reflexion 0.6.0 → 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>
@@ -40,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
 
@@ -82,6 +77,8 @@ namespace Reflex
 
 		ushort child_index = 0;
 
+		int loop_depth     = 0;
+
 		uint flags         =
 			FLAG_CLIP | FLAG_RESIZE_TO_FIT | REDRAW | UPDATE_LAYOUT | UPDATE_STYLE;
 
@@ -93,7 +90,7 @@ namespace Reflex
 
 		std::unique_ptr<SelectorSet>    pselectors_for_update;
 
-		std::unique_ptr<Image>          pcache_image;
+		std::unique_ptr<Image>          pdraw_cache;
 
 		std::unique_ptr<Timers>         ptimers;
 
@@ -115,7 +112,7 @@ namespace Reflex
 
 		std::unique_ptr<ChildList>      pchildren;
 
-		std::unique_ptr<ChildList>      pchildren_sorted;
+		std::unique_ptr<ChildList>      pchildren_for_loop;
 
 		Point& pivot ()
 		{
@@ -364,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)
@@ -394,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);
@@ -408,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)
@@ -422,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();
@@ -739,15 +749,58 @@ namespace Reflex
 	};// LayoutContext
 
 
+	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, bool sort = true)
+	call_children (View* parent, std::function<bool(View*)> fun)
 	{
-		auto* children = parent->self->children(false, sort);
+		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)
 		{
-			if (!fun(it->get()))
+			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;
 		}
 	}
@@ -865,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);
@@ -967,10 +1020,10 @@ namespace Reflex
 		view->on_activate(&e);
 		if (e.is_blocked()) return;
 
-		call_children(view, [&](View* child) {
+		call_children_unsafe(view, [&](View* child) {
 			View_activate_tree(child, &e);
 			return !e.is_blocked();
-		}, false);
+		});
 	}
 
 	void
@@ -981,10 +1034,10 @@ namespace Reflex
 
 		Event e = event->dup();
 
-		call_children(view, [&](View* child) {
+		call_children_unsafe(view, [&](View* child) {
 			View_deactivate_tree(child, &e);
 			return !e.is_blocked();
-		}, false);
+		});
 
 		if (e.is_blocked()) return;
 
@@ -1172,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);
 	}
@@ -1205,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)
 	{
@@ -1227,16 +1264,20 @@ 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);
@@ -1259,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;
 	}
 
@@ -1365,11 +1400,15 @@ 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, scale);
 			}
@@ -1388,7 +1427,7 @@ 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);
 
@@ -1404,34 +1443,26 @@ 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;
 	}
 
@@ -1570,6 +1601,26 @@ namespace Reflex
 		}
 	}
 
+	void
+	View_call_text_event (View* view, TextEvent* event)
+	{
+		if (!view)
+			argument_error(__FILE__, __LINE__);
+		if (!event)
+			argument_error(__FILE__, __LINE__);
+
+		TextEvent e = event->dup();
+		view->on_text(&e);
+		if (e.is_blocked()) return;
+
+		switch (e.action())
+		{
+			case TextEvent::PREEDIT: view->on_text_preedit(&e); break;
+			case TextEvent::COMMIT:  view->on_text_commit(&e);  break;
+			default: break;
+		}
+	}
+
 	static void
 	call_pointer_events_for_each_child (View* parent, PointerEvent* event)
 	{
@@ -1587,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())
 		{
@@ -1600,6 +1660,8 @@ namespace Reflex
 			case Pointer::LEAVE:  view->on_pointer_leave(event);  break;
 			default: break;
 		}
+
+		block_if_canceled();
 	}
 
 	static void
@@ -1635,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();
@@ -1688,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)
 	{
@@ -1738,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)
 	{
@@ -1817,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();
 	}
@@ -1872,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)
 	{
@@ -2004,11 +2100,17 @@ 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
@@ -2019,6 +2121,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)
@@ -2034,10 +2139,8 @@ namespace Reflex
 
 		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);
@@ -2051,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)
@@ -2058,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
@@ -2245,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;
@@ -2501,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)
 	{
@@ -3052,6 +3126,21 @@ namespace Reflex
 	{
 	}
 
+	void
+	View::on_text (TextEvent* e)
+	{
+	}
+
+	void
+	View::on_text_preedit (TextEvent* e)
+	{
+	}
+
+	void
+	View::on_text_commit (TextEvent* e)
+	{
+	}
+
 	void
 	View::on_pointer (PointerEvent* e)
 	{
@@ -3094,58 +3183,58 @@ namespace Reflex
 	}
 
 	void
-	View::on_midi (MIDIEvent* e)
+	View::on_capture (CaptureEvent* e)
 	{
 	}
 
 	void
-	View::on_note (NoteEvent* e)
+	View::on_timer (TimerEvent* e)
 	{
 	}
 
-	void
-	View::on_note_on (NoteEvent* e)
+	bool
+	View::will_contact (View* v)
 	{
+		return true;
 	}
 
 	void
-	View::on_note_off (NoteEvent* e)
+	View::on_contact (ContactEvent* e)
 	{
 	}
 
 	void
-	View::on_control_change (ControlChangeEvent* e)
+	View::on_contact_begin (ContactEvent* e)
 	{
 	}
 
 	void
-	View::on_capture (CaptureEvent* e)
+	View::on_contact_end (ContactEvent* e)
 	{
 	}
 
 	void
-	View::on_timer (TimerEvent* e)
+	View::on_midi (MIDIEvent* e)
 	{
 	}
 
-	bool
-	View::will_contact (View* v)
+	void
+	View::on_note (NoteEvent* e)
 	{
-		return true;
 	}
 
 	void
-	View::on_contact (ContactEvent* e)
+	View::on_note_on (NoteEvent* e)
 	{
 	}
 
 	void
-	View::on_contact_begin (ContactEvent* e)
+	View::on_note_off (NoteEvent* e)
 	{
 	}
 
 	void
-	View::on_contact_end (ContactEvent* e)
+	View::on_control_change (ControlChangeEvent* e)
 	{
 	}