reflexion 0.1.22 → 0.1.23

data/src/window.cpp

@@ -1,14 +1,25 @@
 #include "window.h"
 
 
+#include <set>
 #include "reflex/exception.h"
 #include "view.h"
+#include "event.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;
+
+
 	void
 	Window_set_focus (Window* window, View* view)
 	{
@@ -36,6 +47,80 @@ namespace Reflex
 		}
 	}
 
+	namespace global
+	{
+
+		static Window_CreateRootViewFun create_root_view_fun = NULL;
+
+	}// global
+
+	void
+	Window_set_create_root_view_fun (Window_CreateRootViewFun fun)
+	{
+		global::create_root_view_fun = fun;
+	}
+
+	static View*
+	create_root_view ()
+	{
+		return global::create_root_view_fun
+			?	global::create_root_view_fun()
+			:	new View();
+	}
+
+	void
+	Window_register_capture (Window* window, View* view, Pointer::ID target)
+	{
+		assert(window);
+
+		if (!view)
+			argument_error(__FILE__, __LINE__);
+
+		if (view->window() != window)
+			invalid_state_error(__FILE__, __LINE__);
+
+		if (target < 0) return;
+
+		auto& targets = window->self->captures[view];
+		if (std::find(targets.begin(), targets.end(), target) != targets.end())
+			return;
+
+		targets.insert(
+			target == CAPTURE_ALL ? targets.begin() : targets.end(),
+			target);
+	}
+
+	void
+	Window_unregister_capture (Window* window, View* view, Pointer::ID target)
+	{
+		assert(window);
+
+		if (!view)
+			argument_error(__FILE__, __LINE__);
+
+		auto captures_it = window->self->captures.find(view);
+		if (captures_it == window->self->captures.end()) return;
+
+		auto& targets   = captures_it->second;
+		auto targets_it = std::find(targets.begin(), targets.end(), target);
+		if (targets_it == targets.end()) return;
+
+		targets.erase(targets_it);
+	}
+
+	static void
+	cleanup_captures (Window* window)
+	{
+		assert(window);
+
+		auto& caps = window->self->captures;
+		for (auto it = caps.begin(), end = caps.end(); it != end;)
+		{
+			auto t = it++;
+			if (t->second.empty()) caps.erase(t);
+		}
+	}
+
 	void
 	Window_call_draw_event (Window* window, DrawEvent* event)
 	{
@@ -63,66 +148,252 @@ namespace Reflex
 		painter->end();
 	}
 
-	namespace global
+	static bool
+	is_capturing (
+		const View* view, const CaptureTargetIDList& targets, View::Capture type)
 	{
+		return
+			!targets.empty() &&
+			targets[0] == CAPTURE_ALL &&
+			(view->capture() & type) == type;
+	}
 
-		static Window_CreateRootViewFun create_root_view_fun = NULL;
+	void
+	Window_call_key_event (Window* window, KeyEvent* event)
+	{
+		assert(window);
 
-	}// global
+		if (!event)
+			argument_error(__FILE__, __LINE__);
 
-	void
-	Window_set_create_root_view_fun (Window_CreateRootViewFun fun)
+		window->on_key(event);
+
+		switch (event->type)
+		{
+			case KeyEvent::DOWN: window->on_key_down(event); break;
+			case KeyEvent::UP:   window->on_key_up(event);   break;
+			default: break;
+		}
+
+		for (auto& [view, targets] : window->self->captures)
+		{
+			if (!is_capturing(view.get(), targets, View::CAPTURE_KEY))
+				continue;
+
+			KeyEvent e = *event;
+			e.captured = true;
+			View_call_key_event(const_cast<View*>(view.get()), e);
+		}
+
+		if (window->self->focus)
+			View_call_key_event(window->self->focus.get(), *event);
+
+		cleanup_captures(window);
+	}
+
+	static void
+	get_views_capturing_all_pointers (Window* window, ViewList* result)
 	{
-		global::create_root_view_fun = fun;
+		assert(window && result);
+
+		result->clear();
+		for (const auto& [view, targets] : window->self->captures)
+		{
+			if (is_capturing(view.get(), targets, View::CAPTURE_POINTER))
+				result->emplace_back(view);
+		}
 	}
 
-	static View*
-	create_root_view ()
+	static void
+	capture_all_pointers (
+		Window* window, const PointerEvent& event, ViewList& views_capturing_all)
 	{
-		return global::create_root_view_fun
-			?	global::create_root_view_fun()
-			:	new View();
+		assert(window);
+
+		if (views_capturing_all.empty()) return;
+
+		PointerEvent_each_pointer(&event, [&](const auto& pointer)
+		{
+			if (pointer.action() == Pointer::DOWN)
+			{
+				for (auto& view : views_capturing_all)
+					Window_register_capture(window, view, pointer.id());
+			}
+		});
 	}
 
-	void
-	View_register_capture (View* view)
+	static void
+	extract_pointer (
+		PointerEvent* event, ExtractedPointerIDSet* extracteds,
+		const Pointer& pointer)
 	{
-		if (!view)
-			argument_error(__FILE__, __LINE__);
+		assert(event && extracteds);
+
+		PointerEvent_add_pointer(event, pointer);
+		extracteds->insert(pointer.id());
+	}
 
-		const Window* window = view->window();
-		if (!window)
-			invalid_state_error(__FILE__, __LINE__, "this view does not belong to any Window.");
+	static void
+	extract_targeted_pointers (
+		PointerEvent* event, ExtractedPointerIDSet* extracteds,
+		const CaptureTargetIDList& targets, const PointerMap& pointers)
+	{
+		assert(event && event->empty() && extracteds);
 
-		window->self->capturing_views[view] = true;
+		for (auto pointer_id : targets)
+		{
+			auto it = pointers.find(pointer_id);
+			if (it != pointers.end())
+				extract_pointer(event, extracteds, it->second);
+		}
 	}
 
-	void
-	View_unregister_capture (View* view)
+	static void
+	capture_targeted_pointers_and_call_events (
+		ExtractedPointerIDSet* extracteds,
+		Window* window, const PointerMap& pointers)
 	{
-		if (!view)
-			argument_error(__FILE__, __LINE__);
+		assert(extracteds && window);
 
-		const Window* window = view->window();
-		if (!window) return;
+		for (auto& [view, targets] : window->self->captures)
+		{
+			if (targets.empty()) continue;
 
-		auto it = window->self->capturing_views.find(view);
-		if (it == window->self->capturing_views.end()) return;
+			PointerEvent e(true);
+			extract_targeted_pointers(&e, extracteds, targets, pointers);
+			if (e.empty()) continue;
 
-		it->second = false;
+			PointerEvent_update_for_capturing_view(&e, view);
+			View_call_pointer_event(const_cast<View*>(view.get()), e);
+		}
 	}
 
 	static void
-	cleanup_capturing_views (Window* window)
+	extract_hovering_pointers (
+		PointerEvent* event, ExtractedPointerIDSet* extracteds,
+		const PointerMap& pointers)
 	{
-		auto end = window->self->capturing_views.end();
-		for (auto it = window->self->capturing_views.begin(); it != end;)
+		assert(event && event->empty() && extracteds);
+
+		for (const auto& [_, pointer] : pointers)
 		{
-			auto t = it++;
-			if (!t->second) window->self->capturing_views.erase(t);
+			// dragging pointers is captured as a targeted
+			if (pointer.is_drag()) continue;
+
+			extract_pointer(event, extracteds, pointer);
+		}
+	}
+
+	static void
+	capture_hovering_pointers_and_call_events (
+		ExtractedPointerIDSet* extracteds,
+		const ViewList& views_capturing_all, const PointerMap& pointers)
+	{
+		assert(extracteds);
+
+		if (views_capturing_all.empty()) return;
+
+		PointerEvent event(true);
+		extract_hovering_pointers(&event, extracteds, pointers);
+		if (event.empty()) return;
+
+		for (auto& view : views_capturing_all)
+		{
+			PointerEvent e = event;
+			PointerEvent_update_for_capturing_view(&e, view);
+			View_call_pointer_event(const_cast<View*>(view.get()), e);
 		}
 	}
 
+	static void
+	erase_extracted_pointers (
+		PointerMap* pointers, const ExtractedPointerIDSet& extracteds)
+	{
+		assert(pointers);
+
+		for (auto id : extracteds)
+		{
+			auto it = pointers->find(id);
+			if (it != pointers->end()) pointers->erase(it);
+		}
+	}
+
+	static void
+	erase_extracted_pointers (
+		PointerEvent* event, const ExtractedPointerIDSet& extracteds)
+	{
+		assert(event);
+
+		for (auto id : extracteds)
+			PointerEvent_erase_pointer(event, id);
+	}
+
+	static void
+	call_captured_pointer_events (Window* window, PointerEvent* event)
+	{
+		assert(window && event);
+
+		ViewList views_capturing_all;
+		get_views_capturing_all_pointers(window, &views_capturing_all);
+		capture_all_pointers(window, *event, views_capturing_all);
+
+		PointerMap pointers;
+		PointerEvent_each_pointer(event, [&](const auto& pointer)
+		{
+			if (pointer.id() >= 0) pointers[pointer.id()] = pointer;
+		});
+
+		ExtractedPointerIDSet extracteds;
+		capture_targeted_pointers_and_call_events(&extracteds, window, pointers);
+		erase_extracted_pointers(&pointers, extracteds);
+
+		capture_hovering_pointers_and_call_events(&extracteds, views_capturing_all, pointers);
+		erase_extracted_pointers(event, extracteds);
+	}
+
+	void
+	Window_call_pointer_event (Window* window, PointerEvent* event)
+	{
+		assert(window);
+
+		if (!event)
+			argument_error(__FILE__, __LINE__);
+
+		window->on_pointer(event);
+
+		switch ((*event)[0].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;
+		}
+
+		call_captured_pointer_events(window, event);
+
+		if (!event->empty())
+		{
+			PointerEvent_update_for_child_view(event, window->root());
+			View_call_pointer_event(window->root(), *event);
+		}
+
+		cleanup_captures(window);
+	}
+
+	void
+	Window_call_wheel_event (Window* window, WheelEvent* event)
+	{
+		assert(window);
+
+		if (!event)
+			argument_error(__FILE__, __LINE__);
+
+		window->on_wheel(event);
+
+		View_call_wheel_event(window->root(), *event);
+	}
+
 
 	Window::Window ()
 	:	self(Window_create_data())
@@ -191,6 +462,18 @@ namespace Reflex
 		self->redraw = true;
 	}
 
+	Point
+	Window::from_screen (const Point& point) const
+	{
+		return point - frame().position();
+	}
+
+	Point
+	Window::to_screen (const Point& point) const
+	{
+		return point + frame().position();
+	}
+
 	void
 	Window::set_title (const char* title)
 	{
@@ -275,20 +558,6 @@ namespace Reflex
 		return const_cast<Window*>(this)->painter();
 	}
 
-	Point
-	Window::from_screen (const Point& point) const
-	{
-		not_implemented_error(__FILE__, __LINE__);
-		return 0;
-	}
-
-	Point
-	Window::to_screen (const Point& point) const
-	{
-		not_implemented_error(__FILE__, __LINE__);
-		return 0;
-	}
-
 	void
 	Window::on_show (Event* e)
 	{
@@ -327,28 +596,6 @@ namespace Reflex
 	void
 	Window::on_key (KeyEvent* e)
 	{
-		if (!e)
-			argument_error(__FILE__, __LINE__);
-
-		switch (e->type)
-		{
-			case KeyEvent::DOWN: on_key_down(e); break;
-			case KeyEvent::UP:   on_key_up(e);   break;
-			case KeyEvent::NONE:                 break;
-		}
-
-		auto end = self->capturing_views.end();
-		for (auto it = self->capturing_views.begin(); it != end; ++it)
-		{
-			KeyEvent event = *e;
-			event.capture = true;
-			View_call_key_event(const_cast<View*>(it->first.get()), event);
-		}
-
-		if (self->focus)
-			View_call_key_event(self->focus.get(), *e);
-
-		cleanup_capturing_views(this);
 	}
 
 	void
@@ -364,30 +611,6 @@ namespace Reflex
 	void
 	Window::on_pointer (PointerEvent* e)
 	{
-		if (!e)
-			argument_error(__FILE__, __LINE__);
-
-		switch (e->type)
-		{
-			case PointerEvent::DOWN: on_pointer_down(e); break;
-			case PointerEvent::UP:   on_pointer_up(e);   break;
-			case PointerEvent::MOVE: on_pointer_move(e); break;
-			case PointerEvent::NONE:                     break;
-		}
-
-		auto end = self->capturing_views.end();
-		for (auto it = self->capturing_views.begin(); it != end; ++it)
-		{
-			PointerEvent event = *e;
-			event.capture = true;
-			for (size_t i = 0; i < event.size; ++i)
-				event[i] = it->first.get()->from_window(event[i]);
-			View_call_pointer_event(const_cast<View*>(it->first.get()), event);
-		}
-
-		View_call_pointer_event(root(), *e);
-
-		cleanup_capturing_views(this);
 	}
 
 	void
@@ -406,12 +629,13 @@ namespace Reflex
 	}
 
 	void
-	Window::on_wheel (WheelEvent* e)
+	Window::on_pointer_cancel (PointerEvent* e)
 	{
-		if (!e)
-			argument_error(__FILE__, __LINE__);
+	}
 
-		View_call_wheel_event(root(), *e);
+	void
+	Window::on_wheel (WheelEvent* e)
+	{
 	}
 
 	Window::operator bool () const

data/src/window.h

@@ -4,22 +4,29 @@
 #define __REFLEX_SRC_WINDOW_H__
 
 
+#include <vector>
 #include <map>
 #include <xot/time.h>
 #include <rays/point.h>
 #include <rays/painter.h>
 #include <reflex/window.h>
 #include <reflex/view.h>
+#include "pointer.h"
 
 
 namespace Reflex
 {
 
 
+	enum {CAPTURE_ALL = INT_MAX};
+
+
 	struct Window::Data
 	{
 
-		typedef std::map<View::Ref, bool> CapturingViews;
+		typedef std::vector<Pointer::ID>                 CaptureTargetIDList;
+
+		typedef std::map<View::Ref, CaptureTargetIDList> CaptureMap;
 
 		int hide_count = 1;
 
@@ -33,7 +40,7 @@ namespace Reflex
 
 		double prev_time_update, prev_time_draw, prev_fps = 0;
 
-		CapturingViews capturing_views;
+		CaptureMap captures;
 
 		Data ()
 		{
@@ -84,7 +91,19 @@ namespace Reflex
 
 	void Window_set_focus (Window* window, View* view);
 
-	void Window_call_draw_event (Window* window, DrawEvent* event);
+	void Window_register_capture (
+		Window* window, View* view, Pointer::ID target = CAPTURE_ALL);
+
+	void Window_unregister_capture (
+		Window* window, View* view, Pointer::ID target = CAPTURE_ALL);
+
+	void Window_call_draw_event    (Window* window, DrawEvent*    event);
+
+	void Window_call_key_event     (Window* window, KeyEvent*     event);
+
+	void Window_call_pointer_event (Window* window, PointerEvent* event);
+
+	void Window_call_wheel_event   (Window* window, WheelEvent*   event);
 
 	float Window_get_pixel_density (const Window& window);
 

data/test/test_event.rb

@@ -10,11 +10,25 @@ class TestEvent < Test::Unit::TestCase
     Reflex::Event.new
   end
 
+  def test_dup()
+    e1 = event
+    e2 = e1.dup
+    e1.block
+    e3 = e1.dup
+    assert_equal true,  e1.blocked?
+    assert_equal false, e2.blocked?
+    assert_equal true,  e3.blocked?
+  end
+
   def test_block()
     e = event
-    assert_equal false, e.block?
+    assert_equal false, e.blocked?
     e.block
-    assert_equal true, e.block?
+    assert_equal true,  e.blocked?
+  end
+
+  def test_time()
+    assert_in_delta Time.now.to_f, event.time, 0.001
   end
 
 end# TestEvent