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