drx 0.0.2 → 0.3.0

data/lib/drx/tempfiles.rb

@@ -0,0 +1,44 @@
+require 'tempfile'
+
+# Holds a set of related temporary file names. When it goes out of scope, the files are deleted.
+#
+#   files = Tempfiles.new('foo')
+#   puts files['gif']
+#   puts files['xml']
+#
+class Tempfiles
+
+  def initialize(basename=nil)
+    if basename.nil?
+      basename = $0.tr('^a-z', '_').tr('_', '') + 'xyzzy'
+    end
+
+    @refs = []
+    @paths = Hash.new do |h, suffix|
+      tf = Tempfile.new([basename, '.' + suffix])
+      tf.close
+      @refs << tf  # We must keep a ref to this object or its finalizer will delete the temp file.
+      h[suffix] = tf.path
+    end
+
+    if block_given?
+      begin
+        yield self
+      ensure
+        unlink
+      end
+    end
+  end
+
+  def [](suffix)
+    @paths[suffix]
+  end
+
+  # This method shouldn't be needed, as files are supposed to
+  # get deleted when Tempfile instances are GC'ed. But it seems
+  # they aren't always.
+  def unlink
+    @refs.each { |tf| tf.unlink }
+  end
+
+end

data/lib/drx/tk/app.rb

@@ -0,0 +1,363 @@
+require 'tk'
+#Tk.default_widget_set = :Ttk
+require 'drx/tk/imagemap'
+
+module Drx
+  module TkGUI
+
+    # The 'DRX_EDITOR_COMMAND' environment variable overrides this.
+    EDITOR_COMMAND = 'gedit +%d "%s"'
+
+    class Application
+
+      def toplevel
+        @toplevel ||= TkRoot.new
+      end
+
+      def initialize
+        @navigation_history = []
+        @eval_history = LineHistory.new
+
+        @eval_entry = TkEntry.new(toplevel) {
+          font 'Courier'
+        }
+        @eval_result = TkText.new(toplevel) {
+          font 'Courier'
+          height 4
+          foreground 'black'
+          background 'white'
+          tag_configure('error', :foreground => 'red')
+          tag_configure('info', :foreground => 'blue')
+        }
+
+        @im = TkImageMap::ImageMap.new(toplevel)
+        @im.select_command { |url|
+          if url
+            select_object @objs[url].the_object
+          else
+            select_object nil
+          end
+        }
+        @im.double_select_command { |url|
+          navigate_to_selected
+        }
+        @im.bind('ButtonRelease-3') {
+          navigate_back
+        }
+
+        @varsbox = TkListbox.new(toplevel) {
+          width 25
+        }
+        @methodsbox = TkListbox.new(toplevel) {
+          width 35
+        }
+
+        layout
+
+        @varsbox.bind('<ListboxSelect>') {
+          if @varsbox.has_selection?
+            require 'pp'
+            output "\n== Variable #{@varsbox.get_selection}\n\n", 'info'
+            output PP.pp(selected_var, '')
+          end
+        }
+        @varsbox.bind('ButtonRelease-3') {
+          if @varsbox.has_selection?
+            output "\n== Variable #{@varsbox.get_selection}\n\n", 'info'
+            output selected_var.inspect + "\n"
+          end
+        }
+        @varsbox.bind('Double-Button-1') {
+          if @varsbox.has_selection?
+            see selected_var
+          end
+        }
+        @methodsbox.bind('Double-Button-1') {
+          if @methodsbox.has_selection?
+            locate_method(current_object, @methodsbox.get_selection)
+          end
+        }
+        @eval_entry.bind('Key-Return') {
+          code = @eval_entry.value.strip
+          if code != ''
+            @eval_history.add code.dup
+            eval_code code
+            @eval_entry.value = ''
+          end
+        }
+        @eval_entry.bind('Key-Up') {
+          @eval_entry.value = @eval_history.prev!
+        }
+        @eval_entry.bind('Key-Down') {
+          @eval_entry.value = @eval_history.next!
+        }
+        toplevel.bind('Control-l') {
+          @eval_entry.focus
+        }
+        toplevel.bind('Control-r') {
+          # Refresh the display. Useful if you eval'ed some code that changes the
+          # object inspected.
+          navigate_to tip
+          # Note: it seems that #instance_eval creates a singleton for the object.
+          # So after eval'ing something and pressing C-r, you're going to see this
+          # extra class.
+        }
+
+        output "Please visit the homepage, http://drx.rubyforge.org/, for usage instructions.\n", 'info'
+      end
+
+      # Arrange the main widgets inside layout widgets.
+      def layout
+        main_frame = TkPanedwindow.new(toplevel, :orient => :vertical) {
+          pack :side => :top, :expand => true, :fill=> :both, :pady => 2, :padx => 2
+          # We push layout widgets below the main widgets in the stacking order.
+          # We don't want them to obscure the main ones.
+          lower
+        }
+        main_frame.add VBox.new toplevel, [
+          [Scrolled.new(toplevel, @eval_result, :vertical => true), { :expand => true, :fill => 'both' } ],
+          TkLabel.new(toplevel, :anchor => 'w') {
+            text 'Type some code to eval; \'self\' is the object at tip of diagram; prepend with "see" to examine result.'
+          },
+          @eval_entry,
+        ]
+
+        panes = TkPanedwindow.new(main_frame, :orient => :horizontal) {
+          lower
+        }
+        panes.add VBox.new toplevel, [
+          TkLabel.new(toplevel, :text => 'Object graph (klass and super):', :anchor => 'w'),
+          [@im, { :expand => true, :fill => 'both' } ],
+        ]
+        panes.add VBox.new toplevel, [
+          TkLabel.new(toplevel, :text => 'Variables (iv_tbl):', :anchor => 'w'),
+          [Scrolled.new(toplevel, @varsbox), { :expand => true, :fill => 'both' } ]
+        ]
+        panes.add VBox.new toplevel, [
+          TkLabel.new(toplevel, :text => 'Methods (m_tbl):', :anchor => 'w'),
+          [Scrolled.new(toplevel, @methodsbox), { :expand => true, :fill => 'both' } ]
+        ]
+
+        main_frame.add(panes)
+      end
+
+      # Output some text. It goes to the result textarea.
+      def output(s, tag=nil)
+        @eval_result.insert('end', s, Array(tag))
+        # Scroll to the bottom.
+        @eval_result.mark_set('insert', 'end')
+        @eval_result.see('end')
+      end
+
+      def open_up_editor(filename, lineno)
+        command = sprintf(ENV['DRX_EDITOR_COMMAND'] || EDITOR_COMMAND, lineno, filename)
+        output "Execting: #{command}...\n", 'info'
+        if !fork
+          if !Kernel.system(command)
+            output "Could not execute the command '#{command}'\n", 'error'
+          end
+          exit!
+        end
+      end
+
+      def locate_method(obj, method_name)
+        place = ObjInfo.new(obj).locate_method(method_name)
+        if !place
+          output "Method #{method_name} doesn't exist\n", 'info'
+        else
+          if place =~ /\A(\d+):(.*)/
+            open_up_editor($2, $1)
+          else
+            output "Can't locate method, because: #{place}\n", 'info'
+          end
+        end
+      end
+
+      def navigate_back
+        if @navigation_history.size > 1
+          @navigation_history.pop
+          see @navigation_history.pop
+        end
+      end
+
+      def selected_var
+        ObjInfo.new(current_object).__get_ivar(@varsbox.get_selection)
+      end
+
+      def eval_code(code)
+        see = !!code.sub!(/^see\s/, '')
+        begin
+          result = tip.instance_eval(code)
+          output result.inspect + "\n"
+        rescue StandardError, ScriptError => ex
+          gist = "%s: %s" % [ex.class, ex.message]
+          trace = ex.backtrace.reverse.drop_while { |line| line !~ /eval_code/ }.reverse
+          output gist + "\n" + trace.join("\n") + "\n", 'error'
+        end
+        see(result) if see
+      end
+
+      def current_object
+        # For some reason, even though ICLASS contains a copy of the iv_tbl of
+        # its 'klass', these variables are all nil. I think in all cases we'd
+        # want to see the module itself, so that's what we're going to do:
+        info = Drx::ObjInfo.new(@current_object)
+        if info.t_iclass?
+          # The following line is equivalent to 'Core::get_klass(@current_object)'
+          info.klass.the_object
+        else
+          @current_object
+        end
+      end
+
+      # Fills the variables listbox with a list of the object's instance variables.
+      def display_variables(obj)
+        @varsbox.delete('0', 'end')
+        info = ObjInfo.new(obj)
+        if obj and info.has_iv_tbl?
+          vars = info.iv_tbl.keys.map do |v| v.to_s end.sort
+          # Get rid of gazillions of Tk classes:
+          vars = vars.reject { |v| v =~ /Tk|Ttk/ }
+          @varsbox.insert('end', *vars)
+        end
+      end
+
+      # Fills the methods listbox with a list of the object's methods.
+      def display_methods(obj)
+        @methodsbox.delete('0', 'end')
+        info = ObjInfo.new(obj)
+        if obj and info.class_like?
+          methods = info.m_tbl.keys.map do |v| v.to_s end.sort
+          @methodsbox.insert('end', *methods)
+        end
+      end
+
+      # Loads the imagemap widget with a diagram of the object.
+      def display_graph(obj)
+        require 'drx/tempfiles'
+        @objs = {}
+        Tempfiles.new do |files|
+          ObjInfo.new(obj).generate_diagram(files) do |info|
+            @objs[info.dot_url] = info
+          end
+          @im.image = files['gif']
+          @im.image_map = files['map']
+        end
+      end
+
+      # Makes `obj` the primary object seen (the one which is the tip of the diagram).
+      def navigate_to(obj)
+        @current_object = obj
+        @navigation_history << obj
+        display_graph(obj)
+        # Trigger the update of the variables and methods tables by selecting this object
+        # in the imagemap.
+        @im.active_url = @im.urls.first
+      end
+      alias see navigate_to
+
+      # Returns the tip object in the diagram (the one passed to navigate_to())
+      def tip
+        @navigation_history.last
+      end
+
+      # Make `obj` the selected object. That is, the one the variable and method boxes reflect.
+      def select_object(obj)
+         @current_object = obj
+         display_variables(current_object)
+         display_methods(current_object)
+      end
+
+      # Navigate_to the selected object.
+      def navigate_to_selected
+        # current_object() descends T_ICLASS for us.
+        navigate_to(current_object)
+      end
+
+      def run
+        # @todo Skip this if Tk is already running.
+        Tk.mainloop
+        Tk.restart # So that Tk doesn't complain 'can't invoke "frame" command: application has been destroyed' next time.
+      end
+    end
+
+    # Manages history for an input line.
+    class LineHistory
+      def initialize
+        @entries = []
+        @pos = 0
+      end
+      def past_end?
+        @pos >= @entries.size
+      end
+      def add(s)
+        @entries.reject! { |ent| ent == s }
+        @entries << s
+        @pos = @entries.size
+      end
+      def prev!
+        @pos -= 1 if @pos > 0
+        current
+      end
+      def next!
+        @pos += 1 if not past_end?
+        current
+      end
+      def current
+        past_end? ? '' : @entries[@pos]
+      end
+    end
+
+    # Wraps scrollbars around a widget.
+    class Scrolled < TkFrame
+      def initialize(parent, the_widget, opts = { :vertical => true, :horizontal => true })
+        super(parent)
+        @the_widget = the_widget
+        if opts[:vertical]
+          TkScrollbar.new(self) { |s|
+            pack :side => 'right', :fill => 'y'
+            command { |*args| the_widget.yview *args }
+            the_widget.yscrollcommand { |first,last| s.set first,last }
+          }
+        end
+        if opts[:horizontal]
+          TkScrollbar.new(self) { |s|
+            orient 'horizontal'
+            pack :side => 'bottom', :fill => 'x'
+            command { |*args| the_widget.xview *args }
+            the_widget.xscrollcommand { |first,last| s.set first,last }
+          }
+        end
+        the_widget.raise  # Since the frame is created after the widget, it obscures it by default.
+        the_widget.pack(:in => self, :side => 'left', :expand => 'true', :fill => 'both')
+      end
+      def raise
+        super
+        @the_widget.raise
+      end
+    end
+
+    # Arranges widgets one below the other.
+    class VBox < TkFrame
+      def initialize(parent, widgets)
+        super(parent)
+        widgets.each { |w, layout|
+          layout = {} if layout.nil?
+          layout = { :in => self, :side => 'top', :fill => 'x' }.merge layout
+          w.raise
+          w.pack(layout)
+        }
+      end
+    end
+
+    class ::TkListbox
+      def get_selection
+        return get(curselection[0])
+      end
+      def has_selection?
+        not curselection.empty?
+      end
+    end
+
+  end # module TkGUI
+end # module Drx

data/lib/drx/tk/imagemap.rb

@@ -0,0 +1,284 @@
+class TkCanvas
+  def coords(evt)
+    return [canvasx(evt.x), canvasy(evt.y)]
+  end
+end
+
+module TkImageMap
+
+  # A widget to show an image together with an HTML imagemap.
+  class ImageMap < TkFrame
+
+    def select_command &block
+      @select_command = block
+    end
+
+    def double_select_command &block
+      @double_select_command = block
+    end
+
+    # Returns all the URLs.
+    def urls
+      @hotspots.map { |h| h[:url] }
+    end
+
+    # Delegates all bindings to the canvas. That's probably what the
+    # programmer expects.
+    def bind(*args, &block)
+      @canvas.bind *args, &block
+    end
+
+    def initialize(parent, *rest)
+      super
+      @hover_region = nil
+      @active_region = nil
+      @hotspots = []
+      @image_widget = nil
+      @select_command = proc {}
+      @double_select_command = proc {}
+
+      @canvas = TkCanvas.new self, :scrollregion => [0, 0, 2000, 2000]
+
+      v_scr = TkScrollbar.new(self, :orient => 'vertical').pack :side=> 'right', :fill => 'y'
+      h_scr = TkScrollbar.new(self, :orient => 'horizontal').pack :side=> 'bottom', :fill => 'x'
+      @canvas.xscrollbar(h_scr)
+      @canvas.yscrollbar(v_scr)
+      # Attach scrolling to middle button.
+      @canvas.bind('2', proc { |x,y| @canvas.scan_mark(x,y) }, '%x %y')
+      @canvas.bind('B2-Motion', proc { |x,y| @canvas.scan_dragto x, y }, '%x %y')
+
+      @canvas.pack :expand => true, :fill => 'both'
+
+      ['Motion','Control-Motion'].each { |sequence|
+        @canvas.bind sequence do |evt|
+          x, y = @canvas.coords(evt)
+          spot = @canvas.find('overlapping', x, y, x + 1, y + 1).first
+          if spot and spot.cget('tags').include? 'hotspot'
+            new_hover_region = spot.hotspot_region
+          else
+            new_hover_region = nil
+          end
+          if new_hover_region != @hover_region
+            @hover_region[:hover_spot].configure(:state => 'hidden') if @hover_region
+            @hover_region = new_hover_region
+            @hover_region[:hover_spot].configure(:state => 'disabled') if @hover_region # like 'visible'
+            if sequence['Control']
+              self.active_region = @hover_region
+            end
+          end
+        end
+      }
+      @canvas.bind 'Button-1' do |evt|
+        x, y = @canvas.coords(evt)
+        spot = @canvas.find('overlapping', x, y, x+1, y+1).first
+        if spot and spot.cget('tags').include? 'hotspot'
+          self.active_region = spot.hotspot_region
+        else
+          self.active_region = nil
+        end
+      end
+      @canvas.bind 'Double-Button-1' do
+        @double_select_command.call(active_url) if @active_region
+      end
+      # Middle button: vertical scrolling.
+      @canvas.bind 'Button-4' do
+        @canvas.yview_scroll(-1, 'units')
+      end
+      @canvas.bind 'Button-5' do
+        @canvas.yview_scroll(1, 'units')
+      end
+      # Middle button: horizontal scrolling.
+      @canvas.bind 'Shift-Button-4' do
+        @canvas.xview_scroll(-1, 'units')
+      end
+      @canvas.bind 'Shift-Button-5' do
+        @canvas.xview_scroll(1, 'units')
+      end
+    end
+
+    def active_region=(region)
+      if region != @active_region
+        @active_region[:active_spot].configure(:state => 'hidden') if @active_region
+        @active_region = region
+        @active_region[:active_spot].configure(:state => 'disabled') if @active_region # like 'visible'
+        @select_command.call(active_url)
+      end
+    end
+
+    def active_url
+      @active_region ? @active_region[:url] : nil
+    end
+
+    def active_url=(newurl)
+      catch :found do
+        @hotspots.each { |region|
+          if region[:url] == newurl
+            self.active_region = region
+            throw :found
+          end
+        }
+        # It was not found:
+        self.active_region = nil
+      end
+    end
+
+    def image=(pathname)
+      @image = TkPhotoImage.new :file => pathname
+      @canvas.configure :scrollregion => [0, 0, @image.width, @image.height]
+    end
+
+    # You must call this after image=()
+    def image_map=(pathname)
+      # Delete the previous spot widgets and the image widget.
+      @canvas.find('all').each {|w| w.destroy }
+      @canvas.xview_moveto(0)
+      @canvas.yview_moveto(0)
+
+      @hotspots = Utils.parse_imap(pathname)
+
+      #
+      # Create the back spots.
+      #
+      @hotspots.each do |region|
+        args = [@canvas, *(region[:args])]
+        opts = {
+          :fill => 'red',
+          :tags => ['hotspot']
+        }
+        back_spot = region[:class].new *(args + [opts])
+        # The following won't work, so we have to use define_method instead.
+        #def back_spot.hotspot_region
+        #   region
+        #end
+        meta = class << back_spot; self; end
+        meta.send :define_method, :hotspot_region do
+          region
+        end
+      end
+
+      @image_widget = TkcImage.new(@canvas,0,0, :image => @image, :anchor=> 'nw')
+
+      #
+      # Create the hover spots.
+      #
+      @hotspots.each do |region|
+        args = [@canvas, *(region[:args])]
+        opts = {
+          :dash => '. ',
+          :width => 5,
+          :fill => nil,
+          :outline => 'black',
+          :state => 'hidden'
+        }
+        region[:hover_spot] = region[:class].new *(args + [opts])
+        opts = {
+          :width => 5,
+          :fill => nil,
+          :outline => 'black',
+          :state => 'hidden'
+        }
+        region[:active_spot] = region[:class].new *(args + [opts])
+      end
+    end
+  end # class ImageMap
+
+  module Utils
+
+    # DOT outputs oval elements as polygons with many many sides. Since Tk doesn't
+    # draw them well, we convert such polygons to ovals.
+    def self.to_oval(coords)
+      points = coords.enum_slice(2).to_a
+      if points.size < 10
+        # If there are few sides, we assume it's a real polygon.
+        return nil
+      end
+      x_min, x_max = points.map {|p| p[0]}.minmax
+      y_min, y_max = points.map {|p| p[1]}.minmax
+      # @todo: try to figure out if the points trace a circle?
+      #center_x = x_min + (x_max - x_min) / 2.0
+      #center_y = y_min + (y_max - y_min) / 2.0
+      #points.each do |x,y|
+      #end
+      return [x_min, y_min, x_max, y_max]
+    end
+
+    # Parses an HTML image map.
+    def self.parse_imap(filepath)
+      hotspots = []
+      require 'rexml/document'
+      doc = REXML::Document.new(File.open(filepath))
+      doc.root.elements.each do |elt|
+        if elt.is_a? REXML::Element and elt.name == 'area'
+          attrs  = elt.attributes
+          url    = attrs['href']
+          coords = attrs['coords'].split(/,|\s+/).map{|c|c.to_i}  # @todo: A circle's radius can be a percent.
+          case attrs['shape']
+          when 'poly';
+            if args = to_oval(coords)
+              hotspots << {
+                :args => args,
+                :class => TkcOval,
+                :url => url,
+              }
+            else
+              hotspots << {
+                :args => coords,
+                :class => TkcPolygon,
+                :url => url,
+              }
+            end
+          when 'rect';
+            hotspots << {
+              :args => coords,
+              :class => TkcRectangle,
+              :url => url,
+            }
+          when 'circle';
+            cx, cy, radius = coords
+            hotspots << {
+              :args => [cx - radius, cy - radius, cx + radius, cy + radius],
+              :class => TkcOval,
+              :url => url,
+            }
+          else raise "I don't support shape '#{attrs['shape']}'"
+          end
+        end
+      end
+      return hotspots
+    end
+  end # module Utils
+
+end # module TkImageMap
+
+if $0 == __FILE__    # A little demonstration.
+
+  class App  # :nodoc:
+    def initialize
+      @root = TkRoot.new
+      im = TkImageMap::ImageMap.new(@root)
+      im.pack :expand => true, :fill => 'both'
+      im.image = 'a.gif'
+      im.image_map = 'a.map'
+      im.select_command { |url|
+        if url
+          puts 'clicked: ' + url
+        else
+          puts 'cleared'
+        end
+      }
+      im.double_select_command { |url|
+        puts 'going to ' + url
+      }
+      btn = TkButton.new @root
+      btn.pack
+      btn.command {
+        p 'button clicked'
+        im.active_url = 'http://server/obj/o_1224289036'
+      }
+    end
+  end
+
+  app = App.new
+  Tk.mainloop
+
+end