WebCore:
[WebKit-https.git] / WebCore / dom / Node.cpp
1 /*
2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
4  *           (C) 2001 Dirk Mueller (mueller@kde.org)
5  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
6  * Copyright (C) 2007 Trolltech ASA
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 "CSSParser.h"
28 #include "CSSRule.h"
29 #include "CSSRuleList.h"
30 #include "CSSSelector.h"
31 #include "CSSStyleRule.h"
32 #include "CSSStyleSelector.h"
33 #include "CSSStyleSheet.h"
34 #include "CString.h"
35 #include "ChildNodeList.h"
36 #include "ClassNodeList.h"
37 #include "DOMImplementation.h"
38 #include "Document.h"
39 #include "DynamicNodeList.h"
40 #include "Element.h"
41 #include "ExceptionCode.h"
42 #include "Frame.h"
43 #include "HTMLNames.h"
44 #include "Logging.h"
45 #include "NameNodeList.h"
46 #include "NamedAttrMap.h"
47 #include "RenderObject.h"
48 #include "SelectorNodeList.h"
49 #include "TagNodeList.h"
50 #include "Text.h"
51 #include "XMLNames.h"
52 #include "htmlediting.h"
53 #include "kjs_binding.h"
54
55 namespace WebCore {
56
57 using namespace HTMLNames;
58
59 struct NodeListsNodeData {
60     typedef HashSet<DynamicNodeList*> NodeListSet;
61     NodeListSet m_listsWithCaches;
62
63     DynamicNodeList::Caches m_childNodeListCaches;
64
65     typedef HashMap<String, DynamicNodeList::Caches*> CacheMap;
66     CacheMap m_classNodeListCaches;
67     CacheMap m_nameNodeListCaches;
68
69     ~NodeListsNodeData()
70     {
71         deleteAllValues(m_classNodeListCaches);
72         deleteAllValues(m_nameNodeListCaches);
73     }
74
75     void invalidateCaches();
76     void invalidateCachesThatDependOnAttributes();
77     bool isEmpty() const;
78 };
79
80 // --------
81
82 bool Node::isSupported(const String& feature, const String& version)
83 {
84     return DOMImplementation::instance()->hasFeature(feature, version);
85 }
86
87 #ifndef NDEBUG
88 WTFLogChannel LogWebCoreNodeLeaks =  { 0x00000000, "", WTFLogChannelOn };
89
90 struct NodeCounter {
91     static unsigned count; 
92
93     ~NodeCounter() 
94     { 
95         if (count) 
96             LOG(WebCoreNodeLeaks, "LEAK: %u Node\n", count); 
97     }
98 };
99 unsigned NodeCounter::count = 0;
100 static NodeCounter nodeCounter;
101
102 static bool shouldIgnoreLeaks = false;
103 static HashSet<Node*> ignoreSet;
104 #endif
105
106 void Node::startIgnoringLeaks()
107 {
108 #ifndef NDEBUG
109     shouldIgnoreLeaks = true;
110 #endif
111 }
112
113 void Node::stopIgnoringLeaks()
114 {
115 #ifndef NDEBUG
116     shouldIgnoreLeaks = false;
117 #endif
118 }
119
120 Node::Node(Document *doc)
121     : m_document(doc),
122       m_previous(0),
123       m_next(0),
124       m_renderer(0),
125       m_tabIndex(0),
126       m_hasId(false),
127       m_hasClass(false),
128       m_attached(false),
129       m_styleChange(NoStyleChange),
130       m_hasChangedChild(false),
131       m_inDocument(false),
132       m_isLink(false),
133       m_attrWasSpecifiedOrElementHasRareData(false),
134       m_focused(false),
135       m_active(false),
136       m_hovered(false),
137       m_inActiveChain(false),
138       m_inDetach(false),
139       m_inSubtreeMark(false),
140       m_tabIndexSetExplicitly(false)
141 {
142 #ifndef NDEBUG
143     if (shouldIgnoreLeaks)
144         ignoreSet.add(this);
145     else
146         ++NodeCounter::count;
147 #endif
148 }
149
150 void Node::setDocument(Document* doc)
151 {
152     if (inDocument() || m_document == doc)
153         return;
154
155     willMoveToNewOwnerDocument();
156
157     {
158         KJS::JSLock lock;
159         ScriptInterpreter::updateDOMNodeDocument(this, m_document.get(), doc);
160     }    
161     m_document = doc;
162
163     didMoveToNewOwnerDocument();
164 }
165
166 Node::~Node()
167 {
168 #ifndef NDEBUG
169     HashSet<Node*>::iterator it = ignoreSet.find(this);
170     if (it != ignoreSet.end())
171         ignoreSet.remove(it);
172     else
173         --NodeCounter::count;
174 #endif
175
176     if (m_nodeLists && m_document)
177         document()->removeNodeListCache();
178
179     if (renderer())
180         detach();
181
182     if (m_previous)
183         m_previous->setNextSibling(0);
184     if (m_next)
185         m_next->setPreviousSibling(0);
186 }
187
188 String Node::nodeValue() const
189 {
190   return String();
191 }
192
193 void Node::setNodeValue(const String& /*nodeValue*/, ExceptionCode& ec)
194 {
195     // NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly
196     if (isReadOnlyNode()) {
197         ec = NO_MODIFICATION_ALLOWED_ERR;
198         return;
199     }
200
201     // by default nodeValue is null, so setting it has no effect
202 }
203
204 PassRefPtr<NodeList> Node::childNodes()
205 {
206     if (!m_nodeLists) {
207         m_nodeLists.set(new NodeListsNodeData);
208         document()->addNodeListCache();
209     }
210
211     return new ChildNodeList(this, &m_nodeLists->m_childNodeListCaches);
212 }
213
214 Node* Node::virtualFirstChild() const
215 {
216     return 0;
217 }
218
219 Node* Node::virtualLastChild() const
220 {
221     return 0;
222 }
223
224 bool Node::virtualHasTagName(const QualifiedName&) const
225 {
226     return false;
227 }
228
229 Node *Node::lastDescendant() const
230 {
231     Node *n = const_cast<Node *>(this);
232     while (n && n->lastChild())
233         n = n->lastChild();
234     return n;
235 }
236
237 Node* Node::firstDescendant() const
238 {
239     Node *n = const_cast<Node *>(this);
240     while (n && n->firstChild())
241         n = n->firstChild();
242     return n;
243 }
244
245 bool Node::insertBefore(PassRefPtr<Node>, Node*, ExceptionCode& ec)
246 {
247     ec = HIERARCHY_REQUEST_ERR;
248     return false;
249 }
250
251 bool Node::replaceChild(PassRefPtr<Node>, Node*, ExceptionCode& ec)
252 {
253     ec = HIERARCHY_REQUEST_ERR;
254     return false;
255 }
256
257 bool Node::removeChild(Node*, ExceptionCode& ec)
258 {
259     ec = NOT_FOUND_ERR;
260     return false;
261 }
262
263 bool Node::appendChild(PassRefPtr<Node>, ExceptionCode& ec)
264 {
265     ec = HIERARCHY_REQUEST_ERR;
266     return false;
267 }
268
269 void Node::remove(ExceptionCode& ec)
270 {
271     ref();
272     if (Node *p = parentNode())
273         p->removeChild(this, ec);
274     else
275         ec = HIERARCHY_REQUEST_ERR;
276     deref();
277 }
278
279 void Node::normalize()
280 {
281     // Go through the subtree beneath us, normalizing all nodes. This means that
282     // any two adjacent text nodes are merged together.
283
284     RefPtr<Node> node = this;
285     while (Node* firstChild = node->firstChild())
286         node = firstChild;
287     for (; node; node = node->traverseNextNodePostOrder()) {
288         NodeType type = node->nodeType();
289         if (type == ELEMENT_NODE)
290             static_cast<Element*>(node.get())->normalizeAttributes();
291
292         Node* firstChild = node->firstChild();
293         if (firstChild && !firstChild->nextSibling() && firstChild->isTextNode()) {
294             Text* text = static_cast<Text*>(firstChild);
295             if (!text->length()) {
296                 ExceptionCode ec;
297                 text->remove(ec);
298             }
299         }
300
301         if (node == this)
302             break;
303
304         if (type == TEXT_NODE) {
305             while (1) {
306                 Node* nextSibling = node->nextSibling();
307                 if (!nextSibling || !nextSibling->isTextNode())
308                     break;
309                 // Current child and the next one are both text nodes. Merge them.
310                 Text* text = static_cast<Text*>(node.get());
311                 RefPtr<Text> nextText = static_cast<Text*>(nextSibling);
312                 unsigned offset = text->length();
313                 ExceptionCode ec;
314                 text->appendData(nextText->data(), ec);
315                 document()->textNodesMerged(nextText.get(), offset);
316                 nextText->remove(ec);
317             }
318         }
319     }
320 }
321
322 const AtomicString& Node::prefix() const
323 {
324     // For nodes other than elements and attributes, the prefix is always null
325     return nullAtom;
326 }
327
328 void Node::setPrefix(const AtomicString& /*prefix*/, ExceptionCode& ec)
329 {
330     // The spec says that for nodes other than elements and attributes, prefix is always null.
331     // It does not say what to do when the user tries to set the prefix on another type of
332     // node, however Mozilla throws a NAMESPACE_ERR exception.
333     ec = NAMESPACE_ERR;
334 }
335
336 const AtomicString& Node::localName() const
337 {
338     return nullAtom;
339 }
340
341 const AtomicString& Node::namespaceURI() const
342 {
343     return nullAtom;
344 }
345
346 ContainerNode* Node::addChild(PassRefPtr<Node>)
347 {
348     return 0;
349 }
350
351 bool Node::isContentEditable() const
352 {
353     return parent() && parent()->isContentEditable();
354 }
355
356 bool Node::isContentRichlyEditable() const
357 {
358     return parent() && parent()->isContentRichlyEditable();
359 }
360
361 bool Node::shouldUseInputMethod() const
362 {
363     return isContentEditable();
364 }
365
366 IntRect Node::getRect() const
367 {
368     int _x, _y;
369     if (renderer() && renderer()->absolutePosition(_x, _y))
370         return IntRect( _x, _y, renderer()->width(), renderer()->height() + renderer()->borderTopExtra() + renderer()->borderBottomExtra());
371
372     return IntRect();
373 }
374
375 void Node::setChanged(StyleChangeType changeType)
376 {
377     if ((changeType != NoStyleChange) && !attached()) // changed compared to what?
378         return;
379
380     if (!(changeType == InlineStyleChange && m_styleChange == FullStyleChange))
381         m_styleChange = changeType;
382
383     if (m_styleChange != NoStyleChange) {
384         for (Node* p = parentNode(); p; p = p->parentNode())
385             p->setHasChangedChild(true);
386         document()->setDocumentChanged(true);
387     }
388 }
389
390 bool Node::isFocusable() const
391 {
392     return m_tabIndexSetExplicitly;
393 }
394
395 bool Node::isKeyboardFocusable(KeyboardEvent*) const
396 {
397     return isFocusable() && m_tabIndex >= 0;
398 }
399
400 bool Node::isMouseFocusable() const
401 {
402     return isFocusable();
403 }
404
405 unsigned Node::nodeIndex() const
406 {
407     Node *_tempNode = previousSibling();
408     unsigned count=0;
409     for( count=0; _tempNode; count++ )
410         _tempNode = _tempNode->previousSibling();
411     return count;
412 }
413
414 void Node::registerDynamicNodeList(DynamicNodeList* list)
415 {
416     if (!m_nodeLists) {
417         m_nodeLists.set(new NodeListsNodeData);
418         document()->addNodeListCache();
419     } else if (!m_document->hasNodeListCaches()) {
420         // We haven't been receiving notifications while there were no registered lists, so the cache is invalid now.
421         m_nodeLists->invalidateCaches();
422     }
423
424     if (list->hasOwnCaches())
425         m_nodeLists->m_listsWithCaches.add(list);
426 }
427
428 void Node::unregisterDynamicNodeList(DynamicNodeList* list)
429 {
430     ASSERT(m_nodeLists);
431     if (list->hasOwnCaches()) {
432         m_nodeLists->m_listsWithCaches.remove(list);
433         if (m_nodeLists->isEmpty()) {
434             m_nodeLists.clear();
435             document()->removeNodeListCache();
436         }
437     }
438 }
439
440 void Node::notifyLocalNodeListsAttributeChanged()
441 {
442     if (!m_nodeLists)
443         return;
444
445     m_nodeLists->invalidateCachesThatDependOnAttributes();
446
447     if (m_nodeLists->isEmpty()) {
448         m_nodeLists.clear();
449         document()->removeNodeListCache();
450     }
451 }
452
453 void Node::notifyNodeListsAttributeChanged()
454 {
455     for (Node *n = this; n; n = n->parentNode())
456         n->notifyLocalNodeListsAttributeChanged();
457 }
458
459 void Node::notifyLocalNodeListsChildrenChanged()
460 {
461     if (!m_nodeLists)
462         return;
463
464     m_nodeLists->invalidateCaches();
465
466     NodeListsNodeData::NodeListSet::iterator end = m_nodeLists->m_listsWithCaches.end();
467     for (NodeListsNodeData::NodeListSet::iterator i = m_nodeLists->m_listsWithCaches.begin(); i != end; ++i)
468         (*i)->invalidateCache();
469
470     if (m_nodeLists->isEmpty()) {
471         m_nodeLists.clear();
472         document()->removeNodeListCache();
473     }
474 }
475
476 void Node::notifyNodeListsChildrenChanged()
477 {
478     for (Node* n = this; n; n = n->parentNode())
479         n->notifyLocalNodeListsChildrenChanged();
480 }
481
482 unsigned Node::childNodeCount() const
483 {
484     return 0;
485 }
486
487 Node *Node::childNode(unsigned /*index*/) const
488 {
489     return 0;
490 }
491
492 Node *Node::traverseNextNode(const Node *stayWithin) const
493 {
494     if (firstChild())
495         return firstChild();
496     if (this == stayWithin)
497         return 0;
498     if (nextSibling())
499         return nextSibling();
500     const Node *n = this;
501     while (n && !n->nextSibling() && (!stayWithin || n->parentNode() != stayWithin))
502         n = n->parentNode();
503     if (n)
504         return n->nextSibling();
505     return 0;
506 }
507
508 Node *Node::traverseNextSibling(const Node *stayWithin) const
509 {
510     if (this == stayWithin)
511         return 0;
512     if (nextSibling())
513         return nextSibling();
514     const Node *n = this;
515     while (n && !n->nextSibling() && (!stayWithin || n->parentNode() != stayWithin))
516         n = n->parentNode();
517     if (n)
518         return n->nextSibling();
519     return 0;
520 }
521
522 Node* Node::traverseNextNodePostOrder() const
523 {
524     Node* next = nextSibling();
525     if (!next)
526         return parentNode();
527     while (Node* firstChild = next->firstChild())
528         next = firstChild;
529     return next;
530 }
531
532 Node *Node::traversePreviousNode(const Node *stayWithin) const
533 {
534     if (this == stayWithin)
535         return 0;
536     if (previousSibling()) {
537         Node *n = previousSibling();
538         while (n->lastChild())
539             n = n->lastChild();
540         return n;
541     }
542     return parentNode();
543 }
544
545 Node *Node::traversePreviousNodePostOrder(const Node *stayWithin) const
546 {
547     if (lastChild())
548         return lastChild();
549     if (this == stayWithin)
550         return 0;
551     if (previousSibling())
552         return previousSibling();
553     const Node *n = this;
554     while (n && !n->previousSibling() && (!stayWithin || n->parentNode() != stayWithin))
555         n = n->parentNode();
556     if (n)
557         return n->previousSibling();
558     return 0;
559 }
560
561 Node* Node::traversePreviousSiblingPostOrder(const Node* stayWithin) const
562 {
563     if (this == stayWithin)
564         return 0;
565     if (previousSibling())
566         return previousSibling();
567     const Node *n = this;
568     while (n && !n->previousSibling() && (!stayWithin || n->parentNode() != stayWithin))
569         n = n->parentNode();
570     if (n)
571         return n->previousSibling();
572     return 0;
573 }
574
575 void Node::checkSetPrefix(const AtomicString &_prefix, ExceptionCode& ec)
576 {
577     // Perform error checking as required by spec for setting Node.prefix. Used by
578     // Element::setPrefix() and Attr::setPrefix()
579
580     // FIXME: Implement support for INVALID_CHARACTER_ERR: Raised if the specified prefix contains an illegal character.
581     
582     // NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
583     if (isReadOnlyNode()) {
584         ec = NO_MODIFICATION_ALLOWED_ERR;
585         return;
586     }
587
588     // FIXME: Implement NAMESPACE_ERR: - Raised if the specified prefix is malformed
589     // We have to comment this out, since it's used for attributes and tag names, and we've only
590     // switched one over.
591     /*
592     // - if the namespaceURI of this node is null,
593     // - if the specified prefix is "xml" and the namespaceURI of this node is different from
594     //   "http://www.w3.org/XML/1998/namespace",
595     // - if this node is an attribute and the specified prefix is "xmlns" and
596     //   the namespaceURI of this node is different from "http://www.w3.org/2000/xmlns/",
597     // - or if this node is an attribute and the qualifiedName of this node is "xmlns" [Namespaces].
598     if ((namespacePart(id()) == noNamespace && id() > ID_LAST_TAG) ||
599         (_prefix == "xml" && String(document()->namespaceURI(id())) != "http://www.w3.org/XML/1998/namespace")) {
600         ec = NAMESPACE_ERR;
601         return;
602     }*/
603 }
604
605 bool Node::canReplaceChild(Node* newChild, Node* oldChild)
606 {
607     if (newChild->nodeType() != DOCUMENT_FRAGMENT_NODE) {
608         if (!childTypeAllowed(newChild->nodeType()))
609             return false;
610     }
611     else {
612         for (Node *n = newChild->firstChild(); n; n = n->nextSibling()) {
613             if (!childTypeAllowed(n->nodeType())) 
614                 return false;
615         }
616     }
617     
618     return true;
619 }
620
621 void Node::checkReplaceChild(Node* newChild, Node* oldChild, ExceptionCode& ec)
622 {
623     // Perform error checking as required by spec for adding a new child. Used by
624     // appendChild(), replaceChild() and insertBefore()
625     
626     // Not mentioned in spec: throw NOT_FOUND_ERR if newChild is null
627     if (!newChild) {
628         ec = NOT_FOUND_ERR;
629         return;
630     }
631     
632     // NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly
633     if (isReadOnlyNode()) {
634         ec = NO_MODIFICATION_ALLOWED_ERR;
635         return;
636     }
637     
638     bool shouldAdoptChild = false;
639     
640     // WRONG_DOCUMENT_ERR: Raised if newChild was created from a different document than the one that
641     // created this node.
642     // We assume that if newChild is a DocumentFragment, all children are created from the same document
643     // as the fragment itself (otherwise they could not have been added as children)
644     if (newChild->document() != document()) {
645         // but if the child is not in a document yet then loosen the
646         // restriction, so that e.g. creating an element with the Option()
647         // constructor and then adding it to a different document works,
648         // as it does in Mozilla and Mac IE.
649         if (!newChild->inDocument()) {
650             shouldAdoptChild = true;
651         } else {
652             ec = WRONG_DOCUMENT_ERR;
653             return;
654         }
655     }
656     
657     // HIERARCHY_REQUEST_ERR: Raised if this node is of a type that does not allow children of the type of the
658     // newChild node, or if the node to append is one of this node's ancestors.
659     
660     // check for ancestor/same node
661     if (newChild == this || isDescendantOf(newChild)) {
662         ec = HIERARCHY_REQUEST_ERR;
663         return;
664     }
665     
666     if (!canReplaceChild(newChild, oldChild)) {
667         ec = HIERARCHY_REQUEST_ERR;
668         return;
669     }
670        
671     // change the document pointer of newChild and all of its children to be the new document
672     if (shouldAdoptChild)
673         for (Node* node = newChild; node; node = node->traverseNextNode(newChild))
674             node->setDocument(document());
675 }
676
677 void Node::checkAddChild(Node *newChild, ExceptionCode& ec)
678 {
679     // Perform error checking as required by spec for adding a new child. Used by
680     // appendChild(), replaceChild() and insertBefore()
681
682     // Not mentioned in spec: throw NOT_FOUND_ERR if newChild is null
683     if (!newChild) {
684         ec = NOT_FOUND_ERR;
685         return;
686     }
687
688     // NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly
689     if (isReadOnlyNode()) {
690         ec = NO_MODIFICATION_ALLOWED_ERR;
691         return;
692     }
693
694     bool shouldAdoptChild = false;
695
696     // WRONG_DOCUMENT_ERR: Raised if newChild was created from a different document than the one that
697     // created this node.
698     // We assume that if newChild is a DocumentFragment, all children are created from the same document
699     // as the fragment itself (otherwise they could not have been added as children)
700     if (newChild->document() != document()) {
701         // but if the child is not in a document yet then loosen the
702         // restriction, so that e.g. creating an element with the Option()
703         // constructor and then adding it to a different document works,
704         // as it does in Mozilla and Mac IE.
705         if (!newChild->inDocument()) {
706             shouldAdoptChild = true;
707         } else {
708             ec = WRONG_DOCUMENT_ERR;
709             return;
710         }
711     }
712
713     // HIERARCHY_REQUEST_ERR: Raised if this node is of a type that does not allow children of the type of the
714     // newChild node, or if the node to append is one of this node's ancestors.
715
716     // check for ancestor/same node
717     if (newChild == this || isDescendantOf(newChild)) {
718         ec = HIERARCHY_REQUEST_ERR;
719         return;
720     }
721     
722     if (newChild->nodeType() != DOCUMENT_FRAGMENT_NODE) {
723         if (!childTypeAllowed(newChild->nodeType())) {
724             ec = HIERARCHY_REQUEST_ERR;
725             return;
726         }
727     }
728     else {
729         for (Node *n = newChild->firstChild(); n; n = n->nextSibling()) {
730             if (!childTypeAllowed(n->nodeType())) {
731                 ec = HIERARCHY_REQUEST_ERR;
732                 return;
733             }
734         }
735     }
736     
737     // change the document pointer of newChild and all of its children to be the new document
738     if (shouldAdoptChild)
739         for (Node* node = newChild; node; node = node->traverseNextNode(newChild))
740             node->setDocument(document());
741 }
742
743 bool Node::isDescendantOf(const Node *other) const
744 {
745     // Return true if other is an ancestor of this, otherwise false
746     if (!other)
747         return false;
748     for (const Node *n = parentNode(); n; n = n->parentNode()) {
749         if (n == other)
750             return true;
751     }
752     return false;
753 }
754
755 bool Node::childAllowed(Node* newChild)
756 {
757     return childTypeAllowed(newChild->nodeType());
758 }
759
760 Node::StyleChange Node::diff( RenderStyle *s1, RenderStyle *s2 ) const
761 {
762     // FIXME: The behavior of this function is just totally wrong.  It doesn't handle
763     // explicit inheritance of non-inherited properties and so you end up not re-resolving
764     // style in cases where you need to.
765     StyleChange ch = NoInherit;
766     EDisplay display1 = s1 ? s1->display() : NONE;
767     bool fl1 = s1 && s1->hasPseudoStyle(RenderStyle::FIRST_LETTER);
768     EDisplay display2 = s2 ? s2->display() : NONE;
769     bool fl2 = s2 && s2->hasPseudoStyle(RenderStyle::FIRST_LETTER);
770         
771     if (display1 != display2 || fl1 != fl2 || (s1 && s2 && !s1->contentDataEquivalent(s2)))
772         ch = Detach;
773     else if (!s1 || !s2)
774         ch = Inherit;
775     else if (*s1 == *s2)
776         ch = NoChange;
777     else if (s1->inheritedNotEqual(s2))
778         ch = Inherit;
779     
780     // If the pseudoStyles have changed, we want any StyleChange that is not NoChange
781     // because setStyle will do the right thing with anything else.
782     if (ch == NoChange && s1->hasPseudoStyle(RenderStyle::BEFORE)) {
783         RenderStyle* ps2 = s2->getPseudoStyle(RenderStyle::BEFORE);
784         if (!ps2)
785             ch = NoInherit;
786         else {
787             RenderStyle* ps1 = s1->getPseudoStyle(RenderStyle::BEFORE);
788             ch = ps1 && *ps1 == *ps2 ? NoChange : NoInherit;
789         }
790     }
791     if (ch == NoChange && s1->hasPseudoStyle(RenderStyle::AFTER)) {
792         RenderStyle* ps2 = s2->getPseudoStyle(RenderStyle::AFTER);
793         if (!ps2)
794             ch = NoInherit;
795         else {
796             RenderStyle* ps1 = s1->getPseudoStyle(RenderStyle::AFTER);
797             ch = ps2 && *ps1 == *ps2 ? NoChange : NoInherit;
798         }
799     }
800     
801     return ch;
802 }
803
804 void Node::attach()
805 {
806     ASSERT(!attached());
807     ASSERT(!renderer() || (renderer()->style() && renderer()->parent()));
808
809     // If this node got a renderer it may be the previousRenderer() of sibling text nodes and thus affect the
810     // result of Text::rendererIsNeeded() for those nodes.
811     if (renderer()) {
812         for (Node* next = nextSibling(); next; next = next->nextSibling()) {
813             if (next->renderer())
814                 break;
815             if (!next->attached())
816                 break;  // Assume this means none of the following siblings are attached.
817             if (next->isTextNode())
818                 next->createRendererIfNeeded();
819         }
820     }
821
822     m_attached = true;
823 }
824
825 void Node::willRemove()
826 {
827 }
828
829 void Node::detach()
830 {
831     m_inDetach = true;
832
833     if (renderer())
834         renderer()->destroy();
835     setRenderer(0);
836
837     Document* doc = document();
838     if (m_hovered)
839         doc->hoveredNodeDetached(this);
840     if (m_inActiveChain)
841         doc->activeChainNodeDetached(this);
842
843     m_active = false;
844     m_hovered = false;
845     m_inActiveChain = false;
846     m_attached = false;
847     m_inDetach = false;
848 }
849
850 void Node::insertedIntoDocument()
851 {
852     setInDocument(true);
853     insertedIntoTree(false);
854 }
855
856 void Node::removedFromDocument()
857 {
858     if (m_document && m_document->getCSSTarget() == this)
859         m_document->setCSSTarget(0);
860
861     setInDocument(false);
862     removedFromTree(false);
863 }
864
865 bool Node::isReadOnlyNode()
866 {
867     // Entity & Entity Reference nodes and their descendants are read-only
868     Node *n = this;
869     while (n) {
870         if (n->nodeType() == ENTITY_NODE || n->nodeType() == ENTITY_REFERENCE_NODE)
871             return true;
872         n = n->parentNode();
873     }
874     return false;
875 }
876
877 Node *Node::previousEditable() const
878 {
879     Node *node = previousLeafNode();
880     while (node) {
881         if (node->isContentEditable())
882             return node;
883         node = node->previousLeafNode();
884     }
885     return 0;
886 }
887
888 // Offset specifies the child node to start at.  If it is past
889 // the last child, it specifies to start at next sibling.
890 Node *Node::nextEditable(int offset) const
891 {
892     ASSERT(offset>=0);
893     Node *node;
894     if (hasChildNodes())
895         node = (offset >= (int)childNodeCount()) ? nextSibling() : childNode(offset)->nextLeafNode();
896     else
897         node = nextLeafNode();
898     while (node) {
899         if (node->isContentEditable())
900             return node;
901         node = node->nextLeafNode();
902     }
903     return 0;
904 }
905
906 Node *Node::nextEditable() const
907 {
908     Node *node = nextLeafNode();
909     while (node) {
910         if (node->isContentEditable())
911             return node;
912         node = node->nextLeafNode();
913     }
914     return 0;
915 }
916
917 RenderObject * Node::previousRenderer()
918 {
919     for (Node *n = previousSibling(); n; n = n->previousSibling()) {
920         if (n->renderer())
921             return n->renderer();
922     }
923     return 0;
924 }
925
926 RenderObject * Node::nextRenderer()
927 {
928     // Avoid an O(n^2) problem with this function by not checking for nextRenderer() when the parent element hasn't even 
929     // been attached yet.
930     if (parent() && !parent()->attached())
931         return 0;
932
933     for (Node *n = nextSibling(); n; n = n->nextSibling()) {
934         if (n->renderer())
935             return n->renderer();
936     }
937     return 0;
938 }
939
940 // FIXME: This code is used by editing.  Seems like it could move over there and not pollute Node.
941 Node *Node::previousNodeConsideringAtomicNodes() const
942 {
943     if (previousSibling()) {
944         Node *n = previousSibling();
945         while (!isAtomicNode(n) && n->lastChild())
946             n = n->lastChild();
947         return n;
948     }
949     else if (parentNode()) {
950         return parentNode();
951     }
952     else {
953         return 0;
954     }
955 }
956
957 Node *Node::nextNodeConsideringAtomicNodes() const
958 {
959     if (!isAtomicNode(this) && firstChild())
960         return firstChild();
961     if (nextSibling())
962         return nextSibling();
963     const Node *n = this;
964     while (n && !n->nextSibling())
965         n = n->parentNode();
966     if (n)
967         return n->nextSibling();
968     return 0;
969 }
970
971 Node *Node::previousLeafNode() const
972 {
973     Node *node = previousNodeConsideringAtomicNodes();
974     while (node) {
975         if (isAtomicNode(node))
976             return node;
977         node = node->previousNodeConsideringAtomicNodes();
978     }
979     return 0;
980 }
981
982 Node *Node::nextLeafNode() const
983 {
984     Node *node = nextNodeConsideringAtomicNodes();
985     while (node) {
986         if (isAtomicNode(node))
987             return node;
988         node = node->nextNodeConsideringAtomicNodes();
989     }
990     return 0;
991 }
992
993 void Node::createRendererIfNeeded()
994 {
995     if (!document()->shouldCreateRenderers())
996         return;
997
998     ASSERT(!renderer());
999     
1000     Node *parent = parentNode();    
1001     ASSERT(parent);
1002     
1003     RenderObject *parentRenderer = parent->renderer();
1004     if (parentRenderer && parentRenderer->canHaveChildren()
1005 #if ENABLE(SVG)
1006         && parent->childShouldCreateRenderer(this)
1007 #endif
1008         ) {
1009         RenderStyle* style = styleForRenderer(parentRenderer);
1010         if (rendererIsNeeded(style)) {
1011             if (RenderObject* r = createRenderer(document()->renderArena(), style)) {
1012                 if (!parentRenderer->isChildAllowed(r, style))
1013                     r->destroy();
1014                 else {
1015                     setRenderer(r);
1016                     renderer()->setAnimatableStyle(style);
1017                     parentRenderer->addChild(renderer(), nextRenderer());
1018                 }
1019             }
1020         }
1021         style->deref(document()->renderArena());
1022     }
1023 }
1024
1025 RenderStyle *Node::styleForRenderer(RenderObject *parent)
1026 {
1027     RenderStyle *style = parent->style();
1028     style->ref();
1029     return style;
1030 }
1031
1032 bool Node::rendererIsNeeded(RenderStyle *style)
1033 {
1034     return (document()->documentElement() == this) || (style->display() != NONE);
1035 }
1036
1037 RenderObject *Node::createRenderer(RenderArena *arena, RenderStyle *style)
1038 {
1039     ASSERT(false);
1040     return 0;
1041 }
1042
1043 RenderStyle* Node::renderStyle() const
1044
1045     return m_renderer ? m_renderer->style() : 0; 
1046 }
1047
1048 void Node::setRenderStyle(RenderStyle* s)
1049 {
1050     if (m_renderer)
1051         m_renderer->setAnimatableStyle(s); 
1052 }
1053
1054 RenderStyle* Node::computedStyle()
1055 {
1056     return parent() ? parent()->computedStyle() : 0;
1057 }
1058
1059 int Node::maxCharacterOffset() const
1060 {
1061     ASSERT_NOT_REACHED();
1062     return 0;
1063 }
1064
1065 // FIXME: Shouldn't these functions be in the editing code?  Code that asks questions about HTML in the core DOM class
1066 // is obviously misplaced.
1067 bool Node::canStartSelection() const
1068 {
1069     if (isContentEditable())
1070         return true;
1071     return parent() ? parent()->canStartSelection() : true;
1072 }
1073
1074 Node* Node::shadowAncestorNode()
1075 {
1076 #if ENABLE(SVG)
1077     // SVG elements living in a shadow tree only occour when <use> created them.
1078     // For these cases we do NOT want to return the shadowParentNode() here
1079     // but the actual shadow tree element - as main difference to the HTML forms
1080     // shadow tree concept. (This function _could_ be made virtual - opinions?)
1081     if (isSVGElement())
1082         return this;
1083 #endif
1084
1085     Node *n = this;    
1086     while (n) {
1087         if (n->isShadowNode())
1088             return n->shadowParentNode();
1089         n = n->parentNode();
1090     } 
1091     return this;
1092 }
1093
1094 bool Node::isBlockFlow() const
1095 {
1096     return renderer() && renderer()->isBlockFlow();
1097 }
1098
1099 bool Node::isBlockFlowOrBlockTable() const
1100 {
1101     return renderer() && (renderer()->isBlockFlow() || renderer()->isTable() && !renderer()->isInline());
1102 }
1103
1104 bool Node::isEditableBlock() const
1105 {
1106     return isContentEditable() && isBlockFlow();
1107 }
1108
1109 Element *Node::enclosingBlockFlowOrTableElement() const
1110 {
1111     Node *n = const_cast<Node *>(this);
1112     if (isBlockFlowOrBlockTable())
1113         return static_cast<Element *>(n);
1114
1115     while (1) {
1116         n = n->parentNode();
1117         if (!n)
1118             break;
1119         if (n->isBlockFlowOrBlockTable() || n->hasTagName(bodyTag))
1120             return static_cast<Element *>(n);
1121     }
1122     return 0;
1123 }
1124
1125 Element *Node::enclosingBlockFlowElement() const
1126 {
1127     Node *n = const_cast<Node *>(this);
1128     if (isBlockFlow())
1129         return static_cast<Element *>(n);
1130
1131     while (1) {
1132         n = n->parentNode();
1133         if (!n)
1134             break;
1135         if (n->isBlockFlow() || n->hasTagName(bodyTag))
1136             return static_cast<Element *>(n);
1137     }
1138     return 0;
1139 }
1140
1141 Element *Node::enclosingInlineElement() const
1142 {
1143     Node *n = const_cast<Node *>(this);
1144     Node *p;
1145
1146     while (1) {
1147         p = n->parentNode();
1148         if (!p || p->isBlockFlow() || p->hasTagName(bodyTag))
1149             return static_cast<Element *>(n);
1150         // Also stop if any previous sibling is a block
1151         for (Node *sibling = n->previousSibling(); sibling; sibling = sibling->previousSibling()) {
1152             if (sibling->isBlockFlow())
1153                 return static_cast<Element *>(n);
1154         }
1155         n = p;
1156     }
1157     ASSERT_NOT_REACHED();
1158     return 0;
1159 }
1160
1161 Element* Node::rootEditableElement() const
1162 {
1163     Element* result = 0;
1164     for (Node* n = const_cast<Node*>(this); n && n->isContentEditable(); n = n->parentNode()) {
1165         if (n->isElementNode())
1166             result = static_cast<Element*>(n);
1167         if (n->hasTagName(bodyTag))
1168             break;
1169     }
1170     return result;
1171 }
1172
1173 bool Node::inSameContainingBlockFlowElement(Node *n)
1174 {
1175     return n ? enclosingBlockFlowElement() == n->enclosingBlockFlowElement() : false;
1176 }
1177
1178 // FIXME: End of obviously misplaced HTML editing functions.  Try to move these out of Node.
1179
1180 PassRefPtr<NodeList> Node::getElementsByTagName(const String& name)
1181 {
1182     return getElementsByTagNameNS("*", name);
1183 }
1184  
1185 PassRefPtr<NodeList> Node::getElementsByTagNameNS(const String& namespaceURI, const String& localName)
1186 {
1187     if (localName.isNull())
1188         return 0;
1189
1190     String name = localName;
1191     if (document()->isHTMLDocument())
1192         name = localName.lower();
1193     return new TagNodeList(this, namespaceURI.isEmpty() ? nullAtom : AtomicString(namespaceURI), name);
1194 }
1195
1196 PassRefPtr<NodeList> Node::getElementsByName(const String& elementName)
1197 {
1198     if (!m_nodeLists) {
1199         m_nodeLists.set(new NodeListsNodeData);
1200         document()->addNodeListCache();
1201     }
1202
1203     pair<NodeListsNodeData::CacheMap::iterator, bool> result = m_nodeLists->m_nameNodeListCaches.add(elementName, 0);
1204     if (result.second)
1205         result.first->second = new DynamicNodeList::Caches;
1206     
1207     return new NameNodeList(this, elementName, result.first->second);
1208 }
1209
1210 PassRefPtr<NodeList> Node::getElementsByClassName(const String& classNames)
1211 {
1212     if (!m_nodeLists) {
1213         m_nodeLists.set(new NodeListsNodeData);
1214         document()->addNodeListCache();
1215     }
1216
1217     pair<NodeListsNodeData::CacheMap::iterator, bool> result = m_nodeLists->m_classNodeListCaches.add(classNames, 0);
1218     if (result.second)
1219         result.first->second = new DynamicNodeList::Caches;
1220     
1221     return new ClassNodeList(this, classNames, result.first->second);
1222 }
1223
1224 PassRefPtr<Element> Node::querySelector(const String& selectors, ExceptionCode& ec)
1225 {
1226     if (selectors.isNull() || selectors.isEmpty()) {
1227         ec = SYNTAX_ERR;
1228         return 0;
1229     }
1230     CSSStyleSheet tempStyleSheet(document());
1231     CSSParser p(true);
1232     RefPtr<CSSRule> rule = p.parseRule(&tempStyleSheet, selectors + "{}");
1233     if (!rule || !rule->isStyleRule()) {
1234         ec = SYNTAX_ERR;
1235         return 0;
1236     }
1237
1238     CSSStyleSelector* styleSelector = document()->styleSelector();
1239     CSSSelector* querySelector = static_cast<CSSStyleRule*>(rule.get())->selector();
1240     
1241     // FIXME: We can speed this up by implementing caching similar to the one use by getElementById
1242     for (Node* n = firstChild(); n; n = n->traverseNextNode(this)) {
1243         if (n->isElementNode()) {
1244             Element* element = static_cast<Element*>(n);
1245             styleSelector->initElementAndPseudoState(element);
1246             styleSelector->initForStyleResolve(element, 0);
1247             for (CSSSelector* selector = querySelector; selector; selector = selector->next()) {
1248                 if (styleSelector->checkSelector(selector))
1249                     return element;
1250             }
1251         }
1252     }
1253     
1254     return 0;
1255 }
1256
1257 PassRefPtr<NodeList> Node::querySelectorAll(const String& selectors, ExceptionCode& ec)
1258 {
1259     if (selectors.isNull() || selectors.isEmpty()) {
1260         ec = SYNTAX_ERR;
1261         return 0;
1262     }
1263     CSSStyleSheet tempStyleSheet(document());
1264     CSSParser p(true);
1265     RefPtr<CSSRule> rule = p.parseRule(&tempStyleSheet, selectors + "{}");
1266     if (!rule || !rule->isStyleRule()) {
1267         ec = SYNTAX_ERR;
1268         return 0;
1269     }
1270     
1271     SelectorNodeList* resultList = new SelectorNodeList(this, static_cast<CSSStyleRule*>(rule.get())->selector());
1272
1273     return resultList;
1274 }
1275
1276 Document *Node::ownerDocument() const
1277 {
1278     Document *doc = document();
1279     return doc == this ? 0 : doc;
1280 }
1281
1282 bool Node::hasAttributes() const
1283 {
1284     return false;
1285 }
1286
1287 NamedAttrMap* Node::attributes() const
1288 {
1289     return 0;
1290 }
1291
1292 KURL Node::baseURI() const
1293 {
1294     return parentNode() ? parentNode()->baseURI() : KURL();
1295 }
1296
1297 bool Node::isEqualNode(Node *other) const
1298 {
1299     if (!other)
1300         return false;
1301     
1302     if (nodeType() != other->nodeType())
1303         return false;
1304     
1305     if (nodeName() != other->nodeName())
1306         return false;
1307     
1308     if (localName() != other->localName())
1309         return false;
1310     
1311     if (namespaceURI() != other->namespaceURI())
1312         return false;
1313     
1314     if (prefix() != other->prefix())
1315         return false;
1316     
1317     if (nodeValue() != other->nodeValue())
1318         return false;
1319     
1320     NamedAttrMap *attrs = attributes();
1321     NamedAttrMap *otherAttrs = other->attributes();
1322     
1323     if (!attrs && otherAttrs)
1324         return false;
1325     
1326     if (attrs && !attrs->mapsEquivalent(otherAttrs))
1327         return false;
1328     
1329     Node *child = firstChild();
1330     Node *otherChild = other->firstChild();
1331     
1332     while (child) {
1333         if (!child->isEqualNode(otherChild))
1334             return false;
1335         
1336         child = child->nextSibling();
1337         otherChild = otherChild->nextSibling();
1338     }
1339     
1340     if (otherChild)
1341         return false;
1342     
1343     // FIXME: For DocumentType nodes we should check equality on
1344     // the entities and notations NamedNodeMaps as well.
1345     
1346     return true;
1347 }
1348
1349 bool Node::isDefaultNamespace(const String &namespaceURI) const
1350 {
1351     // Implemented according to
1352     // http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/namespaces-algorithms.html#isDefaultNamespaceAlgo
1353     
1354     switch (nodeType()) {
1355         case ELEMENT_NODE: {
1356             const Element *elem = static_cast<const Element *>(this);
1357             
1358             if (elem->prefix().isNull())
1359                 return elem->namespaceURI() == namespaceURI;
1360
1361             if (elem->hasAttributes()) {
1362                 NamedAttrMap *attrs = elem->attributes();
1363                 
1364                 for (unsigned i = 0; i < attrs->length(); i++) {
1365                     Attribute *attr = attrs->attributeItem(i);
1366                     
1367                     if (attr->localName() == "xmlns")
1368                         return attr->value() == namespaceURI;
1369                 }
1370             }
1371
1372             if (Element* ancestor = ancestorElement())
1373                 return ancestor->isDefaultNamespace(namespaceURI);
1374
1375             return false;
1376         }
1377         case DOCUMENT_NODE:
1378             return static_cast <const Document *>(this)->documentElement()->isDefaultNamespace(namespaceURI);
1379         case ENTITY_NODE:
1380         case NOTATION_NODE:
1381         case DOCUMENT_TYPE_NODE:
1382         case DOCUMENT_FRAGMENT_NODE:
1383             return false;
1384         case ATTRIBUTE_NODE: {
1385             const Attr *attr = static_cast<const Attr *>(this);
1386             if (attr->ownerElement())
1387                 return attr->ownerElement()->isDefaultNamespace(namespaceURI);
1388             return false;
1389         }
1390         default:
1391             if (Element* ancestor = ancestorElement())
1392                 return ancestor->isDefaultNamespace(namespaceURI);
1393             return false;
1394     }
1395 }
1396
1397 String Node::lookupPrefix(const String &namespaceURI) const
1398 {
1399     // Implemented according to
1400     // http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/namespaces-algorithms.html#lookupNamespacePrefixAlgo
1401     
1402     if (namespaceURI.isEmpty())
1403         return String();
1404     
1405     switch (nodeType()) {
1406         case ELEMENT_NODE:
1407             return lookupNamespacePrefix(namespaceURI, static_cast<const Element *>(this));
1408         case DOCUMENT_NODE:
1409             return static_cast<const Document *>(this)->documentElement()->lookupPrefix(namespaceURI);
1410         case ENTITY_NODE:
1411         case NOTATION_NODE:
1412         case DOCUMENT_FRAGMENT_NODE:
1413         case DOCUMENT_TYPE_NODE:
1414             return String();
1415         case ATTRIBUTE_NODE: {
1416             const Attr *attr = static_cast<const Attr *>(this);
1417             if (attr->ownerElement())
1418                 return attr->ownerElement()->lookupPrefix(namespaceURI);
1419             return String();
1420         }
1421         default:
1422             if (Element* ancestor = ancestorElement())
1423                 return ancestor->lookupPrefix(namespaceURI);
1424             return String();
1425     }
1426 }
1427
1428 String Node::lookupNamespaceURI(const String &prefix) const
1429 {
1430     // Implemented according to
1431     // http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/namespaces-algorithms.html#lookupNamespaceURIAlgo
1432     
1433     if (!prefix.isNull() && prefix.isEmpty())
1434         return String();
1435     
1436     switch (nodeType()) {
1437         case ELEMENT_NODE: {
1438             const Element *elem = static_cast<const Element *>(this);
1439             
1440             if (!elem->namespaceURI().isNull() && elem->prefix() == prefix)
1441                 return elem->namespaceURI();
1442             
1443             if (elem->hasAttributes()) {
1444                 NamedAttrMap *attrs = elem->attributes();
1445                 
1446                 for (unsigned i = 0; i < attrs->length(); i++) {
1447                     Attribute *attr = attrs->attributeItem(i);
1448                     
1449                     if (attr->prefix() == "xmlns" && attr->localName() == prefix) {
1450                         if (!attr->value().isEmpty())
1451                             return attr->value();
1452                         
1453                         return String();
1454                     } else if (attr->localName() == "xmlns" && prefix.isNull()) {
1455                         if (!attr->value().isEmpty())
1456                             return attr->value();
1457                         
1458                         return String();
1459                     }
1460                 }
1461             }
1462             if (Element* ancestor = ancestorElement())
1463                 return ancestor->lookupNamespaceURI(prefix);
1464             return String();
1465         }
1466         case DOCUMENT_NODE:
1467             return static_cast<const Document *>(this)->documentElement()->lookupNamespaceURI(prefix);
1468         case ENTITY_NODE:
1469         case NOTATION_NODE:
1470         case DOCUMENT_TYPE_NODE:
1471         case DOCUMENT_FRAGMENT_NODE:
1472             return String();
1473         case ATTRIBUTE_NODE: {
1474             const Attr *attr = static_cast<const Attr *>(this);
1475             
1476             if (attr->ownerElement())
1477                 return attr->ownerElement()->lookupNamespaceURI(prefix);
1478             else
1479                 return String();
1480         }
1481         default:
1482             if (Element* ancestor = ancestorElement())
1483                 return ancestor->lookupNamespaceURI(prefix);
1484             return String();
1485     }
1486 }
1487
1488 String Node::lookupNamespacePrefix(const String &_namespaceURI, const Element *originalElement) const
1489 {
1490     if (_namespaceURI.isNull())
1491         return String();
1492             
1493     if (originalElement->lookupNamespaceURI(prefix()) == _namespaceURI)
1494         return prefix();
1495     
1496     if (hasAttributes()) {
1497         NamedAttrMap *attrs = attributes();
1498         
1499         for (unsigned i = 0; i < attrs->length(); i++) {
1500             Attribute *attr = attrs->attributeItem(i);
1501             
1502             if (attr->prefix() == "xmlns" &&
1503                 attr->value() == _namespaceURI &&
1504                 originalElement->lookupNamespaceURI(attr->localName()) == _namespaceURI)
1505                 return attr->localName();
1506         }
1507     }
1508     
1509     if (Element* ancestor = ancestorElement())
1510         return ancestor->lookupNamespacePrefix(_namespaceURI, originalElement);
1511     return String();
1512 }
1513
1514 String Node::textContent(bool convertBRsToNewlines) const
1515 {
1516     switch (nodeType()) {
1517         case TEXT_NODE:
1518         case CDATA_SECTION_NODE:
1519         case COMMENT_NODE:
1520         case PROCESSING_INSTRUCTION_NODE:
1521             return nodeValue();
1522         
1523         case ELEMENT_NODE:
1524             if (hasTagName(brTag) && 
1525                 convertBRsToNewlines)
1526                 return "\n";
1527         case ATTRIBUTE_NODE:
1528         case ENTITY_NODE:
1529         case ENTITY_REFERENCE_NODE:
1530         case DOCUMENT_FRAGMENT_NODE: {
1531             String s = "";
1532         
1533             for (Node *child = firstChild(); child; child = child->nextSibling()) {
1534                 if (child->nodeType() == COMMENT_NODE || child->nodeType() == PROCESSING_INSTRUCTION_NODE)
1535                     continue;
1536             
1537                 s += child->textContent(convertBRsToNewlines);
1538             }
1539         
1540             return s;
1541         }
1542         
1543         case DOCUMENT_NODE:
1544         case DOCUMENT_TYPE_NODE:
1545         case NOTATION_NODE:
1546         default:
1547             return String();
1548     }
1549 }
1550
1551 void Node::setTextContent(const String &text, ExceptionCode& ec)
1552 {           
1553     switch (nodeType()) {
1554         case TEXT_NODE:
1555         case CDATA_SECTION_NODE:
1556         case COMMENT_NODE:
1557         case PROCESSING_INSTRUCTION_NODE:
1558             setNodeValue(text, ec);
1559             break;
1560         case ELEMENT_NODE:
1561         case ATTRIBUTE_NODE:
1562         case ENTITY_NODE:
1563         case ENTITY_REFERENCE_NODE:
1564         case DOCUMENT_FRAGMENT_NODE: {
1565             ContainerNode *container = static_cast<ContainerNode *>(this);
1566             
1567             container->removeChildren();
1568             
1569             if (!text.isEmpty())
1570                 appendChild(document()->createTextNode(text), ec);
1571             break;
1572         }
1573         case DOCUMENT_NODE:
1574         case DOCUMENT_TYPE_NODE:
1575         case NOTATION_NODE:
1576         default:
1577             // Do nothing
1578             break;
1579     }
1580 }
1581
1582 Element* Node::ancestorElement() const
1583 {
1584     // In theory, there can be EntityReference nodes between elements, but this is currently not supported.
1585     for (Node* n = parentNode(); n; n = n->parentNode()) {
1586         if (n->isElementNode())
1587             return static_cast<Element*>(n);
1588     }
1589     return 0;
1590 }
1591
1592 bool Node::offsetInCharacters() const
1593 {
1594     return false;
1595 }
1596
1597 #ifndef NDEBUG
1598
1599 static void appendAttributeDesc(const Node* node, String& string, const QualifiedName& name, const char* attrDesc)
1600 {
1601     if (node->isElementNode()) {
1602         String attr = static_cast<const Element*>(node)->getAttribute(name);
1603         if (!attr.isEmpty()) {
1604             string += attrDesc;
1605             string += attr;
1606         }
1607     }
1608 }
1609
1610 void Node::showNode(const char* prefix) const
1611 {
1612     if (!prefix)
1613         prefix = "";
1614     if (isTextNode()) {
1615         String value = nodeValue();
1616         value.replace('\\', "\\\\");
1617         value.replace('\n', "\\n");
1618         fprintf(stderr, "%s%s\t%p \"%s\"\n", prefix, nodeName().utf8().data(), this, value.utf8().data());
1619     } else {
1620         String attrs = "";
1621         appendAttributeDesc(this, attrs, classAttr, " CLASS=");
1622         appendAttributeDesc(this, attrs, styleAttr, " STYLE=");
1623         fprintf(stderr, "%s%s\t%p%s\n", prefix, nodeName().utf8().data(), this, attrs.utf8().data());
1624     }
1625 }
1626
1627 void Node::showTreeForThis() const
1628 {
1629     showTreeAndMark(this, "*");
1630 }
1631
1632 void Node::showTreeAndMark(const Node* markedNode1, const char* markedLabel1, const Node* markedNode2, const char * markedLabel2) const
1633 {
1634     const Node* rootNode;
1635     const Node* node = this;
1636     while (node->parentNode() && !node->hasTagName(bodyTag))
1637         node = node->parentNode();
1638     rootNode = node;
1639         
1640     for (node = rootNode; node; node = node->traverseNextNode()) {
1641         if (node == markedNode1)
1642             fprintf(stderr, "%s", markedLabel1);
1643         if (node == markedNode2)
1644             fprintf(stderr, "%s", markedLabel2);
1645                         
1646         for (const Node* tmpNode = node; tmpNode && tmpNode != rootNode; tmpNode = tmpNode->parentNode())
1647             fprintf(stderr, "\t");
1648         node->showNode();
1649     }
1650 }
1651
1652 void Node::formatForDebugger(char* buffer, unsigned length) const
1653 {
1654     String result;
1655     String s;
1656     
1657     s = nodeName();
1658     if (s.length() == 0)
1659         result += "<none>";
1660     else
1661         result += s;
1662           
1663     strncpy(buffer, result.utf8().data(), length - 1);
1664 }
1665
1666 #endif
1667
1668 // --------
1669
1670 void NodeListsNodeData::invalidateCaches()
1671 {
1672     m_childNodeListCaches.reset();
1673     invalidateCachesThatDependOnAttributes();
1674 }
1675
1676 void NodeListsNodeData::invalidateCachesThatDependOnAttributes()
1677 {
1678     CacheMap::iterator classCachesEnd = m_classNodeListCaches.end();
1679     for (CacheMap::iterator it = m_classNodeListCaches.begin(); it != classCachesEnd; ++it)
1680         it->second->reset();
1681
1682     CacheMap::iterator nameCachesEnd = m_nameNodeListCaches.end();
1683     for (CacheMap::iterator it = m_nameNodeListCaches.begin(); it != nameCachesEnd; ++it)
1684         it->second->reset();
1685 }
1686
1687 bool NodeListsNodeData::isEmpty() const
1688 {
1689     if (!m_listsWithCaches.isEmpty())
1690         return false;
1691
1692     if (m_childNodeListCaches.refCount)
1693         return false;
1694
1695     CacheMap::const_iterator classCachesEnd = m_classNodeListCaches.end();
1696     for (CacheMap::const_iterator it = m_classNodeListCaches.begin(); it != classCachesEnd; ++it) {
1697         if (it->second->refCount)
1698             return false;
1699     }
1700
1701     CacheMap::const_iterator nameCachesEnd = m_nameNodeListCaches.end();
1702     for (CacheMap::const_iterator it = m_nameNodeListCaches.begin(); it != nameCachesEnd; ++it) {
1703         if (it->second->refCount)
1704             return false;
1705     }
1706
1707     return true;
1708 }
1709
1710 void Node::getSubresourceURLs(Vector<KURL>& urls) const
1711 {
1712     Vector<String> subresourceStrings;
1713     getSubresourceAttributeStrings(subresourceStrings);
1714     
1715     for (unsigned i = 0; i < subresourceStrings.size(); ++i) {
1716         String& subresourceString(subresourceStrings[i]);
1717         
1718         // FIXME: Is parseURL appropriate here?
1719         if (subresourceString.length())
1720             urls.append(document()->completeURL(parseURL(subresourceString)));
1721     }
1722 }
1723
1724 // --------
1725
1726 } // namespace WebCore
1727
1728 #ifndef NDEBUG
1729
1730 void showTree(const WebCore::Node* node)
1731 {
1732     if (node)
1733         node->showTreeForThis();
1734 }
1735
1736 #endif