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 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();
 
  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 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);
 
  // Finish one-time saved tab selection after ImGui registers the windows.
  void ProcessPendingDockTabSelections();
 
  void SetMainDockspaceId(ImGuiID id) { main_dockspace_id_ = id; }
 
  ImGuiID GetMainDockspaceId() const;
 
  // ==========================================================================
  // Per-editor dockspaces (B2)
  // ==========================================================================
 
  static ImGuiID OuterDockspaceId();
 
  static ImGuiID EditorDockspaceId(EditorType type);
 
  ImGuiID ActiveEditorDockspaceId() const;
 
  void SetActiveEditorType(EditorType type) { active_editor_type_ = type; }
  EditorType active_editor_type() const { return active_editor_type_; }
 
  void DrawEditorHost();
 
  ImGuiID FindPinNode() const;
 
  ImGuiDir pin_dir() const { return pin_dir_; }
  float pin_size() const { return pin_size_; }
 
  // ==========================================================================
  // imgui.ini persistence (B2 layout revision)
  // ==========================================================================
 
  static constexpr int kLayoutIniRevision = 1;
 
  void RegisterLayoutIniHandler();
 
  void ResetLayoutIniSettings();
  void ReadLayoutIniLine(const char* line);
  void ApplyLayoutIniSettings();
  void WriteLayoutIniSettings(ImGuiTextBuffer* buf) const;
 
  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;
  }
  void set_editor_host_size_for_test(ImVec2 size) { editor_host_size_ = size; }
 
  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,
                                     bool allow_redock = false);
  void MarkLazyDefaultDockAttempted(const std::string& panel_id);
  void StashLazyDefaultDockState();
  bool RestoreLazyDefaultDockState(EditorType type, ImGuiID dockspace_id);
  ImGuiID EnsurePinNode();
  void RecordPinSpot();
  // Puts the pin node on side `dir` (size in pixels, 0 keeps the saved one)
  // and moves the panels already pinned there. Returns the pin node.
  ImGuiID MovePinSpot(ImGuiDir dir, float size);
  ImVec2 EditorDockspaceSize() const;
  void EnforcePinnedPanels(ImGuiID pin_node);
  void ProtectRestoredLayoutFromDefaultInitialization();
 
  void LoadLayoutsFromDiskInternal(LayoutScope scope, bool merge);
  void SaveLayoutsToDisk(LayoutScope scope) const;
 
  // Track which layouts have been initialized
  std::unordered_map<EditorType, bool> layouts_initialized_;
 
  struct PendingDockTabSelection {
    ImGuiID node_id = 0;
    ImGuiID selected_id = 0;
    ImGuiID selected_window_id = 0;
    std::vector<ImGuiID> tab_ids;
    size_t session_id = 0;
    int applied_frame = 0;
  };
  std::vector<PendingDockTabSelection> pending_dock_tab_selections_;
 
  // Panel manager for window title lookups
  WorkspaceWindowManager* window_manager_ = nullptr;
 
  // 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;
 
  // Editor whose dockspace the editor host submits as active. Synced each
  // frame by LayoutCoordinator::ProcessLayoutRebuild.
  EditorType active_editor_type_ = EditorType::kUnknown;
 
  // Content size of the editor host from the last frame; zero before it draws.
  ImVec2 editor_host_size_ = ImVec2(0.0f, 0.0f);
 
  // Parsed [YazeLayout][Data] section from imgui.ini.
  struct LayoutIniState {
    bool section_seen = false;
    int revision = 0;
    std::vector<EditorType> initialized;
    ImGuiDir pin_dir = ImGuiDir_None;
    float pin_size = 0.0f;
  };
  LayoutIniState layout_ini_;
  bool layout_ini_backup_checked_ = false;
 
  // Where the shared pin node goes when it is (re)built. The node is deleted
  // when its last panel leaves, so the user's drag is kept here.
  ImGuiDir pin_dir_ = ImGuiDir_Right;
  float pin_size_ = 0.0f;
 
  // Window names of the panels pinned at the last EnforcePinnedPanels. Tells
  // a drag of a pinned panel apart from a panel pinned where it already sat.
  std::unordered_set<std::string> pinned_last_frame_;
 
  // 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_;
  // Lazy state stashed per editor so a switch back resumes first-open docking.
  std::unordered_map<EditorType, LazyDefaultDockState> lazy_states_by_type_;
  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_