reflexion 0.5.3 → 0.7.0

data/src/view.cpp

@@ -4,6 +4,7 @@
 #include <limits.h>
 #include <string.h>
 #include <assert.h>
+#include <math.h>
 #include <memory>
 #include <algorithm>
 #include <rays/matrix.h>
@@ -20,6 +21,7 @@
 #include "world.h"
 #include "body.h"
 #include "fixture.h"
+#include "constraint.h"
 
 
 namespace Reflex
@@ -39,29 +41,23 @@ namespace Reflex
 		enum Flag
 		{
 
-			UPDATING               = Xot::bit(1, FLAG_LAST),
+			NO_SHAPE             = Xot::bit(1, FLAG_LAST),
 
-			NO_SHAPE               = Xot::bit(2, FLAG_LAST),
+			HAS_VARIABLE_LENGTHS = Xot::bit(2, FLAG_LAST),
 
-			HAS_VARIABLE_LENGTHS   = Xot::bit(3, FLAG_LAST),
+			REDRAW               = Xot::bit(3, FLAG_LAST),
 
-			HAS_CHILDREN_TO_REMOVE = Xot::bit(4, FLAG_LAST),
+			APPLY_STYLE          = Xot::bit(4, FLAG_LAST),
 
-			REMOVE_FROM_PARENT     = Xot::bit(5, FLAG_LAST),
+			UPDATE_STYLE         = Xot::bit(5, FLAG_LAST),
 
-			REDRAW                 = Xot::bit(6, FLAG_LAST),
+			UPDATE_SHAPES        = Xot::bit(6, FLAG_LAST),
 
-			APPLY_STYLE            = Xot::bit(7, FLAG_LAST),
+			UPDATE_LAYOUT        = Xot::bit(7, FLAG_LAST),
 
-			UPDATE_STYLE           = Xot::bit(8, FLAG_LAST),
+			SORT_CHILDREN        = Xot::bit(8, FLAG_LAST),
 
-			UPDATE_SHAPES          = Xot::bit(9, FLAG_LAST),
-
-			UPDATE_LAYOUT          = Xot::bit(10, FLAG_LAST),
-
-			SORT_CHILDREN          = Xot::bit(11, FLAG_LAST),
-
-			FIT_TO_CONTENT         = Xot::bit(12, FLAG_LAST),
+			FIT_TO_CONTENT       = Xot::bit(9, FLAG_LAST),
 
 		};// Flag
 
@@ -81,38 +77,42 @@ namespace Reflex
 
 		ushort child_index = 0;
 
+		int loop_depth     = 0;
+
 		uint flags         =
 			FLAG_CLIP | FLAG_RESIZE_TO_FIT | REDRAW | UPDATE_LAYOUT | UPDATE_STYLE;
 
-		std::unique_ptr<Point>       ppivot;
+		std::unique_ptr<Point>          ppivot;
 
-		std::unique_ptr<Point>       pscroll;
+		std::unique_ptr<Point>          pscroll;
 
-		SelectorPtr                  pselector;
+		SelectorPtr                     pselector;
 
-		std::unique_ptr<SelectorSet> pselectors_for_update;
+		std::unique_ptr<SelectorSet>    pselectors_for_update;
 
-		std::unique_ptr<Image>       pcache_image;
+		std::unique_ptr<Image>          pdraw_cache;
 
-		std::unique_ptr<Timers>      ptimers;
+		std::unique_ptr<Timers>         ptimers;
 
-		std::unique_ptr<Style>       pstyle;
+		std::unique_ptr<Style>          pstyle;
 
-		std::unique_ptr<StyleList>   pstyles;
+		std::unique_ptr<StyleList>      pstyles;
 
-		Shape::Ref                   pshape;
+		Shape::Ref                      pshape;
 
-		std::unique_ptr<ShapeList>   pshapes;
+		std::unique_ptr<ShapeList>      pshapes;
 
-		Filter::Ref                  pfilter;
+		Filter::Ref                     pfilter;
 
-		std::unique_ptr<Body>        pbody;
+		std::unique_ptr<Body>           pbody;
 
-		std::unique_ptr<World>       pchild_world;
+		std::unique_ptr<ConstraintList> pconstraints;
 
-		std::unique_ptr<ChildList>   pchildren;
+		std::unique_ptr<World>          pchild_world;
 
-		std::unique_ptr<ChildList>   pchildren_sorted;
+		std::unique_ptr<ChildList>      pchildren;
+
+		std::unique_ptr<ChildList>      pchildren_for_loop;
 
 		Point& pivot ()
 		{
@@ -176,6 +176,24 @@ namespace Reflex
 			return *pshapes;
 		}
 
+		ConstraintList& constraints ()
+		{
+			if (!pconstraints) pconstraints.reset(new ConstraintList);
+			return *pconstraints;
+		}
+
+		void sever_constraints ()
+		{
+			if (!pconstraints) return;
+
+			ConstraintList list;
+			list.swap(*pconstraints);
+			for (auto& constraint : list)
+				Constraint_sever(constraint.get());
+
+			pconstraints.reset();
+		}
+
 		template <typename FUN>
 		void each_shape (FUN fun)
 		{
@@ -203,6 +221,17 @@ namespace Reflex
 			});
 		}
 
+		void update_constraints ()
+		{
+			if (!pconstraints) return;
+
+			for (auto& constraint : *pconstraints)
+			{
+				Constraint_deactivate(constraint.get());
+				Constraint_activate(constraint.get());
+			}
+		}
+
 		void resize_shapes (FrameEvent* e)
 		{
 			each_shape([=](Shape* shape)
@@ -287,6 +316,7 @@ namespace Reflex
 			}
 
 			update_shapes(true);
+			update_constraints();
 		}
 
 		World* parent_world (bool create = true)
@@ -331,24 +361,30 @@ namespace Reflex
 				view->remove_child(wall.get());
 		}
 
-		ChildList* children (bool create = false, bool sort = false)
+		ChildList* children (bool create = false)
 		{
-			if (!pchildren)
-			{
-				if (!create) return NULL;
-				pchildren.reset(new ChildList);
-			}
-
-			if (sort && check_and_remove_flag(SORT_CHILDREN))
-				do_sort_children();
+			if (!pchildren && create) pchildren.reset(new ChildList);
+			return pchildren.get();
+		}
 
-			return sort && pchildren_sorted ? pchildren_sorted.get() : pchildren.get();
+		ChildList* children_for_loop ()
+		{
+			if (pchildren && !pchildren_for_loop) do_sort_children();
+			return pchildren_for_loop.get();
 		}
 
-		void sort_children (bool order_only = false)
+		void sort_children ()
 		{
 			add_flag(SORT_CHILDREN);
-			if (!order_only && pchildren_sorted) pchildren_sorted.reset();
+		}
+
+		void update_children_for_loop (View* view)
+		{
+			if (!has_flag(SORT_CHILDREN) || loop_depth != 0)
+				return;
+
+			do_sort_children();
+			view->redraw();
 		}
 
 		void add_flag (uint flag)
@@ -361,6 +397,11 @@ namespace Reflex
 			Xot::remove_flag(&flags, flag);
 		}
 
+		void update_flag (uint flag, bool add)
+		{
+			Xot::update_flag(&flags, flag, add);
+		}
+
 		bool has_flag (uint flag) const
 		{
 			return Xot::has_flag(flags, flag);
@@ -375,7 +416,19 @@ namespace Reflex
 
 			void do_sort_children ()
 			{
-				auto& children = *pchildren;
+				remove_flag(SORT_CHILDREN);
+
+				if (!pchildren || pchildren->empty())
+				{
+					pchildren_for_loop.reset();
+					return;
+				}
+
+				if (!pchildren_for_loop)
+					pchildren_for_loop.reset(new ChildList);
+
+				auto& children      = *pchildren;
+				*pchildren_for_loop = children;
 
 				size_t size = children.size();
 				if (size >= USHRT_MAX)
@@ -389,20 +442,10 @@ namespace Reflex
 					have_z                  |= child->frame().z != 0;
 				}
 
-				if (!have_z)
-				{
-					pchildren_sorted.reset();
-					return;
-				}
-
-				if (!pchildren_sorted)
-				{
-					pchildren_sorted.reset(
-						new ChildList(children.begin(), children.end()));
-				}
+				if (!have_z) return;
 
 				std::sort(
-					pchildren_sorted->begin(), pchildren_sorted->end(),
+					pchildren_for_loop->begin(), pchildren_for_loop->end(),
 					[](const auto& a, const auto& b)
 					{
 						auto *aa = a->self.get(), *bb = b->self.get();
@@ -706,8 +749,64 @@ namespace Reflex
 	};// LayoutContext
 
 
-	void
-	View_set_window (View* view, Window* window)
+	struct LoopDepthGuard
+	{
+
+		View::Data* self;
+
+		LoopDepthGuard (View::Data* self)
+		:	self(self)
+		{
+			++self->loop_depth;
+		}
+
+		~LoopDepthGuard ()
+		{
+			--self->loop_depth;
+		}
+
+	};// LoopDepthGuard
+
+
+	static void
+	call_children (View* parent, std::function<bool(View*)> fun)
+	{
+		auto* children = parent->self->children_for_loop();
+		if (!children) return;
+
+		LoopDepthGuard depth_guard(parent->self.get());
+
+		for (auto it = children->rbegin(), end = children->rend(); it != end; ++it)
+		{
+			View::Ref child = *it;
+			if (!child) continue;// removed since the last frame
+
+			if (!fun(child.get()))
+				break;
+		}
+	}
+
+	static void
+	call_children_unsafe (View* parent, std::function<bool(View*)> fun)
+	{
+		auto* children = parent->self->children();
+		if (!children) return;
+
+		LoopDepthGuard depth_guard(parent->self.get());
+
+		for (size_t i = children->size(); i-- > 0;)
+		{
+			if (i >= children->size())
+				continue;// a handler shrank the list
+
+			View::Ref child = (*children)[i];
+			if (!fun(child.get()))
+				break;
+		}
+	}
+
+	static void
+	set_window (View* view, Window* window)
 	{
 		if (!view)
 			argument_error(__FILE__, __LINE__);
@@ -726,7 +825,7 @@ namespace Reflex
 		if (children)
 		{
 			for (auto& child : *children)
-				View_set_window(child.get(), window);
+				set_window(child.get(), window);
 		}
 
 		if (view->self->window)
@@ -737,6 +836,28 @@ namespace Reflex
 		}
 	}
 
+	void
+	View_set_window (View* view, Window* window)
+	{
+		if (!view)
+			argument_error(__FILE__, __LINE__);
+
+		Window* old = view->self->window;
+		if (old && old->active())
+		{
+			Event e;
+			View_deactivate_tree(view, &e);
+		}
+
+		set_window(view, window);
+
+		if (window && window->active())
+		{
+			Event e;
+			View_activate_tree(view, &e);
+		}
+	}
+
 	static void
 	apply_style_to_children_have_variable_lengths (View* parent)
 	{
@@ -797,7 +918,7 @@ namespace Reflex
 			self->update_body_frame();
 
 		if (moved && event.dz() != 0 && self->parent)
-			self->parent->self->sort_children(true);
+			self->parent->self->sort_children();
 
 		if ((moved || resized) && self->parent)
 			self->parent->self->add_flag(View::Data::FIT_TO_CONTENT);
@@ -832,18 +953,103 @@ namespace Reflex
 		return create ? &view->self->body() : view->self->pbody.get();
 	}
 
+	const Body*
+	View_get_body (const View* view)
+	{
+		return View_get_body(const_cast<View*>(view), false);
+	}
+
+	void
+	View_add_constraint (View* view, Constraint* constraint)
+	{
+		if (!view || !constraint)
+			argument_error(__FILE__, __LINE__);
+
+		if (constraint->is_removed())
+			invalid_state_error(__FILE__, __LINE__, "constraint is already removed");
+
+		if (constraint->view(0) != view)
+			argument_error(__FILE__, __LINE__, "the constraint does not belong to this view");
+
+		auto& list = view->self->constraints();
+		if (std::find(list.begin(), list.end(), constraint) != list.end())
+			invalid_state_error(__FILE__, __LINE__, "the constraint is already added");
+
+		// the mismatch is not detectable before activation because
+		// activating is what creates the missing bodies
+		if (
+			!Constraint_activate(constraint) &&
+			Constraint_has_world_mismatch(constraint))
+		{
+			physics_error(__FILE__, __LINE__, "the views belong to different worlds");
+		}
+
+		list.push_back(constraint);
+		View* view1 = constraint->view(1);
+		if (view1) view1->self->constraints().push_back(constraint);
+	}
+
+	void
+	View_remove_constraint (View* view, Constraint* constraint)
+	{
+		if (!view || !constraint)
+			argument_error(__FILE__, __LINE__);
+
+		auto* list = view->self->pconstraints.get();
+		if (!list) return;
+
+		auto it = std::find(list->begin(), list->end(), constraint);
+		if (it != list->end()) list->erase(it);
+
+		if (list->empty()) view->self->pconstraints.reset();
+	}
+
 	bool
 	View_is_active (const View& view)
 	{
 		return view.self->window;
 	}
 
+	void
+	View_activate_tree (View* view, Event* event)
+	{
+		if (!view)
+			argument_error(__FILE__, __LINE__);
+
+		Event e = event->dup();
+		view->on_activate(&e);
+		if (e.is_blocked()) return;
+
+		call_children_unsafe(view, [&](View* child) {
+			View_activate_tree(child, &e);
+			return !e.is_blocked();
+		});
+	}
+
+	void
+	View_deactivate_tree (View* view, Event* event)
+	{
+		if (!view)
+			argument_error(__FILE__, __LINE__);
+
+		Event e = event->dup();
+
+		call_children_unsafe(view, [&](View* child) {
+			View_deactivate_tree(child, &e);
+			return !e.is_blocked();
+		});
+
+		if (e.is_blocked()) return;
+
+		view->on_deactivate(&e);
+	}
+
 	static void
 	find_all_children (
 		View::ChildList* result, const View* view, const Selector& selector,
 		bool recursive)
 	{
-		View::ChildList* children = view->self->children();
+		auto* children = view->self->children();
 		if (!children) return;
 
 		for (auto& child : *children)
@@ -869,7 +1075,7 @@ namespace Reflex
 		{
 			for (auto& style : *pstyles)
 			{
-				if (selector.contains(style.selector()))
+				if (style.selector().contains(selector))
 					result->push_back(style);
 			}
 		}
@@ -933,14 +1139,14 @@ namespace Reflex
 	}
 
 	static void
-	update_child_world (View* view, float dt)
+	update_child_world (View* view)
 	{
 		View::Data* self = view->self.get();
 
 		World* child_world = self->pchild_world.get();
 		if (!child_world) return;
 
-		child_world->on_update(dt);
+		child_world->on_update();
 
 		View::ChildList* children = self->children();
 		if (children)
@@ -1019,11 +1225,9 @@ namespace Reflex
 				Style_override(pstyle, st);
 		}
 
-		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);
+		self->update_flag(
+			View::Data::HAS_VARIABLE_LENGTHS,
+			Style_has_variable_lengths(View_get_style(view)));
 
 		self->add_flag(View::Data::APPLY_STYLE);
 	}
@@ -1052,20 +1256,6 @@ namespace Reflex
 		}
 	}
 
-	static void
-	remove_children (View* view, View::ChildList* children)
-	{
-		assert(children);
-
-		int size = (int) children->size();
-		for (int i = size - 1; i >= 0; --i)
-		{
-			View* child = (*children)[i].get();
-			if (child->self->check_and_remove_flag(View::Data::REMOVE_FROM_PARENT))
-				view->remove_child(child);
-		}
-	}
-
 	void
 	View_update_tree (View* view, const UpdateEvent& event)
 	{
@@ -1074,20 +1264,24 @@ namespace Reflex
 
 		View::Data* self = view->self.get();
 
-		self->add_flag(View::Data::UPDATING);
+		self->update_children_for_loop(view);
 
 		fire_timers(view, event.now());
 
-		View::ChildList* children = self->children();
+		View::ChildList* children = self->children_for_loop();
 		if (children)
 		{
-			size_t size = children->size();
-			for (size_t i = 0; i < size; ++i)
-				View_update_tree((*children)[i].get(), event);
+			LoopDepthGuard depth_guard(self);
+
+			for (View::Ref child : *children)
+			{
+				if (!child) continue;// removed since the last frame
+				View_update_tree(child.get(), event);
+			}
 		}
 
 		update_view_shapes(view);
-		update_child_world(view, event.dt());
+		update_child_world(view);
 
 		UpdateEvent e = event.dup();
 		view->on_update(&e);
@@ -1106,42 +1300,36 @@ namespace Reflex
 		if (self->check_and_remove_flag(View::Data::FIT_TO_CONTENT))
 			fit_view_to_content(view);
 
-		self->remove_flag(View::Data::UPDATING);
-
-		if (self->check_and_remove_flag(View::Data::HAS_CHILDREN_TO_REMOVE))
-			remove_children(view, children);
 	}
 
 	static bool
-	use_cache (View* view)
+	use_draw_cache (const View::Data& self)
 	{
-		View::Data* self = view->self.get();
-
-		return
-			self->has_flag(View::FLAG_CACHE) ||
-			(self->pfilter && *self->pfilter);
+		return self.has_flag(View::FLAG_DRAW_CACHE) || (self.pfilter && *self.pfilter);
 	}
 
 	static bool
-	reset_cache_image (View* view, const Painter& painter)
+	setup_draw_cache (View::Data* self, float density)
 	{
-		assert(use_cache(view));
-		View::Data* self = view->self.get();
+		int w = (int) ceil(self->frame.width);
+		int h = (int) ceil(self->frame.height);
+		if (w == 0 || h == 0 || !use_draw_cache(*self))
+		{
+			self->pdraw_cache.reset();
+			return false;
+		}
 
-		Image* image = self->pcache_image.get();
-		int w        = ceil(self->frame.width);
-		int h        = ceil(self->frame.height);
+		Image* image = self->pdraw_cache.get();
 		if (
 			image &&
 			image->width()         == w &&
 			image->height()        == h &&
-			image->pixel_density() == painter.pixel_density())
+			image->pixel_density() == density)
 		{
 			return false;
 		}
 
-		self->pcache_image.reset(
-			new Image(w, h, Rays::RGBA, painter.pixel_density()));
+		self->pdraw_cache.reset(new Image(w, h, Rays::RGBA, density));
 		return true;
 	}
 
@@ -1194,7 +1382,7 @@ namespace Reflex
 
 	static void
 	draw_view (
-		View* view, DrawEvent* event, const Point& offset, const Bounds& clip)
+		View* view, DrawEvent* event, const Point& offset, const Bounds& clip, float scale)
 	{
 		View::Data* self = view->self.get();
 
@@ -1212,13 +1400,17 @@ namespace Reflex
 
 		if (event->is_blocked()) return;
 
-		View::ChildList* children = self->children(false, true);
+		View::ChildList* children = self->children_for_loop();
 		if (children)
 		{
-			for (auto& child : *children)
+			LoopDepthGuard depth_guard(self);
+
+			for (View::Ref child : *children)
 			{
+				if (!child) continue;
+
 				if (event->bounds() & child->self->frame)
-					View_draw_tree(child.get(), event, offset, clip);
+					View_draw_tree(child.get(), event, offset, clip, scale);
 			}
 		}
 
@@ -1235,12 +1427,12 @@ namespace Reflex
 	draw_view_to_cache (View* view, DrawEvent* event)
 	{
 		Painter* view_painter = event->painter();
-		Painter cache_painter = view->self->pcache_image->painter();
+		Painter cache_painter = view->self->pdraw_cache->painter();
 
 		DrawEvent_set_painter(event, &cache_painter);
 
 		cache_painter.begin();
-		draw_view(view, event, 0, event->bounds());
+		draw_view(view, event, 0, event->bounds(), 1);
 		cache_painter.end();
 
 		DrawEvent_set_painter(event, view_painter);
@@ -1251,40 +1443,32 @@ namespace Reflex
 	{
 		View::Data* self = view->self.get();
 
-		if (!use_cache(view))
-		{
-			self->pcache_image.reset();
-			return false;
-		}
-
 		Painter* painter = event->painter();
+		bool created     = setup_draw_cache(self, painter->pixel_density());
+		if (!self->pdraw_cache)
+			return false;
 
-		if (reset_cache_image(view, *painter) || redraw)
-		{
-			if (!self->pcache_image)
-				return false;
-
+		if (created || redraw)
 			draw_view_to_cache(view, event);
-		}
 
 		painter->push_state();
-		painter->set_fill(1);
-		painter->no_stroke();
-		painter->no_shader();
-
-		if (self->pfilter && *self->pfilter)
-			self->pfilter->apply(painter, *self->pcache_image);
-		else
-			painter->image(*self->pcache_image, event->bounds());
+		{
+			painter->set_fill(1);
+			painter->no_stroke();
+			painter->no_shader();
 
+			if (self->pfilter && *self->pfilter)
+				self->pfilter->apply(painter, *self->pdraw_cache);
+			else
+				painter->image(*self->pdraw_cache, event->bounds());
+		}
 		painter->pop_state();
-
 		return true;
 	}
 
 	void
 	View_draw_tree (
-		View* view, DrawEvent* event, const Point& offset, const Bounds& clip)
+		View* view, DrawEvent* event, const Point& offset, Bounds clip, float scale)
 	{
 		if (!view)
 			argument_error(__FILE__, __LINE__);
@@ -1300,9 +1484,17 @@ namespace Reflex
 			return;
 
 		Bounds bounds = self->frame;
-		Point pos     = bounds.position();
-		Bounds clip2  = bounds.dup().move_by(offset) & clip;
+		if (clip)
+		{
+			// clipping is applied via glScissor which ignores the painter matrix,
+			// so track the frame in screen space: ancestor zooms are accumulated
+			// in 'scale' and ancestor positions in 'offset'
+			clip &= Bounds(
+				bounds.x * scale + offset.x, bounds.y * scale + offset.y,
+				bounds.w * scale,            bounds.h * scale);
+		}
 
+		Point pos = bounds.position();
 		bounds.set_position(0, 0, bounds.z);
 		if (self->pscroll)
 		{
@@ -1320,6 +1512,10 @@ namespace Reflex
 			if (pivot) p->translate( pivot->x * bounds.w,  pivot->y * bounds.h);
 			p->rotate(self->angle);
 			if (pivot) p->translate(-pivot->x * bounds.w, -pivot->y * bounds.h);
+
+			// a rotated frame can not be represented as a screen-space
+			// scissor rect, so give up clipping from here on down
+			clip.reset(-1);
 		}
 
 		float zoom = self->zoom;
@@ -1332,8 +1528,9 @@ namespace Reflex
 
 		if (!draw_view_with_cache(view, &e, redraw))
 		{
-			pos += offset;
-			draw_view(view, &e, pos, clip2);
+			draw_view(
+				view, &e, Point(pos.x * scale + offset.x, pos.y * scale + offset.y),
+				clip, zoom > 0 ? scale * zoom : scale);
 		}
 
 		p->pop_matrix();
@@ -1362,6 +1559,26 @@ namespace Reflex
 		view->self->add_flag(View::Data::UPDATE_SHAPES);
 	}
 
+	void
+	View_get_hovered_views (ViewList* result, View* view, const Point& position)
+	{
+		if (!result)
+			argument_error(__FILE__, __LINE__);
+		if (!view)
+			argument_error(__FILE__, __LINE__);
+
+		if (view->hidden() || !view->frame().is_include(position))
+			return;
+
+		result->emplace_back(view);
+
+		Point pos = view->from_parent(position);
+		call_children(view, [&](View* child) {
+			View_get_hovered_views(result, child, pos);
+			return true;
+		});
+	}
+
 	void
 	View_call_key_event (View* view, KeyEvent* event)
 	{
@@ -1384,16 +1601,23 @@ namespace Reflex
 		}
 	}
 
-	static void
-	call_children (View* parent, std::function<bool(View*)> fun, bool sort = true)
+	void
+	View_call_text_event (View* view, TextEvent* event)
 	{
-		auto* children = parent->self->children(false, sort);
-		if (!children) return;
+		if (!view)
+			argument_error(__FILE__, __LINE__);
+		if (!event)
+			argument_error(__FILE__, __LINE__);
 
-		for (auto it = children->rbegin(), end = children->rend(); it != end; ++it)
+		TextEvent e = event->dup();
+		view->on_text(&e);
+		if (e.is_blocked()) return;
+
+		switch (e.action())
 		{
-			if (!fun(it->get()))
-				break;
+			case TextEvent::PREEDIT: view->on_text_preedit(&e); break;
+			case TextEvent::COMMIT:  view->on_text_commit(&e);  break;
+			default: break;
 		}
 	}
 
@@ -1414,8 +1638,17 @@ namespace Reflex
 		if (view->self->pbody)
 			view->self->pbody->awake();
 
+		Window* win            = view->window();
+		uint cancels           = Window_get_pointer_cancels(*win);
+		auto block_if_canceled = [&]()
+		{
+			if (Window_get_pointer_cancels(*win) != cancels)
+				event->block();
+			return event->is_blocked();
+		};
+
 		view->on_pointer(event);
-		if (event->is_blocked()) return;
+		if (block_if_canceled()) return;
 
 		switch ((*event)[0].action())
 		{
@@ -1423,8 +1656,12 @@ namespace Reflex
 			case Pointer::UP:     view->on_pointer_up(event);     break;
 			case Pointer::MOVE:   view->on_pointer_move(event);   break;
 			case Pointer::CANCEL: view->on_pointer_cancel(event); break;
+			case Pointer::ENTER:  view->on_pointer_enter(event);  break;
+			case Pointer::LEAVE:  view->on_pointer_leave(event);  break;
 			default: break;
 		}
+
+		block_if_canceled();
 	}
 
 	static void
@@ -1460,7 +1697,7 @@ namespace Reflex
 		if (!event)
 			argument_error(__FILE__, __LINE__);
 
-		if (view->hidden() || event->empty())
+		if (event->empty() || view->hidden())
 			return;
 
 		Window* win = view->window();
@@ -1469,6 +1706,10 @@ namespace Reflex
 
 		PointerEvent e = event->dup();
 
+		auto action = e[0].action();
+		if (action == Pointer::ENTER || action == Pointer::LEAVE)
+			return call_pointer_events(view, &e);
+
 		if (!e.is_captured())
 			call_pointer_events_for_each_child(view, &e);
 
@@ -1509,6 +1750,25 @@ namespace Reflex
 		view->on_wheel(&e);
 	}
 
+	void
+	View_call_contact_event (View* view, ContactEvent* event)
+	{
+		if (!view)
+			argument_error(__FILE__, __LINE__);
+		if (!event)
+			argument_error(__FILE__, __LINE__);
+
+		ContactEvent e = event->dup();
+		view->on_contact(&e);
+
+		switch (e.action())
+		{
+			case ContactEvent::BEGIN: view->on_contact_begin(&e); break;
+			case ContactEvent::END:   view->on_contact_end(&e);   break;
+			default: break;
+		}
+	}
+
 	void
 	View_call_midi_event (View* view, MIDIEvent* event)
 	{
@@ -1559,25 +1819,6 @@ namespace Reflex
 		view->on_control_change(&e);
 	}
 
-	void
-	View_call_contact_event (View* view, ContactEvent* event)
-	{
-		if (!view)
-			argument_error(__FILE__, __LINE__);
-		if (!event)
-			argument_error(__FILE__, __LINE__);
-
-		ContactEvent e = event->dup();
-		view->on_contact(&e);
-
-		switch (e.action())
-		{
-			case ContactEvent::BEGIN: view->on_contact_begin(&e); break;
-			case ContactEvent::END:   view->on_contact_end(&e);   break;
-			default: break;
-		}
-	}
-
 
 	View::View (const char* name)
 	{
@@ -1586,6 +1827,8 @@ namespace Reflex
 
 	View::~View ()
 	{
+		self->sever_constraints();
+
 		clear_children();// to delete child shapes before world.
 	}
 
@@ -1636,13 +1879,14 @@ namespace Reflex
 	void
 	View::redraw ()
 	{
-		if (self->has_flag(Data::REDRAW))
+		View* parent = self->parent;
+		if (self->has_flag(Data::REDRAW) && (!parent || parent->self->has_flag(Data::REDRAW)))
 			return;
 
 		self->add_flag(Data::REDRAW);
 
-		if (self->parent)
-			self->parent->redraw();
+		if (parent)
+			parent->redraw();
 		else if (self->window)
 			self->window->redraw();
 	}
@@ -1691,6 +1935,39 @@ namespace Reflex
 		redraw();
 	}
 
+	void
+	View::fit_to_content ()
+	{
+		self->add_flag(View::Data::FIT_TO_CONTENT);
+	}
+
+	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;
+	}
+
+	bool
+	View::accepts_text_input () const
+	{
+		return !hidden() && self->has_flag(FLAG_TEXT_INPUT);
+	}
+
+	Bounds
+	View::text_input_bounds () const
+	{
+		return frame().dup().move_to(0, 0);
+	}
+
 	static void
 	get_from_parent_matrix (Matrix* m, const View* view)
 	{
@@ -1823,21 +2100,30 @@ namespace Reflex
 		assert(it != end);
 
 		children->erase(it);
-		if (children->empty())
+
+		View::ChildList* children_for_loop = parent->self->pchildren_for_loop.get();
+		if (children_for_loop)
 		{
-			parent->self->pchildren.reset();
-			parent->self->pchildren_sorted.reset();
+			auto loop_end = children_for_loop->end();
+			auto loop_it  = std::find(children_for_loop->begin(), loop_end, child);
+			if (loop_it != loop_end) loop_it->reset();
 		}
+
+		if (children->empty())
+			parent->self->pchildren.reset();
 	}
 
 	void
-	View::add_child (View* child)
+	View::add_child (View* child, int index)
 	{
 		if (!child)
 			argument_error(__FILE__, __LINE__);
 		if (child == this)
 			argument_error(__FILE__, __LINE__);
 
+		if (World_is_stepping(self->pchild_world.get()))
+			physics_error(__FILE__, __LINE__, "world is stepping now");
+
 		bool found  = std::find(child_begin(), child_end(), child) != child_end();
 		bool belong = child->parent() == this;
 		if (found && belong)
@@ -1845,14 +2131,16 @@ namespace Reflex
 		else if (found != belong)
 			invalid_state_error(__FILE__, __LINE__);
 
-		self->children(true)->push_back(child);
+		auto* children = self->children(true);
+		if (index < 0 || (int) children->size() < index)
+			children->push_back(child);
+		else
+			children->insert(children->begin() + (size_t) index, child);
 
 		View* prev_parent = child->parent();
 		set_parent(child, this);
-
 		if (prev_parent)
 			erase_child_from_children(prev_parent, child);
-
 		self->sort_children();
 
 		update_view_layout(this);
@@ -1866,6 +2154,9 @@ namespace Reflex
 		if (child == this)
 			argument_error(__FILE__, __LINE__);
 
+		if (World_is_stepping(self->pchild_world.get()))
+			physics_error(__FILE__, __LINE__, "world is stepping now");
+
 		bool found  = std::find(child_begin(), child_end(), child) != child_end();
 		bool belong = child->parent() == this;
 		if (!found && !belong)
@@ -1873,19 +2164,11 @@ namespace Reflex
 		else if (found != belong)
 			invalid_state_error(__FILE__, __LINE__);
 
-		if (self->has_flag(Data::UPDATING))
-		{
-			// delay removing child to avoid breaking child list looped on View_update_tree()
-			self->add_flag(Data::HAS_CHILDREN_TO_REMOVE);
-			child->self->add_flag(Data::REMOVE_FROM_PARENT);
-		}
-		else
-		{
-			set_parent(child, NULL);
-			erase_child_from_children(this, child);
-			self->sort_children();
-			update_view_layout(this);
-		}
+		set_parent(child, NULL);
+		erase_child_from_children(this, child);
+		self->sort_children();
+
+		update_view_layout(this);
 	}
 
 	void
@@ -2060,10 +2343,7 @@ namespace Reflex
 	void
 	View::set_shape (Shape* shape)
 	{
-		if (!shape)
-			self->add_flag(Data::NO_SHAPE);
-		else
-			self->remove_flag(Data::NO_SHAPE);
+		self->update_flag(Data::NO_SHAPE, !shape);
 
 		Shape::Ref& pshape = self->pshape;
 		if (shape == pshape.get()) return;
@@ -2089,12 +2369,17 @@ namespace Reflex
 	}
 
 	void
-	View::add_shape (Shape* shape)
+	View::add_shape (Shape* shape, int index)
 	{
 		if (!shape) return;
 
 		Shape_set_owner(shape, this);
-		self->shapes().push_back(shape);
+
+		auto& shapes = self->shapes();
+		if (index < 0 || (int) shapes.size() < index)
+			shapes.push_back(shape);
+		else
+			shapes.insert(shapes.begin() + (size_t) index, shape);
 	}
 
 	void
@@ -2131,7 +2416,7 @@ namespace Reflex
 		{
 			for (auto& shape : *pshapes)
 			{
-				if (selector.contains(shape->selector()))
+				if (shape->selector().contains(selector))
 					result.push_back(shape);
 			}
 		}
@@ -2168,6 +2453,58 @@ namespace Reflex
 		return self->pshapes->end();
 	}
 
+	void
+	View::clear_constraints ()
+	{
+		self->sever_constraints();
+	}
+
+	View::ConstraintList
+	View::find_constraints (const Selector& selector) const
+	{
+		ConstraintList result;
+		ConstraintList* pconstraints = self->pconstraints.get();
+		if (pconstraints)
+		{
+			for (auto& constraint : *pconstraints)
+			{
+				if (constraint->selector().contains(selector))
+					result.push_back(constraint);
+			}
+		}
+		return result;
+	}
+
+	static View::ConstraintList empty_constraints;
+
+	View::constraint_iterator
+	View::constraint_begin ()
+	{
+		if (!self->pconstraints) return empty_constraints.begin();
+		return self->pconstraints->begin();
+	}
+
+	View::const_constraint_iterator
+	View::constraint_begin () const
+	{
+		if (!self->pconstraints) return empty_constraints.begin();
+		return self->pconstraints->begin();
+	}
+
+	View::constraint_iterator
+	View::constraint_end ()
+	{
+		if (!self->pconstraints) return empty_constraints.end();
+		return self->pconstraints->end();
+	}
+
+	View::const_constraint_iterator
+	View::constraint_end () const
+	{
+		if (!self->pconstraints) return empty_constraints.end();
+		return self->pconstraints->end();
+	}
+
 	void
 	View::set_filter (Filter* filter)
 	{
@@ -2259,27 +2596,6 @@ namespace Reflex
 		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_zoom (float zoom)
 	{
@@ -2626,10 +2942,9 @@ namespace Reflex
 	}
 
 	void
-	View::update_world (float duration)
+	View::update_world ()
 	{
-		World* w = self->pchild_world.get();
-		if (w) w->update(duration);
+		update_child_world(this);
 	}
 
 	float
@@ -2736,6 +3051,16 @@ namespace Reflex
 	{
 	}
 
+	void
+	View::on_activate (Event* e)
+	{
+	}
+
+	void
+	View::on_deactivate (Event* e)
+	{
+	}
+
 	void
 	View::on_show (Event* e)
 	{
@@ -2802,59 +3127,59 @@ namespace Reflex
 	}
 
 	void
-	View::on_pointer (PointerEvent* e)
+	View::on_text (TextEvent* e)
 	{
 	}
 
 	void
-	View::on_pointer_down (PointerEvent* e)
+	View::on_text_preedit (TextEvent* e)
 	{
 	}
 
 	void
-	View::on_pointer_up (PointerEvent* e)
+	View::on_text_commit (TextEvent* e)
 	{
 	}
 
 	void
-	View::on_pointer_move (PointerEvent* e)
+	View::on_pointer (PointerEvent* e)
 	{
 	}
 
 	void
-	View::on_pointer_cancel (PointerEvent* e)
+	View::on_pointer_down (PointerEvent* e)
 	{
 	}
 
 	void
-	View::on_wheel (WheelEvent* e)
+	View::on_pointer_up (PointerEvent* e)
 	{
-		//scroll_by(e->dx, e->dy, e->dz);
 	}
 
 	void
-	View::on_midi (MIDIEvent* e)
+	View::on_pointer_move (PointerEvent* e)
 	{
 	}
 
 	void
-	View::on_note (NoteEvent* e)
+	View::on_pointer_cancel (PointerEvent* e)
 	{
 	}
 
 	void
-	View::on_note_on (NoteEvent* e)
+	View::on_pointer_enter (PointerEvent* e)
 	{
 	}
 
 	void
-	View::on_note_off (NoteEvent* e)
+	View::on_pointer_leave (PointerEvent* e)
 	{
 	}
 
 	void
-	View::on_control_change (ControlChangeEvent* e)
+	View::on_wheel (WheelEvent* e)
 	{
+		//scroll_by(e->dx, e->dy, e->dz);
 	}
 
 	void
@@ -2888,6 +3213,31 @@ namespace Reflex
 	{
 	}
 
+	void
+	View::on_midi (MIDIEvent* e)
+	{
+	}
+
+	void
+	View::on_note (NoteEvent* e)
+	{
+	}
+
+	void
+	View::on_note_on (NoteEvent* e)
+	{
+	}
+
+	void
+	View::on_note_off (NoteEvent* e)
+	{
+	}
+
+	void
+	View::on_control_change (ControlChangeEvent* e)
+	{
+	}
+
 	View::operator bool () const
 	{
 		return true;