2009-11-13 Carol Szabo <carol.szabo@nokia.com>
[WebKit-https.git] / WebCore / rendering / CounterNode.cpp
1 /*
2  * Copyright (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
3  * Copyright (C) 2006, 2007 Apple Inc. All rights reserved.
4  *
5  * This library is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU Library General Public
7  * License as published by the Free Software Foundation; either
8  * version 2 of the License, or (at your option) any later version.
9  *
10  * This library is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * Library General Public License for more details.
14  *
15  * You should have received a copy of the GNU Library General Public License
16  * along with this library; see the file COPYING.LIB.  If not, write to
17  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
18  * Boston, MA 02110-1301, USA.
19  *
20  */
21
22 #include "config.h"
23 #include "CounterNode.h"
24
25 #include "RenderObject.h"
26 #include <stdio.h>
27
28 // FIXME: There's currently no strategy for getting the counter tree updated when new
29 // elements with counter-reset and counter-increment styles are added to the render tree.
30 // Also, the code can't handle changes where an existing node needs to change into a
31 // "reset" node, or from a "reset" node back to not a "reset" node. As of this writing,
32 // at least some of these problems manifest as failures in the t1204-increment and
33 // t1204-reset tests in the CSS 2.1 test suite.
34
35 namespace WebCore {
36
37 CounterNode::CounterNode(RenderObject* o, bool isReset, int value)
38     : m_isReset(isReset)
39     , m_value(value)
40     , m_countInParent(0)
41     , m_renderer(o)
42     , m_parent(0)
43     , m_previousSibling(0)
44     , m_nextSibling(0)
45     , m_firstChild(0)
46     , m_lastChild(0)
47 {
48 }
49
50 CounterNode* CounterNode::nextInPreOrderAfterChildren(const CounterNode* stayWithin) const
51 {
52     if (this == stayWithin)
53         return 0;
54
55     CounterNode* next = m_nextSibling;
56     if (next)
57         return next;
58     next = m_parent;
59     while (next && !next->m_nextSibling) {
60         if (next == stayWithin)
61             return 0;
62         next = next->m_parent;
63     }
64     if (next)
65         return next->m_nextSibling;
66     return 0;
67 }
68
69 CounterNode* CounterNode::nextInPreOrder(const CounterNode* stayWithin) const
70 {
71     if (CounterNode* next = m_firstChild)
72         return next;
73
74     return nextInPreOrderAfterChildren(stayWithin);
75 }
76
77 CounterNode* CounterNode::lastDescendant() const
78 {
79     CounterNode* last = m_lastChild;
80     if (!last)
81         return 0;
82
83     while (CounterNode* lastChild = last->m_lastChild)
84         last = lastChild;
85
86     return last;
87 }
88
89 CounterNode* CounterNode::previousInPreOrder() const
90 {
91     CounterNode* previous = m_previousSibling;
92     if (!previous)
93         return m_parent;
94
95     while (CounterNode* lastChild = previous->m_lastChild)
96         previous = lastChild;
97
98     return previous;
99 }
100
101 int CounterNode::computeCountInParent() const
102 {
103     int increment = m_isReset ? 0 : m_value;
104     if (m_previousSibling)
105         return m_previousSibling->m_countInParent + increment;
106     ASSERT(m_parent->m_firstChild == this);
107     return m_parent->m_value + increment;
108 }
109
110
111 void CounterNode::resetRenderer(const AtomicString& identifier) const
112 {
113     if (!m_renderer || m_renderer->documentBeingDestroyed())
114         return;
115     if (RenderObjectChildList* children = m_renderer->virtualChildren())
116         children->invalidateCounters(m_renderer, identifier);
117 }
118
119 void CounterNode::resetRenderers(const AtomicString& identifier) const
120 {
121     const CounterNode* node = this;
122     do {
123         node->resetRenderer(identifier);
124         node = node->nextInPreOrder(this);
125     } while (node);
126 }
127
128 void CounterNode::recount(const AtomicString& identifier)
129 {
130     for (CounterNode* node = this; node; node = node->m_nextSibling) {
131         int oldCount = node->m_countInParent;
132         int newCount = node->computeCountInParent();
133         if (oldCount == newCount)
134             break;
135         node->m_countInParent = newCount;
136         node->resetRenderers(identifier);
137     }
138 }
139
140 void CounterNode::insertAfter(CounterNode* newChild, CounterNode* refChild, const AtomicString& identifier)
141 {
142     ASSERT(newChild);
143     ASSERT(!newChild->m_parent);
144     ASSERT(!newChild->m_previousSibling);
145     ASSERT(!newChild->m_nextSibling);
146     ASSERT(!refChild || refChild->m_parent == this);
147
148     CounterNode* next;
149
150     if (refChild) {
151         next = refChild->m_nextSibling;
152         refChild->m_nextSibling = newChild;
153     } else {
154         next = m_firstChild;
155         m_firstChild = newChild;
156     }
157
158     if (next) {
159         ASSERT(next->m_previousSibling == refChild);
160         next->m_previousSibling = newChild;
161     } else {
162         ASSERT(m_lastChild == refChild);
163         m_lastChild = newChild;
164     }
165
166     newChild->m_parent = this;
167     newChild->m_previousSibling = refChild;
168     newChild->m_nextSibling = next;
169
170     newChild->m_countInParent = newChild->computeCountInParent();
171     if (next)
172         next->recount(identifier);
173 }
174
175 void CounterNode::removeChild(CounterNode* oldChild, const AtomicString& identifier)
176 {
177     ASSERT(oldChild);
178     ASSERT(!oldChild->m_firstChild);
179     ASSERT(!oldChild->m_lastChild);
180
181     CounterNode* next = oldChild->m_nextSibling;
182     CounterNode* previous = oldChild->m_previousSibling;
183
184     oldChild->m_nextSibling = 0;
185     oldChild->m_previousSibling = 0;
186     oldChild->m_parent = 0;
187
188     if (previous) 
189         previous->m_nextSibling = next;
190     else {
191         ASSERT(m_firstChild == oldChild);
192         m_firstChild = next;
193     }
194
195     if (next)
196         next->m_previousSibling = previous;
197     else {
198         ASSERT(m_lastChild == oldChild);
199         m_lastChild = previous;
200     }
201
202     if (next)
203         next->recount(identifier);
204 }
205
206 #ifndef NDEBUG
207
208 static void showTreeAndMark(const CounterNode* node)
209 {
210     const CounterNode* root = node;
211     while (root->parent())
212         root = root->parent();
213
214     for (const CounterNode* current = root; current; current = nextInPreOrder(current)) {
215         fwrite((current == node) ? "*" : " ", 1, 1, stderr);
216         for (const CounterNode* parent = current; parent && parent != root; parent = parent->parent())
217             fwrite("  ", 1, 2, stderr);
218         fprintf(stderr, "%p %s: %d %d P:%p PS:%p NS:%p R:%p\n",
219             current, current->isReset() ? "reset____" : "increment", current->value(),
220             current->countInParent(), current->parent(), current->previousSibling(),
221             current->nextSibling(), current->renderer());
222     }
223 }
224
225 #endif
226
227 } // namespace WebCore
228
229 #ifndef NDEBUG
230
231 void showTree(const WebCore::CounterNode* counter)
232 {
233     if (counter)
234         showTreeAndMark(counter);
235 }
236
237 #endif