summaryrefslogtreecommitdiffstats
path: root/layout/generic/MathMLTextRunFactory.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'layout/generic/MathMLTextRunFactory.cpp')
-rw-r--r--layout/generic/MathMLTextRunFactory.cpp679
1 files changed, 679 insertions, 0 deletions
diff --git a/layout/generic/MathMLTextRunFactory.cpp b/layout/generic/MathMLTextRunFactory.cpp
new file mode 100644
index 0000000000..a04062ba80
--- /dev/null
+++ b/layout/generic/MathMLTextRunFactory.cpp
@@ -0,0 +1,679 @@
+/* -*- 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 "MathMLTextRunFactory.h"
+
+#include "mozilla/ArrayUtils.h"
+#include "mozilla/BinarySearch.h"
+#include "mozilla/ComputedStyle.h"
+#include "mozilla/ComputedStyleInlines.h"
+#include "mozilla/StaticPrefs_mathml.h"
+#include "mozilla/intl/UnicodeScriptCodes.h"
+
+#include "nsStyleConsts.h"
+#include "nsTextFrameUtils.h"
+#include "nsFontMetrics.h"
+#include "nsDeviceContext.h"
+
+using namespace mozilla;
+
+/*
+ Entries for the mathvariant lookup tables. mKey represents the Unicode
+ character to be transformed and is used for searching the tables.
+ mReplacement represents the mapped mathvariant Unicode character.
+*/
+typedef struct {
+ uint32_t mKey;
+ uint32_t mReplacement;
+} MathVarMapping;
+
+/*
+ Lookup tables for use with mathvariant mappings to transform a unicode
+ character point to another unicode character that indicates the proper output.
+ mKey represents one of two concepts.
+ 1. In the Latin table it represents a hole in the mathematical alphanumeric
+ block, where the character that should occupy that position is located
+ elsewhere.
+ 2. It represents an Arabic letter.
+
+ As a replacement, 0 is reserved to indicate no mapping was found.
+*/
+static const MathVarMapping gArabicInitialMapTable[] = {
+ {0x628, 0x1EE21}, {0x62A, 0x1EE35}, {0x62B, 0x1EE36}, {0x62C, 0x1EE22},
+ {0x62D, 0x1EE27}, {0x62E, 0x1EE37}, {0x633, 0x1EE2E}, {0x634, 0x1EE34},
+ {0x635, 0x1EE31}, {0x636, 0x1EE39}, {0x639, 0x1EE2F}, {0x63A, 0x1EE3B},
+ {0x641, 0x1EE30}, {0x642, 0x1EE32}, {0x643, 0x1EE2A}, {0x644, 0x1EE2B},
+ {0x645, 0x1EE2C}, {0x646, 0x1EE2D}, {0x647, 0x1EE24}, {0x64A, 0x1EE29}};
+
+static const MathVarMapping gArabicTailedMapTable[] = {
+ {0x62C, 0x1EE42}, {0x62D, 0x1EE47}, {0x62E, 0x1EE57}, {0x633, 0x1EE4E},
+ {0x634, 0x1EE54}, {0x635, 0x1EE51}, {0x636, 0x1EE59}, {0x639, 0x1EE4F},
+ {0x63A, 0x1EE5B}, {0x642, 0x1EE52}, {0x644, 0x1EE4B}, {0x646, 0x1EE4D},
+ {0x64A, 0x1EE49}, {0x66F, 0x1EE5F}, {0x6BA, 0x1EE5D}};
+
+static const MathVarMapping gArabicStretchedMapTable[] = {
+ {0x628, 0x1EE61}, {0x62A, 0x1EE75}, {0x62B, 0x1EE76}, {0x62C, 0x1EE62},
+ {0x62D, 0x1EE67}, {0x62E, 0x1EE77}, {0x633, 0x1EE6E}, {0x634, 0x1EE74},
+ {0x635, 0x1EE71}, {0x636, 0x1EE79}, {0x637, 0x1EE68}, {0x638, 0x1EE7A},
+ {0x639, 0x1EE6F}, {0x63A, 0x1EE7B}, {0x641, 0x1EE70}, {0x642, 0x1EE72},
+ {0x643, 0x1EE6A}, {0x645, 0x1EE6C}, {0x646, 0x1EE6D}, {0x647, 0x1EE64},
+ {0x64A, 0x1EE69}, {0x66E, 0x1EE7C}, {0x6A1, 0x1EE7E}};
+
+static const MathVarMapping gArabicLoopedMapTable[] = {
+ {0x627, 0x1EE80}, {0x628, 0x1EE81}, {0x62A, 0x1EE95}, {0x62B, 0x1EE96},
+ {0x62C, 0x1EE82}, {0x62D, 0x1EE87}, {0x62E, 0x1EE97}, {0x62F, 0x1EE83},
+ {0x630, 0x1EE98}, {0x631, 0x1EE93}, {0x632, 0x1EE86}, {0x633, 0x1EE8E},
+ {0x634, 0x1EE94}, {0x635, 0x1EE91}, {0x636, 0x1EE99}, {0x637, 0x1EE88},
+ {0x638, 0x1EE9A}, {0x639, 0x1EE8F}, {0x63A, 0x1EE9B}, {0x641, 0x1EE90},
+ {0x642, 0x1EE92}, {0x644, 0x1EE8B}, {0x645, 0x1EE8C}, {0x646, 0x1EE8D},
+ {0x647, 0x1EE84}, {0x648, 0x1EE85}, {0x64A, 0x1EE89}};
+
+static const MathVarMapping gArabicDoubleMapTable[] = {
+ {0x628, 0x1EEA1}, {0x62A, 0x1EEB5}, {0x62B, 0x1EEB6}, {0x62C, 0x1EEA2},
+ {0x62D, 0x1EEA7}, {0x62E, 0x1EEB7}, {0x62F, 0x1EEA3}, {0x630, 0x1EEB8},
+ {0x631, 0x1EEB3}, {0x632, 0x1EEA6}, {0x633, 0x1EEAE}, {0x634, 0x1EEB4},
+ {0x635, 0x1EEB1}, {0x636, 0x1EEB9}, {0x637, 0x1EEA8}, {0x638, 0x1EEBA},
+ {0x639, 0x1EEAF}, {0x63A, 0x1EEBB}, {0x641, 0x1EEB0}, {0x642, 0x1EEB2},
+ {0x644, 0x1EEAB}, {0x645, 0x1EEAC}, {0x646, 0x1EEAD}, {0x648, 0x1EEA5},
+ {0x64A, 0x1EEA9}};
+
+static const MathVarMapping gLatinExceptionMapTable[] = {
+ {0x1D455, 0x210E}, {0x1D49D, 0x212C}, {0x1D4A0, 0x2130}, {0x1D4A1, 0x2131},
+ {0x1D4A3, 0x210B}, {0x1D4A4, 0x2110}, {0x1D4A7, 0x2112}, {0x1D4A8, 0x2133},
+ {0x1D4AD, 0x211B}, {0x1D4BA, 0x212F}, {0x1D4BC, 0x210A}, {0x1D4C4, 0x2134},
+ {0x1D506, 0x212D}, {0x1D50B, 0x210C}, {0x1D50C, 0x2111}, {0x1D515, 0x211C},
+ {0x1D51D, 0x2128}, {0x1D53A, 0x2102}, {0x1D53F, 0x210D}, {0x1D545, 0x2115},
+ {0x1D547, 0x2119}, {0x1D548, 0x211A}, {0x1D549, 0x211D}, {0x1D551, 0x2124}};
+
+namespace {
+
+struct MathVarMappingWrapper {
+ const MathVarMapping* const mTable;
+ explicit MathVarMappingWrapper(const MathVarMapping* aTable)
+ : mTable(aTable) {}
+ uint32_t operator[](size_t index) const { return mTable[index].mKey; }
+};
+
+} // namespace
+
+// Finds a MathVarMapping struct with the specified key (aKey) within aTable.
+// aTable must be an array, whose length is specified by aNumElements
+static uint32_t MathvarMappingSearch(uint32_t aKey,
+ const MathVarMapping* aTable,
+ uint32_t aNumElements) {
+ size_t index;
+ if (BinarySearch(MathVarMappingWrapper(aTable), 0, aNumElements, aKey,
+ &index)) {
+ return aTable[index].mReplacement;
+ }
+
+ return 0;
+}
+
+#define GREEK_UPPER_THETA 0x03F4
+#define HOLE_GREEK_UPPER_THETA 0x03A2
+#define NABLA 0x2207
+#define PARTIAL_DIFFERENTIAL 0x2202
+#define GREEK_UPPER_ALPHA 0x0391
+#define GREEK_UPPER_OMEGA 0x03A9
+#define GREEK_LOWER_ALPHA 0x03B1
+#define GREEK_LOWER_OMEGA 0x03C9
+#define GREEK_LUNATE_EPSILON_SYMBOL 0x03F5
+#define GREEK_THETA_SYMBOL 0x03D1
+#define GREEK_KAPPA_SYMBOL 0x03F0
+#define GREEK_PHI_SYMBOL 0x03D5
+#define GREEK_RHO_SYMBOL 0x03F1
+#define GREEK_PI_SYMBOL 0x03D6
+#define GREEK_LETTER_DIGAMMA 0x03DC
+#define GREEK_SMALL_LETTER_DIGAMMA 0x03DD
+#define MATH_BOLD_CAPITAL_DIGAMMA 0x1D7CA
+#define MATH_BOLD_SMALL_DIGAMMA 0x1D7CB
+
+#define LATIN_SMALL_LETTER_DOTLESS_I 0x0131
+#define LATIN_SMALL_LETTER_DOTLESS_J 0x0237
+
+#define MATH_ITALIC_SMALL_DOTLESS_I 0x1D6A4
+#define MATH_ITALIC_SMALL_DOTLESS_J 0x1D6A5
+
+#define MATH_BOLD_UPPER_A 0x1D400
+#define MATH_ITALIC_UPPER_A 0x1D434
+#define MATH_BOLD_SMALL_A 0x1D41A
+#define MATH_BOLD_UPPER_ALPHA 0x1D6A8
+#define MATH_BOLD_SMALL_ALPHA 0x1D6C2
+#define MATH_ITALIC_UPPER_ALPHA 0x1D6E2
+#define MATH_BOLD_DIGIT_ZERO 0x1D7CE
+#define MATH_DOUBLE_STRUCK_ZERO 0x1D7D8
+
+#define MATH_BOLD_UPPER_THETA 0x1D6B9
+#define MATH_BOLD_NABLA 0x1D6C1
+#define MATH_BOLD_PARTIAL_DIFFERENTIAL 0x1D6DB
+#define MATH_BOLD_EPSILON_SYMBOL 0x1D6DC
+#define MATH_BOLD_THETA_SYMBOL 0x1D6DD
+#define MATH_BOLD_KAPPA_SYMBOL 0x1D6DE
+#define MATH_BOLD_PHI_SYMBOL 0x1D6DF
+#define MATH_BOLD_RHO_SYMBOL 0x1D6E0
+#define MATH_BOLD_PI_SYMBOL 0x1D6E1
+
+/*
+ Performs the character mapping needed to implement MathML's mathvariant
+ attribute. It takes a unicode character and maps it to its appropriate
+ mathvariant counterpart specified by aMathVar. The mapped character is
+ typically located within Unicode's mathematical blocks (0x1D***, 0x1EE**) but
+ there are exceptions which this function accounts for.
+ Characters without a valid mapping or valid aMathvar value are returned
+ unaltered. Characters already in the mathematical blocks (or are one of the
+ exceptions) are never transformed.
+ Acceptable values for aMathVar are specified in layout/style/nsStyleConsts.h.
+ The transformable characters can be found at:
+ http://lists.w3.org/Archives/Public/www-math/2013Sep/0012.html and
+ https://en.wikipedia.org/wiki/Mathematical_Alphanumeric_Symbols
+*/
+static uint32_t MathVariant(uint32_t aCh, StyleMathVariant aMathVar) {
+ uint32_t baseChar;
+ enum CharacterType {
+ kIsLatin,
+ kIsGreekish,
+ kIsNumber,
+ kIsArabic,
+ };
+ CharacterType varType;
+
+ int8_t multiplier;
+
+ if (aMathVar <= StyleMathVariant::Normal) {
+ // nothing to do here
+ return aCh;
+ }
+ if (aMathVar > StyleMathVariant::Stretched) {
+ NS_ASSERTION(false, "Illegal mathvariant value");
+ return aCh;
+ }
+
+ // Exceptional characters with at most one possible transformation
+ if (aCh == HOLE_GREEK_UPPER_THETA) {
+ // Nothing at this code point is transformed
+ return aCh;
+ }
+ if (aCh == GREEK_LETTER_DIGAMMA) {
+ if (aMathVar == StyleMathVariant::Bold) {
+ return MATH_BOLD_CAPITAL_DIGAMMA;
+ }
+ return aCh;
+ }
+ if (aCh == GREEK_SMALL_LETTER_DIGAMMA) {
+ if (aMathVar == StyleMathVariant::Bold) {
+ return MATH_BOLD_SMALL_DIGAMMA;
+ }
+ return aCh;
+ }
+ if (aCh == LATIN_SMALL_LETTER_DOTLESS_I) {
+ if (aMathVar == StyleMathVariant::Italic) {
+ return MATH_ITALIC_SMALL_DOTLESS_I;
+ }
+ return aCh;
+ }
+ if (aCh == LATIN_SMALL_LETTER_DOTLESS_J) {
+ if (aMathVar == StyleMathVariant::Italic) {
+ return MATH_ITALIC_SMALL_DOTLESS_J;
+ }
+ return aCh;
+ }
+
+ // The Unicode mathematical blocks are divided into four segments: Latin,
+ // Greek, numbers and Arabic. In the case of the first three
+ // baseChar represents the relative order in which the characters are
+ // encoded in the Unicode mathematical block, normalised to the first
+ // character of that sequence.
+ //
+ if ('A' <= aCh && aCh <= 'Z') {
+ baseChar = aCh - 'A';
+ varType = kIsLatin;
+ } else if ('a' <= aCh && aCh <= 'z') {
+ // Lowercase characters are placed immediately after the uppercase
+ // characters in the Unicode mathematical block. The constant subtraction
+ // represents the number of characters between the start of the sequence
+ // (capital A) and the first lowercase letter.
+ baseChar = MATH_BOLD_SMALL_A - MATH_BOLD_UPPER_A + aCh - 'a';
+ varType = kIsLatin;
+ } else if ('0' <= aCh && aCh <= '9') {
+ baseChar = aCh - '0';
+ varType = kIsNumber;
+ } else if (GREEK_UPPER_ALPHA <= aCh && aCh <= GREEK_UPPER_OMEGA) {
+ baseChar = aCh - GREEK_UPPER_ALPHA;
+ varType = kIsGreekish;
+ } else if (GREEK_LOWER_ALPHA <= aCh && aCh <= GREEK_LOWER_OMEGA) {
+ // Lowercase Greek comes after uppercase Greek.
+ // Note in this instance the presence of an additional character (Nabla)
+ // between the end of the uppercase Greek characters and the lowercase
+ // ones.
+ baseChar =
+ MATH_BOLD_SMALL_ALPHA - MATH_BOLD_UPPER_ALPHA + aCh - GREEK_LOWER_ALPHA;
+ varType = kIsGreekish;
+ } else if (0x0600 <= aCh && aCh <= 0x06FF) {
+ // Arabic characters are defined within this range
+ varType = kIsArabic;
+ } else {
+ switch (aCh) {
+ case GREEK_UPPER_THETA:
+ baseChar = MATH_BOLD_UPPER_THETA - MATH_BOLD_UPPER_ALPHA;
+ break;
+ case NABLA:
+ baseChar = MATH_BOLD_NABLA - MATH_BOLD_UPPER_ALPHA;
+ break;
+ case PARTIAL_DIFFERENTIAL:
+ baseChar = MATH_BOLD_PARTIAL_DIFFERENTIAL - MATH_BOLD_UPPER_ALPHA;
+ break;
+ case GREEK_LUNATE_EPSILON_SYMBOL:
+ baseChar = MATH_BOLD_EPSILON_SYMBOL - MATH_BOLD_UPPER_ALPHA;
+ break;
+ case GREEK_THETA_SYMBOL:
+ baseChar = MATH_BOLD_THETA_SYMBOL - MATH_BOLD_UPPER_ALPHA;
+ break;
+ case GREEK_KAPPA_SYMBOL:
+ baseChar = MATH_BOLD_KAPPA_SYMBOL - MATH_BOLD_UPPER_ALPHA;
+ break;
+ case GREEK_PHI_SYMBOL:
+ baseChar = MATH_BOLD_PHI_SYMBOL - MATH_BOLD_UPPER_ALPHA;
+ break;
+ case GREEK_RHO_SYMBOL:
+ baseChar = MATH_BOLD_RHO_SYMBOL - MATH_BOLD_UPPER_ALPHA;
+ break;
+ case GREEK_PI_SYMBOL:
+ baseChar = MATH_BOLD_PI_SYMBOL - MATH_BOLD_UPPER_ALPHA;
+ break;
+ default:
+ return aCh;
+ }
+
+ varType = kIsGreekish;
+ }
+
+ if (varType == kIsNumber) {
+ switch (aMathVar) {
+ // Each possible number mathvariant is encoded in a single, contiguous
+ // block. For example the beginning of the double struck number range
+ // follows immediately after the end of the bold number range.
+ // multiplier represents the order of the sequences relative to the first
+ // one.
+ case StyleMathVariant::Bold:
+ multiplier = 0;
+ break;
+ case StyleMathVariant::DoubleStruck:
+ multiplier = 1;
+ break;
+ case StyleMathVariant::SansSerif:
+ multiplier = 2;
+ break;
+ case StyleMathVariant::BoldSansSerif:
+ multiplier = 3;
+ break;
+ case StyleMathVariant::Monospace:
+ multiplier = 4;
+ break;
+ default:
+ // This mathvariant isn't defined for numbers or is otherwise normal
+ return aCh;
+ }
+ // As the ranges are contiguous, to find the desired mathvariant range it
+ // is sufficient to multiply the position within the sequence order
+ // (multiplier) with the period of the sequence (which is constant for all
+ // number sequences) and to add the character point of the first character
+ // within the number mathvariant range.
+ // To this the baseChar calculated earlier is added to obtain the final
+ // code point.
+ return baseChar +
+ multiplier * (MATH_DOUBLE_STRUCK_ZERO - MATH_BOLD_DIGIT_ZERO) +
+ MATH_BOLD_DIGIT_ZERO;
+ } else if (varType == kIsGreekish) {
+ switch (aMathVar) {
+ case StyleMathVariant::Bold:
+ multiplier = 0;
+ break;
+ case StyleMathVariant::Italic:
+ multiplier = 1;
+ break;
+ case StyleMathVariant::BoldItalic:
+ multiplier = 2;
+ break;
+ case StyleMathVariant::BoldSansSerif:
+ multiplier = 3;
+ break;
+ case StyleMathVariant::SansSerifBoldItalic:
+ multiplier = 4;
+ break;
+ default:
+ // This mathvariant isn't defined for Greek or is otherwise normal
+ return aCh;
+ }
+ // See the kIsNumber case for an explanation of the following calculation
+ return baseChar + MATH_BOLD_UPPER_ALPHA +
+ multiplier * (MATH_ITALIC_UPPER_ALPHA - MATH_BOLD_UPPER_ALPHA);
+ }
+
+ uint32_t tempChar;
+ uint32_t newChar;
+ if (varType == kIsArabic) {
+ const MathVarMapping* mapTable;
+ uint32_t tableLength;
+ switch (aMathVar) {
+ /* The Arabic mathematical block is not continuous, nor does it have a
+ * monotonic mapping to the unencoded characters, requiring the use of a
+ * lookup table.
+ */
+ case StyleMathVariant::Initial:
+ mapTable = gArabicInitialMapTable;
+ tableLength = ArrayLength(gArabicInitialMapTable);
+ break;
+ case StyleMathVariant::Tailed:
+ mapTable = gArabicTailedMapTable;
+ tableLength = ArrayLength(gArabicTailedMapTable);
+ break;
+ case StyleMathVariant::Stretched:
+ mapTable = gArabicStretchedMapTable;
+ tableLength = ArrayLength(gArabicStretchedMapTable);
+ break;
+ case StyleMathVariant::Looped:
+ mapTable = gArabicLoopedMapTable;
+ tableLength = ArrayLength(gArabicLoopedMapTable);
+ break;
+ case StyleMathVariant::DoubleStruck:
+ mapTable = gArabicDoubleMapTable;
+ tableLength = ArrayLength(gArabicDoubleMapTable);
+ break;
+ default:
+ // No valid transformations exist
+ return aCh;
+ }
+ newChar = MathvarMappingSearch(aCh, mapTable, tableLength);
+ } else {
+ // Must be Latin
+ if (aMathVar > StyleMathVariant::Monospace) {
+ // Latin doesn't support the Arabic mathvariants
+ return aCh;
+ }
+ multiplier = uint8_t(aMathVar) - 2;
+ // This is possible because the values for StyleMathVariant::* are
+ // chosen to coincide with the order in which the encoded mathvariant
+ // characters are located within their unicode block (less an offset to
+ // avoid _NONE and _NORMAL variants)
+ // See the kIsNumber case for an explanation of the following calculation
+ tempChar = baseChar + MATH_BOLD_UPPER_A +
+ multiplier * (MATH_ITALIC_UPPER_A - MATH_BOLD_UPPER_A);
+ // There are roughly twenty characters that are located outside of the
+ // mathematical block, so the spaces where they ought to be are used
+ // as keys for a lookup table containing the correct character mappings.
+ newChar = MathvarMappingSearch(tempChar, gLatinExceptionMapTable,
+ ArrayLength(gLatinExceptionMapTable));
+ }
+
+ if (newChar) {
+ return newChar;
+ } else if (varType == kIsLatin) {
+ return tempChar;
+ } else {
+ // An Arabic character without a corresponding mapping
+ return aCh;
+ }
+}
+
+#define TT_SSTY TRUETYPE_TAG('s', 's', 't', 'y')
+#define TT_DTLS TRUETYPE_TAG('d', 't', 'l', 's')
+
+void MathMLTextRunFactory::RebuildTextRun(
+ nsTransformedTextRun* aTextRun, mozilla::gfx::DrawTarget* aRefDrawTarget,
+ gfxMissingFontRecorder* aMFR) {
+ gfxFontGroup* fontGroup = aTextRun->GetFontGroup();
+
+ nsAutoString convertedString;
+ AutoTArray<bool, 50> charsToMergeArray;
+ AutoTArray<bool, 50> deletedCharsArray;
+ AutoTArray<RefPtr<nsTransformedCharStyle>, 50> styleArray;
+ AutoTArray<uint8_t, 50> canBreakBeforeArray;
+ bool mergeNeeded = false;
+
+ bool singleCharMI =
+ !!(aTextRun->GetFlags2() & nsTextFrameUtils::Flags::IsSingleCharMi);
+
+ uint32_t length = aTextRun->GetLength();
+ const char16_t* str = aTextRun->mString.BeginReading();
+ const nsTArray<RefPtr<nsTransformedCharStyle>>& styles = aTextRun->mStyles;
+ nsFont font;
+ if (length) {
+ font = styles[0]->mFont;
+
+ if (mSSTYScriptLevel || (mFlags & MATH_FONT_FEATURE_DTLS)) {
+ bool foundSSTY = false;
+ bool foundDTLS = false;
+ // We respect ssty settings explicitly set by the user
+ for (uint32_t i = 0; i < font.fontFeatureSettings.Length(); i++) {
+ if (font.fontFeatureSettings[i].mTag == TT_SSTY) {
+ foundSSTY = true;
+ } else if (font.fontFeatureSettings[i].mTag == TT_DTLS) {
+ foundDTLS = true;
+ }
+ }
+ if (mSSTYScriptLevel && !foundSSTY) {
+ uint8_t sstyLevel = 0;
+ float scriptScaling =
+ pow(styles[0]->mScriptSizeMultiplier, mSSTYScriptLevel);
+ static_assert(kMathMLDefaultScriptSizeMultiplier < 1,
+ "Shouldn't it make things smaller?");
+ /*
+ An SSTY level of 2 is set if the scaling factor is less than or equal
+ to halfway between that for a scriptlevel of 1 (0.71) and that of a
+ scriptlevel of 2 (0.71^2), assuming the default script size
+ multiplier. An SSTY level of 1 is set if the script scaling factor is
+ less than or equal that for a scriptlevel of 1 assuming the default
+ script size multiplier.
+
+ User specified values of script size multiplier will change the
+ scaling factor which mSSTYScriptLevel values correspond to.
+
+ In the event that the script size multiplier actually makes things
+ larger, no change is made.
+
+ To opt out of this change, add the following to the stylesheet:
+ "font-feature-settings: 'ssty' 0"
+ */
+ if (scriptScaling <= (kMathMLDefaultScriptSizeMultiplier +
+ (kMathMLDefaultScriptSizeMultiplier *
+ kMathMLDefaultScriptSizeMultiplier)) /
+ 2) {
+ // Currently only the first two ssty settings are used, so two is
+ // large as we go
+ sstyLevel = 2;
+ } else if (scriptScaling <= kMathMLDefaultScriptSizeMultiplier) {
+ sstyLevel = 1;
+ }
+ if (sstyLevel) {
+ gfxFontFeature settingSSTY;
+ settingSSTY.mTag = TT_SSTY;
+ settingSSTY.mValue = sstyLevel;
+ font.fontFeatureSettings.AppendElement(settingSSTY);
+ }
+ }
+ /*
+ Apply the dtls font feature setting (dotless).
+ This gets applied to the base frame and all descendants of the base
+ frame of certain <mover> and <munderover> frames.
+
+ See nsMathMLmunderoverFrame.cpp for a full description.
+
+ To opt out of this change, add the following to the stylesheet:
+ "font-feature-settings: 'dtls' 0"
+ */
+ if ((mFlags & MATH_FONT_FEATURE_DTLS) && !foundDTLS) {
+ gfxFontFeature settingDTLS;
+ settingDTLS.mTag = TT_DTLS;
+ settingDTLS.mValue = 1;
+ font.fontFeatureSettings.AppendElement(settingDTLS);
+ }
+ }
+ }
+
+ StyleMathVariant mathVar = StyleMathVariant::None;
+ bool doMathvariantStyling = true;
+
+ // Ensure it will be safe to call FindFontForChar in the loop below.
+ fontGroup->CheckForUpdatedPlatformList();
+
+ for (uint32_t i = 0; i < length; ++i) {
+ int extraChars = 0;
+ mathVar = styles[i]->mMathVariant;
+
+ if (singleCharMI && mathVar == StyleMathVariant::None) {
+ mathVar = StyleMathVariant::Italic;
+ }
+
+ uint32_t ch = str[i];
+ if (i < length - 1 && NS_IS_SURROGATE_PAIR(ch, str[i + 1])) {
+ ch = SURROGATE_TO_UCS4(ch, str[i + 1]);
+ }
+ uint32_t ch2 = MathVariant(ch, mathVar);
+
+ if (!StaticPrefs::mathml_mathvariant_styling_fallback_disabled() &&
+ (mathVar == StyleMathVariant::Bold ||
+ mathVar == StyleMathVariant::BoldItalic ||
+ mathVar == StyleMathVariant::Italic)) {
+ if (ch == ch2 && ch != 0x20 && ch != 0xA0) {
+ // Don't apply the CSS style if a character cannot be
+ // transformed. There is an exception for whitespace as it is both
+ // common and innocuous.
+ doMathvariantStyling = false;
+ }
+ if (ch2 != ch) {
+ // Bug 930504. Some platforms do not have fonts for Mathematical
+ // Alphanumeric Symbols. Hence we check whether the transformed
+ // character is actually available.
+ FontMatchType matchType;
+ RefPtr<gfxFont> mathFont = fontGroup->FindFontForChar(
+ ch2, 0, 0, intl::Script::COMMON, nullptr, &matchType);
+ if (mathFont) {
+ // Don't apply the CSS style if there is a math font for at least one
+ // of the transformed character in this text run.
+ doMathvariantStyling = false;
+ } else {
+ // We fallback to the original character.
+ ch2 = ch;
+ if (aMFR) {
+ aMFR->RecordScript(intl::Script::MATHEMATICAL_NOTATION);
+ }
+ }
+ }
+ }
+
+ deletedCharsArray.AppendElement(false);
+ charsToMergeArray.AppendElement(false);
+ styleArray.AppendElement(styles[i]);
+ canBreakBeforeArray.AppendElement(aTextRun->CanBreakLineBefore(i));
+
+ if (IS_IN_BMP(ch2)) {
+ convertedString.Append(ch2);
+ } else {
+ convertedString.Append(H_SURROGATE(ch2));
+ convertedString.Append(L_SURROGATE(ch2));
+ ++extraChars;
+ if (!IS_IN_BMP(ch)) {
+ deletedCharsArray.AppendElement(
+ true); // not exactly deleted, but
+ // the trailing surrogate is skipped
+ ++i;
+ }
+ }
+
+ while (extraChars-- > 0) {
+ mergeNeeded = true;
+ charsToMergeArray.AppendElement(true);
+ styleArray.AppendElement(styles[i]);
+ canBreakBeforeArray.AppendElement(false);
+ }
+ }
+
+ gfx::ShapedTextFlags flags;
+ gfxTextRunFactory::Parameters innerParams =
+ GetParametersForInner(aTextRun, &flags, aRefDrawTarget);
+
+ RefPtr<nsTransformedTextRun> transformedChild;
+ RefPtr<gfxTextRun> cachedChild;
+ gfxTextRun* child;
+
+ if (!StaticPrefs::mathml_mathvariant_styling_fallback_disabled() &&
+ doMathvariantStyling) {
+ if (mathVar == StyleMathVariant::Bold) {
+ font.style = FontSlantStyle::NORMAL;
+ font.weight = FontWeight::BOLD;
+ } else if (mathVar == StyleMathVariant::Italic) {
+ font.style = FontSlantStyle::ITALIC;
+ font.weight = FontWeight::NORMAL;
+ } else if (mathVar == StyleMathVariant::BoldItalic) {
+ font.style = FontSlantStyle::ITALIC;
+ font.weight = FontWeight::BOLD;
+ }
+ }
+ gfxFontGroup* newFontGroup = nullptr;
+
+ // Get the correct gfxFontGroup that corresponds to the earlier font changes.
+ if (length) {
+ font.size = font.size.ScaledBy(mFontInflation);
+ nsPresContext* pc = styles[0]->mPresContext;
+ nsFontMetrics::Params params;
+ params.language = styles[0]->mLanguage;
+ params.explicitLanguage = styles[0]->mExplicitLanguage;
+ params.userFontSet = pc->GetUserFontSet();
+ params.textPerf = pc->GetTextPerfMetrics();
+ params.featureValueLookup = pc->GetFontFeatureValuesLookup();
+ RefPtr<nsFontMetrics> metrics = pc->GetMetricsFor(font, params);
+ newFontGroup = metrics->GetThebesFontGroup();
+ }
+
+ if (!newFontGroup) {
+ // If we can't get a new font group, fall back to the old one. Rendering
+ // will be incorrect, but not significantly so.
+ newFontGroup = fontGroup;
+ }
+
+ if (mInnerTransformingTextRunFactory) {
+ transformedChild = mInnerTransformingTextRunFactory->MakeTextRun(
+ convertedString.BeginReading(), convertedString.Length(), &innerParams,
+ newFontGroup, flags, nsTextFrameUtils::Flags(), std::move(styleArray),
+ false);
+ child = transformedChild.get();
+ } else {
+ cachedChild = newFontGroup->MakeTextRun(
+ convertedString.BeginReading(), convertedString.Length(), &innerParams,
+ flags, nsTextFrameUtils::Flags(), aMFR);
+ child = cachedChild.get();
+ }
+ if (!child) return;
+
+ typedef gfxTextRun::Range Range;
+
+ // Copy potential linebreaks into child so they're preserved
+ // (and also child will be shaped appropriately)
+ NS_ASSERTION(convertedString.Length() == canBreakBeforeArray.Length(),
+ "Dropped characters or break-before values somewhere!");
+ Range range(0, uint32_t(canBreakBeforeArray.Length()));
+ child->SetPotentialLineBreaks(range, canBreakBeforeArray.Elements());
+ if (transformedChild) {
+ transformedChild->FinishSettingProperties(aRefDrawTarget, aMFR);
+ }
+
+ aTextRun->ResetGlyphRuns();
+ if (mergeNeeded) {
+ // Now merge multiple characters into one multi-glyph character as required
+ NS_ASSERTION(charsToMergeArray.Length() == child->GetLength(),
+ "source length mismatch");
+ NS_ASSERTION(deletedCharsArray.Length() == aTextRun->GetLength(),
+ "destination length mismatch");
+ MergeCharactersInTextRun(aTextRun, child, charsToMergeArray.Elements(),
+ deletedCharsArray.Elements());
+ } else {
+ // No merging to do, so just copy; this produces a more optimized textrun.
+ // We can't steal the data because the child may be cached and stealing
+ // the data would break the cache.
+ aTextRun->CopyGlyphDataFrom(child, Range(child), 0);
+ }
+}