libcore/Font.h

   1 // Font.h -- Font class, for Gnash
   2 //
   3 //   Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 Free Software
   4 //   Foundation, Inc
   5 //
   6 // This program is free software; you can redistribute it and/or modify
   7 // it under the terms of the GNU General Public License as published by
   8 // the Free Software Foundation; either version 3 of the License, or
   9 // (at your option) any later version.
  10 //
  11 // This program is distributed in the hope that it will be useful,
  12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 // GNU General Public License for more details.
  15 //
  16 // You should have received a copy of the GNU General Public License
  17 // along with this program; if not, write to the Free Software
  18 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  19 //
  20
  21 // Based on the public domain work of Thatcher Ulrich <tu@tulrich.com> 2003
  22
  23
  24 #ifndef GNASH_FONT_H
  25 #define GNASH_FONT_H
  26
  27 #include <string>
  28 #include <boost/scoped_ptr.hpp>
  29 #include <boost/shared_ptr.hpp>
  30 #include <boost/cstdint.hpp>
  31 #include <memory>
  32 #include <vector>
  33 #include <map>
  34
  35 #include "ref_counted.h"
  36
  37 namespace gnash {
  38     class FreetypeGlyphsProvider;
  39     namespace SWF {
  40         class ShapeRecord;
  41         class DefineFontTag;
  42     }
  43 }
  44
  45 namespace gnash {
  46
  47
  48
  49 // @@ replace this with a flat hash, or else a sorted array
  50 //    (binary search)
  51 class kerning_pair
  52 {
  53 public:
  54     boost::uint16_t m_char0;
  55     boost::uint16_t m_char1;
  56
  57     bool operator==(const kerning_pair& k) const
  58     {
  59         return m_char0 == k.m_char0 && m_char1 == k.m_char1;
  60     }
  61 };
  62
  63 // for use in standard algorithms
  64 inline bool
  65 operator< (const kerning_pair& p1, const kerning_pair& p2)
  66 {
  67     if (p1.m_char0 < p2.m_char0) return true;
  68     if (p1.m_char0 == p2.m_char0) {
  69         if (p1.m_char1 < p2.m_char1) return true;
  70     }
  71
  72     return false;
  73 }
  74
  75
  76 /// A Font resource.
  77 //
  78 /// All fonts used in the course of rendering a SWF are represented by this
  79 /// class. There are two types of Font object: device fonts and glyph fonts
  80 /// (also called embedded fonts). Device fonts contain no embedded glyphs,
  81 /// but glyph fonts may be rendered using device fonts if requested during
  82 /// runtime.
  83 //
  84 /// The fact that one Font object may represent an embedded and a device
  85 /// font simultaneously means that callers must themselves ensure they
  86 /// specify which font they require. Failure to do this consistently may mean
  87 /// callers end up with the wrong information about a font.
  88 //
  89 /// TODO: check whether it really needs to be ref_counted.
  90 class Font : public ref_counted
  91 {
  92 public:
  93
  94     // This table maps from Unicode DisplayObject number to glyph index.
  95     typedef std::map<boost::uint16_t, int> CodeTable;
  96
  97     Font(std::auto_ptr<SWF::DefineFontTag> ft);
  98
  99     /// Create a device-font only font, using the given name to find it
 100     //
 101     /// @param name
 102     ///    Name of the font face to look for.
 103     ///
 104     /// @param bold
 105     ///    Whether to use the bold variant of the font.
 106     ///
 107     /// @param italic
 108     ///    Whether to use the italic variant of the font.
 109     Font(const std::string& name, bool bold = false, bool italic = false);
 110
 111     ~Font();
 112
 113     boost::uint16_t codeTableLookup(int glyph, bool embedded) const;
 114
 115     /// Return true if this font matches given name and flags
 116     //
 117     /// @param name
 118     ///    Font name
 119     ///
 120     /// @param bold
 121     ///    Bold flag
 122     ///
 123     /// @param italic
 124     ///    Italic flag
 125     bool matches(const std::string& name, bool bold, bool italic) const;
 126
 127     /// Get glyph by index.
 128     //
 129     /// @param glyph_index
 130     ///   Index of the glyph. See get_glyph_index() to obtain by character code.
 131     ///
 132     /// @param embedded
 133     ///    If true, queries the 'embedded' glyphs table,
 134     ///    otherwise, looks in the 'device' font table.
 135     ///
 136     /// @return
 137     ///    The glyph outline, or NULL if out of range. (would be a
 138     /// programming error most likely). The ShapeRecord is owned by
 139     /// the Font class.
 140     SWF::ShapeRecord* get_glyph(int glyph_index, bool embedded) const;
 141
 142     /// Get name of this font.
 143     const std::string& name() const { return _name; }
 144
 145     /// Return the glyph index for a given character code
 146     //
 147     /// @param code
 148     ///    Character code to fetch the corresponding glyph index of.
 149     ///
 150     /// @param embedded
 151     ///    If true, queries the 'embedded' glyphs table,
 152     ///    otherwise, looks in the 'device' font table.
 153     ///
 154     /// Note, when querying device fonts, glyphs are created on demand,
 155     /// this never happens for embedded fonts, in which case an unexistent
 156     /// glyph results in a return of -1
 157     ///
 158     /// @return -1 if there is no glyph for the specified code or a valid
 159     ///         positive index to use in subsequent calls to other
 160     ///         glyph-index-based methods.
 161     ///
 162     int get_glyph_index(boost::uint16_t code, bool embedded) const;
 163
 164     /// Return the advance value for the given glyph index
 165     //
 166     /// Note: use unitsPerEM() to get the EM square.
 167     //
 168     /// @param glyph_index      Index of the glyph. See get_glyph_index()
 169     ///                         to obtain by character code.
 170     ///
 171     /// @param embedded         If true, queries the 'embedded' glyphs table,
 172     ///                         otherwise, looks in the 'device' font table.
 173     float get_advance(int glyph_index, bool embedded) const;
 174
 175     /// Return the adjustment in advance between the given two
 176     /// DisplayObjects (makes sense for embedded glyphs only)
 177     //
 178     /// Normally this will be 0
 179     ///
 180     /// NOTE: don't call this method when willing to work with device
 181     ///       fonts, or you'll end up mixing information from device fonts
 182     ///      with information from embedded fonts.
 183     ///
 184     float get_kerning_adjustment(int last_code, int this_code) const;
 185
 186     /// Return height of the EM square used for glyphs definition
 187     //
 188     /// @param embedded     If true, return is based on the SWF tag the font
 189     ///                     was read from, otherwise will query the
 190     ///                     FreeTypeGlyphsProvider
 191     size_t unitsPerEM(bool embedded) const;
 192
 193     /// Return the ascent value of the font.
 194     //
 195     /// Note: use unitsPerEM() to get the EM square.
 196     float ascent(bool embedded) const;
 197
 198     /// Return the descent value of the font in EM units.
 199     //
 200     /// Note: use unitsPerEM() to get the EM square.
 201     float descent(bool embedded) const;
 202
 203     /// Return the leading value of the font.
 204     //
 205     /// Note: use unitsPerEM() to get the EM square.
 206     float leading() const;
 207
 208     /// Return true if the font is bold.
 209     bool isBold() const {
 210         return _bold;
 211     }
 212
 213     /// Return true if the font is italic.
 214     bool isItalic() const {
 215         return _italic;
 216     }
 217
 218     /// A pair of strings describing the font.
 219     //
 220     /// Used by the DefineFontName tag, usefulness unclear.
 221     struct FontNameInfo
 222     {
 223         std::string displayName;
 224         std::string copyrightName;
 225     };
 226
 227     /// Glyph info structure
 228     struct GlyphInfo
 229     {
 230         // no glyph, default textured glyph, 0 advance
 231         GlyphInfo();
 232
 233         /// Construct default textured glyph
 234         //
 235         /// Takes ownership of the SWF::ShapeRecord.
 236         GlyphInfo(std::auto_ptr<SWF::ShapeRecord> glyph, float advance);
 237
 238         GlyphInfo(const GlyphInfo& o);
 239
 240         boost::shared_ptr<SWF::ShapeRecord> glyph;
 241
 242         float advance;
 243     };
 244
 245     typedef std::vector<GlyphInfo> GlyphInfoRecords;
 246
 247     /// Add display name and copyright name for an embedded font.
 248     //
 249     /// It's a string copy, but a decent standard library implementation
 250     /// should be able to avoid actually copying. Since it's only two
 251     /// strings, it doesn't seem worth the effort to avoid the copy.
 252     void addFontNameInfo(const FontNameInfo& fontName);
 253
 254     /// Set the name of the font.
 255     //
 256     /// This is used by SWF::DefineFontInfoTag
 257     void setName(const std::string& name);
 258
 259     /// Set the language and encoding flags of the font.
 260     //
 261     /// This is used by SWF::DefineFontInfoTag
 262     void setFlags(boost::uint8_t flags);
 263
 264     /// Add a CodeTable to the font.
 265     //
 266     /// This is used by SWF::DefineFontInfoTag
 267     void setCodeTable(std::auto_ptr<CodeTable> table);
 268
 269     /// Retrieve the number of embedded glyphs in this font.
 270     GlyphInfoRecords::size_type glyphCount() const;
 271
 272     /// Retrieve the FreetypeGlyphsProvider, initializing it if necessary.
 273     //
 274     /// Always use this method rather than directly accessing the _ftProvider
 275     /// member to ensure that the provider is initialized. May return null.
 276     FreetypeGlyphsProvider* ftProvider() const;
 277
 278 private:
 279
 280     /// Add a glyph from the os font into the device glyphs table
 281     //
 282     /// It is assumed that the glyph tables do NOT contain
 283     /// an entry for the given code.
 284     /// Initializes the rasterizer if not already done so.
 285     ///
 286     /// @return index of the newly added glyph, or -1 on error.
 287     ///
 288     int add_os_glyph(boost::uint16_t code);
 289
 290     /// If we were constructed from a definition, this is not NULL.
 291     boost::scoped_ptr<SWF::DefineFontTag> _fontTag;
 292
 293     // Device glyphs
 294     GlyphInfoRecords _deviceGlyphTable;
 295
 296     std::string    _name;
 297     std::string _displayName;
 298     std::string _copyrightName;
 299
 300     bool _unicodeChars;
 301     bool _shiftJISChars;
 302     bool _ansiChars;
 303     bool _italic;
 304     bool _bold;
 305
 306     /// Code to index table for embedded glyphs
 307     //
 308     /// This can be NULL if an embedded font should not be
 309     /// substituted by a device font. This can arise with
 310     /// a) a DefineFont tag without a corresponding DefineFontInfo
 311     ///    or DefineFontInfo2, or
 312     /// b) a DefineFont2 or DefineFont3 tag with no CodeTable.
 313     ///
 314     /// It is a shared_ptr to avoid changing an original
 315     /// DefineFont2Tag, while allowing this class to take ownership
 316     /// of CodeTables from a DefineFontInfo tag.
 317     boost::shared_ptr<const CodeTable> _embeddedCodeTable;
 318
 319     /// Code to index table for device glyphs
 320     CodeTable _deviceCodeTable;
 321
 322     typedef std::map<kerning_pair, float> kernings_table;
 323     kernings_table m_kerning_pairs;
 324
 325     mutable std::auto_ptr<FreetypeGlyphsProvider> _ftProvider;
 326
 327 };
 328
 329
 330 }    // end namespace gnash
 331
 332
 333
 334 #endif // GNASH_FONT_H
 335
 336 // Local Variables:
 337 // mode: C++
 338 // c-basic-offset: 8
 339 // tab-width: 8
 340 // indent-tabs-mode: t
 341 // End: