reflexion 0.1.12 → 0.1.17

data/ext/reflex/motion_event.cpp

@@ -0,0 +1,77 @@
+#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
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return new_type<Reflex::MotionEvent>(klass);
+}
+RUCY_END
+
+static
+RUCY_DEF1(initialize, gravity)
+{
+	CHECK;
+
+	THIS->gravity = to<Rays::Point>(gravity);
+
+	return rb_call_super(0, NULL);
+}
+RUCY_END
+
+static
+RUCY_DEF1(initialize_copy, obj)
+{
+	CHECK;
+	*THIS = to<Reflex::MotionEvent&>(obj);
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF0(gravity)
+{
+	CHECK;
+	return value(THIS->gravity);
+}
+RUCY_END
+
+
+static Class cMotionEvent;
+
+void
+Init_motion_event ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cMotionEvent = mReflex.define_class("MotionEvent", Reflex::event_class());
+	cMotionEvent.define_alloc_func(alloc);
+	cMotionEvent.define_private_method("initialize",      initialize);
+	cMotionEvent.define_private_method("initialize_copy", initialize_copy);
+	cMotionEvent.define_method("gravity", gravity);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	motion_event_class ()
+	{
+		return cMotionEvent;
+	}
+
+
+}// Reflex

data/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/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)
@@ -26,19 +20,23 @@ RUCY_DEF_ALLOC(alloc, klass)
 RUCY_END
 
 static
-RUCY_DEFN(initialize)
+RUCY_DEF6(initialize, type, pointer_type, modifiers, count, drag, 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);
 }
@@ -54,7 +52,7 @@ RUCY_DEF1(initialize_copy, obj)
 RUCY_END
 
 static
-RUCY_DEF0(get_type)
+RUCY_DEF0(type)
 {
 	CHECK;
 	return value(THIS->type);
@@ -62,7 +60,7 @@ RUCY_DEF0(get_type)
 RUCY_END
 
 static
-RUCY_DEF0(get_pointer_type)
+RUCY_DEF0(pointer_type)
 {
 	CHECK;
 	return value(THIS->pointer_type);
@@ -137,10 +135,15 @@ RUCY_DEFN(position)
 RUCY_END
 
 static
-RUCY_DEF1(array_get, index)
+RUCY_DEF1(get_at, 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]);
 }
 RUCY_END
 
@@ -154,10 +157,10 @@ Init_pointer_event ()
 
 	cPointerEvent = mReflex.define_class("PointerEvent", Reflex::event_class());
 	cPointerEvent.define_alloc_func(alloc);
-	cPointerEvent.define_private_method("initialize", initialize);
+	cPointerEvent.define_private_method("initialize",      initialize);
 	cPointerEvent.define_private_method("initialize_copy", initialize_copy);
-	cPointerEvent.define_method("get_type", get_type);
-	cPointerEvent.define_method("get_pointer_type", get_pointer_type);
+	cPointerEvent.define_method("type", type);
+	cPointerEvent.define_method("pointer_type", pointer_type);
 	cPointerEvent.define_method("size", size);
 	cPointerEvent.define_method("modifiers", modifiers);
 	cPointerEvent.define_method("count", count);
@@ -166,7 +169,7 @@ Init_pointer_event ()
 	cPointerEvent.define_method("x", x);
 	cPointerEvent.define_method("y", y);
 	cPointerEvent.define_method("position", position);
-	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);
@@ -177,7 +180,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/ext/reflex/polygon_shape.cpp

@@ -0,0 +1,68 @@
+#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
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return value(new Reflex::RubyShape<Reflex::PolygonShape>, klass);
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_polygon, polygon)
+{
+	CHECK;
+
+	THIS->set_polygon(to<Rays::Polygon&>(polygon));
+	return polygon;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_polygon)
+{
+	CHECK;
+	return value(THIS->polygon());
+}
+RUCY_END
+
+
+static Class cPolygonShape;
+
+void
+Init_polygon_shape ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cPolygonShape = mReflex.define_class("PolygonShape", Reflex::shape_class());
+	cPolygonShape.define_alloc_func(alloc);
+	cPolygonShape.define_method("polygon=", set_polygon);
+	cPolygonShape.define_method("polygon",  get_polygon);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	polygon_shape_class ()
+	{
+		return cPolygonShape;
+	}
+
+
+}// Reflex

data/ext/reflex/rect_shape.cpp

@@ -1,28 +1,22 @@
-#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
 RUCY_DEF_ALLOC(alloc, klass)
 {
-	return value(new Reflex::RubyShapeView<Reflex::RectShape>, klass);
+	return value(new Reflex::RubyShape<Reflex::RectShape>, klass);
 }
 RUCY_END
 
@@ -30,17 +24,16 @@ static
 RUCY_DEFN(set_round)
 {
 	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;
 }
 RUCY_END
@@ -49,12 +42,99 @@ static
 RUCY_DEF0(get_round)
 {
 	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()));
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_round_left_top, round)
+{
+	CHECK;
+	THIS->set_round_left_top(to<coord>(round));
+	return round;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_round_left_top)
+{
+	CHECK;
+	return value(THIS->round_left_top());
 }
 RUCY_END
 
 static
-RUCY_DEF_clear_override_flags(cof, Reflex::RectShape);
+RUCY_DEF1(set_round_right_top, round)
+{
+	CHECK;
+	THIS->set_round_right_top(to<coord>(round));
+	return round;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_round_right_top)
+{
+	CHECK;
+	return value(THIS->round_right_top());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_round_left_bottom, round)
+{
+	CHECK;
+	THIS->set_round_left_bottom(to<coord>(round));
+	return round;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_round_left_bottom)
+{
+	CHECK;
+	return value(THIS->round_left_bottom());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_round_right_bottom, round)
+{
+	CHECK;
+	THIS->set_round_right_bottom(to<coord>(round));
+	return round;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_round_right_bottom)
+{
+	CHECK;
+	return value(THIS->round_right_bottom());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_nsegment, nsegment)
+{
+	CHECK;
+
+	THIS->set_nsegment(to<uint>(nsegment));
+	return nsegment;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_nsegment)
+{
+	CHECK;
+	return value(THIS->nsegment());
+}
+RUCY_END
 
 
 static Class cRectShape;
@@ -64,11 +144,20 @@ Init_rect_shape ()
 {
 	Module mReflex = define_module("Reflex");
 
-	cRectShape = mReflex.define_class("RectShape", Reflex::shape_view_class());
+	cRectShape = mReflex.define_class("RectShape", Reflex::shape_class());
 	cRectShape.define_alloc_func(alloc);
-	cRectShape.define_private_method("round=", set_round);
-	cRectShape.define_method(        "round",  get_round);
-	cRectShape.define_clear_override_flags(cof);
+	cRectShape.define_method("round=",              set_round);
+	cRectShape.define_method("round",               get_round);
+	cRectShape.define_method("round_left_top=",     set_round_left_top);
+	cRectShape.define_method("round_left_top",      get_round_left_top);
+	cRectShape.define_method("round_right_top=",    set_round_right_top);
+	cRectShape.define_method("round_right_top",     get_round_right_top);
+	cRectShape.define_method("round_left_bottom=",  set_round_left_bottom);
+	cRectShape.define_method("round_left_bottom",   get_round_left_bottom);
+	cRectShape.define_method("round_right_bottom=", set_round_right_bottom);
+	cRectShape.define_method("round_right_bottom",  get_round_right_bottom);
+	cRectShape.define_method("nsegment=", set_nsegment);
+	cRectShape.define_method("nsegment",  get_nsegment);
 }