font_book.hpp

// Copyright Take Vos 2020-2022.
// 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 "font.hpp"
#include "font_family_id.hpp"
#include "elusive_icon.hpp"
#include "hikogui_icon.hpp"
#include "../unicode/module.hpp"
#include "../geometry/module.hpp"
#include "../utility/module.hpp"
#include "../generator.hpp"
#include <limits>
#include <array>
#include <new>
#include <atomic>
#include <filesystem>
 
namespace hi::inline v1 {
 
class font_book {
public:
    struct font_glyph_type {
        hi::font const *font;
        hi::glyph_id glyph;
 
        [[nodiscard]] constexpr friend bool operator==(font_glyph_type const&, font_glyph_type const&) noexcept = default;
 
        [[nodiscard]] glyph_metrics get_metrics() const noexcept
        {
            hi_axiom_not_null(font);
            return font->get_metrics(glyph);
        }
 
        [[nodiscard]] aarectangle get_bounding_rectangle() const noexcept
        {
            return get_metrics().bounding_rectangle;
        }
    };
 
    struct font_glyphs_type {
        hi::font const *font;
        lean_vector<glyph_id> glyphs;
    };
 
    static font_book& global() noexcept;
 
    ~font_book();
    font_book(font_book const&) = delete;
    font_book(font_book&&) = delete;
    font_book& operator=(font_book const&) = delete;
    font_book& operator=(font_book&&) = delete;
    font_book();
 
    font& register_font_file(std::filesystem::path const& path, bool post_process = true);
 
    void register_font_directory(std::filesystem::path const& path, bool post_process = true);
 
    void post_process() noexcept;
 
    [[nodiscard]] font_family_id find_family(std::string const& family_name) const noexcept;
 
    [[nodiscard]] font_family_id register_family(std::string_view family_name) noexcept;
 
    [[nodiscard]] font const& find_font(font_family_id family_id, font_variant variant) const noexcept;
 
    [[nodiscard]] font const& find_font(font_family_id family_id, font_weight weight, font_style style) const noexcept;
 
    [[nodiscard]] font const& find_font(std::string const& family_name, font_weight weight, font_style style) const noexcept;
 
    [[nodiscard]] font_glyphs_type find_glyph(font const& font, grapheme grapheme) const noexcept;
 
    [[nodiscard]] font_glyph_type find_glyph(font const& font, char32_t code_point) const noexcept;
 
private:
    inline static std::unique_ptr<font_book> _global = nullptr;
 
    std::unordered_map<std::string, font_family_id> _family_names;
 
    std::vector<std::array<font const *, font_variant::max()>> _font_variants;
 
    std::vector<std::unique_ptr<font>> _fonts;
    std::vector<hi::font *> _font_ptrs;
 
    [[nodiscard]] std::vector<hi::font *> make_fallback_chain(font_weight weight, font_style style) noexcept;
};
 
inline font& register_font_file(std::filesystem::path const& path)
{
    return font_book::global().register_font_file(path);
}
 
inline void register_font_directory(std::filesystem::path const& path)
{
    return font_book::global().register_font_directory(path);
}
 
template<typename Range>
inline void register_font_directories(Range &&range) noexcept
{
    for (auto const &path: range) {
        font_book::global().register_font_directory(path, false);
    }
    font_book::global().post_process();
}
 
[[nodiscard]] inline font_family_id find_font_family(std::string const& family_name) noexcept
{
    return font_book::global().find_family(family_name);
}
 
[[nodiscard]] inline font const& find_font(font_family_id family_id, font_variant variant = font_variant{}) noexcept
{
    return font_book::global().find_font(family_id, variant);
}
 
[[nodiscard]] inline font const& find_font(std::string const& family_name, font_variant variant = font_variant{}) noexcept
{
    hilet family_id = find_font_family(family_name);
    return font_book::global().find_font(family_id, variant);
}
 
[[nodiscard]] inline auto find_glyph(font const& font, grapheme grapheme) noexcept
{
    return font_book::global().find_glyph(font, grapheme);
}
 
[[nodiscard]] inline auto find_glyph(font const& font, char32_t code_point) noexcept
{
    return font_book::global().find_glyph(font, code_point);
}
 
[[nodiscard]] inline auto find_glyph(elusive_icon rhs) noexcept
{
    hilet& font = find_font("Elusive", font_variant{});
    return find_glyph(font, to_underlying(rhs));
}
 
[[nodiscard]] inline auto find_glyph(hikogui_icon rhs) noexcept
{
    hilet& font = find_font("HikoGUI", font_variant{});
    return find_glyph(font, to_underlying(rhs));
}
 
} // namespace hi::inline v1