vimmate 0.8.1

data/lib/active_window/application.rb

@@ -0,0 +1,137 @@
+class ActiveWindow::Application
+  include ActiveSupport::Callbacks
+  define_callbacks :after_initialize
+
+  attr_accessor :controller, :database, :glade, :window
+  
+  def widget(name)
+    glade[name]
+  end
+  
+  def initialize(options = {})
+    @glade = GladeXML.new(find_glade, nil, options[:title] || 'application' )
+    @window = widget(options[:main_window] || 'main_window')
+    @window.signal_connect("destroy") { Gtk.main_quit }
+    @dot_file_prefs = DotFile.read
+    @database = options[:database]
+    define_widget_readers
+    run_callbacks :after_initialize
+  end
+
+  def start
+    setup
+    window.show
+    run
+  end
+
+  def run
+    Gtk.main
+  end
+
+  def default_database
+    @dot_file_prefs[:db]
+  end
+  
+  def save_default_database(hash)
+    @dot_file_prefs[:db] = hash
+    @dot_file_prefs.save
+  end
+  
+  # creates the controllers, connects the signals
+  # calls 'setup' on each controller
+  def setup
+    @controller = {}
+    
+    Module.constants.grep(/.Controller$/).each do |klass|
+       ctrl = Kernel.const_get(klass).instance
+       ctrl.application = self
+       ctrl.setup
+       name = klass.to_s.sub('Controller','').underscore.to_sym # eg MyFirstController -> :my_first
+       controller[name] = ctrl
+    end
+    
+    glade.signal_autoconnect_full do |source, target, signal, handler, data|
+      # for example:
+      # source  : instance of Gtk::ImageMenuItem
+      # target  : nil
+      # signal  : activate, clicked, pressed, etc.
+      # handler : window.close, which would call WindowController.close()
+      # data    : nil
+      #puts [source, target, signal, handler, data].inspect
+      source.signal_connect(signal) { |widget,event| self.dispatch(handler, :source => source, :target => target, :signal => signal, :handler => handler, :data => data, :widget => widget, :event => event) }
+      #source.signal_connect(signal) { self.(handler, data) }
+    end
+    post_setup
+  end
+  
+  # calls post_setup on each controller
+  def post_setup
+    controller.each do |name,ctrl|
+      ctrl.post_setup
+    end
+  end
+  
+  ##
+  ## dispatch a signal to the correct controller
+  ##
+  def dispatch(handler, event)
+    controller_name,action = handler.to_s.split('.')
+    unless controller_name and action
+      return(error "cannot parse handler '%s'" % handler)
+    end
+
+    name = controller_name.to_sym 
+    ctrl = controller[name]
+    unless ctrl
+      puts controller.inspect
+      return(error "no controller '%s' defined" % controller_name.camelize)
+    end
+    
+    unless ctrl.respond_to? action
+      return(error "controller '%s' does not have a method '%s'" % [ctrl.class, action])
+    end
+    
+    method = ctrl.method(action)
+    #puts "calling %s.%s" % [controller_name.camelize, action]
+    if method.arity == 0
+      method.call
+    else
+      method.call(event)
+    end
+  end
+
+
+  private
+  
+  def class_exists?(classname)
+    return (Kernel::const_get(classname) rescue NameError) != NameError
+  end
+  
+  def error(msg)
+    puts msg
+  end
+  
+  def find_glade
+    Dir.glob("#{views_directory}/*.glade") do |f|
+      return f
+    end
+    raise "could not find a .glade file in #{views_directory}"
+  end
+
+  def views_directory
+    File.join(APP_ROOT, 'views')
+  end
+
+  def define_widget_readers
+    glade.widget_names.each do |widget|
+      meth = widget.underscore
+      instance_eval <<-EOEVAL
+        @#{meth} = glade['#{widget}']
+        def #{meth}
+          @#{meth}
+        end
+      EOEVAL
+    end
+  end
+  
+end

data/lib/active_window/controller.rb

@@ -0,0 +1,58 @@
+# require 'libglade2'
+# require 'gtk2'
+
+class ActiveWindow::Controller
+  include Singleton
+    
+  attr_accessor :application
+  
+  def app
+    application
+  end
+  
+  def widget(name)
+    application.widget(name)
+  end
+  
+  def controller
+    application.controller
+  end
+  
+  def window
+    application.window
+  end
+  
+  def database
+    application.database
+  end
+  
+  # called on startup
+  def setup
+  end
+  
+  # called on startup, after setup has been called for all controllers
+  def post_setup
+  end
+
+  def pref_set(key,value)
+    Preference.delete_all ['pref = ?', key]
+    Preference.create(:pref => key, :value => value)
+    value
+  end
+  
+  def pref_get(key)
+    pref = Preference.find_by_pref(key)
+    return pref.value if pref
+    return nil
+  end
+
+  def pref_get_or_set(key,value)
+    pref_get(key) || pref_set(key,value)
+  end  
+
+  def method_missing(name, *args, &block)
+    application.send name, *args, &block
+  end
+
+end
+

data/lib/active_window/dot_file.rb

@@ -0,0 +1,29 @@
+=begin
+
+A simple class for reading and writing settings information
+to a dot file (~/.appname.yml)
+
+=end
+
+module ActiveWindow
+  class DotFile < ::Hash
+    def self.read(fname=nil)
+      fname ||= filename
+      unless File.exists? fname
+        new.save(fname)
+      end
+      YAML.load_file( fname )
+    end
+
+    def save(fname=nil)
+      fname ||= self.class.filename
+      File.open( fname, 'w+' ) do |out|
+        YAML.dump( self, out )
+      end
+    end
+
+    def self.filename
+      File.join ENV['HOME'], ".#{PROGRAM_NAME}.yml"
+    end
+  end
+end

data/lib/active_window/filtered_active_tree_store.rb

@@ -0,0 +1,113 @@
+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 unless initial_add_in_progress?
+          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)
+      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/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/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,74 @@
+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|
+        i = get_iter(element.path)
+        remove(i) if i
+      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