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