gecko-dev/layout/mathml/nsMathMLmfencedFrame.cpp
Ting-Yu Lin 40fcd21b9a Bug 1277129 Part 7b - Rename various ReflowState variables to ReflowInput. r=dbaron
This patch is generated by the following script:

function rename() {
find .\
     -type f\
     ! -path "./obj*"\
     ! -path "./.git"\
     ! -path "./.hg"\
     \( -name "*.cpp" -or\
        -name "*.h" \)\
        -exec sed -i -r "s/$1/$2/g" "{}" \;
}

rename "([[:alpha:]]*)([rR])eflowState(s?)" "\1\2eflowInput\3"

MozReview-Commit-ID: ITFO7uMTkSb

--HG--
extra : rebase_source : c91a2e174a0baec60c1b0111ac7636295004ab35
2016-07-21 18:36:39 +08:00

744 lines
25 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/. */
#include "nsMathMLmfencedFrame.h"
#include "nsRenderingContext.h"
#include "nsMathMLChar.h"
#include <algorithm>
using namespace mozilla;
//
// <mfenced> -- surround content with a pair of fences
//
nsIFrame*
NS_NewMathMLmfencedFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
{
return new (aPresShell) nsMathMLmfencedFrame(aContext);
}
NS_IMPL_FRAMEARENA_HELPERS(nsMathMLmfencedFrame)
nsMathMLmfencedFrame::~nsMathMLmfencedFrame()
{
RemoveFencesAndSeparators();
}
NS_IMETHODIMP
nsMathMLmfencedFrame::InheritAutomaticData(nsIFrame* aParent)
{
// let the base class get the default from our parent
nsMathMLContainerFrame::InheritAutomaticData(aParent);
mPresentationData.flags |= NS_MATHML_STRETCH_ALL_CHILDREN_VERTICALLY;
RemoveFencesAndSeparators();
CreateFencesAndSeparators(PresContext());
return NS_OK;
}
void
nsMathMLmfencedFrame::SetInitialChildList(ChildListID aListID,
nsFrameList& aChildList)
{
// First, let the base class do its work
nsMathMLContainerFrame::SetInitialChildList(aListID, aChildList);
// InheritAutomaticData will not get called if our parent is not a mathml
// frame, so initialize NS_MATHML_STRETCH_ALL_CHILDREN_VERTICALLY for
// GetPreferredStretchSize() from Reflow().
mPresentationData.flags |= NS_MATHML_STRETCH_ALL_CHILDREN_VERTICALLY;
// No need to track the style contexts given to our MathML chars.
// The Style System will use Get/SetAdditionalStyleContext() to keep them
// up-to-date if dynamic changes arise.
CreateFencesAndSeparators(PresContext());
}
nsresult
nsMathMLmfencedFrame::AttributeChanged(int32_t aNameSpaceID,
nsIAtom* aAttribute,
int32_t aModType)
{
RemoveFencesAndSeparators();
CreateFencesAndSeparators(PresContext());
return nsMathMLContainerFrame::
AttributeChanged(aNameSpaceID, aAttribute, aModType);
}
nsresult
nsMathMLmfencedFrame::ChildListChanged(int32_t aModType)
{
RemoveFencesAndSeparators();
CreateFencesAndSeparators(PresContext());
return nsMathMLContainerFrame::ChildListChanged(aModType);
}
void
nsMathMLmfencedFrame::RemoveFencesAndSeparators()
{
delete mOpenChar;
delete mCloseChar;
if (mSeparatorsChar) delete[] mSeparatorsChar;
mOpenChar = nullptr;
mCloseChar = nullptr;
mSeparatorsChar = nullptr;
mSeparatorsCount = 0;
}
void
nsMathMLmfencedFrame::CreateFencesAndSeparators(nsPresContext* aPresContext)
{
nsAutoString value;
//////////////
// see if the opening fence is there ...
if (!mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::open, value)) {
value = char16_t('('); // default as per the MathML REC
} else {
value.CompressWhitespace();
}
if (!value.IsEmpty()) {
mOpenChar = new nsMathMLChar;
mOpenChar->SetData(value);
ResolveMathMLCharStyle(aPresContext, mContent, mStyleContext, mOpenChar);
}
//////////////
// see if the closing fence is there ...
if(!mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::close, value)) {
value = char16_t(')'); // default as per the MathML REC
} else {
value.CompressWhitespace();
}
if (!value.IsEmpty()) {
mCloseChar = new nsMathMLChar;
mCloseChar->SetData(value);
ResolveMathMLCharStyle(aPresContext, mContent, mStyleContext, mCloseChar);
}
//////////////
// see if separators are there ...
if (!mContent->GetAttr(kNameSpaceID_None, nsGkAtoms::separators_, value)) {
value = char16_t(','); // default as per the MathML REC
} else {
value.StripWhitespace();
}
mSeparatorsCount = value.Length();
if (0 < mSeparatorsCount) {
int32_t sepCount = mFrames.GetLength() - 1;
if (0 < sepCount) {
mSeparatorsChar = new nsMathMLChar[sepCount];
nsAutoString sepChar;
for (int32_t i = 0; i < sepCount; i++) {
if (i < mSeparatorsCount) {
sepChar = value[i];
}
else {
sepChar = value[mSeparatorsCount-1];
}
mSeparatorsChar[i].SetData(sepChar);
ResolveMathMLCharStyle(aPresContext, mContent, mStyleContext, &mSeparatorsChar[i]);
}
mSeparatorsCount = sepCount;
} else {
// No separators. Note that sepCount can be -1 here, so don't
// set mSeparatorsCount to it.
mSeparatorsCount = 0;
}
}
}
void
nsMathMLmfencedFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists)
{
/////////////
// display the content
nsMathMLContainerFrame::BuildDisplayList(aBuilder, aDirtyRect, aLists);
////////////
// display fences and separators
uint32_t count = 0;
if (mOpenChar) {
mOpenChar->Display(aBuilder, this, aLists, count++);
}
if (mCloseChar) {
mCloseChar->Display(aBuilder, this, aLists, count++);
}
for (int32_t i = 0; i < mSeparatorsCount; i++) {
mSeparatorsChar[i].Display(aBuilder, this, aLists, count++);
}
}
/* @param aMetrics is an IN/OUT. Provide the current metrics for the mFenced
frame and it will be enlarged as necessary.
For simplicity the width of the container is always incremented by the width
of the nsMathMLChar. As we only stretch fences and separators in the vertical
direction, this has no impact on overall appearance.
*/
static void
ApplyUnstretchedMetrics(nsPresContext* aPresContext,
DrawTarget* aDrawTarget,
float aFontSizeInflation,
nsMathMLChar* aMathMLChar,
nsBoundingMetrics& aMetrics,
bool aIsRTL)
{
if (aMathMLChar && 0 < aMathMLChar->Length()) {
nsBoundingMetrics charSize;
aMathMLChar->Stretch(aPresContext, aDrawTarget, aFontSizeInflation,
NS_STRETCH_DIRECTION_DEFAULT,
aMetrics, // size is unimportant as we aren't stretching
charSize, NS_STRETCH_NONE, aIsRTL);
aMetrics += charSize;
}
}
void
nsMathMLmfencedFrame::Reflow(nsPresContext* aPresContext,
ReflowOutput& aDesiredSize,
const ReflowInput& aReflowInput,
nsReflowStatus& aStatus)
{
MarkInReflow();
mPresentationData.flags &= ~NS_MATHML_ERROR;
aDesiredSize.ClearSize();
aDesiredSize.SetBlockStartAscent(0);
aDesiredSize.mBoundingMetrics = nsBoundingMetrics();
int32_t i;
const nsStyleFont* font = StyleFont();
float fontSizeInflation = nsLayoutUtils::FontSizeInflationFor(this);
RefPtr<nsFontMetrics> fm =
nsLayoutUtils::GetFontMetricsForFrame(this, fontSizeInflation);
nscoord axisHeight, em;
GetAxisHeight(aReflowInput.mRenderingContext->GetDrawTarget(), fm, axisHeight);
GetEmHeight(fm, em);
// leading to be left at the top and the bottom of stretched chars
nscoord leading = NSToCoordRound(0.2f * em);
/////////////
// Reflow children
// Asking each child to cache its bounding metrics
// Note that we don't use the base method nsMathMLContainerFrame::Reflow()
// because we want to stretch our fences, separators and stretchy frames using
// the *same* initial aDesiredSize.mBoundingMetrics. If we were to use the base
// method here, our stretchy frames will be stretched and placed, and we may
// end up stretching our fences/separators with a different aDesiredSize.
// XXX The above decision was revisited in bug 121748 and this code can be
// refactored to use nsMathMLContainerFrame::Reflow() at some stage.
nsReflowStatus childStatus;
nsIFrame* firstChild = PrincipalChildList().FirstChild();
nsIFrame* childFrame = firstChild;
nscoord ascent = 0, descent = 0;
if (firstChild || mOpenChar || mCloseChar || mSeparatorsCount > 0) {
// We use the ASCII metrics to get our minimum height. This way,
// if we have borders or a background, they will fit better with
// other elements on the line.
ascent = fm->MaxAscent();
descent = fm->MaxDescent();
}
while (childFrame) {
ReflowOutput childDesiredSize(aReflowInput,
aDesiredSize.mFlags
| NS_REFLOW_CALC_BOUNDING_METRICS);
WritingMode wm = childFrame->GetWritingMode();
LogicalSize availSize = aReflowInput.ComputedSize(wm);
availSize.BSize(wm) = NS_UNCONSTRAINEDSIZE;
ReflowInput childReflowInput(aPresContext, aReflowInput,
childFrame, availSize);
ReflowChild(childFrame, aPresContext, childDesiredSize,
childReflowInput, childStatus);
//NS_ASSERTION(NS_FRAME_IS_COMPLETE(childStatus), "bad status");
SaveReflowAndBoundingMetricsFor(childFrame, childDesiredSize,
childDesiredSize.mBoundingMetrics);
mozilla::WritingMode outerWM = aReflowInput.GetWritingMode();
nscoord childDescent = childDesiredSize.BSize(outerWM) -
childDesiredSize.BlockStartAscent();
if (descent < childDescent)
descent = childDescent;
if (ascent < childDesiredSize.BlockStartAscent())
ascent = childDesiredSize.BlockStartAscent();
childFrame = childFrame->GetNextSibling();
}
/////////////
// Ask stretchy children to stretch themselves
nsBoundingMetrics containerSize;
nsStretchDirection stretchDir = NS_STRETCH_DIRECTION_VERTICAL;
DrawTarget* drawTarget = aReflowInput.mRenderingContext->GetDrawTarget();
GetPreferredStretchSize(drawTarget,
0, /* i.e., without embellishments */
stretchDir, containerSize);
childFrame = firstChild;
while (childFrame) {
nsIMathMLFrame* mathmlChild = do_QueryFrame(childFrame);
if (mathmlChild) {
ReflowOutput childDesiredSize(aReflowInput);
// retrieve the metrics that was stored at the previous pass
GetReflowAndBoundingMetricsFor(childFrame, childDesiredSize,
childDesiredSize.mBoundingMetrics);
mathmlChild->Stretch(drawTarget,
stretchDir, containerSize, childDesiredSize);
// store the updated metrics
SaveReflowAndBoundingMetricsFor(childFrame, childDesiredSize,
childDesiredSize.mBoundingMetrics);
nscoord childDescent = childDesiredSize.Height() - childDesiredSize.BlockStartAscent();
if (descent < childDescent)
descent = childDescent;
if (ascent < childDesiredSize.BlockStartAscent())
ascent = childDesiredSize.BlockStartAscent();
}
childFrame = childFrame->GetNextSibling();
}
// bug 121748: for surrounding fences & separators, use a size that covers everything
GetPreferredStretchSize(drawTarget, STRETCH_CONSIDER_EMBELLISHMENTS,
stretchDir, containerSize);
bool isRTL = StyleVisibility()->mDirection;
// To achieve a minimum size of "1", the container should be enlarged by the
// unstretched metrics of the fences and separators.
ApplyUnstretchedMetrics(aPresContext, drawTarget,
fontSizeInflation, mOpenChar,
containerSize, isRTL);
for (i = 0; i < mSeparatorsCount; i++) {
ApplyUnstretchedMetrics(aPresContext, drawTarget,
fontSizeInflation, &mSeparatorsChar[i],
containerSize, isRTL);
}
ApplyUnstretchedMetrics(aPresContext, drawTarget,
fontSizeInflation, mCloseChar,
containerSize, isRTL);
//////////////////////////////////////////
// Prepare the opening fence, separators, and closing fence, and
// adjust the origin of children.
// we need to center around the axis
nscoord delta = std::max(containerSize.ascent - axisHeight,
containerSize.descent + axisHeight);
containerSize.ascent = delta + axisHeight;
containerSize.descent = delta - axisHeight;
/////////////////
// opening fence ...
ReflowChar(aPresContext, drawTarget, *fm,
fontSizeInflation, mOpenChar,
NS_MATHML_OPERATOR_FORM_PREFIX, font->mScriptLevel,
axisHeight, leading, em, containerSize, ascent, descent, isRTL);
/////////////////
// separators ...
for (i = 0; i < mSeparatorsCount; i++) {
ReflowChar(aPresContext, drawTarget, *fm,
fontSizeInflation, &mSeparatorsChar[i],
NS_MATHML_OPERATOR_FORM_INFIX, font->mScriptLevel,
axisHeight, leading, em, containerSize, ascent, descent, isRTL);
}
/////////////////
// closing fence ...
ReflowChar(aPresContext, drawTarget, *fm,
fontSizeInflation, mCloseChar,
NS_MATHML_OPERATOR_FORM_POSTFIX, font->mScriptLevel,
axisHeight, leading, em, containerSize, ascent, descent, isRTL);
//////////////////
// Adjust the origins of each child.
// and update our bounding metrics
i = 0;
nscoord dx = 0;
nsBoundingMetrics bm;
bool firstTime = true;
nsMathMLChar *leftChar, *rightChar;
if (isRTL) {
leftChar = mCloseChar;
rightChar = mOpenChar;
} else {
leftChar = mOpenChar;
rightChar = mCloseChar;
}
if (leftChar) {
PlaceChar(leftChar, ascent, bm, dx);
aDesiredSize.mBoundingMetrics = bm;
firstTime = false;
}
if (isRTL) {
childFrame = this->GetChildList(nsIFrame::kPrincipalList).LastChild();
} else {
childFrame = firstChild;
}
while (childFrame) {
ReflowOutput childSize(aReflowInput);
GetReflowAndBoundingMetricsFor(childFrame, childSize, bm);
if (firstTime) {
firstTime = false;
aDesiredSize.mBoundingMetrics = bm;
}
else
aDesiredSize.mBoundingMetrics += bm;
FinishReflowChild(childFrame, aPresContext, childSize, nullptr,
dx, ascent - childSize.BlockStartAscent(), 0);
dx += childSize.Width();
if (i < mSeparatorsCount) {
PlaceChar(&mSeparatorsChar[isRTL ? mSeparatorsCount - 1 - i : i],
ascent, bm, dx);
aDesiredSize.mBoundingMetrics += bm;
}
i++;
if (isRTL) {
childFrame = childFrame->GetPrevSibling();
} else {
childFrame = childFrame->GetNextSibling();
}
}
if (rightChar) {
PlaceChar(rightChar, ascent, bm, dx);
if (firstTime)
aDesiredSize.mBoundingMetrics = bm;
else
aDesiredSize.mBoundingMetrics += bm;
}
aDesiredSize.Width() = aDesiredSize.mBoundingMetrics.width;
aDesiredSize.Height() = ascent + descent;
aDesiredSize.SetBlockStartAscent(ascent);
SetBoundingMetrics(aDesiredSize.mBoundingMetrics);
SetReference(nsPoint(0, aDesiredSize.BlockStartAscent()));
// see if we should fix the spacing
FixInterFrameSpacing(aDesiredSize);
// Finished with these:
ClearSavedChildMetrics();
// Set our overflow area
GatherAndStoreOverflow(&aDesiredSize);
aStatus = NS_FRAME_COMPLETE;
NS_FRAME_SET_TRUNCATION(aStatus, aReflowInput, aDesiredSize);
}
static void
GetCharSpacing(nsMathMLChar* aMathMLChar,
nsOperatorFlags aForm,
int32_t aScriptLevel,
nscoord em,
nscoord& aLeftSpace,
nscoord& aRightSpace)
{
nsAutoString data;
aMathMLChar->GetData(data);
nsOperatorFlags flags = 0;
float lspace = 0.0f;
float rspace = 0.0f;
bool found = nsMathMLOperators::LookupOperator(data, aForm,
&flags, &lspace, &rspace);
// We don't want extra space when we are a script
if (found && aScriptLevel > 0) {
lspace /= 2.0f;
rspace /= 2.0f;
}
aLeftSpace = NSToCoordRound(lspace * em);
aRightSpace = NSToCoordRound(rspace * em);
}
// helper functions to perform the common task of formatting our chars
/*static*/ nsresult
nsMathMLmfencedFrame::ReflowChar(nsPresContext* aPresContext,
DrawTarget* aDrawTarget,
nsFontMetrics& aFontMetrics,
float aFontSizeInflation,
nsMathMLChar* aMathMLChar,
nsOperatorFlags aForm,
int32_t aScriptLevel,
nscoord axisHeight,
nscoord leading,
nscoord em,
nsBoundingMetrics& aContainerSize,
nscoord& aAscent,
nscoord& aDescent,
bool aRTL)
{
if (aMathMLChar && 0 < aMathMLChar->Length()) {
nscoord leftSpace;
nscoord rightSpace;
GetCharSpacing(aMathMLChar, aForm, aScriptLevel, em, leftSpace, rightSpace);
// stretch the char to the appropriate height if it is not big enough.
nsBoundingMetrics charSize;
nsresult res = aMathMLChar->Stretch(aPresContext, aDrawTarget,
aFontSizeInflation,
NS_STRETCH_DIRECTION_VERTICAL,
aContainerSize, charSize,
NS_STRETCH_NORMAL, aRTL);
if (NS_STRETCH_DIRECTION_UNSUPPORTED != aMathMLChar->GetStretchDirection()) {
// has changed... so center the char around the axis
nscoord height = charSize.ascent + charSize.descent;
charSize.ascent = height/2 + axisHeight;
charSize.descent = height - charSize.ascent;
}
else {
// either it hasn't changed or stretching the char failed (i.e.,
// nsLayoutUtils::AppUnitBoundsOfString failed)
leading = 0;
if (NS_FAILED(res)) {
nsAutoString data;
aMathMLChar->GetData(data);
nsBoundingMetrics metrics =
nsLayoutUtils::AppUnitBoundsOfString(data.get(), data.Length(),
aFontMetrics, aDrawTarget);
charSize.ascent = metrics.ascent;
charSize.descent = metrics.descent;
charSize.width = metrics.width;
// Set this as the bounding metrics of the MathMLChar to leave
// the necessary room to paint the char.
aMathMLChar->SetBoundingMetrics(charSize);
}
}
if (aAscent < charSize.ascent + leading)
aAscent = charSize.ascent + leading;
if (aDescent < charSize.descent + leading)
aDescent = charSize.descent + leading;
// account the spacing
charSize.width += leftSpace + rightSpace;
// x-origin is used to store lspace ...
// y-origin is used to stored the ascent ...
aMathMLChar->SetRect(nsRect(leftSpace,
charSize.ascent, charSize.width,
charSize.ascent + charSize.descent));
}
return NS_OK;
}
/*static*/ void
nsMathMLmfencedFrame::PlaceChar(nsMathMLChar* aMathMLChar,
nscoord aDesiredAscent,
nsBoundingMetrics& bm,
nscoord& dx)
{
aMathMLChar->GetBoundingMetrics(bm);
// the char's x-origin was used to store lspace ...
// the char's y-origin was used to store the ascent ...
// the char's width was used to store the advance with (with spacing) ...
nsRect rect;
aMathMLChar->GetRect(rect);
nscoord dy = aDesiredAscent - rect.y;
if (aMathMLChar->GetStretchDirection() != NS_STRETCH_DIRECTION_UNSUPPORTED) {
// the stretchy char will be centered around the axis
// so we adjust the returned bounding metrics accordingly
bm.descent = (bm.ascent + bm.descent) - rect.y;
bm.ascent = rect.y;
}
aMathMLChar->SetRect(nsRect(dx + rect.x, dy, bm.width, rect.height));
bm.leftBearing += rect.x;
bm.rightBearing += rect.x;
// return rect.width since it includes lspace and rspace
bm.width = rect.width;
dx += rect.width;
}
static nscoord
GetMaxCharWidth(nsPresContext* aPresContext,
DrawTarget* aDrawTarget,
float aFontSizeInflation,
nsMathMLChar* aMathMLChar,
nsOperatorFlags aForm,
int32_t aScriptLevel,
nscoord em)
{
nscoord width = aMathMLChar->GetMaxWidth(aPresContext, aDrawTarget,
aFontSizeInflation);
if (0 < aMathMLChar->Length()) {
nscoord leftSpace;
nscoord rightSpace;
GetCharSpacing(aMathMLChar, aForm, aScriptLevel, em, leftSpace, rightSpace);
width += leftSpace + rightSpace;
}
return width;
}
/* virtual */ void
nsMathMLmfencedFrame::GetIntrinsicISizeMetrics(nsRenderingContext* aRenderingContext, ReflowOutput& aDesiredSize)
{
nscoord width = 0;
nsPresContext* presContext = PresContext();
const nsStyleFont* font = StyleFont();
float fontSizeInflation = nsLayoutUtils:: FontSizeInflationFor(this);
RefPtr<nsFontMetrics> fm =
nsLayoutUtils::GetFontMetricsForFrame(this, fontSizeInflation);
nscoord em;
GetEmHeight(fm, em);
if (mOpenChar) {
width +=
GetMaxCharWidth(presContext, aRenderingContext->GetDrawTarget(),
fontSizeInflation, mOpenChar,
NS_MATHML_OPERATOR_FORM_PREFIX, font->mScriptLevel, em);
}
int32_t i = 0;
for (nsIFrame* childFrame : PrincipalChildList()) {
// XXX This includes margin while Reflow currently doesn't consider
// margin, so we may end up with too much space, but, with stretchy
// characters, this is an approximation anyway.
width += nsLayoutUtils::IntrinsicForContainer(aRenderingContext, childFrame,
nsLayoutUtils::PREF_ISIZE);
if (i < mSeparatorsCount) {
width +=
GetMaxCharWidth(presContext, aRenderingContext->GetDrawTarget(),
fontSizeInflation, &mSeparatorsChar[i],
NS_MATHML_OPERATOR_FORM_INFIX, font->mScriptLevel, em);
}
i++;
}
if (mCloseChar) {
width +=
GetMaxCharWidth(presContext, aRenderingContext->GetDrawTarget(),
fontSizeInflation, mCloseChar,
NS_MATHML_OPERATOR_FORM_POSTFIX, font->mScriptLevel, em);
}
aDesiredSize.Width() = width;
aDesiredSize.mBoundingMetrics.width = width;
aDesiredSize.mBoundingMetrics.leftBearing = 0;
aDesiredSize.mBoundingMetrics.rightBearing = width;
}
nscoord
nsMathMLmfencedFrame::FixInterFrameSpacing(ReflowOutput& aDesiredSize)
{
nscoord gap = nsMathMLContainerFrame::FixInterFrameSpacing(aDesiredSize);
if (!gap) return 0;
nsRect rect;
if (mOpenChar) {
mOpenChar->GetRect(rect);
rect.MoveBy(gap, 0);
mOpenChar->SetRect(rect);
}
if (mCloseChar) {
mCloseChar->GetRect(rect);
rect.MoveBy(gap, 0);
mCloseChar->SetRect(rect);
}
for (int32_t i = 0; i < mSeparatorsCount; i++) {
mSeparatorsChar[i].GetRect(rect);
rect.MoveBy(gap, 0);
mSeparatorsChar[i].SetRect(rect);
}
return gap;
}
// ----------------------
// the Style System will use these to pass the proper style context to our MathMLChar
nsStyleContext*
nsMathMLmfencedFrame::GetAdditionalStyleContext(int32_t aIndex) const
{
int32_t openIndex = -1;
int32_t closeIndex = -1;
int32_t lastIndex = mSeparatorsCount-1;
if (mOpenChar) {
lastIndex++;
openIndex = lastIndex;
}
if (mCloseChar) {
lastIndex++;
closeIndex = lastIndex;
}
if (aIndex < 0 || aIndex > lastIndex) {
return nullptr;
}
if (aIndex < mSeparatorsCount) {
return mSeparatorsChar[aIndex].GetStyleContext();
}
else if (aIndex == openIndex) {
return mOpenChar->GetStyleContext();
}
else if (aIndex == closeIndex) {
return mCloseChar->GetStyleContext();
}
return nullptr;
}
void
nsMathMLmfencedFrame::SetAdditionalStyleContext(int32_t aIndex,
nsStyleContext* aStyleContext)
{
int32_t openIndex = -1;
int32_t closeIndex = -1;
int32_t lastIndex = mSeparatorsCount-1;
if (mOpenChar) {
lastIndex++;
openIndex = lastIndex;
}
if (mCloseChar) {
lastIndex++;
closeIndex = lastIndex;
}
if (aIndex < 0 || aIndex > lastIndex) {
return;
}
if (aIndex < mSeparatorsCount) {
mSeparatorsChar[aIndex].SetStyleContext(aStyleContext);
}
else if (aIndex == openIndex) {
mOpenChar->SetStyleContext(aStyleContext);
}
else if (aIndex == closeIndex) {
mCloseChar->SetStyleContext(aStyleContext);
}
}