text_shaper_char.hpp

// Copyright Take Vos 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 "text_style.hpp"
#include "../font/font.hpp"
#include "../unicode/unicode.hpp"
#include "../geometry/module.hpp"
#include "../macros.hpp"
 
namespace hi::inline v1 {
 
class text_shaper_char {
public:
    hi::grapheme grapheme;

    hi::text_style style;

    float dpi_scale = 1.0f;

    hi::font_book::font_glyphs_type glyphs;

    hi::glyph_metrics metrics;

    size_t line_nr;

    size_t column_nr;

    point2 position;

    aarectangle rectangle;

    unicode_general_category general_category;

    unicode_bidi_class direction;

    iso_15924 script;

    float scale = 1.0f;

    float width = 0.0f;

    bool is_trailing_white_space = false;

    bool glyph_is_initial = false;
 
    [[nodiscard]] text_shaper_char(hi::grapheme const& grapheme, text_style const& style, float dpi_scale) noexcept :
        grapheme(grapheme),
        style(style),
        dpi_scale(dpi_scale),
        line_nr(std::numeric_limits<size_t>::max()),
        column_nr(std::numeric_limits<size_t>::max()),
        general_category(ucd_get_general_category(grapheme.starter()))
    {
    }

    void initialize_glyph(hi::font const& font) noexcept
    {
        if (not glyph_is_initial) {
            set_glyph(find_glyph(font, grapheme));
 
            width = metrics.advance;
            glyph_is_initial = true;
        }
    }

    void initialize_glyph() noexcept
    {
        return initialize_glyph(find_font(style->family_id, style->variant));
    }

    void replace_glyph(char32_t code_point) noexcept
    {
        hi_axiom_not_null(glyphs.font);
        hilet& font = *glyphs.font;
        set_glyph(font_book::font_glyphs_type{font, font.find_glyph(code_point)});
 
        glyph_is_initial = false;
    }

    [[nodiscard]] hi::font_metrics font_metrics() const noexcept
    {
        hi_axiom_not_null(glyphs.font);
        return scale * glyphs.font->metrics;
    }
 
    [[nodiscard]] friend bool operator==(text_shaper_char const& lhs, char32_t const& rhs) noexcept
    {
        return lhs.grapheme == rhs;
    }
 
    [[nodiscard]] friend bool operator==(text_shaper_char const& lhs, char const& rhs) noexcept
    {
        return lhs.grapheme == rhs;
    }
 
private:
    void set_glyph(hi::font_book::font_glyphs_type&& new_glyphs) noexcept
    {
        glyphs = std::move(new_glyphs);
        hi_axiom_not_null(glyphs.font);
        scale = glyphs.get_font_metrics().round_scale(dpi_scale * style->size);
        metrics = scale * glyphs.get_starter_metrics();
    }
};
 
} // namespace hi::inline v1