2154 lines
76 KiB
C++
2154 lines
76 KiB
C++
#include "ProjectPanelInternal.h"
|
|
|
|
#include "Ports/SystemInteractionPort.h"
|
|
#include "Project/EditorProjectRuntime.h"
|
|
#include "State/EditorCommandFocusService.h"
|
|
|
|
#include <XCEditor/Collections/UIEditorTreePanelBehavior.h>
|
|
#include <XCEditor/Fields/UIEditorFieldStyle.h>
|
|
#include <XCEditor/Foundation/UIEditorPanelInputFilter.h>
|
|
#include <XCEditor/Fields/UIEditorTextField.h>
|
|
|
|
#include <XCEngine/Input/InputTypes.h>
|
|
#include <XCEngine/UI/Widgets/UIPopupOverlayModel.h>
|
|
|
|
#include <functional>
|
|
#include <memory>
|
|
#include <utility>
|
|
|
|
namespace XCEngine::UI::Editor::App {
|
|
|
|
using namespace ProjectPanelInternal;
|
|
using ::XCEngine::Input::KeyCode;
|
|
namespace GridDrag = XCEngine::UI::Editor::Collections::GridDragDrop;
|
|
namespace TreeDrag = XCEngine::UI::Editor::Collections::TreeDragDrop;
|
|
|
|
namespace {
|
|
|
|
UIEditorHostCommandEvaluationResult BuildEvaluationResult(
|
|
bool executable,
|
|
std::string message) {
|
|
UIEditorHostCommandEvaluationResult result = {};
|
|
result.executable = executable;
|
|
result.message = std::move(message);
|
|
return result;
|
|
}
|
|
|
|
UIEditorHostCommandDispatchResult BuildDispatchResult(
|
|
bool commandExecuted,
|
|
std::string message) {
|
|
UIEditorHostCommandDispatchResult result = {};
|
|
result.commandExecuted = commandExecuted;
|
|
result.message = std::move(message);
|
|
return result;
|
|
}
|
|
|
|
bool HasValidBounds(const UIRect& bounds) {
|
|
return bounds.width > 0.0f && bounds.height > 0.0f;
|
|
}
|
|
|
|
constexpr auto kGridDoubleClickInterval = std::chrono::milliseconds(400);
|
|
|
|
Widgets::UIEditorMenuPopupItem BuildContextMenuCommandItem(
|
|
std::string itemId,
|
|
std::string label,
|
|
bool enabled = true) {
|
|
Widgets::UIEditorMenuPopupItem item = {};
|
|
item.itemId = std::move(itemId);
|
|
item.kind = UIEditorMenuItemKind::Command;
|
|
item.label = std::move(label);
|
|
item.enabled = enabled;
|
|
return item;
|
|
}
|
|
|
|
Widgets::UIEditorMenuPopupItem BuildContextMenuSeparatorItem(std::string itemId) {
|
|
Widgets::UIEditorMenuPopupItem item = {};
|
|
item.itemId = std::move(itemId);
|
|
item.kind = UIEditorMenuItemKind::Separator;
|
|
item.enabled = false;
|
|
return item;
|
|
}
|
|
|
|
void AppendContextMenuSeparator(
|
|
std::vector<Widgets::UIEditorMenuPopupItem>& items,
|
|
std::string itemId) {
|
|
if (items.empty() || items.back().kind == UIEditorMenuItemKind::Separator) {
|
|
return;
|
|
}
|
|
|
|
items.push_back(BuildContextMenuSeparatorItem(std::move(itemId)));
|
|
}
|
|
|
|
} // namespace
|
|
|
|
EditorProjectRuntime* ProjectPanel::ResolveProjectRuntime() {
|
|
return m_projectRuntime != nullptr
|
|
? m_projectRuntime
|
|
: m_ownedProjectRuntime.get();
|
|
}
|
|
|
|
const EditorProjectRuntime* ProjectPanel::ResolveProjectRuntime() const {
|
|
return m_projectRuntime != nullptr
|
|
? m_projectRuntime
|
|
: m_ownedProjectRuntime.get();
|
|
}
|
|
|
|
bool ProjectPanel::HasProjectRuntime() const {
|
|
return ResolveProjectRuntime() != nullptr;
|
|
}
|
|
|
|
ProjectPanel::BrowserModel& ProjectPanel::GetBrowserModel() {
|
|
return ResolveProjectRuntime()->GetBrowserModel();
|
|
}
|
|
|
|
const ProjectPanel::BrowserModel& ProjectPanel::GetBrowserModel() const {
|
|
return ResolveProjectRuntime()->GetBrowserModel();
|
|
}
|
|
|
|
void ProjectPanel::Initialize(const std::filesystem::path& repoRoot) {
|
|
m_ownedProjectRuntime = std::make_unique<EditorProjectRuntime>();
|
|
m_ownedProjectRuntime->Initialize(repoRoot);
|
|
if (m_icons != nullptr) {
|
|
m_ownedProjectRuntime->SetFolderIcon(ResolveFolderIcon(m_icons));
|
|
}
|
|
SyncCurrentFolderSelection();
|
|
SyncAssetSelectionFromRuntime();
|
|
}
|
|
|
|
void ProjectPanel::SetProjectRuntime(EditorProjectRuntime* projectRuntime) {
|
|
m_projectRuntime = projectRuntime;
|
|
if (m_projectRuntime != nullptr && m_icons != nullptr) {
|
|
m_projectRuntime->SetFolderIcon(ResolveFolderIcon(m_icons));
|
|
}
|
|
SyncCurrentFolderSelection();
|
|
SyncAssetSelectionFromRuntime();
|
|
}
|
|
|
|
void ProjectPanel::SetCommandFocusService(
|
|
EditorCommandFocusService* commandFocusService) {
|
|
m_commandFocusService = commandFocusService;
|
|
}
|
|
|
|
void ProjectPanel::SetSystemInteractionHost(
|
|
Ports::SystemInteractionPort* systemInteractionHost) {
|
|
m_systemInteractionHost = systemInteractionHost;
|
|
}
|
|
|
|
void ProjectPanel::SetBuiltInIcons(const BuiltInIcons* icons) {
|
|
m_icons = icons;
|
|
if (EditorProjectRuntime* runtime = ResolveProjectRuntime();
|
|
runtime != nullptr) {
|
|
runtime->SetFolderIcon(ResolveFolderIcon(m_icons));
|
|
}
|
|
}
|
|
|
|
void ProjectPanel::SetTextMeasurer(const UIEditorTextMeasurer* textMeasurer) {
|
|
m_textMeasurer = textMeasurer;
|
|
}
|
|
|
|
void ProjectPanel::ResetInteractionState() {
|
|
m_assetDragState = {};
|
|
m_treeDragState = {};
|
|
m_treeInteractionState = {};
|
|
m_treeFrame = {};
|
|
m_contextMenu = {};
|
|
ClearRenameState();
|
|
m_frameEvents.clear();
|
|
m_layout = {};
|
|
m_hoveredAssetItemId.clear();
|
|
m_lastPrimaryClickedAssetId.clear();
|
|
m_lastPrimaryClickTime = {};
|
|
m_hoveredBreadcrumbIndex = kInvalidLayoutIndex;
|
|
m_pressedBreadcrumbIndex = kInvalidLayoutIndex;
|
|
m_assetDropTargetSurface = DropTargetSurface::None;
|
|
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 ||
|
|
m_assetDragState.requestPointerCapture ||
|
|
m_treeDragState.requestPointerCapture;
|
|
}
|
|
|
|
bool ProjectPanel::WantsHostPointerRelease() const {
|
|
return m_requestPointerRelease ||
|
|
m_assetDragState.requestPointerRelease ||
|
|
m_treeDragState.requestPointerRelease;
|
|
}
|
|
|
|
bool ProjectPanel::HasActivePointerCapture() const {
|
|
return m_splitterDragging ||
|
|
GridDrag::HasActivePointerCapture(m_assetDragState) ||
|
|
TreeDrag::HasActivePointerCapture(m_treeDragState);
|
|
}
|
|
|
|
const std::vector<ProjectPanel::Event>& ProjectPanel::GetFrameEvents() const {
|
|
return m_frameEvents;
|
|
}
|
|
|
|
const ProjectPanel::FolderEntry* ProjectPanel::FindFolderEntry(std::string_view itemId) const {
|
|
const EditorProjectRuntime* runtime = ResolveProjectRuntime();
|
|
return runtime != nullptr
|
|
? runtime->FindFolderEntry(itemId)
|
|
: nullptr;
|
|
}
|
|
|
|
const ProjectPanel::AssetEntry* ProjectPanel::FindAssetEntry(std::string_view itemId) const {
|
|
const EditorProjectRuntime* runtime = ResolveProjectRuntime();
|
|
return runtime != nullptr
|
|
? runtime->FindAssetEntry(itemId)
|
|
: nullptr;
|
|
}
|
|
|
|
ProjectPanel::AssetCommandTarget ProjectPanel::ResolveAssetCommandTarget(
|
|
std::string_view explicitItemId,
|
|
bool forceCurrentFolder) const {
|
|
if (!HasProjectRuntime()) {
|
|
return {};
|
|
}
|
|
|
|
return ResolveProjectRuntime()->ResolveAssetCommandTarget(
|
|
explicitItemId,
|
|
forceCurrentFolder);
|
|
}
|
|
|
|
const ProjectPanel::AssetEntry* ProjectPanel::GetSelectedAssetEntry() const {
|
|
const EditorProjectRuntime* runtime = ResolveProjectRuntime();
|
|
return runtime != nullptr && runtime->HasSelection()
|
|
? runtime->FindAssetEntry(runtime->GetSelection().itemId)
|
|
: nullptr;
|
|
}
|
|
|
|
const ProjectPanel::FolderEntry* ProjectPanel::GetSelectedFolderEntry() const {
|
|
if (!HasProjectRuntime()) {
|
|
return nullptr;
|
|
}
|
|
|
|
return FindFolderEntry(GetBrowserModel().GetCurrentFolderId());
|
|
}
|
|
|
|
void ProjectPanel::ClearRenameState() {
|
|
m_renameState = {};
|
|
m_renameFrame = {};
|
|
m_pendingRenameItemId.clear();
|
|
m_pendingRenameSurface = RenameSurface::None;
|
|
m_activeRenameSurface = RenameSurface::None;
|
|
}
|
|
|
|
void ProjectPanel::QueueRenameSession(
|
|
std::string_view itemId,
|
|
RenameSurface surface) {
|
|
if (itemId.empty() || surface == RenameSurface::None) {
|
|
return;
|
|
}
|
|
|
|
if (surface == RenameSurface::Tree &&
|
|
FindFolderEntry(itemId) == nullptr) {
|
|
return;
|
|
}
|
|
|
|
if (surface == RenameSurface::Grid &&
|
|
FindAssetEntry(itemId) == nullptr) {
|
|
return;
|
|
}
|
|
|
|
if (m_renameState.active &&
|
|
m_renameState.itemId == itemId &&
|
|
m_activeRenameSurface == surface) {
|
|
return;
|
|
}
|
|
|
|
m_pendingRenameItemId = std::string(itemId);
|
|
m_pendingRenameSurface = surface;
|
|
}
|
|
|
|
UIRect ProjectPanel::BuildRenameBounds(
|
|
std::string_view itemId,
|
|
RenameSurface surface) const {
|
|
if (itemId.empty() || surface == RenameSurface::None) {
|
|
return {};
|
|
}
|
|
|
|
const Widgets::UIEditorTextFieldMetrics hostedMetrics =
|
|
BuildUIEditorPropertyGridTextFieldMetrics(
|
|
ResolveUIEditorPropertyGridMetrics(),
|
|
ResolveUIEditorTextFieldMetrics());
|
|
|
|
if (surface == RenameSurface::Tree) {
|
|
return BuildUIEditorTreePanelInlineRenameBounds(
|
|
m_treeFrame.layout,
|
|
GetBrowserModel().GetTreeItems(),
|
|
itemId,
|
|
hostedMetrics);
|
|
}
|
|
|
|
if (surface == RenameSurface::Grid) {
|
|
for (const AssetTileLayout& tile : m_layout.assetTiles) {
|
|
if (tile.itemIndex >= GetBrowserModel().GetAssetEntries().size()) {
|
|
continue;
|
|
}
|
|
|
|
const AssetEntry& assetEntry =
|
|
GetBrowserModel().GetAssetEntries()[tile.itemIndex];
|
|
if (assetEntry.itemId != itemId) {
|
|
continue;
|
|
}
|
|
|
|
const float x = (std::max)(
|
|
tile.tileRect.x + 4.0f,
|
|
tile.labelRect.x - hostedMetrics.valueTextInsetX);
|
|
const float right = tile.tileRect.x + tile.tileRect.width - 4.0f;
|
|
const float width = (std::max)(72.0f, right - x);
|
|
return UIRect(x, tile.labelRect.y - 2.0f, width, tile.labelRect.height + 4.0f);
|
|
}
|
|
}
|
|
|
|
return {};
|
|
}
|
|
|
|
bool ProjectPanel::TryStartQueuedRenameSession() {
|
|
if (m_pendingRenameItemId.empty() ||
|
|
m_pendingRenameSurface == RenameSurface::None) {
|
|
return false;
|
|
}
|
|
|
|
std::string initialText = {};
|
|
if (m_pendingRenameSurface == RenameSurface::Grid) {
|
|
const AssetEntry* asset = FindAssetEntry(m_pendingRenameItemId);
|
|
if (asset == nullptr) {
|
|
m_pendingRenameItemId.clear();
|
|
m_pendingRenameSurface = RenameSurface::None;
|
|
return false;
|
|
}
|
|
initialText = asset->displayName;
|
|
} else {
|
|
const FolderEntry* folder = FindFolderEntry(m_pendingRenameItemId);
|
|
if (folder == nullptr) {
|
|
m_pendingRenameItemId.clear();
|
|
m_pendingRenameSurface = RenameSurface::None;
|
|
return false;
|
|
}
|
|
initialText = folder->label;
|
|
}
|
|
|
|
const UIRect bounds =
|
|
BuildRenameBounds(m_pendingRenameItemId, m_pendingRenameSurface);
|
|
if (!HasValidBounds(bounds)) {
|
|
return false;
|
|
}
|
|
|
|
const Widgets::UIEditorTextFieldMetrics textFieldMetrics =
|
|
BuildUIEditorInlineRenameTextFieldMetrics(
|
|
bounds,
|
|
BuildUIEditorPropertyGridTextFieldMetrics(
|
|
ResolveUIEditorPropertyGridMetrics(),
|
|
ResolveUIEditorTextFieldMetrics()));
|
|
|
|
UIEditorInlineRenameSessionRequest request = {};
|
|
request.beginSession = true;
|
|
request.itemId = m_pendingRenameItemId;
|
|
request.initialText = initialText;
|
|
request.bounds = bounds;
|
|
m_renameFrame = UpdateUIEditorInlineRenameSession(
|
|
m_renameState,
|
|
request,
|
|
{},
|
|
textFieldMetrics);
|
|
if (!m_renameFrame.result.sessionStarted) {
|
|
return false;
|
|
}
|
|
|
|
m_activeRenameSurface = m_pendingRenameSurface;
|
|
m_pendingRenameItemId.clear();
|
|
m_pendingRenameSurface = RenameSurface::None;
|
|
return true;
|
|
}
|
|
|
|
void ProjectPanel::UpdateRenameSession(
|
|
const std::vector<UIInputEvent>& inputEvents) {
|
|
if (!m_renameState.active || m_activeRenameSurface == RenameSurface::None) {
|
|
return;
|
|
}
|
|
|
|
const UIRect bounds = BuildRenameBounds(m_renameState.itemId, m_activeRenameSurface);
|
|
if (!HasValidBounds(bounds)) {
|
|
ClearRenameState();
|
|
return;
|
|
}
|
|
|
|
const Widgets::UIEditorTextFieldMetrics textFieldMetrics =
|
|
BuildUIEditorInlineRenameTextFieldMetrics(
|
|
bounds,
|
|
BuildUIEditorPropertyGridTextFieldMetrics(
|
|
ResolveUIEditorPropertyGridMetrics(),
|
|
ResolveUIEditorTextFieldMetrics()));
|
|
|
|
UIEditorInlineRenameSessionRequest request = {};
|
|
request.itemId = m_renameState.itemId;
|
|
request.initialText = m_renameState.textFieldSpec.value;
|
|
request.bounds = bounds;
|
|
m_renameFrame = UpdateUIEditorInlineRenameSession(
|
|
m_renameState,
|
|
request,
|
|
inputEvents,
|
|
textFieldMetrics);
|
|
if (!m_renameFrame.result.sessionCommitted) {
|
|
if (m_renameFrame.result.sessionCanceled) {
|
|
m_activeRenameSurface = RenameSurface::None;
|
|
}
|
|
return;
|
|
}
|
|
|
|
RenameSurface committedSurface = m_activeRenameSurface;
|
|
m_activeRenameSurface = RenameSurface::None;
|
|
|
|
std::string renamedItemId = {};
|
|
if (m_renameFrame.result.valueChanged &&
|
|
!ResolveProjectRuntime()->RenameItem(
|
|
m_renameFrame.result.itemId,
|
|
m_renameFrame.result.valueAfter,
|
|
&renamedItemId)) {
|
|
return;
|
|
}
|
|
|
|
if (renamedItemId.empty()) {
|
|
renamedItemId = m_renameFrame.result.itemId;
|
|
}
|
|
|
|
SyncCurrentFolderSelection();
|
|
SyncAssetSelectionFromRuntime();
|
|
m_hoveredAssetItemId.clear();
|
|
m_lastPrimaryClickedAssetId = renamedItemId;
|
|
if (committedSurface == RenameSurface::Grid) {
|
|
if (FindAssetEntry(renamedItemId) != nullptr) {
|
|
EmitEvent(EventKind::AssetSelected, EventSource::GridPrimary, FindAssetEntry(renamedItemId));
|
|
} else if (m_assetSelection.HasSelection()) {
|
|
m_assetSelection.ClearSelection();
|
|
EmitSelectionClearedEvent(EventSource::GridPrimary);
|
|
}
|
|
} else if (committedSurface == RenameSurface::Tree) {
|
|
m_assetSelection.ClearSelection();
|
|
EmitEvent(
|
|
EventKind::FolderNavigated,
|
|
EventSource::Tree,
|
|
FindFolderEntry(GetBrowserModel().GetCurrentFolderId()));
|
|
}
|
|
}
|
|
|
|
std::optional<ProjectPanel::EditCommandTarget> ProjectPanel::ResolveEditCommandTarget(
|
|
std::string_view explicitItemId,
|
|
bool forceCurrentFolder) const {
|
|
if (!HasProjectRuntime()) {
|
|
return std::nullopt;
|
|
}
|
|
|
|
return ResolveProjectRuntime()->ResolveEditCommandTarget(
|
|
explicitItemId,
|
|
forceCurrentFolder);
|
|
}
|
|
|
|
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() {
|
|
if (!HasProjectRuntime()) {
|
|
m_folderSelection.ClearSelection();
|
|
return;
|
|
}
|
|
|
|
const std::string& currentFolderId = GetBrowserModel().GetCurrentFolderId();
|
|
if (currentFolderId.empty()) {
|
|
m_folderSelection.ClearSelection();
|
|
return;
|
|
}
|
|
|
|
const std::vector<std::string> ancestorFolderIds =
|
|
GetBrowserModel().CollectCurrentFolderAncestorIds();
|
|
for (const std::string& ancestorFolderId : ancestorFolderIds) {
|
|
m_folderExpansion.Expand(ancestorFolderId);
|
|
}
|
|
m_folderSelection.SetSelection(currentFolderId);
|
|
}
|
|
|
|
void ProjectPanel::SyncAssetSelectionFromRuntime() {
|
|
const EditorProjectRuntime* runtime = ResolveProjectRuntime();
|
|
if (runtime == nullptr || !runtime->HasSelection()) {
|
|
m_assetSelection.ClearSelection();
|
|
return;
|
|
}
|
|
|
|
if (FindAssetEntry(runtime->GetSelection().itemId) != nullptr) {
|
|
m_assetSelection.SetSelection(runtime->GetSelection().itemId);
|
|
return;
|
|
}
|
|
|
|
m_assetSelection.ClearSelection();
|
|
}
|
|
|
|
bool ProjectPanel::NavigateToFolder(std::string_view itemId, EventSource source) {
|
|
if (!ResolveProjectRuntime()->NavigateToFolder(itemId)) {
|
|
return false;
|
|
}
|
|
|
|
SyncCurrentFolderSelection();
|
|
SyncAssetSelectionFromRuntime();
|
|
m_hoveredAssetItemId.clear();
|
|
m_lastPrimaryClickedAssetId.clear();
|
|
EmitEvent(
|
|
EventKind::FolderNavigated,
|
|
source,
|
|
FindFolderEntry(GetBrowserModel().GetCurrentFolderId()));
|
|
return true;
|
|
}
|
|
|
|
bool ProjectPanel::OpenProjectItem(std::string_view itemId, EventSource source) {
|
|
const AssetEntry* asset = FindAssetEntry(itemId);
|
|
if (asset == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
if (asset->directory) {
|
|
const bool navigated = ResolveProjectRuntime()->OpenItem(asset->itemId);
|
|
if (navigated && HasValidBounds(m_layout.bounds)) {
|
|
SyncCurrentFolderSelection();
|
|
SyncAssetSelectionFromRuntime();
|
|
m_layout = BuildLayout(m_layout.bounds);
|
|
m_hoveredAssetItemId.clear();
|
|
EmitEvent(
|
|
EventKind::FolderNavigated,
|
|
source,
|
|
FindFolderEntry(GetBrowserModel().GetCurrentFolderId()));
|
|
}
|
|
return navigated;
|
|
}
|
|
|
|
if (!ResolveProjectRuntime()->OpenItem(asset->itemId)) {
|
|
return false;
|
|
}
|
|
|
|
EmitEvent(EventKind::AssetOpened, source, asset);
|
|
return true;
|
|
}
|
|
|
|
void ProjectPanel::OpenContextMenu(
|
|
const UIPoint& anchorPosition,
|
|
std::string_view targetItemId,
|
|
bool forceCurrentFolder) {
|
|
CloseContextMenu();
|
|
ClearRenameState();
|
|
|
|
m_contextMenu.open = true;
|
|
m_contextMenu.forceCurrentFolder = forceCurrentFolder;
|
|
m_contextMenu.anchorPosition = anchorPosition;
|
|
m_contextMenu.targetItemId = std::string(targetItemId);
|
|
RebuildContextMenu();
|
|
}
|
|
|
|
void ProjectPanel::CloseContextMenu() {
|
|
m_contextMenu = {};
|
|
}
|
|
|
|
void ProjectPanel::RebuildContextMenu() {
|
|
if (!m_contextMenu.open || !HasValidBounds(m_layout.bounds)) {
|
|
CloseContextMenu();
|
|
return;
|
|
}
|
|
|
|
const AssetCommandTarget assetTarget =
|
|
ResolveAssetCommandTarget(
|
|
m_contextMenu.targetItemId,
|
|
m_contextMenu.forceCurrentFolder);
|
|
const std::optional<EditCommandTarget> editTarget =
|
|
ResolveEditCommandTarget(
|
|
m_contextMenu.targetItemId,
|
|
m_contextMenu.forceCurrentFolder);
|
|
|
|
std::vector<Widgets::UIEditorMenuPopupItem> items = {};
|
|
const bool canOpen =
|
|
assetTarget.subjectAsset != nullptr &&
|
|
(assetTarget.subjectAsset->directory || assetTarget.subjectAsset->canOpen);
|
|
const bool canCreate = assetTarget.containerFolder != nullptr;
|
|
const UIEditorHostCommandEvaluationResult showInExplorerEvaluation =
|
|
EvaluateAssetCommand(
|
|
"assets.show_in_explorer",
|
|
m_contextMenu.targetItemId,
|
|
m_contextMenu.forceCurrentFolder);
|
|
const UIEditorHostCommandEvaluationResult copyPathEvaluation =
|
|
EvaluateAssetCommand(
|
|
"assets.copy_path",
|
|
m_contextMenu.targetItemId,
|
|
m_contextMenu.forceCurrentFolder);
|
|
const UIEditorHostCommandEvaluationResult createFolderEvaluation =
|
|
EvaluateAssetCommand(
|
|
"assets.create_folder",
|
|
m_contextMenu.targetItemId,
|
|
m_contextMenu.forceCurrentFolder);
|
|
const UIEditorHostCommandEvaluationResult createMaterialEvaluation =
|
|
EvaluateAssetCommand(
|
|
"assets.create_material",
|
|
m_contextMenu.targetItemId,
|
|
m_contextMenu.forceCurrentFolder);
|
|
const UIEditorHostCommandEvaluationResult renameEvaluation =
|
|
EvaluateEditCommand(
|
|
"edit.rename",
|
|
m_contextMenu.targetItemId,
|
|
m_contextMenu.forceCurrentFolder);
|
|
const UIEditorHostCommandEvaluationResult deleteEvaluation =
|
|
EvaluateEditCommand(
|
|
"edit.delete",
|
|
m_contextMenu.targetItemId,
|
|
m_contextMenu.forceCurrentFolder);
|
|
|
|
if (canOpen) {
|
|
items.push_back(
|
|
BuildContextMenuCommandItem(
|
|
"project.context.open",
|
|
"Open"));
|
|
}
|
|
|
|
if (canCreate) {
|
|
AppendContextMenuSeparator(items, "project.context.separator.open_create");
|
|
items.push_back(
|
|
BuildContextMenuCommandItem(
|
|
"assets.create_folder",
|
|
"Create Folder",
|
|
createFolderEvaluation.executable));
|
|
items.push_back(
|
|
BuildContextMenuCommandItem(
|
|
"assets.create_material",
|
|
"Create Material",
|
|
createMaterialEvaluation.executable));
|
|
}
|
|
|
|
if (showInExplorerEvaluation.executable || copyPathEvaluation.executable) {
|
|
AppendContextMenuSeparator(items, "project.context.separator.create_util");
|
|
items.push_back(
|
|
BuildContextMenuCommandItem(
|
|
"assets.show_in_explorer",
|
|
"Show in Explorer",
|
|
showInExplorerEvaluation.executable));
|
|
items.push_back(
|
|
BuildContextMenuCommandItem(
|
|
"assets.copy_path",
|
|
"Copy Path",
|
|
copyPathEvaluation.executable));
|
|
}
|
|
|
|
if (editTarget.has_value()) {
|
|
AppendContextMenuSeparator(items, "project.context.separator.util_edit");
|
|
items.push_back(
|
|
BuildContextMenuCommandItem(
|
|
"edit.rename",
|
|
"Rename",
|
|
renameEvaluation.executable));
|
|
items.push_back(
|
|
BuildContextMenuCommandItem(
|
|
"edit.delete",
|
|
"Delete",
|
|
deleteEvaluation.executable));
|
|
}
|
|
|
|
if (items.empty()) {
|
|
CloseContextMenu();
|
|
return;
|
|
}
|
|
|
|
m_contextMenu.items = std::move(items);
|
|
const Widgets::UIEditorMenuPopupMetrics& popupMetrics =
|
|
ResolveUIEditorMenuPopupMetrics();
|
|
const float popupWidth = (std::max)(
|
|
156.0f,
|
|
Widgets::ResolveUIEditorMenuPopupDesiredWidth(
|
|
m_contextMenu.items,
|
|
popupMetrics));
|
|
const float popupHeight =
|
|
Widgets::MeasureUIEditorMenuPopupHeight(
|
|
m_contextMenu.items,
|
|
popupMetrics);
|
|
const ::XCEngine::UI::Widgets::UIPopupPlacementResult placement =
|
|
::XCEngine::UI::Widgets::ResolvePopupPlacementRect(
|
|
UIRect(
|
|
m_contextMenu.anchorPosition.x,
|
|
m_contextMenu.anchorPosition.y,
|
|
1.0f,
|
|
1.0f),
|
|
UISize(popupWidth, popupHeight),
|
|
m_layout.bounds,
|
|
::XCEngine::UI::Widgets::UIPopupPlacement::BottomStart);
|
|
m_contextMenu.layout = Widgets::BuildUIEditorMenuPopupLayout(
|
|
placement.rect,
|
|
m_contextMenu.items,
|
|
popupMetrics);
|
|
m_contextMenu.widgetState = {};
|
|
m_contextMenu.widgetState.focused = true;
|
|
}
|
|
|
|
bool ProjectPanel::HandleContextMenuEvent(const UIInputEvent& event) {
|
|
if (!m_contextMenu.open) {
|
|
return false;
|
|
}
|
|
|
|
const Widgets::UIEditorMenuPopupHitTarget hitTarget =
|
|
Widgets::HitTestUIEditorMenuPopup(
|
|
m_contextMenu.layout,
|
|
m_contextMenu.items,
|
|
event.position);
|
|
|
|
switch (event.type) {
|
|
case UIInputEventType::PointerMove:
|
|
case UIInputEventType::PointerEnter:
|
|
m_contextMenu.widgetState.hoveredIndex =
|
|
hitTarget.kind == Widgets::UIEditorMenuPopupHitTargetKind::Item &&
|
|
hitTarget.index < m_contextMenu.items.size() &&
|
|
m_contextMenu.items[hitTarget.index].enabled
|
|
? hitTarget.index
|
|
: Widgets::UIEditorMenuPopupInvalidIndex;
|
|
return hitTarget.kind != Widgets::UIEditorMenuPopupHitTargetKind::None;
|
|
|
|
case UIInputEventType::PointerLeave:
|
|
m_contextMenu.widgetState.hoveredIndex =
|
|
Widgets::UIEditorMenuPopupInvalidIndex;
|
|
return false;
|
|
|
|
case UIInputEventType::PointerButtonDown:
|
|
if (event.pointerButton == ::XCEngine::UI::UIPointerButton::Right) {
|
|
if (hitTarget.kind != Widgets::UIEditorMenuPopupHitTargetKind::None) {
|
|
return true;
|
|
}
|
|
|
|
CloseContextMenu();
|
|
return false;
|
|
}
|
|
|
|
if (event.pointerButton != ::XCEngine::UI::UIPointerButton::Left) {
|
|
return hitTarget.kind != Widgets::UIEditorMenuPopupHitTargetKind::None;
|
|
}
|
|
|
|
if (hitTarget.kind == Widgets::UIEditorMenuPopupHitTargetKind::Item &&
|
|
hitTarget.index < m_contextMenu.items.size() &&
|
|
m_contextMenu.items[hitTarget.index].enabled) {
|
|
const std::string itemId = m_contextMenu.items[hitTarget.index].itemId;
|
|
DispatchContextMenuItem(itemId);
|
|
CloseContextMenu();
|
|
return true;
|
|
}
|
|
|
|
if (hitTarget.kind == Widgets::UIEditorMenuPopupHitTargetKind::PopupSurface) {
|
|
return true;
|
|
}
|
|
|
|
CloseContextMenu();
|
|
return true;
|
|
|
|
case UIInputEventType::FocusLost:
|
|
CloseContextMenu();
|
|
return false;
|
|
|
|
case UIInputEventType::KeyDown:
|
|
if (event.keyCode == static_cast<std::int32_t>(KeyCode::Escape)) {
|
|
CloseContextMenu();
|
|
return true;
|
|
}
|
|
return false;
|
|
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool ProjectPanel::DispatchContextMenuItem(std::string_view itemId) {
|
|
if (itemId == "project.context.open") {
|
|
return OpenProjectItem(
|
|
m_contextMenu.targetItemId,
|
|
EventSource::GridSecondary);
|
|
}
|
|
|
|
if (itemId.rfind("assets.", 0u) == 0u) {
|
|
return DispatchAssetCommand(
|
|
itemId,
|
|
m_contextMenu.targetItemId,
|
|
m_contextMenu.forceCurrentFolder)
|
|
.commandExecuted;
|
|
}
|
|
|
|
if (itemId.rfind("edit.", 0u) == 0u) {
|
|
return DispatchEditCommand(
|
|
itemId,
|
|
m_contextMenu.targetItemId,
|
|
m_contextMenu.forceCurrentFolder)
|
|
.commandExecuted;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void ProjectPanel::AppendContextMenu(UIDrawList& drawList) const {
|
|
if (!m_contextMenu.open || m_contextMenu.items.empty()) {
|
|
return;
|
|
}
|
|
|
|
const Widgets::UIEditorMenuPopupMetrics& popupMetrics =
|
|
ResolveUIEditorMenuPopupMetrics();
|
|
const Widgets::UIEditorMenuPopupPalette& popupPalette =
|
|
ResolveUIEditorMenuPopupPalette();
|
|
Widgets::AppendUIEditorMenuPopupBackground(
|
|
drawList,
|
|
m_contextMenu.layout,
|
|
m_contextMenu.items,
|
|
m_contextMenu.widgetState,
|
|
popupPalette,
|
|
popupMetrics);
|
|
Widgets::AppendUIEditorMenuPopupForeground(
|
|
drawList,
|
|
m_contextMenu.layout,
|
|
m_contextMenu.items,
|
|
m_contextMenu.widgetState,
|
|
popupPalette,
|
|
popupMetrics);
|
|
}
|
|
|
|
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.itemKind = BrowserModel::ItemKind::Folder;
|
|
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.itemKind = asset->kind;
|
|
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));
|
|
}
|
|
|
|
std::vector<UIInputEvent> ProjectPanel::BuildTreeInteractionInputEvents(
|
|
const std::vector<UIInputEvent>& inputEvents,
|
|
const UIRect& bounds,
|
|
const PanelInputContext& inputContext) const {
|
|
const std::vector<UIInputEvent> rawEvents =
|
|
BuildUIEditorPanelInputEvents(
|
|
bounds,
|
|
inputEvents,
|
|
UIEditorPanelInputFilterOptions{
|
|
.allowPointerInBounds = inputContext.allowInteraction,
|
|
.allowPointerWhileCaptured = HasActivePointerCapture(),
|
|
.allowKeyboardInput = inputContext.hasInputFocus,
|
|
.allowFocusEvents =
|
|
inputContext.hasInputFocus ||
|
|
HasActivePointerCapture() ||
|
|
inputContext.focusGained ||
|
|
inputContext.focusLost,
|
|
.includePointerLeave =
|
|
inputContext.allowInteraction || HasActivePointerCapture()
|
|
},
|
|
inputContext.focusGained,
|
|
inputContext.focusLost);
|
|
|
|
const Widgets::UIEditorTreeViewLayout layout =
|
|
m_treeFrame.layout.bounds.width > 0.0f
|
|
? m_treeFrame.layout
|
|
: Widgets::BuildUIEditorTreeViewLayout(
|
|
m_layout.treeRect,
|
|
GetBrowserModel().GetTreeItems(),
|
|
m_folderExpansion,
|
|
ResolveUIEditorTreeViewMetrics());
|
|
return BuildUIEditorTreePanelInteractionInputEvents(
|
|
m_treeDragState,
|
|
layout,
|
|
GetBrowserModel().GetTreeItems(),
|
|
rawEvents,
|
|
m_splitterDragging || m_assetDragState.dragging);
|
|
}
|
|
|
|
UIEditorHostCommandEvaluationResult ProjectPanel::EvaluateAssetCommand(
|
|
std::string_view commandId) const {
|
|
return EvaluateAssetCommand(commandId, {}, false);
|
|
}
|
|
|
|
UIEditorHostCommandEvaluationResult ProjectPanel::EvaluateAssetCommand(
|
|
std::string_view commandId,
|
|
std::string_view explicitItemId,
|
|
bool forceCurrentFolder) const {
|
|
const AssetCommandTarget target =
|
|
ResolveAssetCommandTarget(explicitItemId, forceCurrentFolder);
|
|
|
|
if (commandId == "assets.create_folder") {
|
|
if (target.containerFolder == nullptr) {
|
|
return BuildEvaluationResult(false, "Project has no active folder.");
|
|
}
|
|
|
|
return BuildEvaluationResult(
|
|
true,
|
|
"Create a folder under '" + target.containerFolder->label + "'.");
|
|
}
|
|
|
|
if (commandId == "assets.create_material") {
|
|
if (target.containerFolder == nullptr) {
|
|
return BuildEvaluationResult(false, "Project has no active folder.");
|
|
}
|
|
|
|
return BuildEvaluationResult(
|
|
true,
|
|
"Create a material under '" + target.containerFolder->label + "'.");
|
|
}
|
|
|
|
if (commandId == "assets.copy_path") {
|
|
if (target.subjectRelativePath.empty()) {
|
|
return BuildEvaluationResult(false, "Project has no selected item or current folder path.");
|
|
}
|
|
if (m_systemInteractionHost == nullptr) {
|
|
return BuildEvaluationResult(false, "Project system host is unavailable.");
|
|
}
|
|
|
|
return BuildEvaluationResult(
|
|
true,
|
|
"Copy project path '" + target.subjectRelativePath + "'.");
|
|
}
|
|
|
|
if (commandId == "assets.show_in_explorer") {
|
|
if (target.subjectItemId.empty() || target.subjectDisplayName.empty()) {
|
|
return BuildEvaluationResult(false, "Project has no selected item or current folder.");
|
|
}
|
|
if (m_systemInteractionHost == nullptr) {
|
|
return BuildEvaluationResult(false, "Project system host is unavailable.");
|
|
}
|
|
|
|
return BuildEvaluationResult(
|
|
true,
|
|
"Reveal '" + target.subjectDisplayName + "' in Explorer.");
|
|
}
|
|
|
|
return BuildEvaluationResult(false, "Project does not expose this asset command.");
|
|
}
|
|
|
|
UIEditorHostCommandDispatchResult ProjectPanel::DispatchAssetCommand(
|
|
std::string_view commandId) {
|
|
return DispatchAssetCommand(commandId, {}, false);
|
|
}
|
|
|
|
UIEditorHostCommandDispatchResult ProjectPanel::DispatchAssetCommand(
|
|
std::string_view commandId,
|
|
std::string_view explicitItemId,
|
|
bool forceCurrentFolder) {
|
|
const UIEditorHostCommandEvaluationResult evaluation =
|
|
EvaluateAssetCommand(commandId, explicitItemId, forceCurrentFolder);
|
|
if (!evaluation.executable) {
|
|
return BuildDispatchResult(false, evaluation.message);
|
|
}
|
|
|
|
const AssetCommandTarget target =
|
|
ResolveAssetCommandTarget(explicitItemId, forceCurrentFolder);
|
|
|
|
const auto finalizeCreatedAsset =
|
|
[this](std::string_view createdItemId) {
|
|
ClearRenameState();
|
|
SyncCurrentFolderSelection();
|
|
m_hoveredAssetItemId.clear();
|
|
m_lastPrimaryClickedAssetId = std::string(createdItemId);
|
|
m_lastPrimaryClickTime = {};
|
|
ResolveProjectRuntime()->SetSelection(createdItemId);
|
|
SyncAssetSelectionFromRuntime();
|
|
|
|
const AssetEntry* createdAsset = FindAssetEntry(createdItemId);
|
|
if (createdAsset == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
EmitEvent(EventKind::AssetSelected, EventSource::Command, createdAsset);
|
|
QueueRenameSession(createdItemId, RenameSurface::Grid);
|
|
EmitEvent(EventKind::RenameRequested, EventSource::Command, createdAsset);
|
|
if (m_visible) {
|
|
TryStartQueuedRenameSession();
|
|
}
|
|
return true;
|
|
};
|
|
|
|
if (commandId == "assets.create_folder") {
|
|
if (target.containerFolder == nullptr) {
|
|
return BuildDispatchResult(false, "Project has no active folder.");
|
|
}
|
|
|
|
std::string createdFolderId = {};
|
|
if (!ResolveProjectRuntime()->CreateFolder(
|
|
target.containerFolder->itemId,
|
|
"New Folder",
|
|
&createdFolderId)) {
|
|
return BuildDispatchResult(false, "Failed to create a folder in the current Project directory.");
|
|
}
|
|
|
|
if (target.containerFolder->itemId != GetBrowserModel().GetCurrentFolderId()) {
|
|
NavigateToFolder(target.containerFolder->itemId, EventSource::GridSecondary);
|
|
if (HasValidBounds(m_layout.bounds)) {
|
|
m_layout = BuildLayout(m_layout.bounds);
|
|
}
|
|
}
|
|
|
|
if (finalizeCreatedAsset(createdFolderId)) {
|
|
if (const AssetEntry* createdFolder = FindAssetEntry(createdFolderId);
|
|
createdFolder != nullptr) {
|
|
return BuildDispatchResult(
|
|
true,
|
|
"Created folder '" + createdFolder->displayName + "'.");
|
|
}
|
|
}
|
|
|
|
return BuildDispatchResult(true, "Created a new folder in the current Project directory.");
|
|
}
|
|
|
|
if (commandId == "assets.create_material") {
|
|
if (target.containerFolder == nullptr) {
|
|
return BuildDispatchResult(false, "Project has no active folder.");
|
|
}
|
|
|
|
std::string createdItemId = {};
|
|
if (!ResolveProjectRuntime()->CreateMaterial(
|
|
target.containerFolder->itemId,
|
|
"New Material",
|
|
&createdItemId)) {
|
|
return BuildDispatchResult(false, "Failed to create a material in the current Project directory.");
|
|
}
|
|
|
|
if (target.containerFolder->itemId != GetBrowserModel().GetCurrentFolderId()) {
|
|
NavigateToFolder(target.containerFolder->itemId, EventSource::GridSecondary);
|
|
if (HasValidBounds(m_layout.bounds)) {
|
|
m_layout = BuildLayout(m_layout.bounds);
|
|
}
|
|
}
|
|
|
|
if (finalizeCreatedAsset(createdItemId)) {
|
|
if (const AssetEntry* createdMaterial = FindAssetEntry(createdItemId);
|
|
createdMaterial != nullptr) {
|
|
return BuildDispatchResult(
|
|
true,
|
|
"Created material '" + createdMaterial->nameWithExtension + "'.");
|
|
}
|
|
}
|
|
|
|
return BuildDispatchResult(true, "Created a new material in the current Project directory.");
|
|
}
|
|
|
|
if (commandId == "assets.copy_path") {
|
|
if (target.subjectRelativePath.empty()) {
|
|
return BuildDispatchResult(false, "Project has no selected item or current folder path.");
|
|
}
|
|
|
|
if (m_systemInteractionHost == nullptr ||
|
|
!m_systemInteractionHost->CopyTextToClipboard(target.subjectRelativePath)) {
|
|
return BuildDispatchResult(false, "Failed to copy the project path to the clipboard.");
|
|
}
|
|
|
|
return BuildDispatchResult(
|
|
true,
|
|
"Copied project path '" + target.subjectRelativePath + "'.");
|
|
}
|
|
|
|
if (commandId == "assets.show_in_explorer") {
|
|
if (target.subjectPath.empty()) {
|
|
return BuildDispatchResult(false, "Project has no selected item or current folder.");
|
|
}
|
|
|
|
if (m_systemInteractionHost == nullptr ||
|
|
!m_systemInteractionHost->RevealPathInFileBrowser(
|
|
target.subjectPath,
|
|
target.showInExplorerSelectTarget)) {
|
|
return BuildDispatchResult(false, "Failed to reveal the target path in Explorer.");
|
|
}
|
|
|
|
return BuildDispatchResult(
|
|
true,
|
|
target.showInExplorerSelectTarget
|
|
? "Revealed '" + target.subjectRelativePath + "' in Explorer."
|
|
: "Opened current Project folder in Explorer.");
|
|
}
|
|
|
|
return BuildDispatchResult(false, "Project does not expose this asset command.");
|
|
}
|
|
|
|
UIEditorHostCommandEvaluationResult ProjectPanel::EvaluateEditCommand(
|
|
std::string_view commandId) const {
|
|
return EvaluateEditCommand(commandId, {}, false);
|
|
}
|
|
|
|
UIEditorHostCommandEvaluationResult ProjectPanel::EvaluateEditCommand(
|
|
std::string_view commandId,
|
|
std::string_view explicitItemId,
|
|
bool forceCurrentFolder) const {
|
|
const std::optional<EditCommandTarget> target =
|
|
ResolveEditCommandTarget(explicitItemId, forceCurrentFolder);
|
|
if (!target.has_value()) {
|
|
return BuildEvaluationResult(false, "Select an asset or folder in Project first.");
|
|
}
|
|
|
|
if (target->assetsRoot &&
|
|
(commandId == "edit.rename" || commandId == "edit.delete")) {
|
|
return BuildEvaluationResult(false, "The Assets root cannot be renamed or deleted.");
|
|
}
|
|
|
|
if (commandId == "edit.rename") {
|
|
return BuildEvaluationResult(
|
|
true,
|
|
"Rename project item '" + target->displayName + "'.");
|
|
}
|
|
|
|
if (commandId == "edit.delete") {
|
|
return BuildEvaluationResult(
|
|
true,
|
|
"Delete project item '" + target->displayName + "'.");
|
|
}
|
|
|
|
if (commandId == "edit.duplicate") {
|
|
return BuildEvaluationResult(
|
|
false,
|
|
"Project duplicate is blocked until asset metadata rewrite is wired.");
|
|
}
|
|
|
|
if (commandId == "edit.cut" ||
|
|
commandId == "edit.copy" ||
|
|
commandId == "edit.paste") {
|
|
return BuildEvaluationResult(
|
|
false,
|
|
"Project clipboard has no bound asset transfer owner in the current shell.");
|
|
}
|
|
|
|
return BuildEvaluationResult(false, "Project does not expose this edit command.");
|
|
}
|
|
|
|
UIEditorHostCommandDispatchResult ProjectPanel::DispatchEditCommand(
|
|
std::string_view commandId) {
|
|
return DispatchEditCommand(commandId, {}, false);
|
|
}
|
|
|
|
UIEditorHostCommandDispatchResult ProjectPanel::DispatchEditCommand(
|
|
std::string_view commandId,
|
|
std::string_view explicitItemId,
|
|
bool forceCurrentFolder) {
|
|
const UIEditorHostCommandEvaluationResult evaluation =
|
|
EvaluateEditCommand(commandId, explicitItemId, forceCurrentFolder);
|
|
if (!evaluation.executable) {
|
|
return BuildDispatchResult(false, evaluation.message);
|
|
}
|
|
|
|
const std::optional<EditCommandTarget> target =
|
|
ResolveEditCommandTarget(explicitItemId, forceCurrentFolder);
|
|
if (!target.has_value()) {
|
|
return BuildDispatchResult(false, "Select an asset or folder in Project first.");
|
|
}
|
|
|
|
if (commandId == "edit.rename") {
|
|
const AssetEntry* renameAsset =
|
|
!explicitItemId.empty() ? FindAssetEntry(target->itemId) : GetSelectedAssetEntry();
|
|
const FolderEntry* renameFolder =
|
|
!explicitItemId.empty() ? FindFolderEntry(target->itemId) : GetSelectedFolderEntry();
|
|
const RenameSurface surface =
|
|
!explicitItemId.empty() && FindAssetEntry(explicitItemId) != nullptr
|
|
? RenameSurface::Grid
|
|
: (GetSelectedAssetEntry() != nullptr ? RenameSurface::Grid : RenameSurface::Tree);
|
|
QueueRenameSession(target->itemId, surface);
|
|
if (surface == RenameSurface::Grid) {
|
|
EmitEvent(EventKind::RenameRequested, EventSource::GridPrimary, renameAsset);
|
|
} else {
|
|
EmitEvent(EventKind::RenameRequested, EventSource::Tree, renameFolder);
|
|
}
|
|
if (m_visible) {
|
|
TryStartQueuedRenameSession();
|
|
}
|
|
return BuildDispatchResult(
|
|
true,
|
|
"Project rename requested for '" + target->displayName + "'.");
|
|
}
|
|
|
|
if (commandId == "edit.delete") {
|
|
const std::string previousCurrentFolderId = GetBrowserModel().GetCurrentFolderId();
|
|
const bool hadAssetSelection = ResolveProjectRuntime()->HasSelection();
|
|
if (!ResolveProjectRuntime()->DeleteItem(target->itemId)) {
|
|
return BuildDispatchResult(false, "Failed to delete the selected project item.");
|
|
}
|
|
|
|
ClearRenameState();
|
|
SyncCurrentFolderSelection();
|
|
SyncAssetSelectionFromRuntime();
|
|
m_hoveredAssetItemId.clear();
|
|
m_lastPrimaryClickedAssetId.clear();
|
|
m_lastPrimaryClickTime = {};
|
|
if (hadAssetSelection && !ResolveProjectRuntime()->HasSelection()) {
|
|
EmitSelectionClearedEvent(EventSource::GridPrimary);
|
|
}
|
|
if (previousCurrentFolderId != GetBrowserModel().GetCurrentFolderId()) {
|
|
EmitEvent(
|
|
EventKind::FolderNavigated,
|
|
EventSource::Tree,
|
|
FindFolderEntry(GetBrowserModel().GetCurrentFolderId()));
|
|
}
|
|
return BuildDispatchResult(
|
|
true,
|
|
"Deleted project item '" + target->displayName + "'.");
|
|
}
|
|
|
|
return BuildDispatchResult(false, "Project does not expose this edit command.");
|
|
}
|
|
|
|
void ProjectPanel::ResetTransientFrames() {
|
|
m_treeFrame = {};
|
|
m_frameEvents.clear();
|
|
m_layout = {};
|
|
m_assetDropTargetSurface = DropTargetSurface::None;
|
|
m_hoveredAssetItemId.clear();
|
|
m_hoveredBreadcrumbIndex = kInvalidLayoutIndex;
|
|
m_pressedBreadcrumbIndex = kInvalidLayoutIndex;
|
|
m_splitterHovered = false;
|
|
m_splitterDragging = false;
|
|
}
|
|
|
|
void ProjectPanel::ClaimCommandFocus(
|
|
const std::vector<UIInputEvent>& inputEvents,
|
|
const UIRect& bounds,
|
|
bool allowInteraction) {
|
|
if (m_commandFocusService == nullptr) {
|
|
return;
|
|
}
|
|
|
|
for (const UIInputEvent& event : inputEvents) {
|
|
if (event.type == UIInputEventType::FocusGained) {
|
|
m_commandFocusService->ClaimFocus(EditorActionRoute::Project);
|
|
return;
|
|
}
|
|
|
|
if (!allowInteraction ||
|
|
event.type != UIInputEventType::PointerButtonDown ||
|
|
!ContainsPoint(bounds, event.position)) {
|
|
continue;
|
|
}
|
|
|
|
m_commandFocusService->ClaimFocus(EditorActionRoute::Project);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void ProjectPanel::Update(
|
|
const UIEditorPanelContentHostFrame& contentHostFrame,
|
|
const std::vector<UIInputEvent>& inputEvents,
|
|
const PanelInputContext& inputContext) {
|
|
m_requestPointerCapture = false;
|
|
m_requestPointerRelease = false;
|
|
m_frameEvents.clear();
|
|
GridDrag::ResetTransientRequests(m_assetDragState);
|
|
TreeDrag::ResetTransientRequests(m_treeDragState);
|
|
|
|
const UIEditorPanelContentHostPanelState* panelState =
|
|
FindMountedProjectPanel(contentHostFrame);
|
|
if (panelState == nullptr) {
|
|
if (m_splitterDragging ||
|
|
m_assetDragState.dragging ||
|
|
m_treeDragState.dragging ||
|
|
m_renameState.active) {
|
|
m_requestPointerRelease = true;
|
|
}
|
|
m_visible = false;
|
|
m_assetDragState = {};
|
|
m_treeDragState = {};
|
|
CloseContextMenu();
|
|
ClearRenameState();
|
|
ResetTransientFrames();
|
|
return;
|
|
}
|
|
|
|
if (!HasProjectRuntime()) {
|
|
m_visible = false;
|
|
CloseContextMenu();
|
|
ClearRenameState();
|
|
ResetTransientFrames();
|
|
return;
|
|
}
|
|
|
|
if (GetBrowserModel().GetTreeItems().empty()) {
|
|
ResolveProjectRuntime()->Refresh();
|
|
SyncCurrentFolderSelection();
|
|
SyncAssetSelectionFromRuntime();
|
|
}
|
|
|
|
m_visible = true;
|
|
SyncAssetSelectionFromRuntime();
|
|
const std::vector<UIInputEvent> filteredEvents =
|
|
BuildUIEditorPanelInputEvents(
|
|
panelState->bounds,
|
|
inputEvents,
|
|
UIEditorPanelInputFilterOptions{
|
|
.allowPointerInBounds = inputContext.allowInteraction,
|
|
.allowPointerWhileCaptured = HasActivePointerCapture(),
|
|
.allowKeyboardInput = inputContext.hasInputFocus,
|
|
.allowFocusEvents =
|
|
inputContext.hasInputFocus ||
|
|
HasActivePointerCapture() ||
|
|
inputContext.focusGained ||
|
|
inputContext.focusLost,
|
|
.includePointerLeave =
|
|
inputContext.allowInteraction || HasActivePointerCapture()
|
|
},
|
|
inputContext.focusGained,
|
|
inputContext.focusLost);
|
|
ClaimCommandFocus(filteredEvents, panelState->bounds, inputContext.allowInteraction);
|
|
|
|
m_navigationWidth = ClampNavigationWidth(m_navigationWidth, panelState->bounds.width);
|
|
m_layout = BuildLayout(panelState->bounds);
|
|
if (m_contextMenu.open) {
|
|
RebuildContextMenu();
|
|
}
|
|
const Widgets::UIEditorTreeViewMetrics treeMetrics = ResolveUIEditorTreeViewMetrics();
|
|
m_treeFrame.layout = Widgets::BuildUIEditorTreeViewLayout(
|
|
m_layout.treeRect,
|
|
GetBrowserModel().GetTreeItems(),
|
|
m_folderExpansion,
|
|
treeMetrics);
|
|
m_treeFrame.result = {};
|
|
|
|
if ((m_renameState.active || !m_pendingRenameItemId.empty()) &&
|
|
(m_assetDragState.dragging || m_treeDragState.dragging)) {
|
|
m_assetDragState = {};
|
|
m_treeDragState = {};
|
|
}
|
|
|
|
if (m_renameState.active || !m_pendingRenameItemId.empty()) {
|
|
TryStartQueuedRenameSession();
|
|
UpdateRenameSession(filteredEvents);
|
|
return;
|
|
}
|
|
|
|
const std::vector<UIInputEvent> treeEvents =
|
|
BuildTreeInteractionInputEvents(
|
|
inputEvents,
|
|
panelState->bounds,
|
|
inputContext);
|
|
m_treeFrame = UpdateUIEditorTreeViewInteraction(
|
|
m_treeInteractionState,
|
|
m_folderSelection,
|
|
m_folderExpansion,
|
|
m_layout.treeRect,
|
|
GetBrowserModel().GetTreeItems(),
|
|
treeEvents,
|
|
treeMetrics);
|
|
|
|
if (m_treeFrame.result.selectionChanged &&
|
|
!m_treeFrame.result.selectedItemId.empty() &&
|
|
m_treeFrame.result.selectedItemId != GetBrowserModel().GetCurrentFolderId()) {
|
|
CloseContextMenu();
|
|
NavigateToFolder(m_treeFrame.result.selectedItemId, EventSource::Tree);
|
|
m_layout = BuildLayout(panelState->bounds);
|
|
}
|
|
if (m_treeFrame.result.renameRequested &&
|
|
!m_treeFrame.result.renameItemId.empty()) {
|
|
QueueRenameSession(m_treeFrame.result.renameItemId, RenameSurface::Tree);
|
|
EmitEvent(
|
|
EventKind::RenameRequested,
|
|
EventSource::Tree,
|
|
FindFolderEntry(m_treeFrame.result.renameItemId));
|
|
TryStartQueuedRenameSession();
|
|
return;
|
|
}
|
|
|
|
struct ProjectTreeDragCallbacks {
|
|
::XCEngine::UI::Widgets::UISelectionModel& folderSelection;
|
|
::XCEngine::UI::Widgets::UIExpansionModel& folderExpansion;
|
|
EditorProjectRuntime& projectRuntime;
|
|
|
|
bool IsItemSelected(std::string_view itemId) const {
|
|
return folderSelection.IsSelected(itemId);
|
|
}
|
|
|
|
bool SelectDraggedItem(std::string_view itemId) {
|
|
return folderSelection.SetSelection(std::string(itemId));
|
|
}
|
|
|
|
bool CanDropOnItem(
|
|
std::string_view draggedItemId,
|
|
std::string_view targetItemId) const {
|
|
return projectRuntime.CanReparentFolder(draggedItemId, targetItemId);
|
|
}
|
|
|
|
bool CanDropToRoot(std::string_view draggedItemId) const {
|
|
const std::optional<std::string> parentId =
|
|
projectRuntime.GetParentFolderId(draggedItemId);
|
|
return parentId.has_value() && parentId.value() != "Assets";
|
|
}
|
|
|
|
bool CommitDropOnItem(
|
|
std::string_view draggedItemId,
|
|
std::string_view targetItemId) {
|
|
std::string movedFolderId = {};
|
|
if (!projectRuntime.ReparentFolder(draggedItemId, targetItemId, &movedFolderId)) {
|
|
return false;
|
|
}
|
|
|
|
folderExpansion.Expand(std::string(targetItemId));
|
|
if (!movedFolderId.empty()) {
|
|
folderSelection.SetSelection(movedFolderId);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool CommitDropToRoot(std::string_view draggedItemId) {
|
|
std::string movedFolderId = {};
|
|
if (!projectRuntime.MoveFolderToRoot(draggedItemId, &movedFolderId)) {
|
|
return false;
|
|
}
|
|
|
|
if (!movedFolderId.empty()) {
|
|
folderSelection.SetSelection(movedFolderId);
|
|
}
|
|
return true;
|
|
}
|
|
} treeDragCallbacks{ m_folderSelection, m_folderExpansion, *ResolveProjectRuntime() };
|
|
const TreeDrag::ProcessResult treeDragResult =
|
|
TreeDrag::ProcessInputEvents(
|
|
m_treeDragState,
|
|
m_treeFrame.layout,
|
|
GetBrowserModel().GetTreeItems(),
|
|
FilterUIEditorTreePanelPointerInputEvents(
|
|
filteredEvents,
|
|
m_splitterDragging || m_assetDragState.dragging),
|
|
m_layout.treeRect,
|
|
treeDragCallbacks);
|
|
if (treeDragResult.dropCommitted) {
|
|
const bool hadAssetSelection = ResolveProjectRuntime()->HasSelection();
|
|
CloseContextMenu();
|
|
ResolveProjectRuntime()->ClearSelection();
|
|
SyncAssetSelectionFromRuntime();
|
|
m_hoveredAssetItemId.clear();
|
|
m_lastPrimaryClickedAssetId.clear();
|
|
if (hadAssetSelection && !ResolveProjectRuntime()->HasSelection()) {
|
|
EmitSelectionClearedEvent(EventSource::Tree);
|
|
}
|
|
SyncCurrentFolderSelection();
|
|
m_layout = BuildLayout(panelState->bounds);
|
|
m_treeFrame.layout = Widgets::BuildUIEditorTreeViewLayout(
|
|
m_layout.treeRect,
|
|
GetBrowserModel().GetTreeItems(),
|
|
m_folderExpansion,
|
|
treeMetrics);
|
|
}
|
|
|
|
struct ProjectAssetDragCallbacks {
|
|
::XCEngine::UI::Widgets::UISelectionModel& assetSelection;
|
|
::XCEngine::UI::Widgets::UIExpansionModel& folderExpansion;
|
|
EditorProjectRuntime& projectRuntime;
|
|
const Layout& layout;
|
|
const std::vector<AssetEntry>& assetEntries;
|
|
std::function<std::string(const UIPoint&, DropTargetSurface*)> resolveDropTarget = {};
|
|
DropTargetSurface dropTargetSurface = DropTargetSurface::None;
|
|
std::string movedItemId = {};
|
|
|
|
bool IsItemSelected(std::string_view itemId) const {
|
|
return assetSelection.IsSelected(itemId);
|
|
}
|
|
|
|
bool SelectDraggedItem(std::string_view itemId) {
|
|
return assetSelection.SetSelection(std::string(itemId));
|
|
}
|
|
|
|
std::string ResolveDraggableItem(const UIPoint& point) const {
|
|
for (const AssetTileLayout& tile : layout.assetTiles) {
|
|
if (tile.itemIndex >= assetEntries.size()) {
|
|
continue;
|
|
}
|
|
if (ContainsPoint(tile.tileRect, point)) {
|
|
return assetEntries[tile.itemIndex].itemId;
|
|
}
|
|
}
|
|
|
|
return {};
|
|
}
|
|
|
|
std::string ResolveDropTargetItem(
|
|
std::string_view draggedItemId,
|
|
const UIPoint& point) {
|
|
dropTargetSurface = DropTargetSurface::None;
|
|
std::string targetItemId = resolveDropTarget(point, &dropTargetSurface);
|
|
if (targetItemId.empty() || targetItemId == draggedItemId) {
|
|
dropTargetSurface = DropTargetSurface::None;
|
|
return {};
|
|
}
|
|
|
|
return targetItemId;
|
|
}
|
|
|
|
bool CanDropOnItem(
|
|
std::string_view draggedItemId,
|
|
std::string_view targetItemId) const {
|
|
return projectRuntime.CanMoveItemToFolder(draggedItemId, targetItemId);
|
|
}
|
|
|
|
bool CommitDropOnItem(
|
|
std::string_view draggedItemId,
|
|
std::string_view targetItemId) {
|
|
movedItemId.clear();
|
|
if (!projectRuntime.MoveItemToFolder(draggedItemId, targetItemId, &movedItemId)) {
|
|
return false;
|
|
}
|
|
|
|
folderExpansion.Expand(std::string(targetItemId));
|
|
return true;
|
|
}
|
|
} assetDragCallbacks{
|
|
m_assetSelection,
|
|
m_folderExpansion,
|
|
*ResolveProjectRuntime(),
|
|
m_layout,
|
|
GetBrowserModel().GetAssetEntries(),
|
|
[this](const UIPoint& point, DropTargetSurface* surface) {
|
|
return ResolveAssetDropTargetItemId(point, surface);
|
|
}
|
|
};
|
|
const GridDrag::ProcessResult assetDragResult =
|
|
GridDrag::ProcessInputEvents(
|
|
m_assetDragState,
|
|
filteredEvents,
|
|
assetDragCallbacks);
|
|
m_assetDropTargetSurface =
|
|
m_assetDragState.dragging && m_assetDragState.validDropTarget
|
|
? assetDragCallbacks.dropTargetSurface
|
|
: DropTargetSurface::None;
|
|
if (assetDragResult.selectionForced) {
|
|
const std::string& draggedItemId = m_assetDragState.draggedItemId.empty()
|
|
? m_assetDragState.armedItemId
|
|
: m_assetDragState.draggedItemId;
|
|
if (const AssetEntry* draggedAsset = FindAssetEntry(draggedItemId);
|
|
draggedAsset != nullptr) {
|
|
EmitEvent(EventKind::AssetSelected, EventSource::GridDrag, draggedAsset);
|
|
}
|
|
}
|
|
if (assetDragResult.dropCommitted) {
|
|
const bool hadAssetSelection = ResolveProjectRuntime()->HasSelection();
|
|
CloseContextMenu();
|
|
ClearRenameState();
|
|
m_hoveredAssetItemId.clear();
|
|
m_lastPrimaryClickedAssetId.clear();
|
|
m_lastPrimaryClickTime = {};
|
|
SyncCurrentFolderSelection();
|
|
|
|
const std::string movedItemId = assetDragCallbacks.movedItemId.empty()
|
|
? assetDragResult.draggedItemId
|
|
: assetDragCallbacks.movedItemId;
|
|
if (const AssetEntry* movedAsset = FindAssetEntry(movedItemId);
|
|
movedAsset != nullptr) {
|
|
ResolveProjectRuntime()->SetSelection(movedItemId);
|
|
SyncAssetSelectionFromRuntime();
|
|
EmitEvent(EventKind::AssetSelected, EventSource::GridDrag, movedAsset);
|
|
} else {
|
|
ResolveProjectRuntime()->ClearSelection();
|
|
SyncAssetSelectionFromRuntime();
|
|
if (hadAssetSelection && !ResolveProjectRuntime()->HasSelection()) {
|
|
EmitSelectionClearedEvent(EventSource::GridDrag);
|
|
}
|
|
}
|
|
|
|
m_layout = BuildLayout(panelState->bounds);
|
|
m_treeFrame.layout = Widgets::BuildUIEditorTreeViewLayout(
|
|
m_layout.treeRect,
|
|
GetBrowserModel().GetTreeItems(),
|
|
m_folderExpansion,
|
|
treeMetrics);
|
|
}
|
|
|
|
const bool suppressPanelPointerEvents =
|
|
m_assetDragState.dragging ||
|
|
m_assetDragState.requestPointerCapture ||
|
|
m_assetDragState.requestPointerRelease ||
|
|
m_treeDragState.armed ||
|
|
m_treeDragState.dragging ||
|
|
m_treeDragState.requestPointerCapture ||
|
|
m_treeDragState.requestPointerRelease;
|
|
|
|
for (const UIInputEvent& event : filteredEvents) {
|
|
if (suppressPanelPointerEvents) {
|
|
switch (event.type) {
|
|
case UIInputEventType::PointerMove:
|
|
case UIInputEventType::PointerButtonDown:
|
|
case UIInputEventType::PointerButtonUp:
|
|
case UIInputEventType::PointerWheel:
|
|
case UIInputEventType::PointerEnter:
|
|
continue;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (HandleContextMenuEvent(event)) {
|
|
continue;
|
|
}
|
|
|
|
switch (event.type) {
|
|
case UIInputEventType::FocusLost:
|
|
m_hoveredAssetItemId.clear();
|
|
m_hoveredBreadcrumbIndex = kInvalidLayoutIndex;
|
|
m_pressedBreadcrumbIndex = kInvalidLayoutIndex;
|
|
m_splitterHovered = false;
|
|
if (m_splitterDragging) {
|
|
m_splitterDragging = false;
|
|
m_requestPointerRelease = true;
|
|
}
|
|
break;
|
|
|
|
case UIInputEventType::PointerMove: {
|
|
if (m_splitterDragging) {
|
|
m_navigationWidth =
|
|
ClampNavigationWidth(event.position.x - panelState->bounds.x, panelState->bounds.width);
|
|
m_layout = BuildLayout(panelState->bounds);
|
|
}
|
|
|
|
m_splitterHovered =
|
|
m_splitterDragging || ContainsPoint(m_layout.dividerRect, event.position);
|
|
m_hoveredBreadcrumbIndex = HitTestBreadcrumbItem(event.position);
|
|
const std::size_t hoveredAssetIndex = HitTestAssetTile(event.position);
|
|
const auto& assetEntries = GetBrowserModel().GetAssetEntries();
|
|
m_hoveredAssetItemId =
|
|
hoveredAssetIndex < assetEntries.size()
|
|
? assetEntries[hoveredAssetIndex].itemId
|
|
: std::string();
|
|
break;
|
|
}
|
|
|
|
case UIInputEventType::PointerLeave:
|
|
if (!m_splitterDragging) {
|
|
m_splitterHovered = false;
|
|
}
|
|
m_hoveredBreadcrumbIndex = kInvalidLayoutIndex;
|
|
m_hoveredAssetItemId.clear();
|
|
break;
|
|
|
|
case UIInputEventType::PointerButtonDown:
|
|
if (event.pointerButton == ::XCEngine::UI::UIPointerButton::Left) {
|
|
if (ContainsPoint(m_layout.dividerRect, event.position)) {
|
|
m_splitterDragging = true;
|
|
m_splitterHovered = true;
|
|
m_pressedBreadcrumbIndex = kInvalidLayoutIndex;
|
|
m_requestPointerCapture = true;
|
|
break;
|
|
}
|
|
|
|
m_pressedBreadcrumbIndex = HitTestBreadcrumbItem(event.position);
|
|
|
|
if (!ContainsPoint(m_layout.gridRect, event.position)) {
|
|
break;
|
|
}
|
|
|
|
const auto& assetEntries = GetBrowserModel().GetAssetEntries();
|
|
const std::size_t hitIndex = HitTestAssetTile(event.position);
|
|
if (hitIndex >= assetEntries.size()) {
|
|
if (ResolveProjectRuntime()->HasSelection()) {
|
|
ResolveProjectRuntime()->ClearSelection();
|
|
SyncAssetSelectionFromRuntime();
|
|
EmitSelectionClearedEvent(EventSource::Background);
|
|
}
|
|
break;
|
|
}
|
|
|
|
const AssetEntry& assetEntry = assetEntries[hitIndex];
|
|
const bool alreadySelected = m_assetSelection.IsSelected(assetEntry.itemId);
|
|
const bool selectionChanged = ResolveProjectRuntime()->SetSelection(assetEntry.itemId);
|
|
SyncAssetSelectionFromRuntime();
|
|
if (selectionChanged) {
|
|
EmitEvent(EventKind::AssetSelected, EventSource::GridPrimary, &assetEntry);
|
|
}
|
|
|
|
const auto now = std::chrono::steady_clock::now();
|
|
const bool doubleClicked =
|
|
alreadySelected &&
|
|
m_lastPrimaryClickedAssetId == assetEntry.itemId &&
|
|
m_lastPrimaryClickTime != std::chrono::steady_clock::time_point{} &&
|
|
now - m_lastPrimaryClickTime <= kGridDoubleClickInterval;
|
|
|
|
m_lastPrimaryClickedAssetId = assetEntry.itemId;
|
|
m_lastPrimaryClickTime = now;
|
|
if (!doubleClicked) {
|
|
break;
|
|
}
|
|
|
|
OpenProjectItem(assetEntry.itemId, EventSource::GridDoubleClick);
|
|
break;
|
|
}
|
|
|
|
if (event.pointerButton == ::XCEngine::UI::UIPointerButton::Right &&
|
|
ContainsPoint(m_layout.gridRect, event.position)) {
|
|
const auto& assetEntries = GetBrowserModel().GetAssetEntries();
|
|
const std::size_t hitIndex = HitTestAssetTile(event.position);
|
|
if (hitIndex >= assetEntries.size()) {
|
|
EmitEvent(
|
|
EventKind::ContextMenuRequested,
|
|
EventSource::Background,
|
|
static_cast<const AssetEntry*>(nullptr));
|
|
OpenContextMenu(event.position, {}, true);
|
|
break;
|
|
}
|
|
|
|
const AssetEntry& assetEntry = assetEntries[hitIndex];
|
|
if (!m_assetSelection.IsSelected(assetEntry.itemId)) {
|
|
ResolveProjectRuntime()->SetSelection(assetEntry.itemId);
|
|
SyncAssetSelectionFromRuntime();
|
|
EmitEvent(EventKind::AssetSelected, EventSource::GridSecondary, &assetEntry);
|
|
}
|
|
EmitEvent(EventKind::ContextMenuRequested, EventSource::GridSecondary, &assetEntry);
|
|
OpenContextMenu(event.position, assetEntry.itemId, false);
|
|
}
|
|
break;
|
|
|
|
case UIInputEventType::PointerButtonUp:
|
|
if (event.pointerButton != ::XCEngine::UI::UIPointerButton::Left) {
|
|
break;
|
|
}
|
|
|
|
if (m_splitterDragging) {
|
|
m_splitterDragging = false;
|
|
m_splitterHovered = ContainsPoint(m_layout.dividerRect, event.position);
|
|
m_requestPointerRelease = true;
|
|
break;
|
|
}
|
|
|
|
{
|
|
const std::size_t releasedBreadcrumbIndex =
|
|
HitTestBreadcrumbItem(event.position);
|
|
if (m_pressedBreadcrumbIndex != kInvalidLayoutIndex &&
|
|
m_pressedBreadcrumbIndex == releasedBreadcrumbIndex &&
|
|
releasedBreadcrumbIndex < m_layout.breadcrumbItems.size()) {
|
|
const BreadcrumbItemLayout& item =
|
|
m_layout.breadcrumbItems[releasedBreadcrumbIndex];
|
|
if (item.clickable) {
|
|
NavigateToFolder(item.targetFolderId, EventSource::Breadcrumb);
|
|
m_layout = BuildLayout(panelState->bounds);
|
|
}
|
|
}
|
|
m_pressedBreadcrumbIndex = kInvalidLayoutIndex;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
ProjectPanel::Layout ProjectPanel::BuildLayout(const UIRect& bounds) const {
|
|
Layout layout = {};
|
|
const auto& assetEntries = GetBrowserModel().GetAssetEntries();
|
|
const std::vector<ProjectBrowserModel::BreadcrumbSegment> breadcrumbSegments =
|
|
GetBrowserModel().BuildBreadcrumbSegments();
|
|
const float dividerThickness = ResolveUIEditorDockHostMetrics().splitterMetrics.thickness;
|
|
layout.bounds = UIRect(
|
|
bounds.x,
|
|
bounds.y,
|
|
ClampNonNegative(bounds.width),
|
|
ClampNonNegative(bounds.height));
|
|
|
|
const float leftWidth = ClampNavigationWidth(m_navigationWidth, layout.bounds.width);
|
|
layout.leftPaneRect = UIRect(
|
|
layout.bounds.x,
|
|
layout.bounds.y,
|
|
leftWidth,
|
|
layout.bounds.height);
|
|
layout.dividerRect = UIRect(
|
|
layout.leftPaneRect.x + layout.leftPaneRect.width,
|
|
layout.bounds.y,
|
|
dividerThickness,
|
|
layout.bounds.height);
|
|
layout.rightPaneRect = UIRect(
|
|
layout.dividerRect.x + layout.dividerRect.width,
|
|
layout.bounds.y,
|
|
ClampNonNegative(layout.bounds.width - layout.leftPaneRect.width - layout.dividerRect.width),
|
|
layout.bounds.height);
|
|
|
|
layout.treeRect = UIRect(
|
|
layout.leftPaneRect.x,
|
|
layout.leftPaneRect.y + kTreeTopPadding,
|
|
layout.leftPaneRect.width,
|
|
ClampNonNegative(layout.leftPaneRect.height - kTreeTopPadding));
|
|
|
|
layout.browserHeaderRect = UIRect(
|
|
layout.rightPaneRect.x,
|
|
layout.rightPaneRect.y,
|
|
layout.rightPaneRect.width,
|
|
(std::min)(kBrowserHeaderHeight, layout.rightPaneRect.height));
|
|
layout.browserBodyRect = UIRect(
|
|
layout.rightPaneRect.x,
|
|
layout.browserHeaderRect.y + layout.browserHeaderRect.height,
|
|
layout.rightPaneRect.width,
|
|
ClampNonNegative(layout.rightPaneRect.height - layout.browserHeaderRect.height));
|
|
layout.gridRect = UIRect(
|
|
layout.browserBodyRect.x + kGridInsetX,
|
|
layout.browserBodyRect.y + kGridInsetY,
|
|
ClampNonNegative(layout.browserBodyRect.width - kGridInsetX * 2.0f),
|
|
ClampNonNegative(layout.browserBodyRect.height - kGridInsetY * 2.0f));
|
|
|
|
const float breadcrumbRowHeight = kHeaderFontSize + kBreadcrumbItemPaddingY * 2.0f;
|
|
const float breadcrumbY =
|
|
layout.browserHeaderRect.y + std::floor((layout.browserHeaderRect.height - breadcrumbRowHeight) * 0.5f);
|
|
const float headerRight =
|
|
layout.browserHeaderRect.x + layout.browserHeaderRect.width - kHeaderHorizontalPadding;
|
|
float nextItemX = layout.browserHeaderRect.x + kHeaderHorizontalPadding;
|
|
for (std::size_t index = 0u; index < breadcrumbSegments.size(); ++index) {
|
|
if (index > 0u) {
|
|
const float separatorWidth = MeasureTextWidth(m_textMeasurer, ">", kHeaderFontSize);
|
|
if (nextItemX < headerRight && separatorWidth > 0.0f) {
|
|
layout.breadcrumbItems.push_back({
|
|
">",
|
|
{},
|
|
UIRect(
|
|
nextItemX,
|
|
breadcrumbY,
|
|
ClampNonNegative((std::min)(separatorWidth, headerRight - nextItemX)),
|
|
breadcrumbRowHeight),
|
|
true,
|
|
false,
|
|
false
|
|
});
|
|
}
|
|
nextItemX += separatorWidth + kBreadcrumbSpacing;
|
|
}
|
|
|
|
const ProjectBrowserModel::BreadcrumbSegment& segment = breadcrumbSegments[index];
|
|
const float labelWidth = MeasureTextWidth(m_textMeasurer, segment.label, kHeaderFontSize);
|
|
const float itemWidth = labelWidth + kBreadcrumbItemPaddingX * 2.0f;
|
|
const float availableWidth = headerRight - nextItemX;
|
|
if (availableWidth <= 0.0f) {
|
|
break;
|
|
}
|
|
|
|
layout.breadcrumbItems.push_back({
|
|
segment.label,
|
|
segment.targetFolderId,
|
|
UIRect(
|
|
nextItemX,
|
|
breadcrumbY,
|
|
ClampNonNegative((std::min)(itemWidth, availableWidth)),
|
|
breadcrumbRowHeight),
|
|
false,
|
|
!segment.current,
|
|
segment.current
|
|
});
|
|
nextItemX += itemWidth + kBreadcrumbSpacing;
|
|
}
|
|
|
|
const float effectiveTileWidth = kGridTileWidth + kGridTileGapX;
|
|
int columnCount = effectiveTileWidth > 0.0f
|
|
? static_cast<int>((layout.gridRect.width + kGridTileGapX) / effectiveTileWidth)
|
|
: 1;
|
|
if (columnCount < 1) {
|
|
columnCount = 1;
|
|
}
|
|
|
|
layout.assetTiles.reserve(assetEntries.size());
|
|
for (std::size_t index = 0; index < assetEntries.size(); ++index) {
|
|
const int column = static_cast<int>(index % static_cast<std::size_t>(columnCount));
|
|
const int row = static_cast<int>(index / static_cast<std::size_t>(columnCount));
|
|
const float tileX = layout.gridRect.x + static_cast<float>(column) * (kGridTileWidth + kGridTileGapX);
|
|
const float tileY = layout.gridRect.y + static_cast<float>(row) * (kGridTileHeight + kGridTileGapY);
|
|
|
|
AssetTileLayout tile = {};
|
|
tile.itemIndex = index;
|
|
tile.tileRect = UIRect(tileX, tileY, kGridTileWidth, kGridTileHeight);
|
|
tile.previewRect = UIRect(
|
|
tile.tileRect.x + (tile.tileRect.width - kGridPreviewWidth) * 0.5f,
|
|
tile.tileRect.y + 6.0f,
|
|
kGridPreviewWidth,
|
|
kGridPreviewHeight);
|
|
tile.labelRect = UIRect(
|
|
tile.tileRect.x + 4.0f,
|
|
tile.previewRect.y + tile.previewRect.height + 8.0f,
|
|
tile.tileRect.width - 8.0f,
|
|
18.0f);
|
|
layout.assetTiles.push_back(tile);
|
|
}
|
|
|
|
return layout;
|
|
}
|
|
|
|
std::size_t ProjectPanel::HitTestBreadcrumbItem(const UIPoint& point) const {
|
|
for (std::size_t index = 0u; index < m_layout.breadcrumbItems.size(); ++index) {
|
|
const BreadcrumbItemLayout& item = m_layout.breadcrumbItems[index];
|
|
if (!item.separator && ContainsPoint(item.rect, point)) {
|
|
return index;
|
|
}
|
|
}
|
|
|
|
return kInvalidLayoutIndex;
|
|
}
|
|
|
|
std::size_t ProjectPanel::HitTestAssetTile(const UIPoint& point) const {
|
|
for (const AssetTileLayout& tile : m_layout.assetTiles) {
|
|
if (ContainsPoint(tile.tileRect, point)) {
|
|
return tile.itemIndex;
|
|
}
|
|
}
|
|
|
|
return kInvalidLayoutIndex;
|
|
}
|
|
|
|
std::string ProjectPanel::ResolveAssetDropTargetItemId(
|
|
const UIPoint& point,
|
|
DropTargetSurface* surface) const {
|
|
if (surface != nullptr) {
|
|
*surface = DropTargetSurface::None;
|
|
}
|
|
|
|
if (ContainsPoint(m_treeFrame.layout.bounds, point)) {
|
|
Widgets::UIEditorTreeViewHitTarget hitTarget =
|
|
Widgets::HitTestUIEditorTreeView(m_treeFrame.layout, point);
|
|
if (hitTarget.itemIndex < GetBrowserModel().GetTreeItems().size() &&
|
|
(hitTarget.kind == Widgets::UIEditorTreeViewHitTargetKind::Row ||
|
|
hitTarget.kind == Widgets::UIEditorTreeViewHitTargetKind::Disclosure)) {
|
|
if (surface != nullptr) {
|
|
*surface = DropTargetSurface::Tree;
|
|
}
|
|
return GetBrowserModel().GetTreeItems()[hitTarget.itemIndex].itemId;
|
|
}
|
|
}
|
|
|
|
const auto& assetEntries = GetBrowserModel().GetAssetEntries();
|
|
const std::size_t assetIndex = HitTestAssetTile(point);
|
|
if (assetIndex < assetEntries.size() &&
|
|
assetEntries[assetIndex].directory) {
|
|
if (surface != nullptr) {
|
|
*surface = DropTargetSurface::Grid;
|
|
}
|
|
return assetEntries[assetIndex].itemId;
|
|
}
|
|
|
|
return {};
|
|
}
|
|
|
|
void ProjectPanel::Append(UIDrawList& drawList) const {
|
|
if (!m_visible || m_layout.bounds.width <= 0.0f || m_layout.bounds.height <= 0.0f) {
|
|
return;
|
|
}
|
|
|
|
const auto& assetEntries = GetBrowserModel().GetAssetEntries();
|
|
|
|
drawList.AddFilledRect(m_layout.bounds, kSurfaceColor);
|
|
drawList.AddFilledRect(m_layout.leftPaneRect, kPaneColor);
|
|
drawList.AddFilledRect(m_layout.rightPaneRect, kPaneColor);
|
|
drawList.AddFilledRect(
|
|
m_layout.dividerRect,
|
|
ResolveUIEditorDockHostPalette().splitterColor);
|
|
|
|
drawList.AddFilledRect(m_layout.browserHeaderRect, kHeaderColor);
|
|
drawList.AddFilledRect(
|
|
UIRect(
|
|
m_layout.browserHeaderRect.x,
|
|
m_layout.browserHeaderRect.y + m_layout.browserHeaderRect.height - kHeaderBottomBorderThickness,
|
|
m_layout.browserHeaderRect.width,
|
|
kHeaderBottomBorderThickness),
|
|
ResolveUIEditorDockHostPalette().splitterColor);
|
|
|
|
const Widgets::UIEditorTreeViewPalette treePalette = ResolveUIEditorTreeViewPalette();
|
|
const Widgets::UIEditorTreeViewMetrics treeMetrics = ResolveUIEditorTreeViewMetrics();
|
|
AppendUIEditorTreeViewBackground(
|
|
drawList,
|
|
m_treeFrame.layout,
|
|
GetBrowserModel().GetTreeItems(),
|
|
m_folderSelection,
|
|
m_treeInteractionState.treeViewState,
|
|
treePalette,
|
|
treeMetrics);
|
|
AppendUIEditorTreeViewForeground(
|
|
drawList,
|
|
m_treeFrame.layout,
|
|
GetBrowserModel().GetTreeItems(),
|
|
treePalette,
|
|
treeMetrics);
|
|
|
|
if (m_treeDragState.dragging && m_treeDragState.validDropTarget) {
|
|
if (m_treeDragState.dropToRoot) {
|
|
drawList.AddRectOutline(
|
|
m_treeFrame.layout.bounds,
|
|
kDropPreviewColor,
|
|
1.0f,
|
|
0.0f);
|
|
} else {
|
|
const std::size_t visibleIndex = FindUIEditorTreePanelVisibleItemIndex(
|
|
m_treeFrame.layout,
|
|
GetBrowserModel().GetTreeItems(),
|
|
m_treeDragState.dropTargetItemId);
|
|
if (visibleIndex != Widgets::UIEditorTreeViewInvalidIndex &&
|
|
visibleIndex < m_treeFrame.layout.rowRects.size()) {
|
|
drawList.AddRectOutline(
|
|
m_treeFrame.layout.rowRects[visibleIndex],
|
|
kDropPreviewColor,
|
|
1.0f,
|
|
0.0f);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (m_assetDragState.dragging &&
|
|
m_assetDragState.validDropTarget &&
|
|
m_assetDropTargetSurface == DropTargetSurface::Tree) {
|
|
const std::size_t visibleIndex = FindUIEditorTreePanelVisibleItemIndex(
|
|
m_treeFrame.layout,
|
|
GetBrowserModel().GetTreeItems(),
|
|
m_assetDragState.dropTargetItemId);
|
|
if (visibleIndex != Widgets::UIEditorTreeViewInvalidIndex &&
|
|
visibleIndex < m_treeFrame.layout.rowRects.size()) {
|
|
drawList.AddRectOutline(
|
|
m_treeFrame.layout.rowRects[visibleIndex],
|
|
kDropPreviewColor,
|
|
1.0f,
|
|
0.0f);
|
|
}
|
|
}
|
|
|
|
drawList.PushClipRect(m_layout.browserHeaderRect);
|
|
for (std::size_t index = 0u; index < m_layout.breadcrumbItems.size(); ++index) {
|
|
const BreadcrumbItemLayout& item = m_layout.breadcrumbItems[index];
|
|
const UIColor textColor =
|
|
item.separator
|
|
? kTextMuted
|
|
: (index == m_hoveredBreadcrumbIndex && item.clickable
|
|
? kTextStrong
|
|
: (item.current ? kTextPrimary : kTextMuted));
|
|
const float textWidth = MeasureTextWidth(m_textMeasurer, item.label, kHeaderFontSize);
|
|
const float textX = item.separator
|
|
? item.rect.x
|
|
: item.rect.x + (item.rect.width - textWidth) * 0.5f;
|
|
drawList.AddText(
|
|
UIPoint(textX, ResolveTextTop(item.rect.y, item.rect.height, kHeaderFontSize)),
|
|
item.label,
|
|
textColor,
|
|
kHeaderFontSize);
|
|
}
|
|
drawList.PopClipRect();
|
|
|
|
for (const AssetTileLayout& tile : m_layout.assetTiles) {
|
|
if (tile.itemIndex >= assetEntries.size()) {
|
|
continue;
|
|
}
|
|
|
|
const AssetEntry& assetEntry = assetEntries[tile.itemIndex];
|
|
const bool selected = m_assetSelection.IsSelected(assetEntry.itemId);
|
|
const bool hovered = m_hoveredAssetItemId == assetEntry.itemId;
|
|
|
|
if (selected || hovered) {
|
|
drawList.AddFilledRect(
|
|
tile.tileRect,
|
|
selected ? kTileSelectedColor : kTileHoverColor);
|
|
}
|
|
|
|
AppendTilePreview(drawList, tile.previewRect, assetEntry.directory);
|
|
|
|
drawList.PushClipRect(tile.labelRect);
|
|
const float textWidth =
|
|
MeasureTextWidth(m_textMeasurer, assetEntry.displayName, kTileLabelFontSize);
|
|
drawList.AddText(
|
|
UIPoint(
|
|
tile.labelRect.x + (tile.labelRect.width - textWidth) * 0.5f,
|
|
ResolveTextTop(tile.labelRect.y, tile.labelRect.height, kTileLabelFontSize)),
|
|
assetEntry.displayName,
|
|
kTextPrimary,
|
|
kTileLabelFontSize);
|
|
drawList.PopClipRect();
|
|
}
|
|
|
|
if (m_assetDragState.dragging &&
|
|
m_assetDragState.validDropTarget &&
|
|
m_assetDropTargetSurface == DropTargetSurface::Grid) {
|
|
for (const AssetTileLayout& tile : m_layout.assetTiles) {
|
|
if (tile.itemIndex >= assetEntries.size()) {
|
|
continue;
|
|
}
|
|
|
|
const AssetEntry& assetEntry = assetEntries[tile.itemIndex];
|
|
if (assetEntry.itemId != m_assetDragState.dropTargetItemId) {
|
|
continue;
|
|
}
|
|
|
|
drawList.AddRectOutline(
|
|
tile.tileRect,
|
|
kDropPreviewColor,
|
|
1.0f,
|
|
0.0f);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (m_renameState.active) {
|
|
const Widgets::UIEditorTextFieldPalette textFieldPalette =
|
|
BuildUIEditorPropertyGridTextFieldPalette(
|
|
ResolveUIEditorPropertyGridPalette(),
|
|
ResolveUIEditorTextFieldPalette());
|
|
const Widgets::UIEditorTextFieldMetrics textFieldMetrics =
|
|
BuildUIEditorInlineRenameTextFieldMetrics(
|
|
BuildRenameBounds(m_renameState.itemId, m_activeRenameSurface),
|
|
BuildUIEditorPropertyGridTextFieldMetrics(
|
|
ResolveUIEditorPropertyGridMetrics(),
|
|
ResolveUIEditorTextFieldMetrics()));
|
|
AppendUIEditorInlineRenameSession(
|
|
drawList,
|
|
m_renameFrame,
|
|
m_renameState,
|
|
textFieldPalette,
|
|
textFieldMetrics);
|
|
}
|
|
|
|
if (assetEntries.empty()) {
|
|
const UIRect messageRect(
|
|
m_layout.gridRect.x,
|
|
m_layout.gridRect.y,
|
|
m_layout.gridRect.width,
|
|
18.0f);
|
|
drawList.AddText(
|
|
UIPoint(messageRect.x, ResolveTextTop(messageRect.y, messageRect.height, kHeaderFontSize)),
|
|
"Current folder is empty.",
|
|
kTextMuted,
|
|
kHeaderFontSize);
|
|
}
|
|
|
|
AppendContextMenu(drawList);
|
|
}
|
|
|
|
} // namespace XCEngine::UI::Editor::App
|