Inputbox.h

Go to the documentation of this file.

#pragma once
 
#include <functional>
#include <string>
 
#include "../Event.h"
#include "../Property.h"
#include "../UI/Validators.h"
#include "../UI/ComponentStackWidget.h"
#include "../UI/Helpers.h"
#include "../Input/KeyRepeater.h"
#include "Registry.h"
 
namespace Gorgon { namespace Widgets {
    
    namespace internal {        
        class Inputbox_base : public UI::ComponentStackWidget {
        protected:
            Inputbox_base(const UI::Template &temp);
            
            //for keeping selection both in bytes and glyphs
            struct glyphbyte {
                int glyph, byte;
 
                glyphbyte &operator +=(const glyphbyte &other) {
                    glyph += other.glyph;
                    byte += other.byte;
 
                    return *this;
                }
 
                glyphbyte operator +(const glyphbyte &other) const {
                    return {glyph + other.glyph, byte + other.byte};
                }
            };
                
            static constexpr int allselected = std::numeric_limits<int>::max();
 
            
        public:
                
            int Length() const {
                return glyphcount;
            }
            
            std::string GetText() const {
                return display;
            }
            
            std::string GetSelectedText() const {
                if(sellen.byte < 0)
                    return display.substr(selstart.byte + sellen.byte, -sellen.byte);
                else if(sellen.byte > 0)
                    return display.substr(selstart.byte, sellen.byte);
                else
                    return "";
            }
            
            
            void SelectAll() {
                selstart = {0, 0};
                sellen = {allselected, allselected};
                updateselection();
            }
            
            void SelectNone() {
                sellen = {0, 0};
                updateselection();
            }
            
            int SelectionStart() const {
                return selstart.glyph;
            }
            
            int SelectionLength() const {
                return sellen.glyph;
            }
            
            int CaretLocation() const {
                return selstart.glyph + sellen.glyph;
            }
            
                
            
            bool Activate() override {
                return Focus();
            }
            
            bool Done() override;
            
            bool CharacterEvent(Gorgon::Char c) override;
            
            virtual bool KeyEvent(Input::Key key, float state) override;
 
            virtual void SetEnabled(bool value) override {
                ComponentStackWidget::SetEnabled(value);
 
                if(readonly) {
                    if(!value) {
                        stack.RemoveCondition(UI::ComponentCondition::Readonly);
                    }
                    else {
                        stack.AddCondition(UI::ComponentCondition::Readonly);
                    }
                }
            }
            
            void SetAutoSelectAll(const bool &value) {
                autoselectall = value;
                if(!IsFocused() && value) {
                    SelectAll();
                }
            }
            
            bool GetAutoSelectAll() const {
                return autoselectall;
            }
 
            void SetBlockEnterKey(const bool &value) {
                blockenter = value;
            }
 
            bool GetBlockEnterKey() const {
                return blockenter;
            }
 
            void SetReadonly(const bool &value) {
                if(value == readonly)
                    return;
 
                readonly = value;
 
                if(readonly && IsEnabled()) {
                    stack.AddCondition(UI::ComponentCondition::Readonly);
                }
                else {
                    stack.RemoveCondition(UI::ComponentCondition::Readonly);
                }
            }
 
            bool GetReadonly() const {
                return readonly;
            }
            
            BooleanProperty< Inputbox_base, bool, 
                            &Inputbox_base::GetAutoSelectAll, 
                            &Inputbox_base::SetAutoSelectAll> AutoSelectAll;
            
            BooleanProperty< Inputbox_base, bool, 
                            &Inputbox_base::GetBlockEnterKey, 
                            &Inputbox_base::SetBlockEnterKey> BlockEnterKey;
                            
            BooleanProperty< Inputbox_base, bool, 
                            &Inputbox_base::GetReadonly, 
                            &Inputbox_base::SetReadonly> Readonly;
                            
            
        protected:
                
            void updateselection();
            
            virtual void updatevalue() = 0;
            
            virtual void updatevaluedisplay(bool updatedisplay = true) = 0;
            
            virtual void changed() = 0;
            
            void moveselleft() {
                if(selstart.glyph > 0) {
                    selstart.glyph--;
                    selstart.byte--;
 
                    //if previous byte is unicode continuation point, go further before
                    while(selstart.byte && (display[selstart.byte] & 0b11000000) == 0b10000000)
                        selstart.byte--;
                }
            }
 
            void moveselright() {
                if(selstart.glyph < glyphcount) {
                    selstart.glyph++;
                    selstart.byte += String::UTF8Bytes(display[selstart.byte]);
                }
            }
 
            void eraseselected() {
                if(sellen.byte < 0) {
                    dirty = true;
 
                    int pos = selstart.byte + sellen.byte;
 
                    display.erase(pos, -sellen.byte);
 
                    glyphcount += sellen.glyph;
                    selstart += sellen;
                    sellen = {0, 0};
                }
                else if(sellen.byte > 0) {
                    dirty = true;
 
                    int pos = selstart.byte;
 
                    display.erase(pos, sellen.byte);
 
                    glyphcount -= sellen.glyph;
                    sellen = {0, 0};
 
                    updatevaluedisplay(false);
                    updateselection();
                }
            }
            
            void focuslost() override;
            
            void focused() override;
            
            void mousedown(UI::ComponentTemplate::Tag tag, Geometry::Point location, Input::Mouse::Button button);
            
            void mouseup(UI::ComponentTemplate::Tag tag, Geometry::Point location, Input::Mouse::Button button);
            
            void mousemove(UI::ComponentTemplate::Tag tag, Geometry::Point location);
 
            
            std::string display;
 
            glyphbyte selstart = {0, 0};
            glyphbyte sellen   = {0, 0};
            int glyphcount = 0;
            int pglyph = 0;
            int scrolloffset = 0;
            
            bool ismousedown = false;
            bool autoselectall = false;
            bool blockenter = false;
            bool readonly = false;
            bool dirty = false;
        
            Input::KeyRepeater repeater;
            
        };
    }
    
    /*template<class V_>
    struct validatorextras {
    protected:
        void transfer(V_ &) {
        }
    };
    
    class StringValidator {
    public:
        
        void SetMaxChars(int value) {
            maxchars = value;
        }
        
        
    private:
        int maxchars = 0;
    };
    
    template<>
    struct validatorextras<StringValidor> {
        void SetMaxChars(int value) {
            maxchars = value;
        }
        
        int GetMaxChars() const {
            return maxchars;
        }
    
    protected:
        void transfer(V_ &validator) {
            validator.SetMaxChars(maxchars);
        }
        
    private:
        int maxchars = 0;
    };
    //derive from validator extras and class transfer
    */
    
    template<class T_, class V_ = UI::ConversionValidator<T_>, template<class C_, class PT_, PT_(C_::*Getter_)() const, void(C_::*Setter_)(const PT_ &)> class P_ = Gorgon::Property, Widgets::Registry::TemplateType DEFTMP_ = Widgets::Registry::Inputbox_Regular>
    class Inputbox : 
        public internal::Inputbox_base, 
        public P_<UI::internal::prophelper<Inputbox<T_, V_, P_>, T_>, T_, &UI::internal::prophelper<Inputbox<T_, V_, P_>, T_>::get_, &UI::internal::prophelper<Inputbox<T_, V_, P_>, T_>::set_> {
 
 
    public:
        
        using Type     = T_;
        using PropType = P_<UI::internal::prophelper<Inputbox<T_, V_, P_>, T_>, T_, &UI::internal::prophelper<Inputbox<T_, V_, P_>, T_>::get_, &UI::internal::prophelper<Inputbox<T_, V_, P_>, T_>::set_>;
 
        friend class P_<UI::internal::prophelper<Inputbox<T_, V_, P_>, T_>, T_, &UI::internal::prophelper<Inputbox<T_, V_, P_>, T_>::get_, &UI::internal::prophelper<Inputbox<T_, V_, P_>, T_>::set_>;
        template<class T1_, class V1_, template<class C_, class PT_, PT_(C_::*Getter_)() const, void(C_::*Setter_)(const PT_&)> class P1_, Widgets::Registry::TemplateType DEFTMP1_>
        friend class Inputbox;
        friend struct UI::internal::prophelper<Inputbox<T_, V_, P_>, T_>;
        
        explicit Inputbox(const UI::Template &temp, T_ value = T_()) : 
        internal::Inputbox_base(temp), PropType(&helper), value(value)
        {
            display = validator.ToString(value);
            
            updatevaluedisplay();
            updateselection();
        }
        
        explicit Inputbox(const UI::Template &temp, std::function<void()> changedevent) : Inputbox(temp) {
            ChangedEvent.Register(changedevent);
        }
        
        explicit Inputbox(const UI::Template &temp, T_ value, std::function<void()> changedevent) : Inputbox(temp, value)
        {
            ChangedEvent.Register(changedevent);
        }
        
        explicit Inputbox(T_ value = T_(), Registry::TemplateType type = DEFTMP_) : 
        Inputbox(Registry::Active()[type], value) { }
        
        explicit Inputbox(std::function<void()> changedevent, Registry::TemplateType type = DEFTMP_) : 
        Inputbox(Registry::Active()[type], changedevent) { }
        
        explicit Inputbox(T_ value, std::function<void()> changedevent, Registry::TemplateType type = DEFTMP_) : 
        Inputbox(Registry::Active()[type], value, changedevent) { }
        
        Inputbox &operator =(const T_ value) {
            set(value);
            
            return *this;
        }
        
        Inputbox &operator =(const Inputbox &value) {
            set(value.Get());
            
            return *this;
        }
        
        
        operator T_() const {
            return value;
        }
        
        Event<Inputbox, const T_ &> ChangedEvent = Event<Inputbox, const T_ &>{this};
        
        Event<Inputbox> EditedEvent = Event<Inputbox>{this};
        
        
    protected:
        
        T_ get() const {
            return value;
        }
        
        void set(const T_ &val) {
            if(value == val)
                return;
            
            value = val;
            
            updatevaluedisplay();
            updateselection();
 
            dirty = false;
        }
 
        void updatevalue() override {
            value = validator.From(display);
            
            EditedEvent();
        }
        
        void changed() override {
            ChangedEvent(value);
        }
            
        void updatevaluedisplay(bool updatedisplay = true) override {
            if(updatedisplay) {
                display = validator.ToString(value);
                glyphcount = String::UnicodeGlyphCount(display);
            }
            
            stack.SetData(UI::ComponentTemplate::Text, display);
        }
        
        
    private:
        V_ validator;
        T_ value;
 
        struct UI::internal::prophelper<Inputbox<T_, V_, P_>, T_> helper = UI::internal::prophelper<Inputbox<T_, V_, P_>, T_>(this);
    };
    
    
} }