WebCore: Fix for https://bugs.webkit.org/show_bug.cgi?id=29703
[WebKit.git] / WebCore / dom / Node.cpp
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 Nokia Corporation and/or its subsidiary(-ies)
7  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
8  *
9  * This library is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Library General Public
11  * License as published by the Free Software Foundation; either
12  * version 2 of the License, or (at your option) any later version.
13  *
14  * This library is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * Library General Public License for more details.
18  *
19  * You should have received a copy of the GNU Library General Public License
20  * along with this library; see the file COPYING.LIB.  If not, write to
21  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
22  * Boston, MA 02110-1301, USA.
23  */
24
25 #include "config.h"
26 #include "Node.h"
27
28 #include "Attr.h"
29 #include "CSSParser.h"
30 #include "CSSRule.h"
31 #include "CSSRuleList.h"
32 #include "CSSSelector.h"
33 #include "CSSSelectorList.h"
34 #include "CSSStyleRule.h"
35 #include "CSSStyleSelector.h"
36 #include "CSSStyleSheet.h"
37 #include "CString.h"
38 #include "ChildNodeList.h"
39 #include "ClassNodeList.h"
40 #include "DOMImplementation.h"
41 #include "Document.h"
42 #include "DynamicNodeList.h"
43 #include "Element.h"
44 #include "Event.h"
45 #include "EventException.h"
46 #include "EventHandler.h"
47 #include "EventListener.h"
48 #include "EventNames.h"
49 #include "ExceptionCode.h"
50 #include "Frame.h"
51 #include "FrameView.h"
52 #include "HTMLNames.h"
53 #include "InspectorTimelineAgent.h"
54 #include "KeyboardEvent.h"
55 #include "Logging.h"
56 #include "MouseEvent.h"
57 #include "MutationEvent.h"
58 #include "NameNodeList.h"
59 #include "NamedNodeMap.h"
60 #include "NodeRareData.h"
61 #include "Page.h"
62 #include "PlatformMouseEvent.h"
63 #include "PlatformWheelEvent.h"
64 #include "ProcessingInstruction.h"
65 #include "ProgressEvent.h"
66 #include "RegisteredEventListener.h"
67 #include "RenderObject.h"
68 #include "ScriptController.h"
69 #include "SelectorNodeList.h"
70 #include "StringBuilder.h"
71 #include "TagNodeList.h"
72 #include "Text.h"
73 #include "TextEvent.h"
74 #include "UIEvent.h"
75 #include "UIEventWithKeyState.h"
76 #include "WebKitAnimationEvent.h"
77 #include "WebKitTransitionEvent.h"
78 #include "WheelEvent.h"
79 #include "XMLNames.h"
80 #include "htmlediting.h"
81 #include <wtf/HashSet.h>
82 #include <wtf/PassOwnPtr.h>
83 #include <wtf/RefCountedLeakCounter.h>
84 #include <wtf/UnusedParam.h>
85
86 #if ENABLE(DOM_STORAGE)
87 #include "StorageEvent.h"
88 #endif
89
90 #if ENABLE(SVG)
91 #include "SVGElementInstance.h"
92 #include "SVGUseElement.h"
93 #endif
94
95 #if ENABLE(XHTMLMP)
96 #include "HTMLNoScriptElement.h"
97 #endif
98
99 #define DUMP_NODE_STATISTICS 0
100
101 using namespace std;
102
103 namespace WebCore {
104
105 using namespace HTMLNames;
106
107 static HashSet<Node*>* gNodesDispatchingSimulatedClicks = 0;
108
109 bool Node::isSupported(const String& feature, const String& version)
110 {
111     return DOMImplementation::hasFeature(feature, version);
112 }
113
114 #if DUMP_NODE_STATISTICS
115 static HashSet<Node*> liveNodeSet;
116 #endif
117
118 void Node::dumpStatistics()
119 {
120 #if DUMP_NODE_STATISTICS
121     size_t nodesWithRareData = 0;
122
123     size_t elementNodes = 0;
124     size_t attrNodes = 0;
125     size_t textNodes = 0;
126     size_t cdataNodes = 0;
127     size_t commentNodes = 0;
128     size_t entityReferenceNodes = 0;
129     size_t entityNodes = 0;
130     size_t piNodes = 0;
131     size_t documentNodes = 0;
132     size_t docTypeNodes = 0;
133     size_t fragmentNodes = 0;
134     size_t notationNodes = 0;
135     size_t xpathNSNodes = 0;
136
137     HashMap<String, size_t> perTagCount;
138
139     size_t attributes = 0;
140     size_t mappedAttributes = 0;
141     size_t mappedAttributesWithStyleDecl = 0;
142     size_t attributesWithAttr = 0;
143     size_t attrMaps = 0;
144     size_t mappedAttrMaps = 0;
145
146     for (HashSet<Node*>::const_iterator it = liveNodeSet.begin(); it != liveNodeSet.end(); ++it) {
147         Node* node = *it;
148
149         if (node->hasRareData())
150             ++nodesWithRareData;
151
152         switch (node->nodeType()) {
153             case ELEMENT_NODE: {
154                 ++elementNodes;
155
156                 // Tag stats
157                 Element* element = static_cast<Element*>(node);
158                 pair<HashMap<String, size_t>::iterator, bool> result = perTagCount.add(element->tagName(), 1);
159                 if (!result.second)
160                     result.first->second++;
161
162                 // AttributeMap stats
163                 if (NamedNodeMap* attrMap = element->attributes(true)) {
164                     attributes += attrMap->length();
165                     ++attrMaps;
166                     if (attrMap->isMappedAttributeMap())
167                         ++mappedAttrMaps;
168                     for (unsigned i = 0; i < attrMap->length(); ++i) {
169                         Attribute* attr = attrMap->attributeItem(i);
170                         if (attr->attr())
171                             ++attributesWithAttr;
172                         if (attr->isMappedAttribute()) {
173                             ++mappedAttributes;
174                             if (attr->style())
175                                 ++mappedAttributesWithStyleDecl;
176                         }
177                     }
178                 }
179                 break;
180             }
181             case ATTRIBUTE_NODE: {
182                 ++attrNodes;
183                 break;
184             }
185             case TEXT_NODE: {
186                 ++textNodes;
187                 break;
188             }
189             case CDATA_SECTION_NODE: {
190                 ++cdataNodes;
191                 break;
192             }
193             case COMMENT_NODE: {
194                 ++commentNodes;
195                 break;
196             }
197             case ENTITY_REFERENCE_NODE: {
198                 ++entityReferenceNodes;
199                 break;
200             }
201             case ENTITY_NODE: {
202                 ++entityNodes;
203                 break;
204             }
205             case PROCESSING_INSTRUCTION_NODE: {
206                 ++piNodes;
207                 break;
208             }
209             case DOCUMENT_NODE: {
210                 ++documentNodes;
211                 break;
212             }
213             case DOCUMENT_TYPE_NODE: {
214                 ++docTypeNodes;
215                 break;
216             }
217             case DOCUMENT_FRAGMENT_NODE: {
218                 ++fragmentNodes;
219                 break;
220             }
221             case NOTATION_NODE: {
222                 ++notationNodes;
223                 break;
224             }
225             case XPATH_NAMESPACE_NODE: {
226                 ++xpathNSNodes;
227                 break;
228             }
229         }
230             
231     }
232
233     printf("Number of Nodes: %d\n\n", liveNodeSet.size());
234     printf("Number of Nodes with RareData: %zu\n\n", nodesWithRareData);
235
236     printf("NodeType distrubution:\n");
237     printf("  Number of Element nodes: %zu\n", elementNodes);
238     printf("  Number of Attribute nodes: %zu\n", attrNodes);
239     printf("  Number of Text nodes: %zu\n", textNodes);
240     printf("  Number of CDATASection nodes: %zu\n", cdataNodes);
241     printf("  Number of Comment nodes: %zu\n", commentNodes);
242     printf("  Number of EntityReference nodes: %zu\n", entityReferenceNodes);
243     printf("  Number of Entity nodes: %zu\n", entityNodes);
244     printf("  Number of ProcessingInstruction nodes: %zu\n", piNodes);
245     printf("  Number of Document nodes: %zu\n", documentNodes);
246     printf("  Number of DocumentType nodes: %zu\n", docTypeNodes);
247     printf("  Number of DocumentFragment nodes: %zu\n", fragmentNodes);
248     printf("  Number of Notation nodes: %zu\n", notationNodes);
249     printf("  Number of XPathNS nodes: %zu\n", xpathNSNodes);
250
251     printf("Element tag name distibution:\n");
252     for (HashMap<String, size_t>::const_iterator it = perTagCount.begin(); it != perTagCount.end(); ++it)
253         printf("  Number of <%s> tags: %zu\n", it->first.utf8().data(), it->second);
254
255     printf("Attribute Maps:\n");
256     printf("  Number of Attributes (non-Node and Node): %zu [%zu]\n", attributes, sizeof(Attribute));
257     printf("  Number of MappedAttributes: %zu [%zu]\n", mappedAttributes, sizeof(MappedAttribute));
258     printf("  Number of MappedAttributes with a StyleDeclaration: %zu\n", mappedAttributesWithStyleDecl);
259     printf("  Number of Attributes with an Attr: %zu\n", attributesWithAttr);
260     printf("  Number of NamedNodeMaps: %zu\n", attrMaps);
261     printf("  Number of NamedMappedAttrMap: %zu\n", mappedAttrMaps);
262 #endif
263 }
264
265 #ifndef NDEBUG
266 static WTF::RefCountedLeakCounter nodeCounter("WebCoreNode");
267
268 static bool shouldIgnoreLeaks = false;
269 static HashSet<Node*> ignoreSet;
270 #endif
271
272 void Node::startIgnoringLeaks()
273 {
274 #ifndef NDEBUG
275     shouldIgnoreLeaks = true;
276 #endif
277 }
278
279 void Node::stopIgnoringLeaks()
280 {
281 #ifndef NDEBUG
282     shouldIgnoreLeaks = false;
283 #endif
284 }
285
286 Node::StyleChange Node::diff(const RenderStyle* s1, const RenderStyle* s2)
287 {
288     // FIXME: The behavior of this function is just totally wrong.  It doesn't handle
289     // explicit inheritance of non-inherited properties and so you end up not re-resolving
290     // style in cases where you need to.
291     StyleChange ch = NoInherit;
292     EDisplay display1 = s1 ? s1->display() : NONE;
293     bool fl1 = s1 && s1->hasPseudoStyle(FIRST_LETTER);
294     EDisplay display2 = s2 ? s2->display() : NONE;
295     bool fl2 = s2 && s2->hasPseudoStyle(FIRST_LETTER);
296         
297     if (display1 != display2 || fl1 != fl2 || (s1 && s2 && !s1->contentDataEquivalent(s2)))
298         ch = Detach;
299     else if (!s1 || !s2)
300         ch = Inherit;
301     else if (*s1 == *s2)
302         ch = NoChange;
303     else if (s1->inheritedNotEqual(s2))
304         ch = Inherit;
305     
306     // For nth-child and other positional rules, treat styles as different if they have
307     // changed positionally in the DOM. This way subsequent sibling resolutions won't be confused
308     // by the wrong child index and evaluate to incorrect results.
309     if (ch == NoChange && s1->childIndex() != s2->childIndex())
310         ch = NoInherit;
311
312     // If the pseudoStyles have changed, we want any StyleChange that is not NoChange
313     // because setStyle will do the right thing with anything else.
314     if (ch == NoChange && s1->hasPseudoStyle(BEFORE)) {
315         RenderStyle* ps2 = s2->getCachedPseudoStyle(BEFORE);
316         if (!ps2)
317             ch = NoInherit;
318         else {
319             RenderStyle* ps1 = s1->getCachedPseudoStyle(BEFORE);
320             ch = ps1 && *ps1 == *ps2 ? NoChange : NoInherit;
321         }
322     }
323     if (ch == NoChange && s1->hasPseudoStyle(AFTER)) {
324         RenderStyle* ps2 = s2->getCachedPseudoStyle(AFTER);
325         if (!ps2)
326             ch = NoInherit;
327         else {
328             RenderStyle* ps1 = s1->getCachedPseudoStyle(AFTER);
329             ch = ps2 && *ps1 == *ps2 ? NoChange : NoInherit;
330         }
331     }
332     
333     return ch;
334 }
335
336 inline bool Node::initialRefCount(ConstructionType type)
337 {
338     switch (type) {
339         case CreateContainer:
340         case CreateElement:
341         case CreateOther:
342         case CreateText:
343             return 1;
344         case CreateElementZeroRefCount:
345             return 0;
346     }
347     ASSERT_NOT_REACHED();
348     return 1;
349 }
350
351 inline bool Node::isContainer(ConstructionType type)
352 {
353     switch (type) {
354         case CreateContainer:
355         case CreateElement:
356         case CreateElementZeroRefCount:
357             return true;
358         case CreateOther:
359         case CreateText:
360             return false;
361     }
362     ASSERT_NOT_REACHED();
363     return false;
364 }
365
366 inline bool Node::isElement(ConstructionType type)
367 {
368     switch (type) {
369         case CreateContainer:
370         case CreateOther:
371         case CreateText:
372             return false;
373         case CreateElement:
374         case CreateElementZeroRefCount:
375             return true;
376     }
377     ASSERT_NOT_REACHED();
378     return false;
379 }
380
381 inline bool Node::isText(ConstructionType type)
382 {
383     switch (type) {
384         case CreateContainer:
385         case CreateElement:
386         case CreateElementZeroRefCount:
387         case CreateOther:
388             return false;
389         case CreateText:
390             return true;
391     }
392     ASSERT_NOT_REACHED();
393     return false;
394 }
395
396 Node::Node(Document* document, ConstructionType type)
397     : TreeShared<Node>(initialRefCount(type))
398     , m_document(document)
399     , m_previous(0)
400     , m_next(0)
401     , m_renderer(0)
402     , m_styleChange(NoStyleChange)
403     , m_hasId(false)
404     , m_hasClass(false)
405     , m_attached(false)
406     , m_childNeedsStyleRecalc(false)
407     , m_inDocument(false)
408     , m_isLink(false)
409     , m_active(false)
410     , m_hovered(false)
411     , m_inActiveChain(false)
412     , m_inDetach(false)
413     , m_inSubtreeMark(false)
414     , m_hasRareData(false)
415     , m_isElement(isElement(type))
416     , m_isContainer(isContainer(type))
417     , m_isText(isText(type))
418     , m_parsingChildrenFinished(true)
419     , m_isStyleAttributeValid(true)
420     , m_synchronizingStyleAttribute(false)
421 #if ENABLE(SVG)
422     , m_areSVGAttributesValid(true)
423     , m_synchronizingSVGAttributes(false)
424 #endif
425 {
426     if (m_document)
427         m_document->selfOnlyRef();
428
429 #ifndef NDEBUG
430     if (shouldIgnoreLeaks)
431         ignoreSet.add(this);
432     else
433         nodeCounter.increment();
434 #endif
435
436 #if DUMP_NODE_STATISTICS
437     liveNodeSet.add(this);
438 #endif
439 }
440
441 Node::~Node()
442 {
443 #ifndef NDEBUG
444     HashSet<Node*>::iterator it = ignoreSet.find(this);
445     if (it != ignoreSet.end())
446         ignoreSet.remove(it);
447     else
448         nodeCounter.decrement();
449 #endif
450
451 #if DUMP_NODE_STATISTICS
452     liveNodeSet.remove(this);
453 #endif
454
455     if (!hasRareData())
456         ASSERT(!NodeRareData::rareDataMap().contains(this));
457     else {
458         if (m_document && rareData()->nodeLists())
459             m_document->removeNodeListCache();
460         
461         NodeRareData::NodeRareDataMap& dataMap = NodeRareData::rareDataMap();
462         NodeRareData::NodeRareDataMap::iterator it = dataMap.find(this);
463         ASSERT(it != dataMap.end());
464         delete it->second;
465         dataMap.remove(it);
466     }
467
468     if (renderer())
469         detach();
470
471     if (m_previous)
472         m_previous->setNextSibling(0);
473     if (m_next)
474         m_next->setPreviousSibling(0);
475
476     if (m_document)
477         m_document->selfOnlyDeref();
478 }
479
480 #ifdef NDEBUG
481
482 static inline void setWillMoveToNewOwnerDocumentWasCalled(bool)
483 {
484 }
485
486 static inline void setDidMoveToNewOwnerDocumentWasCalled(bool)
487 {
488 }
489
490 #else
491     
492 static bool willMoveToNewOwnerDocumentWasCalled;
493 static bool didMoveToNewOwnerDocumentWasCalled;
494
495 static void setWillMoveToNewOwnerDocumentWasCalled(bool wasCalled)
496 {
497     willMoveToNewOwnerDocumentWasCalled = wasCalled;
498 }
499
500 static void setDidMoveToNewOwnerDocumentWasCalled(bool wasCalled)
501 {
502     didMoveToNewOwnerDocumentWasCalled = wasCalled;
503 }
504     
505 #endif
506     
507 void Node::setDocument(Document* document)
508 {
509     if (inDocument() || m_document == document)
510         return;
511
512     document->selfOnlyRef();
513
514     setWillMoveToNewOwnerDocumentWasCalled(false);
515     willMoveToNewOwnerDocument();
516     ASSERT(willMoveToNewOwnerDocumentWasCalled);
517
518 #if USE(JSC)
519     updateDOMNodeDocument(this, m_document, document);
520 #endif
521
522     if (m_document)
523         m_document->selfOnlyDeref();
524
525     m_document = document;
526
527     setDidMoveToNewOwnerDocumentWasCalled(false);
528     didMoveToNewOwnerDocument();
529     ASSERT(didMoveToNewOwnerDocumentWasCalled);
530 }
531
532 NodeRareData* Node::rareData() const
533 {
534     ASSERT(hasRareData());
535     return NodeRareData::rareDataFromMap(this);
536 }
537
538 NodeRareData* Node::ensureRareData()
539 {
540     if (hasRareData())
541         return rareData();
542     
543     ASSERT(!NodeRareData::rareDataMap().contains(this));
544     NodeRareData* data = createRareData();
545     NodeRareData::rareDataMap().set(this, data);
546     m_hasRareData = true;
547     return data;
548 }
549     
550 NodeRareData* Node::createRareData()
551 {
552     return new NodeRareData;
553 }
554     
555 short Node::tabIndex() const
556 {
557     return hasRareData() ? rareData()->tabIndex() : 0;
558 }
559     
560 void Node::setTabIndexExplicitly(short i)
561 {
562     ensureRareData()->setTabIndexExplicitly(i);
563 }
564
565 String Node::nodeValue() const
566 {
567     return String();
568 }
569
570 void Node::setNodeValue(const String& /*nodeValue*/, ExceptionCode& ec)
571 {
572     // NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly
573     if (isReadOnlyNode()) {
574         ec = NO_MODIFICATION_ALLOWED_ERR;
575         return;
576     }
577
578     // By default, setting nodeValue has no effect.
579 }
580
581 PassRefPtr<NodeList> Node::childNodes()
582 {
583     NodeRareData* data = ensureRareData();
584     if (!data->nodeLists()) {
585         data->setNodeLists(NodeListsNodeData::create());
586         if (document())
587             document()->addNodeListCache();
588     }
589
590     return ChildNodeList::create(this, data->nodeLists()->m_childNodeListCaches.get());
591 }
592
593 Node *Node::lastDescendant() const
594 {
595     Node *n = const_cast<Node *>(this);
596     while (n && n->lastChild())
597         n = n->lastChild();
598     return n;
599 }
600
601 Node* Node::firstDescendant() const
602 {
603     Node *n = const_cast<Node *>(this);
604     while (n && n->firstChild())
605         n = n->firstChild();
606     return n;
607 }
608
609 bool Node::insertBefore(PassRefPtr<Node>, Node*, ExceptionCode& ec, bool)
610 {
611     ec = HIERARCHY_REQUEST_ERR;
612     return false;
613 }
614
615 bool Node::replaceChild(PassRefPtr<Node>, Node*, ExceptionCode& ec, bool)
616 {
617     ec = HIERARCHY_REQUEST_ERR;
618     return false;
619 }
620
621 bool Node::removeChild(Node*, ExceptionCode& ec)
622 {
623     ec = NOT_FOUND_ERR;
624     return false;
625 }
626
627 bool Node::appendChild(PassRefPtr<Node>, ExceptionCode& ec, bool)
628 {
629     ec = HIERARCHY_REQUEST_ERR;
630     return false;
631 }
632
633 void Node::remove(ExceptionCode& ec)
634 {
635     ref();
636     if (Node *p = parentNode())
637         p->removeChild(this, ec);
638     else
639         ec = HIERARCHY_REQUEST_ERR;
640     deref();
641 }
642
643 void Node::normalize()
644 {
645     // Go through the subtree beneath us, normalizing all nodes. This means that
646     // any two adjacent text nodes are merged and any empty text nodes are removed.
647
648     RefPtr<Node> node = this;
649     while (Node* firstChild = node->firstChild())
650         node = firstChild;
651     while (node) {
652         NodeType type = node->nodeType();
653         if (type == ELEMENT_NODE)
654             static_cast<Element*>(node.get())->normalizeAttributes();
655
656         if (node == this)
657             break;
658
659         if (type != TEXT_NODE) {
660             node = node->traverseNextNodePostOrder();
661             continue;
662         }
663
664         Text* text = static_cast<Text*>(node.get());
665
666         // Remove empty text nodes.
667         if (!text->length()) {
668             // Care must be taken to get the next node before removing the current node.
669             node = node->traverseNextNodePostOrder();
670             ExceptionCode ec;
671             text->remove(ec);
672             continue;
673         }
674
675         // Merge text nodes.
676         while (Node* nextSibling = node->nextSibling()) {
677             if (!nextSibling->isTextNode())
678                 break;
679             RefPtr<Text> nextText = static_cast<Text*>(nextSibling);
680
681             // Remove empty text nodes.
682             if (!nextText->length()) {
683                 ExceptionCode ec;
684                 nextText->remove(ec);
685                 continue;
686             }
687
688             // Both non-empty text nodes. Merge them.
689             unsigned offset = text->length();
690             ExceptionCode ec;
691             text->appendData(nextText->data(), ec);
692             document()->textNodesMerged(nextText.get(), offset);
693             nextText->remove(ec);
694         }
695
696         node = node->traverseNextNodePostOrder();
697     }
698 }
699
700 const AtomicString& Node::virtualPrefix() const
701 {
702     // For nodes other than elements and attributes, the prefix is always null
703     return nullAtom;
704 }
705
706 void Node::setPrefix(const AtomicString& /*prefix*/, ExceptionCode& ec)
707 {
708     // The spec says that for nodes other than elements and attributes, prefix is always null.
709     // It does not say what to do when the user tries to set the prefix on another type of
710     // node, however Mozilla throws a NAMESPACE_ERR exception.
711     ec = NAMESPACE_ERR;
712 }
713
714 const AtomicString& Node::virtualLocalName() const
715 {
716     return nullAtom;
717 }
718
719 const AtomicString& Node::virtualNamespaceURI() const
720 {
721     return nullAtom;
722 }
723
724 ContainerNode* Node::addChild(PassRefPtr<Node>)
725 {
726     return 0;
727 }
728
729 bool Node::isContentEditable() const
730 {
731     return parent() && parent()->isContentEditable();
732 }
733
734 bool Node::isContentRichlyEditable() const
735 {
736     return parent() && parent()->isContentRichlyEditable();
737 }
738
739 bool Node::shouldUseInputMethod() const
740 {
741     return isContentEditable();
742 }
743
744 RenderBox* Node::renderBox() const
745 {
746     return m_renderer && m_renderer->isBox() ? toRenderBox(m_renderer) : 0;
747 }
748
749 RenderBoxModelObject* Node::renderBoxModelObject() const
750 {
751     return m_renderer && m_renderer->isBoxModelObject() ? toRenderBoxModelObject(m_renderer) : 0;
752 }
753
754 IntRect Node::getRect() const
755 {
756     // FIXME: broken with transforms
757     if (renderer())
758         return renderer()->absoluteBoundingBoxRect();
759     return IntRect();
760 }
761
762 void Node::setNeedsStyleRecalc(StyleChangeType changeType)
763 {
764     if ((changeType != NoStyleChange) && !attached()) // changed compared to what?
765         return;
766
767     if (!(changeType == InlineStyleChange && (m_styleChange == FullStyleChange || m_styleChange == SyntheticStyleChange)))
768         m_styleChange = changeType;
769
770     if (m_styleChange != NoStyleChange) {
771         for (Node* p = parentNode(); p && !p->childNeedsStyleRecalc(); p = p->parentNode())
772             p->setChildNeedsStyleRecalc(true);
773         if (document()->childNeedsStyleRecalc())
774             document()->scheduleStyleRecalc();
775     }
776 }
777
778 static Node* outermostLazyAttachedAncestor(Node* start)
779 {
780     Node* p = start;
781     for (Node* next = p->parentNode(); !next->renderer(); p = next, next = next->parentNode()) {}
782     return p;
783 }
784
785 void Node::lazyAttach()
786 {
787     bool mustDoFullAttach = false;
788
789     for (Node* n = this; n; n = n->traverseNextNode(this)) {
790         if (!n->canLazyAttach()) {
791             mustDoFullAttach = true;
792             break;
793         }
794
795         if (n->firstChild())
796             n->setChildNeedsStyleRecalc(true);
797         n->m_styleChange = FullStyleChange;
798         n->m_attached = true;
799     }
800
801     if (mustDoFullAttach) {
802         Node* lazyAttachedAncestor = outermostLazyAttachedAncestor(this);
803         if (lazyAttachedAncestor->attached())
804             lazyAttachedAncestor->detach();
805         lazyAttachedAncestor->attach();
806     } else {
807         for (Node* p = parentNode(); p && !p->childNeedsStyleRecalc(); p = p->parentNode())
808             p->setChildNeedsStyleRecalc(true);
809         if (document()->childNeedsStyleRecalc())
810             document()->scheduleStyleRecalc();
811     }
812 }
813
814 bool Node::canLazyAttach()
815 {
816     return shadowAncestorNode() == this;
817 }
818     
819 void Node::setFocus(bool b)
820
821     if (b || hasRareData())
822         ensureRareData()->setFocused(b);
823 }
824
825 bool Node::rareDataFocused() const
826 {
827     ASSERT(hasRareData());
828     return rareData()->isFocused();
829 }
830
831 bool Node::supportsFocus() const
832 {
833     return hasRareData() && rareData()->tabIndexSetExplicitly();
834 }
835     
836 bool Node::isFocusable() const
837 {
838     if (!inDocument() || !supportsFocus())
839         return false;
840     
841     if (renderer())
842         ASSERT(!renderer()->needsLayout());
843     else
844         // If the node is in a display:none tree it might say it needs style recalc but
845         // the whole document is atually up to date.
846         ASSERT(!document()->childNeedsStyleRecalc());
847     
848     // FIXME: Even if we are not visible, we might have a child that is visible.
849     // Hyatt wants to fix that some day with a "has visible content" flag or the like.
850     if (!renderer() || renderer()->style()->visibility() != VISIBLE)
851         return false;
852
853     return true;
854 }
855
856 bool Node::isKeyboardFocusable(KeyboardEvent*) const
857 {
858     return isFocusable() && tabIndex() >= 0;
859 }
860
861 bool Node::isMouseFocusable() const
862 {
863     return isFocusable();
864 }
865
866 unsigned Node::nodeIndex() const
867 {
868     Node *_tempNode = previousSibling();
869     unsigned count=0;
870     for ( count=0; _tempNode; count++ )
871         _tempNode = _tempNode->previousSibling();
872     return count;
873 }
874
875 void Node::registerDynamicNodeList(DynamicNodeList* list)
876 {
877     NodeRareData* data = ensureRareData();
878     if (!data->nodeLists()) {
879         data->setNodeLists(NodeListsNodeData::create());
880         document()->addNodeListCache();
881     } else if (!m_document || !m_document->hasNodeListCaches()) {
882         // We haven't been receiving notifications while there were no registered lists, so the cache is invalid now.
883         data->nodeLists()->invalidateCaches();
884     }
885
886     if (list->hasOwnCaches())
887         data->nodeLists()->m_listsWithCaches.add(list);
888 }
889
890 void Node::unregisterDynamicNodeList(DynamicNodeList* list)
891 {
892     ASSERT(rareData());
893     ASSERT(rareData()->nodeLists());
894     if (list->hasOwnCaches()) {
895         NodeRareData* data = rareData();
896         data->nodeLists()->m_listsWithCaches.remove(list);
897         if (data->nodeLists()->isEmpty()) {
898             data->clearNodeLists();
899             if (document())
900                 document()->removeNodeListCache();
901         }
902     }
903 }
904
905 void Node::notifyLocalNodeListsAttributeChanged()
906 {
907     if (!hasRareData())
908         return;
909     NodeRareData* data = rareData();
910     if (!data->nodeLists())
911         return;
912
913     data->nodeLists()->invalidateCachesThatDependOnAttributes();
914
915     if (data->nodeLists()->isEmpty()) {
916         data->clearNodeLists();
917         document()->removeNodeListCache();
918     }
919 }
920
921 void Node::notifyNodeListsAttributeChanged()
922 {
923     for (Node *n = this; n; n = n->parentNode())
924         n->notifyLocalNodeListsAttributeChanged();
925 }
926
927 void Node::notifyLocalNodeListsChildrenChanged()
928 {
929     if (!hasRareData())
930         return;
931     NodeRareData* data = rareData();
932     if (!data->nodeLists())
933         return;
934
935     data->nodeLists()->invalidateCaches();
936
937     NodeListsNodeData::NodeListSet::iterator end = data->nodeLists()->m_listsWithCaches.end();
938     for (NodeListsNodeData::NodeListSet::iterator i = data->nodeLists()->m_listsWithCaches.begin(); i != end; ++i)
939         (*i)->invalidateCache();
940
941     if (data->nodeLists()->isEmpty()) {
942         data->clearNodeLists();
943         document()->removeNodeListCache();
944     }
945 }
946
947 void Node::notifyNodeListsChildrenChanged()
948 {
949     for (Node* n = this; n; n = n->parentNode())
950         n->notifyLocalNodeListsChildrenChanged();
951 }
952
953 Node *Node::traverseNextNode(const Node *stayWithin) const
954 {
955     if (firstChild())
956         return firstChild();
957     if (this == stayWithin)
958         return 0;
959     if (nextSibling())
960         return nextSibling();
961     const Node *n = this;
962     while (n && !n->nextSibling() && (!stayWithin || n->parentNode() != stayWithin))
963         n = n->parentNode();
964     if (n)
965         return n->nextSibling();
966     return 0;
967 }
968
969 Node *Node::traverseNextSibling(const Node *stayWithin) const
970 {
971     if (this == stayWithin)
972         return 0;
973     if (nextSibling())
974         return nextSibling();
975     const Node *n = this;
976     while (n && !n->nextSibling() && (!stayWithin || n->parentNode() != stayWithin))
977         n = n->parentNode();
978     if (n)
979         return n->nextSibling();
980     return 0;
981 }
982
983 Node* Node::traverseNextNodePostOrder() const
984 {
985     Node* next = nextSibling();
986     if (!next)
987         return parentNode();
988     while (Node* firstChild = next->firstChild())
989         next = firstChild;
990     return next;
991 }
992
993 Node *Node::traversePreviousNode(const Node *stayWithin) const
994 {
995     if (this == stayWithin)
996         return 0;
997     if (previousSibling()) {
998         Node *n = previousSibling();
999         while (n->lastChild())
1000             n = n->lastChild();
1001         return n;
1002     }
1003     return parentNode();
1004 }
1005
1006 Node *Node::traversePreviousNodePostOrder(const Node *stayWithin) const
1007 {
1008     if (lastChild())
1009         return lastChild();
1010     if (this == stayWithin)
1011         return 0;
1012     if (previousSibling())
1013         return previousSibling();
1014     const Node *n = this;
1015     while (n && !n->previousSibling() && (!stayWithin || n->parentNode() != stayWithin))
1016         n = n->parentNode();
1017     if (n)
1018         return n->previousSibling();
1019     return 0;
1020 }
1021
1022 Node* Node::traversePreviousSiblingPostOrder(const Node* stayWithin) const
1023 {
1024     if (this == stayWithin)
1025         return 0;
1026     if (previousSibling())
1027         return previousSibling();
1028     const Node *n = this;
1029     while (n && !n->previousSibling() && (!stayWithin || n->parentNode() != stayWithin))
1030         n = n->parentNode();
1031     if (n)
1032         return n->previousSibling();
1033     return 0;
1034 }
1035
1036 void Node::checkSetPrefix(const AtomicString&, ExceptionCode& ec)
1037 {
1038     // Perform error checking as required by spec for setting Node.prefix. Used by
1039     // Element::setPrefix() and Attr::setPrefix()
1040
1041     // FIXME: Implement support for INVALID_CHARACTER_ERR: Raised if the specified prefix contains an illegal character.
1042     
1043     // NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
1044     if (isReadOnlyNode()) {
1045         ec = NO_MODIFICATION_ALLOWED_ERR;
1046         return;
1047     }
1048
1049     // FIXME: Implement NAMESPACE_ERR: - Raised if the specified prefix is malformed
1050     // We have to comment this out, since it's used for attributes and tag names, and we've only
1051     // switched one over.
1052     /*
1053     // - if the namespaceURI of this node is null,
1054     // - if the specified prefix is "xml" and the namespaceURI of this node is different from
1055     //   "http://www.w3.org/XML/1998/namespace",
1056     // - if this node is an attribute and the specified prefix is "xmlns" and
1057     //   the namespaceURI of this node is different from "http://www.w3.org/2000/xmlns/",
1058     // - or if this node is an attribute and the qualifiedName of this node is "xmlns" [Namespaces].
1059     if ((namespacePart(id()) == noNamespace && id() > ID_LAST_TAG) ||
1060         (_prefix == "xml" && String(document()->namespaceURI(id())) != "http://www.w3.org/XML/1998/namespace")) {
1061         ec = NAMESPACE_ERR;
1062         return;
1063     }*/
1064 }
1065
1066 bool Node::canReplaceChild(Node* newChild, Node*)
1067 {
1068     if (newChild->nodeType() != DOCUMENT_FRAGMENT_NODE) {
1069         if (!childTypeAllowed(newChild->nodeType()))
1070             return false;
1071     } else {
1072         for (Node *n = newChild->firstChild(); n; n = n->nextSibling()) {
1073             if (!childTypeAllowed(n->nodeType())) 
1074                 return false;
1075         }
1076     }
1077     return true;
1078 }
1079
1080 void Node::checkReplaceChild(Node* newChild, Node* oldChild, ExceptionCode& ec)
1081 {
1082     // Perform error checking as required by spec for adding a new child. Used by
1083     // appendChild(), replaceChild() and insertBefore()
1084     
1085     // Not mentioned in spec: throw NOT_FOUND_ERR if newChild is null
1086     if (!newChild) {
1087         ec = NOT_FOUND_ERR;
1088         return;
1089     }
1090     
1091     // NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly
1092     if (isReadOnlyNode()) {
1093         ec = NO_MODIFICATION_ALLOWED_ERR;
1094         return;
1095     }
1096     
1097     bool shouldAdoptChild = false;
1098     
1099     // WRONG_DOCUMENT_ERR: Raised if newChild was created from a different document than the one that
1100     // created this node.
1101     // We assume that if newChild is a DocumentFragment, all children are created from the same document
1102     // as the fragment itself (otherwise they could not have been added as children)
1103     if (newChild->document() != document()) {
1104         // but if the child is not in a document yet then loosen the
1105         // restriction, so that e.g. creating an element with the Option()
1106         // constructor and then adding it to a different document works,
1107         // as it does in Mozilla and Mac IE.
1108         if (!newChild->inDocument()) {
1109             shouldAdoptChild = true;
1110         } else {
1111             ec = WRONG_DOCUMENT_ERR;
1112             return;
1113         }
1114     }
1115     
1116     // HIERARCHY_REQUEST_ERR: Raised if this node is of a type that does not allow children of the type of the
1117     // newChild node, or if the node to append is one of this node's ancestors.
1118     
1119     // check for ancestor/same node
1120     if (newChild == this || isDescendantOf(newChild)) {
1121         ec = HIERARCHY_REQUEST_ERR;
1122         return;
1123     }
1124     
1125     if (!canReplaceChild(newChild, oldChild)) {
1126         ec = HIERARCHY_REQUEST_ERR;
1127         return;
1128     }
1129        
1130     // change the document pointer of newChild and all of its children to be the new document
1131     if (shouldAdoptChild)
1132         for (Node* node = newChild; node; node = node->traverseNextNode(newChild))
1133             node->setDocument(document());
1134 }
1135
1136 void Node::checkAddChild(Node *newChild, ExceptionCode& ec)
1137 {
1138     // Perform error checking as required by spec for adding a new child. Used by
1139     // appendChild(), replaceChild() and insertBefore()
1140
1141     // Not mentioned in spec: throw NOT_FOUND_ERR if newChild is null
1142     if (!newChild) {
1143         ec = NOT_FOUND_ERR;
1144         return;
1145     }
1146
1147     // NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly
1148     if (isReadOnlyNode()) {
1149         ec = NO_MODIFICATION_ALLOWED_ERR;
1150         return;
1151     }
1152
1153     bool shouldAdoptChild = false;
1154
1155     // WRONG_DOCUMENT_ERR: Raised if newChild was created from a different document than the one that
1156     // created this node.
1157     // We assume that if newChild is a DocumentFragment, all children are created from the same document
1158     // as the fragment itself (otherwise they could not have been added as children)
1159     if (newChild->document() != document()) {
1160         // but if the child is not in a document yet then loosen the
1161         // restriction, so that e.g. creating an element with the Option()
1162         // constructor and then adding it to a different document works,
1163         // as it does in Mozilla and Mac IE.
1164         if (!newChild->inDocument()) {
1165             shouldAdoptChild = true;
1166         } else {
1167             ec = WRONG_DOCUMENT_ERR;
1168             return;
1169         }
1170     }
1171
1172     // HIERARCHY_REQUEST_ERR: Raised if this node is of a type that does not allow children of the type of the
1173     // newChild node, or if the node to append is one of this node's ancestors.
1174
1175     // check for ancestor/same node
1176     if (newChild == this || isDescendantOf(newChild)) {
1177         ec = HIERARCHY_REQUEST_ERR;
1178         return;
1179     }
1180     
1181     if (newChild->nodeType() != DOCUMENT_FRAGMENT_NODE) {
1182         if (!childTypeAllowed(newChild->nodeType())) {
1183             ec = HIERARCHY_REQUEST_ERR;
1184             return;
1185         }
1186     }
1187     else {
1188         for (Node *n = newChild->firstChild(); n; n = n->nextSibling()) {
1189             if (!childTypeAllowed(n->nodeType())) {
1190                 ec = HIERARCHY_REQUEST_ERR;
1191                 return;
1192             }
1193         }
1194     }
1195     
1196     // change the document pointer of newChild and all of its children to be the new document
1197     if (shouldAdoptChild)
1198         for (Node* node = newChild; node; node = node->traverseNextNode(newChild))
1199             node->setDocument(document());
1200 }
1201
1202 bool Node::isDescendantOf(const Node *other) const
1203 {
1204     // Return true if other is an ancestor of this, otherwise false
1205     if (!other)
1206         return false;
1207     for (const Node *n = parentNode(); n; n = n->parentNode()) {
1208         if (n == other)
1209             return true;
1210     }
1211     return false;
1212 }
1213
1214 bool Node::contains(const Node* node) const
1215 {
1216     if (!node)
1217         return false;
1218     return this == node || node->isDescendantOf(this);
1219 }
1220
1221 bool Node::childAllowed(Node* newChild)
1222 {
1223     return childTypeAllowed(newChild->nodeType());
1224 }
1225
1226 void Node::attach()
1227 {
1228     ASSERT(!attached());
1229     ASSERT(!renderer() || (renderer()->style() && renderer()->parent()));
1230
1231     // If this node got a renderer it may be the previousRenderer() of sibling text nodes and thus affect the
1232     // result of Text::rendererIsNeeded() for those nodes.
1233     if (renderer()) {
1234         for (Node* next = nextSibling(); next; next = next->nextSibling()) {
1235             if (next->renderer())
1236                 break;
1237             if (!next->attached())
1238                 break;  // Assume this means none of the following siblings are attached.
1239             if (next->isTextNode())
1240                 next->createRendererIfNeeded();
1241         }
1242     }
1243
1244     m_attached = true;
1245 }
1246
1247 void Node::willRemove()
1248 {
1249 }
1250
1251 void Node::detach()
1252 {
1253     m_inDetach = true;
1254
1255     if (renderer())
1256         renderer()->destroy();
1257     setRenderer(0);
1258
1259     Document* doc = document();
1260     if (m_hovered)
1261         doc->hoveredNodeDetached(this);
1262     if (m_inActiveChain)
1263         doc->activeChainNodeDetached(this);
1264
1265     m_active = false;
1266     m_hovered = false;
1267     m_inActiveChain = false;
1268     m_attached = false;
1269     m_inDetach = false;
1270 }
1271
1272 Node *Node::previousEditable() const
1273 {
1274     Node *node = previousLeafNode();
1275     while (node) {
1276         if (node->isContentEditable())
1277             return node;
1278         node = node->previousLeafNode();
1279     }
1280     return 0;
1281 }
1282
1283 Node *Node::nextEditable() const
1284 {
1285     Node *node = nextLeafNode();
1286     while (node) {
1287         if (node->isContentEditable())
1288             return node;
1289         node = node->nextLeafNode();
1290     }
1291     return 0;
1292 }
1293
1294 RenderObject * Node::previousRenderer()
1295 {
1296     for (Node *n = previousSibling(); n; n = n->previousSibling()) {
1297         if (n->renderer())
1298             return n->renderer();
1299     }
1300     return 0;
1301 }
1302
1303 RenderObject * Node::nextRenderer()
1304 {
1305     // Avoid an O(n^2) problem with this function by not checking for nextRenderer() when the parent element hasn't even 
1306     // been attached yet.
1307     if (parent() && !parent()->attached())
1308         return 0;
1309
1310     for (Node *n = nextSibling(); n; n = n->nextSibling()) {
1311         if (n->renderer())
1312             return n->renderer();
1313     }
1314     return 0;
1315 }
1316
1317 // FIXME: This code is used by editing.  Seems like it could move over there and not pollute Node.
1318 Node *Node::previousNodeConsideringAtomicNodes() const
1319 {
1320     if (previousSibling()) {
1321         Node *n = previousSibling();
1322         while (!isAtomicNode(n) && n->lastChild())
1323             n = n->lastChild();
1324         return n;
1325     }
1326     else if (parentNode()) {
1327         return parentNode();
1328     }
1329     else {
1330         return 0;
1331     }
1332 }
1333
1334 Node *Node::nextNodeConsideringAtomicNodes() const
1335 {
1336     if (!isAtomicNode(this) && firstChild())
1337         return firstChild();
1338     if (nextSibling())
1339         return nextSibling();
1340     const Node *n = this;
1341     while (n && !n->nextSibling())
1342         n = n->parentNode();
1343     if (n)
1344         return n->nextSibling();
1345     return 0;
1346 }
1347
1348 Node *Node::previousLeafNode() const
1349 {
1350     Node *node = previousNodeConsideringAtomicNodes();
1351     while (node) {
1352         if (isAtomicNode(node))
1353             return node;
1354         node = node->previousNodeConsideringAtomicNodes();
1355     }
1356     return 0;
1357 }
1358
1359 Node *Node::nextLeafNode() const
1360 {
1361     Node *node = nextNodeConsideringAtomicNodes();
1362     while (node) {
1363         if (isAtomicNode(node))
1364             return node;
1365         node = node->nextNodeConsideringAtomicNodes();
1366     }
1367     return 0;
1368 }
1369
1370 void Node::createRendererIfNeeded()
1371 {
1372     if (!document()->shouldCreateRenderers())
1373         return;
1374
1375     ASSERT(!renderer());
1376     
1377     Node* parent = parentNode();    
1378     ASSERT(parent);
1379     
1380     RenderObject* parentRenderer = parent->renderer();
1381     if (parentRenderer && parentRenderer->canHaveChildren()
1382 #if ENABLE(SVG) || ENABLE(XHTMLMP)
1383         && parent->childShouldCreateRenderer(this)
1384 #endif
1385         ) {
1386         RefPtr<RenderStyle> style = styleForRenderer();
1387         if (rendererIsNeeded(style.get())) {
1388             if (RenderObject* r = createRenderer(document()->renderArena(), style.get())) {
1389                 if (!parentRenderer->isChildAllowed(r, style.get()))
1390                     r->destroy();
1391                 else {
1392                     setRenderer(r);
1393                     renderer()->setAnimatableStyle(style.release());
1394                     parentRenderer->addChild(renderer(), nextRenderer());
1395                 }
1396             }
1397         }
1398     }
1399 }
1400
1401 PassRefPtr<RenderStyle> Node::styleForRenderer()
1402 {
1403     if (isElementNode()) {
1404         bool allowSharing = true;
1405 #if ENABLE(XHTMLMP)
1406         // noscript needs the display property protected - it's a special case
1407         allowSharing = localName() != HTMLNames::noscriptTag.localName();
1408 #endif
1409         return document()->styleSelector()->styleForElement(static_cast<Element*>(this), 0, allowSharing);
1410     }
1411     return parentNode() && parentNode()->renderer() ? parentNode()->renderer()->style() : 0;
1412 }
1413
1414 bool Node::rendererIsNeeded(RenderStyle *style)
1415 {
1416     return (document()->documentElement() == this) || (style->display() != NONE);
1417 }
1418
1419 RenderObject* Node::createRenderer(RenderArena*, RenderStyle*)
1420 {
1421     ASSERT(false);
1422     return 0;
1423 }
1424     
1425 RenderStyle* Node::nonRendererRenderStyle() const
1426
1427     return 0; 
1428 }   
1429
1430 void Node::setRenderStyle(PassRefPtr<RenderStyle> s)
1431 {
1432     if (m_renderer)
1433         m_renderer->setAnimatableStyle(s); 
1434 }
1435
1436 RenderStyle* Node::computedStyle()
1437 {
1438     return parent() ? parent()->computedStyle() : 0;
1439 }
1440
1441 int Node::maxCharacterOffset() const
1442 {
1443     ASSERT_NOT_REACHED();
1444     return 0;
1445 }
1446
1447 // FIXME: Shouldn't these functions be in the editing code?  Code that asks questions about HTML in the core DOM class
1448 // is obviously misplaced.
1449 bool Node::canStartSelection() const
1450 {
1451     if (isContentEditable())
1452         return true;
1453
1454     if (renderer()) {
1455         RenderStyle* style = renderer()->style();
1456         // We allow selections to begin within an element that has -webkit-user-select: none set,
1457         // but if the element is draggable then dragging should take priority over selection.
1458         if (style->userDrag() == DRAG_ELEMENT && style->userSelect() == SELECT_NONE)
1459             return false;
1460     }
1461     return parent() ? parent()->canStartSelection() : true;
1462 }
1463
1464 Node* Node::shadowAncestorNode()
1465 {
1466 #if ENABLE(SVG)
1467     // SVG elements living in a shadow tree only occour when <use> created them.
1468     // For these cases we do NOT want to return the shadowParentNode() here
1469     // but the actual shadow tree element - as main difference to the HTML forms
1470     // shadow tree concept. (This function _could_ be made virtual - opinions?)
1471     if (isSVGElement())
1472         return this;
1473 #endif
1474
1475     Node* root = shadowTreeRootNode();
1476     if (root)
1477         return root->shadowParentNode();
1478     return this;
1479 }
1480
1481 Node* Node::shadowTreeRootNode()
1482 {
1483     Node* root = this;
1484     while (root) {
1485         if (root->isShadowNode())
1486             return root;
1487         root = root->parentNode();
1488     }
1489     return 0;
1490 }
1491
1492 bool Node::isInShadowTree()
1493 {
1494     for (Node* n = this; n; n = n->parentNode())
1495         if (n->isShadowNode())
1496             return true;
1497     return false;
1498 }
1499
1500 bool Node::isBlockFlow() const
1501 {
1502     return renderer() && renderer()->isBlockFlow();
1503 }
1504
1505 bool Node::isBlockFlowOrBlockTable() const
1506 {
1507     return renderer() && (renderer()->isBlockFlow() || (renderer()->isTable() && !renderer()->isInline()));
1508 }
1509
1510 bool Node::isEditableBlock() const
1511 {
1512     return isContentEditable() && isBlockFlow();
1513 }
1514
1515 Element *Node::enclosingBlockFlowElement() const
1516 {
1517     Node *n = const_cast<Node *>(this);
1518     if (isBlockFlow())
1519         return static_cast<Element *>(n);
1520
1521     while (1) {
1522         n = n->parentNode();
1523         if (!n)
1524             break;
1525         if (n->isBlockFlow() || n->hasTagName(bodyTag))
1526             return static_cast<Element *>(n);
1527     }
1528     return 0;
1529 }
1530
1531 Element *Node::enclosingInlineElement() const
1532 {
1533     Node *n = const_cast<Node *>(this);
1534     Node *p;
1535
1536     while (1) {
1537         p = n->parentNode();
1538         if (!p || p->isBlockFlow() || p->hasTagName(bodyTag))
1539             return static_cast<Element *>(n);
1540         // Also stop if any previous sibling is a block
1541         for (Node *sibling = n->previousSibling(); sibling; sibling = sibling->previousSibling()) {
1542             if (sibling->isBlockFlow())
1543                 return static_cast<Element *>(n);
1544         }
1545         n = p;
1546     }
1547     ASSERT_NOT_REACHED();
1548     return 0;
1549 }
1550
1551 Element* Node::rootEditableElement() const
1552 {
1553     Element* result = 0;
1554     for (Node* n = const_cast<Node*>(this); n && n->isContentEditable(); n = n->parentNode()) {
1555         if (n->isElementNode())
1556             result = static_cast<Element*>(n);
1557         if (n->hasTagName(bodyTag))
1558             break;
1559     }
1560     return result;
1561 }
1562
1563 bool Node::inSameContainingBlockFlowElement(Node *n)
1564 {
1565     return n ? enclosingBlockFlowElement() == n->enclosingBlockFlowElement() : false;
1566 }
1567
1568 // FIXME: End of obviously misplaced HTML editing functions.  Try to move these out of Node.
1569
1570 PassRefPtr<NodeList> Node::getElementsByTagName(const String& name)
1571 {
1572     return getElementsByTagNameNS(starAtom, name);
1573 }
1574  
1575 PassRefPtr<NodeList> Node::getElementsByTagNameNS(const AtomicString& namespaceURI, const String& localName)
1576 {
1577     if (localName.isNull())
1578         return 0;
1579     
1580     NodeRareData* data = ensureRareData();
1581     if (!data->nodeLists()) {
1582         data->setNodeLists(NodeListsNodeData::create());
1583         document()->addNodeListCache();
1584     }
1585
1586     String name = localName;
1587     if (document()->isHTMLDocument())
1588         name = localName.lower();
1589     
1590     AtomicString localNameAtom = name;
1591         
1592     pair<NodeListsNodeData::TagCacheMap::iterator, bool> result = data->nodeLists()->m_tagNodeListCaches.add(QualifiedName(nullAtom, localNameAtom, namespaceURI), 0);
1593     if (result.second)
1594         result.first->second = DynamicNodeList::Caches::create();
1595     
1596     return TagNodeList::create(this, namespaceURI.isEmpty() ? nullAtom : namespaceURI, localNameAtom, result.first->second.get());
1597 }
1598
1599 PassRefPtr<NodeList> Node::getElementsByName(const String& elementName)
1600 {
1601     NodeRareData* data = ensureRareData();
1602     if (!data->nodeLists()) {
1603         data->setNodeLists(NodeListsNodeData::create());
1604         document()->addNodeListCache();
1605     }
1606
1607     pair<NodeListsNodeData::CacheMap::iterator, bool> result = data->nodeLists()->m_nameNodeListCaches.add(elementName, 0);
1608     if (result.second)
1609         result.first->second = DynamicNodeList::Caches::create();
1610     
1611     return NameNodeList::create(this, elementName, result.first->second.get());
1612 }
1613
1614 PassRefPtr<NodeList> Node::getElementsByClassName(const String& classNames)
1615 {
1616     NodeRareData* data = ensureRareData();
1617     if (!data->nodeLists()) {
1618         data->setNodeLists(NodeListsNodeData::create());
1619         document()->addNodeListCache();
1620     }
1621
1622     pair<NodeListsNodeData::CacheMap::iterator, bool> result = data->nodeLists()->m_classNodeListCaches.add(classNames, 0);
1623     if (result.second)
1624         result.first->second = DynamicNodeList::Caches::create();
1625     
1626     return ClassNodeList::create(this, classNames, result.first->second.get());
1627 }
1628
1629 PassRefPtr<Element> Node::querySelector(const String& selectors, ExceptionCode& ec)
1630 {
1631     if (selectors.isEmpty()) {
1632         ec = SYNTAX_ERR;
1633         return 0;
1634     }
1635     bool strictParsing = !document()->inCompatMode();
1636     CSSParser p(strictParsing);
1637
1638     CSSSelectorList querySelectorList;
1639     p.parseSelector(selectors, document(), querySelectorList);
1640
1641     if (!querySelectorList.first()) {
1642         ec = SYNTAX_ERR;
1643         return 0;
1644     }
1645
1646     // throw a NAMESPACE_ERR if the selector includes any namespace prefixes.
1647     if (querySelectorList.selectorsNeedNamespaceResolution()) {
1648         ec = NAMESPACE_ERR;
1649         return 0;
1650     }
1651
1652     CSSStyleSelector::SelectorChecker selectorChecker(document(), strictParsing);
1653
1654     // FIXME: we could also optimize for the the [id="foo"] case
1655     if (strictParsing && inDocument() && querySelectorList.hasOneSelector() && querySelectorList.first()->m_match == CSSSelector::Id) {
1656         ASSERT(querySelectorList.first()->attribute() == idAttr);
1657         Element* element = document()->getElementById(querySelectorList.first()->m_value);
1658         if (element && (isDocumentNode() || element->isDescendantOf(this)) && selectorChecker.checkSelector(querySelectorList.first(), element))
1659             return element;
1660         return 0;
1661     }
1662
1663     // FIXME: We can speed this up by implementing caching similar to the one use by getElementById
1664     for (Node* n = firstChild(); n; n = n->traverseNextNode(this)) {
1665         if (n->isElementNode()) {
1666             Element* element = static_cast<Element*>(n);
1667             for (CSSSelector* selector = querySelectorList.first(); selector; selector = CSSSelectorList::next(selector)) {
1668                 if (selectorChecker.checkSelector(selector, element))
1669                     return element;
1670             }
1671         }
1672     }
1673     
1674     return 0;
1675 }
1676
1677 PassRefPtr<NodeList> Node::querySelectorAll(const String& selectors, ExceptionCode& ec)
1678 {
1679     if (selectors.isEmpty()) {
1680         ec = SYNTAX_ERR;
1681         return 0;
1682     }
1683     bool strictParsing = !document()->inCompatMode();
1684     CSSParser p(strictParsing);
1685
1686     CSSSelectorList querySelectorList;
1687     p.parseSelector(selectors, document(), querySelectorList);
1688
1689     if (!querySelectorList.first()) {
1690         ec = SYNTAX_ERR;
1691         return 0;
1692     }
1693
1694     // Throw a NAMESPACE_ERR if the selector includes any namespace prefixes.
1695     if (querySelectorList.selectorsNeedNamespaceResolution()) {
1696         ec = NAMESPACE_ERR;
1697         return 0;
1698     }
1699
1700     return createSelectorNodeList(this, querySelectorList);
1701 }
1702
1703 Document *Node::ownerDocument() const
1704 {
1705     Document *doc = document();
1706     return doc == this ? 0 : doc;
1707 }
1708
1709 KURL Node::baseURI() const
1710 {
1711     return parentNode() ? parentNode()->baseURI() : KURL();
1712 }
1713
1714 bool Node::isEqualNode(Node *other) const
1715 {
1716     if (!other)
1717         return false;
1718     
1719     if (nodeType() != other->nodeType())
1720         return false;
1721     
1722     if (nodeName() != other->nodeName())
1723         return false;
1724     
1725     if (localName() != other->localName())
1726         return false;
1727     
1728     if (namespaceURI() != other->namespaceURI())
1729         return false;
1730     
1731     if (prefix() != other->prefix())
1732         return false;
1733     
1734     if (nodeValue() != other->nodeValue())
1735         return false;
1736     
1737     NamedNodeMap *attrs = attributes();
1738     NamedNodeMap *otherAttrs = other->attributes();
1739     
1740     if (!attrs && otherAttrs)
1741         return false;
1742     
1743     if (attrs && !attrs->mapsEquivalent(otherAttrs))
1744         return false;
1745     
1746     Node *child = firstChild();
1747     Node *otherChild = other->firstChild();
1748     
1749     while (child) {
1750         if (!child->isEqualNode(otherChild))
1751             return false;
1752         
1753         child = child->nextSibling();
1754         otherChild = otherChild->nextSibling();
1755     }
1756     
1757     if (otherChild)
1758         return false;
1759     
1760     // FIXME: For DocumentType nodes we should check equality on
1761     // the entities and notations NamedNodeMaps as well.
1762     
1763     return true;
1764 }
1765
1766 bool Node::isDefaultNamespace(const AtomicString &namespaceURI) const
1767 {
1768     // Implemented according to
1769     // http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/namespaces-algorithms.html#isDefaultNamespaceAlgo
1770     
1771     switch (nodeType()) {
1772         case ELEMENT_NODE: {
1773             const Element *elem = static_cast<const Element *>(this);
1774             
1775             if (elem->prefix().isNull())
1776                 return elem->namespaceURI() == namespaceURI;
1777
1778             if (elem->hasAttributes()) {
1779                 NamedNodeMap *attrs = elem->attributes();
1780                 
1781                 for (unsigned i = 0; i < attrs->length(); i++) {
1782                     Attribute *attr = attrs->attributeItem(i);
1783                     
1784                     if (attr->localName() == "xmlns")
1785                         return attr->value() == namespaceURI;
1786                 }
1787             }
1788
1789             if (Element* ancestor = ancestorElement())
1790                 return ancestor->isDefaultNamespace(namespaceURI);
1791
1792             return false;
1793         }
1794         case DOCUMENT_NODE:
1795             if (Element* de = static_cast<const Document*>(this)->documentElement())
1796                 return de->isDefaultNamespace(namespaceURI);
1797             return false;
1798         case ENTITY_NODE:
1799         case NOTATION_NODE:
1800         case DOCUMENT_TYPE_NODE:
1801         case DOCUMENT_FRAGMENT_NODE:
1802             return false;
1803         case ATTRIBUTE_NODE: {
1804             const Attr *attr = static_cast<const Attr *>(this);
1805             if (attr->ownerElement())
1806                 return attr->ownerElement()->isDefaultNamespace(namespaceURI);
1807             return false;
1808         }
1809         default:
1810             if (Element* ancestor = ancestorElement())
1811                 return ancestor->isDefaultNamespace(namespaceURI);
1812             return false;
1813     }
1814 }
1815
1816 String Node::lookupPrefix(const AtomicString &namespaceURI) const
1817 {
1818     // Implemented according to
1819     // http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/namespaces-algorithms.html#lookupNamespacePrefixAlgo
1820     
1821     if (namespaceURI.isEmpty())
1822         return String();
1823     
1824     switch (nodeType()) {
1825         case ELEMENT_NODE:
1826             return lookupNamespacePrefix(namespaceURI, static_cast<const Element *>(this));
1827         case DOCUMENT_NODE:
1828             if (Element* de = static_cast<const Document*>(this)->documentElement())
1829                 return de->lookupPrefix(namespaceURI);
1830             return String();
1831         case ENTITY_NODE:
1832         case NOTATION_NODE:
1833         case DOCUMENT_FRAGMENT_NODE:
1834         case DOCUMENT_TYPE_NODE:
1835             return String();
1836         case ATTRIBUTE_NODE: {
1837             const Attr *attr = static_cast<const Attr *>(this);
1838             if (attr->ownerElement())
1839                 return attr->ownerElement()->lookupPrefix(namespaceURI);
1840             return String();
1841         }
1842         default:
1843             if (Element* ancestor = ancestorElement())
1844                 return ancestor->lookupPrefix(namespaceURI);
1845             return String();
1846     }
1847 }
1848
1849 String Node::lookupNamespaceURI(const String &prefix) const
1850 {
1851     // Implemented according to
1852     // http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/namespaces-algorithms.html#lookupNamespaceURIAlgo
1853     
1854     if (!prefix.isNull() && prefix.isEmpty())
1855         return String();
1856     
1857     switch (nodeType()) {
1858         case ELEMENT_NODE: {
1859             const Element *elem = static_cast<const Element *>(this);
1860             
1861             if (!elem->namespaceURI().isNull() && elem->prefix() == prefix)
1862                 return elem->namespaceURI();
1863             
1864             if (elem->hasAttributes()) {
1865                 NamedNodeMap *attrs = elem->attributes();
1866                 
1867                 for (unsigned i = 0; i < attrs->length(); i++) {
1868                     Attribute *attr = attrs->attributeItem(i);
1869                     
1870                     if (attr->prefix() == "xmlns" && attr->localName() == prefix) {
1871                         if (!attr->value().isEmpty())
1872                             return attr->value();
1873                         
1874                         return String();
1875                     } else if (attr->localName() == "xmlns" && prefix.isNull()) {
1876                         if (!attr->value().isEmpty())
1877                             return attr->value();
1878                         
1879                         return String();
1880                     }
1881                 }
1882             }
1883             if (Element* ancestor = ancestorElement())
1884                 return ancestor->lookupNamespaceURI(prefix);
1885             return String();
1886         }
1887         case DOCUMENT_NODE:
1888             if (Element* de = static_cast<const Document*>(this)->documentElement())
1889                 return de->lookupNamespaceURI(prefix);
1890             return String();
1891         case ENTITY_NODE:
1892         case NOTATION_NODE:
1893         case DOCUMENT_TYPE_NODE:
1894         case DOCUMENT_FRAGMENT_NODE:
1895             return String();
1896         case ATTRIBUTE_NODE: {
1897             const Attr *attr = static_cast<const Attr *>(this);
1898             
1899             if (attr->ownerElement())
1900                 return attr->ownerElement()->lookupNamespaceURI(prefix);
1901             else
1902                 return String();
1903         }
1904         default:
1905             if (Element* ancestor = ancestorElement())
1906                 return ancestor->lookupNamespaceURI(prefix);
1907             return String();
1908     }
1909 }
1910
1911 String Node::lookupNamespacePrefix(const AtomicString &_namespaceURI, const Element *originalElement) const
1912 {
1913     if (_namespaceURI.isNull())
1914         return String();
1915             
1916     if (originalElement->lookupNamespaceURI(prefix()) == _namespaceURI)
1917         return prefix();
1918     
1919     if (hasAttributes()) {
1920         NamedNodeMap *attrs = attributes();
1921         
1922         for (unsigned i = 0; i < attrs->length(); i++) {
1923             Attribute *attr = attrs->attributeItem(i);
1924             
1925             if (attr->prefix() == "xmlns" &&
1926                 attr->value() == _namespaceURI &&
1927                 originalElement->lookupNamespaceURI(attr->localName()) == _namespaceURI)
1928                 return attr->localName();
1929         }
1930     }
1931     
1932     if (Element* ancestor = ancestorElement())
1933         return ancestor->lookupNamespacePrefix(_namespaceURI, originalElement);
1934     return String();
1935 }
1936
1937 void Node::appendTextContent(bool convertBRsToNewlines, StringBuilder& content) const
1938 {
1939     switch (nodeType()) {
1940         case TEXT_NODE:
1941         case CDATA_SECTION_NODE:
1942         case COMMENT_NODE:
1943             content.append(static_cast<const CharacterData*>(this)->data());
1944             break;
1945
1946         case PROCESSING_INSTRUCTION_NODE:
1947             content.append(static_cast<const ProcessingInstruction*>(this)->data());
1948             break;
1949         
1950         case ELEMENT_NODE:
1951             if (hasTagName(brTag) && convertBRsToNewlines) {
1952                 content.append('\n');
1953                 break;
1954         }
1955         // Fall through.
1956         case ATTRIBUTE_NODE:
1957         case ENTITY_NODE:
1958         case ENTITY_REFERENCE_NODE:
1959         case DOCUMENT_FRAGMENT_NODE:
1960             content.setNonNull();
1961
1962             for (Node *child = firstChild(); child; child = child->nextSibling()) {
1963                 if (child->nodeType() == COMMENT_NODE || child->nodeType() == PROCESSING_INSTRUCTION_NODE)
1964                     continue;
1965             
1966                 child->appendTextContent(convertBRsToNewlines, content);
1967             }
1968             break;
1969
1970         case DOCUMENT_NODE:
1971         case DOCUMENT_TYPE_NODE:
1972         case NOTATION_NODE:
1973         case XPATH_NAMESPACE_NODE:
1974             break;
1975     }
1976 }
1977
1978 String Node::textContent(bool convertBRsToNewlines) const
1979 {
1980     StringBuilder content;
1981     appendTextContent(convertBRsToNewlines, content);
1982     return content.toString();
1983 }
1984
1985 void Node::setTextContent(const String &text, ExceptionCode& ec)
1986 {           
1987     switch (nodeType()) {
1988         case TEXT_NODE:
1989         case CDATA_SECTION_NODE:
1990         case COMMENT_NODE:
1991         case PROCESSING_INSTRUCTION_NODE:
1992             setNodeValue(text, ec);
1993             break;
1994         case ELEMENT_NODE:
1995         case ATTRIBUTE_NODE:
1996         case ENTITY_NODE:
1997         case ENTITY_REFERENCE_NODE:
1998         case DOCUMENT_FRAGMENT_NODE: {
1999             ContainerNode *container = static_cast<ContainerNode *>(this);
2000             
2001             container->removeChildren();
2002             
2003             if (!text.isEmpty())
2004                 appendChild(document()->createTextNode(text), ec);
2005             break;
2006         }
2007         case DOCUMENT_NODE:
2008         case DOCUMENT_TYPE_NODE:
2009         case NOTATION_NODE:
2010         default:
2011             // Do nothing
2012             break;
2013     }
2014 }
2015
2016 Element* Node::ancestorElement() const
2017 {
2018     // In theory, there can be EntityReference nodes between elements, but this is currently not supported.
2019     for (Node* n = parentNode(); n; n = n->parentNode()) {
2020         if (n->isElementNode())
2021             return static_cast<Element*>(n);
2022     }
2023     return 0;
2024 }
2025
2026 bool Node::offsetInCharacters() const
2027 {
2028     return false;
2029 }
2030
2031 unsigned short Node::compareDocumentPosition(Node* otherNode)
2032 {
2033     // It is not clear what should be done if |otherNode| is 0.
2034     if (!otherNode)
2035         return DOCUMENT_POSITION_DISCONNECTED;
2036
2037     if (otherNode == this)
2038         return DOCUMENT_POSITION_EQUIVALENT;
2039     
2040     Attr* attr1 = nodeType() == ATTRIBUTE_NODE ? static_cast<Attr*>(this) : 0;
2041     Attr* attr2 = otherNode->nodeType() == ATTRIBUTE_NODE ? static_cast<Attr*>(otherNode) : 0;
2042     
2043     Node* start1 = attr1 ? attr1->ownerElement() : this;
2044     Node* start2 = attr2 ? attr2->ownerElement() : otherNode;
2045     
2046     // If either of start1 or start2 is null, then we are disconnected, since one of the nodes is
2047     // an orphaned attribute node.
2048     if (!start1 || !start2)
2049         return DOCUMENT_POSITION_DISCONNECTED | DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC;
2050
2051     Vector<Node*, 16> chain1;
2052     Vector<Node*, 16> chain2;
2053     if (attr1)
2054         chain1.append(attr1);
2055     if (attr2)
2056         chain2.append(attr2);
2057     
2058     if (attr1 && attr2 && start1 == start2 && start1) {
2059         // We are comparing two attributes on the same node.  Crawl our attribute map
2060         // and see which one we hit first.
2061         NamedNodeMap* map = attr1->ownerElement()->attributes(true);
2062         unsigned length = map->length();
2063         for (unsigned i = 0; i < length; ++i) {
2064             // If neither of the two determining nodes is a child node and nodeType is the same for both determining nodes, then an 
2065             // implementation-dependent order between the determining nodes is returned. This order is stable as long as no nodes of
2066             // the same nodeType are inserted into or removed from the direct container. This would be the case, for example, 
2067             // when comparing two attributes of the same element, and inserting or removing additional attributes might change 
2068             // the order between existing attributes.
2069             Attribute* attr = map->attributeItem(i);
2070             if (attr1->attr() == attr)
2071                 return DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC | DOCUMENT_POSITION_FOLLOWING;
2072             if (attr2->attr() == attr)
2073                 return DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC | DOCUMENT_POSITION_PRECEDING;
2074         }
2075         
2076         ASSERT_NOT_REACHED();
2077         return DOCUMENT_POSITION_DISCONNECTED;
2078     }
2079
2080     // If one node is in the document and the other is not, we must be disconnected.
2081     // If the nodes have different owning documents, they must be disconnected.  Note that we avoid
2082     // comparing Attr nodes here, since they return false from inDocument() all the time (which seems like a bug).
2083     if (start1->inDocument() != start2->inDocument() ||
2084         start1->document() != start2->document())
2085         return DOCUMENT_POSITION_DISCONNECTED | DOCUMENT_POSITION_IMPLEMENTATION_SPECIFIC;
2086
2087     // We need to find a common ancestor container, and then compare the indices of the two immediate children.
2088     Node* current;
2089     for (current = start1; current; current = current->parentNode())
2090         chain1.append(current);
2091     for (current = start2; current; current = current->parentNode())
2092         chain2.append(current);
2093    
2094     // Walk the two chains backwards and look for the first difference.
2095     unsigned index1 = chain1.size();
2096     unsigned index2 = chain2.size();
2097     for (unsigned i = min(index1, index2); i; --i) {
2098         Node* child1 = chain1[--index1];
2099         Node* child2 = chain2[--index2];
2100         if (child1 != child2) {
2101             // If one of the children is an attribute, it wins.
2102             if (child1->nodeType() == ATTRIBUTE_NODE)
2103                 return DOCUMENT_POSITION_FOLLOWING;
2104             if (child2->nodeType() == ATTRIBUTE_NODE)
2105                 return DOCUMENT_POSITION_PRECEDING;
2106             
2107             if (!child2->nextSibling())
2108                 return DOCUMENT_POSITION_FOLLOWING;
2109             if (!child1->nextSibling())
2110                 return DOCUMENT_POSITION_PRECEDING;
2111
2112             // Otherwise we need to see which node occurs first.  Crawl backwards from child2 looking for child1.
2113             for (Node* child = child2->previousSibling(); child; child = child->previousSibling()) {
2114                 if (child == child1)
2115                     return DOCUMENT_POSITION_FOLLOWING;
2116             }
2117             return DOCUMENT_POSITION_PRECEDING;
2118         }
2119     }
2120     
2121     // There was no difference between the two parent chains, i.e., one was a subset of the other.  The shorter
2122     // chain is the ancestor.
2123     return index1 < index2 ? 
2124                DOCUMENT_POSITION_FOLLOWING | DOCUMENT_POSITION_CONTAINED_BY :
2125                DOCUMENT_POSITION_PRECEDING | DOCUMENT_POSITION_CONTAINS;
2126 }
2127
2128 FloatPoint Node::convertToPage(const FloatPoint& p) const
2129 {
2130     // If there is a renderer, just ask it to do the conversion
2131     if (renderer())
2132         return renderer()->localToAbsolute(p, false, true);
2133     
2134     // Otherwise go up the tree looking for a renderer
2135     Element *parent = ancestorElement();
2136     if (parent)
2137         return parent->convertToPage(p);
2138
2139     // No parent - no conversion needed
2140     return p;
2141 }
2142
2143 FloatPoint Node::convertFromPage(const FloatPoint& p) const
2144 {
2145     // If there is a renderer, just ask it to do the conversion
2146     if (renderer())
2147         return renderer()->absoluteToLocal(p, false, true);
2148
2149     // Otherwise go up the tree looking for a renderer
2150     Element *parent = ancestorElement();
2151     if (parent)
2152         return parent->convertFromPage(p);
2153
2154     // No parent - no conversion needed
2155     return p;
2156 }
2157
2158 #ifndef NDEBUG
2159
2160 static void appendAttributeDesc(const Node* node, String& string, const QualifiedName& name, const char* attrDesc)
2161 {
2162     if (node->isElementNode()) {
2163         String attr = static_cast<const Element*>(node)->getAttribute(name);
2164         if (!attr.isEmpty()) {
2165             string += attrDesc;
2166             string += attr;
2167         }
2168     }
2169 }
2170
2171 void Node::showNode(const char* prefix) const
2172 {
2173     if (!prefix)
2174         prefix = "";
2175     if (isTextNode()) {
2176         String value = nodeValue();
2177         value.replace('\\', "\\\\");
2178         value.replace('\n', "\\n");
2179         fprintf(stderr, "%s%s\t%p \"%s\"\n", prefix, nodeName().utf8().data(), this, value.utf8().data());
2180     } else {
2181         String attrs = "";
2182         appendAttributeDesc(this, attrs, classAttr, " CLASS=");
2183         appendAttributeDesc(this, attrs, styleAttr, " STYLE=");
2184         fprintf(stderr, "%s%s\t%p%s\n", prefix, nodeName().utf8().data(), this, attrs.utf8().data());
2185     }
2186 }
2187
2188 void Node::showTreeForThis() const
2189 {
2190     showTreeAndMark(this, "*");
2191 }
2192
2193 void Node::showTreeAndMark(const Node* markedNode1, const char* markedLabel1, const Node* markedNode2, const char * markedLabel2) const
2194 {
2195     const Node* rootNode;
2196     const Node* node = this;
2197     while (node->parentNode() && !node->hasTagName(bodyTag))
2198         node = node->parentNode();
2199     rootNode = node;
2200         
2201     for (node = rootNode; node; node = node->traverseNextNode()) {
2202         if (node == markedNode1)
2203             fprintf(stderr, "%s", markedLabel1);
2204         if (node == markedNode2)
2205             fprintf(stderr, "%s", markedLabel2);
2206                         
2207         for (const Node* tmpNode = node; tmpNode && tmpNode != rootNode; tmpNode = tmpNode->parentNode())
2208             fprintf(stderr, "\t");
2209         node->showNode();
2210     }
2211 }
2212
2213 void Node::formatForDebugger(char* buffer, unsigned length) const
2214 {
2215     String result;
2216     String s;
2217     
2218     s = nodeName();
2219     if (s.length() == 0)
2220         result += "<none>";
2221     else
2222         result += s;
2223           
2224     strncpy(buffer, result.utf8().data(), length - 1);
2225 }
2226
2227 #endif
2228
2229 // --------
2230
2231 void NodeListsNodeData::invalidateCaches()
2232 {
2233     m_childNodeListCaches->reset();
2234     TagCacheMap::const_iterator tagCachesEnd = m_tagNodeListCaches.end();
2235     for (TagCacheMap::const_iterator it = m_tagNodeListCaches.begin(); it != tagCachesEnd; ++it)
2236         it->second->reset();
2237     invalidateCachesThatDependOnAttributes();
2238 }
2239
2240 void NodeListsNodeData::invalidateCachesThatDependOnAttributes()
2241 {
2242     CacheMap::iterator classCachesEnd = m_classNodeListCaches.end();
2243     for (CacheMap::iterator it = m_classNodeListCaches.begin(); it != classCachesEnd; ++it)
2244         it->second->reset();
2245
2246     CacheMap::iterator nameCachesEnd = m_nameNodeListCaches.end();
2247     for (CacheMap::iterator it = m_nameNodeListCaches.begin(); it != nameCachesEnd; ++it)
2248         it->second->reset();
2249 }
2250
2251 bool NodeListsNodeData::isEmpty() const
2252 {
2253     if (!m_listsWithCaches.isEmpty())
2254         return false;
2255
2256     if (m_childNodeListCaches->refCount())
2257         return false;
2258     
2259     TagCacheMap::const_iterator tagCachesEnd = m_tagNodeListCaches.end();
2260     for (TagCacheMap::const_iterator it = m_tagNodeListCaches.begin(); it != tagCachesEnd; ++it) {
2261         if (it->second->refCount())
2262             return false;
2263     }
2264
2265     CacheMap::const_iterator classCachesEnd = m_classNodeListCaches.end();
2266     for (CacheMap::const_iterator it = m_classNodeListCaches.begin(); it != classCachesEnd; ++it) {
2267         if (it->second->refCount())
2268             return false;
2269     }
2270
2271     CacheMap::const_iterator nameCachesEnd = m_nameNodeListCaches.end();
2272     for (CacheMap::const_iterator it = m_nameNodeListCaches.begin(); it != nameCachesEnd; ++it) {
2273         if (it->second->refCount())
2274             return false;
2275     }
2276
2277     return true;
2278 }
2279
2280 void Node::getSubresourceURLs(ListHashSet<KURL>& urls) const
2281 {
2282     addSubresourceAttributeURLs(urls);
2283 }
2284
2285 ContainerNode* Node::eventParentNode()
2286 {
2287     Node* parent = parentNode();
2288     ASSERT(!parent || parent->isContainerNode());
2289     return static_cast<ContainerNode*>(parent);
2290 }
2291
2292 // --------
2293
2294 ScriptExecutionContext* Node::scriptExecutionContext() const
2295 {
2296     return document();
2297 }
2298
2299 void Node::insertedIntoDocument()
2300 {
2301     setInDocument(true);
2302 }
2303
2304 void Node::removedFromDocument()
2305 {
2306     setInDocument(false);
2307 }
2308
2309 void Node::willMoveToNewOwnerDocument()
2310 {
2311     ASSERT(!willMoveToNewOwnerDocumentWasCalled);
2312     setWillMoveToNewOwnerDocumentWasCalled(true);
2313 }
2314
2315 void Node::didMoveToNewOwnerDocument()
2316 {
2317     ASSERT(!didMoveToNewOwnerDocumentWasCalled);
2318     setDidMoveToNewOwnerDocumentWasCalled(true);
2319 }
2320
2321 static inline void updateSVGElementInstancesAfterEventListenerChange(Node* referenceNode)
2322 {
2323 #if !ENABLE(SVG)
2324     UNUSED_PARAM(referenceNode);
2325 #else
2326     ASSERT(referenceNode);
2327     if (!referenceNode->isSVGElement())
2328         return;
2329
2330     // Elements living inside a <use> shadow tree, never cause any updates!
2331     if (referenceNode->shadowTreeRootNode())
2332         return;
2333
2334     // We're possibly (a child of) an element that is referenced by a <use> client
2335     // If an event listeners changes on a referenced element, update all instances.
2336     for (Node* node = referenceNode; node; node = node->parentNode()) {
2337         if (!node->hasID() || !node->isSVGElement())
2338             continue;
2339
2340         SVGElementInstance::invalidateAllInstancesOfElement(static_cast<SVGElement*>(node));
2341         break;
2342     }
2343 #endif
2344 }
2345
2346 bool Node::addEventListener(const AtomicString& eventType, PassRefPtr<EventListener> listener, bool useCapture)
2347 {
2348     if (!EventTarget::addEventListener(eventType, listener, useCapture))
2349         return false;
2350
2351     if (Document* document = this->document())
2352         document->addListenerTypeIfNeeded(eventType);
2353     updateSVGElementInstancesAfterEventListenerChange(this);
2354     return true;
2355 }
2356
2357 bool Node::removeEventListener(const AtomicString& eventType, EventListener* listener, bool useCapture)
2358 {
2359     if (!EventTarget::removeEventListener(eventType, listener, useCapture))
2360         return false;
2361
2362     updateSVGElementInstancesAfterEventListenerChange(this);
2363     return true;
2364 }
2365
2366 EventTargetData* Node::eventTargetData()
2367 {
2368     return hasRareData() ? rareData()->eventTargetData() : 0;
2369 }
2370
2371 EventTargetData* Node::ensureEventTargetData()
2372 {
2373     return ensureRareData()->ensureEventTargetData();
2374 }
2375
2376 void Node::handleLocalEvents(Event* event)
2377 {
2378     if (!hasRareData() || !rareData()->eventTargetData())
2379         return;
2380
2381     if (disabled() && event->isMouseEvent())
2382         return;
2383
2384     fireEventListeners(event);
2385 }
2386
2387 #if ENABLE(SVG)
2388 static inline SVGElementInstance* eventTargetAsSVGElementInstance(Node* referenceNode)
2389 {
2390     ASSERT(referenceNode);
2391     if (!referenceNode->isSVGElement())
2392         return 0;
2393
2394     // Spec: The event handling for the non-exposed tree works as if the referenced element had been textually included
2395     // as a deeply cloned child of the 'use' element, except that events are dispatched to the SVGElementInstance objects
2396     for (Node* n = referenceNode; n; n = n->parentNode()) {
2397         if (!n->isShadowNode() || !n->isSVGElement())
2398             continue;
2399
2400         Node* shadowTreeParentElement = n->shadowParentNode();
2401         ASSERT(shadowTreeParentElement->hasTagName(SVGNames::useTag));
2402
2403         if (SVGElementInstance* instance = static_cast<SVGUseElement*>(shadowTreeParentElement)->instanceForShadowTreeElement(referenceNode))
2404             return instance;
2405     }
2406
2407     return 0;
2408 }
2409 #endif
2410
2411 static inline EventTarget* eventTargetRespectingSVGTargetRules(Node* referenceNode)
2412 {
2413     ASSERT(referenceNode);
2414
2415 #if ENABLE(SVG)
2416     if (SVGElementInstance* instance = eventTargetAsSVGElementInstance(referenceNode)) {
2417         ASSERT(instance->shadowTreeElement() == referenceNode);
2418         return instance;
2419     }
2420 #endif
2421
2422     return referenceNode;
2423 }
2424
2425 bool Node::dispatchEvent(PassRefPtr<Event> prpEvent)
2426 {
2427     RefPtr<EventTarget> protect = this;
2428     RefPtr<Event> event = prpEvent;
2429
2430     event->setTarget(eventTargetRespectingSVGTargetRules(this));
2431
2432     RefPtr<FrameView> view = document()->view();
2433     return dispatchGenericEvent(event.release());
2434 }
2435
2436 bool Node::dispatchGenericEvent(PassRefPtr<Event> prpEvent)
2437 {
2438     RefPtr<Event> event(prpEvent);
2439
2440     ASSERT(!eventDispatchForbidden());
2441     ASSERT(event->target());
2442     ASSERT(!event->type().isNull()); // JavaScript code can create an event with an empty name, but not null.
2443
2444 #if ENABLE(INSPECTOR)
2445     InspectorTimelineAgent* timelineAgent = document()->inspectorTimelineAgent();
2446     if (timelineAgent)
2447         timelineAgent->willDispatchDOMEvent(*event);
2448 #endif
2449
2450     // Make a vector of ancestors to send the event to.
2451     // If the node is not in a document just send the event to it.
2452     // Be sure to ref all of nodes since event handlers could result in the last reference going away.
2453     RefPtr<Node> thisNode(this);
2454     Vector<RefPtr<ContainerNode> > ancestors;
2455     if (inDocument()) {
2456         for (ContainerNode* ancestor = eventParentNode(); ancestor; ancestor = ancestor->eventParentNode()) {
2457 #if ENABLE(SVG)
2458             // Skip <use> shadow tree elements.
2459             if (ancestor->isSVGElement() && ancestor->isShadowNode())
2460                 continue;
2461 #endif
2462             ancestors.append(ancestor);
2463         }
2464     }
2465
2466     // Set up a pointer to indicate whether / where to dispatch window events.
2467     // We don't dispatch load events to the window. That quirk was originally
2468     // added because Mozilla doesn't propagate load events to the window object.
2469     DOMWindow* targetForWindowEvents = 0;
2470     if (event->type() != eventNames().loadEvent) {
2471         Node* topLevelContainer = ancestors.isEmpty() ? this : ancestors.last().get();
2472         if (topLevelContainer->isDocumentNode())
2473             targetForWindowEvents = static_cast<Document*>(topLevelContainer)->domWindow();
2474     }
2475
2476     // Give the target node a chance to do some work before DOM event handlers get a crack.
2477     void* data = preDispatchEventHandler(event.get());
2478     if (event->propagationStopped())
2479         goto doneDispatching;
2480
2481     // Trigger capturing event handlers, starting at the top and working our way down.
2482     event->setEventPhase(Event::CAPTURING_PHASE);
2483
2484     if (targetForWindowEvents) {
2485         event->setCurrentTarget(targetForWindowEvents);
2486         targetForWindowEvents->fireEventListeners(event.get());
2487         if (event->propagationStopped())
2488             goto doneDispatching;
2489     }
2490     for (size_t i = ancestors.size(); i; --i) {
2491         ContainerNode* ancestor = ancestors[i - 1].get();
2492         event->setCurrentTarget(eventTargetRespectingSVGTargetRules(ancestor));
2493         ancestor->handleLocalEvents(event.get());
2494         if (event->propagationStopped())
2495             goto doneDispatching;
2496     }
2497
2498     event->setEventPhase(Event::AT_TARGET);
2499
2500     event->setCurrentTarget(eventTargetRespectingSVGTargetRules(this));
2501     handleLocalEvents(event.get());
2502     if (event->propagationStopped())
2503         goto doneDispatching;
2504
2505     if (event->bubbles() && !event->cancelBubble()) {
2506         // Trigger bubbling event handlers, starting at the bottom and working our way up.
2507         event->setEventPhase(Event::BUBBLING_PHASE);
2508
2509         size_t size = ancestors.size();
2510         for (size_t i = 0; i < size; ++i) {
2511             ContainerNode* ancestor = ancestors[i].get();
2512             event->setCurrentTarget(eventTargetRespectingSVGTargetRules(ancestor));
2513             ancestor->handleLocalEvents(event.get());
2514             if (event->propagationStopped() || event->cancelBubble())
2515                 goto doneDispatching;
2516         }
2517         if (targetForWindowEvents) {
2518             event->setCurrentTarget(targetForWindowEvents);
2519             targetForWindowEvents->fireEventListeners(event.get());
2520             if (event->propagationStopped() || event->cancelBubble())
2521                 goto doneDispatching;
2522         }
2523     }
2524
2525 doneDispatching:
2526     event->setCurrentTarget(0);
2527     event->setEventPhase(0);
2528
2529     // Pass the data from the preDispatchEventHandler to the postDispatchEventHandler.
2530     postDispatchEventHandler(event.get(), data);
2531
2532     // Call default event handlers. While the DOM does have a concept of preventing
2533     // default handling, the detail of which handlers are called is an internal
2534     // implementation detail and not part of the DOM.
2535     if (!event->defaultPrevented() && !event->defaultHandled()) {
2536         // Non-bubbling events call only one default event handler, the one for the target.
2537         defaultEventHandler(event.get());
2538         ASSERT(!event->defaultPrevented());
2539         if (event->defaultHandled())
2540             goto doneWithDefault;
2541         // For bubbling events, call default event handlers on the same targets in the
2542         // same order as the bubbling phase.
2543         if (event->bubbles()) {
2544             size_t size = ancestors.size();
2545             for (size_t i = 0; i < size; ++i) {
2546                 ContainerNode* ancestor = ancestors[i].get();
2547                 ancestor->defaultEventHandler(event.get());
2548                 ASSERT(!event->defaultPrevented());
2549                 if (event->defaultHandled())
2550                     goto doneWithDefault;
2551             }
2552         }
2553     }
2554
2555 doneWithDefault:
2556 #if ENABLE(INSPECTOR)
2557     if (timelineAgent)
2558         timelineAgent->didDispatchDOMEvent();
2559 #endif
2560
2561     Document::updateStyleForAllDocuments();
2562
2563     return !event->defaultPrevented();
2564 }
2565
2566 void Node::dispatchSubtreeModifiedEvent()
2567 {
2568     ASSERT(!eventDispatchForbidden());
2569     
2570     document()->incDOMTreeVersion();
2571
2572     notifyNodeListsAttributeChanged(); // FIXME: Can do better some day. Really only care about the name attribute changing.
2573     
2574     if (!document()->hasListenerType(Document::DOMSUBTREEMODIFIED_LISTENER))
2575         return;
2576
2577     dispatchEvent(MutationEvent::create(eventNames().DOMSubtreeModifiedEvent, true));
2578 }
2579
2580 void Node::dispatchUIEvent(const AtomicString& eventType, int detail, PassRefPtr<Event> underlyingEvent)
2581 {
2582     ASSERT(!eventDispatchForbidden());
2583     ASSERT(eventType == eventNames().DOMFocusInEvent || eventType == eventNames().DOMFocusOutEvent || eventType == eventNames().DOMActivateEvent);
2584     
2585     bool cancelable = eventType == eventNames().DOMActivateEvent;
2586     
2587     RefPtr<UIEvent> event = UIEvent::create(eventType, true, cancelable, document()->defaultView(), detail);
2588     event->setUnderlyingEvent(underlyingEvent);
2589     dispatchEvent(event.release());
2590 }
2591
2592 bool Node::dispatchKeyEvent(const PlatformKeyboardEvent& key)
2593 {
2594     RefPtr<KeyboardEvent> keyboardEvent = KeyboardEvent::create(key, document()->defaultView());
2595     bool r = dispatchEvent(keyboardEvent);
2596     
2597     // we want to return false if default is prevented (already taken care of)
2598     // or if the element is default-handled by the DOM. Otherwise we let it just
2599     // let it get handled by AppKit 
2600     if (keyboardEvent->defaultHandled())
2601         r = false;
2602     
2603     return r;
2604 }
2605
2606 bool Node::dispatchMouseEvent(const PlatformMouseEvent& event, const AtomicString& eventType,
2607     int detail, Node* relatedTarget)
2608 {
2609     ASSERT(!eventDispatchForbidden());
2610     
2611     IntPoint contentsPos;
2612     if (FrameView* view = document()->view())
2613         contentsPos = view->windowToContents(event.pos());
2614
2615     short button = event.button();
2616
2617     ASSERT(event.eventType() == MouseEventMoved || button != NoButton);
2618     
2619     return dispatchMouseEvent(eventType, button, detail,
2620         contentsPos.x(), contentsPos.y(), event.globalX(), event.globalY(),
2621         event.ctrlKey(), event.altKey(), event.shiftKey(), event.metaKey(),
2622         false, relatedTarget, 0);
2623 }
2624
2625 void Node::dispatchSimulatedMouseEvent(const AtomicString& eventType,
2626     PassRefPtr<Event> underlyingEvent)
2627 {
2628     ASSERT(!eventDispatchForbidden());
2629
2630     bool ctrlKey = false;
2631     bool altKey = false;
2632     bool shiftKey = false;
2633     bool metaKey = false;
2634     if (UIEventWithKeyState* keyStateEvent = findEventWithKeyState(underlyingEvent.get())) {
2635         ctrlKey = keyStateEvent->ctrlKey();
2636         altKey = keyStateEvent->altKey();
2637         shiftKey = keyStateEvent->shiftKey();
2638         metaKey = keyStateEvent->metaKey();
2639     }
2640
2641     // Like Gecko, we just pass 0 for everything when we make a fake mouse event.
2642     // Internet Explorer instead gives the current mouse position and state.
2643     dispatchMouseEvent(eventType, 0, 0, 0, 0, 0, 0,
2644         ctrlKey, altKey, shiftKey, metaKey, true, 0, underlyingEvent);
2645 }
2646
2647 void Node::dispatchSimulatedClick(PassRefPtr<Event> event, bool sendMouseEvents, bool showPressedLook)
2648 {
2649     if (!gNodesDispatchingSimulatedClicks)
2650         gNodesDispatchingSimulatedClicks = new HashSet<Node*>;
2651     else if (gNodesDispatchingSimulatedClicks->contains(this))
2652         return;
2653     
2654     gNodesDispatchingSimulatedClicks->add(this);
2655     
2656     // send mousedown and mouseup before the click, if requested
2657     if (sendMouseEvents)
2658         dispatchSimulatedMouseEvent(eventNames().mousedownEvent, event.get());
2659     setActive(true, showPressedLook);
2660     if (sendMouseEvents)
2661         dispatchSimulatedMouseEvent(eventNames().mouseupEvent, event.get());
2662     setActive(false);
2663
2664     // always send click
2665     dispatchSimulatedMouseEvent(eventNames().clickEvent, event);
2666     
2667     gNodesDispatchingSimulatedClicks->remove(this);
2668 }
2669
2670 bool Node::dispatchMouseEvent(const AtomicString& eventType, int button, int detail,
2671     int pageX, int pageY, int screenX, int screenY,
2672     bool ctrlKey, bool altKey, bool shiftKey, bool metaKey, 
2673     bool isSimulated, Node* relatedTargetArg, PassRefPtr<Event> underlyingEvent)
2674 {
2675     ASSERT(!eventDispatchForbidden());
2676     if (disabled()) // Don't even send DOM events for disabled controls..
2677         return true;
2678     
2679     if (eventType.isEmpty())
2680         return false; // Shouldn't happen.
2681     
2682     // Dispatching the first event can easily result in this node being destroyed.
2683     // Since we dispatch up to three events here, we need to make sure we're referenced
2684     // so the pointer will be good for the two subsequent ones.
2685     RefPtr<Node> protect(this);
2686     
2687     bool cancelable = eventType != eventNames().mousemoveEvent;
2688     
2689     bool swallowEvent = false;
2690     
2691     // Attempting to dispatch with a non-EventTarget relatedTarget causes the relatedTarget to be silently ignored.
2692     RefPtr<Node> relatedTarget = relatedTargetArg;
2693
2694     int adjustedPageX = pageX;
2695     int adjustedPageY = pageY;
2696     if (Frame* frame = document()->frame()) {
2697         float pageZoom = frame->pageZoomFactor();
2698         if (pageZoom != 1.0f) {
2699             // Adjust our pageX and pageY to account for the page zoom.
2700             adjustedPageX = lroundf(pageX / pageZoom);
2701             adjustedPageY = lroundf(pageY / pageZoom);
2702         }
2703     }
2704
2705     RefPtr<MouseEvent> mouseEvent = MouseEvent::create(eventType,
2706         true, cancelable, document()->defaultView(),
2707         detail, screenX, screenY, adjustedPageX, adjustedPageY,
2708         ctrlKey, altKey, shiftKey, metaKey, button,
2709         relatedTarget, 0, isSimulated);
2710     mouseEvent->setUnderlyingEvent(underlyingEvent.get());
2711     mouseEvent->setAbsoluteLocation(IntPoint(pageX, pageY));
2712     
2713     dispatchEvent(mouseEvent);
2714     bool defaultHandled = mouseEvent->defaultHandled();
2715     bool defaultPrevented = mouseEvent->defaultPrevented();
2716     if (defaultHandled || defaultPrevented)
2717         swallowEvent = true;
2718     
2719     // Special case: If it's a double click event, we also send the dblclick event. This is not part
2720     // of the DOM specs, but is used for compatibility with the ondblclick="" attribute.  This is treated
2721     // as a separate event in other DOM-compliant browsers like Firefox, and so we do the same.
2722     if (eventType == eventNames().clickEvent && detail == 2) {
2723         RefPtr<Event> doubleClickEvent = MouseEvent::create(eventNames().dblclickEvent,
2724             true, cancelable, document()->defaultView(),
2725             detail, screenX, screenY, pageX, pageY,
2726             ctrlKey, altKey, shiftKey, metaKey, button,
2727             relatedTarget, 0, isSimulated);
2728         doubleClickEvent->setUnderlyingEvent(underlyingEvent.get());
2729         if (defaultHandled)
2730             doubleClickEvent->setDefaultHandled();
2731         dispatchEvent(doubleClickEvent);
2732         if (doubleClickEvent->defaultHandled() || doubleClickEvent->defaultPrevented())
2733             swallowEvent = true;
2734     }
2735
2736     return swallowEvent;
2737 }
2738
2739 void Node::dispatchWheelEvent(PlatformWheelEvent& e)
2740 {
2741     ASSERT(!eventDispatchForbidden());
2742     if (e.deltaX() == 0 && e.deltaY() == 0)
2743         return;
2744     
2745     FrameView* view = document()->view();
2746     if (!view)
2747         return;
2748     
2749     IntPoint pos = view->windowToContents(e.pos());
2750
2751     int adjustedPageX = pos.x();
2752     int adjustedPageY = pos.y();
2753     if (Frame* frame = document()->frame()) {
2754         float pageZoom = frame->pageZoomFactor();
2755         if (pageZoom != 1.0f) {
2756             // Adjust our pageX and pageY to account for the page zoom.
2757             adjustedPageX = lroundf(pos.x() / pageZoom);
2758             adjustedPageY = lroundf(pos.y() / pageZoom);
2759         }
2760     }
2761     
2762     RefPtr<WheelEvent> we = WheelEvent::create(e.wheelTicksX(), e.wheelTicksY(),
2763         document()->defaultView(), e.globalX(), e.globalY(), adjustedPageX, adjustedPageY,
2764         e.ctrlKey(), e.altKey(), e.shiftKey(), e.metaKey());
2765
2766     we->setAbsoluteLocation(IntPoint(pos.x(), pos.y()));
2767
2768     if (!dispatchEvent(we.release()))
2769         e.accept();
2770 }
2771
2772 void Node::dispatchFocusEvent()
2773 {
2774     dispatchEvent(Event::create(eventNames().focusEvent, false, false));
2775 }
2776
2777 void Node::dispatchBlurEvent()
2778 {
2779     dispatchEvent(Event::create(eventNames().blurEvent, false, false));
2780 }
2781
2782 bool Node::disabled() const
2783 {
2784     return false;
2785 }
2786
2787 void Node::defaultEventHandler(Event* event)
2788 {
2789     if (event->target() != this)
2790         return;
2791     const AtomicString& eventType = event->type();
2792     if (eventType == eventNames().keydownEvent || eventType == eventNames().keypressEvent) {
2793         if (event->isKeyboardEvent())
2794             if (Frame* frame = document()->frame())
2795                 frame->eventHandler()->defaultKeyboardEventHandler(static_cast<KeyboardEvent*>(event));
2796     } else if (eventType == eventNames().clickEvent) {
2797         int detail = event->isUIEvent() ? static_cast<UIEvent*>(event)->detail() : 0;
2798         dispatchUIEvent(eventNames().DOMActivateEvent, detail, event);
2799 #if ENABLE(CONTEXT_MENUS)
2800     } else if (eventType == eventNames().contextmenuEvent) {
2801         if (Frame* frame = document()->frame())
2802             if (Page* page = frame->page())
2803                 page->contextMenuController()->handleContextMenuEvent(event);
2804 #endif
2805     } else if (eventType == eventNames().textInputEvent) {
2806         if (event->isTextEvent())
2807             if (Frame* frame = document()->frame())
2808                 frame->eventHandler()->defaultTextInputEventHandler(static_cast<TextEvent*>(event));
2809     }
2810 }
2811
2812 } // namespace WebCore
2813
2814 #ifndef NDEBUG
2815
2816 void showTree(const WebCore::Node* node)
2817 {
2818     if (node)
2819         node->showTreeForThis();
2820 }
2821
2822 #endif