Keybinds.h

/*
 * Copyright 2020 Adobe. All rights reserved.
 * This file is licensed to you under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License. You may obtain a copy
 * of the License at http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under
 * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
 * OF ANY KIND, either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
#pragma once
 
#include <lagrange/ui/api.h>
#include <lagrange/ui/types/GLContext.h>
 
#include <imgui.h>
 
#include <array>
#include <iostream>
#include <map>
#include <string>
#include <vector>
 
namespace lagrange {
namespace ui {
 
class LA_UI_API Keybinds
{
public:
    enum class KeyState { NONE, PRESSED, DOWN, RELEASED };
 
    Keybinds() {}
 
    struct LA_UI_API Keybind
    {
        Keybind(ImGuiKey btn, const std::vector<ImGuiKey>& modifier_keys = {});
        ImGuiKey button = ImGuiKey_None;
        int modifier_count = 0;
        KeyState previous_state = KeyState::NONE;
        KeyState current_state = KeyState::NONE;
        std::array<ImGuiKey, 6> modifiers = {
            ImGuiKey_None,
            ImGuiKey_None,
            ImGuiKey_None,
            ImGuiKey_None,
            ImGuiKey_None,
            ImGuiKey_None,
        };
    };
 
 
    using MapType = std::map<std::string, std::vector<Keybind>>;
 
    void update();
 
    void push_context(const std::string& context);
 
    void pop_context();
 
    void reset_context();
 
 
    void
    add(const std::string& action, ImGuiKey button, const std::vector<ImGuiKey>& modifiers = {});
 
 
    bool has(
        const std::string& action,
        ImGuiKey button,
        const std::vector<ImGuiKey>& modifiers = {})
        const;
 
 
    void add(const std::string& action, const Keybind& keybind);
 
 
    const MapType& get() const;
 
 
    bool remove(const std::string& action);
 
 
    bool unregister_action(const std::string& action);
 
 
    bool register_action(const std::string& action);
 
 
    bool is_pressed(const std::string& action) const;
 
    inline bool is_pressed(ImGuiKey key_code) const { return ImGui::IsKeyPressed(key_code); }
 
    bool is_down(const std::string& action) const;
 
    inline bool is_down(ImGuiKey key_code) const { return ImGui::IsKeyDown(key_code); }
 
    bool is_released(const std::string& action) const;
 
    inline bool is_released(ImGuiKey key_code) const { return ImGui::IsKeyReleased(key_code); }
 
    bool save(std::ostream& out) const;
 
 
    bool load(std::istream& in, bool append = false);
 
    void enable(bool enabled);
 
    bool is_enabled() const;
 
 
    static std::string to_string(const Keybind& keybind);
 
    static std::string to_string(ImGuiKey key);
 
    std::string to_string(const std::string& action, int limit = 1) const;
 
private:
    MapType m_mapping;
    bool m_enabled = true;
    std::vector<std::string> m_context_stack;
 
    bool is_action_in_state(const std::string& action, KeyState state) const;
};
 
} // namespace ui
} // namespace lagrange