reflexion 0.5.3 → 0.7.0

data/.github/workflows/test.yml

@@ -7,31 +7,4 @@ on:
 
 jobs:
   test:
-    runs-on: macos-latest
-
-    steps:
-      - name: ruby 3.2
-        uses: ruby/setup-ruby@v1
-        with:
-          ruby-version: 3.2
-
-      - name: checkout
-        uses: actions/checkout@v4
-
-      - name: setup gems
-        run: bundle install
-
-      - name: setup dependencies
-        run: "ruby -I.github/workflows -rutils -e 'setup_dependencies'"
-
-      - name: packages
-        run: bundle exec rake verbose packages
-
-      - name: lib
-        run: bundle exec rake verbose lib
-
-      - name: ext
-        run: bundle exec rake verbose ext
-
-      - name: test
-        run: bundle exec rake verbose test
+    uses: xord/xot/.github/workflows/test.yml@master

data/ChangeLog.md

@@ -1,6 +1,85 @@
 # reflex ChangeLog
 
 
+## [v0.7.0] - 2026-11-04
+
+- [BREAKING] Rename View#cache to View#draw_cache
+- [BREAKING] Rename Window#hidden to Window#hidden?
+- [BREAKING] Make Menu#shortcut_key a key symbol, not a string
+- [BREAKING] Return only the shortcut modifiers from #modifiers by default
+- [BREAKING] Report wheel deltas in pixels, in the same direction, on every platform
+- [BREAKING] Make the window frame the client rect on Windows, as it is the content rect on macOS
+- [BREAKING] Open gamepads and MIDI only when Gamepad.enable / MIDI.enable is called
+- [BREAKING] Return from Reflex.start on quit on macOS too, and raise the exception of a callback from it
+- [BREAKING] Raise the deployment targets to macOS 11.0 and iOS 14.0
+- Add TextEvent, on_text_preedit and on_text_commit to take text from an input method
+- Add HasTextPreedit for views taking text input
+- Add FileDialog to open the file dialog of the platform
+- Add ColorPicker to open the color picker of the platform
+- Add Reflex.alert to show a message and wait for it to be closed
+- Add Application#background for an app with no dock icon, with its menu in the menu bar or the tray
+- Add Window#transparent= and #shadow=
+- Add the :buttons and :background flags to Window#titlebar to hide the parts of the titlebar
+- Add Window#always_on_top and #always_on_bottom
+- Add Window::FLAG_POINTER_THROUGH and Window#pointer_through_alpha to let pointers go through a window
+- Add Window#unlisted= to keep a window out of Mission Control, the taskbar and alt-tab
+- Add Screen.all, Screen#name and #pixel_density
+- Add Reflex::KEYS and Reflex.get_key_symbol!
+- Add ControlChangeEvent#inspect
+- Handle non-ASCII text on Windows
+- Support High DPI on Windows
+- Deliver MIDI events to every window, also while the app is in the background
+- End every pointer press with an up or a cancel, also when a menu pops up or the pointer leaves the window
+- Decide the enter and leave of a window from where the pointer is
+- Stop hover moves at the edge of a window on macOS, as on the other platforms
+- Let handlers add and remove views while events are dispatched
+- Name an application by the name the system has for it by default
+- Give windows the icon of the executable on Windows
+- Keep the caption on screen when placing a window on Windows
+- Leave the time a popup menu is open on Windows out of the next dt
+- Make Window#close do nothing on a window already closed
+- Let Window#titlebar and #orientations be called as universal accessors
+
+- Fix menu shortcuts never firing on macOS and Windows
+- Fix closable, minimizable and resizable doing nothing on Windows
+- Fix the window flags taking effect one change late on macOS
+- Fix a block given to Window.new or Reflex.start being lost when on(:show) or on(:start) is hooked
+- Fix views added to a window already shown never being drawn
+- Fix a drag not working on Windows right after a popup menu
+- Fix MIDI.all returning true for each device
+- Fix the MIDI input thread corrupting the heap
+- Fix a crash when removing two or more gamepads
+- Fix RtMidi running the event loop of the app on macOS
+- Fix the extension failing to load on Windows without the DirectX redistributable
+- Fix linking the extension statically on macOS
+- Fix the build for iOS
+
+
+## [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

data/Gemfile.lock

@@ -1,21 +1,26 @@
 GEM
   remote: https://rubygems.org/
   specs:
-    power_assert (3.0.1)
-    rake (13.3.1)
-    test-unit (3.7.7)
+    power_assert (3.1.0)
+    rake (13.4.2)
+    test-unit (3.7.8)
       power_assert
-    yard (0.9.39)
+    yard (0.9.45)
 
 PLATFORMS
-  arm64-darwin-21
-  arm64-darwin-23
-  arm64-darwin-24
+  ruby
 
 DEPENDENCIES
   rake
   test-unit
   yard
 
+CHECKSUMS
+  bundler (4.0.20) sha256=7978a8ac648767f5e635bc522445b79e80a52b907a39a36c2d8085ed6bc762ae
+  power_assert (3.1.0) sha256=fefe98ed5d3140628138f3f9f9194d6ece01f1320e69700d3c928adca7518251
+  rake (13.4.2) sha256=cb825b2bd5f1f8e91ca37bddb4b9aaf345551b4731da62949be002fa89283701
+  test-unit (3.7.8) sha256=689d1ca53f4d46f678b4e5d68d8e4294f87fc5e8b9238cc4de7c5727e8d65943
+  yard (0.9.45) sha256=52e211493f7cb8a3ebf7e104a25a1e73937a3103092545d34cb88fafebb3dc51
+
 BUNDLED WITH
-   2.4.19
+  4.0.20

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/Rakefile

@@ -35,12 +35,23 @@ use_external_library 'https://github.com/thestk/rtmidi',
     when linux? then '__LINUX_ALSA__'
     end
   }.call,
-  &proc {sh %( mkdir rtmidi && cp RtMidi.* rtmidi )}
+  &proc {
+    sh %( mkdir rtmidi && cp RtMidi.* rtmidi )
+
+    # the event loop of the app already takes in the port changes, and running
+    # it from inside RtMidi calls the timers and events of the app too early
+    spin = /^[ \t]*CFRunLoopRunInMode\([^)]*\);\n/
+    filter_file 'rtmidi/RtMidi.cpp' do |src|
+      count = src.scan(spin).size
+      raise "expected 6 run loop calls in RtMidi.cpp, found #{count}" if count != 6
+      src.gsub spin, ''
+    end
+  }
 
 default_tasks :ext
 use_bundler
 build_native_library
 build_ruby_extension
-test_ruby_extension unless github_actions? && win32?
+test_ruby_extension
 generate_documents
 build_ruby_gem

data/Reflex.podspec

@@ -11,8 +11,8 @@ Pod::Spec.new do |s|
   s.author       = {"xordog" => "xordog@gmail.com"}
   s.homepage     = "https://github.com/xord/reflex"
 
-  s.osx.deployment_target = "10.10"
-  s.ios.deployment_target = "12.0"
+  s.osx.deployment_target = "11.0"
+  s.ios.deployment_target = "14.0"
 
   root = "${PODS_ROOT}/#{s.name}"
   exts = File.read(File.expand_path 'Rakefile', __dir__)

data/VERSION

@@ -1 +1 @@
-0.5.3
+0.7.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"
 
@@ -9,8 +10,8 @@ RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::Application)
 
 #define THIS      to<Reflex::Application*>(self)
 
-#define CHECK_OBJ RUCY_CHECK_OBJ(   Reflex::Application, self)
-#define CHECK     RUCY_CHECK_OBJECT(Reflex::Application, self)
+#define CHECK_PTR RUCY_CHECK_PTR(Reflex::Application, self)
+#define CHECK     RUCY_CHECK_OBJ(Reflex::Application, self)
 
 #define CALL(fun) RUCY_CALL_SUPER(THIS, fun)
 
@@ -25,7 +26,7 @@ RUCY_END
 static
 RUCY_DEF0(start)
 {
-	CHECK_OBJ;
+	CHECK_PTR;
 	CALL(start());
 	return self;
 }
@@ -57,6 +58,57 @@ 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_DEF1(set_background, state)
+{
+	CHECK;
+	THIS->set_background(to<bool>(state));
+	return state;
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_background)
+{
+	CHECK;
+	return value(THIS->background());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_background_menu, menu)
+{
+	CHECK;
+	THIS->set_background_menu(menu ? to<Reflex::Menu*>(menu) : NULL);
+	return menu;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_background_menu)
+{
+	CHECK;
+	return value(THIS->background_menu());
+}
+RUCY_END
+
 static
 RUCY_DEF0(each_window)
 {
@@ -64,7 +116,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
@@ -74,9 +126,6 @@ RUCY_DEF1(on_start, event)
 {
 	CHECK;
 
-	RUCY_SYM(call_start_block);
-	self.call(call_start_block);
-
 	CALL(on_start(to<Reflex::Event*>(event)));
 }
 RUCY_END
@@ -150,6 +199,12 @@ 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("background=",      set_background);
+	cApplication.define_method("background?",       is_background);
+	cApplication.define_method("background_menu=", set_background_menu);
+	cApplication.define_method("background_menu",  get_background_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/capture_event.cpp

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

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_PTR(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) : 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/color_event.cpp

@@ -0,0 +1,80 @@
+#include "reflex/ruby/event.h"
+
+
+#include <rays/ruby/color.h>
+#include "defs.h"
+
+
+RUCY_DEFINE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::ColorEvent)
+
+#define THIS  to<Reflex::ColorEvent*>(self)
+
+#define CHECK RUCY_CHECK_PTR(Reflex::ColorEvent, self)
+
+
+static
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return new_type<Reflex::ColorEvent>(klass);
+}
+RUCY_END
+
+static
+RUCY_DEF1(initialize, color)
+{
+	CHECK;
+
+	if (color.is_nil())
+		argument_error(__FILE__, __LINE__);
+
+	*THIS = Reflex::ColorEvent(to<Rays::Color>(color));
+
+	return rb_call_super(0, NULL);
+}
+RUCY_END
+
+static
+RUCY_DEF1(initialize_copy, obj)
+{
+	CHECK;
+	*THIS = to<Reflex::ColorEvent&>(obj).dup();
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_color)
+{
+	CHECK;
+	return value(THIS->color());
+}
+RUCY_END
+
+
+static Class cColorEvent;
+
+void
+Init_reflex_color_event ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cColorEvent = mReflex.define_class("ColorEvent", Reflex::event_class());
+	cColorEvent.define_alloc_func(alloc);
+	cColorEvent.define_private_method("initialize",      initialize);
+	cColorEvent.define_private_method("initialize_copy", initialize_copy);
+	cColorEvent.define_method("color", get_color);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	color_event_class ()
+	{
+		return cColorEvent;
+	}
+
+
+}// Reflex

data/ext/reflex/color_picker.cpp

@@ -0,0 +1,121 @@
+#include "reflex/ruby/color_picker.h"
+
+
+#include <rays/ruby/color.h>
+#include "reflex/ruby/window.h"
+#include "defs.h"
+
+
+RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::ColorPicker)
+
+#define THIS      to<Reflex::ColorPicker*>(self)
+
+#define CHECK     RUCY_CHECK_OBJ(Reflex::ColorPicker, self)
+
+#define CALL(fun) RUCY_CALL_SUPER(THIS, fun)
+
+
+static
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return value(new Reflex::RubyColorPicker<Reflex::ColorPicker>, klass);
+}
+RUCY_END
+
+static
+RUCY_DEF1(pick_color, initial)
+{
+	CHECK;
+
+	if (initial.is_nil())
+		THIS->pick_color();
+	else
+		THIS->pick_color(to<Rays::Color>(initial));
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_owner, owner)
+{
+	CHECK;
+	THIS->set_owner(owner.is_nil() ? NULL : to<Reflex::Window*>(owner));
+	return owner;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_owner)
+{
+	CHECK;
+	return value(THIS->owner());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_alpha, state)
+{
+	CHECK;
+	THIS->set_alpha(to<bool>(state));
+	return state;
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_alpha)
+{
+	CHECK;
+	return value(THIS->alpha());
+}
+RUCY_END
+
+static
+RUCY_DEF1(on_color, event)
+{
+	CHECK;
+
+	CALL(on_color(to<Reflex::ColorEvent*>(event)));
+}
+RUCY_END
+
+static
+RUCY_DEF1(on_close, event)
+{
+	CHECK;
+
+	CALL(on_close(to<Reflex::Event*>(event)));
+}
+RUCY_END
+
+
+static Class cColorPicker;
+
+void
+Init_reflex_color_picker ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cColorPicker = mReflex.define_class("ColorPicker");
+	cColorPicker.define_alloc_func(alloc);
+	cColorPicker.define_method("pick_color!", pick_color);
+	cColorPicker.define_method("owner=", set_owner);
+	cColorPicker.define_method("owner",  get_owner);
+	cColorPicker.define_method("alpha=", set_alpha);
+	cColorPicker.define_method("alpha?",  is_alpha);
+	cColorPicker.define_method("on_color", on_color);
+	cColorPicker.define_method("on_close", on_close);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	color_picker_class ()
+	{
+		return cColorPicker;
+	}
+
+
+}// Reflex