Font.h

 
#ifndef FONT_H
#define FONT_H
 
#include "RageUtil/Misc/RageTypes.h"
#include "RageUtil/Utils/RageUtil.h"
 
class FontPage;
class RageTexture;
class IniFile;
 
struct FontPageTextures
{
    RageTexture* m_pTextureMain;
    RageTexture* m_pTextureStroke;
 
    FontPageTextures()
      : m_pTextureMain(NULL)
      , m_pTextureStroke(NULL)
    {
    }
};
 
struct glyph
{
    FontPage* m_pPage;
    FontPageTextures m_FontPageTextures;
    FontPageTextures* GetFontPageTextures() const
    {
        return const_cast<FontPageTextures*>(&m_FontPageTextures);
    }
 
    int m_iHadvance{ 0 };
 
    float m_fWidth{ 0 };
    float m_fHeight{ 0 };
 
    float m_fHshift{ 0 }; // , m_fVshift;
 
    RectF m_TexRect;
 
    glyph()
      : m_pPage(NULL)
      , m_FontPageTextures()
      , m_TexRect()
    {
    }
};
 
struct FontPageSettings
{
    std::string m_sTexturePath;
 
    int m_iDrawExtraPixelsLeft{ 0 }, m_iDrawExtraPixelsRight{ 0 },
      m_iAddToAllWidths{ 0 }, m_iLineSpacing{ -1 }, m_iTop{ -1 },
      m_iBaseline{ -1 }, m_iDefaultWidth{ -1 }, m_iAdvanceExtraPixels{ 1 };
    float m_fScaleAllWidthsBy{ 1 };
    std::string m_sTextureHints;
 
    std::map<wchar_t, int> CharToGlyphNo;
    // If a value is missing, the width of the texture frame is used.
    std::map<int, int> m_mapGlyphWidths;
 
    FontPageSettings()
      : m_sTexturePath("")
      , m_sTextureHints("default")
      , CharToGlyphNo()
      , m_mapGlyphWidths()
    {
    }
 
    std::string MapRange(const std::string& sMapping,
                         int iMapOffset,
                         int iGlyphOffset,
                         int iCount);
};
 
class FontPage
{
  public:
    FontPage();
    ~FontPage();
 
    void Load(const FontPageSettings& cfg);
 
    // Page-global properties.
    int m_iHeight{ 0 };
    int m_iLineSpacing{ 0 };
    float m_fVshift{ 0 };
    int GetCenter() const { return m_iHeight / 2; }
 
    // Remember these only for GetLineWidthInSourcePixels.
    int m_iDrawExtraPixelsLeft{ 0 }, m_iDrawExtraPixelsRight{ 0 };
 
    FontPageTextures m_FontPageTextures;
 
    // XXX: remove?
    std::string m_sTexturePath;
 
    std::vector<glyph> m_aGlyphs;
 
    std::map<wchar_t, int> m_iCharToGlyphNo;
 
  private:
    void SetExtraPixels(int iDrawExtraPixelsLeft, int DrawExtraPixelsRight);
    void SetTextureCoords(const std::vector<int>& aiWidths,
                          int iAdvanceExtraPixels);
};
 
class Font
{
  public:
    int m_iRefCount{ 1 };
    std::string path;
 
    Font();
    ~Font();
 
    const glyph& GetGlyph(wchar_t c) const;
 
    int GetLineWidthInSourcePixels(const std::wstring& szLine) const;
    int GetLineHeightInSourcePixels(const std::wstring& szLine) const;
    int GetGlyphsThatFit(const std::wstring& line, int* width) const;
 
    bool FontCompleteForString(const std::wstring& str) const;
 
    void AddPage(FontPage* fp);
 
    void MergeFont(Font& f);
 
    void Load(const std::string& sFontOrTextureFilePath,
              const std::string& sChars);
    void Unload();
    void Reload();
 
    // Load font-wide settings.
    void CapsOnly();
 
    int GetHeight() const { return m_pDefault->m_iHeight; }
    int GetCenter() const { return m_pDefault->GetCenter(); }
    int GetLineSpacing() const { return m_pDefault->m_iLineSpacing; }
 
    void SetDefaultGlyph(FontPage* pPage);
 
    bool IsRightToLeft() const { return m_bRightToLeft; };
    const RageColor& GetDefaultStrokeColor() const
    {
        return m_DefaultStrokeColor;
    };
 
  private:
    std::vector<FontPage*> m_apPages;
 
    FontPage* m_pDefault;
 
    std::map<wchar_t, glyph*> m_iCharToGlyph;
    glyph* m_iCharToGlyphCache[128];
 
    bool m_bRightToLeft{ false };
 
    RageColor m_DefaultStrokeColor;
 
    std::string m_sChars;
 
    void LoadFontPageSettings(FontPageSettings& cfg,
                              IniFile& ini,
                              const std::string& sTexturePath,
                              const std::string& PageName,
                              const std::string& sChars);
    static void GetFontPaths(const std::string& sFontOrTextureFilePath,
                             std::vector<std::string>& sTexturePaths);
    std::string GetPageNameFromFileName(const std::string& sFilename);
 
    Font(const Font& rhs);
    Font& operator=(const Font& rhs);
};
 
const wchar_t FONT_DEFAULT_GLYPH = 0xF8FF;
 
#endif