reflexion 0.1.6 → 0.1.7

data/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,224 +17,521 @@ using Reflex::coord;
 
 static Class cView;
 
+RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(Reflex::View, cView)
 
-namespace Reflex
+#define THIS      to<Reflex::View*>(self)
+
+#define CHECK     RUCY_CHECK_OBJECT(Reflex::View, cView, self)
+
+#define CALL(fun) RUCY_WRAPPER_CALL(Reflex::View, 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]);
+}
 
 
-	Class
-	view_class ()
-	{
-		return cView;
-	}
+static
+RUCY_DEF_ALLOC(alloc, klass)
+{
+	return value(new Reflex::RubyView<Reflex::View>, klass);
+}
+RUCY_END
 
+static
+RUCY_DEF0(show)
+{
+	CHECK;
+	CALL(show());
+	return self;
+}
+RUCY_END
 
-}// Reflex
+static
+RUCY_DEF0(hide)
+{
+	CHECK;
+	CALL(hide());
+	return self;
+}
+RUCY_END
 
+static
+RUCY_DEF0(hidden)
+{
+	CHECK;
+	return value(THIS->hidden());
+}
+RUCY_END
+
+static
+RUCY_DEF0(redraw)
+{
+	CHECK;
+	THIS->redraw();
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF1(add_child, child)
+{
+	CHECK;
+	THIS->add_child(to<Reflex::View*>(child));
+	return child;
+}
+RUCY_END
 
-typedef Reflex::RubyView<Reflex::View> RubyView;
+static
+RUCY_DEF1(remove_child, child)
+{
+	CHECK;
+	THIS->remove_child(to<Reflex::View*>(child));
+	return child;
+}
+RUCY_END
 
+static
+RUCY_DEFN(find_children)
+{
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "View#find_children", argc, 1, 2);
 
-#define THIS      to<Reflex::View*>(self)
+	bool recursive = (argc >= 2) ? to<bool>(argv[1]) : false;
+
+	Reflex::View::ChildList children;
+	THIS->find_children(&children, to<Reflex::Selector>(argv[0]), recursive);
+	return array(children.begin(), children.end());
+}
+RUCY_END
+
+static
+RUCY_DEF0(each_child)
+{
+	CHECK;
 
-#define CHECK     RUCY_CHECK_OBJECT(self, Reflex::View, cView)
+	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;
+}
+RUCY_END
 
-#define CALL(fun) RUCY_WRAPPER_CALL(RubyView, THIS, fun)
+static
+RUCY_DEF1(add_style, style)
+{
+	CHECK;
+	THIS->add_style(to<Reflex::Style&>(style));
+	return style;
+}
+RUCY_END
 
+static
+RUCY_DEF1(remove_style, style)
+{
+	CHECK;
+	THIS->remove_style(to<Reflex::Style&>(style));
+	return style;
+}
+RUCY_END
 
 static
-RUBY_DEF_ALLOC(alloc, klass)
+RUCY_DEFN(get_style)
 {
-	return value(new RubyView, klass);
+	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])));
+}
+RUCY_END
+
+static
+RUCY_DEFN(find_styles)
+{
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "View#find_styles", argc, 1, 2);
+
+	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());
+}
+RUCY_END
+
+static
+RUCY_DEF0(each_style)
+{
+	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;
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(show)
+RUCY_DEFN(focus)
 {
 	CHECK;
-	if (!CALL(show()))
-		reflex_error("failed to show view.");
+	check_arg_count(__FILE__, __LINE__, "View#focus", argc, 0, 1);
+
+	bool state = (argc >= 1) ? to<bool>(argv[0]) : true;
+
+	THIS->focus(state);
 	return self;
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(hide)
+RUCY_DEF0(blur)
 {
 	CHECK;
-	if (!CALL(hide()))
-		reflex_error("failed to hide view.");
+	THIS->blur();
 	return self;
 }
-RUBY_END
+RUCY_END
+
+static
+RUCY_DEF0(has_focus)
+{
+	CHECK;
+	return value(THIS->has_focus());
+}
+RUCY_END
 
 static
-RUBY_DEF0(redraw)
+RUCY_DEF0(resize_to_fit)
 {
 	CHECK;
-	if (!THIS->redraw())
-		reflex_error("failed to redraw view.");
+	THIS->resize_to_fit();
 	return self;
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF1(add_child, child)
+RUCY_DEF0(content_size)
 {
 	CHECK;
+	return value(THIS->content_size());
+}
+RUCY_END
 
-	Reflex::View* c = to<Reflex::View*>(child);
-	if (!c) argument_error();
+static
+RUCY_DEF1(set_name, name)
+{
+	CHECK;
+	THIS->set_name(name.is_nil() ? NULL : name.c_str());
+}
+RUCY_END
 
-	if (!THIS->add_child(c))
-		reflex_error("failed to add child view.");
+static
+RUCY_DEF0(get_name)
+{
+	CHECK;
+	return THIS->name() ? value(THIS->name()) : nil();
+}
+RUCY_END
 
-	return self;
+static
+RUCY_DEF1(add_tag, tag)
+{
+	CHECK;
+	THIS->add_tag(tag.c_str());
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF1(remove_child, child)
+RUCY_DEF1(remove_tag, tag)
 {
 	CHECK;
+	THIS->remove_tag(tag.c_str());
+}
+RUCY_END
 
-	Reflex::View* c = to<Reflex::View*>(child);
-	if (!c) argument_error();
+static
+RUCY_DEF0(each_tag)
+{
+	CHECK;
 
-	if (!THIS->remove_child(c))
-		reflex_error("failed to remove child view.");
+	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;
+}
+RUCY_END
 
-	return self;
+static
+RUCY_DEF1(set_selector, selector)
+{
+	CHECK;
+	THIS->set_selector(to<Reflex::Selector>(selector));
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEFN(find_child)
+RUCY_DEF0(get_selector)
 {
 	CHECK;
-	if (argc < 1 || 3 < argc)
-		arg_count_error("View#find_child", argc, 1, 2, 3);
+	return value(THIS->selector());
+}
+RUCY_END
 
-	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
+RUCY_DEF1(set_frame, arg)
+{
+	CHECK;
+	THIS->set_frame(to<Rays::Bounds>(arg));
+}
+RUCY_END
 
-	Reflex::View* c = THIS->find_child(name, index, recursive);
-	if (!c) return Qnil;
+static
+RUCY_DEF0(get_frame)
+{
+	CHECK;
+	return value(THIS->frame());
+}
+RUCY_END
 
-	return value(c);
+static
+RUCY_DEF1(set_capture, types)
+{
+	CHECK;
+	THIS->set_capture(to<uint>(types));
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF1(set_name, name)
+RUCY_DEF0(get_capture)
 {
 	CHECK;
-	if (!THIS->set_name(name.c_str()))
-		reflex_error("failed to set the name of view.");
-	return name;
+	return value(THIS->capture());
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(get_name)
+RUCY_DEFN(scroll_to)
 {
 	CHECK;
-	const char* s = THIS->name();
-	if (!s) reflex_error("failed to get name of view.");
-	return value(s);
+	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
+	{
+		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 self;
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF4(set_bounds, x, y, width, height)
+RUCY_DEFN(scroll_by)
 {
 	CHECK;
-	if (!THIS->set_bounds(
-		to<coord>(x), to<coord>(y), to<coord>(width), to<coord>(height)))
+	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
 	{
-		reflex_error("failed to set the bounds of view.");
+		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 value(THIS->bounds());
+
+	return self;
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(get_bounds)
+RUCY_DEF0(get_scroll)
 {
 	CHECK;
-	return value(THIS->bounds());
+	return value(THIS->scroll());
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(hidden)
+RUCY_DEF0(parent)
 {
 	CHECK;
-	return value(THIS->hidden());
+	return value(THIS->parent());
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(parent)
+RUCY_DEF0(window)
 {
 	CHECK;
+	return value(THIS->window());
+}
+RUCY_END
 
-	Reflex::View* v = THIS->parent();
-	if (!v) return Qnil;
+static
+RUCY_DEF1(on_attach, event)
+{
+	CHECK;
+	CALL(on_attach(to<Reflex::Event*>(event)));
+}
+RUCY_END
 
-	return value(v);
+static
+RUCY_DEF1(on_detach, event)
+{
+	CHECK;
+	CALL(on_detach(to<Reflex::Event*>(event)));
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF0(window)
+RUCY_DEF1(on_update, event)
 {
 	CHECK;
+	CALL(on_update(to<Reflex::UpdateEvent*>(event)));
+}
+RUCY_END
 
-	Reflex::Window* w = THIS->window();
-	if (!w) return Qnil;
+static
+RUCY_DEF1(on_draw, event)
+{
+	CHECK;
+	CALL(on_draw(to<Reflex::DrawEvent*>(event)));
+}
+RUCY_END
+
+static
+RUCY_DEF1(on_move, event)
+{
+	CHECK;
+	CALL(on_move(to<Reflex::FrameEvent*>(event)));
+}
+RUCY_END
 
-	return value(w);
+static
+RUCY_DEF1(on_resize, event)
+{
+	CHECK;
+	CALL(on_resize(to<Reflex::FrameEvent*>(event)));
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF1(update, dt)
+RUCY_DEF1(on_scroll, event)
 {
 	CHECK;
-	CALL(update(to<float>(dt)));
-	return self;
+	CALL(on_scroll(to<Reflex::ScrollEvent*>(event)));
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF2(draw, painter, bounds)
+RUCY_DEF1(on_focus, event)
 {
 	CHECK;
-	CALL(draw(to<Rays::Painter*>(painter), *to<Rays::Bounds*>(bounds)));
-	return self;
+	CALL(on_focus(to<Reflex::FocusEvent*>(event)));
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF2(moved, dx, dy)
+RUCY_DEF1(on_blur, event)
 {
 	CHECK;
-	CALL(moved(to<coord>(dx), to<coord>(dy)));
-	return self;
+	CALL(on_blur(to<Reflex::FocusEvent*>(event)));
 }
-RUBY_END
+RUCY_END
 
 static
-RUBY_DEF2(resized, dwidth, dheight)
+RUCY_DEF1(on_key, event)
 {
 	CHECK;
-	CALL(resized(to<coord>(dwidth), to<coord>(dheight)));
-	return self;
+	CALL(on_key(to<Reflex::KeyEvent*>(event)));
 }
-RUBY_END
+RUCY_END
+
+static
+RUCY_DEF1(on_key_down, event)
+{
+	CHECK;
+	CALL(on_key_down(to<Reflex::KeyEvent*>(event)));
+}
+RUCY_END
+
+static
+RUCY_DEF1(on_key_up, event)
+{
+	CHECK;
+	CALL(on_key_up(to<Reflex::KeyEvent*>(event)));
+}
+RUCY_END
+
+static
+RUCY_DEF1(on_pointer, event)
+{
+	CHECK;
+	CALL(on_pointer(to<Reflex::PointerEvent*>(event)));
+}
+RUCY_END
+
+static
+RUCY_DEF1(on_pointer_down, event)
+{
+	CHECK;
+	CALL(on_pointer_down(to<Reflex::PointerEvent*>(event)));
+}
+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_DEF1(on_capture, event)
+{
+	CHECK;
+	CALL(on_capture(to<Reflex::CaptureEvent*>(event)));
+}
+RUCY_END
+
+static
+RUCY_DEF_clear_override_flags(cof, Reflex::View, cView);
 
 
 void
@@ -240,21 +541,75 @@ Init_view ()
 
 	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("show",    show);
+	cView.define_method("hide",    hide);
+	cView.define_method("hidden?", hidden);
+	cView.define_method("redraw",  redraw);
+	cView.define_method("add_child",     add_child);
+	cView.define_method("remove_child",  remove_child);
+	cView.define_method("find_children", find_children);
+	cView.define_method("each_child",    each_child);
+	cView.define_method("add_style",    add_style);
+	cView.define_method("remove_style", remove_style);
+	cView.define_method("get_style",    get_style);
+	cView.define_method("find_styles",  find_styles);
+	cView.define_method("each_style",   each_style);
+	cView.define_method("focus",  focus);
+	cView.define_method("blur",   blur);
+	cView.define_method("focus?", has_focus);
+	cView.define_method("resize_to_fit", resize_to_fit);
+	cView.define_method("content_size",  content_size);
 	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("name",  get_name);
+	cView.define_method("add_tag",    add_tag);
+	cView.define_method("remove_tag", remove_tag);
+	cView.define_method("each_tag", each_tag);
+	cView.define_method("selector=", set_selector);
+	cView.define_method("selector", get_selector);
+	cView.define_private_method("set_frame", set_frame);
+	cView.define_private_method("get_frame", get_frame);
+	cView.define_method("scroll_to", scroll_to);
+	cView.define_method("scroll_by", scroll_by);
+	cView.define_method("scroll", get_scroll);
+	cView.define_method("set_capture", set_capture);
+	cView.define_method("get_capture", get_capture);
 	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);
+	cView.define_method("on_attach", on_attach);
+	cView.define_method("on_detach", on_detach);
+	cView.define_method("on_update", on_update);
+	cView.define_method("on_draw",   on_draw);
+	cView.define_method("on_move",   on_move);
+	cView.define_method("on_resize", on_resize);
+	cView.define_method("on_scroll", on_scroll);
+	cView.define_method("on_focus",  on_focus);
+	cView.define_method("on_blur",   on_blur);
+	cView.define_method("on_key",      on_key);
+	cView.define_method("on_key_down", on_key_down);
+	cView.define_method("on_key_up",   on_key_up);
+	cView.define_method("on_pointer",      on_pointer);
+	cView.define_method("on_pointer_down", on_pointer_down);
+	cView.define_method("on_pointer_up",   on_pointer_up);
+	cView.define_method("on_pointer_move", on_pointer_move);
+	cView.define_method("on_wheel", on_wheel);
+	cView.define_method("on_capture", on_capture);
+	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);
+	cView.define_clear_override_flags(cof);
 }
+
+
+namespace Reflex
+{
+
+
+	Class
+	view_class ()
+	{
+		return cView;
+	}
+
+
+}// Reflex