reflexion 0.5.3 → 0.7.0

data/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
@@ -19,6 +20,14 @@ RUCY_DEF_ALLOC(alloc, klass)
 }
 RUCY_END
 
+static
+RUCY_DEF0(get_name)
+{
+	CHECK;
+	return value(THIS->name());
+}
+RUCY_END
+
 static
 RUCY_DEF0(get_frame)
 {
@@ -27,6 +36,23 @@ RUCY_DEF0(get_frame)
 }
 RUCY_END
 
+static
+RUCY_DEF0(get_pixel_density)
+{
+	CHECK;
+	return value(THIS->pixel_density());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_all)
+{
+	auto list = Reflex::Screen::all() |
+		std::views::transform([](const Reflex::Screen& s) {return value(s);});
+	return array(list.begin(), list.end());
+}
+RUCY_END
+
 
 static Class cScreen;
 
@@ -37,7 +63,10 @@ Init_reflex_screen ()
 
 	cScreen = mReflex.define_class("Screen");
 	cScreen.define_alloc_func(alloc);
-	cScreen.define_method("frame", get_frame);
+	cScreen.define_method("name",          get_name);
+	cScreen.define_method("frame",         get_frame);
+	cScreen.define_method("pixel_density", get_pixel_density);
+	cScreen.define_singleton_method("all", get_all);
 }
 
 

data/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/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
@@ -86,7 +85,7 @@ RUCY_DEF0(each_tag)
 	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;
 }
 RUCY_END
@@ -146,13 +145,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/ext/reflex/selector.h

@@ -11,7 +11,7 @@ template <typename T>
 static
 RUCY_DEF1(set_name, name)
 {
-	RUCY_CHECK_OBJ(T, self);
+	RUCY_CHECK_PTR(T, self);
 	Reflex::HasSelector* this_ = Rucy::to<T*>(self);
 
 	this_->set_name(name.is_nil() ? NULL : name.c_str());
@@ -22,7 +22,7 @@ template <typename T>
 static
 RUCY_DEF0(get_name)
 {
-	RUCY_CHECK_OBJ(T, self);
+	RUCY_CHECK_PTR(T, self);
 	const Reflex::HasSelector* this_ = Rucy::to<const T*>(self);
 
 	return this_->name() ? Rucy::value(this_->name()) : Rucy::nil();
@@ -33,7 +33,7 @@ template <typename T>
 static
 RUCY_DEF1(add_tag, tag)
 {
-	RUCY_CHECK_OBJ(T, self);
+	RUCY_CHECK_PTR(T, self);
 	Reflex::HasSelector* this_ = Rucy::to<T*>(self);
 
 	this_->add_tag(tag.c_str());
@@ -44,7 +44,7 @@ template <typename T>
 static
 RUCY_DEF1(remove_tag, tag)
 {
-	RUCY_CHECK_OBJ(T, self);
+	RUCY_CHECK_PTR(T, self);
 	Reflex::HasSelector* this_ = Rucy::to<T*>(self);
 
 	this_->remove_tag(tag.c_str());
@@ -55,7 +55,7 @@ template <typename T>
 static
 RUCY_DEF0(clear_tags)
 {
-	RUCY_CHECK_OBJ(T, self);
+	RUCY_CHECK_PTR(T, self);
 	Reflex::HasSelector* this_ = Rucy::to<T*>(self);
 
 	this_->clear_tags();
@@ -66,7 +66,7 @@ template <typename T>
 static
 RUCY_DEF1(has_tag, tag)
 {
-	RUCY_CHECK_OBJ(T, self);
+	RUCY_CHECK_PTR(T, self);
 	const Reflex::HasSelector* this_ = Rucy::to<const T*>(self);
 
 	return Rucy::value(this_->has_tag(tag.c_str()));
@@ -77,13 +77,13 @@ template <typename T>
 static
 RUCY_DEF0(each_tag)
 {
-	RUCY_CHECK_OBJ(T, self);
+	RUCY_CHECK_PTR(T, self);
 	const Reflex::HasSelector* this_ = Rucy::to<const T*>(self);
 
 	Rucy::Value ret;
 	Reflex::Selector::const_iterator end = this_->tag_end();
 	for (Reflex::Selector::const_iterator it = this_->tag_begin(); it != end; ++it)
-		ret = rb_yield(Rucy::value(*it));
+		ret = Rucy::yield(Rucy::value(*it));
 	return ret;
 }
 RUCY_END
@@ -92,7 +92,7 @@ template <typename T>
 static
 RUCY_DEF1(set_selector, selector)
 {
-	RUCY_CHECK_OBJ(T, self);
+	RUCY_CHECK_PTR(T, self);
 	Reflex::HasSelector* this_ = Rucy::to<T*>(self);
 
 	this_->set_selector(Rucy::to<Reflex::Selector>(selector));
@@ -103,7 +103,7 @@ template <typename T>
 static
 RUCY_DEF0(get_selector)
 {
-	RUCY_CHECK_OBJ(T, self);
+	RUCY_CHECK_PTR(T, self);
 	const Reflex::HasSelector* this_ = Rucy::to<const T*>(self);
 
 	return Rucy::value(this_->selector());

data/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/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_PTR(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.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/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
@@ -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/text_event.cpp

@@ -0,0 +1,111 @@
+#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
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return new_type<Reflex::TextEvent>(klass);
+}
+RUCY_END
+
+static
+RUCY_DEF4(initialize, action, text, selection_offset, 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);
+}
+RUCY_END
+
+static
+RUCY_DEF1(initialize_copy, obj)
+{
+	CHECK;
+	*THIS = to<Reflex::TextEvent&>(obj).dup();
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_action)
+{
+	CHECK;
+	return value(THIS->action());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_text)
+{
+	CHECK;
+	return value(THIS->text());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_selection_offset)
+{
+	CHECK;
+	return value(THIS->selection_offset());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_selection_size)
+{
+	CHECK;
+	return value(THIS->selection_size());
+}
+RUCY_END
+
+
+static Class cTextEvent;
+
+void
+Init_reflex_text_event ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cTextEvent = mReflex.define_class("TextEvent", Reflex::event_class());
+	cTextEvent.define_alloc_func(alloc);
+	cTextEvent.define_private_method("initialize",      initialize);
+	cTextEvent.define_private_method("initialize_copy", initialize_copy);
+	cTextEvent.define_method("action", get_action);
+	cTextEvent.define_method("text",   get_text);
+	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/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/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/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