diff options
Diffstat (limited to '')
| -rw-r--r-- | gfx/src/nsFont.cpp | 290 |
1 files changed, 290 insertions, 0 deletions
diff --git a/gfx/src/nsFont.cpp b/gfx/src/nsFont.cpp new file mode 100644 index 0000000000..19f15b1db1 --- /dev/null +++ b/gfx/src/nsFont.cpp @@ -0,0 +1,290 @@ +/* -*- 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 "nsFont.h" +#include "gfxFont.h" // for gfxFontStyle +#include "gfxFontFeatures.h" // for gfxFontFeature, etc +#include "gfxFontUtils.h" // for TRUETYPE_TAG +#include "mozilla/ServoStyleConstsInlines.h" +#include "nsCRT.h" // for nsCRT +#include "nsDebug.h" // for NS_ASSERTION +#include "nsISupports.h" +#include "nsUnicharUtils.h" +#include "nscore.h" // for char16_t +#include "mozilla/ArrayUtils.h" +#include "mozilla/gfx/2D.h" + +using namespace mozilla; + +nsFont::nsFont(const StyleFontFamily& aFamily, mozilla::Length aSize) + : family(aFamily), size(aSize) {} + +nsFont::nsFont(StyleGenericFontFamily aGenericType, mozilla::Length aSize) + : family(*Servo_FontFamily_Generic(aGenericType)), size(aSize) {} + +nsFont::nsFont(const nsFont& aOther) = default; + +nsFont::~nsFont() = default; + +nsFont& nsFont::operator=(const nsFont&) = default; + +bool nsFont::Equals(const nsFont& aOther) const { + return CalcDifference(aOther) == MaxDifference::eNone; +} + +nsFont::MaxDifference nsFont::CalcDifference(const nsFont& aOther) const { + if ((style != aOther.style) || (weight != aOther.weight) || + (stretch != aOther.stretch) || (size != aOther.size) || + (sizeAdjust != aOther.sizeAdjust) || (family != aOther.family) || + (kerning != aOther.kerning) || (opticalSizing != aOther.opticalSizing) || + (synthesisWeight != aOther.synthesisWeight) || + (synthesisStyle != aOther.synthesisStyle) || + (synthesisSmallCaps != aOther.synthesisSmallCaps) || + (fontFeatureSettings != aOther.fontFeatureSettings) || + (fontVariationSettings != aOther.fontVariationSettings) || + (languageOverride != aOther.languageOverride) || + (variantAlternates != aOther.variantAlternates) || + (variantCaps != aOther.variantCaps) || + (variantEastAsian != aOther.variantEastAsian) || + (variantLigatures != aOther.variantLigatures) || + (variantNumeric != aOther.variantNumeric) || + (variantPosition != aOther.variantPosition) || + (variantWidth != aOther.variantWidth) || + (variantEmoji != aOther.variantEmoji)) { + return MaxDifference::eLayoutAffecting; + } + + if ((smoothing != aOther.smoothing) || + (fontSmoothingBackgroundColor != aOther.fontSmoothingBackgroundColor)) { + return MaxDifference::eVisual; + } + + return MaxDifference::eNone; +} + +// mapping from bitflag to font feature tag/value pair +// +// these need to be kept in sync with the constants listed +// in gfxFontConstants.h (e.g. NS_FONT_VARIANT_EAST_ASIAN_JIS78) + +// NS_FONT_VARIANT_EAST_ASIAN_xxx values +const gfxFontFeature eastAsianDefaults[] = { + {TRUETYPE_TAG('j', 'p', '7', '8'), 1}, + {TRUETYPE_TAG('j', 'p', '8', '3'), 1}, + {TRUETYPE_TAG('j', 'p', '9', '0'), 1}, + {TRUETYPE_TAG('j', 'p', '0', '4'), 1}, + {TRUETYPE_TAG('s', 'm', 'p', 'l'), 1}, + {TRUETYPE_TAG('t', 'r', 'a', 'd'), 1}, + {TRUETYPE_TAG('f', 'w', 'i', 'd'), 1}, + {TRUETYPE_TAG('p', 'w', 'i', 'd'), 1}, + {TRUETYPE_TAG('r', 'u', 'b', 'y'), 1}}; + +static_assert(MOZ_ARRAY_LENGTH(eastAsianDefaults) == + NS_FONT_VARIANT_EAST_ASIAN_COUNT, + "eastAsianDefaults[] should be correct"); + +// NS_FONT_VARIANT_LIGATURES_xxx values +const gfxFontFeature ligDefaults[] = { + {TRUETYPE_TAG('l', 'i', 'g', 'a'), 0}, // none value means all off + {TRUETYPE_TAG('l', 'i', 'g', 'a'), 1}, + {TRUETYPE_TAG('l', 'i', 'g', 'a'), 0}, + {TRUETYPE_TAG('d', 'l', 'i', 'g'), 1}, + {TRUETYPE_TAG('d', 'l', 'i', 'g'), 0}, + {TRUETYPE_TAG('h', 'l', 'i', 'g'), 1}, + {TRUETYPE_TAG('h', 'l', 'i', 'g'), 0}, + {TRUETYPE_TAG('c', 'a', 'l', 't'), 1}, + {TRUETYPE_TAG('c', 'a', 'l', 't'), 0}}; + +static_assert(MOZ_ARRAY_LENGTH(ligDefaults) == NS_FONT_VARIANT_LIGATURES_COUNT, + "ligDefaults[] should be correct"); + +// NS_FONT_VARIANT_NUMERIC_xxx values +const gfxFontFeature numericDefaults[] = { + {TRUETYPE_TAG('l', 'n', 'u', 'm'), 1}, + {TRUETYPE_TAG('o', 'n', 'u', 'm'), 1}, + {TRUETYPE_TAG('p', 'n', 'u', 'm'), 1}, + {TRUETYPE_TAG('t', 'n', 'u', 'm'), 1}, + {TRUETYPE_TAG('f', 'r', 'a', 'c'), 1}, + {TRUETYPE_TAG('a', 'f', 'r', 'c'), 1}, + {TRUETYPE_TAG('z', 'e', 'r', 'o'), 1}, + {TRUETYPE_TAG('o', 'r', 'd', 'n'), 1}}; + +static_assert(MOZ_ARRAY_LENGTH(numericDefaults) == + NS_FONT_VARIANT_NUMERIC_COUNT, + "numericDefaults[] should be correct"); + +static void AddFontFeaturesBitmask(uint32_t aValue, uint32_t aMin, + uint32_t aMax, + const gfxFontFeature aFeatureDefaults[], + nsTArray<gfxFontFeature>& aFeaturesOut) + +{ + uint32_t i, m; + + for (i = 0, m = aMin; m <= aMax; i++, m <<= 1) { + if (m & aValue) { + const gfxFontFeature& feature = aFeatureDefaults[i]; + aFeaturesOut.AppendElement(feature); + } + } +} + +static uint32_t FontFeatureTagForVariantWidth(uint32_t aVariantWidth) { + switch (aVariantWidth) { + case NS_FONT_VARIANT_WIDTH_FULL: + return TRUETYPE_TAG('f', 'w', 'i', 'd'); + case NS_FONT_VARIANT_WIDTH_HALF: + return TRUETYPE_TAG('h', 'w', 'i', 'd'); + case NS_FONT_VARIANT_WIDTH_THIRD: + return TRUETYPE_TAG('t', 'w', 'i', 'd'); + case NS_FONT_VARIANT_WIDTH_QUARTER: + return TRUETYPE_TAG('q', 'w', 'i', 'd'); + default: + return 0; + } +} + +void nsFont::AddFontFeaturesToStyle(gfxFontStyle* aStyle, + bool aVertical) const { + // add in font-variant features + gfxFontFeature setting; + + // -- kerning + setting.mTag = aVertical ? TRUETYPE_TAG('v', 'k', 'r', 'n') + : TRUETYPE_TAG('k', 'e', 'r', 'n'); + switch (kerning) { + case NS_FONT_KERNING_NONE: + setting.mValue = 0; + aStyle->featureSettings.AppendElement(setting); + break; + case NS_FONT_KERNING_NORMAL: + setting.mValue = 1; + aStyle->featureSettings.AppendElement(setting); + break; + default: + // auto case implies use user agent default + break; + } + + // -- alternates + // + // NOTE(emilio): We handle historical-forms here because it doesn't depend on + // other values set by @font-face and thus may be less expensive to do here + // than after font-matching. + for (auto& alternate : variantAlternates.AsSpan()) { + if (alternate.IsHistoricalForms()) { + setting.mValue = 1; + setting.mTag = TRUETYPE_TAG('h', 'i', 's', 't'); + aStyle->featureSettings.AppendElement(setting); + break; + } + } + + // -- copy font-specific alternate info into style + // (this will be resolved after font-matching occurs) + aStyle->variantAlternates = variantAlternates; + + // -- caps + aStyle->variantCaps = variantCaps; + + // -- east-asian + if (variantEastAsian) { + AddFontFeaturesBitmask(variantEastAsian, NS_FONT_VARIANT_EAST_ASIAN_JIS78, + NS_FONT_VARIANT_EAST_ASIAN_RUBY, eastAsianDefaults, + aStyle->featureSettings); + } + + // -- ligatures + if (variantLigatures) { + AddFontFeaturesBitmask(variantLigatures, NS_FONT_VARIANT_LIGATURES_NONE, + NS_FONT_VARIANT_LIGATURES_NO_CONTEXTUAL, ligDefaults, + aStyle->featureSettings); + + if (variantLigatures & NS_FONT_VARIANT_LIGATURES_COMMON) { + // liga already enabled, need to enable clig also + setting.mTag = TRUETYPE_TAG('c', 'l', 'i', 'g'); + setting.mValue = 1; + aStyle->featureSettings.AppendElement(setting); + } else if (variantLigatures & NS_FONT_VARIANT_LIGATURES_NO_COMMON) { + // liga already disabled, need to disable clig also + setting.mTag = TRUETYPE_TAG('c', 'l', 'i', 'g'); + setting.mValue = 0; + aStyle->featureSettings.AppendElement(setting); + } else if (variantLigatures & NS_FONT_VARIANT_LIGATURES_NONE) { + // liga already disabled, need to disable dlig, hlig, calt, clig + setting.mValue = 0; + setting.mTag = TRUETYPE_TAG('d', 'l', 'i', 'g'); + aStyle->featureSettings.AppendElement(setting); + setting.mTag = TRUETYPE_TAG('h', 'l', 'i', 'g'); + aStyle->featureSettings.AppendElement(setting); + setting.mTag = TRUETYPE_TAG('c', 'a', 'l', 't'); + aStyle->featureSettings.AppendElement(setting); + setting.mTag = TRUETYPE_TAG('c', 'l', 'i', 'g'); + aStyle->featureSettings.AppendElement(setting); + } + } + + // -- numeric + if (variantNumeric) { + AddFontFeaturesBitmask(variantNumeric, NS_FONT_VARIANT_NUMERIC_LINING, + NS_FONT_VARIANT_NUMERIC_ORDINAL, numericDefaults, + aStyle->featureSettings); + } + + // -- position + aStyle->variantSubSuper = variantPosition; + + // -- width + setting.mTag = FontFeatureTagForVariantWidth(variantWidth); + if (setting.mTag) { + setting.mValue = 1; + aStyle->featureSettings.AppendElement(setting); + } + + // indicate common-path case when neither variantCaps or variantSubSuper are + // set + aStyle->noFallbackVariantFeatures = + (aStyle->variantCaps == NS_FONT_VARIANT_CAPS_NORMAL) && + (variantPosition == NS_FONT_VARIANT_POSITION_NORMAL); + + // If the feature list is not empty, we insert a "fake" feature with tag=0 + // as delimiter between the above "high-level" features from font-variant-* + // etc and those coming from the low-level font-feature-settings property. + // This will allow us to distinguish high- and low-level settings when it + // comes to potentially disabling ligatures because of letter-spacing. + if (!aStyle->featureSettings.IsEmpty() || !fontFeatureSettings.IsEmpty()) { + aStyle->featureSettings.AppendElement(gfxFontFeature{0, 0}); + } + + // add in features from font-feature-settings + aStyle->featureSettings.AppendElements(fontFeatureSettings); + + // enable grayscale antialiasing for text + if (smoothing == NS_FONT_SMOOTHING_GRAYSCALE) { + aStyle->useGrayscaleAntialiasing = true; + } + + aStyle->fontSmoothingBackgroundColor = fontSmoothingBackgroundColor.ToColor(); +} + +void nsFont::AddFontVariationsToStyle(gfxFontStyle* aStyle) const { + // If auto optical sizing is enabled, and if there's no 'opsz' axis in + // fontVariationSettings, then set the automatic value on the style. + class VariationTagComparator { + public: + bool Equals(const gfxFontVariation& aVariation, uint32_t aTag) const { + return aVariation.mTag == aTag; + } + }; + const uint32_t kTagOpsz = TRUETYPE_TAG('o', 'p', 's', 'z'); + if (opticalSizing == NS_FONT_OPTICAL_SIZING_AUTO && + !fontVariationSettings.Contains(kTagOpsz, VariationTagComparator())) { + aStyle->autoOpticalSize = size.ToCSSPixels(); + } + + // Add in arbitrary values from font-variation-settings + aStyle->variationSettings.AppendElements(fontVariationSettings); +} |