rubylabs 0.6.4 → 0.7.0

data/lib/rubylabs.rb

@@ -24,8 +24,6 @@ autoload :ElizaLab, 		  "elizalab.rb"
 autoload :SphereLab,      "spherelab.rb"
 autoload :TSPLab, 			  "tsplab.rb"
 
-autoload :Viewer,         "viewer.rb"
-
 module RubyLabs
 
 =begin rdoc
@@ -432,52 +430,278 @@ Similar to TestArray, but draws random words from a file.
   to make sure line numbers are valid.
 =end
 
-  def Source.lines(spec, id)
-    if spec.class == Fixnum && Source.range_check(spec, id)
-      return [spec]
-    elsif spec.class == Array
-      res = Array.new
-      spec.each do |line|
-        raise "line number must be an integer" unless line.class == Fixnum
-        res << line if Source.range_check(line, id)
-      end
-      return res
-    elsif spec.class == String
-      res = Array.new
-			for i in @@base[id]..(@@base[id]+@@size[id]-1)
-			  line = SCRIPT_LINES__[@@file[id]][i-1].chomp
-			  res << i - @@base[id] + 1 if line.index(spec)
-			end
-			return res
-    else
-      raise "invalid spec: '#{spec}' (must be an integer, array of integers, or a pattern)"
-    end    
-  end
+    def Source.lines(spec, id)
+      if spec.class == Fixnum && Source.range_check(spec, id)
+        return [spec]
+      elsif spec.class == Array
+        res = Array.new
+        spec.each do |line|
+          raise "line number must be an integer" unless line.class == Fixnum
+          res << line if Source.range_check(line, id)
+        end
+        return res
+      elsif spec.class == String
+        res = Array.new
+  			for i in @@base[id]..(@@base[id]+@@size[id]-1)
+  			  line = SCRIPT_LINES__[@@file[id]][i-1].chomp
+  			  res << i - @@base[id] + 1 if line.index(spec)
+  			end
+  			return res
+      else
+        raise "invalid spec: '#{spec}' (must be an integer, array of integers, or a pattern)"
+      end    
+    end
   
-  def Source.range_check(n, id)
-    max = @@size[id]
-    raise "line number must be between 1 and #{max}" unless n >= 1 && n <= max
-    return true
-  end
+    def Source.range_check(n, id)
+      max = @@size[id]
+      raise "line number must be between 1 and #{max}" unless n >= 1 && n <= max
+      return true
+    end
     
 =begin rdoc
   Internal use only -- show info about method
 =end
 
-  def Source.info(name)
-    unless id = Source.find(name)
-      puts "Can't find method named '#{name}'"
-      return
-    end
+    def Source.info(name)
+      unless id = Source.find(name)
+        puts "Can't find method named '#{name}'"
+        return
+      end
 
-    printf "file: %s\n", @@file[name]
-    printf "size: %d\n", @@size[name]
-    printf "base: %d\n", @@base[name]
-    printf "probes: %s\n", @@probes[name].inspect
-  end
+      printf "file: %s\n", @@file[name]
+      printf "size: %d\n", @@size[name]
+      printf "base: %d\n", @@base[name]
+      printf "probes: %s\n", @@probes[name].inspect
+    end
   
   end # Source
   
+=begin rdoc
+  Module for interactive graphics.
+=end
+
+  module Canvas
+    
+    def Canvas.init(width, height, title, *opts)
+      require 'tk'
+      
+      @@title = "RubyLabs::#{title}"
+      @@width = width
+      @@height = height
+      
+      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
+    end
+    
+    def Canvas.width
+      @@width
+    end
+    
+    def Canvas.height
+      @@height
+    end
+    
+    def Canvas.root
+      @@tkroot
+    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.
+    # Lots of complications, though -- e.g. if an application calls the coords method to
+    # get object coordinates (e.g. RandomLab#add_tick gets y coordinate of number line)
+    # it will have to map back from Tk to the selected mapping.....
+    
+    # def Canvas.origin(option)
+    #   case option
+    #   when :tk
+    #     @@map = lambda { |x,y| return x, y }
+    #   when :quadrant
+    #     @@map = lambda { |x,y| return x, @@height - y }
+    #   when :cartesian
+    #     @@map = lambda { |x,y| return x + @@width/2, @@height/2 - y }
+    #   end
+    # end
+    # 
+    # def Canvas.map(a)
+    #   (0...a.length).step(2) do |i| 
+    #     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[2] =~ %r{workspace}
+        sleep(0.1)
+      end
+    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)
+    end
+    
+=begin rdoc
+  Move an object by an amount dx, dy
+=end
+
+    def Canvas.move(obj, dx, dy, option = nil)
+      a = obj.coords
+      if option == :track
+        x0 = a[0] + obj.penx
+        y0 = a[1] + obj.peny
+      end
+      (0...a.length).step(2) do |i| 
+        a[i] += dx
+        a[i+1] += dy
+      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' )
+        obj.raise
+      end
+      return a
+    end
+    
+=begin rdoc
+  Attach a "pen point" to an object by adding new accessor methods named penx and peny,
+  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
+    
+=begin rdoc
+  Rotate an object by an angle theta (expressed in degrees).  The object is
+  rotated about the point defined by the first pair of (x,y) coordinates.
+=end
+
+    def Canvas.rotate(obj, theta)
+      theta = Canvas.radians(theta)
+      a = obj.coords
+      x0 = a[0]
+      y0 = a[1]
+      (0...a.length).step(2) do |i| 
+        x = a[i] - x0
+        y = a[i+1] - y0
+        a[i]   = x0 + x * Math.cos(theta) - y * Math.sin(theta)
+        a[i+1] = y0 + x * Math.sin(theta) + y * Math.cos(theta)
+      end
+      obj.coords = a
+      return a
+    end
+       
+    def Canvas.radians(deg)
+      deg * Math::PI / 180
+    end
+    
+    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.
+=end
+    
+    def Canvas.palette(first, last, n)
+  		d = Array.new(3)
+  		3.times { |i| d[i] = (first[i] - last[i]) / n }
+  		a = [first]
+  		(n-1).times do |i|
+  			a << a.last.clone 
+  			3.times { |j| a.last[j] -= d[j] }
+  		end
+  		a << last
+  		a.map { |c| sprintf("#%02X%02X%02X",c[0],c[1],c[2]) }
+  	end
+    
+  end # Canvas
+  
 =begin rdoc
   Priority queue class -- simple wrapper for an array that can only be updated via
   +<<+ and +shift+ operations.  Also responds to +length+, +first+, and +last+,