Refactor new editor boundaries and test ownership

new_editor/app/Commands/EditorHostCommandBridge.cpp

@@ -0,0 +1,255 @@
+#include "Commands/EditorHostCommandBridge.h"
+
+#include <string>
+#include <utility>
+
+namespace XCEngine::UI::Editor::App {
+
+void EditorHostCommandBridge::BindSession(EditorSession& session) {
+    m_session = &session;
+}
+
+void EditorHostCommandBridge::BindCommandFocusService(
+    const EditorCommandFocusService& commandFocusService) {
+    m_commandFocusService = &commandFocusService;
+}
+
+void EditorHostCommandBridge::BindEditCommandRoutes(
+    EditorEditCommandRoute* hierarchyRoute,
+    EditorEditCommandRoute* projectRoute,
+    EditorEditCommandRoute* sceneRoute,
+    EditorEditCommandRoute* inspectorRoute) {
+    m_hierarchyRoute = hierarchyRoute;
+    m_projectRoute = projectRoute;
+    m_sceneRoute = sceneRoute;
+    m_inspectorRoute = inspectorRoute;
+}
+
+void EditorHostCommandBridge::SetExitRequestHandler(std::function<void()> handler) {
+    m_requestExit = std::move(handler);
+}
+
+UIEditorHostCommandEvaluationResult EditorHostCommandBridge::EvaluateHostCommand(
+    std::string_view commandId) const {
+    if (commandId == "file.exit") {
+        return BuildExecutableResult("Exit editor.");
+    }
+
+    if (commandId == "help.about") {
+        return BuildDisabledResult("About dialog is unavailable in the current shell.");
+    }
+
+    if (commandId.rfind("edit.", 0u) == 0u) {
+        return EvaluateEditCommand(commandId);
+    }
+
+    if (commandId.rfind("assets.", 0u) == 0u) {
+        return EvaluateAssetCommand(commandId);
+    }
+
+    return EvaluateUnsupportedHostCommand(commandId);
+}
+
+UIEditorHostCommandDispatchResult EditorHostCommandBridge::DispatchHostCommand(
+    std::string_view commandId) {
+    UIEditorHostCommandDispatchResult result = {};
+
+    if (commandId == "file.exit") {
+        result.commandExecuted = true;
+        result.message = "Exit requested.";
+        if (m_requestExit) {
+            m_requestExit();
+        }
+        return result;
+    }
+
+    if (commandId == "help.about") {
+        result.message = EvaluateHostCommand(commandId).message;
+        return result;
+    }
+
+    if (commandId.rfind("edit.", 0u) == 0u) {
+        return DispatchEditCommand(commandId);
+    }
+
+    if (commandId.rfind("assets.", 0u) == 0u) {
+        return DispatchAssetCommand(commandId);
+    }
+
+    result.message = EvaluateHostCommand(commandId).message;
+    return result;
+}
+
+UIEditorHostCommandEvaluationResult EditorHostCommandBridge::BuildDisabledResult(
+    std::string_view message) const {
+    UIEditorHostCommandEvaluationResult result = {};
+    result.executable = false;
+    result.message = std::string(message);
+    return result;
+}
+
+UIEditorHostCommandEvaluationResult EditorHostCommandBridge::BuildExecutableResult(
+    std::string_view message) const {
+    UIEditorHostCommandEvaluationResult result = {};
+    result.executable = true;
+    result.message = std::string(message);
+    return result;
+}
+
+UIEditorHostCommandEvaluationResult EditorHostCommandBridge::EvaluateFileCommand(
+    std::string_view commandId) const {
+    if (commandId == "file.exit") {
+        return BuildExecutableResult("Exit editor.");
+    }
+
+    return BuildDisabledResult(
+        "Only file.exit has a bound host owner in the current shell.");
+}
+
+UIEditorHostCommandEvaluationResult EditorHostCommandBridge::EvaluateAssetCommand(
+    std::string_view commandId) const {
+    if (m_projectRoute == nullptr) {
+        return BuildDisabledResult("Project command route is unavailable in the current window.");
+    }
+
+    return m_projectRoute->EvaluateAssetCommand(commandId);
+}
+
+UIEditorHostCommandEvaluationResult EditorHostCommandBridge::EvaluateRunCommand(
+    std::string_view commandId) const {
+    (void)commandId;
+    return BuildDisabledResult(
+        "Run commands have no bound play-mode owner in the current shell.");
+}
+
+UIEditorHostCommandEvaluationResult EditorHostCommandBridge::EvaluateScriptCommand(
+    std::string_view commandId) const {
+    (void)commandId;
+    return BuildDisabledResult(
+        "Script commands have no bound script-pipeline owner in the current shell.");
+}
+
+UIEditorHostCommandEvaluationResult EditorHostCommandBridge::EvaluateEditCommand(
+    std::string_view commandId) const {
+    if (m_session == nullptr) {
+        return BuildDisabledResult("Editor session is unavailable.");
+    }
+
+    const EditorActionRoute route = ResolveActiveEditRoute();
+    if (route == EditorActionRoute::None) {
+        return BuildDisabledResult("No active edit route.");
+    }
+
+    EditorEditCommandRoute* editRoute = ResolveEditCommandRoute(route);
+    if (editRoute == nullptr) {
+        switch (route) {
+        case EditorActionRoute::Hierarchy:
+            return BuildDisabledResult("Hierarchy command route is unavailable in the current window.");
+        case EditorActionRoute::Project:
+            return BuildDisabledResult("Project command route is unavailable in the current window.");
+        case EditorActionRoute::Inspector:
+            return BuildDisabledResult("Inspector command route is unavailable in the current window.");
+        case EditorActionRoute::Console:
+            return BuildDisabledResult("Console does not expose edit commands yet.");
+        case EditorActionRoute::Scene:
+            return BuildDisabledResult("Scene command route is unavailable in the current window.");
+        case EditorActionRoute::Game:
+            return BuildDisabledResult("Viewport panels do not expose edit commands yet.");
+        case EditorActionRoute::None:
+        default:
+            return BuildDisabledResult("Current panel does not expose edit commands.");
+        }
+    }
+
+    return editRoute->EvaluateEditCommand(commandId);
+}
+
+UIEditorHostCommandDispatchResult EditorHostCommandBridge::DispatchEditCommand(
+    std::string_view commandId) {
+    UIEditorHostCommandDispatchResult result = {};
+    const UIEditorHostCommandEvaluationResult evaluation = EvaluateEditCommand(commandId);
+    if (!evaluation.executable) {
+        result.message = evaluation.message;
+        return result;
+    }
+
+    EditorEditCommandRoute* route = ResolveEditCommandRoute(ResolveActiveEditRoute());
+    if (route == nullptr) {
+        result.message = "Edit command route is unavailable.";
+        return result;
+    }
+
+    return route->DispatchEditCommand(commandId);
+}
+
+UIEditorHostCommandDispatchResult EditorHostCommandBridge::DispatchAssetCommand(
+    std::string_view commandId) {
+    UIEditorHostCommandDispatchResult result = {};
+    const UIEditorHostCommandEvaluationResult evaluation = EvaluateAssetCommand(commandId);
+    if (!evaluation.executable) {
+        result.message = evaluation.message;
+        return result;
+    }
+
+    if (m_projectRoute == nullptr) {
+        result.message = "Project command route is unavailable.";
+        return result;
+    }
+
+    return m_projectRoute->DispatchAssetCommand(commandId);
+}
+
+UIEditorHostCommandEvaluationResult EditorHostCommandBridge::EvaluateUnsupportedHostCommand(
+    std::string_view commandId) const {
+    if (commandId.rfind("file.", 0u) == 0u) {
+        return EvaluateFileCommand(commandId);
+    }
+
+    if (commandId.rfind("assets.", 0u) == 0u) {
+        return EvaluateAssetCommand(commandId);
+    }
+
+    if (commandId.rfind("run.", 0u) == 0u) {
+        return EvaluateRunCommand(commandId);
+    }
+
+    if (commandId.rfind("scripts.", 0u) == 0u) {
+        return EvaluateScriptCommand(commandId);
+    }
+
+    return BuildDisabledResult("Host command has no owner in the current shell.");
+}
+
+EditorActionRoute EditorHostCommandBridge::ResolveActiveEditRoute() const {
+    if (m_session == nullptr) {
+        return EditorActionRoute::None;
+    }
+
+    const EditorActionRoute fallbackRoute =
+        ResolveEditorActionRoute(m_session->activePanelId);
+    if (m_commandFocusService != nullptr) {
+        return m_commandFocusService->ResolveRoute(fallbackRoute);
+    }
+
+    return m_session->activeRoute != EditorActionRoute::None
+        ? m_session->activeRoute
+        : fallbackRoute;
+}
+
+EditorEditCommandRoute* EditorHostCommandBridge::ResolveEditCommandRoute(
+    EditorActionRoute route) const {
+    switch (route) {
+    case EditorActionRoute::Hierarchy:
+        return m_hierarchyRoute;
+    case EditorActionRoute::Project:
+        return m_projectRoute;
+    case EditorActionRoute::Inspector:
+        return m_inspectorRoute;
+    case EditorActionRoute::Scene:
+        return m_sceneRoute;
+    default:
+        return nullptr;
+    }
+}
+
+} // namespace XCEngine::UI::Editor::App