|
|
|
|
/*
|
|
|
|
|
* This file is part of the DOM implementation for KDE.
|
|
|
|
|
*
|
|
|
|
|
* (C) 1999 Lars Knoll (knoll@kde.org)
|
|
|
|
|
*
|
|
|
|
|
* This library is free software; you can redistribute it and/or
|
|
|
|
|
* modify it under the terms of the GNU Library General Public
|
|
|
|
|
* License as published by the Free Software Foundation; either
|
|
|
|
|
* version 2 of the License, or (at your option) any later version.
|
|
|
|
|
*
|
|
|
|
|
* This library is distributed in the hope that it will be useful,
|
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
|
|
* Library General Public License for more details.
|
|
|
|
|
*
|
|
|
|
|
* You should have received a copy of the GNU Library General Public License
|
|
|
|
|
* along with this library; see the file COPYING.LIB. If not, write to
|
|
|
|
|
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
|
|
|
|
* Boston, MA 02110-1301, USA.
|
|
|
|
|
*
|
|
|
|
|
* This file includes excerpts from the Document Object Model (DOM)
|
|
|
|
|
* Level 1 Specification (Recommendation)
|
|
|
|
|
* http://www.w3.org/TR/REC-DOM-Level-1/
|
|
|
|
|
* Copyright <EFBFBD> World Wide Web Consortium , (Massachusetts Institute of
|
|
|
|
|
* Technology , Institut National de Recherche en Informatique et en
|
|
|
|
|
* Automatique , Keio University ). All Rights Reserved.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#ifndef _DOM_Document_h_
|
|
|
|
|
#define _DOM_Document_h_
|
|
|
|
|
|
|
|
|
|
#include <dom/dom_node.h>
|
|
|
|
|
#include <dom/css_stylesheet.h>
|
|
|
|
|
|
|
|
|
|
class TDEHTMLView;
|
|
|
|
|
class TDEHTMLPart;
|
|
|
|
|
|
|
|
|
|
namespace DOM {
|
|
|
|
|
|
|
|
|
|
class DOMString;
|
|
|
|
|
class DocumentType;
|
|
|
|
|
class NodeList;
|
|
|
|
|
class CDATASection;
|
|
|
|
|
class Comment;
|
|
|
|
|
class DocumentFragment;
|
|
|
|
|
class Text;
|
|
|
|
|
class DOMImplementation;
|
|
|
|
|
class Element;
|
|
|
|
|
class Attr;
|
|
|
|
|
class EntityReference;
|
|
|
|
|
class ProcessingInstruction;
|
|
|
|
|
class DocumentImpl;
|
|
|
|
|
class Range;
|
|
|
|
|
class NodeIterator;
|
|
|
|
|
class TreeWalker;
|
|
|
|
|
class NodeFilter;
|
|
|
|
|
class DOMImplementationImpl;
|
|
|
|
|
class DocumentTypeImpl;
|
|
|
|
|
class Event;
|
|
|
|
|
class AbstractView;
|
|
|
|
|
class CSSStyleDeclaration;
|
|
|
|
|
class HTMLElementImpl;
|
|
|
|
|
class HTMLFrameElement;
|
|
|
|
|
class HTMLElementImpl;
|
|
|
|
|
class HTMLIFrameElement;
|
|
|
|
|
class HTMLObjectElement;
|
|
|
|
|
class HTMLDocument;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* The \c 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.
|
|
|
|
|
*/
|
|
|
|
|
class TDEHTML_EXPORT DOMImplementation
|
|
|
|
|
{
|
|
|
|
|
friend class Document;
|
|
|
|
|
public:
|
|
|
|
|
DOMImplementation();
|
|
|
|
|
DOMImplementation(const DOMImplementation &other);
|
|
|
|
|
|
|
|
|
|
DOMImplementation & operator = (const DOMImplementation &other);
|
|
|
|
|
~DOMImplementation();
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Test if the DOM implementation implements a specific feature.
|
|
|
|
|
*
|
|
|
|
|
* @param feature The package name of the feature to test. In
|
|
|
|
|
* Level 1, the legal values are "HTML" and "XML"
|
|
|
|
|
* (case-insensitive).
|
|
|
|
|
*
|
|
|
|
|
* @param 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 \c true .
|
|
|
|
|
*
|
|
|
|
|
* @return \c true if the feature is implemented in
|
|
|
|
|
* the specified version, \c false otherwise.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
bool hasFeature ( const DOMString &feature, const DOMString &version );
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Introduced in DOM Level 2
|
|
|
|
|
*
|
|
|
|
|
* Creates an empty DocumentType node. Entity declarations and notations
|
|
|
|
|
* are not made available. Entity reference expansions and default
|
|
|
|
|
* attribute additions do not occur. It is expected that a future version
|
|
|
|
|
* of the DOM will provide a way for populating a DocumentType.
|
|
|
|
|
*
|
|
|
|
|
* HTML-only DOM implementations do not need to implement this method.
|
|
|
|
|
*
|
|
|
|
|
* @param qualifiedName The qualified name of the document type to be
|
|
|
|
|
* created.
|
|
|
|
|
*
|
|
|
|
|
* @param publicId The external subset public identifier.
|
|
|
|
|
*
|
|
|
|
|
* @param systemId The external subset system identifier.
|
|
|
|
|
*
|
|
|
|
|
* @return A new DocumentType node with Node.ownerDocument set to null.
|
|
|
|
|
*
|
|
|
|
|
* @exception DOMException
|
|
|
|
|
* INVALID_CHARACTER_ERR: Raised if the specified qualified name contains
|
|
|
|
|
* an illegal character.
|
|
|
|
|
*
|
|
|
|
|
* NAMESPACE_ERR: Raised if the qualifiedName is malformed.
|
|
|
|
|
*/
|
|
|
|
|
DocumentType createDocumentType ( const DOMString &qualifiedName,
|
|
|
|
|
const DOMString &publicId,
|
|
|
|
|
const DOMString &systemId );
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Introduced in DOM Level 2
|
|
|
|
|
*
|
|
|
|
|
* Creates an XML Document object of the specified type with its document
|
|
|
|
|
* element. HTML-only DOM implementations do not need to implement this
|
|
|
|
|
* method.
|
|
|
|
|
*
|
|
|
|
|
* @param namespaceURI The namespace URI of the document element to create.
|
|
|
|
|
*
|
|
|
|
|
* @param qualifiedName The qualified name of the document element to be
|
|
|
|
|
* created.
|
|
|
|
|
*
|
|
|
|
|
* @param doctype The type of document to be created or null. When doctype
|
|
|
|
|
* is not null, its Node.ownerDocument attribute is set to the document
|
|
|
|
|
* being created.
|
|
|
|
|
*
|
|
|
|
|
* @return A new Document object.
|
|
|
|
|
*
|
|
|
|
|
* @exception DOMException
|
|
|
|
|
* INVALID_CHARACTER_ERR: Raised if the specified qualified name contains
|
|
|
|
|
* an illegal character.
|
|
|
|
|
*
|
|
|
|
|
* NAMESPACE_ERR: Raised if the qualifiedName is malformed, if the
|
|
|
|
|
* qualifiedName has a prefix and the namespaceURI is null, or if the
|
|
|
|
|
* qualifiedName has a prefix that is "xml" and the namespaceURI is
|
|
|
|
|
* different from "http://www.w3.org/XML/1998/namespace" [Namespaces].
|
|
|
|
|
*
|
|
|
|
|
* WRONG_DOCUMENT_ERR: Raised if doctype has already been used with a
|
|
|
|
|
* different document or was created from a different implementation.
|
|
|
|
|
*/
|
|
|
|
|
Document createDocument ( const DOMString &namespaceURI,
|
|
|
|
|
const DOMString &qualifiedName,
|
|
|
|
|
const DocumentType &doctype );
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Introduced in DOM Level 3
|
|
|
|
|
* This method makes available a DOMImplementation's specialized
|
|
|
|
|
* interface.
|
|
|
|
|
*
|
|
|
|
|
* @param feature The name of the feature requested (case-insensitive)
|
|
|
|
|
*
|
|
|
|
|
* @return Returns an alternate DOMImplementation which implements
|
|
|
|
|
* the specialized APIs of the specified feature, if any, or null
|
|
|
|
|
* if there is no alternate DOMImplementation object which implements
|
|
|
|
|
* interfaces associated with that feature. Any alternate DOMImplementation
|
|
|
|
|
* returned by this method must delegate to the primary core DOMImplementation
|
|
|
|
|
* and not return results inconsistent with the primary DOMImplementation.
|
|
|
|
|
*/
|
|
|
|
|
DOMImplementation getInterface(const DOMString &feature) const;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Introduced in DOM Level 2
|
|
|
|
|
* This method is from the DOMImplementationCSS interface
|
|
|
|
|
*
|
|
|
|
|
* Creates a new CSSStyleSheet.
|
|
|
|
|
*
|
|
|
|
|
* @param title The advisory title. See also the Style Sheet Interfaces
|
|
|
|
|
* section.
|
|
|
|
|
*
|
|
|
|
|
* @param media The comma-separated list of media associated with the
|
|
|
|
|
* new style sheet. See also the Style Sheet Interfaces section.
|
|
|
|
|
*
|
|
|
|
|
* @return A new CSS style sheet.
|
|
|
|
|
*
|
|
|
|
|
* @exception SYNTAX_ERR: Raised if the specified media string value has a syntax error and is unparsable.
|
|
|
|
|
*/
|
|
|
|
|
CSSStyleSheet createCSSStyleSheet(const DOMString &title, const DOMString &media);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Introduced in DOM Level 2
|
|
|
|
|
* This method is from the HTMLDOMImplementation interface
|
|
|
|
|
*
|
|
|
|
|
* Creates an HTMLDocument with the minimal tree made of these
|
|
|
|
|
* elements: HTML,HEAD,TITLE and BODY.
|
|
|
|
|
* It extends the core interface which can be used to create an
|
|
|
|
|
* XHTML document by passing the XHTML namespace as the namespace
|
|
|
|
|
* for the root element.
|
|
|
|
|
*
|
|
|
|
|
* @param title The title of the document to be set as the content
|
|
|
|
|
* of the TITLE element, through a child Text node.
|
|
|
|
|
*
|
|
|
|
|
* @return the HTMLdocument
|
|
|
|
|
*/
|
|
|
|
|
HTMLDocument createHTMLDocument(const DOMString& title);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* @internal
|
|
|
|
|
* not part of the DOM
|
|
|
|
|
*/
|
|
|
|
|
DOMImplementationImpl *handle() const;
|
|
|
|
|
bool isNull() const;
|
|
|
|
|
|
|
|
|
|
protected:
|
|
|
|
|
DOMImplementation(DOMImplementationImpl *i);
|
|
|
|
|
DOMImplementationImpl *impl;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* The \c 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 \c Document
|
|
|
|
|
* , the \c Document interface also contains the factory
|
|
|
|
|
* methods needed to create these objects. The \c Node
|
|
|
|
|
* objects created have a \c ownerDocument attribute which
|
|
|
|
|
* associates them with the \c Document within whose
|
|
|
|
|
* context they were created.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
class TDEHTML_EXPORT Document : public Node
|
|
|
|
|
{
|
|
|
|
|
friend class ::TDEHTMLView;
|
|
|
|
|
friend class ::TDEHTMLPart;
|
|
|
|
|
friend class AbstractView;
|
|
|
|
|
friend class DOMImplementation;
|
|
|
|
|
friend class HTMLFrameElement;
|
|
|
|
|
friend class HTMLIFrameElement;
|
|
|
|
|
friend class HTMLObjectElement;
|
|
|
|
|
|
|
|
|
|
public:
|
|
|
|
|
Document();
|
|
|
|
|
/**
|
|
|
|
|
* don't create an implementation if false
|
|
|
|
|
* use at own risk
|
|
|
|
|
*/
|
|
|
|
|
Document(bool);
|
|
|
|
|
Document(const Document &other);
|
|
|
|
|
Document(const Node &other) : Node()
|
|
|
|
|
{(*this)=other;}
|
|
|
|
|
|
|
|
|
|
Document & operator = (const Node &other);
|
|
|
|
|
Document & operator = (const Document &other);
|
|
|
|
|
|
|
|
|
|
~Document();
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* The Document Type Declaration (see \c DocumentType
|
|
|
|
|
* ) associated with this document. For HTML documents as well as
|
|
|
|
|
* XML documents without a document type declaration this returns
|
|
|
|
|
* \c null . The DOM Level 1 does not support editing
|
|
|
|
|
* the Document Type Declaration, therefore \c docType
|
|
|
|
|
* cannot be altered in any way.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
DocumentType doctype() const;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* The \c DOMImplementation object that handles this
|
|
|
|
|
* document. A DOM application may use objects from multiple
|
|
|
|
|
* implementations.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
DOMImplementation implementation() const;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* This is a convenience attribute that allows direct access to
|
|
|
|
|
* the child node that is the root element of the document. For
|
|
|
|
|
* HTML documents, this is the element with the tagName "HTML".
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
Element documentElement() const;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Creates an element of the type specified. Note that the
|
|
|
|
|
* instance returned implements the Element interface, so
|
|
|
|
|
* attributes can be specified directly on the returned object.
|
|
|
|
|
*
|
|
|
|
|
* @param tagName The name of the element type to instantiate. For
|
|
|
|
|
* XML, this is case-sensitive. For HTML, the \c tagName
|
|
|
|
|
* parameter may be provided in any case, but it must be
|
|
|
|
|
* mapped to the canonical uppercase form by the DOM
|
|
|
|
|
* implementation.
|
|
|
|
|
*
|
|
|
|
|
* @return A new \c Element object.
|
|
|
|
|
*
|
|
|
|
|
* @exception DOMException
|
|
|
|
|
* INVALID_CHARACTER_ERR: Raised if the specified name contains an
|
|
|
|
|
* invalid character.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
Element createElement ( const DOMString &tagName );
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Introduced in DOM Level 2
|
|
|
|
|
* Creates an element of the given qualified name and namespace URI.
|
|
|
|
|
*
|
|
|
|
|
* @param namespaceURI The namespace URI of the element to create.
|
|
|
|
|
*
|
|
|
|
|
* @param qualifiedName The qualified name of the element type to instantiate.
|
|
|
|
|
*
|
|
|
|
|
* @return A new Element object with the following attributes:
|
|
|
|
|
*
|
|
|
|
|
* @exception INVALID_CHARACTER_ERR Raised if the specified qualified name
|
|
|
|
|
* contains an illegal character.
|
|
|
|
|
*
|
|
|
|
|
* @exception NAMESPACE_ERR Raised if the qualifiedName is malformed, if
|
|
|
|
|
* the qualifiedName has a prefix and the namespaceURI is null, or if the
|
|
|
|
|
* qualifiedName has a prefix that is "xml" and the namespaceURI is
|
|
|
|
|
* different from "http://www.w3.org/XML/1998/namespace"
|
|
|
|
|
*/
|
|
|
|
|
Element createElementNS( const DOMString &namespaceURI,
|
|
|
|
|
const DOMString &qualifiedName );
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Creates an empty \c DocumentFragment object.
|
|
|
|
|
*
|
|
|
|
|
* @return A new \c DocumentFragment .
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
DocumentFragment createDocumentFragment ( );
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Creates a \c Text node given the specified string.
|
|
|
|
|
*
|
|
|
|
|
* @param data The data for the node.
|
|
|
|
|
*
|
|
|
|
|
* @return The new \c Text object.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
Text createTextNode ( const DOMString &data );
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Creates a \c Comment node given the specified
|
|
|
|
|
* string.
|
|
|
|
|
*
|
|
|
|
|
* @param data The data for the node.
|
|
|
|
|
*
|
|
|
|
|
* @return The new \c Comment object.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
Comment createComment ( const DOMString &data );
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Creates a \c CDATASection node whose value is the
|
|
|
|
|
* specified string.
|
|
|
|
|
*
|
|
|
|
|
* @param data The data for the \c CDATASection
|
|
|
|
|
* contents.
|
|
|
|
|
*
|
|
|
|
|
* @return The new \c CDATASection object.
|
|
|
|
|
*
|
|
|
|
|
* @exception DOMException
|
|
|
|
|
* NOT_SUPPORTED_ERR: Raised if this document is an HTML document.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
CDATASection createCDATASection ( const DOMString &data );
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Creates a \c ProcessingInstruction node given the
|
|
|
|
|
* specified name and data strings.
|
|
|
|
|
*
|
|
|
|
|
* @param target The target part of the processing instruction.
|
|
|
|
|
*
|
|
|
|
|
* @param data The data for the node.
|
|
|
|
|
*
|
|
|
|
|
* @return The new \c ProcessingInstruction object.
|
|
|
|
|
*
|
|
|
|
|
* @exception DOMException
|
|
|
|
|
* INVALID_CHARACTER_ERR: Raised if an invalid character is
|
|
|
|
|
* specified.
|
|
|
|
|
*
|
|
|
|
|
* NOT_SUPPORTED_ERR: Raised if this document is an HTML
|
|
|
|
|
* document.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
ProcessingInstruction createProcessingInstruction ( const DOMString &target,
|
|
|
|
|
const DOMString &data );
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Creates an \c Attr of the given name. Note that the
|
|
|
|
|
* \c Attr instance can then be set on an \c Element
|
|
|
|
|
* using the \c setAttribute method.
|
|
|
|
|
*
|
|
|
|
|
* @param name The name of the attribute.
|
|
|
|
|
*
|
|
|
|
|
* @return A new \c Attr object.
|
|
|
|
|
*
|
|
|
|
|
* @exception DOMException
|
|
|
|
|
* INVALID_CHARACTER_ERR: Raised if the specified name contains an
|
|
|
|
|
* invalid character.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
Attr createAttribute ( const DOMString &name );
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Introduced in DOM Level 2
|
|
|
|
|
* Creates an attribute of the given qualified name and namespace URI.
|
|
|
|
|
* HTML-only DOM implementations do not need to implement this method.
|
|
|
|
|
*
|
|
|
|
|
* @param namespaceURI The namespace URI of the attribute to create.
|
|
|
|
|
*
|
|
|
|
|
* @param qualifiedName The qualified name of the attribute to instantiate.
|
|
|
|
|
*
|
|
|
|
|
* @return A new Attr object with the following attributes:
|
|
|
|
|
* Node.nodeName - qualifiedName
|
|
|
|
|
* Node.namespaceURI - namespaceURI
|
|
|
|
|
* Node.prefix - prefix, extracted from qualifiedName, or null if there is
|
|
|
|
|
* no prefix
|
|
|
|
|
* Node.localName - local name, extracted from qualifiedName
|
|
|
|
|
* Attr.name - qualifiedName
|
|
|
|
|
* Node.nodeValue - the empty string
|
|
|
|
|
*
|
|
|
|
|
* @exception INVALID_CHARACTER_ERR Raised if the specified qualified name
|
|
|
|
|
* contains an illegal character.
|
|
|
|
|
*
|
|
|
|
|
* @exception NAMESPACE_ERR Raised if the qualifiedName is malformed, if
|
|
|
|
|
* the qualifiedName has a prefix and the namespaceURI is null, if the
|
|
|
|
|
* qualifiedName has a prefix that is "xml" and the namespaceURI is
|
|
|
|
|
* different from "http://www.w3.org/XML/1998/namespace", or if the
|
|
|
|
|
* qualifiedName is "xmlns" and the namespaceURI is different from
|
|
|
|
|
* "http://www.w3.org/2000/xmlns/".
|
|
|
|
|
*/
|
|
|
|
|
Attr createAttributeNS( const DOMString &namespaceURI,
|
|
|
|
|
const DOMString &qualifiedName );
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Creates an EntityReference object.
|
|
|
|
|
*
|
|
|
|
|
* @param name The name of the entity to reference.
|
|
|
|
|
*
|
|
|
|
|
* @return The new \c EntityReference object.
|
|
|
|
|
*
|
|
|
|
|
* @exception DOMException
|
|
|
|
|
* INVALID_CHARACTER_ERR: Raised if the specified name contains an
|
|
|
|
|
* invalid character.
|
|
|
|
|
*
|
|
|
|
|
* NOT_SUPPORTED_ERR: Raised if this document is an HTML
|
|
|
|
|
* document.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
EntityReference createEntityReference ( const DOMString &name );
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Moved from HTMLDocument in DOM Level 2
|
|
|
|
|
* Returns the Element whose \c id is given by
|
|
|
|
|
* elementId. If no such element exists, returns \c null
|
|
|
|
|
* . Behavior is not defined if more than one element has
|
|
|
|
|
* this \c id .
|
|
|
|
|
*
|
|
|
|
|
* @param elementId The unique \c id value for an
|
|
|
|
|
* element.
|
|
|
|
|
*
|
|
|
|
|
* @return The matching element.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
Element getElementById ( const DOMString &elementId ) const;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* No Exceptions.
|
|
|
|
|
*
|
|
|
|
|
* Returns a \c NodeList of all the \c Element 's
|
|
|
|
|
* with a given tag name in the order in which they
|
|
|
|
|
* would be encountered in a preorder traversal of the
|
|
|
|
|
* \c Document tree.
|
|
|
|
|
*
|
|
|
|
|
* @param tagname The name of the tag to match on. The special
|
|
|
|
|
* value "*" matches all tags.
|
|
|
|
|
*
|
|
|
|
|
* @return A new \c NodeList object containing all the
|
|
|
|
|
* matched \c Element s.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
NodeList getElementsByTagName ( const DOMString &tagname );
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Introduced in DOM Level 2
|
|
|
|
|
* No Exceptions
|
|
|
|
|
*
|
|
|
|
|
* Returns a NodeList of all the Elements with a given local name and
|
|
|
|
|
* namespace URI in the order in which they are encountered in a preorder
|
|
|
|
|
* traversal of the Document tree.
|
|
|
|
|
*
|
|
|
|
|
* @param namespaceURI The namespace URI of the elements to match on. The
|
|
|
|
|
* special value "*" matches all namespaces.
|
|
|
|
|
*
|
|
|
|
|
* @param localName The local name of the elements to match on. The special
|
|
|
|
|
* value "*" matches all local names.
|
|
|
|
|
*
|
|
|
|
|
* @return A new NodeList object containing all the matched Elements.
|
|
|
|
|
*/
|
|
|
|
|
NodeList getElementsByTagNameNS( const DOMString &namespaceURI,
|
|
|
|
|
const DOMString &localName );
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Introduced in DOM Level 2
|
|
|
|
|
*
|
|
|
|
|
* Imports a node from another document to this document. The returned node
|
|
|
|
|
* has no parent; (parentNode is null). The source node is not altered or
|
|
|
|
|
* removed from the original document; this method creates a new copy of
|
|
|
|
|
* the source node.
|
|
|
|
|
*
|
|
|
|
|
* For all nodes, importing a node creates a node object owned by the
|
|
|
|
|
* importing document, with attribute values identical to the source node's
|
|
|
|
|
* nodeName and nodeType, plus the attributes related to namespaces
|
|
|
|
|
* (prefix, localName, and namespaceURI).
|
|
|
|
|
*
|
|
|
|
|
* As in the cloneNode operation on a Node, the source node is not altered.
|
|
|
|
|
* Additional information is copied as appropriate to the nodeType,
|
|
|
|
|
* attempting to mirror the behavior expected if a fragment of XML or HTML
|
|
|
|
|
* source was copied from one document to another, recognizing that the two
|
|
|
|
|
* documents may have different DTDs in the XML case. The following list
|
|
|
|
|
* describes the specifics for each type of node.
|
|
|
|
|
*
|
|
|
|
|
* ATTRIBUTE_NODE
|
|
|
|
|
* The ownerElement attribute is set to null and the specified flag is set
|
|
|
|
|
* to true on the generated Attr. The descendants of the source Attr are
|
|
|
|
|
* recursively imported and the resulting nodes reassembled to form the
|
|
|
|
|
* corresponding subtree. Note that the deep parameter has no effect on
|
|
|
|
|
* Attr nodes; they always carry their children with them when imported.
|
|
|
|
|
*
|
|
|
|
|
* DOCUMENT_FRAGMENT_NODE
|
|
|
|
|
* If the deep option was set to true, the descendants of the source
|
|
|
|
|
* element are recursively imported and the resulting nodes reassembled to
|
|
|
|
|
* form the corresponding subtree. Otherwise, this simply generates an
|
|
|
|
|
* empty DocumentFragment.
|
|
|
|
|
*
|
|
|
|
|
* DOCUMENT_NODE
|
|
|
|
|
* Document nodes cannot be imported.
|
|
|
|
|
*
|
|
|
|
|
* DOCUMENT_TYPE_NODE
|
|
|
|
|
* DocumentType nodes cannot be imported.
|
|
|
|
|
*
|
|
|
|
|
* ELEMENT_NODE
|
|
|
|
|
* Specified attribute nodes of the source element are imported, and the
|
|
|
|
|
* generated Attr nodes are attached to the generated Element. Default
|
|
|
|
|
* attributes are not copied, though if the document being imported into
|
|
|
|
|
* defines default attributes for this element name, those are assigned. If
|
|
|
|
|
* the importNode deep parameter was set to true, the descendants of the
|
|
|
|
|
* source element are recursively imported and the resulting nodes
|
|
|
|
|
* reassembled to form the corresponding subtree.
|
|
|
|
|
*
|
|
|
|
|
* ENTITY_NODE
|
|
|
|
|
* Entity nodes can be imported, however in the current release of the DOM
|
|
|
|
|
* the DocumentType is readonly. Ability to add these imported nodes to a
|
|
|
|
|
* DocumentType will be considered for addition to a future release of the
|
|
|
|
|
* DOM.
|
|
|
|
|
* On import, the publicId, systemId, and notationName attributes are
|
|
|
|
|
* copied. If a deep import is requested, the descendants of the the source
|
|
|
|
|
* Entity are recursively imported and the resulting nodes reassembled to
|
|
|
|
|
* form the corresponding subtree.
|
|
|
|
|
*
|
|
|
|
|
* ENTITY_REFERENCE_NODE Only the EntityReference itself is copied, even if
|
|
|
|
|
* a deep import is requested, since the source and destination documents
|
|
|
|
|
* might have defined the entity differently. If the document being
|
|
|
|
|
* imported into provides a definition for this entity name, its value is
|
|
|
|
|
* assigned.
|
|
|
|
|
*
|
|
|
|
|
* NOTATION_NODE
|
|
|
|
|
* Notation nodes can be imported, however in the current release of the
|
|
|
|
|
* DOM the DocumentType is readonly. Ability to add these imported nodes to
|
|
|
|
|
* a DocumentType will be considered for addition to a future release of
|
|
|
|
|
* the DOM.
|
|
|
|
|
* On import, the publicId and systemId attributes are copied.
|
|
|
|
|
* Note that the deep parameter has no effect on Notation nodes since they
|
|
|
|
|
* never have any children.
|
|
|
|
|
*
|
|
|
|
|
* PROCESSING_INSTRUCTION_NODE
|
|
|
|
|
* The imported node copies its target and data values from those of the
|
|
|
|
|
* source node.
|
|
|
|
|
*
|
|
|
|
|
* TEXT_NODE, CDATA_SECTION_NODE, COMMENT_NODE
|
|
|
|
|
* These three types of nodes inheriting from CharacterData copy their data
|
|
|
|
|
* and length attributes from those of the source node.
|
|
|
|
|
*
|
|
|
|
|
* @param importedNode The node to import.
|
|
|
|
|
*
|
|
|
|
|
* @param deep If true, recursively import the subtree under the specified
|
|
|
|
|
* node; if false, import only the node itself, as explained above. This
|
|
|
|
|
* has no effect on Attr, EntityReference, and Notation nodes.
|
|
|
|
|
*
|
|
|
|
|
* @return The imported node that belongs to this Document.
|
|
|
|
|
*
|
|
|
|
|
* @exception DOMException
|
|
|
|
|
* NOT_SUPPORTED_ERR: Raised if the type of node being imported is not
|
|
|
|
|
* supported.
|
|
|
|
|
*/
|
|
|
|
|
Node importNode( const Node & importedNode, bool deep );
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* @internal
|
|
|
|
|
* not part of the DOM
|
|
|
|
|
*/
|
|
|
|
|
bool isHTMLDocument() const;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Introduced in DOM Level 2
|
|
|
|
|
* This method is from the DocumentRange interface
|
|
|
|
|
*
|
|
|
|
|
* @return Range
|
|
|
|
|
* The initial state of the Range returned from this method is such that
|
|
|
|
|
* both of its boundary-points are positioned at the beginning of the
|
|
|
|
|
* corresponding Document, before any content. The Range returned can only
|
|
|
|
|
* be used to select content associated with this Document, or with
|
|
|
|
|
* DocumentFragments and Attrs for which this Document is the ownerDocument.
|
|
|
|
|
*/
|
|
|
|
|
Range createRange();
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Introduced in DOM Level 2
|
|
|
|
|
* This method is from the DocumentTraversal interface
|
|
|
|
|
*
|
|
|
|
|
* Create a new NodeIterator over the subtree rooted at the specified node.
|
|
|
|
|
*
|
|
|
|
|
* @param 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. The root must not be null.
|
|
|
|
|
*
|
|
|
|
|
* @param whatToShow This flag specifies which node types may appear in the
|
|
|
|
|
* logical view of the tree presented by the iterator. See the description
|
|
|
|
|
* of NodeFilter for the set of possible SHOW_ values. These flags can be
|
|
|
|
|
* combined using OR.
|
|
|
|
|
*
|
|
|
|
|
* @param filter The NodeFilter to be used with this NodeIterator, or null to
|
|
|
|
|
* indicate no filter.
|
|
|
|
|
*
|
|
|
|
|
* @param entityReferenceExpansion The value of this flag determines
|
|
|
|
|
* whether entity reference nodes are expanded.
|
|
|
|
|
*
|
|
|
|
|
* @return NodeIterator The newly created NodeIterator.
|
|
|
|
|
*
|
|
|
|
|
* @exception DOMException
|
|
|
|
|
* NOT_SUPPORTED_ERR: Raised if the specified root is null.
|
|
|
|
|
*/
|
|
|
|
|
NodeIterator createNodeIterator(Node root, unsigned long whatToShow,
|
|
|
|
|
NodeFilter filter,
|
|
|
|
|
bool entityReferenceExpansion);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Introduced in DOM Level 2
|
|
|
|
|
* This method is from the DocumentTraversal interface
|
|
|
|
|
*
|
|
|
|
|
* Create a new TreeWalker over the subtree rooted at the specified node.
|
|
|
|
|
*
|
|
|
|
|
* @param root The node which will serve as the root for the TreeWalker.
|
|
|
|
|
* The whatToShow flags and the NodeFilter are not considered when setting
|
|
|
|
|
* this value; any node type will be accepted as the root. The currentNode
|
|
|
|
|
* of the TreeWalker is initialized to this node, whether or not it is
|
|
|
|
|
* visible. The root functions as a stopping point for traversal methods
|
|
|
|
|
* that look upward in the document structure, such as parentNode and
|
|
|
|
|
* nextNode. The root must not be null.
|
|
|
|
|
*
|
|
|
|
|
* @param whatToShow This flag specifies which node types may appear in the
|
|
|
|
|
* logical view of the tree presented by the tree-walker. See the
|
|
|
|
|
* description of NodeFilter for the set of possible SHOW_ values. These
|
|
|
|
|
* flags can be combined using OR.
|
|
|
|
|
*
|
|
|
|
|
* @param filter The NodeFilter to be used with this TreeWalker, or null to
|
|
|
|
|
* indicate no filter.
|
|
|
|
|
*
|
|
|
|
|
* @param entityReferenceExpansion If this flag is false, the contents of
|
|
|
|
|
* EntityReference nodes are not presented in the logical view.
|
|
|
|
|
*
|
|
|
|
|
* @return The newly created TreeWalker.
|
|
|
|
|
*
|
|
|
|
|
* @exception DOMException
|
|
|
|
|
* NOT_SUPPORTED_ERR: Raised if the specified root is null.
|
|
|
|
|
*/
|
|
|
|
|
TreeWalker createTreeWalker(Node root, unsigned long whatToShow,
|
|
|
|
|
NodeFilter filter,
|
|
|
|
|
bool entityReferenceExpansion);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Introduced in DOM Level 2
|
|
|
|
|
* This method is from the DocumentEvent interface
|
|
|
|
|
*
|
|
|
|
|
* The createEvent method is used in creating Events when it is either
|
|
|
|
|
* inconvenient or unnecessary for the user to create an Event themselves.
|
|
|
|
|
* In cases where the implementation provided Event is insufficient, users
|
|
|
|
|
* may supply their own Event implementations for use with the
|
|
|
|
|
* dispatchEvent method.
|
|
|
|
|
*
|
|
|
|
|
* @param eventType The eventType parameter specifies the type of Event
|
|
|
|
|
* interface to be created. If the Event interface specified is supported
|
|
|
|
|
* by the implementation this method will return a new Event of the
|
|
|
|
|
* interface type requested. If the Event is to be dispatched via the
|
|
|
|
|
* dispatchEvent method the appropriate event init method must be called
|
|
|
|
|
* after creation in order to initialize the Event's values. As an example,
|
|
|
|
|
* a user wishing to synthesize some kind of UIEvent would call createEvent
|
|
|
|
|
* with the parameter "UIEvents". The initUIEvent method could then be
|
|
|
|
|
* called on the newly created UIEvent to set the specific type of UIEvent
|
|
|
|
|
* to be dispatched and set its context information.
|
|
|
|
|
*
|
|
|
|
|
* @return The newly created EventExceptions
|
|
|
|
|
*
|
|
|
|
|
* @exception DOMException
|
|
|
|
|
* NOT_SUPPORTED_ERR: Raised if the implementation does not support the
|
|
|
|
|
* type of Event interface requested
|
|
|
|
|
*/
|
|
|
|
|
Event createEvent(const DOMString &eventType);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Introduced in DOM Level 2
|
|
|
|
|
* This method is from the DocumentView interface
|
|
|
|
|
*
|
|
|
|
|
* The default AbstractView for this Document, or null if none available.
|
|
|
|
|
*/
|
|
|
|
|
AbstractView defaultView() const;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Introduced in DOM Level 2
|
|
|
|
|
* This method is from the DocumentStyle interface
|
|
|
|
|
*
|
|
|
|
|
* A list containing all the style sheets explicitly linked into or
|
|
|
|
|
* embedded in a document. For HTML documents, this includes external style
|
|
|
|
|
* sheets, included via the HTML LINK element, and inline STYLE elements.
|
|
|
|
|
* In XML, this includes external style sheets, included via style sheet
|
|
|
|
|
* processing instructions (see [XML-StyleSheet]).
|
|
|
|
|
*/
|
|
|
|
|
StyleSheetList styleSheets() const;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* CSS3 mechanism for selecting alternate stylesheets using the DOM.
|
|
|
|
|
* Might change without further notice.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
DOMString preferredStylesheetSet();
|
|
|
|
|
DOMString selectedStylesheetSet();
|
|
|
|
|
void setSelectedStylesheetSet(const DOMString& aString);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Adds a new style sheet to the list of style sheets.
|
|
|
|
|
*
|
|
|
|
|
* The new style sheet will be applied after all author and implicit
|
|
|
|
|
* style sheets, but before the user style sheet.
|
|
|
|
|
*
|
|
|
|
|
* Create new style sheets with e. g.
|
|
|
|
|
* \c DOMImplementation::createCSSStyleSheet
|
|
|
|
|
*
|
|
|
|
|
* This is not part of the official DOM.
|
|
|
|
|
*
|
|
|
|
|
* @param sheet style sheet
|
|
|
|
|
* @exception DOMException
|
|
|
|
|
* @since 3.4
|
|
|
|
|
*/
|
|
|
|
|
void addStyleSheet(const StyleSheet &sheet);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Removes a style sheet to the list of style sheets.
|
|
|
|
|
*
|
|
|
|
|
* Only sheets added by \c addStyleSheet may be removed.
|
|
|
|
|
*
|
|
|
|
|
* This is not part of the official DOM.
|
|
|
|
|
*
|
|
|
|
|
* @param sheet style sheet to remove
|
|
|
|
|
* @exception DOMException
|
|
|
|
|
* NOT_FOUND_ERR \c sheet is not contained in the list of style sheets or
|
|
|
|
|
* it has not been added by \c addStyleSheet
|
|
|
|
|
* @since 3.4
|
|
|
|
|
*/
|
|
|
|
|
void removeStyleSheet(const StyleSheet &sheet);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* @return The TDEHTML view widget of this document.
|
|
|
|
|
*/
|
|
|
|
|
TDEHTMLView *view() const;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Introduced in DOM Level 2
|
|
|
|
|
* This method is from the DocumentCSS interface
|
|
|
|
|
*
|
|
|
|
|
* This method is used to retrieve the override style declaration for a
|
|
|
|
|
* specified element and a specified pseudo-element.
|
|
|
|
|
*
|
|
|
|
|
* @param elt The element whose style is to be modified. This parameter
|
|
|
|
|
* cannot be null.
|
|
|
|
|
*
|
|
|
|
|
* @param pseudoElt The pseudo-element or null if none.
|
|
|
|
|
*
|
|
|
|
|
* @return The override style declaration.
|
|
|
|
|
*/
|
|
|
|
|
CSSStyleDeclaration getOverrideStyle(const Element &elt,
|
|
|
|
|
const DOMString &pseudoElt);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Introduced in DOM Level 3
|
|
|
|
|
* This method is from the DocumentLS interface
|
|
|
|
|
*
|
|
|
|
|
* Indicates whether the method DocumentLS.load() should be synchronous or
|
|
|
|
|
* asynchronous. When the async attribute is set to true the load method
|
|
|
|
|
* returns control to the caller before the document has completed loading.
|
|
|
|
|
* The default value of this attribute is true.
|
|
|
|
|
*/
|
|
|
|
|
bool async() const;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Introduced in DOM Level 3
|
|
|
|
|
* This method is from the DocumentLS interface
|
|
|
|
|
*
|
|
|
|
|
* see async
|
|
|
|
|
*
|
|
|
|
|
* @exception DOMException
|
|
|
|
|
* NOT_SUPPORTED_ERR: Raised if the implementation doesn't support the mode
|
|
|
|
|
* the attribute is being set to.
|
|
|
|
|
*/
|
|
|
|
|
void setAsync( bool );
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Introduced in DOM Level 3
|
|
|
|
|
* This method is from the DocumentLS interface
|
|
|
|
|
*
|
|
|
|
|
* If the document is currently being loaded as a result of the method load
|
|
|
|
|
* being invoked the loading and parsing is immediately aborted. The
|
|
|
|
|
* possibly partial result of parsing the document is discarded and the
|
|
|
|
|
* document is cleared.
|
|
|
|
|
*/
|
|
|
|
|
void abort();
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Introduced in DOM Level 3
|
|
|
|
|
* This method is from the DocumentLS interface
|
|
|
|
|
*
|
|
|
|
|
* Replaces the content of the document with the result of parsing the
|
|
|
|
|
* given URI. Invoking this method will either block the caller or return
|
|
|
|
|
* to the caller immediately depending on the value of the async attribute.
|
|
|
|
|
* Once the document is fully loaded a "load" event (as defined in
|
|
|
|
|
* [DOM Level 3 Events], except that the Event.targetNode will be the
|
|
|
|
|
* document, not an element) will be dispatched on the document. If an
|
|
|
|
|
* error occurs, an implementation dependent "error" event will be
|
|
|
|
|
* dispatched on the document. If this method is called on a document that
|
|
|
|
|
* is currently loading, the current load is interrupted and the new URI
|
|
|
|
|
* load is initiated.
|
|
|
|
|
*
|
|
|
|
|
* When invoking this method the parameters used in the DOMParser interface
|
|
|
|
|
* are assumed to have their default values with the exception that the
|
|
|
|
|
* parameters "entities", "normalize-characters",
|
|
|
|
|
* "check-character-normalization" are set to "false".
|
|
|
|
|
*
|
|
|
|
|
* The result of a call to this method is the same the result of a call to
|
|
|
|
|
* DOMParser.parseWithContext with an input stream referencing the URI that
|
|
|
|
|
* was passed to this call, the document as the context node, and the
|
|
|
|
|
* action ACTION_REPLACE_CHILDREN.
|
|
|
|
|
*
|
|
|
|
|
* @param uri of type DOMString
|
|
|
|
|
* The URI reference for the XML file to be loaded. If this is a relative
|
|
|
|
|
* URI, the base URI used by the implementation is implementation dependent.
|
|
|
|
|
*
|
|
|
|
|
* @return If async is set to true load returns true if the document load
|
|
|
|
|
* was successfully initiated. If an error occurred when initiating the
|
|
|
|
|
* document load, load returns false.
|
|
|
|
|
* If async is set to false load returns true if the document was
|
|
|
|
|
* successfully loaded and parsed. If an error occurred when either loading
|
|
|
|
|
* or parsing the URI, load returns false.
|
|
|
|
|
*/
|
|
|
|
|
void load( const DOMString &uri );
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Introduced in DOM Level 3
|
|
|
|
|
* This method is from the DocumentLS interface
|
|
|
|
|
*
|
|
|
|
|
* Replace the content of the document with the result of parsing the input
|
|
|
|
|
* string, this method is always synchronous. This method always parses
|
|
|
|
|
* from a DOMString, which means the data is always UTF-16. All other
|
|
|
|
|
* encoding information is ignored.
|
|
|
|
|
*
|
|
|
|
|
* The parameters used in the DOMParser interface are assumed to have their
|
|
|
|
|
* default values when invoking this method.
|
|
|
|
|
*
|
|
|
|
|
* The result of a call to this method is the same as the result of a call
|
|
|
|
|
* to DOMParser.parseWithContext with an input stream containing the string
|
|
|
|
|
* passed to this call, the document as the context node, and the action
|
|
|
|
|
* ACTION_REPLACE_CHILDREN.
|
|
|
|
|
*
|
|
|
|
|
* @param source A string containing an XML document.
|
|
|
|
|
*/
|
|
|
|
|
void loadXML( const DOMString &source );
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* not part of the official DOM
|
|
|
|
|
*
|
|
|
|
|
* Documents are read-only by default, but they can be made editable by
|
|
|
|
|
* entering "design mode".
|
|
|
|
|
*
|
|
|
|
|
* @return whether this document is in design mode.
|
|
|
|
|
* @since 3.2
|
|
|
|
|
*/
|
|
|
|
|
bool designMode() const;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* not part of the official DOM
|
|
|
|
|
*
|
|
|
|
|
* @param enable @p true to enable design mode, @p false to disable.
|
|
|
|
|
* @see designMode
|
|
|
|
|
* @since 3.2
|
|
|
|
|
*/
|
|
|
|
|
void setDesignMode(bool enable);
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* not part of the DOM
|
|
|
|
|
*
|
|
|
|
|
* completes a given URL
|
|
|
|
|
*/
|
|
|
|
|
DOMString completeURL(const DOMString& url);
|
|
|
|
|
|
|
|
|
|
DOMString toString() const;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* not part of the DOM
|
|
|
|
|
*
|
|
|
|
|
* Updates the rendered display after one or more changes to
|
|
|
|
|
* the DOM structure
|
|
|
|
|
*/
|
|
|
|
|
void updateRendering();
|
|
|
|
|
|
|
|
|
|
Document( DocumentImpl *i);
|
|
|
|
|
protected:
|
|
|
|
|
|
|
|
|
|
friend class Node;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
class DocumentFragmentImpl;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* \c DocumentFragment is a "lightweight" or "minimal"
|
|
|
|
|
* \c 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 \c Document object could fulfil this role, a
|
|
|
|
|
* \c Document object can potentially be a heavyweight object,
|
|
|
|
|
* depending on the underlying implementation. What is really needed
|
|
|
|
|
* for this is a very lightweight object. \c DocumentFragment
|
|
|
|
|
* is such an object.
|
|
|
|
|
*
|
|
|
|
|
* Furthermore, various operations -- such as inserting nodes as
|
|
|
|
|
* children of another \c Node -- may take
|
|
|
|
|
* \c DocumentFragment objects as arguments; this results in all
|
|
|
|
|
* the child nodes of the \c DocumentFragment being moved
|
|
|
|
|
* to the child list of this node.
|
|
|
|
|
*
|
|
|
|
|
* The children of a \c DocumentFragment node are zero or
|
|
|
|
|
* more nodes representing the tops of any sub-trees defining the
|
|
|
|
|
* structure of the document. \c 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
|
|
|
|
|
* \c DocumentFragment might have only one child and that child
|
|
|
|
|
* node could be a \c Text node. Such a structure model
|
|
|
|
|
* represents neither an HTML document nor a well-formed XML document.
|
|
|
|
|
*
|
|
|
|
|
* When a \c DocumentFragment is inserted into a
|
|
|
|
|
* \c Document (or indeed any other \c Node that may
|
|
|
|
|
* take children) the children of the \c DocumentFragment
|
|
|
|
|
* and not the \c DocumentFragment itself are inserted
|
|
|
|
|
* into the \c Node . This makes the
|
|
|
|
|
* \c DocumentFragment very useful when the user wishes to create
|
|
|
|
|
* nodes that are siblings; the \c DocumentFragment acts
|
|
|
|
|
* as the parent of these nodes so that the user can use the standard
|
|
|
|
|
* methods from the \c Node interface, such as
|
|
|
|
|
* \c insertBefore() and \c appendChild() .
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
class TDEHTML_EXPORT DocumentFragment : public Node
|
|
|
|
|
{
|
|
|
|
|
friend class Document;
|
|
|
|
|
friend class HTMLElementImpl;
|
|
|
|
|
friend class Range;
|
|
|
|
|
|
|
|
|
|
public:
|
|
|
|
|
DocumentFragment();
|
|
|
|
|
DocumentFragment(const DocumentFragment &other);
|
|
|
|
|
DocumentFragment(const Node &other) : Node()
|
|
|
|
|
{(*this)=other;}
|
|
|
|
|
|
|
|
|
|
DocumentFragment & operator = (const Node &other);
|
|
|
|
|
DocumentFragment & operator = (const DocumentFragment &other);
|
|
|
|
|
|
|
|
|
|
~DocumentFragment();
|
|
|
|
|
|
|
|
|
|
protected:
|
|
|
|
|
DocumentFragment(DocumentFragmentImpl *i);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
class NamedNodeMap;
|
|
|
|
|
class DOMString;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Each \c Document has a \c doctype attribute
|
|
|
|
|
* whose value is either \c null or a \c DocumentType
|
|
|
|
|
* object. The \c 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 \c DocumentType
|
|
|
|
|
* nodes.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
class TDEHTML_EXPORT DocumentType : public Node
|
|
|
|
|
{
|
|
|
|
|
friend class Document;
|
|
|
|
|
friend class DOMImplementation;
|
|
|
|
|
public:
|
|
|
|
|
DocumentType();
|
|
|
|
|
DocumentType(const DocumentType &other);
|
|
|
|
|
|
|
|
|
|
DocumentType(const Node &other) : Node()
|
|
|
|
|
{(*this)=other;}
|
|
|
|
|
DocumentType & operator = (const Node &other);
|
|
|
|
|
DocumentType & operator = (const DocumentType &other);
|
|
|
|
|
|
|
|
|
|
~DocumentType();
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* The name of DTD; i.e., the name immediately following the
|
|
|
|
|
* \c DOCTYPE keyword.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
DOMString name() const;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* A \c 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 \c foo
|
|
|
|
|
* and \c bar but not \c baz .
|
|
|
|
|
* Every node in this map also implements the \c Entity
|
|
|
|
|
* interface.
|
|
|
|
|
*
|
|
|
|
|
* The DOM Level 1 does not support editing entities, therefore
|
|
|
|
|
* \c entities cannot be altered in any way.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
NamedNodeMap entities() const;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* A \c NamedNodeMap containing the notations declared
|
|
|
|
|
* in the DTD. Duplicates are discarded. Every node in this map
|
|
|
|
|
* also implements the \c Notation interface.
|
|
|
|
|
*
|
|
|
|
|
* The DOM Level 1 does not support editing notations, therefore
|
|
|
|
|
* \c notations cannot be altered in any way.
|
|
|
|
|
*
|
|
|
|
|
*/
|
|
|
|
|
NamedNodeMap notations() const;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Introduced in DOM Level 2
|
|
|
|
|
*
|
|
|
|
|
* The public identifier of the external subset.
|
|
|
|
|
*/
|
|
|
|
|
DOMString publicId() const;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Introduced in DOM Level 2
|
|
|
|
|
*
|
|
|
|
|
* The system identifier of the external subset.
|
|
|
|
|
*/
|
|
|
|
|
DOMString systemId() const;
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Introduced in DOM Level 2
|
|
|
|
|
*
|
|
|
|
|
* The internal subset as a string.
|
|
|
|
|
*
|
|
|
|
|
* Note: The actual content returned depends on how much information is
|
|
|
|
|
* available to the implementation. This may vary depending on various
|
|
|
|
|
* parameters, including the XML processor used to build the document.
|
|
|
|
|
*/
|
|
|
|
|
DOMString internalSubset() const;
|
|
|
|
|
|
|
|
|
|
protected:
|
|
|
|
|
DocumentType(DocumentTypeImpl *impl);
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
} //namespace
|
|
|
|
|
#endif
|