vimmate 0.8.1

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/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
+

data/lib/active_window/active_tree_store/columns.rb

@@ -0,0 +1,88 @@
+module ActiveWindow
+  module ActiveTreeStoreColumns
+      def self.included(base)
+        base.class_eval do
+          class_inheritable_accessor :column_id
+          write_inheritable_attribute :column_id, {}
+          class_inheritable_accessor :columns
+          write_inheritable_attribute :columns, []
+          include InstanceMethods
+          extend ClassMethods
+        end
+      end
+
+      module InstanceMethods
+        def columns
+          self.class.columns
+        end
+
+        def data_columns
+          self.class.data_columns
+        end
+
+        def visible_columns
+          self.class.visible_columns
+        end
+
+      end
+
+      module ClassMethods
+        # options:
+        #   :virtual:  (bool )does not take actual values
+        #   :visible:  (bool) should be shown in the view
+        def column(label,type, opts={})
+          return columns[column_id[label.to_sym]] if column_id.has_key?(label.to_sym) # do not double-define
+          opts.reverse_merge!(:visible => true, :virtual => false)
+          index = column_count
+          column_id[label.to_sym] = index
+          col = ActiveColumn.create(index, label, type, opts)
+          columns << col
+          const_set label.to_s.upcase, index
+          class_eval <<-EOCODE
+            def self.#{label}_column
+              #{index}
+            end
+          EOCODE
+          return col
+        end
+
+        def composite_column(label)
+          col = ActiveCompositeColumn.new(label)
+          yield col
+          columns << col
+          return col
+        end
+
+        def virtual_column(label, type, opts={})
+          column label, type, opts.merge(:virtual => true)
+        end
+
+        # visible vs. virtual
+        def data_columns
+          columns.reject(&:virtual?)
+        end
+
+        def visible_columns
+          columns.select(&:visible?)
+        end
+
+        def invisible_columns
+          columns.reject(&:visible?)
+        end
+
+        def column_count
+          columns.size
+        end
+
+        def column_classes
+          columns.map(&:data_class)
+        end
+
+        def setup_column_id_constants
+          column_id.each do |sym, index|
+            const_set sym.to_s.upcase, index
+          end
+        end
+    end
+  end
+end

data/lib/active_window/active_tree_store/extentions.rb

@@ -0,0 +1,81 @@
+module ActiveWindow
+  module TreeStoreExtentions
+
+    def self.included(base)
+      base.class_eval do
+        include ActiveSupport::Callbacks
+        include ActiveTreeStoreColumns
+        include ActiveTreeStoreIndex
+      end
+    end
+    ## associates a Gtk::TreeView widget with self (a tree model). 
+    def apply_to_tree(treeview, opts={})
+      raise ArgumentError, "please provide a Gtk::TreeView" unless treeview.is_a?(Gtk::TreeView)
+      treeview.model = self
+      cols = self.class.visible_columns
+      cols = cols.except(opts[:except]) if opts.has_key?(:except)
+      cols = cols.slice(opts[:only]) if opts.has_key?(:only)
+      cols.map(&:view).each do |column|
+        treeview.append_column(column)
+      end
+    end
+
+    # Populare the Tree with an array of objects. The Tree gets cleared first.
+    def populate(array)
+      clear
+      array.each do |element|
+        self.add element  
+      end
+    end
+
+    # The original object for +iter+.
+    # FIXME remove
+    def get_object(iter)
+      raise "depricated - please use iter[OBJECT]"
+      iter[ self.class.column_id[:object] ]
+    end
+
+    # Add +object+ to tree, give optional +parent+
+    def add(object, parent=nil)
+      iter = self.append parent
+      case object
+      when Hash
+        update_iter_from_hash iter, object
+      else
+        update_iter_from_object iter, object
+      end
+      iter[ self.class.column_id[:object] ] = object
+      iter
+    end
+
+    # Updates the display in the tree/list of the given object
+    def refresh(object)
+      each do |model,path,iter| 
+        if iter[OBJECT] == object
+          update_iter_from_object(iter, object)
+          break
+        end
+      end
+    end
+
+    private
+    def update_iter_from_object(iter, object)
+      data_columns.each do |column|
+        iter[column.id] = column.data_value(object)
+      end
+      iter
+    end
+    def update_iter_from_hash(iter, hash = {})
+      hash.symbolize_keys.each do |key,value|
+        if id = self.class.column_id[key]
+          iter[ id ] = value
+        end
+      end
+      iter
+    end
+
+    def reference_for(iter)
+      Gtk::TreeRowReference.new(self, iter.path)
+    end
+  end
+end

data/lib/active_window/active_tree_store/index.rb

@@ -0,0 +1,53 @@
+module ActiveWindow
+  module ActiveTreeStoreIndex
+    def self.included(base)
+      base.class_eval do
+        include InstanceMethods
+        extend ClassMethods
+      end
+    end
+
+    module InstanceMethods
+    end
+
+    module ClassMethods
+      def index_by(column)
+        by = %Q~by_#{column}~
+        raise "cannot index by #{column}, it is already applied" if public_instance_methods.include?("find_#{by}")
+        class_eval <<-EOCODE
+          def find_#{by}!(val)
+            find_#{by}(val) || raise("cannot find by #{column}: '\#{val}'")
+          end
+          def find_#{by}(val)
+            if ref = has_#{column}?(val)
+              self.get_iter(ref.path)
+            end
+          end
+          def has_#{column}?(val)
+            index_#{by}[val]
+          end
+          def remember_iter_#{by}(iter)
+            val = iter[ self.class.column_id[:#{column}] ]
+            index_#{by}[val] = reference_for(iter)
+          end
+          def index_#{by}
+            @index_#{by} ||= {}
+          end
+          def add_with_index_#{by}(*args)
+            iter = add_without_index_#{by}(*args)
+            remember_iter_#{by}(iter)
+            iter
+          end
+          alias_method_chain :add, :index_#{by}
+          def remove_with_index_#{by}(iter)
+            index_#{by}.delete iter[ self.class.column_id[:#{column}] ]
+            remove_without_index_#{by}(iter)
+          end
+          alias_method_chain :remove, :index_#{by}
+        EOCODE
+      end
+    end
+
+  end
+end
+

data/lib/active_window/active_tree_store.rb

@@ -0,0 +1,26 @@
+module ActiveWindow
+  class ActiveTreeStore < Gtk::TreeStore
+    include TreeStoreExtentions
+    virtual_column :visible, TrueClass, :visible => false
+    virtual_column :object, Object, :visible => false
+    define_callbacks :after_add
+
+    def initialize(opts={})
+      @initial_add_in_progress = false
+      super(*self.class.column_classes)
+    end
+
+    # disables some heavy calculations
+    def initial_adding
+      old_progress = initial_add_in_progress?
+      @initial_add_in_progress = true
+      yield
+      @initial_add_in_progress = old_progress
+    end
+
+    def initial_add_in_progress?
+      @initial_add_in_progress
+    end
+
+  end
+end