Refactor editor windowing boundaries

editor/app/Windowing/EditorWindowManager.cpp

@@ -1,62 +1,40 @@
 #include "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 "Windowing/Coordinator/EditorWindowLifecycleCoordinator.h"
 #include "Windowing/Coordinator/EditorUtilityWindowCoordinator.h"
-#include "Platform/Win32/Windowing/EditorWindowMessageDispatcher.h"
 #include "Windowing/Coordinator/EditorWindowWorkspaceCoordinator.h"
 
-#include <XCEditor/Workspace/UIEditorWorkspaceController.h>
+#include <XCEditor/Workspace/UIEditorWindowWorkspaceModel.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,
-          windowSystem,
-          *m_contentFactory)) {
+    EditorWindowSystem& windowSystem,
+    EditorWindowHostRuntimeServices& hostRuntime)
+    : m_editorContext(editorContext)
+    , m_hostRuntime(hostRuntime) {
     m_workspaceCoordinator =
-        std::make_unique<EditorWindowWorkspaceCoordinator>(*m_hostRuntime, windowSystem);
+        std::make_unique<EditorWindowWorkspaceCoordinator>(m_hostRuntime, windowSystem);
     m_utilityCoordinator =
-        std::make_unique<EditorUtilityWindowCoordinator>(*m_hostRuntime);
+        std::make_unique<EditorUtilityWindowCoordinator>(m_hostRuntime);
     m_lifecycleCoordinator = std::make_unique<EditorWindowLifecycleCoordinator>(
-        *m_hostRuntime,
+        m_hostRuntime,
         *m_workspaceCoordinator);
-    m_hostRuntime->BindLifecycleCoordinator(*m_lifecycleCoordinator);
+    m_hostRuntime.BindHostCoordinator(*this);
     m_workspaceCoordinator->BindLifecycleCoordinator(*m_lifecycleCoordinator);
     m_utilityCoordinator->BindLifecycleCoordinator(*m_lifecycleCoordinator);
 }
 
 EditorWindowManager::~EditorWindowManager() = default;
 
-EditorHostWindow* EditorWindowManager::CreateEditorWindow(
-    std::unique_ptr<EditorWindowContentController> contentController,
-    const EditorWindowCreateParams& params) {
-    EditorHostWindow* const window =
-        m_hostRuntime->CreateEditorWindow(std::move(contentController), params);
-    if (window != nullptr) {
-        m_workspaceCoordinator->RegisterExistingWindow(*window);
-    }
-    return window;
-}
-
 EditorHostWindow* EditorWindowManager::CreateWorkspaceWindow(
-    UIEditorWorkspaceController workspaceController,
+    const UIEditorWindowWorkspaceState& windowState,
     const EditorWindowCreateParams& params) {
     EditorHostWindow* const window =
-        m_hostRuntime->CreateWorkspaceWindow(std::move(workspaceController), params);
+        m_hostRuntime.CreateWorkspaceWindow(windowState, params);
     if (window != nullptr) {
         m_workspaceCoordinator->RegisterExistingWindow(*window);
     }
@@ -66,90 +44,37 @@ EditorHostWindow* EditorWindowManager::CreateWorkspaceWindow(
 EditorHostWindow* EditorWindowManager::CreateUtilityWindow(
     const EditorUtilityWindowDescriptor& descriptor,
     const EditorWindowCreateParams& params) {
-    EditorHostWindow* const window = m_hostRuntime->CreateUtilityWindow(descriptor, params);
+    EditorHostWindow* 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::RequestPrimaryWindowClose() {
-    if (m_hostRuntime == nullptr || m_lifecycleCoordinator == nullptr) {
+    if (m_lifecycleCoordinator == nullptr) {
         return false;
     }
 
-    EditorHostWindow* const primaryWindow = m_hostRuntime->FindPrimaryWindow();
-    if (primaryWindow == nullptr) {
-        return false;
+    for (EditorHostWindow* window : m_hostRuntime.GetWindows()) {
+        if (window == nullptr || !window->IsPrimary()) {
+            continue;
+        }
+
+        m_lifecycleCoordinator->PostCloseRequest(*window);
+        return true;
     }
 
-    m_lifecycleCoordinator->PostCloseRequest(*primaryWindow);
-    return true;
-}
-
-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);
-}
-
-EditorHostWindow* EditorWindowManager::FindWindow(HWND hwnd) {
-    return m_hostRuntime->FindWindow(hwnd);
-}
-
-const EditorHostWindow* EditorWindowManager::FindWindow(HWND hwnd) const {
-    return m_hostRuntime->FindWindow(hwnd);
-}
-
-EditorHostWindow* EditorWindowManager::FindWindow(std::string_view windowId) {
-    return m_hostRuntime->FindWindowById(windowId);
-}
-
-const EditorHostWindow* EditorWindowManager::FindWindow(std::string_view windowId) const {
-    return m_hostRuntime->FindWindowById(windowId);
-}
-
-EditorHostWindow* EditorWindowManager::FindPrimaryWindow() {
-    return m_hostRuntime->FindPrimaryWindow();
-}
-
-const EditorHostWindow* EditorWindowManager::FindPrimaryWindow() const {
-    return m_hostRuntime->FindPrimaryWindow();
+    return false;
 }
 
 bool EditorWindowManager::HasWindows() const {
-    return m_hostRuntime->HasWindows();
+    return !m_hostRuntime.GetWindows().empty();
 }
 
 void EditorWindowManager::DestroyClosedWindows() {
@@ -157,10 +82,86 @@ void EditorWindowManager::DestroyClosedWindows() {
 }
 
 void EditorWindowManager::RenderAllWindows() {
-    m_hostRuntime->RenderAllWindows(
-        m_workspaceCoordinator->IsGlobalTabDragActive(),
-        *m_workspaceCoordinator,
-        *m_utilityCoordinator);
+    m_hostRuntime.RenderAllWindows();
+}
+
+EditorContext& EditorWindowManager::GetEditorContext() {
+    return m_editorContext;
+}
+
+const EditorContext& EditorWindowManager::GetEditorContext() const {
+    return m_editorContext;
+}
+
+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();
+    }
 }
 
 } // namespace XCEngine::UI::Editor::App