redcar 0.3.2dev → 0.3.3

data/plugins/project/lib/project/drb_service.rb

@@ -0,0 +1,75 @@
+module Redcar
+  class Project
+    class DrbService
+      def initialize
+        # TODO choose a random port instead of hard coded
+        begin
+          address = "druby://127.0.0.1:9999"
+          @drb = DRb.start_service(address, self)
+        rescue Errno::EADDRINUSE => e
+          puts 'warning--not starting listener (perhaps theres another Redcar already open?)' + e + ' ' + address
+        end
+      end
+    
+      # opens an item as if from the command line for use via drb
+      def open_item_drb(full_path)
+        begin
+          puts 'drb opening ' + full_path if $VERBOSE
+          if File.file? full_path
+            
+            Redcar::ApplicationSWT.sync_exec {            
+              if Redcar.app.windows.length == 0              
+                Project.restore_last_session
+              end
+              
+              FileOpenCommand.new(full_path).execute
+              Redcar.app.focussed_window.controller.bring_to_front          
+            }
+            'ok'
+          elsif File.directory? full_path
+            Redcar::ApplicationSWT.sync_exec {
+            
+              # open in any existing window that already has that dir open as a tree
+              # else in a new window
+              # open the window that already has this dir open
+              if Redcar.app.windows.length == 0 && Application.storage['last_open_dir'] == full_path
+                Project.restore_last_session
+              end
+              
+              if Redcar.app.windows.length > 0
+                window = Redcar.app.windows.find{|win| 
+                  # XXXX how can win be nil here?
+                  win && win.treebook.trees.find{|t| 
+                    t.tree_mirror.is_a?(Redcar::Project::DirMirror) && t.tree_mirror.path == full_path
+                  }
+                }            
+              end
+              window ||= Redcar.app.new_window          
+              Project.open_dir(full_path, window)
+              Redcar.app.focussed_window.controller.bring_to_front
+              
+            }
+            'ok'
+          elsif full_path == 'just_bring_to_front'          
+            Redcar::ApplicationSWT.sync_exec {
+              if Redcar.app.windows.length == 0
+                Project.restore_last_session
+              end
+              Redcar.app.focussed_window.controller.bring_to_front
+            }
+            'ok'
+          else
+            puts 'remote load: unexpected: file not found ' + full_path
+            'fail'
+          end
+        rescue Exception => e
+          # normally drb would swallow these
+          puts 'drb got exception:' + e, e.backtrace
+          raise e
+        end 
+      end
+      
+    end
+  end
+end
+    

data/plugins/project/lib/project/file_mirror.rb

@@ -23,7 +23,7 @@ module Redcar
       def read
         return "" unless exists?
         contents = load_contents
-        @hash = Digest::SHA1.hexdigest(contents)
+        @timestamp = File.stat(@path).mtime
         contents
       end
       
@@ -39,7 +39,7 @@ module Redcar
       #
       # @return [Boolean]
       def changed?
-        @hash != Digest::SHA1.hexdigest(load_contents)
+        !@timestamp or @timestamp < File.stat(@path).mtime
       end
       
       # Save new file contents.
@@ -48,7 +48,7 @@ module Redcar
       # @return [unspecified]
       def commit(contents)
         save_contents(contents)
-        @hash = Digest::SHA1.hexdigest(contents)
+        @time = Time.now
       end
       
       # The filename.
@@ -61,11 +61,11 @@ module Redcar
       private
       
       def load_contents
-        File.read(@path)
+        File.open(@path, 'rb') do |f|; f.read; end
       end
       
       def save_contents(contents)
-        File.open(@path, "w") {|f| f.print contents }
+        File.open(@path, "wb") {|f| f.print contents }
       end
     end
   end

data/plugins/project/lib/project/find_file_dialog.rb

@@ -4,17 +4,71 @@ module Redcar
     class FindFileDialog < FilterListDialog
       MAX_ENTRIES = 20
       
+      def self.clear
+        # unfortunately we receive a :focussed
+        # message when the FindFileDialog
+        # itself exits
+        # so we only really clear when we receive an *unexpected* message
+        if @expect_a_clear
+           @expect_a_clear = false
+        else
+          if storage['clear_cache_on_refocus']
+            @cached_dir_lists.clear 
+          end
+        end
+    
+      end
+      
+      @cached_dir_lists = {}
+      @expect_a_clear = false
+      
+      class << self
+       attr_reader :cached_dir_lists
+       attr_accessor :expect_a_clear
+      end
+      
+      def initialize win
+        super()        
+        # add a :focussed listener to the window if it hasn't
+        # been set before
+        win.add_listener_at_most_once(FindFileDialog, :focussed) {
+          FindFileDialog.clear
+        }
+        FindFileDialog.expect_a_clear = true
+      end
+      
+      def self.storage
+        @storage ||= begin
+          storage = Plugin::Storage.new('find_file_dialog')
+          storage.set_default('clear_cache_on_refocus', true)
+          storage
+        end
+      end    
+      
       def update_list(filter)
         if filter.length < 2
-          []
+          paths = Project.recent_files
         else
-          paths = find_files(filter, Redcar.app.focussed_window.treebook.trees.last.tree_mirror.path)
-          @last_list = paths
-          paths.map {|path| display_path(path) }
+          paths = find_files_from_list(filter, Project.recent_files) + find_files(filter, Redcar.app.focussed_window.treebook.trees.last.tree_mirror.path)             
+          paths.uniq! # in case there's some dupe's between the two lists
+        end
+                
+        @last_list = paths        
+        full_paths = paths
+        display_paths = full_paths.map { |path| display_path(path) }
+        if display_paths.uniq.length < full_paths.length
+         # search out and expand duplicates
+          duplicates = display_paths.duplicates_as_hash
+          display_paths.each_with_index{|dp, i|
+            if duplicates[dp]
+              display_paths[i] = display_path(full_paths[i], Redcar.app.focussed_window.treebook.trees.last.tree_mirror.path.split('/')[0..-2].join('/'))
+            end
+          }
         end
+        display_paths
       end
       
-      def selected(text, ix)
+      def selected(text, ix, closing=false)
         if @last_list
           close
           FileOpenCommand.new(@last_list[ix]).run
@@ -23,54 +77,85 @@ module Redcar
       
       private
       
-      def display_path(path)
-        path.split("/").last + 
-          " (" + 
-          path.split("/")[-3..-2].join("/") + 
-          ")"
+      def remove_from_list(path)
+        self.class.recent_files.delete(path)
+      end
+      
+      def display_path(path, first_remove_this_prefix = nil)
+        n = -3
+        if first_remove_this_prefix && path.index(first_remove_this_prefix) == 0
+          path = path[first_remove_this_prefix.length..-1]
+          # show the full subdirs in the case of collisions
+          n = -100
+        end
+        
+        if path.count('/') > 0
+            count_back = [-path.count('/'), n].max
+            path.split("/").last +
+            " (" +
+              path.split("/")[count_back..-2].join("/") +
+            ")"
+        else
+           path
+        end
+          
       end
       
       def files(directories)
-        @files ||= begin
+        FindFileDialog.cached_dir_lists[directories] ||= begin
           files = []
           s = Time.now
           directories.each do |dir|
             files += Dir[File.expand_path(dir + "/**/*")]
           end
           took = Time.now - s
-          puts "find files #{directories.inspect} took #{took}s"
+          puts "find files (#{directories.length} dirs) took #{took}s"
+          files.reject!{|f|
+            begin
+              File.directory?(f)
+            rescue Errno::ENOENT
+              # File.directory? can throw no such file or directory even if File.exist?
+              # has returned true. For example this happens on some awful textmate filenames
+              # unicode in them.
+              true
+            end
+          }
           files
         end
       end
       
+      def find_files_from_list(text, file_list)
+        re = make_regex(text)
+        file_list.select{|fn| 
+          fn.split('/').last =~ re
+        }.compact
+      end
+      
       def find_files(text, directories)
         re = make_regex(text)
 
         score_match_pairs = []
         cutoff = 10000000
-
         results = files(directories).each do |fn|
           begin
-            unless File.directory?(fn)
-              bit = fn.split("/")
-              if m = bit.last.match(re)
-                cs = []
-                diffs = 0
-                m.captures.each_with_index do |_, i|
-                  cs << m.begin(i + 1)
-                  if i > 0
-                    diffs += cs[i] - cs[i-1]
-                  end
+            bit = fn.split("/")
+            if m = bit.last.match(re)
+              cs = []
+              diffs = 0
+              m.captures.each_with_index do |_, i|
+                cs << m.begin(i + 1)
+                if i > 0
+                  diffs += cs[i] - cs[i-1]
                 end
-                # lower score is better
-                score = (cs[0] + diffs)*100 + bit.last.length
-                if score < cutoff
-                  score_match_pairs << [score, fn]
-                  score_match_pairs.sort!
-                  if score_match_pairs.length == MAX_ENTRIES
-                    cutoff = score_match_pairs.last.first
-                    score_match_pairs.pop
-                  end
+              end
+              # lower score is better
+              score = (cs[0] + diffs)*100 + bit.last.length
+              if score < cutoff
+                score_match_pairs << [score, fn]
+                score_match_pairs.sort!
+                if score_match_pairs.length == MAX_ENTRIES
+                  cutoff = score_match_pairs.last.first
+                  score_match_pairs.pop
                 end
               end
             end
@@ -90,3 +175,9 @@ module Redcar
     end
   end
 end
+
+module Enumerable
+  def duplicates_as_hash
+    inject({}) {|h,v| h[v]=h[v].to_i+1; h}.reject{|k,v| v==1}
+  end
+end

data/plugins/project/spec/project/file_mirror_spec.rb

@@ -3,7 +3,7 @@ require File.join(File.dirname(__FILE__), "..", "spec_helper")
 class Redcar::Project
   describe FileMirror do
     def write_testfile_contents(val)
-      File.open(@filename, "w") {|f| f.print val}
+      File.open(@filename, "wb") {|f| f.print val}
     end
     
     before do
@@ -34,6 +34,14 @@ class Redcar::Project
         @mirror.read.should == "hiver"
       end
       
+      it "preserves line endings" do
+        write_testfile_contents("a\nb")
+        
+        @mirror.read.should == "a\nb"
+        write_testfile_contents("a\r\nb")
+        @mirror.read.should == "a\r\nb"
+      end
+      
       describe "that you have read" do
         before do
           @mirror.read
@@ -55,6 +63,7 @@ class Redcar::Project
         
         describe "and has since changed on disk" do
           before do
+            sleep 2
             write_testfile_contents("the queen")
           end
           

data/plugins/project/spec/spec_helper.rb

@@ -1,5 +1,4 @@
 $:.push File.join(File.dirname(__FILE__), '..', '..', '..', 'lib')
 
 require 'redcar'
-Redcar.boot
 Redcar.load

data/plugins/redcar/plugin.rb

@@ -4,7 +4,7 @@ Plugin.define do
   version "1.0"
   file    "redcar"
   object  "Redcar::Top"
-  dependencies "core",              ">0",
+  dependencies "core",              ">0", # includes Storage
                "application",       ">0",
                "project",           ">0",
                "Auto Completer",    ">0",

data/plugins/redcar/redcar.rb

@@ -1,10 +1,6 @@
-
 module Redcar
   module Top
     class NewCommand < Command
-      key :osx     => "Cmd+N",
-          :linux   => "Ctrl+N",
-          :windows => "Ctrl+N"
       
       def execute
         tab = win.new_tab(Redcar::EditTab)
@@ -17,10 +13,6 @@ module Redcar
     class NewNotebookCommand < Command
       sensitize :single_notebook
       
-      key :osx     => "Cmd+Alt+N",
-          :linux   => "Ctrl+Alt+N",
-          :windows => "Ctrl+Alt+N"
-
       def execute
         unless win.notebooks.length > 1
           win.create_notebook
@@ -70,9 +62,6 @@ module Redcar
     
     class SwitchNotebookCommand < Command
       sensitize :multiple_notebooks, :other_notebook_has_tab
-      key :osx     => "Cmd+Alt+O",  
-          :linux   => "Ctrl+Alt+O",
-          :windows => "Ctrl+Alt+O"
           
       def execute
         new_notebook = win.nonfocussed_notebook
@@ -85,10 +74,6 @@ module Redcar
     class MoveTabToOtherNotebookCommand < Command
       sensitize :multiple_notebooks, :open_tab
           
-      key :osx     => "Cmd+Shift+Alt+O",  
-          :linux   => "Ctrl+Shift+Alt+O",
-          :windows => "Ctrl+Shift+Alt+O"
-
       def execute
         current_notebook = tab.notebook
         target_notebook = win.notebooks.detect {|nb| nb != current_notebook}
@@ -96,9 +81,29 @@ module Redcar
         tab.focus
       end
     end
+    
+    class AboutCommand < Command
+      def execute
+          new_tab = Top::NewCommand.new.run          
+          new_tab.document.text = "About: Redcar\nVersion: #{Redcar::VERSION}\n" +
+            "Ruby Version: #{RUBY_VERSION}\n" + 
+            "Jruby version: #{JRUBY_VERSION}\n" + 
+            "Redcar.environment: #{Redcar.environment}\n" + 
+            "http://redcareditor.com"
+          new_tab.title= 'About'
+      end
+    end
+
+    class ChangelogCommand < Command
+      def execute
+          new_tab = Top::NewCommand.new.run          
+          new_tab.document.text = File.read(File.join(File.dirname(__FILE__), "..", "..", "CHANGES"))
+          new_tab.title = 'Changes'
+      end
+    end
+
 
     class PrintContents < EditTabCommand
-      key "Cmd+P"
       
       def execute
         puts "printing contents"
@@ -108,27 +113,27 @@ module Redcar
     
     class PrintHistoryCommand < Command
       def execute
-        Redcar.history.each do |c|
+        Redcar.app.history.each do |c|
           puts c
         end
       end
     end
     
+    
     class PrintScopeTreeCommand < Command
       def execute
         puts tab.edit_view.controller.mate_text.parser.root.pretty(0)
       end
     end
 
-    class CloseTabCommand < TabCommand
-      key :osx     => "Cmd+W",
-          :linux   => "Ctrl+W",
-          :windows => "Ctrl+W"
+    class CloseTabCommand < Command
       
       def execute
-        # TODO: should be win.focussed_notebook
-        if tab = win.focussed_notebook.focussed_tab
+        if tab = win.focussed_notebook_tab
           tab.close
+        else
+         # interpret Ctrl+W with no tabs open as "close window", not just close tab
+         win.close
         end
       end
     end
@@ -140,9 +145,6 @@ module Redcar
     end
     
     class SwitchTabDownCommand < Command
-      key :osx     => "Cmd+Shift+[",
-          :linux   => "Ctrl+Shift+[",
-          :windows => "Ctrl+Shift+["
        
       def execute
         win.focussed_notebook.switch_down
@@ -150,9 +152,6 @@ module Redcar
     end
     
     class SwitchTabUpCommand < Command
-      key :osx     => "Cmd+Shift+]",
-          :linux   => "Ctrl+Shift+]",
-          :windows => "Ctrl+Shift+]"
        
       def execute
         win.focussed_notebook.switch_up
@@ -162,10 +161,6 @@ module Redcar
     class UndoCommand < EditTabCommand
       sensitize :undoable
       
-      key :osx     => "Cmd+Z",
-          :linux   => "Ctrl+Z",
-          :windows => "Ctrl+Z"
-      
       def execute
         tab.edit_view.undo
       end
@@ -174,17 +169,12 @@ module Redcar
     class RedoCommand < EditTabCommand
       sensitize :redoable
       
-      key :osx     => "Cmd+Shift+Z",
-          :linux   => "Ctrl+Shift+Z",
-          :windows => "Ctrl+Shift+Z"
-      
       def execute
         tab.edit_view.redo
       end
     end
     
     class MoveHomeCommand < EditTabCommand
-      key "Ctrl+A"
       
       def execute
         doc = tab.edit_view.document
@@ -194,7 +184,6 @@ module Redcar
     end
     
     class MoveEndCommand < EditTabCommand
-      key "Ctrl+E"
       
       def execute
         doc = tab.edit_view.document
@@ -225,7 +214,7 @@ module Redcar
           else
             end_selection = doc.offset_at_line(last_line_ix + 1)
           end
-          doc.set_selection_range(start_selection..end_selection)
+          doc.set_selection_range(start_selection, end_selection)
         else
           indent_line(doc, doc.cursor_line)
         end
@@ -233,9 +222,6 @@ module Redcar
     end
     
     class DecreaseIndentCommand < ChangeIndentCommand
-      key :osx     => "Cmd+[",
-          :linux   => "Ctrl+[",
-          :windows => "Ctrl+["
       
       def indent_line(doc, line_ix)
         use_spaces = true
@@ -253,9 +239,6 @@ module Redcar
     end
 
     class IncreaseIndentCommand < ChangeIndentCommand
-      key :osx     => "Cmd+]",
-          :linux   => "Ctrl+]",
-          :windows => "Ctrl+]"
       
       def indent_line(doc, line_ix)
         line            = doc.get_line(line_ix)
@@ -267,42 +250,32 @@ module Redcar
     class StripWhitespaceCommand < Redcar::EditTabCommand
     
       def execute
-        doc.text = doc.to_s.gsub(/\s+$/, "")
+        doc.text = doc.to_s.gsub(/\s+$/, "\n")
       end
     end
     
     class SelectAllCommand < Redcar::EditTabCommand
-      key :osx     => "Cmd+A",
-          :linux   => "Ctrl+Shift+A",
-          :windows => "Ctrl+Shift+A"
     
       def execute
-        doc.set_selection_range(0..(doc.length))
+        doc.set_selection_range(doc.length, 0)
       end
     end
     
     class SelectLineCommand < Redcar::EditTabCommand
-      key :osx     => "Cmd+Shift+L",
-          :linux   => "Ctrl+Shift+L",
-          :windows => "Ctrl+Shift+L"
     
       def execute
         doc.set_selection_range(
-          doc.cursor_line_start_offset..doc.cursor_line_end_offset)
+          doc.cursor_line_start_offset, doc.cursor_line_end_offset)
       end
     end
     
-    class CutCommand < Redcar::EditTabCommand
-      key :osx     => "Cmd+X",
-          :linux   => "Ctrl+X",
-          :windows => "Ctrl+X"
+    class CutCommand < Redcar::DocumentCommand
     
       def execute
         if doc.selection?
           text = doc.selection_ranges.map do |range|
             doc.get_range(range.begin, range.count)
           end
-          p text
           Redcar.app.clipboard << text
           diff = 0
           doc.selection_ranges.each do |range|
@@ -317,10 +290,7 @@ module Redcar
       end
     end
     
-    class CopyCommand < Redcar::EditTabCommand
-      key :osx     => "Cmd+C",
-          :linux   => "Ctrl+C",
-          :windows => "Ctrl+C"
+    class CopyCommand < Redcar::DocumentCommand
     
       def execute
         if doc.selection?
@@ -334,13 +304,9 @@ module Redcar
       end
     end
     
-    class PasteCommand < Redcar::EditTabCommand
+    class PasteCommand < Redcar::DocumentCommand
       sensitize :clipboard_not_empty
       
-      key :osx     => "Cmd+V",
-          :linux   => "Ctrl+V",
-          :windows => "Ctrl+V"
-    
       def execute
         start_offset = doc.selection_ranges.first.begin
         start_line   = doc.line_at_offset(start_offset)
@@ -358,11 +324,11 @@ module Redcar
           if line_ix == doc.line_count
             doc.insert(doc.length, "\n" + " "*line_offset)
           else
-            line = doc.get_line(line_ix)
-            if line.length - 1 < line_offset
+            line = doc.get_line(line_ix).chomp
+            if line.length < line_offset
               doc.insert(
                 doc.offset_at_inner_end_of_line(line_ix),
-                " "*(line_offset - line.length + 1)
+                " "*(line_offset - line.length)
               )
             end
           end
@@ -383,7 +349,7 @@ module Redcar
       	  item("Bar") { p :bar }
       	  separator
       	  sub_menu "Baz" do
-      	    item("Qux") { p :qx}
+      	    item("Qux") { p :qx }
       	    item("Quux") { p :quux }
       	    item("Corge") { p :corge }
       	  end
@@ -393,21 +359,27 @@ module Redcar
     end
     
     class GotoLineCommand < Redcar::EditTabCommand
-      key :osx     => "Cmd+L",
-          :linux   => "Ctrl+L",
-          :windows => "Ctrl+L"
       
       class Speedbar < Redcar::Speedbar
-        label "Goto line:"
+        label :goto_label, "Goto line:"
+        
         textbox :line
-        button :go, "Return" do
-          new_line_ix = @speedbar.line.to_i - 1
+        
+        button :go, "Go", "Return" do
+          new_line_ix = line.value.to_i - 1
           if new_line_ix < doc.line_count and new_line_ix >= 0
             doc.cursor_offset = doc.offset_at_line(new_line_ix)
             doc.scroll_to_line(new_line_ix)
             win.close_speedbar
           end
         end
+        
+        def initialize(command)
+          @command = command
+        end
+        
+        def doc; @command.doc; end
+        def win; @command.send(:win); end
       end
       
       def execute
@@ -417,22 +389,54 @@ module Redcar
     end
     
     class SearchForwardCommand < Redcar::EditTabCommand
-      key :osx => "Cmd+F", :linux => "Ctrl+F", :windows => "Ctrl+F"
       
       class Speedbar < Redcar::Speedbar
-        label "Regex"
-        textbox :query
-        button :search, "Return" do
-          FindNextRegex.new(Regexp.new(@speedbar.query), false).run
+        class << self
+          attr_accessor :previous_query
+        end
+        
+        def after_draw
+          self.query.value = Speedbar.previous_query || ""
+          self.query.edit_view.document.select_all
+        end
+      
+        label :label, "Search:"
+        textbox :query        
+        
+        toggle :is_regex, 'Regex', nil, true do
+          # it sets is_regex to either true or false
+        end
+        
+        toggle :match_case, 'Match case', nil, true do
+          
+        end      
+        
+        button :search, "Search", "Return" do
+          current_query = query.value
+          SearchForwardCommand::Speedbar.previous_query = current_query
+          if !is_regex.value
+            current_query = Regexp.escape(current_query)
+          end
+          success = FindNextRegex.new(Regexp.new(current_query, !match_case.value), true).run
         end
       end
       
       def execute
-        @speedbar = SearchForwardCommand::Speedbar.new(self)
+        @speedbar = SearchForwardCommand::Speedbar.new
         win.open_speedbar(@speedbar)
       end
+
     end
     
+    class RepeatPreviousSearchForwardCommand < Redcar::EditTabCommand
+      
+      def execute
+        FindNextRegex.new(Regexp.new(SearchForwardCommand::Speedbar.previous_query), true).run   
+      end
+      
+    end
+        
+    
     class FindNextRegex < Redcar::EditTabCommand
       def initialize(re, wrap=nil)
         @re = re
@@ -452,41 +456,125 @@ module Redcar
           line_start = doc.offset_at_line(doc.cursor_line)
           startoff = line_start + $`.length + cursor_line_offset
           endoff   = startoff + $&.length
-          doc.set_selection_range(startoff..endoff)
-        else
+          doc.set_selection_range(endoff, startoff)
+        elsif doc.cursor_line < doc.line_count - 1
           # next search the rest of the lines
-          line_num = doc.cursor_line + 1
-          curr_line = doc.get_line(line_num)
-          until line_num == doc.line_count - 1 or 
-                found = (curr_line.to_s =~ @re)
-            line_num += 1
-            curr_line = doc.get_line(line_num)
+          found_line_offset = nil
+          found_line_num = nil
+          found_length = nil
+          line_nums = ((doc.cursor_line() + 1)..(doc.line_count() - 1)).to_a # the rest of the document
+          if @wrap
+            line_nums += (0..doc.cursor_line()).to_a
           end
-          if found
-            line_start = doc.offset_at_line(line_num)
-            startoff = line_start + $`.length
-            endoff   = startoff + $&.length
-            doc.set_selection_range(startoff..endoff)
-            doc.scroll_to_line(line_num)
+          for line_num in line_nums do
+            curr_line = doc.get_line(line_num)
+            if new_offset = (curr_line.to_s =~ @re)
+              found_line_offset = new_offset
+              found_line_num = line_num
+              found_length = $&.length
+              break
+            end
           end
-          if !doc.get_line(line_num) and @wrap
-            doc.cursor_offset = 0
-            execute
+          if found_line_num
+            line_start = doc.offset_at_line(found_line_num)
+            startoff = line_start + found_line_offset
+            endoff   = startoff + found_length
+            doc.scroll_to_line(found_line_num)
+            doc.set_selection_range(endoff, startoff)
+            true
+          else
+           false
           end
         end
       end
     end
     
     class ToggleBlockSelectionCommand < Redcar::EditTabCommand
-      key :osx     => "Cmd+B",
-          :windows => "Ctrl+B",
-          :linux   => "Ctrl+B"
       
       def execute
         doc.block_selection_mode = !doc.block_selection_mode?
       end
     end
     
+    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+Shift+O", Project::DirectoryOpenCommand
+        link "Cmd+S",       Project::FileSaveCommand
+        link "Cmd+Shift+S", Project::FileSaveAsCommand
+        link "Cmd+W",       CloseTabCommand
+        link "Cmd+Shift+W", CloseWindowCommand
+
+        link "Cmd+Shift+E", EditView::InfoSpeedbarCommand
+        link "Cmd+Z",       UndoCommand
+        link "Cmd+Shift+Z", RedoCommand
+        link "Cmd+X",       CutCommand
+        link "Cmd+C",       CopyCommand
+        link "Cmd+V",       PasteCommand
+        link "Ctrl+A",      MoveHomeCommand
+        link "Ctrl+E",      MoveEndCommand
+        link "Cmd+[",       DecreaseIndentCommand
+        link "Cmd+]",       IncreaseIndentCommand
+        link "Cmd+L",       GotoLineCommand
+        link "Cmd+F",       SearchForwardCommand
+        link "Cmd+G",       RepeatPreviousSearchForwardCommand
+        link "Cmd+A",       SelectAllCommand
+        link "Cmd+B",       ToggleBlockSelectionCommand
+        link "Ctrl+Escape", AutoCompleter::AutoCompleteCommand
+        link "Cmd+Escape",  AutoCompleter::MenuAutoCompleterCommand
+        
+        link "Cmd+T",           Project::FindFileCommand
+        link "Cmd+Shift+Alt+O", MoveTabToOtherNotebookCommand
+        link "Cmd+Alt+O",       SwitchNotebookCommand
+        link "Cmd+Shift+[",     SwitchTabDownCommand
+        link "Cmd+Shift+]",     SwitchTabUpCommand
+
+        link "Cmd+Shift+R",     PluginManagerUi::ReloadLastReloadedCommand
+      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+Shift+O", Project::DirectoryOpenCommand
+        link "Ctrl+S",       Project::FileSaveCommand
+        link "Ctrl+Shift+S", Project::FileSaveAsCommand
+        link "Ctrl+W",       CloseTabCommand
+        link "Ctrl+Shift+W", CloseWindowCommand
+        
+        link "Ctrl+Shift+E", EditView::InfoSpeedbarCommand
+        link "Ctrl+Z",       UndoCommand
+        link "Ctrl+Shift+Z", RedoCommand
+        link "Ctrl+X",       CutCommand
+        link "Ctrl+C",       CopyCommand
+        link "Ctrl+V",       PasteCommand
+        link "Ctrl+A",       MoveHomeCommand
+        link "Ctrl+E",       MoveEndCommand
+        link "Ctrl+[",       DecreaseIndentCommand
+        link "Ctrl+]",       IncreaseIndentCommand
+        link "Ctrl+L",       GotoLineCommand
+        link "Ctrl+F",       SearchForwardCommand
+        link "Ctrl+G",       RepeatPreviousSearchForwardCommand
+        link "Ctrl+A",       SelectAllCommand
+        link "Ctrl+B",       ToggleBlockSelectionCommand
+        link "Ctrl+Escape",  AutoCompleter::AutoCompleteCommand
+        link "Escape",       AutoCompleter::MenuAutoCompleterCommand
+        
+        link "Ctrl+T",           Project::FindFileCommand
+        link "Ctrl+Shift+Alt+O", MoveTabToOtherNotebookCommand
+        link "Ctrl+Alt+O",       SwitchNotebookCommand
+        link "Ctrl+Shift+Page Up",       SwitchTabDownCommand
+        link "Ctrl+Shift+Page Down",     SwitchTabUpCommand
+
+        link "Ctrl+Shift+R",     PluginManagerUi::ReloadLastReloadedCommand
+      end
+      [linwin, osx]
+    end
+    
     def self.menus
       Menu::Builder.build do
         sub_menu "File" do
@@ -505,6 +593,8 @@ module Redcar
           item "Close Directory", Project::DirectoryCloseCommand
         end
         sub_menu "Edit" do
+          item "Tab Info",  EditView::InfoSpeedbarCommand
+          separator
           item "Undo", UndoCommand
           item "Redo", RedoCommand
           separator
@@ -522,13 +612,15 @@ module Redcar
           separator
           item "Goto Line", GotoLineCommand
           item "Regex Search",    SearchForwardCommand
+          item "Repeat Last Search", RepeatPreviousSearchForwardCommand
           separator
           sub_menu "Select" do
             item "All", SelectAllCommand
             item "Line", SelectLineCommand
           end
           item "Toggle Block Selection", ToggleBlockSelectionCommand
-          item "Auto Complete", AutoCompleter::AutoCompleteCommand
+          item "Auto Complete",          AutoCompleter::AutoCompleteCommand
+          item "Menu Auto Complete",     AutoCompleter::MenuAutoCompleterCommand
         end
         sub_menu "Project" do
           item "Find File", Project::FindFileCommand
@@ -552,10 +644,12 @@ module Redcar
         sub_menu "Plugins" do
           item "Plugin Manager", PluginManagerUi::OpenCommand
           item "Reload Again", PluginManagerUi::ReloadLastReloadedCommand
+          item("Edit Preferences") { Project.open_dir(Redcar::Plugin::Storage.storage_dir, Redcar.app.new_window) }
           separator
         end
         sub_menu "Help" do
-          item "Website", PrintHistoryCommand
+          item "About", AboutCommand
+          item "New In This Version", ChangelogCommand
         end
       end
     end
@@ -569,9 +663,10 @@ module Redcar
       Redcar.gui = ApplicationSWT.gui
       Redcar.app.controller = ApplicationSWT.new(Redcar.app)
       
-      Redcar.app.load_menus
+      Redcar.app.refresh_menu!
       Redcar.app.load_sensitivities
-      Redcar.app.new_window
+      Redcar::Project.start
+      Redcar.app.make_sure_at_least_one_window_open
     end
   end
 end