79e7ca44231da0417483d95a774ad2728bad2feb
[WebKit-https.git] / WebCore / khtml / xml / dom_nodeimpl.h
1 /*
2  * This file is part of the DOM implementation for KDE.
3  *
4  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
5  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
6  *           (C) 2001 Dirk Mueller (mueller@kde.org)
7  * Copyright (C) 2004 Apple Computer, Inc.
8  *
9  * This library is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Library General Public
11  * License as published by the Free Software Foundation; either
12  * version 2 of the License, or (at your option) any later version.
13  *
14  * This library is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * Library General Public License for more details.
18  *
19  * You should have received a copy of the GNU Library General Public License
20  * along with this library; see the file COPYING.LIB.  If not, write to
21  * the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
22  * Boston, MA 02111-1307, USA.
23  *
24  */
25 #ifndef _DOM_NodeImpl_h_
26 #define _DOM_NodeImpl_h_
27
28 #include "dom/dom_misc.h"
29 #include "dom/dom_string.h"
30 #include "dom/dom_node.h"
31 #include "misc/helper.h"
32 #include "misc/shared.h"
33 #include "dom_atomicstring.h"
34
35 class QPainter;
36 template <class type> class QPtrList;
37 class KHTMLView;
38 class RenderArena;
39 class QRect;
40 class QMouseEvent;
41 class QKeyEvent;
42 class QTextStream;
43 class QStringList;
44
45 namespace khtml {
46     class RenderObject;
47     class RenderStyle;
48 };
49
50 namespace DOM {
51
52 class CSSStyleDeclarationImpl;
53 class DocumentImpl;
54 class ElementImpl;
55 class EventImpl;
56 class NamedNodeMapImpl;
57 class NodeListImpl;
58 class Position;
59 class Range;
60 class RangeImpl;
61 class RegisteredEventListener;
62
63 // The namespace used for XHTML elements
64 #define XHTML_NAMESPACE "http://www.w3.org/1999/xhtml"
65
66 const Q_UINT16 noNamespace = 0;
67 const Q_UINT16 anyNamespace = 1;
68 const Q_UINT16 xhtmlNamespace = 2;
69 const Q_UINT16 anyLocalName = 0;
70
71 const Q_UINT32 namespaceMask = 0xFFFF0000U;
72 const Q_UINT32 localNameMask = 0x0000FFFFU;
73
74 inline Q_UINT16 namespacePart(Q_UINT32 i) { return i >> 16; }
75 inline Q_UINT16 localNamePart(Q_UINT32 i) { return i; }
76 inline Q_UINT32 makeId(Q_UINT16 n, Q_UINT16 l) { return (n << 16) | l; }
77
78 // Can't use makeId here because it results in an "initroutine".
79 const Q_UINT32 anyQName = anyNamespace << 16 | anyLocalName;
80
81 class DocumentPtr : public khtml::Shared<DocumentPtr>
82 {
83 public:
84     DocumentImpl *document() const { return doc; }
85 private:
86     DocumentPtr() { doc = 0; }
87     friend class DocumentImpl;
88     friend class DOMImplementationImpl;
89
90     DocumentImpl *doc;
91 };
92
93 // this class implements nodes, which can have a parent but no children:
94 class NodeImpl : public khtml::TreeShared<NodeImpl>
95 {
96     friend class DocumentImpl;
97 public:
98     NodeImpl(DocumentPtr *doc);
99     virtual ~NodeImpl();
100
101     // DOM methods & attributes for Node
102     virtual DOMString nodeName() const;
103     virtual DOMString nodeValue() const;
104     virtual void setNodeValue( const DOMString &_nodeValue, int &exceptioncode );
105     virtual unsigned short nodeType() const;
106     NodeImpl *parentNode() const { return m_parent; }
107     NodeImpl *previousSibling() const { return m_previous; }
108     NodeImpl *nextSibling() const { return m_next; }
109     virtual NodeListImpl *childNodes();
110     virtual NodeImpl *firstChild() const;
111     virtual NodeImpl *lastChild() const;
112     virtual NodeImpl *insertBefore ( NodeImpl *newChild, NodeImpl *refChild, int &exceptioncode );
113     virtual NodeImpl *replaceChild ( NodeImpl *newChild, NodeImpl *oldChild, int &exceptioncode );
114     virtual NodeImpl *removeChild ( NodeImpl *oldChild, int &exceptioncode );
115     virtual NodeImpl *appendChild ( NodeImpl *newChild, int &exceptioncode );
116     virtual void remove(int &exceptioncode);
117     virtual bool hasChildNodes (  ) const;
118     virtual NodeImpl *cloneNode ( bool deep ) = 0;
119     virtual DOMString localName() const;
120     virtual DOMString prefix() const;
121     virtual void setPrefix(const DOMString &_prefix, int &exceptioncode );
122     void normalize ();
123
124     // Other methods (not part of DOM)
125     virtual bool isElementNode() const { return false; }
126     virtual bool isHTMLElement() const { return false; }
127     virtual bool isAttributeNode() const { return false; }
128     virtual bool isTextNode() const { return false; }
129     virtual bool isDocumentNode() const { return false; }
130     virtual bool isXMLElementNode() const { return false; }
131     bool isBlockFlow() const;
132     
133     // Used by <form> elements to indicate a malformed state of some kind, typically
134     // used to keep from applying the bottom margin of the form.
135     virtual bool isMalformed() { return false; }
136     virtual void setMalformed(bool malformed) {};
137     
138     virtual bool containsOnlyWhitespace() const { return false; }
139     
140     // helper functions not being part of the DOM
141     // Attention: they assume that the caller did the consistency checking!
142     void setPreviousSibling(NodeImpl *previous) { m_previous = previous; }
143     void setNextSibling(NodeImpl *next) { m_next = next; }
144
145     virtual void setFirstChild(NodeImpl *child);
146     virtual void setLastChild(NodeImpl *child);
147
148     bool isAtomicNode() const;
149     NodeImpl *previousNodeConsideringAtomicNodes() const;
150     NodeImpl *nextNodeConsideringAtomicNodes() const;
151     
152     /** (Not part of the official DOM)
153      * Returns the next leaf node.
154      *
155      * Using this function delivers leaf nodes as if the whole DOM tree
156      * were a linear chain of its leaf nodes.
157      * @return next leaf node or 0 if there are no more.
158      */
159     NodeImpl *nextLeafNode() const;
160
161     /** (Not part of the official DOM)
162      * Returns the previous leaf node.
163      *
164      * Using this function delivers leaf nodes as if the whole DOM tree
165      * were a linear chain of its leaf nodes.
166      * @return previous leaf node or 0 if there are no more.
167      */
168     NodeImpl *previousLeafNode() const;
169
170     bool isEditableBlock() const;
171     ElementImpl *enclosingBlockFlowElement() const;
172     ElementImpl *rootEditableElement() const;
173     
174     bool inSameRootEditableElement(NodeImpl *);
175     bool inSameContainingBlockFlowElement(NodeImpl *);
176     
177     // used by the parser. Doesn't do as many error checkings as
178     // appendChild(), and returns the node into which will be parsed next.
179     virtual NodeImpl *addChild(NodeImpl *newChild);
180
181     typedef Q_UINT32 Id;
182     // id() is used to easily and exactly identify a node. It
183     // is optimized for quick comparison and low memory consumption.
184     // its value depends on the owner document of the node and is
185     // categorized in the following way:
186     // 1..ID_LAST_TAG: the node inherits HTMLElementImpl and is
187     //                 part of the HTML namespace.
188     //                 The HTML namespace is either the global
189     //                 one (no namespace) or the XHTML namespace
190     //                 depending on the owner document's doctype
191     // ID_LAST_TAG+1..0xffff: non-HTML elements in the global namespace
192     // others       non-HTML elements in a namespace.
193     //                 the upper 16 bit identify the namespace
194     //                 the lower 16 bit identify the local part of the
195     //                 qualified element name.
196     virtual Id id() const { return 0; };
197 #if APPLE_CHANGES
198     Id identifier() const;
199 #endif
200     enum MouseEventType {
201         MousePress,
202         MouseRelease,
203         MouseClick,
204         MouseDblClick,
205         MouseMove
206     };
207
208     struct MouseEvent
209     {
210         MouseEvent( int _button, MouseEventType _type,
211                     const DOMString &_url = DOMString(), const DOMString& _target = DOMString(),
212                     NodeImpl *_innerNode = 0)
213             {
214                 button = _button; type = _type;
215                 url = _url; target = _target;
216                 innerNode = _innerNode;
217             }
218
219         int button;
220         MouseEventType type;
221         DOMString url; // url under mouse or empty
222         DOMString target;
223         Node innerNode;
224     };
225
226     // for LINK and STYLE
227     virtual void sheetLoaded() {}
228
229     bool hasID() const      { return m_hasId; }
230     bool hasClass() const   { return m_hasClass; }
231     bool hasStyle() const   { return m_hasStyle; }
232     bool active() const     { return m_active; }
233     bool focused() const { return m_focused; }
234     bool attached() const   { return m_attached; }
235     bool changed() const    { return m_changed; }
236     bool hasChangedChild() const { return m_hasChangedChild; }
237     bool hasAnchor() const { return m_hasAnchor; }
238     bool inDocument() const { return m_inDocument; }
239     bool styleElement() const { return m_styleElement; }
240     bool implicitNode() const { return m_implicit; }
241     void setHasID(bool b=true) { m_hasId = b; }
242     void setHasClass(bool b=true) { m_hasClass = b; }
243     void setHasStyle(bool b=true) { m_hasStyle = b; }
244     void setHasChangedChild( bool b = true ) { m_hasChangedChild = b; }
245     void setInDocument(bool b=true) { m_inDocument = b; }
246     virtual void setFocus(bool b=true) { m_focused = b; }
247     virtual void setActive(bool b=true) { m_active = b; }
248     void setChanged(bool b=true);
249
250     unsigned short tabIndex() const { return m_tabIndex; }
251     void setTabIndex(unsigned short _tabIndex) { m_tabIndex = _tabIndex; }
252
253     /**
254         * whether this node can receive the keyboard focus.
255      */
256     virtual bool isFocusable() const;
257     virtual bool isKeyboardFocusable() const;
258     virtual bool isMouseFocusable() const;
259     
260     virtual bool isInline() const;
261     QString startMarkup(const DOM::RangeImpl *range) const;
262     QString endMarkup(void) const;
263     virtual QString toHTML() const;
264     QString recursive_toHTML(bool onlyIncludeChildren=false, QPtrList<NodeImpl> *nodes=NULL) const;
265     static QString recursive_toString(const NodeImpl *startNode, bool onlyIncludeChildren, bool includeSiblings, QPtrList<NodeImpl> *nodes);
266     void recursive_completeURLs(QString baseURL);
267     
268     virtual bool isContentEditable() const;
269     virtual QRect getRect() const;
270
271     enum StyleChange { NoChange, NoInherit, Inherit, Detach, Force };
272     virtual void recalcStyle( StyleChange = NoChange ) {}
273     StyleChange diff( khtml::RenderStyle *s1, khtml::RenderStyle *s2 ) const;
274
275     unsigned long nodeIndex() const;
276     // Returns the document that this node is associated with. This is guaranteed to always be non-null, as opposed to
277     // DOM's ownerDocument() which is null for Document nodes (and sometimes DocumentType nodes).
278     DocumentImpl* getDocument() const { return document->document(); }
279
280     void setDocument(DocumentPtr *doc);
281
282     void addEventListener(int id, EventListener *listener, const bool useCapture);
283     void removeEventListener(int id, EventListener *listener, bool useCapture);
284     void removeHTMLEventListener(int id);
285     void setHTMLEventListener(int id, EventListener *listener);
286     EventListener *getHTMLEventListener(int id);
287
288     bool dispatchEvent(EventImpl *evt, int &exceptioncode, bool tempEvent = false);
289     bool dispatchGenericEvent( EventImpl *evt, int &exceptioncode);
290     bool dispatchHTMLEvent(int _id, bool canBubbleArg, bool cancelableArg);
291     bool dispatchWindowEvent(int _id, bool canBubbleArg, bool cancelableArg);
292     bool dispatchMouseEvent(QMouseEvent *e, int overrideId = 0, int overrideDetail = 0);
293     bool dispatchUIEvent(int _id, int detail = 0);
294     bool dispatchSubtreeModifiedEvent();
295     bool dispatchKeyEvent(QKeyEvent *key);
296
297     void handleLocalEvents(EventImpl *evt, bool useCapture);
298
299     /**
300      * Perform the default action for an event e.g. submitting a form
301      */
302     virtual void defaultEventHandler(EventImpl *evt);
303
304     /**
305      * Used for disabled form elements; if true, prevents mouse events from being dispatched
306      * to event listeners, and prevents DOMActivate events from being sent at all.
307      */
308     virtual bool disabled() const;
309
310     virtual bool isReadOnly();
311     virtual bool childTypeAllowed( unsigned short /*type*/ ) { return false; }
312     virtual unsigned long childNodeCount() const;
313     virtual NodeImpl *childNode(unsigned long index);
314
315     /**
316      * Does a pre-order traversal of the tree to find the node next node after this one. This uses the same order that
317      * the tags appear in the source file.
318      *
319      * @param stayWithin If not null, the traversal will stop once the specified node is reached. This can be used to
320      * restrict traversal to a particular sub-tree.
321      *
322      * @return The next node, in document order
323      *
324      * see @ref traversePreviousNode()
325      */
326     NodeImpl *traverseNextNode(NodeImpl *stayWithin = 0) const;
327     
328     /* Like traverseNextNode, but skips children and starts with the next sibling. */
329     NodeImpl *traverseNextSibling(NodeImpl *stayWithin = 0) const;
330
331     /**
332      * Does a reverse pre-order traversal to find the node that comes before the current one in document order
333      *
334      * see @ref traverseNextNode()
335      */
336     NodeImpl *traversePreviousNode() const;
337
338     /* Like traversePreviousNode, but visits nodes before their children. */
339     NodeImpl *traversePreviousNodePostOrder(NodeImpl *stayWithin = 0) const;
340
341     DocumentPtr *docPtr() const { return document; }
342
343     NodeImpl *previousEditable() const;
344     NodeImpl *nextEditable() const;
345     //bool isEditable() const;
346
347     khtml::RenderObject *renderer() const { return m_render; }
348     khtml::RenderObject *nextRenderer();
349     khtml::RenderObject *previousRenderer();
350     void setRenderer(khtml::RenderObject* renderer) { m_render = renderer; }
351     
352     void checkSetPrefix(const DOMString &_prefix, int &exceptioncode);
353     void checkAddChild(NodeImpl *newChild, int &exceptioncode);
354     bool isAncestor(const NodeImpl *) const;
355     virtual bool childAllowed( NodeImpl *newChild );
356
357     virtual long maxOffset() const;
358     virtual long caretMinOffset() const;
359     virtual long caretMaxOffset() const;
360     virtual unsigned long caretMaxRenderedOffset() const;
361
362 #ifndef NDEBUG
363     virtual void dump(QTextStream *stream, QString ind = "") const;
364 #endif
365
366     // -----------------------------------------------------------------------------
367     // Integration with rendering tree
368
369     /**
370      * Attaches this node to the rendering tree. This calculates the style to be applied to the node and creates an
371      * appropriate RenderObject which will be inserted into the tree (except when the style has display: none). This
372      * makes the node visible in the KHTMLView.
373      */
374     virtual void attach();
375
376     /**
377      * Detaches the node from the rendering tree, making it invisible in the rendered view. This method will remove
378      * the node's rendering object from the rendering tree and delete it.
379      */
380     virtual void detach();
381
382     void createRendererIfNeeded();
383     virtual khtml::RenderStyle *styleForRenderer(khtml::RenderObject *parent);
384     virtual bool rendererIsNeeded(khtml::RenderStyle *);
385     virtual khtml::RenderObject *createRenderer(RenderArena *, khtml::RenderStyle *);
386
387     // -----------------------------------------------------------------------------
388     // Methods for maintaining the state of the element between history navigation
389
390     /**
391      * Indicates whether or not this type of node maintains it's state. If so, the state of the node will be stored when
392      * the user goes to a different page using the state() method, and restored using the restoreState() method if the
393      * user returns (e.g. using the back button). This is used to ensure that user-changeable elements such as form
394      * controls maintain their contents when the user returns to a previous page in the history.
395      */
396     virtual bool maintainsState();
397
398     /**
399      * Returns the state of this node represented as a string. This string will be passed to restoreState() if the user
400      * returns to the page.
401      *
402      * @return State information about the node represented as a string
403      */
404     virtual QString state();
405
406     /**
407      * Sets the state of the element based on strings previously returned by state(). This is used to initialize form
408      * controls with their old values when the user returns to the page in their history.  The receiver
409      * should remove the string from the list that it uses for its restore.
410      *
411      * @param states The strings previously returned by nodes' state methods.
412      */
413     virtual void restoreState(QStringList &stateList);
414
415     // -----------------------------------------------------------------------------
416     // Notification of document stucture changes
417
418     /**
419      * Notifies the node that it has been inserted into the document. This is called during document parsing, and also
420      * when a node is added through the DOM methods insertBefore(), appendChild() or replaceChild(). Note that this only
421      * happens when the node becomes part of the document tree, i.e. only when the document is actually an ancestor of
422      * the node. The call happens _after_ the node has been added to the tree.
423      *
424      * This is similar to the DOMNodeInsertedIntoDocument DOM event, but does not require the overhead of event
425      * dispatching.
426      */
427     virtual void insertedIntoDocument();
428
429     /**
430      * Notifies the node that it is no longer part of the document tree, i.e. when the document is no longer an ancestor
431      * node.
432      *
433      * This is similar to the DOMNodeRemovedFromDocument DOM event, but does not require the overhead of event
434      * dispatching, and is called _after_ the node is removed from the tree.
435      */
436     virtual void removedFromDocument();
437
438     /**
439      * Notifies the node that it's list of children have changed (either by adding or removing child nodes), or a child
440      * node that is of the type CDATA_SECTION_NODE, TEXT_NODE or COMMENT_NODE has changed it's value.
441      */
442     virtual void childrenChanged();
443
444     virtual DOMString toString() const = 0;
445     
446 #ifndef NDEBUG
447     virtual void formatForDebugger(char *buffer, unsigned length) const;
448 #endif
449
450 private: // members
451     DocumentPtr *document;
452     NodeImpl *m_previous;
453     NodeImpl *m_next;
454 protected:
455     khtml::RenderObject *m_render;
456     QPtrList<RegisteredEventListener> *m_regdListeners;
457
458     unsigned short m_tabIndex : 15;
459     bool m_hasTabIndex  : 1;
460
461     bool m_hasId : 1;
462     bool m_hasClass : 1;
463     bool m_hasStyle : 1;
464     bool m_attached : 1;
465     bool m_changed : 1;
466     bool m_hasChangedChild : 1;
467     bool m_inDocument : 1;
468
469     bool m_hasAnchor : 1;
470     bool m_specified : 1; // used in AttrImpl. Accessor functions there
471     bool m_focused : 1;
472     bool m_active : 1;
473     bool m_styleElement : 1; // contains stylesheet text
474     bool m_implicit : 1; // implicitely generated by the parser
475
476     // 3 bits unused
477 };
478
479 // this is the full Node Implementation with parents and children.
480 class NodeBaseImpl : public NodeImpl
481 {
482 public:
483     NodeBaseImpl(DocumentPtr *doc);
484     virtual ~NodeBaseImpl();
485
486     // DOM methods overridden from  parent classes
487     virtual NodeImpl *firstChild() const;
488     virtual NodeImpl *lastChild() const;
489     virtual NodeImpl *insertBefore ( NodeImpl *newChild, NodeImpl *refChild, int &exceptioncode );
490     virtual NodeImpl *replaceChild ( NodeImpl *newChild, NodeImpl *oldChild, int &exceptioncode );
491     virtual NodeImpl *removeChild ( NodeImpl *oldChild, int &exceptioncode );
492     virtual NodeImpl *appendChild ( NodeImpl *newChild, int &exceptioncode );
493     virtual bool hasChildNodes (  ) const;
494
495     // Other methods (not part of DOM)
496     void removeChildren();
497     void cloneChildNodes(NodeImpl *clone);
498
499     virtual void setFirstChild(NodeImpl *child);
500     virtual void setLastChild(NodeImpl *child);
501     virtual NodeImpl *addChild(NodeImpl *newChild);
502     virtual void attach();
503     virtual void detach();
504
505     virtual NodeListImpl *getElementsByTagNameNS ( DOMStringImpl* namespaceURI,
506                                                    DOMStringImpl* localName );
507
508     virtual QRect getRect() const;
509     bool getUpperLeftCorner(int &xPos, int &yPos) const;
510     bool getLowerRightCorner(int &xPos, int &yPos) const;
511
512     virtual void setFocus(bool=true);
513     virtual void setActive(bool=true);
514     virtual unsigned long childNodeCount() const;
515     virtual NodeImpl *childNode(unsigned long index);
516
517     virtual void insertedIntoDocument();
518     virtual void removedFromDocument();
519     
520     // check for being (grand-..)father:
521     bool checkNoOwner( NodeImpl *other, int &exceptioncode );
522
523 //protected:
524     NodeImpl *_first;
525     NodeImpl *_last;
526
527     // helper functions for inserting children:
528
529     // ### this should vanish. do it in dom/ !
530     // check for same source document:
531     bool checkSameDocument( NodeImpl *newchild, int &exceptioncode );
532     // check for being child:
533     bool checkIsChild( NodeImpl *oldchild, int &exceptioncode );
534     // ###
535
536     // find out if a node is allowed to be our child
537     void dispatchChildInsertedEvents( NodeImpl *child, int &exceptioncode );
538     void dispatchChildRemovalEvents( NodeImpl *child, int &exceptioncode );
539 };
540
541 // --------------------------------------------------------------------------
542 class Node;
543 class NodeImpl;
544
545 class NodeListImpl : public khtml::Shared<NodeListImpl>
546 {
547 public:
548     virtual ~NodeListImpl() {}
549
550     // DOM methods & attributes for NodeList
551     virtual unsigned long length() const;
552     virtual NodeImpl *item ( unsigned long index ) const;
553
554     // Other methods (not part of DOM)
555
556 #if APPLE_CHANGES
557     static NodeList createInstance(NodeListImpl *impl);
558 #endif
559 protected:
560     // helper functions for searching all ElementImpls in a tree
561     unsigned long recursiveLength(NodeImpl *start) const;
562     NodeImpl *recursiveItem ( NodeImpl *start, unsigned long &offset ) const;
563     virtual bool nodeMatches( NodeImpl *testNode ) const = 0;
564 };
565
566 class ChildNodeListImpl : public NodeListImpl
567 {
568 public:
569     ChildNodeListImpl( NodeImpl *n);
570     virtual ~ChildNodeListImpl();
571
572     // DOM methods overridden from  parent classes
573
574     virtual unsigned long length() const;
575     virtual NodeImpl *item ( unsigned long index ) const;
576
577 protected:
578     virtual bool nodeMatches( NodeImpl *testNode ) const;
579
580     NodeImpl *refNode;
581 };
582
583
584 /**
585  * NodeList which lists all Nodes in a document with a given tag name
586  */
587 class TagNodeListImpl : public NodeListImpl
588 {
589 public:
590     TagNodeListImpl( NodeImpl *n, NodeImpl::Id tagId, NodeImpl::Id tagIdMask );
591     virtual ~TagNodeListImpl();
592
593     // DOM methods overridden from  parent classes
594
595     virtual unsigned long length() const;
596     virtual NodeImpl *item ( unsigned long index ) const;
597
598     // Other methods (not part of DOM)
599
600 protected:
601     virtual bool nodeMatches( NodeImpl *testNode ) const;
602
603     NodeImpl *refNode;
604     NodeImpl::Id m_id;
605     NodeImpl::Id m_idMask;
606 };
607
608
609 /**
610  * NodeList which lists all Nodes in a Element with a given "name=" tag
611  */
612 class NameNodeListImpl : public NodeListImpl
613 {
614 public:
615     NameNodeListImpl( NodeImpl *doc, const DOMString &t );
616     virtual ~NameNodeListImpl();
617
618     // DOM methods overridden from  parent classes
619
620     virtual unsigned long length() const;
621     virtual NodeImpl *item ( unsigned long index ) const;
622
623     // Other methods (not part of DOM)
624
625 protected:
626     virtual bool nodeMatches( NodeImpl *testNode ) const;
627
628     NodeImpl *refNode;
629     DOMString nodeName;
630 };
631
632
633 // Generic NamedNodeMap interface
634 // Other classes implement this for more specific situations e.g. attributes
635 // of an element
636 class NamedNodeMapImpl : public khtml::Shared<NamedNodeMapImpl>
637 {
638 public:
639     NamedNodeMapImpl();
640     virtual ~NamedNodeMapImpl();
641
642     // DOM methods & attributes for NamedNodeMap
643     virtual NodeImpl *getNamedItem ( NodeImpl::Id id ) const = 0;
644     virtual Node removeNamedItem ( NodeImpl::Id id, int &exceptioncode ) = 0;
645     virtual Node setNamedItem ( NodeImpl* arg, int &exceptioncode ) = 0;
646
647     virtual NodeImpl *item ( unsigned long index ) const = 0;
648     virtual unsigned long length(  ) const = 0;
649
650     // Other methods (not part of DOM)
651     virtual NodeImpl::Id mapId(const DOMString& namespaceURI,  const DOMString& localName,  bool readonly) = 0;
652     virtual bool isReadOnly() { return false; }
653
654 #if APPLE_CHANGES
655     static NamedNodeMap createInstance(NamedNodeMapImpl *impl);
656 #endif
657 };
658
659
660 // ### fixme
661 #if 0
662 // Generic read-only NamedNodeMap implementation
663 // You can add items using the internal function addItem()
664 class GenericRONamedNodeMapImpl : public NamedNodeMapImpl
665 {
666 public:
667     GenericRONamedNodeMapImpl(DocumentPtr* doc);
668     virtual ~GenericRONamedNodeMapImpl();
669
670     // DOM methods & attributes for NamedNodeMap
671
672     virtual NodeImpl *getNamedItem ( const DOMString &name, int &exceptioncode ) const;
673     virtual Node setNamedItem ( const Node &arg, int &exceptioncode );
674     virtual Node removeNamedItem ( const DOMString &name, int &exceptioncode );
675     virtual NodeImpl *item ( unsigned long index ) const;
676     virtual unsigned long length(  ) const;
677     virtual NodeImpl *getNamedItemNS( const DOMString &namespaceURI, const DOMString &localName,
678                                       int &exceptioncode ) const;
679     virtual NodeImpl *setNamedItemNS( NodeImpl *arg, int &exceptioncode );
680     virtual NodeImpl *removeNamedItemNS( const DOMString &namespaceURI, const DOMString &localName,
681                                          int &exceptioncode );
682
683     // Other methods (not part of DOM)
684
685     virtual bool isReadOnly() { return true; }
686
687     void addNode(NodeImpl *n);
688
689 protected:
690     DocumentImpl* m_doc;
691     QPtrList<NodeImpl> *m_contents;
692 };
693 #endif
694
695 }; //namespace
696 #endif