XCEngine/editor/app/Windowing/EditorWindowManager.cpp

#include "EditorWindowManager.h"

#include "Content/EditorWindowContentController.h"
#include "Content/EditorWindowContentFactory.h"
#include "Coordinator/EditorWindowLifecycleCoordinator.h"
#include "Coordinator/EditorUtilityWindowCoordinator.h"
#include "Coordinator/EditorWindowWorkspaceCoordinator.h"
#include "EditorWindowInstance.h"
#include "Runtime/EditorWindowRuntimeController.h"

#include "EditorWindowRenderRuntime.h"

#include <XCEditor/Workspace/UIEditorWindowWorkspaceModel.h>

#include <memory>
#include <algorithm>
#include <utility>
#include <vector>

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

EditorWindowManager::EditorWindowManager(
    EditorFrameServices& frameServices,
    EditorWindowSystem& windowSystem,
    Rendering::Host::EditorWindowRenderRuntimeFactory& renderRuntimeFactory,
    Host::EditorHostResourceService& resourceService,
    EditorWindowHostRuntimeServices& hostRuntime,
    EditorWorkspaceShellRuntimeFactory workspaceShellRuntimeFactory,
    EditorUtilityWindowPanelFactory utilityPanelFactory)
    : m_frameServices(frameServices)
    , m_renderRuntimeFactory(renderRuntimeFactory)
    , m_resourceService(resourceService)
    , m_hostRuntime(hostRuntime) {
    m_contentFactory = CreateDefaultEditorWindowContentFactory(
        windowSystem,
        std::move(workspaceShellRuntimeFactory),
        std::move(utilityPanelFactory));
    m_workspaceCoordinator =
        std::make_unique<EditorWindowWorkspaceCoordinator>(
            m_hostRuntime,
            *this,
            windowSystem,
            m_renderRuntimeFactory,
            *m_contentFactory);
    m_utilityCoordinator =
        std::make_unique<EditorUtilityWindowCoordinator>(
            m_hostRuntime,
            *this,
            m_renderRuntimeFactory,
            *m_contentFactory);
    m_lifecycleCoordinator = std::make_unique<EditorWindowLifecycleCoordinator>(
        m_hostRuntime,
        *m_workspaceCoordinator);
    m_hostRuntime.BindHostCoordinator(*this);
    m_workspaceCoordinator->BindLifecycleCoordinator(*m_lifecycleCoordinator);
    m_utilityCoordinator->BindLifecycleCoordinator(*m_lifecycleCoordinator);
}

EditorWindowManager::~EditorWindowManager() = default;

EditorHostWindow* EditorWindowManager::CreateWorkspaceWindow(
    const UIEditorWindowWorkspaceState& windowState,
    const EditorWindowCreateParams& params) {
    if (m_contentFactory == nullptr) {
        return nullptr;
    }
    if (windowState.windowId.empty()) {
        return nullptr;
    }
    if (!params.windowId.empty() && windowState.windowId != params.windowId) {
        return nullptr;
    }

    auto windowInstance = CreateEditorWindowInstance(
        params.windowId,
        params.title,
        params.category,
        params.chromePolicy,
        params.primary,
        std::make_unique<EditorWindowRuntimeController>(
            m_frameServices,
            m_resourceService,
            m_contentFactory->CreateWorkspaceContentController(windowState),
            m_renderRuntimeFactory.CreateWindowRenderRuntime()));
    EditorHostWindow* const window = windowInstance.get();
    if (!m_hostRuntime.CreateHostWindow(*window, params)) {
        return nullptr;
    }
    m_windows.push_back(std::move(windowInstance));
    if (window != nullptr) {
        m_workspaceCoordinator->RegisterExistingWindow(*window);
    }
    return window;
}

EditorHostWindow* EditorWindowManager::CreateUtilityWindow(
    const EditorUtilityWindowDescriptor& descriptor,
    const EditorWindowCreateParams& params) {
    if (m_contentFactory == nullptr) {
        return nullptr;
    }

    auto windowInstance = CreateEditorWindowInstance(
        params.windowId,
        params.title,
        params.category,
        params.chromePolicy,
        params.primary,
        std::make_unique<EditorWindowRuntimeController>(
            m_frameServices,
            m_resourceService,
            m_contentFactory->CreateUtilityContentController(descriptor),
            m_renderRuntimeFactory.CreateWindowRenderRuntime()));
    EditorHostWindow* const window = windowInstance.get();
    if (!m_hostRuntime.CreateHostWindow(*window, params)) {
        return nullptr;
    }
    m_windows.push_back(std::move(windowInstance));
    if (window != nullptr) {
        m_workspaceCoordinator->RegisterExistingWindow(*window);
    }
    return window;
}

void EditorWindowManager::Shutdown() {
    m_workspaceCoordinator->EndGlobalTabDragSession();
    m_lifecycleCoordinator->ShutdownAllWindows();
    ReapDestroyedWindows();
    m_windows.clear();
}

bool EditorWindowManager::RequestPrimaryWindowClose() {
    if (m_lifecycleCoordinator == nullptr) {
        return false;
    }

    for (const std::unique_ptr<EditorWindowInstance>& window : m_windows) {
        if (window == nullptr || !window->IsPrimary()) {
            continue;
        }

        m_lifecycleCoordinator->PostCloseRequest(*window);
        return true;
    }

    return false;
}

bool EditorWindowManager::HasWindows() const {
    return !m_windows.empty();
}

void EditorWindowManager::DestroyClosedWindows() {
    ReapDestroyedWindows();
}

void EditorWindowManager::RenderAllWindows() {
    struct WindowFrameTransferBatch {
        EditorHostWindow* sourceWindow = nullptr;
        EditorWindowFrameTransferRequests requests = {};
    };

    std::vector<WindowFrameTransferBatch> transferBatches = {};
    std::vector<EditorHostWindow*> windows = {};
    windows.reserve(m_windows.size());
    for (const std::unique_ptr<EditorWindowInstance>& window : m_windows) {
        if (window != nullptr) {
            windows.push_back(window.get());
        }
    }
    transferBatches.reserve(windows.size());

    for (EditorHostWindow* window : windows) {
        if (window == nullptr ||
            !window->HasLiveHostWindow() ||
            window->GetLifecycleState() != EditorWindowLifecycleState::Running) {
            continue;
        }

        if (window->ConsumeSkipNextSteadyStateFrame()) {
            RefreshWindowPresentation(*window);
            continue;
        }

        EditorWindowFrameTransferRequests transferRequests = DriveWindowFrame(*window);
        RefreshWindowPresentation(*window);
        if (!transferRequests.HasPendingRequests()) {
            continue;
        }

        transferBatches.push_back(WindowFrameTransferBatch{
            window,
            std::move(transferRequests),
        });
    }

    for (WindowFrameTransferBatch& batch : transferBatches) {
        if (batch.sourceWindow == nullptr ||
            !batch.sourceWindow->HasLiveHostWindow() ||
            batch.sourceWindow->GetLifecycleState() != EditorWindowLifecycleState::Running) {
            continue;
        }

        DispatchWindowFrameTransferRequests(
            *batch.sourceWindow,
            batch.requests);
    }
}

bool EditorWindowManager::InitializeHostWindow(
    EditorHostWindow& window,
    const EditorHostWindowRuntimeInitializationParams& params) {
    return window.InitializeRuntime(params);
}

EditorWindowFrameTransferRequests EditorWindowManager::DriveWindowFrame(
    EditorHostWindow& window) {
    return DriveWindowFrameInternal(window, false);
}

EditorWindowFrameTransferRequests EditorWindowManager::DriveImmediateWindowFrame(
    EditorHostWindow& window) {
    return DriveWindowFrameInternal(window, true);
}

EditorWindowFrameTransferRequests EditorWindowManager::DriveWindowFrameInternal(
    EditorHostWindow& window,
    bool requestSkipNextSteadyStateFrame) {
    if (!window.IsRenderReady() ||
        !window.HasLiveHostWindow() ||
        window.GetLifecycleState() != EditorWindowLifecycleState::Running) {
        return {};
    }

    EditorWindowFrameTransferRequests transferRequests =
        window.RenderHostFrame(IsGlobalTabDragActive());
    window.ValidateHostFrame();
    if (requestSkipNextSteadyStateFrame) {
        window.RequestSkipNextSteadyStateFrame();
    }

    return transferRequests;
}

bool EditorWindowManager::IsGlobalTabDragActive() const {
    return m_workspaceCoordinator != nullptr &&
        m_workspaceCoordinator->IsGlobalTabDragActive();
}

bool EditorWindowManager::OwnsActiveGlobalTabDrag(std::string_view windowId) const {
    return m_workspaceCoordinator != nullptr &&
        m_workspaceCoordinator->OwnsActiveGlobalTabDrag(windowId);
}

bool EditorWindowManager::HandleGlobalTabDragPointerMove(EditorHostWindow& window) {
    return m_workspaceCoordinator != nullptr &&
        m_workspaceCoordinator->HandleGlobalTabDragPointerMove(window);
}

bool EditorWindowManager::HandleGlobalTabDragPointerButtonUp(EditorHostWindow& window) {
    return m_workspaceCoordinator != nullptr &&
        m_workspaceCoordinator->HandleGlobalTabDragPointerButtonUp(window);
}

void EditorWindowManager::EndGlobalTabDragSession() {
    if (m_workspaceCoordinator != nullptr) {
        m_workspaceCoordinator->EndGlobalTabDragSession();
    }
}

void EditorWindowManager::RefreshWindowPresentation(EditorHostWindow& window) {
    if (m_workspaceCoordinator != nullptr) {
        m_workspaceCoordinator->RefreshWindowPresentation(window);
    }
}

void EditorWindowManager::DispatchWindowFrameTransferRequests(
    EditorHostWindow& sourceWindow,
    const EditorWindowFrameTransferRequests& transferRequests) {
    if (m_workspaceCoordinator != nullptr) {
        m_workspaceCoordinator->HandleWindowFrameTransferRequests(
            sourceWindow,
            transferRequests);
    }
    if (m_utilityCoordinator != nullptr) {
        m_utilityCoordinator->HandleWindowFrameTransferRequests(
            sourceWindow,
            transferRequests);
    }
}

void EditorWindowManager::ExecuteCloseRequest(EditorHostWindow& window) {
    if (m_lifecycleCoordinator != nullptr) {
        m_lifecycleCoordinator->ExecuteCloseRequest(window);
    }
}

void EditorWindowManager::HandleNativeWindowDestroyed(EditorHostWindow& window) {
    if (m_lifecycleCoordinator != nullptr) {
        m_lifecycleCoordinator->HandleNativeWindowDestroyed(window);
    }
}

void EditorWindowManager::AbortUnregisteredWindow(EditorHostWindow& window) {
    if (m_lifecycleCoordinator != nullptr) {
        m_lifecycleCoordinator->AbortUnregisteredWindow(window);
    }
}

void EditorWindowManager::ReapDestroyedWindows() {
    if (m_lifecycleCoordinator != nullptr) {
        m_lifecycleCoordinator->ReapDestroyedWindows();
    }
    m_windows.erase(
        std::remove_if(
            m_windows.begin(),
            m_windows.end(),
            [](const std::unique_ptr<EditorWindowInstance>& window) {
                return window == nullptr || window->IsDestroyed();
            }),
        m_windows.end());
}

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