reflexion 0.3.5 → 0.3.7

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

@@ -369,6 +369,27 @@ VALUE on_wheel(VALUE self, VALUE event)
 	CALL(on_wheel(to<Reflex::WheelEvent*>(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 Class cWindow;
 
@@ -422,6 +443,9 @@ 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_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);
 
 	cWindow.define_const("ORIENTATION_PORTRAIT",  Reflex::Window::FLAG_PORTRAIT);
 	cWindow.define_const("ORIENTATION_LANDSCAPE", Reflex::Window::FLAG_LANDSCAPE);

data/ChangeLog.md

@@ -1,6 +1,22 @@
 # reflex ChangeLog
 
 
+## [v0.3.7] - 2025-05-11
+
+- Add MIDI class
+- Add NoteEvent class and on_note and on_note_on/off event handlers
+- Add reflex/test/test_note_event.rb
+- KeyEvent can take 'time' parameter
+
+
+## [v0.3.6] - 2025-04-08
+
+- Add Gamepad class
+- Add Device and DeviceEvent classes
+- Add Application#on_device_connect/disconnect
+- Add Application_call_start() and Application_call_quit()
+
+
 ## [v0.3.5] - 2025-03-24
 
 - Add PULL_REQUEST_TEMPLATE.md

data/Rakefile

@@ -21,6 +21,13 @@ use_external_library 'https://github.com/erincatto/box2d',
   incdirs: %w[include src],
   srcdirs: 'src'
 
+use_external_library 'https://github.com/thestk/rtmidi',
+  tag:     '6.0.0',
+  incdirs: 'rtmidi',
+  srcdirs: 'rtmidi',
+  defs:    '__MACOSX_CORE__',
+  &proc {sh %( mkdir rtmidi && cp RtMidi.* rtmidi )}
+
 default_tasks :ext
 use_bundler
 build_native_library

data/VERSION

@@ -1 +1 @@
-0.3.5
+0.3.7

data/ext/reflex/application.cpp

@@ -89,6 +89,22 @@ RUCY_DEF1(on_quit, event)
 }
 RUCY_END
 
+static
+RUCY_DEF1(on_device_connect, event)
+{
+	CHECK;
+	CALL(on_device_connect(to<Reflex::DeviceEvent*>(event)));
+}
+RUCY_END
+
+static
+RUCY_DEF1(on_device_disconnect, event)
+{
+	CHECK;
+	CALL(on_device_disconnect(to<Reflex::DeviceEvent*>(event)));
+}
+RUCY_END
+
 static
 RUCY_DEF1(on_motion, event)
 {
@@ -137,6 +153,8 @@ Init_reflex_application ()
 	cApplication.define_method("each_window", each_window);
 	cApplication.define_method("on_start", on_start);
 	cApplication.define_method("on_quit",  on_quit);
+	cApplication.define_method("on_device_connect",    on_device_connect);
+	cApplication.define_method("on_device_disconnect", on_device_disconnect);
 	cApplication.define_method("on_motion", on_motion);
 	cApplication.define_method("on_preference", on_preference);
 	cApplication.define_method("on_about",      on_about);

data/ext/reflex/device.cpp

@@ -1,9 +1,34 @@
-#include "reflex/device.h"
+#include "reflex/ruby/device.h"
+
+
 #include "defs.h"
 
 
+RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::Device)
+
+#define THIS  to<Reflex::Device*>(self)
+
+#define CHECK RUCY_CHECK_OBJECT(Reflex::Device, self)
+
+
+static
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	Reflex::reflex_error(__FILE__, __LINE__, "can not instantiate Device class.");
+}
+RUCY_END
+
+static
+RUCY_DEF0(name)
+{
+	CHECK;
+	return value(THIS->name());
+}
+RUCY_END
+
+
 static
-RUCY_DEF0(vibrate)
+RUCY_DEF0(s_vibrate)
 {
 	Reflex::vibrate();
 	return self;
@@ -11,10 +36,30 @@ RUCY_DEF0(vibrate)
 RUCY_END
 
 
+static Class cDevice;
+
 void
 Init_reflex_device ()
 {
 	Module mReflex = define_module("Reflex");
 
-	mReflex.define_singleton_method("vibrate", vibrate);
+	cDevice = mReflex.define_class("Device", Reflex::device_class());
+	cDevice.define_alloc_func(alloc);
+	cDevice.define_method("name", name);
+
+	mReflex.define_singleton_method("vibrate", s_vibrate);
 }
+
+
+namespace Reflex
+{
+
+
+	Class
+	device_class ()
+	{
+		return cDevice;
+	}
+
+
+}// Reflex

data/ext/reflex/device_event.cpp

@@ -0,0 +1,65 @@
+#include "reflex/ruby/event.h"
+
+
+#include "reflex/ruby/device.h"
+#include "defs.h"
+
+
+RUCY_DEFINE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::DeviceEvent)
+
+#define THIS  to<Reflex::DeviceEvent*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Reflex::DeviceEvent, self)
+
+
+static
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return new_type<Reflex::DeviceEvent>(klass);
+}
+RUCY_END
+
+static
+RUCY_DEF1(initialize_copy, obj)
+{
+	CHECK;
+	*THIS = to<Reflex::DeviceEvent&>(obj).dup();
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_device)
+{
+	CHECK;
+	return value(THIS->device());
+}
+RUCY_END
+
+
+static Class cDeviceEvent;
+
+void
+Init_reflex_device_event ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cDeviceEvent = mReflex.define_class("DeviceEvent", Reflex::event_class());
+	cDeviceEvent.define_alloc_func(alloc);
+	cDeviceEvent.define_private_method("initialize_copy", initialize_copy);
+	cDeviceEvent.define_method("device", get_device);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	device_event_class ()
+	{
+		return cDeviceEvent;
+	}
+
+
+}// Reflex

data/ext/reflex/key_event.cpp

@@ -260,25 +260,55 @@ RUCY_DEF0(get_key)
 		CASE(LAUNCH_APP1):         SYMBOL1(launch_app1);
 		CASE(LAUNCH_APP2):         SYMBOL1(launch_app2);
 
-		CASE(GAMEPAD_LEFT):           SYMBOL1(gamepad_left);
-		CASE(GAMEPAD_RIGHT):          SYMBOL1(gamepad_right);
-		CASE(GAMEPAD_UP):             SYMBOL1(gamepad_up);
-		CASE(GAMEPAD_DOWN):           SYMBOL1(gamepad_down);
-		CASE(GAMEPAD_A):              SYMBOL1(gamepad_a);
-		CASE(GAMEPAD_B):              SYMBOL1(gamepad_b);
-		CASE(GAMEPAD_X):              SYMBOL1(gamepad_x);
-		CASE(GAMEPAD_Y):              SYMBOL1(gamepad_y);
-		CASE(GAMEPAD_TRIGGER_LEFT):   SYMBOL1(gamepad_trigger_left);
-		CASE(GAMEPAD_TRIGGER_RIGHT):  SYMBOL1(gamepad_trigger_right);
-		CASE(GAMEPAD_SHOULDER_LEFT):  SYMBOL1(gamepad_shoulder_left);
-		CASE(GAMEPAD_SHOULDER_RIGHT): SYMBOL1(gamepad_shoulder_right);
-		CASE(GAMEPAD_THUMB_LEFT):     SYMBOL1(gamepad_thumb_left);
-		CASE(GAMEPAD_THUMB_RIGHT):    SYMBOL1(gamepad_thumb_right);
-		CASE(GAMEPAD_HOME):           SYMBOL1(gamepad_home);
-		CASE(GAMEPAD_MENU):           SYMBOL1(gamepad_menu);
-		CASE(GAMEPAD_OPTION):         SYMBOL1(gamepad_option);
-		CASE(GAMEPAD_START):          SYMBOL1(gamepad_start);
-		CASE(GAMEPAD_SELECT):         SYMBOL1(gamepad_select);
+		CASE(GAMEPAD_LEFT):         SYMBOL1(gamepad_left);
+		CASE(GAMEPAD_RIGHT):        SYMBOL1(gamepad_right);
+		CASE(GAMEPAD_UP):           SYMBOL1(gamepad_up);
+		CASE(GAMEPAD_DOWN):         SYMBOL1(gamepad_down);
+		CASE(GAMEPAD_LSTICK_LEFT):  SYMBOL1(gamepad_lstick_left);
+		CASE(GAMEPAD_LSTICK_RIGHT): SYMBOL1(gamepad_lstick_right);
+		CASE(GAMEPAD_LSTICK_UP):    SYMBOL1(gamepad_lstick_up);
+		CASE(GAMEPAD_LSTICK_DOWN):  SYMBOL1(gamepad_lstick_down);
+		CASE(GAMEPAD_RSTICK_LEFT):  SYMBOL1(gamepad_rstick_left);
+		CASE(GAMEPAD_RSTICK_RIGHT): SYMBOL1(gamepad_rstick_right);
+		CASE(GAMEPAD_RSTICK_UP):    SYMBOL1(gamepad_rstick_up);
+		CASE(GAMEPAD_RSTICK_DOWN):  SYMBOL1(gamepad_rstick_down);
+		CASE(GAMEPAD_A):            SYMBOL1(gamepad_a);
+		CASE(GAMEPAD_B):            SYMBOL1(gamepad_b);
+		CASE(GAMEPAD_X):            SYMBOL1(gamepad_x);
+		CASE(GAMEPAD_Y):            SYMBOL1(gamepad_y);
+		CASE(GAMEPAD_LTRIGGER):     SYMBOL1(gamepad_ltrigger);
+		CASE(GAMEPAD_RTRIGGER):     SYMBOL1(gamepad_rtrigger);
+		CASE(GAMEPAD_LSHOULDER):    SYMBOL1(gamepad_lshoulder);
+		CASE(GAMEPAD_RSHOULDER):    SYMBOL1(gamepad_rshoulder);
+		CASE(GAMEPAD_LTHUMB):       SYMBOL1(gamepad_lthumb);
+		CASE(GAMEPAD_RTHUMB):       SYMBOL1(gamepad_rthumb);
+		CASE(GAMEPAD_LPADDLE_0):    SYMBOL1(gamepad_lpaddle_0);
+		CASE(GAMEPAD_LPADDLE_1):    SYMBOL1(gamepad_lpaddle_1);
+		CASE(GAMEPAD_RPADDLE_0):    SYMBOL1(gamepad_rpaddle_0);
+		CASE(GAMEPAD_RPADDLE_1):    SYMBOL1(gamepad_rpaddle_1);
+		CASE(GAMEPAD_HOME):         SYMBOL1(gamepad_home);
+		CASE(GAMEPAD_MENU):         SYMBOL1(gamepad_menu);
+		CASE(GAMEPAD_OPTION):       SYMBOL1(gamepad_option);
+		CASE(GAMEPAD_SHARE):        SYMBOL1(gamepad_share);
+		CASE(GAMEPAD_START):        SYMBOL1(gamepad_start);
+		CASE(GAMEPAD_SELECT):       SYMBOL1(gamepad_select);
+		CASE(GAMEPAD_BUTTON_TOUCH): SYMBOL1(gamepad_button_touch);
+		CASE(GAMEPAD_BUTTON_0):     SYMBOL1(gamepad_button_0);
+		CASE(GAMEPAD_BUTTON_1):     SYMBOL1(gamepad_button_1);
+		CASE(GAMEPAD_BUTTON_2):     SYMBOL1(gamepad_button_2);
+		CASE(GAMEPAD_BUTTON_3):     SYMBOL1(gamepad_button_3);
+		CASE(GAMEPAD_BUTTON_4):     SYMBOL1(gamepad_button_4);
+		CASE(GAMEPAD_BUTTON_5):     SYMBOL1(gamepad_button_5);
+		CASE(GAMEPAD_BUTTON_6):     SYMBOL1(gamepad_button_6);
+		CASE(GAMEPAD_BUTTON_7):     SYMBOL1(gamepad_button_7);
+		CASE(GAMEPAD_BUTTON_8):     SYMBOL1(gamepad_button_8);
+		CASE(GAMEPAD_BUTTON_9):     SYMBOL1(gamepad_button_9);
+		CASE(GAMEPAD_BUTTON_10):    SYMBOL1(gamepad_button_10);
+		CASE(GAMEPAD_BUTTON_11):    SYMBOL1(gamepad_button_11);
+		CASE(GAMEPAD_BUTTON_12):    SYMBOL1(gamepad_button_12);
+		CASE(GAMEPAD_BUTTON_13):    SYMBOL1(gamepad_button_13);
+		CASE(GAMEPAD_BUTTON_14):    SYMBOL1(gamepad_button_14);
+		CASE(GAMEPAD_BUTTON_15):    SYMBOL1(gamepad_button_15);
 
 		#undef CASE
 		#undef SYMBOL1

data/ext/reflex/midi.cpp

@@ -0,0 +1,87 @@
+#include "reflex/ruby/midi.h"
+
+
+#include <ranges>
+#include "reflex/ruby/device.h"
+#include "defs.h"
+
+
+RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::MIDI)
+
+#define THIS      to<Reflex::MIDI*>(self)
+
+#define CHECK     RUCY_CHECK_OBJECT(Reflex::MIDI, self)
+
+#define CALL(fun) RUCY_CALL_SUPER(THIS, fun)
+
+
+static
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	Reflex::reflex_error(__FILE__, __LINE__, "can not instantiate MIDI class.");
+}
+RUCY_END
+
+static
+RUCY_DEF1(on_note, event)
+{
+	CHECK;
+	CALL(on_note(to<Reflex::NoteEvent*>(event)));
+}
+RUCY_END
+
+static
+RUCY_DEF1(on_note_on, event)
+{
+	CHECK;
+	CALL(on_note_on(to<Reflex::NoteEvent*>(event)));
+}
+RUCY_END
+
+static
+RUCY_DEF1(on_note_off, event)
+{
+	CHECK;
+	CALL(on_note_off(to<Reflex::NoteEvent*>(event)));
+}
+RUCY_END
+
+static
+RUCY_DEF0(s_get_all)
+{
+	auto list = Reflex::MIDI::all() |
+		std::views::transform([](auto& ref) {return value(ref);});
+	return array(list.begin(), list.end());
+}
+RUCY_END
+
+
+static Class cMIDI;
+
+void
+Init_reflex_midi ()
+{
+	Module mReflex = define_module("Reflex");
+
+	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_singleton_method("all", s_get_all);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	midi_class ()
+	{
+		return cMIDI;
+	}
+
+
+}// Reflex

data/ext/reflex/native.cpp

@@ -4,6 +4,7 @@
 void Init_reflex ();
 void Init_reflex_exception ();
 
+void Init_reflex_pointer ();
 void Init_reflex_selector ();
 void Init_reflex_style ();
 void Init_reflex_style_length ();
@@ -11,19 +12,20 @@ void Init_reflex_timer ();
 void Init_reflex_filter ();
 
 void Init_reflex_event ();
-void Init_reflex_motion_event ();
+void Init_reflex_device_event ();
 void Init_reflex_update_event ();
 void Init_reflex_draw_event ();
 void Init_reflex_frame_event ();
 void Init_reflex_scroll_event ();
 void Init_reflex_focus_event ();
 void Init_reflex_key_event ();
-void Init_reflex_pointer ();
 void Init_reflex_pointer_event ();
 void Init_reflex_wheel_event ();
+void Init_reflex_note_event ();
 void Init_reflex_capture_event ();
 void Init_reflex_timer_event ();
 void Init_reflex_contact_event ();
+void Init_reflex_motion_event ();
 
 void Init_reflex_shape ();
 void Init_reflex_polygon_shape ();
@@ -37,6 +39,7 @@ void Init_reflex_window ();
 void Init_reflex_view ();
 
 void Init_reflex_device ();
+void Init_reflex_midi ();
 
 void Init_reflex_image_view ();
 
@@ -55,6 +58,7 @@ extern "C" void
 	Init_reflex();
 	Init_reflex_exception();
 
+	Init_reflex_pointer();
 	Init_reflex_selector();
 	Init_reflex_style();
 	Init_reflex_style_length();
@@ -62,19 +66,20 @@ extern "C" void
 	Init_reflex_filter();
 
 	Init_reflex_event();
-	Init_reflex_motion_event();
+	Init_reflex_device_event();
 	Init_reflex_update_event();
 	Init_reflex_draw_event();
 	Init_reflex_frame_event();
 	Init_reflex_scroll_event();
 	Init_reflex_focus_event();
 	Init_reflex_key_event();
-	Init_reflex_pointer();
 	Init_reflex_pointer_event();
 	Init_reflex_wheel_event();
+	Init_reflex_note_event();
 	Init_reflex_capture_event();
 	Init_reflex_timer_event();
 	Init_reflex_contact_event();
+	Init_reflex_motion_event();
 
 	Init_reflex_shape();
 	Init_reflex_polygon_shape();
@@ -88,6 +93,7 @@ extern "C" void
 	Init_reflex_view();
 
 	Init_reflex_device();
+	Init_reflex_midi();
 
 	Init_reflex_image_view();
 

data/ext/reflex/note_event.cpp

@@ -0,0 +1,130 @@
+#include "reflex/ruby/event.h"
+
+
+#include "defs.h"
+
+
+RUCY_DEFINE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::NoteEvent)
+
+#define THIS  to<Reflex::NoteEvent*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Reflex::NoteEvent, self)
+
+
+static
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return new_type<Reflex::NoteEvent>(klass);
+}
+RUCY_END
+
+static
+RUCY_DEF5(initialize, action, channel, note, velocity, time)
+{
+	CHECK;
+
+	*THIS = Reflex::NoteEvent(
+		(Reflex::NoteEvent::Action) to<uint>(action),
+		to<int>(channel),
+		to<int>(note),
+		to<float>(velocity),
+		to<double>(time));
+
+	return rb_call_super(0, NULL);
+}
+RUCY_END
+
+static
+RUCY_DEF1(initialize_copy, obj)
+{
+	CHECK;
+	*THIS = to<Reflex::NoteEvent&>(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_note)
+{
+	CHECK;
+	return value(THIS->note());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_frequency)
+{
+	CHECK;
+	return value(THIS->frequency());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_velocity)
+{
+	CHECK;
+	return value(THIS->velocity());
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_captured)
+{
+	CHECK;
+	return value(THIS->is_captured());
+}
+RUCY_END
+
+
+static Class cNoteEvent;
+
+void
+Init_reflex_note_event ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cNoteEvent = mReflex.define_class("NoteEvent", Reflex::event_class());
+	cNoteEvent.define_alloc_func(alloc);
+	cNoteEvent.define_private_method("initialize",      initialize);
+	cNoteEvent.define_private_method("initialize_copy", initialize_copy);
+	cNoteEvent.define_method("action",    get_action);
+	cNoteEvent.define_method("channel",   get_channel);
+	cNoteEvent.define_method("note",      get_note);
+	cNoteEvent.define_method("frequency", get_frequency);
+	cNoteEvent.define_method("velocity",  get_velocity);
+	cNoteEvent.define_method("captured?", is_captured);
+
+	cNoteEvent.define_const("ACTION_NONE", Reflex::NoteEvent::ACTION_NONE);
+	cNoteEvent.define_const("ON",          Reflex::NoteEvent::ON);
+	cNoteEvent.define_const("OFF",         Reflex::NoteEvent::OFF);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	note_event_class ()
+	{
+		return cNoteEvent;
+	}
+
+
+}// Reflex