redcar 0.2.9dev

data/plugins/application/spec/application/window_spec.rb

@@ -0,0 +1,24 @@
+require File.join(File.dirname(__FILE__), "..", "spec_helper")
+
+describe Redcar::Window do
+  
+  describe "a new window" do
+    before do
+      @window = Redcar::Window.new
+    end  
+    
+    it "notifies the controller that the menu has changed" do
+      @called_menu_changed = false
+      @window.add_listener(:menu_changed) do
+        @called_menu_changed = true
+      end
+      @window.menu = 1
+      @called_menu_changed.should be_true
+    end
+
+    it "has no trees" do
+      @window.trees.length.should == 0
+    end
+    
+  end
+end

data/plugins/application/spec/spec_helper.rb

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

data/plugins/application_swt/lib/application_swt.rb

@@ -0,0 +1,70 @@
+
+require "application_swt/cucumber_runner"
+require "application_swt/dialog_adapter"
+require "application_swt/event_loop"
+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/swt_wrapper"
+require "application_swt/tab"
+require "application_swt/window"
+require "application_swt/swt/grid_data"
+
+module Redcar
+  class ApplicationSWT
+    include Redcar::Controller
+    
+    def self.display
+      @display ||= Swt::Widgets::Display.new
+    end
+    
+    def self.load
+      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)
+      @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}"
+      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
+      @gui
+    end
+    
+    def self.sync_exec(&block)
+      runnable = Swt::RRunnable.new(&block)
+      Redcar::ApplicationSWT.display.syncExec(runnable)
+    end
+    
+    def initialize(app)
+      @app = app
+      add_listeners
+    end
+    
+    def add_listeners
+      @app.add_listener(:new_window, &method(:new_window))
+    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/cucumber_patches.rb

@@ -0,0 +1,118 @@
+
+module Cucumber
+  module Ast
+    class StepInvocation #:nodoc:# 
+
+      def invoke(step_mother, options)
+        block = Swt::RRunnable.new do
+          find_step_match!(step_mother)
+          unless @skip_invoke || options[:dry_run] || @exception || @step_collection.exception
+            @skip_invoke = true
+            begin
+              @step_match.invoke(@multiline_arg)
+              step_mother.after_step
+              status!(:passed)
+            rescue Pending => e
+              failed(options, e, false)
+              status!(:pending)
+            rescue Undefined => e
+              failed(options, e, false)
+              status!(:undefined)
+            rescue Exception => e
+              failed(options, e, false)
+              status!(:failed)
+            end
+          end
+        end
+        Redcar::ApplicationSWT.display.syncExec(block)
+        if ENV["SLOW_CUKES"]
+          sleep ENV["SLOW_CUKES"].to_f
+        end
+      end
+    end
+  end
+
+    #   module Ast
+    #     class TreeWalker
+    #       def visit_steps(steps)
+    #         broadcast(steps) do
+    #           block = Swt::RRunnable.new do
+    #             steps.accept(self)
+    #           end
+    #           Redcar::ApplicationSWT.display.syncExec(block)
+    #         end
+    #       end
+    # 
+    #       def visit_step(step)
+    #         broadcast(step) do
+    #           block = Swt::RRunnable.new do
+    #             step.accept(self)
+    #           end
+    #           Redcar::ApplicationSWT.display.syncExec(block)
+    #         end
+    #       end
+    #     end
+    #   end
+
+  module RbSupport
+    class RbLanguage
+      def require_support_files(path)
+        @step_mother.load_code_files(Cli::Configuration.code_files_in_paths([path]))
+      end
+    end
+    
+    module RbDsl
+      def RequireSupportFiles(path)
+        RbDsl.require_support_files(path)
+      end
+      
+      class << self
+        def require_support_files(path)
+          @rb_language.require_support_files(path)
+        end
+      end
+    end
+    
+    # class RbStepDefinition
+    #   def invoke(args)
+    #     args = args.map{|arg| Ast::PyString === arg ? arg.to_s : arg}
+    #     begin
+    #       args = @rb_language.execute_transforms(args)
+    #       block = Swt::RRunnable.new do
+    #         @rb_language.current_world.cucumber_instance_exec(true, regexp_source, *args, &@proc)
+    #       end
+    #       Redcar::ApplicationSWT.display.syncExec(block)
+    #     rescue Cucumber::ArityMismatchError => e
+    #       e.backtrace.unshift(self.backtrace_line)
+    #       raise e
+    #     end
+    #   end
+    # end
+  end
+  
+  module Cli
+    class Configuration
+      def all_files_to_load
+        requires = @options[:require].empty? ? require_dirs : @options[:require]
+        files = Configuration.code_files_in_paths(requires)
+        remove_excluded_files_from(files)
+        files
+      end
+
+      class << self
+        def code_files_in_paths(requires)
+          files = requires.map do |path|
+            path = path.gsub(/\\/, '/') # In case we're on windows. Globs don't work with backslashes.
+            path = path.gsub(/\/$/, '') # Strip trailing slash.
+            File.directory?(path) ? Dir["#{path}/**/*"] : path
+          end.flatten.uniq
+          files.map!    {|f| File.expand_path(f) }
+          files.reject! {|f| !File.file?(f)}
+          files.reject! {|f| File.extname(f) == '.feature' }
+          files.reject! {|f| f =~ /^http/}
+          files
+        end
+      end
+    end
+  end
+end

data/plugins/application_swt/lib/application_swt/cucumber_runner.rb

@@ -0,0 +1,25 @@
+module Redcar
+  class ApplicationSWT
+    class CucumberRunner
+      START_DELAY = 1
+    
+      def run_features(args)
+        require "cucumber/cli/main"
+        require "cucumber"
+        require "cucumber/rb_support/rb_language"
+        require "application_swt/cucumber_patches"
+        Thread.new do
+          begin
+            sleep START_DELAY
+            main = Cucumber::Cli::Main.new(args)
+            main.execute!(Cucumber::StepMother.new)
+            Redcar.app.quit
+          rescue Object => e
+            puts e.message
+            puts e.backtrace
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Redcar
+  class ApplicationSWT
+    class DialogAdapter
+      def open_file(window, options)
+        file_dialog(window, Swt::SWT::OPEN, options)
+      end
+      
+      def save_file(window, options)
+        file_dialog(window, Swt::SWT::SAVE, options)
+      end
+      
+      private
+      
+      def file_dialog(window, type, options)
+        dialog = Swt::Widgets::FileDialog.new(window.controller.shell, type)
+        if options[:filter_path]
+          dialog.set_filter_path(options[:filter_path])
+        end
+        dialog.open
+      end
+    end
+  end
+end

data/plugins/application_swt/lib/application_swt/event_loop.rb

@@ -0,0 +1,27 @@
+
+module Redcar
+  class ApplicationSWT
+    class EventLoop
+      def initialize
+        @running = false
+      end
+      
+      # Begins the SWT event loop. Blocks.
+      def start
+        @running = true
+        display = ApplicationSWT.display
+        while @running and not display.disposed?
+          unless display.read_and_dispatch
+            display.sleep
+          end
+        end
+        display.dispose
+      end
+      
+      # Halts the SWT event loop.
+      def stop
+        @running = false
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+module Redcar
+  class ApplicationSWT
+    class Menu
+      attr_reader :menu_bar
+      
+      def initialize(window, menu_model)
+        @window = window
+        @menu_bar = Swt::Widgets::Menu.new(window.shell, Swt::SWT::BAR)
+        return unless menu_model
+        @handlers = []
+        add_entries_to_menu(@menu_bar, menu_model)
+      end
+      
+      def close
+        @handlers.each {|obj, h| obj.remove_listener(h)}
+        @menu_bar.dispose
+      end
+      
+      private
+      
+      def add_entries_to_menu(menu, menu_model)
+        menu_model.each do |entry|
+          if 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(@window.shell, Swt::SWT::DROP_DOWN)
+            menu_header.menu = new_menu
+            add_entries_to_menu(new_menu, entry)
+          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, 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))
+            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|
+              item.enabled = value
+            end
+            @handlers << [entry.command, h]
+            if not entry.command.active?
+              item.enabled = false
+            end
+          else
+            raise "unknown object of type #{entry.class} in menu"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+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[Core.platform]
+          else
+            key_string = key_specifier
+          end
+          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
+          value += key_string[-1]
+        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,129 @@
+module Redcar
+  class ApplicationSWT
+    class Notebook
+      include Redcar::Observable
+      
+      attr_reader :tab_folder
+      
+      class CTabFolder2Listener
+        def initialize(controller)
+          @controller = controller
+        end
+        
+        def close(event)
+          @controller.swt_event_tab_closed(event.item)
+        end
+      end
+      
+      class SelectionListener
+        def initialize(controller)
+          @controller = controller
+        end
+        
+        def widgetSelected(event)
+          @controller.swt_event_tab_selected(event.item)
+        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
+        setup_drag_and_drop
+      end
+      
+      def create_tab_folder(sash)
+        folder_style = Swt::SWT::BORDER + Swt::SWT::CLOSE
+        @tab_folder = Swt::Custom::CTabFolder.new(sash, folder_style)
+        grid_data = Swt::Layout::GridData.new(Swt::Layout::GridData::FILL_BOTH)
+        @tab_folder.set_layout_data(grid_data)
+        @tab_folder.pack
+      end
+      
+      def style_tab_folder
+        colors = [
+          Swt::Graphics::Color.new(ApplicationSWT.display, 230, 240, 255),
+          Swt::Graphics::Color.new(ApplicationSWT.display, 170, 199, 246),
+          Swt::Graphics::Color.new(ApplicationSWT.display, 135, 178, 247)
+        ].to_java(Swt::Graphics::Color)
+        percents = [60, 85].to_java(:int)
+        
+        @tab_folder.setSelectionBackground(colors, percents, true)
+      end
+      
+      def setup_drag_and_drop
+        # Doesn't work yet
+        # listener = DragAndDropListener.new(@tab_folder)
+        # @tab_folder.addListener(Swt::SWT::DragDetect, listener)
+        # @tab_folder.addListener(Swt::SWT::MouseUp, listener)
+        # @tab_folder.addListener(Swt::SWT::MouseMove, listener)
+        # @tab_folder.addListener(Swt::SWT::MouseExit, listener)
+        # @tab_folder.addListener(Swt::SWT::MouseEnter, listener)
+      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 SWT event listener when a tab is closed by the user.
+      def swt_event_tab_closed(tab_widget)
+        @model.remove_tab!(tab_widget_to_tab_model(tab_widget))
+      end
+      
+      # Called by the SWT event listener when a tab is selected by the user.
+      def swt_event_tab_selected(tab_widget)
+        @model.select_tab!(tab_widget_to_tab_model(tab_widget))
+      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
+
+      # Called by SWT controllers when the tab is selected by the user.
+      def swt_event_tab_focussed(tab)
+        @model.select_tab!(tab)
+      end
+      
+      def model_event_tab_moved(from_notebook, to_notebook, tab_model)
+        tab_controller = tab_model.controller
+        data           = tab_model.serialize
+        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.deserialize(data)
+      end
+      
+      def dispose
+        @tab_folder.dispose
+      end
+      
+      private
+      
+      def focussed_tab
+        focussed_tab_item = tab_folder.get_selection
+        @model.tabs.detect {|tab| tab.controller.item == focussed_tab_item }
+      end
+      
+      def tab_widget_to_tab_model(tab_widget)
+        @model.tabs.detect {|tab| tab.controller.item == tab_widget }
+      end
+    end
+  end
+end