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 "font_grapheme_id.hpp"
#include "glyph_ids.hpp"
#include "elusive_icon.hpp"
#include "hikogui_icon.hpp"
#include "../unicode/grapheme.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:
    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(std::filesystem::path const& path, bool post_process = true);
 
    void register_font_directory(std::filesystem::path const& path, bool post_process = true);
 
    void register_elusive_icon_font(std::filesystem::path const& path)
    {
        _elusive_icon_font = &register_font(path, false);
    }
 
    void register_hikogui_icon_font(std::filesystem::path const& path)
    {
        _hikogui_icon_font = &register_font(path, false);
    }
 
    void post_process() noexcept;
 
    [[nodiscard]] font_family_id find_family(std::string_view 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, bool italic) const noexcept;
 
    [[nodiscard]] font const& find_font(std::string_view family_name, font_weight weight, bool italic) const noexcept;
 
    [[nodiscard]] glyph_ids find_glyph(font const& font, grapheme grapheme) const noexcept;
 
    [[nodiscard]] glyph_ids find_glyph(elusive_icon rhs) const noexcept
    {
        hi_assert_not_null(_elusive_icon_font);
        return _elusive_icon_font->find_glyph(grapheme{static_cast<char32_t>(rhs)});
    }
 
    [[nodiscard]] glyph_ids find_glyph(hikogui_icon rhs) const noexcept
    {
        hi_assert_not_null(_hikogui_icon_font);
        return _hikogui_icon_font->find_glyph(grapheme{static_cast<char32_t>(rhs)});
    }
 
private:
    inline static std::unique_ptr<font_book> _global = nullptr;
 
    font const *_elusive_icon_font = nullptr;
    font const *_hikogui_icon_font = nullptr;
 
    std::unordered_map<std::string, font_family_id> _family_names;
 
    std::unordered_map<std::string, std::string> _family_name_fallback_chain;
 
    std::vector<std::array<font const *, font_variant::max()>> _font_variants;
 
    std::vector<std::unique_ptr<font>> _fonts;
    std::vector<hi::font *> _font_ptrs;
 
    mutable std::unordered_map<std::string, font_family_id> _family_name_cache;
 
    mutable std::unordered_map<font_grapheme_id, glyph_ids> _glyph_cache;
 
    [[nodiscard]] std::vector<hi::font *> make_fallback_chain(font_weight weight, bool italic) noexcept;
 
    // void morph_glyphs(glyph_array &glyphs) const noexcept;
 
    // void atlas_lookup(glyph &glyph) noexcept;
 
    // void atlas_lookup(glyph_array &glyphs) noexcept;
 
    // void kern_glyphs(glyph_array &glyphs) const noexcept;
 
    [[nodiscard]] generator<std::string> generate_family_names(std::string_view name) const noexcept;
 
    void create_family_name_fallback_chain() noexcept;
};
 
[[nodiscard]] inline glyph_ids find_glyph(font const& font, grapheme grapheme) noexcept
{
    return font_book::global().find_glyph(font, grapheme);
}
 
[[nodiscard]] inline glyph_ids find_glyph(elusive_icon rhs) noexcept
{
    return font_book::global().find_glyph(rhs);
}
 
[[nodiscard]] inline glyph_ids find_glyph(hikogui_icon rhs) noexcept
{
    return font_book::global().find_glyph(rhs);
}
 
} // namespace hi::inline v1