niklas-vimmate 0.8.0.1

data/lib/active_window/active_tree_store.rb

@@ -0,0 +1,13 @@
+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={})
+      super(*self.class.column_classes)
+    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/application.rb

@@ -0,0 +1,133 @@
+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
+    post_setup
+    window.show
+    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
+  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