reflexion 0.1.22 → 0.1.23

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.type
+    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_type()
+    def type(t)
+      pointer(type: t).tap do |o|
+        def o.test()
+          [type, mouse?, left?, right?, middle?, touch?, pen?]
+        end
+      end
+    end
+
+    o = type TYPE_NONE
+    assert_equal [[],              F, F, F, F, F, F], o.test
+
+    o = type MOUSE
+    assert_equal [[:mouse],        T, F, F, F, F, F], o.test
+
+    o = type LEFT
+    assert_equal [[:mouse_left],   F, T, F, F, F, F], o.test
+
+    o = type RIGHT
+    assert_equal [[:mouse_right],  F, F, T, F, F, F], o.test
+
+    o = type MIDDLE
+    assert_equal [[:mouse_middle], F, F, F, T, F, F], o.test
+
+    o = type TOUCH
+    assert_equal [[:touch],        F, F, F, F, T, F], o.test
+
+    o = type PEN
+    assert_equal [[:pen],          F, F, F, F, F, T], o.test
+
+    o = type LEFT | RIGHT
+    types = [:mouse_left, :mouse_right]
+    assert_equal [types, F, T, T, F, F, F], o.test
+
+    o = type 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
+    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
-
-    o = pointer_type RIGHT
-    assert_equal [[:mouse_right],  F, T, 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 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.type
+    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_selector.rb

@@ -46,6 +46,13 @@ class TestSelector < Test::Unit::TestCase
     assert_equal [], s.tags.to_a
   end
 
+  def test_empty()
+    assert_equal true,  sel                   .empty?
+    assert_equal false, sel(name: :A         ).empty?
+    assert_equal false, sel(          tag: :T).empty?
+    assert_equal false, sel(name: :A, tag: :T).empty?
+  end
+
   def test_contains()
     assert_not sel.contains(sel name: :A, tag: :T)
     assert     sel(name: :A).contains(sel name: :A)

data/test/test_view.rb

@@ -6,26 +6,30 @@ require_relative 'helper'
 
 class TestView < Test::Unit::TestCase
 
-  def view(*args, &block)
-    Reflex::View.new(*args, &block)
+  def view(*a, **k, &b)
+    Reflex::View.new(*a, **k, &b)
   end
 
-  def style(*args, &block)
-    Reflex::Style.new(*args, &block)
+  def window(*a, **k, &b)
+    Reflex::Window.new(*a, **k, &b)
   end
 
-  def shape(*args, &block)
-    Reflex::RectShape.new(*args, &block)
+  def style(*a, **k, &b)
+    Reflex::Style.new(*a, **k, &b)
   end
 
-  def selector(*args, &block)
-    Reflex::Selector.new(*args, &block)
+  def shape(*a, **k, &b)
+    Reflex::RectShape.new(*a, **k, &b)
   end
 
-  def point(*args)  Rays::Point.new(*args) end
-  def bounds(*args) Rays::Bounds.new(*args) end
+  def selector(*a, **k, &b)
+    Reflex::Selector.new(*a, **k, &b)
+  end
+
+  def point(*a)  Rays::Point.new(*a) end
+  def bounds(*a) Rays::Bounds.new(*a) end
 
-  def test_hidden()
+  def test_show_hide_hidden()
     v = view
     assert_equal false, v.hidden?
     v.hide
@@ -44,6 +48,29 @@ class TestView < Test::Unit::TestCase
     assert_equal true, v.hidden?
   end
 
+  def test_coord_conversion()
+    w  = window x: 100, y: 200
+    v1 = view   x: 10,  y: 20
+    v2 = view   x: 1,   y: 2
+
+    assert_raise(Rucy::NativeError) {v2.from_parent 0}
+    assert_raise(Rucy::NativeError) {v2.  to_parent 0}
+    assert_raise(Rucy::NativeError) {v2.from_window 0}
+    assert_raise(Rucy::NativeError) {v2.  to_window 0}
+    assert_raise(Rucy::NativeError) {v2.from_screen 0}
+    assert_raise(Rucy::NativeError) {v2.  to_screen 0}
+
+    w .add v1
+    v1.add v2
+
+    assert_equal [4,   3],   v2.from_parent(5)  .to_a
+    assert_equal [6,   7],   v2.  to_parent(5)  .to_a
+    assert_equal [39,  28],  v2.from_window(50) .to_a
+    assert_equal [61,  72],  v2.  to_window(50) .to_a
+    assert_equal [389, 278], v2.from_screen(500).to_a
+    assert_equal [611, 722], v2.  to_screen(500).to_a
+  end
+
   def test_add_child()
     assert_raise(ArgumentError) {view.add_child}
     assert_raise(TypeError) {view.add_child nil}

data/test/test_window.rb

@@ -6,40 +6,41 @@ require_relative 'helper'
 
 class TestWindow < Test::Unit::TestCase
 
-  def win(*args, &block)
-    Reflex::Window.new(*args, &block)
+  def win(*a, **k, &b)
+    Reflex::Window.new(*a, **k, &b)
   end
 
-  def point(*args)  Reflex::Point.new(*args) end
-  def bounds(*args) Reflex::Bounds.new(*args) end
+  def point(*a)  Reflex::Point.new(*a) end
+  def bounds(*a) Reflex::Bounds.new(*a) end
 
-  def test_root()
-    w = win
-    assert_not_nil w.root
-    assert_nil     w.root.parent
-    assert_equal 'ROOT', w.root.name
-  end
-
-  def test_window()
+  def test_show_hide_hidden()
     w = win
-    assert_equal w, w.root.window
-  end
-
-  def test_hidden()
-    w = win
-    assert_equal true, w.hidden
+    assert_equal true,  w.hidden
     w.show
     assert_equal false, w.hidden
     w.hide
-    assert_equal true, w.hidden
+    assert_equal true,  w.hidden
     w.hide
-    assert_equal true, w.hidden
+    assert_equal true,  w.hidden
     w.show
-    assert_equal true, w.hidden
+    assert_equal true,  w.hidden
     w.show
     assert_equal false, w.hidden
   end
 
+  def test_coord_conversion()
+    w = win x: 100, y: 200
+    assert_equal [400, 300], w.from_screen(500).to_a
+    assert_equal [600, 700], w.  to_screen(500).to_a
+  end
+
+  def test_title()
+    w = win
+    assert_equal '',  w.title
+    w.title = 'A'
+    assert_equal 'A', w.title
+  end
+
   def test_frame()
     w = win
     b = w.frame.dup
@@ -85,11 +86,12 @@ class TestWindow < Test::Unit::TestCase
     assert_true  w.resizable?
   end
 
-  def test_title()
+  def test_root()
     w = win
-    assert_equal '', w.title
-    w.title = 'A'
-    assert_equal 'A', w.title
+    assert_not_nil       w.root
+    assert_nil           w.root.parent
+    assert_equal 'ROOT', w.root.name
+    assert_equal w,      w.root.window
   end
 
 end# TestWindow