fontcache.h

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * 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.
 * 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.
 * 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/>.
 */
 
#ifndef FONTCACHE_H
#define FONTCACHE_H
 
#include "string_type.h"
#include "spritecache.h"
 
typedef uint32 GlyphID;
static const GlyphID SPRITE_GLYPH = 1U << 30;
 
class FontCache {
private:
  static FontCache *caches[FS_END]; 
protected:
  FontCache *parent;                
  const FontSize fs;                
  int height;                       
  int ascender;                     
  int descender;                    
  int units_per_em;                 
 
public:
  FontCache(FontSize fs);
  virtual ~FontCache();
 
  static int GetDefaultFontHeight(FontSize fs);
 
  inline FontSize GetSize() const { return this->fs; }
 
  inline int GetHeight() const { return this->height; }
 
  inline int GetAscender() const { return this->ascender; }
 
  inline int GetDescender() const{ return this->descender; }
 
  inline int GetUnitsPerEM() const { return this->units_per_em; }
 
  virtual int GetFontSize() const { return this->height; }
 
  virtual void SetUnicodeGlyph(WChar key, SpriteID sprite) = 0;
 
  virtual void InitializeUnicodeGlyphMap() = 0;
 
  virtual void ClearFontCache() = 0;
 
  virtual const Sprite *GetGlyph(GlyphID key) = 0;
 
  virtual uint GetGlyphWidth(GlyphID key) = 0;
 
  virtual bool GetDrawGlyphShadow() = 0;
 
  virtual GlyphID MapCharToGlyph(WChar key) = 0;
 
  virtual const void *GetFontTable(uint32 tag, size_t &length) = 0;
 
  virtual const void *GetOSHandle()
  {
    return nullptr;
  }
 
  virtual std::string GetFontName() = 0;
 
  static inline FontCache *Get(FontSize fs)
  {
    assert(fs < FS_END);
    return FontCache::caches[fs];
  }
 
  inline bool HasParent()
  {
    return this->parent != nullptr;
  }
 
  virtual bool IsBuiltInFont() = 0;
};
 
static inline void SetUnicodeGlyph(FontSize size, WChar key, SpriteID sprite)
{
  FontCache::Get(size)->SetUnicodeGlyph(key, sprite);
}
 
static inline void InitializeUnicodeGlyphMap()
{
  for (FontSize fs = FS_BEGIN; fs < FS_END; fs++) {
    FontCache::Get(fs)->InitializeUnicodeGlyphMap();
  }
}
 
static inline void ClearFontCache()
{
  for (FontSize fs = FS_BEGIN; fs < FS_END; fs++) {
    FontCache::Get(fs)->ClearFontCache();
  }
}
 
static inline const Sprite *GetGlyph(FontSize size, WChar key)
{
  FontCache *fc = FontCache::Get(size);
  return fc->GetGlyph(fc->MapCharToGlyph(key));
}
 
static inline uint GetGlyphWidth(FontSize size, WChar key)
{
  FontCache *fc = FontCache::Get(size);
  return fc->GetGlyphWidth(fc->MapCharToGlyph(key));
}
 
static inline bool GetDrawGlyphShadow(FontSize size)
{
  return FontCache::Get(size)->GetDrawGlyphShadow();
}
 
struct FontCacheSubSetting {
  std::string font; 
  uint size;        
  bool aa;          
 
  const void *os_handle = nullptr; 
};
 
struct FontCacheSettings {
  FontCacheSubSetting small;  
  FontCacheSubSetting medium; 
  FontCacheSubSetting large;  
  FontCacheSubSetting mono;   
};
 
extern FontCacheSettings _fcsettings;
 
static inline FontCacheSubSetting *GetFontCacheSubSetting(FontSize fs)
{
  switch (fs) {
    default: NOT_REACHED();
    case FS_SMALL:  return &_fcsettings.small;
    case FS_NORMAL: return &_fcsettings.medium;
    case FS_LARGE:  return &_fcsettings.large;
    case FS_MONO:   return &_fcsettings.mono;
  }
}
 
void InitFontCache(bool monospace);
void UninitFontCache();
bool HasAntialiasedFonts();
 
bool GetFontAAState(FontSize size, bool check_blitter = true);
void SetFont(FontSize fontsize, const std::string &font, uint size, bool aa);
 
#endif /* FONTCACHE_H */