path: root/layout/base/nsCounterManager.cpp

/* -*- 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