void Font::platformGlyphInit()
{
auto* glyphPageZero = glyphPage(0);
if (!glyphPageZero) {
determinePitch();
return;
}
// Ask for the glyph for 0 to avoid paging in ZERO WIDTH SPACE. Control characters, including 0,
// are mapped to the ZERO WIDTH SPACE glyph.
m_zeroWidthSpaceGlyph = glyphPageZero->glyphDataForCharacter(0).glyph;
// Nasty hack to determine if we should round or ceil space widths.
// If the font is monospace or fake monospace we ceil to ensure that
// every character and the space are the same width. Otherwise we round.
m_spaceGlyph = glyphPageZero->glyphDataForCharacter(' ').glyph;
float width = widthForGlyph(m_spaceGlyph);
m_spaceWidth = width;
m_zeroGlyph = glyphPageZero->glyphDataForCharacter('0').glyph;
m_fontMetrics.setZeroWidth(widthForGlyph(m_zeroGlyph));
determinePitch();
m_adjustedSpaceWidth = m_treatAsFixedPitch ? ceilf(width) : roundf(width);
// Force the glyph for ZERO WIDTH SPACE to have zero width, unless it is shared with SPACE.
// Helvetica is an example of a non-zero width ZERO WIDTH SPACE glyph.
// See <http://bugs.webkit.org/show_bug.cgi?id=13178> and Font::isZeroWidthSpaceGlyph()
if (m_zeroWidthSpaceGlyph == m_spaceGlyph)
m_zeroWidthSpaceGlyph = 0;
}
void SimpleFontData::platformInit()
{
FS_FIXED ascender = 0;
FS_FIXED descender = 0;
FS_FIXED leading = 0;
FsAscDescLeadSource source;
FS_LONG result;
if (m_platformData.size() > 0) {
// FIXME: hack! FS_get_ascender_descender_leading() returns ERR_NO_CURRENT_SFNT when size is 0, even though we called FS_set_scale and m_platformData.font()->cur_sfnt is not 0
result = FS_get_ascender_descender_leading(m_platformData.font(), &ascender, &descender, &leading, &source);
ASSERT_UNUSED(result, result == SUCCESS);
}
m_fontMetrics.setAscent(FS_ROUND(ascender));
m_fontMetrics.setDescent(FS_ROUND(descender));
m_fontMetrics.setLineGap(iTypeFixedToFloat(leading));
m_fontMetrics.setLineSpacing(lroundf(m_fontMetrics.ascent()) + lroundf(m_fontMetrics.descent()) + lroundf(m_fontMetrics.lineGap()));
FONT_METRICS metrics;
result = FS_font_metrics(m_platformData.font(), &metrics);
ASSERT_UNUSED(result, result == SUCCESS);
// m_fontMetrics.setUnitsPerEm(FS_get_design_units(m_platformData().font()));
m_fontMetrics.setUnitsPerEm(metrics.unitsPerEm);
FS_USHORT xRange = metrics.font_bbox.xMax - metrics.font_bbox.xMin;
m_maxCharWidth = roundf((xRange * roundf(m_platformData.size())) / metrics.unitsPerEm);
TTF_OS2 os2;
if (FS_get_table_structure(m_platformData.font(), TAG_OS2, &os2) == SUCCESS && os2.sxHeight && os2.xAvgCharWidth) {
FS_USHORT yppem = m_platformData.font()->lpm;
m_fontMetrics.setXHeight(static_cast<float>(os2.sxHeight) * yppem / metrics.unitsPerEm);
m_avgCharWidth = static_cast<float>(os2.xAvgCharWidth) * yppem / metrics.unitsPerEm;
} else {
// HACK
m_fontMetrics.setXHeight(m_fontMetrics.ascent() * 0.56);
m_fontMetrics.setHasXHeight(false);
m_avgCharWidth = m_fontMetrics.xHeight();
GlyphPage* glyphPageZero = GlyphPageTreeNode::getRootChild(this, 0)->page();
if (glyphPageZero) {
static const UChar32 xChar = 'x';
const Glyph xGlyph = glyphPageZero->glyphDataForCharacter(xChar).glyph;
if (xGlyph) {
// In widthForGlyph(), xGlyph will be compared with
// m_zeroWidthSpaceGlyph, which isn't initialized yet here.
// Initialize it with zero to make sure widthForGlyph() returns
// the right width.
m_zeroWidthSpaceGlyph = 0;
m_avgCharWidth = widthForGlyph(xGlyph);
}
}
}
if (m_platformData.orientation() == Vertical && !isTextOrientationFallback())
m_hasVerticalGlyphs = FS_get_table(m_platformData.font(), openTypeTag('v', 'h', 'e', 'a'), TBL_QUERY, 0)
|| FS_get_table(m_platformData.font(), openTypeTag('V', 'O', 'R', 'G'), TBL_QUERY, 0);
}
void SimpleFontData::platformGlyphInit()
{
GlyphPage* glyphPageZero = GlyphPageTreeNode::getRootChild(this, 0)->page();
if (!glyphPageZero) {
LOG_ERROR("Failed to get glyph page zero.");
m_spaceGlyph = 0;
m_spaceWidth = 0;
m_zeroGlyph = 0;
m_adjustedSpaceWidth = 0;
determinePitch();
m_zeroWidthSpaceGlyph = 0;
m_missingGlyphData.fontData = this;
m_missingGlyphData.glyph = 0;
return;
}
m_zeroWidthSpaceGlyph = glyphPageZero->glyphDataForCharacter(0).glyph;
// Nasty hack to determine if we should round or ceil space widths.
// If the font is monospace or fake monospace we ceil to ensure that
// every character and the space are the same width. Otherwise we round.
m_spaceGlyph = glyphPageZero->glyphDataForCharacter(' ').glyph;
float width = widthForGlyph(m_spaceGlyph);
m_spaceWidth = width;
m_zeroGlyph = glyphPageZero->glyphDataForCharacter('0').glyph;
m_fontMetrics.setZeroWidth(widthForGlyph(m_zeroGlyph));
determinePitch();
m_adjustedSpaceWidth = m_treatAsFixedPitch ? ceilf(width) : roundf(width);
// Force the glyph for ZERO WIDTH SPACE to have zero width, unless it is shared with SPACE.
// Helvetica is an example of a non-zero width ZERO WIDTH SPACE glyph.
// See <http://bugs.webkit.org/show_bug.cgi?id=13178>
// Ask for the glyph for 0 to avoid paging in ZERO WIDTH SPACE. Control characters, including 0,
// are mapped to the ZERO WIDTH SPACE glyph.
if (m_zeroWidthSpaceGlyph == m_spaceGlyph) {
m_zeroWidthSpaceGlyph = 0;
LOG_ERROR("Font maps SPACE and ZERO WIDTH SPACE to the same glyph. Glyph width will not be overridden.");
}
m_missingGlyphData.fontData = this;
m_missingGlyphData.glyph = 0;
}
void SimpleFontData::platformGlyphInit() {
SkTypeface* typeface = platformData().typeface();
if (!typeface->countGlyphs()) {
m_spaceGlyph = 0;
m_spaceWidth = 0;
m_zeroGlyph = 0;
m_missingGlyphData.fontData = this;
m_missingGlyphData.glyph = 0;
return;
}
// Nasty hack to determine if we should round or ceil space widths.
// If the font is monospace or fake monospace we ceil to ensure that
// every character and the space are the same width. Otherwise we round.
m_spaceGlyph = glyphForCharacter(' ');
float width = widthForGlyph(m_spaceGlyph);
m_spaceWidth = width;
m_zeroGlyph = glyphForCharacter('0');
m_fontMetrics.setZeroWidth(widthForGlyph(m_zeroGlyph));
m_missingGlyphData.fontData = this;
m_missingGlyphData.glyph = 0;
}
void SimpleFontData::platformInit()
{
SkPaint paint;
SkPaint::FontMetrics metrics;
m_font.setupPaint(&paint);
paint.getFontMetrics(&metrics);
// Beware those who step here: This code is designed to match Win32 font
// metrics *exactly*.
if (metrics.fVDMXMetricsValid) {
m_ascent = metrics.fVDMXAscent;
m_descent = metrics.fVDMXDescent;
} else {
m_ascent = SkScalarRound(-metrics.fAscent);
m_descent = SkScalarRound(metrics.fHeight) - m_ascent;
}
if (metrics.fXHeight)
m_xHeight = metrics.fXHeight;
else {
// hack taken from the Windows port
m_xHeight = static_cast<float>(m_ascent) * 0.56;
}
m_lineGap = SkScalarRound(metrics.fLeading);
m_lineSpacing = m_ascent + m_descent + m_lineGap;
// In WebKit/WebCore/platform/graphics/SimpleFontData.cpp, m_spaceWidth is
// calculated for us, but we need to calculate m_maxCharWidth and
// m_avgCharWidth in order for text entry widgets to be sized correctly.
m_maxCharWidth = SkScalarRound(metrics.fXRange * SkScalarRound(m_font.size()));
if (metrics.fAvgCharWidth)
m_avgCharWidth = SkScalarRound(metrics.fAvgCharWidth);
else {
m_avgCharWidth = m_xHeight;
GlyphPage* glyphPageZero = GlyphPageTreeNode::getRootChild(this, 0)->page();
if (glyphPageZero) {
static const UChar32 x_char = 'x';
const Glyph xGlyph = glyphPageZero->glyphDataForCharacter(x_char).glyph;
if (xGlyph)
m_avgCharWidth = widthForGlyph(xGlyph);
}
}
}
FontData::FontData(const FontPlatformData& f)
: m_font(f)
, m_treatAsFixedPitch(false)
, m_smallCapsFontData(0)
{
platformInit();
// Nasty hack to determine if we should round or ceil space widths.
// If the font is monospace or fake monospace we ceil to ensure that
// every character and the space are the same width. Otherwise we round.
m_spaceGlyph = GlyphPageTreeNode::getRootChild(this, 0)->page()->glyphDataForCharacter(' ').glyph;
float width = widthForGlyph(m_spaceGlyph);
m_spaceWidth = width;
determinePitch();
m_adjustedSpaceWidth = m_treatAsFixedPitch ? ceilf(width) : roundf(width);
m_missingGlyphData.fontData = this;
m_missingGlyphData.glyph = 0;
}
// Estimates of avgCharWidth and maxCharWidth for platforms that don't support accessing these values from the font.
void Font::initCharWidths()
{
auto* glyphPageZero = glyphPage(0);
// Treat the width of a '0' as the avgCharWidth.
if (m_avgCharWidth <= 0.f && glyphPageZero) {
static const UChar32 digitZeroChar = '0';
Glyph digitZeroGlyph = glyphPageZero->glyphDataForCharacter(digitZeroChar).glyph;
if (digitZeroGlyph)
m_avgCharWidth = widthForGlyph(digitZeroGlyph);
}
// If we can't retrieve the width of a '0', fall back to the x height.
if (m_avgCharWidth <= 0.f)
m_avgCharWidth = m_fontMetrics.xHeight();
if (m_maxCharWidth <= 0.f)
m_maxCharWidth = std::max(m_avgCharWidth, m_fontMetrics.floatAscent());
}
// Estimates of avgCharWidth and maxCharWidth for platforms that don't support accessing these values from the font.
void SimpleFontData::initCharWidths()
{
GlyphPage* glyphPageZero = GlyphPageTreeNode::getRootChild(this, 0)->page();
// Treat the width of a '0' as the avgCharWidth.
if (m_avgCharWidth <= 0.f && glyphPageZero) {
static const UChar32 digitZeroChar = '0';
Glyph digitZeroGlyph = glyphPageZero->glyphDataForCharacter(digitZeroChar).glyph;
if (digitZeroGlyph)
m_avgCharWidth = widthForGlyph(digitZeroGlyph);
}
// If we can't retrieve the width of a '0', fall back to the x height.
if (m_avgCharWidth <= 0.f)
m_avgCharWidth = m_fontMetrics.xHeight();
if (m_maxCharWidth <= 0.f)
m_maxCharWidth = max(m_avgCharWidth, m_fontMetrics.floatAscent());
}
void SimpleFontData::platformInit(bool subpixelAscentDescent) {
if (!m_platformData.size()) {
m_fontMetrics.reset();
m_avgCharWidth = 0;
m_maxCharWidth = 0;
return;
}
SkPaint::FontMetrics metrics;
m_platformData.setupPaint(&m_paint);
m_paint.setTextEncoding(SkPaint::kGlyphID_TextEncoding);
m_paint.getFontMetrics(&metrics);
SkTypeface* face = m_paint.getTypeface();
ASSERT(face);
int vdmxAscent = 0, vdmxDescent = 0;
bool isVDMXValid = false;
#if OS(LINUX) || OS(ANDROID)
// Manually digging up VDMX metrics is only applicable when bytecode hinting
// using FreeType. With DirectWrite or CoreText, no bytecode hinting is ever
// done. This code should be pushed into FreeType (hinted font metrics).
static const uint32_t vdmxTag = SkSetFourByteTag('V', 'D', 'M', 'X');
int pixelSize = m_platformData.size() + 0.5;
if (!m_paint.isAutohinted() &&
(m_paint.getHinting() == SkPaint::kFull_Hinting ||
m_paint.getHinting() == SkPaint::kNormal_Hinting)) {
size_t vdmxSize = face->getTableSize(vdmxTag);
if (vdmxSize && vdmxSize < maxVDMXTableSize) {
uint8_t* vdmxTable = (uint8_t*)WTF::Partitions::fastMalloc(
vdmxSize, WTF_HEAP_PROFILER_TYPE_NAME(SimpleFontData));
if (vdmxTable &&
face->getTableData(vdmxTag, 0, vdmxSize, vdmxTable) == vdmxSize &&
parseVDMX(&vdmxAscent, &vdmxDescent, vdmxTable, vdmxSize, pixelSize))
isVDMXValid = true;
WTF::Partitions::fastFree(vdmxTable);
}
}
#endif
float ascent;
float descent;
// Beware those who step here: This code is designed to match Win32 font
// metrics *exactly* except:
// - the adjustment of ascent/descent on Linux/Android
// - metrics.fAscent and .fDesscent are not rounded to int for tiny fonts
if (isVDMXValid) {
ascent = vdmxAscent;
descent = -vdmxDescent;
} else {
// For tiny fonts, the rounding of fAscent and fDescent results in equal
// baseline for different types of text baselines (crbug.com/338908).
// Please see CanvasRenderingContext2D::getFontBaseline for the heuristic.
if (subpixelAscentDescent &&
(-metrics.fAscent < 3 || -metrics.fAscent + metrics.fDescent < 2)) {
ascent = -metrics.fAscent;
descent = metrics.fDescent;
} else {
ascent = SkScalarRoundToScalar(-metrics.fAscent);
descent = SkScalarRoundToScalar(metrics.fDescent);
}
#if OS(LINUX) || OS(ANDROID)
// When subpixel positioning is enabled, if the descent is rounded down, the
// descent part of the glyph may be truncated when displayed in a 'overflow:
// hidden' container. To avoid that, borrow 1 unit from the ascent when
// possible.
// FIXME: This can be removed if sub-pixel ascent/descent is supported.
if (platformData().getFontRenderStyle().useSubpixelPositioning &&
descent < SkScalarToFloat(metrics.fDescent) && ascent >= 1) {
++descent;
--ascent;
}
#endif
}
#if OS(MACOSX)
// We are preserving this ascent hack to match Safari's ascent adjustment
// in their SimpleFontDataMac.mm, for details see crbug.com/445830.
// We need to adjust Times, Helvetica, and Courier to closely match the
// vertical metrics of their Microsoft counterparts that are the de facto
// web standard. The AppKit adjustment of 20% is too big and is
// incorrectly added to line spacing, so we use a 15% adjustment instead
// and add it to the ascent.
DEFINE_STATIC_LOCAL(AtomicString, timesName, ("Times"));
DEFINE_STATIC_LOCAL(AtomicString, helveticaName, ("Helvetica"));
DEFINE_STATIC_LOCAL(AtomicString, courierName, ("Courier"));
String familyName = m_platformData.fontFamilyName();
if (familyName == timesName || familyName == helveticaName ||
familyName == courierName)
ascent += floorf(((ascent + descent) * 0.15f) + 0.5f);
#endif
m_fontMetrics.setAscent(ascent);
m_fontMetrics.setDescent(descent);
float xHeight;
if (metrics.fXHeight) {
xHeight = metrics.fXHeight;
#if OS(MACOSX)
// Mac OS CTFontGetXHeight reports the bounding box height of x,
// including parts extending below the baseline and apparently no x-height
// value from the OS/2 table. However, the CSS ex unit
// expects only parts above the baseline, hence measuring the glyph:
// http://www.w3.org/TR/css3-values/#ex-unit
const Glyph xGlyph = glyphForCharacter('x');
if (xGlyph) {
FloatRect glyphBounds(boundsForGlyph(xGlyph));
// SkGlyph bounds, y down, based on rendering at (0,0).
xHeight = -glyphBounds.y();
}
#endif
m_fontMetrics.setXHeight(xHeight);
} else {
xHeight = ascent * 0.56; // Best guess from Windows font metrics.
m_fontMetrics.setXHeight(xHeight);
m_fontMetrics.setHasXHeight(false);
}
float lineGap = SkScalarToFloat(metrics.fLeading);
m_fontMetrics.setLineGap(lineGap);
m_fontMetrics.setLineSpacing(lroundf(ascent) + lroundf(descent) +
lroundf(lineGap));
if (platformData().isVerticalAnyUpright() && !isTextOrientationFallback()) {
static const uint32_t vheaTag = SkSetFourByteTag('v', 'h', 'e', 'a');
static const uint32_t vorgTag = SkSetFourByteTag('V', 'O', 'R', 'G');
size_t vheaSize = face->getTableSize(vheaTag);
size_t vorgSize = face->getTableSize(vorgTag);
if ((vheaSize > 0) || (vorgSize > 0))
m_hasVerticalGlyphs = true;
}
// In WebKit/WebCore/platform/graphics/SimpleFontData.cpp, m_spaceWidth is
// calculated for us, but we need to calculate m_maxCharWidth and
// m_avgCharWidth in order for text entry widgets to be sized correctly.
#if OS(WIN)
m_maxCharWidth = SkScalarRoundToInt(metrics.fMaxCharWidth);
// Older version of the DirectWrite API doesn't implement support for max
// char width. Fall back on a multiple of the ascent. This is entirely
// arbitrary but comes pretty close to the expected value in most cases.
if (m_maxCharWidth < 1)
m_maxCharWidth = ascent * 2;
#elif OS(MACOSX)
// FIXME: The current avg/max character width calculation is not ideal,
// it should check either the OS2 table or, better yet, query FontMetrics.
// Sadly FontMetrics provides incorrect data on Mac at the moment.
// https://crbug.com/420901
m_maxCharWidth = std::max(m_avgCharWidth, m_fontMetrics.floatAscent());
#else
// Better would be to rely on either fMaxCharWidth or fAveCharWidth.
// skbug.com/3087
m_maxCharWidth = SkScalarRoundToInt(metrics.fXMax - metrics.fXMin);
#endif
#if !OS(MACOSX)
if (metrics.fAvgCharWidth) {
m_avgCharWidth = SkScalarRoundToInt(metrics.fAvgCharWidth);
} else {
#endif
m_avgCharWidth = xHeight;
const Glyph xGlyph = glyphForCharacter('x');
if (xGlyph) {
m_avgCharWidth = widthForGlyph(xGlyph);
}
#if !OS(MACOSX)
}
#endif
if (int unitsPerEm = face->getUnitsPerEm())
m_fontMetrics.setUnitsPerEm(unitsPerEm);
}
void SimpleFontData::platformInit()
{
if (!m_platformData.size()) {
m_fontMetrics.reset();
m_avgCharWidth = 0;
m_maxCharWidth = 0;
return;
}
SkPaint paint;
SkPaint::FontMetrics metrics;
m_platformData.setupPaint(&paint);
paint.getFontMetrics(&metrics);
const SkFontID fontID = m_platformData.uniqueID();
static const uint32_t vdmxTag = SkSetFourByteTag('V', 'D', 'M', 'X');
int pixelSize = m_platformData.size() + 0.5;
int vdmxAscent, vdmxDescent;
bool isVDMXValid = false;
size_t vdmxSize = SkFontHost::GetTableSize(fontID, vdmxTag);
if (vdmxSize && vdmxSize < maxVDMXTableSize) {
uint8_t* vdmxTable = (uint8_t*) fastMalloc(vdmxSize);
if (vdmxTable
&& SkFontHost::GetTableData(fontID, vdmxTag, 0, vdmxSize, vdmxTable) == vdmxSize
&& parseVDMX(&vdmxAscent, &vdmxDescent, vdmxTable, vdmxSize, pixelSize))
isVDMXValid = true;
fastFree(vdmxTable);
}
float ascent;
float descent;
// Beware those who step here: This code is designed to match Win32 font
// metrics *exactly*.
if (isVDMXValid) {
ascent = vdmxAscent;
descent = -vdmxDescent;
} else {
SkScalar height = -metrics.fAscent + metrics.fDescent + metrics.fLeading;
ascent = SkScalarRound(-metrics.fAscent);
descent = SkScalarRound(height) - ascent;
}
m_fontMetrics.setAscent(ascent);
m_fontMetrics.setDescent(descent);
float xHeight;
if (metrics.fXHeight)
xHeight = metrics.fXHeight;
else {
// hack taken from the Windows port
xHeight = ascent * 0.56f;
}
float lineGap = SkScalarToFloat(metrics.fLeading);
m_fontMetrics.setLineGap(lineGap);
m_fontMetrics.setXHeight(xHeight);
m_fontMetrics.setLineSpacing(lroundf(ascent) + lroundf(descent) + lroundf(lineGap));
if (platformData().orientation() == Vertical && !isTextOrientationFallback()) {
static const uint32_t vheaTag = SkSetFourByteTag('v', 'h', 'e', 'a');
static const uint32_t vorgTag = SkSetFourByteTag('V', 'O', 'R', 'G');
size_t vheaSize = SkFontHost::GetTableSize(fontID, vheaTag);
size_t vorgSize = SkFontHost::GetTableSize(fontID, vorgTag);
if ((vheaSize > 0) || (vorgSize > 0))
m_hasVerticalGlyphs = true;
}
// In WebKit/WebCore/platform/graphics/SimpleFontData.cpp, m_spaceWidth is
// calculated for us, but we need to calculate m_maxCharWidth and
// m_avgCharWidth in order for text entry widgets to be sized correctly.
SkScalar xRange = metrics.fXMax - metrics.fXMin;
m_maxCharWidth = SkScalarRound(xRange * SkScalarRound(m_platformData.size()));
if (metrics.fAvgCharWidth)
m_avgCharWidth = SkScalarRound(metrics.fAvgCharWidth);
else {
m_avgCharWidth = xHeight;
GlyphPage* glyphPageZero = GlyphPageTreeNode::getRootChild(this, 0)->page();
if (glyphPageZero) {
static const UChar32 x_char = 'x';
const Glyph xGlyph = glyphPageZero->glyphDataForCharacter(x_char).glyph;
if (xGlyph)
m_avgCharWidth = widthForGlyph(xGlyph);
}
}
}
void SimpleFontData::platformInit() {
if (!m_platformData.size()) {
m_fontMetrics.reset();
m_avgCharWidth = 0;
m_maxCharWidth = 0;
return;
}
SkPaint paint;
SkPaint::FontMetrics metrics;
m_platformData.setupPaint(&paint);
paint.getFontMetrics(&metrics);
SkTypeface* face = paint.getTypeface();
ASSERT(face);
int vdmxAscent = 0, vdmxDescent = 0;
bool isVDMXValid = false;
#if OS(LINUX) || OS(ANDROID)
// Manually digging up VDMX metrics is only applicable when bytecode hinting
// using FreeType. With GDI, the metrics will already have taken this into
// account (as needed). With DirectWrite or CoreText, no bytecode hinting is
// ever done. This code should be pushed into FreeType (hinted font metrics).
static const uint32_t vdmxTag = SkSetFourByteTag('V', 'D', 'M', 'X');
int pixelSize = m_platformData.size() + 0.5;
if (!paint.isAutohinted() &&
(paint.getHinting() == SkPaint::kFull_Hinting ||
paint.getHinting() == SkPaint::kNormal_Hinting)) {
size_t vdmxSize = face->getTableSize(vdmxTag);
if (vdmxSize && vdmxSize < maxVDMXTableSize) {
uint8_t* vdmxTable = (uint8_t*)fastMalloc(vdmxSize);
if (vdmxTable &&
face->getTableData(vdmxTag, 0, vdmxSize, vdmxTable) == vdmxSize &&
parseVDMX(&vdmxAscent, &vdmxDescent, vdmxTable, vdmxSize, pixelSize))
isVDMXValid = true;
fastFree(vdmxTable);
}
}
#endif
float ascent;
float descent;
// Beware those who step here: This code is designed to match Win32 font
// metrics *exactly* (except the adjustment of ascent/descent on
// Linux/Android).
if (isVDMXValid) {
ascent = vdmxAscent;
descent = -vdmxDescent;
} else {
ascent = SkScalarRoundToInt(-metrics.fAscent);
descent = SkScalarRoundToInt(metrics.fDescent);
#if OS(LINUX) || OS(ANDROID)
// When subpixel positioning is enabled, if the descent is rounded down, the
// descent part of the glyph may be truncated when displayed in a 'overflow:
// hidden' container. To avoid that, borrow 1 unit from the ascent when
// possible.
// FIXME: This can be removed if sub-pixel ascent/descent is supported.
if (platformData().fontRenderStyle().useSubpixelPositioning &&
descent < SkScalarToFloat(metrics.fDescent) && ascent >= 1) {
++descent;
--ascent;
}
#endif
}
m_fontMetrics.setAscent(ascent);
m_fontMetrics.setDescent(descent);
float xHeight;
if (metrics.fXHeight) {
xHeight = metrics.fXHeight;
m_fontMetrics.setXHeight(xHeight);
} else {
xHeight = ascent * 0.56; // Best guess from Windows font metrics.
m_fontMetrics.setXHeight(xHeight);
m_fontMetrics.setHasXHeight(false);
}
float lineGap = SkScalarToFloat(metrics.fLeading);
m_fontMetrics.setLineGap(lineGap);
m_fontMetrics.setLineSpacing(lroundf(ascent) + lroundf(descent) +
lroundf(lineGap));
SkScalar underlineThickness, underlinePosition;
if (metrics.hasUnderlineThickness(&underlineThickness) &&
metrics.hasUnderlinePosition(&underlinePosition)) {
m_fontMetrics.setUnderlineThickness(SkScalarToFloat(underlineThickness));
m_fontMetrics.setUnderlinePosition(SkScalarToFloat(-underlinePosition));
}
if (platformData().orientation() == Vertical &&
!isTextOrientationFallback()) {
static const uint32_t vheaTag = SkSetFourByteTag('v', 'h', 'e', 'a');
static const uint32_t vorgTag = SkSetFourByteTag('V', 'O', 'R', 'G');
size_t vheaSize = face->getTableSize(vheaTag);
size_t vorgSize = face->getTableSize(vorgTag);
if ((vheaSize > 0) || (vorgSize > 0))
m_hasVerticalGlyphs = true;
}
// In WebKit/WebCore/platform/graphics/SimpleFontData.cpp, m_spaceWidth is
// calculated for us, but we need to calculate m_maxCharWidth and
// m_avgCharWidth in order for text entry widgets to be sized correctly.
// FIXME: This seems incorrect and should probably use fMaxCharWidth as
// the code path above.
SkScalar xRange = metrics.fXMax - metrics.fXMin;
m_maxCharWidth =
SkScalarRoundToInt(xRange * SkScalarRoundToInt(m_platformData.size()));
if (metrics.fAvgCharWidth)
m_avgCharWidth = SkScalarRoundToInt(metrics.fAvgCharWidth);
else {
m_avgCharWidth = xHeight;
GlyphPage* glyphPageZero = GlyphPageTreeNode::getRootChild(this, 0)->page();
if (glyphPageZero) {
static const UChar32 xChar = 'x';
const Glyph xGlyph = glyphPageZero->glyphForCharacter(xChar);
if (xGlyph) {
// In widthForGlyph(), xGlyph will be compared with
// m_zeroWidthSpaceGlyph, which isn't initialized yet here.
// Initialize it with zero to make sure widthForGlyph() returns
// the right width.
m_zeroWidthSpaceGlyph = 0;
m_avgCharWidth = widthForGlyph(xGlyph);
}
}
}
if (int unitsPerEm = face->getUnitsPerEm())
m_fontMetrics.setUnitsPerEm(unitsPerEm);
}
SimpleFontData::SimpleFontData(const FontPlatformData& f, bool customFont, bool loading, SVGFontData* svgFontData)
: m_font(f)
, m_treatAsFixedPitch(false)
#if ENABLE(SVG_FONTS)
, m_svgFontData(svgFontData)
#endif
, m_isCustomFont(customFont)
, m_isLoading(loading)
, m_smallCapsFontData(0)
{
#if ENABLE(SVG_FONTS) && !PLATFORM(QT)
if (SVGFontFaceElement* svgFontFaceElement = svgFontData ? svgFontData->svgFontFaceElement() : 0) {
m_unitsPerEm = svgFontFaceElement->unitsPerEm();
double scale = f.size();
if (m_unitsPerEm)
scale /= m_unitsPerEm;
m_ascent = static_cast<int>(svgFontFaceElement->ascent() * scale);
m_descent = static_cast<int>(svgFontFaceElement->descent() * scale);
m_xHeight = static_cast<int>(svgFontFaceElement->xHeight() * scale);
m_lineGap = 0.1f * f.size();
m_lineSpacing = m_ascent + m_descent + m_lineGap;
m_spaceGlyph = 0;
m_spaceWidth = 0;
m_adjustedSpaceWidth = 0;
determinePitch();
m_missingGlyphData.fontData = this;
m_missingGlyphData.glyph = 0;
return;
}
#endif
platformInit();
GlyphPage* glyphPageZero = GlyphPageTreeNode::getRootChild(this, 0)->page();
if (!glyphPageZero) {
LOG_ERROR("Failed to get glyph page zero.");
m_spaceGlyph = 0;
m_spaceWidth = 0;
m_adjustedSpaceWidth = 0;
determinePitch();
m_missingGlyphData.fontData = this;
m_missingGlyphData.glyph = 0;
return;
}
// Nasty hack to determine if we should round or ceil space widths.
// If the font is monospace or fake monospace we ceil to ensure that
// every character and the space are the same width. Otherwise we round.
m_spaceGlyph = glyphPageZero->glyphDataForCharacter(' ').glyph;
float width = widthForGlyph(m_spaceGlyph);
m_spaceWidth = width;
determinePitch();
m_adjustedSpaceWidth = m_treatAsFixedPitch ? ceilf(width) : roundf(width);
// Force the glyph for ZERO WIDTH SPACE to have zero width, unless it is shared with SPACE.
// Helvetica is an example of a non-zero width ZERO WIDTH SPACE glyph.
// See <http://bugs.webkit.org/show_bug.cgi?id=13178>
// Ask for the glyph for 0 to avoid paging in ZERO WIDTH SPACE. Control characters, including 0,
// are mapped to the ZERO WIDTH SPACE glyph.
Glyph zeroWidthSpaceGlyph = glyphPageZero->glyphDataForCharacter(0).glyph;
if (zeroWidthSpaceGlyph) {
if (zeroWidthSpaceGlyph != m_spaceGlyph)
m_glyphToWidthMap.setWidthForGlyph(zeroWidthSpaceGlyph, 0);
else
LOG_ERROR("Font maps SPACE and ZERO WIDTH SPACE to the same glyph. Glyph width not overridden.");
}
m_missingGlyphData.fontData = this;
m_missingGlyphData.glyph = 0;
}
void SimpleFontData::platformInit()
{
if (!m_platformData.size()) {
m_fontMetrics.reset();
m_avgCharWidth = 0;
m_maxCharWidth = 0;
return;
}
SkPaint paint;
SkPaint::FontMetrics metrics;
m_platformData.setupPaint(&paint);
paint.getFontMetrics(&metrics);
const SkFontID fontID = m_platformData.uniqueID();
static const uint32_t vdmxTag = SkSetFourByteTag('V', 'D', 'M', 'X');
int pixelSize = m_platformData.size() + 0.5;
int vdmxAscent, vdmxDescent;
bool isVDMXValid = false;
size_t vdmxSize = SkFontHost::GetTableSize(fontID, vdmxTag);
if (vdmxSize && vdmxSize < maxVDMXTableSize) {
uint8_t* vdmxTable = (uint8_t*) fastMalloc(vdmxSize);
if (vdmxTable
&& SkFontHost::GetTableData(fontID, vdmxTag, 0, vdmxSize, vdmxTable) == vdmxSize
&& parseVDMX(&vdmxAscent, &vdmxDescent, vdmxTable, vdmxSize, pixelSize))
isVDMXValid = true;
fastFree(vdmxTable);
}
float ascent;
float descent;
// Beware those who step here: This code is designed to match Win32 font
// metrics *exactly* (except the adjustment of ascent/descent on Linux/Android).
if (isVDMXValid) {
ascent = vdmxAscent;
descent = -vdmxDescent;
} else {
SkScalar height = -metrics.fAscent + metrics.fDescent + metrics.fLeading;
ascent = SkScalarRound(-metrics.fAscent);
descent = SkScalarRound(height) - ascent;
#if OS(LINUX) || OS(ANDROID)
// When subpixel positioning is enabled, if the descent is rounded down, the descent part
// of the glyph may be truncated when displayed in a 'overflow: hidden' container.
// To avoid that, borrow 1 unit from the ascent when possible.
// FIXME: This can be removed if sub-pixel ascent/descent is supported.
if (platformData().fontRenderStyle().useSubpixelPositioning && descent < SkScalarToFloat(metrics.fDescent) && ascent >= 1) {
++descent;
--ascent;
}
#endif
}
m_fontMetrics.setAscent(ascent);
m_fontMetrics.setDescent(descent);
float xHeight;
if (metrics.fXHeight) {
xHeight = metrics.fXHeight;
m_fontMetrics.setXHeight(xHeight);
} else {
xHeight = ascent * 0.56; // Best guess from Windows font metrics.
m_fontMetrics.setXHeight(xHeight);
m_fontMetrics.setHasXHeight(false);
}
float lineGap = SkScalarToFloat(metrics.fLeading);
m_fontMetrics.setLineGap(lineGap);
m_fontMetrics.setLineSpacing(lroundf(ascent) + lroundf(descent) + lroundf(lineGap));
if (platformData().orientation() == Vertical && !isTextOrientationFallback()) {
static const uint32_t vheaTag = SkSetFourByteTag('v', 'h', 'e', 'a');
static const uint32_t vorgTag = SkSetFourByteTag('V', 'O', 'R', 'G');
size_t vheaSize = SkFontHost::GetTableSize(fontID, vheaTag);
size_t vorgSize = SkFontHost::GetTableSize(fontID, vorgTag);
if ((vheaSize > 0) || (vorgSize > 0))
m_hasVerticalGlyphs = true;
}
// In WebKit/WebCore/platform/graphics/SimpleFontData.cpp, m_spaceWidth is
// calculated for us, but we need to calculate m_maxCharWidth and
// m_avgCharWidth in order for text entry widgets to be sized correctly.
SkScalar xRange = metrics.fXMax - metrics.fXMin;
m_maxCharWidth = SkScalarRound(xRange * SkScalarRound(m_platformData.size()));
if (metrics.fAvgCharWidth)
m_avgCharWidth = SkScalarRound(metrics.fAvgCharWidth);
else {
m_avgCharWidth = xHeight;
GlyphPage* glyphPageZero = GlyphPageTreeNode::getRootChild(this, 0)->page();
if (glyphPageZero) {
static const UChar32 xChar = 'x';
const Glyph xGlyph = glyphPageZero->glyphDataForCharacter(xChar).glyph;
if (xGlyph) {
// In widthForGlyph(), xGlyph will be compared with
// m_zeroWidthSpaceGlyph, which isn't initialized yet here.
// Initialize it with zero to make sure widthForGlyph() returns
// the right width.
m_zeroWidthSpaceGlyph = 0;
m_avgCharWidth = widthForGlyph(xGlyph);
}
}
}
if (int unitsPerEm = paint.getTypeface()->getUnitsPerEm())
m_fontMetrics.setUnitsPerEm(unitsPerEm);
}
