Source code
Revision control
Copy as Markdown
Other Tools
/* -*- 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
#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);
}