reflexion 0.1.6 → 0.1.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4ab611843e39083046757ad8be7974cf3f08802b
+  data.tar.gz: 348a2e5773ec70a2a5215e3bc8783aead028a7d3
+SHA512:
+  metadata.gz: d1a4456dcf74b5d765fcc6819f2fe19a0d1a6bfc39bc610ff1e4d82f73cc23384f6f89fa735eb27c671b1cbc76f208326ecc1fcd63a5f70fe86986cb42ab594b
+  data.tar.gz: d52e858d9aa75386455b8f262bdc7666c92d3481dd9bd2ea7f3b55b5b3d3f9b8c9054e7cd5cd454ec77cf66aac52a3e452ebf1c415558377175c2ebeb2552b6e

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

@@ -10,43 +10,26 @@ using namespace Rucy;
 
 static Class cApplication;
 
-
-namespace Reflex
-{
-
-
-	Class
-	application_class ()
-	{
-		return cApplication;
-	}
-
-
-}// Reflex
-
-
-typedef Reflex::RubyApplication<Reflex::Application> RubyApplication;
-
+RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(Reflex::Application, cApplication)
 
 #define THIS      to<Reflex::Application*>(self)
 
-#define CHECK     RUCY_CHECK_OBJECT(self, Reflex::Application, cApplication)
+#define CHECK     RUCY_CHECK_OBJECT(Reflex::Application, cApplication, self)
 
-#define CALL(fun) RUCY_WRAPPER_CALL(RubyApplication, THIS, fun)
+#define CALL(fun) RUCY_WRAPPER_CALL(Reflex::Application, THIS, fun)
 
 
 static
 VALUE alloc(VALUE klass)
 {
-	return value(new RubyApplication, klass);
+	return value(new Reflex::RubyApplication<Reflex::Application>, klass);
 }
 
 static
-VALUE run(VALUE self)
+VALUE start(VALUE self)
 {
 	CHECK;
-	if (!CALL(run()))
-		system_error("failed to run application.");
+	CALL(start());
 	return self;
 }
 
@@ -54,36 +37,51 @@ static
 VALUE quit(VALUE self)
 {
 	CHECK;
-	if (!CALL(quit()))
-		system_error("failed to quit application.");
+	CALL(quit());
 	return self;
 }
 
 static
-VALUE about(VALUE self)
+VALUE set_name(VALUE self, VALUE name)
 {
 	CHECK;
-	if (!CALL(about()))
-		system_error("failed to show about application.");
-	return self;
+	THIS->set_name(name.c_str());
+	return name;
 }
 
 static
-VALUE set_name(VALUE self, VALUE name)
+VALUE get_name(VALUE self)
 {
 	CHECK;
-	if (!THIS->set_name(name.c_str()))
-		system_error("failed to set name of application.");
-	return name;
+	return value(THIS->name());
 }
 
 static
-VALUE get_name(VALUE self)
+VALUE on_start(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_start(to<Reflex::Event*>(event)));
+}
+
+static
+VALUE on_quit(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_quit(to<Reflex::Event*>(event)));
+}
+
+static
+VALUE on_preference(VALUE self, VALUE event)
 {
 	CHECK;
-	const char* s = THIS->name();
-	if (!s) system_error("failed to get name of application.");
-	return value(s);
+	CALL(on_preference(to<Reflex::Event*>(event)));
+}
+
+static
+VALUE on_about(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_about(to<Reflex::Event*>(event)));
 }
 
 static
@@ -100,10 +98,27 @@ Init_application ()
 
 	cApplication = rb_define_class_under(mReflex, "Application", rb_cObject);
 	rb_define_alloc_func(cApplication, alloc);
-	rb_define_method(cApplication, "run", RUBY_METHOD_FUNC(run), 0);
+	rb_define_method(cApplication, "start", RUBY_METHOD_FUNC(start), 0);
 	rb_define_method(cApplication, "quit", RUBY_METHOD_FUNC(quit), 0);
-	rb_define_method(cApplication, "about", RUBY_METHOD_FUNC(about), 0);
 	rb_define_method(cApplication, "name=", RUBY_METHOD_FUNC(set_name), 1);
 	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_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);
 }
+
+
+namespace Reflex
+{
+
+
+	Class
+	application_class ()
+	{
+		return cApplication;
+	}
+
+
+}// Reflex

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

@@ -0,0 +1,87 @@
+#include "reflex/ruby/event.h"
+
+
+#include <rucy.h>
+#include "rays/ruby/point.h"
+#include "defs.h"
+
+
+using namespace Rucy;
+
+
+static Class cCaptureEvent;
+
+RUCY_DEFINE_VALUE_FROM_TO(Reflex::CaptureEvent, cCaptureEvent)
+
+#define THIS  to<Reflex::CaptureEvent*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Reflex::CaptureEvent, cCaptureEvent, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return new_type<Reflex::CaptureEvent>(klass);
+}
+
+static
+VALUE initialize(VALUE self)
+{
+	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;
+
+	return rb_call_super(0, NULL);
+}
+
+static
+VALUE initialize_copy(VALUE self, VALUE obj)
+{
+	CHECK;
+	*THIS = to<Reflex::CaptureEvent&>(obj);
+	return self;
+}
+
+static
+VALUE begin(VALUE self)
+{
+	CHECK;
+	return value(THIS->begin);
+}
+
+static
+VALUE end(VALUE self)
+{
+	CHECK;
+	return value(THIS->end);
+}
+
+
+void
+Init_capture_event ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	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_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);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	capture_event_class ()
+	{
+		return cCaptureEvent;
+	}
+
+
+}// Reflex

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

@@ -0,0 +1,103 @@
+#include "reflex/ruby/event.h"
+
+
+#include <rucy.h>
+#include <rays/ruby/painter.h>
+#include <rays/ruby/bounds.h>
+#include "defs.h"
+
+
+using namespace Rucy;
+
+
+static Class cDrawEvent;
+
+RUCY_DEFINE_VALUE_FROM_TO(Reflex::DrawEvent, cDrawEvent)
+
+#define THIS  to<Reflex::DrawEvent*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Reflex::DrawEvent, cDrawEvent, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return new_type<Reflex::DrawEvent>(klass);
+}
+
+static
+VALUE initialize(VALUE self)
+{
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "DrawEvent#initialize", argc, 0, 1);
+
+	THIS->dt = (argc >= 1) ? argv[0].as_f() : 0;
+
+	return rb_call_super(0, NULL);
+}
+
+static
+VALUE initialize_copy(VALUE self, VALUE obj)
+{
+	CHECK;
+	*THIS = to<Reflex::DrawEvent&>(obj);
+	return self;
+}
+
+static
+VALUE painter(VALUE self)
+{
+	CHECK;
+	return value(THIS->painter);
+}
+
+static
+VALUE bounds(VALUE self)
+{
+	CHECK;
+	return value(THIS->bounds);
+}
+
+static
+VALUE dt(VALUE self)
+{
+	CHECK;
+	return value(THIS->dt);
+}
+
+static
+VALUE fps(VALUE self)
+{
+	CHECK;
+	return value(THIS->fps);
+}
+
+
+void
+Init_draw_event ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	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_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);
+	rb_define_method(cDrawEvent, "dt", RUBY_METHOD_FUNC(dt), 0);
+	rb_define_method(cDrawEvent, "fps", RUBY_METHOD_FUNC(fps), 0);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	draw_event_class ()
+	{
+		return cDrawEvent;
+	}
+
+
+}// Reflex

data/.doc/ext/reflex/event.cpp

@@ -0,0 +1,73 @@
+#include "reflex/ruby/event.h"
+
+
+#include <rucy.h>
+#include "defs.h"
+
+
+using namespace Rucy;
+
+
+static Class cEvent;
+
+RUCY_DEFINE_VALUE_FROM_TO(Reflex::Event, cEvent)
+
+#define THIS  to<Reflex::Event*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Reflex::Event, cEvent, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return new_type<Reflex::Event>(klass);
+}
+
+static
+VALUE initialize_copy(VALUE self, VALUE obj)
+{
+	CHECK;
+	*THIS = to<Reflex::Event&>(obj);
+	return self;
+}
+
+static
+VALUE block(VALUE self)
+{
+	CHECK;
+	THIS->block();
+}
+
+static
+VALUE is_blocked(VALUE self)
+{
+	CHECK;
+	return value(THIS->is_blocked());
+}
+
+
+void
+Init_event ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cEvent = rb_define_class_under(mReflex, "Event", rb_cObject);
+	rb_define_alloc_func(cEvent, alloc);
+	rb_define_private_method(cEvent, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
+	rb_define_method(cEvent, "block", RUBY_METHOD_FUNC(block), 0);
+	cEvent.define_method("block?", is_blocked);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	event_class ()
+	{
+		return cEvent;
+	}
+
+
+}// Reflex

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

@@ -0,0 +1,98 @@
+#include "reflex/ruby/event.h"
+
+
+#include <rucy.h>
+#include "reflex/ruby/view.h"
+#include "defs.h"
+
+
+using namespace Rucy;
+
+
+static Class cFocusEvent;
+
+RUCY_DEFINE_VALUE_FROM_TO(Reflex::FocusEvent, cFocusEvent)
+
+#define THIS  to<Reflex::FocusEvent*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Reflex::FocusEvent, cFocusEvent, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return new_type<Reflex::FocusEvent>(klass);
+}
+
+static
+VALUE initialize(VALUE self, VALUE type, VALUE focus, VALUE last)
+{
+	CHECK;
+
+	THIS->focus = to<Reflex::View*>(focus);
+	THIS->focus = to<Reflex::View*>(focus);
+	THIS->last  = to<Reflex::View*>(last);
+
+	return rb_call_super(0, NULL);
+}
+
+static
+VALUE initialize_copy(VALUE self, VALUE obj)
+{
+	CHECK;
+	*THIS = to<Reflex::FocusEvent&>(obj);
+	return self;
+}
+
+static
+VALUE get_type(VALUE self)
+{
+	CHECK;
+	return value(THIS->type);
+}
+
+static
+VALUE focus(VALUE self)
+{
+	CHECK;
+	return THIS->focus ? value(THIS->focus) : nil();
+}
+
+static
+VALUE last(VALUE self)
+{
+	CHECK;
+	return THIS->last ? value(THIS->last) : nil();
+}
+
+
+void
+Init_focus_event ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cFocusEvent = mReflex.define_class("FocusEvent", Reflex::event_class());
+	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, "last", RUBY_METHOD_FUNC(last), 0);
+	cFocusEvent.define_const("TYPE_NONE",  Reflex::FocusEvent::NONE);
+	cFocusEvent.define_const("TYPE_FOCUS", Reflex::FocusEvent::FOCUS);
+	cFocusEvent.define_const("TYPE_BLUR",  Reflex::FocusEvent::BLUR);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	focus_event_class ()
+	{
+		return cFocusEvent;
+	}
+
+
+}// Reflex

data/.doc/ext/reflex/frame_event.cpp

@@ -0,0 +1,133 @@
+#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;
+
+
+static Class cFrameEvent;
+
+RUCY_DEFINE_VALUE_FROM_TO(Reflex::FrameEvent, cFrameEvent)
+
+#define THIS  to<Reflex::FrameEvent*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Reflex::FrameEvent, cFrameEvent, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return new_type<Reflex::FrameEvent>(klass);
+}
+
+static
+VALUE initialize(VALUE self)
+{
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "FrameEvent#initialize", argc, 0, 1, 2, 3, 4, 5);
+
+	THIS->frame   = (argc >= 1) ? to<Rays::Bounds&>(argv[0]) : Rays::Bounds(0);
+	THIS->dx      = (argc >= 2) ? to<coord>(argv[1]) : 0;
+	THIS->dy      = (argc >= 3) ? to<coord>(argv[2]) : 0;
+	THIS->dwidth  = (argc >= 4) ? to<coord>(argv[3]) : 0;
+	THIS->dheight = (argc >= 5) ? to<coord>(argv[4]) : 0;
+
+	return rb_call_super(0, NULL);
+}
+
+static
+VALUE initialize_copy(VALUE self, VALUE obj)
+{
+	CHECK;
+	*THIS = to<Reflex::FrameEvent&>(obj);
+	return self;
+}
+
+static
+VALUE frame(VALUE self)
+{
+	CHECK;
+	return value(THIS->frame);
+}
+
+static
+VALUE dx(VALUE self)
+{
+	CHECK;
+	return value(THIS->dx);
+}
+
+static
+VALUE dy(VALUE self)
+{
+	CHECK;
+	return value(THIS->dy);
+}
+
+static
+VALUE dwidth(VALUE self)
+{
+	CHECK;
+	return value(THIS->dwidth);
+}
+
+static
+VALUE dheight(VALUE self)
+{
+	CHECK;
+	return value(THIS->dheight);
+}
+
+static
+VALUE dposition(VALUE self)
+{
+	CHECK;
+	return value(Rays::Point(THIS->dx, THIS->dy));
+}
+
+static
+VALUE dsize(VALUE self)
+{
+	CHECK;
+	return value(Rays::Point(THIS->dw, THIS->dh));
+}
+
+
+void
+Init_frame_event ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cFrameEvent = mReflex.define_class("FrameEvent", Reflex::event_class());
+	rb_define_alloc_func(cFrameEvent, alloc);
+	rb_define_private_method(cFrameEvent, "initialize", RUBY_METHOD_FUNC(initialize), -1);
+	rb_define_private_method(cFrameEvent, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
+	rb_define_method(cFrameEvent, "frame", RUBY_METHOD_FUNC(frame), 0);
+	rb_define_method(cFrameEvent, "dx", RUBY_METHOD_FUNC(dx), 0);
+	rb_define_method(cFrameEvent, "dy", RUBY_METHOD_FUNC(dy), 0);
+	rb_define_method(cFrameEvent, "dwidth", RUBY_METHOD_FUNC(dwidth), 0);
+	rb_define_method(cFrameEvent, "dheight", RUBY_METHOD_FUNC(dheight), 0);
+	rb_define_method(cFrameEvent, "dposition", RUBY_METHOD_FUNC(dposition), 0);
+	rb_define_method(cFrameEvent, "dsize", RUBY_METHOD_FUNC(dsize), 0);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	frame_event_class ()
+	{
+		return cFrameEvent;
+	}
+
+
+}// Reflex

data/.doc/ext/reflex/image_view.cpp

@@ -0,0 +1,74 @@
+#include "reflex/ruby/image_view.h"
+
+
+#include <rucy.h>
+#include "reflex/ruby/view.h"
+
+
+using namespace Rucy;
+
+using Reflex::coord;
+
+
+static Class cImageView;
+
+RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(Reflex::ImageView, cImageView)
+
+#define THIS      to<Reflex::ImageView*>(self)
+
+#define CHECK     RUCY_CHECK_OBJECT(Reflex::ImageView, cImageView, self)
+
+#define CALL(fun) RUCY_WRAPPER_CALL(Reflex::ImageView, THIS, fun)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return value(new Reflex::RubyView<Reflex::ImageView>, klass);
+}
+
+static
+VALUE get_image(VALUE self)
+{
+	CHECK;
+	Rays::Image image = THIS->get_image();
+	return image ? value(image) : nil();
+}
+
+static
+VALUE set_image(VALUE self, VALUE image)
+{
+	CHECK;
+	THIS->set_image(image ? to<Rays::Image&>(image) : Rays::Image());
+	return image;
+}
+
+static
+RUCY_DEF_clear_override_flags(cof, Reflex::ImageView, cImageView);
+
+
+void
+Init_image_view ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cImageView = mReflex.define_class("ImageView", Reflex::view_class());
+	rb_define_alloc_func(cImageView, alloc);
+	rb_define_private_method(cImageView, "set_image", RUBY_METHOD_FUNC(set_image), 1);
+	rb_define_method(cImageView, "image", RUBY_METHOD_FUNC(get_image), 0);
+	
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	image_view_class ()
+	{
+		return cImageView;
+	}
+
+
+}// Reflex