editor_registry.cc

Go to the documentation of this file.

#include "editor_registry.h"
 
#include <unordered_set>
#include <utility>
 
#include "absl/strings/str_format.h"
#include "app/editor/editor.h"
 
namespace yaze {
namespace editor {
 
// Static mappings for editor types
const std::unordered_map<EditorType, std::string>
    EditorRegistry::kEditorCategories = {{EditorType::kDungeon, "Dungeon"},
                                         {EditorType::kOverworld, "Overworld"},
                                         {EditorType::kGraphics, "Graphics"},
                                         {EditorType::kPalette, "Palette"},
                                         {EditorType::kSprite, "Sprite"},
                                         {EditorType::kScreen, "Screen"},
                                         {EditorType::kMessage, "Message"},
                                         {EditorType::kMusic, "Music"},
                                         {EditorType::kAssembly, "Assembly"},
                                         {EditorType::kEmulator, "Emulator"},
                                         {EditorType::kHex, "Memory"},
                                         {EditorType::kAgent, "Agent"},
                                         {EditorType::kSettings, "System"}};
 
const std::unordered_map<EditorType, std::string> EditorRegistry::kEditorNames =
    {{EditorType::kDungeon, "Dungeon Editor"},
     {EditorType::kOverworld, "Overworld Editor"},
     {EditorType::kGraphics, "Graphics Editor"},
     {EditorType::kPalette, "Palette Editor"},
     {EditorType::kSprite, "Sprite Editor"},
     {EditorType::kScreen, "Screen Editor"},
     {EditorType::kMessage, "Message Editor"},
     {EditorType::kMusic, "Music Editor"},
     {EditorType::kAssembly, "Assembly Editor"},
     {EditorType::kEmulator, "Emulator Editor"},
     {EditorType::kHex, "Hex Editor"},
     {EditorType::kAgent, "Agent Editor"},
     {EditorType::kSettings, "Settings Editor"}};
 
const std::unordered_map<EditorType, bool> EditorRegistry::kPanelBasedEditors =
    {
        {EditorType::kDungeon, true},
        {EditorType::kOverworld, true},
        {EditorType::kGraphics, true},
        {EditorType::kPalette, true},
        {EditorType::kSprite, true},
        {EditorType::kScreen, true},
        {EditorType::kMessage, true},
        {EditorType::kMusic, true},
        {EditorType::kAssembly, true},
        {EditorType::kEmulator, true},
        {EditorType::kHex, true},
        {EditorType::kAgent, true},     // Agent: Panel-based UI
        {EditorType::kSettings, false}  // Settings: Sidebar panel
};
 
bool EditorRegistry::IsPanelBasedEditor(EditorType type) {
  auto it = kPanelBasedEditors.find(type);
  return it != kPanelBasedEditors.end() && it->second;
}
 
bool EditorRegistry::UpdateAllowedWithoutLoadedRom(EditorType type) {
  switch (type) {
    case EditorType::kAssembly:
    case EditorType::kGraphics:
      return true;
    default:
      return false;
  }
}
 
bool EditorRegistry::IsExperimentalEditor(EditorType type) {
  switch (type) {
    case EditorType::kScreen:
    case EditorType::kMusic:
    case EditorType::kAgent:
      return true;
    default:
      return false;
  }
}
 
std::string EditorRegistry::GetEditorName(EditorType type) {
  auto it = kEditorNames.find(type);
  if (it != kEditorNames.end()) {
    return it->second;
  }
  return "Unknown Editor";
}
 
std::string EditorRegistry::GetEditorCategory(EditorType type) {
  auto it = kEditorCategories.find(type);
  if (it != kEditorCategories.end()) {
    return it->second;
  }
  return "Unknown";
}
 
EditorType EditorRegistry::GetEditorTypeFromCategory(
    const std::string& category) {
  if (category == "Hex") {
    return EditorType::kHex;
  }
  for (const auto& [type, cat] : kEditorCategories) {
    if (cat == category) {
      return type;  // Return first match
    }
  }
  return EditorType::kSettings;  // Default fallback
}
 
std::vector<std::string> EditorRegistry::GetAllEditorCategories() {
  // Returns all editor categories in preferred display order for the sidebar
  // This is a fixed list to ensure consistent ordering
  return {
      "Overworld",  // Primary map editing
      "Dungeon",    // Dungeon/room editing
      "Graphics",   // Graphics sheet editing
      "Palette",    // Color palette editing
      "Sprite",     // Sprite editing
      "Message",    // Text/dialogue editing
      "Screen",     // Screen/title editing
      "Music",      // Music/SPC editing
      "Assembly",   // Code editing
      "Memory",     // Hex editor (uses "Memory" category for cards)
      "Emulator",   // Game testing
      "Agent"       // AI Agent
  };
}
 
std::vector<EditorType> EditorRegistry::GetEditorsInCategory(
    const std::string& category) const {
  std::vector<EditorType> editors;
 
  for (const auto& [type, cat] : kEditorCategories) {
    if (cat == category) {
      editors.push_back(type);
    }
  }
 
  return editors;
}
 
std::vector<std::string> EditorRegistry::GetAvailableCategories() const {
  std::vector<std::string> categories;
  std::unordered_set<std::string> seen;
 
  for (const auto& [type, category] : kEditorCategories) {
    if (seen.find(category) == seen.end()) {
      categories.push_back(category);
      seen.insert(category);
    }
  }
 
  return categories;
}
 
std::string EditorRegistry::GetEditorDisplayName(EditorType type) const {
  auto it = kEditorNames.find(type);
  if (it != kEditorNames.end()) {
    return it->second;
  }
  return "Unknown Editor";
}
 
void EditorRegistry::RegisterEditor(EditorType type, Editor* editor) {
  ValidateEditorType(type);
 
  if (!editor) {
    throw std::invalid_argument("Editor pointer cannot be null");
  }
 
  registered_editors_[type] = editor;
  printf("[EditorRegistry] Registered %s\n",
         GetEditorDisplayName(type).c_str());
}
 
void EditorRegistry::RegisterFactory(EditorType type, EditorFactory factory) {
  ValidateEditorType(type);
  if (!factory) {
    throw std::invalid_argument("Editor factory cannot be null");
  }
  editor_factories_[type] = std::move(factory);
}
 
void EditorRegistry::UnregisterFactory(EditorType type) {
  ValidateEditorType(type);
  editor_factories_.erase(type);
}
 
bool EditorRegistry::HasFactory(EditorType type) const {
  ValidateEditorType(type);
  return editor_factories_.find(type) != editor_factories_.end();
}
 
std::unique_ptr<Editor> EditorRegistry::CreateEditor(EditorType type,
                                                     Rom* rom) const {
  ValidateEditorType(type);
  auto it = editor_factories_.find(type);
  if (it == editor_factories_.end()) {
    return nullptr;
  }
  return it->second(rom);
}
 
void EditorRegistry::UnregisterEditor(EditorType type) {
  ValidateEditorType(type);
 
  auto it = registered_editors_.find(type);
  if (it != registered_editors_.end()) {
    registered_editors_.erase(it);
    printf("[EditorRegistry] Unregistered %s\n",
           GetEditorDisplayName(type).c_str());
  }
}
 
Editor* EditorRegistry::GetEditor(EditorType type) const {
  ValidateEditorType(type);
 
  auto it = registered_editors_.find(type);
  if (it != registered_editors_.end()) {
    return it->second;
  }
  return nullptr;
}
 
bool EditorRegistry::IsEditorActive(EditorType type) const {
  ValidateEditorType(type);
 
  auto it = registered_editors_.find(type);
  if (it != registered_editors_.end() && it->second) {
    return *it->second->active();
  }
  return false;
}
 
bool EditorRegistry::IsEditorVisible(EditorType type) const {
  ValidateEditorType(type);
 
  auto it = registered_editors_.find(type);
  if (it != registered_editors_.end() && it->second) {
    return *it->second->active();
  }
  return false;
}
 
void EditorRegistry::SetEditorActive(EditorType type, bool active) {
  ValidateEditorType(type);
 
  auto it = registered_editors_.find(type);
  if (it != registered_editors_.end() && it->second) {
    it->second->set_active(active);
  }
}
 
bool EditorRegistry::IsValidEditorType(EditorType type) const {
  return kEditorCategories.find(type) != kEditorCategories.end();
}
 
void EditorRegistry::ValidateEditorType(EditorType type) const {
  if (!IsValidEditorType(type)) {
    throw std::invalid_argument(
        absl::StrFormat("Invalid editor type: %d", static_cast<int>(type)));
  }
}
 
}  // namespace editor
}  // namespace yaze