reflexion 0.1.6 → 0.1.7

data/.doc/ext/reflex/key_event.cpp

@@ -0,0 +1,124 @@
+#include "reflex/ruby/event.h"
+
+
+#include <rucy.h>
+#include "defs.h"
+
+
+using namespace Rucy;
+
+
+static Class cKeyEvent;
+
+RUCY_DEFINE_VALUE_FROM_TO(Reflex::KeyEvent, cKeyEvent)
+
+#define THIS  to<Reflex::KeyEvent*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Reflex::KeyEvent, cKeyEvent, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return new_type<Reflex::KeyEvent>(klass);
+}
+
+static
+VALUE initialize(VALUE self)
+{
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "KeyEvent#initialize", argc, 0, 1, 2, 3, 4, 5);
+
+	THIS->type      = (argc >= 1) ? (Reflex::KeyEvent::Type) to<int>(argv[0]) : Reflex::KeyEvent::NONE;
+	THIS->chars     = (argc >= 2) ? argv[1].c_str()   : NULL;
+	THIS->code      = (argc >= 3) ? to<int>(argv[2])  : Reflex::KEY_NONE;
+	THIS->repeat    = (argc >= 4) ? to<int>(argv[3])  : 1;
+	THIS->modifiers = (argc >= 5) ? to<uint>(argv[4]) : (uint) Reflex::MOD_NONE;
+
+	return rb_call_super(0, NULL);
+}
+
+static
+VALUE initialize_copy(VALUE self, VALUE obj)
+{
+	CHECK;
+	*THIS = to<Reflex::KeyEvent&>(obj);
+	return self;
+}
+
+static
+VALUE get_type(VALUE self)
+{
+	CHECK;
+	return value(THIS->type);
+}
+
+static
+VALUE chars(VALUE self)
+{
+	CHECK;
+	return value(THIS->chars.c_str());
+}
+
+static
+VALUE code(VALUE self)
+{
+	CHECK;
+	return value(THIS->code);
+}
+
+static
+VALUE modifiers(VALUE self)
+{
+	CHECK;
+	return value(THIS->modifiers);
+}
+
+static
+VALUE repeat(VALUE self)
+{
+	CHECK;
+	return value(THIS->repeat);
+}
+
+static
+VALUE capture(VALUE self)
+{
+	CHECK;
+	return value(THIS->capture);
+}
+
+
+void
+Init_key_event ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cKeyEvent = mReflex.define_class("KeyEvent", Reflex::event_class());
+	rb_define_alloc_func(cKeyEvent, alloc);
+	rb_define_private_method(cKeyEvent, "initialize", RUBY_METHOD_FUNC(initialize), -1);
+	rb_define_private_method(cKeyEvent, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
+	rb_define_method(cKeyEvent, "get_type", RUBY_METHOD_FUNC(get_type), 0);
+	rb_define_method(cKeyEvent, "chars", RUBY_METHOD_FUNC(chars), 0);
+	rb_define_method(cKeyEvent, "code", RUBY_METHOD_FUNC(code), 0);
+	rb_define_method(cKeyEvent, "modifiers", RUBY_METHOD_FUNC(modifiers), 0);
+	rb_define_method(cKeyEvent, "repeat", RUBY_METHOD_FUNC(repeat), 0);
+	cKeyEvent.define_method("capture?", capture);
+	cKeyEvent.define_const("TYPE_NONE", Reflex::KeyEvent::NONE);
+	cKeyEvent.define_const("TYPE_DOWN", Reflex::KeyEvent::DOWN);
+	cKeyEvent.define_const("TYPE_UP",   Reflex::KeyEvent::UP);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	key_event_class ()
+	{
+		return cKeyEvent;
+	}
+
+
+}// Reflex

data/.doc/ext/reflex/native.cpp

@@ -6,23 +6,62 @@ using namespace Rucy;
 
 
 void Init_reflex ();
-void Init_key ();
-void Init_points ();
+
+void Init_selector ();
+void Init_style ();
+void Init_style_length ();
+void Init_style_length2 ();
+void Init_style_length4 ();
+
+void Init_event ();
+void Init_update_event ();
+void Init_draw_event ();
+void Init_frame_event ();
+void Init_scroll_event ();
+void Init_focus_event ();
+void Init_key_event ();
+void Init_pointer_event ();
+void Init_wheel_event ();
+void Init_capture_event ();
+
 void Init_application ();
 void Init_window ();
 void Init_view ();
 
+void Init_image_view ();
+
 
 extern "C" void
 Init_native ()
 {
-	if (!Rucy::init())
-		raise(rb_eLoadError, "Rucy::init() failed.");
+	RUCY_TRY
+
+	Rucy::init();
 
 	Init_reflex();
-	Init_key();
-	Init_points();
+
+	Init_selector();
+	Init_style();
+	Init_style_length();
+	Init_style_length2();
+	Init_style_length4();
+
+	Init_event();
+	Init_update_event();
+	Init_draw_event();
+	Init_frame_event();
+	Init_scroll_event();
+	Init_focus_event();
+	Init_key_event();
+	Init_pointer_event();
+	Init_wheel_event();
+	Init_capture_event();
+
 	Init_application();
 	Init_window();
 	Init_view();
+
+	Init_image_view();
+
+	RUCY_CATCH
 }

data/.doc/ext/reflex/pointer_event.cpp

@@ -0,0 +1,181 @@
+#include "reflex/ruby/event.h"
+
+
+#include <rucy.h>
+#include <rays/ruby/point.h>
+#include "defs.h"
+
+
+using namespace Rucy;
+
+using Reflex::coord;
+
+
+static Class cPointerEvent;
+
+RUCY_DEFINE_VALUE_FROM_TO(Reflex::PointerEvent, cPointerEvent)
+
+#define THIS  to<Reflex::PointerEvent*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Reflex::PointerEvent, cPointerEvent, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return new_type<Reflex::PointerEvent>(klass);
+}
+
+static
+VALUE initialize(VALUE self)
+{
+	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;
+
+	return rb_call_super(0, NULL);
+}
+
+static
+VALUE initialize_copy(VALUE self, VALUE obj)
+{
+	CHECK;
+	*THIS = to<Reflex::PointerEvent&>(obj);
+	return self;
+}
+
+static
+VALUE get_type(VALUE self)
+{
+	CHECK;
+	return value(THIS->type);
+}
+
+static
+VALUE get_pointer_type(VALUE self)
+{
+	CHECK;
+	return value(THIS->pointer_type);
+}
+
+static
+VALUE size(VALUE self)
+{
+	CHECK;
+	return value(THIS->size);
+}
+
+static
+VALUE modifiers(VALUE self)
+{
+	CHECK;
+	return value(THIS->modifiers);
+}
+
+static
+VALUE count(VALUE self)
+{
+	CHECK;
+	return value(THIS->count);
+}
+
+static
+VALUE drag(VALUE self)
+{
+	CHECK;
+	return value(THIS->drag);
+}
+
+static
+VALUE capture(VALUE self)
+{
+	CHECK;
+	return value(THIS->capture);
+}
+
+static
+VALUE x(VALUE self)
+{
+	CHECK;
+	return value(THIS->x);
+}
+
+static
+VALUE y(VALUE self)
+{
+	CHECK;
+	return value(THIS->y);
+}
+
+static
+VALUE position(VALUE self)
+{
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "PointerEvent#position", argc, 0, 1);
+
+	size_t index = argc >= 1 ? to<int>(argv[0]) : 0;
+	return value(THIS->position(index));
+}
+
+static
+VALUE array_get(VALUE self, VALUE index)
+{
+	CHECK;
+	return value((*THIS)[index.to_i()]);
+}
+
+
+void
+Init_pointer_event ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cPointerEvent = mReflex.define_class("PointerEvent", Reflex::event_class());
+	rb_define_alloc_func(cPointerEvent, alloc);
+	rb_define_private_method(cPointerEvent, "initialize", RUBY_METHOD_FUNC(initialize), -1);
+	rb_define_private_method(cPointerEvent, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
+	rb_define_method(cPointerEvent, "get_type", RUBY_METHOD_FUNC(get_type), 0);
+	rb_define_method(cPointerEvent, "get_pointer_type", RUBY_METHOD_FUNC(get_pointer_type), 0);
+	rb_define_method(cPointerEvent, "size", RUBY_METHOD_FUNC(size), 0);
+	rb_define_method(cPointerEvent, "modifiers", RUBY_METHOD_FUNC(modifiers), 0);
+	rb_define_method(cPointerEvent, "count", RUBY_METHOD_FUNC(count), 0);
+	cPointerEvent.define_method("drag?", drag);
+	cPointerEvent.define_method("capture?", capture);
+	rb_define_method(cPointerEvent, "x", RUBY_METHOD_FUNC(x), 0);
+	rb_define_method(cPointerEvent, "y", RUBY_METHOD_FUNC(y), 0);
+	rb_define_method(cPointerEvent, "position", RUBY_METHOD_FUNC(position), -1);
+	cPointerEvent.define_method("[]", array_get);
+	cPointerEvent.define_const("TYPE_NONE", Reflex::PointerEvent::NONE);
+	cPointerEvent.define_const("TYPE_DOWN", Reflex::PointerEvent::DOWN);
+	cPointerEvent.define_const("TYPE_UP",   Reflex::PointerEvent::UP);
+	cPointerEvent.define_const("TYPE_MOVE", Reflex::PointerEvent::MOVE);
+	cPointerEvent.define_const("POINTER_NONE",         Reflex::POINTER_NONE);
+	cPointerEvent.define_const("POINTER_MOUSE_LEFT",   Reflex::POINTER_MOUSE_LEFT);
+	cPointerEvent.define_const("POINTER_MOUSE_RIGHT",  Reflex::POINTER_MOUSE_RIGHT);
+	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);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	pointer_event_class ()
+	{
+		return cPointerEvent;
+	}
+
+
+}// Reflex

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

@@ -1,5 +1,5 @@
 #include <rucy.h>
-#include <reflex/reflex.h>
+#include "reflex/reflex.h"
 #include "defs.h"
 
 
@@ -9,53 +9,17 @@ using namespace Rucy;
 static Module mReflex;
 
 
-namespace Reflex
-{
-
-
-	Module
-	reflex_module ()
-	{
-		return mReflex;
-	}
-
-
-}// Reflex
-
-
 static
 VALUE init(VALUE self)
 {
-	if (!Reflex::init())
-		reflex_error("Reflex::init() failed.");
-
+	Reflex::init();
 	return self;
 }
 
 static
 VALUE fin(VALUE self)
 {
-	if (!Reflex::fin())
-		reflex_error("Reflex::fin() failed.");
-
-	return self;
-}
-
-static
-VALUE run(VALUE self, VALUE name)
-{
-	if (!Reflex::run(name ? name.c_str() : NULL))
-		reflex_error("Reflex::run() failed.");
-
-	return self;
-}
-
-static
-VALUE quit(VALUE self)
-{
-	if (!Reflex::quit())
-		reflex_error("Reflex::quit() failed.");
-
+	Reflex::fin();
 	return self;
 }
 
@@ -66,6 +30,18 @@ Init_reflex ()
 	mReflex = rb_define_module("Reflex");
 	mReflex.define_singleton_method("init!", init);
 	mReflex.define_singleton_method("fin!", fin);
-	mReflex.define_singleton_method("run!", run);
-	rb_define_singleton_method(mReflex, "quit", RUBY_METHOD_FUNC(quit), 0);
 }
+
+
+namespace Reflex
+{
+
+
+	Module
+	reflex_module ()
+	{
+		return mReflex;
+	}
+
+
+}// Reflex

data/.doc/ext/reflex/scroll_event.cpp

@@ -0,0 +1,141 @@
+#include "reflex/ruby/event.h"
+
+
+#include <rucy.h>
+#include "rays/ruby/point.h"
+#include "defs.h"
+
+
+using namespace Rucy;
+
+using Reflex::coord;
+
+
+static Class cScrollEvent;
+
+RUCY_DEFINE_VALUE_FROM_TO(Reflex::ScrollEvent, cScrollEvent)
+
+#define THIS  to<Reflex::ScrollEvent*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Reflex::ScrollEvent, cScrollEvent, self)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return new_type<Reflex::ScrollEvent>(klass);
+}
+
+static
+VALUE initialize(VALUE self)
+{
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "ScrollEvent#initialize", argc, 0, 1, 2, 3, 4, 5, 6);
+
+	THIS->x       = (argc >= 1) ? to<coord>(argv[0]) : 0;
+	THIS->y       = (argc >= 2) ? to<coord>(argv[1]) : 0;
+	THIS->z       = (argc >= 3) ? to<coord>(argv[2]) : 0;
+	THIS->dx      = (argc >= 4) ? to<coord>(argv[3]) : 0;
+	THIS->dy      = (argc >= 5) ? to<coord>(argv[4]) : 0;
+	THIS->dz      = (argc >= 6) ? to<coord>(argv[5]) : 0;
+
+	return rb_call_super(0, NULL);
+}
+
+static
+VALUE initialize_copy(VALUE self, VALUE obj)
+{
+	CHECK;
+	*THIS = to<Reflex::ScrollEvent&>(obj);
+	return self;
+}
+
+static
+VALUE x(VALUE self)
+{
+	CHECK;
+	return value(THIS->x);
+}
+
+static
+VALUE y(VALUE self)
+{
+	CHECK;
+	return value(THIS->y);
+}
+
+static
+VALUE z(VALUE self)
+{
+	CHECK;
+	return value(THIS->z);
+}
+
+static
+VALUE dx(VALUE self)
+{
+	CHECK;
+	return value(THIS->dx);
+}
+
+static
+VALUE dy(VALUE self)
+{
+	CHECK;
+	return value(THIS->dy);
+}
+
+static
+VALUE dz(VALUE self)
+{
+	CHECK;
+	return value(THIS->dz);
+}
+
+static
+VALUE scroll(VALUE self)
+{
+	CHECK;
+	return value(Rays::Point(THIS->x, THIS->y, THIS->z));
+}
+
+static
+VALUE delta(VALUE self)
+{
+	CHECK;
+	return value(Rays::Point(THIS->dx, THIS->dy, THIS->dz));
+}
+
+
+void
+Init_scroll_event ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cScrollEvent = mReflex.define_class("ScrollEvent", Reflex::event_class());
+	rb_define_alloc_func(cScrollEvent, alloc);
+	rb_define_private_method(cScrollEvent, "initialize", RUBY_METHOD_FUNC(initialize), -1);
+	rb_define_private_method(cScrollEvent, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
+	rb_define_method(cScrollEvent, "x", RUBY_METHOD_FUNC(x), 0);
+	rb_define_method(cScrollEvent, "y", RUBY_METHOD_FUNC(y), 0);
+	rb_define_method(cScrollEvent, "z", RUBY_METHOD_FUNC(z), 0);
+	rb_define_method(cScrollEvent, "dx", RUBY_METHOD_FUNC(dx), 0);
+	rb_define_method(cScrollEvent, "dy", RUBY_METHOD_FUNC(dy), 0);
+	rb_define_method(cScrollEvent, "dz", RUBY_METHOD_FUNC(dz), 0);
+	rb_define_method(cScrollEvent, "scroll", RUBY_METHOD_FUNC(scroll), 0);
+	rb_define_method(cScrollEvent, "delta", RUBY_METHOD_FUNC(delta), 0);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	scroll_event_class ()
+	{
+		return cScrollEvent;
+	}
+
+
+}// Reflex