This source file includes following definitions.
- m_isGlyphCacheValid
- create
- invalidateGlyphCache
- firstMissingGlyphElement
- registerLigaturesInGlyphCache
- makeKerningPairKey
- buildGlyphList
- addPairsToKerningTable
- buildKerningTable
- ensureGlyphCache
- kerningForPairOfGlyphs
- horizontalKerningForPairOfGlyphs
- verticalKerningForPairOfGlyphs
- collectGlyphsForString
- collectGlyphsForAltGlyphReference
- svgGlyphForGlyph
- missingGlyph
#include "config.h"
#if ENABLE(SVG_FONTS)
#include "core/svg/SVGFontElement.h"
#include "core/dom/ElementTraversal.h"
#include "core/frame/UseCounter.h"
#include "core/svg/SVGGlyphElement.h"
#include "core/svg/SVGHKernElement.h"
#include "core/svg/SVGMissingGlyphElement.h"
#include "core/svg/SVGVKernElement.h"
#include "wtf/ASCIICType.h"
namespace WebCore {
inline SVGFontElement::SVGFontElement(Document& document)
: SVGElement(SVGNames::fontTag, document)
, m_missingGlyph(0)
, m_isGlyphCacheValid(false)
{
ScriptWrappable::init(this);
UseCounter::count(document, UseCounter::SVGFontElement);
}
PassRefPtr<SVGFontElement> SVGFontElement::create(Document& document)
{
return adoptRef(new SVGFontElement(document));
}
void SVGFontElement::invalidateGlyphCache()
{
if (m_isGlyphCacheValid) {
m_glyphMap.clear();
m_horizontalKerningTable.clear();
m_verticalKerningTable.clear();
}
m_isGlyphCacheValid = false;
}
SVGMissingGlyphElement* SVGFontElement::firstMissingGlyphElement() const
{
return Traversal<SVGMissingGlyphElement>::firstChild(*this);
}
void SVGFontElement::registerLigaturesInGlyphCache(Vector<String>& ligatures)
{
ASSERT(!ligatures.isEmpty());
Vector<SVGGlyph> glyphs;
size_t ligaturesSize = ligatures.size();
for (size_t i = 0; i < ligaturesSize; ++i) {
const String& unicode = ligatures[i];
unsigned unicodeLength = unicode.length();
ASSERT(unicodeLength > 1);
for (unsigned i = 0; i < unicodeLength; ++i) {
String lookupString = unicode.substring(i, 1);
m_glyphMap.collectGlyphsForString(lookupString, glyphs);
if (!glyphs.isEmpty()) {
glyphs.clear();
continue;
}
SVGGlyph newGlyphPart;
newGlyphPart.isPartOfLigature = true;
m_glyphMap.addGlyph(String(), lookupString, newGlyphPart);
}
}
}
static inline KerningPairKey makeKerningPairKey(Glyph glyphId1, Glyph glyphId2)
{
return glyphId1 << 16 | glyphId2;
}
Vector<SVGGlyph> SVGFontElement::buildGlyphList(const UnicodeRanges& unicodeRanges, const HashSet<String>& unicodeNames, const HashSet<String>& glyphNames) const
{
Vector<SVGGlyph> glyphs;
if (!unicodeRanges.isEmpty()) {
const UnicodeRanges::const_iterator end = unicodeRanges.end();
for (UnicodeRanges::const_iterator it = unicodeRanges.begin(); it != end; ++it)
m_glyphMap.collectGlyphsForUnicodeRange(*it, glyphs);
}
if (!unicodeNames.isEmpty()) {
const HashSet<String>::const_iterator end = unicodeNames.end();
for (HashSet<String>::const_iterator it = unicodeNames.begin(); it != end; ++it)
m_glyphMap.collectGlyphsForStringExact(*it, glyphs);
}
if (!glyphNames.isEmpty()) {
const HashSet<String>::const_iterator end = glyphNames.end();
for (HashSet<String>::const_iterator it = glyphNames.begin(); it != end; ++it) {
const SVGGlyph& glyph = m_glyphMap.glyphIdentifierForGlyphName(*it);
if (glyph.tableEntry)
glyphs.append(glyph);
}
}
return glyphs;
}
void SVGFontElement::addPairsToKerningTable(const SVGKerningPair& kerningPair, KerningTable& kerningTable)
{
Vector<SVGGlyph> glyphsLhs = buildGlyphList(kerningPair.unicodeRange1, kerningPair.unicodeName1, kerningPair.glyphName1);
Vector<SVGGlyph> glyphsRhs = buildGlyphList(kerningPair.unicodeRange2, kerningPair.unicodeName2, kerningPair.glyphName2);
if (glyphsLhs.isEmpty() || glyphsRhs.isEmpty())
return;
size_t glyphsLhsSize = glyphsLhs.size();
size_t glyphsRhsSize = glyphsRhs.size();
for (size_t lhsIndex = 0; lhsIndex < glyphsLhsSize; ++lhsIndex) {
for (size_t rhsIndex = 0; rhsIndex < glyphsRhsSize; ++rhsIndex) {
Glyph glyph1 = glyphsLhs[lhsIndex].tableEntry;
Glyph glyph2 = glyphsRhs[rhsIndex].tableEntry;
ASSERT(glyph1 && glyph2);
kerningTable.add(makeKerningPairKey(glyph1, glyph2), kerningPair.kerning);
}
}
}
void SVGFontElement::buildKerningTable(const KerningPairVector& kerningPairs, KerningTable& kerningTable)
{
size_t kerningPairsSize = kerningPairs.size();
for (size_t i = 0; i < kerningPairsSize; ++i)
addPairsToKerningTable(kerningPairs[i], kerningTable);
}
void SVGFontElement::ensureGlyphCache()
{
if (m_isGlyphCacheValid)
return;
KerningPairVector horizontalKerningPairs;
KerningPairVector verticalKerningPairs;
SVGMissingGlyphElement* firstMissingGlyphElement = 0;
Vector<String> ligatures;
for (SVGElement* element = Traversal<SVGElement>::firstChild(*this); element; element = Traversal<SVGElement>::nextSibling(*element)) {
if (isSVGGlyphElement(*element)) {
SVGGlyphElement& glyph = toSVGGlyphElement(*element);
AtomicString unicode = glyph.fastGetAttribute(SVGNames::unicodeAttr);
AtomicString glyphId = glyph.getIdAttribute();
if (glyphId.isEmpty() && unicode.isEmpty())
continue;
m_glyphMap.addGlyph(glyphId, unicode, glyph.buildGlyphIdentifier());
if (unicode.length() > 1 && !U16_IS_SURROGATE(unicode[0]))
ligatures.append(unicode.string());
} else if (isSVGHKernElement(*element)) {
toSVGHKernElement(*element).buildHorizontalKerningPair(horizontalKerningPairs);
} else if (isSVGVKernElement(*element)) {
toSVGVKernElement(*element).buildVerticalKerningPair(verticalKerningPairs);
} else if (isSVGMissingGlyphElement(*element) && !firstMissingGlyphElement) {
firstMissingGlyphElement = toSVGMissingGlyphElement(element);
}
}
buildKerningTable(horizontalKerningPairs, m_horizontalKerningTable);
buildKerningTable(verticalKerningPairs, m_verticalKerningTable);
m_glyphMap.dropNamedGlyphMap();
if (!ligatures.isEmpty())
registerLigaturesInGlyphCache(ligatures);
if (firstMissingGlyphElement) {
SVGGlyph svgGlyph = SVGGlyphElement::buildGenericGlyphIdentifier(firstMissingGlyphElement);
m_glyphMap.appendToGlyphTable(svgGlyph);
m_missingGlyph = svgGlyph.tableEntry;
ASSERT(m_missingGlyph > 0);
}
m_isGlyphCacheValid = true;
}
static float kerningForPairOfGlyphs(const KerningTable& kerningTable, Glyph glyphId1, Glyph glyphId2)
{
KerningTable::const_iterator result = kerningTable.find(makeKerningPairKey(glyphId1, glyphId2));
if (result != kerningTable.end())
return result->value;
return 0;
}
float SVGFontElement::horizontalKerningForPairOfGlyphs(Glyph glyphId1, Glyph glyphId2) const
{
if (m_horizontalKerningTable.isEmpty())
return 0;
return kerningForPairOfGlyphs(m_horizontalKerningTable, glyphId1, glyphId2);
}
float SVGFontElement::verticalKerningForPairOfGlyphs(Glyph glyphId1, Glyph glyphId2) const
{
if (m_verticalKerningTable.isEmpty())
return 0;
return kerningForPairOfGlyphs(m_verticalKerningTable, glyphId1, glyphId2);
}
void SVGFontElement::collectGlyphsForString(const String& string, Vector<SVGGlyph>& glyphs)
{
ensureGlyphCache();
m_glyphMap.collectGlyphsForString(string, glyphs);
}
void SVGFontElement::collectGlyphsForAltGlyphReference(const String& glyphIdentifier, Vector<SVGGlyph>& glyphs)
{
ensureGlyphCache();
glyphs.append(m_glyphMap.glyphIdentifierForAltGlyphReference(glyphIdentifier));
}
SVGGlyph SVGFontElement::svgGlyphForGlyph(Glyph glyph)
{
ensureGlyphCache();
return m_glyphMap.svgGlyphForGlyph(glyph);
}
Glyph SVGFontElement::missingGlyph()
{
ensureGlyphCache();
return m_missingGlyph;
}
}
#endif