const FontData* FontFallbackList::primaryFontData(const FontDescription& fontDescription) const
{
bool shouldLoadCustomFont = true;
for (unsigned fontIndex = 0; ; ++fontIndex) {
const FontData* fontData = fontDataAt(fontDescription, fontIndex);
if (!fontData) {
// All fonts are custom fonts and are loading. Return the first FontData.
// FIXME: Correct fallback to the default font.
return fontDataAt(fontDescription, 0);
}
if (fontData->isSegmented() && !toSegmentedFontData(fontData)->containsCharacter(' '))
continue;
// When a custom font is loading, we should use the correct fallback font to layout the text.
// Here skip the temporary font for the loading custom font which may not act as the correct fallback font.
if (!fontData->isLoadingFallback())
return fontData;
// Begin to load the first custom font if needed.
if (shouldLoadCustomFont) {
shouldLoadCustomFont = false;
const SimpleFontData* simpleFontData = fontData->fontDataForCharacter(' ');
if (simpleFontData && simpleFontData->customFontData())
simpleFontData->customFontData()->beginLoadIfNeeded();
}
}
}
const BIFontData* FontFallbackList::fontDataForCharacters(const Font* font, const UChar* characters, int length) const
{
// This method is only called when the primary font does not contain the characters we need.
// Begin our search at position 1.
unsigned realizedFontIndex = 1;
const BIFontData* fontData = fontDataAt(font, realizedFontIndex);
while (fontData && !fontData->containsCharacters(characters, length))
fontData = fontDataAt(font, ++realizedFontIndex);
return fontData;
}
const SimpleFontData* Font::fontDataForCombiningCharacterSequence(const UChar* characters, size_t length, FontDataVariant variant) const
{
UChar32 baseCharacter;
size_t baseCharacterLength = 0;
U16_NEXT(characters, baseCharacterLength, length, baseCharacter);
GlyphData baseCharacterGlyphData = glyphDataForCharacter(baseCharacter, false, variant);
if (!baseCharacterGlyphData.glyph)
return 0;
if (length == baseCharacterLength)
return baseCharacterGlyphData.fontData;
bool triedBaseCharacterFontData = false;
unsigned i = 0;
for (const FontData* fontData = fontDataAt(0); fontData; fontData = fontDataAt(++i)) {
const SimpleFontData* simpleFontData = fontData->fontDataForCharacter(baseCharacter);
if (variant == NormalVariant) {
if (simpleFontData->platformData().orientation() == Vertical) {
if (isCJKIdeographOrSymbol(baseCharacter) && !simpleFontData->hasVerticalGlyphs()) {
variant = BrokenIdeographVariant;
simpleFontData = simpleFontData->brokenIdeographFontData().get();
} else if (m_fontDescription.nonCJKGlyphOrientation() == NonCJKGlyphOrientationVerticalRight) {
SimpleFontData* verticalRightFontData = simpleFontData->verticalRightOrientationFontData().get();
Glyph verticalRightGlyph = verticalRightFontData->glyphForCharacter(baseCharacter);
if (verticalRightGlyph == baseCharacterGlyphData.glyph)
simpleFontData = verticalRightFontData;
} else {
SimpleFontData* uprightFontData = simpleFontData->uprightOrientationFontData().get();
Glyph uprightGlyph = uprightFontData->glyphForCharacter(baseCharacter);
if (uprightGlyph != baseCharacterGlyphData.glyph)
simpleFontData = uprightFontData;
}
}
} else {
if (const SimpleFontData* variantFontData = simpleFontData->variantFontData(m_fontDescription, variant).get())
simpleFontData = variantFontData;
}
if (simpleFontData == baseCharacterGlyphData.fontData)
triedBaseCharacterFontData = true;
if (simpleFontData->canRenderCombiningCharacterSequence(characters, length))
return simpleFontData;
}
if (!triedBaseCharacterFontData && baseCharacterGlyphData.fontData && baseCharacterGlyphData.fontData->canRenderCombiningCharacterSequence(characters, length))
return baseCharacterGlyphData.fontData;
return SimpleFontData::systemFallback();
}
void FontFallbackList::determinePitch(const FontDescription& fontDescription) const
{
for (unsigned fontIndex = 0; ; ++fontIndex) {
const FontData* fontData = fontDataAt(fontDescription, fontIndex);
if (!fontData) {
// All fonts are custom fonts and are loading. Fallback should be variable pitch.
m_pitch = VariablePitch;
break;
}
const SimpleFontData* simpleFontData;
if (fontData->isSegmented()) {
const SegmentedFontData* segmentedFontData = toSegmentedFontData(fontData);
if (segmentedFontData->numRanges() != 1 || !segmentedFontData->rangeAt(0).isEntireRange()) {
m_pitch = VariablePitch;
break;
}
simpleFontData = segmentedFontData->rangeAt(0).fontData().get();
} else {
simpleFontData = toSimpleFontData(fontData);
}
if (!fontData->isLoadingFallback()) {
m_pitch = simpleFontData->pitch();
break;
}
}
}
const FontData* FontFallbackList::fontDataForCharacters(const Font* font, const UChar* characters, int length) const
{
// This method is only called when the primary font does not contain the characters we need.
// Begin our search at position 1.
unsigned realizedFontIndex = 1;
const FontData* fontData = fontDataAt(font, realizedFontIndex);
while (fontData && !fontData->containsCharacters(characters, length))
fontData = fontDataAt(font, ++realizedFontIndex);
if (!fontData) {
ASSERT(fontCache()->generation() == m_generation);
fontData = fontCache()->getFontDataForCharacters(*font, characters, length).get();
}
return fontData;
}
const SimpleFontData* FontFallbackList::determinePrimarySimpleFontData(const FontDescription& fontDescription) const
{
bool shouldLoadCustomFont = true;
for (unsigned fontIndex = 0; ; ++fontIndex) {
const FontData* fontData = fontDataAt(fontDescription, fontIndex);
if (!fontData) {
// All fonts are custom fonts and are loading. Return the first FontData.
fontData = fontDataAt(fontDescription, 0);
if (fontData)
return fontData->fontDataForCharacter(space);
SimpleFontData* lastResortFallback = FontCache::fontCache()->getLastResortFallbackFont(fontDescription).get();
ASSERT(lastResortFallback);
return lastResortFallback;
}
if (fontData->isSegmented() && !toSegmentedFontData(fontData)->containsCharacter(space))
continue;
const SimpleFontData* fontDataForSpace = fontData->fontDataForCharacter(space);
ASSERT(fontDataForSpace);
// When a custom font is loading, we should use the correct fallback font to layout the text.
// Here skip the temporary font for the loading custom font which may not act as the correct fallback font.
if (!fontDataForSpace->isLoadingFallback())
return fontDataForSpace;
if (fontData->isSegmented()) {
const SegmentedFontData* segmented = toSegmentedFontData(fontData);
for (unsigned i = 0; i < segmented->numRanges(); i++) {
const SimpleFontData* rangeFontData = segmented->rangeAt(i).fontData().get();
if (!rangeFontData->isLoadingFallback())
return rangeFontData;
}
if (fontData->isLoading())
shouldLoadCustomFont = false;
}
// Begin to load the first custom font if needed.
if (shouldLoadCustomFont) {
shouldLoadCustomFont = false;
fontDataForSpace->customFontData()->beginLoadIfNeeded();
}
}
}
GlyphData Font::glyphDataForCharacter(UChar32 c, bool mirror, FontDataVariant variant) const
{
ASSERT(isMainThread());
if (variant == AutoVariant) {
if (m_fontDescription.smallCaps()) {
UChar32 upperC = toUpper(c);
if (upperC != c) {
c = upperC;
variant = SmallCapsVariant;
} else
variant = NormalVariant;
} else
variant = NormalVariant;
}
if (mirror)
c = mirroredChar(c);
unsigned pageNumber = (c / GlyphPage::size);
GlyphPageTreeNode* node = pageNumber ? m_fontList->m_pages.get(pageNumber) : m_fontList->m_pageZero;
if (!node) {
node = GlyphPageTreeNode::getRootChild(fontDataAt(0), pageNumber);
if (pageNumber)
m_fontList->m_pages.set(pageNumber, node);
else
m_fontList->m_pageZero = node;
}
GlyphPage* page;
if (variant == NormalVariant) {
// Fastest loop, for the common case (normal variant).
while (true) {
page = node->page();
if (page) {
GlyphData data = page->glyphDataForCharacter(c);
if (data.fontData && (data.fontData->platformData().orientation() == Horizontal || data.fontData->isTextOrientationFallback()))
return data;
if (data.fontData) {
if (isCJKIdeographOrSymbol(c)) {
if (!data.fontData->hasVerticalGlyphs()) {
// Use the broken ideograph font data. The broken ideograph font will use the horizontal width of glyphs
// to make sure you get a square (even for broken glyphs like symbols used for punctuation).
const SimpleFontData* brokenIdeographFontData = data.fontData->brokenIdeographFontData();
GlyphPageTreeNode* brokenIdeographNode = GlyphPageTreeNode::getRootChild(brokenIdeographFontData, pageNumber);
const GlyphPage* brokenIdeographPage = brokenIdeographNode->page();
if (brokenIdeographPage) {
GlyphData brokenIdeographData = brokenIdeographPage->glyphDataForCharacter(c);
if (brokenIdeographData.fontData)
return brokenIdeographData;
}
// Shouldn't be possible to even reach this point.
ASSERT_NOT_REACHED();
}
} else {
if (m_fontDescription.textOrientation() == TextOrientationVerticalRight) {
const SimpleFontData* verticalRightFontData = data.fontData->verticalRightOrientationFontData();
GlyphPageTreeNode* verticalRightNode = GlyphPageTreeNode::getRootChild(verticalRightFontData, pageNumber);
const GlyphPage* verticalRightPage = verticalRightNode->page();
if (verticalRightPage) {
GlyphData verticalRightData = verticalRightPage->glyphDataForCharacter(c);
// If the glyphs are distinct, we will make the assumption that the font has a vertical-right glyph baked
// into it.
if (data.glyph != verticalRightData.glyph)
return data;
// The glyphs are identical, meaning that we should just use the horizontal glyph.
if (verticalRightData.fontData)
return verticalRightData;
}
} else if (m_fontDescription.textOrientation() == TextOrientationUpright) {
const SimpleFontData* uprightFontData = data.fontData->uprightOrientationFontData();
GlyphPageTreeNode* uprightNode = GlyphPageTreeNode::getRootChild(uprightFontData, pageNumber);
const GlyphPage* uprightPage = uprightNode->page();
if (uprightPage) {
GlyphData uprightData = uprightPage->glyphDataForCharacter(c);
// If the glyphs are the same, then we know we can just use the horizontal glyph rotated vertically to be upright.
if (data.glyph == uprightData.glyph)
return data;
// The glyphs are distinct, meaning that the font has a vertical-right glyph baked into it. We can't use that
// glyph, so we fall back to the upright data and use the horizontal glyph.
if (uprightData.fontData)
return uprightData;
}
}
// Shouldn't be possible to even reach this point.
ASSERT_NOT_REACHED();
}
return data;
}
if (node->isSystemFallback())
break;
}
// Proceed with the fallback list.
node = node->getChild(fontDataAt(node->level()), pageNumber);
if (pageNumber)
m_fontList->m_pages.set(pageNumber, node);
else
m_fontList->m_pageZero = node;
}
} else {
while (true) {
page = node->page();
if (page) {
GlyphData data = page->glyphDataForCharacter(c);
if (data.fontData) {
// The variantFontData function should not normally return 0.
// But if it does, we will just render the capital letter big.
const SimpleFontData* variantFontData = data.fontData->variantFontData(m_fontDescription, variant);
if (!variantFontData)
return data;
GlyphPageTreeNode* variantNode = GlyphPageTreeNode::getRootChild(variantFontData, pageNumber);
const GlyphPage* variantPage = variantNode->page();
if (variantPage) {
GlyphData data = variantPage->glyphDataForCharacter(c);
if (data.fontData)
return data;
}
// Do not attempt system fallback off the variantFontData. This is the very unlikely case that
// a font has the lowercase character but the small caps font does not have its uppercase version.
return variantFontData->missingGlyphData();
}
if (node->isSystemFallback())
break;
}
// Proceed with the fallback list.
node = node->getChild(fontDataAt(node->level()), pageNumber);
if (pageNumber)
m_fontList->m_pages.set(pageNumber, node);
else
m_fontList->m_pageZero = node;
}
}
ASSERT(page);
ASSERT(node->isSystemFallback());
// System fallback is character-dependent. When we get here, we
// know that the character in question isn't in the system fallback
// font's glyph page. Try to lazily create it here.
UChar codeUnits[2];
int codeUnitsLength;
if (c <= 0xFFFF) {
codeUnits[0] = Font::normalizeSpaces(c);
codeUnitsLength = 1;
} else {
codeUnits[0] = U16_LEAD(c);
codeUnits[1] = U16_TRAIL(c);
codeUnitsLength = 2;
}
const SimpleFontData* characterFontData = fontCache()->getFontDataForCharacters(*this, codeUnits, codeUnitsLength);
if (variant != NormalVariant && characterFontData)
characterFontData = characterFontData->variantFontData(m_fontDescription, variant);
if (characterFontData) {
// Got the fallback glyph and font.
GlyphPage* fallbackPage = GlyphPageTreeNode::getRootChild(characterFontData, pageNumber)->page();
GlyphData data = fallbackPage && fallbackPage->fontDataForCharacter(c) ? fallbackPage->glyphDataForCharacter(c) : characterFontData->missingGlyphData();
// Cache it so we don't have to do system fallback again next time.
if (variant == NormalVariant) {
#if OS(WINCE)
// missingGlyphData returns a null character, which is not suitable for GDI to display.
// Also, sometimes we cannot map a font for the character on WINCE, but GDI can still
// display the character, probably because the font package is not installed correctly.
// So we just always set the glyph to be same as the character, and let GDI solve it.
page->setGlyphDataForCharacter(c, c, characterFontData);
return page->glyphDataForCharacter(c);
#else
page->setGlyphDataForCharacter(c, data.glyph, data.fontData);
#endif
}
return data;
}
// Even system fallback can fail; use the missing glyph in that case.
// FIXME: It would be nicer to use the missing glyph from the last resort font instead.
GlyphData data = primaryFont()->missingGlyphData();
if (variant == NormalVariant) {
#if OS(WINCE)
// See comment about WINCE GDI handling near setGlyphDataForCharacter above.
page->setGlyphDataForCharacter(c, c, data.fontData);
return page->glyphDataForCharacter(c);
#else
page->setGlyphDataForCharacter(c, data.glyph, data.fontData);
#endif
}
return data;
}
std::pair<GlyphData, GlyphPage*> Font::glyphDataAndPageForCharacter(UChar32 c, bool mirror, FontDataVariant variant) const
{
ASSERT(isMainThread());
if (variant == AutoVariant) {
if (m_fontDescription.smallCaps() && !primaryFont()->isSVGFont()) {
UChar32 upperC = toUpper(c);
if (upperC != c) {
c = upperC;
variant = SmallCapsVariant;
} else {
variant = NormalVariant;
}
} else {
variant = NormalVariant;
}
}
if (mirror)
c = mirroredChar(c);
unsigned pageNumber = (c / GlyphPage::size);
GlyphPageTreeNode* node = pageNumber ? m_fontFallbackList->m_pages.get(pageNumber) : m_fontFallbackList->m_pageZero;
if (!node) {
node = GlyphPageTreeNode::getRootChild(fontDataAt(0), pageNumber);
if (pageNumber)
m_fontFallbackList->m_pages.set(pageNumber, node);
else
m_fontFallbackList->m_pageZero = node;
}
GlyphPage* page = 0;
if (variant == NormalVariant) {
// Fastest loop, for the common case (normal variant).
while (true) {
page = node->page();
if (page) {
GlyphData data = page->glyphDataForCharacter(c);
if (data.fontData && (data.fontData->platformData().orientation() == Horizontal || data.fontData->isTextOrientationFallback()))
return make_pair(data, page);
if (data.fontData) {
if (Character::isCJKIdeographOrSymbol(c)) {
if (!data.fontData->hasVerticalGlyphs()) {
// Use the broken ideograph font data. The broken ideograph font will use the horizontal width of glyphs
// to make sure you get a square (even for broken glyphs like symbols used for punctuation).
variant = BrokenIdeographVariant;
break;
}
} else {
return glyphDataAndPageForNonCJKCharacterWithGlyphOrientation(c, m_fontDescription.nonCJKGlyphOrientation(), data, page, pageNumber);
}
return make_pair(data, page);
}
if (node->isSystemFallback())
break;
}
// Proceed with the fallback list.
node = node->getChild(fontDataAt(node->level()), pageNumber);
if (pageNumber)
m_fontFallbackList->m_pages.set(pageNumber, node);
else
m_fontFallbackList->m_pageZero = node;
}
}
if (variant != NormalVariant) {
while (true) {
page = node->page();
if (page) {
GlyphData data = page->glyphDataForCharacter(c);
if (data.fontData) {
// The variantFontData function should not normally return 0.
// But if it does, we will just render the capital letter big.
RefPtr<SimpleFontData> variantFontData = data.fontData->variantFontData(m_fontDescription, variant);
if (!variantFontData)
return make_pair(data, page);
GlyphPageTreeNode* variantNode = GlyphPageTreeNode::getRootChild(variantFontData.get(), pageNumber);
GlyphPage* variantPage = variantNode->page();
if (variantPage) {
GlyphData data = variantPage->glyphDataForCharacter(c);
if (data.fontData)
return make_pair(data, variantPage);
}
// Do not attempt system fallback off the variantFontData. This is the very unlikely case that
// a font has the lowercase character but the small caps font does not have its uppercase version.
return make_pair(variantFontData->missingGlyphData(), page);
}
if (node->isSystemFallback())
break;
}
// Proceed with the fallback list.
node = node->getChild(fontDataAt(node->level()), pageNumber);
if (pageNumber)
m_fontFallbackList->m_pages.set(pageNumber, node);
else
m_fontFallbackList->m_pageZero = node;
}
}
ASSERT(page);
ASSERT(node->isSystemFallback());
// System fallback is character-dependent. When we get here, we
// know that the character in question isn't in the system fallback
// font's glyph page. Try to lazily create it here.
// FIXME: Unclear if this should normalizeSpaces above 0xFFFF.
// Doing so changes fast/text/international/plane2-diffs.html
UChar32 characterToRender = c;
if (characterToRender <= 0xFFFF)
characterToRender = Character::normalizeSpaces(characterToRender);
const SimpleFontData* fontDataToSubstitute = fontDataAt(0)->fontDataForCharacter(characterToRender);
RefPtr<SimpleFontData> characterFontData = FontCache::fontCache()->platformFallbackForCharacter(m_fontDescription, characterToRender, fontDataToSubstitute);
if (characterFontData) {
if (characterFontData->platformData().orientation() == Vertical && !characterFontData->hasVerticalGlyphs() && Character::isCJKIdeographOrSymbol(c))
variant = BrokenIdeographVariant;
if (variant != NormalVariant)
characterFontData = characterFontData->variantFontData(m_fontDescription, variant);
}
if (characterFontData) {
// Got the fallback glyph and font.
GlyphPage* fallbackPage = GlyphPageTreeNode::getRootChild(characterFontData.get(), pageNumber)->page();
GlyphData data = fallbackPage && fallbackPage->fontDataForCharacter(c) ? fallbackPage->glyphDataForCharacter(c) : characterFontData->missingGlyphData();
// Cache it so we don't have to do system fallback again next time.
if (variant == NormalVariant) {
page->setGlyphDataForCharacter(c, data.glyph, data.fontData);
data.fontData->setMaxGlyphPageTreeLevel(max(data.fontData->maxGlyphPageTreeLevel(), node->level()));
if (!Character::isCJKIdeographOrSymbol(c) && data.fontData->platformData().orientation() != Horizontal && !data.fontData->isTextOrientationFallback())
return glyphDataAndPageForNonCJKCharacterWithGlyphOrientation(c, m_fontDescription.nonCJKGlyphOrientation(), data, fallbackPage, pageNumber);
}
return make_pair(data, page);
}
// Even system fallback can fail; use the missing glyph in that case.
// FIXME: It would be nicer to use the missing glyph from the last resort font instead.
GlyphData data = primaryFont()->missingGlyphData();
if (variant == NormalVariant) {
page->setGlyphDataForCharacter(c, data.glyph, data.fontData);
data.fontData->setMaxGlyphPageTreeLevel(max(data.fontData->maxGlyphPageTreeLevel(), node->level()));
}
return make_pair(data, page);
}
const GlyphData& Font::glyphDataForCharacter(UChar32 c, bool mirror, bool forceSmallCaps) const
{
bool useSmallCapsFont = forceSmallCaps;
if (m_fontDescription.smallCaps()) {
UChar32 upperC = Unicode::toUpper(c);
if (upperC != c) {
c = upperC;
useSmallCapsFont = true;
}
}
if (mirror)
c = mirroredChar(c);
unsigned pageNumber = (c / GlyphPage::size);
GlyphPageTreeNode* node = pageNumber ? m_pages.get(pageNumber) : m_pageZero;
if (!node) {
node = GlyphPageTreeNode::getRootChild(fontDataAt(0), pageNumber);
if (pageNumber)
m_pages.set(pageNumber, node);
else
m_pageZero = node;
}
GlyphPage* page;
if (!useSmallCapsFont) {
// Fastest loop, for the common case (not small caps).
while (true) {
page = node->page();
if (page) {
const GlyphData& data = page->glyphDataForCharacter(c);
if (data.fontData)
return data;
if (node->isSystemFallback())
break;
}
// Proceed with the fallback list.
node = node->getChild(fontDataAt(node->level()), pageNumber);
if (pageNumber)
m_pages.set(pageNumber, node);
else
m_pageZero = node;
}
} else {
while (true) {
page = node->page();
if (page) {
const GlyphData& data = page->glyphDataForCharacter(c);
if (data.fontData) {
// The smallCapsFontData function should not normally return 0.
// But if it does, we will just render the capital letter big.
const SimpleFontData* smallCapsFontData = data.fontData->smallCapsFontData(m_fontDescription);
if (!smallCapsFontData)
return data;
GlyphPageTreeNode* smallCapsNode = GlyphPageTreeNode::getRootChild(smallCapsFontData, pageNumber);
const GlyphPage* smallCapsPage = smallCapsNode->page();
if (smallCapsPage) {
const GlyphData& data = smallCapsPage->glyphDataForCharacter(c);
if (data.fontData)
return data;
}
// Do not attempt system fallback off the smallCapsFontData. This is the very unlikely case that
// a font has the lowercase character but the small caps font does not have its uppercase version.
return smallCapsFontData->missingGlyphData();
}
if (node->isSystemFallback())
break;
}
// Proceed with the fallback list.
node = node->getChild(fontDataAt(node->level()), pageNumber);
if (pageNumber)
m_pages.set(pageNumber, node);
else
m_pageZero = node;
}
}
ASSERT(page);
ASSERT(node->isSystemFallback());
// System fallback is character-dependent. When we get here, we
// know that the character in question isn't in the system fallback
// font's glyph page. Try to lazily create it here.
UChar codeUnits[2];
int codeUnitsLength;
if (c <= 0xFFFF) {
UChar c16 = c;
if (Font::treatAsSpace(c16))
codeUnits[0] = ' ';
else if (Font::treatAsZeroWidthSpace(c16))
codeUnits[0] = zeroWidthSpace;
else
codeUnits[0] = c16;
codeUnitsLength = 1;
} else {
codeUnits[0] = U16_LEAD(c);
codeUnits[1] = U16_TRAIL(c);
codeUnitsLength = 2;
}
const SimpleFontData* characterFontData = FontCache::getFontDataForCharacters(*this, codeUnits, codeUnitsLength);
if (useSmallCapsFont)
characterFontData = characterFontData->smallCapsFontData(m_fontDescription);
if (characterFontData) {
// Got the fallback glyph and font.
GlyphPage* fallbackPage = GlyphPageTreeNode::getRootChild(characterFontData, pageNumber)->page();
const GlyphData& data = fallbackPage && fallbackPage->glyphDataForCharacter(c).fontData ? fallbackPage->glyphDataForCharacter(c) : characterFontData->missingGlyphData();
// Cache it so we don't have to do system fallback again next time.
if (!useSmallCapsFont)
page->setGlyphDataForCharacter(c, data.glyph, data.fontData);
return data;
}
// Even system fallback can fail; use the missing glyph in that case.
// FIXME: It would be nicer to use the missing glyph from the last resort font instead.
const GlyphData& data = primaryFont()->missingGlyphData();
if (!useSmallCapsFont)
page->setGlyphDataForCharacter(c, data.glyph, data.fontData);
return data;
}
GlyphData Font::glyphDataForCharacter(UChar32 c, bool mirror, bool forceSmallCaps) const
{
ASSERT(isMainThread());
bool useSmallCapsFont = forceSmallCaps;
if (m_fontDescription.smallCaps()) {
UChar32 upperC = toUpper(c);
if (upperC != c) {
c = upperC;
useSmallCapsFont = true;
}
}
if (mirror)
c = mirroredChar(c);
unsigned pageNumber = (c / GlyphPage::size);
GlyphPageTreeNode* node = pageNumber ? m_fontList->m_pages.get(pageNumber) : m_fontList->m_pageZero;
if (!node) {
node = GlyphPageTreeNode::getRootChild(fontDataAt(0), pageNumber);
if (pageNumber)
m_fontList->m_pages.set(pageNumber, node);
else
m_fontList->m_pageZero = node;
}
GlyphPage* page;
if (!useSmallCapsFont) {
// Fastest loop, for the common case (not small caps).
while (true) {
page = node->page();
if (page) {
GlyphData data = page->glyphDataForCharacter(c);
if (data.fontData)
return data;
if (node->isSystemFallback())
break;
}
// Proceed with the fallback list.
node = node->getChild(fontDataAt(node->level()), pageNumber);
if (pageNumber)
m_fontList->m_pages.set(pageNumber, node);
else
m_fontList->m_pageZero = node;
}
} else {
while (true) {
page = node->page();
if (page) {
GlyphData data = page->glyphDataForCharacter(c);
if (data.fontData) {
// The smallCapsFontData function should not normally return 0.
// But if it does, we will just render the capital letter big.
const SimpleFontData* smallCapsFontData = data.fontData->smallCapsFontData(m_fontDescription);
if (!smallCapsFontData)
return data;
GlyphPageTreeNode* smallCapsNode = GlyphPageTreeNode::getRootChild(smallCapsFontData, pageNumber);
const GlyphPage* smallCapsPage = smallCapsNode->page();
if (smallCapsPage) {
GlyphData data = smallCapsPage->glyphDataForCharacter(c);
if (data.fontData)
return data;
}
// Do not attempt system fallback off the smallCapsFontData. This is the very unlikely case that
// a font has the lowercase character but the small caps font does not have its uppercase version.
return smallCapsFontData->missingGlyphData();
}
if (node->isSystemFallback())
break;
}
// Proceed with the fallback list.
node = node->getChild(fontDataAt(node->level()), pageNumber);
if (pageNumber)
m_fontList->m_pages.set(pageNumber, node);
else
m_fontList->m_pageZero = node;
}
}
ASSERT(page);
ASSERT(node->isSystemFallback());
// System fallback is character-dependent. When we get here, we
// know that the character in question isn't in the system fallback
// font's glyph page. Try to lazily create it here.
UChar codeUnits[2];
int codeUnitsLength;
if (c <= 0xFFFF) {
codeUnits[0] = Font::normalizeSpaces(c);
codeUnitsLength = 1;
} else {
codeUnits[0] = U16_LEAD(c);
codeUnits[1] = U16_TRAIL(c);
codeUnitsLength = 2;
}
const SimpleFontData* characterFontData = fontCache()->getFontDataForCharacters(*this, codeUnits, codeUnitsLength);
if (useSmallCapsFont && characterFontData)
characterFontData = characterFontData->smallCapsFontData(m_fontDescription);
if (characterFontData) {
// Got the fallback glyph and font.
GlyphPage* fallbackPage = GlyphPageTreeNode::getRootChild(characterFontData, pageNumber)->page();
GlyphData data = fallbackPage && fallbackPage->fontDataForCharacter(c) ? fallbackPage->glyphDataForCharacter(c) : characterFontData->missingGlyphData();
// Cache it so we don't have to do system fallback again next time.
if (!useSmallCapsFont) {
#if OS(WINCE)
// missingGlyphData returns a null character, which is not suitable for GDI to display.
// Also, sometimes we cannot map a font for the character on WINCE, but GDI can still
// display the character, probably because the font package is not installed correctly.
// So we just always set the glyph to be same as the character, and let GDI solve it.
page->setGlyphDataForCharacter(c, c, characterFontData);
return page->glyphDataForCharacter(c);
#else
page->setGlyphDataForCharacter(c, data.glyph, data.fontData);
#endif
}
return data;
}
// Even system fallback can fail; use the missing glyph in that case.
// FIXME: It would be nicer to use the missing glyph from the last resort font instead.
GlyphData data = primaryFont()->missingGlyphData();
if (!useSmallCapsFont) {
#if OS(WINCE)
// See comment about WINCE GDI handling near setGlyphDataForCharacter above.
page->setGlyphDataForCharacter(c, c, data.fontData);
return page->glyphDataForCharacter(c);
#else
page->setGlyphDataForCharacter(c, data.glyph, data.fontData);
#endif
}
return data;
}
std::pair<GlyphData, GlyphPage*> Font::glyphDataAndPageForCharacter(UChar32 c, bool mirror, FontDataVariant variant) const
{
ASSERT(isMainThread());
if (variant == AutoVariant) {
if (m_fontDescription.smallCaps() && !primaryFont()->isSVGFont()) {
UChar32 upperC = toUpper(c);
if (upperC != c) {
c = upperC;
variant = SmallCapsVariant;
} else
variant = NormalVariant;
} else
variant = NormalVariant;
}
if (mirror)
c = mirroredChar(c);
unsigned pageNumber = (c / GlyphPage::size);
GlyphPageTreeNode* node = pageNumber ? m_fontFallbackList->m_pages.get(pageNumber) : m_fontFallbackList->m_pageZero;
if (!node) {
node = GlyphPageTreeNode::getRootChild(fontDataAt(0), pageNumber);
if (pageNumber)
m_fontFallbackList->m_pages.set(pageNumber, node);
else
m_fontFallbackList->m_pageZero = node;
}
GlyphPage* page = 0;
if (variant == NormalVariant) {
// Fastest loop, for the common case (normal variant).
while (true) {
page = node->page();
if (page) {
GlyphData data = page->glyphDataForCharacter(c);
if (data.fontData && (data.fontData->platformData().orientation() == Horizontal || data.fontData->isTextOrientationFallback()))
return make_pair(data, page);
if (data.fontData) {
if (isCJKIdeographOrSymbol(c)) {
if (!data.fontData->hasVerticalGlyphs()) {
// Use the broken ideograph font data. The broken ideograph font will use the horizontal width of glyphs
// to make sure you get a square (even for broken glyphs like symbols used for punctuation).
variant = BrokenIdeographVariant;
break;
}
} else
return glyphDataAndPageForNonCJKCharacterWithGlyphOrientation(c, m_fontDescription.nonCJKGlyphOrientation(), data, page, pageNumber);
return make_pair(data, page);
}
if (node->isSystemFallback())
break;
}
// Proceed with the fallback list.
node = node->getChild(fontDataAt(node->level()), pageNumber);
if (pageNumber)
m_fontFallbackList->m_pages.set(pageNumber, node);
else
m_fontFallbackList->m_pageZero = node;
}
}
if (variant != NormalVariant) {
while (true) {
page = node->page();
if (page) {
GlyphData data = page->glyphDataForCharacter(c);
if (data.fontData) {
// The variantFontData function should not normally return 0.
// But if it does, we will just render the capital letter big.
RefPtr<SimpleFontData> variantFontData = data.fontData->variantFontData(m_fontDescription, variant);
if (!variantFontData)
return make_pair(data, page);
GlyphPageTreeNode* variantNode = GlyphPageTreeNode::getRootChild(variantFontData.get(), pageNumber);
GlyphPage* variantPage = variantNode->page();
if (variantPage) {
GlyphData data = variantPage->glyphDataForCharacter(c);
if (data.fontData)
return make_pair(data, variantPage);
}
// Do not attempt system fallback off the variantFontData. This is the very unlikely case that
// a font has the lowercase character but the small caps font does not have its uppercase version.
return make_pair(variantFontData->missingGlyphData(), page);
}
if (node->isSystemFallback())
break;
}
// Proceed with the fallback list.
node = node->getChild(fontDataAt(node->level()), pageNumber);
if (pageNumber)
m_fontFallbackList->m_pages.set(pageNumber, node);
else
m_fontFallbackList->m_pageZero = node;
}
}
ASSERT(page);
ASSERT(node->isSystemFallback());
// System fallback is character-dependent. When we get here, we
// know that the character in question isn't in the system fallback
// font's glyph page. Try to lazily create it here.
UChar codeUnits[2];
int codeUnitsLength;
if (c <= 0xFFFF) {
codeUnits[0] = Font::normalizeSpaces(c);
codeUnitsLength = 1;
} else {
codeUnits[0] = U16_LEAD(c);
codeUnits[1] = U16_TRAIL(c);
codeUnitsLength = 2;
}
RefPtr<SimpleFontData> characterFontData = fontCache()->getFontDataForCharacters(*this, codeUnits, codeUnitsLength);
if (characterFontData) {
if (characterFontData->platformData().orientation() == Vertical && !characterFontData->hasVerticalGlyphs() && isCJKIdeographOrSymbol(c))
variant = BrokenIdeographVariant;
if (variant != NormalVariant)
characterFontData = characterFontData->variantFontData(m_fontDescription, variant);
}
if (characterFontData) {
// Got the fallback glyph and font.
GlyphPage* fallbackPage = GlyphPageTreeNode::getRootChild(characterFontData.get(), pageNumber)->page();
GlyphData data = fallbackPage && fallbackPage->fontDataForCharacter(c) ? fallbackPage->glyphDataForCharacter(c) : characterFontData->missingGlyphData();
// Cache it so we don't have to do system fallback again next time.
if (variant == NormalVariant) {
#if OS(WINCE)
// missingGlyphData returns a null character, which is not suitable for GDI to display.
// Also, sometimes we cannot map a font for the character on WINCE, but GDI can still
// display the character, probably because the font package is not installed correctly.
// So we just always set the glyph to be same as the character, and let GDI solve it.
page->setGlyphDataForCharacter(c, c, characterFontData.get());
characterFontData->setMaxGlyphPageTreeLevel(max(characterFontData->maxGlyphPageTreeLevel(), node->level()));
return make_pair(page->glyphDataForCharacter(c), page);
#else
page->setGlyphDataForCharacter(c, data.glyph, data.fontData);
data.fontData->setMaxGlyphPageTreeLevel(max(data.fontData->maxGlyphPageTreeLevel(), node->level()));
if (!isCJKIdeographOrSymbol(c) && data.fontData->platformData().orientation() != Horizontal && !data.fontData->isTextOrientationFallback())
return glyphDataAndPageForNonCJKCharacterWithGlyphOrientation(c, m_fontDescription.nonCJKGlyphOrientation(), data, fallbackPage, pageNumber);
#endif
}
return make_pair(data, page);
}
// Even system fallback can fail; use the missing glyph in that case.
// FIXME: It would be nicer to use the missing glyph from the last resort font instead.
GlyphData data = primaryFont()->missingGlyphData();
if (variant == NormalVariant) {
#if OS(WINCE)
// See comment about WINCE GDI handling near setGlyphDataForCharacter above.
page->setGlyphDataForCharacter(c, c, data.fontData);
data.fontData->setMaxGlyphPageTreeLevel(max(data.fontData->maxGlyphPageTreeLevel(), node->level()));
return make_pair(page->glyphDataForCharacter(c), page);
#else
page->setGlyphDataForCharacter(c, data.glyph, data.fontData);
data.fontData->setMaxGlyphPageTreeLevel(max(data.fontData->maxGlyphPageTreeLevel(), node->level()));
#endif
}
return make_pair(data, page);
}
