reflexion 0.1.6 → 0.1.7

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

@@ -1,9 +1,13 @@
 #include "reflex/ruby/view.h"
 
 
+#include <vector>
 #include <rucy.h>
-#include <reflex/ruby/window.h>
-#include "defs.h"
+#include <rays/ruby/point.h>
+#include <rays/ruby/bounds.h>
+#include "reflex/ruby/window.h"
+#include "reflex/ruby/selector.h"
+#include "reflex/ruby/style.h"
 
 
 using namespace Rucy;
@@ -13,43 +17,36 @@ using Reflex::coord;
 
 static Class cView;
 
+RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(Reflex::View, cView)
 
-namespace Reflex
-{
-
-
-	Class
-	view_class ()
-	{
-		return cView;
-	}
-
-
-}// Reflex
-
+#define THIS      to<Reflex::View*>(self)
 
-typedef Reflex::RubyView<Reflex::View> RubyView;
+#define CHECK     RUCY_CHECK_OBJECT(Reflex::View, cView, self)
 
+#define CALL(fun) RUCY_WRAPPER_CALL(Reflex::View, THIS, fun)
 
-#define THIS      to<Reflex::View*>(self)
 
-#define CHECK     RUCY_CHECK_OBJECT(self, Reflex::View, cView)
-
-#define CALL(fun) RUCY_WRAPPER_CALL(RubyView, THIS, fun)
+template <typename T>
+static inline Value
+array (T begin, T end)
+{
+	std::vector<Value> v;
+	for (T it = begin; it != end; ++it) v.push_back(value(*it));
+	return value(v.size(), &v[0]);
+}
 
 
 static
 VALUE alloc(VALUE klass)
 {
-	return value(new RubyView, klass);
+	return value(new Reflex::RubyView<Reflex::View>, klass);
 }
 
 static
 VALUE show(VALUE self)
 {
 	CHECK;
-	if (!CALL(show()))
-		reflex_error("failed to show view.");
+	CALL(show());
 	return self;
 }
 
@@ -57,17 +54,22 @@ static
 VALUE hide(VALUE self)
 {
 	CHECK;
-	if (!CALL(hide()))
-		reflex_error("failed to hide view.");
+	CALL(hide());
 	return self;
 }
 
+static
+VALUE hidden(VALUE self)
+{
+	CHECK;
+	return value(THIS->hidden());
+}
+
 static
 VALUE redraw(VALUE self)
 {
 	CHECK;
-	if (!THIS->redraw())
-		reflex_error("failed to redraw view.");
+	THIS->redraw();
 	return self;
 }
 
@@ -75,145 +77,409 @@ static
 VALUE add_child(VALUE self, VALUE child)
 {
 	CHECK;
+	THIS->add_child(to<Reflex::View*>(child));
+	return child;
+}
+
+static
+VALUE remove_child(VALUE self, VALUE child)
+{
+	CHECK;
+	THIS->remove_child(to<Reflex::View*>(child));
+	return child;
+}
 
-	Reflex::View* c = to<Reflex::View*>(child);
-	if (!c) argument_error();
+static
+VALUE find_children(VALUE self)
+{
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "View#find_children", argc, 1, 2);
 
-	if (!THIS->add_child(c))
-		reflex_error("failed to add child view.");
+	bool recursive = (argc >= 2) ? to<bool>(argv[1]) : false;
 
-	return self;
+	Reflex::View::ChildList children;
+	THIS->find_children(&children, to<Reflex::Selector>(argv[0]), recursive);
+	return array(children.begin(), children.end());
 }
 
 static
-VALUE remove_child(VALUE self, VALUE child)
+VALUE each_child(VALUE self)
 {
 	CHECK;
 
-	Reflex::View* c = to<Reflex::View*>(child);
-	if (!c) argument_error();
+	Value ret;
+	Reflex::View::child_iterator end = THIS->child_end();
+	for (Reflex::View::child_iterator it = THIS->child_begin(); it != end; ++it)
+		ret = rb_yield(value(it->get()));
+	return ret;
+}
+
+static
+VALUE add_style(VALUE self, VALUE style)
+{
+	CHECK;
+	THIS->add_style(to<Reflex::Style&>(style));
+	return style;
+}
+
+static
+VALUE remove_style(VALUE self, VALUE style)
+{
+	CHECK;
+	THIS->remove_style(to<Reflex::Style&>(style));
+	return style;
+}
+
+static
+VALUE get_style(VALUE self)
+{
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "View#get_style", argc, 0, 1);
+
+	if (argc == 0)
+		return value(THIS->style());
+	else
+		return value(THIS->get_style(to<Reflex::Selector>(argv[0])));
+}
+
+static
+VALUE find_styles(VALUE self)
+{
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "View#find_styles", argc, 1, 2);
 
-	if (!THIS->remove_child(c))
-		reflex_error("failed to remove child view.");
+	bool recursive = (argc >= 2) ? to<bool>(argv[1]) : false;
 
+	Reflex::View::StyleList styles;
+	THIS->find_styles(&styles, to<Reflex::Selector>(argv[0]), recursive);
+	return array(styles.begin(), styles.end());
+}
+
+static
+VALUE each_style(VALUE self)
+{
+	CHECK;
+
+	Value ret;
+	Reflex::View::style_iterator end = THIS->style_end();
+	for (Reflex::View::style_iterator it = THIS->style_begin(); it != end; ++it)
+		ret = rb_yield(value(*it));
+	return ret;
+}
+
+static
+VALUE focus(VALUE self)
+{
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "View#focus", argc, 0, 1);
+
+	bool state = (argc >= 1) ? to<bool>(argv[0]) : true;
+
+	THIS->focus(state);
 	return self;
 }
 
 static
-VALUE find_child(VALUE self)
+VALUE blur(VALUE self)
 {
 	CHECK;
-	if (argc < 1 || 3 < argc)
-		arg_count_error("View#find_child", argc, 1, 2, 3);
+	THIS->blur();
+	return self;
+}
 
-	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;
+static
+VALUE has_focus(VALUE self)
+{
+	CHECK;
+	return value(THIS->has_focus());
+}
 
-	Reflex::View* c = THIS->find_child(name, index, recursive);
-	if (!c) return Qnil;
+static
+VALUE resize_to_fit(VALUE self)
+{
+	CHECK;
+	THIS->resize_to_fit();
+	return self;
+}
 
-	return value(c);
+static
+VALUE content_size(VALUE self)
+{
+	CHECK;
+	return value(THIS->content_size());
 }
 
 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;
+	THIS->set_name(name.is_nil() ? NULL : name.c_str());
 }
 
 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);
+	return THIS->name() ? value(THIS->name()) : nil();
 }
 
 static
-VALUE set_bounds(VALUE self, VALUE x, VALUE y, VALUE width, VALUE height)
+VALUE add_tag(VALUE self, VALUE tag)
 {
 	CHECK;
-	if (!THIS->set_bounds(
-		to<coord>(x), to<coord>(y), to<coord>(width), to<coord>(height)))
+	THIS->add_tag(tag.c_str());
+}
+
+static
+VALUE remove_tag(VALUE self, VALUE tag)
+{
+	CHECK;
+	THIS->remove_tag(tag.c_str());
+}
+
+static
+VALUE each_tag(VALUE self)
+{
+	CHECK;
+
+	Value ret;
+	Reflex::View::tag_iterator end = THIS->tag_end();
+	for (Reflex::View::tag_iterator it = THIS->tag_begin(); it != end; ++it)
+		ret = rb_yield(value(*it));
+	return ret;
+}
+
+static
+VALUE set_selector(VALUE self, VALUE selector)
+{
+	CHECK;
+	THIS->set_selector(to<Reflex::Selector>(selector));
+}
+
+static
+VALUE get_selector(VALUE self)
+{
+	CHECK;
+	return value(THIS->selector());
+}
+
+static
+VALUE set_frame(VALUE self, VALUE arg)
+{
+	CHECK;
+	THIS->set_frame(to<Rays::Bounds>(arg));
+}
+
+static
+VALUE get_frame(VALUE self)
+{
+	CHECK;
+	return value(THIS->frame());
+}
+
+static
+VALUE set_capture(VALUE self, VALUE types)
+{
+	CHECK;
+	THIS->set_capture(to<uint>(types));
+}
+
+static
+VALUE get_capture(VALUE self)
+{
+	CHECK;
+	return value(THIS->capture());
+}
+
+static
+VALUE scroll_to(VALUE self)
+{
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "View#scroll_to", argc, 1, 2, 3);
+
+	if (argv[0].is_kind_of(Rays::point_class()))
+		THIS->scroll_to(to<Rays::Point&>(argv[0]));
+	else
 	{
-		reflex_error("failed to set the bounds of view.");
+		const Rays::Point& p = THIS->scroll();
+		coord x = (argc >= 1 && argv[0]) ? to<coord>(argv[0]) : p.x;
+		coord y = (argc >= 2 && argv[1]) ? to<coord>(argv[1]) : p.y;
+		coord z = (argc >= 3 && argv[2]) ? to<coord>(argv[2]) : p.z;
+		THIS->scroll_to(x, y, z);
 	}
-	return value(THIS->bounds());
+
+	return self;
 }
 
 static
-VALUE get_bounds(VALUE self)
+VALUE scroll_by(VALUE self)
 {
 	CHECK;
-	return value(THIS->bounds());
+	check_arg_count(__FILE__, __LINE__, "View#scroll_by", argc, 1, 2, 3);
+
+	if (argv[0].is_kind_of(Rays::point_class()))
+		THIS->scroll_by(to<Rays::Point&>(argv[0]));
+	else
+	{
+		coord x = (argc >= 1 && argv[0]) ? to<coord>(argv[0]) : 0;
+		coord y = (argc >= 2 && argv[1]) ? to<coord>(argv[1]) : 0;
+		coord z = (argc >= 3 && argv[2]) ? to<coord>(argv[2]) : 0;
+		THIS->scroll_by(x, y, z);
+	}
+
+	return self;
 }
 
 static
-VALUE hidden(VALUE self)
+VALUE get_scroll(VALUE self)
 {
 	CHECK;
-	return value(THIS->hidden());
+	return value(THIS->scroll());
 }
 
 static
 VALUE parent(VALUE self)
 {
 	CHECK;
+	return value(THIS->parent());
+}
 
-	Reflex::View* v = THIS->parent();
-	if (!v) return Qnil;
+static
+VALUE window(VALUE self)
+{
+	CHECK;
+	return value(THIS->window());
+}
 
-	return value(v);
+static
+VALUE on_attach(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_attach(to<Reflex::Event*>(event)));
 }
 
 static
-VALUE window(VALUE self)
+VALUE on_detach(VALUE self, VALUE event)
 {
 	CHECK;
+	CALL(on_detach(to<Reflex::Event*>(event)));
+}
 
-	Reflex::Window* w = THIS->window();
-	if (!w) return Qnil;
+static
+VALUE on_update(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_update(to<Reflex::UpdateEvent*>(event)));
+}
+
+static
+VALUE on_draw(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_draw(to<Reflex::DrawEvent*>(event)));
+}
 
-	return value(w);
+static
+VALUE on_move(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_move(to<Reflex::FrameEvent*>(event)));
 }
 
 static
-VALUE update(VALUE self, VALUE dt)
+VALUE on_resize(VALUE self, VALUE event)
 {
 	CHECK;
-	CALL(update(to<float>(dt)));
-	return self;
+	CALL(on_resize(to<Reflex::FrameEvent*>(event)));
 }
 
 static
-VALUE draw(VALUE self, VALUE painter, VALUE bounds)
+VALUE on_scroll(VALUE self, VALUE event)
 {
 	CHECK;
-	CALL(draw(to<Rays::Painter*>(painter), *to<Rays::Bounds*>(bounds)));
-	return self;
+	CALL(on_scroll(to<Reflex::ScrollEvent*>(event)));
 }
 
 static
-VALUE moved(VALUE self, VALUE dx, VALUE dy)
+VALUE on_focus(VALUE self, VALUE event)
 {
 	CHECK;
-	CALL(moved(to<coord>(dx), to<coord>(dy)));
-	return self;
+	CALL(on_focus(to<Reflex::FocusEvent*>(event)));
 }
 
 static
-VALUE resized(VALUE self, VALUE dwidth, VALUE dheight)
+VALUE on_blur(VALUE self, VALUE event)
 {
 	CHECK;
-	CALL(resized(to<coord>(dwidth), to<coord>(dheight)));
-	return self;
+	CALL(on_blur(to<Reflex::FocusEvent*>(event)));
+}
+
+static
+VALUE on_key(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_key(to<Reflex::KeyEvent*>(event)));
+}
+
+static
+VALUE on_key_down(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_key_down(to<Reflex::KeyEvent*>(event)));
 }
 
+static
+VALUE on_key_up(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_key_up(to<Reflex::KeyEvent*>(event)));
+}
+
+static
+VALUE on_pointer(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_pointer(to<Reflex::PointerEvent*>(event)));
+}
+
+static
+VALUE on_pointer_down(VALUE self, VALUE event)
+{
+	CHECK;
+	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
+VALUE on_capture(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_capture(to<Reflex::CaptureEvent*>(event)));
+}
+
+static
+RUCY_DEF_clear_override_flags(cof, Reflex::View, cView);
+
 
 void
 Init_view ()
@@ -224,19 +490,73 @@ Init_view ()
 	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);
+	cView.define_method("hidden?", hidden);
 	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, "find_children", RUBY_METHOD_FUNC(find_children), -1);
+	rb_define_method(cView, "each_child", RUBY_METHOD_FUNC(each_child), 0);
+	rb_define_method(cView, "add_style", RUBY_METHOD_FUNC(add_style), 1);
+	rb_define_method(cView, "remove_style", RUBY_METHOD_FUNC(remove_style), 1);
+	rb_define_method(cView, "get_style", RUBY_METHOD_FUNC(get_style), -1);
+	rb_define_method(cView, "find_styles", RUBY_METHOD_FUNC(find_styles), -1);
+	rb_define_method(cView, "each_style", RUBY_METHOD_FUNC(each_style), 0);
+	rb_define_method(cView, "focus", RUBY_METHOD_FUNC(focus), -1);
+	rb_define_method(cView, "blur", RUBY_METHOD_FUNC(blur), 0);
+	cView.define_method("focus?", has_focus);
+	rb_define_method(cView, "resize_to_fit", RUBY_METHOD_FUNC(resize_to_fit), 0);
+	rb_define_method(cView, "content_size", RUBY_METHOD_FUNC(content_size), 0);
 	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, "add_tag", RUBY_METHOD_FUNC(add_tag), 1);
+	rb_define_method(cView, "remove_tag", RUBY_METHOD_FUNC(remove_tag), 1);
+	rb_define_method(cView, "each_tag", RUBY_METHOD_FUNC(each_tag), 0);
+	rb_define_method(cView, "selector=", RUBY_METHOD_FUNC(set_selector), 1);
+	rb_define_method(cView, "selector", RUBY_METHOD_FUNC(get_selector), 0);
+	rb_define_private_method(cView, "set_frame", RUBY_METHOD_FUNC(set_frame), 1);
+	rb_define_private_method(cView, "get_frame", RUBY_METHOD_FUNC(get_frame), 0);
+	rb_define_method(cView, "scroll_to", RUBY_METHOD_FUNC(scroll_to), -1);
+	rb_define_method(cView, "scroll_by", RUBY_METHOD_FUNC(scroll_by), -1);
+	rb_define_method(cView, "scroll", RUBY_METHOD_FUNC(get_scroll), 0);
+	rb_define_method(cView, "set_capture", RUBY_METHOD_FUNC(set_capture), 1);
+	rb_define_method(cView, "get_capture", RUBY_METHOD_FUNC(get_capture), 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);
+	rb_define_method(cView, "on_attach", RUBY_METHOD_FUNC(on_attach), 1);
+	rb_define_method(cView, "on_detach", RUBY_METHOD_FUNC(on_detach), 1);
+	rb_define_method(cView, "on_update", RUBY_METHOD_FUNC(on_update), 1);
+	rb_define_method(cView, "on_draw", RUBY_METHOD_FUNC(on_draw), 1);
+	rb_define_method(cView, "on_move", RUBY_METHOD_FUNC(on_move), 1);
+	rb_define_method(cView, "on_resize", RUBY_METHOD_FUNC(on_resize), 1);
+	rb_define_method(cView, "on_scroll", RUBY_METHOD_FUNC(on_scroll), 1);
+	rb_define_method(cView, "on_focus", RUBY_METHOD_FUNC(on_focus), 1);
+	rb_define_method(cView, "on_blur", RUBY_METHOD_FUNC(on_blur), 1);
+	rb_define_method(cView, "on_key", RUBY_METHOD_FUNC(on_key), 1);
+	rb_define_method(cView, "on_key_down", RUBY_METHOD_FUNC(on_key_down), 1);
+	rb_define_method(cView, "on_key_up", RUBY_METHOD_FUNC(on_key_up), 1);
+	rb_define_method(cView, "on_pointer", RUBY_METHOD_FUNC(on_pointer), 1);
+	rb_define_method(cView, "on_pointer_down", RUBY_METHOD_FUNC(on_pointer_down), 1);
+	rb_define_method(cView, "on_pointer_up", RUBY_METHOD_FUNC(on_pointer_up), 1);
+	rb_define_method(cView, "on_pointer_move", RUBY_METHOD_FUNC(on_pointer_move), 1);
+	rb_define_method(cView, "on_wheel", RUBY_METHOD_FUNC(on_wheel), 1);
+	rb_define_method(cView, "on_capture", RUBY_METHOD_FUNC(on_capture), 1);
+	cView.define_const("CAPTURE_NONE",      Reflex::View::CAPTURE_NONE);
+	cView.define_const("CAPTURE_KEY",       Reflex::View::CAPTURE_KEY);
+	cView.define_const("CAPTURE_POINTER",   Reflex::View::CAPTURE_POINTER);
+	cView.define_const("CAPTURE_ALL",       Reflex::View::CAPTURE_ALL);
+	
 }
+
+
+namespace Reflex
+{
+
+
+	Class
+	view_class ()
+	{
+		return cView;
+	}
+
+
+}// Reflex