summaryrefslogtreecommitdiffstats
path: root/gfx/src/nsFont.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'gfx/src/nsFont.cpp')
-rw-r--r--gfx/src/nsFont.cpp288
1 files changed, 288 insertions, 0 deletions
diff --git a/gfx/src/nsFont.cpp b/gfx/src/nsFont.cpp
new file mode 100644
index 0000000000..baec648ddb
--- /dev/null
+++ b/gfx/src/nsFont.cpp
@@ -0,0 +1,288 @@
+/* -*- 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) ||
+ (synthesisPosition != aOther.synthesisPosition) ||
+ (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) {
+ 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;
+ }
+}
+
+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);
+}