mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-23 10:15:41 +00:00
6890b35c2b
The difference between the PRCList and LinkedList is that the end of a LinkedList is represented by nullptr, so we don't need to worry about getting the first element when we iterate pass the last element. The majority of the changes is due to this difference. Also, simplify do-while loops by using for-loops in nsCounterManager and nsQuoteList. MozReview-Commit-ID: CZQxqNm2Ksm --HG-- extra : rebase_source : 1a27aa5effa43a46a5d24172085c6d3502cb8c47
347 lines
11 KiB
C++
347 lines
11 KiB
C++
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* 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();
|
|
|
|
AutoTArray<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;
|
|
|
|
for (nsCounterNode* node = First(); node; node = Next(node)) {
|
|
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);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
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->CounterResetAt(i),
|
|
nsCounterChangeNode::RESET);
|
|
for (i = 0, i_end = styleContent->CounterIncrementCount(); i != i_end; ++i)
|
|
dirty |=
|
|
AddResetOrIncrement(aFrame, i, styleContent->CounterIncrementAt(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;
|
|
}
|
|
|
|
void
|
|
nsCounterManager::RecalcAll()
|
|
{
|
|
for (auto iter = mNames.Iter(); !iter.Done(); iter.Next()) {
|
|
nsCounterList* list = iter.UserData();
|
|
if (list->IsDirty()) {
|
|
list->RecalcAll();
|
|
}
|
|
}
|
|
}
|
|
|
|
void
|
|
nsCounterManager::SetAllCounterStylesDirty()
|
|
{
|
|
for (auto iter = mNames.Iter(); !iter.Done(); iter.Next()) {
|
|
nsCounterList* list = iter.UserData();
|
|
bool changed = false;
|
|
|
|
for (nsCounterNode* node = list->First(); node; node = list->Next(node)) {
|
|
if (node->mType == nsCounterNode::USE) {
|
|
node->UseNode()->SetCounterStyleDirty();
|
|
changed = true;
|
|
}
|
|
}
|
|
|
|
if (changed) {
|
|
list->SetDirty();
|
|
}
|
|
}
|
|
}
|
|
|
|
bool
|
|
nsCounterManager::DestroyNodesFor(nsIFrame *aFrame)
|
|
{
|
|
bool destroyedAny = false;
|
|
for (auto iter = mNames.Iter(); !iter.Done(); iter.Next()) {
|
|
nsCounterList* list = iter.UserData();
|
|
if (list->DestroyNodesFor(aFrame)) {
|
|
destroyedAny = true;
|
|
list->SetDirty();
|
|
}
|
|
}
|
|
return destroyedAny;
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
void
|
|
nsCounterManager::Dump()
|
|
{
|
|
printf("\n\nCounter Manager Lists:\n");
|
|
for (auto iter = mNames.Iter(); !iter.Done(); iter.Next()) {
|
|
printf("Counter named \"%s\":\n",
|
|
NS_ConvertUTF16toUTF8(iter.Key()).get());
|
|
|
|
nsCounterList* list = iter.UserData();
|
|
int32_t i = 0;
|
|
for (nsCounterNode* node = list->First(); node; node = list->Next(node)) {
|
|
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");
|
|
}
|
|
}
|
|
printf("\n\n");
|
|
}
|
|
#endif
|