gui_button.hpp

#ifndef LXGUI_GUI_BUTTON_HPP
#define LXGUI_GUI_BUTTON_HPP
 
#include "lxgui/gui_frame.hpp"
#include "lxgui/lxgui.hpp"
#include "lxgui/utils.hpp"
#include "lxgui/utils_string.hpp"
 
#include <string>
 
namespace lxgui::gui {
 
class texture;
class font_string;
 
class button : public frame {
public:
    using base = frame;
 
    enum class state { up, down, disabled };
 
    explicit button(utils::control_block& block, manager& mgr, const frame_core_attributes& attr);
 
    std::string serialize(const std::string& tab) const override;
 
    bool can_use_script(const std::string& script_name) const override;
 
    void
    fire_script(const std::string& script_name, const event_data& data = event_data{}) override;
 
    void copy_from(const region& obj) override;
 
    void set_text(const utils::ustring& content);
 
    const utils::ustring& get_text() const;
 
    const utils::observer_ptr<texture>& get_normal_texture() {
        return normal_texture_;
    }
 
    utils::observer_ptr<const texture> get_normal_texture() const {
        return normal_texture_;
    }
 
    const utils::observer_ptr<texture>& get_pushed_texture() {
        return pushed_texture_;
    }
 
    utils::observer_ptr<const texture> get_pushed_texture() const {
        return pushed_texture_;
    }
 
    const utils::observer_ptr<texture>& get_disabled_texture() {
        return disabled_texture_;
    }
 
    utils::observer_ptr<const texture> get_disabled_texture() const {
        return disabled_texture_;
    }
 
    const utils::observer_ptr<texture>& get_highlight_texture() {
        return highlight_texture_;
    }
 
    utils::observer_ptr<const texture> get_highlight_texture() const {
        return highlight_texture_;
    }
 
    const utils::observer_ptr<font_string>& get_normal_text() {
        return normal_text_;
    }
 
    utils::observer_ptr<const font_string> get_normal_text() const {
        return normal_text_;
    }
 
    const utils::observer_ptr<font_string>& get_highlight_text() {
        return highlight_text_;
    }
 
    utils::observer_ptr<const font_string> get_highlight_text() const {
        return highlight_text_;
    }
 
    const utils::observer_ptr<font_string>& get_disabled_text() {
        return disabled_text_;
    }
 
    utils::observer_ptr<const font_string> get_disabled_text() const {
        return disabled_text_;
    }
 
    const utils::observer_ptr<font_string>& get_current_font_string() {
        return current_font_string_;
    }
 
    utils::observer_ptr<const font_string> get_current_font_string() const {
        return current_font_string_;
    }
 
    void set_normal_texture(utils::observer_ptr<texture> tex);
 
    void set_pushed_texture(utils::observer_ptr<texture> tex);
 
    void set_disabled_texture(utils::observer_ptr<texture> tex);
 
    void set_highlight_texture(utils::observer_ptr<texture> tex);
 
    void set_normal_text(utils::observer_ptr<font_string> fstr);
 
    void set_highlight_text(utils::observer_ptr<font_string> fstr);
 
    void set_disabled_text(utils::observer_ptr<font_string> fstr);
 
    void set_enabled(bool enabled) {
        if (enabled) {
            enable();
        } else {
            disable();
        }
    }
 
    virtual void disable();
 
    virtual void enable();
 
    bool is_enabled() const;
 
    virtual void push();
 
    virtual void release();
 
    void click(const std::string& mouse_event);
 
    void click(input::mouse_button button_id, input::mouse_button_event button_event);
 
    virtual void highlight();
 
    virtual void unlight();
 
    state get_button_state() const;
 
    void lock_highlight();
 
    void unlock_highlight();
 
    void set_pushed_text_offset(const vector2f& offset);
 
    const vector2f& get_pushed_text_offset() const;
 
    void set_button_clicks_enabled(const std::string& mouse_event, bool enable) {
        if (enable) {
            enable_button_clicks(mouse_event);
        } else {
            disable_button_clicks(mouse_event);
        }
    }
 
    void set_button_clicks_enabled(
        input::mouse_button button_id, input::mouse_button_event button_event, bool enable) {
        if (enable) {
            enable_button_clicks(button_id, button_event);
        } else {
            disable_button_clicks(button_id, button_event);
        }
    }
 
    void enable_button_clicks(const std::string& mouse_event);
 
    void
    enable_button_clicks(input::mouse_button button_id, input::mouse_button_event button_event);
 
    void disable_button_clicks(const std::string& mouse_event);
 
    void
    disable_button_clicks(input::mouse_button button_id, input::mouse_button_event button_event);
 
    void disable_button_clicks();
 
    bool is_button_clicks_enabled(const std::string& mouse_event) const;
 
    bool is_button_clicks_enabled(
        input::mouse_button button_id, input::mouse_button_event button_event) const;
 
    static void register_on_lua(sol::state& lua);
 
    static constexpr const char* class_name = "Button";
 
protected:
    void parse_attributes_(const layout_node& node) override;
    void parse_all_nodes_before_children_(const layout_node& node) override;
 
    bool is_button_clicks_enabled_(input::mouse_button button_id) const;
 
    virtual void click_(
        input::mouse_button button_id, input::mouse_button_event button_event, float mx, float my);
 
    const std::vector<std::string>& get_type_list_() const override;
 
    state state_               = state::up;
    bool  is_highlighted_      = false;
    bool  is_highlight_locked_ = false;
 
    utils::ustring content_;
 
    utils::observer_ptr<texture> normal_texture_    = nullptr;
    utils::observer_ptr<texture> pushed_texture_    = nullptr;
    utils::observer_ptr<texture> disabled_texture_  = nullptr;
    utils::observer_ptr<texture> highlight_texture_ = nullptr;
 
    utils::observer_ptr<font_string> normal_text_         = nullptr;
    utils::observer_ptr<font_string> highlight_text_      = nullptr;
    utils::observer_ptr<font_string> disabled_text_       = nullptr;
    utils::observer_ptr<font_string> current_font_string_ = nullptr;
 
    vector2f pushed_text_offset_ = vector2f::zero;
 
    std::set<std::string> reg_click_list_;
};
 
} // namespace lxgui::gui
 
#endif