xuanchi/XCEngine
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refine XCEditor docking and DPI rendering

Browse Source
This commit is contained in:
ssdfasd
2026-04-11 17:07:37 +08:00
parent 35d3d6328b
commit 2958dcc491
46 changed files with 4839 additions and 471 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
tests/UI/Editor/integration/CMakeLists.txt
View File

@@ -148,6 +148,11 @@ if(TARGET editor_ui_scroll_view_basic_validation)
editor_ui_scroll_view_basic_validation)
endif()
if(TARGET editor_ui_dock_tab_reorder_same_stack_validation)
list(APPEND EDITOR_UI_INTEGRATION_TARGETS
editor_ui_dock_tab_reorder_same_stack_validation)
endif()
add_custom_target(editor_ui_integration_tests
DEPENDS
${EDITOR_UI_INTEGRATION_TARGETS}

3
tests/UI/Editor/integration/shell/CMakeLists.txt
View File

@@ -13,6 +13,9 @@ endif()
if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/dock_host_basic/CMakeLists.txt")
add_subdirectory(dock_host_basic)
endif()
if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/dock_tab_reorder_same_stack/CMakeLists.txt")
add_subdirectory(dock_tab_reorder_same_stack)
endif()
if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/panel_content_host_basic/CMakeLists.txt")
add_subdirectory(panel_content_host_basic)
endif()

6
tests/UI/Editor/integration/shell/dock_host_basic/main.cpp
View File

@@ -491,7 +491,7 @@ private:
if (action == ActionId::Reset) {
ResetScenario();
m_lastStatus = "Ready";
m_lastMessage = "场景状态已重置。请重新检查 splitter drag / tab close / panel close / active panel sync。";
m_lastMessage = "场景状态已重置。请重新检查 splitter drag / tab activate / panel close / active panel sync。";
m_lastColor = kWarning;
return;
}
@@ -586,11 +586,11 @@ private:
DrawCard(drawList, m_introRect, "这个测试验证什么功能？", "只验证 DockHost 基础交互 contract，不做 editor 业务面板。");
drawList.AddText(UIPoint(m_introRect.x + 16.0f, m_introRect.y + 72.0f), "1. 验证 splitter drag 是否只通过 DockHostInteraction + WorkspaceController 完成。", kTextPrimary, 12.0f);
drawList.AddText(UIPoint(m_introRect.x + 16.0f, m_introRect.y + 94.0f), "2. 验证 unified dock：tab activate / tab close / single-tab body activate。", kTextPrimary, 12.0f);
drawList.AddText(UIPoint(m_introRect.x + 16.0f, m_introRect.y + 94.0f), "2. 验证 unified dock：tab activate / single-tab body activate / panel close。", kTextPrimary, 12.0f);
drawList.AddText(UIPoint(m_introRect.x + 16.0f, m_introRect.y + 116.0f), "3. 验证 active panel、visible panels、split ratio 是否统一收口到 controller。", kTextPrimary, 12.0f);
drawList.AddText(UIPoint(m_introRect.x + 16.0f, m_introRect.y + 138.0f), "4. 验证 pointer capture / release 请求是否通过 contract 明确返回。", kTextPrimary, 12.0f);
drawList.AddText(UIPoint(m_introRect.x + 16.0f, m_introRect.y + 162.0f), "建议操作：先拖中间 splitter，再点 Document A。", kTextWeak, 11.0f);
drawList.AddText(UIPoint(m_introRect.x + 16.0f, m_introRect.y + 180.0f), "然后关闭 Document B，最后点 Details 或 Console 的 X。", kTextWeak, 11.0f);
drawList.AddText(UIPoint(m_introRect.x + 16.0f, m_introRect.y + 180.0f), "然后切换 Document A / B，最后点 Details 或 Console 的 X。", kTextWeak, 11.0f);
DrawCard(drawList, m_controlsRect, "操作", "这里只保留当前场景必要按钮。");
for (const ButtonState& button : m_buttons) {

30
tests/UI/Editor/integration/shell/dock_tab_reorder_same_stack/CMakeLists.txt Normal file
View File

@@ -0,0 +1,30 @@
add_executable(editor_ui_dock_tab_reorder_same_stack_validation WIN32
main.cpp
)
target_include_directories(editor_ui_dock_tab_reorder_same_stack_validation PRIVATE
${XCENGINE_EDITOR_UI_TESTS_EDITOR_ROOT}/include
${XCENGINE_EDITOR_UI_TESTS_EDITOR_ROOT}
${CMAKE_SOURCE_DIR}/engine/include
)
target_compile_definitions(editor_ui_dock_tab_reorder_same_stack_validation PRIVATE
UNICODE
_UNICODE
XCENGINE_EDITOR_UI_TESTS_REPO_ROOT="${XCENGINE_EDITOR_UI_TESTS_REPO_ROOT_PATH}"
)
if(MSVC)
target_compile_options(editor_ui_dock_tab_reorder_same_stack_validation PRIVATE /utf-8 /FS)
set_property(TARGET editor_ui_dock_tab_reorder_same_stack_validation PROPERTY
MSVC_RUNTIME_LIBRARY "MultiThreaded$<$<CONFIG:Debug>:Debug>DLL")
endif()
target_link_libraries(editor_ui_dock_tab_reorder_same_stack_validation PRIVATE
XCUIEditorLib
XCUIEditorHost
)
set_target_properties(editor_ui_dock_tab_reorder_same_stack_validation PROPERTIES
OUTPUT_NAME "XCUIEditorDockTabReorderSameStackValidation"
)

680
tests/UI/Editor/integration/shell/dock_tab_reorder_same_stack/main.cpp Normal file
View File

@@ -0,0 +1,680 @@
#ifndef NOMINMAX
#define NOMINMAX
#endif
#include <XCEditor/Shell/UIEditorDockHost.h>
#include <XCEditor/Shell/UIEditorDockHostInteraction.h>
#include <XCEditor/Shell/UIEditorWorkspaceController.h>
#include <XCEditor/Shell/UIEditorWorkspaceModel.h>
#include "Host/AutoScreenshot.h"
#include "Host/NativeRenderer.h"
#include <XCEngine/Input/InputTypes.h>
#include <XCEngine/UI/DrawData.h>
#include <windows.h>
#include <windowsx.h>
#include <algorithm>
#include <filesystem>
#include <sstream>
#include <string>
#include <string_view>
#include <vector>
#ifndef XCENGINE_EDITOR_UI_TESTS_REPO_ROOT
#define XCENGINE_EDITOR_UI_TESTS_REPO_ROOT "."
#endif
namespace {
using XCEngine::Input::KeyCode;
using XCEngine::UI::UIColor;
using XCEngine::UI::UIDrawData;
using XCEngine::UI::UIDrawList;
using XCEngine::UI::UIInputEvent;
using XCEngine::UI::UIInputEventType;
using XCEngine::UI::UIPoint;
using XCEngine::UI::UIPointerButton;
using XCEngine::UI::UIRect;
using XCEngine::UI::Editor::BuildDefaultUIEditorWorkspaceController;
using XCEngine::UI::Editor::BuildUIEditorWorkspacePanel;
using XCEngine::UI::Editor::BuildUIEditorWorkspaceSingleTabStack;
using XCEngine::UI::Editor::BuildUIEditorWorkspaceSplit;
using XCEngine::UI::Editor::BuildUIEditorWorkspaceTabStack;
using XCEngine::UI::Editor::FindUIEditorWorkspaceNode;
using XCEngine::UI::Editor::Host::AutoScreenshotController;
using XCEngine::UI::Editor::Host::NativeRenderer;
using XCEngine::UI::Editor::UIEditorDockHostInteractionFrame;
using XCEngine::UI::Editor::UIEditorDockHostInteractionResult;
using XCEngine::UI::Editor::UIEditorDockHostInteractionState;
using XCEngine::UI::Editor::UIEditorDockHostTabStripInteractionEntry;
using XCEngine::UI::Editor::UIEditorPanelRegistry;
using XCEngine::UI::Editor::UIEditorWorkspaceController;
using XCEngine::UI::Editor::UIEditorWorkspaceLayoutOperationStatus;
using XCEngine::UI::Editor::UIEditorWorkspaceModel;
using XCEngine::UI::Editor::UIEditorWorkspaceSplitAxis;
using XCEngine::UI::Editor::UpdateUIEditorDockHostInteraction;
using XCEngine::UI::Editor::Widgets::AppendUIEditorDockHostBackground;
using XCEngine::UI::Editor::Widgets::AppendUIEditorDockHostForeground;
using XCEngine::UI::Editor::Widgets::UIEditorDockHostHitTarget;
using XCEngine::UI::Editor::Widgets::UIEditorDockHostHitTargetKind;
using XCEngine::UI::Editor::Widgets::UIEditorDockHostTabStackLayout;
constexpr const wchar_t* kWindowClassName = L"XCUIEditorDockTabReorderSameStackValidation";
constexpr const wchar_t* kWindowTitle = L"XCUI Editor | Dock Tab Reorder Same Stack";
constexpr UIColor kWindowBg(0.10f, 0.10f, 0.10f, 1.0f);
constexpr UIColor kCardBg(0.16f, 0.16f, 0.16f, 1.0f);
constexpr UIColor kCardBorder(0.28f, 0.28f, 0.28f, 1.0f);
constexpr UIColor kPreviewBg(0.12f, 0.12f, 0.12f, 1.0f);
constexpr UIColor kTextPrimary(0.92f, 0.92f, 0.92f, 1.0f);
constexpr UIColor kTextMuted(0.74f, 0.74f, 0.74f, 1.0f);
constexpr UIColor kTextWeak(0.57f, 0.57f, 0.57f, 1.0f);
constexpr UIColor kButtonBg(0.24f, 0.24f, 0.24f, 1.0f);
constexpr UIColor kButtonHover(0.31f, 0.31f, 0.31f, 1.0f);
constexpr UIColor kButtonBorder(0.44f, 0.44f, 0.44f, 1.0f);
constexpr UIColor kOk(0.47f, 0.71f, 0.50f, 1.0f);
constexpr UIColor kWarn(0.85f, 0.68f, 0.36f, 1.0f);
enum class ActionId : unsigned char {
Reset = 0,
Capture
};
struct ButtonState {
ActionId action = ActionId::Reset;
std::string label = {};
UIRect rect = {};
bool hovered = 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();
}
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 FormatBool(bool value) {
return value ? "是" : "否";
}
std::string FormatOptionalIndex(std::size_t index) {
if (index == XCEngine::UI::Editor::Widgets::UIEditorTabStripInvalidIndex) {
return "无";
}
return std::to_string(index);
}
std::string DescribeHitTarget(const UIEditorDockHostHitTarget& target) {
switch (target.kind) {
case UIEditorDockHostHitTargetKind::Tab:
return "标签: " + target.panelId;
case UIEditorDockHostHitTargetKind::TabStripBackground:
return "标签栏空白";
case UIEditorDockHostHitTargetKind::PanelBody:
return "面板主体: " + target.panelId;
case UIEditorDockHostHitTargetKind::SplitterHandle:
return "分割条: " + target.nodeId;
case UIEditorDockHostHitTargetKind::None:
default:
return "无";
}
}
void DrawCard(
UIDrawList& drawList,
const UIRect& rect,
std::string_view title,
std::string_view subtitle = {}) {
drawList.AddFilledRect(rect, kCardBg, 10.0f);
drawList.AddRectOutline(rect, kCardBorder, 1.0f, 10.0f);
drawList.AddText(UIPoint(rect.x + 16.0f, rect.y + 14.0f), std::string(title), kTextPrimary, 17.0f);
if (!subtitle.empty()) {
drawList.AddText(UIPoint(rect.x + 16.0f, rect.y + 38.0f), std::string(subtitle), kTextMuted, 12.0f);
}
}
void DrawButton(UIDrawList& drawList, const ButtonState& button) {
drawList.AddFilledRect(button.rect, button.hovered ? kButtonHover : kButtonBg, 8.0f);
drawList.AddRectOutline(button.rect, kButtonBorder, 1.0f, 8.0f);
drawList.AddText(UIPoint(button.rect.x + 14.0f, button.rect.y + 10.0f), button.label, kTextPrimary, 12.0f);
}
UIEditorPanelRegistry BuildPanelRegistry() {
UIEditorPanelRegistry registry = {};
registry.panels = {
{ "doc-a", "Document A", {}, true, true, true },
{ "doc-b", "Document B", {}, true, true, true },
{ "doc-c", "Document C", {}, true, true, true },
{ "details", "Details", {}, true, true, true }
};
return registry;
}
UIEditorWorkspaceModel BuildWorkspace() {
UIEditorWorkspaceModel workspace = {};
workspace.root = BuildUIEditorWorkspaceSplit(
"root-split",
UIEditorWorkspaceSplitAxis::Horizontal,
0.72f,
BuildUIEditorWorkspaceTabStack(
"document-tabs",
{
BuildUIEditorWorkspacePanel("doc-a-node", "doc-a", "Document A", true),
BuildUIEditorWorkspacePanel("doc-b-node", "doc-b", "Document B", true),
BuildUIEditorWorkspacePanel("doc-c-node", "doc-c", "Document C", true)
},
0u),
BuildUIEditorWorkspaceSingleTabStack("details-node", "details", "Details", true));
workspace.activePanelId = "doc-a";
return workspace;
}
std::string CollectDocumentTabOrder(const UIEditorWorkspaceController& controller) {
const auto* node = FindUIEditorWorkspaceNode(controller.GetWorkspace(), "document-tabs");
if (node == nullptr) {
return "缺失";
}
std::ostringstream stream = {};
for (std::size_t index = 0; index < node->children.size(); ++index) {
if (index > 0u) {
stream << " | ";
}
stream << node->children[index].panel.panelId;
}
return stream.str();
}
const XCEngine::UI::Editor::Widgets::UIEditorDockHostTabStackLayout* FindDocumentTabStackLayout(
const UIEditorDockHostInteractionFrame& frame) {
for (const auto& tabStack : frame.layout.tabStacks) {
if (tabStack.nodeId == "document-tabs") {
return &tabStack;
}
}
return nullptr;
}
const UIEditorDockHostTabStripInteractionEntry* FindDocumentTabStripInteractionEntry(
const UIEditorDockHostInteractionState& state) {
for (const UIEditorDockHostTabStripInteractionEntry& entry : state.tabStripInteractions) {
if (entry.nodeId == "document-tabs") {
return &entry;
}
}
return nullptr;
}
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<int>(message.wParam);
}
private:
static LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) {
if (message == WM_NCCREATE) {
const auto* createStruct = reinterpret_cast<CREATESTRUCTW*>(lParam);
auto* app = reinterpret_cast<ScenarioApp*>(createStruct->lpCreateParams);
SetWindowLongPtrW(hwnd, GWLP_USERDATA, reinterpret_cast<LONG_PTR>(app));
return TRUE;
}
auto* app = reinterpret_cast<ScenarioApp*>(GetWindowLongPtrW(hwnd, GWLP_USERDATA));
switch (message) {
case WM_SIZE:
if (app != nullptr && wParam != SIZE_MINIMIZED) {
app->m_renderer.Resize(static_cast<UINT>(LOWORD(lParam)), static_cast<UINT>(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_MOUSEMOVE:
if (app != nullptr) {
if (!app->m_trackingMouseLeave) {
TRACKMOUSEEVENT trackMouseEvent = {};
trackMouseEvent.cbSize = sizeof(trackMouseEvent);
trackMouseEvent.dwFlags = TME_LEAVE;
trackMouseEvent.hwndTrack = hwnd;
if (TrackMouseEvent(&trackMouseEvent)) {
app->m_trackingMouseLeave = true;
}
}
app->HandleMouseMove(
static_cast<float>(GET_X_LPARAM(lParam)),
static_cast<float>(GET_Y_LPARAM(lParam)));
return 0;
}
break;
case WM_MOUSELEAVE:
if (app != nullptr) {
app->m_trackingMouseLeave = false;
UIInputEvent event = {};
event.type = UIInputEventType::PointerLeave;
app->m_pendingInputEvents.push_back(event);
return 0;
}
break;
case WM_LBUTTONDOWN:
if (app != nullptr) {
SetFocus(hwnd);
app->HandleLeftButtonDown(
static_cast<float>(GET_X_LPARAM(lParam)),
static_cast<float>(GET_Y_LPARAM(lParam)));
return 0;
}
break;
case WM_LBUTTONUP:
if (app != nullptr) {
app->HandleLeftButtonUp(
static_cast<float>(GET_X_LPARAM(lParam)),
static_cast<float>(GET_Y_LPARAM(lParam)));
return 0;
}
break;
case WM_SETFOCUS:
if (app != nullptr) {
UIInputEvent event = {};
event.type = UIInputEventType::FocusGained;
app->m_pendingInputEvents.push_back(event);
return 0;
}
break;
case WM_KILLFOCUS:
if (app != nullptr) {
UIInputEvent event = {};
event.type = UIInputEventType::FocusLost;
app->m_pendingInputEvents.push_back(event);
app->m_lastInputCause = "focus_lost";
return 0;
}
break;
case WM_CAPTURECHANGED:
if (app != nullptr &&
!app->m_interactionState.activeTabDragNodeId.empty() &&
reinterpret_cast<HWND>(lParam) != hwnd) {
UIInputEvent event = {};
event.type = UIInputEventType::FocusLost;
app->m_pendingInputEvents.push_back(event);
app->m_lastInputCause = "focus_lost";
return 0;
}
break;
case WM_KEYDOWN:
case WM_SYSKEYDOWN:
if (app != nullptr) {
if (wParam == VK_F12) {
app->m_autoScreenshot.RequestCapture("manual_f12");
return 0;
}
UIInputEvent event = {};
event.type = UIInputEventType::KeyDown;
event.keyCode = static_cast<std::int32_t>(wParam == VK_ESCAPE ? KeyCode::Escape : KeyCode::None);
app->m_pendingInputEvents.push_back(event);
return 0;
}
break;
case WM_ERASEBKGND:
return 1;
case WM_DESTROY:
PostQuitMessage(0);
return 0;
default:
break;
}
return DefWindowProcW(hwnd, message, wParam, lParam);
}
bool Initialize(HINSTANCE hInstance, int nCmdShow) {
m_captureRoot =
ResolveRepoRootPath() / "tests/UI/Editor/integration/shell/dock_tab_reorder_same_stack/captures";
m_autoScreenshot.Initialize(m_captureRoot);
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,
1500,
920,
nullptr,
nullptr,
hInstance,
this);
if (m_hwnd == nullptr) {
return false;
}
ShowWindow(m_hwnd, nCmdShow);
if (!m_renderer.Initialize(m_hwnd)) {
return false;
}
ResetScenario();
return true;
}
void Shutdown() {
if (GetCapture() == m_hwnd) {
ReleaseCapture();
}
m_autoScreenshot.Shutdown();
m_renderer.Shutdown();
if (m_hwnd != nullptr && IsWindow(m_hwnd)) {
DestroyWindow(m_hwnd);
}
if (m_windowClassAtom != 0) {
UnregisterClassW(kWindowClassName, GetModuleHandleW(nullptr));
}
}
void ResetScenario() {
if (GetCapture() == m_hwnd) {
ReleaseCapture();
}
m_controller = BuildDefaultUIEditorWorkspaceController(BuildPanelRegistry(), BuildWorkspace());
m_interactionState = {};
m_cachedFrame = {};
m_pendingInputEvents.clear();
m_lastInputCause.clear();
m_hoverText = "无";
m_lastResult = "等待验证：请在同一标签栏内拖拽标签。";
m_lastResultColor = kWarn;
}
void UpdateLayout() {
RECT clientRect = {};
GetClientRect(m_hwnd, &clientRect);
const float width = static_cast<float>((std::max)(clientRect.right - clientRect.left, 1L));
const float height = static_cast<float>((std::max)(clientRect.bottom - clientRect.top, 1L));
constexpr float padding = 20.0f;
constexpr float sidebarWidth = 360.0f;
m_introRect = UIRect(padding, padding, width - padding * 2.0f, 168.0f);
m_previewRect = UIRect(
padding,
m_introRect.y + m_introRect.height + 16.0f,
width - sidebarWidth - padding * 3.0f,
height - m_introRect.height - padding * 3.0f);
m_stateRect = UIRect(
m_previewRect.x + m_previewRect.width + 20.0f,
m_previewRect.y,
sidebarWidth,
m_previewRect.height);
m_dockHostRect = UIRect(
m_previewRect.x + 16.0f,
m_previewRect.y + 64.0f,
m_previewRect.width - 32.0f,
m_previewRect.height - 80.0f);
const float buttonWidth = (m_stateRect.width - 44.0f) * 0.5f;
const float buttonY = m_stateRect.y + m_stateRect.height - 52.0f;
m_buttons = {
{ ActionId::Reset, "重置", UIRect(m_stateRect.x + 16.0f, buttonY, buttonWidth, 36.0f), false },
{ ActionId::Capture, "截图(F12)", UIRect(m_stateRect.x + 28.0f + buttonWidth, buttonY, buttonWidth, 36.0f), false }
};
}
void HandleMouseMove(float x, float y) {
UpdateLayout();
for (ButtonState& button : m_buttons) {
button.hovered = ContainsPoint(button.rect, x, y);
}
UIInputEvent event = {};
event.type = UIInputEventType::PointerMove;
event.position = UIPoint(x, y);
m_pendingInputEvents.push_back(event);
}
void HandleLeftButtonDown(float x, float y) {
UpdateLayout();
for (const ButtonState& button : m_buttons) {
if (ContainsPoint(button.rect, x, y)) {
ExecuteAction(button.action);
return;
}
}
UIInputEvent event = {};
event.type = UIInputEventType::PointerButtonDown;
event.position = UIPoint(x, y);
event.pointerButton = UIPointerButton::Left;
m_pendingInputEvents.push_back(event);
}
void HandleLeftButtonUp(float x, float y) {
UIInputEvent event = {};
event.type = UIInputEventType::PointerButtonUp;
event.position = UIPoint(x, y);
event.pointerButton = UIPointerButton::Left;
m_pendingInputEvents.push_back(event);
}
void ExecuteAction(ActionId action) {
if (action == ActionId::Reset) {
ResetScenario();
m_lastResult = "已重置：请重新检查提交、取消和失焦取消。";
m_lastResultColor = kWarn;
return;
}
m_autoScreenshot.RequestCapture("manual_button");
m_lastResult = "截图已排队：输出到 captures/。";
m_lastResultColor = kWarn;
}
void ApplyHostCaptureRequests(const UIEditorDockHostInteractionResult& result) {
if (result.requestPointerCapture && GetCapture() != m_hwnd) {
SetCapture(m_hwnd);
}
if (result.releasePointerCapture && GetCapture() == m_hwnd) {
ReleaseCapture();
}
}
void UpdateLastResult(const UIEditorDockHostInteractionResult& result) {
if (result.layoutResult.status == UIEditorWorkspaceLayoutOperationStatus::Changed) {
m_lastResult = "结果：同一标签栏内的标签重排已提交。";
m_lastResultColor = kOk;
return;
}
if (result.requestPointerCapture) {
m_lastResult = "结果：开始拖拽，宿主已拿到 pointer capture。";
m_lastResultColor = kOk;
return;
}
if (result.releasePointerCapture && !result.layoutChanged && !result.commandExecuted) {
if (m_lastInputCause == "focus_lost") {
m_lastResult = "结果：窗口失焦，本次重排已取消。";
} else {
m_lastResult = "结果：拖拽已取消。拖到 body 区再松开时，标签顺序应保持不变。";
}
m_lastResultColor = kWarn;
return;
}
}
void RenderFrame() {
UpdateLayout();
m_cachedFrame = UpdateUIEditorDockHostInteraction(
m_interactionState,
m_controller,
m_dockHostRect,
m_pendingInputEvents);
m_pendingInputEvents.clear();
ApplyHostCaptureRequests(m_cachedFrame.result);
UpdateLastResult(m_cachedFrame.result);
m_lastInputCause.clear();
RECT clientRect = {};
GetClientRect(m_hwnd, &clientRect);
const float width = static_cast<float>((std::max)(clientRect.right - clientRect.left, 1L));
const float height = static_cast<float>((std::max)(clientRect.bottom - clientRect.top, 1L));
UIDrawData drawData = {};
UIDrawList& drawList = drawData.EmplaceDrawList("DockTabReorderSameStack");
drawList.AddFilledRect(UIRect(0.0f, 0.0f, width, height), kWindowBg);
DrawCard(drawList, m_introRect, "这个测试验证什么功能？", "只验证同一标签栏内 tab 重排的基础 contract，不做 editor 业务。");
drawList.AddText(UIPoint(m_introRect.x + 16.0f, m_introRect.y + 70.0f), "1. 拖动 Document A / B / C 的 tab header 到同一行其他位置。", kTextPrimary, 12.0f);
drawList.AddText(UIPoint(m_introRect.x + 16.0f, m_introRect.y + 92.0f), "2. 在 header 区松开：应提交重排，并更新右侧标签顺序。", kTextPrimary, 12.0f);
drawList.AddText(UIPoint(m_introRect.x + 16.0f, m_introRect.y + 114.0f), "3. 拖到 body 区再松开：应取消，本次标签顺序不能变化。", kTextPrimary, 12.0f);
drawList.AddText(UIPoint(m_introRect.x + 16.0f, m_introRect.y + 136.0f), "4. 拖拽中切走窗口或按 Esc：应释放 capture，并取消这次重排。", kTextWeak, 11.0f);
DrawCard(drawList, m_previewRect, "预览区", "这里只保留同栏重排所需的最小工作区。");
drawList.AddFilledRect(m_dockHostRect, kPreviewBg, 8.0f);
AppendUIEditorDockHostBackground(drawList, m_cachedFrame.layout);
AppendUIEditorDockHostForeground(drawList, m_cachedFrame.layout);
DrawCard(drawList, m_stateRect, "状态", "拖拽时重点观察右侧状态是否和画面一致。");
float y = m_stateRect.y + 68.0f;
auto addLine = [&](std::string text, const UIColor& color = kTextPrimary, float fontSize = 12.0f) mutable {
drawList.AddText(UIPoint(m_stateRect.x + 16.0f, y), std::move(text), color, fontSize);
y += 22.0f;
};
const auto* documentTabStack = FindDocumentTabStackLayout(m_cachedFrame);
const bool previewVisible =
documentTabStack != nullptr &&
documentTabStack->tabStripLayout.insertionPreview.visible;
const std::size_t previewInsertionIndex =
documentTabStack != nullptr
? documentTabStack->tabStripLayout.insertionPreview.insertionIndex
: XCEngine::UI::Editor::Widgets::UIEditorTabStripInvalidIndex;
addLine("当前标签顺序: " + CollectDocumentTabOrder(m_controller), kTextPrimary, 11.0f);
addLine("活动面板: " + m_controller.GetWorkspace().activePanelId, kTextPrimary, 11.0f);
addLine("已聚焦: " + FormatBool(m_cachedFrame.focused), m_cachedFrame.focused ? kOk : kTextMuted, 11.0f);
addLine("宿主捕获: " + FormatBool(GetCapture() == m_hwnd), GetCapture() == m_hwnd ? kOk : kTextMuted, 11.0f);
addLine(
"拖拽标签栈: " +
(m_interactionState.activeTabDragNodeId.empty()
? std::string("无")
: m_interactionState.activeTabDragNodeId),
kTextWeak,
11.0f);
addLine("预览插入位激活: " + FormatBool(previewVisible), previewVisible ? kOk : kTextWeak, 11.0f);
addLine("预览插入索引: " + FormatOptionalIndex(previewInsertionIndex), kTextWeak, 11.0f);
addLine("当前 Hover: " + m_hoverText, kTextWeak, 11.0f);
drawList.AddText(
UIPoint(m_stateRect.x + 16.0f, y + 8.0f),
"最近结果",
kTextPrimary,
13.0f);
drawList.AddText(
UIPoint(m_stateRect.x + 16.0f, y + 32.0f),
m_lastResult,
m_lastResultColor,
12.0f);
const std::string captureSummary =
m_autoScreenshot.HasPendingCapture()
? "截图排队中..."
: (m_autoScreenshot.GetLastCaptureSummary().empty()
? "F12 或按钮 -> captures/"
: m_autoScreenshot.GetLastCaptureSummary());
drawList.AddText(
UIPoint(m_stateRect.x + 16.0f, m_stateRect.y + m_stateRect.height - 86.0f),
captureSummary,
kTextWeak,
11.0f);
for (const ButtonState& button : m_buttons) {
DrawButton(drawList, button);
}
const bool framePresented = m_renderer.Render(drawData);
m_autoScreenshot.CaptureIfRequested(
m_renderer,
drawData,
static_cast<unsigned int>(width),
static_cast<unsigned int>(height),
framePresented);
}
HWND m_hwnd = nullptr;
ATOM m_windowClassAtom = 0;
NativeRenderer m_renderer = {};
AutoScreenshotController m_autoScreenshot = {};
std::filesystem::path m_captureRoot = {};
UIEditorWorkspaceController m_controller = {};
UIEditorDockHostInteractionState m_interactionState = {};
UIEditorDockHostInteractionFrame m_cachedFrame = {};
std::vector<UIInputEvent> m_pendingInputEvents = {};
std::vector<ButtonState> m_buttons = {};
UIRect m_introRect = {};
UIRect m_previewRect = {};
UIRect m_stateRect = {};
UIRect m_dockHostRect = {};
bool m_trackingMouseLeave = false;
std::string m_lastInputCause = {};
std::string m_hoverText = {};
std::string m_lastResult = {};
UIColor m_lastResultColor = kTextMuted;
};
} // namespace
int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE, LPWSTR, int nCmdShow) {
return ScenarioApp().Run(hInstance, nCmdShow);
}

23
tests/UI/Editor/integration/shell/tab_strip_basic/main.cpp
View File

@@ -196,11 +196,6 @@ std::string DescribeHitTarget(
return "Tab: " + items[target.index].title;
}
return "Tab";
case UIEditorTabStripHitTargetKind::CloseButton:
if (target.index < items.size()) {
return "CloseButton: " + items[target.index].title;
}
return "CloseButton";
case UIEditorTabStripHitTargetKind::None:
default:
return "None";
@@ -218,9 +213,6 @@ std::string JoinTabTitles(const std::vector<UIEditorTabStripItem>& items) {
stream << " | ";
}
stream << items[index].title;
if (!items[index].closable) {
stream << " (locked)";
}
}
return stream.str();
}
@@ -502,15 +494,6 @@ private:
void ApplyInteractionResult(
const UIEditorTabStripInteractionResult& result,
std::string_view source) {
if (result.closeRequested && !result.closedTabId.empty()) {
DispatchCommand(
UIEditorWorkspaceCommandKind::ClosePanel,
result.closedTabId,
std::string(source) + " Close -> " + result.closedTabId);
PumpTabStripEvents({});
return;
}
if ((result.selectionChanged || result.keyboardNavigated) &&
!result.selectedTabId.empty()) {
DispatchCommand(
@@ -609,7 +592,7 @@ private:
drawList,
introRect,
"这个测试验证什么功能？",
"验证 TabStrip 的 header 命中、选中切换、关闭请求和键盘导航，不接业务面板。");
"验证 TabStrip 的 header 命中、选中切换和键盘导航，不接业务面板。");
drawList.AddText(
UIPoint(introRect.x + 16.0f, introRect.y + 68.0f),
"1. 点击 tab，检查 selected / active panel 是否同步。",
@@ -617,7 +600,7 @@ private:
12.0f);
drawList.AddText(
UIPoint(introRect.x + 16.0f, introRect.y + 92.0f),
"2. 点击 X，只验证关闭请求；Document C 没有关闭按钮。",
"2. 所有 tab 都没有关闭按钮；这里只验证命中、focus 和选中同步。",
kTextMuted,
12.0f);
drawList.AddText(
@@ -719,7 +702,7 @@ private:
12.0f);
drawList.AddText(
UIPoint(m_layout.contentRect.x + 20.0f, m_layout.contentRect.y + 100.0f),
"可点击 Document B 切换，或点击 Document C 验证不可关闭 tab。",
"可点击 Document B 切换，再用 Left / Right / Home / End 验证键盘导航。",
kTextWeak,
12.0f);

2
tests/UI/Editor/integration/shell/workspace_shell_compose/main.cpp
View File

@@ -606,7 +606,7 @@ private:
12.0f);
drawList.AddText(
UIPoint(m_introRect.x + 16.0f, m_introRect.y + 92.0f),
"2. tab 激活/关闭、panel 激活/关闭都必须统一回到 controller。",
"2. tab 激活、panel 激活/关闭都必须统一回到 controller。",
kTextPrimary,
12.0f);
drawList.AddText(

22
tests/UI/Editor/unit/test_ui_editor_dock_host.cpp
View File

@@ -98,8 +98,8 @@ TEST(UIEditorDockHostTest, LayoutComposesOnlyUnifiedTabStacksFromWorkspaceTree)
const auto* rootSplitter = FindUIEditorDockHostSplitterLayout(layout, "root-split");
ASSERT_NE(rootSplitter, nullptr);
EXPECT_FLOAT_EQ(rootSplitter->splitterLayout.handleRect.x, 395.0f);
EXPECT_FLOAT_EQ(rootSplitter->splitterLayout.handleRect.width, 10.0f);
EXPECT_FLOAT_EQ(rootSplitter->splitterLayout.handleRect.x, 399.5f);
EXPECT_FLOAT_EQ(rootSplitter->splitterLayout.handleRect.width, 1.0f);
const auto& tabStack = layout.tabStacks.front();
EXPECT_EQ(tabStack.nodeId, "document-tabs");
@@ -138,7 +138,7 @@ TEST(UIEditorDockHostTest, HiddenBranchCollapsesAndVisibleBranchUsesFullBounds)
EXPECT_FLOAT_EQ(layout.tabStacks.front().bounds.height, 480.0f);
}
TEST(UIEditorDockHostTest, HitTestPrioritizesSplitterThenTabCloseThenPanelBody) {
TEST(UIEditorDockHostTest, HitTestPrioritizesSplitterThenTabThenPanelBody) {
const UIEditorPanelRegistry registry = BuildPanelRegistry();
const UIEditorWorkspaceModel workspace = BuildWorkspace();
const UIEditorWorkspaceSession session =
@@ -160,14 +160,14 @@ TEST(UIEditorDockHostTest, HitTestPrioritizesSplitterThenTabCloseThenPanelBody)
EXPECT_EQ(splitterHit.nodeId, "root-split");
ASSERT_EQ(layout.tabStacks.size(), 3u);
const auto& closeRect = layout.tabStacks.front().tabStripLayout.closeButtonRects[1];
const auto tabCloseHit = HitTestUIEditorDockHost(
const auto& tabRect = layout.tabStacks.front().tabStripLayout.tabHeaderRects[1];
const auto tabHit = HitTestUIEditorDockHost(
layout,
UIPoint(closeRect.x + closeRect.width * 0.5f, closeRect.y + closeRect.height * 0.5f));
EXPECT_EQ(tabCloseHit.kind, UIEditorDockHostHitTargetKind::TabCloseButton);
EXPECT_EQ(tabCloseHit.nodeId, "document-tabs");
EXPECT_EQ(tabCloseHit.panelId, "doc-b");
EXPECT_EQ(tabCloseHit.index, 1u);
UIPoint(tabRect.x + tabRect.width - 6.0f, tabRect.y + tabRect.height * 0.5f));
EXPECT_EQ(tabHit.kind, UIEditorDockHostHitTargetKind::Tab);
EXPECT_EQ(tabHit.nodeId, "document-tabs");
EXPECT_EQ(tabHit.panelId, "doc-b");
EXPECT_EQ(tabHit.index, 1u);
const auto panelBodyHit = HitTestUIEditorDockHost(
layout,
@@ -186,7 +186,7 @@ TEST(UIEditorDockHostTest, BackgroundAndForegroundEmitStableCompositeCommands) {
UIEditorDockHostState state = {};
state.focused = true;
state.hoveredTarget = UIEditorDockHostHitTarget{
UIEditorDockHostHitTargetKind::TabCloseButton,
UIEditorDockHostHitTargetKind::Tab,
"document-tabs",
"doc-b",
1u

503
tests/UI/Editor/unit/test_ui_editor_dock_host_interaction.cpp
View File

@@ -5,6 +5,9 @@
#include <XCEditor/Shell/UIEditorWorkspaceController.h>
#include <XCEditor/Shell/UIEditorWorkspaceModel.h>
#include <algorithm>
#include <string>
namespace {
using XCEngine::UI::UIInputEvent;
@@ -19,6 +22,7 @@ using XCEngine::UI::Editor::BuildUIEditorWorkspaceSingleTabStack;
using XCEngine::UI::Editor::BuildUIEditorWorkspaceSplit;
using XCEngine::UI::Editor::BuildUIEditorWorkspaceTabStack;
using XCEngine::UI::Editor::FindUIEditorPanelSessionState;
using XCEngine::UI::Editor::FindUIEditorWorkspaceNode;
using XCEngine::UI::Editor::UIEditorDockHostInteractionState;
using XCEngine::UI::Editor::UIEditorPanelRegistry;
using XCEngine::UI::Editor::UIEditorWorkspaceModel;
@@ -33,6 +37,7 @@ UIEditorPanelRegistry BuildPanelRegistry() {
registry.panels = {
{ "doc-a", "Document A", {}, true, true, true },
{ "doc-b", "Document B", {}, true, true, true },
{ "doc-c", "Document C", {}, true, true, true },
{ "details", "Details", {}, true, true, true },
{ "console", "Console", {}, true, true, true }
};
@@ -62,6 +67,30 @@ UIEditorWorkspaceModel BuildWorkspace() {
return workspace;
}
UIEditorWorkspaceModel BuildThreeDocumentWorkspace() {
UIEditorWorkspaceModel workspace = {};
workspace.root = BuildUIEditorWorkspaceSplit(
"root-split",
UIEditorWorkspaceSplitAxis::Horizontal,
0.5f,
BuildUIEditorWorkspaceTabStack(
"document-tabs",
{
BuildUIEditorWorkspacePanel("doc-a-node", "doc-a", "Document A", true),
BuildUIEditorWorkspacePanel("doc-b-node", "doc-b", "Document B", true),
BuildUIEditorWorkspacePanel("doc-c-node", "doc-c", "Document C", true)
},
2u),
BuildUIEditorWorkspaceSplit(
"right-split",
UIEditorWorkspaceSplitAxis::Vertical,
0.6f,
BuildUIEditorWorkspaceSingleTabStack("details-node", "details", "Details", true),
BuildUIEditorWorkspaceSingleTabStack("console-node", "console", "Console", true)));
workspace.activePanelId = "doc-c";
return workspace;
}
UIInputEvent MakePointerMove(float x, float y) {
UIInputEvent event = {};
event.type = UIInputEventType::PointerMove;
@@ -230,60 +259,6 @@ TEST(UIEditorDockHostInteractionTest, ClickingTabActivatesTargetPanel) {
EXPECT_EQ(documentStack->selectedPanelId, "doc-a");
}
TEST(UIEditorDockHostInteractionTest, ClickingTabCloseClosesPanelThroughController) {
auto controller =
BuildDefaultUIEditorWorkspaceController(BuildPanelRegistry(), BuildWorkspace());
UIEditorDockHostInteractionState state = {};
auto frame = UpdateUIEditorDockHostInteraction(
state,
controller,
UIRect(0.0f, 0.0f, 800.0f, 600.0f),
{});
const auto* documentStack = FindTabStackByNodeId(frame.layout, "document-tabs");
ASSERT_NE(documentStack, nullptr);
const UIRect closeRect = documentStack->tabStripLayout.closeButtonRects[1];
const UIPoint closeCenter = RectCenter(closeRect);
frame = UpdateUIEditorDockHostInteraction(
state,
controller,
UIRect(0.0f, 0.0f, 800.0f, 600.0f),
{ MakePointerMove(closeCenter.x, closeCenter.y) });
EXPECT_EQ(frame.result.hitTarget.kind, UIEditorDockHostHitTargetKind::TabCloseButton);
EXPECT_EQ(frame.result.hitTarget.panelId, "doc-b");
frame = UpdateUIEditorDockHostInteraction(
state,
controller,
UIRect(0.0f, 0.0f, 800.0f, 600.0f),
{ MakePointerDown(closeCenter.x, closeCenter.y) });
EXPECT_TRUE(frame.result.consumed);
EXPECT_FALSE(frame.result.commandExecuted);
frame = UpdateUIEditorDockHostInteraction(
state,
controller,
UIRect(0.0f, 0.0f, 800.0f, 600.0f),
{ MakePointerDown(closeCenter.x, closeCenter.y) });
EXPECT_TRUE(frame.result.consumed);
EXPECT_FALSE(frame.result.commandExecuted);
frame = UpdateUIEditorDockHostInteraction(
state,
controller,
UIRect(0.0f, 0.0f, 800.0f, 600.0f),
{ MakePointerUp(closeCenter.x, closeCenter.y) });
EXPECT_TRUE(frame.result.consumed);
EXPECT_TRUE(frame.result.commandExecuted);
const auto* panelState = FindUIEditorPanelSessionState(controller.GetSession(), "doc-b");
ASSERT_NE(panelState, nullptr);
EXPECT_FALSE(panelState->open);
EXPECT_FALSE(panelState->visible);
EXPECT_EQ(controller.GetWorkspace().activePanelId, "doc-a");
}
TEST(UIEditorDockHostInteractionTest, FocusedTabStripHandlesKeyboardNavigationThroughTabStripInteraction) {
auto controller =
BuildDefaultUIEditorWorkspaceController(BuildPanelRegistry(), BuildWorkspace());
@@ -399,7 +374,7 @@ TEST(UIEditorDockHostInteractionTest, ClickingSingleTabStackBodyActivatesTargetP
EXPECT_EQ(controller.GetWorkspace().activePanelId, "details");
}
TEST(UIEditorDockHostInteractionTest, ClickingSingleTabStackTabCloseClosesPanelThroughController) {
TEST(UIEditorDockHostInteractionTest, DraggingTabWithinSameStackRequestsCaptureAndCommitsReorder) {
auto controller =
BuildDefaultUIEditorWorkspaceController(BuildPanelRegistry(), BuildWorkspace());
UIEditorDockHostInteractionState state = {};
@@ -409,29 +384,411 @@ TEST(UIEditorDockHostInteractionTest, ClickingSingleTabStackTabCloseClosesPanelT
controller,
UIRect(0.0f, 0.0f, 800.0f, 600.0f),
{});
const auto* consoleStack = FindTabStackByNodeId(frame.layout, "console-node");
ASSERT_NE(consoleStack, nullptr);
const UIRect closeRect = consoleStack->tabStripLayout.closeButtonRects[0];
const UIPoint closeCenter = RectCenter(closeRect);
const auto* documentStack = FindTabStackByNodeId(frame.layout, "document-tabs");
ASSERT_NE(documentStack, nullptr);
const UIPoint sourceCenter = RectCenter(documentStack->tabStripLayout.tabHeaderRects[0]);
const UIPoint dropPoint(
documentStack->tabStripLayout.headerRect.x +
documentStack->tabStripLayout.headerRect.width - 2.0f,
sourceCenter.y);
frame = UpdateUIEditorDockHostInteraction(
state,
controller,
UIRect(0.0f, 0.0f, 800.0f, 600.0f),
{ MakePointerMove(closeCenter.x, closeCenter.y) });
EXPECT_EQ(frame.result.hitTarget.kind, UIEditorDockHostHitTargetKind::TabCloseButton);
EXPECT_EQ(frame.result.hitTarget.panelId, "console");
frame = UpdateUIEditorDockHostInteraction(
state,
controller,
UIRect(0.0f, 0.0f, 800.0f, 600.0f),
{ MakePointerUp(closeCenter.x, closeCenter.y) });
{ MakePointerDown(sourceCenter.x, sourceCenter.y) });
EXPECT_TRUE(frame.result.consumed);
EXPECT_TRUE(frame.result.commandExecuted);
const auto* panelState = FindUIEditorPanelSessionState(controller.GetSession(), "console");
ASSERT_NE(panelState, nullptr);
EXPECT_FALSE(panelState->open);
EXPECT_FALSE(panelState->visible);
frame = UpdateUIEditorDockHostInteraction(
state,
controller,
UIRect(0.0f, 0.0f, 800.0f, 600.0f),
{ MakePointerMove(dropPoint.x, dropPoint.y) });
EXPECT_TRUE(frame.result.requestPointerCapture);
EXPECT_TRUE(frame.result.consumed);
frame = UpdateUIEditorDockHostInteraction(
state,
controller,
UIRect(0.0f, 0.0f, 800.0f, 600.0f),
{ MakePointerUp(dropPoint.x, dropPoint.y) });
EXPECT_TRUE(frame.result.releasePointerCapture);
EXPECT_TRUE(frame.result.layoutChanged)
<< " status=" << static_cast<int>(frame.result.layoutResult.status)
<< " message=" << frame.result.layoutResult.message
<< " commandExecuted=" << frame.result.commandExecuted;
const auto* documentTabs =
FindUIEditorWorkspaceNode(controller.GetWorkspace(), "document-tabs");
ASSERT_NE(documentTabs, nullptr);
ASSERT_EQ(documentTabs->children.size(), 2u);
EXPECT_EQ(documentTabs->children[0].panel.panelId, "doc-b");
EXPECT_EQ(documentTabs->children[1].panel.panelId, "doc-a");
}
TEST(UIEditorDockHostInteractionTest, DraggingRightmostTabIntoMiddleCommitsSameStackReorder) {
auto controller =
BuildDefaultUIEditorWorkspaceController(BuildPanelRegistry(), BuildThreeDocumentWorkspace());
UIEditorDockHostInteractionState state = {};
auto frame = UpdateUIEditorDockHostInteraction(
state,
controller,
UIRect(0.0f, 0.0f, 800.0f, 600.0f),
{});
const auto* documentStack = FindTabStackByNodeId(frame.layout, "document-tabs");
ASSERT_NE(documentStack, nullptr);
const UIPoint sourceCenter = RectCenter(documentStack->tabStripLayout.tabHeaderRects[2]);
const UIPoint dropPoint(
documentStack->tabStripLayout.tabHeaderRects[1].x + 4.0f,
sourceCenter.y);
frame = UpdateUIEditorDockHostInteraction(
state,
controller,
UIRect(0.0f, 0.0f, 800.0f, 600.0f),
{ MakePointerDown(sourceCenter.x, sourceCenter.y) });
EXPECT_TRUE(frame.result.consumed);
frame = UpdateUIEditorDockHostInteraction(
state,
controller,
UIRect(0.0f, 0.0f, 800.0f, 600.0f),
{ MakePointerMove(dropPoint.x, dropPoint.y) });
EXPECT_TRUE(frame.result.requestPointerCapture);
EXPECT_TRUE(frame.result.consumed);
frame = UpdateUIEditorDockHostInteraction(
state,
controller,
UIRect(0.0f, 0.0f, 800.0f, 600.0f),
{ MakePointerUp(dropPoint.x, dropPoint.y) });
EXPECT_TRUE(frame.result.releasePointerCapture);
EXPECT_TRUE(frame.result.layoutChanged)
<< " status=" << static_cast<int>(frame.result.layoutResult.status)
<< " message=" << frame.result.layoutResult.message
<< " commandExecuted=" << frame.result.commandExecuted;
const auto* documentTabs =
FindUIEditorWorkspaceNode(controller.GetWorkspace(), "document-tabs");
ASSERT_NE(documentTabs, nullptr);
ASSERT_EQ(documentTabs->children.size(), 3u);
EXPECT_EQ(documentTabs->children[0].panel.panelId, "doc-a");
EXPECT_EQ(documentTabs->children[1].panel.panelId, "doc-c");
EXPECT_EQ(documentTabs->children[2].panel.panelId, "doc-b");
}
TEST(UIEditorDockHostInteractionTest, DraggingRightmostTabToFrontCommitsSameStackReorder) {
auto controller =
BuildDefaultUIEditorWorkspaceController(BuildPanelRegistry(), BuildThreeDocumentWorkspace());
UIEditorDockHostInteractionState state = {};
auto frame = UpdateUIEditorDockHostInteraction(
state,
controller,
UIRect(0.0f, 0.0f, 800.0f, 600.0f),
{});
const auto* documentStack = FindTabStackByNodeId(frame.layout, "document-tabs");
ASSERT_NE(documentStack, nullptr);
const UIPoint sourceCenter = RectCenter(documentStack->tabStripLayout.tabHeaderRects[2]);
const UIPoint dropPoint(
documentStack->tabStripLayout.tabHeaderRects[0].x + 4.0f,
sourceCenter.y);
frame = UpdateUIEditorDockHostInteraction(
state,
controller,
UIRect(0.0f, 0.0f, 800.0f, 600.0f),
{ MakePointerDown(sourceCenter.x, sourceCenter.y) });
EXPECT_TRUE(frame.result.consumed);
frame = UpdateUIEditorDockHostInteraction(
state,
controller,
UIRect(0.0f, 0.0f, 800.0f, 600.0f),
{ MakePointerMove(dropPoint.x, dropPoint.y) });
EXPECT_TRUE(frame.result.requestPointerCapture);
EXPECT_TRUE(frame.result.consumed);
frame = UpdateUIEditorDockHostInteraction(
state,
controller,
UIRect(0.0f, 0.0f, 800.0f, 600.0f),
{ MakePointerUp(dropPoint.x, dropPoint.y) });
EXPECT_TRUE(frame.result.releasePointerCapture);
EXPECT_TRUE(frame.result.layoutChanged);
const auto* documentTabs =
FindUIEditorWorkspaceNode(controller.GetWorkspace(), "document-tabs");
ASSERT_NE(documentTabs, nullptr);
ASSERT_EQ(documentTabs->children.size(), 3u);
EXPECT_EQ(documentTabs->children[0].panel.panelId, "doc-c");
EXPECT_EQ(documentTabs->children[1].panel.panelId, "doc-a");
EXPECT_EQ(documentTabs->children[2].panel.panelId, "doc-b");
}
TEST(UIEditorDockHostInteractionTest, SameStackReorderCommitsFromLastVisiblePreviewEvenIfReleaseDropsBelowHeader) {
auto controller =
BuildDefaultUIEditorWorkspaceController(BuildPanelRegistry(), BuildWorkspace());
UIEditorDockHostInteractionState state = {};
auto frame = UpdateUIEditorDockHostInteraction(
state,
controller,
UIRect(0.0f, 0.0f, 800.0f, 600.0f),
{});
const auto* documentStack = FindTabStackByNodeId(frame.layout, "document-tabs");
ASSERT_NE(documentStack, nullptr);
const UIPoint sourceCenter = RectCenter(documentStack->tabStripLayout.tabHeaderRects[0]);
const UIPoint previewPoint(
documentStack->tabStripLayout.headerRect.x +
documentStack->tabStripLayout.headerRect.width - 2.0f,
sourceCenter.y);
const UIPoint releasePoint(
previewPoint.x,
documentStack->tabStripLayout.headerRect.y +
documentStack->tabStripLayout.headerRect.height + 8.0f);
frame = UpdateUIEditorDockHostInteraction(
state,
controller,
UIRect(0.0f, 0.0f, 800.0f, 600.0f),
{ MakePointerDown(sourceCenter.x, sourceCenter.y) });
EXPECT_TRUE(frame.result.consumed);
frame = UpdateUIEditorDockHostInteraction(
state,
controller,
UIRect(0.0f, 0.0f, 800.0f, 600.0f),
{ MakePointerMove(previewPoint.x, previewPoint.y) });
EXPECT_TRUE(frame.result.requestPointerCapture);
EXPECT_TRUE(frame.result.consumed);
const auto tabStripStateIt = std::find_if(
state.dockHostState.tabStripStates.begin(),
state.dockHostState.tabStripStates.end(),
[](const auto& tabStripState) {
return tabStripState.nodeId == "document-tabs";
});
ASSERT_NE(tabStripStateIt, state.dockHostState.tabStripStates.end());
ASSERT_NE(
tabStripStateIt->state.reorder.previewInsertionIndex,
XCEngine::UI::Editor::Widgets::UIEditorTabStripInvalidIndex);
frame = UpdateUIEditorDockHostInteraction(
state,
controller,
UIRect(0.0f, 0.0f, 800.0f, 600.0f),
{ MakePointerUp(releasePoint.x, releasePoint.y) });
EXPECT_TRUE(frame.result.releasePointerCapture);
EXPECT_TRUE(frame.result.layoutChanged);
const auto* documentTabs =
FindUIEditorWorkspaceNode(controller.GetWorkspace(), "document-tabs");
ASSERT_NE(documentTabs, nullptr);
ASSERT_EQ(documentTabs->children.size(), 2u);
EXPECT_EQ(documentTabs->children[0].panel.panelId, "doc-b");
EXPECT_EQ(documentTabs->children[1].panel.panelId, "doc-a");
}
TEST(UIEditorDockHostInteractionTest, ReleasingDraggedTabOutsideHeaderCancelsWithoutChangingOrder) {
auto controller =
BuildDefaultUIEditorWorkspaceController(BuildPanelRegistry(), BuildWorkspace());
UIEditorDockHostInteractionState state = {};
auto frame = UpdateUIEditorDockHostInteraction(
state,
controller,
UIRect(0.0f, 0.0f, 800.0f, 600.0f),
{});
const auto* documentStack = FindTabStackByNodeId(frame.layout, "document-tabs");
ASSERT_NE(documentStack, nullptr);
const UIPoint sourceCenter = RectCenter(documentStack->tabStripLayout.tabHeaderRects[0]);
const UIPoint activatePoint(
documentStack->tabStripLayout.headerRect.x +
documentStack->tabStripLayout.headerRect.width - 2.0f,
sourceCenter.y);
const UIPoint cancelPoint = RectCenter(documentStack->contentFrameLayout.bodyRect);
frame = UpdateUIEditorDockHostInteraction(
state,
controller,
UIRect(0.0f, 0.0f, 800.0f, 600.0f),
{
MakePointerDown(sourceCenter.x, sourceCenter.y),
MakePointerMove(activatePoint.x, activatePoint.y),
MakePointerMove(cancelPoint.x, cancelPoint.y),
MakePointerUp(cancelPoint.x, cancelPoint.y)
});
EXPECT_TRUE(frame.result.releasePointerCapture);
EXPECT_FALSE(frame.result.layoutChanged);
const auto* documentTabs =
FindUIEditorWorkspaceNode(controller.GetWorkspace(), "document-tabs");
ASSERT_NE(documentTabs, nullptr);
ASSERT_EQ(documentTabs->children.size(), 2u);
EXPECT_EQ(documentTabs->children[0].panel.panelId, "doc-a");
EXPECT_EQ(documentTabs->children[1].panel.panelId, "doc-b");
}
TEST(UIEditorDockHostInteractionTest, DraggingTabOntoAnotherStackHeaderMergesIntoTargetStack) {
auto controller =
BuildDefaultUIEditorWorkspaceController(BuildPanelRegistry(), BuildWorkspace());
UIEditorDockHostInteractionState state = {};
auto frame = UpdateUIEditorDockHostInteraction(
state,
controller,
UIRect(0.0f, 0.0f, 800.0f, 600.0f),
{});
const auto* documentStack = FindTabStackByNodeId(frame.layout, "document-tabs");
const auto* detailsStack = FindTabStackByNodeId(frame.layout, "details-node");
ASSERT_NE(documentStack, nullptr);
ASSERT_NE(detailsStack, nullptr);
const UIPoint sourceCenter =
RectCenter(documentStack->tabStripLayout.tabHeaderRects[0]);
const UIPoint targetHeaderCenter =
RectCenter(detailsStack->tabStripLayout.headerRect);
frame = UpdateUIEditorDockHostInteraction(
state,
controller,
UIRect(0.0f, 0.0f, 800.0f, 600.0f),
{ MakePointerDown(sourceCenter.x, sourceCenter.y) });
EXPECT_TRUE(frame.result.consumed);
frame = UpdateUIEditorDockHostInteraction(
state,
controller,
UIRect(0.0f, 0.0f, 800.0f, 600.0f),
{ MakePointerMove(targetHeaderCenter.x, targetHeaderCenter.y) });
EXPECT_TRUE(frame.result.requestPointerCapture);
EXPECT_TRUE(state.dockHostState.dropPreview.visible);
EXPECT_EQ(state.dockHostState.dropPreview.targetNodeId, "details-node");
frame = UpdateUIEditorDockHostInteraction(
state,
controller,
UIRect(0.0f, 0.0f, 800.0f, 600.0f),
{ MakePointerUp(targetHeaderCenter.x, targetHeaderCenter.y) });
EXPECT_TRUE(frame.result.releasePointerCapture);
EXPECT_TRUE(frame.result.layoutChanged);
const auto* documentTabs =
FindUIEditorWorkspaceNode(controller.GetWorkspace(), "document-tabs");
const auto* detailsTabs =
FindUIEditorWorkspaceNode(controller.GetWorkspace(), "details-node");
ASSERT_NE(documentTabs, nullptr);
ASSERT_NE(detailsTabs, nullptr);
ASSERT_EQ(documentTabs->children.size(), 1u);
ASSERT_EQ(detailsTabs->children.size(), 2u);
EXPECT_EQ(documentTabs->children[0].panel.panelId, "doc-b");
EXPECT_EQ(detailsTabs->children[1].panel.panelId, "doc-a");
EXPECT_EQ(controller.GetWorkspace().activePanelId, "doc-a");
}
TEST(UIEditorDockHostInteractionTest, DraggingTabOntoPanelBodyEdgeCreatesDockSplit) {
auto controller =
BuildDefaultUIEditorWorkspaceController(BuildPanelRegistry(), BuildWorkspace());
UIEditorDockHostInteractionState state = {};
auto frame = UpdateUIEditorDockHostInteraction(
state,
controller,
UIRect(0.0f, 0.0f, 800.0f, 600.0f),
{});
const auto* documentStack = FindTabStackByNodeId(frame.layout, "document-tabs");
const auto* detailsStack = FindTabStackByNodeId(frame.layout, "details-node");
ASSERT_NE(documentStack, nullptr);
ASSERT_NE(detailsStack, nullptr);
const UIPoint sourceCenter =
RectCenter(documentStack->tabStripLayout.tabHeaderRects[0]);
const UIPoint targetBottomCenter(
detailsStack->contentFrameLayout.bodyRect.x +
detailsStack->contentFrameLayout.bodyRect.width * 0.5f,
detailsStack->contentFrameLayout.bodyRect.y +
detailsStack->contentFrameLayout.bodyRect.height - 4.0f);
frame = UpdateUIEditorDockHostInteraction(
state,
controller,
UIRect(0.0f, 0.0f, 800.0f, 600.0f),
{ MakePointerDown(sourceCenter.x, sourceCenter.y) });
EXPECT_TRUE(frame.result.consumed);
frame = UpdateUIEditorDockHostInteraction(
state,
controller,
UIRect(0.0f, 0.0f, 800.0f, 600.0f),
{ MakePointerMove(targetBottomCenter.x, targetBottomCenter.y) });
EXPECT_TRUE(frame.result.requestPointerCapture);
EXPECT_TRUE(state.dockHostState.dropPreview.visible);
EXPECT_EQ(
state.dockHostState.dropPreview.placement,
XCEngine::UI::Editor::UIEditorWorkspaceDockPlacement::Bottom);
frame = UpdateUIEditorDockHostInteraction(
state,
controller,
UIRect(0.0f, 0.0f, 800.0f, 600.0f),
{ MakePointerUp(targetBottomCenter.x, targetBottomCenter.y) });
EXPECT_TRUE(frame.result.releasePointerCapture);
EXPECT_TRUE(frame.result.layoutChanged);
EXPECT_EQ(controller.GetWorkspace().activePanelId, "doc-a");
bool foundDockedTab = false;
for (const std::string candidate : { "details-node__dock_doc-a_stack", "details-node__dock_doc-a_stack-1" }) {
const auto* docked =
FindUIEditorWorkspaceNode(controller.GetWorkspace(), candidate);
if (docked != nullptr &&
docked->children.size() == 1u &&
docked->children[0].panel.panelId == "doc-a") {
foundDockedTab = true;
break;
}
}
EXPECT_TRUE(foundDockedTab);
}
TEST(UIEditorDockHostInteractionTest, FocusLostWhileDraggingTabCancelsAndReleasesCapture) {
auto controller =
BuildDefaultUIEditorWorkspaceController(BuildPanelRegistry(), BuildWorkspace());
UIEditorDockHostInteractionState state = {};
auto frame = UpdateUIEditorDockHostInteraction(
state,
controller,
UIRect(0.0f, 0.0f, 800.0f, 600.0f),
{});
const auto* documentStack = FindTabStackByNodeId(frame.layout, "document-tabs");
ASSERT_NE(documentStack, nullptr);
const UIPoint sourceCenter = RectCenter(documentStack->tabStripLayout.tabHeaderRects[0]);
const UIPoint activatePoint(
documentStack->tabStripLayout.headerRect.x +
documentStack->tabStripLayout.headerRect.width - 2.0f,
sourceCenter.y);
frame = UpdateUIEditorDockHostInteraction(
state,
controller,
UIRect(0.0f, 0.0f, 800.0f, 600.0f),
{
MakePointerDown(sourceCenter.x, sourceCenter.y),
MakePointerMove(activatePoint.x, activatePoint.y)
});
ASSERT_TRUE(frame.result.requestPointerCapture);
frame = UpdateUIEditorDockHostInteraction(
state,
controller,
UIRect(0.0f, 0.0f, 800.0f, 600.0f),
{ MakeFocusLost() });
EXPECT_TRUE(frame.result.releasePointerCapture);
EXPECT_FALSE(frame.result.layoutChanged);
const auto* documentTabs =
FindUIEditorWorkspaceNode(controller.GetWorkspace(), "document-tabs");
ASSERT_NE(documentTabs, nullptr);
ASSERT_EQ(documentTabs->children.size(), 2u);
EXPECT_EQ(documentTabs->children[0].panel.panelId, "doc-a");
EXPECT_EQ(documentTabs->children[1].panel.panelId, "doc-b");
}

5
tests/UI/Editor/unit/test_ui_editor_menu_bar.cpp
View File

@@ -96,12 +96,11 @@ TEST(UIEditorMenuBarTest, BackgroundAndForegroundEmitStableCommands) {
UIDrawList background("MenuBarBackground");
AppendUIEditorMenuBarBackground(background, layout, items, state);
ASSERT_EQ(background.GetCommandCount(), 6u);
ASSERT_EQ(background.GetCommandCount(), 3u);
const auto& backgroundCommands = background.GetCommands();
EXPECT_EQ(backgroundCommands[0].type, UIDrawCommandType::FilledRect);
EXPECT_EQ(backgroundCommands[1].type, UIDrawCommandType::RectOutline);
EXPECT_EQ(backgroundCommands[1].type, UIDrawCommandType::FilledRect);
EXPECT_EQ(backgroundCommands[2].type, UIDrawCommandType::FilledRect);
EXPECT_EQ(backgroundCommands[5].type, UIDrawCommandType::RectOutline);
UIDrawList foreground("MenuBarForeground");
AppendUIEditorMenuBarForeground(foreground, layout, items, state);

79
tests/UI/Editor/unit/test_ui_editor_shell_interaction.cpp
View File

@@ -41,6 +41,8 @@ using XCEngine::UI::Editor::UIEditorShellInteractionModel;
using XCEngine::UI::Editor::UIEditorShellInteractionPopupItemRequest;
using XCEngine::UI::Editor::UIEditorShellInteractionServices;
using XCEngine::UI::Editor::UIEditorShellInteractionState;
using XCEngine::UI::Editor::UIEditorTextMeasureRequest;
using XCEngine::UI::Editor::UIEditorTextMeasurer;
using XCEngine::UI::Editor::UIEditorWorkspaceController;
using XCEngine::UI::Editor::UIEditorWorkspaceCommandKind;
using XCEngine::UI::Editor::UIEditorWorkspaceCommandStatus;
@@ -52,6 +54,13 @@ using XCEngine::UI::Editor::Widgets::UIEditorMenuPopupInvalidIndex;
using XCEngine::UI::Editor::Widgets::UIEditorStatusBarSlot;
using XCEngine::UI::Widgets::UIPopupDismissReason;
class StubTextMeasurer final : public UIEditorTextMeasurer {
public:
float MeasureTextWidth(const UIEditorTextMeasureRequest& request) const override {
return static_cast<float>(request.text.size()) * (request.fontSize * 0.6f);
}
};
UIEditorPanelRegistry BuildPanelRegistry() {
UIEditorPanelRegistry registry = {};
registry.panels = {
@@ -219,6 +228,76 @@ UIEditorWorkspaceController BuildController() {
return BuildDefaultUIEditorWorkspaceController(BuildPanelRegistry(), BuildWorkspace());
}
UIPoint RectCenter(const UIRect& rect);
UIInputEvent MakeLeftPointerDown(const UIPoint& position);
TEST(UIEditorShellInteractionTest, RequestUsesTextMeasurerForMenuBarWidths) {
UIEditorWorkspaceController controller = BuildController();
const UIEditorShellInteractionModel model = BuildInteractionModel();
StubTextMeasurer textMeasurer = {};
UIEditorShellInteractionServices services = {};
services.textMeasurer = &textMeasurer;
const auto request = ResolveUIEditorShellInteractionRequest(
UIRect(0.0f, 0.0f, 480.0f, 320.0f),
controller,
model,
{},
{},
services);
ASSERT_EQ(request.menuBarItems.size(), 2u);
EXPECT_FLOAT_EQ(
request.menuBarItems[0].desiredLabelWidth,
textMeasurer.MeasureTextWidth(UIEditorTextMeasureRequest { "File", 13.0f }));
EXPECT_FLOAT_EQ(
request.menuBarItems[1].desiredLabelWidth,
textMeasurer.MeasureTextWidth(UIEditorTextMeasureRequest { "Window", 13.0f }));
EXPECT_GT(request.menuButtons[1].rect.width, request.menuButtons[0].rect.width);
}
TEST(UIEditorShellInteractionTest, PopupWidgetWidthsUseTextMeasurerForLabelAndShortcut) {
UIEditorWorkspaceController controller = BuildController();
const UIEditorShellInteractionModel model = BuildInteractionModel();
StubTextMeasurer textMeasurer = {};
UIEditorShellInteractionServices services = {};
services.textMeasurer = &textMeasurer;
UIEditorShellInteractionState state = {};
const auto request = ResolveUIEditorShellInteractionRequest(
UIRect(0.0f, 0.0f, 480.0f, 320.0f),
controller,
model,
state,
{},
services);
ASSERT_FALSE(request.menuButtons.empty());
UIInputEvent openMenuEvent = {};
openMenuEvent.type = UIInputEventType::PointerButtonDown;
openMenuEvent.pointerButton = UIPointerButton::Left;
openMenuEvent.position = UIPoint(
request.menuButtons.front().rect.x + request.menuButtons.front().rect.width * 0.5f,
request.menuButtons.front().rect.y + request.menuButtons.front().rect.height * 0.5f);
const auto frame = UpdateUIEditorShellInteraction(
state,
controller,
UIRect(0.0f, 0.0f, 480.0f, 320.0f),
model,
std::vector<UIInputEvent> { openMenuEvent },
services);
ASSERT_EQ(frame.request.popupRequests.size(), 1u);
ASSERT_GE(frame.request.popupRequests.front().widgetItems.size(), 2u);
EXPECT_FLOAT_EQ(
frame.request.popupRequests.front().widgetItems[0].desiredLabelWidth,
textMeasurer.MeasureTextWidth(UIEditorTextMeasureRequest { "Workspace Tools", 13.0f }));
EXPECT_FLOAT_EQ(
frame.request.popupRequests.front().widgetItems[1].desiredShortcutWidth,
textMeasurer.MeasureTextWidth(UIEditorTextMeasureRequest { "Ctrl+W", 13.0f }));
}
const UIEditorShellInteractionMenuButtonRequest* FindMenuButton(
const UIEditorShellInteractionFrame& frame,
std::string_view menuId) {

70
tests/UI/Editor/unit/test_ui_editor_tab_strip.cpp
View File

@@ -15,7 +15,6 @@ using XCEngine::UI::Editor::Widgets::BuildUIEditorTabStripLayout;
using XCEngine::UI::Editor::Widgets::HitTestUIEditorTabStrip;
using XCEngine::UI::Editor::Widgets::ResolveUIEditorTabStripDesiredHeaderLabelWidth;
using XCEngine::UI::Editor::Widgets::ResolveUIEditorTabStripSelectedIndex;
using XCEngine::UI::Editor::Widgets::ResolveUIEditorTabStripSelectedIndexAfterClose;
using XCEngine::UI::Editor::Widgets::UIEditorTabStripHitTargetKind;
using XCEngine::UI::Editor::Widgets::UIEditorTabStripInvalidIndex;
using XCEngine::UI::Editor::Widgets::UIEditorTabStripItem;
@@ -23,7 +22,7 @@ using XCEngine::UI::Editor::Widgets::UIEditorTabStripLayout;
using XCEngine::UI::Editor::Widgets::UIEditorTabStripMetrics;
using XCEngine::UI::Editor::Widgets::UIEditorTabStripState;
TEST(UIEditorTabStripTest, DesiredHeaderWidthReservesCloseButtonBudget) {
TEST(UIEditorTabStripTest, DesiredHeaderWidthUsesLabelWidthAndLeftInsetOnly) {
UIEditorTabStripMetrics metrics = {};
metrics.layoutMetrics.tabHorizontalPadding = 10.0f;
metrics.estimatedGlyphWidth = 8.0f;
@@ -32,14 +31,14 @@ TEST(UIEditorTabStripTest, DesiredHeaderWidthReservesCloseButtonBudget) {
metrics.closeInsetRight = 14.0f;
metrics.labelInsetX = 12.0f;
const float closableWidth = ResolveUIEditorTabStripDesiredHeaderLabelWidth(
const float measuredWidth = ResolveUIEditorTabStripDesiredHeaderLabelWidth(
UIEditorTabStripItem{ "doc-a", "ABCD", true, 0.0f },
metrics);
const float fixedWidth = ResolveUIEditorTabStripDesiredHeaderLabelWidth(
UIEditorTabStripItem{ "doc-b", "Ignored", false, 42.0f },
metrics);
EXPECT_FLOAT_EQ(closableWidth, 58.0f);
EXPECT_FLOAT_EQ(measuredWidth, 34.0f);
EXPECT_FLOAT_EQ(fixedWidth, 44.0f);
}
@@ -58,16 +57,7 @@ TEST(UIEditorTabStripTest, SelectedIndexResolvesByTabIdAndFallsBackToValidRange)
UIEditorTabStripInvalidIndex);
}
TEST(UIEditorTabStripTest, ClosingTabsResolvesSelectionFallbackFromClosedIndex) {
EXPECT_EQ(ResolveUIEditorTabStripSelectedIndexAfterClose(1u, 1u, 3u), 1u);
EXPECT_EQ(ResolveUIEditorTabStripSelectedIndexAfterClose(2u, 2u, 3u), 1u);
EXPECT_EQ(ResolveUIEditorTabStripSelectedIndexAfterClose(2u, 0u, 3u), 1u);
EXPECT_EQ(
ResolveUIEditorTabStripSelectedIndexAfterClose(0u, 0u, 1u),
UIEditorTabStripInvalidIndex);
}
TEST(UIEditorTabStripTest, LayoutUsesCoreTabArrangementAndBuildsCloseRects) {
TEST(UIEditorTabStripTest, LayoutUsesCoreTabArrangementWithoutCloseButtons) {
UIEditorTabStripMetrics metrics = {};
metrics.layoutMetrics.headerHeight = 30.0f;
metrics.layoutMetrics.tabMinWidth = 80.0f;
@@ -101,20 +91,16 @@ TEST(UIEditorTabStripTest, LayoutUsesCoreTabArrangementAndBuildsCloseRects) {
ASSERT_EQ(layout.tabHeaderRects.size(), 2u);
EXPECT_FLOAT_EQ(layout.tabHeaderRects[0].x, 10.0f);
EXPECT_FLOAT_EQ(layout.tabHeaderRects[0].width, 90.0f);
EXPECT_FLOAT_EQ(layout.tabHeaderRects[1].x, 104.0f);
EXPECT_FLOAT_EQ(layout.tabHeaderRects[0].width, 80.0f);
EXPECT_FLOAT_EQ(layout.tabHeaderRects[1].x, 94.0f);
EXPECT_FLOAT_EQ(layout.tabHeaderRects[1].width, 80.0f);
ASSERT_EQ(layout.closeButtonRects.size(), 2u);
EXPECT_TRUE(layout.showCloseButtons[0]);
EXPECT_FALSE(layout.showCloseButtons[0]);
EXPECT_FALSE(layout.showCloseButtons[1]);
EXPECT_FLOAT_EQ(layout.closeButtonRects[0].x, 76.0f);
EXPECT_FLOAT_EQ(layout.closeButtonRects[0].y, 29.0f);
EXPECT_FLOAT_EQ(layout.closeButtonRects[0].width, 12.0f);
EXPECT_FLOAT_EQ(layout.closeButtonRects[0].height, 12.0f);
}
TEST(UIEditorTabStripTest, HitTestPrioritizesCloseButtonThenTabThenContent) {
TEST(UIEditorTabStripTest, HitTestPrioritizesTabThenHeaderThenContent) {
const std::vector<UIEditorTabStripItem> items = {
{ "doc-a", "Document A", true, 48.0f },
{ "doc-b", "Document B", false, 40.0f }
@@ -125,14 +111,23 @@ TEST(UIEditorTabStripTest, HitTestPrioritizesCloseButtonThenTabThenContent) {
const UIEditorTabStripLayout layout =
BuildUIEditorTabStripLayout(UIRect(10.0f, 20.0f, 260.0f, 180.0f), items, state);
const auto closeHit = HitTestUIEditorTabStrip(layout, state, UIPoint(85.0f, 34.0f));
EXPECT_EQ(closeHit.kind, UIEditorTabStripHitTargetKind::CloseButton);
EXPECT_EQ(closeHit.index, 0u);
const auto rightSideTabHit = HitTestUIEditorTabStrip(
layout,
state,
UIPoint(
layout.tabHeaderRects[0].x + layout.tabHeaderRects[0].width - 2.0f,
layout.tabHeaderRects[0].y + layout.tabHeaderRects[0].height * 0.5f));
EXPECT_EQ(rightSideTabHit.kind, UIEditorTabStripHitTargetKind::Tab);
EXPECT_EQ(rightSideTabHit.index, 0u);
const auto tabHit = HitTestUIEditorTabStrip(layout, state, UIPoint(40.0f, 34.0f));
EXPECT_EQ(tabHit.kind, UIEditorTabStripHitTargetKind::Tab);
EXPECT_EQ(tabHit.index, 0u);
const auto headerHit = HitTestUIEditorTabStrip(layout, state, UIPoint(200.0f, 34.0f));
EXPECT_EQ(headerHit.kind, UIEditorTabStripHitTargetKind::HeaderBackground);
EXPECT_EQ(headerHit.index, UIEditorTabStripInvalidIndex);
const auto contentHit = HitTestUIEditorTabStrip(layout, state, UIPoint(40.0f, 70.0f));
EXPECT_EQ(contentHit.kind, UIEditorTabStripHitTargetKind::Content);
EXPECT_EQ(contentHit.index, UIEditorTabStripInvalidIndex);
@@ -147,7 +142,6 @@ TEST(UIEditorTabStripTest, BackgroundAndForegroundEmitStableChromeCommands) {
UIEditorTabStripState state = {};
state.selectedIndex = 0u;
state.hoveredIndex = 1u;
state.closeHoveredIndex = 0u;
state.focused = true;
const UIEditorTabStripLayout layout =
@@ -155,24 +149,28 @@ TEST(UIEditorTabStripTest, BackgroundAndForegroundEmitStableChromeCommands) {
UIDrawList background("TabStripBackground");
AppendUIEditorTabStripBackground(background, layout, state);
ASSERT_EQ(background.GetCommandCount(), 8u);
ASSERT_EQ(background.GetCommandCount(), 9u);
const auto& backgroundCommands = background.GetCommands();
EXPECT_EQ(backgroundCommands[0].type, UIDrawCommandType::FilledRect);
EXPECT_EQ(backgroundCommands[3].type, UIDrawCommandType::RectOutline);
EXPECT_EQ(backgroundCommands[4].type, UIDrawCommandType::FilledRect);
EXPECT_EQ(backgroundCommands[7].type, UIDrawCommandType::RectOutline);
EXPECT_EQ(backgroundCommands[5].type, UIDrawCommandType::RectOutline);
EXPECT_EQ(backgroundCommands[6].type, UIDrawCommandType::FilledRect);
EXPECT_EQ(backgroundCommands[7].type, UIDrawCommandType::FilledRect);
EXPECT_EQ(backgroundCommands[8].type, UIDrawCommandType::RectOutline);
UIDrawList foreground("TabStripForeground");
AppendUIEditorTabStripForeground(foreground, layout, items, state);
ASSERT_EQ(foreground.GetCommandCount(), 9u);
ASSERT_EQ(foreground.GetCommandCount(), 8u);
const auto& foregroundCommands = foreground.GetCommands();
EXPECT_EQ(foregroundCommands[0].type, UIDrawCommandType::PushClipRect);
EXPECT_EQ(foregroundCommands[1].type, UIDrawCommandType::Text);
EXPECT_EQ(foregroundCommands[1].text, "Document A");
EXPECT_EQ(foregroundCommands[5].type, UIDrawCommandType::Text);
EXPECT_EQ(foregroundCommands[5].text, "X");
EXPECT_EQ(foregroundCommands[7].type, UIDrawCommandType::Text);
EXPECT_EQ(foregroundCommands[7].text, "Document B");
EXPECT_EQ(foregroundCommands[0].type, UIDrawCommandType::FilledRect);
EXPECT_EQ(foregroundCommands[1].type, UIDrawCommandType::FilledRect);
EXPECT_EQ(foregroundCommands[2].type, UIDrawCommandType::PushClipRect);
EXPECT_EQ(foregroundCommands[3].type, UIDrawCommandType::Text);
EXPECT_EQ(foregroundCommands[3].text, "Document A");
EXPECT_EQ(foregroundCommands[5].type, UIDrawCommandType::PushClipRect);
EXPECT_EQ(foregroundCommands[6].type, UIDrawCommandType::Text);
EXPECT_EQ(foregroundCommands[6].text, "Document B");
}
} // namespace

427
tests/UI/Editor/unit/test_ui_editor_tab_strip_interaction.cpp
View File

@@ -15,6 +15,7 @@ using XCEngine::UI::UIRect;
using XCEngine::UI::Editor::UIEditorTabStripInteractionState;
using XCEngine::UI::Editor::UpdateUIEditorTabStripInteraction;
using XCEngine::UI::Editor::Widgets::UIEditorTabStripHitTargetKind;
using XCEngine::UI::Editor::Widgets::UIEditorTabStripInvalidIndex;
using XCEngine::UI::Editor::Widgets::UIEditorTabStripItem;
std::vector<UIEditorTabStripItem> BuildTabItems() {
@@ -73,7 +74,7 @@ UIPoint RectCenter(const XCEngine::UI::UIRect& rect) {
} // namespace
TEST(UIEditorTabStripInteractionTest, PointerMoveUpdatesHoveredTabAndCloseState) {
TEST(UIEditorTabStripInteractionTest, PointerMoveUpdatesHoveredTabOnly) {
const auto items = BuildTabItems();
std::string selectedTabId = "doc-a";
UIEditorTabStripInteractionState state = {};
@@ -85,7 +86,7 @@ TEST(UIEditorTabStripInteractionTest, PointerMoveUpdatesHoveredTabAndCloseState)
items,
{});
auto frame = UpdateUIEditorTabStripInteraction(
const auto frame = UpdateUIEditorTabStripInteraction(
state,
selectedTabId,
UIRect(0.0f, 0.0f, 320.0f, 180.0f),
@@ -93,21 +94,11 @@ TEST(UIEditorTabStripInteractionTest, PointerMoveUpdatesHoveredTabAndCloseState)
{ MakePointerMove(
initialFrame.layout.tabHeaderRects[1].x + 12.0f,
initialFrame.layout.tabHeaderRects[1].y + 12.0f) });
EXPECT_EQ(frame.result.hitTarget.kind, UIEditorTabStripHitTargetKind::Tab);
EXPECT_EQ(state.tabStripState.hoveredIndex, 1u);
EXPECT_EQ(state.tabStripState.closeHoveredIndex, XCEngine::UI::Editor::Widgets::UIEditorTabStripInvalidIndex);
frame = UpdateUIEditorTabStripInteraction(
state,
selectedTabId,
UIRect(0.0f, 0.0f, 320.0f, 180.0f),
items,
{ MakePointerMove(
initialFrame.layout.closeButtonRects[0].x + 4.0f,
initialFrame.layout.closeButtonRects[0].y + 4.0f) });
EXPECT_EQ(frame.result.hitTarget.kind, UIEditorTabStripHitTargetKind::CloseButton);
EXPECT_EQ(state.tabStripState.hoveredIndex, 0u);
EXPECT_EQ(state.tabStripState.closeHoveredIndex, 0u);
EXPECT_EQ(state.tabStripState.closeHoveredIndex, UIEditorTabStripInvalidIndex);
EXPECT_FALSE(frame.result.closeRequested);
}
TEST(UIEditorTabStripInteractionTest, LeftClickTabSelectsAndFocusesStrip) {
@@ -141,38 +132,6 @@ TEST(UIEditorTabStripInteractionTest, LeftClickTabSelectsAndFocusesStrip) {
EXPECT_TRUE(state.tabStripState.focused);
}
TEST(UIEditorTabStripInteractionTest, LeftClickCloseButtonRequestsCloseWithoutChangingSelection) {
const auto items = BuildTabItems();
std::string selectedTabId = "doc-a";
UIEditorTabStripInteractionState state = {};
const auto initialFrame = UpdateUIEditorTabStripInteraction(
state,
selectedTabId,
UIRect(0.0f, 0.0f, 320.0f, 180.0f),
items,
{});
const UIPoint closeCenter = RectCenter(initialFrame.layout.closeButtonRects[1]);
const auto frame = UpdateUIEditorTabStripInteraction(
state,
selectedTabId,
UIRect(0.0f, 0.0f, 320.0f, 180.0f),
items,
{
MakePointerDown(closeCenter.x, closeCenter.y),
MakePointerUp(closeCenter.x, closeCenter.y)
});
EXPECT_TRUE(frame.result.consumed);
EXPECT_TRUE(frame.result.closeRequested);
EXPECT_FALSE(frame.result.selectionChanged);
EXPECT_EQ(frame.result.closedTabId, "doc-b");
EXPECT_EQ(frame.result.closedIndex, 1u);
EXPECT_EQ(selectedTabId, "doc-a");
EXPECT_TRUE(state.tabStripState.focused);
}
TEST(UIEditorTabStripInteractionTest, KeyboardNavigationMovesSelectionWhenFocused) {
const auto items = BuildTabItems();
std::string selectedTabId = "doc-b";
@@ -238,7 +197,377 @@ TEST(UIEditorTabStripInteractionTest, OutsideClickAndFocusLostClearFocusAndHover
items,
{ MakePointerLeave(), MakeFocusLost() });
EXPECT_FALSE(state.tabStripState.focused);
EXPECT_EQ(state.tabStripState.hoveredIndex, XCEngine::UI::Editor::Widgets::UIEditorTabStripInvalidIndex);
EXPECT_EQ(state.tabStripState.closeHoveredIndex, XCEngine::UI::Editor::Widgets::UIEditorTabStripInvalidIndex);
EXPECT_EQ(state.tabStripState.hoveredIndex, UIEditorTabStripInvalidIndex);
EXPECT_EQ(state.tabStripState.closeHoveredIndex, UIEditorTabStripInvalidIndex);
EXPECT_FALSE(state.hasPointerPosition);
}
TEST(UIEditorTabStripInteractionTest, DraggingTabRequestsPointerCaptureAndShowsInsertionPreview) {
const auto items = BuildTabItems();
std::string selectedTabId = "doc-a";
UIEditorTabStripInteractionState state = {};
const auto initialFrame = UpdateUIEditorTabStripInteraction(
state,
selectedTabId,
UIRect(0.0f, 0.0f, 320.0f, 180.0f),
items,
{});
const UIPoint sourceCenter = RectCenter(initialFrame.layout.tabHeaderRects[0]);
const auto& lastRect = initialFrame.layout.tabHeaderRects.back();
const UIPoint dragPoint(lastRect.x + lastRect.width - 2.0f, sourceCenter.y);
const auto frame = UpdateUIEditorTabStripInteraction(
state,
selectedTabId,
UIRect(0.0f, 0.0f, 320.0f, 180.0f),
items,
{
MakePointerDown(sourceCenter.x, sourceCenter.y),
MakePointerMove(dragPoint.x, dragPoint.y)
});
EXPECT_TRUE(frame.result.requestPointerCapture);
EXPECT_TRUE(frame.result.dragStarted);
EXPECT_TRUE(frame.result.consumed);
EXPECT_EQ(frame.result.draggedTabId, "doc-a");
EXPECT_EQ(frame.result.dragSourceIndex, 0u);
EXPECT_EQ(frame.result.dropInsertionIndex, items.size());
EXPECT_EQ(frame.result.reorderToIndex, 2u);
EXPECT_TRUE(frame.result.reorderPreviewActive);
EXPECT_EQ(frame.result.reorderPreviewIndex, 2u);
EXPECT_TRUE(state.reorderCaptureActive);
EXPECT_EQ(state.reorderSourceIndex, 0u);
EXPECT_EQ(state.reorderPreviewIndex, 2u);
EXPECT_TRUE(frame.layout.insertionPreview.visible);
EXPECT_EQ(frame.layout.insertionPreview.insertionIndex, items.size());
}
TEST(UIEditorTabStripInteractionTest, DroppingDraggedTabEmitsSameStackReorderRequest) {
const auto items = BuildTabItems();
std::string selectedTabId = "doc-a";
UIEditorTabStripInteractionState state = {};
const auto initialFrame = UpdateUIEditorTabStripInteraction(
state,
selectedTabId,
UIRect(0.0f, 0.0f, 320.0f, 180.0f),
items,
{});
const UIPoint sourceCenter = RectCenter(initialFrame.layout.tabHeaderRects[0]);
const auto& lastRect = initialFrame.layout.tabHeaderRects.back();
const UIPoint dragPoint(lastRect.x + lastRect.width - 2.0f, sourceCenter.y);
const auto frame = UpdateUIEditorTabStripInteraction(
state,
selectedTabId,
UIRect(0.0f, 0.0f, 320.0f, 180.0f),
items,
{
MakePointerDown(sourceCenter.x, sourceCenter.y),
MakePointerMove(dragPoint.x, dragPoint.y),
MakePointerUp(dragPoint.x, dragPoint.y)
});
EXPECT_TRUE(frame.result.releasePointerCapture);
EXPECT_TRUE(frame.result.dragEnded);
EXPECT_TRUE(frame.result.reorderRequested);
EXPECT_FALSE(frame.result.dragCanceled);
EXPECT_EQ(frame.result.draggedTabId, "doc-a");
EXPECT_EQ(frame.result.dragSourceIndex, 0u);
EXPECT_EQ(frame.result.dropInsertionIndex, items.size());
EXPECT_EQ(frame.result.reorderToIndex, 2u);
EXPECT_FALSE(state.reorderCaptureActive);
EXPECT_EQ(state.reorderSourceIndex, UIEditorTabStripInvalidIndex);
EXPECT_EQ(state.reorderPreviewIndex, UIEditorTabStripInvalidIndex);
EXPECT_FALSE(frame.layout.insertionPreview.visible);
}
TEST(UIEditorTabStripInteractionTest, DroppingRightmostTabToFrontCommitsReorderRequest) {
const auto items = BuildTabItems();
std::string selectedTabId = "doc-c";
UIEditorTabStripInteractionState state = {};
const auto initialFrame = UpdateUIEditorTabStripInteraction(
state,
selectedTabId,
UIRect(0.0f, 0.0f, 320.0f, 180.0f),
items,
{});
const UIPoint sourceCenter = RectCenter(initialFrame.layout.tabHeaderRects[2]);
const UIPoint dropPoint(
initialFrame.layout.tabHeaderRects[0].x + 4.0f,
sourceCenter.y);
const auto frame = UpdateUIEditorTabStripInteraction(
state,
selectedTabId,
UIRect(0.0f, 0.0f, 320.0f, 180.0f),
items,
{
MakePointerDown(sourceCenter.x, sourceCenter.y),
MakePointerMove(dropPoint.x, dropPoint.y),
MakePointerUp(dropPoint.x, dropPoint.y)
});
EXPECT_TRUE(frame.result.releasePointerCapture);
EXPECT_TRUE(frame.result.dragEnded);
EXPECT_TRUE(frame.result.reorderRequested);
EXPECT_FALSE(frame.result.dragCanceled);
EXPECT_EQ(frame.result.draggedTabId, "doc-c");
EXPECT_EQ(frame.result.dragSourceIndex, 2u);
EXPECT_EQ(frame.result.dropInsertionIndex, 0u);
EXPECT_EQ(frame.result.reorderToIndex, 0u);
}
TEST(UIEditorTabStripInteractionTest, DroppingRightmostTabIntoMiddleCommitsReorderRequest) {
const auto items = BuildTabItems();
std::string selectedTabId = "doc-c";
UIEditorTabStripInteractionState state = {};
const auto initialFrame = UpdateUIEditorTabStripInteraction(
state,
selectedTabId,
UIRect(0.0f, 0.0f, 320.0f, 180.0f),
items,
{});
const UIPoint sourceCenter = RectCenter(initialFrame.layout.tabHeaderRects[2]);
const UIPoint dropPoint(
initialFrame.layout.tabHeaderRects[1].x + 4.0f,
sourceCenter.y);
const auto frame = UpdateUIEditorTabStripInteraction(
state,
selectedTabId,
UIRect(0.0f, 0.0f, 320.0f, 180.0f),
items,
{
MakePointerDown(sourceCenter.x, sourceCenter.y),
MakePointerMove(dropPoint.x, dropPoint.y),
MakePointerUp(dropPoint.x, dropPoint.y)
});
EXPECT_TRUE(frame.result.releasePointerCapture);
EXPECT_TRUE(frame.result.dragEnded);
EXPECT_TRUE(frame.result.reorderRequested);
EXPECT_FALSE(frame.result.dragCanceled);
EXPECT_EQ(frame.result.draggedTabId, "doc-c");
EXPECT_EQ(frame.result.dragSourceIndex, 2u);
EXPECT_EQ(frame.result.dropInsertionIndex, 1u);
EXPECT_EQ(frame.result.reorderToIndex, 1u);
}
TEST(UIEditorTabStripInteractionTest, SeparateFrameDropOfRightmostTabIntoMiddleStillCommitsReorderRequest) {
const auto items = BuildTabItems();
std::string selectedTabId = "doc-c";
UIEditorTabStripInteractionState state = {};
const auto initialFrame = UpdateUIEditorTabStripInteraction(
state,
selectedTabId,
UIRect(0.0f, 0.0f, 320.0f, 180.0f),
items,
{});
const UIPoint sourceCenter = RectCenter(initialFrame.layout.tabHeaderRects[2]);
const UIPoint dropPoint(
initialFrame.layout.tabHeaderRects[1].x + 4.0f,
sourceCenter.y);
auto frame = UpdateUIEditorTabStripInteraction(
state,
selectedTabId,
UIRect(0.0f, 0.0f, 320.0f, 180.0f),
items,
{
MakePointerDown(sourceCenter.x, sourceCenter.y),
MakePointerMove(dropPoint.x, dropPoint.y)
});
ASSERT_TRUE(frame.result.requestPointerCapture);
ASSERT_TRUE(frame.result.reorderPreviewActive);
ASSERT_TRUE(state.reorderDragState.active);
ASSERT_FALSE(state.reorderDragState.targetId.empty());
frame = UpdateUIEditorTabStripInteraction(
state,
selectedTabId,
UIRect(0.0f, 0.0f, 320.0f, 180.0f),
items,
{ MakePointerUp(dropPoint.x, dropPoint.y) });
EXPECT_TRUE(frame.result.releasePointerCapture);
EXPECT_TRUE(frame.result.dragEnded);
EXPECT_TRUE(frame.result.reorderRequested);
EXPECT_FALSE(frame.result.dragCanceled);
EXPECT_EQ(frame.result.draggedTabId, "doc-c");
EXPECT_EQ(frame.result.dragSourceIndex, 2u);
EXPECT_EQ(frame.result.dropInsertionIndex, 1u);
EXPECT_EQ(frame.result.reorderToIndex, 1u);
}
TEST(UIEditorTabStripInteractionTest, ReleasingOutsideHeaderStillCommitsLastVisibleReorderPreview) {
const auto items = BuildTabItems();
std::string selectedTabId = "doc-a";
UIEditorTabStripInteractionState state = {};
const auto initialFrame = UpdateUIEditorTabStripInteraction(
state,
selectedTabId,
UIRect(0.0f, 0.0f, 320.0f, 180.0f),
items,
{});
const UIPoint sourceCenter = RectCenter(initialFrame.layout.tabHeaderRects[0]);
const auto& lastRect = initialFrame.layout.tabHeaderRects.back();
const UIPoint dragPoint(lastRect.x + lastRect.width - 2.0f, sourceCenter.y);
const UIPoint releasePoint(
dragPoint.x,
initialFrame.layout.headerRect.y + initialFrame.layout.headerRect.height + 8.0f);
auto frame = UpdateUIEditorTabStripInteraction(
state,
selectedTabId,
UIRect(0.0f, 0.0f, 320.0f, 180.0f),
items,
{
MakePointerDown(sourceCenter.x, sourceCenter.y),
MakePointerMove(dragPoint.x, dragPoint.y)
});
ASSERT_TRUE(frame.result.reorderPreviewActive);
ASSERT_EQ(state.tabStripState.reorder.previewInsertionIndex, items.size());
frame = UpdateUIEditorTabStripInteraction(
state,
selectedTabId,
UIRect(0.0f, 0.0f, 320.0f, 180.0f),
items,
{ MakePointerUp(releasePoint.x, releasePoint.y) });
EXPECT_TRUE(frame.result.releasePointerCapture);
EXPECT_TRUE(frame.result.dragEnded);
EXPECT_TRUE(frame.result.reorderRequested);
EXPECT_FALSE(frame.result.dragCanceled);
EXPECT_EQ(frame.result.draggedTabId, "doc-a");
EXPECT_EQ(frame.result.dragSourceIndex, 0u);
EXPECT_EQ(frame.result.dropInsertionIndex, items.size());
EXPECT_EQ(frame.result.reorderToIndex, 2u);
}
TEST(UIEditorTabStripInteractionTest, EscapeCancelsActiveTabDragAndReleasesCapture) {
const auto items = BuildTabItems();
std::string selectedTabId = "doc-a";
UIEditorTabStripInteractionState state = {};
const auto initialFrame = UpdateUIEditorTabStripInteraction(
state,
selectedTabId,
UIRect(0.0f, 0.0f, 320.0f, 180.0f),
items,
{});
const UIPoint sourceCenter = RectCenter(initialFrame.layout.tabHeaderRects[1]);
const UIPoint dragPoint(
initialFrame.layout.tabHeaderRects[2].x + 8.0f,
sourceCenter.y);
auto frame = UpdateUIEditorTabStripInteraction(
state,
selectedTabId,
UIRect(0.0f, 0.0f, 320.0f, 180.0f),
items,
{
MakePointerDown(sourceCenter.x, sourceCenter.y),
MakePointerMove(dragPoint.x, dragPoint.y)
});
ASSERT_TRUE(frame.result.dragStarted);
ASSERT_TRUE(state.reorderCaptureActive);
frame = UpdateUIEditorTabStripInteraction(
state,
selectedTabId,
UIRect(0.0f, 0.0f, 320.0f, 180.0f),
items,
{ MakeKeyDown(KeyCode::Escape) });
EXPECT_TRUE(frame.result.dragCanceled);
EXPECT_TRUE(frame.result.releasePointerCapture);
EXPECT_FALSE(frame.result.reorderRequested);
EXPECT_EQ(frame.result.draggedTabId, "doc-b");
EXPECT_FALSE(state.reorderCaptureActive);
EXPECT_EQ(state.reorderSourceIndex, UIEditorTabStripInvalidIndex);
}
TEST(UIEditorTabStripInteractionTest, FocusLostCancelsActiveTabDragAndClearsPreview) {
const auto items = BuildTabItems();
std::string selectedTabId = "doc-a";
UIEditorTabStripInteractionState state = {};
const auto initialFrame = UpdateUIEditorTabStripInteraction(
state,
selectedTabId,
UIRect(0.0f, 0.0f, 320.0f, 180.0f),
items,
{});
const UIPoint sourceCenter = RectCenter(initialFrame.layout.tabHeaderRects[0]);
const UIPoint dragPoint(
initialFrame.layout.tabHeaderRects[2].x + 8.0f,
sourceCenter.y);
auto frame = UpdateUIEditorTabStripInteraction(
state,
selectedTabId,
UIRect(0.0f, 0.0f, 320.0f, 180.0f),
items,
{
MakePointerDown(sourceCenter.x, sourceCenter.y),
MakePointerMove(dragPoint.x, dragPoint.y)
});
ASSERT_TRUE(frame.result.dragStarted);
ASSERT_TRUE(frame.result.reorderPreviewActive);
frame = UpdateUIEditorTabStripInteraction(
state,
selectedTabId,
UIRect(0.0f, 0.0f, 320.0f, 180.0f),
items,
{ MakeFocusLost() });
EXPECT_TRUE(frame.result.dragCanceled);
EXPECT_TRUE(frame.result.releasePointerCapture);
EXPECT_FALSE(frame.result.reorderRequested);
EXPECT_FALSE(state.tabStripState.focused);
EXPECT_FALSE(state.reorderCaptureActive);
EXPECT_EQ(state.reorderPreviewIndex, UIEditorTabStripInvalidIndex);
EXPECT_FALSE(frame.layout.insertionPreview.visible);
}
TEST(UIEditorTabStripInteractionTest, VisibleInsertionIndexTracksHeaderGapsInsteadOfFinalTabIndices) {
const auto items = BuildTabItems();
std::string selectedTabId = "doc-b";
UIEditorTabStripInteractionState state = {};
const auto initialFrame = UpdateUIEditorTabStripInteraction(
state,
selectedTabId,
UIRect(0.0f, 0.0f, 320.0f, 180.0f),
items,
{});
const UIPoint sourceCenter = RectCenter(initialFrame.layout.tabHeaderRects[1]);
const float betweenFirstAndSecond =
(initialFrame.layout.tabHeaderRects[0].x + initialFrame.layout.tabHeaderRects[0].width +
initialFrame.layout.tabHeaderRects[1].x) * 0.5f;
const auto frame = UpdateUIEditorTabStripInteraction(
state,
selectedTabId,
UIRect(0.0f, 0.0f, 320.0f, 180.0f),
items,
{
MakePointerDown(sourceCenter.x, sourceCenter.y),
MakePointerMove(betweenFirstAndSecond, sourceCenter.y)
});
EXPECT_TRUE(frame.result.requestPointerCapture);
EXPECT_TRUE(frame.result.reorderPreviewActive);
EXPECT_EQ(frame.result.dragSourceIndex, 1u);
EXPECT_EQ(frame.result.dropInsertionIndex, 1u);
EXPECT_EQ(frame.result.reorderToIndex, 1u);
EXPECT_EQ(frame.result.reorderPreviewIndex, 1u);
}

4
tests/UI/Editor/unit/test_ui_editor_viewport_shell.cpp
View File

@@ -37,9 +37,9 @@ TEST(UIEditorViewportShellTest, ResolveRequestUsesViewportInputRectSize) {
spec);
EXPECT_FLOAT_EQ(request.slotLayout.inputRect.width, 800.0f);
EXPECT_FLOAT_EQ(request.slotLayout.inputRect.height, 532.0f);
EXPECT_FLOAT_EQ(request.slotLayout.inputRect.height, 554.0f);
EXPECT_FLOAT_EQ(request.requestedViewportSize.width, 800.0f);
EXPECT_FLOAT_EQ(request.requestedViewportSize.height, 532.0f);
EXPECT_FLOAT_EQ(request.requestedViewportSize.height, 554.0f);
}
TEST(UIEditorViewportShellTest, ResolveRequestTracksChromeBarVisibility) {

12
tests/UI/Editor/unit/test_ui_editor_viewport_slot.cpp
View File

@@ -92,7 +92,7 @@ TEST(UIEditorViewportSlotTest, DesiredToolWidthUsesExplicitValueBeforeEstimatedL
inferredWidth.label = "Scene";
EXPECT_FLOAT_EQ(ResolveUIEditorViewportSlotDesiredToolWidth(explicitWidth), 88.0f);
EXPECT_FLOAT_EQ(ResolveUIEditorViewportSlotDesiredToolWidth(inferredWidth), 55.0f);
EXPECT_FLOAT_EQ(ResolveUIEditorViewportSlotDesiredToolWidth(inferredWidth), 48.5f);
}
TEST(UIEditorViewportSlotTest, LayoutBuildsTopBarSurfaceBottomBarAndAspectFittedTexture) {
@@ -142,12 +142,12 @@ TEST(UIEditorViewportSlotTest, ToolItemsAlignToEdgesAndTitleRectClampsBetweenToo
BuildToolItems(),
{});
EXPECT_FLOAT_EQ(layout.toolItemRects[0].x, 12.0f);
EXPECT_FLOAT_EQ(layout.toolItemRects[0].x, 8.0f);
EXPECT_FLOAT_EQ(layout.toolItemRects[0].width, 96.0f);
EXPECT_FLOAT_EQ(layout.toolItemRects[1].x, 762.0f);
EXPECT_FLOAT_EQ(layout.toolItemRects[2].x, 816.0f);
EXPECT_FLOAT_EQ(layout.titleRect.x, 118.0f);
EXPECT_FLOAT_EQ(layout.titleRect.width, 634.0f);
EXPECT_FLOAT_EQ(layout.toolItemRects[1].x, 768.0f);
EXPECT_FLOAT_EQ(layout.toolItemRects[2].x, 820.0f);
EXPECT_FLOAT_EQ(layout.titleRect.x, 110.0f);
EXPECT_FLOAT_EQ(layout.titleRect.width, 652.0f);
}
TEST(UIEditorViewportSlotTest, HitTestPrioritizesToolThenStatusThenSurface) {

238
tests/UI/Editor/unit/test_ui_editor_workspace_controller.cpp
View File

@@ -2,6 +2,8 @@
#include <XCEditor/Shell/UIEditorWorkspaceController.h>
#include <string>
namespace {
using XCEngine::UI::Editor::BuildDefaultUIEditorWorkspaceController;
@@ -9,6 +11,9 @@ using XCEngine::UI::Editor::BuildDefaultUIEditorWorkspaceSession;
using XCEngine::UI::Editor::BuildUIEditorWorkspacePanel;
using XCEngine::UI::Editor::BuildUIEditorWorkspaceSplit;
using XCEngine::UI::Editor::BuildUIEditorWorkspaceTabStack;
using XCEngine::UI::Editor::AreUIEditorWorkspaceModelsEquivalent;
using XCEngine::UI::Editor::FindUIEditorPanelSessionState;
using XCEngine::UI::Editor::FindUIEditorWorkspaceNode;
using XCEngine::UI::Editor::GetUIEditorWorkspaceCommandKindName;
using XCEngine::UI::Editor::GetUIEditorWorkspaceCommandStatusName;
using XCEngine::UI::Editor::UIEditorPanelRegistry;
@@ -17,7 +22,11 @@ using XCEngine::UI::Editor::UIEditorWorkspaceCommandKind;
using XCEngine::UI::Editor::UIEditorWorkspaceCommandStatus;
using XCEngine::UI::Editor::UIEditorWorkspaceControllerValidationCode;
using XCEngine::UI::Editor::UIEditorWorkspaceController;
using XCEngine::UI::Editor::UIEditorWorkspaceDockPlacement;
using XCEngine::UI::Editor::UIEditorWorkspaceLayoutOperationStatus;
using XCEngine::UI::Editor::UIEditorWorkspaceModel;
using XCEngine::UI::Editor::UIEditorWorkspaceNode;
using XCEngine::UI::Editor::UIEditorWorkspaceSession;
using XCEngine::UI::Editor::UIEditorWorkspaceSplitAxis;
UIEditorPanelRegistry BuildPanelRegistry() {
@@ -25,6 +34,9 @@ UIEditorPanelRegistry BuildPanelRegistry() {
registry.panels = {
{ "doc-a", "Document A", {}, true, true, true },
{ "doc-b", "Document B", {}, true, true, true },
{ "doc-c", "Document C", {}, true, true, true },
{ "hidden-a", "Hidden A", {}, true, true, true },
{ "hidden-b", "Hidden B", {}, true, true, true },
{ "details", "Details", {}, true, true, true },
{ "root", "Root", {}, true, false, false }
};
@@ -49,6 +61,34 @@ UIEditorWorkspaceModel BuildWorkspace() {
return workspace;
}
UIEditorWorkspaceModel BuildReorderWorkspace() {
UIEditorWorkspaceModel workspace = {};
workspace.root = BuildUIEditorWorkspaceTabStack(
"document-tabs",
{
BuildUIEditorWorkspacePanel("doc-a-node", "doc-a", "Document A", true),
BuildUIEditorWorkspacePanel("hidden-a-node", "hidden-a", "Hidden A", true),
BuildUIEditorWorkspacePanel("doc-b-node", "doc-b", "Document B", true),
BuildUIEditorWorkspacePanel("hidden-b-node", "hidden-b", "Hidden B", true),
BuildUIEditorWorkspacePanel("doc-c-node", "doc-c", "Document C", true)
},
2u);
workspace.activePanelId = "doc-b";
return workspace;
}
UIEditorWorkspaceSession BuildReorderSession() {
UIEditorWorkspaceSession session = {};
session.panelStates = {
{ "doc-a", true, true },
{ "hidden-a", true, false },
{ "doc-b", true, true },
{ "hidden-b", true, false },
{ "doc-c", true, true }
};
return session;
}
} // namespace
TEST(UIEditorWorkspaceControllerTest, CommandNameHelpersExposeStableDebugNames) {
@@ -146,3 +186,201 @@ TEST(UIEditorWorkspaceControllerTest, RejectsUnknownPanelAndNonCloseablePanelCom
EXPECT_EQ(nonCloseable.status, UIEditorWorkspaceCommandStatus::Rejected);
EXPECT_EQ(rootController.GetWorkspace().activePanelId, "root");
}
TEST(UIEditorWorkspaceControllerTest, ReorderTabUsesModelSurgeryAndPreservesSelectionActiveAndSession) {
UIEditorWorkspaceController controller(
BuildPanelRegistry(),
BuildReorderWorkspace(),
BuildReorderSession());
const auto result = controller.ReorderTab("document-tabs", "doc-c", 0u);
EXPECT_EQ(result.status, UIEditorWorkspaceLayoutOperationStatus::Changed);
EXPECT_EQ(result.activePanelId, "doc-b");
ASSERT_EQ(result.visiblePanelIds.size(), 1u);
EXPECT_EQ(result.visiblePanelIds[0], "doc-b");
const UIEditorWorkspaceNode* tabStack =
FindUIEditorWorkspaceNode(controller.GetWorkspace(), "document-tabs");
ASSERT_NE(tabStack, nullptr);
ASSERT_EQ(tabStack->children.size(), 5u);
EXPECT_EQ(tabStack->children[0].panel.panelId, "doc-c");
EXPECT_EQ(tabStack->children[1].panel.panelId, "hidden-a");
EXPECT_EQ(tabStack->children[2].panel.panelId, "doc-a");
EXPECT_EQ(tabStack->children[3].panel.panelId, "hidden-b");
EXPECT_EQ(tabStack->children[4].panel.panelId, "doc-b");
EXPECT_EQ(tabStack->selectedTabIndex, 4u);
const auto* hiddenState =
FindUIEditorPanelSessionState(controller.GetSession(), "hidden-a");
ASSERT_NE(hiddenState, nullptr);
EXPECT_TRUE(hiddenState->open);
EXPECT_FALSE(hiddenState->visible);
}
TEST(UIEditorWorkspaceControllerTest, ReorderTabRejectsHiddenPanelsAndOutOfRangeTargetsAndReportsNoOp) {
UIEditorWorkspaceController controller(
BuildPanelRegistry(),
BuildReorderWorkspace(),
BuildReorderSession());
const auto hidden = controller.ReorderTab("document-tabs", "hidden-a", 0u);
EXPECT_EQ(hidden.status, UIEditorWorkspaceLayoutOperationStatus::Rejected);
const auto outOfRange = controller.ReorderTab("document-tabs", "doc-a", 4u);
EXPECT_EQ(outOfRange.status, UIEditorWorkspaceLayoutOperationStatus::Rejected);
const auto noOp = controller.ReorderTab("document-tabs", "doc-a", 0u);
EXPECT_EQ(noOp.status, UIEditorWorkspaceLayoutOperationStatus::NoOp);
}
TEST(UIEditorWorkspaceControllerTest, MoveTabToStackMovesVisibleTabAcrossStacks) {
UIEditorWorkspaceModel workspace = {};
workspace.root = BuildUIEditorWorkspaceSplit(
"root-split",
UIEditorWorkspaceSplitAxis::Horizontal,
0.55f,
BuildUIEditorWorkspaceTabStack(
"left-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";
UIEditorWorkspaceSession session = {};
session.panelStates = {
{ "doc-a", true, true },
{ "doc-b", true, true },
{ "details", true, true }
};
UIEditorWorkspaceController controller(BuildPanelRegistry(), workspace, session);
const auto result = controller.MoveTabToStack("left-tabs", "doc-b", "details-node", 1u);
EXPECT_EQ(result.status, UIEditorWorkspaceLayoutOperationStatus::Changed);
EXPECT_EQ(result.activePanelId, "doc-b");
const UIEditorWorkspaceNode* leftTabs =
FindUIEditorWorkspaceNode(controller.GetWorkspace(), "left-tabs");
const UIEditorWorkspaceNode* detailsTabs =
FindUIEditorWorkspaceNode(controller.GetWorkspace(), "details-node");
ASSERT_NE(leftTabs, nullptr);
ASSERT_NE(detailsTabs, nullptr);
ASSERT_EQ(leftTabs->children.size(), 1u);
ASSERT_EQ(detailsTabs->children.size(), 2u);
EXPECT_EQ(detailsTabs->children[1].panel.panelId, "doc-b");
}
TEST(UIEditorWorkspaceControllerTest, DockTabRelativeCreatesSplitAroundTargetStack) {
UIEditorWorkspaceModel workspace = {};
workspace.root = BuildUIEditorWorkspaceSplit(
"root-split",
UIEditorWorkspaceSplitAxis::Horizontal,
0.55f,
BuildUIEditorWorkspaceTabStack(
"left-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";
UIEditorWorkspaceSession session = {};
session.panelStates = {
{ "doc-a", true, true },
{ "doc-b", true, true },
{ "details", true, true }
};
UIEditorWorkspaceController controller(BuildPanelRegistry(), workspace, session);
const auto result = controller.DockTabRelative(
"left-tabs",
"doc-b",
"details-node",
UIEditorWorkspaceDockPlacement::Bottom,
0.4f);
EXPECT_EQ(result.status, UIEditorWorkspaceLayoutOperationStatus::Changed);
EXPECT_EQ(result.activePanelId, "doc-b");
const UIEditorWorkspaceNode* detailsTabs =
FindUIEditorWorkspaceNode(controller.GetWorkspace(), "details-node");
ASSERT_NE(detailsTabs, nullptr);
EXPECT_EQ(detailsTabs->kind, XCEngine::UI::Editor::UIEditorWorkspaceNodeKind::TabStack);
bool foundDockedTab = false;
for (const std::string candidate : { "details-node__dock_doc-b_stack", "details-node__dock_doc-b_stack-1" }) {
const UIEditorWorkspaceNode* docked =
FindUIEditorWorkspaceNode(controller.GetWorkspace(), candidate);
if (docked != nullptr) {
foundDockedTab = docked->children.size() == 1u &&
docked->children[0].panel.panelId == "doc-b";
if (foundDockedTab) {
break;
}
}
}
EXPECT_TRUE(foundDockedTab);
}
TEST(UIEditorWorkspaceControllerTest, DockTabRelativeReturnsNoOpWhenRedockingAlreadyDockedSingleTabStack) {
UIEditorWorkspaceModel workspace = {};
workspace.root = BuildUIEditorWorkspaceSplit(
"root-split",
UIEditorWorkspaceSplitAxis::Horizontal,
0.55f,
BuildUIEditorWorkspaceTabStack(
"left-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";
UIEditorWorkspaceSession session = {};
session.panelStates = {
{ "doc-a", true, true },
{ "doc-b", true, true },
{ "details", true, true }
};
UIEditorWorkspaceController controller(BuildPanelRegistry(), workspace, session);
const auto first = controller.DockTabRelative(
"left-tabs",
"doc-b",
"details-node",
UIEditorWorkspaceDockPlacement::Bottom,
0.4f);
ASSERT_EQ(first.status, UIEditorWorkspaceLayoutOperationStatus::Changed);
std::string movedStackId = {};
for (const std::string candidate : { "details-node__dock_doc-b_stack", "details-node__dock_doc-b_stack-1" }) {
if (FindUIEditorWorkspaceNode(controller.GetWorkspace(), candidate) != nullptr) {
movedStackId = candidate;
break;
}
}
ASSERT_FALSE(movedStackId.empty());
const UIEditorWorkspaceModel afterFirstDock = controller.GetWorkspace();
const auto second = controller.DockTabRelative(
movedStackId,
"doc-b",
"details-node",
UIEditorWorkspaceDockPlacement::Bottom,
0.4f);
EXPECT_EQ(second.status, UIEditorWorkspaceLayoutOperationStatus::NoOp);
EXPECT_EQ(second.activePanelId, "doc-b");
EXPECT_TRUE(
AreUIEditorWorkspaceModelsEquivalent(
controller.GetWorkspace(),
afterFirstDock));
}

332
tests/UI/Editor/unit/test_ui_editor_workspace_model.cpp
View File

@@ -1,6 +1,7 @@
#include <gtest/gtest.h>
#include <XCEditor/Shell/UIEditorWorkspaceModel.h>
#include <XCEditor/Shell/UIEditorWorkspaceSession.h>
#include <algorithm>
#include <string>
@@ -12,17 +13,25 @@ using XCEngine::UI::Editor::BuildUIEditorWorkspacePanel;
using XCEngine::UI::Editor::BuildUIEditorWorkspaceSingleTabStack;
using XCEngine::UI::Editor::BuildUIEditorWorkspaceSplit;
using XCEngine::UI::Editor::BuildUIEditorWorkspaceTabStack;
using XCEngine::UI::Editor::AreUIEditorWorkspaceModelsEquivalent;
using XCEngine::UI::Editor::CanonicalizeUIEditorWorkspaceModel;
using XCEngine::UI::Editor::CollectUIEditorWorkspaceVisiblePanels;
using XCEngine::UI::Editor::ContainsUIEditorWorkspacePanel;
using XCEngine::UI::Editor::FindUIEditorWorkspaceActivePanel;
using XCEngine::UI::Editor::FindUIEditorWorkspaceNode;
using XCEngine::UI::Editor::TryActivateUIEditorWorkspacePanel;
using XCEngine::UI::Editor::TryDockUIEditorWorkspaceTabRelative;
using XCEngine::UI::Editor::TryMoveUIEditorWorkspaceTabToStack;
using XCEngine::UI::Editor::TryReorderUIEditorWorkspaceTab;
using XCEngine::UI::Editor::TrySetUIEditorWorkspaceSplitRatio;
using XCEngine::UI::Editor::UIEditorWorkspaceDockPlacement;
using XCEngine::UI::Editor::UIEditorWorkspaceModel;
using XCEngine::UI::Editor::UIEditorWorkspaceNode;
using XCEngine::UI::Editor::UIEditorWorkspaceSession;
using XCEngine::UI::Editor::UIEditorWorkspaceNodeKind;
using XCEngine::UI::Editor::UIEditorWorkspaceSplitAxis;
using XCEngine::UI::Editor::UIEditorWorkspaceValidationCode;
using XCEngine::UI::Editor::UIEditorWorkspaceVisiblePanel;
using XCEngine::UI::Editor::ValidateUIEditorWorkspace;
std::vector<std::string> CollectVisiblePanelIds(const UIEditorWorkspaceModel& workspace) {
@@ -170,6 +179,78 @@ TEST(UIEditorWorkspaceModelTest, SplitRatioMutationTargetsSplitNodeAndRejectsInv
EXPECT_FALSE(TrySetUIEditorWorkspaceSplitRatio(workspace, "root-split", 1.0f));
}
TEST(UIEditorWorkspaceModelTest, ReorderTabMovesVisibleTabsAndPreservesHiddenOrderSelectionAndActivePanel) {
UIEditorWorkspaceModel workspace = {};
workspace.root = BuildUIEditorWorkspaceTabStack(
"document-tabs",
{
BuildUIEditorWorkspacePanel("doc-a-node", "doc-a", "Document A", true),
BuildUIEditorWorkspacePanel("hidden-a-node", "hidden-a", "Hidden A", true),
BuildUIEditorWorkspacePanel("doc-b-node", "doc-b", "Document B", true),
BuildUIEditorWorkspacePanel("hidden-b-node", "hidden-b", "Hidden B", true),
BuildUIEditorWorkspacePanel("doc-c-node", "doc-c", "Document C", true)
},
2u);
workspace.activePanelId = "doc-b";
UIEditorWorkspaceSession session = {};
session.panelStates = {
{ "doc-a", true, true },
{ "hidden-a", true, false },
{ "doc-b", true, true },
{ "hidden-b", true, false },
{ "doc-c", true, true }
};
ASSERT_TRUE(TryReorderUIEditorWorkspaceTab(
workspace,
session,
"document-tabs",
"doc-c",
0u));
const UIEditorWorkspaceNode* tabStack =
FindUIEditorWorkspaceNode(workspace, "document-tabs");
ASSERT_NE(tabStack, nullptr);
ASSERT_EQ(tabStack->children.size(), 5u);
EXPECT_EQ(tabStack->children[0].panel.panelId, "doc-c");
EXPECT_EQ(tabStack->children[1].panel.panelId, "hidden-a");
EXPECT_EQ(tabStack->children[2].panel.panelId, "doc-a");
EXPECT_EQ(tabStack->children[3].panel.panelId, "hidden-b");
EXPECT_EQ(tabStack->children[4].panel.panelId, "doc-b");
EXPECT_EQ(tabStack->selectedTabIndex, 4u);
EXPECT_EQ(workspace.activePanelId, "doc-b");
EXPECT_FALSE(TryReorderUIEditorWorkspaceTab(
workspace,
session,
"document-tabs",
"hidden-a",
0u));
ASSERT_TRUE(TryReorderUIEditorWorkspaceTab(
workspace,
session,
"document-tabs",
"doc-a",
3u));
tabStack = FindUIEditorWorkspaceNode(workspace, "document-tabs");
ASSERT_NE(tabStack, nullptr);
EXPECT_EQ(tabStack->children[0].panel.panelId, "doc-c");
EXPECT_EQ(tabStack->children[1].panel.panelId, "hidden-a");
EXPECT_EQ(tabStack->children[2].panel.panelId, "doc-b");
EXPECT_EQ(tabStack->children[3].panel.panelId, "hidden-b");
EXPECT_EQ(tabStack->children[4].panel.panelId, "doc-a");
EXPECT_EQ(tabStack->selectedTabIndex, 2u);
EXPECT_FALSE(TryReorderUIEditorWorkspaceTab(
workspace,
session,
"document-tabs",
"doc-a",
4u));
}
TEST(UIEditorWorkspaceModelTest, CanonicalizeWrapsStandalonePanelsIntoSingleTabStacks) {
UIEditorWorkspaceModel workspace = {};
workspace.root = BuildUIEditorWorkspaceSplit(
@@ -195,3 +276,254 @@ TEST(UIEditorWorkspaceModelTest, CanonicalizeWrapsStandalonePanelsIntoSingleTabS
"left");
EXPECT_EQ(canonicalWorkspace.root.children[1].kind, UIEditorWorkspaceNodeKind::TabStack);
}
TEST(UIEditorWorkspaceModelTest, MoveTabToStackMergesIntoTargetStackAndActivatesMovedPanel) {
UIEditorWorkspaceModel workspace = {};
workspace.root = BuildUIEditorWorkspaceSplit(
"root-split",
UIEditorWorkspaceSplitAxis::Horizontal,
0.58f,
BuildUIEditorWorkspaceTabStack(
"left-tabs",
{
BuildUIEditorWorkspacePanel("doc-a-node", "doc-a", "Document A", true),
BuildUIEditorWorkspacePanel("doc-b-node", "doc-b", "Document B", true)
},
0u),
BuildUIEditorWorkspaceSingleTabStack(
"right-tabs",
"details",
"Details",
true));
workspace.activePanelId = "doc-a";
UIEditorWorkspaceSession session = {};
session.panelStates = {
{ "doc-a", true, true },
{ "doc-b", true, true },
{ "details", true, true }
};
ASSERT_TRUE(TryMoveUIEditorWorkspaceTabToStack(
workspace,
session,
"left-tabs",
"doc-b",
"right-tabs",
1u));
const UIEditorWorkspaceNode* leftTabs =
FindUIEditorWorkspaceNode(workspace, "left-tabs");
const UIEditorWorkspaceNode* rightTabs =
FindUIEditorWorkspaceNode(workspace, "right-tabs");
ASSERT_NE(leftTabs, nullptr);
ASSERT_NE(rightTabs, nullptr);
ASSERT_EQ(leftTabs->children.size(), 1u);
ASSERT_EQ(rightTabs->children.size(), 2u);
EXPECT_EQ(leftTabs->children[0].panel.panelId, "doc-a");
EXPECT_EQ(rightTabs->children[0].panel.panelId, "details");
EXPECT_EQ(rightTabs->children[1].panel.panelId, "doc-b");
EXPECT_EQ(rightTabs->selectedTabIndex, 1u);
EXPECT_EQ(workspace.activePanelId, "doc-b");
}
TEST(UIEditorWorkspaceModelTest, DockTabRelativeSplitsTargetStackAndCreatesNewLeaf) {
UIEditorWorkspaceModel workspace = {};
workspace.root = BuildUIEditorWorkspaceSplit(
"root-split",
UIEditorWorkspaceSplitAxis::Horizontal,
0.58f,
BuildUIEditorWorkspaceTabStack(
"left-tabs",
{
BuildUIEditorWorkspacePanel("doc-a-node", "doc-a", "Document A", true),
BuildUIEditorWorkspacePanel("doc-b-node", "doc-b", "Document B", true)
},
0u),
BuildUIEditorWorkspaceSingleTabStack(
"right-tabs",
"details",
"Details",
true));
workspace.activePanelId = "doc-a";
UIEditorWorkspaceSession session = {};
session.panelStates = {
{ "doc-a", true, true },
{ "doc-b", true, true },
{ "details", true, true }
};
ASSERT_TRUE(TryDockUIEditorWorkspaceTabRelative(
workspace,
session,
"left-tabs",
"doc-b",
"right-tabs",
UIEditorWorkspaceDockPlacement::Bottom,
0.4f));
const UIEditorWorkspaceNode* rightTabs =
FindUIEditorWorkspaceNode(workspace, "right-tabs");
ASSERT_NE(rightTabs, nullptr);
ASSERT_EQ(rightTabs->kind, UIEditorWorkspaceNodeKind::TabStack);
ASSERT_EQ(rightTabs->children.size(), 1u);
EXPECT_EQ(rightTabs->children[0].panel.panelId, "details");
const UIEditorWorkspaceNode* movedTabStack = nullptr;
if (const UIEditorWorkspaceNode* rootSplit =
FindUIEditorWorkspaceNode(workspace, "root-split");
rootSplit != nullptr) {
const auto visibleIds = CollectVisiblePanelIds(workspace);
ASSERT_EQ(visibleIds.size(), 3u);
EXPECT_EQ(visibleIds[0], "doc-a");
EXPECT_EQ(visibleIds[1], "details");
EXPECT_EQ(visibleIds[2], "doc-b");
}
const std::vector<UIEditorWorkspaceVisiblePanel> visiblePanels =
CollectUIEditorWorkspaceVisiblePanels(workspace);
ASSERT_EQ(visiblePanels.size(), 3u);
EXPECT_EQ(visiblePanels[2].panelId, "doc-b");
for (const std::string candidate : { "right-tabs__dock_doc-b_stack", "right-tabs__dock_doc-b_stack-1" }) {
movedTabStack = FindUIEditorWorkspaceNode(workspace, candidate);
if (movedTabStack != nullptr) {
break;
}
}
ASSERT_NE(movedTabStack, nullptr);
ASSERT_EQ(movedTabStack->kind, UIEditorWorkspaceNodeKind::TabStack);
ASSERT_EQ(movedTabStack->children.size(), 1u);
EXPECT_EQ(movedTabStack->children[0].panel.panelId, "doc-b");
EXPECT_EQ(workspace.activePanelId, "doc-b");
}
TEST(UIEditorWorkspaceModelTest, DockTabRelativeCanRedockSingleTabBranchBackOntoSiblingStack) {
UIEditorWorkspaceModel workspace = {};
workspace.root = BuildUIEditorWorkspaceTabStack(
"center-tabs",
{
BuildUIEditorWorkspacePanel("scene-node", "scene", "Scene", true),
BuildUIEditorWorkspacePanel("game-node", "game", "Game", true)
},
0u);
workspace.activePanelId = "scene";
UIEditorWorkspaceSession session = {};
session.panelStates = {
{ "scene", true, true },
{ "game", true, true }
};
ASSERT_TRUE(TryDockUIEditorWorkspaceTabRelative(
workspace,
session,
"center-tabs",
"scene",
"center-tabs",
UIEditorWorkspaceDockPlacement::Top,
0.5f));
const UIEditorWorkspaceNode* firstDockStack =
FindUIEditorWorkspaceNode(workspace, "center-tabs__dock_scene_stack");
ASSERT_NE(firstDockStack, nullptr);
ASSERT_EQ(firstDockStack->kind, UIEditorWorkspaceNodeKind::TabStack);
ASSERT_EQ(firstDockStack->children.size(), 1u);
EXPECT_EQ(firstDockStack->children[0].panel.panelId, "scene");
ASSERT_TRUE(TryDockUIEditorWorkspaceTabRelative(
workspace,
session,
"center-tabs__dock_scene_stack",
"scene",
"center-tabs",
UIEditorWorkspaceDockPlacement::Top,
0.5f));
const auto validation = ValidateUIEditorWorkspace(workspace);
ASSERT_TRUE(validation.IsValid()) << validation.message;
const std::vector<UIEditorWorkspaceVisiblePanel> visiblePanels =
CollectUIEditorWorkspaceVisiblePanels(workspace);
ASSERT_EQ(visiblePanels.size(), 2u);
EXPECT_EQ(visiblePanels[0].panelId, "scene");
EXPECT_EQ(visiblePanels[1].panelId, "game");
EXPECT_EQ(workspace.activePanelId, "scene");
}
TEST(UIEditorWorkspaceModelTest, DockTabRelativeCanRedockGeneratedSingleTabStackWithoutChangingLayout) {
UIEditorWorkspaceModel workspace = {};
workspace.root = BuildUIEditorWorkspaceSplit(
"root-split",
UIEditorWorkspaceSplitAxis::Horizontal,
0.58f,
BuildUIEditorWorkspaceTabStack(
"left-tabs",
{
BuildUIEditorWorkspacePanel("doc-a-node", "doc-a", "Document A", true),
BuildUIEditorWorkspacePanel("doc-b-node", "doc-b", "Document B", true)
},
0u),
BuildUIEditorWorkspaceSingleTabStack(
"right-tabs",
"details",
"Details",
true));
workspace.activePanelId = "doc-a";
UIEditorWorkspaceSession session = {};
session.panelStates = {
{ "doc-a", true, true },
{ "doc-b", true, true },
{ "details", true, true }
};
ASSERT_TRUE(TryDockUIEditorWorkspaceTabRelative(
workspace,
session,
"left-tabs",
"doc-b",
"right-tabs",
UIEditorWorkspaceDockPlacement::Bottom,
0.4f));
std::string movedStackId = {};
for (const std::string candidate : { "right-tabs__dock_doc-b_stack", "right-tabs__dock_doc-b_stack-1" }) {
if (FindUIEditorWorkspaceNode(workspace, candidate) != nullptr) {
movedStackId = candidate;
break;
}
}
ASSERT_FALSE(movedStackId.empty());
const UIEditorWorkspaceModel afterFirstDock = workspace;
ASSERT_TRUE(TryDockUIEditorWorkspaceTabRelative(
workspace,
session,
movedStackId,
"doc-b",
"right-tabs",
UIEditorWorkspaceDockPlacement::Bottom,
0.4f));
const auto validation = ValidateUIEditorWorkspace(workspace);
ASSERT_TRUE(validation.IsValid()) << validation.message;
EXPECT_TRUE(AreUIEditorWorkspaceModelsEquivalent(workspace, afterFirstDock));
EXPECT_EQ(workspace.activePanelId, "doc-b");
const UIEditorWorkspaceNode* rightTabs =
FindUIEditorWorkspaceNode(workspace, "right-tabs");
ASSERT_NE(rightTabs, nullptr);
EXPECT_EQ(rightTabs->kind, UIEditorWorkspaceNodeKind::TabStack);
ASSERT_EQ(rightTabs->children.size(), 1u);
EXPECT_EQ(rightTabs->children[0].panel.panelId, "details");
const UIEditorWorkspaceNode* movedTabStack =
FindUIEditorWorkspaceNode(workspace, movedStackId);
ASSERT_NE(movedTabStack, nullptr);
ASSERT_EQ(movedTabStack->kind, UIEditorWorkspaceNodeKind::TabStack);
ASSERT_EQ(movedTabStack->children.size(), 1u);
EXPECT_EQ(movedTabStack->children[0].panel.panelId, "doc-b");
}