redcar 0.3.1dev → 0.3.2dev

data/plugins/application/spec/application/speedbar_spec.rb

@@ -0,0 +1,46 @@
+require File.join(File.dirname(__FILE__), "..", "spec_helper")
+
+describe Redcar::Speedbar do
+  it "should let you add labels" do
+    class LabelSpeedbar < Redcar::Speedbar
+      label "Here is a speedbar"
+    end
+    LabelSpeedbar.items.should == [Redcar::Speedbar::LabelItem.new("Here is a speedbar")]
+  end
+
+  it "should let you add toggles" do
+    class ToggleSpeedbar < Redcar::Speedbar
+      toggle :case_sensitive, "Case Sensitive", "Cmd+L"
+    end
+    ToggleSpeedbar.items.should == [Redcar::Speedbar::ToggleItem.new(:case_sensitive, "Case Sensitive", "Cmd+L", nil, false)]
+  end
+  
+  it "should let you add textboxes" do
+    class TextBoxSpeedbar < Redcar::Speedbar
+      textbox :query
+    end
+    TextBoxSpeedbar.items.should == [Redcar::Speedbar::TextBoxItem.new(:query, nil, "")]
+  end
+  
+  it "should let you add buttons" do
+    class ButtonSpeedbar < Redcar::Speedbar
+      button :search, "Ctrl+S"
+    end
+    ButtonSpeedbar.items.should == [Redcar::Speedbar::ButtonItem.new(:search, "Ctrl+S")]
+  end
+
+  it "should let you add keys" do
+    class KeySpeedbar < Redcar::Speedbar
+      key "Ctrl+S"
+    end
+    KeySpeedbar.items.should == [Redcar::Speedbar::KeyItem.new("Ctrl+S")]
+  end
+  
+  it "should let you get values from instances" do
+    class GetValueSpeedbar < Redcar::Speedbar
+      textbox :query, "start"
+    end
+    sp = GetValueSpeedbar.new(self)
+    sp.query.should == "start"
+  end
+end

data/plugins/application/spec/spec_helper.rb

@@ -1,7 +1,7 @@
 $:.push File.join(File.dirname(__FILE__), '..', '..', '..', 'lib')
 require 'redcar'
 Redcar.boot
-Redcar.require_files
+Redcar.load
 Dir[File.dirname(__FILE__) + "/application/controllers/*.rb"].each do |fn|
   require fn
 end

data/plugins/application_swt/lib/application_swt.rb

@@ -1,17 +1,22 @@
 
+SWT_APP_NAME = "Redcar"
+
 require "application_swt/swt_wrapper"
 require "application_swt/swt/listener_helpers"
+require "application_swt/tab"
 
+require "application_swt/clipboard"
 require "application_swt/cucumber_runner"
 require "application_swt/dialog_adapter"
 require "application_swt/dialogs/no_buttons_dialog"
 require "application_swt/dialogs/filter_list_dialog_controller"
 require "application_swt/event_loop"
+require "application_swt/html_tab"
 require "application_swt/menu"
 require "application_swt/menu/binding_translator"
 require "application_swt/notebook"
 require "application_swt/notebook/drag_and_drop_listener"
-require "application_swt/tab"
+require "application_swt/speedbar"
 require "application_swt/treebook"
 require "application_swt/window"
 require "application_swt/swt/grid_data"
@@ -21,25 +26,22 @@ module Redcar
     include Redcar::Controller
     
     def self.display
-      @display ||= Swt::Widgets::Display.new
+      @display ||= Swt.display 
     end
-    
-    def self.load
+
+    def self.start
       Swt::Widgets::Display.app_name = Redcar::Application::NAME
       @gui = Redcar::Gui.new("swt")
       @gui.register_event_loop(EventLoop.new)
       @gui.register_features_runner(CucumberRunner.new)
       @gui.register_controllers(
           Redcar::Tab              => ApplicationSWT::Tab,
+          Redcar::HtmlTab          => ApplicationSWT::HtmlTab,
           Redcar::FilterListDialog => ApplicationSWT::FilterListDialogController
         )
       @gui.register_dialog_adapter(ApplicationSWT::DialogAdapter.new)
     end
     
-    def self.start
-      # add_debug_key_filters
-    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}"
@@ -58,13 +60,18 @@ module Redcar
       Redcar::ApplicationSWT.display.syncExec(runnable)
     end
     
-    def initialize(app)
-      @app = app
+    def initialize(model)
+      @model = model
       add_listeners
+      create_clipboard
     end
     
     def add_listeners
-      @app.add_listener(:new_window, &method(:new_window))
+      @model.add_listener(:new_window, &method(:new_window))
+    end
+    
+    def create_clipboard
+      ApplicationSWT::Clipboard.new(@model.clipboard)
     end
     
     def new_window(win)

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

@@ -13,6 +13,74 @@ module Redcar
         file_dialog(window, 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(window, 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(window.controller.shell, styles)
+        dialog.set_message(text)
+        result = dialog.open
+        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(window, title, message, initial_value, &block)
+        dialog = JFace::Dialogs::InputDialog.new(window.controller.shell,
+                   title, message, initial_value) do |text|
+          block ? block[text] : nil
+        end
+        code = dialog.open
+        button = (code == 0 ? :ok : :cancel)
+        {:button => button, :value => dialog.getValue}
+      end
+      
+      def tool_tip(window, message)
+        tool_tip = Swt::Widgets::ToolTip.new(window.controller.shell, Swt::SWT::ICON_INFORMATION)
+        tool_tip.set_message(message)
+        tool_tip.set_visible(true)
+      end
+      
       private
       
       def file_dialog(window, type, options)

data/plugins/application_swt/lib/application_swt/dialogs/filter_list_dialog_controller.rb

@@ -72,7 +72,7 @@ module Redcar
       def update_list
         @last_keypress = Time.now
         Swt::Widgets::Display.getCurrent.timerExec(300, Swt::RRunnable.new { 
-          if @last_keypress and Time.now - @last_keypress > 0.250
+          if @dialog and @last_keypress and Time.now - @last_keypress > 0.250
             @last_keypress = nil
             s = Time.now
             list = @model.update_list(@dialog.text.get_text)

data/plugins/application_swt/lib/application_swt/html_tab.rb

@@ -0,0 +1,32 @@
+
+module Redcar
+  class ApplicationSWT
+    class HtmlTab < Tab
+      attr_reader :browser
+      
+      def initialize(model, notebook)
+        super
+        @model.add_listener(:changed_title) { |title| @item.text = title }
+      end
+      
+      def create_tab_widget
+        @browser = Swt::Browser.new(notebook.tab_folder, Swt::SWT::NONE)
+        @widget = @browser
+        @item.control = @widget
+      end
+      
+      # Focuses the Browser tab within the CTabFolder, and gives the keyboard
+      # focus to the EditViewSWT.
+      def focus
+        super
+        browser.set_focus
+      end
+      
+      # Close the HtmlTab, disposing of any resources along the way.
+      def close
+        @browser.dispose
+        super
+      end
+    end
+  end
+end

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

@@ -1,19 +1,39 @@
 module Redcar
   class ApplicationSWT
     class Menu
+      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 initialize(window, menu_model)
+      def self.menu_types
+        [Swt::SWT::BAR, Swt::SWT::POP_UP]
+      end
+      
+      def initialize(window, menu_model, type)
+        unless Menu.menu_types.include?(type)
+          raise "type should be in #{Menu.menu_types.inspect}"
+        end
         @window = window
-        @menu_bar = Swt::Widgets::Menu.new(window.shell, Swt::SWT::BAR)
+        @menu_bar = Swt::Widgets::Menu.new(window.shell, type)
         return unless menu_model
         @handlers = []
         add_entries_to_menu(@menu_bar, menu_model)
       end
       
+      def show
+        @menu_bar.set_visible(true)
+      end
+      
       def close
         @handlers.each {|obj, h| obj.remove_listener(h)}
         @menu_bar.dispose
+        @result
       end
       
       private
@@ -30,32 +50,48 @@ module Redcar
             item = Swt::Widgets::MenuItem.new(menu, Swt::SWT::SEPARATOR)
           elsif entry.is_a?(Redcar::Menu::Item)
             item = Swt::Widgets::MenuItem.new(menu, Swt::SWT::PUSH)
-            if entry.command.get_key
-              key_specifier = entry.command.get_key
-              key_string    = BindingTranslator.platform_key_string(key_specifier)
-              item.text = entry.text + "\t" + key_string
-              item.set_accelerator(BindingTranslator.key(key_string))
+            if entry.command.is_a?(Proc)
+              connect_proc_to_item(item, entry)
             else
-              item.text = entry.text
-            end
-            item.addSelectionListener do
-              puts "#{entry.command} activated"
-              entry.selected
-            end
-            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
+              connect_command_to_item(item, entry)
             end
           else
             raise "unknown object of type #{entry.class} in menu"
           end
         end
       end
+      
+      def connect_proc_to_item(item, entry)
+        item.text = entry.text
+        item.add_selection_listener { entry.command[] }
+      end
+      
+      def connect_command_to_item(item, entry)
+        if key_specifier = entry.command.get_key
+          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.addSelectionListener do
+          entry.selected
+        end
+        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

@@ -6,10 +6,12 @@ module Redcar
         
         def self.platform_key_string(key_specifier)
           if key_specifier.is_a?(Hash)
-            key_string = key_specifier[Core.platform]
+            key_string = key_specifier[Redcar.platform]
           else
             key_string = key_specifier
           end
+          key_string.gsub("Escape", "")
+          key_string.gsub("Space", "")
           key_string
         end
 
@@ -20,7 +22,42 @@ module Redcar
               value += modifier_values[modifier]
             end
           end
-          value += key_string[-1]
+          if key_string =~ /Escape$/
+            value += Swt::SWT::ESC
+          elsif key_string =~ /Space$/
+            value += " "[0]
+          else
+            value += key_string[-1]
+          end
+        end
+        
+        def self.key_string(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) }
+          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