shortcut_configurator.cc

Go to the documentation of this file.

#include "app/editor/system/commands/shortcut_configurator.h"
 
#include <algorithm>
#include <map>
#include <optional>
#include <unordered_map>
 
#include "absl/functional/bind_front.h"
#include "absl/strings/str_format.h"
#include "app/editor/code/assembly_editor.h"
#include "app/editor/code/memory_editor.h"
#include "app/editor/dungeon/dungeon_editor_v2.h"
#include "app/editor/editor_manager.h"
#include "app/editor/graphics/graphics_editor.h"
#include "app/editor/graphics/screen_editor.h"
#include "app/editor/menu/menu_orchestrator.h"
#include "app/editor/menu/right_drawer_manager.h"
#include "app/editor/message/message_editor.h"
#include "app/editor/music/music_editor.h"
#include "app/editor/overworld/overworld_editor.h"
#include "app/editor/palette/palette_editor.h"
#include "app/editor/shell/coordinator/ui_coordinator.h"
#include "app/editor/shell/coordinator/workspace_manager.h"
#include "app/editor/shell/feedback/popup_manager.h"
#include "app/editor/shell/feedback/toast_manager.h"
#include "app/editor/sprite/sprite_editor.h"
#include "app/editor/system/session/rom_file_manager.h"
#include "app/editor/system/session/session_coordinator.h"
#include "app/editor/system/session/user_settings.h"
#include "app/editor/system/workspace/editor_registry.h"
#include "app/editor/system/workspace/proposal_drawer.h"
#include "app/editor/system/workspace/workspace_window_manager.h"
#include "core/project.h"
#include "imgui/imgui.h"
#include "util/log.h"
 
namespace yaze::editor {
 
namespace {
 
// Matches Global Font Scale slider in settings_panel.cc (0.5–2.0).
constexpr float kUiFontScaleStep = 0.05f;
constexpr float kUiFontScaleMin = 0.5f;
constexpr float kUiFontScaleMax = 2.0f;
 
void AdjustUiFontScaleBy(EditorManager* editor_manager, float delta) {
  if (!editor_manager || ImGui::GetIO().WantTextInput) {
    return;
  }
  float s = editor_manager->user_settings().prefs().font_global_scale + delta;
  editor_manager->SetFontGlobalScale(
      std::clamp(s, kUiFontScaleMin, kUiFontScaleMax));
}
 
void RegisterIfValid(ShortcutManager* shortcut_manager, const std::string& name,
                     const std::vector<ImGuiKey>& keys,
                     std::function<void()> callback,
                     Shortcut::Scope scope = Shortcut::Scope::kGlobal) {
  if (!shortcut_manager || !callback) {
    return;
  }
  shortcut_manager->RegisterShortcut(name, keys, std::move(callback), scope);
}
 
void RegisterIfValid(ShortcutManager* shortcut_manager, const std::string& name,
                     ImGuiKey key, std::function<void()> callback,
                     Shortcut::Scope scope = Shortcut::Scope::kGlobal) {
  if (!shortcut_manager || !callback) {
    return;
  }
  shortcut_manager->RegisterShortcut(name, key, std::move(callback), scope);
}
 
void RegisterEditorIfValid(ShortcutManager* shortcut_manager,
                           const std::string& name,
                           const std::vector<ImGuiKey>& keys,
                           std::function<void()> callback,
                           EditorType editor_type) {
  if (!shortcut_manager || !callback) {
    return;
  }
  shortcut_manager->RegisterEditorShortcut(name, keys, std::move(callback),
                                           editor_type);
}
 
// Register a keyless palette alias for a legacy command name. The keyed entry
// lives under the canonical name so one chord maps to one shortcut.
void RegisterAlias(ShortcutManager* shortcut_manager, const std::string& alias,
                   const std::string& canonical) {
  const Shortcut* target = shortcut_manager->FindShortcut(canonical);
  if (!target || !target->callback) {
    return;
  }
  shortcut_manager->RegisterCommand(alias, target->callback, target->scope);
}
 
struct EditorShortcutDef {
  std::string id;
  std::vector<ImGuiKey> keys;
  std::string description;
};
 
const std::vector<EditorShortcutDef> kMusicEditorShortcuts = {
    {"music.play_pause", {ImGuiKey_Space}, "Play/Pause current song"},
    {"music.stop", {ImGuiKey_Escape}, "Stop playback"},
    {"music.speed_up", {ImGuiKey_Equal}, "Increase playback speed"},
    {"music.speed_up_keypad",
     {ImGuiKey_KeypadAdd},
     "Increase playback speed (keypad)"},
    {"music.speed_down", {ImGuiKey_Minus}, "Decrease playback speed"},
    {"music.speed_down_keypad",
     {ImGuiKey_KeypadSubtract},
     "Decrease playback speed (keypad)"},
};
 
const std::vector<EditorShortcutDef> kDungeonEditorShortcuts = {
    {"dungeon.room.navigate_up",
     {ImGuiMod_Ctrl, ImGuiKey_UpArrow},
     "Adjacent room above"},
    {"dungeon.room.navigate_down",
     {ImGuiMod_Ctrl, ImGuiKey_DownArrow},
     "Adjacent room below"},
    {"dungeon.room.navigate_left",
     {ImGuiMod_Ctrl, ImGuiKey_LeftArrow},
     "Adjacent room to the left"},
    {"dungeon.room.navigate_right",
     {ImGuiMod_Ctrl, ImGuiKey_RightArrow},
     "Adjacent room to the right"},
    {"dungeon.room.previous",
     {ImGuiMod_Ctrl, ImGuiKey_PageUp},
     "Previous open/recent room"},
    {"dungeon.room.next",
     {ImGuiMod_Ctrl, ImGuiKey_PageDown},
     "Next open/recent room"},
    {"dungeon.open_room_list",
     {ImGuiMod_Ctrl, ImGuiMod_Alt, ImGuiKey_L},
     "Open Room List"},
    {"dungeon.open_entrances",
     {ImGuiMod_Ctrl, ImGuiMod_Shift, ImGuiKey_E},
     "Open Entrances"},
    {"dungeon.open_matrix",
     {ImGuiMod_Ctrl, ImGuiMod_Shift, ImGuiKey_M},
     "Open Room Matrix"},
    {"dungeon.open_room_graphics",
     {ImGuiMod_Ctrl, ImGuiMod_Shift, ImGuiKey_G},
     "Open Room Graphics"},
    {"dungeon.open_palette",
     {ImGuiMod_Ctrl, ImGuiMod_Shift, ImGuiMod_Alt, ImGuiKey_P},
     "Open Palette Editor"},
    {"dungeon.object.select_tool", {ImGuiKey_S}, "Select tool"},
    {"dungeon.object.place_tool", {ImGuiKey_P}, "Place tool"},
    {"dungeon.object.delete_tool", {ImGuiKey_D}, "Delete tool"},
    {"dungeon.object.next_object", {ImGuiKey_RightBracket}, "Next object"},
    {"dungeon.object.prev_object", {ImGuiKey_LeftBracket}, "Previous object"},
    // Ctrl+C / Ctrl+V go through the generic Copy/Paste editor shortcuts,
    // which route to DungeonEditorV2::Copy()/Paste().
    {"dungeon.object.delete", {ImGuiKey_Delete}, "Delete selection"},
};
 
const std::vector<EditorShortcutDef> kOverworldShortcuts = {
    {"overworld.brush_toggle", {ImGuiKey_B}, "Toggle brush"},
    {"overworld.fill", {ImGuiKey_F}, "Fill tool"},
    {"overworld.next_tile", {ImGuiKey_RightBracket}, "Next tile"},
    {"overworld.prev_tile", {ImGuiKey_LeftBracket}, "Previous tile"},
    {"overworld.toggle_fullscreen", {ImGuiKey_F11}, "Toggle canvas fullscreen"},
    {"overworld.toggle_lock", {ImGuiMod_Ctrl, ImGuiKey_L}, "Toggle map lock"},
    {"overworld.toggle_tile16_editor",
     {ImGuiMod_Ctrl, ImGuiKey_T},
     "Toggle Tile16 editor"},
    {"overworld.toggle_item_list",
     {ImGuiMod_Ctrl, ImGuiMod_Shift, ImGuiKey_I},
     "Toggle item list"},
    // Plain digits 1-8 are tools/entity modes (interaction coordinator);
    // Cmd/Ctrl+digits switch editors, so worlds use Alt+digits.
    {"overworld.world_light", {ImGuiMod_Alt, ImGuiKey_1}, "Light World"},
    {"overworld.world_dark", {ImGuiMod_Alt, ImGuiKey_2}, "Dark World"},
    {"overworld.world_special", {ImGuiMod_Alt, ImGuiKey_3}, "Special World"},
    {"overworld.map_left",
     {ImGuiMod_Alt, ImGuiKey_LeftArrow},
     "Map to the left"},
    {"overworld.map_right",
     {ImGuiMod_Alt, ImGuiKey_RightArrow},
     "Map to the right"},
    {"overworld.map_up", {ImGuiMod_Alt, ImGuiKey_UpArrow}, "Map above"},
    {"overworld.map_down", {ImGuiMod_Alt, ImGuiKey_DownArrow}, "Map below"},
    {"overworld.zoom_in", {ImGuiKey_Equal}, "Zoom in"},
    {"overworld.zoom_in_keypad", {ImGuiKey_KeypadAdd}, "Zoom in (keypad)"},
    {"overworld.zoom_out", {ImGuiKey_Minus}, "Zoom out"},
    {"overworld.zoom_out_keypad",
     {ImGuiKey_KeypadSubtract},
     "Zoom out (keypad)"},
    {"overworld.zoom_fit", {ImGuiKey_0}, "Zoom to fit world"},
    {"overworld.center_map", {ImGuiKey_Home}, "Center on selected map"},
    {"overworld.toggle_entities", {ImGuiKey_E}, "Show/hide entities"},
    {"overworld.toggle_grid", {ImGuiKey_G}, "Show/hide grid"},
};
 
// Graphics shortcuts are editor-scoped to EditorType::kGraphics, so the
// single-letter tool keys and =/- zoom only fire while the graphics editor
// is focused and never steal keys from the overworld or music editors.
const std::vector<EditorShortcutDef> kGraphicsShortcuts = {
    // Sheet navigation
    {"graphics.next_sheet", {ImGuiKey_PageDown}, "Next sheet"},
    {"graphics.prev_sheet", {ImGuiKey_PageUp}, "Previous sheet"},
 
    // Tool selection shortcuts
    {"graphics.tool.select", {ImGuiKey_M}, "Select tool"},
    {"graphics.tool.hand", {ImGuiKey_H}, "Hand tool (pan)"},
    {"graphics.tool.pencil", {ImGuiKey_B}, "Pencil tool"},
    {"graphics.tool.brush", {ImGuiKey_P}, "Brush tool"},
    {"graphics.tool.eraser", {ImGuiKey_E}, "Eraser tool"},
    {"graphics.tool.fill", {ImGuiKey_G}, "Fill tool"},
    {"graphics.tool.line", {ImGuiKey_L}, "Line tool"},
    {"graphics.tool.rectangle", {ImGuiKey_R}, "Rectangle tool"},
    {"graphics.tool.eyedropper", {ImGuiKey_I}, "Eyedropper tool"},
 
    // Zoom controls
    {"graphics.zoom_in", {ImGuiKey_Equal}, "Zoom in"},
    {"graphics.zoom_in_keypad", {ImGuiKey_KeypadAdd}, "Zoom in (keypad)"},
    {"graphics.zoom_out", {ImGuiKey_Minus}, "Zoom out"},
    {"graphics.zoom_out_keypad",
     {ImGuiKey_KeypadSubtract},
     "Zoom out (keypad)"},
 
    // View toggles
    {"graphics.toggle_grid", {ImGuiMod_Ctrl, ImGuiKey_G}, "Toggle grid"},
};
 
}  // namespace
 
void ConfigureEditorShortcuts(const ShortcutDependencies& deps,
                              ShortcutManager* shortcut_manager) {
  if (!shortcut_manager) {
    return;
  }
 
  auto* editor_manager = deps.editor_manager;
  auto* ui_coordinator = deps.ui_coordinator;
  auto* popup_manager = deps.popup_manager;
  auto* window_manager = deps.window_manager;
 
  if (editor_manager) {
    shortcut_manager->SetActiveEditorProvider(
        [editor_manager]() -> std::optional<EditorType> {
          auto* current_editor = editor_manager->GetCurrentEditor();
          if (!current_editor) {
            return std::nullopt;
          }
          return current_editor->type();
        });
  }
 
  // Toggle activity bar (48px icon strip) visibility
  RegisterIfValid(
      shortcut_manager, "view.toggle_activity_bar", {ImGuiMod_Ctrl, ImGuiKey_B},
      [window_manager]() {
        if (window_manager) {
          window_manager->ToggleSidebarVisibility();
        }
      },
      Shortcut::Scope::kGlobal);
 
  // Toggle side panel (250px expanded panel) expansion
  RegisterIfValid(
      shortcut_manager, "view.toggle_side_panel",
      {ImGuiMod_Ctrl, ImGuiMod_Alt, ImGuiKey_E},
      [window_manager]() {
        if (window_manager) {
          window_manager->ToggleSidebarExpanded();
        }
      },
      Shortcut::Scope::kGlobal);
 
  // Interface / font scale (Ctrl+/- on Windows/Linux, Cmd+/- on macOS).
  RegisterIfValid(
      shortcut_manager, "ui.font_scale_increase",
      {ImGuiMod_Ctrl, ImGuiKey_Equal},
      [editor_manager]() {
        AdjustUiFontScaleBy(editor_manager, kUiFontScaleStep);
      },
      Shortcut::Scope::kGlobal);
 
  RegisterIfValid(
      shortcut_manager, "ui.font_scale_increase_keypad",
      {ImGuiMod_Ctrl, ImGuiKey_KeypadAdd},
      [editor_manager]() {
        AdjustUiFontScaleBy(editor_manager, kUiFontScaleStep);
      },
      Shortcut::Scope::kGlobal);
 
  RegisterIfValid(
      shortcut_manager, "ui.font_scale_decrease",
      {ImGuiMod_Ctrl, ImGuiKey_Minus},
      [editor_manager]() {
        AdjustUiFontScaleBy(editor_manager, -kUiFontScaleStep);
      },
      Shortcut::Scope::kGlobal);
 
  RegisterIfValid(
      shortcut_manager, "ui.font_scale_decrease_keypad",
      {ImGuiMod_Ctrl, ImGuiKey_KeypadSubtract},
      [editor_manager]() {
        AdjustUiFontScaleBy(editor_manager, -kUiFontScaleStep);
      },
      Shortcut::Scope::kGlobal);
 
  RegisterIfValid(
      shortcut_manager, "ui.font_scale_reset", {ImGuiMod_Ctrl, ImGuiKey_0},
      [editor_manager]() {
        if (!editor_manager || ImGui::GetIO().WantTextInput) {
          return;
        }
        editor_manager->SetFontGlobalScale(1.0f);
      },
      Shortcut::Scope::kGlobal);
 
  RegisterIfValid(
      shortcut_manager, "Open", {ImGuiMod_Ctrl, ImGuiKey_O},
      [editor_manager]() {
        if (editor_manager) {
          editor_manager->LoadRom();
        }
      },
      Shortcut::Scope::kGlobal);
 
  RegisterIfValid(shortcut_manager, "Save", {ImGuiMod_Ctrl, ImGuiKey_S},
                  [editor_manager]() {
                    if (editor_manager) {
                      editor_manager->SaveRom();
                    }
                  });
 
  RegisterIfValid(
      shortcut_manager, "Save As", {ImGuiMod_Ctrl, ImGuiMod_Shift, ImGuiKey_S},
      [editor_manager]() {
        if (editor_manager && editor_manager->popup_manager()) {
          editor_manager->popup_manager()->Show(PopupID::kSaveAs);
        }
      },
      Shortcut::Scope::kGlobal);
 
  RegisterIfValid(
      shortcut_manager, "Close ROM", {ImGuiMod_Ctrl, ImGuiKey_W},
      [editor_manager]() {
        // CloseRom() works with a single session and asks about unsaved
        // edits; CloseCurrentSession() refuses to close the last session.
        if (editor_manager) {
          editor_manager->CloseRom();
        }
      },
      Shortcut::Scope::kGlobal);
 
  RegisterIfValid(
      shortcut_manager, "Quit", {ImGuiMod_Ctrl, ImGuiKey_Q},
      [editor_manager]() {
        if (editor_manager) {
          editor_manager->Quit();
        }
      },
      Shortcut::Scope::kGlobal);
 
  RegisterIfValid(
      shortcut_manager, "Undo", {ImGuiMod_Ctrl, ImGuiKey_Z},
      [editor_manager]() {
        if (editor_manager && editor_manager->GetCurrentEditor()) {
          editor_manager->GetCurrentEditor()->Undo();
        }
      },
      Shortcut::Scope::kEditor);
 
  RegisterIfValid(
      shortcut_manager, "Redo", {ImGuiMod_Ctrl, ImGuiMod_Shift, ImGuiKey_Z},
      [editor_manager]() {
        if (editor_manager && editor_manager->GetCurrentEditor()) {
          editor_manager->GetCurrentEditor()->Redo();
        }
      },
      Shortcut::Scope::kEditor);
 
  // Menus advertise Ctrl+Y; keep Ctrl+Shift+Z as the primary binding.
  RegisterIfValid(
      shortcut_manager, "Redo (Alt)", {ImGuiMod_Ctrl, ImGuiKey_Y},
      [editor_manager]() {
        if (editor_manager && editor_manager->GetCurrentEditor()) {
          editor_manager->GetCurrentEditor()->Redo();
        }
      },
      Shortcut::Scope::kEditor);
 
  RegisterIfValid(
      shortcut_manager, "Cut", {ImGuiMod_Ctrl, ImGuiKey_X},
      [editor_manager]() {
        if (editor_manager && editor_manager->GetCurrentEditor()) {
          editor_manager->GetCurrentEditor()->Cut();
        }
      },
      Shortcut::Scope::kEditor);
 
  RegisterIfValid(
      shortcut_manager, "Copy", {ImGuiMod_Ctrl, ImGuiKey_C},
      [editor_manager]() {
        if (editor_manager && editor_manager->GetCurrentEditor()) {
          editor_manager->GetCurrentEditor()->Copy();
        }
      },
      Shortcut::Scope::kEditor);
 
  RegisterIfValid(
      shortcut_manager, "Paste", {ImGuiMod_Ctrl, ImGuiKey_V},
      [editor_manager]() {
        if (editor_manager && editor_manager->GetCurrentEditor()) {
          editor_manager->GetCurrentEditor()->Paste();
        }
      },
      Shortcut::Scope::kEditor);
 
  RegisterIfValid(
      shortcut_manager, "Find", {ImGuiMod_Ctrl, ImGuiKey_F},
      [editor_manager]() {
        if (editor_manager && editor_manager->GetCurrentEditor()) {
          editor_manager->GetCurrentEditor()->Find();
        }
      },
      Shortcut::Scope::kEditor);
 
  RegisterIfValid(
      shortcut_manager, "Command Palette",
      {ImGuiMod_Ctrl, ImGuiMod_Shift, ImGuiKey_P},
      [ui_coordinator]() {
        if (ui_coordinator) {
          ui_coordinator->ShowCommandPalette();
        }
      },
      Shortcut::Scope::kGlobal);
 
  RegisterIfValid(
      shortcut_manager, "Window Finder", {ImGuiMod_Ctrl, ImGuiKey_P},
      [ui_coordinator]() {
        if (ui_coordinator) {
          ui_coordinator->ShowPanelFinder();
        }
      },
      Shortcut::Scope::kGlobal);
 
  RegisterIfValid(
      shortcut_manager, "Keyboard Shortcuts",
      {ImGuiMod_Ctrl, ImGuiMod_Shift, ImGuiKey_Slash},
      [ui_coordinator]() {
        if (ui_coordinator) {
          ui_coordinator->ShowShortcutsBrowser();
        }
      },
      Shortcut::Scope::kGlobal);
 
  RegisterIfValid(
      shortcut_manager, "Global Search",
      {ImGuiMod_Ctrl, ImGuiMod_Shift, ImGuiKey_K},
      [ui_coordinator]() {
        if (ui_coordinator) {
          ui_coordinator->ShowGlobalSearch();
        }
      },
      Shortcut::Scope::kGlobal);
 
  RegisterIfValid(
      shortcut_manager, "Load Last ROM", {ImGuiMod_Ctrl, ImGuiKey_R},
      [editor_manager]() {
        auto& recent = project::RecentFilesManager::GetInstance();
        if (!recent.GetRecentFiles().empty() && editor_manager) {
          editor_manager->OpenRomOrProject(recent.GetRecentFiles().front());
        }
      },
      Shortcut::Scope::kGlobal);
 
  RegisterIfValid(
      shortcut_manager, "Show About", ImGuiKey_F1,
      [popup_manager]() {
        if (popup_manager) {
          popup_manager->Show("About");
        }
      },
      Shortcut::Scope::kGlobal);
 
  auto register_editor_shortcut = [&](EditorType type, ImGuiKey key) {
    RegisterIfValid(shortcut_manager,
                    absl::StrFormat("switch.%d", static_cast<int>(type)),
                    {ImGuiMod_Ctrl, key}, [editor_manager, type]() {
                      if (editor_manager) {
                        editor_manager->SwitchToEditor(type);
                      }
                    });
  };
 
  register_editor_shortcut(EditorType::kOverworld, ImGuiKey_1);
  register_editor_shortcut(EditorType::kDungeon, ImGuiKey_2);
  register_editor_shortcut(EditorType::kGraphics, ImGuiKey_3);
  register_editor_shortcut(EditorType::kSprite, ImGuiKey_4);
  register_editor_shortcut(EditorType::kMessage, ImGuiKey_5);
  register_editor_shortcut(EditorType::kMusic, ImGuiKey_6);
  register_editor_shortcut(EditorType::kPalette, ImGuiKey_7);
  register_editor_shortcut(EditorType::kScreen, ImGuiKey_8);
  register_editor_shortcut(EditorType::kAssembly, ImGuiKey_9);
  // Ctrl/Cmd+0 is "reset font scale"; Settings uses the platform-standard
  // Ctrl/Cmd+, instead.
  register_editor_shortcut(EditorType::kSettings, ImGuiKey_Comma);
 
  // ============================================================================
  // Editor Switch Commands (command palette with friendly names)
  // ============================================================================
  auto register_editor_command = [&](EditorType type, const std::string& name) {
    shortcut_manager->RegisterCommand(
        absl::StrFormat("Switch to %s Editor", name), [editor_manager, type]() {
          if (editor_manager) {
            editor_manager->SwitchToEditor(type);
          }
        });
  };
 
  register_editor_command(EditorType::kOverworld, "Overworld");
  register_editor_command(EditorType::kDungeon, "Dungeon");
  register_editor_command(EditorType::kGraphics, "Graphics");
  register_editor_command(EditorType::kSprite, "Sprite");
  register_editor_command(EditorType::kMessage, "Message");
  register_editor_command(EditorType::kMusic, "Music");
  register_editor_command(EditorType::kPalette, "Palette");
  register_editor_command(EditorType::kScreen, "Screen");
  register_editor_command(EditorType::kAssembly, "Assembly");
  register_editor_command(EditorType::kSettings, "Settings");
  register_editor_command(EditorType::kPlanning, "Planning");
 
  // Editor-scoped Music shortcuts (toggle playback, speed controls)
  if (editor_manager) {
    for (const auto& def : kMusicEditorShortcuts) {
      RegisterEditorIfValid(
          shortcut_manager, def.id, def.keys,
          [editor_manager, id = def.id]() {
            if (!editor_manager)
              return;
            auto* editor_set = editor_manager->GetCurrentEditorSet();
            auto* music_editor =
                editor_set ? editor_set->GetMusicEditor() : nullptr;
            if (!music_editor)
              return;
 
            if (id == "music.play_pause") {
              music_editor->TogglePlayPause();
            } else if (id == "music.stop") {
              music_editor->StopPlayback();
            } else if (id == "music.speed_up" ||
                       id == "music.speed_up_keypad") {
              music_editor->SpeedUp();
            } else if (id == "music.speed_down" ||
                       id == "music.speed_down_keypad") {
              music_editor->SlowDown();
            }
          },
          EditorType::kMusic);
    }
  }
 
  // Editor-scoped Dungeon shortcuts (object tools)
  if (editor_manager) {
    for (const auto& def : kDungeonEditorShortcuts) {
      RegisterEditorIfValid(
          shortcut_manager, def.id, def.keys,
          [editor_manager, id = def.id]() {
            if (!editor_manager)
              return;
            auto* editor_set = editor_manager->GetCurrentEditorSet();
            auto* dungeon_editor =
                editor_set ? editor_set->GetDungeonEditor() : nullptr;
            if (!dungeon_editor)
              return;
 
            if (id == "dungeon.room.navigate_up") {
              dungeon_editor->NavigateToAdjacentRoom(
                  DungeonRoomNavigationDirection::kUp);
            } else if (id == "dungeon.room.navigate_down") {
              dungeon_editor->NavigateToAdjacentRoom(
                  DungeonRoomNavigationDirection::kDown);
            } else if (id == "dungeon.room.navigate_left") {
              dungeon_editor->NavigateToAdjacentRoom(
                  DungeonRoomNavigationDirection::kLeft);
            } else if (id == "dungeon.room.navigate_right") {
              dungeon_editor->NavigateToAdjacentRoom(
                  DungeonRoomNavigationDirection::kRight);
            } else if (id == "dungeon.room.previous") {
              dungeon_editor->CycleRoomSelection(-1);
            } else if (id == "dungeon.room.next") {
              dungeon_editor->CycleRoomSelection(1);
            } else if (id == "dungeon.open_room_list") {
              dungeon_editor->OpenWindow(DungeonEditorV2::kRoomSelectorId);
            } else if (id == "dungeon.open_entrances") {
              dungeon_editor->OpenWindow("dungeon.entrance_properties");
            } else if (id == "dungeon.open_matrix") {
              dungeon_editor->OpenWindow(DungeonEditorV2::kRoomMatrixId);
            } else if (id == "dungeon.open_room_graphics") {
              dungeon_editor->OpenWindow(DungeonEditorV2::kRoomGraphicsId);
            } else if (id == "dungeon.open_palette") {
              dungeon_editor->OpenWindow(DungeonEditorV2::kPaletteEditorId);
            } else if (id == "dungeon.object.select_tool") {
              // Unified mode: cancel placement to switch to selection.
              if (auto* selector = dungeon_editor->object_editor_panel())
                selector->CancelPlacement();
            } else if (id == "dungeon.object.next_object") {
              (void)dungeon_editor->CycleObjectSelection(1);
            } else if (id == "dungeon.object.prev_object") {
              (void)dungeon_editor->CycleObjectSelection(-1);
            } else if (id == "dungeon.object.delete_tool" ||
                       id == "dungeon.object.delete") {
              dungeon_editor->QueueRoomCanvasDeleteShortcut();
            }
          },
          EditorType::kDungeon);
      if (def.id.starts_with("dungeon.room.")) {
        shortcut_manager->SetShortcutEnabled(def.id, [editor_manager]() {
          if (!editor_manager) {
            return false;
          }
          auto* editor_set = editor_manager->GetCurrentEditorSet();
          auto* dungeon_editor =
              editor_set ? editor_set->GetDungeonEditor() : nullptr;
          return dungeon_editor != nullptr &&
                 dungeon_editor->CanHandleDungeonNavigationShortcut();
        });
      }
    }
  }
 
  // Editor-scoped Overworld shortcuts (basic tools)
  if (editor_manager) {
    for (const auto& def : kOverworldShortcuts) {
      RegisterEditorIfValid(
          shortcut_manager, def.id, def.keys,
          [editor_manager, id = def.id]() {
            if (!editor_manager)
              return;
            auto* editor_set = editor_manager->GetCurrentEditorSet();
            auto* overworld_editor =
                editor_set ? editor_set->GetOverworldEditor() : nullptr;
            if (!overworld_editor)
              return;
 
            if (id == "overworld.brush_toggle") {
              overworld_editor->ToggleBrushTool();
            } else if (id == "overworld.fill") {
              overworld_editor->ActivateFillTool();
            } else if (id == "overworld.next_tile") {
              overworld_editor->CycleTileSelection(1);
            } else if (id == "overworld.prev_tile") {
              overworld_editor->CycleTileSelection(-1);
            } else if (id == "overworld.toggle_fullscreen") {
              overworld_editor->ToggleCanvasFullscreen();
            } else if (id == "overworld.toggle_lock") {
              overworld_editor->ToggleMapLock();
            } else if (id == "overworld.toggle_tile16_editor") {
              overworld_editor->ToggleTile16EditorWindow();
            } else if (id == "overworld.toggle_item_list") {
              overworld_editor->ToggleItemListWindow();
            } else if (id == "overworld.world_light") {
              overworld_editor->SwitchToWorld(0);
            } else if (id == "overworld.world_dark") {
              overworld_editor->SwitchToWorld(1);
            } else if (id == "overworld.world_special") {
              overworld_editor->SwitchToWorld(2);
            } else if (id == "overworld.map_left") {
              overworld_editor->SelectAdjacentMap(-1, 0);
            } else if (id == "overworld.map_right") {
              overworld_editor->SelectAdjacentMap(1, 0);
            } else if (id == "overworld.map_up") {
              overworld_editor->SelectAdjacentMap(0, -1);
            } else if (id == "overworld.map_down") {
              overworld_editor->SelectAdjacentMap(0, 1);
            } else if (id == "overworld.zoom_in" ||
                       id == "overworld.zoom_in_keypad") {
              overworld_editor->ZoomIn();
            } else if (id == "overworld.zoom_out" ||
                       id == "overworld.zoom_out_keypad") {
              overworld_editor->ZoomOut();
            } else if (id == "overworld.zoom_fit") {
              overworld_editor->ZoomToFit();
            } else if (id == "overworld.center_map") {
              overworld_editor->CenterOverworldView();
            } else if (id == "overworld.toggle_entities") {
              overworld_editor->ToggleEntityVisibility();
            } else if (id == "overworld.toggle_grid") {
              overworld_editor->ToggleGrid();
            }
          },
          EditorType::kOverworld);
    }
  }
 
  // Editor-scoped Graphics shortcuts (sheet navigation)
  if (editor_manager) {
    for (const auto& def : kGraphicsShortcuts) {
      RegisterEditorIfValid(
          shortcut_manager, def.id, def.keys,
          [editor_manager, id = def.id]() {
            if (!editor_manager)
              return;
            auto* editor_set = editor_manager->GetCurrentEditorSet();
            auto* graphics_editor =
                editor_set ? editor_set->GetGraphicsEditor() : nullptr;
            if (!graphics_editor)
              return;
 
            static const std::map<std::string, PixelTool> kTools = {
                {"graphics.tool.select", PixelTool::kSelect},
                {"graphics.tool.hand", PixelTool::kHand},
                {"graphics.tool.pencil", PixelTool::kPencil},
                {"graphics.tool.brush", PixelTool::kBrush},
                {"graphics.tool.eraser", PixelTool::kEraser},
                {"graphics.tool.fill", PixelTool::kFill},
                {"graphics.tool.line", PixelTool::kLine},
                {"graphics.tool.rectangle", PixelTool::kRectangle},
                {"graphics.tool.eyedropper", PixelTool::kEyedropper},
            };
            if (id == "graphics.next_sheet") {
              graphics_editor->NextSheet();
            } else if (id == "graphics.prev_sheet") {
              graphics_editor->PrevSheet();
            } else if (auto tool = kTools.find(id); tool != kTools.end()) {
              graphics_editor->SetPixelTool(tool->second);
            } else if (id == "graphics.zoom_in" ||
                       id == "graphics.zoom_in_keypad") {
              graphics_editor->ZoomIn();
            } else if (id == "graphics.zoom_out" ||
                       id == "graphics.zoom_out_keypad") {
              graphics_editor->ZoomOut();
            } else if (id == "graphics.toggle_grid") {
              graphics_editor->ToggleGrid();
            }
          },
          EditorType::kGraphics);
    }
  }
 
  RegisterIfValid(
      shortcut_manager, "Editor Selection", {ImGuiMod_Ctrl, ImGuiKey_E},
      [ui_coordinator]() {
        if (ui_coordinator) {
          ui_coordinator->ShowEditorSelection();
        }
      },
      Shortcut::Scope::kGlobal);
 
  RegisterIfValid(
      shortcut_manager, "Window Browser",
      {ImGuiMod_Ctrl, ImGuiMod_Shift, ImGuiKey_B},
      [ui_coordinator]() {
        if (ui_coordinator) {
          ui_coordinator->ShowWindowBrowser();
        }
      },
      Shortcut::Scope::kGlobal);
  RegisterIfValid(
      shortcut_manager, "Window Browser (Alt)",
      {ImGuiMod_Ctrl, ImGuiMod_Alt, ImGuiKey_P},
      [ui_coordinator]() {
        if (ui_coordinator) {
          ui_coordinator->ShowWindowBrowser();
        }
      },
      Shortcut::Scope::kGlobal);
  RegisterAlias(shortcut_manager, "Panel Browser", "Window Browser");
  RegisterAlias(shortcut_manager, "Panel Browser (Alt)",
                "Window Browser (Alt)");
 
  RegisterIfValid(
      shortcut_manager, "View: Previous Right Drawer",
      {ImGuiMod_Ctrl, ImGuiMod_Alt, ImGuiKey_LeftBracket},
      [editor_manager]() {
        if (!editor_manager) {
          return;
        }
        if (auto* right_drawer = editor_manager->right_drawer_manager()) {
          right_drawer->CycleToPreviousDrawer();
        }
      },
      Shortcut::Scope::kGlobal);
 
  RegisterIfValid(
      shortcut_manager, "View: Next Right Drawer",
      {ImGuiMod_Ctrl, ImGuiMod_Alt, ImGuiKey_RightBracket},
      [editor_manager]() {
        if (!editor_manager) {
          return;
        }
        if (auto* right_drawer = editor_manager->right_drawer_manager()) {
          right_drawer->CycleToNextDrawer();
        }
      },
      Shortcut::Scope::kGlobal);
  RegisterAlias(shortcut_manager, "View: Previous Right Panel",
                "View: Previous Right Drawer");
  RegisterAlias(shortcut_manager, "View: Next Right Panel",
                "View: Next Right Drawer");
 
  if (window_manager) {
    // Note: Using Ctrl+Alt for panel shortcuts to avoid conflicts with Save As
    // (Ctrl+Shift+S)
    RegisterIfValid(
        shortcut_manager, "Show Dungeon Windows",
        {ImGuiMod_Ctrl, ImGuiMod_Alt, ImGuiKey_D},
        [window_manager]() {
          window_manager->ShowAllWindowsInCategory(
              window_manager->GetActiveSessionId(), "Dungeon");
        },
        Shortcut::Scope::kEditor);
    RegisterAlias(shortcut_manager, "Show Dungeon Panels",
                  "Show Dungeon Windows");
    RegisterIfValid(
        shortcut_manager, "Show Graphics Windows",
        {ImGuiMod_Ctrl, ImGuiMod_Alt, ImGuiKey_G},
        [window_manager]() {
          window_manager->ShowAllWindowsInCategory(
              window_manager->GetActiveSessionId(), "Graphics");
        },
        Shortcut::Scope::kEditor);
    RegisterAlias(shortcut_manager, "Show Graphics Panels",
                  "Show Graphics Windows");
    RegisterIfValid(
        shortcut_manager, "Show Screen Windows",
        {ImGuiMod_Ctrl, ImGuiMod_Alt, ImGuiKey_S},
        [window_manager]() {
          window_manager->ShowAllWindowsInCategory(
              window_manager->GetActiveSessionId(), "Screen");
        },
        Shortcut::Scope::kEditor);
    RegisterAlias(shortcut_manager, "Show Screen Panels",
                  "Show Screen Windows");
  }
 
#ifdef YAZE_BUILD_AGENT_UI
  RegisterIfValid(shortcut_manager, "Agent Editor",
                  {ImGuiMod_Ctrl, ImGuiMod_Shift, ImGuiKey_A},
                  [editor_manager]() {
                    if (editor_manager) {
                      editor_manager->ShowAIAgent();
                    }
                  });
 
  RegisterIfValid(shortcut_manager, "Agent Sidebar",
                  {ImGuiMod_Ctrl, ImGuiKey_H}, [editor_manager]() {
                    if (editor_manager) {
                      editor_manager->ShowChatHistory();
                    }
                  });
 
  RegisterIfValid(shortcut_manager, "Proposal Drawer",
                  {ImGuiMod_Ctrl, ImGuiMod_Shift,
                   ImGuiKey_R},  // Changed from Ctrl+P to Ctrl+Shift+R
                  [editor_manager]() {
                    if (editor_manager) {
                      editor_manager->ShowProposalDrawer();
                    }
                  });
#endif
 
  // ============================================================================
  // Layout Presets and Profiles (command palette only - no keyboard shortcuts)
  // ============================================================================
  shortcut_manager->RegisterCommand("Layout Profile: Code", [editor_manager]() {
    if (editor_manager) {
      editor_manager->ApplyLayoutProfile("code");
    }
  });
  shortcut_manager->RegisterCommand(
      "Layout Profile: Debug", [editor_manager]() {
        if (editor_manager) {
          editor_manager->ApplyLayoutProfile("debug");
        }
      });
  shortcut_manager->RegisterCommand(
      "Layout Profile: Mapping", [editor_manager]() {
        if (editor_manager) {
          editor_manager->ApplyLayoutProfile("mapping");
        }
      });
  shortcut_manager->RegisterCommand("Layout Profile: Chat", [editor_manager]() {
    if (editor_manager) {
      editor_manager->ApplyLayoutProfile("chat");
    }
  });
  shortcut_manager->RegisterCommand(
      "Layout Snapshot: Capture", [editor_manager]() {
        if (editor_manager) {
          editor_manager->CaptureTemporaryLayoutSnapshot();
        }
      });
  shortcut_manager->RegisterCommand(
      "Layout Snapshot: Restore", [editor_manager]() {
        if (editor_manager) {
          editor_manager->RestoreTemporaryLayoutSnapshot();
        }
      });
  shortcut_manager->RegisterCommand(
      "Layout Snapshot: Clear", [editor_manager]() {
        if (editor_manager) {
          editor_manager->ClearTemporaryLayoutSnapshot();
        }
      });
 
  shortcut_manager->RegisterCommand(
      "Layout: Apply Minimal Preset", [editor_manager]() {
        if (editor_manager) {
          editor_manager->ApplyLayoutPreset("Minimal");
        }
      });
  shortcut_manager->RegisterCommand(
      "Layout: Apply Developer Preset", [editor_manager]() {
        if (editor_manager) {
          editor_manager->ApplyLayoutPreset("Developer");
        }
      });
  shortcut_manager->RegisterCommand(
      "Layout: Apply Designer Preset", [editor_manager]() {
        if (editor_manager) {
          editor_manager->ApplyLayoutPreset("Designer");
        }
      });
  shortcut_manager->RegisterCommand(
      "Layout: Apply Modder Preset", [editor_manager]() {
        if (editor_manager) {
          editor_manager->ApplyLayoutPreset("Modder");
        }
      });
  shortcut_manager->RegisterCommand(
      "Layout: Apply Overworld Expert Preset", [editor_manager]() {
        if (editor_manager) {
          editor_manager->ApplyLayoutPreset("Overworld Expert");
        }
      });
  shortcut_manager->RegisterCommand(
      "Layout: Apply Dungeon Expert Preset", [editor_manager]() {
        if (editor_manager) {
          editor_manager->ApplyLayoutPreset("Dungeon Expert");
        }
      });
  shortcut_manager->RegisterCommand(
      "Layout: Apply Testing Preset", [editor_manager]() {
        if (editor_manager) {
          editor_manager->ApplyLayoutPreset("Testing");
        }
      });
  shortcut_manager->RegisterCommand(
      "Layout: Apply Audio Preset", [editor_manager]() {
        if (editor_manager) {
          editor_manager->ApplyLayoutPreset("Audio");
        }
      });
  shortcut_manager->RegisterCommand(
      "Layout: Reset Current Editor", [editor_manager]() {
        if (editor_manager) {
          editor_manager->ResetCurrentEditorLayout();
        }
      });
 
  // ============================================================================
  // Right Drawer / Panel Toggle Commands (command palette only)
  // ============================================================================
  if (editor_manager) {
    using DrawerType = RightDrawerManager::DrawerType;
    auto* right_drawer_manager = editor_manager->right_drawer_manager();
    if (right_drawer_manager) {
      struct DrawerCmd {
        const char* label;
        DrawerType type;
      };
      DrawerCmd drawer_cmds[] = {
          {"View: Toggle AI Agent Panel", DrawerType::kAgentChat},
          {"View: Toggle AI Agent Drawer", DrawerType::kAgentChat},
          {"View: Toggle Proposals Panel", DrawerType::kProposals},
          {"View: Toggle Proposals Drawer", DrawerType::kProposals},
          {"View: Toggle Settings Panel", DrawerType::kSettings},
          {"View: Toggle Settings Drawer", DrawerType::kSettings},
          {"View: Toggle Help Panel", DrawerType::kHelp},
          {"View: Toggle Help Drawer", DrawerType::kHelp},
          {"View: Toggle Notifications", DrawerType::kNotifications},
          {"View: Toggle Notifications Drawer", DrawerType::kNotifications},
          {"View: Toggle Properties Panel", DrawerType::kProperties},
          {"View: Toggle Properties Drawer", DrawerType::kProperties},
          {"View: Toggle Project Panel", DrawerType::kProject},
          {"View: Toggle Project Drawer", DrawerType::kProject},
      };
      for (const auto& cmd : drawer_cmds) {
        shortcut_manager->RegisterCommand(
            cmd.label, [right_drawer_manager, drawer_type = cmd.type]() {
              right_drawer_manager->ToggleDrawer(drawer_type);
            });
      }
      // The Previous/Next Right Drawer cycle commands are registered above
      // with their Ctrl+Alt+[ / ] chords; re-registering them here as
      // keyless commands used to erase those chords.
    }
  }
 
  // ============================================================================
  // Window + Panel Visibility Commands (command palette only)
  // ============================================================================
  if (window_manager) {
    auto categories = window_manager->GetAllCategories();
    const size_t registration_session_id = window_manager->GetActiveSessionId();
 
    shortcut_manager->RegisterCommand(
        "View: Show Panel Browser",
        [window_manager]() { window_manager->TriggerShowWindowBrowser(); });
    shortcut_manager->RegisterCommand(
        "View: Show Window Browser",
        [window_manager]() { window_manager->TriggerShowWindowBrowser(); });
 
    for (const auto& category : categories) {
      auto windows = window_manager->GetWindowsInCategory(
          registration_session_id, category);
      for (const auto& window : windows) {
        const std::string window_id = window.card_id;
        const std::string display_name = window.display_name;
 
        shortcut_manager->RegisterCommand(
            absl::StrFormat("View: Show %s", display_name),
            [window_manager, window_id]() {
              if (window_manager) {
                window_manager->OpenWindow(window_manager->GetActiveSessionId(),
                                           window_id);
              }
            });
        shortcut_manager->RegisterCommand(
            absl::StrFormat("View: Hide %s", display_name),
            [window_manager, window_id]() {
              if (window_manager) {
                window_manager->CloseWindow(
                    window_manager->GetActiveSessionId(), window_id);
              }
            });
        shortcut_manager->RegisterCommand(
            absl::StrFormat("View: Toggle %s", display_name),
            [window_manager, window_id]() {
              if (window_manager) {
                window_manager->ToggleWindow(
                    window_manager->GetActiveSessionId(), window_id);
              }
            });
 
        shortcut_manager->RegisterCommand(
            absl::StrFormat("View: Open %s Window", display_name),
            [window_manager, window_id]() {
              if (window_manager) {
                window_manager->OpenWindow(window_manager->GetActiveSessionId(),
                                           window_id);
              }
            });
        shortcut_manager->RegisterCommand(
            absl::StrFormat("View: Close %s Window", display_name),
            [window_manager, window_id]() {
              if (window_manager) {
                window_manager->CloseWindow(
                    window_manager->GetActiveSessionId(), window_id);
              }
            });
        shortcut_manager->RegisterCommand(
            absl::StrFormat("View: Toggle %s Window", display_name),
            [window_manager, window_id]() {
              if (window_manager) {
                window_manager->ToggleWindow(
                    window_manager->GetActiveSessionId(), window_id);
              }
            });
      }
 
      shortcut_manager->RegisterCommand(
          absl::StrFormat("View: Show All %s Panels", category),
          [window_manager, category]() {
            if (window_manager) {
              window_manager->ShowAllWindowsInCategory(
                  window_manager->GetActiveSessionId(), category);
            }
          });
      shortcut_manager->RegisterCommand(
          absl::StrFormat("View: Hide All %s Panels", category),
          [window_manager, category]() {
            if (window_manager) {
              window_manager->HideAllWindowsInCategory(
                  window_manager->GetActiveSessionId(), category);
            }
          });
      shortcut_manager->RegisterCommand(
          absl::StrFormat("View: Show All %s Windows", category),
          [window_manager, category]() {
            if (window_manager) {
              window_manager->ShowAllWindowsInCategory(
                  window_manager->GetActiveSessionId(), category);
            }
          });
      shortcut_manager->RegisterCommand(
          absl::StrFormat("View: Hide All %s Windows", category),
          [window_manager, category]() {
            if (window_manager) {
              window_manager->HideAllWindowsInCategory(
                  window_manager->GetActiveSessionId(), category);
            }
          });
    }
  }
}
 
void ConfigureMenuShortcuts(const ShortcutDependencies& deps,
                            ShortcutManager* shortcut_manager) {
  if (!shortcut_manager) {
    return;
  }
 
  auto* menu_orchestrator = deps.menu_orchestrator;
  auto* session_coordinator = deps.session_coordinator;
  auto* workspace_manager = deps.workspace_manager;
  auto* editor_manager = deps.editor_manager;
 
  RegisterIfValid(shortcut_manager, "New Session",
                  {ImGuiMod_Ctrl, ImGuiMod_Shift, ImGuiKey_N},
                  [session_coordinator]() {
                    if (session_coordinator) {
                      session_coordinator->CreateNewSession();
                    }
                  });
 
  RegisterIfValid(shortcut_manager, "Duplicate Session",
                  {ImGuiMod_Ctrl, ImGuiMod_Shift, ImGuiKey_D},
                  [session_coordinator]() {
                    if (session_coordinator) {
                      session_coordinator->DuplicateCurrentSession();
                    }
                  });
 
  RegisterIfValid(shortcut_manager, "Close Session",
                  {ImGuiMod_Ctrl, ImGuiMod_Shift, ImGuiKey_W},
                  [editor_manager, session_coordinator]() {
                    if (editor_manager) {
                      editor_manager->CloseCurrentSession();
                    } else if (session_coordinator) {
                      session_coordinator->CloseCurrentSession();
                    }
                  });
 
  RegisterIfValid(shortcut_manager, "Session Switcher",
                  {ImGuiMod_Ctrl, ImGuiKey_Tab}, [session_coordinator]() {
                    if (session_coordinator) {
                      session_coordinator->ShowSessionSwitcher();
                    }
                  });
 
  RegisterIfValid(shortcut_manager, "Save Layout",
                  {ImGuiMod_Ctrl, ImGuiMod_Shift, ImGuiKey_L},
                  [workspace_manager]() {
                    if (workspace_manager) {
                      workspace_manager->SaveWorkspaceLayout();
                    }
                  });
 
  RegisterIfValid(shortcut_manager, "Load Layout",
                  {ImGuiMod_Ctrl, ImGuiMod_Shift, ImGuiKey_O},
                  [workspace_manager]() {
                    if (workspace_manager) {
                      workspace_manager->LoadWorkspaceLayout();
                    }
                  });
 
  // Note: Changed from Ctrl+Shift+R to Ctrl+Alt+R to avoid conflict with
  // Proposal Drawer
  RegisterIfValid(shortcut_manager, "Reset Layout",
                  {ImGuiMod_Ctrl, ImGuiMod_Alt, ImGuiKey_R},
                  [workspace_manager]() {
                    if (workspace_manager) {
                      workspace_manager->ResetWorkspaceLayout();
                    }
                  });
 
  // F11 and Ctrl+T (Test Dashboard) are global; the overworld editor's
  // editor-scoped F11 (canvas fullscreen) and Ctrl+T (Tile16 editor) win
  // while it is active.
  RegisterIfValid(shortcut_manager, "Maximize Window", ImGuiKey_F11,
                  [workspace_manager]() {
                    if (workspace_manager) {
                      workspace_manager->MaximizeCurrentWindow();
                    }
                  });
 
#ifdef YAZE_ENABLE_TESTING
  RegisterIfValid(shortcut_manager, "Test Dashboard",
                  {ImGuiMod_Ctrl, ImGuiKey_T}, [menu_orchestrator]() {
                    if (menu_orchestrator) {
                      menu_orchestrator->OnShowTestDashboard();
                    }
                  });
#endif
}
 
void ApplyUserShortcutOverrides(const UserSettings& user_settings,
                                ShortcutManager* shortcut_manager) {
  if (!shortcut_manager) {
    return;
  }
  auto apply = [&](const std::unordered_map<std::string, std::string>& map) {
    for (const auto& [name, binding] : map) {
      if (!shortcut_manager->FindShortcut(name)) {
        continue;  // Stale entry for a shortcut that no longer exists.
      }
      if (binding.empty()) {
        // Explicitly unbound by the user.
        shortcut_manager->UpdateShortcutKeys(name, {});
        continue;
      }
      auto keys = ParseShortcut(binding);
      if (keys.empty()) {
        LOG_WARN("Shortcuts", "Ignoring unparseable binding '%s' for '%s'",
                 binding.c_str(), name.c_str());
        continue;
      }
      shortcut_manager->UpdateShortcutKeys(name, keys);
    }
  };
  apply(user_settings.prefs().global_shortcuts);
  apply(user_settings.prefs().editor_shortcuts);
}
 
void ConfigurePanelShortcuts(const ShortcutDependencies& deps,
                             ShortcutManager* shortcut_manager) {
  if (!shortcut_manager) {
    return;
  }
 
  auto* window_manager = deps.window_manager;
  auto* user_settings = deps.user_settings;
 
  // Global/editor rebinds from Settings are applied before panel bindings so
  // the panel collision check below sees the user's effective chords.
  if (user_settings) {
    ApplyUserShortcutOverrides(*user_settings, shortcut_manager);
  }
 
  if (!window_manager) {
    return;
  }
 
  size_t session_id = deps.session_coordinator
                          ? deps.session_coordinator->GetActiveSessionId()
                          : 0;
 
  // Get all categories and panels
  auto categories = window_manager->GetAllCategories();
 
  for (const auto& category : categories) {
    // Panels belong to the editor that owns their category; their toggles only
    // compete for a chord while that editor is active.
    std::optional<EditorType> owner;
    const EditorType category_type =
        EditorRegistry::GetEditorTypeFromCategory(category);
    if (EditorRegistry::GetEditorCategory(category_type) == category) {
      owner = category_type;
    }
 
    auto panels = window_manager->GetWindowsInCategory(session_id, category);
 
    for (const auto& panel : panels) {
      if (panel.shortcut_scope != WindowDescriptor::ShortcutScope::kPanel) {
        continue;
      }
 
      std::string shortcut_string;
      bool user_defined = false;
 
      // Check for user-defined shortcut first
      if (user_settings) {
        auto it = user_settings->prefs().panel_shortcuts.find(panel.card_id);
        if (it != user_settings->prefs().panel_shortcuts.end()) {
          shortcut_string = it->second;
          user_defined = !shortcut_string.empty();
        }
      }
 
      // Fall back to default shortcut_hint
      if (shortcut_string.empty() && !panel.shortcut_hint.empty()) {
        shortcut_string = panel.shortcut_hint;
      }
 
      if (shortcut_string.empty()) {
        continue;
      }
      auto keys = ParseShortcut(shortcut_string);
      if (keys.empty()) {
        continue;
      }
 
      const std::string toggle_id = "view.toggle." + panel.card_id;
      // A default hint must not shadow an existing binding (Command Palette,
      // Save As, Window Browser, an editor's own keys, ...). The hint stays
      // visible in the UI; the user can bind it explicitly in Settings.
      if (!user_defined) {
        const auto conflicts =
            shortcut_manager->FindConflicts(keys, owner, toggle_id);
        if (!conflicts.empty()) {
          LOG_DEBUG("Shortcuts",
                    "Skipping default panel shortcut %s for '%s' (used by "
                    "'%s')",
                    shortcut_string.c_str(), panel.card_id.c_str(),
                    conflicts.front().c_str());
          continue;
        }
      }
 
      std::string panel_id_copy = panel.card_id;
      RegisterIfValid(
          shortcut_manager, toggle_id, keys,
          [window_manager, panel_id_copy]() {
            window_manager->ToggleWindow(window_manager->GetActiveSessionId(),
                                         panel_id_copy);
          },
          Shortcut::Scope::kPanel);
      shortcut_manager->SetShortcutEditor(toggle_id, owner);
    }
  }
}
 
}  // namespace yaze::editor