KeyRepeater.h

Go to the documentation of this file.

#pragma once
 
#include <map>
#include <set>
 
#include "../Event.h"
#include "../Animation.h"
#include "Keyboard.h"
 
namespace Gorgon { namespace Input {
 
    namespace internal {
        struct eventunregisterhelper {
            virtual ~eventunregisterhelper() { }
            virtual void unregister() = 0;
        };
 
        template<class T_>
        struct eventunregisterer : public eventunregisterhelper {
            eventunregisterer(T_ &event, EventToken token) : event(event), token(token) {
            }
 
            virtual void unregister() override {
                event.Unregister(token);
            }
 
            T_ &event;
            EventToken token;
        };
    }
 
    class KeyRepeater : public Animation::Base {
    public:
 
        KeyRepeater() : Base(true) { }
        
        template<class E_>
        KeyRepeater(E_ &event, const std::initializer_list<Key> &keys, int delay = 100);
 
        KeyRepeater(const std::initializer_list<Key> &keys, int delay = 100);
 
        KeyRepeater(const KeyRepeater &) = delete;
 
        ~KeyRepeater() {
            if(token)
                token->unregister();
 
            delete token;
        }
        
        template<class E_>
        void RegisterTo(E_ &event, bool ignoremodified = false) {
            UnregisterFrom();
            
            token = new internal::eventunregisterer<E_>(
                event,
                event.Register(this, &KeyRepeater::KeyEvent)
            );
        }
        
        void UnregisterFrom() {
            if(token)
                token->unregister();
            
            delete token;
            token = nullptr;
        }
 
        void Register(Key key) {
            registeredkeys.insert(key);
        }
        
        template<class ... T_>
        void Register(Key key, T_ &&... args) {
            registeredkeys.insert(key);
            
            this->Register(std::forward<T_>(args)...);
        }
        
        
        void Unregister(Key key) {
            Release(key);
            registeredkeys.erase(key);
        }
        
        bool IsKeyRegistered(Key key) const {
            return registeredkeys.count(key) != 0;
        }
 
        void Press(Key key);
 
        void Release(Key key);
 
        bool IsPressed(Key key) const {
            return pressedkeys.count(key) != 0;
        }
        
        void SetRepeatOnPress(bool value) {
            repeatonpress = value;
        }
        
        bool GetRepeatOnPress() const {
            return repeatonpress;
        }
 
        void SetRepeatOnRelease(bool value) {
            repeatonrelease = value;
        }
        
        bool GetRepeatOnRelease() const {
            return repeatonrelease;
        }
 
        void SetInitialDelay(int value) {
            initialdelay = value;
        }
        
        bool GetInitialDelay() const {
            return initialdelay;
        }
 
        void SetDelay(int value) {
            delay = value;
        }
        
        int GetDelay() const {
            return delay;
        }
 
        void SetAcceleration(int value) {
            acceleration = value;
        }
        
        int GetAcceleration() const {
            return acceleration;
        }
        
        void SetAccelerationStart(int value) {
            accelerationstart = value;
        }
        
        int GetAccelerationStart() const {
            return accelerationstart;
        }
 
        void SetAccelerationCount(int value) {
            accelerationcount = value;
        }
 
        int GetAccelerationCount() const {
            return accelerationcount;
        }
        
        int GetFinalDelay() const {
            return delay - accelerationcount * acceleration;
        }
        
        void SetupAcceleration(int startdelay, int finaldelay, int rampup);
 
        virtual bool Progress(unsigned &) override;
 
        virtual int GetDuration() const override { return 0; }
        
        virtual void SetController(Animation::ControllerBase &controller) override {
            Animation::Base::SetController(controller);
            
            lastprogress = controller.GetProgress();
        }
        
        bool KeyEvent(Key &key, float amount);
        
        Event<KeyRepeater, Key> Repeat = Event<KeyRepeater, Key>{this};
 
    private:
        
        struct repeatinfo {
            int delay      = 0;
            int count      = 0;
        };
 
        internal::eventunregisterhelper *token = nullptr;
 
        std::map<Key, repeatinfo> pressedkeys;
        
        std::set<Key> registeredkeys;
        
        
        bool repeatonpress    = true;
        
        bool repeatonrelease  = false;
        
        int initialdelay      = 500;
        
        int delay             = 100;
        
        int acceleration      = 0;
        
        int accelerationcount = 0;
        
        int accelerationstart = 0;
        
        unsigned lastprogress = 0;
    };
 
    template<class E_>
    KeyRepeater::KeyRepeater(E_ &event, const std::initializer_list<Key> &keys, int delay) : Base(true) { 
        RegisterTo(event);
        
        for(auto key : keys)
            Register(key);
        
        SetDelay(delay);
    }
 
 
} }