rubysketch 0.3.15 → 0.3.16

data/lib/rubysketch/window.rb

@@ -4,81 +4,91 @@ module RubySketch
   class Window < Reflex::Window
 
     attr_accessor :setup, :update, :draw, :before_draw, :after_draw, :resize,
+      :key_down, :key_up,
       :pointer_down, :pointer_up, :pointer_move, :pointer_drag,
-      :key, :motion
+      :motion
 
     attr_accessor :auto_resize
 
     attr_reader :canvas, :canvas_painter
 
-    def initialize (width = 500, height = 500, *args, &block)
-      @events      = []
-      @auto_resize = true
-      @error       = nil
+    def initialize(width = 500, height = 500, *args, **kwargs, &block)
+      RubySketch.instance_variable_set :@window, self
+
+      @canvas         =
+      @canvas_painter = nil
+      @events         = []
+      @auto_resize    = true
+      @error          = nil
 
       painter.miter_limit = 10
       resize_canvas 1, 1
 
-      super *args, size: [width, height], &block
+      root.on(:update)  {|e| on_canvas_update e}
+      root.on(:draw)    {|e| on_canvas_draw e}
+      root.on(:pointer) {|e| on_canvas_pointer e}
+
+      super(*args, size: [width, height], **kwargs, &block)
     end
 
-    def start (&block)
+    def start(&block)
       draw_canvas do
         block.call if block
         on_setup
       end
     end
 
-    def event ()
+    def event()
       @events.last
     end
 
-    def on_setup ()
+    def on_setup()
       call_block @setup, nil
     end
 
-    def on_update (e)
-      call_block @update, e
-      redraw
+    def on_draw(e)
+      update_canvas_view
     end
 
-    def on_draw (e)
-      draw_canvas {call_block @draw, e} if @draw
-
-      x, y, w, h = coord_converter
-      e.painter.image @canvas, x, y, @canvas.width * w, @canvas.height * h
-    end
-
-    def on_key (e)
-      draw_canvas {call_block @key, e} if @key
+    def on_resize(e)
+      resize_canvas e.width, e.height if @auto_resize
+      draw_canvas {call_block @resize, e} if @resize
     end
 
-    def on_pointer (e)
+    def on_key(e)
       block = case e.type
-        when :down then @pointer_down
-        when :up   then @pointer_up
-        when :move then e.drag? ? @pointer_drag : @pointer_move
+        when :down then @key_down
+        when :up   then @key_up
       end
       draw_canvas {call_block block, e} if block
     end
 
-    def on_motion (e)
+    def on_motion(e)
       draw_canvas {call_block @motion, e} if @motion
     end
 
-    def on_resize (e)
-      resize_canvas e.width, e.height if @auto_resize
-      draw_canvas {call_block @resize, e} if @resize
+    def on_canvas_update(e)
+      call_block @update, e
+      redraw
     end
 
-    def to_canvas_coord (x, y)
-      xx, yy, ww, hh = coord_converter
-      return (x - xx) / ww, (y - yy) / hh
+    def on_canvas_draw(e)
+      draw_canvas {call_block @draw, e} if @draw
+      e.painter.image @canvas
+    end
+
+    def on_canvas_pointer(e)
+      block = case e.type
+        when :down then @pointer_down
+        when :up   then @pointer_up
+        when :move then e.drag? ? @pointer_drag : @pointer_move
+      end
+      draw_canvas {call_block block, e} if block
     end
 
     private
 
-    def resize_canvas (width, height, pixel_density = nil)
+    def resize_canvas(width, height, pixel_density = nil)
       return nil if width * height == 0
 
       unless width    == @canvas&.width  &&
@@ -106,11 +116,7 @@ module RubySketch
       @canvas_painter
     end
 
-    def resize_window (width, height)
-      size width, height
-    end
-
-    def copy_painter_attributes (from, to)
+    def copy_painter_attributes(from, to)
       to.fill         = from.fill
       to.stroke       = from.stroke
       to.stroke_width = from.stroke_width
@@ -120,39 +126,49 @@ module RubySketch
       to.font         = from.font
     end
 
-    def coord_converter ()
+    def resize_window(width, height)
+      size width, height
+    end
+
+    def update_canvas_view()
+      scrollx, scrolly, zoom = get_scroll_and_zoom
+      root.scroll_to scrollx, scrolly
+      root.zoom zoom
+    end
+
+    def get_scroll_and_zoom()
       ww, wh =         width.to_f,         height.to_f
       cw, ch = @canvas.width.to_f, @canvas.height.to_f
-      return [0, 0, 1, 1] if ww == 0 || wh == 0 || cw == 0 || ch == 0
+      return [0, 0, 1] if ww == 0 || wh == 0 || cw == 0 || ch == 0
 
       wratio, cratio = ww / wh, cw / ch
       if wratio >= cratio
         scaled_w = wh * cratio
-        return (ww - scaled_w) / 2, 0, scaled_w / cw, wh / ch
+        return (ww - scaled_w) / 2, 0, scaled_w / cw
       else
         scaled_h = ww / cratio
-        return 0, (wh - scaled_h) / 2, ww / cw, scaled_h / ch
+        return 0, (wh - scaled_h) / 2, ww / cw
       end
     end
 
-    def draw_canvas (&block)
+    def draw_canvas(&block)
       begin_draw
       block.call
     ensure
       end_draw
     end
 
-    def begin_draw ()
+    def begin_draw()
       @canvas_painter.__send__ :begin_paint
       @before_draw&.call
     end
 
-    def end_draw ()
+    def end_draw()
       @after_draw&.call
       @canvas_painter.__send__ :end_paint
     end
 
-    def call_block (block, event, *args)
+    def call_block(block, event, *args)
       @events.push event
       block.call event, *args if block && !@error
     rescue Exception => e

data/test/helper.rb

@@ -12,7 +12,7 @@ require 'rubysketch'
 include Xot::Test
 
 
-def assert_equal_vector (v1, v2, delta = 0.000001)
+def assert_equal_vector(v1, v2, delta = 0.000001)
   assert_in_delta v1.x, v2.x, delta
   assert_in_delta v1.y, v2.y, delta
   assert_in_delta v1.z, v2.z, delta

data/test/processing/test_utility.rb

@@ -6,15 +6,11 @@ require_relative '../helper'
 
 class TestProcessingUtility < Test::Unit::TestCase
 
-  class Context
-    include RubySketch::Processing::Context
+  def context()
+    RubySketch::Processing::Context.new RubySketch::Window.new
   end
 
-  def context
-    Context.new
-  end
-
-  def test_random ()
+  def test_random()
     c = context
 
     assert_equal Float,  c.random(1).class

data/test/processing/test_vector.rb

@@ -6,23 +6,20 @@ require_relative '../helper'
 
 class TestProcessingVector < Test::Unit::TestCase
 
-  P = RubySketch::Processing
-
-  V = P::Vector
-
-  M = Math
-
+  P  = RubySketch::Processing
+  V  = P::Vector
+  M  = Math
   PI = M::PI
 
-  def vec (*args)
-    V.new *args
+  def vec(*args, **kwargs)
+    V.new(*args, **kwargs)
   end
 
-  def point (*args)
-    Rays::Point.new *args
+  def point(*args, **kwargs)
+    Rays::Point.new(*args, **kwargs)
   end
 
-  def test_initialize ()
+  def test_initialize()
     assert_equal_vector vec(0, 0, 0), vec()
     assert_equal_vector vec(1, 0, 0), vec(1)
     assert_equal_vector vec(1, 2, 0), vec(1, 2)
@@ -37,7 +34,7 @@ class TestProcessingVector < Test::Unit::TestCase
     assert_equal_vector vec(1, 2, 3), vec(point 1, 2, 3)
   end
 
-  def test_set ()
+  def test_set()
     v0 = vec 9, 9, 9
 
     v = v0.dup; v.set;         assert_equal_vector vec(0, 0, 0), v
@@ -54,7 +51,7 @@ class TestProcessingVector < Test::Unit::TestCase
     v = v0.dup; v.set point(1, 2, 3); assert_equal_vector vec(1, 2, 3), v
   end
 
-  def test_dup ()
+  def test_dup()
     v1 = vec 1, 2, 3
     assert_equal_vector vec(1, 2, 3), v1
 
@@ -67,7 +64,7 @@ class TestProcessingVector < Test::Unit::TestCase
     assert_equal_vector vec(1, 2, 3), v2
   end
 
-  def test_copy ()
+  def test_copy()
     v1 = vec 1, 2, 3
     assert_equal_vector vec(1, 2, 3), v1
 
@@ -80,7 +77,7 @@ class TestProcessingVector < Test::Unit::TestCase
     assert_equal_vector vec(1, 2, 3), v2
   end
 
-  def test_xyz ()
+  def test_xyz()
     v = vec 1, 2, 3
     assert_equal_vector vec(1, 2, 3), v
     assert_equal           [1, 2, 3], [v.x, v.y, v.z]
@@ -95,11 +92,11 @@ class TestProcessingVector < Test::Unit::TestCase
     assert_equal_vector vec(7, 8, 9), v
   end
 
-  def test_array ()
+  def test_array()
     assert_equal [1, 2, 3], vec(1, 2, 3).array
   end
 
-  def test_add ()
+  def test_add()
     v = vec 1, 2, 3
     v.add 4, 5, 6
     assert_equal_vector vec(5, 7, 9), v
@@ -118,7 +115,7 @@ class TestProcessingVector < Test::Unit::TestCase
     assert_equal_vector vec(5, 7, 9), vec(1, 2, 3).add(point(4, 5, 6))
   end
 
-  def test_sub ()
+  def test_sub()
     v = vec 9, 8, 7
     v.sub 1, 2, 3
     assert_equal_vector vec(8, 6, 4), v
@@ -137,19 +134,19 @@ class TestProcessingVector < Test::Unit::TestCase
     assert_equal_vector vec(8, 6, 4), vec(9, 8, 7).sub(point(1, 2, 3))
   end
 
-  def test_mult ()
+  def test_mult()
     v = vec 1, 2, 3
     v.mult 2
     assert_equal_vector vec(2, 4, 6), v
   end
 
-  def test_div ()
+  def test_div()
     v = vec 2, 4, 6
     v.div 2
     assert_equal_vector vec(1, 2, 3), v
   end
 
-  def test_op_add ()
+  def test_op_add()
     v1 = vec 1, 2, 3
     v2 = vec 4, 5, 6
     assert_equal_vector vec(5, 7, 9), v1 + v2
@@ -167,7 +164,7 @@ class TestProcessingVector < Test::Unit::TestCase
     assert_equal_vector vec(5, 7, 9), vec(1, 2, 3) + point(4, 5, 6)
   end
 
-  def test_op_sub ()
+  def test_op_sub()
     v1 = vec 9, 8, 7
     v2 = vec 1, 2, 3
     assert_equal_vector vec(8, 6, 4), v1 - v2
@@ -185,19 +182,19 @@ class TestProcessingVector < Test::Unit::TestCase
     assert_equal_vector vec(8, 6, 4), vec(9, 8, 7) - point(1, 2, 3)
   end
 
-  def test_op_mult ()
+  def test_op_mult()
     v = vec 1, 2, 3
     assert_equal_vector vec(2, 4, 6), v * 2
     assert_equal_vector vec(1, 2, 3), v
   end
 
-  def test_op_div ()
+  def test_op_div()
     v = vec 2, 4, 6
     assert_equal_vector vec(1, 2, 3), v / 2
     assert_equal_vector vec(2, 4, 6), v
   end
 
-  def test_fun_add ()
+  def test_fun_add()
     v1     = vec 1, 2, 3
     v2     = vec 4, 5, 6
     result = vec
@@ -207,7 +204,7 @@ class TestProcessingVector < Test::Unit::TestCase
     assert_equal_vector vec(5, 7, 9), result
   end
 
-  def test_fun_sub ()
+  def test_fun_sub()
     v1     = vec 9, 8, 7
     v2     = vec 1, 2, 3
     result = vec
@@ -217,7 +214,7 @@ class TestProcessingVector < Test::Unit::TestCase
     assert_equal_vector vec(8, 6, 4), result
   end
 
-  def test_fun_mult ()
+  def test_fun_mult()
     v1     = vec 1, 2, 3
     result = vec
     assert_equal_vector vec(2, 4, 6), V.mult(v1, 2, result)
@@ -225,7 +222,7 @@ class TestProcessingVector < Test::Unit::TestCase
     assert_equal_vector vec(2, 4, 6), result
   end
 
-  def test_fun_div ()
+  def test_fun_div()
     v1     = vec 2, 4, 6
     result = vec
     assert_equal_vector vec(1, 2, 3), V.div(v1, 2, result)
@@ -233,17 +230,17 @@ class TestProcessingVector < Test::Unit::TestCase
     assert_equal_vector vec(1, 2, 3), result
   end
 
-  def test_mag ()
+  def test_mag()
     assert_in_delta M.sqrt(5),  vec(1, 2)   .mag, 0.000001
     assert_in_delta M.sqrt(14), vec(1, 2, 3).mag, 0.000001
   end
 
-  def test_magSq ()
+  def test_magSq()
     assert_equal 5,  vec(1, 2)   .magSq
     assert_equal 14, vec(1, 2, 3).magSq
   end
 
-  def test_setMag ()
+  def test_setMag()
     v = vec 3, 4, 0
     assert_equal_vector vec(6, 8, 0), v.setMag(10)
     assert_equal_vector vec(6, 8, 0), v
@@ -255,7 +252,7 @@ class TestProcessingVector < Test::Unit::TestCase
     assert_equal_vector vec(6, 8, 0), result
   end
 
-  def test_normalize ()
+  def test_normalize()
     v      = vec 1, 2, 3
     normal = v / v.mag
     assert_equal_vector normal, v.normalize
@@ -268,7 +265,7 @@ class TestProcessingVector < Test::Unit::TestCase
     assert_equal_vector normal,       result
   end
 
-  def test_limit ()
+  def test_limit()
     v = vec 1, 2, 3
     assert_in_delta 1, v.limit(1).mag, 0.000001
     assert_in_delta 1, v         .mag, 0.000001
@@ -279,7 +276,7 @@ class TestProcessingVector < Test::Unit::TestCase
     assert_in_delta vec(1, 2, 3).mag, vec(1, 2, 3).limit(4).mag, 0.000001
   end
 
-  def test_dist ()
+  def test_dist()
     v1 = vec 1, 2, 3
     v2 = vec 4, 5, 6
 
@@ -292,7 +289,7 @@ class TestProcessingVector < Test::Unit::TestCase
     assert_equal_vector vec(4, 5, 6), v2
   end
 
-  def test_dot ()
+  def test_dot()
     v1 = vec 1, 2, 3
     v2 = vec 4, 5, 6
 
@@ -308,7 +305,7 @@ class TestProcessingVector < Test::Unit::TestCase
     assert_equal_vector vec(4, 5, 6), v2
   end
 
-  def test_cross ()
+  def test_cross()
     v1 = vec 1, 0, 0
     v2 = vec 0, 1, 0
 
@@ -328,9 +325,9 @@ class TestProcessingVector < Test::Unit::TestCase
     assert_equal_vector vec(0, 0, 1), result
   end
 
-  def test_rotate ()
+  def test_rotate()
     angle   = PI * 2 * 0.1
-    context = Object.new.tap {|o| def o.toAngle__ (a); a * 2 * P::RAD2DEG__; end}
+    context = Object.new.tap {|o| def o.toAngle__(a); a * 2 * P::RAD2DEG__; end}
 
     v = vec 1, 0, 0
     assert_equal_vector vec(M.cos(angle), M.sin(angle), 0), v.rotate(angle)
@@ -340,7 +337,7 @@ class TestProcessingVector < Test::Unit::TestCase
     assert_equal_vector vec(M.cos(angle * 2), M.sin(angle * 2), 0), v.rotate(angle)
   end
 
-  def test_fromAngle ()
+  def test_fromAngle()
     angle  = PI * 2 * 0.1
     result = vec
     assert_equal_vector vec(M.cos(angle), M.sin(angle), 0), V.fromAngle(angle)
@@ -348,25 +345,25 @@ class TestProcessingVector < Test::Unit::TestCase
     assert_equal_vector vec(M.cos(angle), M.sin(angle), 0), result
   end
 
-  def test_heading ()
+  def test_heading()
     angle = PI * 1 * 0.1
-    assert_in_delta  angle, V.fromAngle( angle).heading, 0.000001
-    assert_in_delta -angle, V.fromAngle(-angle).heading, 0.000001
+    assert_in_delta( angle, V.fromAngle( angle).heading, 0.000001)
+    assert_in_delta(-angle, V.fromAngle(-angle).heading, 0.000001)
   end
 
-  def test_angleBetween ()
+  def test_angleBetween()
     v1 = V.fromAngle PI * 0.25
     v2 = V.fromAngle PI * 0.75
     assert_in_delta PI / 2, V.angleBetween(v1, v2), 0.000001
   end
 
-  def test_lerp ()
+  def test_lerp()
     assert_equal_vector vec(0.5, 0.5, 0.5), vec(0, 0, 0).lerp(vec(1, 1, 1),    0.5)
     assert_equal_vector vec(0.5, 0.5, 0.5), vec(0, 0, 0).lerp(    1, 1, 1,     0.5)
     assert_equal_vector vec(0.5, 0.5, 0.5), V.lerp(vec(0, 0, 0), vec(1, 1, 1), 0.5)
   end
 
-  def test_random2D ()
+  def test_random2D()
     v1 = V.random2D
     v2 = V.random2D
     assert          v1.x != 0
@@ -380,7 +377,7 @@ class TestProcessingVector < Test::Unit::TestCase
     assert_in_delta 1, v2.mag, 0.000001
   end
 
-  def test_random3D ()
+  def test_random3D()
     v1 = V.random3D
     v2 = V.random3D
     assert v1.x != 0