reflexion 0.3.6 → 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;
 

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/event.h

@@ -27,7 +27,7 @@ namespace Reflex
 
 		public:
 
-			Event ();
+			Event (double time = -1);
 
 			~Event ();
 
@@ -263,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;
 
@@ -354,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

@@ -20,9 +20,9 @@ namespace Reflex
 
 		public:
 
-			typedef Xot::Ref<Gamepad>         Ref;
+			typedef Xot::Ref<Gamepad> Ref;
 
-			typedef std::vector<Gamepad::Ref> List;
+			typedef std::vector<Ref>  List;
 
 			enum Index
 			{

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/event.h

@@ -29,6 +29,8 @@ RUCY_DECLARE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::PointerEvent)
 
 RUCY_DECLARE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::WheelEvent)
 
+RUCY_DECLARE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::NoteEvent)
+
 RUCY_DECLARE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::CaptureEvent)
 
 RUCY_DECLARE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::TimerEvent)
@@ -72,6 +74,9 @@ namespace Reflex
 	REFLEX_EXPORT Rucy::Class wheel_event_class ();
 	// class Reflex::WheelEvent
 
+	REFLEX_EXPORT Rucy::Class note_event_class ();
+	// class Reflex::NoteEvent
+
 	REFLEX_EXPORT Rucy::Class capture_event_class ();
 	// class Reflex::CaptureEvent
 
@@ -152,6 +157,12 @@ namespace Rucy
 		return Reflex::wheel_event_class();
 	}
 
+	template <> inline Class
+	get_ruby_class<Reflex::NoteEvent> ()
+	{
+		return Reflex::note_event_class();
+	}
+
 	template <> inline Class
 	get_ruby_class<Reflex::CaptureEvent> ()
 	{

data/include/reflex/ruby/midi.h

@@ -0,0 +1,84 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_RUBY_MIDI_H__
+#define __REFLEX_RUBY_MIDI_H__
+
+
+#include <rucy/class.h>
+#include <rucy/extension.h>
+#include <reflex/midi.h>
+
+
+RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::MIDI)
+
+
+namespace Reflex
+{
+
+
+	REFLEX_EXPORT Rucy::Class midi_class ();
+	// class Reflex::MIDI
+
+
+	template <typename T>
+	class RubyMIDI : public Rucy::ClassWrapper<T>
+	{
+
+		typedef Rucy::ClassWrapper<T> Super;
+
+		public:
+
+			virtual void on_note (NoteEvent* e)
+			{
+				RUCY_SYM(on_note);
+				if (this->is_overridable())
+					this->value.call(on_note, Rucy::value(e));
+				else
+					Super::on_note(e);
+			}
+
+			virtual void on_note_on (NoteEvent* e)
+			{
+				RUCY_SYM(on_note_on);
+				if (this->is_overridable())
+					this->value.call(on_note_on, Rucy::value(e));
+				else
+					Super::on_note_on(e);
+			}
+
+			virtual void on_note_off (NoteEvent* e)
+			{
+				RUCY_SYM(on_note_off);
+				if (this->is_overridable())
+					this->value.call(on_note_off, Rucy::value(e));
+				else
+					Super::on_note_off(e);
+			}
+
+	};// RubyMIDI
+
+
+}// Reflex
+
+
+namespace Rucy
+{
+
+
+	template <> inline Class
+	get_ruby_class<Reflex::MIDI> ()
+	{
+		return Reflex::midi_class();
+	}
+
+	inline Value
+	value (Reflex::MIDI::Ref& ref, Value klass = Reflex::midi_class())
+	{
+		return value(ref.get(), klass);
+	}
+
+
+}// Rucy
+
+
+#endif//EOH

data/include/reflex/ruby/window.h

@@ -191,6 +191,33 @@ namespace Reflex
 					Super::on_wheel(e);
 			}
 
+			virtual void on_note (NoteEvent* e)
+			{
+				RUCY_SYM(on_note);
+				if (this->is_overridable())
+					this->value.call(on_note, Rucy::value(e));
+				else
+					Super::on_note(e);
+			}
+
+			virtual void on_note_on (NoteEvent* e)
+			{
+				RUCY_SYM(on_note_on);
+				if (this->is_overridable())
+					this->value.call(on_note_on, Rucy::value(e));
+				else
+					Super::on_note_on(e);
+			}
+
+			virtual void on_note_off (NoteEvent* e)
+			{
+				RUCY_SYM(on_note_off);
+				if (this->is_overridable())
+					this->value.call(on_note_off, Rucy::value(e));
+				else
+					Super::on_note_off(e);
+			}
+
 	};// RubyWindow
 
 

data/include/reflex/view.h

@@ -82,7 +82,9 @@ namespace Reflex
 
 				CAPTURE_POINTER = Xot::bit(1),
 
-				CAPTURE_ALL     = CAPTURE_KEY | CAPTURE_POINTER,
+				CAPTURE_NOTE    = Xot::bit(2),
+
+				CAPTURE_ALL     = CAPTURE_KEY | CAPTURE_POINTER | CAPTURE_NOTE,
 
 			};// Capture
 
@@ -380,6 +382,12 @@ namespace Reflex
 
 			virtual void on_wheel (WheelEvent* e);
 
+			virtual void on_note     (NoteEvent* e);
+
+			virtual void on_note_on  (NoteEvent* e);
+
+			virtual void on_note_off (NoteEvent* e);
+
 			virtual void on_capture (CaptureEvent* e);
 
 			virtual void on_timer (TimerEvent* e);

data/include/reflex/window.h

@@ -135,6 +135,12 @@ namespace Reflex
 
 			virtual void on_wheel (WheelEvent* e);
 
+			virtual void on_note     (NoteEvent* e);
+
+			virtual void on_note_on  (NoteEvent* e);
+
+			virtual void on_note_off (NoteEvent* e);
+
 			operator bool () const;
 
 			bool operator ! () const;

data/lib/reflex/note_event.rb

@@ -0,0 +1,34 @@
+require 'xot/const_symbol_accessor'
+require 'reflex/ext'
+
+
+module Reflex
+
+
+  class NoteEvent < Event
+
+    alias get_action action
+
+    const_symbol_reader :action, **{
+      none: ACTION_NONE,
+      on:   ON,
+      off:  OFF
+    }
+
+    def on?()
+      get_action == ON
+    end
+
+    def off?()
+      get_action == OFF
+    end
+
+    def inspect()
+      "#<Reflex::NoteEvent action:%s channel:%d note:%d vel:0f time:%f captured?:%s>" %
+        [action, channel, note, velocity, time, captured?]
+    end
+
+  end# NoteEvent
+
+
+end# Reflex

data/lib/reflex/view.rb

@@ -49,6 +49,7 @@ module Reflex
     bit_flag_accessor :capture do
       flag :key,     CAPTURE_KEY
       flag :pointer, CAPTURE_POINTER
+      flag :note,    CAPTURE_NOTE
       flag :all,     CAPTURE_ALL
     end
 
@@ -103,7 +104,7 @@ module Reflex
       if args.empty?
         not cap.empty?
       elsif args.include?(:all)
-        cap == [:key, :pointer]
+        cap == [:key, :pointer, :note]
       else
         args.all? {|type| cap.include? type}
       end

data/lib/reflex.rb

@@ -19,37 +19,38 @@ require 'reflex/reflex'
 require 'reflex/helper'
 
 require 'reflex/selector'
+require 'reflex/pointer'
 require 'reflex/style'
 require 'reflex/style_length'
 require 'reflex/timer'
 require 'reflex/filter'
 
+require 'reflex/shape'
+require 'reflex/polygon_shape'
+require 'reflex/line_shape'
+require 'reflex/rect_shape'
+require 'reflex/ellipse_shape'
+
 require 'reflex/update_event'
 require 'reflex/draw_event'
 require 'reflex/frame_event'
 require 'reflex/scroll_event'
 require 'reflex/focus_event'
 require 'reflex/key_event'
-require 'reflex/pointer'
 require 'reflex/pointer_event'
 require 'reflex/wheel_event'
+require 'reflex/note_event'
 require 'reflex/capture_event'
 require 'reflex/timer_event'
 require 'reflex/contact_event'
 
-require 'reflex/shape'
-require 'reflex/polygon_shape'
-require 'reflex/line_shape'
-require 'reflex/rect_shape'
-require 'reflex/ellipse_shape'
-
 require 'reflex/model'
 require 'reflex/model_owner'
 
 require 'reflex/application'
-require 'reflex/screen'
 require 'reflex/window'
 require 'reflex/view'
+require 'reflex/screen'
 
 require 'reflex/button'
 require 'reflex/text_view'

data/reflex.gemspec

@@ -25,9 +25,9 @@ Gem::Specification.new do |s|
   s.platform              = Gem::Platform::RUBY
   s.required_ruby_version = '>= 3.0.0'
 
-  s.add_dependency 'xot',   '~> 0.3.6', '>= 0.3.6'
-  s.add_dependency 'rucy',  '~> 0.3.6', '>= 0.3.6'
-  s.add_dependency 'rays',  '~> 0.3.6', '>= 0.3.6'
+  s.add_dependency 'xot',   '~> 0.3.7', '>= 0.3.7'
+  s.add_dependency 'rucy',  '~> 0.3.7', '>= 0.3.7'
+  s.add_dependency 'rays',  '~> 0.3.7', '>= 0.3.7'
 
   s.files            = `git ls-files`.split $/
   s.executables      = s.files.grep(%r{^bin/}) {|f| File.basename f}

data/src/application.cpp

@@ -5,6 +5,7 @@
 #include "reflex/debug.h"
 #include "window.h"
 #include "gamepad.h"
+#include "midi.h"
 
 
 namespace Reflex
@@ -23,6 +24,7 @@ namespace Reflex
 	Application_call_start (Application* app, Event* e)
 	{
 		Gamepad_init(app);
+		MIDI_init(app);
 
 		app->on_start(e);
 	}
@@ -33,6 +35,7 @@ namespace Reflex
 		app->on_quit(e);
 		if (e->is_blocked()) return;
 
+		MIDI_fin(app);
 		Gamepad_fin(app);
 	}