XCEngine/new_editor/app/Platform/Win32/EditorWindowLifecycle.cpp

#include "Platform/Win32/EditorWindow.h"

#include "Bootstrap/EditorResources.h"
#include "Platform/Win32/EditorWindowConstants.h"
#include "Platform/Win32/EditorWindowInternalState.h"
#include "Platform/Win32/EditorWindowPlatformInternal.h"
#include "Platform/Win32/EditorWindowRuntimeInternal.h"
#include "State/EditorContext.h"

#include <XCEditor/Foundation/UIEditorRuntimeTrace.h>
#include <XCEngine/UI/Types.h>

#include <algorithm>
#include <sstream>

namespace XCEngine::UI::Editor::App::EditorWindowInternal {

UINT QuerySystemDpi() {
    HDC screenDc = GetDC(nullptr);
    if (screenDc == nullptr) {
        return kDefaultDpi;
    }

    const int dpiX = GetDeviceCaps(screenDc, LOGPIXELSX);
    ReleaseDC(nullptr, screenDc);
    return dpiX > 0 ? static_cast<UINT>(dpiX) : kDefaultDpi;
}

UINT QueryWindowDpi(HWND hwnd) {
    if (hwnd != nullptr) {
        const HMODULE user32 = GetModuleHandleW(L"user32.dll");
        if (user32 != nullptr) {
            using GetDpiForWindowFn = UINT(WINAPI*)(HWND);
            const auto getDpiForWindow =
                reinterpret_cast<GetDpiForWindowFn>(GetProcAddress(user32, "GetDpiForWindow"));
            if (getDpiForWindow != nullptr) {
                const UINT dpi = getDpiForWindow(hwnd);
                if (dpi != 0u) {
                    return dpi;
                }
            }
        }
    }

    return QuerySystemDpi();
}

bool ResolveVerboseRuntimeTraceEnabled() {
    wchar_t buffer[8] = {};
    const DWORD length = GetEnvironmentVariableW(
        L"XCUIEDITOR_VERBOSE_TRACE",
        buffer,
        static_cast<DWORD>(std::size(buffer)));
    return length > 0u && buffer[0] != L'0';
}

void LogRuntimeTrace(std::string_view channel, std::string_view message) {
    AppendUIEditorRuntimeTrace(channel, message);
}

bool IsAutoCaptureOnStartupEnabled() {
    return App::Internal::IsEnvironmentFlagEnabled("XCUI_AUTO_CAPTURE_ON_STARTUP");
}

} // namespace XCEngine::UI::Editor::App::EditorWindowInternal

namespace XCEngine::UI::Editor::App {

using namespace EditorWindowInternal;
using ::XCEngine::UI::UIPoint;

EditorWindow::EditorWindow(
    std::string windowId,
    std::wstring title,
    bool primary,
    UIEditorWorkspaceController workspaceController)
    : m_state(std::make_unique<EditorWindowState>()) {
    m_state->window.windowId = std::move(windowId);
    m_state->window.title = std::move(title);
    m_state->window.primary = primary;
    m_state->composition.workspaceController = std::move(workspaceController);
    UpdateCachedTitleText();
}

EditorWindow::~EditorWindow() = default;

std::string_view EditorWindow::GetWindowId() const {
    return m_state->window.windowId;
}

HWND EditorWindow::GetHwnd() const {
    return m_state->window.hwnd;
}

bool EditorWindow::HasHwnd() const {
    return m_state->window.hwnd != nullptr;
}

bool EditorWindow::IsPrimary() const {
    return m_state->window.primary;
}

bool EditorWindow::IsClosing() const {
    return m_state->window.closing;
}

bool EditorWindow::IsRenderReady() const {
    return m_state->render.ready;
}

bool EditorWindow::IsTrackingMouseLeave() const {
    return m_state->input.trackingMouseLeave;
}

bool EditorWindow::HasHoveredBorderlessResizeEdge() const {
    return m_state->chrome.runtime.GetHoveredBorderlessResizeEdge() !=
        Host::BorderlessWindowResizeEdge::None;
}

const std::wstring& EditorWindow::GetTitle() const {
    return m_state->window.title;
}

const UIEditorWorkspaceController& EditorWindow::GetWorkspaceController() const {
    return m_state->composition.workspaceController;
}

UIEditorWorkspaceController& EditorWindow::GetMutableWorkspaceController() {
    return m_state->composition.workspaceController;
}

const EditorShellRuntime& EditorWindow::GetShellRuntime() const {
    return m_state->composition.shellRuntime;
}

EditorShellRuntime& EditorWindow::GetShellRuntime() {
    return m_state->composition.shellRuntime;
}

const UIEditorShellInteractionFrame& EditorWindow::GetShellFrame() const {
    return m_state->composition.shellRuntime.GetShellFrame();
}

const UIEditorShellInteractionState& EditorWindow::GetShellInteractionState() const {
    return m_state->composition.shellRuntime.GetShellInteractionState();
}

void EditorWindow::SetExternalDockHostDropPreview(
    const Widgets::UIEditorDockHostDropPreviewState& preview) {
    m_state->composition.shellRuntime.SetExternalDockHostDropPreview(preview);
}

void EditorWindow::ClearExternalDockHostDropPreview() {
    m_state->composition.shellRuntime.ClearExternalDockHostDropPreview();
}

void EditorWindow::AttachHwnd(HWND hwnd) {
    m_state->window.hwnd = hwnd;
    m_state->window.closing = false;
}

void EditorWindow::MarkDestroyed() {
    m_state->window.hwnd = nullptr;
    m_state->window.closing = false;
    m_state->input.trackingMouseLeave = false;
}

void EditorWindow::MarkClosing() {
    m_state->window.closing = true;
}

void EditorWindow::ClearClosing() {
    m_state->window.closing = false;
}

void EditorWindow::SetTrackingMouseLeave(bool trackingMouseLeave) {
    m_state->input.trackingMouseLeave = trackingMouseLeave;
}

void EditorWindow::SetTitle(std::wstring title) {
    m_state->window.title = std::move(title);
    UpdateCachedTitleText();
}

void EditorWindow::ReplaceWorkspaceController(UIEditorWorkspaceController workspaceController) {
    m_state->composition.workspaceController = std::move(workspaceController);
}

void EditorWindow::InvalidateHostWindow() const {
    if (m_state->window.hwnd != nullptr && IsWindow(m_state->window.hwnd)) {
        InvalidateRect(m_state->window.hwnd, nullptr, FALSE);
    }
}

bool EditorWindow::Initialize(
    const std::filesystem::path& repoRoot,
    EditorContext& editorContext,
    const std::filesystem::path& captureRoot,
    bool autoCaptureOnStartup) {
    if (m_state->window.hwnd == nullptr) {
        LogRuntimeTrace("app", "window initialize skipped: hwnd is null");
        return false;
    }

    Host::RefreshBorderlessWindowDwmDecorations(m_state->window.hwnd);
    m_state->chrome.runtime.Reset();
    m_state->chrome.runtime.SetWindowDpi(QueryWindowDpi(m_state->window.hwnd));
    m_state->render.renderer.SetDpiScale(GetDpiScale());

    std::ostringstream dpiTrace = {};
    dpiTrace << "initial dpi=" << m_state->chrome.runtime.GetWindowDpi()
             << " scale=" << GetDpiScale();
    LogRuntimeTrace("window", dpiTrace.str());

    if (!m_state->render.renderer.Initialize(m_state->window.hwnd)) {
        LogRuntimeTrace("app", "renderer initialization failed");
        return false;
    }

    RECT clientRect = {};
    GetClientRect(m_state->window.hwnd, &clientRect);
    const int clientWidth = (std::max)(clientRect.right - clientRect.left, 1L);
    const int clientHeight = (std::max)(clientRect.bottom - clientRect.top, 1L);
    if (!m_state->render.windowRenderer.Initialize(
            m_state->window.hwnd,
            clientWidth,
            clientHeight)) {
        LogRuntimeTrace("app", "d3d12 window renderer initialization failed");
        m_state->render.renderer.Shutdown();
        return false;
    }

    const Host::D3D12WindowRenderLoopAttachResult attachResult =
        m_state->render.windowRenderLoop.Attach(
            m_state->render.renderer,
            m_state->render.windowRenderer);
    if (!attachResult.interopWarning.empty()) {
        LogRuntimeTrace("app", attachResult.interopWarning);
    }

    editorContext.AttachTextMeasurer(m_state->render.renderer);
    m_state->composition.shellRuntime.Initialize(
        repoRoot,
        m_state->render.renderer,
        m_state->render.renderer);
    m_state->composition.shellRuntime.AttachViewportWindowRenderer(
        m_state->render.windowRenderer);
    m_state->composition.shellRuntime.SetViewportSurfacePresentationEnabled(
        attachResult.hasViewportSurfacePresentation);

    std::string titleBarLogoError = {};
    if (!LoadEmbeddedPngTexture(
            m_state->render.renderer,
            IDR_PNG_LOGO_ICON,
            m_state->render.titleBarLogoIcon,
            titleBarLogoError)) {
        LogRuntimeTrace("icons", "titlebar logo_icon.png: " + titleBarLogoError);
    }
    if (!m_state->composition.shellRuntime.GetBuiltInIconError().empty()) {
        LogRuntimeTrace("icons", m_state->composition.shellRuntime.GetBuiltInIconError());
    }

    LogRuntimeTrace(
        "app",
        "shell runtime initialized: " +
            editorContext.DescribeWorkspaceState(
                m_state->composition.workspaceController,
                m_state->composition.shellRuntime.GetShellInteractionState()));
    m_state->render.ready = true;

    m_state->render.autoScreenshot.Initialize(captureRoot);
    if (autoCaptureOnStartup && IsAutoCaptureOnStartupEnabled()) {
        m_state->render.autoScreenshot.RequestCapture("startup");
        editorContext.SetStatus("Capture", "Startup capture requested.");
    }

    return true;
}

void EditorWindow::Shutdown() {
    ForceReleasePointerCapture();

    m_state->render.ready = false;
    m_state->render.autoScreenshot.Shutdown();
    m_state->composition.shellRuntime.Shutdown();
    m_state->render.renderer.ReleaseTexture(m_state->render.titleBarLogoIcon);
    m_state->render.windowRenderLoop.Detach();
    m_state->render.windowRenderer.Shutdown();
    m_state->render.renderer.Shutdown();
    m_state->input.pendingEvents.clear();
    m_state->chrome.chromeState = {};
    m_state->chrome.runtime.Reset();
}

void EditorWindow::ResetInteractionState() {
    ForceReleasePointerCapture();

    m_state->input.pendingEvents.clear();
    m_state->input.trackingMouseLeave = false;
    m_state->input.modifierTracker.Reset();
    m_state->composition.shellRuntime.ResetInteractionState();
    m_state->chrome.chromeState = {};
    m_state->chrome.runtime.EndBorderlessResize();
    m_state->chrome.runtime.EndBorderlessWindowDragRestore();
    m_state->chrome.runtime.EndInteractiveResize();
    m_state->chrome.runtime.SetHoveredBorderlessResizeEdge(
        Host::BorderlessWindowResizeEdge::None);
    m_state->chrome.runtime.ClearPredictedClientPixelSize();
}

bool EditorWindow::ApplyWindowResize(UINT width, UINT height) {
    if (!m_state->render.ready || width == 0u || height == 0u) {
        return false;
    }

    const Host::D3D12WindowRenderLoopResizeResult resizeResult =
        m_state->render.windowRenderLoop.ApplyResize(width, height);
    m_state->composition.shellRuntime.SetViewportSurfacePresentationEnabled(
        resizeResult.hasViewportSurfacePresentation);

    if (!resizeResult.windowRendererWarning.empty()) {
        LogRuntimeTrace("present", resizeResult.windowRendererWarning);
    }

    if (!resizeResult.interopWarning.empty()) {
        LogRuntimeTrace("present", resizeResult.interopWarning);
    }

    return resizeResult.hasViewportSurfacePresentation;
}

bool EditorWindow::QueryCurrentClientPixelSize(UINT& outWidth, UINT& outHeight) const {
    outWidth = 0u;
    outHeight = 0u;
    if (m_state->window.hwnd == nullptr || !IsWindow(m_state->window.hwnd)) {
        return false;
    }

    RECT clientRect = {};
    if (!GetClientRect(m_state->window.hwnd, &clientRect)) {
        return false;
    }

    const LONG width = clientRect.right - clientRect.left;
    const LONG height = clientRect.bottom - clientRect.top;
    if (width <= 0 || height <= 0) {
        return false;
    }

    outWidth = static_cast<UINT>(width);
    outHeight = static_cast<UINT>(height);
    return true;
}

bool EditorWindow::ResolveRenderClientPixelSize(UINT& outWidth, UINT& outHeight) const {
    if (m_state->chrome.runtime.TryGetPredictedClientPixelSize(outWidth, outHeight)) {
        return true;
    }

    return QueryCurrentClientPixelSize(outWidth, outHeight);
}

float EditorWindow::GetDpiScale() const {
    return m_state->chrome.runtime.GetDpiScale(kBaseDpiScale);
}

float EditorWindow::PixelsToDips(float pixels) const {
    const float dpiScale = GetDpiScale();
    return dpiScale > 0.0f ? pixels / dpiScale : pixels;
}

UIPoint EditorWindow::ConvertClientPixelsToDips(LONG x, LONG y) const {
    return UIPoint(
        PixelsToDips(static_cast<float>(x)),
        PixelsToDips(static_cast<float>(y)));
}

UIPoint EditorWindow::ConvertScreenPixelsToClientDips(const POINT& screenPoint) const {
    POINT clientPoint = screenPoint;
    if (m_state->window.hwnd != nullptr) {
        ScreenToClient(m_state->window.hwnd, &clientPoint);
    }

    const float dpiScale = m_state->chrome.runtime.GetDpiScale(kBaseDpiScale);
    return UIPoint(
        dpiScale > 0.0f
            ? static_cast<float>(clientPoint.x) / dpiScale
            : static_cast<float>(clientPoint.x),
        dpiScale > 0.0f
            ? static_cast<float>(clientPoint.y) / dpiScale
            : static_cast<float>(clientPoint.y));
}

void EditorWindow::OnResize(UINT width, UINT height) {
    bool matchesPredictedClientSize = false;
    UINT predictedWidth = 0u;
    UINT predictedHeight = 0u;
    if (m_state->chrome.runtime.TryGetPredictedClientPixelSize(
            predictedWidth,
            predictedHeight)) {
        matchesPredictedClientSize =
            predictedWidth == width &&
            predictedHeight == height;
    }

    m_state->chrome.runtime.ClearPredictedClientPixelSize();
    if (IsBorderlessWindowEnabled() && m_state->window.hwnd != nullptr) {
        Host::RefreshBorderlessWindowDwmDecorations(m_state->window.hwnd);
    }

    if (!matchesPredictedClientSize) {
        ApplyWindowResize(width, height);
    }
}

void EditorWindow::OnEnterSizeMove() {
    m_state->chrome.runtime.BeginInteractiveResize();
}

void EditorWindow::OnExitSizeMove() {
    m_state->chrome.runtime.EndInteractiveResize();
    m_state->chrome.runtime.ClearPredictedClientPixelSize();
    UINT width = 0u;
    UINT height = 0u;
    if (QueryCurrentClientPixelSize(width, height)) {
        ApplyWindowResize(width, height);
    }
}

void EditorWindow::OnDpiChanged(UINT dpi, const RECT& suggestedRect) {
    m_state->chrome.runtime.SetWindowDpi(dpi == 0u ? kDefaultDpi : dpi);
    m_state->render.renderer.SetDpiScale(GetDpiScale());
    if (m_state->window.hwnd != nullptr) {
        const LONG windowWidth = suggestedRect.right - suggestedRect.left;
        const LONG windowHeight = suggestedRect.bottom - suggestedRect.top;
        SetWindowPos(
            m_state->window.hwnd,
            nullptr,
            suggestedRect.left,
            suggestedRect.top,
            windowWidth,
            windowHeight,
            SWP_NOZORDER | SWP_NOACTIVATE);
        UINT clientWidth = 0u;
        UINT clientHeight = 0u;
        if (QueryCurrentClientPixelSize(clientWidth, clientHeight)) {
            ApplyWindowResize(clientWidth, clientHeight);
        }
        Host::RefreshBorderlessWindowDwmDecorations(m_state->window.hwnd);
    }

    std::ostringstream trace = {};
    trace << "dpi changed to " << m_state->chrome.runtime.GetWindowDpi()
          << " scale=" << GetDpiScale();
    LogRuntimeTrace("window", trace.str());
}

bool EditorWindow::IsVerboseRuntimeTraceEnabled() {
    static const bool s_enabled = ResolveVerboseRuntimeTraceEnabled();
    return s_enabled;
}

void EditorWindow::UpdateCachedTitleText() {
    m_state->window.titleText = WideToUtf8(m_state->window.title);
}

} // namespace XCEngine::UI::Editor::App