reflexion 0.1.20 → 0.1.24

data/src/view.cpp

@@ -9,6 +9,7 @@
 #include "reflex/exception.h"
 #include "reflex/debug.h"
 #include "window.h"
+#include "event.h"
 #include "selector.h"
 #include "timer.h"
 #include "style.h"
@@ -877,7 +878,7 @@ namespace Reflex
 		result->clear();
 
 		Selector* sel = view->self->pselector.get();
-		if (!sel || sel->is_empty())
+		if (!sel || sel->empty())
 			return false;
 
 		get_styles_for_selector(result, view, *sel);
@@ -947,7 +948,7 @@ namespace Reflex
 
 		View::Data* self = view->self.get();
 
-		fire_timers(view, event.now);
+		fire_timers(view, event.now());
 
 		View::ChildList* pchildren = self->pchildren.get();
 		if (pchildren)
@@ -957,9 +958,9 @@ namespace Reflex
 		}
 
 		update_view_shapes(view);
-		update_child_world(view, event.dt);
+		update_child_world(view, event.dt());
 
-		UpdateEvent e = event;
+		UpdateEvent e = event.dup();
 		view->on_update(&e);
 
 		update_views_for_selectors(view);
@@ -1023,7 +1024,10 @@ namespace Reflex
 	static void
 	draw_default_shape (View* view, DrawEvent* event)
 	{
-		assert(view && event && event->painter);
+		assert(view && event);
+
+		Painter* painter = event->painter();
+		assert(painter);
 
 		const Style& style       = View_get_style(view);
 		const Color& back_fill   = style.background_fill();
@@ -1032,26 +1036,26 @@ namespace Reflex
 		Shape* shape = view->shape(false);
 		if (shape)
 		{
-			setup_painter(event->painter, back_fill, back_stroke);
+			setup_painter(painter, back_fill, back_stroke);
 			shape->on_draw(event);
 		}
 		else if (back_fill || back_stroke)
 		{
-			setup_painter(event->painter, back_fill, back_stroke);
-			event->painter->rect(event->bounds);
+			setup_painter(painter, back_fill, back_stroke);
+			painter->rect(event->bounds());
 		}
 	}
 
 	static void
 	draw_content (View* view, DrawEvent* event)
 	{
-		assert(view && event && event->painter);
+		assert(view && event && event->painter());
 
 		draw_default_shape(view, event);
 
 		const Style& style = View_get_style(view);
 		setup_painter(
-			event->painter, style.foreground_fill(), style.foreground_stroke());
+			event->painter(), style.foreground_fill(), style.foreground_stroke());
 
 		View::ShapeList* pshapes = view->self->pshapes.get();
 		if (pshapes && !pshapes->empty())
@@ -1067,10 +1071,10 @@ namespace Reflex
 	draw_view (
 		View* view, DrawEvent* event, const Point& offset, const Bounds& clip)
 	{
-		assert(view && event && event->painter);
+		assert(view && event && event->painter());
 		View::Data* self = view->self.get();
 
-		Painter* p = event->painter;
+		Painter* p = event->painter();
 		p->push_state();
 
 		if (self->has_flag(View::FLAG_CLIP) && !self->pbody)
@@ -1087,8 +1091,8 @@ namespace Reflex
 		{
 			for (auto& pchild : *pchildren)
 			{
-				if (event->bounds & pchild->self->frame)
-					View_draw_tree(pchild.get(), *event, offset, clip);
+				if (event->bounds() & pchild->self->frame)
+					View_draw_tree(pchild.get(), event, offset, clip);
 			}
 		}
 
@@ -1104,23 +1108,24 @@ namespace Reflex
 	static void
 	draw_view_to_cache (View* view, DrawEvent* event)
 	{
-		assert(view && event && event->painter && view->self->pcache_image);
+		assert(view && event && event->painter() && view->self->pcache_image);
 
-		Painter* view_painter = event->painter;
+		Painter* view_painter = event->painter();
 		Painter cache_painter = view->self->pcache_image->painter();
-		event->painter = &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());
 		cache_painter.end();
 
-		event->painter = view_painter;
+		DrawEvent_set_painter(event, view_painter);
 	}
 
 	static bool
 	draw_view_with_cache (View* view, DrawEvent* event, bool redraw)
 	{
-		assert(view && event && event->painter);
+		assert(view && event && event->painter());
 		View::Data* self = view->self.get();
 
 		if (!use_cache(view))
@@ -1129,7 +1134,7 @@ namespace Reflex
 			return false;
 		}
 
-		Painter* painter = event->painter;
+		Painter* painter = event->painter();
 
 		if (reset_cache_image(view, *painter) || redraw)
 		{
@@ -1147,7 +1152,7 @@ namespace Reflex
 		if (self->pfilter && *self->pfilter)
 			self->pfilter->apply(painter, *self->pcache_image);
 		else
-			painter->image(*self->pcache_image, event->bounds);
+			painter->image(*self->pcache_image, event->bounds());
 
 		painter->pop_state();
 
@@ -1156,7 +1161,7 @@ namespace Reflex
 
 	void
 	View_draw_tree (
-		View* view, const DrawEvent& event, const Point& offset, const Bounds& clip)
+		View* view, DrawEvent* event, const Point& offset, const Bounds& clip)
 	{
 		if (!view)
 			argument_error(__FILE__, __LINE__);
@@ -1165,26 +1170,24 @@ namespace Reflex
 
 		bool redraw = self->check_and_remove_flag(View::Data::REDRAW);
 
-		if (event.is_blocked() || view->hidden())
+		if (view->hidden() || event->is_blocked())
 			return;
 
 		if (self->frame.width <= 0 || self->frame.height <= 0)
 			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);
+		Bounds bounds = self->frame;
+		Point pos     = bounds.position();
+		Bounds clip2  = bounds.dup().move_by(offset) & clip;
 
+		bounds.move_to(0, 0, bounds.z);
 		if (self->pscroll)
 		{
-			pos     .move_by( *self->pscroll);
-			e.bounds.move_by(-*self->pscroll);
+			bounds.move_by(-*self->pscroll);
+			pos   .move_by( *self->pscroll);
 		}
 
-		Painter* p = event.painter;
+		Painter* p = event->painter();
 		p->push_matrix();
 		p->translate(pos);
 
@@ -1196,9 +1199,15 @@ namespace Reflex
 		if (zoom != 1 && zoom > 0)
 			p->scale(zoom, zoom);
 
-		pos += offset;
+		DrawEvent e = event->dup();
+		DrawEvent_set_view(&e, view);
+		DrawEvent_set_bounds(&e, bounds);
+
 		if (!draw_view_with_cache(view, &e, redraw))
+		{
+			pos += offset;
 			draw_view(view, &e, pos, clip2);
+		}
 
 		p->pop_matrix();
 	}
@@ -1211,7 +1220,7 @@ namespace Reflex
 
 		View::Data* self = view->self.get();
 
-		if (selector.is_empty())
+		if (selector.empty())
 			self->add_flag(View::Data::UPDATE_STYLE);
 		else
 			self->selectors_for_update().insert(selector);
@@ -1226,123 +1235,167 @@ namespace Reflex
 		view->self->add_flag(View::Data::UPDATE_SHAPES);
 	}
 
-	template <typename FUN, typename EVENT>
+	void
+	View_call_key_event (View* view, KeyEvent* event)
+	{
+		if (!view || !event)
+			argument_error(__FILE__, __LINE__);
+
+		if (view->hidden()) return;
+
+		KeyEvent e = event->dup();
+		view->on_key(&e);
+
+		switch (e.action())
+		{
+			case KeyEvent::DOWN: view->on_key_down(&e); break;
+			case KeyEvent::UP:   view->on_key_up(&e);   break;
+			default: break;
+		}
+	}
+
 	static void
-	call_children (View* parent, FUN fun, const EVENT& e)
+	call_children (View* parent, std::function<bool(View*)> fun)
 	{
 		assert(parent);
 
-		View::ChildList* pchildren = parent->self->pchildren.get();
-		if (pchildren)
+		auto* pchildren = parent->self->pchildren.get();
+		if (!pchildren) return;
+
+		auto end = pchildren->rend();
+		for (auto it = pchildren->rbegin(); it != end; ++it)
 		{
-			for (auto& pchild : *pchildren)
-				fun(pchild.get(), e);
+			if (!fun(it->get()))
+				break;
 		}
 	}
 
-	void
-	View_call_key_event (View* view, const KeyEvent& event)
+	static void
+	call_pointer_events_for_each_child (View* parent, PointerEvent* event)
 	{
-		if (!view)
-			argument_error(__FILE__, __LINE__);
+		assert(parent && event);
+
+		call_children(parent, [&](View* child) {
+			PointerEvent e = event->dup();
+			PointerEvent_update_for_child_view(&e, child);
+			View_call_pointer_event(child, &e);
+			return !e.is_blocked();
+		});
+	}
 
-		bool capturing = view->capture() & View::CAPTURE_KEY;
-		if (capturing != event.capture) return;
+	static void
+	call_pointer_events (View* view, PointerEvent* event)
+	{
+		assert(view && event);
 
-		KeyEvent e = event;
-		view->on_key(&e);
+		view->on_pointer(event);
 
-		switch (e.type)
+		switch ((*event)[0].action())
 		{
-			case KeyEvent::DOWN: view->on_key_down(&e); break;
-			case KeyEvent::UP:   view->on_key_up(&e);   break;
-			case KeyEvent::NONE: break;
+			case Pointer::DOWN:   view->on_pointer_down(event);   break;
+			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;
+			default: break;
 		}
 	}
 
 	static void
-	filter_pointer_event (
-		PointerEvent* to, const PointerEvent& from, const Bounds& frame)
+	register_captures (View* view, const PointerEvent& event)
 	{
-		assert(to);
-
-		const Point& offset = frame.position();
+		assert(view);
 
-		to->size = 0;
-		for (size_t i = 0; i < from.size; ++i) {
-			const Point& pos = from.position(i);
-			if (!frame.is_include(pos))
-				continue;
+		Window* win = view->window();
+		if (!win)
+			invalid_state_error(__FILE__, __LINE__);
 
-			to->positions[i] = pos - offset;
-			++to->size;
-		}
+		PointerEvent_each_pointer(&event, [&](const auto& pointer)
+		{
+			if (pointer.action() == Pointer::DOWN)
+				Window_register_capture(win, view, pointer.id());
+		});
 	}
 
-	void
-	View_call_pointer_event (View* view, const PointerEvent& event)
+	static void
+	unregister_captures (View* view, const PointerEvent& event)
 	{
-		if (!view)
-			argument_error(__FILE__, __LINE__);
+		assert(view);
 
-		bool capturing = view->capture() & View::CAPTURE_POINTER;
-		if (capturing != event.capture) return;
+		Window* win = view->window();
+		if (!win)
+			invalid_state_error(__FILE__, __LINE__);
 
-		const Bounds& frame = view->frame();
+		PointerEvent_each_pointer(&event, [&](const auto& pointer)
+		{
+			auto action = pointer.action();
+			if (action == Pointer::UP || action == Pointer::CANCEL)
+				Window_unregister_capture(win, view, pointer.id());
+		});
+	}
 
-		PointerEvent e = event;
-		filter_pointer_event(&e, event, frame);
+	void
+	View_call_pointer_event (View* view, PointerEvent* event)
+	{
+		if (!view || !event)
+			argument_error(__FILE__, __LINE__);
 
-		if (!capturing && e.size == 0)
+		if (view->hidden() || event->empty())
 			return;
 
-		view->on_pointer(&e);
+		PointerEvent e = event->dup();
 
-		switch (e.type)
+		if (!e.is_captured())
+			call_pointer_events_for_each_child(view, &e);
+
+		if (!e.is_blocked())
 		{
-			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;
+			register_captures(view, e);
+			call_pointer_events(view, &e);
 		}
 
-		if (!event.capture)
-			call_children(view, View_call_pointer_event, e);
+		unregister_captures(view, e);
 	}
 
 	void
-	View_call_wheel_event (View* view, const WheelEvent& event)
+	View_call_wheel_event (View* view, WheelEvent* event)
 	{
-		if (!view)
+		if (!view || !event)
 			argument_error(__FILE__, __LINE__);
 
+		if (view->hidden()) return;
+
 		const Bounds& frame = view->frame();
 
-		if (!frame.is_include(event.x, event.y, event.z))
+		if (!frame.is_include(event->position()))
 			return;
 
-		WheelEvent e = event;
-		e.position() -= frame.position();
+		WheelEvent e = event->dup();
+		WheelEvent_set_position(&e, e.position() - frame.position());
 
-		view->on_wheel(&e);
+		call_children(view, [&](View* child) {
+			View_call_wheel_event(child, &e);
+			return !e.is_blocked();
+		});
+
+		if (e.is_blocked()) return;
 
-		call_children(view, View_call_wheel_event, e);
+		view->on_wheel(&e);
 	}
 
 	void
-	View_call_contact_event (View* view, const ContactEvent& event)
+	View_call_contact_event (View* view, ContactEvent* event)
 	{
-		if (!view)
+		if (!view || !event)
 			argument_error(__FILE__, __LINE__);
 
-		ContactEvent e = event;
+		ContactEvent e = event->dup();
 		view->on_contact(&e);
 
-		switch (e.type)
+		switch (e.action())
 		{
 			case ContactEvent::BEGIN: view->on_contact_begin(&e); break;
 			case ContactEvent::END:   view->on_contact_end(&e);   break;
-			case ContactEvent::NONE: break;
+			default: break;
 		}
 	}
 
@@ -1462,22 +1515,29 @@ namespace Reflex
 	Point
 	View::from_parent (const Point& point) const
 	{
-		not_implemented_error(__FILE__, __LINE__);
-		return 0;
+		if (!parent())
+			invalid_state_error(__FILE__, __LINE__);
+
+		return point - frame().position();
 	}
 
 	Point
 	View::to_parent (const Point& point) const
 	{
-		not_implemented_error(__FILE__, __LINE__);
-		return 0;
+		if (!parent())
+			invalid_state_error(__FILE__, __LINE__);
+
+		return point + frame().position();
 	}
 
 	Point
 	View::from_window (const Point& point) const
 	{
+		if (!window())
+			invalid_state_error(__FILE__, __LINE__);
+
 		Point p = point;
-		for (const View* v = parent(); v; v = v->parent())
+		for (const View* v = this; v; v = v->parent())
 			p -= v->frame().position();
 		return p;
 	}
@@ -1485,22 +1545,33 @@ namespace Reflex
 	Point
 	View::to_window (const Point& point) const
 	{
-		not_implemented_error(__FILE__, __LINE__);
-		return 0;
+		if (!window())
+			invalid_state_error(__FILE__, __LINE__);
+
+		Point p = point;
+		for (const View* v = this; v; v = v->parent())
+			p += v->frame().position();
+		return p;
 	}
 
 	Point
 	View::from_screen (const Point& point) const
 	{
-		not_implemented_error(__FILE__, __LINE__);
-		return 0;
+		const Window* w = window();
+		if (!w)
+			invalid_state_error(__FILE__, __LINE__);
+
+		return w->from_screen(from_window(point));
 	}
 
 	Point
 	View::to_screen (const Point& point) const
 	{
-		not_implemented_error(__FILE__, __LINE__);
-		return 0;
+		const Window* w = window();
+		if (!w)
+			invalid_state_error(__FILE__, __LINE__);
+
+		return w->to_screen(to_window(point));
 	}
 
 	static void
@@ -1682,7 +1753,7 @@ namespace Reflex
 	Style*
 	View::get_style (const Selector& selector, bool create)
 	{
-		if (selector.is_empty())
+		if (selector.empty())
 			return style(create);
 
 		StyleList* pstyles = self->pstyles.get();
@@ -1989,18 +2060,23 @@ namespace Reflex
 	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();
+		scroll_to(Point(x, y, z));
 	}
 
 	void
 	View::scroll_to (const Point& scroll)
 	{
-		scroll_to(scroll.x, scroll.y, scroll.z);
+		if (scroll == this->scroll()) return;
+
+		Point old = self->scroll();
+		self->scroll() = scroll;
+
+		ScrollEvent e(
+			scroll.x,         scroll.y,         scroll.z,
+			scroll.x - old.x, scroll.y - old.y, scroll.z - old.z);
+		on_scroll(&e);
+
+		redraw();
 	}
 
 	void
@@ -2028,6 +2104,11 @@ namespace Reflex
 	void
 	View::set_zoom (float zoom)
 	{
+		if (zoom == self->zoom) return;
+
+		if (zoom == 0)
+			argument_error(__FILE__, __LINE__);
+
 		self->zoom = zoom;
 		redraw();
 	}
@@ -2041,7 +2122,8 @@ namespace Reflex
 	void
 	View::set_capture (uint types)
 	{
-		if (types == self->capture) return;
+		Window* w = window();
+		if (!w || types == self->capture) return;
 
 		uint old      = self->capture;
 		self->capture = types;
@@ -2050,9 +2132,9 @@ namespace Reflex
 		bool capture    = types != CAPTURE_NONE;
 
 		if (capture && !registered)
-			View_register_capture(this);
+			Window_register_capture(w, this);
 		else if (!capture && registered)
-			View_unregister_capture(this);
+			Window_unregister_capture(w, this);
 
 		CaptureEvent e(~old & types, old & ~types);
 		on_capture(&e);
@@ -2508,6 +2590,11 @@ namespace Reflex
 	{
 	}
 
+	void
+	View::on_pointer_cancel (PointerEvent* e)
+	{
+	}
+
 	void
 	View::on_wheel (WheelEvent* e)
 	{

data/src/view.h

@@ -30,24 +30,19 @@ namespace Reflex
 	void View_update_tree (View* view, const UpdateEvent& event);
 
 	void View_draw_tree (
-		View* view, const DrawEvent& event,
-		const Point& offset, const Bounds& clip);
+		View* view, DrawEvent* event, const Point& offset, const Bounds& clip);
 
 	void View_update_styles (View* view, const Selector& selector);
 
 	void View_update_shapes (View* view);
 
-	void View_register_capture   (View* view);
+	void View_call_key_event     (View* view, KeyEvent* event);
 
-	void View_unregister_capture (View* view);
+	void View_call_pointer_event (View* view, PointerEvent* event);
 
-	void View_call_key_event     (View* view, const KeyEvent& event);
+	void View_call_wheel_event   (View* view, WheelEvent* event);
 
-	void View_call_pointer_event (View* view, const PointerEvent& event);
-
-	void View_call_wheel_event   (View* view, const WheelEvent& event);
-
-	void View_call_contact_event (View* view, const ContactEvent& event);
+	void View_call_contact_event (View* view, ContactEvent* event);
 
 
 }// Reflex