reflexion 0.1.6 → 0.1.7

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

@@ -0,0 +1,146 @@
+#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
+VALUE alloc(VALUE klass)
+{
+	return new_type<Reflex::WheelEvent>(klass);
+}
+
+static
+VALUE initialize(VALUE self)
+{
+	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);
+}
+
+static
+VALUE initialize_copy(VALUE self, VALUE obj)
+{
+	CHECK;
+	*THIS = to<Reflex::WheelEvent&>(obj);
+	return self;
+}
+
+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 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 modifiers(VALUE self)
+{
+	CHECK;
+	return value(THIS->modifiers);
+}
+
+static
+VALUE delta(VALUE self)
+{
+	CHECK;
+	return value(Rays::Point(THIS->dx, THIS->dy, THIS->dz));
+}
+
+static
+VALUE position(VALUE self)
+{
+	CHECK;
+	return value(Rays::Point(THIS->x, THIS->y, THIS->z));
+}
+
+
+void
+Init_wheel_event ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cWheelEvent = mReflex.define_class("WheelEvent", Reflex::event_class());
+	rb_define_alloc_func(cWheelEvent, alloc);
+	rb_define_private_method(cWheelEvent, "initialize", RUBY_METHOD_FUNC(initialize), -1);
+	rb_define_private_method(cWheelEvent, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
+	rb_define_method(cWheelEvent, "dx", RUBY_METHOD_FUNC(dx), 0);
+	rb_define_method(cWheelEvent, "dy", RUBY_METHOD_FUNC(dy), 0);
+	rb_define_method(cWheelEvent, "dz", RUBY_METHOD_FUNC(dz), 0);
+	rb_define_method(cWheelEvent, "x", RUBY_METHOD_FUNC(x), 0);
+	rb_define_method(cWheelEvent, "y", RUBY_METHOD_FUNC(y), 0);
+	rb_define_method(cWheelEvent, "z", RUBY_METHOD_FUNC(z), 0);
+	rb_define_method(cWheelEvent, "modifiers", RUBY_METHOD_FUNC(modifiers), 0);
+	rb_define_method(cWheelEvent, "delta", RUBY_METHOD_FUNC(delta), 0);
+	rb_define_method(cWheelEvent, "position", RUBY_METHOD_FUNC(position), 0);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	wheel_event_class ()
+	{
+		return cWheelEvent;
+	}
+
+
+}// Reflex

data/.doc/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,43 +14,26 @@ 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
 VALUE alloc(VALUE klass)
 {
-	return value(new RubyWindow, klass);
+	return value(new Reflex::RubyWindow<Reflex::Window>, klass);
 }
 
 static
 VALUE close(VALUE self)
 {
 	CHECK;
-	if (!CALL(close()))
-		system_error("failed to close window.");
+	CALL(close());
 	return self;
 }
 
@@ -58,8 +41,7 @@ static
 VALUE show(VALUE self)
 {
 	CHECK;
-	if (!CALL(show()))
-		system_error("failed to show window.");
+	CALL(show());
 	return self;
 }
 
@@ -67,8 +49,7 @@ static
 VALUE hide(VALUE self)
 {
 	CHECK;
-	if (!CALL(hide()))
-		system_error("failed to hide window.");
+	CALL(hide());
 	return self;
 }
 
@@ -76,8 +57,7 @@ static
 VALUE redraw(VALUE self)
 {
 	CHECK;
-	if (!THIS->redraw())
-		system_error("failed to redraw window.");
+	THIS->redraw();
 	return self;
 }
 
@@ -85,8 +65,7 @@ static
 VALUE set_title(VALUE self, VALUE 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;
 }
 
@@ -94,28 +73,21 @@ static
 VALUE get_title(VALUE self)
 {
 	CHECK;
-	const char* s = THIS->title();
-	if (!s) system_error("failed to get title of window.");
-	return value(s);
+	return value(THIS->title());
 }
 
 static
-VALUE set_bounds(VALUE self, VALUE x, VALUE y, VALUE width, VALUE height)
+VALUE set_frame(VALUE self, VALUE 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));
 }
 
 static
-VALUE get_bounds(VALUE self)
+VALUE get_frame(VALUE self)
 {
 	CHECK;
-	return value(THIS->bounds());
+	return value(THIS->frame());
 }
 
 static
@@ -132,6 +104,13 @@ VALUE root(VALUE self)
 	return value(THIS->root());
 }
 
+static
+VALUE focus(VALUE self)
+{
+	CHECK;
+	return value(THIS->focus());
+}
+
 static
 VALUE painter(VALUE self)
 {
@@ -140,87 +119,92 @@ VALUE painter(VALUE self)
 }
 
 static
-VALUE update(VALUE self, VALUE dt)
+VALUE on_update(VALUE self, VALUE event)
 {
 	CHECK;
-	CALL(update(to<float>(dt)));
-	return self;
+	CALL(on_update(to<Reflex::UpdateEvent*>(event)));
 }
 
 static
-VALUE draw(VALUE self)
+VALUE on_draw(VALUE self, VALUE event)
 {
 	CHECK;
-	CALL(draw());
-	return self;
+	CALL(on_draw(to<Reflex::DrawEvent*>(event)));
 }
 
 static
-VALUE moved(VALUE self, VALUE x, VALUE y)
+VALUE on_move(VALUE self, VALUE event)
 {
 	CHECK;
-	CALL(moved(to<coord>(x), to<coord>(y)));
-	return self;
+	CALL(on_move(to<Reflex::FrameEvent*>(event)));
 }
 
 static
-VALUE resized(VALUE self, VALUE width, VALUE height)
+VALUE on_resize(VALUE self, VALUE event)
 {
 	CHECK;
-	CALL(resized(to<coord>(width), to<coord>(height)));
-	return self;
+	CALL(on_resize(to<Reflex::FrameEvent*>(event)));
 }
 
 static
-VALUE key_down(VALUE self, VALUE key)
+VALUE on_key(VALUE self, VALUE 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)));
 }
 
 static
-VALUE key_up(VALUE self, VALUE key)
+VALUE on_key_down(VALUE self, VALUE 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)));
 }
 
 static
-VALUE points_down(VALUE self, VALUE points)
+VALUE on_key_up(VALUE self, VALUE 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)));
 }
 
 static
-VALUE points_up(VALUE self, VALUE points)
+VALUE on_pointer(VALUE self, VALUE 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)));
 }
 
 static
-VALUE points_moved(VALUE self, VALUE points)
+VALUE on_pointer_down(VALUE self, VALUE 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)));
 }
 
+static
+VALUE on_pointer_up(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_pointer_up(to<Reflex::PointerEvent*>(event)));
+}
+
+static
+VALUE on_pointer_move(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_pointer_move(to<Reflex::PointerEvent*>(event)));
+}
+
+static
+VALUE on_wheel(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_wheel(to<Reflex::WheelEvent*>(event)));
+}
+
+static
+RUCY_DEF_clear_override_flags(cof, Reflex::Window, cWindow);
+
 
 void
 Init_window ()
@@ -235,18 +219,37 @@ Init_window ()
 	rb_define_method(cWindow, "redraw", RUBY_METHOD_FUNC(redraw), 0);
 	rb_define_method(cWindow, "title=", RUBY_METHOD_FUNC(set_title), 1);
 	rb_define_method(cWindow, "title", RUBY_METHOD_FUNC(get_title), 0);
-	rb_define_private_method(cWindow, "set_bounds", RUBY_METHOD_FUNC(set_bounds), 4);
-	rb_define_private_method(cWindow, "get_bounds", RUBY_METHOD_FUNC(get_bounds), 0);
+	rb_define_private_method(cWindow, "set_frame", RUBY_METHOD_FUNC(set_frame), 1);
+	rb_define_private_method(cWindow, "get_frame", RUBY_METHOD_FUNC(get_frame), 0);
 	rb_define_method(cWindow, "hidden", RUBY_METHOD_FUNC(hidden), 0);
 	rb_define_method(cWindow, "root", RUBY_METHOD_FUNC(root), 0);
+	rb_define_method(cWindow, "focus", RUBY_METHOD_FUNC(focus), 0);
 	rb_define_method(cWindow, "painter", RUBY_METHOD_FUNC(painter), 0);
-	rb_define_method(cWindow, "update", RUBY_METHOD_FUNC(update), 1);
-	rb_define_method(cWindow, "draw", RUBY_METHOD_FUNC(draw), 0);
-	rb_define_method(cWindow, "moved", RUBY_METHOD_FUNC(moved), 2);
-	rb_define_method(cWindow, "resized", RUBY_METHOD_FUNC(resized), 2);
-	rb_define_method(cWindow, "key_down", RUBY_METHOD_FUNC(key_down), 1);
-	rb_define_method(cWindow, "key_up", RUBY_METHOD_FUNC(key_up), 1);
-	rb_define_method(cWindow, "points_down", RUBY_METHOD_FUNC(points_down), 1);
-	rb_define_method(cWindow, "points_up", RUBY_METHOD_FUNC(points_up), 1);
-	rb_define_method(cWindow, "points_moved", RUBY_METHOD_FUNC(points_moved), 1);
+	rb_define_method(cWindow, "on_update", RUBY_METHOD_FUNC(on_update), 1);
+	rb_define_method(cWindow, "on_draw", RUBY_METHOD_FUNC(on_draw), 1);
+	rb_define_method(cWindow, "on_move", RUBY_METHOD_FUNC(on_move), 1);
+	rb_define_method(cWindow, "on_resize", RUBY_METHOD_FUNC(on_resize), 1);
+	rb_define_method(cWindow, "on_key", RUBY_METHOD_FUNC(on_key), 1);
+	rb_define_method(cWindow, "on_key_down", RUBY_METHOD_FUNC(on_key_down), 1);
+	rb_define_method(cWindow, "on_key_up", RUBY_METHOD_FUNC(on_key_up), 1);
+	rb_define_method(cWindow, "on_pointer", RUBY_METHOD_FUNC(on_pointer), 1);
+	rb_define_method(cWindow, "on_pointer_down", RUBY_METHOD_FUNC(on_pointer_down), 1);
+	rb_define_method(cWindow, "on_pointer_up", RUBY_METHOD_FUNC(on_pointer_up), 1);
+	rb_define_method(cWindow, "on_pointer_move", RUBY_METHOD_FUNC(on_pointer_move), 1);
+	rb_define_method(cWindow, "on_wheel", RUBY_METHOD_FUNC(on_wheel), 1);
+	
 }
+
+
+namespace Reflex
+{
+
+
+	Class
+	window_class ()
+	{
+		return cWindow;
+	}
+
+
+}// Reflex

data/Rakefile

@@ -1,8 +1,9 @@
 # -*- mode: ruby; coding: utf-8 -*-
 
 
-require 'xot/load_path'
-Xot::LoadPath.unshift File.expand_path('../lib', __FILE__)
+%w[../xot ../rucy ../rays .]
+  .map  {|s| File.expand_path "../#{s}/lib", __FILE__}
+  .each {|s| $:.unshift s if !$:.include?(s) && File.directory?(s)}
 
 require 'xot/rake'
 require 'xot/module'
@@ -13,9 +14,9 @@ require 'reflex/module'
 include Xot::Rake
 
 
-MODULE      = Reflex
+MODULES     = [Xot, Rucy, Rays, Reflex].map {|m| m.const_get :Module}
+MODULE      = MODULES.last
 GEMNAME     = 'reflexion'
-INCDIRS     = [Reflex, Rays, Rucy, Xot].map {|m| m.include_dirs}.flatten
 TESTS_ALONE = ['test/test_reflex.rb']
 
 
@@ -24,4 +25,4 @@ task :default => :build
 task :build => :ext
 
 
-[Xot, Rucy, Rays, Reflex].each {|m| m.load_tasks}
+MODULES.each {|m| m.load_tasks :lib, :ext, :test, :doc, :gem}

data/VERSION

@@ -1 +1 @@
-0.1.6
+0.1.7

data/ext/reflex/application.cpp

@@ -10,94 +10,95 @@ 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
-RUBY_DEF_ALLOC(alloc, klass)
+RUCY_DEF_ALLOC(alloc, klass)
 {
-	return value(new RubyApplication, klass);
+	return value(new Reflex::RubyApplication<Reflex::Application>, klass);
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(run)
+RUCY_DEF0(start)
 {
 	CHECK;
-	if (!CALL(run()))
-		system_error("failed to run application.");
+	CALL(start());
 	return self;
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(quit)
+RUCY_DEF0(quit)
 {
 	CHECK;
-	if (!CALL(quit()))
-		system_error("failed to quit application.");
+	CALL(quit());
 	return self;
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(about)
+RUCY_DEF1(set_name, name)
 {
 	CHECK;
-	if (!CALL(about()))
-		system_error("failed to show about application.");
-	return self;
+	THIS->set_name(name.c_str());
+	return name;
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF1(set_name, name)
+RUCY_DEF0(get_name)
 {
 	CHECK;
-	if (!THIS->set_name(name.c_str()))
-		system_error("failed to set name of application.");
-	return name;
+	return value(THIS->name());
+}
+RUCY_END
+
+static
+RUCY_DEF1(on_start, event)
+{
+	CHECK;
+	CALL(on_start(to<Reflex::Event*>(event)));
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(get_name)
+RUCY_DEF1(on_quit, event)
 {
 	CHECK;
-	const char* s = THIS->name();
-	if (!s) system_error("failed to get name of application.");
-	return value(s);
+	CALL(on_quit(to<Reflex::Event*>(event)));
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(instance)
+RUCY_DEF1(on_preference, event)
+{
+	CHECK;
+	CALL(on_preference(to<Reflex::Event*>(event)));
+}
+RUCY_END
+
+static
+RUCY_DEF1(on_about, event)
+{
+	CHECK;
+	CALL(on_about(to<Reflex::Event*>(event)));
+}
+RUCY_END
+
+static
+RUCY_DEF0(instance)
 {
 	return value(Reflex::app());
 }
-RUBY_END
+RUCY_END
 
 
 void
@@ -107,10 +108,27 @@ Init_application ()
 
 	cApplication = mReflex.define_class("Application");
 	cApplication.define_alloc_func(alloc);
-	cApplication.define_method("run", run);
+	cApplication.define_method("start", start);
 	cApplication.define_method("quit", quit);
-	cApplication.define_method("about", about);
 	cApplication.define_method("name=", set_name);
 	cApplication.define_method("name",  get_name);
+	cApplication.define_method("on_start", on_start);
+	cApplication.define_method("on_quit", on_quit);
+	cApplication.define_method("on_preference", on_preference);
+	cApplication.define_method("on_about", on_about);
 	cApplication.define_singleton_method("instance", instance);
 }
+
+
+namespace Reflex
+{
+
+
+	Class
+	application_class ()
+	{
+		return cApplication;
+	}
+
+
+}// Reflex