panel_manager.h

Go to the documentation of this file.

#ifndef APP_EDITOR_SYSTEM_PANEL_MANAGER_H_
#define APP_EDITOR_SYSTEM_PANEL_MANAGER_H_
 
#include <algorithm>
#include <cstdint>
#include <functional>
#include <list>
#include <memory>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
#include "app/editor/core/event_bus.h"
#include "app/editor/events/core_events.h"
#include "app/editor/system/editor_panel.h"
#include "app/editor/system/file_browser.h"
 
#ifndef YAZE_ENABLE_CARD_SHIM_DEPRECATION
#define YAZE_ENABLE_CARD_SHIM_DEPRECATION 1
#endif
 
#if YAZE_ENABLE_CARD_SHIM_DEPRECATION && defined(__has_cpp_attribute)
#if __has_cpp_attribute(deprecated)
#define YAZE_CARD_SHIM_DEPRECATED(msg) [[deprecated(msg)]]
#else
#define YAZE_CARD_SHIM_DEPRECATED(msg)
#endif
#else
#define YAZE_CARD_SHIM_DEPRECATED(msg)
#endif
 
namespace yaze {
 
namespace gui {
class PanelWindow;
}  // namespace gui
 
namespace editor {
 
// Forward declarations
enum class EditorType;
class Editor;
 
struct PanelDescriptor {
  std::string card_id;       // Unique identifier (e.g., "dungeon.room_selector")
  std::string display_name;  // Human-readable name (e.g., "Room Selector")
  std::string window_title;  // ImGui window title for DockBuilder (e.g., " Rooms List")
  std::string icon;          // Material icon
  std::string category;      // Category (e.g., "Dungeon", "Graphics", "Palette")
 
  // Lifecycle behavior on editor switches (default: EditorBound).
  PanelCategory panel_category = PanelCategory::EditorBound;
 
  // Optional context binding (default: none).
  PanelContextScope context_scope = PanelContextScope::kNone;
 
  PanelScope scope = PanelScope::kSession;
  enum class ShortcutScope {
    kGlobal,   // Available regardless of active editor
    kEditor,   // Only active within the owning editor
    kPanel     // Panel visibility/within-panel actions
  };
  std::string shortcut_hint; // Display hint (e.g., "Ctrl+Shift+R")
  ShortcutScope shortcut_scope = ShortcutScope::kPanel;
  bool* visibility_flag;          // Pointer to bool controlling visibility
  std::function<void()> on_show;  // Callback when card is shown
  std::function<void()> on_hide;  // Callback when card is hidden
  int priority;                   // Display priority for menus (lower = higher)
 
  // Disabled state support for IDE-like behavior
  std::function<bool()> enabled_condition;  // Returns true if card is enabled (nullptr = always enabled)
  std::string disabled_tooltip;             // Tooltip shown when hovering disabled card
 
  std::string GetWindowTitle() const {
    if (!window_title.empty()) {
      return window_title;
    }
    // Generate from icon + display_name if window_title not explicitly set
    return icon + " " + display_name;
  }
 
  std::string GetImGuiWindowName() const {
    const std::string label =
        icon.empty() ? display_name : (icon + " " + display_name);
    if (!card_id.empty()) {
      return label + "##" + card_id;
    }
    return label;
  }
};
 
class PanelManager {
 public:
  PanelManager() = default;
  ~PanelManager() = default;
 
  // Non-copyable, non-movable
  PanelManager(const PanelManager&) = delete;
  PanelManager& operator=(const PanelManager&) = delete;
  PanelManager(PanelManager&&) = delete;
  PanelManager& operator=(PanelManager&&) = delete;
 
  // Special category for dashboard/welcome screen - suppresses panel drawing
  static constexpr const char* kDashboardCategory = "Dashboard";
 
  // ============================================================================
  // Session Lifecycle Management
  // ============================================================================
 
  void RegisterSession(size_t session_id);
  void UnregisterSession(size_t session_id);
  void SetActiveSession(size_t session_id);
 
  // ============================================================================
  // Context Keys (Optional Policy Engine)
  // ============================================================================
 
  void SetContextKey(size_t session_id, PanelContextScope scope,
                     std::string key);
  std::string GetContextKey(size_t session_id, PanelContextScope scope) const;
 
  // ============================================================================
  // Panel Registration
  // ============================================================================
 
  void RegisterPanel(size_t session_id, const PanelDescriptor& base_info);
 
  void RegisterPanelAlias(const std::string& legacy_base_id,
                          const std::string& canonical_base_id);
 
  std::string ResolvePanelAlias(const std::string& panel_id) const;
 
  void RegisterPanel(size_t session_id, const std::string& card_id,
                    const std::string& display_name, const std::string& icon,
                    const std::string& category,
                    const std::string& shortcut_hint = "", int priority = 50,
                    std::function<void()> on_show = nullptr,
                    std::function<void()> on_hide = nullptr,
                    bool visible_by_default = false);
 
  void UnregisterPanel(size_t session_id, const std::string& base_card_id);
  void UnregisterPanelsWithPrefix(const std::string& prefix);
  void ClearAllPanels();
 
  // ============================================================================
  // EditorPanel Instance Management (Phase 4)
  // ============================================================================
 
  void RegisterRegistryPanel(std::unique_ptr<EditorPanel> panel);
 
  void RegisterRegistryPanelsForSession(size_t session_id);
 
  size_t GetRegistryPanelCount() const { return registry_panel_ids_.size(); }
 
  void RegisterEditorPanel(std::unique_ptr<EditorPanel> panel);
 
  void UnregisterEditorPanel(const std::string& panel_id);
 
  EditorPanel* GetEditorPanel(const std::string& panel_id);
 
  void DrawAllVisiblePanels();
 
  void OnEditorSwitch(const std::string& from_category,
                      const std::string& to_category);
 
  // ============================================================================
  // Panel Control (Programmatic)
  // ============================================================================
 
  bool ShowPanel(size_t session_id, const std::string& base_card_id);
  bool HidePanel(size_t session_id, const std::string& base_card_id);
  bool TogglePanel(size_t session_id, const std::string& base_card_id);
  bool IsPanelVisible(size_t session_id, const std::string& base_card_id) const;
  bool* GetVisibilityFlag(size_t session_id, const std::string& base_card_id);
 
  // ============================================================================
  // Batch Operations
  // ============================================================================
 
  void ShowAllPanelsInSession(size_t session_id);
  void HideAllPanelsInSession(size_t session_id);
  void ShowAllPanelsInCategory(size_t session_id, const std::string& category);
  void HideAllPanelsInCategory(size_t session_id, const std::string& category);
  void ShowOnlyPanel(size_t session_id, const std::string& base_card_id);
 
  // ============================================================================
  // Query Methods
  // ============================================================================
 
  std::vector<std::string> GetPanelsInSession(size_t session_id) const;
  std::vector<PanelDescriptor> GetPanelsInCategory(size_t session_id,
                                           const std::string& category) const;
  std::vector<std::string> GetAllCategories(size_t session_id) const;
  const PanelDescriptor* GetPanelDescriptor(size_t session_id,
                              const std::string& base_card_id) const;
 
  const std::unordered_map<std::string, PanelDescriptor>& GetAllPanelDescriptors() const {
    return cards_;
  }
 
  std::vector<std::string> GetAllCategories() const;
 
  // ============================================================================
  // State Persistence
  // ============================================================================
 
  std::vector<std::string> GetVisiblePanelIds(size_t session_id) const;
 
  void SetVisiblePanels(size_t session_id,
                        const std::vector<std::string>& panel_ids);
 
  std::unordered_map<std::string, bool> SerializeVisibilityState(
      size_t session_id) const;
 
  void RestoreVisibilityState(
      size_t session_id, const std::unordered_map<std::string, bool>& state,
      bool publish_events = false);
 
  std::unordered_map<std::string, bool> SerializePinnedState() const;
 
  void RestorePinnedState(const std::unordered_map<std::string, bool>& state);
 
  std::string GetPanelWindowName(size_t session_id,
                                 const std::string& base_card_id) const;
 
  std::string GetPanelWindowName(const PanelDescriptor& descriptor) const;
 
  static constexpr float GetSidebarWidth() { return 48.0f; }
  static constexpr float GetSidePanelWidth() { return 300.0f; }
  struct SidePanelWidthBounds {
    float min_width;
    float max_width;
  };
  static SidePanelWidthBounds GetSidePanelWidthBounds(float viewport_width);
  static float GetSidePanelWidthForViewport(float viewport_width) {
    if (viewport_width <= 0.0f) {
      return GetSidePanelWidth();
    }
 
    // Keep side panel useful on compact/touch widths while preserving
    // desktop defaults on large displays.
    if (viewport_width < 900.0f) {
      const float preferred = viewport_width * 0.50f;
      const float min_width = std::max(220.0f, viewport_width * 0.40f);
      const float max_width =
          std::max(min_width, std::min(380.0f, viewport_width * 0.58f));
      return std::clamp(preferred, min_width, max_width);
    }
 
    if (viewport_width < 1200.0f) {
      const float preferred = viewport_width * 0.34f;
      const float min_width = 300.0f;
      const float max_width = std::min(420.0f, viewport_width * 0.42f);
      return std::clamp(preferred, min_width, max_width);
    }
 
    // iPad Pro landscape sits in this range; avoid falling back to a narrow
    // desktop sidebar width that feels cramped for touch navigation.
    if (viewport_width < 1400.0f) {
      const float preferred = viewport_width * 0.25f;
      const float min_width = 300.0f;
      const float max_width = 380.0f;
      return std::clamp(preferred, min_width, max_width);
    }
 
    float width = GetSidePanelWidth();
    const float max_width = viewport_width * 0.30f;
    if (max_width > 0.0f && width > max_width) {
      width = max_width;
    }
    return width;
  }
  float GetActiveSidePanelWidth(float viewport_width) const;
  void SetActiveSidePanelWidth(float width, float viewport_width = 0.0f,
                               bool notify = true);
  void ResetSidePanelWidth(bool notify = true);
  float GetStoredSidePanelWidth() const { return side_panel_width_; }
  void SetStoredSidePanelWidth(float width, bool notify = false) {
    SetActiveSidePanelWidth(width, 0.0f, notify);
  }
  void SetSidePanelWidthChangedCallback(std::function<void(float)> cb) {
    on_side_panel_width_changed_ = std::move(cb);
  }
 
  float GetPanelBrowserCategoryWidth() const {
    return panel_browser_category_width_;
  }
  void SetPanelBrowserCategoryWidth(float width, bool notify = true);
  void SetPanelBrowserCategoryWidthChangedCallback(
      std::function<void(float)> cb) {
    on_panel_browser_category_width_changed_ = std::move(cb);
  }
  static constexpr float GetDefaultPanelBrowserCategoryWidth() {
    return 260.0f;
  }
 
  static constexpr float GetCollapsedSidebarWidth() { return 16.0f; }
 
  static std::string GetCategoryIcon(const std::string& category);
 
  struct CategoryTheme {
    float r, g, b, a;  // Icon color when active
    float glow_r, glow_g, glow_b;  // Glow/accent color (same hue)
  };
  static CategoryTheme GetCategoryTheme(const std::string& category);
 
  void HandleSidebarKeyboardNav(size_t session_id,
                                const std::vector<PanelDescriptor>& cards);
 
  bool SidebarHasFocus() const { return sidebar_has_focus_; }
  int GetFocusedPanelIndex() const { return focused_card_index_; }
 
  void ToggleSidebarVisibility() {
    sidebar_visible_ = !sidebar_visible_;
    if (on_sidebar_state_changed_) {
      on_sidebar_state_changed_(sidebar_visible_, panel_expanded_);
    }
  }
 
  void SetSidebarVisible(bool visible, bool notify = true) {
    if (sidebar_visible_ != visible) {
      sidebar_visible_ = visible;
      if (notify && on_sidebar_state_changed_) {
        on_sidebar_state_changed_(sidebar_visible_, panel_expanded_);
      }
    }
  }
 
  bool IsSidebarVisible() const { return sidebar_visible_; }
 
  void TogglePanelExpanded() {
    panel_expanded_ = !panel_expanded_;
    if (on_sidebar_state_changed_) {
      on_sidebar_state_changed_(sidebar_visible_, panel_expanded_);
    }
  }
 
  void SetPanelExpanded(bool expanded, bool notify = true) {
    if (panel_expanded_ != expanded) {
      panel_expanded_ = expanded;
      if (notify && on_sidebar_state_changed_) {
        on_sidebar_state_changed_(sidebar_visible_, panel_expanded_);
      }
    }
  }
 
  bool IsPanelExpanded() const { return panel_expanded_; }
 
  // ============================================================================
  // EventBus Integration
  // ============================================================================
 
  void SetEventBus(EventBus* event_bus) { event_bus_ = event_bus; }
 
  // ============================================================================
  // Triggers (exposed for ActivityBar) - prefer EventBus, fallback to callbacks
  // ============================================================================
 
  void TriggerShowEmulator() {
    if (event_bus_) {
      event_bus_->Publish(UIActionRequestEvent::ShowEmulator());
    }
  }
  void TriggerShowSettings() {
    if (event_bus_) {
      event_bus_->Publish(UIActionRequestEvent::ShowSettings());
    }
  }
  void TriggerShowPanelBrowser() {
    if (event_bus_) {
      event_bus_->Publish(UIActionRequestEvent::Create(
          UIActionRequestEvent::Action::kShowPanelBrowser));
    }
  }
  void TriggerSaveRom() {
    if (event_bus_) {
      event_bus_->Publish(UIActionRequestEvent::SaveRom());
    }
  }
  void TriggerUndo() {
    if (event_bus_) {
      event_bus_->Publish(UIActionRequestEvent::Undo());
    }
  }
  void TriggerRedo() {
    if (event_bus_) {
      event_bus_->Publish(UIActionRequestEvent::Redo());
    }
  }
  void TriggerShowSearch() {
    if (event_bus_) {
      event_bus_->Publish(UIActionRequestEvent::Create(
          UIActionRequestEvent::Action::kShowSearch));
    }
  }
  void TriggerShowShortcuts() {
    if (event_bus_) {
      event_bus_->Publish(UIActionRequestEvent::Create(
          UIActionRequestEvent::Action::kShowShortcuts));
    }
  }
  void TriggerShowCommandPalette() {
    if (event_bus_) {
      event_bus_->Publish(UIActionRequestEvent::ShowCommandPalette());
    }
  }
  void TriggerShowHelp() {
    if (event_bus_) {
      event_bus_->Publish(UIActionRequestEvent::Create(
          UIActionRequestEvent::Action::kShowHelp));
    }
  }
  void TriggerShowAgentChatSidebar() {
    if (event_bus_) {
      event_bus_->Publish(UIActionRequestEvent::ShowAgentChatSidebar());
    }
  }
  void TriggerShowAgentProposalsSidebar() {
    if (event_bus_) {
      event_bus_->Publish(UIActionRequestEvent::ShowAgentProposalsSidebar());
    }
  }
  void TriggerResetLayout() {
    if (event_bus_) {
      event_bus_->Publish(UIActionRequestEvent::Create(
          UIActionRequestEvent::Action::kResetLayout));
    }
  }
  void TriggerOpenRom() {
    if (event_bus_) {
      event_bus_->Publish(UIActionRequestEvent::OpenRom());
    }
  }
  void TriggerPanelClicked(const std::string& category) {
    if (on_card_clicked_) on_card_clicked_(category);
  }
  void TriggerCategorySelected(const std::string& category) {
    if (on_category_selected_) on_category_selected_(category);
  }
 
  // ============================================================================
  // Utility Icon Callbacks (DEPRECATED: subscribe to UIActionRequestEvent instead)
  // ============================================================================
 
  void SetSidebarStateChangedCallback(
      std::function<void(bool, bool)> cb) {
    on_sidebar_state_changed_ = std::move(cb);
  }
 
  // ============================================================================
  // Unified Visibility Management (single source of truth)
  // ============================================================================
 
  bool IsEmulatorVisible() const { return emulator_visible_; }
  void SetEmulatorVisible(bool visible) {
    if (emulator_visible_ != visible) {
      emulator_visible_ = visible;
      if (on_emulator_visibility_changed_) {
        on_emulator_visibility_changed_(visible);
      }
    }
  }
  void ToggleEmulatorVisible() { SetEmulatorVisible(!emulator_visible_); }
  void SetEmulatorVisibilityChangedCallback(std::function<void(bool)> cb) {
    on_emulator_visibility_changed_ = std::move(cb);
  }
  void SetCategoryChangedCallback(std::function<void(const std::string&)> cb) {
    on_category_changed_ = std::move(cb);
  }
 
  // ============================================================================
  // Workspace Presets
  // ============================================================================
 
  struct WorkspacePreset {
    std::string name;
    std::vector<std::string> visible_cards;  // Panel IDs
    std::string description;
  };
 
  void SavePreset(const std::string& name, const std::string& description = "");
  bool LoadPreset(const std::string& name);
  void DeletePreset(const std::string& name);
  std::vector<WorkspacePreset> GetPresets() const;
 
  // ============================================================================
  // Panel Validation (for catching ImGui window-name mismatches)
  // ============================================================================
 
  struct PanelValidationResult {
    std::string card_id;
    std::string expected_title;  // Exact ImGui window name for docking/focus
    bool found_in_imgui;         // Whether ImGui found a window with this title
    std::string message;         // Human-readable status
  };
 
  std::vector<PanelValidationResult> ValidatePanels() const;
  PanelValidationResult ValidatePanel(const std::string& card_id) const;
 
  // ============================================================================
  // Quick Actions
  // ============================================================================
 
  void ShowAll(size_t session_id);
  void HideAll(size_t session_id);
  void ResetToDefaults(size_t session_id);
  void ResetToDefaults(size_t session_id, EditorType editor_type);
 
  // ============================================================================
  // Statistics
  // ============================================================================
 
  size_t GetPanelCount() const { return cards_.size(); }
  size_t GetVisiblePanelCount(size_t session_id) const;
  size_t GetSessionCount() const { return session_count_; }
 
  // ============================================================================
  // Session Prefixing Utilities
  // ============================================================================
 
  std::string MakePanelId(size_t session_id, const std::string& base_id) const;
  std::string MakePanelId(size_t session_id, const std::string& base_id,
                          PanelScope scope) const;
  bool ShouldPrefixPanels() const { return session_count_ > 1; }
 
  // ============================================================================
  // Convenience Methods (for EditorManager direct usage without session_id)
  // ============================================================================
 
  void RegisterPanel(const PanelDescriptor& base_info) {
    RegisterPanel(active_session_, base_info);
  }
  void UnregisterPanel(const std::string& base_card_id) {
    UnregisterPanel(active_session_, base_card_id);
  }
  bool ShowPanel(const std::string& base_card_id) {
    return ShowPanel(active_session_, base_card_id);
  }
  bool HidePanel(const std::string& base_card_id) {
    return HidePanel(active_session_, base_card_id);
  }
  bool IsPanelVisible(const std::string& base_card_id) const {
    return IsPanelVisible(active_session_, base_card_id);
  }
  void HideAllPanelsInCategory(const std::string& category) {
    HideAllPanelsInCategory(active_session_, category);
  }
  std::string GetActiveCategory() const { return active_category_; }
  void SetActiveCategory(const std::string& category, bool notify = true) {
    if (active_category_ != category) {
      active_category_ = category;
      if (notify && on_category_changed_) {
        on_category_changed_(category);
      }
    }
  }
  void ShowAllPanelsInCategory(const std::string& category) {
    ShowAllPanelsInCategory(active_session_, category);
  }
  bool* GetVisibilityFlag(const std::string& base_card_id) {
    return GetVisibilityFlag(active_session_, base_card_id);
  }
  void ShowAll() { ShowAll(active_session_); }
  void HideAll() { HideAll(active_session_); }
  void SetOnPanelClickedCallback(std::function<void(const std::string&)> callback) {
    on_card_clicked_ = std::move(callback);
  }
  void SetOnCategorySelectedCallback(std::function<void(const std::string&)> callback) {
    on_category_selected_ = std::move(callback);
  }
  void SetEditorResolver(std::function<Editor*(const std::string&)> resolver) {
    editor_resolver_ = std::move(resolver);
  }
 
  size_t GetActiveSessionId() const { return active_session_; }
 
  // ============================================================================
  // File Browser Integration
  // ============================================================================
 
  FileBrowser* GetFileBrowser(const std::string& category);
  void EnableFileBrowser(const std::string& category,
                         const std::string& root_path = "");
  void DisableFileBrowser(const std::string& category);
  bool HasFileBrowser(const std::string& category) const;
  void SetFileBrowserPath(const std::string& category, const std::string& path);
  void SetFileClickedCallback(
      std::function<void(const std::string& category, const std::string& path)>
          callback) {
    on_file_clicked_ = std::move(callback);
  }
 
  // ============================================================================
  // Favorites (delegates to Pinned) and Recent
  // ============================================================================
 
  // Favorites are now aliases for pinned panels
  void ToggleFavorite(const std::string& card_id) {
    SetPanelPinned(card_id, !IsPanelPinned(card_id));
  }
  bool IsFavorite(const std::string& card_id) const {
    return IsPanelPinned(card_id);
  }
 
  void MarkPanelRecentlyUsed(const std::string& card_id);
 
  std::vector<PanelDescriptor> GetPanelsSortedByMRU(
      size_t session_id, const std::string& category) const;
 
  uint64_t GetPanelMRUTime(const std::string& card_id) const {
    auto iter = last_used_at_.find(card_id);
    return (iter != last_used_at_.end()) ? iter->second : 0;
  }
 
  // ============================================================================
  // Pinning (Phase 3 scaffold)
  // ============================================================================
 
  void SetPanelPinned(size_t session_id, const std::string& base_card_id, bool pinned);
  bool IsPanelPinned(size_t session_id, const std::string& base_card_id) const;
  std::vector<std::string> GetPinnedPanels(size_t session_id) const;
 
  void SetPanelPinned(const std::string& base_card_id, bool pinned);
  bool IsPanelPinned(const std::string& base_card_id) const;
  std::vector<std::string> GetPinnedPanels() const;
 
  // ============================================================================
  // Resource Management (Phase 6)
  // ============================================================================
 
  void EnforceResourceLimits(const std::string& resource_type);
 
  void MarkPanelUsed(const std::string& panel_id);
 
  EditorPanel* FindPanelInstance(const std::string& prefixed_panel_id,
                                 const std::string& base_panel_id);
  const EditorPanel* FindPanelInstance(const std::string& prefixed_panel_id,
                                       const std::string& base_panel_id) const;
 
 private:
  struct PanelContextScopeHash {
    size_t operator()(PanelContextScope scope) const noexcept {
      return static_cast<size_t>(scope);
    }
  };
 
  void ApplyContextPolicy(size_t session_id, PanelContextScope scope,
                          const std::string& old_key,
                          const std::string& new_key);
  std::string ResolveBasePanelId(const std::string& panel_id) const;
  std::string GetBaseIdForPrefixedId(size_t session_id,
                                    const std::string& prefixed_id) const;
 
  // ... existing private members ...
 
  // Resource panel tracking: type -> list of panel_ids (front = LRU, back = MRU)
  std::unordered_map<std::string, std::list<std::string>> resource_panels_;
  
  // Map panel_id -> resource_type for quick lookups
  std::unordered_map<std::string, std::string> panel_resource_types_;
 
  // ... existing private members ...
  // Core card storage (prefixed IDs → PanelDescriptor)
  std::unordered_map<std::string, PanelDescriptor> cards_;
 
  // EditorPanel instance storage (panel_id → EditorPanel)
  // Panels with instances are drawn by DrawAllVisiblePanels()
  std::unordered_map<std::string, std::unique_ptr<EditorPanel>> panel_instances_;
  std::unordered_set<std::string> registry_panel_ids_;
  std::unordered_set<std::string> global_panel_ids_;
 
  // MRU timestamp tracking (panel_id -> monotonic counter)
  std::unordered_map<std::string, uint64_t> last_used_at_;
  uint64_t mru_counter_ = 0;
 
  // Centralized visibility flags for cards without external flags
  std::unordered_map<std::string, bool> centralized_visibility_;
  // Pinned state tracking (prefixed ID → pinned)
  std::unordered_map<std::string, bool> pinned_panels_;
 
  // Session tracking
  size_t session_count_ = 0;
  size_t active_session_ = 0;
 
  // Maps session_id → vector of prefixed card IDs registered for that session
  std::unordered_map<size_t, std::vector<std::string>> session_cards_;
 
  // Maps session_id → (base_card_id → prefixed_card_id)
  std::unordered_map<size_t, std::unordered_map<std::string, std::string>>
      session_card_mapping_;
 
  // Maps session_id → (prefixed_card_id → base_card_id)
  std::unordered_map<size_t, std::unordered_map<std::string, std::string>>
      session_reverse_card_mapping_;
 
  // Backward compatibility aliases for renamed panel IDs.
  // Maps legacy base_id -> canonical base_id.
  std::unordered_map<std::string, std::string> panel_id_aliases_;
 
  // Context keys per session (used by SetContextKey/GetContextKey).
  std::unordered_map<size_t,
                     std::unordered_map<PanelContextScope, std::string,
                                        PanelContextScopeHash>>
      session_context_keys_;
 
  // Workspace presets
  std::unordered_map<std::string, WorkspacePreset> presets_;
 
  // Active category tracking
  std::string active_category_;
  std::vector<std::string> recent_categories_;
  static constexpr size_t kMaxRecentCategories = 5;
 
  // Sidebar state
  bool sidebar_visible_ = false;    // Controls Activity Bar visibility (0px vs 48px)
  bool panel_expanded_ = false;     // Controls Side Panel visibility (0px vs 250px) - starts collapsed
  float side_panel_width_ = 0.0f;   // 0 = use responsive default
  float panel_browser_category_width_ =
      GetDefaultPanelBrowserCategoryWidth();
 
  // Keyboard navigation state (click-to-focus modal)
  int focused_card_index_ = -1;    // Currently focused card index (-1 = none)
  bool sidebar_has_focus_ = false; // Whether sidebar has keyboard focus
 
  // Unified visibility state (single source of truth)
  bool emulator_visible_ = false;  // Emulator window visibility
 
  // EventBus for action events (preferred over callbacks)
  EventBus* event_bus_ = nullptr;
 
  // State change callbacks
  std::function<void(bool visible, bool expanded)> on_sidebar_state_changed_;
  std::function<void(float width)> on_side_panel_width_changed_;
  std::function<void(float width)> on_panel_browser_category_width_changed_;
  std::function<void(const std::string&)> on_category_changed_;
  std::function<void(const std::string&)> on_card_clicked_;
  std::function<void(const std::string&)> on_category_selected_;  // Activity Bar icon clicked
  std::function<void(bool)> on_emulator_visibility_changed_;
  std::function<void(const std::string&, const std::string&)> on_file_clicked_;
  std::function<Editor*(const std::string&)> editor_resolver_;
 
  // File browser for categories that support it (e.g., Assembly)
  std::unordered_map<std::string, std::unique_ptr<FileBrowser>>
      category_file_browsers_;
 
  // Tracking active editor categories for visual feedback
  std::unordered_set<std::string> active_editor_categories_;
 
  // Helper methods
  void UpdateSessionCount();
  std::string GetPrefixedPanelId(size_t session_id,
                                const std::string& base_id) const;
  void RegisterPanelDescriptorForSession(size_t session_id,
                                         const EditorPanel& panel);
  void TrackPanelForSession(size_t session_id, const std::string& base_id,
                            const std::string& panel_id);
  void UnregisterSessionPanels(size_t session_id);
  void SavePresetsToFile();
  void LoadPresetsFromFile();
};
 
}  // namespace editor
}  // namespace yaze
 
#undef YAZE_CARD_SHIM_DEPRECATED
 
#endif  // APP_EDITOR_SYSTEM_PANEL_MANAGER_H_