redcar 0.5.2dev → 0.5.3dev

data/plugins/application/features/support/env.rb

@@ -125,34 +125,34 @@ World(SwtHelper)
 
 def close_everything
   Redcar.app.task_queue.cancel_all
-  Redcar::ApplicationSWT.sync_exec do
+  Swt.sync_exec do
     dialogs.each {|d| d.controller.model.close }
   end
   Redcar.app.windows.each do |win|
     while tree = win.treebook.trees.first
-      Redcar::ApplicationSWT.sync_exec do
+      Swt.sync_exec do
         win.treebook.remove_tree(tree)
       end
     end
     win.notebooks.each do |notebook|
       while tab = notebook.tabs.first
-        Redcar::ApplicationSWT.sync_exec do
+        Swt.sync_exec do
           tab.close
         end
       end
     end
     if win.notebooks.length == 2
-      Redcar::ApplicationSWT.sync_exec do
+      Swt.sync_exec do
         win.close_notebook
       end
     end
   end
   while Redcar.app.windows.length > 1
-    Redcar::ApplicationSWT.sync_exec do
+    Swt.sync_exec do
       Redcar.app.windows.last.close
     end
   end
-  Redcar::ApplicationSWT.sync_exec do
+  Swt.sync_exec do
     Redcar.app.focussed_window.close_speedbar if Redcar.app.focussed_window.speedbar
     Redcar.app.windows.first.title = Redcar::Window::DEFAULT_TITLE
   end

data/plugins/application/lib/application.rb

@@ -11,6 +11,11 @@ require 'application/dialogs/filter_list_dialog'
 require 'application/event_spewer'
 require 'application/keymap'
 require 'application/keymap/builder'
+require 'application/toolbar'
+require 'application/toolbar/item'
+require 'application/toolbar/lazy_toolbar'
+require 'application/toolbar/builder'
+require 'application/toolbar/builder/group'
 require 'application/menu'
 require 'application/menu/item'
 require 'application/menu/lazy_menu'
@@ -69,7 +74,7 @@ module Redcar
       ]
     end
     
-    attr_reader :clipboard, :keymap, :menu, :history, :task_queue
+    attr_reader :clipboard, :keymap, :menu, :toolbar, :history, :task_queue, :show_toolbar
     
     # Create an application instance with a Redcar::Clipboard and a Redcar::History.
     def initialize
@@ -79,6 +84,7 @@ module Redcar
       create_history
       @event_spewer = EventSpewer.new
       @task_queue   = TaskQueue.new
+      @show_toolbar = !!Application.storage['show_toolbar']
     end
     
     def events
@@ -107,6 +113,7 @@ module Redcar
       notify_listeners(:new_window, new_window)
       attach_window_listeners(new_window)
       new_window.refresh_menu
+      new_window.refresh_toolbar
       new_window.show
       set_focussed_window(new_window)
       #puts "App#new_window took #{Time.now - s}s"
@@ -135,6 +142,7 @@ module Redcar
       @storage ||= begin
          storage = Plugin::Storage.new('application_plugin')
          storage.set_default('stay_resident_after_last_window_closed', false)
+         storage.set_default('show_toolbar', true)
          storage
       end
     end
@@ -182,7 +190,14 @@ module Redcar
       @main_menu = nil
       @main_keymap = nil
       windows.each {|window| window.refresh_menu }
-      controller.refresh_menu
+      notify_listeners(:refresh_menu)
+    end
+    
+    # Redraw the main toolbar, reloading all the ToolBars and Keymaps from the plugins.
+    def refresh_toolbar!
+      @main_toolbar = nil
+      windows.each {|window| window.refresh_toolbar }
+      controller.refresh_toolbar
     end
     
     # Generate the main menu by combining menus from all plugins.
@@ -198,6 +213,19 @@ module Redcar
       end
     end
     
+    # Generate the toolbar combining toolbars from all plugins.
+    #
+    # @return [Redcar::ToolBar]
+    def main_toolbar
+      @main_toolbar ||= begin
+        toolbar = ToolBar.new
+        Redcar.plugin_manager.objects_implementing(:toolbars).each do |object|
+          toolbar.merge(object.toolbars)
+        end
+        toolbar
+      end
+    end
+    
     # Generate the main keymap by merging the keymaps from all plugins.
     #
     # @return [Redcar::Keymap]
@@ -299,6 +327,20 @@ module Redcar
     def create_history
       @history = Command::History.new
     end
+
+    public 
+
+    def show_toolbar?
+      @show_toolbar
+    end
+
+    def show_toolbar=(bool)
+      Application.storage['show_toobar'] = @show_toolbar = bool
+    end
+
+    def toggle_show_toolbar
+      Application.storage['show_toolbar'] = @show_toolbar = !Application.storage['show_toolbar']
+    end
   end
 end
 

data/plugins/application/lib/application/toolbar.rb

@@ -0,0 +1,91 @@
+
+module Redcar
+  class ToolBar
+    include Enumerable
+    include Redcar::Model
+    
+    # Default priority for all toolbar's and items if they aren't explicitly provided
+    DEFAULT_PRIORITY = 50
+    
+    attr_reader :text, :entries, :priority
+  
+    # A ToolBar will initially have nothing in it.
+    def initialize(text=nil, options={})
+      @text, @entries, @priority = text || "", [], options[:priority]
+    end
+  
+    # Iterate over each entry, sorted by priority
+    def each
+      sorted = {:first => [], :last => []}
+      entries.each {|e| (sorted[e.priority || ToolBar::DEFAULT_PRIORITY] ||= []) << e}
+      
+      # Get the nasty Symbols out of the hash so we can sort it
+      first = sorted.delete(:first)
+      last = sorted.delete(:last)
+      
+      # Yield up the results
+      first.each {|val| yield val }
+      sorted.keys.sort.each {|i| sorted[i].each {|val| yield val }}
+      last.each {|val| yield val }
+    end
+  
+    # Add a Redcar::ToolItem or a Redcar::ToolBar
+    def <<(entry)
+      entries << entry
+      self
+    end
+  
+    # Number of entries in the toolbar
+    def length
+      entries.length
+    end
+    
+    # Fetch the sub_toolbar with the given name
+    #
+    # @param [String]
+    # @return [ToolBar]
+    def sub_toolbar(text)
+      detect {|e| e.text == text and e.is_a?(ToolBar) }
+    end
+    
+    def entry(text)
+      detect {|e| e.text == text }
+    end
+    
+    # Append items and sub_toolbars using the same syntax as ToolBar::Builder
+    def build(&block)
+      ToolBar::Builder.new(self, &block)
+    end
+    
+    def ==(other)
+      return false unless length == other.length
+      return false unless text == other.text
+      entries.zip(other.entries) do |here, there|
+        return false unless here.class == there.class and here == there
+      end
+      true
+    end
+    
+    def is_unique?
+      false
+    end
+    
+    # Merge two ToolBar trees together. Modifies this ToolBar.
+    #
+    # @param [ToolBar] another ToolBar
+    def merge(other)
+      @priority = @priority || other.priority
+      other.entries.each do |other_entry|
+        if here = entry(other_entry.text) and not other_entry.is_unique?
+          if here.class == other_entry.class
+            here.merge(other_entry)
+          else
+            entries[entries.index(here)] = other_entry
+          end
+        else
+          self << other_entry
+        end
+      end
+    end
+  end
+end

data/plugins/application/lib/application/toolbar/builder.rb

@@ -0,0 +1,80 @@
+
+module Redcar
+  class ToolBar
+    # A DSL for building toolbars simply. An example of usage
+    #
+    #     builder = ToolBar::Builder.new "Edit" do
+    #       item "Select All", SelectAllCommand
+    #       sub_toolbar "Indent" do
+    #         item "Increase", IncreaseIndentCommand
+    #         item("Decrease") { puts "decrease selected" }
+    #       end
+    #     end
+    #
+    # This is equivalent to:
+    # 
+    #     toolbar = Redcar::ToolBar.new("Edit")
+    #     toolbar << Redcar::ToolBar::Item.new("Select All", SelectAllCommand)
+    #     indent_toolbar = Redcar::ToolBar.new("Indent") 
+    #     indent_toolbar << Redcar::ToolBar::Item.new("Increase", IncreaseIndentCommand)
+    #     indent_toolbar << Redcar::ToolBar::Item.new("Decrease") do
+    #       puts "decrease selected"
+    #     end
+    #     toolbar << indent_toolbar
+    class Builder
+      attr_reader :toolbar
+      
+      def self.build(name=nil, &block)
+        new(name, &block).toolbar
+      end
+      
+      def initialize(toolbar_or_text=nil, &block)
+        case toolbar_or_text
+        when String, nil
+          @toolbar = Redcar::ToolBar.new(toolbar_or_text||"")
+        when ToolBar
+          @toolbar = toolbar_or_text
+        end
+        @current_toolbar = @toolbar
+        if block.arity == 1
+          block.call(self)
+        else
+          instance_eval(&block)
+        end
+      end
+      
+      def item(text, options={}, &block)
+        @current_toolbar << Item.new(text, options, &block)
+      end
+      
+      def separator(options={})
+        @current_toolbar << Item::Separator.new(options)
+      end
+      
+      def sub_toolbar(text, options={}, &block)
+        new_toolbar = ToolBar.new(text, options)
+        @current_toolbar << new_toolbar
+        old_toolbar, @current_toolbar = @current_toolbar, new_toolbar
+        if block.arity == 1
+          block.call(self)
+        else
+          instance_eval(&block)
+        end
+        @current_toolbar = old_toolbar
+      end
+      
+      def lazy_sub_toolbar(text, options={}, &block)
+        new_toolbar = LazyToolBar.new(block, text, options)
+        @current_toolbar << new_toolbar
+      end
+      
+      def group(options={}, &block)
+        Builder::Group.new(self, options, &block)
+      end
+      
+      def append(item)
+        @current_toolbar << item
+      end
+    end
+  end
+end

data/plugins/application/lib/application/toolbar/builder/group.rb

@@ -0,0 +1,47 @@
+
+module Redcar
+  class ToolBar
+    class Builder
+      # An extension to the Builder to allow groups of toolbar object to inherit options.
+      #
+      # This is supported for all options, even options that don't exist yet!
+      #
+      # Currently, this is only useful in a practical sense to apply a :priority to a 
+      # set of objects
+      class Group
+        
+        def initialize(builder, options={}, &block)
+          @builder = builder
+          @defaults = options
+          
+          if block.arity == 1
+            block.call(self)
+          else
+            instance_eval(&block)
+          end
+        end
+        
+        def item(text, options={}, &block)
+          options = {:command => options} if not options.respond_to?('[]')
+          @builder.item(text, @defaults.merge(options), &block)
+        end
+        
+        def separator(options={})
+          @builder.separator(@defaults.merge(options))
+        end
+        
+        def sub_toolbar(text, options={}, &block)
+          @builder.sub_toolbar(text, @defaults.merge(options), &block)
+        end
+        
+        def lazy_sub_toolbar(text, options={}, &block)
+          @builder.lazy_sub_toolbar(text, @defaults.merge(options), &block)
+        end
+
+        def append(item)
+          @builder.append(item)
+        end
+      end
+    end
+  end
+end

data/plugins/application/lib/application/toolbar/item.rb

@@ -0,0 +1,72 @@
+
+module Redcar
+  class ToolBar
+    class Item
+      class Separator < Item
+        def initialize(options={})
+          super(nil, options)
+        end
+        
+        def is_unique?
+          true
+        end
+      end
+
+      attr_reader :text, :command, :priority, :value, :type, :icon
+ 
+      # Create a new Item, with the given text to display in the toolbar, and
+      # either:
+      #   the Redcar::Command that is run when the item is selected.
+      #   or a block to run when the item is selected
+      def initialize(text, options={}, &block)
+        @text = text
+        
+        if options.respond_to?('[]')
+          @command = options[:command] || block
+	  @icon = options[:icon]
+          @value = options[:value]
+          @priority = options[:priority]
+          @type = options[:type]
+          @active = options[:active] ? true : false
+        # This branch is for compatibility with old code. Please use :command 
+        # option in new code
+        # FIXME: Should this be removed at some point?
+        else
+          @command = options || block
+        end
+        
+        @priority ||= ToolBar::DEFAULT_PRIORITY
+      end
+      
+      # Call this to signal that the toolbar item has been selected by the user.
+      def selected(with_key=false)
+        if @value
+          @command.new.run(:value => @value)
+        else  
+          @command.new.run#(:with_key => with_key)
+        end
+      end
+      
+      def type
+        @type
+      end
+      
+      def type
+        @type
+      end
+      
+      def merge(other)
+        @command = other.command
+        @priority = other.priority
+      end
+      
+      def ==(other)
+        text == other.text and command == other.command
+      end
+      
+      def is_unique?
+        false
+      end
+    end
+  end
+end

data/plugins/application/lib/application/toolbar/lazy_toolbar.rb

@@ -0,0 +1,25 @@
+
+module Redcar
+  class ToolBar
+    class LazyToolBar < ToolBar
+      
+      def initialize(block, text=nil, options={})
+        @text = text
+        @block = block
+        @priority = options[:priority] || ToolBar::DEFAULT_PRIORITY
+      end
+      
+      def entries
+        ToolBar::Builder.build(&@block).entries
+      end
+      
+      def <<(*_)
+        raise
+      end
+      
+      def merge(*_)
+        raise
+      end
+    end
+  end
+end