reflexion 0.1.23 → 0.1.24

data/src/event.h

@@ -12,6 +12,16 @@ namespace Reflex
 {
 
 
+	void DrawEvent_set_view    (DrawEvent* pthis, View* view);
+
+	void DrawEvent_set_painter (DrawEvent* pthis, Painter* painter);
+
+	void DrawEvent_set_bounds  (DrawEvent* pthis, const Bounds& bounds);
+
+
+	void KeyEvent_set_captured (KeyEvent* pthis, bool captured);
+
+
 	void PointerEvent_add_pointer    (PointerEvent* pthis, const Pointer& pointer);
 
 	void PointerEvent_erase_pointer  (PointerEvent* pthis, Pointer::ID id);
@@ -21,11 +31,16 @@ namespace Reflex
 	void PointerEvent_each_pointer (
 		const PointerEvent* pthis, std::function<void(const Pointer&)> fun);
 
+	void PointerEvent_set_captured (PointerEvent* pthis, bool captured);
+
 	void PointerEvent_update_for_child_view (PointerEvent* pthis, const View* view);
 
 	void PointerEvent_update_for_capturing_view (PointerEvent* pthis, const View* view);
 
 
+	void WheelEvent_set_position (WheelEvent* pthis, const Point& position);
+
+
 }// Reflex
 
 

data/src/image_view.cpp

@@ -53,8 +53,8 @@ namespace Reflex
 	{
 		if (!self->image) return;
 
-		assert(e && e->painter);
-		Painter* p = e->painter;
+		assert(e && e->painter());
+		Painter* p = e->painter();
 
 		Color f = p->fill(), s = p->stroke();
 		p->set_fill(1);

data/src/ios/view_controller.mm

@@ -376,7 +376,7 @@ ReflexViewController_get_show_fun ()
 
 		if (dpos != 0 || dsize != 0)
 		{
-			Reflex::FrameEvent e(b, dpos.x, dpos.y, dsize.x, dsize.y);
+			Reflex::FrameEvent e(b, dpos.x, dpos.y, dsize.x, dsize.y, 0, 0);
 			if (dpos  != 0) win->on_move(&e);
 			if (dsize != 0)
 			{

data/src/osx/event.h

@@ -15,7 +15,7 @@ namespace Reflex
 	struct NativeKeyEvent : public KeyEvent
 	{
 
-		NativeKeyEvent (NSEvent* event, Type type);
+		NativeKeyEvent (NSEvent* event, Action action);
 
 	};// NativeKeyEvent
 

data/src/osx/event.mm

@@ -169,11 +169,11 @@ namespace Reflex
 		return 0;
 	}
 
-	static KeyEvent::Type
-	get_flag_key_event_type(const NSEvent* e)
+	static KeyEvent::Action
+	get_flag_key_event_action (const NSEvent* e)
 	{
 		uint mask = get_modifier_flag_mask(e);
-		if (mask == 0) return Reflex::KeyEvent::NONE;
+		if (mask == 0) return Reflex::KeyEvent::ACTION_NONE;
 
 		return [e modifierFlags] & mask
 			?	Reflex::KeyEvent::DOWN
@@ -251,18 +251,18 @@ namespace Reflex
 	}
 
 
-	NativeKeyEvent::NativeKeyEvent (NSEvent* e, Type type)
+	NativeKeyEvent::NativeKeyEvent (NSEvent* e, Action action)
 	:	KeyEvent(
-			type, get_chars(e), get_code([e keyCode]), get_modifiers(e),
-			[e isARepeat] ? 1 : 0)
+			action, get_chars(e), get_code([e keyCode]),
+			get_modifiers(e), [e isARepeat] ? 1 : 0)
 	{
 	}
 
 
 	NativeFlagKeyEvent::NativeFlagKeyEvent (NSEvent* e)
 	:	KeyEvent(
-			get_flag_key_event_type(e), "", get_code([e keyCode]), get_modifiers(e),
-			0)
+			get_flag_key_event_action(e), "", get_code([e keyCode]),
+			get_modifiers(e), 0)
 	{
 	}
 
@@ -295,7 +295,7 @@ namespace Reflex
 	NativeWheelEvent::NativeWheelEvent (NSEvent* e, NSView* view)
 	:	WheelEvent(0, 0, 0, [e deltaX], [e deltaY], [e deltaZ], get_modifiers(e))
 	{
-		position_ = get_pointer_position(e, view);
+		WheelEvent_set_position(this, get_pointer_position(e, view));
 	}
 
 

data/src/osx/native_window.mm

@@ -269,7 +269,7 @@ count_mouse_buttons (const Reflex::PointerEvent& e)
 
 		if (dpos != 0 || dsize != 0)
 		{
-			Reflex::FrameEvent e(b, dpos.x, dpos.y, dsize.x, dsize.y);
+			Reflex::FrameEvent e(b, dpos.x, dpos.y, dsize.x, dsize.y, 0, 0);
 			if (dpos  != 0) win->on_move(&e);
 			if (dsize != 0)
 			{

data/src/shape.cpp

@@ -432,25 +432,23 @@ namespace Reflex
 	}
 
 	void
-	Shape_call_contact_event (Shape* shape, const ContactEvent& event)
+	Shape_call_contact_event (Shape* shape, ContactEvent* event)
 	{
-		if (!shape)
+		if (!shape || !event)
 			argument_error(__FILE__, __LINE__);
 
-		ContactEvent e = event;
-		shape->on_contact(&e);
+		shape->on_contact(event);
 
-		switch (e.type)
+		switch (event->action())
 		{
-			case ContactEvent::BEGIN: shape->on_contact_begin(&e); break;
-			case ContactEvent::END:   shape->on_contact_end(&e);   break;
-			case ContactEvent::NONE: break;
+			case ContactEvent::BEGIN: shape->on_contact_begin(event); break;
+			case ContactEvent::END:   shape->on_contact_end(event);   break;
+			default: break;
 		}
 
-		if (e.is_blocked())
-			return;
+		if (event->is_blocked()) return;
 
-		View_call_contact_event(shape->owner(), e);
+		View_call_contact_event(shape->owner(), event);
 	}
 
 
@@ -587,9 +585,9 @@ namespace Reflex
 	void
 	Shape::on_draw (DrawEvent* e)
 	{
-		assert(e && e->painter);
+		assert(e && e->painter());
 
-		e->painter->polygon(self->polygon);
+		e->painter()->polygon(self->polygon);
 	}
 
 	void

data/src/shape.h

@@ -52,7 +52,7 @@ namespace Reflex
 
 	void Shape_update (Shape* shape, bool force = false);
 
-	void Shape_call_contact_event (Shape* shape, const ContactEvent& event);
+	void Shape_call_contact_event (Shape* shape, ContactEvent* event);
 
 
 }// Reflex

data/src/view.cpp

@@ -948,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)
@@ -958,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);
@@ -1024,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();
@@ -1033,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())
@@ -1068,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)
@@ -1088,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);
 			}
 		}
 
@@ -1105,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))
@@ -1130,7 +1134,7 @@ namespace Reflex
 			return false;
 		}
 
-		Painter* painter = event->painter;
+		Painter* painter = event->painter();
 
 		if (reset_cache_image(view, *painter) || redraw)
 		{
@@ -1148,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();
 
@@ -1157,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__);
@@ -1166,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);
 
@@ -1197,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();
 	}
@@ -1227,127 +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, const EVENT& event, FUN fun)
+	call_children (View* parent, std::function<bool(View*)> fun)
 	{
 		assert(parent);
 
 		auto* pchildren = parent->self->pchildren.get();
 		if (!pchildren) return;
 
-		for (auto& pchild : *pchildren)
-			fun(pchild.get(), event);
+		auto end = pchildren->rend();
+		for (auto it = pchildren->rbegin(); it != end; ++it)
+		{
+			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);
 
-		KeyEvent e = event;
-		view->on_key(&e);
+		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();
+		});
+	}
+
+	static void
+	call_pointer_events (View* view, PointerEvent* event)
+	{
+		assert(view && event);
+
+		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
-	update_captures (View* view, PointerEvent* event)
+	register_captures (View* view, const PointerEvent& event)
 	{
+		assert(view);
+
 		Window* win = view->window();
 		if (!win)
 			invalid_state_error(__FILE__, __LINE__);
 
-		PointerEvent_each_pointer(event, [&](const auto& pointer)
+		PointerEvent_each_pointer(&event, [&](const auto& pointer)
 		{
-			auto action = pointer.action();
-			if (action == Pointer::DOWN)
-			{
+			if (pointer.action() == Pointer::DOWN)
 				Window_register_capture(win, view, pointer.id());
-			}
-			else if (action == Pointer::UP || action == Pointer::CANCEL)
-			{
-				Window_unregister_capture(win, view, pointer.id());
-			}
 		});
 	}
 
 	static void
-	call_pointer_event_for_each_child (View* parent, const PointerEvent& event)
+	unregister_captures (View* view, const PointerEvent& event)
 	{
-		call_children(parent, event, [](View* child, const PointerEvent& e) {
-			PointerEvent e2 = e;
-			PointerEvent_update_for_child_view(&e2, child);
-			View_call_pointer_event(child, e2);
+		assert(view);
+
+		Window* win = view->window();
+		if (!win)
+			invalid_state_error(__FILE__, __LINE__);
+
+		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());
 		});
 	}
 
 	void
-	View_call_pointer_event (View* view, const PointerEvent& event)
+	View_call_pointer_event (View* view, PointerEvent* event)
 	{
-		if (!view)
+		if (!view || !event)
 			argument_error(__FILE__, __LINE__);
 
-		if (event.empty())
+		if (view->hidden() || event->empty())
 			return;
 
-		PointerEvent e = event;
-		view->on_pointer(&e);
+		PointerEvent e = event->dup();
 
-		switch (e[0].action())
+		if (!e.is_captured())
+			call_pointer_events_for_each_child(view, &e);
+
+		if (!e.is_blocked())
 		{
-			case Pointer::DOWN:   view->on_pointer_down(&e);   break;
-			case Pointer::UP:     view->on_pointer_up(&e);     break;
-			case Pointer::MOVE:   view->on_pointer_move(&e);   break;
-			case Pointer::CANCEL: view->on_pointer_cancel(&e); break;
-			default: break;
+			register_captures(view, e);
+			call_pointer_events(view, &e);
 		}
 
-		update_captures(view, &e);
-
-		if (!e.is_captured())
-			call_pointer_event_for_each_child(view, 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();
+		});
 
-		call_children(view, e, View_call_wheel_event);
+		if (e.is_blocked()) return;
+
+		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;
 		}
 	}
 

data/src/view.h

@@ -30,20 +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_call_key_event     (View* view, const KeyEvent& event);
+	void View_call_key_event     (View* view, KeyEvent* event);
 
-	void View_call_pointer_event (View* view, const PointerEvent& event);
+	void View_call_pointer_event (View* view, PointerEvent* event);
 
-	void View_call_wheel_event   (View* view, const WheelEvent& event);
+	void View_call_wheel_event   (View* view, WheelEvent* event);
 
-	void View_call_contact_event (View* view, const ContactEvent& event);
+	void View_call_contact_event (View* view, ContactEvent* event);
 
 
 }// Reflex