XCEngine/new_editor/app/Features/Project/ProjectPanel.cpp

#include "ProjectPanelSupport.h"

#include <utility>

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

using namespace ProjectPanelSupport;

void ProjectPanel::Initialize(const std::filesystem::path& repoRoot) {
    m_browserModel.Initialize(repoRoot);
    SyncCurrentFolderSelection();
}

void ProjectPanel::SetBuiltInIcons(const BuiltInIcons* icons) {
    m_icons = icons;
    m_browserModel.SetFolderIcon(ResolveFolderIcon(m_icons));
    SyncCurrentFolderSelection();
}

void ProjectPanel::SetTextMeasurer(const UIEditorTextMeasurer* textMeasurer) {
    m_textMeasurer = textMeasurer;
}

void ProjectPanel::ResetInteractionState() {
    m_treeInteractionState = {};
    m_treeFrame = {};
    m_frameEvents.clear();
    m_layout = {};
    m_hoveredAssetItemId.clear();
    m_lastPrimaryClickedAssetId.clear();
    m_hoveredBreadcrumbIndex = kInvalidLayoutIndex;
    m_pressedBreadcrumbIndex = kInvalidLayoutIndex;
    m_visible = false;
    m_splitterHovered = false;
    m_splitterDragging = false;
    m_requestPointerCapture = false;
    m_requestPointerRelease = false;
}

ProjectPanel::CursorKind ProjectPanel::GetCursorKind() const {
    return (m_splitterHovered || m_splitterDragging) ? CursorKind::ResizeEW : CursorKind::Arrow;
}

bool ProjectPanel::WantsHostPointerCapture() const {
    return m_requestPointerCapture;
}

bool ProjectPanel::WantsHostPointerRelease() const {
    return m_requestPointerRelease;
}

bool ProjectPanel::HasActivePointerCapture() const {
    return m_splitterDragging;
}

const std::vector<ProjectPanel::Event>& ProjectPanel::GetFrameEvents() const {
    return m_frameEvents;
}

const ProjectPanel::FolderEntry* ProjectPanel::FindFolderEntry(std::string_view itemId) const {
    return m_browserModel.FindFolderEntry(itemId);
}

const ProjectPanel::AssetEntry* ProjectPanel::FindAssetEntry(std::string_view itemId) const {
    return m_browserModel.FindAssetEntry(itemId);
}

const UIEditorPanelContentHostPanelState* ProjectPanel::FindMountedProjectPanel(
    const UIEditorPanelContentHostFrame& contentHostFrame) const {
    for (const UIEditorPanelContentHostPanelState& panelState : contentHostFrame.panelStates) {
        if (panelState.panelId == kProjectPanelId && panelState.mounted) {
            return &panelState;
        }
    }

    return nullptr;
}

void ProjectPanel::SyncCurrentFolderSelection() {
    const std::string& currentFolderId = m_browserModel.GetCurrentFolderId();
    if (currentFolderId.empty()) {
        m_folderSelection.ClearSelection();
        return;
    }

    const std::vector<std::string> ancestorFolderIds =
        m_browserModel.CollectCurrentFolderAncestorIds();
    for (const std::string& ancestorFolderId : ancestorFolderIds) {
        m_folderExpansion.Expand(ancestorFolderId);
    }
    m_folderSelection.SetSelection(currentFolderId);
}

bool ProjectPanel::NavigateToFolder(std::string_view itemId, EventSource source) {
    if (!m_browserModel.NavigateToFolder(itemId)) {
        return false;
    }

    SyncCurrentFolderSelection();
    m_assetSelection.ClearSelection();
    m_hoveredAssetItemId.clear();
    m_lastPrimaryClickedAssetId.clear();
    EmitEvent(EventKind::FolderNavigated, source, FindFolderEntry(m_browserModel.GetCurrentFolderId()));
    return true;
}

void ProjectPanel::EmitEvent(
    EventKind kind,
    EventSource source,
    const FolderEntry* folder) {
    if (kind == EventKind::None || folder == nullptr) {
        return;
    }

    Event event = {};
    event.kind = kind;
    event.source = source;
    event.itemId = folder->itemId;
    event.absolutePath = folder->absolutePath;
    event.displayName = folder->label;
    event.directory = true;
    m_frameEvents.push_back(std::move(event));
}

void ProjectPanel::EmitEvent(
    EventKind kind,
    EventSource source,
    const AssetEntry* asset) {
    if (kind == EventKind::None) {
        return;
    }

    Event event = {};
    event.kind = kind;
    event.source = source;
    if (asset != nullptr) {
        event.itemId = asset->itemId;
        event.absolutePath = asset->absolutePath;
        event.displayName = asset->displayName;
        event.directory = asset->directory;
    }
    m_frameEvents.push_back(std::move(event));
}

void ProjectPanel::EmitSelectionClearedEvent(EventSource source) {
    Event event = {};
    event.kind = EventKind::AssetSelectionCleared;
    event.source = source;
    m_frameEvents.push_back(std::move(event));
}

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