Document Object Model (DOM) Level 2 Specification

namespaceURI

The namespace URI of the document element to create, or null.

qualifiedName

The qualified name of the document element to be created.

DocumentType

doctype

The type of document to be created or null.

When doctype is not null, its Node.ownerDocument attribute is set to the document being created.

Return Value

Document

A new Document object.

Exceptions

INVALID_CHARACTER_ERR: Raised if the specified qualified name contains an illegal character.

NAMESPACE_ERR: Raised if the qualifiedName is malformed, or if the qualifiedName has a prefix that is "xml" and the namespaceURI is different from "http://www.w3.org/XML/1998/namespace".

WRONG_DOCUMENT_ERR: Raised if doctype has already been used with a different document.

createDocumentType introduced in DOM Level 2

Creates an empty DocumentType node. Entity declarations and notations are not made available. Entity reference expansions and default attribute additions do not occur. It is expected that a future version of the DOM will provide a way for populating a DocumentType.
HTML-only DOM implementations do not need to implement this method.

Parameters

`DOMString`	`qualifiedName`	The qualified name of the document type to be created.
`DOMString`	`publicId`	The external subset public identifier.
`DOMString`	`systemId`	The external subset system identifier.

Return Value

DocumentType

A new DocumentType node with Node.ownerDocument set to null.

Exceptions

INVALID_CHARACTER_ERR: Raised if the specified qualified name contains an illegal character.

NAMESPACE_ERR: Raised if the qualifiedName is malformed.

hasFeature

Test if the DOM implementation implements a specific feature.

Parameters

`DOMString`		`feature`		The name of the feature to test (case-insensitive). The legal values are defined throughout this specification and listed in the Compliance section. The name must be an XML name. To avoid possible conflicts, as a convention, names referring to features defined outside the DOM spec should be made unique by reversing the name of the Internet domain name of the person (or the organization that person belongs to) who defines the feature, component by component, and use this as a prefix. For instance, the W3C SYMM Working Group defines the feature "org.w3c.dom.smil".
`DOMString`		`version`		This is the version number of the feature to test. In Level 2, this is the string "2.0". If the version is not specified, supporting any version of the feature causes the method to return `true`.

Return Value

boolean

true if the feature is implemented in the specified version, false otherwise.

No Exceptions

Interface DocumentFragment

DocumentFragment is a "lightweight" or "minimal" Document object. It is very common to want to be able to extract a portion of a document's tree or to create a new fragment of a document. Imagine implementing a user command like cut or rearranging a document by moving fragments around. It is desirable to have an object which can hold such fragments and it is quite natural to use a Node for this purpose. While it is true that a Document object could fulfill this role, a Document object can potentially be a heavyweight object, depending on the underlying implementation. What is really needed for this is a very lightweight object. DocumentFragment is such an object.

Furthermore, various operations -- such as inserting nodes as children of another Node -- may take DocumentFragment objects as arguments; this results in all the child nodes of the DocumentFragment being moved to the child list of this node.

The children of a DocumentFragment node are zero or more nodes representing the tops of any sub-trees defining the structure of the document. DocumentFragment nodes do not need to be well-formed XML documents (although they do need to follow the rules imposed upon well-formed XML parsed entities, which can have multiple top nodes). For example, a DocumentFragment might have only one child and that child node could be a Text node. Such a structure model represents neither an HTML document nor a well-formed XML document.

When a DocumentFragment is inserted into a Document (or indeed any other Node that may take children) the children of the DocumentFragment and not the DocumentFragment itself are inserted into the Node. This makes the DocumentFragment very useful when the user wishes to create nodes that are siblings; the DocumentFragment acts as the parent of these nodes so that the user can use the standard methods from the Node interface, such as insertBefore and appendChild.

IDL Definition

interface DocumentFragment : Node {
};

Interface Document

The Document interface represents the entire HTML or XML document. Conceptually, it is the root of the document tree, and provides the primary access to the document's data.

Since elements, text nodes, comments, processing instructions, etc. cannot exist outside the context of a Document, the Document interface also contains the factory methods needed to create these objects. The Node objects created have a ownerDocument attribute which associates them with the Document within whose context they were created.

IDL Definition

interface Document : Node {
  readonly attribute DocumentType     doctype;
  readonly attribute DOMImplementation  implementation;
  readonly attribute Element          documentElement;
  Element            createElement(in DOMString tagName)
                                        raises(DOMException);
  DocumentFragment   createDocumentFragment();
  Text               createTextNode(in DOMString data);
  Comment            createComment(in DOMString data);
  CDATASection       createCDATASection(in DOMString data)
                                        raises(DOMException);
  ProcessingInstruction createProcessingInstruction(in DOMString target, 
                                                    in DOMString data)
                                        raises(DOMException);
  Attr               createAttribute(in DOMString name)
                                        raises(DOMException);
  EntityReference    createEntityReference(in DOMString name)
                                        raises(DOMException);
  NodeList           getElementsByTagName(in DOMString tagname);
  // Introduced in DOM Level 2:
  Node               importNode(in Node importedNode, 
                                in boolean deep)
                                        raises(DOMException);
  // Introduced in DOM Level 2:
  Element            createElementNS(in DOMString namespaceURI, 
                                     in DOMString qualifiedName)
                                        raises(DOMException);
  // Introduced in DOM Level 2:
  Attr               createAttributeNS(in DOMString namespaceURI, 
                                       in DOMString qualifiedName)
                                        raises(DOMException);
  // Introduced in DOM Level 2:
  NodeList           getElementsByTagNameNS(in DOMString namespaceURI, 
                                            in DOMString localName);
  // Introduced in DOM Level 2:
  Element            getElementById(in DOMString elementId);
};

Attributes

doctype of type DocumentType, readonly: The Document Type Declaration (see DocumentType) associated with this document. For HTML documents as well as XML documents without a document type declaration this returns null. The DOM Level 2 does not support editing the Document Type Declaration, therefore docType cannot be altered in any way, including through the use of methods, such as insertNode or removeNode, inherited from Node.
documentElement of type Element, readonly: This is a convenience attribute that allows direct access to the child node that is the root element of the document. For HTML documents, this is the element with the tagName "HTML".
implementation of type DOMImplementation, readonly: The DOMImplementation object that handles this document. A DOM application may use objects from multiple implementations.

Methods

createAttribute

Creates an Attr of the given name. Note that the Attr instance can then be set on an Element using the setAttributeNode method.
To create an attribute with a qualified name and namespace URI, use the createAttributeNS method.

Parameters

name

The name of the attribute.

Return Value

A new Attr object with the nodeName attribute set to name, and localName, prefix, and namespaceURI set to null.

Exceptions

INVALID_CHARACTER_ERR: Raised if the specified name contains an illegal character.

createAttributeNS introduced in DOM Level 2

Creates an attribute of the given qualified name and namespace URI. HTML-only DOM implementations do not need to implement this method.

Parameters

`DOMString`		`namespaceURI`		The namespace URI of the attribute to create.
`DOMString`		`qualifiedName`		The qualified name of the attribute to instantiate.

Return Value

A new Attr object with the following attributes:
Attribute Value

Node.nodeName qualifiedName

Node.namespaceURI namespaceURI

Node.prefix prefix, extracted from qualifiedName, or null if there is no prefix

Node.localName local name, extracted from qualifiedName

Attr.name qualifiedName

Exceptions

INVALID_CHARACTER_ERR: Raised if the specified qualified name contains an illegal character.

NAMESPACE_ERR: Raised if the qualifiedName is malformed, if the qualifiedName has a prefix and the namespaceURI is null or an empty string, if the qualifiedName has a prefix that is "xml" and the namespaceURI is different from "http://www.w3.org/XML/1998/namespace", if the qualifiedName has a prefix that is "xmlns" and the namespaceURI is different from "http://www.w3.org/2000/xmlns/", or if the qualifiedName is "xmlns" and the namespaceURI is different from "http://www.w3.org/2000/xmlns/".

createCDATASection

Creates a CDATASection node whose value is the specified string.

Parameters

data

The data for the CDATASection contents.

Return Value

CDATASection

The new CDATASection object.

Exceptions

NOT_SUPPORTED_ERR: Raised if this document is an HTML document.

createComment

Creates a Comment node given the specified string.

Parameters

createDocumentFragment

data

The data for the node.

Return Value

Comment

The new Comment object.

No Exceptions

Creates an empty DocumentFragment object.

Return Value

DocumentFragment

A new DocumentFragment.

No Parameters

No Exceptions

createElement

Creates an element of the type specified. Note that the instance returned implements the Element interface, so attributes can be specified directly on the returned object.
In addition, if there are known attributes with default values, Attr nodes representing them are automatically created and attached to the element.
To create an element with a qualified name and namespace URI, use the createElementNS method.

Parameters

tagName

The name of the element type to instantiate. For XML, this is case-sensitive. For HTML, the tagName parameter may be provided in any case, but it must be mapped to the canonical uppercase form by the DOM implementation.

Return Value

Element

A new Element object with the nodeName attribute set to tagName, and localName, prefix, and namespaceURI set to null.

Exceptions

INVALID_CHARACTER_ERR: Raised if the specified name contains an illegal character.

createElementNS introduced in DOM Level 2

Creates an element of the given qualified name and namespace URI. HTML-only DOM implementations do not need to implement this method.

Parameters

`DOMString`		`namespaceURI`		The namespace URI of the element to create.
`DOMString`		`qualifiedName`		The qualified name of the element type to instantiate.

Return Value

Element

A new Element object with the following attributes:
Attribute Value

Node.nodeName qualifiedName

Node.namespaceURI namespaceURI

Node.prefix prefix, extracted from qualifiedName, or null if there is no prefix

Node.localName local name, extracted from qualifiedName

Element.tagName qualifiedName

Exceptions

createEntityReference

INVALID_CHARACTER_ERR: Raised if the specified qualified name contains an illegal character.

NAMESPACE_ERR: Raised if the qualifiedName is malformed, if the qualifiedName has a prefix and the namespaceURI is null or an empty string, or if the qualifiedName has a prefix that is "xml" and the namespaceURI is different from "http://www.w3.org/XML/1998/namespace" [Namespaces].

Creates an EntityReference object. In addition, if the referenced entity is known, the child list of the EntityReference node is made the same as that of the corresponding Entity node.

Note: If any descendant of the Entity node has an unbound namespace prefix, the corresponding descendant of the created EntityReference node is also unbound; (its namespaceURI is null). The DOM Level 2 does not support any mechanism to resolve namespace prefixes.

Parameters

name

The name of the entity to reference.

Return Value

EntityReference

The new EntityReference object.

Exceptions

createProcessingInstruction

INVALID_CHARACTER_ERR: Raised if the specified name contains an illegal character.

NOT_SUPPORTED_ERR: Raised if this document is an HTML document.

Creates a ProcessingInstruction node given the specified name and data strings.

Parameters

`DOMString`		`target`		The target part of the processing instruction.
`DOMString`		`data`		The data for the node.

Return Value

ProcessingInstruction

The new ProcessingInstruction object.

Exceptions

INVALID_CHARACTER_ERR: Raised if the specified target contains an illegal character.

NOT_SUPPORTED_ERR: Raised if this document is an HTML document.

createTextNode

Creates a Text node given the specified string.

Parameters

data

The data for the node.

Return Value

Text

The new Text object.

No Exceptions

getElementById introduced in DOM Level 2

Returns the Element whose ID is given by elementId. If no such element exists, returns null. Behavior is not defined if more than one element has this ID.

Note: The DOM implementation must have information that says which attributes are of type ID. Attributes with the name "ID" are not of type ID unless so defined. Implementations that do not know whether attributes are of type ID or not are expected to return null.

Parameters

getElementsByTagName

elementId

The unique id value for an element.

Return Value

Element

The matching element.

No Exceptions

Returns a NodeList of all the Elements with a given tag name in the order in which they would be encountered in a preorder traversal of the Document tree.

Parameters

tagname

The name of the tag to match on. The special value "*" matches all tags.

Return Value

A new NodeList object containing all the matched Elements.

No Exceptions

getElementsByTagNameNS introduced in DOM Level 2

Returns a NodeList of all the Elements with a given local name and namespace URI in the order in which they would be encountered in a preorder traversal of the Document tree.

Parameters

`DOMString`		`namespaceURI`		The namespace URI of the elements to match on. The special value "*" matches all namespaces.
`DOMString`		`localName`		The local name of the elements to match on. The special value "*" matches all local names.

Return Value

A new NodeList object containing all the matched Elements.

No Exceptions

importNode introduced in DOM Level 2

Imports a node from another document to this document. The returned node has no parent; (parentNode is null). The source node is not altered or removed from the original document; this method creates a new copy of the source node.
For all nodes, importing a node creates a node object owned by the importing document, with attribute values identical to the source node's nodeName and nodeType, plus the attributes related to namespaces (prefix, localName, and namespaceURI). As in the cloneNode operation on a Node, the source node is not altered.
Additional information is copied as appropriate to the nodeType, attempting to mirror the behavior expected if a fragment of XML or HTML source was copied from one document to another, recognizing that the two documents may have different DTDs in the XML case. The following list describes the specifics for every type of node.

ATTRIBUTE_NODE: The specified flag is set to true on the generated Attr. The descendants of the source Attr are recursively imported and the resulting nodes reassembled to form the corresponding subtree.
Note that the deep parameter does not apply to Attr nodes; they always carry their children with them when imported.
DOCUMENT_FRAGMENT_NODE: If the deep option was set true, the descendants of the source element will be recursively imported and the resulting nodes reassembled to form the corresponding subtree. Otherwise, this simply generates an empty DocumentFragment.
DOCUMENT_NODE: Document nodes cannot be imported.
DOCUMENT_TYPE_NODE: DocumentType nodes cannot be imported.
ELEMENT_NODE: Specified attribute nodes of the source element are imported, and the generated Attr nodes are attached to the generated Element. Default attributes are not copied, though if the document being imported into defines default attributes for this element name, those are assigned. If the importNode deep parameter was set to true, the descendants of the source element will be recursively imported and the resulting nodes reassembled to form the corresponding subtree.
ENTITY_NODE: Entity nodes can be imported, however in the current release of the DOM the DocumentType is readonly. Ability to add these imported nodes to a DocumentType will be considered for addition to a future release of the DOM.
On import, the publicId, systemId, and notationName attributes are copied. If a deep import is requested, the descendants of the the source Entity is recursively imported and the resulting nodes reassembled to form the corresponding subtree.
ENTITY_REFERENCE_NODE: Only the EntityReference itself is copied, even if a deep import is requested, since the source and destination documents might have defined the entity differently. If the document being imported into provides a definition for this entity name, its value is assigned.
NOTATION_NODE: Notation nodes can be imported, however in the current release of the DOM the DocumentType is readonly. Ability to add these imported nodes to a DocumentType will be considered for addition to a future release of the DOM.
On import, the publicId and systemId attributes are copied.
Note that the deep parameter does not apply to Notation nodes since they never have any children.
PROCESSING_INSTRUCTION_NODE: The imported node copies its target and data values from those of the source node.
TEXT_NODE, CDATA_SECTION_NODE, COMMENT_NODE: These three types of nodes inheriting from CharacterData copy their data and length attributes from those of the source node.

Parameters

`Node`		`importedNode`		The node to import.
`boolean`		`deep`		If `true`, recursively import the subtree under the specified node; if `false`, import only the node itself, as explained above. This does not apply to `Attr`, `EntityReference`, and `Notation` nodes.

Return Value

The imported node that belongs to this Document.

Exceptions

NOT_SUPPORTED_ERR: Raised if the type of node being imported is not supported.

Interface Node

The Node interface is the primary datatype for the entire Document Object Model. It represents a single node in the document tree. While all objects implementing the Node interface expose methods for dealing with children, not all objects implementing the Node interface may have children. For example, Text nodes may not have children, and adding children to such nodes results in a DOMException being raised.

The attributes nodeName, nodeValue and attributes are included as a mechanism to get at node information without casting down to the specific derived interface. In cases where there is no obvious mapping of these attributes for a specific nodeType (e.g., nodeValue for an Element or attributes for a Comment), this returns null. Note that the specialized interfaces may contain additional and more convenient mechanisms to get and set the relevant information.

IDL Definition

interface Node {
  // NodeType
  const unsigned short      ELEMENT_NODE                   = 1;
  const unsigned short      ATTRIBUTE_NODE                 = 2;
  const unsigned short      TEXT_NODE                      = 3;
  const unsigned short      CDATA_SECTION_NODE             = 4;
  const unsigned short      ENTITY_REFERENCE_NODE          = 5;
  const unsigned short      ENTITY_NODE                    = 6;
  const unsigned short      PROCESSING_INSTRUCTION_NODE    = 7;
  const unsigned short      COMMENT_NODE                   = 8;
  const unsigned short      DOCUMENT_NODE                  = 9;
  const unsigned short      DOCUMENT_TYPE_NODE             = 10;
  const unsigned short      DOCUMENT_FRAGMENT_NODE         = 11;
  const unsigned short      NOTATION_NODE                  = 12;

  readonly attribute DOMString        nodeName;
           attribute DOMString        nodeValue;
                                        // raises(DOMException) on setting
                                        // raises(DOMException) on retrieval

  readonly attribute unsigned short   nodeType;
  readonly attribute Node             parentNode;
  readonly attribute NodeList         childNodes;
  readonly attribute Node             firstChild;
  readonly attribute Node             lastChild;
  readonly attribute Node             previousSibling;
  readonly attribute Node             nextSibling;
  readonly attribute NamedNodeMap     attributes;
  // Modified in DOM Level 2:
  readonly attribute Document         ownerDocument;
  Node               insertBefore(in Node newChild, 
                                  in Node refChild)
                                        raises(DOMException);
  Node               replaceChild(in Node newChild, 
                                  in Node oldChild)
                                        raises(DOMException);
  Node               removeChild(in Node oldChild)
                                        raises(DOMException);
  Node               appendChild(in Node newChild)
                                        raises(DOMException);
  boolean            hasChildNodes();
  Node               cloneNode(in boolean deep);
  // Introduced in DOM Level 2:
  void               normalize();
  // Introduced in DOM Level 2:
  boolean            supports(in DOMString feature, 
                              in DOMString version);
  // Introduced in DOM Level 2:
  readonly attribute DOMString        namespaceURI;
  // Introduced in DOM Level 2:
           attribute DOMString        prefix;
                                        // raises(DOMException) on setting

  // Introduced in DOM Level 2:
  readonly attribute DOMString        localName;
};

Definition group NodeType

An integer indicating which type of node this is.

Note: Numeric codes up to 200 are reserved to W3C for possible future use.

Defined Constants

ATTRIBUTE_NODE	The node is an `Attr`.
CDATA_SECTION_NODE	The node is a `CDATASection`.
COMMENT_NODE	The node is a `Comment`.
DOCUMENT_FRAGMENT_NODE	The node is a `DocumentFragment`.
DOCUMENT_NODE	The node is a `Document`.
DOCUMENT_TYPE_NODE	The node is a `DocumentType`.
ELEMENT_NODE	The node is an `Element`.
ENTITY_NODE	The node is an `Entity`.
ENTITY_REFERENCE_NODE	The node is an `EntityReference`.
NOTATION_NODE	The node is a `Notation`.
PROCESSING_INSTRUCTION_NODE	The node is a `ProcessingInstruction`.
TEXT_NODE	The node is a `Text` node.

The values of nodeName, nodeValue, and attributes vary according to the node type as follows:
nodeName nodeValue attributes

Attr name of attribute value of attribute null

CDATASection #cdata-section content of the CDATA Section null

Comment #comment content of the comment null

Document #document null null

DocumentFragment #document-fragment null null

DocumentType document type name null null

Element tag name null NamedNodeMap

Entity entity name null null

EntityReference name of entity referenced null null

Notation notation name null null

ProcessingInstruction target entire content excluding the target null

Text #text content of the text node null

Attributes

attributes of type NamedNodeMap, readonly

A NamedNodeMap containing the attributes of this node (if it is an Element) or null otherwise.

childNodes of type NodeList, readonly

A NodeList that contains all children of this node. If there are no children, this is a NodeList containing no nodes.

firstChild of type Node, readonly

The first child of this node. If there is no such node, this returns null.

lastChild of type Node, readonly

The last child of this node. If there is no such node, this returns null.

localName of type DOMString, readonly, introduced in DOM Level 2

Returns the local part of the qualified name of this node.
For nodes created with a DOM Level 1 method, such as createElement from the Document interface, it is null.

namespaceURI of type DOMString, readonly, introduced in DOM Level 2

The namespace URI of this node, or null if it is unspecified.
This is not a computed value that is the result of a namespace lookup based on an examination of the namespace declarations in scope. It is merely the namespace URI given at creation time.
For nodes of any type other than ELEMENT_NODE and ATTRIBUTE_NODE and nodes created with a DOM Level 1 method, such as createElement from the Document interface, this is always null.

Note: Per the Namespaces in XML Specification [Namespaces] an attribute does not inherit its namespace from the element it is attached to. If an attribute is not explicitly given a namespace, it simply has no namespace.

nextSibling of type Node, readonly

The node immediately following this node. If there is no such node, this returns null.

nodeName of type DOMString, readonly

The name of this node, depending on its type; see the table above.

nodeType of type unsigned short, readonly

A code representing the type of the underlying object, as defined above.

nodeValue of type DOMString

The value of this node, depending on its type; see the table above. When it is defined to be null, setting it has no effect.

Exceptions on setting

NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly.

Exceptions on retrieval

DOMSTRING_SIZE_ERR: Raised when it would return more characters than fit in a DOMString variable on the implementation platform.

ownerDocument of type Document, readonly, modified in DOM Level 2

The Document object associated with this node. This is also the Document object used to create new nodes. When this node is a Document or a DocumentType which is not used with any Document yet, this is null.

parentNode of type Node, readonly

The parent of this node. All nodes, except Attr, Document, DocumentFragment, Entity, and Notation may have a parent. However, if a node has just been created and not yet added to the tree, or if it has been removed from the tree, this is null.

prefix of type DOMString, introduced in DOM Level 2

The namespace prefix of this node, or null if it is unspecified.
Note that setting this attribute, when permitted, changes the nodeName attribute, which holds the qualified name, as well as the tagName and name attributes of the Element and Attr interfaces, when applicable.
Note also that changing the prefix of an attribute that is known to have a default value, does not make a new attribute with the default value and the original prefix appear, since the namespaceURI and localName do not change.

Exceptions on setting

INVALID_CHARACTER_ERR: Raised if the specified prefix contains an illegal character.

NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.

NAMESPACE_ERR: Raised if the specified prefix is malformed, if the namespaceURI of this node is null, if the specified prefix is "xml" and the namespaceURI of this node is different from "http://www.w3.org/XML/1998/namespace", if this node is an attribute and the specified prefix is "xmlns" and the namespaceURI of this node is different from "http://www.w3.org/2000/xmlns/", or if this node is an attribute and the qualifiedName of this node is "xmlns" [Namespaces].

previousSibling of type Node, readonly

The node immediately preceding this node. If there is no such node, this returns null.

Methods

appendChild

Adds the node newChild to the end of the list of children of this node. If the newChild is already in the tree, it is first removed.

Parameters

newChild

The node to add.

If it is a DocumentFragment object, the entire contents of the document fragment are moved into the child list of this node

Return Value

The node added.

Exceptions

HIERARCHY_REQUEST_ERR: Raised if this node is of a type that does not allow children of the type of the newChild node, or if the node to append is one of this node's ancestors.

WRONG_DOCUMENT_ERR: Raised if newChild was created from a different document than the one that created this node.

NO_MODIFICATION_ALLOWED_ERR: Raised if this node or the node being appended is readonly.

cloneNode

Returns a duplicate of this node, i.e., serves as a generic copy constructor for nodes. The duplicate node has no parent; (parentNode is null.).
Cloning an Element copies all attributes and their values, including those generated by the XML processor to represent defaulted attributes, but this method does not copy any text it contains unless it is a deep clone, since the text is contained in a child Text node. Cloning an Attribute directly, as opposed to be cloned as part of an Element cloning operation, returns a specified attribute (specified is true). Cloning any other type of node simply returns a copy of this node.
Note that cloning an immutable subtree results in a mutable copy, but the children of an EntityReference clone are readonly.

Parameters

boolean

deep

If true, recursively clone the subtree under the specified node; if false, clone only the node itself (and its attributes, if it is an Element).

Return Value

The duplicate node.

No Exceptions

hasChildNodes

This is a convenience method to allow easy determination of whether a node has any children.

Return Value

boolean

true if the node has any children, false if the node has no children.

No Parameters

No Exceptions

insertBefore

Inserts the node newChild before the existing child node refChild. If refChild is null, insert newChild at the end of the list of children.
If newChild is a DocumentFragment object, all of its children are inserted, in the same order, before refChild. If the newChild is already in the tree, it is first removed.

Parameters

`Node`		`newChild`		The node to insert.
`Node`		`refChild`		The reference node, i.e., the node before which the new node must be inserted.

Return Value

The node being inserted.

Exceptions

HIERARCHY_REQUEST_ERR: Raised if this node is of a type that does not allow children of the type of the newChild node, or if the node to insert is one of this node's ancestors.

WRONG_DOCUMENT_ERR: Raised if newChild was created from a different document than the one that created this node.

NO_MODIFICATION_ALLOWED_ERR: Raised if this node or the node being inserted is readonly.

NOT_FOUND_ERR: Raised if refChild is not a child of this node.

normalize introduced in DOM Level 2

Puts all Text nodes in the full depth of the sub-tree underneath this Node, including attribute nodes, into a "normal" form where only markup (e.g., tags, comments, processing instructions, CDATA sections, and entity references) separates Text nodes, i.e., there are neither adjacent Text nodes nor empty Text nodes. This can be used to ensure that the DOM view of a document is the same as if it were saved and re-loaded, and is useful when operations (such as XPointer lookups) that depend on a particular document tree structure are to be used.

Note: In cases where the document contains CDATASections, the normalize operation alone may not be sufficient, since XPointers do not differentiate between Text nodes and CDATASection nodes.

No Parameters

No Return Value

No Exceptions

removeChild

Removes the child node indicated by oldChild from the list of children, and returns it.

Parameters

oldChild

The node being removed.

Return Value

The node removed.

Exceptions

NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.

NOT_FOUND_ERR: Raised if oldChild is not a child of this node.

replaceChild

Replaces the child node oldChild with newChild in the list of children, and returns the oldChild node.
If newChild is a DocumentFragment object, oldChild is replaced by all of the DocumentFragment children, which are inserted in the same order. If the newChild is already in the tree, it is first removed.

Parameters

`Node`		`newChild`		The new node to put in the child list.
`Node`		`oldChild`		The node being replaced in the list.

Return Value

The node replaced.

Exceptions

HIERARCHY_REQUEST_ERR: Raised if this node is of a type that does not allow children of the type of the newChild node, or if the node to put in is one of this node's ancestors.

WRONG_DOCUMENT_ERR: Raised if newChild was created from a different document than the one that created this node.

NO_MODIFICATION_ALLOWED_ERR: Raised if this node or the new node is readonly.

NOT_FOUND_ERR: Raised if oldChild is not a child of this node.

supports introduced in DOM Level 2

Tests whether the DOM implementation implements a specific feature and that feature is supported by this node.

Parameters

`DOMString`		`feature`		The name of the feature to test. This is the same name which can be passed to the method `hasFeature` on `DOMImplementation`.
`DOMString`		`version`		This is the version number of the feature to test. In Level 2, version 1, this is the string "2.0". If the version is not specified, supporting any version of the feature will cause the method to return `true`.

Return Value

boolean

Returns true if the specified feature is supported on this node, false otherwise.

No Exceptions

Interface NodeList

The NodeList interface provides the abstraction of an ordered collection of nodes, without defining or constraining how this collection is implemented. NodeList objects in the DOM are live.

The items in the NodeList are accessible via an integral index, starting from 0.

IDL Definition

interface NodeList {
  Node               item(in unsigned long index);
  readonly attribute unsigned long    length;
};

Attributes

length of type unsigned long, readonly: The number of nodes in the list. The range of valid child node indices is 0 to length-1 inclusive.

Methods

item

Returns the indexth item in the collection. If index is greater than or equal to the number of nodes in the list, this returns null.

Parameters

unsigned long

index

Index into the collection.

Return Value

The node at the indexth position in the NodeList, or null if that is not a valid index.

No Exceptions

Interface NamedNodeMap

Objects implementing the NamedNodeMap interface are used to represent collections of nodes that can be accessed by name. Note that NamedNodeMap does not inherit from NodeList; NamedNodeMaps are not maintained in any particular order. Objects contained in an object implementing NamedNodeMap may also be accessed by an ordinal index, but this is simply to allow convenient enumeration of the contents of a NamedNodeMap, and does not imply that the DOM specifies an order to these Nodes.

NamedNodeMap objects in the DOM are live.

IDL Definition

interface NamedNodeMap {
  Node               getNamedItem(in DOMString name);
  Node               setNamedItem(in Node arg)
                                        raises(DOMException);
  Node               removeNamedItem(in DOMString name)
                                        raises(DOMException);
  Node               item(in unsigned long index);
  readonly attribute unsigned long    length;
  // Introduced in DOM Level 2:
  Node               getNamedItemNS(in DOMString namespaceURI, 
                                    in DOMString localName);
  // Introduced in DOM Level 2:
  Node               setNamedItemNS(in Node arg)
                                        raises(DOMException);
  // Introduced in DOM Level 2:
  Node               removeNamedItemNS(in DOMString namespaceURI, 
                                       in DOMString localName)
                                        raises(DOMException);
};

Attributes

length of type unsigned long, readonly: The number of nodes in this map. The range of valid child node indices is 0 to length-1 inclusive.

Methods

getNamedItem

Retrieves a node specified by name.

Parameters

name

The nodeName of a node to retrieve.

Return Value

A Node (of any type) with the specified nodeName, or null if it does not identify any node in this map.

No Exceptions

getNamedItemNS introduced in DOM Level 2

Retrieves a node specified by local name and namespace URI. HTML-only DOM implementations do not need to implement this method.

Parameters

`DOMString`		`namespaceURI`		The namespace URI of the node to retrieve.
`DOMString`		`localName`		The local name of the node to retrieve.

Return Value

A Node (of any type) with the specified local name and namespace URI, or null if they do not identify any node in this map.

No Exceptions

item

Returns the indexth item in the map. If index is greater than or equal to the number of nodes in this map, this returns null.

Parameters

unsigned long

index

Index into this map.

Return Value

The node at the indexth position in the map, or null if that is not a valid index.

No Exceptions

removeNamedItem

Removes a node specified by name. A removed attribute may be known to have a default value when this map contains the attributes attached to an element, as returned by the attributes attribute of the Node interface. If so, an attribute immediately appears containing the default value as well as the corresponding namespace URI, local name, and prefix when applicable.

Parameters

name

The nodeName of the node to remove.

Return Value

The node removed from this map if a node with such a name exists.

Exceptions

NOT_FOUND_ERR: Raised if there is no node named name in this map.

NO_MODIFICATION_ALLOWED_ERR: Raised if this map is readonly.

removeNamedItemNS introduced in DOM Level 2

Removes a node specified by local name and namespace URI. A removed attribute may be known to have a default value when this map contains the attributes attached to an element, as returned by the attributes attribute of the Node interface. If so, an attribute immediately appears containing the default value as well as the corresponding namespace URI, local name, and prefix when applicable.
HTML-only DOM implementations do not need to implement this method.

Parameters

`DOMString`		`namespaceURI`		The namespace URI of the node to remove.
`DOMString`		`localName`		The local name of the node to remove.

Return Value

The node removed from this map if a node with such a local name and namespace URI exists.

Exceptions

NOT_FOUND_ERR: Raised if there is no node with the specified namespaceURI and localName in this map.

NO_MODIFICATION_ALLOWED_ERR: Raised if this map is readonly.

setNamedItem

Adds a node using its nodeName attribute. If a node with that name is already present in this map, it is replaced by the new one.
As the nodeName attribute is used to derive the name which the node must be stored under, multiple nodes of certain types (those that have a "special" string value) cannot be stored as the names would clash. This is seen as preferable to allowing nodes to be aliased.

Parameters

arg

A node to store in this map. The node will later be accessible using the value of its nodeName attribute.

Return Value

If the new Node replaces an existing node the replaced Node is returned, otherwise null is returned.

Exceptions

WRONG_DOCUMENT_ERR: Raised if arg was created from a different document than the one that created this map.

NO_MODIFICATION_ALLOWED_ERR: Raised if this map is readonly.

INUSE_ATTRIBUTE_ERR: Raised if arg is an Attr that is already an attribute of another Element object. The DOM user must explicitly clone Attr nodes to re-use them in other elements.

setNamedItemNS introduced in DOM Level 2

Adds a node using its namespaceURI and localName. If a node with that namespace URI and that local name is already present in this map, it is replaced by the new one.
HTML-only DOM implementations do not need to implement this method.

Parameters

arg

A node to store in this map. The node will later be accessible using the value of its namespaceURI and localName attributes.

Return Value

If the new Node replaces an existing node the replaced Node is returned, otherwise null is returned.

Exceptions

WRONG_DOCUMENT_ERR: Raised if arg was created from a different document than the one that created this map.

NO_MODIFICATION_ALLOWED_ERR: Raised if this map is readonly.

INUSE_ATTRIBUTE_ERR: Raised if arg is an Attr that is already an attribute of another Element object. The DOM user must explicitly clone Attr nodes to re-use them in other elements.

Interface CharacterData

The CharacterData interface extends Node with a set of attributes and methods for accessing character data in the DOM. For clarity this set is defined here rather than on each object that uses these attributes and methods. No DOM objects correspond directly to CharacterData, though Text and others do inherit the interface from it. All offsets in this interface start from 0.

As explained in the DOMString interface, text strings in the DOM are represented in UTF-16, i.e. as a sequence of 16-bit units. In the following, the term 16-bit units is used whenever necessary to indicate that indexing on CharacterData is done in 16-bit units.

IDL Definition

interface CharacterData : Node {
           attribute DOMString        data;
                                        // raises(DOMException) on setting
                                        // raises(DOMException) on retrieval

  readonly attribute unsigned long    length;
  DOMString          substringData(in unsigned long offset, 
                                   in unsigned long count)
                                        raises(DOMException);
  void               appendData(in DOMString arg)
                                        raises(DOMException);
  void               insertData(in unsigned long offset, 
                                in DOMString arg)
                                        raises(DOMException);
  void               deleteData(in unsigned long offset, 
                                in unsigned long count)
                                        raises(DOMException);
  void               replaceData(in unsigned long offset, 
                                 in unsigned long count, 
                                 in DOMString arg)
                                        raises(DOMException);
};

Attributes

data of type DOMString

The character data of the node that implements this interface. The DOM implementation may not put arbitrary limits on the amount of data that may be stored in a CharacterData node. However, implementation limits may mean that the entirety of a node's data may not fit into a single DOMString. In such cases, the user may call substringData to retrieve the data in appropriately sized pieces.

Exceptions on setting

NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly.

Exceptions on retrieval

DOMSTRING_SIZE_ERR: Raised when it would return more characters than fit in a DOMString variable on the implementation platform.

length of type unsigned long, readonly

The number of 16-bit units that are available through data and the substringData method below. This may have the value zero, i.e., CharacterData nodes may be empty.

Methods

appendData

Append the string to the end of the character data of the node. Upon success, data provides access to the concatenation of data and the DOMString specified.

Parameters

arg

The DOMString to append.

Exceptions

NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.

No Return Value

deleteData

Remove a range of 16-bit units from the node. Upon success, data and length reflect the change.

Parameters

`unsigned long`		`offset`		The offset from which to start removing.
`unsigned long`		`count`		The number of 16-bit units to delete. If the sum of `offset` and `count` exceeds `length` then all 16-bit units from `offset` to the end of the data are deleted.

Exceptions

INDEX_SIZE_ERR: Raised if the specified offset is negative or greater than the number of 16-bit units in data, or if the specified count is negative.

NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.

No Return Value

insertData

Insert a string at the specified character offset.

Parameters

`unsigned long`		`offset`		The character offset at which to insert.
`DOMString`		`arg`		The `DOMString` to insert.

Exceptions

INDEX_SIZE_ERR: Raised if the specified offset is negative or greater than the number of 16-bit units in data.

NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.

No Return Value

replaceData

Replace the characters starting at the specified 16-bit unit offset with the specified string.

Parameters

`unsigned long`	`offset`	The offset from which to start replacing.
`unsigned long`	`count`	The number of 16-bit units to replace. If the sum of `offset` and `count` exceeds `length`, then all 16-bit units to the end of the data are replaced; (i.e., the effect is the same as a `remove` method call with the same range, followed by an `append` method invocation).
`DOMString`	`arg`	The `DOMString` with which the range must be replaced.

Exceptions

INDEX_SIZE_ERR: Raised if the specified offset is negative or greater than the number of 16-bit units in data, or if the specified count is negative.

NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.

No Return Value

substringData

Extracts a range of data from the node.

Parameters

`unsigned long`		`offset`		Start offset of substring to extract.
`unsigned long`		`count`		The number of 16-bit units to extract.

Return Value

The specified substring. If the sum of offset and count exceeds the length, then all 16-bit units to the end of the data are returned.

Exceptions

INDEX_SIZE_ERR: Raised if the specified offset is negative or greater than the number of 16-bit units in data, or if the specified count is negative.

DOMSTRING_SIZE_ERR: Raised if the specified range of text does not fit into a DOMString.

Interface Attr

The Attr interface represents an attribute in an Element object. Typically the allowable values for the attribute are defined in a document type definition.

Attr objects inherit the Node interface, but since they are not actually child nodes of the element they describe, the DOM does not consider them part of the document tree. Thus, the Node attributes parentNode, previousSibling, and nextSibling have a null value for Attr objects. The DOM takes the view that attributes are properties of elements rather than having a separate identity from the elements they are associated with; this should make it more efficient to implement such features as default attributes associated with all elements of a given type. Furthermore, Attr nodes may not be immediate children of a DocumentFragment. However, they can be associated with Element nodes contained within a DocumentFragment. In short, users and implementors of the DOM need to be aware that Attr nodes have some things in common with other objects inheriting the Node interface, but they also are quite distinct.

The attribute's effective value is determined as follows: if this attribute has been explicitly assigned any value, that value is the attribute's effective value; otherwise, if there is a declaration for this attribute, and that declaration includes a default value, then that default value is the attribute's effective value; otherwise, the attribute does not exist on this element in the structure model until it has been explicitly added. Note that the nodeValue attribute on the Attr instance can also be used to retrieve the string version of the attribute's value(s).

In XML, where the value of an attribute can contain entity references, the child nodes of the Attr node provide a representation in which entity references are not expanded. These child nodes may be either Text or EntityReference nodes. Because the attribute type may be unknown, there are no tokenized attribute values.

IDL Definition

interface Attr : Node {
  readonly attribute DOMString        name;
  readonly attribute boolean          specified;
           attribute DOMString        value;
                                        // raises(DOMException) on setting

  // Introduced in DOM Level 2:
  readonly attribute Element          ownerElement;
};

Attributes

name of type DOMString, readonly

Returns the name of this attribute.

ownerElement of type Element, readonly, introduced in DOM Level 2

The Element node this attribute is attached to or null if this attribute is not in use.

specified of type boolean, readonly

If this attribute was explicitly given a value in the original document, this is true; otherwise, it is false. Note that the implementation is in charge of this attribute, not the user. If the user changes the value of the attribute (even if it ends up having the same value as the default value) then the specified flag is automatically flipped to true. To re-specify the attribute as the default value from the DTD, the user must delete the attribute. The implementation will then make a new attribute available with specified set to false and the default value (if one exists).
In summary:

If the attribute has an assigned value in the document then specified is true, and the value is the assigned value.
If the attribute has no assigned value in the document and has a default value in the DTD, then specified is false, and the value is the default value in the DTD.
If the attribute has no assigned value in the document and has a value of #IMPLIED in the DTD, then the attribute does not appear in the structure model of the document.

value of type DOMString

On retrieval, the value of the attribute is returned as a string. Character and general entity references are replaced with their values. See also the method getAttribute on the Element interface.
On setting, this creates a Text node with the unparsed contents of the string. I.e. any characters that an XML processor would recognize as markup are instead treated as literal text. See also the method setAttribute on the Element interface.

Exceptions on setting

NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly.

Interface Element

The Element interface represents an element in an HTML or XML document. Elements may have attributes associated with them; since the Element interface inherits from Node, the generic Node interface attribute attributes may be used to retrieve the set of all attributes for an element. There are methods on the Element interface to retrieve either an Attr object by name or an attribute value by name. In XML, where an attribute value may contain entity references, an Attr object should be retrieved to examine the possibly fairly complex sub-tree representing the attribute value. On the other hand, in HTML, where all attributes have simple string values, methods to directly access an attribute value can safely be used as a convenience.

Note: In DOM Level 2, the method normalize is inherited from the Node interface where it was moved.

IDL Definition

interface Element : Node {
  readonly attribute DOMString        tagName;
  DOMString          getAttribute(in DOMString name);
  void               setAttribute(in DOMString name, 
                                  in DOMString value)
                                        raises(DOMException);
  void               removeAttribute(in DOMString name)
                                        raises(DOMException);
  Attr               getAttributeNode(in DOMString name);
  Attr               setAttributeNode(in Attr newAttr)
                                        raises(DOMException);
  Attr               removeAttributeNode(in Attr oldAttr)
                                        raises(DOMException);
  NodeList           getElementsByTagName(in DOMString name);
  // Introduced in DOM Level 2:
  DOMString          getAttributeNS(in DOMString namespaceURI, 
                                    in DOMString localName);
  // Introduced in DOM Level 2:
  void               setAttributeNS(in DOMString namespaceURI, 
                                    in DOMString qualifiedName, 
                                    in DOMString value)
                                        raises(DOMException);
  // Introduced in DOM Level 2:
  void               removeAttributeNS(in DOMString namespaceURI, 
                                       in DOMString localName)
                                        raises(DOMException);
  // Introduced in DOM Level 2:
  Attr               getAttributeNodeNS(in DOMString namespaceURI, 
                                        in DOMString localName);
  // Introduced in DOM Level 2:
  Attr               setAttributeNodeNS(in Attr newAttr)
                                        raises(DOMException);
  // Introduced in DOM Level 2:
  NodeList           getElementsByTagNameNS(in DOMString namespaceURI, 
                                            in DOMString localName);
  // Introduced in DOM Level 2:
  boolean            hasAttribute(in DOMString name);
  // Introduced in DOM Level 2:
  boolean            hasAttributeNS(in DOMString namespaceURI, 
                                    in DOMString localName);
};

Attributes

tagName of type DOMString, readonly

The name of the element. For example, in:


<elementExample id="demo"> 
        ... 
</elementExample> ,

tagName has the value "elementExample". Note that this is case-preserving in XML, as are all of the operations of the DOM. The HTML DOM returns the tagName of an HTML element in the canonical uppercase form, regardless of the case in the source HTML document.

Methods

getAttribute

Retrieves an attribute value by name.

Parameters

name

The name of the attribute to retrieve.

Return Value

The Attr value as a string, or the empty string if that attribute does not have a specified or default value.

No Exceptions

getAttributeNS introduced in DOM Level 2

Retrieves an attribute value by local name and namespace URI. HTML-only DOM implementations do not need to implement this method.

Parameters

`DOMString`		`namespaceURI`		The namespace URI of the attribute to retrieve.
`DOMString`		`localName`		The local name of the attribute to retrieve.

Return Value

The Attr value as a string, or the empty string if that attribute does not have a specified or default value.

No Exceptions

getAttributeNode

Retrieves an attribute node by name.
To retrieve an attribute node by qualified name and namespace URI, use the getAttributeNodeNS method.

Parameters

name

The name (nodeName) of the attribute to retrieve.

Return Value

The Attr node with the specified name (nodeName) or null if there is no such attribute.

No Exceptions

getAttributeNodeNS introduced in DOM Level 2

Retrieves an Attr node by local name and namespace URI. HTML-only DOM implementations do not need to implement this method.

Parameters

`DOMString`		`namespaceURI`		The namespace URI of the attribute to retrieve.
`DOMString`		`localName`		The local name of the attribute to retrieve.

Return Value

getElementsByTagName

The Attr node with the specified attribute local name and namespace URI or null if there is no such attribute.

No Exceptions

Returns a NodeList of all descendant elements with a given tag name, in the order in which they would be encountered in a preorder traversal of the Element tree.

Parameters

name

The name of the tag to match on. The special value "*" matches all tags.

Return Value

A list of matching Element nodes.

No Exceptions

getElementsByTagNameNS introduced in DOM Level 2

Returns a NodeList of all the Elements with a given local name and namespace URI in the order in which they would be encountered in a preorder traversal of the Document tree, starting from this node.
HTML-only DOM implementations do not need to implement this method.

Parameters

`DOMString`		`namespaceURI`		The namespace URI of the elements to match on. The special value "*" matches all namespaces.
`DOMString`		`localName`		The local name of the elements to match on. The special value "*" matches all local names.

Return Value

A new NodeList object containing all the matched Elements.

No Exceptions

hasAttribute introduced in DOM Level 2

Returns true when an attribute with a given name is specified on this element or has a default value, false otherwise.

Parameters

name

The name of the attribute to look for.

Return Value

boolean

true if an attribute with the given name is specified on this element or has a default value, false otherwise.

No Exceptions

hasAttributeNS introduced in DOM Level 2

Returns true when an attribute with a given local name and namespace URI is specified on this element or has a default value, false otherwise. HTML-only DOM implementations do not need to implement this method.

Parameters

`DOMString`		`namespaceURI`		The namespace URI of the attribute to look for.
`DOMString`		`localName`		The local name of the attribute to look for.

Return Value

boolean

true if an attribute with the given local name and namespace URI is specified or has a default value on this element, false otherwise.

No Exceptions

removeAttribute

Removes an attribute by name. If the removed attribute is known to have a default value, an attribute immediately appears containing the default value as well as the corresponding namespace URI, local name, and prefix when applicable.
To remove an attribute by local name and namespace URI, use the removeAttributeNS method.

Parameters

name

The name of the attribute to remove.

Exceptions

NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.

No Return Value

removeAttributeNS introduced in DOM Level 2

Removes an attribute by local name and namespace URI. If the removed attribute has a default value it is immediately replaced. The replacing attribute has the same namespace URI and local name, as well as the original prefix.
HTML-only DOM implementations do not need to implement this method.

Parameters

`DOMString`		`namespaceURI`		The namespace URI of the attribute to remove.
`DOMString`		`localName`		The local name of the attribute to remove.

Exceptions

removeAttributeNode

NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.

No Return Value

Removes the specified attribute node. If the removed Attr has a default value it is immediately replaced. The replacing attribute has the same namespace URI and local name, as well as the original prefix, when applicable.

Parameters

oldAttr

The Attr node to remove from the attribute list.

Return Value

The Attr node that was removed.

Exceptions

NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.

NOT_FOUND_ERR: Raised if oldAttr is not an attribute of the element.

setAttribute

Adds a new attribute. If an attribute with that name is already present in the element, its value is changed to be that of the value parameter. This value is a simple string; it is not parsed as it is being set. So any markup (such as syntax to be recognized as an entity reference) is treated as literal text, and needs to be appropriately escaped by the implementation when it is written out. In order to assign an attribute value that contains entity references, the user must create an Attr node plus any Text and EntityReference nodes, build the appropriate subtree, and use setAttributeNode to assign it as the value of an attribute.
To set an attribute with a qualified name and namespace URI, use the setAttributeNS method.

Parameters

`DOMString`		`name`		The name of the attribute to create or alter.
`DOMString`		`value`		Value to set in string form.

Exceptions

INVALID_CHARACTER_ERR: Raised if the specified name contains an illegal character.

NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.

No Return Value

setAttributeNS introduced in DOM Level 2

Adds a new attribute. If an attribute with the same local name and namespace URI is already present on the element, its prefix is changed to be the prefix part of the qualifiedName, and its value is changed to be the value parameter. This value is a simple string; it is not parsed as it is being set. So any markup (such as syntax to be recognized as an entity reference) is treated as literal text, and needs to be appropriately escaped by the implementation when it is written out. In order to assign an attribute value that contains entity references, the user must create an Attr node plus any Text and EntityReference nodes, build the appropriate subtree, and use setAttributeNodeNS or setAttributeNode to assign it as the value of an attribute.
HTML-only DOM implementations do not need to implement this method.

Parameters

`DOMString`	`namespaceURI`	The namespace URI of the attribute to create or alter.
`DOMString`	`qualifiedName`	The qualified name of the attribute to create or alter.
`DOMString`	`value`	The value to set in string form.

Exceptions

INVALID_CHARACTER_ERR: Raised if the specified qualified name contains an illegal character.

NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.

No Return Value

setAttributeNode

Adds a new attribute node. If an attribute with that name (nodeName) is already present in the element, it is replaced by the new one.
To add a new attribute node with a qualified name and namespace URI, use the setAttributeNodeNS method.

Parameters

newAttr

The Attr node to add to the attribute list.

Return Value

If the newAttr attribute replaces an existing attribute, the replaced Attr node is returned, otherwise null is returned.

Exceptions

WRONG_DOCUMENT_ERR: Raised if newAttr was created from a different document than the one that created the element.

NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.

INUSE_ATTRIBUTE_ERR: Raised if newAttr is already an attribute of another Element object. The DOM user must explicitly clone Attr nodes to re-use them in other elements.

setAttributeNodeNS introduced in DOM Level 2

Adds a new attribute. If an attribute with that local name and that namespace URI is already present in the element, it is replaced by the new one.
HTML-only DOM implementations do not need to implement this method.

Parameters

newAttr

The Attr node to add to the attribute list.

Return Value

If the newAttr attribute replaces an existing attribute with the same local name and namespace URI, the replaced Attr node is returned, otherwise null is returned.

Exceptions

WRONG_DOCUMENT_ERR: Raised if newAttr was created from a different document than the one that created the element.

NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.

INUSE_ATTRIBUTE_ERR: Raised if newAttr is already an attribute of another Element object. The DOM user must explicitly clone Attr nodes to re-use them in other elements.

Interface Text

The Text interface inherits from CharacterData and represents the textual content (termed character data in XML) of an Element or Attr. If there is no markup inside an element's content, the text is contained in a single object implementing the Text interface that is the only child of the element. If there is markup, it is parsed into the information items (elements, comments, etc.) and Text nodes that form the list of children of the element.

When a document is first made available via the DOM, there is only one Text node for each block of text. Users may create adjacent Text nodes that represent the contents of a given element without any intervening markup, but should be aware that there is no way to represent the separations between these nodes in XML or HTML, so they will not (in general) persist between DOM editing sessions. The normalize() method on Element merges any such adjacent Text objects into a single node for each block of text.

IDL Definition

interface Text : CharacterData {
  Text               splitText(in unsigned long offset)
                                        raises(DOMException);
};

Methods

splitText

Breaks this node into two nodes at the specified offset, keeping both in the tree as siblings. This node then only contains all the content up to the offset point. A new node of the same type, which is inserted as the next sibling of this node, contains all the content at and after the offset point. When the offset is equal to the length of this node, the new node has no data.

Parameters

unsigned long

offset

The 16-bit unit offset at which to split, starting from 0.

Return Value

Text

The new node, of the same type as this node.

Exceptions

INDEX_SIZE_ERR: Raised if the specified offset is negative or greater than the number of 16-bit units in data.

NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.

Interface Comment

This interface inherits from CharacterData and represents the content of a comment, i.e., all the characters between the starting ''. Note that this is the definition of a comment in XML, and, in practice, HTML, although some HTML tools may implement the full SGML comment structure.

IDL Definition

interface Comment : CharacterData {
};

1.3. Extended Interfaces

The interfaces defined here form part of the DOM Core specification, but objects that expose these interfaces will never be encountered in a DOM implementation that deals only with HTML. As such, HTML-only DOM implementations do not need to have objects that implement these interfaces.

A DOM application can use the hasFeature method of the DOMImplementation interface to determine whether they are supported or not. The feature string for all the interfaces listed in this section is "XML".

Interface CDATASection

CDATA sections are used to escape blocks of text containing characters that would otherwise be regarded as markup. The only delimiter that is recognized in a CDATA section is the "]]>" string that ends the CDATA section. CDATA sections cannot be nested. Their primary purpose is for including material such as XML fragments, without needing to escape all the delimiters.

The DOMString attribute of the Text node holds the text that is contained by the CDATA section. Note that this may contain characters that need to be escaped outside of CDATA sections and that, depending on the character encoding ("charset") chosen for serialization, it may be impossible to write out some characters as part of a CDATA section.

The CDATASection interface inherits from the CharacterData interface through the Text interface. Adjacent CDATASections nodes are not merged by use of the normalize method of the Element interface.

Note: Because no markup is recognized within a CDATASection, character numeric references cannot be used as an escape mechanism when serializing. Therefore, action needs to be taken when serializing a CDATASection with a character encoding where some of the contained characters cannot be represented. Failure to do so would not produce well-formed XML.
One potential solution in the serialization process is to end the CDATA section before the character, output the character using a character reference or entity reference, and open a new CDATA section for any further characters in the text node. Note, however, that some code conversion libraries at the time of writing do not return an error or exception when a character is missing from the encoding, making the task of ensuring that data is not corrupted on serialization more difficult.

IDL Definition

interface CDATASection : Text {
};

Interface DocumentType

Each Document has a doctype attribute whose value is either null or a DocumentType object. The DocumentType interface in the DOM Core provides an interface to the list of entities that are defined for the document, and little else because the effect of namespaces and the various XML schema efforts on DTD representation are not clearly understood as of this writing.

The DOM Level 2 doesn't support editing DocumentType nodes.

IDL Definition

interface DocumentType : Node {
  readonly attribute DOMString        name;
  readonly attribute NamedNodeMap     entities;
  readonly attribute NamedNodeMap     notations;
  // Introduced in DOM Level 2:
  readonly attribute DOMString        publicId;
  // Introduced in DOM Level 2:
  readonly attribute DOMString        systemId;
  // Introduced in DOM Level 2:
  readonly attribute DOMString        internalSubset;
};

Attributes

entities of type NamedNodeMap, readonly

A NamedNodeMap containing the general entities, both external and internal, declared in the DTD. Parameter entities are not contained. Duplicates are discarded. For example in:

<!DOCTYPE ex SYSTEM "ex.dtd" [
  <!ENTITY foo "foo">
  <!ENTITY bar "bar">
  <!ENTITY bar "bar2">
  <!ENTITY % baz "baz">
]>
<ex/>

the interface provides access to foo and the first declaration of bar but not the second declaration of bar or baz. Every node in this map also implements the Entity interface.
The DOM Level 2 does not support editing entities, therefore entities cannot be altered in any way.

internalSubset of type DOMString, readonly, introduced in DOM Level 2

The internal subset as a string.

Note: The actual content returned depends on how much information is available to the implementation. This may vary depending on various parameters, including the XML processor used to build the document.

name of type DOMString, readonly

The name of DTD; i.e., the name immediately following the DOCTYPE keyword.

notations of type NamedNodeMap, readonly

A NamedNodeMap containing the notations declared in the DTD. Duplicates are discarded. Every node in this map also implements the Notation interface.
The DOM Level 2 does not support editing notations, therefore notations cannot be altered in any way.

publicId of type DOMString, readonly, introduced in DOM Level 2

The public identifier of the external subset.

systemId of type DOMString, readonly, introduced in DOM Level 2

The system identifier of the external subset.

Interface Notation

This interface represents a notation declared in the DTD. A notation either declares, by name, the format of an unparsed entity (see section 4.7 of the XML 1.0 specification), or is used for formal declaration of processing instruction targets (see section 2.6 of the XML 1.0 specification). The nodeName attribute inherited from Node is set to the declared name of the notation.

The DOM Level 1 does not support editing Notation nodes; they are therefore readonly.

A Notation node does not have any parent.

IDL Definition

interface Notation : Node {
  readonly attribute DOMString        publicId;
  readonly attribute DOMString        systemId;
};

Attributes

publicId of type DOMString, readonly: The public identifier of this notation. If the public identifier was not specified, this is null.
systemId of type DOMString, readonly: The system identifier of this notation. If the system identifier was not specified, this is null.

Interface Entity

This interface represents an entity, either parsed or unparsed, in an XML document. Note that this models the entity itself not the entity declaration. Entity declaration modeling has been left for a later Level of the DOM specification.

The nodeName attribute that is inherited from Node contains the name of the entity.

An XML processor may choose to completely expand entities before the structure model is passed to the DOM; in this case there will be no EntityReference nodes in the document tree.

XML does not mandate that a non-validating XML processor read and process entity declarations made in the external subset or declared in external parameter entities. This means that parsed entities declared in the external subset need not be expanded by some classes of applications, and that the replacement value of the entity may not be available. When the replacement value is available, the corresponding Entity node's child list represents the structure of that replacement text. Otherwise, the child list is empty.

The DOM Level 2 does not support editing Entity nodes; if a user wants to make changes to the contents of an Entity, every related EntityReference node has to be replaced in the structure model by a clone of the Entity's contents, and then the desired changes must be made to each of those clones instead. All the descendants of an Entity node are readonly.

An Entity node does not have any parent.

Note: If the entity contains an unbound namespace prefix, the namespaceURI of the corresponding node in the Entity node subtree is null. The same is true for EntityReference nodes that refer to this entity, when they are created using the createEntityReference method of the Document interface. The DOM Level 2 does not support any mechanism to resolve namespace prefixes.

IDL Definition

interface Entity : Node {
  readonly attribute DOMString        publicId;
  readonly attribute DOMString        systemId;
  readonly attribute DOMString        notationName;
};

Attributes

notationName of type DOMString, readonly: For unparsed entities, the name of the notation for the entity. For parsed entities, this is null.
publicId of type DOMString, readonly: The public identifier associated with the entity, if specified. If the public identifier was not specified, this is null.
systemId of type DOMString, readonly: The system identifier associated with the entity, if specified. If the system identifier was not specified, this is null.

Interface EntityReference

EntityReference objects may be inserted into the structure model when an entity reference is in the source document, or when the user wishes to insert an entity reference. Note that character references and references to predefined entities are considered to be expanded by the HTML or XML processor so that characters are represented by their Unicode equivalent rather than by an entity reference. Moreover, the XML processor may completely expand references to entities while building the structure model, instead of providing EntityReference objects. If it does provide such objects, then for a given EntityReference node, it may be that there is no Entity node representing the referenced entity. If such an Entity exists, then the subtree of the EntityReference node is in general a copy of the Entity node subtree. However, this may not be true when an entity contains an unbound namespace prefix. In such a case, because the namespace prefix resolution depends on where the entity reference is, the descendants of the EntityReference node may be bound to different namespace URIs.

As with the Entity node, all descendants of the EntityReference are readonly.

IDL Definition

interface EntityReference : Node {
};

Interface ProcessingInstruction

The ProcessingInstruction interface represents a "processing instruction", used in XML as a way to keep processor-specific information in the text of the document.

IDL Definition

interface ProcessingInstruction : Node {
  readonly attribute DOMString        target;
           attribute DOMString        data;
                                        // raises(DOMException) on setting

};

Attributes

data of type DOMString

The content of this processing instruction. This is from the first non white space character after the target to the character immediately preceding the ?>.

Exceptions on setting

NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly.

target of type DOMString, readonly

The target of this processing instruction. XML defines this as being the first token following the markup that begins the processing instruction.

2. Document Object Model HTML

Editors: Arnaud Le Hors, W3C; Mike Champion, ArborText (for DOM Level 1); Vidur Apparao, Netscape (for DOM Level 1); Scott Isaacs, Microsoft (for DOM Level 1 until January 1998); Chris Wilson, Microsoft (for DOM Level 1 after January 1998); Ian Jacobs, W3C (for DOM Level 1)

2.1. Introduction

This section extends the Core API to describe objects and methods specific to HTML documents. In general, the functionality needed to manipulate hierarchical document structures, elements, and attributes will be found in the core section; functionality that depends on the specific elements defined in HTML will be found in this section.

The goals of the HTML-specific DOM API are:

to specialize and add functionality that relates specifically to HTML documents and elements.
to address issues of backwards compatibility with the DOM Level 0.
to provide convenience mechanisms, where appropriate, for common and frequent operations on HTML documents.

The key differences between the core DOM and the HTML application of DOM is that the HTML Document Object Model exposes a number of convenience methods and properties that are consistent with the existing models and are more appropriate to script writers. In many cases, these enhancements are not applicable to a general DOM because they rely on the presence of a predefined DTD. The transitional and frameset DTDs for HTML 4.0 are assumed. Interoperability between implementations is only guaranteed for elements and attributes that are specified in the HTML 4.0 DTDs.

More specifically, this document includes the following specializations for HTML:

An HTMLDocument interface, derived from the core Document interface. HTMLDocument specifies the operations and queries that can be made on a HTML document.
An HTMLElement interface, derived from the core Element interface. HTMLElement specifies the operations and queries that can be made on any HTML element. Methods on HTMLElement include those that allow for the retrieval and modification of attributes that apply to all HTML elements.
Specializations for all HTML elements that have attributes that extend beyond those specified in the HTMLElement interface. For all such attributes, the derived interface for the element contains explicit methods for setting and getting the values.

The DOM Level 2 includes mechanisms to access and modify style specified through CSS and defines an event model that can be used with HTML documents.

The interfaces found within this section are not mandatory. A DOM application can use the hasFeature method of the DOMImplementation interface to determine whether they are supported or not. The feature string for all the interfaces listed in this section is "HTML".

The interfaces in this specification are designed for HTML 4.0 documents, and not for XHTML 1.0 documents. Use of the HTML DOM with XHTML 1.0 documents may result in incorrect processing; see Appendix C11 in [XHTML10] for more information.

2.2. HTML Application of Core DOM

2.2.1. Naming Conventions

The HTML DOM follows a naming convention for properties, methods, events, collections, and data types. All names are defined as one or more English words concatenated together to form a single string.

2.2.1.1. Properties and Methods

The property or method name starts with the initial keyword in lowercase, and each subsequent word starts with a capital letter. For example, a property that returns document meta information such as the date the file was created might be named "fileDateCreated". In the ECMAScript binding, properties are exposed as properties of a given object. In Java, properties are exposed with get and set methods.

2.2.1.2. Non-HTML 4.0 interfaces and attributes

While most of the interfaces defined below can be mapped directly to elements defined in the HTML 4.0 Recommendation, some of them cannot. Similarly, not all attributes listed below have counterparts in the HTML 4.0 specification (and some do, but have been renamed to avoid conflicts with scripting languages). Interfaces and attribute definitions that have links to the HTML 4.0 specification have corresponding element and attribute definitions there; all others are added by this specification, either for convenience or backwards compatibility with DOM Level 0 implementations.

2.3. Miscellaneous Object Definitions

Interface HTMLDOMImplementation (introduced in DOM Level 2)

The HTMLDOMImplementation interface extends the DOMImplementation interface with a method for creating an HTML document instance.

IDL Definition

// Introduced in DOM Level 2:
interface HTMLDOMImplementation : DOMImplementation {
  HTMLDocument       createHTMLDocument(in DOMString title);
};

Methods

createHTMLDocument

Creates an HTMLDocument object with the minimal tree made of the following elements: HTML, HEAD, TITLE, and BODY.

Parameters

title

The title of the document to be set as the content of the TITLE element, through a child Text node.

Return Value

HTMLDocument

A new HTMLDocument object.

No Exceptions

Interface HTMLCollection

An HTMLCollection is a list of nodes. An individual node may be accessed by either ordinal index or the node's name or id attributes. Note: Collections in the HTML DOM are assumed to be live meaning that they are automatically updated when the underlying document is changed.

IDL Definition

interface HTMLCollection {
  readonly attribute unsigned long    length;
  Node               item(in unsigned long index);
  Node               namedItem(in DOMString name);
};

Attributes

length of type unsigned long, readonly: This attribute specifies the length or size of the list.

Methods

item

This method retrieves a node specified by ordinal index. Nodes are numbered in tree order (depth-first traversal order).

Parameters

unsigned long

index

The index of the node to be fetched. The index origin is 0.

Return Value

The Node at the corresponding position upon success. A value of null is returned if the index is out of range.

No Exceptions

namedItem

This method retrieves a Node using a name. It first searches for a Node with a matching id attribute. If it doesn't find one, it then searches for a Node with a matching name attribute, but only on those elements that are allowed a name attribute.

Parameters

name

The name of the Node to be fetched.

Return Value

The Node with a name or id attribute whose value corresponds to the specified string. Upon failure (e.g., no node with this name exists), returns null.

No Exceptions

2.4. Objects related to HTML documents

Interface HTMLDocument

An HTMLDocument is the root of the HTML hierarchy and holds the entire content. Besides providing access to the hierarchy, it also provides some convenience methods for accessing certain sets of information from the document.

The following properties have been deprecated in favor of the corresponding ones for the BODY element:

alinkColor
background
bgColor
fgColor
linkColor
vlinkColor

Note: In DOM Level 2, the method getElementById is inherited from the Document interface where it was moved.

IDL Definition

interface HTMLDocument : Document {
           attribute DOMString        title;
  readonly attribute DOMString        referrer;
  readonly attribute DOMString        domain;
  readonly attribute DOMString        URL;
           attribute HTMLElement      body;
  readonly attribute HTMLCollection   images;
  readonly attribute HTMLCollection   applets;
  readonly attribute HTMLCollection   links;
  readonly attribute HTMLCollection   forms;
  readonly attribute HTMLCollection   anchors;
           attribute DOMString        cookie;
  void               open();
  void               close();
  void               write(in DOMString text);
  void               writeln(in DOMString text);
  NodeList           getElementsByName(in DOMString elementName);
};

Attributes

URL of type DOMString, readonly: The complete URI of the document.
anchors of type HTMLCollection, readonly: A collection of all the anchor (A) elements in a document with a value for the name attribute.Note. For reasons of backwards compatibility, the returned set of anchors only contains those anchors created with the name attribute, not those created with the id attribute.
applets of type HTMLCollection, readonly: A collection of all the OBJECT elements that include applets and APPLET (deprecated) elements in a document.
body of type HTMLElement: The element that contains the content for the document. In documents with BODY contents, returns the BODY element. In frameset documents, this returns the outermost FRAMESET element.
cookie of type DOMString: The cookies associated with this document. If there are none, the value is an empty string. Otherwise, the value is a string: a semicolon-delimited list of "name, value" pairs for all the cookies associated with the page. For example, name=value;expires=date.
domain of type DOMString, readonly: The domain name of the server that served the document, or null if the server cannot be identified by a domain name.
forms of type HTMLCollection, readonly: A collection of all the forms of a document.
images of type HTMLCollection, readonly: A collection of all the IMG elements in a document. The behavior is limited to IMG elements for backwards compatibility.
links of type HTMLCollection, readonly: A collection of all AREA elements and anchor (A) elements in a document with a value for the href attribute.
referrer of type DOMString, readonly: Returns the URI of the page that linked to this page. The value is an empty string if the user navigated to the page directly (not through a link, but, for example, via a bookmark).
title of type DOMString: The title of a document as specified by the TITLE element in the head of the document.

Methods

close

Closes a document stream opened by open() and forces rendering.

No Parameters

No Return Value

No Exceptions

getElementsByName

Returns the (possibly empty) collection of elements whose name value is given by elementName.

Parameters

elementName

The name attribute value for an element.

Return Value

The matching elements.

No Exceptions

open

Note. This method and the ones following allow a user to add to or replace the structure model of a document using strings of unparsed HTML. At the time of writing alternate methods for providing similar functionality for both HTML and XML documents were being considered. The following methods may be deprecated at some point in the future in favor of a more general-purpose mechanism.
Open a document stream for writing. If a document exists in the target, this method clears it.

No Parameters

No Return Value

No Exceptions

write

Write a string of text to a document stream opened by open(). The text is parsed into the document's structure model.

Parameters

text

The string to be parsed into some structure in the document structure model.

No Return Value

No Exceptions

writeln

Write a string of text followed by a newline character to a document stream opened by open(). The text is parsed into the document's structure model.

Parameters

text

The string to be parsed into some structure in the document structure model.

No Return Value

No Exceptions

2.5. HTML Elements

2.5.1. Property Attributes

HTML attributes are exposed as properties on the element object. The DOM naming conventions always determine the name of the exposed property, and is independent of the case of the attribute in the source document. The data type of the property is determined by the type of the attribute as determined by the HTML 4.0 transitional and frameset DTDs. The attributes have the semantics (including case-sensitivity) given in the HTML 4.0 specification.

The attributes are exposed as properties for compatibility with DOM Level 0. This usage is deprecated because it can not be generalized to all possible attribute names, as is required both for XML and potentially for future versions of HTML. We recommend the use of generic methods on the core Element interface for setting, getting and removing attributes.
DTD Data Type Object Model Data Type

CDATA DOMString

Value list (e.g., (left | right | center)) DOMString

one-value Value list (e.g., (disabled)) boolean

Number long int

The return value of an attribute that has a data type that is a value list is always capitalized, independent of the case of the value in the source document. For example, if the value of the align attribute on a P element is "left" then it is returned as "Left". For attributes with the CDATA data type, the case of the return value is that given in the source document.

The return value of an attribute that is unspecified and does not have a default value is the empty string if the return type is a DOMString, false if the return type is a boolean and 0 if the return type is a number.

2.5.2. Naming Exceptions

To avoid namespace conflicts, an attribute with the same name as a keyword in one of our chosen binding languages is prefixed. For HTML, the prefix used is "html". For example, the for attribute of the LABEL element collides with loop construct naming conventions and is renamed htmlFor.

2.5.3. Exposing Element Type Names (`tagName`)

The element type names exposed through a property are in uppercase. For example, the body element type name is exposed through the tagName property as BODY.

2.5.4. The HTMLElement interface

Interface HTMLElement

All HTML element interfaces derive from this class. Elements that only expose the HTML core attributes are represented by the base HTMLElement interface. These elements are as follows:

HEAD
special: SUB, SUP, SPAN, BDO
font: TT, I, B, U, S, STRIKE, BIG, SMALL
phrase: EM, STRONG, DFN, CODE, SAMP, KBD, VAR, CITE, ACRONYM, ABBR
list: DD, DT
NOFRAMES, NOSCRIPT
ADDRESS, CENTER

Note: The style attribute of an HTML element is accessible through the ElementCSSInlineStyle interface which is defined in the Document Object Model CSS.

IDL Definition

interface HTMLElement : Element {
           attribute DOMString        id;
           attribute DOMString        title;
           attribute DOMString        lang;
           attribute DOMString        dir;
           attribute DOMString        className;
};

Attributes

className of type DOMString: The class attribute of the element. This attribute has been renamed due to conflicts with the "class" keyword exposed by many languages. See the class attribute definition in HTML 4.0.
dir of type DOMString: Specifies the base direction of directionally neutral text and the directionality of tables. See the dir attribute definition in HTML 4.0.
id of type DOMString: The element's identifier. See the id attribute definition in HTML 4.0.
lang of type DOMString: Language code defined in RFC 1766. See the lang attribute definition in HTML 4.0.
title of type DOMString: The element's advisory title. See the title attribute definition in HTML 4.0.

2.5.5. Object definitions

Interface HTMLHtmlElement

Root of an HTML document. See the HTML element definition in HTML 4.0.

IDL Definition

interface HTMLHtmlElement : HTMLElement {
           attribute DOMString        version;
};

Attributes

version of type DOMString: Version information about the document's DTD. See the version attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.

Interface HTMLHeadElement

Document head information. See the HEAD element definition in HTML 4.0.

IDL Definition

interface HTMLHeadElement : HTMLElement {
           attribute DOMString        profile;
};

Attributes

profile of type DOMString: URI designating a metadata profile. See the profile attribute definition in HTML 4.0.

Interface HTMLLinkElement

The LINK element specifies a link to an external resource, and defines this document's relationship to that resource (or vice versa). See the LINK element definition in HTML 4.0 (see also the LinkStyle interface in the Document Object Model StyleSheets module).

IDL Definition

interface HTMLLinkElement : HTMLElement {
           attribute boolean          disabled;
           attribute DOMString        charset;
           attribute DOMString        href;
           attribute DOMString        hreflang;
           attribute DOMString        media;
           attribute DOMString        rel;
           attribute DOMString        rev;
           attribute DOMString        target;
           attribute DOMString        type;
};

Attributes

charset of type DOMString: The character encoding of the resource being linked to. See the charset attribute definition in HTML 4.0.
disabled of type boolean: Enables/disables the link. This is currently only used for style sheet links, and may be used to activate or deactivate style sheets.
href of type DOMString: The URI of the linked resource. See the href attribute definition in HTML 4.0.
hreflang of type DOMString: Language code of the linked resource. See the hreflang attribute definition in HTML 4.0.
media of type DOMString: Designed for use with one or more target media. See the media attribute definition in HTML 4.0.
rel of type DOMString: Forward link type. See the rel attribute definition in HTML 4.0.
rev of type DOMString: Reverse link type. See the rev attribute definition in HTML 4.0.
target of type DOMString: Frame to render the resource in. See the target attribute definition in HTML 4.0.
type of type DOMString: Advisory content type. See the type attribute definition in HTML 4.0.

Interface HTMLTitleElement

The document title. See the TITLE element definition in HTML 4.0.

IDL Definition

interface HTMLTitleElement : HTMLElement {
           attribute DOMString        text;
};

Attributes

text of type DOMString: The specified title as a string.

Interface HTMLMetaElement

This contains generic meta-information about the document. See the META element definition in HTML 4.0.

IDL Definition

interface HTMLMetaElement : HTMLElement {
           attribute DOMString        content;
           attribute DOMString        httpEquiv;
           attribute DOMString        name;
           attribute DOMString        scheme;
};

Attributes

content of type DOMString: Associated information. See the content attribute definition in HTML 4.0.
httpEquiv of type DOMString: HTTP response header name. See the http-equiv attribute definition in HTML 4.0.
name of type DOMString: Meta information name. See the name attribute definition in HTML 4.0.
scheme of type DOMString: Select form of content. See the scheme attribute definition in HTML 4.0.

Interface HTMLBaseElement

Document base URI. See the BASE element definition in HTML 4.0.

IDL Definition

interface HTMLBaseElement : HTMLElement {
           attribute DOMString        href;
           attribute DOMString        target;
};

Attributes

href of type DOMString: The base URI. See the href attribute definition in HTML 4.0.
target of type DOMString: The default target frame. See the target attribute definition in HTML 4.0.

Interface HTMLIsIndexElement

This element is used for single-line text input. See the ISINDEX element definition in HTML 4.0. This element is deprecated in HTML 4.0.

IDL Definition

interface HTMLIsIndexElement : HTMLElement {
  readonly attribute HTMLFormElement  form;
           attribute DOMString        prompt;
};

Attributes

form of type HTMLFormElement, readonly: Returns the FORM element containing this control. Returns null if this control is not within the context of a form.
prompt of type DOMString: The prompt message. See the prompt attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.

Interface HTMLStyleElement

Style information. See the STYLE element definition in HTML 4.0, the Document Object Model CSS module and the LinkStyle interface in the Document Object Model StyleSheets module.

IDL Definition

interface HTMLStyleElement : HTMLElement {
           attribute boolean          disabled;
           attribute DOMString        media;
           attribute DOMString        type;
};

Attributes

disabled of type boolean: Enables/disables the style sheet.
media of type DOMString: Designed for use with one or more target media. See the media attribute definition in HTML 4.0.
type of type DOMString: The content type pf the style sheet language. See the type attribute definition in HTML 4.0.

Interface HTMLBodyElement

The HTML document body. This element is always present in the DOM API, even if the tags are not present in the source document. See the BODY element definition in HTML 4.0.

IDL Definition

interface HTMLBodyElement : HTMLElement {
           attribute DOMString        aLink;
           attribute DOMString        background;
           attribute DOMString        bgColor;
           attribute DOMString        link;
           attribute DOMString        text;
           attribute DOMString        vLink;
};

Attributes

aLink of type DOMString: Color of active links (after mouse-button down, but before mouse-button up). See the alink attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.
background of type DOMString: URI of the background texture tile image. See the background attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.
bgColor of type DOMString: Document background color. See the bgcolor attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.
link of type DOMString: Color of links that are not active and unvisited. See the link attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.
text of type DOMString: Document text color. See the text attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.
vLink of type DOMString: Color of links that have been visited by the user. See the vlink attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.

Interface HTMLFormElement

The FORM element encompasses behavior similar to a collection and an element. It provides direct access to the contained input elements as well as the attributes of the form element. See the FORM element definition in HTML 4.0.

IDL Definition

interface HTMLFormElement : HTMLElement {
  readonly attribute HTMLCollection   elements;
  readonly attribute long             length;
           attribute DOMString        name;
           attribute DOMString        acceptCharset;
           attribute DOMString        action;
           attribute DOMString        enctype;
           attribute DOMString        method;
           attribute DOMString        target;
  void               submit();
  void               reset();
};

Attributes

acceptCharset of type DOMString: List of character sets supported by the server. See the accept-charset attribute definition in HTML 4.0.
action of type DOMString: Server-side form handler. See the action attribute definition in HTML 4.0.
elements of type HTMLCollection, readonly: Returns a collection of all control elements in the form.
enctype of type DOMString: The content type of the submitted form, generally "application/x-www-form-urlencoded". See the enctype attribute definition in HTML 4.0.
length of type long, readonly: The number of form controls in the form.
method of type DOMString: HTTP method used to submit form. See the method attribute definition in HTML 4.0.
name of type DOMString: Names the form.
target of type DOMString: Frame to render the resource in. See the target attribute definition in HTML 4.0.

Methods

reset: Restores a form element's default values. It performs the same action as a reset button.
No Parameters

No Return Value

No Exceptions
submit: Submits the form. It performs the same action as a submit button.
No Parameters

No Return Value

No Exceptions

Interface HTMLSelectElement

The select element allows the selection of an option. The contained options can be directly accessed through the select element as a collection. See the SELECT element definition in HTML 4.0.

IDL Definition

interface HTMLSelectElement : HTMLElement {
  readonly attribute DOMString        type;
           attribute long             selectedIndex;
           attribute DOMString        value;
  readonly attribute long             length;
  readonly attribute HTMLFormElement  form;
  readonly attribute HTMLCollection   options;
           attribute boolean          disabled;
           attribute boolean          multiple;
           attribute DOMString        name;
           attribute long             size;
           attribute long             tabIndex;
  void               add(in HTMLElement element, 
                         in HTMLElement before)
                                        raises(DOMException);
  void               remove(in long index);
  void               blur();
  void               focus();
};

Attributes

disabled of type boolean: The control is unavailable in this context. See the disabled attribute definition in HTML 4.0.
form of type HTMLFormElement, readonly: Returns the FORM element containing this control. Returns null if this control is not within the context of a form.
length of type long, readonly: The number of options in this SELECT.
multiple of type boolean: If true, multiple OPTION elements may be selected in this SELECT. See the multiple attribute definition in HTML 4.0.
name of type DOMString: Form control or object name when submitted with a form. See the name attribute definition in HTML 4.0.
options of type HTMLCollection, readonly: The collection of OPTION elements contained by this element.
selectedIndex of type long: The ordinal index of the selected option, starting from 0. The value -1 is returned if no element is selected. If multiple options are selected, the index of the first selected option is returned.
size of type long: Number of visible rows. See the size attribute definition in HTML 4.0.
tabIndex of type long: Index that represents the element's position in the tabbing order. See the tabindex attribute definition in HTML 4.0.
type of type DOMString, readonly: The type of this form control. This is the string "select-multiple" when the multiple attribute is true and the string "select-one" when false.
value of type DOMString: The current form control value.

Methods

add

Add a new element to the collection of OPTION elements for this SELECT. This method is the equivalent of the appendChild method of the Node interface if the before parameter is null. It is equivalent to the insertBefore method on the parent of before in all other cases.

Parameters

`HTMLElement`		`element`		The element to add.
`HTMLElement`		`before`		The element to insert before, or `null` for the tail of the list.

Exceptions

NOT_FOUND_ERR: Raised if before is not a descendant of the SELECT element.

No Return Value

blur

Removes keyboard focus from this element.

No Parameters

No Return Value

No Exceptions

focus

Gives keyboard focus to this element.

No Parameters

No Return Value

No Exceptions

remove

Remove an element from the collection of OPTION elements for this SELECT. Does nothing if no element has the given index.

Parameters

long

index

The index of the item to remove, starting from 0.

No Return Value

No Exceptions

Interface HTMLOptGroupElement

Group options together in logical subdivisions. See the OPTGROUP element definition in HTML 4.0.

IDL Definition

interface HTMLOptGroupElement : HTMLElement {
           attribute boolean          disabled;
           attribute DOMString        label;
};

Attributes

disabled of type boolean: The control is unavailable in this context. See the disabled attribute definition in HTML 4.0.
label of type DOMString: Assigns a label to this option group. See the label attribute definition in HTML 4.0.

Interface HTMLOptionElement

A selectable choice. See the OPTION element definition in HTML 4.0.

IDL Definition

interface HTMLOptionElement : HTMLElement {
  readonly attribute HTMLFormElement  form;
           attribute boolean          defaultSelected;
  readonly attribute DOMString        text;
  readonly attribute long             index;
           attribute boolean          disabled;
           attribute DOMString        label;
           attribute boolean          selected;
           attribute DOMString        value;
};

Attributes

defaultSelected of type boolean: Represents the value of the HTML selected attribute. The value of this attribute does not change if the state of the corresponding form control, in an interactive user agent, changes. Changing defaultSelected, however, resets the state of the form control. See the selected attribute definition in HTML 4.0.
disabled of type boolean: The control is unavailable in this context. See the disabled attribute definition in HTML 4.0.
form of type HTMLFormElement, readonly: Returns the FORM element containing this control. Returns null if this control is not within the context of a form.
index of type long, readonly: The index of this OPTION in its parent SELECT, starting from 0.
label of type DOMString: Option label for use in hierarchical menus. See the label attribute definition in HTML 4.0.
selected of type boolean: Represents the current state of the corresponding form control, in an interactive user agent. Changing this attribute changes the state of the form control, but does not change the value of the HTML selected attribute of the element.
text of type DOMString, readonly: The text contained within the option element.
value of type DOMString: The current form control value. See the value attribute definition in HTML 4.0.

Interface HTMLInputElement

Form control. Note. Depending upon the environment in which the page is being viewed, the value property may be read-only for the file upload input type. For the "password" input type, the actual value returned may be masked to prevent unauthorized use. See the INPUT element definition in HTML 4.0.

IDL Definition

interface HTMLInputElement : HTMLElement {
           attribute DOMString        defaultValue;
           attribute boolean          defaultChecked;
  readonly attribute HTMLFormElement  form;
           attribute DOMString        accept;
           attribute DOMString        accessKey;
           attribute DOMString        align;
           attribute DOMString        alt;
           attribute boolean          checked;
           attribute boolean          disabled;
           attribute long             maxLength;
           attribute DOMString        name;
           attribute boolean          readOnly;
           attribute DOMString        size;
           attribute DOMString        src;
           attribute long             tabIndex;
  readonly attribute DOMString        type;
           attribute DOMString        useMap;
           attribute DOMString        value;
  void               blur();
  void               focus();
  void               select();
  void               click();
};

Attributes

accept of type DOMString: A comma-separated list of content types that a server processing this form will handle correctly. See the accept attribute definition in HTML 4.0.
accessKey of type DOMString: A single character access key to give access to the form control. See the accesskey attribute definition in HTML 4.0.
align of type DOMString: Aligns this object (vertically or horizontally) with respect to its surrounding text. See the align attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.
alt of type DOMString: Alternate text for user agents not rendering the normal content of this element. See the alt attribute definition in HTML 4.0.
checked of type boolean: When the type attribute of the element has the value "Radio" or "Checkbox", this represents the current state of the form control, in an interactive user agent. Changes to this attribute change the state of the form control, but do not change the value of the HTML value attribute of the element.
defaultChecked of type boolean: When type has the value "Radio" or "Checkbox", this represents the HTML checked attribute of the element. The value of this attribute does not change if the state of the corresponding form control, in an interactive user agent, changes. Changes to this attribute, however, resets the state of the form control. See the checked attribute definition in HTML 4.0.
defaultValue of type DOMString: When the type attribute of the element has the value "Text", "File" or "Password", this represents the HTML value attribute of the element. The value of this attribute does not change if the contents of the corresponding form control, in an interactive user agent, changes. Changing this attribute, however, resets the contents of the form control. See the value attribute definition in HTML 4.0.
disabled of type boolean: The control is unavailable in this context. See the disabled attribute definition in HTML 4.0.
form of type HTMLFormElement, readonly: Returns the FORM element containing this control. Returns null if this control is not within the context of a form.
maxLength of type long: Maximum number of characters for text fields, when type has the value "Text" or "Password". See the maxlength attribute definition in HTML 4.0.
name of type DOMString: Form control or object name when submitted with a form. See the name attribute definition in HTML 4.0.
readOnly of type boolean: This control is read-only. Relevant only when type has the value "Text" or "Password". See the readonly attribute definition in HTML 4.0.
size of type DOMString: Size information. The precise meaning is specific to each type of field. See the size attribute definition in HTML 4.0.
src of type DOMString: When the type attribute has the value "Image", this attribute specifies the location of the image to be used to decorate the graphical submit button. See the src attribute definition in HTML 4.0.
tabIndex of type long: Index that represents the element's position in the tabbing order. See the tabindex attribute definition in HTML 4.0.
type of type DOMString, readonly: The type of control created. See the type attribute definition in HTML 4.0.
useMap of type DOMString: Use client-side image map. See the usemap attribute definition in HTML 4.0.
value of type DOMString: When the type attribute of the element has the value "Text", "File" or "Password", this represents the current contents of the corresponding form control, in an interactive user agent. Changing this attribute changes the contents of the form control, but does not change the value of the HTML value attribute of the element. When the type attribute of the element has the value "Button", "Hidden", "Submit", "Reset", "Image", "Checkbox" or "Radio", this represents the HTML value attribute of the element. See the value attribute definition in HTML 4.0.

Methods

blur: Removes keyboard focus from this element.
No Parameters

No Return Value

No Exceptions
click: Simulate a mouse-click. For INPUT elements whose type attribute has one of the following values: "Button", "Checkbox", "Radio", "Reset", or "Submit".
No Parameters

No Return Value

No Exceptions
focus: Gives keyboard focus to this element.
No Parameters

No Return Value

No Exceptions
select: Select the contents of the text area. For INPUT elements whose type attribute has one of the following values: "Text", "File", or "Password".
No Parameters

No Return Value

No Exceptions

Interface HTMLTextAreaElement

Multi-line text field. See the TEXTAREA element definition in HTML 4.0.

IDL Definition

interface HTMLTextAreaElement : HTMLElement {
           attribute DOMString        defaultValue;
  readonly attribute HTMLFormElement  form;
           attribute DOMString        accessKey;
           attribute long             cols;
           attribute boolean          disabled;
           attribute DOMString        name;
           attribute boolean          readOnly;
           attribute long             rows;
           attribute long             tabIndex;
  readonly attribute DOMString        type;
           attribute DOMString        value;
  void               blur();
  void               focus();
  void               select();
};

Attributes

accessKey of type DOMString: A single character access key to give access to the form control. See the accesskey attribute definition in HTML 4.0.
cols of type long: Width of control (in characters). See the cols attribute definition in HTML 4.0.
defaultValue of type DOMString: Represents the contents of the element. The value of this attribute does not change if the contents of the corresponding form control, in an interactive user agent, changes. Changing this attribute, however, resets the contents of the form control.
disabled of type boolean: The control is unavailable in this context. See the disabled attribute definition in HTML 4.0.
form of type HTMLFormElement, readonly: Returns the FORM element containing this control. Returns null if this control is not within the context of a form.
name of type DOMString: Form control or object name when submitted with a form. See the name attribute definition in HTML 4.0.
readOnly of type boolean: This control is read-only. See the readonly attribute definition in HTML 4.0.
rows of type long: Number of text rows. See the rows attribute definition in HTML 4.0.
tabIndex of type long: Index that represents the element's position in the tabbing order. See the tabindex attribute definition in HTML 4.0.
type of type DOMString, readonly: The type of this form control. This the string "textarea".
value of type DOMString: Represents the current contents of the corresponding form control, in an interactive user agent. Changing this attribute changes the contents of the form control, but does not change the contents of the element. If the entirety of the data can not fit into a single DOMString, the implementation may truncate the data.

Methods

blur: Removes keyboard focus from this element.
No Parameters

No Return Value

No Exceptions
focus: Gives keyboard focus to this element.
No Parameters

No Return Value

No Exceptions
select: Select the contents of the TEXTAREA.
No Parameters

No Return Value

No Exceptions

Interface HTMLButtonElement

Push button. See the BUTTON element definition in HTML 4.0.

IDL Definition

interface HTMLButtonElement : HTMLElement {
  readonly attribute HTMLFormElement  form;
           attribute DOMString        accessKey;
           attribute boolean          disabled;
           attribute DOMString        name;
           attribute long             tabIndex;
  readonly attribute DOMString        type;
           attribute DOMString        value;
};

Attributes

accessKey of type DOMString: A single character access key to give access to the form control. See the accesskey attribute definition in HTML 4.0.
disabled of type boolean: The control is unavailable in this context. See the disabled attribute definition in HTML 4.0.
form of type HTMLFormElement, readonly: Returns the FORM element containing this control. Returns null if this control is not within the context of a form.
name of type DOMString: Form control or object name when submitted with a form. See the name attribute definition in HTML 4.0.
tabIndex of type long: Index that represents the element's position in the tabbing order. See the tabindex attribute definition in HTML 4.0.
type of type DOMString, readonly: The type of button. See the type attribute definition in HTML 4.0.
value of type DOMString: The current form control value. See the value attribute definition in HTML 4.0.

Interface HTMLLabelElement

Form field label text. See the LABEL element definition in HTML 4.0.

IDL Definition

interface HTMLLabelElement : HTMLElement {
  readonly attribute HTMLFormElement  form;
           attribute DOMString        accessKey;
           attribute DOMString        htmlFor;
};

Attributes

accessKey of type DOMString: A single character access key to give access to the form control. See the accesskey attribute definition in HTML 4.0.
form of type HTMLFormElement, readonly: Returns the FORM element containing this control. Returns null if this control is not within the context of a form.
htmlFor of type DOMString: This attribute links this label with another form control by id attribute. See the for attribute definition in HTML 4.0.

Interface HTMLFieldSetElement

Organizes form controls into logical groups. See the FIELDSET element definition in HTML 4.0.

IDL Definition

interface HTMLFieldSetElement : HTMLElement {
  readonly attribute HTMLFormElement  form;
};

Attributes

form of type HTMLFormElement, readonly: Returns the FORM element containing this control. Returns null if this control is not within the context of a form.

Interface HTMLLegendElement

Provides a caption for a FIELDSET grouping. See the LEGEND element definition in HTML 4.0.

IDL Definition

interface HTMLLegendElement : HTMLElement {
  readonly attribute HTMLFormElement  form;
           attribute DOMString        accessKey;
           attribute DOMString        align;
};

Attributes

accessKey of type DOMString: A single character access key to give access to the form control. See the accesskey attribute definition in HTML 4.0.
align of type DOMString: Text alignment relative to FIELDSET. See the align attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.
form of type HTMLFormElement, readonly: Returns the FORM element containing this control. Returns null if this control is not within the context of a form.

Interface HTMLUListElement

Unordered list. See the UL element definition in HTML 4.0.

IDL Definition

interface HTMLUListElement : HTMLElement {
           attribute boolean          compact;
           attribute DOMString        type;
};

Attributes

compact of type boolean: Reduce spacing between list items. See the compact attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.
type of type DOMString: Bullet style. See the type attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.

Interface HTMLOListElement

Ordered list. See the OL element definition in HTML 4.0.

IDL Definition

interface HTMLOListElement : HTMLElement {
           attribute boolean          compact;
           attribute long             start;
           attribute DOMString        type;
};

Attributes

compact of type boolean: Reduce spacing between list items. See the compact attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.
start of type long: Starting sequence number. See the start attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.
type of type DOMString: Numbering style. See the type attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.

Interface HTMLDListElement

Definition list. See the DL element definition in HTML 4.0.

IDL Definition

interface HTMLDListElement : HTMLElement {
           attribute boolean          compact;
};

Attributes

compact of type boolean: Reduce spacing between list items. See the compact attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.

Interface HTMLDirectoryElement

Directory list. See the DIR element definition in HTML 4.0. This element is deprecated in HTML 4.0.

IDL Definition

interface HTMLDirectoryElement : HTMLElement {
           attribute boolean          compact;
};

Attributes

compact of type boolean: Reduce spacing between list items. See the compact attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.

Interface HTMLMenuElement

Menu list. See the MENU element definition in HTML 4.0. This element is deprecated in HTML 4.0.

IDL Definition

interface HTMLMenuElement : HTMLElement {
           attribute boolean          compact;
};

Attributes

compact of type boolean: Reduce spacing between list items. See the compact attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.

Interface HTMLLIElement

List item. See the LI element definition in HTML 4.0.

IDL Definition

interface HTMLLIElement : HTMLElement {
           attribute DOMString        type;
           attribute long             value;
};

Attributes

type of type DOMString: List item bullet style. See the type attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.
value of type long: Reset sequence number when used in OL. See the value attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.

Interface HTMLDivElement

Generic block container. See the DIV element definition in HTML 4.0.

IDL Definition

interface HTMLDivElement : HTMLElement {
           attribute DOMString        align;
};

Attributes

align of type DOMString: Horizontal text alignment. See the align attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.

Interface HTMLParagraphElement

Paragraphs. See the P element definition in HTML 4.0.

IDL Definition

interface HTMLParagraphElement : HTMLElement {
           attribute DOMString        align;
};

Attributes

align of type DOMString: Horizontal text alignment. See the align attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.

Interface HTMLHeadingElement

For the H1 to H6 elements. See the H1 element definition in HTML 4.0.

IDL Definition

interface HTMLHeadingElement : HTMLElement {
           attribute DOMString        align;
};

Attributes

align of type DOMString: Horizontal text alignment. See the align attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.

Interface HTMLQuoteElement

For the Q and BLOCKQUOTE elements. See the Q element definition in HTML 4.0.

IDL Definition

interface HTMLQuoteElement : HTMLElement {
           attribute DOMString        cite;
};

Attributes

cite of type DOMString: A URI designating a source document or message. See the cite attribute definition in HTML 4.0.

Interface HTMLPreElement

Preformatted text. See the PRE element definition in HTML 4.0.

IDL Definition

interface HTMLPreElement : HTMLElement {
           attribute long             width;
};

Attributes

width of type long: Fixed width for content. See the width attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.

Interface HTMLBRElement

Force a line break. See the BR element definition in HTML 4.0.

IDL Definition

interface HTMLBRElement : HTMLElement {
           attribute DOMString        clear;
};

Attributes

clear of type DOMString: Control flow of text around floats. See the clear attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.

Interface HTMLBaseFontElement

Base font. See the BASEFONT element definition in HTML 4.0. This element is deprecated in HTML 4.0.

IDL Definition

interface HTMLBaseFontElement : HTMLElement {
           attribute DOMString        color;
           attribute DOMString        face;
           attribute DOMString        size;
};

Attributes

color of type DOMString: Font color. See the color attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.
face of type DOMString: Font face identifier. See the face attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.
size of type DOMString: Font size. See the size attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.

Interface HTMLFontElement

Local change to font. See the FONT element definition in HTML 4.0. This element is deprecated in HTML 4.0.

IDL Definition

interface HTMLFontElement : HTMLElement {
           attribute DOMString        color;
           attribute DOMString        face;
           attribute DOMString        size;
};

Attributes

color of type DOMString: Font color. See the color attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.
face of type DOMString: Font face identifier. See the face attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.
size of type DOMString: Font size. See the size attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.

Interface HTMLHRElement

Create a horizontal rule. See the HR element definition in HTML 4.0.

IDL Definition

interface HTMLHRElement : HTMLElement {
           attribute DOMString        align;
           attribute boolean          noShade;
           attribute DOMString        size;
           attribute DOMString        width;
};

Attributes

align of type DOMString: Align the rule on the page. See the align attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.
noShade of type boolean: Indicates to the user agent that there should be no shading in the rendering of this element. See the noshade attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.
size of type DOMString: The height of the rule. See the size attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.
width of type DOMString: The width of the rule. See the width attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.

Interface HTMLModElement

Notice of modification to part of a document. See the INS and DEL element definitions in HTML 4.0.

IDL Definition

interface HTMLModElement : HTMLElement {
           attribute DOMString        cite;
           attribute DOMString        dateTime;
};

Attributes

cite of type DOMString: A URI designating a document that describes the reason for the change. See the cite attribute definition in HTML 4.0.
dateTime of type DOMString: The date and time of the change. See the datetime attribute definition in HTML 4.0.

Interface HTMLAnchorElement

The anchor element. See the A element definition in HTML 4.0.

IDL Definition

interface HTMLAnchorElement : HTMLElement {
           attribute DOMString        accessKey;
           attribute DOMString        charset;
           attribute DOMString        coords;
           attribute DOMString        href;
           attribute DOMString        hreflang;
           attribute DOMString        name;
           attribute DOMString        rel;
           attribute DOMString        rev;
           attribute DOMString        shape;
           attribute long             tabIndex;
           attribute DOMString        target;
           attribute DOMString        type;
  void               blur();
  void               focus();
};

Attributes

accessKey of type DOMString: A single character access key to give access to the form control. See the accesskey attribute definition in HTML 4.0.
charset of type DOMString: The character encoding of the linked resource. See the charset attribute definition in HTML 4.0.
coords of type DOMString: Comma-separated list of lengths, defining an active region geometry. See also shape for the shape of the region. See the coords attribute definition in HTML 4.0.
href of type DOMString: The URI of the linked resource. See the href attribute definition in HTML 4.0.
hreflang of type DOMString: Language code of the linked resource. See the hreflang attribute definition in HTML 4.0.
name of type DOMString: Anchor name. See the name attribute definition in HTML 4.0.
rel of type DOMString: Forward link type. See the rel attribute definition in HTML 4.0.
rev of type DOMString: Reverse link type. See the rev attribute definition in HTML 4.0.
shape of type DOMString: The shape of the active area. The coordinates are given by coords. See the shape attribute definition in HTML 4.0.
tabIndex of type long: Index that represents the element's position in the tabbing order. See the tabindex attribute definition in HTML 4.0.
target of type DOMString: Frame to render the resource in. See the target attribute definition in HTML 4.0.
type of type DOMString: Advisory content type. See the type attribute definition in HTML 4.0.

Methods

blur: Removes keyboard focus from this element.
No Parameters

No Return Value

No Exceptions
focus: Gives keyboard focus to this element.
No Parameters

No Return Value

No Exceptions

Interface HTMLImageElement

Embedded image. See the IMG element definition in HTML 4.0.

IDL Definition

interface HTMLImageElement : HTMLElement {
           attribute DOMString        lowSrc;
           attribute DOMString        name;
           attribute DOMString        align;
           attribute DOMString        alt;
           attribute DOMString        border;
           attribute DOMString        height;
           attribute DOMString        hspace;
           attribute boolean          isMap;
           attribute DOMString        longDesc;
           attribute DOMString        src;
           attribute DOMString        useMap;
           attribute DOMString        vspace;
           attribute DOMString        width;
};

Attributes

align of type DOMString: Aligns this object (vertically or horizontally) with respect to its surrounding text. See the align attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.
alt of type DOMString: Alternate text for user agents not rendering the normal content of this element. See the alt attribute definition in HTML 4.0.
border of type DOMString: Width of border around image. See the border attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.
height of type DOMString: Override height. See the height attribute definition in HTML 4.0.
hspace of type DOMString: Horizontal space to the left and right of this image. See the hspace attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.
isMap of type boolean: Use server-side image map. See the ismap attribute definition in HTML 4.0.
longDesc of type DOMString: URI designating a long description of this image or frame. See the longdesc attribute definition in HTML 4.0.
lowSrc of type DOMString: URI designating the source of this image, for low-resolution output.
name of type DOMString: The name of the element (for backwards compatibility).
src of type DOMString: URI designating the source of this image. See the src attribute definition in HTML 4.0.
useMap of type DOMString: Use client-side image map. See the usemap attribute definition in HTML 4.0.
vspace of type DOMString: Vertical space above and below this image. See the vspace attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.
width of type DOMString: Override width. See the width attribute definition in HTML 4.0.

Interface HTMLObjectElement

Generic embedded object. Note. In principle, all properties on the object element are read-write but in some environments some properties may be read-only once the underlying object is instantiated. See the OBJECT element definition in HTML 4.0.

IDL Definition

interface HTMLObjectElement : HTMLElement {
  readonly attribute HTMLFormElement  form;
           attribute DOMString        code;
           attribute DOMString        align;
           attribute DOMString        archive;
           attribute DOMString        border;
           attribute DOMString        codeBase;
           attribute DOMString        codeType;
           attribute DOMString        data;
           attribute boolean          declare;
           attribute DOMString        height;
           attribute DOMString        hspace;
           attribute DOMString        name;
           attribute DOMString        standby;
           attribute long             tabIndex;
           attribute DOMString        type;
           attribute DOMString        useMap;
           attribute DOMString        vspace;
           attribute DOMString        width;
  // Introduced in DOM Level 2:
           attribute Document         contentDocument;
};

Attributes

align of type DOMString: Aligns this object (vertically or horizontally) with respect to its surrounding text. See the align attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.
archive of type DOMString: Space-separated list of archives. See the archive attribute definition in HTML 4.0.
border of type DOMString: Width of border around the object. See the border attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.
code of type DOMString: Applet class file. See the code attribute for HTMLAppletElement.
codeBase of type DOMString: Base URI for classid, data, and archive attributes. See the codebase attribute definition in HTML 4.0.
codeType of type DOMString: Content type for data downloaded via classid attribute. See the codetype attribute definition in HTML 4.0.
contentDocument of type Document, introduced in DOM Level 2: The document this object contains, if there is any and it is available, or null otherwise.
data of type DOMString: A URI specifying the location of the object's data. See the data attribute definition in HTML 4.0.
declare of type boolean: Declare (for future reference), but do not instantiate, this object. See the declare attribute definition in HTML 4.0.
form of type HTMLFormElement, readonly: Returns the FORM element containing this control. Returns null if this control is not within the context of a form.
height of type DOMString: Override height. See the height attribute definition in HTML 4.0.
hspace of type DOMString: Horizontal space to the left and right of this image, applet, or object. See the hspace attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.
name of type DOMString: Form control or object name when submitted with a form. See the name attribute definition in HTML 4.0.
standby of type DOMString: Message to render while loading the object. See the standby attribute definition in HTML 4.0.
tabIndex of type long: Index that represents the element's position in the tabbing order. See the tabindex attribute definition in HTML 4.0.
type of type DOMString: Content type for data downloaded via data attribute. See the type attribute definition in HTML 4.0.
useMap of type DOMString: Use client-side image map. See the usemap attribute definition in HTML 4.0.
vspace of type DOMString: Vertical space above and below this image, applet, or object. See the vspace attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.
width of type DOMString: Override width. See the width attribute definition in HTML 4.0.

Interface HTMLParamElement

Parameters fed to the OBJECT element. See the PARAM element definition in HTML 4.0.

IDL Definition

interface HTMLParamElement : HTMLElement {
           attribute DOMString        name;
           attribute DOMString        type;
           attribute DOMString        value;
           attribute DOMString        valueType;
};

Attributes

name of type DOMString: The name of a run-time parameter. See the name attribute definition in HTML 4.0.
type of type DOMString: Content type for the value attribute when valuetype has the value "ref". See the type attribute definition in HTML 4.0.
value of type DOMString: The value of a run-time parameter. See the value attribute definition in HTML 4.0.
valueType of type DOMString: Information about the meaning of the value attribute value. See the valuetype attribute definition in HTML 4.0.

Interface HTMLAppletElement

An embedded Java applet. See the APPLET element definition in HTML 4.0. This element is deprecated in HTML 4.0.

IDL Definition

interface HTMLAppletElement : HTMLElement {
           attribute DOMString        align;
           attribute DOMString        alt;
           attribute DOMString        archive;
           attribute DOMString        code;
           attribute DOMString        codeBase;
           attribute DOMString        height;
           attribute DOMString        hspace;
           attribute DOMString        name;
           attribute DOMString        object;
           attribute DOMString        vspace;
           attribute DOMString        width;
};

Attributes

align of type DOMString: Aligns this object (vertically or horizontally) with respect to its surrounding text. See the align attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.
alt of type DOMString: Alternate text for user agents not rendering the normal content of this element. See the alt attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.
archive of type DOMString: Comma-separated archive list. See the archive attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.
code of type DOMString: Applet class file. See the code attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.
codeBase of type DOMString: Optional base URI for applet. See the codebase attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.
height of type DOMString: Override height. See the height attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.
hspace of type DOMString: Horizontal space to the left and right of this image, applet, or object. See the hspace attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.
name of type DOMString: The name of the applet. See the name attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.
object of type DOMString: Serialized applet file. See the object attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.
vspace of type DOMString: Vertical space above and below this image, applet, or object. See the vspace attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.
width of type DOMString: Override width. See the width attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.

Interface HTMLMapElement

Client-side image map. See the MAP element definition in HTML 4.0.

IDL Definition

interface HTMLMapElement : HTMLElement {
  readonly attribute HTMLCollection   areas;
           attribute DOMString        name;
};

Attributes

areas of type HTMLCollection, readonly: The list of areas defined for the image map.
name of type DOMString: Names the map (for use with usemap). See the name attribute definition in HTML 4.0.

Interface HTMLAreaElement

Client-side image map area definition. See the AREA element definition in HTML 4.0.

IDL Definition

interface HTMLAreaElement : HTMLElement {
           attribute DOMString        accessKey;
           attribute DOMString        alt;
           attribute DOMString        coords;
           attribute DOMString        href;
           attribute boolean          noHref;
           attribute DOMString        shape;
           attribute long             tabIndex;
           attribute DOMString        target;
};

Attributes

accessKey of type DOMString: A single character access key to give access to the form control. See the accesskey attribute definition in HTML 4.0.
alt of type DOMString: Alternate text for user agents not rendering the normal content of this element. See the alt attribute definition in HTML 4.0.
coords of type DOMString: Comma-separated list of lengths, defining an active region geometry. See also shape for the shape of the region. See the coords attribute definition in HTML 4.0.
href of type DOMString: The URI of the linked resource. See the href attribute definition in HTML 4.0.
noHref of type boolean: Specifies that this area is inactive, i.e., has no associated action. See the nohref attribute definition in HTML 4.0.
shape of type DOMString: The shape of the active area. The coordinates are given by coords. See the shape attribute definition in HTML 4.0.
tabIndex of type long: Index that represents the element's position in the tabbing order. See the tabindex attribute definition in HTML 4.0.
target of type DOMString: Frame to render the resource in. See the target attribute definition in HTML 4.0.

Interface HTMLScriptElement

Script statements. See the SCRIPT element definition in HTML 4.0.

IDL Definition

interface HTMLScriptElement : HTMLElement {
           attribute DOMString        text;
           attribute DOMString        htmlFor;
           attribute DOMString        event;
           attribute DOMString        charset;
           attribute boolean          defer;
           attribute DOMString        src;
           attribute DOMString        type;
};

Attributes

charset of type DOMString: The character encoding of the linked resource. See the charset attribute definition in HTML 4.0.
defer of type boolean: Indicates that the user agent can defer processing of the script. See the defer attribute definition in HTML 4.0.
event of type DOMString: Reserved for future use.
htmlFor of type DOMString: Reserved for future use.
src of type DOMString: URI designating an external script. See the src attribute definition in HTML 4.0.
text of type DOMString: The script content of the element.
type of type DOMString: The content type of the script language. See the type attribute definition in HTML 4.0.

Interface HTMLTableElement

The create* and delete* methods on the table allow authors to construct and modify tables. HTML 4.0 specifies that only one of each of the CAPTION, THEAD, and TFOOT elements may exist in a table. Therefore, if one exists, and the createTHead() or createTFoot() method is called, the method returns the existing THead or TFoot element. See the TABLE element definition in HTML 4.0.

IDL Definition

interface HTMLTableElement : HTMLElement {
           attribute HTMLTableCaptionElement  caption;
           attribute HTMLTableSectionElement  tHead;
           attribute HTMLTableSectionElement  tFoot;
  readonly attribute HTMLCollection   rows;
  readonly attribute HTMLCollection   tBodies;
           attribute DOMString        align;
           attribute DOMString        bgColor;
           attribute DOMString        border;
           attribute DOMString        cellPadding;
           attribute DOMString        cellSpacing;
           attribute DOMString        frame;
           attribute DOMString        rules;
           attribute DOMString        summary;
           attribute DOMString        width;
  HTMLElement        createTHead();
  void               deleteTHead();
  HTMLElement        createTFoot();
  void               deleteTFoot();
  HTMLElement        createCaption();
  void               deleteCaption();
  HTMLElement        insertRow(in long index)
                                        raises(DOMException);
  void               deleteRow(in long index)
                                        raises(DOMException);
};

Attributes

align of type DOMString: Specifies the table's position with respect to the rest of the document. See the align attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.
bgColor of type DOMString: Cell background color. See the bgcolor attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.
border of type DOMString: The width of the border around the table. See the border attribute definition in HTML 4.0.
caption of type HTMLTableCaptionElement: Returns the table's CAPTION, or void if none exists.
cellPadding of type DOMString: Specifies the horizontal and vertical space between cell content and cell borders. See the cellpadding attribute definition in HTML 4.0.
cellSpacing of type DOMString: Specifies the horizontal and vertical separation between cells. See the cellspacing attribute definition in HTML 4.0.
frame of type DOMString: Specifies which external table borders to render. See the frame attribute definition in HTML 4.0.
rows of type HTMLCollection, readonly: Returns a collection of all the rows in the table, including all in THEAD, TFOOT, all TBODY elements.
rules of type DOMString: Specifies which internal table borders to render. See the rules attribute definition in HTML 4.0.
summary of type DOMString: Description about the purpose or structure of a table. See the summary attribute definition in HTML 4.0.
tBodies of type HTMLCollection, readonly: Returns a collection of the defined table bodies.
tFoot of type HTMLTableSectionElement: Returns the table's TFOOT, or null if none exists.
tHead of type HTMLTableSectionElement: Returns the table's THEAD, or null if none exists.
width of type DOMString: Specifies the desired table width. See the width attribute definition in HTML 4.0.

Methods

createCaption

Create a new table caption object or return an existing one.

Return Value

A CAPTION element.

No Parameters

No Exceptions

createTFoot

Create a table footer row or return an existing one.

Return Value

A footer element (TFOOT).

No Parameters

No Exceptions

createTHead

Create a table header row or return an existing one.

Return Value

A new table header element (THEAD).

No Parameters

No Exceptions

deleteCaption

Delete the table caption, if one exists.

No Parameters

No Return Value

No Exceptions

deleteRow

Delete a table row.

Parameters

long

index

The index of the row to be deleted. This index starts from 0 and is relative to all the rows contained inside the table, regardless of section parentage.

Exceptions

INDEX_SIZE_ERR: Raised if the specified index is greater than or equal to the number of rows or if the index is negative.

No Return Value

deleteTFoot

Delete the footer from the table, if one exists.

No Parameters

No Return Value

No Exceptions

deleteTHead

Delete the header from the table, if one exists.

No Parameters

No Return Value

No Exceptions

insertRow

Insert a new empty row in the table. The new row is inserted immediately before and in the same section as the current indexth row in the table. If index is equal to the number of rows, the new row is appended. In addition, when the table is empty the row is inserted into a TBODY which is created and inserted into the table. Note. A table row cannot be empty according to HTML 4.0 Recommendation.

Parameters

long

index

The row number where to insert a new row. This index starts from 0 and is relative to all the rows contained inside the table, regardless of section parentage.

Return Value

The newly created row.

Exceptions

INDEX_SIZE_ERR: Raised if the specified index is greater than the number of rows or if the index is negative.

Interface HTMLTableCaptionElement

Table caption See the CAPTION element definition in HTML 4.0.

IDL Definition

interface HTMLTableCaptionElement : HTMLElement {
           attribute DOMString        align;
};

Attributes

align of type DOMString: Caption alignment with respect to the table. See the align attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.

Interface HTMLTableColElement

Regroups the COL and COLGROUP elements. See the COL element definition in HTML 4.0.

IDL Definition

interface HTMLTableColElement : HTMLElement {
           attribute DOMString        align;
           attribute DOMString        ch;
           attribute DOMString        chOff;
           attribute long             span;
           attribute DOMString        vAlign;
           attribute DOMString        width;
};

Attributes

align of type DOMString: Horizontal alignment of cell data in column. See the align attribute definition in HTML 4.0.
ch of type DOMString: Alignment character for cells in a column. See the char attribute definition in HTML 4.0.
chOff of type DOMString: Offset of alignment character. See the charoff attribute definition in HTML 4.0.
span of type long: Indicates the number of columns in a group or affected by a grouping. See the span attribute definition in HTML 4.0.
vAlign of type DOMString: Vertical alignment of cell data in column. See the valign attribute definition in HTML 4.0.
width of type DOMString: Default column width. See the width attribute definition in HTML 4.0.

Interface HTMLTableSectionElement

The THEAD, TFOOT, and TBODY elements.

IDL Definition

interface HTMLTableSectionElement : HTMLElement {
           attribute DOMString        align;
           attribute DOMString        ch;
           attribute DOMString        chOff;
           attribute DOMString        vAlign;
  readonly attribute HTMLCollection   rows;
  HTMLElement        insertRow(in long index)
                                        raises(DOMException);
  void               deleteRow(in long index)
                                        raises(DOMException);
};

Attributes

align of type DOMString: Horizontal alignment of data in cells. See the align attribute for HTMLTheadElement for details.
ch of type DOMString: Alignment character for cells in a column. See the char attribute definition in HTML 4.0.
chOff of type DOMString: Offset of alignment character. See the charoff attribute definition in HTML 4.0.
rows of type HTMLCollection, readonly: The collection of rows in this table section.
vAlign of type DOMString: Vertical alignment of data in cells. See the valign attribute for HTMLTheadElement for details.

Methods

deleteRow

Delete a row from this section.

Parameters

long

index

The index of the row to be deleted. This index starts from 0 and is relative only to the rows contained inside this section, not all the rows in the table.

Exceptions

INDEX_SIZE_ERR: Raised if the specified index is greater than or equal to the number of rows or if the index is negative.

No Return Value

insertRow

Insert a row into this section. The new row is inserted immediately before the current indexth row in this section. If index is equal to the number of rows in this section, the new row is appended.

Parameters

long

index

The row number where to insert a new row. This index starts from 0 and is relative only to the rows contained inside this section, not all the rows in the table.

Return Value

The newly created row.

Exceptions

INDEX_SIZE_ERR: Raised if the specified index is greater than the number of rows of if the index is neagative.

Interface HTMLTableRowElement

A row in a table. See the TR element definition in HTML 4.0.

IDL Definition

interface HTMLTableRowElement : HTMLElement {
  readonly attribute long             rowIndex;
  readonly attribute long             sectionRowIndex;
  readonly attribute HTMLCollection   cells;
           attribute DOMString        align;
           attribute DOMString        bgColor;
           attribute DOMString        ch;
           attribute DOMString        chOff;
           attribute DOMString        vAlign;
  HTMLElement        insertCell(in long index)
                                        raises(DOMException);
  void               deleteCell(in long index)
                                        raises(DOMException);
};

Attributes

align of type DOMString: Horizontal alignment of data within cells of this row. See the align attribute definition in HTML 4.0.
bgColor of type DOMString: Background color for rows. See the bgcolor attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.
cells of type HTMLCollection, readonly: The collection of cells in this row.
ch of type DOMString: Alignment character for cells in a column. See the char attribute definition in HTML 4.0.
chOff of type DOMString: Offset of alignment character. See the charoff attribute definition in HTML 4.0.
rowIndex of type long, readonly: The index of this row, relative to the entire table, starting from 0. This is in document tree order and not display order. The rowIndex does not take into account sections (THEAD, TFOOT, or TBODY) within the table.
sectionRowIndex of type long, readonly: The index of this row, relative to the current section (THEAD, TFOOT, or TBODY), starting from 0.
vAlign of type DOMString: Vertical alignment of data within cells of this row. See the valign attribute definition in HTML 4.0.

Methods

deleteCell

Delete a cell from the current row.

Parameters

long

index

The index of the cell to delete, starting from 0.

Exceptions

INDEX_SIZE_ERR: Raised if the specified index is greater than or equal to the number of cells or if the index is negative.

No Return Value

insertCell

Insert an empty TD cell into this row. If index is equal to the number of cells, the new cell is appended

Parameters

long

index

The place to insert the cell, starting from 0.

Return Value

The newly created cell.

Exceptions

INDEX_SIZE_ERR: Raised if the specified index is greater than the number of cells or if the index is negative.

Interface HTMLTableCellElement

The object used to represent the TH and TD elements. See the TD element definition in HTML 4.0.

IDL Definition

interface HTMLTableCellElement : HTMLElement {
  readonly attribute long             cellIndex;
           attribute DOMString        abbr;
           attribute DOMString        align;
           attribute DOMString        axis;
           attribute DOMString        bgColor;
           attribute DOMString        ch;
           attribute DOMString        chOff;
           attribute long             colSpan;
           attribute DOMString        headers;
           attribute DOMString        height;
           attribute boolean          noWrap;
           attribute long             rowSpan;
           attribute DOMString        scope;
           attribute DOMString        vAlign;
           attribute DOMString        width;
};

Attributes

abbr of type DOMString: Abbreviation for header cells. See the abbr attribute definition in HTML 4.0.
align of type DOMString: Horizontal alignment of data in cell. See the align attribute definition in HTML 4.0.
axis of type DOMString: Names group of related headers. See the axis attribute definition in HTML 4.0.
bgColor of type DOMString: Cell background color. See the bgcolor attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.
cellIndex of type long, readonly: The index of this cell in the row, starting from 0. This index is in document tree order and not display order.
ch of type DOMString: Alignment character for cells in a column. See the char attribute definition in HTML 4.0.
chOff of type DOMString: Offset of alignment character. See the charoff attribute definition in HTML 4.0.
colSpan of type long: Number of columns spanned by cell. See the colspan attribute definition in HTML 4.0.
headers of type DOMString: List of id attribute values for header cells. See the headers attribute definition in HTML 4.0.
height of type DOMString: Cell height. See the height attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.
noWrap of type boolean: Suppress word wrapping. See the nowrap attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.
rowSpan of type long: Number of rows spanned by cell. See the rowspan attribute definition in HTML 4.0.
scope of type DOMString: Scope covered by header cells. See the scope attribute definition in HTML 4.0.
vAlign of type DOMString: Vertical alignment of data in cell. See the valign attribute definition in HTML 4.0.
width of type DOMString: Cell width. See the width attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.

Interface HTMLFrameSetElement

Create a grid of frames. See the FRAMESET element definition in HTML 4.0.

IDL Definition

interface HTMLFrameSetElement : HTMLElement {
           attribute DOMString        cols;
           attribute DOMString        rows;
};

Attributes

cols of type DOMString: The number of columns of frames in the frameset. See the cols attribute definition in HTML 4.0.
rows of type DOMString: The number of rows of frames in the frameset. See the rows attribute definition in HTML 4.0.

Interface HTMLFrameElement

Create a frame. See the FRAME element definition in HTML 4.0.

IDL Definition

interface HTMLFrameElement : HTMLElement {
           attribute DOMString        frameBorder;
           attribute DOMString        longDesc;
           attribute DOMString        marginHeight;
           attribute DOMString        marginWidth;
           attribute DOMString        name;
           attribute boolean          noResize;
           attribute DOMString        scrolling;
           attribute DOMString        src;
  // Introduced in DOM Level 2:
           attribute Document         contentDocument;
};

Attributes

contentDocument of type Document, introduced in DOM Level 2: The document this frame contains, if there is any and it is available, or null otherwise.
frameBorder of type DOMString: Request frame borders. See the frameborder attribute definition in HTML 4.0.
longDesc of type DOMString: URI designating a long description of this image or frame. See the longdesc attribute definition in HTML 4.0.
marginHeight of type DOMString: Frame margin height, in pixels. See the marginheight attribute definition in HTML 4.0.
marginWidth of type DOMString: Frame margin width, in pixels. See the marginwidth attribute definition in HTML 4.0.
name of type DOMString: The frame name (object of the target attribute). See the name attribute definition in HTML 4.0.
noResize of type boolean: When true, forbid user from resizing frame. See the noresize attribute definition in HTML 4.0.
scrolling of type DOMString: Specify whether or not the frame should have scrollbars. See the scrolling attribute definition in HTML 4.0.
src of type DOMString: A URI designating the initial frame contents. See the src attribute definition in HTML 4.0.

Interface HTMLIFrameElement

Inline subwindows. See the IFRAME element definition in HTML 4.0.

IDL Definition

interface HTMLIFrameElement : HTMLElement {
           attribute DOMString        align;
           attribute DOMString        frameBorder;
           attribute DOMString        height;
           attribute DOMString        longDesc;
           attribute DOMString        marginHeight;
           attribute DOMString        marginWidth;
           attribute DOMString        name;
           attribute DOMString        scrolling;
           attribute DOMString        src;
           attribute DOMString        width;
  // Introduced in DOM Level 2:
           attribute Document         contentDocument;
};

Attributes

align of type DOMString: Aligns this object (vertically or horizontally) with respect to its surrounding text. See the align attribute definition in HTML 4.0. This attribute is deprecated in HTML 4.0.
contentDocument of type Document, introduced in DOM Level 2: The document this frame contains, if there is any and it is available, or null otherwise.
frameBorder of type DOMString: Request frame borders. See the frameborder attribute definition in HTML 4.0.
height of type DOMString: Frame height. See the height attribute definition in HTML 4.0.
longDesc of type DOMString: URI designating a long description of this image or frame. See the longdesc attribute definition in HTML 4.0.
marginHeight of type DOMString: Frame margin height, in pixels. See the marginheight attribute definition in HTML 4.0.
marginWidth of type DOMString: Frame margin width, in pixels. See the marginwidth attribute definition in HTML 4.0.
name of type DOMString: The frame name (object of the target attribute). See the name attribute definition in HTML 4.0.
scrolling of type DOMString: Specify whether or not the frame should have scrollbars. See the scrolling attribute definition in HTML 4.0.
src of type DOMString: A URI designating the initial frame contents. See the src attribute definition in HTML 4.0.
width of type DOMString: Frame width. See the width attribute definition in HTML 4.0.

5. Document Object Model CSS

Editors: Vidur Apparao, Netscape Communications Corp.; Philippe Le Hégaret, W3C; Chris Wilson, Microsoft

5.1. Overview of the DOM Level 2 CSS Interfaces

The DOM Level 2 Cascading Style Sheets (CSS) interfaces are designed with the goal of exposing CSS constructs to object model consumers. Cascading Style Sheets is a declarative syntax for defining presentation rules, properties and ancillary constructs used to format and render Web documents. This document specifies a mechanism to programmatically access and modify the rich style and presentation control provided by CSS (specifically CSS level 2 [CSS2]). This augments CSS by providing a mechanism to dynamically control the inclusion and exclusion of individual style sheets, as well as manipulate CSS rules and properties.

The CSS interfaces are organized in a logical, rather than physical structure. A collection of all style sheets referenced by or embedded in the document is accessible on the document interface. Each item in this collection exposes the properties common to all style sheets referenced or embedded in HTML and XML documents; this interface is described in the Document Object Model StyleSheets. User style sheets are not accessible through this collection, in part due to potential privacy concerns (and certainly read-write issues).

For each CSS style sheet, an additional interface is exposed - the CSSStyleSheet interface. This interface allows access to the collection of rules within a CSS style sheet and methods to modify that collection. Interfaces are provided for each specific type of rule in CSS2 (e.g. style declarations, @import rules, or @font-face rules), as well as a shared generic CSSRule interface.

The most common type of rule is a style declaration. The CSSStyleRule interface that represents this type of rule provides string access to the CSS selector of the rule, and access to the property declarations through the CSSStyleDeclaration interface.

Finally, an optional CSS2Properties interface is described; this interface (if implemented) provides shortcuts to the string values of all the properties in CSS level 2.

All CSS objects in the DOM are "live", that is, a change in the style sheet is reflected in the computed and actual style.

A DOM application can use the hasFeature method of the DOMImplementation interface to determine whether the CSS interfaces are supported or not. The feature string for the CSS Model is "CSS". The existence within an implementation of the extended interfaces can also be queried using the hasFeature method.

5.2. CSS Fundamental Interfaces

The interfaces within this section are considered fundamental, and must be supported by all conforming DOM implementations. These interfaces represent CSS style sheets specifically.

Interface CSSStyleSheet (introduced in DOM Level 2)

The CSSStyleSheet interface is a concrete interface used to represent a CSS style sheet i.e., a style sheet whose content type is "text/css".

IDL Definition

// Introduced in DOM Level 2:
interface CSSStyleSheet : stylesheets::StyleSheet {
  readonly attribute CSSRule          ownerRule;
  readonly attribute CSSRuleList      cssRules;
  unsigned long      insertRule(in DOMString rule, 
                                in unsigned long index)
                                        raises(DOMException);
  void               deleteRule(in unsigned long index)
                                        raises(DOMException);
};

Attributes

cssRules of type CSSRuleList, readonly: The list of all CSS rules contained within the style sheet. This includes both rule sets and at-rules.
ownerRule of type CSSRule, readonly: If this style sheet comes from an @import rule, the ownerRule attribute will contain the CSSImportRule. In that case, the ownerNode attribute in the StyleSheet interface will be null. If the style sheet comes from an element or a processing instruction, the ownerRule attribute will be null and the ownerNode attribute will contain the Node.

Methods

deleteRule

Used to delete a rule from the style sheet.

Parameters

unsigned long

index

The index within the style sheet's rule list of the rule to remove.

Exceptions

INDEX_SIZE_ERR: Raised if the specified index does not correspond to a rule in the style sheet's rule list.

NO_MODIFICATION_ALLOWED_ERR: Raised if this style sheet is readonly.

No Return Value

insertRule

Used to insert a new rule into the style sheet. The new rule now becomes part of the cascade.

Parameters

`DOMString`		`rule`		The parsable text representing the rule. For rule sets this contains both the selector and the style declaration. For at-rules, this specifies both the at-identifier and the rule content.
`unsigned long`		`index`		The index within the style sheet's rule list of the rule before which to insert the specified rule. If the specified index is equal to the length of the style sheet's rule collection, the rule will be added to the end of the style sheet.

Return Value

unsigned long

The index within the style sheet's rule collection of the newly inserted rule.

Exceptions

HIERARCHY_REQUEST_ERR: Raised if the rule cannot be inserted at the specified index e.g. if an @import rule is inserted after a standard rule set or other at-rule.

INDEX_SIZE_ERR: Raised if the specified index is not a valid insertion point.

NO_MODIFICATION_ALLOWED_ERR: Raised if this style sheet is readonly.

SYNTAX_ERR: Raised if the specified rule has a syntax error and is unparsable.

Interface CSSRuleList (introduced in DOM Level 2)

The CSSRuleList interface provides the abstraction of an ordered collection of CSS rules.

IDL Definition

// Introduced in DOM Level 2:
interface CSSRuleList {
  readonly attribute unsigned long    length;
  CSSRule            item(in unsigned long index);
};

Attributes

length of type unsigned long, readonly: The number of CSSRules in the list. The range of valid child rule indices is 0 to length-1 inclusive.

Methods

item

Used to retrieve a CSS rule by ordinal index. The order in this collection represents the order of the rules in the CSS style sheet.

Parameters

unsigned long

index

Index into the collection

Return Value

CSSRule

The style rule at the index position in the CSSRuleList, or null if that is not a valid index.

No Exceptions

Interface CSSRule (introduced in DOM Level 2)

The CSSRule interface is the abstract base interface for any type of CSS statement. This includes both rule sets and at-rules. An implementation is expected to preserve all rules specified in a CSS style sheet, even if the rule is not recognized by the parser. Unrecognized rules are represented using the CSSUnknownRule interface.

IDL Definition

// Introduced in DOM Level 2:
interface CSSRule {
  // RuleType
  const unsigned short      UNKNOWN_RULE                   = 0;
  const unsigned short      STYLE_RULE                     = 1;
  const unsigned short      CHARSET_RULE                   = 2;
  const unsigned short      IMPORT_RULE                    = 3;
  const unsigned short      MEDIA_RULE                     = 4;
  const unsigned short      FONT_FACE_RULE                 = 5;
  const unsigned short      PAGE_RULE                      = 6;

  readonly attribute unsigned short   type;
           attribute DOMString        cssText;
                                        // raises(DOMException) on setting

  readonly attribute CSSStyleSheet    parentStyleSheet;
  readonly attribute CSSRule          parentRule;
};

Definition group RuleType

An integer indicating which type of rule this is.

Defined Constants

CHARSET_RULE	The rule is a `CSSCharsetRule`.
FONT_FACE_RULE	The rule is a `CSSFontFaceRule`.
IMPORT_RULE	The rule is a `CSSImportRule`.
MEDIA_RULE	The rule is a `CSSMediaRule`.
PAGE_RULE	The rule is a `CSSPageRule`.
STYLE_RULE	The rule is a `CSSStyleRule`.
UNKNOWN_RULE	The rule is a `CSSUnknownRule`.

Attributes

cssText of type DOMString

The parsable textual representation of the rule. This reflects the current state of the rule and not its initial value.

Exceptions on setting

SYNTAX_ERR: Raised if the specified CSS string value has a syntax error and is unparsable.

INVALID_MODIFICATION_ERR: Raised if the specified CSS string value represents a different type of rule than the current one.

HIERARCHY_REQUEST_ERR: Raised if the rule cannot be inserted at this point in the style sheet.

NO_MODIFICATION_ALLOWED_ERR: Raised if the rule is readonly.

parentRule of type CSSRule, readonly

If this rule is contained inside another rule (e.g. a style rule inside an @media block), this is the containing rule. If this rule is not nested inside any other rules, this returns null.

parentStyleSheet of type CSSStyleSheet, readonly

The style sheet that contains this rule.

type of type unsigned short, readonly

The type of the rule, as defined above. The expectation is that binding-specific casting methods can be used to cast down from an instance of the CSSRule interface to the specific derived interface implied by the type.

Interface CSSStyleRule (introduced in DOM Level 2)

The CSSStyleRule interface represents a single rule set in a CSS style sheet.

IDL Definition

// Introduced in DOM Level 2:
interface CSSStyleRule : CSSRule {
           attribute DOMString        selectorText;
                                        // raises(DOMException) on setting

  readonly attribute CSSStyleDeclaration  style;
};

Attributes

selectorText of type DOMString

The textual representation of the selector for the rule set. The implementation may have stripped out insignificant whitespace while parsing the selector.

Exceptions on setting

SYNTAX_ERR: Raised if the specified CSS string value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this rule is readonly.

style of type CSSStyleDeclaration, readonly

The declaration-block of this rule set.

Interface CSSMediaRule (introduced in DOM Level 2)

The CSSMediaRule interface represents a @media rule in a CSS style sheet. A @media rule can be used to delimit style rules for specific media types.

IDL Definition

// Introduced in DOM Level 2:
interface CSSMediaRule : CSSRule {
  readonly attribute stylesheets::MediaList  media;
  readonly attribute CSSRuleList      cssRules;
  unsigned long      insertRule(in DOMString rule, 
                                in unsigned long index)
                                        raises(DOMException);
  void               deleteRule(in unsigned long index)
                                        raises(DOMException);
};

Attributes

cssRules of type CSSRuleList, readonly: A list of all CSS rules contained within the media block.
media of type stylesheets::MediaList, readonly: A list of media types for this rule.

Methods

deleteRule

Used to delete a rule from the media block.

Parameters

unsigned long

index

The index within the media block's rule collection of the rule to remove.

Exceptions

INDEX_SIZE_ERR: Raised if the specified index does not correspond to a rule in the media rule list.

NO_MODIFICATION_ALLOWED_ERR: Raised if this media rule is readonly.

No Return Value

insertRule

Used to insert a new rule into the media block.

Parameters

`DOMString`		`rule`		The parsable text representing the rule. For rule sets this contains both the selector and the style declaration. For at-rules, this specifies both the at-identifier and the rule content.
`unsigned long`		`index`		The index within the media block's rule collection of the rule before which to insert the specified rule. If the specified index is equal to the length of the media blocks's rule collection, the rule will be added to the end of the media block.

Return Value

unsigned long

The index within the media block's rule collection of the newly inserted rule.

Exceptions

HIERARCHY_REQUEST_ERR: Raised if the rule cannot be inserted at the specified index, e.g., if an @import rule is inserted after a standard rule set or other at-rule.

INDEX_SIZE_ERR: Raised if the specified index is not a valid insertion point.

NO_MODIFICATION_ALLOWED_ERR: Raised if this media rule is readonly.

SYNTAX_ERR: Raised if the specified rule has a syntax error and is unparsable.

Interface CSSFontFaceRule (introduced in DOM Level 2)

The CSSFontFaceRule interface represents a @font-face rule in a CSS style sheet. The @font-face rule is used to hold a set of font descriptions.

IDL Definition

// Introduced in DOM Level 2:
interface CSSFontFaceRule : CSSRule {
  readonly attribute CSSStyleDeclaration  style;
};

Attributes

style of type CSSStyleDeclaration, readonly: The declaration-block of this rule.

Interface CSSPageRule (introduced in DOM Level 2)

The CSSPageRule interface represents a @page rule within a CSS style sheet. The @page rule is used to specify the dimensions, orientation, margins, etc. of a page box for paged media.

IDL Definition

// Introduced in DOM Level 2:
interface CSSPageRule : CSSRule {
           attribute DOMString        selectorText;
                                        // raises(DOMException) on setting

  readonly attribute CSSStyleDeclaration  style;
};

Attributes

selectorText of type DOMString

The parsable textual representation of the page selector for the rule.

Exceptions on setting

SYNTAX_ERR: Raised if the specified CSS string value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this rule is readonly.

style of type CSSStyleDeclaration, readonly

The declaration-block of this rule.

Interface CSSImportRule (introduced in DOM Level 2)

The CSSImportRule interface represents a @import rule within a CSS style sheet. The @import rule is used to import style rules from other style sheets.

IDL Definition

// Introduced in DOM Level 2:
interface CSSImportRule : CSSRule {
  readonly attribute DOMString        href;
  readonly attribute stylesheets::MediaList  media;
  readonly attribute CSSStyleSheet    styleSheet;
};

Attributes

href of type DOMString, readonly: The location of the style sheet to be imported. The attribute will not contain the "url(...)" specifier around the URI.
media of type stylesheets::MediaList, readonly: A list of media types for which this style sheet may be used.
styleSheet of type CSSStyleSheet, readonly: The style sheet referred to by this rule, if it has been loaded. The value of this attribute is null if the style sheet has not yet been loaded or if it will not be loaded (e.g. if the style sheet is for a media type not supported by the user agent).

Interface CSSCharsetRule (introduced in DOM Level 2)

The CSSCharsetRule interface represents a @charset rule in a CSS style sheet. The value of the encoding attribute does not at all affect the encoding of text data in the DOM objects; this encoding is always UTF-16. After a stylesheet is loaded, the value of the encoding attribute is the value found in the @charset rule. If there was no @charset in the original document, then no CSSCharsetRule is created. The value of the encoding attribute may also be used as a hint for the encoding used on serialization of the style sheet.

The value of the @charset rule (and therefore of the CSSCharsetRule) may not correspond to the encoding the document actually came in; character encoding information e.g. in an HTTP header, has priority (see http://www.w3.org/TR/1998/REC-CSS2-19980512/syndata.html#x66) but is not reflected in the CSSCharsetRule.

IDL Definition

// Introduced in DOM Level 2:
interface CSSCharsetRule : CSSRule {
           attribute DOMString        encoding;
                                        // raises(DOMException) on setting

};

Attributes

encoding of type DOMString

The encoding information used in this @charset rule.

Exceptions on setting

SYNTAX_ERR: Raised if the specified encoding value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this encoding rule is readonly.

Interface CSSUnknownRule (introduced in DOM Level 2)

The CSSUnknownRule interface represents an at-rule not supported by this user agent.

IDL Definition

// Introduced in DOM Level 2:
interface CSSUnknownRule : CSSRule {
};

Interface CSSStyleDeclaration (introduced in DOM Level 2)

The CSSStyleDeclaration interface represents a single CSS declaration block. This interface may be used to determine the style properties currently set in a block or to set style properties explicitly within the block.

While an implementation may not recognize all CSS properties within a CSS declaration block, it is expected to provide access to all specified properties through the CSSStyleDeclaration interface. Furthermore, implementations that support a specific level of CSS should correctly handle CSS shorthand properties for that level. For a further discussion of shorthand properties, see the CSS2Properties interface.

IDL Definition

// Introduced in DOM Level 2:
interface CSSStyleDeclaration {
           attribute DOMString        cssText;
                                        // raises(DOMException) on setting

  DOMString          getPropertyValue(in DOMString propertyName);
  CSSValue           getPropertyCSSValue(in DOMString propertyName);
  DOMString          removeProperty(in DOMString propertyName)
                                        raises(DOMException);
  DOMString          getPropertyPriority(in DOMString propertyName);
  void               setProperty(in DOMString propertyName, 
                                 in DOMString value, 
                                 in DOMString priority)
                                        raises(DOMException);
  readonly attribute unsigned long    length;
  DOMString          item(in unsigned long index);
  readonly attribute CSSRule          parentRule;
};

Attributes

cssText of type DOMString

The parsable textual representation of the declaration block (excluding the surrounding curly braces). Setting this attribute will result in the parsing of the new value and resetting of the properties in the declaration block.

Exceptions on setting

getPropertyCSSValue

SYNTAX_ERR: Raised if the specified CSS string value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this declaration is readonly or a property is readonly.

length of type unsigned long, readonly

The number of properties that have been explicitly set in this declaration block.

parentRule of type CSSRule, readonly

The CSS rule that contains this declaration block or null if this CSSStyleDeclaration is not attached to a CSSRule.

Methods

Used to retrieve the object representation of the value of a CSS property if it has been explicitly set within this declaration block. This method returns null if the property is a shorthand property. Shorthand property values can only be accessed and modified as strings, using the getPropertyValue and setProperty methods.

Parameters

getPropertyPriority

propertyName

The name of the CSS property. See the CSS property index.

Return Value

CSSValue

Returns the value of the property if it has been explicitly set for this declaration block. Returns null if the property has not been set.

No Exceptions

Used to retrieve the priority of a CSS property (e.g. the "important" qualifier) if the property has been explicitly set in this declaration block.

Parameters

propertyName

The name of the CSS property. See the CSS property index.

Return Value

A string representing the priority (e.g. "important") if one exists. The empty string if none exists.

No Exceptions

getPropertyValue

Used to retrieve the value of a CSS property if it has been explicitly set within this declaration block.

Parameters

propertyName

The name of the CSS property. See the CSS property index.

Return Value

Returns the value of the property if it has been explicitly set for this declaration block. Returns the empty string if the property has not been set.

No Exceptions

item

Used to retrieve the properties that have been explicitly set in this declaration block. The order of the properties retrieved using this method does not have to be the order in which they were set. This method can be used to iterate over all properties in this declaration block.

Parameters

unsigned long

index

Index of the property name to retrieve.

Return Value

The name of the property at this ordinal position. The empty string if no property exists at this position.

No Exceptions

removeProperty

Used to remove a CSS property if it has been explicitly set within this declaration block.

Parameters

propertyName

The name of the CSS property. See the CSS property index.

Return Value

Returns the value of the property if it has been explicitly set for this declaration block. Returns the empty string if the property has not been set or the property name does not correspond to a valid CSS2 property.

Exceptions

NO_MODIFICATION_ALLOWED_ERR: Raised if this declaration is readonly or the property is readonly.

setProperty

Used to set a property value and priority within this declaration block.

Parameters

`DOMString`	`propertyName`	The name of the CSS property. See the CSS property index.
`DOMString`	`value`	The new value of the property.
`DOMString`	`priority`	The new priority of the property (e.g. `"important"`).

Exceptions

SYNTAX_ERR: Raised if the specified value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this declaration is readonly or the property is readonly.

No Return Value

Interface CSSValue (introduced in DOM Level 2)

The CSSValue interface represents a simple or a complex value. A CSSValue object only occurs in a context of a CSS property.

IDL Definition

// Introduced in DOM Level 2:
interface CSSValue {
  // UnitTypes
  const unsigned short      CSS_INHERIT                    = 0;
  const unsigned short      CSS_PRIMITIVE_VALUE            = 1;
  const unsigned short      CSS_VALUE_LIST                 = 2;
  const unsigned short      CSS_CUSTOM                     = 3;

           attribute DOMString        cssText;
                                        // raises(DOMException) on setting

  readonly attribute unsigned short   valueType;
};

Definition group UnitTypes

An integer indicating which type of unit applies to the value.

Defined Constants

CSS_CUSTOM	The value is a custom value.
CSS_INHERIT	The value is inherited.
CSS_PRIMITIVE_VALUE	The value is a primitive value and an instance of the `CSSPrimitiveValue` interface can be obtained by using binding-specific casting methods on this instance of the `CSSValue` interface.
CSS_VALUE_LIST	The value is a list `CSSValue`.

Attributes

cssText of type DOMString

A string representation of the current value.

Exceptions on setting

SYNTAX_ERR: Raised if the specified CSS string value has a syntax error (according to the attached property) or is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this value is readonly.

valueType of type unsigned short, readonly

A code defining the type of the value as defined above.

Interface CSSPrimitiveValue (introduced in DOM Level 2)

The CSSPrimitiveValue interface represents a single CSS value. This interface may be used to determine the value of a specific style property currently set in a block or to set a specific style property explicitly within the block. An instance of this interface can be obtained from the getPropertyCSSValue method of the CSSStyleDeclaration interface. A CSSPrimitiveValue object only occurs in a context of a CSS property.

Conversions are allowed between absolute values (from millimeters to centimeters, from degrees to radians, and so on) but not between relative values. (For example, a pixel value cannot be converted to a centimeter value.) Percentage values can't be converted since they are relative to the parent value (or another property value). There is one exception for color percentage values: since a color percentage value is relative to the range 0-255, a color percentage value can be converted to a number; (see also the RGBColor interface).

IDL Definition

// Introduced in DOM Level 2:
interface CSSPrimitiveValue : CSSValue {
  // UnitTypes
  const unsigned short      CSS_UNKNOWN                    = 0;
  const unsigned short      CSS_NUMBER                     = 1;
  const unsigned short      CSS_PERCENTAGE                 = 2;
  const unsigned short      CSS_EMS                        = 3;
  const unsigned short      CSS_EXS                        = 4;
  const unsigned short      CSS_PX                         = 5;
  const unsigned short      CSS_CM                         = 6;
  const unsigned short      CSS_MM                         = 7;
  const unsigned short      CSS_IN                         = 8;
  const unsigned short      CSS_PT                         = 9;
  const unsigned short      CSS_PC                         = 10;
  const unsigned short      CSS_DEG                        = 11;
  const unsigned short      CSS_RAD                        = 12;
  const unsigned short      CSS_GRAD                       = 13;
  const unsigned short      CSS_MS                         = 14;
  const unsigned short      CSS_S                          = 15;
  const unsigned short      CSS_HZ                         = 16;
  const unsigned short      CSS_KHZ                        = 17;
  const unsigned short      CSS_DIMENSION                  = 18;
  const unsigned short      CSS_STRING                     = 19;
  const unsigned short      CSS_URI                        = 20;
  const unsigned short      CSS_IDENT                      = 21;
  const unsigned short      CSS_ATTR                       = 22;
  const unsigned short      CSS_COUNTER                    = 23;
  const unsigned short      CSS_RECT                       = 24;
  const unsigned short      CSS_RGBCOLOR                   = 25;

  readonly attribute unsigned short   primitiveType;
  void               setFloatValue(in unsigned short unitType, 
                                   in float floatValue)
                                        raises(DOMException);
  float              getFloatValue(in unsigned short unitType)
                                        raises(DOMException);
  void               setStringValue(in unsigned short stringType, 
                                    in DOMString stringValue)
                                        raises(DOMException);
  DOMString          getStringValue()
                                        raises(DOMException);
  Counter            getCounterValue()
                                        raises(DOMException);
  Rect               getRectValue()
                                        raises(DOMException);
  RGBColor           getRGBColorValue()
                                        raises(DOMException);
};

Definition group UnitTypes

An integer indicating which type of unit applies to the value.

Defined Constants

CSS_ATTR	The value is a attribute function. The value can be obtained by using the `getStringValue` method.
CSS_CM	The value is a length (cm). The value can be obtained by using the `getFloatValue` method.
CSS_COUNTER	The value is a counter or counters function. The value can be obtained by using the `getCounterValue` method.
CSS_DEG	The value is an angle (deg). The value can be obtained by using the `getFloatValue` method.
CSS_DIMENSION	The value is a number with an unknown dimension. The value can be obtained by using the `getFloatValue` method.
CSS_EMS	The value is a length (ems). The value can be obtained by using the `getFloatValue` method.
CSS_EXS	The value is a length (exs). The value can be obtained by using the `getFloatValue` method.
CSS_GRAD	The value is an angle (grad). The value can be obtained by using the `getFloatValue` method.
CSS_HZ	The value is a frequency (Hz). The value can be obtained by using the `getFloatValue` method.
CSS_IDENT	The value is an identifier. The value can be obtained by using the `getStringValue` method.
CSS_IN	The value is a length (in). The value can be obtained by using the `getFloatValue` method.
CSS_KHZ	The value is a frequency (kHz). The value can be obtained by using the `getFloatValue` method.
CSS_MM	The value is a length (mm). The value can be obtained by using the `getFloatValue` method.
CSS_MS	The value is a time (ms). The value can be obtained by using the `getFloatValue` method.
CSS_NUMBER	The value is a simple number. The value can be obtained by using the `getFloatValue` method.
CSS_PC	The value is a length (pc). The value can be obtained by using the `getFloatValue` method.
CSS_PERCENTAGE	The value is a percentage. The value can be obtained by using the `getFloatValue` method.
CSS_PT	The value is a length (pt). The value can be obtained by using the `getFloatValue` method.
CSS_PX	The value is a length (px). The value can be obtained by using the `getFloatValue` method.
CSS_RAD	The value is an angle (rad). The value can be obtained by using the `getFloatValue` method.
CSS_RECT	The value is a rect function. The value can be obtained by using the `getRectValue` method.
CSS_RGBCOLOR	The value is a RGB color. The value can be obtained by using the `getRGBColorValue` method.
CSS_S	The value is a time (s). The value can be obtained by using the `getFloatValue` method.
CSS_STRING	The value is a STRING. The value can be obtained by using the `getStringValue` method.
CSS_UNKNOWN	The value is not a recognized CSS2 value. The value can only be obtained by using the `cssText` attribute.
CSS_URI	The value is a URI. The value can be obtained by using the `getStringValue` method.

Attributes

primitiveType of type unsigned short, readonly: The type of the value as defined by the constants specified above.

Methods

getCounterValue

This method is used to get the Counter value. If this CSS value doesn't contain a counter value, a DOMException is raised. Modification to the corresponding style property can be achieved using the Counter interface.

Return Value

Counter

The Counter value.

Exceptions

INVALID_ACCESS_ERR: Raised if the CSS value doesn't contain a Counter value (e.g. this is not CSS_COUNTER).

No Parameters

getFloatValue

This method is used to get a float value in a specified unit. If this CSS value doesn't contain a float value or can't be converted into the specified unit, a DOMException is raised.

Parameters

unsigned short

unitType

A unit code to get the float value. The unit code can only be a float unit type (i.e. CSS_NUMBER, CSS_PERCENTAGE, CSS_EMS, CSS_EXS, CSS_PX, CSS_CM, CSS_MM, CSS_IN, CSS_PT, CSS_PC, CSS_DEG, CSS_RAD, CSS_GRAD, CSS_MS, CSS_S, CSS_HZ, CSS_KHZ, CSS_DIMENSION).

Return Value

float

The float value in the specified unit.

Exceptions

INVALID_ACCESS_ERR: Raised if the CSS value doesn't contain a float value or if the float value can't be converted into the specified unit.

getRGBColorValue

This method is used to get the RGB color. If this CSS value doesn't contain a RGB color value, a DOMException is raised. Modification to the corresponding style property can be achieved using the RGBColor interface.

Return Value

RGBColor

the RGB color value.

Exceptions

INVALID_ACCESS_ERR: Raised if the attached property can't return a RGB color value (e.g. this is not CSS_RGBCOLOR).

No Parameters

getRectValue

This method is used to get the Rect value. If this CSS value doesn't contain a rect value, a DOMException is raised. Modification to the corresponding style property can be achieved using the Rect interface.

Return Value

Rect

The Rect value.

Exceptions

INVALID_ACCESS_ERR: Raised if the CSS value doesn't contain a Rect value. (e.g. this is not CSS_RECT).

No Parameters

getStringValue

This method is used to get the string value. If the CSS value doesn't contain a string value, a DOMException is raised.

Note: Some properties (like 'font-family' or 'voice-family') convert a whitespace separated list of idents to a string.

Return Value

The string value in the current unit. The current primitiveType can only be a string unit type (i.e. CSS_STRING, CSS_URI, CSS_IDENT and CSS_ATTR).

Exceptions

INVALID_ACCESS_ERR: Raised if the CSS value doesn't contain a string value.

No Parameters

setFloatValue

A method to set the float value with a specified unit. If the property attached with this value can not accept the specified unit or the float value, the value will be unchanged and a DOMException will be raised.

Parameters

`unsigned short`		`unitType`		A unit code as defined above. The unit code can only be a float unit type (i.e. `CSS_NUMBER`, `CSS_PERCENTAGE`, `CSS_EMS`, `CSS_EXS`, `CSS_PX`, `CSS_CM`, `CSS_MM`, `CSS_IN`, `CSS_PT`, `CSS_PC`, `CSS_DEG`, `CSS_RAD`, `CSS_GRAD`, `CSS_MS`, `CSS_S`, `CSS_HZ`, `CSS_KHZ`, `CSS_DIMENSION`).
`float`		`floatValue`		The new float value.

Exceptions

INVALID_ACCESS_ERR: Raised if the attached property doesn't support the float value or the unit type.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

No Return Value

setStringValue

A method to set the string value with the specified unit. If the property attached to this value can't accept the specified unit or the string value, the value will be unchanged and a DOMException will be raised.

Parameters

`unsigned short`		`stringType`		A string code as defined above. The string code can only be a string unit type (i.e. `CSS_STRING`, `CSS_URI`, `CSS_IDENT`, and `CSS_ATTR`).
`DOMString`		`stringValue`		The new string value.

Exceptions

createCSSStyleSheet

INVALID_ACCESS_ERR: Raised if the CSS value doesn't contain a string value or if the string value can't be converted into the specified unit.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

No Return Value

Interface CSSValueList (introduced in DOM Level 2)

The CSSValueList interface provides the abstraction of an ordered collection of CSS values.

Some properties allow an empty list into their syntax. In that case, these properties take the none identifier. So, an empty list means that the property has the value none.

IDL Definition

// Introduced in DOM Level 2:
interface CSSValueList : CSSValue {
  readonly attribute unsigned long    length;
  CSSValue           item(in unsigned long index);
};

Attributes

length of type unsigned long, readonly: The number of CSSValues in the list. The range of valid values of the indices is 0 to length-1 inclusive.

Methods

item

Used to retrieve a CSS rule by ordinal index. The order in this collection represents the order of the values in the CSS style property.

Parameters

unsigned long

index

Index into the collection.

Return Value

CSSValue

The style rule at the index position in the CSSValueList, or null if that is not a valid index.

No Exceptions

Interface RGBColor (introduced in DOM Level 2)

The RGBColor interface is used to represent any RGB color value. This interface reflects the values in the underlying style property. Hence, modifications made to the CSSPrimitiveValue objects modify the style property.

A specified RGB color is not clipped (even if the number is outside the range 0-255 or 0%-100%). A computed RGB color is clipped depending on the device.

Even if a style sheet can only contain an integer for a color value, the internal storage of this integer is a float, and this can be used as a float in the specified or the computed style.

A color percentage value can always be converted to a number and vice versa.

IDL Definition

// Introduced in DOM Level 2:
interface RGBColor {
  readonly attribute CSSPrimitiveValue  red;
  readonly attribute CSSPrimitiveValue  green;
  readonly attribute CSSPrimitiveValue  blue;
};

Attributes

blue of type CSSPrimitiveValue, readonly: This attribute is used for the blue value of the RGB color.
green of type CSSPrimitiveValue, readonly: This attribute is used for the green value of the RGB color.
red of type CSSPrimitiveValue, readonly: This attribute is used for the red value of the RGB color.

Interface Rect (introduced in DOM Level 2)

The Rect interface is used to represent any rect value. This interface reflects the values in the underlying style property. Hence, modifications made to the CSSPrimitiveValue objects modify the style property.

IDL Definition

// Introduced in DOM Level 2:
interface Rect {
  readonly attribute CSSPrimitiveValue  top;
  readonly attribute CSSPrimitiveValue  right;
  readonly attribute CSSPrimitiveValue  bottom;
  readonly attribute CSSPrimitiveValue  left;
};

Attributes

bottom of type CSSPrimitiveValue, readonly: This attribute is used for the bottom of the rect.
left of type CSSPrimitiveValue, readonly: This attribute is used for the left of the rect.
right of type CSSPrimitiveValue, readonly: This attribute is used for the right of the rect.
top of type CSSPrimitiveValue, readonly: This attribute is used for the top of the rect.

Interface Counter (introduced in DOM Level 2)

The Counter interface is used to represent any counter or counters function value. This interface reflects the values in the underlying style property. Hence, modifications made to the CSSPrimitiveValue objects modify the style property.

IDL Definition

// Introduced in DOM Level 2:
interface Counter {
  readonly attribute DOMString        identifier;
  readonly attribute DOMString        listStyle;
  readonly attribute DOMString        separator;
};

Attributes

identifier of type DOMString, readonly: This attribute is used for the identifier of the counter.
listStyle of type DOMString, readonly: This attribute is used for the style of the list.
separator of type DOMString, readonly: This attribute is used for the separator of the nested counters.

5.2.1. Override and computed style sheet

Interface ViewCSS (introduced in DOM Level 2)

This interface represents a CSS view. The getComputedStyle method provides a read only access to the computed values of an element.

The expectation is that an instance of the ViewCSS interface can be obtained by using binding-specific casting methods on an instance of the View interface.

Since a computed style is related to an Element node, if this element is removed from the document, the associated CSSStyleDeclaration and CSSValue related to this declaration are no longer valid.

IDL Definition

// Introduced in DOM Level 2:
interface ViewCSS : views::AbstractView {
  CSSStyleDeclaration getComputedStyle(in Element elt, 
                                       in DOMString pseudoElt);
};

Methods

getComputedStyle

This method is used to get the computed style as it is defined in [CSS2].

Parameters

`Element`		`elt`		The element whose style is to be computed. This parameter cannot be null.
`DOMString`		`pseudoElt`		The pseudo-element or `null` if none.

Return Value

CSSStyleDeclaration

The computed style. The CSSStyleDeclaration is read-only and contains only absolute values.

No Exceptions

Interface DocumentCSS (introduced in DOM Level 2)

This interface represents a document with a CSS view.

The getOverrideStyle method provides a mechanism through which a DOM author could effect immediate change to the style of an element without modifying the explicitly linked style sheets of a document or the inline style of elements in the style sheets. This style sheet comes after the author style sheet in the cascade algorithm and is called override style sheet. The override style sheet takes precedence over author style sheets. An "!important" declaration still takes precedence over a normal declaration. Override, author, and user style sheets all may contain "!important" declarations. User "!important" rules take precedence over both override and author "!important" rules, and override "!important" rules take precedence over author "!important" rules.

The expectation is that an instance of the DocumentCSS interface can be obtained by using binding-specific casting methods on an instance of the Document interface.

IDL Definition

// Introduced in DOM Level 2:
interface DocumentCSS : stylesheets::DocumentStyle {
  CSSStyleDeclaration getOverrideStyle(in Element elt, 
                                       in DOMString pseudoElt);
};

Methods

getOverrideStyle

This method is used to retrieve the override style declaration for a specified element and a specified pseudo-element.

Parameters

`Element`		`elt`		The element whose style is to be modified. This parameter cannot be null.
`DOMString`		`pseudoElt`		The pseudo-element or `null` if none.

Return Value

CSSStyleDeclaration

The override style declaration.

No Exceptions

5.2.2. Style sheet creation

Interface DOMImplementationCSS (introduced in DOM Level 2)

This interface allows the DOM user to create a CSSStyleSheet outside the context of a document. There is no way to associate the new CSSStyleSheet with a document in DOM Level 2.

IDL Definition

// Introduced in DOM   Level 2:
interface DOMImplementationCSS : DOMImplementation {
  CSSStyleSheet      createCSSStyleSheet(in DOMString title, 
                                         in DOMString media);
};

Methods

Creates a new CSSStyleSheet.

Parameters

`DOMString`		`title`		The advisory title. See also the Style Sheet Interfaces section.
`DOMString`		`media`		The comma-separated list of media associated with the new style sheet. See also the Style Sheet Interfaces section.

Return Value

CSSStyleSheet

A new CSS style sheet.

No Exceptions

5.2.3. Element with CSS inline style

Interface ElementCSSInlineStyle (introduced in DOM Level 2)

Inline style information attached to elements is exposed through the style attribute. This represents the contents of the STYLE attribute for HTML elements (or elements in other schemas or DTDs which use the STYLE attribute in the same way).

IDL Definition

// Introduced in DOM Level 2:
interface ElementCSSInlineStyle {
  readonly attribute CSSStyleDeclaration  style;
};

Attributes

style of type CSSStyleDeclaration, readonly: The style attribute.

5.3. CSS Extended Interfaces

The following table specifies the type of CSSValue used to represent each property that can be specified in a CSSStyleDeclaration found in a CSSStyleRule for a CSS Level 2 style sheet. The expectation is that the CSSValue returned from the getPropertyCSSValue method on the CSSStyleDeclaration interface can be cast down, using binding-specific casting methods, to the specific derived interface.

For properties that are represented by a custom interface (the valueType of the CSSValue is CSS_CUSTOM), the name of the derived interface is specified in the table. For properties that consist of lists of values (the valueType of the CSSValue is CSS_VALUE_LIST), the derived interface is CSSValueList. For all other properties (the valueType of the CSSValue is CSS_PRIMITIVE_VALUE), the derived interface is CSSPrimitiveValue.
Property Name Representation

azimuth CSS2Azimuth

background null

background-attachment ident

background-color rgbcolor, ident

background-image uri, ident

background-position CSS2BackgroundPosition

background-repeat ident

border null

border-collapse ident

border-color null

border-spacing CSS2BorderSpacing

border-style null

border-top, border-right, border-bottom, border-left null

border-top-color, border-right-color, border-bottom-color, border-left-color rgbcolor, ident

border-top-style, border-right-style, border-bottom-style, border-left-style ident

border-top-width, border-right-width, border-bottom-width, border-left-width length, ident

border-width null

bottom length, percentage, ident

caption-side ident

clear ident

clip rect, ident

color rgbcolor, ident

content list of string, uri, counter, attr, ident

counter-increment list of CSS2CounterIncrement

counter-reset list of CSS2CounterReset

cue null

cue-after, cue-before uri, ident

cursor CSS2Cursor

direction ident

display ident

elevation angle, ident

empty-cells ident

float ident

font null

font-family list of strings and idents

font-size ident, length, percentage

font-size-adjust number, ident

font-stretch ident

font-style ident

font-variant ident

font-weight ident

height length, percentage, ident

left length, percentage, ident

letter-spacing ident, length

line-height ident, length, percentage, number

list-style null

list-style-image uri, ident

list-style-position ident

list-style-type ident

margin null

margin-top, margin-right, margin-bottom, margin-left length, percentage, ident

marker-offset length, ident

max-height length, percentage, ident

max-width length, percentage, ident

min-height length, percentage, ident

min-width length, percentage, ident

orphans number

outline null

outline-color rgbcolor, ident

outline-style ident

outline-width length, ident

overflow ident

padding null

padding-top, padding-right, padding-bottom, padding-left length, percentage

page ident

page-break-after ident

page-break-before ident

page-break-inside ident

pause null

pause-after, pause-before time, percentage

pitch frequency, identifier

pitch-range number

play-during CSS2PlayDuring

position ident

quotes list of string or ident

richness number

right length, percentage, ident

speak ident

speak-header ident

speak-numeral ident

speak-punctuation ident

speech-rate number, ident

stress number

table-layout ident

text-align ident, string

text-decoration list of ident

text-indent length, percentage

text-shadow list of CSS2TextShadow

text-transform ident

top length, percentage, ident

unicode-bidi ident

vertical-align ident, percentage, length

visibility ident

voice-family list of strings and idents

volume number, percentage, ident

white-space ident

widows number

width length, percentage, ident

word-spacing length, ident

z-index ident, number

Interface CSS2Azimuth (introduced in DOM Level 2)

The CSS2Azimuth interface represents the azimuth CSS Level 2 property.

IDL Definition

// Introduced in DOM Level 2:
interface CSS2Azimuth : CSSValue {
  readonly attribute unsigned short   azimuthType;
  readonly attribute DOMString        identifier;
  readonly attribute boolean          behind;
  void               setAngleValue(in unsigned short uType, 
                                   in float fValue)
                                        raises(DOMException);
  float              getAngleValue(in unsigned short uType)
                                        raises(DOMException);
  void               setIdentifier(in DOMString ident, 
                                   in boolean b)
                                        raises(DOMException);
};

Attributes

azimuthType of type unsigned short, readonly: A code defining the type of the value as defined in CSSValue. It would be one of CSS_DEG, CSS_RAD, CSS_GRAD or CSS_IDENT.
behind of type boolean, readonly: behind indicates whether the behind identifier has been set.
identifier of type DOMString, readonly: If azimuthType is CSS_IDENT, identifier contains one of left-side, far-left, left, center-left, center, center-right, right, far-right, right-side, leftwards, rightwards. The empty string if none is set.

Methods

getAngleValue

Used to retrieved the float value of the azimuth property.

Parameters

unsigned short

uType

The unit type can be only an angle unit type (CSS_DEG, CSS_RAD or CSS_GRAD).

Return Value

float

The float value.

Exceptions

INVALID_ACCESS_ERR: Raised if the unit type is invalid.

setAngleValue

A method to set the angle value with a specified unit. This method will unset any previously set identifier value.

Parameters

`unsigned short`		`uType`		The unitType could only be one of `CSS_DEG`, `CSS_RAD` or `CSS_GRAD`).
`float`		`fValue`		The new float value of the angle.

Exceptions

INVALID_ACCESS_ERR: Raised if the unit type is invalid.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

No Return Value

setIdentifier

Setting the identifier for the azimuth property will unset any previously set angle value. The value of azimuthType is set to CSS_IDENT

Parameters

`DOMString`		`ident`		The new identifier. If the identifier is "leftwards" or "rightward", the behind attribute is ignored.
`boolean`		`b`		The new value for behind.

Exceptions

getHorizontalPosition

SYNTAX_ERR: Raised if the specified identifier has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

No Return Value

Interface CSS2BackgroundPosition (introduced in DOM Level 2)

The CSS2BackgroundPosition interface represents the background-position CSS Level 2 property.

IDL Definition

// Introduced in DOM Level 2:
interface CSS2BackgroundPosition : CSSValue {
  readonly attribute unsigned short   horizontalType;
  readonly attribute unsigned short   verticalType;
  readonly attribute DOMString        horizontalIdentifier;
  readonly attribute DOMString        verticalIdentifier;
  float              getHorizontalPosition(in float hType)
                                        raises(DOMException);
  float              getVerticalPosition(in float vType)
                                        raises(DOMException);
  void               setHorizontalPosition(in unsigned short hType, 
                                           in float value)
                                        raises(DOMException);
  void               setVerticalPosition(in unsigned short vType, 
                                         in float value)
                                        raises(DOMException);
  void               setPositionIdentifier(in DOMString hIdentifier, 
                                           in DOMString vIdentifier)
                                        raises(DOMException);
};

Attributes

horizontalIdentifier of type DOMString, readonly: If horizontalType is CSS_IDENT or CSS_INHERIT, this attribute contains the string representation of the ident, otherwise it contains an empty string.
horizontalType of type unsigned short, readonly: A code defining the type of the horizontal value. It would be one of CSS_PERCENTAGE, CSS_EMS, CSS_EXS, CSS_PX, CSS_CM, CSS_MM, CSS_IN, CSS_PT, CSS_PC or CSS_IDENT. If one of horizontal or vertical is CSS_IDENT, it's guaranteed that the other is the same.
verticalIdentifier of type DOMString, readonly: If verticalType is CSS_IDENT or CSS_INHERIT, this attribute contains the string representation of the ident, otherwise it contains an empty string. The value is "center" if only the horizontalIdentifier has been set.
verticalType of type unsigned short, readonly: A code defining the type of the horizontal value. The code can be one of the following units : CSS_PERCENTAGE, CSS_EMS, CSS_EXS, CSS_PX, CSS_CM, CSS_MM, CSS_IN, CSS_PT, CSS_PC, CSS_IDENT, CSS_INHERIT. If one of horizontal or vertical is CSS_IDENT or CSS_INHERIT, it's guaranteed that the other is the same.

Methods

This method is used to get the float value in a specified unit if the horizontalPosition represents a length or a percentage. If the float doesn't contain a float value or can't be converted into the specified unit, a DOMException is raised.

Parameters

float

hType

The horizontal unit.

Return Value

float

The float value.

Exceptions

getVerticalPosition

INVALID_ACCESS_ERR: Raised if the property doesn't contain a float or the value can't be converted.

This method is used to get the float value in a specified unit if the verticalPosition represents a length or a percentage. If the float doesn't contain a float value or can't be converted into the specified unit, a DOMException is raised. The value is 50% if only the horizontal value has been specified.

Parameters

float

vType

The vertical unit.

Return Value

float

The float value.

Exceptions

setHorizontalPosition

INVALID_ACCESS_ERR: Raised if the property doesn't contain a float or the value can't be converted.

This method is used to set the horizontal position with a specified unit. If the vertical value is not a percentage or a length, it sets the vertical position to 50%.

Parameters

`unsigned short`		`hType`		The specified unit (a length or a percentage).
`float`		`value`		The new value.

Exceptions

setPositionIdentifier

INVALID_ACCESS_ERR: Raised if the specified unit is not a length or a percentage.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

No Return Value

Sets the identifiers. If the second identifier is the empty string, the vertical identifier is set to its default value ("center").

Parameters

`DOMString`		`hIdentifier`		The new horizontal identifier.
`DOMString`		`vIdentifier`		The new vertical identifier.

Exceptions

setVerticalPosition

SYNTAX_ERR: Raised if the identifiers have a syntax error and are unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

No Return Value

This method is used to set the vertical position with a specified unit. If the horizontal value is not a percentage or a length, it sets the vertical position to 50%.

Parameters

`unsigned short`		`vType`		The specified unit (a length or a percentage).
`float`		`value`		The new value.

Exceptions

getHorizontalSpacing

INVALID_ACCESS_ERR: Raised if the specified unit is not a length or a percentage.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

No Return Value

Interface CSS2BorderSpacing (introduced in DOM Level 2)

The CSS2BorderSpacing interface represents the border-spacing CSS Level 2 property.

IDL Definition

// Introduced in DOM Level 2:
interface CSS2BorderSpacing : CSSValue {
  readonly attribute unsigned short   horizontalType;
  readonly attribute unsigned short   verticalType;
  float              getHorizontalSpacing(in float hType)
                                        raises(DOMException);
  float              getVerticalSpacing(in float vType)
                                        raises(DOMException);
  void               setHorizontalSpacing(in unsigned short hType, 
                                          in float value)
                                        raises(DOMException);
  void               setVerticalSpacing(in unsigned short vType, 
                                        in float value)
                                        raises(DOMException);
};

Attributes

horizontalType of type unsigned short, readonly: The A code defining the type of the value as defined in CSSValue. It would be one of CSS_EMS, CSS_EXS, CSS_PX, CSS_CM, CSS_MM, CSS_IN, CSS_PT or CSS_PC.
verticalType of type unsigned short, readonly: The A code defining the type of the value as defined in CSSValue. It would be one of CSS_EMS, CSS_EXS, CSS_PX, CSS_CM, CSS_MM, CSS_IN, CSS_PT, CSS_PC or CSS_INHERIT.

Methods

This method is used to get the float value in a specified unit if the horizontalSpacing represents a length. If the float doesn't contain a float value or can't be converted into the specified unit, a DOMException is raised.

Parameters

float

hType

The horizontal unit.

Return Value

float

The float value.

Exceptions

INVALID_ACCESS_ERR: Raised if the property doesn't contain a float or the value can't be converted.

getVerticalSpacing

This method is used to get the float value in a specified unit if the verticalSpacing represents a length. If the float doesn't contain a float value or can't be converted into the specified unit, a DOMException is raised. The value is 0 if only the horizontal value has been specified.

Parameters

float

vType

The vertical unit.

Return Value

float

The float value.

Exceptions

setHorizontalSpacing

INVALID_ACCESS_ERR: Raised if the property doesn't contain a float or the value can't be converted.

This method is used to set the horizontal spacing with a specified unit. If the vertical value is a length, it sets the vertical spacing to 0.

Parameters

`unsigned short`		`hType`		The horizontal unit.
`float`		`value`		The new value.

Exceptions

INVALID_ACCESS_ERR: Raised if the specified unit is not a length.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

No Return Value

setVerticalSpacing

This method is used to set the vertical spacing with a specified unit. If the horizontal value is not a length, it sets the vertical spacing to 0.

Parameters

`unsigned short`		`vType`		The vertical unit.
`float`		`value`		The new value.

Exceptions

INVALID_ACCESS_ERR: Raised if the specified unit is not a length or a percentage.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

No Return Value

Interface CSS2CounterReset (introduced in DOM Level 2)

The CSS2CounterReset interface represents a simple value for the counter-reset CSS Level 2 property.

IDL Definition

// Introduced in DOM Level   2:
interface CSS2CounterReset : CSSValue {
           attribute DOMString        identifier;
                                        // raises(DOMException) on setting

           attribute short            reset;
                                        // raises(DOMException) on setting

};

Attributes

identifier of type DOMString

The element name.

Exceptions on setting

SYNTAX_ERR: Raised if the specified identifier has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this identifier is readonly.

reset of type short

The reset (default value is 0).

Exceptions on setting

NO_MODIFICATION_ALLOWED_ERR: Raised if this identifier is readonly.

Interface CSS2CounterIncrement (introduced in DOM Level 2)

The CSS2CounterIncrement interface represents a simple value for the counter-increment CSS Level 2 property.

IDL Definition

// Introduced in DOM   Level 2:
interface CSS2CounterIncrement : CSSValue {
           attribute DOMString        identifier;
                                        // raises(DOMException) on setting

           attribute short            increment;
                                        // raises(DOMException) on setting

};

Attributes

identifier of type DOMString

The element name.

Exceptions on setting

SYNTAX_ERR: Raised if the specified identifier has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this identifier is readonly.

increment of type short

The increment. (Default value is 1.)

Exceptions on setting

NO_MODIFICATION_ALLOWED_ERR: Raised if this identifier is readonly.

Interface CSS2Cursor (introduced in DOM Level 2)

The CSS2Cursor interface represents the cursor CSS Level 2 property.

IDL Definition

// Introduced in DOM Level 2:
interface CSS2Cursor : CSSValue {
  readonly attribute CSSValueList     uris;
           attribute DOMString        predefinedCursor;
                                        // raises(DOMException) on setting

};

Attributes

predefinedCursor of type DOMString

This identifier represents a generic cursor name or an empty string.

Exceptions on setting

SYNTAX_ERR: Raised if the specified CSS string value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this declaration is readonly.

uris of type CSSValueList, readonly

uris represents the list of URIs (CSS_URI) on the cursor property. The list can be empty.

Interface CSS2PlayDuring (introduced in DOM Level 2)

The CSS2PlayDuring interface represents the play-during CSS Level 2 property.

IDL Definition

// Introduced in DOM Level 2:
interface CSS2PlayDuring : CSSValue {
  readonly attribute unsigned short   playDuringType;
           attribute DOMString        playDuringIdentifier;
                                        // raises(DOMException) on setting

           attribute DOMString        uri;
                                        // raises(DOMException) on setting

           attribute boolean          mix;
                                        // raises(DOMException) on setting

           attribute boolean          repeat;
                                        // raises(DOMException) on setting

};

Attributes

mix of type boolean

true if the sound should be mixed. It will be ignored if the attribute doesn't contain a uri.

Exceptions on setting

NO_MODIFICATION_ALLOWED_ERR: Raised if this declaration is readonly.

playDuringIdentifier of type DOMString

One of "inherit", "auto", "none" or the empty string if the playDuringType is CSS_UNKNOWN. On setting, it will set the uri to the empty string and mix and repeat to false.

Exceptions on setting

SYNTAX_ERR: Raised if the specified CSS string value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this declaration is readonly.

playDuringType of type unsigned short, readonly

A code defining the type of the value as defined in CSSvalue. It would be one of CSS_UNKNOWN or CSS_IDENT.

repeat of type boolean

true if the sound should be repeated. It will be ignored if the attribute doesn't contain a uri.

Exceptions on setting

NO_MODIFICATION_ALLOWED_ERR: Raised if this declaration is readonly.

uri of type DOMString

The sound specified by the uri. It will set the playDuringType attribute to CSS_UNKNOWN.

Exceptions on setting

SYNTAX_ERR: Raised if the specified CSS string value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this declaration is readonly.

Interface CSS2TextShadow (introduced in DOM Level 2)

The CSS2TextShadow interface represents a simple value for the text-shadow CSS Level 2 property.

IDL Definition

// Introduced in DOM Level 2:
interface CSS2TextShadow {
  readonly attribute CSSValue         color;
  readonly attribute CSSValue         horizontal;
  readonly attribute CSSValue         vertical;
  readonly attribute CSSValue         blur;
};

Attributes

blur of type CSSValue, readonly: The blur radius of the text shadow. 0 if no length has been specified.
color of type CSSValue, readonly: Specifies the color of the text shadow. The CSS Value can contain an empty string if no color has been specified.
horizontal of type CSSValue, readonly: The horizontal position of the text shadow. 0 if no length has been specified.
vertical of type CSSValue, readonly: The vertical position of the text shadow. 0 if no length has been specified.

The following table specifies the type of CSSValue used to represent each descriptor that can be specified in a CSSStyleDeclaration found in a CSSFontFaceRule for a CSS Level 2 style sheet.
Property Name Representation

font-family list of strings and idents

font-style list of idents

font-variant list of idents

font-weight list of idents

font-stretch list of idents

font-size list of lengths or ident

unicode-range list of strings. Example: "U+370-3FF", "U+1F??"

units-per-em number

src list of CSS2FontFaceSrc

panose-1 list of integers

stemv number

stemh number

slope number

cap-height number

x-height number

ascent number

descent number

widths list of CSS2FontFaceWidths

bbox list of numbers

definition-src uri

baseline number

centerline number

mathline number

topline number

Interface CSS2FontFaceSrc (introduced in DOM Level 2)

The CSS2FontFaceSrc interface represents the src CSS Level 2 descriptor.

IDL Definition

// Introduced in DOM Level 2:
interface CSS2FontFaceSrc {
           attribute DOMString        uri;
                                        // raises(DOMException) on setting

  readonly attribute CSSValueList     format;
           attribute DOMString        fontFaceName;
                                        // raises(DOMException) on setting

};

Attributes

fontFaceName of type DOMString

Specifies the full font name of a locally installed font.

Exceptions on setting

SYNTAX_ERR: Raised if the specified CSS string value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this declaration is readonly.

format of type CSSValueList, readonly

This attribute contains a list of strings for the format CSS function.

uri of type DOMString

Specifies the source of the font, empty string otherwise.

Exceptions on setting

SYNTAX_ERR: Raised if the specified CSS string value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this declaration is readonly.

Interface CSS2FontFaceWidths (introduced in DOM Level 2)

The CSS2FontFaceWidths interface represents a simple value for the widths CSS Level 2 descriptor.

IDL Definition

// Introduced in DOM Level 2:
interface CSS2FontFaceWidths {
           attribute DOMString        urange;
                                        // raises(DOMException) on setting

  readonly attribute CSSValueList     numbers;
};

Attributes

numbers of type CSSValueList, readonly

A list of numbers representing the glyph widths.

urange of type DOMString

The range for the characters.

Exceptions on setting

SYNTAX_ERR: Raised if the specified CSS string value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this declaration is readonly.

The following table specifies the type of CSSValue used to represent each property that can be specified in a CSSStyleDeclaration found in a CSSPageRule for a CSS Level 2 style sheet.
Property Name Representation

margin null

margin-top, margin-right, margin-bottom, margin-left length (no CSS_EMS and CSS_EXS), percentage, ident

marks list of idents

size CSS2PageSize

Interface CSS2PageSize (introduced in DOM Level 2)

The CSS2PageSize interface represents the size CSS Level 2 descriptor.

IDL Definition

// Introduced in DOM Level 2:
interface CSS2PageSize : CSSValue {
  readonly attribute unsigned short   widthType;
  readonly attribute unsigned short   heightType;
  readonly attribute DOMString        identifier;
  float              getWidth(in float wType)
                                        raises(DOMException);
  float              getHeightSize(in float hType)
                                        raises(DOMException);
  void               setWidthSize(in unsigned short wType, 
                                  in float value)
                                        raises(DOMException);
  void               setHeightSize(in unsigned short hType, 
                                   in float value)
                                        raises(DOMException);
  void               setIdentifier(in DOMString ident)
                                        raises(DOMException);
};

Attributes

heightType of type unsigned short, readonly: A code defining the type of the height of the page. It would be one of CSS_EMS, CSS_EXS, CSS_PX, CSS_CM, CSS_MM, CSS_IN, CSS_PT, CSS_PC or CSS_IDENT. If one of width or height is CSS_IDENT, it's guaranteed that the other is the same.
identifier of type DOMString, readonly: If width is CSS_IDENT, this attribute contains the string representation of the ident, otherwise it contains an empty string.
widthType of type unsigned short, readonly: A code defining the type of the width of the page. It would be one of CSS_EMS, CSS_EXS, CSS_PX, CSS_CM, CSS_MM, CSS_IN, CSS_PT, CSS_PC or CSS_IDENT.

Methods

getHeightSize

This method is used to get the float value in a specified unit if the heightType represents a length. If the float doesn't contain a float value or can't be converted into the specified unit, a DOMException is raised. If only the width value has been specified, the height value is the same.

Parameters

float

hType

The height unit.

Return Value

float

The float value.

Exceptions

INVALID_ACCESS_ERR: Raised if the property doesn't contain a float or the value can't be converted.

getWidth

This method is used to get the float value in a specified unit if the widthType represents a length. If the float doesn't contain a float value or can't be converted into the specified unit, a DOMException is raised.

Parameters

float

wType

The width unit.

Return Value

float

The float value.

Exceptions

INVALID_ACCESS_ERR: Raised if the property doesn't contain a float or the value can't be converted.

setHeightSize

This method is used to set the height position with a specified unit. If the widthType is not a length, it sets the width position to the same value.

Parameters

`unsigned short`		`hType`		The height unit.
`float`		`value`		The new value.

Exceptions

INVALID_ACCESS_ERR: Raised if the specified unit is not a length or a percentage.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

No Return Value

setIdentifier

Sets the identifier.

Parameters

ident

The new identifier.

Exceptions

SYNTAX_ERR: Raised if the identifier has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

No Return Value

setWidthSize

This method is used to set the width position with a specified unit. If the heightType is not a length, it sets the height position to the same value.

Parameters

`unsigned short`		`wType`		The width unit.
`float`		`value`		The new value.

Exceptions

INVALID_ACCESS_ERR: Raised if the specified unit is not a length or a percentage.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

No Return Value

Interface CSS2Properties (introduced in DOM Level 2)

The CSS2Properties interface represents a convenience mechanism for retrieving and setting properties within a CSSStyleDeclaration. The attributes of this interface correspond to all the properties specified in CSS2. Getting an attribute of this interface is equivalent to calling the getPropertyValue method of the CSSStyleDeclaration interface. Setting an attribute of this interface is equivalent to calling the setProperty method of the CSSStyleDeclaration interface.

A compliant implementation is not required to implement the CSS2Properties interface. If an implementation does implement this interface, the expectation is that language-specific methods can be used to cast from an instance of the CSSStyleDeclaration interface to the CSS2Properties interface.

If an implementation does implement this interface, it is expected to understand the specific syntax of the shorthand properties, and apply their semantics; when the margin property is set, for example, the marginTop, marginRight, marginBottom and marginLeft properties are actually being set by the underlying implementation.

When dealing with CSS "shorthand" properties, the shorthand properties should be decomposed into their component longhand properties as appropriate, and when querying for their value, the form returned should be the shortest form exactly equivalent to the declarations made in the ruleset. However, if there is no shorthand declaration that could be added to the ruleset without changing in any way the rules already declared in the ruleset (i.e., by adding longhand rules that were previously not declared in the ruleset), then the empty string should be returned for the shorthand property.

For example, querying for the font property should not return "normal normal normal 14pt/normal Arial, sans-serif", when "14pt Arial, sans-serif" suffices. (The normals are initial values, and are implied by use of the longhand property.)

If the values for all the longhand properties that compose a particular string are the initial values, then a string consisting of all the initial values should be returned (e.g. a border-width value of "medium" should be returned as such, not as "").

For some shorthand properties that take missing values from other sides, such as the margin, padding, and border-[width|style|color] properties, the minimum number of sides possible should be used; i.e., "0px 10px" will be returned instead of "0px 10px 0px 10px".

If the value of a shorthand property can not be decomposed into its component longhand properties, as is the case for the font property with a value of "menu", querying for the values of the component longhand properties should return the empty string.

IDL Definition

// Introduced in DOM Level 2:
interface CSS2Properties {
           attribute DOMString        azimuth;
                                        // raises(DOMException) on setting

           attribute DOMString        background;
                                        // raises(DOMException) on setting

           attribute DOMString        backgroundAttachment;
                                        // raises(DOMException) on setting

           attribute DOMString        backgroundColor;
                                        // raises(DOMException) on setting

           attribute DOMString        backgroundImage;
                                        // raises(DOMException) on setting

           attribute DOMString        backgroundPosition;
                                        // raises(DOMException) on setting

           attribute DOMString        backgroundRepeat;
                                        // raises(DOMException) on setting

           attribute DOMString        border;
                                        // raises(DOMException) on setting

           attribute DOMString        borderCollapse;
                                        // raises(DOMException) on setting

           attribute DOMString        borderColor;
                                        // raises(DOMException) on setting

           attribute DOMString        borderSpacing;
                                        // raises(DOMException) on setting

           attribute DOMString        borderStyle;
                                        // raises(DOMException) on setting

           attribute DOMString        borderTop;
                                        // raises(DOMException) on setting

           attribute DOMString        borderRight;
                                        // raises(DOMException) on setting

           attribute DOMString        borderBottom;
                                        // raises(DOMException) on setting

           attribute DOMString        borderLeft;
                                        // raises(DOMException) on setting

           attribute DOMString        borderTopColor;
                                        // raises(DOMException) on setting

           attribute DOMString        borderRightColor;
                                        // raises(DOMException) on setting

           attribute DOMString        borderBottomColor;
                                        // raises(DOMException) on setting

           attribute DOMString        borderLeftColor;
                                        // raises(DOMException) on setting

           attribute DOMString        borderTopStyle;
                                        // raises(DOMException) on setting

           attribute DOMString        borderRightStyle;
                                        // raises(DOMException) on setting

           attribute DOMString        borderBottomStyle;
                                        // raises(DOMException) on setting

           attribute DOMString        borderLeftStyle;
                                        // raises(DOMException) on setting

           attribute DOMString        borderTopWidth;
                                        // raises(DOMException) on setting

           attribute DOMString        borderRightWidth;
                                        // raises(DOMException) on setting

           attribute DOMString        borderBottomWidth;
                                        // raises(DOMException) on setting

           attribute DOMString        borderLeftWidth;
                                        // raises(DOMException) on setting

           attribute DOMString        borderWidth;
                                        // raises(DOMException) on setting

           attribute DOMString        bottom;
                                        // raises(DOMException) on setting

           attribute DOMString        captionSide;
                                        // raises(DOMException) on setting

           attribute DOMString        clear;
                                        // raises(DOMException) on setting

           attribute DOMString        clip;
                                        // raises(DOMException) on setting

           attribute DOMString        color;
                                        // raises(DOMException) on setting

           attribute DOMString        content;
                                        // raises(DOMException) on setting

           attribute DOMString        counterIncrement;
                                        // raises(DOMException) on setting

           attribute DOMString        counterReset;
                                        // raises(DOMException) on setting

           attribute DOMString        cue;
                                        // raises(DOMException) on setting

           attribute DOMString        cueAfter;
                                        // raises(DOMException) on setting

           attribute DOMString        cueBefore;
                                        // raises(DOMException) on setting

           attribute DOMString        cursor;
                                        // raises(DOMException) on setting

           attribute DOMString        direction;
                                        // raises(DOMException) on setting

           attribute DOMString        display;
                                        // raises(DOMException) on setting

           attribute DOMString        elevation;
                                        // raises(DOMException) on setting

           attribute DOMString        emptyCells;
                                        // raises(DOMException) on setting

           attribute DOMString        cssFloat;
                                        // raises(DOMException) on setting

           attribute DOMString        font;
                                        // raises(DOMException) on setting

           attribute DOMString        fontFamily;
                                        // raises(DOMException) on setting

           attribute DOMString        fontSize;
                                        // raises(DOMException) on setting

           attribute DOMString        fontSizeAdjust;
                                        // raises(DOMException) on setting

           attribute DOMString        fontStretch;
                                        // raises(DOMException) on setting

           attribute DOMString        fontStyle;
                                        // raises(DOMException) on setting

           attribute DOMString        fontVariant;
                                        // raises(DOMException) on setting

           attribute DOMString        fontWeight;
                                        // raises(DOMException) on setting

           attribute DOMString        height;
                                        // raises(DOMException) on setting

           attribute DOMString        left;
                                        // raises(DOMException) on setting

           attribute DOMString        letterSpacing;
                                        // raises(DOMException) on setting

           attribute DOMString        lineHeight;
                                        // raises(DOMException) on setting

           attribute DOMString        listStyle;
                                        // raises(DOMException) on setting

           attribute DOMString        listStyleImage;
                                        // raises(DOMException) on setting

           attribute DOMString        listStylePosition;
                                        // raises(DOMException) on setting

           attribute DOMString        listStyleType;
                                        // raises(DOMException) on setting

           attribute DOMString        margin;
                                        // raises(DOMException) on setting

           attribute DOMString        marginTop;
                                        // raises(DOMException) on setting

           attribute DOMString        marginRight;
                                        // raises(DOMException) on setting

           attribute DOMString        marginBottom;
                                        // raises(DOMException) on setting

           attribute DOMString        marginLeft;
                                        // raises(DOMException) on setting

           attribute DOMString        markerOffset;
                                        // raises(DOMException) on setting

           attribute DOMString        marks;
                                        // raises(DOMException) on setting

           attribute DOMString        maxHeight;
                                        // raises(DOMException) on setting

           attribute DOMString        maxWidth;
                                        // raises(DOMException) on setting

           attribute DOMString        minHeight;
                                        // raises(DOMException) on setting

           attribute DOMString        minWidth;
                                        // raises(DOMException) on setting

           attribute DOMString        orphans;
                                        // raises(DOMException) on setting

           attribute DOMString        outline;
                                        // raises(DOMException) on setting

           attribute DOMString        outlineColor;
                                        // raises(DOMException) on setting

           attribute DOMString        outlineStyle;
                                        // raises(DOMException) on setting

           attribute DOMString        outlineWidth;
                                        // raises(DOMException) on setting

           attribute DOMString        overflow;
                                        // raises(DOMException) on setting

           attribute DOMString        padding;
                                        // raises(DOMException) on setting

           attribute DOMString        paddingTop;
                                        // raises(DOMException) on setting

           attribute DOMString        paddingRight;
                                        // raises(DOMException) on setting

           attribute DOMString        paddingBottom;
                                        // raises(DOMException) on setting

           attribute DOMString        paddingLeft;
                                        // raises(DOMException) on setting

           attribute DOMString        page;
                                        // raises(DOMException) on setting

           attribute DOMString        pageBreakAfter;
                                        // raises(DOMException) on setting

           attribute DOMString        pageBreakBefore;
                                        // raises(DOMException) on setting

           attribute DOMString        pageBreakInside;
                                        // raises(DOMException) on setting

           attribute DOMString        pause;
                                        // raises(DOMException) on setting

           attribute DOMString        pauseAfter;
                                        // raises(DOMException) on setting

           attribute DOMString        pauseBefore;
                                        // raises(DOMException) on setting

           attribute DOMString        pitch;
                                        // raises(DOMException) on setting

           attribute DOMString        pitchRange;
                                        // raises(DOMException) on setting

           attribute DOMString        playDuring;
                                        // raises(DOMException) on setting

           attribute DOMString        position;
                                        // raises(DOMException) on setting

           attribute DOMString        quotes;
                                        // raises(DOMException) on setting

           attribute DOMString        richness;
                                        // raises(DOMException) on setting

           attribute DOMString        right;
                                        // raises(DOMException) on setting

           attribute DOMString        size;
                                        // raises(DOMException) on setting

           attribute DOMString        speak;
                                        // raises(DOMException) on setting

           attribute DOMString        speakHeader;
                                        // raises(DOMException) on setting

           attribute DOMString        speakNumeral;
                                        // raises(DOMException) on setting

           attribute DOMString        speakPunctuation;
                                        // raises(DOMException) on setting

           attribute DOMString        speechRate;
                                        // raises(DOMException) on setting

           attribute DOMString        stress;
                                        // raises(DOMException) on setting

           attribute DOMString        tableLayout;
                                        // raises(DOMException) on setting

           attribute DOMString        textAlign;
                                        // raises(DOMException) on setting

           attribute DOMString        textDecoration;
                                        // raises(DOMException) on setting

           attribute DOMString        textIndent;
                                        // raises(DOMException) on setting

           attribute DOMString        textShadow;
                                        // raises(DOMException) on setting

           attribute DOMString        textTransform;
                                        // raises(DOMException) on setting

           attribute DOMString        top;
                                        // raises(DOMException) on setting

           attribute DOMString        unicodeBidi;
                                        // raises(DOMException) on setting

           attribute DOMString        verticalAlign;
                                        // raises(DOMException) on setting

           attribute DOMString        visibility;
                                        // raises(DOMException) on setting

           attribute DOMString        voiceFamily;
                                        // raises(DOMException) on setting

           attribute DOMString        volume;
                                        // raises(DOMException) on setting

           attribute DOMString        whiteSpace;
                                        // raises(DOMException) on setting

           attribute DOMString        widows;
                                        // raises(DOMException) on setting

           attribute DOMString        width;
                                        // raises(DOMException) on setting

           attribute DOMString        wordSpacing;
                                        // raises(DOMException) on setting

           attribute DOMString        zIndex;
                                        // raises(DOMException) on setting

};

Attributes

azimuth of type DOMString

See the azimuth property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

background of type DOMString

See the background property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

backgroundAttachment of type DOMString

See the background-attachment property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

backgroundColor of type DOMString

See the background-color property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

backgroundImage of type DOMString

See the background-image property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

backgroundPosition of type DOMString

See the background-position property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

backgroundRepeat of type DOMString

See the background-repeat property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

border of type DOMString

See the border property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

borderBottom of type DOMString

See the border-bottom property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

borderBottomColor of type DOMString

See the border-bottom-color property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

borderBottomStyle of type DOMString

See the border-bottom-style property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

borderBottomWidth of type DOMString

See the border-bottom-width property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

borderCollapse of type DOMString

See the border-collapse property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

borderColor of type DOMString

See the border-color property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

borderLeft of type DOMString

See the border-left property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

borderLeftColor of type DOMString

See the border-left-color property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

borderLeftStyle of type DOMString

See the border-left-style property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

borderLeftWidth of type DOMString

See the border-left-width property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

borderRight of type DOMString

See the border-right property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

borderRightColor of type DOMString

See the border-right-color property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

borderRightStyle of type DOMString

See the border-right-style property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

borderRightWidth of type DOMString

See the border-right-width property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

borderSpacing of type DOMString

See the border-spacing property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

borderStyle of type DOMString

See the border-style property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

borderTop of type DOMString

See the border-top property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

borderTopColor of type DOMString

See the border-top-color property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

borderTopStyle of type DOMString

See the border-top-style property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

borderTopWidth of type DOMString

See the border-top-width property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

borderWidth of type DOMString

See the border-width property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

bottom of type DOMString

See the bottom property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

captionSide of type DOMString

See the caption-side property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

clear of type DOMString

See the clear property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

clip of type DOMString

See the clip property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

color of type DOMString

See the color property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

content of type DOMString

See the content property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

counterIncrement of type DOMString

See the counter-increment property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

counterReset of type DOMString

See the counter-reset property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

cssFloat of type DOMString

See the float property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

cue of type DOMString

See the cue property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

cueAfter of type DOMString

See the cue-after property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

cueBefore of type DOMString

See the cue-before property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

cursor of type DOMString

See the cursor property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

direction of type DOMString

See the direction property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

display of type DOMString

See the display property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

elevation of type DOMString

See the elevation property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

emptyCells of type DOMString

See the empty-cells property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

font of type DOMString

See the font property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

fontFamily of type DOMString

See the font-family property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

fontSize of type DOMString

See the font-size property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

fontSizeAdjust of type DOMString

See the font-size-adjust property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

fontStretch of type DOMString

See the font-stretch property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

fontStyle of type DOMString

See the font-style property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

fontVariant of type DOMString

See the font-variant property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

fontWeight of type DOMString

See the font-weight property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

height of type DOMString

See the height property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

left of type DOMString

See the left property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

letterSpacing of type DOMString

See the letter-spacing property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

lineHeight of type DOMString

See the line-height property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

listStyle of type DOMString

See the list-style property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

listStyleImage of type DOMString

See the list-style-image property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

listStylePosition of type DOMString

See the list-style-position property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

listStyleType of type DOMString

See the list-style-type property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

margin of type DOMString

See the margin property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

marginBottom of type DOMString

See the margin-bottom property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

marginLeft of type DOMString

See the margin-left property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

marginRight of type DOMString

See the margin-right property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

marginTop of type DOMString

See the margin-top property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

markerOffset of type DOMString

See the marker-offset property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

marks of type DOMString

See the marks property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

maxHeight of type DOMString

See the max-height property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

maxWidth of type DOMString

See the max-width property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

minHeight of type DOMString

See the min-height property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

minWidth of type DOMString

See the min-width property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

orphans of type DOMString

See the orphans property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

outline of type DOMString

See the outline property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

outlineColor of type DOMString

See the outline-color property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

outlineStyle of type DOMString

See the outline-style property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

outlineWidth of type DOMString

See the outline-width property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

overflow of type DOMString

See the overflow property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

padding of type DOMString

See the padding property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

paddingBottom of type DOMString

See the padding-bottom property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

paddingLeft of type DOMString

See the padding-left property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

paddingRight of type DOMString

See the padding-right property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

paddingTop of type DOMString

See the padding-top property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

page of type DOMString

See the page property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

pageBreakAfter of type DOMString

See the page-break-after property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

pageBreakBefore of type DOMString

See the page-break-before property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

pageBreakInside of type DOMString

See the page-break-inside property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

pause of type DOMString

See the pause property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

pauseAfter of type DOMString

See the pause-after property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

pauseBefore of type DOMString

See the pause-before property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

pitch of type DOMString

See the pitch property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

pitchRange of type DOMString

See the pitch-range property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

playDuring of type DOMString

See the play-during property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

position of type DOMString

See the position property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

quotes of type DOMString

See the quotes property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

richness of type DOMString

See the richness property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

right of type DOMString

See the right property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

size of type DOMString

See the size property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

speak of type DOMString

See the speak property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

speakHeader of type DOMString

See the speak-header property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

speakNumeral of type DOMString

See the speak-numeral property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

speakPunctuation of type DOMString

See the speak-punctuation property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

speechRate of type DOMString

See the speech-rate property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

stress of type DOMString

See the stress property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

tableLayout of type DOMString

See the table-layout property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

textAlign of type DOMString

See the text-align property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

textDecoration of type DOMString

See the text-decoration property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

textIndent of type DOMString

See the text-indent property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

textShadow of type DOMString

See the text-shadow property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

textTransform of type DOMString

See the text-transform property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

top of type DOMString

See the top property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

unicodeBidi of type DOMString

See the unicode-bidi property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

verticalAlign of type DOMString

See the vertical-align property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

visibility of type DOMString

See the visibility property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

voiceFamily of type DOMString

See the voice-family property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

volume of type DOMString

See the volume property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

whiteSpace of type DOMString

See the white-space property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

widows of type DOMString

See the widows property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

width of type DOMString

See the width property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

wordSpacing of type DOMString

See the word-spacing property definition in CSS2.

Exceptions on setting

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

zIndex of type DOMString

See the z-index property definition in CSS2.

Exceptions on setting

removeEventListener

SYNTAX_ERR: Raised if the new value has a syntax error and is unparsable.

NO_MODIFICATION_ALLOWED_ERR: Raised if this property is readonly.

6. Document Object Model Events

Editors: Tom Pixley, Netscape Communications Corporation

6.1. Overview of the DOM Level 2 Event Model

The DOM Level 2 Event Model is designed with two main goals. The first goal is the design of a generic event system which allows registration of event handlers, describes event flow through a tree structure, and provides basic contextual information for each event. Additionally, the specification will provide standard sets of events for user interface control and document mutation notifications, including defined contextual information for each of these event sets.

The second goal of the event model is to provide a common subset of the current event systems used in DOM Level 0 browsers. This is intended to foster interoperability of existing scripts and content. It is not expected that this goal will be met with full backwards compatibility. However, the specification attempts to achieve this when possible.

The following sections of the Event Model specification define both the specification for the DOM Event Model and a number of compliant event sets designed for use within the model. The Event Model consists of the two sections on event propagation and event listener registration and the Event interface. A DOM consumer can use the hasFeature of the DOMImplementation interface to determine whether the Event Model has been implemented by a DOM implementation. The feature string for the Event Model is "Events". The existence within an implementation of each of the individual event sets can also be queried using the hasFeature method. Each event set describes its own feature string in the event set listing.

6.1.1. Terminology

UI events: User interface events. These events are generated by user interaction through an external device (mouse, keyboard, etc.)
UI Logical events: Device independent user interface events such as focus change messages or element triggering notifications.
Mutation events: Events caused by any action which modifies the structure of the document.
Capturing: The process by which an event can be handled by one of the event's target's ancestors before being handled by the event's target.
Bubbling: The process by which an event propagates upward through its ancestors after being handled by the event's target.
Cancelable: A designation for events which indicates that upon handling the event the client may choose to prevent the DOM implementation from processing any default action associated with the event.

6.2. Description of event flow

Event flow is the process through which the an event originates from the DOM implementation and is passed into the Document Object Model. The methods of event capture and event bubbling, along with various event listener registration techniques, allow the event to then be handled in a number of ways. It can be handled locally at the EventTarget level or centrally from an EventTarget higher in the document tree.

6.2.1. Basic event flow

Each event has an EventTarget toward which the event is directed by the DOM implementation. This EventTarget is specified in the Event's target attribute. When the event reaches the target, any event listeners registered on the EventTarget are triggered. Although all EventListeners on the EventTarget are guaranteed to be triggered by any event which is received by that EventTarget, no specification is made as to the order in which they will receive the event with regards to the other EventListeners on the EventTarget. If neither event capture or event bubbling are in use for that particular event, the event flow process will complete after all listeners have been triggered. If event capture or event bubbling is in use, the event flow will be modified as described in the sections below.

Any exceptions thrown inside an EventListener will not stop propagation of the event. It will continue processing any additional EventListener in the described manner.

It is expected that actions taken by EventListeners may cause additional events to fire. Additional events should be handled in a synchronous manner and may cause reentrancy into the event model.

6.2.2. Event capture

Event capture is the process by which an EventListener registered on an ancestor of the event's target can intercept events of a given type before they are received by the event's target. Capture operates from the top of the tree, generally the Document, downward, making it the symmetrical opposite of bubbling which is described below. The chain of EventTargets from the top of the tree to the event's target is determined before the initial dispatch of the event. If modifications occur to the tree during event processing, event flow will proceed based on the initial state of the tree.

An EventListener being registered on an EventTarget may choose to have that EventListener capture events by specifying the useCapture parameter of the addEventListener method to be true. Thereafter, when an event of the given type is dispatched toward a descendant of the capturing object, the event will trigger any capturing event listeners of the appropriate type which exist in the direct line between the top of the document and the event's target. This downward propagation continues until the event's target is reached. A capturing EventListener will not be triggered by events dispatched directly to the EventTarget upon which it is registered.

If the capturing EventListener wishes to prevent further processing of the event from occurring it may call the stopProgagation method of the Event interface. This will prevent further dispatch of the event, although additional EventListeners registered at the same hierarchy level will still receive the event. Once an event's stopPropagation method has been called, further calls to that method have no additional effect. If no additional capturers exist and stopPropagation has not been called, the event triggers the appropriate EventListeners on the target itself.

Although event capture is similar to the delegation based event model in which all interested parties register their listeners directly on the target about which they wish to receive notifications, it is different in two important respects. First, event capture only allows interception of events which are targeted at descendants of the capturing EventTarget. It does not allow interception of events targeted to the capturer's ancestors, its siblings, or its sibling's descendants. Secondly, event capture is not specified for a single EventTarget, it is specified for a specific type of event. Once specified, event capture intercepts all events of the specified type targeted toward any of the capturer's descendants.

6.2.3. Event bubbling

Events which are designated as bubbling will initially proceed with the same event flow as non-bubbling events. The event is dispatched to its target EventTarget and any event listeners found there are triggered. Bubbling events will then trigger any additional event listeners found by following the EventTarget's parent chain upward, checking for any event listeners registered on each successive EventTarget. This upward propagation will continue up to and including the Document. EventListeners registered as capturers will not be triggered during this phase. The chain of EventTargets from the event target to the top of the tree is determined before the initial dispatch of the event. If modifications occur to the tree during event processing, event flow will proceed based on the initial state of the tree.

Any event handler may choose to prevent further event propagation by calling the stopPropagation method of the Event interface. If any EventListener calls this method, all additional EventListeners on the current EventTarget will be triggered but bubbling will cease at that level. Only one call to stopPropagation is required to prevent further bubbling.

6.2.4. Event cancelation

Some events are specified as cancelable. For these events, the DOM implementation generally has a default action associated with the event. An example of this is a hyperlink in a web browser. When the user clicks on the hyperlink the default action is generally to active that hyperlink. Before processing these events, the implementation must check for event listeners registered to receive the event and dispatch the event to those listeners. These listeners then have the option of canceling the implementation's default action or allowing the default action to proceed. In the case of the hyperlink in the browser, canceling the action would have the result of not activating the hyperlink.

Cancelation is accomplished by calling the Event's preventDefault method. If one or more EventListeners call preventDefault during any phase of event flow the default action will be canceled.

Different implementations will specify their own default actions, if any, associated with each event. The DOM does not attempt to specify these actions.

6.3. Event listener registration

6.3.1. Event registration interfaces

Interface EventTarget (introduced in DOM Level 2)

The EventTarget interface is implemented by all Nodes in an implementation which supports the DOM Event Model. The interface allows registration and removal of EventListeners on an EventTarget and dispatch of events to that EventTarget.

IDL Definition

// Introduced in DOM Level 2:
interface EventTarget {
  void               addEventListener(in DOMString type, 
                                      in EventListener listener, 
                                      in boolean useCapture);
  void               removeEventListener(in DOMString type, 
                                         in EventListener listener, 
                                         in boolean useCapture);
  boolean            dispatchEvent(in Event evt)
                                        raises(EventException);
};

Methods

addEventListener

This method allows the registration of event listeners on the event target. If an EventListener is added to an EventTarget while it is processing an event, it will not be triggered by the current actions but may be triggered during a later stage of event flow, such as the bubbling phase.
If multiple identical EventListeners are registered on the same EventTarget with the same parameters the duplicate instances are discarded. They do not cause the EventListener to be called twice and since they are discarded they do not need to be removed with the removeEventListener method.

Parameters

`DOMString`	`type`	The event type for which the user is registering
`EventListener`	`listener`	The `listener` parameter takes an interface implemented by the user which contains the methods to be called when the event occurs.
`boolean`	`useCapture`	If true, `useCapture` indicates that the user wishes to initiate capture. After initiating capture, all events of the specified type will be dispatched to the registered `EventListener` before being dispatched to any `EventTargets` beneath them in the tree. Events which are bubbling upward through the tree will not trigger an `EventListener` designated to use capture.

No Return Value

No Exceptions

dispatchEvent

This method allows the dispatch of events into the implementations event model. Events dispatched in this manner will have the same capturing and bubbling behavior as events dispatched directly by the implementation. The target of the event is the


     EventTarget

on which dispatchEvent is called.

Parameters

Event

evt

Specifies the event type, behavior, and contextual information to be used in processing the event.

Return Value

boolean

The return value of dispatchEvent indicates whether any of the listeners which handled the event called preventDefault. If preventDefault was called the value is false, else the value is true.

Exceptions

EventException

UNSPECIFIED_EVENT_TYPE_ERR: Raised if the Event's type was not specified by initializing the event before dispatchEvent was called. Specification of the Event's type as null or an empty string will also trigger this exception.

This method allows the removal of event listeners from the event target. If an EventListener is removed from an EventTarget while it is processing an event, it will still be triggered by the current actions but will not be triggered again during any later stages of event flow, such as bubbling.
Calling removeEventListener with arguments which do not identify any currently registered EventListener on the EventTarget has no effect.

Parameters

`DOMString`	`type`	Specifies the event type of the `EventListener` being removed.
`EventListener`	`listener`	The `EventListener` parameter indicates the `EventListener` to be removed.
`boolean`	`useCapture`	Specifies whether the `EventListener` being removed was registered as a capturing listener or not. If a listener was registered twice, one with capture and one without, each must be removed separately. Removal of a capturing listener does not affect a non-capturing version of the same listener, and vice versa.

No Return Value

No Exceptions

Interface EventListener (introduced in DOM Level 2)

The EventListener interface is the primary method for handling events. Users implement the EventListener interface and register their listener on an EventTarget using the AddEventListener method. The users should also remove their EventListener from its EventTarget after they have completed using the listener.

When a Node is copied using the cloneNode method the EventListeners attached to the source Node are not attached to the copied Node. If the user wishes the same EventListeners to be added to the newly created copy the user must add them manually.

IDL Definition

// Introduced in DOM Level 2:
interface EventListener {
  void               handleEvent(in Event evt);
};

Methods

handleEvent

This method is called whenever an event occurs of the type for which the EventListener interface was registered.

Parameters

Event

evt

The Event contains contextual information about the event. It also contains the stopPropagation and preventDefault methods which are used in determining the event's flow and default action.

No Return Value

No Exceptions

6.3.2. Interaction with HTML 4.0 event listeners

In HTML 4.0, event listeners were specified as attributes of an element. As such, registration of a second event listener of the same type would replace the first listener. The DOM Event Model allows registration of multiple event listeners on a single Node. To achieve this, event listeners are no longer stored as attribute values.

In order to achieve compatibility with HTML 4.0, implementors may view the setting of attributes which represent event handlers as the creation and registration of an EventListener on the Node. The value of useCapture defaults to false. This EventListener behaves in the same manner as any other EventListeners which may be registered on the EventTarget. If the attribute representing the event listener is changed, this may be viewed as the removal of the previously registered EventListener and the registration of a new one. No technique is provided to allow HTML 4.0 event listeners access to the context information defined for each event.

6.4. Event interface

Interface Event (introduced in DOM Level 2)

The Event interface is used to provide contextual information about an event to the handler processing the event. An object which implements the Event interface is generally passed as the first parameter to an event handler. More specific context information is passed to event handlers by deriving additional interfaces from Event which contain information directly relating to the type of event they accompany. These derived interfaces are also implemented by the object passed to the event listener.

IDL Definition

// Introduced in DOM Level 2:
interface Event {
  // PhaseType
  const unsigned short      CAPTURING_PHASE                = 1;
  const unsigned short      AT_TARGET                      = 2;
  const unsigned short      BUBBLING_PHASE                 = 3;

  readonly attribute DOMString        type;
  readonly attribute EventTarget      target;
  readonly attribute Node             currentNode;
  readonly attribute unsigned short   eventPhase;
  readonly attribute boolean          bubbles;
  readonly attribute boolean          cancelable;
  readonly attribute DOMTimeStamp     timeStamp;
  void               stopPropagation();
  void               preventDefault();
  void               initEvent(in DOMString eventTypeArg, 
                               in boolean canBubbleArg, 
                               in boolean cancelableArg);
};

Definition group PhaseType

An integer indicating which phase of event flow is being processed.

Defined Constants

AT_TARGET	The event is currently being evaluated at the target node.
BUBBLING_PHASE	The current event phase is the bubbling phase.
CAPTURING_PHASE	The current event phase is the capturing phase.

Attributes

bubbles of type boolean, readonly: Used to indicate whether or not an event is a bubbling event. If the event can bubble the value is true, else the value is false.
cancelable of type boolean, readonly: Used to indicate whether or not an event can have its default action prevented. If the default action can be prevented the value is true, else the value is false.
currentNode of type Node, readonly: Used to indicate the Node whose EventListeners are currently being processed. This is particularly useful during capturing and bubbling.
eventPhase of type unsigned short, readonly: Used to indicate which phase of event flow is currently being evaluated.
target of type EventTarget, readonly: Used to indicate the EventTarget to which the event was originally dispatched.
timeStamp of type DOMTimeStamp, readonly: Used to specify the time (in milliseconds relative to the epoch) at which the event was created. Due to the fact that some systems may not provide this information the value of timeStamp may be not available for all events. When not available, a value of 0 will be returned. Examples of epoch time are the time of the system start or 0:0:0 UTC 1st January 1970.
type of type DOMString, readonly: The name of the event (case-insensitive). The name must be an XML name.

Methods

initEvent

The initEvent method is used to initialize the value of an Event created through the DocumentEvent interface. This method may only be called before the Event has been dispatched via the dispatchEvent method, though it may be called multiple times during that phase if necessary. If called multiple times the final invocation takes precedence. If called from a subclass of Event interface only the values specified in the initEvent method are modified, all other attributes are left unchanged.

Parameters

eventTypeArg

Specifies the event type. This type may be any event type currently defined in this specification or a new event type.. The string must be an XML name.

Any new event type must not begin with any upper, lower, or mixed case version of the string "DOM". This prefix is reserved for future DOM event sets.

boolean

canBubbleArg

Specifies whether or not the event can bubble.

boolean

cancelableArg

Specifies whether or not the event's default action can be prevented.

No Return Value

No Exceptions

preventDefault

If an event is cancelable, the preventDefault method is used to signify that the event is to be canceled, meaning any default action normally taken by the implementation as a result of the event will not occur. If, during any stage of event flow, the preventDefault method is called the event is canceled. Any default action associated with the event will not occur. Calling this method for a non-cancelable event has no effect. Once preventDefault has been called it will remain in effect throughout the remainder of the event's propagation. This method may be used during any stage of event flow.

No Parameters

No Return Value

No Exceptions

stopPropagation

The stopPropagation method is used prevent further propagation of an event during event flow. If this method is called by any EventListener the event will cease propagating through the tree. The event will complete dispatch to all listeners on the current EventTarget before event flow stops. This method may be used during any stage of event flow.

No Parameters

No Return Value

No Exceptions

Exception EventException introduced in DOM Level 2

Event operations may throw an EventException as specified in their method descriptions.

IDL Definition

// Introduced in DOM Level 2:
exception EventException {
  unsigned short   code;
};

// EventExceptionCode
const unsigned short      UNSPECIFIED_EVENT_TYPE_ERR     = 0;

Definition group EventExceptionCode

An integer indicating the type of error generated.

Defined Constants

UNSPECIFIED_EVENT_TYPE_ERR If the Event's type was not specified by initializing the event before the method was called. Specification of the Event's type as null or an empty string will also trigger this exception.

6.5. DocumentEvent interface

Interface DocumentEvent (introduced in DOM Level 2)

The DocumentEvent interface provides a mechanism by which the user can create an Event of a type supported by the implementation. It is expected that the DocumentEvent interface will be implemented on the same object which implements the Document interface in an implementation which supports the Event model.

IDL Definition

// Introduced in DOM Level 2:
interface DocumentEvent {
  Event              createEvent(in DOMString eventType)
                                        raises(DOMException);
};

Methods

createEvent

Parameters

eventType

The eventType parameter specifies the type of Event interface to be created. If the Event interface specified is supported by the implementation this method will return a new Event of the interface type requested. If the Event is to be dispatched via the dispatchEvent method the appropriate event init method must be called after creation in order to initialize the Event's values. As an example, a user wishing to synthesize some kind of UIEvent would call createEvent with the parameter "UIEvents". The initUIEvent method could then be called on the newly created UIEvent to set the specific type of UIEvent to be dispatched and set its context information.

The createEvent method is used in creating Events when it is either inconvenient or unnecessary for the user to create an Event themselves. In cases where the implementation provided Event is insufficient, users may supply their own Event implementations for use with the dispatchEvent method.

Return Value

Event

The newly created Event

Exceptions

NOT_SUPPORTED_ERR: Raised if the implementation does not support the type of Event interface requested

6.6. Event set definitions

The DOM Level 2 Event Model allows a DOM implementation to support multiple sets of events. The model has been designed to allow addition of new event sets as is required. The DOM will not attempt to define all possible events. For purposes of interoperability, the DOM will define a set of user interface events including lower level device dependent events, a set of UI logical events, and a set of document mutation events.

6.6.1. User Interface event types

The User Interface event set is composed of events listed in HTML 4.0 and additional events which are supported in DOM Level 0 browsers.

A DOM consumer can use the hasFeature of the DOMImplementation interface to determine whether the User Interface event set has been implemented by a DOM implementation. The feature string for this event set is "UIEvents". This string is also used with the createEvent method.

Interface UIEvent (introduced in DOM Level 2)

The UIEvent interface provides specific contextual information associated with User Interface events.

IDL Definition

// Introduced in DOM Level 2:
interface UIEvent : Event {
  readonly attribute views::AbstractView  view;
  readonly attribute long             detail;
  void               initUIEvent(in DOMString typeArg, 
                                 in boolean canBubbleArg, 
                                 in boolean cancelableArg, 
                                 in views::AbstractView viewArg, 
                                 in long detailArg);
};

Attributes

detail of type long, readonly: Specifies some detail information about the Event, depending on the type of event.
view of type views::AbstractView, readonly: The view attribute identifies the AbstractView from which the event was generated.

Methods

initUIEvent

The initUIEvent method is used to initialize the value of a UIEvent created through the DocumentEvent interface. This method may only be called before the UIEvent has been dispatched via the dispatchEvent method, though it may be called multiple times during that phase if necessary. If called multiple times, the final invocation takes precedence.

Parameters

`DOMString`	`typeArg`	Specifies the event type.
`boolean`	`canBubbleArg`	Specifies whether or not the event can bubble.
`boolean`	`cancelableArg`	Specifies whether or not the event's default action can be prevented.
`views::AbstractView`	`viewArg`	Specifies the `Event`'s `AbstractView`.
`long`	`detailArg`	Specifies the `Event`'s detail.

No Return Value

No Exceptions

The different types of such events that can occur are:

DOMFocusIn

The focusin event occurs when a node receives focus, for instance via a pointing device being moved onto an element or by tabbing navigation to the element. Unlike the HTML event focus, focusin can be applied to any node, not just FORM controls.

Bubbles: Yes
Cancelable: No
Context Info: None

DOMFocusOut

The focusout event occurs when a node loses focus, for instance via a pointing device being moved out of an element or by tabbing navigation out of the element. Unlike the HTML event blur, focusout can be applied to any node, not just FORM controls.

Bubbles: Yes
Cancelable: No
Context Info: None

DOMActivate

The activate event occurs when an element is activated, for instance, thru a mouse click or a keypress. A numerical argument is provided to give an indication of the type of activation that occurs: 1 for a simple activation (e.g. a simple click or Enter), 2 for hyperactivation (for instance a double click or Shift Enter).

Bubbles: Yes
Cancelable: Yes
Context Info: detail (the numerical value)

6.6.2. Mouse event types

The Mouse event set is composed of events listed in HTML 4.0 and additional events which are supported in DOM Level 0 browsers. This event set is specifically designed for use with mouse input devices.

A DOM consumer can use the hasFeature of the DOMImplementation interface to determine whether the User Interface event set has been implemented by a DOM implementation. The feature string for this event set is "MouseEvents". This string is also used with the createEvent method.

Interface MouseEvent (introduced in DOM Level 2)

The MouseEvent interface provides specific contextual information associated with Mouse events.

The detail attribute inherited from UIEvent indicates the number of times a mouse button has been pressed and released over the same screen location during a user action. The attribute value is 1 when the user begins this action and increments by 1 for each full sequence of pressing and releasing. If the user moves the mouse between the mousedown and mouseup the value will be set to 0, indicating that no click is occurring.

In the case of nested elements mouse events are always targeted at the most deeply nested element. Ancestors of the targeted element may use bubbling to obtain notification of mouse events which occur within its descendent elements.

IDL Definition

// Introduced in DOM Level 2:
interface MouseEvent : UIEvent {
  readonly attribute long             screenX;
  readonly attribute long             screenY;
  readonly attribute long             clientX;
  readonly attribute long             clientY;
  readonly attribute boolean          ctrlKey;
  readonly attribute boolean          shiftKey;
  readonly attribute boolean          altKey;
  readonly attribute boolean          metaKey;
  readonly attribute unsigned short   button;
  readonly attribute Node             relatedNode;
  void               initMouseEvent(in DOMString typeArg, 
                                    in boolean canBubbleArg, 
                                    in boolean cancelableArg, 
                                    in views::AbstractView viewArg, 
                                    in long detailArg, 
                                    in long screenXArg, 
                                    in long screenYArg, 
                                    in long clientXArg, 
                                    in long clientYArg, 
                                    in boolean ctrlKeyArg, 
                                    in boolean altKeyArg, 
                                    in boolean shiftKeyArg, 
                                    in boolean metaKeyArg, 
                                    in unsigned short buttonArg, 
                                    in Node relatedNodeArg);
};

Attributes

altKey of type boolean, readonly: Used to indicate whether the 'alt' key was depressed during the firing of the event. On some platforms this key may map to an alternative key name.
button of type unsigned short, readonly: During mouse events caused by the depression or release of a mouse button, button is used to indicate which mouse button changed state. The values for button range from zero to indicate the left button of the mouse, one to indicate the middle button if present, and two to indicate the right button. For mice configured for left handed use in which the button actions are reversed the values are instead read from right to left.
clientX of type long, readonly: The horizontal coordinate at which the event occurred relative to the DOM implementation's client area.
clientY of type long, readonly: The vertical coordinate at which the event occurred relative to the DOM implementation's client area.
ctrlKey of type boolean, readonly: Used to indicate whether the 'ctrl' key was depressed during the firing of the event.
metaKey of type boolean, readonly: Used to indicate whether the 'meta' key was depressed during the firing of the event. On some platforms this key may map to an alternative key name.
relatedNode of type Node, readonly: Used to identify a secondary node related to a UI event. Currently this attribute is used with the mouseover event to indicate the Node which the pointing device exited and with the mouseout event to indicate the Node which the pointing device entered.
screenX of type long, readonly: The horizontal coordinate at which the event occurred relative to the origin of the screen coordinate system.
screenY of type long, readonly: The vertical coordinate at which the event occurred relative to the origin of the screen coordinate system.
shiftKey of type boolean, readonly: Used to indicate whether the 'shift' key was depressed during the firing of the event.

Methods

initMouseEvent

The initMouseEvent method is used to initialize the value of a MouseEvent created through the DocumentEvent interface. This method may only be called before the MouseEvent has been dispatched via the dispatchEvent method, though it may be called multiple times during that phase if necessary. If called multiple times, the final invocation takes precedence.

Parameters

`DOMString`	`typeArg`	Specifies the event type.
`boolean`	`canBubbleArg`	Specifies whether or not the event can bubble.
`boolean`	`cancelableArg`	Specifies whether or not the event's default action can be prevented.
`views::AbstractView`	`viewArg`	Specifies the `Event`'s `AbstractView`.
`long`	`detailArg`	Specifies the `Event`'s mouse click count.
`long`	`screenXArg`	Specifies the `Event`'s screen x coordinate
`long`	`screenYArg`	Specifies the `Event`'s screen y coordinate
`long`	`clientXArg`	Specifies the `Event`'s client x coordinate
`long`	`clientYArg`	Specifies the `Event`'s client y coordinate
`boolean`	`ctrlKeyArg`	Specifies whether or not control key was depressed during the `Event`.
`boolean`	`altKeyArg`	Specifies whether or not alt key was depressed during the `Event`.
`boolean`	`shiftKeyArg`	Specifies whether or not shift key was depressed during the `Event`.
`boolean`	`metaKeyArg`	Specifies whether or not meta key was depressed during the `Event`.
`unsigned short`	`buttonArg`	Specifies the `Event`'s mouse button.
`Node`	`relatedNodeArg`	Specifies the `Event`'s related Node.

No Return Value

No Exceptions

The different types of Mouse events that can occur are:

click

The click event occurs when the pointing device button is clicked over an element. A click is defined as a mousedown and mouseup over the same screen location. The sequence of these events is:

    mousedown
    mouseup
    click

If multiple clicks occur at the same screen location, the sequence repeats with the detail attribute incrementing with each repetition. This event is valid for most elements.

Bubbles: Yes
Cancelable: Yes
Context Info: screenX, screenY, clientX, clientY, altKey, ctrlKey, shiftKey, metaKey, button, detail

mousedown

The mousedown event occurs when the pointing device button is pressed over an element. This event is valid for most elements.

Bubbles: Yes
Cancelable: Yes
Context Info: screenX, screenY, clientX, clientY, altKey, ctrlKey, shiftKey, metaKey, button, detail

mouseup

The mouseup event occurs when the pointing device button is released over an element. This event is valid for most elements.

Bubbles: Yes
Cancelable: Yes
Context Info: screenX, screenY, clientX, clientY, altKey, ctrlKey, shiftKey, metaKey, button, detail

mouseover

The mouseover event occurs when the pointing device is moved onto an element. This event is valid for most elements.

Bubbles: Yes
Cancelable: Yes
Context Info: screenX, screenY, clientX, clientY, altKey, ctrlKey, shiftKey, metaKey, relatedNode indicates the Node the pointing device is exiting.

mousemove

The mousemove event occurs when the pointing device is moved while it is over an element. This event is valid for most elements.

Bubbles: Yes
Cancelable: No
Context Info: screenX, screenY, clientX, clientY, altKey, ctrlKey, shiftKey, metaKey

mouseout

The mouseout event occurs when the pointing device is moved away from an element. This event is valid for most elements..

Bubbles: Yes
Cancelable: Yes
Context Info: screenX, screenY, clientX, clientY, altKey, ctrlKey, shiftKey, metaKey, relatedNode indicates the Node the pointing device is entering.

6.6.3. Key events

The DOM Level 2 Event specification does not provide a key event set. An event set designed for use with keyboard input devices will be included in a later version of the DOM specification.

6.6.4. Mutation event types

The mutation event set is designed to allow notification of any changes to the structure of a document, including attr and text modifications. It may be noted that none of the mutation events listed are designated as cancelable. This stems from the fact that it is very difficult to make use of existing DOM interfaces which cause document modifications if any change to the document might or might not take place due to cancelation of the related event. Although this is still a desired capability, it was decided that it would be better left until the addition of transactions into the DOM.

Many single modifications of the tree can cause multiple mutation events to be fired. Rather than attempt to specify the ordering of mutation events due to every possible modification of the tree, the ordering of these events is left to the implementation.

A DOM consumer can use the hasFeature of the DOMImplementation interface to determine whether the mutation event set has been implemented by a DOM implementation. The feature string for this event set is "MutationEvents". This string is also used with the createEvent method.

Interface MutationEvent (introduced in DOM Level 2)

The MutationEvent interface provides specific contextual information associated with Mutation events.

IDL Definition

// Introduced in DOM Level 2:
interface MutationEvent : Event {
  readonly attribute Node             relatedNode;
  readonly attribute DOMString        prevValue;
  readonly attribute DOMString        newValue;
  readonly attribute DOMString        attrName;
  void               initMutationEvent(in DOMString typeArg, 
                                       in boolean canBubbleArg, 
                                       in boolean cancelableArg, 
                                       in Node relatedNodeArg, 
                                       in DOMString prevValueArg, 
                                       in DOMString newValueArg, 
                                       in DOMString attrNameArg);
};

Attributes

attrName of type DOMString, readonly: attrName indicates the name of the changed Attr node in a DOMAttrModified event.
newValue of type DOMString, readonly: newValue indicates the new value of the Attr node in DOMAttrModified events, and of the CharacterData node in DOMCharDataModified events.
prevValue of type DOMString, readonly: prevValue indicates the previous value of the Attr node in DOMAttrModified events, and of the CharacterData node in DOMCharDataModified events.
relatedNode of type Node, readonly: relatedNode is used to identify a secondary node related to a mutation event. For example, if a mutation event is dispatched to a node indicating that its parent has changed, the relatedNode is the changed parent. If an event is instead dispatch to a subtree indicating a node was changed within it, the relatedNode is the changed node.

Methods

initMutationEvent

The initMutationEvent method is used to initialize the value of a MutationEvent created through the DocumentEvent interface. This method may only be called before the MutationEvent has been dispatched via the dispatchEvent method, though it may be called multiple times during that phase if necessary. If called multiple times, the final invocation takes precedence.

Parameters

`DOMString`	`typeArg`	Specifies the event type.
`boolean`	`canBubbleArg`	Specifies whether or not the event can bubble.
`boolean`	`cancelableArg`	Specifies whether or not the event's default action can be prevented.
`Node`	`relatedNodeArg`	Specifies the `Event`'s related Node
`DOMString`	`prevValueArg`	Specifies the `Event`'s `prevValue` attribute
`DOMString`	`newValueArg`	Specifies the `Event`'s `newValue` attribute
`DOMString`	`attrNameArg`	Specifies the `Event`'s `attrName` attribute

No Return Value

No Exceptions

The different types of Mutation events that can occur are:

DOMSubtreeModified

This is a general event for notification of all changes to the document. It can be used instead of the more specific events listed below. It may be fired after a single modification to the document or, at the implementation's discretion, after multiple changes have occurred. The latter use should generally be used to accomodate multiple changes which occur either simultaneously or in rapid succession. The target of this event is the lowest common parent of the changes which have taken place. This event is dispatched after any other events caused by the mutation have fired.

Bubbles: Yes
Cancelable: No
Context Info: None

DOMNodeInserted

Fired when a node has been added as a child of another node. This event is dispatched after the insertion has taken place. The target of this event is the node being inserted.

Bubbles: Yes
Cancelable: No
Context Info: relatedNode holds the parent node

DOMNodeRemoved

Fired when a node is being removed from another node. This event is dispatched before the node is removed from the tree. The target of this event is the node being removed.

Bubbles: Yes
Cancelable: No
Context Info: relatedNode holds the parent node

DOMNodeRemovedFromDocument

Fired when a node is being removed from a document, either through direct removal of the Node or removal of a subtree in which it is contained. This event is dispatched before the removal takes place. The target of this event is the node being removed. If the Node is being directly removed the nodeRemoved event will fire before the nodeRemovedFromDocument event.

Bubbles: No
Cancelable: No
Context Info: None

DOMNodeInsertedIntoDocument

Fired when a node is being inserted into a document, either through direct insertion of the Node or insertion of a subtree in which it is contained. This event is dispatched after the insertion has taken place. The target of this event is the node being inserted. If the Node is being directly inserted the nodeInserted event will fire before the nodeInsertedIntoDocument event.

Bubbles: No
Cancelable: No
Context Info: None

DOMAttrModified

Fired after an Attr has been modified on a node. The target of this event is the Node whose Attr changed. The values of prevValue and newValue may be the empty string in cases where an attribute has been added or removed.

Bubbles: Yes
Cancelable: No
Context Info: attrName, prevValue, newValue

DOMCharacterDataModified

Fired after CharacterData within a node has been modified but the node itself has not been inserted or deleted. This event is also triggered by modifications to PI elements. The target of this event is the CharacterData node.

Bubbles: Yes
Cancelable: No
Context Info: prevValue, newValue

6.6.5. HTML event types

The HTML event set is composed of events listed in HTML 4.0 and additional events which are supported in DOM Level 0 browsers.

A DOM consumer can use the hasFeature of the DOMImplementation interface to determine whether the HTML event set has been implemented by a DOM implementation. The feature string for this event set is "HTMLEvents". This string is also used with the createEvent method.

The HTML events use the base DOM Event interface to pass contextual information.

The different types of such events that can occur are:

load

The load event occurs when the DOM implementation finishes loading all content within a document, all frames within a FRAMESET, or an OBJECT element.

Bubbles: No
Cancelable: No
Context Info: None

unload

The unload event occurs when the DOM implementation removes a document from a window or frame. This event is valid for BODY and FRAMESET elements.

Bubbles: No
Cancelable: No
Context Info: None

abort

The abort event occurs when page loading is stopped before an image has been allowed to completely load. This event applies to OBJECT elements.

Bubbles: Yes
Cancelable: No
Context Info: None

error

The error event occurs when an image does not load properly or when an error occurs during script execution. This event is valid for OBJECT elements, BODY elements, and FRAMESET element.

Bubbles: Yes
Cancelable: No
Context Info: None

select

The select event occurs when a user selects some text in a text field. This event is valid for INPUT and TEXTAREA elements.

Bubbles: Yes
Cancelable: No
Context Info: None

change

The change event occurs when a control loses the input focus and its value has been modified since gaining focus. This event is valid for INPUT, SELECT, and TEXTAREA. element.

Bubbles: Yes
Cancelable: No
Context Info: None

submit

The submit event occurs when a form is submitted. This event only applies to the FORM element.

Bubbles: Yes
Cancelable: Yes
Context Info: None

reset

The reset event occurs when a form is reset. This event only applies to the FORM element.

Bubbles: Yes
Cancelable: No
Context Info: None

focus

The focus event occurs when an element receives focus either via a pointing device or by tabbing navigation. This event is valid for the following elements: LABEL, INPUT, SELECT, TEXTAREA, and BUTTON.

Bubbles: No
Cancelable: No
Context Info: None

blur

The blur event occurs when an element loses focus either via the pointing device or by tabbing navigation. This event is valid for the following elements: LABEL, INPUT, SELECT, TEXTAREA, and BUTTON.

Bubbles: No
Cancelable: No
Context Info: None

resize

The resize event occurs when a document view is resized.

Bubbles: Yes
Cancelable: No
Context Info: None

scroll

The scroll event occurs when a document view is scrolled.

Bubbles: Yes
Cancelable: No
Context Info: None

7. Document Object Model Traversal

Editors: Mike Champion, Software AG; Joe Kesselman, IBM; Jonathan Robie, Software AG

7.1. Overview

This chapter describes the optional DOM Level 2 Traversal feature. Its TreeWalker, NodeIterator, and Filter interfaces provide easy-to-use, robust, selective traversal for document nodes. A DOM application can use the hasFeature method of the DOMImplementation interface to determine whether they are supported or not. The feature string for all the interfaces listed in this section is "Traversal". Iterators and TreeWalkers are two different ways of representing the nodes of a document subtree and a position within the nodes they present. A NodeIterator presents a flattened view of the subtree as an ordered sequence of document nodes, presented in document order. Because this view is presented without respect to hierarchy, iterators have methods to move forward and backward, but not to move up and down. A TreeWalker maintains the hierarchical relationships of the subtree, allowing navigation of this hierarchy. In general, TreeWalkers are better for tasks in which the structure of the document around selected nodes will be manipulated, while iterators are better for tasks that focus on the content of each selected node.

Iterators and TreeWalkers each present a view of a document subtree that may not contain all nodes found in the subtree. In this specification, we refer to this as the logical view to distinguish it from the physical view, which corresponds to the document subtree per se. When an iterator or TreeWalker is created, it may be associated with a Filter, which examines a node and determines whether it should appear in the logical view. In addition, flags may be used to specify which node types should occur in the logical view.

Iterators and TreeWalkers are dynamic - the logical view changes to reflect changes made to the underlying document. However, they differ in how they respond to those changes. NodeIterators, which present the nodes sequentially, attempt to maintain their location relative to a position in that sequence when the sequence's contents change. TreeWalkers, which present the nodes as a filtered tree, maintain their location relative to their current node, and remain attached to that node if it is moved to a new context. We will discuss these behaviors in greater detail below.

7.1.1. Iterators

An iterator allows the members of a list of nodes to be returned sequentially. In the current DOM interfaces, this list will always consist of the nodes of a subtree, presented in document order. When an iterator is first created, calling nextNode() returns the first node in the logical view of the subtree; in most cases, this is the root of the subtree. When no more nodes are present, nextNode() returns null.

Iterators are created using the createNodeIterator method found in the DocumentTraversal interface. When a NodeIterator is created, flags can be used to determine which node types will be "visible" and which nodes will be "invisible" while traversing the tree; these flags can be combined using the OR operator. Nodes that are "invisible" are skipped over by the iterator as though they did not exist. The following code creates an iterator, then calls a function to print the name of each element:

	NodeIterator iter=((DocumentTraversal)document).createNodeIterator(root, NodeFilter.SHOW_ELEMENT, null);

	while (Node n = iter.nextNode())
	printMe(n);

7.1.1.1. Moving Forward and Backward

Iterators present nodes as an ordered list, and move forward and backward within this list. The iterator's position is always between two nodes, before the first node, or after the last node. When an iterator is first created, the position is set before the first item. The following diagram shows the list view that an iterator might provide for a particular subtree, with the position indicated by an asterisk '*' :

 * A B C D E F G H I

Each call to nextNode() returns the next node and advances the position. For instance, if we start with the above position, the first call to nextNode() returns "A" and advances the iterator:

 [A] * B C D E F G H I

The position of an iterator can best be described with respect to the last node returned, which we will call the reference node. When an iterator is created, the first node is the reference node, and the iterator is positioned before the reference node. In these diagrams, we use square brackets to indicate the reference node.

A call to previousNode() returns the previous node and moves the position backward. For instance, if we start with the iterator between "A" and "B", it would return "A" and move to the position shown below:

 * [A] B C D E F G H I

If nextNode() is called at the end of a list, or previousNode() is called at the beginning of a list, it returns null and does not change the position of the iterator. When an iterator is first created, the reference node is the first node:

 * [A] B C D E F G H I

7.1.1.2. Robustness

An iterator may be active while the data structure it navigates is being edited, so an iterator must behave gracefully in the face of change. Additions and removals in the underlying data structure do not invalidate an iterator; in fact, an iterator is never invalidated unless its detach() method is invoked. To make this possible, the iterator uses the reference node to maintain its position. The state of an iterator also depends on whether the iterator is positioned before or after the reference node. If the reference node is removed, another node becomes the reference node.

If changes to the iterated list do not remove the reference node, they do not affect the state of the iterator. For instance, the iterator's state is not affected by inserting new nodes in the vicinity of the iterator or removing nodes other than the reference node. Suppose we start from the following position:

A B C [D] * E F G H I

Now let's remove "E". The resulting state is:

A B C [D] * F G H I

If a new node is inserted, the iterator stays close to the reference node, so if a node is inserted between "D" and "F", it will occur between the iterator and "F":

A B C [D] * X F G H I

Moving a node is equivalent to a removal followed by an insertion. If we move "I" to the position before "X" the result is:

A B C [D] * I X F G H

If the reference node is removed, a different node is selected as the reference node. If the reference node is before the iterator, which is usually the case after nextNode() has been called, the nearest node before the iterator is chosen as the new reference node. Suppose we remove the "D" node, starting from the following state:

A B C [D] * F G H I

The "C" node becomes the new reference node, since it is the nearest node to the iterator that is before the iterator:

A B [C] * F G H I

If the reference node is after the iterator, which is usually the case after previousNode() has been called, the nearest node after the iterator is chosen as the new reference node. Suppose we remove "E", starting from the following state:

A B C D * [E] F G H I

The "F" node becomes the new reference node, since it is the nearest node to the iterator that is after the iterator:

A B C D * [F] G H I

Moving a node is equivalent to a removal followed by an insertion. Suppose we wish to move the "D" node to the end of the list, starting from the following state:

A B C [D] * F G H I C

The resulting state is as follows:

A B [C] * F G H I D

One special case arises when the reference node is the last node in the list and the reference node is removed. Suppose we remove node "C", starting from the following state:

A B * [C]

According to the rules we have given, the new reference node should be the nearest node after the iterator, but there are no further nodes after "C". The same situation can arise when previousNode() has just returned the first node in the list, which is then removed. Hence: If there is no node in the original direction of the reference node, the nearest node in the opposite direction is selected as the reference node:

A [B] *

If the iterator is positioned within a block of nodes that is removed, the above rules clearly indicate what is to be done. For instance, suppose "C" is the parent node of "D", "E", and "F", and we remove "C", starting with the following state:

A B C [D] * E F G H I D

The resulting state is as follows:

A [B] * G H I D

7.1.1.3. Visibility of Nodes

The underlying data structure that is being iterated may contain nodes that are not part of the logical view, and therefore will not be returned by the iterator. If invisible nodes are present, nextNode() returns the next visible node, skipping over nodes that are to be excluded because of the value of the whatToShow flag. If a filter is present, it is applied before returning a node; if the filter does not accept the node, the process is repeated until a node is accepted by the filter. That node is returned. If no visible nodes are encountered, a null is returned and the iterator is positioned at the end of the list. In this case, the reference node is the last node in the list, whether or not it is visible. The same approach is taken, in the opposite direction, for previousNode().

In the following examples, we will use lowercase letters to represent nodes that are in the data structure, but which are not in the logical view. For instance, consider the following list:

A [B] * c d E F G

A call to nextNode() returns E and advances to the following position:

A B c d [E] * F G

Nodes that are not visible may nevertheless be used as reference nodes if a reference node is removed. Suppose node "E" is removed, started from the state given above. The resulting state is:

A B c [d] * F G

Suppose a new node "X", which is visible, is inserted before "d". The resulting state is:

A B c X [d] * F G

Note that a call to previousNode() now returns node X. It is important not to skip over invisible nodes when the reference node is removed, because there are cases, like the one just given above, where the wrong results will be returned. When "E" was removed, if the new reference node had been "B" rather than "d", calling previousNode() would not return "X".

7.1.2. Filters

Filters allow the user to create objects that "filter out" nodes. Each filter contains a user-written function that looks at a node and determines whether or not it should be filtered out. To use a filter, you create a NodeIterator or a TreeWalker that uses the filter. The Iterator or TreeWalker applies the filter to each node, and if the filter does not accept the node, the iterator or TreeWalker skips over the node as though it were not present in the document. Filters need not know how to navigate the structure that contains the nodes on which they operate.

Filters will be consulted when a traversal operation is performed, or when a NodeIterator's reference node is removed from the subtree being iterated over and it must select a new one. However, the exact timing of these filter calls may vary from one DOM implementation to another. For that reason, filters should not attempt to maintain state based on the history of past invocations; the resulting behavior may not be portable.

Similarly, TreeWalkers and NodeIterators should behave as if they have no memory of past filter results, and no anticipation of future results. If the conditions a filter is examining have changed (e.g., an attribute which it tests has been added or removed) since the last time the traversal logic examined this node, this change in visibility will be discovered only when the next traversal operation is performed. For example: if the filtering for the current node changes from FILTER_SHOW to FILTER_SKIP, a TreeWalker will be able to navigate off that node in any direction, but not back to it unless the filtering conditions change again. Filters which change during a traversal can be written, but their behavior may be confusing and they should be avoided when possible.

7.1.2.1. Using Filters

A Filter contains one method named acceptNode(), which allows an iterator or TreeWalker to pass a Node to a filter and ask whether it should be present in the logical view. The acceptNode() function returns one of three values to state how the Node should be treated. If acceptNode() returns FILTER_ACCEPT, the Node will be present in the logical view; if it returns FILTER_SKIP, the Node will not be present in the logical view, but the children of the Node may; if it returns FILTER_REJECT, neither the Node nor its descendants will be present in the logical view. Since iterators present nodes as an ordered list, without hierarchy, FILTER_REJECT and FILTER_SKIP are synonyms for iterators, skipping only the single current node.

Consider a filter that accepts the named anchors in an HTML document. In HTML, an HREF can refer to any A element that has a NAME attribute. Here is a filter in Java that looks at a node and determines whether it is a named anchor:

	class NamedAnchorFilter implements NodeFilter
	{
		short acceptNode(Node n) {
			if (n.getNodeType()==Node.ELEMENT_NODE) {
				Element e = (Element)n;
			if (! e.getNodeName().equals("A"))
				return FILTER_SKIP;
			if (e.getAttributeNode("NAME") != null) {
				return FILTER_ACCEPT;
	  		}
	  	}
	  	return FILTER_SKIP;
	  }
	}

If the above Filter were to be used only with NodeIterators, it could have used FILTER_REJECT wherever FILTER_SKIP is used, and the behavior would not change. For TreeWalker, though, FILTER_REJECT would reject the children of any element that is not a named anchor, and since named anchors are always contained within other elements, this would have meant that no named anchors would be found. FILTER_SKIP rejects the given node, but continues to examine the children; therefore, the above filter will work with either a NodeIterator or a TreeWalker.

To use this filter, the user would create an instance of the filter and create an iterator using it:

	  NamedAnchorFilter myFilter = new NamedAnchorFilter(); 
	  NodeIterator iter=((DocumentTraversal)document).createNodeIterator(node, NodeFilter.SHOW_ELEMENT, myFilter);

Note that the use of the SHOW_ELEMENT flag is not strictly necessary in this example, since our sample Filter tests the nodeType. However, some implementations of the Traversal interfaces may be able to improve whatToShow performance by taking advantage of knowledge of the document's structure, which makes the use of SHOW_ELEMENT worthwhile. Conversely, while we could remove the nodeType test from our Filter, that would make it dependent upon whatToShow to distinguish between Elements, Attr's, and ProcessingInstructions.

7.1.2.2. Filters and Exceptions

When writing a Filter, users should avoid writing code that can throw an exception. However, because an implementation can not prevent users from doing so, it is important that the behavior of filters that throw an exception be well-defined. A TreeWalker or NodeIterator does not catch or alter an exception thrown by a filter, but lets it propagate up to the user's code. The following functions may invoke a Filter, and may therefore propagate an exception if one is thrown by a Filter:

NodeIterator.nextNode()
NodeIterator.previousNode()
TreeWalker.firstChild()
TreeWalker.lastChild()
TreeWalker.nextSibling()
TreeWalker.previousSibling()
TreeWalker.nextNode()
TreeWalker.previousNode()
TreeWalker.parentNode()

7.1.2.3. Filters and Document Mutation

Well-designed Filters do not modify the underlying document structure, but a Filter implementation can not prevent a user from writing code that does modify the document structure. Filters do not provide any special processing to handle this case. For instance, if a Filter removes a node from a document, it can still accept the node, which means that the node may be returned by the NodeIterator or TreeWalker even though it is no longer in the document. In general, this may lead to inconsistent, confusing results, so we encourage users to write Filters that make no changes to document structures.

7.1.2.4. Filters and whatToShow flags

Iterator and TreeWalker apply whatToShow flags before applying Filters. If a node is skipped by the active whatToShow flags, a Filter will not be called to evaluate that node. Please note that this behavior is similar to that of FILTER_SKIP; children of that node will be considered, and Filters may be called to evaluate them. Also note that it will in fact be a "skip" even if the Filter would have preferred to reject the entire subtree; if this would cause a problem in your application, consider setting whatToShow to SHOW_ALL and performing the nodeType test inside your filter.

7.1.3. TreeWalker

The TreeWalker interface provides many of the same benefits as the NodeIterator interface. The main difference between these two interfaces is that the TreeWalker presents a tree-oriented view of the nodes in a subtree, and an iterator presents a list-oriented view. In other words, an iterator allows you to move forward or back, but a TreeWalker allows you to move to the parent of a node, to one of its children, or to a sibling.

Using a TreeWalker is quite similar to navigation using the Node directly, and the navigation methods for the two interfaces are analogous. For instance, here is a function that walks over a tree of nodes in document order, taking separate actions when first entering a node and after processing any children:

		processMe(Node n) {
			nodeStartActions(n);
			for (Node child=n.firstChild(); child != null; child=child.nextSibling())
				processMe(child);
			}
			nodeEndActions(n);
		}

Doing the same thing using a TreeWalker is quite similar. There is one difference: since navigation on the TreeWalker changes the current position, the position at the end of the function has changed. A read/write attribute named currentNode allows the current node for a TreeWalker to be set. We will use this to ensure that the position of the TreeWalker is restored when this function is completed:

		processMe(TreeWalker tw) {
			Node n = tw.getCurrentNode();
			nodeStartActions(tw);
			for (Node child=tw.firstChild(); child!=null; child=tw.nextSibling()) {
 				processMe(tw);
			}

			tw.setCurrentNode(n);
			nodeEndActions(tw);
		}

The advantage of using a TreeWalker instead of direct Node navigation is that the TreeWalker allows the user to choose an appropriate view of the tree. Flags may be used to show or hide comments or processing instructions, entities may be expanded or left as entity references. In addition, Filters may be used to present a custom view of the tree. Suppose a program needs a view of a document that shows which tables occur in each chapter, listed by chapter. In this view, only the chapter elements and the tables that they contain are seen. The first step is to write an appropriate filter:

class TablesInChapters implements NodeFilter {

	short acceptNode(Node n) {
		if (n.getNodeType()==Node.ELEMENT_NODE) {
	
			if (n.getNodeName().equals("CHAPTER"))
				return FILTER_ACCEPT;

			if (n.getNodeName().equals("TABLE"))
				return FILTER_ACCEPT;

			if (n.getNodeName().equals("SECT1")
			|| n.getNodeName().equals("SECT2")
			|| n.getNodeName().equals("SECT3")
			|| n.getNodeName().equals("SECT4")
			|| n.getNodeName().equals("SECT5")
			|| n.getNodeName().equals("SECT6")
			|| n.getNodeName().equals("SECT7"))
				return FILTER_SKIP;

		}

		return FILTER_REJECT;
	}
}

This filter assumes that TABLE elements are contained directly in CHAPTER or SECTn elements. If another kind of element is encountered, it and its children are rejected. If a SECTn element is encountered, it is skipped, but its children are explored to see if they contain any TABLE elements.

Now the program can create an instance of this Filter, create a TreeWalker that uses it, and pass this TreeWalker to our ProcessMe() function:

TablesInChapters tablesInChapters  = new TablesInChapters();
	TreeWalker tw  = ((DocumentTraversal)document).createTreeWalker(root, NodeFilter.SHOW_ELEMENT, tablesInChapters);
	processMe(tw);

(Again, we've chosen to both test the nodeType in the filter's logic and use SHOW_ELEMENT, for the reasons discussed in the earlier NodeIterator example.)

Without making any changes to the above ProcessMe() function, it now processes only the CHAPTER and TABLE elements. The programmer can write other filters or set other flags to choose different sets of nodes; if functions use TreeWalker to navigate, they will support any view of the document defined with a TreeWalker.

Note that the structure of a TreeWalker's filtered view of a document may differ significantly from that of the document itself. For example, a TreeWalker with only SHOW_TEXT specified in its whatToShow parameter would present all the Text Nodes as if they were siblings of each other yet had no parent.

7.1.3.1. Robustness

As with iterators, a TreeWalker may be active while the data structure it navigates is being edited, and must behave gracefully in the face of change. Additions and removals in the underlying data structure do not invalidate a TreeWalker; in fact, a TreeWalker is never invalidated.

But a TreeWalker's response to these changes is quite different from that of a NodeIterator. While NodeIterators respond to editing by maintaining their position within the subtree that they are iterating over, TreeWalkers will instead remain attached to their currentNode. All the TreeWalker's navigation methods operate in terms of the context of the currentNode at the time they are invoked, no matter what has happened to, or around, that node since the last time the TreeWalker was accessed. This remains true even if the currentNode is moved out of its original subtree.

As an example, consider the following document fragment:

	...
	<subtree>
		<twRoot>
			<currentNode/>
			<anotherNode/>
		</twRoot>
	</subtree>
	...

Let's say we have created a TreeWalker whose root node is the <twRoot/> element and whose currentNode is the <currentNode/> element. For this illustration, we will assume that all the nodes shown above are accepted by the TreeWalker's whatToShow and filter settings.

If we use removeChild() to remove the <currentNode/> element from its parent, that element remains the TreeWalker's currentNode, even though it is no longer within the root node's subtree. We can still use the TreeWalker to navigate through any children that the orphaned currentNode may have, but are no longer able to navigate outward from the currentNode since there is no parent available.

If we use insertBefore() or appendChild() to give the <currentNode/> a new parent, then TreeWalker navigation will operate from the currentNode's new location. For example, if we inserted the <currentNode> immediately after the <anotherNode/> element, the TreeWalker's previousSibling() operation would move it back to the <anotherNode/>, and calling parentNode() would move it up to the <twRoot/>.

If we instead insert the currentNode into the <subtree/> element, like so:

	...
	<subtree>
		<currentNode/>
		<twRoot>
			<anotherNode/>
		</twRoot>
	</subtree>
	...

we have moved the currentNode out from under the TreeWalker's root node. This does not invalidate the TreeWalker; it may still be used to navigate relative to the currentNode. Calling its parentNode() operation, for example, would move it to the <subtree/> element, even though that too is outside the original root node. However, if the TreeWalker's navigation should take it back into the original root node's subtree -- for example, if rather than calling parentNode() we called nextNode(), moving the TreeWalker to the <twRoot/> element -- the root node will "recapture" the TreeWalker, and prevent it from traversing back out.

This becomes a bit more complicated when filters are in use. Relocation of the currentNode -- or explicit selection of a new currentNode, or changes in the conditions that the filter is basing its decisions on -- can result in a TreeWalker having a currentNode which would not otherwise be visible in the filtered view of the document. This node can be thought of as a "transient member" of that view. When you ask the TreeWalker to navigate off this node the result will be just as if it had been visible, but you may be unable to navigate back to it unless conditions change to make it visible again.

In particular: If the currentNode becomes part of a subtree that would otherwise have been Rejected by the filter, that entire subtree may be added as transient members of the logical view. You will be able to navigate within that subtree (subject to all the usual filtering) until you move upward past the Rejected ancestor. The behavior is as if the Rejected node had only been Skipped (since we somehow wound up inside its subtree) until we leave it; thereafter, standard filtering applies.

7.2. Formal Interface Definition

Interface NodeIterator (introduced in DOM Level 2)

NodeIterators are used to step through a set of nodes, e.g. the set of nodes in a NodeList, the document subtree governed by a particular node, the results of a query, or any other set of nodes. The set of nodes to be iterated is determined by the implementation of the NodeIterator. DOM Level 2 specifies a single NodeIterator implementation for document-order traversal of a document subtree. Instances of these iterators are created by calling DocumentTraversal.createNodeIterator().

IDL Definition

// Introduced in DOM Level 2:
interface NodeIterator {
  readonly attribute Node             root;
  readonly attribute unsigned long    whatToShow;
  readonly attribute NodeFilter       filter;
  readonly attribute boolean          expandEntityReferences;
  Node               nextNode()
                                        raises(DOMException);
  Node               previousNode()
                                        raises(DOMException);
  void               detach();
};

Attributes

expandEntityReferences of type boolean, readonly: The value of this flag determines whether the children of entity reference nodes are visible to the iterator. If false, they and their descendents will be rejected. Note that this rejection takes precedence over whatToShow and the filter. Also note that this is currently the only situation where Iterators may reject a complete subtree rather than skipping individual nodes.
To produce a view of the document that has entity references expanded and does not expose the entity reference node itself, use the whatToShow flags to hide the entity reference node and set expandEntityReferences to true when creating the iterator. To produce a view of the document that has entity reference nodes but no entity expansion, use the whatToShow flags to show the entity reference node and set expandEntityReferences to false.
filter of type NodeFilter, readonly: The filter used to screen nodes.
root of type Node, readonly: The root node of the Iterator, as specified when it was created.
whatToShow of type unsigned long, readonly: This attribute determines which node types are presented via the iterator. The available set of constants is defined in the NodeFilter interface. Nodes not accepted by whatToShow will be skipped, but their children may still be considered. Note that this skip takes precedence over the filter, if any.

Methods

detach

Detaches the iterator from the set which it iterated over, releasing any computational resources and placing the iterator in the INVALID state. After detach has been invoked, calls to nextNode or previousNode will raise the exception INVALID_STATE_ERR.

No Parameters

No Return Value

No Exceptions

nextNode

Returns the next node in the set and advances the position of the iterator in the set. After a NodeIterator is created, the first call to nextNode() returns the first node in the set.

Return Value

The next Node in the set being iterated over, or null if there are no more members in that set.

Exceptions

INVALID_STATE_ERR: Raised if this method is called after the detach method was invoked.

No Parameters

previousNode

Returns the previous node in the set and moves the position of the iterator backwards in the set.

Return Value

The previous Node in the set being iterated over, or null if there are no more members in that set.

Exceptions

INVALID_STATE_ERR: Raised if this method is called after the detach method was invoked.

No Parameters

Interface NodeFilter (introduced in DOM Level 2)

Filters are objects that know how to "filter out" nodes. If a NodeIterator or TreeWalker is given a filter, it applies the filter before it returns the next node. If the filter says to accept the node, the iterator returns it; otherwise, the iterator looks for the next node and pretends that the node that was rejected was not there.

The DOM does not provide any filters. Filter is just an interface that users can implement to provide their own filters.

Filters do not need to know how to iterate, nor do they need to know anything about the data structure that is being iterated. This makes it very easy to write filters, since the only thing they have to know how to do is evaluate a single node. One filter may be used with a number of different kinds of iterators, encouraging code reuse.

Note: This is an ECMAScript function reference. This method returns a short. The parameter is of type Node.

IDL Definition

// Introduced in DOM Level 2:
interface NodeFilter {
  // Constants returned by acceptNode
  const short               FILTER_ACCEPT                  = 1;
  const short               FILTER_REJECT                  = 2;
  const short               FILTER_SKIP                    = 3;

  // Constants for whatToShow
  const unsigned long       SHOW_ALL                       = 0xFFFFFFFF;
  const unsigned long       SHOW_ELEMENT                   = 0x00000001;
  const unsigned long       SHOW_ATTRIBUTE                 = 0x00000002;
  const unsigned long       SHOW_TEXT                      = 0x00000004;
  const unsigned long       SHOW_CDATA_SECTION             = 0x00000008;
  const unsigned long       SHOW_ENTITY_REFERENCE          = 0x00000010;
  const unsigned long       SHOW_ENTITY                    = 0x00000020;
  const unsigned long       SHOW_PROCESSING_INSTRUCTION    = 0x00000040;
  const unsigned long       SHOW_COMMENT                   = 0x00000080;
  const unsigned long       SHOW_DOCUMENT                  = 0x00000100;
  const unsigned long       SHOW_DOCUMENT_TYPE             = 0x00000200;
  const unsigned long       SHOW_DOCUMENT_FRAGMENT         = 0x00000400;
  const unsigned long       SHOW_NOTATION                  = 0x00000800;

  short              acceptNode(in Node n);
};

Definition group Constants returned by acceptNode

The following constants are returned by the acceptNode() method:

Defined Constants

FILTER_ACCEPT	Accept the node. Navigation methods defined for `NodeIterator` or `TreeWalker` will return this node.
FILTER_REJECT	Reject the node. Navigation methods defined for `NodeIterator` or `TreeWalker` will not return this node. For `TreeWalker`, the children of this node will also be rejected. Iterators treat this as a synonym for FILTER_SKIP.
FILTER_SKIP	Skip this single node. Navigation methods defined for `NodeIterator` or `TreeWalker` will not return this node. For both NodeIterator and Treewalker, the children of this node will still be considered.

Definition group Constants for whatToShow

These are the available values for the whatToShow parameter used in TreeWalkers and Iterators. They are the same as the set of possible types for Node, and their values are derived by using a bit position corresponding to the value of Node.nodeType for the equivalent node type. If a bit in whatToShow is set false, that will be taken as a request to skip over this type of node; the behavior in that case is similar to that of FILTER_SKIP.

Note that if node types greater than 32 are ever introduced, they may not be individually testable via whatToShow. If that need should arise, it can be handled by selecting SHOW_ALL together with an appropriate NodeFilter.

Defined Constants

SHOW_ALL	Show all nodes.
SHOW_ATTRIBUTE	Show attribute nodes. This is meaningful only when creating an iterator or tree-walker with an attribute node as its root; in this case, it means that the attribute node will appear in the first position of the iteration or traversal. Since attributes are not part of the document tree, they do not appear when traversing over the document tree.
SHOW_CDATA_SECTION	Show CDATASection nodes.
SHOW_COMMENT	Show Comment nodes.
SHOW_DOCUMENT	Show Document nodes.
SHOW_DOCUMENT_FRAGMENT	Show DocumentFragment nodes.
SHOW_DOCUMENT_TYPE	Show DocumentType nodes.
SHOW_ELEMENT	Show element nodes.
SHOW_ENTITY	Show Entity nodes. This is meaningful only when creating an iterator or tree-walker with an Entity node as its root; in this case, it means that the Entity node will appear in the first position of the traversal. Since entities are not part of the document tree, they do not appear when traversing over the document tree.
SHOW_ENTITY_REFERENCE	Show Entity Reference nodes.
SHOW_NOTATION	Show Notation nodes. This is meaningful only when creating an iterator or tree-walker with a Notation node as its root; in this case, it means that the Notation node will appear in the first position of the traversal. Since notations are not part of the document tree, they do not appear when traversing over the document tree.
SHOW_PROCESSING_INSTRUCTION	Show ProcessingInstruction nodes.
SHOW_TEXT	Show text nodes.

Methods

acceptNode

Test whether a specified node is visible in the logical view of a TreeWalker or NodeIterator. This function will be called by the implementation of TreeWalker and NodeIterator; it is not intended to be called directly from user code.

Parameters

n

The node to check to see if it passes the filter or not.

Return Value

short

a constant to determine whether the node is accepted, rejected, or skipped, as defined above.

No Exceptions

Interface TreeWalker (introduced in DOM Level 2)

TreeWalker objects are used to navigate a document tree or subtree using the view of the document defined by its whatToShow flags and any filters that are defined for the TreeWalker. Any function which performs navigation using a TreeWalker will automatically support any view defined by a TreeWalker.

Omitting nodes from the logical view of a subtree can result in a structure that is substantially different from the same subtree in the complete, unfiltered document. Nodes that are siblings in the TreeWalker view may be children of different, widely separated nodes in the original view. For instance, consider a Filter that skips all nodes except for Text nodes and the root node of a document. In the logical view that results, all text nodes will be siblings and appear as direct children of the root node, no matter how deeply nested the structure of the original document.

IDL Definition

// Introduced in DOM Level 2:
interface TreeWalker {
  readonly attribute Node             root;
  readonly attribute unsigned long    whatToShow;
  readonly attribute NodeFilter       filter;
  readonly attribute boolean          expandEntityReferences;
           attribute Node             currentNode;
                                        // raises(DOMException) on setting

  Node               parentNode();
  Node               firstChild();
  Node               lastChild();
  Node               previousSibling();
  Node               nextSibling();
  Node               previousNode();
  Node               nextNode();
};

Attributes

currentNode of type Node

The node at which the TreeWalker is currently positioned.
The value must not be null. Alterations to the DOM tree may cause the current node to no longer be accepted by the TreeWalker's associated filter. currentNode may also be explicitly set to any node, whether or not it is within the subtree specified by the root node or would be accepted by the filter and whatToShow flags. Further traversal occurs relative to currentNode even if it is not part of the current view by applying the filters in the requested direction (not changing currentNode where no traversal is possible).

Exceptions on setting

NOT_SUPPORTED_ERR: Raised if the specified currentNode is null.

expandEntityReferences of type boolean, readonly

The value of this flag determines whether the children of entity reference nodes are visible to the TreeWalker. If false, they and their descendents will be rejected. Note that this rejection takes precedence over whatToShow and the filter, if any.
To produce a view of the document that has entity references expanded and does not expose the entity reference node itself, use the whatToShow flags to hide the entity reference node and set expandEntityReferences to true when creating the TreeWalker. To produce a view of the document that has entity reference nodes but no entity expansion, use the whatToShow flags to show the entity reference node and set expandEntityReferences to false.

filter of type NodeFilter, readonly

The filter used to screen nodes.

root of type Node, readonly

The root node of the TreeWalker, as specified when it was created.

whatToShow of type unsigned long, readonly

This attribute determines which node types are presented via the TreeWalker. The available set of constants is defined in the NodeFilter interface. Nodes not accepted by whatToShow will be skipped, but their children may still be considered. Note that this skip takes precedence over the filter, if any.

Methods

firstChild

Moves the TreeWalker to the first visible child of the current node, and returns the new node. If the current node has no visible children, returns null, and retains the current node.

Return Value

The new node, or null if the current node has no visible children in the TreeWalker's logical view.

No Parameters

No Exceptions

lastChild

Moves the TreeWalker to the last visible child of the current node, and returns the new node. If the current node has no visible children, returns null, and retains the current node.

Return Value

The new node, or null if the current node has no children in the TreeWalker's logical view.

No Parameters

No Exceptions

nextNode

Moves the TreeWalker to the next visible node in document order relative to the current node, and returns the new node. If the current node has no next node, or if the search for nextNode attempts to step upward from the TreeWalker's root node, returns null, and retains the current node.

Return Value

The new node, or null if the current node has no next node in the TreeWalker's logical view.

No Parameters

No Exceptions

nextSibling

Moves the TreeWalker to the next sibling of the current node, and returns the new node. If the current node has no visible next sibling, returns null, and retains the current node.

Return Value

The new node, or null if the current node has no next sibling in the TreeWalker's logical view.

No Parameters

No Exceptions

parentNode

Moves to and returns the closest visible ancestor node of the current node. If the search for parentNode attempts to step upward from the TreeWalker's root node, or if it fails to find a visible ancestor node, this method retains the current position and returns null.

Return Value

The new parent node, or null if the current node has no parent in the TreeWalker's logical view.

No Parameters

No Exceptions

previousNode

Moves the TreeWalker to the previous visible node in document order relative to the current node, and returns the new node. If the current node has no previous node, or if the search for previousNode attempts to step upward from the TreeWalker's root node, returns null, and retains the current node.

Return Value

The new node, or null if the current node has no previous node in the TreeWalker's logical view.

No Parameters

No Exceptions

previousSibling

Moves the TreeWalker to the previous sibling of the current node, and returns the new node. If the current node has no visible previous sibling, returns null, and retains the current node.

Return Value

The new node, or null if the current node has no previous sibling in the TreeWalker's logical view.

No Parameters

No Exceptions

Interface DocumentTraversal (introduced in DOM Level 2)

DocumentTraversal contains methods that create iterators and tree-walkers to traverse a node and its children in document order (depth first, pre-order traversal, which is equivalent to the order in which the start tags occur in the text representation of the document). In DOMs which support the Traversal feature, DocumentTraversal will be implemented by the same objects that implement the Document interface.

IDL Definition

// Introduced in DOM Level 2:
interface DocumentTraversal {
  NodeIterator       createNodeIterator(in Node root, 
                                        in unsigned long whatToShow, 
                                        in NodeFilter filter, 
                                        in boolean entityReferenceExpansion);
  TreeWalker         createTreeWalker(in Node root, 
                                      in unsigned long whatToShow, 
                                      in NodeFilter filter, 
                                      in boolean entityReferenceExpansion)
                                        raises(DOMException);
};

Methods

createNodeIterator

Create a new NodeIterator over the subtree rooted at the specified node.

Parameters

`Node`	`root`	The node which will be iterated together with its children. The iterator is initially positioned just before this node. The whatToShow flags and the filter, if any, are not considered when setting this position.
`unsigned long`	`whatToShow`	This flag specifies which node types may appear in the logical view of the tree presented by the iterator. See the description of iterator for the set of possible values. These flags can be combined using `OR`.
`NodeFilter`	`filter`	The Filter to be used with this TreeWalker, or null to indicate no filter.
`boolean`	`entityReferenceExpansion`	The value of this flag determines whether entity reference nodes are expanded.

Return Value

NodeIterator

The newly created NodeIterator.

No Exceptions

createTreeWalker

Create a new TreeWalker over the subtree rooted at the specified node.

Parameters

`Node`	`root`	The node which will serve as the root for the `TreeWalker`. The whatToShow flags and the NodeFilter are not considered when setting this value; any node type will be accepted as the root. The currentNode of the TreeWalker is initialized to this node, whether or not it is visible. The root functions as a stopping point for traversal methods that look upward in the document structure, such as parentNode and nextNode. The root must not be null.
`unsigned long`	`whatToShow`	This flag specifies which node types may appear in the logical view of the tree presented by the iterator. See the description of TreeWalker for the set of possible values. These flags can be combined using `OR`.
`NodeFilter`	`filter`	The Filter to be used with this TreeWalker, or null to indicate no filter.
`boolean`	`entityReferenceExpansion`	The value of this flag determines whether entity reference nodes are expanded.

Return Value

TreeWalker

The newly created TreeWalker.

Exceptions

Raises the exception NOT_SUPPORTED_ERR if the specified root node is null.

8. Document Object Model Range

Editors: Vidur Apparao, Netscape Communications; Peter Sharpe, SoftQuad Software Inc.

8.1. Introduction

A Range identifies a range of content in a Document, DocumentFragment or Attr. It is contiguous in the sense that it can be characterized as selecting all of the content between a pair of boundary-points.

Note: In a text editor or a word processor, a user can make a selection by pressing down the mouse at one point in a document, moving the mouse to another point, and releasing the mouse. The resulting selection is contiguous and consists of the content between the two points.

The term 'selecting' does not mean that every Range corresponds to a selection made by a GUI user; however, such a selection can be returned to a DOM user as a Range.

Note: In bidirectional writing (Arabic, Hebrew), a range may correspond to a logical selection that is not necessarily contiguous when displayed. A visually contiguous selection, also used in some cases, may not correspond to a single logical selection, and may therefore have to be represented by more than one range.

The Range interface provides methods for accessing and manipulating the document tree at a higher level than similar methods in the Node interface. The expectation is that each of the methods provided by the Range interface for the insertion, deletion and copying of content can be directly mapped to a series of Node editing operations enabled by DOM Core. In this sense, the Range operations can be viewed as convenience methods that also enable the implementation to optimize common editing patterns.

This chapter describes the Range interface, including methods for creating and moving a Range and methods for manipulating content with Ranges. The feature string for the interfaces listed in this section is "Range".

8.2. Definitions and Notation

8.2.1. Position

This chapter refers to two different representations of a document: the text or source form that includes the document markup and the tree representation similar to the one described in the What is the Document Object Model? section.

A Range consists of two boundary-points corresponding to the start and the end of the Range. A boundary-point's position in a document or document fragment tree can be characterized by a node and an offset. The node is called the container of the boundary-point and of its position. The container and its ancestors are the ancestor containers of the boundary-point and of its position. The offset within the node is called the offset of the boundary-point and its position. If the container is an Attr, Document, Document Fragment, Element or EntityReference node, the offset is between its child nodes. If the container is a CharacterData, Comment or ProcessingInstruction node, the offset is between the 16-bit units of the UTF-16 encoded string contained by it.

The boundary-points of a Range must have a common ancestor container which is either a Document, DocumentFragment or Attr node. That is, the content of a Range must be entirely within the subtree rooted by a single Document, DocumentFragment or Attr Node. This common ancestor container is known as the root container of the Range. The tree rooted by the root container is known as the Range's context tree.

The container of an boundary-point of a Range must be an Element, Comment, ProcessingInstruction, EntityReference, CDATASection, Document, DocumentFragment, Attr, or Text node. None of the ancestor containers of the boundary-point of a Range can be a DocumentType, Entity or Notation node.

In terms of the text representation of a document, the boundary-points of a Range can only be on token boundaries. That is, the boundary-point of the text range cannot be in the middle of a start- or end-tag of an element or within the name of an entity or character reference. A Range locates a contiguous portion of the content of the structure model.

The relationship between locations in a text representation of the document and in the Node tree interface of the DOM is illustrated in the following diagram:

Range Example

In this diagram, four different Ranges are illustrated. The boundary-points of each range are labelled with s# (the start of the range) and e# (the end of the range), where # is the number of the Range. For Range 2, the start is in the BODY element and is immediately after the H1 element and immediately before the P element, so its position is between the H1 and P children of BODY. The offset of a boundary-point whose container is not a CharacterData node is 0 if it is before the first child, 1 if between the first and second child, and so on. So, for the start of the Range 2, the container is BODY and the offset is 1. The offset of a boundary-point whose container is a CharacterData node is obtained similarly but using 16-bit unit positions instead. For example, the boundary-point labelled s1 of the Range 1 has a Text node (the one containing "Title") as its container and an offset of 2 since it is between the second and third 16-bit unit.

Notice that the boundary-points of Ranges 3 and 4 correspond to the same location in the text representation. An important feature of the Range is that a boundary-point of a Range can unambiguously represent every position within the document tree.

The containers and offsets of the boundary-points can be obtained through the following read-only Range attributes:

  readonly attribute Node startContainer; 
  readonly attribute long startOffset;
  readonly attribute Node endContainer; 
  readonly attribute long endOffset;

If the boundary-points of a Range have the same containers and offsets, the Range is said to be a collapsed Range. (This is often referred to as an insertion point in a user agent.)

8.2.2. Selection and Partial Selection

A node or 16-bit unit is said to be selected by a Range if it is between the two boundary-points of the Range, that is, if the position immediately before the node or 16-bit unit is before the end of the Range and the position immediately after the node or 16-bit unit is after the start of the range. For example, in terms of a text representation of the document, an element would be selected by a Range if its corresponding start-tag was located after the start of the Range and its end-tag was located before the end of the Range. In the examples in the above diagram, the Range 2 selects the P node and the Range 3 selects the text node containing the text "Blah xyz."

A node is said to be partially selected by a Range if it is an ancestor container of exactly one boundary-point of the Range. For example, consider Range 1 in the above diagram. The element H1 is partially selected by that Range since the start of the Range is within one of its children.

8.2.3. Notation

Many of the examples in this chapter are illustrated using a text representation of a document. The boundary-points of a range are indicated by displaying the characters (be they markup or data characters) between the two boundary-points in bold, as in

    <FOO>ABC<BAR>DEF</BAR></FOO>

When both boundary-points are at the same position, they are indicated with a bold caret ('^'), as in

    <FOO>A^BC<BAR>DEF</BAR></FOO>

And when referring to a single boundary-point, it will be shown as a bold asterisk ('*') as in

    <FOO>A*BC<BAR>DEF</BAR></FOO>

8.3. Creating a Range

A range is created by calling the createRange() method on the DocumentRange interface. This interface can be obtained from the object implementing the Document interface using binding-specific casting methods.

  interface DocumentRange {
    Range createRange();
  }

The initial state of the range returned from this method is such that both of its boundary-points are positioned at the beginning of the corresponding Document, before any content. In other words, the container of each boundary-point is the Document node and the offset within that node is 0.

Like some objects created using methods in the Document interface (such as Nodes and DocumentFragments), Ranges created via a particular document instance can select only content associated with that Document, or with DocumentFragments and Attrs for which that Document is the ownerDocument. Such Ranges, then, can not be used with other Document instances.

8.4. Changing a Range's Position

A Range's position can be specified by setting the container and offset of each boundary-point with the setStart and setEnd methods.

  void setStart(in Node parent, in long offset)
                        raises(RangeException);
  void setEnd(in Node parent, in long offset)
                raises(RangeException);

If one boundary-point of a Range is set to have a root container other than the current one for the range, the range is collapsed to the new position. This enforces the restriction that both boundary-points of a Range must have the same root container.

The start position of a Range is guaranteed to never be after the end position. To enforce this restriction, if the start is set to be at a position after the end, the range is collapsed to that position. Similarly, if the end is set to be at a position before the start, the range is collapsed to that position.

It is also possible to set a Range's position relative to nodes in the tree:

  void setStartBefore(in Node node);
                              raises(RangeException);
  void setStartAfter(in Node node);
                       raises(RangeException);
  void setEndBefore(in Node node);
                      raises(RangeException);
  void setEndAfter(in Node node);
                     raises(RangeException);

The parent of the node becomes the container of the boundary-point and the Range is subject to the same restrictions as given above in the description of setStart() and setEnd().

A Range can be collapsed to either boundary-point:

  void collapse(in boolean toStart);

Passing TRUE as the parameter toStart will collapse the Range to its start , FALSE to its end.

Testing whether a Range is collapsed can be done by examining the collapsed attribute:

  readonly attribute boolean collapsed;

The following methods can be used to make a range select the contents of a node or the node itself.

  void selectNode(in Node n);
  void selectNodeContents(in Node n);

The following examples demonstrate the operation of the methods selectNode and selectNodeContents:

Before:
  ^<BAR><FOO>A<MOO>B</MOO>C</FOO></BAR>
After range.selectNodeContents(FOO):
  <BAR><FOO>A<MOO>B</MOO>C</FOO></BAR>
(In this case, FOO is the parent of both boundary-points)
After range.selectNode(FOO):

<BAR><FOO>A<MOO>B</MOO>C</FOO></BAR>

8.5. Comparing Range Boundary-Points

It is possible to compare two Ranges by comparing their boundary-points:

  int compareBoundaryPoints(in CompareHow how, in Range sourceRange) raises(RangeException);

where CompareHow is one of four values: START_TO_START, START_TO_END, END_TO_END and END_TO_START. The return value is -1, 0 or 1 depending on whether the corresponding boundary-point of the Range is before, equal to, or after the corresponding boundary-point of sourceRange. An exception is thrown if the two Ranges have different root containers.

The result of comparing two boundary-points (or positions) is specified below. An informal but not always correct specification is that an boundary-point is before, equal to, or after another if it corresponds to a location in a text representation before, equal to, or after the other's corresponding location.

Let A and B be two boundary-points or positions. Then one of the following holds: A is before B, A is equal to B, or A is after B. Which one holds is specified in the following by examining four cases:

In the first case the boundary-points have the same container. A is before B if its offset is less than the offset of B, A is equal to B if its offset is equal to the offset of B, and A if after B if its offset is greater than the offset of B.

In the second case a child C of the container of A is an ancestor container of B. In this case, A is before B if the offset of A is less than or equal to the index of the child C and A is after B otherwise.

In the third case a child C of the container of B is an ancestor container of A. In this case, A is before B if the index of the child C is less than the offset of B and A is after B otherwise.

In the fourth case, none of three other cases hold: the containers of A and B are siblings or descendants of sibling nodes. In this case, A is before B if the container of A is before the container of B in a pre-order traversal of the Ranges' context tree and A is after B otherwise.

Note that because the same location in a text representation of the document can correspond to two different positions in the DOM tree, it is possible for two boundary-points to not compare equal even though they would be equal in the text representation. For this reason, the informal definition above can sometimes be incorrect.

8.6. Deleting Content with a Range

One can delete the contents selected by a Range with:

  void deleteContents();

deleteContents() deletes all nodes and characters selected by the Range. All other nodes and characters remain in the context tree of the Range. Some examples of this deletion operation are:

(1) <FOO>AB<MOO>CD</MOO>CD</FOO>  -->
<FOO>A^CD</FOO>

(2) <FOO>A<MOO>BC</MOO>DE</FOO>  -->
<FOO>A<MOO>B</MOO>^E</FOO>

(3) <FOO>XY<BAR>ZW</BAR>Q</FOO>  -->
<FOO>X^<BAR>W</BAR>Q</FOO>

(4)
<FOO><BAR1>AB</BAR1><BAR2/><BAR3>CD</BAR3></FOO>
-->  <FOO><BAR1>A</BAR1>^<BAR3>D</BAR3>

After deleteContents() is invoked on a Range, the Range is collapsed. If no node was partially selected by the Range, then it is collapsed to its original start point, as in example (1). If a node was partially selected by the Range and was an ancestor container of the start of the Range and no ancestor of the node satisfies these two conditions, then the Range is collapsed to the position immediately after the node, as in examples (2) and (4). If a node waspartially selected by the Range and was an ancestor container of the end of the Range and no ancestor of the node satisfies these two conditions, then the Range is collapsed to the position immediately before the node, as in examples (3) and (4).

8.7. Extracting Content

If the contents of a range need to be extracted rather than deleted, the following method may be used:

  DocumentFragment extractContents();

The extractContents() method removes nodes from the Range's context tree similarly to the deleteContents() method. In addition, it places the deleted contents in a new DocumentFragment. The following examples illustrate the contents of the returned document fragment:

(1) <FOO>AB<MOO>CD</MOO>CD</FOO>  -->
B<MOO>CD</MOO>

(2) <FOO>A<MOO>BC</MOO>DE</FOO>  -->
<MOO>C<MOO>D

(3) <FOO>XY<BAR>ZW</BAR>Q</FOO>  -->
Y<BAR>Z</BAR>

(4)
<FOO><BAR1>AB</BAR1><BAR2/><BAR3>CD</BAR3></FOO>
-->  <BAR1>B</BAR1><BAR2/><BAR3>C</BAR3>

It is important to note that nodes that are partially selected by the range are cloned. Since part of such a node's contents must remain in the Range's context tree and part of the contents must be moved to the new fragment, a clone of the partially selected node is included in the new fragment. Note that cloning does not take place for selected elements; these nodes are moved to the new fragment.

8.8. Cloning Content

The contents of a range may be duplicated using the following method:

  DocumentFragment cloneContents();

This method returns a DocumentFragment that is similar to the one returned by the method extractContents(). However, in this case, the original nodes and character data in the Range are not removed from the Range's context tree. Instead, all of the nodes and text content within the returned DocumentFragment are cloned.

8.9. Inserting Content

A node may be inserted into a range using the following method:

  void insertNode(in Node n) raises(RangeException);

The insertNode() method inserts the specified node into the Range's context tree. For this method, the end of the range is ignored and the node is inserted at the start of the range.

The Node passed into this method can be a DocumentFragment. In that case, the contents of the fragment are inserted at the start position of the range, but the fragment itself is not. Note that if the Node represents the root of a sub-tree, the entire sub-tree is inserted.

The same rules that apply to the insertBefore() method on the Node interface apply here. Specifically, the Node passed in, if it already has a parent, will be removed from its existing position.

8.10. Surrounding Content

The insertion of a single node to subsume the content selected by a Range can be performed with:

  void surroundContents(in Node n);

The surroundContents() method causes all of the content selected by the range to be rooted by the specified node. Calling surroundContents() with the node FOO in the following examples yields:

     Before:
       <BAR>AB<MOO>C</MOO>DE</BAR>
     After surroundContents(FOO):

<BAR>A<FOO>B<MOO>C</MOO>D</FOO>E</BAR>

Another way of describing the effect of this method on the Range's context tree is to decompose it in terms of other operations:

Remove the contents selected by the range with a call to extractContents().
Insert node where the range is now collapsed (after the extraction) with insertNode()
Insert the entire contents of the extracted fragment into node. Specifically, invoke the appendChild() on node passing in the DocumentFragment returned as a result of the call to extractContents()
Select node and all of its contents with selectNode().

The surroundContents() method raises an exception if the range partially selects a non-Text node. An example of a range for which surroundContents() raises an exception is:

     <FOO>AB<BAR>CD</BAR>E</FOO>

If node has any children, those children are removed before its insertion. Also, if node already has a parent, it is removed from the original parent's childNodes list.

8.11. Miscellaneous Members

One can clone a Range:

  Range cloneRange();

This creates a new Range which selects exactly the same content as that selected by the Range on which the method cloneRange was invoked. No content is affected by this operation.

Because the boundary-points of a range do not necessarily have the same containers, use:

  readonly attribute Node commonAncestorContainer;

to get the ancestor container of both boundary-points that is furthest down from the Range's root container

One can get a copy of all the character data selected or partially selected by a range with:

  DOMString toString();

This does nothing more than simply concatenate all the character data selected by the range. This includes character data in both Text and CDATASection nodes.

8.12. Range modification under document mutation

As a document is modified, the Ranges within the document need to be updated. For example, if one boundary-point of a Range is within a node and that node is removed from the document, then the Range would be invalid unless it is fixed up in some way. This section describes how Ranges are modified under document mutations so that they remain valid.

There are two general principles which apply to Ranges under document mutation: The first is that all Ranges in a document will remain valid after any mutation operation and the second is that, as much as possible, all Ranges will select the same portion of the document after any mutation operation.

Any mutation of the document tree which affect Ranges can be considered to be a combination of basic delete and insertion operations. In fact, it can be convenient to think of those operations as being accomplished using the deleteContents() and insertNode() Range methods.

8.12.1. Insertions

An insertion occurs at a single point, the insertion point, in the document. For any Range in the document tree, consider each boundary-point. The only case in which the boundary-point will be changed after the insertion is when the boundary-point and the insertion point have the same container and the offset of the insertion point is strictly less than the offset of the Range's boundary-point. In that case the offset of the Range's boundary-point will be increased so that it is between the same nodes or characters as it was before the insertion.

Note that when content is inserted at a boundary-point, it is ambiguous as to where the boundary-point should be repositioned if its relative position is to be maintained. There are two possibilities: at the start or at the end of the newly inserted content. We have chosen that in this case neither the container nor offset of the boundary-point is changed. As a result, it will be positioned at the start of the newly inserted content.

Examples:

Suppose the Range selects the following:

<P>Abcd efgh XY blah ijkl</P>

Consider the insertion of the text "inserted text" at the following positions:

1. Before the 'X':

<P>Abcd efgh inserted textXY blah ijkl</P>

2. After the 'X':

<P>Abcd efgh Xinserted textY blah ijkl</P>

3. After the 'Y':

<P>Abcd efgh XYinserted text blah ijkl</P>

4. After the 'h' in "Y blah":

<P>Abcd efgh XY blahinserted text ijkl</P>

8.12.2. Deletions

Any deletion from the document tree can be considered as a sequence of deleteContents() operations applied to a minimal set of disjoint Ranges. To specify how a Range is modified under deletions we need only to consider what happens to a Range under a single deleteContents() operation of another Range. And, in fact, we need only to consider what happens to a single boundary-point of the Range since both boundary-points are modified using the same algorithm.

If a boundary-point is within the content being deleted, then after the deletion it will be at the same position as the one common to the boundary-points of the Range used to delete the contents.

If a boundary-point is after the content being deleted then it is not affected by the deletion unless its container is also the container of one of the boundary-points of the range being deleted. If there is such a common container, then the index of the boundary-point is modified so that the boundary-point maintains its position relative to the content of the container.

If a boundary-point is before the content being deleted then it is not affected by the deletion at all.

Examples:

In these examples, the Range on which deleteContents() is invoked is indicated by the underline.

Example 1.

Before:

<P>Abcd efgh The Range
ijkl</P>

After:

<P>Abcd Range ijkl</P>

Example 2.

Before:

<p>Abcd efgh The Range ijkl</p>

After:

<p>Abcd ^kl</p>

Example 3.

Before:

<P>ABCD efgh The
<EM>Range</EM> ijkl</P>

After:

<P>ABCD <EM>ange</EM> ijkl</P>

In this example, the container of the start boundary-point after the deletion is the Text node holding the string "ange".

Example 4.

Before:

<P>Abcd efgh The Range ijkl</P>

After:

<P>Abcd he Range ijkl</P>

Example 5.

Before:

<P>Abcd <EM>efgh The Range
ij</EM>kl</P>

After:

<P>Abcd ^kl</P>

8.13. Formal Description of the Range Interface

To summarize, the complete, formal description of the Range interface is given below:

Interface Range (introduced in DOM Level 2)

IDL Definition

// Introduced in DOM Level 2:
interface Range {
  readonly attribute Node             startContainer;
                                        // raises(DOMException) on retrieval

  readonly attribute long             startOffset;
                                        // raises(DOMException) on retrieval

  readonly attribute Node             endContainer;
                                        // raises(DOMException) on retrieval

  readonly attribute long             endOffset;
                                        // raises(DOMException) on retrieval

  readonly attribute boolean          collapsed;
                                        // raises(DOMException) on retrieval

  readonly attribute Node             commonAncestorContainer;
                                        // raises(DOMException) on retrieval

  void               setStart(in Node refNode, 
                              in long offset)
                                        raises(RangeException, 
                                               DOMException);
  void               setEnd(in Node refNode, 
                            in long offset)
                                        raises(RangeException, 
                                               DOMException);
  void               setStartBefore(in Node refNode)
                                        raises(RangeException, 
                                               DOMException);
  void               setStartAfter(in Node refNode)
                                        raises(RangeException, 
                                               DOMException);
  void               setEndBefore(in Node refNode)
                                        raises(RangeException, 
                                               DOMException);
  void               setEndAfter(in Node refNode)
                                        raises(RangeException, 
                                               DOMException);
  void               collapse(in boolean toStart)
                                        raises(DOMException);
  void               selectNode(in Node refNode)
                                        raises(RangeException, 
                                               DOMException);
  void               selectNodeContents(in Node refNode)
                                        raises(RangeException, 
                                               DOMException);
  // CompareHow
  const unsigned short      START_TO_START                 = 0;
  const unsigned short      START_TO_END                   = 1;
  const unsigned short      END_TO_END                     = 2;
  const unsigned short      END_TO_START                   = 3;

  short              compareBoundaryPoints(in unsigned short how, 
                                           in Range sourceRange)
                                        raises(DOMException);
  void               deleteContents()
                                        raises(DOMException);
  DocumentFragment   extractContents()
                                        raises(DOMException);
  DocumentFragment   cloneContents()
                                        raises(DOMException);
  void               insertNode(in Node newNode)
                                        raises(DOMException, 
                                               RangeException);
  void               surroundContents(in Node newParent)
                                        raises(DOMException, 
                                               RangeException);
  Range              cloneRange()
                                        raises(DOMException);
  DOMString          toString()
                                        raises(DOMException);
  void               detach()
                                        raises(DOMException);
};

Definition group CompareHow

Passed as a parameter to the compareBoundaryPoints method.

Defined Constants

END_TO_END	Compare end boundary-point of `sourceRange` to end boundary-point of Range on which `compareBoundaryPoints` is invoked.
END_TO_START	Compare end boundary-point of `sourceRange` to start boundary-point of Range on which `compareBoundaryPoints` is invoked.
START_TO_END	Compare start boundary-point of `sourceRange` to end boundary-point of Range on which `compareBoundaryPoints` is invoked.
START_TO_START	Compare start boundary-point of `sourceRange` to start boundary-point of Range on which `compareBoundaryPoints` is invoked.

Attributes

collapsed of type boolean, readonly

TRUE if the range is collapsed

Exceptions on retrieval

INVALID_STATE_ERR: Raised if detach() has already been invoked on this object.

commonAncestorContainer of type Node, readonly

The deepest common ancestor container of the range's two boundary-points.

Exceptions on retrieval

INVALID_STATE_ERR: Raised if detach() has already been invoked on this object.

endContainer of type Node, readonly

Node within which the range ends

Exceptions on retrieval

INVALID_STATE_ERR: Raised if detach() has already been invoked on this object.

endOffset of type long, readonly

Offset within the ending node of the range.

Exceptions on retrieval

INVALID_STATE_ERR: Raised if detach() has already been invoked on this object.

startContainer of type Node, readonly

Node within which the range begins

Exceptions on retrieval

INVALID_STATE_ERR: Raised if detach() has already been invoked on this object.

startOffset of type long, readonly

Offset within the starting node of the range.

Exceptions on retrieval

INVALID_STATE_ERR: Raised if detach() has already been invoked on this object.

Methods

cloneContents

Duplicates the contents of a range

Return Value

DocumentFragment

A DocumentFragment containing contents equivalent to those of this range.

Exceptions

HIERARCHY_REQUEST_ERR: Raised if a DocumentType node would be extracted into the new DocumentFragment.

INVALID_STATE_ERR: Raised if detach() has already been invoked on this object.

No Parameters

cloneRange

Produces a new range whose boundary-points are equal to the boundary-points of the range.

Return Value

Range

The duplicated range.

Exceptions

INVALID_STATE_ERR: Raised if detach() has already been invoked on this object.

No Parameters

collapse

Collapse a range onto one of its boundary-points

Parameters

boolean

toStart

If TRUE, collapses the Range onto its start; if FALSE, collapses it onto its end.

Exceptions

compareBoundaryPoints

INVALID_STATE_ERR: Raised if detach() has already been invoked on this object.

No Return Value

Compare the boundary-points of two ranges in a document.

Parameters

`unsigned short`		`how`
`Range`		`sourceRange`

Return Value

short

-1, 0 or 1 depending on whether the corresponding boundary-point of the Range is before, equal to, or after the corresponding boundary-point of sourceRange.

Exceptions

WRONG_DOCUMENT_ERR: Raised if the two Ranges are not in the same document or document fragment.

INVALID_STATE_ERR: Raised if detach() has already been invoked on this object.

deleteContents

Removes the contents of a range from the containing document or document fragment without returning a reference to the removed content.

Exceptions

NO_MODIFICATION_ALLOWED_ERR: Raised if any portion of the content of the range is read-only or any of the nodes that contain any of the content of the range are read-only.

INVALID_STATE_ERR: Raised if detach() has already been invoked on this object.

No Parameters

No Return Value

detach

Called to indicate that the range is no longer in use and that the implementation may relinquish any resources associated with this range. Subsequent calls to any methods or attribute getters on this range will result in a DOMException being thrown with an error code of INVALID_STATE_ERR.

Exceptions

INVALID_STATE_ERR: Raised if detach() has already been invoked on this object.

No Parameters

No Return Value

extractContents

Moves the contents of a range from the containing document or document fragment to a new DocumentFragment.

Return Value

DocumentFragment

A DocumentFragment containing the extracted contents.

Exceptions

NO_MODIFICATION_ALLOWED_ERR: Raised if any portion of the content of the range is read-only or any of the nodes which contain any of the content of the range are read-only.

HIERARCHY_REQUEST_ERR: Raised if a DocumentType node would be extracted into the new DocumentFragment.

INVALID_STATE_ERR: Raised if detach() has already been invoked on this object.

No Parameters

insertNode

Inserts a node into the document or document fragment at the start of the range.

Parameters

newNode

The node to insert at the start of the range

Exceptions

NO_MODIFICATION_ALLOWED_ERR: Raised if an ancestor container of the start of the range is read-only.

WRONG_DOCUMENT_ERR: Raised if newNode and the container of the start of the Range were not created from the same document.

HIERARCHY_REQUEST_ERR: Raised if the container of the start of the Range is of a type that does not allow children of the type of newNode or if newNode is an ancestor of the container.

INVALID_STATE_ERR: Raised if detach() has already been invoked on this object.

INVALID_NODE_TYPE_ERR: Raised if node is an Attr, Entity, Notation, DocumentFragment, or Document node.

No Return Value

selectNode

Select a node and its contents

Parameters

refNode

The node to select.

Exceptions

`RangeException`		INVALID_NODE_TYPE_ERR: Raised if an ancestor of `refNode` is an Entity, Notation or DocumentType node or if `refNode` is a Document, DocumentFragment, Attr, Entity, or Notation node.
`DOMException`		INVALID_STATE_ERR: Raised if `detach()` has already been invoked on this object.

No Return Value

selectNodeContents

Select the contents within a node

Parameters

refNode

Node to select from

Exceptions

`RangeException`		INVALID_NODE_TYPE_ERR: Raised if `refNode` or an ancestor of `refNode` is an Entity, Notation or DocumentType node.
`DOMException`		INVALID_STATE_ERR: Raised if `detach()` has already been invoked on this object.

No Return Value

setEnd

Sets the attributes describing the end of a range.

Parameters

`Node`		`refNode`		The `refNode` value. This parameter must be different from `null`.
`long`		`offset`		The `endOffset` value.

Exceptions

INVALID_NODE_TYPE_ERR: Raised if refNode or an ancestor of refNode is an Entity, Notation, or DocumentType node.

INDEX_SIZE_ERR: Raised if offset is negative or greater than the number of child units in refNode. Child units are 16-bit units if refNode is a CharacterData, Comment or ProcessingInstruction node. Child units are Nodes in all other cases.

INVALID_STATE_ERR: Raised if detach() has already been invoked on this object.

No Return Value

setEndAfter

Sets the end of a range to be after a node

Parameters

refNode

Range ends after refNode.

Exceptions

`RangeException`		INVALID_NODE_TYPE_ERR: Raised if the root container of `refNode` is not an Attr, Document or DocumentFragment node or if `refNode` is a Document, DocumentFragment, Attr, Entity, or Notation node.
`DOMException`		INVALID_STATE_ERR: Raised if `detach()` has already been invoked on this object.

No Return Value

setEndBefore

Sets the end position to be before a node.

Parameters

refNode

Range ends before refNode

Exceptions

`RangeException`		INVALID_NODE_TYPE_ERR: Raised if the root container of `refNode` is not an Attr, Document, or DocumentFragment node or if `refNode` is a Document, DocumentFragment, Attr, Entity, or Notation node.
`DOMException`		INVALID_STATE_ERR: Raised if `detach()` has already been invoked on this object.

No Return Value

setStart

Sets the attributes describing the start of the range.

Parameters

`Node`		`refNode`		The `refNode` value. This parameter must be different from `null`.
`long`		`offset`		The `startOffset` value.

Exceptions

INVALID_NODE_TYPE_ERR: Raised if refNode or an ancestor of refNode is an Entity, Notation, or DocumentType node.

INVALID_STATE_ERR: Raised if detach() has already been invoked on this object.

No Return Value

setStartAfter

Sets the start position to be after a node

Parameters

refNode

Range starts after refNode

Exceptions

`RangeException`		INVALID_NODE_TYPE_ERR: Raised if the root container of `refNode` is not an Attr, Document, or DocumentFragment node or if `refNode` is a Document, DocumentFragment, Attr, Entity, or Notation node.
`DOMException`		INVALID_STATE_ERR: Raised if `detach()` has already been invoked on this object.

No Return Value

setStartBefore

Sets the start position to be before a node

Parameters

refNode

Range starts before refNode

Exceptions

`RangeException`		INVALID_NODE_TYPE_ERR: Raised if the root container of `refNode` is not an Attr, Document, or DocumentFragment node or if `refNode` is a Document, DocumentFragment, Attr, Entity, or Notation node.
`DOMException`		INVALID_STATE_ERR: Raised if `detach()` has already been invoked on this object.

No Return Value

surroundContents

Reparents the contents of the range to the given node and inserts the node at the position of the start of the range.

Parameters

newParent

The node to surround the contents with.

Exceptions

NO_MODIFICATION_ALLOWED_ERR: Raised if an ancestor container of either boundary-point of the range is read-only.

WRONG_DOCUMENT_ERR: Raised if newParent and the container of the start of the Range were not created from the same document.

HIERARCHY_REQUEST_ERR: Raised if the container of the start of the Range is of a type that does not allow children of the type of newParent or if newParent is an ancestor of the container or if node would end up with a child node of a type not allowed by the type of node.

INVALID_STATE_ERR: Raised if detach() has already been invoked on this object.

BAD_BOUNDARYPOINTS_ERR: Raised if the range partially selects a non-text node.

INVALID_NODE_TYPE_ERR: Raised if node is an Attr, Entity, DocumentType, Notation, Document, or DocumentFragment node.

No Return Value

toString

Returns the contents of a range as a string.

Return Value

The contents of the range.

Exceptions