reflexion 0.3.5 → 0.3.7

data/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 @@ RUCY_DEF0(init)
 	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;
 }
@@ -37,12 +48,22 @@ RUCY_DEF0(fin)
 {
 	Reflex::Window_set_create_root_view_fun(NULL);
 	Reflex::Timer_set_create_fun(NULL);
+	Reflex::MIDI_set_create_fun(NULL);
 	Reflex::fin();
 
 	return self;
 }
 RUCY_END
 
+static
+RUCY_DEF0(process_events)
+{
+	Reflex::process_events();
+
+	return self;
+}
+RUCY_END
+
 
 static Module mReflex;
 
@@ -52,6 +73,7 @@ Init_reflex ()
 	mReflex = 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;
 
@@ -261,16 +283,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/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
 RUCY_DEF_ALLOC(alloc, klass)
 {
@@ -213,8 +204,9 @@ RUCY_DEFN(find_children)
 
 	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());
 }
 RUCY_END
@@ -273,8 +265,9 @@ RUCY_DEFN(find_styles)
 
 	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());
 }
 RUCY_END
@@ -358,8 +351,9 @@ RUCY_DEFN(find_shapes)
 	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());
 }
 RUCY_END
@@ -1352,6 +1346,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/ext/reflex/window.cpp

@@ -413,6 +413,30 @@ RUCY_DEF1(on_wheel, event)
 }
 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 Class cWindow;
 
@@ -466,6 +490,9 @@ Init_reflex_window ()
 	cWindow.define_method("on_pointer_move",   on_pointer_move);
 	cWindow.define_method("on_pointer_cancel", on_pointer_cancel);
 	cWindow.define_method("on_wheel", on_wheel);
+	cWindow.define_method("on_note",     on_note);
+	cWindow.define_method("on_note_on",  on_note_on);
+	cWindow.define_method("on_note_off", on_note_off);
 
 	cWindow.define_const("ORIENTATION_PORTRAIT",  Reflex::Window::FLAG_PORTRAIT);
 	cWindow.define_const("ORIENTATION_LANDSCAPE", Reflex::Window::FLAG_LANDSCAPE);

data/include/reflex/application.h

@@ -53,6 +53,10 @@ namespace Reflex
 
 			virtual void on_quit (Event* e);
 
+			virtual void on_device_connect    (DeviceEvent* e);
+
+			virtual void on_device_disconnect (DeviceEvent* e);
+
 			virtual void on_motion (MotionEvent* e);
 
 			virtual void on_preference (Event* e);

data/include/reflex/defs.h

@@ -278,27 +278,64 @@ namespace Reflex
 		#undef NATIVE_VK
 
 		KEY_GAMEPAD_LEFT  = 0x100,
-		KEY_GAMEPAD_RIGHT = 0x101,
-		KEY_GAMEPAD_UP    = 0x102,
-		KEY_GAMEPAD_DOWN  = 0x103,
-
-		KEY_GAMEPAD_A = 0x104,
-		KEY_GAMEPAD_B = 0x105,
-		KEY_GAMEPAD_X = 0x106,
-		KEY_GAMEPAD_Y = 0x107,
-
-		KEY_GAMEPAD_SHOULDER_LEFT  = 0x108,
-		KEY_GAMEPAD_SHOULDER_RIGHT = 0x109,
-		KEY_GAMEPAD_TRIGGER_LEFT   = 0x10A,
-		KEY_GAMEPAD_TRIGGER_RIGHT  = 0x10B,
-		KEY_GAMEPAD_THUMB_LEFT     = 0x10C,
-		KEY_GAMEPAD_THUMB_RIGHT    = 0x10D,
-
-		KEY_GAMEPAD_HOME   = 0x10E,
-		KEY_GAMEPAD_MENU   = 0x10F,
-		KEY_GAMEPAD_OPTION = 0x110,
-		KEY_GAMEPAD_START  = 0x111,
-		KEY_GAMEPAD_SELECT = 0x112,
+		KEY_GAMEPAD_RIGHT,
+		KEY_GAMEPAD_UP,
+		KEY_GAMEPAD_DOWN,
+
+		KEY_GAMEPAD_LSTICK_LEFT,
+		KEY_GAMEPAD_LSTICK_RIGHT,
+		KEY_GAMEPAD_LSTICK_UP,
+		KEY_GAMEPAD_LSTICK_DOWN,
+
+		KEY_GAMEPAD_RSTICK_LEFT,
+		KEY_GAMEPAD_RSTICK_RIGHT,
+		KEY_GAMEPAD_RSTICK_UP,
+		KEY_GAMEPAD_RSTICK_DOWN,
+
+		KEY_GAMEPAD_A,
+		KEY_GAMEPAD_B,
+		KEY_GAMEPAD_X,
+		KEY_GAMEPAD_Y,
+
+		KEY_GAMEPAD_LSHOULDER,
+		KEY_GAMEPAD_RSHOULDER,
+		KEY_GAMEPAD_LTRIGGER,
+		KEY_GAMEPAD_RTRIGGER,
+		KEY_GAMEPAD_LTHUMB,
+		KEY_GAMEPAD_RTHUMB,
+
+		KEY_GAMEPAD_LPADDLE_0,
+		KEY_GAMEPAD_LPADDLE_1,
+		KEY_GAMEPAD_RPADDLE_0,
+		KEY_GAMEPAD_RPADDLE_1,
+
+		KEY_GAMEPAD_HOME,
+		KEY_GAMEPAD_MENU,
+		KEY_GAMEPAD_OPTION,
+		KEY_GAMEPAD_SHARE,
+		KEY_GAMEPAD_START,
+		KEY_GAMEPAD_SELECT,
+
+		KEY_GAMEPAD_BUTTON_TOUCH,
+
+		KEY_GAMEPAD_BUTTON_0,
+		KEY_GAMEPAD_BUTTON_1,
+		KEY_GAMEPAD_BUTTON_2,
+		KEY_GAMEPAD_BUTTON_3,
+		KEY_GAMEPAD_BUTTON_4,
+		KEY_GAMEPAD_BUTTON_5,
+		KEY_GAMEPAD_BUTTON_6,
+		KEY_GAMEPAD_BUTTON_7,
+		KEY_GAMEPAD_BUTTON_8,
+		KEY_GAMEPAD_BUTTON_9,
+		KEY_GAMEPAD_BUTTON_10,
+		KEY_GAMEPAD_BUTTON_11,
+		KEY_GAMEPAD_BUTTON_12,
+		KEY_GAMEPAD_BUTTON_13,
+		KEY_GAMEPAD_BUTTON_14,
+		KEY_GAMEPAD_BUTTON_15,
+
+		KEY_GAMEPAD_BUTTON_MAX
 
 	};// KeyCode
 

data/include/reflex/device.h

@@ -4,10 +4,32 @@
 #define __REFLEX_DEVICE_H__
 
 
+#include <xot/ref.h>
+#include <reflex/defs.h>
+
+
 namespace Reflex
 {
 
 
+	class Device : public Xot::RefCountable<>
+	{
+
+		public:
+
+			typedef Xot::Ref<Device> Ref;
+
+			virtual ~Device ();
+
+			virtual const char* name () const = 0;
+
+			virtual operator bool () const;
+
+			bool operator ! () const;
+
+	};// Device
+
+
 	void vibrate ();
 
 

data/include/reflex/event.h

@@ -17,6 +17,7 @@ namespace Reflex
 {
 
 
+	class Device;
 	class Shape;
 	class View;
 
@@ -26,7 +27,7 @@ namespace Reflex
 
 		public:
 
-			Event ();
+			Event (double time = -1);
 
 			~Event ();
 
@@ -47,6 +48,30 @@ namespace Reflex
 	};// Event
 
 
+	class DeviceEvent : public Event
+	{
+
+		public:
+
+			DeviceEvent (Device* device = NULL);
+
+			DeviceEvent dup () const;
+
+			      Device* device ();
+
+			const Device* device () const;
+
+			struct Data;
+
+			Xot::PSharedImpl<Data> self;
+
+		private:
+
+			DeviceEvent (const DeviceEvent* src);
+
+	};// DeviceEvent
+
+
 	class UpdateEvent : public Event
 	{
 
@@ -238,7 +263,7 @@ namespace Reflex
 
 			KeyEvent (
 				Action action, const char* chars, int code,
-				uint modifiers = 0, int repeat = 0);
+				uint modifiers = 0, int repeat = 0, double time = -1);
 
 			KeyEvent dup () const;
 
@@ -329,6 +354,43 @@ namespace Reflex
 	};// WheelEvent
 
 
+	class NoteEvent : public Event
+	{
+
+		public:
+
+			enum Action {ACTION_NONE = 0, ON, OFF};
+
+			NoteEvent ();
+
+			NoteEvent (
+				Action action, int channel, int note, float velocity, double time);
+
+			NoteEvent dup () const;
+
+			Action action () const;
+
+			int channel () const;
+
+			int note () const;
+
+			float frequency () const;
+
+			float velocity () const;
+
+			bool is_captured () const;
+
+			struct Data;
+
+			Xot::PSharedImpl<Data> self;
+
+		private:
+
+			NoteEvent (const NoteEvent* src);
+
+	};// NoteEvent
+
+
 	class CaptureEvent : public Event
 	{
 

data/include/reflex/gamepad.h

@@ -0,0 +1,175 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_GAMEPAD_H__
+#define __REFLEX_GAMEPAD_H__
+
+
+#include <xot/ref.h>
+#include <xot/pimpl.h>
+#include <xot/util.h>
+#include <reflex/device.h>
+#include <reflex/event.h>
+
+
+namespace Reflex
+{
+
+
+	class Gamepad : public Device
+	{
+
+		public:
+
+			typedef Xot::Ref<Gamepad> Ref;
+
+			typedef std::vector<Ref>  List;
+
+			enum Index
+			{
+
+				INDEX_LEFT = 0, INDEX_RIGHT, INDEX_MAX
+
+			};// Index
+
+			enum Button
+			{
+
+				LEFT         = Xot::bit<ulonglong>(0),
+
+				RIGHT        = Xot::bit<ulonglong>(1),
+
+				UP           = Xot::bit<ulonglong>(2),
+
+				DOWN         = Xot::bit<ulonglong>(3),
+
+				LSTICK_LEFT  = Xot::bit<ulonglong>(4),
+
+				LSTICK_RIGHT = Xot::bit<ulonglong>(5),
+
+				LSTICK_UP    = Xot::bit<ulonglong>(6),
+
+				LSTICK_DOWN  = Xot::bit<ulonglong>(7),
+
+				RSTICK_LEFT  = Xot::bit<ulonglong>(8),
+
+				RSTICK_RIGHT = Xot::bit<ulonglong>(9),
+
+				RSTICK_UP    = Xot::bit<ulonglong>(10),
+
+				RSTICK_DOWN  = Xot::bit<ulonglong>(11),
+
+				BUTTON_A     = Xot::bit<ulonglong>(12),
+
+				BUTTON_B     = Xot::bit<ulonglong>(13),
+
+				BUTTON_X     = Xot::bit<ulonglong>(14),
+
+				BUTTON_Y     = Xot::bit<ulonglong>(15),
+
+				LSHOULDER    = Xot::bit<ulonglong>(16),
+
+				RSHOULDER    = Xot::bit<ulonglong>(17),
+
+				LTRIGGER     = Xot::bit<ulonglong>(18),
+
+				RTRIGGER     = Xot::bit<ulonglong>(19),
+
+				LTHUMB       = Xot::bit<ulonglong>(20),
+
+				RTHUMB       = Xot::bit<ulonglong>(21),
+
+				LPADDLE_0    = Xot::bit<ulonglong>(22),
+
+				LPADDLE_1    = Xot::bit<ulonglong>(23),
+
+				RPADDLE_0    = Xot::bit<ulonglong>(24),
+
+				RPADDLE_1    = Xot::bit<ulonglong>(25),
+
+				HOME         = Xot::bit<ulonglong>(26),
+
+				MENU         = Xot::bit<ulonglong>(27),
+
+				OPTION       = Xot::bit<ulonglong>(28),
+
+				SHARE        = Xot::bit<ulonglong>(29),
+
+				START        = Xot::bit<ulonglong>(30),
+
+				SELECT       = Xot::bit<ulonglong>(31),
+
+				BUTTON_TOUCH = Xot::bit<ulonglong>(32),
+
+				BUTTON_0     = Xot::bit<ulonglong>(33),
+
+				BUTTON_1     = Xot::bit<ulonglong>(34),
+
+				BUTTON_2     = Xot::bit<ulonglong>(35),
+
+				BUTTON_3     = Xot::bit<ulonglong>(36),
+
+				BUTTON_4     = Xot::bit<ulonglong>(37),
+
+				BUTTON_5     = Xot::bit<ulonglong>(38),
+
+				BUTTON_6     = Xot::bit<ulonglong>(39),
+
+				BUTTON_7     = Xot::bit<ulonglong>(40),
+
+				BUTTON_8     = Xot::bit<ulonglong>(41),
+
+				BUTTON_9     = Xot::bit<ulonglong>(42),
+
+				BUTTON_10    = Xot::bit<ulonglong>(43),
+
+				BUTTON_11    = Xot::bit<ulonglong>(44),
+
+				BUTTON_12    = Xot::bit<ulonglong>(45),
+
+				BUTTON_13    = Xot::bit<ulonglong>(46),
+
+				BUTTON_14    = Xot::bit<ulonglong>(47),
+
+				BUTTON_15    = Xot::bit<ulonglong>(48),
+
+			};// Button
+
+			Gamepad ();
+
+			virtual ~Gamepad ();
+
+			virtual const char* name () const;
+
+			virtual ulonglong buttons () const;
+
+			virtual const Point& stick (size_t index = INDEX_LEFT) const;
+
+			virtual float trigger      (size_t index = INDEX_LEFT) const;
+
+			const Gamepad* prev () const;
+
+			virtual void on_key      (KeyEvent* e);
+
+			virtual void on_key_down (KeyEvent* e);
+
+			virtual void on_key_up   (KeyEvent* e);
+
+			//virtual void on_stick (StickEvent* e);
+
+			//virtual void on_trigger (TriggerEvent* e);
+
+			virtual operator bool () const;
+
+			static const List& all ();
+
+			struct Data;
+
+			Xot::PImpl<Data> self;
+
+	};// Gamepad
+
+
+}// Reflex
+
+
+#endif//EOH

data/include/reflex/midi.h

@@ -0,0 +1,53 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_MIDI_H__
+#define __REFLEX_MIDI_H__
+
+
+#include <vector>
+#include <xot/ref.h>
+#include <xot/pimpl.h>
+#include <reflex/device.h>
+#include <reflex/event.h>
+
+
+namespace Reflex
+{
+
+
+	class MIDI : public Device
+	{
+
+		public:
+
+			typedef Xot::Ref<MIDI>   Ref;
+
+			typedef std::vector<Ref> List;
+
+			MIDI ();
+
+			virtual ~MIDI ();
+
+			virtual const char* name () const;
+
+			virtual void on_note     (NoteEvent* e);
+
+			virtual void on_note_on  (NoteEvent* e);
+
+			virtual void on_note_off (NoteEvent* e);
+
+			virtual operator bool () const;
+
+			static const List& all ();
+
+			struct Data;
+
+			Xot::PImpl<Data> self;
+
+	};// MIDI
+
+
+}// Reflex
+
+
+#endif//EOH

data/include/reflex/reflex.h

@@ -16,6 +16,8 @@ namespace Reflex
 
 	void fin ();
 
+	void process_events ();
+
 
 }// Reflex
 

data/include/reflex/ruby/application.h

@@ -65,6 +65,24 @@ namespace Reflex
 					return Super::on_quit(e);
 			}
 
+			virtual void on_device_connect (DeviceEvent* e)
+			{
+				RUCY_SYM(on_device_connect);
+				if (this->is_overridable())
+					this->value.call(on_device_connect, Rucy::value(e));
+				else
+					return Super::on_device_connect(e);
+			}
+
+			virtual void on_device_disconnect (DeviceEvent* e)
+			{
+				RUCY_SYM(on_device_disconnect);
+				if (this->is_overridable())
+					this->value.call(on_device_disconnect, Rucy::value(e));
+				else
+					return Super::on_device_disconnect(e);
+			}
+
 			virtual void on_motion (MotionEvent* e)
 			{
 				RUCY_SYM(on_motion);