reflexion 0.1.12 → 0.1.17

data/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)
@@ -23,12 +19,12 @@ RUCY_DEF_ALLOC(alloc, klass)
 RUCY_END
 
 static
-RUCY_DEFN(initialize)
+RUCY_DEF2(initialize, now, 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);
 }
@@ -43,6 +39,14 @@ RUCY_DEF1(initialize_copy, obj)
 }
 RUCY_END
 
+static
+RUCY_DEF0(now)
+{
+	CHECK;
+	return value(THIS->now);
+}
+RUCY_END
+
 static
 RUCY_DEF0(dt)
 {
@@ -61,8 +65,9 @@ Init_update_event ()
 
 	cUpdateEvent = mReflex.define_class("UpdateEvent", Reflex::event_class());
 	cUpdateEvent.define_alloc_func(alloc);
-	cUpdateEvent.define_private_method("initialize", initialize);
+	cUpdateEvent.define_private_method("initialize",      initialize);
 	cUpdateEvent.define_private_method("initialize_copy", initialize_copy);
+	cUpdateEvent.define_method("now", now);
 	cUpdateEvent.define_method("dt", dt);
 }
 

data/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>
@@ -77,6 +77,59 @@ RUCY_DEF0(redraw)
 }
 RUCY_END
 
+static
+RUCY_DEFN(focus)
+{
+	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;
+}
+RUCY_END
+
+static
+RUCY_DEF0(blur)
+{
+	CHECK;
+	THIS->blur();
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF0(has_focus)
+{
+	CHECK;
+	return value(THIS->has_focus());
+}
+RUCY_END
+
+static
+RUCY_DEFN(start_timer)
+{
+	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);
+}
+RUCY_END
+
+static
+RUCY_DEF0(update_layout)
+{
+	CHECK;
+	THIS->update_layout();
+	return self;
+}
+RUCY_END
+
 static
 RUCY_DEF1(add_child, child)
 {
@@ -95,16 +148,25 @@ RUCY_DEF1(remove_child, child)
 }
 RUCY_END
 
+static
+RUCY_DEF0(clear_children)
+{
+	CHECK;
+	THIS->clear_children();
+	return self;
+}
+RUCY_END
+
 static
 RUCY_DEFN(find_children)
 {
 	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());
 }
 RUCY_END
@@ -147,9 +209,9 @@ RUCY_DEF1(get_style, 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();
 }
@@ -163,8 +225,8 @@ RUCY_DEFN(find_styles)
 
 	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());
 }
 RUCY_END
@@ -182,143 +244,205 @@ RUCY_DEF0(each_style)
 }
 RUCY_END
 
+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
-RUCY_DEFN(focus)
+RUCY_DEF1(set_shape, 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;
+}
+RUCY_END
 
-	THIS->focus(state);
-	return self;
+static
+RUCY_DEF0(get_shape)
+{
+	CHECK;
+	return value(THIS->shape());
 }
 RUCY_END
 
 static
-RUCY_DEF0(blur)
+RUCY_DEF1(add_shape, shape)
 {
 	CHECK;
-	THIS->blur();
-	return self;
+	THIS->add_shape(to_shape(shape));
+	return shape;
 }
 RUCY_END
 
 static
-RUCY_DEF0(has_focus)
+RUCY_DEF1(remove_shape, shape)
 {
 	CHECK;
-	return value(THIS->has_focus());
+	THIS->remove_shape(to<Reflex::Shape*>(shape));
+	return shape;
 }
 RUCY_END
 
 static
-RUCY_DEF0(resize_to_fit)
+RUCY_DEF0(clear_shapes)
 {
 	CHECK;
-	THIS->resize_to_fit();
+	THIS->clear_shapes();
 	return self;
 }
 RUCY_END
 
 static
-RUCY_DEF0(content_size)
+RUCY_DEFN(find_shapes)
 {
 	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());
 }
 RUCY_END
 
 static
-RUCY_DEF0(make_body)
+RUCY_DEF0(each_shape)
 {
 	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;
 }
 RUCY_END
 
 static
-RUCY_DEF0(clear_body)
+RUCY_DEF1(set_filter, filter)
 {
 	CHECK;
-	THIS->clear_body();
+	THIS->set_filter(filter ? to<Reflex::Filter*>(filter) : NULL);
+	return filter;
 }
 RUCY_END
 
 static
-RUCY_DEF1(set_name, name)
+RUCY_DEF0(get_filter)
 {
 	CHECK;
-	THIS->set_name(name.is_nil() ? NULL : name.c_str());
+	return value(THIS->filter());
 }
 RUCY_END
 
 static
-RUCY_DEF0(get_name)
+RUCY_DEFN(set_frame)
 {
 	CHECK;
-	return THIS->name() ? value(THIS->name()) : nil();
+	THIS->set_frame(to<Rays::Bounds>(argc, argv));
+	return value(THIS->frame());
 }
 RUCY_END
 
 static
-RUCY_DEF1(add_tag, tag)
+RUCY_DEF0(get_frame)
 {
 	CHECK;
-	THIS->add_tag(tag.c_str());
+	return value(THIS->frame());
 }
 RUCY_END
 
 static
-RUCY_DEF1(remove_tag, tag)
+RUCY_DEF0(content_bounds)
 {
 	CHECK;
-	THIS->remove_tag(tag.c_str());
+	return value(CALL(content_bounds()));
 }
 RUCY_END
 
 static
-RUCY_DEF0(each_tag)
+RUCY_DEF0(fit_to_content)
 {
 	CHECK;
+	THIS->fit_to_content();
+	return self;
+}
+RUCY_END
 
-	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
+RUCY_DEF1(set_angle, degree)
+{
+	CHECK;
+	THIS->set_angle(to<float>(degree));
+	return degree;
 }
 RUCY_END
 
 static
-RUCY_DEF1(set_selector, selector)
+RUCY_DEF0(get_angle)
 {
 	CHECK;
-	THIS->set_selector(to<Reflex::Selector>(selector));
+	return value(THIS->angle());
 }
 RUCY_END
 
 static
-RUCY_DEF0(get_selector)
+RUCY_DEFN(scroll_to)
 {
 	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;
 }
 RUCY_END
 
 static
-RUCY_DEF1(set_frame, arg)
+RUCY_DEFN(scroll_by)
 {
 	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;
 }
 RUCY_END
 
 static
-RUCY_DEF0(get_frame)
+RUCY_DEF0(get_scroll)
 {
 	CHECK;
-	return value(THIS->frame());
+	return value(THIS->scroll());
 }
 RUCY_END
 
@@ -327,6 +451,7 @@ RUCY_DEF1(set_zoom, zoom)
 {
 	CHECK;
 	THIS->set_zoom(to<float>(zoom));
+	return zoom;
 }
 RUCY_END
 
@@ -339,75 +464,107 @@ RUCY_DEF0(get_zoom)
 RUCY_END
 
 static
-RUCY_DEF0(get_angle)
+RUCY_DEF1(set_capture, types)
 {
 	CHECK;
-	return value(THIS->angle());
+	THIS->set_capture(to<uint>(types));
+	return types;
 }
 RUCY_END
 
 static
-RUCY_DEF1(set_capture, types)
+RUCY_DEF0(get_capture)
 {
 	CHECK;
-	THIS->set_capture(to<uint>(types));
+	return value(THIS->capture());
 }
 RUCY_END
 
 static
-RUCY_DEF0(get_capture)
+RUCY_DEF1(set_clip, 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;
 }
 RUCY_END
 
 static
-RUCY_DEFN(scroll_to)
+RUCY_DEF0(get_clip)
 {
 	CHECK;
-	check_arg_count(__FILE__, __LINE__, "View#scroll_to", argc, 1, 2, 3);
+	return value(THIS->has_flag(Reflex::View::FLAG_CLIP));
+}
+RUCY_END
 
-	if (argv[0].is_kind_of(Rays::point_class()))
-		THIS->scroll_to(to<Rays::Point&>(argv[0]));
+static
+RUCY_DEF1(set_cache, 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;
 }
 RUCY_END
 
 static
-RUCY_DEFN(scroll_by)
+RUCY_DEF0(get_cache)
 {
 	CHECK;
-	check_arg_count(__FILE__, __LINE__, "View#scroll_by", argc, 1, 2, 3);
+	return value(THIS->has_flag(Reflex::View::FLAG_CACHE));
+}
+RUCY_END
 
-	if (argv[0].is_kind_of(Rays::point_class()))
-		THIS->scroll_by(to<Rays::Point&>(argv[0]));
+static
+RUCY_DEF1(set_resize_to_fit, 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;
 }
 RUCY_END
 
 static
-RUCY_DEF0(get_scroll)
+RUCY_DEF0(get_resize_to_fit)
 {
 	CHECK;
-	return value(THIS->scroll());
+	return value(THIS->has_flag(Reflex::View::FLAG_RESIZE_TO_FIT));
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_scroll_to_fit, 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;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_scroll_to_fit)
+{
+	CHECK;
+	return value(THIS->has_flag(Reflex::View::FLAG_SCROLL_TO_FIT));
 }
 RUCY_END
 
@@ -428,10 +585,237 @@ RUCY_DEF0(window)
 RUCY_END
 
 static
-RUCY_DEF0(body)
+RUCY_DEFN(apply_force)
+{
+	CHECK;
+	THIS->apply_force(to<Rays::Point>(argc, argv));
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF1(apply_torque, torque)
 {
 	CHECK;
-	return value(THIS->body());
+	THIS->apply_torque(to<float>(torque));
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEFN(apply_linear_impulse)
+{
+	CHECK;
+	THIS->apply_linear_impulse(to<Rays::Point>(argc, argv));
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF1(apply_angular_impulse, impulse)
+{
+	CHECK;
+	THIS->apply_angular_impulse(to<float>(impulse));
+	return self;
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_static, state)
+{
+	CHECK;
+	THIS->set_static(state);
+	return state;
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_static)
+{
+	CHECK;
+	return value(THIS->is_static());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_dynamic, state)
+{
+	CHECK;
+	THIS->set_dynamic(state);
+	return state;
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_dynamic)
+{
+	CHECK;
+	return value(THIS->is_dynamic());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_density, density)
+{
+	CHECK;
+	THIS->set_density(to<float>(density));
+	return density;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_density)
+{
+	CHECK;
+	return value(THIS->density());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_friction, friction)
+{
+	CHECK;
+	THIS->set_friction(to<float>(friction));
+	return friction;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_friction)
+{
+	CHECK;
+	return value(THIS->friction());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_restitution, restitution)
+{
+	CHECK;
+	THIS->set_restitution(to<float>(restitution));
+	return restitution;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_restitution)
+{
+	CHECK;
+	return value(THIS->restitution());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_sensor, state)
+{
+	CHECK;
+	THIS->set_sensor(state);
+	return state;
+}
+RUCY_END
+
+static
+RUCY_DEF0(is_sensor)
+{
+	CHECK;
+	return value(THIS->is_sensor());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_category_bits, bits)
+{
+	CHECK;
+	THIS->set_category_bits(to<uint>(bits));
+	return bits;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_category_bits)
+{
+	CHECK;
+	return value(THIS->category_bits());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_collision_mask, mask)
+{
+	CHECK;
+	THIS->set_collision_mask(to<uint>(mask));
+	return mask;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_collision_mask)
+{
+	CHECK;
+	return value(THIS->collision_mask());
+}
+RUCY_END
+
+static
+RUCY_DEFN(set_linear_velocity)
+{
+	CHECK;
+	THIS->set_linear_velocity(to<Rays::Point>(argc, argv));
+	return value(THIS->linear_velocity());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_linear_velocity)
+{
+	CHECK;
+	return value(THIS->linear_velocity());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_angular_velocity, velocity)
+{
+	CHECK;
+	THIS->set_angular_velocity(to<float>(velocity));
+	return velocity;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_angular_velocity)
+{
+	CHECK;
+	return value(THIS->angular_velocity());
+}
+RUCY_END
+
+static
+RUCY_DEF1(set_gravity_scale, scale)
+{
+	CHECK;
+	THIS->set_gravity_scale(to<float>(scale));
+	return scale;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_gravity_scale)
+{
+	CHECK;
+	return value(THIS->gravity_scale());
+}
+RUCY_END
+
+static
+RUCY_DEFN(update_physics)
+{
+	CHECK;
+	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;
 }
 RUCY_END
 
@@ -441,18 +825,18 @@ RUCY_DEFN(meter2pixel)
 	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));
 }
 RUCY_END
 
 static
-RUCY_DEF2(set_gravity, x, y)
+RUCY_DEFN(set_gravity)
 {
 	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());
 }
 RUCY_END
 
@@ -464,6 +848,23 @@ RUCY_DEF0(get_gravity)
 }
 RUCY_END
 
+static
+RUCY_DEF1(set_time_scale, scale)
+{
+	CHECK;
+	THIS->set_time_scale(to<float>(scale));
+	return scale;
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_time_scale)
+{
+	CHECK;
+	return value(THIS->time_scale());
+}
+RUCY_END
+
 static
 RUCY_DEF0(wall)
 {
@@ -482,10 +883,10 @@ RUCY_DEF1(set_debug, state)
 RUCY_END
 
 static
-RUCY_DEF0(debugging)
+RUCY_DEF0(get_debug)
 {
 	CHECK;
-	return value(THIS->debugging());
+	return value(THIS->debug());
 }
 RUCY_END
 
@@ -493,10 +894,6 @@ static
 RUCY_DEF1(on_attach, event)
 {
 	CHECK;
-
-	RUCY_SYM(call_attach_block);
-	self.call(call_attach_block);
-
 	CALL(on_attach(to<Reflex::Event*>(event)));
 }
 RUCY_END
@@ -581,14 +978,6 @@ RUCY_DEF1(on_focus, event)
 }
 RUCY_END
 
-static
-RUCY_DEF1(on_blur, event)
-{
-	CHECK;
-	CALL(on_blur(to<Reflex::FocusEvent*>(event)));
-}
-RUCY_END
-
 static
 RUCY_DEF1(on_key, event)
 {
@@ -661,6 +1050,14 @@ RUCY_DEF1(on_capture, event)
 }
 RUCY_END
 
+static
+RUCY_DEF1(on_timer, event)
+{
+	CHECK;
+	CALL(on_timer(to<Reflex::TimerEvent*>(event)));
+}
+RUCY_END
+
 static
 RUCY_DEF1(on_contact, event)
 {
@@ -685,9 +1082,6 @@ RUCY_DEF1(on_contact_end, event)
 }
 RUCY_END
 
-static
-RUCY_DEF_clear_override_flags(cof, Reflex::View);
-
 
 static Class cView;
 
@@ -702,48 +1096,96 @@ Init_view ()
 	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("focus",  focus);
+	cView.define_method("blur",   blur);
+	cView.define_method("focus?", has_focus);
+	cView.define_private_method("start_timer", start_timer);
+	cView.define_method("update_layout", update_layout);
+
+	cView.define_method("add_child",      add_child);
+	cView.define_method("remove_child",   remove_child);
+	cView.define_method("clear_children", clear_children);
+	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("make_body",  make_body);
-	cView.define_method("clear_body", clear_body);
-	cView.define_method("name=", set_name);
-	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("zoom=", set_zoom);
-	cView.define_method("zoom",  get_zoom);
+
+	cView.define_method("shape=",       set_shape);
+	cView.define_method("shape",        get_shape);
+	cView.define_method("add_shape",    add_shape);
+	cView.define_method("remove_shape", remove_shape);
+	cView.define_method("clear_shapes", clear_shapes);
+	cView.define_method("find_shapes",  find_shapes);
+	cView.define_method("each_shape",   each_shape);
+
+	cView.define_method("filter=", set_filter);
+	cView.define_method("filter",  get_filter);
+
+	cView.define_method("frame=", set_frame);
+	cView.define_method("frame",  get_frame);
+	cView.define_method("content_bounds", content_bounds);
+	cView.define_method("fit_to_content", fit_to_content);
+	cView.define_method("angle=", set_angle);
 	cView.define_method("angle",  get_angle);
 	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("zoom=", set_zoom);
+	cView.define_method("zoom",  get_zoom);
+	cView.define_method("capture=", set_capture);
+	cView.define_method("capture",  get_capture);
+	cView.define_method("clip=", set_clip);
+	cView.define_method("clip?", get_clip);
+	cView.define_method("cache=", set_cache);
+	cView.define_method("cache?", get_cache);
+	cView.define_method("resize_to_fit=", set_resize_to_fit);
+	cView.define_method("resize_to_fit?", get_resize_to_fit);
+	cView.define_method("scroll_to_fit=", set_scroll_to_fit);
+	cView.define_method("scroll_to_fit?", get_scroll_to_fit);
 	cView.define_method("parent", parent);
 	cView.define_method("window", window);
-	cView.define_method("body", body);
+
+	cView.define_method("apply_force",           apply_force);
+	cView.define_method("apply_torque",          apply_torque);
+	cView.define_method("apply_linear_impulse",  apply_linear_impulse);
+	cView.define_method("apply_angular_impulse", apply_angular_impulse);
+	cView.define_method("static=",  set_static);
+	cView.define_method("static?",   is_static);
+	cView.define_method("dynamic=", set_dynamic);
+	cView.define_method("dynamic?",  is_dynamic);
+	cView.define_method("density=",     set_density);
+	cView.define_method("density",      get_density);
+	cView.define_method("friction=",    set_friction);
+	cView.define_method("friction",     get_friction);
+	cView.define_method("restitution=", set_restitution);
+	cView.define_method("restitution",  get_restitution);
+	cView.define_method("sensor=",      set_sensor);
+	cView.define_method("sensor?",       is_sensor);
+	cView.define_private_method("set_category_bits",  set_category_bits);
+	cView.define_private_method("get_category_bits",  get_category_bits);
+	cView.define_private_method("set_collision_mask", set_collision_mask);
+	cView.define_private_method("get_collision_mask", get_collision_mask);
+	cView.define_method("linear_velocity=",  set_linear_velocity);
+	cView.define_method("linear_velocity",   get_linear_velocity);
+	cView.define_method("angular_velocity=", set_angular_velocity);
+	cView.define_method("angular_velocity",  get_angular_velocity);
+	cView.define_method("gravity_scale=", set_gravity_scale);
+	cView.define_method("gravity_scale",  get_gravity_scale);
+
+	cView.define_method("update_physics", update_physics);
 	cView.define_method("meter2pixel", meter2pixel);
-	cView.define_method("set_gravity", set_gravity);
-	cView.define_method("gravity",     get_gravity);
+	cView.define_method("gravity=", set_gravity);
+	cView.define_method("gravity",  get_gravity);
+	cView.define_method("time_scale=", set_time_scale);
+	cView.define_method("time_scale",  get_time_scale);
 	cView.define_method("wall", wall);
 	cView.define_method("debug=", set_debug);
-	cView.define_method("debug?",     debugging);
+	cView.define_method("debug?", get_debug);
+
 	cView.define_method("on_attach", on_attach);
 	cView.define_method("on_detach", on_detach);
 	cView.define_method("on_show", on_show);
@@ -755,7 +1197,6 @@ Init_view ()
 	cView.define_method("on_rotate", on_rotate);
 	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);
@@ -765,14 +1206,17 @@ Init_view ()
 	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_method("on_contact",       on_contact);
-	cView.define_method("on_contact_begin", on_contact_begin);
-	cView.define_method("on_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);
-	cView.define_clear_override_flags(cof);
+	cView.define_method("on_timer", on_timer);
+	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);
 }