editor.h

Go to the documentation of this file.

#ifndef YAZE_APP_CORE_EDITOR_H
#define YAZE_APP_CORE_EDITOR_H
 
#include <array>
#include <cstddef>
#include <functional>
#include <vector>
 
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "absl/strings/str_format.h"
#include "app/editor/core/undo_manager.h"
#include "app/editor/editor_context_snapshot.h"
#include "app/editor/overworld/maps/overworld_property_edit.h"
#include "app/editor/shell/feedback/popup_manager.h"
#include "app/editor/system/shortcut_manager.h"
 
// Forward declaration in yaze::core namespace
namespace yaze {
namespace core {
class VersionManager;
}
}  // namespace yaze
 
namespace yaze {
 
// Forward declarations
class Rom;
namespace gfx {
class IRenderer;
}
namespace emu {
class Emulator;
}
namespace project {
struct YazeProject;
}  // namespace project
namespace zelda3 {
struct GameData;
}  // namespace zelda3
 
namespace editor {
 
// Forward declarations
struct GfxGroupWorkspaceState;
class GlobalEditorContext;
class WorkspaceWindowManager;
class ToastManager;
class UserSettings;
class StatusBar;
 
struct EditorContext {
  Rom* rom = nullptr;
  zelda3::GameData* game_data = nullptr;
 
  // Check if context is valid for operations
  bool IsValid() const { return rom != nullptr && game_data != nullptr; }
  bool HasRom() const { return rom != nullptr; }
  bool HasGameData() const { return game_data != nullptr; }
 
  // Implicit conversion to bool for quick validity checks
  explicit operator bool() const { return IsValid(); }
};
 
// Shared clipboard for cross-editor copy/paste operations.
struct SharedClipboard {
  bool has_overworld_tile16 = false;
  std::vector<int> overworld_tile16_ids;
  int overworld_width = 0;
  int overworld_height = 0;
  bool has_overworld_map_metadata = false;
  OverworldMapMetadataClipboard overworld_map_metadata;
 
  void Clear() {
    has_overworld_tile16 = false;
    overworld_tile16_ids.clear();
    overworld_width = 0;
    overworld_height = 0;
    has_overworld_map_metadata = false;
    overworld_map_metadata = {};
  }
};
 
// Data-layer dependencies: ROM, game data, project, session identity.
struct CoreDependencies {
  Rom* rom = nullptr;
  zelda3::GameData* game_data = nullptr;
  project::YazeProject* project = nullptr;
  core::VersionManager* version_manager = nullptr;
  GlobalEditorContext* global_context = nullptr;
  size_t session_id = 0;
 
  EditorContext context() const { return {rom, game_data}; }
  bool HasContext() const { return rom != nullptr && game_data != nullptr; }
};
 
// UI-layer dependencies: panel/popup/toast/shortcut managers.
struct UIDependencies {
  WorkspaceWindowManager* window_manager = nullptr;
  ToastManager* toast_manager = nullptr;
  UndoManager* undo_manager = nullptr;
  PopupManager* popup_manager = nullptr;
  ShortcutManager* shortcut_manager = nullptr;
  SharedClipboard* shared_clipboard = nullptr;
  UserSettings* user_settings = nullptr;
  StatusBar* status_bar = nullptr;
};
 
struct EditorDependencies {
  // --- Core (data-layer) dependencies ---
  Rom* rom = nullptr;
  zelda3::GameData* game_data = nullptr;
  project::YazeProject* project = nullptr;
  core::VersionManager* version_manager = nullptr;
  GlobalEditorContext* global_context = nullptr;
  size_t session_id = 0;
  GfxGroupWorkspaceState* gfx_group_workspace = nullptr;
 
  // --- UI-layer dependencies ---
  WorkspaceWindowManager* window_manager = nullptr;
  ToastManager* toast_manager = nullptr;
  UndoManager* undo_manager = nullptr;
  PopupManager* popup_manager = nullptr;
  ShortcutManager* shortcut_manager = nullptr;
  SharedClipboard* shared_clipboard = nullptr;
  UserSettings* user_settings = nullptr;
  StatusBar* status_bar = nullptr;
 
  // --- Specialized dependencies ---
  gfx::IRenderer* renderer = nullptr;
  emu::Emulator* emulator = nullptr;
  void* custom_data = nullptr;
  // Resolve the descriptor that normal Project Save actually writes. Editors
  // with detached assets must not mutate only the session's captured snapshot.
  std::function<project::YazeProject*()> project_context_provider;
 
  // Extract sub-structs for passing to components that only need a subset.
  CoreDependencies GetCoreDeps() const {
    return {rom,       game_data, project, version_manager, global_context,
            session_id};
  }
  UIDependencies GetUIDeps() const {
    return {window_manager,   toast_manager,    undo_manager,  popup_manager,
            shortcut_manager, shared_clipboard, user_settings, status_bar};
  }
 
  EditorContext context() const { return {rom, game_data}; }
  bool HasContext() const { return rom != nullptr && game_data != nullptr; }
};
 
enum class EditorType {
  kUnknown,
  kAssembly,
  kDungeon,
  kEmulator,
  kGraphics,
  kMusic,
  kOverworld,
  kPalette,
  kScreen,
  kSprite,
  kMessage,
  kHex,
  kAgent,
  kSettings,
  // Values are persisted (recent editors, "switch.<n>" shortcuts): append only.
  kPlanning,
};
 
constexpr std::array<const char*, 15> kEditorNames = {
    "Unknown", "Assembly",  "Dungeon", "Emulator", "Graphics",
    "Music",   "Overworld", "Palette", "Screen",   "Sprite",
    "Message", "Hex",       "Agent",   "Settings", "Planning",
};
 
constexpr EditorType kLastEditorType = EditorType::kPlanning;
constexpr size_t kEditorTypeCount = static_cast<size_t>(kLastEditorType) + 1;
static_assert(kEditorNames.size() == kEditorTypeCount);
 
inline size_t EditorTypeIndex(EditorType type) {
  return static_cast<size_t>(type);
}
 
class Editor {
 public:
  Editor() = default;
  virtual ~Editor() = default;
 
  virtual void SetDependencies(const EditorDependencies& deps) {
    dependencies_ = deps;
  }
 
  // Set GameData for Zelda3-specific data access
  virtual void SetGameData(zelda3::GameData* game_data) {
    dependencies_.game_data = game_data;
  }
 
  // Initialization of the editor, no ROM assets.
  virtual void Initialize() = 0;
 
  // Initialization of ROM assets.
  virtual absl::Status Load() = 0;
 
  // Save the editor state.
  virtual absl::Status Save() = 0;
 
  // Coordinated-save lifecycle. Editors that clear model-level dirty state
  // during Save() can override these hooks to checkpoint and restore it when a
  // later serializer, validation gate, backup, or disk write fails. Default
  // implementations keep existing editors source-compatible.
  virtual absl::Status BeginSaveTransaction() { return absl::OkStatus(); }
  virtual void RollbackSaveTransaction() {}
  virtual void CommitSaveTransaction() {}
 
  // Release callbacks and raw references to session-owned workspace panels
  // before WorkspaceWindowManager destroys those panels. Session teardown is
  // terminal, and implementations must tolerate repeated calls.
  virtual void PrepareForSessionTeardown() {}
 
  // Update the editor state, ran every frame.
  virtual absl::Status Update() = 0;
 
  virtual absl::Status Cut() = 0;
  virtual absl::Status Copy() = 0;
  virtual absl::Status Paste() = 0;
 
  virtual absl::Status Undo() = 0;
  virtual absl::Status Redo() = 0;
 
  // Undo description for toast feedback (queries editor's UndoManager)
  virtual std::string GetUndoDescription() const {
    return undo_manager_.GetUndoDescription();
  }
  virtual std::string GetRedoDescription() const {
    return undo_manager_.GetRedoDescription();
  }
 
  const UndoManager& undo_manager() const { return undo_manager_; }
 
  virtual absl::Status Find() = 0;
 
  virtual absl::Status Clear() { return absl::OkStatus(); }
 
  // Edit-menu availability. The menu bar uses these to enable or disable
  // Undo/Redo/Cut/Copy/Paste/Find for the active editor, so an action that
  // cannot run is greyed out instead of producing a failure toast.
  //
  // Undo/Redo default to the base UndoManager state; editors that keep undo
  // history elsewhere (text widgets, PaletteManager, pending gestures) must
  // override. Clipboard defaults to true so editors with real clipboard
  // support keep working without an override; editors whose clipboard calls
  // are no-ops should return false. Find defaults to false because almost no
  // editor implements it.
  virtual bool CanUndo() const { return undo_manager_.CanUndo(); }
  virtual bool CanRedo() const { return undo_manager_.CanRedo(); }
  virtual bool CanCut() const { return true; }
  virtual bool CanCopy() const { return true; }
  virtual bool CanPaste() const { return true; }
  virtual bool CanFind() const { return false; }
 
  // Push editor-specific context into the shared status bar.
  // Called each frame on the currently active editor by EditorManager.
  // Default no-op; override to surface cursor/selection/zoom/mode/custom
  // segments via StatusBar's Set* setters.
  virtual void ContributeStatus(StatusBar* /*status_bar*/) {}
 
  // Push editor-specific top menu items into the main menu bar.
  // Called when this editor is active. Runs inside an open BeginMenu scope.
  virtual void DrawEditorMenu() {}
 
  // Push editor-specific items into the main Edit menu, after the shared
  // items. Called when this editor is active, inside the open Edit menu.
  // Draw a leading separator when adding anything.
  virtual void DrawEditMenuItems() {}
 
  virtual EditorContextSnapshot BuildContextSnapshot() const {
    EditorContextSnapshot snapshot;
    const size_t index = EditorTypeIndex(type_);
    if (index < kEditorNames.size()) {
      snapshot.category = kEditorNames[index];
      snapshot.title = snapshot.category;
      snapshot.semantic_owner = snapshot.category;
    }
    return snapshot;
  }
 
  EditorType type() const { return type_; }
 
  bool* active() { return &active_; }
  void set_active(bool active) { active_ = active; }
  void toggle_active() { active_ = !active_; }
 
  // ROM loading state helpers (default implementations)
  virtual bool IsRomLoaded() const { return false; }
  virtual std::string GetRomStatus() const {
    return "ROM state not implemented";
  }
 
  // Accessors for common dependencies
  Rom* rom() const { return dependencies_.rom; }
  zelda3::GameData* game_data() const { return dependencies_.game_data; }
  project::YazeProject* project() const { return dependencies_.project; }
  core::VersionManager* version_manager() const {
    return dependencies_.version_manager;
  }
 
  // Get bundled context for sub-components
  EditorContext context() const { return dependencies_.context(); }
  bool HasContext() const { return dependencies_.HasContext(); }
 
 protected:
  bool active_ = false;
  EditorType type_;
  EditorDependencies dependencies_;
  UndoManager undo_manager_;
 
  // Helper method to create session-aware card titles for multi-session support
  std::string MakePanelTitle(const std::string& base_title) const {
    if (dependencies_.session_id > 0) {
      return absl::StrFormat("%s [S%zu]", base_title, dependencies_.session_id);
    }
    return base_title;
  }
 
  // Helper method to create session-aware card IDs for multi-session support
  std::string MakeWindowId(const std::string& base_id) const {
    if (dependencies_.session_id > 0) {
      return absl::StrFormat("s%zu.%s", dependencies_.session_id, base_id);
    }
    return base_id;
  }
 
  // Helper method for ROM access with safety check
  template <typename T>
  absl::StatusOr<T> SafeRomAccess(std::function<T()> accessor,
                                  const std::string& operation = "") const {
    if (!IsRomLoaded()) {
      return absl::FailedPreconditionError(
          operation.empty() ? "ROM not loaded"
                            : absl::StrFormat("%s: ROM not loaded", operation));
    }
    try {
      return accessor();
    } catch (const std::exception& e) {
      return absl::InternalError(absl::StrFormat(
          "%s: %s", operation.empty() ? "ROM access failed" : operation,
          e.what()));
    }
  }
};
 
}  // namespace editor
}  // namespace yaze
 
#endif  // YAZE_APP_CORE_EDITOR_H