diff options
Diffstat (limited to 'layout/base/nsCounterManager.cpp')
| -rw-r--r-- | layout/base/nsCounterManager.cpp | 346 |
1 files changed, 346 insertions, 0 deletions
diff --git a/layout/base/nsCounterManager.cpp b/layout/base/nsCounterManager.cpp new file mode 100644 index 000000000..2d998abd0 --- /dev/null +++ b/layout/base/nsCounterManager.cpp @@ -0,0 +1,346 @@ +/* -*- 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 |