reflexion 0.1.12 → 0.1.13

data/ext/reflex/style.cpp

@@ -1,21 +1,19 @@
 #include "reflex/ruby/style.h"
 
 
-#include <rucy.h>
 #include "rays/ruby/color.h"
 #include "rays/ruby/image.h"
 #include "reflex/ruby/selector.h"
 #include "defs.h"
-
-
-using namespace Rucy;
+#include "selector.h"
 
 
 RUCY_DEFINE_VALUE_FROM_TO(Reflex::Style)
 
-#define THIS  to<Reflex::Style*>(self)
+#define   THIS to<      Reflex::Style*>(self)
+#define C_THIS to<const Reflex::Style*>(self)
 
-#define CHECK RUCY_CHECK_OBJ(Reflex::Style, self)
+#define CHECK  RUCY_CHECK_OBJ(Reflex::Style, self)
 
 
 static
@@ -34,76 +32,27 @@ RUCY_DEF1(initialize_copy, obj)
 }
 RUCY_END
 
-static
-RUCY_DEF1(set_name, name)
-{
-	CHECK;
-	THIS->set_name(name.is_nil() ? NULL : name.c_str());
-}
-RUCY_END
-
-static
-RUCY_DEF0(get_name)
-{
-	CHECK;
-	return THIS->name() ? value(THIS->name()) : nil();
-}
-RUCY_END
-
-static
-RUCY_DEF1(add_tag, tag)
-{
-	CHECK;
-	THIS->add_tag(tag.c_str());
-}
-RUCY_END
-
-static
-RUCY_DEF1(remove_tag, tag)
-{
-	CHECK;
-	THIS->remove_tag(tag.c_str());
-}
-RUCY_END
-
-static
-RUCY_DEF0(each_tag)
-{
-	CHECK;
-
-	Value ret;
-	Reflex::Style::tag_iterator end = THIS->tag_end();
-	for (Reflex::Style::tag_iterator it = THIS->tag_begin(); it != end; ++it)
-		ret = rb_yield(value(*it));
-	return ret;
-}
-RUCY_END
-
-static
-RUCY_DEF1(set_selector, selector)
-{
-	CHECK;
-	THIS->set_selector(to<Reflex::Selector>(selector));
-}
-RUCY_END
-
-static
-RUCY_DEF0(get_selector)
-{
-	CHECK;
-	return value(THIS->selector());
-}
-RUCY_END
-
 static
 RUCY_DEFN(set_flow)
 {
 	CHECK;
 	check_arg_count(__FILE__, __LINE__, "Style#set_flow", argc, 1, 2);
 
-	THIS->set_flow(
-		(Reflex::Style::Flow) argv[0].as_i(),
-		argc >= 2 ? (Reflex::Style::Flow) argv[1].as_i() : Reflex::Style::FLOW_NONE);
+	if (argv[0].is_nil())
+	{
+		if (argc >= 2 && !argv[1].is_nil())
+			argument_error(__FILE__, __LINE__);
+
+		THIS->clear_flow();
+	}
+	else
+	{
+		THIS->set_flow(
+			(Reflex::Style::Flow) to<int>(argv[0]),
+			argc >= 2 ? (Reflex::Style::Flow) to<int>(argv[1]) : Reflex::Style::FLOW_NONE);
+	}
+
+	return value(argc, argv);
 }
 RUCY_END
 
@@ -111,6 +60,7 @@ static
 RUCY_DEF0(get_flow)
 {
 	CHECK;
+
 	Reflex::Style::Flow main, sub;
 	THIS->get_flow(&main, &sub);
 	return array(main, sub);
@@ -121,7 +71,13 @@ static
 RUCY_DEF1(set_width, width)
 {
 	CHECK;
-	THIS->set_width(to<Reflex::StyleLength>(width));
+
+	if (width.is_nil())
+		THIS->clear_width();
+	else
+		THIS->set_width(to<Reflex::StyleLength>(width));
+
+	return width;
 }
 RUCY_END
 
@@ -137,7 +93,13 @@ static
 RUCY_DEF1(set_height, height)
 {
 	CHECK;
-	THIS->set_height(to<Reflex::StyleLength>(height));
+
+	if (height.is_nil())
+		THIS->clear_height();
+	else
+		THIS->set_height(to<Reflex::StyleLength>(height));
+
+	return height;
 }
 RUCY_END
 
@@ -155,8 +117,10 @@ RUCY_DEFN(set_size)
 	CHECK;
 	check_arg_count(__FILE__, __LINE__, "Style#set_size", argc, 1, 2);
 
-	set_width (self, argv[0]);
+	set_width( self, argv[0]);
 	set_height(self, argc >= 2 ? argv[1] : argv[0]);
+
+	return value(argc, argv);
 }
 RUCY_END
 
@@ -164,7 +128,9 @@ static
 RUCY_DEF0(get_size)
 {
 	CHECK;
-	return array(get_width(self), get_height(self));
+	return array(
+		get_width(self),
+		get_height(self));
 }
 RUCY_END
 
@@ -172,7 +138,13 @@ static
 RUCY_DEF1(set_left, left)
 {
 	CHECK;
-	THIS->set_left(to<Reflex::StyleLength>(left));
+
+	if (left.is_nil())
+		THIS->clear_left();
+	else
+		THIS->set_left(to<Reflex::StyleLength>(left));
+
+	return left;
 }
 RUCY_END
 
@@ -188,7 +160,13 @@ static
 RUCY_DEF1(set_top, top)
 {
 	CHECK;
-	THIS->set_top(to<Reflex::StyleLength>(top));
+
+	if (top.is_nil())
+		THIS->clear_top();
+	else
+		THIS->set_top(to<Reflex::StyleLength>(top));
+
+	return top;
 }
 RUCY_END
 
@@ -204,7 +182,13 @@ static
 RUCY_DEF1(set_right, right)
 {
 	CHECK;
-	THIS->set_right(to<Reflex::StyleLength>(right));
+
+	if (right.is_nil())
+		THIS->clear_right();
+	else
+		THIS->set_right(to<Reflex::StyleLength>(right));
+
+	return right;
 }
 RUCY_END
 
@@ -220,7 +204,13 @@ static
 RUCY_DEF1(set_bottom, bottom)
 {
 	CHECK;
-	THIS->set_bottom(to<Reflex::StyleLength>(bottom));
+
+	if (bottom.is_nil())
+		THIS->clear_bottom();
+	else
+		THIS->set_bottom(to<Reflex::StyleLength>(bottom));
+
+	return bottom;
 }
 RUCY_END
 
@@ -236,10 +226,13 @@ static
 RUCY_DEF4(set_position, left, top, right, bottom)
 {
 	CHECK;
-	set_left  (self, left);
-	set_top   (self, top);
-	set_right (self, right);
+
+	set_left(  self, left);
+	set_top(   self, top);
+	set_right( self, right);
 	set_bottom(self, bottom);
+
+	return array(left, top, right, bottom);
 }
 RUCY_END
 
@@ -256,295 +249,468 @@ RUCY_DEF0(get_position)
 RUCY_END
 
 static
-RUCY_DEF1(set_offset_left, left)
+RUCY_DEF1(set_margin_left, left)
 {
 	CHECK;
-	THIS->set_offset_left(to<Reflex::StyleLength>(left));
+
+	if (left.is_nil())
+		THIS->clear_margin_left();
+	else
+		THIS->set_margin_left(to<Reflex::StyleLength>(left));
+
+	return left;
 }
 RUCY_END
 
 static
-RUCY_DEF0(get_offset_left)
+RUCY_DEF0(get_margin_left)
 {
 	CHECK;
-	return value(THIS->offset_left());
+	return value(THIS->margin_left());
 }
 RUCY_END
 
 static
-RUCY_DEF1(set_offset_top, top)
+RUCY_DEF1(set_margin_top, top)
 {
 	CHECK;
-	THIS->set_offset_top(to<Reflex::StyleLength>(top));
+
+	if (top.is_nil())
+		THIS->clear_margin_top();
+	else
+		THIS->set_margin_top(to<Reflex::StyleLength>(top));
+
+	return top;
 }
 RUCY_END
 
 static
-RUCY_DEF0(get_offset_top)
+RUCY_DEF0(get_margin_top)
 {
 	CHECK;
-	return value(THIS->offset_top());
+	return value(THIS->margin_top());
 }
 RUCY_END
 
 static
-RUCY_DEF1(set_offset_right, right)
+RUCY_DEF1(set_margin_right, right)
 {
 	CHECK;
-	THIS->set_offset_right(to<Reflex::StyleLength>(right));
+
+	if (right.is_nil())
+		THIS->clear_margin_right();
+	else
+		THIS->set_margin_right(to<Reflex::StyleLength>(right));
+
+	return right;
 }
 RUCY_END
 
 static
-RUCY_DEF0(get_offset_right)
+RUCY_DEF0(get_margin_right)
 {
 	CHECK;
-	return value(THIS->offset_right());
+	return value(THIS->margin_right());
 }
 RUCY_END
 
 static
-RUCY_DEF1(set_offset_bottom, bottom)
+RUCY_DEF1(set_margin_bottom, bottom)
 {
 	CHECK;
-	THIS->set_offset_bottom(to<Reflex::StyleLength>(bottom));
+
+	if (bottom.is_nil())
+		THIS->clear_margin_bottom();
+	else
+		THIS->set_margin_bottom(to<Reflex::StyleLength>(bottom));
+
+	return bottom;
 }
 RUCY_END
 
 static
-RUCY_DEF0(get_offset_bottom)
+RUCY_DEF0(get_margin_bottom)
 {
 	CHECK;
-	return value(THIS->offset_bottom());
+	return value(THIS->margin_bottom());
 }
 RUCY_END
 
 static
-RUCY_DEF4(set_offset, left, top, right, bottom)
+RUCY_DEF4(set_margin, left, top, right, bottom)
 {
 	CHECK;
-	set_offset_left  (self, left);
-	set_offset_top   (self, top);
-	set_offset_right (self, right);
-	set_offset_bottom(self, bottom);
+
+	set_margin_left(  self, left);
+	set_margin_top(   self, top);
+	set_margin_right( self, right);
+	set_margin_bottom(self, bottom);
+
+	return array(left, top, right, bottom);
 }
 RUCY_END
 
 static
-RUCY_DEF0(get_offset)
+RUCY_DEF0(get_margin)
 {
 	CHECK;
 	return array(
-		get_offset_left(self),
-		get_offset_top(self),
-		get_offset_right(self),
-		get_offset_bottom(self));
+		get_margin_left(self),
+		get_margin_top(self),
+		get_margin_right(self),
+		get_margin_bottom(self));
 }
 RUCY_END
 
 static
-RUCY_DEF1(set_margin_left, left)
+RUCY_DEF1(set_padding_left, left)
 {
 	CHECK;
-	THIS->set_margin_left(to<Reflex::StyleLength>(left));
+
+	if (left.is_nil())
+		THIS->clear_padding_left();
+	else
+		THIS->set_padding_left(to<Reflex::StyleLength>(left));
+
+	return left;
 }
 RUCY_END
 
 static
-RUCY_DEF0(get_margin_left)
+RUCY_DEF0(get_padding_left)
 {
 	CHECK;
-	return value(THIS->margin_left());
+	return value(THIS->padding_left());
 }
 RUCY_END
 
 static
-RUCY_DEF1(set_margin_top, top)
+RUCY_DEF1(set_padding_top, top)
 {
 	CHECK;
-	THIS->set_margin_top(to<Reflex::StyleLength>(top));
+
+	if (top.is_nil())
+		THIS->clear_padding_top();
+	else
+		THIS->set_padding_top(to<Reflex::StyleLength>(top));
+
+	return top;
 }
 RUCY_END
 
 static
-RUCY_DEF0(get_margin_top)
+RUCY_DEF0(get_padding_top)
 {
 	CHECK;
-	return value(THIS->margin_top());
+	return value(THIS->padding_top());
 }
 RUCY_END
 
 static
-RUCY_DEF1(set_margin_right, right)
+RUCY_DEF1(set_padding_right, right)
 {
 	CHECK;
-	THIS->set_margin_right(to<Reflex::StyleLength>(right));
+
+	if (right.is_nil())
+		THIS->clear_padding_right();
+	else
+		THIS->set_padding_right(to<Reflex::StyleLength>(right));
+
+	return right;
 }
 RUCY_END
 
 static
-RUCY_DEF0(get_margin_right)
+RUCY_DEF0(get_padding_right)
 {
 	CHECK;
-	return value(THIS->margin_right());
+	return value(THIS->padding_right());
 }
 RUCY_END
 
 static
-RUCY_DEF1(set_margin_bottom, bottom)
+RUCY_DEF1(set_padding_bottom, bottom)
 {
 	CHECK;
-	THIS->set_margin_bottom(to<Reflex::StyleLength>(bottom));
+
+	if (bottom.is_nil())
+		THIS->clear_padding_bottom();
+	else
+		THIS->set_padding_bottom(to<Reflex::StyleLength>(bottom));
+
+	return bottom;
 }
 RUCY_END
 
 static
-RUCY_DEF0(get_margin_bottom)
+RUCY_DEF0(get_padding_bottom)
 {
 	CHECK;
-	return value(THIS->margin_bottom());
+	return value(THIS->padding_bottom());
 }
 RUCY_END
 
 static
-RUCY_DEF4(set_margin, left, top, right, bottom)
+RUCY_DEF4(set_padding, left, top, right, bottom)
 {
 	CHECK;
-	set_margin_left  (self, left);
-	set_margin_top   (self, top);
-	set_margin_right (self, right);
-	set_margin_bottom(self, bottom);
+
+	set_padding_left(  self, left);
+	set_padding_top(   self, top);
+	set_padding_right( self, right);
+	set_padding_bottom(self, bottom);
+
+	return array(left, top, right, bottom);
 }
 RUCY_END
 
 static
-RUCY_DEF0(get_margin)
+RUCY_DEF0(get_padding)
 {
 	CHECK;
 	return array(
-		get_margin_left(self),
-		get_margin_top(self),
-		get_margin_right(self),
-		get_margin_bottom(self));
+		get_padding_left(self),
+		get_padding_top(self),
+		get_padding_right(self),
+		get_padding_bottom(self));
 }
 RUCY_END
 
 static
-RUCY_DEF1(set_padding_left, left)
+RUCY_DEF1(set_center_x, x)
 {
 	CHECK;
-	THIS->set_padding_left(to<Reflex::StyleLength>(left));
+
+	if (x.is_nil())
+		THIS->clear_center_x();
+	else
+		THIS->set_center_x(to<Reflex::StyleLength>(x));
+
+	return x;
 }
 RUCY_END
 
 static
-RUCY_DEF0(get_padding_left)
+RUCY_DEF0(get_center_x)
 {
 	CHECK;
-	return value(THIS->padding_left());
+	return value(THIS->center_x());
 }
 RUCY_END
 
 static
-RUCY_DEF1(set_padding_top, top)
+RUCY_DEF1(set_center_y, y)
 {
 	CHECK;
-	THIS->set_padding_top(to<Reflex::StyleLength>(top));
+
+	if (y.is_nil())
+		THIS->clear_center_y();
+	else
+		THIS->set_center_y(to<Reflex::StyleLength>(y));
+
+	return y;
 }
 RUCY_END
 
 static
-RUCY_DEF0(get_padding_top)
+RUCY_DEF0(get_center_y)
 {
 	CHECK;
-	return value(THIS->padding_top());
+	return value(THIS->center_y());
 }
 RUCY_END
 
 static
-RUCY_DEF1(set_padding_right, right)
+RUCY_DEF2(set_center, x, y)
 {
 	CHECK;
-	THIS->set_padding_right(to<Reflex::StyleLength>(right));
+
+	set_center_x(self, x);
+	set_center_y(self, y);
+
+	return array(x, y);
 }
 RUCY_END
 
 static
-RUCY_DEF0(get_padding_right)
+RUCY_DEF0(get_center)
 {
 	CHECK;
-	return value(THIS->padding_right());
+	return array(
+		get_center_x(self),
+		get_center_y(self));
 }
 RUCY_END
 
 static
-RUCY_DEF1(set_padding_bottom, bottom)
+RUCY_DEFN(set_foreground_fill)
 {
 	CHECK;
-	THIS->set_padding_bottom(to<Reflex::StyleLength>(bottom));
+	check_arg_count(
+		__FILE__, __LINE__, "Style#set_foreground_fill", argc, 1, 2, 3, 4);
+
+	if (argv[0].is_nil())
+	{
+		if (argc != 1)
+			argument_error(__FILE__, __LINE__);
+
+		THIS->clear_foreground_fill();
+		return argv[0];
+	}
+	else
+	{
+		Reflex::Color color = to<Reflex::Color>(argc, argv);
+		THIS->set_foreground_fill(color);
+		return value(color);
+	}
 }
 RUCY_END
 
 static
-RUCY_DEF0(get_padding_bottom)
+RUCY_DEFN(set_foreground_stroke)
 {
 	CHECK;
-	return value(THIS->padding_bottom());
+	check_arg_count(
+		__FILE__, __LINE__, "Style#set_foreground_stroke", argc, 1, 2, 3, 4);
+
+	if (argv[0].is_nil())
+	{
+		if (argc != 1)
+			argument_error(__FILE__, __LINE__);
+
+		THIS->clear_foreground_stroke();
+		return argv[0];
+	}
+	else
+	{
+		Reflex::Color color = to<Reflex::Color>(argc, argv);
+		THIS->set_foreground_stroke(color);
+		return value(color);
+	}
 }
 RUCY_END
 
 static
-RUCY_DEF4(set_padding, left, top, right, bottom)
+RUCY_DEF1(set_foreground_stroke_width, width)
 {
 	CHECK;
-	set_padding_left  (self, left);
-	set_padding_top   (self, top);
-	set_padding_right (self, right);
-	set_padding_bottom(self, bottom);
+
+	if (width.is_nil())
+		THIS->clear_foreground_stroke_width();
+	else
+		THIS->set_foreground_stroke_width(to<coord>(width));
+
+	return width;
 }
 RUCY_END
 
 static
-RUCY_DEF0(get_padding)
+RUCY_DEFN(set_background_fill)
 {
 	CHECK;
-	return array(
-		get_padding_left(self),
-		get_padding_top(self),
-		get_padding_right(self),
-		get_padding_bottom(self));
+	check_arg_count(
+		__FILE__, __LINE__, "Style#set_background_fill", argc, 1, 2, 3, 4);
+
+	if (argv[0].is_nil())
+	{
+		if (argc != 1)
+			argument_error(__FILE__, __LINE__);
+
+		THIS->clear_background_fill();
+		return argv[0];
+	}
+	else
+	{
+		Reflex::Color color = to<Reflex::Color>(argc, argv);
+		THIS->set_background_fill(color);
+		return value(color);
+	}
 }
 RUCY_END
 
 static
-RUCY_DEF1(set_fill, color)
+RUCY_DEFN(set_background_stroke)
 {
 	CHECK;
-	THIS->set_fill(to<Reflex::Color&>(color));
+	check_arg_count(
+		__FILE__, __LINE__, "Style#set_background_stroke", argc, 1, 2, 3, 4);
+
+	if (argv[0].is_nil())
+	{
+		if (argc != 1)
+			argument_error(__FILE__, __LINE__);
+
+		THIS->clear_background_stroke();
+		return argv[0];
+	}
+	else
+	{
+		Reflex::Color color = to<Reflex::Color>(argc, argv);
+		THIS->set_background_stroke(color);
+		return value(color);
+	}
 }
 RUCY_END
 
 static
-RUCY_DEF0(get_fill)
+RUCY_DEF1(set_background_stroke_width, width)
 {
 	CHECK;
-	return value(THIS->fill());
+
+	if (width.is_nil())
+		THIS->clear_background_stroke_width();
+	else
+		THIS->set_background_stroke_width(to<coord>(width));
+
+	return width;
 }
 RUCY_END
 
 static
-RUCY_DEF1(set_stroke, color)
+RUCY_DEF0(get_foreground_fill)
 {
 	CHECK;
-	THIS->set_stroke(to<Reflex::Color&>(color));
+	return value(THIS->foreground_fill());
 }
 RUCY_END
 
 static
-RUCY_DEF0(get_stroke)
+RUCY_DEF0(get_foreground_stroke)
 {
 	CHECK;
-	return value(THIS->stroke());
+	return value(THIS->foreground_stroke());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_foreground_stroke_width)
+{
+	CHECK;
+	return value(THIS->foreground_stroke_width());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_background_fill)
+{
+	CHECK;
+	return value(THIS->background_fill());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_background_stroke)
+{
+	CHECK;
+	return value(THIS->background_stroke());
+}
+RUCY_END
+
+static
+RUCY_DEF0(get_background_stroke_width)
+{
+	CHECK;
+	return value(THIS->background_stroke_width());
 }
 RUCY_END
 
@@ -552,7 +718,13 @@ static
 RUCY_DEF1(set_image, image)
 {
 	CHECK;
-	THIS->set_image(to<Reflex::Image&>(image));
+
+	if (image.is_nil())
+		THIS->clear_image();
+	else
+		THIS->set_image(to<Reflex::Image&>(image));
+
+	return image;
 }
 RUCY_END
 
@@ -584,14 +756,6 @@ Init_style ()
 	cStyle.define_alloc_func(alloc);
 	cStyle.define_private_method("initialize_copy", initialize_copy);
 
-	cStyle.define_method("name=", set_name);
-	cStyle.define_method("name",  get_name);
-	cStyle.define_method("add_tag",    add_tag);
-	cStyle.define_method("remove_tag", remove_tag);
-	cStyle.define_method("each_tag", each_tag);
-	cStyle.define_method("selector=", set_selector);
-	cStyle.define_method("selector", get_selector);
-
 	cStyle.define_method("set_flow", set_flow);
 	cStyle.define_method("get_flow", get_flow);
 
@@ -613,17 +777,6 @@ Init_style ()
 	cStyle.define_method("position=", set_position);
 	cStyle.define_method("position",  get_position);
 
-	cStyle.define_method("offset_left=",   set_offset_left);
-	cStyle.define_method("offset_left",    get_offset_left);
-	cStyle.define_method("offset_top=",    set_offset_top);
-	cStyle.define_method("offset_top",     get_offset_top);
-	cStyle.define_method("offset_right=",  set_offset_right);
-	cStyle.define_method("offset_right",   get_offset_right);
-	cStyle.define_method("offset_bottom=", set_offset_bottom);
-	cStyle.define_method("offset_bottom",  get_offset_bottom);
-	cStyle.define_method("offset=",        set_offset);
-	cStyle.define_method("offset",         get_offset);
-
 	cStyle.define_method("margin_left=",   set_margin_left);
 	cStyle.define_method("margin_left",    get_margin_left);
 	cStyle.define_method("margin_top=",    set_margin_top);
@@ -646,20 +799,38 @@ Init_style ()
 	cStyle.define_method("padding=",        set_padding);
 	cStyle.define_method("padding",         get_padding);
 
-	cStyle.define_method("fill=",   set_fill);
-	cStyle.define_method("fill",    get_fill);
-	cStyle.define_method("stroke=", set_stroke);
-	cStyle.define_method("stroke",  get_stroke);
+	cStyle.define_method("center_x=", set_center_x);
+	cStyle.define_method("center_x",  get_center_x);
+	cStyle.define_method("center_y=", set_center_y);
+	cStyle.define_method("center_y",  get_center_y);
+	cStyle.define_method("center=",   set_center);
+	cStyle.define_method("center",    get_center);
+
+	cStyle.define_method("foreground_fill=",         set_foreground_fill);
+	cStyle.define_method("foreground_fill",          get_foreground_fill);
+	cStyle.define_method("foreground_stroke=",       set_foreground_stroke);
+	cStyle.define_method("foreground_stroke",        get_foreground_stroke);
+	cStyle.define_method("foreground_stroke_width=", set_foreground_stroke_width);
+	cStyle.define_method("foreground_stroke_width",  get_foreground_stroke_width);
+	cStyle.define_method("background_fill=",         set_background_fill);
+	cStyle.define_method("background_fill",          get_background_fill);
+	cStyle.define_method("background_stroke=",       set_background_stroke);
+	cStyle.define_method("background_stroke",        get_background_stroke);
+	cStyle.define_method("background_stroke_width=", set_background_stroke_width);
+	cStyle.define_method("background_stroke_width",  get_background_stroke_width);
 
 	cStyle.define_method("image=", set_image);
 	cStyle.define_method("image",  get_image);
 
 	cStyle.define_method("==", equal);
+
 	cStyle.define_const("FLOW_NONE",  Reflex::Style::FLOW_NONE);
 	cStyle.define_const("FLOW_DOWN",  Reflex::Style::FLOW_DOWN);
 	cStyle.define_const("FLOW_RIGHT", Reflex::Style::FLOW_RIGHT);
 	cStyle.define_const("FLOW_UP",    Reflex::Style::FLOW_UP);
 	cStyle.define_const("FLOW_LEFT",  Reflex::Style::FLOW_LEFT);
+
+	define_selector_methods<Reflex::Style>(cStyle);
 }