Source/WebCore/dom/ContainerNode.h

   1 /*
   2  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
   3  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
   4  *           (C) 2001 Dirk Mueller (mueller@kde.org)
   5  * Copyright (C) 2004, 2005, 2006, 2007, 2009, 2010, 2011 Apple Inc. All rights reserved.
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public License
  18  * along with this library; see the file COPYING.LIB.  If not, write to
  19  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  20  * Boston, MA 02110-1301, USA.
  21  *
  22  */
  23
  24 #ifndef ContainerNode_h
  25 #define ContainerNode_h
  26
  27 #include "ExceptionCodePlaceholder.h"
  28 #include "Node.h"
  29
  30 namespace WebCore {
  31
  32 class FloatPoint;
  33
  34 typedef void (*NodeCallback)(Node*, unsigned);
  35
  36 namespace Private {
  37     template<class GenericNode, class GenericNodeContainer>
  38     void addChildNodesToDeletionQueue(GenericNode*& head, GenericNode*& tail, GenericNodeContainer*);
  39 };
  40
  41 class ContainerNode : public Node {
  42 public:
  43     virtual ~ContainerNode();
  44
  45     Node* firstChild() const { return m_firstChild; }
  46     Node* lastChild() const { return m_lastChild; }
  47     bool hasChildNodes() const { return m_firstChild; }
  48
  49     unsigned childNodeCount() const;
  50     Node* childNode(unsigned index) const;
  51
  52     bool insertBefore(PassRefPtr<Node> newChild, Node* refChild, ExceptionCode& = ASSERT_NO_EXCEPTION, bool shouldLazyAttach = false);
  53     bool replaceChild(PassRefPtr<Node> newChild, Node* oldChild, ExceptionCode& = ASSERT_NO_EXCEPTION, bool shouldLazyAttach = false);
  54     bool removeChild(Node* child, ExceptionCode& = ASSERT_NO_EXCEPTION);
  55     bool appendChild(PassRefPtr<Node> newChild, ExceptionCode& = ASSERT_NO_EXCEPTION, bool shouldLazyAttach = false);
  56
  57     // These methods are only used during parsing.
  58     // They don't send DOM mutation events or handle reparenting.
  59     // However, arbitrary code may be run by beforeload handlers.
  60     void parserAddChild(PassRefPtr<Node>);
  61     void parserRemoveChild(Node*);
  62     void parserInsertBefore(PassRefPtr<Node> newChild, Node* refChild);
  63
  64     // FIXME: It's not good to have two functions with such similar names, especially public functions.
  65     // How do removeChildren and removeAllChildren differ?
  66     void removeChildren();
  67     void removeAllChildren();
  68
  69     void takeAllChildrenFrom(ContainerNode*);
  70
  71     void cloneChildNodes(ContainerNode* clone);
  72
  73     virtual void attach() OVERRIDE;
  74     virtual void detach() OVERRIDE;
  75     virtual LayoutRect getRect() const OVERRIDE;
  76     virtual void setFocus(bool = true) OVERRIDE;
  77     virtual void setActive(bool active = true, bool pause = false) OVERRIDE;
  78     virtual void setHovered(bool = true) OVERRIDE;
  79     virtual void scheduleSetNeedsStyleRecalc(StyleChangeType = FullStyleChange) OVERRIDE;
  80
  81     // -----------------------------------------------------------------------------
  82     // Notification of document structure changes (see Node.h for more notification methods)
  83
  84     // Notifies the node that it's list of children have changed (either by adding or removing child nodes), or a child
  85     // node that is of the type CDATA_SECTION_NODE, TEXT_NODE or COMMENT_NODE has changed its value.
  86     virtual void childrenChanged(bool createdByParser = false, Node* beforeChange = 0, Node* afterChange = 0, int childCountDelta = 0);
  87
  88     void attachAsNode();
  89     void attachChildren();
  90     void attachChildrenIfNeeded();
  91     void attachChildrenLazily();
  92     void detachAsNode();
  93     void detachChildren();
  94     void detachChildrenIfNeeded();
  95
  96     void disconnectDescendantFrames();
  97
  98     // More efficient versions of these two functions for the case where we are starting with a ContainerNode.
  99     Node* traverseNextNode() const;
 100     Node* traverseNextNode(const Node* stayWithin) const;
 101
 102     virtual void reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
 103     {
 104         MemoryClassInfo<ContainerNode> info(memoryObjectInfo, this, MemoryInstrumentation::DOM);
 105         info.visitBaseClass<Node>(this);
 106         info.addInstrumentedMember(m_firstChild);
 107         info.addInstrumentedMember(m_lastChild);
 108     }
 109
 110 protected:
 111     ContainerNode(Document*, ConstructionType = CreateContainer);
 112
 113     static void queuePostAttachCallback(NodeCallback, Node*, unsigned = 0);
 114     static bool postAttachCallbacksAreSuspended();
 115     void suspendPostAttachCallbacks();
 116     void resumePostAttachCallbacks();
 117
 118     template<class GenericNode, class GenericNodeContainer>
 119     friend void appendChildToContainer(GenericNode* child, GenericNodeContainer*);
 120
 121     template<class GenericNode, class GenericNodeContainer>
 122     friend void Private::addChildNodesToDeletionQueue(GenericNode*& head, GenericNode*& tail, GenericNodeContainer*);
 123
 124     void setFirstChild(Node* child) { m_firstChild = child; }
 125     void setLastChild(Node* child) { m_lastChild = child; }
 126
 127 private:
 128     void removeBetween(Node* previousChild, Node* nextChild, Node* oldChild);
 129     void insertBeforeCommon(Node* nextChild, Node* oldChild);
 130
 131     static void dispatchPostAttachCallbacks();
 132
 133     bool getUpperLeftCorner(FloatPoint&) const;
 134     bool getLowerRightCorner(FloatPoint&) const;
 135
 136     Node* m_firstChild;
 137     Node* m_lastChild;
 138 };
 139
 140 inline ContainerNode* toContainerNode(Node* node)
 141 {
 142     ASSERT(!node || node->isContainerNode());
 143     return static_cast<ContainerNode*>(node);
 144 }
 145
 146 inline const ContainerNode* toContainerNode(const Node* node)
 147 {
 148     ASSERT(!node || node->isContainerNode());
 149     return static_cast<const ContainerNode*>(node);
 150 }
 151
 152 // This will catch anyone doing an unnecessary cast.
 153 void toContainerNode(const ContainerNode*);
 154
 155 inline ContainerNode::ContainerNode(Document* document, ConstructionType type)
 156     : Node(document, type)
 157     , m_firstChild(0)
 158     , m_lastChild(0)
 159 {
 160 }
 161
 162 inline void ContainerNode::attachAsNode()
 163 {
 164     Node::attach();
 165 }
 166
 167 inline void ContainerNode::attachChildren()
 168 {
 169     for (Node* child = firstChild(); child; child = child->nextSibling())
 170         child->attach();
 171 }
 172
 173 inline void ContainerNode::attachChildrenIfNeeded()
 174 {
 175     for (Node* child = firstChild(); child; child = child->nextSibling()) {
 176         if (!child->attached())
 177             child->attach();
 178     }
 179 }
 180
 181 inline void ContainerNode::attachChildrenLazily()
 182 {
 183     for (Node* child = firstChild(); child; child = child->nextSibling())
 184         if (!child->attached())
 185             child->lazyAttach();
 186 }
 187
 188 inline void ContainerNode::detachAsNode()
 189 {
 190     Node::detach();
 191 }
 192
 193 inline void ContainerNode::detachChildrenIfNeeded()
 194 {
 195     for (Node* child = firstChild(); child; child = child->nextSibling()) {
 196         if (child->attached())
 197             child->detach();
 198     }
 199 }
 200
 201 inline void ContainerNode::detachChildren()
 202 {
 203     for (Node* child = firstChild(); child; child = child->nextSibling())
 204         child->detach();
 205 }
 206
 207 inline unsigned Node::childNodeCount() const
 208 {
 209     if (!isContainerNode())
 210         return 0;
 211     return toContainerNode(this)->childNodeCount();
 212 }
 213
 214 inline Node* Node::childNode(unsigned index) const
 215 {
 216     if (!isContainerNode())
 217         return 0;
 218     return toContainerNode(this)->childNode(index);
 219 }
 220
 221 inline Node* Node::firstChild() const
 222 {
 223     if (!isContainerNode())
 224         return 0;
 225     return toContainerNode(this)->firstChild();
 226 }
 227
 228 inline Node* Node::lastChild() const
 229 {
 230     if (!isContainerNode())
 231         return 0;
 232     return toContainerNode(this)->lastChild();
 233 }
 234
 235 inline Node* Node::highestAncestor() const
 236 {
 237     Node* node = const_cast<Node*>(this);
 238     Node* highest = node;
 239     for (; node; node = node->parentNode())
 240         highest = node;
 241     return highest;
 242 }
 243
 244 inline Node* Node::traverseNextSibling() const
 245 {
 246     if (nextSibling())
 247         return nextSibling();
 248     return traverseNextAncestorSibling();
 249 }
 250
 251 inline Node* Node::traverseNextNode() const
 252 {
 253     if (firstChild())
 254         return firstChild();
 255     return traverseNextSibling();
 256 }
 257
 258 inline Node* ContainerNode::traverseNextNode() const
 259 {
 260     // More efficient than the Node::traverseNextNode above, because
 261     // this does not need to do the isContainerNode check inside firstChild.
 262     if (firstChild())
 263         return firstChild();
 264     return traverseNextSibling();
 265 }
 266
 267 inline Node* Node::traverseNextSibling(const Node* stayWithin) const
 268 {
 269     if (this == stayWithin)
 270         return 0;
 271     if (nextSibling())
 272         return nextSibling();
 273     return traverseNextAncestorSibling(stayWithin);
 274 }
 275
 276 inline Node* Node::traverseNextNode(const Node* stayWithin) const
 277 {
 278     if (firstChild())
 279         return firstChild();
 280     return traverseNextSibling(stayWithin);
 281 }
 282
 283 inline Node* ContainerNode::traverseNextNode(const Node* stayWithin) const
 284 {
 285     // More efficient than the Node::traverseNextNode above, because
 286     // this does not need to do the isContainerNode check inside firstChild.
 287     if (firstChild())
 288         return firstChild();
 289     return traverseNextSibling(stayWithin);
 290 }
 291
 292 typedef Vector<RefPtr<Node>, 11> NodeVector;
 293
 294 inline void getChildNodes(Node* node, NodeVector& nodes)
 295 {
 296     ASSERT(!nodes.size());
 297     for (Node* child = node->firstChild(); child; child = child->nextSibling())
 298         nodes.append(child);
 299 }
 300
 301 } // namespace WebCore
 302
 303 #endif // ContainerNode_h