553af80cadc0b3d9cb0026f8109e018653875d46
[WebKit-https.git] / WebCore / dom / ContainerNode.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., 51 Franklin Street, Fifth Floor,
22  * Boston, MA 02110-1301, USA.
23  */
24
25 #include "config.h"
26 #include "ContainerNode.h"
27
28 #include "DeleteButtonController.h"
29 #include "Document.h"
30 #include "Editor.h"
31 #include "EventNames.h"
32 #include "ExceptionCode.h"
33 #include "FrameView.h"
34 #include "InlineTextBox.h"
35 #include "MutationEvent.h"
36 #include "RenderTheme.h"
37 #include "RootInlineBox.h"
38 #include "SystemTime.h"
39 #include <wtf/Vector.h>
40
41 namespace WebCore {
42
43 using namespace EventNames;
44
45 static void dispatchChildInsertionEvents(Node*, ExceptionCode&);
46 static void dispatchChildRemovalEvents(Node*, ExceptionCode&);
47
48 typedef Vector<std::pair<NodeCallback, Node*> > NodeCallbackQueue;
49 static NodeCallbackQueue* s_postAttachCallbackQueue = 0;
50
51 static size_t s_attachDepth = 0;
52
53 ContainerNode::ContainerNode(Document* doc)
54     : EventTargetNode(doc), m_firstChild(0), m_lastChild(0)
55 {
56 }
57
58 void ContainerNode::addChildNodesToDeletionQueue(Node*& head, Node*& tail, ContainerNode* container)
59 {
60     // We have to tell all children that their parent has died.
61     Node* n;
62     Node* next;
63     for (n = container->firstChild(); n != 0; n = next) {
64         ASSERT(!n->m_deletionHasBegun);
65         
66         next = n->nextSibling();
67         n->setPreviousSibling(0);
68         n->setNextSibling(0);
69         n->setParent(0);
70         
71         if (!n->refCount()) {
72 #ifndef NDEBUG
73             n->m_deletionHasBegun = true;
74 #endif
75             // Add the node to the list of nodes to be deleted.
76             // Reuse the nextSibling pointer for this purpose.
77             if (tail)
78                 tail->setNextSibling(n);
79             else
80                 head = n;
81             tail = n;
82         } else if (n->inDocument())
83             n->removedFromDocument();
84     }
85     container->setFirstChild(0);
86     container->setLastChild(0);
87 }
88
89 void ContainerNode::removeAllChildren()
90 {
91     // List of nodes to be deleted.
92     Node* head = 0;
93     Node* tail = 0;
94
95     addChildNodesToDeletionQueue(head, tail, this);
96
97     Node* n;
98     Node* next;
99     while ((n = head) != 0) {
100         ASSERT(n->m_deletionHasBegun);
101
102         next = n->nextSibling();
103         n->setNextSibling(0);
104
105         head = next;
106         if (next == 0)
107             tail = 0;
108         
109         if (n->hasChildNodes())
110             addChildNodesToDeletionQueue(head, tail, static_cast<ContainerNode*>(n));
111         
112         delete n;
113     }
114 }
115
116 ContainerNode::~ContainerNode()
117 {
118     removeAllChildren();
119 }
120
121
122 Node* ContainerNode::virtualFirstChild() const
123 {
124     return m_firstChild;
125 }
126
127 Node* ContainerNode::virtualLastChild() const
128 {
129     return m_lastChild;
130 }
131
132 bool ContainerNode::insertBefore(PassRefPtr<Node> newChild, Node* refChild, ExceptionCode& ec)
133 {
134     // Check that this node is not "floating".
135     // If it is, it can be deleted as a side effect of sending mutation events.
136     ASSERT(refCount() || parent());
137
138     ec = 0;
139
140     // insertBefore(node, 0) is equivalent to appendChild(node)
141     if (!refChild)
142         return appendChild(newChild, ec);
143
144     // Make sure adding the new child is OK.
145     checkAddChild(newChild.get(), ec);
146     if (ec)
147         return false;
148
149     // NOT_FOUND_ERR: Raised if refChild is not a child of this node
150     if (refChild->parentNode() != this) {
151         ec = NOT_FOUND_ERR;
152         return false;
153     }
154
155     bool isFragment = newChild->nodeType() == DOCUMENT_FRAGMENT_NODE;
156
157     // If newChild is a DocumentFragment with no children; there's nothing to do.
158     // Just return true
159     if (isFragment && !newChild->firstChild())
160         return true;
161
162     // Now actually add the child(ren)
163     if (refChild->previousSibling() == newChild || refChild == newChild) // nothing to do
164         return true;
165
166     RefPtr<Node> next = refChild;
167
168     RefPtr<Node> child = isFragment ? newChild->firstChild() : newChild;
169     while (child) {
170         RefPtr<Node> nextChild = isFragment ? child->nextSibling() : 0;
171
172         // If child is already present in the tree, first remove it from the old location.
173         if (Node* oldParent = child->parentNode())
174             oldParent->removeChild(child.get(), ec);
175         if (ec)
176             return 0;
177
178         // FIXME: After sending the mutation events, "this" could be destroyed.
179         // We can prevent that by doing a "ref", but first we have to make sure
180         // that no callers call with ref count == 0 and parent = 0 (as of this
181         // writing, there are definitely callers who call that way).
182
183         // Due to arbitrary code running in response to a DOM mutation event it's
184         // possible that "next" is no longer a child of "this".
185         // It's also possible that "child" has been inserted elsewhere.
186         // In either of those cases, we'll just stop.
187         if (next->parentNode() != this)
188             break;
189         if (child->parentNode())
190             break;
191
192         ASSERT(!child->nextSibling());
193         ASSERT(!child->previousSibling());
194
195         // Add child before "next".
196         forbidEventDispatch();
197         Node* prev = next->previousSibling();
198         ASSERT(m_lastChild != prev);
199         next->setPreviousSibling(child.get());
200         if (prev) {
201             ASSERT(m_firstChild != next);
202             ASSERT(prev->nextSibling() == next);
203             prev->setNextSibling(child.get());
204         } else {
205             ASSERT(m_firstChild == next);
206             m_firstChild = child.get();
207         }
208         child->setParent(this);
209         child->setPreviousSibling(prev);
210         child->setNextSibling(next.get());
211         allowEventDispatch();
212
213         // Dispatch the mutation events.
214         dispatchChildInsertionEvents(child.get(), ec);
215                 
216         // Add child to the rendering tree.
217         if (attached() && !child->attached() && child->parent() == this)
218             child->attach();
219
220         child = nextChild.release();
221     }
222
223     document()->setDocumentChanged(true);
224     dispatchSubtreeModifiedEvent();
225     return true;
226 }
227
228 bool ContainerNode::replaceChild(PassRefPtr<Node> newChild, Node* oldChild, ExceptionCode& ec)
229 {
230     // Check that this node is not "floating".
231     // If it is, it can be deleted as a side effect of sending mutation events.
232     ASSERT(refCount() || parent());
233
234     ec = 0;
235
236     if (oldChild == newChild) // nothing to do
237         return true;
238     
239     // Make sure replacing the old child with the new is ok
240     checkReplaceChild(newChild.get(), oldChild, ec);
241     if (ec)
242         return false;
243
244     // NOT_FOUND_ERR: Raised if oldChild is not a child of this node.
245     if (!oldChild || oldChild->parentNode() != this) {
246         ec = NOT_FOUND_ERR;
247         return false;
248     }
249
250     RefPtr<Node> prev = oldChild->previousSibling();
251
252     // Remove the node we're replacing
253     RefPtr<Node> removedChild = oldChild;
254     removeChild(oldChild, ec);
255     if (ec)
256         return false;
257
258     // FIXME: After sending the mutation events, "this" could be destroyed.
259     // We can prevent that by doing a "ref", but first we have to make sure
260     // that no callers call with ref count == 0 and parent = 0 (as of this
261     // writing, there are definitely callers who call that way).
262
263     bool isFragment = newChild->nodeType() == DOCUMENT_FRAGMENT_NODE;
264
265     // Add the new child(ren)
266     RefPtr<Node> child = isFragment ? newChild->firstChild() : newChild;
267     while (child) {
268         // If the new child is already in the right place, we're done.
269         if (prev && (prev == child || prev == child->previousSibling()))
270             break;
271
272         // For a fragment we have more children to do.
273         RefPtr<Node> nextChild = isFragment ? child->nextSibling() : 0;
274
275         // Remove child from its old position.
276         if (Node* oldParent = child->parentNode())
277             oldParent->removeChild(child.get(), ec);
278         if (ec)
279             return 0;
280
281         // Due to arbitrary code running in response to a DOM mutation event it's
282         // possible that "prev" is no longer a child of "this".
283         // It's also possible that "child" has been inserted elsewhere.
284         // In either of those cases, we'll just stop.
285         if (prev && prev->parentNode() != this)
286             break;
287         if (child->parentNode())
288             break;
289
290         ASSERT(!child->nextSibling());
291         ASSERT(!child->previousSibling());
292
293         // Add child after "prev".
294         forbidEventDispatch();
295         Node* next;
296         if (prev) {
297             next = prev->nextSibling();
298             ASSERT(m_firstChild != next);
299             prev->setNextSibling(child.get());
300         } else {
301             next = m_firstChild;
302             m_firstChild = child.get();
303         }
304         if (next) {
305             ASSERT(m_lastChild != prev);
306             ASSERT(next->previousSibling() == prev);
307             next->setPreviousSibling(child.get());
308         } else {
309             ASSERT(m_lastChild == prev);
310             m_lastChild = child.get();
311         }
312         child->setParent(this);
313         child->setPreviousSibling(prev.get());
314         child->setNextSibling(next);
315         allowEventDispatch();
316
317         // Dispatch the mutation events
318         dispatchChildInsertionEvents(child.get(), ec);
319                 
320         // Add child to the rendering tree
321         if (attached() && !child->attached() && child->parent() == this)
322             child->attach();
323
324         prev = child;
325         child = nextChild.release();
326     }
327
328     // ### set style in case it's attached
329     document()->setDocumentChanged(true);
330     dispatchSubtreeModifiedEvent();
331     return true;
332 }
333
334 void ContainerNode::willRemove()
335 {
336     for (Node *n = m_firstChild; n != 0; n = n->nextSibling())
337         n->willRemove();
338     EventTargetNode::willRemove();
339 }
340
341 static ExceptionCode willRemoveChild(Node *child)
342 {
343     ExceptionCode ec = 0;
344
345     // fire removed from document mutation events.
346     dispatchChildRemovalEvents(child, ec);
347     if (ec)
348         return ec;
349
350     if (child->attached())
351         child->willRemove();
352     
353     return 0;
354 }
355
356 bool ContainerNode::removeChild(Node* oldChild, ExceptionCode& ec)
357 {
358     // Check that this node is not "floating".
359     // If it is, it can be deleted as a side effect of sending mutation events.
360     ASSERT(refCount() || parent());
361
362     ec = 0;
363
364     // NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly.
365     if (isReadOnlyNode()) {
366         ec = NO_MODIFICATION_ALLOWED_ERR;
367         return false;
368     }
369
370     // NOT_FOUND_ERR: Raised if oldChild is not a child of this node.
371     if (!oldChild || oldChild->parentNode() != this) {
372         ec = NOT_FOUND_ERR;
373         return false;
374     }
375
376     RefPtr<Node> child = oldChild;
377     
378     // dispatch pre-removal mutation events
379     if (document()->hasListenerType(Document::DOMNODEREMOVED_LISTENER)) {
380         EventTargetNodeCast(child.get())->dispatchEvent(new MutationEvent(DOMNodeRemovedEvent, true, false,
381             this, String(), String(), String(), 0), ec, true);
382         if (ec)
383             return false;
384     }
385
386     ec = willRemoveChild(child.get());
387     if (ec)
388         return false;
389
390     // Mutation events might have moved this child into a different parent.
391     if (child->parentNode() != this) {
392         ec = NOT_FOUND_ERR;
393         return false;
394     }
395
396     // FIXME: After sending the mutation events, "this" could be destroyed.
397     // We can prevent that by doing a "ref", but first we have to make sure
398     // that no callers call with ref count == 0 and parent = 0 (as of this
399     // writing, there are definitely callers who call that way).
400
401     forbidEventDispatch();
402
403     // Remove from rendering tree
404     if (child->attached())
405         child->detach();
406
407     // Remove the child
408     Node *prev, *next;
409     prev = child->previousSibling();
410     next = child->nextSibling();
411
412     if (next)
413         next->setPreviousSibling(prev);
414     if (prev)
415         prev->setNextSibling(next);
416     if (m_firstChild == child)
417         m_firstChild = next;
418     if (m_lastChild == child)
419         m_lastChild = prev;
420
421     child->setPreviousSibling(0);
422     child->setNextSibling(0);
423     child->setParent(0);
424
425     allowEventDispatch();
426
427     document()->setDocumentChanged(true);
428
429     // Dispatch post-removal mutation events
430     dispatchSubtreeModifiedEvent();
431
432     if (child->inDocument())
433         child->removedFromDocument();
434     else
435         child->removedFromTree(true);
436
437     return child;
438 }
439
440 // this differs from other remove functions because it forcibly removes all the children,
441 // regardless of read-only status or event exceptions, e.g.
442 void ContainerNode::removeChildren()
443 {
444     Node *n;
445     
446     if (!m_firstChild)
447         return;
448
449     // do any prep work needed before actually starting to detach
450     // and remove... e.g. stop loading frames, fire unload events
451     for (n = m_firstChild; n; n = n->nextSibling())
452         willRemoveChild(n);
453     
454     forbidEventDispatch();
455     while ((n = m_firstChild) != 0) {
456         Node *next = n->nextSibling();
457         
458         n->ref();
459
460         // Remove the node from the tree before calling detach or removedFromDocument (4427024, 4129744)
461         n->setPreviousSibling(0);
462         n->setNextSibling(0);
463         n->setParent(0);
464         
465         m_firstChild = next;
466         if (n == m_lastChild)
467             m_lastChild = 0;
468
469         if (n->attached())
470             n->detach();
471         
472         if (n->inDocument())
473             n->removedFromDocument();
474
475         n->deref();
476     }
477     allowEventDispatch();
478     
479     // Dispatch a single post-removal mutation event denoting a modified subtree.
480     dispatchSubtreeModifiedEvent();
481 }
482
483
484 bool ContainerNode::appendChild(PassRefPtr<Node> newChild, ExceptionCode& ec)
485 {
486     // Check that this node is not "floating".
487     // If it is, it can be deleted as a side effect of sending mutation events.
488     ASSERT(refCount() || parent());
489
490     ec = 0;
491
492     // Make sure adding the new child is ok
493     checkAddChild(newChild.get(), ec);
494     if (ec)
495         return 0;
496     
497     if (newChild == m_lastChild) // nothing to do
498         return newChild;
499
500     bool isFragment = newChild->nodeType() == DOCUMENT_FRAGMENT_NODE;
501
502     // If newChild is a DocumentFragment with no children.... there's nothing to do.
503     // Just return the document fragment
504     if (isFragment && !newChild->firstChild())
505         return true;
506
507     // Now actually add the child(ren)
508     RefPtr<Node> child = isFragment ? newChild->firstChild() : newChild;
509     while (child) {
510         // For a fragment we have more children to do.
511         RefPtr<Node> nextChild = isFragment ? child->nextSibling() : 0;
512
513         // If child is already present in the tree, first remove it
514         if (Node* oldParent = child->parentNode()) {
515             oldParent->removeChild(child.get(), ec);
516             if (ec)
517                 return 0;
518             
519             // If the child has a parent again, just stop what we're doing, because
520             // that means someone is doing something with DOM mutation -- can't re-parent
521             // a child that already has a parent.
522             if (child->parentNode())
523                 break;
524         }
525
526         // Append child to the end of the list
527         forbidEventDispatch();
528         child->setParent(this);
529         if (m_lastChild) {
530             child->setPreviousSibling(m_lastChild);
531             m_lastChild->setNextSibling(child.get());
532         } else
533             m_firstChild = child.get();
534         m_lastChild = child.get();
535         allowEventDispatch();
536
537         // Dispatch the mutation events
538         dispatchChildInsertionEvents(child.get(), ec);
539
540         // Add child to the rendering tree
541         if (attached() && !child->attached() && child->parent() == this)
542             child->attach();
543         
544         child = nextChild.release();
545     }
546
547     document()->setDocumentChanged(true);
548     dispatchSubtreeModifiedEvent();
549     return true;
550 }
551
552 bool ContainerNode::hasChildNodes() const
553 {
554     return m_firstChild;
555 }
556
557 ContainerNode* ContainerNode::addChild(PassRefPtr<Node> newChild)
558 {
559     // This function is only used during parsing.
560     // It does not send any DOM mutation events.
561
562     // Check for consistency with DTD, but only when parsing HTML.
563     if (document()->isHTMLDocument() && !childAllowed(newChild.get()))
564         return 0;
565
566     forbidEventDispatch();
567     newChild->setParent(this);
568     if (m_lastChild) {
569         newChild->setPreviousSibling(m_lastChild);
570         m_lastChild->setNextSibling(newChild.get());
571     } else
572         m_firstChild = newChild.get();
573     m_lastChild = newChild.get();
574     allowEventDispatch();
575
576     if (inDocument())
577         newChild->insertedIntoDocument();
578     if (document()->hasNodeLists())
579         notifyNodeListsChildrenChanged();
580     childrenChanged();
581     
582     if (newChild->isElementNode())
583         return static_cast<ContainerNode*>(newChild.get());
584     return this;
585 }
586
587 void ContainerNode::queuePostAttachCallback(NodeCallback callback, Node* node)
588 {
589     if (!s_postAttachCallbackQueue)
590         s_postAttachCallbackQueue = new NodeCallbackQueue;
591     
592     s_postAttachCallbackQueue->append(std::pair<NodeCallback, Node*>(callback, node));
593 }
594
595 void ContainerNode::attach()
596 {
597     ++s_attachDepth;
598
599     for (Node* child = m_firstChild; child; child = child->nextSibling())
600         child->attach();
601     EventTargetNode::attach();
602
603     if (s_attachDepth == 1) {
604         if (s_postAttachCallbackQueue) {
605             // We recalculate size() each time through the loop because a callback
606             // can add more callbacks to the end of the queue.
607             for (size_t i = 0; i < s_postAttachCallbackQueue->size(); ++i) {
608                 std::pair<NodeCallback, Node*>& pair = (*s_postAttachCallbackQueue)[i];
609                 NodeCallback callback = pair.first;
610                 Node* node = pair.second;
611                 
612                 callback(node);
613             }
614             s_postAttachCallbackQueue->clear();
615         }
616     }    
617     --s_attachDepth;
618 }
619
620 void ContainerNode::detach()
621 {
622     for (Node* child = m_firstChild; child; child = child->nextSibling())
623         child->detach();
624     EventTargetNode::detach();
625 }
626
627 void ContainerNode::insertedIntoDocument()
628 {
629     EventTargetNode::insertedIntoDocument();
630     for (Node *child = m_firstChild; child; child = child->nextSibling())
631         child->insertedIntoDocument();
632 }
633
634 void ContainerNode::removedFromDocument()
635 {
636     EventTargetNode::removedFromDocument();
637     for (Node *child = m_firstChild; child; child = child->nextSibling())
638         child->removedFromDocument();
639 }
640
641 void ContainerNode::insertedIntoTree(bool deep)
642 {
643     EventTargetNode::insertedIntoTree(deep);
644     if (deep) {
645         for (Node *child = m_firstChild; child; child = child->nextSibling())
646             child->insertedIntoTree(deep);
647     }
648 }
649
650 void ContainerNode::removedFromTree(bool deep)
651 {
652     EventTargetNode::removedFromTree(deep);
653     if (deep) {
654         for (Node *child = m_firstChild; child; child = child->nextSibling())
655             child->removedFromTree(deep);
656     }
657 }
658
659 void ContainerNode::cloneChildNodes(Node *clone)
660 {
661     // disable the delete button so it's elements are not serialized into the markup
662     if (document()->frame())
663         document()->frame()->editor()->deleteButtonController()->disable();
664     ExceptionCode ec = 0;
665     for (Node* n = firstChild(); n && !ec; n = n->nextSibling())
666         clone->appendChild(n->cloneNode(true), ec);
667     if (document()->frame())
668         document()->frame()->editor()->deleteButtonController()->enable();
669 }
670
671 bool ContainerNode::getUpperLeftCorner(int &xPos, int &yPos) const
672 {
673     if (!renderer())
674         return false;
675     RenderObject *o = renderer();
676     RenderObject *p = o;
677
678     xPos = yPos = 0;
679     if (!o->isInline() || o->isReplaced()) {
680         o->absolutePosition(xPos, yPos);
681         return true;
682     }
683
684     // find the next text/image child, to get a position
685     while(o) {
686         p = o;
687         if (o->firstChild())
688             o = o->firstChild();
689         else if(o->nextSibling())
690             o = o->nextSibling();
691         else {
692             RenderObject *next = 0;
693             while (!next && o->parent()) {
694                 o = o->parent();
695                 next = o->nextSibling();
696             }
697             o = next;
698
699             if (!o)
700                 break;
701         }
702
703         if (!o->isInline() || o->isReplaced()) {
704             o->absolutePosition(xPos, yPos);
705             return true;
706         }
707
708         if (p->element() && p->element() == this && o->isText() && !o->isBR() && !static_cast<RenderText*>(o)->firstTextBox()) {
709                 // do nothing - skip unrendered whitespace that is a child or next sibling of the anchor
710         } else if ((o->isText() && !o->isBR()) || o->isReplaced()) {
711             o->container()->absolutePosition(xPos, yPos);
712             if (o->isText() && static_cast<RenderText *>(o)->firstTextBox()) {
713                 xPos += static_cast<RenderText *>(o)->minXPos();
714                 yPos += static_cast<RenderText *>(o)->firstTextBox()->root()->topOverflow();
715             } else {
716                 xPos += o->xPos();
717                 yPos += o->yPos();
718             }
719             return true;
720         }
721     }
722     
723     // If the target doesn't have any children or siblings that could be used to calculate the scroll position, we must be
724     // at the end of the document.  Scroll to the bottom.
725     if (!o && document()->view()) {
726         yPos += document()->view()->contentsHeight();
727         return true;
728     }
729     return false;
730 }
731
732 bool ContainerNode::getLowerRightCorner(int &xPos, int &yPos) const
733 {
734     if (!renderer())
735         return false;
736
737     RenderObject *o = renderer();
738     xPos = yPos = 0;
739     if (!o->isInline() || o->isReplaced())
740     {
741         o->absolutePosition(xPos, yPos);
742         xPos += o->width();
743         yPos += o->height() + o->borderTopExtra() + o->borderBottomExtra();
744         return true;
745     }
746     // find the last text/image child, to get a position
747     while(o) {
748         if(o->lastChild())
749             o = o->lastChild();
750         else if(o->previousSibling())
751             o = o->previousSibling();
752         else {
753             RenderObject *prev = 0;
754             while(!prev) {
755                 o = o->parent();
756                 if(!o) return false;
757                 prev = o->previousSibling();
758             }
759             o = prev;
760         }
761         if (o->isText() || o->isReplaced()) {
762             o->container()->absolutePosition(xPos, yPos);
763             if (o->isText())
764                 xPos += static_cast<RenderText *>(o)->minXPos() + o->width();
765             else
766                 xPos += o->xPos()+o->width();
767             yPos += o->yPos()+o->height();
768             return true;
769         }
770     }
771     return true;
772 }
773
774 IntRect ContainerNode::getRect() const
775 {
776     int xPos = 0, yPos = 0, xEnd = 0, yEnd = 0;
777     bool foundUpperLeft = getUpperLeftCorner(xPos,yPos);
778     bool foundLowerRight = getLowerRightCorner(xEnd,yEnd);
779     
780     // If we've found one corner, but not the other,
781     // then we should just return a point at the corner that we did find.
782     if (foundUpperLeft != foundLowerRight)
783     {
784         if (foundUpperLeft) {
785             xEnd = xPos;
786             yEnd = yPos;
787         } else {
788             xPos = xEnd;
789             yPos = yEnd;
790         }
791     } 
792
793     if (xEnd < xPos)
794         xEnd = xPos;
795     if (yEnd < yPos)
796         yEnd = yPos;
797         
798     return IntRect(xPos, yPos, xEnd - xPos, yEnd - yPos);
799 }
800
801 void ContainerNode::setFocus(bool received)
802 {
803     if (m_focused == received) return;
804
805     EventTargetNode::setFocus(received);
806
807     // note that we need to recalc the style
808     setChanged();
809 }
810
811 void ContainerNode::setActive(bool down, bool pause)
812 {
813     if (down == active()) return;
814
815     EventTargetNode::setActive(down);
816
817     // note that we need to recalc the style
818     // FIXME: Move to Element
819     if (renderer()) {
820         bool reactsToPress = renderer()->style()->affectedByActiveRules();
821         if (reactsToPress)
822             setChanged();
823         if (renderer() && renderer()->style()->hasAppearance()) {
824             if (theme()->stateChanged(renderer(), PressedState))
825                 reactsToPress = true;
826         }
827         if (reactsToPress && pause) {
828             // The delay here is subtle.  It relies on an assumption, namely that the amount of time it takes
829             // to repaint the "down" state of the control is about the same time as it would take to repaint the
830             // "up" state.  Once you assume this, you can just delay for 100ms - that time (assuming that after you
831             // leave this method, it will be about that long before the flush of the up state happens again).
832 #ifdef HAVE_FUNC_USLEEP
833             double startTime = currentTime();
834 #endif
835
836             // Ensure there are no pending changes
837             Document::updateDocumentsRendering();
838             // Do an immediate repaint.
839             if (renderer())
840                 renderer()->repaint(true);
841             
842             // FIXME: Find a substitute for usleep for Win32.
843             // Better yet, come up with a way of doing this that doesn't use this sort of thing at all.            
844 #ifdef HAVE_FUNC_USLEEP
845             // Now pause for a small amount of time (1/10th of a second from before we repainted in the pressed state)
846             double remainingTime = 0.1 - (currentTime() - startTime);
847             if (remainingTime > 0)
848                 usleep(static_cast<useconds_t>(remainingTime * 1000000.0));
849 #endif
850         }
851     }
852 }
853
854 void ContainerNode::setHovered(bool over)
855 {
856     if (over == hovered()) return;
857
858     EventTargetNode::setHovered(over);
859
860     // note that we need to recalc the style
861     // FIXME: Move to Element
862     if (renderer()) {
863         if (renderer()->style()->affectedByHoverRules())
864             setChanged();
865         if (renderer() && renderer()->style()->hasAppearance())
866             theme()->stateChanged(renderer(), HoverState);
867     }
868 }
869
870 unsigned ContainerNode::childNodeCount() const
871 {
872     unsigned count = 0;
873     Node *n;
874     for (n = firstChild(); n; n = n->nextSibling())
875         count++;
876     return count;
877 }
878
879 Node *ContainerNode::childNode(unsigned index) const
880 {
881     unsigned i;
882     Node *n = firstChild();
883     for (i = 0; n != 0 && i < index; i++)
884         n = n->nextSibling();
885     return n;
886 }
887
888 static void dispatchChildInsertionEvents(Node* child, ExceptionCode& ec)
889 {
890     ASSERT(!eventDispatchForbidden());
891
892     RefPtr<Node> c = child;
893     DocPtr<Document> doc = child->document();
894
895     if (c->parentNode() && c->parentNode()->inDocument())
896         c->insertedIntoDocument();
897     else
898         c->insertedIntoTree(true);
899
900     if (c->parentNode() && 
901         doc->hasListenerType(Document::DOMNODEINSERTED_LISTENER) &&
902         c->isEventTargetNode()) {
903         ec = 0;
904         EventTargetNodeCast(c.get())->dispatchEvent(new MutationEvent(DOMNodeInsertedEvent, true, false,
905             c->parentNode(), String(), String(), String(), 0), ec, true);
906         if (ec)
907             return;
908     }
909
910     // dispatch the DOMNodeInsertedIntoDocument event to all descendants
911     if (c->inDocument() && doc->hasListenerType(Document::DOMNODEINSERTEDINTODOCUMENT_LISTENER))
912         for (; c; c = c->traverseNextNode(child)) {
913             if (!c->isEventTargetNode())
914                 continue;
915           
916             ec = 0;
917             EventTargetNodeCast(c.get())->dispatchEvent(new MutationEvent(DOMNodeInsertedIntoDocumentEvent, false, false,
918                 0, String(), String(), String(), 0), ec, true);
919             if (ec)
920                 return;
921         }
922 }
923
924 static void dispatchChildRemovalEvents(Node* child, ExceptionCode& ec)
925 {
926     RefPtr<Node> c = child;
927     DocPtr<Document> doc = child->document();
928
929     // update auxiliary doc info (e.g. iterators) to note that node is being removed
930     doc->notifyBeforeNodeRemoval(child); // ### use events instead
931
932     // dispatch pre-removal mutation events
933     if (c->parentNode() && 
934         doc->hasListenerType(Document::DOMNODEREMOVED_LISTENER) &&
935         c->isEventTargetNode()) {
936         ec = 0;
937         EventTargetNodeCast(c.get())->dispatchEvent(new MutationEvent(DOMNodeRemovedEvent, true, false,
938             c->parentNode(), String(), String(), String(), 0), ec, true);
939         if (ec)
940             return;
941     }
942
943     // dispatch the DOMNodeRemovedFromDocument event to all descendants
944     if (c->inDocument() && doc->hasListenerType(Document::DOMNODEREMOVEDFROMDOCUMENT_LISTENER))
945         for (; c; c = c->traverseNextNode(child)) {
946             if (!c->isEventTargetNode())
947                 continue;
948             ec = 0;
949             EventTargetNodeCast(c.get())->dispatchEvent(new MutationEvent(DOMNodeRemovedFromDocumentEvent, false, false,
950                 0, String(), String(), String(), 0), ec, true);
951             if (ec)
952                 return;
953         }
954 }
955
956 }