redcar 0.11.0dev → 0.11

data/plugins/project/lib/project/project_tree_controller.rb

@@ -15,7 +15,7 @@ module Redcar
           if tree == @project.tree and r = win.treebook.trees.detect do |t|
             t.tree_mirror.title == @title
           end
-            r.close
+            @project.close
           end
         end
       end

data/plugins/project/plugin.rb

@@ -7,6 +7,5 @@ Plugin.define do
   dependencies "edit_view", ">0",
                "HTML View", ">0",
                "connection_manager", ">0",
-               "application", ">=1.1",
-               "tree", ">=0"
+               "application", ">=1.1"
 end

data/plugins/project_search/features/word_search.feature

@@ -5,7 +5,7 @@ Feature: Word search
   Background:
     Given I will choose "plugins/project_search/spec/fixtures/project" from the "open_directory" dialog
     And I open a directory
-    When I open the "Word Search" from the "Project" menu
+    When I open the "Search" from the "Project" menu
     And I wait "3" seconds
 
   Scenario: See the search interface

data/plugins/project_search/lib/project_search.rb

@@ -15,7 +15,10 @@ class ProjectSearch
     Redcar::Menu::Builder.build do
       sub_menu "Project" do
         group :priority => 1 do
-          item "Search",  :command => ProjectSearch::WordSearchCommand
+          item "Word Search",  :command => ProjectSearch::WordSearchCommand
+        end
+        sub_menu "Refresh", :priority => 31 do
+          item "Search index", :command => ProjectSearch::RefreshIndex
         end
       end
     end
@@ -33,8 +36,8 @@ class ProjectSearch
 
   def self.toolbars
     Redcar::ToolBar::Builder.build do
-      item "Search", :command => WordSearchCommand, 
-        :icon => File.join(Redcar::ICONS_DIRECTORY, "application-search-result.png"), 
+      item "Word Search", :command => WordSearchCommand,
+        :icon => File.join(Redcar::ICONS_DIRECTORY, "application-search-result.png"),
         :barname => :project
     end
   end
@@ -54,13 +57,20 @@ class ProjectSearch
     end
   end
   
-  Lucene::Config.use do |config| 
-    config[:store_on_file] = true 
+  def self.shared_storage
+    @shared_storage ||= begin
+      storage = Redcar::Plugin::SharedStorage.new('shared__ignored_files')
+      storage.set_or_update_default('ignored_file_patterns', [/tags$/, /\.log$/])
+      storage.save
+    end
+  end
+  
+  Lucene::Config.use do |config|
+    config[:store_on_file] = true
     config[:storage_path]  = ""
     config[:id_field]      = :id
   end
   
-  
   def self.project_refresh_task_type
     LuceneRefresh
   end

data/plugins/project_search/lib/project_search/commands.rb

@@ -1,5 +1,18 @@
 
 class ProjectSearch
+  class RefreshIndex < Redcar::Command
+    sensitize :open_project
+    
+    def execute
+      if project = Redcar::Project::Manager.focussed_project
+        if index = ProjectSearch.indexes[project.path]
+          index.delete
+          project.refresh
+        end
+      end
+    end
+  end
+  
   class WordSearchCommand < Redcar::Command
     sensitize :open_project
     
@@ -12,7 +25,7 @@ class ProjectSearch
     
     def execute
       if project = Redcar::Project::Manager.focussed_project
-        if (tab = find_open_instance)
+        if tab = find_open_instance
           tab.html_view.refresh
           tab.focus
         else
@@ -31,32 +44,6 @@ class ProjectSearch
       return
     end
   end
-  
-  class RegexSearchCommand < Redcar::Command
-    sensitize :open_project
-    
-    def execute
-      if Redcar::Project::Manager.focussed_project
-        if (tab = find_open_instance)
-          tab.html_view.controller = tab.html_view.controller # refresh
-        else
-          tab = win.new_tab(Redcar::HtmlTab)
-          tab.html_view.controller = ProjectSearch::RegexSearchController.new
-        end
-        tab.focus
-      else
-        # warning
-        Redcar::Application::Dialog.message_box("You need an open project to be able to use Find In Project!", :type => :error)
-      end
-    end
+end
 
-    private
 
-    def find_open_instance
-      all_tabs = Redcar.app.focussed_window.notebooks.map { |nb| nb.tabs }.flatten
-      all_tabs.find do |t|
-        t.is_a?(Redcar::HtmlTab) && t.title == ProjectSearch::RegexSearchController.new.title
-      end
-    end
-  end  
-end

data/plugins/project_search/lib/project_search/hit.rb

@@ -13,5 +13,9 @@ class ProjectSearch
     def line(start_with=nil, end_with=nil)
       @line.gsub(@regex) { start_with.to_s + $& + end_with.to_s }
     end
+    
+    def inspect
+      "<Hit #{file}:#{line_num}>"
+    end
   end
 end

data/plugins/project_search/lib/project_search/lucene_index.rb

@@ -13,6 +13,16 @@ class ProjectSearch
       File.join(@project.config_dir, 'lucene_last_updated')
     end
     
+    def lucene_index_dir
+      File.join(@project.config_dir, "lucene")
+    end
+    
+    def delete
+      FileUtils.rm(timestamp_file_path)
+      FileUtils.rm_r(lucene_index_dir)
+      load
+    end
+    
     def load
       @last_updated = Time.at(0)
       if File.exist?(timestamp_file_path)
@@ -35,12 +45,12 @@ class ProjectSearch
       changed_files = @project.file_list.changed_since(last_updated)
       @last_updated = Time.now
       changed_files.reject! do |fn, ts|
-        fn.index(@project.config_dir)
+        fn.index(@project.config_dir) or Redcar::Project::FileList.hide_file_path?(fn)
       end
-      Lucene::Transaction.run do 
-        @lucene_index ||= Lucene::Index.new(File.join(@project.config_dir, "lucene")) 
+      Lucene::Transaction.run do
+        @lucene_index ||= Lucene::Index.new(lucene_index_dir)
         begin
-          @lucene_index.field_infos[:contents][:store] = true 
+          @lucene_index.field_infos[:contents][:store] = true
           @lucene_index.field_infos[:contents][:tokenized] = true
          changed_files.each do |fn, ts|
             unless File.basename(fn)[0..0] == "." or fn.include?(".git")
               contents = File.read(fn)

data/plugins/project_search/lib/project_search/views/_file.html.erb

@@ -15,16 +15,16 @@
 <% hits.each_with_index do |hit, i| %>
   <% next_hit = hits[i + 1] %>
   <% next_hit_line_num = next_hit ? next_hit.line_num : 100_000_000 %>
-  
-  <% if @word_search.context? and last_matching_line_num and (hit.line_num - last_matching_line_num) > (@word_search.context_size * 2) %>
+  <% display_line_num = hit.line_num + 1%>
+  <% if @word_search.context? and last_matching_line_num and (display_line_num - last_matching_line_num) > (@word_search.context_size * 2) %>
     <tr class="divider file_<%= file_num %>">
       <td class="line_num">. . .</td>
       <td class="text">&nbsp;</td> <!-- extra space to ensure line-height is respected -->
     </tr>
   <% end %>
-  
+
   <% hit.pre_context.each_with_index do |context_line, i| %>
-    <% this_line_num = hit.line_num - @word_search.context_size + i %>
+    <% this_line_num = display_line_num - @word_search.context_size + i %>
     <% unless this_line_num <= last_displayed_line_num %>
       <% line_index += 1 %>
       <tr class="result file_<%= file_num %> line_<%= this_line_num %> <%= (line_index % 2 == 0 ? 'even' : 'odd') %>" data-href='<%= CGI::escapeHTML(file) %>' data-line_num='<%= this_line_num %>'>
@@ -34,17 +34,17 @@
       </tr>
     <% end %>
   <% end %>
-  
+
   <% line_index += 1 %>
-  <% last_displayed_line_num = hit.line_num %>
-  <tr class="result file_<%= file_num %> line_<%= hit.line_num %> <%= (line_index % 2 == 0 ? 'even' : 'odd') %>" data-href='<%= CGI::escapeHTML(file) %>' data-line_num='<%= hit.line_num %>'>
-  <td class='line_num'><%= hit.line_num %></td>
+  <% last_displayed_line_num = display_line_num %>
+  <tr class="result file_<%= file_num %> line_<%= display_line_num %> <%= (line_index % 2 == 0 ? 'even' : 'odd') %>" data-href='<%= CGI::escapeHTML(file) %>' data-line_num='<%= display_line_num %>'>
+  <td class='line_num'><%= display_line_num %></td>
     <% text = CGI.escapeHTML(hit.line).gsub(@word_search.regex) { "<span>#{$&}</span>" } %>
     <td class='text'><pre><%= text.chomp + " " %></pre></td> <!-- extra space to ensure line-height is respected -->
   </tr>
 
   <% hit.post_context.each_with_index do |context_line, i| %>
-    <% this_line_num = hit.line_num + i + 1%>
+    <% this_line_num = display_line_num + i + 1%>
     <% unless this_line_num >= next_hit_line_num %>
       <% last_displayed_line_num = this_line_num %>
       <% line_index += 1 %>
@@ -55,6 +55,6 @@
       </tr>
     <% end %>
   <% end %>
-  
-  <% last_matching_line_num = hit.line_num %>
+
+  <% last_matching_line_num = display_line_num %>
 <% end %>

data/plugins/project_search/lib/project_search/word_search.rb

@@ -49,6 +49,7 @@ class ProjectSearch
               remove_hits << hit
             end
           end
+          
           hits_needing_post_context -= remove_hits
           
           if matching_line?(line)
@@ -59,11 +60,10 @@ class ProjectSearch
               hits_needing_post_context << hit
             end
           end
-          
-          if pre_context.length == context_size
+          pre_context << line
+          if pre_context.length > context_size
             pre_context.shift
           end
-          pre_context << line
         end
         send_file_results(file_hits)
       end
@@ -97,7 +97,25 @@ class ProjectSearch
           new_doc_ids = index.find(:contents => bit.downcase).map {|doc| doc.id }
           doc_ids = doc_ids ? (doc_ids & new_doc_ids) : new_doc_ids
         end
-        doc_ids
+        doc_ids.reject {|doc_id| Redcar::Project::FileList.hide_file_path?(doc_id) }
+      end
+    end
+  
+    def ignore_regexes
+      self.class.shared_storage['ignored_file_patterns']
+    end
+
+    def ignore_file?(filename)
+      if self.class.storage['ignore_file_patterns']
+        ignore_regexes.any? {|re| re =~ filename }
+      end
+    end
+
+    def inspect
+      if @results
+        "<ProjectSearch::WordSearch #{project.path} \"#{query_string}\" #{@results.length} hits>"
+      else
+        "<ProjectSearch::WordSearch #{project.path} \"#{query_string}\" ...>"
       end
     end
   end

data/plugins/project_search/spec/project_search/word_search_spec.rb

@@ -37,7 +37,7 @@ describe ProjectSearch::WordSearch do
       results.length.should == 1
       result = results.first
       result.should be_an_instance_of(ProjectSearch::Hit)
-      result.file.should == project_search_fixture_dir + "/foo.txt"
+      File.expand_path(result.file).should == File.expand_path(project_search_fixture_dir + "/foo.txt")
       result.line_num.should == 0
       result.line("<b>", "</b>").should == "<b>Foo</b> Bar Baz"
     end
@@ -68,7 +68,7 @@ describe ProjectSearch::WordSearch do
       results.length.should == 1
       result = results.first
       result.should be_an_instance_of(ProjectSearch::Hit)
-      result.file.should == project_search_fixture_dir + "/foo.txt"
+      File.expand_path(result.file).should == File.expand_path(project_search_fixture_dir + "/foo.txt")
       result.line_num.should == 2
       result.line("<b>", "</b>").should == "<b>Corge</b> <b>Corge</b> <b>Corge</b>"
     end

data/plugins/redcar/redcar.rb

@@ -52,41 +52,7 @@ module Redcar
   end
 
   module Top
-    class QuitCommand < Command
-
-      def execute
-        check_for_modified_tabs_and_quit
-      end
-
-      private
-
-      def check_for_modified_tabs_and_quit
-        EditView::ModifiedTabsChecker.new(
-          Redcar.app.all_tabs.select {|t| t.is_a?(EditTab)},
-          "Save all before quitting?",
-          :none     => lambda { check_for_running_processes_and_quit },
-          :continue => lambda { check_for_running_processes_and_quit },
-          :cancel   => nil
-        ).check
-      end
-
-      def check_for_running_processes_and_quit
-        Runnables::RunningProcessChecker.new(
-          Redcar.app.all_tabs.select {|t| t.is_a?(HtmlTab)},
-          "Kill all and quit?",
-          :none     => lambda { quit },
-          :continue => lambda { quit },
-          :cancel   => nil
-        ).check
-      end
-      
-      def quit
-        Project::Manager.open_projects.each {|pr| pr.close }
-        Redcar.app.quit
-      end
-    end
-
-    class NewCommand < Command
+    class OpenNewEditTabCommand < Command
 
       def execute
         unless win.nil?
@@ -101,76 +67,6 @@ module Redcar
       end
     end
 
-    class NewNotebookCommand < Command
-#      sensitize :single_notebook
-
-      def execute
-        #unless win.notebooks.length > 1
-          win.create_notebook
-       # end
-      end
-    end
-
-    class NewWindowCommand < Command
-
-      def initialize(title=nil)
-        @title = title
-      end
-
-      def execute
-        window = Redcar.app.new_window
-        window.title = @title if @title
-      end
-    end
-
-    class CloseWindowCommand < Command
-      def initialize(window=nil)
-        @window = window
-      end
-
-      def execute
-        check_for_modified_tabs_and_close_window
-        quit_if_no_windows if [:linux, :windows].include?(Redcar.platform)
-        @window = nil
-      end
-
-      private
-
-      def quit_if_no_windows
-        if Redcar.app.windows.length == 0
-          if Application.storage['stay_resident_after_last_window_closed'] && !(ARGV.include?("--multiple-instance"))
-            puts 'continuing to run to wait for incoming drb connections later'
-          else
-            QuitCommand.new.run
-          end
-        end
-      end
-
-      def check_for_modified_tabs_and_close_window
-        EditView::ModifiedTabsChecker.new(
-          win.notebooks.map(&:tabs).flatten.select {|t| t.is_a?(EditTab)},
-          "Save all before closing the window?",
-          :none     => lambda { check_for_running_processes_and_close_window },
-          :continue => lambda { check_for_running_processes_and_close_window },
-          :cancel   => nil
-        ).check
-      end
-
-      def check_for_running_processes_and_close_window
-        Runnables::RunningProcessChecker.new(
-          win.notebooks.map(&:tabs).flatten.select {|t| t.is_a?(HtmlTab)},
-          "Kill them and close the window?",
-          :none     => lambda { win.close },
-          :continue => lambda { win.close },
-          :cancel   => nil
-        ).check
-      end
-
-      def win
-        @window || super
-      end
-    end
-
     class GenerateWindowsMenu < Command
       def initialize(builder)
         @builder = builder
@@ -205,9 +101,15 @@ module Redcar
           book.tabs.each_with_index do |tab,i|
             num = i + 1
             if num < 10
-              @builder.item "Tab #{num}: #{trim(tab.title)}", :type => :radio, :active => (tab == focussed_tab), :command => Top.const_get("SelectTab#{num}Command")
+              @builder.item("Tab #{num}: #{trim(tab.title)}",
+                :type => :radio,
+                :active => (tab == focussed_tab),
+                :command => Redcar::Application.const_get("SelectTab#{num}Command")
+              )
             else
-              @builder.item("Tab #{num}: #{trim(tab.title)}", :type => :radio, :active => (tab == focussed_tab)) {tab.focus}
+              @builder.item("Tab #{num}: #{trim(tab.title)}",
+                :type => :radio,
+                :active => (tab == focussed_tab)) { tab.focus }
             end
           end
           if book = win.nonfocussed_notebook and book.tabs.any?
@@ -221,133 +123,9 @@ module Redcar
       end
     end
 
-    class FocusWindowCommand < Command
-      def initialize(window=nil)
-        @window = window
-      end
-
-      def execute
-        win.focus
-        @window = nil
-      end
-
-      def win
-        @window || super
-      end
-    end
-
-    class RotateNotebooksCommand < Command
-      sensitize :multiple_notebooks
-
-      def execute
-        win.rotate_notebooks
-      end
-    end
-
-    class CloseNotebookCommand < Command
-      sensitize :multiple_notebooks
-
-      def execute
-        unless win.notebooks.length == 1
-          win.close_notebook
-        end
-      end
-    end
-
-    class SwitchNotebookCommand < Command
-      sensitize :multiple_notebooks, :other_notebook_has_tab
-
-      def execute
-        new_notebook = win.nonfocussed_notebook
-        if new_notebook.focussed_tab
-          new_notebook.focussed_tab.focus
-        end
-      end
-    end
-
-    class MoveTabToOtherNotebookCommand < Command
-      sensitize :multiple_notebooks, :open_tab
-
-      def execute
-        current_notebook = tab.notebook
-        i = win.notebooks.index current_notebook
-
-        target_notebook = win.notebooks[ (i + 1) % win.notebooks.length ]
-        target_notebook.grab_tab_from(current_notebook, tab)
-        tab.focus
-      end
-    end
-
-    class OpenTreeFinderCommand < TreeCommand
-
-      def execute
-        if win = Redcar.app.focussed_window
-          if trees = win.treebook.trees and trees.any?
-            titles = []
-            trees.each {|t| titles << t.tree_mirror.title}
-            dialog = TreeFuzzyFilter.new(win,titles)
-            dialog.open
-          end
-        end
-      end
-
-      class TreeFuzzyFilter < FilterListDialog
-
-        def initialize(win,titles)
-          super()
-          @win = win
-          @titles = titles
-        end
-
-        def selected(text,ix)
-          if tree = @win.treebook.trees.detect do |tree|
-              tree.tree_mirror.title == text
-            end
-            if @win.treebook.focussed_tree == tree
-              @win.set_trees_visible(true) if not @win.trees_visible?
-            else
-              @win.treebook.focus_tree(tree)
-            end
-            tree.focus
-            close
-          end
-        end
-
-        def update_list(filter)
-          @titles.select do |t|
-            t.downcase.include?(filter.downcase)
-          end
-        end
-      end
-    end
-
-    class CloseTreeCommand < TreeCommand
-      def execute
-        win = Redcar.app.focussed_window
-        if win and treebook = win.treebook
-          if tree = treebook.focussed_tree
-            treebook.remove_tree(tree)
-          end
-        end
-      end
-    end
-
-    class ToggleTreesCommand < TreeCommand
-      def execute
-        win = Redcar.app.focussed_window
-        if win and treebook = win.treebook
-          if win.trees_visible?
-            win.set_trees_visible(false)
-          else
-            win.set_trees_visible(true)
-          end
-        end
-      end
-    end
-
     class AboutCommand < Command
       def execute
-        new_tab = Top::NewCommand.new.run
+        new_tab = Top::OpenNewEditTabCommand.new.run
         new_tab.document.text = <<-TXT
 About: Redcar\nVersion: #{Redcar::VERSION}
 Ruby Version: #{RUBY_VERSION}
@@ -362,7 +140,7 @@ Redcar.environment: #{Redcar.environment}
 
     class ChangelogCommand < Command
       def execute
-        new_tab = Top::NewCommand.new.run
+        new_tab = Top::OpenNewEditTabCommand.new.run
         new_tab.document.text = File.read(File.join(File.dirname(__FILE__), "..", "..", "CHANGES"))
         new_tab.edit_view.reset_undo
         new_tab.edit_view.document.set_modified(false)
@@ -382,135 +160,6 @@ Redcar.environment: #{Redcar.environment}
       end
     end
 
-    class CloseTabCommand < TabCommand
-      def initialize(tab=nil)
-        @tab = tab
-      end
-
-      def tab
-        @tab || super
-      end
-
-      def execute
-        if tab.is_a?(EditTab)
-          if tab.edit_view.document.modified?
-            tab.focus
-            result = Application::Dialog.message_box(
-              "This tab has unsaved changes. \n\nSave before closing?",
-              :buttons => :yes_no_cancel
-            )
-            case result
-            when :yes
-              tab.edit_view.document.save!
-              close_tab
-            when :no
-              close_tab
-            when :cancel
-            end
-          else
-            close_tab
-          end
-        elsif tab.is_a?(HtmlTab)
-          if tab.html_view.controller and message = tab.html_view.controller.ask_before_closing
-            tab.focus
-            result = Application::Dialog.message_box(
-              message,
-              :buttons => :yes_no_cancel
-            )
-            case result
-            when :yes
-              close_tab
-            when :no
-              close_tab
-            when :cancel
-            end
-          else
-            close_tab
-          end
-        else
-          close_tab
-        end
-        @tab = nil
-      end
-
-      private
-
-      def close_tab
-        win = tab.notebook.window
-        tab.close
-        # this will break a lot of features:
-        #if win.all_tabs.empty? and not Project::Manager.in_window(win)
-        #  win.close
-        #end
-      end
-    end
-
-    class CloseAll < Redcar::Command
-      def execute
-        window = Redcar.app.focussed_window
-        tabs = window.all_tabs
-        tabs.each do |t|
-          Redcar::Top::CloseTabCommand.new(t).run
-        end
-      end
-    end
-
-    class CloseOthers < Redcar::Command
-      def execute
-        window = Redcar.app.focussed_window
-        current_tab = Redcar.app.focussed_notebook_tab
-        tabs = window.all_tabs
-        tabs.each do |t|
-          unless t == current_tab
-            Redcar::Top::CloseTabCommand.new(t).run
-          end
-        end
-      end
-    end
-
-    class SwitchTreeDownCommand < TreeCommand
-
-      def execute
-        win = Redcar.app.focussed_window
-        win.treebook.switch_down
-      end
-    end
-
-    class SwitchTreeUpCommand < TreeCommand
-
-      def execute
-        win = Redcar.app.focussed_window
-        win.treebook.switch_up
-      end
-    end
-
-    class SwitchTabDownCommand < TabCommand
-
-      def execute
-        win.focussed_notebook.switch_down
-      end
-    end
-
-    class SwitchTabUpCommand < TabCommand
-
-      def execute
-        win.focussed_notebook.switch_up
-      end
-    end
-
-    class MoveTabUpCommand < TabCommand
-
-      def execute
-        win.focussed_notebook.move_up
-      end
-    end
-
-    class MoveTabDownCommand < TabCommand
-
-      def execute
-        win.focussed_notebook.move_down
-      end
-    end
 
     class UndoCommand < EditTabCommand
       sensitize :undoable
@@ -802,22 +451,6 @@ Redcar.environment: #{Redcar.environment}
       end
     end
 
-    class DialogExample < Redcar::Command
-      def execute
-      	builder = Menu::Builder.new do
-      	  item("Foo") { p :foo }
-      	  item("Bar") { p :bar }
-      	  separator
-      	  sub_menu "Baz" do
-      	    item("Qux") { p :qx }
-      	    item("Quux") { p :quux }
-      	    item("Corge") { p :corge }
-      	  end
-      	end
-      	win.popup_menu(builder.menu)
-      end
-    end
-
     class GotoLineCommand < Redcar::EditTabCommand
 
       class Speedbar < Redcar::Speedbar
@@ -856,79 +489,6 @@ Redcar.environment: #{Redcar.environment}
       end
     end
 
-    class TreebookWidthCommand < Command
-      sensitize :open_trees
-
-      def increment
-        raise "Please implement me!"
-      end
-
-      def execute
-        if win = Redcar.app.focussed_window
-          if increment > 0
-            win.adjust_treebook_width(true)
-          else
-            win.adjust_treebook_width(false)
-          end
-        end
-      end
-    end
-
-    ["In","De"].each do |prefix|
-      const_set("#{prefix}creaseTreebookWidthCommand", Class.new(TreebookWidthCommand)).class_eval do
-        define_method :increment do
-          prefix == "In" ? 1 : -1
-        end
-      end
-    end
-
-    class EnlargeNotebookCommand < Command
-      sensitize :multiple_notebooks
-      def index
-        raise "Please define me!"
-      end
-
-      def execute
-        if win = Redcar.app.focussed_window
-          win.enlarge_notebook(index)
-        end
-      end
-    end
-
-    ["First","Second"].each do |book|
-      const_set("Enlarge#{book}NotebookCommand", Class.new(EnlargeNotebookCommand)).class_eval do
-        define_method :index do
-          book == "First" ? 0 : 1
-        end
-      end
-    end
-
-    # define commands from SelectTab1Command to SelectTab9Command
-    (1..9).each do |tab_num|
-      const_set("SelectTab#{tab_num}Command", Class.new(Redcar::TabCommand)).class_eval do
-        define_method :execute do
-          notebook = Redcar.app.focussed_window_notebook
-          notebook.tabs[tab_num-1].focus if notebook.tabs[tab_num-1]
-        end
-      end
-    end
-
-    class ResetNotebookWidthsCommand < Command
-      sensitize :multiple_notebooks
-
-      def execute
-        if win = Redcar.app.focussed_window
-          win.reset_notebook_widths
-        end
-      end
-    end
-
-    class ToggleFullscreen < Command
-      def execute
-        Redcar.app.focussed_window.fullscreen = !Redcar.app.focussed_window.fullscreen
-      end
-    end
-
     class ToggleInvisibles < Redcar::EditTabCommand
       def execute
         EditView.show_invisibles = !EditView.show_invisibles?
@@ -941,14 +501,6 @@ Redcar.environment: #{Redcar.environment}
       end
     end
 
-    class ToggleToolbar < Command
-
-      def execute
-        Redcar.app.toggle_show_toolbar
-        Redcar.app.refresh_toolbar!
-      end
-    end
-
     class SelectNewFont < EditTabCommand
       def execute
         Redcar::EditView::SelectFontDialog.new.open
@@ -1010,20 +562,20 @@ Redcar.environment: #{Redcar.environment}
 
     def self.keymaps
       osx = Redcar::Keymap.build("main", :osx) do
-        link "Cmd+N",       NewCommand
-        link "Cmd+Shift+N", NewNotebookCommand
-        link "Cmd+Alt+N",   NewWindowCommand
-        link "Cmd+O",       Project::FileOpenCommand
+        link "Cmd+N",       OpenNewEditTabCommand
+        link "Cmd+Shift+N", Application::OpenNewNotebookCommand
+        link "Cmd+Alt+N",   Application::OpenNewWindowCommand
+        link "Cmd+O",       Project::OpenFileCommand
         link "Cmd+U",       Project::FileReloadCommand
         link "Cmd+Shift+O", Project::DirectoryOpenCommand
         link "Cmd+Alt+Ctrl+P",   Project::FindRecentCommand
         #link "Cmd+Ctrl+O",  Project::OpenRemoteCommand
-        link "Cmd+S",       Project::FileSaveCommand
-        link "Cmd+Shift+S", Project::FileSaveAsCommand
-        link "Cmd+W",       CloseTabCommand
-        link "Cmd+Shift+W", CloseWindowCommand
-        link "Alt+Shift+W", CloseTreeCommand
-        link "Cmd+Q",       QuitCommand
+        link "Cmd+S",       Project::SaveFileCommand
+        link "Cmd+Shift+S", Project::SaveFileAsCommand
+        link "Cmd+W",       Application::CloseTabCommand
+        link "Cmd+Shift+W", Application::CloseWindowCommand
+        link "Alt+Shift+W", Application::CloseTreeCommand
+        link "Cmd+Q",       Application::QuitCommand
 
         #link "Cmd+Return",   MoveNextLineCommand
 
@@ -1062,29 +614,28 @@ Redcar.environment: #{Redcar.environment}
         link "Ctrl+Shift+^", SortLinesCommand
 
         link "Cmd+T",           Project::FindFileCommand
-        link "Cmd+Shift+Alt+O", MoveTabToOtherNotebookCommand
-        link "Cmd+Alt+O",       SwitchNotebookCommand
-        link "Alt+Shift+[",     SwitchTreeUpCommand
-        link "Alt+Shift+]",     SwitchTreeDownCommand
-        link "Cmd+Shift+[",     SwitchTabDownCommand
-        link "Cmd+Shift+]",     SwitchTabUpCommand
-        link "Ctrl+Shift+[",    MoveTabDownCommand
-        link "Ctrl+Shift+]",    MoveTabUpCommand
-        link "Cmd+Shift++",     ToggleFullscreen
-        link "Cmd+Shift+T",     OpenTreeFinderCommand
-        link "Alt+Shift+J",     IncreaseTreebookWidthCommand
-        link "Alt+Shift+H",     DecreaseTreebookWidthCommand
-        link "Cmd+Shift+>",     EnlargeFirstNotebookCommand
-        link "Cmd+Shift+<",     EnlargeSecondNotebookCommand
-        link "Cmd+Shift+L",     ResetNotebookWidthsCommand
-        link "Cmd+Shift+:",     RotateNotebooksCommand
-        link "Alt+Shift+N",     CloseNotebookCommand
+        link "Cmd+Shift+Alt+O", Application::MoveTabToOtherNotebookCommand
+        link "Cmd+Alt+O",       Application::SwitchNotebookCommand
+        link "Alt+Shift+[",     Application::SwitchTreeUpCommand
+        link "Alt+Shift+]",     Application::SwitchTreeDownCommand
+        link "Cmd+Shift+[",     Application::SwitchTabDownCommand
+        link "Cmd+Shift+]",     Application::SwitchTabUpCommand
+        link "Ctrl+Shift+[",    Application::MoveTabDownCommand
+        link "Ctrl+Shift+]",    Application::MoveTabUpCommand
+        link "Cmd+Shift++",     Application::ToggleFullscreen
+        link "Cmd+Shift+T",     Application::OpenTreeFinderCommand
+        link "Alt+Shift+J",     Application::IncreaseTreebookWidthCommand
+        link "Alt+Shift+H",     Application::DecreaseTreebookWidthCommand
+        link "Cmd+Shift+>",     Application::EnlargeNotebookCommand
+        link "Cmd+Shift+L",     Application::ResetNotebookWidthsCommand
+        link "Cmd+Shift+:",     Application::RotateNotebooksCommand
+        link "Alt+Shift+N",     Application::CloseNotebookCommand
         link "Cmd+Alt+I",       ToggleInvisibles
         link "Cmd++",           IncreaseFontSize
         link "Cmd+-",           DecreaseFontSize
 
         link "Ctrl+Shift+P", PrintScopeCommand
-        link "Cmd+Shift+H",  ToggleTreesCommand
+        link "Cmd+Shift+H",  Application::ToggleTreesCommand
 
         # link "Cmd+Shift+R",     PluginManagerUi::ReloadLastReloadedCommand
 
@@ -1093,25 +644,25 @@ Redcar.environment: #{Redcar.environment}
 
         # map SelectTab<number>Command
         (1..9).each do |tab_num|
-          link "Cmd+#{tab_num}", Top.const_get("SelectTab#{tab_num}Command")
+          link "Cmd+#{tab_num}", Application.const_get("SelectTab#{tab_num}Command")
         end
 
       end
 
       linwin = Redcar::Keymap.build("main", [:linux, :windows]) do
-        link "Ctrl+N",       NewCommand
-        link "Ctrl+Shift+N", NewNotebookCommand
-        link "Ctrl+Alt+N",   NewWindowCommand
-        link "Ctrl+O",       Project::FileOpenCommand
+        link "Ctrl+N",       OpenNewEditTabCommand
+        link "Ctrl+Shift+N", Application::OpenNewNotebookCommand
+        link "Ctrl+Alt+N",   Application::OpenNewWindowCommand
+        link "Ctrl+O",       Project::OpenFileCommand
         link "Ctrl+Shift+O", Project::DirectoryOpenCommand
         link "Ctrl+Alt+Shift+P",   Project::FindRecentCommand
         #link "Alt+Shift+O",  Project::OpenRemoteCommand
-        link "Ctrl+S",       Project::FileSaveCommand
-        link "Ctrl+Shift+S", Project::FileSaveAsCommand
-        link "Ctrl+W",       CloseTabCommand
-        link "Ctrl+Shift+W", CloseWindowCommand
-        link "Alt+Shift+W",  CloseTreeCommand
-        link "Ctrl+Q",       QuitCommand
+        link "Ctrl+S",       Project::SaveFileCommand
+        link "Ctrl+Shift+S", Project::SaveFileAsCommand
+        link "Ctrl+W",       Application::CloseTabCommand
+        link "Ctrl+Shift+W", Application::CloseWindowCommand
+        link "Alt+Shift+W",  Application::CloseTreeCommand
+        link "Ctrl+Q",       Application::QuitCommand
 
         link "Ctrl+Enter",   MoveNextLineCommand
 
@@ -1141,7 +692,7 @@ Redcar.environment: #{Redcar.environment}
         link "Escape",           AutoCompleter::AutoCompleteCommand
         link "Ctrl+Escape",      AutoCompleter::MenuAutoCompleterCommand
         link "Ctrl+Space",       AutoCompleter::AutoCompleteCommand
-        
+
         link "Ctrl+Shift+Space", AutoCompleter::MenuAutoCompleterCommand
 
         link "Ctrl+U",           EditView::UpcaseTextCommand
@@ -1153,28 +704,26 @@ Redcar.environment: #{Redcar.environment}
         link "Ctrl+Shift+^",     SortLinesCommand
 
         link "Ctrl+T",           Project::FindFileCommand
-        link "Ctrl+Shift+Alt+O", MoveTabToOtherNotebookCommand
+        link "Ctrl+Shift+Alt+O", Application::MoveTabToOtherNotebookCommand
 
         link "Ctrl+Shift+P", PrintScopeCommand
 
-        link "Ctrl+Alt+O",           SwitchNotebookCommand
-        link "Ctrl+Shift+H",         ToggleTreesCommand
-        link "Alt+Page Up",          SwitchTreeUpCommand
-        link "Alt+Page Down",        SwitchTreeDownCommand
-        link "Ctrl+Page Up",         SwitchTabDownCommand
-        link "Ctrl+Page Down",       SwitchTabUpCommand
-        link "Ctrl+Shift+Page Up",   MoveTabDownCommand
-        link "Ctrl+Shift+Page Down", MoveTabUpCommand
-        link "Ctrl+Shift+T",         OpenTreeFinderCommand
-        link "Alt+Shift+J",          IncreaseTreebookWidthCommand
-        link "Alt+Shift+H",          DecreaseTreebookWidthCommand
-        link "Ctrl+Shift+>",         EnlargeFirstNotebookCommand
-        link "Ctrl+Shift+<",         EnlargeSecondNotebookCommand
-        link "Ctrl+Shift+L",         ResetNotebookWidthsCommand
-        link "Ctrl+Shift+:",         RotateNotebooksCommand
-        link "Alt+Shift+N",          CloseNotebookCommand
-        # link "Ctrl+Shift+R",     PluginManagerUi::ReloadLastReloadedCommand
-        link "F11",                  ToggleFullscreen
+        link "Ctrl+Alt+O",           Application::SwitchNotebookCommand
+        link "Ctrl+Shift+H",         Application::ToggleTreesCommand
+        link "Alt+Page Up",          Application::SwitchTreeUpCommand
+        link "Alt+Page Down",        Application::SwitchTreeDownCommand
+        link "Ctrl+Page Up",         Application::SwitchTabDownCommand
+        link "Ctrl+Page Down",       Application::SwitchTabUpCommand
+        link "Ctrl+Shift+Page Up",   Application::MoveTabDownCommand
+        link "Ctrl+Shift+Page Down", Application::MoveTabUpCommand
+        link "Ctrl+Shift+T",         Application::OpenTreeFinderCommand
+        link "Alt+Shift+J",          Application::IncreaseTreebookWidthCommand
+        link "Alt+Shift+H",          Application::DecreaseTreebookWidthCommand
+        link "Ctrl+Shift+>",         Application::EnlargeNotebookCommand
+        link "Ctrl+Shift+L",         Application::ResetNotebookWidthsCommand
+        link "Ctrl+Shift+:",         Application::RotateNotebooksCommand
+        link "Alt+Shift+N",          Application::CloseNotebookCommand
+        link "F11",                  Application::ToggleFullscreen
         link "Ctrl+Alt+I",           ToggleInvisibles
         link "Ctrl++",               IncreaseFontSize
         link "Ctrl+-",               DecreaseFontSize
@@ -1185,7 +734,7 @@ Redcar.environment: #{Redcar.environment}
 
         # map SelectTab<number>Command
         (1..9).each do |tab_num|
-          link "Alt+#{tab_num}", Top.const_get("SelectTab#{tab_num}Command")
+          link "Alt+#{tab_num}", Application.const_get("SelectTab#{tab_num}Command")
         end
 
       end
@@ -1195,15 +744,15 @@ Redcar.environment: #{Redcar.environment}
 
     def self.toolbars
       ToolBar::Builder.build do
-        item "New File", :command => NewCommand, :icon => :new, :barname => :core
-        item "Open File", :command => Project::FileOpenCommand, :icon => :open, :barname => :core
+        item "New File", :command => OpenNewEditTabCommand, :icon => :new, :barname => :core
+        item "Open File", :command => Project::OpenFileCommand, :icon => :open, :barname => :core
         item "Open Directory", :command => Project::DirectoryOpenCommand, :icon => :open_dir, :barname => :core
-        item "Save File", :command => Project::FileSaveCommand, :icon => :save, :barname => :core
-        item "Save File As", :command => Project::FileSaveAsCommand, :icon => :save_as, :barname => :core
+        item "Save File", :command => Project::SaveFileCommand, :icon => :save, :barname => :core
+        item "Save File As", :command => Project::SaveFileAsCommand, :icon => :save_as, :barname => :core
         item "Undo", :command => UndoCommand, :icon => :undo, :barname => :core
         item "Redo", :command => RedoCommand, :icon => :redo, :barname => :core
-        item "New Notebook", :command => NewNotebookCommand, :icon => File.join(Redcar::ICONS_DIRECTORY, "book--plus.png"), :barname => :edit
-        item "Close Notebook", :command => CloseNotebookCommand, :icon => File.join(Redcar::ICONS_DIRECTORY, "book--minus.png"), :barname => :edit
+        item "New Notebook", :command => Application::OpenNewNotebookCommand, :icon => File.join(Redcar::ICONS_DIRECTORY, "book--plus.png"), :barname => :edit
+        item "Close Notebook", :command => Application::CloseNotebookCommand, :icon => File.join(Redcar::ICONS_DIRECTORY, "book--minus.png"), :barname => :edit
       end
     end
 
@@ -1211,22 +760,22 @@ Redcar.environment: #{Redcar.environment}
       Menu::Builder.build do
         sub_menu "File", :priority => :first do
           group(:priority => :first) do
-            item "New", NewCommand
-            item "New Window", NewWindowCommand
+            item "New", OpenNewEditTabCommand
+            item "New Window", Application::OpenNewWindowCommand
           end
 
           group(:priority => 10) do
             separator
-            item "Close Tab", CloseTabCommand
-            item "Close Tree", CloseTreeCommand
-            item "Close Window", CloseWindowCommand
-            item "Close Others", CloseOthers
-            item "Close All", CloseAll
+            item "Close Tab", Application::CloseTabCommand
+            item "Close Tree", Application::CloseTreeCommand
+            item "Close Window", Application::CloseWindowCommand
+            item "Close Others", Application::CloseOthers
+            item "Close All", Application::CloseAll
           end
 
           group(:priority => :last) do
             separator
-            item "Quit", QuitCommand
+            item "Quit", Application::QuitCommand
           end
         end
         sub_menu "Edit", :priority => 5 do
@@ -1282,7 +831,7 @@ Redcar.environment: #{Redcar.environment}
           group(:priority => 10) do
             item "Task Manager", TaskManager::OpenCommand
             separator
-            #item "Print Scope Tree", PrintScopeTreeCommand
+            item "Print Scope Tree", PrintScopeTreeCommand
             item "Print Scope at Cursor", PrintScopeCommand
           end
         end
@@ -1297,49 +846,48 @@ Redcar.environment: #{Redcar.environment}
           end
           group(:priority => 10) do
             separator
-            item "Toggle Fullscreen", :command => ToggleFullscreen, :type => :check, :active => window ? window.fullscreen : false
+            item "Toggle Fullscreen", :command => Application::ToggleFullscreen, :type => :check, :active => window ? window.fullscreen : false
           end
           group(:priority => 15) do
             separator
             sub_menu "Trees" do
-              item "Open Tree Finder", OpenTreeFinderCommand
-              item "Toggle Tree Visibility", ToggleTreesCommand
-              item "Increase Tree Width", IncreaseTreebookWidthCommand
-              item "Decrease Tree Width", DecreaseTreebookWidthCommand
+              item "Open Tree Finder", Application::OpenTreeFinderCommand
+              item "Toggle Tree Visibility", Application::ToggleTreesCommand
+              item "Increase Tree Width", Application::IncreaseTreebookWidthCommand
+              item "Decrease Tree Width", Application::DecreaseTreebookWidthCommand
               separator
-              item "Previous Tree", SwitchTreeUpCommand
-              item "Next Tree", SwitchTreeDownCommand
+              item "Previous Tree", Application::SwitchTreeUpCommand
+              item "Next Tree", Application::SwitchTreeDownCommand
             end
             lazy_sub_menu "Windows" do
               GenerateWindowsMenu.new(self).run
             end
             sub_menu "Notebooks" do
-              item "New Notebook", NewNotebookCommand
-              item "Close Notebook", CloseNotebookCommand
-              item "Rotate Notebooks", RotateNotebooksCommand
-              item "Move Tab To Other Notebook", MoveTabToOtherNotebookCommand
-              item "Switch Notebooks", SwitchNotebookCommand
+              item "New Notebook", Application::OpenNewNotebookCommand
+              item "Close Notebook", Application::CloseNotebookCommand
+              item "Rotate Notebooks", Application::RotateNotebooksCommand
+              item "Move Tab To Other Notebook", Application::MoveTabToOtherNotebookCommand
+              item "Switch Notebooks", Application::SwitchNotebookCommand
               separator
-              item "Enlarge First Notebook", EnlargeFirstNotebookCommand
-              item "Enlarge Second Notebook", EnlargeSecondNotebookCommand
-              item "Reset Notebook Widths", ResetNotebookWidthsCommand
+              item "Enlarge First Notebook", Application::EnlargeNotebookCommand
+              item "Reset Notebook Widths",  Application::ResetNotebookWidthsCommand
             end
             sub_menu "Tabs" do
-              item "Previous Tab", SwitchTabDownCommand
-              item "Next Tab", SwitchTabUpCommand
-              item "Move Tab Left", MoveTabDownCommand
-              item "Move Tab Right", MoveTabUpCommand
+              item "Previous Tab",   Application::SwitchTabDownCommand
+              item "Next Tab",       Application::SwitchTabUpCommand
+              item "Move Tab Left",  Application::MoveTabDownCommand
+              item "Move Tab Right", Application::MoveTabUpCommand
               separator
               # GenerateTabsMenu.new(self).run # TODO: find a way to maintain keybindings with lazy menus
               item "Focussed Notebook", ShowTitle
               (1..9).each do |num|
-                item "Tab #{num}", Top.const_get("SelectTab#{num}Command")
+                item "Tab #{num}", Application.const_get("SelectTab#{num}Command")
               end
             end
           end
           group(:priority => :last) do
             separator
-            item "Show Toolbar", :command => ToggleToolbar, :type => :check, :active => Redcar.app.show_toolbar?
+            item "Show Toolbar", :command => Application::ToggleToolbar, :type => :check, :active => Redcar.app.show_toolbar?
             item "Show Invisibles", :command => ToggleInvisibles, :type => :check, :active => EditView.show_invisibles?
             item "Show Line Numbers", :command => ToggleLineNumbers, :type => :check, :active => EditView.show_line_numbers?
           end
@@ -1370,19 +918,19 @@ Redcar.environment: #{Redcar.environment}
       end
 
       def tab_close(tab)
-        CloseTabCommand.new(tab).run
+        Application::CloseTabCommand.new(tab).run
       end
 
       def window_close(win)
-        CloseWindowCommand.new(win).run
+        Application::CloseWindowCommand.new(win).run
       end
 
       def application_close(app)
-        QuitCommand.new.run
+        Application::QuitCommand.new.run
       end
 
       def window_focus(win)
-        FocusWindowCommand.new(win).run
+        Application::FocusWindowCommand.new(win).run
       end
     end
 
@@ -1391,36 +939,40 @@ Redcar.environment: #{Redcar.environment}
     end
 
     def self.start(args=[])
-      puts "loading plugins took #{Time.now - PROCESS_START_TIME}"
-      Redcar.update_gui do
-        Application.start
-        ApplicationSWT.start
-        Swt.splash_screen.inc(1) if Swt.splash_screen
-        EditViewSWT.start
-        Swt.splash_screen.inc(7) if Swt.splash_screen
-        s = Time.now
-        if Redcar.gui
-          Redcar.app.controller = ApplicationSWT.new(Redcar.app)
+      begin
+        Redcar.log.info("startup milestone: loading plugins took #{Time.now - Redcar.process_start_time}")
+        Redcar.update_gui do
+          Application.start
+          ApplicationSWT.start
+          EditViewSWT.start
+          Swt.splash_screen.inc(1) if Swt.splash_screen
+          s = Time.now
+          if Redcar.gui
+            Redcar.app.controller = ApplicationSWT.new(Redcar.app)
+          end
+          Redcar.app.refresh_menu!
+          Redcar.app.load_sensitivities
+          Redcar.log.info("initializing gui took #{Time.now - s}s")
+        end
+        Redcar.update_gui do
+          Swt.splash_screen.close if Swt.splash_screen
+          win = Redcar.app.make_sure_at_least_one_window_open
+          win.close if win and args.include?("--no-window")
+          Redcar.log.info("startup milestone: window open #{Time.now - Redcar.process_start_time}")
+          Redcar::Project::Manager.start(args)
+          Redcar.log.info("startup milestone: project open #{Time.now - Redcar.process_start_time}")
+        end
+        Redcar.load_useful_libraries
+        Redcar.log.info("startup milestone: complete: #{Time.now - Redcar.process_start_time}")
+        if args.include?("--compute-textmate-cache-and-quit")
+          Redcar::Textmate.all_bundles
+          exit
+        end
+      rescue => e
+        Redcar.log.error("error in startup: #{e.inspect}")
+        e.backtrace.each do |line|
+          Redcar.log.error(line)
         end
-        Redcar.app.refresh_menu!
-        Redcar.app.load_sensitivities
-        puts "initializing gui took #{Time.now - s}s"
-      end
-      Redcar.update_gui do
-        Swt.splash_screen.inc(2) if Swt.splash_screen
-        s = Time.now
-        Redcar::Project::Manager.start(args)
-        puts "project start took #{Time.now - s}s"
-        win = Redcar.app.make_sure_at_least_one_window_open
-        win.close if win and args.include?("--no-window")
-      end
-      Redcar.update_gui do
-        Swt.splash_screen.close if Swt.splash_screen
-      end
-      puts "start time: #{Time.now - $redcar_process_start_time}"
-      if args.include?("--compute-textmate-cache-and-quit")
-        Redcar::Textmate.all_bundles
-        exit
       end
     end
   end