reflexion 0.1.11 → 0.1.16

data/src/style.h

@@ -0,0 +1,39 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_SRC_STYLE_H__
+#define __REFLEX_SRC_STYLE_H__
+
+
+#include <reflex/style.h>
+
+
+namespace Reflex
+{
+
+
+	class View;
+
+
+	bool StyleLength_get_pixel_length (
+		coord* pixel_length, const StyleLength& style_length, coord parent_size);
+
+
+	bool Style_set_owner (Style* style, View* owner);
+
+	bool Style_has_variable_lengths (const Style& style);
+
+	void Style_clear_inherited_values (Style* style);
+
+	void Style_override (Style* overridden, const Style& overrides);
+
+	void Style_apply_to (const Style& style, View* view);
+
+	bool Style_has_width  (const Style& style);
+
+	bool Style_has_height (const Style& style);
+
+
+}// Reflex
+
+
+#endif//EOH

data/src/timer.cpp

@@ -0,0 +1,288 @@
+#include "reflex/timer.h"
+#include "timer.h"
+
+
+#include "reflex/view.h"
+#include "reflex/event.h"
+#include "reflex/exception.h"
+#include "selector.h"
+
+
+namespace Reflex
+{
+
+
+	struct Timer::Data
+	{
+
+		View* owner;
+
+		int id, count;
+
+		float interval;
+
+		double next_time;
+
+		SelectorPtr pselector;
+
+		Data ()
+		:	owner(NULL), id(ID_INVALID), count(1), interval(-1), next_time(-1)
+		{
+		}
+
+		Selector& selector ()
+		{
+			if (!pselector) pselector.reset(new Selector);
+			return *pselector;
+		}
+
+	};// Data
+
+
+	namespace global
+	{
+
+		static Timer_CreateFun create_fun = NULL;
+
+	}// global
+
+	void
+	Timer_set_create_fun (Timer_CreateFun fun)
+	{
+		global::create_fun = fun;
+	}
+
+	static Timer*
+	Timer_create ()
+	{
+		return global::create_fun
+			?	global::create_fun()
+			:	new Timer();
+	}
+
+
+	Timer::Timer ()
+	{
+	}
+
+	Timer::~Timer ()
+	{
+	}
+
+	void
+	Timer::fire ()
+	{
+		if (!*this)
+			invalid_state_error(__FILE__, __LINE__);
+
+		TimerEvent e(this);
+		self->owner->on_timer(&e);
+	}
+
+	void
+	Timer::stop ()
+	{
+		set_count(0);
+	}
+
+	View*
+	Timer::owner () const
+	{
+		return self->owner;
+	}
+
+	int
+	Timer::id () const
+	{
+		return self->id;
+	}
+
+	float
+	Timer::interval () const
+	{
+		return self->interval;
+	}
+
+	void
+	Timer::set_count (int count)
+	{
+		self->count = count;
+	}
+
+	int
+	Timer::count () const
+	{
+		return self->count;
+	}
+
+	bool
+	Timer::is_finished () const
+	{
+		return self->count == 0;
+	}
+
+	Timer::operator bool () const
+	{
+		const Data* p = self.get();
+		return p->owner && p->id != ID_INVALID && p->interval >= 0;
+	}
+
+	bool
+	Timer::operator ! () const
+	{
+		return !operator bool();
+	}
+
+	bool
+	operator == (const Timer& lhs, const Timer& rhs)
+	{
+		return lhs.self.get() == rhs.self.get();
+	}
+
+	bool
+	operator != (const Timer& lhs, const Timer& rhs)
+	{
+		return !operator==(lhs, rhs);
+	}
+
+	SelectorPtr*
+	Timer::get_selector_ptr ()
+	{
+		return &self->pselector;
+	}
+
+
+	Timers::Timers ()
+	:	next_id(Timer::ID_FIRST)
+	{
+	}
+
+	void
+	Timers::add (Timer* timer)
+	{
+		assert(timer && *timer);
+
+		for (auto it = timers.begin(), end = timers.end(); it != end; ++it)
+		{
+			if (timer->self->next_time < (*it)->self->next_time)
+			{
+				timers.insert(it, timer);
+				return;
+			}
+		}
+
+		timers.push_back(timer);
+	}
+
+	static void
+	update_next_time (Timer* timer)
+	{
+		assert(timer && *timer);
+
+		timer->self->next_time = Xot::time() + timer->self->interval;
+	}
+
+	static void
+	setup_timer (Timer* timer, View* owner, int id, float interval, int count)
+	{
+		assert(timer);
+
+		Timer::Data* self = timer->self.get();
+
+		self->owner    = owner;
+		self->id       = id;
+		self->interval = interval;
+		self->count    = count;
+
+		update_next_time(timer);
+	}
+
+	Timer*
+	Timers::add (View* owner, float interval, int count)
+	{
+		if (!owner)
+			argument_error(__FILE__, __LINE__);
+
+		Timer* timer = Timer_create();
+		if (!timer)
+			reflex_error(__FILE__, __LINE__, "failed to create timer.");
+
+		setup_timer(timer, owner, next_id++, interval, count);
+		add(timer);
+		return timer;
+	}
+
+	void
+	Timers::remove (Timer* timer)
+	{
+		if (!timer)
+			argument_error(__FILE__, __LINE__);
+
+		for (auto it = timers.begin(), end = timers.end(); it != end; ++it)
+		{
+			if (timer->id() == (*it)->id())
+				timers.erase(it);
+		}
+	}
+
+	static bool
+	is_time_to_fire (Timer* timer, double now)
+	{
+		assert(timer);
+
+		return now >= timer->self->next_time;
+	}
+
+	static void
+	fire_timer (Timer* timer)
+	{
+		assert(timer);
+
+		if (timer->is_finished())
+			return;
+
+		if (timer->self->count > 0)
+			--timer->self->count;
+
+		timer->fire();
+
+		if (!timer->is_finished())
+			update_next_time(timer);
+	}
+
+	static bool
+	compare_timer (const Timer::Ref& lhs, const Timer::Ref& rhs)
+	{
+		return lhs->is_finished() || lhs->self->next_time < rhs->self->next_time;
+	}
+
+	void
+	Timers::fire (double now)
+	{
+		for (auto it = timers.begin(), end = timers.end(); it != end; ++it)
+		{
+			Timer* timer = it->get();
+			if (!is_time_to_fire(timer, now))
+				break;
+
+			fire_timer(timer);
+		}
+
+		timers.sort(compare_timer);
+
+		while (!timers.empty() && timers.front()->is_finished())
+			timers.pop_front();
+	}
+
+	void
+	Timers::find_timers (
+		TimerList* result, const Selector& selector, bool recursive) const
+	{
+		if (!result)
+			argument_error(__FILE__, __LINE__);
+
+		not_implemented_error(__FILE__, __LINE__);
+	}
+
+
+}// Reflex

data/src/timer.h

@@ -0,0 +1,55 @@
+// -*- c++ -*-
+#pragma once
+#ifndef __REFLEX_SRC_TIMER_H__
+#define __REFLEX_SRC_TIMER_H__
+
+
+#include <vector>
+#include <list>
+#include <reflex/timer.h>
+
+
+namespace Reflex
+{
+
+
+	class Timers
+	{
+
+		public:
+
+			typedef std::vector<Timer::Ref> TimerList;
+
+			Timers ();
+
+			Timer* add (View* owner, float interval, int count = 1);
+
+			void remove (Timer* timer);
+
+			void fire (double now);
+
+			void find_timers (
+				TimerList* result, const Selector& selector, bool recuesive = false) const;
+
+		private:
+
+			typedef std::list<Timer::Ref> List;
+
+			List timers;
+
+			int next_id;
+
+			void add (Timer* timer);
+
+	};// Timers
+
+
+	typedef Timer* (*Timer_CreateFun) ();
+
+	void Timer_set_create_fun (Timer_CreateFun fun);
+
+
+}// Reflex
+
+
+#endif//EOH

data/src/view.cpp

@@ -1,21 +1,28 @@
-#include "reflex/view.h"
+#include "view.h"
 
 
 #include <assert.h>
+#include <memory>
 #include <algorithm>
-#include <boost/scoped_ptr.hpp>
-#include <xot/util.h>
-#include "reflex/window.h"
-#include "reflex/body.h"
+#include "reflex/timer.h"
+#include "reflex/filter.h"
 #include "reflex/exception.h"
+#include "reflex/debug.h"
+#include "window.h"
+#include "selector.h"
+#include "timer.h"
+#include "style.h"
+#include "shape.h"
 #include "world.h"
+#include "body.h"
+#include "fixture.h"
 
 
 namespace Reflex
 {
 
 
-	bool set_style_owner (Style* style, View* owner);
+	static const char* WALL_NAME = "__WALL__";
 
 
 	struct View::Data
@@ -23,22 +30,26 @@ namespace Reflex
 
 		typedef std::set<Selector> SelectorSet;
 
-		enum Flags
+		enum Flag
 		{
 
-			ACTIVE         = 0x1 << 0,
+			REDRAW               = Xot::bit(1, FLAG_LAST),
 
-			UPDATE_STYLE   = 0x1 << 1,
+			APPLY_STYLE          = Xot::bit(2, FLAG_LAST),
 
-			UPDATE_LAYOUT  = 0x1 << 2,
+			UPDATE_STYLE         = Xot::bit(3, FLAG_LAST),
 
-			UPDATING_WORLD = 0x1 << 3,
+			UPDATE_SHAPES        = Xot::bit(4, FLAG_LAST),
 
-			REMOVE_SELF    = 0x1 << 4,
+			UPDATE_LAYOUT        = Xot::bit(5, FLAG_LAST),
 
-			DEFAULT_FLAGS  = UPDATE_STYLE | UPDATE_LAYOUT
+			FIT_TO_CONTENT       = Xot::bit(6, FLAG_LAST),
 
-		};// Flags
+			HAS_VARIABLE_LENGTHS = Xot::bit(7, FLAG_LAST),
+
+			NO_SHAPE             = Xot::bit(8, FLAG_LAST),
+
+		};// Flag
 
 		Window* window;
 
@@ -54,25 +65,36 @@ namespace Reflex
 
 		uint flags;
 
-		boost::scoped_ptr<Selector>    pselector;
+		std::unique_ptr<Point>       pscroll;
+
+		SelectorPtr                  pselector;
+
+		std::unique_ptr<SelectorSet> pselectors_for_update;
 
-		boost::scoped_ptr<SelectorSet> pselectors_for_update;
+		std::unique_ptr<Image>       pcache_image;
 
-		boost::scoped_ptr<Point>       pscroll;
+		std::unique_ptr<Timers>      ptimers;
 
-		boost::scoped_ptr<ChildList>   pchildren;
+		std::unique_ptr<Style>       pstyle;
 
-		boost::scoped_ptr<Style>       pstyle;
+		std::unique_ptr<StyleList>   pstyles;
 
-		boost::scoped_ptr<StyleList>   pstyles;
+		Shape::Ref                   pshape;
 
-		boost::scoped_ptr<World>       pworld;
+		std::unique_ptr<ShapeList>   pshapes;
 
-		boost::scoped_ptr<Body>        pbody;
+		Filter::Ref                  pfilter;
+
+		std::unique_ptr<Body>        pbody;
+
+		std::unique_ptr<World>       pchild_world;
+
+		std::unique_ptr<ChildList>   pchildren;
 
 		Data ()
-		:	window(NULL), parent(NULL), zoom(1), angle(0),
-			capture(CAPTURE_NONE), hide_count(0), flags(DEFAULT_FLAGS)
+		:	window(NULL), parent(NULL),
+			zoom(1), angle(0), capture(CAPTURE_NONE), hide_count(0),
+			flags(FLAG_CLIP | FLAG_RESIZE_TO_FIT | REDRAW | UPDATE_LAYOUT | UPDATE_STYLE)
 		{
 		}
 
@@ -80,6 +102,12 @@ namespace Reflex
 		{
 		}
 
+		Point& scroll ()
+		{
+			if (!pscroll) pscroll.reset(new Point);
+			return *pscroll;
+		}
+
 		Selector& selector ()
 		{
 			if (!pselector) pselector.reset(new Selector);
@@ -92,24 +120,18 @@ namespace Reflex
 			return *pselectors_for_update;
 		}
 
-		Point& scroll ()
-		{
-			if (!pscroll) pscroll.reset(new Point);
-			return *pscroll;
-		}
-
-		ChildList& children ()
+		Timers& timers ()
 		{
-			if (!pchildren) pchildren.reset(new ChildList);
-			return *pchildren;
+			if (!ptimers) ptimers.reset(new Timers);
+			return *ptimers;
 		}
 
-		Style& style (View* this_)
+		Style& style (View* view)
 		{
 			if (!pstyle)
 			{
 				pstyle.reset(new Style);
-				set_style_owner(pstyle.get(), this_);
+				Style_set_owner(pstyle.get(), view);
 			}
 			return *pstyle;
 		}
@@ -120,164 +142,518 @@ namespace Reflex
 			return *pstyles;
 		}
 
-		World* world (View* this_)
+		ShapeList& shapes ()
+		{
+			if (!pshapes) pshapes.reset(new ShapeList);
+			return *pshapes;
+		}
+
+		template <typename FUN>
+		void each_shape (FUN fun)
 		{
-			assert(this_);
+			if (pshape)
+				fun(pshape.get());
 
-			if (!pworld)
+			if (pshapes)
 			{
-				pworld.reset(new World(this_));
-				resize_world(this_);
+				for (auto& shape : *pshapes)
+					fun(shape.get());
 			}
-			return pworld.get();
 		}
 
-		World* parent_world ()
+		template <typename FUN>
+		void each_shape (FUN fun) const
 		{
-			if (!parent) return NULL;
-			return parent->self->world(parent);
+			const_cast<Data*>(this)->each_shape(fun);
+		}
+
+		void update_shapes (bool force = false)
+		{
+			each_shape([=](Shape* shape)
+			{
+				Shape_update(shape, force);
+			});
+		}
+
+		void resize_shapes (FrameEvent* e)
+		{
+			each_shape([=](Shape* shape)
+			{
+				shape->on_resize(e);
+			});
 		}
 
-		Body* body (View* this_)
+		Body& body ()
 		{
 			if (!pbody)
 			{
 				World* world = parent_world();
-				if (!world) return NULL;
-				pbody.reset(world->create_body(this_, frame.position()));
-				this_->make_body();
+				Body* b      = world
+					?	new Body(world, frame.position(), angle)
+					:	Body_create_temporary();
+				assert(b);
+
+				pbody.reset(b);
+				update_body_frame();
+			}
+			return *pbody;
+		}
+
+		void update_body_frame ()
+		{
+			if (!pbody) return;
+
+			pbody->set_transform(frame.x, frame.y, angle);
+		}
+
+		void update_body_and_shapes ()
+		{
+			std::unique_ptr<Body> old_body;
+			if (pbody)
+			{
+				old_body = std::move(pbody);
+				Body_copy_attributes(&body(), *old_body);
+			}
+
+			update_shapes(true);
+		}
+
+		World* parent_world (bool create = true)
+		{
+			if (!parent) return NULL;
+			return parent->self->child_world(parent, create);
+		}
+
+		World* child_world (View* view, bool create = true)
+		{
+			assert(view);
+
+			if (!pchild_world && create)
+			{
+				pchild_world.reset(new World());
+				create_walls(view);
 			}
-			return pbody.get();
+
+			return pchild_world.get();
 		}
 
-		void resize_world (View* this_)
+		void create_walls (View* view)
 		{
-			assert(this_);
+			assert(view);
 
-			World* w = pworld.get();
-			if (!w) return;
+			clear_walls(view);
 
-			w->resize(frame.width, frame.height);
-			this_->redraw();
+			View* wall = new View(WALL_NAME);
+			wall->add_shape(new WallShape(WallShape::ALL));
+			wall->set_static();
+
+			view->add_child(wall);
 		}
 
-		void update_body (View* this_)
+		void clear_walls (View* view)
 		{
-			assert(this_);
+			assert(view);
 
-			Body* b = pbody.get();
-			if (!b) return;
+			for (auto& wall : view->find_children(WALL_NAME))
+				view->remove_child(wall.get());
+		}
 
-			b->set_transform(frame.x, frame.y, angle);
-			this_->redraw();
+		ChildList& children ()
+		{
+			if (!pchildren) pchildren.reset(new ChildList);
+			return *pchildren;
 		}
 
 		void add_flag (uint flag)
 		{
-			flags |= flag;
+			Xot::add_flag(&flags, flag);
 		}
 
 		void remove_flag (uint flag)
 		{
-			flags &= ~flag;
+			Xot::remove_flag(&flags, flag);
 		}
 
 		bool has_flag (uint flag) const
 		{
-			return flags & flag;
+			return Xot::has_flag(flags, flag);
+		}
+
+		bool check_and_remove_flag (uint flag)
+		{
+			return Xot::check_and_remove_flag(&flags, flag);
 		}
 
 	};// View::Data
 
 
-	void
-	set_window (View* view, Window* window_)
+	class LayoutContext
 	{
-		assert(view);
 
-		Window* current = view->self->window;
-		if (current == window_) return;
+		public:
 
-		if (current)
-		{
-			view->set_capture(View::CAPTURE_NONE);
+			LayoutContext (View* parent)
+			:	parent(parent),
+				parent_style(View_get_style(parent)),
+				parent_frame(parent->self->frame)
+			{
+				Style::Flow flow_main, flow_sub;
+				parent_style.get_flow(&flow_main, &flow_sub);
+				get_flow_sign(&flow_main_h, &flow_main_v, flow_main);
+				get_flow_sign(&flow_sub_h,  &flow_sub_v,  flow_sub);
+			}
+
+			void place_children ()
+			{
+				View::ChildList* pchildren = parent->self->pchildren.get();
+				if (!pchildren || pchildren->empty())
+					return;
+
+				bool leftward = flow_main_h < 0 || flow_sub_h < 0;
+				bool upward   = flow_main_v < 0 || flow_sub_v < 0;
+				Point start_position(
+					leftward ? parent_frame.width  : 0,
+					upward   ? parent_frame.height : 0);
+				Point position = start_position;
+
+				for (iterator begin = pchildren->begin(), end = pchildren->end(); true;)
+				{
+					iterator line_end;
+					coord main_fill_size = 0;
+					coord sub_size_max   = 0;
+					calc_line(&line_end, &main_fill_size, &sub_size_max, begin, end);
+
+					for (iterator it = begin; it != line_end; ++it)
+						place_child(it->get(), &position, main_fill_size, sub_size_max);
+
+					if (line_end == end)
+						break;
+
+					flow_value(position.x, position.y, DIR_MAIN) =
+						flow_value(start_position.x, start_position.y, DIR_MAIN);
+
+					flow_value(position.x, position.y, DIR_SUB) +=
+						sub_size_max * flow_value(flow_sub_h, flow_sub_v, DIR_SUB);
+
+					begin = line_end;
+				}
+			}
+
+		private:
+
+			enum FlowDirection {DIR_MAIN, DIR_SUB};
+
+			typedef View::ChildList::iterator iterator;
+
+			View* parent;
+
+			const Style& parent_style;
+
+			const Bounds& parent_frame;
+
+			schar flow_main_h, flow_main_v, flow_sub_h, flow_sub_v;
+
+			static void get_flow_sign (schar* h, schar* v, Style::Flow flow)
+			{
+				assert(h && v);
+
+				switch (flow)
+				{
+					case Style::FLOW_RIGHT: *h = +1; *v =  0; break;
+					case Style::FLOW_DOWN:  *h =  0; *v = +1; break;
+					case Style::FLOW_LEFT:  *h = -1; *v =  0; break;
+					case Style::FLOW_UP:    *h =  0; *v = -1; break;
+					default:                *h =  0; *v =  0; break;
+				}
+			}
+
+			void calc_line (
+				iterator* line_end, coord* main_fill_size, coord* sub_size_max,
+				iterator begin, iterator end)
+			{
+				assert(line_end && main_fill_size && sub_size_max);
+
+				*line_end       = end;
+				*main_fill_size = 0;
+				*sub_size_max   = 0;
+
+				if (!has_flow())
+					return;
+
+				bool multiline     = flow_sub_h != 0 || flow_sub_v != 0;
+				bool line_has_fill = false;
+				coord parent_size  = flow_size(parent_frame, DIR_MAIN);
+				coord pos          = 0;
+
+				for (iterator it = begin; it != end; ++it)
+				{
+					const View* child  = it->get();
+					const Style* style = child->self->pstyle.get();
+					if (is_absolute(style))
+						continue;
+
+					const Bounds& frame = child->self->frame;
+					coord main_size     = flow_size(frame, DIR_MAIN);
+					bool child_has_fill = has_fill_length(style, DIR_MAIN);
+
+					if (multiline && it != begin)
+					{
+						bool next_line   = (pos + main_size) > parent_size;
+						bool double_fill = child_has_fill && line_has_fill;
+						if (next_line || double_fill)
+						{
+							*line_end = it;
+							break;
+						}
+					}
+
+					if (!child_has_fill)
+						pos += main_size;
+
+					if (!has_fill_length(style, DIR_SUB))
+					{
+						coord sub_size = flow_size(frame, DIR_SUB);
+						if (sub_size > *sub_size_max) *sub_size_max = sub_size;
+					}
+
+					line_has_fill |= child_has_fill;
+				}
+
+				*main_fill_size = parent_size - pos;
+			}
+
+			void place_child (
+				View* child, Point* position, coord main_fill_size, coord sub_size_max)
+			{
+				assert(child && position);
+
+				const Style* style = child->self->pstyle.get();
+				Bounds frame       = child->frame();
+				bool update        = false;
+
+				if (has_flow() && !is_absolute(style))
+				{
+					update |= fill_child(&frame, style, main_fill_size, sub_size_max);
+					update |= place_in_flow(&frame, position);
+				}
+
+				update |= place_position(&frame, style);
+
+				if (update)
+					View_set_frame(child, frame);
+			}
+
+			bool fill_child (
+				Bounds* frame,
+				const Style* style, coord main_fill_size, coord sub_size_max)
+			{
+				assert(frame);
+
+				bool update = false;
+
+				if (has_fill_length(style, DIR_MAIN))
+					update |= set_flow_size(frame, main_fill_size, DIR_MAIN);
+
+				if (has_fill_length(style, DIR_SUB))
+					update |= set_flow_size(frame, sub_size_max, DIR_SUB);
+
+				return update;
+			}
+
+			bool place_in_flow (Bounds* frame, Point* position)
+			{
+				assert(frame && position);
+
+				coord old_x = frame->x;
+				coord old_y = frame->y;
+
+				if (flow_main_h < 0) position->x -= frame->width;
+				if (flow_main_v < 0) position->y -= frame->height;
+
+				frame->x = position->x;
+				frame->y = position->y;
+
+				if (flow_main_h > 0) position->x += frame->width;
+				if (flow_main_v > 0) position->y += frame->height;
+
+				if (flow_sub_h < 0) frame->x -= frame->width;
+				if (flow_sub_v < 0) frame->y -= frame->height;
+
+				return frame->x != old_x || frame->y != old_y;
+			}
+
+			bool place_position (Bounds* frame, const Style* style)
+			{
+				assert(frame);
+
+				if (!style)
+					return false;
+
+				const StyleLength& l = style->left();
+				const StyleLength& t = style->top();
+				const StyleLength& r = style->right();
+				const StyleLength& b = style->bottom();
+				if (!l && !t && !r && !b)
+					return false;
+
+				bool update = false;
+
+				if (l && r)
+				{
+					coord ll, rr;
+					update |= StyleLength_get_pixel_length(&ll, l, parent_frame.w);
+					update |= StyleLength_get_pixel_length(&rr, r, parent_frame.w);
+					frame->x = ll;
+					frame->set_right(parent_frame.w - rr);
+				}
+				else if (l && !r)
+					update |= StyleLength_get_pixel_length(&frame->x, l, parent_frame.w);
+				else if (!l && r)
+				{
+					coord rr;
+					update |= StyleLength_get_pixel_length(&rr, r, parent_frame.w);
+					frame->x = parent_frame.w - (rr + frame->w);
+				}
+
+				if (t && b)
+				{
+					coord tt, bb;
+					update |= StyleLength_get_pixel_length(&tt, t, parent_frame.h);
+					update |= StyleLength_get_pixel_length(&bb, b, parent_frame.h);
+					frame->y = tt;
+					frame->set_bottom(parent_frame.h - bb);
+				}
+				else if (t && !b)
+					update |= StyleLength_get_pixel_length(&frame->y, t, parent_frame.h);
+				else if (!t && b)
+				{
+					coord bb;
+					update |= StyleLength_get_pixel_length(&bb, b, parent_frame.h);
+					frame->y = parent_frame.h - (bb + frame->h);
+				}
+
+				return update;
+			}
+
+			template <typename T>
+			T& flow_value (T& horizontal, T& vertical, FlowDirection dir) const
+			{
+				if (dir == DIR_MAIN)
+					return is_horizontal() ? horizontal : vertical;
+				else
+					return is_horizontal() ? vertical   : horizontal;
+			}
+
+			bool set_flow_size (Bounds* frame, coord size, FlowDirection dir) const
+			{
+				assert(frame);
+
+				coord& value = flow_value(frame->width, frame->height, dir);
+				if (value == size) return false;
+
+				value = size;
+				return true;
+			}
+
+			const coord& flow_size (const Bounds& frame, FlowDirection dir) const
+			{
+				return flow_value(frame.width, frame.height, dir);
+			}
+
+			bool is_horizontal () const
+			{
+				return flow_main_h != 0;
+			}
 
+			bool is_absolute (const Style* style) const
+			{
+				if (!style) return false;
+
+				if (is_horizontal())
+					return style->top()  || style->bottom();
+				else
+					return style->left() || style->right();
+			}
+
+			bool has_flow () const
+			{
+				return flow_main_h != 0 || flow_main_v != 0;
+			}
+
+			bool has_fill_length (const Style* style, FlowDirection dir) const
+			{
+				if (!style) return false;
+
+				const StyleLength& l = flow_value(style->width(), style->height(), dir);
+				return l.type() == StyleLength::FILL;
+			}
+
+	};// LayoutContext
+
+
+	void
+	View_set_window (View* view, Window* window)
+	{
+		if (!view)
+			argument_error(__FILE__, __LINE__);
+
+		if (view->self->window)
+		{
 			Event e;
 			view->on_detach(&e);
+			view->set_capture(View::CAPTURE_NONE);
 		}
 
-		view->self->window = window_;
+		view->self->window = window;
+		view->self->update_body_and_shapes();
 
-		View::child_iterator end = view->child_end();
-		for (View::child_iterator it = view->child_begin(); it != end; ++it)
-			set_window(it->get(), window_);
+		View::ChildList* pchildren = view->self->pchildren.get();
+		if (pchildren)
+		{
+			for (auto& pchild : *pchildren)
+				View_set_window(pchild.get(), window);
+		}
 
 		if (view->self->window)
 		{
 			Event e;
 			view->on_attach(&e);
-			view->resize_to_fit();
+			view->self->add_flag(View::Data::FIT_TO_CONTENT);
 		}
 	}
 
 	static void
-	set_parent (View* view, View* parent)
+	apply_style_to_children_have_variable_lengths (View* parent)
 	{
-		assert(view);
-		View::Data* self = view->self.get();
+		assert(parent);
 
-		View* current = self->parent;
-		if (current == parent) return;
+		View::ChildList* pchildren = parent->self->pchildren.get();
+		if (!pchildren) return;
 
-		if (current && parent)
+		for (auto& pchild : *pchildren)
 		{
-			reflex_error(__FILE__, __LINE__,
-				"view '%s' already belongs to another parent '%s'.",
-				view->name(), self->parent->name());
-		}
-
-		self->parent = parent;
-		set_window(view, parent ? parent->window() : NULL);
-	}
-
-	bool
-	is_view_active (View* view)
-	{
-		assert(view);
-
-		return view->self->has_flag(View::Data::ACTIVE);
-	}
-
-	static bool
-	remove_self (View* view)
-	{
-		assert(view);
-		View::Data* self = view->self.get();
-
-		if (!self->has_flag(View::Data::REMOVE_SELF) || !self->parent)
-			return false;
+			assert(pchild);
 
-		self->parent->remove_child(view);
-		return true;
+			if (pchild->self->has_flag(View::Data::HAS_VARIABLE_LENGTHS))
+				pchild->self->add_flag(View::Data::APPLY_STYLE);
+		}
 	}
 
 	static void
-	update_layout (View* view, bool update_parent = false)
+	update_view_layout (View* view, bool update_parent = false)
 	{
 		assert(view);
 		View::Data* self = view->self.get();
 
-		if (self->has_flag(View::Data::UPDATE_LAYOUT))
-			return;
-
 		self->add_flag(View::Data::UPDATE_LAYOUT);
 
 		if (update_parent && self->parent)
-			update_layout(self->parent, true);
+			update_view_layout(self->parent);
 	}
 
 	static void
-	update_view_frame (View* view, const Bounds& frame, float angle, bool update_body)
+	update_view_frame (
+		View* view, const Bounds& frame, float angle, bool update_body)
 	{
 		assert(view);
 		View::Data* self = view->self.get();
@@ -289,639 +665,565 @@ namespace Reflex
 		self->frame = frame;
 		self->angle = angle;
 
-		bool move = event.is_move(), rotate = event.is_rotate();
+		bool move   = event.is_move();
+		bool resize = event.is_resize();
+		bool rotate = event.is_rotate();
 
 		if (move)   view->on_move(&event);
+		if (resize) view->on_resize(&event);
 		if (rotate) view->on_rotate(&event);
 
-		if (update_body && (move || rotate))
-			self->update_body(view);
-
-		if (event.is_resize())
+		if (resize)
 		{
-			self->resize_world(view);
-			view->on_resize(&event);
-
-			update_layout(view, true);
+			view->self->resize_shapes(&event);
+			apply_style_to_children_have_variable_lengths(view);
+			update_view_layout(view, true);
 		}
 
+		if (update_body && (move || rotate) && self->pbody)
+			self->update_body_frame();
+
+		if ((move || resize) && self->parent)
+			self->parent->self->add_flag(View::Data::FIT_TO_CONTENT);
+
 		view->redraw();
 	}
 
-	static void
-	update_view_world (View* view, float dt)
+	void
+	View_set_frame (View* view, const Bounds& frame)
 	{
-		assert(view);
-		View::Data* self = view->self.get();
+		if (!view)
+			argument_error(__FILE__, __LINE__);
 
-		World* world = self->pworld.get();
-		if (world)
-		{
-			self->add_flag(View::Data::UPDATING_WORLD);
-			world->step(dt);
-			self->remove_flag(View::Data::UPDATING_WORLD);
-		}
+		update_view_frame(view, frame, view->self->angle, true);
+	}
 
-		Body* body = self->pbody.get();
-		if (body)
-		{
-			Bounds b = view->frame();
-			b.move_to(body->position());
-			update_view_frame(view, b, body->angle(), false);
-		}
+	const Style&
+	View_get_style (const View* view)
+	{
+		if (!view)
+			argument_error(__FILE__, __LINE__);
+
+		static const Style DEFAULT_STYLE;
+		return view->self->pstyle ? *view->self->pstyle : DEFAULT_STYLE;
 	}
 
-	void
-	update_styles_for_selector (View* view, const Selector& selector)
+	Body*
+	View_get_body (View* view, bool create)
 	{
-		assert(view);
-		View::Data* self = view->self.get();
+		if (!view) return NULL;
 
-		if (selector.is_empty())
-			self->add_flag(View::Data::UPDATE_STYLE);
-		else
-			self->selectors_for_update().insert(selector);
+		return create ? &view->self->body() : view->self->pbody.get();
 	}
 
-	static void
-	update_views_for_selectors (View* view)
+	bool
+	View_is_active (const View& view)
 	{
-		assert(view);
-		View::Data* self = view->self.get();
+		return view.self->window;
+	}
 
-		View::Data::SelectorSet* sels = self->pselectors_for_update.get();
-		if (!sels)
-			return;
+	static void
+	find_all_children (
+		View::ChildList* result, const View* view, const Selector& selector,
+		bool recursive)
+	{
+		assert(result && view);
 
-		Selector* view_sel = self->pselector.get();
-		View::ChildList children;
+		View::ChildList* pchildren = view->self->pchildren.get();
+		if (!pchildren) return;
 
-		View::Data::SelectorSet::iterator end = sels->end();
-		for (View::Data::SelectorSet::iterator it = sels->begin(); it != end; ++it)
+		for (auto& pchild : *pchildren)
 		{
-			if (view_sel && view_sel->contains(*it))
-				self->add_flag(View::Data::UPDATE_STYLE);
+			if (!pchild)
+				invalid_state_error(__FILE__, __LINE__);
 
-			view->find_children(&children, *it, true);
-			for (View::ChildList::iterator jt = children.begin(); jt != children.end(); ++jt)
-				(*jt)->self->add_flag(View::Data::UPDATE_STYLE);
-		}
+			if (pchild->selector().contains(selector))
+				result->push_back(pchild);
 
-		sels->clear();
+			if (recursive)
+				find_all_children(result, pchild.get(), selector, true);
+		}
 	}
 
 	static void
 	find_all_styles (
-		View::StyleList* result, const View* view, const Selector& selector, bool recursive)
+		View::StyleList* result, const View* view, const Selector& selector,
+		bool recursive)
 	{
-		View::const_style_iterator end = view->style_end();
-		for (View::const_style_iterator it = view->style_begin(); it != end; ++it)
+		assert(result && view);
+
+		View::StyleList* pstyles = view->self->pstyles.get();
+		if (pstyles)
 		{
-			if (selector.contains(it->selector()))
-				result->push_back(*it);
+			for (auto& style : *pstyles)
+			{
+				if (selector.contains(style.selector()))
+					result->push_back(style);
+			}
 		}
 
-		if (recursive)
+		if (!recursive) return;
+
+		View::ChildList* pchildren = view->self->pchildren.get();
+		if (pchildren)
 		{
-			View::const_child_iterator end = view->child_end();
-			for (View::const_child_iterator it = view->child_begin(); it != end; ++it)
-				find_all_styles(result, it->get(), selector, true);
+			for (auto& pchild : *pchildren)
+				find_all_styles(result, pchild.get(), selector, true);
 		}
 	}
 
 	static void
-	get_styles_for_selector (
-		View::StyleList* styles, View* view, const Selector& selector)
+	fire_timers (View* view, double now)
 	{
-		assert(styles);
+		assert(view);
 
-		View* parent = view->parent();
-		if (parent)
-			get_styles_for_selector(styles, parent, selector);
+		Timers* timers = view->self->ptimers.get();
+		if (timers)
+			timers->fire(now);
+	}
+
+	static void
+	update_view_shapes (View* view)
+	{
+		assert(view);
+		View::Data* self = view->self.get();
 
-		find_all_styles(styles, view, selector, false);
+		bool create_shape = self->pbody && !self->pshape;
+		if (create_shape)
+			view->shape();
+
+		bool update = self->check_and_remove_flag(View::Data::UPDATE_SHAPES);
+		if (update || create_shape)
+			self->update_shapes(create_shape);
 	}
 
 	static void
-	get_styles_for_view (View::StyleList* styles, View* view)
+	update_view_body (View* view)
 	{
-		Selector* sel = view->self->pselector.get();
-		if (!sel || sel->is_empty())
-			return;
+		assert(view);
+
+		Body* body = view->self->pbody.get();
+		if (!body) return;
 
-		get_styles_for_selector(styles, view, *sel);
+		Bounds frame = view->frame();
+		frame.move_to(body->position());
+		update_view_frame(view, frame, body->angle(), false);
 	}
 
 	static void
-	update_view_style (View* view)
+	update_child_world (View* view, float dt)
 	{
 		assert(view);
 		View::Data* self = view->self.get();
 
-		if (!self->has_flag(View::Data::UPDATE_STYLE))
-			return;
+		World* child_world = self->pchild_world.get();
+		if (!child_world) return;
 
-		View::StyleList styles;
-		get_styles_for_view(&styles, view);
+		child_world->on_update(dt);
 
-		Style style;
-		for (View::StyleList::iterator it = styles.begin(); it != styles.end(); ++it)
+		View::ChildList* pchildren = self->pchildren.get();
+		if (pchildren)
 		{
-			void override_style (Style*, const Style&);
-			override_style(&style, *it);
+			for (auto& pchild : *pchildren)
+				update_view_body(pchild.get());
 		}
-
-		void apply_style (View*, const Style&);
-		apply_style(view, style);
-
-		self->remove_flag(View::Data::UPDATE_STYLE);
 	}
 
-	static void reflow_children (View* parent, const FrameEvent* event = NULL);
-
 	static void
-	update_view_layout (View* view)
+	update_views_for_selectors (View* view)
 	{
 		assert(view);
 		View::Data* self = view->self.get();
 
-		if (!self->has_flag(View::Data::UPDATE_LAYOUT))
+		View::Data::SelectorSet* sels = self->pselectors_for_update.get();
+		if (!sels)
 			return;
 
-		reflow_children(view);
-		self->remove_flag(View::Data::UPDATE_LAYOUT);
+		Selector* view_sel = self->pselector.get();
+		View::ChildList children;
+
+		for (auto& sel : *sels)
+		{
+			if (view_sel && view_sel->contains(sel))
+				self->add_flag(View::Data::UPDATE_STYLE);
+
+			children.clear();
+			find_all_children(&children, view, sel, true);
+			for (auto& pchild : children)
+				pchild->self->add_flag(View::Data::UPDATE_STYLE);
+		}
+
+		sels->clear();
 	}
 
-	void
-	update_view_tree (View* view, const UpdateEvent& event)
+	static void
+	get_styles_for_selector (
+		View::StyleList* result, View* view, const Selector& selector)
 	{
-		if (!view)
-			argument_error(__FILE__, __LINE__);
+		assert(result);
 
-		if (event.is_blocked() || remove_self(view))
-			return;
+		View* parent = view->parent();
+		if (parent)
+			get_styles_for_selector(result, parent, selector);
 
-		UpdateEvent e = event;
-		update_view_world(view, e.dt);
-		view->on_update(&e);
+		find_all_styles(result, view, selector, false);
+	}
 
-		update_views_for_selectors(view);
-		update_view_style(view);
+	static bool
+	get_styles_for_view (View::StyleList* result, View* view)
+	{
+		assert(result && view);
+
+		result->clear();
 
-		View::child_iterator end = view->child_end();
-		for (View::child_iterator it = view->child_begin(); it != end; ++it)
-			update_view_tree(it->get(), e);
+		Selector* sel = view->self->pselector.get();
+		if (!sel || sel->is_empty())
+			return false;
 
-		update_view_layout(view);
+		get_styles_for_selector(result, view, *sel);
+		return !result->empty();
 	}
 
 	static void
-	draw_world (View* view, Painter* painter)
+	update_view_style (View* view)
 	{
 		assert(view);
+		View::Data* self = view->self.get();
 
-		World* world = view->self->pworld.get();
-		if (world) world->draw(painter);
-	}
-
-	void
-	draw_view_tree (
-		View* view, const DrawEvent& event, const Point& offset, const Bounds& clip)
-	{
-		if (!view)
-			argument_error(__FILE__, __LINE__);
+		Style* pstyle = self->pstyle.get();
+		if (pstyle)
+			Style_clear_inherited_values(pstyle);
 
-		if (event.is_blocked() || view->hidden())
-			return;
+		View::StyleList styles;
+		if (get_styles_for_view(&styles, view))
+		{
+			if (!pstyle)
+				pstyle = &self->style(view);
 
-		DrawEvent e = event;
-		Painter*  p = e.painter;
-		Body*     b = view->self->pbody.get();
+			for (auto& st : styles)
+				Style_override(pstyle, st);
+		}
 
-		p->push_matrix();
-		p->push_attr();
+		const Style& style = View_get_style(view);
+		if (Style_has_variable_lengths(style))
+			self->add_flag(View::Data::HAS_VARIABLE_LENGTHS);
+		else
+			self->remove_flag(View::Data::HAS_VARIABLE_LENGTHS);
 
-		Bounds frame = view->frame();
-		Point  pos   = frame.position() - view->scroll();
-		p->translate(pos);
+		self->add_flag(View::Data::APPLY_STYLE);
+	}
 
-		float angle = view->self->angle;
-		if (angle != 0) p->rotate(angle);
+	static void
+	fit_view_to_content (View* view)
+	{
+		assert(view);
 
-		float zoom = view->self->zoom;
-		if (zoom != 1 && zoom > 0) p->scale(zoom, zoom);
+		Bounds bounds = view->content_bounds();
+		if (!bounds) return;
 
-		pos += offset;
-		Bounds clip2 = clip & frame.move_to(pos);
-		if (b)
-			p->no_clip();
+		if (view->self->has_flag(View::FLAG_SCROLL_TO_FIT))
+			view->scroll_to(-bounds.position());
 		else
-			p->set_clip(clip2);
+			bounds.size() += bounds.position();
 
-		e.view   = view;
-		e.bounds = frame.move_to(0, 0, frame.z);
-		view->on_draw(&e);
-
-		View::child_iterator end = view->child_end();
-		for (View::child_iterator it = view->child_begin(); it != end; ++it)
-			draw_view_tree(it->get(), e, pos, clip2);
+		if (view->self->has_flag(View::FLAG_RESIZE_TO_FIT))
+		{
+			Bounds frame = view->frame();
 
-		draw_world(view, p);
+			const Style* style = view->style(false);
+			if ((!style || !Style_has_width( *style))) frame.w = bounds.w;
+			if ((!style || !Style_has_height(*style))) frame.h = bounds.h;
+			frame.d = bounds.d;
 
-		p->pop_attr();
-		p->pop_matrix();
-	}
-#if 0
-	void
-	get_all_margins (MarginList* margins, View* view)
-	{
-		if (!margins || !view)
-			argument_error(__FILE__, __LINE__);
+			view->set_frame(frame);
+		}
 	}
 
 	void
-	get_content_size (
-		Point* size, View* view, const Point& parent_size, bool min_width, bool min_height)
+	View_update_tree (View* view, const UpdateEvent& event)
 	{
-		if (!size || !view)
+		if (!view)
 			argument_error(__FILE__, __LINE__);
 
-		const Style&        style  = view->style();
-		const StyleLength4& pos    = style.position();
-		const StyleLength2& size   = style.size();
-		const StyleLength4& margin = style.margin();
-		bool need_width = true, need_height = true;
-		coord n;
-
-		size->reset(0);
+		View::Data* self = view->self.get();
 
-		if (pos.left && pos.right)
-		{
-			if (!pos.left.is_fixed())
-				layout_error(__FILE__, __LINE__, "");
+		fire_timers(view, event.now);
 
-			size->x += parent_size.x;
-			need_width = false;
-		}
-		else if (size.width.get_pixel(&n, parent_size.x))
+		View::ChildList* pchildren = self->pchildren.get();
+		if (pchildren)
 		{
-			size->x += n;
-			need_width = false;
+			for (auto& pchild : *pchildren)
+				View_update_tree(pchild.get(), event);
 		}
 
-		if (pos.top && pos.bottom)
-			size->y += parent_size.y;
-		else if (size.height.get_pixel(&n, parent_size.y))
-			size->y += n;
-		else
-			need_height = true;
-
-		if (need_width || need_height)
-		{
-			Point content_size = view->content_size();
-			bool view_width = false, view_height = false;
-
-			if (need_width && content_size.x >= 0)
-			{
-				size->x += content_size.x;
-				need_width = false;
-			}
-
-			if (need_height && content_size.y >= 0)
-			{
-				size->y += content_size.y;
-				need_height = false;
-			}
-
-			if (need_width || need_height)
-			{
-				View::child_iterator end = view->child_end();
-				for (View::child_iterator it = view->child_begin(); it != end; ++it)
-				{
-					const View* child = it->get();
-					Point child_size;
-					get_content_size(&child_size, child, );
-					const Bounds& b = it->frame();
-				}
-
-				for ()
-				Point view_size;
-				get_view_size(&view_size, );
-			}
+		update_view_shapes(view);
+		update_child_world(view, event.dt);
 
-			coord m;
-			if (margin.left  .get_pixel(&m, parent_size.x)) size->x += m;
-			if (margin.top   .get_pixel(&m, parent_size.y)) size->y += m;
-			if (margin.right .get_pixel(&m, parent_size.x)) size->x += m;
-			if (margin.bottom.get_pixel(&m, parent_size.y)) size->y += m;
-		}
+		UpdateEvent e = event;
+		view->on_update(&e);
 
+		update_views_for_selectors(view);
 
+		if (self->check_and_remove_flag(View::Data::UPDATE_STYLE))
+			update_view_style(view);
 
+		if (self->check_and_remove_flag(View::Data::APPLY_STYLE))
+			Style_apply_to(View_get_style(view), view);
 
+		if (self->check_and_remove_flag(View::Data::UPDATE_LAYOUT))
+			view->update_layout();
 
+		if (self->check_and_remove_flag(View::Data::FIT_TO_CONTENT))
+			fit_view_to_content(view);
+	}
 
+	static bool
+	use_cache (View* view)
+	{
+		assert(view);
+		View::Data* self = view->self.get();
 
-		const StyleLength4& margin = style.margin();
+		return
+			self->has_flag(View::FLAG_CACHE) ||
+			(self->pfilter && *self->pfilter);
+	}
 
-		coord left, top, right, bottom;
-		bool have_left   = pos.left  .get_pixel(&left,   parent_width);
-		bool have_top    = pos.top   .get_pixel(&top,    parent_height);
-		bool have_right  = pos.right .get_pixel(&right,  parent_width);
-		bool have_bottom = pos.bottom.get_pixel(&bottom, parent_height);
+	static bool
+	reset_cache_image (View* view, const Painter& painter)
+	{
+		assert(view && use_cache(view));
+		View::Data* self = view->self.get();
 
-		if (have_left && have_right)
+		Image* image = self->pcache_image.get();
+		int w        = ceil(self->frame.width);
+		int h        = ceil(self->frame.height);
+		if (
+			image &&
+			image->width()         == w &&
+			image->height()        == h &&
+			image->pixel_density() == painter.pixel_density())
 		{
-			s
+			return false;
 		}
 
-		coord width, height;
-		bool have_width  = size.width .get_pixel(&width,  parent_width);
-		bool have_height = size.height.get_pixel(&height, parent_height);
-		const StyleLength& w = style.width();
-		switch (w.unit())
-		{
-			case StyleLength::PIXEL:
-			case StyleLength::PERCENT:
-			case StyleLength::NONE:
-			default:
-		}
+		self->pcache_image.reset(
+			new Image(w, h, Rays::RGBA, painter.pixel_density()));
+		return true;
 	}
 
 	static void
-	get_flow_factor (int* h, int* v, Style::Flow flow)
+	setup_painter (Painter* painter, const Color& fill, const Color& stroke)
 	{
-		if (!h || !v)
-			argument_error(__FILE__, __LINE__);
+		assert(painter);
 
-		switch (flow)
-		{
-			case Style::FLOW_DOWN:  *h =  0; *v = +1; break;
-			case Style::FLOW_RIGHT: *h = +1; *v =  0; break;
-			case Style::FLOW_UP:    *h =  0; *v = -1; break;
-			case Style::FLOW_LEFT:  *h = -1; *v =  0; break;
-			default:                argument_error(__FILE__, __LINE__);
-		}
+		painter->set_fill(fill);
+		painter->set_stroke(stroke);
 	}
 
-	struct Length4
+	static void
+	draw_default_shape (View* view, DrawEvent* event)
 	{
+		assert(view && event && event->painter);
 
-		coord l, t, r, b;
-
-		Length4 ()
-		{
-		}
+		const Style& style       = View_get_style(view);
+		const Color& back_fill   = style.background_fill();
+		const Color& back_stroke = style.background_stroke();
 
-		Length4 (const StyleLength4& soruce)
+		Shape* shape = view->shape(false);
+		if (shape)
 		{
-			reset(source);
+			setup_painter(event->painter, back_fill, back_stroke);
+			shape->on_draw(event);
 		}
-
-		void reset (const StyleLength4& source)
+		else if (back_fill || back_stroke)
 		{
-			source.left  .get_pixel(&l, 0);
-			source.top   .get_pixel(&t, 0);
-			source.right .get_pixel(&r, 0);
-			source.bottom.get_pixel(&b, 0);
+			setup_painter(event->painter, back_fill, back_stroke);
+			event->painter->rect(event->bounds);
 		}
+	}
 
-	};// Length4
-
-	struct ChildView
+	static void
+	draw_content (View* view, DrawEvent* event)
 	{
+		assert(view && event && event->painter);
 
-		View* view;
-
-		Point size;
-
-		Length4 margin;
-
-		ChildView (View* view) : view(view) {}
+		draw_default_shape(view, event);
 
-	};// ChildView
+		const Style& style = View_get_style(view);
+		setup_painter(
+			event->painter, style.foreground_fill(), style.foreground_stroke());
 
-	typedef std::vector<ChildView> ChildViewList;
+		View::ShapeList* pshapes = view->self->pshapes.get();
+		if (pshapes && !pshapes->empty())
+		{
+			for (auto& pshape : *pshapes)
+				pshape->on_draw(event);
+		}
 
-	static void reflow_view_tree (Point* size, Length4* margin, View* view);
+		view->on_draw(event);
+	}
 
 	static void
-	reflow_children (View* view, Point* size, const Style& style)
+	draw_view (
+		View* view, DrawEvent* event, const Point& offset, const Bounds& clip)
 	{
-		assert(view && size);
-
-		size_t nchildren = view->self->count_children();
-		if (nchildren == 0) return;
-
-		ChildViewList children;
-		children.reserve(nchildren);
+		assert(view && event && event->painter);
+		View::Data* self = view->self.get();
 
-		View::child_iterator end = view->child_end();
-		for (View::child_iterator it = view->child_begin(); it != end; ++it)
-		{
-			ChildView c(it->get());
-			reflow_view_tree(&c.size, &c.margin, c.view);
-			children.push_back(c);
-		}
+		Painter* p = event->painter;
+		p->push_state();
 
-		assert(children.size() == nchildren)
-#if 0
-		Flow flow_main, flow_sub;
-		style.get_flow(&flow_main, &flow_sub);
-
-		int main_h, main_v, sub_h, sub_v;
-		get_flow_factor(&main_h, &main_v, flow_main);
-		get_flow_factor(&sub_h,  &sub_v,  flow_sub);
-#endif
-		coord x = 0, y = 0;
-		coord parent_w = size->x, parent_h = size->y;
-		coord height_max = 0;
-		int child_count = 0;
-		bool multiline = sub != Style::FLOW_NONE;
-
-		for (size_t i = 0; i < nchildren; ++i)
-		{
-			const ChildView& child = children[i];
-			Bounds& child_frame = child.view->self->frame;
+		if (self->has_flag(View::FLAG_CLIP) && !self->pbody)
+			p->set_clip(clip);
+		else
+			p->no_clip();
 
-			child_frame.x = x;
-			child_frame.y = y;
-			x            += child.size.x;
+		draw_content(view, event);
 
-			if (child.size.y > size_max)
-				size_max = child.size.y;
+		p->pop_state();
 
-			if (parent_w >= 0 && x > parent_w && view_count > 0)
+		View::ChildList* pchildren = view->self->pchildren.get();
+		if (pchildren)
+		{
+			for (auto& pchild : *pchildren)
 			{
-				x        = 0;
-				y       += size_max;
-				size_max = 0;
-				if (parent_h < 0 && y > size->y) size->y = y;
+				if (event->bounds & pchild->self->frame)
+					View_draw_tree(pchild.get(), *event, offset, clip);
 			}
+		}
 
-			++view_count;
+		World* child_world = view->self->pchild_world.get();
+		if (child_world)
+		{
+			p->push_state();
+			child_world->on_draw(p);
+			p->pop_state();
 		}
 	}
 
 	static void
-	reflow_view_tree (Point* size, Length4* margin, View* view)
+	draw_view_to_cache (View* view, DrawEvent* event)
 	{
-		if (!size || !margin || !view)
-			argument_error(__FILE__, __LINE__);
-
-		const Style& style = view->style();
+		assert(view && event && event->painter && view->self->pcache_image);
 
-		*size = view->content_size();
-		reflow_children(view, size, style);
+		Painter* view_painter = event->painter;
+		Painter cache_painter = view->self->pcache_image->painter();
+		event->painter = &cache_painter;
 
-		Length4 padding(style.padding());
-		size->x += padding.l + padding.r;
-		size->y += padding.t + padding.b;
+		cache_painter.begin();
+		draw_view(view, event, 0, event->bounds);
+		cache_painter.end();
 
-		Bounds& frame = view->self->frame;
-		margin->reset(style.margin());
-
-		frame.width  = margin.l + size->x + margin.r;
-		frame.height = margin.t + size->y + margin.b;
+		event->painter = view_painter;
 	}
 
-	void
-	get_fixed_content_size (Point* size, View* view)
+	static bool
+	draw_view_with_cache (View* view, DrawEvent* event, bool redraw)
 	{
-		if (!size || !view)
-			argument_error(__FILE__, __LINE__);
-
-		const Style&        style  = view->style();
-		const StyleLength2& size   = style.size();
-		bool need_width = true, need_height = true;
-		coord n;
-
-		size->reset(-1);
+		assert(view && event && event->painter);
+		View::Data* self = view->self.get();
 
-		if (size.width.is_fixed() && size.width.get_pixel(&n, parent_size.x))
+		if (!use_cache(view))
 		{
-			size->x += n;
-			need_width = false;
+			self->pcache_image.reset();
+			return false;
 		}
 
-		if (size.height.get_pixel(&n, parent_size.y))
-		{
-			size->y += n;
-			need_height = false;
-		}
+		Painter* painter = event->painter;
 
-		if (need_width || need_height)
+		if (reset_cache_image(view, *painter) || redraw)
 		{
-			Point content_size = view->content_size();
-			bool view_width = false, view_height = false;
+			if (!self->pcache_image)
+				return false;
 
-			if (need_width && content_size.x >= 0)
-			{
-				size->x += content_size.x;
-				need_width = false;
-			}
+			draw_view_to_cache(view, event);
+		}
 
-			if (need_height && content_size.y >= 0)
-			{
-				size->y += content_size.y;
-				need_height = false;
-			}
+		painter->push_state();
+		painter->set_fill(1);
+		painter->no_stroke();
+		painter->no_shader();
 
-			if (need_width || need_height)
-			{
-				View::child_iterator end = view->child_end();
-				for (View::child_iterator it = view->child_begin(); it != end; ++it)
-				{
-					const View* child = it->get();
-					Point child_size;
-					get_content_size(&child_size, child, );
-					const Bounds& b = it->frame();
-				}
+		if (self->pfilter && *self->pfilter)
+			self->pfilter->apply(painter, *self->pcache_image);
+		else
+			painter->image(*self->pcache_image, event->bounds);
 
-				for ()
-				Point view_size;
-				get_view_size(&view_size, );
-			}
+		painter->pop_state();
 
-			coord m;
-			if (margin.left  .get_pixel(&m, parent_size.x)) size->x += m;
-			if (margin.top   .get_pixel(&m, parent_size.y)) size->y += m;
-			if (margin.right .get_pixel(&m, parent_size.x)) size->x += m;
-			if (margin.bottom.get_pixel(&m, parent_size.y)) size->y += m;
-		}
+		return true;
 	}
-#endif
 
-	static bool
-	get_style_flow (Style::Flow* main, Style::Flow* sub, const Style* style)
+	void
+	View_draw_tree (
+		View* view, const DrawEvent& event, const Point& offset, const Bounds& clip)
 	{
-		void get_default_flow (Style::Flow*, Style::Flow*);
+		if (!view)
+			argument_error(__FILE__, __LINE__);
 
-		assert(main && sub);
+		View::Data* self = view->self.get();
 
-		if (style)
-			style->get_flow(main, sub);
-		else
-			get_default_flow(main, sub);
+		bool redraw = self->check_and_remove_flag(View::Data::REDRAW);
 
-		return *main != Style::FLOW_NONE;
-	}
+		if (event.is_blocked() || view->hidden())
+			return;
 
-	static void
-	reflow_children (View* parent, const FrameEvent* event)
-	{
-		assert(parent);
+		if (self->frame.width <= 0 || self->frame.height <= 0)
+			return;
 
-		View::ChildList* children = parent->self->pchildren.get();
-		if (!children || children->empty()) return;
+		Point pos    = self->frame.position();
+		Bounds clip2 = self->frame.dup().move_by(offset) & clip;
+		DrawEvent e  = event;
+		e.view       = view;
+		e.bounds     = self->frame;
+		e.bounds.move_to(0, 0, e.bounds.z);
 
-		const Style* style = parent->style();
+		if (self->pscroll)
+		{
+			pos     .move_by( *self->pscroll);
+			e.bounds.move_by(-*self->pscroll);
+		}
 
-		Style::Flow flow_main, flow_sub;
-		if (!get_style_flow(&flow_main, &flow_sub, style))
-			return;
+		Painter* p = event.painter;
+		p->push_matrix();
+		p->translate(pos);
 
-#if 0
-		int main_h, main_v, sub_h, sub_v;
-		get_flow_factor(&main_h, &main_v, flow_main);
-		get_flow_factor(&sub_h,  &sub_v,  flow_sub);
-#endif
+		float angle = self->angle;
+		if (angle != 0)
+			p->rotate(angle);
 
-		const Bounds& parent_frame = parent->self->frame;
-		coord x = 0, y = 0, size_max = 0;
-		int child_count = 0;
-		bool multiline = flow_sub != Style::FLOW_NONE;
+		float zoom = self->zoom;
+		if (zoom != 1 && zoom > 0)
+			p->scale(zoom, zoom);
 
-		size_t nchildren = children->size();
-		for (size_t i = 0; i < nchildren; ++i)
-		{
-			View* child = (*children)[i].get();
-			Bounds child_frame = child->self->frame;
+		pos += offset;
+		if (!draw_view_with_cache(view, &e, redraw))
+			draw_view(view, &e, pos, clip2);
 
-			if (
-				(x + child_frame.width) > parent_frame.width &&
-				child_count > 0 && multiline)
-			{
-				x           = 0;
-				y          += size_max;
-				size_max    = 0;
-				child_count = 0;
-			}
+		p->pop_matrix();
+	}
 
-			child_frame.x = x;
-			child_frame.y = y;
+	void
+	View_update_styles (View* view, const Selector& selector)
+	{
+		if (!view)
+			argument_error(__FILE__, __LINE__);
 
-			x += child_frame.width;
+		View::Data* self = view->self.get();
 
-			if (size_max < child_frame.height)
-				size_max = child_frame.height;
+		if (selector.is_empty())
+			self->add_flag(View::Data::UPDATE_STYLE);
+		else
+			self->selectors_for_update().insert(selector);
+	}
 
-			//if (y + size_max > parent_frame.height)
-			//	parent_frame.height = y + size_max;
+	void
+	View_update_shapes (View* view)
+	{
+		if (!view)
+			argument_error(__FILE__, __LINE__);
 
-			++child_count;
-			child->set_frame(child_frame);
-		}
+		view->self->add_flag(View::Data::UPDATE_SHAPES);
 	}
 
 	template <typename FUN, typename EVENT>
@@ -930,67 +1232,91 @@ namespace Reflex
 	{
 		assert(parent);
 
-		View::child_iterator end = parent->child_end();
-		for (View::child_iterator it = parent->child_begin(); it != end; ++it)
-			fun(it->get(), e);
+		View::ChildList* pchildren = parent->self->pchildren.get();
+		if (pchildren)
+		{
+			for (auto& pchild : *pchildren)
+				fun(pchild.get(), e);
+		}
 	}
 
 	void
-	call_key_event (View* child, const KeyEvent& event)
+	View_call_key_event (View* view, const KeyEvent& event)
 	{
-		if (!child)
+		if (!view)
 			argument_error(__FILE__, __LINE__);
 
-		bool capturing = child->capture() & View::CAPTURE_KEY;
+		bool capturing = view->capture() & View::CAPTURE_KEY;
 		if (capturing != event.capture) return;
 
 		KeyEvent e = event;
-		child->on_key(&e);
+		view->on_key(&e);
+
+		switch (e.type)
+		{
+			case KeyEvent::DOWN: view->on_key_down(&e); break;
+			case KeyEvent::UP:   view->on_key_up(&e);   break;
+			case KeyEvent::NONE: break;
+		}
+	}
+
+	static void
+	filter_pointer_event (
+		PointerEvent* to, const PointerEvent& from, const Bounds& frame)
+	{
+		assert(to);
+
+		const Point& offset = frame.position();
+
+		to->size = 0;
+		for (size_t i = 0; i < from.size; ++i) {
+			const Point& pos = from.position(i);
+			if (!frame.is_include(pos))
+				continue;
+
+			to->positions[i] = pos - offset;
+			++to->size;
+		}
 	}
 
 	void
-	call_pointer_event (View* child, const PointerEvent& event)
+	View_call_pointer_event (View* view, const PointerEvent& event)
 	{
-		if (!child)
+		if (!view)
 			argument_error(__FILE__, __LINE__);
 
-		bool capturing = child->capture() & View::CAPTURE_POINTER;
+		bool capturing = view->capture() & View::CAPTURE_POINTER;
 		if (capturing != event.capture) return;
 
-		const Bounds& frame = child->frame();
-
-		if (!capturing)
-		{
-			bool include = false;
-			for (size_t i = 0; i < event.size; ++i)
-			{
-				if (frame.is_include(event[i]))
-				{
-					include = true;
-					break;
-				}
-			}
-			if (!include) return;
-		}
+		const Bounds& frame = view->frame();
 
 		PointerEvent e = event;
-		Point offset = frame.position();
-		for (size_t i = 0; i < e.size; ++i)
-			e[i] -= offset;
+		filter_pointer_event(&e, event, frame);
+
+		if (!capturing && e.size == 0)
+			return;
+
+		view->on_pointer(&e);
 
-		child->on_pointer(&e);
+		switch (e.type)
+		{
+			case PointerEvent::DOWN: view->on_pointer_down(&e); break;
+			case PointerEvent::UP:   view->on_pointer_up(&e);   break;
+			case PointerEvent::MOVE: view->on_pointer_move(&e); break;
+			case PointerEvent::NONE: break;
+		}
 
 		if (!event.capture)
-			call_children(child, call_pointer_event, e);
+			call_children(view, View_call_pointer_event, e);
 	}
 
 	void
-	call_wheel_event (View* child, const WheelEvent& event)
+	View_call_wheel_event (View* view, const WheelEvent& event)
 	{
-		if (!child)
+		if (!view)
 			argument_error(__FILE__, __LINE__);
 
-		const Bounds& frame = child->frame();
+		const Bounds& frame = view->frame();
 
 		if (!frame.is_include(event.x, event.y, event.z))
 			return;
@@ -998,24 +1324,45 @@ namespace Reflex
 		WheelEvent e = event;
 		e.position() -= frame.position();
 
-		child->on_wheel(&e);
+		view->on_wheel(&e);
 
-		call_children(child, call_wheel_event, e);
+		call_children(view, View_call_wheel_event, e);
 	}
 
-
-	View::View (const char* name)
+	void
+	View_call_contact_event (View* view, const ContactEvent& event)
 	{
-		if (name) self->selector().set_name(name);
+		if (!view)
+			argument_error(__FILE__, __LINE__);
+
+		ContactEvent e = event;
+		view->on_contact(&e);
+
+		switch (e.type)
+		{
+			case ContactEvent::BEGIN: view->on_contact_begin(&e); break;
+			case ContactEvent::END:   view->on_contact_end(&e);   break;
+			case ContactEvent::NONE: break;
+		}
+	}
+
+
+	View::View (const char* name)
+	{
+		if (name) set_name(name);
 	}
 
 	View::~View ()
 	{
+		clear_children();// to delete child shapes before world.
 	}
 
 	void
 	View::show ()
 	{
+		if (self->hide_count <= SHRT_MIN)
+			invalid_state_error(__FILE__, __LINE__);
+
 		int new_count = self->hide_count - 1;
 		if (new_count == 0)
 		{
@@ -1032,6 +1379,9 @@ namespace Reflex
 	void
 	View::hide ()
 	{
+		if (self->hide_count >= SHRT_MAX)
+			invalid_state_error(__FILE__, __LINE__);
+
 		int new_count = self->hide_count + 1;
 		if (new_count == 1)
 		{
@@ -1053,11 +1403,133 @@ namespace Reflex
 
 	void
 	View::redraw ()
+	{
+		if (self->has_flag(Data::REDRAW))
+			return;
+
+		self->add_flag(Data::REDRAW);
+
+		if (self->parent)
+			self->parent->redraw();
+		else if (self->window)
+			self->window->redraw();
+	}
+
+	void
+	View::focus (bool state)
 	{
 		Window* w = window();
 		if (!w) return;
 
-		w->redraw();
+		if (state)
+			Window_set_focus(w, this);
+		else if (w->focus() == this)
+			Window_set_focus(w, NULL);
+	}
+
+	void
+	View::blur ()
+	{
+		focus(false);
+	}
+
+	bool
+	View::has_focus () const
+	{
+		const Window* w = window();
+		return w && w->focus() == this;
+	}
+
+	Timer*
+	View::start_timer (float seconds, int count)
+	{
+		return self->timers().add(this, seconds, count);
+	}
+
+	Timer*
+	View::start_interval (float seconds)
+	{
+		return start_timer(seconds, -1);
+	}
+
+	void
+	View::update_layout ()
+	{
+		LayoutContext(this).place_children();
+		redraw();
+	}
+
+	Point
+	View::from_parent (const Point& point) const
+	{
+		not_implemented_error(__FILE__, __LINE__);
+		return 0;
+	}
+
+	Point
+	View::to_parent (const Point& point) const
+	{
+		not_implemented_error(__FILE__, __LINE__);
+		return 0;
+	}
+
+	Point
+	View::from_window (const Point& point) const
+	{
+		Point p = point;
+		for (const View* v = parent(); v; v = v->parent())
+			p -= v->frame().position();
+		return p;
+	}
+
+	Point
+	View::to_window (const Point& point) const
+	{
+		not_implemented_error(__FILE__, __LINE__);
+		return 0;
+	}
+
+	Point
+	View::from_screen (const Point& point) const
+	{
+		not_implemented_error(__FILE__, __LINE__);
+		return 0;
+	}
+
+	Point
+	View::to_screen (const Point& point) const
+	{
+		not_implemented_error(__FILE__, __LINE__);
+		return 0;
+	}
+
+	static void
+	set_parent (View* view, View* parent)
+	{
+		assert(view);
+		View::Data* self = view->self.get();
+
+		if (parent == self->parent) return;
+
+		self->parent = parent;
+		View_set_window(view, parent ? parent->window() : NULL);
+	}
+
+	static void
+	erase_child_from_children (View* parent, View* child)
+	{
+		assert(parent && child);
+
+		View::ChildList* children = parent->self->pchildren.get();
+		if (!children) return;
+
+		auto end = children->end();
+		auto it  = std::find(children->begin(), end, child);
+		assert(it != end);
+
+		children->erase(it);
+		if (children->empty())
+			parent->self->pchildren.reset();
 	}
 
 	void
@@ -1073,12 +1545,15 @@ namespace Reflex
 		else if (found != belong)
 			invalid_state_error(__FILE__, __LINE__);
 
-		child->self->add_flag(View::Data::ACTIVE);
-
 		self->children().push_back(child);
+
+		View* prev_parent = child->parent();
 		set_parent(child, this);
 
-		update_layout(this);
+		if (prev_parent)
+			erase_child_from_children(prev_parent, child);
+
+		update_view_layout(this);
 	}
 
 	void
@@ -1087,54 +1562,36 @@ namespace Reflex
 		if (!child || child == this)
 			argument_error(__FILE__, __LINE__);
 
-		if (!self->pchildren) return;
-
-		child_iterator it = std::find(child_begin(), child_end(), child);
-		if (it == child_end()) return;
-
-		child->self->remove_flag(View::Data::ACTIVE);
-
-		if (self->has_flag(Data::UPDATING_WORLD))
-		{
-			child->self->add_flag(View::Data::REMOVE_SELF);
+		bool found  = std::find(child_begin(), child_end(), child) != child_end();
+		bool belong = child->parent() == this;
+		if (!found && !belong)
 			return;
-		}
-
-		if (child->parent() != this)
+		else if (found != belong)
 			invalid_state_error(__FILE__, __LINE__);
 
-		child->clear_body();
-
 		set_parent(child, NULL);
-		self->pchildren->erase(it);
 
-		update_layout(this);
+		erase_child_from_children(this, child);
+
+		update_view_layout(this);
 	}
 
-	static void
-	find_all_children (
-		View::ChildList* result, const View* view, const Selector& selector, bool recursive)
+	void
+	View::clear_children ()
 	{
-		View::const_child_iterator end = view->child_end();
-		for (View::const_child_iterator it = view->child_begin(); it != end; ++it)
-		{
-			const View* child = it->get();
-			if (!child)
-				invalid_state_error(__FILE__, __LINE__);
-
-			if (child->selector().contains(selector))
-				result->push_back(*it);
+		if (!self->pchildren || self->pchildren->empty()) return;
 
-			if (recursive) find_all_children(result, child, selector, true);
-		}
+		auto children = *self->pchildren;
+		for (auto& child : children)
+			remove_child(child);
 	}
 
-	void
-	View::find_children (
-		ChildList* result, const Selector& selector, bool recursive) const
+	View::ChildList
+	View::find_children (const Selector& selector, bool recursive) const
 	{
-		result->clear();
-		find_all_children(result, this, selector, recursive);
+		ChildList result;
+		find_all_children(&result, this, selector, recursive);
+		return result;
 	}
 
 	static View::ChildList empty_children;
@@ -1182,14 +1639,14 @@ namespace Reflex
 	static Style*
 	add_view_style (View* view, Style style)
 	{
-		assert(view && *view);
+		assert(view);
 
-		if (!set_style_owner(&style, view))
+		if (!Style_set_owner(&style, view))
 			return NULL;
 
-		View::StyleList* styles = &view->self->styles();
-		styles->push_back(style);
-		return &styles->back();
+		View::StyleList* pstyles = &view->self->styles();
+		pstyles->push_back(style);
+		return &pstyles->back();
 	}
 
 	void
@@ -1203,10 +1660,23 @@ namespace Reflex
 	{
 		if (!self->pstyles) return;
 
-		style_iterator it = std::find(style_begin(), style_end(), style);
-		if (it == style_end()) return;
+		auto end = style_end();
+		auto it = std::find(style_begin(), end, style);
+		if (it == end) return;
+
+		if (!Style_set_owner(&*it, NULL))
+			invalid_state_error(__FILE__, __LINE__);
 
-		self->styles().erase(it);
+		self->pstyles->erase(it);
+		if (self->pstyles->empty())
+			self->pstyles.reset();
+	}
+
+	void
+	View::clear_styles ()
+	{
+		while (self->pstyles && !self->pstyles->empty())
+			remove_style(*self->pstyles->begin());
 	}
 
 	Style*
@@ -1215,11 +1685,14 @@ namespace Reflex
 		if (selector.is_empty())
 			return style(create);
 
-		style_iterator end = style_end();
-		for (style_iterator it = style_begin(); it != end; ++it)
+		StyleList* pstyles = self->pstyles.get();
+		if (pstyles)
 		{
-			if (selector == it->selector())
-				return &*it;
+			for (auto& style : *pstyles)
+			{
+				if (selector == style.selector())
+					return &style;
+			}
 		}
 
 		if (create)
@@ -1238,11 +1711,12 @@ namespace Reflex
 		return const_cast<View*>(this)->get_style(selector);
 	}
 
-	void
-	View::find_styles (StyleList* result, const Selector& selector, bool recursive) const
+	View::StyleList
+	View::find_styles (const Selector& selector, bool recursive) const
 	{
-		result->clear();
-		find_all_styles(result, this, selector, recursive);
+		StyleList result;
+		find_all_styles(&result, this, selector, recursive);
+		return result;
 	}
 
 	static View::StyleList empty_styles;
@@ -1268,317 +1742,586 @@ namespace Reflex
 		return self->pstyles->end();
 	}
 
-	View::const_style_iterator
-	View::style_end () const
+	View::const_style_iterator
+	View::style_end () const
+	{
+		if (!self->pstyles) return empty_styles.end();
+		return self->pstyles->end();
+	}
+
+	void
+	View::set_shape (Shape* shape)
+	{
+		if (!shape)
+			self->add_flag(Data::NO_SHAPE);
+		else
+			self->remove_flag(Data::NO_SHAPE);
+
+		Shape::Ref& pshape = self->pshape;
+		if (shape == pshape.get()) return;
+
+		if (pshape) Shape_set_owner(pshape, NULL);
+		pshape.reset(shape);
+		if (pshape) Shape_set_owner(pshape, this);
+	}
+
+	Shape*
+	View::shape (bool create)
+	{
+		if (create && !self->pshape && !self->has_flag(Data::NO_SHAPE))
+			set_shape(new RectShape);
+
+		return self->pshape.get();
+	}
+
+	const Shape*
+	View::shape () const
+	{
+		return const_cast<View*>(this)->shape(false);
+	}
+
+	void
+	View::add_shape (Shape* shape)
+	{
+		if (!shape) return;
+
+		Shape_set_owner(shape, this);
+		self->shapes().push_back(shape);
+	}
+
+	void
+	View::remove_shape (Shape* shape)
+	{
+		if (!shape || !self->pshapes)
+			return;
+
+		auto end = shape_end();
+		auto it  = std::find(shape_begin(), end, shape);
+		if (it == end) return;
+
+		Shape_set_owner(it->get(), NULL);
+
+		self->pshapes->erase(it);
+		if (self->pshapes->empty())
+			self->pshapes.reset();
+	}
+
+	void
+	View::clear_shapes ()
+	{
+		set_shape(NULL);
+		while (self->pshapes && !self->pshapes->empty())
+			remove_shape(self->pshapes->begin()->get());
+	}
+
+	View::ShapeList
+	View::find_shapes (const Selector& selector) const
+	{
+		ShapeList result;
+		ShapeList* pshapes = self->pshapes.get();
+		if (pshapes)
+		{
+			for (auto& shape : *pshapes)
+			{
+				if (selector.contains(shape->selector()))
+					result.push_back(shape);
+			}
+		}
+		return result;
+	}
+
+	static View::ShapeList empty_shapes;
+
+	View::shape_iterator
+	View::shape_begin ()
+	{
+		if (!self->pshapes) return empty_shapes.begin();
+		return self->pshapes->begin();
+	}
+
+	View::const_shape_iterator
+	View::shape_begin () const
+	{
+		if (!self->pshapes) return empty_shapes.begin();
+		return self->pshapes->begin();
+	}
+
+	View::shape_iterator
+	View::shape_end ()
+	{
+		if (!self->pshapes) return empty_shapes.end();
+		return self->pshapes->end();
+	}
+
+	View::const_shape_iterator
+	View::shape_end () const
+	{
+		if (!self->pshapes) return empty_shapes.end();
+		return self->pshapes->end();
+	}
+
+	void
+	View::set_filter (Filter* filter)
+	{
+		self->pfilter = filter;
+	}
+
+	Filter*
+	View::filter ()
+	{
+		return self->pfilter.get();
+	}
+
+	const Filter*
+	View::filter () const
+	{
+		return const_cast<View*>(this)->filter();
+	}
+
+	void
+	View::set_name (const char* name)
+	{
+		const char* current = this->name();
+		if (name && current && strcmp(name, current) == 0)
+			return;
+
+		HasSelector::set_name(name);
+		self->add_flag(Data::UPDATE_STYLE);
+	}
+
+	void
+	View::add_tag (const char* tag)
+	{
+		if (has_tag(tag)) return;
+
+		HasSelector::add_tag(tag);
+		self->add_flag(Data::UPDATE_STYLE);
+	}
+
+	void
+	View::remove_tag (const char* tag)
+	{
+		if (!has_tag(tag)) return;
+
+		HasSelector::remove_tag(tag);
+		self->add_flag(Data::UPDATE_STYLE);
+	}
+
+	void
+	View::clear_tags ()
+	{
+		if (tag_begin() == tag_end()) return;
+
+		HasSelector::clear_tags();
+		self->add_flag(Data::UPDATE_STYLE);
+	}
+
+	void
+	View::set_selector (const Selector& selector)
+	{
+		if (selector == this->selector()) return;
+
+		HasSelector::set_selector(selector);
+		self->add_flag(Data::UPDATE_STYLE);
+	}
+
+	void
+	View::set_frame (coord x, coord y, coord width, coord height)
+	{
+		set_frame(Bounds(x, y, width, height));
+	}
+
+	void
+	View::set_frame (const Bounds& frame)
+	{
+		const Bounds& current = self->frame;
+
+		if (frame.w != current.w && !Style_has_width(*style()))
+			style()->set_width(StyleLength::NONE);
+
+		if (frame.h != current.h && !Style_has_height(*style()))
+			style()->set_height(StyleLength::NONE);
+
+		View_set_frame(this, frame);
+	}
+
+	const Bounds&
+	View::frame () const
+	{
+		return self->frame;
+	}
+
+	Bounds
+	View::content_bounds () const
+	{
+		Bounds bounds = Rays::invalid_bounds();
+		self->each_shape([&](const Shape* shape)
+		{
+			if (!shape || !Shape_has_frame(*shape))
+				return;
+
+			Bounds frame = shape->frame();
+			if (frame) bounds |= frame;
+		});
+		return bounds;
+	}
+
+	void
+	View::fit_to_content ()
+	{
+		self->add_flag(View::Data::FIT_TO_CONTENT);
+	}
+
+	void
+	View::set_angle (float degree)
+	{
+		update_view_frame(this, self->frame, degree, true);
+	}
+
+	float
+	View::angle () const
+	{
+		return self->angle;
+	}
+
+	static const Point ZERO_SCROLL;
+
+	void
+	View::scroll_to (coord x, coord y, coord z)
+	{
+		Point old = self->scroll();
+		self->scroll().reset(x, y, z);
+		ScrollEvent e(x, y, z, x - old.x, y - old.y, z - old.z);
+		on_scroll(&e);
+
+		redraw();
+	}
+
+	void
+	View::scroll_to (const Point& scroll)
+	{
+		scroll_to(scroll.x, scroll.y, scroll.z);
+	}
+
+	void
+	View::scroll_by (coord x, coord y, coord z)
+	{
+		const Point& p = scroll();
+		scroll_to(p.x + x, p.y + y, p.z + z);
+	}
+
+	void
+	View::scroll_by (const Point& dscroll)
+	{
+		scroll_by(dscroll.x, dscroll.y, dscroll.z);
+	}
+
+	const Point&
+	View::scroll () const
+	{
+		if (self->pscroll)
+			return self->scroll();
+		else
+			return ZERO_SCROLL;
+	}
+
+	void
+	View::set_zoom (float zoom)
+	{
+		self->zoom = zoom;
+		redraw();
+	}
+
+	float
+	View::zoom () const
+	{
+		return self->zoom;
+	}
+
+	void
+	View::set_capture (uint types)
+	{
+		if (types == self->capture) return;
+
+		uint old      = self->capture;
+		self->capture = types;
+
+		bool registered = old   != CAPTURE_NONE;
+		bool capture    = types != CAPTURE_NONE;
+
+		if (capture && !registered)
+			View_register_capture(this);
+		else if (!capture && registered)
+			View_unregister_capture(this);
+
+		CaptureEvent e(~old & types, old & ~types);
+		on_capture(&e);
+	}
+
+	uint
+	View::capture () const
 	{
-		if (!self->pstyles) return empty_styles.end();
-		return self->pstyles->end();
+		return self->capture;
 	}
 
 	void
-	View::focus (bool state)
+	View::add_flag (uint flags)
 	{
-		Window* w = window();
-		if (!w) return;
-
-		void set_focus (Window*, View*);
-		if (state)
-			set_focus(w, this);
-		else if (w->focus() == this)
-			set_focus(w, NULL);
+		self->add_flag(flags);
 	}
 
 	void
-	View::blur ()
+	View::remove_flag (uint flags)
 	{
-		focus(false);
+		self->remove_flag(flags);
 	}
 
 	bool
-	View::has_focus () const
+	View::has_flag (uint flags) const
 	{
-		const Window* w = window();
-		return w && w->focus() == this;
+		return self->has_flag(flags);
 	}
 
-	void
-	View::resize_to_fit ()
+	View*
+	View::parent ()
 	{
-		Point size = content_size();
-		if (size.x < 0 && size.y < 0 && size.z <= 0) return;
-
-		const Style* st = style();
-
-		Bounds b = frame();
-		if ((!st || !st->width())  && size.x >= 0) b.width  = size.x;
-		if ((!st || !st->height()) && size.y >= 0) b.height = size.y;
-		if (                          size.z >= 0) b.depth  = size.z;
-		set_frame(b);
+		return self->parent;
 	}
 
-	Point
-	View::content_size () const
+	const View*
+	View::parent () const
 	{
-		return -1;
+		return const_cast<This*>(this)->parent();
 	}
 
-	void
-	View::make_body ()
+	Window*
+	View::window ()
 	{
-		Body* b = body();
-		if (!b) return;
-
-		b->clear_fixtures();
-
-		const Point& size = frame().size();
-		b->add_box(size.x, size.y);
+		return self->window;
 	}
 
-	void
-	View::clear_body ()
+	const Window*
+	View::window () const
 	{
-		Body* body = self->pbody.get();
-		if (!body) return;
-
-		World* world = self->parent_world();
-		if (!world)
-			invalid_state_error(__FILE__, __LINE__);
-
-		world->destroy_body(body);
-		self->pbody.reset();
+		return const_cast<View*>(this)->window();
 	}
 
 	void
-	View::set_name (const char* name)
+	View::apply_force (coord x, coord y)
 	{
-		self->selector().set_name(name);
+		self->body().apply_force(x, y);
 	}
 
-	const char*
-	View::name () const
+	void
+	View::apply_force (const Point& force)
 	{
-		const Selector* sel = self->pselector.get();
-		return sel ? sel->name() : "";
+		self->body().apply_force(force);
 	}
 
 	void
-	View::add_tag (const char* tag)
+	View::apply_torque (float torque)
 	{
-		self->selector().add_tag(tag);
+		self->body().apply_torque(torque);
 	}
 
 	void
-	View::remove_tag (const char* tag)
+	View::apply_linear_impulse (coord x, coord y)
 	{
-		Selector* sel = self->pselector.get();
-		if (!sel) return;
-
-		sel->remove_tag(tag);
+		self->body().apply_linear_impulse(x, y);
 	}
 
-	static Selector::TagSet empty_tags;
-
-	View::tag_iterator
-	View::tag_begin ()
+	void
+	View::apply_linear_impulse (const Point& impulse)
 	{
-		Selector* sel = self->pselector.get();
-		return sel ? sel->begin() : empty_tags.begin();
+		self->body().apply_linear_impulse(impulse);
 	}
 
-	View::const_tag_iterator
-	View::tag_begin () const
+	void
+	View::apply_angular_impulse (float impulse)
 	{
-		const Selector* sel = self->pselector.get();
-		return sel ? sel->begin() : empty_tags.begin();
+		self->body().apply_angular_impulse(impulse);
 	}
 
-	View::tag_iterator
-	View::tag_end ()
+	void
+	View::set_static (bool state)
 	{
-		Selector* sel = self->pselector.get();
-		return sel ? sel->end() : empty_tags.end();
+		set_dynamic(!state);
 	}
 
-	View::const_tag_iterator
-	View::tag_end () const
+	bool
+	View::is_static () const
 	{
-		const Selector* sel = self->pselector.get();
-		return sel ? sel->end() : empty_tags.end();
+		return self->pbody ? !self->pbody->is_dynamic() : false;
 	}
 
 	void
-	View::set_selector (const Selector& selector)
+	View::set_dynamic (bool state)
 	{
-		self->selector() = selector;
+		Body& b = self->body();
+		if (state == b.is_dynamic())
+			return;
+
+		b.set_dynamic(state);
 	}
 
-	Selector&
-	View::selector ()
+	bool
+	View::is_dynamic () const
 	{
-		return self->selector();
+		return self->pbody ? self->pbody->is_dynamic() : false;
 	}
 
-	const Selector&
-	View::selector () const
+	void
+	View::set_density (float density)
 	{
-		static const Selector EMPTY;
+		Shape* s = shape();
+		if (!s)
+			invalid_state_error(__FILE__, __LINE__, "view has no shape.");
 
-		const Selector* sel = self->pselector.get();
-		return sel ? *sel : EMPTY;
+		s->set_density(density);
 	}
 
-	void
-	View::set_frame (coord x, coord y, coord width, coord height)
+	float
+	View::density () const
 	{
-		set_frame(Bounds(x, y, width, height));
+		const Shape* s = self->pshape.get();
+		return s ? s->density() : 0;
 	}
 
 	void
-	View::set_frame (const Bounds& frame)
+	View::set_friction (float friction)
 	{
-		update_view_frame(this, frame, self->angle, true);
+		Shape* s = shape();
+		if (!s)
+			invalid_state_error(__FILE__, __LINE__, "view has no shape.");
+
+		s->set_friction(friction);
 	}
 
-	const Bounds&
-	View::frame () const
+	float
+	View::friction () const
 	{
-		return self->frame;
+		const Shape* s = self->pshape.get();
+		return s ? s->friction() : 0;
 	}
 
 	void
-	View::set_zoom (float zoom)
+	View::set_restitution (float restitution)
 	{
-		self->zoom = zoom;
-		redraw();
+		Shape* s = shape();
+		if (!s)
+			invalid_state_error(__FILE__, __LINE__, "view has no shape.");
+
+		s->set_restitution(restitution);
 	}
 
 	float
-	View::zoom () const
+	View::restitution () const
 	{
-		return self->zoom;
+		const Shape* s = self->pshape.get();
+		return s ? s->restitution() : 0;
 	}
 
-#if 0
 	void
-	View::set_angle (float degree)
+	View::set_sensor (bool state)
 	{
-		update_view_frame(this, self->frame, degree, true);
+		Shape* s = shape();
+		if (!s)
+			invalid_state_error(__FILE__, __LINE__, "view has no shape.");
+
+		s->set_sensor(state);
 	}
-#endif
 
-	float
-	View::angle () const
+	bool
+	View::is_sensor () const
 	{
-		return self->angle;
+		const Shape* s = self->pshape.get();
+		return s ? s->is_sensor() : false;
 	}
 
-	static const Point ZERO_SCROLL;
-
 	void
-	View::scroll_to (coord x, coord y, coord z)
+	View::set_category_bits (uint bits)
 	{
-		Point old = self->scroll();
-		self->scroll().reset(x, y, z);
-		ScrollEvent e(x, y, z, x - old.x, y - old.y, z - old.z);
-		on_scroll(&e);
+		Shape* s = shape();
+		if (!s)
+			invalid_state_error(__FILE__, __LINE__, "view has no shape.");
 
-		redraw();
+		s->set_category_bits(bits);
 	}
 
-	void
-	View::scroll_to (const Point& scroll)
+	uint
+	View::category_bits () const
 	{
-		scroll_to(scroll.x, scroll.y, scroll.z);
+		const Shape* s = self->pshape.get();
+		return s ? s->category_bits() : 0x1;
 	}
 
 	void
-	View::scroll_by (coord x, coord y, coord z)
+	View::set_collision_mask (uint mask)
 	{
-		const Point& p = scroll();
-		scroll_to(p.x + x, p.y + y, p.z + z);
-	}
+		Shape* s = shape();
+		if (!s)
+			invalid_state_error(__FILE__, __LINE__, "view has no shape.");
 
-	void
-	View::scroll_by (const Point& dscroll)
-	{
-		scroll_by(dscroll.x, dscroll.y, dscroll.z);
+		s->set_collision_mask(mask);
 	}
 
-	const Point&
-	View::scroll () const
+	uint
+	View::collision_mask () const
 	{
-		if (self->pscroll)
-			return self->scroll();
-		else
-			return ZERO_SCROLL;
+		const Shape* s = self->pshape.get();
+		return s ? s->collision_mask() : 0xffff;
 	}
 
 	void
-	View::set_capture (uint types)
+	View::set_linear_velocity (coord x, coord y)
 	{
-		if (types == self->capture) return;
-
-		uint old      = self->capture;
-		self->capture = types;
-
-		bool registered = old   != CAPTURE_NONE;
-		bool capture    = types != CAPTURE_NONE;
-
-		if (capture && !registered)
-		{
-			void register_capture (View*);
-			register_capture(this);
-		}
-		else if (!capture && registered)
-		{
-			void unregister_capture (View*);
-			unregister_capture(this);
-		}
-
-		CaptureEvent e(~old & types, old & ~types);
-		on_capture(&e);
+		self->body().set_linear_velocity(x, y);
 	}
 
-	uint
-	View::capture () const
+	void
+	View::set_linear_velocity (const Point& velocity)
 	{
-		return self->capture;
+		self->body().set_linear_velocity(velocity);
 	}
 
-	View*
-	View::parent ()
+	Point
+	View::linear_velocity () const
 	{
-		return self->parent;
+		const Body* b = self->pbody.get();
+		return b ? b->linear_velocity() : 0;
 	}
 
-	const View*
-	View::parent () const
+	void
+	View::set_angular_velocity (float velocity)
 	{
-		return const_cast<This*>(this)->parent();
+		self->body().set_angular_velocity(velocity);
 	}
 
-	Window*
-	View::window ()
+	float
+	View::angular_velocity () const
 	{
-		return self->window;
+		const Body* b = self->pbody.get();
+		return b ? b->angular_velocity() : 0;
 	}
 
-	const Window*
-	View::window () const
+	void
+	View::set_gravity_scale (float scale)
 	{
-		return const_cast<View*>(this)->window();
+		self->body().set_gravity_scale(scale);
 	}
 
-	Body*
-	View::body ()
+	float
+	View::gravity_scale () const
 	{
-		return self->body(this);
+		const Body* b = self->pbody.get();
+		return b ? b->gravity_scale() : 1;
 	}
 
-	const Body*
-	View::body () const
+	void
+	View::update_physics (float duration)
 	{
-		return const_cast<View*>(this)->body();
+		World* w = self->pchild_world.get();
+		if (w) w->update(duration);
 	}
 
 	float
@@ -1588,27 +2331,22 @@ namespace Reflex
 		if (body)
 			return body->meter2pixel(meter);
 
-		World* world   = self->pworld.get();
-		if (world)
-			return world->meter2pixel(meter);
+		World* child_world = self->pchild_world.get();
+		if (child_world)
+			return child_world->meter2pixel(meter);
 
-		View*  parent_      = NULL;
-		World* parent_world = NULL;
-		if (
-			(parent_      = parent()) &&
-			(parent_world = parent_->self->pworld.get()))
-		{
+		World* parent_world = self->parent_world(false);
+		if (parent_world)
 			return parent_world->meter2pixel(meter);
-		}
 
 		if (!create_world)
 			invalid_state_error(__FILE__, __LINE__);
 
-		World* new_world = self->world(this);
-		if (!new_world)
+		child_world = self->child_world(this);
+		if (!child_world)
 			invalid_state_error(__FILE__, __LINE__);
 
-		return new_world->meter2pixel(meter);
+		return child_world->meter2pixel(meter);
 	}
 
 	float
@@ -1626,283 +2364,179 @@ namespace Reflex
 	void
 	View::set_gravity (const Point& vector)
 	{
-		World* w = self->world(this);
-		if (!w)
-			invalid_state_error(__FILE__, __LINE__);
-
-		w->set_gravity(vector);
+		self->child_world(this)->set_gravity(vector);
 	}
 
 	Point
 	View::gravity () const
 	{
-		World* w = self->pworld.get();
+		World* w = self->pchild_world.get();
 		return w ? w->gravity() : 0;
 	}
 
-	Body*
-	View::wall ()
-	{
-		return self->world(this)->wall();
-	}
-
-	const Body*
-	View::wall () const
-	{
-		return const_cast<View*>(this)->wall();
-	}
-
 	void
-	View::set_debug (bool state)
+	View::set_time_scale (float scale)
 	{
-		World* w = self->world(this);
-		if (!w)
-			invalid_state_error(__FILE__, __LINE__);
-
-		w->set_debug(state);
+		self->child_world(this)->set_time_scale(scale);
 	}
 
-	bool
-	View::debugging () const
+	float
+	View::time_scale () const
 	{
-		World* w = self->pworld.get();
-		return w ? w->debugging() : false;
+		World* w = self->pchild_world.get();
+		return w ? w->time_scale() : 1;
 	}
 
-	Point
-	View::from_parent (const Point& point) const
+	View*
+	View::wall ()
 	{
-		not_implemented_error(__FILE__, __LINE__);
-		return 0;
-	}
+		self->child_world(this);
 
-	Point
-	View::to_parent (const Point& point) const
-	{
-		not_implemented_error(__FILE__, __LINE__);
-		return 0;
-	}
+		ChildList children = find_children(WALL_NAME);
+		if (children.empty()) return NULL;
 
-	Point
-	View::from_window (const Point& point) const
-	{
-		Point p = point;
-		for (const View* v = parent(); v; v = v->parent())
-			p -= v->frame().position();
-		return p;
+		return children[0].get();
 	}
 
-	Point
-	View::to_window (const Point& point) const
+	const View*
+	View::wall () const
 	{
-		not_implemented_error(__FILE__, __LINE__);
-		return 0;
+		return const_cast<View*>(this)->wall();
 	}
 
-	Point
-	View::from_screen (const Point& point) const
+	void
+	View::set_debug (bool state)
 	{
-		not_implemented_error(__FILE__, __LINE__);
-		return 0;
+		World* w = self->child_world(this);
+		if (w) w->set_debug(state);
 	}
 
-	Point
-	View::to_screen (const Point& point) const
+	bool
+	View::debug () const
 	{
-		not_implemented_error(__FILE__, __LINE__);
-		return 0;
+		World* w = self->pchild_world.get();
+		return w ? w->debug() : false;
 	}
 
 	void
 	View::on_attach (Event* e)
 	{
-		if (!e)
-			argument_error(__FILE__, __LINE__);
 	}
 
 	void
 	View::on_detach (Event* e)
 	{
-		if (!e)
-			argument_error(__FILE__, __LINE__);
 	}
 
 	void
 	View::on_show (Event* e)
 	{
-		if (!e)
-			argument_error(__FILE__, __LINE__);
 	}
 
 	void
 	View::on_hide (Event* e)
 	{
-		if (!e)
-			argument_error(__FILE__, __LINE__);
 	}
 
 	void
 	View::on_update (UpdateEvent* e)
 	{
-		if (!e)
-			argument_error(__FILE__, __LINE__);
 	}
 
 	void
 	View::on_draw (DrawEvent* e)
 	{
-		if (!e)
-			argument_error(__FILE__, __LINE__);
 	}
 
 	void
 	View::on_move (FrameEvent* e)
 	{
-		if (!e)
-			argument_error(__FILE__, __LINE__);
 	}
 
 	void
 	View::on_resize (FrameEvent* e)
 	{
-		if (!e)
-			argument_error(__FILE__, __LINE__);
 	}
 
 	void
 	View::on_rotate (FrameEvent* e)
 	{
-		if (!e)
-			argument_error(__FILE__, __LINE__);
 	}
 
 	void
 	View::on_scroll (ScrollEvent* e)
 	{
-		if (!e)
-			argument_error(__FILE__, __LINE__);
 	}
 
 	void
 	View::on_focus (FocusEvent* e)
 	{
-		if (!e)
-			argument_error(__FILE__, __LINE__);
-	}
-
-	void
-	View::on_blur (FocusEvent* e)
-	{
-		if (!e)
-			argument_error(__FILE__, __LINE__);
 	}
 
 	void
 	View::on_key (KeyEvent* e)
 	{
-		if (!e)
-			argument_error(__FILE__, __LINE__);
-
-		switch (e->type)
-		{
-			case KeyEvent::DOWN: on_key_down(e); break;
-			case KeyEvent::UP:   on_key_up(e);   break;
-			case KeyEvent::NONE: break;
-		}
 	}
 
 	void
 	View::on_key_down (KeyEvent* e)
 	{
-		if (!e)
-			argument_error(__FILE__, __LINE__);
 	}
 
 	void
 	View::on_key_up (KeyEvent* e)
 	{
-		if (!e)
-			argument_error(__FILE__, __LINE__);
 	}
 
 	void
 	View::on_pointer (PointerEvent* e)
 	{
-		if (!e)
-			argument_error(__FILE__, __LINE__);
-
-		switch (e->type)
-		{
-			case PointerEvent::DOWN: on_pointer_down(e); break;
-			case PointerEvent::UP:   on_pointer_up(e);   break;
-			case PointerEvent::MOVE: on_pointer_move(e); break;
-			case PointerEvent::NONE: break;
-		}
 	}
 
 	void
 	View::on_pointer_down (PointerEvent* e)
 	{
-		if (!e)
-			argument_error(__FILE__, __LINE__);
 	}
 
 	void
 	View::on_pointer_up (PointerEvent* e)
 	{
-		if (!e)
-			argument_error(__FILE__, __LINE__);
 	}
 
 	void
 	View::on_pointer_move (PointerEvent* e)
 	{
-		if (!e)
-			argument_error(__FILE__, __LINE__);
 	}
 
 	void
 	View::on_wheel (WheelEvent* e)
 	{
-		if (!e)
-			argument_error(__FILE__, __LINE__);
-
 		//scroll_by(e->dx, e->dy, e->dz);
 	}
 
 	void
 	View::on_capture (CaptureEvent* e)
 	{
-		if (!e)
-			argument_error(__FILE__, __LINE__);
 	}
 
 	void
-	View::on_contact (ContactEvent* e)
+	View::on_timer (TimerEvent* e)
 	{
-		if (!e)
-			argument_error(__FILE__, __LINE__);
+	}
 
-		switch (e->type)
-		{
-			case ContactEvent::BEGIN: on_contact_begin(e); break;
-			case ContactEvent::END:   on_contact_end(e);   break;
-			case ContactEvent::NONE: break;
-		}
+	void
+	View::on_contact (ContactEvent* e)
+	{
 	}
 
 	void
 	View::on_contact_begin (ContactEvent* e)
 	{
-		if (!e)
-			argument_error(__FILE__, __LINE__);
 	}
 
 	void
 	View::on_contact_end (ContactEvent* e)
 	{
-		if (!e)
-			argument_error(__FILE__, __LINE__);
 	}
 
 	View::operator bool () const
@@ -1916,5 +2550,11 @@ namespace Reflex
 		return !operator bool();
 	}
 
+	SelectorPtr*
+	View::get_selector_ptr ()
+	{
+		return &self->pselector;
+	}
+
 
 }// Reflex