redcar-dev 0.12.17dev

data/plugins/application_swt/lib/application_swt/listener_helpers.rb

@@ -0,0 +1,20 @@
+module Redcar
+  class ApplicationSWT
+    module ListenerHelpers
+      def ignore_within_self
+        name = __calling_method__
+        unless singly_hash[name]
+          singly_hash[name] = true
+          yield
+          singly_hash.delete(name)
+        end
+      end
+      
+      private
+      
+      def singly_hash
+        @singly_hash ||= {}
+      end
+    end
+  end
+end

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

@@ -0,0 +1,167 @@
+module Redcar
+  class ApplicationSWT
+    class Menu
+
+      def self.types
+        @types = { :check => Swt::SWT::CHECK, :radio => Swt::SWT::RADIO }
+      end
+
+      def self.items
+        @items ||= Hash.new {|h,k| h[k] = []}
+      end
+
+      def self.disable_items(key_string)
+        items[key_string].each {|i| p i.text; i.enabled = false}
+      end
+
+      attr_reader :menu_bar
+
+
+
+      def self.menu_types
+        [Swt::SWT::BAR, Swt::SWT::POP_UP]
+      end
+
+      def initialize(window, menu_model, keymap, type, options={})
+        s = Time.now
+        unless Menu.menu_types.include?(type)
+          raise "type should be in #{Menu.menu_types.inspect}"
+        end
+        @window = window
+        @keymap = keymap
+        @menu_bar = Swt::Widgets::Menu.new(window.shell, type)
+        @menu_bar.set_visible(false)
+        return unless menu_model
+        @handlers = []
+        @use_numbers = options[:numbers]
+        @number = 1
+        add_entries_to_menu(@menu_bar, menu_model)
+        #puts "ApplicationSWT::Menu initialize took #{Time.now - s}s"
+      end
+
+      def show
+        @menu_bar.set_visible(true)
+      end
+
+      def close
+        @handlers.each {|obj, h| obj.remove_listener(h) }
+        @menu_bar.dispose
+        @result
+      end
+
+      def move(x, y)
+        @menu_bar.setLocation(x, y)
+      end
+
+      private
+
+      def use_numbers?
+        @use_numbers
+      end
+
+      def add_entries_to_menu(menu, menu_model)
+        menu_model.each do |entry|
+          if entry.is_a?(Redcar::Menu::LazyMenu)
+            menu_header = Swt::Widgets::MenuItem.new(menu, Swt::SWT::CASCADE)
+            menu_header.text = entry.text
+            new_menu = Swt::Widgets::Menu.new(menu)
+            menu_header.menu = new_menu
+            menu_header.add_arm_listener do
+              new_menu.get_items.each {|i| i.dispose }
+              add_entries_to_menu(new_menu, entry)
+            end
+          elsif entry.is_a?(Redcar::Menu)
+            menu_header = Swt::Widgets::MenuItem.new(menu, Swt::SWT::CASCADE)
+            menu_header.text = entry.text
+            new_menu = Swt::Widgets::Menu.new(menu)
+            menu_header.menu = new_menu
+            menu_header.enabled = (entry.length > 0)
+            add_entries_to_menu(new_menu, entry)
+            menu_header.add_arm_listener do
+              entry.entries.zip(new_menu.get_items) do |sub_entry, swt_item|
+                if sub_entry.lazy_text?
+                  swt_item.text = sub_entry.text
+                end
+              end
+            end
+          elsif entry.is_a?(Redcar::Menu::Item::Separator)
+            item = Swt::Widgets::MenuItem.new(menu, Swt::SWT::SEPARATOR)
+          elsif entry.is_a?(Redcar::Menu::Item)
+            item = Swt::Widgets::MenuItem.new(menu, Menu.types[entry.type] || Swt::SWT::PUSH)
+            item.setSelection(entry.active)
+            if entry.command.is_a?(Proc)
+              connect_proc_to_item(item, entry)
+            else
+              connect_command_to_item(item, entry)
+            end
+          else
+            raise "unknown object of type #{entry.class} in menu"
+          end
+        end
+      end
+
+      class ProcSelectionListener
+        def initialize(entry)
+          @entry = entry
+        end
+
+        def widget_selected(e)
+          Redcar.safely("menu item '#{@entry.text}'") do
+            @entry.command.call
+          end
+        end
+
+        alias :widget_default_selected :widget_selected
+      end
+
+      def connect_proc_to_item(item, entry)
+        if use_numbers? and Redcar.platform == :osx
+          item.text = entry.text + "\t" + @number.to_s
+          @number += 1
+        else
+          item.text = entry.text
+        end
+        item.addSelectionListener(ProcSelectionListener.new(entry))
+      end
+
+      class SelectionListener
+        def initialize(entry)
+          @entry = entry
+        end
+
+        def widget_selected(e)
+          @entry.selected(e.stateMask != 0)
+        end
+
+        def widget_default_selected(e)
+          @entry.selected(e.stateMask != 0)
+        end
+      end
+
+      def connect_command_to_item(item, entry)
+        if key_specifier = @keymap.command_to_key(entry.command)
+          if key_string    = BindingTranslator.platform_key_string(key_specifier)
+            item.text = entry.text + "\t" + key_string
+            item.set_accelerator(BindingTranslator.key(key_string))
+            Menu.items[key_string] << item
+          else
+            puts "you didn't specify a keybinding for this platform for #{entry.text}"
+            item.text = entry.text
+          end
+        else
+          item.text = entry.text
+        end
+        item.add_selection_listener(SelectionListener.new(entry))
+        h = entry.command.add_listener(:active_changed) do |value|
+          unless item.disposed
+            item.enabled = value
+          end
+        end
+        @handlers << [entry.command, h]
+        if not entry.command.active?
+          item.enabled = false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+module Redcar
+  class ApplicationSWT
+    class Menu
+      module BindingTranslator
+        MODIFIERS = %w(Cmd Ctrl Alt Shift)
+        
+        def self.platform_key_string(key_specifier)
+          if key_specifier.is_a?(Hash)
+            key_string = key_specifier[Redcar.platform]
+          else
+            key_string = key_specifier
+          end
+          key_string.gsub("Escape", "")
+          key_string.gsub("Space", "")
+          key_string
+        end
+
+        def self.key(key_string)
+          value = 0
+          MODIFIERS.each do |modifier|
+            if key_string =~ /\b#{modifier}\b/
+              value += modifier_values[modifier]
+            end
+          end
+          if key_string =~ /Escape$/
+            value += Swt::SWT::ESC
+          elsif key_string =~ /Space$/
+            value += " "[0]
+          elsif key_string =~ /(F\d+)/
+            value += Swt::SWT.const_get $1
+          elsif key_string =~ /Page Up$/
+            value += Swt::SWT::PAGE_UP
+          elsif key_string =~ /Page Down$/
+            value += Swt::SWT::PAGE_DOWN
+          elsif key_string =~ /(Right|Left|Up|Down)/
+            value += Swt::SWT.const_get 'ARROW_'+$1.upcase
+          elsif key_string =~ /Tab/
+            value += Swt::SWT::TAB
+          elsif key_string =~ /Home$/
+            value += Swt::SWT::HOME
+          elsif key_string =~ /End$/
+            value += Swt::SWT::END
+          else
+            value += key_string[-1]
+          end
+        end
+        
+        def self.modifiers(key_event)
+          modifiers = []
+          modifier_values.each do |string, constant|
+            if (key_event.stateMask & constant) != 0
+              modifiers << string
+            end
+          end
+          modifiers = modifiers.sort_by {|m| MODIFIERS.index(m) }
+        end
+        
+        def self.key_string(key_event)
+          modifiers = modifiers(key_event)
+          if key_event.character == 0
+            modifiers.join("+")
+          else
+            letter = java.lang.Character.new(key_event.character).toString.upcase # key_event.keyCode)
+            if modifiers.any?
+              modifiers.join("+") << "+" << (pretty_letter(letter) || letter)
+            else
+              (pretty_letter(letter) || letter)
+            end
+          end
+        end
+        
+        def self.matches?(key_string, key_string2)
+          key_string.split("+").sort ==
+            key_string2.split("+").sort
+        end
+        
+        def self.pretty_letter(char_string)
+          {"\r" => "Return"}[char_string]
+        end
+        
+        private
+        
+        def self.modifier_values
+          {
+            "Cmd"   => Swt::SWT::COMMAND,
+            "Ctrl"  => Swt::SWT::CTRL,
+            "Alt"   => Swt::SWT::ALT,
+            "Shift" => Swt::SWT::SHIFT,
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,148 @@
+module Redcar
+  class ApplicationSWT
+    class Notebook
+      include Redcar::Observable
+      
+      attr_reader :tab_folder, :model
+      
+      class CTabFolder2Listener
+        def initialize(controller)
+          @controller = controller
+        end
+        
+        def close(event)
+          if event.item
+            tab = @controller.tab_widget_to_tab_model(event.item)
+            unless Redcar.app.events.ignore?(:tab_close, tab)
+              event.doit = false
+              Redcar.app.events.create(:tab_close, tab)
+            end
+          end
+        end
+        
+        def show_list(event); end
+        def maximize(*_); end
+        def minimize(*_); end
+        def restore(*_); end
+      end
+      
+      class SelectionListener
+        def initialize(controller)
+          @controller = controller
+        end
+        
+        def widgetSelected(event)
+          if event.item
+            tab = @controller.tab_widget_to_tab_model(event.item)
+            unless Redcar.app.events.ignore?(:tab_focus, tab)
+              event.doit = false
+              Redcar.app.events.create(:tab_focus, tab)
+            end
+          end
+        end
+        
+        def widgetDefaultSelected(*_)
+        end
+      end
+      
+      def initialize(model, sash)
+        @model = model
+        @model.controller = self
+        create_tab_folder(sash)
+        style_tab_folder
+        attach_model_listeners
+        attach_view_listeners
+      end
+
+      def create_tab_folder(sash)
+        folder_style = Swt::SWT::CLOSE
+        @tab_folder = Swt::Custom::CTabFolder.new(sash, folder_style)
+        font_data = @tab_folder.font.font_data.first
+        font = Swt::Graphics::Font.new(
+          ApplicationSWT.display,
+          font_data.name,
+          Redcar::EditView.font_size - 1,
+          Swt::SWT::NORMAL)
+        @tab_folder.font = font
+        grid_data = Swt::Layout::GridData.new
+        grid_data.grabExcessHorizontalSpace = true
+        grid_data.horizontalAlignment = Swt::Layout::GridData::FILL
+        @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
+        selected_tab_background = Redcar::ApplicationSWT.selected_tab_background
+        @tab_folder.set_selection_background(selected_tab_background.swt_colors, selected_tab_background.swt_stops, true)
+
+        unselected_tab_background = Redcar::ApplicationSWT.unselected_tab_background
+        @tab_folder.set_background(unselected_tab_background.swt_colors, unselected_tab_background.swt_stops, true)
+      end
+      
+      def attach_model_listeners
+        @model.add_listener(:tab_added) do |tab|
+          tab.controller = Redcar.gui.controller_for(tab).new(tab, self)
+        end
+        @model.add_listener(:tab_moved, &method(:model_event_tab_moved))
+      end
+      
+      def attach_view_listeners
+        @tab_folder.add_ctab_folder2_listener(CTabFolder2Listener.new(self))
+        @tab_folder.add_selection_listener(SelectionListener.new(self))
+      end
+      
+      # Called by the models when a tab is selected by Redcar.
+      def model_event_focus_tab(tab)
+        tab_folder.set_selection(tab.item)
+        @model.select_tab!(tab.model)
+      end
+
+      def model_event_tab_moved(from_notebook, to_notebook, tab_model)
+        tab_controller = tab_model.controller
+        title          = tab_model.title
+        tab_controller.set_notebook(to_notebook.controller)
+        tab_controller.create_item_widget
+        tab_controller.move_tab_widget_to_current_notebook
+        tab_controller.focus
+        tab_model.title = title
+      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
+      
+      def tab_widget_to_tab_model(tab_widget)
+        @model.tabs.detect {|tab| tab.controller.item == tab_widget }
+      end
+
+      private
+      
+      def focussed_tab
+        focussed_tab_item = tab_folder.get_selection
+        @model.tabs.detect {|tab| tab.controller.item == focussed_tab_item }
+      end
+      
+    end
+  end
+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
+