FontPlatformData* FontCache::createFontPlatformData(const FontDescription& fontDescription, const FontFaceCreationParams& creationParams, float fontSize)
{
ASSERT(creationParams.creationType() == CreateFontByFamily);
CString name;
RefPtr<SkTypeface> tf = createTypeface(fontDescription, creationParams, name);
// Windows will always give us a valid pointer here, even if the face name
// is non-existent. We have to double-check and see if the family name was
// really used.
if (!tf || !typefacesMatchesFamily(tf.get(), creationParams.family())) {
AtomicString adjustedName;
FontWeight variantWeight;
FontStretch variantStretch;
if (typefacesHasWeightSuffix(creationParams.family(), adjustedName,
variantWeight)) {
FontFaceCreationParams adjustedParams(adjustedName);
FontDescription adjustedFontDescription = fontDescription;
adjustedFontDescription.setWeight(variantWeight);
tf = createTypeface(adjustedFontDescription, adjustedParams, name);
if (!tf || !typefacesMatchesFamily(tf.get(), adjustedName))
return 0;
} else if (typefacesHasStretchSuffix(creationParams.family(),
adjustedName, variantStretch)) {
FontFaceCreationParams adjustedParams(adjustedName);
FontDescription adjustedFontDescription = fontDescription;
adjustedFontDescription.setStretch(variantStretch);
tf = createTypeface(adjustedFontDescription, adjustedParams, name);
if (!tf || !typefacesMatchesFamily(tf.get(), adjustedName))
return 0;
} else {
return 0;
}
}
FontPlatformData* result = new FontPlatformData(tf,
name.data(),
fontSize,
fontDescription.weight() >= FontWeight600 && !tf->isBold() || fontDescription.isSyntheticBold(),
fontDescription.style() == FontStyleItalic && !tf->isItalic() || fontDescription.isSyntheticItalic(),
fontDescription.orientation(),
s_useSubpixelPositioning);
struct FamilyMinSize {
const wchar_t* family;
unsigned minSize;
};
const static FamilyMinSize minAntiAliasSizeForFont[] = {
{ L"simsun", 11 },
{ L"dotum", 12 },
{ L"gulim", 12 },
{ L"pmingliu", 11 }
};
size_t numFonts = WTF_ARRAY_LENGTH(minAntiAliasSizeForFont);
for (size_t i = 0; i < numFonts; i++) {
FamilyMinSize entry = minAntiAliasSizeForFont[i];
if (typefacesMatchesFamily(tf.get(), entry.family)) {
result->setMinSizeForAntiAlias(entry.minSize);
break;
}
}
// List of fonts that look bad with subpixel text rendering at smaller font
// sizes. This includes all fonts in the Microsoft Core fonts for the Web
// collection.
const static wchar_t* noSubpixelForSmallSizeFont[] = {
L"andale mono",
L"arial",
L"comic sans",
L"courier new",
L"georgia",
L"impact",
L"lucida console",
L"tahoma",
L"times new roman",
L"trebuchet ms",
L"verdana",
L"webdings"
};
const static float minSizeForSubpixelForFont = 16.0f;
numFonts = WTF_ARRAY_LENGTH(noSubpixelForSmallSizeFont);
for (size_t i = 0; i < numFonts; i++) {
const wchar_t* family = noSubpixelForSmallSizeFont[i];
if (typefacesMatchesFamily(tf.get(), family)) {
result->setMinSizeForSubpixel(minSizeForSubpixelForFont);
break;
}
}
return result;
}
// Given the desired base font, this will create a SimpleFontData for a specific
// font that can be used to render the given range of characters.
PassRefPtr<SimpleFontData> FontCache::fallbackFontForCharacter(
const FontDescription& fontDescription, UChar32 character,
const SimpleFontData* originalFontData)
{
// First try the specified font with standard style & weight.
if (fontDescription.style() == FontStyleItalic
|| fontDescription.weight() >= FontWeightBold) {
RefPtr<SimpleFontData> fontData = fallbackOnStandardFontStyle(
fontDescription, character);
if (fontData)
return fontData;
}
// FIXME: Consider passing fontDescription.dominantScript()
// to GetFallbackFamily here.
UScriptCode script;
const wchar_t* family = getFallbackFamily(character,
fontDescription.genericFamily(),
&script,
m_fontManager.get());
FontPlatformData* data = 0;
if (family) {
FontFaceCreationParams createByFamily(AtomicString(family, wcslen(family)));
data = getFontPlatformData(fontDescription, createByFamily);
}
// Last resort font list : PanUnicode. CJK fonts have a pretty
// large repertoire. Eventually, we need to scan all the fonts
// on the system to have a Firefox-like coverage.
// Make sure that all of them are lowercased.
const static wchar_t* const cjkFonts[] = {
L"arial unicode ms",
L"ms pgothic",
L"simsun",
L"gulim",
L"pmingliu",
L"wenquanyi zen hei", // Partial CJK Ext. A coverage but more widely known to Chinese users.
L"ar pl shanheisun uni",
L"ar pl zenkai uni",
L"han nom a", // Complete CJK Ext. A coverage.
L"code2000" // Complete CJK Ext. A coverage.
// CJK Ext. B fonts are not listed here because it's of no use
// with our current non-BMP character handling because we use
// Uniscribe for it and that code path does not go through here.
};
const static wchar_t* const commonFonts[] = {
L"tahoma",
L"arial unicode ms",
L"lucida sans unicode",
L"microsoft sans serif",
L"palatino linotype",
// Six fonts below (and code2000 at the end) are not from MS, but
// once installed, cover a very wide range of characters.
L"dejavu serif",
L"dejavu sasns",
L"freeserif",
L"freesans",
L"gentium",
L"gentiumalt",
L"ms pgothic",
L"simsun",
L"gulim",
L"pmingliu",
L"code2000"
};
const wchar_t* const* panUniFonts = 0;
int numFonts = 0;
if (script == USCRIPT_HAN) {
panUniFonts = cjkFonts;
numFonts = WTF_ARRAY_LENGTH(cjkFonts);
} else {
panUniFonts = commonFonts;
numFonts = WTF_ARRAY_LENGTH(commonFonts);
}
// Font returned from getFallbackFamily may not cover |character|
// because it's based on script to font mapping. This problem is
// critical enough for non-Latin scripts (especially Han) to
// warrant an additional (real coverage) check with fontCotainsCharacter.
int i;
for (i = 0; (!data || !data->fontContainsCharacter(character)) && i < numFonts; ++i) {
family = panUniFonts[i];
FontFaceCreationParams createByFamily(AtomicString(family, wcslen(family)));
data = getFontPlatformData(fontDescription, createByFamily);
}
// For font fallback we want to match the subpixel behavior of the original
// font. Mixing subpixel and non-subpixel in the same text run looks really
// odd and causes problems with preferred width calculations.
if (data && originalFontData) {
const FontPlatformData& platformData = originalFontData->platformData();
data->setMinSizeForAntiAlias(platformData.minSizeForAntiAlias());
data->setMinSizeForSubpixel(platformData.minSizeForSubpixel());
}
// When i-th font (0-base) in |panUniFonts| contains a character and
// we get out of the loop, |i| will be |i + 1|. That is, if only the
// last font in the array covers the character, |i| will be numFonts.
// So, we have to use '<=" rather than '<' to see if we found a font
// covering the character.
if (i <= numFonts)
return fontDataFromFontPlatformData(data, DoNotRetain);
return nullptr;
}