watir 1.4.1

data/unittests/textfields_test.rb

@@ -0,0 +1,239 @@
+# feature tests for Text Fields
+# revision: $Revision: 1.31 $
+
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..') if $0 == __FILE__
+require 'unittests/setup'
+
+class TC_Fields < Test::Unit::TestCase
+    include Watir
+
+    def setup()
+        $ie.goto($htmlRoot + "textfields1.html")
+    end
+
+    def test_text_field_exists
+       assert($ie.text_field(:name, "text1").exists?)   
+       assert_false($ie.text_field(:name, "missing").exists?)   
+
+       assert($ie.text_field(:id, "text2").exists?)   
+       assert_false($ie.text_field(:id, "alsomissing").exists?)   
+
+        assert($ie.text_field(:beforeText , "This Text After").exists? )
+        assert($ie.text_field(:afterText , "This Text Before").exists? )
+
+        assert($ie.text_field(:beforeText , /after/i).exists? )
+        assert($ie.text_field(:afterText , /before/i).exists? )
+    end
+
+    def test_text_field_dragContentsTo
+        $ie.text_field(:name, "text1").dragContentsTo(:id, "text2")
+        assert_equal($ie.text_field(:name, "text1").getContents, "" ) 
+        assert_equal($ie.text_field(:id, "text2").getContents, "goodbye allHello World" ) 
+    end
+
+    def test_text_field_VerifyContents
+       assert($ie.text_field(:name, "text1").verify_contains("Hello World") )  
+       assert($ie.text_field(:name, "text1").verify_contains(/Hello\sW/ ) )  
+       assert_false($ie.text_field(:name, "text1").verify_contains("Ruby") )  
+       assert_false($ie.text_field(:name, "text1").verify_contains(/R/) )  
+       assert_raises(UnknownObjectException , "UnknownObjectException was supposed to be thrown" ) {   $ie.text_field(:name, "NoName").verify_contains("No field to get a value of") }  
+
+       assert($ie.text_field(:id, "text2").verify_contains("goodbye all") )  
+       assert_raises(UnknownObjectException , "UnknownObjectException was supposed to be thrown" ) {   $ie.text_field(:id, "noID").verify_contains("No field to get a value of") }  
+
+    end
+
+    def test_text_field_enabled
+       assert_false($ie.text_field(:name, "disabled").enabled? )  
+       assert($ie.text_field(:name, "text1").enabled? )  
+       assert($ie.text_field(:id, "text2").enabled? )  
+    end
+
+    def test_text_field_readOnly
+       assert_false($ie.text_field(:name, "disabled").readonly? )  
+       assert($ie.text_field(:name, "readOnly").readonly? )  
+       assert($ie.text_field(:id, "readOnly2").readonly? )  
+    end
+
+    def test_text_field_getContents()
+         assert_raises(UnknownObjectException  , "ObjectReadOnlyException   was supposed to be thrown" ) {   $ie.text_field(:name, "missing_field").append("Some Text") }  
+         assert_equal(  "Hello World" , $ie.text_field(:name, "text1").getContents )  
+    end
+
+    def test_TextField_to_s
+        expected = [build_to_s_regex("type", "text"),
+                    build_to_s_regex("id", ""),
+                    build_to_s_regex("name", "text1"),
+                    build_to_s_regex("value", "Hello World"),
+                    build_to_s_regex("disabled", "false"),
+                    build_to_s_regex("length", "20"),
+                    build_to_s_regex("max length", "2147483647"),
+                    build_to_s_regex("read only", "false")]
+        items = $ie.text_field(:index, 1).to_s.split(/\n/)
+        expected.each_with_index{|regex, x| assert(regex =~ items[x]) }
+        expected[1] = build_to_s_regex("id", "text2")
+        expected[2] = build_to_s_regex("name", "")
+        expected[3] = build_to_s_regex("value", "goodbye all")
+        items = $ie.text_field(:index, 2).to_s.split(/\n/)
+        expected.each_with_index{|regex, x| assert(regex =~ items[x]) }
+        assert_raises(UnknownObjectException  , "UnknownObjectException  was supposed to be thrown" ) {   $ie.text_field(:index, 999 ).to_s}  
+    end
+    
+    def build_to_s_regex(lhs, rhs)
+        Regexp.new("^#{lhs}: +#{rhs}$")
+    end
+
+    def test_text_field_Append
+         assert_raises(ObjectReadOnlyException  , "ObjectReadOnlyException   was supposed to be thrown" ) {   $ie.text_field(:id, "readOnly2").append("Some Text") }  
+         assert_raises(ObjectDisabledException   , "ObjectDisabledException   was supposed to be thrown" ) {   $ie.text_field(:name, "disabled").append("Some Text") }  
+         assert_raises(UnknownObjectException  , "UnknownObjectException  was supposed to be thrown" ) {   $ie.text_field(:name, "missing_field").append("Some Text") }  
+
+         $ie.text_field(:name, "text1").append(" Some Text")
+         assert_equal(  "Hello World Some Text" , $ie.text_field(:name, "text1").getContents )  
+
+         # may need this to see that it really happened
+         #puts "press return to continue"
+         #gets 
+
+    end
+
+
+    def test_text_field_Clear
+         assert_raises(ObjectReadOnlyException  , "ObjectReadOnlyException   was supposed to be thrown" ) {   $ie.text_field(:id, "readOnly2").append("Some Text") }  
+         assert_raises(ObjectDisabledException   , "ObjectReadOnlyException   was supposed to be thrown" ) {   $ie.text_field(:name, "disabled").append("Some Text") }  
+         assert_raises(UnknownObjectException  , "ObjectReadOnlyException   was supposed to be thrown" ) {   $ie.text_field(:name, "missing_field").append("Some Text") }  
+
+         $ie.text_field(:name, "text1").clear()
+         assert_equal(  "" , $ie.text_field(:name, "text1").getContents )  
+
+         # may need this to see that it really happened
+         #puts "press return to continue"
+         #gets 
+
+    end
+
+    def test_text_field_Set
+         assert_raises(ObjectReadOnlyException  , "ObjectReadOnlyException   was supposed to be thrown" ) {   $ie.text_field(:id, "readOnly2").append("Some Text") }  
+         assert_raises(ObjectDisabledException   , "ObjectReadOnlyException   was supposed to be thrown" ) {   $ie.text_field(:name, "disabled").append("Some Text") }  
+         assert_raises(UnknownObjectException  , "ObjectReadOnlyException   was supposed to be thrown" ) {   $ie.text_field(:name, "missing_field").append("Some Text") }  
+
+         $ie.text_field(:name, "text1").set("watir IE Controller")
+         assert_equal(  "watir IE Controller" , $ie.text_field(:name, "text1").getContents )  
+
+         # may need this to see that it really happened
+         #puts "press return to continue"
+         #gets 
+    end
+
+    def test_text_field_properties
+
+        assert_raises(UnknownObjectException  , "UnknownObjectException  was supposed to be thrown" ) {   $ie.text_field(:index, 199).value}  
+        assert_raises(UnknownObjectException  , "UnknownObjectException  was supposed to be thrown" ) {   $ie.text_field(:index, 199).name }  
+        assert_raises(UnknownObjectException  , "UnknownObjectException  was supposed to be thrown" ) {   $ie.text_field(:index, 199).id }  
+        assert_raises(UnknownObjectException  , "UnknownObjectException  was supposed to be thrown" ) {   $ie.text_field(:index, 199).disabled }  
+        assert_raises(UnknownObjectException  , "UnknownObjectException  was supposed to be thrown" ) {   $ie.text_field(:index, 199).type }  
+
+        assert_equal( "Hello World" , $ie.text_field(:index, 1).value )
+        assert_equal( "text"        , $ie.text_field(:index, 1).type)
+        assert_equal( "text1"       , $ie.text_field(:index, 1).name )
+        assert_equal( ""            , $ie.text_field(:index, 1).id )
+        assert_equal( false         , $ie.text_field(:index, 1).disabled )
+
+        assert_equal( ""            , $ie.text_field(:index, 2).name )
+        assert_equal( "text2"       , $ie.text_field(:index, 2).id )
+
+        assert(  $ie.text_field(:index, 3).disabled )
+
+        assert_equal( "This used to test :afterText" , $ie.text_field(:name, "aftertest"  ).title )
+        assert_equal( "" , $ie.text_field(:index, 1  ).title )
+
+
+    end
+
+    def test_text_field_iterators
+
+        assert_equal( 12 , $ie.text_fields.length )
+
+        # watir is 1 based, so this is the first text field
+        assert_equal( "Hello World" , $ie.text_fields[1].value )
+        assert_equal( "text1" , $ie.text_fields[1].name )
+
+        assert_equal( "password" , $ie.text_fields[ $ie.text_fields.length ].type)
+
+
+        index = 1
+        $ie.text_fields.each do |t|
+            assert_equal(  $ie.text_field(:index, index).value, t.value )
+            assert_equal(  $ie.text_field(:index, index).id, t.id )
+            assert_equal(  $ie.text_field(:index, index).name, t.name )
+            index +=1
+        end
+        assert_equal( index-1, $ie.text_fields.length) 
+
+    end
+
+    def test_JS_Events
+        $ie.text_field(:name , 'events_tester').set('p')
+
+        # the following line has an extra keypress at the begining, as we mimic the delete key being pressed
+        assert_equal( "keypresskeydownkeypresskeyup" , $ie.text_field(:name , 'events_text').value.gsub("\r\n" , "")  )
+        $ie.button(:value , "Clear Events Box").click
+        $ie.text_field(:name , 'events_tester').set('ab')
+
+        # the following line has an extra keypress at the begining, as we mimic the delete key being pressed
+        assert_equal( "keypresskeydownkeypresskeyupkeydownkeypresskeyup" , $ie.text_field(:name , 'events_text').value.gsub("\r\n" , "") )
+
+    end
+
+    def test_password
+
+        $ie.text_field(:name , "password1").set("secret")
+        assert( 'secret' , $ie.text_field(:name , "password1").value )
+
+        $ie.text_field(:id , "password1").set("top_secret")
+        assert( 'top_secret' , $ie.text_field(:id, "password1").value )
+    end
+
+    def test_labels_iterator
+
+        assert_equal(3, $ie.labels.length)
+        assert_equal('Label For this Field' , $ie.labels[1].innerText.strip )
+        assert_equal('Password With ID ( the text here is a label for it )' , $ie.labels[3].innerText )
+
+        count=0
+        $ie.labels.each do |l|
+            count +=1
+        end
+        assert_equal(count, $ie.labels.length)
+
+
+    end
+
+    def test_label_properties
+        assert_raises(UnknownObjectException  ) {  $ie.label(:index,20).innerText  } 
+        assert_raises(UnknownObjectException  ) {  $ie.label(:index,20).for  } 
+        assert_raises(UnknownObjectException  ) {  $ie.label(:index,20).name  } 
+        assert_raises(UnknownObjectException  ) {  $ie.label(:index,20).type  } 
+        assert_raises(UnknownObjectException  ) {  $ie.label(:index,20).id  } 
+
+        assert_false( $ie.label(:index,10).exists? ) 
+        assert_false( $ie.label(:id,'missing').exists? ) 
+        assert( $ie.label(:index,1).exists? ) 
+
+
+        assert_equal( "" , $ie.label(:index,1).id )
+        assert_false(      $ie.label(:index,1).disabled )
+        assert(            $ie.label(:index,1).enabled?)
+
+
+        assert_equal( "label2" , $ie.label(:index,2).id )
+        assert_equal( "Label"  , $ie.label(:index,2).type )
+
+        assert_equal( "Password With ID ( the text here is a label for it )" , $ie.label(:index,3).innerText)
+        assert_equal( "password1" , $ie.label(:index,3).for)
+    end
+
+
+    
+
+end

data/watir.rb

@@ -0,0 +1,3744 @@
+=begin
+  license
+  ---------------------------------------------------------------------------
+  Copyright (c) 2004-2005, Paul Rogers and Bret Pettichord
+  All rights reserved.
+  
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+  
+  1. Redistributions of source code must retain the above copyright notice,
+  this list of conditions and the following disclaimer.
+  
+  2. Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer in the
+  documentation and/or other materials provided with the distribution.
+  
+  3. Neither the names Paul Rogers, Bret Pettichord nor the names of contributors to
+  this software may be used to endorse or promote products derived from this
+  software without specific prior written permission.
+  
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS
+  IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+  PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR
+  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+  OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+  OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+  --------------------------------------------------------------------------
+  (based on BSD Open Source License)
+=end
+
+#  This is Watir, Web Application Testing In Ruby
+#  Home page is http://wtr.rubyforge.org
+#
+#  Version "$Revision: 1.211.2.2 $"
+#
+#  Typical usage: 
+#   # include the controller 
+#   require "watir" 
+#   # go to the page you want to test 
+#   ie = Watir::IE.start("http://myserver/mypage")  
+#   # enter "Paul" into an input field named "username" 
+#   ie.text_field(:name, "username").set("Paul") 
+#   # enter "Ruby Co" into input field with id "company_ID" 
+#   ie.text_field(:id ,"company_ID").set("Ruby Co") 
+#   # click button that has a caption of "Cancel" 
+#   ie.button(:value, "Cancel").click 
+#   
+#  The ways that are available to identify an html object depend upon the object type, but include
+#   :id           used for an object that has an ID attribute -- this is the best way!
+#   :name         used for an object that has a name attribute. 
+#   :value        value of text fields, captions of buttons 
+#   :index        finds the nth object of the specified type - eg button(:index , 2) finds the second button. This is 1 based. <br>
+#   :beforeText   finds the object immeditaley before the specified text. Doesnt work if the text is in a table cell
+#   :afterText    finds the object immeditaley after the specified text. Doesnt work if the text is in a table cell
+#
+
+
+# These 2 web sites provide info on Internet Explorer and on the DOM as implemented by Internet Explorer
+# 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
+
+# command line options:
+#
+#  -b  (background)   Run Internet Explorer invisible
+#  -f  (fast)         Run tests fast
+#  -x  (spinner)      Add a spinner that displays when pages are waiting to be loaded.
+
+require 'win32ole'
+require 'logger'
+require 'watir/winClicker'
+require 'watir/exceptions'
+
+class String
+    def matches (x)
+        return self == x
+    end
+end
+
+class Regexp
+    def matches (x)
+        return self.match(x) 
+    end
+end
+
+# ARGV needs to be deleted to enable the Test::Unit functionality that grabs
+# the remaining ARGV as a filter on what tests to run.
+# Note: this means that watir must be require'd BEFORE test/unit.
+def command_line_flag(switch)
+    setting = ARGV.include?(switch) 
+    ARGV.delete(switch)
+    return setting
+end            
+
+# Constant to make Internet explorer minimisez. -b stands for background
+$HIDE_IE = command_line_flag('-b') 
+
+# Constant to enable/disable the spinner
+$ENABLE_SPINNER = command_line_flag('-x') 
+
+# Constant to set fast speed
+$FAST_SPEED = command_line_flag('-f')
+
+# Eat the -s command line switch (deprecated)
+command_line_flag('-s')
+
+module Watir
+    include Watir::Exception
+
+    # BUG: this won't work right until the null objects are pulled out
+    def exists?
+        begin
+            yield
+            true
+        rescue
+            false
+        end
+    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
+    
+    # This class displays the spinner object that appears in the console when a page is being loaded
+    class Spinner
+        
+        def initialize(enabled = true)
+            @s = [ "\b/" , "\b|" , "\b\\" , "\b-"]
+            @i=0
+            @enabled = enabled
+        end
+        
+        # reverse the direction of spinning
+        def reverse
+            @s.reverse!
+        end
+        
+        def spin
+            print self.next if @enabled
+        end
+
+        # get the next character to display
+        def next
+            @i=@i+1
+            @i=0 if @i>@s.length-1
+            return @s[@i]
+        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 @ieController, document and document.body
+    module SupportsSubElements 
+        include Watir::Exception
+
+        # this method returns the real Internet Explorer object, allowing access to objects, properties and methods that Watir doesnot support
+        def ie
+            return @ieController
+        end
+
+        # write the specified string to the log, assuming a logger has been setup using IE#set_logger
+        def log ( what )
+            @ieController.logger.debug( what ) if @logger
+        end
+
+        # this method causes Watir to wait until Internet Explorer has finished the action
+        def wait( noSleep  = false )
+             @ieController.wait( noSleep )
+        end
+
+        def process_default(default_attribute, how, what)
+            if what == nil
+                what = how
+                how = default_attribute 
+            end
+            return how, what
+        end 
+        private :process_default
+
+        # 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.
+        #
+        # Typical usage:
+        #
+        #   ie.frame(:index, 1) 
+        #   ie.frame(:name , 'main_frame')
+        #   ie.frame('main_frame')        # in this case, just a name is supplied
+        def frame(how, what=nil)
+            how, what = process_default :name, how, what
+            return 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
+        #  * 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
+        def form(how, what=nil)
+            how, what = process_default :name, how, what
+            return 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. 
+        # The first form can be accessed with :index 1, the second :index 2, etc. 
+        #   * how - symbol - the way we look for the table. Supported values are
+        #                  - :id
+        #                  - :index
+        #   * what  - string the thing we are looking for, ex. id or index of the object we are looking for
+        def table( how, what )
+            return 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()
+            return Tables.new(self)
+        end
+
+        # this method accesses a table cell. 
+        # how - symbol - how we access the cell,  :id is supported
+        # 
+        # returns a TableCell Object
+        def cell( how, what )
+           return TableCell.new( self, how, what)
+        end
+
+        # this method accesses a table row. 
+        # how - symbol - how we access the row,  :id is supported
+        # 
+        # returns a TableRow object
+        def row( how, what )
+           return TableRow.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 
+        #  *  what  - string, int or re , what we are looking for, 
+        # Returns a Button object.
+        #
+        # Valid values for 'how' are
+        #
+        #    :index      - find the item using the index in the container ( a container can be a document, a TableCell, a Span, a Div or a P
+        #                  index is 1 based
+        #    :name       - find the item using the name attribute
+        #    :id         - find the item using the id attribute
+        #    :value      - find the item using the value attribute ( in this case the button caption)
+        #    :caption    - same as value
+        #    :beforeText - finds the item immediately before the specified text
+        #    :afterText  - finds the item immediately after the specified text
+        #
+        # 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)
+        #
+        # 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
+            return 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()
+            return 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 , :index, :id, :name etc
+        #  *  what  - string, int or re , 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)
+            return 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()
+            return 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, int or re , what we are looking for, 
+        #
+        # returns a TextField object
+        #
+        # Valid values for 'how' are
+        #
+        #    :index      - find the item using the index in the container ( a container can be a document, a TableCell, a Span, a Div or a P
+        #                  index is 1 based
+        #    :name       - find the item using the name attribute
+        #    :id         - find the item using the id attribute
+        #    :beforeText - finds the item immediately before the specified text
+        #    :afterText  - finds the item immediately after the specified text
+        #
+        # 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)
+        def text_field(how , what=nil)
+            return 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
+            return 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 field , :index, :id, :name etc
+        #  *  what  - string, int or re , what we are looking for, 
+        #
+        # 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)
+        def hidden( how, what )
+            return 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
+            return 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, int or re , what we are looking for, 
+        #
+        # returns a SelectList object
+        #
+        # Valid values for 'how' are
+        #
+        #    :index      - find the item using the index in the container ( a container can be a document, a TableCell, a Span, a Div or a P
+        #                  index is 1 based
+        #    :name       - find the item using the name attribute
+        #    :id         - find the item using the id attribute
+        #    :beforeText - finds the item immediately before the specified text
+        #    :afterText  - finds the item immediately after the specified text
+        #
+        # 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)
+        def select_list(how , what=nil)
+            return 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()
+            return 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, int or re , 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
+        #
+        # returns a CheckBox object
+        #
+        # Valid values for 'how' are
+        #
+        #    :index      - find the item using the index in the container ( a container can be a document, a TableCell, a Span, a Div or a P
+        #                  index is 1 based
+        #    :name       - find the item using the name attribute
+        #    :id         - find the item using the id attribute
+        #    :beforeText - finds the item immediately before the specified text
+        #    :afterText  - finds the item immediately after the specified text
+        #
+        # 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'
+        def checkbox(how, what=nil ,value=nil)
+            return 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
+            return 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, int or regexp , 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
+        #
+        # returns a Radio object
+        #
+        # Valid values for 'how' are
+        #
+        #    :index      - find the item using the index in the container ( a container can be a document, a TableCell, a Span, a Div or a P
+        #                  index is 1 based
+        #    :name       - find the item using the name attribute
+        #    :id         - find the item using the id attribute
+        #    :beforeText - finds the item immediately before the specified text
+        #    :afterText  - finds the item immediately after the specified text
+        #
+        # 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 type = radio  name = email_frequency value = 'Weekly'> Weekly Email
+        #  <input type = radio  name = email_frequency value = 'monthly'>Monthly Email
+        #
+        # 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'
+        #
+        def radio(how, what=nil, value=nil)
+            return 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
+            return Radios.new(self)
+        end
+        
+        # This is the main method for accessing a link.
+        #  *  how   - symbol - how we access the link, :index, :id, :name , :beforetext, :afterText, :title , :text , :url
+        #  *  what  - string, int or re , what we are looking for
+        #
+        # returns a Link object
+        #
+        # Valid values for 'how' are
+        #
+        #    :index      - find the item using the index in the container ( a container can be a document, a TableCell, a Span, a Div or a P
+        #                  index is 1 based
+        #    :name       - find the item using the name attribute
+        #    :id         - find the item using the id attribute
+        #    :beforeText - finds the item immediately before the specified text
+        #    :afterText  - finds the item immediately after the specified text
+        #    :url        - finds the link based on the url. This must be the full path to the link, so is best used with a regular expression
+        #    :text       - finds a link using the innerText of the link, ie the Text that is displayed to the user
+        #    :title      - finds the item using the tool tip text
+        #
+        # 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(:afterText, 'Click->')      # access the link that immediately follows the text Click->
+        #
+        def link(how, what=nil)
+            return 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
+            return Links.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 or :alt are supported
+        #  *  what  - string, int or re , what we are looking for, 
+        #
+        # returns an Image object
+        #
+        # Valid values for 'how' are
+        #
+        #    :index      - find the item using the index in the container ( a container can be a document, a TableCell, a Span, a Div or a P
+        #                  index is 1 based
+        #    :name       - find the item using the name attribute
+        #    :id         - find the item using the id attribute
+        #    :alt        - finds the item using the tool tip text
+        #    :src        - finds the item using the src tag. This must be the fully qualified name, so is best used with a regular expression
+        #
+        # 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
+        #   
+        def image( how , what=nil)
+            return 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
+            return Images.new(self)
+        end
+
+        # This is the main method for accessing JavaScript popups.
+        # returns a PopUp object
+        def popup
+            return 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, :index, :id, :title
+        #  *  what  - string, integer or re , what we are looking for, 
+        #
+        # 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
+        #   
+        def div(how, what)
+            return Div.new(self, how, what)
+        end
+
+        # this is the main method for accessing the divs iterator. Returns a Divs object
+        #
+        # 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
+            return 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, :index, :id, :name 
+        #  *  what  - string, integer or re , what we are looking for, 
+        #
+        # 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)
+            return 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
+            return 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, :index, :id, :name 
+        #  *  what  - string, integer or re , what we are looking for, 
+        #
+        # 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)
+            return 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
+            return Ps.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, :index, :id, :for
+        #  *  what  - string, integer or re , what we are looking for, 
+        #
+        # 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)
+            return 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()
+            return Labels.new(self)
+        end
+
+        #--
+        #
+        # Searching for Page Elements
+        # Not for external consumption
+        #        
+        #++
+        def getContainerContents()
+            return document.body.all 
+        end
+        private :getContainerContents
+
+        # 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.
+        # BUG: This looks wrong: Not everything that includes SupportsSubElements has a document.body!
+        def getContainer()
+            return document.body
+        end
+     
+        # This is the main method for finding objects 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. Only used when index is specified as the how.
+        #   * value - used for objects that have one name, but many values. ex. radio lists and checkboxes
+        def getObject(how, what, types, value=nil)
+            container = getContainerContents # XXX actually this returns a collection object (not a container)
+            how = :value if how == :caption
+            log "getting object - how is #{how} what is #{what} types = #{types} value = #{value}"
+            
+            o = nil
+            if how == :index
+                index =  what.to_i
+                log" getting object #{types.to_s}  at index( #{index}"
+                
+                objectIndex = 1
+                container.each do | thisObject |
+                    begin
+                        this_type = thisObject.invoke("type")
+                    rescue
+                        this_type = nil
+                    end
+                    if types.include?(this_type)
+                        if objectIndex == index
+                            o = thisObject
+                            break
+                        end
+                        objectIndex += 1
+                    end
+                end
+                return o
+                
+            else
+                container.each do |object|
+                    next  unless o == nil
+                    
+                    begin
+                        case how
+                        when :id
+                            attribute = object.invoke("id")
+                        when :name
+                            attribute = object.invoke("name")
+                        when :value
+                            attribute = object.value
+                        when :alt
+                            attribute = object.alt
+                        when :src
+                            attribute = object.src
+                        when :beforeText
+                            attribute = object.getAdjacentText("afterEnd").strip
+                        when :afterText
+                            attribute = object.getAdjacentText("beforeBegin").strip
+                        else
+                            next
+                        end
+                        
+                        if what.matches(attribute) && types.include?(object.invoke("type"))
+                            if value
+                                log "checking value supplied #{value} ( #{value.class}) actual #{object.value} ( #{object.value.class})"
+                                if object.value.to_s == value.to_s
+                                    o = object
+                                end
+                            else # no value
+                                o = object
+                            end
+                        end
+                        
+                    rescue => e
+                        log 'IE#getObject error ' + e.to_s 
+                    end
+                    
+                end
+            end
+            
+            return o
+        end
+
+        # This method is used iternally by Watir and should not be used externally. It cannot be marked as private because of the way mixins and inheritance work in watir
+        #
+        # this method finds the specified image
+        #    * how  - symbol - how to look
+        #    * what - string or regexp - what to look ofr
+        def getImage( how, what )
+
+            doc = document
+            count = 1
+            images = doc.all.tags("IMG")
+            o=nil
+            images.each do |img|
+                
+                #puts "Image on page: src = #{img.src}"
+                
+                next unless o == nil
+                if how == :index
+                    o = img if count == what.to_i
+                else                
+                    case how
+                        
+                    when :src
+                        attribute = img.src
+                    when :name
+                        attribute = img.name
+                    when :id
+                        attribute = img.invoke("id")
+                    when :alt
+                        attribute = img.invoke("alt")
+                    else
+                        next
+                    end
+                    
+                    o = img if what.matches(attribute)
+                end
+                count +=1
+            end # do
+            return o
+
+        end
+
+        # This method is used iternally by Watir and should not be used externally. It cannot be marked as private because of the way mixins and inheritance work in watir
+        #
+        # This method gets a link from the document. This is a hyperlink, generally declared in the <a href="http://testsite">test site</a> HTML tag.
+        #   * how  - symbol - how we get the link Supported types are:
+        #                     :index - the link at position x , 1 based
+        #                     :url   - get the link that has a url that matches. A regular expression match is performed
+        #                     :text  - get link based on the supplied text. uses either a string or regular expression match
+        #   * what - depends on how - an integer for index, a string or regexp for url and text
+        def getLink( how, what )
+            links = document.all.tags("A")
+            
+            # Guard ensures watir won't crash if somehow the list of links is nil
+            if (links == nil)
+                raise UnknownObjectException, "Unknown Object in getLink: attempted to click a link when no links present"
+            end
+            
+            link = nil
+            case how
+            when :index
+                begin
+                    link = links[ (what-1).to_s ]
+                rescue
+                    link=nil
+                end
+                
+            when :url
+                links.each do |thisLink|
+                    if what.matches(thisLink.href) 
+                        link = thisLink if link == nil
+                    end
+                end
+                
+            when :text
+                links.each do |thisLink|
+                    if what.matches(thisLink.innerText.strip) 
+                        link = thisLink if link == nil
+                    end
+                end
+                
+            when :id
+                links.each do |thisLink|
+                    if what.matches(thisLink.invoke("id"))
+                        link = thisLink if link == nil
+                    end
+                end
+            when :name
+                links.each do |thisLink|
+                    if what.matches(thisLink.invoke("name"))
+                        link = thisLink if link == nil
+                    end
+                end
+
+            when :title
+                links.each do |thisLink|
+                    if what.matches(thisLink.invoke("title"))
+                        link = thisLink if link == nil
+                    end
+                end
+                
+            when :beforeText
+                links.each do |thisLink|
+                    if what.matches(thisLink.getAdjacentText("afterEnd").strip)
+                        link = thisLink if link == nil
+                    end
+                end
+
+            when :afterText
+                links.each do |thisLink|
+                    if what.matches(thisLink.getAdjacentText("beforeBegin").strip)
+                        link = thisLink if link == nil
+                    end
+                end
+            else
+                raise MissingWayOfFindingObjectException, "#{how.inspect} is an unknown way of finding a link ( #{what} )"
+            end
+            
+            # if no link found, link will be a nil.  This is OK.  Actions taken on links (e.g. "click") should rescue 
+            # the nil-related exceptions and provide useful information to the user.
+            return link
+        
+        end
+
+        # This method is used iternally by Watir and should not be used externally. It cannot be marked as private because of the way mixins and inheritance work in watir
+        #
+        # This method gets a table row or cell 
+        #   * how  - symbol - how we get the link row or cell types are:
+        #            id
+        #   * what -  a string or regexp 
+        def getTablePart( part , how , what )
+             doc = document
+             parts = doc.all.tags( part )
+             n = nil
+             parts.each do | p |
+                 next unless n==nil
+                 if what.matches( p.invoke("id") )
+                     n = p 
+                 end
+             end
+             return n
+        end
+
+        # This method is used iternally by Watir and should not be used externally. It cannot be marked as private because of the way mixins and inheritance work in watir
+        #
+        # this method is used to get elements like SPAN or DIV
+        def getNonControlObject(part , how, what )
+
+             doc = document
+             parts = doc.all.tags( part )
+             n = nil
+             case how
+                when :id
+                    attribute = "id"
+                when :name
+                    attribute = "name"
+                when :title
+                    attribute = "title"
+                when :for   # only applies to labels
+                    attribute = "htmlFor"
+              end
+
+              if attribute
+                 parts.each do | p |
+                     next unless n==nil
+                     n = p if what.matches( p.invoke(attribute) )
+                 end
+              elsif how == :index
+                  count = 1
+                  parts.each do | p |
+                     next unless n==nil
+                     n = p if what == count
+                     count +=1
+                  end
+              else
+                  raise MissingWayOfFindingObjectException, "unknown way of finding a #{ part} ( {what} )"
+              end
+            return n
+
+        end
+
+    end
+
+    
+    # This class is the main Internet Explorer Controller
+    # An instance of this must be created to access Internet Explorer.
+    class IE
+        include Watir::Exception
+        include SupportsSubElements 
+
+        # The revision number ( according to CVS )
+        REVISION = "$Revision: 1.211.2.2 $"
+
+        # the Release number
+        VERSION = "1.4.1"
+        
+        # Used internally to determine when IE has finished loading a page
+        READYSTATE_COMPLETE = 4         
+        
+        # The default delay when entering text on a web page.
+        DEFAULT_TYPING_SPEED = 0.08
+        
+        # The default time we wait after a page has loaded.
+        DEFAULT_SLEEP_TIME = 0.1
+        
+        # The default color for highlighting objects as they are accessed.
+        DEFAULT_HIGHLIGHT_COLOR = "yellow"
+        
+        # This is used to change the typing speed when entering text on a page.
+        attr_accessor :typingspeed
+        
+        # This is used to change how long after a page has finished loading that we wait for.
+        attr_accessor :defaultSleepTime
+        
+        # The color we want to use for the active object. This can be any valid web-friendly color.
+        attr_accessor :activeObjectHighLightColor
+
+        # use this to switch the spinner on and off
+        attr_accessor :enable_spinner
+
+        # use this to get the time for the last page download
+        attr_reader :down_load_time
+        
+        # When a new window is created it is stored in newWindow
+        attr_accessor :newWindow
+
+        # Use this to gain access to the 'raw' internet explorer object.        
+        attr_reader :ie
+
+        # access to the logger object
+        attr_accessor :logger
+
+
+        # this contains the list of unique urls that have been visited
+        attr_reader :url_list                        
+
+        def initialize(suppress_new_window=nil)
+            unless suppress_new_window
+                create_browser_window
+                set_defaults
+            end
+        end
+        
+        # Create a new IE Window, starting at the specified url.
+        # If no url is given, start empty.
+        def IE.start( url = nil )
+            ie = new
+            ie.goto(url) if url
+            return ie
+        end
+        
+        # Attach to an existing IE window, either by url or title.
+        # IE.attach(:url, 'http://www.google.com')
+        # IE.attach(:title, 'Google') 
+        def IE.attach(how, what)
+            ie = new(true) # don't create window
+            ie.attach_init(how, what)
+            return ie
+        end   
+
+        # this method is used internally to attach to an existing window
+        # dont make private
+        def attach_init( how, what )
+            attach_browser_window(how, what)
+            set_defaults
+            wait                        
+        end        
+        
+        def set_defaults
+            @form = nil
+
+            @enable_spinner = $ENABLE_SPINNER
+            @error_checkers= []
+
+            @ie.visible = ! $HIDE_IE
+            @activeObjectHighLightColor = DEFAULT_HIGHLIGHT_COLOR
+            if $FAST_SPEED
+                set_fast_speed
+            else
+                set_slow_speed
+            end
+
+            @logger = DefaultLogger.new()
+
+            @url_list = []
+
+            # add an error checker for http navigation errors, such as 404, 500 etc
+            navigation_checker=Proc.new{ |ie|
+                if ie.document.frames.length > 1
+                    1.upto ie.document.frames.length do |i|
+                        check_for_http_error(ie.frame(:index, i)  )
+                    end
+                else
+                    check_for_http_error(ie)
+                end
+             }
+
+            add_checker(  navigation_checker )       
+
+        end
+        private :set_defaults        
+        
+        # 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(ie)
+            url=ie.document.url 
+            #puts "url is " + url
+            if /shdoclc.dll/.match(url)
+                #puts "Match on shdoclc.dll"
+                m = /id=IEText.*?>(.*?)</i.match(ie.html)
+                if m
+                    #puts "Error is #{m[1]}"
+                    raise NavigationException , m[1]
+                end
+            end
+        end
+
+        def set_fast_speed
+            @typingspeed = 0
+            @defaultSleepTime = 0.01
+        end            
+
+        def set_slow_speed
+            @typingspeed = DEFAULT_TYPING_SPEED
+            @defaultSleepTime = DEFAULT_SLEEP_TIME
+        end
+        
+        def create_browser_window
+            @ie = WIN32OLE.new('InternetExplorer.Application')
+        end
+        private :create_browser_window
+
+        def attach_browser_window( how, what )
+            log "Seeking Window with #{how}: #{ what }"
+            shell = WIN32OLE.new("Shell.Application")
+            appWindows = shell.Windows()
+            
+            ieTemp = nil
+            appWindows.each do |aWin| 
+                log "Found a window: #{aWin}. "
+                
+                case how
+                when :url
+                    log " url is: #{aWin.locationURL}\n"
+                    ieTemp = aWin if (what.matches(aWin.locationURL) )
+                when :title
+                    # normal windows explorer shells do not have document
+                    title = nil
+                    begin
+                        title = aWin.document.title
+                    rescue WIN32OLERuntimeError
+                    end
+                    ieTemp = aWin if (what.matches( title ) ) 
+                else
+                    raise ArgumentError
+                end
+            end
+
+            #if it can not find window
+            if ieTemp == nil
+                 raise NoMatchingWindowFoundException,
+                 "Unable to locate a window with #{ how} of #{what}"
+            end
+            @ie = ieTemp
+        end
+        private :attach_browser_window
+
+        # deprecated: use logger= instead
+        def set_logger( logger )
+            @logger = logger
+        end
+
+        def log ( what )
+            @logger.debug( what ) if @logger
+        end
+        
+        # Deprecated: Use IE#ie instead
+        # This method returns the Internet Explorer object. 
+        # Methods, properties,  etc. that the IE object does not support can be accessed.
+        def getIE()
+            return @ie
+        end
+        
+        #
+        # Accessing data outside the document
+        #
+        
+        # Return the title of the window
+        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()
+            sleep 0.2
+            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
+            @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 = WIN32OLE.new('AutoItX3.Control')
+    		autoit.WinActivate title, ''		
+     	end
+
+     	def front?
+    		autoit = WIN32OLE.new('AutoItX3.Control')
+    		1 == autoit.WinActive(title, '')		
+     	end	     	         
+
+     	def set_window_state (state)
+    		autoit = WIN32OLE.new('AutoItX3.Control')
+    		autoit.WinSetState title, '', autoit.send(state)			
+        end
+        private :set_window_state
+                
+		# 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 = WIN32OLE.new 'AutoItX3.Control' 
+            autoit.WinActivate title
+            autoit.Send key_string
+        end
+
+        # used by the popup code only
+        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
+
+        # Search the current page for specified text or regexp.
+        # Returns true if the specified text was found.
+        # Returns matchdata object if the specified regexp was found.
+        #  * text - string or regular expression - the string to look for
+        def contains_text(text)
+            returnValue = false
+            retryCount = 0
+            begin
+                retryCount += 1
+                returnValue = 
+                if text.kind_of? Regexp
+                    document.body.innerText.match(text)
+                elsif text.kind_of? String
+                    document.body.innerText.index(text)
+                else
+                    raise MissingWayOfFindingObjectException
+                end 
+            rescue MissingWayOfFindingObjectException => e
+                raise e
+            rescue
+                retry if retryCount < 2 
+            end
+            return returnValue
+        end
+
+        # 
+        # Synchronization
+        #
+        
+        # This method is used internally to cause an execution to stop until the page has loaded in Internet Explorer.
+        def wait( noSleep  = false )
+            begin
+                @down_load_time=0
+                pageLoadStart = Time.now
+                @pageHasReloaded= false
+                
+                s= Spinner.new(@enable_spinner)
+                while @ie.busy
+                    @pageHasReloaded = true
+                    sleep 0.02
+                    s.spin
+                end
+                s.reverse
+                
+                log "wait: readystate=" + @ie.readyState.to_s 
+                until @ie.readyState == READYSTATE_COMPLETE
+                    @pageHasReloaded = true
+                    sleep 0.02
+                    s.spin
+                end
+                sleep 0.02
+                
+                until @ie.document.readyState == "complete"
+                    sleep 0.02
+                    s.spin
+                end
+                
+                
+                if @ie.document.frames.length > 1
+                    begin
+                        0.upto @ie.document.frames.length-1 do |i|
+                            until @ie.document.frames[i.to_s].document.readyState == "complete"
+                                sleep 0.02
+                                s.spin
+                            end
+                            @url_list << @ie.document.frames[i.to_s].document.url unless url_list.include?(@ie.document.frames[i.to_s].document.url)
+                        end
+                    rescue=>e
+                        @logger.warn 'frame error in wait'   + e.to_s + "\n" + e.backtrace.join("\n")
+                    end
+                else
+                    @url_list << @ie.document.url unless @url_list.include?(@ie.document.url)
+                end
+                @down_load_time =  Time.now - pageLoadStart 
+
+                run_error_checks
+
+                print "\b" unless @enable_spinner == false
+                
+                s=nil
+            rescue WIN32OLERuntimeError => e
+                @logger.info "runtime error in wait: #{e}\n#{e.backtrace.join("\\\n")}"
+            end
+            sleep 0.01
+            sleep @defaultSleepTime unless noSleep  == true
+        end
+
+        # Error checkers
+
+        # this method runs the predefined error checks
+        def run_error_checks
+            @error_checkers.each do |e|
+                e.call(self)
+            end
+        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
+
+        # The HTML of the current page
+        def html
+            return document.body.outerHTML
+        end
+        
+        # The text of the current document
+        def text
+            return document.body.innerText.strip
+        end
+
+        #
+        # Show me state
+        #        
+        
+        # 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--" if e.to_s.match(/Access is denied/)
+                    end
+                end
+            else
+                puts "no frames"
+            end
+        end
+        
+        # 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=s+ p.ljust(print_sizes[i]) 
+            end
+            s=s + "text/src".ljust(text_size)
+            s=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 =s+ temp_var
+                end
+                s=s+  n.innerText
+                if n.getElementsByTagName("IMG").length > 0
+                     s=s+  " / " + n.getElementsByTagName("IMG")[0.to_s].src
+                end
+                s=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=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 =s+ "  " + "#{prop}=#{p}".to_s.ljust(18)
+                rescue
+                    #this object probably doesnt have this property
+                end
+            end
+            s=s+"\n"
+        end
+        
+        # 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=s+n.invoke("type").to_s.ljust(16)
+                rescue
+                    next
+                end
+                props.each do |prop|
+                    begin
+                        p = n.invoke(prop)
+                        s =s+ "  " + "#{prop}=#{p}".to_s.ljust(18)
+                    rescue
+                        # this object probably doesnt have this property
+                    end
+                end
+                s=s+"\n"
+            end
+            puts s+"\n\n\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=#{d.rows["0"].cells.length }"
+                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
+
+        #
+        # This method gives focus to the frame
+        # It may be removed and become part of the frame object
+        def focus
+            document.activeElement.blur
+            document.focus
+        end
+       
+    end # class IE
+        
+    # 
+    # MOVETO: watir/popup.rb
+    # Module Watir::Popup
+    #
+    
+    # POPUP object
+    class PopUp
+        def initialize( ieController )
+            @ieController = ieController
+        end
+        
+        def button( caption )
+            return JSButton.new(  @ieController.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
+    
+    # 
+    # Module Watir::Control or Watir::BrowserDriver
+    #
+
+    class Frame < IE
+    
+        def initialize(container, how, what)
+            @container = container
+            @frame = nil
+
+            frames = @container.document.frames
+
+            for i in 0 .. frames.length-1
+                next unless @frame == nil
+                this_frame = frames.item(i)
+                if how == :index 
+                    if i+1 == what
+                        @frame = this_frame
+                    end
+                elsif how == :name
+                    begin
+                        if what.matches(this_frame.name)
+                            @frame = this_frame
+                        end
+                    rescue # access denied?
+                    end
+                elsif how == :id
+                    # BUG: Won't work for IFRAMES
+                    if what.matches(@container.document.getElementsByTagName("FRAME").item(i).invoke("id"))
+                        @frame = this_frame
+                    end
+                else
+                    raise ArgumentError, "Argument #{how} not supported"
+                end
+            end
+            
+            unless @frame
+                raise UnknownFrameException , "Unable to locate a frame with name #{ what} " 
+            end
+
+            @typingspeed = container.typingspeed      
+            @activeObjectHighLightColor = container.activeObjectHighLightColor      
+        end
+
+        def ie
+            return @frame
+        end
+
+        def document
+            @frame.document
+        end
+
+        def wait(no_sleep = false)
+            @container.wait(no_sleep)
+        end
+    end
+    
+
+    # Forms
+
+    module FormAccess
+        def name
+            @form.getAttributeNode('name').value
+        end
+        def action
+            @form.action
+        end
+        def method
+            @form.invoke('method')
+        end
+        def id
+            @form.invoke("id").to_s
+        end
+    end        
+        
+    # wraps around a form OLE object
+    class FormWrapper
+        include FormAccess
+        def initialize ( ole_object )
+            @form = ole_object
+        end
+    end
+       
+    #   Form Factory object 
+    class Form < IE
+        include FormAccess
+
+        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 )
+            @container = container
+            @formHow = how
+            @formName = what
+            
+            log "Get form  formHow is #{@formHow}  formName is #{@formName} "
+            count = 1
+            doc = @container.document
+            doc.forms.each do |thisForm|
+                next unless @form == nil
+
+                wrapped = FormWrapper.new(thisForm)
+
+                log "form on page, name is " + wrapped.name
+                
+                @form =
+                case @formHow
+                when :name 
+                    wrapped.name == @formName ? thisForm : nil
+                when :id
+                    wrapped.id == @formName.to_s ? thisForm : nil
+                when :index
+                    count == @formName.to_i ? thisForm : nil
+                when :method
+                    wrapped.method.downcase == @formName.downcase ? thisForm : nil
+                when :action
+                    @formName.matches(wrapped.action) ? thisForm : nil
+                else
+                    raise MissingWayOfFindingObjectException
+                end
+                count = count +1
+            end
+            
+            @typingspeed = @container.typingspeed      
+            @activeObjectHighLightColor = @container.activeObjectHighLightColor      
+        end
+
+        def exists?
+            @form ? true : false
+        end
+        
+        # Submit the data -- equivalent to pressing Enter or Return to submit a form. 
+        def submit
+            raise UnknownFormException ,  "Unable to locate a form using #{@formHow} and #{@formName} " if @form == nil
+            @form.submit 
+            @container.wait
+        end   
+
+        def getContainerContents
+            raise UnknownFormException , "Unable to locate a form using #{@formHow} and #{@formName} " if @form == nil
+            @form.elements.all
+        end   
+        private :getContainerContents
+
+        def getContainer
+            return @form
+        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( setOrClear  , element , count)
+
+            if setOrClear == :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        
+        def flash
+            @original_styles = {}
+            10.times do
+                count=0
+                @form.elements.each do |element|
+                    highLight(:set , element , count)
+                    count +=1
+                end
+                sleep 0.05
+                count = 0
+                @form.elements.each do |element|
+                    highLight(:clear , element , count)
+                    count +=1
+                end
+                sleep 0.05
+            end
+        end
+                
+    end # class Form
+    
+    # Base class for most elements.
+    # This is not a class that users would normally access. 
+    class Element
+        include Watir::Exception
+        
+        # number of spaces that seperate the property from the value in the to_s method
+        TO_S_SIZE = 14
+        
+        #   o  - the ole object for the element being wrapped
+        def initialize( o )
+            @o = o
+            @originalColor = nil
+        end
+        
+        private
+        def self.def_wrap(method_name)
+            class_eval "def #{method_name}
+                          assert_exists
+                          @o.invoke('#{method_name}')
+                        end"
+        end
+        def self.def_wrap_guard(method_name)
+            class_eval "def #{method_name}
+                          assert_exists
+                          begin
+                            @o.invoke('#{method_name}')
+                          rescue
+                            ''
+                          end
+                        end"
+        end
+        def assert_exists
+            unless @o
+                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
+
+        public
+        def_wrap_guard :type        
+        def_wrap_guard :name
+        def_wrap :id
+        def_wrap :disabled
+        def_wrap_guard :value
+        def_wrap_guard :title
+
+        # returns the Object in its OLE form, allowing any methods of the DOM that Watir doesnt support to be used    
+        #--    
+        # BUG: should be renamed appropriately and then use an attribute reader
+        #++
+        def getOLEObject
+            return @o
+        end
+  
+        # returns the outer html of the object - see http://msdn.microsoft.com/workshop/author/dhtml/reference/properties/outerhtml.asp?frame=true
+        def html
+            assert_exists
+            return @o.outerHTML
+        end
+
+        # Returns 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
+        
+        # This method displays 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
+        def highLight( setOrClear )
+            if setOrClear == :set
+                begin
+                    @originalColor = @o.style.backgroundColor
+                    @o.style.backgroundColor = @ieController.activeObjectHighLightColor
+                rescue 
+                    @originalColor = nil
+                end
+            else # BUG: assumes is :clear, but could actually be anything
+                begin 
+                    @o.style.backgroundColor = @originalColor unless @originalColor == nil
+                rescue
+                    # we could be here for a number of reasons...
+                ensure
+                    @originalColor = 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
+            assert_exists
+            assert_enabled
+           
+            highLight(:set)
+            @o.click()
+            @ieController.wait()
+            highLight(:clear)
+        end
+
+        # causes the object to flash. Normally used in IRB when creating scripts        
+        def flash
+            assert_exists
+            10.times do
+                highLight(:set)
+                sleep 0.05
+                highLight(:clear)
+                sleep 0.05
+            end
+            nil
+        end
+        
+        # This method 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 fireEvent(event)
+            assert_exists
+            assert_enabled
+
+            highLight(:set)
+            @o.fireEvent(event)
+            @ieController.wait()
+            highLight(:clear)
+        end
+        alias fire_event fireEvent
+        
+        # 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_exists
+            assert_enabled
+            @o.focus()
+        end
+        
+        # This methods checks to see if the current element actually exists. 
+        def exists?
+            @o? true: false
+        end
+        
+        # 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 ! @o.invoke("disabled")
+        end
+    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
+        #   * ieController  - an instance of an IE object
+        def initialize( ieController)
+            @ieController = ieController
+            @length = length() # defined by subclasses
+
+            # set up the items we want to display when the show method s used
+            set_show_items
+        end
+ 
+        def set_show_items
+            @show_attributes = AttributeLengthPairs.new( "id" , 20)
+            @show_attributes.add( "name" , 20)
+        end
+
+        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 = @ieController.getContainer.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=s + attribute_length_pair.attribute.ljust(attribute_length_pair.length)
+            end
+
+            index = 1
+            self.each do |o|
+                s= s+"\n"
+                s=s + index.to_s.ljust(6)
+                @show_attributes.each do |attribute_length_pair| 
+                    begin
+                        s=s  + eval( 'o.getOLEObject.invoke("#{attribute_length_pair.attribute}")').to_s.ljust( attribute_length_pair.length  )
+                    rescue=>e
+                        s=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(@ieController, :index, i+1)
+        end
+    end
+
+    # this class contains items that are common between the span and div objects
+    # it would not normally be used directly
+    #
+    # many of the methods available to this object are inherited from the Element class
+    #
+    class SpanDivCommon < Element
+        include Watir::Exception
+        include SupportsSubElements 
+
+        attr_reader :typingspeed      
+
+        def initialize( ieController,  how , what )
+            @ieController = ieController
+            @how = how
+            @what = what
+            @o = @ieController.getNonControlObject(tag , @how, @what )
+            super( @o )
+            @typingspeed = @ieController.typingspeed      
+            @activeObjectHighLightColor = @ieController.activeObjectHighLightColor      
+        end
+
+        def getContainerContents()
+            return @o.all
+        end
+        private :getContainerContents
+
+        def getContainer()
+            return @o
+        end
+
+        # this method returns the innerText of the object
+        # raises an ObjectNotFound exception if the object cannot be found
+        def text
+            assert_exists
+            return @o.innerText.strip
+        end
+
+        # returns the class name of the span or div is using
+        # raises an ObjectNotFound exception if the object cannot be found
+        def class_name
+            assert_exists
+            return @o.invoke("className")
+        end
+
+        # this method returns the type of  object
+        # raises an ObjectNotFound exception if the object cannot be found
+        def type
+            assert_exists
+            return self.class.name[self.class.name.index("::")+2 .. self.class.name.length ]
+        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=r + span_div_string_creator
+            return r.join("\n")
+         end
+    end
+
+    class P < SpanDivCommon 
+        TAG = 'P'
+        def tag; TAG; end
+        def self.tag; TAG; end
+    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 < SpanDivCommon 
+        TAG = 'DIV'
+        def tag; TAG; end
+        def self.tag; TAG; end
+    end
+
+    # this class is used to deal with Span tags in the html page. It would not normally be created by users
+    class Span < SpanDivCommon 
+        TAG = 'SPAN'
+        def tag; TAG; end
+        def self.tag; TAG; end
+    end
+
+    # this class is used to access a label object on the html page - http://msdn.microsoft.com/workshop/author/dhtml/reference/objects/label.asp?frame=true
+    #
+    # many of the methods available to this object are inherited from the Element class
+    #
+    class Label < Element
+        def initialize( ieController , how, what)
+            @ieController = ieController
+            @how = how
+            @what = what
+            @o = @ieController.getNonControlObject("LABEL" , @how, @what )
+            super( @o )
+        end
+
+        # return the type of this object
+        def type
+            assert_exists
+            return "Label"
+        end
+
+        # return the ID of the control that this label is associated with
+        def for
+            assert_exists
+            return @o.htmlFor
+        end
+
+        def text
+            assert_exists
+            return @o.innerText.strip
+        end
+        alias innerText :text
+
+        # 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 <<   "inner text:".ljust(TO_S_SIZE) + self.innerText
+            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=r + label_string_creator
+            return r.join("\n")
+        end
+
+    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::SupportsSubElements#table method
+    #
+    # many of the methods available to this object are inherited from the Element class
+    #
+    class Table < Element
+ 
+        # Returns an initialized instance of the table object to wich anElement belongs
+        #   * ieController  - an instance of an IE object
+        #   * anElement     - a Watir object (TextField, Button, etc.)
+        def Table.create_from_element(ieController,anElement)
+            o = anElement.getOLEObject.parentElement
+            while(o && o.tagName != 'TABLE')
+                o = o.parentElement
+            end
+            return Table.new(ieController,:from_object,o)
+        end
+
+        # Returns an initialized instance of a table object
+        #   * parent      - an instance of an IEController ( or a frame etc )
+        #   * how         - symbol - how we access the table
+        #   * what         - what we use to access the table - id, name index etc 
+        def initialize( parent,  how , what )
+            @ieController = parent
+            @how = how
+            @what = what
+
+            table = nil
+
+	      if(@how != :from_object) then
+               table=get_table
+	      else
+		    table = @what
+	      end
+
+            parent.log "table - #{@what}, #{@how} Not found " if table ==  nil
+            @o = table
+            super( @o )
+        end
+
+        # --- 
+        # BUG: should be private
+        # +++
+        # this method finds the specified table on the page
+        def get_table
+                allTables = @ieController.document.getElementsByTagName("TABLE")
+                @ieController.log "There are #{ allTables.length } tables"
+                tableIndex = 1
+                table=nil
+                allTables.each do |t|
+                    next  unless table == nil
+                    case @how
+                        when :id
+                        if @what.matches( t.invoke("id").to_s )
+                            table = t
+                        end
+                        when :index
+                        if tableIndex == @what.to_i
+                            table = t
+                        end
+                    end
+                    tableIndex = tableIndex + 1
+                end
+            return table
+        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 flsh method wont work
+        def highLight(setOrClear )
+
+           if setOrClear == :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 ppulate 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=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(@ieController ,:direct, row(i) )    }
+        end
+ 
+        # Returns a row in the table
+        #   * index         - the index of the row
+        def [](index)
+            raise UnknownTableException ,  "Unable to locate a table using #{@how} and #{@what} " if @o == nil
+            return  TableRow.new(@ieController ,:direct, row(index) )
+        end
+
+        # This method returns the number of rows in the table.
+        # Raises an UnknownTableException if the table doesnt exist.
+        def row_count 
+            raise UnknownTableException ,  "Unable to locate a table using #{@how} and #{@what} " if @o == nil
+            #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 UnknownTableException if the table doesn't exist.
+        #   * index         - the index of the row
+        def column_count(index=1) 
+            raise UnknownTableException ,  "Unable to locate a table using #{@how} and #{@what} " if @o == nil
+            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 UnknownTableException if the table doesn't exist.
+        def to_a
+            raise UnknownTableException ,  "Unable to locate a table using #{@how} and #{@what} " if @o == nil
+            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
+
+        def body( how , what )
+            return TableBody.new( @ieController, how, what , self)
+        end
+
+        def bodies
+            return TableBodies.new(@ieController,  :direct , @o)
+        end
+   
+        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 UnknownTableException 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 UnknownTableException 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(ieController, how, what )
+            @ieController = ieController
+            @o= nil
+            if how == :direct
+                @o = what     # in this case, @o is the parent table
+            end
+        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( @ieController , :direct , @o.tBodies[(n-1).to_s] )
+        end
+
+        def get_IE_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
+            0.upto( @o.tBodies.length-1 ) { |i | yield TableBody.new( @ieController , :direct , @o.tBodies[i.to_s] )   }
+        end
+
+    end
+
+
+    # this class is a table body
+    class TableBody<Element
+        def initialize(ieController, how, what, parent_table=nil )
+            @ieController = ieController
+            @o= nil
+            if how == :direct
+                @o = what     # in this case, @o is the table body
+            elsif how == :index
+                @o=parent_table.bodies.get_IE_table_body_at_index( what )
+            end
+            @rows = []
+            update_rows
+            super(@o)
+        end
+ 
+        # This method updates the internal representation of the table. It can be used on dynamic tables to update the watir representation 
+        # after the table has changed
+        # BUG: Remove
+        def update_rows
+            if @o
+                @o.rows.each do |oo|
+                    @rows << TableRow.new(@ieController, :direct, oo)
+                end
+            end
+        end
+
+        # returns the specified row as a TableRow object
+        def []n
+            assert_exists
+            return TableRow.new( @ieController , :direct , @rows[n-1] )
+        end
+
+        # iterates through all the rows in the table body
+        def each
+            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
+
+        # Returns an initialized instance of a table row          
+        #   * o  - the object contained in the row
+        #   * ieController  - 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 :direct then what is a Internet Explorer Raw Row 
+        def initialize(ieController , how, what)
+            @ieController = ieController
+            @how = how   
+            @what = what   
+            @o=nil
+            if how == :direct
+                @o = what
+            else
+                @o = ieController.getTablePart( "TR" , how , what )   
+            end
+            update_row_cells
+            super( @o )   
+        end
+   
+
+        # this method updates the internal list of cells. 
+        def update_row_cells
+            if @o   # cant call the assert_exists here, as an exists? method call will fail
+                @cells=[]
+                @o.cells.each do |oo|
+                    @cells << TableCell.new(@ieController, :direct, oo)
+                end
+            end
+        end
+
+        # this method iterates through each of the cells in the row. Yields a TableCell object
+        def each
+            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
+             @cells.length
+        end
+    end
+ 
+    # this class is a table cell - when called via the Table object
+    class TableCell <Element
+        include Watir::Exception
+        include SupportsSubElements 
+
+        attr_reader :typingspeed      
+        attr_reader :activeObjectHighLightColor 
+
+        # Returns an initialized instance of a table cell          
+        #   * ieController  - an  IE object       
+        #   * how         - symbol - how we access the cell        
+        #   * what         - what we use to access the cell - id, name index etc
+        def initialize( ieController,  how , what )   
+            @ieController = ieController    
+            #puts "How = #{how}"
+             if how == :direct
+                 @o = what
+                 #puts "@o.class=#{@o.class}"
+             else
+                 @o = ieController.getTablePart( "TD" , how , what )   
+             end
+             super( @o )   
+             @how = how   
+             @what = what   
+             @typingspeed = @ieController.typingspeed      
+             @activeObjectHighLightColor = @ieController.activeObjectHighLightColor      
+         end 
+
+        def getContainerContents
+            return @o.all
+        end
+        private :getContainerContents
+
+        def getContainer
+            return @o
+        end
+
+        def document
+            return @o  
+        end
+
+        # returns the contents of the cell as text
+        def text
+             raise UnknownObjectException , "Unable to locate table cell with #{@how} of #{@what}" if @o == nil
+             return @o.innerText.strip 
+        end
+        alias to_s text
+ 
+        def colspan
+            @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::SupportsSubElements#image method
+    #
+    # many of the methods available to this object are inherited from the Element class
+    #
+    class Image < Element
+        
+        # Returns an initialized instance of a image  object
+        #   * ieController  - an instance of an IEController
+        #   * how         - symbol - how we access the image
+        #   * what         - what we use to access the image, name, src, index, id or alt
+        def initialize( ieController,  how , what )
+            @ieController = ieController
+            @how = how
+            @what = what
+            @o = @ieController.getImage(@how, @what)
+            super( @o )
+        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=r + image_string_creator
+            return r.join("\n")
+        end
+
+        def_wrap :src
+
+        # 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 alt text of the image
+        def alt
+            assert_exists
+            return @o.invoke("alt").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
+
+        # returns the type of the object - 'image'
+        def type 
+            assert_exists
+            return "image"
+        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?
+            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)
+        #  * setOrClear   - symbol - :set to set the border, :clear to remove it
+        def highLight( setOrClear )
+            if setOrClear == :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
+            @ieController.goto(src)
+            begin
+                thrd = fill_save_image_dialog(path)
+                @ieController.document.execCommand("SaveAs")
+                thrd.join(5)
+            ensure
+                @ieController.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::SupportsSubElements#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
+        #   * ieController  - an instance of an IEController
+        #   * how         - symbol - how we access the link
+        #   * what         - what we use to access the link, text, url, index etc
+        def initialize( ieController,  how , what )
+            @ieController = ieController
+            @how = how
+            @what = what
+            begin
+                @o = @ieController.getLink( @how, @what )
+            rescue UnknownObjectException
+                @o = nil
+            end
+            super( @o )
+        end
+
+        # returns 'link' as the object type
+        def type
+            assert_exists
+            return "link"
+        end
+
+        # returns the text displayed by the link
+        def innerText
+            assert_exists
+            return @o.innerText.strip
+        end
+        alias text innerText
+
+        # returns the url the link points to
+        def_wrap :href
+
+        # if an image is used as part of the link, this will return true      
+        def link_has_image
+            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
+            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.innerText
+            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
+    
+    # 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::SupportsSubElements#select_list method
+    #
+    # many of the methods available to this object are inherited from the Element class
+    #
+    class SelectList < Element
+        # returns an initialized instance of a SelectList object
+        #   * ieController  - an instance of an IEController
+        #   * how          - symbol - how we access the select box
+        #   * what         - what we use to access the select box, name, id etc
+        def initialize( ieController,  how , what )
+            @ieController = ieController
+            @how = how
+            @what = what
+            @o = @ieController.getObject(@how, @what, ["select-one", "select-multiple"])
+            super( @o )
+        end
+        
+        attr :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
+            @ieController.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, reg exp or an array of string and reg exps
+        def select( item )
+            select_item_in_select_list( :text , item )
+        end
+
+        # 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
+            @ieController.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")
+                        @ieController.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()
+            assert_exists
+            @ieController.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 = []
+            @ieController.log "There are #{@o.length} items"
+            @o.each do |thisItem|
+                if thisItem.selected
+                    @ieController.log "Item ( #{thisItem.text} ) is selected"
+                    returnArray << thisItem.text 
+                end
+            end
+            return returnArray 
+        end
+        
+        def option (attribute, value)
+            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::SupportsSubElements#button method
+    #
+    # most of the methods available to Button objects are inherited from the Element class
+    #
+    class Button < Element
+        def initialize( ieController,  how , what )
+            @ieController = ieController
+            @how = how
+            @what = what
+            if(how == :from_object) then
+                @o = what
+            else
+                @o = @ieController.getObject( @how, @what , object_types)
+            end              
+            super( @o )
+        end
+
+        def object_types
+            return ["button" , "submit" , "image" , "reset" ] 
+        end
+
+    end
+
+    
+    # File dialog
+    class FileField < Element
+        # Create an instance of the file object
+        def initialize( ieController,  how , what )
+            @ieController = ieController
+            @how = how
+            @what = what
+            super( @o )
+            @o = @ieController.getObject( @how, @what , ["file"] )
+
+        end
+
+        def set(setPath)
+            assert_exists	        
+            Thread.new {
+                clicker = WinClicker.new
+                clicker.setFileRequesterFileName_newProcess(setPath)
+            }
+            # may need to experiment with this value.  if it takes longer than this
+            # to open the new external Ruby process, the current thread may become
+            # blocked by the file chooser.
+            sleep(1)	
+            self.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::SupportsSubElements#checkbox or Watir::SupportsSubElements#radio methods
+    #
+    # most of the methods available to this element are inherited from the Element class
+    #
+    class RadioCheckCommon < Element
+
+        def initialize( ieController,  how , what , type, value=nil )
+            @ieController = ieController
+            @how = how
+            @what = what
+            @type = type
+            @value = value
+            @o = @ieController.getObject(@how, @what, @type, @value)
+            super( @o )
+        end
+
+        # 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_exists
+            assert_enabled
+            highLight( :set)
+            set_clear_item( false )
+            highLight( :clear )
+        end
+        
+        # This method sets the radio list item or check box.
+        #   Raises UnknownObjectException  if its unable to locate an object
+        #         ObjectDisabledException  if the object is disabled 
+        def set
+            assert_exists
+            assert_enabled
+            highLight( :set)
+            set_clear_item( true )
+            highLight( :clear )
+        end
+    
+        # This method is the common code for setting or clearing checkboxes and radio. A user would normalyy not access this, but use Checkbox#set etc
+        def set_clear_item( set )
+            @o.checked = set
+            @o.fireEvent("onClick")
+            @ieController.wait
+        end
+        private :set_clear_item
+    
+    end
+
+    #--
+    #  this class is only used to change the name of the class that radio buttons use to something more meaningful
+    #  and to make 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 
+
+        # This method, with no arguments supplied, sets the check box.
+        # If the optional set_or_clear is supplied, the checkbox is set, when its true and cleared when its false
+        #   Raises UnknownObjectException  if its unable to locate an object
+        #         ObjectDisabledException  if the object is disabled 
+        def set( set_or_clear=true )
+            assert_exists
+            assert_enabled
+            highLight( :set)
+
+            if set_or_clear == true
+                if @o.checked == false
+                    set_clear_item( true )
+                end
+            else
+                self.clear
+            end
+            highLight( :clear )
+        end
+        
+        # This method clears a check box. 
+        # 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_exists
+            assert_enabled
+            highLight( :set)
+            if @o.checked == true
+                set_clear_item( false )
+            end
+            highLight( :clear)
+        end
+        
+
+    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::SupportsSubElements#text_field method
+    #
+    # most of the methods available to this element are inherited from the Element class
+    #
+    class TextField < Element
+        
+        def initialize( ieController,  how , what )
+            @ieController = ieController
+            @how = how
+            @what = what
+
+	      if(how != :from_object) then
+                @o = @ieController.getObject(@how, @what, supported_types)
+	      else
+		    @o = what
+	      end
+            super( @o )
+        end
+
+        def supported_types
+            return ["text" , "password", "textarea"] 
+        end
+        private :supported_types
+
+        def size
+            assert_exists
+            begin 
+                s=@o.size
+            rescue
+                # TextArea does not support size
+                s=""
+            end
+            return s
+
+        end
+
+        def maxLength
+            assert_exists
+            begin 
+                s=@o.maxlength
+            rescue
+                # TextArea does not support maxLength
+                s=""
+            end
+            return s
+        end
+
+        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
+
+         def to_s
+            assert_exists
+            r = string_creator
+            r=r + text_string_creator
+            return r.join("\n")
+         end
+        
+        # This method returns true or false if the text field is read only.
+        #   Raises  UnknownObjectException if the object can't be found.
+        def readonly?
+            assert_exists
+            return @o.readOnly 
+        end
+        alias readOnly? :readonly?
+
+        def assert_not_readonly
+            raise ObjectReadOnlyException , "Textfield #{@how} and #{@what} is read only"  if self.readonly?
+        end                
+        #--
+        # BUG: rename me
+        #++
+        # This method returns the current contents of the text field as a string.
+        #   Raises  UnknownObjectException if the object can't be found
+        def getContents()
+            assert_exists
+            return self.value
+        end
+        
+        # This method returns true orfalse 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 )
+            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 = @ieController.textField(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_exists
+            assert_enabled
+            assert_not_readonly
+            
+            highLight(:set)
+            
+            @o.scrollIntoView
+            @o.focus
+            @o.select()
+            @o.fireEvent("onSelect")
+            @o.value = ""
+            @o.fireEvent("onKeyPress")
+            @o.fireEvent("onChange")
+            @ieController.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_exists
+            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_exists
+            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
+
+        def fire_key_events
+            @o.fireEvent("onKeyDown")
+            @o.fireEvent("onKeyPress")
+            @o.fireEvent("onKeyUp")
+        end
+        private :fire_key_events
+
+        # 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
+                    value = suppliedValue[0 .. maxLength ]
+                    @ieController.log " Supplied string is #{suppliedValue.length} chars, which exceeds the max length (#{maxLength}) of the field. Using value: #{value}"
+                end
+            rescue
+                # probably a text area - so it doesnt have a max Length
+                maxLength = -1
+            end
+            for i in 0 .. value.length-1   
+                sleep @ieController.typingspeed   # typing speed
+                c = value[i,1]
+                #@ieController.log  " adding c.chr " + c  #.chr.to_s
+                @o.value = @o.value.to_s + c   #c.chr
+                fire_key_events
+            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::SupportsSubElements#hidden method
+    #
+    # most of the methods available to this element are inherited from the Element class
+    #
+    class Hidden < TextField 
+
+        def initialize( ieController,  how , what )
+            super
+        end
+
+        def supported_types
+            return ["hidden"]
+        end
+       
+
+        # 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
+            # do nothing!
+        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
+            @ieController.getContainer.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::SupportsSubElements#buttons method
+    #
+    class Buttons < ElementCollections
+        def element_class; Button; end
+        def length
+            get_length_of_input_objects(["button", "submit", "image"])
+        end
+
+        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
+    # it would normally only be accessed by the Watir::SupportsSubElements#file_fields method
+    #
+    class FileFields< ElementCollections
+        def element_class; FileField; end
+        def length
+            get_length_of_input_objects(["file"])
+        end
+
+        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::SupportsSubElements#checkboxes method
+    #
+    class CheckBoxes < ElementCollections
+        def element_class; CheckBox; end  
+        def length
+            get_length_of_input_objects("checkbox")
+        end
+        # this method creates an object of the correct type that the iterators use
+        private
+        def iterator_object(i)
+            @ieController.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::SupportsSubElements#radios method
+    #
+    class Radios < ElementCollections
+        def element_class; Radio; end
+        def length
+            get_length_of_input_objects("radio")
+        end
+        # this method creates an object of the correct type that the iterators use
+        private
+        def iterator_object(i)
+            @ieController.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::SupportsSubElements#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::SupportsSubElements#links method
+    #
+    class Links < ElementCollections
+        include CommonCollection
+        def element_class; Link; end    
+        def element_tag; 'A'; end
+
+        def set_show_items
+            super
+            @show_attributes.add("href", 60)
+            @show_attributes.add("innerText" , 60)
+        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::SupportsSubElements#images method
+    #
+    class Images < ElementCollections
+        def element_class; Image; end 
+        def length
+            @ieController.document.images.length
+        end
+
+        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::SupportsSubElements#text_fields method
+    #
+    class TextFields < ElementCollections
+        def element_class; TextField; end
+        def length
+            # text areas are also included inthe Text_filds, but we need to get them seperately
+            get_length_of_input_objects( ["text" , "password"] ) +
+                @ieController.ie.document.body.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::SupportsSubElements#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::SupportsSubElements#tables method
+    #
+    class Tables < ElementCollections
+        include CommonCollection
+        def element_class; Table; end
+        def element_tag; 'TABLE'; end
+
+        def set_show_items
+            super
+            @show_attributes.delete( "name")
+        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::SupportsSubElements#labels method
+    #
+    class Labels < ElementCollections
+        include CommonCollection
+        def element_class; Label; end
+        def element_tag; 'LABEL'; end
+
+        def set_show_items
+            super
+            @show_attributes.add("htmlFor", 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::SupportsSubElements#ps method
+    #
+    class Ps < ElementCollections
+        include CommonCollection
+        def element_class; P; end
+
+        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::SupportsSubElements#spans method
+    #
+    class Spans < ElementCollections
+        include CommonCollection
+        def element_class; Span; end
+
+        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::SupportsSubElements#divs method
+    #
+    class Divs < ElementCollections
+        include CommonCollection
+        def element_class; Div; end
+
+        def set_show_items
+            super
+            @show_attributes.delete( "name")
+            @show_attributes.add( "className" , 20)
+        end
+
+    end
+
+end
+
+require 'watir/camel_case'