src/fontcache.h

   1 /* $Id: fontcache.h 26170 2013-12-22 17:46:27Z rubidium $ */
   2
   3 /*
   4  * This file is part of OpenTTD.
   5  * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
   6  * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   7  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
   8  */
   9
  10 /** @file fontcache.h Functions to read fonts from files and cache them. */
  11
  12 #ifndef FONTCACHE_H
  13 #define FONTCACHE_H
  14
  15 #include "string_type.h"
  16 #include "spritecache.h"
  17
  18 /** Glyphs are characters from a font. */
  19 typedef uint32 GlyphID;
  20 static const GlyphID SPRITE_GLYPH = 1U << 30;
  21
  22 extern int font_height_cache[FS_END]; ///< Cache of font heights
  23
  24 void UpdateFontHeightCache();
  25
  26 /** Font cache for basic fonts. */
  27 class FontCache {
  28 private:
  29         static FontCache *caches[FS_END]; ///< All the font caches.
  30 protected:
  31         FontCache *parent;                ///< The parent of this font cache.
  32         const FontSize fs;                ///< The size of the font.
  33         int height;                       ///< The height of the font.
  34         int ascender;                     ///< The ascender value of the font.
  35         int descender;                    ///< The descender value of the font.
  36         int units_per_em;                 ///< The units per EM value of the font.
  37 public:
  38         FontCache(FontSize fs);
  39         virtual ~FontCache();
  40
  41         /**
  42          * Get the FontSize of the font.
  43          * @return The FontSize.
  44          */
  45         inline FontSize GetSize() const { return this->fs; }
  46
  47         /**
  48          * Get the height of the font.
  49          * @return The height of the font.
  50          */
  51         virtual int GetHeight() const { return this->height; }
  52
  53         /**
  54          * Get the ascender value of the font.
  55          * @return The ascender value of the font.
  56          */
  57         inline int GetAscender() const { return this->ascender; }
  58
  59         /**
  60          * Get the descender value of the font.
  61          * @return The descender value of the font.
  62          */
  63         inline int GetDescender() const{ return this->descender; }
  64
  65         /**
  66          * Get the units per EM value of the font.
  67          * @return The units per EM value of the font.
  68          */
  69         inline int GetUnitsPerEM() const { return this->units_per_em; }
  70
  71         /**
  72          * Get the SpriteID mapped to the given key
  73          * @param key The key to get the sprite for.
  74          * @return The sprite.
  75          */
  76         virtual SpriteID GetUnicodeGlyph(WChar key) = 0;
  77
  78         /**
  79          * Map a SpriteID to the key
  80          * @param key The key to map to.
  81          * @param sprite The sprite that is being mapped.
  82          */
  83         virtual void SetUnicodeGlyph(WChar key, SpriteID sprite) = 0;
  84
  85         /** Initialize the glyph map */
  86         virtual void InitializeUnicodeGlyphMap() = 0;
  87
  88         /** Clear the font cache. */
  89         virtual void ClearFontCache() = 0;
  90
  91         /**
  92          * Get the glyph (sprite) of the given key.
  93          * @param key The key to look up.
  94          * @return The sprite.
  95          */
  96         virtual const Sprite *GetGlyph(GlyphID key) = 0;
  97
  98         /**
  99          * Get the width of the glyph with the given key.
 100          * @param key The key to look up.
 101          * @return The width.
 102          */
 103         virtual uint GetGlyphWidth(GlyphID key) = 0;
 104
 105         /**
 106          * Do we need to draw a glyph shadow?
 107          * @return True if it has to be done, otherwise false.
 108          */
 109         virtual bool GetDrawGlyphShadow() = 0;
 110
 111         /**
 112          * Map a character into a glyph.
 113          * @param key The character.
 114          * @return The glyph ID used to draw the character.
 115          */
 116         virtual GlyphID MapCharToGlyph(WChar key) = 0;
 117
 118         /**
 119          * Read a font table from the font.
 120          * @param tag The of the table to load.
 121          * @param length The length of the read data.
 122          * @return The loaded table data.
 123          */
 124         virtual const void *GetFontTable(uint32 tag, size_t &length) = 0;
 125
 126         /**
 127          * Get the name of this font.
 128          * @return The name of the font.
 129          */
 130         virtual const char *GetFontName() = 0;
 131
 132         /**
 133          * Get the font cache of a given font size.
 134          * @param fs The font size to look up.
 135          * @return The font cache.
 136          */
 137         static inline FontCache *Get(FontSize fs)
 138         {
 139                 assert(fs < FS_END);
 140                 return FontCache::caches[fs];
 141         }
 142
 143         /**
 144          * Check whether the font cache has a parent.
 145          */
 146         inline bool HasParent()
 147         {
 148                 return this->parent != nullptr;
 149         }
 150 };
 151
 152 /** Get the SpriteID mapped to the given font size and key */
 153 static inline SpriteID GetUnicodeGlyph(FontSize size, WChar key)
 154 {
 155         return FontCache::Get(size)->GetUnicodeGlyph(key);
 156 }
 157
 158 /** Map a SpriteID to the font size and key */
 159 static inline void SetUnicodeGlyph(FontSize size, WChar key, SpriteID sprite)
 160 {
 161         FontCache::Get(size)->SetUnicodeGlyph(key, sprite);
 162 }
 163
 164 /** Initialize the glyph map */
 165 static inline void InitializeUnicodeGlyphMap()
 166 {
 167         for (FontSize fs = FS_BEGIN; fs < FS_END; fs++) {
 168                 FontCache::Get(fs)->InitializeUnicodeGlyphMap();
 169         }
 170 }
 171
 172 static inline void ClearFontCache()
 173 {
 174         for (FontSize fs = FS_BEGIN; fs < FS_END; fs++) {
 175                 FontCache::Get(fs)->ClearFontCache();
 176         }
 177 }
 178
 179 /** Get the Sprite for a glyph */
 180 static inline const Sprite *GetGlyph(FontSize size, WChar key)
 181 {
 182         FontCache *fc = FontCache::Get(size);
 183         return fc->GetGlyph(fc->MapCharToGlyph(key));
 184 }
 185
 186 /** Get the width of a glyph */
 187 static inline uint GetGlyphWidth(FontSize size, WChar key)
 188 {
 189         FontCache *fc = FontCache::Get(size);
 190         return fc->GetGlyphWidth(fc->MapCharToGlyph(key));
 191 }
 192
 193 static inline bool GetDrawGlyphShadow(FontSize size)
 194 {
 195         return FontCache::Get(size)->GetDrawGlyphShadow();
 196 }
 197
 198 #ifdef WITH_FREETYPE
 199
 200 /** Settings for a single freetype font. */
 201 struct FreeTypeSubSetting {
 202         char font[MAX_PATH]; ///< The name of the font, or path to the font.
 203         uint size;           ///< The (requested) size of the font.
 204         bool aa;             ///< Whether to do anti aliasing or not.
 205 };
 206
 207 /** Settings for the freetype fonts. */
 208 struct FreeTypeSettings {
 209         FreeTypeSubSetting small;  ///< The smallest font; mostly used for zoomed out view.
 210         FreeTypeSubSetting medium; ///< The normal font size.
 211         FreeTypeSubSetting large;  ///< The largest font; mostly used for newspapers.
 212         FreeTypeSubSetting mono;   ///< The mono space font used for license/readme viewers.
 213 };
 214
 215 extern FreeTypeSettings _freetype;
 216
 217 #endif /* WITH_FREETYPE */
 218
 219 void InitFreeType(bool monospace);
 220 void UninitFreeType();
 221
 222 #endif /* FONTCACHE_H */