reflexion 0.1.6 → 0.1.7

data/ext/reflex/wheel_event.cpp

@@ -0,0 +1,158 @@
+#include "reflex/ruby/event.h"
+
+
+#include <rucy.h>
+#include "rays/ruby/point.h"
+#include "defs.h"
+
+
+using namespace Rucy;
+
+using Reflex::coord;
+
+
+static Class cWheelEvent;
+
+RUCY_DEFINE_VALUE_FROM_TO(Reflex::WheelEvent, cWheelEvent)
+
+#define THIS  to<Reflex::WheelEvent*>(self)
+
+#define CHECK RUCY_CHECK_OBJ(Reflex::WheelEvent, cWheelEvent, self)
+
+
+static
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return new_type<Reflex::WheelEvent>(klass);
+}
+RUCY_END
+
+static
+RUCY_DEFN(initialize)
+{
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "WheelEvent#initialize", argc, 0, 1, 2, 3);
+
+	THIS->dx = (argc >= 1) ? to<coord>(argv[0]) : 0;
+	THIS->dy = (argc >= 2) ? to<coord>(argv[1]) : 0;
+	THIS->dz = (argc >= 3) ? to<coord>(argv[2]) : 0;
+
+	return rb_call_super(0, NULL);
+}
+RUCY_END
+
+static
+RUCY_DEF1(initialize_copy, obj)
+{
+	CHECK;
+	*THIS = to<Reflex::WheelEvent&>(obj);
+	return self;
+}
+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(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(modifiers)
+{
+	CHECK;
+	return value(THIS->modifiers);
+}
+RUCY_END
+
+static
+RUCY_DEF0(delta)
+{
+	CHECK;
+	return value(Rays::Point(THIS->dx, THIS->dy, THIS->dz));
+}
+RUCY_END
+
+static
+RUCY_DEF0(position)
+{
+	CHECK;
+	return value(Rays::Point(THIS->x, THIS->y, THIS->z));
+}
+RUCY_END
+
+
+void
+Init_wheel_event ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cWheelEvent = mReflex.define_class("WheelEvent", Reflex::event_class());
+	cWheelEvent.define_alloc_func(alloc);
+	cWheelEvent.define_private_method("initialize", initialize);
+	cWheelEvent.define_private_method("initialize_copy", initialize_copy);
+	cWheelEvent.define_method("dx", dx);
+	cWheelEvent.define_method("dy", dy);
+	cWheelEvent.define_method("dz", dz);
+	cWheelEvent.define_method("x", x);
+	cWheelEvent.define_method("y", y);
+	cWheelEvent.define_method("z", z);
+	cWheelEvent.define_method("modifiers", modifiers);
+	cWheelEvent.define_method("delta", delta);
+	cWheelEvent.define_method("position", position);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	wheel_event_class ()
+	{
+		return cWheelEvent;
+	}
+
+
+}// Reflex

data/ext/reflex/window.cpp

@@ -2,9 +2,9 @@
 
 
 #include <rucy.h>
+#include <rays/ruby/bounds.h>
 #include <rays/ruby/painter.h>
-#include <reflex/ruby/view.h>
-#include "defs.h"
+#include "reflex/ruby/view.h"
 
 
 using namespace Rucy;
@@ -14,233 +14,221 @@ using Reflex::coord;
 
 static Class cWindow;
 
-
-namespace Reflex
-{
-
-
-	Class
-	window_class ()
-	{
-		return cWindow;
-	}
-
-
-}// Reflex
-
-
-typedef Reflex::RubyWindow<Reflex::Window> RubyWindow;
-
+RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(Reflex::Window, cWindow)
 
 #define THIS      to<Reflex::Window*>(self)
 
-#define CHECK     RUCY_CHECK_OBJECT(self, Reflex::Window, cWindow)
+#define CHECK     RUCY_CHECK_OBJECT(Reflex::Window, cWindow, self)
 
-#define CALL(fun) RUCY_WRAPPER_CALL(RubyWindow, THIS, fun)
+#define CALL(fun) RUCY_WRAPPER_CALL(Reflex::Window, THIS, fun)
 
 
 static
-RUBY_DEF_ALLOC(alloc, klass)
+RUCY_DEF_ALLOC(alloc, klass)
 {
-	return value(new RubyWindow, klass);
+	return value(new Reflex::RubyWindow<Reflex::Window>, klass);
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(close)
+RUCY_DEF0(close)
 {
 	CHECK;
-	if (!CALL(close()))
-		system_error("failed to close window.");
+	CALL(close());
 	return self;
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(show)
+RUCY_DEF0(show)
 {
 	CHECK;
-	if (!CALL(show()))
-		system_error("failed to show window.");
+	CALL(show());
 	return self;
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(hide)
+RUCY_DEF0(hide)
 {
 	CHECK;
-	if (!CALL(hide()))
-		system_error("failed to hide window.");
+	CALL(hide());
 	return self;
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(redraw)
+RUCY_DEF0(redraw)
 {
 	CHECK;
-	if (!THIS->redraw())
-		system_error("failed to redraw window.");
+	THIS->redraw();
 	return self;
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF1(set_title, title)
+RUCY_DEF1(set_title, title)
 {
 	CHECK;
-	if (!THIS->set_title(title.c_str()))
-		system_error("failed to set title of window.");
+	THIS->set_title(title.c_str());
 	return title;
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(get_title)
+RUCY_DEF0(get_title)
 {
 	CHECK;
-	const char* s = THIS->title();
-	if (!s) system_error("failed to get title of window.");
-	return value(s);
+	return value(THIS->title());
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF4(set_bounds, x, y, width, height)
+RUCY_DEF1(set_frame, arg)
 {
 	CHECK;
-	if (!THIS->set_bounds(
-		to<coord>(x), to<coord>(y), to<coord>(width), to<coord>(height)))
-	{
-		system_error("failed to set bounds of window.");
-	}
-	return value(THIS->bounds());
+	THIS->set_frame(to<Rays::Bounds>(arg));
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(get_bounds)
+RUCY_DEF0(get_frame)
 {
 	CHECK;
-	return value(THIS->bounds());
+	return value(THIS->frame());
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(hidden)
+RUCY_DEF0(hidden)
 {
 	CHECK;
 	return value(THIS->hidden());
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(root)
+RUCY_DEF0(root)
 {
 	CHECK;
 	return value(THIS->root());
 }
-RUBY_END
+RUCY_END
+
+static
+RUCY_DEF0(focus)
+{
+	CHECK;
+	return value(THIS->focus());
+}
+RUCY_END
 
 static
-RUBY_DEF0(painter)
+RUCY_DEF0(painter)
 {
 	CHECK;
 	return value(THIS->painter());
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF1(update, dt)
+RUCY_DEF1(on_update, event)
 {
 	CHECK;
-	CALL(update(to<float>(dt)));
-	return self;
+	CALL(on_update(to<Reflex::UpdateEvent*>(event)));
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(draw)
+RUCY_DEF1(on_draw, event)
 {
 	CHECK;
-	CALL(draw());
-	return self;
+	CALL(on_draw(to<Reflex::DrawEvent*>(event)));
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF2(moved, x, y)
+RUCY_DEF1(on_move, event)
 {
 	CHECK;
-	CALL(moved(to<coord>(x), to<coord>(y)));
-	return self;
+	CALL(on_move(to<Reflex::FrameEvent*>(event)));
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF2(resized, width, height)
+RUCY_DEF1(on_resize, event)
 {
 	CHECK;
-	CALL(resized(to<coord>(width), to<coord>(height)));
-	return self;
+	CALL(on_resize(to<Reflex::FrameEvent*>(event)));
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF1(key_down, key)
+RUCY_DEF1(on_key, event)
 {
 	CHECK;
-	Reflex::Key* k = to<Reflex::Key*>(key);
-	if (!k) argument_error();
-	CALL(key_down(*k));
-	return self;
+	CALL(on_key(to<Reflex::KeyEvent*>(event)));
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF1(key_up, key)
+RUCY_DEF1(on_key_down, event)
 {
 	CHECK;
-	Reflex::Key* k = to<Reflex::Key*>(key);
-	if (!k) argument_error();
-	CALL(key_up(*k));
-	return self;
+	CALL(on_key_down(to<Reflex::KeyEvent*>(event)));
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF1(points_down, points)
+RUCY_DEF1(on_key_up, event)
 {
 	CHECK;
-	Reflex::Points* p = to<Reflex::Points*>(points);
-	if (!p) argument_error();
-	CALL(points_down(*p));
-	return self;
+	CALL(on_key_up(to<Reflex::KeyEvent*>(event)));
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF1(points_up, points)
+RUCY_DEF1(on_pointer, event)
 {
 	CHECK;
-	Reflex::Points* p = to<Reflex::Points*>(points);
-	if (!p) argument_error();
-	CALL(points_up(*p));
-	return self;
+	CALL(on_pointer(to<Reflex::PointerEvent*>(event)));
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF1(points_moved, points)
+RUCY_DEF1(on_pointer_down, event)
 {
 	CHECK;
-	Reflex::Points* p = to<Reflex::Points*>(points);
-	if (!p) argument_error();
-	CALL(points_moved(*p));
-	return self;
+	CALL(on_pointer_down(to<Reflex::PointerEvent*>(event)));
 }
-RUBY_END
+RUCY_END
+
+static
+RUCY_DEF1(on_pointer_up, event)
+{
+	CHECK;
+	CALL(on_pointer_up(to<Reflex::PointerEvent*>(event)));
+}
+RUCY_END
+
+static
+RUCY_DEF1(on_pointer_move, event)
+{
+	CHECK;
+	CALL(on_pointer_move(to<Reflex::PointerEvent*>(event)));
+}
+RUCY_END
+
+static
+RUCY_DEF1(on_wheel, event)
+{
+	CHECK;
+	CALL(on_wheel(to<Reflex::WheelEvent*>(event)));
+}
+RUCY_END
+
+static
+RUCY_DEF_clear_override_flags(cof, Reflex::Window, cWindow);
 
 
 void
@@ -256,18 +244,37 @@ Init_window ()
 	cWindow.define_method("redraw", redraw);
 	cWindow.define_method("title=", set_title);
 	cWindow.define_method("title", get_title);
-	cWindow.define_private_method("set_bounds", set_bounds);
-	cWindow.define_private_method("get_bounds", get_bounds);
+	cWindow.define_private_method("set_frame", set_frame);
+	cWindow.define_private_method("get_frame", get_frame);
 	cWindow.define_method("hidden", hidden);
 	cWindow.define_method("root", root);
+	cWindow.define_method("focus", focus);
 	cWindow.define_method("painter", painter);
-	cWindow.define_method("update", update);
-	cWindow.define_method("draw", draw);
-	cWindow.define_method("moved", moved);
-	cWindow.define_method("resized", resized);
-	cWindow.define_method("key_down", key_down);
-	cWindow.define_method("key_up", key_up);
-	cWindow.define_method("points_down", points_down);
-	cWindow.define_method("points_up",   points_up);
-	cWindow.define_method("points_moved", points_moved);
+	cWindow.define_method("on_update", on_update);
+	cWindow.define_method("on_draw",   on_draw);
+	cWindow.define_method("on_move",   on_move);
+	cWindow.define_method("on_resize", on_resize);
+	cWindow.define_method("on_key",      on_key);
+	cWindow.define_method("on_key_down", on_key_down);
+	cWindow.define_method("on_key_up",   on_key_up);
+	cWindow.define_method("on_pointer",      on_pointer);
+	cWindow.define_method("on_pointer_down", on_pointer_down);
+	cWindow.define_method("on_pointer_up",   on_pointer_up);
+	cWindow.define_method("on_pointer_move", on_pointer_move);
+	cWindow.define_method("on_wheel", on_wheel);
+	cWindow.define_clear_override_flags(cof);
 }
+
+
+namespace Reflex
+{
+
+
+	Class
+	window_class ()
+	{
+		return cWindow;
+	}
+
+
+}// Reflex

data/include/reflex/application.h

@@ -7,6 +7,7 @@
 #include <xot/ref.h>
 #include <xot/pimpl.h>
 #include <reflex/defs.h>
+#include <reflex/event.h>
 
 
 namespace Reflex
@@ -24,17 +25,21 @@ namespace Reflex
 
 			Application ();
 
-			virtual bool run ();
+			virtual void start ();
 
-			virtual bool quit ();
+			virtual void quit ();
 
-			virtual bool preference ();
+			virtual void    set_name (const char* name);
 
-			virtual bool about ();
+			virtual const char* name () const;
 
-			virtual bool    set_name (const char* name);
+			virtual void on_start (Event* e);
 
-			virtual const char* name () const;
+			virtual void on_quit (Event* e);
+
+			virtual void on_preference (Event* e);
+
+			virtual void on_about (Event* e);
 
 			operator bool () const;
 
@@ -42,7 +47,7 @@ namespace Reflex
 
 			struct Data;
 
-			Xot::PImpl<Data, true> self;
+			Xot::PImpl<Data> self;
 
 		protected: