reflexion 0.5.3 → 0.7.0

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

@@ -0,0 +1,178 @@
+#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::LinkConstraint)
+
+#define THIS  to<Reflex::LinkConstraint*>(self)
+
+#define CHECK RUCY_CHECK_PTR(Reflex::LinkConstraint, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	Reflex::reflex_error(
+		__FILE__, __LINE__, "can not instantiate LinkConstraint class");
+}
+
+static
+VALUE set_axis(VALUE self)
+{
+	CHECK;
+	if (argc == 1 && argv[0].is_nil())
+		THIS->clear_axis();
+	else
+		THIS->set_axis(to<Rays::Point>(argc, argv));
+}
+
+static
+VALUE get_axis(VALUE self)
+{
+	CHECK;
+	return THIS->has_axis() ? value(THIS->axis()) : nil();
+}
+
+static
+VALUE set_distance(VALUE self, VALUE distance)
+{
+	CHECK;
+	if (distance.is_nil())
+		THIS->clear_distance();
+	else
+		THIS->set_distance(to<coord>(distance));
+}
+
+static
+VALUE get_distance(VALUE self)
+{
+	CHECK;
+	return value(THIS->distance());
+}
+
+static
+VALUE has_distance(VALUE self)
+{
+	CHECK;
+	return value(THIS->has_distance());
+}
+
+static
+VALUE current_distance(VALUE self)
+{
+	CHECK;
+	return value(THIS->current_distance());
+}
+
+static
+VALUE set_range(VALUE self, VALUE min, VALUE max)
+{
+	CHECK;
+	THIS->set_range(to<coord>(min), to<coord>(max));
+}
+
+static
+VALUE clear_range(VALUE self)
+{
+	CHECK;
+	THIS->clear_range();
+}
+
+static
+VALUE range_min(VALUE self)
+{
+	CHECK;
+	return value(THIS->range_min());
+}
+
+static
+VALUE range_max(VALUE self)
+{
+	CHECK;
+	return value(THIS->range_max());
+}
+
+static
+VALUE has_range(VALUE self)
+{
+	CHECK;
+	return value(THIS->has_range());
+}
+
+static
+VALUE set_motor(VALUE self, VALUE pixels_per_second)
+{
+	CHECK;
+	if (pixels_per_second.is_nil())
+		THIS->clear_motor();
+	else
+		THIS->set_motor(to<coord>(pixels_per_second));
+}
+
+static
+VALUE get_motor(VALUE self)
+{
+	CHECK;
+	return THIS->has_motor() ? value(THIS->motor()) : nil();
+}
+
+static
+VALUE set_force(VALUE self, VALUE max_force)
+{
+	CHECK;
+	if (max_force.is_nil())
+		THIS->clear_force();
+	else
+		THIS->set_force(to<float>(max_force));
+}
+
+static
+VALUE get_force(VALUE self)
+{
+	CHECK;
+	return THIS->has_force() ? value(THIS->force()) : nil();
+}
+
+
+static Class cLinkConstraint;
+
+void
+Init_reflex_link_constraint ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cLinkConstraint = mReflex.define_class("LinkConstraint", Reflex::constraint_class());
+	rb_define_alloc_func(cLinkConstraint, alloc);
+	rb_define_method(cLinkConstraint, "axis=", RUBY_METHOD_FUNC(set_axis), -1);
+	rb_define_method(cLinkConstraint, "axis", RUBY_METHOD_FUNC(get_axis), 0);
+	rb_define_method(cLinkConstraint, "distance=", RUBY_METHOD_FUNC(set_distance), 1);
+	rb_define_method(cLinkConstraint, "distance", RUBY_METHOD_FUNC(get_distance), 0);
+	rb_define_method(cLinkConstraint, "current_distance", RUBY_METHOD_FUNC(current_distance), 0);
+	cLinkConstraint.define_private_method(  "set_range!",   set_range);
+	cLinkConstraint.define_private_method("clear_range!", clear_range);
+	cLinkConstraint.define_private_method(      "range_min!",   range_min);
+	cLinkConstraint.define_private_method(      "range_max!",   range_max);
+	cLinkConstraint.define_private_method(  "has_range!",   has_range);
+	rb_define_method(cLinkConstraint, "motor=", RUBY_METHOD_FUNC(set_motor), 1);
+	rb_define_method(cLinkConstraint, "motor", RUBY_METHOD_FUNC(get_motor), 0);
+	rb_define_method(cLinkConstraint, "force=", RUBY_METHOD_FUNC(set_force), 1);
+	rb_define_method(cLinkConstraint, "force", RUBY_METHOD_FUNC(get_force), 0);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	link_constraint_class ()
+	{
+		return cLinkConstraint;
+	}
+
+
+}// Reflex

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

@@ -0,0 +1,303 @@
+#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
+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<Reflex::KeyCode>(key) : Reflex::KEY_NONE,
+		THIS->shortcut_modifiers());
+}
+
+static
+VALUE get_shortcut_key(VALUE self)
+{
+	CHECK;
+	return value((int) 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);
+	cMenu.define_private_method("set_shortcut_key!", set_shortcut_key);
+	cMenu.define_private_method("shortcut_key!",     get_shortcut_key);
+	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/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)
 
@@ -60,10 +60,16 @@ static
 VALUE s_get_all(VALUE self)
 {
 	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());
 }
 
+static
+VALUE s_enable(VALUE self)
+{
+	Reflex::enable_midi();
+}
+
 
 static Class cMIDI;
 
@@ -80,6 +86,7 @@ Init_reflex_midi ()
 	rb_define_method(cMIDI, "on_note_off", RUBY_METHOD_FUNC(on_note_off), 1);
 	rb_define_method(cMIDI, "on_control_change", RUBY_METHOD_FUNC(on_control_change), 1);
 	rb_define_singleton_method(cMIDI, "all", RUBY_METHOD_FUNC(s_get_all), 0);
+	rb_define_singleton_method(cMIDI, "enable", RUBY_METHOD_FUNC(s_enable), 0);
 
 	define_wrapper_equality_methods<Reflex::MIDI>(cMIDI);
 }

data/.doc/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/.doc/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/.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 ();
@@ -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/.doc/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