ebf7df4f30d6a600d7e3e43403170bc528255aad
[WebKit-https.git] / 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 DeprecatedStringList;
41 class Document;
42 class Element;
43 class Event;
44 class EventListener;
45 class IntRect;
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 #if 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 inSameRootEditableElement(Node*);
185     bool inSameContainingBlockFlowElement(Node*);
186     
187     // Used by the parser. Checks against the DTD, unlike DOM operations like appendChild().
188     // Also does not dispatch DOM mutation events.
189     // Returns the appropriate container node for future insertions as you parse, or 0 for failure.
190     virtual ContainerNode* addChild(PassRefPtr<Node>);
191
192     // Called by the parser when this element's close tag is reached,
193     // signalling that all child tags have been parsed and added.
194     // This is needed for <applet> and <object> elements, which can't lay themselves out
195     // until they know all of their nested <param>s. [Radar 3603191, 4040848].
196     // Also used for script elements and some SVG elements for similar purposes,
197     // but making parsing a special case in this respect should be avoided if possible.
198     virtual void closeRenderer() { }
199
200     // For <link> and <style> elements.
201     virtual void sheetLoaded() { }
202
203     bool hasID() const { return m_hasId; }
204     bool hasClass() const { return m_hasClass; }
205     bool hasStyle() const { return m_hasStyle; }
206     bool active() const { return m_active; }
207     bool inActiveChain() const { return m_inActiveChain; }
208     bool hovered() const { return m_hovered; }
209     bool focused() const { return m_focused; }
210     bool attached() const { return m_attached; }
211     void setAttached(bool b = true) { m_attached = b; }
212     bool changed() const { return m_changed; }
213     bool hasChangedChild() const { return m_hasChangedChild; }
214     bool isLink() const { return m_isLink; }
215     bool styleElement() const { return m_styleElement; }
216     bool implicitNode() const { return m_implicit; }
217     void setHasID(bool b = true) { m_hasId = b; }
218     void setHasClass(bool b = true) { m_hasClass = b; }
219     void setHasStyle(bool b = true) { m_hasStyle = b; }
220     void setHasChangedChild( bool b = true ) { m_hasChangedChild = b; }
221     void setInDocument(bool b = true) { m_inDocument = b; }
222     void setInActiveChain(bool b = true) { m_inActiveChain = b; }
223     void setChanged(bool b = true);
224
225     virtual void setFocus(bool b = true) { m_focused = b; }
226     virtual void setActive(bool b = true, bool pause=false) { m_active = b; }
227     virtual void setHovered(bool b = true) { m_hovered = b; }
228
229     unsigned short tabIndex() const { return m_tabIndex; }
230     void setTabIndex(unsigned short i) { m_tabIndex = i; }
231
232     /**
233      * Whether this node can receive the keyboard focus.
234      */
235     virtual bool isFocusable() const;
236     virtual bool isKeyboardFocusable() const;
237     virtual bool isMouseFocusable() const;
238
239     virtual bool isControl() const { return false; } // Eventually the notion of what is a control will be extensible.
240     virtual bool isEnabled() const { return true; }
241     virtual bool isChecked() const { return false; }
242     virtual bool isIndeterminate() const { return false; }
243     virtual bool isReadOnlyControl() const { return false; }
244
245     virtual bool isContentEditable() const;
246     virtual bool isContentRichlyEditable() const;
247     virtual IntRect getRect() const;
248
249     enum StyleChange { NoChange, NoInherit, Inherit, Detach, Force };
250     virtual void recalcStyle(StyleChange = NoChange) { }
251     StyleChange diff(RenderStyle*, RenderStyle*) const;
252
253     unsigned nodeIndex() const;
254
255     // Returns the DOM ownerDocument attribute. This method never returns NULL, except in the case 
256     // of (1) a Document node or (2) a DocumentType node that is not used with any Document yet. 
257     virtual Document* ownerDocument() const;
258
259     // Returns the document associated with this node. This method never returns NULL, except in the case 
260     // of a DocumentType node that is not used with any Document yet. A Document node returns itself.
261     Document* document() const 
262     { 
263       ASSERT(m_document || nodeType() == DOCUMENT_TYPE_NODE && !inDocument());
264       return m_document.get(); 
265     }
266     void setDocument(Document*);
267
268     // Returns true if this node is associated with a document and is in its associated document's
269     // node tree, false otherwise.
270     bool inDocument() const 
271     { 
272       ASSERT(m_document || !m_inDocument);
273       return m_inDocument; 
274     }
275     
276     virtual bool isReadOnlyNode();
277     virtual bool childTypeAllowed(NodeType) { return false; }
278     virtual unsigned childNodeCount() const;
279     virtual Node* childNode(unsigned index) const;
280
281     /**
282      * Does a pre-order traversal of the tree to find the node next node after this one. This uses the same order that
283      * the tags appear in the source file.
284      *
285      * @param stayWithin If not null, the traversal will stop once the specified node is reached. This can be used to
286      * restrict traversal to a particular sub-tree.
287      *
288      * @return The next node, in document order
289      *
290      * see @ref traversePreviousNode()
291      */
292     Node* traverseNextNode(const Node* stayWithin = 0) const;
293     
294     /* Like traverseNextNode, but skips children and starts with the next sibling. */
295     Node* traverseNextSibling(const Node* stayWithin = 0) const;
296
297     /**
298      * Does a reverse pre-order traversal to find the node that comes before the current one in document order
299      *
300      * see @ref traverseNextNode()
301      */
302     Node* traversePreviousNode(const Node * stayWithin = 0) const;
303
304     /* Like traversePreviousNode, but visits nodes before their children. */
305     Node* traversePreviousNodePostOrder(const Node *stayWithin = 0) const;
306
307     /**
308      * Finds previous or next editable leaf node.
309      */
310     Node* previousEditable() const;
311     Node* nextEditable() const;
312     Node* nextEditable(int offset) const;
313
314     RenderObject* renderer() const { return m_renderer; }
315     RenderObject* nextRenderer();
316     RenderObject* previousRenderer();
317     void setRenderer(RenderObject* renderer) { m_renderer = renderer; }
318     
319     void checkSetPrefix(const AtomicString& prefix, ExceptionCode&);
320     bool isAncestor(const Node*) const;
321
322     // These two methods are mutually exclusive.  The former is used to do strict error-checking
323     // when adding children via the public DOM API (e.g., appendChild()).  The latter is called only when parsing, 
324     // to sanity-check against the DTD for error recovery.
325     void checkAddChild(Node* newChild, ExceptionCode&); // Error-checking when adding via the DOM API
326     virtual bool childAllowed(Node* newChild);          // Error-checking during parsing that checks the DTD
327
328     // Used to determine whether range offsets use characters or node indices.
329     virtual bool offsetInCharacters() const;
330
331     // FIXME: These next 7 functions are mostly editing-specific and should be moved out.
332     virtual int maxOffset() const;
333     virtual int caretMinOffset() const;
334     virtual int caretMaxOffset() const;
335     virtual unsigned caretMaxRenderedOffset() const;
336     virtual int previousOffset(int current) const;
337     virtual int nextOffset(int current) const;
338     
339 #ifndef NDEBUG
340     virtual void dump(TextStream*, DeprecatedString indent = "") const;
341 #endif
342
343     // -----------------------------------------------------------------------------
344     // Integration with rendering tree
345
346     /**
347      * Attaches this node to the rendering tree. This calculates the style to be applied to the node and creates an
348      * appropriate RenderObject which will be inserted into the tree (except when the style has display: none). This
349      * makes the node visible in the FrameView.
350      */
351     virtual void attach();
352
353     /**
354      * Detaches the node from the rendering tree, making it invisible in the rendered view. This method will remove
355      * the node's rendering object from the rendering tree and delete it.
356      */
357     virtual void detach();
358
359     virtual void willRemove();
360     void createRendererIfNeeded();
361     virtual RenderStyle* styleForRenderer(RenderObject* parent);
362     virtual bool rendererIsNeeded(RenderStyle*);
363 #if SVG_SUPPORT
364     virtual bool childShouldCreateRenderer(Node*) const { return true; }
365 #endif
366     virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);
367     
368     // Wrapper for nodes that don't have a renderer, but still cache the style (like HTMLOptionElement).
369     virtual RenderStyle* renderStyle();
370     virtual void setRenderStyle(RenderStyle* s);
371
372     // -----------------------------------------------------------------------------
373     // Notification of document structure changes
374
375     /**
376      * Notifies the node that it has been inserted into the document. This is called during document parsing, and also
377      * when a node is added through the DOM methods insertBefore(), appendChild() or replaceChild(). Note that this only
378      * happens when the node becomes part of the document tree, i.e. only when the document is actually an ancestor of
379      * the node. The call happens _after_ the node has been added to the tree.
380      *
381      * This is similar to the DOMNodeInsertedIntoDocument DOM event, but does not require the overhead of event
382      * dispatching.
383      */
384     virtual void insertedIntoDocument();
385
386     /**
387      * Notifies the node that it is no longer part of the document tree, i.e. when the document is no longer an ancestor
388      * node.
389      *
390      * This is similar to the DOMNodeRemovedFromDocument DOM event, but does not require the overhead of event
391      * dispatching, and is called _after_ the node is removed from the tree.
392      */
393     virtual void removedFromDocument();
394
395     // These functions are called whenever you are connected or disconnected from a tree.  That tree may be the main
396     // document tree, or it could be another disconnected tree.  Override these functions to do any work that depends
397     // on connectedness to some ancestor (e.g., an ancestor <form> for example).
398     virtual void insertedIntoTree(bool deep) { }
399     virtual void removedFromTree(bool deep) { }
400
401     /**
402      * Notifies the node that it's list of children have changed (either by adding or removing child nodes), or a child
403      * node that is of the type CDATA_SECTION_NODE, TEXT_NODE or COMMENT_NODE has changed its value.
404      */
405     virtual void childrenChanged();
406
407     virtual String toString() const = 0;
408
409 #ifndef NDEBUG
410     virtual void formatForDebugger(char* buffer, unsigned length) const;
411
412     void showNode(const char* prefix = "") const;
413     void showTreeForThis() const;
414     void showTreeAndMark(const Node* markedNode1, const char* markedLabel1, const Node* markedNode2 = 0, const char* markedLabel2 = 0) const;
415 #endif
416
417     void registerNodeList(NodeList*);
418     void unregisterNodeList(NodeList*);
419     void notifyNodeListsChildrenChanged();
420     void notifyLocalNodeListsChildrenChanged();
421     void notifyNodeListsAttributeChanged();
422     void notifyLocalNodeListsAttributeChanged();
423     
424     PassRefPtr<NodeList> getElementsByTagName(const String&);
425     PassRefPtr<NodeList> getElementsByTagNameNS(const String& namespaceURI, const String& localName);
426
427 private: // members
428     DocPtr<Document> m_document;
429     Node* m_previous;
430     Node* m_next;
431     RenderObject* m_renderer;
432
433 protected:
434     typedef HashSet<NodeList*> NodeListSet;
435     NodeListSet* m_nodeLists;
436
437     unsigned short m_tabIndex : 15;
438     bool m_hasTabIndex : 1;
439
440     bool m_hasId : 1;
441     bool m_hasClass : 1;
442     bool m_hasStyle : 1;
443     bool m_attached : 1;
444     bool m_changed : 1;
445     bool m_hasChangedChild : 1;
446     bool m_inDocument : 1;
447
448     bool m_isLink : 1;
449     bool m_specified : 1; // used in Attr; accessor functions there
450     bool m_focused : 1;
451     bool m_active : 1;
452     bool m_hovered : 1;
453     bool m_inActiveChain : 1;
454     bool m_styleElement : 1; // contains stylesheet text
455     bool m_implicit : 1; // implicitly generated by the parser
456
457     bool m_inDetach : 1;
458
459 private:
460     Element* ancestorElement() const;
461 };
462
463 } //namespace
464
465 #ifndef NDEBUG
466 // Outside the WebCore namespace for ease of invocation from gdb.
467 void showTree(const WebCore::Node*);
468 #endif
469
470 #endif