hilfer 0.9.0

data/lib/hilfer/tree_viewer.rb

@@ -0,0 +1,805 @@
+# local files
+# local files
+require 'hilfer/scite_editor.rb'
+require 'hilfer/rails_locator.rb'
+require 'hilfer/svn_colours.rb'
+require 'pathname'
+
+=begin
+This is the tree viewer object. It contains a GtkTreeView
+and references an editor object. It also contains a HilferItem
+which is the root node of the tree, but it's never displayed
+=end
+class TreeViewer
+  include SvnColours
+  
+  attr_reader :view, :editor, :root_item
+
+  # Can pass in $options[:terminal] => some_terminal
+  # to use different terminal types. See GnomeTerminal
+  # for an example
+  def initialize( path, editor, parent_window, location )
+    @terminal = $options[:terminal]
+    @parent_window = parent_window
+    @location = location
+    @location.activates_default = false
+
+    # these need to be window-local
+    @expecting_synchronize_path = false
+    @auto_synchronize_path = $options[:auto_sync]
+    @root_item = HilferItem.new( '', path )
+    # TODO this shuold be in set_root or something like that
+    @location.text = @root_item.path
+    @location.select_region(0,0)
+    @location.position = -1
+    @hilfer_items = {}
+    
+    # locators are things that provide a set of shortcut keys
+    # to jump to specific directories, files, or related locations
+    @locators = []
+    @locators << RailsLocator.new( self )
+
+    # pre-populate model from filesystem, only 1 level deep
+    #model = Gtk::TreeStore.new( HilferItem )
+    model = HilferModel.new( HilferItem )
+    populate( model, @root_item, nil )
+
+    # Create view
+    @view = Gtk::TreeView.new( model )
+    @view.headers_visible = false
+    @view.selection.mode = Gtk::SELECTION_MULTIPLE
+
+    # register with the editor, and remember it
+    editor.register_view( self )
+    @editor = editor
+
+    # handle key presses
+    init_keys
+
+    # handle enter for location bar
+    @location.signal_connect( 'activate' ) do |widget|
+      new_path = File.expand_path( widget.text )
+      if File.exists? new_path
+        go_into( new_path )
+      else
+        dialog = Gtk::MessageDialog.new(
+          @window,
+          Gtk::Dialog::Flags::MODAL,
+          Gtk::MessageDialog::Type::INFO,
+          Gtk::MessageDialog::BUTTONS_OK,
+          "Directory #{widget.text} does not exist"
+        )
+        dialog.run
+        dialog.destroy
+      end
+    end
+
+    @location.signal_connect( 'focus-out-event' ) do |widget,event|
+      #make sure everything is unselected, and put the cursor at the end
+      widget.select_region(0,0)
+      widget.position = -1
+    end
+
+    # handle double-clicks so they don't activate the
+    # cell editing
+    @view.signal_connect( 'button-press-event' ) do
+      |view, event|
+      if event.button == 1 && event.event_type == Gdk::Event::BUTTON2_PRESS
+        path, column, cell_x, cell_y = view.get_path( *event.coords )
+        if iter = view.model.get_iter( path )
+          open_action( [ iter[0] ] )
+          true
+        end
+      end
+    end
+
+    # handle collapse and expand are cached in HilferItems
+    @view.signal_connect( 'row-collapsed' ) do
+      |view, iter, path|
+      iter[0].status = :collapsed
+      true
+    end
+
+    @view.signal_connect( 'row-expanded' ) do
+      |view, iter, path|
+      print "expanding row: #{iter[0].path}, #{iter[0].populated?}\n" if $options[:debug]
+      iter[0].status = :expanded
+      child = iter.first_child
+      loop do
+        print "expanded child: #{child[0].path}, #{child[0].populated?}\n" if $options[:debug]
+        populate( @view.model, child[0], child ) unless child[0].populated?
+        break if !child.next!
+      end
+
+      # remember expanded status
+      setstatus
+      true
+    end
+
+    # add widgets for the columns and cells
+    init_renderers
+
+    # all columns must be fixed for this to work
+    @view.fixed_height_mode = true
+
+    init_searchable
+
+    # Allow drag and drop reordering of rows
+    # would need to be hooked into fs move, and maybe
+    # the refresh so that items aren't put back in their original
+    # places. That's hard.
+    #@view.set_reorderable( true)
+
+    # set up refresh thread
+    #~ Thread.new( self ) do |arg|
+      #~ loop do
+        #~ sleep 2
+        #~ arg.refresh
+        #~ print "refreshed\n"
+      #~ end
+    #~ end
+  end
+
+  def refresh
+    go_into( @root_item.path )
+    if $options[:debug]
+      load 'rails_locator.rb'
+      load 'tree_viewer.rb'
+    end
+  end
+
+  def init_renderers
+    # The column to display everything in
+    column = Gtk::TreeViewColumn.new( "icon and name" )
+    column.resizable = false
+    column.sizing = Gtk::TreeViewColumn::FIXED
+
+    # display the icon
+    pixbuf_renderer = Gtk::CellRendererPixbuf.new
+    column.pack_start( pixbuf_renderer, false )
+    column.set_cell_data_func( pixbuf_renderer ) do
+      |column, renderer, model, iter|
+      item = iter[0]
+
+      # figure out which icon to use
+      stock =
+      if item.dir?
+        if renderer.expanded?
+          Gtk::Stock::OPEN
+        else
+          Gtk::Stock::OPEN
+        end
+      else
+        Gtk::Stock::FILE
+      end
+
+      # set the icon
+      renderer.pixbuf = @view.render_icon( stock, Gtk::IconSize::MENU, 'cell_renderer' )
+    end
+
+    # display the file name
+    @text_renderer = Gtk::CellRendererText.new
+    @text_renderer.ypad = 0
+    column.pack_start( @text_renderer, true )
+    column.set_cell_data_func( @text_renderer ) do
+      |column, renderer, model, iter|
+      item = iter[0]
+      renderer.text = item.item
+      renderer.foreground = item.colour
+    end
+
+    # Allow file renames
+    @text_renderer.signal_connect("editing-started") do |widget,editable,path|
+      editable && editable.signal_connect("editing-done") do |widget|
+        # Fetch the HilferItem
+        item = @view.model.get_iter(path)[0]
+        
+        # make the new file name, in full
+        new_path = ( Pathname.new( item.path ).parent + editable.text )
+        
+        # rename the file if it's renameable
+        if editable.text != item.item && !File.exists?( new_path.to_s )
+          # rename the file
+          begin
+            File.rename( item.path, new_path.to_s )
+            item.item = editable.text
+            item.path = new_path.to_s
+          rescue Exception => e
+            print "couldn't rename #{item.path} to #{new_path.to_s}\n"
+            print e, "\n"
+            e.backtrace.each { | line | print line, "\n" }
+          end
+        end
+        true
+      end
+      
+      true
+    end
+    
+    @view.append_column( column )
+  end
+
+  # Set the interactive search box
+  def init_searchable
+    # allow tree to be searchable using regular expressions
+    @view.search_column = 0
+    @view.enable_search = true
+    @view.set_search_equal_func do
+      # - model: a Gtk::TreeModel
+      # - column: a Column number
+      # - key: a String
+      # - iter: a Gtk::TreeIter
+      # - Returns: true to continue, or false to quit(the word is matched).
+      |model, column, key, iter|
+      begin
+        iter[0].item !~ /#{key}/
+      rescue
+        true
+      end
+    end
+  end
+
+  # display a dialog and delete the files if the
+  # response was yes. Unless the don't ask for file
+  # deletion flag is switched off
+  def confirm_delete_files( iters )
+    msg = "Are you sure you want to delete\n"
+    iters.each { |it| msg += it[0].path + "\n" }
+    
+    confirm = Gtk::MessageDialog.new(
+      @window,
+      Gtk::Dialog::Flags::MODAL,
+      Gtk::MessageDialog::Type::QUESTION,
+      Gtk::MessageDialog::BUTTONS_YES_NO,
+      msg
+    )
+    confirm.default_response = Gtk::Dialog::RESPONSE_YES
+    confirm.signal_connect( 'key-press-event' ) do
+      |widget,event|
+      case event.hardware_keycode
+        when 57 # n pressed
+          confirm.response( Gtk::Dialog::RESPONSE_NO )
+          true
+        when 29 # y pressed
+          confirm.response( Gtk::Dialog::RESPONSE_YES )
+          true
+      end
+    end
+    
+    # actually delete the files
+    confirm.run do |response|
+      delete_files( iters ) if response == Gtk::Dialog::RESPONSE_YES
+      confirm.destroy
+    end
+  end
+
+  def delete_files( iters )
+    iters.each do |it|
+      begin
+        File.delete it[0].path
+        @view.model.remove(it)
+      rescue
+        print "Can't delete #{it[0].path}"
+      end
+    end
+  end
+
+  # handle keypresses
+  def init_keys
+    @view.signal_connect( 'key-press-event' ) do
+      |widget,event|
+      #puts event.inspect
+      retval = true
+      case
+        # enter - go into directory
+        # or open all selected files
+        when event.hardware_keycode == 36 && event.state.empty?
+          items = []
+          
+          # fetch all selected items
+          widget.selection.selected_each do |model, path, iter|
+            items << model.get_value( iter, 0 )
+          end
+          
+          # go into if the first item is a directory
+          open_action( items )
+          
+        # ctrl-enter opens new window with the selected root(s)
+        when event.hardware_keycode == 36 && event.state.control_mask?
+          widget.selection.selected_each do |model, path, iter|
+            new_path = 
+            if !iter[0].dir?
+              # open the directory this file lives in
+              # unless we're already in that directory
+              iter.parent[0].path unless iter.parent.nil?
+            else
+              # open this directory
+              iter[0].path
+            end
+            TreeViewerWindow.new( new_path, @editor ) unless new_path.nil?
+          end
+          
+        # backspace - go up to parent directory
+        when event.hardware_keycode == 22
+          # go up one directory
+          temp = Pathname.new( @root_item.path )
+          @root_item.path = temp.parent.realpath.to_s
+          go_into( @root_item.path )
+          
+        # del on main keyboard or keypad deletes a file
+        when [91,107].include?( event.hardware_keycode )
+          iters = []
+          widget.selection.selected_each do |model, path, iter|
+            iters << iter
+          end
+          confirm_delete_files( iters )
+          
+        # ctrl-e and F2 edits the file name
+        when ( event.hardware_keycode == 26 && event.state.control_mask? ) || event.hardware_keycode == 68
+          # make sure all the files are selected
+          rows = widget.selection.selected_rows
+          rows.each do |path|
+            # seems it not necessary to set this
+            # @text_renderer.mode = Gtk::CellRendererText::MODE_EDITABLE
+            @text_renderer.editable = true
+            # true is to start editing
+            view.set_cursor( path, view.get_column(0), true )
+            # the rest of the work is done in the renderer's handler.
+            @text_renderer.editable = false
+          end
+        
+        # ctrl-d sends some debug/info commands to scite
+        when event.hardware_keycode == 40 && event.state.control_mask?  && !event.state.shift_mask?
+          @editor.dump
+          
+        # ctrl-b sends the current selection to the editor
+        when event.hardware_keycode == 56 && event.state.control_mask?  && !event.state.shift_mask?
+          paths = []
+          widget.selection.selected_each do |model, path, iter|
+            # note use of single quotes
+            paths << model.get_value( iter, 0 ).path
+          end
+          @editor.insert paths
+          
+        # ctrl-c copies current selections as text
+        when event.hardware_keycode == 54 && event.state.control_mask?  && !event.state.shift_mask?
+          paths = ""
+          
+          # fetch all selected items
+          # don't use a join here so we get a trailing newline
+          widget.selection.selected_each do |model, path, iter|
+            paths << model.get_value( iter, 0 ).path << "\n"
+          end
+          
+          Gtk::Clipboard.get( Gdk::Selection::CLIPBOARD ).text = paths
+        
+        # ctrl-v selects the files in the clipboard 
+        when event.hardware_keycode == 55 && event.state.control_mask?  && !event.state.shift_mask?
+          text = Gtk::Clipboard.get( Gdk::Selection::CLIPBOARD ).wait_for_text
+          paths = text.strip.split( /\s*\n\s*/ )
+          location_path = Pathname.new( @root_item.path )
+          paths = paths.map do |x|
+            # check for path names relative to the current location
+            fullpath = location_path + x
+            ( fullpath.exist? ? fullpath : x ).to_s
+          end
+          select_fs_paths( paths )
+          
+        # ctrl-n opens new window with same root
+        when event.hardware_keycode == 57 && event.state.control_mask?
+          TreeViewerWindow.new( @root_item.path, @editor )
+          
+        # ctrl-y synchronizes with current editor file
+        when event.hardware_keycode == 29 && event.state.control_mask?
+          # make sure other windows don't synchronize
+          @expecting_synchronize_path = true
+          # ask editor for current file and sync
+          @editor.synchronize_path
+          
+        # alt-y toggles automatic synchronization
+        when event.hardware_keycode == 29 && event.state.mod1_mask?
+          @auto_synchronize_path = !@auto_synchronize_path
+
+        # ctrl-r refreshes from filesystem
+        when event.hardware_keycode == 27 && event.state.control_mask?
+          refresh
+          
+        # ctrl-t opens a terminal window on the given directorties.
+        # Uses gnome-terminal and opens directories in tabs
+        when event.hardware_keycode == 28 && event.state.control_mask? && !event.state.shift_mask?
+          # collect all unique directories
+          dirs = []
+          widget.selection.selected_each do |model, path, iter|
+            dirs << if iter[0].dir?
+              iter[0].path
+            else
+              if iter.parent != nil
+                iter.parent[0].path
+              else
+                @root_item.path
+              end
+            end
+          end
+          terminal.launch( dirs )
+
+        # alt-l toggles the location bar
+        when event.hardware_keycode == 46 && event.state.mod1_mask?
+          @location.no_show_all = true
+          @location.visible = !@location.visible?
+
+        # ctrl-* on keypad means expand the entire tree
+        when event.hardware_keycode == 63 && event.state.control_mask?
+          # 100 levels of directories should be enough...
+          populate( @view.model, @root_item, nil, 100 )
+          @view.expand_all
+
+        # * on keypad means expand subtree
+        when event.hardware_keycode == 63 && event.state.empty?
+          widget.selection.selected_rows.each do |path|
+            iter = @view.model.get_iter( path )
+            if iter[0].dir?
+              expand_dir( widget, path, iter )
+            end
+          end
+
+        # shift-/ on keypad means collapse the entire tree
+        when event.hardware_keycode == 112 && event.state.shift_mask?
+          @view.collapse_all
+
+        # ctrl-left means go to parent
+        when event.hardware_keycode == 100 && event.state.control_mask?
+          widget.selection.selected_each do |model, path, iter|
+            if iter.parent != nil
+              iter.parent[0].last_child_used = path
+              select_iter( iter.parent )
+            end
+
+            # only do the first one
+            break
+          end
+
+        # ctrl-right means go to last used path, or first child
+        when event.hardware_keycode == 102 && event.state.control_mask?
+          widget.selection.selected_each do |model, path, iter|
+            if iter[0].dir?
+              widget.expand_row( iter.path, false )
+              if iter[0].last_child_used != nil
+                select_path( iter[0].last_child_used )
+              else
+                select_iter( iter.first_child )
+              end
+            end
+
+            # only do the first one
+            break
+          end
+
+        # ctrl-up means go to previous sibling with children
+        when event.hardware_keycode == 98 && event.state.control_mask?
+          widget.selection.selected_each do |model, path, iter|
+            if iter[0].dir?
+              while path.prev!
+                if model.get_iter( path ).has_child?
+                  select_path( path )
+                  break
+                end
+              end
+            else
+              select_iter iter.parent unless iter.parent.nil?
+            end
+            break
+          end
+
+        # ctrl-down means go to next sibling with children
+        when event.hardware_keycode == 104 && event.state.control_mask?
+          widget.selection.selected_each do |model, path, iter|
+            if iter[0].dir?
+              while iter.next!
+                if iter[0].dir?
+                  select_iter( iter )
+                  break
+                end
+              end
+            else
+              # go up to parent and then down
+              # to parent's following sibling
+              temp = iter.parent
+              if temp != nil
+                temp.next!
+                select_iter temp
+              end
+            end
+            # only do the first selection
+            break
+          end
+
+        # shift-left means select parent
+        when event.hardware_keycode == 100 && event.state.shift_mask?
+          widget.selection.selected_each do |model, path, iter|
+            if iter.parent != nil
+              select_children( widget, iter.parent )
+            end
+          end
+
+        # shift-right means select children
+        when event.hardware_keycode == 102 && event.state.shift_mask?
+          widget.selection.selected_each do |model, path, iter|
+            if iter[0].dir?
+              select_children( widget, iter )
+            end
+          end
+
+        # left means close level(s)
+        when event.hardware_keycode == 100 && event.state.empty?
+          widget.selection.selected_each do |model, path, iter|
+            widget.collapse_row( path ) if iter[0].dir?
+          end
+
+        # right means open level(s)
+        when event.hardware_keycode == 102
+          widget.selection.selected_each do
+            |model, path, iter|
+            # false means don't expand children
+            widget.expand_row( path, false )
+          end
+          
+        else
+          # pass keypress to all locators
+          @locators.each {|x| retval &&= x.handle_keypress( widget, event ) }
+          # indicate signal not handled
+          if $options[:debug] && !retval
+            print "hardware_keycode: #{event.hardware_keycode}\n"
+          end
+      end
+      retval
+    end
+  end
+  
+  def expand_dir( widget, path, iter )
+    # make sure all directories in subtree are populated
+    populate( @view.model, iter[0], iter, 100 )
+
+    # expand row, with children
+    widget.expand_row( path, true )
+  end
+
+  def expand_parents_of( path )
+    cur = path.clone
+    cur.up!
+    paths = []
+    while !@view.row_expanded?( cur ) && cur.depth > 0
+      paths << cur.clone
+      cur.up!
+    end
+    
+    # now open the necessary paths from the top down
+    # false is don't open all children
+    paths.reverse.each do |x|
+      @view.expand_row( x, false )
+      @view.selection.unselect_path( x )
+    end
+  end
+  
+  def unselect_all
+    @view.selection.unselect_all
+  end
+  
+  def select_children( widget, iter )
+    widget.expand_row( iter.path, false )
+    (0...iter.n_children).each do |index|
+      select_iter( iter.nth_child( index ), false, false )
+    end
+  end
+  
+  # set selection and cursor to the given GtkTreeModel path
+  def select_path( path, unselect = true, set_cursor = true )
+    unselect_all if unselect
+    expand_parents_of( path )
+    @view.selection.select_path( path )
+    @view.set_cursor( path, nil, false ) if set_cursor
+    # path, column, use_align, row_align, col_align
+    @view.scroll_to_cell( path, nil, true, 0.5, 0.0 )
+  end
+
+  # set selection and cursor to the given GtkTreeModel iter
+  def select_iter( iter, unselect = true, set_cursor = true )
+    unselect_all if unselect
+    expand_parents_of( iter.path )
+    @view.selection.select_iter( iter )
+    @view.set_cursor( iter.path, nil, false ) if set_cursor
+    # path, column, use_align, row_align, col_align
+    @view.scroll_to_cell( iter.path, nil, true, 0.5, 0.0 )
+  end
+  
+  # Set selection to the given filesystem path.
+  # TODO could optimise this to select faster if we
+  # use directory names. Possibly also use select_iter if it's faster
+  def select_fs_path( fs_path, open = false )
+    @view.model.each do
+      |model, path, iter|
+      if iter[0].path == fs_path
+        select_path( path )
+        @view.expand_row( path, false ) if open
+        break
+      end
+    end
+  end
+
+  def select_fs_paths( fs_paths, open = false )
+    cursor_set = false
+    @view.model.each do
+      |model, path, iter|
+      if fs_paths.include?( iter[0].path )
+        @view.expand_row( path, false ) if open
+        # set the cursor at the beginning because
+        # selection seems to follow it and we want
+        # a multiple selection with the cursor on the first
+        if !cursor_set
+          @view.set_cursor( iter.path, nil, false )
+          cursor_set = true
+        end
+        
+        select_iter( iter, false, false )
+      end
+    end
+    
+  end
+  
+  def select_first
+    # set first item as selected
+    @view.selection.select_path Gtk::TreePath.new( '0' )
+  end
+
+  # callback for the editor classes
+  # First checks the values of
+  # @expecting_synchronize_path and @auto_synchronize_path
+  # and then calls select_fs_path
+  def synchronise_editor_path( fs_path )
+    if ( @expecting_synchronize_path || @auto_synchronize_path )
+      select_fs_path fs_path
+      @expecting_synchronize_path = false
+    end
+  end
+  
+  # called from open_action when we don't want the auto-centering
+  # to do its thing.
+  def no_synchronize
+    save = @auto_synchronize_path
+    @auto_synchronize_path = false
+    yield @editor
+    @auto_synchronize_path = save
+  end
+  
+  # called from the keyboard handler on enter
+  # and the double-click handler to
+  # open files or go into a directory
+  def open_action( files )
+    if files.size == 1 && files.first.dir?
+      go_into( files.first.path )
+    else
+      nodirs = files.find_all{ |x| !x.dir? }
+      no_synchronize do |editor|
+        editor.open_action( nodirs )
+      end
+    end
+  end
+
+  def terminal
+    @terminal ||= GnomeTerminal.new
+  end
+
+  # Move the displayed tree to the given directory
+  def go_into( fs_path )
+    last_select = []
+    @view.selection.selected_each do |model, path, iter|
+      last_select << path
+    end
+
+    last_select = [ Gtk::TreePath.new( '0' ) ] if last_select.empty?
+
+    @view.model.clear
+    @hilfer_items.values.each { |x| x.populated = false }
+    # this waits forever when called by the refresh thread
+    @root_item.path = fs_path
+    @root_item.populated = false
+    # show location as relative to home
+    @location.text = @root_item.path.sub( ENV['HOME'], '~' )
+    populate( @view.model, @root_item, nil )
+    setstatus
+    last_select.each { |x| select_path( x ) }
+  end
+
+  # fetch or create the HilferItem. Attemps a lookup from the item_path
+  # first if not found creates it from the item_name and item_path
+  def fetch_hilfer_item( item_name, item_path )
+    if @hilfer_items.has_key?( item_path )
+      @hilfer_items[item_path]
+    else
+      # create new item, add to column 0
+      tmp = HilferItem.new( item_name, item_path )
+      @hilfer_items[item_path] = tmp
+      tmp
+    end
+  end
+
+  def do_compute_colours( item )
+    if respond_to? :compute_colours
+      compute_colours( item.path )
+    else
+      {}
+    end
+  end
+  
+  # populate the model from the filesystem
+  # by default populate only 1 level down
+  def populate( model, item, parent_iter, levels_to_populate = 1, level = 0 )
+    iter = nil
+    path_colours = do_compute_colours( item )
+    
+    Dir.new( item.path ).entries.sort.each do |x|
+      begin
+        # ignore directory entries
+        next if x =~ /^\.\.?$/
+        # ignore hidden files unless the flag is set
+        next if x =~ /^\./ && !$options[:hidden]
+        # ignore generated files
+        next if x =~ /.os$/ || x =~ /.pot$/
+
+        # the path of the new item to consider
+        next_item_path = item.path + '/' + x
+
+        if item.populated?
+          # already have iters for this item
+          if iter.nil?
+            iter = parent_iter ? parent_iter.first_child : model.iter_first
+          else
+            iter.next!
+          end
+        else
+          # generate new iters
+          iter = model.append( parent_iter )
+        end
+
+        # insert the HilferItem objects, from cache if
+        # that exists.
+        iter[0] = current_item = fetch_hilfer_item( x, next_item_path )
+        if ( colour = path_colours[next_item_path] )
+          current_item.colour = colour
+        end
+
+        # recursively populate files, so the TreeView
+        # knows to draw the expanders
+        if ( ( File.directory?( next_item_path ) && level < levels_to_populate ) || iter[0].expanded? )
+          print "populating level #{level} #{iter[0].path}\n" if $options[:debug]
+          # populate children
+          populate( model, iter[0], iter, levels_to_populate, level + 1 )
+        end
+
+      rescue Errno::EACCES
+        # mostly to protect against permissions errors
+      rescue Exception => ex
+        print "caught exception: #{ex} #{ex.class}\n"
+        ex.backtrace.each { |x| print x, "\n" }
+      end
+
+    end
+    # OK, this dir is now populated
+    item.populated = true
+
+    # clean deleted entries. Doesn't seem necessary?
+    #model.remove iter while iter != model.iter_first
+  end
+
+  # go through and expand / collapse based on HilferItem status
+  def setstatus
+    @view.model.each do |model, path, iter|
+      case iter[0].status
+        when :collapsed
+          @view.collapse_row( iter.path )
+        when :expanded
+          @view.expand_row( iter.path, false )
+      end
+    end
+  end
+
+end