reflexion 0.3.8.1 → 0.3.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 426bd478562126bba0a70a156d12aa361518d78be46a92bc98ab8bcc537df788
-  data.tar.gz: 42c84def0974236fd1c7998087775e18142736b891828ef0a2529638249904f4
+  metadata.gz: acfb751a36e79b634057dfb05f148c4f079ebef32b4e3bacdedb90ce1eed3ae2
+  data.tar.gz: 523645a844af1565fdc07e9858188cb97400ae6886c2c948b10a6946838f3e3b
 SHA512:
-  metadata.gz: 164313bfe16c3407ebe1649006337092ff6496742b50bef5e130396558a9ea72fbd30347922e4a60d2828d2d41a1ff2a2a2b1f5679001715d24e7acf4c73ace8
-  data.tar.gz: 9e034593dd3d2e034ea3b0ba199b1febc96a8fae774a24107743f69332b8e747c45644d218c99689f0e334be342fce438a6c35e5037aa8e7f34d402ddc0679b3
+  metadata.gz: 10fb64e33a6332c6c083e8f1e2a9b902e475e86574cc7371b45b9a768c58a05c58c9caba69256c11be9d453e5b0811409c01484f9bc54f8834a0d1a5ba88b131
+  data.tar.gz: 8d2bed2ea3d72b67132e828687b139012739295192ec1b23d318d12bf7ee0b5a7e803a55c2b95fa2dcd105781c7a6ddfeabe59d4d701fb0b32edf3f725e6869d

data/.doc/ext/reflex/control_change_event.cpp

@@ -0,0 +1,101 @@
+#include "reflex/ruby/event.h"
+
+
+#include "defs.h"
+
+
+RUCY_DEFINE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::ControlChangeEvent)
+
+#define THIS  to<Reflex::ControlChangeEvent*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Reflex::ControlChangeEvent, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return new_type<Reflex::ControlChangeEvent>(klass);
+}
+
+static
+VALUE initialize(VALUE self, VALUE channel, VALUE controller, VALUE value, VALUE time)
+{
+	CHECK;
+
+	*THIS = Reflex::ControlChangeEvent(
+		to<int>(channel),
+		to<int>(controller),
+		to<float>(value),
+		to<double>(time));
+
+	return rb_call_super(0, NULL);
+}
+
+static
+VALUE initialize_copy(VALUE self, VALUE obj)
+{
+	CHECK;
+	*THIS = to<Reflex::ControlChangeEvent&>(obj).dup();
+	return self;
+}
+
+static
+VALUE get_channel(VALUE self)
+{
+	CHECK;
+	return value(THIS->channel());
+}
+
+static
+VALUE get_controller(VALUE self)
+{
+	CHECK;
+	return value(THIS->controller());
+}
+
+static
+VALUE get_value(VALUE self)
+{
+	CHECK;
+	return value(THIS->value());
+}
+
+static
+VALUE is_captured(VALUE self)
+{
+	CHECK;
+	return value(THIS->is_captured());
+}
+
+
+static Class cControlChangeEvent;
+
+void
+Init_reflex_control_change_event ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cControlChangeEvent =
+		mReflex.define_class("ControlChangeEvent", Reflex::event_class());
+	rb_define_alloc_func(cControlChangeEvent, alloc);
+	rb_define_private_method(cControlChangeEvent, "initialize", RUBY_METHOD_FUNC(initialize), 4);
+	rb_define_private_method(cControlChangeEvent, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
+	rb_define_method(cControlChangeEvent, "channel", RUBY_METHOD_FUNC(get_channel), 0);
+	rb_define_method(cControlChangeEvent, "controller", RUBY_METHOD_FUNC(get_controller), 0);
+	rb_define_method(cControlChangeEvent, "value", RUBY_METHOD_FUNC(get_value), 0);
+	cControlChangeEvent.define_method("captured?", is_captured);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	control_change_event_class ()
+	{
+		return cControlChangeEvent;
+	}
+
+
+}// Reflex

data/.doc/ext/reflex/midi.cpp

@@ -21,6 +21,13 @@ VALUE alloc(VALUE klass)
 	Reflex::reflex_error(__FILE__, __LINE__, "can not instantiate MIDI class.");
 }
 
+static
+VALUE on_midi(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_midi(to<Reflex::MIDIEvent*>(event)));
+}
+
 static
 VALUE on_note(VALUE self, VALUE event)
 {
@@ -42,6 +49,13 @@ VALUE on_note_off(VALUE self, VALUE event)
 	CALL(on_note_off(to<Reflex::NoteEvent*>(event)));
 }
 
+static
+VALUE on_control_change(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_control_change(to<Reflex::ControlChangeEvent*>(event)));
+}
+
 static
 VALUE s_get_all(VALUE self)
 {
@@ -60,9 +74,11 @@ Init_reflex_midi ()
 
 	cMIDI = mReflex.define_class("MIDI", Reflex::device_class());
 	rb_define_alloc_func(cMIDI, alloc);
+	rb_define_method(cMIDI, "on_midi", RUBY_METHOD_FUNC(on_midi), 1);
 	rb_define_method(cMIDI, "on_note", RUBY_METHOD_FUNC(on_note), 1);
 	rb_define_method(cMIDI, "on_note_on", RUBY_METHOD_FUNC(on_note_on), 1);
 	rb_define_method(cMIDI, "on_note_off", RUBY_METHOD_FUNC(on_note_off), 1);
+	rb_define_method(cMIDI, "on_control_change", RUBY_METHOD_FUNC(on_control_change), 1);
 
 	rb_define_singleton_method(cMIDI, "all", RUBY_METHOD_FUNC(s_get_all), 0);
 }

data/.doc/ext/reflex/midi_event.cpp

@@ -0,0 +1,124 @@
+#include "reflex/ruby/event.h"
+
+
+#include "reflex/ruby/midi.h"
+#include "defs.h"
+
+
+RUCY_DEFINE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::MIDIEvent)
+
+#define THIS  to<Reflex::MIDIEvent*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Reflex::MIDIEvent, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return new_type<Reflex::MIDIEvent>(klass);
+}
+
+static
+VALUE initialize(VALUE self, VALUE midi, VALUE byte0, VALUE byte1, VALUE byte2, VALUE time)
+{
+	CHECK;
+
+	uchar bytes[3] =
+	{
+		to<uchar>(byte0),
+		to<uchar>(byte1),
+		to<uchar>(byte2)
+	};
+	*THIS = Reflex::MIDIEvent(
+		midi ? to<Reflex::MIDI*>(midi) : NULL,
+		bytes,
+		to<double>(time));
+
+	return rb_call_super(0, NULL);
+}
+
+static
+VALUE initialize_copy(VALUE self, VALUE obj)
+{
+	CHECK;
+	*THIS = to<Reflex::MIDIEvent&>(obj).dup();
+	return self;
+}
+
+static
+VALUE get_action(VALUE self)
+{
+	CHECK;
+	return value(THIS->action());
+}
+
+static
+VALUE get_channel(VALUE self)
+{
+	CHECK;
+	return value(THIS->channel());
+}
+
+static
+VALUE get_data1(VALUE self)
+{
+	CHECK;
+	return value(THIS->data1());
+}
+
+static
+VALUE get_data2(VALUE self)
+{
+	CHECK;
+	return value(THIS->data2());
+}
+
+static
+VALUE is_captured(VALUE self)
+{
+	CHECK;
+	return value(THIS->is_captured());
+}
+
+
+static Class cMIDIEvent;
+
+void
+Init_reflex_midi_event ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cMIDIEvent = mReflex.define_class("MIDIEvent", Reflex::event_class());
+	rb_define_alloc_func(cMIDIEvent, alloc);
+	rb_define_private_method(cMIDIEvent, "initialize", RUBY_METHOD_FUNC(initialize), 5);
+	rb_define_private_method(cMIDIEvent, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
+	rb_define_method(cMIDIEvent, "action", RUBY_METHOD_FUNC(get_action), 0);
+	rb_define_method(cMIDIEvent, "channel", RUBY_METHOD_FUNC(get_channel), 0);
+	rb_define_method(cMIDIEvent, "data1", RUBY_METHOD_FUNC(get_data1), 0);
+	rb_define_method(cMIDIEvent, "data2", RUBY_METHOD_FUNC(get_data2), 0);
+	cMIDIEvent.define_method("captured?", is_captured);
+
+	cMIDIEvent.define_const("ACTION_NONE",       Reflex::MIDIEvent::ACTION_NONE);
+	cMIDIEvent.define_const("NOTE_ON",           Reflex::MIDIEvent::NOTE_ON);
+	cMIDIEvent.define_const("NOTE_OFF",          Reflex::MIDIEvent::NOTE_OFF);
+	cMIDIEvent.define_const("CONTROL_CHANGE",    Reflex::MIDIEvent::CONTROL_CHANGE);
+	cMIDIEvent.define_const("PROGRAM_CHANGE",    Reflex::MIDIEvent::PROGRAM_CHANGE);
+	cMIDIEvent.define_const("CHANNEL_PRESSURE",  Reflex::MIDIEvent::CHANNEL_PRESSURE);
+	cMIDIEvent.define_const("KEY_PRESSURE",      Reflex::MIDIEvent::KEY_PRESSURE);
+	cMIDIEvent.define_const("PITCH_BEND_CHANGE", Reflex::MIDIEvent::PITCH_BEND_CHANGE);
+	cMIDIEvent.define_const("SYSTEM",            Reflex::MIDIEvent::SYSTEM);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	midi_event_class ()
+	{
+		return cMIDIEvent;
+	}
+
+
+}// Reflex

data/.doc/ext/reflex/native.cpp

@@ -21,7 +21,9 @@ void Init_reflex_focus_event ();
 void Init_reflex_key_event ();
 void Init_reflex_pointer_event ();
 void Init_reflex_wheel_event ();
+void Init_reflex_midi_event ();
 void Init_reflex_note_event ();
+void Init_reflex_control_change_event ();
 void Init_reflex_capture_event ();
 void Init_reflex_timer_event ();
 void Init_reflex_contact_event ();
@@ -75,7 +77,9 @@ extern "C" void
 	Init_reflex_key_event();
 	Init_reflex_pointer_event();
 	Init_reflex_wheel_event();
+	Init_reflex_midi_event();
 	Init_reflex_note_event();
+	Init_reflex_control_change_event();
 	Init_reflex_capture_event();
 	Init_reflex_timer_event();
 	Init_reflex_contact_event();

data/.doc/ext/reflex/view.cpp

@@ -1040,6 +1040,41 @@ VALUE on_wheel(VALUE self, VALUE event)
 	CALL(on_wheel(to<Reflex::WheelEvent*>(event)));
 }
 
+static
+VALUE on_midi(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_midi(to<Reflex::MIDIEvent*>(event)));
+}
+
+static
+VALUE on_note(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_note(to<Reflex::NoteEvent*>(event)));
+}
+
+static
+VALUE on_note_on(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_note_on(to<Reflex::NoteEvent*>(event)));
+}
+
+static
+VALUE on_note_off(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_note_off(to<Reflex::NoteEvent*>(event)));
+}
+
+static
+VALUE on_control_change(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_control_change(to<Reflex::ControlChangeEvent*>(event)));
+}
+
 static
 VALUE on_capture(VALUE self, VALUE event)
 {
@@ -1215,6 +1250,11 @@ Init_reflex_view ()
 	rb_define_method(cView, "on_pointer_move", RUBY_METHOD_FUNC(on_pointer_move), 1);
 	rb_define_method(cView, "on_pointer_cancel", RUBY_METHOD_FUNC(on_pointer_cancel), 1);
 	rb_define_method(cView, "on_wheel", RUBY_METHOD_FUNC(on_wheel), 1);
+	rb_define_method(cView, "on_midi", RUBY_METHOD_FUNC(on_midi), 1);
+	rb_define_method(cView, "on_note", RUBY_METHOD_FUNC(on_note), 1);
+	rb_define_method(cView, "on_note_on", RUBY_METHOD_FUNC(on_note_on), 1);
+	rb_define_method(cView, "on_note_off", RUBY_METHOD_FUNC(on_note_off), 1);
+	rb_define_method(cView, "on_control_change", RUBY_METHOD_FUNC(on_control_change), 1);
 	rb_define_method(cView, "on_capture", RUBY_METHOD_FUNC(on_capture), 1);
 	rb_define_method(cView, "on_timer", RUBY_METHOD_FUNC(on_timer), 1);
 	cView.define_method(        "will_contact?",     will_contact);
@@ -1225,7 +1265,7 @@ Init_reflex_view ()
 	cView.define_const("CAPTURE_NONE",    Reflex::View::CAPTURE_NONE);
 	cView.define_const("CAPTURE_KEY",     Reflex::View::CAPTURE_KEY);
 	cView.define_const("CAPTURE_POINTER", Reflex::View::CAPTURE_POINTER);
-	cView.define_const("CAPTURE_NOTE",    Reflex::View::CAPTURE_NOTE);
+	cView.define_const("CAPTURE_MIDI",    Reflex::View::CAPTURE_MIDI);
 	cView.define_const("CAPTURE_ALL",     Reflex::View::CAPTURE_ALL);
 
 	define_selector_methods<Reflex::View>(cView);

data/.doc/ext/reflex/window.cpp

@@ -369,6 +369,13 @@ VALUE on_wheel(VALUE self, VALUE event)
 	CALL(on_wheel(to<Reflex::WheelEvent*>(event)));
 }
 
+static
+VALUE on_midi(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_midi(to<Reflex::MIDIEvent*>(event)));
+}
+
 static
 VALUE on_note(VALUE self, VALUE event)
 {
@@ -390,6 +397,13 @@ VALUE on_note_off(VALUE self, VALUE event)
 	CALL(on_note_off(to<Reflex::NoteEvent*>(event)));
 }
 
+static
+VALUE on_control_change(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_control_change(to<Reflex::ControlChangeEvent*>(event)));
+}
+
 
 static Class cWindow;
 
@@ -443,9 +457,11 @@ Init_reflex_window ()
 	rb_define_method(cWindow, "on_pointer_move", RUBY_METHOD_FUNC(on_pointer_move), 1);
 	rb_define_method(cWindow, "on_pointer_cancel", RUBY_METHOD_FUNC(on_pointer_cancel), 1);
 	rb_define_method(cWindow, "on_wheel", RUBY_METHOD_FUNC(on_wheel), 1);
+	rb_define_method(cWindow, "on_midi", RUBY_METHOD_FUNC(on_midi), 1);
 	rb_define_method(cWindow, "on_note", RUBY_METHOD_FUNC(on_note), 1);
 	rb_define_method(cWindow, "on_note_on", RUBY_METHOD_FUNC(on_note_on), 1);
 	rb_define_method(cWindow, "on_note_off", RUBY_METHOD_FUNC(on_note_off), 1);
+	rb_define_method(cWindow, "on_control_change", RUBY_METHOD_FUNC(on_control_change), 1);
 
 	cWindow.define_const("ORIENTATION_PORTRAIT",  Reflex::Window::FLAG_PORTRAIT);
 	cWindow.define_const("ORIENTATION_LANDSCAPE", Reflex::Window::FLAG_LANDSCAPE);

data/ChangeLog.md

@@ -1,6 +1,13 @@
 # reflex ChangeLog
 
 
+## [v0.3.9] - 2025-05-22
+
+- Add MIDIEvent class and on_midi() event handler
+- Add ControlChangeEvent and on_control_change() event handler
+- Replace capture type from CAPTURE_NOTE to CAPTURE_MIDI
+
+
 ## [v0.3.8.1] - 2025-05-13
 
 - Fix a crash that occasionally occurred at startup when a MIDI device was connected

data/VERSION

@@ -1 +1 @@
-0.3.8.1
+0.3.9

data/ext/reflex/control_change_event.cpp

@@ -0,0 +1,108 @@
+#include "reflex/ruby/event.h"
+
+
+#include "defs.h"
+
+
+RUCY_DEFINE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::ControlChangeEvent)
+
+#define THIS  to<Reflex::ControlChangeEvent*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Reflex::ControlChangeEvent, self)
+
+
+static
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return new_type<Reflex::ControlChangeEvent>(klass);
+}
+RUCY_END
+
+static
+RUCY_DEF4(initialize, channel, controller, value, time)
+{
+	CHECK;
+
+	*THIS = Reflex::ControlChangeEvent(
+		to<int>(channel),
+		to<int>(controller),
+		to<float>(value),
+		to<double>(time));
+
+	return rb_call_super(0, NULL);
+}
+RUCY_END
+
+static
+RUCY_DEF1(initialize_copy, obj)
+{
+	CHECK;
+	*THIS = to<Reflex::ControlChangeEvent&>(obj).dup();
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_channel)
+{
+	CHECK;
+	return value(THIS->channel());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_controller)
+{
+	CHECK;
+	return value(THIS->controller());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_value)
+{
+	CHECK;
+	return value(THIS->value());
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_captured)
+{
+	CHECK;
+	return value(THIS->is_captured());
+}
+RUCY_END
+
+
+static Class cControlChangeEvent;
+
+void
+Init_reflex_control_change_event ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cControlChangeEvent =
+		mReflex.define_class("ControlChangeEvent", Reflex::event_class());
+	cControlChangeEvent.define_alloc_func(alloc);
+	cControlChangeEvent.define_private_method("initialize",      initialize);
+	cControlChangeEvent.define_private_method("initialize_copy", initialize_copy);
+	cControlChangeEvent.define_method("channel",    get_channel);
+	cControlChangeEvent.define_method("controller", get_controller);
+	cControlChangeEvent.define_method("value",      get_value);
+	cControlChangeEvent.define_method("captured?", is_captured);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	control_change_event_class ()
+	{
+		return cControlChangeEvent;
+	}
+
+
+}// Reflex

data/ext/reflex/midi.cpp

@@ -22,6 +22,14 @@ RUCY_DEF_ALLOC(alloc, klass)
 }
 RUCY_END
 
+static
+RUCY_DEF1(on_midi, event)
+{
+	CHECK;
+	CALL(on_midi(to<Reflex::MIDIEvent*>(event)));
+}
+RUCY_END
+
 static
 RUCY_DEF1(on_note, event)
 {
@@ -46,6 +54,14 @@ RUCY_DEF1(on_note_off, event)
 }
 RUCY_END
 
+static
+RUCY_DEF1(on_control_change, event)
+{
+	CHECK;
+	CALL(on_control_change(to<Reflex::ControlChangeEvent*>(event)));
+}
+RUCY_END
+
 static
 RUCY_DEF0(s_get_all)
 {
@@ -65,9 +81,11 @@ Init_reflex_midi ()
 
 	cMIDI = mReflex.define_class("MIDI", Reflex::device_class());
 	cMIDI.define_alloc_func(alloc);
-	cMIDI.define_method("on_note",     on_note);
-	cMIDI.define_method("on_note_on",  on_note_on);
-	cMIDI.define_method("on_note_off", on_note_off);
+	cMIDI.define_method("on_midi",           on_midi);
+	cMIDI.define_method("on_note",           on_note);
+	cMIDI.define_method("on_note_on",        on_note_on);
+	cMIDI.define_method("on_note_off",       on_note_off);
+	cMIDI.define_method("on_control_change", on_control_change);
 
 	cMIDI.define_singleton_method("all", s_get_all);
 }

data/ext/reflex/midi_event.cpp

@@ -0,0 +1,132 @@
+#include "reflex/ruby/event.h"
+
+
+#include "reflex/ruby/midi.h"
+#include "defs.h"
+
+
+RUCY_DEFINE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::MIDIEvent)
+
+#define THIS  to<Reflex::MIDIEvent*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Reflex::MIDIEvent, self)
+
+
+static
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return new_type<Reflex::MIDIEvent>(klass);
+}
+RUCY_END
+
+static
+RUCY_DEF5(initialize, midi, byte0, byte1, byte2, time)
+{
+	CHECK;
+
+	uchar bytes[3] =
+	{
+		to<uchar>(byte0),
+		to<uchar>(byte1),
+		to<uchar>(byte2)
+	};
+	*THIS = Reflex::MIDIEvent(
+		midi ? to<Reflex::MIDI*>(midi) : NULL,
+		bytes,
+		to<double>(time));
+
+	return rb_call_super(0, NULL);
+}
+RUCY_END
+
+static
+RUCY_DEF1(initialize_copy, obj)
+{
+	CHECK;
+	*THIS = to<Reflex::MIDIEvent&>(obj).dup();
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_action)
+{
+	CHECK;
+	return value(THIS->action());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_channel)
+{
+	CHECK;
+	return value(THIS->channel());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_data1)
+{
+	CHECK;
+	return value(THIS->data1());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_data2)
+{
+	CHECK;
+	return value(THIS->data2());
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_captured)
+{
+	CHECK;
+	return value(THIS->is_captured());
+}
+RUCY_END
+
+
+static Class cMIDIEvent;
+
+void
+Init_reflex_midi_event ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cMIDIEvent = mReflex.define_class("MIDIEvent", Reflex::event_class());
+	cMIDIEvent.define_alloc_func(alloc);
+	cMIDIEvent.define_private_method("initialize",      initialize);
+	cMIDIEvent.define_private_method("initialize_copy", initialize_copy);
+	cMIDIEvent.define_method("action",    get_action);
+	cMIDIEvent.define_method("channel",   get_channel);
+	cMIDIEvent.define_method("data1",     get_data1);
+	cMIDIEvent.define_method("data2",     get_data2);
+	cMIDIEvent.define_method("captured?", is_captured);
+
+	cMIDIEvent.define_const("ACTION_NONE",       Reflex::MIDIEvent::ACTION_NONE);
+	cMIDIEvent.define_const("NOTE_ON",           Reflex::MIDIEvent::NOTE_ON);
+	cMIDIEvent.define_const("NOTE_OFF",          Reflex::MIDIEvent::NOTE_OFF);
+	cMIDIEvent.define_const("CONTROL_CHANGE",    Reflex::MIDIEvent::CONTROL_CHANGE);
+	cMIDIEvent.define_const("PROGRAM_CHANGE",    Reflex::MIDIEvent::PROGRAM_CHANGE);
+	cMIDIEvent.define_const("CHANNEL_PRESSURE",  Reflex::MIDIEvent::CHANNEL_PRESSURE);
+	cMIDIEvent.define_const("KEY_PRESSURE",      Reflex::MIDIEvent::KEY_PRESSURE);
+	cMIDIEvent.define_const("PITCH_BEND_CHANGE", Reflex::MIDIEvent::PITCH_BEND_CHANGE);
+	cMIDIEvent.define_const("SYSTEM",            Reflex::MIDIEvent::SYSTEM);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	midi_event_class ()
+	{
+		return cMIDIEvent;
+	}
+
+
+}// Reflex