reflexion 0.5.3 → 0.7.0

data/.doc/ext/reflex/screen.cpp

@@ -1,6 +1,7 @@
 #include "reflex/ruby/screen.h"
 
 
+#include <ranges>
 #include <rays/ruby/bounds.h>
 #include "defs.h"
 
@@ -9,7 +10,7 @@ RUCY_DEFINE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::Screen)
 
 #define THIS  to<Reflex::Screen*>(self)
 
-#define CHECK RUCY_CHECK_OBJECT(Reflex::Screen, self)
+#define CHECK RUCY_CHECK_OBJ(Reflex::Screen, self)
 
 
 static
@@ -18,6 +19,13 @@ VALUE alloc(VALUE klass)
 	Reflex::reflex_error(__FILE__, __LINE__, "can not instantiate Screen class.");
 }
 
+static
+VALUE get_name(VALUE self)
+{
+	CHECK;
+	return value(THIS->name());
+}
+
 static
 VALUE get_frame(VALUE self)
 {
@@ -25,6 +33,21 @@ VALUE get_frame(VALUE self)
 	return value(THIS->frame());
 }
 
+static
+VALUE get_pixel_density(VALUE self)
+{
+	CHECK;
+	return value(THIS->pixel_density());
+}
+
+static
+VALUE get_all(VALUE self)
+{
+	auto list = Reflex::Screen::all() |
+		std::views::transform([](const Reflex::Screen& s) {return value(s);});
+	return array(list.begin(), list.end());
+}
+
 
 static Class cScreen;
 
@@ -35,7 +58,10 @@ Init_reflex_screen ()
 
 	cScreen = rb_define_class_under(mReflex, "Screen", rb_cObject);
 	rb_define_alloc_func(cScreen, alloc);
+	rb_define_method(cScreen, "name", RUBY_METHOD_FUNC(get_name), 0);
 	rb_define_method(cScreen, "frame", RUBY_METHOD_FUNC(get_frame), 0);
+	rb_define_method(cScreen, "pixel_density", RUBY_METHOD_FUNC(get_pixel_density), 0);
+	rb_define_singleton_method(cScreen, "all", RUBY_METHOD_FUNC(get_all), 0);
 }
 
 

data/.doc/ext/reflex/scroll_event.cpp

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

data/.doc/ext/reflex/selector.cpp

@@ -1,7 +1,6 @@
 #include "reflex/ruby/selector.h"
 
 
-#include <assert.h>
 #include "defs.h"
 
 
@@ -10,7 +9,7 @@ RUCY_DEFINE_VALUE_OR_ARRAY_FROM_TO(REFLEX_EXPORT, Reflex::Selector)
 #define   THIS to<      Reflex::Selector*>(self)
 #define C_THIS to<const Reflex::Selector*>(self)
 
-#define CHECK RUCY_CHECK_OBJ(Reflex::Selector, self)
+#define CHECK RUCY_CHECK_PTR(Reflex::Selector, self)
 
 
 static
@@ -78,7 +77,7 @@ VALUE each_tag(VALUE self)
 	Value ret;
 	Reflex::Selector::const_iterator end = C_THIS->end();
 	for (Reflex::Selector::const_iterator it = C_THIS->begin(); it != end; ++it)
-		ret = rb_yield(value(*it));
+		ret = yield(value(*it));
 	return ret;
 }
 
@@ -134,13 +133,14 @@ namespace Rucy
 	template <> REFLEX_EXPORT Reflex::Selector
 	value_to<Reflex::Selector> (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/shape.cpp

@@ -12,7 +12,7 @@ RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::Shape)
 
 #define THIS      to<Reflex::Shape*>(self)
 
-#define CHECK     RUCY_CHECK_OBJ(Reflex::Shape, self)
+#define CHECK     RUCY_CHECK_PTR(Reflex::Shape, self)
 
 #define CALL(fun) RUCY_CALL_SUPER(THIS, fun)
 

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_PTR(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.cpp

@@ -13,7 +13,7 @@ RUCY_DEFINE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::Style)
 #define   THIS to<      Reflex::Style*>(self)
 #define C_THIS to<const Reflex::Style*>(self)
 
-#define CHECK  RUCY_CHECK_OBJ(Reflex::Style, self)
+#define CHECK  RUCY_CHECK_PTR(Reflex::Style, self)
 
 
 static

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

@@ -9,7 +9,7 @@ RUCY_DEFINE_VALUE_OR_ARRAY_FROM_TO(REFLEX_EXPORT, Reflex::StyleLength)
 
 #define THIS  to<Reflex::StyleLength*>(self)
 
-#define CHECK RUCY_CHECK_OBJ(Reflex::StyleLength, self)
+#define CHECK RUCY_CHECK_PTR(Reflex::StyleLength, self)
 
 
 static
@@ -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/text_event.cpp

@@ -0,0 +1,104 @@
+#include "reflex/ruby/event.h"
+
+
+#include "defs.h"
+
+
+RUCY_DEFINE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::TextEvent)
+
+#define THIS  to<Reflex::TextEvent*>(self)
+
+#define CHECK RUCY_CHECK_PTR(Reflex::TextEvent, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return new_type<Reflex::TextEvent>(klass);
+}
+
+static
+VALUE initialize(VALUE self, VALUE action, VALUE text, VALUE selection_offset, VALUE selection_size)
+{
+	CHECK;
+
+	*THIS = Reflex::TextEvent(
+		(Reflex::TextEvent::Action) to<uint>(action),
+		text.is_nil() ? "" : text.c_str(),
+		to<int>(selection_offset),
+		to<int>(selection_size));
+
+	return rb_call_super(0, NULL);
+}
+
+static
+VALUE initialize_copy(VALUE self, VALUE obj)
+{
+	CHECK;
+	*THIS = to<Reflex::TextEvent&>(obj).dup();
+	return self;
+}
+
+static
+VALUE get_action(VALUE self)
+{
+	CHECK;
+	return value(THIS->action());
+}
+
+static
+VALUE get_text(VALUE self)
+{
+	CHECK;
+	return value(THIS->text());
+}
+
+static
+VALUE get_selection_offset(VALUE self)
+{
+	CHECK;
+	return value(THIS->selection_offset());
+}
+
+static
+VALUE get_selection_size(VALUE self)
+{
+	CHECK;
+	return value(THIS->selection_size());
+}
+
+
+static Class cTextEvent;
+
+void
+Init_reflex_text_event ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cTextEvent = mReflex.define_class("TextEvent", Reflex::event_class());
+	rb_define_alloc_func(cTextEvent, alloc);
+	rb_define_private_method(cTextEvent, "initialize", RUBY_METHOD_FUNC(initialize), 4);
+	rb_define_private_method(cTextEvent, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
+	rb_define_method(cTextEvent, "action", RUBY_METHOD_FUNC(get_action), 0);
+	rb_define_method(cTextEvent, "text", RUBY_METHOD_FUNC(get_text), 0);
+	cTextEvent.define_private_method("selection_offset!", get_selection_offset);
+	cTextEvent.define_private_method("selection_size!",   get_selection_size);
+
+	cTextEvent.define_const("ACTION_NONE", Reflex::TextEvent::ACTION_NONE);
+	cTextEvent.define_const("PREEDIT",     Reflex::TextEvent::PREEDIT);
+	cTextEvent.define_const("COMMIT",      Reflex::TextEvent::COMMIT);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	text_event_class ()
+	{
+		return cTextEvent;
+	}
+
+
+}// Reflex

data/.doc/ext/reflex/timer.cpp

@@ -12,7 +12,7 @@ RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::Timer)
 
 #define THIS      to<Reflex::Timer*>(self)
 
-#define CHECK     RUCY_CHECK_OBJ(Reflex::Timer, self)
+#define CHECK     RUCY_CHECK_PTR(Reflex::Timer, self)
 
 #define CALL(fun) RUCY_CALL_SUPER(THIS, fun)
 

data/.doc/ext/reflex/timer_event.cpp

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

data/.doc/ext/reflex/update_event.cpp

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