cover.html 100664 3122 20 20461 6604667462 11342 0 ustar lehors w3c
This document has been reviewed by W3C Members and other interested parties and has been endorsed by the Director as a W3C Recommendation. It is a stable document and may be used as reference material or cited as a normative reference from another document. W3C's role in making the Recommendation is to draw attention to the specification and to promote its widespread deployment. This enhances the functionality and interoperability of the Web.
The authors of this document are the DOM Working Group members, different chapters may have different editors.
Comments on this document should be sent to the public mailing list www-dom@w3.org.
A list of current W3C Recommendations and other technical documents can be found at http://www.w3.org/TR.
The list of known errors in this document is found at http://www.w3.org/DOM/updates/REC-DOM-Level-1-19981001-errata.html.
The English version of this specification is the only normative version. However, for translations in other languages see http://www.w3.org/DOM/updates/REC-DOM-Level-1-translations.html.
This specification defines the Document Object Model Level 1, a platform- and language-neutral interface that allows programs and scripts to dynamically access and update the content, structure and style of documents. The Document Object Model provides a standard set of objects for representing HTML and XML documents, a standard model of how these objects can be combined, and a standard interface for accessing and manipulating them. Vendors can support the DOM as an interface to their proprietary data structures and APIs, and content authors can write to the standard DOM interfaces rather than product-specific APIs, thus increasing interoperability on the Web.
The goal of the DOM specification is to define a programmatic interface for XML and HTML. The DOM Level 1 specification is separated into two parts: Core and HTML. The Core DOM Level 1 section provides a low-level set of fundamental interfaces that can represent any structured document, as well as defining extended interfaces for representing an XML document. These extended XML interfaces need not be implemented by a DOM implementation that only provides access to HTML documents; all of the fundamental interfaces in the Core section must be implemented. A compliant DOM implementation that implements the extended XML interfaces is required to also implement the fundamental Core interfaces, but not the HTML interfaces. The HTML Level 1 section provides additional, higher-level interfaces that are used with the fundamental interfaces defined in the Core Level 1 section to provide a more convenient view of an HTML document. A compliant implementation of the HTML DOM implements all of the fundamental Core interfaces as well as the HTML interfaces.
Copyright 1998 World Wide Web Consortium , (Massachusetts Institute of Technology , Institut National de Recherche en Informatique et en Automatique , Keio University ). All Rights Reserved.
Documents on the W3C site are provided by the copyright holders under the following license. By obtaining, using and/or copying this document, or the W3C document from which this statement is linked, you agree that you have read, understood, and will comply with the following terms and conditions:
Permission to use, copy, and distribute the contents of this document, or the W3C document from which this statement is linked, in any medium for any purpose and without fee or royalty is hereby granted, provided that you include the following on ALL copies of the document, or portions thereof, that you use:
When space permits, inclusion of the full text of this NOTICE should be provided. In addition, credit shall be attributed to the copyright holders for any software, documents, or other items or products that you create pursuant to the implementation of the contents of this document, or any portion thereof.
No right to create modifications or derivatives is granted pursuant to this license.
THIS DOCUMENT IS PROVIDED "AS IS," AND COPYRIGHT HOLDERS MAKE NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, OR TITLE; THAT THE CONTENTS OF THE DOCUMENT ARE SUITABLE FOR ANY PURPOSE; NOR THAT THE IMPLEMENTATION OF SUCH CONTENTS WILL NOT INFRINGE ANY THIRD PARTY PATENTS, COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS.
COPYRIGHT HOLDERS WILL NOT BE LIABLE FOR ANY DIRECT, INDIRECT, SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF ANY USE OF THE DOCUMENT OR THE PERFORMANCE OR IMPLEMENTATION OF THE CONTENTS THEREOF.
The name and trademarks of copyright holders may NOT be used in advertising or publicity pertaining to this document or its contents without specific, written prior permission. Title to copyright in this document will at all times remain with copyright holders.
introduction.html 100664 3122 20 36131 6604667477 12754 0 ustar lehors w3cThe Document Object Model (DOM) is an application programming interface (API) for HTML and XML documents. It defines the logical structure of documents and the way a document is accessed and manipulated. In the DOM specification, the term "document" is used in the broad sense - increasingly, XML is being used as a way of representing many different kinds of information that may be stored in diverse systems, and much of this would traditionally be seen as data rather than as documents. Nevertheless, XML presents this data as documents, and the DOM may be used to manage this data.
With the Document Object Model, programmers can build documents, navigate their structure, and add, modify, or delete elements and content. Anything found in an HTML or XML document can be accessed, changed, deleted, or added using the Document Object Model, with a few exceptions - in particular, the DOM interfaces for the XML internal and external subsets have not yet been specified.
As a W3C specification, one important objective for the Document
Object Model is to provide a standard programming interface that
can be used in a wide variety of environments and applications.
The DOM is designed to be used with any programming
language. In order to provide a precise, language-independent specification
of the DOM interfaces, we have chosen to define
the specifications in OMG IDL, as defined in the CORBA 2.2
specification.
In addition to the OMG IDL specification,
we provide language bindings for Java and ECMAScript (an
industry-standard scripting language based on JavaScript and
JScript). Note: OMG IDL is used only as a language-independent and
implementation-neutral way to specify interfaces. Various other
IDLs could have been used. In general, IDLs are designed for
specific computing environments. The Document Object Model
can be implemented in any computing environment, and does not
require the object binding runtimes generally associated with
such IDLs.
The DOM is a programming API for documents. It closely resembles the structure of the documents it models. For instance, consider this table, taken from an HTML document:
<TABLE> <TBODY> <TR> <TD>Shady Grove</TD> <TD>Aeolian</TD> </TR> <TR> <TD>Over the River, Charlie</TD> <TD>Dorian</TD> </TR> </TBODY> </TABLE>
The DOM represents this table like this:
In the DOM, documents have a logical structure which is very much like a tree; to be more precise, it is like a "forest" or "grove", which can contain more than one tree. However, the DOM does not specify that documents must be implemented as a tree or a grove, nor does it specify how the relationships among objects be implemented. The DOM is a logical model that may be implemented in any convenient manner. In this specification, we use the term structure model to describe the tree-like representation of a document; we specifically avoid terms like "tree" or "grove" in order to avoid implying a particular implementation. One important property of DOM structure models is structural isomorphism: if any two Document Object Model implementations are used to create a representation of the same document, they will create the same structure model, with precisely the same objects and relationships.
The name "Document Object Model" was chosen because it is an "object model" in the traditional object oriented design sense: documents are modeled using objects, and the model encompasses not only the structure of a document, but also the behavior of a document and the objects of which it is composed. In other words, the nodes in the above diagram do not represent a data structure, they represent objects, which have functions and identity. As an object model, the DOM identifies:
The structure of SGML documents has traditionally been represented by an abstract data model, not by an object model. In an abstract data model, the model is centered around the data. In object oriented programming languages, the data itself is encapsulated in objects that hide the data, protecting it from direct external manipulation. The functions associated with these objects determine how the objects may be manipulated, and they are part of the object model.
The Document Object Model currently consists of two parts,
DOM Core and DOM HTML. The DOM Core represents the
functionality used for XML documents, and also serves as the
basis for DOM HTML.
A compliant implementation of the DOM must implement all of the
fundamental interfaces in the Core chapter with the semantics as
defined. Further, it must implement at least one of the HTML DOM
and the extended (XML) interfaces with the semantics as defined.
This section is designed to give a more precise understanding of the DOM by distinguishing it from other systems that may seem to be like it.
The DOM originated as a specification to
allow JavaScript scripts and Java programs to be portable among
Web browsers. "Dynamic HTML" was the immediate ancestor of the
Document Object Model, and it was originally thought of largely
in terms of browsers. However, when the DOM
Working Group was formed at W3C, it was also joined by vendors in other
domains, including HTML or XML editors and document
repositories. Several of these vendors had worked with SGML
before XML was developed; as a result, the DOM
has been influenced by SGML Groves and the HyTime standard. Some
of these vendors had also developed their own object models for
documents in order to provide an API for SGML/XML
editors or document repositories, and these object models have
also influenced the DOM.
In the fundamental DOM interfaces, there are no objects representing entities. Numeric character references, and references to the pre-defined entities in HTML and XML, are replaced by the single character that makes up the entity's replacement. For example, in:
<p>This is a dog & a cat</p>the "&" will be replaced by the character "&", and the text in the P element will form a single continuous sequence of characters. Since numeric character references and pre-defined entities are not recognized as such in CDATA sections, or the SCRIPT and STYLE elements in HTML, they are not replaced by the single character they appear to refer to. If the example above were enclosed in a CDATA section, the "&" would not be replaced by "&"; neither would the <p> be recognized as a start tag. The representation of general entities, both internal and external, are defined within the extended (XML) interfaces of the Level 1 specification.
Note: When a DOM representation of a document is serialized
as XML or HTML text, applications will need to check each
character in text data to see if it needs to be escaped
using a numeric or pre-defined entity. Failing to do so
could result in invalid HTML or XML. Also, implementations should be
aware of the fact that serialization into a character encoding
("charset") that does not fully cover ISO 10646 may fail if there are
characters in markup or CDATA sections that are not present in the
encoding.
The DOM specifies interfaces which may be used to manage XML or HTML documents. It is important to realize that these interfaces are an abstraction - much like "abstract base classes" in C++, they are a means of specifying a way to access and manipulate an application's internal representation of a document. Interfaces do not imply a particular concrete implementation. Each DOM application is free to maintain documents in any convenient representation, as long as the interfaces shown in this specification are supported. Some DOM implementations will be existing programs that use the DOM interfaces to access software written long before the DOM specification existed. Therefore, the DOM is designed to avoid implementation dependencies; in particular,
The DOM Level 1 specification is intentionally limited to those methods needed to represent and manipulate document structure and content. The plan is for future Levels of the DOM specification to provide:
This section defines a minimal set of objects and
interfaces for accessing and manipulating document objects.
The functionality specified in this section (the
Core functionality) should be sufficient to allow
software developers and web script authors to access and
manipulate parsed HTML and XML content inside conforming
products. The DOM Core API also allows population
of a Document
object using only DOM API calls; creating
the skeleton Document
and saving it persistently is left
to the product that implements the DOM API.
The DOM presents documents as a hierarchy of Node
objects that also implement other, more specialized interfaces. Some
types of nodes may have child nodes of various types, and others are
leaf nodes that cannot have anything below them in the document
structure. The node types, and which node types they may have as
children, are as follows:
Document
-- Element
(maximum of
one), ProcessingInstruction
, Comment
,
DocumentType
DocumentFragment
-- Element
,
ProcessingInstruction
, Comment
,
Text
, CDATASection
,
EntityReference
DocumentType
-- no childrenEntityReference
-- Element
,
ProcessingInstruction
, Comment
,
Text
, CDATASection
,
EntityReference
Element
-- Element
,
Text
, Comment
,
ProcessingInstruction
, CDATASection
,
EntityReference
Attr
-- Text
,
EntityReference
ProcessingInstruction
-- no childrenComment
-- no childrenText
-- no childrenCDATASection
-- no childrenEntity
-- Element
,
ProcessingInstruction
, Comment
,
Text
, CDATASection
,
EntityReference
Notation
-- no childrenThe DOM also specifies a NodeList
interface to handle
ordered lists of Node
s, such as the children of a
Node
, or the elements returned by the
Element.getElementsByTagName
method, and also a
NamedNodeMap
interface to handle unordered sets of nodes
referenced by their name attribute, such as the attributes of an
Element
. NodeList
s and
NamedNodeMap
s in the DOM are "live", that is, changes to
the underlying document structure are reflected in all relevant
NodeList
s and NamedNodeMap
s. For example, if
a DOM user gets a NodeList
object containing the children
of an Element
, then subsequently adds more children to
that element (or removes children, or modifies them), those changes are
automatically reflected in the NodeList
without further
action on the user's part. Likewise changes to a Node
in
the tree are reflected in all references to that Node
in
NodeList
s and NamedNodeMap
s.
Most of the APIs defined by this specification are
interfaces rather than classes. That means that
an actual implementation need only expose methods with
the defined names and specified operation, not actually
implement classes that correspond directly to the interfaces.
This allows the DOM APIs to be implemented as a thin veneer on top
of legacy applications with their own data structures, or
on top of newer applications with different class hierarchies.
This also means that ordinary constructors (in the Java or C++
sense) cannot be used to create DOM objects, since the
underlying objects to be constructed may have little relationship
to the DOM interfaces. The conventional solution to this in
object-oriented design is to define factory methods
that create instances of objects that implement the various
interfaces. In the DOM Level 1, objects implementing some
interface "X" are created by a "createX()" method on the
Document
interface; this is because all DOM objects live
in the context of a specific Document.
The DOM Level 1 API does not define a standard
way to create DOMImplementation
or Document
objects; actual DOM implementations must provide
some proprietary way of bootstrapping these DOM interfaces, and
then all other objects can be built from the Create methods on
Document
(or by various other convenience methods).
The Core DOM APIs are designed to be compatible with a wide
range of languages, including both general-user scripting languages and
the more challenging languages used mostly by professional programmers.
Thus, the DOM
APIs need to operate across a variety of memory management
philosophies, from language platforms that do not expose memory
management to the user at all, through those (notably Java) that
provide explicit constructors but provide an automatic garbage
collection mechanism to automatically reclaim unused memory,
to those (especially C/C++) that generally require the
programmer to explicitly allocate object memory, track where
it is used, and explicitly free it for re-use. To ensure a
consistent API across these platforms, the DOM does not
address memory management issues at all,
but instead leaves these for the
implementation. Neither of the explicit language bindings
devised by the DOM Working Group (for ECMAScript and Java)
require any memory management methods, but DOM bindings for
other languages (especially C or C++) probably will require
such support. These extensions will be the responsibility of
those adapting the DOM API to a specific language, not the DOM
WG.
While it would
be nice to have attribute and method names that are short,
informative, internally consistent, and familiar to users of
similar APIs, the names also should not clash with the names
in legacy APIs supported by DOM implementations.
Furthermore, both OMG IDL and ECMAScript
have
significant limitations in their ability to disambiguate names
from different namespaces that makes it difficult to avoid naming
conflicts with short, familiar names. So, DOM names tend to be
long and quite descriptive in order to be unique across all
environments.
The Working Group has also attempted to be internally
consistent in its use of various terms, even though these may
not be common distinctions in other APIs. For example, we use
the method name "remove" when the method changes the
structural model, and the method name "delete" when the method
gets rid of something inside the structure model. The thing
that is deleted is not returned. The thing that is removed may
be returned, when it makes sense to return it.
The DOM Core APIs present two somewhat different sets of
interfaces to an XML/HTML document; one presenting an "object
oriented" approach with a hierarchy of inheritance, and a
"simplified" view that allows all manipulation to be done via
the Node
interface without requiring casts (in
Java and other C-like languages) or query interface calls in
COM environments. These operations are fairly expensive in Java and
COM, and the DOM may be used in performance-critical
environments, so we allow significant functionality using just the
Node
interface. Because many other users will find the
inheritance hierarchy easier to understand than the
"everything is a Node
" approach to the DOM, we also
support the full higher-level interfaces for those who prefer a more
object-oriented API.
In practice, this means that there is a certain amount of
redundancy in the API. The Working Group considers the
"inheritance" approach the primary view of the API, and the
full set of functionality on Node
to be "extra"
functionality that users may employ, but that does not eliminate
the need for methods on other interfaces that an
object-oriented analysis would dictate. (Of course, when the
O-O analysis yields an attribute or method that is
identical to one on the Node
interface, we don't
specify a completely redundant one). Thus, even though there
is a generic nodeName
attribute on the Node
interface, there is still a tagName
attribute on the
Element
interface; these two attributes must
contain the same value, but the Working Group considers it
worthwhile to support both, given the different constituencies
the DOM API must satisfy.
DOMString
typeTo ensure interoperability, the DOM specifies the
DOMString
type as follows:
DOMString
is a sequence of 16-bit
quantities. This may be expressed in IDL terms as:typedef sequence<unsigned short> DOMString;
DOMString
using UTF-16
(defined in Appendix C.3 of [UNICODE] and Amendment 1 of
[ISO-10646]).The UTF-16 encoding was chosen because of its widespread
industry practice. Please note that for both HTML and XML, the document
character set (and therefore the notation of numeric character
references) is based on UCS-4. A single numeric character reference in
a source document may therefore in some cases correspond to two array
positions in a DOMString
(a high surrogate and a low
surrogate). Note: Even though the DOM defines the name of the string type to
be DOMString
, bindings may used different names. For,
example for Java, DOMString
is bound to the
String
type because it also uses UTF-16 as its
encoding.wstring
type. However, that definition did not meet the
interoperability criteria of the DOM API since it relied on encoding
negotiation to decide the width of a character.The DOM has many interfaces that imply string matching.
HTML processors generally assume an uppercase (less often,
lowercase) normalization of names for such things as
elements, while XML is explicitly case sensitive. For the
purposes of the DOM, string matching takes place on a character
code by character code basis, on the 16 bit value of a
DOMString
. As such, the DOM assumes that any
normalizations will take place in the processor,
before the DOM structures are built.
This then raises the issue of exactly what normalizations
occur. The W3C I18N working group is in the process of
defining exactly which normalizations are necessary for applications
implementing the DOM.
The interfaces within this section are considered fundamental, and must be fully implemented by all conforming implementations of the DOM, including all HTML DOM implementations.
DOM operations only raise exceptions in "exceptional"
circumstances, i.e., when an operation is impossible
to perform (either for logical reasons, because data is lost, or
because the implementation has become unstable). In general, DOM methods
return specific error values in ordinary
processing situation, such as out-of-bound errors when using
NodeList
.
Implementations may raise other exceptions under other circumstances.
For example, implementations may raise an implementation-dependent
exception if a null
argument is passed.
Some languages and object systems do not support the concept of exceptions. For such systems, error conditions may be indicated using native error reporting mechanisms. For some bindings, for example, methods may return error codes similar to those listed in the corresponding method descriptions.
exception DOMException { unsigned short code; }; // ExceptionCode const unsigned short INDEX_SIZE_ERR = 1; const unsigned short DOMSTRING_SIZE_ERR = 2; const unsigned short HIERARCHY_REQUEST_ERR = 3; const unsigned short WRONG_DOCUMENT_ERR = 4; const unsigned short INVALID_CHARACTER_ERR = 5; const unsigned short NO_DATA_ALLOWED_ERR = 6; const unsigned short NO_MODIFICATION_ALLOWED_ERR = 7; const unsigned short NOT_FOUND_ERR = 8; const unsigned short NOT_SUPPORTED_ERR = 9; const unsigned short INUSE_ATTRIBUTE_ERR = 10;
An integer indicating the type of error generated.
INDEX_SIZE_ERR |
If index or size is negative, or greater than the allowed value |
DOMSTRING_SIZE_ERR |
If the specified range of text does not fit into a DOMString |
HIERARCHY_REQUEST_ERR |
If any node is inserted somewhere it doesn't belong |
WRONG_DOCUMENT_ERR |
If a node is used in a different document than the one that created it (that doesn't support it) |
INVALID_CHARACTER_ERR |
If an invalid character is specified, such as in a name. |
NO_DATA_ALLOWED_ERR |
If data is specified for a node which does not support data |
NO_MODIFICATION_ALLOWED_ERR |
If an attempt is made to modify an object where modifications are not allowed |
NOT_FOUND_ERR |
If an attempt was made to reference a node in a context where it does not exist |
NOT_SUPPORTED_ERR |
If the implementation does not support the type of object requested |
INUSE_ATTRIBUTE_ERR |
If an attempt is made to add an attribute that is already inuse elsewhere |
The DOMImplementation
interface provides a
number of methods for performing operations that are independent
of any particular instance of the document object model.
The DOM Level 1 does not specify a way of creating a document instance, and hence document creation is an operation specific to an implementation. Future Levels of the DOM specification are expected to provide methods for creating documents directly.
interface DOMImplementation { boolean hasFeature(in DOMString feature, in DOMString version); };
hasFeature
feature |
The package name of the feature to test. In Level 1, the legal values are "HTML" and "XML" (case-insensitive). | |
version |
This is the version number of the package name to
test. In Level 1, this is the string "1.0".
If the version is not specified, supporting any version of the
feature will cause the method to return |
true
if the feature is implemented in the specified
version, false
otherwise.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 fulfil 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()
.
interface DocumentFragment : Node { };
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.
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); };
doctype
DocumentType
)
associated with
this document. For HTML documents as well as XML documents without a
document type declaration this returns null
. The DOM Level
1 does not support editing the Document Type Declaration, therefore
docType
cannot be altered in any way.implementation
DOMImplementation
object that handles this
document. A DOM application may use objects from multiple
implementations.documentElement
createElement
tagName |
The name of the element type to
instantiate. For XML, this is case-sensitive. For HTML, the
|
Element
object.DOMException
INVALID_CHARACTER_ERR: Raised if the specified name contains an invalid character.
createDocumentFragment
DocumentFragment
object.
DocumentFragment
.createTextNode
createComment
createCDATASection
CDATASection
node whose value is
the specified string.
data |
The data for the |
CDATASection
object.DOMException
NOT_SUPPORTED_ERR: Raised if this document is an HTML document.
createProcessingInstruction
ProcessingInstruction
node given
the specified name and data strings.
target |
The target part of the processing instruction. | |
data |
The data for the node. |
ProcessingInstruction
object.DOMException
INVALID_CHARACTER_ERR: Raised if an invalid character is specified.
NOT_SUPPORTED_ERR: Raised if this document is an HTML document.
createAttribute
Attr
of the given name.
Note that the Attr
instance
can then be set on an Element
using the
setAttribute
method.
name |
The name of the attribute. |
Attr
object.DOMException
INVALID_CHARACTER_ERR: Raised if the specified name contains an invalid character.
createEntityReference
name |
The name of the entity to reference. |
EntityReference
object.DOMException
INVALID_CHARACTER_ERR: Raised if the specified name contains an invalid character.
NOT_SUPPORTED_ERR: Raised if this document is an HTML document.
getElementsByTagName
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.
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; 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); };
An integer indicating which type of node this is.
ELEMENT_NODE |
The node is a |
ATTRIBUTE_NODE |
The node is an |
TEXT_NODE |
The node is a |
CDATA_SECTION_NODE |
The node is a |
ENTITY_REFERENCE_NODE |
The node is an |
ENTITY_NODE |
The node is an |
PROCESSING_INSTRUCTION_NODE |
The node is a |
COMMENT_NODE |
The node is a |
DOCUMENT_NODE |
The node is a |
DOCUMENT_TYPE_NODE |
The node is a |
DOCUMENT_FRAGMENT_NODE |
The node is a |
NOTATION_NODE |
The node is a |
The values of nodeName
, nodeValue
,
and attributes
vary according to the node type as follows:
nodeName | nodeValue | attributes | |
Element | tagName | null | NamedNodeMap |
Attr | name of attribute | value of attribute | null |
Text | #text | content of the text node | null |
CDATASection | #cdata-section | content of the CDATA Section | null |
EntityReference | name of entity referenced | null | null |
Entity | entity name | null | null |
ProcessingInstruction | target | entire content excluding the target | null |
Comment | #comment | content of the comment | null |
Document | #document | null | null |
DocumentType | document type name | null | null |
DocumentFragment | #document-fragment | null | null |
Notation | notation name | null | null |
nodeName
nodeValue
DOMException
NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly.
DOMException
DOMSTRING_SIZE_ERR: Raised when it would return more
characters than fit in a DOMString
variable on the
implementation platform.
nodeType
parentNode
Document
, DocumentFragment
, and
Attr
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
.childNodes
NodeList
that contains all
children of this node. If there are no children, this is a
NodeList
containing no nodes. The content of the
returned NodeList
is "live" in the
sense that, for instance, changes to the children of the node object
that it was created from are immediately reflected in the nodes
returned by the NodeList
accessors; it is not a
static snapshot of the content of the node. This is true for every
NodeList
, including the ones returned by the
getElementsByTagName
method.firstChild
null
.lastChild
null
.previousSibling
null
.nextSibling
null
.attributes
NamedNodeMap
containing the
attributes of this node (if it is an Element
) or
null
otherwise. ownerDocument
Document
object associated with this node. This
is also the Document
object used to create new nodes. When
this node is a Document
this is null
.insertBefore
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.
newChild |
The node to insert. | |
refChild |
The reference node, i.e., the node before which the new node must be inserted. |
DOMException
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 is readonly.
NOT_FOUND_ERR: Raised if refChild
is not a child
of this node.
replaceChild
oldChild
with
newChild
in the list of children, and returns the
oldChild
node. If the newChild
is already in
the tree, it is first removed.
newChild |
The new node to put in the child list. | |
oldChild |
The node being replaced in the list. |
DOMException
HIERARCHY_REQUEST_ERR: Raised if this node is of a type
that does not allow children of the type of the newChild
node, or it 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 is readonly.
NOT_FOUND_ERR: Raised if oldChild
is not a
child of this node.
removeChild
oldChild
from
the list of children, and returns it.
oldChild |
The node being removed. |
DOMException
NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
NOT_FOUND_ERR: Raised if oldChild
is not a child
of this node.
appendChild
newChild
to the end of the list of
children of this node. If the newChild
is already in the
tree, it is first removed.
newChild |
The node to add. If it is a
|
DOMException
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 is readonly.
hasChildNodes
true
if the node has any children,
false
if the node has no children.cloneNode
parentNode
returns 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 any other type of
node simply returns a copy of this node.
deep |
If |
The NodeList
interface provides the abstraction of an
ordered collection of nodes, without defining or
constraining how this collection is implemented.
The items in the NodeList
are accessible via an
integral index, starting from 0.
interface NodeList { Node item(in unsigned long index); readonly attribute unsigned long length; };
item
index
th item in the collection.
If index
is greater than or equal to the number
of nodes in the list, this returns null
.
index |
Index into the collection. |
index
th position in the
NodeList
, or null
if that is not a
valid index.length
length-1
inclusive. 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
; NamedNodeMap
s 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.
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; };
getNamedItem
name |
Name of a node to retrieve. |
Node
(of any type) with the specified
name, or null
if the specified name did not
identify any node in the map. setNamedItem
nodeName
attribute.
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.
arg |
A node to store in a named node map. The node will
later be accessible using the value of the
|
Node
replaces an existing node with the
same name the previously existing Node
is returned,
otherwise null
is returned.DOMException
WRONG_DOCUMENT_ERR: Raised if arg
was created from a different
document than the one that created the NamedNodeMap
.
NO_MODIFICATION_ALLOWED_ERR: Raised if this
NamedNodeMap
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.
removeNamedItem
Attr
with a default value it is immediately
replaced.
name |
The name of a node to remove. |
null
if no node with such a name exists.DOMException
NOT_FOUND_ERR: Raised if there is no node named
name
in the map.
item
index
th item in the map.
If index
is greater than or equal to the number
of nodes in the map, this returns null
.
index |
Index into the map. |
index
th position in the
NamedNodeMap
, or null
if that is not a
valid index.length
length-1
inclusive. 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 offset
s in
this interface start from 0.
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); };
data
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.
DOMException
NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly.
DOMException
DOMSTRING_SIZE_ERR: Raised when it would return more
characters than fit in a DOMString
variable on the
implementation platform.
length
data
and the
substringData
method below. This may have the value zero,
i.e., CharacterData
nodes may be empty.substringData
offset |
Start offset of substring to extract. | |
count |
The number of characters to extract. |
offset
and count
exceeds the
length
, then all characters to the end of the data are
returned.DOMException
INDEX_SIZE_ERR: Raised if the specified offset is negative or
greater than the number of characters 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
.
appendData
data
provides access to the concatenation of
data
and the DOMString
specified.
arg |
The |
DOMException
NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
insertData
offset |
The character offset at which to insert. | |
arg |
The |
DOMException
INDEX_SIZE_ERR: Raised if the specified offset is negative or
greater than the number of characters in data
.
NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
deleteData
data
and length
reflect the change.
offset |
The offset from which to remove characters. | |
count |
The number of characters to delete. If the sum of
|
DOMException
INDEX_SIZE_ERR: Raised if the specified offset is negative or
greater than the number of characters in data
, or if the
specified count
is negative.
NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
replaceData
offset |
The offset from which to start replacing. | |
count |
The number of characters to replace. If the sum of
| |
arg |
The |
DOMException
INDEX_SIZE_ERR: Raised if the specified offset is negative or
greater than the number of characters in data
, or if the
specified count
is negative.
NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
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.
interface Attr : Node { readonly attribute DOMString name; readonly attribute boolean specified; attribute DOMString value; };
name
specified
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:
specified
is true
, and the value is the
assigned value.
specified
is false
,
and the value is the default value in the DTD.value
On setting, this creates a Text
node with the unparsed
contents of the string.
By far the vast majority of objects (apart from text)
that authors encounter when traversing a document
are Element
nodes.
Assume the following XML document:
<elementExample id="demo"> <subelement1/> <subelement2><subsubelement/></subelement2> </elementExample>
When represented using DOM, the top node is an Element
node
for "elementExample", which contains two child Element
nodes, one for "subelement1" and one
for "subelement2". "subelement1" contains no
child nodes.
Elements may have attributes associated with them; since the
Element
interface inherits from Node
, the generic
Node
interface method getAttributes
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.
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); void normalize(); };
tagName
<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. getAttribute
name |
The name of the attribute to retrieve. |
Attr
value as a string, or the empty
string if that attribute does not have a specified or default value.setAttribute
Attr
node plus any Text
and
EntityReference
nodes, build the appropriate subtree, and
use setAttributeNode
to assign it as the value of an
attribute.
name |
The name of the attribute to create or alter. | |
value |
Value to set in string form. |
DOMException
INVALID_CHARACTER_ERR: Raised if the specified name contains an invalid character.
NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
removeAttribute
name |
The name of the attribute to remove. |
DOMException
NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
getAttributeNode
setAttributeNode
newAttr |
The |
newAttr
attribute replaces
an existing attribute with the same name, the
previously existing Attr
node is returned, otherwise
null
is returned.DOMException
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.
removeAttributeNode
oldAttr |
The |
Attr
node that was removed.DOMException
NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
NOT_FOUND_ERR: Raised if oldAttr
is not an attribute of
the element.
getElementsByTagName
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.
name |
The name of the tag to match on. The special value "*" matches all tags. |
Element
nodes.normalize
Text
nodes in the full depth of the
sub-tree underneath this Element
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 no adjacent 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.The Text
interface 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
a list of elements 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; this is
recommended before employing operations that depend on a particular
document structure, such as navigation with XPointers.
interface Text : CharacterData { Text splitText(in unsigned long offset) raises(DOMException); };
splitText
Text
node into two Text 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. And
a new Text
node, which is inserted as the next sibling of
this node, contains all the content at and after the
offset
point.
offset |
The offset at which to split, starting from 0. |
Text
node.DOMException
INDEX_SIZE_ERR: Raised if the specified offset is negative or
greater than the number of characters in data
.
NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
This represents the content of a comment, i.e., all the
characters between the starting '<!--
' and
ending '-->
'. 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.
interface Comment : CharacterData { };
The interfaces defined here form part of the DOM Level 1 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.
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 can not be nested. The 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 the
CharacterData
interface through the Text
interface. Adjacent CDATASections
nodes are not merged by
use of the Element.normalize() method.
interface CDATASection : Text { };
Each Document
has a doctype
attribute
whose value is either null
or a DocumentType
object. The DocumentType
interface in the DOM Level 1 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 scheme efforts on DTD
representation are not clearly understood as of this writing.
The DOM Level 1 doesn't support editing DocumentType
nodes.
interface DocumentType : Node { readonly attribute DOMString name; readonly attribute NamedNodeMap entities; readonly attribute NamedNodeMap notations; };
name
DOCTYPE
keyword.entities
NamedNodeMap
containing the general entities, both
external and internal, declared in the DTD. Duplicates are discarded.
For example in:
<!DOCTYPE ex SYSTEM "ex.dtd" [ <!ENTITY foo "foo"> <!ENTITY bar "bar"> <!ENTITY % baz "baz"> ]> <ex/>the interface provides access to
foo
and
bar
but not baz
. Every node in this map
also implements the Entity
interface.
The DOM Level 1 does not support editing entities, therefore
entities
cannot be altered in any way.
notations
NamedNodeMap
containing the
notations declared in the DTD. Duplicates are discarded. Every node in
this map also implements the Notation
interface.
The DOM Level 1 does not support editing notations, therefore
notations
cannot be altered in any way.
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.
interface Notation : Node { readonly attribute DOMString publicId; readonly attribute DOMString systemId; };
publicId
null
.systemId
null
.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 resolution of the children of the Entity
(the
replacement value) may be lazily evaluated; actions by the user (such as
calling the childNodes
method on the
Entity
Node) are assumed to trigger the evaluation.
The DOM Level 1 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.
interface Entity : Node { readonly attribute DOMString publicId; readonly attribute DOMString systemId; readonly attribute DOMString notationName; };
publicId
null
.systemId
null
.notationName
null
.
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;
but if such an Entity
exists, then the child list of the
EntityReference
node is the same as that of the
Entity
node. As with the Entity
node, all
descendants of the EntityReference
are readonly.
The resolution of the children of the EntityReference
(the
replacement value of the referenced Entity
) may be lazily
evaluated; actions by the user (such as calling the
childNodes
method on the EntityReference
node)
are assumed to trigger the evaluation.
interface EntityReference : Node { };
The ProcessingInstruction
interface
represents a "processing instruction", used in XML
as a way to keep processor-specific information in the text of the
document.
interface ProcessingInstruction : Node { readonly attribute DOMString target; attribute DOMString data; // raises(DOMException) on setting };
target
data
?>
.
DOMException
NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly.
This section extends the Level 1 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:
The term "DOM Level 0" refers to a mix (not formally specified) of HTML document functionalities offered by Netscape Navigator version 3.0 and Microsoft Internet Explorer version 3.0. In some cases, attributes or methods have been included for reasons of backward compatibility with "DOM Level 0".
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. For DOM Level 1, 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 these DTDs.
More specifically, this document includes the following specializations for HTML:
The DOM Level 1 does not include mechanisms to access and
modify style specified through CSS 1. Furthermore, it does not
define an event model for HTML documents. This functionality
is planned to be specified in a future Level of this specification.
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. 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. 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.
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.
interface HTMLCollection { readonly attribute unsigned long length; Node item(in unsigned long index); Node namedItem(in DOMString name); };
length
item
index |
The index of the node to be fetched. The index origin is 0. |
Node
at the corresponding position upon
success. A value of null
is returned if the index is
out of range. namedItem
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.
name |
The name of 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
.An HTMLDocument
is the root of the HTML hierarchy and
holds the entire content. Beside 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:
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); Element getElementById(in DOMString elementId); NodeList getElementsByName(in DOMString elementName); };
title
TITLE
element in the head of the document. referrer
domain
URL
body
BODY
contents, returns the BODY
element, and in frameset documents, this returns the outermost
FRAMESET
element. images
IMG
elements in a document.
The behavior is limited to IMG
elements for
backwards compatibility.
applets
OBJECT
elements that include
applets and APPLET
(deprecated) elements in
a document. links
AREA
elements and
anchor (A
) elements in a document
with a value for the href
attribute. forms
anchors
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. cookie
name=value;expires=date
. open
Open a document stream for writing. If a document exists in the
target, this method clears it.
This method has no parameters.
This method returns nothing.
This method raises no exceptions.
close
open()
and forces rendering.write
open()
. The text is parsed into the document's structure
model.
text |
The string to be parsed into some structure in the document structure model. |
writeln
open()
. The text is parsed into the
document's structure model.
text |
The string to be parsed into some structure in the document structure model. |
getElementById
id
is given by
elementId. If no such element exists, returns null
.
Behavior is not defined if more than one element
has this id
.
elementId |
The unique |
getElementsByName
name
value is given by elementName
.
elementName |
The |
HTML attributes are exposed as properties on the element object. The name of the exposed property always uses the naming conventions, 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., (border)) | 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.
To avoid name-space 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
.
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".
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:
Note. The style
attribute for this
interface is reserved for future usage.
interface HTMLElement : Element { attribute DOMString id; attribute DOMString title; attribute DOMString lang; attribute DOMString dir; attribute DOMString className; };
id
title
lang
dir
className
Root of an HTML document. See the HTML element definition in HTML 4.0.
interface HTMLHtmlElement : HTMLElement { attribute DOMString version; };
version
Document head information. See the HEAD element definition in HTML 4.0.
interface HTMLHeadElement : HTMLElement { attribute DOMString profile; };
profile
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.
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; };
disabled
charset
href
hreflang
media
rel
rev
target
type
The document title. See the TITLE element definition in HTML 4.0.
interface HTMLTitleElement : HTMLElement { attribute DOMString text; };
text
This contains generic meta-information about the document. See the META element definition in HTML 4.0.
interface HTMLMetaElement : HTMLElement { attribute DOMString content; attribute DOMString httpEquiv; attribute DOMString name; attribute DOMString scheme; };
content
httpEquiv
name
scheme
Document base URI. See the BASE element definition in HTML 4.0.
interface HTMLBaseElement : HTMLElement { attribute DOMString href; attribute DOMString target; };
href
target
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.
interface HTMLIsIndexElement : HTMLElement { readonly attribute HTMLFormElement form; attribute DOMString prompt; };
form
FORM
element containing this control.
Returns null if this control is not within the context of a form. prompt
Style information. A more detailed style sheet object model is planned to be defined in a separate document. See the STYLE element definition in HTML 4.0.
interface HTMLStyleElement : HTMLElement { attribute boolean disabled; attribute DOMString media; attribute DOMString type; };
disabled
media
type
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.
interface HTMLBodyElement : HTMLElement { attribute DOMString aLink; attribute DOMString background; attribute DOMString bgColor; attribute DOMString link; attribute DOMString text; attribute DOMString vLink; };
aLink
background
bgColor
link
text
vLink
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.
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(); };
elements
length
name
acceptCharset
action
enctype
method
target
submit
reset
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.
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); void remove(in long index); void blur(); void focus(); };
type
selectedIndex
value
length
SELECT
. form
FORM
element containing this control.
Returns null if this control is not within the context of a form. options
OPTION
elements contained by this element. disabled
multiple
OPTION
elements may
be selected in this SELECT
. See the multiple attribute definition
in HTML 4.0.name
size
tabIndex
add
OPTION
elements
for this SELECT
.
element |
The element to add. | |
before |
The element to insert before, or NULL for the head of the list. |
remove
OPTION
elements
for this SELECT
. Does nothing if no element has the given
index.
index |
The index of the item to remove. |
blur
focus
Group options together in logical subdivisions. See the OPTGROUP element definition in HTML 4.0.
interface HTMLOptGroupElement : HTMLElement { attribute boolean disabled; attribute DOMString label; };
disabled
label
A selectable choice. See the OPTION element definition in HTML 4.0.
interface HTMLOptionElement : HTMLElement { readonly attribute HTMLFormElement form; attribute boolean defaultSelected; readonly attribute DOMString text; attribute long index; attribute boolean disabled; attribute DOMString label; readonly attribute boolean selected; attribute DOMString value; };
form
FORM
element containing this control.
Returns null if this control is not within the context of a form. defaultSelected
selected
attribute. text
index
OPTION
in its parent SELECT
. disabled
label
selected
value
Form control. Note. Depending upon the environment 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.
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(); };
defaultValue
value
). defaultChecked
type
has the value "Radio" or "Checkbox",
stores the initial value of the checked
attribute. form
FORM
element containing this control.
Returns null if this control is not within the context of a form. accept
accessKey
align
alt
checked
type
has the value "Radio" or "Checkbox". The value is
TRUE if explicitly set. Represents the current state of the checkbox
or radio button. See the checked attribute definition
in HTML 4.0.disabled
maxLength
type
has the value "Text" or "Password". See the maxlength attribute definition
in HTML 4.0.name
readOnly
type
has the value "text"
or "password" only. See the readonly attribute definition
in HTML 4.0.size
src
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
type
useMap
value
blur
focus
select
INPUT
elements
whose type
attribute has one of the following values:
"Text", "File", or "Password".click
INPUT
elements whose
type
attribute has one of the following
values: "Button", "Checkbox", "Radio", "Reset", or "Submit".Multi-line text field. See the TEXTAREA element definition in HTML 4.0.
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(); };
defaultValue
value
). form
FORM
element containing this control.
Returns null if this control is not within the context of a form. accessKey
cols
disabled
name
readOnly
rows
tabIndex
type
value
blur
focus
select
TEXTAREA
.Push button. See the BUTTON element definition in HTML 4.0.
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; };
form
FORM
element containing this control.
Returns null if this control is not within the context of a form. accessKey
disabled
name
tabIndex
type
value
Form field label text. See the LABEL element definition in HTML 4.0.
interface HTMLLabelElement : HTMLElement { readonly attribute HTMLFormElement form; attribute DOMString accessKey; attribute DOMString htmlFor; };
form
FORM
element containing this control.
Returns null if this control is not within the context of a form. accessKey
htmlFor
id
attribute. See the for attribute definition
in HTML 4.0.Organizes form controls into logical groups. See the FIELDSET element definition in HTML 4.0.
interface HTMLFieldSetElement : HTMLElement { readonly attribute HTMLFormElement form; };
form
FORM
element containing this control.
Returns null if this control is not within the context of a form. Provides a caption for a FIELDSET
grouping. See the LEGEND element definition
in HTML 4.0.
interface HTMLLegendElement : HTMLElement { readonly attribute HTMLFormElement form; attribute DOMString accessKey; attribute DOMString align; };
form
FORM
element containing this control.
Returns null if this control is not within the context of a form. accessKey
align
FIELDSET
. See the align attribute definition
in HTML 4.0. This attribute is deprecated in HTML 4.0.Unordered list. See the UL element definition in HTML 4.0.
interface HTMLUListElement : HTMLElement { attribute boolean compact; attribute DOMString type; };
compact
type
Ordered list. See the OL element definition in HTML 4.0.
interface HTMLOListElement : HTMLElement { attribute boolean compact; attribute long start; attribute DOMString type; };
compact
start
type
Definition list. See the DL element definition in HTML 4.0.
interface HTMLDListElement : HTMLElement { attribute boolean compact; };
compact
Directory list. See the DIR element definition in HTML 4.0. This element is deprecated in HTML 4.0.
interface HTMLDirectoryElement : HTMLElement { attribute boolean compact; };
compact
Menu list. See the MENU element definition in HTML 4.0. This element is deprecated in HTML 4.0.
interface HTMLMenuElement : HTMLElement { attribute boolean compact; };
compact
List item. See the LI element definition in HTML 4.0.
interface HTMLLIElement : HTMLElement { attribute DOMString type; attribute long value; };
type
value
OL
See the value attribute definition
in HTML 4.0. This attribute is deprecated in HTML 4.0.??? See the BLOCKQUOTE element definition in HTML 4.0.
interface HTMLBlockquoteElement : HTMLElement { attribute DOMString cite; };
cite
Generic block container. See the DIV element definition in HTML 4.0.
interface HTMLDivElement : HTMLElement { attribute DOMString align; };
align
Paragraphs. See the P element definition in HTML 4.0.
interface HTMLParagraphElement : HTMLElement { attribute DOMString align; };
align
For the H1
to H6
elements. See the H1 element definition
in HTML 4.0.
interface HTMLHeadingElement : HTMLElement { attribute DOMString align; };
align
For the Q
and BLOCKQUOTE
elements. See the Q element definition
in HTML 4.0.
interface HTMLQuoteElement : HTMLElement { attribute DOMString cite; };
cite
Preformatted text. See the PRE element definition in HTML 4.0.
interface HTMLPreElement : HTMLElement { attribute long width; };
width
Force a line break. See the BR element definition in HTML 4.0.
interface HTMLBRElement : HTMLElement { attribute DOMString clear; };
clear
Base font. See the BASEFONT element definition in HTML 4.0. This element is deprecated in HTML 4.0.
interface HTMLBaseFontElement : HTMLElement { attribute DOMString color; attribute DOMString face; attribute DOMString size; };
color
face
size
Local change to font. See the FONT element definition in HTML 4.0. This element is deprecated in HTML 4.0.
interface HTMLFontElement : HTMLElement { attribute DOMString color; attribute DOMString face; attribute DOMString size; };
color
face
size
Create a horizontal rule. See the HR element definition in HTML 4.0.
interface HTMLHRElement : HTMLElement { attribute DOMString align; attribute boolean noShade; attribute DOMString size; attribute DOMString width; };
align
noShade
size
width
Notice of modification to part of a document. See the INS and DEL element definitions in HTML 4.0.
interface HTMLModElement : HTMLElement { attribute DOMString cite; attribute DOMString dateTime; };
cite
dateTime
The anchor element. See the A element definition in HTML 4.0.
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(); };
accessKey
charset
coords
shape
for the shape of the region. See the coords attribute definition
in HTML 4.0.href
hreflang
name
rel
rev
shape
coords
. See the shape attribute definition
in HTML 4.0.tabIndex
target
type
blur
focus
Embedded image. See the IMG element definition in HTML 4.0.
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; };
lowSrc
name
align
alt
border
height
hspace
isMap
longDesc
src
useMap
vspace
width
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.
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; };
form
FORM
element containing this control.
Returns null if this control is not within the context of a form. code
code
attribute for
HTMLAppletElement. align
archive
border
codeBase
classid
, data
, and
archive
attributes. See the codebase attribute definition
in HTML 4.0.codeType
classid
attribute. See the codetype attribute definition
in HTML 4.0.data
declare
height
hspace
name
standby
tabIndex
type
data
attribute. See the type attribute definition
in HTML 4.0.useMap
vspace
width
Parameters fed to the OBJECT
element. See the PARAM element definition
in HTML 4.0.
interface HTMLParamElement : HTMLElement { attribute DOMString name; attribute DOMString type; attribute DOMString value; attribute DOMString valueType; };
name
type
value
attribute when
valuetype
has the value "ref". See the type attribute definition
in HTML 4.0.value
valueType
value
attribute
value. See the valuetype attribute definition
in HTML 4.0.An embedded Java applet. See the APPLET element definition in HTML 4.0. This element is deprecated in HTML 4.0.
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; };
align
alt
archive
code
codeBase
height
hspace
name
object
vspace
width
Client-side image map. See the MAP element definition in HTML 4.0.
interface HTMLMapElement : HTMLElement { readonly attribute HTMLCollection areas; attribute DOMString name; };
areas
name
usemap
). See the name attribute definition
in HTML 4.0.Client-side image map area definition. See the AREA element definition in HTML 4.0.
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; };
accessKey
alt
coords
shape
for the shape of the region. See the coords attribute definition
in HTML 4.0.href
noHref
shape
coords
. See the shape attribute definition
in HTML 4.0.tabIndex
target
Script statements. See the SCRIPT element definition in HTML 4.0.
interface HTMLScriptElement : HTMLElement { attribute DOMString text; attribute DOMString htmlFor; attribute DOMString event; attribute DOMString charset; attribute boolean defer; attribute DOMString src; attribute DOMString type; };
text
htmlFor
event
charset
defer
src
type
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.
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); void deleteRow(in long index); };
caption
CAPTION
, or void if none exists. tHead
THEAD
, or
null
if none exists.
tFoot
TFOOT
, or
null
if none exists.
rows
THEAD
, TFOOT
, all
TBODY
elements. tBodies
align
bgColor
border
cellPadding
cellSpacing
frame
rules
summary
width
createTHead
THEAD
).deleteTHead
createTFoot
TFOOT
).deleteTFoot
createCaption
CAPTION
element.deleteCaption
insertRow
index |
The row number where to insert a new row. |
deleteRow
index |
The index of the row to be deleted. |
Table caption See the CAPTION element definition in HTML 4.0.
interface HTMLTableCaptionElement : HTMLElement { attribute DOMString align; };
align
Regroups the COL
and COLGROUP
elements. See the COL element definition
in HTML 4.0.
interface HTMLTableColElement : HTMLElement { attribute DOMString align; attribute DOMString ch; attribute DOMString chOff; attribute long span; attribute DOMString vAlign; attribute DOMString width; };
align
ch
chOff
span
vAlign
width
The THEAD
, TFOOT
, and TBODY
elements.
interface HTMLTableSectionElement : HTMLElement { attribute DOMString align; attribute DOMString ch; attribute DOMString chOff; attribute DOMString vAlign; readonly attribute HTMLCollection rows; HTMLElement insertRow(in long index); void deleteRow(in long index); };
align
align
attribute for HTMLTheadElement for details. ch
chOff
vAlign
valign
attribute for HTMLTheadElement for details. rows
insertRow
index |
The row number where to insert a new row. |
deleteRow
index |
The index of the row to be deleted. |
A row in a table. See the TR element definition in HTML 4.0.
interface HTMLTableRowElement : HTMLElement { attribute long rowIndex; attribute long sectionRowIndex; attribute HTMLCollection cells; attribute DOMString align; attribute DOMString bgColor; attribute DOMString ch; attribute DOMString chOff; attribute DOMString vAlign; HTMLElement insertCell(in long index); void deleteCell(in long index); };
rowIndex
sectionRowIndex
THEAD
, TFOOT
, or TBODY
). cells
align
bgColor
ch
chOff
vAlign
insertCell
TD
cell into this row.
index |
The place to insert the cell. |
deleteCell
index |
The index of the cell to delete. |
The object used to represent the TH
and TD
elements. See the TD element definition
in HTML 4.0.
interface HTMLTableCellElement : HTMLElement { 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; };
cellIndex
abbr
align
axis
bgColor
ch
chOff
colSpan
headers
id
attribute values for header cells. See the headers attribute definition
in HTML 4.0.height
noWrap
rowSpan
scope
vAlign
width
Create a grid of frames. See the FRAMESET element definition in HTML 4.0.
interface HTMLFrameSetElement : HTMLElement { attribute DOMString cols; attribute DOMString rows; };
cols
rows
Create a frame. See the FRAME element definition in HTML 4.0.
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; };
frameBorder
longDesc
marginHeight
marginWidth
name
target
attribute). See the name attribute definition
in HTML 4.0.noResize
scrolling
src
Inline subwindows. See the IFRAME element definition in HTML 4.0.
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; };
align
frameBorder
height
longDesc
marginHeight
marginWidth
name
target
attribute). See the name attribute definition
in HTML 4.0.scrolling
src
width
Members of the DOM Working Group and Interest Group contributing to this specification were:
Several of the following term definitions have been borrowed or modified from similar definitions in other W3C or standards documents. See the links within the definitions for more information.
This appendix contains the complete OMG IDL for the Level 1 Document Object Model definitions. The definitions are divided into Core and HTML.
The IDL files are also available as: http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/idl.zip
This section contains the OMG IDL definitions for the interfaces in the Core Document Object Model specification, including the extended (XML) interfaces.
exception DOMException { unsigned short code; }; // ExceptionCode const unsigned short INDEX_SIZE_ERR = 1; const unsigned short DOMSTRING_SIZE_ERR = 2; const unsigned short HIERARCHY_REQUEST_ERR = 3; const unsigned short WRONG_DOCUMENT_ERR = 4; const unsigned short INVALID_CHARACTER_ERR = 5; const unsigned short NO_DATA_ALLOWED_ERR = 6; const unsigned short NO_MODIFICATION_ALLOWED_ERR = 7; const unsigned short NOT_FOUND_ERR = 8; const unsigned short NOT_SUPPORTED_ERR = 9; const unsigned short INUSE_ATTRIBUTE_ERR = 10; // ExceptionCode const unsigned short INDEX_SIZE_ERR = 1; const unsigned short DOMSTRING_SIZE_ERR = 2; const unsigned short HIERARCHY_REQUEST_ERR = 3; const unsigned short WRONG_DOCUMENT_ERR = 4; const unsigned short INVALID_CHARACTER_ERR = 5; const unsigned short NO_DATA_ALLOWED_ERR = 6; const unsigned short NO_MODIFICATION_ALLOWED_ERR = 7; const unsigned short NOT_FOUND_ERR = 8; const unsigned short NOT_SUPPORTED_ERR = 9; const unsigned short INUSE_ATTRIBUTE_ERR = 10; interface DOMImplementation { boolean hasFeature(in DOMString feature, in DOMString version); }; interface DocumentFragment : Node { }; 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); }; 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; 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); }; interface NodeList { Node item(in unsigned long index); readonly attribute unsigned long length; }; 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; }; 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); }; interface Attr : Node { readonly attribute DOMString name; readonly attribute boolean specified; attribute DOMString value; }; 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); void normalize(); }; interface Text : CharacterData { Text splitText(in unsigned long offset) raises(DOMException); }; interface Comment : CharacterData { }; interface CDATASection : Text { }; interface DocumentType : Node { readonly attribute DOMString name; readonly attribute NamedNodeMap entities; readonly attribute NamedNodeMap notations; }; interface Notation : Node { readonly attribute DOMString publicId; readonly attribute DOMString systemId; }; interface Entity : Node { readonly attribute DOMString publicId; readonly attribute DOMString systemId; readonly attribute DOMString notationName; }; interface EntityReference : Node { }; interface ProcessingInstruction : Node { readonly attribute DOMString target; attribute DOMString data; // raises(DOMException) on setting };
interface HTMLCollection { readonly attribute unsigned long length; Node item(in unsigned long index); Node namedItem(in DOMString name); }; 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); Element getElementById(in DOMString elementId); NodeList getElementsByName(in DOMString elementName); }; interface HTMLElement : Element { attribute DOMString id; attribute DOMString title; attribute DOMString lang; attribute DOMString dir; attribute DOMString className; }; interface HTMLHtmlElement : HTMLElement { attribute DOMString version; }; interface HTMLHeadElement : HTMLElement { attribute DOMString profile; }; 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; }; interface HTMLTitleElement : HTMLElement { attribute DOMString text; }; interface HTMLMetaElement : HTMLElement { attribute DOMString content; attribute DOMString httpEquiv; attribute DOMString name; attribute DOMString scheme; }; interface HTMLBaseElement : HTMLElement { attribute DOMString href; attribute DOMString target; }; interface HTMLIsIndexElement : HTMLElement { readonly attribute HTMLFormElement form; attribute DOMString prompt; }; interface HTMLStyleElement : HTMLElement { attribute boolean disabled; attribute DOMString media; attribute DOMString type; }; interface HTMLBodyElement : HTMLElement { attribute DOMString aLink; attribute DOMString background; attribute DOMString bgColor; attribute DOMString link; attribute DOMString text; attribute DOMString vLink; }; 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(); }; 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); void remove(in long index); void blur(); void focus(); }; interface HTMLOptGroupElement : HTMLElement { attribute boolean disabled; attribute DOMString label; }; interface HTMLOptionElement : HTMLElement { readonly attribute HTMLFormElement form; attribute boolean defaultSelected; readonly attribute DOMString text; attribute long index; attribute boolean disabled; attribute DOMString label; readonly attribute boolean selected; attribute DOMString value; }; 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(); }; 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(); }; 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; }; interface HTMLLabelElement : HTMLElement { readonly attribute HTMLFormElement form; attribute DOMString accessKey; attribute DOMString htmlFor; }; interface HTMLFieldSetElement : HTMLElement { readonly attribute HTMLFormElement form; }; interface HTMLLegendElement : HTMLElement { readonly attribute HTMLFormElement form; attribute DOMString accessKey; attribute DOMString align; }; interface HTMLUListElement : HTMLElement { attribute boolean compact; attribute DOMString type; }; interface HTMLOListElement : HTMLElement { attribute boolean compact; attribute long start; attribute DOMString type; }; interface HTMLDListElement : HTMLElement { attribute boolean compact; }; interface HTMLDirectoryElement : HTMLElement { attribute boolean compact; }; interface HTMLMenuElement : HTMLElement { attribute boolean compact; }; interface HTMLLIElement : HTMLElement { attribute DOMString type; attribute long value; }; interface HTMLBlockquoteElement : HTMLElement { attribute DOMString cite; }; interface HTMLDivElement : HTMLElement { attribute DOMString align; }; interface HTMLParagraphElement : HTMLElement { attribute DOMString align; }; interface HTMLHeadingElement : HTMLElement { attribute DOMString align; }; interface HTMLQuoteElement : HTMLElement { attribute DOMString cite; }; interface HTMLPreElement : HTMLElement { attribute long width; }; interface HTMLBRElement : HTMLElement { attribute DOMString clear; }; interface HTMLBaseFontElement : HTMLElement { attribute DOMString color; attribute DOMString face; attribute DOMString size; }; interface HTMLFontElement : HTMLElement { attribute DOMString color; attribute DOMString face; attribute DOMString size; }; interface HTMLHRElement : HTMLElement { attribute DOMString align; attribute boolean noShade; attribute DOMString size; attribute DOMString width; }; interface HTMLModElement : HTMLElement { attribute DOMString cite; attribute DOMString dateTime; }; 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(); }; 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; }; 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; }; interface HTMLParamElement : HTMLElement { attribute DOMString name; attribute DOMString type; attribute DOMString value; attribute DOMString valueType; }; 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; }; interface HTMLMapElement : HTMLElement { readonly attribute HTMLCollection areas; attribute DOMString name; }; 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; }; interface HTMLScriptElement : HTMLElement { attribute DOMString text; attribute DOMString htmlFor; attribute DOMString event; attribute DOMString charset; attribute boolean defer; attribute DOMString src; attribute DOMString type; }; 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); void deleteRow(in long index); }; interface HTMLTableCaptionElement : HTMLElement { attribute DOMString align; }; interface HTMLTableColElement : HTMLElement { attribute DOMString align; attribute DOMString ch; attribute DOMString chOff; attribute long span; attribute DOMString vAlign; attribute DOMString width; }; interface HTMLTableSectionElement : HTMLElement { attribute DOMString align; attribute DOMString ch; attribute DOMString chOff; attribute DOMString vAlign; readonly attribute HTMLCollection rows; HTMLElement insertRow(in long index); void deleteRow(in long index); }; interface HTMLTableRowElement : HTMLElement { attribute long rowIndex; attribute long sectionRowIndex; attribute HTMLCollection cells; attribute DOMString align; attribute DOMString bgColor; attribute DOMString ch; attribute DOMString chOff; attribute DOMString vAlign; HTMLElement insertCell(in long index); void deleteCell(in long index); }; interface HTMLTableCellElement : HTMLElement { 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; }; interface HTMLFrameSetElement : HTMLElement { attribute DOMString cols; attribute DOMString rows; }; 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; }; 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; };
This appendix contains the complete Java binding for the Level 1 Document Object Model. The definitions are divided into Core and HTML.
The Java files are also available as http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/java-binding.zip
public abstract class DOMException extends RuntimeException { public DOMException(short code, String message) { super(message); this.code = code; } public short code; // ExceptionCode public static final short INDEX_SIZE_ERR = 1; public static final short DOMSTRING_SIZE_ERR = 2; public static final short HIERARCHY_REQUEST_ERR = 3; public static final short WRONG_DOCUMENT_ERR = 4; public static final short INVALID_CHARACTER_ERR = 5; public static final short NO_DATA_ALLOWED_ERR = 6; public static final short NO_MODIFICATION_ALLOWED_ERR = 7; public static final short NOT_FOUND_ERR = 8; public static final short NOT_SUPPORTED_ERR = 9; public static final short INUSE_ATTRIBUTE_ERR = 10; } // ExceptionCode public static final short INDEX_SIZE_ERR = 1; public static final short DOMSTRING_SIZE_ERR = 2; public static final short HIERARCHY_REQUEST_ERR = 3; public static final short WRONG_DOCUMENT_ERR = 4; public static final short INVALID_CHARACTER_ERR = 5; public static final short NO_DATA_ALLOWED_ERR = 6; public static final short NO_MODIFICATION_ALLOWED_ERR = 7; public static final short NOT_FOUND_ERR = 8; public static final short NOT_SUPPORTED_ERR = 9; public static final short INUSE_ATTRIBUTE_ERR = 10; } public interface DOMImplementation { public boolean hasFeature(String feature, String version); } public interface DocumentFragment extends Node { } public interface Document extends Node { public DocumentType getDoctype(); public DOMImplementation getImplementation(); public Element getDocumentElement(); public Element createElement(String tagName) throws DOMException; public DocumentFragment createDocumentFragment(); public Text createTextNode(String data); public Comment createComment(String data); public CDATASection createCDATASection(String data) throws DOMException; public ProcessingInstruction createProcessingInstruction(String target, String data) throws DOMException; public Attr createAttribute(String name) throws DOMException; public EntityReference createEntityReference(String name) throws DOMException; public NodeList getElementsByTagName(String tagname); } public interface Node { // NodeType public static final short ELEMENT_NODE = 1; public static final short ATTRIBUTE_NODE = 2; public static final short TEXT_NODE = 3; public static final short CDATA_SECTION_NODE = 4; public static final short ENTITY_REFERENCE_NODE = 5; public static final short ENTITY_NODE = 6; public static final short PROCESSING_INSTRUCTION_NODE = 7; public static final short COMMENT_NODE = 8; public static final short DOCUMENT_NODE = 9; public static final short DOCUMENT_TYPE_NODE = 10; public static final short DOCUMENT_FRAGMENT_NODE = 11; public static final short NOTATION_NODE = 12; public String getNodeName(); public String getNodeValue() throws DOMException; public void setNodeValue(String nodeValue) throws DOMException; public short getNodeType(); public Node getParentNode(); public NodeList getChildNodes(); public Node getFirstChild(); public Node getLastChild(); public Node getPreviousSibling(); public Node getNextSibling(); public NamedNodeMap getAttributes(); public Document getOwnerDocument(); public Node insertBefore(Node newChild, Node refChild) throws DOMException; public Node replaceChild(Node newChild, Node oldChild) throws DOMException; public Node removeChild(Node oldChild) throws DOMException; public Node appendChild(Node newChild) throws DOMException; public boolean hasChildNodes(); public Node cloneNode(boolean deep); } public interface NodeList { public Node item(int index); public int getLength(); } public interface NamedNodeMap { public Node getNamedItem(String name); public Node setNamedItem(Node arg) throws DOMException; public Node removeNamedItem(String name) throws DOMException; public Node item(int index); public int getLength(); } public interface CharacterData extends Node { public String getData() throws DOMException; public void setData(String data) throws DOMException; public int getLength(); public String substringData(int offset, int count) throws DOMException; public void appendData(String arg) throws DOMException; public void insertData(int offset, String arg) throws DOMException; public void deleteData(int offset, int count) throws DOMException; public void replaceData(int offset, int count, String arg) throws DOMException; } public interface Attr extends Node { public String getName(); public boolean getSpecified(); public String getValue(); public void setValue(String value); } public interface Element extends Node { public String getTagName(); public String getAttribute(String name); public void setAttribute(String name, String value) throws DOMException; public void removeAttribute(String name) throws DOMException; public Attr getAttributeNode(String name); public Attr setAttributeNode(Attr newAttr) throws DOMException; public Attr removeAttributeNode(Attr oldAttr) throws DOMException; public NodeList getElementsByTagName(String name); public void normalize(); } public interface Text extends CharacterData { public Text splitText(int offset) throws DOMException; } public interface Comment extends CharacterData { } public interface CDATASection extends Text { } public interface DocumentType extends Node { public String getName(); public NamedNodeMap getEntities(); public NamedNodeMap getNotations(); } public interface Notation extends Node { public String getPublicId(); public String getSystemId(); } public interface Entity extends Node { public String getPublicId(); public String getSystemId(); public String getNotationName(); } public interface EntityReference extends Node { } public interface ProcessingInstruction extends Node { public String getTarget(); public String getData(); public void setData(String data) throws DOMException; }
public interface HTMLCollection { public int getLength(); public Node item(int index); public Node namedItem(String name); } public interface HTMLDocument extends Document { public String getTitle(); public void setTitle(String title); public String getReferrer(); public String getDomain(); public String getURL(); public HTMLElement getBody(); public void setBody(HTMLElement body); public HTMLCollection getImages(); public HTMLCollection getApplets(); public HTMLCollection getLinks(); public HTMLCollection getForms(); public HTMLCollection getAnchors(); public String getCookie(); public void setCookie(String cookie); public void open(); public void close(); public void write(String text); public void writeln(String text); public Element getElementById(String elementId); public NodeList getElementsByName(String elementName); } public interface HTMLElement extends Element { public String getId(); public void setId(String id); public String getTitle(); public void setTitle(String title); public String getLang(); public void setLang(String lang); public String getDir(); public void setDir(String dir); public String getClassName(); public void setClassName(String className); } public interface HTMLHtmlElement extends HTMLElement { public String getVersion(); public void setVersion(String version); } public interface HTMLHeadElement extends HTMLElement { public String getProfile(); public void setProfile(String profile); } public interface HTMLLinkElement extends HTMLElement { public boolean getDisabled(); public void setDisabled(boolean disabled); public String getCharset(); public void setCharset(String charset); public String getHref(); public void setHref(String href); public String getHreflang(); public void setHreflang(String hreflang); public String getMedia(); public void setMedia(String media); public String getRel(); public void setRel(String rel); public String getRev(); public void setRev(String rev); public String getTarget(); public void setTarget(String target); public String getType(); public void setType(String type); } public interface HTMLTitleElement extends HTMLElement { public String getText(); public void setText(String text); } public interface HTMLMetaElement extends HTMLElement { public String getContent(); public void setContent(String content); public String getHttpEquiv(); public void setHttpEquiv(String httpEquiv); public String getName(); public void setName(String name); public String getScheme(); public void setScheme(String scheme); } public interface HTMLBaseElement extends HTMLElement { public String getHref(); public void setHref(String href); public String getTarget(); public void setTarget(String target); } public interface HTMLIsIndexElement extends HTMLElement { public HTMLFormElement getForm(); public String getPrompt(); public void setPrompt(String prompt); } public interface HTMLStyleElement extends HTMLElement { public boolean getDisabled(); public void setDisabled(boolean disabled); public String getMedia(); public void setMedia(String media); public String getType(); public void setType(String type); } public interface HTMLBodyElement extends HTMLElement { public String getALink(); public void setALink(String aLink); public String getBackground(); public void setBackground(String background); public String getBgColor(); public void setBgColor(String bgColor); public String getLink(); public void setLink(String link); public String getText(); public void setText(String text); public String getVLink(); public void setVLink(String vLink); } public interface HTMLFormElement extends HTMLElement { public HTMLCollection getElements(); public int getLength(); public String getName(); public void setName(String name); public String getAcceptCharset(); public void setAcceptCharset(String acceptCharset); public String getAction(); public void setAction(String action); public String getEnctype(); public void setEnctype(String enctype); public String getMethod(); public void setMethod(String method); public String getTarget(); public void setTarget(String target); public void submit(); public void reset(); } public interface HTMLSelectElement extends HTMLElement { public String getType(); public int getSelectedIndex(); public void setSelectedIndex(int selectedIndex); public String getValue(); public void setValue(String value); public int getLength(); public HTMLFormElement getForm(); public HTMLCollection getOptions(); public boolean getDisabled(); public void setDisabled(boolean disabled); public boolean getMultiple(); public void setMultiple(boolean multiple); public String getName(); public void setName(String name); public int getSize(); public void setSize(int size); public int getTabIndex(); public void setTabIndex(int tabIndex); public void add(HTMLElement element, HTMLElement before); public void remove(int index); public void blur(); public void focus(); } public interface HTMLOptGroupElement extends HTMLElement { public boolean getDisabled(); public void setDisabled(boolean disabled); public String getLabel(); public void setLabel(String label); } public interface HTMLOptionElement extends HTMLElement { public HTMLFormElement getForm(); public boolean getDefaultSelected(); public void setDefaultSelected(boolean defaultSelected); public String getText(); public int getIndex(); public void setIndex(int index); public boolean getDisabled(); public void setDisabled(boolean disabled); public String getLabel(); public void setLabel(String label); public boolean getSelected(); public String getValue(); public void setValue(String value); } public interface HTMLInputElement extends HTMLElement { public String getDefaultValue(); public void setDefaultValue(String defaultValue); public boolean getDefaultChecked(); public void setDefaultChecked(boolean defaultChecked); public HTMLFormElement getForm(); public String getAccept(); public void setAccept(String accept); public String getAccessKey(); public void setAccessKey(String accessKey); public String getAlign(); public void setAlign(String align); public String getAlt(); public void setAlt(String alt); public boolean getChecked(); public void setChecked(boolean checked); public boolean getDisabled(); public void setDisabled(boolean disabled); public int getMaxLength(); public void setMaxLength(int maxLength); public String getName(); public void setName(String name); public boolean getReadOnly(); public void setReadOnly(boolean readOnly); public String getSize(); public void setSize(String size); public String getSrc(); public void setSrc(String src); public int getTabIndex(); public void setTabIndex(int tabIndex); public String getType(); public String getUseMap(); public void setUseMap(String useMap); public String getValue(); public void setValue(String value); public void blur(); public void focus(); public void select(); public void click(); } public interface HTMLTextAreaElement extends HTMLElement { public String getDefaultValue(); public void setDefaultValue(String defaultValue); public HTMLFormElement getForm(); public String getAccessKey(); public void setAccessKey(String accessKey); public int getCols(); public void setCols(int cols); public boolean getDisabled(); public void setDisabled(boolean disabled); public String getName(); public void setName(String name); public boolean getReadOnly(); public void setReadOnly(boolean readOnly); public int getRows(); public void setRows(int rows); public int getTabIndex(); public void setTabIndex(int tabIndex); public String getType(); public String getValue(); public void setValue(String value); public void blur(); public void focus(); public void select(); } public interface HTMLButtonElement extends HTMLElement { public HTMLFormElement getForm(); public String getAccessKey(); public void setAccessKey(String accessKey); public boolean getDisabled(); public void setDisabled(boolean disabled); public String getName(); public void setName(String name); public int getTabIndex(); public void setTabIndex(int tabIndex); public String getType(); public String getValue(); public void setValue(String value); } public interface HTMLLabelElement extends HTMLElement { public HTMLFormElement getForm(); public String getAccessKey(); public void setAccessKey(String accessKey); public String getHtmlFor(); public void setHtmlFor(String htmlFor); } public interface HTMLFieldSetElement extends HTMLElement { public HTMLFormElement getForm(); } public interface HTMLLegendElement extends HTMLElement { public HTMLFormElement getForm(); public String getAccessKey(); public void setAccessKey(String accessKey); public String getAlign(); public void setAlign(String align); } public interface HTMLUListElement extends HTMLElement { public boolean getCompact(); public void setCompact(boolean compact); public String getType(); public void setType(String type); } public interface HTMLOListElement extends HTMLElement { public boolean getCompact(); public void setCompact(boolean compact); public int getStart(); public void setStart(int start); public String getType(); public void setType(String type); } public interface HTMLDListElement extends HTMLElement { public boolean getCompact(); public void setCompact(boolean compact); } public interface HTMLDirectoryElement extends HTMLElement { public boolean getCompact(); public void setCompact(boolean compact); } public interface HTMLMenuElement extends HTMLElement { public boolean getCompact(); public void setCompact(boolean compact); } public interface HTMLLIElement extends HTMLElement { public String getType(); public void setType(String type); public int getValue(); public void setValue(int value); } public interface HTMLBlockquoteElement extends HTMLElement { public String getCite(); public void setCite(String cite); } public interface HTMLDivElement extends HTMLElement { public String getAlign(); public void setAlign(String align); } public interface HTMLParagraphElement extends HTMLElement { public String getAlign(); public void setAlign(String align); } public interface HTMLHeadingElement extends HTMLElement { public String getAlign(); public void setAlign(String align); } public interface HTMLQuoteElement extends HTMLElement { public String getCite(); public void setCite(String cite); } public interface HTMLPreElement extends HTMLElement { public int getWidth(); public void setWidth(int width); } public interface HTMLBRElement extends HTMLElement { public String getClear(); public void setClear(String clear); } public interface HTMLBaseFontElement extends HTMLElement { public String getColor(); public void setColor(String color); public String getFace(); public void setFace(String face); public String getSize(); public void setSize(String size); } public interface HTMLFontElement extends HTMLElement { public String getColor(); public void setColor(String color); public String getFace(); public void setFace(String face); public String getSize(); public void setSize(String size); } public interface HTMLHRElement extends HTMLElement { public String getAlign(); public void setAlign(String align); public boolean getNoShade(); public void setNoShade(boolean noShade); public String getSize(); public void setSize(String size); public String getWidth(); public void setWidth(String width); } public interface HTMLModElement extends HTMLElement { public String getCite(); public void setCite(String cite); public String getDateTime(); public void setDateTime(String dateTime); } public interface HTMLAnchorElement extends HTMLElement { public String getAccessKey(); public void setAccessKey(String accessKey); public String getCharset(); public void setCharset(String charset); public String getCoords(); public void setCoords(String coords); public String getHref(); public void setHref(String href); public String getHreflang(); public void setHreflang(String hreflang); public String getName(); public void setName(String name); public String getRel(); public void setRel(String rel); public String getRev(); public void setRev(String rev); public String getShape(); public void setShape(String shape); public int getTabIndex(); public void setTabIndex(int tabIndex); public String getTarget(); public void setTarget(String target); public String getType(); public void setType(String type); public void blur(); public void focus(); } public interface HTMLImageElement extends HTMLElement { public String getLowSrc(); public void setLowSrc(String lowSrc); public String getName(); public void setName(String name); public String getAlign(); public void setAlign(String align); public String getAlt(); public void setAlt(String alt); public String getBorder(); public void setBorder(String border); public String getHeight(); public void setHeight(String height); public String getHspace(); public void setHspace(String hspace); public boolean getIsMap(); public void setIsMap(boolean isMap); public String getLongDesc(); public void setLongDesc(String longDesc); public String getSrc(); public void setSrc(String src); public String getUseMap(); public void setUseMap(String useMap); public String getVspace(); public void setVspace(String vspace); public String getWidth(); public void setWidth(String width); } public interface HTMLObjectElement extends HTMLElement { public HTMLFormElement getForm(); public String getCode(); public void setCode(String code); public String getAlign(); public void setAlign(String align); public String getArchive(); public void setArchive(String archive); public String getBorder(); public void setBorder(String border); public String getCodeBase(); public void setCodeBase(String codeBase); public String getCodeType(); public void setCodeType(String codeType); public String getData(); public void setData(String data); public boolean getDeclare(); public void setDeclare(boolean declare); public String getHeight(); public void setHeight(String height); public String getHspace(); public void setHspace(String hspace); public String getName(); public void setName(String name); public String getStandby(); public void setStandby(String standby); public int getTabIndex(); public void setTabIndex(int tabIndex); public String getType(); public void setType(String type); public String getUseMap(); public void setUseMap(String useMap); public String getVspace(); public void setVspace(String vspace); public String getWidth(); public void setWidth(String width); } public interface HTMLParamElement extends HTMLElement { public String getName(); public void setName(String name); public String getType(); public void setType(String type); public String getValue(); public void setValue(String value); public String getValueType(); public void setValueType(String valueType); } public interface HTMLAppletElement extends HTMLElement { public String getAlign(); public void setAlign(String align); public String getAlt(); public void setAlt(String alt); public String getArchive(); public void setArchive(String archive); public String getCode(); public void setCode(String code); public String getCodeBase(); public void setCodeBase(String codeBase); public String getHeight(); public void setHeight(String height); public String getHspace(); public void setHspace(String hspace); public String getName(); public void setName(String name); public String getObject(); public void setObject(String object); public String getVspace(); public void setVspace(String vspace); public String getWidth(); public void setWidth(String width); } public interface HTMLMapElement extends HTMLElement { public HTMLCollection getAreas(); public String getName(); public void setName(String name); } public interface HTMLAreaElement extends HTMLElement { public String getAccessKey(); public void setAccessKey(String accessKey); public String getAlt(); public void setAlt(String alt); public String getCoords(); public void setCoords(String coords); public String getHref(); public void setHref(String href); public boolean getNoHref(); public void setNoHref(boolean noHref); public String getShape(); public void setShape(String shape); public int getTabIndex(); public void setTabIndex(int tabIndex); public String getTarget(); public void setTarget(String target); } public interface HTMLScriptElement extends HTMLElement { public String getText(); public void setText(String text); public String getHtmlFor(); public void setHtmlFor(String htmlFor); public String getEvent(); public void setEvent(String event); public String getCharset(); public void setCharset(String charset); public boolean getDefer(); public void setDefer(boolean defer); public String getSrc(); public void setSrc(String src); public String getType(); public void setType(String type); } public interface HTMLTableElement extends HTMLElement { public HTMLTableCaptionElement getCaption(); public void setCaption(HTMLTableCaptionElement caption); public HTMLTableSectionElement getTHead(); public void setTHead(HTMLTableSectionElement tHead); public HTMLTableSectionElement getTFoot(); public void setTFoot(HTMLTableSectionElement tFoot); public HTMLCollection getRows(); public HTMLCollection getTBodies(); public String getAlign(); public void setAlign(String align); public String getBgColor(); public void setBgColor(String bgColor); public String getBorder(); public void setBorder(String border); public String getCellPadding(); public void setCellPadding(String cellPadding); public String getCellSpacing(); public void setCellSpacing(String cellSpacing); public String getFrame(); public void setFrame(String frame); public String getRules(); public void setRules(String rules); public String getSummary(); public void setSummary(String summary); public String getWidth(); public void setWidth(String width); public HTMLElement createTHead(); public void deleteTHead(); public HTMLElement createTFoot(); public void deleteTFoot(); public HTMLElement createCaption(); public void deleteCaption(); public HTMLElement insertRow(int index); public void deleteRow(int index); } public interface HTMLTableCaptionElement extends HTMLElement { public String getAlign(); public void setAlign(String align); } public interface HTMLTableColElement extends HTMLElement { public String getAlign(); public void setAlign(String align); public String getCh(); public void setCh(String ch); public String getChOff(); public void setChOff(String chOff); public int getSpan(); public void setSpan(int span); public String getVAlign(); public void setVAlign(String vAlign); public String getWidth(); public void setWidth(String width); } public interface HTMLTableSectionElement extends HTMLElement { public String getAlign(); public void setAlign(String align); public String getCh(); public void setCh(String ch); public String getChOff(); public void setChOff(String chOff); public String getVAlign(); public void setVAlign(String vAlign); public HTMLCollection getRows(); public HTMLElement insertRow(int index); public void deleteRow(int index); } public interface HTMLTableRowElement extends HTMLElement { public int getRowIndex(); public void setRowIndex(int rowIndex); public int getSectionRowIndex(); public void setSectionRowIndex(int sectionRowIndex); public HTMLCollection getCells(); public void setCells(HTMLCollection cells); public String getAlign(); public void setAlign(String align); public String getBgColor(); public void setBgColor(String bgColor); public String getCh(); public void setCh(String ch); public String getChOff(); public void setChOff(String chOff); public String getVAlign(); public void setVAlign(String vAlign); public HTMLElement insertCell(int index); public void deleteCell(int index); } public interface HTMLTableCellElement extends HTMLElement { public int getCellIndex(); public void setCellIndex(int cellIndex); public String getAbbr(); public void setAbbr(String abbr); public String getAlign(); public void setAlign(String align); public String getAxis(); public void setAxis(String axis); public String getBgColor(); public void setBgColor(String bgColor); public String getCh(); public void setCh(String ch); public String getChOff(); public void setChOff(String chOff); public int getColSpan(); public void setColSpan(int colSpan); public String getHeaders(); public void setHeaders(String headers); public String getHeight(); public void setHeight(String height); public boolean getNoWrap(); public void setNoWrap(boolean noWrap); public int getRowSpan(); public void setRowSpan(int rowSpan); public String getScope(); public void setScope(String scope); public String getVAlign(); public void setVAlign(String vAlign); public String getWidth(); public void setWidth(String width); } public interface HTMLFrameSetElement extends HTMLElement { public String getCols(); public void setCols(String cols); public String getRows(); public void setRows(String rows); } public interface HTMLFrameElement extends HTMLElement { public String getFrameBorder(); public void setFrameBorder(String frameBorder); public String getLongDesc(); public void setLongDesc(String longDesc); public String getMarginHeight(); public void setMarginHeight(String marginHeight); public String getMarginWidth(); public void setMarginWidth(String marginWidth); public String getName(); public void setName(String name); public boolean getNoResize(); public void setNoResize(boolean noResize); public String getScrolling(); public void setScrolling(String scrolling); public String getSrc(); public void setSrc(String src); } public interface HTMLIFrameElement extends HTMLElement { public String getAlign(); public void setAlign(String align); public String getFrameBorder(); public void setFrameBorder(String frameBorder); public String getHeight(); public void setHeight(String height); public String getLongDesc(); public void setLongDesc(String longDesc); public String getMarginHeight(); public void setMarginHeight(String marginHeight); public String getMarginWidth(); public void setMarginWidth(String marginWidth); public String getName(); public void setName(String name); public String getScrolling(); public void setScrolling(String scrolling); public String getSrc(); public void setSrc(String src); public String getWidth(); public void setWidth(String width); }
This appendix contains the complete ECMA Script binding for the Level 1 Document Object Model definitions. The definitions are divided into Core and HTML.
ATTRIBUTE_NODE 1 | Attr 1 | CDATASection 1 |
CDATA_SECTION_NODE 1 | COMMENT_NODE 1 | CharacterData 1 |
Comment 1 | DOCUMENT_FRAGMENT_NODE 1 | DOCUMENT_NODE 1 |
DOCUMENT_TYPE_NODE 1 | DOMException 1 | DOMImplementation 1 |
DOMSTRING_SIZE_ERR 1 | Document 1 | DocumentFragment 1 |
DocumentType 1 | ELEMENT_NODE 1 | ENTITY_NODE 1 |
ENTITY_REFERENCE_NODE 1 | Element 1 | Entity 1 |
EntityReference 1 | HIERARCHY_REQUEST_ERR 1 | HTMLAnchorElement 1 |
HTMLAppletElement 1 | HTMLAreaElement 1 | HTMLBRElement 1 |
HTMLBaseElement 1 | HTMLBaseFontElement 1 | HTMLBlockquoteElement 1 |
HTMLBodyElement 1 | HTMLButtonElement 1 | HTMLCollection 1 |
HTMLDListElement 1 | HTMLDirectoryElement 1 | HTMLDivElement 1 |
HTMLDocument 1 | HTMLElement 1 | HTMLFieldSetElement 1 |
HTMLFontElement 1 | HTMLFormElement 1 | HTMLFrameElement 1 |
HTMLFrameSetElement 1 | HTMLHRElement 1 | HTMLHeadElement 1 |
HTMLHeadingElement 1 | HTMLHtmlElement 1 | HTMLIFrameElement 1 |
HTMLImageElement 1 | HTMLInputElement 1 | HTMLIsIndexElement 1 |
HTMLLIElement 1 | HTMLLabelElement 1 | HTMLLegendElement 1 |
HTMLLinkElement 1 | HTMLMapElement 1 | HTMLMenuElement 1 |
HTMLMetaElement 1 | HTMLModElement 1 | HTMLOListElement 1 |
HTMLObjectElement 1 | HTMLOptGroupElement 1 | HTMLOptionElement 1 |
HTMLParagraphElement 1 | HTMLParamElement 1 | HTMLPreElement 1 |
HTMLQuoteElement 1 | HTMLScriptElement 1 | HTMLSelectElement 1 |
HTMLStyleElement 1 | HTMLTableCaptionElement 1 | HTMLTableCellElement 1 |
HTMLTableColElement 1 | HTMLTableElement 1 | HTMLTableRowElement 1 |
HTMLTableSectionElement 1 | HTMLTextAreaElement 1 | HTMLTitleElement 1 |
HTMLUListElement 1 | INDEX_SIZE_ERR 1 | INUSE_ATTRIBUTE_ERR 1 |
INVALID_CHARACTER_ERR 1 | NOTATION_NODE 1 | NOT_FOUND_ERR 1 |
NOT_SUPPORTED_ERR 1 | NO_DATA_ALLOWED_ERR 1 | NO_MODIFICATION_ALLOWED_ERR 1 |
NamedNodeMap 1 | Node 1 | NodeList 1 |
Notation 1 | PROCESSING_INSTRUCTION_NODE 1 | ProcessingInstruction 1 |
TEXT_NODE 1 | Text 1 | URL 1 |
WRONG_DOCUMENT_ERR 1 | aLink 1 | abbr 1 |
accept 1 | acceptCharset 1 | accessKey 1, 2, 3, 4, 5, 6, 7 |
action 1 | add 1 | align 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 |
alt 1, 2, 3, 4 | anchors 1 | appendChild 1 |
appendData 1 | applets 1 | archive 1, 2 |
areas 1 | attributes 1 | axis 1 |
background 1 | bgColor 1, 2, 3, 4 | blur 1, 2, 3, 4 |
body 1 | border 1, 2, 3 | caption 1 |
cellIndex 1 | cellPadding 1 | cellSpacing 1 |
cells 1 | ch 1, 2, 3, 4 | chOff 1, 2, 3, 4 |
charset 1, 2, 3 | checked 1 | childNodes 1 |
cite 1, 2, 3 | className 1 | clear 1 |
click 1 | cloneNode 1 | close 1 |
code 1, 2 | codeBase 1, 2 | codeType 1 |
colSpan 1 | color 1, 2 | cols 1, 2 |
compact 1, 2, 3, 4, 5 | content 1 | cookie 1 |
coords 1, 2 | createAttribute 1 | createCDATASection 1 |
createCaption 1 | createComment 1 | createDocumentFragment 1 |
createElement 1 | createEntityReference 1 | createProcessingInstruction 1 |
createTFoot 1 | createTHead 1 | createTextNode 1 |
data 1, 2, 3 | dateTime 1 | declare 1 |
defaultChecked 1 | defaultSelected 1 | defaultValue 1, 2 |
defer 1 | deleteCaption 1 | deleteCell 1 |
deleteData 1 | deleteRow 1, 2 | deleteTFoot 1 |
deleteTHead 1 | dir 1 | disabled 1, 2, 3, 4, 5, 6, 7, 8 |
doctype 1 | documentElement 1 | domain 1 |
elements 1 | enctype 1 | entities 1 |
event 1 | face 1, 2 | firstChild 1 |
focus 1, 2, 3, 4 | form 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 | forms 1 |
frame 1 | frameBorder 1, 2 | getAttribute 1 |
getAttributeNode 1 | getElementById 1 | getElementsByName 1 |
getElementsByTagName 1, 2 | getNamedItem 1 | hasChildNodes 1 |
hasFeature 1 | headers 1 | height 1, 2, 3, 4, 5 |
href 1, 2, 3, 4 | hreflang 1, 2 | hspace 1, 2, 3 |
htmlFor 1, 2 | httpEquiv 1 | id 1 |
images 1 | implementation 1 | index 1 |
insertBefore 1 | insertCell 1 | insertData 1 |
insertRow 1, 2 | isMap 1 | item 1, 2, 3 |
label 1, 2 | lang 1 | lastChild 1 |
length 1, 2, 3, 4, 5, 6 | link 1 | links 1 |
longDesc 1, 2, 3 | lowSrc 1 | marginHeight 1, 2 |
marginWidth 1, 2 | maxLength 1 | media 1, 2 |
method 1 | multiple 1 | name 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 |
namedItem 1 | nextSibling 1 | noHref 1 |
noResize 1 | noShade 1 | noWrap 1 |
nodeName 1 | nodeType 1 | nodeValue 1 |
normalize 1 | notationName 1 | notations 1 |
object 1 | open 1 | options 1 |
ownerDocument 1 | parentNode 1 | previousSibling 1 |
profile 1 | prompt 1 | publicId 1, 2 |
readOnly 1, 2 | referrer 1 | rel 1, 2 |
remove 1 | removeAttribute 1 | removeAttributeNode 1 |
removeChild 1 | removeNamedItem 1 | replaceChild 1 |
replaceData 1 | reset 1 | rev 1, 2 |
rowIndex 1 | rowSpan 1 | rows 1, 2, 3, 4 |
rules 1 | scheme 1 | scope 1 |
scrolling 1, 2 | sectionRowIndex 1 | select 1, 2 |
selected 1 | selectedIndex 1 | setAttribute 1 |
setAttributeNode 1 | setNamedItem 1 | shape 1, 2 |
size 1, 2, 3, 4, 5 | span 1 | specified 1 |
splitText 1 | src 1, 2, 3, 4, 5 | standby 1 |
start 1 | submit 1 | substringData 1 |
summary 1 | systemId 1, 2 | tBodies 1 |
tFoot 1 | tHead 1 | tabIndex 1, 2, 3, 4, 5, 6, 7 |
tagName 1 | target 1, 2, 3, 4, 5, 6 | text 1, 2, 3, 4 |
title 1, 2 | type 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 | useMap 1, 2, 3 |
vAlign 1, 2, 3, 4 | vLink 1 | value 1, 2, 3, 4, 5, 6, 7, 8 |
valueType 1 | version 1 | vspace 1, 2, 3 |
width 1, 2, 3, 4, 5, 6, 7, 8, 9 | write 1 | writeln 1 |
The DOM specification serves as a good example of the power of using XML: all of the HTML documents, Java bindings, OMG IDL bindings, and ECMA Script bindings are generated from a single set of XML source files. This section outlines how this specification is written in XML, and how the various derived works are created.
This specification was written entirely in XML, using a DTD based heavily on the DTD used by the XML Working Group for the XML specification. The major difference between the DTD used by the XML Working Group, and the DTD used for this specification is the addition of a DTD module for interface specifications.
The DTD module for interfaces specifications is a very loose translation of the Extended Backus-Naur Form (EBNF) specification of the OMG IDL syntax into XML DTD syntax. In addition to the translation, the ability to describe the interfaces was added, thereby creating a limited form of literate programming for interface definitions.
While the DTD module is sufficient for the purposes of the DOM
WG, it is very loosely typed, meaning that there are very few
constraints placed on the type specifications (the type
information is effectively treated as an opaque string). In a DTD
for object
to object communication, some stricter enforcement of data types
would probably be beneficial.
The DOM specification is written using XML. All documents are valid XML. In order to produce the HTML versions of the specification, the object indexes, the Java source code, and the OMG IDL and ECMA Script definitions, the XML specification is converted.
The tool currently used for conversion is COST by
Joe English. COST
takes the ESIS output of
nsgmls
, creates an internal representation, and
then allows scripts, and event
handlers to be run over the internal data structure.
Event handlers allow document patterns and
associated processing to be specified: when the pattern is
matched during a pre-order traversal of a document subtree, the
associated action is executed. This is the heart of the
conversion process. Scripts are used to tie the various
components together. For example, each of the major derived data
sources (Java code etc.) is created by the execution of a
script, which in turn executes one or more event handlers. The
scripts and event handlers are specified using TCL.
The current version of COST
has been somewhat
modified from the publicly available version. In particular,
it now runs correctly under 32-bit Windows, uses TCL 8.0, and
correctly handles the case sensitivity of
XML (though it probably could not correctly handle native language
markup).
We could also have used Jade
, by James Clark. Like
COST
, Jade
allows patterns and actions
to be specified, but Jade
is based on DSSSL, an
international standard, whereas COST
is
not. Jade
is more powerful than COST
in many ways, but prior experience of the editor with Cost made it
easier to use this rather than Jade
. A future version
or Level of
the DOM specification may be produced using Jade
or
an XSL
processor.
The complete XML source files are available at: http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/xml-source.zip
As stated earlier, all object definitions are specified in XML. The Java bindings, OMG IDL bindings, and ECMA Script bindings are all generated automatically from the XML source code.
This is possible because the information specified in XML is a superset of what these other syntax need. This is a general observation, and the same kind of technique can be applied to many other areas: given rich structure, rich processing and conversion are possible. For Java and OMG IDL, it is basically just a matter of renaming syntactic keywords; for ECMA Script, the process is somewhat more involved.
A typical object definition in XML looks something like this:
<interface name="foo"> <descr><p>Description goes here...</p></descr> <method name="bar"> <descr><p>Description goes here...</p></descr> <parameters> <param name="baz" type="DOMString" attr="in"> <descr><p>Description goes here...</p></descr> </param> </parameters> <returns type="void"> <descr><p>Description goes here...</p></descr> </returns> <raises> <!-- Throws no exceptions --> </raises> </method> </interface>
As can easily be seen, this is quite verbose, but not unlike
OMG IDL. In fact, when the specification was originally
converted to use XML, the OMG IDL definitions were automatically
converted into the corresponding XML source using common Unix text
manipulation tools.