reflexion 0.5.3 → 0.7.0

data/ext/reflex/wheel_constraint.cpp

@@ -0,0 +1,154 @@
+#include "reflex/ruby/constraint.h"
+
+
+#include <rays/ruby/point.h>
+#include "reflex/exception.h"
+#include "defs.h"
+
+
+RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::WheelConstraint)
+
+#define THIS  to<Reflex::WheelConstraint*>(self)
+
+#define CHECK RUCY_CHECK_PTR(Reflex::WheelConstraint, self)
+
+
+static
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	Reflex::reflex_error(
+		__FILE__, __LINE__, "can not instantiate WheelConstraint class");
+}
+RUCY_END
+
+static
+RUCY_DEFN(set_axis)
+{
+	CHECK;
+	THIS->set_axis(to<Rays::Point>(argc, argv));
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_axis)
+{
+	CHECK;
+	return value(THIS->axis());
+}
+RUCY_END
+
+static
+RUCY_DEF2(set_range, min, max)
+{
+	CHECK;
+	THIS->set_range(to<coord>(min), to<coord>(max));
+}
+RUCY_END
+
+static
+RUCY_DEF0(clear_range)
+{
+	CHECK;
+	THIS->clear_range();
+}
+RUCY_END
+
+static
+RUCY_DEF0(range_min)
+{
+	CHECK;
+	return value(THIS->range_min());
+}
+RUCY_END
+
+static
+RUCY_DEF0(range_max)
+{
+	CHECK;
+	return value(THIS->range_max());
+}
+RUCY_END
+
+static
+RUCY_DEF0(has_range)
+{
+	CHECK;
+	return value(THIS->has_range());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_motor, degrees_per_second)
+{
+	CHECK;
+	if (degrees_per_second.is_nil())
+		THIS->clear_motor();
+	else
+		THIS->set_motor(to<float>(degrees_per_second));
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_motor)
+{
+	CHECK;
+	return THIS->has_motor() ? value(THIS->motor()) : nil();
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_force, max_torque)
+{
+	CHECK;
+	if (max_torque.is_nil())
+		THIS->clear_force();
+	else
+		THIS->set_force(to<float>(max_torque));
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_force)
+{
+	CHECK;
+	return THIS->has_force() ? value(THIS->force()) : nil();
+}
+RUCY_END
+
+
+static Class cWheelConstraint;
+
+void
+Init_reflex_wheel_constraint ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cWheelConstraint = mReflex.define_class(
+		"WheelConstraint", Reflex::constraint_class());
+	cWheelConstraint.define_alloc_func(alloc);
+	cWheelConstraint.define_method("axis=", set_axis);
+	cWheelConstraint.define_method("axis",  get_axis);
+	cWheelConstraint.define_private_method(  "set_range!",   set_range);
+	cWheelConstraint.define_private_method("clear_range!", clear_range);
+	cWheelConstraint.define_private_method(      "range_min!",   range_min);
+	cWheelConstraint.define_private_method(      "range_max!",   range_max);
+	cWheelConstraint.define_private_method(  "has_range!",   has_range);
+	cWheelConstraint.define_method("motor=", set_motor);
+	cWheelConstraint.define_method("motor",  get_motor);
+	cWheelConstraint.define_method("force=", set_force);
+	cWheelConstraint.define_method("force",  get_force);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	wheel_constraint_class ()
+	{
+		return cWheelConstraint;
+	}
+
+
+}// Reflex

data/ext/reflex/wheel_event.cpp

@@ -9,7 +9,7 @@ RUCY_DEFINE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::WheelEvent)
 
 #define THIS  to<Reflex::WheelEvent*>(self)
 
-#define CHECK RUCY_CHECK_OBJ(Reflex::WheelEvent, self)
+#define CHECK RUCY_CHECK_PTR(Reflex::WheelEvent, self)
 
 
 static

data/ext/reflex/window.cpp

@@ -3,8 +3,9 @@
 
 #include <rays/ruby/bounds.h>
 #include <rays/ruby/painter.h>
-#include "reflex/ruby/screen.h"
 #include "reflex/ruby/view.h"
+#include "reflex/ruby/menu.h"
+#include "reflex/ruby/screen.h"
 #include "defs.h"
 
 
@@ -12,7 +13,8 @@ RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::Window)
 
 #define THIS      to<Reflex::Window*>(self)
 
-#define CHECK     RUCY_CHECK_OBJECT(Reflex::Window, self)
+#define CHECK_PTR RUCY_CHECK_PTR(Reflex::Window, self)
+#define CHECK     RUCY_CHECK_OBJ(Reflex::Window, self)
 
 #define CALL(fun) RUCY_CALL_SUPER(THIS, fun)
 
@@ -43,7 +45,7 @@ RUCY_DEF0(hide)
 RUCY_END
 
 static
-RUCY_DEF0(hidden)
+RUCY_DEF0(is_hidden)
 {
 	CHECK;
 	return value(THIS->hidden());
@@ -53,8 +55,8 @@ RUCY_END
 static
 RUCY_DEF0(close)
 {
-	CHECK;
-	THIS->close();
+	CHECK_PTR;
+	if (*THIS) THIS->close();
 	return self;
 }
 RUCY_END
@@ -84,6 +86,14 @@ RUCY_DEF1(to_screen, point)
 }
 RUCY_END
 
+static
+RUCY_DEF0(is_active)
+{
+	CHECK;
+	return value(THIS->active());
+}
+RUCY_END
+
 static
 RUCY_DEF1(set_title, title)
 {
@@ -118,6 +128,23 @@ RUCY_DEF0(get_frame)
 }
 RUCY_END
 
+static
+RUCY_DEF1(set_menu, menu)
+{
+	CHECK;
+	THIS->set_menu(menu ? to<Reflex::Menu*>(menu) : NULL);
+	return menu;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_menu)
+{
+	CHECK;
+	return value(THIS->menu());
+}
+RUCY_END
+
 static
 RUCY_DEF1(set_closable, state)
 {
@@ -184,6 +211,88 @@ RUCY_DEF0(is_resizable)
 }
 RUCY_END
 
+static const uint TITLEBAR_MASK =
+	Reflex::Window::FLAG_TITLEBAR_BUTTONS |
+	Reflex::Window::FLAG_TITLEBAR_BACKGROUND;
+
+static
+RUCY_DEF1(set_titlebar, titlebar)
+{
+	CHECK;
+
+	uint flags = to<uint>(titlebar);
+	THIS->set_flags((flags & TITLEBAR_MASK) | (THIS->flags() & ~TITLEBAR_MASK));
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_titlebar)
+{
+	CHECK;
+	return value(THIS->flags() & TITLEBAR_MASK);
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_unlisted, state)
+{
+	CHECK;
+
+	if (state)
+		THIS->   add_flag(Reflex::Window::FLAG_UNLISTED);
+	else
+		THIS->remove_flag(Reflex::Window::FLAG_UNLISTED);
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_unlisted)
+{
+	CHECK;
+	return value(THIS->has_flag(Reflex::Window::FLAG_UNLISTED));
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_shadow, state)
+{
+	CHECK;
+
+	if (state)
+		THIS->   add_flag(Reflex::Window::FLAG_SHADOW);
+	else
+		THIS->remove_flag(Reflex::Window::FLAG_SHADOW);
+}
+RUCY_END
+
+static
+RUCY_DEF0(has_shadow)
+{
+	CHECK;
+	return value(THIS->has_flag(Reflex::Window::FLAG_SHADOW));
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_transparent, state)
+{
+	CHECK;
+
+	if (state)
+		THIS->   add_flag(Reflex::Window::FLAG_TRANSPARENT);
+	else
+		THIS->remove_flag(Reflex::Window::FLAG_TRANSPARENT);
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_transparent)
+{
+	CHECK;
+	return value(THIS->has_flag(Reflex::Window::FLAG_TRANSPARENT));
+}
+RUCY_END
+
 static
 RUCY_DEF1(set_fullscreen, state)
 {
@@ -206,18 +315,98 @@ RUCY_DEF0(is_fullscreen)
 }
 RUCY_END
 
+static
+RUCY_DEF1(set_always_on_top, state)
+{
+	CHECK;
+
+	if (state)
+	{
+		THIS->remove_flag(Reflex::Window::FLAG_ALWAYS_ON_BOTTOM);
+		THIS->   add_flag(Reflex::Window::FLAG_ALWAYS_ON_TOP);
+	}
+	else
+		THIS->remove_flag(Reflex::Window::FLAG_ALWAYS_ON_TOP);
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_always_on_top)
+{
+	CHECK;
+	return value(THIS->has_flag(Reflex::Window::FLAG_ALWAYS_ON_TOP));
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_always_on_bottom, state)
+{
+	CHECK;
+
+	if (state)
+	{
+		THIS->remove_flag(Reflex::Window::FLAG_ALWAYS_ON_TOP);
+		THIS->   add_flag(Reflex::Window::FLAG_ALWAYS_ON_BOTTOM);
+	}
+	else
+		THIS->remove_flag(Reflex::Window::FLAG_ALWAYS_ON_BOTTOM);
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_always_on_bottom)
+{
+	CHECK;
+	return value(THIS->has_flag(Reflex::Window::FLAG_ALWAYS_ON_BOTTOM));
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_pointer_through, state)
+{
+	CHECK;
+
+	if (state)
+		THIS->   add_flag(Reflex::Window::FLAG_POINTER_THROUGH);
+	else
+		THIS->remove_flag(Reflex::Window::FLAG_POINTER_THROUGH);
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_pointer_through)
+{
+	CHECK;
+	return value(THIS->has_flag(Reflex::Window::FLAG_POINTER_THROUGH));
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_pointer_through_alpha, alpha)
+{
+	CHECK;
+	THIS->set_pointer_through_alpha(to<float>(alpha));
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_pointer_through_alpha)
+{
+	CHECK;
+	return value(THIS->pointer_through_alpha());
+}
+RUCY_END
+
 static const uint ORIENTATION_MASK =
 	Reflex::Window::FLAG_PORTRAIT | Reflex::Window::FLAG_LANDSCAPE;
 
 static
 RUCY_DEF1(set_orientations, orientations)
 {
-	using namespace Reflex;
-
 	CHECK;
 
 	uint flags = to<uint>(orientations);
-	THIS->set_flag(
+	THIS->set_flags(
 		(      flags   &  ORIENTATION_MASK) |
 		(THIS->flags() & ~ORIENTATION_MASK));
 }
@@ -226,8 +415,6 @@ RUCY_END
 static
 RUCY_DEF0(get_orientations)
 {
-	using namespace Reflex;
-
 	CHECK;
 	return value(THIS->flags() & ORIENTATION_MASK);
 }
@@ -266,46 +453,43 @@ RUCY_DEF0(get_painter)
 RUCY_END
 
 static
-RUCY_DEF1(on_activate, event)
+RUCY_DEF1(on_show, event)
 {
 	CHECK;
-	CALL(on_activate(to<Reflex::Event*>(event)));
+
+	CALL(on_show(to<Reflex::Event*>(event)));
 }
 RUCY_END
 
 static
-RUCY_DEF1(on_deactivate, event)
+RUCY_DEF1(on_hide, event)
 {
 	CHECK;
-	CALL(on_deactivate(to<Reflex::Event*>(event)));
+	CALL(on_hide(to<Reflex::Event*>(event)));
 }
 RUCY_END
 
 static
-RUCY_DEF1(on_show, event)
+RUCY_DEF1(on_close, event)
 {
 	CHECK;
-
-	RUCY_SYM(call_show_block);
-	self.call(call_show_block);
-
-	CALL(on_show(to<Reflex::Event*>(event)));
+	CALL(on_close(to<Reflex::Event*>(event)));
 }
 RUCY_END
 
 static
-RUCY_DEF1(on_hide, event)
+RUCY_DEF1(on_activate, event)
 {
 	CHECK;
-	CALL(on_hide(to<Reflex::Event*>(event)));
+	CALL(on_activate(to<Reflex::Event*>(event)));
 }
 RUCY_END
 
 static
-RUCY_DEF1(on_close, event)
+RUCY_DEF1(on_deactivate, event)
 {
 	CHECK;
-	CALL(on_close(to<Reflex::Event*>(event)));
+	CALL(on_deactivate(to<Reflex::Event*>(event)));
 }
 RUCY_END
 
@@ -365,6 +549,30 @@ RUCY_DEF1(on_key_up, event)
 }
 RUCY_END
 
+static
+RUCY_DEF1(on_text, event)
+{
+	CHECK;
+	CALL(on_text(to<Reflex::TextEvent*>(event)));
+}
+RUCY_END
+
+static
+RUCY_DEF1(on_text_preedit, event)
+{
+	CHECK;
+	CALL(on_text_preedit(to<Reflex::TextEvent*>(event)));
+}
+RUCY_END
+
+static
+RUCY_DEF1(on_text_commit, event)
+{
+	CHECK;
+	CALL(on_text_commit(to<Reflex::TextEvent*>(event)));
+}
+RUCY_END
+
 static
 RUCY_DEF1(on_pointer, event)
 {
@@ -405,6 +613,22 @@ RUCY_DEF1(on_pointer_cancel, event)
 }
 RUCY_END
 
+static
+RUCY_DEF1(on_pointer_enter, event)
+{
+	CHECK;
+	CALL(on_pointer_enter(to<Reflex::PointerEvent*>(event)));
+}
+RUCY_END
+
+static
+RUCY_DEF1(on_pointer_leave, event)
+{
+	CHECK;
+	CALL(on_pointer_leave(to<Reflex::PointerEvent*>(event)));
+}
+RUCY_END
+
 static
 RUCY_DEF1(on_wheel, event)
 {
@@ -413,6 +637,30 @@ RUCY_DEF1(on_wheel, event)
 }
 RUCY_END
 
+static
+RUCY_DEF1(on_file, event)
+{
+	CHECK;
+	CALL(on_file(to<Reflex::FileEvent*>(event)));
+}
+RUCY_END
+
+static
+RUCY_DEF1(on_file_open, event)
+{
+	CHECK;
+	CALL(on_file_open(to<Reflex::FileEvent*>(event)));
+}
+RUCY_END
+
+static
+RUCY_DEF1(on_file_save, event)
+{
+	CHECK;
+	CALL(on_file_save(to<Reflex::FileEvent*>(event)));
+}
+RUCY_END
+
 static
 RUCY_DEF1(on_midi, event)
 {
@@ -463,36 +711,55 @@ Init_reflex_window ()
 
 	cWindow = mReflex.define_class("Window");
 	cWindow.define_alloc_func(alloc);
-	cWindow.define_method("show", show);
-	cWindow.define_method("hide", hide);
+	cWindow.define_method("show",       show);
+	cWindow.define_method("hide",       hide);
+	cWindow.define_method("hidden?", is_hidden);
 	cWindow.define_method("close", close);
 	cWindow.define_method("redraw", redraw);
 	cWindow.define_method("from_screen", from_screen);
 	cWindow.define_method(  "to_screen",   to_screen);
+	cWindow.define_method("active?", is_active);
 	cWindow.define_method("title=", set_title);
-	cWindow.define_method("title", get_title);
+	cWindow.define_method("title",  get_title);
 	cWindow.define_method("frame=", set_frame);
 	cWindow.define_method("frame",  get_frame);
-	cWindow.define_method("closable=",    set_closable);
-	cWindow.define_method("closable?",     is_closable);
-	cWindow.define_method("minimizable=", set_minimizable);
-	cWindow.define_method("minimizable?",  is_minimizable);
-	cWindow.define_method("resizable=",   set_resizable);
-	cWindow.define_method("resizable?",    is_resizable);
-	cWindow.define_method("fullscreen=",  set_fullscreen);
-	cWindow.define_method("fullscreen?",   is_fullscreen);
-	cWindow.define_method("orientations=", set_orientations);
-	cWindow.define_method("orientations",  get_orientations);
-	cWindow.define_method("hidden", hidden);
+	cWindow.define_method("menu=",  set_menu);
+	cWindow.define_method("menu",   get_menu);
+	cWindow.define_method("closable=",              set_closable);
+	cWindow.define_method("closable?",               is_closable);
+	cWindow.define_method("minimizable=",           set_minimizable);
+	cWindow.define_method("minimizable?",            is_minimizable);
+	cWindow.define_method("resizable=",             set_resizable);
+	cWindow.define_method("resizable?",              is_resizable);
+	cWindow.define_method("titlebar=",              set_titlebar);
+	cWindow.define_method("titlebar",               get_titlebar);
+	cWindow.define_method("unlisted=",              set_unlisted);
+	cWindow.define_method("unlisted?",               is_unlisted);
+	cWindow.define_method("shadow=",                set_shadow);
+	cWindow.define_method("shadow?",                has_shadow);
+	cWindow.define_method("transparent=",           set_transparent);
+	cWindow.define_method("transparent?",            is_transparent);
+	cWindow.define_method("fullscreen=",            set_fullscreen);
+	cWindow.define_method("fullscreen?",             is_fullscreen);
+	cWindow.define_method("always_on_top=",         set_always_on_top);
+	cWindow.define_method("always_on_top?",          is_always_on_top);
+	cWindow.define_method("always_on_bottom=",      set_always_on_bottom);
+	cWindow.define_method("always_on_bottom?",       is_always_on_bottom);
+	cWindow.define_method("pointer_through=",       set_pointer_through);
+	cWindow.define_method("pointer_through?",        is_pointer_through);
+	cWindow.define_method("pointer_through_alpha=", set_pointer_through_alpha);
+	cWindow.define_method("pointer_through_alpha",  get_pointer_through_alpha);
+	cWindow.define_method("orientations=",          set_orientations);
+	cWindow.define_method("orientations",           get_orientations);
 	cWindow.define_method("screen",  get_screen);
 	cWindow.define_method("root",    get_root);
 	cWindow.define_method("focus",   get_focus);
 	cWindow.define_method("painter", get_painter);
-	cWindow.define_method("on_activate",   on_activate);
-	cWindow.define_method("on_deactivate", on_deactivate);
 	cWindow.define_method("on_show",  on_show);
 	cWindow.define_method("on_hide",  on_hide);
 	cWindow.define_method("on_close", on_close);
+	cWindow.define_method("on_activate",   on_activate);
+	cWindow.define_method("on_deactivate", on_deactivate);
 	cWindow.define_method("on_update", on_update);
 	cWindow.define_method("on_draw",   on_draw);
 	cWindow.define_method("on_move",   on_move);
@@ -500,18 +767,29 @@ Init_reflex_window ()
 	cWindow.define_method("on_key",      on_key);
 	cWindow.define_method("on_key_down", on_key_down);
 	cWindow.define_method("on_key_up",   on_key_up);
+	cWindow.define_method("on_text",         on_text);
+	cWindow.define_method("on_text_preedit", on_text_preedit);
+	cWindow.define_method("on_text_commit",  on_text_commit);
 	cWindow.define_method("on_pointer",      on_pointer);
 	cWindow.define_method("on_pointer_down",   on_pointer_down);
 	cWindow.define_method("on_pointer_up",     on_pointer_up);
 	cWindow.define_method("on_pointer_move",   on_pointer_move);
 	cWindow.define_method("on_pointer_cancel", on_pointer_cancel);
+	cWindow.define_method("on_pointer_enter",  on_pointer_enter);
+	cWindow.define_method("on_pointer_leave",  on_pointer_leave);
 	cWindow.define_method("on_wheel",          on_wheel);
+	cWindow.define_method("on_file",      on_file);
+	cWindow.define_method("on_file_open", on_file_open);
+	cWindow.define_method("on_file_save", on_file_save);
 	cWindow.define_method("on_midi",           on_midi);
 	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_method("on_control_change", on_control_change);
 
+	cWindow.define_const("TITLEBAR_BUTTONS",    Reflex::Window::FLAG_TITLEBAR_BUTTONS);
+	cWindow.define_const("TITLEBAR_BACKGROUND", Reflex::Window::FLAG_TITLEBAR_BACKGROUND);
+
 	cWindow.define_const("ORIENTATION_PORTRAIT",  Reflex::Window::FLAG_PORTRAIT);
 	cWindow.define_const("ORIENTATION_LANDSCAPE", Reflex::Window::FLAG_LANDSCAPE);
 

data/include/reflex/application.h

@@ -16,6 +16,9 @@ namespace Reflex
 {
 
 
+	class Menu;
+
+
 	class Application : public Xot::RefCountable<>
 	{
 
@@ -41,6 +44,22 @@ namespace Reflex
 
 			virtual const char* name () const;
 
+			virtual void    set_menu (Menu* menu);
+
+			virtual       Menu* menu ();
+
+			virtual const Menu* menu () const;
+
+			virtual void    set_background (bool state);
+
+			virtual bool        background () const;
+
+			virtual void    set_background_menu (Menu* menu);
+
+			virtual       Menu* background_menu ();
+
+			virtual const Menu* background_menu () const;
+
 			virtual       window_iterator window_begin ();
 
 			virtual const_window_iterator window_begin () const;