: Watir::Container [Watir API Reference]

area (how, what=nil)

This is the main method for accessing area tags - msdn.microsoft.com/workshop/author/dhtml/reference/objects/area.asp?frame=true

*  how   - symbol - how we access the area
*  what  - string, integer or regular expression - what we are looking for,

Valid values for ‘how’ are listed in the Watir Wiki - wiki.openqa.org/display/WTR/Watir+Methods+Supported+by+HTML+Element

returns a area object

Typical Usage

browser.area(:id, /list/)                 # access the first area that matches list.
browser.area(:index,2)                    # access the second area on the page
browser.area(:title, "A Picture")         # access a area using the tooltip text. See http://msdn.microsoft.com/workshop/author/dhtml/reference/properties/title_1.asp?frame=true

[show source]

# File watir/lib/watir/container.rb, line 549
    def area(how, what=nil)
      return Area.new(self, how, what)
    end

areas ()

this is the main method for accessing the areas iterator.

Returns a areas object

Typical usage:

browser.areas.each { |s| puts s.to_s }            # iterate through all the areas on the page
browser.areas[1].to_s                             # goto the first area on the page
browser.areas.length                              # show how many areas are on the page.

[show source]

# File watir/lib/watir/container.rb, line 563
    def areas
      return Areas.new(self)
    end

button (how, what=nil)

This is the main method for accessing a button. Often declared as an <input type = submit> tag.

*  how   - symbol - how we access the button, :index, :id, :name etc
*  what  - string, integer or regular expression - what we are looking for,

Valid values for ‘how’ are listed in the Watir Wiki - wiki.openqa.org/display/WTR/Watir+Methods+Supported+by+HTML+Element

Returns a Button object.

Typical usage

browser.button(:id,    'b_1')                             # access the button with an ID of b_1
browser.button(:name,  'verify_data')                     # access the button with a name of verify_data
browser.button(:value, 'Login')                           # access the button with a value (the text displayed on the button) of Login
browser.button(:caption, 'Login')                         # same as above
browser.button(:value, /Log/)                             # access the button that has text matching /Log/
browser.button(:index, 2)                                 # access the second button on the page (1 based, so the first button is accessed with :index,1)
browser.button(:class, 'my_custom_button_class')          # access the button with a class of my_custom_button_class
browser.button(:xpath, "//input[@value='Click Me']/")     # access the button with a value of Click Me

Accessing a Button nested within another element

browser.div(:class, 'xyz').button(:index, 2)              # access a div of class xyz, and the 2nd button within that div

If only a single parameter is supplied, then :value is used

browser.button('Click Me')                                # access the button with a value of Click Me

[show source]

# File watir/lib/watir/container.rb, line 215
    def button(how, what=nil)
      how, what = process_default :value, how, what
      Button.new(self, how, what)
    end

buttons ()

this is the main method for accessing the buttons iterator. It returns a Buttons object

Typical usage:

browser.buttons.each { |b| puts b.to_s }                   # iterate through all the buttons on the page
browser.buttons[1].to_s                                    # goto the first button on the page
browser.buttons.length                                     # show how many buttons are on the page.

[show source]

# File watir/lib/watir/container.rb, line 227
    def buttons
      Buttons.new(self)
    end

cell (how, what=nil)

this method accesses a table cell. how - symbol - how we access the cell, valid values are

:id       - find the table cell with given id.
:xpath    - find the table cell using xpath query.

returns a TableCell Object

[show source]

# File watir/lib/watir/container.rb, line 154
    def cell(how, what=nil)
      TableCell.new(self, how, what)
    end

cells ()

[show source]

# File watir/lib/watir/container.rb, line 157
    def cells
      TableCells.new(self)
    end

checkbox (how, what=nil, value=nil)

This is the main method for accessing a check box. Usually an <input type = checkbox> HTML tag.

*  how   - symbol - how we access the check box - :index, :id, :name etc
*  what  - string, integer or regular expression - what we are looking for,
*  value - string - when there are multiple objects with different value attributes, this can be used to find the correct object

Valid values for ‘how’ are listed in the Watir Wiki - wiki.openqa.org/display/WTR/Watir+Methods+Supported+by+HTML+Element

returns a CheckBox object

Typical usage

browser.checkbox(:id, 'send_email')                    # access the check box with an id of send_mail
browser.checkbox(:name, 'send_copy')                   # access the check box with a name of send_copy
browser.checkbox(:name, /n_/)                          # access the first check box whose name matches n_
browser.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:

browser.checkbox(:id, 'day_to_send', 'monday')         # access the check box with an id of day_to_send and a value of monday
browser.checkbox(:name,'email_frequency', 'weekly')    # access the check box with a name of email_frequency and a value of 'weekly'
browser.checkbox(:xpath, "//input[@name='email_frequency' and @value='daily']/")     # access the checkbox with a name of email_frequency and a value of 'daily'

[show source]

# File watir/lib/watir/container.rb, line 380
    def checkbox(how, what=nil, value=nil) # should be "check_box" ?
      CheckBox.new(self, how, what, value)
    end

checkboxes ()

this is the method for accessing the check boxes iterator. Returns a CheckBoxes object

Typical usage:

browser.checkboxes.each { |c| puts c.to_s }             # iterate through all the check boxes on the page
browser.checkboxes[1].to_s                              # goto the first check box on the page
browser.checkboxes.length                               # show how many check boxes are on the page.

[show source]

# File watir/lib/watir/container.rb, line 391
    def checkboxes
      CheckBoxes.new(self)
    end

dds ()

this is the main method for accessing the dds iterator. Returns a Dds collection

Typical usage:

browser.dds.each { |d| puts d.to_s }            # iterate through all the dds on the page
browser.dds[1].to_s                             # goto the first dd on the page
browser.dds.length                              # show how many dds are on the page.

[show source]

# File watir/lib/watir/container.rb, line 638
    def dds
      Dds.new(self)
    end

divs ()

this is the main method for accessing the divs iterator. Returns a Divs collection

Typical usage:

browser.divs.each { |d| puts d.to_s }            # iterate through all the divs on the page
browser.divs[1].to_s                             # goto the first div on the page
browser.divs.length                              # show how many divs are on the page.

[show source]

# File watir/lib/watir/container.rb, line 614
    def divs
      Divs.new(self)
    end

dls ()

this is the main method for accessing the dls iterator. Returns a Dls collection

Typical usage:

browser.dls.each { |d| puts d.to_s }            # iterate through all the dls on the page
browser.dls[1].to_s                             # goto the first dl on the page
browser.dls.length                              # show how many dls are on the page.

[show source]

# File watir/lib/watir/container.rb, line 626
    def dls
      Dls.new(self)
    end

dts ()

this is the main method for accessing the dts iterator. Returns a Dts collection

Typical usage:

browser.dts.each { |d| puts d.to_s }            # iterate through all the dts on the page
browser.dts[1].to_s                             # goto the first dt on the page
browser.dts.length                              # show how many dts are on the page.

[show source]

# File watir/lib/watir/container.rb, line 650
    def dts
      Dts.new(self)
    end

ems ()

this is the main method for accessing the ems iterator. Returns a Ems collection

Typical usage:

browser.ems.each { |d| puts d.to_s }            # iterate through all the ems on the page
browser.ems[1].to_s                             # goto the first em on the page
browser.ems.length                              # show how many ems are on the page.

[show source]

# File watir/lib/watir/container.rb, line 662
    def ems
      Ems.new(self)
    end

file_field (how, what=nil)

This is the main method for accessing a file field. Usually an <input type = file> HTML tag.

*  how   - symbol - how we access the field, valid values are
  :index      - find the file field using index
  :id         - find the file field using id attribute
  :name       - find the file field using name attribute
  :xpath      - find the file field using xpath query
*  what  - string, integer, regular expression, or xpath query - what we are looking for,

returns a FileField object

Typical Usage

browser.file_field(:id,   'up_1')                     # access the file upload field with an ID of up_1
browser.file_field(:name, 'upload')                   # access the file upload field with a name of upload
browser.file_field(:index, 2)                         # access the second file upload on the page (1 based, so the first field is accessed with :index,1)

[show source]

# File watir/lib/watir/container.rb, line 247
    def file_field(how, what=nil)
      FileField.new(self, how, what)
    end

file_fields ()

this is the main method for accessing the file_fields iterator. It returns a FileFields object

Typical usage:

browser.file_fields.each { |f| puts f.to_s }            # iterate through all the file fields on the page
browser.file_fields[1].to_s                             # goto the first file field on the page
browser.file_fields.length                              # show how many file fields are on the page.

[show source]

# File watir/lib/watir/container.rb, line 258
    def file_fields
      FileFields.new(self)
    end

form (how, what=nil)

this method is used to access a form. available ways of accessing it are, :index, :name, :id, :method, :action, :xpath

* how    - symbol - What mecahnism we use to find the form, one of
               the above. NOTE if what is not supplied this parameter is the NAME of the form
* what   - String - the text associated with the symbol

Valid values for ‘how’ are listed in the Watir Wiki - wiki.openqa.org/display/WTR/Watir+Methods+Supported+by+HTML+Element

returns a Form object

[show source]

# File watir/lib/watir/container.rb, line 116
    def form(how, what=nil)
      how, what = process_default :name, how, what
      Form.new(self, how, what)
    end

forms ()

[show source]

# File watir/lib/watir/form.rb, line 167
    def forms
      Forms.new(self)
    end

frame (how, what=nil)

this method is the main way of accessing a frame

*  how   - how the frame is accessed. This can also just be the name of the frame.
*  what  - what we want to access.

Valid values for ‘how’ are listed in the Watir Wiki - wiki.openqa.org/display/WTR/Watir+Methods+Supported+by+HTML+Element

returns a Frame object

Typical usage:

browser.frame(:index, 1)
browser.frame(:name, 'main_frame')
browser.frame('main_frame')        # in this case, just a name is supplied

[show source]

# File watir/lib/watir/container.rb, line 102
    def frame(how, what=nil)
      how, what = process_default :name, how, what
      Frame.new(self, how, what)
    end

hidden (how, what=nil)

This is the main method for accessing a hidden field. Usually an <input type = hidden> HTML tag

*  how   - symbol - how we access the hidden field, :index, :id, :name etc
*  what  - string, integer or regular expression - what we are looking for,

Valid values for ‘how’ are listed in the Watir Wiki - wiki.openqa.org/display/WTR/Watir+Methods+Supported+by+HTML+Element

returns a Hidden object

Typical usage

browser.hidden(:id, 'session_id')                 # access the hidden field with an ID of session_id
browser.hidden(:name, 'temp_value')               # access the hidden field with a name of temp_value
browser.hidden(:index, 2)                         # access the second hidden field on the page (1 based, so the first field is accessed with :index,1)
browser.hidden(:xpath, "//input[@type='hidden' and @id='session_value']/")    # access the hidden field with an ID of session_id

[show source]

# File watir/lib/watir/container.rb, line 307
    def hidden(how, what=nil)
      Hidden.new(self, how, what)
    end

hiddens ()

this is the method for accessing the hiddens iterator. It returns a Hiddens object

Typical usage:

browser.hiddens.each { |t| puts t.to_s }            # iterate through all the hidden fields on the page
browser.hiddens[1].to_s                             # goto the first hidden field on the page
browser.hiddens.length                              # show how many hidden fields are on the page.

[show source]

# File watir/lib/watir/container.rb, line 318
    def hiddens
      Hiddens.new(self)
    end

image (how, what=nil)

This is the main method for accessing images - normally an <img src="image.gif"> HTML tag.

*  how   - symbol - how we access the image, :index, :id, :name, :src, :title or :alt are supported
*  what  - string, integer or regular expression - what we are looking for,

Valid values for ‘how’ are listed in the Watir Wiki - wiki.openqa.org/display/WTR/Watir+Methods+Supported+by+HTML+Element

returns an Image object

Typical Usage

browser.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, browser.image(:src, 'http://myserver.com/my_path/my_image.jpg')
browser.image(:index,2)                  # access the second image on the page
browser.image(:alt, "A Picture")         # access an image using the alt text
browser.image(:xpath, "//img[@alt='A Picture']/")    # access an image using the alt text

[show source]

# File watir/lib/watir/container.rb, line 583
    def image(how, what=nil)
      Image.new(self, how, what)
    end

images ()

This is the main method for accessing the images collection. Returns an Images object

Typical usage:

browser.images.each { |i| puts i.to_s }            # iterate through all the images on the page
browser.images[1].to_s                             # goto the first image on the page
browser.images.length                              # show how many images are on the page.

[show source]

# File watir/lib/watir/container.rb, line 595
    def images
      Images.new(self)
    end

labels ()

this is the main method for accessing the labels iterator. It returns a Labels object

Returns a Labels object

Typical usage:

browser.labels.each { |l| puts l.to_s }            # iterate through all the labels on the page
browser.labels[1].to_s                             # goto the first label on the page
browser.labels.length                              # show how many labels are on the page.

[show source]

# File watir/lib/watir/container.rb, line 733
    def labels
      Labels.new(self)
    end

link (how, what=nil)

This is the main method for accessing a link.

*  how   - symbol - how we access the link, :index, :id, :name, :title, :text, :url
*  what  - string, integer or regular expression - what we are looking for,

Valid values for ‘how’ are listed in the Watir Wiki - wiki.openqa.org/display/WTR/Watir+Methods+Supported+by+HTML+Element

returns a Link object

Typical Usage

browser.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, browser.link(:url, 'http://myserver.com/my_path/login.asp')
browser.link(:index,2)                   # access the second link on the page
browser.link(:title, "Picture")         # access a link using the tool tip
browser.link(:text, 'Click Me')          # access the link that has Click Me as its text
browser.link(:xpath, "//a[contains(.,'Click Me')]/")      # access the link with Click Me as its text

[show source]

# File watir/lib/watir/container.rb, line 454
    def link(how, what=nil)
      Link.new(self, how, what)
    end

links ()

This is the main method for accessing the links collection. Returns a Links object

Typical usage:

browser.links.each { |l| puts l.to_s }            # iterate through all the links on the page
browser.links[1].to_s                             # goto the first link on the page
browser.links.length                              # show how many links are on the page.

[show source]

# File watir/lib/watir/container.rb, line 466
    def links
      Links.new(self)
    end

lis ()

this is the main method for accessing the lis iterator.

Returns a lis object

Typical usage:

browser.lis.each { |s| puts s.to_s }            # iterate through all the lis on the page
browser.lis[1].to_s                             # goto the first li on the page
browser.lis.length                              # show how many lis are on the page.

[show source]

# File watir/lib/watir/container.rb, line 498
    def lis
      return Lis.new(self)
    end

locate_input_element (how, what, types, value=nil)

Returns the specified ole object for input elements on a web page.

This method is used internally by Watir and should not be used externally. It cannot be marked as private because of the way mixins and inheritance work in watir

* how - symbol - the way we look for the object. Supported values are
               - :name
               - :id
               - :index
               - :value etc
* what  - string that we are looking for, ex. the name, or id tag attribute or index of the object we are looking for.
* types - what object types we will look at.
* value - used for objects that have one name, but many values. ex. radio lists and checkboxes

[show source]

# File watir/lib/watir/container.rb, line 792
    def locate_input_element(how, what, types, value=nil)
      case how
      when :xpath
        return element_by_xpath(what)
      when :ole_object
        return what
      end
      # else:
      
      locator = InputElementLocator.new self, types
      locator.specifier = [how, what, value]
      locator.document = document
      return locator.element if locator.fast_locate
      # todo: restrict search to elements.getElementsByTag('INPUT'); faster
      locator.elements = ole_inner_elements if locator.elements.nil?
      locator.locate
    end

locate_tagged_element (tag, how, what)

returns the ole object for the specified element

[show source]

# File watir/lib/watir/container.rb, line 811
    def locate_tagged_element(tag, how, what)
      locator = TaggedElementLocator.new(self, tag)
      locator.set_specifier(how, what)
      locator.locate
    end

log (what)

Write the specified string to the log.

[show source]

# File watir/lib/watir/container.rb, line 42
    def log(what)
      @container.logger.debug(what) if @logger
    end

map (how, what=nil)

This is the main method for accessing map tags - msdn.microsoft.com/workshop/author/dhtml/reference/objects/map.asp?frame=true

*  how   - symbol - how we access the map,
*  what  - string, integer or regular expression - what we are looking for,

Valid values for ‘how’ are listed in the Watir Wiki - wiki.openqa.org/display/WTR/Watir+Methods+Supported+by+HTML+Element

returns a map object

Typical Usage

browser.map(:id, /list/)                 # access the first map that matches list.
browser.map(:index,2)                    # access the second map on the page
browser.map(:title, "A Picture")         # access a map using the tooltip text. See http://msdn.microsoft.com/workshop/author/dhtml/reference/properties/title_1.asp?frame=true

[show source]

# File watir/lib/watir/container.rb, line 517
    def map(how, what=nil)
      return Map.new(self, how, what)
    end

maps ()

this is the main method for accessing the maps iterator.

Returns a maps object

Typical usage:

browser.maps.each { |s| puts s.to_s }            # iterate through all the maps on the page
browser.maps[1].to_s                             # goto the first map on the page
browser.maps.length                              # show how many maps are on the page.

[show source]

# File watir/lib/watir/container.rb, line 531
    def maps
      return Maps.new(self)
    end

modal_dialog (how=nil, what=nil)

Access a modal web dialog, which is a PageContainer, like IE or Frame. Returns a ModalDialog object.

Typical Usage

browser.modal_dialog                  # access the modal dialog of ie
browser.modal_dialog(:title, 'Title') # access the modal dialog by title
browser.modal_dialog.modal_dialog     # access a modal dialog's modal dialog XXX untested!

This method will not work when Watir/Ruby is run under a service (instead of a user). Note: unlike Watir.attach, this returns before the page is assured to have loaded.

[show source]

# File watir/lib/watir/container.rb, line 187
    def modal_dialog(how=nil, what=nil)
      ModalDialog.new(self, how, what)
    end

popup (

This is the main method for accessing JavaScript popups. returns a PopUp object

[show source]

# File watir/lib/watir/container.rb, line 601
    def popup         # BUG this should not be on the container object!
      PopUp.new(self)
    end

pres ()

this is the main method for accessing the ps iterator.

Returns a Pres object

Typical usage:

browser.pres.each { |pre| puts pre.to_s }        # iterate through all the pre tags on the page
browser.pres[1].to_s                             # goto the first pre tag on the page
browser.pres.length                              # show how many pre tags are on the page.

[show source]

# File watir/lib/watir/container.rb, line 719
    def pres
      Pres.new(self)
    end

ps ()

this is the main method for accessing the ps iterator.

Returns a Ps object

Typical usage:

browser.ps.each { |p| puts p.to_s }            # iterate through all the p tags on the page
browser.ps[1].to_s                             # goto the first p tag on the page
browser.ps.length                              # show how many p tags are on the page.

[show source]

# File watir/lib/watir/container.rb, line 705
    def ps
      Ps.new(self)
    end

radio (how, what=nil, value=nil)

This is the main method for accessing a radio button. Usually an <input type = radio> HTML tag.

*  how   - symbol - how we access the radio button, :index, :id, :name etc
*  what  - string, integer or regular expression - what we are looking for,
*  value - string - when  there are multiple objects with different value attributes, this can be used to find the correct object

Valid values for ‘how’ are listed in the Watir Wiki - wiki.openqa.org/display/WTR/Watir+Methods+Supported+by+HTML+Element

returns a Radio object

Typical usage

browser.radio(:id, 'send_email')                   # access the radio button with an id of currency
browser.radio(:name, 'send_copy')                  # access the radio button with a name of country
browser.radio(:name, /n_/)                        # access the first radio button whose name matches n_
browser.radio(:index, 2)                           # access the second radio button on the page (1 based, so the first field is accessed with :index,1)

In many instances, radio buttons on an html page have the same name, but are identified by different values. An example is shown next.

<input type="radio" name="email_frequency" value="daily">Daily Email</input>
<input type="radio" name="email_frequency" value="weekly">Weekly Email</input>
<input type="radio" name="email_frequency" value="monthly">Monthly Email</input>

Watir can access these using the following:

browser.radio(:id, 'day_to_send', 'monday')         # access the radio button with an id of day_to_send and a value of monday
browser.radio(:name,'email_frequency', 'weekly')     # access the radio button with a name of email_frequency and a value of 'weekly'
browser.radio(:xpath, "//input[@name='email_frequency' and @value='daily']/")     # access the radio button with a name of email_frequency and a value of 'daily'

[show source]

# File watir/lib/watir/container.rb, line 422
    def radio(how, what=nil, value=nil)
      Radio.new(self, how, what, value)
    end

radios ()

This is the method for accessing the radio buttons iterator. Returns a Radios object

Typical usage:

browser.radios.each { |r| puts r.to_s }            # iterate through all the radio buttons on the page
browser.radios[1].to_s                             # goto the first radio button on the page
browser.radios.length                              # show how many radio buttons are on the page.

[show source]

# File watir/lib/watir/container.rb, line 434
    def radios
      Radios.new(self)
    end

row (how, what=nil)

this method accesses a table row. how - symbol - how we access the row, valid values are

:id       - find the table row with given id.
:xpath    - find the table row using xpath query.

returns a TableRow object

[show source]

# File watir/lib/watir/container.rb, line 167
    def row(how, what=nil)
      TableRow.new(self, how, what)
    end

rows ()

[show source]

# File watir/lib/watir/container.rb, line 170
    def rows
      TableRows.new(self)
    end

select_list (how, what=nil)

This is the main method for accessing a selection list. Usually a <select> HTML tag.

*  how   - symbol - how we access the selection list, :index, :id, :name etc
*  what  - string, integer or regular expression - what we are looking for,

Valid values for ‘how’ are listed in the Watir Wiki - wiki.openqa.org/display/WTR/Watir+Methods+Supported+by+HTML+Element

returns a SelectList object

Typical usage

browser.select_list(:id, 'currency')                   # access the select box with an id of currency
browser.select_list(:name, 'country')                  # access the select box with a name of country
browser.select_list(:name, /n_/)                       # access the first select box whose name matches n_
browser.select_list(:index, 2)                         # access the second select box on the page (1 based, so the first field is accessed with :index,1)
browser.select(:xpath, "//select[@id='currency']/")    # access the select box with an id of currency

[show source]

# File watir/lib/watir/container.rb, line 337
    def select_list(how, what=nil)
      SelectList.new(self, how, what)
    end

select_lists ()

this is the method for accessing the select lists iterator. Returns a SelectLists object

Typical usage:

browser.select_lists.each { |s| puts s.to_s }            # iterate through all the select boxes on the page
browser.select_lists[1].to_s                             # goto the first select boxes on the page
browser.select_lists.length                              # show how many select boxes are on the page.

[show source]

# File watir/lib/watir/container.rb, line 348
    def select_lists
      SelectLists.new(self)
    end

show_all_objects ()

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.

[show source]

# File watir/lib/watir/container.rb, line 752
    def show_all_objects
      puts "-----------Objects in page -------------"
      doc = document
      s = ""
      props = ["name", "id", "value", "alt", "src"]
      doc.all.each do |n|
        begin
          s += n.invoke("type").to_s.ljust(16)
        rescue
          next
        end
        props.each do |prop|
          begin
            p = n.invoke(prop)
            s += "  " + "#{prop}=#{p}".to_s.ljust(18)
          rescue
            # this object probably doesnt have this property
          end
        end
        s += "\n"
      end
      puts s
    end

spans ()

this is the main method for accessing the spans iterator.

Returns a Spans object

Typical usage:

browser.spans.each { |s| puts s.to_s }            # iterate through all the spans on the page
browser.spans[1].to_s                             # goto the first span on the page
browser.spans.length                              # show how many spans are on the page.

[show source]

# File watir/lib/watir/container.rb, line 676
    def spans
      Spans.new(self)
    end

strongs ()

this is the main method for accessing the Strongs iterator.

Returns a Strongs object

Typical usage:

browser.strongs.each { |s| puts s.to_s }            # iterate through all the strongs on the page
browser.strongs[1].to_s                             # goto the first strong on the page
browser.strongs.length                              # show how many strongs are on the page.

[show source]

# File watir/lib/watir/container.rb, line 690
    def strongs
      return Strongs.new(self)
    end

table (how, what=nil)

This method is used to get a table from the page. :index (1 based counting) and :id are supported.

NOTE :name is not supported, as the table tag does not have a name attribute. It is not part of the DOM.

:index can be used when there are multiple tables on a page. :xpath can be used to select table using XPath query. The first form can be accessed with :index 1, the second :index 2, etc.

* how   - symbol - how we access the table, :index, :id, :xpath etc
* what  - string the thing we are looking for, ex. id, index or xpath query, of the object we are looking for

Valid values for ‘how’ are listed in the Watir Wiki - wiki.openqa.org/display/WTR/Watir+Methods+Supported+by+HTML+Element

returns a Table object

[show source]

# File watir/lib/watir/container.rb, line 133
    def table(how, what=nil)
      Table.new(self, how, what)
    end

tables ()

this is the main method for accessing the tables iterator. It returns a Tables object

Typical usage:

browser.tables.each { |t| puts t.to_s }            # iterate through all the tables on the page
browser.tables[1].to_s                             # goto the first table on the page
browser.tables.length                              # show how many tables are on the page. Tables that are nested will be included in this

[show source]

# File watir/lib/watir/container.rb, line 144
    def tables
      Tables.new(self)
    end

text_field (how, what=nil)

This is the main method for accessing a text field. Usually an <input type=text> HTML tag. or a text area - a <textarea> tag

*  how   - symbol - how we access the field, :index, :id, :name etc
*  what  - string, integer or regular expression - what we are looking for,

Valid values for ‘how’ are listed in the Watir Wiki - wiki.openqa.org/display/WTR/Watir+Methods+Supported+by+HTML+Element

returns a TextField object

Typical Usage

browser.text_field(:id,   'user_name')                 # access the text field with an ID of user_name
browser.text_field(:name, 'address')                   # access the text field with a name of address
browser.text_field(:index, 2)                          # access the second text field on the page (1 based, so the first field is accessed with :index,1)
browser.text_field(:xpath, "//textarea[@id='user_name']/")    # access the text field with an ID of user_name

[show source]

# File watir/lib/watir/container.rb, line 277
    def text_field(how, what=nil)
      TextField.new(self, how, what)
    end

text_fields ()

this is the method for accessing the text_fields iterator. It returns a Text_Fields object

Typical usage:

browser.text_fields.each { |t| puts t.to_s }            # iterate through all the text fields on the page
browser.text_fields[1].to_s                             # goto the first text field on the page
browser.text_fields.length                              # show how many text field are on the page.

[show source]

# File watir/lib/watir/container.rb, line 288
    def text_fields
      TextFields.new(self)
    end

wait (no_sleep=false)

Wait until Browser has finished loading the page.

[show source]

# File watir/lib/watir/container.rb, line 49
    def wait(no_sleep=false)
      @container.wait(no_sleep)
    end

activeObjectHighLightColor	[RW]	The color we want to use for the active object. This can be any valid web-friendly color.
page_container	[RW]	The PageContainer object containing this element
type_keys	[RW]
typingspeed	[RW]	This is used to change the typing speed when entering text on a page.

Module Watir::Container

Methods

public instance

Included modules

Attributes

Public instance methods