reflexion 0.1.10 → 0.1.11

data/lib/reflex/style.rb

@@ -29,6 +29,21 @@ module Reflex
       get_flow.map {|n| flow2sym n}
     end
 
+    def inspect ()
+      attrs = {
+        selector:         selector,
+        flow:             flow,
+        size:             size,
+        position:         position,
+        offset:           offset,
+        margin:           margin,
+        padding:          padding,
+        background_color: background_color,
+        background_image: background_image
+      }
+      "#<Reflex::Style #{attrs.map {|k, v| %(#{k}:#{v.to_s})}.join ' '}>"
+    end
+
     private
 
       SYM2FLOW = {

data/lib/reflex/style_length.rb

@@ -21,7 +21,7 @@ module Reflex
     end
 
     def inspect ()
-      "#<Reflex::StyleLength #{value}#{unit}>"
+      "#<#{self.class.name} #{to_s}>"
     end
 
   end# StyleLength

data/lib/reflex/view.rb

@@ -26,7 +26,10 @@ module Reflex
       :static=, :static?, :dynamic=, :dynamic?,
       :velocity=, :linear_velocity=, :angular_velocity=,
       :velocity,  :linear_velocity,  :angular_velocity,
-      :density=, :density, :friction=, :friction, :restitution=, :restitution
+      :apply_force, :apply_torque, :apply_impulse,
+      :apply_linear_impulse, :apply_angular_impulse,
+      :density=, :density, :friction=, :friction, :restitution=, :restitution,
+      :gravity_scale=, :gravity_scale
 
     alias add    add_child
     alias remove remove_child
@@ -48,7 +51,7 @@ module Reflex
     end
 
     def style (*args, &block)
-      s = get_style *args
+      s = get_style args.empty? ? nil : Selector.selector(*args)
       Xot::BlockUtil.instance_eval_or_block_call s, &block if block
       s
     end

data/lib/reflex/window.rb

@@ -20,8 +20,8 @@ module Reflex
     extend Forwardable
 
     def_delegators :root,
-      :add_child, :remove_child, :find_children, :style, :meter2pixel, :meter,
-      :gravity=, :gravity, :wall, :debug=, :debug?
+      :add_child, :remove_child, :find_children, :style, :styles,
+      :meter2pixel, :meter, :gravity=, :gravity, :wall, :debug=, :debug?
 
     def_delegators :wall,
       :friction=, :friction, :restitution=, :restitution

data/samples/reflexion/breakout.rb

@@ -9,7 +9,6 @@ require 'reflexion/include'
 
 
 $hit, $bang = [880, 440].map {|n| Sound.new SineWave.new(freq: n), 0.1}
-$garbages   = []
 
 def add_shape (klass: RectShape, frame: [0, 0, 100, 100], color: :white, type: :static)
   window.add klass.new {
@@ -18,27 +17,23 @@ def add_shape (klass: RectShape, frame: [0, 0, 100, 100], color: :white, type: :
 end
 
 setup do
+  style.flow = :none
   set size: [600, 400], friction: 0
   5.times do |y|
     10.times do |x|
       shape = add_shape frame: [(x + 1) * 50, (y + 1) * 20, 30, 10], color: [:white, :red, :green, :blue, :yellow][y]
-      shape.on(:contact) {$hit.play; $garbages << shape}
+      shape.on(:contact) {$hit.play; shape.parent.remove shape}
     end
   end
   $bar   = add_shape frame: [0, 350, 100, 20], color: :blue
   bottom = add_shape frame: [0, window.h - 1, window.w, 1]
-  bottom.on(:contact) {|e| $bang.play; $garbages << e.view}
+  bottom.on(:contact) {|e| $bang.play; e.view.parent.remove e.view}
 end
 
 pointer do |e|
   $bar.x = e.x - $bar.w / 2
   if e.down?
-    ball = add_shape klass: [EllipseShape, RectShape].sample, frame: [e.x, $bar.y - 20, 20, 20], type: :dynamic 
+    ball = add_shape klass: [EllipseShape, RectShape].sample, frame: [e.x, $bar.y - 20, 20, 20], type: :dynamic
     ball.velocity = Point.new(rand(-1.0..1.0), -1).normal * 500
   end
 end
-
-update do
-  $garbages.uniq.each {|o| o.parent.remove o}
-  $garbages.clear
-end

data/src/body.cpp

@@ -314,6 +314,51 @@ namespace Reflex
 		return Xot::rad2deg(PTR->GetAngularVelocity());
 	}
 
+	void
+	Body::apply_force (coord x, coord y)
+	{
+		apply_force(Point(x, y));
+	}
+
+	void
+	Body::apply_force (const Point& force)
+	{
+		assert(PTR);
+
+		PTR->ApplyForceToCenter(to_b2vec2(force, ppm), true);
+	}
+
+	void
+	Body::apply_torque (float torque)
+	{
+		assert(PTR);
+
+		PTR->ApplyTorque(torque, true);
+	}
+
+	void
+	Body::apply_linear_impulse (coord x, coord y)
+	{
+		apply_linear_impulse(Point(x, y));
+	}
+
+	void
+	Body::apply_linear_impulse (const Point& impulse)
+	{
+		assert(PTR);
+
+		PTR->ApplyLinearImpulse(
+			to_b2vec2(impulse, ppm), PTR->GetWorldCenter(), true);
+	}
+
+	void
+	Body::apply_angular_impulse (float impulse)
+	{
+		assert(PTR);
+
+		PTR->ApplyAngularImpulse(impulse, true);
+	}
+
 	void
 	Body::set_density (float density)
 	{
@@ -398,6 +443,22 @@ namespace Reflex
 		return val;
 	}
 
+	void
+	Body::set_gravity_scale (float scale)
+	{
+		assert(PTR);
+
+		return PTR->SetGravityScale(scale);
+	}
+
+	float
+	Body::gravity_scale () const
+	{
+		assert(PTR);
+
+		return PTR->GetGravityScale();
+	}
+
 	Body::iterator
 	Body::begin ()
 	{

data/src/ios/event.mm

@@ -13,9 +13,7 @@ namespace Reflex
 	correct_point (UIView* view, UITouch* touch)
 	{
 		assert(view && touch);
-		CGPoint p = [touch locationInView: view];
-		p.y = [view bounds].size.height - p.y;
-		return p;
+		return [touch locationInView: view];
 	}
 
 

data/src/ios/native_window.mm

@@ -24,26 +24,11 @@ namespace Reflex
 }// Reflex
 
 
-static CGRect device_frame ()
-{
-	UIScreen* screen = [UIScreen mainScreen];
-	CGRect rect      = screen.applicationFrame;
-	CGFloat scale    = screen.scale;
-
-	rect.origin.x     = 0;
-	rect.origin.y     = 0;
-	rect.size.width  *= scale;
-	rect.size.height *= scale;
-
-	return rect;
-}
-
-
 @implementation NativeWindow
 
 	- (id) init
 	{
-		self = [super initWithFrame: device_frame()];
+		self = [super initWithFrame: UIScreen.mainScreen.bounds];
 		if (!self) return nil;
 
 		pref            = new Reflex::Window::Ref;
@@ -106,8 +91,7 @@ static CGRect device_frame ()
 		REF->self->prev_time_update = now;
 
 		REF->on_update(&e);
-		if (!e.is_blocked())
-			Reflex::update_view_tree(REF->root(), e);
+		Reflex::update_view_tree(REF->root(), e);
 	}
 
 	- (void) draw
@@ -139,8 +123,7 @@ static CGRect device_frame ()
 		e.painter->clear();
 
 		REF->on_draw(&e);
-		if (!e.is_blocked())
-			draw_view_tree(REF->root(), e, 0, REF->frame().dup().move_to(0));
+		draw_view_tree(REF->root(), e, 0, REF->frame().dup().move_to(0));
 
 		e.painter->end();
 	}

data/src/ios/opengl_view.mm

@@ -24,7 +24,7 @@
 		GLKView* view = (GLKView*) self.view;
 		view.context             = context;
 		view.drawableDepthFormat = GLKViewDrawableDepthFormat24;
-		view.drawableMultisample = GLKViewDrawableMultisample4X;
+		//view.drawableMultisample = GLKViewDrawableMultisample4X;
 
 		self.preferredFramesPerSecond = 60;
 

data/src/ios/window.mm

@@ -8,6 +8,12 @@
 #import "native_window.h"
 
 
+namespace Rays
+{
+	void set_painter_scale_factor(Painter*, float);
+};
+
+
 namespace Reflex
 {
 
@@ -94,6 +100,7 @@ namespace Reflex
 
 		set_window(self->root.get(), this);
 
+		Rays::set_painter_scale_factor(&self->painter, UIScreen.mainScreen.scale);
 		self->painter.canvas(0, 0, 1, 1);
 	}
 

data/src/selector.cpp

@@ -15,9 +15,9 @@ namespace Reflex
 
 		TagSet tags;
 
-		bool operator == (const Data& rhs)
+		friend bool operator == (const Data& lhs, const Data& rhs)
 		{
-			return name == rhs.name && tags == rhs.tags;
+			return lhs.name == rhs.name && lhs.tags == rhs.tags;
 		}
 
 	};// Selector::Data
@@ -28,6 +28,31 @@ namespace Reflex
 		if (name) set_name(name);
 	}
 
+	Selector
+	Selector::copy () const
+	{
+		Selector t;
+		*t.self = *self;
+		return t;
+	}
+
+	bool
+	Selector::contains (const This& selector) const
+	{
+		if (self->name.empty() && self->tags.empty())
+			return false;
+
+		const TagSet& tags      = self->tags;
+		const_iterator tags_end = tags.end();
+
+		iterator end = selector.end();
+		for (iterator tag = selector.begin(); tag != end; ++tag)
+			if (tags.find(*tag) == tags_end)
+				return false;
+
+		return selector.self->name.empty() || selector.self->name == self->name;
+	}
+
 	void
 	Selector::set_name (const char* name)
 	{
@@ -37,7 +62,7 @@ namespace Reflex
 	const char*
 	Selector::name () const
 	{
-		return self->name.empty() ? NULL : self->name.c_str();
+		return self->name.c_str();
 	}
 
 	void
@@ -89,20 +114,9 @@ namespace Reflex
 	}
 
 	bool
-	Selector::match (const This& obj) const
+	Selector::is_empty () const
 	{
-		if (self->name.empty() && self->tags.empty())
-			return false;
-
-		const TagSet& obj_tags = obj.self->tags;
-		const_iterator obj_end = obj_tags.end();
-
-		iterator end = this->end();
-		for (iterator it = begin(); it != end; ++it)
-			if (obj_tags.find(*it) == obj_end)
-				return false;
-
-		return self->name.empty() || self->name == obj.self->name;
+		return self->name.empty() && self->tags.empty();
 	}
 
 	bool
@@ -117,5 +131,13 @@ namespace Reflex
 		return !operator==(lhs, rhs);
 	}
 
+	bool
+	operator < (const Selector& lhs, const Selector& rhs)
+	{
+		Selector::Data* l = lhs.self.get();
+		Selector::Data* r = rhs.self.get();
+		return l->name < r->name || l->tags < r->tags;
+	}
+
 
 }// Reflex

data/src/style.cpp

@@ -85,22 +85,37 @@ namespace Reflex
 				Wrapper* p = pointer();
 				if (!p)
 				{
-					if (create)
-						p = reset(new Wrapper());
-					else
+					if (!create)
 						invalid_state_error(__FILE__, __LINE__);
+
+					p = reset(new Wrapper());
 				}
 				return p->get();
 			}
 
-			const Value& value (bool create = false) const
+			const Value& get (const Value& defval) const
 			{
-				return const_cast<This*>(this)->value(create);
+				Wrapper* p = pointer();
+				return p ? p->get() : defval;
 			}
 
-			void set_inherited (bool state = true)
+			bool set (const Value& val)
 			{
-				if (pointer()) pwrapper = Xot::set_pointer_flag(pwrapper, state);
+				Value& current = value(true);
+				if (current == val)
+					return false;
+
+				current = val;
+				return true;
+			}
+
+			void override (const This& value)
+			{
+				if (!value || (*this && !is_inherited()))
+					return;
+
+				reset(value.pointer());
+				set_inherited();
 			}
 
 			bool is_inherited () const
@@ -128,101 +143,295 @@ namespace Reflex
 				return p;
 			}
 
-			      Wrapper* pointer ()       {return Xot::set_pointer_flag(pwrapper, false);}
+			void set_inherited (bool state = true)
+			{
+				if (pwrapper)
+					pwrapper = Xot::set_pointer_flag(pwrapper, state);
+			}
 
-			const Wrapper* pointer () const {return const_cast<StyleValue*>(this)->pointer();}
+			Wrapper* pointer () const {return Xot::set_pointer_flag(pwrapper, false);}
 
 	};// StyleValue
 
 
-	struct Style::Data : public Xot::RefCountable<>
+	struct StyleLength::Data
 	{
 
-		typedef StyleValue<bool>         Bool;
-
-		typedef StyleValue<int>          Int;
+		Value value;
 
-		typedef StyleValue<double>       Float;
+		Unit unit;
 
-		typedef StyleValue<StyleLength>  Length;
+		Data () : value(0), unit(NONE) {}
 
-		typedef StyleValue<StyleLength2> Length2;
+		friend bool operator == (const Data& lhs, const Data& rhs)
+		{
+			return lhs.value == rhs.value && lhs.unit == rhs.unit;
+		}
 
-		typedef StyleValue<StyleLength4> Length4;
+	};// StyleLength::Data
 
-		typedef StyleValue<Color>        Color;
 
-		typedef StyleValue<Image>        Image;
+	StyleLength::StyleLength ()
+	{
+	}
 
-		View* owner;
+	StyleLength::StyleLength (Value value, Unit unit)
+	{
+		reset(value, unit);
+	}
 
-		Selector selector;
+	StyleLength::StyleLength (const char* str)
+	{
+		reset(str);
+	}
 
-		Int flow_main, flow_sub;
+	StyleLength
+	StyleLength::copy () const
+	{
+		return StyleLength(value(), unit());
+	}
 
-		Length2 size;
+	void
+	StyleLength::reset (Value value, Unit unit)
+	{
+		if (unit < NONE || UNIT_LAST <= unit)
+			argument_error(__FILE__, __LINE__);
 
-		Length4 position, offset, margin, padding;
+		self->value = value;
+		self->unit  = unit;
+	}
 
-		Color background_color;
+	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;
+	}
 
-		Image background_image;
+	static const char*
+	unit2str (StyleLength::Unit unit)
+	{
+		switch (unit)
+		{
+			case StyleLength::PIXEL:   return "px";
+			case StyleLength::PERCENT: return "%";
+			default:                   return NULL;
+		}
+	}
 
-		Data () : owner(NULL) {}
+	void
+	StyleLength::reset (const char* str)
+	{
+		Value num;
+		char suffix[256];
+		int count = sscanf(str, "%f%s", &num, suffix);
+		if (count != 2)
+			argument_error(__FILE__, __LINE__);
 
-	};// Style::Data
+		reset(num, str2unit(suffix));
+	}
 
+	StyleLength::Value
+	StyleLength::value () const
+	{
+		return self->value;
+	}
 
-	namespace Zero
+	StyleLength::Unit
+	StyleLength::unit () const
 	{
+		return self->unit;
+	}
 
-		static const StyleLength  length;
+	String
+	StyleLength::to_s () const
+	{
+		if (!*this)
+			return "";
 
-		static const StyleLength2 length2;
+		String num;
+		if (fmod(self->value, 1) == 0)
+			num = Xot::stringf("%d", (long) self->value);
+		else
+			num = Xot::stringf("%g", self->value);
 
-		static const StyleLength4 length4;
+		const char* suffix = unit2str(self->unit);;
+		if (!suffix)
+			invalid_state_error(__FILE__, __LINE__);
 
-		static const Color        color(0);
+		return num + suffix;
+	}
 
-		static const Image        image;
+	StyleLength::operator bool () const
+	{
+		return NONE < self->unit && self->unit < UNIT_LAST;
+	}
 
-	}// Zero
+	bool
+	StyleLength::operator ! () const
+	{
+		return !operator bool();
+	}
 
+	bool
+	operator == (const StyleLength& lhs, const StyleLength& rhs)
+	{
+		return (!lhs && !rhs) || *lhs.self == *rhs.self;
+	}
 
-	static Style::Data*
-	get_data (Style* this_, bool create = false)
+	bool
+	operator != (const StyleLength& lhs, const StyleLength& rhs)
 	{
-		if (!this_)
-			argument_error(__FILE__, __LINE__);
+		return !operator ==(lhs, rhs);
+	}
 
-		if (create && !this_->ref)
-			this_->ref.reset(new Style::Data());
 
-		return this_->ref.get();
+	void
+	get_default_flow (Style::Flow* main, Style::Flow* sub)
+	{
+		assert(main || sub);
+
+		if (main) *main = Style::FLOW_RIGHT;
+		if (sub)  *sub  = Style::FLOW_DOWN;
 	}
 
-	static const Style::Data*
-	get_data (const Style* this_)
+
+	struct Style::Data
 	{
-		return get_data(const_cast<Style*>(this_));
-	}
 
+		typedef StyleValue<bool>        Bool;
 
-	Style::Style (const char* name)
+		typedef StyleValue<int>         Int;
+
+		typedef StyleValue<double>      Float;
+
+		typedef StyleValue<Color>       Color;
+
+		typedef StyleValue<Image>       Image;
+
+		typedef StyleValue<StyleLength> Length;
+
+		View* owner;
+
+		Selector selector;
+
+		Int flow;
+
+		Length width, height;
+
+		Length         left,         top,         right,         bottom;
+
+		Length  offset_left,  offset_top,  offset_right,  offset_bottom;
+
+		Length  margin_left,  margin_top,  margin_right,  margin_bottom;
+
+		Length padding_left, padding_top, padding_right, padding_bottom;
+
+		Color fill, stroke;
+
+		Image image;
+
+		Data ()
+		:	owner(NULL)
+		{
+		}
+
+		enum FlowOffset {FLOW_MASK = 0xffff, FLOW_SHIFT = 16};
+
+		bool set_flow (Flow main, Flow sub)
+		{
+			return flow.set((main & FLOW_MASK) | ((sub & FLOW_MASK) << FLOW_SHIFT));
+		}
+
+		Flow flow_main () const
+		{
+			Flow defval = FLOW_NONE;
+			get_default_flow(&defval, NULL);
+			return (Flow) (flow.get(defval) & 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);
+		}
+
+	};// Data
+
+
+	namespace Zero
 	{
-		if (name) set_name(name);
+
+		static const Color       color;
+
+		static const Image       image;
+
+		static const StyleLength length;
+
+	}// Zero
+
+
+	bool
+	set_style_owner (Style* style, View* owner)
+	{
+		assert(style);
+
+		if (style->self->owner)
+			return false;
+
+		style->self->owner = owner;
+		return true;
 	}
 
-	Style::Style (const This& obj)
-	:	ref(obj.ref)
+	static void
+	update_owner (const Style& style)
 	{
+		View* owner = style.self->owner;
+		if (!owner) return;
+
+		void update_styles_for_selector (View*, const Selector&);
+		update_styles_for_selector(owner, style.self->selector);
 	}
 
-	Style&
-	Style::operator = (const This& obj)
+	void
+	override_style (Style* overridden, const Style& overrides)
+	{
+		assert(overridden);
+
+		Style::Data* from  = overrides.self.get();
+		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);
+	}
+
+
+	Style::Style (const char* name)
 	{
-		if (&obj != this) ref = obj.ref;
-		return *this;
+		if (name) set_name(name);
 	}
 
 	Style::~Style ()
@@ -232,80 +441,83 @@ namespace Reflex
 	void
 	Style::set_name (const char* name)
 	{
-		get_data(this, true)->selector.set_name(name);
+		update_owner(*this);
+
+		self->selector.set_name(name);
+
+		update_owner(*this);
 	}
 
 	const char*
 	Style::name () const
 	{
-		const Data* data = get_data(this);
-		return data ? data->selector.name() : NULL;
+		return self->selector.name();
 	}
 
 	void
 	Style::add_tag (const char* tag)
 	{
-		get_data(this, true)->selector.add_tag(tag);
+		update_owner(*this);
+
+		self->selector.add_tag(tag);
+
+		update_owner(*this);
 	}
 
 	void
 	Style::remove_tag (const char* tag)
 	{
-		Data* data = get_data(this);
-		if (!data) return;
+		update_owner(*this);
 
-		data->selector.remove_tag(tag);
-	}
+		self->selector.remove_tag(tag);
 
-	static Selector::TagSet empty_tags;
+		update_owner(*this);
+	}
 
 	Selector::iterator
 	Style::tag_begin ()
 	{
-		Data* data = get_data(this);
-		return data ? data->selector.begin() : empty_tags.begin();
+		return self->selector.begin();
 	}
 
 	Selector::const_iterator
 	Style::tag_begin () const
 	{
-		const Data* data = get_data(this);
-		return data ? data->selector.begin() : empty_tags.begin();
+		return self->selector.begin();
 	}
 
 	Selector::iterator
 	Style::tag_end ()
 	{
-		Data* data = get_data(this);
-		return data ? data->selector.end() : empty_tags.end();
+		return self->selector.end();
 	}
 
 	Selector::const_iterator
 	Style::tag_end () const
 	{
-		const Data* data = get_data(this);
-		return data ? data->selector.end() : empty_tags.end();
+		return self->selector.end();
 	}
 
 	void
 	Style::set_selector (const Selector& selector)
 	{
-		get_data(this, true)->selector = selector;
+		update_owner(*this);
+
+		self->selector = selector;
+
+		update_owner(*this);
 	}
 
 	Selector&
 	Style::selector ()
 	{
-		return get_data(this, true)->selector;
+		return self->selector;
 	}
 
 	const Selector&
 	Style::selector () const
 	{
-		static const Selector EMPTY;
-
-		const Data* data = get_data(this);
-		return data ? data->selector : EMPTY;
+		return self->selector;
 	}
 
 	enum FlowDir {FLOW_INVALID = 0, FLOW_H, FLOW_V};
@@ -319,8 +531,8 @@ namespace Reflex
 			case Style::FLOW_RIGHT: return FLOW_H;
 			case Style::FLOW_UP:
 			case Style::FLOW_DOWN:  return FLOW_V;
+			default:                return FLOW_INVALID;
 		}
-		return FLOW_INVALID;
 	}
 
 	void
@@ -335,9 +547,9 @@ namespace Reflex
 			argument_error(__FILE__, __LINE__);
 		}
 
-		Data* data = get_data(this, true);
-		data->flow_main = main;
-		data->flow_sub  = sub;
+		self->set_flow(main, sub);
+
+		update_owner(*this);
 	}
 
 	void
@@ -346,224 +558,287 @@ namespace Reflex
 		if (!main && !sub)
 			argument_error(__FILE__, __LINE__);
 
-		const Data* data = get_data(this);
-		if (!data || (!data->flow_main && !data->flow_sub))
-		{
-			if (main) *main = FLOW_DOWN;
-			if (sub)  *sub  = FLOW_NONE;
-		}
-		else if (data->flow_main && data->flow_sub)
-		{
-			if (main) *main = (Flow) data->flow_main.value();
-			if (sub)  *sub  = (Flow) data->flow_sub.value();
-		}
-		else
-			invalid_state_error(__FILE__, __LINE__);
-	}
-
-	void
-	Style::set_size (const StyleLength2& size)
-	{
-		get_data(this, true)->size = size;
+		if (main) *main = self->flow_main();
+		if (sub)  *sub  = self->flow_sub();
 	}
 
 	void
 	Style::set_width (const StyleLength& width)
 	{
-		get_data(this, true)->size.value(true).set_width(width);
+		if (self->width.set(width))
+			update_owner(*this);
 	}
 
 	void
 	Style::set_height (const StyleLength& height)
 	{
-		get_data(this, true)->size.value(true).set_height(height);
+		if (self->height.set(height))
+			update_owner(*this);
 	}
 
-	const StyleLength2&
-	Style::size () const
+	const StyleLength&
+	Style::width () const
 	{
-		const Data* data = get_data(this);
-		return data && data->size ? data->size.value() : Zero::length2;
+		return self->width.get(Zero::length);
 	}
 
-	void
-	Style::set_position (const StyleLength4& position)
+	const StyleLength&
+	Style::height () const
 	{
-		get_data(this, true)->position = position;
+		return self->height.get(Zero::length);
 	}
 
 	void
 	Style::set_left (const StyleLength& left)
 	{
-		get_data(this, true)->position.value(true).set_left(left);
+		if (self->left.set(left))
+			update_owner(*this);
 	}
 
 	void
 	Style::set_top (const StyleLength& top)
 	{
-		get_data(this, true)->position.value(true).set_top(top);
+		if (self->top.set(top))
+			update_owner(*this);
 	}
 
 	void
 	Style::set_right (const StyleLength& right)
 	{
-		get_data(this, true)->position.value(true).set_right(right);
+		if (self->right.set(right))
+			update_owner(*this);
 	}
 
 	void
 	Style::set_bottom (const StyleLength& bottom)
 	{
-		get_data(this, true)->position.value(true).set_bottom(bottom);
+		if (self->bottom.set(bottom))
+			update_owner(*this);
 	}
 
-	const StyleLength4&
-	Style::position () const
+	const StyleLength&
+	Style::left () const
 	{
-		const Data* data = get_data(this);
-		return data && data->position ? data->position.value() : Zero::length4;
+		return self->left.get(Zero::length);
 	}
 
-	void
-	Style::set_offset (const StyleLength4& offset)
+	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
 	{
-		get_data(this, true)->offset = offset;
+		return self->bottom.get(Zero::length);
 	}
 
 	void
 	Style::set_offset_left (const StyleLength& left)
 	{
-		get_data(this, true)->offset.value(true).set_left(left);
+		if (self->offset_left.set(left))
+			update_owner(*this);
 	}
 
 	void
 	Style::set_offset_top (const StyleLength& top)
 	{
-		get_data(this, true)->offset.value(true).set_top(top);
+		if (self->offset_top.set(top))
+			update_owner(*this);
 	}
 
 	void
 	Style::set_offset_right (const StyleLength& right)
 	{
-		get_data(this, true)->offset.value(true).set_right(right);
+		if (self->offset_right.set(right))
+			update_owner(*this);
 	}
 
 	void
 	Style::set_offset_bottom (const StyleLength& bottom)
 	{
-		get_data(this, true)->offset.value(true).set_bottom(bottom);
+		if (self->offset_bottom.set(bottom))
+			update_owner(*this);
 	}
 
-	const StyleLength4&
-	Style::offset () const
+	const StyleLength&
+	Style::offset_left () const
 	{
-		const Data* data = get_data(this);
-		return data && data->offset ? data->offset.value() : Zero::length4;
+		return self->offset_left.get(Zero::length);
 	}
 
-	void
-	Style::set_margin (const StyleLength4& margin)
+	const StyleLength&
+	Style::offset_top () const
 	{
-		get_data(this, true)->margin = margin;
+		return self->offset_top.get(Zero::length);
+	}
+
+	const StyleLength&
+	Style::offset_right () const
+	{
+		return self->offset_right.get(Zero::length);
+	}
+
+	const StyleLength&
+	Style::offset_bottom () const
+	{
+		return self->offset_bottom.get(Zero::length);
 	}
 
 	void
 	Style::set_margin_left (const StyleLength& left)
 	{
-		get_data(this, true)->margin.value(true).set_left(left);
+		if (self->margin_left.set(left))
+			update_owner(*this);
 	}
 
 	void
 	Style::set_margin_top (const StyleLength& top)
 	{
-		get_data(this, true)->margin.value(true).set_top(top);
+		if (self->margin_top.set(top))
+			update_owner(*this);
 	}
 
 	void
 	Style::set_margin_right (const StyleLength& right)
 	{
-		get_data(this, true)->margin.value(true).set_right(right);
+		if (self->margin_right.set(right))
+			update_owner(*this);
 	}
 
 	void
 	Style::set_margin_bottom (const StyleLength& bottom)
 	{
-		get_data(this, true)->margin.value(true).set_bottom(bottom);
+		if (self->margin_bottom.set(bottom))
+			update_owner(*this);
 	}
 
-	const StyleLength4&
-	Style::margin () const
+	const StyleLength&
+	Style::margin_left () const
 	{
-		const Data* data = get_data(this);
-		return data && data->margin ? data->margin.value() : Zero::length4;
+		return self->margin_left.get(Zero::length);
 	}
 
-	void
-	Style::set_padding (const StyleLength4& padding)
+	const StyleLength&
+	Style::margin_top () const
+	{
+		return self->margin_top.get(Zero::length);
+	}
+
+	const StyleLength&
+	Style::margin_right () const
 	{
-		get_data(this, true)->padding = padding;
+		return self->margin_right.get(Zero::length);
+	}
+
+	const StyleLength&
+	Style::margin_bottom () const
+	{
+		return self->margin_bottom.get(Zero::length);
 	}
 
 	void
 	Style::set_padding_left (const StyleLength& left)
 	{
-		get_data(this, true)->padding.value(true).set_left(left);
+		if (self->padding_left.set(left))
+			update_owner(*this);
 	}
 
 	void
 	Style::set_padding_top (const StyleLength& top)
 	{
-		get_data(this, true)->padding.value(true).set_top(top);
+		if (self->padding_top.set(top))
+			update_owner(*this);
 	}
 
 	void
 	Style::set_padding_right (const StyleLength& right)
 	{
-		get_data(this, true)->padding.value(true).set_right(right);
+		if (self->padding_right.set(right))
+			update_owner(*this);
 	}
 
 	void
 	Style::set_padding_bottom (const StyleLength& bottom)
 	{
-		get_data(this, true)->padding.value(true).set_bottom(bottom);
+		if (self->padding_bottom.set(bottom))
+			update_owner(*this);
+	}
+
+	const StyleLength&
+	Style::padding_left () const
+	{
+		return self->padding_left.get(Zero::length);
+	}
+
+	const StyleLength&
+	Style::padding_top () const
+	{
+		return self->padding_top.get(Zero::length);
+	}
+
+	const StyleLength&
+	Style::padding_right () const
+	{
+		return self->padding_right.get(Zero::length);
+	}
+
+	const StyleLength&
+	Style::padding_bottom () const
+	{
+		return self->padding_bottom.get(Zero::length);
 	}
 
-	const StyleLength4&
-	Style::padding () const
+	void
+	Style::set_fill (const Color& fill)
 	{
-		const Data* data = get_data(this);
-		return data && data->padding ? data->padding.value() : Zero::length4;
+		if (self->fill.set(fill))
+			update_owner(*this);
+	}
+
+	const Color&
+	Style::fill () const
+	{
+		return self->fill.get(Zero::color);
 	}
 
 	void
-	Style::set_background_color (const Color& value)
+	Style::set_stroke (const Color& stroke)
 	{
-		get_data(this, true)->background_color = value;
+		if (self->stroke.set(stroke))
+			update_owner(*this);
 	}
 
 	const Color&
-	Style::background_color () const
+	Style::stroke () const
 	{
-		const Data* data = get_data(this);
-		return data && data->background_color ? data->background_color.value() : Zero::color;
+		return self->stroke.get(Zero::color);
 	}
 
 	void
-	Style::set_background_image (const Image& value)
+	Style::set_image (const Image& image)
 	{
-		get_data(this, true)->background_image = value;
+		if (self->image.set(image))
+			update_owner(*this);
 	}
 
 	const Image&
-	Style::background_image () const
+	Style::image () const
 	{
-		const Data* data = get_data(this);
-		return data && data->background_image ? data->background_image.value() : Zero::image;
+		return self->image.get(Zero::image);
 	}
 
 	bool
 	operator == (const Style& lhs, const Style& rhs)
 	{
-		return lhs.ref == rhs.ref;
+		return lhs.self.get() == rhs.self.get();
 	}
 
 	bool
@@ -573,4 +848,83 @@ namespace Reflex
 	}
 
 
+	static bool
+	get_pixel_length (
+		coord* pixel_length,
+		const StyleLength& style_length, const coord* parent_size)
+	{
+		if (!pixel_length)
+			argument_error(__FILE__, __LINE__);
+
+		if (!style_length)
+			return false;
+
+		coord length = 0;
+		StyleLength::Value value = style_length.value();
+		switch (style_length.unit())
+		{
+			case StyleLength::PIXEL:
+				length = value;
+				break;
+
+			case StyleLength::PERCENT:
+			{
+				if (!parent_size)
+					argument_error(__FILE__, __LINE__);
+
+				length = (value == 100) ?
+					*parent_size : floor(*parent_size * value / 100);
+				break;
+			}
+
+			default:
+				invalid_state_error(__FILE__, __LINE__);
+		}
+
+		if (length == *pixel_length)
+			return false;
+
+		*pixel_length = length;
+		return true;
+	}
+
+	static void
+	update_frame (View* view, const Style& style)
+	{
+		assert(view);
+		Style::Data* s = style.self.get();
+
+		Bounds frame         = view->frame();
+		View* parent_view    = view->parent();
+		const Bounds* parent = parent_view ? &parent_view->frame() : NULL;
+		bool update          = false;
+
+		if (s->width)
+		{
+			update |= get_pixel_length(
+				&frame.width, s->width.value(), parent ? &parent->width  : NULL);
+		}
+
+		if (s->height) {
+			update |= get_pixel_length(
+				&frame.height, s->height.value(), parent ? &parent->height : NULL);
+		}
+
+		if (update)
+			view->set_frame(frame);
+	}
+
+	void
+	apply_style (View* view, const Style& style)
+	{
+		if (!view)
+			argument_error(__FILE__, __LINE__);
+
+		//update_margin(view, values);
+		//update_padding(view, values);
+		update_frame(view, style);
+		//update_background(view, values);
+	}
+
+
 }// Reflex