reflexion 0.1.23 → 0.1.26

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

data/src/window.cpp

@@ -31,17 +31,16 @@ 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();
 		}
@@ -133,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();
@@ -142,7 +141,7 @@ 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();
@@ -168,7 +167,7 @@ namespace Reflex
 
 		window->on_key(event);
 
-		switch (event->type)
+		switch (event->action())
 		{
 			case KeyEvent::DOWN: window->on_key_down(event); break;
 			case KeyEvent::UP:   window->on_key_up(event);   break;
@@ -180,13 +179,13 @@ namespace Reflex
 			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);
+			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);
+			View_call_key_event(window->self->focus.get(), event);
 
 		cleanup_captures(window);
 	}
@@ -259,12 +258,13 @@ namespace Reflex
 		{
 			if (targets.empty()) continue;
 
-			PointerEvent e(true);
-			extract_targeted_pointers(&e, extracteds, targets, pointers);
-			if (e.empty()) continue;
+			PointerEvent event;
+			PointerEvent_set_captured(&event, true);
+			extract_targeted_pointers(&event, extracteds, targets, pointers);
+			if (event.empty()) continue;
 
-			PointerEvent_update_for_capturing_view(&e, view);
-			View_call_pointer_event(const_cast<View*>(view.get()), e);
+			PointerEvent_update_for_capturing_view(&event, view);
+			View_call_pointer_event(const_cast<View*>(view.get()), &event);
 		}
 	}
 
@@ -293,15 +293,16 @@ namespace Reflex
 
 		if (views_capturing_all.empty()) return;
 
-		PointerEvent event(true);
+		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;
+			PointerEvent e = event.dup();
 			PointerEvent_update_for_capturing_view(&e, view);
-			View_call_pointer_event(const_cast<View*>(view.get()), e);
+			View_call_pointer_event(const_cast<View*>(view.get()), &e);
 		}
 	}
 
@@ -375,7 +376,7 @@ namespace Reflex
 		if (!event->empty())
 		{
 			PointerEvent_update_for_child_view(event, window->root());
-			View_call_pointer_event(window->root(), *event);
+			View_call_pointer_event(window->root(), event);
 		}
 
 		cleanup_captures(window);
@@ -391,7 +392,7 @@ namespace Reflex
 
 		window->on_wheel(event);
 
-		View_call_wheel_event(window->root(), *event);
+		View_call_wheel_event(window->root(), event);
 	}
 
 
@@ -409,9 +410,7 @@ namespace Reflex
 
 	Window::~Window ()
 	{
-		//close();
-
-		View_set_window(self->root.get(), NULL);
+		//close(true);
 	}
 
 	void
@@ -447,11 +446,14 @@ namespace Reflex
 	}
 
 	void
-	Window::close ()
+	Window::close (bool force)
 	{
 		Event e;
 		on_close(&e);
-		if (e.is_blocked()) return;
+		if (!force && e.is_blocked()) return;
+
+		View_set_window(self->root.get(), NULL);
+		self->root.reset();
 
 		Window_close(this);
 	}

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/test_capture_event.rb

@@ -12,6 +12,22 @@ class TestCaptureEvent < Test::Unit::TestCase
     })
   end
 
+  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

data/test/test_contact_event.rb

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+
+
+require_relative 'helper'
+
+
+class TestContactEvent < Test::Unit::TestCase
+
+  def event(*args)
+    Reflex::ContactEvent.new(*args)
+  end
+
+  def shape()
+    Reflex::RectShape.new
+  end
+
+  def view(*args)
+    Reflex::View.new(*args)
+  end
+
+  def test_initialize()
+    s, v    = shape, view
+    v.shape = s# attach to view
+    e       = event Reflex::ContactEvent::BEGIN, s
+    assert_equal :begin, e.action
+    assert_equal s,      e.shape
+    assert_equal v,      e.view
+  end
+
+  def test_dup()
+    e1 = event Reflex::ContactEvent::BEGIN, shape
+    e2 = e1.dup
+    e1.block
+    e3 = e1.dup
+    assert_true  e1.blocked?
+    assert_false e2.blocked?
+    assert_true  e3.blocked?
+  end
+
+end# TestContactEvent