096c9e730e
Backed out changeset d497ae104185 (bug 1908069) Backed out changeset c87b8ca300dc (bug 1908069) Backed out changeset 3e76c02843a7 (bug 1908069) Backed out changeset f4c5983c700b (bug 1908069) Backed out changeset 5468da212605 (bug 1908069) Backed out changeset ab5ab71ddfc4 (bug 1908069) Backed out changeset 21269d373fff (bug 1908069)
631 lines
24 KiB
C++
631 lines
24 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
/* 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 "nsMathMLmmultiscriptsFrame.h"
|
|
|
|
#include "mozilla/dom/Document.h"
|
|
#include "mozilla/dom/Element.h"
|
|
#include "mozilla/PresShell.h"
|
|
#include "mozilla/StaticPrefs_mathml.h"
|
|
#include "nsLayoutUtils.h"
|
|
#include "nsPresContext.h"
|
|
#include <algorithm>
|
|
#include "gfxContext.h"
|
|
#include "gfxMathTable.h"
|
|
#include "gfxTextRun.h"
|
|
|
|
using namespace mozilla;
|
|
|
|
//
|
|
// <mmultiscripts> -- attach prescripts and tensor indices to a base -
|
|
// implementation <msub> -- attach a subscript to a base - implementation
|
|
// <msubsup> -- attach a subscript-superscript pair to a base - implementation
|
|
// <msup> -- attach a superscript to a base - implementation
|
|
//
|
|
|
|
nsIFrame* NS_NewMathMLmmultiscriptsFrame(PresShell* aPresShell,
|
|
ComputedStyle* aStyle) {
|
|
return new (aPresShell)
|
|
nsMathMLmmultiscriptsFrame(aStyle, aPresShell->GetPresContext());
|
|
}
|
|
|
|
NS_IMPL_FRAMEARENA_HELPERS(nsMathMLmmultiscriptsFrame)
|
|
|
|
nsMathMLmmultiscriptsFrame::~nsMathMLmmultiscriptsFrame() = default;
|
|
|
|
uint8_t nsMathMLmmultiscriptsFrame::ScriptIncrement(nsIFrame* aFrame) {
|
|
if (!aFrame) return 0;
|
|
if (mFrames.ContainsFrame(aFrame)) {
|
|
if (mFrames.FirstChild() == aFrame ||
|
|
aFrame->GetContent()->IsMathMLElement(nsGkAtoms::mprescripts_)) {
|
|
return 0; // No script increment for base frames or prescript markers
|
|
}
|
|
return 1;
|
|
}
|
|
return 0; // not a child
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsMathMLmmultiscriptsFrame::TransmitAutomaticData() {
|
|
// if our base is an embellished operator, let its state bubble to us
|
|
mPresentationData.baseFrame = mFrames.FirstChild();
|
|
GetEmbellishDataFrom(mPresentationData.baseFrame, mEmbellishData);
|
|
|
|
// The TeXbook (Ch 17. p.141) says the superscript inherits the compression
|
|
// while the subscript is compressed. So here we collect subscripts and set
|
|
// the compression flag in them.
|
|
|
|
int32_t count = 0;
|
|
bool isSubScript = !mContent->IsMathMLElement(nsGkAtoms::msup_);
|
|
|
|
AutoTArray<nsIFrame*, 8> subScriptFrames;
|
|
nsIFrame* childFrame = mFrames.FirstChild();
|
|
while (childFrame) {
|
|
if (childFrame->GetContent()->IsMathMLElement(nsGkAtoms::mprescripts_)) {
|
|
// mprescripts frame
|
|
} else if (0 == count) {
|
|
// base frame
|
|
} else {
|
|
// super/subscript block
|
|
if (isSubScript) {
|
|
// subscript
|
|
subScriptFrames.AppendElement(childFrame);
|
|
} else {
|
|
// superscript
|
|
}
|
|
PropagateFrameFlagFor(childFrame, NS_FRAME_MATHML_SCRIPT_DESCENDANT);
|
|
isSubScript = !isSubScript;
|
|
}
|
|
count++;
|
|
childFrame = childFrame->GetNextSibling();
|
|
}
|
|
for (int32_t i = subScriptFrames.Length() - 1; i >= 0; i--) {
|
|
childFrame = subScriptFrames[i];
|
|
PropagatePresentationDataFor(childFrame, NS_MATHML_COMPRESSED,
|
|
NS_MATHML_COMPRESSED);
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
/* virtual */
|
|
nsresult nsMathMLmmultiscriptsFrame::Place(DrawTarget* aDrawTarget,
|
|
bool aPlaceOrigin,
|
|
ReflowOutput& aDesiredSize) {
|
|
nscoord subScriptShift = 0;
|
|
nscoord supScriptShift = 0;
|
|
float fontSizeInflation = nsLayoutUtils::FontSizeInflationFor(this);
|
|
|
|
return PlaceMultiScript(PresContext(), aDrawTarget, aPlaceOrigin,
|
|
aDesiredSize, this, subScriptShift, supScriptShift,
|
|
fontSizeInflation);
|
|
}
|
|
|
|
// exported routine that both munderover and mmultiscripts share.
|
|
// munderover uses this when movablelimits is set.
|
|
nsresult nsMathMLmmultiscriptsFrame::PlaceMultiScript(
|
|
nsPresContext* aPresContext, DrawTarget* aDrawTarget, bool aPlaceOrigin,
|
|
ReflowOutput& aDesiredSize, nsMathMLContainerFrame* aFrame,
|
|
nscoord aUserSubScriptShift, nscoord aUserSupScriptShift,
|
|
float aFontSizeInflation) {
|
|
nsAtom* tag = aFrame->GetContent()->NodeInfo()->NameAtom();
|
|
|
|
// This function deals with both munderover etc. as well as msubsup etc.
|
|
// As the former behaves identically to the later, we treat it as such
|
|
// to avoid additional checks later.
|
|
if (aFrame->GetContent()->IsMathMLElement(nsGkAtoms::mover_))
|
|
tag = nsGkAtoms::msup_;
|
|
else if (aFrame->GetContent()->IsMathMLElement(nsGkAtoms::munder_))
|
|
tag = nsGkAtoms::msub_;
|
|
else if (aFrame->GetContent()->IsMathMLElement(nsGkAtoms::munderover_))
|
|
tag = nsGkAtoms::msubsup_;
|
|
|
|
nsBoundingMetrics bmFrame;
|
|
|
|
nscoord minShiftFromXHeight, subDrop, supDrop;
|
|
|
|
////////////////////////////////////////
|
|
// Initialize super/sub shifts that
|
|
// depend only on the current font
|
|
////////////////////////////////////////
|
|
|
|
nsIFrame* baseFrame = aFrame->PrincipalChildList().FirstChild();
|
|
|
|
if (!baseFrame) {
|
|
if (tag == nsGkAtoms::mmultiscripts_)
|
|
aFrame->ReportErrorToConsole("NoBase");
|
|
else
|
|
aFrame->ReportChildCountError();
|
|
return aFrame->PlaceAsMrow(aDrawTarget, aPlaceOrigin, aDesiredSize);
|
|
}
|
|
|
|
// get x-height (an ex)
|
|
const nsStyleFont* font = aFrame->StyleFont();
|
|
RefPtr<nsFontMetrics> fm =
|
|
nsLayoutUtils::GetFontMetricsForFrame(baseFrame, aFontSizeInflation);
|
|
|
|
nscoord xHeight = fm->XHeight();
|
|
|
|
nscoord oneDevPixel = fm->AppUnitsPerDevPixel();
|
|
RefPtr<gfxFont> mathFont = fm->GetThebesFontGroup()->GetFirstMathFont();
|
|
// scriptspace from TeX for extra spacing after sup/subscript
|
|
nscoord scriptSpace;
|
|
if (mathFont) {
|
|
scriptSpace = mathFont->MathTable()->Constant(
|
|
gfxMathTable::SpaceAfterScript, oneDevPixel);
|
|
} else {
|
|
// (0.5pt in plain TeX)
|
|
scriptSpace = nsPresContext::CSSPointsToAppUnits(0.5f);
|
|
}
|
|
|
|
// Try and read sub and sup drops from the MATH table.
|
|
if (mathFont) {
|
|
subDrop = mathFont->MathTable()->Constant(
|
|
gfxMathTable::SubscriptBaselineDropMin, oneDevPixel);
|
|
supDrop = mathFont->MathTable()->Constant(
|
|
gfxMathTable::SuperscriptBaselineDropMax, oneDevPixel);
|
|
}
|
|
|
|
// force the scriptSpace to be at least 1 pixel
|
|
nscoord onePixel = nsPresContext::CSSPixelsToAppUnits(1);
|
|
scriptSpace = std::max(onePixel, scriptSpace);
|
|
|
|
/////////////////////////////////////
|
|
// first the shift for the subscript
|
|
|
|
nscoord subScriptShift;
|
|
if (mathFont) {
|
|
// Try and get the sub script shift from the MATH table. Note that contrary
|
|
// to TeX we only have one parameter.
|
|
subScriptShift = mathFont->MathTable()->Constant(
|
|
gfxMathTable::SubscriptShiftDown, oneDevPixel);
|
|
} else {
|
|
// subScriptShift{1,2}
|
|
// = minimum amount to shift the subscript down
|
|
// = sub{1,2} in TeXbook
|
|
// subScriptShift1 = subscriptshift attribute * x-height
|
|
nscoord subScriptShift1, subScriptShift2;
|
|
// Get subScriptShift{1,2} default from font
|
|
GetSubScriptShifts(fm, subScriptShift1, subScriptShift2);
|
|
if (tag == nsGkAtoms::msub_) {
|
|
subScriptShift = subScriptShift1;
|
|
} else {
|
|
subScriptShift = std::max(subScriptShift1, subScriptShift2);
|
|
}
|
|
}
|
|
|
|
if (0 < aUserSubScriptShift) {
|
|
// the user has set the subscriptshift attribute
|
|
subScriptShift = std::max(subScriptShift, aUserSubScriptShift);
|
|
}
|
|
|
|
/////////////////////////////////////
|
|
// next the shift for the superscript
|
|
|
|
nscoord supScriptShift;
|
|
nsPresentationData presentationData;
|
|
aFrame->GetPresentationData(presentationData);
|
|
if (mathFont) {
|
|
// Try and get the super script shift from the MATH table. Note that
|
|
// contrary to TeX we only have two parameters.
|
|
supScriptShift = mathFont->MathTable()->Constant(
|
|
NS_MATHML_IS_COMPRESSED(presentationData.flags)
|
|
? gfxMathTable::SuperscriptShiftUpCramped
|
|
: gfxMathTable::SuperscriptShiftUp,
|
|
oneDevPixel);
|
|
} else {
|
|
// supScriptShift{1,2,3}
|
|
// = minimum amount to shift the supscript up
|
|
// = sup{1,2,3} in TeX
|
|
// supScriptShift1 = superscriptshift attribute * x-height
|
|
// Note that there are THREE values for supscript shifts depending
|
|
// on the current style
|
|
nscoord supScriptShift1, supScriptShift2, supScriptShift3;
|
|
// Set supScriptShift{1,2,3} default from font
|
|
GetSupScriptShifts(fm, supScriptShift1, supScriptShift2, supScriptShift3);
|
|
|
|
// get sup script shift depending on current script level and display style
|
|
// Rule 18c, App. G, TeXbook
|
|
if (font->mMathDepth == 0 && font->mMathStyle == StyleMathStyle::Normal &&
|
|
!NS_MATHML_IS_COMPRESSED(presentationData.flags)) {
|
|
// Style D in TeXbook
|
|
supScriptShift = supScriptShift1;
|
|
} else if (NS_MATHML_IS_COMPRESSED(presentationData.flags)) {
|
|
// Style C' in TeXbook = D',T',S',SS'
|
|
supScriptShift = supScriptShift3;
|
|
} else {
|
|
// everything else = T,S,SS
|
|
supScriptShift = supScriptShift2;
|
|
}
|
|
}
|
|
|
|
if (0 < aUserSupScriptShift) {
|
|
// the user has set the supscriptshift attribute
|
|
supScriptShift = std::max(supScriptShift, aUserSupScriptShift);
|
|
}
|
|
|
|
////////////////////////////////////
|
|
// Get the children's sizes
|
|
////////////////////////////////////
|
|
|
|
const WritingMode wm(aDesiredSize.GetWritingMode());
|
|
nscoord width = 0, prescriptsWidth = 0, rightBearing = 0;
|
|
nscoord minSubScriptShift = 0, minSupScriptShift = 0;
|
|
nscoord trySubScriptShift = subScriptShift;
|
|
nscoord trySupScriptShift = supScriptShift;
|
|
nscoord maxSubScriptShift = subScriptShift;
|
|
nscoord maxSupScriptShift = supScriptShift;
|
|
ReflowOutput baseSize(wm);
|
|
ReflowOutput subScriptSize(wm);
|
|
ReflowOutput supScriptSize(wm);
|
|
ReflowOutput multiSubSize(wm), multiSupSize(wm);
|
|
baseFrame = nullptr;
|
|
nsIFrame* subScriptFrame = nullptr;
|
|
nsIFrame* supScriptFrame = nullptr;
|
|
nsIFrame* prescriptsFrame = nullptr; // frame of <mprescripts/>, if there.
|
|
|
|
bool firstPrescriptsPair = false;
|
|
nsBoundingMetrics bmBase, bmSubScript, bmSupScript, bmMultiSub, bmMultiSup;
|
|
multiSubSize.SetBlockStartAscent(-0x7FFFFFFF);
|
|
multiSupSize.SetBlockStartAscent(-0x7FFFFFFF);
|
|
bmMultiSub.ascent = bmMultiSup.ascent = -0x7FFFFFFF;
|
|
bmMultiSub.descent = bmMultiSup.descent = -0x7FFFFFFF;
|
|
nscoord italicCorrection = 0;
|
|
|
|
nsBoundingMetrics boundingMetrics;
|
|
boundingMetrics.width = 0;
|
|
boundingMetrics.ascent = boundingMetrics.descent = -0x7FFFFFFF;
|
|
aDesiredSize.Width() = aDesiredSize.Height() = 0;
|
|
|
|
int32_t count = 0;
|
|
|
|
// Boolean to determine whether the current child is a subscript.
|
|
// Note that only msup starts with a superscript.
|
|
bool isSubScript = (tag != nsGkAtoms::msup_);
|
|
|
|
nsIFrame* childFrame = aFrame->PrincipalChildList().FirstChild();
|
|
while (childFrame) {
|
|
if (childFrame->GetContent()->IsMathMLElement(nsGkAtoms::mprescripts_)) {
|
|
if (tag != nsGkAtoms::mmultiscripts_) {
|
|
if (aPlaceOrigin) {
|
|
aFrame->ReportInvalidChildError(nsGkAtoms::mprescripts_);
|
|
}
|
|
return aFrame->PlaceAsMrow(aDrawTarget, aPlaceOrigin, aDesiredSize);
|
|
}
|
|
if (prescriptsFrame) {
|
|
// duplicate <mprescripts/> found
|
|
// report an error, encourage people to get their markups in order
|
|
if (aPlaceOrigin) {
|
|
aFrame->ReportErrorToConsole("DuplicateMprescripts");
|
|
}
|
|
return aFrame->PlaceAsMrow(aDrawTarget, aPlaceOrigin, aDesiredSize);
|
|
}
|
|
if (!isSubScript) {
|
|
if (aPlaceOrigin) {
|
|
aFrame->ReportErrorToConsole("SubSupMismatch");
|
|
}
|
|
return aFrame->PlaceAsMrow(aDrawTarget, aPlaceOrigin, aDesiredSize);
|
|
}
|
|
|
|
prescriptsFrame = childFrame;
|
|
firstPrescriptsPair = true;
|
|
} else if (0 == count) {
|
|
// base
|
|
baseFrame = childFrame;
|
|
GetReflowAndBoundingMetricsFor(baseFrame, baseSize, bmBase);
|
|
|
|
if (tag != nsGkAtoms::msub_) {
|
|
// Apply italics correction if there is the potential for a
|
|
// postsupscript.
|
|
GetItalicCorrection(bmBase, italicCorrection);
|
|
// If italics correction is applied, we always add "a little to spare"
|
|
// (see TeXbook Ch.11, p.64), as we estimate the italic creation
|
|
// ourselves and it isn't the same as TeX.
|
|
italicCorrection += onePixel;
|
|
}
|
|
|
|
// we update boundingMetrics.{ascent,descent} with that
|
|
// of the baseFrame only after processing all the sup/sub pairs
|
|
boundingMetrics.width = bmBase.width;
|
|
boundingMetrics.rightBearing = bmBase.rightBearing;
|
|
boundingMetrics.leftBearing = bmBase.leftBearing; // until overwritten
|
|
} else {
|
|
// super/subscript block
|
|
if (isSubScript) {
|
|
// subscript
|
|
subScriptFrame = childFrame;
|
|
GetReflowAndBoundingMetricsFor(subScriptFrame, subScriptSize,
|
|
bmSubScript);
|
|
if (!mathFont) {
|
|
// get the subdrop from the subscript font
|
|
GetSubDropFromChild(subScriptFrame, subDrop, aFontSizeInflation);
|
|
}
|
|
|
|
// parameter v, Rule 18a, App. G, TeXbook
|
|
minSubScriptShift = bmBase.descent + subDrop;
|
|
trySubScriptShift = std::max(minSubScriptShift, subScriptShift);
|
|
multiSubSize.SetBlockStartAscent(std::max(
|
|
multiSubSize.BlockStartAscent(), subScriptSize.BlockStartAscent()));
|
|
bmMultiSub.ascent = std::max(bmMultiSub.ascent, bmSubScript.ascent);
|
|
bmMultiSub.descent = std::max(bmMultiSub.descent, bmSubScript.descent);
|
|
multiSubSize.Height() =
|
|
std::max(multiSubSize.Height(),
|
|
subScriptSize.Height() - subScriptSize.BlockStartAscent());
|
|
if (bmSubScript.width) width = bmSubScript.width + scriptSpace;
|
|
rightBearing = bmSubScript.rightBearing;
|
|
|
|
if (tag == nsGkAtoms::msub_) {
|
|
boundingMetrics.rightBearing = boundingMetrics.width + rightBearing;
|
|
boundingMetrics.width += width;
|
|
|
|
nscoord subscriptTopMax;
|
|
if (mathFont) {
|
|
subscriptTopMax = mathFont->MathTable()->Constant(
|
|
gfxMathTable::SubscriptTopMax, oneDevPixel);
|
|
} else {
|
|
// get min subscript shift limit from x-height
|
|
// = h(x) - 4/5 * sigma_5, Rule 18b, App. G, TeXbook
|
|
subscriptTopMax = NSToCoordRound((4.0f / 5.0f) * xHeight);
|
|
}
|
|
nscoord minShiftFromXHeight = bmSubScript.ascent - subscriptTopMax;
|
|
maxSubScriptShift = std::max(trySubScriptShift, minShiftFromXHeight);
|
|
|
|
maxSubScriptShift = std::max(maxSubScriptShift, trySubScriptShift);
|
|
trySubScriptShift = subScriptShift;
|
|
}
|
|
} else {
|
|
// supscript
|
|
supScriptFrame = childFrame;
|
|
GetReflowAndBoundingMetricsFor(supScriptFrame, supScriptSize,
|
|
bmSupScript);
|
|
if (!mathFont) {
|
|
// get the supdrop from the supscript font
|
|
GetSupDropFromChild(supScriptFrame, supDrop, aFontSizeInflation);
|
|
}
|
|
// parameter u, Rule 18a, App. G, TeXbook
|
|
minSupScriptShift = bmBase.ascent - supDrop;
|
|
nscoord superscriptBottomMin;
|
|
if (mathFont) {
|
|
superscriptBottomMin = mathFont->MathTable()->Constant(
|
|
gfxMathTable::SuperscriptBottomMin, oneDevPixel);
|
|
} else {
|
|
// get min supscript shift limit from x-height
|
|
// = d(x) + 1/4 * sigma_5, Rule 18c, App. G, TeXbook
|
|
superscriptBottomMin = NSToCoordRound((1.0f / 4.0f) * xHeight);
|
|
}
|
|
minShiftFromXHeight = bmSupScript.descent + superscriptBottomMin;
|
|
trySupScriptShift = std::max(
|
|
minSupScriptShift, std::max(minShiftFromXHeight, supScriptShift));
|
|
multiSupSize.SetBlockStartAscent(std::max(
|
|
multiSupSize.BlockStartAscent(), supScriptSize.BlockStartAscent()));
|
|
bmMultiSup.ascent = std::max(bmMultiSup.ascent, bmSupScript.ascent);
|
|
bmMultiSup.descent = std::max(bmMultiSup.descent, bmSupScript.descent);
|
|
multiSupSize.Height() =
|
|
std::max(multiSupSize.Height(),
|
|
supScriptSize.Height() - supScriptSize.BlockStartAscent());
|
|
|
|
if (bmSupScript.width)
|
|
width = std::max(width, bmSupScript.width + scriptSpace);
|
|
|
|
if (!prescriptsFrame) { // we are still looping over base & postscripts
|
|
rightBearing = std::max(rightBearing,
|
|
italicCorrection + bmSupScript.rightBearing);
|
|
boundingMetrics.rightBearing = boundingMetrics.width + rightBearing;
|
|
boundingMetrics.width += width;
|
|
} else {
|
|
prescriptsWidth += width;
|
|
if (firstPrescriptsPair) {
|
|
firstPrescriptsPair = false;
|
|
boundingMetrics.leftBearing =
|
|
std::min(bmSubScript.leftBearing, bmSupScript.leftBearing);
|
|
}
|
|
}
|
|
width = rightBearing = 0;
|
|
|
|
// negotiate between the various shifts so that
|
|
// there is enough gap between the sup and subscripts
|
|
// Rule 18e, App. G, TeXbook
|
|
if (tag == nsGkAtoms::mmultiscripts_ || tag == nsGkAtoms::msubsup_) {
|
|
nscoord subSuperscriptGapMin;
|
|
if (mathFont) {
|
|
subSuperscriptGapMin = mathFont->MathTable()->Constant(
|
|
gfxMathTable::SubSuperscriptGapMin, oneDevPixel);
|
|
} else {
|
|
nscoord ruleSize;
|
|
GetRuleThickness(aDrawTarget, fm, ruleSize);
|
|
subSuperscriptGapMin = 4 * ruleSize;
|
|
}
|
|
nscoord gap = (trySupScriptShift - bmSupScript.descent) -
|
|
(bmSubScript.ascent - trySubScriptShift);
|
|
if (gap < subSuperscriptGapMin) {
|
|
// adjust trySubScriptShift to get a gap of subSuperscriptGapMin
|
|
trySubScriptShift += subSuperscriptGapMin - gap;
|
|
}
|
|
|
|
// next we want to ensure that the bottom of the superscript
|
|
// will be > superscriptBottomMaxWithSubscript
|
|
nscoord superscriptBottomMaxWithSubscript;
|
|
if (mathFont) {
|
|
superscriptBottomMaxWithSubscript = mathFont->MathTable()->Constant(
|
|
gfxMathTable::SuperscriptBottomMaxWithSubscript, oneDevPixel);
|
|
} else {
|
|
superscriptBottomMaxWithSubscript =
|
|
NSToCoordRound((4.0f / 5.0f) * xHeight);
|
|
}
|
|
gap = superscriptBottomMaxWithSubscript -
|
|
(trySupScriptShift - bmSupScript.descent);
|
|
if (gap > 0) {
|
|
trySupScriptShift += gap;
|
|
trySubScriptShift -= gap;
|
|
}
|
|
}
|
|
|
|
maxSubScriptShift = std::max(maxSubScriptShift, trySubScriptShift);
|
|
maxSupScriptShift = std::max(maxSupScriptShift, trySupScriptShift);
|
|
|
|
trySubScriptShift = subScriptShift;
|
|
trySupScriptShift = supScriptShift;
|
|
}
|
|
|
|
isSubScript = !isSubScript;
|
|
}
|
|
count++;
|
|
childFrame = childFrame->GetNextSibling();
|
|
}
|
|
|
|
// NoBase error may also have been reported above
|
|
if ((count != 2 && (tag == nsGkAtoms::msup_ || tag == nsGkAtoms::msub_)) ||
|
|
(count != 3 && tag == nsGkAtoms::msubsup_) || !baseFrame ||
|
|
(!isSubScript && tag == nsGkAtoms::mmultiscripts_)) {
|
|
// report an error, encourage people to get their markups in order
|
|
if (aPlaceOrigin) {
|
|
if ((count != 2 &&
|
|
(tag == nsGkAtoms::msup_ || tag == nsGkAtoms::msub_)) ||
|
|
(count != 3 && tag == nsGkAtoms::msubsup_)) {
|
|
aFrame->ReportChildCountError();
|
|
} else if (!baseFrame) {
|
|
aFrame->ReportErrorToConsole("NoBase");
|
|
} else {
|
|
aFrame->ReportErrorToConsole("SubSupMismatch");
|
|
}
|
|
}
|
|
return aFrame->PlaceAsMrow(aDrawTarget, aPlaceOrigin, aDesiredSize);
|
|
}
|
|
|
|
// we left out the width of prescripts, so ...
|
|
boundingMetrics.rightBearing += prescriptsWidth;
|
|
boundingMetrics.width += prescriptsWidth;
|
|
|
|
// Zero out the shifts in where a frame isn't present to avoid the potential
|
|
// for overflow.
|
|
if (!subScriptFrame) maxSubScriptShift = 0;
|
|
if (!supScriptFrame) maxSupScriptShift = 0;
|
|
|
|
// we left out the base during our bounding box updates, so ...
|
|
if (tag == nsGkAtoms::msub_) {
|
|
boundingMetrics.ascent =
|
|
std::max(bmBase.ascent, bmMultiSub.ascent - maxSubScriptShift);
|
|
} else {
|
|
boundingMetrics.ascent =
|
|
std::max(bmBase.ascent, (bmMultiSup.ascent + maxSupScriptShift));
|
|
}
|
|
if (tag == nsGkAtoms::msup_) {
|
|
boundingMetrics.descent =
|
|
std::max(bmBase.descent, bmMultiSup.descent - maxSupScriptShift);
|
|
} else {
|
|
boundingMetrics.descent =
|
|
std::max(bmBase.descent, (bmMultiSub.descent + maxSubScriptShift));
|
|
}
|
|
aFrame->SetBoundingMetrics(boundingMetrics);
|
|
|
|
// get the reflow metrics ...
|
|
aDesiredSize.SetBlockStartAscent(
|
|
std::max(baseSize.BlockStartAscent(),
|
|
std::max(multiSubSize.BlockStartAscent() - maxSubScriptShift,
|
|
multiSupSize.BlockStartAscent() + maxSupScriptShift)));
|
|
aDesiredSize.Height() =
|
|
aDesiredSize.BlockStartAscent() +
|
|
std::max(baseSize.Height() - baseSize.BlockStartAscent(),
|
|
std::max(multiSubSize.Height() + maxSubScriptShift,
|
|
multiSupSize.Height() - maxSupScriptShift));
|
|
aDesiredSize.Width() = boundingMetrics.width;
|
|
aDesiredSize.mBoundingMetrics = boundingMetrics;
|
|
|
|
aFrame->SetReference(nsPoint(0, aDesiredSize.BlockStartAscent()));
|
|
|
|
//////////////////
|
|
// Place Children
|
|
|
|
// Place prescripts, followed by base, and then postscripts.
|
|
// The list of frames is in the order: {base} {postscripts} {prescripts}
|
|
// We go over the list in a circular manner, starting at <prescripts/>
|
|
|
|
if (aPlaceOrigin) {
|
|
nscoord dx = 0, dy = 0;
|
|
|
|
// With msub and msup there is only one element and
|
|
// subscriptFrame/supScriptFrame have already been set above where
|
|
// relevant. In these cases we skip to the reflow part.
|
|
if (tag == nsGkAtoms::msub_ || tag == nsGkAtoms::msup_)
|
|
count = 1;
|
|
else
|
|
count = 0;
|
|
childFrame = prescriptsFrame;
|
|
bool isPreScript = true;
|
|
do {
|
|
if (!childFrame) { // end of prescripts,
|
|
isPreScript = false;
|
|
// place the base ...
|
|
childFrame = baseFrame;
|
|
dy = aDesiredSize.BlockStartAscent() - baseSize.BlockStartAscent();
|
|
FinishReflowChild(
|
|
baseFrame, aPresContext, baseSize, nullptr,
|
|
aFrame->MirrorIfRTL(aDesiredSize.Width(), baseSize.Width(), dx), dy,
|
|
ReflowChildFlags::Default);
|
|
dx += bmBase.width;
|
|
} else if (prescriptsFrame == childFrame) {
|
|
// Clear reflow flags of prescripts frame.
|
|
prescriptsFrame->DidReflow(aPresContext, nullptr);
|
|
} else {
|
|
// process each sup/sub pair
|
|
if (0 == count) {
|
|
subScriptFrame = childFrame;
|
|
count = 1;
|
|
} else if (1 == count) {
|
|
if (tag != nsGkAtoms::msub_) supScriptFrame = childFrame;
|
|
count = 0;
|
|
|
|
// get the ascent/descent of sup/subscripts stored in their rects
|
|
// rect.x = descent, rect.y = ascent
|
|
if (subScriptFrame)
|
|
GetReflowAndBoundingMetricsFor(subScriptFrame, subScriptSize,
|
|
bmSubScript);
|
|
if (supScriptFrame)
|
|
GetReflowAndBoundingMetricsFor(supScriptFrame, supScriptSize,
|
|
bmSupScript);
|
|
|
|
width = std::max(subScriptSize.Width(), supScriptSize.Width());
|
|
|
|
if (subScriptFrame) {
|
|
nscoord x = dx;
|
|
// prescripts should be right aligned
|
|
// https://bugzilla.mozilla.org/show_bug.cgi?id=928675
|
|
if (isPreScript) x += width - subScriptSize.Width();
|
|
dy = aDesiredSize.BlockStartAscent() -
|
|
subScriptSize.BlockStartAscent() + maxSubScriptShift;
|
|
FinishReflowChild(subScriptFrame, aPresContext, subScriptSize,
|
|
nullptr,
|
|
aFrame->MirrorIfRTL(aDesiredSize.Width(),
|
|
subScriptSize.Width(), x),
|
|
dy, ReflowChildFlags::Default);
|
|
}
|
|
|
|
if (supScriptFrame) {
|
|
nscoord x = dx;
|
|
if (isPreScript) {
|
|
x += width - supScriptSize.Width();
|
|
} else {
|
|
// post superscripts are shifted by the italic correction value
|
|
x += italicCorrection;
|
|
}
|
|
dy = aDesiredSize.BlockStartAscent() -
|
|
supScriptSize.BlockStartAscent() - maxSupScriptShift;
|
|
FinishReflowChild(supScriptFrame, aPresContext, supScriptSize,
|
|
nullptr,
|
|
aFrame->MirrorIfRTL(aDesiredSize.Width(),
|
|
supScriptSize.Width(), x),
|
|
dy, ReflowChildFlags::Default);
|
|
}
|
|
dx += width + scriptSpace;
|
|
}
|
|
}
|
|
childFrame = childFrame->GetNextSibling();
|
|
} while (prescriptsFrame != childFrame);
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|