Button.h

Go to the documentation of this file.

#pragma once
 
#include "../UI/ComponentStackWidget.h"
#include "../Property.h"
#include "Registry.h"
 
namespace Gorgon { namespace Graphics { class Bitmap; } }
 
namespace Gorgon { namespace Widgets {
 
    class Button : public UI::ComponentStackWidget {
    public:
        Button(const Button &) = delete;
        
        explicit Button(std::string text, Registry::TemplateType type = Registry::Button_Regular) : 
            Button(Registry::Active()[type], text) 
        {
        }
        
        explicit Button(const char *text, Registry::TemplateType type = Registry::Button_Regular) : 
            Button(Registry::Active()[type], text) 
        {
        }
        
        explicit Button(Registry::TemplateType type = Registry::Button_Regular) : 
            Button(Registry::Active()[type], "") 
        {
        }
        
        template<class F_>
        explicit Button(F_ clickfn, Registry::TemplateType type = Registry::Button_Regular) : 
            Button(Registry::Active()[type], "", clickfn) 
        {
        }
        
        template<class F_>
        explicit Button(std::string text, F_ clickfn, Registry::TemplateType type = Registry::Button_Regular) : 
            Button(Registry::Active()[type], text, clickfn) 
        {
        }
        
        template<class F_>
        explicit Button(const char *text, F_ clickfn, Registry::TemplateType type = Registry::Button_Regular) : 
            Button(Registry::Active()[type], text, clickfn) 
        {
        }
 
        explicit Button(const UI::Template &temp, std::string text = "");
 
        Button(const UI::Template &temp, const char *text) : Button(temp, std::string(text)) { }
 
        template<class F_>
        Button(const UI::Template &temp, F_ clickfn) : Button(temp, "") {
            ClickEvent.Register(clickfn);
        }
 
        template<class F_>
        Button(const UI::Template &temp, std::string text, F_ clickfn) : Button(temp, text) {
            ClickEvent.Register(clickfn);
        }
 
        template<class F_>
        Button(const UI::Template &temp, const char *text, F_ clickfn) : Button(temp, std::string(text), clickfn) { }
        
        virtual ~Button();
        
        void SetText(const std::string &value);
 
        std::string GetText() const { return text; }
        
        void SetIcon(const Graphics::Bitmap &value);
        
        void SetIcon(const Graphics::Drawable &value);
        
 
        void SetIconProvider(const Graphics::AnimationProvider &value);
        
        void SetIconProvider(Graphics::AnimationProvider &&provider);
 
        void RemoveIcon();
        
        bool HasIcon() const { return icon != nullptr; }
        
        const Graphics::Drawable &GetIcon() const {
            if(!HasIcon())
                throw std::runtime_error("This widget has no icon.");
 
            return *icon;
        }
 
        void OwnIcon();
 
        void OwnIcon(const Graphics::Animation &value);
        
        void OwnIcon(Graphics::Bitmap &&value);
        
        void ActivateClickRepeat(int delay = 500, int repeat = 400, int accelerationtime = 2000, int minrepeat = 200);
        
        
        void DeactivateClickRepeat();
        
        virtual bool Activate() override;
        
        bool KeyEvent(Input::Key key, float state) override;
 
        TextualProperty<Button, std::string, &Button::GetText, &Button::SetText> Text;
 
        ObjectProperty<Button, const Graphics::Drawable, &Button::GetIcon, &Button::SetIcon> Icon;
        
        Event<Button> ClickEvent    = Event<Button>(this);
        Event<Button> PressEvent    = Event<Button>(this);
        Event<Button> ReleaseEvent  = Event<Button>(this);
        
    private:
        std::string text;
        const Graphics::Drawable         *icon     = nullptr;
        const Graphics::AnimationProvider  *iconprov = nullptr;
        bool ownicon    = false;
        bool spacedown  = false;
        bool mousedown  = false;
        
        enum repeatstate {
            repeatdisabled,
            repeatstandby,
            repeatondelay,
            repeating,
        };
        
        int             repeatdelay = 500;
        int             repeatinit  = 400;
        int             repeatacc   = 2000;
        int             repeatfin   = 400;
        int             repeatdiff  = -200;
        float           repeatcur   = 0;
        int             repeatleft  = -1;
        repeatstate     repeaten    = repeatdisabled;
        
    protected:
        virtual bool allowfocus() const override;
 
        void repeattick();
    };
    
} }