src/fontcache.cpp

   1 /* $Id: fontcache.cpp 26389 2014-03-03 21:34:36Z fonsinchen $ */
   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.cpp Cache for characters from fonts. */
  11
  12 #include "stdafx.h"
  13 #include "fontcache.h"
  14 #include "fontdetection.h"
  15 #include "blitter/factory.hpp"
  16 #include "core/math_func.hpp"
  17 #include "core/smallmap_type.hpp"
  18 #include "strings_func.h"
  19 #include "zoom_type.h"
  20 #include "gfx_layout.h"
  21 #include "zoom_func.h"
  22
  23 #include "table/sprites.h"
  24 #include "table/control_codes.h"
  25 #include "table/unicode.h"
  26
  27 #include "safeguards.h"
  28
  29 static const int ASCII_LETTERSTART = 32; ///< First printable ASCII letter.
  30 static const int MAX_FONT_SIZE     = 72; ///< Maximum font size.
  31
  32 /** Default heights for the different sizes of fonts. */
  33 static const int _default_font_height[FS_END]   = {10, 6, 18, 10};
  34 static const int _default_font_ascender[FS_END] = { 8, 5, 15,  8};
  35
  36 /**
  37  * Create a new font cache.
  38  * @param fs The size of the font.
  39  */
  40 FontCache::FontCache(FontSize fs) : parent(FontCache::Get(fs)), fs(fs), height(_default_font_height[fs]),
  41                 ascender(_default_font_ascender[fs]), descender(_default_font_ascender[fs] - _default_font_height[fs]),
  42                 units_per_em(1)
  43 {
  44         assert(this->parent == nullptr || this->fs == this->parent->fs);
  45         FontCache::caches[this->fs] = this;
  46         font_height_cache[this->fs] = this->height;
  47         Layouter::ResetFontCache(this->fs);
  48 }
  49
  50 /** Clean everything up. */
  51 FontCache::~FontCache()
  52 {
  53         assert(this->fs == this->parent->fs);
  54         FontCache::caches[this->fs] = this->parent;
  55         Layouter::ResetFontCache(this->fs);
  56 }
  57
  58
  59 /** Font cache for fonts that are based on a freetype font. */
  60 class SpriteFontCache : public FontCache {
  61 private:
  62         SpriteID **glyph_to_spriteid_map; ///< Mapping of glyphs to sprite IDs.
  63
  64         void ClearGlyphToSpriteMap();
  65 public:
  66         SpriteFontCache(FontSize fs);
  67         ~SpriteFontCache();
  68         virtual SpriteID GetUnicodeGlyph(WChar key);
  69         virtual void SetUnicodeGlyph(WChar key, SpriteID sprite);
  70         virtual void InitializeUnicodeGlyphMap();
  71         virtual void ClearFontCache();
  72         virtual const Sprite *GetGlyph(GlyphID key);
  73         virtual uint GetGlyphWidth(GlyphID key);
  74         virtual int GetHeight() const;
  75         virtual bool GetDrawGlyphShadow();
  76         virtual GlyphID MapCharToGlyph(WChar key) { assert(IsPrintable(key)); return SPRITE_GLYPH | key; }
  77         virtual const void *GetFontTable(uint32 tag, size_t &length) { length = 0; return nullptr; }
  78         virtual const char *GetFontName() { return "sprite"; }
  79 };
  80
  81 /**
  82  * Create a new sprite font cache.
  83  * @param fs The font size to create the cache for.
  84  */
  85 SpriteFontCache::SpriteFontCache(FontSize fs) : FontCache(fs), glyph_to_spriteid_map(nullptr)
  86 {
  87         this->InitializeUnicodeGlyphMap();
  88 }
  89
  90 /**
  91  * Free everything we allocated.
  92  */
  93 SpriteFontCache::~SpriteFontCache()
  94 {
  95         this->ClearGlyphToSpriteMap();
  96 }
  97
  98 SpriteID SpriteFontCache::GetUnicodeGlyph(GlyphID key)
  99 {
 100         if (this->glyph_to_spriteid_map[GB(key, 8, 8)] == nullptr) return 0;
 101         return this->glyph_to_spriteid_map[GB(key, 8, 8)][GB(key, 0, 8)];
 102 }
 103
 104 void SpriteFontCache::SetUnicodeGlyph(GlyphID key, SpriteID sprite)
 105 {
 106         if (this->glyph_to_spriteid_map == nullptr) this->glyph_to_spriteid_map = CallocT<SpriteID*>(256);
 107         if (this->glyph_to_spriteid_map[GB(key, 8, 8)] == nullptr) this->glyph_to_spriteid_map[GB(key, 8, 8)] = CallocT<SpriteID>(256);
 108         this->glyph_to_spriteid_map[GB(key, 8, 8)][GB(key, 0, 8)] = sprite;
 109 }
 110
 111 void SpriteFontCache::InitializeUnicodeGlyphMap()
 112 {
 113         /* Clear out existing glyph map if it exists */
 114         this->ClearGlyphToSpriteMap();
 115
 116         SpriteID base;
 117         switch (this->fs) {
 118                 default: NOT_REACHED();
 119                 case FS_MONO:   // Use normal as default for mono spaced font
 120                 case FS_NORMAL: base = SPR_ASCII_SPACE;       break;
 121                 case FS_SMALL:  base = SPR_ASCII_SPACE_SMALL; break;
 122                 case FS_LARGE:  base = SPR_ASCII_SPACE_BIG;   break;
 123         }
 124
 125         for (uint i = ASCII_LETTERSTART; i < 256; i++) {
 126                 SpriteID sprite = base + i - ASCII_LETTERSTART;
 127                 if (!SpriteExists(sprite)) continue;
 128                 this->SetUnicodeGlyph(i, sprite);
 129                 this->SetUnicodeGlyph(i + SCC_SPRITE_START, sprite);
 130         }
 131
 132         for (uint i = 0; i < lengthof(_default_unicode_map); i++) {
 133                 byte key = _default_unicode_map[i].key;
 134                 if (key == CLRA) {
 135                         /* Clear the glyph. This happens if the glyph at this code point
 136                          * is non-standard and should be accessed by an SCC_xxx enum
 137                          * entry only. */
 138                         this->SetUnicodeGlyph(_default_unicode_map[i].code, 0);
 139                 } else {
 140                         SpriteID sprite = base + key - ASCII_LETTERSTART;
 141                         this->SetUnicodeGlyph(_default_unicode_map[i].code, sprite);
 142                 }
 143         }
 144
 145         font_height_cache[this->fs] = this->GetHeight();
 146 }
 147
 148 /**
 149  * Clear the glyph to sprite mapping.
 150  */
 151 void SpriteFontCache::ClearGlyphToSpriteMap()
 152 {
 153         if (this->glyph_to_spriteid_map == nullptr) return;
 154
 155         for (uint i = 0; i < 256; i++) {
 156                 free(this->glyph_to_spriteid_map[i]);
 157         }
 158         free(this->glyph_to_spriteid_map);
 159         this->glyph_to_spriteid_map = nullptr;
 160 }
 161
 162 void SpriteFontCache::ClearFontCache()
 163 {
 164         Layouter::ResetFontCache(this->fs);
 165 }
 166
 167 const Sprite *SpriteFontCache::GetGlyph(GlyphID key)
 168 {
 169         SpriteID sprite = this->GetUnicodeGlyph(key);
 170         if (sprite == 0) sprite = this->GetUnicodeGlyph('?');
 171         return GetSprite(sprite, ST_FONT);
 172 }
 173
 174 uint SpriteFontCache::GetGlyphWidth(GlyphID key)
 175 {
 176         SpriteID sprite = this->GetUnicodeGlyph(key);
 177         if (sprite == 0) sprite = this->GetUnicodeGlyph('?');
 178         return SpriteExists(sprite) ? GetSprite(sprite, ST_FONT)->width + ScaleGUITrad(this->fs != FS_NORMAL ? 1 : 0) : 0;
 179 }
 180
 181 int SpriteFontCache::GetHeight() const
 182 {
 183         return ScaleGUITrad(this->height);
 184 }
 185
 186 bool SpriteFontCache::GetDrawGlyphShadow()
 187 {
 188         return false;
 189 }
 190
 191 /* static */ FontCache *FontCache::caches[FS_END] = { new SpriteFontCache(FS_NORMAL), new SpriteFontCache(FS_SMALL), new SpriteFontCache(FS_LARGE), new SpriteFontCache(FS_MONO) };
 192 int font_height_cache[FS_END];
 193
 194 void UpdateFontHeightCache()
 195 {
 196         for (int i = 0; i < FS_END; i++) {
 197                 font_height_cache[i] = FontCache::Get((FontSize) i)->GetHeight();
 198         }
 199 }
 200
 201 #ifdef WITH_FREETYPE
 202 #include <ft2build.h>
 203 #include FT_FREETYPE_H
 204 #include FT_GLYPH_H
 205 #include FT_TRUETYPE_TABLES_H
 206
 207 /** Font cache for fonts that are based on a freetype font. */
 208 class FreeTypeFontCache : public FontCache {
 209 private:
 210         FT_Face face;  ///< The font face associated with this font.
 211
 212         typedef SmallMap<uint32, SmallPair<size_t, const void*> > FontTable; ///< Table with font table cache
 213         FontTable font_tables; ///< Cached font tables.
 214
 215         /** Container for information about a glyph. */
 216         struct GlyphEntry {
 217                 Sprite *sprite; ///< The loaded sprite.
 218                 byte width;     ///< The width of the glyph.
 219                 bool duplicate; ///< Whether this glyph entry is a duplicate, i.e. may this be freed?
 220         };
 221
 222         /**
 223          * The glyph cache. This is structured to reduce memory consumption.
 224          * 1) There is a 'segment' table for each font size.
 225          * 2) Each segment table is a discrete block of characters.
 226          * 3) Each block contains 256 (aligned) characters sequential characters.
 227          *
 228          * The cache is accessed in the following way:
 229          * For character 0x0041  ('A'): glyph_to_sprite[0x00][0x41]
 230          * For character 0x20AC (Euro): glyph_to_sprite[0x20][0xAC]
 231          *
 232          * Currently only 256 segments are allocated, "limiting" us to 65536 characters.
 233          * This can be simply changed in the two functions Get & SetGlyphPtr.
 234          */
 235         GlyphEntry **glyph_to_sprite;
 236
 237         GlyphEntry *GetGlyphPtr(GlyphID key);
 238         void SetGlyphPtr(GlyphID key, const GlyphEntry *glyph, bool duplicate = false);
 239
 240 public:
 241         FreeTypeFontCache(FontSize fs, FT_Face face, int pixels);
 242         ~FreeTypeFontCache();
 243         virtual SpriteID GetUnicodeGlyph(WChar key) { return this->parent->GetUnicodeGlyph(key); }
 244         virtual void SetUnicodeGlyph(WChar key, SpriteID sprite) { this->parent->SetUnicodeGlyph(key, sprite); }
 245
 246         virtual void InitializeUnicodeGlyphMap()
 247         {
 248                 this->parent->InitializeUnicodeGlyphMap();
 249                 font_height_cache[this->fs] = this->GetHeight();
 250         }
 251
 252         virtual void ClearFontCache();
 253         virtual const Sprite *GetGlyph(GlyphID key);
 254         virtual uint GetGlyphWidth(GlyphID key);
 255         virtual bool GetDrawGlyphShadow();
 256         virtual GlyphID MapCharToGlyph(WChar key);
 257         virtual const void *GetFontTable(uint32 tag, size_t &length);
 258         virtual const char *GetFontName() { return face->family_name; }
 259 };
 260
 261 FT_Library _library = nullptr;
 262
 263 FreeTypeSettings _freetype;
 264
 265 static const byte FACE_COLOUR   = 1;
 266 static const byte SHADOW_COLOUR = 2;
 267
 268 /**
 269  * Create a new FreeTypeFontCache.
 270  * @param fs     The font size that is going to be cached.
 271  * @param face   The font that has to be loaded.
 272  * @param pixels The number of pixels this font should be high.
 273  */
 274 FreeTypeFontCache::FreeTypeFontCache(FontSize fs, FT_Face face, int pixels) : FontCache(fs), face(face), glyph_to_sprite(nullptr)
 275 {
 276         assert(face != nullptr);
 277
 278         if (pixels == 0) {
 279                 /* Try to determine a good height based on the minimal height recommended by the font. */
 280                 pixels = _default_font_height[this->fs];
 281
 282                 TT_Header *head = (TT_Header *)FT_Get_Sfnt_Table(this->face, ft_sfnt_head);
 283                 if (head != nullptr) {
 284                         /* Font height is minimum height plus the difference between the default
 285                          * height for this font size and the small size. */
 286                         int diff = _default_font_height[this->fs] - _default_font_height[FS_SMALL];
 287                         pixels = Clamp(min(head->Lowest_Rec_PPEM, 20) + diff, _default_font_height[this->fs], MAX_FONT_SIZE);
 288                 }
 289         }
 290
 291         FT_Error err = FT_Set_Pixel_Sizes(this->face, 0, pixels);
 292         if (err != FT_Err_Ok) {
 293
 294                 /* Find nearest size to that requested */
 295                 FT_Bitmap_Size *bs = this->face->available_sizes;
 296                 int i = this->face->num_fixed_sizes;
 297                 if (i > 0) { // In pathetic cases one might get no fixed sizes at all.
 298                         int n = bs->height;
 299                         FT_Int chosen = 0;
 300                         for (; --i; bs++) {
 301                                 if (abs(pixels - bs->height) >= abs(pixels - n)) continue;
 302                                 n = bs->height;
 303                                 chosen = this->face->num_fixed_sizes - i;
 304                         }
 305
 306                         /* Don't use FT_Set_Pixel_Sizes here - it might give us another
 307                          * error, even though the size is available (FS#5885). */
 308                         err = FT_Select_Size(this->face, chosen);
 309                 }
 310         }
 311
 312         if (err == FT_Err_Ok) {
 313                 this->units_per_em = this->face->units_per_EM;
 314                 this->ascender     = this->face->size->metrics.ascender >> 6;
 315                 this->descender    = this->face->size->metrics.descender >> 6;
 316                 this->height       = this->ascender - this->descender;
 317         } else {
 318                 /* Both FT_Set_Pixel_Sizes and FT_Select_Size failed. */
 319                 DEBUG(freetype, 0, "Font size selection failed. Using FontCache defaults.");
 320         }
 321
 322         font_height_cache[this->fs] = this->GetHeight();
 323 }
 324
 325 /**
 326  * Loads the freetype font.
 327  * First type to load the fontname as if it were a path. If that fails,
 328  * try to resolve the filename of the font using fontconfig, where the
 329  * format is 'font family name' or 'font family name, font style'.
 330  * @param fs The font size to load.
 331  */
 332 static void LoadFreeTypeFont(FontSize fs)
 333 {
 334         FreeTypeSubSetting *settings = nullptr;
 335         switch (fs) {
 336                 default: NOT_REACHED();
 337                 case FS_SMALL:  settings = &_freetype.small;  break;
 338                 case FS_NORMAL: settings = &_freetype.medium; break;
 339                 case FS_LARGE:  settings = &_freetype.large;  break;
 340                 case FS_MONO:   settings = &_freetype.mono;   break;
 341         }
 342
 343         if (StrEmpty(settings->font)) return;
 344
 345         if (_library == nullptr) {
 346                 if (FT_Init_FreeType(&_library) != FT_Err_Ok) {
 347                         ShowInfoF("Unable to initialize FreeType, using sprite fonts instead");
 348                         return;
 349                 }
 350
 351                 DEBUG(freetype, 2, "Initialized");
 352         }
 353
 354         FT_Face face = nullptr;
 355         FT_Error error = FT_New_Face(_library, settings->font, 0, &face);
 356
 357         if (error != FT_Err_Ok) error = GetFontByFaceName(settings->font, &face);
 358
 359         if (error == FT_Err_Ok) {
 360                 DEBUG(freetype, 2, "Requested '%s', using '%s %s'", settings->font, face->family_name, face->style_name);
 361
 362                 /* Attempt to select the unicode character map */
 363                 error = FT_Select_Charmap(face, ft_encoding_unicode);
 364                 if (error == FT_Err_Ok) goto found_face; // Success
 365
 366                 if (error == FT_Err_Invalid_CharMap_Handle) {
 367                         /* Try to pick a different character map instead. We default to
 368                          * the first map, but platform_id 0 encoding_id 0 should also
 369                          * be unicode (strange system...) */
 370                         FT_CharMap found = face->charmaps[0];
 371                         int i;
 372
 373                         for (i = 0; i < face->num_charmaps; i++) {
 374                                 FT_CharMap charmap = face->charmaps[i];
 375                                 if (charmap->platform_id == 0 && charmap->encoding_id == 0) {
 376                                         found = charmap;
 377                                 }
 378                         }
 379
 380                         if (found != nullptr) {
 381                                 error = FT_Set_Charmap(face, found);
 382                                 if (error == FT_Err_Ok) goto found_face;
 383                         }
 384                 }
 385         }
 386
 387         FT_Done_Face(face);
 388
 389         static const char *SIZE_TO_NAME[] = { "medium", "small", "large", "mono" };
 390         ShowInfoF("Unable to use '%s' for %s font, FreeType reported error 0x%X, using sprite font instead", settings->font, SIZE_TO_NAME[fs], error);
 391         return;
 392
 393 found_face:
 394         new FreeTypeFontCache(fs, face, settings->size);
 395 }
 396
 397
 398 /**
 399  * Free everything that was allocated for this font cache.
 400  */
 401 FreeTypeFontCache::~FreeTypeFontCache()
 402 {
 403         FT_Done_Face(this->face);
 404         this->ClearFontCache();
 405
 406         for (FontTable::iterator iter = this->font_tables.Begin(); iter != this->font_tables.End(); iter++) {
 407                 free(iter->second.second);
 408         }
 409 }
 410
 411 /**
 412  * Reset cached glyphs.
 413  */
 414 void FreeTypeFontCache::ClearFontCache()
 415 {
 416         if (this->glyph_to_sprite == nullptr) return;
 417
 418         for (int i = 0; i < 256; i++) {
 419                 if (this->glyph_to_sprite[i] == nullptr) continue;
 420
 421                 for (int j = 0; j < 256; j++) {
 422                         if (this->glyph_to_sprite[i][j].duplicate) continue;
 423                         free(this->glyph_to_sprite[i][j].sprite);
 424                 }
 425
 426                 free(this->glyph_to_sprite[i]);
 427         }
 428
 429         free(this->glyph_to_sprite);
 430         this->glyph_to_sprite = nullptr;
 431
 432         Layouter::ResetFontCache(this->fs);
 433 }
 434
 435 FreeTypeFontCache::GlyphEntry *FreeTypeFontCache::GetGlyphPtr(GlyphID key)
 436 {
 437         if (this->glyph_to_sprite == nullptr) return nullptr;
 438         if (this->glyph_to_sprite[GB(key, 8, 8)] == nullptr) return nullptr;
 439         return &this->glyph_to_sprite[GB(key, 8, 8)][GB(key, 0, 8)];
 440 }
 441
 442
 443 void FreeTypeFontCache::SetGlyphPtr(GlyphID key, const GlyphEntry *glyph, bool duplicate)
 444 {
 445         if (this->glyph_to_sprite == nullptr) {
 446                 DEBUG(freetype, 3, "Allocating root glyph cache for size %u", this->fs);
 447                 this->glyph_to_sprite = CallocT<GlyphEntry*>(256);
 448         }
 449
 450         if (this->glyph_to_sprite[GB(key, 8, 8)] == nullptr) {
 451                 DEBUG(freetype, 3, "Allocating glyph cache for range 0x%02X00, size %u", GB(key, 8, 8), this->fs);
 452                 this->glyph_to_sprite[GB(key, 8, 8)] = CallocT<GlyphEntry>(256);
 453         }
 454
 455         DEBUG(freetype, 4, "Set glyph for unicode character 0x%04X, size %u", key, this->fs);
 456         this->glyph_to_sprite[GB(key, 8, 8)][GB(key, 0, 8)].sprite    = glyph->sprite;
 457         this->glyph_to_sprite[GB(key, 8, 8)][GB(key, 0, 8)].width     = glyph->width;
 458         this->glyph_to_sprite[GB(key, 8, 8)][GB(key, 0, 8)].duplicate = duplicate;
 459 }
 460
 461 static void *AllocateFont(size_t size)
 462 {
 463         return MallocT<byte>(size);
 464 }
 465
 466
 467 /* Check if a glyph should be rendered with antialiasing */
 468 static bool GetFontAAState(FontSize size)
 469 {
 470         /* AA is only supported for 32 bpp */
 471         if (BlitterFactory::GetCurrentBlitter()->GetScreenDepth() != 32) return false;
 472
 473         switch (size) {
 474                 default: NOT_REACHED();
 475                 case FS_NORMAL: return _freetype.medium.aa;
 476                 case FS_SMALL:  return _freetype.small.aa;
 477                 case FS_LARGE:  return _freetype.large.aa;
 478                 case FS_MONO:   return _freetype.mono.aa;
 479         }
 480 }
 481
 482
 483 const Sprite *FreeTypeFontCache::GetGlyph(GlyphID key)
 484 {
 485         if ((key & SPRITE_GLYPH) != 0) return this->parent->GetGlyph(key);
 486
 487         /* Check for the glyph in our cache */
 488         GlyphEntry *glyph = this->GetGlyphPtr(key);
 489         if (glyph != nullptr && glyph->sprite != nullptr) return glyph->sprite;
 490
 491         FT_GlyphSlot slot = this->face->glyph;
 492
 493         bool aa = GetFontAAState(this->fs);
 494
 495         GlyphEntry new_glyph;
 496         if (key == 0) {
 497                 GlyphID question_glyph = this->MapCharToGlyph('?');
 498                 if (question_glyph == 0) {
 499                         /* The font misses the '?' character. Use built-in sprite.
 500                          * Note: We cannot use the baseset as this also has to work in the bootstrap GUI. */
 501 #define CPSET { 0, 0, 0, 0, 1 }
 502 #define CP___ { 0, 0, 0, 0, 0 }
 503                         static SpriteLoader::CommonPixel builtin_questionmark_data[10 * 8] = {
 504                                 CP___, CP___, CPSET, CPSET, CPSET, CPSET, CP___, CP___,
 505                                 CP___, CPSET, CPSET, CP___, CP___, CPSET, CPSET, CP___,
 506                                 CP___, CP___, CP___, CP___, CP___, CPSET, CPSET, CP___,
 507                                 CP___, CP___, CP___, CP___, CPSET, CPSET, CP___, CP___,
 508                                 CP___, CP___, CP___, CPSET, CPSET, CP___, CP___, CP___,
 509                                 CP___, CP___, CP___, CPSET, CPSET, CP___, CP___, CP___,
 510                                 CP___, CP___, CP___, CPSET, CPSET, CP___, CP___, CP___,
 511                                 CP___, CP___, CP___, CP___, CP___, CP___, CP___, CP___,
 512                                 CP___, CP___, CP___, CPSET, CPSET, CP___, CP___, CP___,
 513                                 CP___, CP___, CP___, CPSET, CPSET, CP___, CP___, CP___,
 514                         };
 515 #undef CPSET
 516 #undef CP___
 517                         static const SpriteLoader::Sprite builtin_questionmark = {
 518                                 10, // height
 519                                 8,  // width
 520                                 0,  // x_offs
 521                                 0,  // y_offs
 522                                 ST_FONT,
 523                                 builtin_questionmark_data
 524                         };
 525
 526                         Sprite *spr = BlitterFactory::GetCurrentBlitter()->Encode(&builtin_questionmark, AllocateFont);
 527                         assert(spr != nullptr);
 528                         new_glyph.sprite = spr;
 529                         new_glyph.width  = spr->width + (this->fs != FS_NORMAL);
 530                         this->SetGlyphPtr(key, &new_glyph, false);
 531                         return new_glyph.sprite;
 532                 } else {
 533                         /* Use '?' for missing characters. */
 534                         this->GetGlyph(question_glyph);
 535                         glyph = this->GetGlyphPtr(question_glyph);
 536                         this->SetGlyphPtr(key, glyph, true);
 537                         return glyph->sprite;
 538                 }
 539         }
 540         FT_Load_Glyph(this->face, key, FT_LOAD_DEFAULT);
 541         FT_Render_Glyph(this->face->glyph, aa ? FT_RENDER_MODE_NORMAL : FT_RENDER_MODE_MONO);
 542
 543         /* Despite requesting a normal glyph, FreeType may have returned a bitmap */
 544         aa = (slot->bitmap.pixel_mode == FT_PIXEL_MODE_GRAY);
 545
 546         /* Add 1 pixel for the shadow on the medium font. Our sprite must be at least 1x1 pixel */
 547         uint width  = max(1U, (uint)slot->bitmap.width + (this->fs == FS_NORMAL));
 548         uint height = max(1U, (uint)slot->bitmap.rows  + (this->fs == FS_NORMAL));
 549
 550         /* Limit glyph size to prevent overflows later on. */
 551         if (width > 256 || height > 256) usererror("Font glyph is too large");
 552
 553         /* FreeType has rendered the glyph, now we allocate a sprite and copy the image into it */
 554         SpriteLoader::Sprite sprite;
 555         sprite.AllocateData(ZOOM_LVL_NORMAL, width * height);
 556         sprite.type = ST_FONT;
 557         sprite.width = width;
 558         sprite.height = height;
 559         sprite.x_offs = slot->bitmap_left;
 560         sprite.y_offs = this->ascender - slot->bitmap_top;
 561
 562         /* Draw shadow for medium size */
 563         if (this->fs == FS_NORMAL && !aa) {
 564                 for (uint y = 0; y < (uint)slot->bitmap.rows; y++) {
 565                         for (uint x = 0; x < (uint)slot->bitmap.width; x++) {
 566                                 if (aa ? (slot->bitmap.buffer[x + y * slot->bitmap.pitch] > 0) : HasBit(slot->bitmap.buffer[(x / 8) + y * slot->bitmap.pitch], 7 - (x % 8))) {
 567                                         sprite.data[1 + x + (1 + y) * sprite.width].m = SHADOW_COLOUR;
 568                                         sprite.data[1 + x + (1 + y) * sprite.width].a = aa ? slot->bitmap.buffer[x + y * slot->bitmap.pitch] : 0xFF;
 569                                 }
 570                         }
 571                 }
 572         }
 573
 574         for (uint y = 0; y < (uint)slot->bitmap.rows; y++) {
 575                 for (uint x = 0; x < (uint)slot->bitmap.width; x++) {
 576                         if (aa ? (slot->bitmap.buffer[x + y * slot->bitmap.pitch] > 0) : HasBit(slot->bitmap.buffer[(x / 8) + y * slot->bitmap.pitch], 7 - (x % 8))) {
 577                                 sprite.data[x + y * sprite.width].m = FACE_COLOUR;
 578                                 sprite.data[x + y * sprite.width].a = aa ? slot->bitmap.buffer[x + y * slot->bitmap.pitch] : 0xFF;
 579                         }
 580                 }
 581         }
 582
 583         new_glyph.sprite = BlitterFactory::GetCurrentBlitter()->Encode(&sprite, AllocateFont);
 584         new_glyph.width  = slot->advance.x >> 6;
 585
 586         this->SetGlyphPtr(key, &new_glyph);
 587
 588         return new_glyph.sprite;
 589 }
 590
 591
 592 bool FreeTypeFontCache::GetDrawGlyphShadow()
 593 {
 594         return this->fs == FS_NORMAL && GetFontAAState(FS_NORMAL);
 595 }
 596
 597
 598 uint FreeTypeFontCache::GetGlyphWidth(GlyphID key)
 599 {
 600         if ((key & SPRITE_GLYPH) != 0) return this->parent->GetGlyphWidth(key);
 601
 602         GlyphEntry *glyph = this->GetGlyphPtr(key);
 603         if (glyph == nullptr || glyph->sprite == nullptr) {
 604                 this->GetGlyph(key);
 605                 glyph = this->GetGlyphPtr(key);
 606         }
 607
 608         return glyph->width;
 609 }
 610
 611 GlyphID FreeTypeFontCache::MapCharToGlyph(WChar key)
 612 {
 613         assert(IsPrintable(key));
 614
 615         if (key >= SCC_SPRITE_START && key <= SCC_SPRITE_END) {
 616                 return this->parent->MapCharToGlyph(key);
 617         }
 618
 619         return FT_Get_Char_Index(this->face, key);
 620 }
 621
 622 const void *FreeTypeFontCache::GetFontTable(uint32 tag, size_t &length)
 623 {
 624         const FontTable::iterator iter = this->font_tables.Find(tag);
 625         if (iter != this->font_tables.End()) {
 626                 length = iter->second.first;
 627                 return iter->second.second;
 628         }
 629
 630         FT_ULong len = 0;
 631         FT_Byte *result = nullptr;
 632
 633         FT_Load_Sfnt_Table(this->face, tag, 0, nullptr, &len);
 634
 635         if (len > 0) {
 636                 result = MallocT<FT_Byte>(len);
 637                 FT_Load_Sfnt_Table(this->face, tag, 0, result, &len);
 638         }
 639         length = len;
 640
 641         this->font_tables.Insert(tag, SmallPair<size_t, const void *>(length, result));
 642         return result;
 643 }
 644
 645 #endif /* WITH_FREETYPE */
 646
 647 /**
 648  * (Re)initialize the freetype related things, i.e. load the non-sprite fonts.
 649  * @param monospace Whether to initialise the monospace or regular fonts.
 650  */
 651 void InitFreeType(bool monospace)
 652 {
 653         for (FontSize fs = FS_BEGIN; fs < FS_END; fs++) {
 654                 if (monospace != (fs == FS_MONO)) continue;
 655
 656                 FontCache *fc = FontCache::Get(fs);
 657                 if (fc->HasParent()) delete fc;
 658
 659 #ifdef WITH_FREETYPE
 660                 LoadFreeTypeFont(fs);
 661 #endif
 662         }
 663 }
 664
 665 /**
 666  * Free everything allocated w.r.t. fonts.
 667  */
 668 void UninitFreeType()
 669 {
 670         for (FontSize fs = FS_BEGIN; fs < FS_END; fs++) {
 671                 FontCache *fc = FontCache::Get(fs);
 672                 if (fc->HasParent()) delete fc;
 673         }
 674
 675 #ifdef WITH_FREETYPE
 676         FT_Done_FreeType(_library);
 677         _library = nullptr;
 678 #endif /* WITH_FREETYPE */
 679 }