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