reflexion 0.3.5 → 0.3.7

data/include/reflex/ruby/device.h

@@ -0,0 +1,40 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_RUBY_DEVICE_H__
+#define __REFLEX_RUBY_DEVICE_H__
+
+
+#include <rucy/class.h>
+#include <rucy/extension.h>
+#include <reflex/device.h>
+
+
+RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::Device)
+
+
+namespace Reflex
+{
+
+
+	REFLEX_EXPORT Rucy::Class device_class ();
+	// class Reflex::Device
+
+
+}// Reflex
+
+
+namespace Rucy
+{
+
+
+	template <> inline Class
+	get_ruby_class<Reflex::Device> ()
+	{
+		return Reflex::device_class();
+	}
+
+
+}// Rucy
+
+
+#endif//EOH

data/include/reflex/ruby/event.h

@@ -11,6 +11,8 @@
 
 RUCY_DECLARE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::Event)
 
+RUCY_DECLARE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::DeviceEvent)
+
 RUCY_DECLARE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::UpdateEvent)
 
 RUCY_DECLARE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::DrawEvent)
@@ -27,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)
@@ -43,6 +47,9 @@ namespace Reflex
 	REFLEX_EXPORT Rucy::Class event_class ();
 	// class Reflex::Event
 
+	REFLEX_EXPORT Rucy::Class device_event_class ();
+	// class Reflex::DeviceEvent
+
 	REFLEX_EXPORT Rucy::Class update_event_class ();
 	// class Reflex::UpdateEvent
 
@@ -67,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
 
@@ -93,6 +103,12 @@ namespace Rucy
 		return Reflex::event_class();
 	}
 
+	template <> inline Class
+	get_ruby_class<Reflex::DeviceEvent> ()
+	{
+		return Reflex::device_event_class();
+	}
+
 	template <> inline Class
 	get_ruby_class<Reflex::UpdateEvent> ()
 	{
@@ -141,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.5', '>= 0.3.5'
-  s.add_dependency 'rucy',  '~> 0.3.5', '>= 0.3.5'
-  s.add_dependency 'rays',  '~> 0.3.5', '>= 0.3.5'
+  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

@@ -4,6 +4,8 @@
 #include "reflex/exception.h"
 #include "reflex/debug.h"
 #include "window.h"
+#include "gamepad.h"
+#include "midi.h"
 
 
 namespace Reflex
@@ -18,6 +20,39 @@ namespace Reflex
 	}// global
 
 
+	void
+	Application_call_start (Application* app, Event* e)
+	{
+		Gamepad_init(app);
+		MIDI_init(app);
+
+		app->on_start(e);
+	}
+
+	void
+	Application_call_quit (Application* app, Event* e)
+	{
+		app->on_quit(e);
+		if (e->is_blocked()) return;
+
+		MIDI_fin(app);
+		Gamepad_fin(app);
+	}
+
+	void
+	Application_call_device_connect (Application* app, Device* device)
+	{
+		DeviceEvent e(device);
+		app->on_device_connect(&e);
+	}
+
+	void
+	Application_call_device_disconnect (Application* app, Device* device)
+	{
+		DeviceEvent e(device);
+		app->on_device_disconnect(&e);
+	}
+
 	Application*
 	app ()
 	{
@@ -78,6 +113,41 @@ namespace Reflex
 		return Window_all().end();
 	}
 
+	void
+	Application::on_start (Event* e)
+	{
+	}
+
+	void
+	Application::on_quit (Event* e)
+	{
+	}
+
+	void
+	Application::on_device_connect (DeviceEvent* e)
+	{
+	}
+
+	void
+	Application::on_device_disconnect (DeviceEvent* e)
+	{
+	}
+
+	void
+	Application::on_motion (MotionEvent* e)
+	{
+	}
+
+	void
+	Application::on_preference (Event* e)
+	{
+	}
+
+	Application::operator bool () const
+	{
+		return true;
+	}
+
 	bool
 	Application::operator ! () const
 	{

data/src/application.h

@@ -22,6 +22,15 @@ namespace Reflex
 	Application::Data* Application_create_data ();
 
 
+	void Application_call_start (Application* app, Event* e);
+
+	void Application_call_quit  (Application* app, Event* e);
+
+	void Application_call_device_connect    (Application* app, Device* device);
+
+	void Application_call_device_disconnect (Application* app, Device* device);
+
+
 }// Reflex
 
 

data/src/device.cpp

@@ -0,0 +1,24 @@
+#include "reflex/device.h"
+
+
+namespace Reflex
+{
+
+
+	Device::~Device ()
+	{
+	}
+
+	Device::operator bool () const
+	{
+		return true;
+	}
+
+	bool
+	Device::operator ! () const
+	{
+		return !operator bool();
+	}
+
+
+}// Reflex

data/src/event.cpp

@@ -2,6 +2,7 @@
 
 
 #include <algorithm>
+#include "reflex/device.h"
 #include "reflex/timer.h"
 #include "reflex/shape.h"
 #include "reflex/exception.h"
@@ -16,14 +17,14 @@ namespace Reflex
 	struct Event::Data
 	{
 
-		bool blocked;
-
 		double time;
 
+		bool blocked;
+
 		Data* parent = NULL;
 
-		Data (bool blocked = false, double time = Xot::time())
-		:	blocked(blocked), time(time)
+		Data (double time = -1, bool blocked = false)
+		:	time(time >= 0 ? time : Xot::time()), blocked(blocked)
 		{
 		}
 
@@ -36,7 +37,8 @@ namespace Reflex
 	};// Event::Data
 
 
-	Event::Event ()
+	Event::Event (double time)
+	:	self(new Data(time))
 	{
 	}
 
@@ -69,6 +71,43 @@ namespace Reflex
 	}
 
 
+	struct DeviceEvent::Data
+	{
+
+		Device::Ref device;
+
+	};// DeviceEvent::Data
+
+
+	DeviceEvent::DeviceEvent (Device* device)
+	{
+		if (device) self->device = device;
+	}
+
+	DeviceEvent::DeviceEvent (const DeviceEvent* src)
+	:	Event(src), self(new Data(*src->self))
+	{
+	}
+
+	DeviceEvent
+	DeviceEvent::dup () const
+	{
+		return DeviceEvent(this);
+	}
+
+	Device*
+	DeviceEvent::device ()
+	{
+		return self->device;
+	}
+
+	const Device*
+	DeviceEvent::device () const
+	{
+		return self->device;
+	}
+
+
 	struct UpdateEvent::Data
 	{
 
@@ -524,8 +563,9 @@ namespace Reflex
 	}
 
 	KeyEvent::KeyEvent (
-		Action action, const char* chars, int code, uint modifiers, int repeat)
-	:	self(new Data(action, chars, code, modifiers, repeat))
+		Action action, const char* chars, int code, uint modifiers, int repeat,
+		double time)
+	:	Event(time), self(new Data(action, chars, code, modifiers, repeat))
 	{
 	}
 
@@ -828,6 +868,92 @@ namespace Reflex
 	}
 
 
+	struct NoteEvent::Data
+	{
+
+		Action action  = ACTION_NONE;
+
+		int channel    = 0;
+
+		int note       = 0;
+
+		float velocity = 0;
+
+		bool captured  = false;
+
+	};// NoteEvent::Data
+
+
+	void
+	NoteEvent_set_captured (NoteEvent* pthis, bool captured)
+	{
+		pthis->self->captured = captured;
+	}
+
+
+	NoteEvent::NoteEvent ()
+	{
+	}
+
+	NoteEvent::NoteEvent (
+		Action action, int channel, int note, float velocity, double time)
+	:	Event(time)
+	{
+		self->action   = action;
+		self->channel  = channel;
+		self->note     = note;
+		self->velocity = velocity;
+	}
+
+	NoteEvent::NoteEvent (const NoteEvent* src)
+	:	Event(src), self(new Data(*src->self))
+	{
+	}
+
+	NoteEvent
+	NoteEvent::dup () const
+	{
+		return NoteEvent(this);
+	}
+
+	NoteEvent::Action
+	NoteEvent::action () const
+	{
+		return self->action;
+	}
+
+	int
+	NoteEvent::channel () const
+	{
+		return self->channel;
+	}
+
+	int
+	NoteEvent::note () const
+	{
+		return self->note;
+	}
+
+	float
+	NoteEvent::frequency () const
+	{
+		static const int A4 = 69;
+		return 440 * std::pow(2.0, (note() - A4) / 12.0);
+	}
+
+	float
+	NoteEvent::velocity () const
+	{
+		return self->velocity;
+	}
+
+	bool
+	NoteEvent::is_captured () const
+	{
+		return self->captured;
+	}
+
+
 	struct CaptureEvent::Data
 	{
 

data/src/event.h

@@ -19,6 +19,8 @@ namespace Reflex
 	void DrawEvent_set_bounds  (DrawEvent* pthis, const Bounds& bounds);
 
 
+	uint KeyEvent_get_modifiers ();
+
 	void KeyEvent_set_chars (KeyEvent* pthis, const char* chars);
 
 	void KeyEvent_set_captured (KeyEvent* pthis, bool captured);
@@ -47,6 +49,9 @@ namespace Reflex
 	void WheelEvent_set_position (WheelEvent* pthis, const Point& position);
 
 
+	void NoteEvent_set_captured (NoteEvent* pthis, bool captured);
+
+
 }// Reflex