redcar-dev 0.12.17dev

data/plugins/application/lib/application/tab.rb

@@ -0,0 +1,92 @@
+module Redcar
+  class Tab
+    include Redcar::Model
+    include Redcar::Observable
+
+    DEFAULT_ICON  = :document
+    NO_WRITE_ICON = :exclamation_red
+    MISSING_ICON  = :exclamation
+    CONFIG_ICON   = :hammer_screwdriver
+    HELP_ICON     = :question
+    WEB_ICON      = :globe
+
+    attr_reader :notebook
+
+    def initialize(notebook)
+      @notebook = notebook
+      @title    = "unknown"
+    end
+
+    # Close the tab (remove it from the Notebook).
+    #
+    # Events: close
+    def close
+      Redcar.app.events.ignore(:tab_close, self) do
+        notify_listeners(:close)
+      end
+    end
+
+    # Focus the tab within the notebook, and gives the keyboard focus to the
+    # contents of the tab, if appropriate.
+    #
+    # Events: focus
+    def focus
+      Redcar.app.events.ignore(:tab_focus, self) do
+        notify_listeners(:focus)
+      end
+    end
+
+    def title
+      @title
+    end
+
+    def title=(title)
+      @title = title
+      notify_listeners(:changed_title, title)
+    end
+
+    def icon
+      @icon || DEFAULT_ICON
+    end
+
+    def icon=(value)
+      @icon = value
+      notify_listeners(:changed_icon, icon)
+    end
+
+    def inspect
+      "#<#{self.class.name} \"#{title}\">"
+    end
+
+    # Sets the notebook of the tab. Should not be called from user code.
+    def set_notebook(notebook)
+      @notebook = notebook
+    end
+
+    # Moves the tab to a new position in the notebook, if said position
+    # is currently occupied. Defaults to the first position, if none
+    # is passed.
+    #
+    # Events: moved (position)
+    def move_to_position(position = 0)
+      if (0..@notebook.tabs.size - 1).include?(position)
+        notify_listeners(:moved, position)
+      end
+    end
+
+    def edit_tab?
+      is_a?(EditTab)
+    end
+
+    # Helper method to get the edit_view's document, if applicable.
+    def document
+      edit_view.document if edit_tab?
+    end
+
+    # Helper method to get this tab's Mirror object for the current
+    # document, if applicable.
+    def document_mirror
+      document.mirror if document
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+module Redcar
+  class TabCommand < Command
+    sensitize :open_tab
+  end
+end

data/plugins/application/lib/application/toolbar.rb

@@ -0,0 +1,83 @@
+
+module Redcar
+  class ToolBar
+    include Enumerable
+    include Redcar::Model
+    
+    # Default priority for all toolbar's and items if they aren't explicitly provided
+    DEFAULT_PRIORITY = 50
+    
+    attr_reader :text, :entries, :priority
+  
+    # A ToolBar will initially have nothing in it.
+    def initialize(text=nil, options={})
+      @text, @entries, @priority = text || "", [], options[:priority]
+    end
+  
+    # Iterate over each entry, sorted by priority
+    def each
+      sorted = {:first => [], :last => []}
+      entries.each {|e| (sorted[e.priority || ToolBar::DEFAULT_PRIORITY] ||= []) << e}
+      
+      # Get the nasty Symbols out of the hash so we can sort it
+      first = sorted.delete(:first)
+      last = sorted.delete(:last)
+      
+      # Yield up the results
+      first.each {|val| yield val }
+      sorted.keys.sort.each {|i| sorted[i].each {|val| yield val }}
+      last.each {|val| yield val }
+    end
+  
+    # Add a Redcar::ToolItem or a Redcar::ToolBar
+    def <<(entry)
+      entries << entry
+      self
+    end
+  
+    # Number of entries in the toolbar
+    def length
+      entries.length
+    end
+    
+    def entry(text)
+      detect {|e| e.text == text }
+    end
+    
+    # Append items using the same syntax as ToolBar::Builder
+    def build(&block)
+      ToolBar::Builder.new(self, &block)
+    end
+    
+    def ==(other)
+      return false unless length == other.length
+      return false unless text == other.text
+      entries.zip(other.entries) do |here, there|
+        return false unless here.class == there.class and here == there
+      end
+      true
+    end
+    
+    def is_unique?
+      false
+    end
+    
+    # Merge two ToolBar trees together. Modifies this ToolBar.
+    #
+    # @param [ToolBar] another ToolBar
+    def merge(other)
+      @priority = @priority || other.priority
+      other.entries.each do |other_entry|
+        if here = entry(other_entry.text) and not other_entry.is_unique?
+          if here.class == other_entry.class
+            here.merge(other_entry)
+          else
+            entries[entries.index(here)] = other_entry
+          end
+        else
+          self << other_entry
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+
+module Redcar
+  class ToolBar
+    # A DSL for building toolbars simply. An example of usage
+    #
+    #     builder = ToolBar::Builder.new "Edit" do
+    #       item "Select All", SelectAllCommand
+    #       sub_toolbar "Indent" do
+    #         item "Increase", IncreaseIndentCommand
+    #         item("Decrease") { puts "decrease selected" }
+    #       end
+    #     end
+    #
+    # This is equivalent to:
+    # 
+    #     toolbar = Redcar::ToolBar.new("Edit")
+    #     toolbar << Redcar::ToolBar::Item.new("Select All", SelectAllCommand)
+    #     indent_toolbar = Redcar::ToolBar.new("Indent") 
+    #     indent_toolbar << Redcar::ToolBar::Item.new("Increase", IncreaseIndentCommand)
+    #     indent_toolbar << Redcar::ToolBar::Item.new("Decrease") do
+    #       puts "decrease selected"
+    #     end
+    #     toolbar << indent_toolbar
+    class Builder
+      attr_reader :toolbar
+      
+      def self.build(name=nil, &block)
+        new(name, &block).toolbar
+      end
+      
+      def initialize(toolbar_or_text=nil, &block)
+        case toolbar_or_text
+        when String, nil
+          @toolbar = Redcar::ToolBar.new(toolbar_or_text||"")
+        when ToolBar
+          @toolbar = toolbar_or_text
+        end
+        @current_toolbar = @toolbar
+        if block.arity == 1
+          block.call(self)
+        else
+          instance_eval(&block)
+        end
+      end
+      
+      def item(text, options={}, &block)
+        @current_toolbar << Item.new(text, options, &block)
+      end
+      
+      def separator(options={})
+        @current_toolbar << Item::Separator.new(options)
+      end
+      
+      def sub_toolbar(text, options={}, &block)
+        new_toolbar = ToolBar.new(text, options)
+        @current_toolbar << new_toolbar
+        old_toolbar, @current_toolbar = @current_toolbar, new_toolbar
+        if block.arity == 1
+          block.call(self)
+        else
+          instance_eval(&block)
+        end
+        @current_toolbar = old_toolbar
+      end
+      
+      def lazy_sub_toolbar(text, options={}, &block)
+        new_toolbar = LazyToolBar.new(block, text, options)
+        @current_toolbar << new_toolbar
+      end
+      
+      def group(options={}, &block)
+        Builder::Group.new(self, options, &block)
+      end
+      
+      def append(item)
+        @current_toolbar << item
+      end
+    end
+  end
+end

data/plugins/application/lib/application/toolbar/builder/group.rb

@@ -0,0 +1,47 @@
+
+module Redcar
+  class ToolBar
+    class Builder
+      # An extension to the Builder to allow groups of toolbar object to inherit options.
+      #
+      # This is supported for all options, even options that don't exist yet!
+      #
+      # Currently, this is only useful in a practical sense to apply a :priority to a 
+      # set of objects
+      class Group
+        
+        def initialize(builder, options={}, &block)
+          @builder = builder
+          @defaults = options
+          
+          if block.arity == 1
+            block.call(self)
+          else
+            instance_eval(&block)
+          end
+        end
+        
+        def item(text, options={}, &block)
+          options = {:command => options} if not options.respond_to?('[]')
+          @builder.item(text, @defaults.merge(options), &block)
+        end
+        
+        def separator(options={})
+          @builder.separator(@defaults.merge(options))
+        end
+        
+        def sub_toolbar(text, options={}, &block)
+          @builder.sub_toolbar(text, @defaults.merge(options), &block)
+        end
+        
+        def lazy_sub_toolbar(text, options={}, &block)
+          @builder.lazy_sub_toolbar(text, @defaults.merge(options), &block)
+        end
+
+        def append(item)
+          @builder.append(item)
+        end
+      end
+    end
+  end
+end

data/plugins/application/lib/application/toolbar/item.rb

@@ -0,0 +1,71 @@
+
+module Redcar
+  class ToolBar
+    class Item
+      class Separator < Item
+        def initialize(options={})
+          super(nil, options)
+        end
+        
+        def is_unique?
+          true
+        end
+      end
+
+      attr_reader :text, :command, :priority, :value, :icon, :barname
+ 
+      # Create a new Item, with the given text to display in the toolbar, and
+      # either:
+      #   the Redcar::Command that is run when the item is selected.
+      #   or a block to run when the item is selected
+      def initialize(text, options={}, &block)
+        @text = text
+        
+        if options.respond_to?('[]')
+          @command = options[:command] || block
+	        @priority = options[:priority] # Currently not utilized
+          @value = options[:value]
+          @icon = options[:icon]
+          @barname = options[:barname]
+        # This branch is for compatibility with old code. Please use :command 
+        # option in new code
+        # FIXME: Should this be removed at some point?
+        else
+          @command = options || block
+        end
+        
+        @priority ||= ToolBar::DEFAULT_PRIORITY
+      end
+      
+      # Call this to signal that the toolbar item has been selected by the user.
+      def selected(with_key=false)
+        if @value
+          @command.new.run(:value => @value)
+        else  
+          @command.new.run#(:with_key => with_key)
+        end
+      end
+      
+      def type
+        @type
+      end
+      
+      def type
+        @type
+      end
+      
+      def merge(other)
+        @command = other.command
+        @priority = other.priority
+      end
+      
+      def ==(other)
+        text == other.text and command == other.command
+      end
+      
+      def is_unique?
+        false
+      end
+    end
+  end
+end

data/plugins/application/lib/application/toolbar/lazy_toolbar.rb

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

data/plugins/application/lib/application/tree.rb

@@ -0,0 +1,94 @@
+
+module Redcar
+  # Pass classes implementing Redcar::Tree::Mirror and 
+  # Redcar::Tree::Controller to Tree#new to create a tree. Pass to
+  # window.treebook.add_tree to open the Tree in a Window.
+  #
+  # Trees build up their contents by querying the Tree::Mirror. For
+  # instance, a simple tree containing the numbers 1 to 10 could be created
+  # like this:
+  #
+  #   class CountMirror 
+  #     include Redcar::Tree::Mirror
+  #
+  #     def top
+  #       (1..10).map {|i| CountNode.new(i)}
+  #     end
+  #
+  #     class CountNode
+  #       include Redcar::Tree::NodeMirror
+  #
+  #       def initialize(i)
+  #         @i = i
+  #       end
+  #      
+  #       def text
+  #         @i.to_s
+  #       end
+  #     end
+  #   end
+  #
+  #   tree = Tree.new(CountMirror.new)
+  #   Redcar.app.focussed_window.treebook.add_tree(tree)
+  class Tree
+    include Redcar::Model
+    include Redcar::Observable
+    include Redcar::HasSPI
+    
+    attr_reader :tree_mirror, :tree_controller
+    
+    # @param [Tree::Mirror] an instance of a class including Tree::Mirror
+    # @param [Tree::Controller] an instance of a class including Tree::Controller
+    def initialize(tree_mirror, tree_controller=nil)
+      assert_interface(tree_mirror,     Redcar::Tree::Mirror)
+      if tree_controller
+        assert_interface(tree_controller, Redcar::Tree::Controller)
+      end
+      @tree_mirror     = tree_mirror
+      @tree_controller = tree_controller
+    end
+    
+    # Refresh the tree by requerying the mirror from the top and
+    # recursing down through open items.
+    def refresh
+      notify_listeners(:refresh)
+    end
+    
+    # Begin an edit operation on the node. This allows the user
+    # to edit the text. When the user has finished, TreeController#edited
+    # will be called with the new text.
+    def edit(node, select_from=nil, select_to=nil)
+      notify_listeners(:edit_element, node, select_from, select_to)
+    end
+    
+    # Expand the node.
+    def expand(node)
+      notify_listeners(:expand_element, node)
+    end
+    
+    # Select the node.
+    def select(node)
+      notify_listeners(:select_element, node)
+    end
+    
+    def focus
+      notify_listeners(:focus)
+    end
+    
+    # @return [Array<NodeMirror>] the selected nodes
+    def selection
+      controller.selection
+    end
+    
+    # @return [Array<NodeMirror>] the visible nodes
+    def visible_nodes
+      controller.visible_nodes
+    end
+    
+    # Close the tree (removes it from the Window's Treebook)
+    def close
+      Redcar.app.windows.detect {|win| win.treebook.trees.include?(self) }.treebook.remove_tree(self)
+    end
+  end
+end
+