mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-12-28 03:18:41 +00:00
718 lines
23 KiB
C++
718 lines
23 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 "gfxDWriteFonts.h"
|
|
|
|
#include "mozilla/MemoryReporting.h"
|
|
|
|
#include "gfxDWriteShaper.h"
|
|
#include "gfxHarfBuzzShaper.h"
|
|
#include <algorithm>
|
|
#include "gfxGraphiteShaper.h"
|
|
#include "gfxDWriteFontList.h"
|
|
#include "gfxContext.h"
|
|
#include <dwrite.h>
|
|
|
|
#include "gfxDWriteTextAnalysis.h"
|
|
|
|
#include "harfbuzz/hb.h"
|
|
|
|
// Chosen this as to resemble DWrite's own oblique face style.
|
|
#define OBLIQUE_SKEW_FACTOR 0.3
|
|
|
|
using namespace mozilla;
|
|
using namespace mozilla::gfx;
|
|
|
|
// This is also in gfxGDIFont.cpp. Would be nice to put it somewhere common,
|
|
// but we can't declare it in the gfxFont.h or gfxFontUtils.h headers
|
|
// because those are exported, and the cairo headers aren't.
|
|
static inline cairo_antialias_t
|
|
GetCairoAntialiasOption(gfxFont::AntialiasOption anAntialiasOption)
|
|
{
|
|
switch (anAntialiasOption) {
|
|
default:
|
|
case gfxFont::kAntialiasDefault:
|
|
return CAIRO_ANTIALIAS_DEFAULT;
|
|
case gfxFont::kAntialiasNone:
|
|
return CAIRO_ANTIALIAS_NONE;
|
|
case gfxFont::kAntialiasGrayscale:
|
|
return CAIRO_ANTIALIAS_GRAY;
|
|
case gfxFont::kAntialiasSubpixel:
|
|
return CAIRO_ANTIALIAS_SUBPIXEL;
|
|
}
|
|
}
|
|
|
|
// Code to determine whether Windows is set to use ClearType font smoothing;
|
|
// based on private functions in cairo-win32-font.c
|
|
|
|
#ifndef SPI_GETFONTSMOOTHINGTYPE
|
|
#define SPI_GETFONTSMOOTHINGTYPE 0x200a
|
|
#endif
|
|
#ifndef FE_FONTSMOOTHINGCLEARTYPE
|
|
#define FE_FONTSMOOTHINGCLEARTYPE 2
|
|
#endif
|
|
|
|
static bool
|
|
UsingClearType()
|
|
{
|
|
BOOL fontSmoothing;
|
|
if (!SystemParametersInfo(SPI_GETFONTSMOOTHING, 0, &fontSmoothing, 0) ||
|
|
!fontSmoothing)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
UINT type;
|
|
if (SystemParametersInfo(SPI_GETFONTSMOOTHINGTYPE, 0, &type, 0) &&
|
|
type == FE_FONTSMOOTHINGCLEARTYPE)
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// gfxDWriteFont
|
|
gfxDWriteFont::gfxDWriteFont(gfxFontEntry *aFontEntry,
|
|
const gfxFontStyle *aFontStyle,
|
|
bool aNeedsBold,
|
|
AntialiasOption anAAOption)
|
|
: gfxFont(aFontEntry, aFontStyle, anAAOption)
|
|
, mCairoFontFace(nullptr)
|
|
, mMetrics(nullptr)
|
|
, mNeedsOblique(false)
|
|
, mNeedsBold(aNeedsBold)
|
|
, mUseSubpixelPositions(false)
|
|
, mAllowManualShowGlyphs(true)
|
|
{
|
|
gfxDWriteFontEntry *fe =
|
|
static_cast<gfxDWriteFontEntry*>(aFontEntry);
|
|
nsresult rv;
|
|
DWRITE_FONT_SIMULATIONS sims = DWRITE_FONT_SIMULATIONS_NONE;
|
|
if ((GetStyle()->style & (NS_FONT_STYLE_ITALIC | NS_FONT_STYLE_OBLIQUE)) &&
|
|
!fe->IsItalic()) {
|
|
// For this we always use the font_matrix for uniformity. Not the
|
|
// DWrite simulation.
|
|
mNeedsOblique = true;
|
|
}
|
|
if (aNeedsBold) {
|
|
sims |= DWRITE_FONT_SIMULATIONS_BOLD;
|
|
}
|
|
|
|
rv = fe->CreateFontFace(getter_AddRefs(mFontFace), sims);
|
|
|
|
if (NS_FAILED(rv)) {
|
|
mIsValid = false;
|
|
return;
|
|
}
|
|
|
|
ComputeMetrics(anAAOption);
|
|
|
|
if (FontCanSupportGraphite()) {
|
|
mGraphiteShaper = new gfxGraphiteShaper(this);
|
|
}
|
|
|
|
if (FontCanSupportHarfBuzz()) {
|
|
mHarfBuzzShaper = new gfxHarfBuzzShaper(this);
|
|
}
|
|
}
|
|
|
|
gfxDWriteFont::~gfxDWriteFont()
|
|
{
|
|
if (mCairoFontFace) {
|
|
cairo_font_face_destroy(mCairoFontFace);
|
|
}
|
|
if (mScaledFont) {
|
|
cairo_scaled_font_destroy(mScaledFont);
|
|
}
|
|
delete mMetrics;
|
|
}
|
|
|
|
gfxFont*
|
|
gfxDWriteFont::CopyWithAntialiasOption(AntialiasOption anAAOption)
|
|
{
|
|
return new gfxDWriteFont(static_cast<gfxDWriteFontEntry*>(mFontEntry.get()),
|
|
&mStyle, mNeedsBold, anAAOption);
|
|
}
|
|
|
|
void
|
|
gfxDWriteFont::CreatePlatformShaper()
|
|
{
|
|
mPlatformShaper = new gfxDWriteShaper(this);
|
|
}
|
|
|
|
const gfxFont::Metrics&
|
|
gfxDWriteFont::GetMetrics()
|
|
{
|
|
return *mMetrics;
|
|
}
|
|
|
|
bool
|
|
gfxDWriteFont::GetFakeMetricsForArialBlack(DWRITE_FONT_METRICS *aFontMetrics)
|
|
{
|
|
gfxFontStyle style(mStyle);
|
|
style.weight = 700;
|
|
bool needsBold;
|
|
|
|
gfxFontEntry* fe =
|
|
gfxPlatformFontList::PlatformFontList()->
|
|
FindFontForFamily(NS_LITERAL_STRING("Arial"), &style, needsBold);
|
|
if (!fe || fe == mFontEntry) {
|
|
return false;
|
|
}
|
|
|
|
nsRefPtr<gfxFont> font = fe->FindOrMakeFont(&style, needsBold);
|
|
gfxDWriteFont *dwFont = static_cast<gfxDWriteFont*>(font.get());
|
|
dwFont->mFontFace->GetMetrics(aFontMetrics);
|
|
|
|
return true;
|
|
}
|
|
|
|
void
|
|
gfxDWriteFont::ComputeMetrics(AntialiasOption anAAOption)
|
|
{
|
|
DWRITE_FONT_METRICS fontMetrics;
|
|
if (!(mFontEntry->Weight() == 900 &&
|
|
!mFontEntry->IsUserFont() &&
|
|
mFontEntry->Name().EqualsLiteral("Arial Black") &&
|
|
GetFakeMetricsForArialBlack(&fontMetrics)))
|
|
{
|
|
mFontFace->GetMetrics(&fontMetrics);
|
|
}
|
|
|
|
if (mStyle.sizeAdjust != 0.0) {
|
|
gfxFloat aspect = (gfxFloat)fontMetrics.xHeight /
|
|
fontMetrics.designUnitsPerEm;
|
|
mAdjustedSize = mStyle.GetAdjustedSize(aspect);
|
|
} else {
|
|
mAdjustedSize = mStyle.size;
|
|
}
|
|
|
|
// Note that GetMeasuringMode depends on mAdjustedSize
|
|
if ((anAAOption == gfxFont::kAntialiasDefault &&
|
|
UsingClearType() &&
|
|
GetMeasuringMode() == DWRITE_MEASURING_MODE_NATURAL) ||
|
|
anAAOption == gfxFont::kAntialiasSubpixel)
|
|
{
|
|
mUseSubpixelPositions = true;
|
|
// note that this may be reset to FALSE if we determine that a bitmap
|
|
// strike is going to be used
|
|
}
|
|
|
|
gfxDWriteFontEntry *fe =
|
|
static_cast<gfxDWriteFontEntry*>(mFontEntry.get());
|
|
if (fe->IsCJKFont() && HasBitmapStrikeForSize(NS_lround(mAdjustedSize))) {
|
|
mAdjustedSize = NS_lround(mAdjustedSize);
|
|
mUseSubpixelPositions = false;
|
|
// if we have bitmaps, we need to tell Cairo NOT to use subpixel AA,
|
|
// to avoid the manual-subpixel codepath in cairo-d2d-surface.cpp
|
|
// which fails to render bitmap glyphs (see bug 626299).
|
|
// This option will be passed to the cairo_dwrite_scaled_font_t
|
|
// after creation.
|
|
mAllowManualShowGlyphs = false;
|
|
}
|
|
|
|
mMetrics = new gfxFont::Metrics;
|
|
::memset(mMetrics, 0, sizeof(*mMetrics));
|
|
|
|
mFUnitsConvFactor = float(mAdjustedSize / fontMetrics.designUnitsPerEm);
|
|
|
|
mMetrics->xHeight = fontMetrics.xHeight * mFUnitsConvFactor;
|
|
|
|
mMetrics->maxAscent = ceil(fontMetrics.ascent * mFUnitsConvFactor);
|
|
mMetrics->maxDescent = ceil(fontMetrics.descent * mFUnitsConvFactor);
|
|
mMetrics->maxHeight = mMetrics->maxAscent + mMetrics->maxDescent;
|
|
|
|
mMetrics->emHeight = mAdjustedSize;
|
|
mMetrics->emAscent = mMetrics->emHeight *
|
|
mMetrics->maxAscent / mMetrics->maxHeight;
|
|
mMetrics->emDescent = mMetrics->emHeight - mMetrics->emAscent;
|
|
|
|
mMetrics->maxAdvance = mAdjustedSize;
|
|
|
|
// try to get the true maxAdvance value from 'hhea'
|
|
gfxFontEntry::AutoTable hheaTable(GetFontEntry(),
|
|
TRUETYPE_TAG('h','h','e','a'));
|
|
if (hheaTable) {
|
|
uint32_t len;
|
|
const HheaTable* hhea =
|
|
reinterpret_cast<const HheaTable*>(hb_blob_get_data(hheaTable, &len));
|
|
if (len >= sizeof(HheaTable)) {
|
|
mMetrics->maxAdvance =
|
|
uint16_t(hhea->advanceWidthMax) * mFUnitsConvFactor;
|
|
}
|
|
}
|
|
|
|
mMetrics->internalLeading = std::max(mMetrics->maxHeight - mMetrics->emHeight, 0.0);
|
|
mMetrics->externalLeading = ceil(fontMetrics.lineGap * mFUnitsConvFactor);
|
|
|
|
UINT16 glyph = (uint16_t)GetSpaceGlyph();
|
|
mMetrics->spaceWidth = MeasureGlyphWidth(glyph);
|
|
|
|
// try to get aveCharWidth from the OS/2 table, fall back to measuring 'x'
|
|
// if the table is not available or if using hinted/pixel-snapped widths
|
|
if (mUseSubpixelPositions) {
|
|
mMetrics->aveCharWidth = 0;
|
|
gfxFontEntry::AutoTable os2Table(GetFontEntry(),
|
|
TRUETYPE_TAG('O','S','/','2'));
|
|
if (os2Table) {
|
|
uint32_t len;
|
|
const OS2Table* os2 =
|
|
reinterpret_cast<const OS2Table*>(hb_blob_get_data(os2Table, &len));
|
|
if (len >= 4) {
|
|
// Not checking against sizeof(mozilla::OS2Table) here because older
|
|
// versions of the table have different sizes; we only need the first
|
|
// two 16-bit fields here.
|
|
mMetrics->aveCharWidth =
|
|
int16_t(os2->xAvgCharWidth) * mFUnitsConvFactor;
|
|
}
|
|
}
|
|
}
|
|
|
|
UINT32 ucs;
|
|
if (mMetrics->aveCharWidth < 1) {
|
|
ucs = L'x';
|
|
if (SUCCEEDED(mFontFace->GetGlyphIndicesA(&ucs, 1, &glyph))) {
|
|
mMetrics->aveCharWidth = MeasureGlyphWidth(glyph);
|
|
}
|
|
if (mMetrics->aveCharWidth < 1) {
|
|
// Let's just assume the X is square.
|
|
mMetrics->aveCharWidth = fontMetrics.xHeight * mFUnitsConvFactor;
|
|
}
|
|
}
|
|
|
|
ucs = L'0';
|
|
if (SUCCEEDED(mFontFace->GetGlyphIndicesA(&ucs, 1, &glyph))) {
|
|
mMetrics->zeroOrAveCharWidth = MeasureGlyphWidth(glyph);
|
|
}
|
|
if (mMetrics->zeroOrAveCharWidth < 1) {
|
|
mMetrics->zeroOrAveCharWidth = mMetrics->aveCharWidth;
|
|
}
|
|
|
|
mMetrics->underlineOffset =
|
|
fontMetrics.underlinePosition * mFUnitsConvFactor;
|
|
mMetrics->underlineSize =
|
|
fontMetrics.underlineThickness * mFUnitsConvFactor;
|
|
mMetrics->strikeoutOffset =
|
|
fontMetrics.strikethroughPosition * mFUnitsConvFactor;
|
|
mMetrics->strikeoutSize =
|
|
fontMetrics.strikethroughThickness * mFUnitsConvFactor;
|
|
mMetrics->superscriptOffset = 0;
|
|
mMetrics->subscriptOffset = 0;
|
|
|
|
SanitizeMetrics(mMetrics, GetFontEntry()->mIsBadUnderlineFont);
|
|
|
|
#if 0
|
|
printf("Font: %p (%s) size: %f\n", this,
|
|
NS_ConvertUTF16toUTF8(GetName()).get(), mStyle.size);
|
|
printf(" emHeight: %f emAscent: %f emDescent: %f\n", mMetrics->emHeight, mMetrics->emAscent, mMetrics->emDescent);
|
|
printf(" maxAscent: %f maxDescent: %f maxAdvance: %f\n", mMetrics->maxAscent, mMetrics->maxDescent, mMetrics->maxAdvance);
|
|
printf(" internalLeading: %f externalLeading: %f\n", mMetrics->internalLeading, mMetrics->externalLeading);
|
|
printf(" spaceWidth: %f aveCharWidth: %f zeroOrAve: %f xHeight: %f\n",
|
|
mMetrics->spaceWidth, mMetrics->aveCharWidth, mMetrics->zeroOrAveCharWidth, mMetrics->xHeight);
|
|
printf(" uOff: %f uSize: %f stOff: %f stSize: %f supOff: %f subOff: %f\n",
|
|
mMetrics->underlineOffset, mMetrics->underlineSize, mMetrics->strikeoutOffset, mMetrics->strikeoutSize,
|
|
mMetrics->superscriptOffset, mMetrics->subscriptOffset);
|
|
#endif
|
|
}
|
|
|
|
using namespace mozilla; // for AutoSwap_* types
|
|
|
|
struct EBLCHeader {
|
|
AutoSwap_PRUint32 version;
|
|
AutoSwap_PRUint32 numSizes;
|
|
};
|
|
|
|
struct SbitLineMetrics {
|
|
int8_t ascender;
|
|
int8_t descender;
|
|
uint8_t widthMax;
|
|
int8_t caretSlopeNumerator;
|
|
int8_t caretSlopeDenominator;
|
|
int8_t caretOffset;
|
|
int8_t minOriginSB;
|
|
int8_t minAdvanceSB;
|
|
int8_t maxBeforeBL;
|
|
int8_t minAfterBL;
|
|
int8_t pad1;
|
|
int8_t pad2;
|
|
};
|
|
|
|
struct BitmapSizeTable {
|
|
AutoSwap_PRUint32 indexSubTableArrayOffset;
|
|
AutoSwap_PRUint32 indexTablesSize;
|
|
AutoSwap_PRUint32 numberOfIndexSubTables;
|
|
AutoSwap_PRUint32 colorRef;
|
|
SbitLineMetrics hori;
|
|
SbitLineMetrics vert;
|
|
AutoSwap_PRUint16 startGlyphIndex;
|
|
AutoSwap_PRUint16 endGlyphIndex;
|
|
uint8_t ppemX;
|
|
uint8_t ppemY;
|
|
uint8_t bitDepth;
|
|
uint8_t flags;
|
|
};
|
|
|
|
typedef EBLCHeader EBSCHeader;
|
|
|
|
struct BitmapScaleTable {
|
|
SbitLineMetrics hori;
|
|
SbitLineMetrics vert;
|
|
uint8_t ppemX;
|
|
uint8_t ppemY;
|
|
uint8_t substitutePpemX;
|
|
uint8_t substitutePpemY;
|
|
};
|
|
|
|
bool
|
|
gfxDWriteFont::HasBitmapStrikeForSize(uint32_t aSize)
|
|
{
|
|
uint8_t *tableData;
|
|
uint32_t len;
|
|
void *tableContext;
|
|
BOOL exists;
|
|
HRESULT hr =
|
|
mFontFace->TryGetFontTable(DWRITE_MAKE_OPENTYPE_TAG('E', 'B', 'L', 'C'),
|
|
(const void**)&tableData, &len,
|
|
&tableContext, &exists);
|
|
if (FAILED(hr)) {
|
|
return false;
|
|
}
|
|
|
|
bool hasStrike = false;
|
|
// not really a loop, but this lets us use 'break' to skip out of the block
|
|
// as soon as we know the answer, and skips it altogether if the table is
|
|
// not present
|
|
while (exists) {
|
|
if (len < sizeof(EBLCHeader)) {
|
|
break;
|
|
}
|
|
const EBLCHeader *hdr = reinterpret_cast<const EBLCHeader*>(tableData);
|
|
if (hdr->version != 0x00020000) {
|
|
break;
|
|
}
|
|
uint32_t numSizes = hdr->numSizes;
|
|
if (numSizes > 0xffff) { // sanity-check, prevent overflow below
|
|
break;
|
|
}
|
|
if (len < sizeof(EBLCHeader) + numSizes * sizeof(BitmapSizeTable)) {
|
|
break;
|
|
}
|
|
const BitmapSizeTable *sizeTable =
|
|
reinterpret_cast<const BitmapSizeTable*>(hdr + 1);
|
|
for (uint32_t i = 0; i < numSizes; ++i, ++sizeTable) {
|
|
if (sizeTable->ppemX == aSize && sizeTable->ppemY == aSize) {
|
|
// we ignore a strike that contains fewer than 4 glyphs,
|
|
// as that probably indicates a font such as Courier New
|
|
// that provides bitmaps ONLY for the "shading" characters
|
|
// U+2591..2593
|
|
hasStrike = (uint16_t(sizeTable->endGlyphIndex) >=
|
|
uint16_t(sizeTable->startGlyphIndex) + 3);
|
|
break;
|
|
}
|
|
}
|
|
// if we reach here, we didn't find a strike; unconditionally break
|
|
// out of the while-loop block
|
|
break;
|
|
}
|
|
mFontFace->ReleaseFontTable(tableContext);
|
|
|
|
if (hasStrike) {
|
|
return true;
|
|
}
|
|
|
|
// if we didn't find a real strike, check if the font calls for scaling
|
|
// another bitmap to this size
|
|
hr = mFontFace->TryGetFontTable(DWRITE_MAKE_OPENTYPE_TAG('E', 'B', 'S', 'C'),
|
|
(const void**)&tableData, &len,
|
|
&tableContext, &exists);
|
|
if (FAILED(hr)) {
|
|
return false;
|
|
}
|
|
|
|
while (exists) {
|
|
if (len < sizeof(EBSCHeader)) {
|
|
break;
|
|
}
|
|
const EBSCHeader *hdr = reinterpret_cast<const EBSCHeader*>(tableData);
|
|
if (hdr->version != 0x00020000) {
|
|
break;
|
|
}
|
|
uint32_t numSizes = hdr->numSizes;
|
|
if (numSizes > 0xffff) {
|
|
break;
|
|
}
|
|
if (len < sizeof(EBSCHeader) + numSizes * sizeof(BitmapScaleTable)) {
|
|
break;
|
|
}
|
|
const BitmapScaleTable *scaleTable =
|
|
reinterpret_cast<const BitmapScaleTable*>(hdr + 1);
|
|
for (uint32_t i = 0; i < numSizes; ++i, ++scaleTable) {
|
|
if (scaleTable->ppemX == aSize && scaleTable->ppemY == aSize) {
|
|
hasStrike = true;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
mFontFace->ReleaseFontTable(tableContext);
|
|
|
|
return hasStrike;
|
|
}
|
|
|
|
uint32_t
|
|
gfxDWriteFont::GetSpaceGlyph()
|
|
{
|
|
UINT32 ucs = L' ';
|
|
UINT16 glyph;
|
|
HRESULT hr;
|
|
hr = mFontFace->GetGlyphIndicesA(&ucs, 1, &glyph);
|
|
if (FAILED(hr)) {
|
|
return 0;
|
|
}
|
|
return glyph;
|
|
}
|
|
|
|
bool
|
|
gfxDWriteFont::SetupCairoFont(gfxContext *aContext)
|
|
{
|
|
cairo_scaled_font_t *scaledFont = GetCairoScaledFont();
|
|
if (cairo_scaled_font_status(scaledFont) != CAIRO_STATUS_SUCCESS) {
|
|
// Don't cairo_set_scaled_font as that would propagate the error to
|
|
// the cairo_t, precluding any further drawing.
|
|
return false;
|
|
}
|
|
cairo_set_scaled_font(aContext->GetCairo(), scaledFont);
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
gfxDWriteFont::IsValid()
|
|
{
|
|
return mFontFace != nullptr;
|
|
}
|
|
|
|
IDWriteFontFace*
|
|
gfxDWriteFont::GetFontFace()
|
|
{
|
|
return mFontFace.get();
|
|
}
|
|
|
|
cairo_font_face_t *
|
|
gfxDWriteFont::CairoFontFace()
|
|
{
|
|
if (!mCairoFontFace) {
|
|
#ifdef CAIRO_HAS_DWRITE_FONT
|
|
mCairoFontFace =
|
|
cairo_dwrite_font_face_create_for_dwrite_fontface(
|
|
((gfxDWriteFontEntry*)mFontEntry.get())->mFont, mFontFace);
|
|
#endif
|
|
}
|
|
return mCairoFontFace;
|
|
}
|
|
|
|
|
|
cairo_scaled_font_t *
|
|
gfxDWriteFont::GetCairoScaledFont()
|
|
{
|
|
if (!mScaledFont) {
|
|
cairo_matrix_t sizeMatrix;
|
|
cairo_matrix_t identityMatrix;
|
|
|
|
cairo_matrix_init_scale(&sizeMatrix, mAdjustedSize, mAdjustedSize);
|
|
cairo_matrix_init_identity(&identityMatrix);
|
|
|
|
cairo_font_options_t *fontOptions = cairo_font_options_create();
|
|
if (mNeedsOblique) {
|
|
double skewfactor = OBLIQUE_SKEW_FACTOR;
|
|
|
|
cairo_matrix_t style;
|
|
cairo_matrix_init(&style,
|
|
1, //xx
|
|
0, //yx
|
|
-1 * skewfactor, //xy
|
|
1, //yy
|
|
0, //x0
|
|
0); //y0
|
|
cairo_matrix_multiply(&sizeMatrix, &sizeMatrix, &style);
|
|
}
|
|
|
|
if (mAntialiasOption != kAntialiasDefault) {
|
|
cairo_font_options_set_antialias(fontOptions,
|
|
GetCairoAntialiasOption(mAntialiasOption));
|
|
}
|
|
|
|
mScaledFont = cairo_scaled_font_create(CairoFontFace(),
|
|
&sizeMatrix,
|
|
&identityMatrix,
|
|
fontOptions);
|
|
cairo_font_options_destroy(fontOptions);
|
|
|
|
cairo_dwrite_scaled_font_allow_manual_show_glyphs(mScaledFont,
|
|
mAllowManualShowGlyphs);
|
|
|
|
gfxDWriteFontEntry *fe =
|
|
static_cast<gfxDWriteFontEntry*>(mFontEntry.get());
|
|
cairo_dwrite_scaled_font_set_force_GDI_classic(mScaledFont,
|
|
GetForceGDIClassic());
|
|
}
|
|
|
|
NS_ASSERTION(mAdjustedSize == 0.0 ||
|
|
cairo_scaled_font_status(mScaledFont)
|
|
== CAIRO_STATUS_SUCCESS,
|
|
"Failed to make scaled font");
|
|
|
|
return mScaledFont;
|
|
}
|
|
|
|
gfxFont::RunMetrics
|
|
gfxDWriteFont::Measure(gfxTextRun *aTextRun,
|
|
uint32_t aStart, uint32_t aEnd,
|
|
BoundingBoxType aBoundingBoxType,
|
|
gfxContext *aRefContext,
|
|
Spacing *aSpacing)
|
|
{
|
|
gfxFont::RunMetrics metrics =
|
|
gfxFont::Measure(aTextRun, aStart, aEnd,
|
|
aBoundingBoxType, aRefContext, aSpacing);
|
|
|
|
// if aBoundingBoxType is LOOSE_INK_EXTENTS
|
|
// and the underlying cairo font may be antialiased,
|
|
// we can't trust Windows to have considered all the pixels
|
|
// so we need to add "padding" to the bounds.
|
|
// (see bugs 475968, 439831, compare also bug 445087)
|
|
if (aBoundingBoxType == LOOSE_INK_EXTENTS &&
|
|
mAntialiasOption != kAntialiasNone &&
|
|
GetMeasuringMode() == DWRITE_MEASURING_MODE_GDI_CLASSIC &&
|
|
metrics.mBoundingBox.width > 0) {
|
|
metrics.mBoundingBox.x -= aTextRun->GetAppUnitsPerDevUnit();
|
|
metrics.mBoundingBox.width += aTextRun->GetAppUnitsPerDevUnit() * 3;
|
|
}
|
|
|
|
return metrics;
|
|
}
|
|
|
|
bool
|
|
gfxDWriteFont::ProvidesGlyphWidths()
|
|
{
|
|
return !mUseSubpixelPositions ||
|
|
(mFontFace->GetSimulations() & DWRITE_FONT_SIMULATIONS_BOLD);
|
|
}
|
|
|
|
int32_t
|
|
gfxDWriteFont::GetGlyphWidth(gfxContext *aCtx, uint16_t aGID)
|
|
{
|
|
if (!mGlyphWidths) {
|
|
mGlyphWidths = new nsDataHashtable<nsUint32HashKey,int32_t>(200);
|
|
}
|
|
|
|
int32_t width = -1;
|
|
if (mGlyphWidths->Get(aGID, &width)) {
|
|
return width;
|
|
}
|
|
|
|
width = NS_lround(MeasureGlyphWidth(aGID) * 65536.0);
|
|
mGlyphWidths->Put(aGID, width);
|
|
return width;
|
|
}
|
|
|
|
TemporaryRef<GlyphRenderingOptions>
|
|
gfxDWriteFont::GetGlyphRenderingOptions()
|
|
{
|
|
if (UsingClearType()) {
|
|
return Factory::CreateDWriteGlyphRenderingOptions(
|
|
gfxWindowsPlatform::GetPlatform()->GetRenderingParams(GetForceGDIClassic() ?
|
|
gfxWindowsPlatform::TEXT_RENDERING_GDI_CLASSIC : gfxWindowsPlatform::TEXT_RENDERING_NORMAL));
|
|
} else {
|
|
return Factory::CreateDWriteGlyphRenderingOptions(gfxWindowsPlatform::GetPlatform()->
|
|
GetRenderingParams(gfxWindowsPlatform::TEXT_RENDERING_NO_CLEARTYPE));
|
|
}
|
|
}
|
|
|
|
bool
|
|
gfxDWriteFont::GetForceGDIClassic()
|
|
{
|
|
return static_cast<gfxDWriteFontEntry*>(mFontEntry.get())->GetForceGDIClassic() &&
|
|
cairo_dwrite_get_cleartype_rendering_mode() < 0 &&
|
|
GetAdjustedSize() <=
|
|
gfxDWriteFontList::PlatformFontList()->GetForceGDIClassicMaxFontSize();
|
|
}
|
|
|
|
DWRITE_MEASURING_MODE
|
|
gfxDWriteFont::GetMeasuringMode()
|
|
{
|
|
return GetForceGDIClassic()
|
|
? DWRITE_MEASURING_MODE_GDI_CLASSIC
|
|
: gfxWindowsPlatform::GetPlatform()->DWriteMeasuringMode();
|
|
}
|
|
|
|
gfxFloat
|
|
gfxDWriteFont::MeasureGlyphWidth(uint16_t aGlyph)
|
|
{
|
|
DWRITE_GLYPH_METRICS metrics;
|
|
HRESULT hr;
|
|
if (mUseSubpixelPositions) {
|
|
hr = mFontFace->GetDesignGlyphMetrics(&aGlyph, 1, &metrics, FALSE);
|
|
if (SUCCEEDED(hr)) {
|
|
return metrics.advanceWidth * mFUnitsConvFactor;
|
|
}
|
|
} else {
|
|
hr = mFontFace->GetGdiCompatibleGlyphMetrics(
|
|
FLOAT(mAdjustedSize), 1.0f, nullptr,
|
|
GetMeasuringMode() == DWRITE_MEASURING_MODE_GDI_NATURAL,
|
|
&aGlyph, 1, &metrics, FALSE);
|
|
if (SUCCEEDED(hr)) {
|
|
return NS_lround(metrics.advanceWidth * mFUnitsConvFactor);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void
|
|
gfxDWriteFont::AddSizeOfExcludingThis(MallocSizeOf aMallocSizeOf,
|
|
FontCacheSizes* aSizes) const
|
|
{
|
|
gfxFont::AddSizeOfExcludingThis(aMallocSizeOf, aSizes);
|
|
aSizes->mFontInstances += aMallocSizeOf(mMetrics);
|
|
if (mGlyphWidths) {
|
|
aSizes->mFontInstances +=
|
|
mGlyphWidths->SizeOfExcludingThis(nullptr, aMallocSizeOf);
|
|
}
|
|
}
|
|
|
|
void
|
|
gfxDWriteFont::AddSizeOfIncludingThis(MallocSizeOf aMallocSizeOf,
|
|
FontCacheSizes* aSizes) const
|
|
{
|
|
aSizes->mFontInstances += aMallocSizeOf(this);
|
|
AddSizeOfExcludingThis(aMallocSizeOf, aSizes);
|
|
}
|
|
|
|
TemporaryRef<ScaledFont>
|
|
gfxDWriteFont::GetScaledFont(mozilla::gfx::DrawTarget *aTarget)
|
|
{
|
|
bool wantCairo = aTarget->GetType() == BACKEND_CAIRO;
|
|
if (mAzureScaledFont && mAzureScaledFontIsCairo == wantCairo) {
|
|
return mAzureScaledFont;
|
|
}
|
|
|
|
NativeFont nativeFont;
|
|
nativeFont.mType = NATIVE_FONT_DWRITE_FONT_FACE;
|
|
nativeFont.mFont = GetFontFace();
|
|
|
|
if (wantCairo) {
|
|
mAzureScaledFont = Factory::CreateScaledFontWithCairo(nativeFont,
|
|
GetAdjustedSize(),
|
|
GetCairoScaledFont());
|
|
} else {
|
|
mAzureScaledFont = Factory::CreateScaledFontForNativeFont(nativeFont,
|
|
GetAdjustedSize());
|
|
}
|
|
|
|
mAzureScaledFontIsCairo = wantCairo;
|
|
|
|
return mAzureScaledFont;
|
|
}
|