redcar-dev 0.12.17dev

data/plugins/application_swt/lib/application_swt.rb

@@ -0,0 +1,218 @@
+
+require 'swt/full'
+
+require "application_swt/tab"
+
+require "application_swt/clipboard"
+require "application_swt/dialog_adapter"
+require "application_swt/dialogs/no_buttons_dialog"
+require "application_swt/dialogs/text_and_file_dialog"
+require "application_swt/dialogs/filter_list_dialog_controller"
+require "application_swt/dialogs/input_dialog"
+require "application_swt/dialogs/modeless_dialog"
+require "application_swt/dialogs/modeless_html_dialog"
+require "application_swt/dialogs/modeless_list_dialog_controller"
+require "application_swt/gradient"
+require "application_swt/html_tab"
+require "application_swt/icon"
+require "application_swt/listener_helpers"
+require "application_swt/menu"
+require "application_swt/menu/binding_translator"
+require "application_swt/toolbar"
+require "application_swt/toolbar/binding_translator"
+require "application_swt/notebook"
+require "application_swt/notebook/tab_transfer"
+require "application_swt/notebook/tab_drag_and_drop_listener"
+require "application_swt/speedbar"
+require "application_swt/treebook"
+require "application_swt/window"
+
+require "dist/application_swt"
+
+module Redcar
+  class ApplicationSWT
+    include Redcar::Controller
+    
+    attr_reader :fake_shell
+
+    def self.display
+      @display ||= Swt.display
+    end
+
+    def self.start
+      if Redcar.gui
+        Redcar.gui.register_controllers(
+            Redcar::Tab                => ApplicationSWT::Tab,
+            Redcar::HtmlTab            => ApplicationSWT::HtmlTab,
+            Redcar::FilterListDialog   => ApplicationSWT::FilterListDialogController,
+            Redcar::ModelessListDialog => ApplicationSWT::ModelessListDialogController
+          )
+        Redcar.gui.register_dialog_adapter(ApplicationSWT::DialogAdapter.new)
+      end
+    end
+
+    def self.selected_tab_background
+      Gradient.new(Redcar::ApplicationSWT.storage['selected_tab_background'])
+    end
+
+    def self.unselected_tab_background
+      Gradient.new(Redcar::ApplicationSWT.storage['unselected_tab_background'])
+    end
+
+    def self.tree_background
+      Gradient.new(Redcar::ApplicationSWT.storage['tree_background'])
+    end
+
+    def self.storage
+      @storage ||= begin
+        storage = Plugin::Storage.new('application_swt')
+        storage.set_default('selected_tab_background', {0 => "#FEFEFE", 100 => "#EEEEEE"})
+        storage.set_default('unselected_tab_background', {0 => "#E5E5E5", 100 => "#D0D0D0"})
+        storage.set_default('tree_background', "#FFFFFF")
+        storage
+      end
+    end
+
+    def self.add_debug_key_filters
+      display.add_filter(Swt::SWT::KeyDown) do |a|
+        puts "type: #{a.type}, keyCode: #{a.keyCode}, character: #{a.character}, statemask: #{a.stateMask}"
+      end
+      display.add_filter(Swt::SWT::KeyUp) do |a|
+        puts "type: #{a.type}, keyCode: #{a.keyCode}, character: #{a.character}, statemask: #{a.stateMask}"
+      end
+    end
+
+    def self.gui
+      Redcar.gui
+    end
+
+    class ShellListener
+      def shell_deactivated(_)
+        Swt.timer_exec(100) do
+          unless Swt::Widgets::Display.get_current.get_active_shell
+            Redcar.app.lost_application_focus
+          end
+        end
+      end
+
+      def shell_activated(_)
+        Redcar.app.gained_application_focus
+      end
+
+      def shell_closed(_);      end
+      def shell_deiconified(_); end
+      def shell_iconified(_);   end
+    end
+
+    # ALL new shells must be registered here, otherwise Redcar will
+    # get confused about when it has lost the application focus.
+    def self.register_shell(shell)
+      shell.add_shell_listener(ShellListener.new)
+    end
+
+    def self.shell_dialogs
+      @shell_dialogs ||= {}
+    end
+
+    def self.register_dialog(shell, dialog)
+      shell_dialogs[shell] = dialog
+    end
+
+    def self.unregister_dialog(dialog)
+      shell_dialogs.delete(shell_dialogs.invert[dialog])
+    end
+
+    def initialize(model)
+      @model = model
+      add_listeners
+      add_swt_listeners
+      create_clipboard
+      create_fake_window
+    end
+
+    def fake_shell
+      @fake_shell
+    end
+
+    def create_fake_window
+      @fake_shell = Swt::Widgets::Shell.new(ApplicationSWT.display, Swt::SWT::NO_TRIM)
+      @fake_shell.open
+      @fake_shell.set_size(0, 0)
+      @fake_shell.set_visible(false) unless Redcar.platform == :osx
+    end
+
+    class FakeWindow
+      def initialize(shell)
+        @shell = shell
+      end
+
+      attr_reader :shell
+    end
+
+    def refresh_menu
+      if Redcar.platform == :osx and @fake_shell
+        old_menu_bar = @fake_shell.menu_bar
+        fake_menu_controller = ApplicationSWT::Menu.new(FakeWindow.new(@fake_shell), Redcar.app.main_menu, Redcar.app.main_keymap, Swt::SWT::BAR)
+        fake_shell.menu_bar = fake_menu_controller.menu_bar
+        old_menu_bar.dispose if old_menu_bar
+      end
+    end
+
+    def refresh_toolbar
+      # if Redcar.platform == :osx and @fake_shell
+      #   fake_toolbar_controller = ApplicationSWT::ToolBar.new(FakeWindow.new(@fake_shell), Redcar.app.main_toolbar, Swt::SWT::FLAT)
+      # end
+    end
+
+    def add_listeners
+      @model.add_listener(:new_window, &method(:new_window))
+      @model.add_listener(:refresh_menu, &method(:refresh_menu))
+    end
+
+    class CocoaUIListener
+
+      def initialize(name)
+        @name = name
+      end
+
+      def handle_event(e)
+        if    @name == :prefs
+          Redcar::PluginManagerUi::OpenPreferencesCommand.new.run
+        elsif @name == :about
+          Redcar::Top::AboutCommand.new.run
+        elsif @name == :quit
+          unless Redcar.app.events.ignore?(:application_close, Redcar.app)
+            e.doit = false
+            Redcar.app.events.create(:application_close, Redcar.app)
+          end
+        else
+          Application::Dialog.message_box("#{@name} menu is not hooked up yet")
+        end
+      end
+    end
+
+    def add_swt_listeners
+      if Redcar.platform == :osx
+        enhancer = com.redcareditor.application_swt.CocoaUIEnhancer.new("Redcar")
+        enhancer.hook_application_menu(
+          ApplicationSWT.display,
+          CocoaUIListener.new(:quit),
+          CocoaUIListener.new(:about),
+          CocoaUIListener.new(:prefs)
+        )
+      end
+    end
+
+    def create_clipboard
+      ApplicationSWT::Clipboard.new(@model.clipboard)
+    end
+
+    def new_window(win)
+      win.controller = ApplicationSWT::Window.new(win)
+    end
+
+    def menu_changed
+      Menu.new(self, @model.menu)
+    end
+  end
+end

data/plugins/application_swt/lib/application_swt/bring_to_front.rb

@@ -0,0 +1,53 @@
+
+gem "ffi"
+require 'ffi'
+
+module Redcar
+  class ApplicationSWT
+    class Window
+        # it appears that swt offers no real way to
+        # bring a window to the front
+        # force_active doesn't seem to work as expected, at least on doze
+        # http://stackoverflow.com/questions/2315560/how-do-you-force-a-java-swt-program-to-move-itself-to-the-foreground
+        # this hack around seems to work for windows.
+      module BringToFront
+        extend FFI::Library
+        ffi_lib 'user32', 'kernel32'
+        ffi_convention :stdcall
+        attach_function :GetForegroundWindow, [], :long
+        attach_function :SetForegroundWindow, [:long], :int
+        attach_function :GetWindowThreadProcessId, [:long, :pointer], :int
+        attach_function :AttachThreadInput, [:int, :int, :int], :int
+        attach_function :GetCurrentThreadId, [], :int # unused
+
+        def self.bring_window_to_front hwnd_int
+          wanted = hwnd_int
+          top_window = BringToFront.GetForegroundWindow
+          if top_window == 0
+            # should be able to set it without delay?
+            if(BringToFront.SetForegroundWindow(wanted) > 0)
+              return true
+            end
+          end
+          top_pid = BringToFront.GetWindowThreadProcessId(top_window, nil)
+          wanted_pid = BringToFront.GetWindowThreadProcessId(hwnd_int, nil)
+          if top_pid == wanted_pid
+            if(BringToFront.SetForegroundWindow(wanted))
+              return true
+            end
+          end
+          if top_pid > 0 && wanted_pid > 0
+            if (BringToFront.AttachThreadInput(wanted_pid,top_pid,1) == 0)
+              return false
+            end
+            BringToFront.SetForegroundWindow(wanted) 
+            BringToFront.AttachThreadInput(wanted_pid, top_pid,0)
+            return true
+          else
+            return false
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/application_swt/lib/application_swt/clipboard.rb

@@ -0,0 +1,42 @@
+module Redcar
+  class ApplicationSWT
+  
+    # The controller for a Clipboard. In SWT a clipboard can only contain
+    # one piece of text, but that's ok because inside Redcar all the Paste 
+    # commands are implemented directly from the model. This is only useful
+    # for copying/pasting between other applications and Redcar.
+    class Clipboard
+      attr_accessor :last_set
+    
+      def initialize(model)
+        @model = model
+        @model.controller = self
+        @swt_clipboard = Swt::DND::Clipboard.new(Redcar.app.controller.display)
+        attach_model_listeners
+        if contents = get_contents
+          @model.silently_add([contents])
+        end
+      end
+      
+      def plain_text_data_type
+        Swt::DND::TextTransfer.get_instance
+      end
+      
+      def attach_model_listeners
+        @model.add_listener(:added_internal) do |text|
+          text = text.join("\n")
+          @last_set = text
+          @swt_clipboard.set_contents([text].to_java(:object), [plain_text_data_type].to_java(Swt::DND::Transfer))
+        end
+      end
+      
+      def changed?
+        @last_set != get_contents
+      end
+      
+      def get_contents
+        @swt_clipboard.get_contents(plain_text_data_type)
+      end
+    end
+  end
+end

data/plugins/application_swt/lib/application_swt/dialog_adapter.rb

@@ -0,0 +1,180 @@
+module Redcar
+  class ApplicationSWT
+    class DialogAdapter
+      def open_file(options)
+        file_dialog(Swt::SWT::OPEN, options)
+      end
+
+      def open_directory(options)
+        directory_dialog(options)
+      end
+
+      def save_file(options)
+        file_dialog(Swt::SWT::SAVE, options)
+      end
+
+      MESSAGE_BOX_TYPES = {
+        :info     => Swt::SWT::ICON_INFORMATION,
+        :error    => Swt::SWT::ICON_ERROR,
+        :question => Swt::SWT::ICON_QUESTION,
+        :warning  => Swt::SWT::ICON_WARNING,
+        :working  => Swt::SWT::ICON_WORKING
+      }
+
+      BUTTONS = {
+        :yes    => Swt::SWT::YES,
+        :no     => Swt::SWT::NO,
+        :cancel => Swt::SWT::CANCEL,
+        :retry  => Swt::SWT::RETRY,
+        :ok     => Swt::SWT::OK,
+        :abort  => Swt::SWT::ABORT,
+        :ignore => Swt::SWT::IGNORE
+      }
+
+      MESSAGE_BOX_BUTTON_COMBOS = {
+        :ok                 => [:ok],
+        :ok_cancel          => [:ok, :cancel],
+        :yes_no             => [:yes, :no],
+        :yes_no_cancel      => [:yes, :no, :cancel],
+        :retry_cancel       => [:retry, :cancel],
+        :abort_retry_ignore => [:abort, :retry, :ignore]
+      }
+
+      def message_box(text, options)
+        styles = 0
+        styles = styles | MESSAGE_BOX_TYPES[options[:type]] if options[:type]
+        if options[:buttons]
+          buttons = MESSAGE_BOX_BUTTON_COMBOS[options[:buttons]]
+          buttons.each {|b| styles = styles | BUTTONS[b] }
+        end
+        dialog = Swt::Widgets::MessageBox.new(parent_shell, styles)
+        dialog.set_message(text)
+        result = nil
+        Redcar.app.protect_application_focus do
+          EditView.protect_edit_view_focus do
+            result = dialog.open
+          end
+        end
+        BUTTONS.invert[result]
+      end
+
+      def buttons
+        BUTTONS.keys
+      end
+
+      def available_message_box_types
+        MESSAGE_BOX_TYPES.keys
+      end
+
+      def available_message_box_button_combos
+        MESSAGE_BOX_BUTTON_COMBOS.keys
+      end
+
+      def input(title, message, initial_value, &block)
+        dialog = Dialogs::InputDialog.new(
+                   parent_shell,
+                   title, message, :initial_text => initial_value) do |text|
+          block ? block[text] : nil
+        end
+        code = dialog.open
+        button = (code == 0 ? :ok : :cancel)
+        {:button => button, :value => dialog.value}
+      end
+
+      def password_input(title, message)
+        dialog = Dialogs::InputDialog.new(parent_shell, title, message, :password => true)
+        code = dialog.open
+        button = (code == 0 ? :ok : :cancel)
+        {:button => button, :value => dialog.value}
+      end
+
+      def tool_tip(message, location)
+        tool_tip = Swt::Widgets::ToolTip.new(parent_shell, Swt::SWT::ICON_INFORMATION)
+        tool_tip.set_message(message)
+        tool_tip.set_location(*get_coordinates(location))
+        tool_tip.set_visible(true)
+      end
+
+      def popup_menu(menu, location)
+        window = Redcar.app.focussed_window
+        menu   = ApplicationSWT::Menu.new(window.controller, menu, nil, Swt::SWT::POP_UP)
+        menu.move(*get_coordinates(location))
+        menu.show
+      end
+
+      def popup_text(title, message, location,dimensions=nil)
+        if dimensions
+          box = ApplicationSWT::ModelessDialog.new(title,message,dimensions[0],dimensions[1])
+        else
+          box = ApplicationSWT::ModelessDialog.new(title,message)
+        end
+        box.open(parent_shell,*get_coordinates(location))
+      end
+
+      def popup_html(text,location,dimensions=nil)
+        if dimensions
+          box = ApplicationSWT::ModelessHtmlDialog.new(text,dimensions[0],dimensions[1])
+        else
+          box = ApplicationSWT::ModelessHtmlDialog.new(text)
+        end
+        box.open(parent_shell,*get_coordinates(location))
+      end
+
+      private
+
+      def get_coordinates(location)
+        edit_view = EditView.focussed_tab_edit_view
+        if (location == :cursor or location.to_s =~ /^(\d+)$/) and not edit_view
+          location = :pointer
+        end
+        case location
+        when :cursor
+          x, y = Swt::GraphicsUtils.pixel_location_at_offset(edit_view.cursor_offset)
+        when :below_cursor
+          x, y = Swt::GraphicsUtils.below_pixel_location_at_offset(edit_view.cursor_offset)
+        when :pointer
+          location = ApplicationSWT.display.get_cursor_location
+          x, y = location.x, location.y
+        else
+          if location.to_s =~ /^(\d+)$/
+            x, y = Swt::GraphicsUtils.pixel_location_at_offset($1.to_i)
+          end
+        end
+        [x, y]
+      end
+
+      def file_dialog(type, options)
+        dialog = Swt::Widgets::FileDialog.new(parent_shell, type)
+        dialog.setText("Save File")
+        dialog.setOverwrite(true)
+        if options[:filter_path]
+          dialog.setText("Save File As") if type == Swt::SWT::SAVE
+          dialog.setText("Open File") if type == Swt::SWT::OPEN
+          dialog.set_filter_path(options[:filter_path])
+        end
+        Redcar.app.protect_application_focus do
+          dialog.open
+        end
+      end
+
+      def directory_dialog(options)
+        dialog = Swt::Widgets::DirectoryDialog.new(parent_shell)
+        dialog.setText("Open Directory")
+        if options[:filter_path]
+          dialog.set_filter_path(options[:filter_path])
+        end
+        Redcar.app.protect_application_focus do
+          dialog.open
+        end
+      end
+
+      def parent_shell
+        if focussed_window = Redcar.app.focussed_window
+          focussed_window.controller.shell
+        else
+          Redcar.app.controller.fake_shell
+        end
+      end
+    end
+  end
+end