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