reflexion 0.5.2 → 0.6.0

data/ChangeLog.md

@@ -1,6 +1,36 @@
 # reflex ChangeLog
 
 
+## [v0.6.0] - 2026-08-04
+
+- [BREAKING] Read modifiers as symbols from every event that carries them
+- [BREAKING] Rename KEY_APPS to KEY_CONTEXT_MENU and fix its macOS keycode
+- [BREAKING] Sync view frames on View#update_world, drop its duration argument
+- Add Menu class and Application#menu
+- Add Constraint classes backed by Box2D joints
+- Add Clipboard class
+- Add on_pointer_enter/leave event handlers to View and Window
+- Add on_activate/deactivate event handlers to View
+- Add index argument to View#add_child and #add_shape
+- Add locks: option to modifiers for excluding caps/num/scroll lock
+- Add midi and gamepad to the umbrella header
+- Add menu and constraint samples
+- Give View#each_* an enumerator form and array-returning plural accessors
+- Make View#each_* safe against removals during iteration
+- Fill in the Windows virtual-key codes for punctuation and numpad operators
+- Report fn+return as the keypad enter on macOS
+
+- Fix crash when an empty array is passed where a Pin or Selector is expected
+- Fix get_modifiers reporting only the first modifier held
+- Fix reversed selector match in find_shapes and find_styles
+- Fix view clipping to track ancestor zoom and position in screen space
+
+
+## [v0.5.3] - 2026-06-23
+
+- Run vendor and erb for reflex itself in pod.rake setup
+
+
 ## [v0.5.2] - 2026-06-23
 
 - Add include, ext, vendor to podspec preserve_paths

data/README.md

@@ -74,6 +74,7 @@ $ gem install reflexion
 | `Reflex::Window`         | OS-level window with title, frame, flags (closable / resizable / fullscreen / portrait / landscape) |
 | `Reflex::View`           | Recursive UI node: position, size, transform, styles, child views, optional clipping / caching |
 | `Reflex::Screen`         | Information about a display monitor                                     |
+| `Reflex::Clipboard`      | Read and write the system clipboard                                     |
 | `Reflex::Timer`          | One-shot or interval timer that delivers `TimerEvent`                   |
 
 ### Shapes (drawing + physics body)

data/VERSION

@@ -1 +1 @@
-0.5.2
+0.6.0

data/ext/reflex/application.cpp

@@ -1,6 +1,7 @@
 #include "reflex/ruby/application.h"
 
 
+#include "reflex/ruby/menu.h"
 #include "reflex/ruby/window.h"
 #include "defs.h"
 
@@ -57,6 +58,23 @@ RUCY_DEF0(get_name)
 }
 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_DEF0(each_window)
 {
@@ -64,7 +82,7 @@ RUCY_DEF0(each_window)
 
 	Value ret;
 	for (auto it = THIS->window_begin(), end = THIS->window_end(); it != end; ++it)
-		ret = rb_yield(value(it->get()));
+		ret = yield(value(it->get()));
 	return ret;
 }
 RUCY_END
@@ -150,6 +168,8 @@ Init_reflex_application ()
 	cApplication.define_method("quit",  quit);
 	cApplication.define_method("name=", set_name);
 	cApplication.define_method("name",  get_name);
+	cApplication.define_method("menu=", set_menu);
+	cApplication.define_method("menu",  get_menu);
 	cApplication.define_method("each_window", each_window);
 	cApplication.define_method("on_start", on_start);
 	cApplication.define_method("on_quit",  on_quit);

data/ext/reflex/chase_constraint.cpp

@@ -0,0 +1,89 @@
+#include "reflex/ruby/constraint.h"
+
+
+#include <rays/ruby/point.h>
+#include "reflex/exception.h"
+#include "reflex/ruby/pin.h"
+#include "reflex/ruby/view.h"
+#include "defs.h"
+
+
+RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::ChaseConstraint)
+
+#define THIS  to<Reflex::ChaseConstraint*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Reflex::ChaseConstraint, self)
+
+
+static
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	Reflex::reflex_error(
+		__FILE__, __LINE__, "can not instantiate ChaseConstraint class");
+}
+RUCY_END
+
+static
+RUCY_DEFN(set_target)
+{
+	CHECK;
+	THIS->set_target(to<Reflex::Pin>(argc, argv));
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_target)
+{
+	CHECK;
+	return value(THIS->target());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_force, max_force)
+{
+	CHECK;
+	if (max_force.is_nil())
+		THIS->clear_force();
+	else
+		THIS->set_force(to<float>(max_force));
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_force)
+{
+	CHECK;
+	return THIS->has_force() ? value(THIS->force()) : nil();
+}
+RUCY_END
+
+
+static Class cChaseConstraint;
+
+void
+Init_reflex_chase_constraint ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cChaseConstraint = mReflex.define_class("ChaseConstraint", Reflex::constraint_class());
+	cChaseConstraint.define_alloc_func(alloc);
+	cChaseConstraint.define_method("target=", set_target);
+	cChaseConstraint.define_method("target",  get_target);
+	cChaseConstraint.define_method("force=", set_force);
+	cChaseConstraint.define_method("force",  get_force);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	chase_constraint_class ()
+	{
+		return cChaseConstraint;
+	}
+
+
+}// Reflex

data/ext/reflex/clipboard.cpp

@@ -0,0 +1,69 @@
+#include "reflex/ruby/clipboard.h"
+
+
+#include "reflex/exception.h"
+#include "defs.h"
+
+
+static
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	Reflex::reflex_error(__FILE__, __LINE__, "can not instantiate Clipboard class.");
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_text, text)
+{
+	Reflex::Clipboard clipboard;
+	if (!text.is_nil()) clipboard.set_text(text.c_str());
+	Reflex::set_clipboard(clipboard);
+	return text;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_text)
+{
+	Reflex::Clipboard clipboard = Reflex::get_clipboard();
+	const char* text = clipboard.text();
+	return text ? value(text, rb_utf8_encoding()) : nil();
+}
+RUCY_END
+
+static
+RUCY_DEF0(clear)
+{
+	Reflex::set_clipboard(Reflex::Clipboard());
+	return self;
+}
+RUCY_END
+
+
+static Class cClipboard;
+
+void
+Init_reflex_clipboard ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cClipboard = mReflex.define_class("Clipboard");
+	cClipboard.define_alloc_func(alloc);
+	cClipboard.define_singleton_method("text=", set_text);
+	cClipboard.define_singleton_method("text",  get_text);
+	cClipboard.define_singleton_method("clear", clear);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	clipboard_class ()
+	{
+		return cClipboard;
+	}
+
+
+}// Reflex

data/ext/reflex/constraint.cpp

@@ -0,0 +1,146 @@
+#include "reflex/ruby/constraint.h"
+
+
+#include <rays/ruby/point.h>
+#include "reflex/exception.h"
+#include "reflex/ruby/view.h"
+#include "reflex/ruby/pin.h"
+#include "defs.h"
+#include "selector.h"
+
+
+RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::Constraint)
+
+#define THIS  to<Reflex::Constraint*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Reflex::Constraint, self)
+
+
+static
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	Reflex::reflex_error(
+		__FILE__, __LINE__, "can not instantiate Constraint class");
+}
+RUCY_END
+
+static
+RUCY_DEF0(remove)
+{
+	CHECK;
+	THIS->remove();
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF1(get_pin, index)
+{
+	CHECK;
+	return value(THIS->pin(to<int>(index)));
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_spring, hertz)
+{
+	CHECK;
+	THIS->set_spring(hertz ? to<float>(hertz) : 0);
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_spring)
+{
+	CHECK;
+	float hertz = THIS->spring();
+	return hertz > 0 ? value(hertz) : nil();
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_damping, ratio)
+{
+	CHECK;
+	THIS->set_damping(to<float>(ratio));
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_damping)
+{
+	CHECK;
+	return value(THIS->damping());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_collide, state)
+{
+	CHECK;
+	THIS->set_collide(to<bool>(state));
+}
+RUCY_END
+
+static
+RUCY_DEF0(can_collide)
+{
+	CHECK;
+	return value(THIS->can_collide());
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_removed)
+{
+	CHECK;
+	return value(THIS->is_removed());
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_active)
+{
+	CHECK;
+	return value(THIS->operator bool());
+}
+RUCY_END
+
+
+static Class cConstraint;
+
+void
+Init_reflex_constraint ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cConstraint = mReflex.define_class("Constraint");
+	cConstraint.define_alloc_func(alloc);
+	cConstraint.define_method("remove", remove);
+	cConstraint.define_private_method("get_pin", get_pin);
+	cConstraint.define_method("spring=",  set_spring);
+	cConstraint.define_method("spring",   get_spring);
+	cConstraint.define_method("damping=", set_damping);
+	cConstraint.define_method("damping",  get_damping);
+	cConstraint.define_method("collide=", set_collide);
+	cConstraint.define_method("collide?", can_collide);
+	cConstraint.define_method("removed?", is_removed);
+	cConstraint.define_method("active?",  is_active);
+
+	define_selector_methods<Reflex::Constraint>(cConstraint);
+	define_wrapper_equality_methods<Reflex::Constraint>(cConstraint);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	constraint_class ()
+	{
+		return cConstraint;
+	}
+
+
+}// Reflex

data/ext/reflex/key_event.cpp

@@ -232,12 +232,12 @@ RUCY_DEF0(get_key)
 		CASE(VOLUME_DOWN): SYMBOL1(volume_down);
 		CASE(MUTE):        SYMBOL1(mute);
 
-		CASE(SLEEP):  SYMBOL1(sleep);
-		CASE(EXEC):   SYMBOL1(exec);
-		CASE(PRINT):  SYMBOL1(print);
-		CASE(APPS):   SYMBOL1(apps);
-		CASE(SELECT): SYMBOL1(select);
-		CASE(CLEAR):  SYMBOL1(clear);
+		CASE(SLEEP):        SYMBOL1(sleep);
+		CASE(EXEC):         SYMBOL1(exec);
+		CASE(PRINT):        SYMBOL1(print);
+		CASE(CONTEXT_MENU): SYMBOL1(context_menu);
+		CASE(SELECT):       SYMBOL1(select);
+		CASE(CLEAR):        SYMBOL1(clear);
 
 		CASE(NAVIGATION_VIEW):   SYMBOL1(navigation_view);
 		CASE(NAVIGATION_MENU):   SYMBOL1(navigation_menu);

data/ext/reflex/link_constraint.cpp

@@ -0,0 +1,194 @@
+#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_OBJ(Reflex::LinkConstraint, self)
+
+
+static
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	Reflex::reflex_error(
+		__FILE__, __LINE__, "can not instantiate LinkConstraint class");
+}
+RUCY_END
+
+static
+RUCY_DEFN(set_axis)
+{
+	CHECK;
+	if (argc == 1 && argv[0].is_nil())
+		THIS->clear_axis();
+	else
+		THIS->set_axis(to<Rays::Point>(argc, argv));
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_axis)
+{
+	CHECK;
+	return THIS->has_axis() ? value(THIS->axis()) : nil();
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_distance, distance)
+{
+	CHECK;
+	if (distance.is_nil())
+		THIS->clear_distance();
+	else
+		THIS->set_distance(to<coord>(distance));
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_distance)
+{
+	CHECK;
+	return value(THIS->distance());
+}
+RUCY_END
+
+static
+RUCY_DEF0(has_distance)
+{
+	CHECK;
+	return value(THIS->has_distance());
+}
+RUCY_END
+
+static
+RUCY_DEF0(current_distance)
+{
+	CHECK;
+	return value(THIS->current_distance());
+}
+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, pixels_per_second)
+{
+	CHECK;
+	if (pixels_per_second.is_nil())
+		THIS->clear_motor();
+	else
+		THIS->set_motor(to<coord>(pixels_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_force)
+{
+	CHECK;
+	if (max_force.is_nil())
+		THIS->clear_force();
+	else
+		THIS->set_force(to<float>(max_force));
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_force)
+{
+	CHECK;
+	return THIS->has_force() ? value(THIS->force()) : nil();
+}
+RUCY_END
+
+
+static Class cLinkConstraint;
+
+void
+Init_reflex_link_constraint ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cLinkConstraint = mReflex.define_class("LinkConstraint", Reflex::constraint_class());
+	cLinkConstraint.define_alloc_func(alloc);
+	cLinkConstraint.define_method("axis=", set_axis);
+	cLinkConstraint.define_method("axis",  get_axis);
+	cLinkConstraint.define_method(        "distance=", set_distance);
+	cLinkConstraint.define_method(        "distance",  get_distance);
+	cLinkConstraint.define_method("current_distance", current_distance);
+	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);
+	cLinkConstraint.define_method("motor=", set_motor);
+	cLinkConstraint.define_method("motor",  get_motor);
+	cLinkConstraint.define_method("force=", set_force);
+	cLinkConstraint.define_method("force",  get_force);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	link_constraint_class ()
+	{
+		return cLinkConstraint;
+	}
+
+
+}// Reflex