#include "config.h"
#include "ContainerNode.h"
#include "Cache.h"
#include "ContainerNodeAlgorithms.h"
#include "DeleteButtonController.h"
#include "EventNames.h"
#include "ExceptionCode.h"
#include "FloatRect.h"
#include "Frame.h"
#include "FrameView.h"
#include "InlineTextBox.h"
#include "MutationEvent.h"
#include "Page.h"
#include "RenderTheme.h"
#include "RootInlineBox.h"
#include "loader.h"
#include <wtf/CurrentTime.h>
namespace WebCore {
static void dispatchChildInsertionEvents(Node*, ExceptionCode&);
static void dispatchChildRemovalEvents(Node*, ExceptionCode&);
typedef Vector<std::pair<NodeCallback, RefPtr<Node> > > NodeCallbackQueue;
static NodeCallbackQueue* s_postAttachCallbackQueue;
static size_t s_attachDepth;
static bool s_shouldReEnableMemoryCacheCallsAfterAttach;
void ContainerNode::removeAllChildren()
{
removeAllChildrenInContainer<Node, ContainerNode>(this);
}
ContainerNode::~ContainerNode()
{
removeAllChildren();
}
bool ContainerNode::insertBefore(PassRefPtr<Node> newChild, Node* refChild, ExceptionCode& ec, bool shouldLazyAttach)
{
ASSERT(refCount() || parent());
ec = 0;
if (!refChild)
return appendChild(newChild, ec, shouldLazyAttach);
checkAddChild(newChild.get(), ec);
if (ec)
return false;
if (refChild->parentNode() != this) {
ec = NOT_FOUND_ERR;
return false;
}
bool isFragment = newChild->nodeType() == DOCUMENT_FRAGMENT_NODE;
if (isFragment && !newChild->firstChild())
return true;
if (refChild->previousSibling() == newChild || refChild == newChild) return true;
RefPtr<Node> next = refChild;
RefPtr<Node> refChildPreviousSibling = refChild->previousSibling();
RefPtr<Node> child = isFragment ? newChild->firstChild() : newChild;
while (child) {
RefPtr<Node> nextChild = isFragment ? child->nextSibling() : 0;
if (Node* oldParent = child->parentNode())
oldParent->removeChild(child.get(), ec);
if (ec)
return 0;
if (next->parentNode() != this)
break;
if (child->parentNode())
break;
ASSERT(!child->nextSibling());
ASSERT(!child->previousSibling());
forbidEventDispatch();
Node* prev = next->previousSibling();
ASSERT(m_lastChild != prev);
next->setPreviousSibling(child.get());
if (prev) {
ASSERT(m_firstChild != next);
ASSERT(prev->nextSibling() == next);
prev->setNextSibling(child.get());
} else {
ASSERT(m_firstChild == next);
m_firstChild = child.get();
}
child->setParent(this);
child->setPreviousSibling(prev);
child->setNextSibling(next.get());
allowEventDispatch();
childrenChanged(false, refChildPreviousSibling.get(), next.get(), 1);
dispatchChildInsertionEvents(child.get(), ec);
if (attached() && !child->attached() && child->parent() == this) {
if (shouldLazyAttach)
child->lazyAttach();
else
child->attach();
}
child = nextChild.release();
}
dispatchSubtreeModifiedEvent();
return true;
}
bool ContainerNode::replaceChild(PassRefPtr<Node> newChild, Node* oldChild, ExceptionCode& ec, bool shouldLazyAttach)
{
ASSERT(refCount() || parent());
ec = 0;
if (oldChild == newChild) return true;
checkReplaceChild(newChild.get(), oldChild, ec);
if (ec)
return false;
if (!oldChild || oldChild->parentNode() != this) {
ec = NOT_FOUND_ERR;
return false;
}
RefPtr<Node> prev = oldChild->previousSibling();
RefPtr<Node> next = oldChild->nextSibling();
RefPtr<Node> removedChild = oldChild;
removeChild(oldChild, ec);
if (ec)
return false;
bool isFragment = newChild->nodeType() == DOCUMENT_FRAGMENT_NODE;
int childCountDelta = 0;
RefPtr<Node> child = isFragment ? newChild->firstChild() : newChild;
while (child) {
if (prev && (prev == child || prev == child->previousSibling()))
break;
RefPtr<Node> nextChild = isFragment ? child->nextSibling() : 0;
if (Node* oldParent = child->parentNode())
oldParent->removeChild(child.get(), ec);
if (ec)
return false;
if (prev && prev->parentNode() != this)
break;
if (child->parentNode())
break;
childCountDelta++;
ASSERT(!child->nextSibling());
ASSERT(!child->previousSibling());
forbidEventDispatch();
Node* next;
if (prev) {
next = prev->nextSibling();
ASSERT(m_firstChild != next);
prev->setNextSibling(child.get());
} else {
next = m_firstChild;
m_firstChild = child.get();
}
if (next) {
ASSERT(m_lastChild != prev);
ASSERT(next->previousSibling() == prev);
next->setPreviousSibling(child.get());
} else {
ASSERT(m_lastChild == prev);
m_lastChild = child.get();
}
child->setParent(this);
child->setPreviousSibling(prev.get());
child->setNextSibling(next);
allowEventDispatch();
dispatchChildInsertionEvents(child.get(), ec);
if (attached() && !child->attached() && child->parent() == this) {
if (shouldLazyAttach)
child->lazyAttach();
else
child->attach();
}
prev = child;
child = nextChild.release();
}
if (childCountDelta)
childrenChanged(false, prev.get(), next.get(), childCountDelta);
dispatchSubtreeModifiedEvent();
return true;
}
void ContainerNode::willRemove()
{
for (Node *n = m_firstChild; n != 0; n = n->nextSibling())
n->willRemove();
Node::willRemove();
}
static ExceptionCode willRemoveChild(Node *child)
{
ExceptionCode ec = 0;
dispatchChildRemovalEvents(child, ec);
if (ec)
return ec;
if (child->attached())
child->willRemove();
return 0;
}
bool ContainerNode::removeChild(Node* oldChild, ExceptionCode& ec)
{
ASSERT(refCount() || parent());
ec = 0;
if (isReadOnlyNode()) {
ec = NO_MODIFICATION_ALLOWED_ERR;
return false;
}
if (!oldChild || oldChild->parentNode() != this) {
ec = NOT_FOUND_ERR;
return false;
}
RefPtr<Node> child = oldChild;
ec = willRemoveChild(child.get());
if (ec)
return false;
if (child->parentNode() != this) {
ec = NOT_FOUND_ERR;
return false;
}
document()->removeFocusedNodeOfSubtree(child.get());
forbidEventDispatch();
if (child->attached())
child->detach();
Node *prev, *next;
prev = child->previousSibling();
next = child->nextSibling();
if (next)
next->setPreviousSibling(prev);
if (prev)
prev->setNextSibling(next);
if (m_firstChild == child)
m_firstChild = next;
if (m_lastChild == child)
m_lastChild = prev;
child->setPreviousSibling(0);
child->setNextSibling(0);
child->setParent(0);
allowEventDispatch();
childrenChanged(false, prev, next, -1);
dispatchSubtreeModifiedEvent();
if (child->inDocument())
child->removedFromDocument();
else
child->removedFromTree(true);
return child;
}
bool ContainerNode::removeChildren()
{
if (!m_firstChild)
return false;
RefPtr<Node> protect(this);
for (RefPtr<Node> n = m_firstChild; n; n = n->nextSibling())
willRemoveChild(n.get());
document()->removeFocusedNodeOfSubtree(this, true);
forbidEventDispatch();
int childCountDelta = 0;
while (RefPtr<Node> n = m_firstChild) {
childCountDelta--;
Node* next = n->nextSibling();
n->setPreviousSibling(0);
n->setNextSibling(0);
n->setParent(0);
m_firstChild = next;
if (n == m_lastChild)
m_lastChild = 0;
if (n->attached())
n->detach();
if (n->inDocument())
n->removedFromDocument();
}
allowEventDispatch();
childrenChanged(false, 0, 0, childCountDelta);
dispatchSubtreeModifiedEvent();
return true;
}
bool ContainerNode::appendChild(PassRefPtr<Node> newChild, ExceptionCode& ec, bool shouldLazyAttach)
{
ASSERT(refCount() || parent());
ec = 0;
checkAddChild(newChild.get(), ec);
if (ec)
return 0;
if (newChild == m_lastChild) return newChild;
bool isFragment = newChild->nodeType() == DOCUMENT_FRAGMENT_NODE;
if (isFragment && !newChild->firstChild())
return true;
RefPtr<Node> prev = lastChild();
RefPtr<Node> child = isFragment ? newChild->firstChild() : newChild;
while (child) {
RefPtr<Node> nextChild = isFragment ? child->nextSibling() : 0;
if (Node* oldParent = child->parentNode()) {
oldParent->removeChild(child.get(), ec);
if (ec)
return 0;
if (child->parentNode())
break;
}
forbidEventDispatch();
child->setParent(this);
if (m_lastChild) {
child->setPreviousSibling(m_lastChild);
m_lastChild->setNextSibling(child.get());
} else
m_firstChild = child.get();
m_lastChild = child.get();
allowEventDispatch();
childrenChanged(false, prev.get(), 0, 1);
dispatchChildInsertionEvents(child.get(), ec);
if (attached() && !child->attached() && child->parent() == this) {
if (shouldLazyAttach)
child->lazyAttach();
else
child->attach();
}
child = nextChild.release();
}
dispatchSubtreeModifiedEvent();
return true;
}
ContainerNode* ContainerNode::addChild(PassRefPtr<Node> newChild)
{
ASSERT(newChild);
if (document()->isHTMLDocument() && !childAllowed(newChild.get()))
return 0;
forbidEventDispatch();
Node* last = m_lastChild;
appendChildToContainer<Node, ContainerNode>(newChild.get(), this);
allowEventDispatch();
document()->incDOMTreeVersion();
if (inDocument())
newChild->insertedIntoDocument();
childrenChanged(true, last, 0, 1);
if (newChild->isElementNode())
return static_cast<ContainerNode*>(newChild.get());
return this;
}
void ContainerNode::suspendPostAttachCallbacks()
{
if (!s_attachDepth) {
ASSERT(!s_shouldReEnableMemoryCacheCallsAfterAttach);
if (Page* page = document()->page()) {
if (page->areMemoryCacheClientCallsEnabled()) {
page->setMemoryCacheClientCallsEnabled(false);
s_shouldReEnableMemoryCacheCallsAfterAttach = true;
}
}
cache()->loader()->suspendPendingRequests();
}
++s_attachDepth;
}
void ContainerNode::resumePostAttachCallbacks()
{
if (s_attachDepth == 1) {
if (s_postAttachCallbackQueue)
dispatchPostAttachCallbacks();
if (s_shouldReEnableMemoryCacheCallsAfterAttach) {
s_shouldReEnableMemoryCacheCallsAfterAttach = false;
if (Page* page = document()->page())
page->setMemoryCacheClientCallsEnabled(true);
}
cache()->loader()->resumePendingRequests();
}
--s_attachDepth;
}
void ContainerNode::queuePostAttachCallback(NodeCallback callback, Node* node)
{
if (!s_postAttachCallbackQueue)
s_postAttachCallbackQueue = new NodeCallbackQueue;
s_postAttachCallbackQueue->append(std::pair<NodeCallback, RefPtr<Node> >(callback, node));
}
void ContainerNode::dispatchPostAttachCallbacks()
{
for (size_t i = 0; i < s_postAttachCallbackQueue->size(); ++i) {
std::pair<NodeCallback, RefPtr<Node> >& pair = (*s_postAttachCallbackQueue)[i];
NodeCallback callback = pair.first;
Node* node = pair.second.get();
callback(node);
}
s_postAttachCallbackQueue->clear();
}
void ContainerNode::attach()
{
for (Node* child = m_firstChild; child; child = child->nextSibling())
child->attach();
Node::attach();
}
void ContainerNode::detach()
{
for (Node* child = m_firstChild; child; child = child->nextSibling())
child->detach();
setChildNeedsStyleRecalc(false);
Node::detach();
}
void ContainerNode::insertedIntoDocument()
{
Node::insertedIntoDocument();
insertedIntoTree(false);
for (Node* child = m_firstChild; child; child = child->nextSibling())
child->insertedIntoDocument();
}
void ContainerNode::removedFromDocument()
{
Node::removedFromDocument();
if (document()->cssTarget() == this)
document()->setCSSTarget(0);
setInDocument(false);
removedFromTree(false);
for (Node* child = m_firstChild; child; child = child->nextSibling())
child->removedFromDocument();
}
void ContainerNode::insertedIntoTree(bool deep)
{
if (!deep)
return;
for (Node* child = m_firstChild; child; child = child->nextSibling())
child->insertedIntoTree(true);
}
void ContainerNode::removedFromTree(bool deep)
{
if (!deep)
return;
for (Node* child = m_firstChild; child; child = child->nextSibling())
child->removedFromTree(true);
}
void ContainerNode::childrenChanged(bool changedByParser, Node* beforeChange, Node* afterChange, int childCountDelta)
{
Node::childrenChanged(changedByParser, beforeChange, afterChange, childCountDelta);
if (!changedByParser && childCountDelta)
document()->nodeChildrenChanged(this);
if (document()->hasNodeListCaches())
notifyNodeListsChildrenChanged();
}
void ContainerNode::cloneChildNodes(ContainerNode *clone)
{
if (document()->frame())
document()->frame()->editor()->deleteButtonController()->disable();
ExceptionCode ec = 0;
for (Node* n = firstChild(); n && !ec; n = n->nextSibling())
clone->appendChild(n->cloneNode(true), ec);
if (document()->frame())
document()->frame()->editor()->deleteButtonController()->enable();
}
bool ContainerNode::getUpperLeftCorner(FloatPoint& point) const
{
if (!renderer())
return false;
RenderObject *o = renderer();
RenderObject *p = o;
if (!o->isInline() || o->isReplaced()) {
point = o->localToAbsolute();
return true;
}
while (o) {
p = o;
if (o->firstChild())
o = o->firstChild();
else if (o->nextSibling())
o = o->nextSibling();
else {
RenderObject *next = 0;
while (!next && o->parent()) {
o = o->parent();
next = o->nextSibling();
}
o = next;
if (!o)
break;
}
ASSERT(o);
if (!o->isInline() || o->isReplaced()) {
point = o->localToAbsolute();
return true;
}
if (p->node() && p->node() == this && o->isText() && !o->isBR() && !toRenderText(o)->firstTextBox()) {
} else if ((o->isText() && !o->isBR()) || o->isReplaced()) {
point = o->container()->localToAbsolute();
if (o->isText() && toRenderText(o)->firstTextBox()) {
point.move(toRenderText(o)->linesBoundingBox().x(),
toRenderText(o)->firstTextBox()->root()->topOverflow());
} else if (o->isBox()) {
RenderBox* box = toRenderBox(o);
point.move(box->x(), box->y());
}
return true;
}
}
if (!o && document()->view()) {
point = FloatPoint(0, document()->view()->contentsHeight());
return true;
}
return false;
}
bool ContainerNode::getLowerRightCorner(FloatPoint& point) const
{
if (!renderer())
return false;
RenderObject* o = renderer();
if (!o->isInline() || o->isReplaced()) {
RenderBox* box = toRenderBox(o);
point = o->localToAbsolute();
point.move(box->width(), box->height());
return true;
}
while (o) {
if (o->lastChild())
o = o->lastChild();
else if (o->previousSibling())
o = o->previousSibling();
else {
RenderObject* prev = 0;
while (!prev) {
o = o->parent();
if (!o)
return false;
prev = o->previousSibling();
}
o = prev;
}
ASSERT(o);
if (o->isText() || o->isReplaced()) {
point = o->container()->localToAbsolute();
if (o->isText()) {
RenderText* text = toRenderText(o);
IntRect linesBox = text->linesBoundingBox();
point.move(linesBox.x() + linesBox.width(), linesBox.y() + linesBox.height());
} else {
RenderBox* box = toRenderBox(o);
point.move(box->x() + box->width(), box->y() + box->height());
}
return true;
}
}
return true;
}
IntRect ContainerNode::getRect() const
{
FloatPoint upperLeft, lowerRight;
bool foundUpperLeft = getUpperLeftCorner(upperLeft);
bool foundLowerRight = getLowerRightCorner(lowerRight);
if (foundUpperLeft != foundLowerRight) {
if (foundUpperLeft)
lowerRight = upperLeft;
else
upperLeft = lowerRight;
}
lowerRight.setX(max(upperLeft.x(), lowerRight.x()));
lowerRight.setY(max(upperLeft.y(), lowerRight.y()));
return enclosingIntRect(FloatRect(upperLeft, lowerRight - upperLeft));
}
void ContainerNode::setFocus(bool received)
{
if (focused() == received)
return;
Node::setFocus(received);
setNeedsStyleRecalc();
}
void ContainerNode::setActive(bool down, bool pause)
{
if (down == active()) return;
Node::setActive(down);
if (renderer()) {
bool reactsToPress = renderer()->style()->affectedByActiveRules();
if (reactsToPress)
setNeedsStyleRecalc();
if (renderer() && renderer()->style()->hasAppearance()) {
if (renderer()->theme()->stateChanged(renderer(), PressedState))
reactsToPress = true;
}
if (reactsToPress && pause) {
#ifdef HAVE_FUNC_USLEEP
double startTime = currentTime();
#endif
Document::updateStyleForAllDocuments();
if (renderer())
renderer()->repaint(true);
#ifdef HAVE_FUNC_USLEEP
double remainingTime = 0.1 - (currentTime() - startTime);
if (remainingTime > 0)
usleep(static_cast<useconds_t>(remainingTime * 1000000.0));
#endif
}
}
}
void ContainerNode::setHovered(bool over)
{
if (over == hovered()) return;
Node::setHovered(over);
if (renderer()) {
if (renderer()->style()->affectedByHoverRules())
setNeedsStyleRecalc();
if (renderer() && renderer()->style()->hasAppearance())
renderer()->theme()->stateChanged(renderer(), HoverState);
}
}
unsigned ContainerNode::childNodeCount() const
{
unsigned count = 0;
Node *n;
for (n = firstChild(); n; n = n->nextSibling())
count++;
return count;
}
Node *ContainerNode::childNode(unsigned index) const
{
unsigned i;
Node *n = firstChild();
for (i = 0; n != 0 && i < index; i++)
n = n->nextSibling();
return n;
}
static void dispatchChildInsertionEvents(Node* child, ExceptionCode& ec)
{
ASSERT(!eventDispatchForbidden());
RefPtr<Node> c = child;
DocPtr<Document> doc = child->document();
if (c->parentNode() && c->parentNode()->inDocument())
c->insertedIntoDocument();
else
c->insertedIntoTree(true);
doc->incDOMTreeVersion();
if (c->parentNode() && doc->hasListenerType(Document::DOMNODEINSERTED_LISTENER)) {
ec = 0;
c->dispatchMutationEvent(eventNames().DOMNodeInsertedEvent, true, c->parentNode(), String(), String(), ec);
if (ec)
return;
}
if (c->inDocument() && doc->hasListenerType(Document::DOMNODEINSERTEDINTODOCUMENT_LISTENER))
for (; c; c = c->traverseNextNode(child)) {
ec = 0;
c->dispatchMutationEvent(eventNames().DOMNodeInsertedIntoDocumentEvent, false, 0, String(), String(), ec);
if (ec)
return;
}
}
static void dispatchChildRemovalEvents(Node* child, ExceptionCode& ec)
{
RefPtr<Node> c = child;
DocPtr<Document> doc = child->document();
doc->nodeWillBeRemoved(child);
doc->incDOMTreeVersion();
if (c->parentNode() && doc->hasListenerType(Document::DOMNODEREMOVED_LISTENER)) {
ec = 0;
c->dispatchMutationEvent(eventNames().DOMNodeRemovedEvent, true, c->parentNode(), String(), String(), ec);
if (ec)
return;
}
if (c->inDocument() && doc->hasListenerType(Document::DOMNODEREMOVEDFROMDOCUMENT_LISTENER))
for (; c; c = c->traverseNextNode(child)) {
ec = 0;
c->dispatchMutationEvent(eventNames().DOMNodeRemovedFromDocumentEvent, false, 0, String(), String(), ec);
if (ec)
return;
}
}
}