reflexion 0.1.11 → 0.1.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: bdaed8fe443916ffe6273ee2ae4938dd97afe3a5
-  data.tar.gz: b9eeb656bae9a1f91089fccc1c4a31adc892a1fb
+SHA256:
+  metadata.gz: 79fd61794a59ff8ba0b15f2f32515ef63064bc1e62c92adc081712bac777fa4d
+  data.tar.gz: 3a7fdb5fd13bcecebf019185329450ee92b09d18c9b2c5ecefcc8c08d562469c
 SHA512:
-  metadata.gz: a3fc6b52f80e75dc7d4e43cb72de7c02af376da86264da9f279b7c23e8979bf98a1ebd62d684e6607e96e734d102bd1249887109d879f29ad79e49b81373cece
-  data.tar.gz: e3e178432bb7fb6dfca698e8d18038f70f1bc4821042598274973971449e6558a442906f37625164b2214e1996bf0b8b080e4856503bf5bdce0a5ee7fc69a663
+  metadata.gz: 78e88670abd02997ea2e9aee2b373687109e9fb78f1f951f74277506f2f4ad2e83fe65cd85847a1be812d34e914671ba186a522db944423df4e8e940d99d3c81
+  data.tar.gz: 9d334478e511ff0d6aea0575d6a11b093e652209693e1d04775eff4807479fba836759eb800f526b48715e7fa854ebbcc54e638101739e24d4695734774912f5

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