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