Inputable.h

#ifndef Inputable_H
#define Inputable_H
 
#include "AzulCore.h"
#include "KeyboardEventManager.h"
#include "../EventType.h"
#include "../RegistrationState.h"
 
class KeyRegistrationCommand;
class KeyDeregistrationCommand;
class MouseKeyRegistrationCommand;
class MouseKeyDeregistrationCommand;

class Inputable
{
protected:
    Inputable() = default;
    Inputable(const Inputable&) = delete;
    Inputable& operator=(const Inputable&) = delete;
    virtual ~Inputable();

    void SubmitKeyRegistration(AZUL_KEY k, EventType e);

    void SubmitKeyDeregistration(AZUL_KEY k, EventType e);

    void SubmitMouseKeyRegistration(AZUL_MOUSE m, EventType e);

    void SubmitMouseKeyDeregistration(AZUL_MOUSE m, EventType e);
 
private:
    friend class InputableAttorney;

    struct RegistrationData
    {
        KeyboardEventManager::StorageMapRef pMyDeleteRef;
        RegistrationState RegStateCurr = RegistrationState::CURRENTLY_DEREGISTERED;
        KeyRegistrationCommand* pKeyRegistrationCommand = nullptr;
        KeyDeregistrationCommand* pKeyDeregistrationCommand = nullptr;
    };

    struct MouseRegistrationData
    {
        KeyboardEventManager::StorageMapMouseRef pMyDeleteRef;
        RegistrationState RegStateCurr = RegistrationState::CURRENTLY_DEREGISTERED;
        MouseKeyRegistrationCommand* pKeyRegistrationCommand = nullptr;
        MouseKeyDeregistrationCommand* pKeyDeregistrationCommand = nullptr;
    };

    struct KeyEventPair
    {
        AZUL_KEY key;
        EventType eventType;

        bool operator<(const KeyEventPair& other) const
        {
            return std::tie(key, eventType) < std::tie(other.key, other.eventType);
        };
    };

    struct MouseKeyEventPair
    {
        AZUL_MOUSE key;
        EventType eventType;

        bool operator<(const MouseKeyEventPair& other) const
        {
            return std::tie(key, eventType) < std::tie(other.key, other.eventType);
        };
    };

    using KeyMap = std::map<KeyEventPair, RegistrationData*>;

    using MouseKeyMap = std::map<MouseKeyEventPair, MouseRegistrationData*>;

    using KeyMapIt = KeyMap::iterator;

    using MouseKeyMapIt = MouseKeyMap::iterator;

    KeyMap keyMap;

    MouseKeyMap mouseKeyMap;

    virtual void KeyInactive(AZUL_KEY k) { k; };

    virtual void KeyPress(AZUL_KEY k) { k; };

    virtual void KeyHeld(AZUL_KEY k) { k; };

    virtual void KeyRelease(AZUL_KEY k) { k; };

    virtual void MouseInactive(AZUL_MOUSE m) { m; };

    virtual void MousePress(AZUL_MOUSE m) { m; };

    virtual void MouseHeld(AZUL_MOUSE m) { m; };

    virtual void MouseRelease(AZUL_MOUSE m) { m; };

    void KeyRegistration(AZUL_KEY k, EventType e);

    void KeyDeregistration(AZUL_KEY k, EventType e);

    void MouseKeyRegistration(AZUL_MOUSE m, EventType e);

    void MouseKeyDeregistration(AZUL_MOUSE m, EventType e);
};
 
#endif