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