reflexion 0.1.12 → 0.1.13

data/src/style.cpp

@@ -1,44 +1,24 @@
-#include "reflex/style.h"
+#include "style.h"
 
 
-#include <boost/noncopyable.hpp>
-#include "reflex/view.h"
 #include "reflex/exception.h"
+#include "reflex/debug.h"
+#include "view.h"
+#include "selector.h"
 
 
 namespace Reflex
 {
 
 
-	template <typename T>
+	template <typename T, typename DefaultValue = T>
 	class StyleValue
 	{
 
-		typedef StyleValue<T> This;
+		typedef StyleValue<T, DefaultValue> This;
 
 		typedef T Value;
 
-		class Wrapper : public boost::noncopyable, public Xot::RefCountable<>
-		{
-
-			public:
-
-				Wrapper () {}
-
-				Wrapper (const Value& value) : value(value) {}
-
-				void reset (const Value& value_) {value = value_;}
-
-				      Value& get ()       {return value;}
-
-				const Value& get () const {return value;}
-
-			private:
-
-				Value value;
-
-		};// Wrapper
-
 		public:
 
 			StyleValue ()
@@ -60,13 +40,15 @@ namespace Reflex
 
 			This& operator = (const Value& value)
 			{
-				reset(new Wrapper(value));
+				set_wrapper(new ValueWrapper(value));
 				return *this;
 			}
 
 			This& operator = (const This& obj)
 			{
-				if (&obj != this) reset(obj.pwrapper);
+				if (&obj == this) return *this;
+				const ValueWrapper* p = obj.wrapper();
+				set_wrapper(p ? new ValueWrapper(*p) : NULL);
 				return *this;
 			}
 
@@ -75,46 +57,44 @@ namespace Reflex
 				clear();
 			}
 
-			void clear ()
+			bool clear ()
 			{
-				reset();
+				return set_wrapper(NULL);
 			}
 
-			Value& value (bool create = false)
+			bool set (const Value& value)
 			{
-				Wrapper* p = pointer();
-				if (!p)
-				{
-					if (!create)
-						invalid_state_error(__FILE__, __LINE__);
+				const ValueWrapper* p = wrapper();
+				if (p && p->value() == value)
+					return false;
 
-					p = reset(new Wrapper());
-				}
-				return p->get();
+				set_wrapper(new ValueWrapper(value));
+				return true;
 			}
 
-			const Value& get (const Value& defval) const
+			const Value& get () const
 			{
-				Wrapper* p = pointer();
-				return p ? p->get() : defval;
+				static const Value DEFVAL = DefaultValue();
+
+				const ValueWrapper* p = wrapper();
+				return p ? p->value() : DEFVAL;
 			}
 
-			bool set (const Value& val)
+			const Value& get (const Value& defval) const
 			{
-				Value& current = value(true);
-				if (current == val)
-					return false;
-
-				current = val;
-				return true;
+				const ValueWrapper* p = wrapper();
+				return p ? p->value() : defval;
 			}
 
-			void override (const This& value)
+			void override (const This& obj)
 			{
-				if (!value || (*this && !is_inherited()))
+				if (!obj)
+					return;
+
+				if (*this && !is_inherited())
 					return;
 
-				reset(value.pointer());
+				set_wrapper(obj.wrapper());
 				set_inherited();
 			}
 
@@ -123,17 +103,42 @@ namespace Reflex
 				return get_pointer_flag(pwrapper);
 			}
 
-			operator bool () const {return pointer() != NULL;}
+			operator bool () const
+			{
+				return wrapper() != NULL;
+			}
 
-			bool operator ! () const {return !operator bool();}
+			bool operator ! () const
+			{
+				return !operator bool();
+			}
 
 		private:
 
-			Wrapper* pwrapper;
+			class ValueWrapper : public Xot::RefCountable<>
+			{
+
+				public:
+
+					ValueWrapper () : value_(DefaultValue()) {}
+
+					ValueWrapper (const Value& value) : value_(value) {}
+
+					ValueWrapper (const ValueWrapper& obj) : value_(obj.value_) {}
 
-			Wrapper* reset (Wrapper* ptr = NULL)
+					const Value& value () const {return value_;}
+
+				private:
+
+					Value value_;
+
+			};// ValueWrapper
+
+			const ValueWrapper* pwrapper;
+
+			const ValueWrapper* set_wrapper (const ValueWrapper* ptr)
 			{
-				Wrapper* p = pointer();
+				const ValueWrapper* p = wrapper();
 				if (ptr != p)
 				{
 					if (p) p->release();
@@ -149,7 +154,10 @@ namespace Reflex
 					pwrapper = Xot::set_pointer_flag(pwrapper, state);
 			}
 
-			Wrapper* pointer () const {return Xot::set_pointer_flag(pwrapper, false);}
+			const ValueWrapper* wrapper () const
+			{
+				return Xot::set_pointer_flag(pwrapper, false);
+			}
 
 	};// StyleValue
 
@@ -157,79 +165,56 @@ namespace Reflex
 	struct StyleLength::Data
 	{
 
+		Type type;
+
 		Value value;
 
-		Unit unit;
+		Data ()
+		:	type(NONE), value(0)
+		{
+		}
 
-		Data () : value(0), unit(NONE) {}
+		bool is_variable () const
+		{
+			return type == PERCENT || type == FILL || type == FIT;
+		}
 
 		friend bool operator == (const Data& lhs, const Data& rhs)
 		{
-			return lhs.value == rhs.value && lhs.unit == rhs.unit;
+			return lhs.type == rhs.type && lhs.value == rhs.value;
 		}
 
 	};// StyleLength::Data
 
 
-	StyleLength::StyleLength ()
-	{
-	}
-
-	StyleLength::StyleLength (Value value, Unit unit)
-	{
-		reset(value, unit);
-	}
-
-	StyleLength::StyleLength (const char* str)
+	StyleLength::StyleLength (Type type, Value value)
 	{
-		reset(str);
+		reset(type, value);
 	}
 
 	StyleLength
 	StyleLength::copy () const
 	{
-		return StyleLength(value(), unit());
+		return StyleLength(type(), value());
 	}
 
 	void
-	StyleLength::reset (Value value, Unit unit)
+	StyleLength::reset (Type type, Value value)
 	{
-		if (unit < NONE || UNIT_LAST <= unit)
+		if (type < NONE || TYPE_LAST <= type)
 			argument_error(__FILE__, __LINE__);
 
-		self->value = value;
-		self->unit  = unit;
-	}
-
-	static StyleLength::Unit
-	str2unit (const char* s)
-	{
-		     if (strcasecmp(s, "px") == 0) return StyleLength::PIXEL;
-		else if (strcasecmp(s, "%")  == 0) return StyleLength::PERCENT;
-		else                               return StyleLength::NONE;
-	}
+		if (type == FIT && value != 1)
+			argument_error(__FILE__, __LINE__);
 
-	static const char*
-	unit2str (StyleLength::Unit unit)
-	{
-		switch (unit)
-		{
-			case StyleLength::PIXEL:   return "px";
-			case StyleLength::PERCENT: return "%";
-			default:                   return NULL;
-		}
+		self->type  = type;
+		self->value = value;
 	}
 
-	void
-	StyleLength::reset (const char* str)
+	StyleLength::Type
+	StyleLength::type () const
 	{
-		Value num;
-		char suffix[256];
-		int count = sscanf(str, "%f%s", &num, suffix);
-		if (count != 2)
-			argument_error(__FILE__, __LINE__);
-
-		reset(num, str2unit(suffix));
+		return self->type;
 	}
 
 	StyleLength::Value
@@ -238,34 +223,9 @@ namespace Reflex
 		return self->value;
 	}
 
-	StyleLength::Unit
-	StyleLength::unit () const
-	{
-		return self->unit;
-	}
-
-	String
-	StyleLength::to_s () const
-	{
-		if (!*this)
-			return "";
-
-		String num;
-		if (fmod(self->value, 1) == 0)
-			num = Xot::stringf("%d", (long) self->value);
-		else
-			num = Xot::stringf("%g", self->value);
-
-		const char* suffix = unit2str(self->unit);;
-		if (!suffix)
-			invalid_state_error(__FILE__, __LINE__);
-
-		return num + suffix;
-	}
-
 	StyleLength::operator bool () const
 	{
-		return NONE < self->unit && self->unit < UNIT_LAST;
+		return NONE < self->type && self->type < TYPE_LAST;
 	}
 
 	bool
@@ -287,56 +247,73 @@ namespace Reflex
 	}
 
 
-	void
-	get_default_flow (Style::Flow* main, Style::Flow* sub)
+	struct Style::Data
 	{
-		assert(main || sub);
 
-		if (main) *main = Style::FLOW_RIGHT;
-		if (sub)  *sub  = Style::FLOW_DOWN;
-	}
+		struct WhiteColor : public Color
+		{
+			WhiteColor () : Color(1, 1) {}
+		};
 
+		struct TransparentColor : public Color
+		{
+			TransparentColor () : Color(0, 0) {}
+		};
 
-	struct Style::Data
-	{
+		struct MaxLength : public StyleLength
+		{
+			MaxLength () : StyleLength(PERCENT, 100) {}
+		};
 
-		typedef StyleValue<bool>        Bool;
+		typedef StyleValue<bool>        BoolValue;
 
-		typedef StyleValue<int>         Int;
+		typedef StyleValue<int>         IntValue;
 
-		typedef StyleValue<double>      Float;
+		typedef StyleValue<double>      FloatValue;
 
-		typedef StyleValue<Color>       Color;
+		typedef StyleValue<coord>       CoordValue;
 
-		typedef StyleValue<Image>       Image;
+		typedef StyleValue<Color>       ColorValue;
 
-		typedef StyleValue<StyleLength> Length;
+		typedef StyleValue<Image>       ImageValue;
+
+		typedef StyleValue<StyleLength> LengthValue;
 
 		View* owner;
 
-		Selector selector;
+		SelectorPtr pselector;
+
+		IntValue flow;
+
+		StyleValue<StyleLength, MaxLength> width, height;
 
-		Int flow;
+		LengthValue         left,         top,         right,         bottom;
 
-		Length width, height;
+		LengthValue  margin_left,  margin_top,  margin_right,  margin_bottom;
 
-		Length         left,         top,         right,         bottom;
+		LengthValue padding_left, padding_top, padding_right, padding_bottom;
 
-		Length  offset_left,  offset_top,  offset_right,  offset_bottom;
+		LengthValue center_x, center_y;
 
-		Length  margin_left,  margin_top,  margin_right,  margin_bottom;
+		StyleValue<Color, WhiteColor>       fore_fill;
 
-		Length padding_left, padding_top, padding_right, padding_bottom;
+		StyleValue<Color, TransparentColor> fore_stroke, back_fill, back_stroke;
 
-		Color fill, stroke;
+		CoordValue fore_stroke_width, back_stroke_width;
 
-		Image image;
+		ImageValue image;
 
 		Data ()
 		:	owner(NULL)
 		{
 		}
 
+		Selector& selector ()
+		{
+			if (!pselector) pselector.reset(new Selector);
+			return *pselector;
+		}
+
 		enum FlowOffset {FLOW_MASK = 0xffff, FLOW_SHIFT = 16};
 
 		bool set_flow (Flow main, Flow sub)
@@ -346,57 +323,110 @@ namespace Reflex
 
 		Flow flow_main () const
 		{
-			Flow defval = FLOW_NONE;
-			get_default_flow(&defval, NULL);
-			return (Flow) (flow.get(defval) & FLOW_MASK);
+			return (Flow) (flow.get(FLOW_NONE) & FLOW_MASK);
 		}
 
 		Flow flow_sub () const
 		{
-			Flow defval = FLOW_NONE;
-			get_default_flow(NULL, &defval);
-			return (Flow) ((flow.get(defval << FLOW_SHIFT) >> FLOW_SHIFT) & FLOW_MASK);
+			return (Flow) ((flow.get(FLOW_NONE << FLOW_SHIFT) >> FLOW_SHIFT) & FLOW_MASK);
 		}
 
 	};// Data
 
 
-	namespace Zero
+	bool
+	Style_set_owner (Style* style, View* owner)
 	{
+		assert(style);
 
-		static const Color       color;
-
-		static const Image       image;
-
-		static const StyleLength length;
+		if (!!style->self->owner == !!owner)
+			return false;
 
-	}// Zero
+		style->self->owner = owner;
+		return true;
+	}
 
+	template <typename T>
+	static bool
+	is_variable (const T& length)
+	{
+		return length.get().self->is_variable();
+	}
 
 	bool
-	set_style_owner (Style* style, View* owner)
+	Style_has_variable_lengths (const Style& style)
 	{
-		assert(style);
+		Style::Data* s = style.self.get();
+		if (!s) return false;
 
-		if (style->self->owner)
-			return false;
+		return
+			is_variable(s->width)  ||
+			is_variable(s->height) ||
 
-		style->self->owner = owner;
-		return true;
+			is_variable(s->left)   ||
+			is_variable(s->top)    ||
+			is_variable(s->right)  ||
+			is_variable(s->bottom) ||
+
+			is_variable(s->margin_left)   ||
+			is_variable(s->margin_top)    ||
+			is_variable(s->margin_right)  ||
+			is_variable(s->margin_bottom) ||
+
+			is_variable(s->padding_left)   ||
+			is_variable(s->padding_top)    ||
+			is_variable(s->padding_right)  ||
+			is_variable(s->padding_bottom) ||
+
+			is_variable(s->center_x)  ||
+			is_variable(s->center_y);
 	}
 
+	template <typename T>
 	static void
-	update_owner (const Style& style)
+	clear_inherited_value (T* value)
 	{
-		View* owner = style.self->owner;
-		if (!owner) return;
+		assert(value);
+
+		if (value->is_inherited())
+			value->clear();
+	}
+
+	void
+	Style_clear_inherited_values (Style* style)
+	{
+		assert(style);
 
-		void update_styles_for_selector (View*, const Selector&);
-		update_styles_for_selector(owner, style.self->selector);
+		Style::Data* self = style->self.get();
+
+		clear_inherited_value(&self->flow);
+		clear_inherited_value(&self->width);
+		clear_inherited_value(&self->height);
+		clear_inherited_value(&self->left);
+		clear_inherited_value(&self->top);
+		clear_inherited_value(&self->right);
+		clear_inherited_value(&self->bottom);
+		clear_inherited_value(&self->margin_left);
+		clear_inherited_value(&self->margin_top);
+		clear_inherited_value(&self->margin_right);
+		clear_inherited_value(&self->margin_bottom);
+		clear_inherited_value(&self->padding_left);
+		clear_inherited_value(&self->padding_top);
+		clear_inherited_value(&self->padding_right);
+		clear_inherited_value(&self->padding_bottom);
+		clear_inherited_value(&self->center_x);
+		clear_inherited_value(&self->center_y);
+		clear_inherited_value(&self->fore_fill);
+		clear_inherited_value(&self->fore_stroke);
+		clear_inherited_value(&self->fore_stroke_width);
+		clear_inherited_value(&self->back_fill);
+		clear_inherited_value(&self->back_stroke);
+		clear_inherited_value(&self->back_stroke_width);
+		clear_inherited_value(&self->image);
 	}
 
 	void
-	override_style (Style* overridden, const Style& overrides)
+	Style_override (Style* overridden, const Style& overrides)
 	{
 		assert(overridden);
 
@@ -404,120 +434,166 @@ namespace Reflex
 		Style::Data* to    = overridden->self.get();
 		if (!from || !to) return;
 
-		to->flow          .override(from->flow);
-		to->width         .override(from->width);
-		to->height        .override(from->height);
-		to->left          .override(from->left);
-		to->top           .override(from->top);
-		to->right         .override(from->right);
-		to->bottom        .override(from->bottom);
-		to->offset_left   .override(from->offset_left);
-		to->offset_top    .override(from->offset_top);
-		to->offset_right  .override(from->offset_right);
-		to->offset_bottom .override(from->offset_bottom);
-		to->margin_left   .override(from->margin_left);
-		to->margin_top    .override(from->margin_top);
-		to->margin_right  .override(from->margin_right);
-		to->margin_bottom .override(from->margin_bottom);
-		to->padding_left  .override(from->padding_left);
-		to->padding_top   .override(from->padding_top);
-		to->padding_right .override(from->padding_right);
-		to->padding_bottom.override(from->padding_bottom);
-		to->fill          .override(from->fill);
-		to->stroke        .override(from->stroke);
-		to->image         .override(from->image);
+		to->flow             .override(from->flow);
+		to->width            .override(from->width);
+		to->height           .override(from->height);
+		to->left             .override(from->left);
+		to->top              .override(from->top);
+		to->right            .override(from->right);
+		to->bottom           .override(from->bottom);
+		to->margin_left      .override(from->margin_left);
+		to->margin_top       .override(from->margin_top);
+		to->margin_right     .override(from->margin_right);
+		to->margin_bottom    .override(from->margin_bottom);
+		to->padding_left     .override(from->padding_left);
+		to->padding_top      .override(from->padding_top);
+		to->padding_right    .override(from->padding_right);
+		to->padding_bottom   .override(from->padding_bottom);
+		to->center_x         .override(from->center_x);
+		to->center_y         .override(from->center_y);
+		to->fore_fill        .override(from->fore_fill);
+		to->fore_stroke      .override(from->fore_stroke);
+		to->fore_stroke_width.override(from->fore_stroke_width);
+		to->back_fill        .override(from->back_fill);
+		to->back_stroke      .override(from->back_stroke);
+		to->back_stroke_width.override(from->back_stroke_width);
+		to->image            .override(from->image);
 	}
 
-
-	Style::Style (const char* name)
+	bool
+	StyleLength_get_pixel_length (
+		coord* pixel_length, const StyleLength& style_length, coord parent_size)
 	{
-		if (name) set_name(name);
-	}
+		assert(pixel_length);
 
-	Style::~Style ()
-	{
-	}
+		if (!style_length)
+			return false;
 
-	void
-	Style::set_name (const char* name)
-	{
-		update_owner(*this);
+		coord old_length = *pixel_length;
 
-		self->selector.set_name(name);
+		StyleLength::Value value = style_length.value();
+		switch (style_length.type())
+		{
+			case StyleLength::PIXEL:
+				*pixel_length = value;
+				break;
 
-		update_owner(*this);
-	}
+			case StyleLength::PERCENT:
+				*pixel_length =
+					(value == 100) ? parent_size : floor(parent_size * value / 100);
+				break;
 
-	const char*
-	Style::name () const
-	{
-		return self->selector.name();
+			case StyleLength::FILL:
+				break;
+
+			default:
+				invalid_state_error(__FILE__, __LINE__);
+		}
+
+		return *pixel_length != old_length;
 	}
 
-	void
-	Style::add_tag (const char* tag)
+	static void
+	update_frame (View* view, const Style& style)
 	{
-		update_owner(*this);
+		assert(view);
 
-		self->selector.add_tag(tag);
+		View* parent = view->parent();
+		if (!parent) return;
 
-		update_owner(*this);
+		Bounds frame               = view->frame();
+		const Bounds& parent_frame = parent->frame();
+
+		bool update = false;
+		update |=
+			StyleLength_get_pixel_length(&frame.w, style.width(),  parent_frame.w);
+		update |=
+			StyleLength_get_pixel_length(&frame.h, style.height(), parent_frame.h);
+
+		if (update)
+			View_set_frame(view, frame);
 	}
 
 	void
-	Style::remove_tag (const char* tag)
+	Style_apply_to (const Style& style, View* view)
 	{
-		update_owner(*this);
+		assert(view);
 
-		self->selector.remove_tag(tag);
+		//update_margin(view, values);
+		//update_padding(view, values);
+		update_frame(view, style);
+		//update_background(view, values);
+	}
 
-		update_owner(*this);
+	bool
+	Style_has_width (const Style& style)
+	{
+		return style.self->width;
 	}
 
-	Selector::iterator
-	Style::tag_begin ()
+	bool
+	Style_has_height (const Style& style)
 	{
-		return self->selector.begin();
+		return style.self->height;
 	}
 
-	Selector::const_iterator
-	Style::tag_begin () const
+	static void
+	update_owner (const Style& style)
 	{
-		return self->selector.begin();
+		View* owner = style.self->owner;
+		if (!owner) return;
+
+		View_update_styles(owner, style.selector());
 	}
 
-	Selector::iterator
-	Style::tag_end ()
+
+	Style::Style (const char* name)
 	{
-		return self->selector.end();
+		if (name) set_name(name);
 	}
 
-	Selector::const_iterator
-	Style::tag_end () const
+	Style::~Style ()
 	{
-		return self->selector.end();
 	}
 
 	void
-	Style::set_selector (const Selector& selector)
+	Style::set_name (const char* name)
 	{
 		update_owner(*this);
+		HasSelector::set_name(name);
+		update_owner(*this);
+	}
 
-		self->selector = selector;
+	void
+	Style::add_tag (const char* tag)
+	{
+		update_owner(*this);
+		HasSelector::add_tag(tag);
+		update_owner(*this);
+	}
 
+	void
+	Style::remove_tag (const char* tag)
+	{
+		update_owner(*this);
+		HasSelector::remove_tag(tag);
 		update_owner(*this);
 	}
 
-	Selector&
-	Style::selector ()
+	void
+	Style::clear_tags ()
 	{
-		return self->selector;
+		update_owner(*this);
+		HasSelector::clear_tags();
+		update_owner(*this);
 	}
 
-	const Selector&
-	Style::selector () const
+	void
+	Style::set_selector (const Selector& selector)
 	{
-		return self->selector;
+		update_owner(*this);
+		HasSelector::set_selector(selector);
+		update_owner(*this);
 	}
 
 	enum FlowDir {FLOW_INVALID = 0, FLOW_H, FLOW_V};
@@ -552,6 +628,13 @@ namespace Reflex
 		update_owner(*this);
 	}
 
+	void
+	Style::clear_flow ()
+	{
+		if (self->flow.clear())
+			update_owner(*this);
+	}
+
 	void
 	Style::get_flow (Flow* main, Flow* sub) const
 	{
@@ -576,16 +659,30 @@ namespace Reflex
 			update_owner(*this);
 	}
 
+	void
+	Style::clear_width ()
+	{
+		if (self->width.clear())
+			update_owner(*this);
+	}
+
+	void
+	Style::clear_height ()
+	{
+		if (self->height.clear())
+			update_owner(*this);
+	}
+
 	const StyleLength&
 	Style::width () const
 	{
-		return self->width.get(Zero::length);
+		return self->width.get();
 	}
 
 	const StyleLength&
 	Style::height () const
 	{
-		return self->height.get(Zero::length);
+		return self->height.get();
 	}
 
 	void
@@ -616,80 +713,56 @@ namespace Reflex
 			update_owner(*this);
 	}
 
-	const StyleLength&
-	Style::left () const
-	{
-		return self->left.get(Zero::length);
-	}
-
-	const StyleLength&
-	Style::top () const
-	{
-		return self->top.get(Zero::length);
-	}
-
-	const StyleLength&
-	Style::right () const
-	{
-		return self->right.get(Zero::length);
-	}
-
-	const StyleLength&
-	Style::bottom () const
-	{
-		return self->bottom.get(Zero::length);
-	}
-
 	void
-	Style::set_offset_left (const StyleLength& left)
+	Style::clear_left ()
 	{
-		if (self->offset_left.set(left))
+		if (self->left.clear())
 			update_owner(*this);
 	}
 
 	void
-	Style::set_offset_top (const StyleLength& top)
+	Style::clear_top ()
 	{
-		if (self->offset_top.set(top))
+		if (self->top.clear())
 			update_owner(*this);
 	}
 
 	void
-	Style::set_offset_right (const StyleLength& right)
+	Style::clear_right ()
 	{
-		if (self->offset_right.set(right))
+		if (self->right.clear())
 			update_owner(*this);
 	}
 
 	void
-	Style::set_offset_bottom (const StyleLength& bottom)
+	Style::clear_bottom ()
 	{
-		if (self->offset_bottom.set(bottom))
+		if (self->bottom.clear())
 			update_owner(*this);
 	}
 
 	const StyleLength&
-	Style::offset_left () const
+	Style::left () const
 	{
-		return self->offset_left.get(Zero::length);
+		return self->left.get();
 	}
 
 	const StyleLength&
-	Style::offset_top () const
+	Style::top () const
 	{
-		return self->offset_top.get(Zero::length);
+		return self->top.get();
 	}
 
 	const StyleLength&
-	Style::offset_right () const
+	Style::right () const
 	{
-		return self->offset_right.get(Zero::length);
+		return self->right.get();
 	}
 
 	const StyleLength&
-	Style::offset_bottom () const
+	Style::bottom () const
 	{
-		return self->offset_bottom.get(Zero::length);
+		return self->bottom.get();
 	}
 
 	void
@@ -720,28 +793,56 @@ namespace Reflex
 			update_owner(*this);
 	}
 
+	void
+	Style::clear_margin_left ()
+	{
+		if (self->margin_left.clear())
+			update_owner(*this);
+	}
+
+	void
+	Style::clear_margin_top ()
+	{
+		if (self->margin_top.clear())
+			update_owner(*this);
+	}
+
+	void
+	Style::clear_margin_right ()
+	{
+		if (self->margin_right.clear())
+			update_owner(*this);
+	}
+
+	void
+	Style::clear_margin_bottom ()
+	{
+		if (self->margin_bottom.clear())
+			update_owner(*this);
+	}
+
 	const StyleLength&
 	Style::margin_left () const
 	{
-		return self->margin_left.get(Zero::length);
+		return self->margin_left.get();
 	}
 
 	const StyleLength&
 	Style::margin_top () const
 	{
-		return self->margin_top.get(Zero::length);
+		return self->margin_top.get();
 	}
 
 	const StyleLength&
 	Style::margin_right () const
 	{
-		return self->margin_right.get(Zero::length);
+		return self->margin_right.get();
 	}
 
 	const StyleLength&
 	Style::margin_bottom () const
 	{
-		return self->margin_bottom.get(Zero::length);
+		return self->margin_bottom.get();
 	}
 
 	void
@@ -772,158 +873,254 @@ namespace Reflex
 			update_owner(*this);
 	}
 
+	void
+	Style::clear_padding_left ()
+	{
+		if (self->padding_left.clear())
+			update_owner(*this);
+	}
+
+	void
+	Style::clear_padding_top ()
+	{
+		if (self->padding_top.clear())
+			update_owner(*this);
+	}
+
+	void
+	Style::clear_padding_right ()
+	{
+		if (self->padding_right.clear())
+			update_owner(*this);
+	}
+
+	void
+	Style::clear_padding_bottom ()
+	{
+		if (self->padding_bottom.clear())
+			update_owner(*this);
+	}
+
 	const StyleLength&
 	Style::padding_left () const
 	{
-		return self->padding_left.get(Zero::length);
+		return self->padding_left.get();
 	}
 
 	const StyleLength&
 	Style::padding_top () const
 	{
-		return self->padding_top.get(Zero::length);
+		return self->padding_top.get();
 	}
 
 	const StyleLength&
 	Style::padding_right () const
 	{
-		return self->padding_right.get(Zero::length);
+		return self->padding_right.get();
 	}
 
 	const StyleLength&
 	Style::padding_bottom () const
 	{
-		return self->padding_bottom.get(Zero::length);
+		return self->padding_bottom.get();
 	}
 
 	void
-	Style::set_fill (const Color& fill)
+	Style::set_center_x (const StyleLength& x)
 	{
-		if (self->fill.set(fill))
+		if (self->center_x.set(x))
 			update_owner(*this);
 	}
 
-	const Color&
-	Style::fill () const
+	void
+	Style::set_center_y (const StyleLength& y)
 	{
-		return self->fill.get(Zero::color);
+		if (self->center_y.set(y))
+			update_owner(*this);
 	}
 
 	void
-	Style::set_stroke (const Color& stroke)
+	Style::clear_center_x ()
 	{
-		if (self->stroke.set(stroke))
+		if (self->center_x.clear())
 			update_owner(*this);
 	}
 
-	const Color&
-	Style::stroke () const
+	void
+	Style::clear_center_y ()
 	{
-		return self->stroke.get(Zero::color);
+		if (self->center_y.clear())
+			update_owner(*this);
+	}
+
+	const StyleLength&
+	Style::center_x () const
+	{
+		return self->center_x.get();
+	}
+
+	const StyleLength&
+	Style::center_y () const
+	{
+		return self->center_y.get();
 	}
 
 	void
-	Style::set_image (const Image& image)
+	Style::set_foreground_fill (const Color& fill)
 	{
-		if (self->image.set(image))
+		if (self->fore_fill.set(fill))
 			update_owner(*this);
 	}
 
-	const Image&
-	Style::image () const
+	void
+	Style::set_foreground_stroke (const Color& stroke)
 	{
-		return self->image.get(Zero::image);
+		if (self->fore_stroke.set(stroke))
+			update_owner(*this);
 	}
 
-	bool
-	operator == (const Style& lhs, const Style& rhs)
+	void
+	Style::set_foreground_stroke_width (coord width)
 	{
-		return lhs.self.get() == rhs.self.get();
+		if (self->fore_stroke_width.set(width))
+			update_owner(*this);
 	}
 
-	bool
-	operator != (const Style& lhs, const Style& rhs)
+	void
+	Style::set_background_fill (const Color& fill)
 	{
-		return !operator==(lhs, rhs);
+		if (self->back_fill.set(fill))
+			update_owner(*this);
 	}
 
+	void
+	Style::set_background_stroke (const Color& stroke)
+	{
+		if (self->back_stroke.set(stroke))
+			update_owner(*this);
+	}
 
-	static bool
-	get_pixel_length (
-		coord* pixel_length,
-		const StyleLength& style_length, const coord* parent_size)
+	void
+	Style::set_background_stroke_width (coord width)
 	{
-		if (!pixel_length)
-			argument_error(__FILE__, __LINE__);
+		if (self->back_stroke_width.set(width))
+			update_owner(*this);
+	}
 
-		if (!style_length)
-			return false;
+	void
+	Style::clear_foreground_fill ()
+	{
+		if (self->fore_fill.clear())
+			update_owner(*this);
+	}
 
-		coord length = 0;
-		StyleLength::Value value = style_length.value();
-		switch (style_length.unit())
-		{
-			case StyleLength::PIXEL:
-				length = value;
-				break;
+	void
+	Style::clear_foreground_stroke ()
+	{
+		if (self->fore_stroke.clear())
+			update_owner(*this);
+	}
 
-			case StyleLength::PERCENT:
-			{
-				if (!parent_size)
-					argument_error(__FILE__, __LINE__);
+	void
+	Style::clear_foreground_stroke_width ()
+	{
+		if (self->fore_stroke_width.clear())
+			update_owner(*this);
+	}
 
-				length = (value == 100) ?
-					*parent_size : floor(*parent_size * value / 100);
-				break;
-			}
+	void
+	Style::clear_background_fill ()
+	{
+		if (self->back_fill.clear())
+			update_owner(*this);
+	}
 
-			default:
-				invalid_state_error(__FILE__, __LINE__);
-		}
+	void
+	Style::clear_background_stroke ()
+	{
+		if (self->back_stroke.clear())
+			update_owner(*this);
+	}
 
-		if (length == *pixel_length)
-			return false;
+	void
+	Style::clear_background_stroke_width ()
+	{
+		if (self->back_stroke_width.clear())
+			update_owner(*this);
+	}
 
-		*pixel_length = length;
-		return true;
+	const Color&
+	Style::foreground_fill () const
+	{
+		return self->fore_fill.get();
 	}
 
-	static void
-	update_frame (View* view, const Style& style)
+	const Color&
+	Style::foreground_stroke () const
 	{
-		assert(view);
-		Style::Data* s = style.self.get();
+		return self->fore_stroke.get();
+	}
 
-		Bounds frame         = view->frame();
-		View* parent_view    = view->parent();
-		const Bounds* parent = parent_view ? &parent_view->frame() : NULL;
-		bool update          = false;
+	coord
+	Style::foreground_stroke_width () const
+	{
+		return self->fore_stroke_width.get();
+	}
 
-		if (s->width)
-		{
-			update |= get_pixel_length(
-				&frame.width, s->width.value(), parent ? &parent->width  : NULL);
-		}
+	const Color&
+	Style::background_fill () const
+	{
+		return self->back_fill.get();
+	}
 
-		if (s->height) {
-			update |= get_pixel_length(
-				&frame.height, s->height.value(), parent ? &parent->height : NULL);
-		}
+	const Color&
+	Style::background_stroke () const
+	{
+		return self->back_stroke.get();
+	}
 
-		if (update)
-			view->set_frame(frame);
+	coord
+	Style::background_stroke_width () const
+	{
+		return self->back_stroke_width.get();
 	}
 
 	void
-	apply_style (View* view, const Style& style)
+	Style::set_image (const Image& image)
 	{
-		if (!view)
-			argument_error(__FILE__, __LINE__);
+		if (self->image.set(image))
+			update_owner(*this);
+	}
 
-		//update_margin(view, values);
-		//update_padding(view, values);
-		update_frame(view, style);
-		//update_background(view, values);
+	void
+	Style::clear_image ()
+	{
+		if (self->image.clear())
+			update_owner(*this);
+	}
+
+	const Image&
+	Style::image () const
+	{
+		return self->image.get();
+	}
+
+	bool
+	operator == (const Style& lhs, const Style& rhs)
+	{
+		return lhs.self.get() == rhs.self.get();
+	}
+
+	bool
+	operator != (const Style& lhs, const Style& rhs)
+	{
+		return !operator==(lhs, rhs);
+	}
+
+	SelectorPtr*
+	Style::get_selector_ptr ()
+	{
+		return &self->pselector;
 	}