core_events.h

Go to the documentation of this file.

#ifndef YAZE_APP_EDITOR_EVENTS_CORE_EVENTS_H_
#define YAZE_APP_EDITOR_EVENTS_CORE_EVENTS_H_
 
#include <cstddef>
#include <string>
#include <vector>
 
#include "app/editor/core/event_bus.h"
 
namespace yaze {
class Rom;
 
namespace editor {
 
class RomSession;
 
// =============================================================================
// ROM Lifecycle Events
// =============================================================================
 
struct RomLoadedEvent : public Event {
  Rom* rom = nullptr;
  std::string filename;
  size_t session_id = 0;
 
  static RomLoadedEvent Create(Rom* r, const std::string& file,
                               size_t session) {
    RomLoadedEvent e;
    e.rom = r;
    e.filename = file;
    e.session_id = session;
    return e;
  }
};
 
struct RomUnloadedEvent : public Event {
  size_t session_id = 0;
 
  static RomUnloadedEvent Create(size_t session) {
    RomUnloadedEvent e;
    e.session_id = session;
    return e;
  }
};
 
struct RomModifiedEvent : public Event {
  Rom* rom = nullptr;
  uint32_t address = 0;
  size_t byte_count = 0;
  size_t session_id = 0;
 
  static RomModifiedEvent Create(Rom* r, size_t session, uint32_t addr = 0,
                                 size_t bytes = 0) {
    RomModifiedEvent e;
    e.rom = r;
    e.session_id = session;
    e.address = addr;
    e.byte_count = bytes;
    return e;
  }
};
 
// =============================================================================
// Session Lifecycle Events
// =============================================================================
 
struct SessionSwitchedEvent : public Event {
  size_t old_index = 0;
  size_t new_index = 0;
  RomSession* session = nullptr;
  bool transient = false;
 
  static SessionSwitchedEvent Create(size_t old_idx, size_t new_idx,
                                     RomSession* sess,
                                     bool is_transient = false) {
    SessionSwitchedEvent e;
    e.old_index = old_idx;
    e.new_index = new_idx;
    e.session = sess;
    e.transient = is_transient;
    return e;
  }
};
 
struct SessionCreatedEvent : public Event {
  size_t index = 0;
  RomSession* session = nullptr;
 
  static SessionCreatedEvent Create(size_t idx, RomSession* sess) {
    SessionCreatedEvent e;
    e.index = idx;
    e.session = sess;
    return e;
  }
};
 
struct SessionClosedEvent : public Event {
  size_t index = 0;
 
  static SessionClosedEvent Create(size_t idx) {
    SessionClosedEvent e;
    e.index = idx;
    return e;
  }
};
 
// =============================================================================
// Editor State Events
// =============================================================================
 
struct EditorSwitchedEvent : public Event {
  int editor_type = 0;  // EditorType enum value
  void* editor = nullptr;
 
  static EditorSwitchedEvent Create(int type, void* ed) {
    EditorSwitchedEvent e;
    e.editor_type = type;
    e.editor = ed;
    return e;
  }
};
 
// =============================================================================
// UI State Events
// =============================================================================
 
struct SelectionChangedEvent : public Event {
  std::string
      source;  // Source editor: "overworld", "dungeon", "graphics", etc.
  std::vector<int>
      selected_ids;     // IDs of selected items (tiles, rooms, sprites, etc.)
  int primary_id = -1;  // Primary selection (first or focused item)
  size_t session_id = 0;
 
  static SelectionChangedEvent Create(const std::string& src,
                                      const std::vector<int>& ids,
                                      size_t session = 0) {
    SelectionChangedEvent e;
    e.source = src;
    e.selected_ids = ids;
    e.primary_id = ids.empty() ? -1 : ids.front();
    e.session_id = session;
    return e;
  }
 
  static SelectionChangedEvent CreateSingle(const std::string& src, int id,
                                            size_t session = 0) {
    SelectionChangedEvent e;
    e.source = src;
    e.selected_ids = {id};
    e.primary_id = id;
    e.session_id = session;
    return e;
  }
 
  static SelectionChangedEvent CreateEmpty(const std::string& src,
                                           size_t session = 0) {
    SelectionChangedEvent e;
    e.source = src;
    e.selected_ids = {};
    e.primary_id = -1;
    e.session_id = session;
    return e;
  }
 
  bool IsEmpty() const { return selected_ids.empty(); }
  size_t Count() const { return selected_ids.size(); }
};
 
struct PanelVisibilityChangedEvent : public Event {
  std::string panel_id;       // Panel identifier (may be session-prefixed)
  std::string base_panel_id;  // Base panel ID without session prefix
  std::string category;       // Panel category ("Dungeon", "Overworld", etc.)
  bool visible = false;       // New visibility state
  size_t session_id = 0;
 
  static PanelVisibilityChangedEvent Create(const std::string& id,
                                            const std::string& base_id,
                                            const std::string& cat, bool vis,
                                            size_t session = 0) {
    PanelVisibilityChangedEvent e;
    e.panel_id = id;
    e.base_panel_id = base_id;
    e.category = cat;
    e.visible = vis;
    e.session_id = session;
    return e;
  }
};
 
struct ZoomChangedEvent : public Event {
  std::string
      source;  // Source canvas: "overworld_canvas", "dungeon_canvas", etc.
  float old_zoom = 1.0f;  // Previous zoom level
  float new_zoom = 1.0f;  // New zoom level
  size_t session_id = 0;
 
  static ZoomChangedEvent Create(const std::string& src, float old_z,
                                 float new_z, size_t session = 0) {
    ZoomChangedEvent e;
    e.source = src;
    e.old_zoom = old_z;
    e.new_zoom = new_z;
    e.session_id = session;
    return e;
  }
 
  float GetZoomDelta() const { return new_zoom - old_zoom; }
  float GetZoomRatio() const {
    return old_zoom > 0.0f ? new_zoom / old_zoom : 1.0f;
  }
  bool IsZoomIn() const { return new_zoom > old_zoom; }
  bool IsZoomOut() const { return new_zoom < old_zoom; }
};
 
// =============================================================================
// Navigation Request Events (cross-editor navigation)
// =============================================================================
 
struct JumpToRoomRequestEvent : public Event {
  int room_id = -1;
  size_t session_id = 0;
 
  static JumpToRoomRequestEvent Create(int room, size_t session = 0) {
    JumpToRoomRequestEvent e;
    e.room_id = room;
    e.session_id = session;
    return e;
  }
};
 
struct JumpToMapRequestEvent : public Event {
  int map_id = -1;
  size_t session_id = 0;
 
  static JumpToMapRequestEvent Create(int map, size_t session = 0) {
    JumpToMapRequestEvent e;
    e.map_id = map;
    e.session_id = session;
    return e;
  }
};
 
struct JumpToMessageRequestEvent : public Event {
  int message_id = -1;
  size_t session_id = 0;
 
  static JumpToMessageRequestEvent Create(int message, size_t session = 0) {
    JumpToMessageRequestEvent e;
    e.message_id = message;
    e.session_id = session;
    return e;
  }
};
 
struct JumpToAssemblySymbolRequestEvent : public Event {
  std::string symbol;
  size_t session_id = 0;
 
  static JumpToAssemblySymbolRequestEvent Create(std::string sym,
                                                 size_t session = 0) {
    JumpToAssemblySymbolRequestEvent e;
    e.symbol = std::move(sym);
    e.session_id = session;
    return e;
  }
};
 
// =============================================================================
// UI Action Request Events (activity bar, menus, shortcuts)
// =============================================================================
 
struct UIActionRequestEvent : public Event {
  enum class Action {
    kShowEmulator,
    kShowSettings,
    kShowPanelBrowser,
    kShowSearch,
    kShowShortcuts,
    kShowCommandPalette,
    kShowHelp,
    kShowAgentChatSidebar,
    kShowAgentProposalsSidebar,
    kOpenRom,
    kSaveRom,
    kUndo,
    kRedo,
    kShowOracleRam,
    kResetLayout,
  };
 
  Action action;
  size_t session_id = 0;
 
  static UIActionRequestEvent Create(Action act, size_t session = 0) {
    UIActionRequestEvent e;
    e.action = act;
    e.session_id = session;
    return e;
  }
 
  // Convenience factory methods
  static UIActionRequestEvent ShowEmulator(size_t session = 0) {
    return Create(Action::kShowEmulator, session);
  }
  static UIActionRequestEvent ShowSettings(size_t session = 0) {
    return Create(Action::kShowSettings, session);
  }
  static UIActionRequestEvent ShowCommandPalette(size_t session = 0) {
    return Create(Action::kShowCommandPalette, session);
  }
  static UIActionRequestEvent ShowAgentChatSidebar(size_t session = 0) {
    return Create(Action::kShowAgentChatSidebar, session);
  }
  static UIActionRequestEvent ShowAgentProposalsSidebar(size_t session = 0) {
    return Create(Action::kShowAgentProposalsSidebar, session);
  }
  static UIActionRequestEvent OpenRom(size_t session = 0) {
    return Create(Action::kOpenRom, session);
  }
  static UIActionRequestEvent SaveRom(size_t session = 0) {
    return Create(Action::kSaveRom, session);
  }
  static UIActionRequestEvent Undo(size_t session = 0) {
    return Create(Action::kUndo, session);
  }
  static UIActionRequestEvent Redo(size_t session = 0) {
    return Create(Action::kRedo, session);
  }
};
 
struct SidebarStateChangedEvent : public Event {
  bool sidebar_visible = false;
  bool panel_expanded = false;
 
  static SidebarStateChangedEvent Create(bool visible, bool expanded) {
    SidebarStateChangedEvent e;
    e.sidebar_visible = visible;
    e.panel_expanded = expanded;
    return e;
  }
};
 
// =============================================================================
// Frame Lifecycle Events (for deferred action consolidation)
// =============================================================================
 
struct FrameBeginEvent : public Event {
  float delta_time = 0.0f;
 
  static FrameBeginEvent Create(float dt) {
    FrameBeginEvent e;
    e.delta_time = dt;
    return e;
  }
};
 
struct FrameGuiBeginEvent : public Event {
  float delta_time = 0.0f;
 
  static FrameGuiBeginEvent Create(float dt) {
    FrameGuiBeginEvent e;
    e.delta_time = dt;
    return e;
  }
};
 
struct FrameEndEvent : public Event {
  float delta_time = 0.0f;
 
  static FrameEndEvent Create(float dt) {
    FrameEndEvent e;
    e.delta_time = dt;
    return e;
  }
};
 
}  // namespace editor
}  // namespace yaze
 
#endif  // YAZE_APP_EDITOR_EVENTS_CORE_EVENTS_H_