layout_manager.h

Go to the documentation of this file.

#ifndef YAZE_APP_EDITOR_LAYOUT_LAYOUT_MANAGER_H_
#define YAZE_APP_EDITOR_LAYOUT_LAYOUT_MANAGER_H_
 
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "app/editor/editor.h"
#include "app/editor/layout/layout_designer/dock_tree.h"
#include "imgui/imgui.h"
 
namespace yaze {
namespace editor {
 
// Forward declaration
class WorkspaceWindowManager;
class UserSettings;
 
enum class LayoutType {
  kDefault,
  kOverworld,
  kDungeon,
  kGraphics,
  kPalette,
  kScreen,
  kMusic,
  kSprite,
  kMessage,
  kAssembly,
  kSettings,
  kEmulator
};
 
enum class LayoutScope { kGlobal, kProject };
 
struct LayoutProfile {
  std::string id;           // Stable id (e.g. "code", "debug")
  std::string label;        // UI-facing label
  std::string description;  // Short profile summary
  std::string preset_name;  // Backing LayoutPresets name
  bool open_agent_chat = false;
};
 
class LayoutManager {
 public:
  LayoutManager() = default;
  ~LayoutManager() = default;
 
  void SetWindowManager(WorkspaceWindowManager* manager) {
    window_manager_ = manager;
  }
 
  WorkspaceWindowManager* window_manager() const { return window_manager_; }
 
  void InitializeEditorLayout(EditorType type, ImGuiID dockspace_id);
 
  void RebuildLayout(EditorType type, ImGuiID dockspace_id);
 
  bool DockDefaultPositionOnFirstOpen(size_t session_id,
                                      const std::string& panel_id);
 
  bool DockPresetPositionOnPanelOpen(size_t session_id,
                                     const std::string& panel_id);
 
  void SaveCurrentLayout(const std::string& name, bool persist = true);
 
  void LoadLayout(const std::string& name);
 
  void CaptureTemporarySessionLayout(size_t session_id);
 
  bool RestoreTemporarySessionLayout(size_t session_id,
                                     bool clear_after_restore = false);
 
  bool HasTemporarySessionLayout() const { return has_temp_session_layout_; }
 
  void ClearTemporarySessionLayout();
 
  bool SaveNamedSnapshot(const std::string& name, size_t session_id);
 
  bool RestoreNamedSnapshot(const std::string& name, size_t session_id,
                            bool remove_after_restore = false);
 
  bool DeleteNamedSnapshot(const std::string& name);
 
  std::vector<std::string> ListNamedSnapshots(size_t session_id) const;
 
  bool HasNamedSnapshot(const std::string& name) const;
 
  bool DeleteLayout(const std::string& name);
 
  static std::vector<LayoutProfile> GetBuiltInProfiles();
 
  bool ApplyBuiltInProfile(const std::string& profile_id, size_t session_id,
                           EditorType editor_type,
                           LayoutProfile* out_profile = nullptr);
 
  std::vector<std::string> GetSavedLayoutNames() const;
 
  bool HasLayout(const std::string& name) const;
 
  void LoadLayoutsFromDisk();
 
  void SetProjectLayoutKey(const std::string& key);
 
  void UseGlobalLayouts();
 
  LayoutScope GetActiveScope() const;
 
  void ResetToDefaultLayout(EditorType type);
 
  bool IsLayoutInitialized(EditorType type) const;
 
  void MarkLayoutInitialized(EditorType type);
 
  void ClearInitializationFlags();
 
  void SetLayoutType(LayoutType type) { current_layout_type_ = type; }
 
  LayoutType GetLayoutType() const { return current_layout_type_; }
 
  void RequestRebuild() { rebuild_requested_ = true; }
 
  bool IsRebuildRequested() const { return rebuild_requested_; }
 
  void ClearRebuildRequest() { rebuild_requested_ = false; }
 
  std::string GetWindowTitle(const std::string& card_id) const;
 
  // ==========================================================================
  // DockTree integration (Layout Designer)
  // ==========================================================================
 
  absl::Status ApplyDockTree(const layout_designer::DockTree& tree,
                             ImGuiID dockspace_id);
 
  void SetMainDockspaceId(ImGuiID id) { main_dockspace_id_ = id; }
 
  ImGuiID GetMainDockspaceId() const { return main_dockspace_id_; }
 
  void reset_startup_layout_consumed_for_test() {
    startup_layout_consumed_ = false;
  }
  bool startup_layout_consumed_for_test() const {
    return startup_layout_consumed_;
  }
  bool startup_reapply_pending_protection_for_test() const {
    return startup_reapply_pending_protection_;
  }
  void set_current_editor_type_for_test(EditorType type) {
    current_editor_type_ = type;
  }
 
  absl::Status MaybeReapplyStartupLayout(UserSettings* settings);
 
  absl::StatusOr<layout_designer::DockTree> CaptureDockTree(
      ImGuiID dockspace_id) const;
 
 private:
  // DockBuilder layout implementations for each editor type
  void BuildLayoutFromPreset(EditorType type, ImGuiID dockspace_id);
  void DisableLazyDefaultDocking();
  void RefreshLazyDefaultDockingContext(EditorType type, ImGuiID dockspace_id);
  void DockOpenPresetPanels(EditorType type);
  bool DockPresetPositionOnFirstOpen(size_t session_id,
                                     const std::string& panel_id,
                                     bool include_default_visible);
  void MarkLazyDefaultDockAttempted(const std::string& panel_id);
  void ProtectRestoredLayoutFromDefaultInitialization();
 
  void LoadLayoutsFromDiskInternal(LayoutScope scope, bool merge);
  void SaveLayoutsToDisk(LayoutScope scope) const;
 
  // Deprecated individual builders - kept for compatibility or as wrappers
  void BuildOverworldLayout(ImGuiID dockspace_id);
  void BuildDungeonLayout(ImGuiID dockspace_id);
  void BuildGraphicsLayout(ImGuiID dockspace_id);
  void BuildPaletteLayout(ImGuiID dockspace_id);
  void BuildScreenLayout(ImGuiID dockspace_id);
  void BuildMusicLayout(ImGuiID dockspace_id);
  void BuildSpriteLayout(ImGuiID dockspace_id);
  void BuildMessageLayout(ImGuiID dockspace_id);
  void BuildAssemblyLayout(ImGuiID dockspace_id);
  void BuildSettingsLayout(ImGuiID dockspace_id);
  void BuildEmulatorLayout(ImGuiID dockspace_id);
 
  // Track which layouts have been initialized
  std::unordered_map<EditorType, bool> layouts_initialized_;
 
  // Panel manager for window title lookups
  WorkspaceWindowManager* window_manager_ = nullptr;
 
  // Current layout type
  LayoutType current_layout_type_ = LayoutType::kDefault;
 
  // Rebuild flag
  bool rebuild_requested_ = false;
 
  // Last used dockspace ID (for rebuild operations)
  ImGuiID last_dockspace_id_ = 0;
 
  // Main dockspace ID captured from the authoritative scope (see
  // `SetMainDockspaceId`). 0 until the controller has rendered at least
  // one DockSpaceWindow frame.
  ImGuiID main_dockspace_id_ = 0;
 
  // True after `MaybeReapplyStartupLayout` has fired for this session
  // (whether successfully or with a logged error). Guards the one-shot
  // semantics across the per-frame call cadence.
  bool startup_layout_consumed_ = false;
 
  // Set by `MaybeReapplyStartupLayout` after a successful apply, then
  // consumed by the very next `InitializeEditorLayout` call (any
  // editor type). Phase 8.2 review (2026-04-25): without this flag the
  // first editor activation post-startup would blow away the
  // freshly-reapplied custom layout via lazy preset init. The flag is
  // intentionally global-one-shot rather than per-editor because at
  // startup we don't know which editor the user will activate first;
  // the very first lazy init is always the dangerous one.
  bool startup_reapply_pending_protection_ = false;
 
  // Current editor type being displayed
  EditorType current_editor_type_ = EditorType::kUnknown;
 
  // Default presets may omit hidden panels from the initial dock tree. Keep
  // enough state to create their preferred region lazily on first open.
  struct LazyDefaultDockState {
    bool enabled = false;
    bool compact = false;
    EditorType editor_type = EditorType::kUnknown;
    size_t session_id = 0;
    ImGuiID dockspace = 0;
    ImGuiID center = 0;
    ImGuiID left = 0;
    ImGuiID right = 0;
    ImGuiID bottom = 0;
    ImGuiID top = 0;
    ImGuiID left_top = 0;
    ImGuiID left_bottom = 0;
    ImGuiID right_top = 0;
    ImGuiID right_bottom = 0;
    float left_ratio = 0.17f;
    float right_ratio = 0.24f;
    float bottom_ratio = 0.22f;
    float top_ratio = 0.12f;
    float vertical_split = 0.52f;
    std::unordered_set<std::string> attempted_panels;
  };
  LazyDefaultDockState lazy_default_dock_state_;
  std::unordered_map<
      size_t, std::unordered_map<EditorType, std::unordered_set<std::string>>>
      lazy_default_dock_attempts_;
 
  // Saved layouts (panel visibility state)
  std::unordered_map<std::string, std::unordered_map<std::string, bool>>
      saved_layouts_;
 
  // In-memory temporary session snapshot (never persisted).
  bool has_temp_session_layout_ = false;
  size_t temp_session_id_ = 0;
  std::unordered_map<std::string, bool> temp_session_visibility_;
  std::unordered_map<std::string, bool> temp_session_pinned_;
  std::string temp_session_imgui_layout_;
 
  // Multi-slot named session snapshots (in-memory only, never persisted).
  // The user-supplied name is the stable key; duplicate saves overwrite.
  struct SessionSnapshot {
    size_t session_id = 0;
    std::unordered_map<std::string, bool> visibility;
    std::unordered_map<std::string, bool> pinned;
    std::string imgui_layout;
  };
  std::unordered_map<std::string, SessionSnapshot> named_snapshots_;
 
  // Saved ImGui docking layouts (INI data)
  std::unordered_map<std::string, std::string> saved_imgui_layouts_;
 
  // Saved pinned panel state for layouts
  std::unordered_map<std::string, std::unordered_map<std::string, bool>>
      saved_pinned_layouts_;
 
  // Layout scope tracking
  std::unordered_map<std::string, LayoutScope> layout_scopes_;
 
  // Project storage key for project-scoped layouts
  std::string project_layout_key_;
};
 
}  // namespace editor
}  // namespace yaze
 
#endif  // YAZE_APP_EDITOR_LAYOUT_LAYOUT_MANAGER_H_