niklas-vimmate 0.8.0.1

data/TODO

@@ -0,0 +1,21 @@
+= TODO
+List of things to do:
+- Find a better way to hide the file list and use the same way to hide
+  the terminals. Patches for this are welcome!
+- Configurable shortcut keys: allow users to change the shortcut keys
+  with .vimmaterc. Need to find a way to specify the modifier (shift, ctrl)
+  and the key. Probably something like "CONTROL_MASK SHIFT_MASK GDK_S".
+- Icons are missing on move or mkdir -p
+
+= Ideas
+- New from file copy
+- Opening many files at once
+- Open in external viewer
+
+= TODO from Rewrite
+- re-enable SVN support
+
+
+/home/niklas/ruby/VimMate/bin/../lib/file_tree_controller.rb: line 150
+   Gtk-CRITICAL **:gtk_tree_model_row_has_child_toggled: assertion `path != NULL' failed
+

data/bin/vimmate

@@ -0,0 +1,95 @@
+#!/usr/bin/env ruby
+# Parse the command line arguments
+require 'optparse'
+excludes = []
+OptionParser.new do |opts|
+  opts.banner = "Usage: #{File.basename($0)} [options] [files or directories]"
+
+  opts.separator ""
+#  opts.separator "VimMate #{VimMate::VERSION}: Vim graphical add-on"
+  opts.separator "Copyright (C) 2006 Guillaume Benny"
+  opts.separator ""
+  opts.separator "If files or directories are omitted, the current directory is shown"
+
+  opts.on("-x",
+          "--exclude file1,file2,file3",
+          Array,
+          "Comma separated list of files or directory to exclude.") do |list|
+    excludes = list
+  end
+
+  opts.on_tail("-h", "--help", "Show this help screen") do |string|
+    puts opts
+    exit
+  end
+end.parse!
+
+
+# Ignore patterns from .vimmate_ignore
+local_ignore_file = File.expand_path('.vimmate_ignore')
+if File.exists?(local_ignore_file)
+  File.open(local_ignore_file) do |f|
+    while line = f.gets 
+      line.chomp!.strip!
+      excludes << line unless line.empty?
+    end
+  end
+end
+
+# We fork to give back the shell to the user, like Vim
+fork do
+  # TODO set this in activewindow.. but how?
+  APP_ROOT = File.expand_path( File.join( File.dirname(__FILE__), '..'  ) )
+  PROGRAM_NAME = 'vim_mate'
+  require File.join( APP_ROOT, 'config/environment' )
+  Thread.abort_on_exception = true
+
+  class VimMateApp < ActiveWindow::Application
+    def initialize(opts={})
+      @excludes = opts.delete(:excludes)
+      super
+    end
+    def file_tree
+      files.file_tree
+    end
+    def files
+      controller[:file_filter]
+    end
+    def vim
+      controller[:vim].vim
+    end
+    def add_path(path)
+      file_tree.add_path(path)
+    end
+
+    def post_setup
+      super
+
+      @excludes.each do |rule|
+        file_tree.exclude! rule
+      end unless @excludes.blank?
+
+      # If there are no files given, add the current directory to the file list.
+      # If files are specified on the command line, use them
+      if ARGV.empty?
+        add_path(File.expand_path('.'))
+        files.expand_first_row
+      else
+        ARGV.each do |file|
+          path = File.expand_path(file)
+          add_path(path)
+          #window.vim.open(path, :tab)
+        end
+      end
+    end
+  end
+
+  app = VimMateApp.new(:title => 'VimMate', :main_window => 'VimMate', :excludes => excludes)
+  app.start
+
+
+  ## Create the main objects
+  #window = VimMate::Window.new
+
+end
+

data/config/environment.rb

@@ -0,0 +1,33 @@
+require 'rubygems'
+require 'activesupport'
+
+
+#ActiveSupport::Dependencies::logger = Logger.new( File.expand_path('log/dependencies.log') )
+#ActiveSupport::Dependencies::log_activity = true
+ActiveSupport::Dependencies::load_paths << File.expand_path(File.join(File.dirname(__FILE__), "../lib"))
+ActiveSupport::Dependencies::load_paths << File.expand_path(File.join(File.dirname(__FILE__), "../controllers"))
+ActiveSupport::Dependencies::load_paths << File.expand_path(File.join(File.dirname(__FILE__), "../lib/vim_mate"))
+
+VimMate::Requirer.require_exit('gtk2')
+VimMate::Requirer.require_exit('libglade2')
+
+
+#require 'vimmatelib/file_tree_view'
+require_dependency 'gtk_thread_helper'
+require_dependency 'plugins'
+
+require_dependency 'active_window'
+
+%w(
+  file_created file_modified file_deleted file_opened
+  dir_created
+  item_opened item_removed item_refreshed
+  file_opened
+).each do |signal|
+  ActiveWindow::Signal::define signal
+end
+
+require_dependency 'vim_mate_controller'
+require_dependency 'vim_controller'
+require_dependency 'file_filter_controller'
+require_dependency 'file_popup_menu_controller'

data/controllers/file_filter_controller.rb

@@ -0,0 +1,85 @@
+class FileFilterController < ActiveWindow::Controller
+  attr_reader :file_tree, :filtered_file_tree
+
+  def post_setup
+    # TODO use ActiveTreeStore derivate
+    @file_tree = FileTreeStore.new
+    @filtered_file_tree = FilteredFileTreeStore.new(file_tree)
+
+    filtered_file_tree.apply_to_tree file_tree_view
+
+    file_tree_view.selection.mode = Gtk::SELECTION_SINGLE
+    file_tree_view.headers_visible = VimMate::Config[:file_headers_visible]
+    file_tree_view.hover_selection = VimMate::Config[:file_hover_selection]
+
+    tree_scroller.set_size_request(VimMate::Config[:files_opened_width], -1)
+    files_filter_button.active = VimMate::Config[:files_filter_active]
+    files_pane.position = VimMate::Config[:files_search_separator_position]
+  end
+
+  # TODO find another poace to put
+  def selection_changed
+    STDERR.puts "changed selection"
+    if row.file_or_directory?
+      selected_path_label.text = File.join(row.full_path)
+    else
+      selected_path_label.text = ""
+    end
+  end
+  def changed
+    if files_filter_button.active?
+      filter_string = files_filter_term.text
+
+      if filtered_file_tree.filter_string.blank? && filter_string.length == 1 # begin of filtering
+        save_expands if VimMate::Config[:files_auto_expand_on_filter]
+      end
+
+      filtered_file_tree.filter = filter_string
+
+      if VimMate::Config[:files_auto_expand_on_filter]
+        filter_string.blank? ? restore_expands : expand_all
+      end
+    else
+      filtered_file_tree.clear_filter
+      restore_expands if VimMate::Config[:files_auto_expand_on_filter]
+    end
+  end
+  alias_method :toggle, :changed
+
+  def expand_all
+    file_tree_view.expand_all
+  end
+
+  def expand_first_row
+    file_tree_view.collapse_all
+    file_tree_view.expand_row(Gtk::TreePath.new("0"), false)
+  end
+
+  def button_pressed(given)
+    event = given[:event]
+    if event.kind_of? Gdk::EventButton and event.button == 3
+      path = file_tree_view.get_path_at_pos(event.x, event.y)
+      file_tree_view.selection.select_path(path[0]) if path
+      if file_tree_view.selection.selected
+        file_popup.popup(nil, nil, 0, 0)
+      end
+    end
+  end
+
+  private
+    def save_expands
+      @expands = []
+      file_tree_view.map_expanded_rows { |tree_view, path| @expands << path }
+      @expands
+    end
+
+    def restore_expands
+      file_tree_view.collapse_all if VimMate::Config[:files_auto_expand_on_filter]
+      unless @expands.nil? || @expands.empty?
+        @expands.each do |path|
+          file_tree_view.expand_row(path, false)
+        end
+      end
+    end
+
+end

data/controllers/file_popup_menu_controller.rb

@@ -0,0 +1,40 @@
+class FilePopupMenuController < ActiveWindow::Controller
+
+  def setup
+    @last_path = File.expand_path '.'
+  end
+
+  # Open a dialog to enter a new file name to create
+  # TODO use path of selected file
+  # TODO make inline renaming (like TextMate)
+  def new_file(given)
+    dialog = Gtk::FileChooserDialog.new("New file",
+                                        window,
+                                        Gtk::FileChooser::ACTION_SAVE,
+                                        nil,
+                                        [Gtk::Stock::CANCEL, Gtk::Dialog::RESPONSE_CANCEL],
+                                        [Gtk::Stock::SAVE, Gtk::Dialog::RESPONSE_ACCEPT])
+    #dialog.set_icon_list(Icons.window_icons)
+    dialog.current_folder = if File.directory? @last_path
+                              @last_path
+                            else
+                              File.dirname(@last_path)
+                            end
+    if dialog.run == Gtk::Dialog::RESPONSE_ACCEPT
+      begin
+        FileUtils.touch(dialog.filename)
+      rescue
+        $stderr.puts "Cannot touch #{dialog.filename}"
+      end
+    end
+    dialog.destroy
+  end
+  def new_directory(given)
+  end
+  def rename_item(given)
+  end
+  def delete_item(given)
+  end
+  def refresh_item(given)
+  end
+end

data/controllers/vim_controller.rb

@@ -0,0 +1,28 @@
+class VimController < ActiveWindow::Controller
+  attr_accessor :vim
+
+  def setup
+    @vim = VimMate::VimWidget.new
+    main_pane.pack2(vim.window, true, false)
+  end
+
+  def open_selected_file
+    open_selected_file_as
+  end
+
+  def open_selected_file_split
+    open_selected_file_as :split
+  end
+
+  def open_selected_file_tab
+    open_selected_file_as :tab
+  end
+
+  private
+  def open_selected_file_as(mode = VimMate::Config[:files_default_open_in_tabs] ? :tab : :open)
+    if iter = file_tree_view.selection.selected
+      vim.open iter[ FileTreeStore.full_path_column ], mode
+    end
+  end
+end
+

data/controllers/vim_mate_controller.rb

@@ -0,0 +1,76 @@
+class VimMateController < ActiveWindow::Controller
+
+  attr_accessor :terminals_window, :tags_tree
+
+  def post_setup
+    window.set_default_size( VimMate::Config[:window_width],
+                             VimMate::Config[:window_height])
+    window.set_icon_list(VimMate::Icons.window_icons)
+
+
+    # Double-click, Enter, Space: Signal to open the file
+    #file_tree.on_row_activated &method(:on_file_tree_row_activated)
+
+    #file_tree.on_right_click &method(:open_file_popup)
+    #file_tree.on_popup_menu &method(:open_file_popup)
+
+
+
+    #@tags_tree = VimMate::TagsWindow.new(@vim)
+    #tags_scroller.add @tags_tree.gtk_window
+
+    ## Set the signals for the file menu
+    #menu.add_open_signal do |path, kind|
+    #  vim.open(path, kind)
+    #end
+    #menu.add_refresh_signal do
+    #  files.refresh
+    #end
+  end
+
+  def pressed_key(given)
+    return unless event = given[:event]
+    if event.state & Gdk::Window::ModifierType::CONTROL_MASK != 0
+      if event.state & Gdk::Window::ModifierType::SHIFT_MASK != 0
+        case event.keyval
+        # CTRL+SHIFT+S: Set focus to terminal (shell)
+        when Gdk::Keyval::GDK_S
+          terminals_window.focus_terminal if terminals_window
+        # CTRL+SHIFT+T: New terminal
+        when Gdk::Keyval::GDK_T
+          terminals_window.add_new_terminal if terminals_window
+        # CTRL+SHIFT+W: Close terminal
+        when Gdk::Keyval::GDK_W
+          terminals_window.delete_current_terminal if terminals_window
+        # CTRL+SHIFT+L: Set focus to file filter
+        when Gdk::Keyval::GDK_L
+          files_filter_term.has_focus = true
+        # CTRL+SHIFT+F: Set focus to file list
+        when Gdk::Keyval::GDK_F
+          file_tree_view.has_focus = true
+        # CTRL+SHIFT+S: Set focus to search file list
+        when Gdk::Keyval::GDK_E
+          files_window.focus_file_search if files_window
+        # CTRL+SHIFT+V: Set focus to Vim
+        when Gdk::Keyval::GDK_V
+          vim.focus!
+        end
+      else
+        #case event.keyval
+        ## CTRL+PAGEDOWN: Next terminal
+        #when Gdk::Keyval::GDK_Page_Down
+        #  terminals_window.next_terminal if terminals_window
+        #  next true
+        ## CTRL+PAGEDOWN: Previous terminal
+        #when Gdk::Keyval::GDK_Page_Up
+        #  terminals_window.prev_terminal if terminals_window
+        #  next true
+        #else
+        #  next nil
+        #end
+      end
+    end
+    nil
+  end
+
+end

data/lib/active_window.rb

@@ -0,0 +1,8 @@
+module ActiveWindow
+
+end
+require_dependency 'active_window/signal'
+require_dependency 'active_window/active_tree_store/columns'
+require_dependency 'active_window/active_tree_store/index'
+require_dependency 'active_window/active_tree_store/extentions'
+require_dependency 'active_window/filtered_active_tree_store'

data/lib/active_window/active_column.rb

@@ -0,0 +1,218 @@
+module ActiveWindow
+
+=begin
+
+ActiveColumn is used to define columns for ActiveTreeStore
+
+=end
+
+  class ActiveColumn 
+    attr_accessor :id, :name
+    extend ActiveSupport::Memoizable
+
+    ClassesToSymbols = {
+      TrueClass     => :boolean,
+      FalseClass    => :boolean,
+      String        => :string,
+      Time          => :datetime,
+      Date          => :datetime,
+      Fixnum        => :integer,
+      Bignum        => :integer,
+      Integer       => :integer,
+      Float         => :float,
+      Gdk::Pixbuf   => :image
+    }
+
+    ##
+    ## column: ActiveRecord::ConnectionAdapters::MysqlColumn
+    ##
+    def self.create(id, name, klass=:string, opts={})
+      klass = ClassesToSymbols[klass] if klass.is_a?(Class)
+      subclass = case klass # ignore warning this creates
+        when :string;         ActiveTextColumn
+        when :datetime;       ActiveDateColumn
+        when :integer;        ActiveIntegerColumn
+        when :float;          ActiveFloatColumn
+        when :boolean;        ActiveToggleColumn
+        when :image;          ActiveImageColumn
+        else; self
+      end
+      return subclass.new(id, name.to_s, opts)
+    end
+    
+    def initialize(id, name, opts={})
+      self.id = id
+      self.name = name
+      @virtual = opts[:virtual] == true ? true : false
+      @visible = opts[:visible] == false ? false : true
+      #puts 'new column: %s %s' % [self.class, name]
+    end
+
+    def virtual?
+      @virtual
+    end
+
+    def hide!
+      @visible = false
+    end
+
+    def visible?
+      @visible
+    end
+    
+    ## return a Gtk::TreeViewColumn appropriate for showing this column
+    def view
+      raise "There is no way to show #{name} yet."
+    end
+
+    def renderer
+      raise "There is no way to render #{name} yet."
+    end
+
+    ## return the class of the value held for this column in the model
+    def data_class
+      Object
+    end
+    
+    ## given an active record object, return the attribute
+    ## value that corresponds to this column. the returned
+    ## value must match the class returned in data_class.
+    ## so, you might have to do some conversion.
+    def data_value(ar_object)
+      ar_object.send(self.name)
+    end
+
+    def view
+      r = renderer
+      column.pack_start(r, true)
+      column.add_attribute(r, attribute, self.id)
+      column
+    end
+
+    private
+    def column
+      @gtk_column ||= Gtk::TreeViewColumn.new(self.name)
+    end
+  end
+
+  ##
+  ## ActiveTextColumn
+  ##
+  ## For columns with string values
+  ##
+  class ActiveTextColumn < ActiveColumn
+    def data_class
+      String
+    end    
+    def renderer
+      Gtk::CellRendererText.new
+    end
+    def attribute
+      :text
+    end
+  end
+
+  class ActiveIntegerColumn < ActiveTextColumn
+    def data_class
+      Integer
+    end    
+  end
+   
+  ##
+  ## how to do?:
+  ##   renderer.signal_connect('toggled') do |cell, path|
+  ##     fixed_toggled(treeview.model, path)
+  ##   end
+  ## 
+  class ActiveToggleColumn < ActiveColumn
+    def data_class
+      TrueClass
+    end
+    def renderer
+      Gtk::CellRendererToggle.new
+    end
+    def attribute
+      :active
+    end
+  end
+  
+  ##
+  ## TODO: configure the number of digits printed
+  ##
+  class ActiveFloatColumn < ActiveColumn
+    def data_class
+      Float
+    end
+    def renderer
+      Gtk::CellRendererText.new
+    end
+    def attribute
+      :text
+    end
+    def view
+      super.set_cell_data_func(renderer) do |col, renderer, model, iter|
+        renderer.text = sprintf("%.2f", iter[self.id])
+      end
+    end
+    def data_value(ar_object)
+      super(ar_object) || 0
+    end
+  end
+
+  ##
+  ## TODO: configure the date format
+  ##
+  class ActiveDateColumn < ActiveColumn
+    def data_class
+      Time
+    end
+    def renderer
+      Gtk::CellRendererText.new
+    end
+    def attribute
+      :text
+    end
+    def view
+      super.set_cell_data_func(renderer) do |col, renderer, model, iter|
+        renderer.text = sprintf("%x %X", iter[self.id])
+      end
+    end
+  end
+
+
+  class ActiveImageColumn < ActiveColumn
+    def data_class
+      Gdk::Pixbuf
+    end
+
+    def renderer
+      Gtk::CellRendererPixbuf.new
+    end
+
+    def attribute
+      :pixbuf
+    end
+  end
+
+  # pack multiple columns into one
+  class ActiveCompositeColumn < ActiveColumn
+    def initialize(name, opts={})
+      self.name = name
+      @virtual = true
+      @visible = true
+    end
+    def view
+      column
+    end
+    def add(child_column, expand=true)
+      raise ArgumentError, "give an ActiveColumn, not #{child_column.inspect}" unless child_column.is_a?(ActiveColumn)
+      child_column.hide!
+      rend = child_column.renderer
+      column.pack_start(rend, expand)
+      column.add_attribute(rend, child_column.attribute, child_column.id)
+    end
+  end
+
+    
+end
+