reflexion 0.5.2 → 0.6.0

data/.doc/ext/reflex/snap_constraint.cpp

@@ -0,0 +1,125 @@
+#include "reflex/ruby/constraint.h"
+
+
+#include "reflex/exception.h"
+#include "defs.h"
+
+
+RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::SnapConstraint)
+
+#define THIS  to<Reflex::SnapConstraint*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Reflex::SnapConstraint, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	Reflex::reflex_error(
+		__FILE__, __LINE__, "can not instantiate SnapConstraint class");
+}
+
+static
+VALUE set_angle(VALUE self, VALUE min, VALUE max)
+{
+	CHECK;
+	THIS->set_angle(to<float>(min), to<float>(max));
+}
+
+static
+VALUE clear_angle(VALUE self)
+{
+	CHECK;
+	THIS->clear_angle();
+}
+
+static
+VALUE angle_min(VALUE self)
+{
+	CHECK;
+	return value(THIS->angle_min());
+}
+
+static
+VALUE angle_max(VALUE self)
+{
+	CHECK;
+	return value(THIS->angle_max());
+}
+
+static
+VALUE has_angle(VALUE self)
+{
+	CHECK;
+	return value(THIS->has_angle());
+}
+
+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 cSnapConstraint;
+
+void
+Init_reflex_snap_constraint ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cSnapConstraint = mReflex.define_class("SnapConstraint", Reflex::constraint_class());
+	rb_define_alloc_func(cSnapConstraint, alloc);
+	cSnapConstraint.define_private_method(  "set_angle!",   set_angle);
+	cSnapConstraint.define_private_method("clear_angle!", clear_angle);
+	cSnapConstraint.define_private_method(      "angle_min!",   angle_min);
+	cSnapConstraint.define_private_method(      "angle_max!",   angle_max);
+	cSnapConstraint.define_private_method(  "has_angle!",   has_angle);
+	rb_define_method(cSnapConstraint, "motor=", RUBY_METHOD_FUNC(set_motor), 1);
+	rb_define_method(cSnapConstraint, "motor", RUBY_METHOD_FUNC(get_motor), 0);
+	rb_define_method(cSnapConstraint, "force=", RUBY_METHOD_FUNC(set_force), 1);
+	rb_define_method(cSnapConstraint, "force", RUBY_METHOD_FUNC(get_force), 0);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	snap_constraint_class ()
+	{
+		return cSnapConstraint;
+	}
+
+
+}// Reflex

data/.doc/ext/reflex/style_length.cpp

@@ -213,13 +213,14 @@ namespace Rucy
 	template <> REFLEX_EXPORT Reflex::StyleLength
 	value_to<Reflex::StyleLength> (int argc, const Value* argv, bool convert)
 	{
-		if (argc == 1 && argv->is_array())
+		if (argc == 1 && argv && argv->is_array())
 		{
 			argc = argv->size();
 			argv = argv->as_array();
 		}
 
-		assert(argc > 0 && argv);
+		if (argc <= 0 || !argv)
+			argument_error(__FILE__, __LINE__);
 
 		if (convert)
 		{

data/.doc/ext/reflex/view.cpp

@@ -10,6 +10,7 @@
 #include "reflex/ruby/timer.h"
 #include "reflex/ruby/style.h"
 #include "reflex/ruby/shape.h"
+#include "reflex/ruby/constraint.h"
 #include "reflex/ruby/filter.h"
 #include "reflex/ruby/window.h"
 #include "defs.h"
@@ -94,7 +95,7 @@ static
 VALUE start_timer(VALUE self)
 {
 	CHECK;
-	check_arg_count(__FILE__, __LINE__, "View#start_timer", argc, 1, 2);
+	check_arg_count(__FILE__, __LINE__, "View#start_timer!", argc, 1, 2);
 
 	Reflex::Timer* timer = THIS->start_timer(
 		to<float>(argv[0]),
@@ -154,10 +155,10 @@ VALUE to_screen(VALUE self, VALUE point)
 }
 
 static
-VALUE add_child(VALUE self, VALUE child)
+VALUE add_child(VALUE self, VALUE child, VALUE index)
 {
 	CHECK;
-	THIS->add_child(to<Reflex::View*>(child));
+	THIS->add_child(to<Reflex::View*>(child), index.is_nil() ? -1 : to<int>(index));
 	return child;
 }
 
@@ -196,9 +197,11 @@ VALUE each_child(VALUE self)
 {
 	CHECK;
 
+	Reflex::View::ChildList children(THIS->child_begin(), THIS->child_end());
+
 	Value ret;
-	for (auto it = THIS->child_begin(), end = THIS->child_end(); it != end; ++it)
-		ret = rb_yield(value(it->get()));
+	for (auto& child : children)
+		ret = yield(value(child.get()));
 	return ret;
 }
 
@@ -251,10 +254,11 @@ VALUE each_style(VALUE self)
 {
 	CHECK;
 
+	Reflex::View::StyleList styles(THIS->style_begin(), THIS->style_end());
+
 	Value ret;
-	Reflex::View::style_iterator end = THIS->style_end();
-	for (Reflex::View::style_iterator it = THIS->style_begin(); it != end; ++it)
-		ret = rb_yield(value(*it));
+	for (auto& style : styles)
+		ret = yield(value(style));
 	return ret;
 }
 
@@ -290,10 +294,10 @@ VALUE get_shape(VALUE self)
 }
 
 static
-VALUE add_shape(VALUE self, VALUE shape)
+VALUE add_shape(VALUE self, VALUE shape, VALUE index)
 {
 	CHECK;
-	THIS->add_shape(to_shape(shape));
+	THIS->add_shape(to_shape(shape), index.is_nil() ? -1 : to<int>(index));
 	return shape;
 }
 
@@ -330,10 +334,45 @@ VALUE each_shape(VALUE self)
 {
 	CHECK;
 
+	Reflex::View::ShapeList shapes(THIS->shape_begin(), THIS->shape_end());
+
 	Value ret;
-	Reflex::View::shape_iterator end = THIS->shape_end();
-	for (Reflex::View::shape_iterator it = THIS->shape_begin(); it != end; ++it)
-		ret = rb_yield(value(it->get()));
+	for (auto& shape : shapes)
+		ret = yield(value(shape.get()));
+	return ret;
+}
+
+static
+VALUE clear_constraints(VALUE self)
+{
+	CHECK;
+	THIS->clear_constraints();
+	return self;
+}
+
+static
+VALUE find_constraints(VALUE self)
+{
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "View#find_constraints", argc, 1);
+
+	auto constraints =
+		THIS->find_constraints(to<Reflex::Selector>(argv[0])) |
+		std::views::transform([](auto& ref) {return value(ref.get());});
+	return array(constraints.begin(), constraints.end());
+}
+
+static
+VALUE each_constraint(VALUE self)
+{
+	CHECK;
+
+	Reflex::View::ConstraintList constraints(
+		THIS->constraint_begin(), THIS->constraint_end());
+
+	Value ret;
+	for (auto& constraint : constraints)
+		ret = yield(value(constraint.get()));
 	return ret;
 }
 
@@ -822,10 +861,8 @@ static
 VALUE update_world(VALUE self)
 {
 	CHECK;
-	check_arg_count(__FILE__, __LINE__, "View#update_world", argc, 0, 1);
 
-	float duration = argc >= 1 ? to<float>(argv[0]) : 0;
-	THIS->update_world(duration);
+	THIS->update_world();
 	return self;
 }
 
@@ -906,6 +943,20 @@ VALUE on_detach(VALUE self, VALUE event)
 	CALL(on_detach(to<Reflex::Event*>(event)));
 }
 
+static
+VALUE on_activate(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_activate(to<Reflex::Event*>(event)));
+}
+
+static
+VALUE on_deactivate(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_deactivate(to<Reflex::Event*>(event)));
+}
+
 static
 VALUE on_show(VALUE self, VALUE event)
 {
@@ -1032,6 +1083,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)
 {
@@ -1133,7 +1198,7 @@ Init_reflex_view ()
 	rb_define_method(cView, "focus", RUBY_METHOD_FUNC(focus), -1);
 	rb_define_method(cView, "blur", RUBY_METHOD_FUNC(blur), 0);
 	cView.define_method("focus?", has_focus);
-	rb_define_private_method(cView, "start_timer", RUBY_METHOD_FUNC(start_timer), -1);
+	cView.define_private_method("start_timer!", start_timer);
 	rb_define_method(cView, "update_layout", RUBY_METHOD_FUNC(update_layout), 0);
 
 	rb_define_method(cView, "from_parent", RUBY_METHOD_FUNC(from_parent), 1);
@@ -1143,25 +1208,29 @@ Init_reflex_view ()
 	rb_define_method(cView, "from_screen", RUBY_METHOD_FUNC(from_screen), 1);
 	rb_define_method(cView, "to_screen", RUBY_METHOD_FUNC(to_screen), 1);
 
-	rb_define_method(cView, "add_child", RUBY_METHOD_FUNC(add_child), 1);
+	cView.define_method(         "add_child!",     add_child);
 	rb_define_method(cView, "remove_child", RUBY_METHOD_FUNC(remove_child), 1);
 	rb_define_method(cView, "clear_children", RUBY_METHOD_FUNC(clear_children), 0);
 	rb_define_method(cView, "find_children", RUBY_METHOD_FUNC(find_children), -1);
-	rb_define_method(cView, "each_child", RUBY_METHOD_FUNC(each_child), 0);
+	cView.define_private_method("each_child!",    each_child);
 
 	rb_define_method(cView, "add_style", RUBY_METHOD_FUNC(add_style), 1);
 	rb_define_method(cView, "remove_style", RUBY_METHOD_FUNC(remove_style), 1);
 	rb_define_method(cView, "get_style", RUBY_METHOD_FUNC(get_style), 1);
 	rb_define_method(cView, "find_styles", RUBY_METHOD_FUNC(find_styles), -1);
-	rb_define_method(cView, "each_style", RUBY_METHOD_FUNC(each_style), 0);
+	cView.define_private_method("each_style!",  each_style);
 
 	rb_define_method(cView, "shape=", RUBY_METHOD_FUNC(set_shape), 1);
 	rb_define_method(cView, "shape", RUBY_METHOD_FUNC(get_shape), 0);
-	rb_define_method(cView, "add_shape", RUBY_METHOD_FUNC(add_shape), 1);
+	cView.define_method(         "add_shape!",   add_shape);
 	rb_define_method(cView, "remove_shape", RUBY_METHOD_FUNC(remove_shape), 1);
 	rb_define_method(cView, "clear_shapes", RUBY_METHOD_FUNC(clear_shapes), 0);
 	rb_define_method(cView, "find_shapes", RUBY_METHOD_FUNC(find_shapes), -1);
-	rb_define_method(cView, "each_shape", RUBY_METHOD_FUNC(each_shape), 0);
+	cView.define_private_method("each_shape!",  each_shape);
+
+	rb_define_method(cView, "clear_constraints", RUBY_METHOD_FUNC(clear_constraints), 0);
+	rb_define_method(cView, "find_constraints", RUBY_METHOD_FUNC(find_constraints), -1);
+	cView.define_private_method("each_constraint!",  each_constraint);
 
 	rb_define_method(cView, "filter=", RUBY_METHOD_FUNC(set_filter), 1);
 	rb_define_method(cView, "filter", RUBY_METHOD_FUNC(get_filter), 0);
@@ -1218,7 +1287,7 @@ Init_reflex_view ()
 	rb_define_method(cView, "gravity_scale", RUBY_METHOD_FUNC(get_gravity_scale), 0);
 
 	rb_define_method(cView, "create_world", RUBY_METHOD_FUNC(create_world), 1);
-	rb_define_method(cView, "update_world", RUBY_METHOD_FUNC(update_world), -1);
+	rb_define_method(cView, "update_world", RUBY_METHOD_FUNC(update_world), 0);
 	rb_define_method(cView, "meter2pixel", RUBY_METHOD_FUNC(meter2pixel), -1);
 	rb_define_method(cView, "gravity=", RUBY_METHOD_FUNC(set_gravity), -1);
 	rb_define_method(cView, "gravity", RUBY_METHOD_FUNC(get_gravity), 0);
@@ -1230,6 +1299,8 @@ Init_reflex_view ()
 
 	rb_define_method(cView, "on_attach", RUBY_METHOD_FUNC(on_attach), 1);
 	rb_define_method(cView, "on_detach", RUBY_METHOD_FUNC(on_detach), 1);
+	rb_define_method(cView, "on_activate", RUBY_METHOD_FUNC(on_activate), 1);
+	rb_define_method(cView, "on_deactivate", RUBY_METHOD_FUNC(on_deactivate), 1);
 	rb_define_method(cView, "on_show", RUBY_METHOD_FUNC(on_show), 1);
 	rb_define_method(cView, "on_hide", RUBY_METHOD_FUNC(on_hide), 1);
 	rb_define_method(cView, "on_update", RUBY_METHOD_FUNC(on_update), 1);
@@ -1248,6 +1319,8 @@ Init_reflex_view ()
 	rb_define_method(cView, "on_pointer_up", RUBY_METHOD_FUNC(on_pointer_up), 1);
 	rb_define_method(cView, "on_pointer_move", RUBY_METHOD_FUNC(on_pointer_move), 1);
 	rb_define_method(cView, "on_pointer_cancel", RUBY_METHOD_FUNC(on_pointer_cancel), 1);
+	rb_define_method(cView, "on_pointer_enter", RUBY_METHOD_FUNC(on_pointer_enter), 1);
+	rb_define_method(cView, "on_pointer_leave", RUBY_METHOD_FUNC(on_pointer_leave), 1);
 	rb_define_method(cView, "on_wheel", RUBY_METHOD_FUNC(on_wheel), 1);
 	rb_define_method(cView, "on_midi", RUBY_METHOD_FUNC(on_midi), 1);
 	rb_define_method(cView, "on_note", RUBY_METHOD_FUNC(on_note), 1);

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_OBJ(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/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"
 
 
@@ -76,6 +77,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 +114,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)
 {
@@ -239,20 +262,6 @@ VALUE get_painter(VALUE self)
 	return value(THIS->painter());
 }
 
-static
-VALUE on_activate(VALUE self, VALUE event)
-{
-	CHECK;
-	CALL(on_activate(to<Reflex::Event*>(event)));
-}
-
-static
-VALUE on_deactivate(VALUE self, VALUE event)
-{
-	CHECK;
-	CALL(on_deactivate(to<Reflex::Event*>(event)));
-}
-
 static
 VALUE on_show(VALUE self, VALUE event)
 {
@@ -278,6 +287,20 @@ VALUE on_close(VALUE self, VALUE event)
 	CALL(on_close(to<Reflex::Event*>(event)));
 }
 
+static
+VALUE on_activate(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_activate(to<Reflex::Event*>(event)));
+}
+
+static
+VALUE on_deactivate(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_deactivate(to<Reflex::Event*>(event)));
+}
+
 static
 VALUE on_update(VALUE self, VALUE event)
 {
@@ -362,6 +385,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)
 {
@@ -420,10 +457,13 @@ Init_reflex_window ()
 	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);
 	rb_define_method(cWindow, "minimizable=", RUBY_METHOD_FUNC(set_minimizable), 1);
@@ -439,11 +479,11 @@ Init_reflex_window ()
 	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);
@@ -456,6 +496,8 @@ Init_reflex_window ()
 	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_midi", RUBY_METHOD_FUNC(on_midi), 1);
 	rb_define_method(cWindow, "on_note", RUBY_METHOD_FUNC(on_note), 1);

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

@@ -26,8 +26,17 @@ jobs:
       - name: setup dependencies
         run: "ruby -I.github/workflows -rutils -e 'setup_dependencies'"
 
+      - name: packages
+        run: bundle exec rake packages
+
+      - name: setup zig
+        if: github.event.repository.name == 'reflex-terminal'
+        uses: mlugg/setup-zig@v2
+        with:
+          version: 0.16.0
+
       - name: test
-        run: bundle exec rake packages test
+        run: bundle exec rake test
 
       - name: create gem
         id: gem

data/.github/workflows/test.yml

@@ -27,6 +27,15 @@ jobs:
       - name: packages
         run: bundle exec rake verbose packages
 
+      - name: setup zig
+        if: github.event.repository.name == 'reflex-terminal'
+        uses: mlugg/setup-zig@v2
+        with:
+          version: 0.16.0
+
+      - name: vendor
+        run: bundle exec rake vendor
+
       - name: lib
         run: bundle exec rake verbose lib