XCEngine/editor/app/Platform/Win32/Windowing/EditorWindowManager.cpp

#include "Platform/Win32/Windowing/EditorWindowManager.h"

#include "Platform/Win32/Windowing/EditorWindow.h"
#include "Windowing/Content/EditorWindowContentFactory.h"
#include "Windowing/Content/EditorWindowContentController.h"
#include "Platform/Win32/Windowing/EditorWindowHostRuntime.h"
#include "Platform/Win32/Windowing/EditorWindowLifecycleCoordinator.h"
#include "Platform/Win32/Windowing/EditorUtilityWindowCoordinator.h"
#include "Platform/Win32/Windowing/EditorWindowMessageDispatcher.h"
#include "Platform/Win32/Windowing/EditorWindowWorkspaceCoordinator.h"

#include <XCEditor/Workspace/UIEditorWorkspaceController.h>

#include <utility>

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

EditorWindowManager::EditorWindowManager(
    EditorWindowHostConfig hostConfig,
    std::filesystem::path repoRoot,
    EditorContext& editorContext,
    EditorWindowSystem& windowSystem)
    : m_contentFactory(CreateDefaultEditorWindowContentFactory())
    , m_hostRuntime(std::make_unique<EditorWindowHostRuntime>(
          hostConfig,
          std::move(repoRoot),
          editorContext,
          *m_contentFactory)) {
    m_workspaceCoordinator =
        std::make_unique<EditorWindowWorkspaceCoordinator>(*m_hostRuntime, windowSystem);
    m_utilityCoordinator =
        std::make_unique<EditorUtilityWindowCoordinator>(*m_hostRuntime);
    m_lifecycleCoordinator = std::make_unique<EditorWindowLifecycleCoordinator>(
        *m_hostRuntime,
        *m_workspaceCoordinator);
    m_hostRuntime->BindLifecycleCoordinator(*m_lifecycleCoordinator);
    m_workspaceCoordinator->BindLifecycleCoordinator(*m_lifecycleCoordinator);
    m_utilityCoordinator->BindLifecycleCoordinator(*m_lifecycleCoordinator);
}

EditorWindowManager::~EditorWindowManager() = default;

EditorWindow* EditorWindowManager::CreateEditorWindow(
    std::unique_ptr<EditorWindowContentController> contentController,
    const CreateParams& params) {
    EditorWindow* const window =
        m_hostRuntime->CreateEditorWindow(std::move(contentController), params);
    if (window != nullptr) {
        m_workspaceCoordinator->RegisterExistingWindow(*window);
    }
    return window;
}

EditorWindow* EditorWindowManager::CreateWorkspaceWindow(
    UIEditorWorkspaceController workspaceController,
    const CreateParams& params) {
    EditorWindow* const window =
        m_hostRuntime->CreateWorkspaceWindow(std::move(workspaceController), params);
    if (window != nullptr) {
        m_workspaceCoordinator->RegisterExistingWindow(*window);
    }
    return window;
}

EditorWindow* EditorWindowManager::CreateUtilityWindow(
    const EditorUtilityWindowDescriptor& descriptor,
    const CreateParams& params) {
    EditorWindow* const window = m_hostRuntime->CreateUtilityWindow(descriptor, params);
    if (window != nullptr) {
        m_workspaceCoordinator->RegisterExistingWindow(*window);
    }
    return window;
}

void EditorWindowManager::HandlePendingNativeWindowCreated(HWND hwnd) {
    m_hostRuntime->HandlePendingNativeWindowCreated(hwnd);
}

void EditorWindowManager::Shutdown() {
    m_workspaceCoordinator->EndGlobalTabDragSession();
    m_lifecycleCoordinator->ShutdownAllWindows();
}

bool EditorWindowManager::TryDispatchWindowMessage(
    HWND hwnd,
    UINT message,
    WPARAM wParam,
    LPARAM lParam,
    LRESULT& outResult) {
    if (m_hostRuntime == nullptr || m_workspaceCoordinator == nullptr) {
        return false;
    }

    EditorWindow* const window = m_hostRuntime->FindWindow(hwnd);
    if (window == nullptr) {
        return false;
    }

    return EditorWindowMessageDispatcher::TryDispatch(
        hwnd,
        *m_hostRuntime,
        *m_lifecycleCoordinator,
        *m_utilityCoordinator,
        *m_workspaceCoordinator,
        *window,
        message,
        wParam,
        lParam,
        outResult);
}

EditorWindow* EditorWindowManager::FindWindow(HWND hwnd) {
    return m_hostRuntime->FindWindow(hwnd);
}

const EditorWindow* EditorWindowManager::FindWindow(HWND hwnd) const {
    return m_hostRuntime->FindWindow(hwnd);
}

EditorWindow* EditorWindowManager::FindWindow(std::string_view windowId) {
    return m_hostRuntime->FindWindow(windowId);
}

const EditorWindow* EditorWindowManager::FindWindow(std::string_view windowId) const {
    return m_hostRuntime->FindWindow(windowId);
}

EditorWindow* EditorWindowManager::FindPrimaryWindow() {
    return m_hostRuntime->FindPrimaryWindow();
}

const EditorWindow* EditorWindowManager::FindPrimaryWindow() const {
    return m_hostRuntime->FindPrimaryWindow();
}

bool EditorWindowManager::HasWindows() const {
    return m_hostRuntime->HasWindows();
}

void EditorWindowManager::DestroyClosedWindows() {
    m_lifecycleCoordinator->ReapDestroyedWindows();
}

void EditorWindowManager::RenderAllWindows() {
    m_hostRuntime->RenderAllWindows(
        m_workspaceCoordinator->IsGlobalTabDragActive(),
        *m_workspaceCoordinator,
        *m_utilityCoordinator);
}

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