redcar-dev 0.12.17dev

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

@@ -0,0 +1,95 @@
+module Redcar
+  # 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
+    include Enumerable
+    
+    def self.max_length
+      10
+    end
+
+    attr_reader :name
+  
+    def initialize(name)
+      @name     = name
+      @contents = []
+    end
+    
+    # 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)
+      end
+      notify_listeners(:added_internal, text)
+      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
+    
+    private
+    
+    def check_for_changes
+      if controller and controller.changed?
+        if @contents.length > 0
+          controller.last_set = @contents.last.join("\n")
+        end
+        contents = controller.get_contents
+        self << contents if contents
+      end
+    end
+  end
+end
+
+

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

@@ -0,0 +1,108 @@
+module Redcar
+  # A Redcar::Command class encapsulates a block of code, along with metadata
+  # to describe in what ways it can be called, and how Redcar will treat the
+  # command instances.
+  #
+  # Define commands by subclassing the Redcar::Command class.
+  #
+  # ## Examples
+  #
+  #     class CloseTab < Redcar::Command
+  #       def self.keymaps
+  #          Redcar::Keymap.build("main", :osx) do
+  #            link "Cmd+W",  CloseTab
+  #          end            
+  #       def execute
+  #         tab.close if tab
+  #       end
+  #     end
+  #
+  # ## Avoiding Memory Leaks (Command instance Lifecycle)
+  #
+  # When a command is activated, an instance of the Command class will be created.
+  # Once the command has been run, the Command instance is put into the Command History,
+  # which stores recent commands so they are accessible to e.g. Macros.
+  #
+  # This means that the command instance will hang around indefinitely, so it is 
+  # easy to create a memory leak (it is not 'technically' a leak because the Command
+  # will be collected eventually, just probably not soon enough.)
+  #
+  # For example, this command has a memory leak:
+  #
+  #     class MyCommand < Redcar::Command
+  #       def execute
+  #         @cache = create_outrageously_large_data_structure
+  #         do_some_stuff_with_data_structure
+  #       end
+  #     end
+  #
+  # Because the History will store the MyCommand instance, the @cache object will 
+  # be around for quite a while. Best to get rid of it:
+  #
+  #     class MyCommand < Redcar::Command
+  #       def execute
+  #         @cache = create_outrageously_large_data_structure
+  #         do_some_stuff_with_data_structure
+  #         @cache = nil
+  #       end
+  #     end
+  class Command
+    attr_accessor :error
+    
+    extend Redcar::Observable
+    extend Redcar::Sensitive
+
+    def self.inherited(klass)
+      klass.send(:extend, Redcar::Sensitive)
+      klass.sensitize(*sensitivity_names)
+    end
+    
+    # Called by the Sensitive module when the active value of this changed
+    def self.active_changed(value)
+      notify_listeners(:active_changed, value)
+    end
+    
+    def self.norecord
+      @record = false
+    end
+    
+    def self.record?
+      @record == nil or @record
+    end
+    
+    def environment(env)
+      if env == nil
+        remove_instance_variable(:@env) if @env
+      else
+        @env = env
+      end
+    end
+    
+    def run(opts = {})
+      @executor = Executor.new(self, opts)
+      s = Time.now
+      result = @executor.execute
+      remove_instance_variable(:@executor)
+      Redcar.log.debug("command #{self.inspect} (#{Time.now - s})")
+      result
+    end
+    
+    def inspect
+      "#<#{self.class.name}>"
+    end
+    
+    private
+    
+    def env
+      @env || {}
+    end
+    
+    def win
+      @win || env[:win]
+    end
+    
+    def tab
+      @tab || env[:tab]
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+
+module Redcar
+  class Command
+    class Executor
+      
+      attr_reader :options, :command_instance
+      
+      def self.current_environment
+        if Redcar.app
+          win = Redcar.app.focussed_window        
+          tab = Redcar.app.focussed_notebook_tab
+          { :win => win,
+            :tab => tab }
+        end
+      end
+      
+      def initialize(command_instance, options={})
+        @command_instance = command_instance
+        @options          = options
+      end
+      
+      def execute
+        set_environment
+        begin
+          if not @options.empty?
+            result = @command_instance.execute(@options) 
+          else
+            result = @command_instance.execute
+          end
+          finish
+          clear_environment
+        rescue Object => e
+          set_error(e)
+          print_command_error(e)
+        rescue java.lang.StackOverflowError => e
+          set_error(e)
+          print_command_error(e)
+        end
+        record
+        result
+      ensure
+        clear_environment
+      end
+      
+      private
+      
+      def set_environment
+        env = Executor.current_environment || {}
+        env = env.merge(options.delete(:env) || {})
+        @command_instance.environment(env)
+      end
+      
+      def clear_environment
+        @command_instance.environment(nil)
+      end
+      
+      def set_error(e)
+        @command_instance.error = e
+      end
+      
+      def finish
+        if @command_instance.respond_to?(:_finished)
+          @command_instance._finished
+        end
+      end
+
+      def print_command_error(e)
+        puts "Error in command #{@command_instance.class}"
+        puts e.class.to_s + ": " + e.message.to_s
+        puts e.backtrace
+      end
+      
+      def record
+        if Redcar.app.andand.history
+          Redcar.app.history.record(@command_instance)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+
+module Redcar
+  class Command
+    # A class that holds a Redcar command history. The maximum length
+    # defaults to 500.
+    class History < Array
+      def initialize
+        @max       = 500
+      end
+    
+      # Clear the command history
+      def clear
+        super
+      end
+      
+      # Add a command to the command history if CommandHistory.recording is
+      # true.
+      def record(command)
+        if command.class.record?
+          self << command
+        end
+        truncate
+      end
+    
+      # Adds a command to the command history if CommandHistory.recording is
+      # true. If the last command is of the same class, it is replaced.
+      def record_and_replace(command)
+        if command.class.record?
+          if last.class == command.class
+            self[-1] = command
+          else
+            self << command
+          end
+        end
+        truncate
+      end
+    
+      # Set the maximum length of the history
+      def max=(max)
+        @max = max
+      end
+      
+      private
+      
+      def truncate #:nodoc:
+        (length - @max).times { delete_at(0) }
+      end
+    end
+  end
+end
+
+
+
+

data/plugins/application/lib/application/commands/application_commands.rb

@@ -0,0 +1,21 @@
+module Redcar
+  class Application
+    class QuitCommand < Command
+      def execute
+        Redcar.app.call_on_plugins(:quit_guard) do |guard|
+          return unless guard
+        end
+        Project::Manager.open_projects.each {|pr| pr.close }
+        Redcar.app.quit
+      end
+    end
+    
+    class ToggleToolbar < Command
+
+      def execute
+        Redcar.app.toggle_show_toolbar
+        Redcar.app.refresh_toolbar!
+      end
+    end
+  end
+end

data/plugins/application/lib/application/commands/notebook_commands.rb

@@ -0,0 +1,73 @@
+module Redcar
+  class Application
+    class OpenNewNotebookCommand < Command
+      
+      def execute
+        win.create_notebook
+      end
+    end
+    
+    class EnlargeNotebookCommand < Command
+      sensitize :multiple_notebooks
+      
+      def execute
+        if win = Redcar.app.focussed_window
+          win.enlarge_notebook(0)
+        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 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
+
+  end
+end

data/plugins/application/lib/application/commands/tab_commands.rb

@@ -0,0 +1,105 @@
+module Redcar
+  class Application
+
+    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 CloseTabCommand < TabCommand
+      def initialize(tab=nil)
+        @tab = tab
+      end
+
+      def tab
+        @tab || super
+      end
+
+      def execute
+        Redcar.app.call_on_plugins(:close_tab_guard, tab) do |guard|
+          return unless guard
+        end
+        close_tab
+        @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|
+          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
+            CloseTabCommand.new(t).run
+          end
+        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
+  end
+end
+
+
+
+
+
+
+
+
+
+
+