reflexion 0.1.12 → 0.1.13

data/ext/reflex/frame_event.cpp

@@ -1,17 +1,11 @@
 #include "reflex/ruby/event.h"
 
 
-#include <rucy.h>
 #include "rays/ruby/point.h"
 #include "rays/ruby/bounds.h"
 #include "defs.h"
 
 
-using namespace Rucy;
-
-using Reflex::coord;
-
-
 RUCY_DEFINE_VALUE_FROM_TO(Reflex::FrameEvent)
 
 #define THIS  to<Reflex::FrameEvent*>(self)
@@ -107,6 +101,46 @@ RUCY_DEF0(dsize)
 }
 RUCY_END
 
+static
+RUCY_DEF0(angle)
+{
+	CHECK;
+	return value(THIS->angle);
+}
+RUCY_END
+
+static
+RUCY_DEF0(dangle)
+{
+	CHECK;
+	return value(THIS->dangle);
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_move)
+{
+	CHECK;
+	return value(THIS->is_move());
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_resize)
+{
+	CHECK;
+	return value(THIS->is_resize());
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_rotate)
+{
+	CHECK;
+	return value(THIS->is_rotate());
+}
+RUCY_END
+
 
 static Class cFrameEvent;
 
@@ -117,7 +151,7 @@ Init_frame_event ()
 
 	cFrameEvent = mReflex.define_class("FrameEvent", Reflex::event_class());
 	cFrameEvent.define_alloc_func(alloc);
-	cFrameEvent.define_private_method("initialize", initialize);
+	cFrameEvent.define_private_method("initialize",      initialize);
 	cFrameEvent.define_private_method("initialize_copy", initialize_copy);
 	cFrameEvent.define_method("frame", frame);
 	cFrameEvent.define_method("dx", dx);
@@ -126,6 +160,11 @@ Init_frame_event ()
 	cFrameEvent.define_method("dheight", dheight);
 	cFrameEvent.define_method("dposition", dposition);
 	cFrameEvent.define_method("dsize",     dsize);
+	cFrameEvent.define_method( "angle",  angle);
+	cFrameEvent.define_method("dangle", dangle);
+	cFrameEvent.define_method("move?",   is_move);
+	cFrameEvent.define_method("resize?", is_resize);
+	cFrameEvent.define_method("rotate?", is_rotate);
 }
 
 

data/ext/reflex/image_view.cpp

@@ -1,14 +1,9 @@
 #include "reflex/ruby/image_view.h"
 
 
-#include <rucy.h>
 #include <rays/ruby/point.h>
 #include "reflex/ruby/view.h"
-
-
-using namespace Rucy;
-
-using Reflex::coord;
+#include "defs.h"
 
 
 RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(Reflex::ImageView)
@@ -45,9 +40,6 @@ RUCY_DEF1(set_image, image)
 }
 RUCY_END
 
-static
-RUCY_DEF_clear_override_flags(cof, Reflex::ImageView);
-
 
 static Class cImageView;
 
@@ -60,7 +52,6 @@ Init_image_view ()
 	cImageView.define_alloc_func(alloc);
 	cImageView.define_private_method("set_image", set_image);
 	cImageView.define_method(            "image", get_image);
-	cImageView.define_clear_override_flags(cof);
 }
 
 

data/ext/reflex/key_event.cpp

@@ -1,13 +1,9 @@
 #include "reflex/ruby/event.h"
 
 
-#include <rucy.h>
 #include "defs.h"
 
 
-using namespace Rucy;
-
-
 RUCY_DEFINE_VALUE_FROM_TO(Reflex::KeyEvent)
 
 #define THIS  to<Reflex::KeyEvent*>(self)
@@ -48,7 +44,7 @@ RUCY_DEF1(initialize_copy, obj)
 RUCY_END
 
 static
-RUCY_DEF0(get_type)
+RUCY_DEF0(type)
 {
 	CHECK;
 	return value(THIS->type);
@@ -105,9 +101,9 @@ Init_key_event ()
 
 	cKeyEvent = mReflex.define_class("KeyEvent", Reflex::event_class());
 	cKeyEvent.define_alloc_func(alloc);
-	cKeyEvent.define_private_method("initialize", initialize);
+	cKeyEvent.define_private_method("initialize",      initialize);
 	cKeyEvent.define_private_method("initialize_copy", initialize_copy);
-	cKeyEvent.define_method("get_type", get_type);
+	cKeyEvent.define_method("type", type);
 	cKeyEvent.define_method("chars", chars);
 	cKeyEvent.define_method("code", code);
 	cKeyEvent.define_method("modifiers", modifiers);

data/ext/reflex/line_shape.cpp

@@ -0,0 +1,104 @@
+#include "reflex/ruby/shape.h"
+
+
+#include <rays/ruby/point.h>
+#include "defs.h"
+
+
+RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(Reflex::LineShape)
+
+#define THIS      to<Reflex::LineShape*>(self)
+
+#define CHECK     RUCY_CHECK_OBJ(Reflex::LineShape, self)
+
+#define CALL(fun) RUCY_CALL_SUPER(THIS, fun)
+
+
+static
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return value(new Reflex::RubyShape<Reflex::LineShape>, klass);
+}
+RUCY_END
+
+static
+RUCY_DEFN(add_point)
+{
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "LineShape#add_point", argc, 1, 2, 3);
+
+	THIS->add_point(to<Rays::Point>(argc, argv));
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEFN(add_points)
+{
+	CHECK;
+
+	if (argc <= 0) return self;
+
+	if (argv[0].is_num())
+	{
+		if (argc % 2 != 0)
+			argument_error(__FILE__, __LINE__);
+
+		for (int i = 0; i < argc; i += 2)
+			THIS->add_point(to<coord>(argv[i]), to<coord>(argv[i + 1]));
+	}
+	else
+	{
+		for (int i = 0; i < argc; ++i)
+			THIS->add_point(to<Rays::Point>(argv[i]));
+	}
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_loop, loop)
+{
+	CHECK;
+	THIS->set_loop(loop);
+	return loop;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_loop)
+{
+	CHECK;
+	return value(THIS->loop());
+}
+RUCY_END
+
+
+static Class cLineShape;
+
+void
+Init_line_shape ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cLineShape = mReflex.define_class("LineShape", Reflex::shape_class());
+	cLineShape.define_alloc_func(alloc);
+	cLineShape.define_method("add_point",  add_point);
+	cLineShape.define_method("add_points", add_points);
+	cLineShape.define_method("loop=", set_loop);
+	cLineShape.define_method("loop",  get_loop);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	line_shape_class ()
+	{
+		return cLineShape;
+	}
+
+
+}// Reflex

data/ext/reflex/motion_event.cpp

@@ -0,0 +1,79 @@
+#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_DEFN(initialize)
+{
+	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);
+}
+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)
@@ -54,7 +48,7 @@ RUCY_DEF1(initialize_copy, obj)
 RUCY_END
 
 static
-RUCY_DEF0(get_type)
+RUCY_DEF0(type)
 {
 	CHECK;
 	return value(THIS->type);
@@ -62,7 +56,7 @@ RUCY_DEF0(get_type)
 RUCY_END
 
 static
-RUCY_DEF0(get_pointer_type)
+RUCY_DEF0(pointer_type)
 {
 	CHECK;
 	return value(THIS->pointer_type);
@@ -140,7 +134,7 @@ static
 RUCY_DEF1(array_get, index)
 {
 	CHECK;
-	return value((*THIS)[index.to_i()]);
+	return value((*THIS)[to<int>(index)]);
 }
 RUCY_END
 
@@ -154,10 +148,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);

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