reflexion 0.5.2 → 0.6.0

data/ext/reflex/menu.cpp

@@ -0,0 +1,330 @@
+#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
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return value(new Reflex::RubyMenu<Reflex::Menu>, klass);
+}
+RUCY_END
+
+static
+RUCY_DEFN(popup)
+{
+	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;
+}
+RUCY_END
+
+static
+RUCY_DEF2(add_child, child, index)
+{
+	CHECK;
+	THIS->add_child(to<Reflex::Menu*>(child), index.is_nil() ? -1 : to<int>(index));
+	return child;
+}
+RUCY_END
+
+static
+RUCY_DEF1(remove_child, child)
+{
+	CHECK;
+	THIS->remove_child(to<Reflex::Menu*>(child));
+	return child;
+}
+RUCY_END
+
+static
+RUCY_DEF0(clear_children)
+{
+	CHECK;
+	THIS->clear_children();
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEFN(find_children)
+{
+	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());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_label, label)
+{
+	CHECK;
+	THIS->set_label(label ? to<const char*>(label) : NULL);
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_label)
+{
+	CHECK;
+	return value(THIS->label());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_image, image)
+{
+	CHECK;
+	THIS->set_image(image ? to<Rays::Image&>(image) : Rays::Image());
+	return image;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_image)
+{
+	CHECK;
+	const Rays::Image& image = THIS->image();
+	return image ? value(image) : nil();
+}
+RUCY_END
+
+static
+RUCY_DEF1(enable, state)
+{
+	CHECK;
+	THIS->enable(to<bool>(state));
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_enabled)
+{
+	CHECK;
+	return value(THIS->is_enabled());
+}
+RUCY_END
+
+static
+RUCY_DEF1(check, state)
+{
+	CHECK;
+	THIS->check(to<bool>(state));
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_checked)
+{
+	CHECK;
+	return value(THIS->is_checked());
+}
+RUCY_END
+
+
+static
+RUCY_DEF1(set_shortcut_key, key)
+{
+	CHECK;
+	THIS->set_shortcut(
+		key ? to<const char*>(key) : NULL,
+		THIS->shortcut_modifiers());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_shortcut_key)
+{
+	CHECK;
+	return value(THIS->shortcut_key());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_shortcut_modifiers, modifiers)
+{
+	CHECK;
+	THIS->set_shortcut(THIS->shortcut_key(), to<uint>(modifiers));
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_shortcut_modifiers)
+{
+	CHECK;
+	return value(THIS->shortcut_modifiers());
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_separator)
+{
+	CHECK;
+	return value(THIS->is_separator());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_parent)
+{
+	CHECK;
+	return value(THIS->parent());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_size)
+{
+	CHECK;
+	return value((int) THIS->size());
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_empty)
+{
+	CHECK;
+	return value(THIS->empty());
+}
+RUCY_END
+
+static
+RUCY_DEF0(each)
+{
+	CHECK;
+
+	std::vector<Reflex::Menu::Ref> children(THIS->begin(), THIS->end());
+
+	Value ret;
+	for (auto& child : children)
+		ret = yield(value(child.get()));
+	return ret;
+}
+RUCY_END
+
+static
+RUCY_DEF1(on_show, event)
+{
+	CHECK;
+	CALL(on_show(to<Reflex::Event*>(event)));
+}
+RUCY_END
+
+static
+RUCY_DEF1(on_hide, event)
+{
+	CHECK;
+	CALL(on_hide(to<Reflex::Event*>(event)));
+}
+RUCY_END
+
+static
+RUCY_DEF1(on_open_submenu, event)
+{
+	CHECK;
+	CALL(on_open_submenu(to<Reflex::Event*>(event)));
+}
+RUCY_END
+
+static
+RUCY_DEF1(on_close_submenu, event)
+{
+	CHECK;
+	CALL(on_close_submenu(to<Reflex::Event*>(event)));
+}
+RUCY_END
+
+static
+RUCY_DEF1(on_click, event)
+{
+	CHECK;
+	CALL(on_click(to<Reflex::Event*>(event)));
+}
+RUCY_END
+
+
+static Class cMenu;
+
+void
+Init_reflex_menu ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cMenu = mReflex.define_class("Menu");
+	cMenu.define_alloc_func(alloc);
+	cMenu.define_method("popup", popup);
+	cMenu.define_method(   "add_child!",     add_child);
+	cMenu.define_method("remove_child",   remove_child);
+	cMenu.define_method( "clear_children", clear_children);
+	cMenu.define_method(  "find_children",  find_children);
+	cMenu.define_method("label=", set_label);
+	cMenu.define_method("label",  get_label);
+	cMenu.define_method("image=", set_image);
+	cMenu.define_method("image",  get_image);
+	cMenu.define_method("enable!",     enable);
+	cMenu.define_method("enabled?", is_enabled);
+	cMenu.define_method("check!",      check);
+	cMenu.define_method("checked?", is_checked);
+	cMenu.define_method("shortcut_key=",       set_shortcut_key);
+	cMenu.define_method("shortcut_key",        get_shortcut_key);
+	cMenu.define_method("shortcut_modifiers=", set_shortcut_modifiers);
+	cMenu.define_method("shortcut_modifiers",  get_shortcut_modifiers);
+	cMenu.define_method("separator?", is_separator);
+	cMenu.define_method("parent", get_parent);
+	cMenu.define_method("size",  get_size);
+	cMenu.define_method("empty?", is_empty);
+	cMenu.define_method("each!", each);
+	cMenu.define_method("on_show",        on_show);
+	cMenu.define_method("on_hide",        on_hide);
+	cMenu.define_method("on_open_submenu",  on_open_submenu);
+	cMenu.define_method("on_close_submenu", on_close_submenu);
+	cMenu.define_method("on_click",       on_click);
+
+	define_wrapper_equality_methods<Reflex::Menu>(cMenu);
+	define_selector_methods<Reflex::Menu>(cMenu);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	menu_class ()
+	{
+		return cMenu;
+	}
+
+
+}// Reflex

data/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/ext/reflex/pin.cpp

@@ -0,0 +1,165 @@
+#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
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return new_type<Reflex::Pin>(klass);
+}
+RUCY_END
+
+static
+RUCY_DEFN(initialize)
+{
+	CHECK;
+	*THIS = to<Reflex::Pin>(argc, argv);
+}
+RUCY_END
+
+static
+RUCY_DEF1(initialize_copy, obj)
+{
+	CHECK;
+	*THIS = to<Reflex::Pin&>(obj);
+}
+RUCY_END
+
+static
+RUCY_DEFN(snap)
+{
+	CHECK;
+	return value(THIS->snap(to<Reflex::Pin>(argc, argv)));
+}
+RUCY_END
+
+static
+RUCY_DEFN(link)
+{
+	CHECK;
+	return value(THIS->link(to<Reflex::Pin>(argc, argv)));
+}
+RUCY_END
+
+static
+RUCY_DEFN(wheel)
+{
+	CHECK;
+	return value(THIS->wheel(to<Reflex::Pin>(argc, argv)));
+}
+RUCY_END
+
+static
+RUCY_DEFN(chase)
+{
+	CHECK;
+	return value(THIS->chase(to<Reflex::Pin>(argc, argv)));
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_view)
+{
+	CHECK;
+	return value(THIS->view());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_position)
+{
+	CHECK;
+	const Rays::Point* pos = THIS->position();
+	return pos ? value(*pos) : nil();
+}
+RUCY_END
+
+
+static Class cPin;
+
+void
+Init_reflex_pin ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cPin = mReflex.define_class("Pin");
+	cPin.define_alloc_func(alloc);
+	cPin.define_private_method("initialize",      initialize);
+	cPin.define_private_method("initialize_copy", initialize_copy);
+	cPin.define_private_method("snap!",  snap);
+	cPin.define_private_method("link!",  link);
+	cPin.define_private_method("wheel!", wheel);
+	cPin.define_private_method("chase!", chase);
+	cPin.define_method("view",     get_view);
+	cPin.define_method("position", get_position);
+}
+
+
+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/ext/reflex/pointer.cpp

@@ -163,6 +163,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/ext/reflex/pointer_event.cpp

@@ -92,7 +92,7 @@ RUCY_DEF0(each)
 
 	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;
 }
 RUCY_END

data/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
 RUCY_DEF0(init)
 {
 	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;
 }
@@ -46,9 +76,13 @@ RUCY_END
 static
 RUCY_DEF0(fin)
 {
-	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;
@@ -242,7 +276,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);
 
@@ -307,6 +341,7 @@ Init_reflex ()
 	DEFINE_CONST(MOD_FUNCTION);
 	DEFINE_CONST(MOD_NUMPAD);
 	DEFINE_CONST(MOD_CAPS);
+	DEFINE_CONST(MOD_SCROLL);
 
 	#undef DEFINE_CONST
 }

data/ext/reflex/selector.cpp

@@ -1,7 +1,6 @@
 #include "reflex/ruby/selector.h"
 
 
-#include <assert.h>
 #include "defs.h"
 
 
@@ -86,7 +85,7 @@ RUCY_DEF0(each_tag)
 	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;
 }
 RUCY_END
@@ -146,13 +145,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)
 		{

data/ext/reflex/selector.h

@@ -83,7 +83,7 @@ RUCY_DEF0(each_tag)
 	Rucy::Value ret;
 	Reflex::Selector::const_iterator end = this_->tag_end();
 	for (Reflex::Selector::const_iterator it = this_->tag_begin(); it != end; ++it)
-		ret = rb_yield(Rucy::value(*it));
+		ret = Rucy::yield(Rucy::value(*it));
 	return ret;
 }
 RUCY_END