reflexion 0.1.21 → 0.1.25

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)
 	{
@@ -20,22 +31,95 @@ namespace Reflex
 
 		window->self->focus.reset(view);
 
-		FocusEvent e(FocusEvent::BLUR, view, current);
-
 		if (current)
 		{
+			FocusEvent e(FocusEvent::BLUR, view, current);
 			current->on_focus(&e);
 			current->redraw();
 		}
 
 		if (view)
 		{
-			e.type = FocusEvent::FOCUS;
+			FocusEvent e(FocusEvent::FOCUS, view, current);
 			view->on_focus(&e);
 			view->redraw();
 		}
 	}
 
+	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)
 	{
@@ -48,8 +132,8 @@ namespace Reflex
 
 		Rays::Bounds frame = window->frame();
 
-		event->painter = painter;
-		event->bounds.reset(0, 0, frame.width, frame.height);
+		DrawEvent_set_painter(event, painter);
+		DrawEvent_set_bounds(event, Bounds(0, 0, frame.width, frame.height));
 
 		painter->begin();
 		painter->push_state();
@@ -57,72 +141,265 @@ namespace Reflex
 
 		window->on_draw(event);
 		if (!event->is_blocked())
-			Reflex::View_draw_tree(window->root(), *event, 0, frame.move_to(0));
+			Reflex::View_draw_tree(window->root(), event, 0, frame.move_to(0));
 
 		painter->pop_state();
 		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)
+		for (auto& [view, targets] : window->self->captures)
+		{
+			if (!is_capturing(view.get(), targets, View::CAPTURE_KEY))
+				continue;
+
+			KeyEvent e = event->dup();
+			KeyEvent_set_captured(&e, 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);
+
+		if (event->is_blocked()) return;
+
+		window->on_key(event);
+
+		switch (event->action())
+		{
+			case KeyEvent::DOWN: window->on_key_down(event); break;
+			case KeyEvent::UP:   window->on_key_up(event);   break;
+			default: break;
+		}
+	}
+
+	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);
 
-		const Window* window = view->window();
-		if (!window)
-			invalid_state_error(__FILE__, __LINE__, "this view does not belong to any Window.");
+		PointerEvent_add_pointer(event, pointer);
+		extracteds->insert(pointer.id());
+	}
 
-		window->self->capturing_views[view] = true;
+	static void
+	extract_targeted_pointers (
+		PointerEvent* event, ExtractedPointerIDSet* extracteds,
+		const CaptureTargetIDList& targets, const PointerMap& pointers)
+	{
+		assert(event && event->empty() && extracteds);
+
+		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 event;
+			PointerEvent_set_captured(&event, true);
+			extract_targeted_pointers(&event, extracteds, targets, pointers);
+			if (event.empty()) continue;
 
-		it->second = false;
+			PointerEvent_update_for_capturing_view(&event, view);
+			View_call_pointer_event(const_cast<View*>(view.get()), &event);
+		}
 	}
 
 	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;
+		PointerEvent_set_captured(&event, true);
+		extract_hovering_pointers(&event, extracteds, pointers);
+		if (event.empty()) return;
+
+		for (auto& view : views_capturing_all)
+		{
+			PointerEvent e = event.dup();
+			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__);
+
+		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);
+
+		if (event->empty() || event->is_blocked())
+			return;
+
+		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;
 		}
 	}
 
+	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 +468,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)
 	{
@@ -230,7 +519,7 @@ namespace Reflex
 	bool
 	Window::is_resizable () const
 	{
-		Window_is_resizable(*this);
+		return Window_is_resizable(*this);
 	}
 
 	bool
@@ -275,20 +564,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 +602,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 +617,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 +635,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/src/world.cpp

@@ -251,8 +251,9 @@ namespace Reflex
 		if (!View_is_active(*s1->owner()) || !View_is_active(*s2->owner()))
 			return;
 
-		Shape_call_contact_event(s1, ContactEvent(ContactEvent::BEGIN, s2));
-		Shape_call_contact_event(s2, ContactEvent(ContactEvent::BEGIN, s1));
+		ContactEvent e1(ContactEvent::BEGIN, s2), e2(ContactEvent::BEGIN, s1);
+		Shape_call_contact_event(s1, &e1);
+		Shape_call_contact_event(s2, &e2);
 	}
 
 	void
@@ -267,8 +268,9 @@ namespace Reflex
 		if (!View_is_active(*s1->owner()) || !View_is_active(*s2->owner()))
 			return;
 
-		Shape_call_contact_event(s1, ContactEvent(ContactEvent::END, s2));
-		Shape_call_contact_event(s2, ContactEvent(ContactEvent::END, s1));
+		ContactEvent e1(ContactEvent::END, s2), e2(ContactEvent::END, s1);
+		Shape_call_contact_event(s1, &e1);
+		Shape_call_contact_event(s2, &e2);
 	}
 
 

data/test/helper.rb

@@ -12,7 +12,7 @@ require 'reflex'
 include Xot::Test
 
 
-unless $REFLEX_NOAUTOINIT
-  def Rays.fin! () end
-  def Reflex.fin! () end
+unless defined?($REFLEX_NOAUTOINIT) && $REFLEX_NOAUTOINIT
+  def Rays.fin!() end
+  def Reflex.fin!() end
 end

data/test/test_application.rb

@@ -8,7 +8,7 @@ class TestApplication < Test::Unit::TestCase
 
   @@app = Reflex::Application.new
 
-  def test_name ()
+  def test_name()
     assert_equal '', @@app.name
     @@app.name = 'AppName'
     assert_equal 'AppName', @@app.name

data/test/test_capture_event.rb

@@ -6,13 +6,29 @@ require_relative 'helper'
 
 class TestCaptureEvent < Test::Unit::TestCase
 
-  def event (*args)
-    Reflex::CaptureEvent.new *args.map {|arg|
-      Reflex::View.capture_flag.symbols2bits *arg
-    }
+  def event(*args)
+    Reflex::CaptureEvent.new(*args.map {|arg|
+      Reflex::View.capture_flag.symbols2bits(*arg)
+    })
   end
 
-  def test_begin ()
+  def test_initialize()
+    e = event :key, :pointer
+    assert_equal [:key],     e.begin
+    assert_equal [:pointer], e.end
+  end
+
+  def test_dup()
+    e1 = event :key, :pointer
+    e2 = e1.dup
+    e1.block
+    e3 = e1.dup
+    assert_true  e1.blocked?
+    assert_false e2.blocked?
+    assert_true  e3.blocked?
+  end
+
+  def test_begin()
     c = event [:key, :pointer], []
     assert_equal [:key, :pointer], c.begin
     assert_equal true, c.begin?(:key)
@@ -26,7 +42,7 @@ class TestCaptureEvent < Test::Unit::TestCase
     assert_equal false, c.begin?(:all)
   end
 
-  def test_end ()
+  def test_end()
     c = event [], [:key, :pointer]
     assert_equal [:key, :pointer], c.end
     assert_equal true, c.end?(:key)