reflexion 0.6.0 → 0.7.0

data/include/reflex/ruby/event.h

@@ -25,16 +25,12 @@ RUCY_DECLARE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::FocusEvent)
 
 RUCY_DECLARE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::KeyEvent)
 
+RUCY_DECLARE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::TextEvent)
+
 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::MIDIEvent)
-
-RUCY_DECLARE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::NoteEvent)
-
-RUCY_DECLARE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::ControlChangeEvent)
-
 RUCY_DECLARE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::CaptureEvent)
 
 RUCY_DECLARE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::TimerEvent)
@@ -43,6 +39,16 @@ RUCY_DECLARE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::ContactEvent)
 
 RUCY_DECLARE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::MotionEvent)
 
+RUCY_DECLARE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::FileEvent)
+
+RUCY_DECLARE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::ColorEvent)
+
+RUCY_DECLARE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::MIDIEvent)
+
+RUCY_DECLARE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::NoteEvent)
+
+RUCY_DECLARE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::ControlChangeEvent)
+
 
 namespace Reflex
 {
@@ -72,21 +78,15 @@ namespace Reflex
 	REFLEX_EXPORT Rucy::Class key_event_class ();
 	// class Reflex::KeyEvent
 
+	REFLEX_EXPORT Rucy::Class text_event_class ();
+	// class Reflex::TextEvent
+
 	REFLEX_EXPORT Rucy::Class pointer_event_class ();
 	// class Reflex::PointerEvent
 
 	REFLEX_EXPORT Rucy::Class wheel_event_class ();
 	// class Reflex::WheelEvent
 
-	REFLEX_EXPORT Rucy::Class midi_event_class ();
-	// class Reflex::MIDIEvent
-
-	REFLEX_EXPORT Rucy::Class note_event_class ();
-	// class Reflex::NoteEvent
-
-	REFLEX_EXPORT Rucy::Class control_change_event_class ();
-	// class Reflex::ControlChangeEvent
-
 	REFLEX_EXPORT Rucy::Class capture_event_class ();
 	// class Reflex::CaptureEvent
 
@@ -99,6 +99,21 @@ namespace Reflex
 	REFLEX_EXPORT Rucy::Class motion_event_class ();
 	// class Reflex::MotionEvent
 
+	REFLEX_EXPORT Rucy::Class file_event_class ();
+	// class Reflex::FileEvent
+
+	REFLEX_EXPORT Rucy::Class color_event_class ();
+	// class Reflex::ColorEvent
+
+	REFLEX_EXPORT Rucy::Class midi_event_class ();
+	// class Reflex::MIDIEvent
+
+	REFLEX_EXPORT Rucy::Class note_event_class ();
+	// class Reflex::NoteEvent
+
+	REFLEX_EXPORT Rucy::Class control_change_event_class ();
+	// class Reflex::ControlChangeEvent
+
 
 }// Reflex
 
@@ -155,6 +170,12 @@ namespace Rucy
 		return Reflex::key_event_class();
 	}
 
+	template <> inline Class
+	get_ruby_class<Reflex::TextEvent> ()
+	{
+		return Reflex::text_event_class();
+	}
+
 	template <> inline Class
 	get_ruby_class<Reflex::PointerEvent> ()
 	{
@@ -168,45 +189,57 @@ namespace Rucy
 	}
 
 	template <> inline Class
-	get_ruby_class<Reflex::MIDIEvent> ()
+	get_ruby_class<Reflex::CaptureEvent> ()
 	{
-		return Reflex::midi_event_class();
+		return Reflex::capture_event_class();
 	}
 
 	template <> inline Class
-	get_ruby_class<Reflex::NoteEvent> ()
+	get_ruby_class<Reflex::TimerEvent> ()
 	{
-		return Reflex::note_event_class();
+		return Reflex::timer_event_class();
 	}
 
 	template <> inline Class
-	get_ruby_class<Reflex::ControlChangeEvent> ()
+	get_ruby_class<Reflex::ContactEvent> ()
 	{
-		return Reflex::control_change_event_class();
+		return Reflex::contact_event_class();
 	}
 
 	template <> inline Class
-	get_ruby_class<Reflex::CaptureEvent> ()
+	get_ruby_class<Reflex::MotionEvent> ()
 	{
-		return Reflex::capture_event_class();
+		return Reflex::motion_event_class();
 	}
 
 	template <> inline Class
-	get_ruby_class<Reflex::TimerEvent> ()
+	get_ruby_class<Reflex::FileEvent> ()
 	{
-		return Reflex::timer_event_class();
+		return Reflex::file_event_class();
 	}
 
 	template <> inline Class
-	get_ruby_class<Reflex::ContactEvent> ()
+	get_ruby_class<Reflex::ColorEvent> ()
 	{
-		return Reflex::contact_event_class();
+		return Reflex::color_event_class();
 	}
 
 	template <> inline Class
-	get_ruby_class<Reflex::MotionEvent> ()
+	get_ruby_class<Reflex::MIDIEvent> ()
 	{
-		return Reflex::motion_event_class();
+		return Reflex::midi_event_class();
+	}
+
+	template <> inline Class
+	get_ruby_class<Reflex::NoteEvent> ()
+	{
+		return Reflex::note_event_class();
+	}
+
+	template <> inline Class
+	get_ruby_class<Reflex::ControlChangeEvent> ()
+	{
+		return Reflex::control_change_event_class();
 	}
 
 

data/include/reflex/ruby/file_dialog.h

@@ -0,0 +1,89 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_RUBY_FILE_DIALOG_H__
+#define __REFLEX_RUBY_FILE_DIALOG_H__
+
+
+#include <rucy/class.h>
+#include <rucy/extension.h>
+#include <reflex/file_dialog.h>
+#include <reflex/ruby/event.h>
+
+
+RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::FileDialog)
+
+
+namespace Reflex
+{
+
+
+	REFLEX_EXPORT Rucy::Class file_dialog_class ();
+	// class Reflex::FileDialog
+
+
+	template <typename T>
+	class RubyFileDialog : public Rucy::ClassWrapper<T>
+	{
+
+		typedef Rucy::ClassWrapper<T> Super;
+
+		public:
+
+			virtual void on_file (FileEvent* e)
+			{
+				if (this->is_overridable())
+				{
+					RUCY_SYM(call_file_block);
+					this->value.call(call_file_block, Rucy::value(e));
+
+					if (!e->is_blocked())
+					{
+						RUCY_SYM(on_file);
+						this->value.call(on_file, Rucy::value(e));
+					}
+				}
+				else
+					Super::on_file(e);
+			}
+
+			virtual void on_cancel (Event* e)
+			{
+				if (this->is_overridable())
+				{
+					RUCY_SYM(call_cancel_block);
+					this->value.call(call_cancel_block);
+
+					RUCY_SYM(on_cancel);
+					this->value.call(on_cancel, Rucy::value(e));
+				}
+				else
+					Super::on_cancel(e);
+			}
+
+	};// RubyFileDialog
+
+
+}// Reflex
+
+
+namespace Rucy
+{
+
+
+	template <> inline Class
+	get_ruby_class<Reflex::FileDialog> ()
+	{
+		return Reflex::file_dialog_class();
+	}
+
+	inline Value
+	value (Reflex::FileDialog::Ref& ref, Value klass = Reflex::file_dialog_class())
+	{
+		return value(ref.get(), klass);
+	}
+
+
+}// Rucy
+
+
+#endif//EOH

data/include/reflex/ruby/gamepad.h

@@ -0,0 +1,46 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_RUBY_GAMEPAD_H__
+#define __REFLEX_RUBY_GAMEPAD_H__
+
+
+#include <rucy/class.h>
+#include <rucy/extension.h>
+#include <reflex/gamepad.h>
+
+
+RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::Gamepad)
+
+
+namespace Reflex
+{
+
+
+	REFLEX_EXPORT Rucy::Class gamepad_class ();
+	// class Reflex::Gamepad
+
+
+}// Reflex
+
+
+namespace Rucy
+{
+
+
+	template <> inline Class
+	get_ruby_class<Reflex::Gamepad> ()
+	{
+		return Reflex::gamepad_class();
+	}
+
+	inline Value
+	value (Reflex::Gamepad::Ref& ref, Value klass = Reflex::gamepad_class())
+	{
+		return value(ref.get(), klass);
+	}
+
+
+}// Rucy
+
+
+#endif//EOH

data/include/reflex/ruby/reflex.h

@@ -9,6 +9,9 @@
 #include <reflex/reflex.h>
 
 
+RUCY_DECLARE_CONVERT_TO(REFLEX_EXPORT, Reflex::KeyCode)
+
+
 namespace Reflex
 {
 

data/include/reflex/ruby/view.h

@@ -41,6 +41,27 @@ namespace Reflex
 					return Super::content_bounds();
 			}
 
+			virtual bool accepts_text_input () const
+			{
+				RUCY_SYM_Q(accepts_text_input);
+				if (this->is_overridable())
+					return Rucy::to<bool>(this->value.call(accepts_text_input));
+				else
+					return Super::accepts_text_input();
+			}
+
+			virtual Bounds text_input_bounds () const
+			{
+				RUCY_SYM(text_input_bounds);
+				if (this->is_overridable())
+				{
+					Rucy::Value ret = this->value.call(text_input_bounds);
+					return ret.is_nil() ? Super::text_input_bounds() : Rucy::to<Bounds>(ret);
+				}
+				else
+					return Super::text_input_bounds();
+			}
+
 			virtual void on_attach (Event* e)
 			{
 				RUCY_SYM(on_attach);
@@ -194,6 +215,33 @@ namespace Reflex
 					Super::on_key_up(e);
 			}
 
+			virtual void on_text (TextEvent* e)
+			{
+				RUCY_SYM(on_text);
+				if (this->is_overridable())
+					this->value.call(on_text, Rucy::value(e));
+				else
+					Super::on_text(e);
+			}
+
+			virtual void on_text_preedit (TextEvent* e)
+			{
+				RUCY_SYM(on_text_preedit);
+				if (this->is_overridable())
+					this->value.call(on_text_preedit, Rucy::value(e));
+				else
+					Super::on_text_preedit(e);
+			}
+
+			virtual void on_text_commit (TextEvent* e)
+			{
+				RUCY_SYM(on_text_commit);
+				if (this->is_overridable())
+					this->value.call(on_text_commit, Rucy::value(e));
+				else
+					Super::on_text_commit(e);
+			}
+
 			virtual void on_pointer (PointerEvent* e)
 			{
 				RUCY_SYM(on_pointer);
@@ -266,103 +314,103 @@ namespace Reflex
 					Super::on_wheel(e);
 			}
 
-			virtual void on_midi (MIDIEvent* e)
+			virtual void on_capture (CaptureEvent* e)
 			{
-				RUCY_SYM(on_midi);
+				RUCY_SYM(on_capture);
 				if (this->is_overridable())
-					this->value.call(on_midi, Rucy::value(e));
+					this->value.call(on_capture, Rucy::value(e));
 				else
-					Super::on_midi(e);
+					Super::on_capture(e);
 			}
 
-			virtual void on_note (NoteEvent* e)
+			virtual void on_timer (TimerEvent* e)
 			{
-				RUCY_SYM(on_note);
+				RUCY_SYM(on_timer);
 				if (this->is_overridable())
-					this->value.call(on_note, Rucy::value(e));
+					this->value.call(on_timer, Rucy::value(e));
 				else
-					Super::on_note(e);
+					Super::on_timer(e);
 			}
 
-			virtual void on_note_on (NoteEvent* e)
+			virtual bool will_contact (View* v)
 			{
-				RUCY_SYM(on_note_on);
+				RUCY_SYM_Q(will_contact);
 				if (this->is_overridable())
-					this->value.call(on_note_on, Rucy::value(e));
+					return this->value.call(will_contact, Rucy::value(v));
 				else
-					Super::on_note_on(e);
+					return Super::will_contact(v);
 			}
 
-			virtual void on_note_off (NoteEvent* e)
+			virtual void on_contact (ContactEvent* e)
 			{
-				RUCY_SYM(on_note_off);
+				RUCY_SYM_B(on_contact);
 				if (this->is_overridable())
-					this->value.call(on_note_off, Rucy::value(e));
+					this->value.call(on_contact, Rucy::value(e));
 				else
-					Super::on_note_off(e);
+					Super::on_contact(e);
 			}
 
-			virtual void on_control_change (ControlChangeEvent* e)
+			virtual void on_contact_begin (ContactEvent* e)
 			{
-				RUCY_SYM(on_control_change);
+				RUCY_SYM_B(on_contact_begin);
 				if (this->is_overridable())
-					this->value.call(on_control_change, Rucy::value(e));
+					this->value.call(on_contact_begin, Rucy::value(e));
 				else
-					Super::on_control_change(e);
+					Super::on_contact_begin(e);
 			}
 
-			virtual void on_capture (CaptureEvent* e)
+			virtual void on_contact_end (ContactEvent* e)
 			{
-				RUCY_SYM(on_capture);
+				RUCY_SYM_B(on_contact_end);
 				if (this->is_overridable())
-					this->value.call(on_capture, Rucy::value(e));
+					this->value.call(on_contact_end, Rucy::value(e));
 				else
-					Super::on_capture(e);
+					Super::on_contact_end(e);
 			}
 
-			virtual void on_timer (TimerEvent* e)
+			virtual void on_midi (MIDIEvent* e)
 			{
-				RUCY_SYM(on_timer);
+				RUCY_SYM(on_midi);
 				if (this->is_overridable())
-					this->value.call(on_timer, Rucy::value(e));
+					this->value.call(on_midi, Rucy::value(e));
 				else
-					Super::on_timer(e);
+					Super::on_midi(e);
 			}
 
-			virtual bool will_contact (View* v)
+			virtual void on_note (NoteEvent* e)
 			{
-				RUCY_SYM_Q(will_contact);
+				RUCY_SYM(on_note);
 				if (this->is_overridable())
-					return this->value.call(will_contact, Rucy::value(v));
+					this->value.call(on_note, Rucy::value(e));
 				else
-					return Super::will_contact(v);
+					Super::on_note(e);
 			}
 
-			virtual void on_contact (ContactEvent* e)
+			virtual void on_note_on (NoteEvent* e)
 			{
-				RUCY_SYM_B(on_contact);
+				RUCY_SYM(on_note_on);
 				if (this->is_overridable())
-					this->value.call(on_contact, Rucy::value(e));
+					this->value.call(on_note_on, Rucy::value(e));
 				else
-					Super::on_contact(e);
+					Super::on_note_on(e);
 			}
 
-			virtual void on_contact_begin (ContactEvent* e)
+			virtual void on_note_off (NoteEvent* e)
 			{
-				RUCY_SYM_B(on_contact_begin);
+				RUCY_SYM(on_note_off);
 				if (this->is_overridable())
-					this->value.call(on_contact_begin, Rucy::value(e));
+					this->value.call(on_note_off, Rucy::value(e));
 				else
-					Super::on_contact_begin(e);
+					Super::on_note_off(e);
 			}
 
-			virtual void on_contact_end (ContactEvent* e)
+			virtual void on_control_change (ControlChangeEvent* e)
 			{
-				RUCY_SYM_B(on_contact_end);
+				RUCY_SYM(on_control_change);
 				if (this->is_overridable())
-					this->value.call(on_contact_end, Rucy::value(e));
+					this->value.call(on_control_change, Rucy::value(e));
 				else
-					Super::on_contact_end(e);
+					Super::on_control_change(e);
 			}
 
 	};// RubyView

data/include/reflex/ruby/window.h

@@ -31,9 +31,14 @@ namespace Reflex
 
 			virtual void on_show (Event* e)
 			{
-				RUCY_SYM(on_show);
 				if (this->is_overridable())
+				{
+					RUCY_SYM(call_show_block);
+					this->value.call(call_show_block);
+
+					RUCY_SYM(on_show);
 					this->value.call(on_show, Rucy::value(e));
+				}
 				else
 					return Super::on_show(e);
 			}
@@ -137,6 +142,33 @@ namespace Reflex
 					Super::on_key_up(e);
 			}
 
+			virtual void on_text (TextEvent* e)
+			{
+				RUCY_SYM(on_text);
+				if (this->is_overridable())
+					this->value.call(on_text, Rucy::value(e));
+				else
+					Super::on_text(e);
+			}
+
+			virtual void on_text_preedit (TextEvent* e)
+			{
+				RUCY_SYM(on_text_preedit);
+				if (this->is_overridable())
+					this->value.call(on_text_preedit, Rucy::value(e));
+				else
+					Super::on_text_preedit(e);
+			}
+
+			virtual void on_text_commit (TextEvent* e)
+			{
+				RUCY_SYM(on_text_commit);
+				if (this->is_overridable())
+					this->value.call(on_text_commit, Rucy::value(e));
+				else
+					Super::on_text_commit(e);
+			}
+
 			virtual void on_pointer (PointerEvent* e)
 			{
 				RUCY_SYM(on_pointer);
@@ -209,6 +241,33 @@ namespace Reflex
 					Super::on_wheel(e);
 			}
 
+			virtual void on_file (FileEvent* e)
+			{
+				RUCY_SYM(on_file);
+				if (this->is_overridable())
+					this->value.call(on_file, Rucy::value(e));
+				else
+					Super::on_file(e);
+			}
+
+			virtual void on_file_open (FileEvent* e)
+			{
+				RUCY_SYM(on_file_open);
+				if (this->is_overridable())
+					this->value.call(on_file_open, Rucy::value(e));
+				else
+					Super::on_file_open(e);
+			}
+
+			virtual void on_file_save (FileEvent* e)
+			{
+				RUCY_SYM(on_file_save);
+				if (this->is_overridable())
+					this->value.call(on_file_save, Rucy::value(e));
+				else
+					Super::on_file_save(e);
+			}
+
 			virtual void on_midi (MIDIEvent* e)
 			{
 				RUCY_SYM(on_midi);

data/include/reflex/ruby.h

@@ -20,6 +20,9 @@
 #include <reflex/ruby/window.h>
 #include <reflex/ruby/view.h>
 #include <reflex/ruby/screen.h>
+#include <reflex/ruby/clipboard.h>
+#include <reflex/ruby/file_dialog.h>
+#include <reflex/ruby/color_picker.h>
 
 #include <reflex/ruby/image_view.h>
 

data/include/reflex/screen.h

@@ -4,6 +4,7 @@
 #define __REFLEX_SCREEN_H__
 
 
+#include <vector>
 #include <xot/pimpl.h>
 #include <rays/bounds.h>
 #include <reflex/defs.h>
@@ -20,16 +21,24 @@ namespace Reflex
 
 		public:
 
+			typedef std::vector<Screen> List;
+
 			Screen ();
 
-			virtual ~Screen ();
+			~Screen ();
+
+			String name () const;
 
-			virtual Bounds frame () const;
+			Bounds frame () const;
+
+			float pixel_density () const;
 
 			operator bool () const;
 
 			bool operator ! () const;
 
+			static List all ();
+
 			struct Data;
 
 			Xot::PSharedImpl<Data> self;