RubyGems - watir - Versions diffs - 1.5.2 → 1.5.3 - Mend

watir 1.5.2 → 1.5.3

Files changed (29) hide show

data/readme.rb +20 -12
data/unittests/html/table1.html +41 -1
data/unittests/links_test.rb +2 -2
data/unittests/navigate_test.rb +2 -2
data/unittests/parent_child_test.rb +0 -15
data/unittests/table_test.rb +5 -2
data/unittests/textarea_test.rb +55 -39
data/unittests/windows/iedialog_test.rb +2 -2
data/watir.rb +20 -4386
data/watir/{elements.rb → bonus-elements.rb} +0 -0
data/watir/collections.rb +317 -0
data/watir/container.rb +883 -0
data/watir/element.rb +306 -0
data/watir/element_collections.rb +82 -0
data/watir/form.rb +151 -0
data/watir/frame.rb +60 -0
data/watir/ie.rb +973 -0
data/watir/image.rb +131 -0
data/watir/input_elements.rb +518 -0
data/watir/link.rb +65 -0
data/watir/locator.rb +79 -0
data/watir/logger.rb +19 -0
data/watir/modal_dialog.rb +123 -0
data/watir/non_control_elements.rb +91 -0
data/watir/page-container.rb +106 -0
data/watir/popup.rb +30 -0
data/watir/table.rb +356 -0
data/watir/win32.rb +29 -0
metadata +21 -3

data/readme.rb CHANGED

@@ -2,17 +2,25 @@
 This is Watir - Web Application Testing In Ruby    http://wtr.rubyforge.org
-To Install Ruby:    http://ruby-lang.org
-   Best is to use Ruby 1.8.2-14 or later.
-   However, if you are using the Watir::IE#modal_dialog method, you must use Ruby 1.8.2-14 and not a more recent version.
-   Watir (in general) will not work with Ruby 1.8.1-13. (This version of Ruby has a bad WIN32OLE library.)
-To Install Watir:
-   Best way to install is to use the gem.
-   From your command line:
-     > gem install win32-process --include-dependencies
-     > gem install watir
-   This will download and install watir, win32-process and all dependencies.
+Install Ruby http://ruby-lang.org
+   First you need to install Ruby using the one-click installer for Windows. We
+   recommend Ruby 1.8.5. (Ruby 1.8.6 has problems.)
+   However, if you wish to use Watir's support for the IE showModalDialog then
+   you must use Ruby 1.8.2-15 (or 1.8.2-14) and not a more recent version. This
+   dialog is the one that is posted with the showModalDialog() JavaScript
+   command and is supported with Watir's ie.modal_dialog command.
+Install Watir
+   Watir is packaged as a gem, a Ruby library that can be installed over the
+   internet.
+   Watir 1.5 was released in September 2007. To install it, type this at a
+   command prompt:
+      gem install watir
+   Watir 1.4 was released in August 2005. If you are upgrading from it, see
+   these notes: http://wiki.openqa.org/display/WTR/Development+Builds
 How To Use:
    This only works on Windows.
@@ -93,7 +101,7 @@ Contacts:
    Paul Rogers (paul.rogers@shaw.ca)
    Bret Pettichord (bret@pettichord.com)
    Charley Baker (charley.baker@gmail.com)
-   The mailing list: http://rubyforge.org/mail/?group_id=104
+   The mailing list: http://groups.google.com/group/watir-general
 Contributors:
    Bret Pettichord

data/unittests/html/table1.html CHANGED

@@ -6,6 +6,33 @@ Test page for Tables
 </head>
 <body>
+<style type="text/css">
+table.sample {
+	border-width: 1px 1px 1px 1px;
+	border-spacing: 2px;
+	border-style: outset outset outset outset;
+	border-color: gray gray gray gray;
+	border-collapse: separate;
+	background-color: white;
+}
+table.sample th {
+	border-width: 1px 1px 1px 1px;
+	padding: 1px 1px 1px 1px;
+	border-style: inset inset inset inset;
+	border-color: gray gray gray gray;
+	background-color: white;
+	-moz-border-radius: 0px 0px 0px 0px;
+}
+table.sample td {
+	border-width: 1px 1px 1px 1px;
+	padding: 1px 1px 1px 1px;
+	border-style: inset inset inset inset;
+	border-color: gray gray gray gray;
+	background-color: white;
+	-moz-border-radius: 0px 0px 0px 0px;
+}
+</style>
 <script language=javascript>
 function addRow() {
@@ -32,7 +59,7 @@ function addRow() {
 </script>
-CVS Revision: "$Revision: 561 $"
+CVS Revision: "$Revision: 1239 $"
 <br>
 <br>
 <table >
@@ -137,6 +164,19 @@ This text is in the THIRD TBODY.
+<table class="sample">
+<tr>
+	<th>Header</th>
+	<td>First table with css class</td>
+</tr>
+</table>
+<table class="sample">
+<tr>
+	<td>Second table with css class</td>
+</tr>
+</table>
 </body>
 </html>

data/unittests/links_test.rb CHANGED

@@ -1,9 +1,9 @@
 # feature tests for Links
-# revision: $Revision: 1078 $
+# revision: $Revision: 1277 $
 $LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..') if $0 == __FILE__
 require 'unittests/setup'
-require 'CGI'
+require 'cgi'
 class TC_Links < Test::Unit::TestCase
   include Watir

data/unittests/navigate_test.rb CHANGED

@@ -1,9 +1,9 @@
 # feature tests for navigation
-# revision: $Revision: 1009 $
+# revision: $Revision: 1277 $
 $LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..') if $0 == __FILE__
 require 'unittests/setup'
-require 'CGI'
+require 'cgi'
 class TC_Navigate < Test::Unit::TestCase
   include Watir

data/unittests/parent_child_test.rb CHANGED

@@ -3,21 +3,6 @@
 $LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..') if $0 == __FILE__
 require 'unittests/setup'
-# These tests are based on the rails depot application, which requires some
-# modifications...
- module Watir
-   class H3 < NonControlElement
-     TAG = 'h3'
-   end
-   module Container
-     def h3(how, what)
-       return H3.new(self, how, what)
-     end
-   end
- end
 class TC_Relative < Test::Unit::TestCase
   def setup

data/unittests/table_test.rb CHANGED

@@ -1,5 +1,5 @@
 # feature tests for Tables
-# revision: $Revision: 1076 $
+# revision: $Revision: 1246 $
 $LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..') if $0 == __FILE__
 require 'unittests/setup'
@@ -54,7 +54,6 @@ class TC_Tables < Test::Unit::TestCase
   def test_dynamic_tables
     t = $ie.table(:id, 't1')
     assert_equal(5, t.row_count)
     $ie.button(:value, 'add row').click
     assert_equal(6, t.row_count)
   end
@@ -176,6 +175,10 @@ class TC_Tables < Test::Unit::TestCase
   def test_table_container
     assert_nothing_raised { $ie.table(:id, 't1').html }
   end
+  def test_multiple_selector
+    assert( $ie.table(:class => 'sample', :index => 2)[1][1].text, '')
+  end
 end
 class TC_Tables_Simple < Test::Unit::TestCase

data/unittests/textarea_test.rb CHANGED

@@ -1,5 +1,5 @@
-# feature tests for TextArea Fields
-# revision: $Revision: 963 $
+# tests for textarea elements
+# revision: $Revision: 1260 $
 $LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..') if $0 == __FILE__
 require 'unittests/setup'
@@ -7,13 +7,15 @@ require 'unittests/setup'
 class TC_TextArea < Test::Unit::TestCase
   include Watir
-  def goto_page
-    $ie.goto($htmlRoot + "textArea.html")
+  def use_page page
+    $ie.goto($htmlRoot + page)
+  end
+  def setup
+    use_page 'textarea.html'
   end
-  def test_textarea_field_exists
-    goto_page
-    #test for existance of 4 text area
+  def test_elements_exist_or_not
     assert($ie.text_field(:name,"txtMultiLine1").exists?)
     assert($ie.text_field(:name,"txtMultiLine2").exists?)
     assert($ie.text_field(:name,"txtMultiLine3").exists?)
@@ -23,59 +25,73 @@ class TC_TextArea < Test::Unit::TestCase
     assert($ie.text_field(:id,"txtMultiLine2").exists?)
     assert($ie.text_field(:id,"txtMultiLine3").exists?)
     assert($ie.text_field(:id,"txtReadOnly").exists?)
-    #test for missing
     assert(!$ie.text_field(:name, "missing").exists?)
     assert(!$ie.text_field(:name,"txtMultiLine4").exists?)
   end
-  def test_textarea_to_s
+  def test_to_s_bug
     # from a bug reported by Zeljko Filipin
     assert_nothing_raised { $ie.text_field(:id,"txtMultiLine3").to_s  }
   end
-  def test_textarea_field
-    goto_page
-    # test for read only method
+  def test_maxlength_bug
+    # from another bug
+    assert_nothing_raised { $ie.text_field(:id,"txtMultiLine3").append('foo')}
+  end
+  def test_readonly_and_enabled
     assert(!$ie.text_field(:name, "txtMultiLine1").readonly? )
     assert($ie.text_field(:name,"txtReadOnly").readonly?)
-    # test for enabled? method
     assert(!$ie.text_field(:name, "txtDisabled").enabled? )
     assert($ie.text_field(:id, "txtMultiLine1").enabled? )
+  end
+  def test_verify_contains
     t1 = $ie.text_field(:name, "txtMultiLine1")
     assert(t1.verify_contains("Hello World") )
     assert(t1.verify_contains(/el/) )
-    t2 = $ie.text_field(:name, "txtMultiLine2")
-    assert(t2.verify_contains(/IE/))
-    assert_raises(UnknownObjectException , "UnknownObjectException was supposed to be thrown" ) {   $ie.text_field(:name, "NoName").verify_contains("No field to get a value of") }
-    assert_raises(UnknownObjectException , "UnknownObjectException was supposed to be thrown" ) {   $ie.text_field(:id, "noID").verify_contains("No field to get a value of") }
-    assert_raises(UnknownObjectException  , "ObjectReadOnlyException   was supposed to be thrown" ) {   $ie.text_field(:name, "txtNone").append("Some Text") }
-    assert_raises(ObjectReadOnlyException  , "ObjectReadOnlyException   was supposed to be thrown" ) {   $ie.text_field(:id, "txtReadOnly").append("Some Text") }
-    assert_raises(ObjectDisabledException   , "ObjectDisabledException   was supposed to be thrown" ) {   $ie.text_field(:name, "txtDisabled").append("Some Text") }
-    assert_raises(UnknownObjectException  , "UnknownObjectException  was supposed to be thrown" ) {   $ie.text_field(:name, "missing_field").append("Some Text") }
+    assert($ie.text_field(:name, "txtMultiLine2").verify_contains(/IE/))
+  end
+  def test_no_such_element
+    assert_raises(UnknownObjectException) do
+      $ie.text_field(:name, "NoName").verify_contains("de nada")
+    end
+    assert_raises(UnknownObjectException) do
+      $ie.text_field(:id, "noID").verify_contains("de nada")
+    end
+    assert_raises(UnknownObjectException) do
+      $ie.text_field(:name, "txtNone").append("de nada")
+    end
+  end
+  def test_readonly_and_disabled_errors
+    assert_raises(ObjectReadOnlyException) do
+      $ie.text_field(:id, "txtReadOnly").append("de nada")
+    end
+    assert_raises(ObjectDisabledException) do
+      $ie.text_field(:name, "txtDisabled").append("de nada")
+    end
+    assert_raises(ObjectReadOnlyException) do
+      $ie.text_field(:id, "txtReadOnly").append("Some Text")
+    end
+    assert_raises(ObjectDisabledException) do
+      $ie.text_field(:name, "txtDisabled").append("Some Text")
+    end
+  end
+  def test_append_set_and_clear
     $ie.text_field(:name, "txtMultiLine1").append(" Some Text")
-    assert_equal(  "Hello World Some Text" , $ie.text_field(:name, "txtMultiLine1").getContents )
-    assert_raises(ObjectReadOnlyException  , "ObjectReadOnlyException   was supposed to be thrown" ) {   $ie.text_field(:id, "txtReadOnly").append("Some Text") }
-    assert_raises(ObjectDisabledException   , "ObjectReadOnlyException   was supposed to be thrown" ) {   $ie.text_field(:name, "txtDisabled").append("Some Text") }
-    assert_raises(UnknownObjectException  , "ObjectReadOnlyException   was supposed to be thrown" ) {   $ie.text_field(:name, "missing_field").append("Some Text") }
+    assert_equal("Hello World Some Text",
+      $ie.text_field(:name, "txtMultiLine1").getContents )
     $ie.text_field(:name, "txtMultiLine1").set("watir IE Controller")
-    assert_equal(  "watir IE Controller" , $ie.text_field(:name, "txtMultiLine1").getContents )
-    assert_raises(ObjectReadOnlyException  , "ObjectReadOnlyException   was supposed to be thrown" ) {   $ie.text_field(:id, "txtReadOnly").append("Some Text") }
-    assert_raises(ObjectDisabledException   , "ObjectReadOnlyException   was supposed to be thrown" ) {   $ie.text_field(:name, "txtDisabled").append("Some Text") }
-    assert_raises(UnknownObjectException  , "ObjectReadOnlyException   was supposed to be thrown" ) {   $ie.text_field(:name, "missing_field").append("Some Text") }
+    assert_equal("watir IE Controller",
+      $ie.text_field(:name, "txtMultiLine1").getContents )
     $ie.text_field(:name, "txtMultiLine2").clear
-    assert_equal(  "" , $ie.text_field(:name, "txtMultiLine2").getContents )
+    assert_equal("" , $ie.text_field(:name, "txtMultiLine2").getContents )
   end
 end

data/unittests/windows/iedialog_test.rb CHANGED

@@ -1,5 +1,5 @@
 # unit tests for iedialog.dll and customized win32ole.so
-# revision: $Revision: 1177 $
+# revision: $Revision: 1278 $
 $LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', '..') if $0 == __FILE__
 require 'unittests/setup'
@@ -10,7 +10,7 @@ class TC_IEDialog < Test::Unit::TestCase
   include Watir
   # this will find the IEDialog.dll file in its build location
-  @@iedialog_file = (File.expand_path(File.dirname(__FILE__)) + "/../watir/IEDialog/Release/IEDialog.dll").gsub('/', '\\')
+  @@iedialog_file = (File.expand_path(File.dirname(__FILE__)) + "/../../watir/IEDialog/Release/IEDialog.dll").gsub('/', '\\')
   # commented out because it currently requires a manual click
   # a better idea would be to automate the click...

data/watir.rb CHANGED

@@ -86,6 +86,25 @@ $FAST_SPEED = command_line_flag('-f')
 # Eat the -s command line switch (deprecated)
 command_line_flag('-s')
+require 'watir/logger'
+require 'watir/win32'
+require 'watir/container'
+require 'watir/locator'
+require 'watir/page-container'
+require 'watir/ie'
+require 'watir/popup'
+require 'watir/element'
+require 'watir/frame'
+require 'watir/modal_dialog'
+require 'watir/element_collections'
+require 'watir/form'
+require 'watir/non_control_elements'
+require 'watir/input_elements'
+require 'watir/table'
+require 'watir/image'
+require 'watir/link'
+require 'watir/collections'
 module Watir
   include Watir::Exception
@@ -103,4393 +122,8 @@ module Watir
     ATTACHER.timeout = IE.attach_timeout
     ATTACHER.wait_until { yield }
   end
-  class WatirLogger < Logger
-    def initialize(filName, logsToKeep, maxLogSize)
-      super(filName, logsToKeep, maxLogSize)
-      self.level = Logger::DEBUG
-      self.datetime_format = "%d-%b-%Y %H:%M:%S"
-      self.debug("Watir starting")
-    end
-  end
-  class DefaultLogger < Logger
-    def initialize
-      super(STDERR)
-      self.level = Logger::WARN
-      self.datetime_format = "%d-%b-%Y %H:%M:%S"
-      self.info "Log started"
-    end
-  end
-  module Win32
-    # this will find the IEDialog.dll file in its build location
-    @@iedialog_file = (File.expand_path(File.dirname(__FILE__)) + "/watir/IEDialog/Release/IEDialog.dll").gsub('/', '\\')
-    GetUnknown = Win32API.new(@@iedialog_file, 'GetUnknown', ['l', 'p'], 'v')
-    User32 = DL.dlopen('user32')
-    FindWindowEx = User32['FindWindowEx', 'LLLpp']
-    # method for this found in wet-winobj/wet/winobjects/WinUtils.rb
-    GetWindow = User32['GetWindow', 'ILL']
-    ## GetWindows Constants
-    GW_HWNDFIRST = 0
-    GW_HWNDLAST = 1
-    GW_HWNDNEXT = 2
-    GW_HWNDPREV = 3
-    GW_OWNER = 4
-    GW_CHILD = 5
-    GW_ENABLEDPOPUP = 6
-    GW_MAX = 6
-    IsWindow = User32['IsWindow', 'II']
-    # Does the window with the specified window handle (hwnd) exist?
-    def self.window_exists? hwnd
-      rtn, junk = IsWindow[hwnd]
-      rtn == 1
-    end
-  end
-  # This module contains the factory methods that are used to access most html objects
-  #
-  # For example, to access a button on a web page that has the following html
-  #  <input type = button name= 'b1' value='Click Me' onClick='javascript:doSomething()'>
-  #
-  # the following watir code could be used
-  #
-  #  ie.button(:name, 'b1').click
-  #
-  # or
-  #
-  #  ie.button(:value, 'Click Me').to_s
-  #
-  # there are many methods available to the Button object
-  #
-  # Is includable for classes that have @container, document and ole_inner_elements
-  module Container
-    include Watir::Exception
-    # Note: @container is the container of this object, i.e. the container
-    # of this container.
-    # In other words, for ie.table().this_thing().text_field().set,
-    # container of this_thing is the table.
-    # This is used to change the typing speed when entering text on a page.
-    attr_accessor :typingspeed
-    # The color we want to use for the active object. This can be any valid web-friendly color.
-    attr_accessor :activeObjectHighLightColor
-    # The PageContainer object containing this element
-    attr_accessor :page_container
-    def copy_test_config(container) # only used by form and frame
-      @typingspeed = container.typingspeed
-      @activeObjectHighLightColor = container.activeObjectHighLightColor
-    end
-    private :copy_test_config
-    # Write the specified string to the log.
-    def log(what)
-      @container.logger.debug(what) if @logger
-    end
-    # Wait until Internet Explorer has finished loading the page.
-    def wait(no_sleep=false)
-      @container.wait(no_sleep)
-    end
-    # Determine the how and what when defaults are possible.
-    def process_default(default_attribute, how, what)
-      if how.class == String && what == nil
-        what = how
-        how = default_attribute
-      end
-      return how, what
-    end
-    private :process_default
-    def set_container container
-      @container = container
-      @page_container = container.page_container
-    end
-    private
-    def self.def_creator(method_name, klass_name=nil)
-      klass_name ||= method_name.to_s.capitalize
-      class_eval "def #{method_name}(how, what=nil)
-                          #{klass_name}.new(self, how, what)
-                        end"
-    end
-    def self.def_creator_with_default(method_name, default_symbol)
-      klass_name = method_name.to_s.capitalize
-      class_eval "def #{method_name}(how, what=nil)
-                          how, what = process_default :#{default_symbol}, how, what
-                          #{klass_name}.new(self, how, what)
-                        end"
-    end
-    #
-    #           Factory Methods
-    #
-    # this method is the main way of accessing a frame
-    #   *  how   - how the frame is accessed. This can also just be the name of the frame.
-    #   *  what  - what we want to access.
-    #
-    # Valid values for 'how' are listed in the Watir Wiki - http://wiki.openqa.org/display/WTR/Methods+supported+by+Element
-    #
-    # returns a Frame object
-    #
-    # Typical usage:
-    #
-    #   ie.frame(:index, 1)
-    #   ie.frame(:name, 'main_frame')
-    #   ie.frame('main_frame')        # in this case, just a name is supplied
-    public
-    def frame(how, what=nil)
-      how, what = process_default :name, how, what
-      Frame.new(self, how, what)
-    end
-    # this method is used to access a form.
-    # available ways of accessing it are, :index, :name, :id, :method, :action, :xpath
-    #  * how    - symbol - What mecahnism we use to find the form, one of
-    #                 the above. NOTE if what is not supplied this parameter is the NAME of the form
-    #  * what   - String - the text associated with the symbol
-    #
-    # Valid values for 'how' are listed in the Watir Wiki - http://wiki.openqa.org/display/WTR/Methods+supported+by+Element
-    #
-    # returns a Form object
-    def form(how, what=nil)
-      how, what = process_default :name, how, what
-      Form.new(self, how, what)
-    end
-    # This method is used to get a table from the page.
-    # :index (1 based counting) and :id are supported.
-    #  NOTE :name is not supported, as the table tag does not have a name attribute. It is not part of the DOM.
-    # :index can be used when there are multiple tables on a page.
-    # :xpath can be used to select table using XPath query.
-    # The first form can be accessed with :index 1, the second :index 2, etc.
-    #   * how   - symbol - how we access the table, :index, :id, :xpath etc
-    #   * what  - string the thing we are looking for, ex. id, index or xpath query, of the object we are looking for
-    #
-    # Valid values for 'how' are listed in the Watir Wiki - http://wiki.openqa.org/display/WTR/Methods+supported+by+Element
-    #
-    # returns a Table object
-    def table(how, what=nil)
-      Table.new(self, how, what)
-    end
-    # this is the main method for accessing the tables iterator. It returns a Tables object
-    #
-    # Typical usage:
-    #
-    #   ie.tables.each { |t| puts t.to_s }            # iterate through all the tables on the page
-    #   ie.tables[1].to_s                             # goto the first table on the page
-    #   ie.tables.length                              # show how many tables are on the page. Tables that are nested will be included in this
-    def tables
-      Tables.new(self)
-    end
-    # this method accesses a table cell.
-    # how - symbol - how we access the cell, valid values are
-    #    :id       - find the table cell with given id.
-    #    :xpath    - find the table cell using xpath query.
-    #
-    # returns a TableCell Object
-    def cell(how, what=nil)
-      TableCell.new(self, how, what)
-    end
-    def cells
-      TableCells.new(self)
-    end
-    # this method accesses a table row.
-    # how - symbol - how we access the row, valid values are
-    #    :id       - find the table row with given id.
-    #    :xpath    - find the table row using xpath query.
-    #
-    # returns a TableRow object
-    def row(how, what=nil)
-      TableRow.new(self, how, what)
-    end
-    def rows
-      TableRows.new(self)
-    end
-    # Access a modal web dialog, which is a PageContainer, like IE or Frame.
-    # Returns a ModalDialog object.
-    #
-    # Typical Usage
-    #    ie.modal_dialog                  # access the modal dialog of ie
-    #    ie.modal_dialog(:title, 'Title') # access the modal dialog by title
-    #    ie.modal_dialog.modal_dialog     # access a modal dialog's modal dialog XXX untested!
-    #
-    # This method will not work when
-    # Watir/Ruby is run under a service (instead of a user).
-    # Note: unlike Watir.attach, this returns before the page is assured to have
-    # loaded.
-    def modal_dialog(how=nil, what=nil)
-      ModalDialog.new(self, how, what)
-    end
-    # This is the main method for accessing a button. Often declared as an <input type = submit> tag.
-    #  *  how   - symbol - how we access the button, :index, :id, :name etc
-    #  *  what  - string, integer or regular expression - what we are looking for,
-    #
-    # Valid values for 'how' are listed in the Watir Wiki - http://wiki.openqa.org/display/WTR/Methods+supported+by+Element
-    #
-    # Returns a Button object.
-    #
-    # Typical usage
-    #
-    #    ie.button(:id,    'b_1')                             # access the button with an ID of b_1
-    #    ie.button(:name,  'verify_data')                     # access the button with a name of verify_data
-    #    ie.button(:value, 'Login')                           # access the button with a value (the text displayed on the button) of Login
-    #    ie.button(:caption, 'Login')                         # same as above
-    #    ie.button(:value, /Log/)                             # access the button that has text matching /Log/
-    #    ie.button(:index, 2)                                 # access the second button on the page (1 based, so the first button is accessed with :index,1)
-    #    ie.button(:class, 'my_custom_button_class')          # access the button with a class of my_custom_button_class
-    #    ie.button(:xpath, "//input[@value='Click Me']/")     # access the button with a value of Click Me
-    #
-    # Accessing a Button nested within another element
-    #    ie.div(:class, 'xyz').button(:index, 2)              # access a div of class xyz, and the 2nd button within that div
-    #
-    # If only a single parameter is supplied, then :value is used
-    #    ie.button('Click Me')                                # access the button with a value of Click Me
-    def button(how, what=nil)
-      how, what = process_default :value, how, what
-      Button.new(self, how, what)
-    end
-    # this is the main method for accessing the buttons iterator. It returns a Buttons object
-    #
-    # Typical usage:
-    #
-    #   ie.buttons.each { |b| puts b.to_s }                   # iterate through all the buttons on the page
-    #   ie.buttons[1].to_s                                    # goto the first button on the page
-    #   ie.buttons.length                                     # show how many buttons are on the page.
-    def buttons
-      Buttons.new(self)
-    end
-    # This is the main method for accessing a file field. Usually an <input type = file> HTML tag.
-    #  *  how   - symbol - how we access the field, valid values are
-    #    :index      - find the file field using index
-    #    :id         - find the file field using id attribute
-    #    :name       - find the file field using name attribute
-    #    :xpath      - find the file field using xpath query
-    #  *  what  - string, integer, regular expression, or xpath query - what we are looking for,
-    #
-    # returns a FileField object
-    #
-    # Typical Usage
-    #
-    #    ie.file_field(:id,   'up_1')                     # access the file upload field with an ID of up_1
-    #    ie.file_field(:name, 'upload')                   # access the file upload field with a name of upload
-    #    ie.file_field(:index, 2)                         # access the second file upload on the page (1 based, so the first field is accessed with :index,1)
-    #
-    def file_field(how, what=nil)
-      FileField.new(self, how, what)
-    end
-    # this is the main method for accessing the file_fields iterator. It returns a FileFields object
-    #
-    # Typical usage:
-    #
-    #   ie.file_fields.each { |f| puts f.to_s }            # iterate through all the file fields on the page
-    #   ie.file_fields[1].to_s                             # goto the first file field on the page
-    #   ie.file_fields.length                              # show how many file fields are on the page.
-    def file_fields
-      FileFields.new(self)
-    end
-    # This is the main method for accessing a text field. Usually an <input type = text> HTML tag. or a text area - a  <textarea> tag
-    #  *  how   - symbol - how we access the field, :index, :id, :name etc
-    #  *  what  - string, integer or regular expression - what we are looking for,
-    #
-    # Valid values for 'how' are listed in the Watir Wiki - http://wiki.openqa.org/display/WTR/Methods+supported+by+Element
-    #
-    # returns a TextField object
-    #
-    # Typical Usage
-    #
-    #    ie.text_field(:id,   'user_name')                 # access the text field with an ID of user_name
-    #    ie.text_field(:name, 'address')                   # access the text field with a name of address
-    #    ie.text_field(:index, 2)                          # access the second text field on the page (1 based, so the first field is accessed with :index,1)
-    #    ie.text_field(:xpath, "//textarea[@id='user_name']/")    # access the text field with an ID of user_name
-    def text_field(how, what=nil)
-      TextField.new(self, how, what)
-    end
-    # this is the method for accessing the text_fields iterator. It returns a Text_Fields object
-    #
-    # Typical usage:
-    #
-    #   ie.text_fields.each { |t| puts t.to_s }            # iterate through all the text fields on the page
-    #   ie.text_fields[1].to_s                             # goto the first text field on the page
-    #   ie.text_fields.length                              # show how many text field are on the page.
-    def text_fields
-      TextFields.new(self)
-    end
-    # This is the main method for accessing a hidden field. Usually an <input type = hidden> HTML tag
-    #
-    #  *  how   - symbol - how we access the hidden field, :index, :id, :name etc
-    #  *  what  - string, integer or regular expression - what we are looking for,
-    #
-    # Valid values for 'how' are listed in the Watir Wiki - http://wiki.openqa.org/display/WTR/Methods+supported+by+Element
-    #
-    # returns a Hidden object
-    #
-    # Typical usage
-    #
-    #    ie.hidden(:id, 'session_id')                 # access the hidden field with an ID of session_id
-    #    ie.hidden(:name, 'temp_value')               # access the hidden field with a name of temp_value
-    #    ie.hidden(:index, 2)                         # access the second hidden field on the page (1 based, so the first field is accessed with :index,1)
-    #    ie.hidden(:xpath, "//input[@type='hidden' and @id='session_value']/")    # access the hidden field with an ID of session_id
-    def hidden(how, what=nil)
-      Hidden.new(self, how, what)
-    end
-    # this is the method for accessing the hiddens iterator. It returns a Hiddens object
-    #
-    # Typical usage:
-    #
-    #   ie.hiddens.each { |t| puts t.to_s }            # iterate through all the hidden fields on the page
-    #   ie.hiddens[1].to_s                             # goto the first hidden field on the page
-    #   ie.hiddens.length                              # show how many hidden fields are on the page.
-    def hiddens
-      Hiddens.new(self)
-    end
-    # This is the main method for accessing a selection list. Usually a <select> HTML tag.
-    #  *  how   - symbol - how we access the selection list, :index, :id, :name etc
-    #  *  what  - string, integer or regular expression - what we are looking for,
-    #
-    # Valid values for 'how' are listed in the Watir Wiki - http://wiki.openqa.org/display/WTR/Methods+supported+by+Element
-    #
-    # returns a SelectList object
-    #
-    # Typical usage
-    #
-    #    ie.select_list(:id, 'currency')                   # access the select box with an id of currency
-    #    ie.select_list(:name, 'country')                  # access the select box with a name of country
-    #    ie.select_list(:name, /n_/)                       # access the first select box whose name matches n_
-    #    ie.select_list(:index, 2)                         # access the second select box on the page (1 based, so the first field is accessed with :index,1)
-    #    ie.select(:xpath, "//select[@id='currency']/")    # access the select box with an id of currency
-    def select_list(how, what)
-      SelectList.new(self, how, what)
-    end
-    # this is the method for accessing the select lists iterator. Returns a SelectLists object
-    #
-    # Typical usage:
-    #
-    #   ie.select_lists.each { |s| puts s.to_s }            # iterate through all the select boxes on the page
-    #   ie.select_lists[1].to_s                             # goto the first select boxes on the page
-    #   ie.select_lists.length                              # show how many select boxes are on the page.
-    def select_lists
-      SelectLists.new(self)
-    end
-    # This is the main method for accessing a check box. Usually an <input type = checkbox> HTML tag.
-    #
-    #  *  how   - symbol - how we access the check box - :index, :id, :name etc
-    #  *  what  - string, integer or regular expression - what we are looking for,
-    #  *  value - string - when there are multiple objects with different value attributes, this can be used to find the correct object
-    #
-    # Valid values for 'how' are listed in the Watir Wiki - http://wiki.openqa.org/display/WTR/Methods+supported+by+Element
-    #
-    # returns a CheckBox object
-    #
-    # Typical usage
-    #
-    #    ie.checkbox(:id, 'send_email')                    # access the check box with an id of send_mail
-    #    ie.checkbox(:name, 'send_copy')                   # access the check box with a name of send_copy
-    #    ie.checkbox(:name, /n_/)                          # access the first check box whose name matches n_
-    #    ie.checkbox(:index, 2)                            # access the second check box on the page (1 based, so the first field is accessed with :index,1)
-    #
-    # In many instances, checkboxes on an html page have the same name, but are identified by different values. An example is shown next.
-    #
-    #  <input type = checkbox name = email_frequency value = 'daily' > Daily Email
-    #  <input type = checkbox name = email_frequency value = 'Weekly'> Weekly Email
-    #  <input type = checkbox name = email_frequency value = 'monthly'>Monthly Email
-    #
-    # Watir can access these using the following:
-    #
-    #    ie.checkbox(:id, 'day_to_send', 'monday')         # access the check box with an id of day_to_send and a value of monday
-    #    ie.checkbox(:name,'email_frequency', 'weekly')    # access the check box with a name of email_frequency and a value of 'weekly'
-    #    ie.checkbox(:xpath, "//input[@name='email_frequency' and @value='daily']/")     # access the checkbox with a name of email_frequency and a value of 'daily'
-    def checkbox(how, what, value=nil)
-      CheckBox.new(self, how, what, ["checkbox"], value)
-    end
-    # this is the method for accessing the check boxes iterator. Returns a CheckBoxes object
-    #
-    # Typical usage:
-    #
-    #   ie.checkboxes.each { |c| puts c.to_s }             # iterate through all the check boxes on the page
-    #   ie.checkboxes[1].to_s                              # goto the first check box on the page
-    #   ie.checkboxes.length                               # show how many check boxes are on the page.
-    def checkboxes
-      CheckBoxes.new(self)
-    end
-    # This is the main method for accessing a radio button. Usually an <input type = radio> HTML tag.
-    #  *  how   - symbol - how we access the radio button, :index, :id, :name etc
-    #  *  what  - string, integer or regular expression - what we are looking for,
-    #  *  value - string - when  there are multiple objects with different value attributes, this can be used to find the correct object
-    #
-    # Valid values for 'how' are listed in the Watir Wiki - http://wiki.openqa.org/display/WTR/Methods+supported+by+Element
-    #
-    # returns a Radio object
-    #
-    # Typical usage
-    #
-    #    ie.radio(:id, 'send_email')                   # access the radio button with an id of currency
-    #    ie.radio(:name, 'send_copy')                  # access the radio button with a name of country
-    #    ie.radio(:name, /n_/)                        # access the first radio button whose name matches n_
-    #    ie.radio(:index, 2)                           # access the second radio button on the page (1 based, so the first field is accessed with :index,1)
-    #
-    # In many instances, radio buttons on an html page have the same name, but are identified by different values. An example is shown next.
-    #
-    #  <input type="radio" name="email_frequency" value="daily">Daily Email</input>
-    #  <input type="radio" name="email_frequency" value="weekly">Weekly Email</input>
-    #  <input type="radio" name="email_frequency" value="monthly">Monthly Email</input>
-    #
-    # Watir can access these using the following:
-    #
-    #    ie.radio(:id, 'day_to_send', 'monday')         # access the radio button with an id of day_to_send and a value of monday
-    #    ie.radio(:name,'email_frequency', 'weekly')     # access the radio button with a name of email_frequency and a value of 'weekly'
-    #    ie.radio(:xpath, "//input[@name='email_frequency' and @value='daily']/")     # access the radio button with a name of email_frequency and a value of 'daily'
-    def radio(how, what, value=nil)
-      Radio.new(self, how, what, ["radio"], value)
-    end
-    # This is the method for accessing the radio buttons iterator. Returns a Radios object
-    #
-    # Typical usage:
-    #
-    #   ie.radios.each { |r| puts r.to_s }            # iterate through all the radio buttons on the page
-    #   ie.radios[1].to_s                             # goto the first radio button on the page
-    #   ie.radios.length                              # show how many radio buttons are on the page.
-    #
-    def radios
-      Radios.new(self)
-    end
-    # This is the main method for accessing a link.
-    #  *  how   - symbol - how we access the link, :index, :id, :name, :title, :text, :url
-    #  *  what  - string, integer or regular expression - what we are looking for,
-    #
-    # Valid values for 'how' are listed in the Watir Wiki - http://wiki.openqa.org/display/WTR/Methods+supported+by+Element
-    #
-    # returns a Link object
-    #
-    # Typical Usage
-    #
-    #   ie.link(:url, /login/)              # access the first link whose url matches login. We can use a string in place of the regular expression
-    #                                       # but the complete path must be used, ie.link(:url, 'http://myserver.com/my_path/login.asp')
-    #   ie.link(:index,2)                   # access the second link on the page
-    #   ie.link(:title, "Picture")         # access a link using the tool tip
-    #   ie.link(:text, 'Click Me')          # access the link that has Click Me as its text
-    #   ie.link(:xpath, "//a[contains(.,'Click Me')]/")      # access the link with Click Me as its text
-    def link(how, what=nil)
-      Link.new(self, how, what)
-    end
-    # This is the main method for accessing the links collection. Returns a Links object
-    #
-    # Typical usage:
-    #
-    #   ie.links.each { |l| puts l.to_s }            # iterate through all the links on the page
-    #   ie.links[1].to_s                             # goto the first link on the page
-    #   ie.links.length                              # show how many links are on the page.
-    #
-    def links
-      Links.new(self)
-    end
-    # This is the main method for accessing li tags - http://msdn.microsoft.com/workshop/author/dhtml/reference/objects/map.asp?frame=true
-    #  *  how   - symbol - how we access the li,
-    #  *  what  - string, integer or regular expression - what we are looking for,
-    #
-    # Valid values for 'how' are listed in the Watir Wiki - http://wiki.openqa.org/display/WTR/Methods+supported+by+Element
-    #
-    # returns a li object
-    #
-    # Typical Usage
-    #
-    #   ie.li(:id, /list/)                 # access the first li that matches list.
-    #   ie.li(:index,2)                    # access the second li on the page
-    #   ie.li(:title, "A Picture")        # access a li using the tooltip text. See http://msdn.microsoft.com/workshop/author/dhtml/reference/properties/title_1.asp?frame=true
-    #
-    def li(how, what)
-      return Li.new(self, how, what)
-    end
-    # this is the main method for accessing the lis iterator.
-    #
-    # Returns a lis object
-    #
-    # Typical usage:
-    #
-    #   ie.lis.each { |s| puts s.to_s }            # iterate through all the lis on the page
-    #   ie.lis[1].to_s                             # goto the first li on the page
-    #   ie.lis.length                              # show how many lis are on the page.
-    #
-    def lis
-      return Lis.new(self)
-    end
-    # This is the main method for accessing map tags - http://msdn.microsoft.com/workshop/author/dhtml/reference/objects/map.asp?frame=true
-    #  *  how   - symbol - how we access the map,
-    #  *  what  - string, integer or regular expression - what we are looking for,
-    #
-    # Valid values for 'how' are listed in the Watir Wiki - http://wiki.openqa.org/display/WTR/Methods+supported+by+Element
-    #
-    # returns a map object
-    #
-    # Typical Usage
-    #
-    #   ie.map(:id, /list/)                 # access the first map that matches list.
-    #   ie.map(:index,2)                    # access the second map on the page
-    #   ie.map(:title, "A Picture")         # access a map using the tooltip text. See http://msdn.microsoft.com/workshop/author/dhtml/reference/properties/title_1.asp?frame=true
-    #
-    def map(how, what)
-      return Map.new(self, how, what)
-    end
-    # this is the main method for accessing the maps iterator.
-    #
-    # Returns a maps object
-    #
-    # Typical usage:
-    #
-    #   ie.maps.each { |s| puts s.to_s }            # iterate through all the maps on the page
-    #   ie.maps[1].to_s                             # goto the first map on the page
-    #   ie.maps.length                              # show how many maps are on the page.
-    #
-    def maps
-      return Maps.new(self)
-    end
-    # This is the main method for accessing area tags - http://msdn.microsoft.com/workshop/author/dhtml/reference/objects/area.asp?frame=true
-    #  *  how   - symbol - how we access the area
-    #  *  what  - string, integer or regular expression - what we are looking for,
-    #
-    # Valid values for 'how' are listed in the Watir Wiki - http://wiki.openqa.org/display/WTR/Methods+supported+by+Element
-    #
-    # returns a area object
-    #
-    # Typical Usage
-    #
-    #   ie.area(:id, /list/)                 # access the first area that matches list.
-    #   ie.area(:index,2)                    # access the second area on the page
-    #   ie.area(:title, "A Picture")         # access a area using the tooltip text. See http://msdn.microsoft.com/workshop/author/dhtml/reference/properties/title_1.asp?frame=true
-    #
-    def area(how, what)
-      return Area.new(self, how, what)
-    end
-    # this is the main method for accessing the areas iterator.
-    #
-    # Returns a areas object
-    #
-    # Typical usage:
-    #
-    #   ie.areas.each { |s| puts s.to_s }            # iterate through all the areas on the page
-    #   ie.areas[1].to_s                             # goto the first area on the page
-    #   ie.areas.length                              # show how many areas are on the page.
-    #
-    def areas
-      return Areas.new(self)
-    end
-    # This is the main method for accessing images - normally an <img src="image.gif"> HTML tag.
-    #  *  how   - symbol - how we access the image, :index, :id, :name, :src, :title or :alt are supported
-    #  *  what  - string, integer or regular expression - what we are looking for,
-    #
-    # Valid values for 'how' are listed in the Watir Wiki - http://wiki.openqa.org/display/WTR/Methods+supported+by+Element
-    #
-    # returns an Image object
-    #
-    # Typical Usage
-    #
-    #   ie.image(:src, /myPic/)             # access the first image that matches myPic. We can use a string in place of the regular expression
-    #                                       # but the complete path must be used, ie.image(:src, 'http://myserver.com/my_path/my_image.jpg')
-    #   ie.image(:index,2)                  # access the second image on the page
-    #   ie.image(:alt, "A Picture")         # access an image using the alt text
-    #   ie.image(:xpath, "//img[@alt='A Picture']/")    # access an image using the alt text
-    #
-    def image(how,what=nil)
-      Image.new(self, how, what)
-    end
-    # This is the main method for accessing the images collection. Returns an Images object
-    #
-    # Typical usage:
-    #
-    #   ie.images.each { |i| puts i.to_s }            # iterate through all the images on the page
-    #   ie.images[1].to_s                             # goto the first image on the page
-    #   ie.images.length                              # show how many images are on the page.
-    #
-    def images
-      Images.new(self)
-    end
-    # This is the main method for accessing JavaScript popups.
-    # returns a PopUp object
-    def popup         # BUG this should not be on the container object!
-      PopUp.new(self)
-    end
-    # This is the main method for accessing divs. http://msdn.microsoft.com/workshop/author/dhtml/reference/objects/div.asp?frame=true
-    #  *  how   - symbol - how we access the div
-    #  *  what  - string, integer, regular expression or xpath query - what we are looking for,
-    #
-    # Valid values for 'how' are listed in the Watir Wiki - http://wiki.openqa.org/display/WTR/Methods+supported+by+Element
-    #
-    # returns an Div object
-    #
-    # Typical Usage
-    #
-    #   ie.div(:id, /list/)                 # access the first div that matches list.
-    #   ie.div(:index,2)                    # access the second div on the page
-    #   ie.div(:title, "A Picture")         # access a div using the tooltip text. See http://msdn.microsoft.com/workshop/author/dhtml/reference/properties/title_1.asp?frame=true
-    #   ie.div(:xpath, "//div[@id='list']/")    # access the first div whose id is 'list'
-    #
-    def div(how, what=nil)
-      Div.new(self, how, what)
-    end
-    # this is the main method for accessing the divs iterator. Returns a Divs collection
-    #
-    # Typical usage:
-    #
-    #   ie.divs.each { |d| puts d.to_s }            # iterate through all the divs on the page
-    #   ie.divs[1].to_s                             # goto the first div on the page
-    #   ie.divs.length                              # show how many divs are on the page.
-    #
-    def divs
-      Divs.new(self)
-    end
-    # This is the main method for accessing span tags - http://msdn.microsoft.com/workshop/author/dhtml/reference/objects/span.asp?frame=true
-    #  *  how   - symbol - how we access the span,
-    #  *  what  - string, integer or regular expression - what we are looking for,
-    #
-    # Valid values for 'how' are listed in the Watir Wiki - http://wiki.openqa.org/display/WTR/Methods+supported+by+Element
-    #
-    # returns a Span object
-    #
-    # Typical Usage
-    #
-    #   ie.span(:id, /list/)                 # access the first span that matches list.
-    #   ie.span(:index,2)                    # access the second span on the page
-    #   ie.span(:title, "A Picture")         # access a span using the tooltip text. See http://msdn.microsoft.com/workshop/author/dhtml/reference/properties/title_1.asp?frame=true
-    #
-    def span(how, what=nil)
-      Span.new(self, how, what)
-    end
-    # this is the main method for accessing the spans iterator.
-    #
-    # Returns a Spans object
-    #
-    # Typical usage:
-    #
-    #   ie.spans.each { |s| puts s.to_s }            # iterate through all the spans on the page
-    #   ie.spans[1].to_s                             # goto the first span on the page
-    #   ie.spans.length                              # show how many spans are on the page.
-    #
-    def spans
-      Spans.new(self)
-    end
-    # This is the main method for accessing p tags - http://msdn.microsoft.com/workshop/author/dhtml/reference/objects/p.asp?frame=true
-    #  *  how   - symbol - how we access the p,
-    #  *  what  - string, integer or regular expression - what we are looking for,
-    #
-    # Valid values for 'how' are listed in the Watir Wiki - http://wiki.openqa.org/display/WTR/Methods+supported+by+Element
-    #
-    # returns a P object
-    #
-    # Typical Usage
-    #
-    #   ie.p(:id, /list/)                 # access the first p tag  that matches list.
-    #   ie.p(:index,2)                    # access the second p tag on the page
-    #   ie.p(:title, "A Picture")         # access a p tag using the tooltip text. See http://msdn.microsoft.com/workshop/author/dhtml/reference/properties/title_1.asp?frame=true
-    #
-    def p(how, what=nil)
-      P.new(self, how, what)
-    end
-    # this is the main method for accessing the ps iterator.
-    #
-    # Returns a Ps object
-    #
-    # Typical usage:
-    #
-    #   ie.ps.each { |p| puts p.to_s }            # iterate through all the p tags on the page
-    #   ie.ps[1].to_s                             # goto the first p tag on the page
-    #   ie.ps.length                              # show how many p tags are on the page.
-    #
-    def ps
-      Ps.new(self)
-    end
-    # This is the main method for accessing pre tags - http://msdn.microsoft.com/workshop/author/dhtml/reference/objects/pre.asp?frame=true
-    #  *  how   - symbol - how we access the pre, valid values are
-    #    :index      - finds the item using its index
-    #    :id         - finds the item using its id attribute
-    #    :name       - finds the item using its name attribute
-    #  *  what  - string, integer or re, what we are looking for,
-    #
-    # returns a Pre object
-    #
-    # Typical Usage
-    #
-    #   ie.pre(:id, /list/)                 # access the first pre tag  that matches list.
-    #   ie.pre(:index,2)                    # access the second pre tag on the page
-    #   ie.pre(:title, "A Picture")         # access a pre tag using the tooltip text. See http://msdn.microsoft.com/workshop/author/dhtml/reference/properties/title_1.asp?frame=true
-    #
-    def pre(how, what=nil)
-      Pre.new(self, how, what)
-    end
-    # this is the main method for accessing the ps iterator.
-    #
-    # Returns a Pres object
-    #
-    # Typical usage:
-    #
-    #   ie.pres.each { |pre| puts pre.to_s }        # iterate through all the pre tags on the page
-    #   ie.pres[1].to_s                             # goto the first pre tag on the page
-    #   ie.pres.length                              # show how many pre tags are on the page.
-    #
-    def pres
-      Pres.new(self)
-    end
-    # This is the main method for accessing labels. http://msdn.microsoft.com/workshop/author/dhtml/reference/objects/label.asp?frame=true
-    #  *  how   - symbol - how we access the label,
-    #  *  what  - string, integer or regular expression - what we are looking for,
-    #
-    # Valid values for 'how' are listed in the Watir Wiki - http://wiki.openqa.org/display/WTR/Methods+supported+by+Element
-    #
-    # returns a Label object
-    #
-    # Typical Usage
-    #
-    #   ie.label(:id, /list/)                 # access the first span that matches list.
-    #   ie.label(:index,2)                    # access the second label on the page
-    #   ie.label(:for, "text_1")              # access a the label that is associated with the object that has an id of text_1
-    #
-    def label(how, what=nil)
-      Label.new(self, how, what)
-    end
-    # this is the main method for accessing the labels iterator. It returns a Labels object
-    #
-    # Returns a Labels object
-    #
-    # Typical usage:
-    #
-    #   ie.labels.each { |l| puts l.to_s }            # iterate through all the labels on the page
-    #   ie.labels[1].to_s                             # goto the first label on the page
-    #   ie.labels.length                              # show how many labels are on the page.
-    #
-    def labels
-      Labels.new(self)
-    end
-    #--
-    #
-    # Searching for Page Elements
-    # Not for external consumption
-    #
-    #++
-    def ole_inner_elements
-      return document.body.all
-    end
-    private :ole_inner_elements
-    # This method shows the available objects on the current page.
-    # This is usually only used for debugging or writing new test scripts.
-    # This is a nice feature to help find out what HTML objects are on a page
-    # when developing a test case using Watir.
-    def show_all_objects
-      puts "-----------Objects in page -------------"
-      doc = document
-      s = ""
-      props = ["name", "id", "value", "alt", "src"]
-      doc.all.each do |n|
-        begin
-          s += n.invoke("type").to_s.ljust(16)
-        rescue
-          next
-        end
-        props.each do |prop|
-          begin
-            p = n.invoke(prop)
-            s += "  " + "#{prop}=#{p}".to_s.ljust(18)
-          rescue
-            # this object probably doesnt have this property
-          end
-        end
-        s += "\n"
-      end
-      puts s
-    end
-    #
-    #                Locator Methods
-    #
-    # Returns the specified ole object for input elements on a web page.
-    #
-    # This method is used internally by Watir and should not be used externally. It cannot be marked as private because of the way mixins and inheritance work in watir
-    #
-    #   * how - symbol - the way we look for the object. Supported values are
-    #                  - :name
-    #                  - :id
-    #                  - :index
-    #                  - :value etc
-    #   * what  - string that we are looking for, ex. the name, or id tag attribute or index of the object we are looking for.
-    #   * types - what object types we will look at.
-    #   * value - used for objects that have one name, but many values. ex. radio lists and checkboxes
-    def locate_input_element(how, what, types, value=nil)
-      elements = nil
-      # Searching through all elements returned by ole_inner_elements
-      # is *significantly* slower than IE's getElementById() and
-      # getElementsByName() calls when how is :id or :name.  However
-      # IE doesn't match Regexps, so first we make sure what is a String.
-      # In addition, IE's getElementById() will also return an element
-      # where the :name matches, so we will only return the results of
-      # getElementById() if the matching element actually HAS a matching
-      # :id.
-      begin
-        if what.class == String   # Only use fast calls with String what.
-          if how == :id
-            element = document.getElementById(what)
-            # Return if our fast match really HAS a matching :id
-            return element if element.nil? or element.invoke('id') == what
-          elsif how == :name
-            elements = document.getElementsByName(what)
-          end
-        end
-      rescue
-      end
-      # Use slow methods if the faster methods didn't match
-      elements = ole_inner_elements if elements.nil?
-      how = :value if how == :caption
-      how = :class_name if how == :class
-      what = what.to_i if how == :index
-      value = value.to_s if value unless value.class == String
-      log "getting object - how is #{how} what is #{what} types = #{types} value = #{value}"
-      object_index = 1
-      elements.each do |object|
-        element = Element.new(object)
-        if types.include?(element.type)
-          if how == :index
-            attribute = object_index
-          else
-            begin
-              attribute = element.send(how)
-            rescue NoMethodError
-              raise MissingWayOfFindingObjectException,
-                            "#{how} is an unknown way of finding an <INPUT> element (#{what})"
-            end
-          end
-          if what.matches(attribute)
-            if value
-              if element.value == value
-                return object
-              end
-            else
-              return object
-            end
-          end
-          object_index += 1
-        end
-      end
-      return nil
-    end
-    # returns the ole object for the specified element
-    def locate_tagged_element(tag, how, what)
-      locator = TaggedElementLocator.new(self, tag)
-      locator.set_specifier(how, what)
-      locator.locate
-    end
-  end # module
-  class TaggedElementLocator
-    include Watir
-    include Watir::Exception
-    def initialize(container, tag)
-      @container = container
-      @tag = tag
-    end
-    def set_specifier(how, what)
-      if how.class == Hash and what.nil?
-        specifiers = how
-      else
-        specifiers = {how => what}
-      end
-      @specifiers = {:index => 1} # default if not specified
-      specifiers.each do |how, what|
-        what = what.to_i if how == :index
-        how = :href if how == :url
-        how = :class_name if how == :class
-        @specifiers[how] = what
-      end
-    end
-    def each_element tag
-      @container.document.getElementsByTagName(tag).each do |ole_element|
-        yield Element.new(ole_element)
-      end
-    end
-    def locate
-      index_target = @specifiers[:index]
-      count = 0
-      each_element(@tag) do |element|
-        catch :next_element do
-          @specifiers.each do |how, what|
-            next if how == :index
-            unless match? element, how, what
-              throw :next_element
-            end
-          end
-          count += 1
-          unless index_target == count
-            throw :next_element
-          end
-          return element.ole_object
-        end
-      end # elements
-      nil
-    end
-    def match?(element, how, what)
-      begin
-        method = element.method(how)
-      rescue NameError
-        raise MissingWayOfFindingObjectException,
-              "#{how} is an unknown way of finding a <#{@tag}> element (#{what})"
-      end
-      case method.arity
-      when 0
-        what.matches element.send(how)
-      when 1
-        element.send(how, what)
-      else
-        raise MissingWayOfFindingObjectException,
-              "#{how} is an unknown way of finding a <#{@tag}> element (#{what})"
-      end
-    end
-  end
-  # A PageContainer contains an HTML Document. In other words, it is a
-  # JavaScript Window.
-  module PageContainer
-    include Watir::Exception
-    # This method checks the currently displayed page for http errors, 404, 500 etc
-    # It gets called internally by the wait method, so a user does not need to call it explicitly
-    def check_for_http_error
-      # check for IE7
-      n = self.document.invoke('parentWindow').navigator.appVersion
-      m=/MSIE\s(.*?);/.match( n )
-      if m and m[1] =='7.0'
-        if m=/HTTP (\d\d\d.*)/.match( self.title )
-          raise NavigationException, m[1]
-        end
-      else
-        # assume its IE6
-        url = self.document.url
-        if /shdoclc.dll/.match(url)
-          m = /id=IEText.*?>(.*?)</i.match(self.html)
-          raise NavigationException, m[1] if m
-        end
-      end
-      false
-    end
-    # The HTML Page
-    def page
-      document.documentelement
-    end
-    private :page
-    # The HTML of the current page
-    def html
-      page.outerhtml
-    end
-    # The url of the page object.
-    def url
-      page.document.location.href
-    end
-    # The text of the current page
-    def text
-      page.innertext.strip
-    end
-    def eval_in_spawned_process(command)
-      command.strip!
-      load_path_code = _code_that_copies_readonly_array($LOAD_PATH, '$LOAD_PATH')
-      ruby_code = "require 'watir'; "
-#      ruby_code = "$HIDE_IE = #{$HIDE_IE};" # This prevents attaching to a window from setting it visible. However modal dialogs cannot be attached to when not visible.
-      ruby_code << "pc = #{attach_command}; " # pc = page container
-      # IDEA: consider changing this to not use instance_eval (it makes the code hard to understand)
-      ruby_code << "pc.instance_eval(#{command.inspect})"
-      exec_string = "start rubyw -e #{(load_path_code + '; ' + ruby_code).inspect}"
-      system(exec_string)
-    end
-    def set_container container
-      @container = container
-      @page_container = self
-    end
-    # This method is used to display the available html frames that Internet Explorer currently has loaded.
-    # This method is usually only used for debugging test scripts.
-    def show_frames
-      if allFrames = document.frames
-        count = allFrames.length
-        puts "there are #{count} frames"
-        for i in 0..count-1 do
-          begin
-            fname = allFrames[i.to_s].name.to_s
-            puts "frame  index: #{i + 1} name: #{fname}"
-          rescue => e
-            puts "frame  index: #{i + 1} Access Denied, see http://wiki.openqa.org/display/WTR/FAQ#access-denied" if e.to_s.match(/Access is denied/)
-          end
-        end
-      else
-        puts "no frames"
-      end
-    end
-    # Search the current page for specified text or regexp.
-    # Returns the index if the specified text was found.
-    # Returns matchdata object if the specified regexp was found.
-    #
-    # *Deprecated*
-    # Instead use
-    #   IE#text.include? target
-    # or
-    #   IE#text.match target
-    def contains_text(target)
-        if target.kind_of? Regexp
-          self.text.match(target)
-        elsif target.kind_of? String
-          self.text.index(target)
-        else
-          raise ArgumentError, "Argument #{target} should be a string or regexp."
-        end
-    end
-  end # module
-=begin rdoc
-   This is Watir, Web Application Testing In Ruby
-   http://wtr.rubyforge.org
-   Version "$Revision: 1234 $"
-   Example:
-    # Load the Watir library.
-    require "watir"
-    # Go to the page you want to test.
-    ie = Watir::IE.start("http://myserver/mypage")
-    # Enter "Paul" in a text input field named "username".
-    ie.text_field(:name, "username").set("Paul")
-    # Enter "Ruby Co" in the text input field whose "id" is "company_ID".
-    ie.text_field(:id, "company_ID").set("Ruby Co")
-    # Click on a link that includes the word "green".
-    ie.link(:text, /green/)
-    # Click button that is labelled "Cancel".
-    ie.button(:value, "Cancel").click
-   The Watir::IE class allows your test to read and interact with HTML
-   elements on a page, including their attributes and contents.
-   The class includes many methods for accessing HTML elements, including the
-   following:
-   #button::     <input> tags with type=button, submit, image or reset
-   #check_box::  <input> tags with type=checkbox
-   #div::        <div> tags
-   #form::       <form> tags
-   #frame::      frames, including both the <frame> elements and the
-                corresponding pages.
-   #hidden::       <input> tags with type=hidden
-   #image::        <img> tags
-   #label::        <label> tags (including "for" attribute)
-   #link::         <a> (anchor) tags
-   #p::            <p> (paragraph) tags
-   #radio::        <input> tags with the type=radio; known as radio buttons
-   #select_list::  <select> tags, known as drop-downs or drop-down lists
-   #span::         <span> tags
-   #table::        <table> tags, including +row+ and +cell+ methods for accessing
-                nested elements.
-   #text_field   <input> tags with the type=text (single-line), type=textarea
-                (multi-line), and type=password
-   #map::          <map> tags
-   #area::         <area> tags
-   #li::           <li> tags
-   In general, there are several ways to identify a specific object.  WATIR's
-   syntax is in the form (how, what), where "how" is a means of identifying
-   the object, and "what" is the specific string or regular expression
-   that WATIR will seek, as shown in the examples above.  Available "how"
-   options depend upon the type of object, but here are a few examples:
-   How           Description
-   ============  ===============================================================
-   :id           Used to find an object that has an "id=" attribute. Since each
-                 id should be unique, according to the XHTML specification,
-                 this is recommended as the most reliable method to find an
-                 object.
-   :name         Used to find an object that has a "name=" attribute.  This is
-                 useful for older versions of HTML, but "name" is deprecated
-                 in XHTML.
-   :value        Used to find a text field with a given default value, or a
-                 button with a given caption
-   :index        Used to find the nth object of the specified type on a page.
-                 For example, button(:index, 2) finds the second button.
-                 Current versions of WATIR use 1-based indexing, but future
-                 versions will use 0-based indexing.
-   :xpath        Uses xpath (see separate doc)
-   Note that the XHTML specification requires that tags and their attributes be
-   in lower case.  WATIR doesn't enforce this; WATIR will find tags and
-   attributes whether they're in upper, lower, or mixed case.  This is either
-   a bug or a feature.
-   WATIR uses Microsoft's Document Object Model (DOM) as implemented by Internet
-   Explorer.  For further information on Internet Explorer and on the DOM, go to
-   the following Web pages:
-   http://msdn.microsoft.com/library/default.asp?url=/workshop/browser/webbrowser/webbrowser.asp
-   http://msdn.microsoft.com/library/default.asp?url=/workshop/browser/overview/overview.asp
-   WATIR supports command-line options:
-   -b  (background)   Run Internet Explorer invisibly
-   -f  (fast)         By default, WATIR types slowly and pauses briefly between
-                      actions.  This switch removes the delays and sets WATIR
-                      to run at full speed.  The set_fast_speed method of the
-                      IE object performs the same function; set_slow_speed
-                      returns WATIR to its default behaviour.
-=end
-  class IE
-    include Watir::Exception
-    include Container
-    include PageContainer
-    def self.quit
-    end
-    # Maximum number of seconds to wait when attaching to a window
-    def self.reset_attach_timeout
-      @@attach_timeout = 2.0
-    end
-    reset_attach_timeout
-    def self.attach_timeout
-      @@attach_timeout
-    end
-    def self.attach_timeout=(timeout)
-      @@attach_timeout = timeout
-    end
-    # The revision number (according to Subversion)
-    REVISION_STRING = '$Revision: 1234 $'
-    REVISION_STRING.scan(/Revision: (\d*)/)
-    REVISION = $1 or 'unknown'
-    # The Release number
-    VERSION_SHORT = '1.5.2'
-    VERSION = VERSION_SHORT + '.' + REVISION
-    # Used internally to determine when IE has finished loading a page
-    READYSTATE_COMPLETE = 4
-    # TODO: the following constants should be able to be specified by object (not class)
-    # The delay when entering text on a web page when speed = :slow.
-    DEFAULT_TYPING_SPEED = 0.08
-    # The default time we wait after a page has loaded when speed = :slow.
-    DEFAULT_SLEEP_TIME = 0.1
-    # The default color for highlighting objects as they are accessed.
-    HIGHLIGHT_COLOR = 'yellow'
-    # IE inserts some element whose tagName is empty and just acts as block level element
-    # Probably some IE method of cleaning things
-    # To pass the same to REXML we need to give some name to empty tagName
-    EMPTY_TAG_NAME = "DUMMY"
-    # The time, in seconds, it took for the new page to load after executing the
-    # the last command
-    attr_reader :down_load_time
-    # Whether the speed is :fast or :slow
-    attr_reader :speed
-    # the OLE Internet Explorer object
-    attr_accessor :ie
-    # access to the logger object
-    attr_accessor :logger
-    # this contains the list of unique urls that have been visited
-    attr_reader :url_list
-    # Create a new IE window. Works just like IE.new in Watir 1.4.
-    def self.new_window
-      ie = new true
-      ie._new_window_init
-      ie
-    end
-    # Create an IE browser.
-    def initialize suppress_new_window=nil
-      _new_window_init unless suppress_new_window
-    end
-    def _new_window_init
-      create_browser_window
-      set_defaults
-      goto 'about:blank' # this avoids numerous problems caused by lack of a document
-    end
-    # Create a new IE Window, starting at the specified url.
-    # If no url is given, start empty.
-    def self.start url=nil
-      start_window url
-    end
-    # Create a new IE window, starting at the specified url.
-    # If no url is given, start empty. Works like IE.start in Watir 1.4.
-    def self.start_window url=nil
-      ie = new_window
-      ie.goto url if url
-      ie
-    end
-    # Create a new IE window in a new process.
-    # This method will not work when
-    # Watir/Ruby is run under a service (instead of a user).
-    def self.new_process
-      ie = new true
-      ie._new_process_init
-      ie
-    end
-    def _new_process_init
-      iep = Process.start
-      @ie = iep.window
-      @process_id = iep.process_id
-      set_defaults
-      goto 'about:blank'
-    end
-    # Create a new IE window in a new process, starting at the specified URL.
-    # Same as IE.start.
-    def self.start_process url=nil
-      ie = new_process
-      ie.goto url if url
-      ie
-    end
-    # Return a Watir::IE object for an existing IE window. Window can be
-    # referenced by url, title, or window handle.
-    # Second argument can be either a string or a regular expression in the
-    # case of of :url or :title.
-    # IE.attach(:url, 'http://www.google.com')
-    # IE.attach(:title, 'Google')
-    # IE.attach(:hwnd, 528140)
-    # This method will not work when
-    # Watir/Ruby is run under a service (instead of a user).
-    def self.attach how, what
-      ie = new true # don't create window
-      ie._attach_init(how, what)
-      ie
-    end
-    # this method is used internally to attach to an existing window
-    def _attach_init how, what
-      attach_browser_window how, what
-      set_defaults
-      wait
-    end
-    # Return an IE object that wraps the given window, typically obtained from
-    # Shell.Application.windows.
-    def self.bind window
-      ie = new true
-      ie.ie = window
-      ie.set_defaults
-      ie
-    end
-    def create_browser_window
-      @ie = WIN32OLE.new('InternetExplorer.Application')
-    end
-    private :create_browser_window
-    def set_defaults
-      self.visible = ! $HIDE_IE
-      @ole_object = nil
-      @page_container = self
-      @error_checkers = []
-      @activeObjectHighLightColor = HIGHLIGHT_COLOR
-      if $FAST_SPEED
-        set_fast_speed
-      else
-        set_slow_speed
-      end
-      @logger = DefaultLogger.new
-      @url_list = []
-    end
-    def speed= how_fast
-      case how_fast
-      when :fast : set_fast_speed
-      when :slow : set_slow_speed
-      else
-        raise ArgumentError, "Invalid speed: #{how_fast}"
-      end
-    end
-    # deprecated: use speed = :fast instead
-    def set_fast_speed
-      @typingspeed = 0
-      @defaultSleepTime = 0.01
-      @speed = :fast
-    end
-    # deprecated: use speed = :slow instead
-    def set_slow_speed
-      @typingspeed = DEFAULT_TYPING_SPEED
-      @defaultSleepTime = DEFAULT_SLEEP_TIME
-      @speed = :slow
-    end
-    def visible
-      @ie.visible
-    end
-    def visible=(boolean)
-      @ie.visible = boolean if boolean != @ie.visible
-    end
-    # Yields successively to each IE window on the current desktop. Takes a block.
-    # This method will not work when
-    # Watir/Ruby is run under a service (instead of a user).
-	# Yields to the window and its hwnd.
-    def self.each
-      shell = WIN32OLE.new('Shell.Application')
-      shell.Windows.each do |window|
-        next unless (window.path =~ /Internet Explorer/ rescue false)
-        next unless (hwnd = window.hwnd rescue false)
-        ie = IE.bind(window)
-        ie.hwnd = hwnd
-        yield ie
-      end
-    end
-    # return internet explorer instance as specified. if none is found,
-    # return nil.
-    # arguments:
-    #   :url, url -- the URL of the IE browser window
-    #   :title, title -- the title of the browser page
-    #   :hwnd, hwnd -- the window handle of the browser window.
-    # This method will not work when
-    # Watir/Ruby is run under a service (instead of a user).
-    def self.find(how, what)
-      ie_ole = IE._find(how, what)
-      IE.bind ie_ole if ie_ole
-    end
-    def self._find(how, what)
-      ieTemp = nil
-      IE.each do |ie|
-        window = ie.ie
-        case how
-        when :url
-          ieTemp = window if (what.matches(window.locationURL))
-        when :title
-          # normal windows explorer shells do not have document
-          # note window.document will fail for "new" browsers
-          begin
-            title = window.locationname
-            title = window.document.title
-          rescue WIN32OLERuntimeError
-          end
-          ieTemp = window if what.matches(title)
-        when :hwnd
-          begin
-            ieTemp = window if what == window.HWND
-          rescue WIN32OLERuntimeError
-          end
-        else
-          raise ArgumentError
-        end
-      end
-      return ieTemp
-    end
-    def attach_browser_window how, what
-      log "Seeking Window with #{how}: #{what}"
-      ieTemp = nil
-      begin
-        Watir::until_with_timeout do
-          ieTemp = IE._find how, what
-        end
-      rescue TimeOutException
-        raise NoMatchingWindowFoundException,
-                 "Unable to locate a window with #{how} of #{what}"
-      end
-      @ie = ieTemp
-    end
-    private :attach_browser_window
-    # Return the current window handle
-    def hwnd
-      raise "Not attached to a browser" if @ie.nil?
-      @hwnd ||= @ie.hwnd
-    end
-    attr_writer :hwnd
-    include Watir::Win32
-  	# Are we attached to an open browser?
-    def exists?
-      return false if @closing
-      begin
-        @ie.name =~ /Internet Explorer/
-      rescue WIN32OLERuntimeError
-        false
-      end
-    end
-    alias :exist? :exists?
-    # deprecated: use logger= instead
-    def set_logger(logger)
-      @logger = logger
-    end
-    def log(what)
-      @logger.debug(what) if @logger
-    end
-    #
-    # Accessing data outside the document
-    #
-    # Return the title of the document
-    def title
-      @ie.document.title
-    end
-    # Return the status of the window, typically from the status bar at the bottom.
-    def status
-      raise NoStatusBarException if !@ie.statusBar
-      return @ie.statusText
-    end
-    #
-    # Navigation
-    #
-    # Navigate to the specified URL.
-    #  * url - string - the URL to navigate to
-    def goto(url)
-      @ie.navigate(url)
-      wait
-      return @down_load_time
-    end
-    # Go to the previous page - the same as clicking the browsers back button
-    # an WIN32OLERuntimeError exception is raised if the browser cant go back
-    def back
-      @ie.GoBack
-      wait
-    end
-    # Go to the next page - the same as clicking the browsers forward button
-    # an WIN32OLERuntimeError exception is raised if the browser cant go forward
-    def forward
-      @ie.GoForward
-      wait
-    end
-    # Refresh the current page - the same as clicking the browsers refresh button
-    # an WIN32OLERuntimeError exception is raised if the browser cant refresh
-    def refresh
-      @ie.refresh2(3)
-      wait
-    end
-    # clear the list of urls that we have visited
-    def clear_url_list
-      @url_list.clear
-    end
-    # Closes the Browser
-    def close
-      @closing = true
-      @ie.quit
-    end
-    # Maximize the window (expands to fill the screen)
-    def maximize
-      set_window_state :SW_MAXIMIZE
-    end
-    # Minimize the window (appears as icon on taskbar)
-    def minimize
-      set_window_state :SW_MINIMIZE
-    end
-    # Restore the window (after minimizing or maximizing)
-    def restore
-      set_window_state :SW_RESTORE
-    end
-    # Make the window come to the front
-    def bring_to_front
-      autoit.WinActivate title, ''
-    end
-    def front?
-      1 == autoit.WinActive(title, '')
-    end
-    private
-    def set_window_state(state)
-      autoit.WinSetState title, '', autoit.send(state)
-    end
-    def autoit
-      Watir::autoit
-    end
-    public
-    # Send key events to IE window.
-    # See http://www.autoitscript.com/autoit3/docs/appendix/SendKeys.htm
-    # for complete documentation on keys supported and syntax.
-    def send_keys(key_string)
-      autoit.WinActivate title
-      autoit.Send key_string
-    end
-    def dir
-      return File.expand_path(File.dirname(__FILE__))
-    end
-    #
-    # Document and Document Data
-    #
-    # Return the current document
-    def document
-      return @ie.document
-    end
-    # returns the current url, as displayed in the address bar of the browser
-    def url
-      return @ie.LocationURL
-    end
-    #
-    # Synchronization
-    #
-    include Watir::Utils
-    # Block execution until the page has loaded.
-    # =nodoc
-    # Note: This code needs to be prepared for the ie object to be closed at
-    # any moment!
-    def wait(no_sleep=false)
-      @rexmlDomobject = nil
-      @down_load_time = 0.0
-      a_moment = 0.2 # seconds
-      start_load_time = Time.now
-      begin
-        while @ie.busy # XXX need to add time out
-          sleep a_moment
-        end
-        until @ie.readyState == READYSTATE_COMPLETE do
-          sleep a_moment
-        end
-        sleep a_moment
-        until @ie.document do
-          sleep a_moment
-        end
-        documents_to_wait_for = [@ie.document]
-      rescue WIN32OLERuntimeError # IE window must have been closed
-        @down_load_time = Time.now - start_load_time
-        sleep @defaultSleepTime unless no_sleep
-        return @down_load_time
-      end
-      while doc = documents_to_wait_for.shift
-        begin
-          until doc.readyState == "complete" do
-            sleep a_moment
-          end
-          @url_list << doc.url unless @url_list.include?(doc.url)
-          doc.frames.length.times do |n|
-            begin
-              documents_to_wait_for << doc.frames[n.to_s].document
-            rescue WIN32OLERuntimeError
-            end
-          end
-        rescue WIN32OLERuntimeError
-        end
-      end
-      @down_load_time = Time.now - start_load_time
-      run_error_checks
-      sleep @defaultSleepTime unless no_sleep
-      @down_load_time
-    end
-    # Error checkers
-    # this method runs the predefined error checks
-    def run_error_checks
-      @error_checkers.each { |e| e.call(self) }
-    end
-    # this method is used to add an error checker that gets executed on every page load
-    # *  checker   Proc Object, that contains the code to be run
-    def add_checker(checker)
-      @error_checkers << checker
-    end
-    # this allows a checker to be disabled
-    # *  checker   Proc Object, the checker that is to be disabled
-    def disable_checker(checker)
-      @error_checkers.delete(checker)
-    end
-    #
-    # Show me state
-    #
-    # Show all forms displays all the forms that are on a web page.
-    def show_forms
-      if allForms = document.forms
-        count = allForms.length
-        puts "There are #{count} forms"
-        for i in 0..count-1 do
-          wrapped = FormWrapper.new(allForms.item(i))
-          puts "Form name: #{wrapped.name}"
-          puts "       id: #{wrapped.id}"
-          puts "   method: #{wrapped.method}"
-          puts "   action: #{wrapped.action}"
-        end
-      else
-        puts "No forms"
-      end
-    end
-    # this method shows all the images availble in the document
-    def show_images
-      doc = document
-      index = 1
-      doc.images.each do |l|
-        puts "image: name: #{l.name}"
-        puts "         id: #{l.invoke("id")}"
-        puts "        src: #{l.src}"
-        puts "      index: #{index}"
-        index += 1
-      end
-    end
-    # this method shows all the links availble in the document
-    def show_links
-      props = ["name", "id", "href"]
-      print_sizes = [12, 12, 60]
-      doc = document
-      index = 0
-      text_size = 60
-      # draw the table header
-      s = "index".ljust(6)
-      props.each_with_index do |p, i|
-        s += p.ljust(print_sizes[i])
-      end
-      s += "text/src".ljust(text_size)
-      s += "\n"
-      # now get the details of the links
-      doc.links.each do |n|
-        index += 1
-        s = s + index.to_s.ljust(6)
-        props.each_with_index do |prop, i|
-          printsize = print_sizes[i]
-          begin
-            p = n.invoke(prop)
-            temp_var = "#{p}".to_s.ljust(printsize)
-          rescue
-            # this object probably doesnt have this property
-            temp_var = "".to_s.ljust(printsize)
-          end
-          s += temp_var
-        end
-        s += n.innerText
-        if n.getElementsByTagName("IMG").length > 0
-          s += " / " + n.getElementsByTagName("IMG")[0.to_s].src
-        end
-        s += "\n"
-      end
-      puts s
-    end
-    # this method shows the name, id etc of the object that is currently active - ie the element that has focus
-    # its mostly used in irb when creating a script
-    def show_active
-      s = ""
-      current = document.activeElement
-      begin
-        s += current.invoke("type").to_s.ljust(16)
-      rescue
-      end
-      props = ["name", "id", "value", "alt", "src", "innerText", "href"]
-      props.each do |prop|
-        begin
-          p = current.invoke(prop)
-          s += "  " + "#{prop}=#{p}".to_s.ljust(18)
-        rescue
-          #this object probably doesnt have this property
-        end
-      end
-      s += "\n"
-    end
-    # this method shows all the divs availble in the document
-    def show_divs
-      divs = document.getElementsByTagName("DIV")
-      puts "Found #{divs.length} div tags"
-      index = 1
-      divs.each do |d|
-        puts "#{index}  id=#{d.invoke('id')}      class=#{d.invoke("className")}"
-        index += 1
-      end
-    end
-    # this method is used to show all the tables that are available
-    def show_tables
-      tables = document.getElementsByTagName("TABLE")
-      puts "Found #{tables.length} tables"
-      index = 1
-      tables.each do |d|
-        puts "#{index}  id=#{d.invoke('id')}      rows=#{d.rows.length}   columns=#{begin d.rows["0"].cells.length; rescue; end}"
-        index += 1
-      end
-    end
-    def show_pres
-      pres = document.getElementsByTagName("PRE")
-      puts "Found #{ pres.length } pre tags"
-      index = 1
-      pres.each do |d|
-        puts "#{index}   id=#{d.invoke('id')}      class=#{d.invoke("className")}"
-        index+=1
-      end
-    end
-    # this method shows all the spans availble in the document
-    def show_spans
-      spans = document.getElementsByTagName("SPAN")
-      puts "Found #{spans.length} span tags"
-      index = 1
-      spans.each do |d|
-        puts "#{index}   id=#{d.invoke('id')}      class=#{d.invoke("className")}"
-        index += 1
-      end
-    end
-    def show_labels
-      labels = document.getElementsByTagName("LABEL")
-      puts "Found #{labels.length} label tags"
-      index = 1
-      labels.each do |d|
-        puts "#{index}  text=#{d.invoke('innerText')}      class=#{d.invoke("className")}  for=#{d.invoke("htmlFor")}"
-        index += 1
-      end
-    end
-    # Gives focus to the frame
-    def focus
-      document.activeElement.blur
-      document.focus
-    end
-    #
-    # Functions written for using xpath for getting the elements.
-    #
-    # Get the Rexml object.
-    def rexml_document_object
-      #puts "Value of rexmlDomobject is : #{@rexmlDomobject}"
-      if @rexmlDomobject == nil
-        create_rexml_document_object
-      end
-      return @rexmlDomobject
-    end
-    # Create the Rexml object if it is nil. This method is private so can be called only
-    # from rexml_document_object method.
-    def create_rexml_document_object
-      # Use our modified rexml libraries
-      require 'rexml/document'
-      unless REXML::Version >= '3.1.4'
-        raise "Requires REXML version of at least 3.1.4. Actual: #{REXML::Version}"
-      end
-      if @rexmlDomobject == nil
-        htmlSource ="<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<HTML>\n"
-        htmlSource = html_source(document.body,htmlSource," ")
-        htmlSource += "\n</HTML>\n"
-	# Angrez: Resolving Jira issue WTR-114
-	htmlSource = htmlSource.gsub(/&nbsp;/, '&#160;')
-        begin
-          @rexmlDomobject = REXML::Document.new(htmlSource)
-        rescue => e
-          output_rexml_document("error.xml", htmlSource)
-          raise e
-        end
-      end
-    end
-    private :create_rexml_document_object
-    def output_rexml_document(name, text)
-      file = File.open(name,"w")
-      file.print(text)
-      file.close
-    end
-    private :output_rexml_document
-    #Function Tokenizes the tag line and returns array of tokens.
-    #Token could be either tagName or "=" or attribute name or attribute value
-    #Attribute value could be either quoted string or single word
-    def tokenize_tagline(outerHtml)
-      outerHtml = outerHtml.gsub(/\n|\r/," ")
-      #removing "< symbol", opening of current tag
-      outerHtml =~ /^\s*<(.*)$/
-      outerHtml = $1
-      tokens = Array.new
-      i = startOffset = 0
-      length = outerHtml.length
-      #puts outerHtml
-      parsingValue = false
-      while i < length do
-        i +=1 while (i < length && outerHtml[i,1] =~ /\s/)
-        next if i == length
-        currentToken = outerHtml[i,1]
-        #Either current tag has been closed or user has not closed the tag >
-        # and we have received the opening of next element
-        break if currentToken =~ /<|>/
-        #parse quoted value
-        if(currentToken == "\"" || currentToken == "'")
-          parsingValue = false
-          quote = currentToken
-          startOffset = i
-          i += 1
-          i += 1 while (i < length && (outerHtml[i,1] != quote || outerHtml[i-1,1] == "\\"))
-          if i == length
-            tokens.push quote + outerHtml[startOffset..i-1]
-          else
-            tokens.push outerHtml[startOffset..i]
-          end
-        elsif currentToken == "="
-          tokens.push "="
-          parsingValue = true
-        else
-          startOffset = i
-          i += 1 while (i < length && !(outerHtml[i,1] =~ /\s|=|<|>/)) if !parsingValue
-          i += 1 while (i < length && !(outerHtml[i,1] =~ /\s|<|>/)) if parsingValue
-          parsingValue = false
-          i -= 1
-          tokens.push outerHtml[startOffset..i]
-        end
-        i += 1
-      end
-      return tokens
-    end
-    private :tokenize_tagline
-    # This function get and clean all the attributes of the tag.
-    def all_tag_attributes(outerHtml)
-      tokens = tokenize_tagline(outerHtml)
-      #puts tokens
-      tagLine = ""
-      count = 1
-      tokensLength = tokens.length
-      expectedEqualityOP= false
-      while count < tokensLength do
-        if expectedEqualityOP == false
-          #print Attribute Name
-          # If attribute name is valid. Refer: http://www.w3.org/TR/REC-xml/#NT-Name
-          if tokens[count] =~ /^(\w|_|:)(.*)$/
-            tagLine += " #{tokens[count]}"
-            expectedEqualityOP = true
-          end
-        elsif tokens[count] == "="
-          count += 1
-          if count == tokensLength
-            tagLine += "=\"\""
-          elsif(tokens[count][0,1] == "\"" || tokens[count][0,1] == "'")
-            tagLine += "=#{tokens[count]}"
-          else
-            tagLine += "=\"#{tokens[count]}\""
-          end
-          expectedEqualityOP = false
-        else
-          #Opps! equality was expected but its not there.
-          #Set value same as the attribute name e.g. selected="selected"
-          tagLine += "=\"#{tokens[count-1]}\""
-          expectedEqualityOP = false
-          next
-        end
-        count += 1
-      end
-      tagLine += "=\"#{tokens[count-1]}\" " if expectedEqualityOP == true
-      #puts tagLine
-      return tagLine
-    end
-    private :all_tag_attributes
-    # This function is used to escape the characters that are not valid XML data.
-    def xml_escape(str)
-      str = str.gsub(/&/,'&amp;')
-      str = str.gsub(/</,'&lt;')
-      str = str.gsub(/>/,'&gt;')
-      str = str.gsub(/"/, '&quot;')
-      str
-    end
-    private :xml_escape
-    # Returns HTML Source
-    # Traverse the DOM tree rooted at body element
-    # and generate the HTML source.
-    # element: Represent Current element
-    # htmlString:HTML Source
-    # spaces:(Used for debugging). Helps in indentation
-    def html_source(element, htmlString, spaceString)
-      begin
-        tagLine = ""
-        outerHtml = ""
-        tagName = ""
-        begin
-          tagName = element.tagName.downcase
-          tagName = EMPTY_TAG_NAME if tagName == ""
-          # If tag is a mismatched tag.
-          if !(tagName =~ /^(\w|_|:)(.*)$/)
-            return htmlString
-          end
-        rescue
-          #handling text nodes
-          htmlString += xml_escape(element.toString)
-          return htmlString
-        end
-        #puts tagName
-        #Skip comment and script tag
-        if tagName =~ /^!/ || tagName== "script" || tagName =="style"
-          return htmlString
-        end
-        #tagLine += spaceString
-        outerHtml = all_tag_attributes(element.outerHtml) if tagName != EMPTY_TAG_NAME
-        tagLine += "<#{tagName} #{outerHtml}"
-        canHaveChildren = element.canHaveChildren
-        if canHaveChildren
-          tagLine += ">"
-        else
-          tagLine += "/>" #self closing tag
-        end
-        #spaceString += spaceString
-        htmlString += tagLine
-        childElements = element.childnodes
-        childElements.each do |child|
-          htmlString = html_source(child,htmlString,spaceString)
-        end
-        if canHaveChildren
-          #tagLine += spaceString
-          tagLine ="</" + tagName + ">"
-          htmlString += tagLine
-        end
-        return htmlString
-      rescue => e
-        puts e.to_s
-      end
-      return htmlString
-    end
-    private :html_source
-    # return the first element that matches the xpath
-    def element_by_xpath(xpath)
-      temp = elements_by_xpath(xpath)
-      temp = temp[0] if temp
-      return temp
-    end
-    # execute xpath and return an array of elements
-    def elements_by_xpath(xpath)
-      doc = rexml_document_object
-      modifiedXpath = ""
-      selectedElements = Array.new
-      doc.elements.each(xpath) do |element|
-        modifiedXpath = element.xpath                   # element = a REXML element
-#        puts "modified xpath: #{modifiedXpath}"
-#        puts "text: #{element.text}"
-#        puts "class: #{element.attributes['class']}"
-#        require 'breakpoint'; breakpoint
-        temp = element_by_absolute_xpath(modifiedXpath) # temp = a DOM/COM element
-        selectedElements << temp if temp != nil
-      end
-      #puts selectedElements.length
-      if selectedElements.length == 0
-        return nil
-      else
-        return selectedElements
-      end
-    end
-    # Method that iterates over IE DOM object and get the elements for the given
-    # xpath.
-    def element_by_absolute_xpath(xpath)
-      curElem = nil
-      #puts "Hello; Given xpath is : #{xpath}"
-      doc = document
-      curElem = doc.getElementsByTagName("body")["0"]
-      xpath =~ /^.*\/body\[?\d*\]?\/(.*)/
-      xpath = $1
-      if xpath == nil
-        puts "Function Requires absolute XPath."
-        return
-      end
-      arr = xpath.split(/\//)
-      return nil if arr.length == 0
-      lastTagName = arr[arr.length-1].to_s.upcase
-      # lastTagName is like tagName[number] or just tagName. For the first case we need to
-      # separate tagName and number.
-      lastTagName =~ /(\w*)\[?\d*\]?/
-      lastTagName = $1
-      #puts lastTagName
-      for element in arr do
-        element =~ /(\w*)\[?(\d*)\]?/
-        tagname = $1
-        tagname = tagname.upcase
-        if $2 != nil && $2 != ""
-          index = $2
-          index = "#{index}".to_i - 1
-        else
-          index = 0
-        end
-        #puts "#{element} #{tagname} #{index}"
-        allElemns = curElem.childnodes
-        if allElemns == nil || allElemns.length == 0
-          puts "#{element} is null"
-          next # Go to next element
-        end
-        #puts "Current element is : #{curElem.tagName}"
-        allElemns.each do |child|
-          gotIt = false
-          begin
-            curTag = child.tagName
-            curTag = EMPTY_TAG_NAME if curTag == ""
-          rescue
-            next
-          end
-          #puts child.tagName
-          if curTag == tagname
-            index-=1
-            if index < 0
-              curElem = child
-              break
-            end
-          end
-        end
-      #puts "Node selected at index #{index.to_s} : #{curElem.tagName}"
-      end
-      begin
-        if curElem.tagName == lastTagName
-          #puts curElem.tagName
-          return curElem
-        else
-          return nil
-        end
-      rescue
-        return nil
-      end
-    end
-    private :element_by_absolute_xpath
-    def attach_command
-      "Watir::IE.attach(:hwnd, #{hwnd})"
-    end
-  end # class IE
-  #
-  # MOVETO: watir/popup.rb
-  # Module Watir::Popup
-  #
-  # POPUP object
-  class PopUp
-    def initialize(container)
-      @container = container
-      @page_container = container.page_container
-    end
-    def button(caption)
-      return JSButton.new(@container.getIE.hwnd, caption)
-    end
-  end
-  class JSButton
-    def initialize(hWnd, caption)
-      @hWnd = hWnd
-      @caption = caption
-    end
-    def startClicker(waitTime=3)
-      clicker = WinClicker.new
-      clicker.clickJSDialog_Thread
-      # clickerThread = Thread.new(@caption) {
-      #   sleep waitTime
-      #   puts "After the wait time in startClicker"
-      #   clickWindowsButton_hwnd(hwnd, buttonCaption)
-      #}
-    end
-  end
-  # Base class for html elements.
-  # This is not a class that users would normally access.
-  class Element # Wrapper
-    include Watir::Exception
-    include Container # presumes @container is defined
-    attr_accessor :container
-    # number of spaces that separate the property from the value in the to_s method
-    TO_S_SIZE = 14
-    # ole_object - the ole object for the element being wrapped
-    def initialize(ole_object)
-      @o = ole_object
-      @original_color = nil
-    end
-    # Return the ole object, allowing any methods of the DOM that Watir doesn't support to be used.
-    def ole_object # BUG: should use an attribute reader and rename the instance variable
-      return @o
-    end
-    def ole_object=(o)
-      @o = o
-    end
-    private
-    def self.def_wrap(ruby_method_name, ole_method_name=nil)
-      ole_method_name = ruby_method_name unless ole_method_name
-      class_eval "def #{ruby_method_name}
-                          assert_exists
-                          ole_object.invoke('#{ole_method_name}')
-                        end"
-    end
-    def self.def_wrap_guard(method_name)
-      class_eval "def #{method_name}
-                          assert_exists
-                          begin
-                            ole_object.invoke('#{method_name}')
-                          rescue
-                            ''
-                          end
-                        end"
-    end
-    public
-    def assert_exists
-      locate if defined?(locate)
-      unless ole_object
-        raise UnknownObjectException.new("Unable to locate object, using #{@how} and #{@what}")
-      end
-    end
-    def assert_enabled
-      unless enabled?
-        raise ObjectDisabledException, "object #{@how} and #{@what} is disabled"
-      end
-    end
-    # return the name of the element (as defined in html)
-    def_wrap_guard :name
-    # return the id of the element
-    def_wrap_guard :id
-    # return whether the element is disabled
-    def_wrap :disabled
-    alias disabled? disabled
-    # return the value of the element
-    def_wrap_guard :value
-    # return the title of the element
-    def_wrap_guard :title
-    # return the style of the element
-    def_wrap_guard :style
-    def_wrap_guard :alt
-    def_wrap_guard :src
-    # return the type of the element
-    def_wrap_guard :type # input elements only
-    # return the url the link points to
-    def_wrap :href # link only
-    # return the ID of the control that this label is associated with
-    def_wrap :for, :htmlFor # label only
-    # return the class name of the element
-    # raise an ObjectNotFound exception if the object cannot be found
-    def_wrap :class_name, :className
-    # return the unique COM number for the element
-    def_wrap :unique_number, :uniqueNumber
-    # Return the outer html of the object - see http://msdn.microsoft.com/workshop/author/dhtml/reference/properties/outerhtml.asp?frame=true
-    def_wrap :html, :outerHTML
-    # return the text before the element
-    def before_text # label only
-      assert_exists
-      begin
-        ole_object.getAdjacentText("afterEnd").strip
-      rescue
-                ''
-      end
-    end
-    # return the text after the element
-    def after_text # label only
-      assert_exists
-      begin
-        ole_object.getAdjacentText("beforeBegin").strip
-      rescue
-                ''
-      end
-    end
-    # Return the innerText of the object
-    # Raise an ObjectNotFound exception if the object cannot be found
-    def text
-      assert_exists
-      return ole_object.innerText.strip
-    end
-    def ole_inner_elements
-      assert_exists
-      return ole_object.all
-    end
-    private :ole_inner_elements
-    def document
-      assert_exists
-      return ole_object
-    end
-    # Return the element immediately containing self.
-    def parent
-      assert_exists
-      result = Element.new(ole_object.parentelement)
-      result.set_container self
-      result
-    end
-    include Comparable
-    def <=> other
-      assert_exists
-      other.assert_exists
-      ole_object.sourceindex <=> other.ole_object.sourceindex
-    end
-    # Return true if self is contained earlier in the html than other.
-    alias :before? :<
-    # Return true if self is contained later in the html than other.
-    alias :after? :>
-    def typingspeed
-      @container.typingspeed
-    end
-    def activeObjectHighLightColor
-      @container.activeObjectHighLightColor
-    end
-    # Return an array with many of the properties, in a format to be used by the to_s method
-    def string_creator
-      n = []
-      n <<   "type:".ljust(TO_S_SIZE) + self.type
-      n <<   "id:".ljust(TO_S_SIZE) +         self.id.to_s
-      n <<   "name:".ljust(TO_S_SIZE) +       self.name.to_s
-      n <<   "value:".ljust(TO_S_SIZE) +      self.value.to_s
-      n <<   "disabled:".ljust(TO_S_SIZE) +   self.disabled.to_s
-      return n
-    end
-    private :string_creator
-    # Display basic details about the object. Sample output for a button is shown.
-    # Raises UnknownObjectException if the object is not found.
-    #      name      b4
-    #      type      button
-    #      id         b5
-    #      value      Disabled Button
-    #      disabled   true
-    def to_s
-      assert_exists
-      return string_creator.join("\n")
-    end
-    # This method is responsible for setting and clearing the colored highlighting on the currently active element.
-    # use :set   to set the highlight
-    #   :clear  to clear the highlight
-    # TODO: Make this two methods: set_highlight & clear_highlight
-    # TODO: Remove begin/rescue blocks
-    def highlight(set_or_clear)
-      if set_or_clear == :set
-        begin
-          @original_color ||= style.backgroundColor
-          style.backgroundColor = @container.activeObjectHighLightColor
-        rescue
-          @original_color = nil
-        end
-      else # BUG: assumes is :clear, but could actually be anything
-        begin
-          style.backgroundColor = @original_color unless @original_color == nil
-        rescue
-          # we could be here for a number of reasons...
-          # e.g. page may have reloaded and the reference is no longer valid
-        ensure
-          @original_color = nil
-        end
-      end
-    end
-    private :highlight
-    #   This method clicks the active element.
-    #   raises: UnknownObjectException  if the object is not found
-    #   ObjectDisabledException if the object is currently disabled
-    def click
-      click!
-      @container.wait
-    end
-    def click_no_wait
-      assert_enabled
-      highlight(:set)
-      object = "#{self.class}.new(self, :unique_number, #{self.unique_number})"
-      @page_container.eval_in_spawned_process(object + ".click!")
-      highlight(:clear)
-    end
-    def click!
-      assert_enabled
-      highlight(:set)
-      ole_object.click
-      highlight(:clear)
-    end
-    # Flash the element the specified number of times.
-    # Defaults to 10 flashes.
-    def flash number=10
-      assert_exists
-      number.times do
-        highlight(:set)
-        sleep 0.05
-        highlight(:clear)
-        sleep 0.05
-      end
-      nil
-    end
-    # Executes a user defined "fireEvent" for objects with JavaScript events tied to them such as DHTML menus.
-    #   usage: allows a generic way to fire javascript events on page objects such as "onMouseOver", "onClick", etc.
-    #   raises: UnknownObjectException  if the object is not found
-    #           ObjectDisabledException if the object is currently disabled
-    def fire_event(event)
-      assert_enabled
-      highlight(:set)
-      ole_object.fireEvent(event)
-      @container.wait
-      highlight(:clear)
-    end
-    # This method sets focus on the active element.
-    #   raises: UnknownObjectException  if the object is not found
-    #           ObjectDisabledException if the object is currently disabled
-    def focus
-      assert_enabled
-      ole_object.focus
-    end
-    # Returns whether this element actually exists.
-    def exists?
-      begin
-        locate if defined?(locate)
-      rescue WIN32OLERuntimeError
-        @o = nil
-      end
-      @o ? true: false
-    end
-    alias :exist? :exists?
-    # Returns true if the element is enabled, false if it isn't.
-    #   raises: UnknownObjectException  if the object is not found
-    def enabled?
-      assert_exists
-      return ! disabled
-    end
-    # Get attribute value for any attribute of the element.
-    # Returns null if attribute doesn't exist.
-    def attribute_value(attribute_name)
-      assert_exists
-      return ole_object.getAttribute(attribute_name)
-    end
-  end
-  class ElementMapper # Still to be used
-    include Container
-    def initialize wrapper_class, container, how, what
-      @wrapper_class = wrapper_class
-      set_container
-      @how = how
-      @what = what
-    end
-    def method_missing method, *args
-      locate
-      @wrapper_class.new(@o).send(method, *args)
-    end
-  end
-  class Frame
-    include Container
-    include PageContainer
-    # Find the frame denoted by how and what in the container and return its ole_object
-    def locate
-      how = @how
-      what = @what
-      frames = @container.document.frames
-      target = nil
-      for i in 0..(frames.length - 1)
-        this_frame = frames.item(i)
-        case how
-        when :index
-          index = i + 1
-          return this_frame if index == what
-        when :name
-          begin
-            return this_frame if what.matches(this_frame.name)
-          rescue # access denied?
-          end
-        when :id
-          # We assume that pages contain frames or iframes, but not both.
-          this_frame_tag = @container.document.getElementsByTagName("FRAME").item(i)
-          return this_frame if this_frame_tag and what.matches(this_frame_tag.invoke("id"))
-          this_iframe_tag = @container.document.getElementsByTagName("IFRAME").item(i)
-          return this_frame if this_iframe_tag and what.matches(this_iframe_tag.invoke("id"))
-        when :src
-          this_frame_tag = @container.document.getElementsByTagName("FRAME").item(i)
-          return this_frame if this_frame_tag and what.matches(this_frame_tag.src)
-          this_iframe_tag = @container.document.getElementsByTagName("IFRAME").item(i)
-          return this_frame if this_iframe_tag and what.matches(this_iframe_tag.src)
-        else
-          raise ArgumentError, "Argument #{how} not supported"
-        end
-      end
-      raise UnknownFrameException, "Unable to locate a frame with #{how.to_s} #{what}"
-    end
-    def initialize(container, how, what)
-      set_container container
-      @how = how
-      @what = what
-      @o = locate
-      copy_test_config container
-    end
-    def document
-      @o.document
-    end
-    def attach_command
-      @container.page_container.attach_command + ".frame(#{@how.inspect}, #{@what.inspect})"
-    end
-  end
-  class ModalDialog
-    include Container
-    include PageContainer
-    include Win32
-    # Return the current window handle
-    attr_reader :hwnd
-    def find_modal_from_window
-      # Use handle of our parent window to see if we have any currently
-      # enabled popup.
-      hwnd = @container.hwnd
-      hwnd_modal = 0
-      begin
-        Watir::until_with_timeout do
-          hwnd_modal, arr = GetWindow.call(hwnd, GW_ENABLEDPOPUP) # GW_ENABLEDPOPUP = 6
-          hwnd_modal > 0
-        end
-      rescue TimeOutException
-        return nil
-      end
-      if hwnd_modal == hwnd || hwnd_modal == 0
-        hwnd_modal = nil
-      end
-      @hwnd = hwnd_modal
-    end
-    private :find_modal_from_window
-    def locate
-      how = @how
-      what = @what
-      case how
-      when nil
-        unless find_modal_from_window
-          raise NoMatchingWindowFoundException,
-            "Modal Dialog not found. Timeout = #{Watir::IE.attach_timeout}"
-        end
-      when :title
-        case what.class.to_s
-        # TODO: re-write like WET's so we can select on regular expressions too.
-        when "String"
-          begin
-            Watir::until_with_timeout do
-              title = "#{what} -- Web Page Dialog"
-              @hwnd, arr = FindWindowEx.call(0, 0, nil, title)
-              @hwnd > 0
-            end
-          rescue TimeOutException
-            raise NoMatchingWindowFoundException,
-              "Modal Dialog with title #{what} not found. Timeout = #{Watir::IE.attach_timeout}"
-          end
-        else
-          raise ArgumentError, "Title value must be String"
-        end
-      else
-        raise ArgumentError, "Only null and :title methods are supported"
-      end
-      intUnknown = 0
-      begin
-        Watir::until_with_timeout do
-          intPointer = " " * 4 # will contain the int value of the IUnknown*
-          GetUnknown.call(@hwnd, intPointer)
-          intArray = intPointer.unpack('L')
-          intUnknown = intArray.first
-          intUnknown > 0
-        end
-      rescue TimeOutException => e
-        raise NoMatchingWindowFoundException,
-          "Unable to attach to Modal Window #{what.inspect} after #{e.duration} seconds."
-      end
-      copy_test_config @parent_container
-      @document = WIN32OLE.connect_unknown(intUnknown)
-    end
-    def initialize(container, how, what=nil)
-      set_container container
-      @how = how
-      @what = what
-      @parent_container = container
-      # locate our modal dialog's Document object and save it
-      begin
-        locate
-      rescue NoMethodError => e
-        message =
-          "IE#modal_dialog not supported with the current version of Ruby (#{RUBY_VERSION}).\n" +
-          "See http://jira.openqa.org/browse/WTR-2 for details.\n" +
-            e.message
-        raise NoMethodError.new(message)
-      end
-    end
-    def document
-      @document
-    end
-    # Return the title of the document
-    def title
-      document.title
-    end
-    def close
-      document.parentWindow.close
-    end
-    def attach_command
-      "Watir::IE.find(:hwnd, #{@container.hwnd}).modal_dialog"
-    end
-    def wait(no_sleep=false)
-    end
-    # Return true if the modal exists. Mostly this is useful for testing whether
-    # a modal has closed.
-    def exists?
-      Watir::Win32::window_exists? @hwnd
-    end
-    alias :exist? :exists?
-  end
-  # this class is the super class for the iterator classes (buttons, links, spans etc
-  # it would normally only be accessed by the iterator methods (spans, links etc) of IE
-  class ElementCollections
-    include Enumerable
-    # Super class for all the iteractor classes
-    #   * container - an instance of an IE object
-    def initialize(container)
-      @container = container
-      @page_container = container.page_container
-      @length = length # defined by subclasses
-      # set up the items we want to display when the show method is used
-      set_show_items
-    end
-    private
-    def set_show_items
-      @show_attributes = AttributeLengthPairs.new("id", 20)
-      @show_attributes.add("name", 20)
-    end
-    public
-    def get_length_of_input_objects(object_type)
-      object_types =
-      if object_type.kind_of? Array
-        object_type
-      else
-        [object_type]
-      end
-      length = 0
-      objects = @container.document.getElementsByTagName("INPUT")
-      if objects.length > 0
-        objects.each do |o|
-          length += 1 if object_types.include?(o.invoke("type").downcase)
-        end
-      end
-      return length
-    end
-    # iterate through each of the elements in the collection in turn
-    def each
-      0.upto(@length-1) { |i| yield iterator_object(i) }
-    end
-    # allows access to a specific item in the collection
-    def [](n)
-      return iterator_object(n-1)
-    end
-    # this method is the way to show the objects, normally used from irb
-    def show
-      s = "index".ljust(6)
-      @show_attributes.each do |attribute_length_pair|
-        s += attribute_length_pair.attribute.ljust(attribute_length_pair.length)
-      end
-      index = 1
-      self.each do |o|
-        s += "\n"
-        s += index.to_s.ljust(6)
-        @show_attributes.each do |attribute_length_pair|
-          begin
-            s += eval('o.ole_object.invoke("#{attribute_length_pair.attribute}")').to_s.ljust(attribute_length_pair.length)
-          rescue => e
-            s += " ".ljust(attribute_length_pair.length)
-          end
-        end
-        index += 1
-      end
-      puts s
-    end
-    # this method creates an object of the correct type that the iterators use
-    private
-    def iterator_object(i)
-      element_class.new(@container, :index, i + 1)
-    end
-  end
-  # Forms
-  module FormAccess
-    def name
-      @ole_object.getAttributeNode('name').value
-    end
-    def action
-      @ole_object.action
-    end
-    def method
-      @ole_object.invoke('method')
-    end
-    def id
-      @ole_object.invoke('id')
-    end
-  end
-  # wraps around a form OLE object
-  class FormWrapper
-    include FormAccess
-    def initialize(ole_object)
-      @ole_object = ole_object
-    end
-  end
-  #   Form Factory object
-  class Form < Element
-    include FormAccess
-    include Container
-    attr_accessor :form
-    #   * container   - the containing object, normally an instance of IE
-    #   * how         - symbol - how we access the form (:name, :id, :index, :action, :method)
-    #   * what        - what we use to access the form
-    def initialize(container, how, what)
-      set_container container
-      @how = how
-      @what = what
-      log "Get form how is #{@how}  what is #{@what} "
-      # Get form using xpath.
-      if @how == :xpath
-        @ole_object = @container.element_by_xpath(@what)
-      else
-        count = 1
-        doc = @container.document
-        doc.forms.each do |thisForm|
-          next unless @ole_object == nil
-          wrapped = FormWrapper.new(thisForm)
-          log "form on page, name is " + wrapped.name
-          @ole_object =
-          case @how
-          when :name, :id, :method, :action
-            @what.matches(wrapped.send(@how)) ? thisForm : nil
-          when :index
-            count == @what ? thisForm : nil
-          else
-            raise MissingWayOfFindingObjectException, "#{how} is an unknown way of finding a form (#{what})"
-          end
-          count = count +1
-        end
-      end
-      super(@ole_object)
-      copy_test_config container
-    end
-    def exists?
-      @ole_object ? true : false
-    end
-    alias :exist? :exists?
-    # Submit the data -- equivalent to pressing Enter or Return to submit a form.
-    def submit # XXX use assert_exists
-      raise UnknownFormException, "Unable to locate a form using #{@how} and #{@what} " if @ole_object == nil
-      @ole_object.submit
-      @container.wait
-    end
-    def ole_inner_elements # XXX use assert_exists
-      raise UnknownFormException, "Unable to locate a form using #{@how} and #{@what} " if @ole_object == nil
-      @ole_object.elements
-    end
-    private :ole_inner_elements
-    def document
-      return @ole_object
-    end
-    def wait(no_sleep=false)
-      @container.wait(no_sleep)
-    end
-    # This method is responsible for setting and clearing the colored highlighting on the specified form.
-    # use :set  to set the highlight
-    #   :clear  to clear the highlight
-    def highlight(set_or_clear, element, count)
-      if set_or_clear == :set
-        begin
-          original_color = element.style.backgroundColor
-          original_color = "" if original_color==nil
-          element.style.backgroundColor = activeObjectHighLightColor
-        rescue => e
-          puts e
-          puts e.backtrace.join("\n")
-          original_color = ""
-        end
-        @original_styles[count] = original_color
-      else
-        begin
-          element.style.backgroundColor = @original_styles[ count]
-        rescue => e
-          puts e
-          # we could be here for a number of reasons...
-        ensure
-        end
-      end
-    end
-    private :highlight
-    # causes the object to flash. Normally used in IRB when creating scripts
-    # Default is 10
-    def flash number=10
-      @original_styles = {}
-      number.times do
-        count = 0
-        @ole_object.elements.each do |element|
-          highlight(:set, element, count)
-          count += 1
-        end
-        sleep 0.05
-        count = 0
-        @ole_object.elements.each do |element|
-          highlight(:clear, element, count)
-          count += 1
-        end
-        sleep 0.05
-      end
-    end
-  end # class Form
-  # this class contains items that are common between the span, div, and pre objects
-  # it would not normally be used directly
-  #
-  # many of the methods available to this object are inherited from the Element class
-  #
-  class NonControlElement < Element
-    include Watir::Exception
-    def locate
-      if @how == :xpath
-        @o = @container.element_by_xpath(@what)
-      else
-        @o = @container.locate_tagged_element(self.class::TAG, @how, @what)
-      end
-    end
-    def initialize(container, how, what)
-      set_container container
-      @how = how
-      @what = what
-      super nil
-    end
-    # this method is used to populate the properties in the to_s method
-    def span_div_string_creator
-      n = []
-      n <<   "class:".ljust(TO_S_SIZE) + self.class_name
-      n <<   "text:".ljust(TO_S_SIZE) + self.text
-      return n
-    end
-    private :span_div_string_creator
-    # returns the properties of the object in a string
-    # raises an ObjectNotFound exception if the object cannot be found
-    def to_s
-      assert_exists
-      r = string_creator
-      r += span_div_string_creator
-      return r.join("\n")
-    end
-  end
-  class Pre < NonControlElement
-    TAG = 'PRE'
-  end
-  class P < NonControlElement
-    TAG = 'P'
-  end
-  # this class is used to deal with Div tags in the html page. http://msdn.microsoft.com/workshop/author/dhtml/reference/objects/div.asp?frame=true
-  # It would not normally be created by users
-  class Div < NonControlElement
-    TAG = 'DIV'
-  end
-  # this class is used to deal with Span tags in the html page. It would not normally be created by users
-  class Span < NonControlElement
-    TAG = 'SPAN'
-  end
-  # Accesses Label element on the html page - http://msdn.microsoft.com/workshop/author/dhtml/reference/objects/label.asp?frame=true
-  class Label < NonControlElement
-    TAG = 'LABEL'
-    # this method is used to populate the properties in the to_s method
-    def label_string_creator
-      n = []
-      n <<   "for:".ljust(TO_S_SIZE) + self.for
-      n <<   "text:".ljust(TO_S_SIZE) + self.text
-      return n
-    end
-    private :label_string_creator
-    # returns the properties of the object in a string
-    # raises an ObjectNotFound exception if the object cannot be found
-    def to_s
-      assert_exists
-      r = string_creator
-      r += label_string_creator
-      return r.join("\n")
-    end
-  end
-  class Li < NonControlElement
-    TAG = 'LI'
-  end
-  # This class is used for dealing with tables.
-  # Normally a user would not need to create this object as it is returned by the Watir::Container#table method
-  #
-  # many of the methods available to this object are inherited from the Element class
-  #
-  class Table < Element
-    include Container
-    # Returns the table object containing anElement
-    #   * container  - an instance of an IE object
-    #   * anElement  - a Watir object (TextField, Button, etc.)
-    def Table.create_from_element(container, anElement)
-      anElement.locate if defined?(anElement.locate)
-      o = anElement.ole_object.parentElement
-      o = o.parentElement until o.tagName == 'TABLE'
-      new container, :ole_object, o
-    end
-    # Returns an initialized instance of a table object
-    #   * container      - the container
-    #   * how         - symbol - how we access the table
-    #   * what         - what we use to access the table - id, name index etc
-    def initialize(container, how, what)
-      set_container container
-      @how = how
-      @what = what
-      super nil
-    end
-    def locate
-      if @how == :xpath
-        @o = @container.element_by_xpath(@what)
-      elsif @how == :ole_object
-        @o = @what
-      else
-        @o = @container.locate_tagged_element('TABLE', @how, @what)
-      end
-    end
-    # override the highlight method, as if the tables rows are set to have a background color,
-    # this will override the table background color, and the normal flash method won't work
-    def highlight(set_or_clear)
-      if set_or_clear == :set
-        begin
-          @original_border = @o.border.to_i
-          if @o.border.to_i==1
-            @o.border = 2
-          else
-            @o.border = 1
-          end
-        rescue
-          @original_border = nil
-        end
-      else
-        begin
-          @o.border= @original_border unless @original_border == nil
-          @original_border = nil
-        rescue
-          # we could be here for a number of reasons...
-        ensure
-          @original_border = nil
-        end
-      end
-      super
-    end
-    # this method is used to populate the properties in the to_s method
-    def table_string_creator
-      n = []
-      n <<   "rows:".ljust(TO_S_SIZE) + self.row_count.to_s
-      n <<   "cols:".ljust(TO_S_SIZE) + self.column_count.to_s
-      return n
-    end
-    private :table_string_creator
-    # returns the properties of the object in a string
-    # raises an ObjectNotFound exception if the object cannot be found
-    def to_s
-      assert_exists
-      r = string_creator
-      r += table_string_creator
-      return r.join("\n")
-    end
-    # iterates through the rows in the table. Yields a TableRow object
-    def each
-      assert_exists
-      1.upto(@o.getElementsByTagName("TR").length) { |i| yield TableRow.new(@container, :ole_object, row(i))    }
-    end
-    # Returns a row in the table
-    #   * index         - the index of the row
-    def [](index)
-      assert_exists
-      return TableRow.new(@container, :ole_object, row(index))
-    end
-    # This method returns the number of rows in the table.
-    # Raises an UnknownObjectException if the table doesnt exist.
-    def row_count
-      assert_exists
-      #return table_body.children.length
-      return @o.getElementsByTagName("TR").length
-    end
-    # This method returns the number of columns in a row of the table.
-    # Raises an UnknownObjectException if the table doesn't exist.
-    #   * index         - the index of the row
-    def column_count(index=1)
-      assert_exists
-      row(index).cells.length
-    end
-    # This method returns the table as a 2 dimensional array. Dont expect too much if there are nested tables, colspan etc.
-    # Raises an UnknownObjectException if the table doesn't exist.
-    # http://www.w3.org/TR/html4/struct/tables.html
-    def to_a
-      assert_exists
-      y = []
-      table_rows = @o.getElementsByTagName("TR")
-      for row in table_rows
-        x = []
-        for td in row.getElementsbyTagName("TD")
-          x << td.innerText.strip
-        end
-        y << x
-      end
-      return y
-    end
-    def table_body(index=1)
-      return @o.getElementsByTagName('TBODY')[index]
-    end
-    private :table_body
-    # returns a watir object
-    def body(how, what)
-      return TableBody.new(@container, how, what, self)
-    end
-    # returns a watir object
-    def bodies
-      assert_exists
-      return TableBodies.new(@container, @o)
-    end
-    # returns an ole object
-    def row(index)
-      return @o.invoke("rows")[(index-1).to_s]
-    end
-    private :row
-    # Returns an array containing all the text values in the specified column
-    # Raises an UnknownCellException if the specified column does not exist in every
-    # Raises an UnknownObjectException if the table doesn't exist.
-    # row of the table
-    #   * columnnumber  - column index to extract values from
-    def column_values(columnnumber)
-      return(1..row_count).collect {|idx| self[idx][columnnumber].text}
-    end
-    # Returns an array containing all the text values in the specified row
-    # Raises an UnknownObjectException if the table doesn't exist.
-    #   * rownumber  - row index to extract values from
-    def row_values(rownumber)
-      return(1..column_count(rownumber)).collect {|idx| self[rownumber][idx].text}
-    end
-  end
-  # this class is a collection of the table body objects that exist in the table
-  # it wouldnt normally be created by a user, but gets returned by the bodies method of the Table object
-  # many of the methods available to this object are inherited from the Element class
-  #
-  class TableBodies < Element
-    def initialize(container, parent_table)
-      set_container container
-      @o = parent_table     # in this case, @o is the parent table
-    end
-    # returns the number of TableBodies that exist in the table
-    def length
-      assert_exists
-      return @o.tBodies.length
-    end
-    # returns the n'th Body as a Watir TableBody object
-    def []n
-      assert_exists
-      return TableBody.new(@container, :ole_object, ole_table_body_at_index(n))
-    end
-    # returns an ole table body
-    def ole_table_body_at_index(n)
-      return @o.tBodies[(n-1).to_s]
-    end
-    # iterates through each of the TableBodies in the Table. Yields a TableBody object
-    def each
-      1.upto(@o.tBodies.length) { |i| yield TableBody.new(@container, :ole_object, ole_table_body_at_index(i)) }
-    end
-  end
-  # this class is a table body
-  class TableBody < Element
-    def locate
-      @o = nil
-      if @how == :ole_object
-        @o = @what     # in this case, @o is the table body
-      elsif @how == :index
-        @o = @parent_table.bodies.ole_table_body_at_index(@what)
-      end
-      @rows = []
-      if @o
-        @o.rows.each do |oo|
-          @rows << TableRow.new(@container, :ole_object, oo)
-        end
-      end
-    end
-    def initialize(container, how, what, parent_table=nil)
-      set_container container
-      @how = how
-      @what = what
-      @parent_table = parent_table
-      super nil
-    end
-    # returns the specified row as a TableRow object
-    def [](n)
-      assert_exists
-      return @rows[n - 1]
-    end
-    # iterates through all the rows in the table body
-    def each
-      locate
-      0.upto(@rows.length - 1) { |i| yield @rows[i] }
-    end
-    # returns the number of rows in this table body.
-    def length
-      return @rows.length
-    end
-  end
-  # this class is a table row
-  class TableRow < Element
-    def locate
-      @o = nil
-      if @how == :ole_object
-        @o = @what
-      elsif @how == :xpath
-        @o = @container.element_by_xpath(@what)
-      else
-        @o = @container.locate_tagged_element("TR", @how, @what)
-      end
-      if @o # cant call the assert_exists here, as an exists? method call will fail
-        @cells = []
-        @o.cells.each do |oo|
-          @cells << TableCell.new(@container, :ole_object, oo)
-        end
-      end
-    end
-    # Returns an initialized instance of a table row
-    #   * o  - the object contained in the row
-    #   * container  - an instance of an IE object
-    #   * how          - symbol - how we access the row
-    #   * what         - what we use to access the row - id, index etc. If how is :ole_object then what is a Internet Explorer Raw Row
-    def initialize(container, how, what)
-      set_container container
-      @how = how
-      @what = what
-      super nil
-    end
-    # this method iterates through each of the cells in the row. Yields a TableCell object
-    def each
-      locate
-      0.upto(@cells.length-1) { |i| yield @cells[i] }
-    end
-    # Returns an element from the row as a TableCell object
-    def [](index)
-      assert_exists
-      raise UnknownCellException, "Unable to locate a cell at index #{index}" if @cells.length < index
-      return @cells[(index - 1)]
-    end
-    # defaults all missing methods to the array of elements, to be able to
-    # use the row as an array
-    #        def method_missing(aSymbol, *args)
-    #            return @o.send(aSymbol, *args)
-    #        end
-    def column_count
-      locate
-      @cells.length
-    end
-  end
-  # this class is a table cell - when called via the Table object
-  class TableCell < Element
-    include Watir::Exception
-    include Container
-    def locate
-      if @how == :xpath
-        @o = @container.element_by_xpath(@what)
-      elsif @how == :ole_object
-        @o = @what
-      else
-        @o = @container.locate_tagged_element("TD", @how, @what)
-      end
-    end
-    # Returns an initialized instance of a table cell
-    #   * container  - an  IE object
-    #   * how        - symbol - how we access the cell
-    #   * what       - what we use to access the cell - id, name index etc
-    def initialize(container, how, what)
-      set_container container
-      @how = how
-      @what = what
-      super nil
-    end
-    def ole_inner_elements
-      locate
-      return @o.all
-    end
-    private :ole_inner_elements
-    def document
-      locate
-      return @o
-    end
-    alias to_s text
-    def colspan
-      locate
-      @o.colSpan
-    end
-  end
-  # This class is the means of accessing an image on a page.
-  # Normally a user would not need to create this object as it is returned by the Watir::Container#image method
-  #
-  # many of the methods available to this object are inherited from the Element class
-  #
-  class Image < Element
-    def initialize(container, how, what)
-      set_container container
-      @how = how
-      @what = what
-      super nil
-    end
-    def locate
-      if @how == :xpath
-        @o = @container.element_by_xpath(@what)
-      else
-        @o = @container.locate_tagged_element('IMG', @how, @what)
-      end
-    end
-    # this method produces the properties for an image as an array
-    def image_string_creator
-      n = []
-      n <<   "src:".ljust(TO_S_SIZE) + self.src.to_s
-      n <<   "file date:".ljust(TO_S_SIZE) + self.fileCreatedDate.to_s
-      n <<   "file size:".ljust(TO_S_SIZE) + self.fileSize.to_s
-      n <<   "width:".ljust(TO_S_SIZE) + self.width.to_s
-      n <<   "height:".ljust(TO_S_SIZE) + self.height.to_s
-      n <<   "alt:".ljust(TO_S_SIZE) + self.alt.to_s
-      return n
-    end
-    private :image_string_creator
-    # returns a string representation of the object
-    def to_s
-      assert_exists
-      r = string_creator
-      r += image_string_creator
-      return r.join("\n")
-    end
-    # this method returns the file created date of the image
-    def fileCreatedDate
-      assert_exists
-      return @o.invoke("fileCreatedDate")
-    end
-    # this method returns the filesize of the image
-    def fileSize
-      assert_exists
-      return @o.invoke("fileSize").to_s
-    end
-    # returns the width in pixels of the image, as a string
-    def width
-      assert_exists
-      return @o.invoke("width").to_s
-    end
-    # returns the height in pixels of the image, as a string
-    def height
-      assert_exists
-      return @o.invoke("height").to_s
-    end
-    # This method attempts to find out if the image was actually loaded by the web browser.
-    # If the image was not loaded, the browser is unable to determine some of the properties.
-    # We look for these missing properties to see if the image is really there or not.
-    # If the Disk cache is full (tools menu -> Internet options -> Temporary Internet Files), it may produce incorrect responses.
-    def hasLoaded?
-      locate
-      raise UnknownObjectException, "Unable to locate image using #{@how} and #{@what}" if @o == nil
-      return false if @o.fileCreatedDate == "" and @o.fileSize.to_i == -1
-      return true
-    end
-    # this method highlights the image (in fact it adds or removes a border around the image)
-    #  * set_or_clear   - symbol - :set to set the border, :clear to remove it
-    def highlight(set_or_clear)
-      if set_or_clear == :set
-        begin
-          @original_border = @o.border
-          @o.border = 1
-        rescue
-          @original_border = nil
-        end
-      else
-        begin
-          @o.border = @original_border
-          @original_border = nil
-        rescue
-          # we could be here for a number of reasons...
-        ensure
-          @original_border = nil
-        end
-      end
-    end
-    private :highlight
-    # This method saves the image to the file path that is given.  The
-    # path must be in windows format (c:\\dirname\\somename.gif).  This method
-    # will not overwrite a previously existing image.  If an image already
-    # exists at the given path then a dialog will be displayed prompting
-    # for overwrite.
-    # Raises a WatirException if AutoIt is not correctly installed
-    # path - directory path and file name of where image should be saved
-    def save(path)
-      require 'watir/windowhelper'
-      WindowHelper.check_autoit_installed
-      @container.goto(src)
-      begin
-        thrd = fill_save_image_dialog(path)
-        @container.document.execCommand("SaveAs")
-        thrd.join(5)
-      ensure
-        @container.back
-      end
-    end
-    def fill_save_image_dialog(path)
-      Thread.new do
-        system("ruby -e \"require 'win32ole'; @autoit=WIN32OLE.new('AutoItX3.Control'); waitresult=@autoit.WinWait 'Save Picture', '', 15; if waitresult == 1\" -e \"@autoit.ControlSetText 'Save Picture', '', '1148', '#{path}'; @autoit.ControlSend 'Save Picture', '', '1', '{ENTER}';\" -e \"end\"")
-      end
-    end
-    private :fill_save_image_dialog
-  end
-  # This class is the means of accessing a link on a page
-  # Normally a user would not need to create this object as it is returned by the Watir::Container#link method
-  # many of the methods available to this object are inherited from the Element class
-  #
-  class Link < Element
-    # Returns an initialized instance of a link object
-    #   * container  - an instance of a container
-    #   * how         - symbol - how we access the link
-    #   * what         - what we use to access the link, text, url, index etc
-    def initialize(container, how, what)
-      set_container container
-      @how = how
-      @what = what
-      super(nil)
-    end
-    def locate
-      if @how == :xpath
-        @o = @container.element_by_xpath(@what)
-      else
-        begin
-          @o = @container.locate_tagged_element('A', @how, @what)
-        rescue UnknownObjectException
-          @o = nil
-        end
-      end
-    end
-    # if an image is used as part of the link, this will return true
-    def link_has_image
-      assert_exists
-      return true if @o.getElementsByTagName("IMG").length > 0
-      return false
-    end
-    # this method returns the src of an image, if an image is used as part of the link
-    def src # BUG?
-      assert_exists
-      if @o.getElementsByTagName("IMG").length > 0
-        return @o.getElementsByTagName("IMG")[0.to_s].src
-      else
-        return ""
-      end
-    end
-    def link_string_creator
-      n = []
-      n <<   "href:".ljust(TO_S_SIZE) + self.href
-      n <<   "inner text:".ljust(TO_S_SIZE) + self.text
-      n <<   "img src:".ljust(TO_S_SIZE) + self.src if self.link_has_image
-      return n
-    end
-    # returns a textual description of the link
-    def to_s
-      assert_exists
-      r = string_creator
-      r = r + link_string_creator
-      return r.join("\n")
-    end
-  end
-  class InputElement < Element
-    def locate
-      if @how == :xpath
-        @o = @container.element_by_xpath(@what)
-      elsif @how == :ole_object
-        @o = @what
-      else
-        @o = @container.locate_input_element(@how, @what, self.class::INPUT_TYPES)
-      end
-    end
-    def initialize(container, how, what)
-      set_container container
-      @how = how
-      @what = what
-      super(nil)
-    end
-  end
-  # This class is the way in which select boxes are manipulated.
-  # Normally a user would not need to create this object as it is returned by the Watir::Container#select_list method
-  class SelectList < InputElement
-    INPUT_TYPES = ["select-one", "select-multiple"]
-    attr_accessor :o
-    # This method clears the selected items in the select box
-    def clearSelection
-      assert_exists
-      highlight(:set)
-      wait = false
-      @o.each do |selectBoxItem|
-        if selectBoxItem.selected
-          selectBoxItem.selected = false
-          wait = true
-        end
-      end
-      @container.wait if wait
-      highlight(:clear)
-    end
-    #        private :clearSelection
-    # This method selects an item, or items in a select box, by text.
-    # Raises NoValueFoundException   if the specified value is not found.
-    #  * item   - the thing to select, string or reg exp
-    def select(item)
-      select_item_in_select_list(:text, item)
-    end
-    alias :set :select
-    # Selects an item, or items in a select box, by value.
-    # Raises NoValueFoundException   if the specified value is not found.
-    #  * item   - the value of the thing to select, string, reg exp or an array of string and reg exps
-    def select_value(item)
-      select_item_in_select_list(:value, item)
-    end
-    # BUG: Should be private
-    # Selects something from the select box
-    #  * name  - symbol  :value or :text - how we find an item in the select box
-    #  * item  - string or reg exp - what we are looking for
-    def select_item_in_select_list(attribute, value)
-      assert_exists
-      highlight(:set)
-      doBreak = false
-      @container.log "Setting box #{@o.name} to #{attribute} #{value} "
-      @o.each do |option| # items in the list
-        if value.matches(option.invoke(attribute.to_s))
-          if option.selected
-            doBreak = true
-            break
-          else
-            option.selected = true
-            @o.fireEvent("onChange")
-            @container.wait
-            doBreak = true
-            break
-          end
-        end
-      end
-      unless doBreak
-        raise NoValueFoundException,
-                        "No option with #{attribute.to_s} of #{value} in this select element"
-      end
-      highlight(:clear)
-    end
-    # Returns all the items in the select list as an array.
-    # An empty array is returned if the select box has no contents.
-    # Raises UnknownObjectException if the select box is not found
-    def getAllContents # BUG: camel_case.rb
-      assert_exists
-      @container.log "There are #{@o.length} items"
-      returnArray = []
-      @o.each { |thisItem| returnArray << thisItem.text }
-      return returnArray
-    end
-    # Returns the selected items as an array.
-    # Raises UnknownObjectException if the select box is not found.
-    def getSelectedItems
-      assert_exists
-      returnArray = []
-      @container.log "There are #{@o.length} items"
-      @o.each do |thisItem|
-        if thisItem.selected
-          @container.log "Item (#{thisItem.text}) is selected"
-          returnArray << thisItem.text
-        end
-      end
-      return returnArray
-    end
-    # Does the SelectList include the specified option (text)?
-    def includes? text
-      getAllContents.include? text
-    end
-    # Is the specified option (text) selected? Raises exception of option does not exist.
-    def selected? text
-      unless includes? text
-        raise UnknownObjectException, "Option #{text} not found."
-      end
-      getSelectedItems.include? text
-    end
-    def option(attribute, value)
-      assert_exists
-      Option.new(self, attribute, value)
-    end
-  end
-  module OptionAccess
-    def text
-      @option.text
-    end
-    def value
-      @option.value
-    end
-    def selected
-      @option.selected
-    end
-  end
-  class OptionWrapper
-    include OptionAccess
-    def initialize(option)
-      @option = option
-    end
-  end
-  # An item in a select list
-  class Option
-    include OptionAccess
-    include Watir::Exception
-    def initialize(select_list, attribute, value)
-      @select_list = select_list
-      @how = attribute
-      @what = value
-      @option = nil
-      unless [:text, :value].include? attribute
-        raise MissingWayOfFindingObjectException,
-                    "Option does not support attribute #{@how}"
-      end
-      @select_list.o.each do |option| # items in the list
-        if value.matches(option.invoke(attribute.to_s))
-          @option = option
-          break
-        end
-      end
-    end
-    def assert_exists
-      unless @option
-        raise UnknownObjectException,
-                    "Unable to locate an option using #{@how} and #{@what}"
-      end
-    end
-    private :assert_exists
-    def select
-      assert_exists
-      @select_list.select_item_in_select_list(@how, @what)
-    end
-  end
-  # This is the main class for accessing buttons.
-  # Normally a user would not need to create this object as it is
-  # returned by the Watir::Container#button method
-  class Button < InputElement
-    INPUT_TYPES = ["button", "submit", "image", "reset"]
-  end
-  # This class is the main class for Text Fields
-  # Normally a user would not need to create this object as it is returned by the Watir::Container#text_field method
-  class TextField < InputElement
-    INPUT_TYPES = ["text", "password", "textarea"]
-    def_wrap_guard :size
-    def_wrap_guard :maxlength
-    # Returns true or false if the text field is read only.
-    #   Raises UnknownObjectException if the object can't be found.
-    def_wrap :readonly?, :readOnly
-    def text_string_creator
-      n = []
-      n <<   "length:".ljust(TO_S_SIZE) + self.size.to_s
-      n <<   "max length:".ljust(TO_S_SIZE) + self.maxlength.to_s
-      n <<   "read only:".ljust(TO_S_SIZE) + self.readonly?.to_s
-      return n
-    end
-    private :text_string_creator
-    def to_s
-      assert_exists
-      r = string_creator
-      r += text_string_creator
-      return r.join("\n")
-    end
-    def assert_not_readonly
-      raise ObjectReadOnlyException, "Textfield #{@how} and #{@what} is read only." if self.readonly?
-    end
-    # This method returns true or false if the text field contents is either a string match
-    # or a regular expression match to the supplied value.
-    #   Raises UnknownObjectException if the object can't be found
-    #   * containsThis - string or reg exp - the text to verify
-    def verify_contains(containsThis) # FIXME: verify_contains should have same name and semantics as IE#contains_text (prolly make this work for all elements)
-      assert_exists
-      if containsThis.kind_of? String
-        return true if self.value == containsThis
-      elsif containsThis.kind_of? Regexp
-        return true if self.value.match(containsThis) != nil
-      end
-      return false
-    end
-    # this method is used to drag the entire contents of the text field to another text field
-    #  19 Jan 2005 - It is added as prototype functionality, and may change
-    #   * destination_how   - symbol, :id, :name how we identify the drop target
-    #   * destination_what  - string or regular expression, the name, id, etc of the text field that will be the drop target
-    def dragContentsTo(destination_how, destination_what)
-      assert_exists
-      destination = @container.text_field(destination_how, destination_what)
-      raise UnknownObjectException, "Unable to locate destination using #{destination_how } and #{destination_what } "   if destination.exists? == false
-      @o.focus
-      @o.select
-      value = self.value
-      @o.fireEvent("onSelect")
-      @o.fireEvent("ondragstart")
-      @o.fireEvent("ondrag")
-      destination.fireEvent("onDragEnter")
-      destination.fireEvent("onDragOver")
-      destination.fireEvent("ondrop")
-      @o.fireEvent("ondragend")
-      destination.value = destination.value + value.to_s
-      self.value = ""
-    end
-    # This method clears the contents of the text box.
-    #   Raises UnknownObjectException if the object can't be found
-    #   Raises ObjectDisabledException if the object is disabled
-    #   Raises ObjectReadOnlyException if the object is read only
-    def clear
-      assert_enabled
-      assert_not_readonly
-      highlight(:set)
-      @o.scrollIntoView
-      @o.focus
-      @o.select
-      @o.fireEvent("onSelect")
-      @o.value = ""
-      @o.fireEvent("onKeyPress")
-      @o.fireEvent("onChange")
-      @container.wait
-      highlight(:clear)
-    end
-    # This method appens the supplied text to the contents of the text box.
-    #   Raises UnknownObjectException if the object cant be found
-    #   Raises ObjectDisabledException if the object is disabled
-    #   Raises ObjectReadOnlyException if the object is read only
-    #   * setThis  - string - the text to append
-    def append(setThis)
-      assert_enabled
-      assert_not_readonly
-      highlight(:set)
-      @o.scrollIntoView
-      @o.focus
-      doKeyPress(setThis)
-      highlight(:clear)
-    end
-    # This method sets the contents of the text box to the supplied text
-    #   Raises UnknownObjectException if the object cant be found
-    #   Raises ObjectDisabledException if the object is disabled
-    #   Raises ObjectReadOnlyException if the object is read only
-    #   * setThis - string - the text to set
-    def set(setThis)
-      assert_enabled
-      assert_not_readonly
-      highlight(:set)
-      @o.scrollIntoView
-      @o.focus
-      @o.select
-      @o.fireEvent("onSelect")
-      @o.value = ""
-      @o.fireEvent("onKeyPress")
-      doKeyPress(setThis)
-      highlight(:clear)
-      @o.fireEvent("onChange")
-      @o.fireEvent("onBlur")
-    end
-    # this method sets the value of the text field directly. It causes no events to be fired or exceptions to be raised, so generally shouldnt be used
-    # it is preffered to use the set method.
-    def value=(v)
-      assert_exists
-      @o.value = v.to_s
-    end
-    # This method is used internally by setText and appendText
-    # It should not be used externally.
-    #   * value - string - The string to enter into the text field
-    def doKeyPress(value)
-      begin
-        maxLength = @o.maxLength
-        if value.length > maxLength
-          original_value = value
-          value = original_value[0 .. maxLength-1 ]
-          @container.log " Supplied string is #{original_value.length} chars, which exceeds the max length (#{maxLength}) of the field. Using value: #{value}"
-        end
-      rescue WIN32OLERuntimeError => e
-        # probably a text area - so it doesnt have a max Length
-        raise e unless /unknown property or method .*?maxLength/.match( e.message )
-        maxLength = -1
-      end
-      for i in 0 .. value.length-1
-        sleep @container.typingspeed
-        c = value[i,1]
-        #@container.log " adding c.chr " + c
-        @o.value = @o.value.to_s + c
-        @o.fireEvent("onKeyDown")
-        @o.fireEvent("onKeyPress")
-        @o.fireEvent("onKeyUp")
-      end
-    end
-    private :doKeyPress
-  end
-  # this class can be used to access hidden field objects
-  # Normally a user would not need to create this object as it is returned by the Watir::Container#hidden method
-  class Hidden < TextField
-    INPUT_TYPES = ["hidden"]
-    # set is overriden in this class, as there is no way to set focus to a hidden field
-    def set(n)
-      self.value = n
-    end
-    # override the append method, so that focus isnt set to the hidden object
-    def append(n)
-      self.value = self.value.to_s + n.to_s
-    end
-    # override the clear method, so that focus isnt set to the hidden object
-    def clear
-      self.value = ""
-    end
-    # this method will do nothing, as you cant set focus to a hidden field
-    def focus
-    end
-  end
-  # This class is the class for fields that accept file uploads
-  # Windows dialog is opened and handled in this case by autoit
-  # launching into a new process.
-  class FileField < InputElement
-    INPUT_TYPES = ["file"]
-    # set the file location in the Choose file dialog in a new process
-    # will raise a Watir Exception if AutoIt is not correctly installed
-    def set(setPath)
-      assert_exists
-      require 'watir/windowhelper'
-      WindowHelper.check_autoit_installed
-      begin
-        thrd = Thread.new do
-          system("rubyw -e \"require 'win32ole'; @autoit=WIN32OLE.new('AutoItX3.Control'); waitresult=@autoit.WinWait 'Choose file', '', 15; if waitresult == 1\" -e \"@autoit.ControlSetText 'Choose file', '', 'Edit1', '#{setPath}'; @autoit.ControlSend 'Choose file', '', 'Button2', '{ENTER}';\" -e \"end\"")
-        end
-      thrd.join(1)
-      rescue
-        raise Watir::Exception::WatirException, "Problem accessing Choose file dialog"
-      end
-      click
-    end
-  end
-  # This class is the class for radio buttons and check boxes.
-  # It contains methods common to both.
-  # Normally a user would not need to create this object as it is returned by the Watir::Container#checkbox or Watir::Container#radio methods
-  #
-  # most of the methods available to this element are inherited from the Element class
-  #
-  class RadioCheckCommon < Element
-    def locate
-      if @how == :xpath
-        @o = @container.element_by_xpath(@what)
-      else
-        @o = @container.locate_input_element(@how, @what, @type, @value)
-      end
-    end
-    def initialize(container, how, what, type, value=nil)
-      set_container container
-      @how = how
-      @what = what
-      @type = type
-      @value = value
-      super(nil)
-    end
-    # BUG: rename me
-    # This method determines if a radio button or check box is set.
-    # Returns true is set/checked or false if not set/checked.
-    # Raises UnknownObjectException if its unable to locate an object.
-    def isSet?
-      assert_exists
-      return @o.checked
-    end
-    alias getState isSet?
-    alias checked? isSet?
-    # This method clears a radio button or check box. Note, with radio buttons one of them will almost always be set.
-    # Returns true if set or false if not set.
-    #   Raises UnknownObjectException if its unable to locate an object
-    #         ObjectDisabledException IF THE OBJECT IS DISABLED
-    def clear
-      assert_enabled
-      highlight(:set)
-      set_clear_item(false)
-      highlight(:clear)
-    end
-    # This method sets the radio list item or check box.
-    #   Raises UnknownObjectException  if it's unable to locate an object
-    #         ObjectDisabledException  if the object is disabled
-    def set
-      assert_enabled
-      highlight(:set)
-      set_clear_item(true)
-      highlight(:clear)
-    end
-    # This method is the common code for setting or clearing checkboxes and radio.
-    def set_clear_item(set)
-      @o.checked = set
-      @o.fireEvent("onClick")
-      @container.wait
-    end
-    private :set_clear_item
-  end
-  #--
-  #  this class makes the docs better
-  #++
-  # This class is the watir representation of a radio button.
-  class Radio < RadioCheckCommon
-  end
-  # This class is the watir representation of a check box.
-  class CheckBox < RadioCheckCommon
-    # With no arguments supplied, sets the check box.
-    # If the optional value is supplied, the checkbox is set, when its true and
-    # cleared when its false
-    #   Raises UnknownObjectException if it's unable to locate an object
-    #         ObjectDisabledException if the object is disabled
-    def set(value=true)
-      assert_enabled
-      highlight :set
-      unless @o.checked == value
-        set_clear_item value
-      end
-      highlight :clear
-    end
-    # Clears a check box.
-    #   Raises UnknownObjectException if its unable to locate an object
-    #         ObjectDisabledException if the object is disabled
-    def clear
-      set false
-    end
-  end
-  #--
-  #   These classes are not for public consumption, so we switch off rdoc
-  # presumes element_class or element_tag is defined
-  # for subclasses of ElementCollections
-  module CommonCollection
-    def element_tag
-      element_class::TAG
-    end
-    def length
-      @container.document.getElementsByTagName(element_tag).length
-    end
-  end
-  # This class is used as part of the .show method of the iterators class
-  # it would not normally be used by a user
-  class AttributeLengthPairs
-    # This class is used as part of the .show method of the iterators class
-    # it would not normally be used by a user
-    class AttributeLengthHolder
-      attr_accessor :attribute
-      attr_accessor :length
-      def initialize(attrib, length)
-        @attribute = attrib
-        @length = length
-      end
-    end
-    def initialize(attrib=nil, length=nil)
-      @attr=[]
-      add(attrib, length) if attrib
-      @index_counter = 0
-    end
-    # BUG: Untested. (Null implementation passes all tests.)
-    def add(attrib, length)
-      @attr << AttributeLengthHolder.new(attrib, length)
-    end
-    def delete(attrib)
-      item_to_delete = nil
-      @attr.each_with_index do |e,i|
-        item_to_delete = i if e.attribute == attrib
-      end
-      @attr.delete_at(item_to_delete) unless item_to_delete == nil
-    end
-    def next
-      temp = @attr[@index_counter]
-      @index_counter += 1
-      return temp
-    end
-    def each
-      0.upto(@attr.length-1) { |i | yield @attr[i]   }
-    end
-  end
-  #    resume rdoc
-  #++
-  # this class accesses the buttons in the document as a collection
-  # it would normally only be accessed by the Watir::Container#buttons method
-  class Buttons < ElementCollections
-    def element_class; Button; end
-    def length
-      get_length_of_input_objects(["button", "submit", "image"])
-    end
-    private
-    def set_show_items
-      super
-      @show_attributes.add("disabled", 9)
-      @show_attributes.add("value", 20)
-    end
-  end
-  # this class accesses the file fields in the document as a collection
-  # normal access is via the Container#file_fields method
-  class FileFields < ElementCollections
-    def element_class; FileField; end
-    def length
-      get_length_of_input_objects(["file"])
-    end
-    private
-    def set_show_items
-      super
-      @show_attributes.add("disabled", 9)
-      @show_attributes.add("value", 20)
-    end
-  end
-  # this class accesses the check boxes in the document as a collection
-  # Normally a user would not need to create this object as it is returned by the Watir::Container#checkboxes method
-  class CheckBoxes < ElementCollections
-    def element_class; CheckBox; end
-    def length
-      get_length_of_input_objects("checkbox")
-    end
-    private
-    def iterator_object(i)
-      @container.checkbox(:index, i + 1)
-    end
-  end
-  # this class accesses the radio buttons in the document as a collection
-  # Normally a user would not need to create this object as it is returned by the Watir::Container#radios method
-  class Radios < ElementCollections
-    def element_class; Radio; end
-    def length
-      get_length_of_input_objects("radio")
-    end
-    private
-    def iterator_object(i)
-      @container.radio(:index, i + 1)
-    end
-  end
-  # this class accesses the select boxes in the document as a collection
-  # Normally a user would not need to create this object as it is returned by the Watir::Container#select_lists method
-  class SelectLists < ElementCollections
-    include CommonCollection
-    def element_class; SelectList; end
-    def element_tag; 'SELECT'; end
-  end
-  # this class accesses the links in the document as a collection
-  # Normally a user would not need to create this object as it is returned by the Watir::Container#links method
-  class Links < ElementCollections
-    include CommonCollection
-    def element_class; Link; end
-    def element_tag; 'A'; end
-    private
-    def set_show_items
-      super
-      @show_attributes.add("href", 60)
-      @show_attributes.add("innerText", 60)
-    end
-  end
-  class Lis  < ElementCollections
-    include Watir::CommonCollection
-    def element_class; Li; end
-    def set_show_items
-      super
-      @show_attributes.delete( "name")
-      @show_attributes.add( "className" , 20)
-    end
-  end
-  class Map < NonControlElement
-    TAG = 'MAP'
-  end
-  class Area < NonControlElement
-    TAG = 'AREA'
-  end
-  # this class accesses the maps in the document as a collection
-  # Normally a user would not need to create this object as it is returned by the Watir::Container#maps method
-  class Maps < ElementCollections
-    include CommonCollection
-    def element_class; Map; end
-    def element_tag; 'MAP'; end
-  end
-  # this class accesses the areas in the document as a collection
-  # Normally a user would not need to create this object as it is returned by the Watir::Container#areas method
-  class Areas < ElementCollections
-    include CommonCollection
-    def element_class; Area; end
-    def element_tag; 'AREA'; end
-  end
-  # this class accesses the imnages in the document as a collection
-  # Normally a user would not need to create this object as it is returned by the Watir::Container#images method
-  class Images < ElementCollections
-    def element_class; Image; end
-    def length
-      @container.document.images.length
-    end
-    private
-    def set_show_items
-      super
-      @show_attributes.add("src", 60)
-      @show_attributes.add("alt", 30)
-    end
-  end
-  # this class accesses the text fields in the document as a collection
-  # Normally a user would not need to create this object as it is returned by the Watir::Container#text_fields method
-  class TextFields < ElementCollections
-    def element_class; TextField; end
-    def length
-      # text areas are also included in the TextFields, but we need to get them seperately
-      get_length_of_input_objects(["text", "password"]) +
-      @container.document.getElementsByTagName("textarea").length
-    end
-  end
-  # this class accesses the hidden fields in the document as a collection
-  # Normally a user would not need to create this object as it is returned by the Watir::Container#hiddens method
-  class Hiddens < ElementCollections
-    def element_class; Hidden; end
-    def length
-      get_length_of_input_objects("hidden")
-    end
-  end
-  # this class accesses the text fields in the document as a collection
-  # Normally a user would not need to create this object as it is returned by the Watir::Container#tables method
-  class Tables < ElementCollections
-    include CommonCollection
-    def element_class; Table; end
-    def element_tag; 'TABLE'; end
-    private
-    def set_show_items
-      super
-      @show_attributes.delete("name")
-    end
-  end
-  # this class accesses the table rows in the document as a collection
-  # Normally a user would not need to create this object as it is returned by the Watir::Container#rows method
-  class TableRows < ElementCollections
-    include CommonCollection
-    def element_class; TableRow; end
-    def element_tag; 'TR'; end
-  end
-  # this class accesses the table cells in the document as a collection
-  # Normally a user would not need to create this object as it is returned by the Watir::Container#cells method
-  class TableCells < ElementCollections
-    include CommonCollection
-    def element_class; TableCell; end
-    def element_tag; 'TD'; end
-  end
-  # this class accesses the labels in the document as a collection
-  # Normally a user would not need to create this object as it is returned by the Watir::Container#labels method
-  class Labels < ElementCollections
-    include CommonCollection
-    def element_class; Label; end
-    def element_tag; 'LABEL'; end
-    private
-    def set_show_items
-      super
-      @show_attributes.add("htmlFor", 20)
-    end
-  end
-  # this class accesses the pre tags in the document as a collection
-  # Normally a user would not need to create this object as it is returned by the Watir::Container#pres method
-  class Pres < ElementCollections
-    include CommonCollection
-    def element_class; Pre; end
-    private
-    def set_show_items
-      super
-      @show_attributes.delete("name")
-      @show_attributes.add("className", 20)
-    end
-  end
-  # this class accesses the p tags in the document as a collection
-  # Normally a user would not need to create this object as it is returned by the Watir::Container#ps method
-  class Ps < ElementCollections
-    include CommonCollection
-    def element_class; P; end
-    private
-    def set_show_items
-      super
-      @show_attributes.delete("name")
-      @show_attributes.add("className", 20)
-    end
-  end
-  # this class accesses the spans in the document as a collection
-  # Normally a user would not need to create this object as it is returned by the Watir::Container#spans method
-  class Spans < ElementCollections
-    include CommonCollection
-    def element_class; Span; end
-    private
-    def set_show_items
-      super
-      @show_attributes.delete("name")
-      @show_attributes.add("className", 20)
-    end
-  end
-  # this class accesses the divs in the document as a collection
-  # Normally a user would not need to create this object as it is returned by the Watir::Container#divs method
-  class Divs < ElementCollections
-    include CommonCollection
-    def element_class; Div; end
-    private
-    def set_show_items
-      super
-      @show_attributes.delete("name")
-      @show_attributes.add("className", 20)
-    end
-  end
   # Move to Watir::Utils
   @@autoit = nil
@@ -4520,4 +154,4 @@ def _code_that_copies_readonly_array(array, name)
 end
 require 'watir/camel_case'
-require 'watir/elements'
+require 'watir/bonus-elements'