void SVGFontElement::ensureGlyphCache()
{
if (m_isGlyphCacheValid)
return;
SVGMissingGlyphElement* firstMissingGlyphElement = 0;
Vector<String> ligatures;
for (Node* child = firstChild(); child; child = child->nextSibling()) {
if (child->hasTagName(SVGNames::glyphTag)) {
SVGGlyphElement* glyph = static_cast<SVGGlyphElement*>(child);
AtomicString unicode = glyph->fastGetAttribute(SVGNames::unicodeAttr);
AtomicString glyphId = glyph->getIdAttribute();
if (glyphId.isEmpty() && unicode.isEmpty())
continue;
m_glyphMap.addGlyph(glyphId, unicode, glyph->buildGlyphIdentifier());
// Register ligatures, if needed, don't mix up with surrogate pairs though!
if (unicode.length() > 1 && !U16_IS_SURROGATE(unicode[0]))
ligatures.append(unicode.string());
} else if (child->hasTagName(SVGNames::hkernTag)) {
SVGHKernElement* hkern = static_cast<SVGHKernElement*>(child);
hkern->buildHorizontalKerningPair(m_horizontalKerningPairs);
} else if (child->hasTagName(SVGNames::vkernTag)) {
SVGVKernElement* vkern = static_cast<SVGVKernElement*>(child);
vkern->buildVerticalKerningPair(m_verticalKerningPairs);
} else if (child->hasTagName(SVGNames::missing_glyphTag) && !firstMissingGlyphElement)
firstMissingGlyphElement = static_cast<SVGMissingGlyphElement*>(child);
}
// Register each character of each ligature, if needed.
if (!ligatures.isEmpty())
registerLigaturesInGlyphCache(ligatures);
// Register missing-glyph element, if present.
if (firstMissingGlyphElement) {
SVGGlyph svgGlyph = SVGGlyphElement::buildGenericGlyphIdentifier(firstMissingGlyphElement);
m_glyphMap.appendToGlyphTable(svgGlyph);
m_missingGlyph = svgGlyph.tableEntry;
ASSERT(m_missingGlyph > 0);
}
m_isGlyphCacheValid = true;
}
void SVGFontElement::ensureGlyphCache() const
{
if (m_isGlyphCacheValid)
return;
for (Node* child = firstChild(); child; child = child->nextSibling()) {
if (child->hasTagName(glyphTag)) {
SVGGlyphElement* glyph = static_cast<SVGGlyphElement*>(child);
String unicode = glyph->getAttribute(unicodeAttr);
if (unicode.length())
m_glyphMap.add(unicode, glyph->buildGlyphIdentifier());
} else if (child->hasTagName(hkernTag)) {
SVGHKernElement* hkern = static_cast<SVGHKernElement*>(child);
SVGHorizontalKerningPair kerningPair = hkern->buildHorizontalKerningPair();
m_kerningPairs.append(kerningPair);
}
}
m_isGlyphCacheValid = true;
}
void walk(const TextRun& run, bool isVerticalText, const String& language, int from, int to)
{
// Should hold true for SVG text, otherwhise sth. is wrong
ASSERT(to - from == run.length());
Vector<SVGGlyphIdentifier::ArabicForm> chars(charactersWithArabicForm(String(run.data(from), run.length()), run.rtl()));
SVGGlyphIdentifier identifier;
bool foundGlyph = false;
int characterLookupRange;
int endOfScanRange = to + m_walkerData.extraCharsAvailable;
bool haveAltGlyph = false;
SVGGlyphIdentifier altGlyphIdentifier;
if (RenderObject* renderObject = run.referencingRenderObject()) {
if (renderObject->element() && renderObject->element()->hasTagName(SVGNames::altGlyphTag)) {
SVGGlyphElement* glyphElement = static_cast<SVGAltGlyphElement*>(renderObject->element())->glyphElement();
if (glyphElement) {
haveAltGlyph = true;
altGlyphIdentifier = glyphElement->buildGlyphIdentifier();
altGlyphIdentifier.isValid = true;
altGlyphIdentifier.nameLength = to - from;
}
}
}
for (int i = from; i < to; ++i) {
// If characterLookupRange is > 0, then the font defined ligatures (length of unicode property value > 1).
// We have to check wheter the current character & the next character define a ligature. This needs to be
// extended to the n-th next character (where n is 'characterLookupRange'), to check for any possible ligature.
characterLookupRange = endOfScanRange - i;
String lookupString(run.data(i), characterLookupRange);
Vector<SVGGlyphIdentifier> glyphs;
if (haveAltGlyph)
glyphs.append(altGlyphIdentifier);
else
m_fontElement->getGlyphIdentifiersForString(lookupString, glyphs);
Vector<SVGGlyphIdentifier>::iterator it = glyphs.begin();
Vector<SVGGlyphIdentifier>::iterator end = glyphs.end();
for (; it != end; ++it) {
identifier = *it;
if (identifier.isValid && isCompatibleGlyph(identifier, isVerticalText, language, chars, i, i + identifier.nameLength)) {
ASSERT(characterLookupRange > 0);
i += identifier.nameLength - 1;
m_walkerData.charsConsumed += identifier.nameLength;
m_walkerData.glyphName = identifier.glyphName;
foundGlyph = true;
SVGGlyphElement::inheritUnspecifiedAttributes(identifier, m_fontData);
break;
}
}
if (!foundGlyph) {
++m_walkerData.charsConsumed;
if (SVGMissingGlyphElement* element = m_fontElement->firstMissingGlyphElement()) {
// <missing-glyph> element support
identifier = SVGGlyphElement::buildGenericGlyphIdentifier(element);
SVGGlyphElement::inheritUnspecifiedAttributes(identifier, m_fontData);
identifier.isValid = true;
} else {
// Fallback to system font fallback
TextRun subRun(run);
subRun.setText(subRun.data(i), 1);
(*m_walkerMissingGlyphCallback)(subRun, m_walkerData);
continue;
}
}
if (!(*m_walkerCallback)(identifier, m_walkerData))
break;
foundGlyph = false;
}
}
