reflexion 0.1.10 → 0.1.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2bbd862d88e6ae5162205e9b1656a23ce6f62a70
-  data.tar.gz: 48e9ec4d9ee31e1edc662d7fe7e17e134a2024af
+  metadata.gz: bdaed8fe443916ffe6273ee2ae4938dd97afe3a5
+  data.tar.gz: b9eeb656bae9a1f91089fccc1c4a31adc892a1fb
 SHA512:
-  metadata.gz: 5b8d6a218d4844bcda3f1faa9c6319c9708de00950e9d485e889ab43b184391ae4b13ead28b298942479de9f06c1a8c7c7d7cf9ec3b784a1ab51299a824024de
-  data.tar.gz: fe2306dac1b6d79b2e73848948392e82ad4ab9e65de34d50a6f0c38dcd597b2236dc8992b3a55d3e7e062f48c9f7cc483f1b87d9e9ce30ec9defb212dd8a30ae
+  metadata.gz: a3fc6b52f80e75dc7d4e43cb72de7c02af376da86264da9f279b7c23e8979bf98a1ebd62d684e6607e96e734d102bd1249887109d879f29ad79e49b81373cece
+  data.tar.gz: e3e178432bb7fb6dfca698e8d18038f70f1bc4821042598274973971449e6558a442906f37625164b2214e1996bf0b8b080e4856503bf5bdce0a5ee7fc69a663

data/.doc/ext/reflex/body.cpp

@@ -140,6 +140,38 @@ VALUE get_angular_velocity(VALUE self)
 	return value(THIS->angular_velocity());
 }
 
+static
+VALUE apply_force(VALUE self, VALUE force)
+{
+	CHECK;
+	THIS->apply_force(to<Rays::Point&>(force));
+	return self;
+}
+
+static
+VALUE apply_torque(VALUE self, VALUE torque)
+{
+	CHECK;
+	THIS->apply_torque(torque.as_f(true));
+	return self;
+}
+
+static
+VALUE apply_linear_impulse(VALUE self, VALUE impulse)
+{
+	CHECK;
+	THIS->apply_linear_impulse(to<Rays::Point&>(impulse));
+	return self;
+}
+
+static
+VALUE apply_angular_impulse(VALUE self, VALUE impulse)
+{
+	CHECK;
+	THIS->apply_angular_impulse(impulse.as_f(true));
+	return self;
+}
+
 static
 VALUE set_density(VALUE self, VALUE density)
 {
@@ -185,6 +217,21 @@ VALUE get_restitution(VALUE self)
 	return value(THIS->restitution());
 }
 
+static
+VALUE set_gravity_scale(VALUE self, VALUE scale)
+{
+	CHECK;
+	THIS->set_gravity_scale(scale.as_f(true));
+	return self;
+}
+
+static
+VALUE get_gravity_scale(VALUE self)
+{
+	CHECK;
+	return value(THIS->gravity_scale());
+}
+
 static
 VALUE each(VALUE self)
 {
@@ -222,12 +269,18 @@ Init_body ()
 	rb_define_method(cBody, "linear_velocity", RUBY_METHOD_FUNC(get_linear_velocity), 0);
 	rb_define_method(cBody, "angular_velocity=", RUBY_METHOD_FUNC(set_angular_velocity), 1);
 	rb_define_method(cBody, "angular_velocity", RUBY_METHOD_FUNC(get_angular_velocity), 0);
+	rb_define_method(cBody, "apply_force", RUBY_METHOD_FUNC(apply_force), 1);
+	rb_define_method(cBody, "apply_torque", RUBY_METHOD_FUNC(apply_torque), 1);
+	rb_define_method(cBody, "apply_linear_impulse", RUBY_METHOD_FUNC(apply_linear_impulse), 1);
+	rb_define_method(cBody, "apply_angular_impulse", RUBY_METHOD_FUNC(apply_angular_impulse), 1);
 	rb_define_method(cBody, "density=", RUBY_METHOD_FUNC(set_density), 1);
 	rb_define_method(cBody, "density", RUBY_METHOD_FUNC(get_density), 0);
 	rb_define_method(cBody, "friction=", RUBY_METHOD_FUNC(set_friction), 1);
 	rb_define_method(cBody, "friction", RUBY_METHOD_FUNC(get_friction), 0);
 	rb_define_method(cBody, "restitution=", RUBY_METHOD_FUNC(set_restitution), 1);
 	rb_define_method(cBody, "restitution", RUBY_METHOD_FUNC(get_restitution), 0);
+	rb_define_method(cBody, "gravity_scale=", RUBY_METHOD_FUNC(set_gravity_scale), 1);
+	rb_define_method(cBody, "gravity_scale", RUBY_METHOD_FUNC(get_gravity_scale), 0);
 	rb_define_method(cBody, "each", RUBY_METHOD_FUNC(each), 0);
 }
 

data/.doc/ext/reflex/native.cpp

@@ -10,8 +10,6 @@ void Init_reflex ();
 void Init_selector ();
 void Init_style ();
 void Init_style_length ();
-void Init_style_length2 ();
-void Init_style_length4 ();
 
 void Init_event ();
 void Init_update_event ();
@@ -56,8 +54,6 @@ extern "C" void
 	Init_selector();
 	Init_style();
 	Init_style_length();
-	Init_style_length2();
-	Init_style_length4();
 
 	Init_event();
 	Init_update_event();

data/.doc/ext/reflex/selector.cpp

@@ -70,10 +70,10 @@ VALUE each_tag(VALUE self)
 }
 
 static
-VALUE match(VALUE self, VALUE selector)
+VALUE contains(VALUE self, VALUE selector)
 {
 	CHECK;
-	return value(THIS->match(to<Reflex::Selector&>(selector)));
+	return value(THIS->contains(to<Reflex::Selector&>(selector)));
 }
 
 static
@@ -99,7 +99,7 @@ Init_selector ()
 	rb_define_method(cSelector, "add_tag", RUBY_METHOD_FUNC(add_tag), 1);
 	rb_define_method(cSelector, "remove_tag", RUBY_METHOD_FUNC(remove_tag), 1);
 	rb_define_method(cSelector, "each_tag", RUBY_METHOD_FUNC(each_tag), 0);
-	rb_define_method(cSelector, "match", RUBY_METHOD_FUNC(match), 1);
+	rb_define_method(cSelector, "contains", RUBY_METHOD_FUNC(contains), 1);
 	cSelector.define_method("==", equal);
 }
 

data/.doc/ext/reflex/style.cpp

@@ -5,7 +5,6 @@
 #include "rays/ruby/color.h"
 #include "rays/ruby/image.h"
 #include "reflex/ruby/selector.h"
-#include "reflex/ruby/style_length.h"
 #include "defs.h"
 
 
@@ -94,7 +93,7 @@ VALUE set_flow(VALUE self)
 	check_arg_count(__FILE__, __LINE__, "Style#set_flow", argc, 1, 2);
 
 	THIS->set_flow(
-		argc >= 1 ? (Reflex::Style::Flow) argv[0].as_i() : Reflex::Style::FLOW_DOWN,
+		(Reflex::Style::Flow) argv[0].as_i(),
 		argc >= 2 ? (Reflex::Style::Flow) argv[1].as_i() : Reflex::Style::FLOW_NONE);
 }
 
@@ -108,87 +107,398 @@ VALUE get_flow(VALUE self)
 }
 
 static
-VALUE set_size(VALUE self, VALUE size)
+VALUE set_width(VALUE self, VALUE width)
 {
 	CHECK;
-	THIS->set_size(to<Reflex::StyleLength2>(size));
+	THIS->set_width(to<Reflex::StyleLength>(width));
+}
+
+static
+VALUE get_width(VALUE self)
+{
+	CHECK;
+	return value(THIS->width());
+}
+
+static
+VALUE set_height(VALUE self, VALUE height)
+{
+	CHECK;
+	THIS->set_height(to<Reflex::StyleLength>(height));
+}
+
+static
+VALUE get_height(VALUE self)
+{
+	CHECK;
+	return value(THIS->height());
+}
+
+static
+VALUE set_size(VALUE self)
+{
+	CHECK;
+	check_arg_count(__FILE__, __LINE__, "Style#set_size", argc, 1, 2);
+
+	set_width (self, argv[0]);
+	set_height(self, argc >= 2 ? argv[1] : argv[0]);
 }
 
 static
 VALUE get_size(VALUE self)
 {
 	CHECK;
-	return value(THIS->size());
+	return array(get_width(self), get_height(self));
 }
 
 static
-VALUE set_position(VALUE self, VALUE position)
+VALUE set_left(VALUE self, VALUE left)
 {
 	CHECK;
-	THIS->set_position(to<Reflex::StyleLength4>(position));
+	THIS->set_left(to<Reflex::StyleLength>(left));
+}
+
+static
+VALUE get_left(VALUE self)
+{
+	CHECK;
+	return value(THIS->left());
+}
+
+static
+VALUE set_top(VALUE self, VALUE top)
+{
+	CHECK;
+	THIS->set_top(to<Reflex::StyleLength>(top));
+}
+
+static
+VALUE get_top(VALUE self)
+{
+	CHECK;
+	return value(THIS->top());
+}
+
+static
+VALUE set_right(VALUE self, VALUE right)
+{
+	CHECK;
+	THIS->set_right(to<Reflex::StyleLength>(right));
+}
+
+static
+VALUE get_right(VALUE self)
+{
+	CHECK;
+	return value(THIS->right());
+}
+
+static
+VALUE set_bottom(VALUE self, VALUE bottom)
+{
+	CHECK;
+	THIS->set_bottom(to<Reflex::StyleLength>(bottom));
+}
+
+static
+VALUE get_bottom(VALUE self)
+{
+	CHECK;
+	return value(THIS->bottom());
+}
+
+static
+VALUE set_position(VALUE self, VALUE left, VALUE top, VALUE right, VALUE bottom)
+{
+	CHECK;
+	set_left  (self, left);
+	set_top   (self, top);
+	set_right (self, right);
+	set_bottom(self, bottom);
 }
 
 static
 VALUE get_position(VALUE self)
 {
 	CHECK;
-	return value(THIS->position());
+	return array(
+		get_left(self),
+		get_top(self),
+		get_right(self),
+		get_bottom(self));
+}
+
+static
+VALUE set_offset_left(VALUE self, VALUE left)
+{
+	CHECK;
+	THIS->set_offset_left(to<Reflex::StyleLength>(left));
+}
+
+static
+VALUE get_offset_left(VALUE self)
+{
+	CHECK;
+	return value(THIS->offset_left());
+}
+
+static
+VALUE set_offset_top(VALUE self, VALUE top)
+{
+	CHECK;
+	THIS->set_offset_top(to<Reflex::StyleLength>(top));
+}
+
+static
+VALUE get_offset_top(VALUE self)
+{
+	CHECK;
+	return value(THIS->offset_top());
+}
+
+static
+VALUE set_offset_right(VALUE self, VALUE right)
+{
+	CHECK;
+	THIS->set_offset_right(to<Reflex::StyleLength>(right));
+}
+
+static
+VALUE get_offset_right(VALUE self)
+{
+	CHECK;
+	return value(THIS->offset_right());
+}
+
+static
+VALUE set_offset_bottom(VALUE self, VALUE bottom)
+{
+	CHECK;
+	THIS->set_offset_bottom(to<Reflex::StyleLength>(bottom));
+}
+
+static
+VALUE get_offset_bottom(VALUE self)
+{
+	CHECK;
+	return value(THIS->offset_bottom());
+}
+
+static
+VALUE set_offset(VALUE self, VALUE left, VALUE top, VALUE right, VALUE bottom)
+{
+	CHECK;
+	set_offset_left  (self, left);
+	set_offset_top   (self, top);
+	set_offset_right (self, right);
+	set_offset_bottom(self, bottom);
+}
+
+static
+VALUE get_offset(VALUE self)
+{
+	CHECK;
+	return array(
+		get_offset_left(self),
+		get_offset_top(self),
+		get_offset_right(self),
+		get_offset_bottom(self));
+}
+
+static
+VALUE set_margin_left(VALUE self, VALUE left)
+{
+	CHECK;
+	THIS->set_margin_left(to<Reflex::StyleLength>(left));
 }
 
 static
-VALUE set_margin(VALUE self, VALUE margin)
+VALUE get_margin_left(VALUE self)
 {
 	CHECK;
-	THIS->set_margin(to<Reflex::StyleLength4>(margin));
+	return value(THIS->margin_left());
+}
+
+static
+VALUE set_margin_top(VALUE self, VALUE top)
+{
+	CHECK;
+	THIS->set_margin_top(to<Reflex::StyleLength>(top));
+}
+
+static
+VALUE get_margin_top(VALUE self)
+{
+	CHECK;
+	return value(THIS->margin_top());
+}
+
+static
+VALUE set_margin_right(VALUE self, VALUE right)
+{
+	CHECK;
+	THIS->set_margin_right(to<Reflex::StyleLength>(right));
+}
+
+static
+VALUE get_margin_right(VALUE self)
+{
+	CHECK;
+	return value(THIS->margin_right());
+}
+
+static
+VALUE set_margin_bottom(VALUE self, VALUE bottom)
+{
+	CHECK;
+	THIS->set_margin_bottom(to<Reflex::StyleLength>(bottom));
+}
+
+static
+VALUE get_margin_bottom(VALUE self)
+{
+	CHECK;
+	return value(THIS->margin_bottom());
+}
+
+static
+VALUE set_margin(VALUE self, VALUE left, VALUE top, VALUE right, VALUE bottom)
+{
+	CHECK;
+	set_margin_left  (self, left);
+	set_margin_top   (self, top);
+	set_margin_right (self, right);
+	set_margin_bottom(self, bottom);
 }
 
 static
 VALUE get_margin(VALUE self)
 {
 	CHECK;
-	return value(THIS->margin());
+	return array(
+		get_margin_left(self),
+		get_margin_top(self),
+		get_margin_right(self),
+		get_margin_bottom(self));
 }
 
 static
-VALUE set_padding(VALUE self, VALUE padding)
+VALUE set_padding_left(VALUE self, VALUE left)
 {
 	CHECK;
-	THIS->set_padding(to<Reflex::StyleLength4>(padding));
+	THIS->set_padding_left(to<Reflex::StyleLength>(left));
+}
+
+static
+VALUE get_padding_left(VALUE self)
+{
+	CHECK;
+	return value(THIS->padding_left());
+}
+
+static
+VALUE set_padding_top(VALUE self, VALUE top)
+{
+	CHECK;
+	THIS->set_padding_top(to<Reflex::StyleLength>(top));
+}
+
+static
+VALUE get_padding_top(VALUE self)
+{
+	CHECK;
+	return value(THIS->padding_top());
+}
+
+static
+VALUE set_padding_right(VALUE self, VALUE right)
+{
+	CHECK;
+	THIS->set_padding_right(to<Reflex::StyleLength>(right));
+}
+
+static
+VALUE get_padding_right(VALUE self)
+{
+	CHECK;
+	return value(THIS->padding_right());
+}
+
+static
+VALUE set_padding_bottom(VALUE self, VALUE bottom)
+{
+	CHECK;
+	THIS->set_padding_bottom(to<Reflex::StyleLength>(bottom));
+}
+
+static
+VALUE get_padding_bottom(VALUE self)
+{
+	CHECK;
+	return value(THIS->padding_bottom());
+}
+
+static
+VALUE set_padding(VALUE self, VALUE left, VALUE top, VALUE right, VALUE bottom)
+{
+	CHECK;
+	set_padding_left  (self, left);
+	set_padding_top   (self, top);
+	set_padding_right (self, right);
+	set_padding_bottom(self, bottom);
 }
 
 static
 VALUE get_padding(VALUE self)
 {
 	CHECK;
-	return value(THIS->padding());
+	return array(
+		get_padding_left(self),
+		get_padding_top(self),
+		get_padding_right(self),
+		get_padding_bottom(self));
+}
+
+static
+VALUE set_fill(VALUE self, VALUE color)
+{
+	CHECK;
+	THIS->set_fill(to<Reflex::Color&>(color));
+}
+
+static
+VALUE get_fill(VALUE self)
+{
+	CHECK;
+	return value(THIS->fill());
 }
 
 static
-VALUE set_background_color(VALUE self, VALUE color)
+VALUE set_stroke(VALUE self, VALUE color)
 {
 	CHECK;
-	THIS->set_background_color(to<Reflex::Color&>(color));
+	THIS->set_stroke(to<Reflex::Color&>(color));
 }
 
 static
-VALUE get_background_color(VALUE self)
+VALUE get_stroke(VALUE self)
 {
 	CHECK;
-	return value(THIS->background_color());
+	return value(THIS->stroke());
 }
 
 static
-VALUE set_background_image(VALUE self, VALUE image)
+VALUE set_image(VALUE self, VALUE image)
 {
 	CHECK;
-	THIS->set_background_image(to<Reflex::Image&>(image));
+	THIS->set_image(to<Reflex::Image&>(image));
 }
 
 static
-VALUE get_background_image(VALUE self)
+VALUE get_image(VALUE self)
 {
 	CHECK;
-	return THIS->background_image() ? value(THIS->background_image()) : nil();
+	return THIS->image() ? value(THIS->image()) : nil();
 }
 
 static
@@ -209,6 +519,7 @@ Init_style ()
 	cStyle = rb_define_class_under(mReflex, "Style", rb_cObject);
 	rb_define_alloc_func(cStyle, alloc);
 	rb_define_private_method(cStyle, "initialize_copy", RUBY_METHOD_FUNC(initialize_copy), 1);
+
 	rb_define_method(cStyle, "name=", RUBY_METHOD_FUNC(set_name), 1);
 	rb_define_method(cStyle, "name", RUBY_METHOD_FUNC(get_name), 0);
 	rb_define_method(cStyle, "add_tag", RUBY_METHOD_FUNC(add_tag), 1);
@@ -216,20 +527,69 @@ Init_style ()
 	rb_define_method(cStyle, "each_tag", RUBY_METHOD_FUNC(each_tag), 0);
 	rb_define_method(cStyle, "selector=", RUBY_METHOD_FUNC(set_selector), 1);
 	rb_define_method(cStyle, "selector", RUBY_METHOD_FUNC(get_selector), 0);
+
 	rb_define_method(cStyle, "set_flow", RUBY_METHOD_FUNC(set_flow), -1);
 	rb_define_method(cStyle, "get_flow", RUBY_METHOD_FUNC(get_flow), 0);
-	rb_define_method(cStyle, "size=", RUBY_METHOD_FUNC(set_size), 1);
+
+	rb_define_method(cStyle, "width=", RUBY_METHOD_FUNC(set_width), 1);
+	rb_define_method(cStyle, "width", RUBY_METHOD_FUNC(get_width), 0);
+	rb_define_method(cStyle, "height=", RUBY_METHOD_FUNC(set_height), 1);
+	rb_define_method(cStyle, "height", RUBY_METHOD_FUNC(get_height), 0);
+	rb_define_method(cStyle, "size=", RUBY_METHOD_FUNC(set_size), -1);
 	rb_define_method(cStyle, "size", RUBY_METHOD_FUNC(get_size), 0);
-	rb_define_method(cStyle, "position=", RUBY_METHOD_FUNC(set_position), 1);
+
+	rb_define_method(cStyle, "left=", RUBY_METHOD_FUNC(set_left), 1);
+	rb_define_method(cStyle, "left", RUBY_METHOD_FUNC(get_left), 0);
+	rb_define_method(cStyle, "top=", RUBY_METHOD_FUNC(set_top), 1);
+	rb_define_method(cStyle, "top", RUBY_METHOD_FUNC(get_top), 0);
+	rb_define_method(cStyle, "right=", RUBY_METHOD_FUNC(set_right), 1);
+	rb_define_method(cStyle, "right", RUBY_METHOD_FUNC(get_right), 0);
+	rb_define_method(cStyle, "bottom=", RUBY_METHOD_FUNC(set_bottom), 1);
+	rb_define_method(cStyle, "bottom", RUBY_METHOD_FUNC(get_bottom), 0);
+	rb_define_method(cStyle, "position=", RUBY_METHOD_FUNC(set_position), 4);
 	rb_define_method(cStyle, "position", RUBY_METHOD_FUNC(get_position), 0);
-	rb_define_method(cStyle, "margin=", RUBY_METHOD_FUNC(set_margin), 1);
+
+	rb_define_method(cStyle, "offset_left=", RUBY_METHOD_FUNC(set_offset_left), 1);
+	rb_define_method(cStyle, "offset_left", RUBY_METHOD_FUNC(get_offset_left), 0);
+	rb_define_method(cStyle, "offset_top=", RUBY_METHOD_FUNC(set_offset_top), 1);
+	rb_define_method(cStyle, "offset_top", RUBY_METHOD_FUNC(get_offset_top), 0);
+	rb_define_method(cStyle, "offset_right=", RUBY_METHOD_FUNC(set_offset_right), 1);
+	rb_define_method(cStyle, "offset_right", RUBY_METHOD_FUNC(get_offset_right), 0);
+	rb_define_method(cStyle, "offset_bottom=", RUBY_METHOD_FUNC(set_offset_bottom), 1);
+	rb_define_method(cStyle, "offset_bottom", RUBY_METHOD_FUNC(get_offset_bottom), 0);
+	rb_define_method(cStyle, "offset=", RUBY_METHOD_FUNC(set_offset), 4);
+	rb_define_method(cStyle, "offset", RUBY_METHOD_FUNC(get_offset), 0);
+
+	rb_define_method(cStyle, "margin_left=", RUBY_METHOD_FUNC(set_margin_left), 1);
+	rb_define_method(cStyle, "margin_left", RUBY_METHOD_FUNC(get_margin_left), 0);
+	rb_define_method(cStyle, "margin_top=", RUBY_METHOD_FUNC(set_margin_top), 1);
+	rb_define_method(cStyle, "margin_top", RUBY_METHOD_FUNC(get_margin_top), 0);
+	rb_define_method(cStyle, "margin_right=", RUBY_METHOD_FUNC(set_margin_right), 1);
+	rb_define_method(cStyle, "margin_right", RUBY_METHOD_FUNC(get_margin_right), 0);
+	rb_define_method(cStyle, "margin_bottom=", RUBY_METHOD_FUNC(set_margin_bottom), 1);
+	rb_define_method(cStyle, "margin_bottom", RUBY_METHOD_FUNC(get_margin_bottom), 0);
+	rb_define_method(cStyle, "margin=", RUBY_METHOD_FUNC(set_margin), 4);
 	rb_define_method(cStyle, "margin", RUBY_METHOD_FUNC(get_margin), 0);
-	rb_define_method(cStyle, "padding=", RUBY_METHOD_FUNC(set_padding), 1);
+
+	rb_define_method(cStyle, "padding_left=", RUBY_METHOD_FUNC(set_padding_left), 1);
+	rb_define_method(cStyle, "padding_left", RUBY_METHOD_FUNC(get_padding_left), 0);
+	rb_define_method(cStyle, "padding_top=", RUBY_METHOD_FUNC(set_padding_top), 1);
+	rb_define_method(cStyle, "padding_top", RUBY_METHOD_FUNC(get_padding_top), 0);
+	rb_define_method(cStyle, "padding_right=", RUBY_METHOD_FUNC(set_padding_right), 1);
+	rb_define_method(cStyle, "padding_right", RUBY_METHOD_FUNC(get_padding_right), 0);
+	rb_define_method(cStyle, "padding_bottom=", RUBY_METHOD_FUNC(set_padding_bottom), 1);
+	rb_define_method(cStyle, "padding_bottom", RUBY_METHOD_FUNC(get_padding_bottom), 0);
+	rb_define_method(cStyle, "padding=", RUBY_METHOD_FUNC(set_padding), 4);
 	rb_define_method(cStyle, "padding", RUBY_METHOD_FUNC(get_padding), 0);
-	rb_define_method(cStyle, "background_color=", RUBY_METHOD_FUNC(set_background_color), 1);
-	rb_define_method(cStyle, "background_color", RUBY_METHOD_FUNC(get_background_color), 0);
-	rb_define_method(cStyle, "background_image=", RUBY_METHOD_FUNC(set_background_image), 1);
-	rb_define_method(cStyle, "background_image", RUBY_METHOD_FUNC(get_background_image), 0);
+
+	rb_define_method(cStyle, "fill=", RUBY_METHOD_FUNC(set_fill), 1);
+	rb_define_method(cStyle, "fill", RUBY_METHOD_FUNC(get_fill), 0);
+	rb_define_method(cStyle, "stroke=", RUBY_METHOD_FUNC(set_stroke), 1);
+	rb_define_method(cStyle, "stroke", RUBY_METHOD_FUNC(get_stroke), 0);
+
+	rb_define_method(cStyle, "image=", RUBY_METHOD_FUNC(set_image), 1);
+	rb_define_method(cStyle, "image", RUBY_METHOD_FUNC(get_image), 0);
+
 	cStyle.define_method("==", equal);
 	cStyle.define_const("FLOW_NONE",  Reflex::Style::FLOW_NONE);
 	cStyle.define_const("FLOW_DOWN",  Reflex::Style::FLOW_DOWN);