reflexion 0.5.3 → 0.7.0

data/src/window.cpp

@@ -2,26 +2,56 @@
 
 
 #include <assert.h>
+#include <math.h>
 #include <algorithm>
 #include <set>
+#include <rays/rays.h>
 #include "reflex/exception.h"
 #include "reflex/debug.h"
+#include "application.h"
 #include "view.h"
 #include "event.h"
+#include "midi.h"
+#include "rays.h"
 
 
 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;
+
+
+	Window::Data::Data ()
+	:	flags(Window_default_flags() | REDRAW)
+	{
+		prev_time_update = prev_time_draw = Xot::time();
+	}
+
+	Window::Data::~Data ()
+	{
+	}
+
+
+	static Window_CreateRootViewFun create_root_view_fun = NULL;
+
+	void
+	Window_set_create_root_view_fun (Window_CreateRootViewFun fun)
+	{
+		create_root_view_fun = fun;
+	}
+
+	static View*
+	create_root_view ()
+	{
+		return create_root_view_fun ? create_root_view_fun() : new View();
+	}
 
 	void
 	Window_register (Window* win)
@@ -64,15 +94,11 @@ namespace Reflex
 		return NULL;
 	}
 
-
-	Window::Data::Data ()
-	:	flags(Window_default_flags())
-	{
-		prev_time_update = prev_time_draw = Xot::time();
-	}
-
-	Window::Data::~Data ()
+	void
+	Window_skip_update_time_of_all (double seconds)
 	{
+		for (auto& window : Window_all())
+			window->self->prev_time_update += seconds;
 	}
 
 
@@ -104,20 +130,6 @@ namespace Reflex
 		}
 	}
 
-	static Window_CreateRootViewFun create_root_view_fun = NULL;
-
-	void
-	Window_set_create_root_view_fun (Window_CreateRootViewFun fun)
-	{
-		create_root_view_fun = fun;
-	}
-
-	static View*
-	create_root_view ()
-	{
-		return create_root_view_fun ? create_root_view_fun() : new View();
-	}
-
 	void
 	Window_register_capture (Window* window, View* view, Pointer::ID target)
 	{
@@ -167,15 +179,84 @@ namespace Reflex
 		}
 	}
 
+	static const uint MOUSE_BUTTONS =
+		Pointer::MOUSE_LEFT  |
+		Pointer::MOUSE_RIGHT |
+		Pointer::MOUSE_MIDDLE;
+
+	void
+	Window_cancel_active_pointers (Window* window)
+	{
+		assert(window);
+
+		// synthesizes a cancel for every pointer being pressed and delivers
+		// it through the normal path, so the existing up/cancel handling
+		// releases captures and pressed states
+
+		Window::Data* self = window->self.get();
+
+		double now = Xot::time();
+
+		PointerEvent event;
+
+		const auto& mouse = self->prev_mouse_pointer;
+		uint pressed      = Pointer_mask_flag(mouse, MOUSE_BUTTONS);
+		if (pressed != 0)
+		{
+			Pointer pointer = mouse;
+			Pointer_set_types(&pointer, Pointer::MOUSE | pressed);
+			Pointer_set_action(&pointer, Pointer::CANCEL);
+			Pointer_set_time(&pointer, now);
+			PointerEvent_add_pointer(&event, pointer);
+		}
+
+		for (const auto& p : self->prev_pointers)
+		{
+			if (!p.down()) continue;
+			Pointer pointer = p;
+			Pointer_set_action(&pointer, Pointer::CANCEL);
+			Pointer_set_time(&pointer, now);
+			PointerEvent_add_pointer(&event, pointer);
+		}
+
+		if (event.empty()) return;
+
+		++self->pointer_cancels;
+		Window_call_pointer_event(window, &event);
+	}
+
+	uint
+	Window_get_pointer_cancels (const Window& window)
+	{
+		return window.self->pointer_cancels;
+	}
+
+	void
+	Window_call_close (Window* window)
+	{
+		if (!window) return;
+
+		Application_guard([&]()
+		{
+			window->close();
+		});
+	}
+
 	void
 	Window_call_activate_event (Window* window)
 	{
 		if (!window) return;
 
-		Xot::add_flag(&window->self->flags, Window::Data::ACTIVE);
+		Application_guard([&]()
+		{
+			Xot::add_flag(&window->self->flags, Window::Data::ACTIVE);
 
-		Event e;
-		window->on_activate(&e);
+			Event e;
+			window->on_activate(&e);
+			if (e.is_blocked()) return;
+
+			View_activate_tree(window->root(), &e);
+		});
 	}
 
 	void
@@ -183,25 +264,186 @@ namespace Reflex
 	{
 		if (!window) return;
 
-		Event e;
-		window->on_deactivate(&e);
+		Application_guard([&]()
+		{
+			Xot::remove_flag(&window->self->flags, Window::Data::ACTIVE);
+
+			Event e;
+			window->on_deactivate(&e);
+			if (e.is_blocked()) return;
+
+			View_deactivate_tree(window->root(), &e);
+		});
+	}
+
+	static bool
+	is_pointer_through_by_alpha (const Window::Data& self)
+	{
+		return
+			Xot::has_flag(self.flags, Window::FLAG_POINTER_THROUGH) &&
+			self.pointer_through_alpha < 1;
+	}
+
+	static bool
+	has_pressed_pointer (const Window::Data& self)
+	{
+		if (Pointer_mask_flag(self.prev_mouse_pointer, MOUSE_BUTTONS) != 0)
+			return true;
+
+		for (const auto& p : self.prev_pointers)
+		{
+			if (p.down())
+				return true;
+		}
+		return false;
+	}
+
+	static float
+	get_cache_alpha (Window::Data* self, const Point& position)
+	{
+		if (!self->draw_cache)
+			return 0;
+
+		Rays::activate_offscreen_context();
+
+		Color color;
+		bool ret = Rays::Painter_get_pixel(
+			&color, &self->draw_cache_painter, position.x, position.y);
+		return ret ? color.alpha : 0;
+	}
+
+	static void
+	apply_pointer_through (Window* window)
+	{
+		using Data = Window::Data;
+
+		Data* self = window->self.get();
+
+		if (!is_pointer_through_by_alpha(*self))
+		{
+			Xot::remove_flag(
+				&self->flags,
+				Data::POINTER_THROUGH_PAUSED | Data::POINTER_THROUGH_ENTERED);
+		}
 
-		Xot::remove_flag(&window->self->flags, Window::Data::ACTIVE);
+		Window_set_pointer_through(
+			window,
+			Xot::has_flag(self->flags, Window::FLAG_POINTER_THROUGH) &&
+			!Xot::has_flag(self->flags, Data::POINTER_THROUGH_PAUSED));
+	}
+
+	static bool is_inside_window (Window* window, const Point& position);
+
+	static void call_pointer_event (Window* window, PointerEvent* event);
+
+	static void
+	update_pointer_through (Window* window)
+	{
+		using Data = Window::Data;
+
+		Data* self = window->self.get();
+		if (!is_pointer_through_by_alpha(*self))
+			return;
+		if (has_pressed_pointer(*self))
+			return;
+
+		Point pos;
+		bool over_and_uncov = Window_is_pointer_over_and_uncovered(&pos, *window);
+		bool inside         = over_and_uncov && is_inside_window(window, pos);
+		bool opaque         =
+			over_and_uncov &&
+			(!inside || get_cache_alpha(self, pos) > self->pointer_through_alpha);
+		if (opaque != Xot::has_flag(self->flags, Data::POINTER_THROUGH_PAUSED))
+		{
+			Xot::update_flag(&self->flags, Data::POINTER_THROUGH_PAUSED, opaque);
+			apply_pointer_through(window);
+		}
+
+		bool entered = opaque && inside;
+		if (entered == Xot::has_flag(self->flags, Data::POINTER_THROUGH_ENTERED))
+			return;
+
+		Xot::update_flag(&self->flags, Data::POINTER_THROUGH_ENTERED, entered);
+
+		PointerEvent event;
+		PointerEvent_add_pointer(&event, Pointer(
+			0, Pointer::MOUSE,
+			entered ? Pointer::ENTER : Pointer::LEAVE,
+			entered ? pos            : self->prev_mouse_pointer.position(),
+			0, 0, false, Xot::time()));
+		call_pointer_event(window, &event);
 	}
 
 	void
 	Window_call_update_event (Window* window)
 	{
-		Window::Data* self = window->self.get();
+		Application_guard([&]()
+		{
+			Window::Data* self = window->self.get();
 
-		double now = Xot::time();
-		UpdateEvent e(now, now - self->prev_time_update);
-		self->prev_time_update = now;
+			MIDI_process_events();
+
+			update_pointer_through(window);
 
-		window->on_update(&e);
-		if (e.is_blocked()) return;
+			double now = Xot::time();
+			UpdateEvent e(now, std::max(now - self->prev_time_update, 0.0));
+			self->prev_time_update = now;
 
-		View_update_tree(window->root(), e);
+			window->on_update(&e);
+			if (!e.is_blocked())
+				View_update_tree(window->root(), e);
+		});
+	}
+
+	static bool
+	use_draw_cache (const Window::Data& self)
+	{
+		return is_pointer_through_by_alpha(self);
+	}
+
+	static void
+	setup_draw_cache (Window::Data* self, const Bounds& bounds, float density)
+	{
+		int w = (int) ceil(bounds.width);
+		int h = (int) ceil(bounds.height);
+		if (w == 0 || h == 0 || !use_draw_cache(*self))
+		{
+			if (self->draw_cache)
+			{
+				self->draw_cache         = Image();
+				self->draw_cache_painter = Painter();
+			}
+			return;
+		}
+
+		Image& cache = self->draw_cache;
+		if (
+			!cache ||
+			cache.width()         != w ||
+			cache.height()        != h ||
+			cache.pixel_density() != density)
+		{
+			self->draw_cache         = Image(w, h, Rays::RGBA, density);
+			self->draw_cache_painter = self->draw_cache.painter();
+		}
+	}
+
+	static void
+	draw_window (Window* window, DrawEvent* event)
+	{
+		Painter* painter = event->painter();
+
+		painter->begin();
+		painter->push_state();
+		{
+			painter->clear();
+
+			window->on_draw(event);
+			if (!event->is_blocked())
+				View_draw_tree(window->root(), event, 0, event->bounds());
+		}
+		painter->pop_state();
+		painter->end();
 	}
 
 	void
@@ -212,25 +454,74 @@ namespace Reflex
 		if (!event)
 			argument_error(__FILE__, __LINE__);
 
-		Painter* painter = window->painter();
-		if (!painter)
-			Xot::invalid_state_error(__FILE__, __LINE__);
+		Application_guard([&]()
+		{
+			Window::Data* self = window->self.get();
 
-		Rays::Bounds frame = window->frame();
+			Painter* painter = window->painter();
+			if (!painter)
+				Xot::invalid_state_error(__FILE__, __LINE__);
 
-		DrawEvent_set_painter(event, painter);
-		DrawEvent_set_bounds(event, Bounds(0, 0, frame.width, frame.height));
+			Bounds bounds = window->frame().move_to(0);
+			setup_draw_cache(self, bounds, painter->pixel_density());
 
-		painter->begin();
-		painter->push_state();
-		painter->clear();
+			DrawEvent_set_painter(event, painter);
+			DrawEvent_set_bounds(event, bounds);
 
-		window->on_draw(event);
-		if (!event->is_blocked())
-			View_draw_tree(window->root(), event, 0, frame.move_to(0));
+			if (self->draw_cache)
+			{
+				painter->bind(self->draw_cache);
+				draw_window(window, event);
+				painter->unbind();
 
-		painter->pop_state();
-		painter->end();
+				painter->begin();
+				painter->push_state();
+				{
+					painter->clear();
+					painter->set_fill(1);
+					painter->no_stroke();
+					painter->no_shader();
+					painter->image(self->draw_cache, 0, 0);
+				}
+				painter->pop_state();
+				painter->end();
+			}
+			else
+				draw_window(window, event);
+		});
+	}
+
+	void
+	Window_call_frame_event (Window* window)
+	{
+		if (!window) return;
+
+		Application_guard([&]()
+		{
+			Rays::Bounds b              = window->frame();
+			Rays::Point dpos            = b.position() - window->self->prev_position;
+			Rays::Point dsize           = b.size()     - window->self->prev_size;
+			window->self->prev_position = b.position();
+			window->self->prev_size     = b.size();
+
+			if (dpos == 0 && dsize == 0) return;
+
+			FrameEvent e(b, dpos.x, dpos.y, 0, dsize.x, dsize.y, 0);
+			if (dpos  != 0) window->on_move(&e);
+			if (dsize != 0)
+			{
+				Rays::Bounds b = window->frame();
+				b.move_to(0, 0);
+
+				if (window->painter())
+					window->painter()->canvas(b, window->painter()->pixel_density());
+
+				if (window->root())
+					View_set_frame(window->root(), b);
+
+				window->on_resize(&e);
+			}
+		});
 	}
 
 	static bool
@@ -243,49 +534,126 @@ namespace Reflex
 			(view->capture() & type) == type;
 	}
 
+	static void
+	each_capture (Window* window, auto&& fun)
+	{
+		assert(window);
+
+		auto& captures = window->self->captures;
+
+		ViewList views;
+		views.reserve(captures.size());
+		for (const auto& [view, targets] : captures)
+			views.emplace_back(view);
+
+		for (auto& view : views)
+		{
+			if (!view->window()) continue;
+
+			auto it = captures.find(view);
+			if (it == captures.end() || it->second.empty()) continue;
+
+			fun(const_cast<View*>(view.get()), it->second);
+		}
+	}
+
+	static void
+	each_capturing_view (Window* window, View::Capture type, auto&& fun)
+	{
+		each_capture(window, [&](View* view, const CaptureTargetIDList& targets)
+		{
+			if (is_capturing(view, targets, type))
+				fun(view);
+		});
+	}
+
 	void
-	Window_call_key_event (Window* window, KeyEvent* event)
+	Window_call_key_event (Window* window, KeyEvent* event, bool capture)
 	{
 		assert(window);
 
 		if (!event)
 			argument_error(__FILE__, __LINE__);
 
-		window->on_key(event);
-
-		if (!event->is_blocked())
+		Application_guard([&]()
 		{
-			switch (event->action())
+			window->on_key(event);
+
+			if (!event->is_blocked())
 			{
-				case KeyEvent::DOWN: window->on_key_down(event); break;
-				case KeyEvent::UP:   window->on_key_up(event);   break;
-				default: break;
+				switch (event->action())
+				{
+					case KeyEvent::DOWN: window->on_key_down(event); break;
+					case KeyEvent::UP:   window->on_key_up(event);   break;
+					default: break;
+				}
 			}
-		}
 
-		if (!event->is_blocked())
-		{
-			for (auto& [view, targets] : window->self->captures)
+			if (capture && !event->is_blocked())
 			{
-				if (
-					!view->window() ||
-					!is_capturing(view.get(), targets, View::CAPTURE_KEY))
+				each_capturing_view(window, View::CAPTURE_KEY, [&](View* view)
 				{
-					continue;
-				}
+					KeyEvent e = event->dup();
+					KeyEvent_set_captured(&e, true);
+					View_call_key_event(view, &e);
+
+					if (e.is_blocked()) event->block();
+				});
+			}
 
-				KeyEvent e = event->dup();
-				KeyEvent_set_captured(&e, true);
-				View_call_key_event(const_cast<View*>(view.get()), &e);
+			if (!event->is_blocked() && window->self->focus)
+				View_call_key_event(window->self->focus.get(), event);
+
+			if (capture)
+				cleanup_captures(window);
+		});
+	}
+
+	void
+	Window_call_text_event (
+		Window* window, TextEvent* event, bool synthesize_key_events)
+	{
+		assert(window);
+
+		if (!event)
+			argument_error(__FILE__, __LINE__);
+
+		Application_guard([&]()
+		{
+			window->on_text(event);
+			if (event->is_blocked()) return;
+
+			switch (event->action())
+			{
+				case TextEvent::PREEDIT: window->on_text_preedit(event); break;
+				case TextEvent::COMMIT:  window->on_text_commit(event);  break;
+				default: break;
+			}
+			if (event->is_blocked()) return;
 
-				if (e.is_blocked()) event->block();
+			if (window->self->focus)
+			{
+				View_call_text_event(window->self->focus.get(), event);
+				if (event->is_blocked()) return;
 			}
-		}
 
-		if (!event->is_blocked() && window->self->focus)
-			View_call_key_event(window->self->focus.get(), event);
+			if (synthesize_key_events)
+			{
+				KeyEvent down(KeyEvent::DOWN, event->text(), KEY_NONE);
+				KeyEvent up(  KeyEvent::UP,   event->text(), KEY_NONE);
+				Window_call_key_event(window, &down, false);
+				Window_call_key_event(window, &up,   false);
+			}
+		});
+	}
 
-		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   ||
+			prev_pointer.action() == Pointer::CANCEL;
 	}
 
 	static Pointer::ID
@@ -297,21 +665,15 @@ namespace Reflex
 	static void
 	setup_mouse_pointer (Window* window, Pointer* pointer)
 	{
-		static const uint MOUSE_BUTTONS =
-			Pointer::MOUSE_LEFT  |
-			Pointer::MOUSE_RIGHT |
-			Pointer::MOUSE_MIDDLE;
-
 		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 +684,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 +714,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,22 +740,44 @@ 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);
 		}
 	}
 
+	static void
+	reject_unpaired_up_pointers (PointerEvent* event)
+	{
+		// a canceled pointer must deliver nothing until its next down, so
+		// an up whose down was never delivered stays silent
+
+		std::vector<Pointer::ID> ids;
+		PointerEvent_each_pointer(event, [&](const auto& pointer)
+		{
+			if (pointer.action() == Pointer::UP && !pointer.down())
+				ids.emplace_back(pointer.id());
+		});
+
+		for (auto id : ids)
+			PointerEvent_erase_pointer(event, id);
+	}
+
 	static void
 	setup_pointer_event (Window* window, PointerEvent* event)
 	{
@@ -389,6 +789,8 @@ namespace Reflex
 			else
 				setup_pointer(window, &pointer);
 		}
+
+		reject_unpaired_up_pointers(event);
 	}
 
 	static void
@@ -451,20 +853,18 @@ namespace Reflex
 		ExtractedPointerIDSet* extracteds, bool* blocked,
 		Window* window, const PointerMap& pointers)
 	{
-		for (auto& [view, targets] : window->self->captures)
+		each_capture(window, [&](View* view, const CaptureTargetIDList& targets)
 		{
-			if (!view->window() || targets.empty()) continue;
-
 			PointerEvent event;
 			PointerEvent_set_captured(&event, true);
 			extract_targeted_pointers(&event, extracteds, targets, pointers);
-			if (event.empty()) continue;
+			if (event.empty()) return;
 
-			PointerEvent_update_for_capturing_view(&event, view);
-			View_call_pointer_event(const_cast<View*>(view.get()), &event);
+			PointerEvent_to_view_coord(&event, view);
+			View_call_pointer_event(view, &event);
 
 			if (event.is_blocked()) *blocked = true;
-		}
+		});
 	}
 
 	static void
@@ -502,7 +902,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,79 +961,346 @@ namespace Reflex
 		if (blocked) event->block();
 	}
 
-	void
-	Window_call_pointer_event (Window* window, PointerEvent* event)
+	static bool
+	is_inside_window (Window* window, const Point& position)
 	{
-		assert(window);
+		View* root = window->root();
+		return root && Bounds(root->frame().size()).is_include(position);
+	}
 
-		if (!event)
-			argument_error(__FILE__, __LINE__);
+	static bool
+	is_inside_window (Window* window, const Pointer& pointer)
+	{
+		// a boundary event says which side the pointer came out on and is taken
+		// at its word; the position it carries cannot be, since sdl reports the
+		// last one inside and win32 the one under a menu
+		auto action = pointer.action();
+		if (action == Pointer::ENTER) return true;
+		if (action == Pointer::LEAVE) return false;
+
+		// a pointer that ends here is nowhere afterwards: a lifted finger, or a
+		// pen taken out of hover range
+		return
+			is_inside_window(window, pointer.position()) &&
+			!is_last_pointer_event(pointer);
+	}
 
-		setup_pointer_event(window, event);
+	static Pointer::Action
+	get_window_boundary_transition (Window* window, const Pointer& pointer)
+	{
+		const Pointer* prev = pointer.prev();
+		bool  is_inside =         is_inside_window(window, pointer);
+		bool was_inside = prev && is_inside_window(window, *prev);
 
-		if (!event->empty())
-			window->on_pointer(event);
+		if ( is_inside && !was_inside) return Pointer::ENTER;
+		if (!is_inside &&  was_inside) return Pointer::LEAVE;
+		return Pointer::ACTION_NONE;
+	}
+
+	static void
+	call_pointer_window_boundary_events (
+		Window* window, const auto& pointers, Pointer::Action action)
+	{
+		for (const auto& pointer : pointers)
+		{
+			if (get_window_boundary_transition(window, pointer) != action)
+				continue;
+
+			Pointer p = pointer;
+			Pointer_set_action(&p, action);
+
+			PointerEvent event(&p, 1);
+			window->on_pointer(&event);
+			if (event.is_blocked()) continue;
+
+			if (action == Pointer::ENTER)
+				window->on_pointer_enter(&event);
+			else
+				window->on_pointer_leave(&event);
+		}
+	}
+
+	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;
 
-		if (!event->empty() && !event->is_blocked())
+		auto it = map.find(pointer.id());
+		if (
+			it == map.end() &&
+			pointer.prev() && pointer.prev()->id() != pointer.id())
 		{
-			switch ((*event)[0].action())
+			auto prev_it = map.find(pointer.prev()->id());
+			if (prev_it != map.end())
 			{
-				case Pointer::DOWN:   window->on_pointer_down(event);   break;
-				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;
-				default: break;
+				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);
 			}
 		}
 
-		if (!event->empty() && !event->is_blocked())
-			call_captured_pointer_events(window, event);
+		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 void
+	do_call_pointer_event (Window* window, PointerEvent* event)
+	{
+		auto action   = (*event)[0].action();
+		bool boundary = action == Pointer::ENTER || action == Pointer::LEAVE;
+
+		std::vector<Pointer> pointers;
+		PointerEvent_each_pointer(event, [&](const auto& p)
+		{
+			pointers.emplace_back(p);
+		});
 
-		if (!event->empty() && !event->is_blocked())
+		call_pointer_window_boundary_events(window, pointers, Pointer::ENTER);
+		call_pointer_enter_events(window, pointers);
+
+		if (!boundary)
 		{
-			PointerEvent_update_for_child_view(event, window->root());
-			View_call_pointer_event(window->root(), event);
+			uint cancels           = Window_get_pointer_cancels(*window);
+			auto block_if_canceled = [&]()
+			{
+				if (Window_get_pointer_cancels(*window) != cancels)
+					event->block();
+				return event->is_blocked();
+			};
+
+			window->on_pointer(event);
+
+			if (!block_if_canceled())
+			{
+				switch (action)
+				{
+					case Pointer::DOWN:   window->on_pointer_down(event);   break;
+					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;
+					default: break;
+				}
+			}
+
+			if (!block_if_canceled())
+				call_captured_pointer_events(window, event);
+
+			if (!block_if_canceled())
+			{
+				PointerEvent_update_for_child_view(event, window->root());
+				View_call_pointer_event(window->root(), event);
+			}
 		}
 
-		cleanup_captures(window);
+		call_pointer_leave_events(window, pointers);
+		call_pointer_window_boundary_events(window, pointers, Pointer::LEAVE);
+	}
+
+	static void
+	call_pointer_event (Window* window, PointerEvent* event)
+	{
+		Application_guard([&]()
+		{
+			setup_pointer_event(window, event);
+			if (!event->empty())
+				do_call_pointer_event(window, event);
+
+			cleanup_captures(window);
+		});
 	}
 
 	void
-	Window_call_wheel_event (Window* window, WheelEvent* event)
+	Window_call_pointer_event (Window* window, PointerEvent* event)
 	{
 		assert(window);
 
 		if (!event)
 			argument_error(__FILE__, __LINE__);
 
-		if (!event->is_blocked())
-			window->on_wheel(event);
+		const Window::Data& self = *window->self;
 
-		if (!event->is_blocked())
-			View_call_wheel_event(window->root(), event);
+		if (is_pointer_through_by_alpha(self) && !event->empty())
+		{
+			// with pointers going through by alpha, update_pointer_through()
+			// decides when the pointer is in the content area, so the native
+			// enter and leave at the edge are dropped, and so is any event in
+			// the content area before it says the pointer is there: macos moves
+			// the key window's pointer wherever it is, ignored or not, and a
+			// move from the titlebar lands a frame before the pixel under it
+			// is judged
+
+			const auto& pointer0 = (*event)[0];
+			auto action          = pointer0.action();
+			if (action == Pointer::ENTER || action == Pointer::LEAVE)
+				return;
+
+			if (
+				!Xot::has_flag(self.flags, Window::Data::POINTER_THROUGH_ENTERED) &&
+				is_inside_window(window, pointer0.position()))
+			{
+				return;
+			}
+		}
+
+		call_pointer_event(window, event);
 	}
 
-	static void
-	Window_call_note_event (Window* window, NoteEvent* event)
+	void
+	Window_call_wheel_event (Window* window, WheelEvent* event)
 	{
 		assert(window);
 
 		if (!event)
 			argument_error(__FILE__, __LINE__);
 
-		for (auto& [view, targets] : window->self->captures)
+		Application_guard([&]()
 		{
-			if (
-				!view->window() ||
-				!is_capturing(view.get(), targets, View::CAPTURE_MIDI))
+			if (!event->is_blocked())
+				window->on_wheel(event);
+
+			if (!event->is_blocked())
+				View_call_wheel_event(window->root(), event);
+		});
+	}
+
+	void
+	Window_call_file_event (Window* window, FileEvent* event)
+	{
+		if (!window)
+			argument_error(__FILE__, __LINE__);
+		if (!event)
+			argument_error(__FILE__, __LINE__);
+
+		Application_guard([&]()
+		{
+			window->on_file(event);
+			if (event->is_blocked()) return;
+
+			switch (event->action())
 			{
-				continue;
+				case FileEvent::OPEN: window->on_file_open(event); break;
+				case FileEvent::SAVE: window->on_file_save(event); break;
+				default: break;
 			}
+		});
+	}
+
+	static void
+	Window_call_note_event (Window* window, NoteEvent* event)
+	{
+		assert(window);
+
+		if (!event)
+			argument_error(__FILE__, __LINE__);
 
+		each_capturing_view(window, View::CAPTURE_MIDI, [&](View* view)
+		{
 			NoteEvent e = event->dup();
 			NoteEvent_set_captured(&e, true);
-			View_call_note_event(const_cast<View*>(view.get()), &e);
-		}
+			View_call_note_event(view, &e);
+		});
 
 		if (!event->is_blocked())
 			window->on_note(event);
@@ -660,19 +1327,12 @@ namespace Reflex
 		if (!event)
 			argument_error(__FILE__, __LINE__);
 
-		for (auto& [view, targets] : window->self->captures)
+		each_capturing_view(window, View::CAPTURE_MIDI, [&](View* view)
 		{
-			if (
-				!view->window() ||
-				!is_capturing(view.get(), targets, View::CAPTURE_MIDI))
-			{
-				continue;
-			}
-
 			ControlChangeEvent e = event->dup();
 			ControlChangeEvent_set_captured(&e, true);
-			View_call_control_change_event(const_cast<View*>(view.get()), &e);
-		}
+			View_call_control_change_event(view, &e);
+		});
 
 		if (!event->is_blocked())
 			window->on_control_change(event);
@@ -689,38 +1349,34 @@ namespace Reflex
 		if (!event)
 			argument_error(__FILE__, __LINE__);
 
-		for (auto& [view, targets] : window->self->captures)
+		Application_guard([&]()
 		{
-			if (
-				!view->window() ||
-				!is_capturing(view.get(), targets, View::CAPTURE_MIDI))
+			each_capturing_view(window, View::CAPTURE_MIDI, [&](View* view)
 			{
-				continue;
-			}
-
-			MIDIEvent e = event->dup();
-			MIDIEvent_set_captured(&e, true);
-			View_call_midi_event(const_cast<View*>(view.get()), &e);
-		}
+				MIDIEvent e = event->dup();
+				MIDIEvent_set_captured(&e, true);
+				View_call_midi_event(view, &e);
+			});
 
-		if (!event->is_blocked())
-			window->on_midi(event);
+			if (!event->is_blocked())
+				window->on_midi(event);
 
-		if (!event->is_blocked() && window->self->focus)
-			View_call_midi_event(window->self->focus.get(), event);
+			if (!event->is_blocked() && window->self->focus)
+				View_call_midi_event(window->self->focus.get(), event);
 
-		if (!event->is_blocked())
-		{
-			NoteEvent note_e;
-			if (MIDIEvent_to_note_event(&note_e, *event))
-				Window_call_note_event(window, &note_e);
+			if (!event->is_blocked())
+			{
+				NoteEvent note_e;
+				if (MIDIEvent_to_note_event(&note_e, *event))
+					Window_call_note_event(window, &note_e);
 
-			ControlChangeEvent cc_e;
-			if (MIDIEvent_to_control_change_event(&cc_e, *event))
-				Window_call_control_change_event(window, &cc_e);
-		}
+				ControlChangeEvent cc_e;
+				if (MIDIEvent_to_control_change_event(&cc_e, *event))
+					Window_call_control_change_event(window, &cc_e);
+			}
 
-		cleanup_captures(window);
+			cleanup_captures(window);
+		});
 	}
 
 
@@ -782,10 +1438,14 @@ namespace Reflex
 	void
 	Window::close (bool force)
 	{
+		if (!*this) return;
+
 		Event e;
 		on_close(&e);
 		if (!force && e.is_blocked()) return;
 
+		self->hovered_views.clear();
+
 		View_set_window(self->root.get(), NULL);
 
 		Window_close(this);
@@ -794,7 +1454,7 @@ namespace Reflex
 	void
 	Window::redraw ()
 	{
-		self->redraw = true;
+		Xot::add_flag(&self->flags, Data::REDRAW);
 	}
 
 	Point
@@ -809,6 +1469,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)
 	{
@@ -840,17 +1506,63 @@ namespace Reflex
 	}
 
 	void
-	Window::set_flag (uint flags)
+	Window::set_menu (Menu* menu)
 	{
-		Window_set_flags(this, flags);
+		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_pointer_through_alpha (float alpha)
+	{
+		if (alpha < 0 || 1 < alpha)
+			argument_error(__FILE__, __LINE__);
+
+		if (alpha == self->pointer_through_alpha)
+			return;
+
+		self->pointer_through_alpha = alpha;
+		apply_pointer_through(this);
+	}
+
+	float
+	Window::pointer_through_alpha () const
+	{
+		return self->pointer_through_alpha;
+	}
+
+	static const uint PUBLIC_FLAGS = (Window::FLAG_LAST << 1) - 1;
+
+	void
+	Window::set_flags (uint flags)
+	{
+		flags &= PUBLIC_FLAGS;
+		flags |= self->flags & ~PUBLIC_FLAGS;
+		if (flags == self->flags)
+			return;
+
+		Window_set_flags(this, flags);
 		self->flags = flags;
+
+		apply_pointer_through(this);
 	}
 
 	uint
 	Window::flags () const
 	{
-		return self->flags;
+		return self->flags & PUBLIC_FLAGS;
 	}
 
 	void
@@ -858,10 +1570,7 @@ namespace Reflex
 	{
 		uint value = self->flags;
 		Xot::add_flag(&value, flags);
-
-		Window_set_flags(this, value);
-
-		self->flags = value;
+		set_flags(value);
 	}
 
 	void
@@ -869,16 +1578,13 @@ namespace Reflex
 	{
 		uint value = self->flags;
 		Xot::remove_flag(&value, flags);
-
-		Window_set_flags(this, value);
-
-		self->flags = value;
+		set_flags(value);
 	}
 
 	bool
 	Window::has_flag (uint flags) const
 	{
-		return Xot::has_flag(self->flags, flags);
+		return Xot::has_flag(this->flags(), flags);
 	}
 
 	Screen
@@ -924,27 +1630,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)
 	{
 	}
 
@@ -983,6 +1689,21 @@ namespace Reflex
 	{
 	}
 
+	void
+	Window::on_text (TextEvent* e)
+	{
+	}
+
+	void
+	Window::on_text_preedit (TextEvent* e)
+	{
+	}
+
+	void
+	Window::on_text_commit (TextEvent* e)
+	{
+	}
+
 	void
 	Window::on_pointer (PointerEvent* e)
 	{
@@ -1008,11 +1729,36 @@ namespace Reflex
 	{
 	}
 
+	void
+	Window::on_pointer_enter (PointerEvent* e)
+	{
+	}
+
+	void
+	Window::on_pointer_leave (PointerEvent* e)
+	{
+	}
+
 	void
 	Window::on_wheel (WheelEvent* e)
 	{
 	}
 
+	void
+	Window::on_file (FileEvent* e)
+	{
+	}
+
+	void
+	Window::on_file_open (FileEvent* e)
+	{
+	}
+
+	void
+	Window::on_file_save (FileEvent* e)
+	{
+	}
+
 	void
 	Window::on_midi (MIDIEvent* e)
 	{