| /* |
| * Copyright (C) 1999 Lars Knoll (knoll@kde.org) |
| * (C) 1999 Antti Koivisto (koivisto@kde.org) |
| * (C) 2001 Dirk Mueller (mueller@kde.org) |
| * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved. |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Library General Public |
| * License as published by the Free Software Foundation; either |
| * version 2 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Library General Public License for more details. |
| * |
| * You should have received a copy of the GNU Library General Public License |
| * along with this library; see the file COPYING.LIB. If not, write to |
| * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, |
| * Boston, MA 02110-1301, USA. |
| */ |
| |
| #include "config.h" |
| #include "ContainerNode.h" |
| |
| #include "BeforeLoadEvent.h" |
| #include "MemoryCache.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 "InspectorInstrumentation.h" |
| #include "MutationEvent.h" |
| #include "ResourceLoadScheduler.h" |
| #include "Page.h" |
| #include "RenderBox.h" |
| #include "RenderTheme.h" |
| #include "RootInlineBox.h" |
| #include <wtf/CurrentTime.h> |
| #include <wtf/Vector.h> |
| |
| namespace WebCore { |
| |
| static void notifyChildInserted(Node*); |
| static void dispatchChildInsertionEvents(Node*); |
| static void dispatchChildRemovalEvents(Node*); |
| |
| typedef Vector<std::pair<NodeCallback, RefPtr<Node> > > NodeCallbackQueue; |
| typedef Vector<RefPtr<Node>, 1> NodeVector; |
| static NodeCallbackQueue* s_postAttachCallbackQueue; |
| |
| static size_t s_attachDepth; |
| static bool s_shouldReEnableMemoryCacheCallsAfterAttach; |
| |
| static inline void collectNodes(Node* node, NodeVector& nodes) |
| { |
| for (Node* child = node->firstChild(); child; child = child->nextSibling()) |
| nodes.append(child); |
| } |
| |
| static void collectTargetNodes(Node* node, NodeVector& nodes) |
| { |
| if (node->nodeType() != Node::DOCUMENT_FRAGMENT_NODE) { |
| nodes.append(node); |
| return; |
| } |
| collectNodes(node, nodes); |
| } |
| |
| void ContainerNode::removeAllChildren() |
| { |
| removeAllChildrenInContainer<Node, ContainerNode>(this); |
| } |
| |
| void ContainerNode::takeAllChildrenFrom(ContainerNode* oldParent) |
| { |
| NodeVector children; |
| collectNodes(oldParent, children); |
| oldParent->removeAllChildren(); |
| |
| for (unsigned i = 0; i < children.size(); ++i) { |
| ExceptionCode ec = 0; |
| if (children[i]->attached()) |
| children[i]->detach(); |
| // FIXME: We need a no mutation event version of adoptNode. |
| RefPtr<Node> child = document()->adoptNode(children[i].release(), ec); |
| ASSERT(!ec); |
| parserAddChild(child.get()); |
| if (attached() && !child->attached()) |
| child->attach(); |
| } |
| } |
| |
| ContainerNode::~ContainerNode() |
| { |
| removeAllChildren(); |
| } |
| |
| bool ContainerNode::insertBefore(PassRefPtr<Node> newChild, Node* refChild, ExceptionCode& ec, bool shouldLazyAttach) |
| { |
| // Check that this node is not "floating". |
| // If it is, it can be deleted as a side effect of sending mutation events. |
| ASSERT(refCount() || parentOrHostNode()); |
| |
| ec = 0; |
| |
| // insertBefore(node, 0) is equivalent to appendChild(node) |
| if (!refChild) |
| return appendChild(newChild, ec, shouldLazyAttach); |
| |
| // Make sure adding the new child is OK. |
| checkAddChild(newChild.get(), ec); |
| if (ec) |
| return false; |
| |
| // NOT_FOUND_ERR: Raised if refChild is not a child of this node |
| if (refChild->parentNode() != this) { |
| ec = NOT_FOUND_ERR; |
| return false; |
| } |
| |
| NodeVector targets; |
| collectTargetNodes(newChild.get(), targets); |
| if (targets.isEmpty()) |
| return true; |
| |
| // Now actually add the child(ren) |
| if (refChild->previousSibling() == newChild || refChild == newChild) // nothing to do |
| return true; |
| |
| RefPtr<Node> next = refChild; |
| RefPtr<Node> refChildPreviousSibling = refChild->previousSibling(); |
| for (NodeVector::const_iterator it = targets.begin(); it != targets.end(); ++it) { |
| Node* child = it->get(); |
| |
| // If child is already present in the tree, first remove it from the old location. |
| if (ContainerNode* oldParent = child->parentNode()) |
| oldParent->removeChild(child, ec); |
| if (ec) |
| return false; |
| |
| // FIXME: After sending the mutation events, "this" could be destroyed. |
| // We can prevent that by doing a "ref", but first we have to make sure |
| // that no callers call with ref count == 0 and parent = 0 (as of this |
| // writing, there are definitely callers who call that way). |
| |
| // Due to arbitrary code running in response to a DOM mutation event it's |
| // possible that "next" is no longer a child of "this". |
| // It's also possible that "child" has been inserted elsewhere. |
| // In either of those cases, we'll just stop. |
| if (next->parentNode() != this) |
| break; |
| if (child->parentNode()) |
| break; |
| |
| #if ENABLE(INSPECTOR) |
| InspectorInstrumentation::willInsertDOMNode(document(), child, this); |
| #endif |
| |
| child->setTreeScopeRecursively(treeScope()); |
| |
| insertBeforeCommon(next.get(), child); |
| |
| // Send notification about the children change. |
| childrenChanged(false, refChildPreviousSibling.get(), next.get(), 1); |
| notifyChildInserted(child); |
| |
| // Add child to the rendering tree. |
| if (attached() && !child->attached() && child->parentNode() == this) { |
| if (shouldLazyAttach) |
| child->lazyAttach(); |
| else |
| child->attach(); |
| } |
| |
| // Now that the child is attached to the render tree, dispatch |
| // the relevant mutation events. |
| dispatchChildInsertionEvents(child); |
| } |
| |
| dispatchSubtreeModifiedEvent(); |
| return true; |
| } |
| |
| void ContainerNode::insertBeforeCommon(Node* nextChild, Node* newChild) |
| { |
| ASSERT(newChild); |
| ASSERT(!newChild->parentNode()); // Use insertBefore if you need to handle reparenting (and want DOM mutation events). |
| ASSERT(!newChild->nextSibling()); |
| ASSERT(!newChild->previousSibling()); |
| |
| forbidEventDispatch(); |
| Node* prev = nextChild->previousSibling(); |
| ASSERT(m_lastChild != prev); |
| nextChild->setPreviousSibling(newChild); |
| if (prev) { |
| ASSERT(m_firstChild != nextChild); |
| ASSERT(prev->nextSibling() == nextChild); |
| prev->setNextSibling(newChild); |
| } else { |
| ASSERT(m_firstChild == nextChild); |
| m_firstChild = newChild; |
| } |
| newChild->setParent(this); |
| newChild->setPreviousSibling(prev); |
| newChild->setNextSibling(nextChild); |
| allowEventDispatch(); |
| } |
| |
| void ContainerNode::parserInsertBefore(PassRefPtr<Node> newChild, Node* nextChild) |
| { |
| ASSERT(newChild); |
| ASSERT(nextChild); |
| ASSERT(nextChild->parentNode() == this); |
| |
| NodeVector targets; |
| collectTargetNodes(newChild.get(), targets); |
| if (targets.isEmpty()) |
| return; |
| |
| if (nextChild->previousSibling() == newChild || nextChild == newChild) // nothing to do |
| return; |
| |
| RefPtr<Node> next = nextChild; |
| RefPtr<Node> nextChildPreviousSibling = nextChild->previousSibling(); |
| for (NodeVector::const_iterator it = targets.begin(); it != targets.end(); ++it) { |
| Node* child = it->get(); |
| |
| #if ENABLE(INSPECTOR) |
| InspectorInstrumentation::willInsertDOMNode(document(), child, this); |
| #endif |
| |
| insertBeforeCommon(next.get(), child); |
| |
| childrenChanged(true, nextChildPreviousSibling.get(), nextChild, 1); |
| notifyChildInserted(child); |
| } |
| } |
| |
| bool ContainerNode::replaceChild(PassRefPtr<Node> newChild, Node* oldChild, ExceptionCode& ec, bool shouldLazyAttach) |
| { |
| // Check that this node is not "floating". |
| // If it is, it can be deleted as a side effect of sending mutation events. |
| ASSERT(refCount() || parentOrHostNode()); |
| |
| ec = 0; |
| |
| if (oldChild == newChild) // nothing to do |
| return true; |
| |
| // Make sure replacing the old child with the new is ok |
| checkReplaceChild(newChild.get(), oldChild, ec); |
| if (ec) |
| return false; |
| |
| // NOT_FOUND_ERR: Raised if oldChild is not a child of this node. |
| if (!oldChild || oldChild->parentNode() != this) { |
| ec = NOT_FOUND_ERR; |
| return false; |
| } |
| |
| RefPtr<Node> prev = oldChild->previousSibling(); |
| RefPtr<Node> next = oldChild->nextSibling(); |
| |
| // Remove the node we're replacing |
| RefPtr<Node> removedChild = oldChild; |
| removeChild(oldChild, ec); |
| if (ec) |
| return false; |
| |
| // FIXME: After sending the mutation events, "this" could be destroyed. |
| // We can prevent that by doing a "ref", but first we have to make sure |
| // that no callers call with ref count == 0 and parent = 0 (as of this |
| // writing, there are definitely callers who call that way). |
| |
| bool isFragment = newChild->nodeType() == DOCUMENT_FRAGMENT_NODE; |
| |
| // Add the new child(ren) |
| RefPtr<Node> child = isFragment ? newChild->firstChild() : newChild; |
| while (child) { |
| // If the new child is already in the right place, we're done. |
| if (prev && (prev == child || prev == child->previousSibling())) |
| break; |
| |
| // For a fragment we have more children to do. |
| RefPtr<Node> nextChild = isFragment ? child->nextSibling() : 0; |
| |
| // Remove child from its old position. |
| if (ContainerNode* oldParent = child->parentNode()) |
| oldParent->removeChild(child.get(), ec); |
| if (ec) |
| return false; |
| |
| // Due to arbitrary code running in response to a DOM mutation event it's |
| // possible that "prev" is no longer a child of "this". |
| // It's also possible that "child" has been inserted elsewhere. |
| // In either of those cases, we'll just stop. |
| if (prev && prev->parentNode() != this) |
| break; |
| if (child->parentNode()) |
| break; |
| |
| ASSERT(!child->nextSibling()); |
| ASSERT(!child->previousSibling()); |
| |
| #if ENABLE(INSPECTOR) |
| InspectorInstrumentation::willInsertDOMNode(document(), child.get(), this); |
| #endif |
| |
| child->setTreeScopeRecursively(treeScope()); |
| |
| // Add child after "prev". |
| 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(); |
| |
| childrenChanged(false, prev.get(), next, 1); |
| notifyChildInserted(child.get()); |
| |
| // Add child to the rendering tree |
| if (attached() && !child->attached() && child->parentNode() == this) { |
| if (shouldLazyAttach) |
| child->lazyAttach(); |
| else |
| child->attach(); |
| } |
| |
| // Now that the child is attached to the render tree, dispatch |
| // the relevant mutation events. |
| dispatchChildInsertionEvents(child.get()); |
| |
| prev = child; |
| child = nextChild.release(); |
| } |
| |
| dispatchSubtreeModifiedEvent(); |
| return true; |
| } |
| |
| void ContainerNode::willRemove() |
| { |
| Vector<RefPtr<Node>, 10> nodes; |
| nodes.reserveInitialCapacity(childNodeCount()); |
| for (Node* n = m_lastChild; n; n = n->previousSibling()) |
| nodes.append(n); |
| for (; nodes.size(); nodes.removeLast()) |
| nodes.last().get()->willRemove(); |
| Node::willRemove(); |
| } |
| |
| static void willRemoveChild(Node* child) |
| { |
| // update auxiliary doc info (e.g. iterators) to note that node is being removed |
| child->document()->nodeWillBeRemoved(child); |
| child->document()->incDOMTreeVersion(); |
| |
| // fire removed from document mutation events. |
| dispatchChildRemovalEvents(child); |
| child->willRemove(); |
| } |
| |
| static void willRemoveChildren(ContainerNode* container) |
| { |
| container->document()->nodeChildrenWillBeRemoved(container); |
| container->document()->incDOMTreeVersion(); |
| |
| NodeVector children; |
| collectNodes(container, children); |
| |
| for (NodeVector::const_iterator it = children.begin(); it != children.end(); it++) { |
| Node* child = it->get(); |
| // fire removed from document mutation events. |
| dispatchChildRemovalEvents(child); |
| child->willRemove(); |
| } |
| } |
| |
| bool ContainerNode::removeChild(Node* oldChild, ExceptionCode& ec) |
| { |
| // Check that this node is not "floating". |
| // If it is, it can be deleted as a side effect of sending mutation events. |
| ASSERT(refCount() || parentOrHostNode()); |
| |
| ec = 0; |
| |
| // NO_MODIFICATION_ALLOWED_ERR: Raised if this node is readonly. |
| if (isReadOnlyNode()) { |
| ec = NO_MODIFICATION_ALLOWED_ERR; |
| return false; |
| } |
| |
| // NOT_FOUND_ERR: Raised if oldChild is not a child of this node. |
| if (!oldChild || oldChild->parentNode() != this) { |
| ec = NOT_FOUND_ERR; |
| return false; |
| } |
| |
| RefPtr<Node> child = oldChild; |
| willRemoveChild(child.get()); |
| |
| // Mutation events might have moved this child into a different parent. |
| if (child->parentNode() != this) { |
| ec = NOT_FOUND_ERR; |
| return false; |
| } |
| |
| document()->removeFocusedNodeOfSubtree(child.get()); |
| |
| // Events fired when blurring currently focused node might have moved this |
| // child into a different parent. |
| if (child->parentNode() != this) { |
| ec = NOT_FOUND_ERR; |
| return false; |
| } |
| |
| // FIXME: After sending the mutation events, "this" could be destroyed. |
| // We can prevent that by doing a "ref", but first we have to make sure |
| // that no callers call with ref count == 0 and parent = 0 (as of this |
| // writing, there are definitely callers who call that way). |
| |
| Node* prev = child->previousSibling(); |
| Node* next = child->nextSibling(); |
| removeBetween(prev, next, child.get()); |
| |
| // Dispatch post-removal mutation events |
| childrenChanged(false, prev, next, -1); |
| dispatchSubtreeModifiedEvent(); |
| |
| if (child->inDocument()) |
| child->removedFromDocument(); |
| else |
| child->removedFromTree(true); |
| |
| return child; |
| } |
| |
| void ContainerNode::removeBetween(Node* previousChild, Node* nextChild, Node* oldChild) |
| { |
| ASSERT(oldChild); |
| ASSERT(oldChild->parentNode() == this); |
| |
| forbidEventDispatch(); |
| |
| // Remove from rendering tree |
| if (oldChild->attached()) |
| oldChild->detach(); |
| |
| if (nextChild) |
| nextChild->setPreviousSibling(previousChild); |
| if (previousChild) |
| previousChild->setNextSibling(nextChild); |
| if (m_firstChild == oldChild) |
| m_firstChild = nextChild; |
| if (m_lastChild == oldChild) |
| m_lastChild = previousChild; |
| |
| oldChild->setPreviousSibling(0); |
| oldChild->setNextSibling(0); |
| oldChild->setParent(0); |
| |
| allowEventDispatch(); |
| } |
| |
| void ContainerNode::parserRemoveChild(Node* oldChild) |
| { |
| ASSERT(oldChild); |
| ASSERT(oldChild->parentNode() == this); |
| |
| Node* prev = oldChild->previousSibling(); |
| Node* next = oldChild->nextSibling(); |
| |
| removeBetween(prev, next, oldChild); |
| |
| childrenChanged(true, prev, next, -1); |
| if (oldChild->inDocument()) |
| oldChild->removedFromDocument(); |
| else |
| oldChild->removedFromTree(true); |
| } |
| |
| // this differs from other remove functions because it forcibly removes all the children, |
| // regardless of read-only status or event exceptions, e.g. |
| void ContainerNode::removeChildren() |
| { |
| if (!m_firstChild) |
| return; |
| |
| // The container node can be removed from event handlers. |
| RefPtr<ContainerNode> protect(this); |
| |
| // Do any prep work needed before actually starting to detach |
| // and remove... e.g. stop loading frames, fire unload events. |
| willRemoveChildren(protect.get()); |
| |
| // exclude this node when looking for removed focusedNode since only children will be removed |
| document()->removeFocusedNodeOfSubtree(this, true); |
| |
| forbidEventDispatch(); |
| Vector<RefPtr<Node>, 10> removedChildren; |
| removedChildren.reserveInitialCapacity(childNodeCount()); |
| while (RefPtr<Node> n = m_firstChild) { |
| Node* next = n->nextSibling(); |
| |
| // Remove the node from the tree before calling detach or removedFromDocument (4427024, 4129744). |
| // removeChild() does this after calling detach(). There is no explanation for |
| // this discrepancy between removeChild() and its optimized version removeChildren(). |
| n->setPreviousSibling(0); |
| n->setNextSibling(0); |
| n->setParent(0); |
| |
| m_firstChild = next; |
| if (n == m_lastChild) |
| m_lastChild = 0; |
| removedChildren.append(n.release()); |
| } |
| |
| size_t removedChildrenCount = removedChildren.size(); |
| size_t i; |
| |
| // Detach the nodes only after properly removed from the tree because |
| // a. detaching requires a proper DOM tree (for counters and quotes for |
| // example) and during the previous loop the next sibling still points to |
| // the node being removed while the node being removed does not point back |
| // and does not point to the same parent as its next sibling. |
| // b. destroying Renderers of standalone nodes is sometimes faster. |
| for (i = 0; i < removedChildrenCount; ++i) { |
| Node* removedChild = removedChildren[i].get(); |
| if (removedChild->attached()) |
| removedChild->detach(); |
| } |
| |
| allowEventDispatch(); |
| |
| // Dispatch a single post-removal mutation event denoting a modified subtree. |
| childrenChanged(false, 0, 0, -static_cast<int>(removedChildrenCount)); |
| dispatchSubtreeModifiedEvent(); |
| |
| for (i = 0; i < removedChildrenCount; ++i) { |
| Node* removedChild = removedChildren[i].get(); |
| if (removedChild->inDocument()) |
| removedChild->removedFromDocument(); |
| // removeChild() calls removedFromTree(true) if the child was not in the |
| // document. There is no explanation for this discrepancy between removeChild() |
| // and its optimized version removeChildren(). |
| } |
| } |
| |
| bool ContainerNode::appendChild(PassRefPtr<Node> newChild, ExceptionCode& ec, bool shouldLazyAttach) |
| { |
| // Check that this node is not "floating". |
| // If it is, it can be deleted as a side effect of sending mutation events. |
| ASSERT(refCount() || parentOrHostNode()); |
| |
| ec = 0; |
| |
| // Make sure adding the new child is ok |
| checkAddChild(newChild.get(), ec); |
| if (ec) |
| return false; |
| |
| if (newChild == m_lastChild) // nothing to do |
| return newChild; |
| |
| NodeVector targets; |
| collectTargetNodes(newChild.get(), targets); |
| if (targets.isEmpty()) |
| return true; |
| |
| // Now actually add the child(ren) |
| RefPtr<Node> prev = lastChild(); |
| for (NodeVector::const_iterator it = targets.begin(); it != targets.end(); ++it) { |
| Node* child = it->get(); |
| // If child is already present in the tree, first remove it |
| if (ContainerNode* oldParent = child->parentNode()) { |
| oldParent->removeChild(child, ec); |
| if (ec) |
| return false; |
| |
| // If the child has a parent again, just stop what we're doing, because |
| // that means someone is doing something with DOM mutation -- can't re-parent |
| // a child that already has a parent. |
| if (child->parentNode()) |
| break; |
| } |
| |
| #if ENABLE(INSPECTOR) |
| InspectorInstrumentation::willInsertDOMNode(document(), child, this); |
| #endif |
| |
| child->setTreeScopeRecursively(treeScope()); |
| |
| // Append child to the end of the list |
| forbidEventDispatch(); |
| child->setParent(this); |
| if (m_lastChild) { |
| child->setPreviousSibling(m_lastChild); |
| m_lastChild->setNextSibling(child); |
| } else |
| m_firstChild = child; |
| m_lastChild = child; |
| allowEventDispatch(); |
| |
| // Send notification about the children change. |
| childrenChanged(false, prev.get(), 0, 1); |
| notifyChildInserted(child); |
| |
| // Add child to the rendering tree |
| if (attached() && !child->attached() && child->parentNode() == this) { |
| if (shouldLazyAttach) |
| child->lazyAttach(); |
| else |
| child->attach(); |
| } |
| |
| // Now that the child is attached to the render tree, dispatch |
| // the relevant mutation events. |
| dispatchChildInsertionEvents(child); |
| prev = child; |
| } |
| |
| dispatchSubtreeModifiedEvent(); |
| return true; |
| } |
| |
| void ContainerNode::parserAddChild(PassRefPtr<Node> newChild) |
| { |
| ASSERT(newChild); |
| ASSERT(!newChild->parentNode()); // Use appendChild if you need to handle reparenting (and want DOM mutation events). |
| |
| #if ENABLE(INSPECTOR) |
| InspectorInstrumentation::willInsertDOMNode(document(), newChild.get(), this); |
| #endif |
| |
| forbidEventDispatch(); |
| Node* last = m_lastChild; |
| // FIXME: This method should take a PassRefPtr. |
| appendChildToContainer<Node, ContainerNode>(newChild.get(), this); |
| allowEventDispatch(); |
| |
| // FIXME: Why doesn't this use notifyChildInserted(newChild) instead? |
| document()->incDOMTreeVersion(); |
| if (inDocument()) |
| newChild->insertedIntoDocument(); |
| childrenChanged(true, last, 0, 1); |
| } |
| |
| void ContainerNode::deprecatedParserAddChild(PassRefPtr<Node> node) |
| { |
| parserAddChild(node); |
| } |
| |
| void ContainerNode::suspendPostAttachCallbacks() |
| { |
| if (!s_attachDepth) { |
| ASSERT(!s_shouldReEnableMemoryCacheCallsAfterAttach); |
| if (Page* page = document()->page()) { |
| if (page->areMemoryCacheClientCallsEnabled()) { |
| page->setMemoryCacheClientCallsEnabled(false); |
| s_shouldReEnableMemoryCacheCallsAfterAttach = true; |
| } |
| } |
| resourceLoadScheduler()->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); |
| } |
| resourceLoadScheduler()->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)); |
| } |
| |
| bool ContainerNode::postAttachCallbacksAreSuspended() |
| { |
| return s_attachDepth; |
| } |
| |
| void ContainerNode::dispatchPostAttachCallbacks() |
| { |
| // We recalculate size() each time through the loop because a callback |
| // can add more callbacks to the end of the queue. |
| 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(); |
| clearChildNeedsStyleRecalc(); |
| Node::detach(); |
| } |
| |
| void ContainerNode::insertedIntoDocument() |
| { |
| Node::insertedIntoDocument(); |
| insertedIntoTree(false); |
| |
| // Determine set of children before operating on any of them. |
| NodeVector children; |
| collectNodes(this, children); |
| |
| NodeVector::iterator it; |
| for (it = children.begin(); it != children.end() && inDocument(); ++it) { |
| Node* child = it->get(); |
| child->insertedIntoDocument(); |
| } |
| } |
| |
| void ContainerNode::removedFromDocument() |
| { |
| Node::removedFromDocument(); |
| if (document()->cssTarget() == this) |
| document()->setCSSTarget(0); |
| clearInDocument(); |
| 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) |
| { |
| // disable the delete button so it's elements are not serialized into the markup |
| bool isEditorEnabled = false; |
| if (document()->frame() && document()->frame()->editor()->canEdit()) { |
| SelectionController* selection = document()->frame()->selection(); |
| Element* root = selection ? selection->rootEditableElement() : 0; |
| isEditorEnabled = root && isDescendantOf(root); |
| |
| if (isEditorEnabled) |
| document()->frame()->editor()->deleteButtonController()->disable(); |
| } |
| |
| ExceptionCode ec = 0; |
| for (Node* n = firstChild(); n && !ec; n = n->nextSibling()) |
| clone->appendChild(n->cloneNode(true), ec); |
| if (isEditorEnabled && document()->frame()) |
| document()->frame()->editor()->deleteButtonController()->enable(); |
| } |
| |
| bool ContainerNode::getUpperLeftCorner(FloatPoint& point) const |
| { |
| if (!renderer()) |
| return false; |
| // What is this code really trying to do? |
| RenderObject *o = renderer(); |
| RenderObject *p = o; |
| |
| if (!o->isInline() || o->isReplaced()) { |
| point = o->localToAbsolute(FloatPoint(), false, true); |
| return true; |
| } |
| |
| // find the next text/image child, to get a position |
| 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(FloatPoint(), false, true); |
| return true; |
| } |
| |
| if (p->node() && p->node() == this && o->isText() && !o->isBR() && !toRenderText(o)->firstTextBox()) { |
| // do nothing - skip unrendered whitespace that is a child or next sibling of the anchor |
| } else if ((o->isText() && !o->isBR()) || o->isReplaced()) { |
| point = FloatPoint(); |
| if (o->isText() && toRenderText(o)->firstTextBox()) { |
| point.move(toRenderText(o)->linesBoundingBox().x(), |
| toRenderText(o)->firstTextBox()->root()->lineTop()); |
| } else if (o->isBox()) { |
| RenderBox* box = toRenderBox(o); |
| point.move(box->x(), box->y()); |
| } |
| point = o->container()->localToAbsolute(point, false, true); |
| return true; |
| } |
| } |
| |
| // If the target doesn't have any children or siblings that could be used to calculate the scroll position, we must be |
| // at the end of the document. Scroll to the bottom. FIXME: who said anything about scrolling? |
| if (!o && document()->view()) { |
| point = FloatPoint(0, document()->view()->contentsHeight()); |
| return true; |
| } |
| return false; |
| } |
| |
| // FIXME: This doesn't work correctly with transforms. |
| 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(FloatPoint(), false, true); |
| point.move(box->width(), box->height()); |
| return true; |
| } |
| |
| // find the last text/image child, to get a position |
| 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 = FloatPoint(); |
| if (o->isText()) { |
| RenderText* text = toRenderText(o); |
| IntRect linesBox = text->linesBoundingBox(); |
| if (!linesBox.x() && !linesBox.width() && !linesBox.y() && !linesBox.height()) |
| continue; |
| 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()); |
| } |
| point = o->container()->localToAbsolute(point, false, true); |
| return true; |
| } |
| } |
| return true; |
| } |
| |
| IntRect ContainerNode::getRect() const |
| { |
| FloatPoint upperLeft, lowerRight; |
| bool foundUpperLeft = getUpperLeftCorner(upperLeft); |
| bool foundLowerRight = getLowerRightCorner(lowerRight); |
| |
| // If we've found one corner, but not the other, |
| // then we should just return a point at the corner that we did find. |
| 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); |
| |
| // note that we need to recalc the style |
| setNeedsStyleRecalc(); |
| } |
| |
| void ContainerNode::setActive(bool down, bool pause) |
| { |
| if (down == active()) return; |
| |
| Node::setActive(down); |
| |
| // note that we need to recalc the style |
| // FIXME: Move to Element |
| 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) { |
| // The delay here is subtle. It relies on an assumption, namely that the amount of time it takes |
| // to repaint the "down" state of the control is about the same time as it would take to repaint the |
| // "up" state. Once you assume this, you can just delay for 100ms - that time (assuming that after you |
| // leave this method, it will be about that long before the flush of the up state happens again). |
| #ifdef HAVE_FUNC_USLEEP |
| double startTime = currentTime(); |
| #endif |
| |
| // Ensure there are no pending changes |
| Document::updateStyleForAllDocuments(); |
| // Do an immediate repaint. |
| if (renderer()) |
| renderer()->repaint(true); |
| |
| // FIXME: Find a substitute for usleep for Win32. |
| // Better yet, come up with a way of doing this that doesn't use this sort of thing at all. |
| #ifdef HAVE_FUNC_USLEEP |
| // Now pause for a small amount of time (1/10th of a second from before we repainted in the pressed state) |
| 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); |
| |
| // note that we need to recalc the style |
| // FIXME: Move to Element |
| 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 notifyChildInserted(Node* child) |
| { |
| ASSERT(!eventDispatchForbidden()); |
| |
| #if ENABLE(INSPECTOR) |
| InspectorInstrumentation::didInsertDOMNode(child->document(), child); |
| #endif |
| |
| RefPtr<Node> c = child; |
| RefPtr<Document> document = child->document(); |
| |
| Node* parentOrHostNode = c->parentOrHostNode(); |
| if (parentOrHostNode && parentOrHostNode->inDocument()) |
| c->insertedIntoDocument(); |
| else |
| c->insertedIntoTree(true); |
| |
| document->incDOMTreeVersion(); |
| } |
| |
| static void dispatchChildInsertionEvents(Node* child) |
| { |
| ASSERT(!eventDispatchForbidden()); |
| |
| RefPtr<Node> c = child; |
| RefPtr<Document> document = child->document(); |
| |
| if (c->parentNode() && document->hasListenerType(Document::DOMNODEINSERTED_LISTENER)) |
| c->dispatchScopedEvent(MutationEvent::create(eventNames().DOMNodeInsertedEvent, true, c->parentNode())); |
| |
| // dispatch the DOMNodeInsertedIntoDocument event to all descendants |
| if (c->inDocument() && document->hasListenerType(Document::DOMNODEINSERTEDINTODOCUMENT_LISTENER)) { |
| for (; c; c = c->traverseNextNode(child)) |
| c->dispatchScopedEvent(MutationEvent::create(eventNames().DOMNodeInsertedIntoDocumentEvent, false)); |
| } |
| } |
| |
| static void dispatchChildRemovalEvents(Node* child) |
| { |
| ASSERT(!eventDispatchForbidden()); |
| |
| #if ENABLE(INSPECTOR) |
| InspectorInstrumentation::willRemoveDOMNode(child->document(), child); |
| #endif |
| |
| RefPtr<Node> c = child; |
| RefPtr<Document> document = child->document(); |
| |
| // dispatch pre-removal mutation events |
| if (c->parentNode() && document->hasListenerType(Document::DOMNODEREMOVED_LISTENER)) |
| c->dispatchScopedEvent(MutationEvent::create(eventNames().DOMNodeRemovedEvent, true, c->parentNode())); |
| |
| // dispatch the DOMNodeRemovedFromDocument event to all descendants |
| if (c->inDocument() && document->hasListenerType(Document::DOMNODEREMOVEDFROMDOCUMENT_LISTENER)) { |
| for (; c; c = c->traverseNextNode(child)) |
| c->dispatchScopedEvent(MutationEvent::create(eventNames().DOMNodeRemovedFromDocumentEvent, false)); |
| } |
| } |
| |
| bool ContainerNode::dispatchBeforeLoadEvent(const String& sourceURL) |
| { |
| if (!document()->hasListenerType(Document::BEFORELOAD_LISTENER)) |
| return true; |
| |
| RefPtr<ContainerNode> protector(this); |
| RefPtr<BeforeLoadEvent> beforeLoadEvent = BeforeLoadEvent::create(sourceURL); |
| dispatchEvent(beforeLoadEvent.get()); |
| return !beforeLoadEvent->defaultPrevented(); |
| } |
| |
| } // namespace WebCore |
