gecko/layout/base/nsCounterManager.cpp

385 lines
12 KiB
C++

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
// vim:cindent:ai:sw=4:ts=4:et:
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
/* implementation of CSS counters (for numbering things) */
#include "nsCounterManager.h"
#include "mozilla/Likely.h"
#include "mozilla/WritingModes.h"
#include "nsBulletFrame.h" // legacy location for list style type to text code
#include "nsContentUtils.h"
#include "nsIContent.h"
#include "nsTArray.h"
using namespace mozilla;
bool
nsCounterUseNode::InitTextFrame(nsGenConList* aList,
nsIFrame* aPseudoFrame, nsIFrame* aTextFrame)
{
nsCounterNode::InitTextFrame(aList, aPseudoFrame, aTextFrame);
nsCounterList *counterList = static_cast<nsCounterList*>(aList);
counterList->Insert(this);
bool dirty = counterList->IsDirty();
if (!dirty) {
if (counterList->IsLast(this)) {
Calc(counterList);
nsAutoString contentString;
GetText(contentString);
aTextFrame->GetContent()->SetText(contentString, false);
} else {
// In all other cases (list already dirty or node not at the end),
// just start with an empty string for now and when we recalculate
// the list we'll change the value to the right one.
counterList->SetDirty();
return true;
}
}
return false;
}
CounterStyle*
nsCounterUseNode::GetCounterStyle()
{
if (!mCounterStyle) {
const nsCSSValue& style = mCounterFunction->Item(mAllCounters ? 2 : 1);
CounterStyleManager* manager = mPresContext->CounterStyleManager();
if (style.GetUnit() == eCSSUnit_Ident) {
nsString ident;
style.GetStringValue(ident);
mCounterStyle = manager->BuildCounterStyle(ident);
} else if (style.GetUnit() == eCSSUnit_Symbols) {
mCounterStyle = new AnonymousCounterStyle(style.GetArrayValue());
} else {
NS_NOTREACHED("Unknown counter style");
mCounterStyle = CounterStyleManager::GetDecimalStyle();
}
}
return mCounterStyle;
}
// assign the correct |mValueAfter| value to a node that has been inserted
// Should be called immediately after calling |Insert|.
void nsCounterUseNode::Calc(nsCounterList *aList)
{
NS_ASSERTION(!aList->IsDirty(),
"Why are we calculating with a dirty list?");
mValueAfter = aList->ValueBefore(this);
}
// assign the correct |mValueAfter| value to a node that has been inserted
// Should be called immediately after calling |Insert|.
void nsCounterChangeNode::Calc(nsCounterList *aList)
{
NS_ASSERTION(!aList->IsDirty(),
"Why are we calculating with a dirty list?");
if (mType == RESET) {
mValueAfter = mChangeValue;
} else {
NS_ASSERTION(mType == INCREMENT, "invalid type");
mValueAfter = nsCounterManager::IncrementCounter(aList->ValueBefore(this),
mChangeValue);
}
}
// The text that should be displayed for this counter.
void
nsCounterUseNode::GetText(nsString& aResult)
{
aResult.Truncate();
nsAutoTArray<nsCounterNode*, 8> stack;
stack.AppendElement(static_cast<nsCounterNode*>(this));
if (mAllCounters && mScopeStart)
for (nsCounterNode *n = mScopeStart; n->mScopePrev; n = n->mScopeStart)
stack.AppendElement(n->mScopePrev);
const char16_t* separator;
if (mAllCounters)
separator = mCounterFunction->Item(1).GetStringBufferValue();
CounterStyle* style = GetCounterStyle();
WritingMode wm = mPseudoFrame ?
mPseudoFrame->GetWritingMode() : WritingMode();
for (uint32_t i = stack.Length() - 1;; --i) {
nsCounterNode *n = stack[i];
nsAutoString text;
bool isTextRTL;
style->GetCounterText(n->mValueAfter, wm, text, isTextRTL);
aResult.Append(text);
if (i == 0)
break;
NS_ASSERTION(mAllCounters, "yikes, separator is uninitialized");
aResult.Append(separator);
}
}
void
nsCounterList::SetScope(nsCounterNode *aNode)
{
// This function is responsible for setting |mScopeStart| and
// |mScopePrev| (whose purpose is described in nsCounterManager.h).
// We do this by starting from the node immediately preceding
// |aNode| in content tree order, which is reasonably likely to be
// the previous element in our scope (or, for a reset, the previous
// element in the containing scope, which is what we want). If
// we're not in the same scope that it is, then it's too deep in the
// frame tree, so we walk up parent scopes until we find something
// appropriate.
if (aNode == First()) {
aNode->mScopeStart = nullptr;
aNode->mScopePrev = nullptr;
return;
}
// Get the content node for aNode's rendering object's *parent*,
// since scope includes siblings, so we want a descendant check on
// parents.
nsIContent *nodeContent = aNode->mPseudoFrame->GetContent()->GetParent();
for (nsCounterNode *prev = Prev(aNode), *start;
prev; prev = start->mScopePrev) {
// If |prev| starts a scope (because it's a real or implied
// reset), we want it as the scope start rather than the start
// of its enclosing scope. Otherwise, there's no enclosing
// scope, so the next thing in prev's scope shares its scope
// start.
start = (prev->mType == nsCounterNode::RESET || !prev->mScopeStart)
? prev : prev->mScopeStart;
// |startContent| is analogous to |nodeContent| (see above).
nsIContent *startContent = start->mPseudoFrame->GetContent()->GetParent();
NS_ASSERTION(nodeContent || !startContent,
"null check on startContent should be sufficient to "
"null check nodeContent as well, since if nodeContent "
"is for the root, startContent (which is before it) "
"must be too");
// A reset's outer scope can't be a scope created by a sibling.
if (!(aNode->mType == nsCounterNode::RESET &&
nodeContent == startContent) &&
// everything is inside the root (except the case above,
// a second reset on the root)
(!startContent ||
nsContentUtils::ContentIsDescendantOf(nodeContent,
startContent))) {
aNode->mScopeStart = start;
aNode->mScopePrev = prev;
return;
}
}
aNode->mScopeStart = nullptr;
aNode->mScopePrev = nullptr;
}
void
nsCounterList::RecalcAll()
{
mDirty = false;
nsCounterNode *node = First();
if (!node)
return;
do {
SetScope(node);
node->Calc(this);
if (node->mType == nsCounterNode::USE) {
nsCounterUseNode *useNode = node->UseNode();
// Null-check mText, since if the frame constructor isn't
// batching, we could end up here while the node is being
// constructed.
if (useNode->mText) {
nsAutoString text;
useNode->GetText(text);
useNode->mText->SetData(text);
}
}
} while ((node = Next(node)) != First());
}
nsCounterManager::nsCounterManager()
: mNames()
{
}
bool
nsCounterManager::AddCounterResetsAndIncrements(nsIFrame *aFrame)
{
const nsStyleContent *styleContent = aFrame->StyleContent();
if (!styleContent->CounterIncrementCount() &&
!styleContent->CounterResetCount())
return false;
// Add in order, resets first, so all the comparisons will be optimized
// for addition at the end of the list.
int32_t i, i_end;
bool dirty = false;
for (i = 0, i_end = styleContent->CounterResetCount(); i != i_end; ++i)
dirty |= AddResetOrIncrement(aFrame, i,
styleContent->GetCounterResetAt(i),
nsCounterChangeNode::RESET);
for (i = 0, i_end = styleContent->CounterIncrementCount(); i != i_end; ++i)
dirty |= AddResetOrIncrement(aFrame, i,
styleContent->GetCounterIncrementAt(i),
nsCounterChangeNode::INCREMENT);
return dirty;
}
bool
nsCounterManager::AddResetOrIncrement(nsIFrame *aFrame, int32_t aIndex,
const nsStyleCounterData *aCounterData,
nsCounterNode::Type aType)
{
nsCounterChangeNode *node =
new nsCounterChangeNode(aFrame, aType, aCounterData->mValue, aIndex);
nsCounterList *counterList = CounterListFor(aCounterData->mCounter);
counterList->Insert(node);
if (!counterList->IsLast(node)) {
// Tell the caller it's responsible for recalculating the entire
// list.
counterList->SetDirty();
return true;
}
// Don't call Calc() if the list is already dirty -- it'll be recalculated
// anyway, and trying to calculate with a dirty list doesn't work.
if (MOZ_LIKELY(!counterList->IsDirty())) {
node->Calc(counterList);
}
return false;
}
nsCounterList*
nsCounterManager::CounterListFor(const nsSubstring& aCounterName)
{
// XXX Why doesn't nsTHashtable provide an API that allows us to use
// get/put in one hashtable lookup?
nsCounterList *counterList;
if (!mNames.Get(aCounterName, &counterList)) {
counterList = new nsCounterList();
mNames.Put(aCounterName, counterList);
}
return counterList;
}
static PLDHashOperator
RecalcDirtyLists(const nsAString& aKey, nsCounterList* aList, void* aClosure)
{
if (aList->IsDirty())
aList->RecalcAll();
return PL_DHASH_NEXT;
}
void
nsCounterManager::RecalcAll()
{
mNames.EnumerateRead(RecalcDirtyLists, nullptr);
}
static PLDHashOperator
SetCounterStylesDirty(const nsAString& aKey,
nsCounterList* aList,
void* aClosure)
{
nsCounterNode* first = aList->First();
if (first) {
bool changed = false;
nsCounterNode* node = first;
do {
if (node->mType == nsCounterNode::USE) {
node->UseNode()->SetCounterStyleDirty();
changed = true;
}
} while ((node = aList->Next(node)) != first);
if (changed) {
aList->SetDirty();
}
}
return PL_DHASH_NEXT;
}
void
nsCounterManager::SetAllCounterStylesDirty()
{
mNames.EnumerateRead(SetCounterStylesDirty, nullptr);
}
struct DestroyNodesData {
explicit DestroyNodesData(nsIFrame *aFrame)
: mFrame(aFrame)
, mDestroyedAny(false)
{
}
nsIFrame *mFrame;
bool mDestroyedAny;
};
static PLDHashOperator
DestroyNodesInList(const nsAString& aKey, nsCounterList* aList, void* aClosure)
{
DestroyNodesData *data = static_cast<DestroyNodesData*>(aClosure);
if (aList->DestroyNodesFor(data->mFrame)) {
data->mDestroyedAny = true;
aList->SetDirty();
}
return PL_DHASH_NEXT;
}
bool
nsCounterManager::DestroyNodesFor(nsIFrame *aFrame)
{
DestroyNodesData data(aFrame);
mNames.EnumerateRead(DestroyNodesInList, &data);
return data.mDestroyedAny;
}
#ifdef DEBUG
static PLDHashOperator
DumpList(const nsAString& aKey, nsCounterList* aList, void* aClosure)
{
printf("Counter named \"%s\":\n", NS_ConvertUTF16toUTF8(aKey).get());
nsCounterNode *node = aList->First();
if (node) {
int32_t i = 0;
do {
const char *types[] = { "RESET", "INCREMENT", "USE" };
printf(" Node #%d @%p frame=%p index=%d type=%s valAfter=%d\n"
" scope-start=%p scope-prev=%p",
i++, (void*)node, (void*)node->mPseudoFrame,
node->mContentIndex, types[node->mType], node->mValueAfter,
(void*)node->mScopeStart, (void*)node->mScopePrev);
if (node->mType == nsCounterNode::USE) {
nsAutoString text;
node->UseNode()->GetText(text);
printf(" text=%s", NS_ConvertUTF16toUTF8(text).get());
}
printf("\n");
} while ((node = aList->Next(node)) != aList->First());
}
return PL_DHASH_NEXT;
}
void
nsCounterManager::Dump()
{
printf("\n\nCounter Manager Lists:\n");
mNames.EnumerateRead(DumpList, nullptr);
printf("\n\n");
}
#endif