reflexion 0.5.3 → 0.7.0

data/ext/reflex/menu.cpp

@@ -0,0 +1,331 @@
+#include "reflex/ruby/menu.h"
+
+
+#include <ranges>
+#include <rays/ruby/image.h>
+#include "reflex/exception.h"
+#include "reflex/ruby/reflex.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_PTR(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<Reflex::KeyCode>(key) : Reflex::KEY_NONE,
+		THIS->shortcut_modifiers());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_shortcut_key)
+{
+	CHECK;
+	return value((int) 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_private_method("set_shortcut_key!", set_shortcut_key);
+	cMenu.define_private_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/midi.cpp

@@ -10,7 +10,7 @@ RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::MIDI)
 
 #define THIS      to<Reflex::MIDI*>(self)
 
-#define CHECK     RUCY_CHECK_OBJECT(Reflex::MIDI, self)
+#define CHECK     RUCY_CHECK_OBJ(Reflex::MIDI, self)
 
 #define CALL(fun) RUCY_CALL_SUPER(THIS, fun)
 
@@ -66,11 +66,18 @@ static
 RUCY_DEF0(s_get_all)
 {
 	auto list = Reflex::MIDI::all() |
-		std::views::transform([](auto& ref) {return value(ref);});
+		std::views::transform([](Reflex::MIDI::Ref ref) {return value(ref);});
 	return array(list.begin(), list.end());
 }
 RUCY_END
 
+static
+RUCY_DEF0(s_enable)
+{
+	Reflex::enable_midi();
+}
+RUCY_END
+
 
 static Class cMIDI;
 
@@ -86,7 +93,8 @@ Init_reflex_midi ()
 	cMIDI.define_method("on_note_on",        on_note_on);
 	cMIDI.define_method("on_note_off",       on_note_off);
 	cMIDI.define_method("on_control_change", on_control_change);
-	cMIDI.define_singleton_method("all", s_get_all);
+	cMIDI.define_singleton_method("all",    s_get_all);
+	cMIDI.define_singleton_method("enable", s_enable);
 
 	define_wrapper_equality_methods<Reflex::MIDI>(cMIDI);
 }

data/ext/reflex/midi_event.cpp

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

data/ext/reflex/motion_event.cpp

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

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 ();
@@ -19,15 +19,18 @@ void Init_reflex_frame_event ();
 void Init_reflex_scroll_event ();
 void Init_reflex_focus_event ();
 void Init_reflex_key_event ();
+void Init_reflex_text_event ();
 void Init_reflex_pointer_event ();
 void Init_reflex_wheel_event ();
-void Init_reflex_midi_event ();
-void Init_reflex_note_event ();
-void Init_reflex_control_change_event ();
 void Init_reflex_capture_event ();
 void Init_reflex_timer_event ();
 void Init_reflex_contact_event ();
 void Init_reflex_motion_event ();
+void Init_reflex_file_event ();
+void Init_reflex_color_event ();
+void Init_reflex_midi_event ();
+void Init_reflex_note_event ();
+void Init_reflex_control_change_event ();
 
 void Init_reflex_shape ();
 void Init_reflex_polygon_shape ();
@@ -35,13 +38,25 @@ 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_file_dialog ();
+void Init_reflex_color_picker ();
 
 void Init_reflex_device ();
 void Init_reflex_midi ();
+void Init_reflex_gamepad ();
 
 void Init_reflex_image_view ();
 
@@ -56,8 +71,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();
@@ -71,15 +86,18 @@ Init_reflex_ext ()
 	Init_reflex_scroll_event();
 	Init_reflex_focus_event();
 	Init_reflex_key_event();
+	Init_reflex_text_event();
 	Init_reflex_pointer_event();
 	Init_reflex_wheel_event();
-	Init_reflex_midi_event();
-	Init_reflex_note_event();
-	Init_reflex_control_change_event();
 	Init_reflex_capture_event();
 	Init_reflex_timer_event();
 	Init_reflex_contact_event();
 	Init_reflex_motion_event();
+	Init_reflex_file_event();
+	Init_reflex_color_event();
+	Init_reflex_midi_event();
+	Init_reflex_note_event();
+	Init_reflex_control_change_event();
 
 	Init_reflex_shape();
 	Init_reflex_polygon_shape();
@@ -87,13 +105,25 @@ 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_file_dialog();
+	Init_reflex_color_picker();
 
 	Init_reflex_device();
 	Init_reflex_midi();
+	Init_reflex_gamepad();
 
 	Init_reflex_image_view();
 

data/ext/reflex/note_event.cpp

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

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_PTR(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

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

@@ -11,7 +11,7 @@ RUCY_DEFINE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::PointerEvent)
 
 #define THIS  to<Reflex::PointerEvent*>(self)
 
-#define CHECK RUCY_CHECK_OBJ(Reflex::PointerEvent, self)
+#define CHECK RUCY_CHECK_PTR(Reflex::PointerEvent, self)
 
 
 static
@@ -33,7 +33,7 @@ RUCY_DEFN(initialize)
 	for (size_t i = 0; i < argc; ++i)
 		pointers.emplace_back(to<Reflex::Pointer&>(argv[i]));
 
-	*THIS = Reflex::PointerEvent(&pointers[0], pointers.size());
+	*THIS = Reflex::PointerEvent(pointers.data(), pointers.size());
 	return rb_call_super(0, NULL);
 }
 RUCY_END
@@ -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