tkar 0.63

data/lib/tkar.rb

@@ -0,0 +1,109 @@
+require 'enumerator'
+
+module Tkar
+  class Error < StandardError; end
+  module Recoverable; end
+  
+  RADIANS_TO_DEGREES = 180.0 / Math::PI
+  DEGREES_TO_RADIANS = Math::PI / 180.0
+
+  require 'tkar/window'
+  require 'tkar/stream'
+
+  def self.run(argv, opts)
+    verbose = opts["v"]
+    title = argv.empty? ?  "stdin" : argv.join(":")
+    root = TkRoot.new { title "Tkar @ #{title}"; iconname "Tkar" }
+    root.resizable true, true
+    window = Window.new(root, opts)
+    canvas = window.canvas
+
+    thread = Thread.new do
+      movie = false
+      if movie
+        win_id = root.winfo_id
+        pid = Process.pid
+      end
+      
+      persist = opts["persist"]
+      
+      f = MessageStream.for(argv, opts)
+      window.def_message_out do |msg|
+        begin
+          f.put_msg msg if f
+          $stderr.puts msg if verbose
+        rescue MessageStream::StreamClosed
+        rescue Errno::ECONNABORTED, Errno::ECONNRESET
+          raise unless persist
+        end
+      end
+
+      cmd = args = nil
+    
+      update_count = 0
+      start_time = Time.now
+      
+      j = 0
+      begin
+        loop do
+          cmd, *args = f.get_cmd
+          break if cmd == "done"
+          exit if cmd == "exit"
+          if cmd == "update"
+            f.put_msg "update" ## optional?
+            update_count += 1
+            if verbose and update_count % 100 == 0
+              rate = update_count / (Time.now - start_time)
+              $stderr.puts "update rate: %10.2f updates per second" % rate
+              update_count = 0
+              start_time = Time.now
+            end
+          end
+          r = canvas.send(cmd, *args)
+          # f.put_msg return_value if return_value ?
+          
+          if movie and cmd == "update"
+            # add a frame to the movie
+            mcmd =
+              "import -window #{win_id} \"tmp/#{pid}_frame_%05d.miff\"" % j
+            j += 1
+            rslt = system(mcmd)
+            unless rslt
+              puts $?
+              exit
+            end
+          end
+        end
+      rescue MessageStream::StreamClosed
+        f.put_msg "stream closed"
+        exit unless persist
+        canvas.update
+      rescue Recoverable => ex
+        f.put_msg ex
+        retry
+      rescue Errno::ECONNABORTED, Errno::ECONNRESET
+        raise unless persist
+      rescue => ex
+        begin
+            f.put_msg ex
+            f.put_msg "exiting"
+        rescue Errno::ECONNABORTED, Errno::ECONNRESET
+        end
+        $stderr.puts "#{ex.class}: #{ex.message}", ex.backtrace.join("\n  ")
+        raise unless persist
+      end
+    end
+
+#     if /mswin32/ =~ RUBY_PLATFORM
+#       3.times do
+#         timer = TkTimer.new(1) do
+#           3.times {thread.run}
+#         end
+#
+#         timer.start
+#       end
+#     end
+
+    Tk.mainloop
+  end
+end

data/lib/tkar/argos.rb

@@ -0,0 +1,214 @@
+# A slim command-line parser that does one thing well: turn an array of
+# strings, such as ARGV, into a hash of recognized options and their
+# arguments, leaving unrecognized strings in the original array.
+#
+# Argos was Odysseus' faithful dog, who was good at recognizing ;)
+#
+# Synopsis:
+#
+#    require 'argos'
+#
+#    optdef = {
+#      "v"   => true,
+#      "n"   => proc {|arg| Integer(arg)}
+#    }
+#
+#    argv = %w{-v -n10 filename}
+#    opts = Argos.parse_options(argv, optdef)
+#    p opts    # ==> {"v"=>true, "n"=>10}
+#    p argv    # ==> ["filename"]
+#
+# Features:
+#
+# - Operates on ARGV or any given array of strings.
+#
+# - Output is a hash of {option => value, ...}.
+#
+# - You can merge this hash on top of a hash of defaults if you want.
+#
+# - Supports both long ("--foo") and short ("-f") options.
+#
+# - A long option with an argument is --foo=bar or --foo bar.
+#
+# - A short option with an argument is -fbar or -f bar.
+#
+# - The options -x and --x are synonymous.
+#
+# - Short options with no args can be combined as -xyz in place of -x -y -z.
+#
+# - If -z takes an argument, then -xyz foo is same as -x -y -z foo.
+#
+# - The string "--" terminates option parsing, leaving the rest untouched.
+#
+# - The string "-" is not considered an option.
+#
+# - ARGV (or other given array) is modified: it has all parsed options
+#   and arguments removed, so you can use ARGF to treat the rest as input files.
+#
+# - Unrecognized arguments are left in the argument array. You can catch them
+#   with grep(/^-./), in case you want to pass them on to another program or
+#   warn the user.
+#
+# - Argument validation and conversion are in terms of an option definition
+#   hash, which specifies which options are allowed, the number of arguments
+#   for each (0 or 1), and how to generate the value from the argument, if any.
+#
+# - Repetition of args ("-v -v", or "-vv") can be handled by closures. See
+#   the example below.
+#
+# - Everything is ducky. For example, handlers only need an #arity method
+#   and a #[] method to be recognized as callable. Otherwise they are treated
+#   as static objects.
+#
+# Limitations:
+#
+# - A particular option takes either 0 args or 1 arg. There are no optional
+#   arguments, in the sense of both "-x" and "-x3" being accepted.
+#
+# - Options lose their ordering in the output hash (but they are parsed in
+#   order and you can keep track using state in the handler closures).
+#
+# - There is no usage/help output.
+#
+# Copyright (C) 2006-2009 Joel VanderWerf, mailto:vjoel@users.sourceforge.net.
+#
+# License is the Ruby license. See http://www.ruby-lang.org.
+#
+module Argos
+  module_function
+
+  # Raised (a) when an option that takes an argument occurs at the end of the
+  # argv list, with no argument following it, or (b) when a handler barfs.
+  class OptionError < ArgumentError; end
+  
+  # Called when an option that takes an argument occurs at the end of the
+  # argv list, with no argument following it.
+  def argument_missing opt
+    raise OptionError, "#{opt}: no argument provided."
+  end
+  
+  def handle opt, handler, *args # :nodoc
+    args.empty? ?  handler[] : handler[args[0]]
+  rescue => ex
+    raise OptionError, "#{opt}: #{ex}"
+  end
+
+  # Returns the hash of parsed options and argument values. The +argv+ array
+  # is modified: every recognized option and argument is deleted.
+  #
+  # The +optdef+ hash defines the options and their arguments.
+  #
+  # Each key is an option name (without "-" chars).
+  #
+  # The value for a key in +optdef+
+  # is used to generate the value for the same key in the options hash
+  # returned by this method.
+  #
+  # If the value has an #arity method and arity > 0, the value is considered to
+  # be a handler; it is called with the argument string to return the value
+  # associated with the option in the hash returned by the method.
+  #
+  # If the arity <= 0, the value is considered to be a handler for an option
+  # without arguments; it is called with no arguments to return the value of
+  # the option.
+  #
+  # If there is no arity method, the object itself is used as the value of
+  # the option.
+  #
+  # Only one kind of input will cause an exception (not counting exceptions
+  # raised by handler code or by bugs):
+  #
+  # - An option is found at the end of the list, and it requires an argument.
+  #   This results in a call to #argument_missing, which by default raises
+  #   OptionError.
+  #
+  def parse_options argv, optdef
+    orig = argv.dup; argv.clear
+    opts = {}
+
+    loop do
+      case (argstr=orig.shift)
+      when nil, "--"
+        argv.concat orig
+        break
+
+      when /^(--)([^=]+)=(.*)/, /^(-)([^-])(.+)/
+        short = ($1 == "-"); opt = $2; arg = $3
+        unless optdef.key?(opt)
+          argv << argstr
+          next
+        end
+        handler = optdef[opt]
+        arity = (handler.arity rescue nil)
+        opts[opt] =
+          case arity
+          when nil;   orig.unshift("-#{arg}") if short; handler
+          when 0,-1;  orig.unshift("-#{arg}") if short; handle(opt, handler)
+          else        handle(opt, handler, arg)
+          end
+
+      when /^--(.+)/, /^-(.)$/
+        opt = $1
+        unless optdef.key?(opt)
+          argv << argstr
+          next
+        end
+        handler = optdef[opt]
+        arity = (handler.arity rescue nil)
+        opts[opt] =
+          case arity
+          when nil;   handler
+          when 0,-1;  handle(opt, handler)
+          else        handle(opt, handler, orig.shift || argument_missing(opt))
+          end
+
+      else
+        argv << argstr
+      end
+    end
+
+    opts
+  end
+end
+
+if __FILE__ == $0
+
+  v = 0
+  defaults = {
+    "v"     => v,
+    "port"  => 4000,
+    "host"  => "localhost"
+  }
+
+  optdef = {
+    "x"     => true,
+    "y"     => "y",
+    "z"     => 3,
+    "v"     => proc {v+=1}, # no argument, but call the proc to get the value
+    "port"  => proc {|arg| Integer(arg)},
+    "n"     => proc {|arg| Integer(arg)},
+    "t"     => proc {|arg| Float(arg)},
+    "cmd"   => proc {|arg| arg.split(",")}
+  }
+
+  ARGV.replace %w{
+    -xyzn5 somefile --port 5000 -t -1.23 -vv -v --unrecognized-option
+    --cmd=ls,-l otherfile -- --port
+  }
+  
+  begin
+    cli_opts = Argos.parse_options(ARGV, optdef)
+  rescue Argos::OptionError => ex
+    $stderr.puts ex.message
+    exit
+  end
+  
+  opts = defaults.merge cli_opts
+
+  p opts
+  p ARGV
+  unless ARGV.empty?
+    puts "Some arg-looking strings were not handled:", *ARGV.grep(/^-./)
+  end
+  
+end

data/lib/tkar/canvas.rb

@@ -0,0 +1,370 @@
+require 'tk'
+require 'tkar/tkaroid'
+require 'tkar/primitives'
+require 'tkar/timer'
+
+module Tkar
+  class Canvas < TkCanvas
+    class Error < Tkar::Error; end
+    class MissingObject < Error; end
+    
+    attr_reader :zoom
+    attr_accessor :follow_id
+  
+    def initialize(*)
+      super
+
+      @shapes = {}
+      @shape_def = {}
+      @zoom = 1.0
+      init_objects
+    end
+    
+    def init_objects
+      @objects = {}
+      @changed = {}
+      @layers = []            # sorted array of layer numbers
+      @objects_by_layer = {}  # layer => [obj, ...]
+      follow nil
+    end
+    
+    def zoom_by zf
+      zf = Float(zf)
+      @zoom *= zf
+      
+      vf = (1 - 1/zf) / 2
+      
+      x0, x1 = xview
+      xf = x0 + vf * (x1-x0)
+
+      y0, y1 = yview
+      yf = y0 + vf * (y1-y0)
+
+      scale 'all', 0, 0, zf, zf
+      adjust_scrollregion
+
+      xview "moveto", xf
+      yview "moveto", yf
+    end
+    
+    def adjust_scrollregion
+      configure :scrollregion => @bounds.map {|u|u*@zoom}
+      ## if all of canvas can be shown, hide the scroll bars
+    end
+    
+    def xview(mode=nil, *args)
+      if mode and mode == "scroll" and @follow_xdelta
+        number, what = args
+        x_pre, = xview
+        r = super(mode, *args)
+        x_post, = xview
+        x0,y0,x1,y1 = @bounds
+        @follow_xdelta += (x_post - x_pre) * (x1-x0)
+        r
+      elsif not mode
+        super()
+      else
+        super(mode, *args)
+      end
+    end
+    
+    def yview(mode=nil, *args)
+      if mode and mode == "scroll" and @follow_ydelta
+        number, what = args
+        y_pre, = yview
+        r = super(mode, *args)
+        y_post, = yview
+        x0,y0,x1,y1 = @bounds
+        @follow_ydelta += (y_post - y_pre) * (y1-y0)
+        r
+      elsif not mode
+        super()
+      else
+        super(mode, *args)
+      end
+    end
+    
+    # fixes a bug in RubyTk
+    def scan_dragto(x, y, gain = 10)
+      tk_send_without_enc('scan', 'dragto', x, y, gain)
+      self
+    end
+
+    def view_followed_obj
+      tkaroid = get_object(@follow_id)
+      if tkaroid
+        view_at(tkaroid.x + @follow_xdelta, tkaroid.y + @follow_ydelta)
+      end
+    end
+
+    def current_width
+      Integer(TkWinfo.geometry(self)[/\d+/])
+    end
+
+    def current_height
+      Integer(TkWinfo.geometry(self)[/\d+x(\d+)/, 1])
+    end
+
+    # ------------------------
+    # :section: Tkaroid manipulation commands
+    #
+    # Methods which operate on the population of objects shown in the canvas.
+    # ------------------------
+
+    def get_shape name
+      @shapes[name] || (fail MissingObject, "No such shape, #{name}")
+    end
+    
+    def get_object tkar_id
+      @objects[tkar_id] || (fail MissingObject, "No such object, #{tkar_id}")
+    end
+    
+    def get_objects_by_layer layer
+      ary = @objects_by_layer[layer]
+      unless ary
+        ary = @objects_by_layer[layer] = []
+        @layers << layer
+        @layers.sort!
+      end
+      ary
+    end
+    
+    def insert_at_layer tkaroid
+      layer = tkaroid.layer
+      peers = get_objects_by_layer(layer)
+      if peers.empty?
+        high = @layers.find {|l| l > layer}
+        if high
+          high_objects = get_objects_by_layer(high)
+          unless high_objects.empty?
+            lower tkaroid.tag, high_objects.first.tag
+          end
+        else
+          low = @layers.reverse.find {|l| l < layer}
+          if low
+            low_objects = get_objects_by_layer(low)
+            unless low_objects.empty?
+              raise tkaroid.tag, low_objects.last.tag
+            end
+          #else must be the only object!
+          end
+        end
+      else
+        raise tkaroid.tag, peers.last.tag
+      end
+      peers << tkaroid
+    end
+    
+    def current_tkaroid
+      object = find_withtag('current').first
+      if object
+        tags = object.tags
+        tkar_id = tags.grep(/^tkar\d+$/).first[/\d+/].to_i
+        @objects[tkar_id]
+      end
+    end
+    
+    # ------------------------
+    # :section: Commands
+    #
+    # Methods which handle incoming commands.
+    # ------------------------
+
+    def add shape_name, tkar_id, flags, layer, x, y, r, *params
+      del(tkar_id)
+      
+      tkaroid = Tkaroid.new do |t|
+        t.shape   = get_shape(shape_name)
+        t.id      = tkar_id
+        t.flags   = flags
+        t.layer   = layer
+        t.x       = x
+        t.y       = y
+        t.r       = r
+        t.params  = params
+        t.newly_added = true
+      end
+
+      @objects[tkar_id] = tkaroid
+      @changed[tkar_id] = tkaroid
+    end
+
+    # Not "delete"! That already exists in tk.
+    def del tkar_id
+      tkaroid = @objects[tkar_id]
+      if tkaroid
+        if @follow_id == tkar_id
+          follow nil
+        end
+        delete tkaroid.tag
+        @objects.delete tkar_id
+        @changed.delete tkar_id
+        get_objects_by_layer(tkaroid.layer).delete tkaroid
+      end
+    end
+
+    def moveto tkar_id, x, y
+      tkaroid = get_object(tkar_id)
+      unless tkaroid.x == x and tkaroid.y == y
+        tkaroid.x = x
+        tkaroid.y = y
+        @changed[tkar_id] = tkaroid
+      end
+    end
+
+    def rot tkar_id, r
+      tkaroid = get_object(tkar_id)
+      unless tkaroid.r == r
+        tkaroid.r = r
+        @changed[tkar_id] = tkaroid
+      end
+    end
+
+    def param tkar_id, idx, val
+      tkaroid = get_object(tkar_id)
+      params = tkaroid.params
+      unless params[idx] == val
+        tkaroid.params[idx] = val
+        @changed[tkar_id] = tkaroid
+      end
+    end
+    
+    def check_param param
+      if param.nil?
+        nil
+      elsif param.is_a? String and param[0] == ?*
+        param_idx = Integer(param[1..-1])
+        proc {|param_array| param_array[param_idx]}
+      else
+        (Integer(param) rescue Float(param)) rescue param
+      end
+    end
+    
+    def compile_shape defn
+      part_spec_defs = defn.scan(/([_A-Za-z]+)([^;]*);?/)
+      
+      part_spec_defs.map do |prim_name, args|
+        args = args.split(",")
+        key_args, args = args.partition {|arg| /:/ =~ arg}
+
+        macro = @shape_def[prim_name]
+        if macro
+          macro2 = macro.gsub(/\*\d+/) {|s| i=Integer(s[/\d+/]); args[i]}
+          macro2 = [macro2, *key_args].join(",")
+          compile_shape(macro2)
+        else
+          args.map! {|arg| check_param(arg)}
+          key_args.map! {|key_arg| key_arg.split(":")}
+          key_args.map! do |k, v|
+            [Primitives.handle_shortcuts(k), v]
+          end
+          key_args = key_args.inject({}) {|h,(k,v)| h[k] = check_param(v); h}
+          Primitives.send(prim_name, args, key_args)
+        end
+      end
+    end
+
+    def shape name, *defn
+      defn = defn.join(";")
+      part_spec_makers = compile_shape(defn)
+      part_spec_makers.flatten!
+      @shape_def[name] = defn # should prevent inf recursion
+      
+      @shapes[name] = proc do |tkaroid|
+        cos_r = Math::cos(tkaroid.r)
+        sin_r = Math::sin(tkaroid.r)
+        
+        part_spec_makers.map do |maker|
+          maker[tkaroid, cos_r, sin_r]
+        end
+      end
+    end
+
+    def update
+      z = (zoom - 1).abs > 0.01 && zoom
+      
+      thread = Thread.current
+      pri = thread.priority
+      thread.priority += 10
+      
+      @changed.each do |tkar_id, tkaroid|
+        newly_added = tkaroid.update(self, z)
+        if newly_added
+          insert_at_layer(tkaroid)
+        end
+      end
+      @changed.clear
+
+      view_followed_obj if @follow_id
+    ensure
+      thread.priority = pri if thread
+    end
+    
+    def title str
+      @root.title str
+    end
+    
+    #background, height, width # already defined!
+    
+    def window_xy x,y
+      s = ""
+      s << "+" if x > 0
+      s << x.to_s
+      s << "+" if y > 0
+      s << y.to_s
+      @root.geometry s
+    end
+
+    def zoom_to z
+      zoom_by(z/@zoom)
+    end
+    
+    def view_at x, y
+      x0,y0,x1,y1 = @bounds
+      width = TkWinfo.width(self)
+      height = TkWinfo.height(self)
+      xview "moveto", (x-x0-(width/(@zoom*2.0)))/(x1-x0).to_f
+      yview "moveto", (y-y0-(height/(@zoom*2.0)))/(y1-y0).to_f
+    end
+    
+    def view_at_screen x,y
+      view_at(canvasx(x)/@zoom, canvasy(y)/@zoom)
+    end
+
+    def view_id id
+      tkaroid = get_object(id)
+      view_at tkaroid.x, tkaroid.y if tkaroid
+    end
+    
+    def wait t
+      unless @timer
+        @timer = Timer.new(t)
+      end
+      @timer.wait(t)
+    end
+    
+    def follow id
+      @follow_id = id
+      @follow_xdelta = id && 0
+      @follow_ydelta = id && 0
+    end
+    
+    def bounds x0,y0,x1,y1
+      @bounds = [x0,y0,x1,y1]
+      adjust_scrollregion
+    end
+    
+    def delete_all
+      @objects.values.each do |tkaroid|
+        delete tkaroid.tag
+      end
+      init_objects
+    end
+    
+    def scale_obj tkar_id, xf, yf
+      tkaroid = get_object(tkar_id)
+      z = @zoom
+      scale tkaroid.tag, tkaroid.x*z, tkaroid.y*z, xf, yf
+    end
+  end
+end