font.hpp

// Copyright Take Vos 2019-2021.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#include "glyph_metrics.hpp"
#include "font_glyph_ids.hpp"
#include "gstring.hpp"
#include "unicode_mask.hpp"
#include "font_weight.hpp"
#include "font_variant.hpp"
#include "../graphic_path.hpp"
#include "../resource_view.hpp"
#include "../exception.hpp"
#include "../required.hpp"
#include "../URL.hpp"
#include <span>
#include <vector>
#include <map>
 
namespace tt {
 
class font {
public:
    std::string family_name;
    std::string sub_family_name;
 
    bool monospace = false;
    bool serif = false;
    bool italic = false;
    bool condensed = false;
    font_weight weight = font_weight::Regular;
    float optical_size = 12.0;
 
    tt::unicode_mask unicode_mask;
 
    float xHeight = 0.0;
    float HHeight = 0.0;
    float DigitWidth = 0.0;
 
    std::vector<tt::font *> fallback_chain;
 
    font() = default;
    virtual ~font() = default;
    font(font const &) = delete;
    font &operator=(font const &) = delete;
    font(font &&) = delete;
    font &operator=(font &&) = delete;
 
    [[nodiscard]] virtual bool loaded() const noexcept = 0;
 
    [[nodiscard]] virtual tt::glyph_id find_glyph(char32_t c) const noexcept = 0;
 
    [[nodiscard]] font_glyph_ids find_glyph(grapheme g) const noexcept;
 
    virtual std::optional<tt::glyph_id> load_glyph(tt::glyph_id glyph_id, graphic_path &path) const noexcept = 0;
 
    virtual bool load_glyph_metrics(
        tt::glyph_id glyph_id,
        glyph_metrics &metrics,
        tt::glyph_id lookahead_glyph_id = tt::glyph_id{}) const noexcept = 0;
 
    [[nodiscard]] font_variant font_variant() const noexcept
    {
        return {weight, italic};
    }
 
    [[nodiscard]] friend std::string to_string(font const &rhs) noexcept
    {
        return std::format(
            "{} - {}: {}{}{}{}{} {} num-code-points={}",
            rhs.family_name,
            rhs.sub_family_name,
            rhs.monospace ? 'M' : '_',
            rhs.serif ? 'S' : '_',
            rhs.italic ? 'I' : '_',
            rhs.condensed ? 'C' : '_',
            to_char(rhs.weight),
            rhs.optical_size,
            rhs.unicode_mask.size());
    }
};
 
} // namespace tt
 
namespace std {
 
template<typename CharT>
struct formatter<tt::font, CharT> : formatter<std::string_view, CharT> {
    auto format(tt::font const &t, auto &fc)
    {
        return formatter<string_view, CharT>::format(to_string(t), fc);
    }
};
 
} // namespace std