reflexion 0.1.11 → 0.1.16

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

@@ -1,16 +1,10 @@
 #include "reflex/ruby/event.h"
 
 
-#include <rucy.h>
 #include <rays/ruby/point.h>
 #include "defs.h"
 
 
-using namespace Rucy;
-
-using Reflex::coord;
-
-
 RUCY_DEFINE_VALUE_FROM_TO(Reflex::PointerEvent)
 
 #define THIS  to<Reflex::PointerEvent*>(self)
@@ -25,19 +19,23 @@ VALUE alloc(VALUE klass)
 }
 
 static
-VALUE initialize(VALUE self)
+VALUE initialize(VALUE self, VALUE type, VALUE pointer_type, VALUE modifiers, VALUE count, VALUE drag, VALUE positions)
 {
 	CHECK;
-	check_arg_count(__FILE__, __LINE__, "PointerEvent#initialize", argc, 0, 1, 2, 3, 4, 5, 6, 7);
 
-	THIS->type         = (argc >= 1) ? (Reflex::PointerEvent::Type) to<int>(argv[0]) : Reflex::PointerEvent::NONE;
-	THIS->pointer_type = (argc >= 2) ? to<uint>(argv[1])  : Reflex::POINTER_NONE;
-	THIS->x            = (argc >= 3) ? to<coord>(argv[2]) : 0;
-	THIS->y            = (argc >= 4) ? to<coord>(argv[3]) : 0;
-	THIS->size         = 1;
-	THIS->modifiers    = (argc >= 5) ? to<uint>(argv[4])  : (uint) Reflex::MOD_NONE;
-	THIS->count        = (argc >= 6) ? to<uint>(argv[5])  : 0;
-	THIS->drag         = (argc >= 7) ? to<bool>(argv[6])  : false;
+	int size = positions.size();
+	if (size <= 0 || Reflex::PointerEvent::MAX < size)
+		argument_error(__FILE__, __LINE__);
+
+	THIS->type         = (Reflex::PointerEvent::Type) to<int>(type);
+	THIS->pointer_type = to<uint>(pointer_type);
+	THIS->modifiers    = to<uint>(modifiers);
+	THIS->count        = to<uint>(count);
+	THIS->drag         = to<bool>(drag);
+	THIS->size         = (size_t) size;
+
+	for (int i = 0; i < size; ++i)
+		THIS->positions[i] = to<Rays::Point>(positions[i]);
 
 	return rb_call_super(0, NULL);
 }
@@ -51,14 +49,14 @@ VALUE initialize_copy(VALUE self, VALUE obj)
 }
 
 static
-VALUE get_type(VALUE self)
+VALUE type(VALUE self)
 {
 	CHECK;
 	return value(THIS->type);
 }
 
 static
-VALUE get_pointer_type(VALUE self)
+VALUE pointer_type(VALUE self)
 {
 	CHECK;
 	return value(THIS->pointer_type);
@@ -124,10 +122,15 @@ VALUE position(VALUE self)
 }
 
 static
-VALUE array_get(VALUE self, VALUE index)
+VALUE get_at(VALUE self, VALUE index)
 {
 	CHECK;
-	return value((*THIS)[index.to_i()]);
+
+	int i = to<int>(index);
+	if (i < 0 || THIS->size <= (size_t) i)
+		index_error(__FILE__, __LINE__);
+
+	return value((*THIS)[i]);
 }
 
 
@@ -140,10 +143,10 @@ Init_pointer_event ()
 
 	cPointerEvent = mReflex.define_class("PointerEvent", Reflex::event_class());
 	rb_define_alloc_func(cPointerEvent, alloc);
-	rb_define_private_method(cPointerEvent, "initialize", RUBY_METHOD_FUNC(initialize), -1);
+	rb_define_private_method(cPointerEvent, "initialize", RUBY_METHOD_FUNC(initialize), 6);
 	rb_define_private_method(cPointerEvent, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
-	rb_define_method(cPointerEvent, "get_type", RUBY_METHOD_FUNC(get_type), 0);
-	rb_define_method(cPointerEvent, "get_pointer_type", RUBY_METHOD_FUNC(get_pointer_type), 0);
+	rb_define_method(cPointerEvent, "type", RUBY_METHOD_FUNC(type), 0);
+	rb_define_method(cPointerEvent, "pointer_type", RUBY_METHOD_FUNC(pointer_type), 0);
 	rb_define_method(cPointerEvent, "size", RUBY_METHOD_FUNC(size), 0);
 	rb_define_method(cPointerEvent, "modifiers", RUBY_METHOD_FUNC(modifiers), 0);
 	rb_define_method(cPointerEvent, "count", RUBY_METHOD_FUNC(count), 0);
@@ -152,7 +155,7 @@ Init_pointer_event ()
 	rb_define_method(cPointerEvent, "x", RUBY_METHOD_FUNC(x), 0);
 	rb_define_method(cPointerEvent, "y", RUBY_METHOD_FUNC(y), 0);
 	rb_define_method(cPointerEvent, "position", RUBY_METHOD_FUNC(position), -1);
-	cPointerEvent.define_method("[]", array_get);
+	cPointerEvent.define_method("[]", get_at);
 	cPointerEvent.define_const("TYPE_NONE", Reflex::PointerEvent::NONE);
 	cPointerEvent.define_const("TYPE_DOWN", Reflex::PointerEvent::DOWN);
 	cPointerEvent.define_const("TYPE_UP",   Reflex::PointerEvent::UP);
@@ -163,7 +166,6 @@ Init_pointer_event ()
 	cPointerEvent.define_const("POINTER_MOUSE_MIDDLE", Reflex::POINTER_MOUSE_MIDDLE);
 	cPointerEvent.define_const("POINTER_TOUCH",        Reflex::POINTER_TOUCH);
 	cPointerEvent.define_const("POINTER_PEN",          Reflex::POINTER_PEN);
-	cPointerEvent.define_const("POINTER_TYPE_LAST",    Reflex::POINTER_TYPE_LAST);
 }
 
 

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

@@ -0,0 +1,65 @@
+#include "reflex/ruby/shape.h"
+
+
+#include "rays/ruby/polygon.h"
+#include "defs.h"
+
+
+RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(Reflex::PolygonShape)
+
+#define THIS      to<Reflex::PolygonShape*>(self)
+
+#define CHECK     RUCY_CHECK_OBJ(Reflex::PolygonShape, self)
+
+#define CALL(fun) RUCY_CALL_SUPER(THIS, fun)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return value(new Reflex::RubyShape<Reflex::PolygonShape>, klass);
+}
+
+static
+VALUE set_polygon(VALUE self, VALUE polygon)
+{
+	CHECK;
+
+	THIS->set_polygon(to<Rays::Polygon&>(polygon));
+	return polygon;
+}
+
+static
+VALUE get_polygon(VALUE self)
+{
+	CHECK;
+	return value(THIS->polygon());
+}
+
+
+static Class cPolygonShape;
+
+void
+Init_polygon_shape ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cPolygonShape = mReflex.define_class("PolygonShape", Reflex::shape_class());
+	rb_define_alloc_func(cPolygonShape, alloc);
+	rb_define_method(cPolygonShape, "polygon=", RUBY_METHOD_FUNC(set_polygon), 1);
+	rb_define_method(cPolygonShape, "polygon", RUBY_METHOD_FUNC(get_polygon), 0);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	polygon_shape_class ()
+	{
+		return cPolygonShape;
+	}
+
+
+}// Reflex

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

@@ -1,45 +1,38 @@
-#include "reflex/ruby/shape_view.h"
+#include "reflex/ruby/shape.h"
 
 
-#include <rucy.h>
-#include <rays/ruby/point.h>
-
-
-using namespace Rucy;
-
-using Reflex::coord;
+#include "defs.h"
 
 
 RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(Reflex::RectShape)
 
 #define THIS      to<Reflex::RectShape*>(self)
 
-#define CHECK     RUCY_CHECK_OBJECT(Reflex::RectShape, self)
+#define CHECK     RUCY_CHECK_OBJ(Reflex::RectShape, self)
 
-#define CALL(fun) RUCY_WRAPPER_CALL(Reflex::RectShape, THIS, fun)
+#define CALL(fun) RUCY_CALL_SUPER(THIS, fun)
 
 
 static
 VALUE alloc(VALUE klass)
 {
-	return value(new Reflex::RubyShapeView<Reflex::RectShape>, klass);
+	return value(new Reflex::RubyShape<Reflex::RectShape>, klass);
 }
 
 static
 VALUE set_round(VALUE self)
 {
 	CHECK;
-	check_arg_count(__FILE__, __LINE__, "RectShape#set_fill", argc, 1, 2);
+	check_arg_count(__FILE__, __LINE__, "RectShape#set_round", argc, 1, 4);
 
-	if (argc == 1 && argv[0].is_kind_of(Rays::point_class()))
-		THIS->set_round(to<Rays::Point&>(argv[0]));
+	if (argc == 1)
+		THIS->set_round(to<float>(argv[0]));
 	else
 	{
-		float w =               to<float>(argv[0]);
-		float h = (argc >= 2) ? to<float>(argv[1]) : 1;
-		THIS->set_round(w, h);
+		THIS->set_round(
+			to<float>(argv[0]), to<float>(argv[1]),
+			to<float>(argv[2]), to<float>(argv[3]));
 	}
-
 	return self;
 }
 
@@ -47,11 +40,88 @@ static
 VALUE get_round(VALUE self)
 {
 	CHECK;
-	return value(THIS->round());
+	return array(
+		value(THIS->round_left_top()),
+		value(THIS->round_right_top()),
+		value(THIS->round_left_bottom()),
+		value(THIS->round_right_bottom()));
+}
+
+static
+VALUE set_round_left_top(VALUE self, VALUE round)
+{
+	CHECK;
+	THIS->set_round_left_top(to<coord>(round));
+	return round;
+}
+
+static
+VALUE get_round_left_top(VALUE self)
+{
+	CHECK;
+	return value(THIS->round_left_top());
 }
 
 static
-RUCY_DEF_clear_override_flags(cof, Reflex::RectShape);
+VALUE set_round_right_top(VALUE self, VALUE round)
+{
+	CHECK;
+	THIS->set_round_right_top(to<coord>(round));
+	return round;
+}
+
+static
+VALUE get_round_right_top(VALUE self)
+{
+	CHECK;
+	return value(THIS->round_right_top());
+}
+
+static
+VALUE set_round_left_bottom(VALUE self, VALUE round)
+{
+	CHECK;
+	THIS->set_round_left_bottom(to<coord>(round));
+	return round;
+}
+
+static
+VALUE get_round_left_bottom(VALUE self)
+{
+	CHECK;
+	return value(THIS->round_left_bottom());
+}
+
+static
+VALUE set_round_right_bottom(VALUE self, VALUE round)
+{
+	CHECK;
+	THIS->set_round_right_bottom(to<coord>(round));
+	return round;
+}
+
+static
+VALUE get_round_right_bottom(VALUE self)
+{
+	CHECK;
+	return value(THIS->round_right_bottom());
+}
+
+static
+VALUE set_nsegment(VALUE self, VALUE nsegment)
+{
+	CHECK;
+
+	THIS->set_nsegment(to<uint>(nsegment));
+	return nsegment;
+}
+
+static
+VALUE get_nsegment(VALUE self)
+{
+	CHECK;
+	return value(THIS->nsegment());
+}
 
 
 static Class cRectShape;
@@ -61,11 +131,20 @@ Init_rect_shape ()
 {
 	Module mReflex = rb_define_module("Reflex");
 
-	cRectShape = mReflex.define_class("RectShape", Reflex::shape_view_class());
+	cRectShape = mReflex.define_class("RectShape", Reflex::shape_class());
 	rb_define_alloc_func(cRectShape, alloc);
-	rb_define_private_method(cRectShape, "round=", RUBY_METHOD_FUNC(set_round), -1);
+	rb_define_method(cRectShape, "round=", RUBY_METHOD_FUNC(set_round), -1);
 	rb_define_method(cRectShape, "round", RUBY_METHOD_FUNC(get_round), 0);
-	
+	rb_define_method(cRectShape, "round_left_top=", RUBY_METHOD_FUNC(set_round_left_top), 1);
+	rb_define_method(cRectShape, "round_left_top", RUBY_METHOD_FUNC(get_round_left_top), 0);
+	rb_define_method(cRectShape, "round_right_top=", RUBY_METHOD_FUNC(set_round_right_top), 1);
+	rb_define_method(cRectShape, "round_right_top", RUBY_METHOD_FUNC(get_round_right_top), 0);
+	rb_define_method(cRectShape, "round_left_bottom=", RUBY_METHOD_FUNC(set_round_left_bottom), 1);
+	rb_define_method(cRectShape, "round_left_bottom", RUBY_METHOD_FUNC(get_round_left_bottom), 0);
+	rb_define_method(cRectShape, "round_right_bottom=", RUBY_METHOD_FUNC(set_round_right_bottom), 1);
+	rb_define_method(cRectShape, "round_right_bottom", RUBY_METHOD_FUNC(get_round_right_bottom), 0);
+	rb_define_method(cRectShape, "nsegment=", RUBY_METHOD_FUNC(set_nsegment), 1);
+	rb_define_method(cRectShape, "nsegment", RUBY_METHOD_FUNC(get_nsegment), 0);
 }
 
 

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

@@ -1,22 +1,43 @@
-#include <rucy.h>
-#include "reflex/reflex.h"
+#include "reflex/ruby/reflex.h"
+
+
+#include "reflex/ruby/view.h"
+#include "reflex/ruby/timer.h"
+#include "../../src/window.h"
+#include "../../src/timer.h"
 #include "defs.h"
 
 
-using namespace Rucy;
+static Reflex::View*
+create_root_view ()
+{
+	return new Reflex::RubyView<Reflex::View>;
+}
+
+static Reflex::Timer*
+create_timer ()
+{
+	return new Reflex::RubyTimer<Reflex::Timer>;
+}
 
 
 static
 VALUE init(VALUE self)
 {
 	Reflex::init();
+	Reflex::Window_set_create_root_view_fun(create_root_view);
+	Reflex::Timer_set_create_fun(create_timer);
+
 	return self;
 }
 
 static
 VALUE fin(VALUE self)
 {
+	Reflex::Window_set_create_root_view_fun(NULL);
+	Reflex::Timer_set_create_fun(NULL);
 	Reflex::fin();
+
 	return self;
 }
 

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

@@ -1,16 +1,10 @@
 #include "reflex/ruby/event.h"
 
 
-#include <rucy.h>
 #include "rays/ruby/point.h"
 #include "defs.h"
 
 
-using namespace Rucy;
-
-using Reflex::coord;
-
-
 RUCY_DEFINE_VALUE_FROM_TO(Reflex::ScrollEvent)
 
 #define THIS  to<Reflex::ScrollEvent*>(self)
@@ -25,17 +19,16 @@ VALUE alloc(VALUE klass)
 }
 
 static
-VALUE initialize(VALUE self)
+VALUE initialize(VALUE self, VALUE x, VALUE y, VALUE z, VALUE dx, VALUE dy, VALUE dz)
 {
 	CHECK;
-	check_arg_count(__FILE__, __LINE__, "ScrollEvent#initialize", argc, 0, 1, 2, 3, 4, 5, 6);
 
-	THIS->x       = (argc >= 1) ? to<coord>(argv[0]) : 0;
-	THIS->y       = (argc >= 2) ? to<coord>(argv[1]) : 0;
-	THIS->z       = (argc >= 3) ? to<coord>(argv[2]) : 0;
-	THIS->dx      = (argc >= 4) ? to<coord>(argv[3]) : 0;
-	THIS->dy      = (argc >= 5) ? to<coord>(argv[4]) : 0;
-	THIS->dz      = (argc >= 6) ? to<coord>(argv[5]) : 0;
+	THIS->x  = to<coord>(x);
+	THIS->y  = to<coord>(y);
+	THIS->z  = to<coord>(z);
+	THIS->dx = to<coord>(dx);
+	THIS->dy = to<coord>(dy);
+	THIS->dz = to<coord>(dz);
 
 	return rb_call_super(0, NULL);
 }
@@ -114,7 +107,7 @@ Init_scroll_event ()
 
 	cScrollEvent = mReflex.define_class("ScrollEvent", Reflex::event_class());
 	rb_define_alloc_func(cScrollEvent, alloc);
-	rb_define_private_method(cScrollEvent, "initialize", RUBY_METHOD_FUNC(initialize), -1);
+	rb_define_private_method(cScrollEvent, "initialize", RUBY_METHOD_FUNC(initialize), 6);
 	rb_define_private_method(cScrollEvent, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
 	rb_define_method(cScrollEvent, "x", RUBY_METHOD_FUNC(x), 0);
 	rb_define_method(cScrollEvent, "y", RUBY_METHOD_FUNC(y), 0);

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

@@ -1,16 +1,13 @@
 #include "reflex/ruby/selector.h"
 
 
-#include <rucy.h>
 #include "defs.h"
 
 
-using namespace Rucy;
+RUCY_DEFINE_VALUE_OR_ARRAY_FROM_TO(Reflex::Selector)
 
-
-RUCY_DEFINE_VALUE_FROM_TO(Reflex::Selector)
-
-#define THIS  to<Reflex::Selector*>(self)
+#define   THIS to<      Reflex::Selector*>(self)
+#define C_THIS to<const Reflex::Selector*>(self)
 
 #define CHECK RUCY_CHECK_OBJ(Reflex::Selector, self)
 
@@ -40,7 +37,8 @@ static
 VALUE get_name(VALUE self)
 {
 	CHECK;
-	return THIS->name() ? value(THIS->name()) : nil();
+	const char* name = C_THIS->name();
+	return name ? value(name) : nil();
 }
 
 static
@@ -57,14 +55,28 @@ VALUE remove_tag(VALUE self, VALUE tag)
 	THIS->remove_tag(tag.c_str());
 }
 
+static
+VALUE clear_tags(VALUE self)
+{
+	CHECK;
+	THIS->clear_tags();
+}
+
+static
+VALUE has_tag(VALUE self, VALUE tag)
+{
+	CHECK;
+	return value(C_THIS->has_tag(tag.c_str()));
+}
+
 static
 VALUE each_tag(VALUE self)
 {
 	CHECK;
 
 	Value ret;
-	Reflex::Selector::iterator end = THIS->end();
-	for (Reflex::Selector::iterator it = THIS->begin(); it != end; ++it)
+	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));
 	return ret;
 }
@@ -73,14 +85,14 @@ static
 VALUE contains(VALUE self, VALUE selector)
 {
 	CHECK;
-	return value(THIS->contains(to<Reflex::Selector&>(selector)));
+	return value(C_THIS->contains(to<Reflex::Selector&>(selector)));
 }
 
 static
 VALUE equal(VALUE self, VALUE selector)
 {
 	CHECK;
-	return value(*THIS == to<Reflex::Selector&>(selector));
+	return value(*C_THIS == to<const Reflex::Selector&>(selector));
 }
 
 
@@ -98,6 +110,8 @@ Init_selector ()
 	rb_define_method(cSelector, "name", RUBY_METHOD_FUNC(get_name), 0);
 	rb_define_method(cSelector, "add_tag", RUBY_METHOD_FUNC(add_tag), 1);
 	rb_define_method(cSelector, "remove_tag", RUBY_METHOD_FUNC(remove_tag), 1);
+	rb_define_method(cSelector, "clear_tags", RUBY_METHOD_FUNC(clear_tags), 0);
+	cSelector.define_method("tag?",       has_tag);
 	rb_define_method(cSelector, "each_tag", RUBY_METHOD_FUNC(each_tag), 0);
 	rb_define_method(cSelector, "contains", RUBY_METHOD_FUNC(contains), 1);
 	cSelector.define_method("==", equal);
@@ -109,12 +123,26 @@ namespace Rucy
 
 
 	template <> Reflex::Selector
-	value_to<Reflex::Selector> (Value value, bool convert)
+	value_to<Reflex::Selector> (int argc, const Value* argv, bool convert)
 	{
-		if (convert && (value.is_s() || value.is_sym()))
-			return Reflex::Selector(value.c_str());
+		if (argc == 1 && argv->is_array())
+		{
+			argc = argv->size();
+			argv = argv->as_array();
+		}
+
+		assert(argc > 0 && argv);
+
+		if (convert)
+		{
+			if (argc == 1 && (argv->is_s() || argv->is_sym()))
+				return Reflex::Selector(argv[0].c_str());
+		}
+
+		if (argc != 1)
+			argument_error(__FILE__, __LINE__);
 
-		return value_to<Reflex::Selector&>(value, convert);
+		return value_to<Reflex::Selector&>(*argv, convert);
 	}