font_set.hpp

[詳解]

#ifndef TYPESET_FONT_FONT_SET_HPP
#define TYPESET_FONT_FONT_SET_HPP
 
#include <map>
#include <memory>
#include <optional>
#include <string>
#include <vector>
 
#include <glyphware/Face.h>
 
#include "typeset/geom.hpp"
 
struct hb_font_t;
 
namespace typeset { struct FontSpec; }
 
namespace typeset::font {
 
struct FontDeclaration {
    std::string key;                        
    std::string path;                       
    int faceIndex = 0;
    std::vector<std::string> family;        
    int weight = 0;                         
    std::optional<bool> italic;             
    std::vector<std::string> languages;     
    std::vector<glyphware::CodepointRange> ranges;  
};
 
class FontSet {
public:
    FontSet();
    ~FontSet();
 
    FontSet(const FontSet&) = delete;
    FontSet& operator=(const FontSet&) = delete;
 
    std::shared_ptr<glyphware::Face> loadFile(const std::string& path,
                                              const std::string& key = std::string(),
                                              int faceIndex = 0);
 
    std::shared_ptr<glyphware::Face> loadMemory(const std::string& key,
                                                const void* data, size_t size,
                                                int faceIndex = 0);
 
    bool declare(FontDeclaration decl);
 
    bool has(const std::string& key) const;
    bool isLoaded(const std::string& key) const;
    std::vector<std::string> keys() const;
 
    std::shared_ptr<glyphware::Face> find(const std::string& keyOrFamily);
 
    std::shared_ptr<glyphware::Face> select(const std::string& keyOrFamily, int weight, bool italic,
                                            const std::map<std::string, float>& variations = {});
 
    std::shared_ptr<glyphware::Face> instance(const std::shared_ptr<glyphware::Face>& base,
                                              const std::vector<glyphware::VarCoord>& coords);
 
    std::shared_ptr<glyphware::Face> resolve(const FontSpec& spec, char32_t cp,
                                             const std::string& language = std::string(),
                                             int colorPreference = 0);
 
    std::shared_ptr<glyphware::Face> primary(const FontSpec& spec);
 
    void setLanguageFonts(const std::string& language, std::vector<std::string> families);
    std::vector<std::string> languageFonts(const std::string& language) const;
 
    hb_font_t* hbFont(const glyphware::Face& face);
 
    size_t size() const { return entries_.size(); }
 
private:
    struct Entry {
        FontDeclaration decl;
        std::shared_ptr<glyphware::Face> face;
        bool failed = false;                    
        std::vector<std::string> names;         
        int weight = 400;                       
        bool italic = false;
        bool matches(const std::string& name) const;
        bool languageMatches(const std::string& language) const;
    };
 
    Entry* entryFor(const std::string& key);
    void adopt(Entry& e, std::shared_ptr<glyphware::Face> face);
    bool ensureLoaded(Entry& e);
    bool covers(Entry& e, char32_t cp);
    Entry* best(const std::string& name, int weight, bool italic);
    std::shared_ptr<glyphware::Face> faceOf(Entry* e);
 
    std::shared_ptr<glyphware::Face> withVariations(const std::shared_ptr<glyphware::Face>& base,
                                                    int weight, bool italic,
                                                    const std::map<std::string, float>& variations);
 
    std::vector<std::unique_ptr<Entry>> entries_;
    std::map<std::string, std::vector<std::string>> languageFonts_;
    std::map<const glyphware::Face*, hb_font_t*> hbFonts_;
    std::map<std::pair<const glyphware::Face*, std::string>, std::shared_ptr<glyphware::Face>> instances_;
};
 
inline uint32_t makeTag(const std::string& s) {
    uint32_t t = 0;
    for (size_t i = 0; i < 4; ++i) t = (t << 8) | static_cast<uint8_t>(i < s.size() ? s[i] : ' ');
    return t;
}
 
int effectiveWeight(const glyphware::Face& face);
 
float unitsPerEm(const glyphware::Face& face);
 
void faceAscentDescent(const glyphware::Face& face, Pt size, Pt& ascent, Pt& descent);
 
struct DecorationMetrics {
    Pt underlineOffset = 0.0f;
    Pt underlineThickness = 0.0f;
    Pt strikeoutOffset = 0.0f;
    Pt strikeoutThickness = 0.0f;
};
 
DecorationMetrics decorationMetrics(FontSet& fonts, const glyphware::Face& face, Pt size);
 
} // namespace typeset::font
 
#endif // TYPESET_FONT_FONT_SET_HPP