reflexion 0.1.3 → 0.1.4

data/ext/reflex/view.cpp

@@ -0,0 +1,260 @@
+#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
+RUBY_DEF_ALLOC(alloc, klass)
+{
+	return value(new RubyView, klass);
+}
+RUBY_END
+
+static
+RUBY_DEF0(show)
+{
+	CHECK;
+	if (!CALL(show()))
+		reflex_error("failed to show view.");
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF0(hide)
+{
+	CHECK;
+	if (!CALL(hide()))
+		reflex_error("failed to hide view.");
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF0(redraw)
+{
+	CHECK;
+	if (!THIS->redraw())
+		reflex_error("failed to redraw view.");
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF1(add_child, 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;
+}
+RUBY_END
+
+static
+RUBY_DEF1(remove_child, 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;
+}
+RUBY_END
+
+static
+RUBY_DEFN(find_child)
+{
+	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);
+}
+RUBY_END
+
+static
+RUBY_DEF1(set_name, name)
+{
+	CHECK;
+	if (!THIS->set_name(name.c_str()))
+		reflex_error("failed to set the name of view.");
+	return name;
+}
+RUBY_END
+
+static
+RUBY_DEF0(get_name)
+{
+	CHECK;
+	const char* s = THIS->name();
+	if (!s) reflex_error("failed to get name of view.");
+	return value(s);
+}
+RUBY_END
+
+static
+RUBY_DEF4(set_bounds, x, y, width, 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());
+}
+RUBY_END
+
+static
+RUBY_DEF0(get_bounds)
+{
+	CHECK;
+	return value(THIS->bounds());
+}
+RUBY_END
+
+static
+RUBY_DEF0(hidden)
+{
+	CHECK;
+	return value(THIS->hidden());
+}
+RUBY_END
+
+static
+RUBY_DEF0(parent)
+{
+	CHECK;
+
+	Reflex::View* v = THIS->parent();
+	if (!v) return Qnil;
+
+	return value(v);
+}
+RUBY_END
+
+static
+RUBY_DEF0(window)
+{
+	CHECK;
+
+	Reflex::Window* w = THIS->window();
+	if (!w) return Qnil;
+
+	return value(w);
+}
+RUBY_END
+
+static
+RUBY_DEF1(update, dt)
+{
+	CHECK;
+	CALL(update(to<float>(dt)));
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF2(draw, painter, bounds)
+{
+	CHECK;
+	CALL(draw(to<Rays::Painter*>(painter), *to<Rays::Bounds*>(bounds)));
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF2(moved, dx, dy)
+{
+	CHECK;
+	CALL(moved(to<coord>(dx), to<coord>(dy)));
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF2(resized, dwidth, dheight)
+{
+	CHECK;
+	CALL(resized(to<coord>(dwidth), to<coord>(dheight)));
+	return self;
+}
+RUBY_END
+
+
+void
+Init_view ()
+{
+	Module mReflex = define_module("Reflex");
+
+	cView = mReflex.define_class("View");
+	cView.define_alloc_func(alloc);
+	cView.define_method("show", show);
+	cView.define_method("hide", hide);
+	cView.define_method("redraw", redraw);
+	cView.define_method("add_child", add_child);
+	cView.define_method("remove_child", remove_child);
+	cView.define_method("find_child", find_child);
+	cView.define_method("name=", set_name);
+	cView.define_method("name", get_name);
+	cView.define_private_method("set_bounds", set_bounds);
+	cView.define_private_method("get_bounds", get_bounds);
+	cView.define_method("hidden", hidden);
+	cView.define_method("parent", parent);
+	cView.define_method("window", window);
+	cView.define_method("update", update);
+	cView.define_method("draw", draw);
+	cView.define_method("moved", moved);
+	cView.define_method("resized", resized);
+}

data/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,120 +29,20 @@ 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
 RUBY_DEF_ALLOC(alloc, klass)
 {
-	RubyWindow* win = new RubyWindow;
-	return win->self = new_type<RubyWindow>(klass, win, mark_type<RubyWindow>);
+	return value(new RubyWindow, klass);
 }
 RUBY_END
 
@@ -149,7 +50,7 @@ static
 RUBY_DEF0(close)
 {
 	CHECK;
-	if (!this->Super::close())
+	if (!CALL(close()))
 		system_error("failed to close window.");
 	return self;
 }
@@ -159,7 +60,7 @@ static
 RUBY_DEF0(show)
 {
 	CHECK;
-	if (!this->Super::show())
+	if (!CALL(show()))
 		system_error("failed to show window.");
 	return self;
 }
@@ -169,92 +70,102 @@ static
 RUBY_DEF0(hide)
 {
 	CHECK;
-	if (!this->Super::hide())
+	if (!CALL(hide()))
 		system_error("failed to hide window.");
 	return self;
 }
 RUBY_END
 
 static
-RUBY_DEF0(hidden)
+RUBY_DEF0(redraw)
 {
 	CHECK;
-	return value(this->hidden());
+	if (!THIS->redraw())
+		system_error("failed to redraw window.");
+	return self;
 }
 RUBY_END
 
 static
-RUBY_DEF0(update)
+RUBY_DEF1(set_title, title)
 {
 	CHECK;
-	this->Super::update();
-	return self;
+	if (!THIS->set_title(title.c_str()))
+		system_error("failed to set title of window.");
+	return title;
 }
 RUBY_END
 
 static
-RUBY_DEF0(draw)
+RUBY_DEF0(get_title)
 {
 	CHECK;
-	this->Super::draw();
-	return self;
+	const char* s = THIS->title();
+	if (!s) system_error("failed to get title of window.");
+	return value(s);
 }
 RUBY_END
 
 static
-RUBY_DEF0(redraw)
+RUBY_DEF4(set_bounds, x, y, width, 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());
 }
 RUBY_END
 
 static
-RUBY_DEF0(get_title)
+RUBY_DEF0(get_bounds)
 {
 	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());
 }
 RUBY_END
 
 static
-RUBY_DEF1(set_title, title)
+RUBY_DEF0(hidden)
 {
 	CHECK;
-	if (!this->set_title(title.c_str()))
-		system_error("failed to set title of window.");
-	return title;
+	return value(THIS->hidden());
 }
 RUBY_END
 
 static
-RUBY_DEF0(get_bounds)
+RUBY_DEF0(root)
 {
 	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());
 }
 RUBY_END
 
 static
-RUBY_DEF4(set_bounds, x, y, width, height)
+RUBY_DEF0(painter)
 {
 	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());
+}
+RUBY_END
+
+static
+RUBY_DEF1(update, dt)
+{
+	CHECK;
+	CALL(update(to<float>(dt)));
+	return self;
+}
+RUBY_END
+
+static
+RUBY_DEF0(draw)
+{
+	CHECK;
+	CALL(draw());
+	return self;
 }
 RUBY_END
 
@@ -262,7 +173,7 @@ static
 RUBY_DEF2(moved, x, y)
 {
 	CHECK;
-	this->Super::moved(to<coord>(x), to<coord>(y));
+	CALL(moved(to<coord>(x), to<coord>(y)));
 	return self;
 }
 RUBY_END
@@ -271,7 +182,7 @@ static
 RUBY_DEF2(resized, width, height)
 {
 	CHECK;
-	this->Super::resized(to<coord>(width), to<coord>(height));
+	CALL(resized(to<coord>(width), to<coord>(height)));
 	return self;
 }
 RUBY_END
@@ -282,7 +193,7 @@ RUBY_DEF1(key_down, key)
 	CHECK;
 	Reflex::Key* k = to<Reflex::Key*>(key);
 	if (!k) argument_error();
-	this->Super::key_down(*k);
+	CALL(key_down(*k));
 	return self;
 }
 RUBY_END
@@ -293,7 +204,7 @@ RUBY_DEF1(key_up, key)
 	CHECK;
 	Reflex::Key* k = to<Reflex::Key*>(key);
 	if (!k) argument_error();
-	this->Super::key_up(*k);
+	CALL(key_up(*k));
 	return self;
 }
 RUBY_END
@@ -304,7 +215,7 @@ RUBY_DEF1(points_down, points)
 	CHECK;
 	Reflex::Points* p = to<Reflex::Points*>(points);
 	if (!p) argument_error();
-	this->Super::points_down(*p);
+	CALL(points_down(*p));
 	return self;
 }
 RUBY_END
@@ -315,7 +226,7 @@ RUBY_DEF1(points_up, points)
 	CHECK;
 	Reflex::Points* p = to<Reflex::Points*>(points);
 	if (!p) argument_error();
-	this->Super::points_up(*p);
+	CALL(points_up(*p));
 	return self;
 }
 RUBY_END
@@ -326,7 +237,7 @@ RUBY_DEF1(points_moved, points)
 	CHECK;
 	Reflex::Points* p = to<Reflex::Points*>(points);
 	if (!p) argument_error();
-	this->Super::points_moved(*p);
+	CALL(points_moved(*p));
 	return self;
 }
 RUBY_END
@@ -335,28 +246,28 @@ RUBY_END
 void
 Init_window ()
 {
-	Module m = define_module("Reflex");
-
-	Class c = m.define_class("Window");
-	Reflex::cWindow = c;
-
-	c.define_alloc_func(alloc);
-	c.define_method("close",  close);
-	c.define_method("show",   show);
-	c.define_method("hide",   hide);
-	c.define_method("hidden", hidden);
-	c.define_method("update", update);
-	c.define_method("draw",   draw);
-	c.define_method("redraw", redraw);
-	c.define_method("title",  get_title);
-	c.define_method("title=", set_title);
-	c.define_private_method("get_bounds", get_bounds);
-	c.define_private_method("set_bounds", set_bounds);
-	c.define_method("moved",   moved);
-	c.define_method("resized", resized);
-	c.define_method("key_down", key_down);
-	c.define_method("key_up",   key_up);
-	c.define_method("points_down", points_down);
-	c.define_method("points_up",   points_up);
-	c.define_method("points_moved", points_moved);
+	Module mReflex = define_module("Reflex");
+
+	cWindow = mReflex.define_class("Window");
+	cWindow.define_alloc_func(alloc);
+	cWindow.define_method("close", close);
+	cWindow.define_method("show", show);
+	cWindow.define_method("hide", hide);
+	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_method("hidden", hidden);
+	cWindow.define_method("root", root);
+	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);
 }