reflexion 0.5.2 → 0.6.0

data/src/win32/window.h

@@ -4,6 +4,7 @@
 #define __REFLEX_SRC_WIN32_WINDOW_H__
 
 
+#include <xot/windows.h>
 #include "../window.h"
 
 
@@ -11,6 +12,8 @@ namespace Reflex
 {
 
 
+	HWND Window_get_hwnd (const Window* window);
+
 	void Window_update (Window* win);
 
 

data/src/window.cpp

@@ -14,14 +14,14 @@ namespace Reflex
 {
 
 
-	using ViewList              = std::vector<View::Ref>;
-
 	using PointerMap            = std::map<Pointer::ID, Pointer>;
 
 	using ExtractedPointerIDSet = std::set<Pointer::ID>;
 
 	using CaptureTargetIDList   = Window::Data::CaptureTargetIDList;
 
+	using WeakViewList          = Window::Data::WeakViewList;
+
 
 	void
 	Window_register (Window* win)
@@ -176,6 +176,9 @@ namespace Reflex
 
 		Event e;
 		window->on_activate(&e);
+		if (e.is_blocked()) return;
+
+		View_activate_tree(window->root(), &e);
 	}
 
 	void
@@ -183,10 +186,13 @@ namespace Reflex
 	{
 		if (!window) return;
 
+		Xot::remove_flag(&window->self->flags, Window::Data::ACTIVE);
+
 		Event e;
 		window->on_deactivate(&e);
+		if (e.is_blocked()) return;
 
-		Xot::remove_flag(&window->self->flags, Window::Data::ACTIVE);
+		View_deactivate_tree(window->root(), &e);
 	}
 
 	void
@@ -288,6 +294,14 @@ namespace Reflex
 		cleanup_captures(window);
 	}
 
+	static bool
+	need_next_pointer_id (const Pointer& pointer, const Pointer& prev_pointer)
+	{
+		return
+			     pointer.action() == Pointer::DOWN ||
+			prev_pointer.action() == Pointer::UP;
+	}
+
 	static Pointer::ID
 	get_next_pointer_id (Window* window)
 	{
@@ -304,14 +318,13 @@ namespace Reflex
 
 		Window::Data* self = window->self.get();
 
-		auto action        = pointer->action();
 		auto& prev_pointer = self->prev_mouse_pointer;
 
 		auto id    = prev_pointer ? prev_pointer.id() : get_next_pointer_id(window);
 		auto* down = prev_pointer.down();
 		if (
 			Pointer_mask_flag(prev_pointer, MOUSE_BUTTONS) == 0 &&
-			(action == Pointer::DOWN || prev_pointer.action() == Pointer::UP))
+			need_next_pointer_id(*pointer, prev_pointer))
 		{
 			id   = get_next_pointer_id(window);
 			down = NULL;
@@ -322,6 +335,7 @@ namespace Reflex
 		Pointer_set_prev(pointer, &prev_pointer);
 		Pointer_set_down(pointer, down);
 
+		auto action = pointer->action();
 		if (action == Pointer::DOWN)
 			Pointer_add_flag(pointer, pointer->types() & MOUSE_BUTTONS);
 
@@ -351,6 +365,21 @@ namespace Reflex
 			});
 	}
 
+	static bool
+	is_last_pointer_event (const Pointer& pointer)
+	{
+		auto action = pointer.action();
+		if (action == Pointer::UP || action == Pointer::CANCEL)
+		{
+			// a mouse cursor and a floatable pen (Apple Pencil) survive their
+			// up/cancel; a finger or non-floatable pen ends here.
+			return
+				!(pointer.types() & Pointer::MOUSE) &&
+				!Pointer_is_floatable(pointer);
+		}
+		return action == Pointer::LEAVE;
+	}
+
 	static void
 	setup_pointer (Window* window, Pointer* pointer)
 	{
@@ -362,16 +391,21 @@ namespace Reflex
 
 		if (prev_pointer)
 		{
-			Pointer_set_id(pointer, prev_pointer->id());
+			if (need_next_pointer_id(*pointer, *prev_pointer))
+				Pointer_set_id(pointer, get_next_pointer_id(window));
+			else
+			{
+				Pointer_set_id(pointer, prev_pointer->id());
+				Pointer_set_down(pointer, prev_pointer->down());
+			}
+			Pointer_set_floatable(pointer, Pointer_is_floatable(*prev_pointer));
 			Pointer_set_prev(pointer, prev_pointer);
-			Pointer_set_down(pointer, prev_pointer->down());
 			prev_pointers.erase(it);
 		}
 		else
 			Pointer_set_id(pointer, get_next_pointer_id(window));
 
-		auto action = pointer->action();
-		if (action != Pointer::UP && action != Pointer::CANCEL)
+		if (!is_last_pointer_event(*pointer))
 		{
 			prev_pointers.emplace_back(*pointer);
 			Pointer_set_prev(&prev_pointers.back(), NULL);
@@ -460,7 +494,7 @@ namespace Reflex
 			extract_targeted_pointers(&event, extracteds, targets, pointers);
 			if (event.empty()) continue;
 
-			PointerEvent_update_for_capturing_view(&event, view);
+			PointerEvent_to_view_coord(&event, view);
 			View_call_pointer_event(const_cast<View*>(view.get()), &event);
 
 			if (event.is_blocked()) *blocked = true;
@@ -502,7 +536,7 @@ namespace Reflex
 			if (!view->window()) continue;
 
 			PointerEvent e = event.dup();
-			PointerEvent_update_for_capturing_view(&e, view);
+			PointerEvent_to_view_coord(&e, view);
 			View_call_pointer_event(const_cast<View*>(view.get()), &e);
 
 			if (e.is_blocked()) *blocked = true;
@@ -561,6 +595,137 @@ namespace Reflex
 		if (blocked) event->block();
 	}
 
+	static void
+	get_current_hovered_views (
+		ViewList* result, Window* window, const Pointer& pointer)
+	{
+		if (pointer.is_drag())
+		{
+			// while dragging, only the capturing view(s) take part in enter/leave,
+			// tested against their own frame; views merely passed over are ignored.
+			for (auto& [view, targets] : window->self->captures)
+			{
+				if (!view->window()) continue;
+				if (std::find(targets.begin(), targets.end(), pointer.id()) == targets.end())
+					continue;
+
+				Point pos = view->from_window(pointer.position());
+				if (Bounds(view->frame().size()).is_include(pos))
+					result->emplace_back(view);
+			}
+		}
+		else
+			View_get_hovered_views(result, window->root(), pointer.position());
+	}
+
+	static WeakViewList*
+	get_prev_hovered_views (Window* window, const Pointer& pointer)
+	{
+		// a mouse pointer gets a fresh id on every click, so follow the prev()
+		// chain to keep tracking the same physical pointer across id changes.
+		auto& map = window->self->hovered_views;
+
+		auto it = map.find(pointer.id());
+		if (
+			it == map.end() &&
+			pointer.prev() && pointer.prev()->id() != pointer.id())
+		{
+			auto prev_it = map.find(pointer.prev()->id());
+			if (prev_it != map.end())
+			{
+				it = map.emplace(pointer.id(), std::move(prev_it->second)).first;
+				map.erase(prev_it);
+			}
+		}
+
+		return it != map.end() ? &it->second : NULL;
+	}
+
+	static void
+	call_pointer_boundary_event (
+		View* view, const Pointer& pointer, Pointer::Action action)
+	{
+		if (!view->window()) return;
+
+		Pointer p = pointer;
+		Pointer_set_action(&p, action);
+
+		PointerEvent event(&p, 1);
+		PointerEvent_to_view_coord(&event, view);
+		View_call_pointer_event(view, &event);
+	}
+
+	static void
+	call_pointer_boundary_events (
+		Window* window, const Pointer& pointer, ViewList* news)
+	{
+		ViewList olds;
+		if (auto* weak_views = get_prev_hovered_views(window, pointer))
+		{
+			for (auto& view : *weak_views)
+				if (view) olds.emplace_back(view.get());
+
+			for (auto it = olds.rbegin(); it != olds.rend(); ++it)
+			{
+				if (std::find(news->begin(), news->end(), it->get()) != news->end())
+					continue;
+				call_pointer_boundary_event(it->get(), pointer, Pointer::LEAVE);
+			}
+		}
+
+		for (auto& view : *news)
+		{
+			if (std::find(olds.begin(), olds.end(), view.get()) != olds.end())
+				continue;
+			call_pointer_boundary_event(view.get(), pointer, Pointer::ENTER);
+		}
+
+		auto& map = window->self->hovered_views;
+		if (news->empty())
+			map.erase(pointer.id());
+		else
+			map[pointer.id()] = WeakViewList(news->begin(), news->end());
+	}
+
+	static void
+	call_pointer_enter_events (Window* window, const auto& pointers)
+	{
+		for (const auto& pointer : pointers)
+		{
+			auto a = pointer.action();
+			if (a == Pointer::DOWN || a == Pointer::MOVE || a == Pointer::ENTER)
+			{
+				ViewList views;
+				get_current_hovered_views(&views, window, pointer);
+				call_pointer_boundary_events(window, pointer, &views);
+			}
+		}
+	}
+
+	static void
+	call_pointer_leave_events (Window* window, const auto& pointers)
+	{
+		for (const auto& pointer : pointers)
+		{
+			auto a = pointer.action();
+			if (a == Pointer::UP || a == Pointer::CANCEL || a == Pointer::LEAVE)
+			{
+				// a pointer that survives this event keeps hovering whatever is under
+				// it; a pointer that ends here hovers nothing and leaves every view.
+				ViewList views;
+				if (!is_last_pointer_event(pointer))
+					get_current_hovered_views(&views, window, pointer);
+				call_pointer_boundary_events(window, pointer, &views);
+			}
+		}
+	}
+
+	static bool
+	is_boundary_action (Pointer::Action action)
+	{
+		return action == Pointer::ENTER || action == Pointer::LEAVE;
+	}
+
 	void
 	Window_call_pointer_event (Window* window, PointerEvent* event)
 	{
@@ -571,6 +736,10 @@ namespace Reflex
 
 		setup_pointer_event(window, event);
 
+		bool boundary = !event->empty() && is_boundary_action((*event)[0].action());
+		std::vector<Pointer> pointers;
+		PointerEvent_each_pointer(event, [&](const auto& p) {pointers.emplace_back(p);});
+
 		if (!event->empty())
 			window->on_pointer(event);
 
@@ -582,18 +751,25 @@ namespace Reflex
 				case Pointer::UP:     window->on_pointer_up(event);     break;
 				case Pointer::MOVE:   window->on_pointer_move(event);   break;
 				case Pointer::CANCEL: window->on_pointer_cancel(event); break;
+				case Pointer::ENTER:  window->on_pointer_enter(event);  break;
+				case Pointer::LEAVE:  window->on_pointer_leave(event);  break;
 				default: break;
 			}
 		}
 
-		if (!event->empty() && !event->is_blocked())
-			call_captured_pointer_events(window, event);
-
-		if (!event->empty() && !event->is_blocked())
+		call_pointer_enter_events(window, pointers);
+		if (!boundary)
 		{
-			PointerEvent_update_for_child_view(event, window->root());
-			View_call_pointer_event(window->root(), event);
+			if (!event->empty() && !event->is_blocked())
+				call_captured_pointer_events(window, event);
+
+			if (!event->empty() && !event->is_blocked())
+			{
+				PointerEvent_update_for_child_view(event, window->root());
+				View_call_pointer_event(window->root(), event);
+			}
 		}
+		call_pointer_leave_events(window, pointers);
 
 		cleanup_captures(window);
 	}
@@ -786,6 +962,8 @@ namespace Reflex
 		on_close(&e);
 		if (!force && e.is_blocked()) return;
 
+		self->hovered_views.clear();
+
 		View_set_window(self->root.get(), NULL);
 
 		Window_close(this);
@@ -809,6 +987,12 @@ namespace Reflex
 		return point + frame().position();
 	}
 
+	bool
+	Window::active () const
+	{
+		return Xot::has_flag(self->flags, Data::ACTIVE);
+	}
+
 	void
 	Window::set_title (const char* title)
 	{
@@ -839,6 +1023,25 @@ namespace Reflex
 		return Window_get_frame(*this);
 	}
 
+	void
+	Window::set_menu (Menu* menu)
+	{
+		self->menu = menu;
+		Window_set_menu(this, menu);
+	}
+
+	Menu*
+	Window::menu ()
+	{
+		return self->menu.get();
+	}
+
+	const Menu*
+	Window::menu () const
+	{
+		return const_cast<Window*>(this)->menu();
+	}
+
 	void
 	Window::set_flag (uint flags)
 	{
@@ -924,27 +1127,27 @@ namespace Reflex
 	}
 
 	void
-	Window::on_activate (Event* e)
+	Window::on_show (Event* e)
 	{
 	}
 
 	void
-	Window::on_deactivate (Event* e)
+	Window::on_hide (Event* e)
 	{
 	}
 
 	void
-	Window::on_show (Event* e)
+	Window::on_close (Event* e)
 	{
 	}
 
 	void
-	Window::on_hide (Event* e)
+	Window::on_activate (Event* e)
 	{
 	}
 
 	void
-	Window::on_close (Event* e)
+	Window::on_deactivate (Event* e)
 	{
 	}
 
@@ -1008,6 +1211,16 @@ namespace Reflex
 	{
 	}
 
+	void
+	Window::on_pointer_enter (PointerEvent* e)
+	{
+	}
+
+	void
+	Window::on_pointer_leave (PointerEvent* e)
+	{
+	}
+
 	void
 	Window::on_wheel (WheelEvent* e)
 	{

data/src/window.h

@@ -12,6 +12,7 @@
 #include <rays/painter.h>
 #include "reflex/window.h"
 #include "reflex/view.h"
+#include "reflex/menu.h"
 #include "application.h"
 #include "pointer.h"
 
@@ -33,6 +34,10 @@ namespace Reflex
 
 		typedef std::map<View::Ref, CaptureTargetIDList> CaptureMap;
 
+		typedef std::vector<Xot::WeakRef<View>>          WeakViewList;
+
+		typedef std::map<Pointer::ID, WeakViewList>      HoveredViewMap;
+
 		enum Flag
 		{
 
@@ -48,12 +53,12 @@ namespace Reflex
 
 		View::Ref root, focus;
 
+		Menu::Ref menu;
+
 		Point prev_position, prev_size;
 
 		double prev_time_update, prev_time_draw, prev_fps = 0;
 
-		CaptureMap captures;
-
 		int next_pointer_id = 1;
 
 		Pointer prev_mouse_pointer;
@@ -62,6 +67,10 @@ namespace Reflex
 
 		uint flags;
 
+		CaptureMap captures;
+
+		HoveredViewMap hovered_views;
+
 		Data ();
 
 		virtual ~Data ();
@@ -111,6 +120,8 @@ namespace Reflex
 
 	Bounds Window_get_frame (const Window& window);
 
+	void Window_set_menu (Window* window, Menu* menu);
+
 	Screen Window_get_screen (const Window& window);
 
 	void Window_set_flags (Window* window, uint flags);

data/src/world.cpp

@@ -2,6 +2,7 @@
 
 
 #include <assert.h>
+#include <algorithm>
 #include <memory>
 #include <vector>
 #include <map>
@@ -9,8 +10,9 @@
 #include <box2d/box2d.h>
 #include "reflex/event.h"
 #include "reflex/exception.h"
-#include "shape.h"
 #include "view.h"
+#include "shape.h"
+#include "constraint.h"
 #include "body.h"
 #include "fixture.h"
 
@@ -274,12 +276,24 @@ namespace Reflex
 
 		bool stepping     = false;
 
-		std::unique_ptr<DebugDraw> debug_draw;
-
 		// tracked to deliver contact-end events for shapes that Box2D has already
 		// forgotten on destruction
 		ShapePairMap touching_pairs;
 
+		std::vector<Xot::WeakRef<Constraint>> constraints;
+
+		// fixture-less static body for constraints that anchor to the world
+		// (e.g. chasing a target point) without affecting any collision
+		std::unique_ptr<Body>      pground;
+
+		std::unique_ptr<DebugDraw> pdebug_draw;
+
+		Body* ground (World* world)
+		{
+			if (!pground) pground.reset(new Body(world));
+			return pground.get();
+		}
+
 		void begin_contact (b2ShapeId b2shape1, b2ShapeId b2shape2, bool is_sensor_event)
 		{
 			Shape* s1 = get_shape(b2shape1);
@@ -338,6 +352,25 @@ namespace Reflex
 			}
 		}
 
+		void update_constraints ()
+		{
+			for (auto& constraint : constraints)
+			{
+				if (constraint)
+					Constraint_on_world_update(constraint);
+			}
+		}
+
+		void clear_constraints ()
+		{
+			for (auto& constraint : constraints)
+			{
+				if (constraint)
+					Constraint_on_world_destroyed(constraint);
+			}
+			constraints.clear();
+		}
+
 	};// World::Data
 
 
@@ -361,6 +394,8 @@ namespace Reflex
 	World::~World ()
 	{
 		self->touching_pairs.clear();
+		self->clear_constraints();
+		self->pground.reset();
 
 		b2DestroyWorld(self->b2world);
 		self->b2world = b2_nullWorldId;
@@ -377,6 +412,8 @@ namespace Reflex
 
 		for (int i = 0; i < count; ++i)
 		{
+			self->update_constraints();
+
 			self->stepping = true;
 			b2World_Step(self->b2world, dt, 4);
 			self->stepping = false;
@@ -426,19 +463,19 @@ namespace Reflex
 		if (state == debug()) return;
 
 		if (state)
-			self->debug_draw.reset(new DebugDraw(self->ppm));
+			self->pdebug_draw.reset(new DebugDraw(self->ppm));
 		else
-			self->debug_draw.reset();
+			self->pdebug_draw.reset();
 	}
 
 	bool
 	World::debug () const
 	{
-		return !!self->debug_draw;
+		return !!self->pdebug_draw;
 	}
 
 	void
-	World::on_update (float dt)
+	World::on_update ()
 	{
 		update(DELTA_TIME);
 	}
@@ -446,11 +483,11 @@ namespace Reflex
 	void
 	World::on_draw (Painter* painter)
 	{
-		if (!self->debug_draw) return;
+		if (!self->pdebug_draw) return;
 
-		self->debug_draw->begin(painter);
-		b2World_Draw(self->b2world, self->debug_draw->b2ptr());
-		self->debug_draw->end();
+		self->pdebug_draw->begin(painter);
+		b2World_Draw(self->b2world, self->pdebug_draw->b2ptr());
+		self->pdebug_draw->end();
 	}
 
 
@@ -460,10 +497,24 @@ namespace Reflex
 		return world ? world->self->b2world : b2_nullWorldId;
 	}
 
-	bool
-	World_is_stepping (const World* world)
+	void
+	World_add_constraint (World* world, Constraint* constraint)
 	{
-		return world ? world->self->stepping : false;
+		if (!world || !constraint)
+			argument_error(__FILE__, __LINE__);
+
+		world->self->constraints.emplace_back(constraint);
+	}
+
+	void
+	World_remove_constraint (World* world, Constraint* constraint)
+	{
+		if (!world || !constraint)
+			argument_error(__FILE__, __LINE__);
+
+		std::erase_if(
+			world->self->constraints,
+			[=](auto& c) {return !c || c == constraint;});
 	}
 
 	void
@@ -490,6 +541,18 @@ namespace Reflex
 			call_contact_events(pair.first, pair.second, ContactEvent::END);
 	}
 
+	bool
+	World_is_stepping (const World* world)
+	{
+		return world ? world->self->stepping : false;
+	}
+
+	const Body*
+	World_get_ground (World* world)
+	{
+		return world ? world->self->ground(world) : NULL;
+	}
+
 	World*
 	World_get_temporary ()
 	{

data/src/world.h

@@ -19,6 +19,7 @@ namespace Reflex
 
 	class View;
 	class Body;
+	class Constraint;
 
 
 	class World : public Xot::NonCopyable
@@ -51,7 +52,7 @@ namespace Reflex
 
 			bool     debug () const;
 
-			virtual void on_update (float dt);
+			virtual void on_update ();
 
 			virtual void on_draw (Painter* painter);
 
@@ -104,10 +105,16 @@ namespace Reflex
 
 	b2WorldId World_get_id (const World* world);
 
-	bool World_is_stepping (const World* world);
+	void World_add_constraint    (World* world, Constraint* constraint);
+
+	void World_remove_constraint (World* world, Constraint* constraint);
 
 	void World_end_contacts_for (World* world, b2ShapeId b2shape);
 
+	bool World_is_stepping (const World* world);
+
+	const Body* World_get_ground (World* world);
+
 	World* World_get_temporary ();
 
 

data/test/helper.rb

@@ -8,3 +8,10 @@ require 'reflex'
 require 'test/unit'
 
 include Xot::Test
+
+
+def assert_equal_point(expected, actual, delta = 0.01, *args)
+  assert_in_delta expected.x, actual.x, delta, *args
+  assert_in_delta expected.y, actual.y, delta, *args
+  assert_in_delta expected.z, actual.z, delta, *args
+end