reflexion 0.5.3 → 0.7.0

data/include/reflex/pin.h

@@ -0,0 +1,68 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_PIN_H__
+#define __REFLEX_PIN_H__
+
+
+#include <xot/pimpl.h>
+#include <rays/point.h>
+#include <reflex/defs.h>
+
+
+namespace Reflex
+{
+
+
+	class View;
+	class SnapConstraint;
+	class LinkConstraint;
+	class WheelConstraint;
+	class ChaseConstraint;
+
+
+	class Pin
+	{
+
+		public:
+
+			Pin ();
+
+			Pin (coord x, coord y);
+
+			Pin (const Point& position);
+
+			Pin (View* view);
+
+			Pin (View* view, coord x, coord y);
+
+			Pin (View* view, const Point& position);
+
+			SnapConstraint*  snap  (Pin target = Pin());
+
+			LinkConstraint*  link  (Pin target = Pin());
+
+			WheelConstraint* wheel (Pin target = Pin());
+
+			ChaseConstraint* chase (Pin target = Pin());
+
+			      View* view ();
+
+			const View* view () const;
+
+			const Point* position () const;
+
+			operator bool () const;
+
+			bool operator ! () const;
+
+			struct Data;
+
+			Xot::PSharedImpl<Data> self;
+
+	};// Pin
+
+
+}// Reflex
+
+
+#endif//EOH

data/include/reflex/pointer.h

@@ -57,6 +57,10 @@ namespace Reflex
 
 				CANCEL,
 
+				ENTER,
+
+				LEAVE,
+
 				STAY
 
 			};// Action

data/include/reflex/reflex.h

@@ -18,6 +18,8 @@ namespace Reflex
 
 	void process_events ();
 
+	void alert (const char* message, const char* title = NULL);
+
 
 }// Reflex
 

data/include/reflex/ruby/application.h

@@ -49,9 +49,14 @@ namespace Reflex
 
 			virtual void on_start (Event* e)
 			{
-				RUCY_SYM(on_start);
 				if (this->is_overridable())
+				{
+					RUCY_SYM(call_start_block);
+					this->value.call(call_start_block);
+
+					RUCY_SYM(on_start);
 					this->value.call(on_start, Rucy::value(e));
+				}
 				else
 					return Super::on_start(e);
 			}

data/include/reflex/ruby/clipboard.h

@@ -0,0 +1,23 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_RUBY_CLIPBOARD_H__
+#define __REFLEX_RUBY_CLIPBOARD_H__
+
+
+#include <rucy/class.h>
+#include <rucy/extension.h>
+#include <reflex/clipboard.h>
+
+
+namespace Reflex
+{
+
+
+	REFLEX_EXPORT Rucy::Class clipboard_class ();
+	// class Reflex::Clipboard
+
+
+}// Reflex
+
+
+#endif//EOH

data/include/reflex/ruby/color_picker.h

@@ -0,0 +1,89 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_RUBY_COLOR_PICKER_H__
+#define __REFLEX_RUBY_COLOR_PICKER_H__
+
+
+#include <rucy/class.h>
+#include <rucy/extension.h>
+#include <reflex/color_picker.h>
+#include <reflex/ruby/event.h>
+
+
+RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::ColorPicker)
+
+
+namespace Reflex
+{
+
+
+	REFLEX_EXPORT Rucy::Class color_picker_class ();
+	// class Reflex::ColorPicker
+
+
+	template <typename T>
+	class RubyColorPicker : public Rucy::ClassWrapper<T>
+	{
+
+		typedef Rucy::ClassWrapper<T> Super;
+
+		public:
+
+			virtual void on_color (ColorEvent* e)
+			{
+				if (this->is_overridable())
+				{
+					RUCY_SYM(call_color_block);
+					this->value.call(call_color_block, Rucy::value(e));
+
+					if (!e->is_blocked())
+					{
+						RUCY_SYM(on_color);
+						this->value.call(on_color, Rucy::value(e));
+					}
+				}
+				else
+					Super::on_color(e);
+			}
+
+			virtual void on_close (Event* e)
+			{
+				if (this->is_overridable())
+				{
+					RUCY_SYM(clear_color_block);
+					this->value.call(clear_color_block);
+
+					RUCY_SYM(on_close);
+					this->value.call(on_close, Rucy::value(e));
+				}
+				else
+					Super::on_close(e);
+			}
+
+	};// RubyColorPicker
+
+
+}// Reflex
+
+
+namespace Rucy
+{
+
+
+	template <> inline Class
+	get_ruby_class<Reflex::ColorPicker> ()
+	{
+		return Reflex::color_picker_class();
+	}
+
+	inline Value
+	value (Reflex::ColorPicker::Ref& ref, Value klass = Reflex::color_picker_class())
+	{
+		return value(ref.get(), klass);
+	}
+
+
+}// Rucy
+
+
+#endif//EOH

data/include/reflex/ruby/constraint.h

@@ -0,0 +1,94 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_RUBY_CONSTRAINT_H__
+#define __REFLEX_RUBY_CONSTRAINT_H__
+
+
+#include <rucy/class.h>
+#include <rucy/extension.h>
+#include <reflex/constraint.h>
+
+
+RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::Constraint)
+
+RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::SnapConstraint)
+
+RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::LinkConstraint)
+
+RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::WheelConstraint)
+
+RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::ChaseConstraint)
+
+
+namespace Reflex
+{
+
+
+	template <typename T>
+	class RubyConstraint : public Rucy::ClassWrapper<T> {};
+
+
+	REFLEX_EXPORT Rucy::Class constraint_class ();
+	// class Reflex::Constraint
+
+	REFLEX_EXPORT Rucy::Class snap_constraint_class ();
+	// class Reflex::SnapConstraint
+
+	REFLEX_EXPORT Rucy::Class link_constraint_class ();
+	// class Reflex::LinkConstraint
+
+	REFLEX_EXPORT Rucy::Class wheel_constraint_class ();
+	// class Reflex::WheelConstraint
+
+	REFLEX_EXPORT Rucy::Class chase_constraint_class ();
+	// class Reflex::ChaseConstraint
+
+
+}// Reflex
+
+
+namespace Rucy
+{
+
+
+	template <> inline Class
+	get_ruby_class<Reflex::Constraint> ()
+	{
+		return Reflex::constraint_class();
+	}
+
+	template <> inline Class
+	get_ruby_class<Reflex::SnapConstraint> ()
+	{
+		return Reflex::snap_constraint_class();
+	}
+
+	template <> inline Class
+	get_ruby_class<Reflex::LinkConstraint> ()
+	{
+		return Reflex::link_constraint_class();
+	}
+
+	template <> inline Class
+	get_ruby_class<Reflex::WheelConstraint> ()
+	{
+		return Reflex::wheel_constraint_class();
+	}
+
+	template <> inline Class
+	get_ruby_class<Reflex::ChaseConstraint> ()
+	{
+		return Reflex::chase_constraint_class();
+	}
+
+	inline Value
+	value (Reflex::Constraint::Ref& ref, Value klass = Reflex::constraint_class())
+	{
+		return value(ref.get(), klass);
+	}
+
+
+}// Rucy
+
+
+#endif//EOH

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

@@ -0,0 +1,103 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_RUBY_MENU_H__
+#define __REFLEX_RUBY_MENU_H__
+
+
+#include <rucy/class.h>
+#include <rucy/extension.h>
+#include <reflex/menu.h>
+#include <reflex/ruby/event.h>
+
+
+RUCY_DECLARE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::Menu)
+
+
+namespace Reflex
+{
+
+
+	REFLEX_EXPORT Rucy::Class menu_class ();
+	// class Reflex::Menu
+
+
+	template <typename T>
+	class RubyMenu : public Rucy::ClassWrapper<T>
+	{
+
+		typedef Rucy::ClassWrapper<T> Super;
+
+		public:
+
+			virtual void on_show (Event* e)
+			{
+				RUCY_SYM(on_show);
+				if (this->is_overridable())
+					this->value.call(on_show, Rucy::value(e));
+				else
+					Super::on_show(e);
+			}
+
+			virtual void on_hide (Event* e)
+			{
+				RUCY_SYM(on_hide);
+				if (this->is_overridable())
+					this->value.call(on_hide, Rucy::value(e));
+				else
+					Super::on_hide(e);
+			}
+
+			virtual void on_open_submenu (Event* e)
+			{
+				RUCY_SYM(on_open_submenu);
+				if (this->is_overridable())
+					this->value.call(on_open_submenu, Rucy::value(e));
+				else
+					Super::on_open_submenu(e);
+			}
+
+			virtual void on_close_submenu (Event* e)
+			{
+				RUCY_SYM(on_close_submenu);
+				if (this->is_overridable())
+					this->value.call(on_close_submenu, Rucy::value(e));
+				else
+					Super::on_close_submenu(e);
+			}
+
+			virtual void on_click (Event* e)
+			{
+				RUCY_SYM(on_click);
+				if (this->is_overridable())
+					this->value.call(on_click, Rucy::value(e));
+				else
+					Super::on_click(e);
+			}
+
+	};// RubyMenu
+
+
+}// Reflex
+
+
+namespace Rucy
+{
+
+
+	template <> inline Class
+	get_ruby_class<Reflex::Menu> ()
+	{
+		return Reflex::menu_class();
+	}
+
+	inline Value
+	value (Reflex::Menu::Ref& ref, Value klass = Reflex::menu_class())
+	{
+		return value(ref.get(), klass);
+	}
+
+
+}// Rucy
+
+
+#endif//EOH