|
|
DocumentTraversal contains methods that creates
Iterators to traverse a node and its children in document order
(depth first, pre-order traversal, which is equivalent to the order
in which the start tags occur in the text representation of the
document).
class DocumentTraversal // : public Document ? { public: DocumentTraversal(); DocumentTraversal(const DocumentTraversal &other);
DocumentTraversal & operator = (const DocumentTraversal &other);
~DocumentTraversal();
*
These flags can be combined using OR .
NodeIterator createNodeIterator ( const Node &root, long whatToShow, const NodeFilter &filter, bool entityReferenceExpansion );
* Create a new TreeWalker over the subtree rooted by the specified node.
These flags can be combined using OR .
TreeWalker createTreeWalker ( const Node &root, long whatToShow, const NodeFilter &filter, bool entityReferenceExpansion ); };
Parameters:
| root | The node which will be iterated together with its children. The iterator is initially positioned just before this node. The whatToShow flags and the filter, if any, are not considered when setting this position. |
| whatToShow | This flag specifies which node types may appear in the logical view of the tree presented by the Iterator. See the description of Iterator for the set of possible values. These flags can be combined using OR. |
| filter | The Filter to be used with this TreeWalker, or null to indicate no filter. |
| entityReferenceExpansion | The value of this flag determines whether entity reference nodes are expanded. |
| root | The node which will serve as the root for the
TreeWalker . The currentNode of the TreeWalker
is set to this node. The whatToShow flags and the NodeFilter
are not considered when setting this value; any node type will
be accepted as the root. The root must not be null.
|
| whatToShow | This flag specifies which node types may appear in the logical view of the tree presented by the Iterator. See the description of TreeWalker for the set of possible values. These flags can be combined using OR. |
| filter | The Filter to be used with this TreeWalker, or null to indicate no filter. |
| entityReferenceExpansion | The value of this flag determines whether entity reference nodes are expanded. |
Returns: The newly created TreeWalker .
Throws: DOMException, Raises, the, exception, NOT_SUPPORTED_ERR, if, the, specified, root, node, is, null.
| HTMLDocument (class) | HTMLDocument |
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:
| Node (class) | Node |
The Node interface is the primary datatype for the
entire Document Object Model. It represents a single node in the
document tree. While all objects implementing the Node
interface expose methods for dealing with children, not all
objects implementing the Node interface may have
children. For example, Text nodes may not have
children, and adding children to such nodes results in a
DOMException being raised.
The attributes nodeName , nodeValue
and attributes are included as a mechanism to get at
node information without casting down to the specific derived
interface. In cases where there is no obvious mapping of these
attributes for a specific nodeType (e.g.,
nodeValue for an Element or attributes for a
Comment), this returns null . Note that the
specialized interfaces may contain additional and more convenient
mechanisms to get and set the relevant information.
| EventListener (class) | EventListener |
Introduced in DOM Level 2
The EventListener interface is the primary method for handling events. Users implement the EventListener interface and register their listener on an EventTarget using the AddEventListener method. The users should also remove their EventListener from its EventTarget after they have completed using the listener.
When a Node is copied using the cloneNode method the EventListeners attached to the source Node are not attached to the copied Node. If the user wishes the same EventListeners to be added to the newly created copy the user must add them manually.
| Range (class) | Range |
| CSS2Azimuth (class) | CSS2Azimuth |
The CSS2Azimuth interface represents the
azimuth CSS Level 2 property.
| CSS2BackgroundPosition (class) | CSS2BackgroundPosition |
The CSS2BackgroundPosition interface represents the
background-position CSS Level 2 property.
| CSS2BorderSpacing (class) | CSS2BorderSpacing |
The CSS2BorderSpacing interface represents the
border-spacing CSS Level 2 property.
| CSS2CounterIncrement (class) | CSS2CounterIncrement |
The CSS2CounterIncrement interface represents a
imple value for the
counter-increment CSS Level 2 property.
| CSS2CounterReset (class) | CSS2CounterReset |
The CSS2CounterReset interface represents a simple
value for the
counter-reset CSS Level 2 property.
| CSSValueList (class) | CSSValueList |
The CSSValueList interface provides the absraction
of an ordered collection of CSS values.
| CSS2Cursor (class) | CSS2Cursor |
The CSS2Cursor interface represents the cursor
CSS Level 2 property.
| CSS2FontFaceSrc (class) | CSS2FontFaceSrc |
The CSS2Cursor interface represents the src
CSS Level 2 descriptor.
| CSS2FontFaceWidths (class) | CSS2FontFaceWidths |
The CSS2Cursor interface represents a simple value
for the
widths CSS Level 2 descriptor.
| CSS2PageSize (class) | CSS2PageSize |
The CSS2Cursor interface represents the size
CSS Level 2 descriptor.
| CSS2PlayDuring (class) | CSS2PlayDuring |
The CSS2PlayDuring interface represents the
play-during CSS Level 2 property.
| CSS2Properties (class) | CSS2Properties |
The CSS2Properties interface represents a
convenience mechanism for retrieving and setting properties within
a CSSStyleDeclaration . The attributes of this
interface correspond to all the properties
specified in CSS2 . Getting an attribute of this interface is
equivalent to calling the getPropertyValue method of
the CSSStyleDeclaration interface. Setting an
attribute of this interface is equivalent to calling the
setProperty method of the CSSStyleDeclaration
interface.
A compliant implementation is not required to implement the
CSS2Properties interface. If an implementation does
implement this interface, the expectation is that language-specific
methods can be used to cast from an instance of the
CSSStyleDeclaration interface to the CSS2Properties
interface.
If an implementation does implement this interface, it is expected
to understand the specific syntax of the shorthand properties, and
apply their semantics; when the margin property is
set, for example, the marginTop , marginRight
, marginBottom and marginLeft
properties are actually being set by the underlying implementation.
When dealing with CSS "shorthand" properties, the shorthand properties should be decomposed into their component longhand properties as appropriate, and when querying for their value, the form returned should be the shortest form exactly equivalent to the declarations made in the ruleset. However, if there is no shorthand declaration that could be added to the ruleset without changing in any way the rules already declared in the ruleset (i.e., by adding longhand rules that were previously not declared in the ruleset), then the empty string should be returned for the shorthand property.
For example, querying for the font property should
not return "normal normal normal 14pt/normal Arial, sans-serif",
when "14pt Arial, sans-serif" suffices (the normals are initial
values, and are implied by use of the longhand property).
If the values for all the longhand properties that compose a
particular string are the initial values, then a string consisting
of all the initial values should be returned (e.g. a
border-width value of "medium" should be returned as such,
not as "").
For some shorthand properties that take missing values from other
sides, such as the margin , padding ,
and border-[width|style|color] properties, the
minimum number of sides possible should be used, i.e., "0px 10px"
will be returned instead of "0px 10px 0px 10px".
If the value of a shorthand property can not be decomposed into
its component longhand properties, as is the case for the
font property with a value of "menu", querying for the
values of the component longhand properties should return the empty
string.
| CSSValue (class) | CSSValue |
The CSSValue interface represents a simple or a
complexe value.
| CSS2TextShadow (class) | CSS2TextShadow |
The CSS2TextShadow interface represents a simple
value for the
text-shadow CSS Level 2 property.
| CSSRule (class) | CSSRule |
The CSSRule interface is the abstract base interface
for any type of CSS statement
. This includes both rule sets
and
at-rules . An implementation is expected to preserve all rules
specified in a CSS style sheet, even if it is not recognized.
Unrecognized rules are represented using the CSSUnknownRule
interface.
| CSSCharsetRule (class) | CSSCharsetRule |
The CSSCharsetRule interface a @charset
rule in a CSS style sheet. A @charset rule can
be used to define the encoding of the style sheet.
| CSSFontFaceRule (class) | CSSFontFaceRule |
The CSSFontFaceRule interface represents a
@font-face rule in a CSS style sheet. The @font-face
rule is used to hold a set of font descriptions.
| CSSImportRule (class) | CSSImportRule |
The CSSImportRule interface represents a
@import rule within a CSS style sheet. The @import
rule is used to import style rules from other style sheets.
| CSSMediaRule (class) | CSSMediaRule |
The CSSMediaRule interface represents a
@media rule in a CSS style sheet. A @media rule
can be used to delimit style rules for specific media types.
| CSSPageRule (class) | CSSPageRule |
The CSSPageRule interface represents a @page rule
within a CSS style sheet. The @page rule is
used to specify the dimensions, orientation, margins, etc. of a
page box for paged media.
| CSSStyleRule (class) | CSSStyleRule |
The CSSStyleRule interface represents a single rule set
in a CSS style sheet.
| CSSUnknownRule (class) | CSSUnknownRule |
The CSSUnkownRule interface represents an at-rule
not supported by this user agent.
| CSSRuleList (class) | CSSRuleList |
The CSSRuleList interface provides the abstraction
of an ordered collection of CSS rules.
| MediaList (class) | MediaList |
The MediaList interface provides the abstraction of
an ordered collection of media, without defining or constraining
how this collection is implemented. All media are lowercase
strings.
| StyleSheet (class) | StyleSheet |
The StyleSheet interface is the abstract base
interface for any type of style sheet. It represents a single style
sheet associated with a structured document. In HTML, the
StyleSheet interface represents either an external style sheet,
included via the HTML
LINK element, or an inline
STYLE element. In XML, this interface represents an external
style sheet, included via a style sheet processing
instruction .
| CSSException (class) | CSSException |
This exception is raised when a specific CSS operation is impossible to perform.
| CSSStyleSheet (class) | CSSStyleSheet |
The CSSStyleSheet interface is a concrete interface
used to represent a CSS style sheet i.e. a style sheet whose
content type is "text/css".
| StyleSheetList (class) | StyleSheetList |
The StyleSheetList interface provides the
abstraction of an ordered collection of style sheets.
| LinkStyle (class) | LinkStyle |
| DocumentStyle (class) | DocumentStyle |
| CSSStyleDeclaration (class) | CSSStyleDeclaration |
The CSSStyleDeclaration interface represents a
single
CSS declaration block . This interface may be used to
determine the style properties currently set in a block or to set
style properties explicitly within the block.
While an implementation may not recognize all CSS properties
within a CSS declaration block, it is expected to provide access to
all specified properties through the CSSStyleDeclaration
interface. Furthermore, implementations that support a
specific level of CSS should correctly handle CSS
shorthand properties for that level. For a further discussion
of shorthand properties, see the CSS2Properties
interface.
| Counter (class) | Counter |
The Counter interface is used to represent any
counter or counters function value. This interface reflects
the values in the underlying style property. Hence, modifications
made through this interface modify the style property.
| RGBColor (class) | RGBColor |
The RGBColor interface is used to represent any
RGB color value. This interface reflects the values in the
underlying style property. Hence, modifications made through this
interface modify the style property.
| Rect (class) | Rect |
The Rect interface is used to represent any
rect value. This interface reflects the values in the
underlying style property. Hence, modifications made through this
interface modify the style property.
| CSSPrimitiveValue (class) | CSSPrimitiveValue |
The CSSPrimitiveValue interface represents a single
CSS
value . This interface may be used to determine the value of a
specific style property currently set in a block or to set a
specific style properties explicitly within the block. An instance
of this interface can be obtained from the
getPropertyCSSValue method of the
CSSStyleDeclaration interface.
| Event (class) | Event |
Introduced in DOM Level 2
The Event interface is used to provide contextual information about an event to the handler processing the event. An object which implements the Event interface is generally passed as the first parameter to an event handler. More specific context information is passed to event handlers by deriving additional interfaces from Event which contain information directly relating to the type of event they accompany. These derived interfaces are also implemented by the object passed to the event listener.
| EventException (class) | EventException |
Introduced in DOM Level 2:
Event operations may throw an EventException as specified in their method descriptions.
| UIEvent (class) | UIEvent |
Introduced in DOM Level 2
The UIEvent interface provides specific contextual information associated with User Interface events.
| MouseEvent (class) | MouseEvent |
Introduced in DOM Level 2
The MouseEvent interface provides specific contextual information associated with Mouse events.
The detail attribute inherited from UIEvent indicates the number of times a mouse button has been pressed and released over the same screen location during a user action. The attribute value is 1 when the user begins this action and increments by 1 for each full sequence of pressing and releasing. If the user moves the mouse between the mousedown and mouseup the value will be set to 0, indicating that no click is occurring.
In the case of nested elements mouse events are always targeted at the most deeply nested element. Ancestors of the targeted element may use bubbling to obtain notification of mouse events which occur within its descendent elements.
| MutationEvent (class) | MutationEvent |
Introduced in DOM Level 2
The MutationEvent interface provides specific contextual information associated with Mutation events.
| AbstractView (class) | AbstractView |
Introduced in DOM Level 2
A base interface that all views shall derive from.
| DocumentFragment (class) | DocumentFragment |
DocumentFragment is a "lightweight" or "minimal"
Document object. It is very common to want to be
able to extract a portion of a document's tree or to create a new
fragment of a document. Imagine implementing a user command like
cut or rearranging a document by moving fragments around. It is
desirable to have an object which can hold such fragments and it is
quite natural to use a Node for this purpose. While it is true that
a Document object could 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() .
| DOMString (class) | DOMString |
This class implements the basic string we use in the DOM. We do not use QString for 2 reasons: Memory overhead, and the missing explicit sharing of strings we need for the DOM.
All DOMStrings are explicitly shared (they behave like pointers), meaning that modifications to one instance will also modify all others. If you wish to get a DOMString that is independent, use copy().
| DOMException (class) | DOMException |
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.
| RangeException (class) | RangeException |
| NodeFilter (class) | NodeFilter |
Filters are objects that know how to "filter out" nodes. If an
Iterator or TreeWalker is given a filter, before it
returns the next node, it applies the filter. If the filter says to
accept the node, the Iterator returns it; otherwise, the Iterator
looks for the next node and pretends that the node that was
rejected was not there.
The DOM does not provide any filters. Filter is just an interface that users can implement to provide their own filters.
Filters do not need to know how to iterate, nor do they need to know anything about the data structure that is being iterated. This makes it very easy to write filters, since the only thing they have to know how to do is evaluate a single node. One filter may be used with a number of different kinds of Iterators, encouraging code reuse.
To create your own cutsom NodeFilter, define a subclass of CustomNodeFilter which overrides the acceptNode() method and assign an instance of it to the NodeFilter. For more details see the CustomNodeFilter class
| CustomNodeFilter (class) | CustomNodeFilter |
CustomNodeFilter can be used to define your own NodeFilter for use with NodeIterators and TreeWalkers. You can create a custom filter by doing the follwing:
class MyCustomNodeFilter { ..... virtual short acceptNode (const Node &n); ..... }
Then in your program:
short MyCustomNodeFilter::acceptNode (const Node &n) { if (condition) return NodeFilter::FILTER_ACCEPT; else .... }
MyCustomFilter *filter = new MyCustomFilter(); NodeFilter nf = NodeFilter::createCutsom(filter); NodeIterator ni = document.createNodeIterator(document,NodeFilter.SHOW_ALL,nf,false);
The default implementation of acceptNode() returns NodeFilter::FILTER_ACCEPT for all nodes.
| NodeIterator (class) | NodeIterator |
NodeIterators are used to step through a set of nodes, e.g. the set of nodes in a NodeList, the document subtree governed by a particular node, the results of a query, or any other set of nodes. The set of nodes to be iterated is determined by the implementation of the NodeIterator. DOM Level 2 specifies a single NodeIterator implementation for document-order traversal of a document subtree. Instances of these iterators are created by calling DocumentTraversal.createNodeIterator().
Any Iterator that returns nodes may implement the
NodeIterator interface. Users and vendor libraries may also
choose to create Iterators that implement the NodeIterator
interface.
| TreeWalker (class) | TreeWalker |
TreeWalker objects are used to navigate a document
tree or subtree using the view of the document defined by its
whatToShow flags and any filters that are defined
for the TreeWalker . Any function which performs
navigation using a TreeWalker will automatically
support any view defined by a TreeWalker .
Omitting nodes from the logical view of a subtree can result in a structure that is substantially different from the same subtree in the complete, unfiltered document. Nodes that are siblings in the TreeWalker view may be children of different, widely separated nodes in the original view. For instance, consider a Filter that skips all nodes except for Text nodes and the root node of a document. In the logical view that results, all text nodes will be siblings and appear as direct children of the root node, no matter how deeply nested the structure of the original document.
| Document (class) | Document |
The Document interface represents the entire HTML or
XML document. Conceptually, it is the root of the document tree,
and provides the primary access to the document's data.
Since elements, text nodes, comments, processing instructions,
etc. cannot exist outside the context of a Document
, the Document interface also contains the factory
methods needed to create these objects. The Node
objects created have a ownerDocument attribute which
associates them with the Document within whose
context they were created.
| Element (class) | Element |
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.
| DocumentType (class) | DocumentType |
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.
| NodeList (class) | NodeList |
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.
| CDATASection (class) | CDATASection |
CDATA sections are used to escape blocks of text containing characters that would otherwise be regarded as markup. The only delimiter that is recognized in a CDATA section is the "]]>" string that ends the CDATA section. CDATA sections 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.
| Comment (class) | Comment |
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.
| Text (class) | Text |
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.
| DOMImplementation (class) | DOMImplementation |
The DOMImplementation interface provides a number of
methods for performing operations that are independent of any
particular instance of the document object model.
DOM Level 2 and newer provide means for creating documents directly, which was not possible with DOM Level 1.
| Attr (class) | Attr |
The Attr interface represents an attribute in an
Element object. Typically the allowable values for
the attribute are defined in a document type definition.
Attr objects inherit the Node
interface, but since they are not actually child nodes of the
element they describe, the DOM does not consider them part of the
document tree. Thus, the Node attributes
parentNode , previousSibling , and
nextSibling have a null value for Attr
objects. The DOM takes the view that attributes are properties of
elements rather than having a separate identity from the elements
they are associated with; this should make it more efficient to
implement such features as default attributes associated with all
elements of a given type. Furthermore, Attr nodes
may not be immediate children of a DocumentFragment
. However, they can be associated with Element nodes
contained within a DocumentFragment . In short,
users and implementors of the DOM need to be aware that Attr
nodes have some things in common with other objects
inheriting the Node interface, but they also are
quite distinct.
The attribute's effective value is determined as follows: if this
attribute has been explicitly assigned any value, that value is the
attribute's effective value; otherwise, if there is a declaration
for this attribute, and that declaration includes a default value,
then that default value is the attribute's effective value;
otherwise, the attribute does not exist on this element in the
structure model until it has been explicitly added. Note that the
nodeValue attribute on the Attr
instance can also be used to retrieve the string version of the
attribute's value(s).
In XML, where the value of an attribute can contain entity
references, the child nodes of the Attr node provide
a representation in which entity references are not expanded. These
child nodes may be either Text or
EntityReference nodes. Because the attribute type may be
unknown, there are no tokenized attribute values.
| EntityReference (class) | EntityReference |
EntityReference objects may be inserted into the
structure model when an entity reference is in the source document,
or when the user wishes to insert an entity reference. Note that
character references and references to predefined entities are
considered to be expanded by the HTML or XML processor so that
characters are represented by their Unicode equivalent rather than
by an entity reference. Moreover, the XML processor may completely
expand references to entities while building the structure model,
instead of providing EntityReference objects. If it
does provide such objects, then for a given EntityReference
node, it may be that there is no Entity node
representing the referenced entity; 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.
| ProcessingInstruction (class) | ProcessingInstruction |
The ProcessingInstruction interface represents a
"processing instruction", used in XML as a way to keep
processor-specific information in the text of the document.
| HTMLFrameElement (class) | HTMLFrameElement |
Create a frame. See the FRAME element definition in HTML 4.0.
| HTMLIFrameElement (class) | HTMLIFrameElement |
Inline subwindows. See the IFRAME element definition in HTML 4.0.
| HTMLObjectElement (class) | HTMLObjectElement |
Generic embedded object. Note. In principle, all properties on the object element are read-write but in some environments some properties may be read-only once the underlying object is instantiated. See the OBJECT element definition in HTML 4.0.
| NamedNodeMap (class) | NamedNodeMap |
Objects implementing the NamedNodeMap interface are
used to represent collections of nodes that can be accessed by
name. Note that NamedNodeMap does not inherit from
NodeList ; 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.
| DomShared (class) | DomShared |
| typedef unsigned long long DOMTimeStamp | DOMTimeStamp |
A DOMTimeStamp represents a number of milliseconds.
| bool operator== ( const DOMString &a, const DOMString &b )
| operator== |
| bool operator== ( const DOMString &a, const QString &b )
| operator== |
| bool operator== ( const DOMString &a, const char *b )
| operator== |
| inline bool operator!= ( const DOMString &a, const DOMString &b )
| operator!= |
| inline bool operator!= ( const DOMString &a, const QString &b )
| operator!= |
| inline bool operator!= ( const DOMString &a, const char *b )
| operator!= |
| inline bool strcmp ( const DOMString &a, const DOMString &b )
| strcmp |
| bool strcasecmp ( const DOMString &a, const DOMString &b )
| strcasecmp |
| bool strcasecmp ( const DOMString& a, const char* b )
| strcasecmp |
| CharacterData (class) | CharacterData |
The CharacterData interface extends Node with a set
of attributes and methods for accessing character data in the DOM.
For clarity this set is defined here rather than on each object
that uses these attributes and methods. No DOM objects correspond
directly to CharacterData , though Text
and others do inherit the interface from it. All
offsets in this interface start from 0.
| Entity (class) | Entity |
This interface represents an entity, either parsed or unparsed, in
an XML document. Note that this models the entity itself not the
entity declaration. Entity declaration modeling has
been left for a later Level of the DOM specification.
The nodeName attribute that is inherited from
Node contains the name of the entity.
An XML processor may choose to completely expand entities before
the structure model is passed to the DOM; in this case there will
be no EntityReference nodes in the document tree.
XML does not mandate that a non-validating XML processor read and
process entity declarations made in the external subset or declared
in external parameter entities. This means that parsed entities
declared in the external subset need not be expanded by some
classes of applications, and that the replacement value of the
entity may not be available. When the replacement value is
available, the corresponding Entity node's child
list represents the structure of that replacement text. Otherwise,
the child list is empty.
The 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.
| Notation (class) | Notation |
This interface represents a notation declared in the DTD. A
notation either declares, by name, the format of an unparsed entity
(see section 4.7 of the XML 1.0 specification), or is used for
formal declaration of Processing Instruction targets (see section
2.6 of the XML 1.0 specification). The nodeName
attribute inherited from Node is set to the declared
name of the notation.
The DOM Level 1 does not support editing Notation
nodes; they are therefore readonly.
A Notation node does not have any parent.
| HTMLBodyElement (class) | HTMLBodyElement |
The HTML document body. This element is always present in the DOM API, even if the tags are not present in the source document. See the BODY element definition in HTML 4.0.
| HTMLFrameSetElement (class) | HTMLFrameSetElement |
Create a grid of frames. See the FRAMESET element definition in HTML 4.0.
| HTMLHeadElement (class) | HTMLHeadElement |
Document head information. See the HEAD element definition in HTML 4.0.
| HTMLHtmlElement (class) | HTMLHtmlElement |
Root of an HTML document. See the HTML element definition in HTML 4.0.
| HTMLBlockquoteElement (class) | HTMLBlockquoteElement |
??? See the BLOCKQUOTE element definition in HTML 4.0.
| HTMLDivElement (class) | HTMLDivElement |
Generic block container. See the DIV element definition in HTML 4.0.
| HTMLHRElement (class) | HTMLHRElement |
Create a horizontal rule. See the HR element definition in HTML 4.0.
| HTMLHeadingElement (class) | HTMLHeadingElement |
For the H1 to H6 elements. See the
H1 element definition in HTML 4.0.
| HTMLParagraphElement (class) | HTMLParagraphElement |
Paragraphs. See the P element definition in HTML 4.0.
| HTMLPreElement (class) | HTMLPreElement |
Preformatted text. See the PRE element definition in HTML 4.0.
| HTMLCollection (class) | HTMLCollection |
An HTMLCollection is a list of nodes. An individual
node may be accessed by either ordinal index or the node's
name or id attributes. Note: Collections in
the HTML DOM are assumed to be live meaning that they are
automatically updated when the underlying document is changed.
| HTMLElement (class) | HTMLElement |
All HTML element interfaces derive from this class. Elements that
only expose the HTML core attributes are represented by the base
HTMLElement interface. These elements are as
follows:
Note. The style attribute for this
interface is reserved for future usage.
| HTMLFormElement (class) | HTMLFormElement |
The FORM element encompasses behavior similar to a
collection and an element. It provides direct access to the
contained input elements as well as the attributes of the form
element. See the
FORM element definition in HTML 4.0.
| HTMLButtonElement (class) | HTMLButtonElement |
Push button. See the BUTTON element definition in HTML 4.0.
| HTMLFieldSetElement (class) | HTMLFieldSetElement |
Organizes form controls into logical groups. See the FIELDSET element definition in HTML 4.0.
| HTMLInputElement (class) | HTMLInputElement |
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.
| HTMLLabelElement (class) | HTMLLabelElement |
Form field label text. See the LABEL element definition in HTML 4.0.
| HTMLLegendElement (class) | HTMLLegendElement |
Provides a caption for a FIELDSET grouping. See the
LEGEND element definition in HTML 4.0.
| HTMLOptGroupElement (class) | HTMLOptGroupElement |
Group options together in logical subdivisions. See the OPTGROUP element definition in HTML 4.0.
| HTMLSelectElement (class) | HTMLSelectElement |
The select element allows the selection of an option. The contained options can be directly accessed through the select element as a collection. See the SELECT element definition in HTML 4.0.
| HTMLTextAreaElement (class) | HTMLTextAreaElement |
Multi-line text field. See the TEXTAREA element definition in HTML 4.0.
| HTMLOptionElement (class) | HTMLOptionElement |
A selectable choice. See the OPTION element definition in HTML 4.0.
| HTMLIsIndexElement (class) | HTMLIsIndexElement |
This element is used for single-line text input. See the ISINDEX element definition in HTML 4.0. This element is deprecated in HTML 4.0.
| HTMLBaseElement (class) | HTMLBaseElement |
Document base URI. See the BASE element definition in HTML 4.0.
| HTMLLinkElement (class) | HTMLLinkElement |
The LINK element specifies a link to an external
resource, and defines this document's relationship to that resource
(or vice versa). See the
LINK element definition in HTML 4.0.
| HTMLMetaElement (class) | HTMLMetaElement |
This contains generic meta-information about the document. See the META element definition in HTML 4.0.
| HTMLScriptElement (class) | HTMLScriptElement |
Script statements. See the SCRIPT element definition in HTML 4.0.
| HTMLStyleElement (class) | HTMLStyleElement |
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.
| HTMLTitleElement (class) | HTMLTitleElement |
The document title. See the TITLE element definition in HTML 4.0.
| HTMLAreaElement (class) | HTMLAreaElement |
Client-side image map area definition. See the AREA element definition in HTML 4.0.
| HTMLImageElement (class) | HTMLImageElement |
Embedded image. See the IMG element definition in HTML 4.0.
| HTMLMapElement (class) | HTMLMapElement |
Client-side image map. See the MAP element definition in HTML 4.0.
| HTMLAnchorElement (class) | HTMLAnchorElement |
The anchor element. See the A element definition in HTML 4.0.
| HTMLBRElement (class) | HTMLBRElement |
Force a line break. See the BR element definition in HTML 4.0.
| HTMLFontElement (class) | HTMLFontElement |
Local change to font. See the FONT element definition in HTML 4.0. This element is deprecated in HTML 4.0.
| HTMLModElement (class) | HTMLModElement |
Notice of modification to part of a document. See the INS and DEL element definitions in HTML 4.0.
| HTMLQuoteElement (class) | HTMLQuoteElement |
For the Q and BLOCKQUOTE elements.
See the Q
element definition in HTML 4.0.
Note: The DOM is not quite consistent here. They also define the
HTMLBlockQuoteElement interface, to represent the BLOCKQUOTE
element. To resolve ambiquities, we use this one for the Q
element only.
| HTMLDListElement (class) | HTMLDListElement |
Definition list. See the DL element definition in HTML 4.0.
| HTMLDirectoryElement (class) | HTMLDirectoryElement |
Directory list. See the DIR element definition in HTML 4.0. This element is deprecated in HTML 4.0.
| HTMLLIElement (class) | HTMLLIElement |
List item. See the LI element definition in HTML 4.0.
| HTMLMenuElement (class) | HTMLMenuElement |
Menu list. See the MENU element definition in HTML 4.0. This element is deprecated in HTML 4.0.
| HTMLOListElement (class) | HTMLOListElement |
Ordered list. See the OL element definition in HTML 4.0.
| HTMLUListElement (class) | HTMLUListElement |
Unordered list. See the UL element definition in HTML 4.0.
| HTMLBaseFontElement (class) | HTMLBaseFontElement |
Base font. See the BASEFONT element definition in HTML 4.0. This element is deprecated in HTML 4.0.
| HTMLFormCollection (class) | HTMLFormCollection |
| HTMLAppletElement (class) | HTMLAppletElement |
An embedded Java applet. See the APPLET element definition in HTML 4.0. This element is deprecated in HTML 4.0.
| HTMLParamElement (class) | HTMLParamElement |
Parameters fed to the OBJECT element. See the
PARAM element definition in HTML 4.0.
| HTMLTableCaptionElement (class) | HTMLTableCaptionElement |
Table caption See the CAPTION element definition in HTML 4.0.
| HTMLTableCellElement (class) | HTMLTableCellElement |
The object used to represent the TH and TD
elements. See the
TD element definition in HTML 4.0.
| HTMLTableColElement (class) | HTMLTableColElement |
Regroups the COL and COLGROUP
elements. See the
COL element definition in HTML 4.0.
| HTMLTableSectionElement (class) | HTMLTableSectionElement |
The THEAD , TFOOT , and TBODY
elements.
| HTMLTableElement (class) | HTMLTableElement |
The create* and delete* methods on the table allow authors to
construct and modify tables. HTML 4.0 specifies that only one of
each of the CAPTION , THEAD , and
TFOOT elements may exist in a table. Therefore, if
one exists, and the createTHead() or createTFoot() method is
called, the method returns the existing THead or TFoot element. See
the
TABLE element definition in HTML 4.0.
| HTMLTableRowElement (class) | HTMLTableRowElement |
A row in a table. See the TR element definition in HTML 4.0.
| Generated by: dfaure on faure on Tue Apr 16 08:50:42 2002, using kdoc 2.0a53. |