summaryrefslogtreecommitdiffstats
path: root/gfx/src/nsFont.cpp
blob: 19f15b1db15dbcb9a7e300af48097fe7e3a3e571 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
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);
}