fsIInputManager.h

Go to the documentation of this file.

/********************************************************************
*
*       Created:        3/3/2014   16:26
*
*       File:           fsIInputManager.h
*
*       Author:         Mick Waites
*       
*       Purpose:        Generating events from user input and pushing the
*                               events to any listeners.
*
*********************************************************************/
 
#ifndef fsIInputManagerhdr
#define fsIInputManagerhdr
 
#include <vector>
 
#include <fsCore/fsPoint.h>
#include <fsCore/src/fsTSingletonBackend.h>
 
#include "fsIMessageDispatcher.h"
#include "fsINode.h"
 
class fsCInputPoint;
class fsCEntity;
class fsCInputSession;
class fsCTextEntryComponent;
class fsCTextEntry;
 
class fsIInputManager : public fsIMessageDispatcher, public fsTSingletonBackend<fsIInputManager>
{
        friend class fsTSingletonBackend<fsIInputManager>;
 
public:
 
    void ondDPADClickEvent(fsPoint pPos, fsBool pDown);
        enum
        {
                eKEY_CODE_ENTER = 13,
                eKEY_CODE_BACKSPACE = '\b',
                eKEY_CODE_CURSOR_LEFT = 26,
                eKEY_CODE_CURSOR_RIGHT = 27,
                eKEY_CODE_CURSOR_UP = 28,
                eKEY_CODE_CURSOR_DOWN = 29,
 
                eKEY_DPAD_LEFT = 30,
                eKEY_DPAD_RIGHT = 31,
                eKEY_DPAD_UP = 32,
                eKEY_DPAD_DOWN = 33,
                eKEY_DPAD_CENTRE = 34,
 
        };
 
        static fsBool DPADKey(fsS32 pKeyCode)
        {
                return (eKEY_DPAD_LEFT <= pKeyCode) && (pKeyCode <= eKEY_DPAD_CENTRE);
 
        }
 
        enum
        {
                ePOINTER_TYPE_MOUSE = 0,
                ePOINTER_TYPE_SINGLE_TOUCH,
                ePOINTER_TYPE_MULTI_TOUCH
        };
 
        struct sClonableMessageParameters : public sMessageParameters
        {
                const static fsS32 mPointerMessageTypeId;
                const static fsS32 mKeyboardMessageTypeId;
                const static fsS32 mFrameUpdateMessageTypeId;
                const static fsS32 mDPADMessageTypeId;
 
                void s32Save(fsStr& pSaveStr, fsS32 pVal);
                fsS32 s32Load(fsStr& pLoadStr);
                void boolSave(fsStr& pSaveStr, fsBool pVal);
                fsBool boolLoad(fsStr& pLoadStr);
                void strSave(fsStr& pSaveStr, const fsStr& pVal);
                fsStr strLoad(fsStr& pLoadStr);
                void pointSave(fsStr& pSaveStr, const fsPoint& pVal);
                fsPoint pointLoad(fsStr& pLoadStr);
 
                virtual sClonableMessageParameters* clone() const = 0;
                virtual void saveStr(fsStr& pSaveStr) = 0;
                static sClonableMessageParameters* create(fsStr& pSaveStr);
        };
 
    struct sDPADMsgParam : public sClonableMessageParameters
    {
                sDPADMsgParam(fsPoint pPos, fsS32 pId, fsBool pDown) : mPos(pPos), mId(pId), mDown(pDown) {}
 
                sDPADMsgParam(fsStr& pLoadStr);
 
        sClonableMessageParameters* clone() const override;
        void saveStr(fsStr& pSaveStr) override;
 
        fsS32 mId;
        fsBool mDown;
        fsPoint mPos;
    };
 
        struct sPointerMsgParam : public sClonableMessageParameters
        {
                sPointerMsgParam() : mPos(0, 0), mIdx(0), mDown(false), mStealableFrom(nullptr)
                {
                }
 
                sPointerMsgParam(fsStr& pLoadStr);
 
                sClonableMessageParameters* clone() const override;
                void saveStr(fsStr& pSaveStr) override;
 
                fsPoint mPos;
                fsS32 mIdx;
                fsBool mDown;
                mutable fsIMessageListener* mStealableFrom;
        };
 
        struct sKeyboardMsgParam : public sClonableMessageParameters
        {
                sKeyboardMsgParam() : mKey(0), mPressed(true), mAltKeyChanged(false), mShiftKeyChanged(false), mCommandChanged(false), mTime(0) {}
                sKeyboardMsgParam(
                        fsS32 pKey,
                        fsBool pPressed,
                        fsBool pAltKeyDown,
                        fsBool pShiftKeyDown,
                        fsBool pCommandDown,
                        fsS64 pTime) :
                        mKey(pKey),
                        mPressed(pPressed),
                        mAltKeyChanged(pAltKeyDown),
                        mShiftKeyChanged(pShiftKeyDown),
                        mCommandChanged(pCommandDown),
                        mTime(pTime)
                {
                }
 
                sKeyboardMsgParam(fsStr& pLoadStr);
 
                sClonableMessageParameters* clone() const override;
                void saveStr(fsStr& pSaveStr) override;
 
                fsS32 mKey;
                fsBool mPressed;
                fsBool mAltKeyChanged;
                fsBool mShiftKeyChanged;
                fsBool mCommandChanged;
                fsS64 mTime;
        };
 
        struct sFrameUpdateParam : public sClonableMessageParameters
        {
                sFrameUpdateParam(fsS32 pTime) : mFrameDelta(pTime)
                {
                }
 
                sFrameUpdateParam(fsStr& pLoadStr);
 
                sClonableMessageParameters* clone() const override;
                void saveStr(fsStr& pSaveStr) override;
 
                fsS32 mFrameDelta;
        };
 
        static const fsCUniqueId mPointerDownStealMsg;
        static const fsCUniqueId mPointerDownMsg;
        static const fsCUniqueId mPointerUpMsg;
        static const fsCUniqueId mPointerMoveMsg;
        static const fsCUniqueId mFrameUpdateMsg;
        static const fsCUniqueId mDPADDownMsg;
        static const fsCUniqueId mDPADUpMsg;
 
        static const fsCUniqueId mKeyDownMsg;
        static const fsCUniqueId mKeyUpMsg;
        static const fsCUniqueId mTypedCharMsg;
 
 
 
        fsBool keyDecode(fsS32& pKeyCode);
        void keyDownEvent(sKeyboardMsgParam& pKeyboardEvent);
        void keyUpEvent(sKeyboardMsgParam& pKeyboardEvent);
 
 
        fsPoint const& mousePosGet() const;
        void mouseEvent(sPointerMsgParam const& pEvent);
        void mouseUpDownEvent(sPointerMsgParam const& pEvent);
 
        void keyEvent(sKeyboardMsgParam const& pEvent);
 
        fsS32 frameReady(fsS32 pDeltaMs);
 
        void messageDispatchLocal(const fsCUniqueId& pMessageType, const sClonableMessageParameters& pParam);
 
        virtual fsS32 pointerTypeGet() const = 0;
        virtual fsBool hasPhysicalKeyboardGet() const = 0;
 
        fsS32 maxInputPointsGet() const;
 
        void update(fsS32 pDeltaMs);
 
protected:
 
        static fsIInputManager* backendInstanceCreate();
 
        void postCreateDo() override { initialise(); }
        void preDestroyDo() override { uninitialise(); }
 
        virtual fsBool keyDecodeDo(fsS32& pKeyCode) = 0;
 
        virtual void pollKeys() {}
 
        static void altEnterHandle();
 
        virtual void initialiseDo() = 0;
        virtual void uninitialiseDo() = 0;
 
        fsIInputManager();
        virtual ~fsIInputManager();
 
        std::vector<fsS32> mPressedKeys;
        std::vector<fsS32> mTypedChars;
        std::vector<sDPADMsgParam> mDPADPresses;
        std::vector<fsCInputPoint*> mInputPoints;
 
        fsS32 mMaxInputPoints;
 
        fsBool mAltKeyDown;
        fsBool mShiftKeyDown;
        fsBool mCommandDown;
 
        std::map<fsS32, fsS64> mKeysDown;
 
 
private:
 
        void playback();
 
        void pointerEventsProcess();
        void keyboardEventsProcess();
 
        void initialise();
        void uninitialise();
 
        fsCInputSession* mInputSession;
        fsPoint mMousePos;
 
};
 
#endif