XCEngine/new_editor/app/Composition/WorkspaceEventSync.cpp

#include "Composition/WorkspaceEventSync.h"

#include "Composition/EditorContext.h"
#include "Features/Hierarchy/HierarchyPanel.h"
#include "Features/Project/ProjectPanel.h"
#include "Composition/EditorShellRuntime.h"

#include "Composition/EditorPanelIds.h"

#include <sstream>
#include <utility>

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

namespace {

std::string_view DescribeProjectItemKind(ProjectBrowserModel::ItemKind kind) {
    switch (kind) {
    case ProjectBrowserModel::ItemKind::Folder:
        return "Folder";
    case ProjectBrowserModel::ItemKind::Scene:
        return "Scene";
    case ProjectBrowserModel::ItemKind::Model:
        return "Model";
    case ProjectBrowserModel::ItemKind::Material:
        return "Material";
    case ProjectBrowserModel::ItemKind::Texture:
        return "Texture";
    case ProjectBrowserModel::ItemKind::Script:
        return "Script";
    case ProjectBrowserModel::ItemKind::File:
    default:
        return "File";
    }
}

std::string DescribeProjectPanelEvent(const ProjectPanel::Event& event) {
    std::ostringstream stream = {};
    switch (event.kind) {
    case ProjectPanel::EventKind::AssetSelected:
        stream << "AssetSelected";
        break;
    case ProjectPanel::EventKind::AssetSelectionCleared:
        stream << "AssetSelectionCleared";
        break;
    case ProjectPanel::EventKind::FolderNavigated:
        stream << "FolderNavigated";
        break;
    case ProjectPanel::EventKind::AssetOpened:
        stream << "AssetOpened";
        break;
    case ProjectPanel::EventKind::RenameRequested:
        stream << "RenameRequested";
        break;
    case ProjectPanel::EventKind::ContextMenuRequested:
        stream << "ContextMenuRequested";
        break;
    case ProjectPanel::EventKind::None:
    default:
        stream << "None";
        break;
    }

    stream << " source=";
    switch (event.source) {
    case ProjectPanel::EventSource::Tree:
        stream << "Tree";
        break;
    case ProjectPanel::EventSource::Breadcrumb:
        stream << "Breadcrumb";
        break;
    case ProjectPanel::EventSource::GridPrimary:
        stream << "GridPrimary";
        break;
    case ProjectPanel::EventSource::GridDoubleClick:
        stream << "GridDoubleClick";
        break;
    case ProjectPanel::EventSource::GridSecondary:
        stream << "GridSecondary";
        break;
    case ProjectPanel::EventSource::GridDrag:
        stream << "GridDrag";
        break;
    case ProjectPanel::EventSource::Command:
        stream << "Command";
        break;
    case ProjectPanel::EventSource::Background:
        stream << "Background";
        break;
    case ProjectPanel::EventSource::None:
    default:
        stream << "None";
        break;
    }

    if (!event.itemId.empty()) {
        stream << " item=" << event.itemId;
    }
    if (!event.displayName.empty()) {
        stream << " label=" << event.displayName;
    }
    if (!event.itemId.empty()) {
        stream << " kind=" << DescribeProjectItemKind(event.itemKind);
    }
    return stream.str();
}

std::string DescribeHierarchyPanelEvent(const HierarchyPanel::Event& event) {
    std::ostringstream stream = {};
    switch (event.kind) {
    case HierarchyPanel::EventKind::SelectionChanged:
        stream << "SelectionChanged";
        break;
    case HierarchyPanel::EventKind::Reparented:
        stream << "Reparented";
        break;
    case HierarchyPanel::EventKind::MovedToRoot:
        stream << "MovedToRoot";
        break;
    case HierarchyPanel::EventKind::RenameRequested:
        stream << "RenameRequested";
        break;
    case HierarchyPanel::EventKind::None:
    default:
        stream << "None";
        break;
    }

    if (!event.itemId.empty()) {
        stream << " item=" << event.itemId;
    }
    if (!event.targetItemId.empty()) {
        stream << " target=" << event.targetItemId;
    }
    if (!event.label.empty()) {
        stream << " label=" << event.label;
    }
    return stream.str();
}

} // namespace

std::vector<WorkspaceTraceEntry> SyncWorkspaceEvents(
    EditorContext& context,
    const EditorShellRuntime& runtime) {
    std::vector<WorkspaceTraceEntry> entries = {};
    context.SyncSessionFromSelectionService();
    if (const std::optional<std::filesystem::path> scenePath =
            context.GetProjectRuntime().ConsumePendingSceneOpenPath();
        scenePath.has_value()) {
        context.GetSceneRuntime().OpenSceneAsset(scenePath.value());
        context.SyncSessionFromSelectionService();
    }

    for (const HierarchyPanel::Event& event : runtime.GetHierarchyPanelEvents()) {
        const std::string message = DescribeHierarchyPanelEvent(event);
        context.SetStatus("Hierarchy", message);
        entries.push_back(WorkspaceTraceEntry{ std::string(kHierarchyPanelId), std::move(message) });
    }

    for (const ProjectPanel::Event& event : runtime.GetProjectPanelEvents()) {
        const std::string message = DescribeProjectPanelEvent(event);
        context.SetStatus("Project", message);
        entries.push_back(WorkspaceTraceEntry{ std::string(kProjectPanelId), std::move(message) });
    }

    return entries;
}

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