command_palette.h

Go to the documentation of this file.

#ifndef YAZE_APP_EDITOR_SYSTEM_COMMAND_PALETTE_H_
#define YAZE_APP_EDITOR_SYSTEM_COMMAND_PALETTE_H_
 
#include <cstdint>
#include <functional>
#include <memory>
#include <string>
#include <string_view>
#include <unordered_map>
#include <vector>
 
namespace yaze {
namespace editor {
 
class CommandPalette;
class WorkspaceWindowManager;
class EditorRegistry;
class RecentProjectsModel;
 
class CommandProvider {
 public:
  virtual ~CommandProvider() = default;
  virtual std::string ProviderId() const = 0;
  virtual void Provide(CommandPalette* palette) = 0;
};
 
struct CommandCategory {
  static constexpr const char* kPanel = "Panels";
  static constexpr const char* kEditor = "Editor";
  static constexpr const char* kLayout = "Layout";
  static constexpr const char* kFile = "File";
  static constexpr const char* kEdit = "Edit";
  static constexpr const char* kView = "View";
  static constexpr const char* kNavigation = "Navigation";
  static constexpr const char* kTools = "Tools";
  static constexpr const char* kWorkflow = "Workflow";
  static constexpr const char* kHelp = "Help";
  static constexpr const char* kDrawer = "Drawers";
};
 
struct CommandEntry {
  std::string name;
  std::string category;
  std::string description;
  std::string shortcut;
  std::function<void()> callback;
  int usage_count = 0;
  int64_t last_used_ms = 0;
  std::string provider_id;
  bool enabled = true;
  std::string note;
};
 
struct CommandMatch {
  CommandEntry entry;
  int score = 0;
};
 
class CommandPalette {
 public:
  void AddCommand(const std::string& name, const std::string& category,
                  const std::string& description, const std::string& shortcut,
                  std::function<void()> callback);
 
  bool RecordUsage(const std::string& name);
 
  std::vector<CommandEntry> SearchCommands(const std::string& query);
  std::vector<CommandMatch> Search(const std::string& query,
                                   int64_t now_ms) const;
  std::vector<CommandMatch> Search(const std::string& query) const;
 
  std::vector<CommandEntry> GetRecentCommands(int limit = 10);
 
  std::vector<CommandEntry> GetFrequentCommands(int limit = 10);
 
  std::vector<CommandEntry> GetAllCommands() const;
 
  std::vector<CommandEntry> GetVisibleCommands() const;
 
  size_t GetCommandCount() const { return commands_.size(); }
 
  void Clear();
 
  // ============================================================================
  // Providers
  // ============================================================================
 
  void RegisterProvider(std::unique_ptr<CommandProvider> provider);
 
  void UnregisterProvider(const std::string& provider_id);
 
  void RefreshProvider(const std::string& provider_id);
 
  void RefreshProviders();
 
  void RemoveProviderCommands(const std::string& provider_id);
 
  // ============================================================================
  // Bulk Registration Methods (used by built-in providers; kept public so
  // tests and legacy callers can still drive registration directly).
  // ============================================================================
 
  void RegisterPanelCommands(WorkspaceWindowManager* window_manager,
                             size_t session_id);
 
  void RegisterEditorCommands(
      std::function<void(const std::string&)> switch_callback);
 
  void RegisterLayoutCommands(
      std::function<void(const std::string&)> apply_callback);
 
  void RegisterRecentFilesCommands(
      std::function<void(const std::string&)> open_callback);
 
  void RegisterOverworldMapCommands(size_t session_id);
 
  void RegisterDungeonRoomCommands(size_t session_id);
 
  void RegisterDrawerCommands(
      std::function<void(int drawer_type)> toggle_callback,
      std::function<void()> cycle_next = {},
      std::function<void()> cycle_prev = {});
 
  void RegisterWorkflowCommands(WorkspaceWindowManager* window_manager,
                                size_t session_id);
 
  void RegisterWelcomeCommands(
      const RecentProjectsModel* model,
      const std::vector<std::string>& template_names,
      std::function<void(const std::string&)> remove_callback,
      std::function<void(const std::string&)> toggle_pin_callback,
      std::function<void()> undo_remove_callback,
      std::function<void()> clear_recents_callback,
      std::function<void(const std::string&)> create_from_template_callback,
      std::function<void()> dismiss_welcome_callback,
      std::function<void()> show_welcome_callback);
 
  void SaveHistory(const std::string& filepath);
 
  void LoadHistory(const std::string& filepath);
 
  static int FuzzyScore(const std::string& text, const std::string& query);
 
  static int ScoreText(std::string_view text, std::string_view query);
 
  static int ScoreEntry(const CommandEntry& entry, std::string_view query,
                        int64_t now_ms);
 
  static std::string NormalizeCommandName(std::string_view name);
 
  static bool IsInternalCommandId(std::string_view name);
 
  std::string CanonicalCommandName(const std::string& name) const;
 
  static int64_t NowMs();
 
  uint64_t generation() const { return generation_; }
 
 private:
  uint64_t generation_ = 0;
  struct UsageStats {
    int count = 0;
    int64_t last_used_ms = 0;
  };
 
  std::unordered_map<std::string, CommandEntry> commands_;
  std::unordered_map<std::string, UsageStats> usage_;
  std::vector<std::unique_ptr<CommandProvider>> providers_;
  std::string current_provider_id_;
};
 
}  // namespace editor
}  // namespace yaze
 
#endif  // YAZE_APP_EDITOR_SYSTEM_COMMAND_PALETTE_H_