src/fontcache.cpp

   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.cpp Cache for characters from fonts. */
   9
  10 #include "stdafx.h"
  11 #include "fontcache.h"
  12 #include "fontdetection.h"
  13 #include "blitter/factory.hpp"
  14 #include "gfx_layout.h"
  15 #include "fontcache/spritefontcache.h"
  16 #include "openttd.h"
  17 #include "settings_func.h"
  18 #include "strings_func.h"
  19 #include "viewport_func.h"
  20 #include "window_func.h"
  21 #include "fileio_func.h"
  22
  23 #include "safeguards.h"
  24
  25 /** Default heights for the different sizes of fonts. */
  26 static const int _default_font_height[FS_END]   = {10, 6, 18, 10};
  27 static const int _default_font_ascender[FS_END] = { 8, 5, 15,  8};
  28
  29 FontCacheSettings _fcsettings;
  30
  31 /**
  32  * Create a new font cache.
  33  * @param fs The size of the font.
  34  */
  35 FontCache::FontCache(FontSize fs) : parent(FontCache::Get(fs)), fs(fs), height(_default_font_height[fs]),
  36                 ascender(_default_font_ascender[fs]), descender(_default_font_ascender[fs] - _default_font_height[fs])
  37 {
  38         assert(this->parent == nullptr || this->fs == this->parent->fs);
  39         FontCache::caches[this->fs] = this;
  40         Layouter::ResetFontCache(this->fs);
  41 }
  42
  43 /** Clean everything up. */
  44 FontCache::~FontCache()
  45 {
  46         assert(this->fs == this->parent->fs);
  47         FontCache::caches[this->fs] = this->parent;
  48         Layouter::ResetFontCache(this->fs);
  49 }
  50
  51 int FontCache::GetDefaultFontHeight(FontSize fs)
  52 {
  53         return _default_font_height[fs];
  54 }
  55
  56 /**
  57  * Get the font name of a given font size.
  58  * @param fs The font size to look up.
  59  * @return The font name.
  60  */
  61 std::string FontCache::GetName(FontSize fs)
  62 {
  63         FontCache *fc = FontCache::Get(fs);
  64         if (fc != nullptr) {
  65                 return fc->GetFontName();
  66         } else {
  67                 return "[NULL]";
  68         }
  69 }
  70
  71
  72 /**
  73  * Get height of a character for a given font size.
  74  * @param size Font size to get height of
  75  * @return     Height of characters in the given font (pixels)
  76  */
  77 int GetCharacterHeight(FontSize size)
  78 {
  79         return FontCache::Get(size)->GetHeight();
  80 }
  81
  82
  83 /* static */ FontCache *FontCache::caches[FS_END];
  84
  85 /* static */ void FontCache::InitializeFontCaches()
  86 {
  87         for (FontSize fs = FS_BEGIN; fs != FS_END; fs++) {
  88                 if (FontCache::caches[fs] == nullptr) new SpriteFontCache(fs); /* FontCache inserts itself into to the cache. */
  89         }
  90 }
  91
  92 /* Check if a glyph should be rendered with anti-aliasing. */
  93 bool GetFontAAState()
  94 {
  95         /* AA is only supported for 32 bpp */
  96         if (BlitterFactory::GetCurrentBlitter()->GetScreenDepth() != 32) return false;
  97
  98         return _fcsettings.global_aa;
  99 }
 100
 101 void SetFont(FontSize fontsize, const std::string &font, uint size)
 102 {
 103         FontCacheSubSetting *setting = GetFontCacheSubSetting(fontsize);
 104         bool changed = false;
 105
 106         if (setting->font != font) {
 107                 setting->font = font;
 108                 changed = true;
 109         }
 110
 111         if (setting->size != size) {
 112                 setting->size = size;
 113                 changed = true;
 114         }
 115
 116         if (!changed) return;
 117
 118         if (fontsize != FS_MONO) {
 119                 /* Try to reload only the modified font. */
 120                 FontCacheSettings backup = _fcsettings;
 121                 for (FontSize fs = FS_BEGIN; fs < FS_END; fs++) {
 122                         if (fs == fontsize) continue;
 123                         FontCache *fc = FontCache::Get(fs);
 124                         GetFontCacheSubSetting(fs)->font = fc->HasParent() ? fc->GetFontName() : "";
 125                 }
 126                 CheckForMissingGlyphs();
 127                 _fcsettings = backup;
 128         } else {
 129                 InitFontCache(true);
 130         }
 131
 132         LoadStringWidthTable();
 133         UpdateAllVirtCoords();
 134         ReInitAllWindows(true);
 135
 136         if (_save_config) SaveToConfig();
 137 }
 138
 139 #ifdef WITH_FREETYPE
 140 extern void LoadFreeTypeFont(FontSize fs);
 141 extern void UninitFreeType();
 142 #elif defined(_WIN32)
 143 extern void LoadWin32Font(FontSize fs);
 144 #elif defined(WITH_COCOA)
 145 extern void LoadCoreTextFont(FontSize fs);
 146 #endif
 147
 148 /**
 149  * Test if a font setting uses the default font.
 150  * @return true iff the font is not configured and no fallback font data is present.
 151  */
 152 static bool IsDefaultFont(const FontCacheSubSetting &setting)
 153 {
 154         return setting.font.empty() && setting.os_handle == nullptr;
 155 }
 156
 157 /**
 158  * Get the scalable font size to use for a FontSize.
 159  * @param fs FontSize to get the scalable font size for.
 160  * @return Scalable font size to use.
 161  */
 162 uint GetFontCacheFontSize(FontSize fs)
 163 {
 164         const FontCacheSubSetting &setting = *GetFontCacheSubSetting(fs);
 165         return IsDefaultFont(setting) ? FontCache::GetDefaultFontHeight(fs) : setting.size;
 166 }
 167
 168 #if defined(WITH_FREETYPE) || defined(_WIN32) || defined(WITH_COCOA)
 169 /**
 170  * Get name of default font file for a given font size.
 171  * @param fs Font size.
 172  * @return Name of default font file.
 173  */
 174 static std::string GetDefaultTruetypeFont(FontSize fs)
 175 {
 176         switch (fs) {
 177                 case FS_NORMAL: return "OpenTTD-Sans.ttf";
 178                 case FS_SMALL: return "OpenTTD-Small.ttf";
 179                 case FS_LARGE: return "OpenTTD-Serif.ttf";
 180                 case FS_MONO: return "OpenTTD-Mono.ttf";
 181                 default: NOT_REACHED();
 182         }
 183 }
 184 #endif /* defined(WITH_FREETYPE) || defined(_WIN32) || defined(WITH_COCOA) */
 185
 186 /**
 187  * Get path of default font file for a given font size.
 188  * @param fs Font size.
 189  * @return Full path of default font file.
 190  */
 191 static std::string GetDefaultTruetypeFontFile([[maybe_unused]] FontSize fs)
 192 {
 193 #if defined(WITH_FREETYPE) || defined(_WIN32) || defined(WITH_COCOA)
 194         /* Find font file. */
 195         return FioFindFullPath(BASESET_DIR, GetDefaultTruetypeFont(fs));
 196 #else
 197         return {};
 198 #endif /* defined(WITH_FREETYPE) || defined(_WIN32) || defined(WITH_COCOA) */
 199 }
 200
 201 /**
 202  * Get font to use for a given font size.
 203  * @param fs Font size.
 204  * @return If configured, the font name to use, or the path of the default TrueType font if sprites are not preferred.
 205  */
 206 std::string GetFontCacheFontName(FontSize fs)
 207 {
 208         const FontCacheSubSetting *settings = GetFontCacheSubSetting(fs);
 209         if (!settings->font.empty()) return settings->font;
 210         if (_fcsettings.prefer_sprite) return {};
 211         return GetDefaultTruetypeFontFile(fs);
 212 }
 213
 214 /**
 215  * (Re)initialize the font cache related things, i.e. load the non-sprite fonts.
 216  * @param monospace Whether to initialise the monospace or regular fonts.
 217  */
 218 void InitFontCache(bool monospace)
 219 {
 220         FontCache::InitializeFontCaches();
 221
 222         for (FontSize fs = FS_BEGIN; fs < FS_END; fs++) {
 223                 if (monospace != (fs == FS_MONO)) continue;
 224
 225                 FontCache *fc = FontCache::Get(fs);
 226                 if (fc->HasParent()) delete fc;
 227
 228 #ifdef WITH_FREETYPE
 229                 LoadFreeTypeFont(fs);
 230 #elif defined(_WIN32)
 231                 LoadWin32Font(fs);
 232 #elif defined(WITH_COCOA)
 233                 LoadCoreTextFont(fs);
 234 #endif
 235         }
 236 }
 237
 238 /**
 239  * Free everything allocated w.r.t. fonts.
 240  */
 241 void UninitFontCache()
 242 {
 243         for (FontSize fs = FS_BEGIN; fs < FS_END; fs++) {
 244                 FontCache *fc = FontCache::Get(fs);
 245                 if (fc->HasParent()) delete fc;
 246         }
 247
 248 #ifdef WITH_FREETYPE
 249         UninitFreeType();
 250 #endif /* WITH_FREETYPE */
 251 }
 252
 253 #if !defined(_WIN32) && !defined(__APPLE__) && !defined(WITH_FONTCONFIG) && !defined(WITH_COCOA)
 254
 255 bool SetFallbackFont(FontCacheSettings *, const std::string &, int, MissingGlyphSearcher *) { return false; }
 256 #endif /* !defined(_WIN32) && !defined(__APPLE__) && !defined(WITH_FONTCONFIG) && !defined(WITH_COCOA) */