reflexion 0.1.6 → 0.1.7

data/ext/reflex/key_event.cpp

@@ -0,0 +1,133 @@
+#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
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return new_type<Reflex::KeyEvent>(klass);
+}
+RUCY_END
+
+static
+RUCY_DEFN(initialize)
+{
+	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);
+}
+RUCY_END
+
+static
+RUCY_DEF1(initialize_copy, obj)
+{
+	CHECK;
+	*THIS = to<Reflex::KeyEvent&>(obj);
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_type)
+{
+	CHECK;
+	return value(THIS->type);
+}
+RUCY_END
+
+static
+RUCY_DEF0(chars)
+{
+	CHECK;
+	return value(THIS->chars.c_str());
+}
+RUCY_END
+
+static
+RUCY_DEF0(code)
+{
+	CHECK;
+	return value(THIS->code);
+}
+RUCY_END
+
+static
+RUCY_DEF0(modifiers)
+{
+	CHECK;
+	return value(THIS->modifiers);
+}
+RUCY_END
+
+static
+RUCY_DEF0(repeat)
+{
+	CHECK;
+	return value(THIS->repeat);
+}
+RUCY_END
+
+static
+RUCY_DEF0(capture)
+{
+	CHECK;
+	return value(THIS->capture);
+}
+RUCY_END
+
+
+void
+Init_key_event ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cKeyEvent = mReflex.define_class("KeyEvent", Reflex::event_class());
+	cKeyEvent.define_alloc_func(alloc);
+	cKeyEvent.define_private_method("initialize", initialize);
+	cKeyEvent.define_private_method("initialize_copy", initialize_copy);
+	cKeyEvent.define_method("get_type", get_type);
+	cKeyEvent.define_method("chars", chars);
+	cKeyEvent.define_method("code", code);
+	cKeyEvent.define_method("modifiers", modifiers);
+	cKeyEvent.define_method("repeat", repeat);
+	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/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/ext/reflex/pointer_event.cpp

@@ -0,0 +1,195 @@
+#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
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return new_type<Reflex::PointerEvent>(klass);
+}
+RUCY_END
+
+static
+RUCY_DEFN(initialize)
+{
+	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);
+}
+RUCY_END
+
+static
+RUCY_DEF1(initialize_copy, obj)
+{
+	CHECK;
+	*THIS = to<Reflex::PointerEvent&>(obj);
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_type)
+{
+	CHECK;
+	return value(THIS->type);
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_pointer_type)
+{
+	CHECK;
+	return value(THIS->pointer_type);
+}
+RUCY_END
+
+static
+RUCY_DEF0(size)
+{
+	CHECK;
+	return value(THIS->size);
+}
+RUCY_END
+
+static
+RUCY_DEF0(modifiers)
+{
+	CHECK;
+	return value(THIS->modifiers);
+}
+RUCY_END
+
+static
+RUCY_DEF0(count)
+{
+	CHECK;
+	return value(THIS->count);
+}
+RUCY_END
+
+static
+RUCY_DEF0(drag)
+{
+	CHECK;
+	return value(THIS->drag);
+}
+RUCY_END
+
+static
+RUCY_DEF0(capture)
+{
+	CHECK;
+	return value(THIS->capture);
+}
+RUCY_END
+
+static
+RUCY_DEF0(x)
+{
+	CHECK;
+	return value(THIS->x);
+}
+RUCY_END
+
+static
+RUCY_DEF0(y)
+{
+	CHECK;
+	return value(THIS->y);
+}
+RUCY_END
+
+static
+RUCY_DEFN(position)
+{
+	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));
+}
+RUCY_END
+
+static
+RUCY_DEF1(array_get, index)
+{
+	CHECK;
+	return value((*THIS)[index.to_i()]);
+}
+RUCY_END
+
+
+void
+Init_pointer_event ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cPointerEvent = mReflex.define_class("PointerEvent", Reflex::event_class());
+	cPointerEvent.define_alloc_func(alloc);
+	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("size", size);
+	cPointerEvent.define_method("modifiers", modifiers);
+	cPointerEvent.define_method("count", count);
+	cPointerEvent.define_method("drag?", drag);
+	cPointerEvent.define_method("capture?", capture);
+	cPointerEvent.define_method("x", x);
+	cPointerEvent.define_method("y", y);
+	cPointerEvent.define_method("position", position);
+	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/ext/reflex/reflex.cpp

@@ -1,5 +1,5 @@
 #include <rucy.h>
-#include <reflex/reflex.h>
+#include "reflex/reflex.h"
 #include "defs.h"
 
 
@@ -9,59 +9,21 @@ using namespace Rucy;
 static Module mReflex;
 
 
-namespace Reflex
-{
-
-
-	Module
-	reflex_module ()
-	{
-		return mReflex;
-	}
-
-
-}// Reflex
-
-
-static
-RUBY_DEF0(init)
-{
-	if (!Reflex::init())
-		reflex_error("Reflex::init() failed.");
-
-	return self;
-}
-RUBY_END
-
-static
-RUBY_DEF0(fin)
-{
-	if (!Reflex::fin())
-		reflex_error("Reflex::fin() failed.");
-
-	return self;
-}
-RUBY_END
-
 static
-RUBY_DEF1(run, name)
+RUCY_DEF0(init)
 {
-	if (!Reflex::run(name ? name.c_str() : NULL))
-		reflex_error("Reflex::run() failed.");
-
+	Reflex::init();
 	return self;
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(quit)
+RUCY_DEF0(fin)
 {
-	if (!Reflex::quit())
-		reflex_error("Reflex::quit() failed.");
-
+	Reflex::fin();
 	return self;
 }
-RUBY_END
+RUCY_END
 
 
 void
@@ -70,6 +32,18 @@ Init_reflex ()
 	mReflex = define_module("Reflex");
 	mReflex.define_singleton_method("init!", init);
 	mReflex.define_singleton_method("fin!", fin);
-	mReflex.define_singleton_method("run!", run);
-	mReflex.define_singleton_method("quit", quit);
 }
+
+
+namespace Reflex
+{
+
+
+	Module
+	reflex_module ()
+	{
+		return mReflex;
+	}
+
+
+}// Reflex

data/ext/reflex/scroll_event.cpp

@@ -0,0 +1,152 @@
+#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
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return new_type<Reflex::ScrollEvent>(klass);
+}
+RUCY_END
+
+static
+RUCY_DEFN(initialize)
+{
+	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);
+}
+RUCY_END
+
+static
+RUCY_DEF1(initialize_copy, obj)
+{
+	CHECK;
+	*THIS = to<Reflex::ScrollEvent&>(obj);
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF0(x)
+{
+	CHECK;
+	return value(THIS->x);
+}
+RUCY_END
+
+static
+RUCY_DEF0(y)
+{
+	CHECK;
+	return value(THIS->y);
+}
+RUCY_END
+
+static
+RUCY_DEF0(z)
+{
+	CHECK;
+	return value(THIS->z);
+}
+RUCY_END
+
+static
+RUCY_DEF0(dx)
+{
+	CHECK;
+	return value(THIS->dx);
+}
+RUCY_END
+
+static
+RUCY_DEF0(dy)
+{
+	CHECK;
+	return value(THIS->dy);
+}
+RUCY_END
+
+static
+RUCY_DEF0(dz)
+{
+	CHECK;
+	return value(THIS->dz);
+}
+RUCY_END
+
+static
+RUCY_DEF0(scroll)
+{
+	CHECK;
+	return value(Rays::Point(THIS->x, THIS->y, THIS->z));
+}
+RUCY_END
+
+static
+RUCY_DEF0(delta)
+{
+	CHECK;
+	return value(Rays::Point(THIS->dx, THIS->dy, THIS->dz));
+}
+RUCY_END
+
+
+void
+Init_scroll_event ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cScrollEvent = mReflex.define_class("ScrollEvent", Reflex::event_class());
+	cScrollEvent.define_alloc_func(alloc);
+	cScrollEvent.define_private_method("initialize", initialize);
+	cScrollEvent.define_private_method("initialize_copy", initialize_copy);
+	cScrollEvent.define_method("x", x);
+	cScrollEvent.define_method("y", y);
+	cScrollEvent.define_method("z", z);
+	cScrollEvent.define_method("dx", dx);
+	cScrollEvent.define_method("dy", dy);
+	cScrollEvent.define_method("dz", dz);
+	cScrollEvent.define_method("scroll", scroll);
+	cScrollEvent.define_method("delta", delta);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	scroll_event_class ()
+	{
+		return cScrollEvent;
+	}
+
+
+}// Reflex