font_font.hpp

// Copyright Take Vos 2019-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 "glyph_metrics.hpp"
#include "glyph_atlas_info.hpp"
#include "font_weight.hpp"
#include "font_variant.hpp"
#include "font_metrics.hpp"
#include "font_char_map.hpp"
#include "../unicode/unicode.hpp"
#include "../i18n/i18n.hpp"
#include "../graphic_path/graphic_path.hpp"
#include "../utility/utility.hpp"
#include "../container/module.hpp"
#include <span>
#include <vector>
#include <map>
#include <string>
 
hi_export_module(hikogui.font.font);
 
namespace hi::inline v1 {
 
hi_export class font {
public:
    std::string family_name;
 
    std::string sub_family_name;
 
    bool monospace = false;
    bool serif = false;
    font_style style = font_style::normal;
    bool condensed = false;
    font_weight weight = font_weight::regular;
    float optical_size = 12.0;
 
    font_char_map char_map;
 
    std::string features;
 
    hi::font_metrics metrics;
 
    std::vector<hi::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]] glyph_id find_glyph(char32_t c) const noexcept
    {
        return char_map.find(c);
    }
 
    [[nodiscard]] lean_vector<glyph_id> find_glyph(grapheme g) const
    {
        // Create a glyph_ids object for a single grapheme.
        auto r = lean_vector<glyph_id>{};
 
        // First try composed normalization
        for (hilet c : g.composed()) {
            if (hilet glyph_id = find_glyph(c)) {
                r.push_back(glyph_id);
            } else {
                r.clear();
                break;
            }
        }
 
        if (r.empty()) {
            // Now try decomposed normalization
            for (hilet c : g.decomposed()) {
                if (hilet glyph_id = find_glyph(c)) {
                    r.push_back(glyph_id);
                } else {
                    r.clear();
                    break;
                }
            }
        }
 
        return r;
    }
 
    [[nodiscard]] virtual graphic_path get_path(hi::glyph_id glyph_id) const = 0;
 
    [[nodiscard]] virtual float get_advance(hi::glyph_id glyph_id) const = 0;
 
    [[nodiscard]] virtual glyph_metrics get_metrics(hi::glyph_id glyph_id) const = 0;
 
    struct shape_run_result_type {
        std::vector<float> advances;
 
        std::vector<size_t> glyph_count;
 
        std::vector<glyph_id> glyphs;
 
        std::vector<point2> glyph_positions;
 
        std::vector<aarectangle> glyph_rectangles;
 
        void reserve(size_t count) noexcept
        {
            advances.reserve(count);
            glyph_count.reserve(count);
            glyphs.reserve(count);
            glyph_positions.reserve(count);
            glyph_rectangles.reserve(count);
        }
 
        void scale_and_offset(float s) noexcept
        {
            auto S = scale2{s};
 
            for (auto& tmp : advances) {
                tmp = s * tmp;
            }
            for (auto& tmp : glyph_positions) {
                tmp = S * tmp;
            }
            for (auto& tmp : glyph_rectangles) {
                tmp = S * tmp;
            }
        }
    };
 
    [[nodiscard]] virtual shape_run_result_type shape_run(iso_639 language, iso_15924 script, gstring run) const = 0;
 
    glyph_atlas_info& atlas_info(glyph_id glyph) const
    {
        if (*glyph >= _glyph_atlas_table.size()) [[unlikely]] {
            _glyph_atlas_table.resize(*glyph + 1);
        }
 
        hi_axiom_bounds(*glyph, _glyph_atlas_table);
        return _glyph_atlas_table[*glyph];
    }
 
    [[nodiscard]] font_variant font_variant() const noexcept
    {
        return {weight, style};
    }
 
    [[nodiscard]] friend std::string to_string(font const& rhs) noexcept
    {
        return std::format(
            "{} - {}: style={}{}{}{}{}{}, features={}",
            rhs.family_name,
            rhs.sub_family_name,
            rhs.monospace ? 'M' : '_',
            rhs.serif ? 'S' : '_',
            rhs.style == font_style::italic ? 'I' : '_',
            rhs.condensed ? 'C' : '_',
            to_char(rhs.weight),
            rhs.optical_size,
            rhs.features);
    }
 
private:
    mutable std::vector<glyph_atlas_info> _glyph_atlas_table;
};
 
} // namespace hi::inline v1
 
template<typename CharT>
struct std::formatter<hi::font, CharT> : formatter<std::string_view, CharT> {
    auto format(hi::font const& t, auto& fc) const
    {
        return formatter<string_view, CharT>::format(to_string(t), fc);
    }
};