forked from mirrors/gecko-dev
5730ee0ca5
Extend the per-frame-class bit we have to devirtualize IsLeaf to also devirtualize IsFrameOfType. That is, move this data to FrameClasses.py. This was done by going through all the frame classes, trying to preserve behavior. The only quirky thing is that I had to add two more trivial frame classes, `nsAudioFrame` for audio elements, and `nsFloatingFirstLetterFrame`. That's because these frame classes were returning different answers at runtime, but they do this only on conditions that trigger frame reconstruction (floating, and being an audio element, respectively). Differential Revision: https://phabricator.services.mozilla.com/D194703
299 lines
11 KiB
C++
299 lines
11 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/. */
|
|
|
|
#ifndef nsMathMLFrame_h___
|
|
#define nsMathMLFrame_h___
|
|
|
|
#include "mozilla/Attributes.h"
|
|
#include "nsFontMetrics.h"
|
|
#include "nsMathMLOperators.h"
|
|
#include "nsIMathMLFrame.h"
|
|
#include "nsBoundingMetrics.h"
|
|
#include "nsIFrame.h"
|
|
|
|
class nsMathMLChar;
|
|
class nsCSSValue;
|
|
|
|
namespace mozilla {
|
|
class nsDisplayListBuilder;
|
|
class nsDisplayListSet;
|
|
} // namespace mozilla
|
|
|
|
// Concrete base class with default methods that derived MathML frames can
|
|
// override
|
|
class nsMathMLFrame : public nsIMathMLFrame {
|
|
public:
|
|
// nsIMathMLFrame ---
|
|
|
|
virtual bool IsSpaceLike() override {
|
|
return NS_MATHML_IS_SPACE_LIKE(mPresentationData.flags);
|
|
}
|
|
|
|
NS_IMETHOD
|
|
GetBoundingMetrics(nsBoundingMetrics& aBoundingMetrics) override {
|
|
aBoundingMetrics = mBoundingMetrics;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHOD
|
|
SetBoundingMetrics(const nsBoundingMetrics& aBoundingMetrics) override {
|
|
mBoundingMetrics = aBoundingMetrics;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHOD
|
|
SetReference(const nsPoint& aReference) override {
|
|
mReference = aReference;
|
|
return NS_OK;
|
|
}
|
|
|
|
virtual eMathMLFrameType GetMathMLFrameType() override;
|
|
|
|
NS_IMETHOD
|
|
Stretch(mozilla::gfx::DrawTarget* aDrawTarget,
|
|
nsStretchDirection aStretchDirection,
|
|
nsBoundingMetrics& aContainerSize,
|
|
mozilla::ReflowOutput& aDesiredStretchSize) override {
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHOD
|
|
GetEmbellishData(nsEmbellishData& aEmbellishData) override {
|
|
aEmbellishData = mEmbellishData;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHOD
|
|
GetPresentationData(nsPresentationData& aPresentationData) override {
|
|
aPresentationData = mPresentationData;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHOD
|
|
InheritAutomaticData(nsIFrame* aParent) override;
|
|
|
|
NS_IMETHOD
|
|
TransmitAutomaticData() override { return NS_OK; }
|
|
|
|
NS_IMETHOD
|
|
UpdatePresentationData(uint32_t aFlagsValues,
|
|
uint32_t aFlagsToUpdate) override;
|
|
|
|
NS_IMETHOD
|
|
UpdatePresentationDataFromChildAt(int32_t aFirstIndex, int32_t aLastIndex,
|
|
uint32_t aFlagsValues,
|
|
uint32_t aFlagsToUpdate) override {
|
|
return NS_OK;
|
|
}
|
|
|
|
uint8_t ScriptIncrement(nsIFrame* aFrame) override { return 0; }
|
|
|
|
bool IsMrowLike() override { return false; }
|
|
|
|
// helper to get the mEmbellishData of a frame
|
|
// The MathML REC precisely defines an "embellished operator" as:
|
|
// - an <mo> element;
|
|
// - or one of the elements <msub>, <msup>, <msubsup>, <munder>, <mover>,
|
|
// <munderover>, <mmultiscripts>, <mfrac>, or <semantics>, whose first
|
|
// argument exists and is an embellished operator;
|
|
//- or one of the elements <mstyle>, <mphantom>, or <mpadded>, such that
|
|
// an <mrow> containing the same arguments would be an embellished
|
|
// operator;
|
|
// - or an <maction> element whose selected subexpression exists and is an
|
|
// embellished operator;
|
|
// - or an <mrow> whose arguments consist (in any order) of one embellished
|
|
// operator and zero or more spacelike elements.
|
|
static void GetEmbellishDataFrom(nsIFrame* aFrame,
|
|
nsEmbellishData& aEmbellishData);
|
|
|
|
// helper to get the presentation data of a frame. If aClimbTree is
|
|
// set to true and the frame happens to be surrounded by non-MathML
|
|
// helper frames needed for its support, we walk up the frame hierarchy
|
|
// until we reach a MathML ancestor or the <root> math element.
|
|
static void GetPresentationDataFrom(nsIFrame* aFrame,
|
|
nsPresentationData& aPresentationData,
|
|
bool aClimbTree = true);
|
|
|
|
// utilities to parse and retrieve numeric values in CSS units
|
|
// All values are stored in twips.
|
|
// @pre aLengthValue is the default length value of the attribute.
|
|
// @post aLengthValue is the length value computed from the attribute.
|
|
static void ParseNumericValue(const nsString& aString, nscoord* aLengthValue,
|
|
uint32_t aFlags, nsPresContext* aPresContext,
|
|
mozilla::ComputedStyle* aComputedStyle,
|
|
float aFontSizeInflation);
|
|
|
|
static nscoord CalcLength(nsPresContext* aPresContext,
|
|
mozilla::ComputedStyle* aComputedStyle,
|
|
const nsCSSValue& aCSSValue,
|
|
float aFontSizeInflation);
|
|
|
|
static eMathMLFrameType GetMathMLFrameTypeFor(nsIFrame* aFrame) {
|
|
if (aFrame->IsMathMLFrame()) {
|
|
if (nsIMathMLFrame* mathMLFrame = do_QueryFrame(aFrame)) {
|
|
return mathMLFrame->GetMathMLFrameType();
|
|
}
|
|
}
|
|
return eMathMLFrameType_UNKNOWN;
|
|
}
|
|
|
|
// estimate of the italic correction
|
|
static void GetItalicCorrection(nsBoundingMetrics& aBoundingMetrics,
|
|
nscoord& aItalicCorrection) {
|
|
aItalicCorrection = aBoundingMetrics.rightBearing - aBoundingMetrics.width;
|
|
if (0 > aItalicCorrection) {
|
|
aItalicCorrection = 0;
|
|
}
|
|
}
|
|
|
|
static void GetItalicCorrection(nsBoundingMetrics& aBoundingMetrics,
|
|
nscoord& aLeftItalicCorrection,
|
|
nscoord& aRightItalicCorrection) {
|
|
aRightItalicCorrection =
|
|
aBoundingMetrics.rightBearing - aBoundingMetrics.width;
|
|
if (0 > aRightItalicCorrection) {
|
|
aRightItalicCorrection = 0;
|
|
}
|
|
aLeftItalicCorrection = -aBoundingMetrics.leftBearing;
|
|
if (0 > aLeftItalicCorrection) {
|
|
aLeftItalicCorrection = 0;
|
|
}
|
|
}
|
|
|
|
// helper methods for getting sup/subdrop's from a child
|
|
static void GetSubDropFromChild(nsIFrame* aChild, nscoord& aSubDrop,
|
|
float aFontSizeInflation);
|
|
|
|
static void GetSupDropFromChild(nsIFrame* aChild, nscoord& aSupDrop,
|
|
float aFontSizeInflation);
|
|
|
|
static void GetSkewCorrectionFromChild(nsIFrame* aChild,
|
|
nscoord& aSkewCorrection) {
|
|
// default is 0
|
|
// individual classes should over-ride this method if necessary
|
|
aSkewCorrection = 0;
|
|
}
|
|
|
|
// 2 levels of subscript shifts
|
|
static void GetSubScriptShifts(nsFontMetrics* fm, nscoord& aSubScriptShift1,
|
|
nscoord& aSubScriptShift2) {
|
|
nscoord xHeight = fm->XHeight();
|
|
aSubScriptShift1 = NSToCoordRound(150.000f / 430.556f * xHeight);
|
|
aSubScriptShift2 = NSToCoordRound(247.217f / 430.556f * xHeight);
|
|
}
|
|
|
|
// 3 levels of superscript shifts
|
|
static void GetSupScriptShifts(nsFontMetrics* fm, nscoord& aSupScriptShift1,
|
|
nscoord& aSupScriptShift2,
|
|
nscoord& aSupScriptShift3) {
|
|
nscoord xHeight = fm->XHeight();
|
|
aSupScriptShift1 = NSToCoordRound(412.892f / 430.556f * xHeight);
|
|
aSupScriptShift2 = NSToCoordRound(362.892f / 430.556f * xHeight);
|
|
aSupScriptShift3 = NSToCoordRound(288.889f / 430.556f * xHeight);
|
|
}
|
|
|
|
// these are TeX specific params not found in ordinary fonts
|
|
|
|
static void GetSubDrop(nsFontMetrics* fm, nscoord& aSubDrop) {
|
|
nscoord xHeight = fm->XHeight();
|
|
aSubDrop = NSToCoordRound(50.000f / 430.556f * xHeight);
|
|
}
|
|
|
|
static void GetSupDrop(nsFontMetrics* fm, nscoord& aSupDrop) {
|
|
nscoord xHeight = fm->XHeight();
|
|
aSupDrop = NSToCoordRound(386.108f / 430.556f * xHeight);
|
|
}
|
|
|
|
static void GetNumeratorShifts(nsFontMetrics* fm, nscoord& numShift1,
|
|
nscoord& numShift2, nscoord& numShift3) {
|
|
nscoord xHeight = fm->XHeight();
|
|
numShift1 = NSToCoordRound(676.508f / 430.556f * xHeight);
|
|
numShift2 = NSToCoordRound(393.732f / 430.556f * xHeight);
|
|
numShift3 = NSToCoordRound(443.731f / 430.556f * xHeight);
|
|
}
|
|
|
|
static void GetDenominatorShifts(nsFontMetrics* fm, nscoord& denShift1,
|
|
nscoord& denShift2) {
|
|
nscoord xHeight = fm->XHeight();
|
|
denShift1 = NSToCoordRound(685.951f / 430.556f * xHeight);
|
|
denShift2 = NSToCoordRound(344.841f / 430.556f * xHeight);
|
|
}
|
|
|
|
static void GetEmHeight(nsFontMetrics* fm, nscoord& emHeight) {
|
|
#if 0
|
|
// should switch to this API in order to scale with changes of TextZoom
|
|
emHeight = fm->EmHeight();
|
|
#else
|
|
emHeight = fm->Font().size.ToAppUnits();
|
|
#endif
|
|
}
|
|
|
|
static void GetAxisHeight(nsFontMetrics* fm, nscoord& axisHeight) {
|
|
axisHeight = NSToCoordRound(250.000f / 430.556f * fm->XHeight());
|
|
}
|
|
|
|
static void GetBigOpSpacings(nsFontMetrics* fm, nscoord& bigOpSpacing1,
|
|
nscoord& bigOpSpacing2, nscoord& bigOpSpacing3,
|
|
nscoord& bigOpSpacing4, nscoord& bigOpSpacing5) {
|
|
nscoord xHeight = fm->XHeight();
|
|
bigOpSpacing1 = NSToCoordRound(111.111f / 430.556f * xHeight);
|
|
bigOpSpacing2 = NSToCoordRound(166.667f / 430.556f * xHeight);
|
|
bigOpSpacing3 = NSToCoordRound(200.000f / 430.556f * xHeight);
|
|
bigOpSpacing4 = NSToCoordRound(600.000f / 430.556f * xHeight);
|
|
bigOpSpacing5 = NSToCoordRound(100.000f / 430.556f * xHeight);
|
|
}
|
|
|
|
static void GetRuleThickness(nsFontMetrics* fm, nscoord& ruleThickness) {
|
|
nscoord xHeight = fm->XHeight();
|
|
ruleThickness = NSToCoordRound(40.000f / 430.556f * xHeight);
|
|
}
|
|
|
|
// Some parameters are not accurately obtained using the x-height.
|
|
// Here are some slower variants to obtain the desired metrics
|
|
// by actually measuring some characters
|
|
static void GetRuleThickness(mozilla::gfx::DrawTarget* aDrawTarget,
|
|
nsFontMetrics* aFontMetrics,
|
|
nscoord& aRuleThickness);
|
|
|
|
static void GetAxisHeight(mozilla::gfx::DrawTarget* aDrawTarget,
|
|
nsFontMetrics* aFontMetrics, nscoord& aAxisHeight);
|
|
|
|
static void GetRadicalParameters(nsFontMetrics* aFontMetrics,
|
|
bool aDisplayStyle,
|
|
nscoord& aRadicalRuleThickness,
|
|
nscoord& aRadicalExtraAscender,
|
|
nscoord& aRadicalVerticalGap);
|
|
|
|
protected:
|
|
#if defined(DEBUG) && defined(SHOW_BOUNDING_BOX)
|
|
void DisplayBoundingMetrics(mozilla::nsDisplayListBuilder* aBuilder,
|
|
nsIFrame* aFrame, const nsPoint& aPt,
|
|
const nsBoundingMetrics& aMetrics,
|
|
const nsDisplayListSet& aLists);
|
|
#endif
|
|
|
|
/**
|
|
* Display a solid rectangle in the frame's text color. Used for drawing
|
|
* fraction separators and root/sqrt overbars.
|
|
*/
|
|
void DisplayBar(mozilla::nsDisplayListBuilder* aBuilder, nsIFrame* aFrame,
|
|
const nsRect& aRect, const mozilla::nsDisplayListSet& aLists,
|
|
uint32_t aIndex = 0);
|
|
|
|
// information about the presentation policy of the frame
|
|
nsPresentationData mPresentationData;
|
|
|
|
// information about a container that is an embellished operator
|
|
nsEmbellishData mEmbellishData;
|
|
|
|
// Metrics that _exactly_ enclose the text of the frame
|
|
nsBoundingMetrics mBoundingMetrics;
|
|
|
|
// Reference point of the frame: mReference.y is the baseline
|
|
nsPoint mReference;
|
|
};
|
|
|
|
#endif /* nsMathMLFrame_h___ */
|