src/third_party/WebKit/Source/core/svg/SVGGlyphMap.h

   1 /*
   2  * Copyright (C) 2008 Apple Inc. All rights reserved.
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Library General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Library General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Library General Public License
  15  * along with this library; see the file COPYING.LIB.  If not, write to
  16  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  17  * Boston, MA 02110-1301, USA.
  18  */
  19
  20 #ifndef SVGGlyphMap_h
  21 #define SVGGlyphMap_h
  22
  23 #if ENABLE(SVG_FONTS)
  24 #include "core/svg/SVGParserUtilities.h"
  25 #include "platform/fonts/Latin1TextIterator.h"
  26 #include "platform/fonts/SVGGlyph.h"
  27 #include "platform/text/SurrogatePairAwareTextIterator.h"
  28 #include "wtf/HashMap.h"
  29 #include "wtf/Vector.h"
  30
  31 namespace blink {
  32
  33 struct GlyphMapNode;
  34
  35 typedef HashMap<UChar32, RefPtr<GlyphMapNode> > GlyphMapLayer;
  36
  37 struct GlyphMapNode : public RefCounted<GlyphMapNode> {
  38 private:
  39     GlyphMapNode() { }
  40 public:
  41     static PassRefPtr<GlyphMapNode> create() { return adoptRef(new GlyphMapNode); }
  42
  43     Vector<SVGGlyph> glyphs;
  44
  45     GlyphMapLayer children;
  46 };
  47
  48 class SVGGlyphMap {
  49 public:
  50     SVGGlyphMap() : m_currentPriority(0) { }
  51
  52     void addGlyph(const String& glyphIdentifier, const String& unicodeString, SVGGlyph glyph)
  53     {
  54         ASSERT(!glyphIdentifier.isEmpty() || !unicodeString.isEmpty());
  55
  56         bool hasGlyphIdentifier = !glyphIdentifier.isEmpty();
  57         if (unicodeString.isEmpty()) {
  58             // Register glyphs with 'id's in the id glyph map and in the glyph table.
  59             ASSERT(hasGlyphIdentifier);
  60             appendToGlyphTable(glyph);
  61             m_idGlyphs.add(glyphIdentifier, glyph.tableEntry);
  62             return;
  63         }
  64
  65         unsigned length = unicodeString.length();
  66
  67         RefPtr<GlyphMapNode> node;
  68         if (unicodeString.is8Bit()) {
  69             Latin1TextIterator textIterator(unicodeString.characters8(), 0, length, length);
  70             node = findOrCreateNode(textIterator);
  71         } else {
  72             SurrogatePairAwareTextIterator textIterator(unicodeString.characters16(), 0, length, length);
  73             node = findOrCreateNode(textIterator);
  74         }
  75         if (!node)
  76             return;
  77
  78         // Register glyph associated with an unicode string into the glyph map.
  79         node->glyphs.append(glyph);
  80         SVGGlyph& lastGlyph = node->glyphs.last();
  81         lastGlyph.priority = m_currentPriority++;
  82         lastGlyph.unicodeStringLength = length;
  83
  84         // If the glyph is named, also add it to the named glyph name, and to the glyph table in both cases.
  85         appendToGlyphTable(lastGlyph);
  86         if (!lastGlyph.glyphName.isEmpty())
  87             m_namedGlyphs.add(lastGlyph.glyphName, lastGlyph.tableEntry);
  88         if (hasGlyphIdentifier)
  89             m_idGlyphs.add(glyphIdentifier, lastGlyph.tableEntry);
  90     }
  91
  92     void appendToGlyphTable(SVGGlyph& glyph)
  93     {
  94         size_t tableEntry = m_glyphTable.size();
  95         ASSERT(tableEntry < std::numeric_limits<unsigned short>::max());
  96
  97         // The first table entry starts with 1. 0 denotes an unknown glyph.
  98         glyph.tableEntry = tableEntry + 1;
  99         m_glyphTable.append(glyph);
 100     }
 101
 102     static inline bool compareGlyphPriority(const SVGGlyph& first, const SVGGlyph& second)
 103     {
 104         return first.priority < second.priority;
 105     }
 106
 107     void collectGlyphsForString(const String& string, Vector<SVGGlyph>& glyphs)
 108     {
 109         unsigned length = string.length();
 110
 111         if (!length)
 112             return;
 113
 114         if (string.is8Bit()) {
 115             Latin1TextIterator textIterator(string.characters8(), 0, length, length);
 116             collectGlyphsForIterator(textIterator, glyphs);
 117         } else {
 118             SurrogatePairAwareTextIterator textIterator(string.characters16(), 0, length, length);
 119             collectGlyphsForIterator(textIterator, glyphs);
 120         }
 121
 122         std::sort(glyphs.begin(), glyphs.end(), compareGlyphPriority);
 123     }
 124
 125     void collectGlyphsForStringExact(const String& string, Vector<SVGGlyph>& glyphs) const
 126     {
 127         unsigned length = string.length();
 128
 129         if (!length)
 130             return;
 131
 132         RefPtr<GlyphMapNode> node;
 133         if (string.is8Bit()) {
 134             Latin1TextIterator textIterator(string.characters8(), 0, length, length);
 135             node = findNode(textIterator);
 136         } else {
 137             SurrogatePairAwareTextIterator textIterator(string.characters16(), 0, length, length);
 138             node = findNode(textIterator);
 139         }
 140
 141         if (node)
 142             glyphs.appendVector(node->glyphs);
 143     }
 144
 145     void collectGlyphsForUnicodeRange(const UnicodeRange& unicodeRange, Vector<SVGGlyph>& glyphs) const
 146     {
 147         for (unsigned character = unicodeRange.first; character <= unicodeRange.second; ++character) {
 148             if (RefPtr<GlyphMapNode> node = m_rootLayer.get(character))
 149                 glyphs.appendVector(node->glyphs);
 150         }
 151     }
 152
 153     void clear()
 154     {
 155         m_rootLayer.clear();
 156         m_glyphTable.clear();
 157         m_idGlyphs.clear();
 158         m_namedGlyphs.clear();
 159         m_currentPriority = 0;
 160     }
 161
 162     void dropNamedGlyphMap()
 163     {
 164         m_namedGlyphs.clear();
 165     }
 166
 167     const SVGGlyph& svgGlyphForGlyph(Glyph glyph) const
 168     {
 169         if (!glyph || glyph > m_glyphTable.size()) {
 170             DEFINE_STATIC_LOCAL(SVGGlyph, defaultGlyph, ());
 171             return defaultGlyph;
 172         }
 173         return m_glyphTable[glyph - 1];
 174     }
 175
 176     const SVGGlyph& glyphIdentifierForAltGlyphReference(const String& glyphIdentifier) const
 177     {
 178         return svgGlyphForGlyph(m_idGlyphs.get(glyphIdentifier));
 179     }
 180
 181     const SVGGlyph& glyphIdentifierForGlyphName(const String& glyphName) const
 182     {
 183         return svgGlyphForGlyph(m_namedGlyphs.get(glyphName));
 184     }
 185
 186 private:
 187     template<typename Iterator>
 188     PassRefPtr<GlyphMapNode> findOrCreateNode(Iterator& textIterator)
 189     {
 190         GlyphMapLayer* currentLayer = &m_rootLayer;
 191
 192         RefPtr<GlyphMapNode> node;
 193         UChar32 character = 0;
 194         unsigned clusterLength = 0;
 195         while (textIterator.consume(character, clusterLength)) {
 196             node = currentLayer->get(character);
 197             if (!node) {
 198                 node = GlyphMapNode::create();
 199                 currentLayer->set(character, node);
 200             }
 201             currentLayer = &node->children;
 202             textIterator.advance(clusterLength);
 203         }
 204
 205         return node.release();
 206     }
 207
 208     template<typename Iterator>
 209     PassRefPtr<GlyphMapNode> findNode(Iterator& textIterator) const
 210     {
 211         const GlyphMapLayer* currentLayer = &m_rootLayer;
 212
 213         RefPtr<GlyphMapNode> node;
 214         UChar32 character = 0;
 215         unsigned clusterLength = 0;
 216         while (textIterator.consume(character, clusterLength)) {
 217             node = currentLayer->get(character);
 218             if (!node)
 219                 break;
 220             currentLayer = &node->children;
 221             textIterator.advance(clusterLength);
 222         }
 223
 224         return node.release();
 225     }
 226
 227     template<typename Iterator>
 228     void collectGlyphsForIterator(Iterator& textIterator, Vector<SVGGlyph>& glyphs)
 229     {
 230         GlyphMapLayer* currentLayer = &m_rootLayer;
 231
 232         UChar32 character = 0;
 233         unsigned clusterLength = 0;
 234         while (textIterator.consume(character, clusterLength)) {
 235             RefPtr<GlyphMapNode> node = currentLayer->get(character);
 236             if (!node)
 237                 break;
 238             glyphs.appendVector(node->glyphs);
 239             currentLayer = &node->children;
 240             textIterator.advance(clusterLength);
 241         }
 242     }
 243
 244     GlyphMapLayer m_rootLayer;
 245     Vector<SVGGlyph> m_glyphTable;
 246     HashMap<String, Glyph> m_namedGlyphs;
 247     HashMap<String, Glyph> m_idGlyphs;
 248     int m_currentPriority;
 249 };
 250
 251 }
 252
 253 #endif // ENABLE(SVG_FONTS)
 254 #endif // SVGGlyphMap_h