reflexion 0.3.6 → 0.3.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6208109e523193e989fd8aab8deb156b0cedac3f2d686104e44dec97c4cc9a5e
-  data.tar.gz: 8b9060b45cd8f0a2603411895d7739f7ba4df40e21d03ab9f78d4e3fbb09133f
+  metadata.gz: 3520640328cfb50b658b9010aa67ea46133947fe974e2a53652f5279a387629d
+  data.tar.gz: 241019eb81187280e520610adbc0626eb3336e2201ed3c6be71026e828e412c7
 SHA512:
-  metadata.gz: e90800b628b22f0b174ba433acfddc5232687408e6845880eed7e898f03e417906f381b7d58c7c01e19dbe7965738f1ee43bf9594a2329c83a97c84ad5f843ec
-  data.tar.gz: fbc4b887c236dce6096fb8ab1ded816da3a4c08a2c5873f2826fc044d02dae123004e9c7d8da3b5999410b906cbaafbd742c07198bae71027ddd80259d25e212
+  metadata.gz: 5eabad841c91594992c6bd852e53a18aaa53c5d5f0f46e4df2cfcf921f31cf2a82a8509ed9431e148b4e209f25eaf30f3ccc75dd5bedaa12db03ab3cb9d98bf9
+  data.tar.gz: a927541d68a6df779112af64db8e5da871ce814638e40a9d9b392f2379e8610fbcae2d54857599d603f119971558d2a3ccf71ede3974bff968477d3d092b819d

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

@@ -0,0 +1,82 @@
+#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
+VALUE alloc(VALUE klass)
+{
+	Reflex::reflex_error(__FILE__, __LINE__, "can not instantiate MIDI class.");
+}
+
+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 s_get_all(VALUE self)
+{
+	auto list = Reflex::MIDI::all() |
+		std::views::transform([](auto& ref) {return value(ref);});
+	return array(list.begin(), list.end());
+}
+
+
+static Class cMIDI;
+
+void
+Init_reflex_midi ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cMIDI = mReflex.define_class("MIDI", Reflex::device_class());
+	rb_define_alloc_func(cMIDI, alloc);
+	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_singleton_method(cMIDI, "all", RUBY_METHOD_FUNC(s_get_all), 0);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	midi_class ()
+	{
+		return cMIDI;
+	}
+
+
+}// Reflex

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

@@ -21,6 +21,7 @@ void Init_reflex_focus_event ();
 void Init_reflex_key_event ();
 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 ();
@@ -38,6 +39,7 @@ void Init_reflex_window ();
 void Init_reflex_view ();
 
 void Init_reflex_device ();
+void Init_reflex_midi ();
 
 void Init_reflex_image_view ();
 
@@ -73,6 +75,7 @@ extern "C" void
 	Init_reflex_key_event();
 	Init_reflex_pointer_event();
 	Init_reflex_wheel_event();
+	Init_reflex_note_event();
 	Init_reflex_capture_event();
 	Init_reflex_timer_event();
 	Init_reflex_contact_event();
@@ -90,6 +93,7 @@ extern "C" void
 	Init_reflex_view();
 
 	Init_reflex_device();
+	Init_reflex_midi();
 
 	Init_reflex_image_view();
 

data/.doc/ext/reflex/note_event.cpp

@@ -0,0 +1,121 @@
+#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
+VALUE alloc(VALUE klass)
+{
+	return new_type<Reflex::NoteEvent>(klass);
+}
+
+static
+VALUE initialize(VALUE self, VALUE action, VALUE channel, VALUE note, VALUE velocity, VALUE 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);
+}
+
+static
+VALUE initialize_copy(VALUE self, VALUE obj)
+{
+	CHECK;
+	*THIS = to<Reflex::NoteEvent&>(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_note(VALUE self)
+{
+	CHECK;
+	return value(THIS->note());
+}
+
+static
+VALUE get_frequency(VALUE self)
+{
+	CHECK;
+	return value(THIS->frequency());
+}
+
+static
+VALUE get_velocity(VALUE self)
+{
+	CHECK;
+	return value(THIS->velocity());
+}
+
+static
+VALUE is_captured(VALUE self)
+{
+	CHECK;
+	return value(THIS->is_captured());
+}
+
+
+static Class cNoteEvent;
+
+void
+Init_reflex_note_event ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cNoteEvent = mReflex.define_class("NoteEvent", Reflex::event_class());
+	rb_define_alloc_func(cNoteEvent, alloc);
+	rb_define_private_method(cNoteEvent, "initialize", RUBY_METHOD_FUNC(initialize), 5);
+	rb_define_private_method(cNoteEvent, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
+	rb_define_method(cNoteEvent, "action", RUBY_METHOD_FUNC(get_action), 0);
+	rb_define_method(cNoteEvent, "channel", RUBY_METHOD_FUNC(get_channel), 0);
+	rb_define_method(cNoteEvent, "note", RUBY_METHOD_FUNC(get_note), 0);
+	rb_define_method(cNoteEvent, "frequency", RUBY_METHOD_FUNC(get_frequency), 0);
+	rb_define_method(cNoteEvent, "velocity", RUBY_METHOD_FUNC(get_velocity), 0);
+	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

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

@@ -3,21 +3,31 @@
 
 #include "reflex/ruby/view.h"
 #include "reflex/ruby/timer.h"
+#include "reflex/ruby/midi.h"
 #include "../../src/window.h"
 #include "../../src/timer.h"
+#include "../../src/midi.h"
 #include "defs.h"
 
 
 static Reflex::View*
 create_root_view ()
 {
-	return new Reflex::RubyView<Reflex::View>;
+	return new Reflex::RubyView<Reflex::View>();
 }
 
 static Reflex::Timer*
 create_timer ()
 {
-	return new Reflex::RubyTimer<Reflex::Timer>;
+	return new Reflex::RubyTimer<Reflex::Timer>();
+}
+
+static Reflex::MIDI*
+create_midi ()
+{
+	Reflex::MIDI* midi = new Reflex::RubyMIDI<Reflex::MIDI>();
+	value(midi);// apply MIDI class to ClassWrapper's value
+	return midi;
 }
 
 
@@ -27,6 +37,7 @@ VALUE init(VALUE self)
 	Reflex::init();
 	Reflex::Window_set_create_root_view_fun(create_root_view);
 	Reflex::Timer_set_create_fun(create_timer);
+	Reflex::MIDI_set_create_fun(create_midi);
 
 	return self;
 }
@@ -36,11 +47,20 @@ VALUE fin(VALUE self)
 {
 	Reflex::Window_set_create_root_view_fun(NULL);
 	Reflex::Timer_set_create_fun(NULL);
+	Reflex::MIDI_set_create_fun(NULL);
 	Reflex::fin();
 
 	return self;
 }
 
+static
+VALUE process_events(VALUE self)
+{
+	Reflex::process_events();
+
+	return self;
+}
+
 
 static Module mReflex;
 
@@ -50,6 +70,7 @@ Init_reflex ()
 	mReflex = rb_define_module("Reflex");
 	mReflex.define_singleton_method("init!", init);
 	mReflex.define_singleton_method("fin!", fin);
+	mReflex.define_singleton_method("process_events!", process_events);
 
 	using namespace Reflex;
 

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

@@ -2,6 +2,7 @@
 
 
 #include <vector>
+#include <ranges>
 #include <rays/ruby/point.h>
 #include <rays/ruby/bounds.h>
 #include <rays/ruby/polygon.h>
@@ -25,16 +26,6 @@ RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::View)
 #define CALL(fun) RUCY_CALL_SUPER(THIS, fun)
 
 
-template <typename T>
-static inline Value
-array (T begin, T end)
-{
-	std::vector<Value> v;
-	for (T it = begin; it != end; ++it) v.push_back(value(*it));
-	return array(&v[0], v.size());
-}
-
-
 static
 VALUE alloc(VALUE klass)
 {
@@ -194,8 +185,9 @@ VALUE find_children(VALUE self)
 
 	bool recursive = (argc >= 2) ? to<bool>(argv[1]) : true;
 
-	Reflex::View::ChildList children =
-		THIS->find_children(to<Reflex::Selector>(argv[0]), recursive);
+	auto children =
+		THIS->find_children(to<Reflex::Selector>(argv[0]), recursive) |
+		std::views::transform([](auto& ref) {return value(ref);});
 	return array(children.begin(), children.end());
 }
 
@@ -249,8 +241,9 @@ VALUE find_styles(VALUE self)
 
 	bool recursive = (argc >= 2) ? to<bool>(argv[1]) : false;
 
-	Reflex::View::StyleList styles =
-		THIS->find_styles(to<Reflex::Selector>(argv[0]), recursive);
+	auto styles =
+		THIS->find_styles(to<Reflex::Selector>(argv[0]), recursive) |
+		std::views::transform([](auto& ref) {return value(ref);});
 	return array(styles.begin(), styles.end());
 }
 
@@ -327,8 +320,9 @@ VALUE find_shapes(VALUE self)
 	CHECK;
 	check_arg_count(__FILE__, __LINE__, "View#find_shapes", argc, 1);
 
-	Reflex::View::ShapeList shapes =
-		THIS->find_shapes(to<Reflex::Selector>(argv[0]));
+	auto shapes =
+		THIS->find_shapes(to<Reflex::Selector>(argv[0])) |
+		std::views::transform([](auto& ref) {return value(ref);});
 	return array(shapes.begin(), shapes.end());
 }
 
@@ -1231,6 +1225,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_ALL",     Reflex::View::CAPTURE_ALL);
 
 	define_selector_methods<Reflex::View>(cView);

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,14 @@
 # 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

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.6
+0.3.7

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

@@ -21,6 +21,7 @@ void Init_reflex_focus_event ();
 void Init_reflex_key_event ();
 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 ();
@@ -38,6 +39,7 @@ void Init_reflex_window ();
 void Init_reflex_view ();
 
 void Init_reflex_device ();
+void Init_reflex_midi ();
 
 void Init_reflex_image_view ();
 
@@ -73,6 +75,7 @@ extern "C" void
 	Init_reflex_key_event();
 	Init_reflex_pointer_event();
 	Init_reflex_wheel_event();
+	Init_reflex_note_event();
 	Init_reflex_capture_event();
 	Init_reflex_timer_event();
 	Init_reflex_contact_event();
@@ -90,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