reflexion 0.1.21 → 0.1.25

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

@@ -6,15 +6,43 @@ require_relative 'helper'
 
 class TestEvent < Test::Unit::TestCase
 
-  def event ()
-    Reflex::Event.new
+  def event()
+    Reflex::UpdateEvent.new 0, 0
   end
 
-  def test_block ()
+  def test_dup()
+    e1 = event
+    e2 = e1.dup
+    e1.block
+    e3 = e1.dup
+    assert_true  e1.blocked?
+    assert_false e2.blocked?
+    assert_true  e3.blocked?
+  end
+
+  def test_block()
     e = event
-    assert_equal false, e.block?
+    assert_false e.blocked?
     e.block
-    assert_equal true, e.block?
+    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()
+    assert_in_delta Time.now.to_f, event.time, 0.001
   end
 
 end# TestEvent

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_has_frame.rb

@@ -6,11 +6,11 @@ require_relative 'helper'
 
 class TestHasFrame < Test::Unit::TestCase
 
-  def view (*args)
-    Reflex::View.new *args
+  def view(*args)
+    Reflex::View.new(*args)
   end
 
-  def test_accessors ()
+  def test_accessors()
     v = view
     b = v.frame.dup
     assert_equal b, v.frame
@@ -28,18 +28,18 @@ class TestHasFrame < Test::Unit::TestCase
     assert_equal [15, 25, 30, 90, 190, 300], v.frame.to_a(3)
   end
 
-  def test_move ()
+  def test_move()
     v = view
-    v.move_to  10,  10; assert_equal [10, 10], v.pos.to_a
-    v.move_by  40,  40; assert_equal [50, 50], v.pos.to_a
-    v.move_by -10, -10; assert_equal [40, 40], v.pos.to_a
+    v.move_to( 10,  10); assert_equal [10, 10], v.pos.to_a
+    v.move_by( 40,  40); assert_equal [50, 50], v.pos.to_a
+    v.move_by(-10, -10); assert_equal [40, 40], v.pos.to_a
   end
 
-  def test_resize ()
+  def test_resize()
     v = view
-    v.resize_to  100,  100; assert_equal [100, 100], v.size.to_a
-    v.resize_by  400,  400; assert_equal [500, 500], v.size.to_a
-    v.resize_by -100, -100; assert_equal [400, 400], v.size.to_a
+    v.resize_to( 100,  100); assert_equal [100, 100], v.size.to_a
+    v.resize_by( 400,  400); assert_equal [500, 500], v.size.to_a
+    v.resize_by(-100, -100); assert_equal [400, 400], v.size.to_a
   end
 
 end# TestHasFrame

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

@@ -0,0 +1,149 @@
+# -*- coding: utf-8 -*-
+
+
+require_relative 'helper'
+
+
+class TestPointer < Test::Unit::TestCase
+
+  TYPE_NONE = Reflex::Pointer::TYPE_NONE
+  MOUSE     = Reflex::Pointer::MOUSE
+  LEFT      = Reflex::Pointer::MOUSE_LEFT
+  RIGHT     = Reflex::Pointer::MOUSE_RIGHT
+  MIDDLE    = Reflex::Pointer::MOUSE_MIDDLE
+  TOUCH     = Reflex::Pointer::TOUCH
+  PEN       = Reflex::Pointer::PEN
+
+  ACTION_NONE = Reflex::Pointer::ACTION_NONE
+  DOWN        = Reflex::Pointer::DOWN
+  UP          = Reflex::Pointer::UP
+  MOVE        = Reflex::Pointer::MOVE
+  STAY        = Reflex::Pointer::STAY
+  CANCEL      = Reflex::Pointer::CANCEL
+
+  T = true
+  F = false
+
+  def pointer(
+    id: 0, type: TYPE_NONE, action: ACTION_NONE,
+    position: 0, modifiers: 0, click_count: 0, drag: false,
+    time: 0)
+
+    Reflex::Pointer.new(
+      id, type, action, position, modifiers, click_count, drag, time)
+  end
+
+  def test_initialize()
+    assert_nothing_raised {pointer}
+
+    p = pointer(
+      id: 1, type: TOUCH, action: DOWN,
+      position: [2, 3], modifiers: 4, click_count: 5, drag: true,
+      time: 6)
+
+    assert_equal    1,             p.id
+    assert_equal    [:touch],      p.types
+    assert_equal    :down,         p.action
+    assert_equal    [2, 3],        p.position.to_a
+    assert_equal    4,             p.modifiers
+    assert_equal    5,             p.click_count
+    assert_equal    true,          p.drag?
+    assert_equal    6,             p.time
+    assert_nil                     p.prev
+  end
+
+  def test_types()
+    def create(t)
+      pointer(type: t).tap do |o|
+        def o.test()
+          [types, mouse?, left?, right?, middle?, touch?, pen?]
+        end
+      end
+    end
+
+    o = create TYPE_NONE
+    assert_equal [[],              F, F, F, F, F, F], o.test
+
+    o = create MOUSE
+    assert_equal [[:mouse],        T, F, F, F, F, F], o.test
+
+    o = create LEFT
+    assert_equal [[:mouse_left],   F, T, F, F, F, F], o.test
+
+    o = create RIGHT
+    assert_equal [[:mouse_right],  F, F, T, F, F, F], o.test
+
+    o = create MIDDLE
+    assert_equal [[:mouse_middle], F, F, F, T, F, F], o.test
+
+    o = create TOUCH
+    assert_equal [[:touch],        F, F, F, F, T, F], o.test
+
+    o = create PEN
+    assert_equal [[:pen],          F, F, F, F, F, T], o.test
+
+    o = create LEFT | RIGHT
+    types = [:mouse_left, :mouse_right]
+    assert_equal [types, F, T, T, F, F, F], o.test
+
+    o = create LEFT | RIGHT | MIDDLE
+    types = [:mouse_left, :mouse_right, :mouse_middle]
+    assert_equal [types, F, T, T, T, F, F], o.test
+
+    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
+
+  def test_action()
+    def action(a)
+      pointer(action: a).tap do |o|
+        def o.test()
+          [action, down?, up?, move?, cancel?, stay?]
+        end
+      end
+    end
+
+    o = action ACTION_NONE
+    assert_equal [:none,   F, F, F, F, F], o.test
+
+    o = action DOWN
+    assert_equal [:down,   T, F, F, F, F], o.test
+
+    o = action UP
+    assert_equal [:up,     F, T, F, F, F], o.test
+
+    o = action MOVE
+    assert_equal [:move,   F, F, T, F, F], o.test
+
+    o = action CANCEL
+    assert_equal [:cancel, F, F, F, T, F], o.test
+
+    o = action STAY
+    assert_equal [:stay,   F, F, F, F, T], o.test
+  end
+
+  def test_position()
+    assert_equal [1, 1], pointer(position: 1     ).position.to_a
+    assert_equal [2, 3], pointer(position: [2, 3]).position.to_a
+  end
+
+  def test_xy()
+    assert_equal 1, pointer(position: [1, 2]).x
+    assert_equal 2, pointer(position: [1, 2]).y
+  end
+
+  def test_compare()
+    assert_equal pointer, pointer
+
+    assert_not_equal pointer, pointer(id:          1)
+    assert_not_equal pointer, pointer(type:        Reflex::Pointer::PEN)
+    assert_not_equal pointer, pointer(action:      Reflex::Pointer::UP)
+    assert_not_equal pointer, pointer(position:    2)
+    assert_not_equal pointer, pointer(modifiers:   3)
+    assert_not_equal pointer, pointer(click_count: 4)
+    assert_not_equal pointer, pointer(drag:        true)
+    assert_not_equal pointer, pointer(time:        5)
+  end
+
+end# TestPointer

data/test/test_pointer_event.rb

@@ -6,125 +6,91 @@ require_relative 'helper'
 
 class TestPointerEvent < Test::Unit::TestCase
 
-  E = Reflex::PointerEvent
-  T = true
-  F = false
-
-  TYPE_NONE = E::TYPE_NONE
-  DOWN      = E::TYPE_DOWN
-  UP        = E::TYPE_UP
-  MOVE      = E::TYPE_MOVE
-
-  POINTER_NONE = E::POINTER_NONE
-  LEFT         = E::POINTER_MOUSE_LEFT
-  RIGHT        = E::POINTER_MOUSE_RIGHT
-  MIDDLE       = E::POINTER_MOUSE_MIDDLE
-  TOUCH        = E::POINTER_TOUCH
-  PEN          = E::POINTER_PEN
-
-  def event (
-    type = TYPE_NONE, pointer_type = POINTER_NONE,
-    modifiers = 0, count = 0, drag = false,
-    positions: [0])
-
-    Reflex::PointerEvent.new type, pointer_type, modifiers, count, drag, positions
-  end
-
-  def test_initialize ()
-    assert_nothing_raised       {event positions: 10.times.to_a}
-    assert_raise(ArgumentError) {event positions: 11.times.to_a}
-    assert_raise(ArgumentError) {event positions: []}
-  end
-
-  def test_type ()
-    def type (arg)
-      event(arg).tap do |o|
-        def o.test ()
-          [type, down?, up?, move?]
-        end
-      end
-    end
+  TYPE_NONE = Reflex::Pointer::TYPE_NONE
+  TOUCH     = Reflex::Pointer::TOUCH
+  PEN       = Reflex::Pointer::PEN
 
-    o = type TYPE_NONE
-    assert_equal [:none, F, F, F], o.test
+  ACTION_NONE = Reflex::Pointer::ACTION_NONE
+  DOWN        = Reflex::Pointer::DOWN
+  UP          = Reflex::Pointer::UP
 
-    o = type DOWN
-    assert_equal [:down, T, F, F], o.test
-
-    o = type UP
-    assert_equal [:up,   F, T, F], o.test
-
-    o = type MOVE
-    assert_equal [:move, F, F, T], o.test
+  def event(*args)
+    Reflex::PointerEvent.new(*args)
   end
 
-  def test_pointer_type ()
-    def pointer_type (arg)
-      event(TYPE_NONE, arg).tap do |o|
-        def o.test ()
-          [pointer_type, left?, right?, middle?, touch?, pen?]
-        end
-      end
-    end
-
-    o = pointer_type POINTER_NONE
-    assert_equal [[],              F, F, F, F, F], o.test
-
-    o = pointer_type LEFT
-    assert_equal [[:mouse_left],   T, F, F, F, F], o.test
+  def pointer(
+    id: 0, type: TYPE_NONE, action: ACTION_NONE,
+    position: 0, modifiers: 0, click_count: 0, drag: false,
+    time: 0)
 
-    o = pointer_type RIGHT
-    assert_equal [[:mouse_right],  F, T, F, F, F], o.test
-
-    o = pointer_type MIDDLE
-    assert_equal [[:mouse_middle], F, F, T, F, F], o.test
-
-    o = pointer_type TOUCH
-    assert_equal [[:touch],        F, F, F, T, F], o.test
-
-    o = pointer_type PEN
-    assert_equal [[:pen],          F, F, F, F, T], o.test
-
-    o = pointer_type LEFT | RIGHT
-    types = [:mouse_left, :mouse_right]
-    assert_equal [types, T, T, F, F, F], o.test
-
-    o = pointer_type LEFT | RIGHT | MIDDLE
-    types = [:mouse_left, :mouse_right, :mouse_middle]
-    assert_equal [types, T, T, T, F, F], o.test
-
-    o = pointer_type LEFT | RIGHT | MIDDLE | TOUCH | PEN
-    types = [:mouse_left, :mouse_right, :mouse_middle, :touch, :pen]
-    assert_equal [types, T, T, T, T, T], o.test
+    Reflex::Pointer.new(
+      id, type, action, position, modifiers, click_count, drag, time)
   end
 
-  def test_size ()
-    assert_equal 1, event(positions: [0]   ).size
-    assert_equal 2, event(positions: [0, 1]).size
+  def test_initialize()
+    assert_nothing_raised       {event pointer}
+    assert_nothing_raised       {event pointer, pointer}
+    assert_raise(ArgumentError) {event}
+
+    p1 = pointer(
+      id: 1,  type: TOUCH, action: DOWN,
+      position: [2,  3],  modifiers: 4,  click_count: 5,  drag: true,
+      time: 6)
+    p2 = pointer(
+      id: 10, type: PEN,   action: UP,
+      position: [20, 30], modifiers: 40, click_count: 50, drag: false,
+      time: 60)
+    e = event p1, p2
+
+    assert_equal [p1, p2], e.pointers.to_a
+    assert_equal 2,        e.size
+    assert_equal false,    e.empty?
+    assert_equal false,    e.captured?
+
+    assert_equal 1,        p1.id
+    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
+    assert_equal 2,        p1.x
+    assert_equal 3,        p1.y
+    assert_equal 4,        p1.modifiers
+    assert_equal 5,        p1.click_count
+    assert_equal true,     p1.drag?
+    assert_equal 6,        p1.time
   end
 
-  def test_xy ()
-    assert_equal 0, event(positions: [[0, 1], [2, 3]]).x
-    assert_equal 1, event(positions: [[0, 1], [2, 3]]).y
+  def test_dup()
+    e1 = event pointer
+    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_position ()
-    assert_equal [0, 1], event(positions: [[0, 1], [2, 3]]).position.to_a
+  def test_size()
+    assert_equal 1, event(pointer         ).size
+    assert_equal 2, event(pointer, pointer).size
   end
 
-  def test_positions ()
-    assert_equal [[0, 0]],         event(positions: [0]   ).positions.map(&:to_a)
-    assert_equal [[0, 0], [1, 1]], event(positions: [0, 1]).positions.map(&:to_a)
-
-    assert_equal [[0, 1]],         event(positions: [[0, 1]]        ).positions.map(&:to_a)
-    assert_equal [[0, 1], [2, 3]], event(positions: [[0, 1], [2, 3]]).positions.map(&:to_a)
+  def test_empty?()
+    assert_equal false, event(pointer).empty?
   end
 
-  def test_at ()
-    assert_equal [0, 1], event(positions: [[0, 1], [2, 3]])[0].to_a
-    assert_equal [2, 3], event(positions: [[0, 1], [2, 3]])[1].to_a
-    assert_raise(IndexError) {event(positions: [[0, 1], [2, 3]])[-1]}
-    assert_raise(IndexError) {event(positions: [[0, 1], [2, 3]])[2]}
+  def test_get_at()
+    p1 = pointer position: 1
+    p2 = pointer position: 2
+    p3 = pointer position: 3
+    e  = event p1, p2, p3
+
+    assert_equal p1, e[0]
+    assert_equal p3, e[2]
+    assert_nil       e[3]
+    assert_equal p3, e[-1]
+    assert_equal p1, e[-3]
+    assert_nil       e[-4]
   end
 
 end# TestPointerEvent

data/test/test_reflex.rb

@@ -9,7 +9,7 @@ require_relative 'helper'
 
 class TestReflex < Test::Unit::TestCase
 
-  def test_init ()
+  def test_init()
     assert_raise(Rucy::NativeError) {Reflex.fin!}
     assert Reflex.init!
     assert_raise(Rucy::NativeError) {Reflex.init!}

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