XCEngine/new_editor/app/Composition/WorkspaceEventSync.cpp

#include "Composition/WorkspaceEventSync.h"

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

#include <sstream>
#include <utility>

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

namespace {

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::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::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;
    }
    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();
}

void ApplyHierarchySelection(
    EditorContext& context,
    const HierarchyPanel::Event& event) {
    if (event.kind != HierarchyPanel::EventKind::SelectionChanged) {
        return;
    }

    if (event.itemId.empty()) {
        context.ClearSelection();
        return;
    }

    EditorSelectionState selection = {};
    selection.kind = EditorSelectionKind::HierarchyNode;
    selection.itemId = event.itemId;
    selection.displayName = event.label.empty() ? event.itemId : event.label;
    context.SetSelection(std::move(selection));
}

void ApplyProjectSelection(
    EditorContext& context,
    const ProjectPanel::Event& event) {
    switch (event.kind) {
    case ProjectPanel::EventKind::AssetSelected: {
        EditorSelectionState selection = {};
        selection.kind = EditorSelectionKind::ProjectItem;
        selection.itemId = event.itemId;
        selection.displayName = event.displayName.empty() ? event.itemId : event.displayName;
        selection.absolutePath = event.absolutePath;
        selection.directory = event.directory;
        context.SetSelection(std::move(selection));
        return;
    }
    case ProjectPanel::EventKind::AssetSelectionCleared:
    case ProjectPanel::EventKind::FolderNavigated:
        if (context.GetSession().selection.kind == EditorSelectionKind::ProjectItem) {
            context.ClearSelection();
        }
        return;
    case ProjectPanel::EventKind::AssetOpened:
    case ProjectPanel::EventKind::ContextMenuRequested:
    case ProjectPanel::EventKind::None:
    default:
        return;
    }
}

} // namespace

std::vector<WorkspaceTraceEntry> SyncWorkspaceEvents(
    EditorContext& context,
    const EditorShellRuntime& runtime) {
    std::vector<WorkspaceTraceEntry> entries = {};

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

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

    return entries;
}

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