redcar-dev 0.12.17dev

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

@@ -0,0 +1,5 @@
+module Redcar
+  class TreeCommand < Redcar::Command
+    sensitize :open_trees
+  end
+end

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

@@ -0,0 +1,64 @@
+
+module Redcar
+  class Tree
+    # SPI specification. Implement a class including this module
+    # and pass an instance to Tree#new to respond to tree events.
+    module Controller
+      
+      # Called when a node in a tree is activated (e.g double clicked). 
+      # ONLY called when that node is a leaf node. If the node is not a 
+      # leaf node then the tree will expand the node instead and query
+      # for its children.
+      def activated(tree, node);   end
+      
+      # Called when a node in a tree is selected. 
+      def selected(tree, node);    end
+
+      # Called when a node in a tree is right clicked on. node may be nil
+      # if the right click happened over the tree but not on a node.
+      def right_click(tree, node); end
+      
+      # Called after an edit operation with the new text of the
+      # node. See Tree#edit
+      def edited(tree, node, text); end
+      
+      # Called when a drag operation begins. Should return
+      # a Redcar::Tree::Controller::DragController.
+      def drag_controller(tree)
+        DragController::Fake.new
+      end
+      
+      # SPI for Tree drag and drop. Implement this class to support drag and
+      # drop in your tree.
+      module DragController
+        class Fake; include DragController; end
+
+        # Can elements in the tree be reordered by dragging and 
+        # dropping? Shows insertion feedback in the GUI.
+        def reorderable?
+          false
+        end
+        
+        # Called with the dragged nodes when a drag operation begins
+        def drag_start(nodes); end
+        
+        # Called during a drag operation when the cursor hovers over other
+        # rows. 
+        #
+        # @param nodes - the dragged nodes
+        # @param target - the hovered over node, or nil if the empty tree area
+        # @param position - one of :onto, :before, :after (always :onto unless
+        #                   reorderable?)
+        def can_drop?(nodes, target, position); end
+        
+        # Called when the user has dropped nodes onto another node.
+        #
+        # @param nodes - the dragged nodes
+        # @param target - the hovered over node, or nil if the empty tree area
+        # @param position - one of :onto, :before, :after (always :onto unless
+        #                   reorderable?)
+        def do_drop(nodes, target, position); end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,132 @@
+
+module Redcar
+  class Tree
+    
+    # SPI specification. Implement a class including this module and
+    # pass an instance to Tree#new to populate the contents of a Tree.
+    module Mirror
+      include Redcar::Observable
+      
+      # Return the title of the tree. It should NOT change.
+      #
+      # @return [String]
+      def title
+        "Tree"
+      end
+      
+      # Return the top level entries in the Tree. Each element should
+      # be an instance of a class implementing Redcar::Tree::Mirror::NodeMirror
+      #
+      # @return [Array<NodeMirror>]
+      def top
+        []
+      end
+      
+      # Does the resource still exist
+      #
+      # @return [Boolean]
+      def exist?
+        true
+      end
+      
+      # What type of data does the tree contain? If Node#to_data returns an
+      # absolute path to a file, then :file may be specified for OS integration.
+      #
+      # @return [Symbol] either :file or :text
+      def data_type
+        :text
+      end
+
+      # Has the top nodes changed since the last time `top` 
+      # was called?
+      #
+      # @return [Boolean]
+      def changed?
+        false
+      end
+      
+      # Should drag and drop be permitted?
+      #
+      # @return [Boolean]
+      def drag_and_drop?
+        false
+      end
+      
+      # Create a node from the data created by to_data. This is the reverse
+      # operation to #to_data, and should turn the String (in case data_type
+      # if :text) or Array of Strings (in case data_type is :file) into an 
+      # array of nodes
+      #
+      # @return [NodeMirror]
+      def from_data(data)
+        raise "not implemented"
+      end
+    
+      # This must be implemented (along with a from_data method)
+      # in order to allow drag and drop and copy and paste within the tree.
+      #
+      # If the Tree::Mirror data_type is :text (the default), this must
+      # return a String. The string should be a *complete* representation
+      # of the data in the nodes, so that the from_data method can turn the
+      # string back into nodes
+      #
+      # If the Tree::Mirror data_type is :file, this must return an
+      # array of Strings, where each string is the absolute path to the file.
+      #
+      # @return [String or Array<String>]
+      def to_data(nodes)
+        raise "not implemented"
+      end
+      
+      # Called when the whole tree needs to be refreshed. Implementations
+      # should do whatever they need to do to fetch full tree data, and then
+      # yield.
+      #
+      # The purpose is so that a refresh operation can run against some cached
+      # data, but then at the end of the method the mirror can discard the cache.
+      # Because refreshes typically generate large numbers of queries.
+      def refresh_operation(tree)
+        yield
+      end
+      
+      # This is the required interface of a ROW in a TreeView.
+      module NodeMirror
+        include Redcar::Observable
+        
+        # Which text to show in the tree
+        #
+        # @return [String]
+        def text
+          raise "not implemented"
+        end
+        
+        # Which icon to show next to the text
+        def icon
+          nil
+        end
+
+        # This node's children
+        #
+        # @return [Array<NodeMirror>]
+        def children
+          []
+        end
+
+        # Whether this node is a leaf node or not (different to whether or
+        # not it has children.)
+        #
+        # @return [Boolean]
+        def leaf?
+          true
+        end
+        
+        # The text for the tooltip, or nil if no tooltip
+        #
+        # @return [String or nil]
+        def tooltip_text
+          nil
+        end
+      end
+    end
+  end
+end

data/plugins/application/lib/application/treebook.rb

@@ -0,0 +1,83 @@
+module Redcar
+  class Treebook
+    include Redcar::Observable
+    include Redcar::Model
+
+    attr_reader :trees, :focussed_tree
+
+    def initialize
+      @trees = []
+      @focussed_tree = nil
+    end
+
+    # Add a tree to this treebook
+    #
+    # @param [Redcar::Tree]
+    def add_tree(tree)
+      @trees << tree
+      @focussed_tree = tree
+      notify_listeners(:tree_added, tree)
+      tree.focus
+      Redcar.app.repeat_event(:tree_added) if Redcar.app
+    end
+
+    # Bring the tree to the front
+    #
+    # @param [Redcar::Tree]
+    def focus_tree(tree)
+      return if @focussed_tree == tree
+      @focussed_tree = tree
+      notify_listeners(:tree_focussed, tree)
+      tree.focus
+    end
+
+    # Remove a tree from this treebook
+    #
+    # @param [Redcar::Tree]
+    def remove_tree(tree)
+      if @trees.include?(tree)
+        @trees.delete(tree)
+        notify_listeners(:tree_removed, tree)
+        if tree == focussed_tree
+          focus_tree(trees.first) if trees.any?
+        end
+        Redcar.app.repeat_event(:tree_removed) if Redcar.app
+      end
+    end
+
+    def switch_down
+      if @trees.any?
+        if @focussed_tree
+          index = @trees.index @focussed_tree
+        else
+          index = -1
+        end
+        new_tree_index = index + 1
+        new_tree_index = 0 if new_tree_index < 0 or new_tree_index >= @trees.size
+        tree = @trees[new_tree_index]
+        focus_tree(tree) if tree
+      end
+    end
+
+    def switch_up
+      if @trees.any?
+        if @focussed_tree
+          index = @trees.index @focussed_tree
+        else
+          index = 1
+        end
+        new_tree_index = index - 1
+        new_tree_index = @trees.size - 1 if new_tree_index < 0 or new_tree_index >= @trees.size
+        tree = @trees[new_tree_index]
+        focus_tree(tree) if tree
+      end
+    end
+
+    private
+
+    # Tell the Treebook that this tree has been focussed in the GUI.
+    def set_focussed_tree(tree)
+      @focussed_tree = tree
+    end
+  end
+end

data/plugins/application/lib/application/window.rb

@@ -0,0 +1,274 @@
+
+module Redcar
+  class Window
+    DEFAULT_TITLE = "Redcar"
+
+    include Redcar::Model
+    include Redcar::Observable
+
+    # All instantiated windows
+    def self.all
+      @all ||= []
+    end
+
+    attr_reader :notebooks, :notebook_orientation
+    attr_reader :treebook
+    attr_reader :speedbar
+
+    def initialize
+      Window.all << self
+      @visible   = false
+      @notebooks = []
+      @notebook_orientation = :horizontal
+      create_notebook
+      @treebook   = Treebook.new
+      @speedbar   = nil
+      self.title  = DEFAULT_TITLE
+    end
+
+    def set_trees_visible(value)
+      if value
+        notify_listeners(:toggle_trees_visible) unless trees_visible?
+      else
+        notify_listeners(:toggle_trees_visible) if trees_visible?
+      end
+    end
+
+    def trees_visible?
+      not controller.treebook_hidden?
+    end
+
+    def title
+      @title
+    end
+
+    def title=(value)
+      @title = value
+      notify_listeners(:title_changed, @title)
+    end
+
+    def show
+      @visible = true
+      notify_listeners(:show)
+    end
+
+    def visible?
+      @visible
+    end
+
+    def fullscreen
+      controller.fullscreen
+    end
+
+    def fullscreen=(value)
+      controller.fullscreen = value
+    end
+
+    # Create a new notebook in this window.
+    #
+    # @events [(:new_notebook, notebook)]
+    def create_notebook
+    #  return if @notebooks.length == 2
+      notebook = Redcar::Notebook.new(self)
+      @notebooks << notebook
+      if @notebooks.length == 1
+        self.focussed_notebook = notebook
+      end
+      attach_notebook_listeners(notebook)
+      notify_listeners(:new_notebook, notebook)
+    end
+
+    def enlarge_notebook(index)
+      notify_listeners(:enlarge_notebook,index)
+    end
+
+    def adjust_treebook_width(more=true)
+      if more
+        notify_listeners(:increase_treebook_width)
+      else
+        notify_listeners(:decrease_treebook_width)
+      end
+    end
+
+    def reset_notebook_widths
+      notify_listeners(:reset_notebook_widths)
+    end
+
+    def attach_notebook_listeners(notebook)
+      notebook.add_listener(:tab_focussed) do |tab|
+        notify_listeners(:tab_focussed, tab)
+        if tab
+          self.focussed_notebook = tab.notebook
+        else
+          new_notebook = self.notebooks.sort_by {|nb| nb.tabs.length}.last
+          if new_tab = new_notebook.focussed_tab
+            new_notebook.focussed_tab.focus
+          end
+        end
+        if speedbar and speedbar.respond_to?(:tab_changed)
+          speedbar.tab_changed(tab)
+        end
+      end
+      notebook.add_listener(:tab_closed) do
+        notify_listeners(:tab_closed)
+      end
+      notebook.add_listener(:focussed_tab_changed) do |tab|
+        if notebook == focussed_notebook
+          notify_listeners(:focussed_tab_changed, tab)
+        end
+      end
+      notebook.add_listener(:focussed_tab_selection_changed) do |tab|
+        if notebook == focussed_notebook
+          notify_listeners(:focussed_tab_selection_changed, tab)
+        end
+      end
+    end
+
+    def close_notebook
+      return if @notebooks.length == 1
+      first_notebook, second_notebook = *@notebooks
+      second_notebook.tabs.each do |tab|
+        first_notebook.grab_tab_from(second_notebook, tab)
+      end
+      @notebooks.delete(second_notebook)
+      self.focussed_notebook = first_notebook
+      notify_listeners(:notebook_removed, second_notebook)
+    end
+
+    def focussed_notebook
+      @focussed_notebook
+    end
+
+    def focussed_notebook_tab
+      @focussed_notebook.focussed_tab
+    end
+
+    def focussed_notebook_tab_document
+      focussed_notebook_tab.document if focussed_notebook_tab
+    end
+
+    def focussed_notebook=(notebook)
+      if notebook != @focussed_notebook
+        set_focussed_notebook(notebook)
+        notify_listeners(:notebook_focussed, notebook)
+      end
+    end
+
+    def set_focussed_notebook(notebook)
+      @focussed_notebook = notebook
+    end
+
+    def nonfocussed_notebook
+        i = @notebooks.index @focussed_notebook
+        @notebooks[(i + 1) % @notebooks.length]
+      #@notebooks.find {|nb| nb != @focussed_notebook }
+    end
+
+    # Sets the orientation of the notebooks.
+    #
+    # @param [:horizontal, :vertical]
+    def notebook_orientation=(key)
+      @notebook_orientation = key
+      notify_listeners(:notebook_orientation_changed, key)
+    end
+
+    # Sets the orientation of the notebooks to whatever it is not currently.
+    def rotate_notebooks
+      if notebook_orientation == :horizontal
+        self.notebook_orientation = :vertical
+      else
+        self.notebook_orientation = :horizontal
+      end
+    end
+
+    # Delegates to the new_tab method in the Window's active Notebook.
+    def new_tab(*args, &block)
+      focussed_notebook.new_tab(*args, &block)
+    end
+
+    attr_reader :menu, :toolbar, :keymap
+
+    def menu=(menu)
+      @menu = menu
+    end
+
+    def toolbar=(toolbar)
+      @toolbar = toolbar
+    end
+
+    def keymap=(keymap)
+      @keymap = keymap
+    end
+
+    def popup_menu(menu)
+      notify_listeners(:popup_menu, menu)
+    end
+
+    def popup_menu_with_numbers(menu)
+      notify_listeners(:popup_menu_with_numbers, menu)
+    end
+
+    def refresh_menu
+      notify_listeners(:refresh_menu)
+    end
+
+    def refresh_toolbar
+      notify_listeners(:refresh_toolbar)
+    end
+
+    # Focus the Window.
+    def focus
+      Redcar.app.events.ignore(:window_focus, self) do
+        notify_listeners(:focussed, self)
+        refresh_tabs
+      end
+    end
+
+    # Check all tabs for underlying files; mark if missing
+    def refresh_tabs
+      all_tabs.each do |tab|
+        if tab.is_a?(Redcar::EditTab)
+          tab.update_for_file_changes
+        end
+      end
+    end
+
+    def close
+      Redcar.app.events.ignore(:window_close, self) do
+        notify_listeners(:about_to_close, self)
+        notebooks.each do |notebook|
+          notebook.tabs.each {|tab| tab.close }
+        end
+        if notebooks.length > 1
+          close_notebook
+        end
+        notify_listeners(:closed, self)
+      end
+    end
+
+    def inspect
+      "#<Redcar::Window \"#{title}\">"
+    end
+
+    def open_speedbar(speedbar)
+      if @speedbar
+        close_speedbar
+      end
+      @speedbar = speedbar
+      notify_listeners(:speedbar_opened, speedbar)
+    end
+
+    def close_speedbar
+      notify_listeners(:speedbar_closed, @speedbar)
+      @speedbar.close if @speedbar.respond_to?(:close)
+      @speedbar = nil
+      if tab = focussed_notebook.focussed_tab
+        tab.focus
+      end
+    end
+
+    def all_tabs
+      notebooks.map {|nb| nb.tabs }.flatten
+    end
+  end
+end