src/fontcache.cpp

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