357 lines
12 KiB
C++
357 lines
12 KiB
C++
#include "Platform/Win32/WindowManager/Internal.h"
|
|
|
|
#include "Platform/Win32/WindowManager/CrossWindowDropInternal.h"
|
|
#include "State/EditorContext.h"
|
|
#include "Platform/Win32/EditorWindow.h"
|
|
|
|
#include <XCEditor/Workspace/UIEditorWindowWorkspaceController.h>
|
|
|
|
#include <algorithm>
|
|
#include <cmath>
|
|
|
|
namespace XCEngine::UI::Editor::App::Internal {
|
|
|
|
namespace {
|
|
|
|
using Win32::Internal::CrossWindowDockDropTarget;
|
|
using Win32::Internal::TryResolveCrossWindowDockDropTarget;
|
|
|
|
constexpr LONG kFallbackDragHotspotX = 40;
|
|
constexpr LONG kFallbackDragHotspotY = 12;
|
|
|
|
POINT BuildFallbackGlobalTabDragHotspot() {
|
|
POINT hotspot = {};
|
|
hotspot.x = kFallbackDragHotspotX;
|
|
hotspot.y = kFallbackDragHotspotY;
|
|
return hotspot;
|
|
}
|
|
|
|
float ResolveWindowDpiScale(HWND hwnd) {
|
|
if (hwnd == nullptr) {
|
|
return 1.0f;
|
|
}
|
|
|
|
const UINT dpi = GetDpiForWindow(hwnd);
|
|
return dpi == 0u ? 1.0f : static_cast<float>(dpi) / 96.0f;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
bool EditorWindowWorkspaceCoordinator::IsGlobalTabDragActive() const {
|
|
return m_globalTabDragSession.active;
|
|
}
|
|
|
|
bool EditorWindowWorkspaceCoordinator::OwnsActiveGlobalTabDrag(std::string_view windowId) const {
|
|
return m_globalTabDragSession.active &&
|
|
m_globalTabDragSession.panelWindowId == windowId;
|
|
}
|
|
|
|
void EditorWindowWorkspaceCoordinator::BeginGlobalTabDragSession(
|
|
std::string_view panelWindowId,
|
|
std::string_view sourceNodeId,
|
|
std::string_view panelId,
|
|
const POINT& screenPoint,
|
|
const POINT& dragHotspot) {
|
|
m_globalTabDragSession.active = true;
|
|
m_globalTabDragSession.panelWindowId = std::string(panelWindowId);
|
|
m_globalTabDragSession.sourceNodeId = std::string(sourceNodeId);
|
|
m_globalTabDragSession.panelId = std::string(panelId);
|
|
m_globalTabDragSession.screenPoint = screenPoint;
|
|
m_globalTabDragSession.dragHotspot = dragHotspot;
|
|
}
|
|
|
|
bool EditorWindowWorkspaceCoordinator::TryResolveGlobalTabDragHotspot(
|
|
const EditorWindow& sourceWindow,
|
|
std::string_view nodeId,
|
|
std::string_view panelId,
|
|
const POINT& screenPoint,
|
|
POINT& outDragHotspot) const {
|
|
const HWND hwnd = sourceWindow.GetHwnd();
|
|
if (hwnd == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
const auto& layout =
|
|
sourceWindow.GetShellFrame().workspaceInteractionFrame.dockHostFrame.layout;
|
|
for (const Widgets::UIEditorDockHostTabStackLayout& tabStack : layout.tabStacks) {
|
|
if (tabStack.nodeId != nodeId) {
|
|
continue;
|
|
}
|
|
|
|
const std::size_t tabCount =
|
|
(std::min)(tabStack.items.size(), tabStack.tabStripLayout.tabHeaderRects.size());
|
|
for (std::size_t index = 0u; index < tabCount; ++index) {
|
|
if (tabStack.items[index].panelId != panelId) {
|
|
continue;
|
|
}
|
|
|
|
const ::XCEngine::UI::UIPoint clientPointDips =
|
|
sourceWindow.ConvertScreenPixelsToClientDips(screenPoint);
|
|
const ::XCEngine::UI::UIRect& tabRect =
|
|
tabStack.tabStripLayout.tabHeaderRects[index];
|
|
const float dpiScale = ResolveWindowDpiScale(hwnd);
|
|
const float localOffsetXDips = (std::clamp)(
|
|
clientPointDips.x - tabRect.x,
|
|
0.0f,
|
|
(std::max)(tabRect.width, 0.0f));
|
|
const float localOffsetYDips = (std::clamp)(
|
|
clientPointDips.y - tabRect.y,
|
|
0.0f,
|
|
(std::max)(tabRect.height, 0.0f));
|
|
outDragHotspot.x = static_cast<LONG>(std::lround(localOffsetXDips * dpiScale));
|
|
outDragHotspot.y = static_cast<LONG>(std::lround(localOffsetYDips * dpiScale));
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void EditorWindowWorkspaceCoordinator::UpdateGlobalTabDragOwnerWindowPosition() {
|
|
if (!m_globalTabDragSession.active) {
|
|
return;
|
|
}
|
|
|
|
EditorWindow* ownerWindow = m_hostRuntime.FindWindow(m_globalTabDragSession.panelWindowId);
|
|
if (ownerWindow == nullptr || ownerWindow->GetHwnd() == nullptr) {
|
|
return;
|
|
}
|
|
|
|
RECT windowRect = {};
|
|
if (!GetWindowRect(ownerWindow->GetHwnd(), &windowRect)) {
|
|
return;
|
|
}
|
|
|
|
const LONG targetLeft =
|
|
m_globalTabDragSession.screenPoint.x - m_globalTabDragSession.dragHotspot.x;
|
|
const LONG targetTop =
|
|
m_globalTabDragSession.screenPoint.y - m_globalTabDragSession.dragHotspot.y;
|
|
if (windowRect.left == targetLeft && windowRect.top == targetTop) {
|
|
return;
|
|
}
|
|
|
|
SetWindowPos(
|
|
ownerWindow->GetHwnd(),
|
|
nullptr,
|
|
targetLeft,
|
|
targetTop,
|
|
0,
|
|
0,
|
|
SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
|
|
}
|
|
|
|
void EditorWindowWorkspaceCoordinator::ClearGlobalTabDragDropPreview() {
|
|
if (m_globalTabDragSession.previewWindowId.empty()) {
|
|
return;
|
|
}
|
|
|
|
if (EditorWindow* previewWindow = m_hostRuntime.FindWindow(m_globalTabDragSession.previewWindowId);
|
|
previewWindow != nullptr) {
|
|
previewWindow->ClearExternalDockHostDropPreview();
|
|
previewWindow->InvalidateHostWindow();
|
|
}
|
|
m_globalTabDragSession.previewWindowId.clear();
|
|
}
|
|
|
|
void EditorWindowWorkspaceCoordinator::UpdateGlobalTabDragDropPreview() {
|
|
if (!m_globalTabDragSession.active) {
|
|
return;
|
|
}
|
|
|
|
EditorWindow* targetWindow = FindTopmostWindowAtScreenPoint(
|
|
m_globalTabDragSession.screenPoint,
|
|
m_globalTabDragSession.panelWindowId);
|
|
if (targetWindow == nullptr || targetWindow->GetHwnd() == nullptr) {
|
|
ClearGlobalTabDragDropPreview();
|
|
return;
|
|
}
|
|
|
|
const ::XCEngine::UI::UIPoint targetPoint =
|
|
targetWindow->ConvertScreenPixelsToClientDips(m_globalTabDragSession.screenPoint);
|
|
const Widgets::UIEditorDockHostLayout& targetLayout =
|
|
targetWindow->GetShellFrame().workspaceInteractionFrame.dockHostFrame.layout;
|
|
CrossWindowDockDropTarget dropTarget = {};
|
|
if (!TryResolveCrossWindowDockDropTarget(targetLayout, targetPoint, dropTarget) ||
|
|
!dropTarget.valid) {
|
|
ClearGlobalTabDragDropPreview();
|
|
return;
|
|
}
|
|
|
|
if (!m_globalTabDragSession.previewWindowId.empty() &&
|
|
m_globalTabDragSession.previewWindowId != targetWindow->GetWindowId()) {
|
|
ClearGlobalTabDragDropPreview();
|
|
}
|
|
|
|
Widgets::UIEditorDockHostDropPreviewState preview = {};
|
|
preview.visible = true;
|
|
preview.sourceNodeId = m_globalTabDragSession.sourceNodeId;
|
|
preview.sourcePanelId = m_globalTabDragSession.panelId;
|
|
preview.targetNodeId = dropTarget.nodeId;
|
|
preview.placement = dropTarget.placement;
|
|
preview.insertionIndex = dropTarget.insertionIndex;
|
|
targetWindow->SetExternalDockHostDropPreview(preview);
|
|
targetWindow->InvalidateHostWindow();
|
|
m_globalTabDragSession.previewWindowId = std::string(targetWindow->GetWindowId());
|
|
}
|
|
|
|
void EditorWindowWorkspaceCoordinator::EndGlobalTabDragSession() {
|
|
if (!m_globalTabDragSession.active) {
|
|
return;
|
|
}
|
|
|
|
ClearGlobalTabDragDropPreview();
|
|
|
|
if (EditorWindow* ownerWindow = m_hostRuntime.FindWindow(m_globalTabDragSession.panelWindowId);
|
|
ownerWindow != nullptr) {
|
|
if (GetCapture() == ownerWindow->GetHwnd()) {
|
|
ReleaseCapture();
|
|
}
|
|
ownerWindow->ResetInteractionState();
|
|
}
|
|
|
|
m_globalTabDragSession = {};
|
|
}
|
|
|
|
bool EditorWindowWorkspaceCoordinator::HandleGlobalTabDragPointerMove(HWND hwnd) {
|
|
if (!m_globalTabDragSession.active) {
|
|
return false;
|
|
}
|
|
|
|
const EditorWindow* ownerWindow = m_hostRuntime.FindWindow(m_globalTabDragSession.panelWindowId);
|
|
if (ownerWindow == nullptr || ownerWindow->GetHwnd() != hwnd) {
|
|
return false;
|
|
}
|
|
|
|
POINT screenPoint = {};
|
|
if (GetCursorPos(&screenPoint)) {
|
|
m_globalTabDragSession.screenPoint = screenPoint;
|
|
UpdateGlobalTabDragOwnerWindowPosition();
|
|
UpdateGlobalTabDragDropPreview();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool EditorWindowWorkspaceCoordinator::TryStartGlobalTabDrag(
|
|
EditorWindow& sourceWindow,
|
|
const EditorWindowPanelTransferRequest& request) {
|
|
POINT dragHotspot = BuildFallbackGlobalTabDragHotspot();
|
|
TryResolveGlobalTabDragHotspot(
|
|
sourceWindow,
|
|
request.nodeId,
|
|
request.panelId,
|
|
request.screenPoint,
|
|
dragHotspot);
|
|
|
|
if (sourceWindow.IsPrimary()) {
|
|
UIEditorWindowWorkspaceController windowWorkspaceController =
|
|
BuildLiveWindowWorkspaceController(sourceWindow.GetWindowId());
|
|
const UIEditorWindowWorkspaceOperationResult result =
|
|
windowWorkspaceController.DetachPanelToNewWindow(
|
|
sourceWindow.GetWindowId(),
|
|
request.nodeId,
|
|
request.panelId);
|
|
if (result.status != UIEditorWindowWorkspaceOperationStatus::Changed) {
|
|
LogRuntimeTrace(
|
|
"drag",
|
|
"failed to start global tab drag from primary window: " + result.message);
|
|
return false;
|
|
}
|
|
|
|
if (!SynchronizeWindowsFromController(
|
|
windowWorkspaceController,
|
|
result.targetWindowId,
|
|
request.screenPoint)) {
|
|
LogRuntimeTrace("drag", "failed to synchronize detached drag window state");
|
|
return false;
|
|
}
|
|
|
|
EditorWindow* detachedWindow = m_hostRuntime.FindWindow(result.targetWindowId);
|
|
if (detachedWindow == nullptr || detachedWindow->GetHwnd() == nullptr) {
|
|
LogRuntimeTrace("drag", "detached drag window was not created.");
|
|
return false;
|
|
}
|
|
|
|
BeginGlobalTabDragSession(
|
|
detachedWindow->GetWindowId(),
|
|
detachedWindow->GetWorkspaceController().GetWorkspace().root.nodeId,
|
|
request.panelId,
|
|
request.screenPoint,
|
|
dragHotspot);
|
|
UpdateGlobalTabDragOwnerWindowPosition();
|
|
SetCapture(detachedWindow->GetHwnd());
|
|
SetForegroundWindow(detachedWindow->GetHwnd());
|
|
LogRuntimeTrace(
|
|
"drag",
|
|
"started global tab drag by detaching panel '" + request.panelId +
|
|
"' into window '" + std::string(detachedWindow->GetWindowId()) + "'");
|
|
return true;
|
|
}
|
|
|
|
sourceWindow.ResetInteractionState();
|
|
BeginGlobalTabDragSession(
|
|
sourceWindow.GetWindowId(),
|
|
request.nodeId,
|
|
request.panelId,
|
|
request.screenPoint,
|
|
dragHotspot);
|
|
UpdateGlobalTabDragOwnerWindowPosition();
|
|
if (sourceWindow.GetHwnd() != nullptr) {
|
|
SetCapture(sourceWindow.GetHwnd());
|
|
}
|
|
LogRuntimeTrace(
|
|
"drag",
|
|
"started global tab drag from detached window '" +
|
|
std::string(sourceWindow.GetWindowId()) +
|
|
"' panel '" + request.panelId + "'");
|
|
return true;
|
|
}
|
|
|
|
EditorWindow* EditorWindowWorkspaceCoordinator::FindTopmostWindowAtScreenPoint(
|
|
const POINT& screenPoint,
|
|
std::string_view excludedWindowId) {
|
|
if (const HWND hitWindow = WindowFromPoint(screenPoint); hitWindow != nullptr) {
|
|
const HWND rootWindow = GetAncestor(hitWindow, GA_ROOT);
|
|
if (EditorWindow* window = m_hostRuntime.FindWindow(rootWindow);
|
|
window != nullptr &&
|
|
window->GetWindowId() != excludedWindowId) {
|
|
return window;
|
|
}
|
|
}
|
|
|
|
for (auto it = m_hostRuntime.GetWindows().rbegin(); it != m_hostRuntime.GetWindows().rend(); ++it) {
|
|
EditorWindow* const window = it->get();
|
|
if (window == nullptr ||
|
|
window->GetHwnd() == nullptr ||
|
|
window->GetWindowId() == excludedWindowId) {
|
|
continue;
|
|
}
|
|
|
|
RECT windowRect = {};
|
|
if (GetWindowRect(window->GetHwnd(), &windowRect) &&
|
|
screenPoint.x >= windowRect.left &&
|
|
screenPoint.x < windowRect.right &&
|
|
screenPoint.y >= windowRect.top &&
|
|
screenPoint.y < windowRect.bottom) {
|
|
return window;
|
|
}
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
const EditorWindow* EditorWindowWorkspaceCoordinator::FindTopmostWindowAtScreenPoint(
|
|
const POINT& screenPoint,
|
|
std::string_view excludedWindowId) const {
|
|
return const_cast<EditorWindowWorkspaceCoordinator*>(this)->FindTopmostWindowAtScreenPoint(
|
|
screenPoint,
|
|
excludedWindowId);
|
|
}
|
|
|
|
void EditorWindowWorkspaceCoordinator::LogRuntimeTrace(
|
|
std::string_view channel,
|
|
std::string_view message) const {
|
|
m_hostRuntime.LogRuntimeTrace(channel, message);
|
|
}
|
|
|
|
} // namespace XCEngine::UI::Editor::App::Internal
|