gui_font_string.hpp

#ifndef LXGUI_GUI_FONT_STRING_HPP
#define LXGUI_GUI_FONT_STRING_HPP
 
#include "lxgui/gui_layered_region.hpp"
#include "lxgui/gui_text.hpp"
#include "lxgui/lxgui.hpp"
#include "lxgui/utils.hpp"
 
namespace lxgui::gui {
 
enum class vertex_cache_strategy {
    always_disabled,
    prefer_enabled,
    always_enabled,
    automatic
};
 
class font_string : public layered_region {
public:
    using base = layered_region;
 
    explicit font_string(
        utils::control_block& block, manager& mgr, const region_core_attributes& attr);
 
    std::string serialize(const std::string& tab) const override;
 
    void render() const override;
 
    void copy_from(const region& obj) override;
 
    const std::string& get_font_name() const;
 
    float get_font_height() const;
 
    void set_outlined(bool outlined);
 
    bool is_outlined() const;
 
    alignment_x get_alignment_x() const;
 
    alignment_y get_alignment_y() const;
 
    const color& get_shadow_color() const;
 
    const vector2f& get_shadow_offset() const;
 
    const vector2f& get_offset() const;
 
    float get_spacing() const;
 
    float get_line_spacing() const;
 
    const color& get_text_color() const;
 
    void set_font(const std::string& font_name, float height);
 
    void set_alignment_x(alignment_x align_x);
 
    void set_alignment_y(alignment_y align_y);
 
    void set_shadow_color(const color& shadow_color);
 
    void set_shadow_offset(const vector2f& shadow_offset);
 
    void set_offset(const vector2f& offset);
 
    void set_spacing(float spacing);
 
    void set_line_spacing(float line_spacing);
 
    void set_text_color(const color& text_color);
 
    bool is_non_space_wrap_enabled() const;
 
    float get_string_height() const;
 
    float get_string_width() const;
 
    float get_string_width(const utils::ustring& content) const;
 
    const utils::ustring& get_text() const;
 
    void set_non_space_wrap_enabled(bool enabled);
 
    void enable_non_space_wrap() {
        set_non_space_wrap_enabled(true);
    }
 
    void disable_non_space_wrap() {
        set_non_space_wrap_enabled(false);
    }
 
    bool is_shadow_enabled() const;
 
    void set_shadow_enabled(bool enabled);
 
    void enable_shadow() {
        set_shadow_enabled(true);
    }
 
    void disable_shadow() {
        set_shadow_enabled(false);
    }
 
    void set_word_wrap_enabled(bool enabled);
 
    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 enabled);
 
    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 enabled);
 
    void enable_formatting() {
        set_formatting_enabled(true);
    }
 
    void disable_formatting() {
        set_formatting_enabled(false);
    }
 
    bool is_formatting_enabled() const;
 
    void set_vertex_cache_strategy(vertex_cache_strategy strategy);
 
    vertex_cache_strategy get_vertex_cache_strategy() const;
 
    void set_text(const utils::ustring& content);
 
    void notify_scaling_factor_updated() override;
 
    void parse_layout(const layout_node& node) override;
 
    text* get_text_object();
 
    const text* get_text_object() const;
 
    static void register_on_lua(sol::state& lua);
 
    static constexpr const char* class_name = "FontString";
 
private:
    void parse_attributes_(const layout_node& node) override;
    void parse_shadow_node_(const layout_node& node);
 
    const std::vector<std::string>& get_type_list_() const override;
 
    void create_text_object_();
    bool is_vertex_cache_used_() const;
 
    void update_borders_() override;
 
    std::unique_ptr<text> text_;
 
    utils::ustring content_;
    std::string    font_name_;
    float          height_ = 0.0f;
 
    float       spacing_      = 0.0f;
    float       line_spacing_ = 1.0f;
    alignment_x align_x_      = alignment_x::center;
    alignment_y align_y_      = alignment_y::middle;
    vector2f    offset_       = vector2f::zero;
 
    bool  is_outlined_            = false;
    bool  non_space_wrap_enabled_ = false;
    bool  word_wrap_enabled_      = true;
    bool  ellipsis_enabled_       = true;
    bool  formatting_enabled_     = true;
    color text_color_             = color::white;
 
    vertex_cache_strategy vertex_cache_strategy_ = vertex_cache_strategy::automatic;
 
    bool     is_shadow_enabled_ = false;
    color    shadow_color_      = color::black;
    vector2f shadow_offset_     = vector2f::zero;
};
 
} // namespace lxgui::gui
 
#endif