FontPlatformData::FontPlatformData(const FontDescription& desc, const AtomicString& family)
{
// NB: The Windows wxFont constructor has two forms, one taking a wxSize (with pixels)
// and one taking an int (points). When points are used, Windows calculates
// a pixel size using an algorithm which causes the size to be way off. However,
// this is a moot issue on Linux and Mac as they only accept the point argument. So,
// we use the pixel size constructor on Windows, but we use point size on Linux and Mac.
#if __WXMSW__
m_font = new FontHolder(new wxFont( wxSize(0, -desc.computedPixelSize()),
fontFamilyToWxFontFamily(desc.genericFamily()),
italicToWxFontStyle(desc.italic()),
fontWeightToWxFontWeight(desc.weight()),
false,
family.string()
)
);
#else
m_font = new FontHolder(new wxFont( desc.computedPixelSize(),
fontFamilyToWxFontFamily(desc.genericFamily()),
italicToWxFontStyle(desc.italic()),
fontWeightToWxFontWeight(desc.weight()),
false,
family.string()
)
);
#endif
m_fontState = VALID;
}
FontPlatformData FontCustomPlatformData::fontPlatformData(const FontDescription& fontDescription, bool bold, bool italic)
{
int size = fontDescription.computedPixelSize();
FontRenderingMode renderingMode = fontDescription.renderingMode();
LOGFONT logFont;
memset(&logFont, 0, sizeof(LOGFONT));
wcsncpy(logFont.lfFaceName, m_name.charactersWithNullTermination().data(), LF_FACESIZE - 1);
logFont.lfHeight = -size;
if (renderingMode == FontRenderingMode::Normal)
logFont.lfHeight *= 32;
logFont.lfWidth = 0;
logFont.lfEscapement = 0;
logFont.lfOrientation = 0;
logFont.lfUnderline = false;
logFont.lfStrikeOut = false;
logFont.lfCharSet = DEFAULT_CHARSET;
logFont.lfOutPrecision = OUT_TT_ONLY_PRECIS;
logFont.lfQuality = CLEARTYPE_QUALITY;
logFont.lfPitchAndFamily = DEFAULT_PITCH | FF_DONTCARE;
logFont.lfItalic = italic;
logFont.lfWeight = bold ? 700 : 400;
auto hfont = adoptGDIObject(::CreateFontIndirect(&logFont));
cairo_font_face_t* fontFace = cairo_win32_font_face_create_for_hfont(hfont.get());
FontPlatformData fontPlatformData(WTFMove(hfont), fontFace, size, bold, italic);
cairo_font_face_destroy(fontFace);
return fontPlatformData;
}
FontPlatformData FontCustomPlatformData::fontPlatformData(const FontDescription& fontDescription, bool bold, bool italic)
{
int size = fontDescription.computedPixelSize();
FontRenderingMode renderingMode = fontDescription.renderingMode();
ASSERT(m_fontReference);
LOGFONT& logFont = *static_cast<LOGFONT*>(malloc(sizeof(LOGFONT)));
memcpy(logFont.lfFaceName, m_name.charactersWithNullTermination().data(), sizeof(logFont.lfFaceName[0]) * std::min<size_t>(static_cast<size_t>(LF_FACESIZE), 1 + m_name.length()));
logFont.lfHeight = -size;
if (renderingMode == FontRenderingMode::Normal)
logFont.lfHeight *= 32;
logFont.lfWidth = 0;
logFont.lfEscapement = 0;
logFont.lfOrientation = 0;
logFont.lfUnderline = false;
logFont.lfStrikeOut = false;
logFont.lfCharSet = DEFAULT_CHARSET;
logFont.lfOutPrecision = OUT_TT_ONLY_PRECIS;
logFont.lfQuality = CLEARTYPE_QUALITY;
logFont.lfPitchAndFamily = DEFAULT_PITCH | FF_DONTCARE;
logFont.lfItalic = italic;
logFont.lfWeight = bold ? 700 : 400;
auto hfont = adoptGDIObject(::CreateFontIndirect(&logFont));
RetainPtr<CGFontRef> cgFont = adoptCF(CGFontCreateWithPlatformFont(&logFont));
return FontPlatformData(WTFMove(hfont), cgFont.get(), size, bold, italic, renderingMode == FontRenderingMode::Alternate);
}
FontRanges CSSSegmentedFontFace::fontRanges(const FontDescription& fontDescription)
{
if (!isValid())
return FontRanges();
FontTraitsMask desiredTraitsMask = fontDescription.traitsMask();
unsigned hashKey = ((fontDescription.computedPixelSize() + 1) << (FontTraitsMaskWidth + FontWidthVariantWidth + 1))
| ((fontDescription.orientation() == Vertical ? 1 : 0) << (FontTraitsMaskWidth + FontWidthVariantWidth))
| fontDescription.widthVariant() << FontTraitsMaskWidth
| desiredTraitsMask;
auto addResult = m_descriptionToRangesMap.add(hashKey, FontRanges());
auto& fontRanges = addResult.iterator->value;
if (addResult.isNewEntry) {
for (auto& face : m_fontFaces) {
if (!face->isValid())
continue;
FontTraitsMask traitsMask = face->traitsMask();
bool syntheticBold = !(traitsMask & (FontWeight600Mask | FontWeight700Mask | FontWeight800Mask | FontWeight900Mask)) && (desiredTraitsMask & (FontWeight600Mask | FontWeight700Mask | FontWeight800Mask | FontWeight900Mask));
bool syntheticItalic = !(traitsMask & FontStyleItalicMask) && (desiredTraitsMask & FontStyleItalicMask);
if (RefPtr<Font> faceFont = face->font(fontDescription, syntheticBold, syntheticItalic))
appendFontWithInvalidUnicodeRangeIfLoading(fontRanges, faceFont.releaseNonNull(), face->ranges());
}
}
return fontRanges;
}
FontPlatformData::FontPlatformData(const FontDescription& description, const AtomicString& familyName, int wordSpacing, int letterSpacing)
: m_data(adoptRef(new FontPlatformDataPrivate()))
{
QFont& font = m_data->font;
int requestedSize = qRound(description.computedPixelSize());
font.setFamily(familyName);
font.setPixelSize(qRound(requestedSize));
font.setItalic(description.italic());
font.setWeight(toQFontWeight(description.weight()));
font.setWordSpacing(wordSpacing);
font.setLetterSpacing(QFont::AbsoluteSpacing, letterSpacing);
const bool smallCaps = description.smallCaps();
font.setCapitalization(smallCaps ? QFont::SmallCaps : QFont::MixedCase);
// Commented out to work around webkit bug 93263
//font.setStyleStrategy(QFont::ForceIntegerMetrics);
m_data->bold = font.bold();
// WebKit allows font size zero but QFont does not. We will return
// m_data->size if a font size of zero is requested and pixelSize()
// otherwise.
m_data->size = (!requestedSize) ? requestedSize : font.pixelSize();
#if HAVE(QRAWFONT)
m_data->rawFont = QRawFont::fromFont(font, QFontDatabase::Any);
#endif
}
PassRefPtr<FontData> CSSSegmentedFontFace::getFontData(const FontDescription& fontDescription)
{
if (!isValid())
return 0;
FontTraitsMask desiredTraitsMask = fontDescription.traitsMask();
unsigned hashKey = ((fontDescription.computedPixelSize() + 1) << (FontTraitsMaskWidth + FontWidthVariantWidth + 1))
| ((fontDescription.orientation() == Vertical ? 1 : 0) << (FontTraitsMaskWidth + FontWidthVariantWidth))
| fontDescription.widthVariant() << FontTraitsMaskWidth
| desiredTraitsMask;
RefPtr<SegmentedFontData>& fontData = m_fontDataTable.add(hashKey, 0).iterator->value;
if (fontData && fontData->numRanges())
return fontData; // No release, we have a reference to an object in the cache which should retain the ref count it has.
if (!fontData)
fontData = SegmentedFontData::create();
unsigned size = m_fontFaces.size();
for (unsigned i = 0; i < size; i++) {
if (!m_fontFaces[i]->isValid())
continue;
FontTraitsMask traitsMask = m_fontFaces[i]->traitsMask();
bool syntheticBold = !(traitsMask & (FontWeight600Mask | FontWeight700Mask | FontWeight800Mask | FontWeight900Mask)) && (desiredTraitsMask & (FontWeight600Mask | FontWeight700Mask | FontWeight800Mask | FontWeight900Mask));
bool syntheticItalic = !(traitsMask & FontStyleItalicMask) && (desiredTraitsMask & FontStyleItalicMask);
if (RefPtr<SimpleFontData> faceFontData = m_fontFaces[i]->getFontData(fontDescription, syntheticBold, syntheticItalic)) {
ASSERT(!faceFontData->isSegmented());
appendFontDataWithInvalidUnicodeRangeIfLoading(fontData.get(), faceFontData.release(), m_fontFaces[i]->ranges());
}
}
if (fontData->numRanges())
return fontData; // No release, we have a reference to an object in the cache which should retain the ref count it has.
return 0;
}
FontPlatformData::FontPlatformData(FcPattern* pattern, const FontDescription& fontDescription)
: m_pattern(pattern)
, m_fallbacks(0)
, m_size(fontDescription.computedPixelSize())
, m_syntheticBold(false)
, m_syntheticOblique(false)
, m_fixedWidth(false)
, m_scaledFont(0)
, m_orientation(fontDescription.orientation())
{
RefPtr<cairo_font_face_t> fontFace = adoptRef(cairo_ft_font_face_create_for_pattern(m_pattern.get()));
initializeWithFontFace(fontFace.get(), fontDescription);
int spacing;
if (FcPatternGetInteger(pattern, FC_SPACING, 0, &spacing) == FcResultMatch && spacing == FC_MONO)
m_fixedWidth = true;
if (fontDescription.weight() >= FontWeightBold) {
// The FC_EMBOLDEN property instructs us to fake the boldness of the font.
FcBool fontConfigEmbolden = FcFalse;
if (FcPatternGetBool(pattern, FC_EMBOLDEN, 0, &fontConfigEmbolden) == FcResultMatch)
m_syntheticBold = fontConfigEmbolden;
// Fallback fonts may not have FC_EMBOLDEN activated even though it's necessary.
int weight = 0;
if (!m_syntheticBold && FcPatternGetInteger(pattern, FC_WEIGHT, 0, &weight) == FcResultMatch)
m_syntheticBold = m_syntheticBold || weight < FC_WEIGHT_DEMIBOLD;
}
}
FontPlatformData::FontPlatformData(const FontDescription& description, const AtomicString& familyName, int wordSpacing, int letterSpacing)
: m_data(adoptRef(new FontPlatformDataPrivate()))
{
QFont font;
int requestedSize = description.computedPixelSize();
font.setFamily(familyName);
if (requestedSize)
font.setPixelSize(requestedSize);
font.setItalic(description.italic());
font.setWeight(toQFontWeight(description.weight()));
font.setWordSpacing(wordSpacing);
font.setLetterSpacing(QFont::AbsoluteSpacing, letterSpacing);
if (description.fontSmoothing() == NoSmoothing)
font.setStyleStrategy(QFont::NoAntialias);
#if QT_VERSION >= QT_VERSION_CHECK(5, 1, 0)
if (description.fontSmoothing() == AutoSmoothing && !Font::shouldUseSmoothing())
font.setStyleStrategy(QFont::NoAntialias);
#endif
m_data->bold = font.bold();
// WebKit allows font size zero but QFont does not. We will return
// m_data->size if a font size of zero is requested and pixelSize()
// otherwise.
m_data->size = (!requestedSize) ? requestedSize : font.pixelSize();
m_data->rawFont = QRawFont::fromFont(font, QFontDatabase::Any);
}
uint qHash(const FontDescription& key)
{
uint value = CaseFoldingHash::hash(key.family().family());
value ^= key.computedPixelSize();
value ^= static_cast<int>(key.weight());
return value;
}
std::unique_ptr<FontPlatformData> FontCache::createFontPlatformData(const FontDescription& fontDescription, const AtomicString& family)
{
// The CSS font matching algorithm (http://www.w3.org/TR/css3-fonts/#font-matching-algorithm)
// says that we must find an exact match for font family, slant (italic or oblique can be used)
// and font weight (we only match bold/non-bold here).
RefPtr<FcPattern> pattern = adoptRef(FcPatternCreate());
// Never choose unscalable fonts, as they pixelate when displayed at different sizes.
FcPatternAddBool(pattern.get(), FC_SCALABLE, FcTrue);
String familyNameString(getFamilyNameStringFromFamily(family));
if (!FcPatternAddString(pattern.get(), FC_FAMILY, reinterpret_cast<const FcChar8*>(familyNameString.utf8().data())))
return nullptr;
bool italic = fontDescription.italic();
if (!FcPatternAddInteger(pattern.get(), FC_SLANT, italic ? FC_SLANT_ITALIC : FC_SLANT_ROMAN))
return nullptr;
if (!FcPatternAddInteger(pattern.get(), FC_WEIGHT, fontWeightToFontconfigWeight(fontDescription.weight())))
return nullptr;
if (!FcPatternAddDouble(pattern.get(), FC_PIXEL_SIZE, fontDescription.computedPixelSize()))
return nullptr;
// The strategy is originally from Skia (src/ports/SkFontHost_fontconfig.cpp):
// Allow Fontconfig to do pre-match substitution. Unless we are accessing a "fallback"
// family like "sans," this is the only time we allow Fontconfig to substitute one
// family name for another (i.e. if the fonts are aliased to each other).
FcConfigSubstitute(0, pattern.get(), FcMatchPattern);
FcDefaultSubstitute(pattern.get());
FcChar8* fontConfigFamilyNameAfterConfiguration;
FcPatternGetString(pattern.get(), FC_FAMILY, 0, &fontConfigFamilyNameAfterConfiguration);
String familyNameAfterConfiguration = String::fromUTF8(reinterpret_cast<char*>(fontConfigFamilyNameAfterConfiguration));
FcResult fontConfigResult;
RefPtr<FcPattern> resultPattern = adoptRef(FcFontMatch(0, pattern.get(), &fontConfigResult));
if (!resultPattern) // No match.
return nullptr;
FcChar8* fontConfigFamilyNameAfterMatching;
FcPatternGetString(resultPattern.get(), FC_FAMILY, 0, &fontConfigFamilyNameAfterMatching);
String familyNameAfterMatching = String::fromUTF8(reinterpret_cast<char*>(fontConfigFamilyNameAfterMatching));
// If Fontconfig gave use a different font family than the one we requested, we should ignore it
// and allow WebCore to give us the next font on the CSS fallback list. The only exception is if
// this family name is a commonly used generic family.
if (!equalIgnoringCase(familyNameAfterConfiguration, familyNameAfterMatching)
&& !(equalIgnoringCase(familyNameString, "sans") || equalIgnoringCase(familyNameString, "sans-serif")
|| equalIgnoringCase(familyNameString, "serif") || equalIgnoringCase(familyNameString, "monospace")
|| equalIgnoringCase(familyNameString, "fantasy") || equalIgnoringCase(familyNameString, "cursive")))
return nullptr;
// Verify that this font has an encoding compatible with Fontconfig. Fontconfig currently
// supports three encodings in FcFreeTypeCharIndex: Unicode, Symbol and AppleRoman.
// If this font doesn't have one of these three encodings, don't select it.
auto platformData = std::make_unique<FontPlatformData>(resultPattern.get(), fontDescription);
if (!platformData->hasCompatibleCharmap())
return nullptr;
return platformData;
}
FontPlatformData FontCustomPlatformData::fontPlatformData(const FontDescription& fontDescription, bool bold, bool italic, const FontFeatureSettings& fontFaceFeatures, const FontVariantSettings& fontFaceVariantSettings)
{
int size = fontDescription.computedPixelSize();
FontOrientation orientation = fontDescription.orientation();
FontWidthVariant widthVariant = fontDescription.widthVariant();
RetainPtr<CTFontRef> font = adoptCF(CTFontCreateWithFontDescriptor(m_fontDescriptor.get(), size, nullptr));
font = preparePlatformFont(font.get(), fontDescription.textRenderingMode(), &fontFaceFeatures, &fontFaceVariantSettings, fontDescription.featureSettings(), fontDescription.variantSettings());
return FontPlatformData(font.get(), size, bold, italic, orientation, widthVariant, fontDescription.textRenderingMode());
}
FontPlatformPrivateData(const FontDescription& fontDescription, const AtomicString& family)
: m_reference(1)
, m_size(fontDescription.computedPixelSize())
, m_fontDescription(fontDescription)
, m_family(family)
, m_fontScaledWidth(0)
, m_fontScaledHeight(0)
, m_disabled(!fontDescription.specifiedSize())
{
m_rootFontData = FixedSizeFontData::create(family, toGDIFontWeight(fontDescription.weight()), fontDescription.italic());
}
FontPlatformData::FontPlatformData(const FontDescription& desc, const AtomicString& family)
{
// NB: The Windows wxFont constructor has two forms, one taking a wxSize (with pixels)
// and one taking an int (points). When points are used, Windows calculates
// a pixel size using an algorithm which causes the size to be way off. However,
// this is a moot issue on Linux and Mac as they only accept the point argument. So,
// we use the pixel size constructor on Windows, but we use point size on Linux and Mac.
#if __WXMSW__
m_font = adoptRef(new FontHolder(new wxFont( wxSize(0, -desc.computedPixelSize()),
fontFamilyToWxFontFamily(desc.genericFamily()),
italicToWxFontStyle(desc.italic()),
fontWeightToWxFontWeight(desc.weight()),
false,
family.string()
)
));
#else
m_font = adoptRef(new FontHolder(new wxFont( desc.computedPixelSize(),
fontFamilyToWxFontFamily(desc.genericFamily()),
italicToWxFontStyle(desc.italic()),
fontWeightToWxFontWeight(desc.weight()),
false,
family.string()
)
));
#endif
#if OS(DARWIN)
#if !wxOSX_USE_CORE_TEXT
#if wxCHECK_VERSION(2,9,0)
m_atsuFontID = m_font->font()->OSXGetATSUFontID();
#else
m_atsuFontID = m_font->font()->MacGetATSUFontID();
#endif
#endif
m_nsFont = 0;
cacheNSFont();
#endif
m_size = desc.computedPixelSize();
m_fontState = VALID;
m_size = desc.computedPixelSize();
}
FontPlatformData FontCustomPlatformData::fontPlatformData(const FontDescription& fontDescription, bool bold, bool italic)
{
int size = fontDescription.computedPixelSize();
FontOrientation orientation = fontDescription.orientation();
FontWidthVariant widthVariant = fontDescription.widthVariant();
#if CORETEXT_WEB_FONTS
RetainPtr<CTFontRef> font = adoptCF(CTFontCreateWithFontDescriptor(m_fontDescriptor.get(), size, nullptr));
font = preparePlatformFont(font.get(), fontDescription.textRenderingMode(), fontDescription.featureSettings());
return FontPlatformData(font.get(), size, bold, italic, orientation, widthVariant, fontDescription.textRenderingMode());
#else
return FontPlatformData(m_cgFont.get(), size, bold, italic, orientation, widthVariant, fontDescription.textRenderingMode());
#endif
}
RefPtr<Font> CachedSVGFont::createFont(const FontDescription& fontDescription, const AtomicString& remoteURI, bool syntheticBold, bool syntheticItalic, bool externalSVG)
{
#if ENABLE(SVG_OTF_CONVERTER)
if (!externalSVG || firstFontFace(remoteURI))
return CachedFont::createFont(fontDescription, remoteURI, syntheticBold, syntheticItalic, externalSVG);
#else
if (!externalSVG)
return CachedFont::createFont(fontDescription, remoteURI, syntheticBold, syntheticItalic, externalSVG);
if (SVGFontFaceElement* firstFontFace = this->firstFontFace(remoteURI))
return Font::create(std::make_unique<SVGFontData>(firstFontFace), fontDescription.computedPixelSize(), syntheticBold, syntheticItalic);
#endif
return nullptr;
}
static void FillLogFont(const FontDescription& fontDescription, LOGFONT* winfont)
{
// The size here looks unusual. The negative number is intentional.
// Unlike WebKit trunk, we don't multiply the size by 32. That seems to be
// some kind of artifact of their CG backend, or something.
winfont->lfHeight = -fontDescription.computedPixelSize();
winfont->lfWidth = 0;
winfont->lfEscapement = 0;
winfont->lfOrientation = 0;
winfont->lfUnderline = false;
winfont->lfStrikeOut = false;
winfont->lfCharSet = DEFAULT_CHARSET;
winfont->lfOutPrecision = OUT_TT_ONLY_PRECIS;
winfont->lfQuality = PlatformSupport::layoutTestMode() ? NONANTIALIASED_QUALITY : DEFAULT_QUALITY; // Honor user's desktop settings.
winfont->lfPitchAndFamily = DEFAULT_PITCH | FF_DONTCARE;
winfont->lfItalic = fontDescription.italic();
winfont->lfWeight = toGDIFontWeight(fontDescription.weight());
}
FontPlatformData::FontPlatformData(FcPattern* pattern, const FontDescription& fontDescription)
: m_pattern(pattern)
, m_fallbacks(0)
, m_size(fontDescription.computedPixelSize())
, m_syntheticBold(false)
, m_syntheticOblique(false)
, m_fixedWidth(false)
{
PlatformRefPtr<cairo_font_face_t> fontFace = adoptPlatformRef(cairo_ft_font_face_create_for_pattern(m_pattern.get()));
initializeWithFontFace(fontFace.get());
int spacing;
if (FcPatternGetInteger(pattern, FC_SPACING, 0, &spacing) == FcResultMatch && spacing == FC_MONO)
m_fixedWidth = true;
if (fontDescription.weight() >= FontWeightBold) {
// The FC_EMBOLDEN property instructs us to fake the boldness of the font.
FcBool fontConfigEmbolden;
if (FcPatternGetBool(pattern, FC_EMBOLDEN, 0, &fontConfigEmbolden) == FcResultMatch)
m_syntheticBold = fontConfigEmbolden;
}
}
RefPtr<Font> CSSFontFaceSource::font(const FontDescription& fontDescription, bool syntheticBold, bool syntheticItalic, CSSFontSelector* fontSelector, const FontFeatureSettings& fontFaceFeatures, const FontVariantSettings& fontFaceVariantSettings)
{
// If the font hasn't loaded or an error occurred, then we've got nothing.
if (!isValid())
return nullptr;
if (!m_font
#if ENABLE(SVG_FONTS)
&& !m_svgFontFaceElement
#endif
) {
// We're local. Just return a Font from the normal cache.
// We don't want to check alternate font family names here, so pass true as the checkingAlternateName parameter.
return FontCache::singleton().fontForFamily(fontDescription, m_string, true);
}
if (!m_font || m_font->isLoaded()) {
if (m_font) {
if (!m_font->ensureCustomFontData(m_string))
return nullptr;
return m_font->createFont(fontDescription, m_string, syntheticBold, syntheticItalic, fontFaceFeatures, fontFaceVariantSettings);
} else {
#if ENABLE(SVG_FONTS)
// In-Document SVG Fonts
if (m_svgFontFaceElement) {
#if ENABLE(SVG_OTF_CONVERTER)
if (!m_svgFontFaceElement->parentNode() || !is<SVGFontElement>(m_svgFontFaceElement->parentNode()))
return nullptr;
SVGFontElement& fontElement = downcast<SVGFontElement>(*m_svgFontFaceElement->parentNode());
// FIXME: Re-run this when script modifies the element or any of its descendents
// FIXME: We might have already converted this font. Make existing conversions discoverable.
if (auto otfFont = convertSVGToOTFFont(fontElement))
m_generatedOTFBuffer = SharedBuffer::adoptVector(otfFont.value());
if (!m_generatedOTFBuffer)
return nullptr;
auto customPlatformData = createFontCustomPlatformData(*m_generatedOTFBuffer);
if (!customPlatformData)
return nullptr;
return Font::create(customPlatformData->fontPlatformData(fontDescription, syntheticBold, syntheticItalic, fontFaceFeatures, fontFaceVariantSettings), true, false);
#else
return Font::create(std::make_unique<SVGFontData>(m_svgFontFaceElement.get()), fontDescription.computedPixelSize(), syntheticBold, syntheticItalic);
#endif
}
#endif
return nullptr;
}
} else {
// Kick off the load. Do it soon rather than now, because we may be in the middle of layout,
// and the loader may invoke arbitrary delegate or event handler code.
fontSelector->beginLoadingFontSoon(m_font.get());
return Font::create(FontCache::singleton().lastResortFallbackFont(fontDescription)->platformData(), true, true);
}
}
FontPlatformData CachedSVGFont::platformDataFromCustomData(const FontDescription& fontDescription, bool bold, bool italic, const FontFeatureSettings& fontFaceFeatures, const FontVariantSettings& fontFaceVariantSettings)
{
if (m_externalSVGDocument)
return FontPlatformData(fontDescription.computedPixelSize(), bold, italic);
return CachedFont::platformDataFromCustomData(fontDescription, bold, italic, fontFaceFeatures, fontFaceVariantSettings);
}
std::unique_ptr<FontPlatformData> FontCache::createFontPlatformData(const FontDescription& fontDescription, const AtomicString& family)
{
// The CSS font matching algorithm (http://www.w3.org/TR/css3-fonts/#font-matching-algorithm)
// says that we must find an exact match for font family, slant (italic or oblique can be used)
// and font weight (we only match bold/non-bold here).
RefPtr<FcPattern> pattern = adoptRef(FcPatternCreate());
// Never choose unscalable fonts, as they pixelate when displayed at different sizes.
FcPatternAddBool(pattern.get(), FC_SCALABLE, FcTrue);
String familyNameString(getFamilyNameStringFromFamily(family));
if (!FcPatternAddString(pattern.get(), FC_FAMILY, reinterpret_cast<const FcChar8*>(familyNameString.utf8().data())))
return nullptr;
bool italic = fontDescription.italic();
if (!FcPatternAddInteger(pattern.get(), FC_SLANT, italic ? FC_SLANT_ITALIC : FC_SLANT_ROMAN))
return nullptr;
if (!FcPatternAddInteger(pattern.get(), FC_WEIGHT, fontWeightToFontconfigWeight(fontDescription.weight())))
return nullptr;
if (!FcPatternAddDouble(pattern.get(), FC_PIXEL_SIZE, fontDescription.computedPixelSize()))
return nullptr;
// The strategy is originally from Skia (src/ports/SkFontHost_fontconfig.cpp):
//
// We do not normally allow fontconfig to substitute one font family for another, since this
// would break CSS font family fallback: the website should be in control of fallback. During
// normal font matching, the only font family substitution permitted is for generic families
// (sans, serif, monospace) or for strongly-aliased fonts (which are to be treated as
// effectively identical). This is because the font matching step is designed to always find a
// match for the font, which we don't want.
//
// Fontconfig is used in two stages: (1) configuration and (2) matching. During the
// configuration step, before any matching occurs, we allow arbitrary family substitutions,
// since this is an exact matter of respecting the user's font configuration.
FcConfigSubstitute(nullptr, pattern.get(), FcMatchPattern);
FcDefaultSubstitute(pattern.get());
FcChar8* fontConfigFamilyNameAfterConfiguration;
FcPatternGetString(pattern.get(), FC_FAMILY, 0, &fontConfigFamilyNameAfterConfiguration);
String familyNameAfterConfiguration = String::fromUTF8(reinterpret_cast<char*>(fontConfigFamilyNameAfterConfiguration));
FcResult fontConfigResult;
RefPtr<FcPattern> resultPattern = adoptRef(FcFontMatch(nullptr, pattern.get(), &fontConfigResult));
if (!resultPattern) // No match.
return nullptr;
FcChar8* fontConfigFamilyNameAfterMatching;
FcPatternGetString(resultPattern.get(), FC_FAMILY, 0, &fontConfigFamilyNameAfterMatching);
String familyNameAfterMatching = String::fromUTF8(reinterpret_cast<char*>(fontConfigFamilyNameAfterMatching));
// If Fontconfig gave us a different font family than the one we requested, we should ignore it
// and allow WebCore to give us the next font on the CSS fallback list. The exceptions are if
// this family name is a commonly-used generic family, or if the families are strongly-aliased.
// Checking for a strong alias comes last, since it is slow.
if (!equalIgnoringCase(familyNameAfterConfiguration, familyNameAfterMatching)
&& !(equalIgnoringCase(familyNameString, "sans") || equalIgnoringCase(familyNameString, "sans-serif")
|| equalIgnoringCase(familyNameString, "serif") || equalIgnoringCase(familyNameString, "monospace")
|| equalIgnoringCase(familyNameString, "fantasy") || equalIgnoringCase(familyNameString, "cursive"))
&& !areStronglyAliased(familyNameAfterConfiguration, familyNameAfterMatching))
return nullptr;
// Verify that this font has an encoding compatible with Fontconfig. Fontconfig currently
// supports three encodings in FcFreeTypeCharIndex: Unicode, Symbol and AppleRoman.
// If this font doesn't have one of these three encodings, don't select it.
auto platformData = std::make_unique<FontPlatformData>(resultPattern.get(), fontDescription);
if (!platformData->hasCompatibleCharmap())
return nullptr;
return platformData;
}
FontPlatformData CachedSVGFont::platformDataFromCustomData(const FontDescription& fontDescription, bool bold, bool italic)
{
if (m_externalSVGDocument)
return FontPlatformData(fontDescription.computedPixelSize(), bold, italic);
return CachedFont::platformDataFromCustomData(fontDescription, bold, italic);
}
RefPtr<Font> CSSFontFaceSource::font(const FontDescription& fontDescription, bool syntheticBold, bool syntheticItalic, CSSFontSelector* fontSelector)
{
// If the font hasn't loaded or an error occurred, then we've got nothing.
if (!isValid())
return nullptr;
if (!m_font
#if ENABLE(SVG_FONTS)
&& !m_svgFontFaceElement
#endif
) {
// We're local. Just return a Font from the normal cache.
// We don't want to check alternate font family names here, so pass true as the checkingAlternateName parameter.
return FontCache::singleton().fontForFamily(fontDescription, m_string, true);
}
unsigned hashKey = (fontDescription.computedPixelSize() + 1) << 5 | fontDescription.widthVariant() << 3
| (fontDescription.orientation() == Vertical ? 4 : 0) | (syntheticBold ? 2 : 0) | (syntheticItalic ? 1 : 0);
RefPtr<Font> font = m_fontTable.add(hashKey, nullptr).iterator->value;
if (font)
return font.release();
// If we are still loading, then we let the system pick a font.
if (isLoaded()) {
if (m_font) {
// Create new FontPlatformData from our CGFontRef, point size and ATSFontRef.
bool hasExternalSVGFont = false;
#if ENABLE(SVG_FONTS)
hasExternalSVGFont = m_hasExternalSVGFont;
#endif
if (!m_font->ensureCustomFontData(hasExternalSVGFont, m_string))
return nullptr;
font = m_font->createFont(fontDescription, m_string, syntheticBold, syntheticItalic, hasExternalSVGFont);
} else {
#if ENABLE(SVG_FONTS)
// In-Document SVG Fonts
if (m_svgFontFaceElement) {
#if ENABLE(SVG_OTF_CONVERTER)
if (!m_svgFontFaceElement->parentNode() || !is<SVGFontElement>(m_svgFontFaceElement->parentNode()))
return nullptr;
SVGFontElement& fontElement = downcast<SVGFontElement>(*m_svgFontFaceElement->parentNode());
// FIXME: Re-run this when script modifies the element or any of its descendents
// FIXME: We might have already converted this font. Make existing conversions discoverable.
Vector<char> otfFont = convertSVGToOTFFont(fontElement);
m_generatedOTFBuffer = SharedBuffer::adoptVector(otfFont);
if (!m_generatedOTFBuffer)
return nullptr;
auto customPlatformData = createFontCustomPlatformData(*m_generatedOTFBuffer);
if (!customPlatformData)
return nullptr;
font = Font::create(customPlatformData->fontPlatformData(fontDescription, syntheticBold, syntheticItalic), true, false);
#else
font = Font::create(std::make_unique<SVGFontData>(m_svgFontFaceElement.get()), fontDescription.computedPixelSize(), syntheticBold, syntheticItalic);
#endif
}
#endif
}
} else {
// Kick off the load. Do it soon rather than now, because we may be in the middle of layout,
// and the loader may invoke arbitrary delegate or event handler code.
fontSelector->beginLoadingFontSoon(m_font.get());
Ref<Font> placeholderFont = FontCache::singleton().lastResortFallbackFont(fontDescription);
Ref<Font> placeholderFontCopyInLoadingState = Font::create(placeholderFont->platformData(), true, true);
return WTF::move(placeholderFontCopyInLoadingState);
}
return font.release();
}
FontPlatformData::FontPlatformData(const FontDescription& in_desc, const AtomicString& in_family)
{
int size = 0;
int weight = WKC_FONT_WEIGHT_NORMAL;
int family = WKC_FONT_FAMILY_NONE;
bool italic = in_desc.italic();
switch (in_desc.genericFamily()) {
case FontDescription::NoFamily:
family = WKC_FONT_FAMILY_NONE;
break;
case FontDescription::StandardFamily:
family = WKC_FONT_FAMILY_STANDARD;
break;
case FontDescription::SerifFamily:
family = WKC_FONT_FAMILY_SERIF;
break;
case FontDescription::SansSerifFamily:
family = WKC_FONT_FAMILY_SANSSERIF;
break;
case FontDescription::MonospaceFamily:
family = WKC_FONT_FAMILY_MONOSPACE;
break;
case FontDescription::CursiveFamily:
family = WKC_FONT_FAMILY_CURSIVE;
break;
case FontDescription::FantasyFamily:
family = WKC_FONT_FAMILY_FANTASY;
break;
}
switch (in_desc.weight()) {
case FontWeight100:
weight = WKC_FONT_WEIGHT_100;
break;
case FontWeight200:
weight = WKC_FONT_WEIGHT_200;
break;
case FontWeight300:
weight = WKC_FONT_WEIGHT_300;
break;
case FontWeight400:
weight = WKC_FONT_WEIGHT_400;
break;
case FontWeight500:
weight = WKC_FONT_WEIGHT_500;
break;
case FontWeight600:
weight = WKC_FONT_WEIGHT_600;
break;
case FontWeight700:
weight = WKC_FONT_WEIGHT_700;
break;
case FontWeight800:
weight = WKC_FONT_WEIGHT_800;
break;
case FontWeight900:
weight = WKC_FONT_WEIGHT_900;
break;
}
m_requestSize = in_desc.computedPixelSize();
size = m_requestSize;
m_weight = weight;
m_italic = italic;
m_font = wkcFontNewPeer(size, weight, italic, family, in_family.string().utf8().data());
m_fontState = VALID;
m_createdSize = wkcFontGetSizePeer(m_font);
m_ascent = wkcFontGetAscentPeer(m_font);
m_descent = wkcFontGetDescentPeer(m_font);
m_lineSpacing = wkcFontGetLineSpacingPeer(m_font);
m_canScale = wkcFontCanScalePeer(m_font);
m_scale = 1.f;
if (gEnableScalingMonosizeFont && m_createdSize) {
m_scale = (float)m_requestSize / (float)m_createdSize;
}
m_iscale = 1.f / m_scale;
m_hashValue = calculateHash();
}
PassRefPtr<SimpleFontData> CSSFontFaceSource::getFontData(const FontDescription& fontDescription, bool syntheticBold, bool syntheticItalic, CSSFontSelector* fontSelector)
{
// If the font hasn't loaded or an error occurred, then we've got nothing.
if (!isValid())
return 0;
if (!m_font
#if ENABLE(SVG_FONTS)
&& !m_svgFontFaceElement
#endif
) {
// We're local. Just return a SimpleFontData from the normal cache.
// We don't want to check alternate font family names here, so pass true as the checkingAlternateName parameter.
return fontCache()->getCachedFontData(fontDescription, m_string, true);
}
// See if we have a mapping in our FontData cache.
unsigned hashKey = (fontDescription.computedPixelSize() + 1) << 5 | fontDescription.widthVariant() << 3
| (fontDescription.orientation() == Vertical ? 4 : 0) | (syntheticBold ? 2 : 0) | (syntheticItalic ? 1 : 0);
RefPtr<SimpleFontData>& fontData = m_fontDataTable.add(hashKey, 0).iterator->value;
if (fontData)
return fontData; // No release, because fontData is a reference to a RefPtr that is held in the m_fontDataTable.
// If we are still loading, then we let the system pick a font.
if (isLoaded()) {
if (m_font) {
#if ENABLE(SVG_FONTS)
if (m_hasExternalSVGFont) {
// For SVG fonts parse the external SVG document, and extract the <font> element.
if (!m_font->ensureSVGFontData())
return 0;
if (!m_externalSVGFontElement) {
String fragmentIdentifier;
size_t start = m_string.find('#');
if (start != notFound)
fragmentIdentifier = m_string.string().substring(start + 1);
m_externalSVGFontElement = m_font->getSVGFontById(fragmentIdentifier);
}
if (!m_externalSVGFontElement)
return 0;
if (auto fontFaceElement = Traversal<SVGFontFaceElement>::firstChild(m_externalSVGFontElement.get())) {
if (!m_svgFontFaceElement) {
// We're created using a CSS @font-face rule, that means we're not associated with a SVGFontFaceElement.
// Use the imported <font-face> tag as referencing font-face element for these cases.
m_svgFontFaceElement = fontFaceElement;
}
fontData = SimpleFontData::create(SVGFontData::create(fontFaceElement), fontDescription.computedPixelSize(), syntheticBold, syntheticItalic);
}
} else
#endif
{
// Create new FontPlatformData from our CGFontRef, point size and ATSFontRef.
if (!m_font->ensureCustomFontData())
return 0;
fontData = SimpleFontData::create(m_font->platformDataFromCustomData(fontDescription.computedPixelSize(), syntheticBold, syntheticItalic,
fontDescription.orientation(), fontDescription.widthVariant(), fontDescription.renderingMode()), true, false);
}
} else {
#if ENABLE(SVG_FONTS)
// In-Document SVG Fonts
if (m_svgFontFaceElement)
fontData = SimpleFontData::create(SVGFontData::create(m_svgFontFaceElement.get()), fontDescription.computedPixelSize(), syntheticBold, syntheticItalic);
#endif
}
} else {
// Kick off the load. Do it soon rather than now, because we may be in the middle of layout,
// and the loader may invoke arbitrary delegate or event handler code.
fontSelector->beginLoadingFontSoon(m_font.get());
// This temporary font is not retained and should not be returned.
FontCachePurgePreventer fontCachePurgePreventer;
SimpleFontData* temporaryFont = fontCache()->getNonRetainedLastResortFallbackFont(fontDescription);
fontData = SimpleFontData::create(temporaryFont->platformData(), true, true);
}
return fontData; // No release, because fontData is a reference to a RefPtr that is held in the m_fontDataTable.
}
