src/fontcache.h

   1 /*
   2  * This file is part of OpenTTD.
   3  * 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.
   4  * 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.
   5  * 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/>.
   6  */
   7
   8 /** @file fontcache.h Functions to read fonts from files and cache them. */
   9
  10 #ifndef FONTCACHE_H
  11 #define FONTCACHE_H
  12
  13 #include "string_type.h"
  14 #include "spritecache.h"
  15
  16 /** Glyphs are characters from a font. */
  17 typedef uint32_t GlyphID;
  18 static const GlyphID SPRITE_GLYPH = 1U << 30;
  19
  20 /** Font cache for basic fonts. */
  21 class FontCache {
  22 protected:
  23         static FontCache *caches[FS_END]; ///< All the font caches.
  24         FontCache *parent;                ///< The parent of this font cache.
  25         const FontSize fs;                ///< The size of the font.
  26         int height;                       ///< The height of the font.
  27         int ascender;                     ///< The ascender value of the font.
  28         int descender;                    ///< The descender value of the font.
  29
  30 public:
  31         FontCache(FontSize fs);
  32         virtual ~FontCache();
  33
  34         static void InitializeFontCaches();
  35
  36         static int GetDefaultFontHeight(FontSize fs);
  37
  38         /**
  39          * Get the FontSize of the font.
  40          * @return The FontSize.
  41          */
  42         inline FontSize GetSize() const { return this->fs; }
  43
  44         /**
  45          * Get the height of the font.
  46          * @return The height of the font.
  47          */
  48         inline int GetHeight() const { return this->height; }
  49
  50         /**
  51          * Get the ascender value of the font.
  52          * @return The ascender value of the font.
  53          */
  54         inline int GetAscender() const { return this->ascender; }
  55
  56         /**
  57          * Get the descender value of the font.
  58          * @return The descender value of the font.
  59          */
  60         inline int GetDescender() const{ return this->descender; }
  61
  62         /**
  63          * Get the nominal font size of the font.
  64          * @return The nominal font size.
  65          */
  66         virtual int GetFontSize() const { return this->height; }
  67
  68         /**
  69          * Map a SpriteID to the key
  70          * @param key The key to map to.
  71          * @param sprite The sprite that is being mapped.
  72          */
  73         virtual void SetUnicodeGlyph(char32_t key, SpriteID sprite) = 0;
  74
  75         /** Initialize the glyph map */
  76         virtual void InitializeUnicodeGlyphMap() = 0;
  77
  78         /** Clear the font cache. */
  79         virtual void ClearFontCache() = 0;
  80
  81         /**
  82          * Get the glyph (sprite) of the given key.
  83          * @param key The key to look up.
  84          * @return The sprite.
  85          */
  86         virtual const Sprite *GetGlyph(GlyphID key) = 0;
  87
  88         /**
  89          * Get the width of the glyph with the given key.
  90          * @param key The key to look up.
  91          * @return The width.
  92          */
  93         virtual uint GetGlyphWidth(GlyphID key) = 0;
  94
  95         /**
  96          * Do we need to draw a glyph shadow?
  97          * @return True if it has to be done, otherwise false.
  98          */
  99         virtual bool GetDrawGlyphShadow() = 0;
 100
 101         /**
 102          * Map a character into a glyph.
 103          * @param key The character.
 104          * @param fallback Allow fallback to the parent font.
 105          * @return The glyph ID used to draw the character.
 106          */
 107         virtual GlyphID MapCharToGlyph(char32_t key, bool fallback = true) = 0;
 108
 109         /**
 110          * Get the native OS font handle, if there is one.
 111          * @return Opaque OS font handle.
 112          */
 113         virtual const void *GetOSHandle()
 114         {
 115                 return nullptr;
 116         }
 117
 118         /**
 119          * Get the name of this font.
 120          * @return The name of the font.
 121          */
 122         virtual std::string GetFontName() = 0;
 123
 124         /**
 125          * Get the font cache of a given font size.
 126          * @param fs The font size to look up.
 127          * @return The font cache.
 128          */
 129         static inline FontCache *Get(FontSize fs)
 130         {
 131                 assert(fs < FS_END);
 132                 return FontCache::caches[fs];
 133         }
 134
 135         static std::string GetName(FontSize fs);
 136
 137         /**
 138          * Check whether the font cache has a parent.
 139          */
 140         inline bool HasParent()
 141         {
 142                 return this->parent != nullptr;
 143         }
 144
 145         /**
 146          * Is this a built-in sprite font?
 147          */
 148         virtual bool IsBuiltInFont() = 0;
 149 };
 150
 151 /** Map a SpriteID to the font size and key */
 152 inline void SetUnicodeGlyph(FontSize size, char32_t key, SpriteID sprite)
 153 {
 154         FontCache::Get(size)->SetUnicodeGlyph(key, sprite);
 155 }
 156
 157 /** Initialize the glyph map */
 158 inline void InitializeUnicodeGlyphMap()
 159 {
 160         for (FontSize fs = FS_BEGIN; fs < FS_END; fs++) {
 161                 FontCache::Get(fs)->InitializeUnicodeGlyphMap();
 162         }
 163 }
 164
 165 inline void ClearFontCache()
 166 {
 167         for (FontSize fs = FS_BEGIN; fs < FS_END; fs++) {
 168                 FontCache::Get(fs)->ClearFontCache();
 169         }
 170 }
 171
 172 /** Get the Sprite for a glyph */
 173 inline const Sprite *GetGlyph(FontSize size, char32_t key)
 174 {
 175         FontCache *fc = FontCache::Get(size);
 176         return fc->GetGlyph(fc->MapCharToGlyph(key));
 177 }
 178
 179 /** Get the width of a glyph */
 180 inline uint GetGlyphWidth(FontSize size, char32_t key)
 181 {
 182         FontCache *fc = FontCache::Get(size);
 183         return fc->GetGlyphWidth(fc->MapCharToGlyph(key));
 184 }
 185
 186 inline bool GetDrawGlyphShadow(FontSize size)
 187 {
 188         return FontCache::Get(size)->GetDrawGlyphShadow();
 189 }
 190
 191 /** Settings for a single font. */
 192 struct FontCacheSubSetting {
 193         std::string font; ///< The name of the font, or path to the font.
 194         uint size;        ///< The (requested) size of the font.
 195
 196         const void *os_handle = nullptr; ///< Optional native OS font info. Only valid during font search.
 197 };
 198
 199 /** Settings for the four different fonts. */
 200 struct FontCacheSettings {
 201         FontCacheSubSetting small;  ///< The smallest font; mostly used for zoomed out view.
 202         FontCacheSubSetting medium; ///< The normal font size.
 203         FontCacheSubSetting large;  ///< The largest font; mostly used for newspapers.
 204         FontCacheSubSetting mono;   ///< The mono space font used for license/readme viewers.
 205         bool prefer_sprite;         ///< Whether to prefer the built-in sprite font over resizable fonts.
 206         bool global_aa;             ///< Whether to anti alias all font sizes.
 207 };
 208
 209 extern FontCacheSettings _fcsettings;
 210
 211 /**
 212  * Get the settings of a given font size.
 213  * @param fs The font size to look up.
 214  * @return The settings.
 215  */
 216 inline FontCacheSubSetting *GetFontCacheSubSetting(FontSize fs)
 217 {
 218         switch (fs) {
 219                 default: NOT_REACHED();
 220                 case FS_SMALL:  return &_fcsettings.small;
 221                 case FS_NORMAL: return &_fcsettings.medium;
 222                 case FS_LARGE:  return &_fcsettings.large;
 223                 case FS_MONO:   return &_fcsettings.mono;
 224         }
 225 }
 226
 227 uint GetFontCacheFontSize(FontSize fs);
 228 std::string GetFontCacheFontName(FontSize fs);
 229 void InitFontCache(bool monospace);
 230 void UninitFontCache();
 231
 232 bool GetFontAAState();
 233 void SetFont(FontSize fontsize, const std::string &font, uint size);
 234
 235 #endif /* FONTCACHE_H */