reflexion 0.3.5 → 0.3.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0d6d1b028ab65bd561deb01b032b0fc7ddb1d633f493fecf9c9407bc8321f568
-  data.tar.gz: 32f3da5338572a0ce044d64e7c8474f73dbb3d99d0813f86aa1ca0194a18e4c3
+  metadata.gz: 3520640328cfb50b658b9010aa67ea46133947fe974e2a53652f5279a387629d
+  data.tar.gz: 241019eb81187280e520610adbc0626eb3336e2201ed3c6be71026e828e412c7
 SHA512:
-  metadata.gz: 6f44899a6ae5eaadd962a62c18c1d1dc1d70c5bdf5f09a71fa68ac829c318853a492e390188e7100391255a53b9f84276028d7038b31a5cd5b4b7b57a38bb715
-  data.tar.gz: 3dec2aa1ec50884e538b19b46066737cf6cdd3943fba0c4918e388d7be64d75dd4bab0dbd4c7a27989c197428ebcc0e6c093f76697dc1d83ef8ff4385c9b9d9d
+  metadata.gz: 5eabad841c91594992c6bd852e53a18aaa53c5d5f0f46e4df2cfcf921f31cf2a82a8509ed9431e148b4e209f25eaf30f3ccc75dd5bedaa12db03ab3cb9d98bf9
+  data.tar.gz: a927541d68a6df779112af64db8e5da871ce814638e40a9d9b392f2379e8610fbcae2d54857599d603f119971558d2a3ccf71ede3974bff968477d3d092b819d

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

@@ -81,6 +81,20 @@ VALUE on_quit(VALUE self, VALUE event)
 	CALL(on_quit(to<Reflex::Event*>(event)));
 }
 
+static
+VALUE on_device_connect(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_device_connect(to<Reflex::DeviceEvent*>(event)));
+}
+
+static
+VALUE on_device_disconnect(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_device_disconnect(to<Reflex::DeviceEvent*>(event)));
+}
+
 static
 VALUE on_motion(VALUE self, VALUE event)
 {
@@ -125,6 +139,8 @@ Init_reflex_application ()
 	rb_define_method(cApplication, "each_window", RUBY_METHOD_FUNC(each_window), 0);
 	rb_define_method(cApplication, "on_start", RUBY_METHOD_FUNC(on_start), 1);
 	rb_define_method(cApplication, "on_quit", RUBY_METHOD_FUNC(on_quit), 1);
+	rb_define_method(cApplication, "on_device_connect", RUBY_METHOD_FUNC(on_device_connect), 1);
+	rb_define_method(cApplication, "on_device_disconnect", RUBY_METHOD_FUNC(on_device_disconnect), 1);
 	rb_define_method(cApplication, "on_motion", RUBY_METHOD_FUNC(on_motion), 1);
 	rb_define_method(cApplication, "on_preference", RUBY_METHOD_FUNC(on_preference), 1);
 	rb_define_method(cApplication, "on_about", RUBY_METHOD_FUNC(on_about), 1);

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

@@ -1,19 +1,62 @@
-#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
+VALUE alloc(VALUE klass)
+{
+	Reflex::reflex_error(__FILE__, __LINE__, "can not instantiate Device class.");
+}
+
+static
+VALUE name(VALUE self)
+{
+	CHECK;
+	return value(THIS->name());
+}
+
+
 static
-VALUE vibrate(VALUE self)
+VALUE s_vibrate(VALUE self)
 {
 	Reflex::vibrate();
 	return self;
 }
 
 
+static Class cDevice;
+
 void
 Init_reflex_device ()
 {
 	Module mReflex = rb_define_module("Reflex");
 
-	rb_define_singleton_method(mReflex, "vibrate", RUBY_METHOD_FUNC(vibrate), 0);
+	cDevice = mReflex.define_class("Device", Reflex::device_class());
+	rb_define_alloc_func(cDevice, alloc);
+	rb_define_method(cDevice, "name", RUBY_METHOD_FUNC(name), 0);
+
+	rb_define_singleton_method(mReflex, "vibrate", RUBY_METHOD_FUNC(s_vibrate), 0);
 }
+
+
+namespace Reflex
+{
+
+
+	Class
+	device_class ()
+	{
+		return cDevice;
+	}
+
+
+}// Reflex

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

@@ -0,0 +1,62 @@
+#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
+VALUE alloc(VALUE klass)
+{
+	return new_type<Reflex::DeviceEvent>(klass);
+}
+
+static
+VALUE initialize_copy(VALUE self, VALUE obj)
+{
+	CHECK;
+	*THIS = to<Reflex::DeviceEvent&>(obj).dup();
+	return self;
+}
+
+static
+VALUE get_device(VALUE self)
+{
+	CHECK;
+	return value(THIS->device());
+}
+
+
+static Class cDeviceEvent;
+
+void
+Init_reflex_device_event ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cDeviceEvent = mReflex.define_class("DeviceEvent", Reflex::event_class());
+	rb_define_alloc_func(cDeviceEvent, alloc);
+	rb_define_private_method(cDeviceEvent, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
+	rb_define_method(cDeviceEvent, "device", RUBY_METHOD_FUNC(get_device), 0);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	device_event_class ()
+	{
+		return cDeviceEvent;
+	}
+
+
+}// Reflex

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

@@ -256,25 +256,55 @@ VALUE get_key(VALUE self)
 		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/.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

@@ -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/.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;
 
@@ -259,16 +280,17 @@ Init_reflex ()
 	DEFINE_CONST(KEY_GAMEPAD_X);
 	DEFINE_CONST(KEY_GAMEPAD_Y);
 
-	DEFINE_CONST(KEY_GAMEPAD_SHOULDER_LEFT);
-	DEFINE_CONST(KEY_GAMEPAD_SHOULDER_RIGHT);
-	DEFINE_CONST(KEY_GAMEPAD_TRIGGER_LEFT);
-	DEFINE_CONST(KEY_GAMEPAD_TRIGGER_RIGHT);
-	DEFINE_CONST(KEY_GAMEPAD_THUMB_LEFT);
-	DEFINE_CONST(KEY_GAMEPAD_THUMB_RIGHT);
+	DEFINE_CONST(KEY_GAMEPAD_LSHOULDER);
+	DEFINE_CONST(KEY_GAMEPAD_RSHOULDER);
+	DEFINE_CONST(KEY_GAMEPAD_LTRIGGER);
+	DEFINE_CONST(KEY_GAMEPAD_RTRIGGER);
+	DEFINE_CONST(KEY_GAMEPAD_LTHUMB);
+	DEFINE_CONST(KEY_GAMEPAD_RTHUMB);
 
 	DEFINE_CONST(KEY_GAMEPAD_HOME);
 	DEFINE_CONST(KEY_GAMEPAD_MENU);
 	DEFINE_CONST(KEY_GAMEPAD_OPTION);
+	DEFINE_CONST(KEY_GAMEPAD_SHARE);
 	DEFINE_CONST(KEY_GAMEPAD_START);
 	DEFINE_CONST(KEY_GAMEPAD_SELECT);
 

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);