editor_card_registry.h

Go to the documentation of this file.

#ifndef YAZE_APP_EDITOR_SYSTEM_EDITOR_CARD_REGISTRY_H_
#define YAZE_APP_EDITOR_SYSTEM_EDITOR_CARD_REGISTRY_H_
 
#include <functional>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
 
#include "imgui/imgui.h"
 
namespace yaze {
namespace editor {
 
// Forward declaration
class EditorCard;
 
struct CardInfo {
  std::string card_id;           // Unique identifier (e.g., "dungeon.room_selector")
  std::string display_name;      // Human-readable name (e.g., "Room Selector")
  std::string icon;              // Material icon
  std::string category;          // Category (e.g., "Dungeon", "Graphics", "Palette")
  std::string shortcut_hint;     // Display hint (e.g., "Ctrl+Shift+R")
  bool* visibility_flag;         // Pointer to bool controlling visibility
  EditorCard* card_instance;     // Pointer to actual card (optional)
  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)
};
 
class EditorCardRegistry {
 public:
  EditorCardRegistry() = default;
  ~EditorCardRegistry() = default;
  
  // Non-copyable, non-movable (manages pointers and callbacks)
  EditorCardRegistry(const EditorCardRegistry&) = delete;
  EditorCardRegistry& operator=(const EditorCardRegistry&) = delete;
  EditorCardRegistry(EditorCardRegistry&&) = delete;
  EditorCardRegistry& operator=(EditorCardRegistry&&) = delete;
  
  // ============================================================================
  // Session Lifecycle Management
  // ============================================================================
  
  void RegisterSession(size_t session_id);
  
  void UnregisterSession(size_t session_id);
  
  void SetActiveSession(size_t session_id);
  
  // ============================================================================
  // Card Registration
  // ============================================================================
  
  void RegisterCard(size_t session_id, const CardInfo& base_info);
  
  void RegisterCard(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 UnregisterCard(size_t session_id, const std::string& base_card_id);
  
  void UnregisterCardsWithPrefix(const std::string& prefix);
  
  void ClearAllCards();
  
  // ============================================================================
  // Card Control (Programmatic, No GUI)
  // ============================================================================
  
  bool ShowCard(size_t session_id, const std::string& base_card_id);
  
  bool HideCard(size_t session_id, const std::string& base_card_id);
  
  bool ToggleCard(size_t session_id, const std::string& base_card_id);
  
  bool IsCardVisible(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 ShowAllCardsInSession(size_t session_id);
  
  void HideAllCardsInSession(size_t session_id);
  
  void ShowAllCardsInCategory(size_t session_id, const std::string& category);
  
  void HideAllCardsInCategory(size_t session_id, const std::string& category);
  
  void ShowOnlyCard(size_t session_id, const std::string& base_card_id);
  
  // ============================================================================
  // Query Methods
  // ============================================================================
  
  std::vector<std::string> GetCardsInSession(size_t session_id) const;
  
  std::vector<CardInfo> GetCardsInCategory(size_t session_id, const std::string& category) const;
  
  std::vector<std::string> GetAllCategories(size_t session_id) const;
  
  const CardInfo* GetCardInfo(size_t session_id, const std::string& base_card_id) const;
  
  std::vector<std::string> GetAllCategories() const;
  
  // ============================================================================
  // View Menu Integration
  // ============================================================================
  
  void DrawViewMenuSection(size_t session_id, const std::string& category);
  
  void DrawViewMenuAll(size_t session_id);
  
  // ============================================================================
  // VSCode-Style Sidebar
  // ============================================================================
  
  void DrawSidebar(size_t session_id,
                  const std::string& category,
                  const std::vector<std::string>& active_categories = {},
                  std::function<void(const std::string&)> on_category_switch = nullptr,
                  std::function<void()> on_collapse = nullptr);
  
  static constexpr float GetSidebarWidth() { return 48.0f; }
  
  // ============================================================================
  // Compact Controls for Menu Bar
  // ============================================================================
  
  void DrawCompactCardControl(size_t session_id, const std::string& category);
  
  void DrawInlineCardToggles(size_t session_id, const std::string& category);
  
  // ============================================================================
  // Card Browser UI
  // ============================================================================
  
  void DrawCardBrowser(size_t session_id, bool* p_open);
  
  // ============================================================================
  // Workspace Presets
  // ============================================================================
  
  struct WorkspacePreset {
    std::string name;
    std::vector<std::string> visible_cards;  // Card 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;
  
  // ============================================================================
  // Quick Actions
  // ============================================================================
  
  void ShowAll(size_t session_id);
  void HideAll(size_t session_id);
  void ResetToDefaults(size_t session_id);
  
  // ============================================================================
  // Statistics
  // ============================================================================
  
  size_t GetCardCount() const { return cards_.size(); }
  size_t GetVisibleCardCount(size_t session_id) const;
  size_t GetSessionCount() const { return session_count_; }
  
  // ============================================================================
  // Session Prefixing Utilities
  // ============================================================================
  
  std::string MakeCardId(size_t session_id, const std::string& base_id) const;
  
  bool ShouldPrefixCards() const { return session_count_ > 1; }
  
  // ============================================================================
  // Convenience Methods (for EditorManager direct usage without session_id)
  // ============================================================================
  
  void RegisterCard(const CardInfo& base_info) {
    RegisterCard(active_session_, base_info);
  }
  
  bool ShowCard(const std::string& base_card_id) {
    return ShowCard(active_session_, base_card_id);
  }
  
  bool HideCard(const std::string& base_card_id) {
    return HideCard(active_session_, base_card_id);
  }
  
  bool IsCardVisible(const std::string& base_card_id) const {
    return IsCardVisible(active_session_, base_card_id);
  }
  
  void HideAllCardsInCategory(const std::string& category) {
    HideAllCardsInCategory(active_session_, category);
  }
  
  void DrawCardBrowser(bool* p_open) {
    DrawCardBrowser(active_session_, p_open);
  }
  
  std::string GetActiveCategory() const { return active_category_; }
  
  void SetActiveCategory(const std::string& category) { active_category_ = category; }
  
  void ShowAllCardsInCategory(const std::string& category) {
    ShowAllCardsInCategory(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 DrawSidebar(const std::string& category,
                  const std::vector<std::string>& active_categories = {},
                  std::function<void(const std::string&)> on_category_switch = nullptr,
                  std::function<void()> on_collapse = nullptr) {
    DrawSidebar(active_session_, category, active_categories, on_category_switch, on_collapse);
  }
  
 private:
  // Core card storage (prefixed IDs → CardInfo)
  std::unordered_map<std::string, CardInfo> cards_;
  
  // Centralized visibility flags for cards without external flags
  std::unordered_map<std::string, bool> centralized_visibility_;
  
  // 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_;
  
  // 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;
  
  // Helper methods
  void UpdateSessionCount();
  std::string GetPrefixedCardId(size_t session_id, const std::string& base_id) const;
  void UnregisterSessionCards(size_t session_id);
  void SavePresetsToFile();
  void LoadPresetsFromFile();
  
  // UI drawing helpers (internal)
  void DrawCardMenuItem(const CardInfo& info);
  void DrawCardInSidebar(const CardInfo& info, bool is_active);
};
 
}  // namespace editor
}  // namespace yaze
 
#endif  // YAZE_APP_EDITOR_SYSTEM_EDITOR_CARD_REGISTRY_H_