keyboard_bindings.hpp

// Copyright Take Vos 2020.
// 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 "../URL.hpp"
#include "../os_detect.hpp"
#include "../command.hpp"
#include <unordered_map>
#include <tuple>
 
namespace tt {
 
class keyboard_bindings {
    struct commands_t {
        std::vector<command> system = {};
 
        std::vector<command> ignored = {};
 
        std::vector<command> user = {};
 
        std::vector<command> cache = {};
 
        [[nodiscard]] std::vector<command> const &get_commands() const noexcept {
            return cache;
        }
 
        void add_system_command(command cmd) noexcept {
            ttlet i = std::find(system.cbegin(), system.cend(), cmd);
            if (i == system.cend()) {
                system.push_back(cmd);
                update_cache();
            }
        }
 
        void add_ignored_command(command cmd) noexcept {
            ttlet i = std::find(ignored.cbegin(), ignored.cend(), cmd);
            if (i == ignored.cend()) {
                ignored.push_back(cmd);
                update_cache();
            }
        }
 
        void add_user_command(command cmd) noexcept {
            ttlet i = std::find(user.cbegin(), user.cend(), cmd);
            if (i == user.cend()) {
                user.push_back(cmd);
                update_cache();
            }
        }
 
        void update_cache() noexcept {
            cache.reserve(std::ssize(system) + std::ssize(user));
 
            for (ttlet cmd: system) {
                ttlet i = std::find(cache.cbegin(), cache.cend(), cmd);
                if (i == cache.cend()) {
                    cache.push_back(cmd);
                }
            }
 
            for (ttlet cmd: ignored) {
                ttlet i = std::find(cache.cbegin(), cache.cend(), cmd);
                if (i != cache.cend()) {
                    cache.erase(i);
                }
            }
 
            for (ttlet cmd: user) {
                ttlet i = std::find(cache.cbegin(), cache.cend(), cmd);
                if (i == cache.cend()) {
                    cache.push_back(cmd);
                }
            }
        }
    };
 
    std::unordered_map<keyboard_key,commands_t> bindings;
 
public:
    keyboard_bindings() noexcept :
        bindings() {}
 
    void addSystemBinding(keyboard_key key, command command) noexcept {
        bindings[key].add_system_command(command);
    }
 
    void addIgnoredBinding(keyboard_key key, command command) noexcept {
        bindings[key].add_ignored_command(command);
    }
 
    void addUserBinding(keyboard_key key, command command) noexcept {
        bindings[key].add_user_command(command);
    }
 
    [[nodiscard]] std::vector<command> const &translate(keyboard_key key) const noexcept {
        static std::vector<command> empty_commands = {};
 
        ttlet i = bindings.find(key);
        if (i != bindings.cend()) {
            return i->second.get_commands();
        } else {
            return empty_commands;
        }
    }
 
    void clear() noexcept {
        bindings.clear();
    }
 
    void loadBindings(URL url, bool system_binding);
 
    void loadSystemBindings() {
        if constexpr (OperatingSystem::current == OperatingSystem::Windows) {
            return loadBindings(URL{"resource:win32.keybinds.json"}, true);
        } else {
            tt_no_default();
        }
    }
 
    void loadUserBindings(URL url) {
        clear();
        loadSystemBindings();
        loadBindings(url, false);
    }
 
    void saveUserBindings(URL url);
};
 
inline keyboard_bindings keyboardBindings;
 
}