gui_input_manager.h

Go to the documentation of this file.

#pragma once
 
#include <utility>
#include <vector>
#include <gui_core/input/gui_input_state.h>
#include <gui_core/input/gui_input_enums.h>
#include <gui_core/input/gui_platform_input_handler.h>
#include <gui_core/input/gui_input_handler_func.h>
 
namespace tachyon
{
 
    class ScrollManagement;
    class ElementStorage;
    class GUIStateManager;
    class TabChainManager;
    class ITextSystem;

    struct RecordedInputEvent
    {
        EventType  type     = EventType::None;
        InputState state    = {};
        tachyon::ID    windowId = tachyon::ID::Invalid(); 
        bool       consumed = false; 
    };

    class InputManager : public IPlatformInputHandler
    {
    public:
        InputManager() = default;
        ~InputManager() = default;

        void OnKeyboard(tachyon::ID windowId, KeyCode key, int repeat, KeyModifier modifiers, KeyAction action) override;
        void OnMouseMove(tachyon::ID windowId, tachyon::int2 screenPos, tachyon::MouseButtons buttons, KeyModifier modifiers) override;
        void OnMouseButton(tachyon::ID windowId, tachyon::int2 screenPos, tachyon::MouseButtons buttons, KeyModifier modifiers, MouseAction action) override;
        void OnMouseScroll(tachyon::ID windowId, tachyon::int2 screenPos, tachyon::float2 scrollOffset, KeyModifier modifiers) override;
        void OnTextComposition(tachyon::ID, std::string_view, int32_t) override {} // the text editor shows it
        void OnFileDrop(tachyon::ID windowId, tachyon::int2 screenPos, FileDropAction action, std::string_view data) override;

        const FileDrag* GetFileDrag() const { return m_fileDrag.windowID != ID::Invalid() ? &m_fileDrag : nullptr; }
        std::vector<FileDrop> TakeFileDrops() { return std::exchange(m_fileDrops, {}); }

        void PushGlobalHandler(EventHandler h)
        {
            if (h) m_globalHandlers.push_back(std::move(h));
        }

        bool PopGlobalHandler()
        {
            if (m_globalHandlers.empty()) return false;
            m_globalHandlers.pop_back();
            return true;
        }

        void ConsumeKey();

        const std::vector<RecordedInputEvent>& GetRecordedEvents() const { return m_recordedEvents; }
        void ConsumeEvent(size_t index) { if (index < m_recordedEvents.size()) m_recordedEvents[index].consumed = true; }

        MouseButtons GetCurrentButtons() const { return m_currentButtons; }
        bool IsDragAbandoned(MouseButtons button = MouseButtons::Left) const;

        void UpdatePreHover(GUIStateManager& guiStateManager);

        void SynthesizeMissingMouseEvents(int2 screenPos,MouseButtons lastPhysicalButtons, MouseButtons physicalButtons);

        void Process(GUIStateManager& guiStateManager,
                     ElementStorage& elementStorage,
                     TabChainManager& tabChainManager,
                     ITextSystem* textSystem,
                     ID overID);

        void Dispatch(GUIStateManager& guiStateManager, ElementStorage& storage);
 
    private:
        static bool IsMouseEvent(EventType type);
        static bool IsKeyboardEvent(EventType type);
 
        void DispatchSingleEvent(RecordedInputEvent& recorded, GUIStateManager& guiStateManager, ElementStorage& storage);

        int2          m_prevScreenPos  {};
        MouseButtons  m_currentButtons { MouseButtons::None };
        ID            m_prevFocusedID  = ID::Invalid();
 
        std::vector<RecordedInputEvent> m_recordedEvents;
        std::vector<EventHandler>       m_globalHandlers;
 
        FileDrag              m_fileDrag;
        FileDrop              m_dropping;    
        std::vector<FileDrop> m_fileDrops;
    };

}