D:/Programmation/Sources/lxgui/bak/lxgui/gui/include/input.hpp

Go to the documentation of this file.

#ifndef INPUT_HPP
#define INPUT_HPP

#include <utils.hpp>
#include <utils_refptr.hpp>
#include <utils_wptr.hpp>
#include <string>
#include <vector>
#include <deque>
#include <array>
#include <map>
#include "input_keys.hpp"

#define INPUT_MOUSE_BUTTON_NUMBER 3

namespace gui
{
    class event;
    class event_receiver;
    class event_manager;
}

namespace input
{
    class handler_impl
    {
    public :

        handler_impl();

        virtual ~handler_impl() {}

        virtual void update() = 0;


        virtual void toggle_mouse_grab() = 0;


        virtual std::string get_key_name(key::code mKey) const = 0;

        struct key_state
        {
            std::array<bool, key::code::K_MAXKEY> lKeyState;
        } mKeyboard;

        struct mouse_state
        {
            std::array<bool, INPUT_MOUSE_BUTTON_NUMBER> lButtonState;
            float fAbsX, fAbsY, fDX, fDY;
            float fRelX, fRelY, fRelDX, fRelDY;
            float fRelWheel;
            bool  bHasDelta;
        } mMouse;

        std::vector<char32_t> lChars;
        std::vector<char32_t> lCharsCache_;
    };


    class handler
    {
    public :

        handler();


        template<class T>
        handler(utils::refptr<T> pImpl) : bManuallyUpdated_(false), pImpl_(pImpl) {
        }


        void update();


        bool is_manually_updated() const;


        void set_manually_updated(bool bManuallyUpdated);

        const handler_impl::key_state& get_key_state() const;


        std::vector<char32_t> get_chars() const;


        std::string get_key_name(key::code mKey) const;

        const handler_impl::mouse_state& get_mouse_state() const;

        utils::wptr<handler_impl> get_impl();

    private :

        bool                        bManuallyUpdated_;
        utils::refptr<handler_impl> pImpl_;
    };

    class manager
    {
    public :


        explicit manager(const handler& mHandler);

        manager(const manager& mMgr) = delete;

        manager& operator = (const manager& mMgr) = delete;

        void update(float fDelta);


        void allow_input(const std::string& sGroupName);


        void block_input(const std::string& sGroupName);


        bool can_receive_input(const std::string& sGroupName) const;


        void force_input_allowed(const std::string& sGroupName, bool bForce);


        bool get_key(bool bForce = false) const;


        bool key_is_down(key::code mKey, bool bForce = false) const;


        bool key_is_down_long(key::code mKey, bool bForce = false) const;


        double get_key_press_duration(key::code mKey) const;


        bool key_is_pressed(key::code mKey, bool bForce = false) const;


        bool key_is_released(key::code mKey, bool bForce = false) const;


        std::vector<char32_t> get_chars() const;


        std::string get_key_name(key::code mKey) const;


        std::string get_key_name(key::code mKey, key::code mModifier) const;


        std::string get_key_name(key::code mKey, key::code mModifier1, key::code mModifier2) const;


        const std::deque<key::code>& get_key_release_stack() const;


        const std::deque<key::code>& get_key_press_stack() const;


        bool alt_is_pressed() const;


        bool shift_is_pressed() const;


        bool ctrl_is_pressed() const;


        bool mouse_is_down(mouse::button mID) const;


        bool mouse_is_down_long(mouse::button mID) const;


        double get_mouse_press_duration(mouse::button mKey) const;


        bool mouse_is_pressed(mouse::button mID) const;


        bool mouse_is_released(mouse::button mID) const;


        bool mouse_is_doubleclicked(mouse::button mID) const;


        bool wheel_is_rolled() const;


        bool mouse_last_dragged() const;


        mouse::state get_mouse_state(mouse::button mID) const;


        float get_mouse_x() const;


        float get_mouse_y() const;


        float get_mouse_rel_x() const;


        float get_mouse_rel_y() const;


        float get_mouse_raw_dx() const;


        float get_mouse_raw_dy() const;


        float get_mouse_dx() const;


        float get_mouse_dy() const;


        float get_mouse_rel_dx() const;


        float get_mouse_rel_dy() const;


        float get_mouse_smooth_dx() const;


        float get_mouse_smooth_dy() const;


        float get_mouse_wheel() const;


        std::string get_mouse_button_string(mouse::button mID) const;


        void set_doubleclick_time(double dDoubleClickTime);


        double get_doubleclick_time() const;


        void set_mouse_buffer_duration(double dMouseHistoryMaxLength);


        double get_mouse_buffer_duration() const;


        void set_mouse_sensibility(float fMouseSensibility);


        float get_mouse_sensibility() const;


        void set_long_press_delay(double dLongPressDelay);


        double get_long_press_delay() const;


        void set_focus(bool bFocus, gui::event_receiver* pReceiver = nullptr);


        bool is_focused() const;


        void register_event_manager(utils::wptr<gui::event_manager> pManager);


        void unregister_event_manager(utils::wptr<gui::event_manager> pManager);


        const handler& get_handler() const;


        handler& get_handler();

    private :

        void fire_event_(const gui::event& mEvent, bool bForce = false);

        bool bRemoveFocus_;
        bool bFocus_;
        gui::event_receiver* pFocusReceiver_;

        std::vector<utils::wptr<gui::event_manager>> lEventManagerList_;

        // Keyboard
        std::array<double, 256> lKeyDelay_;
        std::array<bool, 256>   lKeyLong_;
        std::array<bool, 256>   lKeyBuf_;
        std::array<bool, 256>   lKeyBufOld_;

        bool bCtrlPressed_;
        bool bShiftPressed_;
        bool bAltPressed_;
        bool bKey_;
        std::vector<char32_t> lChars_;

        std::deque<key::code> lDownStack_;
        std::deque<key::code> lUpStack_;

        // Mouse
        double                                              dDoubleClickTime_;
        std::array<double, INPUT_MOUSE_BUTTON_NUMBER>       lDoubleClickDelay_;
        std::array<double, INPUT_MOUSE_BUTTON_NUMBER>       lMouseDelay_;
        std::array<bool, INPUT_MOUSE_BUTTON_NUMBER>         lMouseLong_;
        std::array<bool, INPUT_MOUSE_BUTTON_NUMBER>         lMouseBuf_;
        std::array<bool, INPUT_MOUSE_BUTTON_NUMBER>         lMouseBufOld_;
        std::array<mouse::state, INPUT_MOUSE_BUTTON_NUMBER> lMouseState_;

        std::map<std::string, bool> lClickGroupList_;
        std::map<std::string, bool> lForcedClickGroupList_;

        float       fMX_, fMY_;
        float       fRelMX_, fRelMY_;
        float       fDMX_, fDMY_;
        float       fRelDMX_, fRelDMY_;
        float       fRawDMX_, fRawDMY_;
        float       fMouseSensibility_;
        double      dMouseHistoryMaxLength_;
        double      dLongPressDelay_;
        std::deque<std::pair<double, std::array<float,3>>> lMouseHistory_;
        float       fSmoothDMX_, fSmoothDMY_, fSmoothMWheel_;
        float       fMWheel_;
        bool        bWheelRolled_;
        std::string sMouseButton_;
        bool        bLastDragged_;

        double dTime_;

        handler mHandler_;
    };
}

#endif

---