2011-05-03 Roland Steiner <rolandsteiner@chromium.org>
[WebKit-https.git] / Source / WebCore / dom / Node.h
1 /*
2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
4  *           (C) 2001 Dirk Mueller (mueller@kde.org)
5  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
6  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Library General Public
10  * License as published by the Free Software Foundation; either
11  * version 2 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Library General Public License for more details.
17  *
18  * You should have received a copy of the GNU Library General Public License
19  * along with this library; see the file COPYING.LIB.  If not, write to
20  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
21  * Boston, MA 02110-1301, USA.
22  *
23  */
24
25 #ifndef Node_h
26 #define Node_h
27
28 #include "EventTarget.h"
29 #include "KURLHash.h"
30 #include "RenderStyleConstants.h"
31 #include "ScriptWrappable.h"
32 #include "TreeShared.h"
33 #include <wtf/Forward.h>
34 #include <wtf/ListHashSet.h>
35
36 #if USE(JSC)
37 namespace JSC {
38     class JSGlobalData;
39     class MarkStack;
40     typedef MarkStack SlotVisitor;
41 }
42 #endif
43
44 namespace WebCore {
45
46 class Attribute;
47 class ClassNodeList;
48 class ContainerNode;
49 class Document;
50 class DynamicNodeList;
51 class Element;
52 class Event;
53 class EventContext;
54 class EventListener;
55 class FloatPoint;
56 class Frame;
57 class InputElement;
58 class IntRect;
59 class KeyboardEvent;
60 class NSResolver;
61 class NamedNodeMap;
62 class NameNodeList;
63 class NodeList;
64 class NodeRareData;
65 class PlatformKeyboardEvent;
66 class PlatformMouseEvent;
67 class PlatformWheelEvent;
68 class QualifiedName;
69 class RegisteredEventListener;
70 class RenderArena;
71 class RenderBox;
72 class RenderBoxModelObject;
73 class RenderObject;
74 class RenderStyle;
75 #if ENABLE(SVG)
76 class SVGUseElement;
77 #endif
78 class TagNodeList;
79 class TreeScope;
80
81 typedef int ExceptionCode;
82
83 const int nodeStyleChangeShift = 25;
84
85 // SyntheticStyleChange means that we need to go through the entire style change logic even though
86 // no style property has actually changed. It is used to restructure the tree when, for instance,
87 // RenderLayers are created or destroyed due to animation changes.
88 enum StyleChangeType { 
89     NoStyleChange = 0, 
90     InlineStyleChange = 1 << nodeStyleChangeShift, 
91     FullStyleChange = 2 << nodeStyleChangeShift, 
92     SyntheticStyleChange = 3 << nodeStyleChangeShift
93 };
94
95 class Node : public EventTarget, public TreeShared<ContainerNode>, public ScriptWrappable {
96     friend class Document;
97     friend class TreeScope;
98
99 public:
100     enum NodeType {
101         ELEMENT_NODE = 1,
102         ATTRIBUTE_NODE = 2,
103         TEXT_NODE = 3,
104         CDATA_SECTION_NODE = 4,
105         ENTITY_REFERENCE_NODE = 5,
106         ENTITY_NODE = 6,
107         PROCESSING_INSTRUCTION_NODE = 7,
108         COMMENT_NODE = 8,
109         DOCUMENT_NODE = 9,
110         DOCUMENT_TYPE_NODE = 10,
111         DOCUMENT_FRAGMENT_NODE = 11,
112         NOTATION_NODE = 12,
113         XPATH_NAMESPACE_NODE = 13,
114         SHADOW_ROOT_NODE = 14
115     };
116     enum DocumentPosition {
117         DOCUMENT_POSITION_EQUIVALENT = 0x00,
118         DOCUMENT_POSITION_DISCONNECTED = 0x01,
119         DOCUMENT_POSITION_PRECEDING = 0x02,
120         DOCUMENT_POSITION_FOLLOWING = 0x04,
121         DOCUMENT_POSITION_CONTAINS = 0x08,
122         DOCUMENT_POSITION_CONTAINED_BY = 0x10,
123         DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC = 0x20,
124     };
125
126     static bool isSupported(const String& feature, const String& version);
127
128     static void startIgnoringLeaks();
129     static void stopIgnoringLeaks();
130
131     static void dumpStatistics();
132
133     enum StyleChange { NoChange, NoInherit, Inherit, Detach, Force };    
134     static StyleChange diff(const RenderStyle*, const RenderStyle*);
135
136     virtual ~Node();
137
138     // DOM methods & attributes for Node
139
140     bool hasTagName(const QualifiedName&) const;
141     bool hasLocalName(const AtomicString&) const;
142     virtual String nodeName() const = 0;
143     virtual String nodeValue() const;
144     virtual void setNodeValue(const String&, ExceptionCode&);
145     virtual NodeType nodeType() const = 0;
146     ContainerNode* parentNode() const;
147     Element* parentElement() const;
148     Node* previousSibling() const { return m_previous; }
149     Node* nextSibling() const { return m_next; }
150     PassRefPtr<NodeList> childNodes();
151     Node* firstChild() const;
152     Node* lastChild() const;
153     bool hasAttributes() const;
154     NamedNodeMap* attributes() const;
155
156     virtual KURL baseURI() const;
157     
158     void getSubresourceURLs(ListHashSet<KURL>&) const;
159
160     // These should all actually return a node, but this is only important for language bindings,
161     // which will already know and hold a ref on the right node to return. Returning bool allows
162     // these methods to be more efficient since they don't need to return a ref
163     bool insertBefore(PassRefPtr<Node> newChild, Node* refChild, ExceptionCode&, bool shouldLazyAttach = false);
164     bool replaceChild(PassRefPtr<Node> newChild, Node* oldChild, ExceptionCode&, bool shouldLazyAttach = false);
165     bool removeChild(Node* child, ExceptionCode&);
166     bool appendChild(PassRefPtr<Node> newChild, ExceptionCode&, bool shouldLazyAttach = false);
167
168     void remove(ExceptionCode&);
169     bool hasChildNodes() const { return firstChild(); }
170     virtual PassRefPtr<Node> cloneNode(bool deep) = 0;
171     const AtomicString& localName() const { return virtualLocalName(); }
172     const AtomicString& namespaceURI() const { return virtualNamespaceURI(); }
173     const AtomicString& prefix() const { return virtualPrefix(); }
174     virtual void setPrefix(const AtomicString&, ExceptionCode&);
175     void normalize();
176
177     bool isSameNode(Node* other) const { return this == other; }
178     bool isEqualNode(Node*) const;
179     bool isDefaultNamespace(const AtomicString& namespaceURI) const;
180     String lookupPrefix(const AtomicString& namespaceURI) const;
181     String lookupNamespaceURI(const String& prefix) const;
182     String lookupNamespacePrefix(const AtomicString& namespaceURI, const Element* originalElement) const;
183     
184     String textContent(bool convertBRsToNewlines = false) const;
185     void setTextContent(const String&, ExceptionCode&);
186     
187     Node* lastDescendant() const;
188     Node* firstDescendant() const;
189     
190     // Other methods (not part of DOM)
191
192     bool isElementNode() const { return getFlag(IsElementFlag); }
193     bool isContainerNode() const { return getFlag(IsContainerFlag); }
194     bool isTextNode() const { return getFlag(IsTextFlag); }
195
196     bool isHTMLElement() const { return getFlag(IsHTMLFlag); }
197
198     bool isSVGElement() const { return getFlag(IsSVGFlag); }
199     virtual bool isSVGShadowRoot() const { return false; }
200 #if ENABLE(SVG)
201     SVGUseElement* svgShadowHost() const;
202 #endif
203
204     virtual bool isMediaControlElement() const { return false; }
205     bool isStyledElement() const { return getFlag(IsStyledElementFlag); }
206     virtual bool isFrameOwnerElement() const { return false; }
207     virtual bool isAttributeNode() const { return false; }
208     bool isCommentNode() const { return getFlag(IsCommentFlag); }
209     virtual bool isCharacterDataNode() const { return false; }
210     bool isDocumentNode() const;
211     bool isShadowRoot() const { return getFlag(IsShadowRootFlag); }
212     // FIXME: Remove this when all shadow roots are ShadowRoots.
213     virtual bool isShadowBoundary() const { return false; }
214     virtual bool canHaveLightChildRendererWithShadow() const { return false; }
215
216     Node* shadowAncestorNode();
217     Node* shadowTreeRootNode();
218     bool isInShadowTree();
219     // Node's parent, shadow tree host, or SVG use.
220     ContainerNode* parentOrHostNode() const;
221     // Use when it's guaranteed to that shadowHost is 0 and svgShadowHost is 0.
222     ContainerNode* parentNodeGuaranteedHostFree() const;
223
224     Element* shadowHost() const;
225     void setShadowHost(Element*);
226
227     bool selfOrAncestorHasDirAutoAttribute() const { return getFlag(SelfOrAncestorHasDirAutoFlag); }
228     void setSelfOrAncestorHasDirAutoAttribute(bool flag) { setFlag(flag, SelfOrAncestorHasDirAutoFlag); }
229
230     // Returns the enclosing event parent node (or self) that, when clicked, would trigger a navigation.
231     Node* enclosingLinkEventParentOrSelf();
232
233     bool isBlockFlow() const;
234     bool isBlockFlowOrBlockTable() const;
235     
236     // These low-level calls give the caller responsibility for maintaining the integrity of the tree.
237     void setPreviousSibling(Node* previous) { m_previous = previous; }
238     void setNextSibling(Node* next) { m_next = next; }
239
240     // FIXME: These two functions belong in editing -- "atomic node" is an editing concept.
241     Node* previousNodeConsideringAtomicNodes() const;
242     Node* nextNodeConsideringAtomicNodes() const;
243     
244     // Returns the next leaf node or 0 if there are no more.
245     // Delivers leaf nodes as if the whole DOM tree were a linear chain of its leaf nodes.
246     // Uses an editing-specific concept of what a leaf node is, and should probably be moved
247     // out of the Node class into an editing-specific source file.
248     Node* nextLeafNode() const;
249
250     // Returns the previous leaf node or 0 if there are no more.
251     // Delivers leaf nodes as if the whole DOM tree were a linear chain of its leaf nodes.
252     // Uses an editing-specific concept of what a leaf node is, and should probably be moved
253     // out of the Node class into an editing-specific source file.
254     Node* previousLeafNode() const;
255
256     // enclosingBlockFlowElement() is deprecated. Use enclosingBlock instead.
257     Element* enclosingBlockFlowElement() const;
258     
259     Element* rootEditableElement() const;
260     
261     bool inSameContainingBlockFlowElement(Node*);
262
263     // FIXME: All callers of this function are almost certainly wrong!
264     virtual void deprecatedParserAddChild(PassRefPtr<Node>);
265
266     // Called by the parser when this element's close tag is reached,
267     // signaling that all child tags have been parsed and added.
268     // This is needed for <applet> and <object> elements, which can't lay themselves out
269     // until they know all of their nested <param>s. [Radar 3603191, 4040848].
270     // Also used for script elements and some SVG elements for similar purposes,
271     // but making parsing a special case in this respect should be avoided if possible.
272     virtual void finishParsingChildren() { }
273     virtual void beginParsingChildren() { }
274
275     // Called on the focused node right before dispatching an unload event.
276     virtual void aboutToUnload() { }
277
278     // For <link> and <style> elements.
279     virtual bool sheetLoaded() { return true; }
280
281     bool hasID() const { return getFlag(HasIDFlag); }
282     bool hasClass() const { return getFlag(HasClassFlag); }
283     bool active() const { return getFlag(IsActiveFlag); }
284     bool inActiveChain() const { return getFlag(InActiveChainFlag); }
285     bool inDetach() const { return getFlag(InDetachFlag); }
286     bool hovered() const { return getFlag(IsHoveredFlag); }
287     bool focused() const { return hasRareData() ? rareDataFocused() : false; }
288     bool attached() const { return getFlag(IsAttachedFlag); }
289     void setAttached() { setFlag(IsAttachedFlag); }
290     bool needsStyleRecalc() const { return styleChangeType() != NoStyleChange; }
291     StyleChangeType styleChangeType() const { return static_cast<StyleChangeType>(m_nodeFlags & StyleChangeMask); }
292     bool childNeedsStyleRecalc() const { return getFlag(ChildNeedsStyleRecalcFlag); }
293     bool isLink() const { return getFlag(IsLinkFlag); }
294
295     void setHasID(bool f) { setFlag(f, HasIDFlag); }
296     void setHasClass(bool f) { setFlag(f, HasClassFlag); }
297     void setChildNeedsStyleRecalc() { setFlag(ChildNeedsStyleRecalcFlag); }
298     void clearChildNeedsStyleRecalc() { clearFlag(ChildNeedsStyleRecalcFlag); }
299     void setInDocument() { setFlag(InDocumentFlag); }
300     void clearInDocument() { clearFlag(InDocumentFlag); }
301
302     void setInActiveChain() { setFlag(InActiveChainFlag); }
303     void clearInActiveChain() { clearFlag(InActiveChainFlag); }
304
305     void setNeedsStyleRecalc(StyleChangeType changeType = FullStyleChange);
306     void clearNeedsStyleRecalc() { m_nodeFlags &= ~StyleChangeMask; }
307
308     void setIsLink(bool f) { setFlag(f, IsLinkFlag); }
309     void setIsLink() { setFlag(IsLinkFlag); }
310     void clearIsLink() { clearFlag(IsLinkFlag); }
311
312     enum ShouldSetAttached {
313         SetAttached,
314         DoNotSetAttached
315     };
316     void lazyAttach(ShouldSetAttached = SetAttached);
317
318     virtual void setFocus(bool = true);
319     virtual void setActive(bool f = true, bool /*pause*/ = false) { setFlag(f, IsActiveFlag); }
320     virtual void setHovered(bool f = true) { setFlag(f, IsHoveredFlag); }
321
322     virtual short tabIndex() const;
323
324     // Whether this kind of node can receive focus by default. Most nodes are
325     // not focusable but some elements, such as form controls and links, are.
326     virtual bool supportsFocus() const;
327     // Whether the node can actually be focused.
328     virtual bool isFocusable() const;
329     virtual bool isKeyboardFocusable(KeyboardEvent*) const;
330     virtual bool isMouseFocusable() const;
331
332     bool isContentEditable() const;
333
334     bool rendererIsEditable() const { return rendererIsEditable(Editable); }
335     bool rendererIsRichlyEditable() const { return rendererIsEditable(RichlyEditable); }
336     virtual bool shouldUseInputMethod() const;
337     virtual IntRect getRect() const;
338     IntRect renderRect(bool* isReplaced);
339
340     // Returns true if the node has a non-empty bounding box in layout.
341     // This does not 100% guarantee the user can see it, but is pretty close.
342     // Note: This method only works properly after layout has occurred.
343     bool hasNonEmptyBoundingBox() const;
344
345     virtual void recalcStyle(StyleChange = NoChange) { }
346
347     unsigned nodeIndex() const;
348
349     // Returns the DOM ownerDocument attribute. This method never returns NULL, except in the case 
350     // of (1) a Document node or (2) a DocumentType node that is not used with any Document yet. 
351     Document* ownerDocument() const;
352
353     // Returns the document associated with this node. This method never returns NULL, except in the case 
354     // of a DocumentType node that is not used with any Document yet. A Document node returns itself.
355     Document* document() const
356     {
357         ASSERT(this);
358         // FIXME: below ASSERT is useful, but prevents the use of document() in the constructor or destructor
359         // due to the virtual function call to nodeType().
360         ASSERT(m_document || (nodeType() == DOCUMENT_TYPE_NODE && !inDocument()));
361         return m_document;
362     }
363
364     TreeScope* treeScope() const;
365
366     // Used by the basic DOM methods (e.g., appendChild()).
367     void setTreeScopeRecursively(TreeScope*, bool includeRoot = true);
368
369     // Returns true if this node is associated with a document and is in its associated document's
370     // node tree, false otherwise.
371     bool inDocument() const 
372     { 
373         ASSERT(m_document || !getFlag(InDocumentFlag));
374         return getFlag(InDocumentFlag);
375     }
376
377     bool isReadOnlyNode() const { return nodeType() == ENTITY_REFERENCE_NODE; }
378     virtual bool childTypeAllowed(NodeType) const { return false; }
379     unsigned childNodeCount() const;
380     Node* childNode(unsigned index) const;
381
382     // Does a pre-order traversal of the tree to find the next node after this one.
383     // This uses the same order that tags appear in the source file. If the stayWithin
384     // argument is non-null, the traversal will stop once the specified node is reached.
385     // This can be used to restrict traversal to a particular sub-tree.
386     Node* traverseNextNode(const Node* stayWithin = 0) const;
387
388     // Like traverseNextNode, but skips children and starts with the next sibling.
389     Node* traverseNextSibling(const Node* stayWithin = 0) const;
390
391     // Does a reverse pre-order traversal to find the node that comes before the current one in document order
392     Node* traversePreviousNode(const Node* stayWithin = 0) const;
393
394     // Like traverseNextNode, but visits parents after their children.
395     Node* traverseNextNodePostOrder() const;
396
397     // Like traversePreviousNode, but visits parents before their children.
398     Node* traversePreviousNodePostOrder(const Node* stayWithin = 0) const;
399     Node* traversePreviousSiblingPostOrder(const Node* stayWithin = 0) const;
400
401     void checkSetPrefix(const AtomicString& prefix, ExceptionCode&);
402     bool isDescendantOf(const Node*) const;
403     bool contains(const Node*) const;
404     bool containsIncludingShadowDOM(Node*);
405
406     // This method is used to do strict error-checking when adding children via
407     // the public DOM API (e.g., appendChild()).
408     void checkAddChild(Node* newChild, ExceptionCode&); // Error-checking when adding via the DOM API
409
410     void checkReplaceChild(Node* newChild, Node* oldChild, ExceptionCode&);
411     virtual bool canReplaceChild(Node* newChild, Node* oldChild);
412     
413     // Used to determine whether range offsets use characters or node indices.
414     virtual bool offsetInCharacters() const;
415     // Number of DOM 16-bit units contained in node. Note that rendered text length can be different - e.g. because of
416     // css-transform:capitalize breaking up precomposed characters and ligatures.
417     virtual int maxCharacterOffset() const;
418     
419     // FIXME: We should try to find a better location for these methods.
420     virtual bool canSelectAll() const { return false; }
421     virtual void selectAll() { }
422
423     // Whether or not a selection can be started in this object
424     virtual bool canStartSelection() const;
425
426     // Getting points into and out of screen space
427     FloatPoint convertToPage(const FloatPoint&) const;
428     FloatPoint convertFromPage(const FloatPoint&) const;
429
430     // -----------------------------------------------------------------------------
431     // Integration with rendering tree
432
433     RenderObject* renderer() const { return m_renderer; }
434     RenderObject* nextRenderer();
435     RenderObject* previousRenderer();
436     void setRenderer(RenderObject* renderer) { m_renderer = renderer; }
437     
438     // Use these two methods with caution.
439     RenderBox* renderBox() const;
440     RenderBoxModelObject* renderBoxModelObject() const;
441
442     // Attaches this node to the rendering tree. This calculates the style to be applied to the node and creates an
443     // appropriate RenderObject which will be inserted into the tree (except when the style has display: none). This
444     // makes the node visible in the FrameView.
445     virtual void attach();
446
447     // Detaches the node from the rendering tree, making it invisible in the rendered view. This method will remove
448     // the node's rendering object from the rendering tree and delete it.
449     virtual void detach();
450
451     virtual void willRemove();
452     void createRendererIfNeeded();
453     PassRefPtr<RenderStyle> styleForRenderer();
454     virtual bool rendererIsNeeded(RenderStyle*);
455     virtual bool childShouldCreateRenderer(Node*) const { return true; }
456     virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);
457     ContainerNode* parentNodeForRenderingAndStyle();
458     
459     // Wrapper for nodes that don't have a renderer, but still cache the style (like HTMLOptionElement).
460     RenderStyle* renderStyle() const;
461     virtual void setRenderStyle(PassRefPtr<RenderStyle>);
462
463     RenderStyle* computedStyle(PseudoId pseudoElementSpecifier = NOPSEUDO) { return virtualComputedStyle(pseudoElementSpecifier); }
464
465     // -----------------------------------------------------------------------------
466     // Notification of document structure changes
467
468     // Notifies the node that it has been inserted into the document. This is called during document parsing, and also
469     // when a node is added through the DOM methods insertBefore(), appendChild() or replaceChild(). Note that this only
470     // happens when the node becomes part of the document tree, i.e. only when the document is actually an ancestor of
471     // the node. The call happens _after_ the node has been added to the tree.
472     //
473     // This is similar to the DOMNodeInsertedIntoDocument DOM event, but does not require the overhead of event
474     // dispatching.
475     virtual void insertedIntoDocument();
476
477     // Notifies the node that it is no longer part of the document tree, i.e. when the document is no longer an ancestor
478     // node.
479     //
480     // This is similar to the DOMNodeRemovedFromDocument DOM event, but does not require the overhead of event
481     // dispatching, and is called _after_ the node is removed from the tree.
482     virtual void removedFromDocument();
483
484     // These functions are called whenever you are connected or disconnected from a tree.  That tree may be the main
485     // document tree, or it could be another disconnected tree.  Override these functions to do any work that depends
486     // on connectedness to some ancestor (e.g., an ancestor <form> for example).
487     virtual void insertedIntoTree(bool /*deep*/) { }
488     virtual void removedFromTree(bool /*deep*/) { }
489
490     // Notifies the node that it's list of children have changed (either by adding or removing child nodes), or a child
491     // node that is of the type CDATA_SECTION_NODE, TEXT_NODE or COMMENT_NODE has changed its value.
492     virtual void childrenChanged(bool /*changedByParser*/ = false, Node* /*beforeChange*/ = 0, Node* /*afterChange*/ = 0, int /*childCountDelta*/ = 0) { }
493
494 #ifndef NDEBUG
495     virtual void formatForDebugger(char* buffer, unsigned length) const;
496
497     void showNode(const char* prefix = "") const;
498     void showTreeForThis() const;
499     void showTreeAndMark(const Node* markedNode1, const char* markedLabel1, const Node* markedNode2 = 0, const char* markedLabel2 = 0) const;
500 #endif
501
502     void registerDynamicNodeList(DynamicNodeList*);
503     void unregisterDynamicNodeList(DynamicNodeList*);
504     void notifyNodeListsChildrenChanged();
505     void notifyLocalNodeListsChildrenChanged();
506     void notifyNodeListsAttributeChanged();
507     void notifyLocalNodeListsAttributeChanged();
508     void notifyLocalNodeListsLabelChanged();
509     void removeCachedClassNodeList(ClassNodeList*, const String&);
510     void removeCachedNameNodeList(NameNodeList*, const String&);
511     void removeCachedTagNodeList(TagNodeList*, const AtomicString&);
512     void removeCachedTagNodeList(TagNodeList*, const QualifiedName&);
513     void removeCachedLabelsNodeList(DynamicNodeList*);
514
515     PassRefPtr<NodeList> getElementsByTagName(const AtomicString&);
516     PassRefPtr<NodeList> getElementsByTagNameNS(const AtomicString& namespaceURI, const AtomicString& localName);
517     PassRefPtr<NodeList> getElementsByName(const String& elementName);
518     PassRefPtr<NodeList> getElementsByClassName(const String& classNames);
519
520     PassRefPtr<Element> querySelector(const String& selectors, ExceptionCode&);
521     PassRefPtr<NodeList> querySelectorAll(const String& selectors, ExceptionCode&);
522
523     unsigned short compareDocumentPosition(Node*);
524
525     virtual Node* toNode() { return this; }
526
527     virtual InputElement* toInputElement();
528
529     virtual ScriptExecutionContext* scriptExecutionContext() const;
530
531     virtual bool addEventListener(const AtomicString& eventType, PassRefPtr<EventListener>, bool useCapture);
532     virtual bool removeEventListener(const AtomicString& eventType, EventListener*, bool useCapture);
533
534     // Handlers to do/undo actions on the target node before an event is dispatched to it and after the event
535     // has been dispatched.  The data pointer is handed back by the preDispatch and passed to postDispatch.
536     virtual void* preDispatchEventHandler(Event*) { return 0; }
537     virtual void postDispatchEventHandler(Event*, void* /*dataFromPreDispatch*/) { }
538
539     using EventTarget::dispatchEvent;
540     bool dispatchEvent(PassRefPtr<Event>);
541     void dispatchScopedEvent(PassRefPtr<Event>);
542
543     virtual void handleLocalEvents(Event*);
544
545     void dispatchSubtreeModifiedEvent();
546     void dispatchUIEvent(const AtomicString& eventType, int detail, PassRefPtr<Event> underlyingEvent);
547     bool dispatchKeyEvent(const PlatformKeyboardEvent&);
548     bool dispatchWheelEvent(const PlatformWheelEvent&);
549     bool dispatchMouseEvent(const PlatformMouseEvent&, const AtomicString& eventType, int clickCount = 0, Node* relatedTarget = 0);
550     void dispatchSimulatedClick(PassRefPtr<Event> underlyingEvent, bool sendMouseEvents = false, bool showPressedLook = true);
551
552     virtual void dispatchFocusEvent();
553     virtual void dispatchBlurEvent();
554     virtual void dispatchChangeEvent();
555     virtual void dispatchInputEvent();
556
557     // Perform the default action for an event.
558     virtual void defaultEventHandler(Event*);
559
560     // Used for disabled form elements; if true, prevents mouse events from being dispatched
561     // to event listeners, and prevents DOMActivate events from being sent at all.
562     virtual bool disabled() const;
563
564     using TreeShared<ContainerNode>::ref;
565     using TreeShared<ContainerNode>::deref;
566
567     virtual EventTargetData* eventTargetData();
568     virtual EventTargetData* ensureEventTargetData();
569
570 private:
571     enum NodeFlags {
572         IsTextFlag = 1,
573         IsCommentFlag = 1 << 1,
574         IsContainerFlag = 1 << 2,
575         IsElementFlag = 1 << 3,
576         IsStyledElementFlag = 1 << 4,
577         IsHTMLFlag = 1 << 5,
578         IsSVGFlag = 1 << 6,
579         HasIDFlag = 1 << 7,
580         HasClassFlag = 1 << 8,
581         IsAttachedFlag = 1 << 9,
582         ChildNeedsStyleRecalcFlag = 1 << 10,
583         InDocumentFlag = 1 << 11,
584         IsLinkFlag = 1 << 12,
585         IsActiveFlag = 1 << 13,
586         IsHoveredFlag = 1 << 14,
587         InActiveChainFlag = 1 << 15,
588         InDetachFlag = 1 << 16,
589         HasRareDataFlag = 1 << 17,
590         IsShadowRootFlag = 1 << 18,
591
592         // These bits are used by derived classes, pulled up here so they can
593         // be stored in the same memory word as the Node bits above.
594         IsParsingChildrenFinishedFlag = 1 << 19, // Element
595         IsStyleAttributeValidFlag = 1 << 20, // StyledElement
596         IsSynchronizingStyleAttributeFlag = 1 << 21, // StyledElement
597 #if ENABLE(SVG)
598         AreSVGAttributesValidFlag = 1 << 22, // Element
599         IsSynchronizingSVGAttributesFlag = 1 << 23, // SVGElement
600         HasSVGRareDataFlag = 1 << 24, // SVGElement
601 #endif
602
603         StyleChangeMask = 1 << nodeStyleChangeShift | 1 << (nodeStyleChangeShift + 1),
604
605         SelfOrAncestorHasDirAutoFlag = 1 << 27,
606
607 #if ENABLE(SVG)
608         DefaultNodeFlags = IsParsingChildrenFinishedFlag | IsStyleAttributeValidFlag | AreSVGAttributesValidFlag
609 #else
610         DefaultNodeFlags = IsParsingChildrenFinishedFlag | IsStyleAttributeValidFlag
611 #endif
612     };
613
614     // 4 bits remaining
615
616     bool getFlag(NodeFlags mask) const { return m_nodeFlags & mask; }
617     void setFlag(bool f, NodeFlags mask) const { m_nodeFlags = (m_nodeFlags & ~mask) | (-(int32_t)f & mask); } 
618     void setFlag(NodeFlags mask) const { m_nodeFlags |= mask; } 
619     void clearFlag(NodeFlags mask) const { m_nodeFlags &= ~mask; } 
620
621 protected:
622     enum ConstructionType { 
623         CreateOther = DefaultNodeFlags,
624         CreateText = DefaultNodeFlags | IsTextFlag,
625         CreateComment = DefaultNodeFlags | IsCommentFlag,
626         CreateContainer = DefaultNodeFlags | IsContainerFlag, 
627         CreateElement = CreateContainer | IsElementFlag, 
628         CreateStyledElement = CreateElement | IsStyledElementFlag, 
629         CreateHTMLElement = CreateStyledElement | IsHTMLFlag, 
630         CreateSVGElement = CreateStyledElement | IsSVGFlag, 
631     };
632     Node(Document*, ConstructionType);
633
634     virtual void willMoveToNewOwnerDocument();
635     virtual void didMoveToNewOwnerDocument();
636     
637     virtual void addSubresourceAttributeURLs(ListHashSet<KURL>&) const { }
638     void setTabIndexExplicitly(short);
639     void clearTabIndexExplicitly();
640     
641     bool hasRareData() const { return getFlag(HasRareDataFlag); }
642
643     NodeRareData* rareData() const;
644     NodeRareData* ensureRareData();
645
646 private:
647     // Do not use this method to change the document of a node until after the node has been
648     // removed from its previous document.
649     void setDocumentRecursively(Document*);
650     void setDocument(Document*);
651
652     enum EditableLevel { Editable, RichlyEditable };
653     bool rendererIsEditable(EditableLevel) const;
654
655     void setStyleChange(StyleChangeType);
656
657     // Used to share code between lazyAttach and setNeedsStyleRecalc.
658     void markAncestorsWithChildNeedsStyleRecalc();
659
660     virtual void refEventTarget();
661     virtual void derefEventTarget();
662
663     virtual NodeRareData* createRareData();
664     bool rareDataFocused() const;
665
666     virtual RenderStyle* nonRendererRenderStyle() const;
667
668     virtual const AtomicString& virtualPrefix() const;
669     virtual const AtomicString& virtualLocalName() const;
670     virtual const AtomicString& virtualNamespaceURI() const;
671     virtual RenderStyle* virtualComputedStyle(PseudoId = NOPSEUDO);
672
673     Element* ancestorElement() const;
674
675     // Use Node::parentNode as the consistent way of querying a parent node.
676     // This method is made private to ensure a compiler error on call sites that
677     // don't follow this rule.
678     using TreeShared<ContainerNode>::parent;
679
680     void trackForDebugging();
681
682     Document* m_document;
683     Node* m_previous;
684     Node* m_next;
685     RenderObject* m_renderer;
686     mutable uint32_t m_nodeFlags;
687
688 protected:
689     bool isParsingChildrenFinished() const { return getFlag(IsParsingChildrenFinishedFlag); }
690     void setIsParsingChildrenFinished() { setFlag(IsParsingChildrenFinishedFlag); }
691     void clearIsParsingChildrenFinished() { clearFlag(IsParsingChildrenFinishedFlag); }
692     bool isStyleAttributeValid() const { return getFlag(IsStyleAttributeValidFlag); }
693     void setIsStyleAttributeValid(bool f) { setFlag(f, IsStyleAttributeValidFlag); }
694     void setIsStyleAttributeValid() const { setFlag(IsStyleAttributeValidFlag); }
695     void clearIsStyleAttributeValid() { clearFlag(IsStyleAttributeValidFlag); }
696     bool isSynchronizingStyleAttribute() const { return getFlag(IsSynchronizingStyleAttributeFlag); }
697     void setIsSynchronizingStyleAttribute(bool f) { setFlag(f, IsSynchronizingStyleAttributeFlag); }
698     void setIsSynchronizingStyleAttribute() const { setFlag(IsSynchronizingStyleAttributeFlag); }
699     void clearIsSynchronizingStyleAttribute() const { clearFlag(IsSynchronizingStyleAttributeFlag); }
700
701 #if ENABLE(SVG)
702     bool areSVGAttributesValid() const { return getFlag(AreSVGAttributesValidFlag); }
703     void setAreSVGAttributesValid() const { setFlag(AreSVGAttributesValidFlag); }
704     void clearAreSVGAttributesValid() { clearFlag(AreSVGAttributesValidFlag); }
705     bool isSynchronizingSVGAttributes() const { return getFlag(IsSynchronizingSVGAttributesFlag); }
706     void setIsSynchronizingSVGAttributes() const { setFlag(IsSynchronizingSVGAttributesFlag); }
707     void clearIsSynchronizingSVGAttributes() const { clearFlag(IsSynchronizingSVGAttributesFlag); }
708     bool hasRareSVGData() const { return getFlag(HasSVGRareDataFlag); }
709     void setHasRareSVGData() { setFlag(HasSVGRareDataFlag); }
710     void clearHasRareSVGData() { clearFlag(HasSVGRareDataFlag); }
711 #endif
712 };
713
714 // Used in Node::addSubresourceAttributeURLs() and in addSubresourceStyleURLs()
715 inline void addSubresourceURL(ListHashSet<KURL>& urls, const KURL& url)
716 {
717     if (!url.isNull())
718         urls.add(url);
719 }
720
721 inline ContainerNode* Node::parentNode() const
722 {
723     return getFlag(IsShadowRootFlag) || isSVGShadowRoot() ? 0 : parent();
724 }
725
726 inline ContainerNode* Node::parentOrHostNode() const
727 {
728     return parent();
729 }
730
731 inline ContainerNode* Node::parentNodeGuaranteedHostFree() const
732 {
733     ASSERT(!getFlag(IsShadowRootFlag) && !isSVGShadowRoot());
734     return parentOrHostNode();
735 }
736
737 } //namespace
738
739 #ifndef NDEBUG
740 // Outside the WebCore namespace for ease of invocation from gdb.
741 void showTree(const WebCore::Node*);
742 #endif
743
744 #endif