static CounterNode* makeCounterNode(RenderObject* object, const AtomicString& identifier, bool alwaysCreateCounter) { ASSERT(object); if (object->m_hasCounterNodeMap) if (CounterMap* nodeMap = counterMaps().get(object)) if (CounterNode* node = nodeMap->get(identifier.impl())) return node; bool isReset = false; int value = 0; if (!planCounter(object, identifier, isReset, value) && !alwaysCreateCounter) return 0; CounterNode* newParent = 0; CounterNode* newPreviousSibling = 0; CounterNode* newNode = new CounterNode(object, isReset, value); if (findPlaceForCounter(object, identifier, isReset, newParent, newPreviousSibling)) newParent->insertAfter(newNode, newPreviousSibling, identifier); CounterMap* nodeMap; if (object->m_hasCounterNodeMap) nodeMap = counterMaps().get(object); else { nodeMap = new CounterMap; counterMaps().set(object, nodeMap); object->m_hasCounterNodeMap = true; } nodeMap->set(identifier.impl(), newNode); if (newNode->parent() || !object->nextInPreOrder(object->parent())) return newNode; // Checking if some nodes that were previously counter tree root nodes // should become children of this node now. CounterMaps& maps = counterMaps(); RenderObject* stayWithin = object->parent(); for (RenderObject* currentRenderer = object->nextInPreOrder(stayWithin); currentRenderer; currentRenderer = currentRenderer->nextInPreOrder(stayWithin)) { if (!currentRenderer->m_hasCounterNodeMap) continue; CounterNode* currentCounter = maps.get(currentRenderer)->get(identifier.impl()); if (!currentCounter) continue; if (currentCounter->parent()) { ASSERT(newNode->firstChild()); if (currentRenderer->lastChild()) currentRenderer = currentRenderer->lastChild(); continue; } if (stayWithin != currentRenderer->parent() || !currentCounter->hasResetType()) newNode->insertAfter(currentCounter, newNode->lastChild(), identifier); if (currentRenderer->lastChild()) currentRenderer = currentRenderer->lastChild(); } return newNode; }
static void updateCounters(RenderObject* renderer) { ASSERT(renderer->style()); const CounterDirectiveMap* directiveMap = renderer->style()->counterDirectives(); if (!directiveMap) return; CounterDirectiveMap::const_iterator end = directiveMap->end(); if (!renderer->hasCounterNodeMap()) { for (CounterDirectiveMap::const_iterator it = directiveMap->begin(); it != end; ++it) makeCounterNode(renderer, AtomicString(it->first.get()), false); return; } CounterMap* counterMap = counterMaps().get(renderer); ASSERT(counterMap); for (CounterDirectiveMap::const_iterator it = directiveMap->begin(); it != end; ++it) { RefPtr<CounterNode> node = counterMap->get(it->first.get()); if (!node) { makeCounterNode(renderer, AtomicString(it->first.get()), false); continue; } CounterNode* newParent = 0; CounterNode* newPreviousSibling; findPlaceForCounter(renderer, AtomicString(it->first.get()), node->hasResetType(), newParent, newPreviousSibling); if (node != counterMap->get(it->first.get())) continue; CounterNode* parent = node->parent(); if (newParent == parent && newPreviousSibling == node->previousSibling()) continue; if (parent) parent->removeChild(node.get()); if (newParent) newParent->insertAfter(node.get(), newPreviousSibling, it->first.get()); } }
static CounterNode* makeCounterNode(RenderObject* object, const AtomicString& identifier, bool alwaysCreateCounter) { ASSERT(object); if (object->hasCounterNodeMap()) { if (CounterMap* nodeMap = counterMaps().get(object)) { if (CounterNode* node = nodeMap->get(identifier.impl()).get()) return node; } } bool isReset = false; int value = 0; if (!planCounter(object, identifier, isReset, value) && !alwaysCreateCounter) return 0; CounterNode* newParent = 0; CounterNode* newPreviousSibling = 0; RefPtr<CounterNode> newNode = CounterNode::create(object, isReset, value); if (findPlaceForCounter(object, identifier, isReset, newParent, newPreviousSibling)) newParent->insertAfter(newNode.get(), newPreviousSibling, identifier); CounterMap* nodeMap; if (object->hasCounterNodeMap()) nodeMap = counterMaps().get(object); else { nodeMap = new CounterMap; counterMaps().set(object, nodeMap); object->setHasCounterNodeMap(true); } nodeMap->set(identifier.impl(), newNode); if (newNode->parent()) return newNode.get(); // Checking if some nodes that were previously counter tree root nodes // should become children of this node now. CounterMaps& maps = counterMaps(); Element* stayWithin = parentElement(object); bool skipDescendants; for (RenderObject* currentRenderer = nextInPreOrder(object, stayWithin); currentRenderer; currentRenderer = nextInPreOrder(currentRenderer, stayWithin, skipDescendants)) { skipDescendants = false; if (!currentRenderer->hasCounterNodeMap()) continue; CounterNode* currentCounter = maps.get(currentRenderer)->get(identifier.impl()).get(); if (!currentCounter) continue; skipDescendants = true; if (currentCounter->parent()) continue; if (stayWithin == parentElement(currentRenderer) && currentCounter->hasResetType()) break; newNode->insertAfter(currentCounter, newNode->lastChild(), identifier); } return newNode.get(); }
static CounterNode* counter(RenderObject* object, const AtomicString& counterName, bool alwaysCreateCounter) { ASSERT(object); if (object->m_hasCounterNodeMap) if (CounterMap* nodeMap = counterMaps().get(object)) if (CounterNode* node = nodeMap->get(counterName.impl())) return node; bool isReset = false; int value = 0; if (!planCounter(object, counterName, isReset, value) && !alwaysCreateCounter) return 0; CounterNode* newParent = 0; CounterNode* newPreviousSibling = 0; CounterNode* newNode; if (findPlaceForCounter(object, counterName, isReset, newParent, newPreviousSibling)) { newNode = new CounterNode(object, isReset, value); newParent->insertAfter(newNode, newPreviousSibling); } else { // Make a reset node for counters that aren't inside an existing reset node. newNode = new CounterNode(object, true, value); } CounterMap* nodeMap; if (object->m_hasCounterNodeMap) nodeMap = counterMaps().get(object); else { nodeMap = new CounterMap; counterMaps().set(object, nodeMap); object->m_hasCounterNodeMap = true; } nodeMap->set(counterName.impl(), newNode); return newNode; }