redcar 0.3.2dev → 0.3.3

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

@@ -59,7 +59,7 @@ end
 
 World(SwtHelper)
 
-After do
+def close_everything
   Redcar.app.windows.each do |win|
     while tree = win.treebook.trees.first
       Redcar::ApplicationSWT.sync_exec do
@@ -86,6 +86,14 @@ After do
   end
 end
 
+Before do
+  close_everything
+end
+
+After do
+  close_everything
+end
+
 
 
 

data/plugins/application/lib/application.rb

@@ -8,6 +8,8 @@ require 'application/clipboard'
 require 'application/command'
 require 'application/dialog'
 require 'application/dialogs/filter_list_dialog'
+require 'application/keymap'
+require 'application/keymap/builder'
 require 'application/menu'
 require 'application/menu/item'
 require 'application/menu/builder'
@@ -19,17 +21,15 @@ require 'application/treebook'
 require 'application/window'
 
 module Redcar
-  class << self
-    attr_accessor :app, :history
-    attr_reader :gui
-  end
-
-  # Set the application GUI.
-  def self.gui=(gui)
-    raise "can't set gui twice" if @gui
-    @gui = gui
-  end
-  
+  # A Redcar process contains one Application instance. The application instance
+  # (the app) contains:
+  #
+  #  * an array of {Redcar::Window} objects and handles creating new Windows.
+  #  * a {Redcar::Clipboard}
+  #  * a {Redcar::Command::History}
+  #
+  # A lot of events in Redcar bubble up through the app, which gives plugins
+  # one place to hook into Redcar events.
   class Application
     NAME = "Redcar"
     
@@ -37,8 +37,7 @@ module Redcar
     include Redcar::Observable
     
     def self.start
-      Redcar.app     = Application.new
-      Redcar.history = Command::History.new
+      Redcar.app = Application.new
     end
     
     def self.sensitivities
@@ -67,17 +66,14 @@ module Redcar
       ]
     end
     
-    attr_reader :clipboard
+    attr_reader :clipboard, :keymap, :menu, :history
     
+    # Create an application instance with a Redcar::Clipboard and a Redcar::History.
     def initialize
       @windows = []
       @window_handlers = Hash.new {|h,k| h[k] = []}
       create_clipboard
-    end
-    
-    def create_clipboard
-      @clipboard       = Clipboard.new("application")
-      @clipboard.add_listener(:added) { notify_listeners(:clipboard_added) }
+      create_history
     end
     
     # Immediately halts the gui event loop.
@@ -85,7 +81,9 @@ module Redcar
       Redcar.gui.stop
     end
     
-    # Return a list of all open windows
+    # All open windows
+    #
+    # @return [Array<Redcar::Window>]
     def windows
       @windows
     end
@@ -96,67 +94,125 @@ module Redcar
       windows << new_window
       notify_listeners(:new_window, new_window)
       attach_window_listeners(new_window)
-      new_window.menu = menu
+      new_window.menu   = load_menu
+      new_window.keymap = main_keymap
+      new_window.refresh_menu
       new_window.show
       set_focussed_window(new_window)
       new_window
-    end
+    end   
+    
+    def make_sure_at_least_one_window_open
+      if windows.length == 0
+        new_window
+      end
+    end 
     
-    # Removes a window from this Application. Should not be called by user
-    # code, use Window#close instead.
+    # Removes a window from this Application. Should not be called by plugins,
+    # use Window#close instead.
     def window_closed(window)
       windows.delete(window)
       if focussed_window == window
         self.focussed_window = windows.first
       end
       @window_handlers[window].each {|h| window.remove_listener(h) }
+      
       @window_handlers.delete(window)
-      if windows.length == 0  and [:linux, :windows].include?(Redcar.platform)
-        quit
+      if windows.length == 0 and [:linux, :windows].include?(Redcar.platform)
+        if Application.storage['stay_resident_after_last_window_closed'] == 'yes' && !(ARGV.include?("--multiple-instance"))
+          puts 'continuing to run to wait for incoming drb connections later'
+        else
+          quit
+        end
+      end
+    end
+    
+    def self.storage
+      @storage ||= begin
+         storage = Plugin::Storage.new('application_plugin')
+         storage.set_default('stay_resident_after_last_window_closed', 'no')
+         storage
       end
     end
     
+    # All Redcar::Notebooks in all Windows.
+    def all_notebooks
+      windows.inject([]) { |arr, window| arr << window.notebooks }.flatten
+    end
+    
+    # All Redcar::Tabs in all Notebooks in all Windows.
+    def all_tabs
+      all_notebooks.inject([]) { |arr, notebook| arr << notebook.tabs }.flatten
+    end
+    
+    # The focussed Redcar::Notebook in the focussed window, or nil.
+    def focussed_window_notebook
+      focussed_window.focussed_notebook if focussed_window
+    end
+    
+    # The focussed Redcar::Tab in the focussed notebook in the focussed window.
+    def focussed_notebook_tab
+      focussed_window_notebook.focussed_tab if focussed_window_notebook
+    end
+
+    # The focussed Redcar::Window.    
     def focussed_window
       @focussed_window
     end
     
+    # Set which window the app thinks is focussed. 
+    # Should not be called by plugins, use Window#focus instead.
     def focussed_window=(window)
       set_focussed_window(window)
       notify_listeners(:focussed_window, window)
     end
     
+    # Set which window the app thinks is focussed.
+    # Should not be called by plugins, use Window#focus instead.
     def set_focussed_window(window)
       @focussed_window = window
     end
     
-    attr_reader :menu
-    
-    # Set the main menu. Causes a redraw of the GUI menu.
-    #
-    # @param [Menu]
-    def menu=(menu)
-      @menu = menu
+    # Redraw the main menu, reloading all the Menus and Keymaps from the plugins.
+    def refresh_menu!
       windows.each do |window|
-        window.menu = menu
+        window.menu = load_menu
+        window.keymap = main_keymap
+        window.refresh_menu
       end
     end
     
-    # Redraw the main menu. Useful if you have modified the main menu
-    # instead of setting it afresh.
-    def refresh_menu!
-      self.menu = @menu
-    end
-    
-    def load_menus
+    # Generate the main menu by combining menus from all plugins.
+    #
+    # @return [Redcar::Menu]
+    def load_menu
       menu = Menu.new
       Redcar.plugin_manager.loaded_plugins.each do |plugin|
         if plugin.object.respond_to?(:menus)
           menu.merge(plugin.object.menus)
         end
       end
-      self.menu = menu
+      menu
     end
     
+    # Generate the main keymap by merging the keymaps from all plugins.
+    #
+    # @return [Redcar::Keymap]
+    def main_keymap
+      keymap = Keymap.new("main", Redcar.platform)
+      Redcar.plugin_manager.loaded_plugins.each do |plugin|
+        if plugin.object.respond_to?(:keymaps)
+          maps = plugin.object.keymaps
+          keymaps = maps.select do |map| 
+            map.name == "main" and map.platforms.include?(Redcar.platform)
+          end
+          keymap = keymaps.inject(keymap) {|k, nk| k.merge(nk) }
+        end
+      end
+      keymap
+    end
+    
+    # Loads sensitivities from all plugins.
     def load_sensitivities
       Redcar.plugin_manager.loaded_plugins.each do |plugin|
         if plugin.object.respond_to?(:sensitivities)
@@ -165,6 +221,8 @@ module Redcar
       end
     end
     
+    private
+    
     def attach_window_listeners(window)
       h1 = window.add_listener(:tab_focussed) do |tab|
         notify_listeners(:tab_focussed, tab)
@@ -197,7 +255,19 @@ module Redcar
           notify_listeners(:focussed_tab_selection_changed, tab)
         end
       end
-      @window_handlers[window] << h1 << h2 << h3 << h4 << h5 << h6 << h7 << h8 << h9
+      h10 = window.add_listener(:about_to_close) do |win|
+        notify_listeners(:window_about_to_close, win)
+      end
+      @window_handlers[window] << h1 << h2 << h3 << h4 << h5 << h6 << h7 << h8 << h9 << h10
+    end
+    
+    def create_clipboard
+      @clipboard       = Clipboard.new("application")
+      @clipboard.add_listener(:added) { notify_listeners(:clipboard_added) }
+    end
+    
+    def create_history
+      @history = Command::History.new
     end
   end
 end

data/plugins/application/lib/application/clipboard.rb

@@ -1,6 +1,13 @@
 module Redcar
-  # A simple array with a maximum length. Models a copy/paste clipboard
-  # that can contain multiple elements.
+  # Models a copy/paste clipboard that can contain multiple elements.
+  #
+  # Each entry in the Clipboard is an array of Strings, like these:
+  #
+  #      ["mytext"]
+  #      ["foo", "bar"]
+  #
+  # Each entry is an array of Strings in order to support copy/paste in 
+  # block selection mode.
   class Clipboard
     include Redcar::Model
     include Redcar::Observable
@@ -17,13 +24,17 @@ module Redcar
       @contents = []
     end
     
-    # Add text to the clipboard.
+    # Add an entry to the clipboard.
+    #
+    # Events: [:added, Array<String>]
     #
     # @param [String, Array<String>]
     def <<(text)
       if text.is_a?(String)
         text = [text]
       end
+      return if text == [""]
+      
       @contents << text
       if @contents.length == Clipboard.max_length + 1
         @contents.delete_at(0)
@@ -32,26 +43,37 @@ module Redcar
       notify_listeners(:added, text)
     end
     
+    # The most recent entry added to the Clipboard
+    #
+    # @return [Array<String>]
     def last
       check_for_changes
       @contents.last
     end
     
+    # The number of entries on the Clipboard
     def length
       check_for_changes
       @contents.length
     end
     
+    # Fetch an entry. 0 is the most recent
+    #
+    # @return [Array<String>]
     def [](index)
       check_for_changes
       @contents[-1*index-1]
     end
     
+    # Iterate over each entry.
     def each(&block)
       check_for_changes
       @contents.each(&block)
     end
     
+    # Add an entry without raising an event.
+    #
+    # @param [String, Array<String>]
     def silently_add(text)
       @contents << text
     end
@@ -60,7 +82,9 @@ module Redcar
     
     def check_for_changes
       if controller and controller.changed?
-        controller.last_set = @contents.last.join("\n")
+        if @contents.length > 0
+          controller.last_set = @contents.last.join("\n")
+        end
         contents = controller.get_contents
         self << contents if contents
       end

data/plugins/application/lib/application/command.rb

@@ -8,10 +8,10 @@ module Redcar
   # ## Examples
   #
   #     class CloseTab < Redcar::Command
-  #       key  :linux   => "Ctrl+W",
-  #            :osx     => "Cmd+W",
-  #            :windows => "Ctrl+W"
-  #     
+  #       def self.keymaps
+  #          Redcar::Keymap.build("main", :osx) do
+  #            link "Cmd+W",  CloseTab
+  #          end            
   #       def execute
   #         tab.close if tab
   #       end
@@ -32,14 +32,6 @@ module Redcar
       notify_listeners(:active_changed, value)
     end
     
-    def self.key(key)
-      @key = key
-    end
-    
-    def self.get_key
-      @key
-    end
-    
     def self.norecord
       @record = false
     end

data/plugins/application/lib/application/command/executor.rb

@@ -42,8 +42,8 @@ module Redcar
       end
       
       def record
-        if Redcar.history
-          Redcar.history.record(@command_instance)
+        if Redcar.app.history
+          Redcar.app.history.record(@command_instance)
         end
       end
     end

data/plugins/application/lib/application/keymap.rb

@@ -0,0 +1,39 @@
+
+module Redcar
+  class Keymap
+    def self.build(name, platform, &block)
+      Builder.new(name, platform, &block).keymap
+    end
+    
+    attr_reader :name, :platforms
+    attr_accessor :map
+      
+    def initialize(name, platforms)
+      @name, @platforms = name, [*platforms]
+      @map = {}
+    end
+    
+    def link(key_string, command)
+      @map[key_string] = command
+    end
+    
+    def command(key_string)
+      @map[key_string]
+    end
+    
+    def command_to_key(command)
+      @map.invert[command]
+    end
+    
+    def length
+      @map.length
+    end
+    
+    def merge(other)
+      keymap = Keymap.new(@name, @platforms)
+      keymap.map = @map.merge(other.map)
+      keymap
+    end
+  end
+end
+ 

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

@@ -0,0 +1,19 @@
+
+module Redcar
+  class Keymap
+    class Builder
+      attr_reader :keymap
+
+      def initialize(name, platforms, &block)
+        @keymap = Keymap.new(name, platforms)
+        instance_eval(&block)
+      end
+      
+      private
+      
+      def link(key, command)
+        @keymap.link(key, command)
+      end
+    end
+  end
+end