reflexion 0.1.3 → 0.1.4

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

@@ -0,0 +1,242 @@
+#include "reflex/ruby/view.h"
+
+
+#include <rucy.h>
+#include <reflex/ruby/window.h>
+#include "defs.h"
+
+
+using namespace Rucy;
+
+using Reflex::coord;
+
+
+static Class cView;
+
+
+namespace Reflex
+{
+
+
+	Class
+	view_class ()
+	{
+		return cView;
+	}
+
+
+}// Reflex
+
+
+typedef Reflex::RubyView<Reflex::View> RubyView;
+
+
+#define THIS      to<Reflex::View*>(self)
+
+#define CHECK     RUCY_CHECK_OBJECT(self, Reflex::View, cView)
+
+#define CALL(fun) RUCY_WRAPPER_CALL(RubyView, THIS, fun)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	return value(new RubyView, klass);
+}
+
+static
+VALUE show(VALUE self)
+{
+	CHECK;
+	if (!CALL(show()))
+		reflex_error("failed to show view.");
+	return self;
+}
+
+static
+VALUE hide(VALUE self)
+{
+	CHECK;
+	if (!CALL(hide()))
+		reflex_error("failed to hide view.");
+	return self;
+}
+
+static
+VALUE redraw(VALUE self)
+{
+	CHECK;
+	if (!THIS->redraw())
+		reflex_error("failed to redraw view.");
+	return self;
+}
+
+static
+VALUE add_child(VALUE self, VALUE child)
+{
+	CHECK;
+
+	Reflex::View* c = to<Reflex::View*>(child);
+	if (!c) argument_error();
+
+	if (!THIS->add_child(c))
+		reflex_error("failed to add child view.");
+
+	return self;
+}
+
+static
+VALUE remove_child(VALUE self, VALUE child)
+{
+	CHECK;
+
+	Reflex::View* c = to<Reflex::View*>(child);
+	if (!c) argument_error();
+
+	if (!THIS->remove_child(c))
+		reflex_error("failed to remove child view.");
+
+	return self;
+}
+
+static
+VALUE find_child(VALUE self)
+{
+	CHECK;
+	if (argc < 1 || 3 < argc)
+		arg_count_error("View#find_child", argc, 1, 2, 3);
+
+	const char* name = to<const char*>(argv[0]);
+	size_t index     = (argc >= 2) ? to<size_t>(argv[1]) : 0;
+	bool recursive   = (argc >= 3) ? to<bool>(argv[2])   : false;
+
+	Reflex::View* c = THIS->find_child(name, index, recursive);
+	if (!c) return Qnil;
+
+	return value(c);
+}
+
+static
+VALUE set_name(VALUE self, VALUE name)
+{
+	CHECK;
+	if (!THIS->set_name(name.c_str()))
+		reflex_error("failed to set the name of view.");
+	return name;
+}
+
+static
+VALUE get_name(VALUE self)
+{
+	CHECK;
+	const char* s = THIS->name();
+	if (!s) reflex_error("failed to get name of view.");
+	return value(s);
+}
+
+static
+VALUE set_bounds(VALUE self, VALUE x, VALUE y, VALUE width, VALUE height)
+{
+	CHECK;
+	if (!THIS->set_bounds(
+		to<coord>(x), to<coord>(y), to<coord>(width), to<coord>(height)))
+	{
+		reflex_error("failed to set the bounds of view.");
+	}
+	return value(THIS->bounds());
+}
+
+static
+VALUE get_bounds(VALUE self)
+{
+	CHECK;
+	return value(THIS->bounds());
+}
+
+static
+VALUE hidden(VALUE self)
+{
+	CHECK;
+	return value(THIS->hidden());
+}
+
+static
+VALUE parent(VALUE self)
+{
+	CHECK;
+
+	Reflex::View* v = THIS->parent();
+	if (!v) return Qnil;
+
+	return value(v);
+}
+
+static
+VALUE window(VALUE self)
+{
+	CHECK;
+
+	Reflex::Window* w = THIS->window();
+	if (!w) return Qnil;
+
+	return value(w);
+}
+
+static
+VALUE update(VALUE self, VALUE dt)
+{
+	CHECK;
+	CALL(update(to<float>(dt)));
+	return self;
+}
+
+static
+VALUE draw(VALUE self, VALUE painter, VALUE bounds)
+{
+	CHECK;
+	CALL(draw(to<Rays::Painter*>(painter), *to<Rays::Bounds*>(bounds)));
+	return self;
+}
+
+static
+VALUE moved(VALUE self, VALUE dx, VALUE dy)
+{
+	CHECK;
+	CALL(moved(to<coord>(dx), to<coord>(dy)));
+	return self;
+}
+
+static
+VALUE resized(VALUE self, VALUE dwidth, VALUE dheight)
+{
+	CHECK;
+	CALL(resized(to<coord>(dwidth), to<coord>(dheight)));
+	return self;
+}
+
+
+void
+Init_view ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cView = rb_define_class_under(mReflex, "View", rb_cObject);
+	rb_define_alloc_func(cView, alloc);
+	rb_define_method(cView, "show", RUBY_METHOD_FUNC(show), 0);
+	rb_define_method(cView, "hide", RUBY_METHOD_FUNC(hide), 0);
+	rb_define_method(cView, "redraw", RUBY_METHOD_FUNC(redraw), 0);
+	rb_define_method(cView, "add_child", RUBY_METHOD_FUNC(add_child), 1);
+	rb_define_method(cView, "remove_child", RUBY_METHOD_FUNC(remove_child), 1);
+	rb_define_method(cView, "find_child", RUBY_METHOD_FUNC(find_child), -1);
+	rb_define_method(cView, "name=", RUBY_METHOD_FUNC(set_name), 1);
+	rb_define_method(cView, "name", RUBY_METHOD_FUNC(get_name), 0);
+	rb_define_private_method(cView, "set_bounds", RUBY_METHOD_FUNC(set_bounds), 4);
+	rb_define_private_method(cView, "get_bounds", RUBY_METHOD_FUNC(get_bounds), 0);
+	rb_define_method(cView, "hidden", RUBY_METHOD_FUNC(hidden), 0);
+	rb_define_method(cView, "parent", RUBY_METHOD_FUNC(parent), 0);
+	rb_define_method(cView, "window", RUBY_METHOD_FUNC(window), 0);
+	rb_define_method(cView, "update", RUBY_METHOD_FUNC(update), 1);
+	rb_define_method(cView, "draw", RUBY_METHOD_FUNC(draw), 2);
+	rb_define_method(cView, "moved", RUBY_METHOD_FUNC(moved), 2);
+	rb_define_method(cView, "resized", RUBY_METHOD_FUNC(resized), 2);
+}

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

@@ -2,8 +2,8 @@
 
 
 #include <rucy.h>
-#include <reflex/ruby/key.h>
-#include <reflex/ruby/points.h>
+#include <rays/ruby/painter.h>
+#include <reflex/ruby/view.h>
 #include "defs.h"
 
 
@@ -12,12 +12,13 @@ using namespace Rucy;
 using Reflex::coord;
 
 
+static Class cWindow;
+
+
 namespace Reflex
 {
 
 
-	static Class cWindow;
-
 	Class
 	window_class ()
 	{
@@ -28,127 +29,27 @@ namespace Reflex
 }// Reflex
 
 
-namespace Rucy
-{
-
-
-	Value
-	value (const Reflex::Window& window)
-	{
-		return new_type<Reflex::Window>(
-			Reflex::window_class(), new Reflex::Window(window));
-	}
-
+typedef Reflex::RubyWindow<Reflex::Window> RubyWindow;
 
-}// Rucy
 
+#define THIS      to<Reflex::Window*>(self)
 
-class RubyWindow : public Reflex::Window
-{
+#define CHECK     RUCY_CHECK_OBJECT(self, Reflex::Window, cWindow)
 
-	public:
-
-		typedef Reflex::Window Super;
-
-		Value self;
-
-		void mark ()
-		{
-			self.mark();
-		}
-
-		virtual bool close ()
-		{
-			SYM(close);
-			return self.call(close);
-		}
-
-		virtual bool show ()
-		{
-			SYM(show);
-			return self.call(show);
-		}
-
-		virtual bool hide ()
-		{
-			SYM(hide);
-			return self.call(hide);
-		}
-
-		virtual void update ()
-		{
-			SYM(update);
-			self.call(update);
-		}
-
-		virtual void draw ()
-		{
-			SYM(draw);
-			self.call(draw);
-		}
-
-		virtual void moved (coord x, coord y)
-		{
-			SYM(moved);
-			self.call(moved, x, y);
-		}
-
-		virtual void resized (coord width, coord height)
-		{
-			SYM(resized);
-			self.call(resized, width, height);
-		}
-
-		virtual void key_down (const Reflex::Key& key)
-		{
-			SYM(key_down);
-			self.call(key_down, value(key));
-		}
-
-		virtual void key_up (const Reflex::Key& key)
-		{
-			SYM(key_up);
-			self.call(key_up, value(key));
-		}
-
-		virtual void points_down (const Reflex::Points& points)
-		{
-			SYM(points_down);
-			self.call(points_down, value(points));
-		}
-
-		virtual void points_up (const Reflex::Points& points)
-		{
-			SYM(points_up);
-			self.call(points_up, value(points));
-		}
-
-		virtual void points_moved (const Reflex::Points& points)
-		{
-			SYM(points_moved);
-			self.call(points_moved, value(points));
-		}
-
-};// RubyWindow
-
-
-#define this ((RubyWindow*) to<Reflex::Window*>(self))
-
-#define CHECK CHECK_OBJECT(self, RubyWindow, Reflex::window_class())
+#define CALL(fun) RUCY_WRAPPER_CALL(RubyWindow, THIS, fun)
 
 
 static
 VALUE alloc(VALUE klass)
 {
-	RubyWindow* win = new RubyWindow;
-	return win->self = new_type<RubyWindow>(klass, win, mark_type<RubyWindow>);
+	return value(new RubyWindow, klass);
 }
 
 static
 VALUE close(VALUE self)
 {
 	CHECK;
-	if (!this->Super::close())
+	if (!CALL(close()))
 		system_error("failed to close window.");
 	return self;
 }
@@ -157,7 +58,7 @@ static
 VALUE show(VALUE self)
 {
 	CHECK;
-	if (!this->Super::show())
+	if (!CALL(show()))
 		system_error("failed to show window.");
 	return self;
 }
@@ -166,91 +67,99 @@ static
 VALUE hide(VALUE self)
 {
 	CHECK;
-	if (!this->Super::hide())
+	if (!CALL(hide()))
 		system_error("failed to hide window.");
 	return self;
 }
 
 static
-VALUE hidden(VALUE self)
+VALUE redraw(VALUE self)
 {
 	CHECK;
-	return value(this->hidden());
+	if (!THIS->redraw())
+		system_error("failed to redraw window.");
+	return self;
 }
 
 static
-VALUE update(VALUE self)
+VALUE set_title(VALUE self, VALUE title)
 {
 	CHECK;
-	this->Super::update();
-	return self;
+	if (!THIS->set_title(title.c_str()))
+		system_error("failed to set title of window.");
+	return title;
 }
 
 static
-VALUE draw(VALUE self)
+VALUE get_title(VALUE self)
 {
 	CHECK;
-	this->Super::draw();
-	return self;
+	const char* s = THIS->title();
+	if (!s) system_error("failed to get title of window.");
+	return value(s);
 }
 
 static
-VALUE redraw(VALUE self)
+VALUE set_bounds(VALUE self, VALUE x, VALUE y, VALUE width, VALUE height)
 {
 	CHECK;
-	if (!this->Super::redraw())
-		system_error("failed to redraw window.");
-	return self;
+	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());
 }
 
 static
-VALUE get_title(VALUE self)
+VALUE get_bounds(VALUE self)
 {
 	CHECK;
-	String s;
-	if (!this->get_title(&s))
-		system_error("failed to get title of window.");
-	return value(s.c_str());
+	return value(THIS->bounds());
 }
 
 static
-VALUE set_title(VALUE self, VALUE title)
+VALUE hidden(VALUE self)
 {
 	CHECK;
-	if (!this->set_title(title.c_str()))
-		system_error("failed to set title of window.");
-	return title;
+	return value(THIS->hidden());
 }
 
 static
-VALUE get_bounds(VALUE self)
+VALUE root(VALUE self)
 {
 	CHECK;
-	coord x = 0, y = 0, width = 0, height = 0;
-	if (!this->get_bounds(&x, &y, &width, &height))
-		system_error("failed to get bounds of window.");
-	Value ret[] = {x, y, width, height};
-	return value(4, ret);
+	return value(THIS->root());
 }
 
 static
-VALUE set_bounds(VALUE self, VALUE x, VALUE y, VALUE width, VALUE height)
+VALUE painter(VALUE self)
 {
 	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.");
-	}
-	Value ret[] = {x, y, width, height};
-	return value(4, ret);
+	return value(THIS->painter());
+}
+
+static
+VALUE update(VALUE self, VALUE dt)
+{
+	CHECK;
+	CALL(update(to<float>(dt)));
+	return self;
+}
+
+static
+VALUE draw(VALUE self)
+{
+	CHECK;
+	CALL(draw());
+	return self;
 }
 
 static
 VALUE moved(VALUE self, VALUE x, VALUE y)
 {
 	CHECK;
-	this->Super::moved(to<coord>(x), to<coord>(y));
+	CALL(moved(to<coord>(x), to<coord>(y)));
 	return self;
 }
 
@@ -258,7 +167,7 @@ static
 VALUE resized(VALUE self, VALUE width, VALUE height)
 {
 	CHECK;
-	this->Super::resized(to<coord>(width), to<coord>(height));
+	CALL(resized(to<coord>(width), to<coord>(height)));
 	return self;
 }
 
@@ -268,7 +177,7 @@ VALUE key_down(VALUE self, VALUE key)
 	CHECK;
 	Reflex::Key* k = to<Reflex::Key*>(key);
 	if (!k) argument_error();
-	this->Super::key_down(*k);
+	CALL(key_down(*k));
 	return self;
 }
 
@@ -278,7 +187,7 @@ VALUE key_up(VALUE self, VALUE key)
 	CHECK;
 	Reflex::Key* k = to<Reflex::Key*>(key);
 	if (!k) argument_error();
-	this->Super::key_up(*k);
+	CALL(key_up(*k));
 	return self;
 }
 
@@ -288,7 +197,7 @@ VALUE points_down(VALUE self, VALUE points)
 	CHECK;
 	Reflex::Points* p = to<Reflex::Points*>(points);
 	if (!p) argument_error();
-	this->Super::points_down(*p);
+	CALL(points_down(*p));
 	return self;
 }
 
@@ -298,7 +207,7 @@ VALUE points_up(VALUE self, VALUE points)
 	CHECK;
 	Reflex::Points* p = to<Reflex::Points*>(points);
 	if (!p) argument_error();
-	this->Super::points_up(*p);
+	CALL(points_up(*p));
 	return self;
 }
 
@@ -308,7 +217,7 @@ VALUE points_moved(VALUE self, VALUE points)
 	CHECK;
 	Reflex::Points* p = to<Reflex::Points*>(points);
 	if (!p) argument_error();
-	this->Super::points_moved(*p);
+	CALL(points_moved(*p));
 	return self;
 }
 
@@ -316,28 +225,28 @@ VALUE points_moved(VALUE self, VALUE points)
 void
 Init_window ()
 {
-	Module m = rb_define_module("Reflex");
-
-	Class c = rb_define_class_under(m, "Window", rb_cObject);
-	Reflex::cWindow = c;
-
-	rb_define_alloc_func(c, alloc);
-	rb_define_method(c, "close", RUBY_METHOD_FUNC(close), 0);
-	rb_define_method(c, "show", RUBY_METHOD_FUNC(show), 0);
-	rb_define_method(c, "hide", RUBY_METHOD_FUNC(hide), 0);
-	rb_define_method(c, "hidden", RUBY_METHOD_FUNC(hidden), 0);
-	rb_define_method(c, "update", RUBY_METHOD_FUNC(update), 0);
-	rb_define_method(c, "draw", RUBY_METHOD_FUNC(draw), 0);
-	rb_define_method(c, "redraw", RUBY_METHOD_FUNC(redraw), 0);
-	rb_define_method(c, "title", RUBY_METHOD_FUNC(get_title), 0);
-	rb_define_method(c, "title=", RUBY_METHOD_FUNC(set_title), 1);
-	rb_define_private_method(c, "get_bounds", RUBY_METHOD_FUNC(get_bounds), 0);
-	rb_define_private_method(c, "set_bounds", RUBY_METHOD_FUNC(set_bounds), 4);
-	rb_define_method(c, "moved", RUBY_METHOD_FUNC(moved), 2);
-	rb_define_method(c, "resized", RUBY_METHOD_FUNC(resized), 2);
-	rb_define_method(c, "key_down", RUBY_METHOD_FUNC(key_down), 1);
-	rb_define_method(c, "key_up", RUBY_METHOD_FUNC(key_up), 1);
-	rb_define_method(c, "points_down", RUBY_METHOD_FUNC(points_down), 1);
-	rb_define_method(c, "points_up", RUBY_METHOD_FUNC(points_up), 1);
-	rb_define_method(c, "points_moved", RUBY_METHOD_FUNC(points_moved), 1);
+	Module mReflex = rb_define_module("Reflex");
+
+	cWindow = rb_define_class_under(mReflex, "Window", rb_cObject);
+	rb_define_alloc_func(cWindow, alloc);
+	rb_define_method(cWindow, "close", RUBY_METHOD_FUNC(close), 0);
+	rb_define_method(cWindow, "show", RUBY_METHOD_FUNC(show), 0);
+	rb_define_method(cWindow, "hide", RUBY_METHOD_FUNC(hide), 0);
+	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_method(cWindow, "hidden", RUBY_METHOD_FUNC(hidden), 0);
+	rb_define_method(cWindow, "root", RUBY_METHOD_FUNC(root), 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);
 }

data/.gitignore

@@ -0,0 +1,14 @@
+*.o
+*.so
+*.bundle
+*.dll.a
+*.gem
+*.log
+*.rdoc.cpp
+*~
+lib/*.a
+.doc
+.yardoc
+.DS_Store
+Makefile
+depend.mf