shortcut_manager.h

Go to the documentation of this file.

#ifndef YAZE_APP_EDITOR_SYSTEM_SHORTCUT_MANAGER_H
#define YAZE_APP_EDITOR_SYSTEM_SHORTCUT_MANAGER_H
 
#include <functional>
#include <optional>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
 
#include "absl/strings/string_view.h"
 
// Must define before including imgui.h
#ifndef IMGUI_DEFINE_MATH_OPERATORS
#define IMGUI_DEFINE_MATH_OPERATORS
#endif
 
#include "imgui/imgui.h"
 
namespace yaze {
namespace editor {
 
enum class EditorType;
 
struct Shortcut {
  enum class Scope { kGlobal, kEditor, kPanel };
  std::string name;
  Scope scope = Scope::kGlobal;
  std::vector<ImGuiKey> keys;
  std::function<void()> callback;
  // When set, the shortcut only competes for its chord while this editor is
  // the active editor (see ShortcutManager::SetActiveEditorProvider).
  std::optional<EditorType> editor_type;
  // Optional extra applicability check evaluated before arbitration.
  std::function<bool()> enabled;
  // Keys as first registered; ResetShortcutKeys() restores them.
  std::vector<ImGuiKey> default_keys;
};
 
std::vector<ImGuiKey> ParseShortcut(const std::string& shortcut);
 
std::string PrintShortcut(const std::vector<ImGuiKey>& keys);
 
std::string InferShortcutGroup(absl::string_view name);
 
class ShortcutManager {
 public:
  using ActiveEditorProvider = std::function<std::optional<EditorType>()>;
 
  void RegisterShortcut(const std::string& name,
                        const std::vector<ImGuiKey>& keys,
                        Shortcut::Scope scope = Shortcut::Scope::kGlobal) {
    Store({name, scope, keys});
  }
  void RegisterShortcut(const std::string& name,
                        const std::vector<ImGuiKey>& keys,
                        std::function<void()> callback,
                        Shortcut::Scope scope = Shortcut::Scope::kGlobal) {
    Store({name, scope, keys, std::move(callback)});
  }
 
  void RegisterShortcut(const std::string& name, ImGuiKey key,
                        std::function<void()> callback,
                        Shortcut::Scope scope = Shortcut::Scope::kGlobal) {
    Store({name, scope, {key}, std::move(callback)});
  }
 
  void RegisterEditorShortcut(const std::string& name,
                              const std::vector<ImGuiKey>& keys,
                              std::function<void()> callback,
                              EditorType editor_type) {
    Shortcut shortcut{name, Shortcut::Scope::kEditor, keys,
                      std::move(callback)};
    shortcut.editor_type = editor_type;
    Store(std::move(shortcut));
  }
 
  void RegisterCommand(const std::string& name, std::function<void()> callback,
                       Shortcut::Scope scope = Shortcut::Scope::kGlobal) {
    Store({name, scope, {}, std::move(callback)});  // Empty key vector
  }
 
  bool SetShortcutEditor(const std::string& name,
                         std::optional<EditorType> editor_type);
  bool SetShortcutEnabled(const std::string& name,
                          std::function<bool()> enabled);
 
  void SetActiveEditorProvider(ActiveEditorProvider provider) {
    active_editor_provider_ = std::move(provider);
  }
  std::optional<EditorType> GetActiveEditorType() const {
    return active_editor_provider_ ? active_editor_provider_() : std::nullopt;
  }
 
  bool IsShortcutApplicable(const Shortcut& shortcut) const;
 
  void ExecuteShortcut(const std::string& name) const {
    shortcuts_.at(name).callback();
  }
 
  // Access the shortcut and print the readable name of the shortcut for menus
  const Shortcut& GetShortcut(const std::string& name) const {
    return shortcuts_.at(name);
  }
 
  const Shortcut* FindShortcut(const std::string& name) const {
    auto it = shortcuts_.find(name);
    return it != shortcuts_.end() ? &it->second : nullptr;
  }
 
  // Get shortcut callback function
  std::function<void()> GetCallback(const std::string& name) const {
    return shortcuts_.at(name).callback;
  }
 
  const std::string GetKeys(const std::string& name) const {
    return PrintShortcut(shortcuts_.at(name).keys);
  }
 
  std::string GetDisplayString(const std::string& name) const;
 
  const std::unordered_map<std::string, Shortcut>& GetShortcuts() const {
    return shortcuts_;
  }
  bool UpdateShortcutKeys(const std::string& name,
                          const std::vector<ImGuiKey>& keys);
  bool ResetShortcutKeys(const std::string& name);
 
  std::vector<std::string> FindConflicts(const std::string& name) const;
  std::vector<std::string> FindConflicts(
      const std::vector<ImGuiKey>& keys, std::optional<EditorType> editor_type,
      const std::string& exclude_name = "") const;
 
  std::vector<Shortcut> GetShortcutsByScope(Shortcut::Scope scope) const {
    std::vector<Shortcut> result;
    result.reserve(shortcuts_.size());
    for (const auto& [_, sc] : shortcuts_) {
      if (sc.scope == scope)
        result.push_back(sc);
    }
    return result;
  }
 
  // Convenience methods for registering common shortcuts
  void RegisterStandardShortcuts(std::function<void()> save_callback,
                                 std::function<void()> open_callback,
                                 std::function<void()> close_callback,
                                 std::function<void()> find_callback,
                                 std::function<void()> settings_callback);
 
  void RegisterWindowNavigationShortcuts(std::function<void()> focus_left,
                                         std::function<void()> focus_right,
                                         std::function<void()> focus_up,
                                         std::function<void()> focus_down,
                                         std::function<void()> close_window,
                                         std::function<void()> split_horizontal,
                                         std::function<void()> split_vertical);
 
 private:
  void Store(Shortcut shortcut) {
    shortcut.default_keys = shortcut.keys;
    std::string name = shortcut.name;
    shortcuts_[name] = std::move(shortcut);
  }
 
  std::unordered_map<std::string, Shortcut> shortcuts_;
  ActiveEditorProvider active_editor_provider_;
};
 
bool SameChord(const std::vector<ImGuiKey>& a, const std::vector<ImGuiKey>& b);
 
void ExecuteShortcuts(const ShortcutManager& shortcut_manager);
 
}  // namespace editor
}  // namespace yaze
 
#endif  // YAZE_APP_EDITOR_SYSTEM_SHORTCUT_MANAGER_H