reflexion 0.1.12 → 0.1.17

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: f4670b432d3c7b5118a704adeaf2cb4dddc11cc6
-  data.tar.gz: b688cf9645c078dc5e4fbb2ad811b534c0aac1eb
+SHA256:
+  metadata.gz: 2d9ca818863d195ffc9dbc6bdecd4ba21158c8392619674c0a9feb2a54cc741d
+  data.tar.gz: ad29fa4aa0339cf01de49193b6cd65e6a3c46daf41716f2a1520994f58a1df5c
 SHA512:
-  metadata.gz: 73f6c4bf4329acf985fd06453bbe7955dce476bc216ba9253bc5d142a27c81a0cd3fec27a3ba65f58257886111a5e5b0bd02621f6bfc123d54b6f359d387fb52
-  data.tar.gz: 3f1b72930a6baa7e3f97a28cf5715e39123e03fcb0283988f7d0929ace59612ec11dbe3f2f96ae6ab0ddf7c8723a7bcef169b008a5d30f4f483f61695b0202d5
+  metadata.gz: 6f250456a3fb36085750a13d8bc8fee85beae0387846dbb9372d0d74254336b6685b328e01e61128f5dda4d70ba93656bdecb7e1dda82f5e223b58df6ad0553d
+  data.tar.gz: 538763c84a4f3cb77b31aaee67f63f3b5334f26cd7b317fb6958054910ef827c89cd5e5c82ef8b2929759bab09ab1c47f8ec6c2612075c754b78980a622b74e4

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

@@ -1,13 +1,9 @@
 #include "reflex/ruby/application.h"
 
 
-#include <rucy.h>
 #include "defs.h"
 
 
-using namespace Rucy;
-
-
 RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(Reflex::Application)
 
 #define THIS      to<Reflex::Application*>(self)
@@ -15,7 +11,7 @@ RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(Reflex::Application)
 #define CHECK_OBJ RUCY_CHECK_OBJ(   Reflex::Application, self)
 #define CHECK     RUCY_CHECK_OBJECT(Reflex::Application, self)
 
-#define CALL(fun) RUCY_WRAPPER_CALL(Reflex::Application, THIS, fun)
+#define CALL(fun) RUCY_CALL_SUPER(THIS, fun)
 
 
 static
@@ -73,6 +69,13 @@ VALUE on_quit(VALUE self, VALUE event)
 	CALL(on_quit(to<Reflex::Event*>(event)));
 }
 
+static
+VALUE on_motion(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_motion(to<Reflex::MotionEvent*>(event)));
+}
+
 static
 VALUE on_preference(VALUE self, VALUE event)
 {
@@ -109,6 +112,7 @@ Init_application ()
 	rb_define_method(cApplication, "name", RUBY_METHOD_FUNC(get_name), 0);
 	rb_define_method(cApplication, "on_start", RUBY_METHOD_FUNC(on_start), 1);
 	rb_define_method(cApplication, "on_quit", RUBY_METHOD_FUNC(on_quit), 1);
+	rb_define_method(cApplication, "on_motion", RUBY_METHOD_FUNC(on_motion), 1);
 	rb_define_method(cApplication, "on_preference", RUBY_METHOD_FUNC(on_preference), 1);
 	rb_define_method(cApplication, "on_about", RUBY_METHOD_FUNC(on_about), 1);
 	rb_define_singleton_method(cApplication, "instance", RUBY_METHOD_FUNC(instance), 0);

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

@@ -1,14 +1,10 @@
 #include "reflex/ruby/event.h"
 
 
-#include <rucy.h>
 #include "rays/ruby/point.h"
 #include "defs.h"
 
 
-using namespace Rucy;
-
-
 RUCY_DEFINE_VALUE_FROM_TO(Reflex::CaptureEvent)
 
 #define THIS  to<Reflex::CaptureEvent*>(self)
@@ -23,13 +19,12 @@ VALUE alloc(VALUE klass)
 }
 
 static
-VALUE initialize(VALUE self)
+VALUE initialize(VALUE self, VALUE begin, VALUE end)
 {
 	CHECK;
-	check_arg_count(__FILE__, __LINE__, "CaptureEvent#initialize", argc, 0, 1, 2);
 
-	THIS->begin = (argc >= 1) ? to<uint>(argv[0]) : 0;
-	THIS->end   = (argc >= 2) ? to<uint>(argv[1]) : 0;
+	THIS->begin = to<uint>(begin);
+	THIS->end   = to<uint>(end);
 
 	return rb_call_super(0, NULL);
 }
@@ -66,7 +61,7 @@ Init_capture_event ()
 
 	cCaptureEvent = mReflex.define_class("CaptureEvent", Reflex::event_class());
 	rb_define_alloc_func(cCaptureEvent, alloc);
-	rb_define_private_method(cCaptureEvent, "initialize", RUBY_METHOD_FUNC(initialize), -1);
+	rb_define_private_method(cCaptureEvent, "initialize", RUBY_METHOD_FUNC(initialize), 2);
 	rb_define_private_method(cCaptureEvent, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
 	rb_define_private_method(cCaptureEvent, "get_begin", RUBY_METHOD_FUNC(begin), 0);
 	rb_define_private_method(cCaptureEvent, "get_end", RUBY_METHOD_FUNC(end), 0);

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

@@ -1,14 +1,11 @@
 #include "reflex/ruby/event.h"
 
 
-#include <rucy.h>
+#include "reflex/ruby/shape.h"
 #include "reflex/ruby/view.h"
 #include "defs.h"
 
 
-using namespace Rucy;
-
-
 RUCY_DEFINE_VALUE_FROM_TO(Reflex::ContactEvent)
 
 #define THIS  to<Reflex::ContactEvent*>(self)
@@ -23,13 +20,12 @@ VALUE alloc(VALUE klass)
 }
 
 static
-VALUE initialize(VALUE self)
+VALUE initialize(VALUE self, VALUE type, VALUE shape)
 {
 	CHECK;
-	check_arg_count(__FILE__, __LINE__, "ContactEvent#initialize", argc, 0, 2);
 
-	THIS->type = (argc >= 1) ? (Reflex::ContactEvent::Type) to<int>(argv[0]) : Reflex::ContactEvent::NONE;
-	THIS->view = (argc >= 2) ? to<Reflex::View*>(argv[1]) : NULL;
+	THIS->type  = (Reflex::ContactEvent::Type) to<int>(type);
+	THIS->shape = to<Reflex::Shape*>(shape);
 
 	return rb_call_super(0, NULL);
 }
@@ -43,14 +39,21 @@ 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_view(VALUE self)
+VALUE shape(VALUE self)
+{
+	CHECK;
+	return value(THIS->shape);
+}
+
+static
+VALUE view(VALUE self)
 {
 	CHECK;
 	return value(THIS->view);
@@ -66,10 +69,11 @@ Init_contact_event ()
 
 	cContactEvent = mReflex.define_class("ContactEvent", Reflex::event_class());
 	rb_define_alloc_func(cContactEvent, alloc);
-	rb_define_private_method(cContactEvent, "initialize", RUBY_METHOD_FUNC(initialize), -1);
+	rb_define_private_method(cContactEvent, "initialize", RUBY_METHOD_FUNC(initialize), 2);
 	rb_define_private_method(cContactEvent, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
-	rb_define_method(cContactEvent, "get_type", RUBY_METHOD_FUNC(get_type), 0);
-	rb_define_method(cContactEvent, "view", RUBY_METHOD_FUNC(get_view), 0);
+	rb_define_method(cContactEvent, "type", RUBY_METHOD_FUNC(type), 0);
+	rb_define_method(cContactEvent, "shape", RUBY_METHOD_FUNC(shape), 0);
+	rb_define_method(cContactEvent, "view", RUBY_METHOD_FUNC(view), 0);
 	cContactEvent.define_const("TYPE_NONE",  Reflex::ContactEvent::NONE);
 	cContactEvent.define_const("TYPE_BEGIN", Reflex::ContactEvent::BEGIN);
 	cContactEvent.define_const("TYPE_END",   Reflex::ContactEvent::END);

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

@@ -1,15 +1,11 @@
 #include "reflex/ruby/event.h"
 
 
-#include <rucy.h>
 #include <rays/ruby/painter.h>
 #include <rays/ruby/bounds.h>
 #include "defs.h"
 
 
-using namespace Rucy;
-
-
 RUCY_DEFINE_VALUE_FROM_TO(Reflex::DrawEvent)
 
 #define THIS  to<Reflex::DrawEvent*>(self)
@@ -24,12 +20,11 @@ VALUE alloc(VALUE klass)
 }
 
 static
-VALUE initialize(VALUE self)
+VALUE initialize(VALUE self, VALUE dt)
 {
 	CHECK;
-	check_arg_count(__FILE__, __LINE__, "DrawEvent#initialize", argc, 0, 1);
 
-	THIS->dt = (argc >= 1) ? argv[0].as_f() : 0;
+	THIS->dt = to<float>(dt);
 
 	return rb_call_super(0, NULL);
 }
@@ -80,7 +75,7 @@ Init_draw_event ()
 
 	cDrawEvent = mReflex.define_class("DrawEvent", Reflex::event_class());
 	rb_define_alloc_func(cDrawEvent, alloc);
-	rb_define_private_method(cDrawEvent, "initialize", RUBY_METHOD_FUNC(initialize), -1);
+	rb_define_private_method(cDrawEvent, "initialize", RUBY_METHOD_FUNC(initialize), 1);
 	rb_define_private_method(cDrawEvent, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
 	rb_define_method(cDrawEvent, "painter", RUBY_METHOD_FUNC(painter), 0);
 	rb_define_method(cDrawEvent, "bounds", RUBY_METHOD_FUNC(bounds), 0);

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

@@ -1,49 +1,76 @@
-#include "reflex/ruby/shape_view.h"
+#include "reflex/ruby/shape.h"
 
 
-#include <rucy.h>
-
-
-using namespace Rucy;
-
-using Reflex::coord;
+#include "defs.h"
 
 
 RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(Reflex::EllipseShape)
 
 #define THIS      to<Reflex::EllipseShape*>(self)
 
-#define CHECK     RUCY_CHECK_OBJECT(Reflex::EllipseShape, self)
+#define CHECK     RUCY_CHECK_OBJ(Reflex::EllipseShape, self)
 
-#define CALL(fun) RUCY_WRAPPER_CALL(Reflex::EllipseShape, THIS, fun)
+#define CALL(fun) RUCY_CALL_SUPER(THIS, fun)
 
 
 static
 VALUE alloc(VALUE klass)
 {
-	return value(new Reflex::RubyShapeView<Reflex::EllipseShape>, klass);
+	return value(new Reflex::RubyShape<Reflex::EllipseShape>, klass);
+}
+
+static
+VALUE set_angle_from(VALUE self, VALUE degree)
+{
+	CHECK;
+	THIS->set_angle_from(to<float>(degree));
+	return self;
+}
+
+static
+VALUE get_angle_from(VALUE self)
+{
+	CHECK;
+	return value(THIS->angle_from());
+}
+
+static
+VALUE set_angle_to(VALUE self, VALUE degree)
+{
+	CHECK;
+	THIS->set_angle_to(to<float>(degree));
+	return self;
 }
 
 static
-VALUE set_radius_min(VALUE self, VALUE radius)
+VALUE get_angle_to(VALUE self)
 {
 	CHECK;
-	THIS->set_radius_min(radius.as_f(true));
-	return radius;
+	return value(THIS->angle_to());
 }
 
 static
-VALUE get_radius_min(VALUE self)
+VALUE set_hole_size(VALUE self)
 {
 	CHECK;
-	return value(THIS->radius_min());
+	check_arg_count(__FILE__, __LINE__, "EllipseShape#set_hole_size", argc, 1, 2, 3);
+
+	THIS->set_hole_size(to<Rays::Point>(argc, argv));
+	return value(THIS->hole_size());
+}
+
+static
+VALUE get_hole_size(VALUE self)
+{
+	CHECK;
+	return value(THIS->hole_size());
 }
 
 static
 VALUE set_nsegment(VALUE self, VALUE nsegment)
 {
 	CHECK;
-	THIS->set_nsegment(nsegment.as_i(true));
+	THIS->set_nsegment(to<uint>(nsegment));
 	return nsegment;
 }
 
@@ -54,9 +81,6 @@ VALUE get_nsegment(VALUE self)
 	return value(THIS->nsegment());
 }
 
-static
-RUCY_DEF_clear_override_flags(cof, Reflex::EllipseShape);
-
 
 static Class cEllipseShape;
 
@@ -65,13 +89,16 @@ Init_ellipse_shape ()
 {
 	Module mReflex = rb_define_module("Reflex");
 
-	cEllipseShape = mReflex.define_class("EllipseShape", Reflex::shape_view_class());
+	cEllipseShape = mReflex.define_class("EllipseShape", Reflex::shape_class());
 	rb_define_alloc_func(cEllipseShape, alloc);
-	rb_define_private_method(cEllipseShape, "radius_min=", RUBY_METHOD_FUNC(set_radius_min), 1);
-	rb_define_method(cEllipseShape, "radius_min", RUBY_METHOD_FUNC(get_radius_min), 0);
-	rb_define_private_method(cEllipseShape, "nsegment=", RUBY_METHOD_FUNC(set_nsegment), 1);
+	rb_define_method(cEllipseShape, "angle_from=", RUBY_METHOD_FUNC(set_angle_from), 1);
+	rb_define_method(cEllipseShape, "angle_from", RUBY_METHOD_FUNC(get_angle_from), 0);
+	rb_define_method(cEllipseShape, "angle_to=", RUBY_METHOD_FUNC(set_angle_to), 1);
+	rb_define_method(cEllipseShape, "angle_to", RUBY_METHOD_FUNC(get_angle_to), 0);
+	rb_define_method(cEllipseShape, "hole_size=", RUBY_METHOD_FUNC(set_hole_size), -1);
+	rb_define_method(cEllipseShape, "hole_size", RUBY_METHOD_FUNC(get_hole_size), 0);
+	rb_define_method(cEllipseShape, "nsegment=", RUBY_METHOD_FUNC(set_nsegment), 1);
 	rb_define_method(cEllipseShape, "nsegment", RUBY_METHOD_FUNC(get_nsegment), 0);
-	
 }
 
 

data/.doc/ext/reflex/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::Event)
 
 #define THIS  to<Reflex::Event*>(self)

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

@@ -0,0 +1,81 @@
+#include "reflex/ruby/filter.h"
+
+
+#include <rays/ruby/painter.h>
+#include <rays/ruby/image.h>
+#include "defs.h"
+
+
+RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(Reflex::Filter)
+
+#define THIS      to<Reflex::Filter*>(self)
+
+#define CHECK     RUCY_CHECK_OBJ(Reflex::Filter, self)
+
+#define CALL(fun) RUCY_CALL_SUPER(THIS, fun)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return value(new Reflex::RubyFilter<Reflex::Filter>, klass);
+}
+
+static
+VALUE initialize(VALUE self, VALUE arg)
+{
+	CHECK;
+
+	THIS->set_shader(to<Rays::Shader>(arg));
+}
+
+static
+VALUE apply(VALUE self, VALUE painter, VALUE image)
+{
+	CHECK;
+	CALL(apply(to<Rays::Painter*>(painter), to<const Rays::Image&>(image)));
+}
+
+static
+VALUE set_shader(VALUE self, VALUE shader)
+{
+	CHECK;
+	THIS->set_shader(to<Rays::Shader>(shader));
+}
+
+static
+VALUE get_shader(VALUE self)
+{
+	CHECK;
+	return value(THIS->shader());
+}
+
+
+static Class cFilter;
+
+void
+Init_filter ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cFilter = rb_define_class_under(mReflex, "Filter", rb_cObject);
+	rb_define_alloc_func(cFilter, alloc);
+	rb_define_private_method(cFilter, "initialize", RUBY_METHOD_FUNC(initialize), 1);
+	rb_define_method(cFilter, "apply", RUBY_METHOD_FUNC(apply), 2);
+	rb_define_method(cFilter, "shader=", RUBY_METHOD_FUNC(set_shader), 1);
+	rb_define_method(cFilter, "shader", RUBY_METHOD_FUNC(get_shader), 0);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	filter_class ()
+	{
+		return cFilter;
+	}
+
+
+}// Reflex

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

@@ -1,14 +1,10 @@
 #include "reflex/ruby/event.h"
 
 
-#include <rucy.h>
 #include "reflex/ruby/view.h"
 #include "defs.h"
 
 
-using namespace Rucy;
-
-
 RUCY_DEFINE_VALUE_FROM_TO(Reflex::FocusEvent)
 
 #define THIS  to<Reflex::FocusEvent*>(self)
@@ -23,13 +19,13 @@ VALUE alloc(VALUE klass)
 }
 
 static
-VALUE initialize(VALUE self, VALUE type, VALUE focus, VALUE last)
+VALUE initialize(VALUE self, VALUE type, VALUE current, VALUE last)
 {
 	CHECK;
 
-	THIS->focus = to<Reflex::View*>(focus);
-	THIS->focus = to<Reflex::View*>(focus);
-	THIS->last  = to<Reflex::View*>(last);
+	THIS->type    = (Reflex::FocusEvent::Type) to<uint>(type);
+	THIS->current = to<Reflex::View*>(current);
+	THIS->last    = to<Reflex::View*>(last);
 
 	return rb_call_super(0, NULL);
 }
@@ -43,17 +39,17 @@ VALUE initialize_copy(VALUE self, VALUE obj)
 }
 
 static
-VALUE get_type(VALUE self)
+VALUE type(VALUE self)
 {
 	CHECK;
 	return value(THIS->type);
 }
 
 static
-VALUE focus(VALUE self)
+VALUE current(VALUE self)
 {
 	CHECK;
-	return THIS->focus ? value(THIS->focus) : nil();
+	return THIS->current ? value(THIS->current) : nil();
 }
 
 static
@@ -75,8 +71,8 @@ Init_focus_event ()
 	rb_define_alloc_func(cFocusEvent, alloc);
 	rb_define_private_method(cFocusEvent, "initialize", RUBY_METHOD_FUNC(initialize), 3);
 	rb_define_private_method(cFocusEvent, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
-	rb_define_method(cFocusEvent, "get_type", RUBY_METHOD_FUNC(get_type), 0);
-	rb_define_method(cFocusEvent, "focus", RUBY_METHOD_FUNC(focus), 0);
+	rb_define_method(cFocusEvent, "type", RUBY_METHOD_FUNC(type), 0);
+	rb_define_method(cFocusEvent, "current", RUBY_METHOD_FUNC(current), 0);
 	rb_define_method(cFocusEvent, "last", RUBY_METHOD_FUNC(last), 0);
 	cFocusEvent.define_const("TYPE_NONE",  Reflex::FocusEvent::NONE);
 	cFocusEvent.define_const("TYPE_FOCUS", Reflex::FocusEvent::FOCUS);