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 void willRemove() OVERRIDE;
  76     virtual LayoutRect getRect() const OVERRIDE;
  77     virtual void setFocus(bool = true) OVERRIDE;
  78     virtual void setActive(bool active = true, bool pause = false) OVERRIDE;
  79     virtual void setHovered(bool = true) OVERRIDE;
  80     virtual void insertedIntoDocument() OVERRIDE;
  81     virtual void removedFromDocument() OVERRIDE;
  82     virtual void scheduleSetNeedsStyleRecalc(StyleChangeType = FullStyleChange) OVERRIDE;
  83
  84     // -----------------------------------------------------------------------------
  85     // Notification of document structure changes (see Node.h for more notification methods)
  86
  87     // These functions are called whenever you are connected or disconnected from a tree. That tree may be the main
  88     // document tree, or it could be another disconnected tree. Override these functions to do any work that depends
  89     // on connectedness to some ancestor (e.g., an ancestor <form>).
  90     virtual void insertedIntoTree(bool deep);
  91     virtual void removedFromTree(bool deep);
  92
  93     // Notifies the node that it's list of children have changed (either by adding or removing child nodes), or a child
  94     // node that is of the type CDATA_SECTION_NODE, TEXT_NODE or COMMENT_NODE has changed its value.
  95     virtual void childrenChanged(bool createdByParser = false, Node* beforeChange = 0, Node* afterChange = 0, int childCountDelta = 0);
  96
  97     void attachAsNode();
  98     void attachChildren();
  99     void attachChildrenIfNeeded();
 100     void attachChildrenLazily();
 101     void detachAsNode();
 102     void detachChildren();
 103     void detachChildrenIfNeeded();
 104
 105 protected:
 106     ContainerNode(Document*, ConstructionType = CreateContainer);
 107
 108     static void queuePostAttachCallback(NodeCallback, Node*, unsigned = 0);
 109     static bool postAttachCallbacksAreSuspended();
 110     void suspendPostAttachCallbacks();
 111     void resumePostAttachCallbacks();
 112
 113     template<class GenericNode, class GenericNodeContainer>
 114     friend void appendChildToContainer(GenericNode* child, GenericNodeContainer*);
 115
 116     template<class GenericNode, class GenericNodeContainer>
 117     friend void Private::addChildNodesToDeletionQueue(GenericNode*& head, GenericNode*& tail, GenericNodeContainer*);
 118
 119     void setFirstChild(Node* child) { m_firstChild = child; }
 120     void setLastChild(Node* child) { m_lastChild = child; }
 121
 122 private:
 123     void removeBetween(Node* previousChild, Node* nextChild, Node* oldChild);
 124     void insertBeforeCommon(Node* nextChild, Node* oldChild);
 125
 126     static void dispatchPostAttachCallbacks();
 127
 128     bool getUpperLeftCorner(FloatPoint&) const;
 129     bool getLowerRightCorner(FloatPoint&) const;
 130
 131     Node* m_firstChild;
 132     Node* m_lastChild;
 133 };
 134
 135 inline ContainerNode* toContainerNode(Node* node)
 136 {
 137     ASSERT(!node || node->isContainerNode());
 138     return static_cast<ContainerNode*>(node);
 139 }
 140
 141 inline const ContainerNode* toContainerNode(const Node* node)
 142 {
 143     ASSERT(!node || node->isContainerNode());
 144     return static_cast<const ContainerNode*>(node);
 145 }
 146
 147 // This will catch anyone doing an unnecessary cast.
 148 void toContainerNode(const ContainerNode*);
 149
 150 inline ContainerNode::ContainerNode(Document* document, ConstructionType type)
 151     : Node(document, type)
 152     , m_firstChild(0)
 153     , m_lastChild(0)
 154 {
 155 }
 156
 157 inline void ContainerNode::attachAsNode()
 158 {
 159     Node::attach();
 160 }
 161
 162 inline void ContainerNode::attachChildren()
 163 {
 164     for (Node* child = firstChild(); child; child = child->nextSibling())
 165         child->attach();
 166 }
 167
 168 inline void ContainerNode::attachChildrenIfNeeded()
 169 {
 170     for (Node* child = firstChild(); child; child = child->nextSibling()) {
 171         if (!child->attached())
 172             child->attach();
 173     }
 174 }
 175
 176 inline void ContainerNode::attachChildrenLazily()
 177 {
 178     for (Node* child = firstChild(); child; child = child->nextSibling())
 179         if (!child->attached())
 180             child->lazyAttach();
 181 }
 182
 183 inline void ContainerNode::detachAsNode()
 184 {
 185     Node::detach();
 186 }
 187
 188 inline void ContainerNode::detachChildrenIfNeeded()
 189 {
 190     for (Node* child = firstChild(); child; child = child->nextSibling()) {
 191         if (child->attached())
 192             child->detach();
 193     }
 194 }
 195
 196 inline void ContainerNode::detachChildren()
 197 {
 198     for (Node* child = firstChild(); child; child = child->nextSibling())
 199         child->detach();
 200 }
 201
 202 inline unsigned Node::childNodeCount() const
 203 {
 204     if (!isContainerNode())
 205         return 0;
 206     return toContainerNode(this)->childNodeCount();
 207 }
 208
 209 inline Node* Node::childNode(unsigned index) const
 210 {
 211     if (!isContainerNode())
 212         return 0;
 213     return toContainerNode(this)->childNode(index);
 214 }
 215
 216 inline Node* Node::firstChild() const
 217 {
 218     if (!isContainerNode())
 219         return 0;
 220     return toContainerNode(this)->firstChild();
 221 }
 222
 223 inline Node* Node::lastChild() const
 224 {
 225     if (!isContainerNode())
 226         return 0;
 227     return toContainerNode(this)->lastChild();
 228 }
 229
 230 typedef Vector<RefPtr<Node>, 11> NodeVector;
 231
 232 inline void getChildNodes(Node* node, NodeVector& nodes)
 233 {
 234     ASSERT(!nodes.size());
 235     for (Node* child = node->firstChild(); child; child = child->nextSibling())
 236         nodes.append(child);
 237 }
 238
 239 } // namespace WebCore
 240
 241 #endif // ContainerNode_h