reflexion 0.1.11 → 0.1.16

data/.doc/ext/reflex/shape.cpp

@@ -0,0 +1,211 @@
+#include "reflex/ruby/shape.h"
+
+
+#include <rays/ruby/bounds.h>
+#include "reflex/exception.h"
+#include "reflex/ruby/view.h"
+#include "defs.h"
+#include "selector.h"
+
+
+RUCY_DEFINE_WRAPPER_VALUE_FROM_TO(Reflex::Shape)
+
+#define THIS      to<Reflex::Shape*>(self)
+
+#define CHECK     RUCY_CHECK_OBJ(Reflex::Shape, self)
+
+#define CALL(fun) RUCY_CALL_SUPER(THIS, fun)
+
+
+static
+VALUE alloc(VALUE klass)
+{
+	Reflex::reflex_error(__FILE__, __LINE__, "can not instantiate Shape class.");
+}
+
+static
+VALUE owner(VALUE self)
+{
+	CHECK;
+	return value(THIS->owner());
+}
+
+static
+VALUE set_frame(VALUE self)
+{
+	CHECK;
+	THIS->set_frame(to<Rays::Bounds>(argc, argv));
+	return value(THIS->frame());
+}
+
+static
+VALUE get_frame(VALUE self)
+{
+	CHECK;
+	return value(THIS->frame());
+}
+
+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 on_draw(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_draw(to<Reflex::DrawEvent*>(event)));
+}
+
+static
+VALUE on_contact(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_contact(to<Reflex::ContactEvent*>(event)));
+}
+
+static
+VALUE on_contact_begin(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_contact_begin(to<Reflex::ContactEvent*>(event)));
+}
+
+static
+VALUE on_contact_end(VALUE self, VALUE event)
+{
+	CHECK;
+	CALL(on_contact_end(to<Reflex::ContactEvent*>(event)));
+}
+
+
+static Class cShape;
+
+void
+Init_shape ()
+{
+	Module mReflex = rb_define_module("Reflex");
+
+	cShape = rb_define_class_under(mReflex, "Shape", rb_cObject);
+	rb_define_alloc_func(cShape, alloc);
+	rb_define_method(cShape, "owner", RUBY_METHOD_FUNC(owner), 0);
+	rb_define_method(cShape, "frame=", RUBY_METHOD_FUNC(set_frame), -1);
+	rb_define_method(cShape, "frame", RUBY_METHOD_FUNC(get_frame), 0);
+	rb_define_method(cShape, "density=", RUBY_METHOD_FUNC(set_density), 1);
+	rb_define_method(cShape, "density", RUBY_METHOD_FUNC(get_density), 0);
+	rb_define_method(cShape, "friction=", RUBY_METHOD_FUNC(set_friction), 1);
+	rb_define_method(cShape, "friction", RUBY_METHOD_FUNC(get_friction), 0);
+	rb_define_method(cShape, "restitution=", RUBY_METHOD_FUNC(set_restitution), 1);
+	rb_define_method(cShape, "restitution", RUBY_METHOD_FUNC(get_restitution), 0);
+	rb_define_method(cShape, "sensor=", RUBY_METHOD_FUNC(set_sensor), 1);
+	rb_define_method(cShape, "sensor", RUBY_METHOD_FUNC(is_sensor), 0);
+	rb_define_method(cShape, "category_bits=", RUBY_METHOD_FUNC(set_category_bits), 1);
+	rb_define_method(cShape, "category_bits", RUBY_METHOD_FUNC(get_category_bits), 0);
+	rb_define_method(cShape, "collision_mask=", RUBY_METHOD_FUNC(set_collision_mask), 1);
+	rb_define_method(cShape, "collision_mask", RUBY_METHOD_FUNC(get_collision_mask), 0);
+	rb_define_method(cShape, "on_draw", RUBY_METHOD_FUNC(on_draw), 1);
+	cShape.define_private_method("call_contact!",       on_contact);
+	cShape.define_private_method("call_contact_begin!", on_contact_begin);
+	cShape.define_private_method("call_contact_end!",   on_contact_end);
+
+	define_selector_methods<Reflex::Shape>(cShape);
+}
+
+
+namespace Reflex
+{
+
+
+	Class
+	shape_class ()
+	{
+		return cShape;
+	}
+
+
+}// Reflex

data/.doc/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
@@ -32,75 +30,34 @@ VALUE initialize_copy(VALUE self, VALUE obj)
 	return self;
 }
 
-static
-VALUE set_name(VALUE self, VALUE name)
-{
-	CHECK;
-	THIS->set_name(name.is_nil() ? NULL : name.c_str());
-}
-
-static
-VALUE get_name(VALUE self)
-{
-	CHECK;
-	return THIS->name() ? value(THIS->name()) : nil();
-}
-
-static
-VALUE add_tag(VALUE self, VALUE tag)
-{
-	CHECK;
-	THIS->add_tag(tag.c_str());
-}
-
-static
-VALUE remove_tag(VALUE self, VALUE tag)
-{
-	CHECK;
-	THIS->remove_tag(tag.c_str());
-}
-
-static
-VALUE each_tag(VALUE self)
-{
-	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;
-}
-
-static
-VALUE set_selector(VALUE self, VALUE selector)
-{
-	CHECK;
-	THIS->set_selector(to<Reflex::Selector>(selector));
-}
-
-static
-VALUE get_selector(VALUE self)
-{
-	CHECK;
-	return value(THIS->selector());
-}
-
 static
 VALUE set_flow(VALUE self)
 {
 	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);
 }
 
 static
 VALUE get_flow(VALUE self)
 {
 	CHECK;
+
 	Reflex::Style::Flow main, sub;
 	THIS->get_flow(&main, &sub);
 	return array(main, sub);
@@ -110,7 +67,13 @@ static
 VALUE set_width(VALUE self, VALUE 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;
 }
 
 static
@@ -124,7 +87,13 @@ static
 VALUE set_height(VALUE self, VALUE 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;
 }
 
 static
@@ -140,22 +109,32 @@ VALUE set_size(VALUE self)
 	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);
 }
 
 static
 VALUE get_size(VALUE self)
 {
 	CHECK;
-	return array(get_width(self), get_height(self));
+	return array(
+		get_width(self),
+		get_height(self));
 }
 
 static
 VALUE set_left(VALUE self, VALUE 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;
 }
 
 static
@@ -169,7 +148,13 @@ static
 VALUE set_top(VALUE self, VALUE 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;
 }
 
 static
@@ -183,7 +168,13 @@ static
 VALUE set_right(VALUE self, VALUE 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;
 }
 
 static
@@ -197,7 +188,13 @@ static
 VALUE set_bottom(VALUE self, VALUE 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;
 }
 
 static
@@ -211,10 +208,13 @@ 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_left(  self, left);
+	set_top(   self, top);
+	set_right( self, right);
 	set_bottom(self, bottom);
+
+	return array(left, top, right, bottom);
 }
 
 static
@@ -229,269 +229,444 @@ VALUE get_position(VALUE self)
 }
 
 static
-VALUE set_offset_left(VALUE self, VALUE left)
+VALUE set_margin_left(VALUE self, VALUE 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;
 }
 
 static
-VALUE get_offset_left(VALUE self)
+VALUE get_margin_left(VALUE self)
 {
 	CHECK;
-	return value(THIS->offset_left());
+	return value(THIS->margin_left());
 }
 
 static
-VALUE set_offset_top(VALUE self, VALUE top)
+VALUE set_margin_top(VALUE self, VALUE 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;
 }
 
 static
-VALUE get_offset_top(VALUE self)
+VALUE get_margin_top(VALUE self)
 {
 	CHECK;
-	return value(THIS->offset_top());
+	return value(THIS->margin_top());
 }
 
 static
-VALUE set_offset_right(VALUE self, VALUE right)
+VALUE set_margin_right(VALUE self, VALUE 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;
 }
 
 static
-VALUE get_offset_right(VALUE self)
+VALUE get_margin_right(VALUE self)
 {
 	CHECK;
-	return value(THIS->offset_right());
+	return value(THIS->margin_right());
 }
 
 static
-VALUE set_offset_bottom(VALUE self, VALUE bottom)
+VALUE set_margin_bottom(VALUE self, VALUE 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;
 }
 
 static
-VALUE get_offset_bottom(VALUE self)
+VALUE get_margin_bottom(VALUE self)
 {
 	CHECK;
-	return value(THIS->offset_bottom());
+	return value(THIS->margin_bottom());
 }
 
 static
-VALUE set_offset(VALUE self, VALUE left, VALUE top, VALUE right, VALUE bottom)
+VALUE set_margin(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);
+
+	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);
 }
 
 static
-VALUE get_offset(VALUE self)
+VALUE get_margin(VALUE self)
 {
 	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));
 }
 
 static
-VALUE set_margin_left(VALUE self, VALUE left)
+VALUE set_padding_left(VALUE self, VALUE 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;
 }
 
 static
-VALUE get_margin_left(VALUE self)
+VALUE get_padding_left(VALUE self)
 {
 	CHECK;
-	return value(THIS->margin_left());
+	return value(THIS->padding_left());
 }
 
 static
-VALUE set_margin_top(VALUE self, VALUE top)
+VALUE set_padding_top(VALUE self, VALUE 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;
 }
 
 static
-VALUE get_margin_top(VALUE self)
+VALUE get_padding_top(VALUE self)
 {
 	CHECK;
-	return value(THIS->margin_top());
+	return value(THIS->padding_top());
 }
 
 static
-VALUE set_margin_right(VALUE self, VALUE right)
+VALUE set_padding_right(VALUE self, VALUE 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;
 }
 
 static
-VALUE get_margin_right(VALUE self)
+VALUE get_padding_right(VALUE self)
 {
 	CHECK;
-	return value(THIS->margin_right());
+	return value(THIS->padding_right());
 }
 
 static
-VALUE set_margin_bottom(VALUE self, VALUE bottom)
+VALUE set_padding_bottom(VALUE self, VALUE 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;
 }
 
 static
-VALUE get_margin_bottom(VALUE self)
+VALUE get_padding_bottom(VALUE self)
 {
 	CHECK;
-	return value(THIS->margin_bottom());
+	return value(THIS->padding_bottom());
 }
 
 static
-VALUE set_margin(VALUE self, VALUE left, VALUE top, VALUE right, VALUE bottom)
+VALUE set_padding(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);
+
+	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);
 }
 
 static
-VALUE get_margin(VALUE self)
+VALUE get_padding(VALUE self)
 {
 	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));
 }
 
 static
-VALUE set_padding_left(VALUE self, VALUE left)
+VALUE set_center_x(VALUE self, VALUE 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;
 }
 
 static
-VALUE get_padding_left(VALUE self)
+VALUE get_center_x(VALUE self)
 {
 	CHECK;
-	return value(THIS->padding_left());
+	return value(THIS->center_x());
 }
 
 static
-VALUE set_padding_top(VALUE self, VALUE top)
+VALUE set_center_y(VALUE self, VALUE 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;
 }
 
 static
-VALUE get_padding_top(VALUE self)
+VALUE get_center_y(VALUE self)
 {
 	CHECK;
-	return value(THIS->padding_top());
+	return value(THIS->center_y());
 }
 
 static
-VALUE set_padding_right(VALUE self, VALUE right)
+VALUE set_center(VALUE self, VALUE x, VALUE y)
 {
 	CHECK;
-	THIS->set_padding_right(to<Reflex::StyleLength>(right));
+
+	set_center_x(self, x);
+	set_center_y(self, y);
+
+	return array(x, y);
 }
 
 static
-VALUE get_padding_right(VALUE self)
+VALUE get_center(VALUE self)
 {
 	CHECK;
-	return value(THIS->padding_right());
+	return array(
+		get_center_x(self),
+		get_center_y(self));
 }
 
 static
-VALUE set_padding_bottom(VALUE self, VALUE bottom)
+VALUE set_foreground_fill(VALUE self)
 {
 	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);
+	}
 }
 
 static
-VALUE get_padding_bottom(VALUE self)
+VALUE set_foreground_stroke(VALUE self)
 {
 	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);
+	}
 }
 
 static
-VALUE set_padding(VALUE self, VALUE left, VALUE top, VALUE right, VALUE bottom)
+VALUE set_foreground_stroke_width(VALUE self, VALUE 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;
 }
 
 static
-VALUE get_padding(VALUE self)
+VALUE set_background_fill(VALUE self)
 {
 	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);
+	}
+}
+
+static
+VALUE set_background_stroke(VALUE self)
+{
+	CHECK;
+	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);
+	}
+}
+
+static
+VALUE set_background_stroke_width(VALUE self, VALUE width)
+{
+	CHECK;
+
+	if (width.is_nil())
+		THIS->clear_background_stroke_width();
+	else
+		THIS->set_background_stroke_width(to<coord>(width));
+
+	return width;
 }
 
 static
-VALUE set_fill(VALUE self, VALUE color)
+VALUE get_foreground_fill(VALUE self)
 {
 	CHECK;
-	THIS->set_fill(to<Reflex::Color&>(color));
+	return value(THIS->foreground_fill());
 }
 
 static
-VALUE get_fill(VALUE self)
+VALUE get_foreground_stroke(VALUE self)
 {
 	CHECK;
-	return value(THIS->fill());
+	return value(THIS->foreground_stroke());
 }
 
 static
-VALUE set_stroke(VALUE self, VALUE color)
+VALUE get_foreground_stroke_width(VALUE self)
 {
 	CHECK;
-	THIS->set_stroke(to<Reflex::Color&>(color));
+	return value(THIS->foreground_stroke_width());
 }
 
 static
-VALUE get_stroke(VALUE self)
+VALUE get_background_fill(VALUE self)
 {
 	CHECK;
-	return value(THIS->stroke());
+	return value(THIS->background_fill());
+}
+
+static
+VALUE get_background_stroke(VALUE self)
+{
+	CHECK;
+	return value(THIS->background_stroke());
+}
+
+static
+VALUE get_background_stroke_width(VALUE self)
+{
+	CHECK;
+	return value(THIS->background_stroke_width());
 }
 
 static
 VALUE set_image(VALUE self, VALUE 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;
 }
 
 static
@@ -520,14 +695,6 @@ Init_style ()
 	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);
-	rb_define_method(cStyle, "remove_tag", RUBY_METHOD_FUNC(remove_tag), 1);
-	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);
 
@@ -549,17 +716,6 @@ Init_style ()
 	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, "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);
@@ -582,20 +738,38 @@ Init_style ()
 	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, "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, "center_x=", RUBY_METHOD_FUNC(set_center_x), 1);
+	rb_define_method(cStyle, "center_x", RUBY_METHOD_FUNC(get_center_x), 0);
+	rb_define_method(cStyle, "center_y=", RUBY_METHOD_FUNC(set_center_y), 1);
+	rb_define_method(cStyle, "center_y", RUBY_METHOD_FUNC(get_center_y), 0);
+	rb_define_method(cStyle, "center=", RUBY_METHOD_FUNC(set_center), 2);
+	rb_define_method(cStyle, "center", RUBY_METHOD_FUNC(get_center), 0);
+
+	rb_define_method(cStyle, "foreground_fill=", RUBY_METHOD_FUNC(set_foreground_fill), -1);
+	rb_define_method(cStyle, "foreground_fill", RUBY_METHOD_FUNC(get_foreground_fill), 0);
+	rb_define_method(cStyle, "foreground_stroke=", RUBY_METHOD_FUNC(set_foreground_stroke), -1);
+	rb_define_method(cStyle, "foreground_stroke", RUBY_METHOD_FUNC(get_foreground_stroke), 0);
+	rb_define_method(cStyle, "foreground_stroke_width=", RUBY_METHOD_FUNC(set_foreground_stroke_width), 1);
+	rb_define_method(cStyle, "foreground_stroke_width", RUBY_METHOD_FUNC(get_foreground_stroke_width), 0);
+	rb_define_method(cStyle, "background_fill=", RUBY_METHOD_FUNC(set_background_fill), -1);
+	rb_define_method(cStyle, "background_fill", RUBY_METHOD_FUNC(get_background_fill), 0);
+	rb_define_method(cStyle, "background_stroke=", RUBY_METHOD_FUNC(set_background_stroke), -1);
+	rb_define_method(cStyle, "background_stroke", RUBY_METHOD_FUNC(get_background_stroke), 0);
+	rb_define_method(cStyle, "background_stroke_width=", RUBY_METHOD_FUNC(set_background_stroke_width), 1);
+	rb_define_method(cStyle, "background_stroke_width", RUBY_METHOD_FUNC(get_background_stroke_width), 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);
 	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);
 }