mirror of
https://github.com/mozilla/gecko-dev.git
synced 2025-03-04 15:51:37 +00:00

This removes a lot of old cruft in thebes to instantiate Cairo scaled fonts. Instead, we only instantiate the Cairo scaled font inside Moz2D when we actually need it for DrawTargetCairo. This thus gets rid of the duplicated code we had inside both Moz2D and thebes to deal with Cairo scaled fonts. Differential Revision: https://phabricator.services.mozilla.com/D47297 --HG-- extra : moz-landing-system : lando
236 lines
7.7 KiB
C++
236 lines
7.7 KiB
C++
/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 2 -*-
|
|
* 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/. */
|
|
|
|
#if defined(MOZ_WIDGET_GTK)
|
|
# include "gfxPlatformGtk.h"
|
|
# define gfxToolkitPlatform gfxPlatformGtk
|
|
#elif defined(XP_WIN)
|
|
# include "gfxWindowsPlatform.h"
|
|
# define gfxToolkitPlatform gfxWindowsPlatform
|
|
#elif defined(ANDROID)
|
|
# include "gfxAndroidPlatform.h"
|
|
# define gfxToolkitPlatform gfxAndroidPlatform
|
|
#endif
|
|
|
|
#include "gfxTypes.h"
|
|
#include "gfxFT2Fonts.h"
|
|
#include "gfxFT2FontBase.h"
|
|
#include "gfxFT2Utils.h"
|
|
#include "gfxFT2FontList.h"
|
|
#include "gfxTextRun.h"
|
|
#include <locale.h>
|
|
#include "nsGkAtoms.h"
|
|
#include "nsTArray.h"
|
|
#include "nsCRT.h"
|
|
#include "nsXULAppAPI.h"
|
|
|
|
#include "mozilla/Logging.h"
|
|
#include "prinit.h"
|
|
|
|
#include "mozilla/MemoryReporting.h"
|
|
#include "mozilla/Preferences.h"
|
|
#include "mozilla/gfx/2D.h"
|
|
|
|
using namespace mozilla;
|
|
using namespace mozilla::gfx;
|
|
|
|
/**
|
|
* gfxFT2Font
|
|
*/
|
|
|
|
bool gfxFT2Font::ShapeText(DrawTarget* aDrawTarget, const char16_t* aText,
|
|
uint32_t aOffset, uint32_t aLength, Script aScript,
|
|
bool aVertical, RoundingFlags aRounding,
|
|
gfxShapedText* aShapedText) {
|
|
if (!gfxFont::ShapeText(aDrawTarget, aText, aOffset, aLength, aScript,
|
|
aVertical, aRounding, aShapedText)) {
|
|
// harfbuzz must have failed(?!), just render raw glyphs
|
|
AddRange(aText, aOffset, aLength, aShapedText);
|
|
PostShapingFixup(aDrawTarget, aText, aOffset, aLength, aVertical,
|
|
aShapedText);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void gfxFT2Font::AddRange(const char16_t* aText, uint32_t aOffset,
|
|
uint32_t aLength, gfxShapedText* aShapedText) {
|
|
typedef gfxShapedText::CompressedGlyph CompressedGlyph;
|
|
|
|
const uint32_t appUnitsPerDevUnit = aShapedText->GetAppUnitsPerDevUnit();
|
|
// we'll pass this in/figure it out dynamically, but at this point there can
|
|
// be only one face.
|
|
gfxFT2LockedFace faceLock(this);
|
|
FT_Face face = faceLock.get();
|
|
|
|
CompressedGlyph* charGlyphs = aShapedText->GetCharacterGlyphs();
|
|
|
|
const gfxFT2Font::CachedGlyphData *cgd = nullptr, *cgdNext = nullptr;
|
|
|
|
FT_UInt spaceGlyph = GetSpaceGlyph();
|
|
|
|
for (uint32_t i = 0; i < aLength; i++, aOffset++) {
|
|
char16_t ch = aText[i];
|
|
|
|
if (ch == 0) {
|
|
// treat this null byte as a missing glyph, don't create a glyph for it
|
|
aShapedText->SetMissingGlyph(aOffset, 0, this);
|
|
continue;
|
|
}
|
|
|
|
NS_ASSERTION(!gfxFontGroup::IsInvalidChar(ch), "Invalid char detected");
|
|
|
|
if (cgdNext) {
|
|
cgd = cgdNext;
|
|
cgdNext = nullptr;
|
|
} else {
|
|
cgd = GetGlyphDataForChar(face, ch);
|
|
}
|
|
|
|
FT_UInt gid = cgd->glyphIndex;
|
|
int32_t advance = 0;
|
|
|
|
if (gid == 0) {
|
|
advance = -1; // trigger the missing glyphs case below
|
|
} else {
|
|
// find next character and its glyph -- in case they exist
|
|
// and exist in the current font face -- to compute kerning
|
|
char16_t chNext = 0;
|
|
FT_UInt gidNext = 0;
|
|
FT_Pos lsbDeltaNext = 0;
|
|
|
|
if (FT_HAS_KERNING(face) && i + 1 < aLength) {
|
|
chNext = aText[i + 1];
|
|
if (chNext != 0) {
|
|
cgdNext = GetGlyphDataForChar(face, chNext);
|
|
gidNext = cgdNext->glyphIndex;
|
|
if (gidNext && gidNext != spaceGlyph)
|
|
lsbDeltaNext = cgdNext->lsbDelta;
|
|
}
|
|
}
|
|
|
|
advance = cgd->xAdvance;
|
|
|
|
// now add kerning to the current glyph's advance
|
|
if (chNext && gidNext) {
|
|
FT_Vector kerning;
|
|
kerning.x = 0;
|
|
FT_Get_Kerning(face, gid, gidNext, FT_KERNING_DEFAULT, &kerning);
|
|
advance += kerning.x;
|
|
if (cgd->rsbDelta - lsbDeltaNext >= 32) {
|
|
advance -= 64;
|
|
} else if (cgd->rsbDelta - lsbDeltaNext < -32) {
|
|
advance += 64;
|
|
}
|
|
}
|
|
|
|
// convert 26.6 fixed point to app units
|
|
// round rather than truncate to nearest pixel
|
|
// because these advances are often scaled
|
|
advance = ((advance * appUnitsPerDevUnit + 32) >> 6);
|
|
}
|
|
|
|
if (advance >= 0 && CompressedGlyph::IsSimpleAdvance(advance) &&
|
|
CompressedGlyph::IsSimpleGlyphID(gid)) {
|
|
charGlyphs[aOffset].SetSimpleGlyph(advance, gid);
|
|
} else if (gid == 0) {
|
|
// gid = 0 only happens when the glyph is missing from the font
|
|
aShapedText->SetMissingGlyph(aOffset, ch, this);
|
|
} else {
|
|
gfxTextRun::DetailedGlyph details;
|
|
details.mGlyphID = gid;
|
|
NS_ASSERTION(details.mGlyphID == gid,
|
|
"Seriously weird glyph ID detected!");
|
|
details.mAdvance = advance;
|
|
bool isClusterStart = charGlyphs[aOffset].IsClusterStart();
|
|
aShapedText->SetGlyphs(
|
|
aOffset, CompressedGlyph::MakeComplex(isClusterStart, true, 1),
|
|
&details);
|
|
}
|
|
}
|
|
}
|
|
|
|
gfxFT2Font::gfxFT2Font(const RefPtr<UnscaledFontFreeType>& aUnscaledFont,
|
|
RefPtr<mozilla::gfx::SharedFTFace>&& aFTFace,
|
|
FT2FontEntry* aFontEntry, const gfxFontStyle* aFontStyle,
|
|
int aLoadFlags)
|
|
: gfxFT2FontBase(aUnscaledFont, std::move(aFTFace), aFontEntry, aFontStyle,
|
|
aLoadFlags, aFontStyle->NeedsSyntheticBold(aFontEntry)),
|
|
mCharGlyphCache(32) {
|
|
NS_ASSERTION(mFontEntry,
|
|
"Unable to find font entry for font. Something is whack.");
|
|
InitMetrics();
|
|
}
|
|
|
|
gfxFT2Font::~gfxFT2Font() {}
|
|
|
|
already_AddRefed<ScaledFont> gfxFT2Font::GetScaledFont(DrawTarget* aTarget) {
|
|
if (!mAzureScaledFont) {
|
|
mAzureScaledFont = Factory::CreateScaledFontForFreeTypeFont(
|
|
GetUnscaledFont(), GetAdjustedSize(), mFTFace,
|
|
GetStyle()->NeedsSyntheticBold(GetFontEntry()));
|
|
InitializeScaledFont();
|
|
}
|
|
|
|
RefPtr<ScaledFont> scaledFont(mAzureScaledFont);
|
|
return scaledFont.forget();
|
|
}
|
|
|
|
bool gfxFT2Font::ShouldHintMetrics() const {
|
|
return !gfxPlatform::GetPlatform()->RequiresLinearZoom();
|
|
}
|
|
|
|
void gfxFT2Font::FillGlyphDataForChar(FT_Face face, uint32_t ch,
|
|
CachedGlyphData* gd) {
|
|
if (!face->charmap || (face->charmap->encoding != FT_ENCODING_UNICODE &&
|
|
face->charmap->encoding != FT_ENCODING_MS_SYMBOL)) {
|
|
if (FT_Err_Ok != FT_Select_Charmap(face, FT_ENCODING_UNICODE) &&
|
|
FT_Err_Ok != FT_Select_Charmap(face, FT_ENCODING_MS_SYMBOL)) {
|
|
NS_WARNING("failed to select Unicode or symbol charmap!");
|
|
}
|
|
}
|
|
FT_UInt gid = FT_Get_Char_Index(face, ch);
|
|
|
|
if (gid == 0) {
|
|
// this font doesn't support this char!
|
|
NS_ASSERTION(gid != 0,
|
|
"We don't have a glyph, but font indicated that it supported "
|
|
"this char in tables?");
|
|
gd->glyphIndex = 0;
|
|
return;
|
|
}
|
|
|
|
FT_Error err = Factory::LoadFTGlyph(face, gid, mFTLoadFlags);
|
|
|
|
if (err) {
|
|
// hmm, this is weird, we failed to load a glyph that we had?
|
|
NS_WARNING("Failed to load glyph that we got from Get_Char_index");
|
|
|
|
gd->glyphIndex = 0;
|
|
return;
|
|
}
|
|
|
|
gd->glyphIndex = gid;
|
|
gd->lsbDelta = face->glyph->lsb_delta;
|
|
gd->rsbDelta = face->glyph->rsb_delta;
|
|
gd->xAdvance = face->glyph->advance.x;
|
|
if (gd->xAdvance) {
|
|
gd->xAdvance += GetEmboldenStrength(face).x;
|
|
}
|
|
}
|
|
|
|
void gfxFT2Font::AddSizeOfExcludingThis(MallocSizeOf aMallocSizeOf,
|
|
FontCacheSizes* aSizes) const {
|
|
gfxFont::AddSizeOfExcludingThis(aMallocSizeOf, aSizes);
|
|
aSizes->mFontInstances +=
|
|
mCharGlyphCache.ShallowSizeOfExcludingThis(aMallocSizeOf);
|
|
}
|
|
|
|
void gfxFT2Font::AddSizeOfIncludingThis(MallocSizeOf aMallocSizeOf,
|
|
FontCacheSizes* aSizes) const {
|
|
aSizes->mFontInstances += aMallocSizeOf(this);
|
|
AddSizeOfExcludingThis(aMallocSizeOf, aSizes);
|
|
}
|