redcar-dev 0.12.17dev

data/plugins/application/lib/application/menu/lazy_menu.rb

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

data/plugins/application/lib/application/navigation_history.rb

@@ -0,0 +1,71 @@
+module Redcar
+  # A class that holds a cursor navigation history. The maximum length
+  # defaults to 100.
+  class NavigationHistory < Array
+    def initialize
+      @max_history_size = 100
+      @current = 0
+    end
+    
+    def save(doc)
+      return if last && last[:path] == doc.path && last[:cursor_offset] == doc.cursor_offset
+      
+      # Invoking this method means new future is about to be created, so remove old one.
+      self.slice!(@current...self.size)
+      
+      ensure_size_less_than_max
+      self << {:path => doc.path, :cursor_offset => doc.cursor_offset}
+      @current += 1
+    end
+    
+    def can_backward?
+      return @current > 0
+    end
+
+    def backward
+      move_current_and_restore(-1) if can_backward?
+    end
+    
+    def can_forward?
+      return @current < self.size - 1
+    end
+
+    def forward
+      move_current_and_restore(1) if can_forward?
+    end
+    
+    private
+    
+    def ensure_size_less_than_max
+      while self.size >= @max_history_size
+        self.delete_at(0)
+        @current -= 1
+      end
+    end
+    
+    def move_current_and_restore(history_size)
+      save_current_doc
+      @current += history_size
+      restore_hisotry
+    end
+    
+    def restore_hisotry
+      Project::Manager.open_file(self[@current][:path])
+      new_doc = Redcar.app.focussed_window.focussed_notebook_tab_document
+      new_doc.cursor_offset = self[@current][:cursor_offset]
+      new_doc.ensure_cursor_visible
+    end
+    
+    def save_current_doc
+      if win = Redcar.app.focussed_window and cur_doc = win.focussed_notebook_tab_document
+        history = {:path => cur_doc.path, :cursor_offset => cur_doc.cursor_offset}
+        if @current < self.size
+          self[@current] = history
+        else
+          save(cur_doc)
+          @current = self.size - 1
+        end
+      end
+    end
+  end
+end

data/plugins/application/lib/application/notebook.rb

@@ -0,0 +1,163 @@
+module Redcar
+  class Notebook
+    include Redcar::Model
+    include Redcar::Observable
+    
+    attr_reader :window
+    
+    def initialize(window)
+      @tabs         = []
+      @focussed_tab = nil
+      @tab_handlers = Hash.new {|h,k| h[k] = [] }
+      @window       = window
+    end
+    
+    def length
+      @tabs.length
+    end
+    
+    def focussed_tab
+      @focussed_tab
+    end
+    
+    def tabs
+      @tabs.clone
+    end
+    
+    # Creates a new tab in this Notebook, of class tab_class. Returns
+    # the tab.
+    #
+    # Events: tab_added (tab)
+    def new_tab(tab_class)
+      tab = tab_class.new(self)
+      attach_tab_listeners(tab)
+      notify_listeners(:tab_added, tab) do
+        @tabs << tab
+      end
+      Redcar.app.call_on_plugins(:tab_added, tab)
+      tab
+    end
+    
+    # Moves a tab from another notebook to this notebook.
+    #
+    # @param [Redcar::Notebook]
+    # @param [Redcar::Tab]
+    def grab_tab_from(other_notebook, tab)
+      return if other_notebook == self
+      other_notebook.remove_tab!(tab)
+      @tabs << tab
+      tab.set_notebook(self)
+      notify_listeners(:tab_moved, other_notebook, self, tab)
+      attach_tab_listeners(tab)
+    end
+    
+    # Should not be called by user code. Call tab.close instead.
+    def remove_tab!(tab)
+      @tabs.delete(tab)
+      @tab_handlers[tab].each {|h| tab.remove_listener(h) }
+      @tab_handlers.delete(tab)
+      select_tab!(nil) unless @tabs.any?
+    end
+    
+    # Should not be called by user code. Call tab.focus instead.
+    def select_tab!(tab)
+      @focussed_tab = tab
+      notify_listeners(:tab_focussed, tab)
+    end
+    
+    def sort_tabs!(&block)
+      @tabs.sort!(&block)
+    end
+    
+    # Focus the next tab to the right from the currently focussed tab.
+    # Wraps.
+    def switch_up
+      focussed do |current_ix|
+        current_ix = wrap_index(current_ix + 1)
+        @tabs[current_ix].focus
+      end
+    end
+    
+    # Focus the next tab to the left from the currently focussed tab.
+    # Wraps.
+    def switch_down
+      focussed do |current_ix|
+        current_ix = wrap_index(current_ix - 1)
+        @tabs[current_ix].focus
+      end
+    end
+    
+    # Moves the currently focussed tab to the right.
+    # Wraps.
+    def move_up
+      focussed do |current_ix|
+        new_ix = wrap_index(current_ix + 1)
+        swap_tab_with(@tabs[current_ix], new_ix)
+      end
+    end
+    
+    # Moves the currently focussed tab to the left.
+    # Wraps.
+    def move_down
+      focussed do |current_ix|
+        new_ix = wrap_index(current_ix - 1)
+        swap_tab_with(@tabs[current_ix], new_ix)
+      end
+    end
+    
+    # Yields the current index of the foccussed tab, if it exists.
+    def focussed(&block)
+      current_ix = @tabs.index(@focussed_tab)
+      unless current_ix.nil?
+        yield(current_ix)
+      end
+    end
+    
+    # Swaps a tab with another one at a certain position.
+    # If no position is specified, this will default to 0.
+    #
+    # @param [Redcar::Tab] the tab to be moved
+    # @param [Integer] the position
+    def swap_tab_with(move_tab, position = 0)
+      swap_tab = @tabs[position]
+      unless move_tab == swap_tab || [move_tab, swap_tab].include?(nil)
+        move_tab.move_to_position(position)
+      end
+    end
+    
+    # Wraps an index according to the current number of tabs.
+    def wrap_index(index)
+      until (0..@tabs.size - 1).include?(index)
+        index = index > 0 ? index - @tabs.size : @tabs.size + index
+      end
+      index
+    end
+    
+    def inspect
+      "#<Redcar::Notebook #{object_id}>"
+    end
+    
+    private
+    
+    def attach_tab_listeners(tab)
+      @tab_handlers[tab] << tab.add_listener(:focus) do
+        select_tab!(tab)
+      end
+      @tab_handlers[tab] << tab.add_listener(:close) do
+        Redcar.app.call_on_plugins(:tab_closed, tab)
+        remove_tab!(tab)
+        notify_listeners(:tab_closed)
+      end
+      @tab_handlers[tab] << tab.add_listener(:changed) do
+        if tab == focussed_tab
+          notify_listeners(:focussed_tab_changed, tab)
+        end
+      end
+      @tab_handlers[tab] << tab.add_listener(:selection_changed) do
+        if tab == focussed_tab
+          notify_listeners(:focussed_tab_selection_changed, tab)
+        end
+      end
+    end
+  end
+end

data/plugins/application/lib/application/sensitive.rb

@@ -0,0 +1,57 @@
+module Redcar
+  # Sensitive abstracts the concept of an object having an enabled/disabled
+  # property that is 'sensitive' to whether a number of other things
+  # are true. The "things that can be true" are Redcar::Sensitivitys,
+  # and the disabled, enabled property is only enabled when all the 
+  # Sensitivitys are active.
+  #
+  # For instance, if :is_tuesday is the name of a 
+  # Redcar::Sensitivity that is only active when it is Tuesday, 
+  # you can make an object sensitive to whether it is Tuesday by including
+  # this module and sensitizing the instance.
+  #
+  #     class MySensitiveClass
+  #       include Redcar::Sensitive
+  #     end
+  #     
+  #     obj = MySensitiveClass.new
+  #     obj.sensitize :is_tuesday
+  #     obj.active?  # => true|false
+  module Sensitive
+    # Sensitize the object to a list of sensitivities. May be called with
+    # multiple sensitivities multiple times.
+    #
+    #      obj.sensitize :is_tuesday, :raining
+    #      obj.sensitize :month_has_y
+    #
+    # @param [Array<Symbol>] list of sensitivity_names
+    def sensitize(*sensitivity_names)
+      @sensitivity_names ||= []
+      @sensitivity_names += sensitivity_names
+      sensitivity_names.each do |sensitivity_name|
+        Sensitivity.add_listener(Sensitivity.event_name(sensitivity_name)) do
+          old_sensitivity = @current_sensitivity
+          @current_sensitivity = active?
+          if old_sensitivity != @current_sensitivity
+            active_changed(@current_sensitivity)
+          end
+        end
+      end
+    end
+    
+    # @return [Array<Symbol>] list of senstivity names
+    def sensitivity_names
+      @sensitivity_names || []
+    end
+    
+    # @return [Array<Sensitivity>] list of senstivities
+    def sensitivities
+      sensitivity_names.map {|n| Sensitivity.get(n) }.compact
+    end
+    
+    # Whether all the sensitivities of this object are active.
+    def active?
+      sensitivities.all? {|s| s.active? }
+    end
+  end
+end

data/plugins/application/lib/application/sensitivity.rb

@@ -0,0 +1,82 @@
+
+module Redcar
+  # A Sensitivity represents an application state that can be true or false.
+  # For example, whether there is text selected, whether there are any
+  # open edit tabs, whether there is a project open.
+  #
+  # The Commands use these sensitivities to determine whether they are 
+  # active or not, so that their menu items can be greyed out in the menus
+  # if they are inactive.
+  #
+  # The "whether there are any open edit tabs" sensitivity is defined like this:
+  #
+  #     Sensitivity.new(:open_edit_tab, Redcar.app, [:new_tab, :close_tab]) do
+  #       # checks whether there are any open edit tabs
+  #       Redcar.app.windows.any? {|w| w.notebook.tabs.any? {|t| t.is_a?(EditTab)}}
+  #     end
+  #
+  # This says that this sensitivity is called :open_edit_tab, that the state
+  # it represents ONLY changes when the application object issues events 
+  # :new_tab or close_tab (see Redcar::Observable for more on events).
+  #
+  # A new tab opening or a tab closing MAY change the state, but on the other
+  # hand it may not (if it is a ProjectTab), so the code in the block examines
+  # the application and returns a boolean true or false.
+  class Sensitivity
+    include Redcar::Observable
+    extend Redcar::Observable
+    
+    # All sensitivities
+    def self.all
+      @all ||= {}
+    end
+    
+    def self.get(name)
+      all[name]
+    end
+    
+    def self.event_name(sensitivity_name)
+      :"sensitivity_#{sensitivity_name.to_s}"
+    end
+    
+    def self.broadcast_sensitivity_change(sensitivity_name, active)
+      notify_listeners(event_name(sensitivity_name), active)
+    end
+    
+    attr_reader :name
+
+    def initialize(name, observed_object, first, event_names, &block)
+      Sensitivity.all[name] = self
+      @name                 = name
+      @observed_object      = observed_object
+      @event_names          = event_names
+      @boolean_finder       = block
+      @active               = first
+      connect_listeners
+      Sensitivity.broadcast_sensitivity_change(name, first)
+    end
+    
+    def active?
+      @active
+    end
+    
+    def recompute(*args)
+      before = @active
+      @active = @boolean_finder.call(*args)
+      if before != @active
+        notify_listeners(:changed)
+        Sensitivity.broadcast_sensitivity_change(@name, @active)
+      end
+    end
+    
+    private
+    
+    def connect_listeners
+      @event_names.each do |event_name|
+        @observed_object.add_listener(event_name) do |args|
+          recompute(*args)
+        end
+      end
+    end
+  end
+end

data/plugins/application/lib/application/speedbar.rb

@@ -0,0 +1,100 @@
+
+module Redcar
+  class Speedbar
+    include Redcar::Model
+
+    LabelItem   = ObservableStruct.new(:name, :text)
+    ToggleItem  = ObservableStruct.new(:name, :text, :key, :listener, :value)
+    TextBoxItem = ObservableStruct.new(:name, :listener, :value, :edit_view)
+    ButtonItem  = ObservableStruct.new(:name, :text, :key, :listener)
+    ComboItem   = ObservableStruct.new(:name, :items, :value, :editable, :listener)
+    SliderItem  = ObservableStruct.new(:name, :value, :minimum, :maximum, :increment, :enabled, :listener)
+    KeyItem     = ObservableStruct.new(:key, :listener)
+
+    def self.items
+      @items ||= []
+    end
+
+    def self.append_item(item)
+      return if items.detect {|i| i.respond_to?(:name) and i.name == item.name }
+      items << item
+    end
+
+    def self.close_image_path
+      File.join(Redcar.icons_directory, "/close.png")
+    end
+
+    def self.define_item_finder(name)
+      self.class_eval %Q{
+        def #{name}
+          __get_item(#{name.to_s.inspect})
+        end
+      }
+    end
+
+    def __get_item(name)
+      item = __items.detect do |i|
+        i.respond_to?(:name) and
+          i.name.to_s == name
+      end
+      unless item
+        raise "can't find item #{name}"
+      end
+      item
+    end
+
+    def __items
+      @__items ||= self.class.items.map {|i| i.clone }
+    end
+
+    def __get_item_by_text_or_name(name)
+      __items.detect {|i| (i.respond_to?(:text) and i.text == name) or i.name.to_s == name.to_s }
+    end
+
+    def __get_item_by_label(name)
+      label = __items.detect {|i| i.is_a?(LabelItem) and (i.text == name or i.name.to_s == name.to_s)}
+      if label
+        index_of_label = __items.index(label)
+        __items[index_of_label + 1]
+      end
+    end
+
+    def self.label(name, text)
+      append_item LabelItem.new(name, text)
+      define_item_finder(name)
+    end
+
+    def self.toggle(name, text, key, value=false, &block)
+      append_item ToggleItem.new(name, text, key, block, value)
+      define_item_finder(name)
+    end
+
+    def self.textbox(name, value="", &block)
+      append_item TextBoxItem.new(name, block, value)
+      define_item_finder(name)
+    end
+
+    def self.button(name, text, key, &block)
+      append_item ButtonItem.new(name, text, key, block)
+      define_item_finder(name)
+    end
+
+    def self.combo(name, items=[], value=nil, editable=false,&block)
+      append_item ComboItem.new(name, items, value, editable, block)
+      define_item_finder(name)
+    end
+
+    def self.slider(name, value = 50, minimum = 0, maximum = 100, increment = 1, &block)
+      append_item SliderItem.new(name, value, minimum, maximum, increment, true, block)
+      define_item_finder(name)
+    end
+
+    def self.key(key, &block)
+      append_item KeyItem.new(key, block)
+    end
+
+    def inspect
+      "#<Speedbar #{__items.inspect}"
+    end
+  end
+end