reflexion 0.1.11 → 0.1.16

data/.doc/ext/reflex/update_event.cpp

@@ -1,13 +1,9 @@
 #include "reflex/ruby/event.h"
 
 
-#include <rucy.h>
 #include "defs.h"
 
 
-using namespace Rucy;
-
-
 RUCY_DEFINE_VALUE_FROM_TO(Reflex::UpdateEvent)
 
 #define THIS  to<Reflex::UpdateEvent*>(self)
@@ -22,12 +18,12 @@ VALUE alloc(VALUE klass)
 }
 
 static
-VALUE initialize(VALUE self)
+VALUE initialize(VALUE self, VALUE now, VALUE dt)
 {
 	CHECK;
-	check_arg_count(__FILE__, __LINE__, "UpdateEvent#initialize", argc, 0, 1);
 
-	THIS->dt = (argc >= 1) ? argv[0].as_f() : 0;
+	THIS->now = to<double>(now);
+	THIS->dt  = to<float>(dt);
 
 	return rb_call_super(0, NULL);
 }
@@ -40,6 +36,13 @@ VALUE initialize_copy(VALUE self, VALUE obj)
 	return self;
 }
 
+static
+VALUE now(VALUE self)
+{
+	CHECK;
+	return value(THIS->now);
+}
+
 static
 VALUE dt(VALUE self)
 {
@@ -57,8 +60,9 @@ Init_update_event ()
 
 	cUpdateEvent = mReflex.define_class("UpdateEvent", Reflex::event_class());
 	rb_define_alloc_func(cUpdateEvent, alloc);
-	rb_define_private_method(cUpdateEvent, "initialize", RUBY_METHOD_FUNC(initialize), -1);
+	rb_define_private_method(cUpdateEvent, "initialize", RUBY_METHOD_FUNC(initialize), 2);
 	rb_define_private_method(cUpdateEvent, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
+	rb_define_method(cUpdateEvent, "now", RUBY_METHOD_FUNC(now), 0);
 	rb_define_method(cUpdateEvent, "dt", RUBY_METHOD_FUNC(dt), 0);
 }
 

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

@@ -2,27 +2,27 @@
 
 
 #include <vector>
-#include <rucy.h>
 #include <rays/ruby/point.h>
 #include <rays/ruby/bounds.h>
-#include "reflex/ruby/window.h"
+#include <rays/ruby/polygon.h>
 #include "reflex/ruby/selector.h"
+#include "reflex/ruby/timer.h"
 #include "reflex/ruby/style.h"
-#include "reflex/ruby/body.h"
-
-
-using namespace Rucy;
-
-using Reflex::coord;
+#include "reflex/ruby/shape.h"
+#include "reflex/ruby/filter.h"
+#include "reflex/ruby/window.h"
+#include "defs.h"
+#include "selector.h"
 
 
 RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(Reflex::View)
 
-#define THIS      to<Reflex::View*>(self)
+#define   THIS    to<      Reflex::View*>(self)
+#define C_THIS    to<const Reflex::View*>(self)
 
 #define CHECK     RUCY_CHECK_OBJECT(Reflex::View, self)
 
-#define CALL(fun) RUCY_WRAPPER_CALL(Reflex::View, THIS, fun)
+#define CALL(fun) RUCY_CALL_SUPER(THIS, fun)
 
 
 template <typename T>
@@ -72,6 +72,54 @@ VALUE redraw(VALUE self)
 	return self;
 }
 
+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 blur(VALUE self)
+{
+	CHECK;
+	THIS->blur();
+	return self;
+}
+
+static
+VALUE has_focus(VALUE self)
+{
+	CHECK;
+	return value(THIS->has_focus());
+}
+
+static
+VALUE start_timer(VALUE self)
+{
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "View#start_timer", argc, 1, 2);
+
+	Reflex::Timer* timer = THIS->start_timer(
+		to<float>(argv[0]),
+		argc >= 2 ? to<int>(argv[1]) : 1);
+
+	return value(timer);
+}
+
+static
+VALUE update_layout(VALUE self)
+{
+	CHECK;
+	THIS->update_layout();
+	return self;
+}
+
 static
 VALUE add_child(VALUE self, VALUE child)
 {
@@ -88,16 +136,24 @@ VALUE remove_child(VALUE self, VALUE child)
 	return child;
 }
 
+static
+VALUE clear_children(VALUE self)
+{
+	CHECK;
+	THIS->clear_children();
+	return self;
+}
+
 static
 VALUE find_children(VALUE self)
 {
 	CHECK;
 	check_arg_count(__FILE__, __LINE__, "View#find_children", argc, 1, 2);
 
-	bool recursive = (argc >= 2) ? to<bool>(argv[1]) : false;
+	bool recursive = (argc >= 2) ? to<bool>(argv[1]) : true;
 
-	Reflex::View::ChildList children;
-	THIS->find_children(&children, to<Reflex::Selector>(argv[0]), recursive);
+	Reflex::View::ChildList children =
+		THIS->find_children(to<Reflex::Selector>(argv[0]), recursive);
 	return array(children.begin(), children.end());
 }
 
@@ -136,9 +192,9 @@ VALUE get_style(VALUE self, VALUE selector)
 
 	Reflex::Style* s = NULL;
 	if (selector)
-		s = THIS->get_style(to<Reflex::Selector>(selector), true);
+		s = THIS->get_style(to<Reflex::Selector>(selector));
 	else
-		s = THIS->style(true);
+		s = THIS->style();
 
 	return s ? value(*s) : nil();
 }
@@ -151,8 +207,8 @@ VALUE find_styles(VALUE self)
 
 	bool recursive = (argc >= 2) ? to<bool>(argv[1]) : false;
 
-	Reflex::View::StyleList styles;
-	THIS->find_styles(&styles, to<Reflex::Selector>(argv[0]), recursive);
+	Reflex::View::StyleList styles =
+		THIS->find_styles(to<Reflex::Selector>(argv[0]), recursive);
 	return array(styles.begin(), styles.end());
 }
 
@@ -168,128 +224,188 @@ VALUE each_style(VALUE self)
 	return ret;
 }
 
+static Reflex::Shape::Ref
+to_shape (Value value)
+{
+	if (value.is_nil())
+		return NULL;
+
+	if (value.is_kind_of(Rays::polygon_class()))
+	{
+		Reflex::PolygonShape* shape = new Reflex::PolygonShape();
+		shape->set_polygon(to<Rays::Polygon&>(value));
+		return shape;
+	}
+	else
+		return to<Reflex::Shape*>(value);
+}
+
 static
-VALUE focus(VALUE self)
+VALUE set_shape(VALUE self, VALUE shape)
 {
 	CHECK;
-	check_arg_count(__FILE__, __LINE__, "View#focus", argc, 0, 1);
-
-	bool state = (argc >= 1) ? to<bool>(argv[0]) : true;
+	THIS->set_shape(to_shape(shape));
+	return shape;
+}
 
-	THIS->focus(state);
-	return self;
+static
+VALUE get_shape(VALUE self)
+{
+	CHECK;
+	return value(THIS->shape());
 }
 
 static
-VALUE blur(VALUE self)
+VALUE add_shape(VALUE self, VALUE shape)
 {
 	CHECK;
-	THIS->blur();
-	return self;
+	THIS->add_shape(to_shape(shape));
+	return shape;
 }
 
 static
-VALUE has_focus(VALUE self)
+VALUE remove_shape(VALUE self, VALUE shape)
 {
 	CHECK;
-	return value(THIS->has_focus());
+	THIS->remove_shape(to<Reflex::Shape*>(shape));
+	return shape;
 }
 
 static
-VALUE resize_to_fit(VALUE self)
+VALUE clear_shapes(VALUE self)
 {
 	CHECK;
-	THIS->resize_to_fit();
+	THIS->clear_shapes();
 	return self;
 }
 
 static
-VALUE content_size(VALUE self)
+VALUE find_shapes(VALUE self)
 {
 	CHECK;
-	return value(CALL(content_size()));
+	check_arg_count(__FILE__, __LINE__, "View#find_shapes", argc, 1);
+
+	Reflex::View::ShapeList shapes =
+		THIS->find_shapes(to<Reflex::Selector>(argv[0]));
+	return array(shapes.begin(), shapes.end());
 }
 
 static
-VALUE make_body(VALUE self)
+VALUE each_shape(VALUE self)
 {
 	CHECK;
-	CALL(make_body());
+
+	Value ret;
+	Reflex::View::shape_iterator end = THIS->shape_end();
+	for (Reflex::View::shape_iterator it = THIS->shape_begin(); it != end; ++it)
+		ret = rb_yield(value(it->get()));
+	return ret;
 }
 
 static
-VALUE clear_body(VALUE self)
+VALUE set_filter(VALUE self, VALUE filter)
 {
 	CHECK;
-	THIS->clear_body();
+	THIS->set_filter(filter ? to<Reflex::Filter*>(filter) : NULL);
+	return filter;
 }
 
 static
-VALUE set_name(VALUE self, VALUE name)
+VALUE get_filter(VALUE self)
 {
 	CHECK;
-	THIS->set_name(name.is_nil() ? NULL : name.c_str());
+	return value(THIS->filter());
 }
 
 static
-VALUE get_name(VALUE self)
+VALUE set_frame(VALUE self)
 {
 	CHECK;
-	return THIS->name() ? value(THIS->name()) : nil();
+	THIS->set_frame(to<Rays::Bounds>(argc, argv));
+	return value(THIS->frame());
 }
 
 static
-VALUE add_tag(VALUE self, VALUE tag)
+VALUE get_frame(VALUE self)
 {
 	CHECK;
-	THIS->add_tag(tag.c_str());
+	return value(THIS->frame());
 }
 
 static
-VALUE remove_tag(VALUE self, VALUE tag)
+VALUE content_bounds(VALUE self)
 {
 	CHECK;
-	THIS->remove_tag(tag.c_str());
+	return value(CALL(content_bounds()));
 }
 
 static
-VALUE each_tag(VALUE self)
+VALUE fit_to_content(VALUE self)
 {
 	CHECK;
+	THIS->fit_to_content();
+	return self;
+}
 
-	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_angle(VALUE self, VALUE degree)
+{
+	CHECK;
+	THIS->set_angle(to<float>(degree));
+	return degree;
 }
 
 static
-VALUE set_selector(VALUE self, VALUE selector)
+VALUE get_angle(VALUE self)
 {
 	CHECK;
-	THIS->set_selector(to<Reflex::Selector>(selector));
+	return value(THIS->angle());
 }
 
 static
-VALUE get_selector(VALUE self)
+VALUE scroll_to(VALUE self)
 {
 	CHECK;
-	return value(THIS->selector());
+	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;
 }
 
 static
-VALUE set_frame(VALUE self, VALUE arg)
+VALUE scroll_by(VALUE self)
 {
 	CHECK;
-	THIS->set_frame(to<Rays::Bounds>(arg));
+	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 get_frame(VALUE self)
+VALUE get_scroll(VALUE self)
 {
 	CHECK;
-	return value(THIS->frame());
+	return value(THIS->scroll());
 }
 
 static
@@ -297,6 +413,7 @@ VALUE set_zoom(VALUE self, VALUE zoom)
 {
 	CHECK;
 	THIS->set_zoom(to<float>(zoom));
+	return zoom;
 }
 
 static
@@ -307,70 +424,98 @@ VALUE get_zoom(VALUE self)
 }
 
 static
-VALUE get_angle(VALUE self)
+VALUE set_capture(VALUE self, VALUE types)
 {
 	CHECK;
-	return value(THIS->angle());
+	THIS->set_capture(to<uint>(types));
+	return types;
 }
 
 static
-VALUE set_capture(VALUE self, VALUE types)
+VALUE get_capture(VALUE self)
 {
 	CHECK;
-	THIS->set_capture(to<uint>(types));
+	return value(THIS->capture());
 }
 
 static
-VALUE get_capture(VALUE self)
+VALUE set_clip(VALUE self, VALUE clip)
 {
 	CHECK;
-	return value(THIS->capture());
+
+	if (clip)
+		THIS->   add_flag(Reflex::View::FLAG_CLIP);
+	else
+		THIS->remove_flag(Reflex::View::FLAG_CLIP);
+
+	return clip;
 }
 
 static
-VALUE scroll_to(VALUE self)
+VALUE get_clip(VALUE self)
 {
 	CHECK;
-	check_arg_count(__FILE__, __LINE__, "View#scroll_to", argc, 1, 2, 3);
+	return value(THIS->has_flag(Reflex::View::FLAG_CLIP));
+}
 
-	if (argv[0].is_kind_of(Rays::point_class()))
-		THIS->scroll_to(to<Rays::Point&>(argv[0]));
+static
+VALUE set_cache(VALUE self, VALUE cache)
+{
+	CHECK;
+
+	if (cache)
+		THIS->   add_flag(Reflex::View::FLAG_CACHE);
 	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);
-	}
+		THIS->remove_flag(Reflex::View::FLAG_CACHE);
 
-	return self;
+	return cache;
 }
 
 static
-VALUE scroll_by(VALUE self)
+VALUE get_cache(VALUE self)
 {
 	CHECK;
-	check_arg_count(__FILE__, __LINE__, "View#scroll_by", argc, 1, 2, 3);
+	return value(THIS->has_flag(Reflex::View::FLAG_CACHE));
+}
 
-	if (argv[0].is_kind_of(Rays::point_class()))
-		THIS->scroll_by(to<Rays::Point&>(argv[0]));
+static
+VALUE set_resize_to_fit(VALUE self, VALUE resize)
+{
+	CHECK;
+
+	if (resize)
+		THIS->   add_flag(Reflex::View::FLAG_RESIZE_TO_FIT);
 	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);
-	}
+		THIS->remove_flag(Reflex::View::FLAG_RESIZE_TO_FIT);
 
-	return self;
+	return resize;
 }
 
 static
-VALUE get_scroll(VALUE self)
+VALUE get_resize_to_fit(VALUE self)
 {
 	CHECK;
-	return value(THIS->scroll());
+	return value(THIS->has_flag(Reflex::View::FLAG_RESIZE_TO_FIT));
+}
+
+static
+VALUE set_scroll_to_fit(VALUE self, VALUE scroll)
+{
+	CHECK;
+
+	if (scroll)
+		THIS->   add_flag(Reflex::View::FLAG_SCROLL_TO_FIT);
+	else
+		THIS->remove_flag(Reflex::View::FLAG_SCROLL_TO_FIT);
+
+	return scroll;
+}
+
+static
+VALUE get_scroll_to_fit(VALUE self)
+{
+	CHECK;
+	return value(THIS->has_flag(Reflex::View::FLAG_SCROLL_TO_FIT));
 }
 
 static
@@ -388,10 +533,211 @@ VALUE window(VALUE self)
 }
 
 static
-VALUE body(VALUE self)
+VALUE apply_force(VALUE self)
+{
+	CHECK;
+	THIS->apply_force(to<Rays::Point>(argc, argv));
+	return self;
+}
+
+static
+VALUE apply_torque(VALUE self, VALUE torque)
+{
+	CHECK;
+	THIS->apply_torque(to<float>(torque));
+	return self;
+}
+
+static
+VALUE apply_linear_impulse(VALUE self)
+{
+	CHECK;
+	THIS->apply_linear_impulse(to<Rays::Point>(argc, argv));
+	return self;
+}
+
+static
+VALUE apply_angular_impulse(VALUE self, VALUE impulse)
+{
+	CHECK;
+	THIS->apply_angular_impulse(to<float>(impulse));
+	return self;
+}
+
+static
+VALUE set_static(VALUE self, VALUE state)
+{
+	CHECK;
+	THIS->set_static(state);
+	return state;
+}
+
+static
+VALUE is_static(VALUE self)
+{
+	CHECK;
+	return value(THIS->is_static());
+}
+
+static
+VALUE set_dynamic(VALUE self, VALUE state)
+{
+	CHECK;
+	THIS->set_dynamic(state);
+	return state;
+}
+
+static
+VALUE is_dynamic(VALUE self)
+{
+	CHECK;
+	return value(THIS->is_dynamic());
+}
+
+static
+VALUE set_density(VALUE self, VALUE density)
+{
+	CHECK;
+	THIS->set_density(to<float>(density));
+	return density;
+}
+
+static
+VALUE get_density(VALUE self)
+{
+	CHECK;
+	return value(THIS->density());
+}
+
+static
+VALUE set_friction(VALUE self, VALUE friction)
+{
+	CHECK;
+	THIS->set_friction(to<float>(friction));
+	return friction;
+}
+
+static
+VALUE get_friction(VALUE self)
+{
+	CHECK;
+	return value(THIS->friction());
+}
+
+static
+VALUE set_restitution(VALUE self, VALUE restitution)
+{
+	CHECK;
+	THIS->set_restitution(to<float>(restitution));
+	return restitution;
+}
+
+static
+VALUE get_restitution(VALUE self)
+{
+	CHECK;
+	return value(THIS->restitution());
+}
+
+static
+VALUE set_sensor(VALUE self, VALUE state)
+{
+	CHECK;
+	THIS->set_sensor(state);
+	return state;
+}
+
+static
+VALUE is_sensor(VALUE self)
+{
+	CHECK;
+	return value(THIS->is_sensor());
+}
+
+static
+VALUE set_category_bits(VALUE self, VALUE bits)
+{
+	CHECK;
+	THIS->set_category_bits(to<uint>(bits));
+	return bits;
+}
+
+static
+VALUE get_category_bits(VALUE self)
+{
+	CHECK;
+	return value(THIS->category_bits());
+}
+
+static
+VALUE set_collision_mask(VALUE self, VALUE mask)
+{
+	CHECK;
+	THIS->set_collision_mask(to<uint>(mask));
+	return mask;
+}
+
+static
+VALUE get_collision_mask(VALUE self)
+{
+	CHECK;
+	return value(THIS->collision_mask());
+}
+
+static
+VALUE set_linear_velocity(VALUE self)
+{
+	CHECK;
+	THIS->set_linear_velocity(to<Rays::Point>(argc, argv));
+	return value(THIS->linear_velocity());
+}
+
+static
+VALUE get_linear_velocity(VALUE self)
+{
+	CHECK;
+	return value(THIS->linear_velocity());
+}
+
+static
+VALUE set_angular_velocity(VALUE self, VALUE velocity)
+{
+	CHECK;
+	THIS->set_angular_velocity(to<float>(velocity));
+	return velocity;
+}
+
+static
+VALUE get_angular_velocity(VALUE self)
+{
+	CHECK;
+	return value(THIS->angular_velocity());
+}
+
+static
+VALUE set_gravity_scale(VALUE self, VALUE scale)
+{
+	CHECK;
+	THIS->set_gravity_scale(to<float>(scale));
+	return scale;
+}
+
+static
+VALUE get_gravity_scale(VALUE self)
+{
+	CHECK;
+	return value(THIS->gravity_scale());
+}
+
+static
+VALUE update_physics(VALUE self)
 {
 	CHECK;
-	return value(THIS->body());
+	check_arg_count(__FILE__, __LINE__, "View#update_physics", argc, 0, 1);
+
+	float duration = argc >= 1 ? to<float>(argv[0]) : 0;
+	THIS->update_physics(duration);
+	return self;
 }
 
 static
@@ -400,17 +746,17 @@ VALUE meter2pixel(VALUE self)
 	CHECK;
 	check_arg_count(__FILE__, __LINE__, "View#meter2pixel", argc, 0, 1, 2);
 
-	float meter       = argc >= 1 ? argv[0].as_f(true) : 1;
-	bool create_world = argc >= 2 ? (bool) argv[1]     : true;
+	float meter       = argc >= 1 ? to<float>(argv[0]) : 1;
+	bool create_world = argc >= 2 ? to<bool> (argv[1]) : true;
 	return value(THIS->meter2pixel(meter, create_world));
 }
 
 static
-VALUE set_gravity(VALUE self, VALUE x, VALUE y)
+VALUE set_gravity(VALUE self)
 {
 	CHECK;
-	THIS->set_gravity(x.as_f(true), y.as_f(true));
-	return self;
+	THIS->set_gravity(to<Rays::Point>(argc, argv));
+	return value(THIS->gravity());
 }
 
 static
@@ -420,6 +766,21 @@ VALUE get_gravity(VALUE self)
 	return value(THIS->gravity());
 }
 
+static
+VALUE set_time_scale(VALUE self, VALUE scale)
+{
+	CHECK;
+	THIS->set_time_scale(to<float>(scale));
+	return scale;
+}
+
+static
+VALUE get_time_scale(VALUE self)
+{
+	CHECK;
+	return value(THIS->time_scale());
+}
+
 static
 VALUE wall(VALUE self)
 {
@@ -436,20 +797,16 @@ VALUE set_debug(VALUE self, VALUE state)
 }
 
 static
-VALUE debugging(VALUE self)
+VALUE get_debug(VALUE self)
 {
 	CHECK;
-	return value(THIS->debugging());
+	return value(THIS->debug());
 }
 
 static
 VALUE on_attach(VALUE self, VALUE event)
 {
 	CHECK;
-
-	RUCY_SYM(call_attach_block);
-	self.call(call_attach_block);
-
 	CALL(on_attach(to<Reflex::Event*>(event)));
 }
 
@@ -523,13 +880,6 @@ VALUE on_focus(VALUE self, VALUE event)
 	CALL(on_focus(to<Reflex::FocusEvent*>(event)));
 }
 
-static
-VALUE on_blur(VALUE self, VALUE event)
-{
-	CHECK;
-	CALL(on_blur(to<Reflex::FocusEvent*>(event)));
-}
-
 static
 VALUE on_key(VALUE self, VALUE event)
 {
@@ -593,6 +943,13 @@ VALUE on_capture(VALUE self, VALUE event)
 	CALL(on_capture(to<Reflex::CaptureEvent*>(event)));
 }
 
+static
+VALUE on_timer(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_timer(to<Reflex::TimerEvent*>(event)));
+}
+
 static
 VALUE on_contact(VALUE self, VALUE event)
 {
@@ -614,9 +971,6 @@ VALUE on_contact_end(VALUE self, VALUE event)
 	CALL(on_contact_end(to<Reflex::ContactEvent*>(event)));
 }
 
-static
-RUCY_DEF_clear_override_flags(cof, Reflex::View);
-
 
 static Class cView;
 
@@ -631,48 +985,96 @@ Init_view ()
 	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, "focus", RUBY_METHOD_FUNC(focus), -1);
+	rb_define_method(cView, "blur", RUBY_METHOD_FUNC(blur), 0);
+	cView.define_method("focus?", has_focus);
+	rb_define_private_method(cView, "start_timer", RUBY_METHOD_FUNC(start_timer), -1);
+	rb_define_method(cView, "update_layout", RUBY_METHOD_FUNC(update_layout), 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, "clear_children", RUBY_METHOD_FUNC(clear_children), 0);
 	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, "make_body", RUBY_METHOD_FUNC(make_body), 0);
-	rb_define_method(cView, "clear_body", RUBY_METHOD_FUNC(clear_body), 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_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, "zoom=", RUBY_METHOD_FUNC(set_zoom), 1);
-	rb_define_method(cView, "zoom", RUBY_METHOD_FUNC(get_zoom), 0);
+
+	rb_define_method(cView, "shape=", RUBY_METHOD_FUNC(set_shape), 1);
+	rb_define_method(cView, "shape", RUBY_METHOD_FUNC(get_shape), 0);
+	rb_define_method(cView, "add_shape", RUBY_METHOD_FUNC(add_shape), 1);
+	rb_define_method(cView, "remove_shape", RUBY_METHOD_FUNC(remove_shape), 1);
+	rb_define_method(cView, "clear_shapes", RUBY_METHOD_FUNC(clear_shapes), 0);
+	rb_define_method(cView, "find_shapes", RUBY_METHOD_FUNC(find_shapes), -1);
+	rb_define_method(cView, "each_shape", RUBY_METHOD_FUNC(each_shape), 0);
+
+	rb_define_method(cView, "filter=", RUBY_METHOD_FUNC(set_filter), 1);
+	rb_define_method(cView, "filter", RUBY_METHOD_FUNC(get_filter), 0);
+
+	rb_define_method(cView, "frame=", RUBY_METHOD_FUNC(set_frame), -1);
+	rb_define_method(cView, "frame", RUBY_METHOD_FUNC(get_frame), 0);
+	rb_define_method(cView, "content_bounds", RUBY_METHOD_FUNC(content_bounds), 0);
+	rb_define_method(cView, "fit_to_content", RUBY_METHOD_FUNC(fit_to_content), 0);
+	rb_define_method(cView, "angle=", RUBY_METHOD_FUNC(set_angle), 1);
 	rb_define_method(cView, "angle", RUBY_METHOD_FUNC(get_angle), 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, "zoom=", RUBY_METHOD_FUNC(set_zoom), 1);
+	rb_define_method(cView, "zoom", RUBY_METHOD_FUNC(get_zoom), 0);
+	rb_define_method(cView, "capture=", RUBY_METHOD_FUNC(set_capture), 1);
+	rb_define_method(cView, "capture", RUBY_METHOD_FUNC(get_capture), 0);
+	rb_define_method(cView, "clip=", RUBY_METHOD_FUNC(set_clip), 1);
+	cView.define_method("clip?", get_clip);
+	rb_define_method(cView, "cache=", RUBY_METHOD_FUNC(set_cache), 1);
+	cView.define_method("cache?", get_cache);
+	rb_define_method(cView, "resize_to_fit=", RUBY_METHOD_FUNC(set_resize_to_fit), 1);
+	cView.define_method("resize_to_fit?", get_resize_to_fit);
+	rb_define_method(cView, "scroll_to_fit=", RUBY_METHOD_FUNC(set_scroll_to_fit), 1);
+	cView.define_method("scroll_to_fit?", get_scroll_to_fit);
 	rb_define_method(cView, "parent", RUBY_METHOD_FUNC(parent), 0);
 	rb_define_method(cView, "window", RUBY_METHOD_FUNC(window), 0);
-	rb_define_method(cView, "body", RUBY_METHOD_FUNC(body), 0);
+
+	rb_define_method(cView, "apply_force", RUBY_METHOD_FUNC(apply_force), -1);
+	rb_define_method(cView, "apply_torque", RUBY_METHOD_FUNC(apply_torque), 1);
+	rb_define_method(cView, "apply_linear_impulse", RUBY_METHOD_FUNC(apply_linear_impulse), -1);
+	rb_define_method(cView, "apply_angular_impulse", RUBY_METHOD_FUNC(apply_angular_impulse), 1);
+	rb_define_method(cView, "static=", RUBY_METHOD_FUNC(set_static), 1);
+	cView.define_method("static?",   is_static);
+	rb_define_method(cView, "dynamic=", RUBY_METHOD_FUNC(set_dynamic), 1);
+	cView.define_method("dynamic?",  is_dynamic);
+	rb_define_method(cView, "density=", RUBY_METHOD_FUNC(set_density), 1);
+	rb_define_method(cView, "density", RUBY_METHOD_FUNC(get_density), 0);
+	rb_define_method(cView, "friction=", RUBY_METHOD_FUNC(set_friction), 1);
+	rb_define_method(cView, "friction", RUBY_METHOD_FUNC(get_friction), 0);
+	rb_define_method(cView, "restitution=", RUBY_METHOD_FUNC(set_restitution), 1);
+	rb_define_method(cView, "restitution", RUBY_METHOD_FUNC(get_restitution), 0);
+	rb_define_method(cView, "sensor=", RUBY_METHOD_FUNC(set_sensor), 1);
+	cView.define_method("sensor?",       is_sensor);
+	rb_define_private_method(cView, "set_category_bits", RUBY_METHOD_FUNC(set_category_bits), 1);
+	rb_define_private_method(cView, "get_category_bits", RUBY_METHOD_FUNC(get_category_bits), 0);
+	rb_define_private_method(cView, "set_collision_mask", RUBY_METHOD_FUNC(set_collision_mask), 1);
+	rb_define_private_method(cView, "get_collision_mask", RUBY_METHOD_FUNC(get_collision_mask), 0);
+	rb_define_method(cView, "linear_velocity=", RUBY_METHOD_FUNC(set_linear_velocity), -1);
+	rb_define_method(cView, "linear_velocity", RUBY_METHOD_FUNC(get_linear_velocity), 0);
+	rb_define_method(cView, "angular_velocity=", RUBY_METHOD_FUNC(set_angular_velocity), 1);
+	rb_define_method(cView, "angular_velocity", RUBY_METHOD_FUNC(get_angular_velocity), 0);
+	rb_define_method(cView, "gravity_scale=", RUBY_METHOD_FUNC(set_gravity_scale), 1);
+	rb_define_method(cView, "gravity_scale", RUBY_METHOD_FUNC(get_gravity_scale), 0);
+
+	rb_define_method(cView, "update_physics", RUBY_METHOD_FUNC(update_physics), -1);
 	rb_define_method(cView, "meter2pixel", RUBY_METHOD_FUNC(meter2pixel), -1);
-	rb_define_method(cView, "set_gravity", RUBY_METHOD_FUNC(set_gravity), 2);
+	rb_define_method(cView, "gravity=", RUBY_METHOD_FUNC(set_gravity), -1);
 	rb_define_method(cView, "gravity", RUBY_METHOD_FUNC(get_gravity), 0);
+	rb_define_method(cView, "time_scale=", RUBY_METHOD_FUNC(set_time_scale), 1);
+	rb_define_method(cView, "time_scale", RUBY_METHOD_FUNC(get_time_scale), 0);
 	rb_define_method(cView, "wall", RUBY_METHOD_FUNC(wall), 0);
 	rb_define_method(cView, "debug=", RUBY_METHOD_FUNC(set_debug), 1);
-	cView.define_method("debug?",     debugging);
+	cView.define_method("debug?", get_debug);
+
 	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_show", RUBY_METHOD_FUNC(on_show), 1);
@@ -684,7 +1086,6 @@ Init_view ()
 	rb_define_method(cView, "on_rotate", RUBY_METHOD_FUNC(on_rotate), 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);
@@ -694,14 +1095,17 @@ Init_view ()
 	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);
-	rb_define_method(cView, "on_contact", RUBY_METHOD_FUNC(on_contact), 1);
-	rb_define_method(cView, "on_contact_begin", RUBY_METHOD_FUNC(on_contact_begin), 1);
-	rb_define_method(cView, "on_contact_end", RUBY_METHOD_FUNC(on_contact_end), 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);
-	
+	rb_define_method(cView, "on_timer", RUBY_METHOD_FUNC(on_timer), 1);
+	cView.define_private_method("call_contact!",       on_contact);
+	cView.define_private_method("call_contact_begin!", on_contact_begin);
+	cView.define_private_method("call_contact_end!",   on_contact_end);
+
+	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);
+
+	define_selector_methods<Reflex::View>(cView);
 }