diff --git a/docs/plan/XCUI完整架构设计与执行计划.md b/docs/plan/XCUI完整架构设计与执行计划.md index 87b21747..c7935351 100644 --- a/docs/plan/XCUI完整架构设计与执行计划.md +++ b/docs/plan/XCUI完整架构设计与执行计划.md @@ -169,10 +169,10 @@ tests/ 以下规则在当前阶段覆盖本节中所有与目录落点有关的模糊表述： - `editor/` 当前视为 ImGui 版本冻结区；在 XCUI editor shell 成熟前，不直接在该目录中推进替换开发。 -- 新的 `Editor` 层实现当前先落在 `new_editor/`，用于 editor shell、editor-only widget 与工作区壳层构建。 -- `tests/UI` 继续只承担 XCUI 的 `unit / integration` 验证职责，不承载正式 editor 实现。 +- `tests/UI` 是当前 `Editor` 基础层的唯一实验场；所有基础能力验证、交互试验、状态流检查都必须优先放在 `tests/UI/Editor/unit` 与 `tests/UI/Editor/integration`。 +- `new_editor/` 当前冻结为空壳目录，不承担实验场职责；在 `Editor` 基础层尚未通过测试体系收口前，禁止继续往其中添加新功能、新面板或新的验证入口。 - `engine/UI` 当前继续只放 `Core / Runtime / shared` 部分，不再继续沉积 editor-only 代码。 -- 当 `new_editor/` 中的 XCUI editor shell 达到替换条件后，再计划性回收进正式 `editor/`。 +- 等 `Editor` 基础层在 `tests/UI/Editor` 中稳定收口后，如确有宿主集成需要，再单独规划 `new_editor/` 或正式 `editor/` 的接入阶段。 #### 当前过渡期目录（自 2026-04-06 起执行） ```text @@ -185,7 +185,7 @@ new_editor/ src/ ui/ captures/ - # 当前新的 Editor 层与 editor shell 先在这里构建 + # 当前冻结为空壳，不作为基础层开发或实验入口 editor/ # 当前 ImGui 版本冻结，不作为本阶段 XCUI 主实现目录 @@ -1417,8 +1417,8 @@ tests/UI/Editor/ 近期执行顺序调整如下： 1. 冻结当前基于 ImGui 的 `editor/` 目录，不把它作为本阶段 XCUI 替换开发的主工作区。 -2. 新的 XCUI `Editor` 层先在 `new_editor/` 中构建。 -3. `tests/UI` 继续只做验证，不承载正式 editor 实现。 +2. 当前阶段所有 `Editor` 基础层实验、交互验证、状态流验证，一律放在 `tests/UI/Editor` 中完成。 +3. `new_editor/` 保持空壳冻结；在基础层未成熟前，不把它当作试验场，不往里面追加功能。 4. 在具体 editor 面板之前，优先完成 editor shell 基础能力： - Splitter / pane resize - Tab strip @@ -1438,7 +1438,8 @@ tests/UI/Editor/ - `Editor` 当前阶段只负责 editor shell、panel 生命周期、workspace 装配、menu/shortcut 这类 editor-only 上层能力。 - 凡是发现 `layout / input / style / text / render contract / shared widget` 等共享能力缺口，必须优先回补到 `Core` 或 shared UI 层。 - 禁止在 `Editor` 层硬写临时替代实现去绕过 `Core` 缺口；否则后面迁移到正式 editor 时会再次返工。 -- `new_editor/` 当前只作为 `Editor` 层实现载体与试验场，不作为业务面板堆叠区。 +- `tests/UI/Editor` 是当前 `Editor` 基础层的唯一实验与验证入口；需要人工操作检查的内容，也必须做成这里的集成测试场景。 +- `new_editor/` 当前保持空壳冻结，不作为试验场，不作为基础层功能承载目录，更不允许在基础层未成熟前向其中堆任何业务或验证逻辑。 - `tests/UI/Editor` 当前只验证 `Editor` 基础壳层与状态流，不提前承担具体业务面板复刻。 ### 24.3 Editor基础层当前推进顺序（2026-04-06） diff --git a/new_editor/CMakeLists.txt b/new_editor/CMakeLists.txt index d7620ff2..843c8f45 100644 --- a/new_editor/CMakeLists.txt +++ b/new_editor/CMakeLists.txt @@ -14,6 +14,7 @@ set(NEW_EDITOR_RESOURCE_FILES add_library(XCNewEditorLib STATIC src/editor/EditorShellAsset.cpp src/editor/UIEditorPanelRegistry.cpp + src/editor/UIEditorWorkspaceLayoutPersistence.cpp src/editor/UIEditorWorkspaceController.cpp src/editor/UIEditorWorkspaceModel.cpp src/editor/UIEditorWorkspaceSession.cpp diff --git a/new_editor/include/XCNewEditor/Editor/UIEditorWorkspaceController.h b/new_editor/include/XCNewEditor/Editor/UIEditorWorkspaceController.h index 6240d890..b1f31b3e 100644 --- a/new_editor/include/XCNewEditor/Editor/UIEditorWorkspaceController.h +++ b/new_editor/include/XCNewEditor/Editor/UIEditorWorkspaceController.h @@ -1,5 +1,6 @@ #pragma once +#include #include #include @@ -58,6 +59,23 @@ struct UIEditorWorkspaceControllerValidationResult { std::string_view GetUIEditorWorkspaceCommandKindName(UIEditorWorkspaceCommandKind kind); std::string_view GetUIEditorWorkspaceCommandStatusName(UIEditorWorkspaceCommandStatus status); +enum class UIEditorWorkspaceLayoutOperationStatus : std::uint8_t { + Changed = 0, + NoOp, + Rejected +}; + +struct UIEditorWorkspaceLayoutOperationResult { + UIEditorWorkspaceLayoutOperationStatus status = + UIEditorWorkspaceLayoutOperationStatus::Rejected; + std::string message = {}; + std::string activePanelId = {}; + std::vector visiblePanelIds = {}; +}; + +std::string_view GetUIEditorWorkspaceLayoutOperationStatusName( + UIEditorWorkspaceLayoutOperationStatus status); + class UIEditorWorkspaceController { public: UIEditorWorkspaceController() = default; @@ -79,6 +97,11 @@ public: } UIEditorWorkspaceControllerValidationResult ValidateState() const; + UIEditorWorkspaceLayoutSnapshot CaptureLayoutSnapshot() const; + UIEditorWorkspaceLayoutOperationResult RestoreLayoutSnapshot( + const UIEditorWorkspaceLayoutSnapshot& snapshot); + UIEditorWorkspaceLayoutOperationResult RestoreSerializedLayout( + std::string_view serializedLayout); UIEditorWorkspaceCommandResult Dispatch(const UIEditorWorkspaceCommand& command); private: @@ -95,6 +118,10 @@ private: const UIEditorWorkspaceModel& previousWorkspace, const UIEditorWorkspaceSession& previousSession); + UIEditorWorkspaceLayoutOperationResult BuildLayoutOperationResult( + UIEditorWorkspaceLayoutOperationStatus status, + std::string message) const; + const UIEditorPanelDescriptor* FindPanelDescriptor(std::string_view panelId) const; UIEditorPanelRegistry m_panelRegistry = {}; diff --git a/new_editor/include/XCNewEditor/Editor/UIEditorWorkspaceLayoutPersistence.h b/new_editor/include/XCNewEditor/Editor/UIEditorWorkspaceLayoutPersistence.h new file mode 100644 index 00000000..39b4d157 --- /dev/null +++ b/new_editor/include/XCNewEditor/Editor/UIEditorWorkspaceLayoutPersistence.h @@ -0,0 +1,55 @@ +#pragma once + +#include + +#include +#include +#include + +namespace XCEngine::NewEditor { + +struct UIEditorWorkspaceLayoutSnapshot { + UIEditorWorkspaceModel workspace = {}; + UIEditorWorkspaceSession session = {}; +}; + +enum class UIEditorWorkspaceLayoutLoadCode : std::uint8_t { + None = 0, + InvalidPanelRegistry, + EmptyInput, + InvalidHeader, + UnsupportedVersion, + MissingActiveRecord, + UnexpectedEndOfInput, + InvalidNodeRecord, + InvalidSessionRecord, + InvalidWorkspace, + InvalidWorkspaceSession +}; + +struct UIEditorWorkspaceLayoutLoadResult { + UIEditorWorkspaceLayoutLoadCode code = UIEditorWorkspaceLayoutLoadCode::None; + std::string message = {}; + UIEditorWorkspaceLayoutSnapshot snapshot = {}; + + [[nodiscard]] bool IsValid() const { + return code == UIEditorWorkspaceLayoutLoadCode::None; + } +}; + +UIEditorWorkspaceLayoutSnapshot BuildUIEditorWorkspaceLayoutSnapshot( + const UIEditorWorkspaceModel& workspace, + const UIEditorWorkspaceSession& session); + +bool AreUIEditorWorkspaceLayoutSnapshotsEquivalent( + const UIEditorWorkspaceLayoutSnapshot& lhs, + const UIEditorWorkspaceLayoutSnapshot& rhs); + +std::string SerializeUIEditorWorkspaceLayoutSnapshot( + const UIEditorWorkspaceLayoutSnapshot& snapshot); + +UIEditorWorkspaceLayoutLoadResult DeserializeUIEditorWorkspaceLayoutSnapshot( + const UIEditorPanelRegistry& panelRegistry, + std::string_view serializedLayout); + +} // namespace XCEngine::NewEditor diff --git a/new_editor/include/XCNewEditor/Editor/UIEditorWorkspaceModel.h b/new_editor/include/XCNewEditor/Editor/UIEditorWorkspaceModel.h index 1bae265f..7ded89ed 100644 --- a/new_editor/include/XCNewEditor/Editor/UIEditorWorkspaceModel.h +++ b/new_editor/include/XCNewEditor/Editor/UIEditorWorkspaceModel.h @@ -100,6 +100,14 @@ bool ContainsUIEditorWorkspacePanel( const UIEditorWorkspaceModel& workspace, std::string_view panelId); +bool AreUIEditorWorkspaceNodesEquivalent( + const UIEditorWorkspaceNode& lhs, + const UIEditorWorkspaceNode& rhs); + +bool AreUIEditorWorkspaceModelsEquivalent( + const UIEditorWorkspaceModel& lhs, + const UIEditorWorkspaceModel& rhs); + const UIEditorWorkspacePanelState* FindUIEditorWorkspaceActivePanel( const UIEditorWorkspaceModel& workspace); diff --git a/new_editor/include/XCNewEditor/Editor/UIEditorWorkspaceSession.h b/new_editor/include/XCNewEditor/Editor/UIEditorWorkspaceSession.h index bfb42b2d..9904a5d5 100644 --- a/new_editor/include/XCNewEditor/Editor/UIEditorWorkspaceSession.h +++ b/new_editor/include/XCNewEditor/Editor/UIEditorWorkspaceSession.h @@ -53,6 +53,10 @@ UIEditorWorkspaceSessionValidationResult ValidateUIEditorWorkspaceSession( const UIEditorWorkspaceModel& workspace, const UIEditorWorkspaceSession& session); +bool AreUIEditorWorkspaceSessionsEquivalent( + const UIEditorWorkspaceSession& lhs, + const UIEditorWorkspaceSession& rhs); + std::vector CollectUIEditorWorkspaceVisiblePanels( const UIEditorWorkspaceModel& workspace, const UIEditorWorkspaceSession& session); diff --git a/new_editor/src/editor/UIEditorWorkspaceController.cpp b/new_editor/src/editor/UIEditorWorkspaceController.cpp index 0776366c..3d52a70d 100644 --- a/new_editor/src/editor/UIEditorWorkspaceController.cpp +++ b/new_editor/src/editor/UIEditorWorkspaceController.cpp @@ -6,57 +6,6 @@ namespace XCEngine::NewEditor { namespace { -bool AreWorkspaceNodesEquivalent( - const UIEditorWorkspaceNode& lhs, - const UIEditorWorkspaceNode& rhs) { - if (lhs.kind != rhs.kind || - lhs.nodeId != rhs.nodeId || - lhs.splitAxis != rhs.splitAxis || - lhs.splitRatio != rhs.splitRatio || - lhs.selectedTabIndex != rhs.selectedTabIndex || - lhs.panel.panelId != rhs.panel.panelId || - lhs.panel.title != rhs.panel.title || - lhs.panel.placeholder != rhs.panel.placeholder || - lhs.children.size() != rhs.children.size()) { - return false; - } - - for (std::size_t index = 0; index < lhs.children.size(); ++index) { - if (!AreWorkspaceNodesEquivalent(lhs.children[index], rhs.children[index])) { - return false; - } - } - - return true; -} - -bool AreWorkspaceModelsEquivalent( - const UIEditorWorkspaceModel& lhs, - const UIEditorWorkspaceModel& rhs) { - return lhs.activePanelId == rhs.activePanelId && - AreWorkspaceNodesEquivalent(lhs.root, rhs.root); -} - -bool AreWorkspaceSessionsEquivalent( - const UIEditorWorkspaceSession& lhs, - const UIEditorWorkspaceSession& rhs) { - if (lhs.panelStates.size() != rhs.panelStates.size()) { - return false; - } - - for (std::size_t index = 0; index < lhs.panelStates.size(); ++index) { - const UIEditorPanelSessionState& lhsState = lhs.panelStates[index]; - const UIEditorPanelSessionState& rhsState = rhs.panelStates[index]; - if (lhsState.panelId != rhsState.panelId || - lhsState.open != rhsState.open || - lhsState.visible != rhsState.visible) { - return false; - } - } - - return true; -} - std::vector CollectVisiblePanelIds( const UIEditorWorkspaceModel& workspace, const UIEditorWorkspaceSession& session) { @@ -106,6 +55,20 @@ std::string_view GetUIEditorWorkspaceCommandStatusName(UIEditorWorkspaceCommandS return "Unknown"; } +std::string_view GetUIEditorWorkspaceLayoutOperationStatusName( + UIEditorWorkspaceLayoutOperationStatus status) { + switch (status) { + case UIEditorWorkspaceLayoutOperationStatus::Changed: + return "Changed"; + case UIEditorWorkspaceLayoutOperationStatus::NoOp: + return "NoOp"; + case UIEditorWorkspaceLayoutOperationStatus::Rejected: + return "Rejected"; + } + + return "Unknown"; +} + UIEditorWorkspaceController::UIEditorWorkspaceController( UIEditorPanelRegistry panelRegistry, UIEditorWorkspaceModel workspace, @@ -148,6 +111,10 @@ UIEditorWorkspaceControllerValidationResult UIEditorWorkspaceController::Validat return {}; } +UIEditorWorkspaceLayoutSnapshot UIEditorWorkspaceController::CaptureLayoutSnapshot() const { + return BuildUIEditorWorkspaceLayoutSnapshot(m_workspace, m_session); +} + UIEditorWorkspaceCommandResult UIEditorWorkspaceController::BuildResult( const UIEditorWorkspaceCommand& command, UIEditorWorkspaceCommandStatus status, @@ -162,6 +129,17 @@ UIEditorWorkspaceCommandResult UIEditorWorkspaceController::BuildResult( return result; } +UIEditorWorkspaceLayoutOperationResult UIEditorWorkspaceController::BuildLayoutOperationResult( + UIEditorWorkspaceLayoutOperationStatus status, + std::string message) const { + UIEditorWorkspaceLayoutOperationResult result = {}; + result.status = status; + result.message = std::move(message); + result.activePanelId = m_workspace.activePanelId; + result.visiblePanelIds = CollectVisiblePanelIds(m_workspace, m_session); + return result; +} + UIEditorWorkspaceCommandResult UIEditorWorkspaceController::FinalizeMutation( const UIEditorWorkspaceCommand& command, bool changed, @@ -197,6 +175,71 @@ const UIEditorPanelDescriptor* UIEditorWorkspaceController::FindPanelDescriptor( return FindUIEditorPanelDescriptor(m_panelRegistry, panelId); } +UIEditorWorkspaceLayoutOperationResult UIEditorWorkspaceController::RestoreLayoutSnapshot( + const UIEditorWorkspaceLayoutSnapshot& snapshot) { + const UIEditorPanelRegistryValidationResult registryValidation = + ValidateUIEditorPanelRegistry(m_panelRegistry); + if (!registryValidation.IsValid()) { + return BuildLayoutOperationResult( + UIEditorWorkspaceLayoutOperationStatus::Rejected, + "Panel registry invalid: " + registryValidation.message); + } + + const UIEditorWorkspaceValidationResult workspaceValidation = + ValidateUIEditorWorkspace(snapshot.workspace); + if (!workspaceValidation.IsValid()) { + return BuildLayoutOperationResult( + UIEditorWorkspaceLayoutOperationStatus::Rejected, + "Layout workspace invalid: " + workspaceValidation.message); + } + + const UIEditorWorkspaceSessionValidationResult sessionValidation = + ValidateUIEditorWorkspaceSession(m_panelRegistry, snapshot.workspace, snapshot.session); + if (!sessionValidation.IsValid()) { + return BuildLayoutOperationResult( + UIEditorWorkspaceLayoutOperationStatus::Rejected, + "Layout session invalid: " + sessionValidation.message); + } + + if (AreUIEditorWorkspaceModelsEquivalent(m_workspace, snapshot.workspace) && + AreUIEditorWorkspaceSessionsEquivalent(m_session, snapshot.session)) { + return BuildLayoutOperationResult( + UIEditorWorkspaceLayoutOperationStatus::NoOp, + "Current state already matches the requested layout snapshot."); + } + + const UIEditorWorkspaceModel previousWorkspace = m_workspace; + const UIEditorWorkspaceSession previousSession = m_session; + m_workspace = snapshot.workspace; + m_session = snapshot.session; + + const UIEditorWorkspaceControllerValidationResult validation = ValidateState(); + if (!validation.IsValid()) { + m_workspace = previousWorkspace; + m_session = previousSession; + return BuildLayoutOperationResult( + UIEditorWorkspaceLayoutOperationStatus::Rejected, + "Restored layout produced invalid controller state: " + validation.message); + } + + return BuildLayoutOperationResult( + UIEditorWorkspaceLayoutOperationStatus::Changed, + "Layout restored."); +} + +UIEditorWorkspaceLayoutOperationResult UIEditorWorkspaceController::RestoreSerializedLayout( + std::string_view serializedLayout) { + const UIEditorWorkspaceLayoutLoadResult loadResult = + DeserializeUIEditorWorkspaceLayoutSnapshot(m_panelRegistry, serializedLayout); + if (!loadResult.IsValid()) { + return BuildLayoutOperationResult( + UIEditorWorkspaceLayoutOperationStatus::Rejected, + "Serialized layout rejected: " + loadResult.message); + } + + return RestoreLayoutSnapshot(loadResult.snapshot); +} + UIEditorWorkspaceCommandResult UIEditorWorkspaceController::Dispatch( const UIEditorWorkspaceCommand& command) { const UIEditorWorkspaceControllerValidationResult validation = ValidateState(); @@ -326,8 +369,8 @@ UIEditorWorkspaceCommandResult UIEditorWorkspaceController::Dispatch( previousSession); case UIEditorWorkspaceCommandKind::ResetWorkspace: - if (AreWorkspaceModelsEquivalent(m_workspace, m_baselineWorkspace) && - AreWorkspaceSessionsEquivalent(m_session, m_baselineSession)) { + if (AreUIEditorWorkspaceModelsEquivalent(m_workspace, m_baselineWorkspace) && + AreUIEditorWorkspaceSessionsEquivalent(m_session, m_baselineSession)) { return BuildResult(command, UIEditorWorkspaceCommandStatus::NoOp, "Workspace already matches the baseline state."); } diff --git a/new_editor/src/editor/UIEditorWorkspaceLayoutPersistence.cpp b/new_editor/src/editor/UIEditorWorkspaceLayoutPersistence.cpp new file mode 100644 index 00000000..39ab76c6 --- /dev/null +++ b/new_editor/src/editor/UIEditorWorkspaceLayoutPersistence.cpp @@ -0,0 +1,497 @@ +#include + +#include +#include +#include +#include +#include +#include + +namespace XCEngine::NewEditor { + +namespace { + +constexpr std::string_view kLayoutHeader = "XCUI_EDITOR_WORKSPACE_LAYOUT"; +constexpr int kLayoutVersion = 1; + +struct LayoutLine { + std::size_t number = 0u; + std::string text = {}; +}; + +UIEditorWorkspaceLayoutLoadResult MakeLoadError( + UIEditorWorkspaceLayoutLoadCode code, + std::string message) { + UIEditorWorkspaceLayoutLoadResult result = {}; + result.code = code; + result.message = std::move(message); + return result; +} + +bool HasTrailingTokens(std::istringstream& stream) { + stream >> std::ws; + return !stream.eof(); +} + +std::string MakeLinePrefix(const LayoutLine& line) { + return "Line " + std::to_string(line.number) + ": "; +} + +bool ParseBinaryFlag( + std::istringstream& stream, + const LayoutLine& line, + int& outValue, + UIEditorWorkspaceLayoutLoadResult& outError, + UIEditorWorkspaceLayoutLoadCode code, + std::string_view fieldName) { + if (!(stream >> outValue) || (outValue != 0 && outValue != 1)) { + outError = MakeLoadError( + code, + MakeLinePrefix(line) + std::string(fieldName) + " must be encoded as 0 or 1."); + return false; + } + + return true; +} + +bool ParseNodeLine( + const LayoutLine& line, + std::string& outTag, + std::istringstream& outStream) { + outStream = std::istringstream(line.text); + return static_cast(outStream >> outTag); +} + +UIEditorWorkspaceLayoutLoadResult ParseNodeRecursive( + const std::vector& lines, + std::size_t& index, + UIEditorWorkspaceNode& outNode); + +std::string SerializeAxis(UIEditorWorkspaceSplitAxis axis) { + return axis == UIEditorWorkspaceSplitAxis::Vertical ? "vertical" : "horizontal"; +} + +UIEditorWorkspaceLayoutLoadResult ParseAxis( + std::string_view text, + UIEditorWorkspaceSplitAxis& outAxis, + const LayoutLine& line) { + if (text == "horizontal") { + outAxis = UIEditorWorkspaceSplitAxis::Horizontal; + return {}; + } + + if (text == "vertical") { + outAxis = UIEditorWorkspaceSplitAxis::Vertical; + return {}; + } + + return MakeLoadError( + UIEditorWorkspaceLayoutLoadCode::InvalidNodeRecord, + MakeLinePrefix(line) + "split axis must be \"horizontal\" or \"vertical\"."); +} + +void SerializeNodeRecursive( + const UIEditorWorkspaceNode& node, + std::ostringstream& stream) { + switch (node.kind) { + case UIEditorWorkspaceNodeKind::Panel: + stream << "node_panel " + << std::quoted(node.nodeId) << ' ' + << std::quoted(node.panel.panelId) << ' ' + << std::quoted(node.panel.title) << ' ' + << (node.panel.placeholder ? 1 : 0) << '\n'; + return; + + case UIEditorWorkspaceNodeKind::TabStack: + stream << "node_tabstack " + << std::quoted(node.nodeId) << ' ' + << node.selectedTabIndex << ' ' + << node.children.size() << '\n'; + for (const UIEditorWorkspaceNode& child : node.children) { + SerializeNodeRecursive(child, stream); + } + return; + + case UIEditorWorkspaceNodeKind::Split: + stream << "node_split " + << std::quoted(node.nodeId) << ' ' + << std::quoted(SerializeAxis(node.splitAxis)) << ' ' + << std::setprecision(std::numeric_limits::max_digits10) + << node.splitRatio << '\n'; + for (const UIEditorWorkspaceNode& child : node.children) { + SerializeNodeRecursive(child, stream); + } + return; + } +} + +std::vector CollectNonEmptyLines(std::string_view serializedLayout) { + std::vector lines = {}; + std::istringstream stream{ std::string(serializedLayout) }; + std::string text = {}; + std::size_t lineNumber = 0u; + while (std::getline(stream, text)) { + ++lineNumber; + if (!text.empty() && text.back() == '\r') { + text.pop_back(); + } + + const std::size_t first = text.find_first_not_of(" \t"); + if (first == std::string::npos) { + continue; + } + + lines.push_back({ lineNumber, text }); + } + + return lines; +} + +UIEditorWorkspaceLayoutLoadResult ParseHeader(const LayoutLine& line) { + std::istringstream stream(line.text); + std::string header = {}; + int version = 0; + if (!(stream >> header >> version) || HasTrailingTokens(stream)) { + return MakeLoadError( + UIEditorWorkspaceLayoutLoadCode::InvalidHeader, + MakeLinePrefix(line) + "invalid layout header."); + } + + if (header != kLayoutHeader) { + return MakeLoadError( + UIEditorWorkspaceLayoutLoadCode::InvalidHeader, + MakeLinePrefix(line) + "layout header magic is invalid."); + } + + if (version != kLayoutVersion) { + return MakeLoadError( + UIEditorWorkspaceLayoutLoadCode::UnsupportedVersion, + MakeLinePrefix(line) + "unsupported layout version " + std::to_string(version) + "."); + } + + return {}; +} + +UIEditorWorkspaceLayoutLoadResult ParseActiveRecord( + const LayoutLine& line, + std::string& outActivePanelId) { + std::istringstream stream(line.text); + std::string tag = {}; + if (!(stream >> tag) || tag != "active" || + !(stream >> std::quoted(outActivePanelId)) || + HasTrailingTokens(stream)) { + return MakeLoadError( + UIEditorWorkspaceLayoutLoadCode::MissingActiveRecord, + MakeLinePrefix(line) + "active record must be `active \"panel-id\"`."); + } + + return {}; +} + +UIEditorWorkspaceLayoutLoadResult ParsePanelNode( + std::istringstream& stream, + const LayoutLine& line, + UIEditorWorkspaceNode& outNode) { + std::string nodeId = {}; + std::string panelId = {}; + std::string title = {}; + int placeholderValue = 0; + if (!(stream >> std::quoted(nodeId) >> std::quoted(panelId) >> std::quoted(title))) { + return MakeLoadError( + UIEditorWorkspaceLayoutLoadCode::InvalidNodeRecord, + MakeLinePrefix(line) + "panel node record is malformed."); + } + + UIEditorWorkspaceLayoutLoadResult boolParse = {}; + if (!ParseBinaryFlag( + stream, + line, + placeholderValue, + boolParse, + UIEditorWorkspaceLayoutLoadCode::InvalidNodeRecord, + "placeholder")) { + return boolParse; + } + + if (HasTrailingTokens(stream)) { + return MakeLoadError( + UIEditorWorkspaceLayoutLoadCode::InvalidNodeRecord, + MakeLinePrefix(line) + "panel node record contains trailing tokens."); + } + + outNode = BuildUIEditorWorkspacePanel( + std::move(nodeId), + std::move(panelId), + std::move(title), + placeholderValue != 0); + return {}; +} + +UIEditorWorkspaceLayoutLoadResult ParseTabStackNode( + const std::vector& lines, + std::size_t& index, + std::istringstream& stream, + const LayoutLine& line, + UIEditorWorkspaceNode& outNode) { + std::string nodeId = {}; + std::size_t selectedTabIndex = 0u; + std::size_t childCount = 0u; + if (!(stream >> std::quoted(nodeId) >> selectedTabIndex >> childCount) || + HasTrailingTokens(stream)) { + return MakeLoadError( + UIEditorWorkspaceLayoutLoadCode::InvalidNodeRecord, + MakeLinePrefix(line) + "tab stack node record is malformed."); + } + + outNode = {}; + outNode.kind = UIEditorWorkspaceNodeKind::TabStack; + outNode.nodeId = std::move(nodeId); + outNode.selectedTabIndex = selectedTabIndex; + outNode.children.reserve(childCount); + for (std::size_t childIndex = 0; childIndex < childCount; ++childIndex) { + UIEditorWorkspaceNode child = {}; + UIEditorWorkspaceLayoutLoadResult childResult = ParseNodeRecursive(lines, index, child); + if (!childResult.IsValid()) { + return childResult; + } + outNode.children.push_back(std::move(child)); + } + + return {}; +} + +UIEditorWorkspaceLayoutLoadResult ParseSplitNode( + const std::vector& lines, + std::size_t& index, + std::istringstream& stream, + const LayoutLine& line, + UIEditorWorkspaceNode& outNode) { + std::string nodeId = {}; + std::string axisText = {}; + float splitRatio = 0.0f; + if (!(stream >> std::quoted(nodeId) >> std::quoted(axisText) >> splitRatio) || + HasTrailingTokens(stream)) { + return MakeLoadError( + UIEditorWorkspaceLayoutLoadCode::InvalidNodeRecord, + MakeLinePrefix(line) + "split node record is malformed."); + } + + UIEditorWorkspaceSplitAxis axis = UIEditorWorkspaceSplitAxis::Horizontal; + if (UIEditorWorkspaceLayoutLoadResult axisResult = ParseAxis(axisText, axis, line); + !axisResult.IsValid()) { + return axisResult; + } + + UIEditorWorkspaceNode primary = {}; + UIEditorWorkspaceNode secondary = {}; + if (UIEditorWorkspaceLayoutLoadResult primaryResult = ParseNodeRecursive(lines, index, primary); + !primaryResult.IsValid()) { + return primaryResult; + } + + if (UIEditorWorkspaceLayoutLoadResult secondaryResult = ParseNodeRecursive(lines, index, secondary); + !secondaryResult.IsValid()) { + return secondaryResult; + } + + outNode = BuildUIEditorWorkspaceSplit( + std::move(nodeId), + axis, + splitRatio, + std::move(primary), + std::move(secondary)); + return {}; +} + +UIEditorWorkspaceLayoutLoadResult ParseNodeRecursive( + const std::vector& lines, + std::size_t& index, + UIEditorWorkspaceNode& outNode) { + if (index >= lines.size()) { + return MakeLoadError( + UIEditorWorkspaceLayoutLoadCode::UnexpectedEndOfInput, + "Unexpected end of input while parsing workspace nodes."); + } + + const LayoutLine& line = lines[index++]; + std::istringstream stream = {}; + std::string tag = {}; + if (!ParseNodeLine(line, tag, stream)) { + return MakeLoadError( + UIEditorWorkspaceLayoutLoadCode::InvalidNodeRecord, + MakeLinePrefix(line) + "workspace node record is empty."); + } + + if (tag == "node_panel") { + return ParsePanelNode(stream, line, outNode); + } + + if (tag == "node_tabstack") { + return ParseTabStackNode(lines, index, stream, line, outNode); + } + + if (tag == "node_split") { + return ParseSplitNode(lines, index, stream, line, outNode); + } + + return MakeLoadError( + UIEditorWorkspaceLayoutLoadCode::InvalidNodeRecord, + MakeLinePrefix(line) + "unknown workspace node tag '" + tag + "'."); +} + +UIEditorWorkspaceLayoutLoadResult ParseSessionRecord( + const LayoutLine& line, + UIEditorPanelSessionState& outState) { + std::istringstream stream(line.text); + std::string tag = {}; + int openValue = 0; + int visibleValue = 0; + if (!(stream >> tag) || tag != "session" || + !(stream >> std::quoted(outState.panelId))) { + return MakeLoadError( + UIEditorWorkspaceLayoutLoadCode::InvalidSessionRecord, + MakeLinePrefix(line) + "session record must start with `session`."); + } + + UIEditorWorkspaceLayoutLoadResult boolParse = {}; + if (!ParseBinaryFlag( + stream, + line, + openValue, + boolParse, + UIEditorWorkspaceLayoutLoadCode::InvalidSessionRecord, + "open")) { + return boolParse; + } + + if (!ParseBinaryFlag( + stream, + line, + visibleValue, + boolParse, + UIEditorWorkspaceLayoutLoadCode::InvalidSessionRecord, + "visible")) { + return boolParse; + } + + if (HasTrailingTokens(stream)) { + return MakeLoadError( + UIEditorWorkspaceLayoutLoadCode::InvalidSessionRecord, + MakeLinePrefix(line) + "session record contains trailing tokens."); + } + + outState.open = openValue != 0; + outState.visible = visibleValue != 0; + return {}; +} + +} // namespace + +UIEditorWorkspaceLayoutSnapshot BuildUIEditorWorkspaceLayoutSnapshot( + const UIEditorWorkspaceModel& workspace, + const UIEditorWorkspaceSession& session) { + UIEditorWorkspaceLayoutSnapshot snapshot = {}; + snapshot.workspace = workspace; + snapshot.session = session; + return snapshot; +} + +bool AreUIEditorWorkspaceLayoutSnapshotsEquivalent( + const UIEditorWorkspaceLayoutSnapshot& lhs, + const UIEditorWorkspaceLayoutSnapshot& rhs) { + return AreUIEditorWorkspaceModelsEquivalent(lhs.workspace, rhs.workspace) && + AreUIEditorWorkspaceSessionsEquivalent(lhs.session, rhs.session); +} + +std::string SerializeUIEditorWorkspaceLayoutSnapshot( + const UIEditorWorkspaceLayoutSnapshot& snapshot) { + std::ostringstream stream = {}; + stream << kLayoutHeader << ' ' << kLayoutVersion << '\n'; + stream << "active " << std::quoted(snapshot.workspace.activePanelId) << '\n'; + SerializeNodeRecursive(snapshot.workspace.root, stream); + for (const UIEditorPanelSessionState& state : snapshot.session.panelStates) { + stream << "session " + << std::quoted(state.panelId) << ' ' + << (state.open ? 1 : 0) << ' ' + << (state.visible ? 1 : 0) << '\n'; + } + return stream.str(); +} + +UIEditorWorkspaceLayoutLoadResult DeserializeUIEditorWorkspaceLayoutSnapshot( + const UIEditorPanelRegistry& panelRegistry, + std::string_view serializedLayout) { + const UIEditorPanelRegistryValidationResult registryValidation = + ValidateUIEditorPanelRegistry(panelRegistry); + if (!registryValidation.IsValid()) { + return MakeLoadError( + UIEditorWorkspaceLayoutLoadCode::InvalidPanelRegistry, + "Panel registry invalid: " + registryValidation.message); + } + + const std::vector lines = CollectNonEmptyLines(serializedLayout); + if (lines.empty()) { + return MakeLoadError( + UIEditorWorkspaceLayoutLoadCode::EmptyInput, + "Serialized layout input is empty."); + } + + if (UIEditorWorkspaceLayoutLoadResult headerResult = ParseHeader(lines.front()); + !headerResult.IsValid()) { + return headerResult; + } + + if (lines.size() < 2u) { + return MakeLoadError( + UIEditorWorkspaceLayoutLoadCode::MissingActiveRecord, + "Serialized layout is missing the active panel record."); + } + + UIEditorWorkspaceLayoutSnapshot snapshot = {}; + if (UIEditorWorkspaceLayoutLoadResult activeResult = + ParseActiveRecord(lines[1], snapshot.workspace.activePanelId); + !activeResult.IsValid()) { + return activeResult; + } + + std::size_t index = 2u; + if (UIEditorWorkspaceLayoutLoadResult rootResult = + ParseNodeRecursive(lines, index, snapshot.workspace.root); + !rootResult.IsValid()) { + return rootResult; + } + + snapshot.session.panelStates.clear(); + while (index < lines.size()) { + UIEditorPanelSessionState state = {}; + if (UIEditorWorkspaceLayoutLoadResult stateResult = + ParseSessionRecord(lines[index], state); + !stateResult.IsValid()) { + return stateResult; + } + snapshot.session.panelStates.push_back(std::move(state)); + ++index; + } + + if (UIEditorWorkspaceValidationResult workspaceValidation = + ValidateUIEditorWorkspace(snapshot.workspace); + !workspaceValidation.IsValid()) { + return MakeLoadError( + UIEditorWorkspaceLayoutLoadCode::InvalidWorkspace, + workspaceValidation.message); + } + + if (UIEditorWorkspaceSessionValidationResult sessionValidation = + ValidateUIEditorWorkspaceSession(panelRegistry, snapshot.workspace, snapshot.session); + !sessionValidation.IsValid()) { + return MakeLoadError( + UIEditorWorkspaceLayoutLoadCode::InvalidWorkspaceSession, + sessionValidation.message); + } + + UIEditorWorkspaceLayoutLoadResult result = {}; + result.snapshot = std::move(snapshot); + return result; +} + +} // namespace XCEngine::NewEditor diff --git a/new_editor/src/editor/UIEditorWorkspaceModel.cpp b/new_editor/src/editor/UIEditorWorkspaceModel.cpp index 127cffc5..a915d0cf 100644 --- a/new_editor/src/editor/UIEditorWorkspaceModel.cpp +++ b/new_editor/src/editor/UIEditorWorkspaceModel.cpp @@ -205,6 +205,37 @@ UIEditorWorkspaceValidationResult ValidateNodeRecursive( } // namespace +bool AreUIEditorWorkspaceNodesEquivalent( + const UIEditorWorkspaceNode& lhs, + const UIEditorWorkspaceNode& rhs) { + if (lhs.kind != rhs.kind || + lhs.nodeId != rhs.nodeId || + lhs.splitAxis != rhs.splitAxis || + lhs.splitRatio != rhs.splitRatio || + lhs.selectedTabIndex != rhs.selectedTabIndex || + lhs.panel.panelId != rhs.panel.panelId || + lhs.panel.title != rhs.panel.title || + lhs.panel.placeholder != rhs.panel.placeholder || + lhs.children.size() != rhs.children.size()) { + return false; + } + + for (std::size_t index = 0; index < lhs.children.size(); ++index) { + if (!AreUIEditorWorkspaceNodesEquivalent(lhs.children[index], rhs.children[index])) { + return false; + } + } + + return true; +} + +bool AreUIEditorWorkspaceModelsEquivalent( + const UIEditorWorkspaceModel& lhs, + const UIEditorWorkspaceModel& rhs) { + return lhs.activePanelId == rhs.activePanelId && + AreUIEditorWorkspaceNodesEquivalent(lhs.root, rhs.root); +} + UIEditorWorkspaceModel BuildDefaultEditorShellWorkspaceModel() { const UIEditorPanelRegistry registry = BuildDefaultEditorShellPanelRegistry(); const UIEditorPanelDescriptor& rootPanel = diff --git a/new_editor/src/editor/UIEditorWorkspaceSession.cpp b/new_editor/src/editor/UIEditorWorkspaceSession.cpp index 17e21544..4cbc45be 100644 --- a/new_editor/src/editor/UIEditorWorkspaceSession.cpp +++ b/new_editor/src/editor/UIEditorWorkspaceSession.cpp @@ -198,57 +198,6 @@ void NormalizeWorkspaceSession( TryActivateUIEditorWorkspacePanel(workspace, targetActivePanelId); } -bool AreWorkspaceNodesEquivalent( - const UIEditorWorkspaceNode& lhs, - const UIEditorWorkspaceNode& rhs) { - if (lhs.kind != rhs.kind || - lhs.nodeId != rhs.nodeId || - lhs.splitAxis != rhs.splitAxis || - lhs.splitRatio != rhs.splitRatio || - lhs.selectedTabIndex != rhs.selectedTabIndex || - lhs.panel.panelId != rhs.panel.panelId || - lhs.panel.title != rhs.panel.title || - lhs.panel.placeholder != rhs.panel.placeholder || - lhs.children.size() != rhs.children.size()) { - return false; - } - - for (std::size_t index = 0; index < lhs.children.size(); ++index) { - if (!AreWorkspaceNodesEquivalent(lhs.children[index], rhs.children[index])) { - return false; - } - } - - return true; -} - -bool AreWorkspaceModelsEquivalent( - const UIEditorWorkspaceModel& lhs, - const UIEditorWorkspaceModel& rhs) { - return lhs.activePanelId == rhs.activePanelId && - AreWorkspaceNodesEquivalent(lhs.root, rhs.root); -} - -bool AreWorkspaceSessionsEquivalent( - const UIEditorWorkspaceSession& lhs, - const UIEditorWorkspaceSession& rhs) { - if (lhs.panelStates.size() != rhs.panelStates.size()) { - return false; - } - - for (std::size_t index = 0; index < lhs.panelStates.size(); ++index) { - const UIEditorPanelSessionState& lhsState = lhs.panelStates[index]; - const UIEditorPanelSessionState& rhsState = rhs.panelStates[index]; - if (lhsState.panelId != rhsState.panelId || - lhsState.open != rhsState.open || - lhsState.visible != rhsState.visible) { - return false; - } - } - - return true; -} - } // namespace UIEditorWorkspaceSession BuildDefaultUIEditorWorkspaceSession( @@ -348,6 +297,26 @@ UIEditorWorkspaceSessionValidationResult ValidateUIEditorWorkspaceSession( return {}; } +bool AreUIEditorWorkspaceSessionsEquivalent( + const UIEditorWorkspaceSession& lhs, + const UIEditorWorkspaceSession& rhs) { + if (lhs.panelStates.size() != rhs.panelStates.size()) { + return false; + } + + for (std::size_t index = 0; index < lhs.panelStates.size(); ++index) { + const UIEditorPanelSessionState& lhsState = lhs.panelStates[index]; + const UIEditorPanelSessionState& rhsState = rhs.panelStates[index]; + if (lhsState.panelId != rhsState.panelId || + lhsState.open != rhsState.open || + lhsState.visible != rhsState.visible) { + return false; + } + } + + return true; +} + std::vector CollectUIEditorWorkspaceVisiblePanels( const UIEditorWorkspaceModel& workspace, const UIEditorWorkspaceSession& session) { @@ -391,8 +360,8 @@ bool TryOpenUIEditorWorkspacePanel( state->open = true; state->visible = true; NormalizeWorkspaceSession(panelRegistry, workspace, session, panelId); - return !AreWorkspaceModelsEquivalent(workspaceBefore, workspace) || - !AreWorkspaceSessionsEquivalent(sessionBefore, session); + return !AreUIEditorWorkspaceModelsEquivalent(workspaceBefore, workspace) || + !AreUIEditorWorkspaceSessionsEquivalent(sessionBefore, session); } bool TryCloseUIEditorWorkspacePanel( @@ -412,8 +381,8 @@ bool TryCloseUIEditorWorkspacePanel( state->open = false; state->visible = false; NormalizeWorkspaceSession(panelRegistry, workspace, session, {}); - return !AreWorkspaceModelsEquivalent(workspaceBefore, workspace) || - !AreWorkspaceSessionsEquivalent(sessionBefore, session); + return !AreUIEditorWorkspaceModelsEquivalent(workspaceBefore, workspace) || + !AreUIEditorWorkspaceSessionsEquivalent(sessionBefore, session); } bool TryShowUIEditorWorkspacePanel( @@ -432,8 +401,8 @@ bool TryShowUIEditorWorkspacePanel( state->visible = true; NormalizeWorkspaceSession(panelRegistry, workspace, session, panelId); - return !AreWorkspaceModelsEquivalent(workspaceBefore, workspace) || - !AreWorkspaceSessionsEquivalent(sessionBefore, session); + return !AreUIEditorWorkspaceModelsEquivalent(workspaceBefore, workspace) || + !AreUIEditorWorkspaceSessionsEquivalent(sessionBefore, session); } bool TryHideUIEditorWorkspacePanel( @@ -452,8 +421,8 @@ bool TryHideUIEditorWorkspacePanel( state->visible = false; NormalizeWorkspaceSession(panelRegistry, workspace, session, {}); - return !AreWorkspaceModelsEquivalent(workspaceBefore, workspace) || - !AreWorkspaceSessionsEquivalent(sessionBefore, session); + return !AreUIEditorWorkspaceModelsEquivalent(workspaceBefore, workspace) || + !AreUIEditorWorkspaceSessionsEquivalent(sessionBefore, session); } bool TryActivateUIEditorWorkspacePanel( @@ -469,8 +438,8 @@ bool TryActivateUIEditorWorkspacePanel( } NormalizeWorkspaceSession(panelRegistry, workspace, session, panelId); - return !AreWorkspaceModelsEquivalent(workspaceBefore, workspace) || - !AreWorkspaceSessionsEquivalent(sessionBefore, session); + return !AreUIEditorWorkspaceModelsEquivalent(workspaceBefore, workspace) || + !AreUIEditorWorkspaceSessionsEquivalent(sessionBefore, session); } } // namespace XCEngine::NewEditor diff --git a/tests/UI/Editor/integration/README.md b/tests/UI/Editor/integration/README.md index 4b5763c4..af580e97 100644 --- a/tests/UI/Editor/integration/README.md +++ b/tests/UI/Editor/integration/README.md @@ -10,12 +10,15 @@ Current status: splitters, tab host, panel chrome placeholders, and hot reload. - The second scenario is `state/panel_session_flow/`, focused on editor command dispatch and panel session state only: `command dispatch + workspace controller + open / close / show / hide / activate`. +- The third scenario is `state/layout_persistence/`, focused on editor layout save/load/reset only: + `layout snapshot + serialize / deserialize + invalid payload reject`. Layout: - `shared/`: editor validation scenario registry, Win32 host wrapper, shared theme - `workspace_shell_compose/`: first manual editor shell compose scenario - `state/panel_session_flow/`: custom host scenario for editor panel session state flow +- `state/layout_persistence/`: custom host scenario for editor layout persistence flow Current scenario: @@ -31,6 +34,13 @@ Additional scenario: - Executable name: `XCUIEditorPanelSessionFlowValidation` - Validation scope: editor command dispatch and panel session state only, no business panels +Additional scenario: + +- Scenario id: `editor.state.layout_persistence` +- Build target: `editor_ui_layout_persistence_validation` +- Executable name: `XCUIEditorLayoutPersistenceValidation` +- Validation scope: layout save / load / reset / invalid payload reject only, no business panels + Run: ```bash @@ -52,6 +62,13 @@ Panel session flow controls: - Check `Last command` shows `Changed / NoOp / Rejected` consistently with the current state. - Press `F12` to write screenshots into `state/panel_session_flow/captures/`. +Layout persistence controls: + +- Click `Hide Active -> Save Layout -> Close Doc B -> Load Layout`. +- Check `Saved` summary captures the expected active/visible state, and `Load Layout` restores it. +- Click `Load Invalid` and confirm the result is `Rejected` while current state remains unchanged. +- Press `F12` to write screenshots into `state/layout_persistence/captures/`. + Build: ```bash diff --git a/tests/UI/Editor/integration/state/CMakeLists.txt b/tests/UI/Editor/integration/state/CMakeLists.txt index dafd6212..2a801b14 100644 --- a/tests/UI/Editor/integration/state/CMakeLists.txt +++ b/tests/UI/Editor/integration/state/CMakeLists.txt @@ -1 +1,2 @@ add_subdirectory(panel_session_flow) +add_subdirectory(layout_persistence) diff --git a/tests/UI/Editor/integration/state/layout_persistence/CMakeLists.txt b/tests/UI/Editor/integration/state/layout_persistence/CMakeLists.txt new file mode 100644 index 00000000..edd10bd2 --- /dev/null +++ b/tests/UI/Editor/integration/state/layout_persistence/CMakeLists.txt @@ -0,0 +1,29 @@ +add_executable(editor_ui_layout_persistence_validation WIN32 + main.cpp +) + +target_include_directories(editor_ui_layout_persistence_validation PRIVATE + ${CMAKE_SOURCE_DIR}/engine/include + ${CMAKE_SOURCE_DIR}/new_editor/include +) + +target_compile_definitions(editor_ui_layout_persistence_validation PRIVATE + UNICODE + _UNICODE + XCENGINE_EDITOR_UI_TESTS_REPO_ROOT="${XCENGINE_EDITOR_UI_TESTS_REPO_ROOT_PATH}" +) + +if(MSVC) + target_compile_options(editor_ui_layout_persistence_validation PRIVATE /utf-8 /FS) + set_property(TARGET editor_ui_layout_persistence_validation PROPERTY + MSVC_RUNTIME_LIBRARY "MultiThreaded$<$:Debug>DLL") +endif() + +target_link_libraries(editor_ui_layout_persistence_validation PRIVATE + XCNewEditorLib + XCNewEditorHost +) + +set_target_properties(editor_ui_layout_persistence_validation PROPERTIES + OUTPUT_NAME "XCUIEditorLayoutPersistenceValidation" +) diff --git a/tests/UI/Editor/integration/state/layout_persistence/captures/.gitkeep b/tests/UI/Editor/integration/state/layout_persistence/captures/.gitkeep new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/tests/UI/Editor/integration/state/layout_persistence/captures/.gitkeep @@ -0,0 +1 @@ + diff --git a/tests/UI/Editor/integration/state/layout_persistence/main.cpp b/tests/UI/Editor/integration/state/layout_persistence/main.cpp new file mode 100644 index 00000000..a86b30a3 --- /dev/null +++ b/tests/UI/Editor/integration/state/layout_persistence/main.cpp @@ -0,0 +1,858 @@ +#ifndef NOMINMAX +#define NOMINMAX +#endif + +#include +#include +#include +#include + +#include + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#ifndef XCENGINE_EDITOR_UI_TESTS_REPO_ROOT +#define XCENGINE_EDITOR_UI_TESTS_REPO_ROOT "." +#endif + +namespace { + +using XCEngine::NewEditor::BuildDefaultUIEditorWorkspaceController; +using XCEngine::NewEditor::BuildDefaultUIEditorWorkspaceSession; +using XCEngine::NewEditor::BuildUIEditorWorkspacePanel; +using XCEngine::NewEditor::BuildUIEditorWorkspaceSplit; +using XCEngine::NewEditor::BuildUIEditorWorkspaceTabStack; +using XCEngine::NewEditor::CollectUIEditorWorkspaceVisiblePanels; +using XCEngine::NewEditor::FindUIEditorPanelSessionState; +using XCEngine::NewEditor::GetUIEditorWorkspaceCommandStatusName; +using XCEngine::NewEditor::GetUIEditorWorkspaceLayoutOperationStatusName; +using XCEngine::NewEditor::SerializeUIEditorWorkspaceLayoutSnapshot; +using XCEngine::NewEditor::UIEditorPanelRegistry; +using XCEngine::NewEditor::UIEditorWorkspaceCommand; +using XCEngine::NewEditor::UIEditorWorkspaceCommandKind; +using XCEngine::NewEditor::UIEditorWorkspaceCommandResult; +using XCEngine::NewEditor::UIEditorWorkspaceCommandStatus; +using XCEngine::NewEditor::UIEditorWorkspaceController; +using XCEngine::NewEditor::UIEditorWorkspaceLayoutOperationResult; +using XCEngine::NewEditor::UIEditorWorkspaceLayoutOperationStatus; +using XCEngine::NewEditor::UIEditorWorkspaceLayoutSnapshot; +using XCEngine::NewEditor::UIEditorWorkspaceModel; +using XCEngine::NewEditor::UIEditorWorkspaceSession; +using XCEngine::NewEditor::UIEditorWorkspaceSplitAxis; +using XCEngine::UI::UIColor; +using XCEngine::UI::UIDrawData; +using XCEngine::UI::UIDrawList; +using XCEngine::UI::UIPoint; +using XCEngine::UI::UIRect; +using XCEngine::XCUI::Host::AutoScreenshotController; +using XCEngine::XCUI::Host::NativeRenderer; + +constexpr const wchar_t* kWindowClassName = L"XCUIEditorLayoutPersistenceValidation"; +constexpr const wchar_t* kWindowTitle = L"XCUI Editor | Layout Persistence"; + +constexpr UIColor kWindowBg(0.14f, 0.14f, 0.14f, 1.0f); +constexpr UIColor kCardBg(0.19f, 0.19f, 0.19f, 1.0f); +constexpr UIColor kCardBorder(0.29f, 0.29f, 0.29f, 1.0f); +constexpr UIColor kTextPrimary(0.94f, 0.94f, 0.94f, 1.0f); +constexpr UIColor kTextMuted(0.70f, 0.70f, 0.70f, 1.0f); +constexpr UIColor kAccent(0.82f, 0.82f, 0.82f, 1.0f); +constexpr UIColor kSuccess(0.43f, 0.71f, 0.47f, 1.0f); +constexpr UIColor kWarning(0.78f, 0.60f, 0.30f, 1.0f); +constexpr UIColor kDanger(0.78f, 0.34f, 0.34f, 1.0f); +constexpr UIColor kButtonEnabled(0.31f, 0.31f, 0.31f, 1.0f); +constexpr UIColor kButtonDisabled(0.24f, 0.24f, 0.24f, 1.0f); +constexpr UIColor kButtonBorder(0.42f, 0.42f, 0.42f, 1.0f); +constexpr UIColor kPanelRowBg(0.17f, 0.17f, 0.17f, 1.0f); + +enum class ActionId : unsigned char { + HideActive = 0, + SaveLayout, + CloseDocB, + LoadLayout, + ActivateDetails, + LoadInvalid, + Reset +}; + +struct ButtonState { + ActionId action = ActionId::HideActive; + std::string label = {}; + UIRect rect = {}; + bool enabled = false; +}; + +std::filesystem::path ResolveRepoRootPath() { + std::string root = XCENGINE_EDITOR_UI_TESTS_REPO_ROOT; + if (root.size() >= 2u && root.front() == '"' && root.back() == '"') { + root = root.substr(1u, root.size() - 2u); + } + + return std::filesystem::path(root).lexically_normal(); +} + +UIEditorPanelRegistry BuildPanelRegistry() { + UIEditorPanelRegistry registry = {}; + registry.panels = { + { "doc-a", "Document A", {}, true, true, true }, + { "doc-b", "Document B", {}, true, true, true }, + { "details", "Details", {}, true, true, true } + }; + return registry; +} + +UIEditorWorkspaceModel BuildWorkspace() { + UIEditorWorkspaceModel workspace = {}; + workspace.root = BuildUIEditorWorkspaceSplit( + "root-split", + UIEditorWorkspaceSplitAxis::Horizontal, + 0.66f, + BuildUIEditorWorkspaceTabStack( + "document-tabs", + { + BuildUIEditorWorkspacePanel("doc-a-node", "doc-a", "Document A", true), + BuildUIEditorWorkspacePanel("doc-b-node", "doc-b", "Document B", true) + }, + 0u), + BuildUIEditorWorkspacePanel("details-node", "details", "Details", true)); + workspace.activePanelId = "doc-a"; + return workspace; +} + +bool ContainsPoint(const UIRect& rect, float x, float y) { + return x >= rect.x && + x <= rect.x + rect.width && + y >= rect.y && + y <= rect.y + rect.height; +} + +std::string JoinVisiblePanelIds( + const UIEditorWorkspaceModel& workspace, + const UIEditorWorkspaceSession& session) { + const auto panels = CollectUIEditorWorkspaceVisiblePanels(workspace, session); + if (panels.empty()) { + return "(none)"; + } + + std::ostringstream stream; + for (std::size_t index = 0; index < panels.size(); ++index) { + if (index > 0u) { + stream << ", "; + } + stream << panels[index].panelId; + } + return stream.str(); +} + +std::string DescribePanelState( + const UIEditorWorkspaceSession& session, + std::string_view panelId, + std::string_view displayName) { + const auto* state = FindUIEditorPanelSessionState(session, panelId); + if (state == nullptr) { + return std::string(displayName) + ": missing"; + } + + std::string visibility = {}; + if (!state->open) { + visibility = "closed"; + } else if (!state->visible) { + visibility = "hidden"; + } else { + visibility = "visible"; + } + + return std::string(displayName) + ": " + visibility; +} + +UIColor ResolvePanelStateColor( + const UIEditorWorkspaceSession& session, + std::string_view panelId) { + const auto* state = FindUIEditorPanelSessionState(session, panelId); + if (state == nullptr) { + return kDanger; + } + + if (!state->open) { + return kDanger; + } + + if (!state->visible) { + return kWarning; + } + + return kSuccess; +} + +void DrawCard( + UIDrawList& drawList, + const UIRect& rect, + std::string_view title, + std::string_view subtitle = {}) { + drawList.AddFilledRect(rect, kCardBg, 12.0f); + drawList.AddRectOutline(rect, kCardBorder, 1.0f, 12.0f); + drawList.AddText(UIPoint(rect.x + 18.0f, rect.y + 16.0f), std::string(title), kTextPrimary, 17.0f); + if (!subtitle.empty()) { + drawList.AddText(UIPoint(rect.x + 18.0f, rect.y + 42.0f), std::string(subtitle), kTextMuted, 12.0f); + } +} + +std::string BuildSerializedPreview(std::string_view serializedLayout) { + if (serializedLayout.empty()) { + return "尚未保存布局"; + } + + std::istringstream stream{ std::string(serializedLayout) }; + std::ostringstream preview = {}; + std::string line = {}; + int lineCount = 0; + while (std::getline(stream, line) && lineCount < 4) { + if (!line.empty() && line.back() == '\r') { + line.pop_back(); + } + if (line.empty()) { + continue; + } + if (lineCount > 0) { + preview << " | "; + } + preview << line; + ++lineCount; + } + + return preview.str(); +} + +std::string ReplaceActiveRecord( + std::string serializedLayout, + std::string_view replacementPanelId) { + const std::size_t activeStart = serializedLayout.find("active "); + if (activeStart == std::string::npos) { + return {}; + } + + const std::size_t lineEnd = serializedLayout.find('\n', activeStart); + std::ostringstream replacement = {}; + replacement << "active " << std::quoted(std::string(replacementPanelId)); + serializedLayout.replace( + activeStart, + lineEnd == std::string::npos ? serializedLayout.size() - activeStart : lineEnd - activeStart, + replacement.str()); + return serializedLayout; +} + +UIColor ResolveCommandStatusColor(UIEditorWorkspaceCommandStatus status) { + switch (status) { + case UIEditorWorkspaceCommandStatus::Changed: + return kSuccess; + case UIEditorWorkspaceCommandStatus::NoOp: + return kWarning; + case UIEditorWorkspaceCommandStatus::Rejected: + return kDanger; + } + + return kTextMuted; +} + +UIColor ResolveLayoutStatusColor(UIEditorWorkspaceLayoutOperationStatus status) { + switch (status) { + case UIEditorWorkspaceLayoutOperationStatus::Changed: + return kSuccess; + case UIEditorWorkspaceLayoutOperationStatus::NoOp: + return kWarning; + case UIEditorWorkspaceLayoutOperationStatus::Rejected: + return kDanger; + } + + return kTextMuted; +} + +class ScenarioApp { +public: + int Run(HINSTANCE hInstance, int nCmdShow) { + if (!Initialize(hInstance, nCmdShow)) { + Shutdown(); + return 1; + } + + MSG message = {}; + while (message.message != WM_QUIT) { + if (PeekMessageW(&message, nullptr, 0U, 0U, PM_REMOVE)) { + TranslateMessage(&message); + DispatchMessageW(&message); + continue; + } + + RenderFrame(); + Sleep(8); + } + + Shutdown(); + return static_cast(message.wParam); + } + +private: + static LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) { + if (message == WM_NCCREATE) { + const auto* createStruct = reinterpret_cast(lParam); + auto* app = reinterpret_cast(createStruct->lpCreateParams); + SetWindowLongPtrW(hwnd, GWLP_USERDATA, reinterpret_cast(app)); + return TRUE; + } + + auto* app = reinterpret_cast(GetWindowLongPtrW(hwnd, GWLP_USERDATA)); + switch (message) { + case WM_SIZE: + if (app != nullptr && wParam != SIZE_MINIMIZED) { + app->OnResize(static_cast(LOWORD(lParam)), static_cast(HIWORD(lParam))); + } + return 0; + case WM_PAINT: + if (app != nullptr) { + PAINTSTRUCT paintStruct = {}; + BeginPaint(hwnd, &paintStruct); + app->RenderFrame(); + EndPaint(hwnd, &paintStruct); + return 0; + } + break; + case WM_LBUTTONUP: + if (app != nullptr) { + app->HandleClick( + static_cast(GET_X_LPARAM(lParam)), + static_cast(GET_Y_LPARAM(lParam))); + return 0; + } + break; + case WM_KEYDOWN: + case WM_SYSKEYDOWN: + if (app != nullptr) { + if (wParam == VK_F12) { + app->m_autoScreenshot.RequestCapture("manual_f12"); + } else { + app->HandleShortcut(static_cast(wParam)); + } + return 0; + } + break; + case WM_ERASEBKGND: + return 1; + case WM_DESTROY: + if (app != nullptr) { + app->m_hwnd = nullptr; + } + PostQuitMessage(0); + return 0; + default: + break; + } + + return DefWindowProcW(hwnd, message, wParam, lParam); + } + + bool Initialize(HINSTANCE hInstance, int nCmdShow) { + m_hInstance = hInstance; + ResetScenario(); + + WNDCLASSEXW windowClass = {}; + windowClass.cbSize = sizeof(windowClass); + windowClass.style = CS_HREDRAW | CS_VREDRAW; + windowClass.lpfnWndProc = &ScenarioApp::WndProc; + windowClass.hInstance = hInstance; + windowClass.hCursor = LoadCursorW(nullptr, IDC_ARROW); + windowClass.lpszClassName = kWindowClassName; + + m_windowClassAtom = RegisterClassExW(&windowClass); + if (m_windowClassAtom == 0) { + return false; + } + + m_hwnd = CreateWindowExW( + 0, + kWindowClassName, + kWindowTitle, + WS_OVERLAPPEDWINDOW | WS_VISIBLE, + CW_USEDEFAULT, + CW_USEDEFAULT, + 1360, + 900, + nullptr, + nullptr, + hInstance, + this); + if (m_hwnd == nullptr) { + return false; + } + + ShowWindow(m_hwnd, nCmdShow); + UpdateWindow(m_hwnd); + + if (!m_renderer.Initialize(m_hwnd)) { + return false; + } + + m_autoScreenshot.Initialize( + (ResolveRepoRootPath() / "tests/UI/Editor/integration/state/layout_persistence/captures") + .lexically_normal()); + return true; + } + + void Shutdown() { + m_autoScreenshot.Shutdown(); + m_renderer.Shutdown(); + + if (m_hwnd != nullptr && IsWindow(m_hwnd)) { + DestroyWindow(m_hwnd); + } + m_hwnd = nullptr; + + if (m_windowClassAtom != 0 && m_hInstance != nullptr) { + UnregisterClassW(kWindowClassName, m_hInstance); + m_windowClassAtom = 0; + } + } + + void ResetScenario() { + m_controller = + BuildDefaultUIEditorWorkspaceController(BuildPanelRegistry(), BuildWorkspace()); + m_savedSnapshot = {}; + m_savedSerializedLayout.clear(); + m_hasSavedLayout = false; + SetCustomResult( + "等待操作", + "Pending", + "先点 `1 Hide Active`，再点 `2 Save Layout`；保存后继续改状态，再用 `4 Load Layout` 检查恢复。"); + } + + void OnResize(UINT width, UINT height) { + if (width == 0 || height == 0) { + return; + } + + m_renderer.Resize(width, height); + } + + void RenderFrame() { + if (m_hwnd == nullptr) { + return; + } + + RECT clientRect = {}; + GetClientRect(m_hwnd, &clientRect); + const float width = static_cast((std::max)(clientRect.right - clientRect.left, 1L)); + const float height = static_cast((std::max)(clientRect.bottom - clientRect.top, 1L)); + + UIDrawData drawData = {}; + BuildDrawData(drawData, width, height); + + const bool framePresented = m_renderer.Render(drawData); + m_autoScreenshot.CaptureIfRequested( + m_renderer, + drawData, + static_cast(width), + static_cast(height), + framePresented); + } + + void HandleClick(float x, float y) { + for (const ButtonState& button : m_buttons) { + if (button.enabled && ContainsPoint(button.rect, x, y)) { + DispatchAction(button.action); + InvalidateRect(m_hwnd, nullptr, FALSE); + return; + } + } + } + + void HandleShortcut(UINT keyCode) { + switch (keyCode) { + case '1': + DispatchAction(ActionId::HideActive); + break; + case '2': + DispatchAction(ActionId::SaveLayout); + break; + case '3': + DispatchAction(ActionId::CloseDocB); + break; + case '4': + DispatchAction(ActionId::LoadLayout); + break; + case '5': + DispatchAction(ActionId::ActivateDetails); + break; + case '6': + DispatchAction(ActionId::LoadInvalid); + break; + case 'R': + DispatchAction(ActionId::Reset); + break; + default: + return; + } + + InvalidateRect(m_hwnd, nullptr, FALSE); + } + + void DispatchAction(ActionId action) { + switch (action) { + case ActionId::HideActive: { + UIEditorWorkspaceCommand command = {}; + command.kind = UIEditorWorkspaceCommandKind::HidePanel; + command.panelId = m_controller.GetWorkspace().activePanelId; + SetCommandResult("Hide Active", m_controller.Dispatch(command)); + return; + } + + case ActionId::SaveLayout: + SaveLayout(); + return; + + case ActionId::CloseDocB: + SetCommandResult( + "Close Doc B", + m_controller.Dispatch({ UIEditorWorkspaceCommandKind::ClosePanel, "doc-b" })); + return; + + case ActionId::LoadLayout: + LoadLayout(); + return; + + case ActionId::ActivateDetails: + SetCommandResult( + "Activate Details", + m_controller.Dispatch({ UIEditorWorkspaceCommandKind::ActivatePanel, "details" })); + return; + + case ActionId::LoadInvalid: + LoadInvalidLayout(); + return; + + case ActionId::Reset: + SetCommandResult( + "Reset", + m_controller.Dispatch({ UIEditorWorkspaceCommandKind::ResetWorkspace, {} })); + return; + } + } + + void SaveLayout() { + const auto validation = m_controller.ValidateState(); + if (!validation.IsValid()) { + SetCustomResult( + "Save Layout", + "Rejected", + "当前 controller 状态非法，不能保存布局：" + validation.message); + return; + } + + const UIEditorWorkspaceLayoutSnapshot snapshot = m_controller.CaptureLayoutSnapshot(); + const std::string serialized = SerializeUIEditorWorkspaceLayoutSnapshot(snapshot); + const bool changed = !m_hasSavedLayout || serialized != m_savedSerializedLayout; + + m_savedSnapshot = snapshot; + m_savedSerializedLayout = serialized; + m_hasSavedLayout = true; + SetCustomResult( + "Save Layout", + changed ? "Saved" : "NoOp", + changed + ? "已更新保存的布局快照。接下来继续改状态，再点 `Load Layout` 检查恢复。" + : "保存内容与当前已保存布局一致。"); + } + + void LoadLayout() { + if (!m_hasSavedLayout) { + SetCustomResult("Load Layout", "Rejected", "当前还没有保存过布局。"); + return; + } + + SetLayoutResult("Load Layout", m_controller.RestoreSerializedLayout(m_savedSerializedLayout)); + } + + void LoadInvalidLayout() { + const auto validation = m_controller.ValidateState(); + if (!validation.IsValid()) { + SetCustomResult( + "Load Invalid", + "Rejected", + "当前 controller 状态非法，无法构造 invalid payload：" + validation.message); + return; + } + + const std::string source = + m_hasSavedLayout + ? m_savedSerializedLayout + : SerializeUIEditorWorkspaceLayoutSnapshot(m_controller.CaptureLayoutSnapshot()); + const std::string invalidSerialized = ReplaceActiveRecord(source, "missing-panel"); + if (invalidSerialized.empty()) { + SetCustomResult("Load Invalid", "Rejected", "构造 invalid payload 失败。"); + return; + } + + SetLayoutResult("Load Invalid", m_controller.RestoreSerializedLayout(invalidSerialized)); + } + + void SetCommandResult( + std::string actionName, + const UIEditorWorkspaceCommandResult& result) { + m_lastActionName = std::move(actionName); + m_lastStatusLabel = std::string(GetUIEditorWorkspaceCommandStatusName(result.status)); + m_lastMessage = result.message; + m_lastStatusColor = ResolveCommandStatusColor(result.status); + } + + void SetLayoutResult( + std::string actionName, + const UIEditorWorkspaceLayoutOperationResult& result) { + m_lastActionName = std::move(actionName); + m_lastStatusLabel = std::string(GetUIEditorWorkspaceLayoutOperationStatusName(result.status)); + m_lastMessage = result.message; + m_lastStatusColor = ResolveLayoutStatusColor(result.status); + } + + void SetCustomResult( + std::string actionName, + std::string statusLabel, + std::string message) { + m_lastActionName = std::move(actionName); + m_lastStatusLabel = std::move(statusLabel); + m_lastMessage = std::move(message); + if (m_lastStatusLabel == "Rejected") { + m_lastStatusColor = kDanger; + } else if (m_lastStatusLabel == "NoOp") { + m_lastStatusColor = kWarning; + } else if (m_lastStatusLabel == "Pending") { + m_lastStatusColor = kTextMuted; + } else { + m_lastStatusColor = kSuccess; + } + } + + bool IsButtonEnabled(ActionId action) const { + const UIEditorWorkspaceModel& workspace = m_controller.GetWorkspace(); + const UIEditorWorkspaceSession& session = m_controller.GetSession(); + + switch (action) { + case ActionId::HideActive: { + if (workspace.activePanelId.empty()) { + return false; + } + const auto* state = FindUIEditorPanelSessionState(session, workspace.activePanelId); + return state != nullptr && state->open && state->visible; + } + + case ActionId::SaveLayout: + return m_controller.ValidateState().IsValid(); + + case ActionId::CloseDocB: { + const auto* state = FindUIEditorPanelSessionState(session, "doc-b"); + return state != nullptr && state->open; + } + + case ActionId::LoadLayout: + return m_hasSavedLayout; + + case ActionId::ActivateDetails: { + const auto* state = FindUIEditorPanelSessionState(session, "details"); + return state != nullptr && + state->open && + state->visible && + workspace.activePanelId != "details"; + } + + case ActionId::LoadInvalid: + return m_controller.ValidateState().IsValid(); + + case ActionId::Reset: + return true; + } + + return false; + } + + void DrawPanelStateRows( + UIDrawList& drawList, + float startX, + float startY, + float width, + const UIEditorWorkspaceSession& session, + std::string_view activePanelId) { + const std::vector> panelDefs = { + { "doc-a", "Document A" }, + { "doc-b", "Document B" }, + { "details", "Details" } + }; + + float rowY = startY; + for (const auto& [panelId, label] : panelDefs) { + const UIRect rowRect(startX, rowY, width, 54.0f); + drawList.AddFilledRect(rowRect, kPanelRowBg, 8.0f); + drawList.AddRectOutline(rowRect, kCardBorder, 1.0f, 8.0f); + drawList.AddFilledRect( + UIRect(rowRect.x + 12.0f, rowRect.y + 15.0f, 10.0f, 10.0f), + ResolvePanelStateColor(session, panelId), + 5.0f); + drawList.AddText( + UIPoint(rowRect.x + 32.0f, rowRect.y + 11.0f), + DescribePanelState(session, panelId, label), + kTextPrimary, + 14.0f); + const bool active = activePanelId == panelId; + drawList.AddText( + UIPoint(rowRect.x + 32.0f, rowRect.y + 31.0f), + active ? "active = true" : "active = false", + active ? kAccent : kTextMuted, + 12.0f); + rowY += 64.0f; + } + } + + void BuildDrawData(UIDrawData& drawData, float width, float height) { + const UIEditorWorkspaceModel& workspace = m_controller.GetWorkspace(); + const UIEditorWorkspaceSession& session = m_controller.GetSession(); + const auto validation = m_controller.ValidateState(); + + UIDrawList& drawList = drawData.EmplaceDrawList("Editor Layout Persistence"); + drawList.AddFilledRect(UIRect(0.0f, 0.0f, width, height), kWindowBg); + + const float margin = 20.0f; + const UIRect headerRect(margin, margin, width - margin * 2.0f, 178.0f); + const UIRect actionRect(margin, headerRect.y + headerRect.height + 16.0f, 320.0f, height - 254.0f); + const UIRect stateRect(actionRect.x + actionRect.width + 16.0f, actionRect.y, width - actionRect.width - margin * 2.0f - 16.0f, height - 254.0f); + const UIRect footerRect(margin, height - 100.0f, width - margin * 2.0f, 80.0f); + + DrawCard(drawList, headerRect, "测试功能：Editor Layout Persistence", "只验证 Save / Load / Load Invalid / Reset 的布局恢复链路；不验证业务面板。"); + drawList.AddText(UIPoint(headerRect.x + 18.0f, headerRect.y + 70.0f), "1. 点 `1 Hide Active`，把 Document A 隐藏；active 应切到 doc-b，visible 应变成 `doc-b, details`。", kTextPrimary, 13.0f); + drawList.AddText(UIPoint(headerRect.x + 18.0f, headerRect.y + 92.0f), "2. 点 `2 Save Layout` 保存当前布局；右侧 Saved 摘要必须记录刚才的 active/visible。", kTextPrimary, 13.0f); + drawList.AddText(UIPoint(headerRect.x + 18.0f, headerRect.y + 114.0f), "3. 再点 `3 Close Doc B` 或 `5 Activate Details` 改状态，然后点 `4 Load Layout`；当前状态必须恢复到保存时。", kTextPrimary, 13.0f); + drawList.AddText(UIPoint(headerRect.x + 18.0f, headerRect.y + 136.0f), "4. 点 `6 Load Invalid`；Result 必须是 Rejected，且当前 active/visible 不得被污染。", kTextPrimary, 13.0f); + drawList.AddText(UIPoint(headerRect.x + 18.0f, headerRect.y + 158.0f), "5. `R Reset` 必须回到基线 active=doc-a；按 `F12` 保存当前窗口截图。", kTextPrimary, 13.0f); + + DrawCard(drawList, actionRect, "操作区", "只保留这一步需要检查的布局保存/恢复动作。"); + DrawCard(drawList, stateRect, "状态摘要", "左侧看 Current，右侧看 Saved；重点检查 active、visible 和坏数据恢复。"); + DrawCard(drawList, footerRect, "最近结果", "显示最近一次操作、状态和当前 validation。"); + + m_buttons.clear(); + const std::vector> buttonDefs = { + { ActionId::HideActive, "1 Hide Active" }, + { ActionId::SaveLayout, "2 Save Layout" }, + { ActionId::CloseDocB, "3 Close Doc B" }, + { ActionId::LoadLayout, "4 Load Layout" }, + { ActionId::ActivateDetails, "5 Activate Details" }, + { ActionId::LoadInvalid, "6 Load Invalid" }, + { ActionId::Reset, "R Reset" } + }; + + float buttonY = actionRect.y + 72.0f; + for (const auto& [action, label] : buttonDefs) { + ButtonState button = {}; + button.action = action; + button.label = label; + button.rect = UIRect(actionRect.x + 18.0f, buttonY, actionRect.width - 36.0f, 46.0f); + button.enabled = IsButtonEnabled(action); + m_buttons.push_back(button); + + drawList.AddFilledRect( + button.rect, + button.enabled ? kButtonEnabled : kButtonDisabled, + 8.0f); + drawList.AddRectOutline(button.rect, kButtonBorder, 1.0f, 8.0f); + drawList.AddText( + UIPoint(button.rect.x + 14.0f, button.rect.y + 13.0f), + button.label, + button.enabled ? kTextPrimary : kTextMuted, + 13.0f); + buttonY += 58.0f; + } + + const float columnGap = 20.0f; + const float contentLeft = stateRect.x + 18.0f; + const float columnWidth = (stateRect.width - 36.0f - columnGap) * 0.5f; + const float rightColumnX = contentLeft + columnWidth + columnGap; + + drawList.AddText(UIPoint(contentLeft, stateRect.y + 70.0f), "Current", kAccent, 15.0f); + drawList.AddText(UIPoint(contentLeft, stateRect.y + 96.0f), "active panel", kTextMuted, 12.0f); + drawList.AddText(UIPoint(contentLeft, stateRect.y + 116.0f), workspace.activePanelId.empty() ? "(none)" : workspace.activePanelId, kTextPrimary, 14.0f); + drawList.AddText(UIPoint(contentLeft, stateRect.y + 148.0f), "visible panels", kTextMuted, 12.0f); + drawList.AddText(UIPoint(contentLeft, stateRect.y + 168.0f), JoinVisiblePanelIds(workspace, session), kTextPrimary, 14.0f); + drawList.AddText( + UIPoint(contentLeft, stateRect.y + 198.0f), + validation.IsValid() ? "validation = OK" : "validation = " + validation.message, + validation.IsValid() ? kSuccess : kDanger, + 12.0f); + DrawPanelStateRows(drawList, contentLeft, stateRect.y + 236.0f, columnWidth, session, workspace.activePanelId); + + drawList.AddText(UIPoint(rightColumnX, stateRect.y + 70.0f), "Saved", kAccent, 15.0f); + if (!m_hasSavedLayout) { + drawList.AddText(UIPoint(rightColumnX, stateRect.y + 104.0f), "尚未执行 Save Layout。", kTextMuted, 13.0f); + drawList.AddText(UIPoint(rightColumnX, stateRect.y + 128.0f), "先把状态改掉，再保存，这样 Load 才有恢复意义。", kTextMuted, 12.0f); + } else { + drawList.AddText(UIPoint(rightColumnX, stateRect.y + 96.0f), "active panel", kTextMuted, 12.0f); + drawList.AddText(UIPoint(rightColumnX, stateRect.y + 116.0f), m_savedSnapshot.workspace.activePanelId.empty() ? "(none)" : m_savedSnapshot.workspace.activePanelId, kTextPrimary, 14.0f); + drawList.AddText(UIPoint(rightColumnX, stateRect.y + 148.0f), "visible panels", kTextMuted, 12.0f); + drawList.AddText( + UIPoint(rightColumnX, stateRect.y + 168.0f), + JoinVisiblePanelIds(m_savedSnapshot.workspace, m_savedSnapshot.session), + kTextPrimary, + 14.0f); + drawList.AddText(UIPoint(rightColumnX, stateRect.y + 198.0f), "payload preview", kTextMuted, 12.0f); + drawList.AddText( + UIPoint(rightColumnX, stateRect.y + 220.0f), + BuildSerializedPreview(m_savedSerializedLayout), + kTextPrimary, + 12.0f); + } + + drawList.AddText( + UIPoint(footerRect.x + 18.0f, footerRect.y + 28.0f), + "Last operation: " + m_lastActionName + " | Result: " + m_lastStatusLabel, + m_lastStatusColor, + 13.0f); + drawList.AddText(UIPoint(footerRect.x + 18.0f, footerRect.y + 48.0f), m_lastMessage, kTextPrimary, 12.0f); + drawList.AddText( + UIPoint(footerRect.x + 18.0f, footerRect.y + 66.0f), + validation.IsValid() ? "Validation: OK" : "Validation: " + validation.message, + validation.IsValid() ? kSuccess : kDanger, + 12.0f); + + const std::string captureSummary = + m_autoScreenshot.HasPendingCapture() + ? "截图排队中..." + : (m_autoScreenshot.GetLastCaptureSummary().empty() + ? std::string("F12 -> tests/UI/Editor/integration/state/layout_persistence/captures/") + : m_autoScreenshot.GetLastCaptureSummary()); + drawList.AddText(UIPoint(footerRect.x + 760.0f, footerRect.y + 66.0f), captureSummary, kTextMuted, 12.0f); + } + + HWND m_hwnd = nullptr; + HINSTANCE m_hInstance = nullptr; + ATOM m_windowClassAtom = 0; + NativeRenderer m_renderer = {}; + AutoScreenshotController m_autoScreenshot = {}; + UIEditorWorkspaceController m_controller = {}; + UIEditorWorkspaceLayoutSnapshot m_savedSnapshot = {}; + std::string m_savedSerializedLayout = {}; + bool m_hasSavedLayout = false; + std::vector m_buttons = {}; + std::string m_lastActionName = {}; + std::string m_lastStatusLabel = {}; + std::string m_lastMessage = {}; + UIColor m_lastStatusColor = kTextMuted; +}; + +} // namespace + +int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE, LPWSTR, int nCmdShow) { + ScenarioApp app; + return app.Run(hInstance, nCmdShow); +} diff --git a/tests/UI/Editor/unit/CMakeLists.txt b/tests/UI/Editor/unit/CMakeLists.txt index a06b8636..98e1631c 100644 --- a/tests/UI/Editor/unit/CMakeLists.txt +++ b/tests/UI/Editor/unit/CMakeLists.txt @@ -6,6 +6,7 @@ set(EDITOR_UI_UNIT_TEST_SOURCES test_ui_editor_collection_primitives.cpp test_ui_editor_panel_chrome.cpp test_ui_editor_workspace_controller.cpp + test_ui_editor_workspace_layout_persistence.cpp test_ui_editor_workspace_model.cpp test_ui_editor_workspace_session.cpp ) diff --git a/tests/UI/Editor/unit/test_ui_editor_workspace_layout_persistence.cpp b/tests/UI/Editor/unit/test_ui_editor_workspace_layout_persistence.cpp new file mode 100644 index 00000000..a3ce3903 --- /dev/null +++ b/tests/UI/Editor/unit/test_ui_editor_workspace_layout_persistence.cpp @@ -0,0 +1,185 @@ +#include + +#include +#include + +#include +#include +#include + +namespace { + +using XCEngine::NewEditor::AreUIEditorWorkspaceLayoutSnapshotsEquivalent; +using XCEngine::NewEditor::BuildDefaultUIEditorWorkspaceController; +using XCEngine::NewEditor::BuildDefaultUIEditorWorkspaceSession; +using XCEngine::NewEditor::BuildUIEditorWorkspaceLayoutSnapshot; +using XCEngine::NewEditor::BuildUIEditorWorkspacePanel; +using XCEngine::NewEditor::BuildUIEditorWorkspaceSplit; +using XCEngine::NewEditor::BuildUIEditorWorkspaceTabStack; +using XCEngine::NewEditor::DeserializeUIEditorWorkspaceLayoutSnapshot; +using XCEngine::NewEditor::SerializeUIEditorWorkspaceLayoutSnapshot; +using XCEngine::NewEditor::TryCloseUIEditorWorkspacePanel; +using XCEngine::NewEditor::TryHideUIEditorWorkspacePanel; +using XCEngine::NewEditor::UIEditorPanelRegistry; +using XCEngine::NewEditor::UIEditorWorkspaceController; +using XCEngine::NewEditor::UIEditorWorkspaceLayoutLoadCode; +using XCEngine::NewEditor::UIEditorWorkspaceLayoutOperationStatus; +using XCEngine::NewEditor::UIEditorWorkspaceCommandKind; +using XCEngine::NewEditor::UIEditorWorkspaceCommandStatus; +using XCEngine::NewEditor::UIEditorWorkspaceModel; +using XCEngine::NewEditor::UIEditorWorkspaceSession; +using XCEngine::NewEditor::UIEditorWorkspaceSplitAxis; + +UIEditorPanelRegistry BuildPanelRegistry() { + UIEditorPanelRegistry registry = {}; + registry.panels = { + { "doc-a", "Document A", {}, true, true, true }, + { "doc-b", "Document B", {}, true, true, true }, + { "details", "Details", {}, true, true, true } + }; + return registry; +} + +UIEditorWorkspaceModel BuildWorkspace() { + UIEditorWorkspaceModel workspace = {}; + workspace.root = BuildUIEditorWorkspaceSplit( + "root-split", + UIEditorWorkspaceSplitAxis::Horizontal, + 0.66f, + BuildUIEditorWorkspaceTabStack( + "document-tabs", + { + BuildUIEditorWorkspacePanel("doc-a-node", "doc-a", "Document A", true), + BuildUIEditorWorkspacePanel("doc-b-node", "doc-b", "Document B", true) + }, + 0u), + BuildUIEditorWorkspacePanel("details-node", "details", "Details", true)); + workspace.activePanelId = "doc-a"; + return workspace; +} + +std::string ReplaceFirst( + std::string source, + std::string_view from, + std::string_view to) { + const std::size_t index = source.find(from); + EXPECT_NE(index, std::string::npos); + if (index == std::string::npos) { + return source; + } + + source.replace(index, from.size(), to); + return source; +} +} // namespace + +TEST(UIEditorWorkspaceLayoutPersistenceTest, SerializeAndDeserializeRoundTripPreservesWorkspaceAndSession) { + const UIEditorPanelRegistry registry = BuildPanelRegistry(); + UIEditorWorkspaceModel workspace = BuildWorkspace(); + UIEditorWorkspaceSession session = + BuildDefaultUIEditorWorkspaceSession(registry, workspace); + + ASSERT_TRUE(TryHideUIEditorWorkspacePanel(registry, workspace, session, "doc-a")); + ASSERT_TRUE(TryCloseUIEditorWorkspacePanel(registry, workspace, session, "doc-b")); + + const auto snapshot = BuildUIEditorWorkspaceLayoutSnapshot(workspace, session); + const std::string serialized = SerializeUIEditorWorkspaceLayoutSnapshot(snapshot); + const auto loadResult = + DeserializeUIEditorWorkspaceLayoutSnapshot(registry, serialized); + + ASSERT_TRUE(loadResult.IsValid()) << loadResult.message; + EXPECT_TRUE( + AreUIEditorWorkspaceLayoutSnapshotsEquivalent(loadResult.snapshot, snapshot)); +} + +TEST(UIEditorWorkspaceLayoutPersistenceTest, DeserializeRejectsInvalidSelectedTabIndex) { + const UIEditorPanelRegistry registry = BuildPanelRegistry(); + const UIEditorWorkspaceModel workspace = BuildWorkspace(); + const UIEditorWorkspaceSession session = + BuildDefaultUIEditorWorkspaceSession(registry, workspace); + + const std::string invalidSerialized = ReplaceFirst( + SerializeUIEditorWorkspaceLayoutSnapshot( + BuildUIEditorWorkspaceLayoutSnapshot(workspace, session)), + "node_tabstack \"document-tabs\" 0 2", + "node_tabstack \"document-tabs\" 5 2"); + + const auto loadResult = + DeserializeUIEditorWorkspaceLayoutSnapshot(registry, invalidSerialized); + + EXPECT_EQ(loadResult.code, UIEditorWorkspaceLayoutLoadCode::InvalidWorkspace); +} + +TEST(UIEditorWorkspaceLayoutPersistenceTest, DeserializeRejectsMissingSessionRecord) { + const UIEditorPanelRegistry registry = BuildPanelRegistry(); + const UIEditorWorkspaceModel workspace = BuildWorkspace(); + const UIEditorWorkspaceSession session = + BuildDefaultUIEditorWorkspaceSession(registry, workspace); + + const std::string invalidSerialized = ReplaceFirst( + SerializeUIEditorWorkspaceLayoutSnapshot( + BuildUIEditorWorkspaceLayoutSnapshot(workspace, session)), + "session \"details\" 1 1\n", + ""); + + const auto loadResult = + DeserializeUIEditorWorkspaceLayoutSnapshot(registry, invalidSerialized); + + EXPECT_EQ(loadResult.code, UIEditorWorkspaceLayoutLoadCode::InvalidWorkspaceSession); +} + +TEST(UIEditorWorkspaceLayoutPersistenceTest, RestoreSerializedLayoutRestoresSavedStateAfterFurtherMutations) { + const UIEditorPanelRegistry registry = BuildPanelRegistry(); + UIEditorWorkspaceController controller = + BuildDefaultUIEditorWorkspaceController(registry, BuildWorkspace()); + + EXPECT_EQ( + controller.Dispatch({ UIEditorWorkspaceCommandKind::HidePanel, "doc-a" }).status, + UIEditorWorkspaceCommandStatus::Changed); + + const std::string savedLayout = + SerializeUIEditorWorkspaceLayoutSnapshot(controller.CaptureLayoutSnapshot()); + + EXPECT_EQ( + controller.Dispatch({ UIEditorWorkspaceCommandKind::ClosePanel, "doc-b" }).status, + UIEditorWorkspaceCommandStatus::Changed); + EXPECT_EQ(controller.GetWorkspace().activePanelId, "details"); + + const auto restoreResult = controller.RestoreSerializedLayout(savedLayout); + EXPECT_EQ(restoreResult.status, UIEditorWorkspaceLayoutOperationStatus::Changed); + EXPECT_EQ(controller.GetWorkspace().activePanelId, "doc-b"); + ASSERT_EQ(restoreResult.visiblePanelIds.size(), 2u); + EXPECT_EQ(restoreResult.visiblePanelIds[0], "doc-b"); + EXPECT_EQ(restoreResult.visiblePanelIds[1], "details"); +} + +TEST(UIEditorWorkspaceLayoutPersistenceTest, RestoreSerializedLayoutRejectsInvalidPayloadWithoutMutatingCurrentState) { + const UIEditorPanelRegistry registry = BuildPanelRegistry(); + UIEditorWorkspaceController controller = + BuildDefaultUIEditorWorkspaceController(registry, BuildWorkspace()); + + EXPECT_EQ( + controller.Dispatch({ UIEditorWorkspaceCommandKind::ActivatePanel, "details" }).status, + UIEditorWorkspaceCommandStatus::Changed); + const auto before = controller.CaptureLayoutSnapshot(); + + const std::string invalidSerialized = ReplaceFirst( + SerializeUIEditorWorkspaceLayoutSnapshot(before), + "active \"details\"", + "active \"missing\""); + + const auto restoreResult = controller.RestoreSerializedLayout(invalidSerialized); + EXPECT_EQ(restoreResult.status, UIEditorWorkspaceLayoutOperationStatus::Rejected); + + const auto after = controller.CaptureLayoutSnapshot(); + EXPECT_TRUE(AreUIEditorWorkspaceLayoutSnapshotsEquivalent(after, before)); +} + +TEST(UIEditorWorkspaceLayoutPersistenceTest, RestoreLayoutSnapshotReturnsNoOpWhenStateAlreadyMatchesSnapshot) { + UIEditorWorkspaceController controller = + BuildDefaultUIEditorWorkspaceController(BuildPanelRegistry(), BuildWorkspace()); + + const auto result = controller.RestoreLayoutSnapshot(controller.CaptureLayoutSnapshot()); + + EXPECT_EQ(result.status, UIEditorWorkspaceLayoutOperationStatus::NoOp); +}