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