message_editor.h

Go to the documentation of this file.

#ifndef YAZE_APP_EDITOR_MESSAGE_EDITOR_H
#define YAZE_APP_EDITOR_MESSAGE_EDITOR_H
 
#include <array>
#include <cstdint>
#include <optional>
#include <string>
#include <vector>
 
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "app/editor/editor.h"
#include "app/editor/message/message_data.h"
#include "app/editor/message/message_preview.h"
#include "app/editor/message/message_undo_actions.h"
#include "app/editor/message/panels/message_editor_panels.h"
#include "app/gfx/core/bitmap.h"
#include "app/gui/app/editor_layout.h"
#include "app/gui/canvas/canvas.h"
#include "app/gui/core/style.h"
#include "rom/rom.h"
 
namespace yaze {
namespace editor {
 
class MessageEditorTestPeer;
class MessageEditorSaveTestPeer;
 
constexpr int kGfxFont = 0x70000;  // 2bpp format
constexpr int kCharactersWidth = 0x74ADF;
constexpr int kNumMessages = 396;
constexpr int kFontGfxMessageSize = 128;
constexpr int kFontGfxMessageDepth =
    8;  // Fixed: Must be 8 for indexed palette mode
constexpr int kFontGfx16Size = 172 * 4096;
 
constexpr uint8_t kBlockTerminator = 0x80;
constexpr uint8_t kMessageBankChangeId = 0x80;
 
class MessageEditor : public Editor {
 public:
  explicit MessageEditor(Rom* rom = nullptr) : rom_(rom) {
    type_ = EditorType::kMessage;
  }
 
  explicit MessageEditor(Rom* rom, const EditorDependencies& deps)
      : MessageEditor(rom) {
    dependencies_ = deps;
  }
 
  void Initialize() override;
  absl::Status Load() override;
  absl::Status Update() override;
  void SetGameData(zelda3::GameData* game_data) override;
 
  void DrawMessageList();
  void DrawCurrentMessage();
  void DrawFontAtlas();
  void DrawTextCommands();
  void DrawSpecialCharacters();
  void DrawExpandedMessageSettings();
  void DrawDictionary();
  void DrawMessagePreview();
  void UpdateCurrentMessageFromText(const std::string& text);
 
  // Jump/navigation helper used by panels (e.g. Story Event Graph).
  // Accepts vanilla IDs (0..N) and expanded IDs (expanded_base_id..).
  bool OpenMessageById(int display_id);
 
  absl::Status Save() override;
  absl::Status BeginSaveTransaction() override;
  void RollbackSaveTransaction() override;
  void CommitSaveTransaction() override;
  absl::Status SaveExpandedMessages();
  absl::Status LoadExpandedMessagesFromRom();
  int CalculateExpandedBankUsage() const;
 
  absl::Status Cut() override;
  absl::Status Copy() override;
  absl::Status Paste() override;
  absl::Status Undo() override;
  absl::Status Redo() override;
  absl::Status Find() override;
  void Delete();
  void SelectAll();
 
  void set_rom(Rom* rom) { rom_ = rom; }
  Rom* rom() const { return rom_; }
 
 private:
  friend class MessageEditorTestPeer;
  friend class MessageEditorSaveTestPeer;
 
  enum class SaveDomain {
    kFontWidths,
    kVanillaMessages,
    kExpandedMessages,
  };
 
  struct PlannedWrite {
    SaveDomain domain;
    uint32_t start;
    std::vector<uint8_t> bytes;
 
    uint32_t end() const { return start + static_cast<uint32_t>(bytes.size()); }
  };
 
  struct SavePlan {
    std::vector<PlannedWrite> writes;
    std::vector<int> expanded_message_addresses;
    bool saves_font_widths = false;
    bool saves_vanilla_messages = false;
    bool saves_expanded_messages = false;
  };
 
  struct DirtyState {
    bool font_widths = false;
    bool vanilla_messages = false;
    bool expanded_messages = false;
  };
 
  absl::StatusOr<SavePlan> BuildSavePlan(bool include_font_widths,
                                         bool include_vanilla_messages,
                                         bool include_expanded_messages) const;
  absl::Status ValidateSavePlan(const SavePlan& plan) const;
  absl::Status ApplySavePlan(const SavePlan& plan);
  absl::Status SaveDirtyDomains(bool include_font_widths,
                                bool include_vanilla_messages,
                                bool include_expanded_messages);
  void MarkDomainDirty(SaveDomain domain);
  void RecordSavedDomains(const SavePlan& plan);
  void ClearSavedDomains(const DirtyState& saved);
  void SyncCurrentExpandedMessageAddress();
 
  bool case_sensitive_ = false;
  bool match_whole_word_ = false;
  std::string search_text_ = "";
  std::string replace_text_ = "";
  std::string replace_status_ = "";
  bool replace_status_error_ = false;
 
  // Replace helpers
  int ReplaceCurrentMatch();
  int ReplaceAllMatches();
 
  std::array<uint8_t, 0x4000> raw_font_gfx_data_;
  std::vector<std::string> parsed_messages_;
  std::vector<MessageData> list_of_texts_;
  std::vector<MessageData> expanded_messages_;
 
  MessageData current_message_;
  MessagePreview message_preview_;
 
  gfx::Bitmap font_gfx_bitmap_;
  gfx::Bitmap current_font_gfx16_bitmap_;
  gfx::SnesPalette font_preview_colors_;
 
  gui::Canvas font_gfx_canvas_{"##FontGfxCanvas", ImVec2(256, 256)};
  gui::Canvas current_font_gfx16_canvas_{"##CurrentMessageGfx",
                                         ImVec2(172 * 2, 4096)};
  gui::TextBox message_text_box_;
  Rom* rom_;
  Rom expanded_message_bin_;
  std::string expanded_message_path_;
  int expanded_message_base_id_ = 0;
  int current_message_index_ = 0;
  bool current_message_is_expanded_ = false;
  DirtyState dirty_state_;
  DirtyState transaction_dirty_snapshot_;
  DirtyState transaction_saved_domains_;
  std::vector<int> transaction_expanded_address_snapshot_;
  bool save_transaction_active_ = false;
 
  // Undo/Redo - delegates to UndoManager (inherited from Editor)
  std::optional<MessageSnapshot> pending_undo_before_;
  void PushUndoSnapshot();
  void FinalizePendingUndo();
  void ApplySnapshot(const MessageSnapshot& snapshot);
 
  // Panel visibility states
  bool show_message_list_ = false;
  bool show_message_editor_ = false;
  bool show_font_atlas_ = false;
  bool show_dictionary_ = false;
 
  void ResolveFontPalette();
  gfx::SnesPalette BuildFallbackFontPalette() const;
  void LoadFontGraphics();
  void RefreshFontAtlasBitmap(const std::vector<uint8_t>& font_data);
  void ApplyFontPalette();
  void EnsureFontTexturesReady();
  void ImportMessageBundleFromFile(const std::string& path);
  int ResolveExpandedMessageBaseId() const;
 
  bool font_graphics_loaded_ = false;
  std::string message_bundle_status_;
  bool message_bundle_status_error_ = false;
  std::vector<std::string> current_parse_errors_;
  std::vector<std::string> current_parse_warnings_;
};
 
}  // namespace editor
}  // namespace yaze
 
#endif  // YAZE_APP_EDITOR_MESSAGE_EDITOR_H