WebCore/dom/Node.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, 2005, 2006 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
  26 #ifndef DOM_NodeImpl_h_
  27 #define DOM_NodeImpl_h_
  28
  29 #include "DocPtr.h"
  30 #include "PlatformString.h"
  31 #include "DeprecatedString.h"
  32 #include <wtf/Assertions.h>
  33 #include <wtf/HashSet.h>
  34 #include <wtf/PassRefPtr.h>
  35
  36 namespace WebCore {
  37
  38 class AtomicString;
  39 class ContainerNode;
  40 class Document;
  41 class Element;
  42 class Event;
  43 class EventListener;
  44 class IntRect;
  45 class KeyboardEvent;
  46 class NamedAttrMap;
  47 class NodeList;
  48 class PlatformKeyboardEvent;
  49 class PlatformMouseEvent;
  50 class PlatformWheelEvent;
  51 class QualifiedName;
  52 class RegisteredEventListener;
  53 class RenderArena;
  54 class RenderObject;
  55 class RenderStyle;
  56 class TextStream;
  57
  58 typedef int ExceptionCode;
  59
  60 // this class implements nodes, which can have a parent but no children:
  61 class Node : public TreeShared<Node> {
  62     friend class Document;
  63 public:
  64     enum NodeType {
  65         ELEMENT_NODE = 1,
  66         ATTRIBUTE_NODE = 2,
  67         TEXT_NODE = 3,
  68         CDATA_SECTION_NODE = 4,
  69         ENTITY_REFERENCE_NODE = 5,
  70         ENTITY_NODE = 6,
  71         PROCESSING_INSTRUCTION_NODE = 7,
  72         COMMENT_NODE = 8,
  73         DOCUMENT_NODE = 9,
  74         DOCUMENT_TYPE_NODE = 10,
  75         DOCUMENT_FRAGMENT_NODE = 11,
  76         NOTATION_NODE = 12,
  77         XPATH_NAMESPACE_NODE = 13
  78     };
  79
  80     Node(Document*);
  81     virtual ~Node();
  82
  83     // DOM methods & attributes for Node
  84
  85     virtual bool hasTagName(const QualifiedName&) const { return false; }
  86     virtual String nodeName() const = 0;
  87     virtual String nodeValue() const;
  88     virtual void setNodeValue(const String&, ExceptionCode&);
  89     virtual NodeType nodeType() const = 0;
  90     Node* parentNode() const { return parent(); }
  91     Node* previousSibling() const { return m_previous; }
  92     Node* nextSibling() const { return m_next; }
  93     virtual PassRefPtr<NodeList> childNodes();
  94     virtual Node* firstChild() const;
  95     virtual Node* lastChild() const;
  96     virtual bool hasAttributes() const;
  97     virtual NamedAttrMap* attributes() const;
  98
  99     // These should all actually return a node, but this is only important for language bindings,
 100     // which will already know and hold a ref on the right node to return. Returning bool allows
 101     // these methods to be more efficient since they don't need to return a ref
 102     virtual bool insertBefore(PassRefPtr<Node> newChild, Node* refChild, ExceptionCode&);
 103     virtual bool replaceChild(PassRefPtr<Node> newChild, Node* oldChild, ExceptionCode&);
 104     virtual bool removeChild(Node* child, ExceptionCode&);
 105     virtual bool appendChild(PassRefPtr<Node> newChild, ExceptionCode&);
 106
 107     virtual void remove(ExceptionCode&);
 108     virtual bool hasChildNodes() const;
 109     virtual PassRefPtr<Node> cloneNode(bool deep) = 0;
 110     virtual const AtomicString& localName() const;
 111     virtual const AtomicString& namespaceURI() const;
 112     virtual const AtomicString& prefix() const;
 113     virtual void setPrefix(const AtomicString&, ExceptionCode&);
 114     void normalize();
 115     static bool isSupported(const String& feature, const String& version);
 116
 117     bool isSameNode(Node* other) const { return this == other; }
 118     bool isEqualNode(Node*) const;
 119     bool isDefaultNamespace(const String& namespaceURI) const;
 120     String lookupPrefix(const String& namespaceURI) const;
 121     String lookupNamespaceURI(const String& prefix) const;
 122     String lookupNamespacePrefix(const String& namespaceURI, const Element* originalElement) const;
 123
 124     String textContent(bool convertBRsToNewlines = false) const;
 125     void setTextContent(const String&, ExceptionCode&);
 126
 127     Node* lastDescendant() const;
 128     Node* firstDescendant() const;
 129
 130     // Other methods (not part of DOM)
 131
 132     virtual bool isElementNode() const { return false; }
 133     virtual bool isHTMLElement() const { return false; }
 134 #ifdef SVG_SUPPORT
 135     virtual bool isSVGElement() const { return false; }
 136 #endif
 137     virtual bool isStyledElement() const { return false; }
 138     virtual bool isAttributeNode() const { return false; }
 139     virtual bool isTextNode() const { return false; }
 140     virtual bool isCommentNode() const { return false; }
 141     virtual bool isDocumentNode() const { return false; }
 142     virtual bool isEventTargetNode() const { return false; }
 143     virtual bool isShadowNode() const { return false; }
 144     virtual Node* shadowParentNode() { return 0; }
 145     Node* shadowAncestorNode();
 146     bool isBlockFlow() const;
 147     bool isBlockFlowOrBlockTable() const;
 148
 149     // Used by <form> elements to indicate a malformed state of some kind, typically
 150     // used to keep from applying the bottom margin of the form.
 151     virtual bool isMalformed() { return false; }
 152     virtual void setMalformed(bool malformed) { }
 153
 154     // These low-level calls give the caller responsibility for maintaining the integrity of the tree.
 155     void setPreviousSibling(Node* previous) { m_previous = previous; }
 156     void setNextSibling(Node* next) { m_next = next; }
 157
 158     // FIXME: These two functions belong in editing -- "atomic node" is an editing concept.
 159     Node* previousNodeConsideringAtomicNodes() const;
 160     Node* nextNodeConsideringAtomicNodes() const;
 161
 162     /** (Not part of the official DOM)
 163      * Returns the next leaf node.
 164      *
 165      * Using this function delivers leaf nodes as if the whole DOM tree were a linear chain of its leaf nodes.
 166      * @return next leaf node or 0 if there are no more.
 167      */
 168     Node* nextLeafNode() const;
 169
 170     /** (Not part of the official DOM)
 171      * Returns the previous leaf node.
 172      *
 173      * Using this function delivers leaf nodes as if the whole DOM tree were a linear chain of its leaf nodes.
 174      * @return previous leaf node or 0 if there are no more.
 175      */
 176     Node* previousLeafNode() const;
 177
 178     bool isEditableBlock() const;
 179     Element* enclosingBlockFlowElement() const;
 180     Element* enclosingBlockFlowOrTableElement() const;
 181     Element* enclosingInlineElement() const;
 182     Element* rootEditableElement() const;
 183
 184     bool inSameContainingBlockFlowElement(Node*);
 185
 186     // Used by the parser. Checks against the DTD, unlike DOM operations like appendChild().
 187     // Also does not dispatch DOM mutation events.
 188     // Returns the appropriate container node for future insertions as you parse, or 0 for failure.
 189     virtual ContainerNode* addChild(PassRefPtr<Node>);
 190
 191     // Called by the parser when this element's close tag is reached,
 192     // signalling that all child tags have been parsed and added.
 193     // This is needed for <applet> and <object> elements, which can't lay themselves out
 194     // until they know all of their nested <param>s. [Radar 3603191, 4040848].
 195     // Also used for script elements and some SVG elements for similar purposes,
 196     // but making parsing a special case in this respect should be avoided if possible.
 197     virtual void closeRenderer() { }
 198
 199     // Called by the frame right before dispatching an unloadEvent. [Radar 4532113]
 200     // This is needed for HTMLInputElements to tell the frame that it is done editing
 201     // (sends textFieldDidEndEditing notification)
 202     virtual void aboutToUnload() { }
 203
 204     // For <link> and <style> elements.
 205     virtual void sheetLoaded() { }
 206
 207     bool hasID() const { return m_hasId; }
 208     bool hasClass() const { return m_hasClass; }
 209     bool hasStyle() const { return m_hasStyle; }
 210     bool active() const { return m_active; }
 211     bool inActiveChain() const { return m_inActiveChain; }
 212     bool hovered() const { return m_hovered; }
 213     bool focused() const { return m_focused; }
 214     bool attached() const { return m_attached; }
 215     void setAttached(bool b = true) { m_attached = b; }
 216     bool changed() const { return m_changed; }
 217     bool hasChangedChild() const { return m_hasChangedChild; }
 218     bool isLink() const { return m_isLink; }
 219     bool styleElement() const { return m_styleElement; }
 220     bool implicitNode() const { return m_implicit; }
 221     void setHasID(bool b = true) { m_hasId = b; }
 222     void setHasClass(bool b = true) { m_hasClass = b; }
 223     void setHasStyle(bool b = true) { m_hasStyle = b; }
 224     void setHasChangedChild( bool b = true ) { m_hasChangedChild = b; }
 225     void setInDocument(bool b = true) { m_inDocument = b; }
 226     void setInActiveChain(bool b = true) { m_inActiveChain = b; }
 227     void setChanged(bool b = true);
 228
 229     virtual void setFocus(bool b = true) { m_focused = b; }
 230     virtual void setActive(bool b = true, bool pause=false) { m_active = b; }
 231     virtual void setHovered(bool b = true) { m_hovered = b; }
 232
 233     unsigned short tabIndex() const { return m_tabIndex; }
 234     void setTabIndex(unsigned short i) { m_tabIndex = i; }
 235
 236     /**
 237      * Whether this node can receive the keyboard focus.
 238      */
 239     virtual bool supportsFocus() const { return isFocusable(); }
 240     virtual bool isFocusable() const;
 241     virtual bool isKeyboardFocusable(KeyboardEvent*) const;
 242     virtual bool isMouseFocusable() const;
 243
 244     virtual bool isControl() const { return false; } // Eventually the notion of what is a control will be extensible.
 245     virtual bool isEnabled() const { return true; }
 246     virtual bool isChecked() const { return false; }
 247     virtual bool isIndeterminate() const { return false; }
 248     virtual bool isReadOnlyControl() const { return false; }
 249
 250     virtual bool isContentEditable() const;
 251     virtual bool isContentRichlyEditable() const;
 252     virtual IntRect getRect() const;
 253
 254     enum StyleChange { NoChange, NoInherit, Inherit, Detach, Force };
 255     virtual void recalcStyle(StyleChange = NoChange) { }
 256     StyleChange diff(RenderStyle*, RenderStyle*) const;
 257
 258     unsigned nodeIndex() const;
 259
 260     // Returns the DOM ownerDocument attribute. This method never returns NULL, except in the case
 261     // of (1) a Document node or (2) a DocumentType node that is not used with any Document yet.
 262     virtual Document* ownerDocument() const;
 263
 264     // Returns the document associated with this node. This method never returns NULL, except in the case
 265     // of a DocumentType node that is not used with any Document yet. A Document node returns itself.
 266     Document* document() const
 267     {
 268       ASSERT(this);
 269       ASSERT(m_document || nodeType() == DOCUMENT_TYPE_NODE && !inDocument());
 270       return m_document.get();
 271     }
 272     void setDocument(Document*);
 273
 274     // Returns true if this node is associated with a document and is in its associated document's
 275     // node tree, false otherwise.
 276     bool inDocument() const
 277     {
 278       ASSERT(m_document || !m_inDocument);
 279       return m_inDocument;
 280     }
 281
 282     virtual bool isReadOnlyNode();
 283     virtual bool childTypeAllowed(NodeType) { return false; }
 284     virtual unsigned childNodeCount() const;
 285     virtual Node* childNode(unsigned index) const;
 286
 287     /**
 288      * Does a pre-order traversal of the tree to find the node next node after this one. This uses the same order that
 289      * the tags appear in the source file.
 290      *
 291      * @param stayWithin If not null, the traversal will stop once the specified node is reached. This can be used to
 292      * restrict traversal to a particular sub-tree.
 293      *
 294      * @return The next node, in document order
 295      *
 296      * see @ref traversePreviousNode()
 297      */
 298     Node* traverseNextNode(const Node* stayWithin = 0) const;
 299
 300     /* Like traverseNextNode, but skips children and starts with the next sibling. */
 301     Node* traverseNextSibling(const Node* stayWithin = 0) const;
 302
 303     /**
 304      * Does a reverse pre-order traversal to find the node that comes before the current one in document order
 305      *
 306      * see @ref traverseNextNode()
 307      */
 308     Node* traversePreviousNode(const Node * stayWithin = 0) const;
 309
 310     /* Like traversePreviousNode, but visits nodes before their children. */
 311     Node* traversePreviousNodePostOrder(const Node *stayWithin = 0) const;
 312
 313     /**
 314      * Finds previous or next editable leaf node.
 315      */
 316     Node* previousEditable() const;
 317     Node* nextEditable() const;
 318     Node* nextEditable(int offset) const;
 319
 320     RenderObject* renderer() const { return m_renderer; }
 321     RenderObject* nextRenderer();
 322     RenderObject* previousRenderer();
 323     void setRenderer(RenderObject* renderer) { m_renderer = renderer; }
 324
 325     void checkSetPrefix(const AtomicString& prefix, ExceptionCode&);
 326     bool isDescendantOf(const Node*) const;
 327
 328     // These two methods are mutually exclusive.  The former is used to do strict error-checking
 329     // when adding children via the public DOM API (e.g., appendChild()).  The latter is called only when parsing,
 330     // to sanity-check against the DTD for error recovery.
 331     void checkAddChild(Node* newChild, ExceptionCode&); // Error-checking when adding via the DOM API
 332     virtual bool childAllowed(Node* newChild);          // Error-checking during parsing that checks the DTD
 333
 334     // Used to determine whether range offsets use characters or node indices.
 335     virtual bool offsetInCharacters() const;
 336
 337     // FIXME: These next 7 functions are mostly editing-specific and should be moved out.
 338     virtual int maxOffset() const;
 339     virtual int caretMinOffset() const;
 340     virtual int caretMaxOffset() const;
 341     virtual unsigned caretMaxRenderedOffset() const;
 342     virtual int previousOffset(int current) const;
 343     virtual int nextOffset(int current) const;
 344
 345 #ifndef NDEBUG
 346     virtual void dump(TextStream*, DeprecatedString indent = "") const;
 347 #endif
 348
 349     // -----------------------------------------------------------------------------
 350     // Integration with rendering tree
 351
 352     /**
 353      * Attaches this node to the rendering tree. This calculates the style to be applied to the node and creates an
 354      * appropriate RenderObject which will be inserted into the tree (except when the style has display: none). This
 355      * makes the node visible in the FrameView.
 356      */
 357     virtual void attach();
 358
 359     /**
 360      * Detaches the node from the rendering tree, making it invisible in the rendered view. This method will remove
 361      * the node's rendering object from the rendering tree and delete it.
 362      */
 363     virtual void detach();
 364
 365     virtual void willRemove();
 366     void createRendererIfNeeded();
 367     virtual RenderStyle* styleForRenderer(RenderObject* parent);
 368     virtual bool rendererIsNeeded(RenderStyle*);
 369 #ifdef SVG_SUPPORT
 370     virtual bool childShouldCreateRenderer(Node*) const { return true; }
 371 #endif
 372     virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);
 373
 374     // Wrapper for nodes that don't have a renderer, but still cache the style (like HTMLOptionElement).
 375     virtual RenderStyle* renderStyle() const;
 376     virtual void setRenderStyle(RenderStyle*);
 377
 378     // -----------------------------------------------------------------------------
 379     // Notification of document structure changes
 380
 381     /**
 382      * Notifies the node that it has been inserted into the document. This is called during document parsing, and also
 383      * when a node is added through the DOM methods insertBefore(), appendChild() or replaceChild(). Note that this only
 384      * happens when the node becomes part of the document tree, i.e. only when the document is actually an ancestor of
 385      * the node. The call happens _after_ the node has been added to the tree.
 386      *
 387      * This is similar to the DOMNodeInsertedIntoDocument DOM event, but does not require the overhead of event
 388      * dispatching.
 389      */
 390     virtual void insertedIntoDocument();
 391
 392     /**
 393      * Notifies the node that it is no longer part of the document tree, i.e. when the document is no longer an ancestor
 394      * node.
 395      *
 396      * This is similar to the DOMNodeRemovedFromDocument DOM event, but does not require the overhead of event
 397      * dispatching, and is called _after_ the node is removed from the tree.
 398      */
 399     virtual void removedFromDocument();
 400
 401     // These functions are called whenever you are connected or disconnected from a tree.  That tree may be the main
 402     // document tree, or it could be another disconnected tree.  Override these functions to do any work that depends
 403     // on connectedness to some ancestor (e.g., an ancestor <form> for example).
 404     virtual void insertedIntoTree(bool deep) { }
 405     virtual void removedFromTree(bool deep) { }
 406
 407     /**
 408      * Notifies the node that it's list of children have changed (either by adding or removing child nodes), or a child
 409      * node that is of the type CDATA_SECTION_NODE, TEXT_NODE or COMMENT_NODE has changed its value.
 410      */
 411     virtual void childrenChanged();
 412
 413     virtual String toString() const = 0;
 414
 415 #ifndef NDEBUG
 416     virtual void formatForDebugger(char* buffer, unsigned length) const;
 417
 418     void showNode(const char* prefix = "") const;
 419     void showTreeForThis() const;
 420     void showTreeAndMark(const Node* markedNode1, const char* markedLabel1, const Node* markedNode2 = 0, const char* markedLabel2 = 0) const;
 421 #endif
 422
 423     void registerNodeList(NodeList*);
 424     void unregisterNodeList(NodeList*);
 425     void notifyNodeListsChildrenChanged();
 426     void notifyLocalNodeListsChildrenChanged();
 427     void notifyNodeListsAttributeChanged();
 428     void notifyLocalNodeListsAttributeChanged();
 429
 430     PassRefPtr<NodeList> getElementsByTagName(const String&);
 431     PassRefPtr<NodeList> getElementsByTagNameNS(const String& namespaceURI, const String& localName);
 432
 433 private: // members
 434     DocPtr<Document> m_document;
 435     Node* m_previous;
 436     Node* m_next;
 437     RenderObject* m_renderer;
 438
 439 protected:
 440     typedef HashSet<NodeList*> NodeListSet;
 441     NodeListSet* m_nodeLists;
 442
 443     unsigned short m_tabIndex : 15;
 444     bool m_hasTabIndex : 1;
 445
 446     bool m_hasId : 1;
 447     bool m_hasClass : 1;
 448     bool m_hasStyle : 1;
 449     bool m_attached : 1;
 450     bool m_changed : 1;
 451     bool m_hasChangedChild : 1;
 452     bool m_inDocument : 1;
 453
 454     bool m_isLink : 1;
 455     bool m_specified : 1; // used in Attr; accessor functions there
 456     bool m_focused : 1;
 457     bool m_active : 1;
 458     bool m_hovered : 1;
 459     bool m_inActiveChain : 1;
 460     bool m_styleElement : 1; // contains stylesheet text
 461     bool m_implicit : 1; // implicitly generated by the parser
 462
 463     bool m_inDetach : 1;
 464
 465 private:
 466     Element* ancestorElement() const;
 467 };
 468
 469 } //namespace
 470
 471 #ifndef NDEBUG
 472 // Outside the WebCore namespace for ease of invocation from gdb.
 473 void showTree(const WebCore::Node*);
 474 #endif
 475
 476 #endif