reflexion 0.5.2 → 0.6.0

data/ext/reflex/snap_constraint.cpp

@@ -0,0 +1,135 @@
+#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
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	Reflex::reflex_error(
+		__FILE__, __LINE__, "can not instantiate SnapConstraint class");
+}
+RUCY_END
+
+static
+RUCY_DEF2(set_angle, min, max)
+{
+	CHECK;
+	THIS->set_angle(to<float>(min), to<float>(max));
+}
+RUCY_END
+
+static
+RUCY_DEF0(clear_angle)
+{
+	CHECK;
+	THIS->clear_angle();
+}
+RUCY_END
+
+static
+RUCY_DEF0(angle_min)
+{
+	CHECK;
+	return value(THIS->angle_min());
+}
+RUCY_END
+
+static
+RUCY_DEF0(angle_max)
+{
+	CHECK;
+	return value(THIS->angle_max());
+}
+RUCY_END
+
+static
+RUCY_DEF0(has_angle)
+{
+	CHECK;
+	return value(THIS->has_angle());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_motor, degrees_per_second)
+{
+	CHECK;
+
+	if (degrees_per_second.is_nil())
+		THIS->clear_motor();
+	else
+		THIS->set_motor(to<float>(degrees_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_torque)
+{
+	CHECK;
+	if (max_torque.is_nil())
+		THIS->clear_force();
+	else
+		THIS->set_force(to<float>(max_torque));
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_force)
+{
+	CHECK;
+	return THIS->has_force() ? value(THIS->force()) : nil();
+}
+RUCY_END
+
+
+static Class cSnapConstraint;
+
+void
+Init_reflex_snap_constraint ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cSnapConstraint = mReflex.define_class("SnapConstraint", Reflex::constraint_class());
+	cSnapConstraint.define_alloc_func(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);
+	cSnapConstraint.define_method("motor=", set_motor);
+	cSnapConstraint.define_method("motor",  get_motor);
+	cSnapConstraint.define_method("force=", set_force);
+	cSnapConstraint.define_method("force",  get_force);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	snap_constraint_class ()
+	{
+		return cSnapConstraint;
+	}
+
+
+}// Reflex

data/ext/reflex/style_length.cpp

@@ -219,13 +219,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/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"
@@ -102,7 +103,7 @@ static
 RUCY_DEFN(start_timer)
 {
 	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]),
@@ -170,10 +171,10 @@ RUCY_DEF1(to_screen, point)
 RUCY_END
 
 static
-RUCY_DEF1(add_child, child)
+RUCY_DEF2(add_child, child, 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;
 }
 RUCY_END
@@ -216,9 +217,11 @@ RUCY_DEF0(each_child)
 {
 	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;
 }
 RUCY_END
@@ -276,10 +279,11 @@ RUCY_DEF0(each_style)
 {
 	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;
 }
 RUCY_END
@@ -318,10 +322,10 @@ RUCY_DEF0(get_shape)
 RUCY_END
 
 static
-RUCY_DEF1(add_shape, shape)
+RUCY_DEF2(add_shape, shape, index)
 {
 	CHECK;
-	THIS->add_shape(to_shape(shape));
+	THIS->add_shape(to_shape(shape), index.is_nil() ? -1 : to<int>(index));
 	return shape;
 }
 RUCY_END
@@ -362,10 +366,48 @@ RUCY_DEF0(each_shape)
 {
 	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;
+}
+RUCY_END
+
+static
+RUCY_DEF0(clear_constraints)
+{
+	CHECK;
+	THIS->clear_constraints();
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEFN(find_constraints)
+{
+	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());
+}
+RUCY_END
+
+static
+RUCY_DEF0(each_constraint)
+{
+	CHECK;
+
+	Reflex::View::ConstraintList constraints(
+		THIS->constraint_begin(), THIS->constraint_end());
+
+	Value ret;
+	for (auto& constraint : constraints)
+		ret = yield(value(constraint.get()));
 	return ret;
 }
 RUCY_END
@@ -904,13 +946,11 @@ RUCY_DEF1(create_world, pixels_per_meter)
 RUCY_END
 
 static
-RUCY_DEFN(update_world)
+RUCY_DEF0(update_world)
 {
 	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;
 }
 RUCY_END
@@ -1002,6 +1042,22 @@ RUCY_DEF1(on_detach, event)
 }
 RUCY_END
 
+static
+RUCY_DEF1(on_activate, event)
+{
+	CHECK;
+	CALL(on_activate(to<Reflex::Event*>(event)));
+}
+RUCY_END
+
+static
+RUCY_DEF1(on_deactivate, event)
+{
+	CHECK;
+	CALL(on_deactivate(to<Reflex::Event*>(event)));
+}
+RUCY_END
+
 static
 RUCY_DEF1(on_show, event)
 {
@@ -1146,6 +1202,22 @@ RUCY_DEF1(on_pointer_cancel, event)
 }
 RUCY_END
 
+static
+RUCY_DEF1(on_pointer_enter, event)
+{
+	CHECK;
+	CALL(on_pointer_enter(to<Reflex::PointerEvent*>(event)));
+}
+RUCY_END
+
+static
+RUCY_DEF1(on_pointer_leave, event)
+{
+	CHECK;
+	CALL(on_pointer_leave(to<Reflex::PointerEvent*>(event)));
+}
+RUCY_END
+
 static
 RUCY_DEF1(on_wheel, event)
 {
@@ -1259,7 +1331,7 @@ Init_reflex_view ()
 	cView.define_method("focus",  focus);
 	cView.define_method("blur",   blur);
 	cView.define_method("focus?", has_focus);
-	cView.define_private_method("start_timer", start_timer);
+	cView.define_private_method("start_timer!", start_timer);
 	cView.define_method("update_layout", update_layout);
 
 	cView.define_method("from_parent", from_parent);
@@ -1269,25 +1341,29 @@ Init_reflex_view ()
 	cView.define_method("from_screen", from_screen);
 	cView.define_method(  "to_screen",   to_screen);
 
-	cView.define_method(   "add_child",      add_child);
-	cView.define_method("remove_child",   remove_child);
-	cView.define_method( "clear_children", clear_children);
-	cView.define_method(  "find_children",  find_children);
-	cView.define_method(  "each_child",     each_child);
-
-	cView.define_method(   "add_style",    add_style);
-	cView.define_method("remove_style", remove_style);
-	cView.define_method(   "get_style",    get_style);
-	cView.define_method(  "find_styles",  find_styles);
-	cView.define_method(  "each_style",   each_style);
-
-	cView.define_method(       "shape=",   set_shape);
-	cView.define_method(       "shape",    get_shape);
-	cView.define_method(   "add_shape",    add_shape);
-	cView.define_method("remove_shape", remove_shape);
-	cView.define_method( "clear_shapes", clear_shapes);
-	cView.define_method(  "find_shapes",  find_shapes);
-	cView.define_method(  "each_shape",   each_shape);
+	cView.define_method(         "add_child!",     add_child);
+	cView.define_method(      "remove_child",   remove_child);
+	cView.define_method(       "clear_children", clear_children);
+	cView.define_method(        "find_children",  find_children);
+	cView.define_private_method("each_child!",    each_child);
+
+	cView.define_method(         "add_style",    add_style);
+	cView.define_method(      "remove_style", remove_style);
+	cView.define_method(         "get_style",    get_style);
+	cView.define_method(        "find_styles",  find_styles);
+	cView.define_private_method("each_style!",  each_style);
+
+	cView.define_method(             "shape=",   set_shape);
+	cView.define_method(             "shape",    get_shape);
+	cView.define_method(         "add_shape!",   add_shape);
+	cView.define_method(      "remove_shape", remove_shape);
+	cView.define_method(       "clear_shapes", clear_shapes);
+	cView.define_method(        "find_shapes",  find_shapes);
+	cView.define_private_method("each_shape!",  each_shape);
+
+	cView.define_method(       "clear_constraints", clear_constraints);
+	cView.define_method(        "find_constraints",  find_constraints);
+	cView.define_private_method("each_constraint!",  each_constraint);
 
 	cView.define_method("filter=", set_filter);
 	cView.define_method("filter",  get_filter);
@@ -1356,6 +1432,8 @@ Init_reflex_view ()
 
 	cView.define_method("on_attach", on_attach);
 	cView.define_method("on_detach", on_detach);
+	cView.define_method("on_activate",   on_activate);
+	cView.define_method("on_deactivate", on_deactivate);
 	cView.define_method("on_show",   on_show);
 	cView.define_method("on_hide",   on_hide);
 	cView.define_method("on_update", on_update);
@@ -1374,6 +1452,8 @@ Init_reflex_view ()
 	cView.define_method("on_pointer_up",     on_pointer_up);
 	cView.define_method("on_pointer_move",   on_pointer_move);
 	cView.define_method("on_pointer_cancel", on_pointer_cancel);
+	cView.define_method("on_pointer_enter",  on_pointer_enter);
+	cView.define_method("on_pointer_leave",  on_pointer_leave);
 	cView.define_method("on_wheel",          on_wheel);
 	cView.define_method("on_midi",           on_midi);
 	cView.define_method("on_note",           on_note);

data/ext/reflex/wheel_constraint.cpp

@@ -0,0 +1,154 @@
+#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
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	Reflex::reflex_error(
+		__FILE__, __LINE__, "can not instantiate WheelConstraint class");
+}
+RUCY_END
+
+static
+RUCY_DEFN(set_axis)
+{
+	CHECK;
+	THIS->set_axis(to<Rays::Point>(argc, argv));
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_axis)
+{
+	CHECK;
+	return value(THIS->axis());
+}
+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, degrees_per_second)
+{
+	CHECK;
+	if (degrees_per_second.is_nil())
+		THIS->clear_motor();
+	else
+		THIS->set_motor(to<float>(degrees_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_torque)
+{
+	CHECK;
+	if (max_torque.is_nil())
+		THIS->clear_force();
+	else
+		THIS->set_force(to<float>(max_torque));
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_force)
+{
+	CHECK;
+	return THIS->has_force() ? value(THIS->force()) : nil();
+}
+RUCY_END
+
+
+static Class cWheelConstraint;
+
+void
+Init_reflex_wheel_constraint ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cWheelConstraint = mReflex.define_class(
+		"WheelConstraint", Reflex::constraint_class());
+	cWheelConstraint.define_alloc_func(alloc);
+	cWheelConstraint.define_method("axis=", set_axis);
+	cWheelConstraint.define_method("axis",  get_axis);
+	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);
+	cWheelConstraint.define_method("motor=", set_motor);
+	cWheelConstraint.define_method("motor",  get_motor);
+	cWheelConstraint.define_method("force=", set_force);
+	cWheelConstraint.define_method("force",  get_force);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	wheel_constraint_class ()
+	{
+		return cWheelConstraint;
+	}
+
+
+}// Reflex