resources.h

// Name:        resources.h
// Author:      David Bauer
// Created:     2022
// Copyright (c) Authors and others. All rights reserved.
 
#ifndef __VRV_RESOURCES_H__
#define __VRV_RESOURCES_H__
 
#include <optional>
#include <unordered_map>
 
//----------------------------------------------------------------------------
 
#include "filereader.h"
#include "glyph.h"
 
namespace vrv {
 
//----------------------------------------------------------------------------
// Resources
//----------------------------------------------------------------------------
 
class Resources {
public:
    using StyleAttributes = std::pair<data_FONTWEIGHT, data_FONTSTYLE>;
    using GlyphTable = std::unordered_map<char32_t, Glyph>;
    using GlyphNameTable = std::unordered_map<std::string, char32_t>;
    using GlyphTextMap = std::map<StyleAttributes, GlyphTable>;
 
    Resources();
    virtual ~Resources() = default;
 
    static std::string GetDefaultPath() { return s_defaultPath; }
    static void SetDefaultPath(const std::string &path) { s_defaultPath = path; }
 
    std::string GetPath() const { return m_path; }
    void SetPath(const std::string &path) { m_path = path; }
 
    bool Ok() const { return (m_loadedFonts.size() > 1); }
 
    void UseLiberationTextFont(bool useLiberation) { m_useLiberation = useLiberation; }
    bool UseLiberationTextFont() const { return m_useLiberation; }
    std::string GetTextFont() const { return ((m_useLiberation) ? "Liberation" : "Times"); }
 
 
    bool InitFonts();
    bool SetFont(const std::string &fontName);
    bool AddCustom(const std::vector<std::string> &extraFonts);
    bool LoadAll();
    void SetFallbackFont(const std::string &fontName);
    std::string GetFallbackFont() const { return m_fallbackFontName; }
 
    bool SetCurrentFont(const std::string &fontName, bool allowLoading = false);
    std::string GetCurrentFont() const { return m_currentFontName; }
    bool IsFontLoaded(const std::string &fontName) const { return m_loadedFonts.find(fontName) != m_loadedFonts.end(); }
 
 
    const Glyph *GetGlyph(char32_t smuflCode) const;
    const Glyph *GetGlyph(const std::string &smuflName) const;
    char32_t GetGlyphCode(const std::string &smuflName) const;
 
    bool IsSmuflFallbackNeeded(const std::u32string &text) const;
 
    bool IsCurrentFontFallback() const;
 
 
    void SelectTextFont(data_FONTWEIGHT fontWeight, data_FONTSTYLE fontStyle) const;
    const Glyph *GetTextGlyph(char32_t code) const;
    bool FontHasGlyphAvailable(const std::string &fontName, char32_t smuflCode) const;
 
    std::string GetCSSFontFor(const std::string &fontName) const;
 
    std::string GetCustomFontname(const std::string &filename, const ZipFileReader &zipFile);
 
    static char32_t GetSmuflGlyphForUnicodeChar(const char32_t unicodeChar);
 
private:
    //----------------------------------------------------------------------------
    // LoadedFont
    //----------------------------------------------------------------------------
 
    class LoadedFont {
 
    public:
        LoadedFont(const std::string &name, bool isFallback) : m_name(name), m_isFallback(isFallback) {}
        ~LoadedFont() {}
        const std::string GetName() const { return m_name; };
        const GlyphTable &GetGlyphTable() const { return m_glyphTable; };
        GlyphTable &GetGlyphTableForModification() { return m_glyphTable; };
        bool isFallback() const { return m_isFallback; };
 
        void SetCSSFont(const std::string &css) { m_css = css; }
        std::string GetCSSFont(const std::string &path) const;
 
    private:
        std::string m_name;
        GlyphTable m_glyphTable;
        const bool m_isFallback;
        std::string m_css;
    };
 
    //----------------------------------------------------------------------------
 
    bool LoadFont(const std::string &fontName, ZipFileReader *zipFile = NULL);
 
    bool InitTextFont(const std::string &fontName, const StyleAttributes &style);
 
    const GlyphTable &GetCurrentGlyphTable() const { return m_loadedFonts.at(m_currentFontName).GetGlyphTable(); };
    const GlyphTable &GetFallbackGlyphTable() const { return m_loadedFonts.at(m_fallbackFontName).GetGlyphTable(); };
 
    bool m_useLiberation;
    std::string m_path;
    std::string m_defaultFontName;
    std::string m_fallbackFontName;
    std::map<std::string, LoadedFont> m_loadedFonts;
    std::string m_currentFontName;
 
    GlyphTextMap m_textFont;
    mutable StyleAttributes m_currentStyle;
    GlyphNameTable m_glyphNameTable;
 
    mutable std::optional<std::pair<char32_t, const Glyph *>> m_cachedGlyph;
 
    //----------------//
    // Static members //
    //----------------//
 
    static thread_local std::string s_defaultPath;
 
    static const StyleAttributes k_defaultStyle;
};
 
} // namespace vrv
 
#endif