void CounterReset::removeChild ( CounterNode *oldChild )
{
Q_ASSERT( oldChild );
CounterNode* next = oldChild->m_next;
CounterNode* prev = oldChild->m_previous;
if (oldChild->firstChild()) {
CounterNode* first = oldChild->firstChild();
CounterNode* last = oldChild->lastChild();
if (prev) {
prev->m_next = first;
first->m_previous = prev;
}
else {
assert ( m_first == oldChild );
m_first = first;
}
if (next) {
next->m_previous = last;
last->m_next = next;
}
else {
assert ( m_last == oldChild );
m_last = last;
}
next = first;
while (next) {
next->m_parent = this;
if (next == last) break;
next = next->m_next;
}
first->recount(true);
}
else {
if (prev) prev->m_next = next;
else {
assert ( m_first == oldChild );
m_first = next;
}
if (next) next->m_previous = prev;
else {
assert ( m_last == oldChild );
m_last = prev;
}
if (next)
next->recount();
}
oldChild->m_next = 0;
oldChild->m_previous = 0;
oldChild->m_parent = 0;
}
void CounterNode::insertAfter(CounterNode* newChild, CounterNode* refChild)
{
ASSERT(newChild);
ASSERT(!newChild->m_parent);
ASSERT(!newChild->m_previousSibling);
ASSERT(!newChild->m_nextSibling);
ASSERT(!refChild || refChild->m_parent == this);
CounterNode* next;
if (refChild) {
next = refChild->m_nextSibling;
refChild->m_nextSibling = newChild;
} else {
next = m_firstChild;
m_firstChild = newChild;
}
if (next) {
ASSERT(next->m_previousSibling == refChild);
next->m_previousSibling = newChild;
} else {
ASSERT(m_lastChild == refChild);
m_lastChild = newChild;
}
newChild->m_parent = this;
newChild->m_previousSibling = refChild;
newChild->m_nextSibling = next;
newChild->m_countInParent = newChild->computeCountInParent();
if (next)
next->recount();
}
void CounterNode::removeChild(CounterNode* oldChild)
{
ASSERT(oldChild);
ASSERT(!oldChild->m_firstChild);
ASSERT(!oldChild->m_lastChild);
CounterNode* next = oldChild->m_nextSibling;
CounterNode* prev = oldChild->m_previousSibling;
oldChild->m_nextSibling = 0;
oldChild->m_previousSibling = 0;
oldChild->m_parent = 0;
if (prev)
prev->m_nextSibling = next;
else {
ASSERT(m_firstChild == oldChild);
m_firstChild = next;
}
if (next)
next->m_previousSibling = prev;
else {
ASSERT(m_lastChild == oldChild);
m_lastChild = prev;
}
if (next)
next->recount();
}
void CounterNode::removeChild(CounterNode* oldChild, const AtomicString& identifier)
{
ASSERT(oldChild);
ASSERT(!oldChild->m_firstChild);
ASSERT(!oldChild->m_lastChild);
CounterNode* next = oldChild->m_nextSibling;
CounterNode* previous = oldChild->m_previousSibling;
oldChild->m_nextSibling = 0;
oldChild->m_previousSibling = 0;
oldChild->m_parent = 0;
if (previous)
previous->m_nextSibling = next;
else {
ASSERT(m_firstChild == oldChild);
m_firstChild = next;
}
if (next)
next->m_previousSibling = previous;
else {
ASSERT(m_lastChild == oldChild);
m_lastChild = previous;
}
if (next)
next->recount(identifier);
}
void CounterNode::insertAfter(CounterNode* newChild, CounterNode* refChild, const AtomicString& identifier)
{
ASSERT(newChild);
ASSERT(!newChild->m_parent);
ASSERT(!newChild->m_previousSibling);
ASSERT(!newChild->m_nextSibling);
// If the refChild is not our child we can not complete the request. This hardens against bugs in RenderCounter.
// When renderers are reparented it may request that we insert counter nodes improperly.
if (refChild && refChild->m_parent != this)
return;
if (newChild->m_hasResetType) {
while (m_lastChild != refChild)
RenderCounter::destroyCounterNode(m_lastChild->owner(), identifier);
}
CounterNode* next;
if (refChild) {
next = refChild->m_nextSibling;
refChild->m_nextSibling = newChild;
} else {
next = m_firstChild;
m_firstChild = newChild;
}
newChild->m_parent = this;
newChild->m_previousSibling = refChild;
if (next) {
ASSERT(next->m_previousSibling == refChild);
next->m_previousSibling = newChild;
newChild->m_nextSibling = next;
} else {
ASSERT(m_lastChild == refChild);
m_lastChild = newChild;
}
if (!newChild->m_firstChild || newChild->m_hasResetType) {
newChild->m_countInParent = newChild->computeCountInParent();
newChild->resetThisAndDescendantsRenderers();
if (next)
next->recount();
return;
}
// The code below handles the case when a formerly root increment counter is loosing its root position
// and therefore its children become next siblings.
CounterNode* last = newChild->m_lastChild;
CounterNode* first = newChild->m_firstChild;
if (first) {
ASSERT(last);
newChild->m_nextSibling = first;
if (m_lastChild == newChild)
m_lastChild = last;
first->m_previousSibling = newChild;
// The case when the original next sibling of the inserted node becomes a child of
// one of the former children of the inserted node is not handled as it is believed
// to be impossible since:
// 1. if the increment counter node lost it's root position as a result of another
// counter node being created, it will be inserted as the last child so next is null.
// 2. if the increment counter node lost it's root position as a result of a renderer being
// inserted into the document's render tree, all its former children counters are attached
// to children of the inserted renderer and hence cannot be in scope for counter nodes
// attached to renderers that were already in the document's render tree.
last->m_nextSibling = next;
if (next) {
ASSERT(next->m_previousSibling == newChild);
next->m_previousSibling = last;
} else
m_lastChild = last;
for (next = first; ; next = next->m_nextSibling) {
next->m_parent = this;
if (last == next)
break;
}
}
newChild->m_firstChild = 0;
newChild->m_lastChild = 0;
newChild->m_countInParent = newChild->computeCountInParent();
newChild->resetRenderers();
first->recount();
}
