operawatir 0.4.3.pre1-jruby → 0.5-jruby

data/lib/operawatir/browser.rb

@@ -2,10 +2,10 @@
 class OperaWatir::Browser
   include Deprecated
 
-  attr_accessor :driver, :active_window, :preferences, :keys, :spatnav
+  attr_accessor :driver, :active_window, :preferences, :keys, :spatnav, :utils
 
   def self.settings=(settings={})
-    @opera_driver_settings = nil  # Bust cache
+    @desired_capabilities = nil  # Bust cache
     @settings = settings
   end
 
@@ -22,11 +22,12 @@ class OperaWatir::Browser
   def initialize
     OperaWatir.compatibility! unless OperaWatir.api >= 3
 
-    self.driver        = OperaDriver.new(self.class.opera_driver_settings)
+    self.driver        = OperaDriver.new(self.class.desired_capabilities)
     self.active_window = OperaWatir::Window.new(self)
     self.preferences   = OperaWatir::Preferences.new(self)
     self.keys          = OperaWatir::Keys.new(self)
     self.spatnav       = OperaWatir::Spatnav.new(self)
+    self.utils         = OperaWatir::Utils.new(self)
   end
 
   alias_method :window, :active_window
@@ -48,14 +49,7 @@ class OperaWatir::Browser
 
   # Instruct the browser instance to quit and shut down.
   def quit
-    driver.shutdown
-  end
-
-  # Closes all windows.
-  #
-  # TODO This should be on Windows
-  def close_all
-    driver.closeAll
+    driver.quit
   end
 
   # Get the version number of the driver.  This _is not_ the same as
@@ -106,6 +100,7 @@ class OperaWatir::Browser
   def opera_action(name, *args)
     driver.operaAction(name, args.to_java(:string))
   end
+
   deprecated :opera_action
 
   # Full list of available Opera actions in the Opera build you're
@@ -116,8 +111,9 @@ class OperaWatir::Browser
   #
   # @return [String] List of available Opera actions.
   def opera_action_list
-    driver.getOperaActionList.to_s
+    driver.getOperaActionList.to_a
   end
+
   deprecated :opera_action_list
 
   # Selects all content in the currently focused element.  Equivalent
@@ -195,16 +191,24 @@ class OperaWatir::Browser
 
   deprecated :key, 'browser.keys.send'
 
+  # actions
+
+  def actions
+    OperaWatir::Actions.new(browser)
+  end
+
 private
 
-  def self.opera_driver_settings
-    @opera_driver_settings ||= OperaDriverSettings.new.tap { |s|
-      s.setAutostart false if self.settings[:manual]
-      s.setOperaLauncherBinary self.settings[:launcher] if self.settings[:launcher]
-      s.setOperaBinaryLocation self.settings[:path] if self.settings[:path]
-      s.setOperaBinaryArguments self.settings[:args].to_s if self.settings[:args]
-      s.setNoQuit true if self.settings[:no_quit]
-      s.setUseOperaIdle true if self.settings[:opera_idle] or ENV['OPERA_IDLE'].truthy?
+  def self.desired_capabilities
+    @desired_capabilities ||= DesiredCapabilities.new.tap { |s|
+      s.setCapability('opera.logging.level', self.settings[:logging_level]) if self.settings[:logging_level]
+      s.setCapability('opera.logging.file', self.settings[:logging_file]) if self.settings[:logging_file]
+      s.setCapability('opera.autostart', false) if self.settings[:manual]
+      s.setCapability('opera.launcher', self.settings[:launcher]) if self.settings[:launcher]
+      s.setCapability('opera.binary', self.settings[:path]) if self.settings[:path]
+      s.setCapability('opera.arguments', self.settings[:args].to_s) if self.settings[:args]
+      s.setCapability('opera.no_quit', true) if self.settings[:no_quit]
+      s.setCapability('opera.idle', true) if self.settings[:opera_idle] or ENV['OPERA_IDLE'].truthy?
     }
   end
 

data/lib/operawatir/clickable_item.rb

@@ -0,0 +1,68 @@
+module OperaWatir
+  module ClickableItem
+
+    ######################################################################
+    # Clicks the button, and waits for loading to finish
+    #
+    # @return [int] Window ID of the window shown or 0 if no window is shown
+    #
+    # @raise [DesktopExceptions::WidgetNotVisibleException] if the button
+    #            is not visible
+    #
+    def load_page_with_click
+      wait_start
+      click
+      # Just wait for the load
+      wait_for_window_loaded("")
+    end
+
+    ######################################################################
+    # Clicks the button, and waits for the window with window name
+    # win_name to be shown
+    #
+    # @param [String] win_name name of the window that will be opened (Pass a blank string for any window)
+    #
+    # @return [int] Window ID of the window shown or 0 if no window is shown
+    #
+    # @raise [DesktopExceptions::WidgetNotVisibleException] if the button
+    #            is not visible
+    #
+    def open_window_with_click(win_name)
+      wait_start
+      click
+      wait_for_window_shown(win_name)
+    end
+    alias_method :open_dialog_with_click, :open_window_with_click
+
+    ######################################################################
+    # Clicks item and waits for the menu to close
+    #
+    # @return name of menu closed
+    #
+    def close_menu_with_click(menu_name)
+      wait_start
+      click
+      wait_for_menu_closed(menu_name)
+    end
+
+    ######################################################################
+    # Clicks the item, and waits for the menu with menu with name
+    # menu_name to be shown
+    #
+    # @param [String] name of menu that should open
+    #
+    # @raise [DesktopExceptions::WidgetNotVisibleException] if the button
+    #            is not visible
+    #
+    # @return name of menu opened if it matches the parameter menu_name,
+    #           otherwise returns empty string
+    #
+    def open_menu_with_click(menu_name)
+      wait_start
+      click
+      wait_for_menu_shown(menu_name)
+    end
+
+
+  end
+end

data/lib/operawatir/compat.rb

@@ -1,5 +1,5 @@
 module OperaWatir
-  
+
   module Compat; end
 
   # Switches on compatibility layer (Watir 2 API).
@@ -7,12 +7,12 @@ module OperaWatir
     require 'operawatir/compat/browser'
     require 'operawatir/compat/element_finders'
     require 'operawatir/compat/window'
-    
+
     Browser.send :include, Compat::Browser
     Window.send :include, Compat::ElementFinders
     Window.send :include, Compat::Window
     Collection.send :include, Compat::ElementFinders
-    
+
     # TODO Ruby Modules can't override methods defined in their included klass
     #   Requiring the files is OK, but there needs to be some way of detecting
     #   that we are in compatibility mode.
@@ -21,5 +21,5 @@ module OperaWatir
     require 'operawatir/compat/collection'
     require 'operawatir/compat/element'
   end
-  
+
 end

data/lib/operawatir/compat/collection.rb

@@ -26,7 +26,7 @@ class OperaWatir::Collection
     elsif args.first == :index
       type, value = :index, args[1].to_i - 1
 
-	# Handle a hash of selectors
+    # Handle a hash of selectors
     elsif args.length == 1 and  args.first.is_a? Hash
       args.first.each_pair do |k, v|
         s = add_selector_from_arguments([k, v], default_method)

data/lib/operawatir/compat/element.rb

@@ -74,7 +74,7 @@ class OperaWatir::Element
   # @param [optional, Fixnum] y The offset from the top of the element
   #
 
-  def click(x=0, y=0)
+  def click(x=1, y=1)
     assert_enabled!
     node.click(x.to_i, y.to_i)
   end

data/lib/operawatir/compat/window.rb

@@ -64,11 +64,12 @@ module OperaWatir
         driver.switch_to.default_content
       end
 
-      
+
       def show_frames
         frames = driver.list_frames
-        puts "There are #{frames.length.to_s} frames"
-        frames.each_with_index { |frame, i| puts "frame index: #{(i.to_i + 1).to_s} name: #{frame.to_s}" }
+        text = "There are #{frames.length.to_s} frames\n"
+        frames.each_with_index { |frame, i| text << "frame index: #{(i.to_i + 1).to_s} name: #{frame.to_s}\n" }
+        text
       end
 
     end

data/lib/operawatir/desktop_browser.rb

@@ -2,11 +2,13 @@ module OperaWatir
   class DesktopBrowser < Browser
     include DesktopContainer
     include DesktopCommon
-    
+
+    ConditionTimeout = 10.0
+
     LoadActions = ["Open url in new page", "Open url in current page", "Open url in new background page",
-      "Open url in new window", "New private page", "Paste and go", "Paste and go background", 
-      "Hotclick search", "Duplicate page", "Reopen page", "Back", "Forward", "Help"]
-    
+      "Open url in new window", "New private page", "Paste and go", "Paste and go background",
+      "Hotclick search", "Duplicate page", "Reopen page", "Back", "Forward", "Help", "Autocomplete server name"]
+
     # @private
     def initialize
       OperaWatir.compatibility! unless OperaWatir.api >= 3
@@ -18,22 +20,26 @@ module OperaWatir
       self.spatnav       = OperaWatir::Spatnav.new(self)
     end
 
+    #def running?
+    #  driver.isOperaRunning()
+    #end
+
     # @private
-    # Hack overload to allow for timing of the OnLoaded event that can cause 
-    # dialogs to autoclose in Dialog.cpp when then OnUrlChanged is fired 
+    # Hack overload to allow for timing of the OnLoaded event that can cause
+    # dialogs to autoclose in Dialog.cpp when then OnUrlChanged is fired
     # after a dialog is opened
     def goto(url = "")
       active_window.url = url
       sleep(1)
     end
-    
+
     ######################################################################
     # Quits Opera
     #
     def quit_opera
       driver.quitOpera
     end
-    
+
     ######################################################################
     # Restarts Opera
     #
@@ -41,14 +47,22 @@ module OperaWatir
       driver.quitOpera
       driver.startOpera
     end
-    
+
     ######################################################################
     # Quits the driver without exiting Opera
     #
     def quit_driver
       driver.quitDriver
     end
-      
+
+    ######################################################################
+    #
+    # Get ID of active Desktop UI window
+    #
+    def active_quick_window_id
+      driver.getActiveQuickWindowID()
+    end
+
     ######################################################################
     # Executes the action given by action_name, and waits for
     # the window with window name win_name to be shown
@@ -67,14 +81,14 @@ module OperaWatir
       if LoadActions.include?(action_name) then
         raise(DesktopExceptions::UnsupportedActionException, "Action #{action_name} not supported")
       end
-      
+
       wait_start
       opera_desktop_action(action_name, *params)
       wait_for_window_shown(win_name)
     end
-    
+
     alias_method :open_dialog_with_action, :open_window_with_action
-    
+
     ######################################################################
     # Executes the action given by action_name, and waits for
     # the window with window name win_name to be loaded
@@ -89,7 +103,7 @@ module OperaWatir
     #
     # @return [int] Window ID of the window shown or 0 if no window is shown
     def load_window_with_action(win_name, action_name, *params)
-      if LoadActions.include?(action_name) 
+      if LoadActions.include?(action_name)
         wait_start
         opera_desktop_action(action_name, *params)
         wait_for_window_loaded(win_name)
@@ -117,14 +131,17 @@ module OperaWatir
       key_press_direct(key, *modifiers)
       wait_for_window_shown(win_name)
     end
-    
+
     alias_method :open_dialog_with_key_press, :open_window_with_key_press
-    
+
     ######################################################################
     # Clicks the key and modifiers and waits for a new tab to be activated
     #
+    # @example
+    #     browser.activate_tab_with_key_press("F6", :ctrl)
+    #
     # @param [String]  key         key to press (e.g. "a" or "backspace")
-    # @param [Symbol]  modifiers   optional modifier(s) to hold down while pressing 
+    # @param [Symbol]  modifiers   optional modifier(s) to hold down while pressing
     #                                the key (e.g. :shift, :ctrl, :alt, :meta)
     #
     # @return [int] Window ID of the document window (tab) that is activated, or 0 if no tab
@@ -133,22 +150,26 @@ module OperaWatir
     def activate_tab_with_key_press(key, *modifiers)
       wait_start
       # TODO: FIXME. key_down and up are not yet implemented on mac and windows
-      if linux? 
-        key_down(key,*modifiers)
-        key_up(key, *modifiers)
+      if linux?
+        key_down_direct(key,*modifiers)
+        key_up_direct(key, *modifiers)
       else
         key_press_direct(key, *modifiers)
       end
       wait_for_window_activated("Document Window")
      end
-    
+
     ######################################################################
     # Opens a new tab and loads the url entered, then waits for
     # a dialog to be shown based on the url entered
     #
-    # @param [String] dialog_name name of the dialog that will be opened 
+    # @example
+    #     browser.open_dialog_with_url("Setup Apply Dialog Confirm Dialog", \
+    #              "http://t/platforms/desktop/bts/DSK-316777/001-1.ini")
+    #
+    # @param [String] dialog_name name of the dialog that will be opened
     #                       (Pass a blank string for any window)
-    # @param [String] url to load 
+    # @param [String] url to load
     #
     # @return [int] Window ID of the dialog opened or 0 if no window is opened
     #
@@ -158,7 +179,7 @@ module OperaWatir
       # The loading of the page will happen first then the dialog will be shown
       wait_for_window_shown(dialog_name)
     end
-    
+
     ######################################################################
     # Executes the action given by action_name, and waits for
     # the window with window name win_name to close
@@ -175,12 +196,12 @@ module OperaWatir
     #
     def close_window_with_action(win_name, action_name, *params)
       wait_start
-      opera_desktop_action(action_name, *params) 
+      opera_desktop_action(action_name, *params)
       wait_for_window_close(win_name)
     end
-    
+
     alias_method :close_dialog_with_action, :close_window_with_action
-    
+
     ######################################################################
     # Presses the key, with optional modifiers, and waits for
     # the window with window name win_name to close
@@ -200,13 +221,16 @@ module OperaWatir
       key_press_direct(key, *opts)
       wait_for_window_close(win_name)
     end
-    
+
     alias_method :close_dialog_with_key_press, :close_window_with_key_press
-    
+
     ######################################################################
     # Close the dialog with name dialog_name, using the "Cancel" action
     #
-    # @param [String] dialog_name name of the dialog that will be closed 
+    # @example
+    #   browser.close_dialog("New Preferences Dialog")
+    #
+    # @param [String] dialog_name name of the dialog that will be closed
     #                 (Pass a blank string for any window)
     #
     # @return [int] Window ID of the dialog closed or 0 if no window is closed
@@ -216,7 +240,7 @@ module OperaWatir
       opera_desktop_action("Cancel")
       wait_for_window_close(dialog_name)
     end
-      
+
     ######################################################################
     # Sets the alignment of a toolbar or panel
     #
@@ -226,11 +250,11 @@ module OperaWatir
     #
     def set_alignment_with_action(toolbar_name, alignment)
       opera_desktop_action("Set alignment", toolbar_name, alignment)
-      sleep(0.1) 
+      sleep(0.1)
     end
 
     ######################################################################
-    # Retrieves an array of all widgets in the window with window 
+    # Retrieves an array of all widgets in the window with window
     # name win_name
     #
     # @example
@@ -243,15 +267,15 @@ module OperaWatir
     # @return [Array] Array of widgets retrieved from the window
     #
     def widgets(window)
-      
+
       # If window specifies window name, and the active window has this name
       # use its id to get the widgets,
       if window.is_a? String
         active_win_id = driver.getActiveQuickWindowID()
         active_win_name = driver.getQuickWindowName(active_win_id)
-        
+
         #If the active window is of same type, then grab that one, not first
-        if active_win_name == window #e.g. Both Document Window 
+        if active_win_name == window #e.g. Both Document Window
           window = active_win_id
         end
       end
@@ -282,11 +306,14 @@ module OperaWatir
         end
       end.to_a
     end
-   
+
     alias_method :quick_widgets, :widgets
-    
+
     ####################################################
-    # Retrieves an array of all windows 
+    # Retrieves an array of all windows
+    #
+    # @example
+    #     browser.quick_windows.each { |win| puts win.to_s }
     #
     # @return [Array] Array of windows
     #
@@ -295,28 +322,31 @@ module OperaWatir
         QuickWindow.new(self,java_window)
       end.to_a
     end
-    
+
     ####################################################
     # Retrieves an array of all tabs (Document Windows)
     #
+    # @example
+    #    browser.open_pages.length.should == 2
+    #
     # @return [Array] Array of windows
     #
     def open_pages
       quick_windows.select { |win| win.name == "Document Window" }
     end
-    
+
     #@private
     # Not needed as quick_tabs is def. below
     #def tab_buttons
     #  widgets("Browser Window").select { | w | w.type == :tabbutton }
     #end
-    
+
 #=begin
     # Return collection for each widget type
     # example browser.quick_buttons
     #         browser.quick_treeitems
     #         ....
-    #    
+    #
     WIDGET_ENUM_MAP.keys.each do |widget_type|
       my_type = "quick_" << widget_type.to_s
       type = my_type
@@ -330,7 +360,63 @@ module OperaWatir
       end
     end
 #=end
-    
+
+    #TODO
+    def quick_menus
+      driver.getQuickMenuList().map do |java_menu|
+        QuickMenu.new(self, java_menu)
+      end.to_a
+    end
+
+    #TODO
+    def quick_menuitems
+      driver.getQuickMenuItemList().map do |java_item|
+        QuickMenuItem.new(self, java_item)
+      end.to_a
+    end
+
+    #####################################################################
+    #
+    # Closes the active menu
+    #
+    def close_active_menu
+      wait_start
+
+      menus = quick_menus
+      main = menus.select {|menu| menu.name == "Main Menu"}
+      main_open = main.length > 0
+      real_submenu = main_open ? (menus.length > 2) : menus.length > 1
+
+      if real_submenu
+        key_press_direct("Left")
+      else
+        close_menu
+      end
+
+      wait_for_menu_closed("")
+    end
+
+    #####################################################################
+    #
+    # Closes all open menus
+    # (Note: On mac one esc closes all menus)
+    def close_all_menus
+      i = 6 #Just some number
+      while quick_menus.delete_if { |menu| menu.name == "Main Menu" }.length > 0
+         close_menu
+         i-=1
+         break if i == 0
+      end
+    end
+
+    ######################################################################
+    #
+    # @return [Array] with all tabs (quick_tab)
+    #
+    def quick_tabs
+      quick_tabbuttons
+    end
+
     ######################################################################
     # Retrieves the name of a window based on it's id
     #
@@ -341,7 +427,7 @@ module OperaWatir
     def window_name(win_id)
       driver.getQuickWindowName(win_id)
     end
-     
+
     ######################################################################
     # Presses the key, with optional modifiers, and waits for loaded event
     #
@@ -360,9 +446,57 @@ module OperaWatir
          key_press_direct(key, *modifiers)
          wait_for_window_loaded("")
     end
-    
+
+    ######################################################################
+    # Clicks the element and waits for the menu with menu_name as given
+    # opens
+    #
+    # @param [String]  element     Web page element to click (a link, an image ..)
+    # @param [Symbol]  menu_name   Name of menu that should open when clicking the element
+    #
+    # @return [String] name of menu opened if it matches menu_name given as
+    #          parameter, otherwise empty string
+    #
+    def open_menu_with_rightclick(element, menu_name)
+      wait_start
+      element.right_click
+      wait_for_menu_shown(menu_name)
+    end
+
+    #####################################################################
+    #
+    # Presses key and waits for the menu to show
+    #
+    # @param [String] menu_name  Name of the menu that should be opened
+    # @param [String] key        Key to press
+    #
+    # @return [String] name of menu that was opened, or empty
+    #
+    def open_menu_with_key_press(menu_name, key, *modifiers)
+      wait_start
+      key_press_direct(key, *modifiers)
+      wait_for_menu_shown(menu_name)
+    end
+
+    #####################################################################
+    #
+    # Presses key and waits for the menu to close
+    #
+    # @param [String] menu_name  Name of the menu that should be opened
+    # @param [String] key        Key to press
+    #
+    # @return [String] name of menu that was closed, or empty string
+    #
+    def close_menu_with_key_press(menu_name, key, *modifiers)
+      wait_start
+      key_press_direct(key, *modifiers)
+      wait_for_menu_closed(menu_name)
+    end
+
+
+=begin
     ##############################################################################
-    # Clicks the element specified by method and selector, 
+    # Clicks the element specified by method and selector,
     # and waits for the window with name win_name to be shown
     #
     # @param [WebElement]  element   element to click
@@ -370,53 +504,53 @@ module OperaWatir
     #
     # @return [int] Window ID of the window shown or 0 if no window is shown
     #
-=begin    
+#=begin
     # or open_dialog_with_click(type, method, selector, win_name)
     # open_dialog_with_click(:button, :id, "text", win_name)
-=end   
+#=end
     def open_dialog_with_click(method, selector, win_name)
       wait_start
       OperaWatir::WebElement.new(self, method, selector).click
       wait_for_window_shown(win_name)
     end
-
+=end
 
     ######################################################################
-    # Returns the full path to the Opera executable 
+    # Returns the full path to the Opera executable
     #
-    # @return [String] Full path to the opera executable 
+    # @return [String] Full path to the opera executable
     #
     def path
       driver.getOperaPath()
     end
 
     ######################################################################
-    # Returns the full path to the Opera large preferences folder 
+    # Returns the full path to the Opera large preferences folder
     #
     # @return [String] Full path to the large preferences folder
     #
     def large_preferences_path
       driver.getLargePreferencesPath()
     end
-  
+
     ######################################################################
-    # Returns the full path to the Opera small preferences folder 
+    # Returns the full path to the Opera small preferences folder
     #
     # @return [String] Full path to the small preferences folder
     #
     def small_preferences_path
       driver.getSmallPreferencesPath()
     end
-  
+
     ######################################################################
-    # Returns the full path to the Opera cache preferences folder 
+    # Returns the full path to the Opera cache preferences folder
     #
     # @return [String] Full path to the cache preferences folder
     #
     def cache_preferences_path
       driver.getCachePreferencesPath()
     end
-    
+
     ######################################################################
     # Returns the language string corresponding to the string_id provided
     #
@@ -436,56 +570,56 @@ module OperaWatir
     end
 
     ######################################################################
-    # Returns true if the test is running on Mac 
+    # Returns true if the test is running on Mac
     #
-    # @return [Boolean] true we the operating system is Mac, otherwise false 
+    # @return [Boolean] true we the operating system is Mac, otherwise false
     #
     def mac?
-      Config::CONFIG['target_os'] == "darwin"
+      mac_internal?
     end
-    
+
     ######################################################################
-    # Returns true if the test is running on Linux 
+    # Returns true if the test is running on Linux
     #
-    # @return [Boolean] true we the operating system is Linux, otherwise false 
+    # @return [Boolean] true we the operating system is Linux, otherwise false
     #
     def linux?
-       Config::CONFIG['target_os'] == "linux"
+      linux_internal?
      end
-    
+
     # @private
     # Special method to access the driver
     attr_reader :driver
-    
+
     ######################################################################
-    # Clear all private data (as in Delete Private Data Dialog) 
+    # Clear all private data (as in Delete Private Data Dialog)
     #
-    # @return [int] 0 if operation failed, else > 0 
+    # @return [int] 0 if operation failed, else > 0
     #
     def clear_all_private_data
-      
+
       #FIXME: Set CheckFlags to uncheck to prevent storing the settings used here
-      
+
       win_id = open_dialog_with_action("Clear Private Data Dialog", "Delete private data")
       return 0 if win_id == 0
-      
+
       #Ensure is Expanded
       if quick_button(:name, "Destails_expand").value == 0
         quick_button(:name, "Destails_expand").toggle_with_click
       end
-           
+
       quick_checkboxes("Clear Private Data Dialog").each do |box|
         box.toggle_with_click unless box.checked?
       end
-      
+
       #Delete all
       win_id = quick_button(:name, "button_OK").close_dialog_with_click("Clear Private Data Dialog")
-      
+
       #FIXME: Reset CheckFlags
-      
+
       win_id
     end
-    
+
     ######################################################################
     # Clear typed and visited history
     #
@@ -494,35 +628,35 @@ module OperaWatir
       opera_desktop_action("Clear visited history")
       opera_desktop_action("Clear typed in history")
     end
-    
+
     ######################################################################
-    #  
+    #
     # Clear disk cache
     #
     def clear_cache
       #TODO: Use Delete Private Data Dialog?
       opera_desktop_action("Clear disk cache")
     end
-    
+
     ######################################################################
-    # 
+    #
     # Close all open tabs (except last one)
     #
     def close_all_tabs
       #The collection has the activate tab first and then the rest sorted on number, so resort to get on descending position
       quick_tabbuttons("Browser Window").sort {|t1, t2| (t2.position <=> t1.position) }.each do |btn|
         #Tab button is in Browser window which is prob not the active window,
-        #so we cannot do this the easy way           
+        #so we cannot do this the easy way
         #btn.quick_button(:name, "pb_CloseButton").close_window_with_click("Document Window") unless btn.position == 0
         #puts "Current tab = #{btn}"
         if btn.position != 0 or btn.value > 1 then
           quick_window(:name, "Browser Window").quick_tab(:pos, btn.position).quick_button(:name, "pb_CloseButton").close_window_with_click("Document Window")
-        end  
+        end
       end
     end
-    
+
     #####################################################################
-    # 
+    #
     # Close all open dialogs
     #
     def close_all_dialogs
@@ -539,7 +673,61 @@ module OperaWatir
         end
       end
     end
-    
+
+    ###############################################################
+    #
+    # key_press_with_condition(key, modifiers) { block } → res
+    #
+    #
+    # Performs the keypress specified and waits until block evaluates to true or timeout is hit
+    #
+    # @param [String] key - key to press
+    # @param *modifiers - modifier(s) to hold while pressing key
+    #
+    # @return value of block, or false if no block provided
+    #
+    def key_press_with_condition(key, *modifiers)
+      return false unless block_given?
+
+      key_press_direct(key, *modifiers)
+
+      start = Time.now
+      until res = yield rescue false do
+        if Time.now - start > ConditionTimeout
+          return false
+        end
+        sleep 0.1
+      end
+      res
+    end
+
+    ###############################################################
+    #
+    # action_with_condition { block } → res
+    #
+    #
+    # Executes action and waits until block evaluates to true or timeout is hit.
+    #
+    # @param [String] action_name - name of action to execute
+    # @param *params - parameters to the action
+    #
+    # @return value of block, or false if no block provided
+    #
+    def action_with_condition(action_name, *params)
+      return false unless block_given?
+
+      opera_desktop_action(action_name, *params)
+
+      start = Time.now
+      until res = yield rescue false do
+        if Time.now - start > ConditionTimeout
+           return false
+        end
+        sleep 0.1
+      end
+      res
+    end
+
     ############################################################################
     #
     # Reset prefs
@@ -550,7 +738,7 @@ module OperaWatir
     def reset_prefs(new_prefs)
       driver.resetOperaPrefs(new_prefs)
     end
-    
+
     ##############################################################################
     #
     # Deletes profile for the connected Opera instance.
@@ -560,7 +748,7 @@ module OperaWatir
     def delete_profile
       driver.deleteOperaPrefs
     end
-    
+
     # Set preference pref in prefs section prefs_section to value
     # specified.
     #
@@ -580,7 +768,7 @@ module OperaWatir
     def get_preference(prefs_section, pref)
       driver.getPref(prefs_section, pref)
     end
-        
+
     # Get default value of preference pref in prefs section
     # prefs_section.
     #
@@ -591,37 +779,53 @@ module OperaWatir
     def get_default_preference(prefs_section, pref)
       driver.getDefaultPref(prefs_section, pref)
     end
-      
+
     # @private
     def start_opera
       driver.startOpera
     end
 
+    # Is attached browser instance of type internal build or public
+    # desktop?
+    #
+    # @return [Boolean] True if browser attached is of type desktop,
+    #   false otherwise.
+    def desktop?
+      true # Not nice, but if you're running desktopbrowser, assume running desktop
+    end
+
 private
 
+   def close_menu
+      wait_start
+      key_press_direct("Esc")
+      wait_for_menu_closed("")
+   end
+
+
    def self.opera_driver_settings
      @opera_driver_settings ||= OperaDriverSettings.new.tap {|s|
-       s.setRunOperaLauncherFromOperaDriver true
+       #s.setRunOperaLauncherFromOperaDriver true
        s.setAutostart false if self.settings[:manual]
        s.setOperaLauncherBinary self.settings[:launcher]
        s.setOperaBinaryLocation self.settings[:path]
-       s.setOperaBinaryArguments self.settings[:args].to_s + ' -autotestmode'
+#       s.setOperaBinaryArguments self.settings[:args].to_s + ' -autotestmode'
        s.setNoQuit self.settings[:no_quit]
        s.setNoRestart self.settings[:no_restart]
        s.setGuessOperaPath false
        s.setUseOperaIdle false if !self.settings[:opera_idle]
      }
    end
-   
+
     # Gets the parent widget name of which there is none here
     def parent_widget
       nil
     end
-    
+
     # Gets the window id to use for the search
     def window_id
       -1
     end
   end
-  
+
 end