Module: Watir::Container

Includes:
Exception
Included in:
Element, ElementMapper, Form, Frame, IE, ModalDialog, Table, TableCell
Defined in:
lib/watir/container.rb,
lib/watir/form.rb,
lib/watir/camel_case.rb

Overview

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 to click the button

browser.button(:name, 'b1').click

or to find the name attribute

browser.button(:value, 'Click Me').name

there are many methods available to the Button object – Is includable for classes that have @container, document and ole_inner_elements

Instance Attribute Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#activeObjectHighLightColor ⇒ Object

The color we want to use for the active object. This can be any valid web-friendly color.



30
31
32
 
# File 'lib/watir/container.rb', line 30

def activeObjectHighLightColor
  @activeObjectHighLightColor
end

#page_container ⇒ Object

The PageContainer object containing this element



32
33
34
 
# File 'lib/watir/container.rb', line 32

def page_container
  @page_container
end

#type_keys ⇒ Object

Returns the value of attribute type_keys.



28
29
30
 
# File 'lib/watir/container.rb', line 28

def type_keys
  @type_keys
end

#typingspeed ⇒ Object

This is used to change the typing speed when entering text on a page.



27
28
29
 
# File 'lib/watir/container.rb', line 27

def typingspeed
  @typingspeed
end

Instance Method Details

#area(how, what = nil) ⇒ Object

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/Methods+supported+by+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



549
550
551
 
# File 'lib/watir/container.rb', line 549

def area(how, what=nil)
  return Area.new(self, how, what)
end

#areas ⇒ Object

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.



563
564
565
 
# File 'lib/watir/container.rb', line 563

def areas
  return Areas.new(self)
end

#button(how, what = nil) ⇒ Object

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/Methods+supported+by+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



215
216
217
218
 
# File '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 ⇒ Object

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.



227
228
229
 
# File 'lib/watir/container.rb', line 227

def buttons
  Buttons.new(self)
end

#cell(how, what = nil) ⇒ Object

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



154
155
156
 
# File 'lib/watir/container.rb', line 154

def cell(how, what=nil)
  TableCell.new(self, how, what)
end

#cells ⇒ Object 



157
158
159
 
# File 'lib/watir/container.rb', line 157

def cells
  TableCells.new(self)
end

#checkbox(how, what = nil, value = nil) ⇒ Object Also known as: checkBox

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/Methods+supported+by+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'



380
381
382
 
# File '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 ⇒ Object

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.



391
392
393
 
# File 'lib/watir/container.rb', line 391

def checkboxes
  CheckBoxes.new(self)
end

#dds ⇒ Object

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.



638
639
640
 
# File 'lib/watir/container.rb', line 638

def dds
  Dds.new(self)
end

#divs ⇒ Object

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.



614
615
616
 
# File 'lib/watir/container.rb', line 614

def divs
  Divs.new(self)
end

#dls ⇒ Object

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.



626
627
628
 
# File 'lib/watir/container.rb', line 626

def dls
  Dls.new(self)
end

#dts ⇒ Object

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.



650
651
652
 
# File 'lib/watir/container.rb', line 650

def dts
  Dts.new(self)
end

#element(how, what) ⇒ Object

This is the main method for accessing a generic element with a given attibute

*  how   - symbol - how we access the element. Supports all values except :index and :xpath
*  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/Methods+supported+by+Element

returns an Watir::Element object

Typical Usage

ie.element(:class, /foo/)      # access the first element with class 'foo'. We can use a string in place of the regular expression
ie.element(:id, "11")          # access the first element that matches an id



750
751
752
 
# File 'lib/watir/container.rb', line 750

def element(how, what)
  return HTMLElement.new(self, how, what)  
end

#elements(how, what) ⇒ Object

this is the main method for accessing generic html elements by an attribute

Returns a HTMLElements object

Typical usage:

ie.elements(:class, 'test').each { |l| puts l.to_s }  # iterate through all elements of a given attribute
ie.elements(:alt, 'foo')[1].to_s                       # get the first element of a given attribute
ie.elements(:id, 'foo').length                        # show how many elements are foung in the collection



764
765
766
 
# File 'lib/watir/container.rb', line 764

def elements(how, what)
  return HTMLElements.new(self, how, what)  
end

#ems ⇒ Object

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.



662
663
664
 
# File 'lib/watir/container.rb', line 662

def ems
  Ems.new(self)
end

#file_field(how, what = nil) ⇒ Object Also known as: fileField

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)



247
248
249
 
# File 'lib/watir/container.rb', line 247

def file_field(how, what=nil)
  FileField.new(self, how, what)
end

#file_fields ⇒ Object

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.



258
259
260
 
# File 'lib/watir/container.rb', line 258

def file_fields
  FileFields.new(self)
end

#form(how, what = nil) ⇒ Object

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/Methods+supported+by+Element

returns a Form object



116
117
118
119
 
# File '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 ⇒ Object 



167
168
169
 
# File 'lib/watir/form.rb', line 167

def forms
  Forms.new(self)
end

#frame(how, what = nil) ⇒ Object

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/Methods+supported+by+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



102
103
104
105
 
# File '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) ⇒ Object

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/Methods+supported+by+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



307
308
309
 
# File 'lib/watir/container.rb', line 307

def hidden(how, what=nil)
  Hidden.new(self, how, what)
end

#hiddens ⇒ Object

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.



318
319
320
 
# File 'lib/watir/container.rb', line 318

def hiddens
  Hiddens.new(self)
end

#image(how, what = nil) ⇒ Object

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/Methods+supported+by+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



583
584
585
 
# File 'lib/watir/container.rb', line 583

def image(how, what=nil)
  Image.new(self, how, what)
end

#images ⇒ Object

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.



595
596
597
 
# File 'lib/watir/container.rb', line 595

def images
  Images.new(self)
end

#labels ⇒ Object

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.



733
734
735
 
# File 'lib/watir/container.rb', line 733

def labels
  Labels.new(self)
end

#link(how, what = nil) ⇒ Object

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/Methods+supported+by+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



454
455
456
 
# File 'lib/watir/container.rb', line 454

def link(how, what=nil)
  Link.new(self, how, what)
end

#links ⇒ Object

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.



466
467
468
 
# File 'lib/watir/container.rb', line 466

def links
  Links.new(self)
end

#lis ⇒ Object

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.



498
499
500
 
# File 'lib/watir/container.rb', line 498

def lis
  return Lis.new(self)
end

#locate_all_elements(how, what) ⇒ Object

returns the the locator object so you can iterate over the elements using #each



851
852
853
854
855
 
# File 'lib/watir/container.rb', line 851

def locate_all_elements(how, what)
  locator = ElementLocator.new(self)
  locator.set_specifier(how, what)
  locator
end

#locate_input_element(how, what, types, value = nil, klass = nil) ⇒ Object

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



823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
 
# File 'lib/watir/container.rb', line 823

def locate_input_element(how, what, types, value=nil, klass=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.klass = klass if klass 
  locator.locate
end

#locate_tagged_element(tag, how, what) ⇒ Object

returns the ole object for the specified element



843
844
845
846
847
 
# File 'lib/watir/container.rb', line 843

def locate_tagged_element(tag, how, what)
  locator = TaggedElementLocator.new(self, tag)
  locator.set_specifier(how, what)
  locator.locate
end

#log(what) ⇒ Object

Write the specified string to the log.



42
43
44
 
# File 'lib/watir/container.rb', line 42

def log(what)
  @container.logger.debug(what) if @logger
end

#map(how, what = nil) ⇒ Object

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/Methods+supported+by+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



517
518
519
 
# File 'lib/watir/container.rb', line 517

def map(how, what=nil)
  return Map.new(self, how, what)
end

#maps ⇒ Object

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.



531
532
533
 
# File 'lib/watir/container.rb', line 531

def maps
  return Maps.new(self)
end

#modal_dialog(how = nil, what = nil) ⇒ Object

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.



187
188
189
 
# File 'lib/watir/container.rb', line 187

def modal_dialog(how=nil, what=nil)
  ModalDialog.new(self, how, what)
end

#popup ⇒ Object

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



601
602
603
 
# File 'lib/watir/container.rb', line 601

def popup         # BUG this should not be on the container object!
  PopUp.new(self)
end

#pres ⇒ Object

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.



719
720
721
 
# File 'lib/watir/container.rb', line 719

def pres
  Pres.new(self)
end

#ps ⇒ Object

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.



705
706
707
 
# File 'lib/watir/container.rb', line 705

def ps
  Ps.new(self)
end

#radio(how, what = nil, value = nil) ⇒ Object

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/Methods+supported+by+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'



422
423
424
 
# File 'lib/watir/container.rb', line 422

def radio(how, what=nil, value=nil)
  Radio.new(self, how, what, value)
end

#radios ⇒ Object

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.



434
435
436
 
# File 'lib/watir/container.rb', line 434

def radios
  Radios.new(self)
end

#row(how, what = nil) ⇒ Object

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



167
168
169
 
# File 'lib/watir/container.rb', line 167

def row(how, what=nil)
  TableRow.new(self, how, what)
end

#rows ⇒ Object 



170
171
172
 
# File 'lib/watir/container.rb', line 170

def rows
  TableRows.new(self)
end

#select_list(how, what = nil) ⇒ Object Also known as: selectBox

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/Methods+supported+by+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



337
338
339
 
# File 'lib/watir/container.rb', line 337

def select_list(how, what=nil)
  SelectList.new(self, how, what)
end

#select_lists ⇒ Object

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.



348
349
350
 
# File 'lib/watir/container.rb', line 348

def select_lists
  SelectLists.new(self)
end

#set_container(container) ⇒ Object

:nodoc:



63
64
65
66
 
# File 'lib/watir/container.rb', line 63

def set_container container #:nodoc:
  @container = container 
  @page_container = container.page_container
end

#show_all_objects ⇒ Object

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.



783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
 
# File 'lib/watir/container.rb', line 783

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 ⇒ Object

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.



676
677
678
 
# File 'lib/watir/container.rb', line 676

def spans
  Spans.new(self)
end

#strongs ⇒ Object

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.



690
691
692
 
# File 'lib/watir/container.rb', line 690

def strongs
  return Strongs.new(self)
end

#table(how, what = nil) ⇒ Object

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/Methods+supported+by+Element

returns a Table object



133
134
135
 
# File 'lib/watir/container.rb', line 133

def table(how, what=nil)
  Table.new(self, how, what)
end

#tables ⇒ Object

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



144
145
146
 
# File 'lib/watir/container.rb', line 144

def tables
  Tables.new(self)
end

#text_field(how, what = nil) ⇒ Object Also known as: textField

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/Methods+supported+by+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



277
278
279
 
# File 'lib/watir/container.rb', line 277

def text_field(how, what=nil)
  TextField.new(self, how, what)
end

#text_fields ⇒ Object

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.



288
289
290
 
# File 'lib/watir/container.rb', line 288

def text_fields
  TextFields.new(self)
end

#wait(no_sleep = false) ⇒ Object Also known as: waitForIE

Wait until Browser has finished loading the page. – called explicitly by most click and set methods



49
50
51
 
# File 'lib/watir/container.rb', line 49

def wait(no_sleep=false)
  @container.wait(no_sleep)
end