game/mario/gui/gui.hpp

#ifndef GUIELEMENTS
#define GUIELEMENTS

#include "../../sdlpp/sdlpp.hpp"
#include "../global_vars.hpp"
#include "../objectids.hpp"
#include <functional>
#include <mutex>
#include <utility>

struct ButtonConfig {
    std::string font_color;
    std::string font_outline_color;
    std::string bg_color;
    std::string font_color_highlight;
    std::string font_outline_color_highlight;
    std::string bg_color_highlight;
    std::string font_color_disabled;
    std::string font_outline_color_disabled;
    std::string bg_color_disabled;
    double outline;
};

class Button : public SDLPP::TextRenderer {
public:
    Button() = delete;
    Button(double x, double y, double w, double h,
           std::shared_ptr<SDLPP::Renderer> &r, const std::string &text,
           const ButtonConfig &config,
           std::function<void(void *, Button *)> click_fun, void *input)
            : TextRenderer(x, y, w, h, r, g_text_config->getFont(), text, config.font_color,
                           config.font_outline_color, config.outline),
              click_fun(std::move(click_fun)), func_input(input),
              config(config) {
        setColor(config.bg_color);
        setId(BUTTON_ID);
        addCollision(SDLPP::RectColider(0, 0, 1, 1));
    }
    void setFontColor(const std::string &color, std::mutex &mutex) {
        config.font_color = color;
        if(!highlighted && !disabled) {
            updateTextColor(config.font_color, config.font_outline_color, mutex);
        }
    }
    void setFontColorHighlight(const std::string &color, std::mutex &mutex) {
        config.font_color_highlight = color;
        if(highlighted && !disabled) {
            updateTextColor(config.font_color_highlight, config.font_outline_color_highlight, mutex);
        }
    }
    void setFontColorDisabled(const std::string &color, std::mutex &mutex) {
        config.font_color_disabled = color;
        if(disabled) {
            updateTextColor(config.font_color_disabled, config.font_outline_color_disabled, mutex);
        }
    }
    void setFontOutlineColor(const std::string &color, std::mutex &mutex) {
        config.font_outline_color = color;
        if(!highlighted && !disabled) {
            updateTextColor(config.font_color, config.font_outline_color, mutex);
        }
    }
    void setFontOutlineColorHighlight(const std::string &color, std::mutex &mutex) {
        config.font_outline_color_highlight = color;
        if(highlighted && !disabled) {
            updateTextColor(config.font_color_highlight, config.font_outline_color_highlight, mutex);
        }
    }
    void setFontOutlineColorDisabled(const std::string &color, std::mutex &mutex) {
        config.font_outline_color_disabled = color;
        if(disabled) {
            updateTextColor(config.font_color_disabled, config.font_outline_color_disabled, mutex);
        }
    }
    void setBackgroundColor(const std::string &color) {
        config.bg_color = color;
        if(!highlighted && !disabled) {
            setColor(color);
        }
    }
    void setBackgroundColorHighlight(const std::string &color) {
        config.bg_color_highlight = color;
        if(highlighted && !disabled) {
            setColor(color);
        }
    }
    void setBackgroundColorDisabled(const std::string &color) {
        config.bg_color_disabled = color;
        if(disabled) {
            setColor(color);
        }
    }
    void performFunction() {
        if(!disabled) {
            click_fun(func_input, this);
        }
    }
    uint64_t getButtonIndex() const {
        return _id;
    }
    void setButtonIndex(uint64_t id) {
        _id = id;
    }
    void setHighlight(std::mutex &mutex) {
        if(!disabled) {
            setColor(config.bg_color_highlight);
            updateTextColor(config.font_color_highlight, config.font_outline_color_highlight, mutex);
        }
        highlighted = true;
    }
    void unsetHighlight(std::mutex &mutex) {
        if(!disabled) {
            setColor(config.bg_color);
            updateTextColor(config.font_color, config.font_outline_color, mutex);
        }
        highlighted = false;
    }
    void disable(std::mutex &mutex) {
        setColor(config.bg_color_disabled);
        updateTextColor(config.font_color_disabled, config.font_outline_color_disabled, mutex);
        disabled = true;
    }
    void enable(std::mutex &mutex) {
        if(!highlighted) {
            setColor(config.bg_color);
            updateTextColor(config.font_color, config.font_outline_color, mutex);
        } else {
            setColor(config.bg_color_highlight);
            updateTextColor(config.font_color_highlight, config.font_outline_color_highlight, mutex);
        }
        disabled = false;
    }
private:
    void updateTextColor(const std::string &font, const std::string &outline, std::mutex &mutex) {
        std::lock_guard<std::mutex> textUpdate(mutex);
        setTextColor(g_text_config->getFont(), font, outline, config.outline);
    }

    std::function<void(void *, Button *)> click_fun;
    void *func_input;
    uint64_t _id{};
    ButtonConfig config{};
    bool highlighted = false;
    bool disabled = false;
};

/*std::shared_ptr<SDLPP::RectangleRender>
createButton(double x, double y, double w, double h,
             std::shared_ptr<SDLPP::Renderer> &r, const std::string &text,
             const std::string &color, const std::string &outline_color,
             const std::string &background_color,
             std::function<void(void *)> click_fun, void *input);*/

#endif