reflexion 0.5.3 → 0.7.0

data/.doc/ext/reflex/wheel_constraint.cpp

@@ -0,0 +1,142 @@
+#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::WheelConstraint)
+
+#define THIS  to<Reflex::WheelConstraint*>(self)
+
+#define CHECK RUCY_CHECK_PTR(Reflex::WheelConstraint, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	Reflex::reflex_error(
+		__FILE__, __LINE__, "can not instantiate WheelConstraint class");
+}
+
+static
+VALUE set_axis(VALUE self)
+{
+	CHECK;
+	THIS->set_axis(to<Rays::Point>(argc, argv));
+}
+
+static
+VALUE get_axis(VALUE self)
+{
+	CHECK;
+	return value(THIS->axis());
+}
+
+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 degrees_per_second)
+{
+	CHECK;
+	if (degrees_per_second.is_nil())
+		THIS->clear_motor();
+	else
+		THIS->set_motor(to<float>(degrees_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_torque)
+{
+	CHECK;
+	if (max_torque.is_nil())
+		THIS->clear_force();
+	else
+		THIS->set_force(to<float>(max_torque));
+}
+
+static
+VALUE get_force(VALUE self)
+{
+	CHECK;
+	return THIS->has_force() ? value(THIS->force()) : nil();
+}
+
+
+static Class cWheelConstraint;
+
+void
+Init_reflex_wheel_constraint ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cWheelConstraint = mReflex.define_class(
+		"WheelConstraint", Reflex::constraint_class());
+	rb_define_alloc_func(cWheelConstraint, alloc);
+	rb_define_method(cWheelConstraint, "axis=", RUBY_METHOD_FUNC(set_axis), -1);
+	rb_define_method(cWheelConstraint, "axis", RUBY_METHOD_FUNC(get_axis), 0);
+	cWheelConstraint.define_private_method(  "set_range!",   set_range);
+	cWheelConstraint.define_private_method("clear_range!", clear_range);
+	cWheelConstraint.define_private_method(      "range_min!",   range_min);
+	cWheelConstraint.define_private_method(      "range_max!",   range_max);
+	cWheelConstraint.define_private_method(  "has_range!",   has_range);
+	rb_define_method(cWheelConstraint, "motor=", RUBY_METHOD_FUNC(set_motor), 1);
+	rb_define_method(cWheelConstraint, "motor", RUBY_METHOD_FUNC(get_motor), 0);
+	rb_define_method(cWheelConstraint, "force=", RUBY_METHOD_FUNC(set_force), 1);
+	rb_define_method(cWheelConstraint, "force", RUBY_METHOD_FUNC(get_force), 0);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	wheel_constraint_class ()
+	{
+		return cWheelConstraint;
+	}
+
+
+}// Reflex

data/.doc/ext/reflex/wheel_event.cpp

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

data/.doc/ext/reflex/window.cpp

@@ -3,8 +3,9 @@
 
 #include <rays/ruby/bounds.h>
 #include <rays/ruby/painter.h>
-#include "reflex/ruby/screen.h"
 #include "reflex/ruby/view.h"
+#include "reflex/ruby/menu.h"
+#include "reflex/ruby/screen.h"
 #include "defs.h"
 
 
@@ -12,7 +13,8 @@ RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::Window)
 
 #define THIS      to<Reflex::Window*>(self)
 
-#define CHECK     RUCY_CHECK_OBJECT(Reflex::Window, self)
+#define CHECK_PTR RUCY_CHECK_PTR(Reflex::Window, self)
+#define CHECK     RUCY_CHECK_OBJ(Reflex::Window, self)
 
 #define CALL(fun) RUCY_CALL_SUPER(THIS, fun)
 
@@ -40,7 +42,7 @@ VALUE hide(VALUE self)
 }
 
 static
-VALUE hidden(VALUE self)
+VALUE is_hidden(VALUE self)
 {
 	CHECK;
 	return value(THIS->hidden());
@@ -49,8 +51,8 @@ VALUE hidden(VALUE self)
 static
 VALUE close(VALUE self)
 {
-	CHECK;
-	THIS->close();
+	CHECK_PTR;
+	if (*THIS) THIS->close();
 	return self;
 }
 
@@ -76,6 +78,13 @@ VALUE to_screen(VALUE self, VALUE point)
 	return value(THIS->to_screen(to<Rays::Point>(point)));
 }
 
+static
+VALUE is_active(VALUE self)
+{
+	CHECK;
+	return value(THIS->active());
+}
+
 static
 VALUE set_title(VALUE self, VALUE title)
 {
@@ -106,6 +115,21 @@ VALUE get_frame(VALUE self)
 	return value(THIS->frame());
 }
 
+static
+VALUE set_menu(VALUE self, VALUE menu)
+{
+	CHECK;
+	THIS->set_menu(menu ? to<Reflex::Menu*>(menu) : NULL);
+	return menu;
+}
+
+static
+VALUE get_menu(VALUE self)
+{
+	CHECK;
+	return value(THIS->menu());
+}
+
 static
 VALUE set_closable(VALUE self, VALUE state)
 {
@@ -166,6 +190,80 @@ VALUE is_resizable(VALUE self)
 	return value(THIS->has_flag(Reflex::Window::FLAG_RESIZABLE));
 }
 
+static const uint TITLEBAR_MASK =
+	Reflex::Window::FLAG_TITLEBAR_BUTTONS |
+	Reflex::Window::FLAG_TITLEBAR_BACKGROUND;
+
+static
+VALUE set_titlebar(VALUE self, VALUE titlebar)
+{
+	CHECK;
+
+	uint flags = to<uint>(titlebar);
+	THIS->set_flags((flags & TITLEBAR_MASK) | (THIS->flags() & ~TITLEBAR_MASK));
+}
+
+static
+VALUE get_titlebar(VALUE self)
+{
+	CHECK;
+	return value(THIS->flags() & TITLEBAR_MASK);
+}
+
+static
+VALUE set_unlisted(VALUE self, VALUE state)
+{
+	CHECK;
+
+	if (state)
+		THIS->   add_flag(Reflex::Window::FLAG_UNLISTED);
+	else
+		THIS->remove_flag(Reflex::Window::FLAG_UNLISTED);
+}
+
+static
+VALUE is_unlisted(VALUE self)
+{
+	CHECK;
+	return value(THIS->has_flag(Reflex::Window::FLAG_UNLISTED));
+}
+
+static
+VALUE set_shadow(VALUE self, VALUE state)
+{
+	CHECK;
+
+	if (state)
+		THIS->   add_flag(Reflex::Window::FLAG_SHADOW);
+	else
+		THIS->remove_flag(Reflex::Window::FLAG_SHADOW);
+}
+
+static
+VALUE has_shadow(VALUE self)
+{
+	CHECK;
+	return value(THIS->has_flag(Reflex::Window::FLAG_SHADOW));
+}
+
+static
+VALUE set_transparent(VALUE self, VALUE state)
+{
+	CHECK;
+
+	if (state)
+		THIS->   add_flag(Reflex::Window::FLAG_TRANSPARENT);
+	else
+		THIS->remove_flag(Reflex::Window::FLAG_TRANSPARENT);
+}
+
+static
+VALUE is_transparent(VALUE self)
+{
+	CHECK;
+	return value(THIS->has_flag(Reflex::Window::FLAG_TRANSPARENT));
+}
+
 static
 VALUE set_fullscreen(VALUE self, VALUE state)
 {
@@ -186,18 +284,90 @@ VALUE is_fullscreen(VALUE self)
 	return value(THIS->has_flag(Reflex::Window::FLAG_FULLSCREEN));
 }
 
+static
+VALUE set_always_on_top(VALUE self, VALUE state)
+{
+	CHECK;
+
+	if (state)
+	{
+		THIS->remove_flag(Reflex::Window::FLAG_ALWAYS_ON_BOTTOM);
+		THIS->   add_flag(Reflex::Window::FLAG_ALWAYS_ON_TOP);
+	}
+	else
+		THIS->remove_flag(Reflex::Window::FLAG_ALWAYS_ON_TOP);
+}
+
+static
+VALUE is_always_on_top(VALUE self)
+{
+	CHECK;
+	return value(THIS->has_flag(Reflex::Window::FLAG_ALWAYS_ON_TOP));
+}
+
+static
+VALUE set_always_on_bottom(VALUE self, VALUE state)
+{
+	CHECK;
+
+	if (state)
+	{
+		THIS->remove_flag(Reflex::Window::FLAG_ALWAYS_ON_TOP);
+		THIS->   add_flag(Reflex::Window::FLAG_ALWAYS_ON_BOTTOM);
+	}
+	else
+		THIS->remove_flag(Reflex::Window::FLAG_ALWAYS_ON_BOTTOM);
+}
+
+static
+VALUE is_always_on_bottom(VALUE self)
+{
+	CHECK;
+	return value(THIS->has_flag(Reflex::Window::FLAG_ALWAYS_ON_BOTTOM));
+}
+
+static
+VALUE set_pointer_through(VALUE self, VALUE state)
+{
+	CHECK;
+
+	if (state)
+		THIS->   add_flag(Reflex::Window::FLAG_POINTER_THROUGH);
+	else
+		THIS->remove_flag(Reflex::Window::FLAG_POINTER_THROUGH);
+}
+
+static
+VALUE is_pointer_through(VALUE self)
+{
+	CHECK;
+	return value(THIS->has_flag(Reflex::Window::FLAG_POINTER_THROUGH));
+}
+
+static
+VALUE set_pointer_through_alpha(VALUE self, VALUE alpha)
+{
+	CHECK;
+	THIS->set_pointer_through_alpha(to<float>(alpha));
+}
+
+static
+VALUE get_pointer_through_alpha(VALUE self)
+{
+	CHECK;
+	return value(THIS->pointer_through_alpha());
+}
+
 static const uint ORIENTATION_MASK =
 	Reflex::Window::FLAG_PORTRAIT | Reflex::Window::FLAG_LANDSCAPE;
 
 static
 VALUE set_orientations(VALUE self, VALUE orientations)
 {
-	using namespace Reflex;
-
 	CHECK;
 
 	uint flags = to<uint>(orientations);
-	THIS->set_flag(
+	THIS->set_flags(
 		(      flags   &  ORIENTATION_MASK) |
 		(THIS->flags() & ~ORIENTATION_MASK));
 }
@@ -205,8 +375,6 @@ VALUE set_orientations(VALUE self, VALUE orientations)
 static
 VALUE get_orientations(VALUE self)
 {
-	using namespace Reflex;
-
 	CHECK;
 	return value(THIS->flags() & ORIENTATION_MASK);
 }
@@ -240,42 +408,39 @@ VALUE get_painter(VALUE self)
 }
 
 static
-VALUE on_activate(VALUE self, VALUE event)
+VALUE on_show(VALUE self, VALUE event)
 {
 	CHECK;
-	CALL(on_activate(to<Reflex::Event*>(event)));
+
+	CALL(on_show(to<Reflex::Event*>(event)));
 }
 
 static
-VALUE on_deactivate(VALUE self, VALUE event)
+VALUE on_hide(VALUE self, VALUE event)
 {
 	CHECK;
-	CALL(on_deactivate(to<Reflex::Event*>(event)));
+	CALL(on_hide(to<Reflex::Event*>(event)));
 }
 
 static
-VALUE on_show(VALUE self, VALUE event)
+VALUE on_close(VALUE self, VALUE event)
 {
 	CHECK;
-
-	RUCY_SYM(call_show_block);
-	self.call(call_show_block);
-
-	CALL(on_show(to<Reflex::Event*>(event)));
+	CALL(on_close(to<Reflex::Event*>(event)));
 }
 
 static
-VALUE on_hide(VALUE self, VALUE event)
+VALUE on_activate(VALUE self, VALUE event)
 {
 	CHECK;
-	CALL(on_hide(to<Reflex::Event*>(event)));
+	CALL(on_activate(to<Reflex::Event*>(event)));
 }
 
 static
-VALUE on_close(VALUE self, VALUE event)
+VALUE on_deactivate(VALUE self, VALUE event)
 {
 	CHECK;
-	CALL(on_close(to<Reflex::Event*>(event)));
+	CALL(on_deactivate(to<Reflex::Event*>(event)));
 }
 
 static
@@ -327,6 +492,27 @@ VALUE on_key_up(VALUE self, VALUE event)
 	CALL(on_key_up(to<Reflex::KeyEvent*>(event)));
 }
 
+static
+VALUE on_text(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_text(to<Reflex::TextEvent*>(event)));
+}
+
+static
+VALUE on_text_preedit(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_text_preedit(to<Reflex::TextEvent*>(event)));
+}
+
+static
+VALUE on_text_commit(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_text_commit(to<Reflex::TextEvent*>(event)));
+}
+
 static
 VALUE on_pointer(VALUE self, VALUE event)
 {
@@ -362,6 +548,20 @@ VALUE on_pointer_cancel(VALUE self, VALUE event)
 	CALL(on_pointer_cancel(to<Reflex::PointerEvent*>(event)));
 }
 
+static
+VALUE on_pointer_enter(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_pointer_enter(to<Reflex::PointerEvent*>(event)));
+}
+
+static
+VALUE on_pointer_leave(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_pointer_leave(to<Reflex::PointerEvent*>(event)));
+}
+
 static
 VALUE on_wheel(VALUE self, VALUE event)
 {
@@ -369,6 +569,27 @@ VALUE on_wheel(VALUE self, VALUE event)
 	CALL(on_wheel(to<Reflex::WheelEvent*>(event)));
 }
 
+static
+VALUE on_file(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_file(to<Reflex::FileEvent*>(event)));
+}
+
+static
+VALUE on_file_open(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_file_open(to<Reflex::FileEvent*>(event)));
+}
+
+static
+VALUE on_file_save(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_file_save(to<Reflex::FileEvent*>(event)));
+}
+
 static
 VALUE on_midi(VALUE self, VALUE event)
 {
@@ -416,34 +637,53 @@ Init_reflex_window ()
 	rb_define_alloc_func(cWindow, alloc);
 	rb_define_method(cWindow, "show", RUBY_METHOD_FUNC(show), 0);
 	rb_define_method(cWindow, "hide", RUBY_METHOD_FUNC(hide), 0);
+	cWindow.define_method("hidden?", is_hidden);
 	rb_define_method(cWindow, "close", RUBY_METHOD_FUNC(close), 0);
 	rb_define_method(cWindow, "redraw", RUBY_METHOD_FUNC(redraw), 0);
 	rb_define_method(cWindow, "from_screen", RUBY_METHOD_FUNC(from_screen), 1);
 	rb_define_method(cWindow, "to_screen", RUBY_METHOD_FUNC(to_screen), 1);
+	cWindow.define_method("active?", is_active);
 	rb_define_method(cWindow, "title=", RUBY_METHOD_FUNC(set_title), 1);
 	rb_define_method(cWindow, "title", RUBY_METHOD_FUNC(get_title), 0);
 	rb_define_method(cWindow, "frame=", RUBY_METHOD_FUNC(set_frame), -1);
 	rb_define_method(cWindow, "frame", RUBY_METHOD_FUNC(get_frame), 0);
+	rb_define_method(cWindow, "menu=", RUBY_METHOD_FUNC(set_menu), 1);
+	rb_define_method(cWindow, "menu", RUBY_METHOD_FUNC(get_menu), 0);
 	rb_define_method(cWindow, "closable=", RUBY_METHOD_FUNC(set_closable), 1);
-	cWindow.define_method("closable?",     is_closable);
+	cWindow.define_method("closable?",               is_closable);
 	rb_define_method(cWindow, "minimizable=", RUBY_METHOD_FUNC(set_minimizable), 1);
-	cWindow.define_method("minimizable?",  is_minimizable);
+	cWindow.define_method("minimizable?",            is_minimizable);
 	rb_define_method(cWindow, "resizable=", RUBY_METHOD_FUNC(set_resizable), 1);
-	cWindow.define_method("resizable?",    is_resizable);
+	cWindow.define_method("resizable?",              is_resizable);
+	rb_define_method(cWindow, "titlebar=", RUBY_METHOD_FUNC(set_titlebar), 1);
+	rb_define_method(cWindow, "titlebar", RUBY_METHOD_FUNC(get_titlebar), 0);
+	rb_define_method(cWindow, "unlisted=", RUBY_METHOD_FUNC(set_unlisted), 1);
+	cWindow.define_method("unlisted?",               is_unlisted);
+	rb_define_method(cWindow, "shadow=", RUBY_METHOD_FUNC(set_shadow), 1);
+	cWindow.define_method("shadow?",                has_shadow);
+	rb_define_method(cWindow, "transparent=", RUBY_METHOD_FUNC(set_transparent), 1);
+	cWindow.define_method("transparent?",            is_transparent);
 	rb_define_method(cWindow, "fullscreen=", RUBY_METHOD_FUNC(set_fullscreen), 1);
-	cWindow.define_method("fullscreen?",   is_fullscreen);
+	cWindow.define_method("fullscreen?",             is_fullscreen);
+	rb_define_method(cWindow, "always_on_top=", RUBY_METHOD_FUNC(set_always_on_top), 1);
+	cWindow.define_method("always_on_top?",          is_always_on_top);
+	rb_define_method(cWindow, "always_on_bottom=", RUBY_METHOD_FUNC(set_always_on_bottom), 1);
+	cWindow.define_method("always_on_bottom?",       is_always_on_bottom);
+	rb_define_method(cWindow, "pointer_through=", RUBY_METHOD_FUNC(set_pointer_through), 1);
+	cWindow.define_method("pointer_through?",        is_pointer_through);
+	rb_define_method(cWindow, "pointer_through_alpha=", RUBY_METHOD_FUNC(set_pointer_through_alpha), 1);
+	rb_define_method(cWindow, "pointer_through_alpha", RUBY_METHOD_FUNC(get_pointer_through_alpha), 0);
 	rb_define_method(cWindow, "orientations=", RUBY_METHOD_FUNC(set_orientations), 1);
 	rb_define_method(cWindow, "orientations", RUBY_METHOD_FUNC(get_orientations), 0);
-	rb_define_method(cWindow, "hidden", RUBY_METHOD_FUNC(hidden), 0);
 	rb_define_method(cWindow, "screen", RUBY_METHOD_FUNC(get_screen), 0);
 	rb_define_method(cWindow, "root", RUBY_METHOD_FUNC(get_root), 0);
 	rb_define_method(cWindow, "focus", RUBY_METHOD_FUNC(get_focus), 0);
 	rb_define_method(cWindow, "painter", RUBY_METHOD_FUNC(get_painter), 0);
-	rb_define_method(cWindow, "on_activate", RUBY_METHOD_FUNC(on_activate), 1);
-	rb_define_method(cWindow, "on_deactivate", RUBY_METHOD_FUNC(on_deactivate), 1);
 	rb_define_method(cWindow, "on_show", RUBY_METHOD_FUNC(on_show), 1);
 	rb_define_method(cWindow, "on_hide", RUBY_METHOD_FUNC(on_hide), 1);
 	rb_define_method(cWindow, "on_close", RUBY_METHOD_FUNC(on_close), 1);
+	rb_define_method(cWindow, "on_activate", RUBY_METHOD_FUNC(on_activate), 1);
+	rb_define_method(cWindow, "on_deactivate", RUBY_METHOD_FUNC(on_deactivate), 1);
 	rb_define_method(cWindow, "on_update", RUBY_METHOD_FUNC(on_update), 1);
 	rb_define_method(cWindow, "on_draw", RUBY_METHOD_FUNC(on_draw), 1);
 	rb_define_method(cWindow, "on_move", RUBY_METHOD_FUNC(on_move), 1);
@@ -451,18 +691,29 @@ Init_reflex_window ()
 	rb_define_method(cWindow, "on_key", RUBY_METHOD_FUNC(on_key), 1);
 	rb_define_method(cWindow, "on_key_down", RUBY_METHOD_FUNC(on_key_down), 1);
 	rb_define_method(cWindow, "on_key_up", RUBY_METHOD_FUNC(on_key_up), 1);
+	rb_define_method(cWindow, "on_text", RUBY_METHOD_FUNC(on_text), 1);
+	rb_define_method(cWindow, "on_text_preedit", RUBY_METHOD_FUNC(on_text_preedit), 1);
+	rb_define_method(cWindow, "on_text_commit", RUBY_METHOD_FUNC(on_text_commit), 1);
 	rb_define_method(cWindow, "on_pointer", RUBY_METHOD_FUNC(on_pointer), 1);
 	rb_define_method(cWindow, "on_pointer_down", RUBY_METHOD_FUNC(on_pointer_down), 1);
 	rb_define_method(cWindow, "on_pointer_up", RUBY_METHOD_FUNC(on_pointer_up), 1);
 	rb_define_method(cWindow, "on_pointer_move", RUBY_METHOD_FUNC(on_pointer_move), 1);
 	rb_define_method(cWindow, "on_pointer_cancel", RUBY_METHOD_FUNC(on_pointer_cancel), 1);
+	rb_define_method(cWindow, "on_pointer_enter", RUBY_METHOD_FUNC(on_pointer_enter), 1);
+	rb_define_method(cWindow, "on_pointer_leave", RUBY_METHOD_FUNC(on_pointer_leave), 1);
 	rb_define_method(cWindow, "on_wheel", RUBY_METHOD_FUNC(on_wheel), 1);
+	rb_define_method(cWindow, "on_file", RUBY_METHOD_FUNC(on_file), 1);
+	rb_define_method(cWindow, "on_file_open", RUBY_METHOD_FUNC(on_file_open), 1);
+	rb_define_method(cWindow, "on_file_save", RUBY_METHOD_FUNC(on_file_save), 1);
 	rb_define_method(cWindow, "on_midi", RUBY_METHOD_FUNC(on_midi), 1);
 	rb_define_method(cWindow, "on_note", RUBY_METHOD_FUNC(on_note), 1);
 	rb_define_method(cWindow, "on_note_on", RUBY_METHOD_FUNC(on_note_on), 1);
 	rb_define_method(cWindow, "on_note_off", RUBY_METHOD_FUNC(on_note_off), 1);
 	rb_define_method(cWindow, "on_control_change", RUBY_METHOD_FUNC(on_control_change), 1);
 
+	cWindow.define_const("TITLEBAR_BUTTONS",    Reflex::Window::FLAG_TITLEBAR_BUTTONS);
+	cWindow.define_const("TITLEBAR_BACKGROUND", Reflex::Window::FLAG_TITLEBAR_BACKGROUND);
+
 	cWindow.define_const("ORIENTATION_PORTRAIT",  Reflex::Window::FLAG_PORTRAIT);
 	cWindow.define_const("ORIENTATION_LANDSCAPE", Reflex::Window::FLAG_LANDSCAPE);
 

data/.github/workflows/release-gem.yml

@@ -9,43 +9,5 @@ permissions:
 
 jobs:
   release:
-    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: test
-        run: bundle exec rake packages test
-
-      - name: create gem
-        id: gem
-        run: |
-          bundle exec rake gem
-          echo path=$(ruby -e 'print Dir.glob("*.gem").first') >> $GITHUB_OUTPUT
-
-      - name: create github release
-        env:
-          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        run: ruby -I.github/workflows -rutils -e 'release(*ARGV)' ./${{ steps.gem.outputs.path }}
-
-      - name: upload to rubygems
-        env:
-          GEM_HOST_API_KEY: ${{ secrets.RUBYGEMS_AUTH_TOKEN }}
-        run: |
-          mkdir -p $HOME/.gem
-          touch $HOME/.gem/credentials
-          chmod 0600 $HOME/.gem/credentials
-          printf -- "---\n:rubygems_api_key: ${GEM_HOST_API_KEY}\n" > $HOME/.gem/credentials
-          bundle exec rake upload
+    uses: xord/xot/.github/workflows/release-gem.yml@master
+    secrets: inherit

data/.github/workflows/tag.yml

@@ -1,35 +1,12 @@
 name: Tag
 
 on:
-  push:
+  workflow_run:
+    workflows: [Test]
+    types: [completed]
     branches: [master]
 
 jobs:
   tag:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: ruby 3.2
-        uses: ruby/setup-ruby@v1
-        with:
-          ruby-version: 3.2
-
-      - name: checkout
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-          token: ${{ secrets.PAT }}
-
-      - name: setup dependencies
-        run: "ruby -I.github/workflows -rutils -e 'setup_dependencies only: :xot'"
-
-      - name: setup user name and email
-        run: |
-          git config --global user.email "xordog@gmail.com"
-          git config --global user.name "xord"
-
-      - name: tag versions
-        run: "ruby -I.github/workflows -rutils -e 'tag_versions'"
-
-      - name: push tags
-        run: git push origin --tags
+    uses: xord/xot/.github/workflows/tag.yml@master
+    secrets: inherit