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