redcar 0.3.5 → 0.3.6

data/plugins/application_swt/lib/application_swt/menu.rb

@@ -42,6 +42,10 @@ module Redcar
         @result
       end
       
+      def move(x, y)
+        @menu_bar.setLocation(x, y)
+      end
+      
       private
       
       def use_numbers?

data/plugins/application_swt/lib/application_swt/menu/binding_translator.rb

@@ -36,6 +36,10 @@ module Redcar
             value += Swt::SWT::PAGE_UP
           elsif key_string =~ /Page Down$/
             value += Swt::SWT::PAGE_DOWN
+          elsif key_string =~ /Home$/
+            value += Swt::SWT::HOME
+          elsif key_string =~ /End$/
+            value += Swt::SWT::END
           else
             value += key_string[-1]
           end

data/plugins/application_swt/lib/application_swt/notebook.rb

@@ -3,7 +3,7 @@ module Redcar
     class Notebook
       include Redcar::Observable
       
-      attr_reader :tab_folder
+      attr_reader :tab_folder, :model
       
       class CTabFolder2Listener
         def initialize(controller)
@@ -60,6 +60,21 @@ module Redcar
         grid_data = Swt::Layout::GridData.new(Swt::Layout::GridData::FILL_BOTH)
         @tab_folder.set_layout_data(grid_data)
         @tab_folder.pack
+        register_tab_dnd(@tab_folder)
+      end
+      
+      def register_tab_dnd(tab_folder)
+        dnd_listener = TabDragAndDropListener.new(self)
+        operations = (Swt::DND::DND::DROP_COPY | Swt::DND::DND::DROP_DEFAULT | Swt::DND::DND::DROP_MOVE)
+        transfer_types = [TabTransfer.get_instance].to_java(:"org.eclipse.swt.dnd.ByteArrayTransfer")
+        
+        drag_source = Swt::DND::DragSource.new(tab_folder, operations)
+        drag_source.set_transfer(transfer_types)
+        drag_source.add_drag_listener(dnd_listener)
+        
+        drop_target = Swt::DND::DropTarget.new(tab_folder, operations)
+        drop_target.set_transfer(transfer_types)
+        drop_target.add_drop_listener(dnd_listener)
       end
       
       def style_tab_folder
@@ -101,6 +116,12 @@ module Redcar
         tab_model.deserialize(data)
       end
       
+      def recalculate_tab_order
+        @model.sort_tabs! do |a,b|
+          tab_folder.index_of(a.controller.item) <=> tab_folder.index_of(b.controller.item)
+        end
+      end
+      
       def dispose
         @tab_folder.dispose
       end

data/plugins/application_swt/lib/application_swt/notebook/tab_drag_and_drop_listener.rb

@@ -0,0 +1,124 @@
+module Redcar
+  class ApplicationSWT
+    class Notebook
+      class TabDragAndDropListener
+        include org.eclipse.swt.dnd.DragSourceListener
+        include org.eclipse.swt.dnd.DropTargetListener
+                
+        # A TabPaintListener allows clients to draw 
+        # indicators next to a tab in the tab folder
+        class TabPaintListener
+          include org.eclipse.swt.events.PaintListener    
+          attr_writer :item, :indicate_front
+      
+          def paintControl(event)
+            event.gc.background = ApplicationSWT.display.system_color Swt::SWT::COLOR_DARK_GRAY
+            if @item && @item.bounds
+              bounds = @item.bounds
+              side_length = bounds.height / 3
+              offset = (bounds.width unless @indicate_front) || 0
+              triangle = [bounds.x + offset, bounds.y + side_length,
+                bounds.x + offset + side_length, bounds.y,
+                bounds.x + offset - side_length, bounds.y]
+            else
+              triangle = [0, 0, 10, 10, 0, 20]
+            end
+            event.gc.fill_polygon(triangle.to_java(:int))
+          end
+        end
+
+        def initialize(notebook)
+          @notebook = notebook
+          @paint_listener = TabPaintListener.new
+        end
+        
+        def tab_folder
+          @notebook.tab_folder
+        end
+        
+        # DragSourceListener interface implementation
+        # When a drag starts, the dragged tab is marked
+        def dragStart(event)
+          if tab_folder.item_count > 0
+            @dragged_tab_controller = @notebook.tab_widget_to_tab_model(tab_folder.selection).controller
+            @dragged_tab_controller.dragging = true
+          else
+            event.doit = false
+          end
+        end
+        
+        # DragSourceListener interface implementation
+        # When a drag finishes, the dragged tab is unmarked and released
+        def dragFinished(event)
+          @dragged_tab_controller.dragging = false
+          @dragged_tab_controller = @paint_listener.item = nil
+          tab_folder.redraw
+        end
+        
+        # DropTargetListener interface implementation
+        # A @link{TabPaintListener} is added to the tab folder when dragging into it
+        # to indicate where the drop would happen
+        def dragEnter(event)
+          tab_folder.add_paint_listener(@paint_listener)
+        end
+        
+        # DropTargetListener interface implementation
+        # If a drag leaves the tab folder, remove the @link{TabPaintListener}
+        def dragLeave(event)
+          tab_folder.remove_paint_listener(@paint_listener)
+          tab_folder.redraw
+        end
+
+        # DropTargetListener interface implementation
+        # While dragging, update the @link{TabPaintListener} to show drop indicators
+        def dragOver(event)
+          widget = event_to_tab_widget(event)
+          @paint_listener.item = widget
+          @paint_listener.indicate_front = move_to_front?(widget, event)
+          tab_folder.redraw
+        end
+
+        # DropTargetListener interface implementation
+        # Drop the dragged tab on the notebook at the target position
+        def drop(event)
+          target_tab_widget = event_to_tab_widget(event)
+          unless @dragged_tab_controller && target_tab_widget == @dragged_tab_controller.item
+            dragged_tab_model = @dragged_tab_controller.model if @dragged_tab_controller
+            dragged_tab_model ||= Redcar.app.all_tabs.detect {|t| t.controller.dragging?}
+            @notebook.model.grab_tab_from(dragged_tab_model.notebook, dragged_tab_model)
+            move_tab(dragged_tab_model.controller, target_tab_widget, event)
+          end
+        end
+
+        # Move the tab controlled by the given controller behind or before the indicated tab
+        # @param [Redcar::ApplicationSWT::Tab] the dragged tab's controller
+        # @param [SWT::Custom::CTabItem] the item to drop behind
+        def move_tab(tab_controller, tab_widget, event)
+          position = (tab_folder.index_of(tab_widget) if tab_widget) || 0
+          position -= 1 if move_to_front?(tab_widget, event)
+          position += 1 if tab_folder.index_of(tab_controller.item) > position
+          tab_controller.move_tab_widget_to_position(position)
+        end
+        
+        # Find the CTabItem targeted by a given event        
+        def event_to_tab_widget(event)
+          if tab_folder.item_count > 0
+            tab_folder.item(tab_folder.to_control(event.x, event.y)) or 
+            tab_folder.items[tab_folder.item_count - 1]
+          end
+        end
+        
+        def move_to_front?(widget, event)
+          widget && (widget.bounds.width / 2 > 
+            (tab_folder.to_control(event.x, event.y).x - widget.bounds.x))
+        end
+
+        # Unimplemented interface methods
+        def dragSetData(event); end
+        def dragOperationChanged(event); end
+        def dropAccept(event); end
+      end
+    end
+  end
+end
+

data/plugins/application_swt/lib/application_swt/notebook/tab_transfer.rb

@@ -0,0 +1,83 @@
+module Redcar
+  class ApplicationSWT
+    class Notebook
+      class TabTransfer < Swt::DND::ByteArrayTransfer
+        
+        class TabType
+          # Empty class for now, until we figure out which 
+          # information we want to attach to the transfer.
+          # This _will_ be needed to DnD tabs between windows
+        end
+      	
+        TAB_TYPE = "TabType"
+        TAB_TYPE_ID = register_type(TAB_TYPE)
+        @@instance = nil
+       
+        def self.get_instance
+          @@instance || TabTransfer.new
+        end
+        
+        def javaToNative(types, transfer_data)
+          return if (types.nil? || types.empty? || (types.first.class != TabType))
+   
+          begin
+            # write data to a byte array and then ask super to convert to
+            out = java.io.ByteArrayOutputStream.new
+            write_out = java.io.DataOutputStream.new(out)
+            types.length.times do |i|
+              buffer = TAB_TYPE.to_java_bytes
+              write_out.write_int(buffer.length)
+              write_out.write(buffer)
+            end
+            buffer = out.to_byte_array
+            write_out.close
+            super(buffer, transfer_data)
+          rescue java.io.IOException => e
+          end
+        end
+        
+        def nativeToJava(transfer_data)
+          if (is_supported_type(transfer_data))
+            buffer = super
+            return nil unless buffer
+       		
+            data = []
+            begin
+              input = java.io.ByteArrayInputStream.new(buffer)
+              read_in = java.io.DataInputStream.new(input)
+              while (read_in.available > 20) do
+                datum = TabType.new
+                int size = read_in.read_int
+                name = Java::byte[size].new
+                read_in.read(name)
+                tab_type_name = String.from_java_bytes(name);
+                data << datum
+              end
+              read_in.close
+            rescue java.io.IOException => e
+              return null;
+            end
+            return data.to_java
+          end
+          return nil
+        end
+        
+        def get_type_names
+          [TAB_TYPE].to_java(:string)
+        end
+        
+        def get_type_ids
+          [TAB_TYPE_ID].to_java(:int)
+        end
+        
+        def getTypeIds
+          get_type_ids
+        end
+        
+        def getTypeNames
+          get_type_names
+        end
+      end
+    end
+  end
+end

data/plugins/application_swt/lib/application_swt/swt_wrapper.rb

@@ -45,6 +45,7 @@ module Swt
     import org.eclipse.swt.widgets.Menu
     import org.eclipse.swt.widgets.MenuItem
     import org.eclipse.swt.widgets.MessageBox
+    import org.eclipse.swt.widgets.Sash
     import org.eclipse.swt.widgets.Shell
     import org.eclipse.swt.widgets.TabFolder
     import org.eclipse.swt.widgets.TabItem
@@ -71,13 +72,26 @@ module Swt
   end
   
   module DND
+    import org.eclipse.swt.dnd.DND
     import org.eclipse.swt.dnd.Clipboard
     import org.eclipse.swt.dnd.Transfer
     import org.eclipse.swt.dnd.TextTransfer
+    import org.eclipse.swt.dnd.ByteArrayTransfer
+    
+    import org.eclipse.swt.dnd.DropTarget
+    import org.eclipse.swt.dnd.DropTargetEvent
+    import org.eclipse.swt.dnd.DropTargetListener
+    
+    import org.eclipse.swt.dnd.DragSource
+    import org.eclipse.swt.dnd.DragSourceEvent
+    import org.eclipse.swt.dnd.DragSourceListener
   end
   
   module Layout
     import org.eclipse.swt.layout.FillLayout
+    import org.eclipse.swt.layout.FormAttachment
+    import org.eclipse.swt.layout.FormLayout
+    import org.eclipse.swt.layout.FormData
     import org.eclipse.swt.layout.GridLayout
     import org.eclipse.swt.layout.GridData
     import org.eclipse.swt.layout.RowLayout

data/plugins/application_swt/lib/application_swt/tab.rb

@@ -1,22 +1,24 @@
 module Redcar
   class ApplicationSWT
     class Tab
+      
       attr_reader :item, :model, :notebook, :widget
       
       FILE_ICON = File.join(Redcar.root, %w(plugins application lib application assets file.png))
       
-      def initialize(model, notebook)
+      def initialize(model, notebook, position = nil)
         @model, @notebook = model, notebook
-        create_item_widget
+        create_item_widget(position || @notebook.tab_folder.item_count)
         create_tab_widget
         attach_listeners
       end
       
-      def create_item_widget
+      def create_item_widget(position = nil)
+        position ||= notebook.tab_folder.item_count
         if @item
           @item.dispose
-        end
-        @item = Swt::Custom::CTabItem.new(notebook.tab_folder, Swt::SWT::CLOSE)
+        end        
+        @item = Swt::Custom::CTabItem.new(notebook.tab_folder, Swt::SWT::CLOSE, position)
         @icon = Swt::Graphics::Image.new(ApplicationSWT.display, FILE_ICON)
         @item.image = @icon
       end
@@ -27,11 +29,31 @@ module Redcar
         @item.control = @widget
       end
       
+      def dragging?
+        @dragging
+      end
+      
+      def dragging= boolean
+        @dragging = boolean
+      end
+      
       def move_tab_widget_to_current_notebook
         @widget.setParent(notebook.tab_folder)
         @item.control = @widget
       end
-      
+
+      def move_tab_widget_to_position(position)
+        # CTabItem state
+        state_variables = [:font, :tool_tip_text, :text]
+        view_state = state_variables.collect {|var| @item.send(var)}
+        create_item_widget(position)
+        state_variables.each_with_index {|var, idx| @item.send(:"#{var}=", view_state[idx])}
+        @item.control = @widget
+        @item.image = @icon
+        @notebook.recalculate_tab_order
+        focus
+      end
+
       def set_notebook(notebook_controller)
         @notebook = notebook_controller
       end

data/plugins/application_swt/lib/application_swt/window.rb

@@ -2,9 +2,14 @@
 module Redcar
   class ApplicationSWT
     class Window
-      attr_reader :shell, :window, :shell_listener
+      attr_reader :shell, :window
+      
+      SASH_WIDTH = 5
+      TREEBOOK_WIDTH = 200
       
       class ShellListener
+        include org.eclipse.swt.events.ShellListener
+
         def initialize(controller)
           @win = controller.window
         end
@@ -38,7 +43,7 @@ module Redcar
         create_treebook_controller
         reset_sash_widths
         @treebook_unopened = true
-        set_icon File.join(Redcar.root, %w(plugins application icons redcar_icon_beta.png))
+        set_icon
       end
 
       def add_listeners
@@ -116,10 +121,23 @@ module Redcar
         old_menu_bar.dispose if old_menu_bar
       end
       
-      def set_icon(path)
+      def set_icon
+        path = File.join(icon_dir, icon_file)
         icon = Swt::Graphics::Image.new(ApplicationSWT.display, path)
         shell.image = icon
       end
+      
+      def icon_dir
+        File.join(Redcar.root, %w(plugins application icons))
+      end
+      
+      def icon_file
+        if Redcar::VERSION =~ /dev$/
+          "redcar_icon_beta_dev.png"
+        else
+          "redcar_icon_beta.png"
+        end
+      end
 
       def bring_to_front
         @shell.set_minimized(false) # unminimize, just in case
@@ -189,51 +207,79 @@ module Redcar
         
       private
       
-      SASH_WIDTH = 5
-      TREEBOOK_WIDTH = 20
+      attr_reader :right_composite
       
       def create_shell
         @shell = Swt::Widgets::Shell.new(ApplicationSWT.display)
-        @shell.layout = Swt::Layout::GridLayout.new(1, false)
-      	@shell_listener = ShellListener.new(self)
-        @shell.add_shell_listener(@shell_listener)
+        @shell.layout = Swt::Layout::FormLayout.new
+        @shell.add_shell_listener(ShellListener.new(self))
+        @shell.add_listener Swt::SWT::Resize do |e|
+          client_area = @shell.client_area
+          if client_area.width < @sash.bounds.x
+            @sash.layout_data.left = Swt::Layout::FormAttachment.new(0, client_area.width - SASH_WIDTH)
+          end
+        end
         ApplicationSWT.register_shell(@shell)
       end
       
       def create_sashes(window_model)
         orientation = horizontal_vertical(window_model.notebook_orientation)
-        @sash     = Swt::Custom::SashForm.new(@shell, orientation)
-        grid_data = Swt::Layout::GridData.new(Swt::Layout::GridData::FILL_BOTH)
-      	@sash.setLayoutData(grid_data)
-      	@sash.setSashWidth(0)
-      	
-      	@tree_composite = Swt::Widgets::Composite.new(@sash, Swt::SWT::NONE)
-      	@tree_layout = Swt::Custom::StackLayout.new
-      	@tree_composite.setLayout(@tree_layout)
-      	button = Swt::Widgets::Button.new(@tree_composite, Swt::SWT::PUSH)
-      	button.setText("Button in pane2")
-      	@tree_layout.topControl = button
-      	
-      	@right_composite = Swt::Widgets::Composite.new(@sash, Swt::SWT::NONE)
-      	@grid_layout = Swt::Layout::GridLayout.new(1, false)
-        @grid_layout.verticalSpacing = 0
-        @grid_layout.marginHeight = 0
-        @grid_layout.horizontalSpacing = 0
-        @grid_layout.marginWidth = 0
-      	@right_composite.setLayout(@grid_layout)
-      	
-        @notebook_sash     = Swt::Custom::SashForm.new(@right_composite, orientation)
-        #grid_data = Swt::Layout::GridData.new
-        #grid_data.grabExcessHorizontalSpace = true
-        #grid_data.horizontalAlignment = Swt::Layout::GridData::FILL
-        #grid_data.grabExcessVerticalSpace = true
-        #grid_data.verticalAlignment = Swt::Layout::GridData::FILL
+        
+        @tree_composite = Swt::Widgets::Composite.new(@shell, Swt::SWT::NONE)
+        @tree_layout = Swt::Custom::StackLayout.new
+        @tree_composite.setLayout(@tree_layout)
+        
+        @sash = Swt::Widgets::Sash.new(@shell, Swt::SWT::VERTICAL)
+        @right_composite = Swt::Widgets::Composite.new(@shell, Swt::SWT::NONE)
+        
+        
+        @tree_composite.layout_data = Swt::Layout::FormData.new.tap do |l|
+          l.left = Swt::Layout::FormAttachment.new(0, 5)
+          l.right = Swt::Layout::FormAttachment.new(@sash, 0)
+          l.top = Swt::Layout::FormAttachment.new(0, 5)
+          l.bottom = Swt::Layout::FormAttachment.new(100, -5)
+        end
+        
+        @right_composite.layout = Swt::Layout::GridLayout.new(1, false).tap do |l|
+          l.verticalSpacing = 0
+          l.marginHeight = 0
+          l.horizontalSpacing = 0
+          l.marginWidth = 0
+        end
+        
+        @sash.layout_data = Swt::Layout::FormData.new.tap do |d|
+          d.left = Swt::Layout::FormAttachment.new(0, 0)
+          d.top =  Swt::Layout::FormAttachment.new(0, 0)
+          d.bottom = Swt::Layout::FormAttachment.new(100, 0)
+        end
+        
+        @sash.add_selection_listener do |e|
+          sash_rect = @sash.bounds
+          shell_rect = @shell.client_area
+          right = shell_rect.width - sash_rect.width - SASH_WIDTH
+          e.x = [[e.x, right].min, SASH_WIDTH].max
+          if (e.x != sash_rect.x)
+            if @window.treebook.trees.any?
+              @sash.layout_data.left = Swt::Layout::FormAttachment.new(0, e.x)
+            else
+              @sash.layout_data.left = Swt::Layout::FormAttachment.new(0, 0)
+            end
+            @shell.layout
+          end
+        end
+        
+        @right_composite.layout_data = Swt::Layout::FormData.new.tap do |d|
+          d.left = Swt::Layout::FormAttachment.new(@sash, 0)
+          d.right = Swt::Layout::FormAttachment.new(100, -5)
+          d.top = Swt::Layout::FormAttachment.new(0, 5)
+          d.bottom = Swt::Layout::FormAttachment.new(100, -5)
+        end
+                
+        @notebook_sash = Swt::Custom::SashForm.new(@right_composite, orientation)
         grid_data = Swt::Layout::GridData.new(Swt::Layout::GridData::FILL_BOTH)
-      	@notebook_sash.setLayoutData(grid_data)
-      	@notebook_sash.setSashWidth(SASH_WIDTH)
+        @notebook_sash.layout_data = grid_data
+        @notebook_sash.sash_width = SASH_WIDTH
       end
-
-      attr_reader :right_composite      
       
       def horizontal_vertical(symbol)
         case symbol
@@ -245,14 +291,13 @@ module Redcar
       end
       
       def reset_sash_widths
+        @treebook_unopened = !@window.treebook.trees.any?
         if @window.treebook.trees.any?
-          @sash.setWeights([TREEBOOK_WIDTH, 100 - TREEBOOK_WIDTH].to_java(:int))
-          @sash.setSashWidth(SASH_WIDTH)
+          @sash.layout_data.left = Swt::Layout::FormAttachment.new(0, TREEBOOK_WIDTH + SASH_WIDTH)
         else
-          @sash.setWeights([0,100].to_java(:int))
-          @sash.setSashWidth(0)
-          @treebook_unopened = true
+          @sash.layout_data.left = Swt::Layout::FormAttachment.new(0, 0)
         end
+        @shell.layout
       end
       
       def reset_notebook_sash_widths