rubylabs 0.8.3 → 0.9.0

data/lib/rubylabs.rb

@@ -494,38 +494,212 @@ Call +a.random(:success)+ to get a value that is in the array +a+, or call
 
   module Canvas
     
+    class TkObject
+
+      attr_accessor :name, :coords, :penpoint
+      
+      def TkObject.reset(p)
+        @@pipe = p
+        @@id = 0
+      end
+      
+      def TkObject.nextId
+        @@id += 1
+        return "obj" + @@id.to_s
+      end
+      
+      def TkObject.options(h)
+        a = []
+        h.each do |k,v| 
+          a << "-#{k} #{v}"
+        end
+        return a.join(" ")
+      end
+      
+      def raise
+        @@pipe.puts ".canvas raise $#{@name}"
+      end
+      
+      def lower
+        @@pipe.puts ".canvas lower $#{@name}"
+      end
+      
+      def erase
+        @@pipe.puts ".canvas delete $#{@name}"
+      end
+      
+      def coords=(a)
+        @coords = a
+        @@pipe.puts ".canvas coords $#{@name} #{a.join(' ')}"
+      end
+      
+      def fill=(x)
+        @@pipe.puts ".canvas itemconfigure $#{name} -fill #{x}"
+      end
+      
+    end
+    
+=begin rdoc
+  Draw a line from (x0,y0) to (x1,y1)
+=end
+
+    class Line < TkObject
+      def initialize(x0, y0, x1, y1, args = {})
+        raise "No canvas" unless @@pipe
+        @name = TkObject.nextId
+        @coords = [ x0, y0, x1, y1 ] 
+        @penpoint = nil
+        cmnd = "set #{@name} [.canvas create line #{@coords.join(" ")} #{TkObject.options(args)}]"
+        @@pipe.puts cmnd
+      end
+      
+      def Line.erase_all(tag)
+        @@pipe.puts ".canvas delete withtag #{tag}"
+      end
+      
+    end
+    
+=begin rdoc
+  Create a circle with center at (x,y) and radius r.
+=end
+
+    class Circle < TkObject
+      def initialize(x, y, r, args = {})
+        raise "No canvas" unless @@pipe
+        @name = TkObject.nextId
+        @coords = [ x-r, y-r, x+r, y+r ] 
+        @penpoint = [ r, r ]
+        cmnd = "set #{@name} [.canvas create oval #{@coords.join(" ")} #{TkObject.options(args)}]"
+        @@pipe.puts cmnd
+      end
+    end
+    
+=begin rdoc
+  Create a rectangle with upper left at (x0,y0) and lower right at (x1,y1).
+=end
+
+    class Rectangle < TkObject
+      def initialize(x0, y0, x1, y1, args = {})
+        raise "No canvas" unless @@pipe
+        @name = TkObject.nextId
+        @coords = [ x0, y0, x1, y1 ] 
+        @penpoint = [ (x1-x0)/2, (y1-y0)/2 ]
+        cmnd = "set #{@name} [.canvas create rectangle #{@coords.join(" ")} #{TkObject.options(args)}]"
+        @@pipe.puts cmnd
+      end
+    end
+
+=begin rdoc
+  Create a polygon with vertices defined by array a.  The array can be a flat
+  list of x's and y's (e.g. [100,100,100,200,200,100]) or a list of (x,y)
+  pairs (e.g. [[100,100], [100,200], [200,100]]).
+=end
+
+    class Polygon < TkObject
+      def initialize(a, args = {})
+        raise "No canvas" unless @@pipe
+        @name = TkObject.nextId
+        @coords = a
+        @penpoint = [0,0]
+        cmnd = "set #{@name} [.canvas create polygon #{@coords.join(" ")} #{TkObject.options(args)}]"
+        @@pipe.puts cmnd
+      end
+    end
+    
+=begin rdoc
+  Add text at (x, y).  Sets the anchor point to northwest unless it is passed
+  as an argument.
+=end
+
+    class Text < TkObject
+      def initialize(s, x, y, args = {})
+        raise "No canvas" unless @@pipe
+        @name = TkObject.nextId
+        @coords = [ x, y ]
+        @penpoint = nil
+        args[:anchor] = :nw unless args.has_key?(:anchor)
+        args[:text] = "\"#{s}\""
+        cmnd = "set #{@name} [.canvas create text #{@coords.join(" ")} #{TkObject.options(args)}]"
+        @@pipe.puts cmnd
+      end
+      
+      def update(s)
+        @@pipe.puts ".canvas itemconfigure $#{name} -text \"#{s}\""
+      end
+    end
+    
+    class Font < TkObject
+      
+      @@fonts = []
+      
+      def initialize(name, args)
+        @name = name
+        if @@fonts.index(name).nil?
+          cmnd = "font create #{name} #{TkObject.options(args)}"
+          @@pipe.puts cmnd
+          @@fonts << name
+        end
+      end
+      
+    end
+
+=begin rdoc
+  Initialize a drawing canvas.  This version uses Tk to draw objects used during
+  a visualization.  If it's not already initialized, open a connection to a wish
+  shell and configure the window.
+=end
+
+=begin
+  TODO Read the path to wish from a configuration file, so users can alter it
+  TODO there are probably other configuration options that can go there, too
+=end
+
+    @@tkpipe = nil
+    @@title = ""
+    @@height = 0
+    @@width = 0
+    
     def Canvas.init(width, height, title, *opts)
-      require 'tk'
       
       @@title = "RubyLabs::#{title}"
       @@width = width
       @@height = height
+      pad = 12
       
-      if @@tkroot.nil?
-        #         @@tkroot = TkRoot.new { title @@title }
-        # @@content = TkFrame.new(@@tkroot)
-        # @@canvas = TkCanvas.new(@@content, :width => width, :height => height) 
-        #         @@canvas.grid :column => 0, :row => 0, :columnspan => 4, :padx => 10, :pady => 10
-        # @@content.pack :pady => 20
-
-      	@@tkroot = TkRoot.new { title @@title }
-        # @@content = TkFrame.new(@@tkroot)
-    		@@canvas = TkCanvas.new(@@tkroot, :width => width, :height => height) 
-        # @@canvas.grid :column => 0, :row => 0, :columnspan => 4, :padx => 10, :pady => 10
-        @@canvas.pack :padx => 10, :pady => 10
-        # @@content.pack :pady => 20
-
-      	@@threads = []
-      	@@threads << Thread.new() do
-      		Tk.mainloop
-      	end
-    	else
-    	  Canvas.clear
-    	  @@canvas.height = height
-    	  @@canvas.width = width
-    	  @@tkroot.title = @@title
-    	end
-    	return opts[0] == :debug ? @@canvas : true
+      if @@tkpipe.nil?
+        if Canvas.OS == "Windows"
+          @@tkpipe = IO.popen("wish", "w")
+				elsif Canvas.OS == "Linux"
+          @@tkpipe = IO.popen("/opt/ActiveTcl-8.5/bin/wish", "w")
+        else
+          @@tkpipe = IO.popen("/usr/local/bin/wish", "w")
+        end
+        at_exit { Canvas.close }
+        @@tkpipe.puts "tk::canvas .canvas -bg white -width #{width} -height #{height}"
+        @@tkpipe.puts ". configure -bg gray"
+        @@tkpipe.puts "pack .canvas -padx #{pad} -pady #{pad}"
+        TkObject.reset(@@tkpipe)
+      else
+        @@tkpipe.puts ".canvas delete all"
+        @@tkpipe.puts ".canvas configure -width #{width} -height #{height}"
+      end
+      
+      @@tkpipe.puts "wm geometry . #{width+2*pad}x#{height+2*pad}+30+50"
+      @@tkpipe.puts "wm title . #{@@title}"
+        
+    	return opts[0] == :debug ? @@tkpipe : true
+    end
+    
+    def Canvas.close
+      if @@tkpipe
+        @@tkpipe.puts "exit"
+        @@tkpipe = nil
+        TkObject.reset(nil)
+      end
+    end
+    
+    def Canvas.flush
+      @@tkpipe.flush
     end
     
     def Canvas.width
@@ -536,14 +710,10 @@ Call +a.random(:success)+ to get a value that is in the array +a+, or call
       @@height
     end
     
-    def Canvas.root
-      @@tkroot
+    def Canvas.pipe
+      @@tkpipe
     end
-    
-    def Canvas.create(*args)
-      @@canvas.send(:create, *args)
-    end
-    
+            
     # Idea for the future, abandoned for now: allow applications to define a coordinate
     # system, e.g. cartesian with the origin in the middle of the canvas, and map coords
     # pass to line, rectangle, etc from user-specified coordinates to Tk coordinates.
@@ -567,82 +737,21 @@ Call +a.random(:success)+ to get a value that is in the array +a+, or call
     #     a[i], a[i+1] = @@map.call( a[i], a[i+1] )
     #   end
     # end
-    
-    def Canvas.clear
-      @@objects.each { |x| x.delete }
-      @@objects.clear
-    end
-    
-    # total hack -- if on OS X and version is 1.8 and called directly from irb pause to
-    # synch the drawing thread....
-    
-    def Canvas.sync
-      if RUBY_VERSION =~ %r{^1\.8} && RUBY_PLATFORM =~ %r{darwin} && caller[1].index("(irb)") == 0
-        sleep(0.1)
-      end
-      # @@tkroot.update :idletasks
-    end
-    
-=begin rdoc
-  Add text at (x, y).  Note -- looks like :anchor is required, otherwise runtime error
-  from Tk (something about illegal coords).
-=end
-
-    def Canvas.text(s, x, y, opts = {})
-      return nil unless @@canvas
-      opts[:anchor] = :nw unless opts.has_key?(:anchor)
-      opts[:text] = s
-      text = TkcText.new( @@canvas, x, y, opts)
-      @@objects << text
-      return text
-    end
-    
-    def Canvas.font(options)
-      return TkFont.new(options)
-    end
-    
-=begin rdoc
-  Draw a line from (x0,y0) to (x1,y1)
-=end
-
-    def Canvas.line(x0, y0, x1, y1, opts = {})
-      return nil unless @@canvas
-      line = TkcLine.new( @@canvas, x0, y0, x1, y1, opts )
-      @@objects << line
-      return line
-    end
-    
-=begin rdoc
-  Draw a rectangle with upper left at (x0,y0) and lower right at (x1,y1).
-=end
         
-    def Canvas.rectangle(x0, y0, x1, y1, opts = {})
-      return nil unless @@canvas
-      rect = TkcRectangle.new( @@canvas, x0, y0, x1, y1, opts)
-      Canvas.makeObject(rect, (x1-x0)/2, (y1-y0)/2)
-    end
-    
-=begin rdoc
-  Draw a circle with center at (x,y) and radius r
-=end
-
-    def Canvas.circle(x, y, r, opts = {})
-      return nil unless @@canvas
-      ulx, uly, lrx, lry = x-r, y-r, x+r, y+r 
-      circ = TkcOval.new( @@canvas, ulx, uly, lrx, lry, opts )
-      Canvas.makeObject(circ, r, r)
-    end
-    
-=begin rdoc
-  Draw a polygon with vertices defined by array a.  The array can be a flat
-  list of x's and y's (e.g. [100,100,100,200,200,100]) or a list of (x,y)
-  pairs (e.g. [[100,100], [100,200], [200,100]]).
-=end
-
-    def Canvas.polygon(a, opts = {})
-      return nil unless @@canvas
-      poly = TkcPolygon.new( @@canvas, a, opts)
-      Canvas.makeObject(poly, 0, 0)
+    # Figure out what type of system we're on.  
+    # TODO:  find out what the platform string is for the legacy windows one-click installer;
+    # the new installer uses the "mingw" compiler.
+    
+    def Canvas.OS
+      if RUBY_PLATFORM =~ %r{darwin}
+        return "OS X"
+      elsif RUBY_PLATFORM =~ %r{linux}
+        return "Linux"
+      elsif RUBY_PLATFORM =~ %r{mingw}
+        return "Windows"
+      else
+        return "Unknown"
+      end
     end
     
 =begin rdoc
@@ -652,8 +761,8 @@ Call +a.random(:success)+ to get a value that is in the array +a+, or call
     def Canvas.move(obj, dx, dy, option = nil)
       a = obj.coords
       if option == :track
-        x0 = a[0] + obj.penx
-        y0 = a[1] + obj.peny
+        x0 = a[0] + obj.penpoint[0]
+        y0 = a[1] + obj.penpoint[1]
       end
       (0...a.length).step(2) do |i| 
         a[i] += dx
@@ -661,9 +770,9 @@ Call +a.random(:success)+ to get a value that is in the array +a+, or call
       end
       obj.coords = a
       if option == :track
-        x1 = a[0] + obj.penx
-        y1 = a[1] + obj.peny
-        @@objects << TkcLine.new( @@canvas, x0, y0, x1, y1, :width => 1, :fill => '#777777' )
+        x1 = a[0] + obj.penpoint[0]
+        y1 = a[1] + obj.penpoint[1]
+        Canvas::Line.new( x0, y0, x1, y1, :width => 1, :fill => '#777777' )
         obj.raise
       end
       return a
@@ -674,15 +783,15 @@ Call +a.random(:success)+ to get a value that is in the array +a+, or call
   and save the object in a local list so it can be erased by Canvas.clear
 =end
 
-    def Canvas.makeObject(obj, xoff, yoff)
-      class <<obj
-        attr_accessor :penx, :peny
-      end
-      obj.penx = xoff
-      obj.peny = yoff
-      @@objects << obj
-      return obj
-    end
+    # def Canvas.makeObject(obj, xoff, yoff)
+    #   class <<obj
+    #     attr_accessor :penx, :peny
+    #   end
+    #   obj.penx = xoff
+    #   obj.peny = yoff
+    #   @@objects << obj
+    #   return obj
+    # end
     
 =begin rdoc
   Rotate an object by an angle theta (expressed in degrees).  The object is
@@ -711,16 +820,14 @@ Call +a.random(:success)+ to get a value that is in the array +a+, or call
     def Canvas.degrees(rad)
       180 * rad / Math::PI
     end
-    
-    @@tkroot = nil
-    @@objects = Array.new
-    @@title = ""
-    @@height = 0
-    @@width = 0
-    @@map = lambda { |x,y| return x, y }
-    
+        
 =begin rdoc
-  Make an array of n colors that vary from first to last.
+	# Make a range of colors starting from first and going to last in n steps.
+	# First and last are expected to be 3-tuples of integer RGB values.  The
+	# result is an array that starts with first, has n-1 intermediate colors,
+	# and ends with last.  Example: 
+	#    makePalette( [255,0,0], [0,0,0], 10) 
+	# makes 11 colors starting with red and ending with black.
 =end
     
     def Canvas.palette(first, last, n)

data/lib/spherelab.rb

@@ -215,7 +215,7 @@ module SphereLab
         copy.position = position.clone
         copy.velocity = velocity.clone
         copy.force = force.clone
-        copy.graphic = Canvas.circle(prevx, prevy, size, :fill => color)
+        copy.graphic = Canvas::Circle.new(prevx, prevy, size, :fill => color)
       end
       return copy
     end
@@ -327,7 +327,6 @@ module SphereLab
       @velocity.y = y
       if @graphic
         Canvas.rotate(@graphic,alpha)
-        Canvas.sync
       end
       return alpha
     end
@@ -338,7 +337,6 @@ module SphereLab
       @position.add( @velocity * dt )
       if @graphic
         Canvas.move(@graphic, @position.x-prevx, prevy-@position.y, @tracking)
-        Canvas.sync
       end
       return dt
     end  
@@ -354,7 +352,6 @@ module SphereLab
       theta = Canvas.degrees(mid.angle(@velocity))
       alpha = 2 * (90.0 - theta)
       turn(alpha)
-      Canvas.sync if @graphic
       return alpha      
     end
     
@@ -386,9 +383,9 @@ module SphereLab
       poly[i] += edge/10
       poly[i+1] += edge/2
     end
-    Canvas.init(edge, edge, "SphereLab")
+    Canvas.init(edge, edge, "SphereLab::Robot")
     turtle = Turtle.new( :x => edge/10, :y => edge/2, :heading => 0, :speed => 10 )
-    turtle.graphic = Canvas.polygon(poly, :outline => 'black', :fill => '#00ff88')
+    turtle.graphic = Canvas::Polygon.new(poly, :outline => 'black', :fill => '#00ff88')
     if options[:flag]
       turtle.set_flag( *options[:flag] )
     end
@@ -398,17 +395,15 @@ module SphereLab
     class <<turtle
       def plant_flag
         set_flag( @position.x, @position.y )
-        Canvas.sync
       end
     end
     @@drawing = TurtleView.new( turtle, options )
-    Canvas.sync
     return true
   end
   
   def set_flag(fx, fy)
     r = 3.0
-    Canvas.circle( fx + r/2, fy + r/2, r, :fill => 'darkblue' )
+    Canvas::Circle.new( fx + r/2, fy + r/2, r, :fill => 'darkblue' )
     @reference = [ fx, fy ]          
   end
     
@@ -574,7 +569,7 @@ module SphereLab
 =end
 
   def view_system(blist, userOptions = {})
-    Canvas.init(700, 700, "SphereLab")
+    Canvas.init(700, 700, "SphereLab::N-Body")
     if prev = @@drawing
       prev.bodies.each { |x| x.graphic = nil }
     end
@@ -583,7 +578,7 @@ module SphereLab
     sf = setScale(blist, options[:origin], options[:scale])
     blist.each do |b|
       x, y = scale(b.position, origin, sf)
-      b.graphic = Canvas.circle(x, y, b.size, :fill => b.color)
+      b.graphic = Canvas::Circle.new(x, y, b.size, :fill => b.color)
       b.prevx = x
       b.prevy = y
     end
@@ -594,7 +589,6 @@ module SphereLab
     elsif options.has_key?(:pendown)
       options[:pendown] = :track
     end
-    Canvas.sync
     return true  
   end
 
@@ -622,7 +616,6 @@ module SphereLab
     falling.prevx = newx
     falling.prevy = newy
     falling.clear_force
-    Canvas.sync
     return true
   end
 
@@ -668,7 +661,6 @@ module SphereLab
       b.prevx = newx
       b.prevy = newy
     end
-    Canvas.sync
     return true
   end
 
@@ -728,15 +720,14 @@ module SphereLab
     mxmin = options[:mxmin]
     mymin = options[:mymin]
     hmax = options[:hmax]
-    Canvas.init(edge, edge, "SphereLab")
-    earth = Canvas.circle(200, 2150, 1800, :fill => blist[1].color)
+    Canvas.init(edge, edge, "SphereLab::Melon")
+    earth = Canvas::Circle.new(200, 2150, 1800, :fill => blist[1].color)
     blist[1].graphic = earth
     mymax = earth.coords[1]
-    melon = Canvas.circle(mxmin, mymax, 5, :fill => blist[0].color)
+    melon = Canvas::Circle.new(mxmin, mymax, 5, :fill => blist[0].color)
     blist[0].graphic = melon
     scale = (mymax-mymin) / hmax.to_f
     @@drawing = MelonView.new(blist, scale, blist[0].position.y, melon.coords, options)
-    Canvas.sync
     return true
   end
   
@@ -759,7 +750,6 @@ module SphereLab
       a[1] -= height * @@drawing.scale
       a[3] -= height * @@drawing.scale
       melon.graphic.coords = a
-      Canvas.sync
     else
       melon.prevy = melon.position.y
       melon.position.y += height
@@ -784,7 +774,6 @@ module SphereLab
       dx = (melon.position.x - mx) * @@drawing.scale
       dy = (my - melon.position.y) * @@drawing.scale
       Canvas.move(melon.graphic, dx, dy, @@drawing.options[:pendown])
-      Canvas.sync
     end
     return blist[0].height
   end
@@ -797,7 +786,6 @@ module SphereLab
       break if res == "splat"
       count += 1
     end
-    Canvas.sync if @@drawing
     return count * dt
   end
   # :end :drop_melon