Inline Node::traverseNextNode
[WebKit-https.git] / 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 protected:
99     ContainerNode(Document*, ConstructionType = CreateContainer);
100
101     static void queuePostAttachCallback(NodeCallback, Node*, unsigned = 0);
102     static bool postAttachCallbacksAreSuspended();
103     void suspendPostAttachCallbacks();
104     void resumePostAttachCallbacks();
105
106     template<class GenericNode, class GenericNodeContainer>
107     friend void appendChildToContainer(GenericNode* child, GenericNodeContainer*);
108
109     template<class GenericNode, class GenericNodeContainer>
110     friend void Private::addChildNodesToDeletionQueue(GenericNode*& head, GenericNode*& tail, GenericNodeContainer*);
111
112     void setFirstChild(Node* child) { m_firstChild = child; }
113     void setLastChild(Node* child) { m_lastChild = child; }
114
115 private:
116     void removeBetween(Node* previousChild, Node* nextChild, Node* oldChild);
117     void insertBeforeCommon(Node* nextChild, Node* oldChild);
118
119     static void dispatchPostAttachCallbacks();
120
121     bool getUpperLeftCorner(FloatPoint&) const;
122     bool getLowerRightCorner(FloatPoint&) const;
123
124     Node* m_firstChild;
125     Node* m_lastChild;
126 };
127
128 inline ContainerNode* toContainerNode(Node* node)
129 {
130     ASSERT(!node || node->isContainerNode());
131     return static_cast<ContainerNode*>(node);
132 }
133
134 inline const ContainerNode* toContainerNode(const Node* node)
135 {
136     ASSERT(!node || node->isContainerNode());
137     return static_cast<const ContainerNode*>(node);
138 }
139
140 // This will catch anyone doing an unnecessary cast.
141 void toContainerNode(const ContainerNode*);
142
143 inline ContainerNode::ContainerNode(Document* document, ConstructionType type)
144     : Node(document, type)
145     , m_firstChild(0)
146     , m_lastChild(0)
147 {
148 }
149
150 inline void ContainerNode::attachAsNode()
151 {
152     Node::attach();
153 }
154
155 inline void ContainerNode::attachChildren()
156 {
157     for (Node* child = firstChild(); child; child = child->nextSibling())
158         child->attach();
159 }
160
161 inline void ContainerNode::attachChildrenIfNeeded()
162 {
163     for (Node* child = firstChild(); child; child = child->nextSibling()) {
164         if (!child->attached())
165             child->attach();
166     }
167 }
168
169 inline void ContainerNode::attachChildrenLazily()
170 {
171     for (Node* child = firstChild(); child; child = child->nextSibling())
172         if (!child->attached())
173             child->lazyAttach();
174 }
175
176 inline void ContainerNode::detachAsNode()
177 {
178     Node::detach();
179 }
180
181 inline void ContainerNode::detachChildrenIfNeeded()
182 {
183     for (Node* child = firstChild(); child; child = child->nextSibling()) {
184         if (child->attached())
185             child->detach();
186     }
187 }
188
189 inline void ContainerNode::detachChildren()
190 {
191     for (Node* child = firstChild(); child; child = child->nextSibling())
192         child->detach();
193 }
194
195 inline unsigned Node::childNodeCount() const
196 {
197     if (!isContainerNode())
198         return 0;
199     return toContainerNode(this)->childNodeCount();
200 }
201
202 inline Node* Node::childNode(unsigned index) const
203 {
204     if (!isContainerNode())
205         return 0;
206     return toContainerNode(this)->childNode(index);
207 }
208
209 inline Node* Node::firstChild() const
210 {
211     if (!isContainerNode())
212         return 0;
213     return toContainerNode(this)->firstChild();
214 }
215
216 inline Node* Node::lastChild() const
217 {
218     if (!isContainerNode())
219         return 0;
220     return toContainerNode(this)->lastChild();
221 }
222
223 inline Node* Node::highestAncestor() const
224 {
225     Node* node = const_cast<Node*>(this);
226     Node* highest = node;
227     for (; node; node = node->parentNode())
228         highest = node;
229     return highest;
230 }
231
232 inline Node* Node::traverseNextSibling() const
233 {
234     if (nextSibling())
235         return nextSibling();
236     return traverseNextAncestorSibling();
237 }
238
239 inline Node* Node::traverseNextNode() const
240 {
241     if (firstChild())
242         return firstChild();
243     return traverseNextSibling();
244 }
245
246 inline Node* Node::traverseNextSibling(const Node* stayWithin) const
247 {
248     if (this == stayWithin)
249         return 0;
250     if (nextSibling())
251         return nextSibling();
252     return traverseNextAncestorSibling(stayWithin);
253 }
254
255 inline Node* Node::traverseNextNode(const Node* stayWithin) const
256 {
257     if (firstChild())
258         return firstChild();
259     return traverseNextSibling(stayWithin);
260 }
261
262 typedef Vector<RefPtr<Node>, 11> NodeVector;
263
264 inline void getChildNodes(Node* node, NodeVector& nodes)
265 {
266     ASSERT(!nodes.size());
267     for (Node* child = node->firstChild(); child; child = child->nextSibling())
268         nodes.append(child);
269 }
270
271 } // namespace WebCore
272
273 #endif // ContainerNode_h