keyboard_bindings.hpp

// Copyright Take Vos 2020-2022.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#include "keyboard_key.hpp"
#include "gui_event.hpp"
#include "../utility/utility.hpp"
#include "../codec/codec.hpp"
#include "../coroutine/module.hpp"
#include "../macros.hpp"
#include <unordered_map>
#include <tuple>
#include <filesystem>
 
namespace hi { inline namespace v1 {
 
class keyboard_bindings {
public:
    keyboard_bindings() noexcept : bindings() {}
 
    static keyboard_bindings& global() noexcept;
 
    void add_system_binding(keyboard_key key, gui_event_type command) noexcept
    {
        bindings[key].add_system_command(command);
    }
 
    void add_ignored_binding(keyboard_key key, gui_event_type command) noexcept
    {
        bindings[key].add_ignored_command(command);
    }
 
    void add_user_binding(keyboard_key key, gui_event_type command) noexcept
    {
        bindings[key].add_user_command(command);
    }
 
    [[nodiscard]] generator<gui_event> translate(gui_event event) const noexcept
    {
        if (event == gui_event_type::keyboard_down) {
            hilet i = bindings.find(keyboard_key{event.keyboard_modifiers, event.key()});
            if (i != bindings.cend()) {
                for (auto &e : i->second.get_events()) {
                    co_yield e;
                }
            }
        }
    }
 
    void clear() noexcept
    {
        bindings.clear();
    }
 
    void load_bindings(std::filesystem::path const& path, bool system_binding = false)
    {
        hilet data = parse_JSON(path);
 
        try {
            hi_check(data.contains("bindings"), "Missing key 'bindings' at top level.");
 
            hilet binding_list = data["bindings"];
            hi_check(
                holds_alternative<datum::vector_type>(binding_list), "Expecting array value for key 'bindings' at top level.");
 
            for (hilet& binding : binding_list) {
                hi_check(holds_alternative<datum::map_type>(binding), "Expecting object for a binding, got {}", binding);
 
                hi_check(
                    binding.contains("key") && binding.contains("command"),
                    "Expecting required 'key' and 'command' for a binding, got {}",
                    binding);
 
                hilet key_name = static_cast<std::string>(binding["key"]);
                hilet key = keyboard_key(key_name);
 
                auto command_name = static_cast<std::string>(binding["command"]);
 
                // Commands starting with '-' are ignored system-bindings.
                bool ignored_binding = false;
                if (command_name.size() >= 1 && command_name[0] == '-') {
                    ignored_binding = true;
                    command_name = command_name.substr(1);
                }
 
                auto command = to_gui_event_type(command_name);
                if (command == gui_event_type::none) {
                    throw parse_error(std::format("Could not parse command '{}'", command_name));
                }
 
                if (ignored_binding) {
                    add_ignored_binding(key, command);
                } else if (system_binding) {
                    add_system_binding(key, command);
                } else {
                    add_user_binding(key, command);
                }
            }
 
        } catch (std::exception const& e) {
            throw io_error(std::format("{}: Could not load keyboard bindings.\n{}", path.string(), e.what()));
        }
    }
 
    // void save_user_bindings(std::filesystem::path const &path);
 
private:
    struct commands_t {
        std::vector<gui_event_type> system = {};
 
        std::vector<gui_event_type> ignored = {};
 
        std::vector<gui_event_type> user = {};
 
        std::vector<gui_event> cache = {};
 
        [[nodiscard]] std::vector<gui_event> const& get_events() const noexcept
        {
            return cache;
        }
 
        void add_system_command(gui_event_type cmd) noexcept
        {
            hilet i = std::find(system.cbegin(), system.cend(), cmd);
            if (i == system.cend()) {
                system.push_back(cmd);
                update_cache();
            }
        }
 
        void add_ignored_command(gui_event_type cmd) noexcept
        {
            hilet i = std::find(ignored.cbegin(), ignored.cend(), cmd);
            if (i == ignored.cend()) {
                ignored.push_back(cmd);
                update_cache();
            }
        }
 
        void add_user_command(gui_event_type cmd) noexcept
        {
            hilet i = std::find(user.cbegin(), user.cend(), cmd);
            if (i == user.cend()) {
                user.push_back(cmd);
                update_cache();
            }
        }
 
        void update_cache() noexcept
        {
            cache.reserve(ssize(system) + ssize(user));
 
            for (hilet cmd : system) {
                hilet i = std::find(cache.cbegin(), cache.cend(), cmd);
                if (i == cache.cend()) {
                    cache.emplace_back(cmd);
                }
            }
 
            for (hilet cmd : ignored) {
                hilet i = std::find(cache.cbegin(), cache.cend(), cmd);
                if (i != cache.cend()) {
                    cache.erase(i);
                }
            }
 
            for (hilet cmd : user) {
                hilet i = std::find(cache.cbegin(), cache.cend(), cmd);
                if (i == cache.cend()) {
                    cache.emplace_back(cmd);
                }
            }
        }
    };
 
    inline static std::unique_ptr<keyboard_bindings> _global;
 
    std::unordered_map<keyboard_key, commands_t> bindings;
};
 
inline keyboard_bindings& keyboard_bindings::global() noexcept
{
    if (not _global) {
        _global = std::make_unique<keyboard_bindings>();
    }
    return *_global;
}
 
inline void load_user_keyboard_bindings(std::filesystem::path const& path)
{
    return keyboard_bindings::global().load_bindings(path, false);
}
 
inline void load_system_keyboard_bindings(std::filesystem::path const& path)
{
    return keyboard_bindings::global().load_bindings(path, true);
}
 
inline generator<gui_event> translate_keyboard_event(gui_event event) noexcept
{
    for (auto &e : keyboard_bindings::global().translate(event)) {
        co_yield e;
    }
}
 
}} // namespace hi::v1