gui_text.hpp

#ifndef LXGUI_GUI_TEXT_HPP
#define LXGUI_GUI_TEXT_HPP
 
#include "lxgui/gui_color.hpp"
#include "lxgui/gui_font.hpp"
#include "lxgui/gui_matrix4.hpp"
#include "lxgui/gui_quad.hpp"
#include "lxgui/lxgui.hpp"
#include "lxgui/utils.hpp"
#include "lxgui/utils_maths.hpp"
#include "lxgui/utils_string.hpp"
 
#include <array>
#include <limits>
#include <memory>
#include <vector>
 
namespace lxgui::gui {
 
class renderer;
class vertex_cache;
struct vertex;
 
enum class alignment_x { left, center, right };
 
enum class alignment_y { top, middle, bottom };
 
class text {
public:
    explicit text(
        renderer&                   rdr,
        std::shared_ptr<const font> fnt,
        std::shared_ptr<const font> outline_fnt = nullptr);
 
    // Non-copiable, non-movable
    text(const text&) = delete;
    text(text&&)      = delete;
    text& operator=(const text&) = delete;
    text& operator=(text&&) = delete;
 
    float get_line_height() const;
 
    void set_scaling_factor(float scaling_factor);
 
    float get_scaling_factor() const;
 
    void set_text(const utils::ustring& content);
 
    const utils::ustring& get_text() const;
 
    void set_color(const color& c, bool force_color = false);
 
    const color& get_color() const;
 
    void set_alpha(float alpha);
 
    float get_alpha() const;
 
    void set_box_dimensions(float box_width, float box_height);
 
    void set_box_width(float box_width);
 
    void set_box_height(float box_height);
 
    float get_width() const;
 
    float get_height() const;
 
    float get_box_width() const;
 
    float get_box_height() const;
 
    float get_text_width() const;
 
    std::size_t get_line_count() const;
 
    float get_string_width(const std::string& content) const;
 
    float get_string_width(const utils::ustring& content) const;
 
    float get_character_width(char32_t c) const;
 
    float get_character_kerning(char32_t c1, char32_t c2) const;
 
    float get_text_height() const;
 
    void set_alignment_x(alignment_x align_x);
 
    void set_alignment_y(alignment_y align_y);
 
    alignment_x get_alignment_x() const;
 
    alignment_y get_alignment_y() const;
 
    void set_tracking(float tracking);
 
    float get_tracking() const;
 
    void set_line_spacing(float line_spacing);
 
    float get_line_spacing() const;
 
    void set_remove_starting_spaces(bool remove_starting_spaces);
 
    bool get_remove_starting_spaces() const;
 
    void set_word_wrap_enabled(bool wrap);
 
    void enable_word_wrap() {
        set_word_wrap_enabled(true);
    }
 
    void disable_word_wrap() {
        set_word_wrap_enabled(false);
    }
 
    bool is_word_wrap_enabled() const;
 
    void set_word_ellipsis_enabled(bool add_ellipsis);
 
    void enable_word_ellipsis() {
        set_word_ellipsis_enabled(true);
    }
 
    void disable_word_ellipsis() {
        set_word_ellipsis_enabled(false);
    }
 
    bool is_word_ellipsis_enabled() const;
 
    void set_formatting_enabled(bool formatting);
 
    void enable_formatting() {
        set_formatting_enabled(true);
    }
 
    void disable_formatting() {
        set_formatting_enabled(false);
    }
 
    void render(const matrix4f& transform = matrix4f::identity) const;
 
    std::size_t get_letter_count() const;
 
    const std::array<vertex, 4>& get_letter_quad(std::size_t index) const;
 
    quad create_letter_quad(char32_t c) const;
 
    void set_use_vertex_cache(bool use_vertex_cache);
 
    bool get_use_vertex_cache() const;
 
    const renderer& get_renderer() const {
        return renderer_;
    }
 
    renderer& get_renderer() {
        return renderer_;
    }
 
private:
    void update_() const;
    void update_vertex_cache_() const;
    bool use_vertex_cache_() const;
    void notify_cache_dirty_() const;
    void notify_vertex_cache_dirty_() const;
 
    float round_to_pixel_(
        float value, utils::rounding_method method = utils::rounding_method::nearest) const;
 
    std::array<vertex, 4> create_letter_quad_(const gui::font& font, char32_t c) const;
    std::array<vertex, 4> create_letter_quad_(char32_t c) const;
    std::array<vertex, 4> create_outline_letter_quad_(char32_t c) const;
 
    renderer& renderer_;
 
    float       scaling_factor_         = 1.0f;
    float       tracking_               = 0.0f;
    float       line_spacing_           = 1.0f;
    bool        remove_starting_spaces_ = false;
    bool        word_wrap_enabled_      = true;
    bool        ellipsis_enabled_       = false;
    color       color_                  = color::white;
    bool        force_color_            = false;
    float       alpha_                  = 1.0f;
    bool        formatting_enabled_     = false;
    float       box_width_              = std::numeric_limits<float>::infinity();
    float       box_height_             = std::numeric_limits<float>::infinity();
    alignment_x align_x_                = alignment_x::left;
    alignment_y align_y_                = alignment_y::middle;
 
    std::shared_ptr<const font> font_;
    std::shared_ptr<const font> outline_font_;
    utils::ustring              unicode_text_;
 
    mutable bool        update_cache_flag_ = false;
    mutable float       width_             = 0.0f;
    mutable float       height_            = 0.0f;
    mutable std::size_t num_lines_         = 0u;
 
    bool                                       use_vertex_cache_flag_    = false;
    mutable bool                               update_vertex_cache_flag_ = false;
    mutable std::vector<std::array<vertex, 4>> quad_list_;
    mutable std::shared_ptr<vertex_cache>      vertex_cache_;
    mutable std::vector<std::array<vertex, 4>> outline_quad_list_;
    mutable std::shared_ptr<vertex_cache>      outline_vertex_cache_;
    mutable std::vector<quad>                  icons_list_;
};
 
} // namespace lxgui::gui
 
#endif