reflexion 0.5.3 → 0.7.0

data/.doc/ext/reflex/pin.cpp

@@ -0,0 +1,156 @@
+#include "reflex/ruby/pin.h"
+
+
+#include <rays/ruby/point.h>
+#include "reflex/ruby/constraint.h"
+#include "reflex/ruby/view.h"
+#include "defs.h"
+
+
+RUCY_DEFINE_VALUE_OR_ARRAY_FROM_TO(REFLEX_EXPORT, Reflex::Pin)
+
+#define THIS  to<Reflex::Pin*>(self)
+
+#define CHECK RUCY_CHECK_PTR(Reflex::Pin, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return new_type<Reflex::Pin>(klass);
+}
+
+static
+VALUE initialize(VALUE self)
+{
+	CHECK;
+	*THIS = to<Reflex::Pin>(argc, argv);
+}
+
+static
+VALUE initialize_copy(VALUE self, VALUE obj)
+{
+	CHECK;
+	*THIS = to<Reflex::Pin&>(obj);
+}
+
+static
+VALUE snap(VALUE self)
+{
+	CHECK;
+	return value(THIS->snap(to<Reflex::Pin>(argc, argv)));
+}
+
+static
+VALUE link(VALUE self)
+{
+	CHECK;
+	return value(THIS->link(to<Reflex::Pin>(argc, argv)));
+}
+
+static
+VALUE wheel(VALUE self)
+{
+	CHECK;
+	return value(THIS->wheel(to<Reflex::Pin>(argc, argv)));
+}
+
+static
+VALUE chase(VALUE self)
+{
+	CHECK;
+	return value(THIS->chase(to<Reflex::Pin>(argc, argv)));
+}
+
+static
+VALUE get_view(VALUE self)
+{
+	CHECK;
+	return value(THIS->view());
+}
+
+static
+VALUE get_position(VALUE self)
+{
+	CHECK;
+	const Rays::Point* pos = THIS->position();
+	return pos ? value(*pos) : nil();
+}
+
+
+static Class cPin;
+
+void
+Init_reflex_pin ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cPin = rb_define_class_under(mReflex, "Pin", rb_cObject);
+	rb_define_alloc_func(cPin, alloc);
+	rb_define_private_method(cPin, "initialize", RUBY_METHOD_FUNC(initialize), -1);
+	rb_define_private_method(cPin, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
+	cPin.define_private_method("snap!",  snap);
+	cPin.define_private_method("link!",  link);
+	cPin.define_private_method("wheel!", wheel);
+	cPin.define_private_method("chase!", chase);
+	rb_define_method(cPin, "view", RUBY_METHOD_FUNC(get_view), 0);
+	rb_define_method(cPin, "position", RUBY_METHOD_FUNC(get_position), 0);
+}
+
+
+namespace Rucy
+{
+
+
+	template <> REFLEX_EXPORT Reflex::Pin
+	value_to<Reflex::Pin> (int argc, const Value* argv, bool convert)
+	{
+		if (argc == 1 && argv && argv->is_array())
+		{
+			argc = argv->size();
+			argv = argv->as_array();
+		}
+
+		if (convert)
+		{
+			if (argc == 0 || argv->is_nil())
+				return Reflex::Pin();
+
+			if (argv->is_a(Reflex::view_class()))
+			{
+				Reflex::View* view = value_to<Reflex::View*>(*argv);
+				argc -= 1;
+				argv += 1;
+
+				if (argc == 0)
+					return Reflex::Pin(view);
+				else
+					return Reflex::Pin(view, value_to<Rays::Point>(argc, argv, convert));
+			}
+
+			if (!argv->is_a(Reflex::pin_class()))
+				return Reflex::Pin(value_to<Rays::Point>(argc, argv, convert));
+		}
+
+		if (argc != 1)
+			argument_error(__FILE__, __LINE__);
+
+		return value_to<Reflex::Pin&>(*argv, convert);
+	}
+
+
+}// Rucy
+
+
+namespace Reflex
+{
+
+
+	Class
+	pin_class ()
+	{
+		return cPin;
+	}
+
+
+}// Reflex

data/.doc/ext/reflex/pointer.cpp

@@ -9,7 +9,7 @@ RUCY_DEFINE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::Pointer)
 
 #define THIS  to<Reflex::Pointer*>(self)
 
-#define CHECK RUCY_CHECK_OBJ(Reflex::Pointer, self)
+#define CHECK RUCY_CHECK_PTR(Reflex::Pointer, self)
 
 
 static
@@ -150,6 +150,8 @@ Init_reflex_pointer ()
 	cPointer.define_const("UP",          Reflex::Pointer::UP);
 	cPointer.define_const("MOVE",        Reflex::Pointer::MOVE);
 	cPointer.define_const("CANCEL",      Reflex::Pointer::CANCEL);
+	cPointer.define_const("ENTER",       Reflex::Pointer::ENTER);
+	cPointer.define_const("LEAVE",       Reflex::Pointer::LEAVE);
 	cPointer.define_const("STAY",        Reflex::Pointer::STAY);
 }
 

data/.doc/ext/reflex/pointer_event.cpp

@@ -11,7 +11,7 @@ RUCY_DEFINE_VALUE_FROM_TO(REFLEX_EXPORT, Reflex::PointerEvent)
 
 #define THIS  to<Reflex::PointerEvent*>(self)
 
-#define CHECK RUCY_CHECK_OBJ(Reflex::PointerEvent, self)
+#define CHECK RUCY_CHECK_PTR(Reflex::PointerEvent, self)
 
 
 static
@@ -32,7 +32,7 @@ VALUE initialize(VALUE self)
 	for (size_t i = 0; i < argc; ++i)
 		pointers.emplace_back(to<Reflex::Pointer&>(argv[i]));
 
-	*THIS = Reflex::PointerEvent(&pointers[0], pointers.size());
+	*THIS = Reflex::PointerEvent(pointers.data(), pointers.size());
 	return rb_call_super(0, NULL);
 }
 
@@ -85,7 +85,7 @@ VALUE each(VALUE self)
 
 	Value ret;
 	for (size_t i = 0, size = THIS->size(); i < size; ++i)
-		ret = rb_yield(value((*THIS)[i]));
+		ret = yield(value((*THIS)[i]));
 	return ret;
 }
 

data/.doc/ext/reflex/polygon_shape.cpp

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

data/.doc/ext/reflex/rect_shape.cpp

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