reflexion 0.5.3 → 0.6.0

data/.doc/ext/reflex/menu.cpp

@@ -0,0 +1,302 @@
+#include "reflex/ruby/menu.h"
+
+
+#include <ranges>
+#include <rays/ruby/image.h>
+#include "reflex/exception.h"
+#include "reflex/ruby/selector.h"
+#include "reflex/ruby/view.h"
+#include "defs.h"
+#include "selector.h"
+
+
+RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::Menu)
+
+#define THIS      to<Reflex::Menu*>(self)
+
+#define CHECK     RUCY_CHECK_OBJ(Reflex::Menu, self)
+
+#define CALL(fun) RUCY_CALL_SUPER(THIS, fun)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return value(new Reflex::RubyMenu<Reflex::Menu>, klass);
+}
+
+static
+VALUE popup(VALUE self)
+{
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "Menu#popup", argc, 2, 3);
+
+	Reflex::View* view = NULL;
+	if (argv[0].is_a(Reflex::view_class()))
+	{
+		view = to<Reflex::View*>(argv[0]);
+		argc--;
+		argv++;
+	}
+	THIS->popup(view, to<Rays::Point>(argc, argv));
+	return self;
+}
+
+static
+VALUE add_child(VALUE self, VALUE child, VALUE index)
+{
+	CHECK;
+	THIS->add_child(to<Reflex::Menu*>(child), index.is_nil() ? -1 : to<int>(index));
+	return child;
+}
+
+static
+VALUE remove_child(VALUE self, VALUE child)
+{
+	CHECK;
+	THIS->remove_child(to<Reflex::Menu*>(child));
+	return child;
+}
+
+static
+VALUE clear_children(VALUE self)
+{
+	CHECK;
+	THIS->clear_children();
+	return self;
+}
+
+static
+VALUE find_children(VALUE self)
+{
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "Menu#find_children", argc, 1, 2);
+
+	bool recursive = (argc >= 2) ? to<bool>(argv[1]) : true;
+
+	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());
+}
+
+static
+VALUE set_label(VALUE self, VALUE label)
+{
+	CHECK;
+	THIS->set_label(label ? to<const char*>(label) : NULL);
+}
+
+static
+VALUE get_label(VALUE self)
+{
+	CHECK;
+	return value(THIS->label());
+}
+
+static
+VALUE set_image(VALUE self, VALUE image)
+{
+	CHECK;
+	THIS->set_image(image ? to<Rays::Image&>(image) : Rays::Image());
+	return image;
+}
+
+static
+VALUE get_image(VALUE self)
+{
+	CHECK;
+	const Rays::Image& image = THIS->image();
+	return image ? value(image) : nil();
+}
+
+static
+VALUE enable(VALUE self, VALUE state)
+{
+	CHECK;
+	THIS->enable(to<bool>(state));
+}
+
+static
+VALUE is_enabled(VALUE self)
+{
+	CHECK;
+	return value(THIS->is_enabled());
+}
+
+static
+VALUE check(VALUE self, VALUE state)
+{
+	CHECK;
+	THIS->check(to<bool>(state));
+}
+
+static
+VALUE is_checked(VALUE self)
+{
+	CHECK;
+	return value(THIS->is_checked());
+}
+
+
+static
+VALUE set_shortcut_key(VALUE self, VALUE key)
+{
+	CHECK;
+	THIS->set_shortcut(
+		key ? to<const char*>(key) : NULL,
+		THIS->shortcut_modifiers());
+}
+
+static
+VALUE get_shortcut_key(VALUE self)
+{
+	CHECK;
+	return value(THIS->shortcut_key());
+}
+
+static
+VALUE set_shortcut_modifiers(VALUE self, VALUE modifiers)
+{
+	CHECK;
+	THIS->set_shortcut(THIS->shortcut_key(), to<uint>(modifiers));
+}
+
+static
+VALUE get_shortcut_modifiers(VALUE self)
+{
+	CHECK;
+	return value(THIS->shortcut_modifiers());
+}
+
+static
+VALUE is_separator(VALUE self)
+{
+	CHECK;
+	return value(THIS->is_separator());
+}
+
+static
+VALUE get_parent(VALUE self)
+{
+	CHECK;
+	return value(THIS->parent());
+}
+
+static
+VALUE get_size(VALUE self)
+{
+	CHECK;
+	return value((int) THIS->size());
+}
+
+static
+VALUE is_empty(VALUE self)
+{
+	CHECK;
+	return value(THIS->empty());
+}
+
+static
+VALUE each(VALUE self)
+{
+	CHECK;
+
+	std::vector<Reflex::Menu::Ref> children(THIS->begin(), THIS->end());
+
+	Value ret;
+	for (auto& child : children)
+		ret = yield(value(child.get()));
+	return ret;
+}
+
+static
+VALUE on_show(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_show(to<Reflex::Event*>(event)));
+}
+
+static
+VALUE on_hide(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_hide(to<Reflex::Event*>(event)));
+}
+
+static
+VALUE on_open_submenu(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_open_submenu(to<Reflex::Event*>(event)));
+}
+
+static
+VALUE on_close_submenu(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_close_submenu(to<Reflex::Event*>(event)));
+}
+
+static
+VALUE on_click(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_click(to<Reflex::Event*>(event)));
+}
+
+
+static Class cMenu;
+
+void
+Init_reflex_menu ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cMenu = rb_define_class_under(mReflex, "Menu", rb_cObject);
+	rb_define_alloc_func(cMenu, alloc);
+	rb_define_method(cMenu, "popup", RUBY_METHOD_FUNC(popup), -1);
+	cMenu.define_method(   "add_child!",     add_child);
+	rb_define_method(cMenu, "remove_child", RUBY_METHOD_FUNC(remove_child), 1);
+	rb_define_method(cMenu, "clear_children", RUBY_METHOD_FUNC(clear_children), 0);
+	rb_define_method(cMenu, "find_children", RUBY_METHOD_FUNC(find_children), -1);
+	rb_define_method(cMenu, "label=", RUBY_METHOD_FUNC(set_label), 1);
+	rb_define_method(cMenu, "label", RUBY_METHOD_FUNC(get_label), 0);
+	rb_define_method(cMenu, "image=", RUBY_METHOD_FUNC(set_image), 1);
+	rb_define_method(cMenu, "image", RUBY_METHOD_FUNC(get_image), 0);
+	cMenu.define_method("enable!",     enable);
+	cMenu.define_method("enabled?", is_enabled);
+	cMenu.define_method("check!",      check);
+	cMenu.define_method("checked?", is_checked);
+	rb_define_method(cMenu, "shortcut_key=", RUBY_METHOD_FUNC(set_shortcut_key), 1);
+	rb_define_method(cMenu, "shortcut_key", RUBY_METHOD_FUNC(get_shortcut_key), 0);
+	rb_define_method(cMenu, "shortcut_modifiers=", RUBY_METHOD_FUNC(set_shortcut_modifiers), 1);
+	rb_define_method(cMenu, "shortcut_modifiers", RUBY_METHOD_FUNC(get_shortcut_modifiers), 0);
+	cMenu.define_method("separator?", is_separator);
+	rb_define_method(cMenu, "parent", RUBY_METHOD_FUNC(get_parent), 0);
+	rb_define_method(cMenu, "size", RUBY_METHOD_FUNC(get_size), 0);
+	cMenu.define_method("empty?", is_empty);
+	cMenu.define_method("each!", each);
+	rb_define_method(cMenu, "on_show", RUBY_METHOD_FUNC(on_show), 1);
+	rb_define_method(cMenu, "on_hide", RUBY_METHOD_FUNC(on_hide), 1);
+	rb_define_method(cMenu, "on_open_submenu", RUBY_METHOD_FUNC(on_open_submenu), 1);
+	rb_define_method(cMenu, "on_close_submenu", RUBY_METHOD_FUNC(on_close_submenu), 1);
+	rb_define_method(cMenu, "on_click", RUBY_METHOD_FUNC(on_click), 1);
+
+	define_wrapper_equality_methods<Reflex::Menu>(cMenu);
+	define_selector_methods<Reflex::Menu>(cMenu);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	menu_class ()
+	{
+		return cMenu;
+	}
+
+
+}// Reflex

data/.doc/ext/reflex/native.cpp

@@ -4,8 +4,8 @@
 void Init_reflex ();
 void Init_reflex_exception ();
 
-void Init_reflex_pointer ();
 void Init_reflex_selector ();
+void Init_reflex_pointer ();
 void Init_reflex_style ();
 void Init_reflex_style_length ();
 void Init_reflex_timer ();
@@ -35,10 +35,19 @@ void Init_reflex_line_shape ();
 void Init_reflex_rect_shape ();
 void Init_reflex_ellipse_shape ();
 
+void Init_reflex_pin ();
+void Init_reflex_constraint ();
+void Init_reflex_snap_constraint ();
+void Init_reflex_link_constraint ();
+void Init_reflex_wheel_constraint ();
+void Init_reflex_chase_constraint ();
+
 void Init_reflex_application ();
-void Init_reflex_screen ();
 void Init_reflex_window ();
 void Init_reflex_view ();
+void Init_reflex_menu ();
+void Init_reflex_screen ();
+void Init_reflex_clipboard ();
 
 void Init_reflex_device ();
 void Init_reflex_midi ();
@@ -56,8 +65,8 @@ Init_reflex_ext ()
 	Init_reflex();
 	Init_reflex_exception();
 
-	Init_reflex_pointer();
 	Init_reflex_selector();
+	Init_reflex_pointer();
 	Init_reflex_style();
 	Init_reflex_style_length();
 	Init_reflex_timer();
@@ -87,10 +96,19 @@ Init_reflex_ext ()
 	Init_reflex_rect_shape();
 	Init_reflex_ellipse_shape();
 
+	Init_reflex_pin();
+	Init_reflex_constraint();
+	Init_reflex_snap_constraint();
+	Init_reflex_link_constraint();
+	Init_reflex_wheel_constraint();
+	Init_reflex_chase_constraint();
+
 	Init_reflex_application();
-	Init_reflex_screen();
 	Init_reflex_window();
 	Init_reflex_view();
+	Init_reflex_menu();
+	Init_reflex_screen();
+	Init_reflex_clipboard();
 
 	Init_reflex_device();
 	Init_reflex_midi();

data/.doc/ext/reflex/pin.cpp

@@ -0,0 +1,156 @@
+#include "reflex/ruby/pin.h"
+
+
+#include <rays/ruby/point.h>
+#include "reflex/ruby/constraint.h"
+#include "reflex/ruby/view.h"
+#include "defs.h"
+
+
+RUCY_DEFINE_VALUE_OR_ARRAY_FROM_TO(REFLEX_EXPORT, Reflex::Pin)
+
+#define THIS  to<Reflex::Pin*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Reflex::Pin, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return new_type<Reflex::Pin>(klass);
+}
+
+static
+VALUE initialize(VALUE self)
+{
+	CHECK;
+	*THIS = to<Reflex::Pin>(argc, argv);
+}
+
+static
+VALUE initialize_copy(VALUE self, VALUE obj)
+{
+	CHECK;
+	*THIS = to<Reflex::Pin&>(obj);
+}
+
+static
+VALUE snap(VALUE self)
+{
+	CHECK;
+	return value(THIS->snap(to<Reflex::Pin>(argc, argv)));
+}
+
+static
+VALUE link(VALUE self)
+{
+	CHECK;
+	return value(THIS->link(to<Reflex::Pin>(argc, argv)));
+}
+
+static
+VALUE wheel(VALUE self)
+{
+	CHECK;
+	return value(THIS->wheel(to<Reflex::Pin>(argc, argv)));
+}
+
+static
+VALUE chase(VALUE self)
+{
+	CHECK;
+	return value(THIS->chase(to<Reflex::Pin>(argc, argv)));
+}
+
+static
+VALUE get_view(VALUE self)
+{
+	CHECK;
+	return value(THIS->view());
+}
+
+static
+VALUE get_position(VALUE self)
+{
+	CHECK;
+	const Rays::Point* pos = THIS->position();
+	return pos ? value(*pos) : nil();
+}
+
+
+static Class cPin;
+
+void
+Init_reflex_pin ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cPin = rb_define_class_under(mReflex, "Pin", rb_cObject);
+	rb_define_alloc_func(cPin, alloc);
+	rb_define_private_method(cPin, "initialize", RUBY_METHOD_FUNC(initialize), -1);
+	rb_define_private_method(cPin, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
+	cPin.define_private_method("snap!",  snap);
+	cPin.define_private_method("link!",  link);
+	cPin.define_private_method("wheel!", wheel);
+	cPin.define_private_method("chase!", chase);
+	rb_define_method(cPin, "view", RUBY_METHOD_FUNC(get_view), 0);
+	rb_define_method(cPin, "position", RUBY_METHOD_FUNC(get_position), 0);
+}
+
+
+namespace Rucy
+{
+
+
+	template <> REFLEX_EXPORT Reflex::Pin
+	value_to<Reflex::Pin> (int argc, const Value* argv, bool convert)
+	{
+		if (argc == 1 && argv && argv->is_array())
+		{
+			argc = argv->size();
+			argv = argv->as_array();
+		}
+
+		if (convert)
+		{
+			if (argc == 0 || argv->is_nil())
+				return Reflex::Pin();
+
+			if (argv->is_a(Reflex::view_class()))
+			{
+				Reflex::View* view = value_to<Reflex::View*>(*argv);
+				argc -= 1;
+				argv += 1;
+
+				if (argc == 0)
+					return Reflex::Pin(view);
+				else
+					return Reflex::Pin(view, value_to<Rays::Point>(argc, argv, convert));
+			}
+
+			if (!argv->is_a(Reflex::pin_class()))
+				return Reflex::Pin(value_to<Rays::Point>(argc, argv, convert));
+		}
+
+		if (argc != 1)
+			argument_error(__FILE__, __LINE__);
+
+		return value_to<Reflex::Pin&>(*argv, convert);
+	}
+
+
+}// Rucy
+
+
+namespace Reflex
+{
+
+
+	Class
+	pin_class ()
+	{
+		return cPin;
+	}
+
+
+}// Reflex

data/.doc/ext/reflex/pointer.cpp

@@ -150,6 +150,8 @@ Init_reflex_pointer ()
 	cPointer.define_const("UP",          Reflex::Pointer::UP);
 	cPointer.define_const("MOVE",        Reflex::Pointer::MOVE);
 	cPointer.define_const("CANCEL",      Reflex::Pointer::CANCEL);
+	cPointer.define_const("ENTER",       Reflex::Pointer::ENTER);
+	cPointer.define_const("LEAVE",       Reflex::Pointer::LEAVE);
 	cPointer.define_const("STAY",        Reflex::Pointer::STAY);
 }
 

data/.doc/ext/reflex/pointer_event.cpp

@@ -85,7 +85,7 @@ VALUE each(VALUE self)
 
 	Value ret;
 	for (size_t i = 0, size = THIS->size(); i < size; ++i)
-		ret = rb_yield(value((*THIS)[i]));
+		ret = yield(value((*THIS)[i]));
 	return ret;
 }
 

data/.doc/ext/reflex/reflex.cpp

@@ -2,9 +2,11 @@
 
 
 #include "reflex/ruby/view.h"
+#include "reflex/ruby/constraint.h"
 #include "reflex/ruby/timer.h"
 #include "reflex/ruby/midi.h"
 #include "../../src/window.h"
+#include "../../src/constraint.h"
 #include "../../src/timer.h"
 #include "../../src/midi.h"
 #include "defs.h"
@@ -16,6 +18,30 @@ create_root_view ()
 	return new Reflex::RubyView<Reflex::View>();
 }
 
+static Reflex::SnapConstraint*
+create_snap_constraint ()
+{
+	return new Reflex::RubyConstraint<Reflex::SnapConstraint>();
+}
+
+static Reflex::LinkConstraint*
+create_link_constraint ()
+{
+	return new Reflex::RubyConstraint<Reflex::LinkConstraint>();
+}
+
+static Reflex::WheelConstraint*
+create_wheel_constraint ()
+{
+	return new Reflex::RubyConstraint<Reflex::WheelConstraint>();
+}
+
+static Reflex::ChaseConstraint*
+create_chase_constraint ()
+{
+	return new Reflex::RubyConstraint<Reflex::ChaseConstraint>();
+}
+
 static Reflex::Timer*
 create_timer ()
 {
@@ -35,9 +61,13 @@ static
 VALUE init(VALUE self)
 {
 	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);
+	Reflex::         Window_set_create_root_view_fun(create_root_view);
+	Reflex:: SnapConstraint_set_create_fun(create_snap_constraint);
+	Reflex:: LinkConstraint_set_create_fun(create_link_constraint);
+	Reflex::WheelConstraint_set_create_fun(create_wheel_constraint);
+	Reflex::ChaseConstraint_set_create_fun(create_chase_constraint);
+	Reflex::          Timer_set_create_fun(create_timer);
+	Reflex::           MIDI_set_create_fun(create_midi);
 
 	return self;
 }
@@ -45,9 +75,13 @@ VALUE init(VALUE self)
 static
 VALUE fin(VALUE self)
 {
-	Reflex::Window_set_create_root_view_fun(NULL);
-	Reflex::Timer_set_create_fun(NULL);
-	Reflex::MIDI_set_create_fun(NULL);
+	Reflex::         Window_set_create_root_view_fun(NULL);
+	Reflex:: SnapConstraint_set_create_fun(NULL);
+	Reflex:: LinkConstraint_set_create_fun(NULL);
+	Reflex::WheelConstraint_set_create_fun(NULL);
+	Reflex::ChaseConstraint_set_create_fun(NULL);
+	Reflex::          Timer_set_create_fun(NULL);
+	Reflex::           MIDI_set_create_fun(NULL);
 	Reflex::fin();
 
 	return self;
@@ -239,7 +273,7 @@ Init_reflex ()
 	DEFINE_CONST(KEY_SLEEP);
 	DEFINE_CONST(KEY_EXEC);
 	DEFINE_CONST(KEY_PRINT);
-	DEFINE_CONST(KEY_APPS);
+	DEFINE_CONST(KEY_CONTEXT_MENU);
 	DEFINE_CONST(KEY_SELECT);
 	DEFINE_CONST(KEY_CLEAR);
 
@@ -304,6 +338,7 @@ Init_reflex ()
 	DEFINE_CONST(MOD_FUNCTION);
 	DEFINE_CONST(MOD_NUMPAD);
 	DEFINE_CONST(MOD_CAPS);
+	DEFINE_CONST(MOD_SCROLL);
 
 	#undef DEFINE_CONST
 }

data/.doc/ext/reflex/selector.cpp

@@ -1,7 +1,6 @@
 #include "reflex/ruby/selector.h"
 
 
-#include <assert.h>
 #include "defs.h"
 
 
@@ -78,7 +77,7 @@ VALUE each_tag(VALUE self)
 	Value ret;
 	Reflex::Selector::const_iterator end = C_THIS->end();
 	for (Reflex::Selector::const_iterator it = C_THIS->begin(); it != end; ++it)
-		ret = rb_yield(value(*it));
+		ret = yield(value(*it));
 	return ret;
 }
 
@@ -134,13 +133,14 @@ namespace Rucy
 	template <> REFLEX_EXPORT Reflex::Selector
 	value_to<Reflex::Selector> (int argc, const Value* argv, bool convert)
 	{
-		if (argc == 1 && argv->is_array())
+		if (argc == 1 && argv && argv->is_array())
 		{
 			argc = argv->size();
 			argv = argv->as_array();
 		}
 
-		assert(argc > 0 && argv);
+		if (argc <= 0 || !argv)
+			argument_error(__FILE__, __LINE__);
 
 		if (convert)
 		{