gui_command_manager.h

Go to the documentation of this file.

#pragma once
 
#include <gui_core/diagnostics/gui_logging.h>
#include <gui_core/input/gui_input_enums.h>
#include <gui_core/input/gui_input_state.h>
#include <gui_core/input/gui_input_handler_func.h>
#include <gui_core/input/gui_undo_history.h>
#include <gui_core/style/gui_style_text.h> // IconID
 
#include <stdint.h>
#include <functional>
#include <string>
#include <string_view>
#include <vector>
 
namespace tachyon
{

    enum class CommandMode : uint32_t
    {
        Default = 0
    };

    struct CommandID
    {
        uint32_t value = 0;
 
        constexpr bool IsValid() const { return value != 0; }
        constexpr explicit operator bool() const { return value != 0; }
        constexpr bool operator==(const CommandID&) const = default;
        static constexpr CommandID Invalid() { return {}; }
    };

    class CommandManager
    {
    public:
        struct Command
        {
            CommandMode           mode;
            IconID                icon = IconID::Invalid; 
            KeyCode               key;
            KeyModifier           modifiers;
            KeyCode               chord2Key  = KeyCode::None;
            KeyModifier           chord2Mods = KeyModifier::None;
            std::string           description;
            std::string           displayString; 
            std::function<void()> callback;
            std::function<void()> onEnd;
            KeyCode               defaultKey       = KeyCode::None;
            KeyModifier           defaultModifiers = KeyModifier::None;
 
            bool IsChord()     const { return chord2Key != KeyCode::None; }
            bool HasShortcut() const { return key != KeyCode::None; }
            bool IsHeld()      const { return static_cast<bool>(onEnd); }
            bool IsRebound()   const { return key != defaultKey || modifiers != defaultModifiers; }
        };

        UndoHistory&       History()       { return m_history; }
        const UndoHistory& History() const { return m_history; }
 
        CommandManager()
        {
            m_modeNames.push_back("Default");
            m_byMode.emplace_back(); // bucket for Default
        }

        CommandMode RegisterMode(std::string_view name)
        {
            for (uint32_t i = 0; i < uint32_t(m_modeNames.size()); i++)
                if (m_modeNames[i] == name) return CommandMode(i);
            m_modeNames.emplace_back(name);
            m_byMode.emplace_back();
            return CommandMode(m_modeNames.size() - 1);
        }

        std::string_view GetModeName(CommandMode mode) const
        {
            uint32_t index = uint32_t(mode);
            return (index < m_modeNames.size()) ? std::string_view(m_modeNames[index]) : std::string_view{};
        }
 
        uint32_t GetModeCount() const { return uint32_t(m_modeNames.size()); }

        void        SetMode(CommandMode mode)
        {
            m_currentMode       = mode;
            m_pendingChord.key  = KeyCode::None;
            m_pendingChord.mods = KeyModifier::None;
        }
        CommandMode GetMode() const { return m_currentMode; }

        CommandID RegisterCommand(CommandMode mode, IconID icon, KeyCode key, KeyModifier modifiers,
                                  std::function<void()> callback, std::string_view description = {})
        {
            if (const CommandID existing = FindCommand(mode, key, modifiers))
            {
                TACHYON_LOG_DEBUG(::tachyon::Diagnostics::MakeLogCategory("input"), "updating existing command: {}", description);
                Command& s    = At(existing);
                s.icon        = icon;
                s.description = std::string(description);
                s.callback    = std::move(callback);
                s.onEnd       = {}; // re-registering as instant drops any prior held delegate
                return existing;
            }
 
            const CommandID id{ uint32_t(m_commands.size()) + 1 };
            m_commands.push_back({
                mode, icon, key, modifiers,
                KeyCode::None, KeyModifier::None, // single-key: no chord2
                std::string(description),
                FormatShortcut(key, modifiers),
                std::move(callback)
            });
            m_commands.back().defaultKey       = key;
            m_commands.back().defaultModifiers = modifiers;
            if (uint32_t(mode) < m_byMode.size())
                m_byMode[uint32_t(mode)].push_back(id);
            return id;
        }

        CommandID RegisterCommand(IconID icon, KeyCode key, KeyModifier modifiers,
                                  std::function<void()> callback, std::string_view description = {})
        {
            return RegisterCommand(CommandMode::Default, icon, key, modifiers, std::move(callback), description);
        }

        CommandID RegisterCommand(CommandMode mode, KeyCode key, KeyModifier modifiers,
                                  std::function<void()> callback, std::string_view description = {})
        {
            return RegisterCommand(mode, IconID::Invalid, key, modifiers, std::move(callback), description);
        }

        CommandID RegisterCommand(KeyCode key, KeyModifier modifiers,
                                  std::function<void()> callback, std::string_view description = {})
        {
            return RegisterCommand(CommandMode::Default, IconID::Invalid, key, modifiers, std::move(callback), description);
        }

        CommandID RegisterCommand(CommandMode mode, IconID icon,
                                  std::function<void()> callback, std::string_view description = {})
        {
            return RegisterCommand(mode, icon, KeyCode::None, KeyModifier::None, std::move(callback), description);
        }

        CommandID RegisterCommand(IconID icon,
                                  std::function<void()> callback, std::string_view description = {})
        {
            return RegisterCommand(CommandMode::Default, icon, KeyCode::None, KeyModifier::None, std::move(callback), description);
        }

        CommandID RegisterHeldCommand(CommandMode mode, IconID icon, KeyCode key, KeyModifier modifiers,
                                      std::function<void()> onBegin, std::function<void()> onEnd,
                                      std::string_view description = {})
        {
            const CommandID id = RegisterCommand(mode, icon, key, modifiers, std::move(onBegin), description);
            At(id).onEnd = std::move(onEnd);
            return id;
        }

        CommandID RegisterHeldCommand(KeyCode key, KeyModifier modifiers,
                                      std::function<void()> onBegin, std::function<void()> onEnd,
                                      std::string_view description = {})
        {
            return RegisterHeldCommand(CommandMode::Default, IconID::Invalid, key, modifiers,
                                       std::move(onBegin), std::move(onEnd), description);
        }

        CommandID RegisterHeldCommand(CommandMode mode, KeyCode key, KeyModifier modifiers,
                                      std::function<void()> onBegin, std::function<void()> onEnd,
                                      std::string_view description = {})
        {
            return RegisterHeldCommand(mode, IconID::Invalid, key, modifiers,
                                       std::move(onBegin), std::move(onEnd), description);
        }

        CommandID FindCommand(CommandMode mode, KeyCode key, KeyModifier modifiers) const
        {
            if (key == KeyCode::None) return {};
            const uint32_t modeIdx = uint32_t(mode);
            if (modeIdx >= m_byMode.size()) return {};
            for (const CommandID id : m_byMode[modeIdx])
            {
                const Command& s = At(id);
                if (!s.IsChord() && s.key == key && s.modifiers == modifiers) return id;
            }
            return {};
        }

        CommandID FindChord(CommandMode mode, KeyCode k1, KeyModifier m1,
                            KeyCode k2, KeyModifier m2) const
        {
            if (k1 == KeyCode::None || k2 == KeyCode::None) return {};
            const uint32_t modeIdx = uint32_t(mode);
            if (modeIdx >= m_byMode.size()) return {};
            for (const CommandID id : m_byMode[modeIdx])
            {
                const Command& s = At(id);
                if (s.IsChord()
                    && s.key == k1 && s.modifiers  == m1
                    && s.chord2Key == k2 && s.chord2Mods == m2)
                    return id;
            }
            return {};
        }

        CommandID RegisterChord(CommandMode mode,
                                KeyCode key1, KeyModifier mods1,
                                KeyCode key2, KeyModifier mods2,
                                std::function<void()> callback, std::string_view description = {})
        {
            if (const CommandID existing = FindChord(mode, key1, mods1, key2, mods2))
            {
                Command& s    = At(existing);
                s.description = std::string(description);
                s.callback    = std::move(callback);
                return existing;
            }
 
            const CommandID id{ uint32_t(m_commands.size()) + 1 };
            m_commands.push_back({
                mode, IconID::Invalid, key1, mods1,
                key2, mods2,
                std::string(description),
                FormatChordShortcut(key1, mods1, key2, mods2),
                std::move(callback)
            });
            m_commands.back().defaultKey       = key1;
            m_commands.back().defaultModifiers = mods1;
            if (uint32_t(mode) < m_byMode.size())
                m_byMode[uint32_t(mode)].push_back(id);
            return id;
        }

        EventHandler MakeHandler()
        {
            return [this](ElementEvent&& event) -> bool
            {
                if (event.type == EventType::KeyDown) return ProcessInput(event.state);
                if (event.type == EventType::KeyUp)   return ProcessKeyUp(event.state);
                return false;
            };
        }
 
        // --- Inspection API (for command/shortcut viewer UI) ---

        const std::vector<Command>& GetCommands() const { return m_commands; }
        static CommandID IDAt(size_t index) { return CommandID{ uint32_t(index) + 1 }; }
        static size_t    IndexOf(CommandID id) { return size_t(id.value) - 1; }   // a valid ID's index

        const Command* GetCommand(CommandID id) const
        {
            return (id.value >= 1 && id.value <= m_commands.size()) ? &m_commands[id.value - 1] : nullptr;
        }

        const std::vector<CommandID>& GetCommandsForMode(CommandMode mode) const
        {
            static const std::vector<CommandID> empty;
            uint32_t index = uint32_t(mode);
            return (index < m_byMode.size()) ? m_byMode[index] : empty;
        }
 
        // --- Rebind mode ---

        void      BeginRebind(CommandID id) { m_rebinding = GetCommand(id) ? id : CommandID{}; }
        void      CancelRebind()            { m_rebinding = {}; }
        bool      IsRebinding() const       { return m_rebinding.IsValid(); }
        CommandID RebindTarget() const      { return m_rebinding; }

        void SetShortcut(CommandID id, KeyCode key, KeyModifier modifiers)
        {
            if (!GetCommand(id)) return;
            Command& s = At(id);
 
            // Most recent wins: another command in this mode owning (key, mods) becomes unbound.
            if (key != KeyCode::None)
            {
                const CommandID existing = FindCommand(s.mode, key, modifiers);
                if (existing && existing != id)
                {
                    Command& other      = At(existing);
                    other.key           = KeyCode::None;
                    other.modifiers     = KeyModifier::None;
                    other.displayString = FormatShortcut(KeyCode::None, KeyModifier::None);
                }
            }
 
            s.key           = key;
            s.modifiers     = key != KeyCode::None ? modifiers : KeyModifier::None;
            s.displayString = s.IsChord() ? FormatChordShortcut(s.key, s.modifiers, s.chord2Key, s.chord2Mods)
                                          : FormatShortcut(s.key, s.modifiers);
        }

        bool IsChordPending() const { return m_pendingChord.key != KeyCode::None; }

        static std::string FormatChordShortcut(KeyCode k1, KeyModifier m1,
                                               KeyCode k2, KeyModifier m2)
        {
            if (k1 == KeyCode::None) return "(unbound)";
            std::string out = FormatShortcut(k1, m1);
            if (k2 != KeyCode::None)
            {
                out += ' ';
                out += FormatShortcut(k2, m2);
            }
            return out;
        }

        static std::string FormatShortcut(KeyCode key, KeyModifier modifiers)
        {
            if (key == KeyCode::None) return "(unbound)";
            std::string out;
            auto addMod = [&](KeyModifier bit, const char* name)
            {
                if ((modifiers & bit) != KeyModifier::None)
                {
                    if (!out.empty()) out += '+';
                    out += name;
                }
            };
            addMod(KeyModifier::Control, "Ctrl");
            addMod(KeyModifier::Shift,   "Shift");
            addMod(KeyModifier::Alt,     "Alt");
            addMod(KeyModifier::Command, "Cmd");
            addMod(KeyModifier::Option,  "Opt");
 
            if (!out.empty()) out += '+';
            out += KeyCodeName(key);
            return out;
        }

        static std::string KeyCodeName(KeyCode k)
        {
            switch (k)
            {
                case KeyCode::None:        return "(none)";
                case KeyCode::Return:      return "Enter";
                case KeyCode::Escape:      return "Esc";
                case KeyCode::Backspace:   return "Backspace";
                case KeyCode::Tab:         return "Tab";
                case KeyCode::Space:       return "Space";
                case KeyCode::Comma:       return ",";
                case KeyCode::Minus:       return "-";
                case KeyCode::Period:      return ".";
                case KeyCode::Slash:       return "/";
                case KeyCode::Semicolon:   return ";";
                case KeyCode::Equals:      return "=";
                case KeyCode::LeftBracket: return "[";
                case KeyCode::Backslash:   return "\\";
                case KeyCode::RightBracket:return "]";
                case KeyCode::Backquote:   return "`";
                case KeyCode::Quote:       return "'";
                case KeyCode::Insert:      return "Insert";
                case KeyCode::Home:        return "Home";
                case KeyCode::PageUp:      return "PageUp";
                case KeyCode::Delete:      return "Delete";
                case KeyCode::End:         return "End";
                case KeyCode::PageDown:    return "PageDown";
                case KeyCode::Right:       return "Right";
                case KeyCode::Left:        return "Left";
                case KeyCode::Down:        return "Down";
                case KeyCode::Up:          return "Up";
                default: break;
            }
            if (k >= KeyCode::KeyA && k <= KeyCode::KeyZ)
                return std::string(1, char('A' + (uint32_t(k) - uint32_t(KeyCode::KeyA))));
            if (k >= KeyCode::Key0 && k <= KeyCode::Key9)
                return std::string(1, char('0' + (uint32_t(k) - uint32_t(KeyCode::Key0))));
            if (k >= KeyCode::F1 && k <= KeyCode::F12)
                return "F" + std::to_string(1 + int(uint32_t(k) - uint32_t(KeyCode::F1)));
            return "?";
        }
 
    private:
        struct KeyChord
        {
            KeyCode     key  = KeyCode::None;
            KeyModifier mods = KeyModifier::None;
        };
 
        static bool IsModifierKey(KeyCode k)
        {
            return k == KeyCode::LeftControl  || k == KeyCode::RightControl
                || k == KeyCode::LeftShift    || k == KeyCode::RightShift
                || k == KeyCode::LeftAlt      || k == KeyCode::RightAlt
                || k == KeyCode::LeftCommand  || k == KeyCode::RightCommand;
        }
 
        Command&       At(CommandID id)       { return m_commands[id.value - 1]; }
        const Command& At(CommandID id) const { return m_commands[id.value - 1]; }
 
    public:
        bool ProcessInput(const InputState& state)
        {
            if (state.lastKey == KeyCode::None)
                return false;
 
            // Before the state.consumed check so a focused textbox can't swallow the rebind key.
            if (m_rebinding)
            {
                if (IsModifierKey(state.lastKey)) return false;
                if (state.lastKey != KeyCode::Escape)
                    SetShortcut(m_rebinding, state.lastKey, state.modifiers);
                m_rebinding = {};
                return true;
            }
 
            if (state.consumed)
                return false;
 
            // The next non-modifier key completes the chord or cancels it.
            if (m_pendingChord.key != KeyCode::None)
            {
                if (IsModifierKey(state.lastKey)) return false;
 
                KeyChord pending = m_pendingChord;
                m_pendingChord   = {};
 
                if (state.lastKey == KeyCode::Escape)
                    return true;
 
                if (TryCompleteChord(m_currentMode, pending, state)) return true;
                if (m_currentMode != CommandMode::Default
                    && TryCompleteChord(CommandMode::Default, pending, state)) return true;
 
                // Swallow a non-completing key so it doesn't fire an unrelated command.
                return true;
            }
 
            if (TryDispatchMode(m_currentMode, state)) return true;
            if (m_currentMode != CommandMode::Default
                && TryDispatchMode(CommandMode::Default, state)) return true;
 
            // A chord prefix enters pending state.
            if (HasChordPrefix(m_currentMode, state.lastKey, state.modifiers)
                || (m_currentMode != CommandMode::Default
                    && HasChordPrefix(CommandMode::Default, state.lastKey, state.modifiers)))
            {
                m_pendingChord = { state.lastKey, state.modifiers };
                return true;
            }
 
            return false;
        }

        bool ProcessKeyUp(const InputState& state)
        {
            if (state.lastKey == KeyCode::None) return false;
            bool fired = false;
            for (size_t j = 0; j < m_activeHeld.size(); )
            {
                if (m_activeHeld[j].key != state.lastKey) { ++j; continue; }
                const CommandID cmd = m_activeHeld[j].cmd;
                m_activeHeld.erase(m_activeHeld.begin() + j);
                if (const Command* c = GetCommand(cmd); c && c->onEnd)
                    c->onEnd();
                fired = true;
            }
            return fired;
        }
 
    private:
        bool TryDispatchMode(CommandMode mode, const InputState& state)
        {
            uint32_t index = uint32_t(mode);
            if (index >= m_byMode.size()) return false;
            for (const CommandID i : m_byMode[index])
            {
                const Command& s = At(i);
                if (s.IsChord()) continue; // chord commands only fire via the pending-prefix path
                if (s.key == state.lastKey && s.modifiers == state.modifiers)
                {
                    BeginCommand(i);
                    return true;
                }
            }
            return false;
        }

        void BeginCommand(CommandID i)
        {
            const Command& s = At(i);
            if (s.IsHeld())
            {
                if (IsHeldActive(i)) return;
                m_activeHeld.push_back({ s.key, i });
            }
            if (s.callback) s.callback();
        }
 
        bool IsHeldActive(CommandID cmd) const
        {
            for (const HeldActive& h : m_activeHeld)
                if (h.cmd == cmd) return true;
            return false;
        }
 
        bool TryCompleteChord(CommandMode mode, KeyChord prefix, const InputState& state)
        {
            uint32_t index = uint32_t(mode);
            if (index >= m_byMode.size()) return false;
            for (const CommandID i : m_byMode[index])
            {
                const Command& s = At(i);
                if (!s.IsChord()) continue;
                if (s.key == prefix.key && s.modifiers == prefix.mods
                    && s.chord2Key == state.lastKey && s.chord2Mods == state.modifiers)
                {
                    if (s.callback) s.callback();
                    return true;
                }
            }
            return false;
        }
 
        bool HasChordPrefix(CommandMode mode, KeyCode key, KeyModifier mods) const
        {
            uint32_t index = uint32_t(mode);
            if (index >= m_byMode.size()) return false;
            for (const CommandID i : m_byMode[index])
            {
                const Command& s = At(i);
                if (s.IsChord() && s.key == key && s.modifiers == mods)
                    return true;
            }
            return false;
        }
 
        UndoHistory m_history;
        struct HeldActive { KeyCode key; CommandID cmd; };
 
        std::vector<std::string>           m_modeNames;
        std::vector<Command>               m_commands;
        std::vector<std::vector<CommandID>> m_byMode;      
        CommandMode                        m_currentMode = CommandMode::Default;
        CommandID                          m_rebinding;       
        KeyChord                           m_pendingChord {}; 
        std::vector<HeldActive>            m_activeHeld;      
    };

} // namespace tachyon