redcar 0.3.6 → 0.3.7

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

@@ -1,44 +1,84 @@
 
 module Redcar
   class Tree
-    # Abstract interface. A Mirror allows an TreeView contents to reflect 
-    # some other resource, for example a directory tree on disk.
-    # They have methods for loading the contents from the resource.
-    #
-    # Events: changed
+    
+    # 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 resource. (e.g. the name of the directory)
+      # Return the title of the tree.
       #
       # @return [String]
       def title
-        raise "not implemented"
+        "Tree"
       end
       
-      # Return the top entries in the Tree. (e.g. the files in the top dir)
+      # 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
-        raise "not implemented"
+        []
       end
       
-      # Does the resource still exist (e.g. does the dir exist?)
+      # Does the resource still exist
       #
       # @return [Boolean]
       def exist?
-        raise "not implemented"
+        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` 
-      # were was called? (E.g. have the contents of the top level dir changed)
+      # 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
       
-      # This is the abstract representation of a ROW in a TreeView.
+      # This is the required interface of a ROW in a TreeView.
       module NodeMirror
         include Redcar::Observable
         
@@ -51,14 +91,14 @@ module Redcar
         
         # Which icon to show next to the text
         def icon
-          raise "not implemented"
+          nil
         end
 
         # This node's children
         #
         # @return [Array<NodeMirror>]
         def children
-          raise "not implemented"
+          []
         end
 
         # Whether this node is a leaf node or not (different to whether or
@@ -66,7 +106,7 @@ module Redcar
         #
         # @return [Boolean]
         def leaf?
-          raise "not implemented"
+          true
         end
       end
     end

data/plugins/tree_view_swt/lib/tree_view_swt.rb

@@ -1,7 +1,7 @@
 
 module Redcar
   class TreeViewSWT
-    attr_reader :viewer
+    attr_reader :viewer, :model
     
     def self.storage
       @storage ||= begin
@@ -10,11 +10,11 @@ module Redcar
          storage
       end
     end
-
     
     def initialize(composite, model)
       @composite, @model = composite, model
-      @viewer = JFace::Viewers::TreeViewer.new(@composite, Swt::SWT::VIRTUAL)
+      tree_style = Swt::SWT::VIRTUAL | Swt::SWT::MULTI
+      @viewer = JFace::Viewers::TreeViewer.new(@composite, tree_style)
       @viewer.set_content_provider(TreeMirrorContentProvider.new)
       @viewer.set_input(@model.tree_mirror)
       @viewer.set_label_provider(TreeMirrorLabelProvider.new)
@@ -22,32 +22,230 @@ module Redcar
       if @model.tree_controller
         @viewer.add_tree_listener(@viewer.getControl, TreeListener.new)
         @viewer.add_double_click_listener(DoubleClickListener.new)
-        @viewer.add_open_listener(OpenListener.new(@model.tree_controller))
-      end
-      
-      @model.add_listener(:refresh) do
-        s = Time.now
-        begin
-          @viewer.refresh if TreeViewSWT.storage['refresh_trees_on_refocus']
-        rescue => e
-          # Don't know why the @viewer sometimes throws these:
-          # "undefined method `getParent' for #<Redcar::TreeViewSWT::TreeMirrorContentProvider:0x44655c8c> (NoMethodError)"
-          # It looks like it is expecting a ILazyTreeViewContentProvider, because getParent
-          # is in the API for that.
-          puts e.message
-          puts e.backtrace
+        @viewer.add_open_listener(OpenListener.new(@model))
+        control.add_mouse_listener(MouseListener.new(self))
+      end
+      
+      register_dnd if @model.tree_mirror.drag_and_drop?
+      
+      @model.add_listener(:refresh) { @viewer.refresh }
+      
+      @editor = Swt::Custom::TreeEditor.new(control)
+      
+      @editor.horizontalAlignment = Swt::SWT::LEFT
+      @editor.grabHorizontal = true
+      
+      @model.add_listener(:edit_element, &method(:edit_element))
+      @model.add_listener(:expand_element, &method(:expand_element))
+      @model.add_listener(:select_element, &method(:select_element))
+    end
+    
+    class DragSourceListener
+      attr_reader :tree, :dragged_elements
+      
+      def initialize(tree_view_swt, tree)
+        @tree_view_swt = tree_view_swt
+        @tree = tree
+      end
+      
+      def drag_start(event)
+        selection = tree.get_selection
+        if selection.length > 0
+          event.doit = true
+          @dragged_elements = selection.map do |item|
+            @tree_view_swt.item_to_element(item)
+          end
+          Redcar.safely do
+            @tree_view_swt.drag_controller.drag_start(@dragged_elements)
+          end
+        else
+          event.doit = false
+        end
+      end
+      
+      def drag_set_data(event)
+        case tree_mirror.data_type
+        when :file
+          Redcar.safely do
+            @data = tree_mirror.to_data(dragged_elements).to_java(:string)
+          end
+          event.data = @data
+        when :text
+          Redcar.safely do
+            @data = tree_mirror.to_data(dragged_elements)
+          end
+          event.data = @data
+        else
+          raise "unknown tree data_type #{tree.tree_mirror.data_type}"
+        end
+      end
+      
+      def drag_finished(*_); end
+      
+      def tree_mirror
+        @tree_view_swt.model.tree_mirror
+      end
+    end
+    
+    class DropAdapter < JFace::Viewers::ViewerDropAdapter
+      def initialize(tree_view_swt, drag_source_listener, viewer)
+        @tree_view_swt = tree_view_swt
+        @drag_source_listener = drag_source_listener
+        super(viewer)
+      end
+      
+      def validateDrop(target, operation, transfer_data_type)
+        pos = location_to_position(get_current_location)
+        Redcar.safely do
+          @tree_view_swt.drag_controller.can_drop?(@drag_source_listener.dragged_elements, target, pos)
+        end
+      end
+      
+      def performDrop(data)
+        elements = data.to_a.map {|datum| @tree_view_swt.model.tree_mirror.from_data(datum) }
+        pos = location_to_position(get_current_location)
+        Redcar.safely do
+          @tree_view_swt.drag_controller.do_drop(elements, get_current_target, pos)
+        end
+        true
+      end
+      
+      private
+      
+      def location_to_position(location)
+        if Redcar.safely { @tree_view_swt.drag_controller.reorderable? }
+          {1 => :before, 2 => :after, 3 => :onto}[location]
+        else
+          :onto
+        end
+      end
+    end
+    
+    def register_dnd
+      case Redcar.safely { @model.tree_mirror.data_type }
+      when :file
+        types = [Swt::DND::FileTransfer.getInstance()].to_java(:"org.eclipse.swt.dnd.FileTransfer")
+      when :text
+        types = [Swt::DND::TextTransfer.getInstance()].to_java(:"org.eclipse.swt.dnd.TextTransfer")
+      else
+        raise "unknown tree data_type #{Redcar.safely { tree.tree_mirror.data_type }}"
+      end
+      operations = Swt::DND::DND::DROP_MOVE | Swt::DND::DND::DROP_COPY
+      
+      source_listener = DragSourceListener.new(self, @viewer.get_tree)
+      drop_adapter = DropAdapter.new(self, source_listener, @viewer)
+      drop_adapter.set_feedback_enabled(drag_controller.reorderable?)
+      
+      @viewer.add_drag_support(operations, types, source_listener)
+      @viewer.add_drop_support(operations, types, drop_adapter)
+    end
+    
+    def drag_controller
+      @model.tree_controller.drag_controller(@model)
+    end
+    
+    def edit_element(element, select_from, select_to)
+      item = element_to_item(element)
+      unless item
+        puts "ERROR: when trying to edit, no visible item for #{element.inspect}"
+        return
+      end
+      
+      text = Swt::Widgets::Text.new(control, Swt::SWT::NONE)
+      text.set_text(item.get_text)
+      colour = ApplicationSWT.display.get_system_color(Swt::SWT::COLOR_GRAY)
+      text.set_background(colour)
+      
+      @editor.set_editor(text, item)
+      text.set_selection(select_from || 0, select_to || text.get_text.length)
+      listener = EditorListener.new(self, element, text)
+      text.add_listener(Swt::SWT::FocusOut, listener)
+      text.add_listener(Swt::SWT::Traverse, listener)
+
+      text.set_focus
+    end
+    
+    def edited_element(element, text)
+      if @model.tree_controller and @model.tree_controller.respond_to?(:edited)
+        Redcar.safely("edit element") do
+          @model.tree_controller.edited(@model, element, text)
+        end
+      end
+    end
+    
+    def expand_element(element)
+      if item = element_to_item(element)
+        @viewer.expandToLevel(element, 1)
+      end
+    end
+
+    def select_element(element)
+      if item = element_to_item(element)
+        @viewer.get_tree.set_selection(item)
+      end
+    end
+
+    def element_to_item(element)
+      @viewer.test_find_item(element)
+    end
+    
+    def item_to_element(item)
+      @viewer.getViewerRowFromItem(item).get_element
+    end
+    
+    def selection
+      @viewer.get_tree.get_selection.map {|i| item_to_element(i) }
+    end
+    
+    class EditorListener
+      def initialize(tree_view_swt, element, text_widget)
+        @tree_view_swt = tree_view_swt
+        @element = element
+        @text = text_widget
+      end
+      
+      def handle_event(e)
+        case e.type
+        when Swt::SWT::FocusOut
+          new_text = @text.get_text
+          @text.dispose
+          @tree_view_swt.edited_element(@element, new_text)
+        when Swt::SWT::Traverse
+          case e.detail
+          when Swt::SWT::TRAVERSE_RETURN
+            new_text = @text.get_text
+            @text.dispose
+            e.doit = false
+            @tree_view_swt.edited_element(@element, new_text)
+          when Swt::SWT::TRAVERSE_ESCAPE
+            @text.dispose
+            e.doit = false
+          end
         end
       end
     end
     
     def control
-      @viewer.getControl
+      @viewer.get_control
     end
     
     def close
       @viewer.getControl.dispose
     end
     
+    def right_click(mouse_event)
+      if @model.tree_controller
+        point = Swt::Graphics::Point.new(mouse_event.x, mouse_event.y)
+        item = @viewer.get_item_at(point)
+        element = item ? @viewer.getViewerRowFromItem(item).get_element : nil
+        if @model.tree_controller.respond_to?(:right_click)
+          Redcar.safely("right click on tree") do
+            @model.tree_controller.right_click(@model, element)
+          end
+        end
+      end
+    end
+    
     class TreeListener
       def tree_collapsed(e)
       end
@@ -64,6 +262,22 @@ module Redcar
       end
     end
     
+    class MouseListener
+      def initialize(tree_view_swt)
+        @tree_view_swt = tree_view_swt
+      end
+      
+      def mouse_double_click(_); end
+      def mouse_up(_)
+      end
+      
+      def mouse_down(e)
+        if e.button == 3
+          @tree_view_swt.right_click(e)
+        end
+      end
+    end
+    
     class DoubleClickListener
       def double_click(e)
 
@@ -84,12 +298,14 @@ module Redcar
     end
     
     class OpenListener
-      def initialize(controller)
-        @controller = controller
+      def initialize(tree_model)
+        @tree_model = tree_model
       end
       
       def open(e)
-        @controller.activated(e.getSelection.toArray.to_a.first)
+        Redcar.safely("tree row activation") do
+          @tree_model.tree_controller.activated(@tree_model, e.getSelection.toArray.to_a.first)
+        end
       end
     end
     
@@ -111,6 +327,10 @@ module Redcar
       def get_children(tree_node)
         tree_node.children.to_java
       end
+      
+      def get_parent(tree_node)
+        # not sure why this is necessary
+      end
 
       def dispose
       end
@@ -130,11 +350,13 @@ module Redcar
       end
 
       def get_image(tree_node)
-        case tree_node.icon
+        case icon = tree_node.icon
         when :directory
           dir_image
         when :file
           file_image
+        when String
+          image(icon)
         end
       end
 
@@ -143,17 +365,21 @@ module Redcar
       
       private
       
+      def image(path)
+        Swt::Graphics::Image.new(ApplicationSWT.display, path)
+      end
+      
       def dir_image
         @dir_image ||= begin
           path = File.join(Redcar.root, %w(plugins application icons darwin-folder.png))
-          Swt::Graphics::Image.new(ApplicationSWT.display, path)
+          image(path)
         end
       end
       
       def file_image
         @file_image ||= begin
           path = File.join(Redcar.root, %w(plugins application icons darwin-file.png))
-          Swt::Graphics::Image.new(ApplicationSWT.display, path)
+          image(path)
         end
       end
     end