reflexion 0.1.23 → 0.1.24

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();
@@ -166,29 +165,31 @@ namespace Reflex
 		if (!event)
 			argument_error(__FILE__, __LINE__);
 
-		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);
+			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);
+
+		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
@@ -259,12 +260,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 +295,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);
 		}
 	}
 
@@ -359,6 +362,19 @@ namespace Reflex
 		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())
@@ -369,16 +385,6 @@ namespace Reflex
 			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
@@ -391,7 +397,7 @@ namespace Reflex
 
 		window->on_wheel(event);
 
-		View_call_wheel_event(window->root(), *event);
+		View_call_wheel_event(window->root(), event);
 	}
 
 

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

data/test/test_draw_event.rb

@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*-
+
+
+require_relative 'helper'
+
+
+class TestDrawEvent < Test::Unit::TestCase
+
+  def event(*args)
+    Reflex::DrawEvent.new(*args)
+  end
+
+  def bounds(*args)
+    Rays::Bounds.new(*args)
+  end
+
+  def test_initialize()
+    e = event 1, 2
+    assert_nil              e.painter
+    assert_equal bounds(0), e.bounds
+    assert_equal 1,         e.dt
+    assert_equal 2,         e.fps
+  end
+
+  def test_dup()
+    e1 = event 1, 2
+    e2 = e1.dup
+    e1.block
+    e3 = e1.dup
+    assert_true  e1.blocked?
+    assert_false e2.blocked?
+    assert_true  e3.blocked?
+  end
+
+end# TestDrawEvent

data/test/test_event.rb

@@ -7,7 +7,7 @@ require_relative 'helper'
 class TestEvent < Test::Unit::TestCase
 
   def event()
-    Reflex::Event.new
+    Reflex::UpdateEvent.new 0, 0
   end
 
   def test_dup()
@@ -15,16 +15,30 @@ class TestEvent < Test::Unit::TestCase
     e2 = e1.dup
     e1.block
     e3 = e1.dup
-    assert_equal true,  e1.blocked?
-    assert_equal false, e2.blocked?
-    assert_equal true,  e3.blocked?
+    assert_true  e1.blocked?
+    assert_false e2.blocked?
+    assert_true  e3.blocked?
   end
 
   def test_block()
     e = event
-    assert_equal false, e.blocked?
+    assert_false e.blocked?
     e.block
-    assert_equal true,  e.blocked?
+    assert_true  e.blocked?
+  end
+
+  def test_block_propagation()
+    e1 = event
+    e2 = e1.dup
+    e3 = e2.dup
+    assert_false e1.blocked?
+    assert_false e2.blocked?
+    assert_false e3.blocked?
+
+    e2.block
+    assert_true  e1.blocked?
+    assert_true  e2.blocked?
+    assert_false e3.blocked?
   end
 
   def test_time()

data/test/test_focus_event.rb

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+
+
+require_relative 'helper'
+
+
+class TestFocusEvent < Test::Unit::TestCase
+
+  def event(*args)
+    Reflex::FocusEvent.new(*args)
+  end
+
+  def view(*args)
+    Reflex::View.new(*args)
+  end
+
+  def test_initialize()
+    e = event Reflex::FocusEvent::FOCUS, view(name: :a), view(name: :b)
+    assert_equal :focus, e.action
+    assert_equal 'a',    e.current.name
+    assert_equal 'b',    e.last   .name
+  end
+
+  def test_dup()
+    e1 = event Reflex::FocusEvent::FOCUS, view, view
+    e2 = e1.dup
+    e1.block
+    e3 = e1.dup
+    assert_true  e1.blocked?
+    assert_false e2.blocked?
+    assert_true  e3.blocked?
+  end
+
+end# TestFocusEvent

data/test/test_frame_event.rb

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+
+
+require_relative 'helper'
+
+
+class TestFrameEvent < Test::Unit::TestCase
+
+  def event(*args)
+    Reflex::FrameEvent.new(*args)
+  end
+
+  def bounds(*args)
+    Rays::Bounds.new(*args)
+  end
+
+  def test_initialize()
+    e = event bounds(1, 2, 3, 4, 5, 6), 7, 8, 9, 10, 11, 12
+    assert_equal bounds(1, 2, 3, 4, 5, 6), e.frame
+    assert_equal 7,  e.dx
+    assert_equal 8,  e.dy
+    assert_equal 9,  e.dw
+    assert_equal 10, e.dh
+    assert_equal 11, e.angle
+    assert_equal 12, e.dangle
+  end
+
+  def test_dup()
+    e1 = event bounds(1, 2, 3, 4, 5, 6), 7, 8, 9, 10, 11, 12
+    e2 = e1.dup
+    e1.block
+    e3 = e1.dup
+    assert_true  e1.blocked?
+    assert_false e2.blocked?
+    assert_true  e3.blocked?
+  end
+
+end# TestFrameEvent

data/test/test_key_event.rb

@@ -0,0 +1,33 @@
+# -*- coding: utf-8 -*-
+
+
+require_relative 'helper'
+
+
+class TestKeyEvent < Test::Unit::TestCase
+
+  def event(*args)
+    Reflex::KeyEvent.new(*args)
+  end
+
+  def test_initialize()
+    e = event Reflex::KeyEvent::DOWN, 'a', 1, 2, 3
+    assert_equal :down, e.action
+    assert_equal 'a',   e.chars
+    assert_equal 1,     e.code
+    assert_equal 2,     e.modifiers
+    assert_equal 3,     e.repeat
+    assert_false        e.captured?
+  end
+
+  def test_dup()
+    e1 = event Reflex::KeyEvent::DOWN, 'a', 1, 2, 3
+    e2 = e1.dup
+    e1.block
+    e3 = e1.dup
+    assert_true  e1.blocked?
+    assert_false e2.blocked?
+    assert_true  e3.blocked?
+  end
+
+end# TestKeyEvent

data/test/test_pointer.rb

@@ -42,7 +42,7 @@ class TestPointer < Test::Unit::TestCase
       time: 6)
 
     assert_equal    1,             p.id
-    assert_equal    [:touch],      p.type
+    assert_equal    [:touch],      p.types
     assert_equal    :down,         p.action
     assert_equal    [2, 3],        p.position.to_a
     assert_equal    4,             p.modifiers
@@ -52,45 +52,45 @@ class TestPointer < Test::Unit::TestCase
     assert_nil                     p.prev
   end
 
-  def test_type()
-    def type(t)
+  def test_types()
+    def create(t)
       pointer(type: t).tap do |o|
         def o.test()
-          [type, mouse?, left?, right?, middle?, touch?, pen?]
+          [types, mouse?, left?, right?, middle?, touch?, pen?]
         end
       end
     end
 
-    o = type TYPE_NONE
+    o = create TYPE_NONE
     assert_equal [[],              F, F, F, F, F, F], o.test
 
-    o = type MOUSE
+    o = create MOUSE
     assert_equal [[:mouse],        T, F, F, F, F, F], o.test
 
-    o = type LEFT
+    o = create LEFT
     assert_equal [[:mouse_left],   F, T, F, F, F, F], o.test
 
-    o = type RIGHT
+    o = create RIGHT
     assert_equal [[:mouse_right],  F, F, T, F, F, F], o.test
 
-    o = type MIDDLE
+    o = create MIDDLE
     assert_equal [[:mouse_middle], F, F, F, T, F, F], o.test
 
-    o = type TOUCH
+    o = create TOUCH
     assert_equal [[:touch],        F, F, F, F, T, F], o.test
 
-    o = type PEN
+    o = create PEN
     assert_equal [[:pen],          F, F, F, F, F, T], o.test
 
-    o = type LEFT | RIGHT
+    o = create LEFT | RIGHT
     types = [:mouse_left, :mouse_right]
     assert_equal [types, F, T, T, F, F, F], o.test
 
-    o = type LEFT | RIGHT | MIDDLE
+    o = create LEFT | RIGHT | MIDDLE
     types = [:mouse_left, :mouse_right, :mouse_middle]
     assert_equal [types, F, T, T, T, F, F], o.test
 
-    o = type MOUSE | LEFT | RIGHT | MIDDLE | TOUCH | PEN
+    o = create MOUSE | LEFT | RIGHT | MIDDLE | TOUCH | PEN
     types = [:mouse, :mouse_left, :mouse_right, :mouse_middle, :touch, :pen]
     assert_equal [types, T, T, T, T, T, T], o.test
   end

data/test/test_pointer_event.rb

@@ -48,7 +48,7 @@ class TestPointerEvent < Test::Unit::TestCase
     assert_equal false,    e.captured?
 
     assert_equal 1,        p1.id
-    assert_equal [:touch], p1.type
+    assert_equal [:touch], p1.types
     assert_equal :down,    p1.action
     assert_equal [2, 3],   p1.position.to_a
     assert_equal [2, 3],   p1.pos     .to_a

data/test/test_scroll_event.rb

@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+
+
+require_relative 'helper'
+
+
+class TestScrollEvent < Test::Unit::TestCase
+
+  def event(*args)
+    Reflex::ScrollEvent.new(*args)
+  end
+
+  def point(*args)
+    Rays::Point.new(*args)
+  end
+
+  def test_initialize()
+    e = event 1, 2, 3, 4, 5, 6
+    assert_equal 1, e.x
+    assert_equal 2, e.y
+    assert_equal 3, e.z
+    assert_equal 4, e.dx
+    assert_equal 5, e.dy
+    assert_equal 6, e.dz
+    assert_equal point(1, 2, 3), e. scroll
+    assert_equal point(4, 5, 6), e.dscroll
+  end
+
+  def test_dup()
+    e1 = event 1, 2, 3, 4, 5, 6
+    e2 = e1.dup
+    e1.block
+    e3 = e1.dup
+    assert_true  e1.blocked?
+    assert_false e2.blocked?
+    assert_true  e3.blocked?
+  end
+
+end# TestScrollEvent

data/test/test_timer_event.rb

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+
+
+require_relative 'helper'
+
+
+class TestTimerEvent < Test::Unit::TestCase
+
+  def event(*args)
+    Reflex::TimerEvent.new(*args)
+  end
+
+  def timer(seconds = 0, count = 1)
+    Reflex::View.new.timeout(seconds, count: count)
+  end
+
+  def test_initialize()
+    t = timer 1, 2
+    e = event t
+    assert_equal t,       e.timer
+    assert_equal t.owner, e.owner
+    assert_equal t.id,    e.id
+    assert_equal 1,       e.interval
+    assert_equal 2,       e.count
+    assert_false          e.finished?
+  end
+
+  def test_dup()
+    e1 = event timer
+    e2 = e1.dup
+    e1.block
+    e3 = e1.dup
+    assert_true  e1.blocked?
+    assert_false e2.blocked?
+    assert_true  e3.blocked?
+  end
+
+end# TestTimerEvent

data/test/test_update_event.rb

@@ -0,0 +1,29 @@
+# -*- coding: utf-8 -*-
+
+
+require_relative 'helper'
+
+
+class TestUpdateEvent < Test::Unit::TestCase
+
+  def event(*args)
+    Reflex::UpdateEvent.new(*args)
+  end
+
+  def test_initialize()
+    e = event 1, 2
+    assert_equal 1, e.now
+    assert_equal 2, e.dt
+  end
+
+  def test_dup()
+    e1 = event 1, 2
+    e2 = e1.dup
+    e1.block
+    e3 = e1.dup
+    assert_true  e1.blocked?
+    assert_false e2.blocked?
+    assert_true  e3.blocked?
+  end
+
+end# TestUpdateEvent

data/test/test_wheel_event.rb

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+
+
+require_relative 'helper'
+
+
+class TestWheelEvent < Test::Unit::TestCase
+
+  def event(*args)
+    Reflex::WheelEvent.new(*args)
+  end
+
+  def point(*args)
+    Rays::Point.new(*args)
+  end
+
+  def test_initialize()
+    e = event 1, 2, 3, 4, 5, 6, 7
+    assert_equal 1, e.x
+    assert_equal 2, e.y
+    assert_equal 3, e.z
+    assert_equal 4, e.dx
+    assert_equal 5, e.dy
+    assert_equal 6, e.dz
+    assert_equal 7, e.modifiers
+    assert_equal point(1, 2, 3), e. position
+    assert_equal point(4, 5, 6), e.dposition
+  end
+
+  def test_dup()
+    e1 = event 1, 2, 3, 4, 5, 6, 7
+    e2 = e1.dup
+    e1.block
+    e3 = e1.dup
+    assert_true  e1.blocked?
+    assert_false e2.blocked?
+    assert_true  e3.blocked?
+  end
+
+end# TestWheelEvent