mirror of
https://gitlab.winehq.org/wine/wine-gecko.git
synced 2024-09-13 09:24:08 -07:00
367 lines
15 KiB
C++
367 lines
15 KiB
C++
/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
|
* 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 "gfxFT2FontBase.h"
|
|
#include "gfxFT2Utils.h"
|
|
#include "mozilla/Likely.h"
|
|
#include FT_TRUETYPE_TAGS_H
|
|
#include FT_TRUETYPE_TABLES_H
|
|
#include <algorithm>
|
|
|
|
#ifdef HAVE_FONTCONFIG_FCFREETYPE_H
|
|
#include <fontconfig/fcfreetype.h>
|
|
#endif
|
|
|
|
#include "prlink.h"
|
|
|
|
// aScale is intended for a 16.16 x/y_scale of an FT_Size_Metrics
|
|
static inline FT_Long
|
|
ScaleRoundDesignUnits(FT_Short aDesignMetric, FT_Fixed aScale)
|
|
{
|
|
FT_Long fixed26dot6 = FT_MulFix(aDesignMetric, aScale);
|
|
return ROUND_26_6_TO_INT(fixed26dot6);
|
|
}
|
|
|
|
// Snap a line to pixels while keeping the center and size of the line as
|
|
// close to the original position as possible.
|
|
//
|
|
// Pango does similar snapping for underline and strikethrough when fonts are
|
|
// hinted, but nsCSSRendering::GetTextDecorationRectInternal always snaps the
|
|
// top and size of lines. Optimizing the distance between the line and
|
|
// baseline is probably good for the gap between text and underline, but
|
|
// optimizing the center of the line is better for positioning strikethough.
|
|
static void
|
|
SnapLineToPixels(gfxFloat& aOffset, gfxFloat& aSize)
|
|
{
|
|
gfxFloat snappedSize = std::max(floor(aSize + 0.5), 1.0);
|
|
// Correct offset for change in size
|
|
gfxFloat offset = aOffset - 0.5 * (aSize - snappedSize);
|
|
// Snap offset
|
|
aOffset = floor(offset + 0.5);
|
|
aSize = snappedSize;
|
|
}
|
|
|
|
void
|
|
gfxFT2LockedFace::GetMetrics(gfxFont::Metrics* aMetrics,
|
|
uint32_t* aSpaceGlyph)
|
|
{
|
|
NS_PRECONDITION(aMetrics != nullptr, "aMetrics must not be NULL");
|
|
NS_PRECONDITION(aSpaceGlyph != nullptr, "aSpaceGlyph must not be NULL");
|
|
|
|
if (MOZ_UNLIKELY(!mFace)) {
|
|
// No face. This unfortunate situation might happen if the font
|
|
// file is (re)moved at the wrong time.
|
|
const gfxFloat emHeight = mGfxFont->GetStyle()->size;
|
|
aMetrics->emHeight = emHeight;
|
|
aMetrics->maxAscent = aMetrics->emAscent = 0.8 * emHeight;
|
|
aMetrics->maxDescent = aMetrics->emDescent = 0.2 * emHeight;
|
|
aMetrics->maxHeight = emHeight;
|
|
aMetrics->internalLeading = 0.0;
|
|
aMetrics->externalLeading = 0.2 * emHeight;
|
|
const gfxFloat spaceWidth = 0.5 * emHeight;
|
|
aMetrics->spaceWidth = spaceWidth;
|
|
aMetrics->maxAdvance = spaceWidth;
|
|
aMetrics->aveCharWidth = spaceWidth;
|
|
aMetrics->zeroOrAveCharWidth = spaceWidth;
|
|
const gfxFloat xHeight = 0.5 * emHeight;
|
|
aMetrics->xHeight = xHeight;
|
|
const gfxFloat underlineSize = emHeight / 14.0;
|
|
aMetrics->underlineSize = underlineSize;
|
|
aMetrics->underlineOffset = -underlineSize;
|
|
aMetrics->strikeoutOffset = 0.25 * emHeight;
|
|
aMetrics->strikeoutSize = underlineSize;
|
|
|
|
*aSpaceGlyph = 0;
|
|
return;
|
|
}
|
|
|
|
const FT_Size_Metrics& ftMetrics = mFace->size->metrics;
|
|
|
|
gfxFloat emHeight;
|
|
// Scale for vertical design metric conversion: pixels per design unit.
|
|
// If this remains at 0.0, we can't use metrics from OS/2 etc.
|
|
gfxFloat yScale = 0.0;
|
|
if (FT_IS_SCALABLE(mFace)) {
|
|
// Prefer FT_Size_Metrics::x_scale to x_ppem as x_ppem does not
|
|
// have subpixel accuracy.
|
|
//
|
|
// FT_Size_Metrics::y_scale is in 16.16 fixed point format. Its
|
|
// (fractional) value is a factor that converts vertical metrics from
|
|
// design units to units of 1/64 pixels, so that the result may be
|
|
// interpreted as pixels in 26.6 fixed point format.
|
|
yScale = FLOAT_FROM_26_6(FLOAT_FROM_16_16(ftMetrics.y_scale));
|
|
emHeight = mFace->units_per_EM * yScale;
|
|
} else { // Not scalable.
|
|
emHeight = ftMetrics.y_ppem;
|
|
// FT_Face doc says units_per_EM and a bunch of following fields
|
|
// are "only relevant to scalable outlines". If it's an sfnt,
|
|
// we can get units_per_EM from the 'head' table instead; otherwise,
|
|
// we don't have a unitsPerEm value so we can't compute/use yScale.
|
|
const TT_Header* head =
|
|
static_cast<TT_Header*>(FT_Get_Sfnt_Table(mFace, ft_sfnt_head));
|
|
if (head) {
|
|
gfxFloat emUnit = head->Units_Per_EM;
|
|
yScale = emHeight / emUnit;
|
|
}
|
|
}
|
|
|
|
TT_OS2 *os2 =
|
|
static_cast<TT_OS2*>(FT_Get_Sfnt_Table(mFace, ft_sfnt_os2));
|
|
|
|
aMetrics->maxAscent = FLOAT_FROM_26_6(ftMetrics.ascender);
|
|
aMetrics->maxDescent = -FLOAT_FROM_26_6(ftMetrics.descender);
|
|
aMetrics->maxAdvance = FLOAT_FROM_26_6(ftMetrics.max_advance);
|
|
|
|
gfxFloat lineHeight;
|
|
if (os2 && os2->sTypoAscender && yScale > 0.0) {
|
|
aMetrics->emAscent = os2->sTypoAscender * yScale;
|
|
aMetrics->emDescent = -os2->sTypoDescender * yScale;
|
|
FT_Short typoHeight =
|
|
os2->sTypoAscender - os2->sTypoDescender + os2->sTypoLineGap;
|
|
lineHeight = typoHeight * yScale;
|
|
|
|
// If the OS/2 fsSelection USE_TYPO_METRICS bit is set,
|
|
// set maxAscent/Descent from the sTypo* fields instead of hhea.
|
|
const uint16_t kUseTypoMetricsMask = 1 << 7;
|
|
if (os2->fsSelection & kUseTypoMetricsMask) {
|
|
aMetrics->maxAscent = NS_round(aMetrics->emAscent);
|
|
aMetrics->maxDescent = NS_round(aMetrics->emDescent);
|
|
} else {
|
|
// maxAscent/maxDescent get used for frame heights, and some fonts
|
|
// don't have the HHEA table ascent/descent set (bug 279032).
|
|
// We use NS_round here to parallel the pixel-rounded values that
|
|
// freetype gives us for ftMetrics.ascender/descender.
|
|
aMetrics->maxAscent =
|
|
std::max(aMetrics->maxAscent, NS_round(aMetrics->emAscent));
|
|
aMetrics->maxDescent =
|
|
std::max(aMetrics->maxDescent, NS_round(aMetrics->emDescent));
|
|
}
|
|
} else {
|
|
aMetrics->emAscent = aMetrics->maxAscent;
|
|
aMetrics->emDescent = aMetrics->maxDescent;
|
|
lineHeight = FLOAT_FROM_26_6(ftMetrics.height);
|
|
}
|
|
|
|
cairo_text_extents_t extents;
|
|
*aSpaceGlyph = GetCharExtents(' ', &extents);
|
|
if (*aSpaceGlyph) {
|
|
aMetrics->spaceWidth = extents.x_advance;
|
|
} else {
|
|
aMetrics->spaceWidth = aMetrics->maxAdvance; // guess
|
|
}
|
|
|
|
aMetrics->zeroOrAveCharWidth = 0.0;
|
|
if (GetCharExtents('0', &extents)) {
|
|
aMetrics->zeroOrAveCharWidth = extents.x_advance;
|
|
}
|
|
|
|
// Prefering a measured x over sxHeight because sxHeight doesn't consider
|
|
// hinting, but maybe the x extents are not quite right in some fancy
|
|
// script fonts. CSS 2.1 suggests possibly using the height of an "o",
|
|
// which would have a more consistent glyph across fonts.
|
|
if (GetCharExtents('x', &extents) && extents.y_bearing < 0.0) {
|
|
aMetrics->xHeight = -extents.y_bearing;
|
|
aMetrics->aveCharWidth = extents.x_advance;
|
|
} else {
|
|
if (os2 && os2->sxHeight && yScale > 0.0) {
|
|
aMetrics->xHeight = os2->sxHeight * yScale;
|
|
} else {
|
|
// CSS 2.1, section 4.3.2 Lengths: "In the cases where it is
|
|
// impossible or impractical to determine the x-height, a value of
|
|
// 0.5em should be used."
|
|
aMetrics->xHeight = 0.5 * emHeight;
|
|
}
|
|
aMetrics->aveCharWidth = 0.0; // updated below
|
|
}
|
|
// aveCharWidth is used for the width of text input elements so be
|
|
// liberal rather than conservative in the estimate.
|
|
if (os2 && os2->xAvgCharWidth) {
|
|
// Round to pixels as this is compared with maxAdvance to guess
|
|
// whether this is a fixed width font.
|
|
gfxFloat avgCharWidth =
|
|
ScaleRoundDesignUnits(os2->xAvgCharWidth, ftMetrics.x_scale);
|
|
aMetrics->aveCharWidth =
|
|
std::max(aMetrics->aveCharWidth, avgCharWidth);
|
|
}
|
|
aMetrics->aveCharWidth =
|
|
std::max(aMetrics->aveCharWidth, aMetrics->zeroOrAveCharWidth);
|
|
if (aMetrics->aveCharWidth == 0.0) {
|
|
aMetrics->aveCharWidth = aMetrics->spaceWidth;
|
|
}
|
|
if (aMetrics->zeroOrAveCharWidth == 0.0) {
|
|
aMetrics->zeroOrAveCharWidth = aMetrics->aveCharWidth;
|
|
}
|
|
// Apparently hinting can mean that max_advance is not always accurate.
|
|
aMetrics->maxAdvance =
|
|
std::max(aMetrics->maxAdvance, aMetrics->aveCharWidth);
|
|
|
|
// gfxFont::Metrics::underlineOffset is the position of the top of the
|
|
// underline.
|
|
//
|
|
// FT_FaceRec documentation describes underline_position as "the
|
|
// center of the underlining stem". This was the original definition
|
|
// of the PostScript metric, but in the PostScript table of OpenType
|
|
// fonts the metric is "the top of the underline"
|
|
// (http://www.microsoft.com/typography/otspec/post.htm), and FreeType
|
|
// (up to version 2.3.7) doesn't make any adjustment.
|
|
//
|
|
// Therefore get the underline position directly from the table
|
|
// ourselves when this table exists. Use FreeType's metrics for
|
|
// other (including older PostScript) fonts.
|
|
if (mFace->underline_position && mFace->underline_thickness && yScale > 0.0) {
|
|
aMetrics->underlineSize = mFace->underline_thickness * yScale;
|
|
TT_Postscript *post = static_cast<TT_Postscript*>
|
|
(FT_Get_Sfnt_Table(mFace, ft_sfnt_post));
|
|
if (post && post->underlinePosition) {
|
|
aMetrics->underlineOffset = post->underlinePosition * yScale;
|
|
} else {
|
|
aMetrics->underlineOffset = mFace->underline_position * yScale
|
|
+ 0.5 * aMetrics->underlineSize;
|
|
}
|
|
} else { // No underline info.
|
|
// Imitate Pango.
|
|
aMetrics->underlineSize = emHeight / 14.0;
|
|
aMetrics->underlineOffset = -aMetrics->underlineSize;
|
|
}
|
|
|
|
if (os2 && os2->yStrikeoutSize && os2->yStrikeoutPosition && yScale > 0.0) {
|
|
aMetrics->strikeoutSize = os2->yStrikeoutSize * yScale;
|
|
aMetrics->strikeoutOffset = os2->yStrikeoutPosition * yScale;
|
|
} else { // No strikeout info.
|
|
aMetrics->strikeoutSize = aMetrics->underlineSize;
|
|
// Use OpenType spec's suggested position for Roman font.
|
|
aMetrics->strikeoutOffset = emHeight * 409.0 / 2048.0
|
|
+ 0.5 * aMetrics->strikeoutSize;
|
|
}
|
|
SnapLineToPixels(aMetrics->strikeoutOffset, aMetrics->strikeoutSize);
|
|
|
|
aMetrics->maxHeight = aMetrics->maxAscent + aMetrics->maxDescent;
|
|
|
|
// Make the line height an integer number of pixels so that lines will be
|
|
// equally spaced (rather than just being snapped to pixels, some up and
|
|
// some down). Layout calculates line height from the emHeight +
|
|
// internalLeading + externalLeading, but first each of these is rounded
|
|
// to layout units. To ensure that the result is an integer number of
|
|
// pixels, round each of the components to pixels.
|
|
aMetrics->emHeight = floor(emHeight + 0.5);
|
|
|
|
// maxHeight will normally be an integer, but round anyway in case
|
|
// FreeType is configured differently.
|
|
aMetrics->internalLeading =
|
|
floor(aMetrics->maxHeight - aMetrics->emHeight + 0.5);
|
|
|
|
// Text input boxes currently don't work well with lineHeight
|
|
// significantly less than maxHeight (with Verdana, for example).
|
|
lineHeight = floor(std::max(lineHeight, aMetrics->maxHeight) + 0.5);
|
|
aMetrics->externalLeading =
|
|
lineHeight - aMetrics->internalLeading - aMetrics->emHeight;
|
|
|
|
// Ensure emAscent + emDescent == emHeight
|
|
gfxFloat sum = aMetrics->emAscent + aMetrics->emDescent;
|
|
aMetrics->emAscent = sum > 0.0 ?
|
|
aMetrics->emAscent * aMetrics->emHeight / sum : 0.0;
|
|
aMetrics->emDescent = aMetrics->emHeight - aMetrics->emAscent;
|
|
}
|
|
|
|
uint32_t
|
|
gfxFT2LockedFace::GetGlyph(uint32_t aCharCode)
|
|
{
|
|
if (MOZ_UNLIKELY(!mFace))
|
|
return 0;
|
|
|
|
#ifdef HAVE_FONTCONFIG_FCFREETYPE_H
|
|
// FcFreeTypeCharIndex will search starting from the most recently
|
|
// selected charmap. This can cause non-determistic behavior when more
|
|
// than one charmap supports a character but with different glyphs, as
|
|
// with older versions of MS Gothic, for example. Always prefer a Unicode
|
|
// charmap, if there is one. (FcFreeTypeCharIndex usually does the
|
|
// appropriate Unicode conversion, but some fonts have non-Roman glyphs
|
|
// for FT_ENCODING_APPLE_ROMAN characters.)
|
|
if (!mFace->charmap || mFace->charmap->encoding != FT_ENCODING_UNICODE) {
|
|
FT_Select_Charmap(mFace, FT_ENCODING_UNICODE);
|
|
}
|
|
|
|
return FcFreeTypeCharIndex(mFace, aCharCode);
|
|
#else
|
|
return FT_Get_Char_Index(mFace, aCharCode);
|
|
#endif
|
|
}
|
|
|
|
typedef FT_UInt (*GetCharVariantFunction)(FT_Face face,
|
|
FT_ULong charcode,
|
|
FT_ULong variantSelector);
|
|
|
|
uint32_t
|
|
gfxFT2LockedFace::GetUVSGlyph(uint32_t aCharCode, uint32_t aVariantSelector)
|
|
{
|
|
NS_PRECONDITION(aVariantSelector, "aVariantSelector should not be NULL");
|
|
|
|
if (MOZ_UNLIKELY(!mFace))
|
|
return 0;
|
|
|
|
// This function is available from FreeType 2.3.6 (June 2008).
|
|
static CharVariantFunction sGetCharVariantPtr = FindCharVariantFunction();
|
|
if (!sGetCharVariantPtr)
|
|
return 0;
|
|
|
|
#ifdef HAVE_FONTCONFIG_FCFREETYPE_H
|
|
// FcFreeTypeCharIndex may have changed the selected charmap.
|
|
// FT_Face_GetCharVariantIndex needs a unicode charmap.
|
|
if (!mFace->charmap || mFace->charmap->encoding != FT_ENCODING_UNICODE) {
|
|
FT_Select_Charmap(mFace, FT_ENCODING_UNICODE);
|
|
}
|
|
#endif
|
|
|
|
return (*sGetCharVariantPtr)(mFace, aCharCode, aVariantSelector);
|
|
}
|
|
|
|
uint32_t
|
|
gfxFT2LockedFace::GetCharExtents(char aChar, cairo_text_extents_t* aExtents)
|
|
{
|
|
NS_PRECONDITION(aExtents != nullptr, "aExtents must not be NULL");
|
|
|
|
if (!mFace)
|
|
return 0;
|
|
|
|
FT_UInt gid = mGfxFont->GetGlyph(aChar);
|
|
if (gid) {
|
|
mGfxFont->GetGlyphExtents(gid, aExtents);
|
|
}
|
|
|
|
return gid;
|
|
}
|
|
|
|
gfxFT2LockedFace::CharVariantFunction
|
|
gfxFT2LockedFace::FindCharVariantFunction()
|
|
{
|
|
// This function is available from FreeType 2.3.6 (June 2008).
|
|
PRLibrary *lib = nullptr;
|
|
CharVariantFunction function =
|
|
reinterpret_cast<CharVariantFunction>
|
|
(PR_FindFunctionSymbolAndLibrary("FT_Face_GetCharVariantIndex", &lib));
|
|
if (!lib) {
|
|
return nullptr;
|
|
}
|
|
|
|
FT_Int major;
|
|
FT_Int minor;
|
|
FT_Int patch;
|
|
FT_Library_Version(mFace->glyph->library, &major, &minor, &patch);
|
|
|
|
// Versions 2.4.0 to 2.4.3 crash if configured with
|
|
// FT_CONFIG_OPTION_OLD_INTERNALS. Presence of the symbol FT_Alloc
|
|
// indicates FT_CONFIG_OPTION_OLD_INTERNALS.
|
|
if (major == 2 && minor == 4 && patch < 4 &&
|
|
PR_FindFunctionSymbol(lib, "FT_Alloc")) {
|
|
function = nullptr;
|
|
}
|
|
|
|
// Decrement the reference count incremented in
|
|
// PR_FindFunctionSymbolAndLibrary.
|
|
PR_UnloadLibrary(lib);
|
|
|
|
return function;
|
|
}
|