reflexion 0.1.12 → 0.1.13

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

@@ -0,0 +1,75 @@
+#include "reflex/ruby/event.h"
+
+
+#include "rays/ruby/point.h"
+#include "defs.h"
+
+
+RUCY_DEFINE_VALUE_FROM_TO(Reflex::MotionEvent)
+
+#define THIS  to<Reflex::MotionEvent*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Reflex::MotionEvent, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return new_type<Reflex::MotionEvent>(klass);
+}
+
+static
+VALUE initialize(VALUE self)
+{
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "MotionEvent#initialize", argc, 0, 1);
+
+	if (argc >= 1)
+		THIS->gravity = to<Rays::Point>(argv[0]);
+
+	return rb_call_super(0, NULL);
+}
+
+static
+VALUE initialize_copy(VALUE self, VALUE obj)
+{
+	CHECK;
+	*THIS = to<Reflex::MotionEvent&>(obj);
+	return self;
+}
+
+static
+VALUE gravity(VALUE self)
+{
+	CHECK;
+	return value(THIS->gravity);
+}
+
+
+static Class cMotionEvent;
+
+void
+Init_motion_event ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cMotionEvent = mReflex.define_class("MotionEvent", Reflex::event_class());
+	rb_define_alloc_func(cMotionEvent, alloc);
+	rb_define_private_method(cMotionEvent, "initialize", RUBY_METHOD_FUNC(initialize), -1);
+	rb_define_private_method(cMotionEvent, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
+	rb_define_method(cMotionEvent, "gravity", RUBY_METHOD_FUNC(gravity), 0);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	motion_event_class ()
+	{
+		return cMotionEvent;
+	}
+
+
+}// Reflex

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

@@ -1,17 +1,16 @@
-#include <rucy.h>
 #include "defs.h"
 
 
-using namespace Rucy;
-
-
 void Init_reflex ();
 
 void Init_selector ();
 void Init_style ();
 void Init_style_length ();
+void Init_timer ();
+void Init_filter ();
 
 void Init_event ();
+void Init_motion_event ();
 void Init_update_event ();
 void Init_draw_event ();
 void Init_frame_event ();
@@ -21,10 +20,14 @@ void Init_key_event ();
 void Init_pointer_event ();
 void Init_wheel_event ();
 void Init_capture_event ();
+void Init_timer_event ();
 void Init_contact_event ();
 
-void Init_body ();
-void Init_fixture ();
+void Init_shape ();
+void Init_polygon_shape ();
+void Init_line_shape ();
+void Init_rect_shape ();
+void Init_ellipse_shape ();
 
 void Init_application ();
 void Init_window ();
@@ -32,11 +35,6 @@ void Init_view ();
 
 void Init_image_view ();
 
-void Init_shape_view ();
-void Init_rect_shape ();
-void Init_ellipse_shape ();
-void Init_arc_shape ();
-
 
 extern "C" void
 #ifdef COCOAPODS
@@ -54,8 +52,11 @@ extern "C" void
 	Init_selector();
 	Init_style();
 	Init_style_length();
+	Init_timer();
+	Init_filter();
 
 	Init_event();
+	Init_motion_event();
 	Init_update_event();
 	Init_draw_event();
 	Init_frame_event();
@@ -65,10 +66,14 @@ extern "C" void
 	Init_pointer_event();
 	Init_wheel_event();
 	Init_capture_event();
+	Init_timer_event();
 	Init_contact_event();
 
-	Init_body();
-	Init_fixture();
+	Init_shape();
+	Init_polygon_shape();
+	Init_line_shape();
+	Init_rect_shape();
+	Init_ellipse_shape();
 
 	Init_application();
 	Init_window();
@@ -76,10 +81,5 @@ extern "C" void
 
 	Init_image_view();
 
-	Init_shape_view();
-	Init_rect_shape();
-	Init_ellipse_shape();
-	Init_arc_shape();
-
 	RUCY_CATCH
 }

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)
@@ -51,14 +45,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);
@@ -127,7 +121,7 @@ static
 VALUE array_get(VALUE self, VALUE index)
 {
 	CHECK;
-	return value((*THIS)[index.to_i()]);
+	return value((*THIS)[to<int>(index)]);
 }
 
 
@@ -142,8 +136,8 @@ Init_pointer_event ()
 	rb_define_alloc_func(cPointerEvent, alloc);
 	rb_define_private_method(cPointerEvent, "initialize", RUBY_METHOD_FUNC(initialize), -1);
 	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);

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,41 @@
-#include <rucy.h>
 #include "reflex/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)

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);
 	}