diff options
Diffstat (limited to 'tdehtml/xml/dom_nodeimpl.h')
| -rw-r--r-- | tdehtml/xml/dom_nodeimpl.h | 736 |
1 files changed, 736 insertions, 0 deletions
diff --git a/tdehtml/xml/dom_nodeimpl.h b/tdehtml/xml/dom_nodeimpl.h new file mode 100644 index 000000000..c01e69c0a --- /dev/null +++ b/tdehtml/xml/dom_nodeimpl.h @@ -0,0 +1,736 @@ +/* + * This file is part of the DOM implementation for KDE. + * + * Copyright (C) 1999 Lars Knoll (knoll@kde.org) + * (C) 1999 Antti Koivisto (koivisto@kde.org) + * (C) 2001 Dirk Mueller (mueller@kde.org) + * (C) 2003 Apple Computer, Inc. + * + * 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. + * + */ +#ifndef _DOM_NodeImpl_h_ +#define _DOM_NodeImpl_h_ + +#include "dom/dom_misc.h" +#include "dom/dom_string.h" +#include "dom/dom_node.h" +#include "misc/helper.h" +#include "misc/shared.h" + +// The namespace used for XHTML elements +#define XHTML_NAMESPACE "http://www.w3.org/1999/xhtml" + +class TQPainter; +template <class type> class TQPtrList; +template <class type> class TQValueList; +class KHTMLView; +class TQRect; +class TQMouseEvent; +class TQKeyEvent; +class TQTextStream; + +namespace tdehtml { + class RenderStyle; + class RenderObject; + class RenderArena; +} + +namespace DOM { + +class NodeListImpl; +class NamedNodeMapImpl; +class DocumentImpl; +class CSSStyleDeclarationImpl; +class RegisteredEventListener; +class EventImpl; + +struct RegisteredListenerList { + RegisteredListenerList() : listeners(0) + {} + + ~RegisteredListenerList(); + + void addEventListener(int id, EventListener *listener, const bool useCapture); + void removeEventListener(int id, EventListener *listener, bool useCapture); + + void setHTMLEventListener(int id, EventListener *listener); + EventListener *getHTMLEventListener(int id); + + bool hasEventListener(int id); + void clear(); + + //### KDE4: should disappear + bool stillContainsListener(const RegisteredEventListener& listener); + + TQValueList<RegisteredEventListener>* listeners;//The actual listener list - may be 0 +private: + bool isHTMLEventListener(EventListener* listener); +}; + + +// this class implements nodes, which can have a parent but no children: +#define NodeImpl_IdNSMask 0xffff0000 +#define NodeImpl_IdLocalMask 0x0000ffff + +const TQ_UINT16 defaultNamespace = 0; +const TQ_UINT16 xhtmlNamespace = 1; +const TQ_UINT16 emptyNamespace = 2; +const TQ_UINT16 anyNamespace = 0xffff; +const TQ_UINT16 anyLocalName = 0xffff; + +inline TQ_UINT16 localNamePart(TQ_UINT32 id) { return id & NodeImpl_IdLocalMask; } +inline TQ_UINT16 namespacePart(TQ_UINT32 id) { return (((unsigned int)id) & NodeImpl_IdNSMask) >> 16; } +inline TQ_UINT32 makeId(TQ_UINT16 n, TQ_UINT16 l) { return (n << 16) | l; } + +const TQ_UINT32 anyQName = makeId(anyNamespace, anyLocalName); + +class NodeImpl : public tdehtml::TreeShared<NodeImpl> +{ + friend class DocumentImpl; +public: + NodeImpl(DocumentImpl *doc); + virtual ~NodeImpl(); + + // DOM methods & attributes for Node + virtual DOMString nodeName() const; + virtual DOMString nodeValue() const; + virtual void setNodeValue( const DOMString &_nodeValue, int &exceptioncode ); + virtual unsigned short nodeType() const; + NodeImpl *parentNode() const { return m_parent; } + NodeImpl *previousSibling() const { return m_previous; } + NodeImpl *nextSibling() const { return m_next; } + virtual NodeListImpl *childNodes(); + virtual NodeImpl *firstChild() const; + virtual NodeImpl *lastChild() const; + // insertBefore, replaceChild and appendChild also close newChild + // unlike the speed optimized addChild (which is used by the parser) + virtual NodeImpl *insertBefore ( NodeImpl *newChild, NodeImpl *refChild, int &exceptioncode ); + + /* These two methods may delete the old node, so make sure to reference it if you need it */ + virtual void replaceChild ( NodeImpl *newChild, NodeImpl *oldChild, int &exceptioncode ); + virtual void removeChild ( NodeImpl *oldChild, int &exceptioncode ); + virtual NodeImpl *appendChild ( NodeImpl *newChild, int &exceptioncode ); + virtual bool hasChildNodes ( ) const; + virtual NodeImpl *cloneNode ( bool deep ) = 0; + virtual DOMString localName() const; + virtual DOMString prefix() const; + virtual DOMString namespaceURI() const; + virtual void setPrefix(const DOMString &_prefix, int &exceptioncode ); + void normalize (); + + // Other methods (not part of DOM) + virtual bool isElementNode() const { return false; } + virtual bool isHTMLElement() const { return false; } + virtual bool isAttributeNode() const { return false; } + virtual bool isTextNode() const { return false; } + virtual bool isDocumentNode() const { return false; } + virtual bool isXMLElementNode() const { return false; } + virtual bool isGenericFormElement() const { return false; } + virtual bool containsOnlyWhitespace() const { return false; } + virtual bool contentEditable() const; + + // helper functions not being part of the DOM + // Attention: they assume that the caller did the consistency checking! + void setPreviousSibling(NodeImpl *previous) { m_previous = previous; } + void setNextSibling(NodeImpl *next) { m_next = next; } + + virtual void setFirstChild(NodeImpl *child); + virtual void setLastChild(NodeImpl *child); + + // used by the parser. Doesn't do as many error checkings as + // appendChild(), and returns the node into which will be parsed next. + virtual NodeImpl *addChild(NodeImpl *newChild); + + typedef TQ_UINT32 Id; + // id() is used to easily and exactly identify a node. It + // is optimized for quick comparison and low memory consumption. + // its value depends on the owner document of the node and is + // categorized in the following way: + // 1..ID_LAST_TAG: the node inherits HTMLElementImpl and is + // part of the HTML namespace. + // The HTML namespace is either the global + // one (no namespace) or the XHTML namespace + // depending on the owner document's doctype + // ID_LAST_TAG+1..0xffff: non-HTML elements in the global namespace + // others non-HTML elements in a namespace. + // the upper 16 bit identify the namespace + // the lower 16 bit identify the local part of the + // qualified element name. + virtual Id id() const { return 0; } + + // These are the DOM 3 Core answer to innerText/setInnerText, and are used + // quite a bit since Mozilla doesn't do innerText. They do, however, behave slightly + // differently. The default implementation is for ELEMENT_NODE, ATTRIBUTE_NODE, + // ENTITY_NODE, ENTITY_REFERENCE_NODE, DOCUMENT_FRAGMENT_NODE. + virtual DOMStringImpl* textContent() const; + virtual void setTextContent( const DOMString &text, int& exceptioncode ) = 0; + + enum IdType { + AttributeId, + ElementId, + NamespaceId + }; + + enum MouseEventType { + MousePress, + MouseRelease, + MouseClick, + MouseDblClick, + MouseMove + }; + + struct MouseEvent + { + MouseEvent( int _button, MouseEventType _type, + const DOMString &_url = DOMString(), const DOMString& _target = DOMString(), + NodeImpl *_innerNode = 0, NodeImpl *_innerNonSharedNode = 0) + { + button = _button; type = _type; + url = _url; target = _target; + innerNode = _innerNode; + innerNonSharedNode = _innerNonSharedNode; + } + + int button; + MouseEventType type; + DOMString url; // url under mouse or empty + DOMString target; + Node innerNode; + Node innerNonSharedNode; + }; + + // for LINK and STYLE + virtual void sheetLoaded() {} + + bool hasID() const { return m_hasId; } + bool hasClass() const { return m_hasClass; } + bool active() const { return m_active; } + bool focused() const { return m_focused; } + bool hovered() const { return m_hovered; } + bool attached() const { return m_attached; } + bool closed() const { return m_closed; } + bool changed() const { return m_changed; } + bool hasChangedChild() const { return m_hasChangedChild; } + bool hasAnchor() const { return m_hasAnchor; } + bool inDocument() const { return m_inDocument; } + bool implicitNode() const { return m_implicit; } + bool htmlCompat() const { return m_htmlCompat; } + void setHasID(bool b=true) { m_hasId = b; } + void setHasClass(bool b=true) { m_hasClass = b; } + void setHasChangedChild( bool b = true ) { m_hasChangedChild = b; } + void setInDocument(bool b=true) { m_inDocument = b; } + void setHTMLCompat(bool b) { m_htmlCompat = b; } + virtual void setFocus(bool b=true) { m_focused = b; } + virtual void setActive(bool b=true) { m_active = b; } + virtual void setHovered(bool b=true) { m_hovered = b; } + virtual void setChanged(bool b=true); + + // for descending restyle when ID or CLASS changes + bool changedAscendentAttribute() const { return m_changedAscendentAttribute; } + void setChangedAscendentAttribute(bool b) { m_changedAscendentAttribute = b; } + + // for style selection performance: whether the element matches several CSS Classes + bool hasClassList() const { return m_hasClassList; } + void setHasClassList(bool b) { m_hasClassList = b; } + + unsigned short tabIndex() const { return m_tabIndex; } + void setTabIndex(unsigned short _tabIndex) { m_tabIndex = _tabIndex; } + + virtual bool isFocusable() const { return false; } + virtual bool isMouseFocusable() const { return isFocusable(); } + virtual bool isTabFocusable() const { return isFocusable(); } + + virtual bool isInline() const; + + virtual void getCaret(int offset, bool override, int &_x, int &_y, int &width, int &height); + virtual TQRect getRect() const; + + enum StyleChange { NoChange, NoInherit, Inherit, Detach, Force }; + virtual void recalcStyle( StyleChange = NoChange ) {} + static StyleChange diff( tdehtml::RenderStyle *s1, tdehtml::RenderStyle *s2 ); + static bool pseudoDiff( tdehtml::RenderStyle *s1, tdehtml::RenderStyle *s2, unsigned int pid); + + unsigned long nodeIndex() const; + // Returns the document that this node is associated with. This is guaranteed to always be non-null, as opposed to + // DOM's ownerDocument() which is null for Document nodes (and sometimes DocumentType nodes). + DocumentImpl* getDocument() const { return m_document.get(); } + + void addEventListener(int id, EventListener *listener, const bool useCapture); + void removeEventListener(int id, EventListener *listener, bool useCapture); + void setHTMLEventListener(int id, EventListener *listener); + EventListener *getHTMLEventListener(int id); + + void dispatchEvent(EventImpl *evt, int &exceptioncode, bool tempEvent = false); + void dispatchGenericEvent( EventImpl *evt, int &exceptioncode); + // return true if event not prevented + bool dispatchHTMLEvent(int _id, bool canBubbleArg, bool cancelableArg); + void dispatchWindowEvent(int _id, bool canBubbleArg, bool cancelableArg); + void dispatchMouseEvent(TQMouseEvent *e, int overrideId = 0, int overrideDetail = 0); + void dispatchUIEvent(int _id, int detail = 0); + void dispatchSubtreeModifiedEvent(); + // return true if defaultPrevented (i.e. event should be swallowed) + // this matches the logic in KHTMLView. + bool dispatchKeyEvent(TQKeyEvent *key, bool keypress); + + void handleLocalEvents(EventImpl *evt, bool useCapture); + + /** + * Perform the default action for an event e.g. submitting a form + */ + virtual void defaultEventHandler(EventImpl *evt); + + virtual bool isReadOnly(); + virtual bool childTypeAllowed( unsigned short /*type*/ ) { return false; } + virtual unsigned long childNodeCount(); + virtual NodeImpl *childNode(unsigned long index); + + /** + * Does a pre-order traversal of the tree to find the node next node after this one. This uses the same order that + * the tags appear in the source file. + * + * @param stayWithin If not null, the traversal will stop once the specified node is reached. This can be used to + * restrict traversal to a particular sub-tree. + * + * @return The next node, in document order + * + * see traversePreviousNode() + */ + NodeImpl *traverseNextNode(NodeImpl *stayWithin = 0) const; + + /** + * Does a reverse pre-order traversal to find the node that comes before the current one in document order + * + * see traverseNextNode() + */ + NodeImpl *traversePreviousNode() const; + + DocumentImpl *docPtr() const { return m_document.get(); } + + tdehtml::RenderObject *renderer() const { return m_render; } + tdehtml::RenderObject *nextRenderer(); + tdehtml::RenderObject *previousRenderer(); + void setRenderer(tdehtml::RenderObject* renderer) { m_render = renderer; } + + void checkSetPrefix(const DOMString &_prefix, int &exceptioncode); + void checkAddChild(NodeImpl *newChild, int &exceptioncode); + bool isAncestor( NodeImpl *other ); + virtual bool childAllowed( NodeImpl *newChild ); + + /** + * Returns the minimum caret offset that is allowed for this node. + * + * This default implementation always returns 0. Textual child nodes + * may return other values. + */ + virtual long minOffset() const; + /** + * Returns the maximum caret offset that is allowed for this node. + * + * This default implementation always returns the node count. + * Textual child nodes return the character count instead. + */ + virtual long maxOffset() const; + + // ----------------------------------------------------------------------------- + // Integration with rendering tree + + /** + * Attaches this node to the rendering tree. This calculates the style to be applied to the node and creates an + * appropriate RenderObject which will be inserted into the tree (except when the style has display: none). This + * makes the node visible in the KHTMLView. + */ + virtual void attach(); + + /** + * Detaches the node from the rendering tree, making it invisible in the rendered view. This method will remove + * the node's rendering object from the rendering tree and delete it. + */ + virtual void detach(); + + /** + * Notifies the node that no more children will be added during parsing. + * After a node has been closed all changes must go through the DOM interface. + */ + virtual void close(); + + virtual void structureChanged() {}; + virtual void backwardsStructureChanged() {}; + + void createRendererIfNeeded(); + virtual tdehtml::RenderStyle *styleForRenderer(tdehtml::RenderObject *parent); + virtual bool rendererIsNeeded(tdehtml::RenderStyle *); + virtual tdehtml::RenderObject *createRenderer(tdehtml::RenderArena *, tdehtml::RenderStyle *); + + // ----------------------------------------------------------------------------- + // Methods for maintaining the state of the element between history navigation + + /** + * Indicates whether or not this type of node maintains its state. If so, the state of the node will be stored when + * the user goes to a different page using the state() method, and restored using the restoreState() method if the + * user returns (e.g. using the back button). This is used to ensure that user-changeable elements such as form + * controls maintain their contents when the user returns to a previous page in the history. + */ + virtual bool maintainsState(); + + /** + * Returns the state of this node represented as a string. This string will be passed to restoreState() if the user + * returns to the page. + * + * @return State information about the node represented as a string + */ + virtual TQString state(); + + /** + * Sets the state of the element based on a string previosuly returned by state(). This is used to initialize form + * controls with their old values when the user returns to the page in their history. + * + * @param state A string representation of the node's previously-stored state + */ + virtual void restoreState(const TQString &state); + + // ----------------------------------------------------------------------------- + // Notification of document stucture changes + + /** + * Notifies the node that it has been inserted into the document. This is called during document parsing, and also + * when a node is added through the DOM methods insertBefore(), appendChild() or replaceChild(). Note that this only + * happens when the node becomes part of the document tree, i.e. only when the document is actually an ancestor of + * the node. The call happens _after_ the node has been added to the tree. + * + * This is similar to the DOMNodeInsertedIntoDocument DOM event, but does not require the overhead of event + * dispatching. + */ + virtual void insertedIntoDocument(); + + /** + * Notifies the node that it is no longer part of the document tree, i.e. when the document is no longer an ancestor + * node. + * + * This is similar to the DOMNodeRemovedFromDocument DOM event, but does not require the overhead of event + * dispatching, and is called _after_ the node is removed from the tree. + */ + virtual void removedFromDocument(); + + /** + * Notifies the node that its list of children have changed (either by adding or removing child nodes), or a child + * node that is of the type CDATA_SECTION_NODE, TEXT_NODE or COMMENT_NODE has changed its value. + */ + virtual void childrenChanged(); + + virtual DOMString toString() const = 0; + /** + * Sometimes we need to get the string between two points on the DOM graph. Use this function to do this. + * For example, when the user copies some selected text to the clipboard as html. + * @param selectionStart Where to start the selection. If selectionStart != this, it is assumed we are after the start point + * @param selectionEnd Where to end the selection. If selectionEnd != this, it is assumed we are before the end point (unless found is true) + * @param startOffset Number of characters into the text in selectionStart that the start of the selection is. + * @param endOffset Number of characters into the text in selectionEnd that the end of the selection is. + * @param found When this is set to true, don't print anymore but closing tags. + * @return An html formatted string for this node and its children between the selectionStart and selectionEnd. + */ + virtual DOMString selectionToString(NodeImpl * selectionStart, + NodeImpl * selectionEnd, + int startOffset, + int endOffset, + bool &found) const + { Q_UNUSED(selectionStart); + Q_UNUSED(selectionEnd); + Q_UNUSED(startOffset); + Q_UNUSED(endOffset); + Q_UNUSED(found); + return toString(); + } + +private: // members + tdehtml::DocPtr<DocumentImpl> m_document; + NodeImpl *m_previous; + NodeImpl *m_next; +protected: + tdehtml::RenderObject *m_render; + RegisteredListenerList m_regdListeners; + + unsigned short m_tabIndex : 15; + bool m_hasTabIndex : 1; + + bool m_hasId : 1; + bool m_attached : 1; + bool m_closed : 1; + bool m_changed : 1; + bool m_hasChangedChild : 1; + bool m_changedAscendentAttribute : 1; + bool m_inDocument : 1; + bool m_hasAnchor : 1; + bool m_specified : 1; // used in AttrImpl. Accessor functions there + + bool m_hovered : 1; + bool m_focused : 1; + bool m_active : 1; + bool m_implicit : 1; // implicitely generated by the parser + bool m_htmlCompat : 1; // true if element was created in HTML compat mode + bool m_hasClassList : 1; + bool m_hasClass : 1; // true if element has a class property, as relevant to CSS +}; + +// this is the full Node Implementation with parents and children. +class NodeBaseImpl : public NodeImpl +{ +public: + NodeBaseImpl(DocumentImpl *doc) + : NodeImpl(doc), _first(0), _last(0) {} + virtual ~NodeBaseImpl(); + + // DOM methods overridden from parent classes + virtual NodeImpl *firstChild() const; + virtual NodeImpl *lastChild() const; + virtual NodeImpl *insertBefore ( NodeImpl *newChild, NodeImpl *refChild, int &exceptioncode ); + virtual void replaceChild ( NodeImpl *newChild, NodeImpl *oldChild, int &exceptioncode ); + virtual void removeChild ( NodeImpl *oldChild, int &exceptioncode ); + virtual NodeImpl *appendChild ( NodeImpl *newChild, int &exceptioncode ); + virtual bool hasChildNodes ( ) const; + + virtual void setTextContent( const DOMString &text, int& exceptioncode ); + + // Other methods (not part of DOM) + void removeChildren(); + void cloneChildNodes(NodeImpl *clone); + + virtual void setFirstChild(NodeImpl *child); + virtual void setLastChild(NodeImpl *child); + virtual NodeImpl *addChild(NodeImpl *newChild); + virtual void attach(); + virtual void detach(); + + + bool getUpperLeftCorner(int &xPos, int &yPos) const; + bool getLowerRightCorner(int &xPos, int &yPos) const; + + virtual void setFocus(bool=true); + virtual void setActive(bool=true); + virtual void setHovered(bool=true); + virtual unsigned long childNodeCount(); + virtual NodeImpl *childNode(unsigned long index); + +protected: + NodeImpl *_first; + NodeImpl *_last; + + // helper functions for inserting children: + + // ### this should vanish. do it in dom/ ! + // check for same source document: + bool checkSameDocument( NodeImpl *newchild, int &exceptioncode ); + // check for being child: + bool checkIsChild( NodeImpl *oldchild, int &exceptioncode ); + // ### + + // find out if a node is allowed to be our child + void dispatchChildInsertedEvents( NodeImpl *child, int &exceptioncode ); + void dispatchChildRemovalEvents( NodeImpl *child, int &exceptioncode ); +}; + +// -------------------------------------------------------------------------- +class Node; +class NodeImpl; + +class NodeListImpl : public tdehtml::Shared<NodeListImpl> +{ +public: + //Type of the item stored in the cache. + enum Type { + UNCACHEABLE, //Too complex to be cached like this + CHILD_NODES, + LAST_NODE_LIST = CHILD_NODES + }; + + struct CacheKey + { + NodeImpl* baseNode; + int type; + + CacheKey(): type(UNCACHEABLE) {} + + CacheKey(NodeImpl* _baseNode, int _type): + baseNode(_baseNode), type(_type) + {} + + int hash() const + { + return int(reinterpret_cast<unsigned long>(baseNode) >> 2) ^ + (unsigned(type) << 26); + } + + bool operator==(const CacheKey& other) const + { + return baseNode == other.baseNode && + type == other.type; + } + }; + + struct Cache: public tdehtml::Shared<Cache> + { + static Cache* make() { return new Cache; } + + CacheKey key;//### We must store this in here due to TQCache in Qt3 sucking + + unsigned int version; + union + { + NodeImpl* node; + unsigned int index; + } current; + unsigned int position; + unsigned int length; + bool hasLength; + + void updateNodeListInfo(DocumentImpl* doc); + + virtual void clear(DocumentImpl* doc); + virtual ~Cache(); + }; + + typedef Cache* CacheFactory(); + + NodeListImpl(NodeImpl* node, int type, CacheFactory* factory = 0); + virtual ~NodeListImpl(); + + // DOM methods & attributes for NodeList + virtual unsigned long length() const; + virtual NodeImpl *item ( unsigned long index ) const; + + // Other methods (not part of DOM) + +protected: + virtual unsigned long calcLength(NodeImpl *start) const; + // helper functions for searching all ElementImpls in a tree + + NodeImpl *recursiveItem ( NodeImpl* absStart, NodeImpl *start, unsigned long &offset ) const; + NodeImpl *recursiveItemBack( NodeImpl* absStart, NodeImpl *start, unsigned long &offset ) const; + + // Override this to determine what nodes to return. Set doRecurse to + // false if the children of this node do not need to be entered. + virtual bool nodeMatches( NodeImpl *testNode, bool& doRecurse ) const = 0; + + NodeImpl* m_refNode; + mutable Cache* m_cache; +}; + +class ChildNodeListImpl : public NodeListImpl +{ +public: + + ChildNodeListImpl( NodeImpl *n); + +protected: + virtual bool nodeMatches( NodeImpl *testNode, bool& doRecurse ) const; +}; + + +/** + * NodeList which lists all Nodes in a document with a given tag name + */ +class TagNodeListImpl : public NodeListImpl +{ +public: + TagNodeListImpl( NodeImpl *n, NodeImpl::Id id ); + TagNodeListImpl( NodeImpl *n, const DOMString &namespaceURI, const DOMString &localName ); + + // Other methods (not part of DOM) + +protected: + virtual bool nodeMatches( NodeImpl *testNode, bool& doRecurse ) const; + NodeImpl::Id m_id; + DOMString m_namespaceURI; + DOMString m_localName; + + bool m_matchAllNames; + bool m_matchAllNamespaces; + bool m_namespaceAware; +}; + + +/** + * NodeList which lists all Nodes in a Element with a given "name=" tag + */ +class NameNodeListImpl : public NodeListImpl +{ +public: + NameNodeListImpl( NodeImpl *doc, const DOMString &t ); + + // Other methods (not part of DOM) + +protected: + virtual bool nodeMatches( NodeImpl *testNode, bool& doRecurse ) const; + + DOMString nodeName; +}; + +// Generic NamedNodeMap interface +// Other classes implement this for more specific situations e.g. attributes +// of an element +class NamedNodeMapImpl : public tdehtml::Shared<NamedNodeMapImpl> +{ +public: + NamedNodeMapImpl(); + virtual ~NamedNodeMapImpl(); + + // DOM methods & attributes for NamedNodeMap + virtual NodeImpl *getNamedItem ( NodeImpl::Id id, bool nsAware = false, DOMStringImpl* qName = 0 ) const = 0; + virtual Node removeNamedItem ( NodeImpl::Id id, bool nsAware, DOMStringImpl* qName, int &exceptioncode ) = 0; + virtual Node setNamedItem ( NodeImpl* arg, bool nsAware, DOMStringImpl* qName, int &exceptioncode ) = 0; + + virtual NodeImpl *item ( unsigned long index ) const = 0; + virtual unsigned long length( ) const = 0; + + // Other methods (not part of DOM) + virtual NodeImpl::Id mapId(DOMStringImpl* namespaceURI, + DOMStringImpl* localName, bool readonly) = 0; + virtual bool isReadOnly() { return false; } +}; + +// Generic read-only NamedNodeMap implementation +// Used for e.g. entities and notations in DocumentType. +// You can add nodes using addNode +class GenericRONamedNodeMapImpl : public NamedNodeMapImpl +{ +public: + GenericRONamedNodeMapImpl(DocumentImpl* doc); + virtual ~GenericRONamedNodeMapImpl(); + + // DOM methods & attributes for NamedNodeMap + + virtual NodeImpl *getNamedItem ( NodeImpl::Id id, bool nsAware = false, DOMStringImpl* qName = 0 ) const; + virtual Node removeNamedItem ( NodeImpl::Id id, bool nsAware, DOMStringImpl* qName, int &exceptioncode ); + virtual Node setNamedItem ( NodeImpl* arg, bool nsAware, DOMStringImpl* qName, int &exceptioncode ); + + virtual NodeImpl *item ( unsigned long index ) const; + virtual unsigned long length( ) const; + + // Other methods (not part of DOM) + virtual NodeImpl::Id mapId(DOMStringImpl* namespaceURI, + DOMStringImpl* localName, bool readonly); + + virtual bool isReadOnly() { return true; } + + void addNode(NodeImpl *n); + +protected: + DocumentImpl* m_doc; + TQPtrList<NodeImpl> *m_contents; +}; + +} //namespace +#endif |