niklas-vimmate 0.8.0.1

data/lib/active_window/filtered_active_tree_store.rb

@@ -0,0 +1,114 @@
+module ActiveWindow
+  # This creates a TreeModel which supports filtering. Please give a block that "returns" boolean
+  #
+  #   filtered_model = ActiveTreeStoreFilter.new model do |filter_string, model, path, iter|
+  #     !iter[23].index(filter_string).nil?
+  #   end
+  class FilteredActiveTreeStore < Gtk::TreeModelFilter
+    include TreeStoreExtentions
+
+    attr_reader :filter_string, :found_count
+    attr_reader :unfiltered_store
+    define_callbacks :before_filter_applied, :after_filter_applied
+    define_callbacks :before_clear_filter, :after_clear_filter
+
+    def self.inherited(child_class)
+      unfiltered_class_name = child_class.name.sub(/^Filtered/,'')
+      unfiltered_class = unfiltered_class_name.constantize
+      child_class.columns = unfiltered_class.columns
+      child_class.column_id = unfiltered_class.column_id
+      child_class.setup_column_id_constants
+      unfiltered_class.class_eval <<-EOCODE
+        def add_with_filter_visibility(file, *args)
+          iter = add_without_filter_visibility(file, *args)
+          filtered_model.set_visibility_for(iter)
+          filtered_model.refilter
+          iter
+        end
+        alias_method_chain :add, :filter_visibility
+        attr_accessor :filtered_model
+      EOCODE
+    rescue NameError => e
+      if e.message =~ /uninitialized constant #{unfiltered_class}/
+        raise "there is no class named #{unfiltered_class} to filter from"
+      else
+        raise
+      end
+    end
+
+    def initialize(child_model)
+      super(child_model)
+      setup_filter
+    end
+
+    def filter_string=(new_filter_string)
+      @filter_regexp = nil
+      if new_filter_string.empty?
+        clear_filter
+      else
+        @filter_string = new_filter_string
+        apply_filter
+      end
+    end
+
+    def clear_filter
+      run_callbacks :before_clear_filter
+      @filter_string = ''
+      @found_count = -1
+      refilter
+      run_callbacks :after_clear_filter
+    end
+
+    # implement this to oyur own needs
+    def iter_visible?(iter)
+      true
+    end
+
+    # Iterate over child model and set visible column according to #iter_visible?
+    def apply_filter
+      run_callbacks :before_filter_applied
+      @found_count = 0
+      child_model.each do |model,path,iter|
+        set_visibility_for(iter)
+      end
+      refilter
+      run_callbacks :after_filter_applied
+    end
+
+    def filtered?
+      !filter_string.blank?
+    end
+    alias_method :filter, :filter_string
+    alias_method :filter=, :filter_string=
+    alias_method :filtering?, :filtered?
+
+    def set_visibility_for(iter)
+      visid = self.class.column_id[:visible]
+      unless filtering?
+        iter[ visid ] = true
+      else
+        if iter_visible?(iter) # iter matches - mark it and all parents as visible
+          @found_count += 1
+          iter[ visid ] = true
+          i = iter
+          while i = i.parent
+            i[ visid ] = true
+          end
+        else
+          iter[ visid ] = false
+        end
+      end
+    end
+
+    private
+
+    def setup_filter
+      set_visible_func do |model, iter|
+        !filtered? || iter[ self.class.column_id[:visible] ]
+      end
+      child_model.filtered_model = self
+      clear_filter
+    end
+
+  end
+end

data/lib/active_window/listed_item.rb

@@ -0,0 +1,127 @@
+module ActiveWindow
+  # The ListItem is created on the fly
+  #  * to oo-abstract methods to its TreeIter
+  #  * for iteration in TreeController
+  #  * as object in ActiveTreeStore
+  class ListedItem
+
+    def initialize(opts = {})
+      @traversed = false
+      self
+    end
+
+    def sort
+      "item-#{iter}"
+    end
+
+    def icon_name
+      nil
+    end
+
+    def icon
+      VimMate::Icons.by_name icon_name
+    end
+
+    # New by Gtk::TreeRowReference
+    def self.new_by_reference(reference)
+      new(:iter => reference.iter)
+    end
+
+    # New by Gtk::TreeIter
+    def self.new_by_iter(iter)
+      new(:iter => iter)
+    end
+
+    def message?
+      referenced_type == 'VimMate::Message'
+    end
+
+    def separator?
+      referenced_type == 'VimMate::Separator'
+    end
+
+    def file?
+      false
+    end
+
+    def directory?
+      false
+    end
+
+    def file_or_directory?
+      false
+    end
+
+    def show!
+      self.visible = true
+      # TODO hide seperator
+      #if directory? and Config[:file_directory_separator]
+      #  if iter.next!
+      #    tree.row_for_iter(iter).show!
+      #  end
+      #end
+    end
+    def hide!
+      self.visible = false
+      # TODO hide seperator
+      #if directory? and Config[:file_directory_separator]
+      #  if iter.next!
+      #    tree.row_for_iter(iter).hide!
+      #  end
+      #end
+    end
+
+    def visible?
+      visible
+    end
+
+    def matches?(str)
+      name.index(str)
+    end
+
+    def refresh
+    end
+
+    def reference
+      @reference ||= Gtk::TreeRowReference.new(tree.store, iter.path)
+    end
+
+    def reference=(new_ref)
+      if new_ref
+        @reference = new_ref
+        @iter = tree.store.get_iter(new_ref.path)
+      end
+    end
+
+    def self.build(attrs)
+      if full_path = attrs[:full_path]
+        if ::File.directory? full_path
+          'ListedDirectory'
+        elsif ::File.file? full_path
+          'ListedFile'
+        else
+          self
+        end
+      elsif iter = attrs[:iter] and !iter[REFERENCED_TYPE].nil?
+        iter[REFERENCED_TYPE]
+      else
+        self
+      end.constantize.new attrs
+    end
+
+    def to_s
+      "#{self.class} [#{iter.path}]"
+    end
+
+    def self.modify_icon(scope, &block)
+      with = "icon_name_with_#{scope}"
+      without = "icon_name_without_#{scope}"
+      define_method with do
+        block.call(self)
+      end
+      alias_method without, :icon_name
+      alias_method :icon_name, with
+    end
+
+  end
+end

data/lib/active_window/signal.rb

@@ -0,0 +1,46 @@
+module ActiveWindow
+  class Signal
+    class UnknownSignalError < StandardError ; end
+    @@signals = {}
+
+    def self.on(name, &block)
+      @@signals[name] ||= []
+      @@signals[name] << block
+    end
+
+    def self.emit(name, *args)
+      if @@signals[name].is_a?(Array)
+        @@signals[name].each do |block|
+          block.call(*args)
+        end
+      end
+    end
+
+    def self.signals
+      @@signals
+    end
+
+    def self.define name
+      class_eval <<-EOCODE
+        def self.emit_#{name}(*args)
+          self.emit(:#{name},*args)
+        end
+        def self.on_#{name}(&block)
+          self.on(:#{name}, &block)
+        end
+      EOCODE
+    end
+
+    def self.method_missing(meth,*args,&block)
+      case meth.to_s
+      when /^emit_(.*)$/
+        raise UnknownSignalError, "cannot emit unknown signal '#{$1}'"
+      when /^on_(.*)$/
+        raise UnknownSignalError, "cannot connect to unknown signal '#{$1}'"
+      else
+        raise NoMethodError, "unknown method: #{meth}"
+      end
+    end
+    
+  end
+end

data/lib/config_window.rb

@@ -0,0 +1,90 @@
+module VimMate
+  class ConfigWindow
+    attr_reader :container
+    def initialize(main_window=nil)
+      @gtk_main_window = Gtk::Dialog.new("Configuration", main_window, Gtk::Dialog::MODAL,
+                                         [ Gtk::Stock::CANCEL, Gtk::Dialog::RESPONSE_REJECT ],
+                                         [ Gtk::Stock::OK, Gtk::Dialog::RESPONSE_ACCEPT ]
+                                        )
+      gtk_window.set_default_size(400,300)
+      gtk_window.signal_connect('response') do |win,resp|
+        case resp
+        when Gtk::Dialog::RESPONSE_ACCEPT
+          save_settings
+          win.close
+        when Gtk::Dialog::RESPONSE_REJECT
+          win.close
+        when Gtk::Dialog::RESPONSE_NONE
+          puts "closing"
+        end
+      end
+      @container = gtk_window.vbox
+      fill_container
+      gtk_window.show_all
+    end
+    # The "window" for this object
+    def gtk_window
+      @gtk_main_window
+    end
+
+    def fill_container
+      @fields = {}
+      Config::DEFAULT_CONFIG.keys.sort {|a,b| a.to_s <=> b.to_s}.each do |key|
+        val = Config[key]
+        box = Gtk::HBox.new(true,10)
+          label = Gtk::Label.new(key.to_s.humanize)
+          label.xalign = 1
+          box.pack_start label, true, true 
+
+          field = field_for val
+          @fields[key] = field
+          box.pack_start field, true, false
+        container.pack_start box 
+      end
+    end
+
+    def save_settings
+      Config::DEFAULT_CONFIG.keys.each do |key|
+        if new_val = val_of(key)
+          Config.config[key] = new_val
+        end
+      end
+      Config.write_config
+    end
+
+    def val_of(key)
+      field = @fields[key]
+      case Config::DEFAULT_CONFIG[key]
+      when String
+        field.text
+      when Fixnum
+        field.value.to_i
+      when Float
+        field.value.to_f
+      when FalseClass, TrueClass
+        field.active?
+      end
+    end
+
+    def field_for(val)
+      case val
+      when String
+        # TODO make "textarea" for more than 42 chars
+        e = Gtk::Entry.new
+        e.editable = true
+        e.text = val
+        e
+      when Fixnum, Float
+        Gtk::SpinButton.new(
+          Gtk::Adjustment.new(val,0,10000,1,10,1),
+          1,0)
+      when FalseClass, TrueClass
+        e = Gtk::ToggleButton.new
+        e.active = val
+        e
+      else
+       Gtk::Label.new(val.to_s)
+      end
+    end
+  end
+end

data/lib/file_tree_store.rb

@@ -0,0 +1,73 @@
+class FileTreeStore < ActiveWindow::ActiveTreeStore
+  column :full_path, String, :visible => false
+  column :status, String, :visible => false
+  column :sort, String, :visible => false
+
+  composite_column 'Files' do |col|
+    col.add column(:icon, Gdk::Pixbuf), false
+    col.add column(:name, String)
+  end
+
+  index_by :full_path
+
+  attr_reader :excludes
+  def initialize
+    super
+    @excludes ||= []
+    set_sort_column_id self.class.column_id[:sort]
+    ActiveWindow::Signal.on_file_modified { |path| refresh_path(path) }
+    ActiveWindow::Signal.on_file_created  { |path| add_path(path)     }
+    ActiveWindow::Signal.on_file_deleted  { |path| remove_path(path)  }
+  end
+
+  def add_path(path, parent=nil)
+    unless excludes?(File.expand_path(path))
+      file = ListedFile.create(:full_path => path)
+      iter = add file, parent || find_by_full_path( File.dirname(path) )
+      if file.directory?
+        file.children_paths.each do |child|
+          add_path child, iter
+        end
+      end
+    end
+  rescue ArgumentError => e
+    STDERR.puts e.message
+  end
+
+  def refresh_path(path)
+    if iter = find_by_full_path(path)
+      update_iter_from_object(iter, iter[OBJECT])
+      if iter[OBJECT].directory?
+        each do |iter|
+          if iter[FULL_PATH].start_with?(path)
+            refresh_path iter[FULL_PATH]
+          end
+        end
+      end
+    end
+  end
+
+  def remove_path(file_path)
+    if has_full_path?(file_path)
+      to_remove = []
+      each do |model,path,iter|
+        if iter[FULL_PATH].starts_with?(file_path)
+          to_remove << reference_for(iter)
+        end
+      end
+      to_remove.each do |element|
+        remove(get_iter(element.path))
+      end
+    end
+  end
+
+  # Path ends with a node name contained in the exclude list
+  def excludes?(path)
+    excludes.any?  {|f| path[-(f.size+1)..-1] == "/#{f}" }
+  end
+
+  def exclude!(new_exclude)
+    excludes << new_exclude.chomp.strip
+  end
+
+end