CGNICO/UnrealEngine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
c11d382a6f0acddb0bc1e95ab9bc5f8fc3570b55
UnrealEngine/Engine/Source/Editor/ContentBrowser/Private/SPathView.cpp
Jeffreytsai1004 c11d382a6f ue5-main
2025-05-18 13:04:45 +08:00

3045 lines
99 KiB
C++
Raw Blame History

// Copyright Epic Games, Inc. All Rights Reserved.
#include "SPathView.h"
#include "Algo/AllOf.h"
#include "Algo/AnyOf.h"
#include "Algo/Copy.h"
#include "AssetRegistry/ARFilter.h"
#include "AssetToolsModule.h"
#include "Containers/ContainerAllocationPolicies.h"
#include "Containers/StringView.h"
#include "ContentBrowserConfig.h"
#include "ContentBrowserDataDragDropOp.h"
#include "ContentBrowserDataSource.h"
#include "ContentBrowserDataSubsystem.h"
#include "ContentBrowserItemData.h"
#include "ContentBrowserLog.h"
#include "ContentBrowserMenuUtils.h"
#include "ContentBrowserModule.h"
#include "ContentBrowserPathViewMenuContexts.h"
#include "ContentBrowserPluginFilters.h"
#include "ContentBrowserSingleton.h"
#include "ContentBrowserStyle.h"
#include "ContentBrowserUtils.h"
#include "CoreGlobals.h"
#include "CoreTypes.h"
#include "DragDropHandler.h"
#include "Fonts/SlateFontInfo.h"
#include "Framework/Application/SlateApplication.h"
#include "Framework/Commands/UIAction.h"
#include "Framework/Commands/UICommandInfo.h"
#include "HAL/PlatformTime.h"
#include "HistoryManager.h"
#include "IAssetTools.h"
#include "IContentBrowserDataModule.h"
#include "Input/Events.h"
#include "InputCoreTypes.h"
#include "Interfaces/IPluginManager.h"
#include "Layout/Children.h"
#include "Layout/Margin.h"
#include "Layout/SlateRect.h"
#include "Layout/WidgetPath.h"
#include "Logging/LogCategory.h"
#include "Logging/LogMacros.h"
#include "Misc/CString.h"
#include "Misc/ComparisonUtility.h"
#include "Misc/ConfigCacheIni.h"
#include "Misc/FilterCollection.h"
#include "Misc/NamePermissionList.h"
#include "Misc/PathViews.h"
#include "Misc/Paths.h"
#include "Misc/StringBuilder.h"
#include "Modules/ModuleManager.h"
#include "PathViewTypes.h"
#include "ProfilingDebugging/CpuProfilerTrace.h"
#include "Settings/ContentBrowserSettings.h"
#include "SlotBase.h"
#include "SourcesSearch.h"
#include "SourcesViewWidgets.h"
#include "Styling/AppStyle.h"
#include "Styling/ISlateStyle.h"
#include "Textures/SlateIcon.h"
#include "ToolMenu.h"
#include "ToolMenus.h"
#include "ToolMenuSection.h"
#include "Framework/Commands/GenericCommands.h"
#include "Trace/Detail/Channel.h"
#include "Types/WidgetActiveTimerDelegate.h"
#include "UObject/UObjectGlobals.h"
#include "UObject/UnrealNames.h"
#include "Widgets/Input/SComboButton.h"
#include "Widgets/Input/SSearchBox.h"
#include "Widgets/Layout/SBorder.h"
#include "Widgets/Layout/SBox.h"
#include "Widgets/Layout/SExpandableArea.h"
#include "Widgets/Layout/SSeparator.h"
#include "Widgets/Layout/SSplitter.h"
#include "Widgets/SBoxPanel.h"
#include "Widgets/Text/STextBlock.h"
#include "Widgets/Views/ITableRow.h"
#include "Widgets/Views/STableRow.h"
class FDragDropOperation;
class SWidget;
struct FAssetData;
struct FGeometry;
DEFINE_LOG_CATEGORY_STATIC(LogPathView, Log, Log);
#define LOCTEXT_NAMESPACE "ContentBrowser"
namespace UE::PathView
{
TArray<TWeakPtr<SPathView>> AllPathViews;
FAutoConsoleCommand RepopulateAllPathViewsCommand(TEXT("PathView.Repopulate"),
TEXT("Repopulate all path views to expose bugs with caching/data updates"),
FConsoleCommandDelegate::CreateLambda([]() {
for (TWeakPtr<SPathView> WeakView : AllPathViews)
{
if (TSharedPtr<SPathView> View = WeakView.Pin())
{
View->Populate();
}
}
}));
TSharedRef<FTreeItem> CreateOrReuseNode(FContentBrowserItemData&& InData,
TMap<FName, TSharedPtr<FTreeItem>>* OldItemsByInvariantPath)
{
if (OldItemsByInvariantPath)
{
TSharedPtr<FTreeItem> ExistingItem;
// Reolve old value so we don't pick it out again when looking at another item from a different source
if (OldItemsByInvariantPath->RemoveAndCopyValue(InData.GetInvariantPath(), ExistingItem)
&& ExistingItem.IsValid())
{
ExistingItem->RemoveAllChildren();
ExistingItem->SetItemData(FContentBrowserItem(MoveTemp(InData)));
return ExistingItem.ToSharedRef();
}
}
return MakeShared<FTreeItem>(MoveTemp(InData));
}
void DefaultSort(TArray<TSharedPtr<FTreeItem>>& InChildren)
{
if (InChildren.Num() < 2)
{
return;
}
static const FString ClassesPrefix = TEXT("Classes_");
struct FItemSortInfo
{
// Name to display
FString FolderName;
float Priority;
int32 SpecialDefaultFolderPriority;
bool bIsClassesFolder;
TSharedPtr<FTreeItem> TreeItem;
// Name to use when comparing "MyPlugin" vs "Classes_MyPlugin", looking up a plugin by name and other situations
FName ItemNameWithoutClassesPrefix;
};
TArray<FItemSortInfo> SortInfoArray;
SortInfoArray.Reserve(InChildren.Num());
const TArray<FName>& SpecialSortFolders =
IContentBrowserDataModule::Get().GetSubsystem()->GetPathViewSpecialSortFolders();
// Generate information needed to perform sort
for (TSharedPtr<FTreeItem>& It : InChildren)
{
FItemSortInfo& SortInfo = SortInfoArray.AddDefaulted_GetRef();
SortInfo.TreeItem = It;
const FName InvariantPathFName = It->GetItem().GetInvariantPath();
FNameBuilder InvariantPathBuilder(InvariantPathFName);
const FStringView InvariantPath(InvariantPathBuilder);
bool bIsRootInvariantFolder = false;
if (InvariantPath.Len() > 1)
{
FStringView RootInvariantFolder(InvariantPath);
RootInvariantFolder.RightChopInline(1);
int32 SecondSlashIndex = INDEX_NONE;
bIsRootInvariantFolder = !RootInvariantFolder.FindChar(TEXT('/'), SecondSlashIndex);
}
SortInfo.FolderName = It->GetItem().GetDisplayName().ToString();
SortInfo.bIsClassesFolder = false;
if (bIsRootInvariantFolder)
{
FNameBuilder ItemNameBuilder(It->GetItem().GetItemName());
const FStringView ItemNameView(ItemNameBuilder);
if (ItemNameView.StartsWith(ClassesPrefix))
{
SortInfo.bIsClassesFolder = true;
SortInfo.ItemNameWithoutClassesPrefix = FName(ItemNameView.RightChop(ClassesPrefix.Len()));
}
if (SortInfo.FolderName.StartsWith(ClassesPrefix))
{
SortInfo.bIsClassesFolder = true;
SortInfo.FolderName.RightChopInline(ClassesPrefix.Len(), EAllowShrinking::No);
}
}
if (SortInfo.ItemNameWithoutClassesPrefix.IsNone())
{
SortInfo.ItemNameWithoutClassesPrefix = It->GetItem().GetItemName();
}
if (SortInfo.bIsClassesFolder)
{
// Sort using a path without "Classes_" prefix
FStringView InvariantWithoutClassesPrefix(InvariantPath);
InvariantWithoutClassesPrefix.RightChopInline(1);
if (InvariantWithoutClassesPrefix.StartsWith(ClassesPrefix))
{
InvariantWithoutClassesPrefix.RightChopInline(ClassesPrefix.Len());
FNameBuilder Builder;
Builder.Append(TEXT("/"));
Builder.Append(InvariantWithoutClassesPrefix);
SortInfo.SpecialDefaultFolderPriority = SpecialSortFolders.IndexOfByKey(FName(Builder));
}
else
{
SortInfo.SpecialDefaultFolderPriority = SpecialSortFolders.IndexOfByKey(InvariantPathFName);
}
}
else
{
SortInfo.SpecialDefaultFolderPriority = SpecialSortFolders.IndexOfByKey(InvariantPathFName);
}
if (bIsRootInvariantFolder)
{
if (SortInfo.SpecialDefaultFolderPriority == INDEX_NONE)
{
SortInfo.Priority = FContentBrowserSingleton::Get()
.GetPluginSettings(SortInfo.ItemNameWithoutClassesPrefix)
.RootFolderSortPriority;
}
else
{
SortInfo.Priority = 1.f;
}
}
else
{
if (SortInfo.SpecialDefaultFolderPriority != INDEX_NONE)
{
SortInfo.Priority = 1.f;
}
else
{
SortInfo.Priority = 0.f;
}
}
}
// Perform sort
SortInfoArray.Sort([](const FItemSortInfo& SortInfoA, const FItemSortInfo& SortInfoB) -> bool {
if (SortInfoA.Priority != SortInfoB.Priority)
{
// Not the same priority, use priority to sort
return SortInfoA.Priority > SortInfoB.Priority;
}
else if (SortInfoA.SpecialDefaultFolderPriority != SortInfoB.SpecialDefaultFolderPriority)
{
// Special folders use the index to sort. Non special folders are all set to 0.
return SortInfoA.SpecialDefaultFolderPriority < SortInfoB.SpecialDefaultFolderPriority;
}
else
{
// If either is a class folder and names without classes prefix are same
if ((SortInfoA.bIsClassesFolder != SortInfoB.bIsClassesFolder)
&& (SortInfoA.ItemNameWithoutClassesPrefix == SortInfoB.ItemNameWithoutClassesPrefix))
{
return !SortInfoA.bIsClassesFolder;
}
// Two non special folders of the same priority, sort alphabetically
const int32 CompareResult =
UE::ComparisonUtility::CompareWithNumericSuffix(SortInfoA.FolderName, SortInfoB.FolderName);
if (CompareResult != 0)
{
return CompareResult < 0;
}
else
{
// Classes folders have the same name so sort them adjacent but under non-classes
return !SortInfoA.bIsClassesFolder;
}
}
});
// Replace with sorted array
TArray<TSharedPtr<FTreeItem>> NewList;
NewList.Reserve(SortInfoArray.Num());
for (const FItemSortInfo& It : SortInfoArray)
{
NewList.Add(It.TreeItem);
}
InChildren = MoveTemp(NewList);
}
} // namespace UE::PathView
// Struct to factor out path view data fetching/filtering as a precursor to being able to bind this data to the view
// instead of fetching it internally
struct FPathViewData
{
public:
FPathViewData(FName InContentBrowserName, bool InFlat)
: OwningContentBrowserName(InContentBrowserName)
, bFlat(InFlat)
, FolderPathTextFilter(decltype(FolderPathTextFilter)::FItemToStringArray::CreateStatic(
[](FStringView Input, TArray<FString>& Out) { Out.Emplace(FString(Input)); }))
{
}
~FPathViewData() { }
uint64 GetVersion()
{
return Version;
}
// Return an array that can be bound to a tree view widget for the current visible set of root items
TArray<TSharedPtr<FTreeItem>>* GetVisibleRootItems()
{
return &VisibleRootItems;
}
TTextFilter<FStringView>& GetFolderPathTextFilter()
{
return FolderPathTextFilter;
}
// Fetch all data from the content browser data backend and transform it into the tree data
void PopulateFullFolderTree(const FContentBrowserDataCompiledFilter& InFilter);
// Fetch favorite folders from config, filter them against the content browser data filter
// bFlat parameter adds all items at the root of the tree and not create parents
void PopulateWithFavorites(const FContentBrowserDataCompiledFilter& InFilter);
// Apply the current text filter to everything in the tree
void FilterFullFolderTree();
// Clear the filter state of all items in the tree
void ClearItemFilterState();
// Sort the roots of the tree
void SortRootItems();
// Add an item to the tree by its virtual path, reusing an old object if possible to ensure persistence of
// selection/expansion for the widget the items are bound to
TSharedRef<FTreeItem> AddFolderItem(FContentBrowserItemData&& InItemData);
// Remove the given item from the tree whether it's a root or child.
void RemoveFolderItem(const TSharedRef<FTreeItem>& InItem);
// Find an item with the exact virtual path
TSharedPtr<FTreeItem> FindTreeItem(FName InVirtualPath, bool bVisibleOnly = false);
// Search the tree for the item furthest from the root that matches the given path, if any
// Searches all items, not just visible ones according to the current text filter
TSharedPtr<FTreeItem> FindBestItemForPath(FStringView InVirtualPath);
// Apply new/modified/removed data notifications to the tree
// bFlat parameter adds all items at the root of the tree as in the favorites tree
void ProcessDataUpdates(TConstArrayView<FContentBrowserItemDataUpdate> InUpdatedItems,
const FContentBrowserDataCompiledFilter& InFilter);
protected:
TSharedRef<FTreeItem> AddFolderItemInternal(FContentBrowserItemData&& InItemData,
TMap<FName, TSharedPtr<FTreeItem>>* OldItemsByInvariantPath);
// Remove the given item data from the tree - if this results in an item having no data from any sources, the tree
// item is removed. If the item was removed and had a parent, the parent is returned.
TSharedPtr<FTreeItem> TryRemoveFolderItemInternal(const FContentBrowserItemData& InItem);
TSharedPtr<FTreeItem> TryRemoveFolderItemInternal(const FContentBrowserMinimalItemData& InKey);
bool PassesTextFilter(const TSharedPtr<FTreeItem>& InItem);
struct FEmptyFolderFilter
{
FContentBrowserFolderContentsFilter FolderFilter;
EContentBrowserIsFolderVisibleFlags FolderFlags;
};
FEmptyFolderFilter GetEmptyFolderFilter(const FContentBrowserDataCompiledFilter& CompiledDataFilter) const;
// Incremented to trigger tree rebuild from changes to the tree contents
uint64 Version;
// Items with no parent
TArray<TSharedPtr<FTreeItem>> RootItems;
// Items with no parent
TArray<TSharedPtr<FTreeItem>> VisibleRootItems;
// Mapping of full virtual path such as '/All/Game/Maps/Arena' to items
TMap<FName, TSharedPtr<FTreeItem>> VirtualPathToItem;
// Mapping of path that doesn't change based on display settings (e.g. '/MyPlugin/MyAsset') to item
// Used to reuse node objects when changing path view settings and rebuilding the tree
TMap<FName, TSharedPtr<FTreeItem>> InvariantPathToItem;
// Used for retrieving saved settings per content browser instance
FName OwningContentBrowserName;
// If true, parent items are not created and all items are added as roots.
bool bFlat;
TTextFilter<FStringView> FolderPathTextFilter;
};
FPathViewData::FEmptyFolderFilter FPathViewData::GetEmptyFolderFilter(const FContentBrowserDataCompiledFilter& CompiledDataFilter) const
{
const UContentBrowserSettings* ContentBrowserSettings = GetDefault<UContentBrowserSettings>();
bool bDisplayEmpty = ContentBrowserSettings->DisplayEmptyFolders;
// check to see if we have an instance config that overrides the default in UContentBrowserSettings
if (FContentBrowserInstanceConfig* EditorConfig =
ContentBrowserUtils::GetContentBrowserConfig(OwningContentBrowserName))
{
bDisplayEmpty = EditorConfig->bShowEmptyFolders;
}
FContentBrowserFolderContentsFilter FolderFilter;
if (bDisplayEmpty)
{
UContentBrowserDataSubsystem* ContentBrowserData = IContentBrowserDataModule::Get().GetSubsystem();
FolderFilter.HideFolderIfEmptyFilter = ContentBrowserData->CreateHideFolderIfEmptyFilter();
}
else
{
FolderFilter.ItemCategoryFilter = CompiledDataFilter.ItemCategoryFilter;
}
EContentBrowserIsFolderVisibleFlags FolderFlags = ContentBrowserUtils::GetIsFolderVisibleFlags(bDisplayEmpty);
return { MoveTemp(FolderFilter), FolderFlags };
}
void FPathViewData::PopulateFullFolderTree(const FContentBrowserDataCompiledFilter& CompiledDataFilter)
{
TMap<FName, TSharedPtr<FTreeItem>> OldItemsByInvariantPath = MoveTemp(InvariantPathToItem);
RootItems.Reset();
VisibleRootItems.Reset();
InvariantPathToItem.Reset();
VirtualPathToItem.Reset();
UContentBrowserDataSubsystem* ContentBrowserData = IContentBrowserDataModule::Get().GetSubsystem();
FEmptyFolderFilter EmptyFilter = GetEmptyFolderFilter(CompiledDataFilter);
TArray<TSharedPtr<FTreeItem>> ItemsCreated;
ContentBrowserData->EnumerateItemsMatchingFilter(CompiledDataFilter,
[this,
CompiledDataFilter,
EmptyFilter,
ContentBrowserData,
&OldItemsByInvariantPath](FContentBrowserItemData&& InItemData) {
UContentBrowserDataSource* Source = InItemData.GetOwnerDataSource();
if (Source && !Source->IsFolderVisible(InItemData.GetVirtualPath(), EmptyFilter.FolderFlags, EmptyFilter.FolderFilter))
{
UE_LOG(LogPathView, VeryVerbose, TEXT("[%s] Populate: skipping folder %s:%s that fails current pre-text filtering"),
*WriteToString<256>(OwningContentBrowserName),
*WriteToString<256>(Source->GetFName()),
*WriteToString<256>(InItemData.GetVirtualPath()));
return true; // continue enumerating
}
UE_LOG(LogPathView, VeryVerbose, TEXT("[%s] Populate: adding folder %s:%s"),
*WriteToString<256>(OwningContentBrowserName),
*WriteToString<256>(Source->GetFName()),
*WriteToString<256>(InItemData.GetVirtualPath()));
AddFolderItemInternal(MoveTemp(InItemData), &OldItemsByInvariantPath);
return true;
});
VisibleRootItems = RootItems;
++Version;
}
void FPathViewData::PopulateWithFavorites(const FContentBrowserDataCompiledFilter& CompiledDataFilter)
{
// Clear all root items and clear selection
TMap<FName, TSharedPtr<FTreeItem>> OldItemsByInvariantPath = MoveTemp(InvariantPathToItem);
RootItems.Reset();
VisibleRootItems.Reset();
InvariantPathToItem.Reset();
VirtualPathToItem.Reset();
const TArray<FString>& FavoritePaths = ContentBrowserUtils::GetFavoriteFolders();
UContentBrowserDataSubsystem* ContentBrowserData = IContentBrowserDataModule::Get().GetSubsystem();
FEmptyFolderFilter EmptyFilter = GetEmptyFolderFilter(CompiledDataFilter);
for (const FString& InvariantPath : FavoritePaths)
{
FName VirtualPath;
IContentBrowserDataModule::Get().GetSubsystem()->ConvertInternalPathToVirtual(InvariantPath, VirtualPath);
const FString Path = VirtualPath.ToString();
ContentBrowserData->EnumerateItemsAtPath(*Path,
CompiledDataFilter.ItemTypeFilter,
[this, &CompiledDataFilter, EmptyFilter, &OldItemsByInvariantPath](FContentBrowserItemData&& InItemData) {
UContentBrowserDataSource* ItemDataSource = InItemData.GetOwnerDataSource();
if (!ItemDataSource->IsFolderVisible(InItemData.GetVirtualPath(), EmptyFilter.FolderFlags, EmptyFilter.FolderFilter))
{
UE_LOG(LogPathView,
VeryVerbose,
TEXT("Hiding folder %s that fails current pre-text filtering"),
*WriteToString<256>(InItemData.GetVirtualPath()));
return true; // continue enumerating
}
ItemDataSource->ConvertItemForFilter(InItemData, CompiledDataFilter);
if (ItemDataSource->DoesItemPassFilter(InItemData, CompiledDataFilter))
{
AddFolderItemInternal(MoveTemp(InItemData), &OldItemsByInvariantPath);
}
return true;
});
}
++Version;
}
void FPathViewData::ProcessDataUpdates(TConstArrayView<FContentBrowserItemDataUpdate> InUpdatedItems,
const FContentBrowserDataCompiledFilter& CompiledDataFilter)
{
UContentBrowserDataSubsystem* ContentBrowserData = IContentBrowserDataModule::Get().GetSubsystem();
FEmptyFolderFilter EmptyFilter = GetEmptyFolderFilter(CompiledDataFilter);
auto DoesItemPassFilter = [this, EmptyFilter, ContentBrowserData, &CompiledDataFilter](
const FContentBrowserItemData& InItemData) {
UContentBrowserDataSource* ItemDataSource = InItemData.GetOwnerDataSource();
if (!ItemDataSource->DoesItemPassFilter(InItemData, CompiledDataFilter))
{
UE_LOG(LogPathView, VeryVerbose, TEXT("[%s] Fails compiled data filter"),
*WriteToString<256>(OwningContentBrowserName));
return false;
}
if (!ContentBrowserData->IsFolderVisible(InItemData.GetVirtualPath(), EmptyFilter.FolderFlags, EmptyFilter.FolderFilter))
{
UE_LOG(LogPathView, VeryVerbose, TEXT("[%s] Fails folder visibility filter"),
*WriteToString<256>(OwningContentBrowserName));
return false;
}
return true;
};
TArray<TSharedRef<FTreeItem>> NewItems;
TArray<TSharedRef<FTreeItem>> ModifiedParents; // Parents who need their bHasVisibleDescendants updated
for (const FContentBrowserItemDataUpdate& ItemDataUpdate : InUpdatedItems)
{
const FContentBrowserItemData& ItemDataRef = ItemDataUpdate.GetItemData();
if (!ItemDataRef.IsFolder())
{
continue;
}
FContentBrowserItemData ItemData = ItemDataRef;
ItemData.GetOwnerDataSource()->ConvertItemForFilter(ItemData, CompiledDataFilter);
switch (ItemDataUpdate.GetUpdateType())
{
case EContentBrowserItemUpdateType::Added:
UE_LOG(LogPathView, VeryVerbose, TEXT("[%s] Added item %s:%s"), *WriteToString<256>(OwningContentBrowserName),
*WriteToString<256>(ItemData.GetOwnerDataSource()->GetFName()),
*WriteToString<256>(ItemData.GetVirtualPath()));
if (DoesItemPassFilter(ItemData))
{
NewItems.Emplace(AddFolderItemInternal(MoveTemp(ItemData), nullptr));
}
break;
case EContentBrowserItemUpdateType::Modified:
UE_LOG(LogPathView, VeryVerbose, TEXT("[%s] Modified item %s:%s"), *WriteToString<256>(OwningContentBrowserName),
*WriteToString<256>(ItemData.GetOwnerDataSource()->GetFName()),
*WriteToString<256>(ItemData.GetVirtualPath()));
if (DoesItemPassFilter(ItemData))
{
NewItems.Emplace(AddFolderItemInternal(MoveTemp(ItemData), nullptr));
}
else
{
TSharedPtr<FTreeItem> Parent = TryRemoveFolderItemInternal(ItemData);
if (Parent.IsValid())
{
ModifiedParents.Emplace(Parent.ToSharedRef());
}
}
break;
case EContentBrowserItemUpdateType::Moved:
{
UE_LOG(LogPathView, VeryVerbose, TEXT("[%s] Moved item %s:%s->%s"), *WriteToString<256>(OwningContentBrowserName),
*WriteToString<256>(ItemData.GetOwnerDataSource()->GetFName()),
*WriteToString<256>(ItemDataUpdate.GetPreviousVirtualPath()),
*WriteToString<256>(ItemData.GetVirtualPath()));
const FContentBrowserMinimalItemData OldItemKey(ItemData.GetItemType(), ItemDataUpdate.GetPreviousVirtualPath(), ItemData.GetOwnerDataSource());
TSharedPtr<FTreeItem> Parent = TryRemoveFolderItemInternal(OldItemKey);
if (DoesItemPassFilter(ItemData))
{
NewItems.Emplace(AddFolderItemInternal(MoveTemp(ItemData), nullptr));
}
else if (Parent.IsValid())
{
ModifiedParents.Emplace(Parent.ToSharedRef());
}
}
break;
case EContentBrowserItemUpdateType::Removed:
UE_LOG(LogPathView, VeryVerbose, TEXT("[%s] Removed item %s:%s"), *WriteToString<256>(OwningContentBrowserName),
*WriteToString<256>(ItemData.GetOwnerDataSource()->GetFName()),
*WriteToString<256>(ItemData.GetVirtualPath()));
TryRemoveFolderItemInternal(ItemData);
break;
default:
checkf(false, TEXT("Unexpected EContentBrowserItemUpdateType!"));
break;
}
}
++Version;
// Determine visibility for new items and their parents
if (!FolderPathTextFilter.GetRawFilterText().IsEmpty())
{
// Clear visible descendents flag on modified parents because we will reset it
for (const TSharedRef<FTreeItem>& Parent : ModifiedParents)
{
Parent->SetHasVisibleDescendants(false);
}
for (const TSharedRef<FTreeItem>& Item : NewItems)
{
bool bVisible = PassesTextFilter(Item);
Item->SetVisible(bVisible);
if (bVisible)
{
// Propagate to parents
for (TSharedPtr<FTreeItem> Parent = Item->GetParent(); Parent.IsValid() && !Parent->IsVisible();
Parent = Parent->GetParent())
{
Parent->SetHasVisibleDescendants(true);
}
}
}
// Sort modified parents so if items are related, we visit the items furthest from the root first
Algo::Sort(ModifiedParents,
[](const TSharedRef<FTreeItem>& A, const TSharedRef<FTreeItem>& B) { return A->IsChildOf(*B); });
for (const TSharedRef<FTreeItem>& Parent : ModifiedParents)
{
// May have already figured this out when dealing with directly modified items
if (!Parent->GetHasVisibleDescendants())
{
bool bVisibleChildren = Algo::AnyOf(Parent->GetChildren(),
[](const TSharedPtr<FTreeItem>& Child) { return Child.IsValid() && Child->IsVisible(); });
Parent->SetHasVisibleDescendants(bVisibleChildren);
}
}
}
else
{
// If filtering is not active and we created some new root items, we need them to be visible
VisibleRootItems = RootItems;
}
}
bool FPathViewData::PassesTextFilter(const TSharedPtr<FTreeItem>& InItem)
{
return FolderPathTextFilter.PassesFilter(WriteToString<256>(InItem->GetItem().GetVirtualPath()))
// TODO: this will not match a string like LocName1/LocName2 when both parent and child are localized
|| FolderPathTextFilter.PassesFilter(FStringView(InItem->GetItem().GetDisplayName().ToString()));
}
void FPathViewData::ClearItemFilterState()
{
for (const TPair<FName, TSharedPtr<FTreeItem>>& Pair : VirtualPathToItem)
{
FName VirtualPath = Pair.Key;
Pair.Value->SetVisible(true);
Pair.Value->SetHasVisibleDescendants(true);
}
VisibleRootItems = RootItems;
++Version;
}
void FPathViewData::FilterFullFolderTree()
{
for (const TPair<FName, TSharedPtr<FTreeItem>>& Pair : VirtualPathToItem)
{
FName VirtualPath = Pair.Key;
Pair.Value->SetVisible(PassesTextFilter(Pair.Value));
Pair.Value->SetHasVisibleDescendants(false);
}
// Propagate visibility down to parents
for (const TPair<FName, TSharedPtr<FTreeItem>>& Pair : VirtualPathToItem)
{
if (Pair.Value->IsVisible())
{
for (TSharedPtr<FTreeItem> Parent = Pair.Value->GetParent(); Parent.IsValid() && !Parent->IsVisible();
Parent = Parent->GetParent())
{
Parent->SetHasVisibleDescendants(true);
}
}
}
VisibleRootItems.Reset();
Algo::CopyIf(RootItems, VisibleRootItems, UE_PROJECTION_MEMBER(FTreeItem, IsVisible));
++Version;
}
void FPathViewData::SortRootItems()
{
UE::PathView::DefaultSort(RootItems);
UE::PathView::DefaultSort(VisibleRootItems);
}
TSharedPtr<FTreeItem> FPathViewData::FindTreeItem(FName InVirtualPath, bool bVisibleOnly)
{
if (TSharedPtr<FTreeItem> Found = VirtualPathToItem.FindRef(InVirtualPath))
{
if (bVisibleOnly && !Found->IsVisible())
{
return {};
}
return Found;
}
return {};
}
TSharedPtr<FTreeItem> FPathViewData::FindBestItemForPath(FStringView InVirtualPath)
{
if (bFlat)
{
return FindTreeItem(FName(InVirtualPath), false);
}
TSharedPtr<FTreeItem> Found;
FPathViews::IterateAncestors(InVirtualPath, [this, &Found](FStringView Ancestor) {
FName ItemName{ Ancestor };
if (TSharedPtr<FTreeItem>* Item = VirtualPathToItem.Find(ItemName))
{
Found = *Item;
return false; // Found the leafmost item matching this path
}
return true; // continue
});
return Found;
}
TSharedRef<FTreeItem> FPathViewData::AddFolderItem(FContentBrowserItemData&& InItemData)
{
TSharedRef<FTreeItem> NewOrUpdatedItem = AddFolderItemInternal(MoveTemp(InItemData), nullptr);
++Version;
return NewOrUpdatedItem;
}
TSharedRef<FTreeItem> FPathViewData::AddFolderItemInternal(FContentBrowserItemData&& InItemData,
TMap<FName, TSharedPtr<FTreeItem>>* OldItemsByInvariantPath)
{
UContentBrowserDataSubsystem* ContentBrowserData = IContentBrowserDataModule::Get().GetSubsystem();
UContentBrowserDataSource* OriginalDataSource = InItemData.GetOwnerDataSource();
FName ItemVirtualPath = InItemData.GetVirtualPath();
TSharedPtr<FTreeItem> LeafItem = VirtualPathToItem.FindRef(ItemVirtualPath);
if (LeafItem.IsValid())
{
UE_LOG(LogPathView, VeryVerbose, TEXT("[%s] Appending data to existing item %s:%s"),
*WriteToString<256>(OwningContentBrowserName),
*WriteToString<256>(OriginalDataSource->GetFName()),
*WriteToString<256>(ItemVirtualPath));
// Item already existed - duplicate item returned by multiple data sources, merge data and move on.
// We will have already created all the parent items.
LeafItem->AppendItemData(InItemData);
return LeafItem.ToSharedRef();
}
UE_LOG(LogPathView, VeryVerbose, TEXT("[%s] Creating new tree item for %s:%s"),
*WriteToString<256>(OwningContentBrowserName),
*WriteToString<256>(OriginalDataSource->GetFName()),
*WriteToString<256>(ItemVirtualPath));
FName ItemInvariantPath = InItemData.GetInvariantPath();
TStringBuilder<FName::StringBufferSize> PathBuffer(InPlace, ItemVirtualPath);
LeafItem = UE::PathView::CreateOrReuseNode(MoveTemp(InItemData), OldItemsByInvariantPath);
// InItemData is now no longer valid!!
VirtualPathToItem.Add(ItemVirtualPath, LeafItem);
InvariantPathToItem.Add(ItemInvariantPath, LeafItem);
if (bFlat)
{
RootItems.Add(LeafItem);
return LeafItem.ToSharedRef();
}
TSharedRef<FTreeItem> PreviousItem = LeafItem.ToSharedRef();
// Work backwards from the leaf path of the requested item until we encounter an item that already existed
FPathViews::IterateAncestors(PathBuffer.ToView(),
[this, &PathBuffer, &PreviousItem, OriginalDataSource, OldItemsByInvariantPath, &ContentBrowserData](FStringView PathView) {
if (PathView.Len() == PathBuffer.Len())
{
// This is the item returned by the data source, we already added it
return true;
}
if (PathView == TEXTVIEW("/"))
{
UE_LOG(LogPathView, VeryVerbose, TEXT("[%s] Adding root item %s:%.*s"),
*WriteToString<256>(OwningContentBrowserName),
*WriteToString<256>(OriginalDataSource->GetFName()),
PathView.Len(), PathView.GetData());
// PreviousItem must have been new, add it to the set of root items
RootItems.Add(PreviousItem);
return false;
}
FName ParentVirtualPath{ PathView };
TSharedPtr<FTreeItem> ParentItem = VirtualPathToItem.FindRef(ParentVirtualPath);
bool bContinue = false;
if (!ParentItem.IsValid())
{
UE_LOG(LogPathView, VeryVerbose, TEXT("[%s] Creating placeholder or virtual parent %s:%.*s"),
*WriteToString<256>(OwningContentBrowserName),
*WriteToString<256>(OriginalDataSource->GetFName()),
PathView.Len(), PathView.GetData());
// TODO: If another data source provides this path in future, can that data source become the 'primary'?
FName ItemName(FPathViews::GetPathLeaf(PathView));
FName InternalPath;
if (ContentBrowserData->TryConvertVirtualPath(ParentVirtualPath, InternalPath) != EContentBrowserPathType::Internal)
{
InternalPath = FName(); // Assuming this is a virtual path with no internal path
}
ParentItem = UE::PathView::CreateOrReuseNode(FContentBrowserItemData(OriginalDataSource,
EContentBrowserItemFlags::Type_Folder,
ParentVirtualPath,
ItemName,
FText(),
nullptr,
InternalPath
),
OldItemsByInvariantPath);
VirtualPathToItem.Add(ParentVirtualPath, ParentItem);
// TODO: Do fully virtual paths have an invariant path?
InvariantPathToItem.Add(ParentItem->GetItem().GetInvariantPath());
bContinue = true;
}
else
{
UE_LOG(LogPathView, VeryVerbose, TEXT("[%s] Found existing parent %.*s"),
*WriteToString<256>(OwningContentBrowserName),
PathView.Len(), PathView.GetData());
}
ParentItem->AddChild(PreviousItem);
PreviousItem = ParentItem.ToSharedRef();
return bContinue; // If we made a node here, keep checking if we need to make more parent nodes
});
return LeafItem.ToSharedRef();
}
TSharedPtr<FTreeItem> FPathViewData::TryRemoveFolderItemInternal(const FContentBrowserItemData& InItemData)
{
return TryRemoveFolderItemInternal(FContentBrowserMinimalItemData(InItemData));
}
TSharedPtr<FTreeItem> FPathViewData::TryRemoveFolderItemInternal(const FContentBrowserMinimalItemData& InItemKey)
{
// Find the folder in the tree
if (TSharedPtr<FTreeItem> ItemToRemove = VirtualPathToItem.FindRef(InItemKey.GetVirtualPath()))
{
// Only fully remove this item if every sub-item is removed (items become invalid when empty)
FContentBrowserItemData OldItemData = ItemToRemove->RemoveItemData(InItemKey);
if (ItemToRemove->GetItem().IsValid())
{
return {};
}
// Found the folder to remove. Remove it.
TSharedPtr<FTreeItem> ItemParent = ItemToRemove->GetParent();
if (ItemParent.IsValid())
{
// Remove the folder from its parent's list
ItemParent->RemoveChild(ItemToRemove.ToSharedRef());
}
else
{
// This is a root item. Remove the folder from the root items list.
RootItems.Remove(ItemToRemove);
VisibleRootItems.Remove(ItemToRemove);
}
VirtualPathToItem.Remove(InItemKey.GetVirtualPath());
InvariantPathToItem.Remove(OldItemData.GetInvariantPath());
return ItemParent;
}
// Did not find the folder to remove
return {};
}
void FPathViewData::RemoveFolderItem(const TSharedRef<FTreeItem>& TreeItem)
{
if (TSharedPtr<FTreeItem> Parent = TreeItem->GetParent())
{
// Remove this item from it's parent's list
Parent->RemoveChild(TreeItem);
}
else
{
// This was a root node, remove from the root list
RootItems.Remove(TreeItem);
VisibleRootItems.Remove(TreeItem);
}
VirtualPathToItem.Remove(TreeItem->GetItem().GetVirtualPath());
InvariantPathToItem.Remove(TreeItem->GetItem().GetInvariantPath());
Version++;
}
SPathView::FScopedSelectionChangedEvent::FScopedSelectionChangedEvent(const TSharedRef<SPathView>& InPathView, const bool InShouldEmitEvent)
: PathView(InPathView)
, bShouldEmitEvent(InShouldEmitEvent)
{
PathView->PreventTreeItemChangedDelegateCount++;
InitialSelectionSet = GetSelectionSet();
}
SPathView::FScopedSelectionChangedEvent::~FScopedSelectionChangedEvent()
{
check(PathView->PreventTreeItemChangedDelegateCount > 0);
PathView->PreventTreeItemChangedDelegateCount--;
if (bShouldEmitEvent)
{
const TSet<FName> FinalSelectionSet = GetSelectionSet();
const bool bHasSelectionChanges = InitialSelectionSet.Num() != FinalSelectionSet.Num() || InitialSelectionSet.Difference(FinalSelectionSet).Num() > 0;
if (bHasSelectionChanges)
{
const TArray<TSharedPtr<FTreeItem>> NewSelectedItems = PathView->TreeViewPtr->GetSelectedItems();
PathView->TreeSelectionChanged(NewSelectedItems.Num() > 0 ? NewSelectedItems[0] : nullptr,
ESelectInfo::Direct);
}
}
}
TSet<FName> SPathView::FScopedSelectionChangedEvent::GetSelectionSet() const
{
TSet<FName> SelectionSet;
Algo::Transform(PathView->TreeViewPtr->GetSelectedItems(), SelectionSet, [](const TSharedPtr<FTreeItem>& Item) {
return Item->GetItem().GetVirtualPath();
});
return SelectionSet;
}
SPathView::~SPathView()
{
UE::PathView::AllPathViews.RemoveAllSwap([this](const TWeakPtr<SPathView> Weak) { return Weak.Pin().Get() == this; });
if (IContentBrowserDataModule* ContentBrowserDataModule = IContentBrowserDataModule::GetPtr())
{
if (UContentBrowserDataSubsystem* ContentBrowserData = ContentBrowserDataModule->GetSubsystem())
{
ContentBrowserData->OnItemDataUpdated().RemoveAll(this);
ContentBrowserData->OnItemDataRefreshed().RemoveAll(this);
ContentBrowserData->OnItemDataDiscoveryComplete().RemoveAll(this);
}
}
TreeData->GetFolderPathTextFilter().OnChanged().RemoveAll(this);
}
void SPathView::Construct( const FArguments& InArgs )
{
UE::PathView::AllPathViews.Add(SharedThis(this));
OwningContentBrowserName = InArgs._OwningContentBrowserName;
OnItemSelectionChanged = InArgs._OnItemSelectionChanged;
bAllowContextMenu = InArgs._AllowContextMenu;
OnGetItemContextMenu = InArgs._OnGetItemContextMenu;
InitialCategoryFilter = InArgs._InitialCategoryFilter;
bAllowClassesFolder = InArgs._AllowClassesFolder;
bAllowReadOnlyFolders = InArgs._AllowReadOnlyFolders;
bShowRedirectors = InArgs._ShowRedirectors;
bCanShowDevelopersFolder = InArgs._CanShowDevelopersFolder;
bForceShowEngineContent = InArgs._ForceShowEngineContent;
bForceShowPluginContent = InArgs._ForceShowPluginContent;
bLastShowRedirectors = bShowRedirectors.Get(false);
PreventTreeItemChangedDelegateCount = 0;
TreeTitle = LOCTEXT("AssetTreeTitle", "Asset Tree");
if ( InArgs._FocusSearchBoxWhenOpened )
{
RegisterActiveTimer( 0.f, FWidgetActiveTimerDelegate::CreateSP( this, &SPathView::SetFocusPostConstruct ) );
}
TreeData = MakeShared<FPathViewData>(OwningContentBrowserName, bFlat);
TreeData->GetFolderPathTextFilter().OnChanged().AddSP(this, &SPathView::FilterUpdated);
UContentBrowserDataSubsystem* ContentBrowserData = IContentBrowserDataModule::Get().GetSubsystem();
ContentBrowserData->OnItemDataUpdated().AddSP(this, &SPathView::HandleItemDataUpdated);
ContentBrowserData->OnItemDataRefreshed().AddSP(this, &SPathView::HandleItemDataRefreshed);
ContentBrowserData->OnItemDataDiscoveryComplete().AddSP(this, &SPathView::HandleItemDataDiscoveryComplete);
FAssetToolsModule& AssetToolsModule = FModuleManager::LoadModuleChecked<FAssetToolsModule>("AssetTools");
FolderPermissionList = AssetToolsModule.Get().GetFolderPermissionList();
WritableFolderPermissionList = AssetToolsModule.Get().GetWritableFolderPermissionList();
// Listen for when view settings are changed
FContentBrowserModule& ContentBrowserModule = FModuleManager::GetModuleChecked<FContentBrowserModule>(TEXT("ContentBrowser"));
ContentBrowserModule.GetOnContentBrowserSettingChanged().AddSP(this, &SPathView::HandleSettingChanged);
// Binds the commands for the PathView
BindCommands();
// Setup plugin filters
PluginPathFilters = InArgs._PluginPathFilters;
if (PluginPathFilters.IsValid())
{
// Add all built-in filters here
AllPluginPathFilters.Add( MakeShareable(new FContentBrowserPluginFilter_ContentOnlyPlugins()) );
// Add external filters
for (const FContentBrowserModule::FAddPathViewPluginFilters& Delegate : ContentBrowserModule.GetAddPathViewPluginFilters())
{
if (Delegate.IsBound())
{
Delegate.Execute(AllPluginPathFilters);
}
}
}
STreeView<TSharedPtr<FTreeItem>>::FArguments TreeViewArgs;
ConfigureTreeView(TreeViewArgs);
TreeViewPtr = SArgumentNew(TreeViewArgs, STreeView<TSharedPtr<FTreeItem>>)
.TreeItemsSource(TreeData->GetVisibleRootItems())
.OnGetChildren(this, &SPathView::GetChildrenForTree)
.OnGenerateRow(this, &SPathView::GenerateTreeRow)
.OnItemScrolledIntoView(this, &SPathView::TreeItemScrolledIntoView)
.SelectionMode(InArgs._SelectionMode)
.AllowInvisibleItemSelection(true)
.OnSelectionChanged(this, &SPathView::TreeSelectionChanged)
.OnContextMenuOpening(this, &SPathView::MakePathViewContextMenu)
.ClearSelectionOnClick(false);
SearchPtr = InArgs._ExternalSearch;
if (!SearchPtr)
{
SearchPtr = MakeShared<FSourcesSearch>();
SearchPtr->Initialize();
SearchPtr->SetHintText(LOCTEXT("AssetTreeSearchBoxHint", "Search Folders"));
}
SearchPtr->OnSearchChanged().AddSP(this, &SPathView::SetSearchFilterText);
TSharedRef<SBox> SearchBox = SNew(SBox);
if (!InArgs._ExternalSearch)
{
SearchBox->SetContent(
SNew(SHorizontalBox)
+SHorizontalBox::Slot()
.AutoWidth()
[
InArgs._SearchContent.Widget
]
+SHorizontalBox::Slot()
.FillWidth(1.0f)
[
SNew(SBox)
.Visibility(InArgs._SearchBarVisibility)
[
SearchPtr->GetWidget()
]
]
+SHorizontalBox::Slot()
.Padding(4.f, 0.f, 0.f, 0.f)
.AutoWidth()
[
SNew(SComboButton)
.Visibility(InArgs._ShowViewOptions ? EVisibility::Visible : EVisibility::Collapsed)
.ComboButtonStyle(&FAppStyle::Get().GetWidgetStyle<FComboButtonStyle>("SimpleComboButton"))
.OnGetMenuContent(this, &SPathView::GetViewButtonContent)
.HasDownArrow(false)
.ButtonContent()
[
SNew(SImage)
.ColorAndOpacity(FSlateColor::UseForeground())
.Image(FAppStyle::Get().GetBrush("Icons.Settings"))
]
]
);
}
TSharedRef<SVerticalBox> ContentBox = SNew(SVerticalBox);
if (!InArgs._ExternalSearch || InArgs._ShowTreeTitle)
{
ContentBox->AddSlot()
.AutoHeight()
[
SNew(SBorder)
.BorderImage(FAppStyle::Get().GetBrush("Brushes.Panel"))
.Padding(8.f)
[
SNew(SVerticalBox)
// Search
+ SVerticalBox::Slot()
.AutoHeight()
[
SearchBox
]
// Tree title
+SVerticalBox::Slot()
.AutoHeight()
[
SNew(STextBlock)
.Font(UE::ContentBrowser::Private::FContentBrowserStyle::Get().GetFontStyle("ContentBrowser.SourceTitleFont") )
.Text(this, &SPathView::GetTreeTitle)
.Visibility(InArgs._ShowTreeTitle ? EVisibility::Visible : EVisibility::Collapsed)
]
]
];
}
// Separator
if (InArgs._ShowSeparator)
{
ContentBox->AddSlot()
.AutoHeight()
.Padding(0, 0, 0, 1)
[
SNew(SSeparator)
];
}
if (InArgs._ShowFavorites)
{
ContentBox->AddSlot()
.FillHeight(1.f)
[
SNew(SSplitter)
.Orientation(Orient_Vertical)
+ SSplitter::Slot()
.SizeRule_Lambda([this]()
{
return (FavoritesArea.IsValid() && FavoritesArea->IsExpanded()) ? SSplitter::ESizeRule::FractionOfParent : SSplitter::ESizeRule::SizeToContent;
})
.MinSize(24)
.Value(0.25f)
[
CreateFavoritesView()
]
+ SSplitter::Slot()
.Value(0.75f)
[
TreeViewPtr.ToSharedRef()
]
];
}
else
{
// Tree
ContentBox->AddSlot()
.FillHeight(1.f)
[
TreeViewPtr.ToSharedRef()
];
}
ChildSlot
[
ContentBox
];
CustomFolderPermissionList = InArgs._CustomFolderPermissionList;
// Add all paths currently gathered from the asset registry
Populate();
for (const FName PathToExpand : GetDefaultPathsToExpand())
{
if (TSharedPtr<FTreeItem> FoundItem = TreeData->FindTreeItem(PathToExpand))
{
RecursiveExpandParents(FoundItem);
TreeViewPtr->SetItemExpansion(FoundItem, true);
}
}
if (!InArgs._DefaultPath.IsEmpty() && InternalPathPassesBlockLists(InArgs._DefaultPath))
{
const FName VirtualPath = ContentBrowserData->ConvertInternalPathToVirtual(*InArgs._DefaultPath);
FName InternalPath;
if (ContentBrowserData->TryConvertVirtualPath(VirtualPath, InternalPath) != EContentBrowserPathType::Internal)
{
InternalPath = FName();
}
if (InArgs._CreateDefaultPath && !TreeData->FindTreeItem(VirtualPath))
{
const FString DefaultPathLeafName = FPaths::GetPathLeaf(VirtualPath.ToString());
TreeData->AddFolderItem(FContentBrowserItemData(nullptr,
EContentBrowserItemFlags::Type_Folder,
VirtualPath,
*DefaultPathLeafName,
FText(),
nullptr,
InternalPath));
}
SetSelectedPaths({ VirtualPath.ToString() });
}
}
void SPathView::ConfigureTreeView(STreeView<TSharedPtr<FTreeItem>>::FArguments& InArgs)
{
InArgs.OnExpansionChanged(this, &SPathView::TreeExpansionChanged)
.OnSetExpansionRecursive(this, &SPathView::SetTreeItemExpansionRecursive)
.HighlightParentNodesForSelection(true);
}
void SPathView::Tick(const FGeometry& AllottedGeometry, const double InCurrentTime, const float InDeltaTime)
{
Super::Tick(AllottedGeometry, InCurrentTime, InDeltaTime);
if (LastTreeDataVersion != TreeData->GetVersion())
{
LastTreeDataVersion = TreeData->GetVersion();
TreeViewPtr->RequestTreeRefresh();
}
const bool bNewShowRedirectors = bShowRedirectors.Get(false);
if (bNewShowRedirectors != bLastShowRedirectors)
{
UE_LOG(LogPathView, Verbose, TEXT("PathView bShowRedirectors changed to %d"), bNewShowRedirectors);
bLastShowRedirectors = bNewShowRedirectors;
HandleSettingChanged("ShowRedirectors");
}
if (bLastExpandedPathsDirty)
{
UpdateLastExpandedPathsIfDirty();
}
}
FReply SPathView::OnKeyDown(const FGeometry& MyGeometry, const FKeyEvent& InKeyEvent)
{
if (Commands->ProcessCommandBindings(InKeyEvent))
{
return FReply::Handled();
}
return FReply::Unhandled();
}
bool SPathView::IsEmpty() const
{
return TreeViewPtr->GetRootItems().IsEmpty();
}
void SPathView::PopulatePathViewFiltersMenu(UToolMenu* Menu)
{
{
FToolMenuSection& Section = Menu->AddSection("Reset");
Section.AddMenuEntry(
"ResetPluginPathFilters",
LOCTEXT("ResetPluginPathFilters_Label", "Reset Path View Filters"),
LOCTEXT("ResetPluginPathFilters_Tooltip", "Reset current path view filters state"),
FSlateIcon(),
FUIAction(FExecuteAction::CreateSP(this, &SPathView::ResetPluginPathFilters))
);
}
{
FToolMenuSection& Section = Menu->AddSection("Filters", LOCTEXT("PathViewFilters_Label", "Filters"));
for (const TSharedRef<FContentBrowserPluginFilter>& Filter : AllPluginPathFilters)
{
Section.AddMenuEntry(
NAME_None,
Filter->GetDisplayName(),
Filter->GetToolTipText(),
FSlateIcon(FAppStyle::GetAppStyleSetName(), Filter->GetIconName()),
FUIAction(
FExecuteAction::CreateSP(this, &SPathView::PluginPathFilterClicked, Filter),
FCanExecuteAction(),
FIsActionChecked::CreateSP(this, &SPathView::IsPluginPathFilterChecked, Filter)
),
EUserInterfaceActionType::ToggleButton
);
}
}
}
void SPathView::PluginPathFilterClicked(TSharedRef<FContentBrowserPluginFilter> Filter)
{
SetPluginPathFilterActive(Filter, !IsPluginPathFilterInUse(Filter));
Populate();
}
bool SPathView::IsPluginPathFilterChecked(TSharedRef<FContentBrowserPluginFilter> Filter) const
{
if (IsPluginPathFilterInUse(Filter))
{
return !Filter->IsInverseFilter();
}
return Filter->IsInverseFilter();
}
bool SPathView::IsPluginPathFilterInUse(TSharedRef<FContentBrowserPluginFilter> Filter) const
{
if (PluginPathFilters.IsValid())
{
for (int32 i=0; i < PluginPathFilters->Num(); ++i)
{
if (PluginPathFilters->GetFilterAtIndex(i) == Filter)
{
return true;
}
}
}
return false;
}
void SPathView::ResetPluginPathFilters()
{
for (const TSharedRef<FContentBrowserPluginFilter>& Filter : AllPluginPathFilters)
{
SetPluginPathFilterActive(Filter, false);
}
Populate();
}
bool SPathView::DisablePluginPathFiltersThatHideItems(TConstArrayView<FContentBrowserItem> Items)
{
if (!PluginPathFilters.IsValid())
{
return false;
}
TSet<TSharedRef<IPlugin>> RelevantPlugins;
for (const FContentBrowserItem& Item : Items)
{
FName InternalPath = Item.GetInternalPath();
if (InternalPath.IsNone())
{
continue;
}
TStringBuilder<256> PathBuffer(InPlace, InternalPath);
const FStringView MountPoint = FPathViews::GetMountPointNameFromPath(PathBuffer);
if (TSharedPtr<IPlugin> Plugin = IPluginManager::Get().FindPlugin(MountPoint))
{
RelevantPlugins.Add(Plugin.ToSharedRef());
}
}
bool bAnyChanges = false;
for (const TSharedRef<FContentBrowserPluginFilter>& Filter : AllPluginPathFilters)
{
if (Algo::AnyOf(RelevantPlugins, [&Filter](const TSharedRef<IPlugin>& Plugin) { return !Filter->PassesFilter(Plugin); }))
{
// Whether the filter is inverse or not, we don't want it in the list
if (IsPluginPathFilterInUse(Filter))
{
SetPluginPathFilterActive(Filter, Filter->IsInverseFilter());
bAnyChanges = true;
}
}
}
return bAnyChanges;
}
void SPathView::SetPluginPathFilterActive(const TSharedRef<FContentBrowserPluginFilter>& Filter, bool bActive)
{
if (Filter->IsInverseFilter())
{
//Inverse filters are active when they are "disabled"
bActive = !bActive;
}
UE_LOG(LogPathView, Verbose, TEXT("[%s] Setting%s plugin filter %s to %s"),
*WriteToString<64>(OwningContentBrowserName),
Filter->IsInverseFilter() ? TEXT(" inverse") : TEXT(""),
*Filter->GetName(), bActive ? TEXT("Active") : TEXT("Inactive"));
Filter->ActiveStateChanged(bActive);
if (bActive)
{
PluginPathFilters->Add(Filter);
}
else
{
PluginPathFilters->Remove(Filter);
}
if (FPathViewConfig* PathViewConfig = GetPathViewConfig())
{
if (bActive)
{
PathViewConfig->PluginFilters.Add(Filter->GetName());
}
else
{
PathViewConfig->PluginFilters.Remove(Filter->GetName());
}
UContentBrowserConfig::Get()->SaveEditorConfig();
}
}
FPathViewConfig* SPathView::GetPathViewConfig() const
{
return ContentBrowserUtils::GetPathViewConfig(OwningContentBrowserName);
}
FContentBrowserInstanceConfig* SPathView::GetContentBrowserConfig() const
{
return ContentBrowserUtils::GetContentBrowserConfig(OwningContentBrowserName);
}
void SPathView::SetSelectedPaths(const TArray<FName>& Paths)
{
TArray<FString> PathStrings;
Algo::Transform(Paths, PathStrings, [](const FName& Name) { return Name.ToString(); });
SetSelectedPaths(PathStrings);
}
void SPathView::SetSelectedPaths(const TArray<FString>& Paths)
{
if (!ensure(TreeViewPtr.IsValid()))
{
return;
}
// Prevent the selection changed delegate since the invoking code requested it
FScopedPreventTreeItemChangedDelegate DelegatePrevention( SharedThis(this) );
// If the selection was changed before all pending initial paths were found, stop attempting to select them
PendingInitialPaths.Empty();
// Clear the selection to start, then add the selected paths as they are found
LastSelectedPaths.Empty();
TreeViewPtr->ClearSelection();
for (const FString& Path : Paths)
{
TSharedPtr<FTreeItem> BestItem = TreeData->FindBestItemForPath(Path);
if (BestItem.IsValid())
{
if (!BestItem->IsVisible())
{
// Clear the search box if it potentially hides a path we want to select
SearchPtr->ClearSearch();
}
for (TSharedPtr<FTreeItem> Parent = BestItem->GetParent(); Parent.IsValid(); Parent = Parent->GetParent())
{
TreeViewPtr->SetItemExpansion(Parent, true);
}
// Set the selection to the closest found folder and scroll it into view
LastSelectedPaths.Add(BestItem->GetItem().GetInvariantPath());
TreeViewPtr->SetItemSelection(BestItem, true);
TreeViewPtr->RequestScrollIntoView(BestItem);
}
}
}
void SPathView::ClearSelection()
{
// Prevent the selection changed delegate since the invoking code requested it
FScopedPreventTreeItemChangedDelegate DelegatePrevention( SharedThis(this) );
// If the selection was changed before all pending initial paths were found, stop attempting to select them
PendingInitialPaths.Empty();
// Clear the selection to start, then add the selected paths as they are found
TreeViewPtr->ClearSelection();
}
FString SPathView::GetSelectedPath() const
{
// TODO: Abstract away?
TArray<TSharedPtr<FTreeItem>> Items = TreeViewPtr->GetSelectedItems();
if ( Items.Num() > 0 )
{
return Items[0]->GetItem().GetVirtualPath().ToString();
}
return FString();
}
TArray<FString> SPathView::GetSelectedPaths() const
{
TArray<FString> RetArray;
// TODO: Abstract away?
TArray<TSharedPtr<FTreeItem>> Items = TreeViewPtr->GetSelectedItems();
for ( int32 ItemIdx = 0; ItemIdx < Items.Num(); ++ItemIdx )
{
RetArray.Add(Items[ItemIdx]->GetItem().GetVirtualPath().ToString());
}
return RetArray;
}
TArray<FContentBrowserItem> SPathView::GetSelectedFolderItems() const
{
TArray<TSharedPtr<FTreeItem>> SelectedViewItems = TreeViewPtr->GetSelectedItems();
TArray<FContentBrowserItem> SelectedFolders;
for (const TSharedPtr<FTreeItem>& SelectedViewItem : SelectedViewItems)
{
if (!SelectedViewItem->GetItem().IsTemporary())
{
SelectedFolders.Emplace(SelectedViewItem->GetItem());
}
}
return SelectedFolders;
}
void SPathView::RenameFolderItem(const FContentBrowserItem& InItem)
{
if (!ensure(TreeViewPtr.IsValid()))
{
// No tree view for some reason
return;
}
if (!InItem.IsFolder())
{
// Not a folder
return;
}
// Find the folder in the tree
if (TSharedPtr<FTreeItem> ItemToRename = TreeData->FindTreeItem(InItem.GetVirtualPath()))
{
if (!ItemToRename->IsVisible())
{
SearchPtr->ClearSearch();
}
ItemToRename->SetNamingFolder(true);
TreeViewPtr->SetSelection(ItemToRename);
TreeViewPtr->RequestScrollIntoView(ItemToRename);
}
}
FContentBrowserDataCompiledFilter SPathView::CreateCompiledFolderFilter() const
{
UE_LOG(LogPathView, VeryVerbose, TEXT("[%s] Creating folder filter"), *WriteToString<256>(OwningContentBrowserName));
const UContentBrowserSettings* ContentBrowserSettings = GetDefault<UContentBrowserSettings>();
bool bDisplayPluginFolders = ContentBrowserSettings->GetDisplayPluginFolders();
// check to see if we have an instance config that overrides the default in UContentBrowserSettings
if (FContentBrowserInstanceConfig* EditorConfig = GetContentBrowserConfig())
{
bDisplayPluginFolders = EditorConfig->bShowPluginContent;
}
FContentBrowserDataFilter DataFilter;
DataFilter.bRecursivePaths = true;
DataFilter.ItemTypeFilter = EContentBrowserItemTypeFilter::IncludeFolders;
DataFilter.ItemCategoryFilter = GetContentBrowserItemCategoryFilter();
DataFilter.ItemAttributeFilter = GetContentBrowserItemAttributeFilter();
UE_LOG(LogPathView, VeryVerbose, TEXT("[%s] bDisplayPluginFolders:%d ItemCategoryFilter:%d ItemAttributeFilter:%d"),
*WriteToString<256>(OwningContentBrowserName), bDisplayPluginFolders, DataFilter.ItemCategoryFilter, DataFilter.ItemAttributeFilter);
TSharedPtr<FPathPermissionList> CombinedFolderPermissionList = ContentBrowserUtils::GetCombinedFolderPermissionList(FolderPermissionList, bAllowReadOnlyFolders ? nullptr : WritableFolderPermissionList);
if (CustomFolderPermissionList.IsValid())
{
if (!CombinedFolderPermissionList.IsValid())
{
CombinedFolderPermissionList = MakeShared<FPathPermissionList>();
}
CombinedFolderPermissionList->Append(*CustomFolderPermissionList);
}
if (PluginPathFilters.IsValid() && PluginPathFilters->Num() > 0 && bDisplayPluginFolders)
{
UE_SUPPRESS(LogPathView, VeryVerbose, {
FString PluginFiltersString;
for (int32 i=0; i < PluginPathFilters->Num(); ++i)
{
if (i != 0)
{
PluginFiltersString += TEXT(", ");
}
PluginFiltersString += PluginPathFilters->GetFilterAtIndex(i)->GetName();
}
UE_LOG(LogPathView, VeryVerbose, TEXT("[%s] Active plugin filters: %s"),
*WriteToString<256>(OwningContentBrowserName), *PluginFiltersString);
});
TArray<TSharedRef<IPlugin>> Plugins = IPluginManager::Get().GetEnabledPluginsWithContent();
for (const TSharedRef<IPlugin>& Plugin : Plugins)
{
if (!PluginPathFilters->PassesAllFilters(Plugin))
{
FString MountedAssetPath = Plugin->GetMountedAssetPath();
MountedAssetPath.RemoveFromEnd(TEXT("/"), ESearchCase::CaseSensitive);
if (!CombinedFolderPermissionList.IsValid())
{
CombinedFolderPermissionList = MakeShared<FPathPermissionList>();
}
CombinedFolderPermissionList->AddDenyListItem("PluginPathFilters", MountedAssetPath);
}
}
}
UE_LOG(LogPathView, VeryVerbose, TEXT("Compiled folder permission list: %s"), CombinedFolderPermissionList.IsValid() ? *CombinedFolderPermissionList->ToString() : TEXT("null"));
ContentBrowserUtils::AppendAssetFilterToContentBrowserFilter(FARFilter(), nullptr, CombinedFolderPermissionList, DataFilter);
FContentBrowserDataCompiledFilter CompiledDataFilter;
{
static const FName RootPath = "/";
UContentBrowserDataSubsystem* ContentBrowserData = IContentBrowserDataModule::Get().GetSubsystem();
ContentBrowserData->CompileFilter(RootPath, DataFilter, CompiledDataFilter);
}
return CompiledDataFilter;
}
EContentBrowserItemCategoryFilter SPathView::GetContentBrowserItemCategoryFilter() const
{
const UContentBrowserSettings* ContentBrowserSettings = GetDefault<UContentBrowserSettings>();
bool bDisplayCppFolders = ContentBrowserSettings->GetDisplayCppFolders();
// check to see if we have an instance config that overrides the default in UContentBrowserSettings
if (FContentBrowserInstanceConfig* EditorConfig = GetContentBrowserConfig())
{
bDisplayCppFolders = EditorConfig->bShowCppFolders;
}
EContentBrowserItemCategoryFilter ItemCategoryFilter = InitialCategoryFilter;
if (bAllowClassesFolder && bDisplayCppFolders)
{
ItemCategoryFilter |= EContentBrowserItemCategoryFilter::IncludeClasses;
}
else
{
ItemCategoryFilter &= ~EContentBrowserItemCategoryFilter::IncludeClasses;
}
ItemCategoryFilter &= ~EContentBrowserItemCategoryFilter::IncludeCollections;
if (bShowRedirectors.Get(false))
{
ItemCategoryFilter |= EContentBrowserItemCategoryFilter::IncludeRedirectors;
}
else
{
ItemCategoryFilter &= ~EContentBrowserItemCategoryFilter::IncludeRedirectors;
}
return ItemCategoryFilter;
}
EContentBrowserItemAttributeFilter SPathView::GetContentBrowserItemAttributeFilter() const
{
const UContentBrowserSettings* ContentBrowserSettings = GetDefault<UContentBrowserSettings>();
bool bDisplayEngineContent = ContentBrowserSettings->GetDisplayEngineFolder();
bool bDisplayPluginContent = ContentBrowserSettings->GetDisplayPluginFolders();
bool bDisplayDevelopersContent = ContentBrowserSettings->GetDisplayDevelopersFolder();
bool bDisplayL10NContent = ContentBrowserSettings->GetDisplayL10NFolder();
// check to see if we have an instance config that overrides the defaults in UContentBrowserSettings
if (FContentBrowserInstanceConfig* EditorConfig = GetContentBrowserConfig())
{
bDisplayEngineContent = EditorConfig->bShowEngineContent;
bDisplayPluginContent = EditorConfig->bShowPluginContent;
bDisplayDevelopersContent = EditorConfig->bShowDeveloperContent;
bDisplayL10NContent = EditorConfig->bShowLocalizedContent;
}
return EContentBrowserItemAttributeFilter::IncludeProject
| (bDisplayEngineContent || bForceShowEngineContent ? EContentBrowserItemAttributeFilter::IncludeEngine : EContentBrowserItemAttributeFilter::IncludeNone)
| (bDisplayPluginContent || bForceShowPluginContent ? EContentBrowserItemAttributeFilter::IncludePlugins : EContentBrowserItemAttributeFilter::IncludeNone)
| (bDisplayDevelopersContent && bCanShowDevelopersFolder ? EContentBrowserItemAttributeFilter::IncludeDeveloper : EContentBrowserItemAttributeFilter::IncludeNone)
| (bDisplayL10NContent ? EContentBrowserItemAttributeFilter::IncludeLocalized : EContentBrowserItemAttributeFilter::IncludeNone);
}
FVector2D SPathView::GetScrollDistance()
{
if (!TreeViewPtr.IsValid())
{
return FVector2D::ZeroVector;
}
return TreeViewPtr->GetScrollDistance();
}
FVector2D SPathView::GetScrollDistanceRemaining()
{
if (!TreeViewPtr.IsValid())
{
return FVector2D::ZeroVector;
}
return TreeViewPtr->GetScrollDistanceRemaining();
}
TSharedRef<SWidget> SPathView::GetScrollWidget()
{
return SharedThis(this);
}
bool SPathView::InternalPathPassesBlockLists(const FStringView InInternalPath, const int32 InAlreadyCheckedDepth) const
{
TArray<const FPathPermissionList*, TInlineAllocator<2>> BlockLists;
if (FolderPermissionList.IsValid() && FolderPermissionList->HasFiltering())
{
BlockLists.Add(FolderPermissionList.Get());
}
if (!bAllowReadOnlyFolders && WritableFolderPermissionList.IsValid() && WritableFolderPermissionList->HasFiltering())
{
BlockLists.Add(WritableFolderPermissionList.Get());
}
for (const FPathPermissionList* Filter : BlockLists)
{
if (!Filter->PassesStartsWithFilter(InInternalPath))
{
return false;
}
}
if (InAlreadyCheckedDepth < 1 && PluginPathFilters.IsValid() && PluginPathFilters->Num() > 0)
{
const UContentBrowserSettings* ContentBrowserSettings = GetDefault<UContentBrowserSettings>();
bool bDisplayPluginFolders = ContentBrowserSettings->GetDisplayPluginFolders();
// check to see if we have an instance config that overrides the default in UContentBrowserSettings
if (FContentBrowserInstanceConfig* EditorConfig = GetContentBrowserConfig())
{
bDisplayPluginFolders = EditorConfig->bShowPluginContent;
}
if (bDisplayPluginFolders)
{
const FStringView FirstFolderName = FPathViews::GetMountPointNameFromPath(InInternalPath);
if (TSharedPtr<IPlugin> Plugin = IPluginManager::Get().FindPlugin(FirstFolderName))
{
if (!PluginPathFilters->PassesAllFilters(Plugin.ToSharedRef()))
{
return false;
}
}
}
}
return true;
}
void SPathView::SyncToItems(TArrayView<const FContentBrowserItem> ItemsToSync, const bool bAllowImplicitSync)
{
TArray<FName> VirtualPathsToSync;
for (const FContentBrowserItem& Item : ItemsToSync)
{
if (Item.IsFile())
{
// Files need to sync their parent folder in the tree, so chop off the end of their path
VirtualPathsToSync.Add(*FPaths::GetPath(Item.GetVirtualPath().ToString()));
}
else
{
VirtualPathsToSync.Add(Item.GetVirtualPath());
}
}
SyncToVirtualPaths(VirtualPathsToSync, bAllowImplicitSync);
}
void SPathView::SyncToVirtualPaths(TArrayView<const FName> VirtualPathsToSync, const bool bAllowImplicitSync)
{
TSet<TSharedRef<FTreeItem>> SyncTreeItems;
for (const FName& VirtualPathToSync : VirtualPathsToSync)
{
TSharedPtr<FTreeItem> Item = TreeData->FindTreeItem(VirtualPathToSync);
if (Item.IsValid())
{
SyncTreeItems.Add(Item.ToSharedRef());
}
}
if (Algo::AnyOf(SyncTreeItems, [](const TSharedRef<FTreeItem>& Item) { return !Item->IsVisible(); }))
{
// Clear the search box if it potentially hides a path we want to select
SearchPtr->ClearSearch();
}
if (SyncTreeItems.Num() > 0)
{
// Batch the selection changed event
FScopedSelectionChangedEvent ScopedSelectionChangedEvent(SharedThis(this));
if (bAllowImplicitSync)
{
// Prune the current selection so that we don't unnecessarily change the path which might disorientate the user.
// If a parent tree item is currently selected we don't need to clear it and select the child
TSet<TSharedPtr<FTreeItem>> SelectedTreeItems{ TreeViewPtr->GetSelectedItems() };
TSet<TSharedRef<FTreeItem>> FinalItems;
for (const TSharedRef<FTreeItem>& ItemToSelect : SyncTreeItems)
{
// If the target item or any of its parents are already selected, maintain that object in the final
// selection
TSharedPtr<FTreeItem> It = ItemToSelect;
while (It.IsValid() && !SelectedTreeItems.Contains(It))
{
It = It->GetParent();
}
if (It.IsValid())
{
FinalItems.Add(It.ToSharedRef());
}
else
{
// Otherwise select the specific folder we were asked for
FinalItems.Add(ItemToSelect);
}
}
SyncTreeItems = FinalItems;
}
// SyncTreeItems now shows exactly what we want to be selected and no more
TreeViewPtr->ClearSelection();
// SyncTreeItems should now only contain items which aren't already shown explicitly or implicitly (as a child)
for (const TSharedRef<FTreeItem>& Item : SyncTreeItems)
{
RecursiveExpandParents(Item);
TreeViewPtr->SetItemSelection(Item, true);
}
}
// > 0 as some may have been removed in the code above
if (SyncTreeItems.Num() > 0)
{
// Scroll the first item into view if applicable
TreeViewPtr->RequestScrollIntoView(*SyncTreeItems.CreateConstIterator());
}
}
void SPathView::SyncToLegacy(TArrayView<const FAssetData> AssetDataList, TArrayView<const FString> FolderList, const bool bAllowImplicitSync)
{
TArray<FName> VirtualPathsToSync;
ContentBrowserUtils::ConvertLegacySelectionToVirtualPaths(AssetDataList, FolderList, /*UseFolderPaths*/true, VirtualPathsToSync);
SyncToVirtualPaths(VirtualPathsToSync, bAllowImplicitSync);
}
bool SPathView::DoesItemExist(FName InVirtualPath) const
{
return TreeData->FindTreeItem(InVirtualPath).IsValid();
}
void SPathView::ApplyHistoryData( const FHistoryData& History )
{
// Prevent the selection changed delegate because it would add more history when we are just setting a state
FScopedPreventTreeItemChangedDelegate DelegatePrevention( SharedThis(this) );
// Update paths
TArray<FString> SelectedPaths;
for (const FName& HistoryPath : History.ContentSources.GetVirtualPaths())
{
SelectedPaths.Add(HistoryPath.ToString());
}
SetSelectedPaths(SelectedPaths);
}
void SPathView::SaveSettings(const FString& IniFilename, const FString& IniSection, const FString& InstanceName) const
{
FString SelectedPathsString;
TArray< TSharedPtr<FTreeItem> > PathItems = TreeViewPtr->GetSelectedItems();
for (const TSharedPtr<FTreeItem>& Item : PathItems)
{
if (SelectedPathsString.Len() > 0)
{
SelectedPathsString += TEXT(",");
}
FName InvariantPath;
IContentBrowserDataModule::Get().GetSubsystem()->TryConvertVirtualPath(Item->GetItem().GetVirtualPath(), InvariantPath);
InvariantPath.AppendString(SelectedPathsString);
}
GConfig->SetString(*IniSection, *(InstanceName + TEXT(".SelectedPaths")), *SelectedPathsString, IniFilename);
FString PluginFiltersString;
if (PluginPathFilters.IsValid())
{
for (int32 FilterIdx = 0; FilterIdx < PluginPathFilters->Num(); ++FilterIdx)
{
if (PluginFiltersString.Len() > 0)
{
PluginFiltersString += TEXT(",");
}
TSharedPtr<FContentBrowserPluginFilter> Filter = StaticCastSharedPtr<FContentBrowserPluginFilter>(PluginPathFilters->GetFilterAtIndex(FilterIdx));
PluginFiltersString += Filter->GetName();
}
GConfig->SetString(*IniSection, *(InstanceName + TEXT(".PluginFilters")), *PluginFiltersString, IniFilename);
}
}
void SPathView::LoadSettings(const FString& IniFilename, const FString& IniSection, const FString& SettingsString)
{
// Selected Paths
TArray<FName> NewSelectedPaths;
{
FString SelectedPathsString;
if (GConfig->GetString(*IniSection, *(SettingsString + TEXT(".SelectedPaths")), SelectedPathsString, IniFilename))
{
TArray<FString> ParsedPaths;
SelectedPathsString.ParseIntoArray(ParsedPaths, TEXT(","), /*bCullEmpty*/true);
Algo::Transform(ParsedPaths, NewSelectedPaths, [](const FString& Str) { return *Str; });
}
}
// Replace each path in NewSelectedPaths with virtual version of that path
for (FName& Path : NewSelectedPaths)
{
IContentBrowserDataModule::Get().GetSubsystem()->ConvertInternalPathToVirtual(Path, Path);
}
UE_LOG(LogPathView, Verbose, TEXT("[%s] LoadSettings: SelectedPaths: %s"),
*WriteToString<256>(OwningContentBrowserName), *FString::JoinBy(NewSelectedPaths, TEXT(", "), UE_PROJECTION_MEMBER(FName, ToString)));
{
// Batch the selection changed event
FScopedSelectionChangedEvent ScopedSelectionChangedEvent(SharedThis(this));
UContentBrowserDataSubsystem* ContentBrowserData = IContentBrowserDataModule::Get().GetSubsystem();
if (ContentBrowserData->IsDiscoveringItems())
{
PendingInitialPaths = NewSelectedPaths;
// If any of the pending paths are available, select only them
// otherwise, leave the selection unchanged until we discover some
if (Algo::AnyOf(NewSelectedPaths, [this](FName VirtualPath) {
return TreeData->FindTreeItem(VirtualPath, /* bVisibleOnly */ true).IsValid();
}))
{
// Clear any previously selected paths
LastSelectedPaths.Empty();
TreeViewPtr->ClearSelection();
}
// If the selected paths is empty, the path was "All assets"
// This should handle that case properly
for (const FName& Path : NewSelectedPaths)
{
ExplicitlyAddPathToSelection(Path);
}
// Keep entire list of pending paths around until discovery is complete or all of them are selected
PendingInitialPaths = NewSelectedPaths;
}
else
{
PendingInitialPaths.Reset();
// If all assets are already discovered, just select paths the best we can
SetSelectedPaths(NewSelectedPaths);
}
}
// Plugin Filters
if (PluginPathFilters.IsValid())
{
TArray<FString> NewSelectedFilters;
if (FPathViewConfig* PathViewConfig = GetPathViewConfig())
{
UE_LOG(LogPathView, Verbose, TEXT("[%s] LoadSettings: Loading plugin filters from editor config: %s"),
*WriteToString<256>(OwningContentBrowserName), *FString::Join(NewSelectedFilters, TEXT(", ")));
NewSelectedFilters = PathViewConfig->PluginFilters;
}
else
{
FString PluginFiltersString;
if (GConfig->GetString(*IniSection, *(SettingsString + TEXT(".PluginFilters")), PluginFiltersString, IniFilename))
{
UE_LOG(LogPathView, Verbose, TEXT("[%s] LoadSettings: Loading plugin filters from ini: %s"),
*WriteToString<256>(OwningContentBrowserName), *PluginFiltersString);
PluginFiltersString.ParseIntoArray(NewSelectedFilters, TEXT(","), /*bCullEmpty*/ true);
}
}
for (const TSharedRef<FContentBrowserPluginFilter>& Filter : AllPluginPathFilters)
{
bool bFilterActive = NewSelectedFilters.Contains(Filter->GetName());
SetPluginPathFilterActive(Filter, bFilterActive);
}
}
}
EActiveTimerReturnType SPathView::SetFocusPostConstruct( double InCurrentTime, float InDeltaTime )
{
FWidgetPath WidgetToFocusPath;
FSlateApplication::Get().GeneratePathToWidgetUnchecked( SearchPtr->GetWidget(), WidgetToFocusPath );
FSlateApplication::Get().SetKeyboardFocus( WidgetToFocusPath, EFocusCause::SetDirectly );
return EActiveTimerReturnType::Stop;
}
EActiveTimerReturnType SPathView::TriggerRepopulate(double InCurrentTime, float InDeltaTime)
{
Populate();
return EActiveTimerReturnType::Stop;
}
TSharedPtr<SWidget> SPathView::MakePathViewContextMenu()
{
if (!bAllowContextMenu || !OnGetItemContextMenu.IsBound())
{
return nullptr;
}
const TArray<FContentBrowserItem> CurrentSelectedItems = GetSelectedFolderItems();
if (CurrentSelectedItems.Num() == 0)
{
return nullptr;
}
return OnGetItemContextMenu.Execute(CurrentSelectedItems);
}
void SPathView::NewFolderItemRequested(const FContentBrowserItemTemporaryContext& NewItemContext)
{
bool bAddedTemporaryFolder = false;
TSharedPtr<FTreeItem> NewItem;
// TODO: Consider having FTreeItem explicitly store FContentBrowserItemTemporaryContext
for (const FContentBrowserItemData& NewItemData : NewItemContext.GetItem().GetInternalItems())
{
NewItem = TreeData->AddFolderItem(CopyTemp(NewItemData));
}
if (NewItem.IsValid())
{
PendingNewFolderContext = NewItemContext;
PendingInitialPaths.Reset();
RecursiveExpandParents(NewItem);
TreeViewPtr->SetSelection(NewItem);
NewItem->SetNamingFolder(true);
TreeViewPtr->RequestScrollIntoView(NewItem);
}
}
bool SPathView::ExplicitlyAddPathToSelection(const FName Path)
{
if ( !ensure(TreeViewPtr.IsValid()) )
{
return false;
}
if (TSharedPtr<FTreeItem> FoundItem = TreeData->FindTreeItem(Path))
{
if (TreeViewPtr->IsItemSelected(FoundItem))
{
return true;
}
if (!FoundItem->IsVisible())
{
SearchPtr->ClearSearch();
}
// Set the selection to the closest found folder and scroll it into view
RecursiveExpandParents(FoundItem);
LastSelectedPaths.Add(FoundItem->GetItem().GetInvariantPath());
TreeViewPtr->SetItemSelection(FoundItem, true);
TreeViewPtr->RequestScrollIntoView(FoundItem);
return true;
}
return false;
}
bool SPathView::ShouldAllowTreeItemChangedDelegate() const
{
return PreventTreeItemChangedDelegateCount == 0;
}
void SPathView::RecursiveExpandParents(const TSharedPtr<FTreeItem>& Item)
{
if (TSharedPtr<FTreeItem> Parent = Item->GetParent())
{
RecursiveExpandParents(Parent);
TreeViewPtr->SetItemExpansion(Parent, true);
}
}
TSharedRef<ITableRow> SPathView::GenerateTreeRow( TSharedPtr<FTreeItem> TreeItem, const TSharedRef<STableViewBase>& OwnerTable )
{
check(TreeItem.IsValid());
return
SNew( STableRow< TSharedPtr<FTreeItem> >, OwnerTable )
.OnDragDetected( this, &SPathView::OnFolderDragDetected )
[
SNew(SAssetTreeItem)
.TreeItem(TreeItem)
.OnNameChanged(this, &SPathView::FolderNameChanged)
.OnVerifyNameChanged(this, &SPathView::VerifyFolderNameChanged)
.IsItemExpanded(this, &SPathView::IsTreeItemExpanded, TreeItem)
.HighlightText(this, &SPathView::GetHighlightText)
.IsSelected(this, &SPathView::IsTreeItemSelected, TreeItem)
];
}
void SPathView::TreeItemScrolledIntoView( TSharedPtr<FTreeItem> TreeItem, const TSharedPtr<ITableRow>& Widget )
{
if ( TreeItem->IsNamingFolder() && Widget.IsValid() && Widget->GetContent().IsValid() )
{
TreeItem->OnRenameRequested().Broadcast();
}
}
void SPathView::GetChildrenForTree( TSharedPtr< FTreeItem > TreeItem, TArray< TSharedPtr<FTreeItem> >& OutChildren )
{
TreeItem->GetSortedVisibleChildren(OutChildren);
}
void SPathView::SetTreeItemExpansionRecursive( TSharedPtr< FTreeItem > TreeItem, bool bInExpansionState )
{
TreeViewPtr->SetItemExpansion(TreeItem, bInExpansionState);
TreeItem->ForAllChildrenRecursive([this, bInExpansionState](const TSharedRef<FTreeItem>& Child) {
TreeViewPtr->SetItemExpansion(Child, bInExpansionState);
});
}
void SPathView::TreeSelectionChanged( TSharedPtr< FTreeItem > TreeItem, ESelectInfo::Type SelectInfo )
{
if (SelectInfo != ESelectInfo::Direct)
{
PendingInitialPaths.Reset();
}
if ( ShouldAllowTreeItemChangedDelegate() )
{
const TArray<TSharedPtr<FTreeItem>> NewSelectedItems = TreeViewPtr->GetSelectedItems();
LastSelectedPaths.Empty();
for (int32 ItemIdx = 0; ItemIdx < NewSelectedItems.Num(); ++ItemIdx)
{
const TSharedPtr<FTreeItem> Item = NewSelectedItems[ItemIdx];
if ( !ensure(Item.IsValid()) )
{
// All items must exist
continue;
}
// Keep track of the last paths that we broadcasted for selection reasons when filtering
LastSelectedPaths.Add(Item->GetItem().GetInvariantPath());
}
if ( OnItemSelectionChanged.IsBound() )
{
if ( TreeItem.IsValid() )
{
OnItemSelectionChanged.Execute(TreeItem->GetItem(), SelectInfo);
}
else
{
OnItemSelectionChanged.Execute(FContentBrowserItem(), SelectInfo);
}
}
}
if (TreeItem.IsValid())
{
// Prioritize the content scan for the selected path
UContentBrowserDataSubsystem* ContentBrowserData = IContentBrowserDataModule::Get().GetSubsystem();
ContentBrowserData->PrioritizeSearchPath(TreeItem->GetItem().GetVirtualPath());
}
}
void SPathView::TreeExpansionChanged( TSharedPtr< FTreeItem > TreeItem, bool bIsExpanded )
{
if ( ShouldAllowTreeItemChangedDelegate() )
{
DirtyLastExpandedPaths();
if (!bIsExpanded)
{
const TArray<TSharedPtr<FTreeItem>> CurrentSelectedItems = TreeViewPtr->GetSelectedItems();
bool bSelectTreeItem = false;
// If any selected item was a child of the collapsed node, then add the collapsed node to the current selection
// This avoids the selection ever becoming empty, as this causes the Content Browser to show everything
for (const TSharedPtr<FTreeItem>& SelectedItem : CurrentSelectedItems)
{
if (SelectedItem->IsChildOf(*TreeItem.Get()))
{
bSelectTreeItem = true;
break;
}
}
if (bSelectTreeItem)
{
TreeViewPtr->SetItemSelection(TreeItem, true);
}
}
}
}
void SPathView::FilterUpdated()
{
TRACE_CPUPROFILER_EVENT_SCOPE(SPathView::FilterUpdated);
// Batch the selection changed event
// Only emit events when the user isn't filtering, as the selection may be artificially limited by the filter
FScopedSelectionChangedEvent ScopedSelectionChangedEvent(SharedThis(this), false);
if (TreeData->GetFolderPathTextFilter().GetRawFilterText().IsEmpty())
{
TreeData->ClearItemFilterState();
TreeViewPtr->ClearExpandedItems();
// First expand the default expanded paths
for (const FName PathToExpand : GetDefaultPathsToExpand())
{
if (TSharedPtr<FTreeItem> FoundItem = TreeData->FindTreeItem(PathToExpand))
{
RecursiveExpandParents(FoundItem);
TreeViewPtr->SetItemExpansion(FoundItem, true);
}
}
TArray<TSharedPtr<FTreeItem>> SelectedItems = TreeViewPtr->GetSelectedItems();
if (!SelectedItems.IsEmpty())
{
for (const TSharedPtr<FTreeItem>& SelectedItem : SelectedItems)
{
for (TSharedPtr<FTreeItem> Parent = SelectedItem->GetParent(); Parent.IsValid();
Parent = Parent->GetParent())
{
TreeViewPtr->SetItemExpansion(Parent, true);
}
}
TreeViewPtr->RequestScrollIntoView(SelectedItems[0]);
}
}
else
{
TreeData->FilterFullFolderTree();
TreeViewPtr->ClearExpandedItems();
for (const TSharedPtr<FTreeItem>& Root : *TreeData->GetVisibleRootItems())
{
TreeViewPtr->SetItemExpansion(Root, true);
Root->ForAllChildrenRecursive([this](const TSharedPtr<FTreeItem> Descendant) {
if (Descendant->GetHasVisibleDescendants())
{
TreeViewPtr->SetItemExpansion(Descendant, true);
}
});
}
}
}
void SPathView::SetSearchFilterText(const FText& InSearchText, TArray<FText>& OutErrors)
{
TreeData->GetFolderPathTextFilter().SetRawFilterText(InSearchText);
const FText ErrorText = TreeData->GetFolderPathTextFilter().GetFilterErrorText();
if (!ErrorText.IsEmpty())
{
OutErrors.Add(ErrorText);
}
}
FText SPathView::GetHighlightText() const
{
return TreeData->GetFolderPathTextFilter().GetRawFilterText();
}
void SPathView::Populate(const bool bIsRefreshingFilter)
{
TRACE_CPUPROFILER_EVENT_SCOPE(SPathView::Populate);
UE_LOG(LogPathView, Verbose, TEXT("Repopulating path view"));
const bool bFilteringByText = !TreeData->GetFolderPathTextFilter().GetRawFilterText().IsEmpty();
// Batch the selection changed event
// Only emit events when the user isn't filtering, as the selection may be artificially limited by the filter
FScopedSelectionChangedEvent ScopedSelectionChangedEvent(SharedThis(this),
!bFilteringByText && !bIsRefreshingFilter);
TreeData->PopulateFullFolderTree(CreateCompiledFolderFilter());
TreeData->FilterFullFolderTree();
TreeData->SortRootItems();
// Select any of our initial paths which aren't currently selected
if (Algo::AllOf(PendingInitialPaths, [this](FName VirtualPath) {
return ExplicitlyAddPathToSelection(VirtualPath);
}))
{
UE_LOG(LogPathView, VeryVerbose, TEXT("[%s] Resetting pending initial paths as all are selected"), *WriteToString<256>(OwningContentBrowserName));
PendingInitialPaths.Reset();
}
}
FReply SPathView::OnFolderDragDetected(const FGeometry& Geometry, const FPointerEvent& MouseEvent)
{
if ( MouseEvent.IsMouseButtonDown( EKeys::LeftMouseButton ) )
{
if (TSharedPtr<FDragDropOperation> DragDropOp = DragDropHandler::CreateDragOperation(GetSelectedFolderItems()))
{
return FReply::Handled().BeginDragDrop(DragDropOp.ToSharedRef());
}
}
return FReply::Unhandled();
}
bool SPathView::VerifyFolderNameChanged(const TSharedPtr< FTreeItem >& TreeItem, const FString& ProposedName, FText& OutErrorMessage) const
{
if (PendingNewFolderContext.IsValid())
{
checkf(FContentBrowserItemKey(TreeItem->GetItem()) == FContentBrowserItemKey(PendingNewFolderContext.GetItem()), TEXT("PendingNewFolderContext was still set when attempting to rename a different item!"));
return PendingNewFolderContext.ValidateItem(ProposedName, &OutErrorMessage);
}
else if (!TreeItem->GetItem().GetItemName().ToString().Equals(ProposedName))
{
UContentBrowserDataSubsystem* ContentBrowserData = IContentBrowserDataModule::Get().GetSubsystem();
return TreeItem->GetItem().CanRename(&ProposedName, ContentBrowserData->CreateHideFolderIfEmptyFilter().Get(), &OutErrorMessage);
}
return true;
}
void SPathView::FolderNameChanged(const TSharedPtr<FTreeItem>& TreeItem,
const FString& ProposedName,
const UE::Slate::FDeprecateVector2DParameter& MessageLocation,
const ETextCommit::Type CommitType)
{
if (!TreeItem.IsValid())
{
return;
}
bool bSuccess = false;
FText ErrorMessage;
// Group the deselect and reselect into a single operation
FScopedSelectionChangedEvent ScopedSelectionChangedEvent(SharedThis(this));
FContentBrowserItem NewItem;
if (PendingNewFolderContext.IsValid())
{
checkf(FContentBrowserItemKey(TreeItem->GetItem()) == FContentBrowserItemKey(PendingNewFolderContext.GetItem()), TEXT("PendingNewFolderContext was still set when attempting to rename a different item!"));
// Remove the temporary item before we do any work to ensure the new item creation is not prevented
TreeData->RemoveFolderItem(TreeItem.ToSharedRef());
TreeViewPtr->SetItemSelection(TreeItem.ToSharedRef(), false);
// Clearing the rename box on a newly created item cancels the entire creation process
if (CommitType == ETextCommit::OnCleared)
{
// We need to select the parent item of this folder, as the folder would have become selected while it was being named
if (TSharedPtr<FTreeItem> ParentTreeItem = TreeItem->GetParent())
{
TreeViewPtr->SetItemSelection(ParentTreeItem, true);
}
else
{
TreeViewPtr->ClearSelection();
}
}
else
{
UContentBrowserDataSubsystem* ContentBrowserData = IContentBrowserDataModule::Get().GetSubsystem();
FScopedSuppressContentBrowserDataTick TickSuppression(ContentBrowserData);
if (PendingNewFolderContext.ValidateItem(ProposedName, &ErrorMessage))
{
NewItem = PendingNewFolderContext.FinalizeItem(ProposedName, &ErrorMessage);
if (NewItem.IsValid())
{
bSuccess = true;
}
}
}
PendingNewFolderContext = FContentBrowserItemTemporaryContext();
}
else if (CommitType != ETextCommit::OnCleared && !TreeItem->GetItem().GetItemName().ToString().Equals(ProposedName))
{
UContentBrowserDataSubsystem* ContentBrowserData = IContentBrowserDataModule::Get().GetSubsystem();
FScopedSuppressContentBrowserDataTick TickSuppression(ContentBrowserData);
if (TreeItem->GetItem().CanRename(&ProposedName, ContentBrowserData->CreateHideFolderIfEmptyFilter().Get(), &ErrorMessage) && TreeItem->GetItem().Rename(ProposedName, &NewItem))
{
bSuccess = true;
}
}
if (bSuccess && NewItem.IsValid())
{
// Add result to view
TSharedPtr<FTreeItem> NewTreeItem;
for (const FContentBrowserItemData& NewItemData : NewItem.GetInternalItems())
{
NewTreeItem = TreeData->AddFolderItem(CopyTemp(NewItemData));
}
// Select the new item
if (NewTreeItem)
{
TreeViewPtr->SetItemSelection(NewTreeItem, true);
TreeViewPtr->RequestScrollIntoView(NewTreeItem);
}
}
if (!bSuccess && !ErrorMessage.IsEmpty())
{
// Display the reason why the folder was invalid
FSlateRect MessageAnchor(MessageLocation.X, MessageLocation.Y, MessageLocation.X, MessageLocation.Y);
ContentBrowserUtils::DisplayMessage(ErrorMessage, MessageAnchor, SharedThis(this), ContentBrowserUtils::EDisplayMessageType::Error);
}
}
bool SPathView::IsTreeItemExpanded(TSharedPtr<FTreeItem> TreeItem) const
{
return TreeViewPtr->IsItemExpanded(TreeItem);
}
bool SPathView::IsTreeItemSelected(TSharedPtr<FTreeItem> TreeItem) const
{
return TreeViewPtr->IsItemSelected(TreeItem);
}
void SPathView::HandleItemDataUpdated(TArrayView<const FContentBrowserItemDataUpdate> InUpdatedItems)
{
TRACE_CPUPROFILER_EVENT_SCOPE(SPathView::HandleItemDataUpdated);
if (InUpdatedItems.Num() == 0)
{
return;
}
// TODO: Consider batching if sometimes we get very few items and filter construction time dominates
if (!Algo::AnyOf(InUpdatedItems,
[](const FContentBrowserItemDataUpdate& Update) { return Update.GetItemData().IsFolder(); }))
{
UE_LOG(LogPathView, VeryVerbose, TEXT("[%s] Skipping item data update because there were no folders present"), *WriteToString<256>(OwningContentBrowserName));
return;
}
const bool bFilteringByText = !TreeData->GetFolderPathTextFilter().GetRawFilterText().IsEmpty();
// Batch the selection changed event
// Only emit events when the user isn't filtering, as the selection may be artificially limited by the filter
FScopedSelectionChangedEvent ScopedSelectionChangedEvent(SharedThis(this), !bFilteringByText);
const double HandleItemDataUpdatedStartTime = FPlatformTime::Seconds();
TreeData->ProcessDataUpdates(InUpdatedItems, CreateCompiledFolderFilter());
UE_LOG(LogPathView, VeryVerbose, TEXT("[%s] PathView - HandleItemDataUpdated completed in %0.4f seconds for %d items"),
*WriteToString<256>(OwningContentBrowserName),
FPlatformTime::Seconds() - HandleItemDataUpdatedStartTime,
InUpdatedItems.Num());
// Select any of our initial paths which aren't currently selected
if (Algo::AllOf(PendingInitialPaths, [this](FName VirtualPath) {
return ExplicitlyAddPathToSelection(VirtualPath);
}))
{
UE_LOG(LogPathView, VeryVerbose, TEXT("[%s] Resetting pending initial paths as all are selected"), *WriteToString<256>(OwningContentBrowserName));
PendingInitialPaths.Reset();
}
}
void SPathView::HandleItemDataRefreshed()
{
// Populate immediately, as the path view must be up to date for Content Browser selection to work correctly
// and since it defaults to being hidden, it potentially won't be ticked to run this update latently
Populate();
/*
// The class hierarchy has changed in some way, so we need to refresh our set of paths
RegisterActiveTimer(0.f, FWidgetActiveTimerDelegate::CreateSP(this, &SPathView::TriggerRepopulate));
*/
}
void SPathView::HandleItemDataDiscoveryComplete()
{
// If there were any more initial paths, they no longer exist so clear them now.
UE_LOG(LogPathView, VeryVerbose, TEXT("[%s] Resetting pending initial paths at end of asset data discovery"), *WriteToString<256>(OwningContentBrowserName));
PendingInitialPaths.Empty();
}
void SPathView::HandleSettingChanged(FName PropertyName)
{
if ((PropertyName == GET_MEMBER_NAME_CHECKED(UContentBrowserSettings, DisplayEmptyFolders))
|| (PropertyName == "ShowRedirectors")
|| (PropertyName == "DisplayDevelopersFolder")
|| (PropertyName == "DisplayEngineFolder")
|| (PropertyName == "DisplayPluginFolders")
|| (PropertyName == "DisplayL10NFolder")
|| (PropertyName == GET_MEMBER_NAME_CHECKED(UContentBrowserSettings, bDisplayContentFolderSuffix))
|| (PropertyName == GET_MEMBER_NAME_CHECKED(UContentBrowserSettings, bDisplayFriendlyNameForPluginFolders))
|| (PropertyName == NAME_None)) // @todo: Needed if PostEditChange was called manually, for now
{
UE_LOG(LogPathView,
Log,
TEXT("[%s][PathView] HandleSettingChanged %s"),
*WriteToString<256>(OwningContentBrowserName),
*WriteToString<256>(PropertyName));
const bool bHadSelectedPath = TreeViewPtr->GetNumItemsSelected() > 0;
// Update our path view so that it can include/exclude the dev folder
Populate();
// If folder is no longer visible but we're inside it...
if (TreeViewPtr->GetNumItemsSelected() == 0 && bHadSelectedPath)
{
for (const FName VirtualPath : GetDefaultPathsToSelect())
{
if (TSharedPtr<FTreeItem> TreeItemToSelect = TreeData->FindTreeItem(VirtualPath))
{
TreeViewPtr->SetSelection(TreeItemToSelect);
break;
}
}
}
// If the dev or engine folder has become visible and we're inside it...
const UContentBrowserSettings* ContentBrowserSettings = GetDefault<UContentBrowserSettings>();
bool bDisplayDev = ContentBrowserSettings->GetDisplayDevelopersFolder();
bool bDisplayEngine = ContentBrowserSettings->GetDisplayEngineFolder();
bool bDisplayPlugins = ContentBrowserSettings->GetDisplayPluginFolders();
bool bDisplayL10N = ContentBrowserSettings->GetDisplayL10NFolder();
// check to see if we have an instance config that overrides the default in UContentBrowserSettings
if (FContentBrowserInstanceConfig* EditorConfig = GetContentBrowserConfig())
{
bDisplayDev = EditorConfig->bShowDeveloperContent;
bDisplayEngine = EditorConfig->bShowEngineContent;
bDisplayPlugins = EditorConfig->bShowPluginContent;
bDisplayL10N = EditorConfig->bShowLocalizedContent;
}
if (bDisplayDev || bDisplayEngine || bDisplayPlugins || bDisplayL10N)
{
const TArray<FContentBrowserItem> NewSelectedItems = GetSelectedFolderItems();
if (NewSelectedItems.Num() > 0)
{
const FContentBrowserItem& NewSelectedItem = NewSelectedItems[0];
if ((bDisplayDev && ContentBrowserUtils::IsItemDeveloperContent(NewSelectedItem)) ||
(bDisplayEngine && ContentBrowserUtils::IsItemEngineContent(NewSelectedItem)) ||
(bDisplayPlugins && ContentBrowserUtils::IsItemPluginContent(NewSelectedItem)) ||
(bDisplayL10N && ContentBrowserUtils::IsItemLocalizedContent(NewSelectedItem))
)
{
// Refresh the contents
OnItemSelectionChanged.ExecuteIfBound(NewSelectedItem, ESelectInfo::Direct);
}
}
}
}
}
TArray<FName> SPathView::GetDefaultPathsToSelect() const
{
TArray<FName> VirtualPaths;
FContentBrowserModule& ContentBrowserModule = FModuleManager::Get().GetModuleChecked<FContentBrowserModule>(TEXT("ContentBrowser"));
if (!ContentBrowserModule.GetDefaultSelectedPathsDelegate().ExecuteIfBound(VirtualPaths))
{
VirtualPaths.Add(IContentBrowserDataModule::Get().GetSubsystem()->ConvertInternalPathToVirtual(TEXT("/Game")));
}
return VirtualPaths;
}
TArray<FName> SPathView::GetRootPathItemNames() const
{
TArray<FName> RootPathItemNames;
RootPathItemNames.Reserve(TreeData->GetVisibleRootItems()->Num());
for (const TSharedPtr<FTreeItem>& RootItem : *TreeData->GetVisibleRootItems())
{
if (RootItem.IsValid())
{
RootPathItemNames.Add(RootItem->GetItem().GetItemName());
}
}
return RootPathItemNames;
}
TArray<FName> SPathView::GetDefaultPathsToExpand() const
{
TArray<FName> VirtualPaths;
FContentBrowserModule& ContentBrowserModule = FModuleManager::Get().GetModuleChecked<FContentBrowserModule>(TEXT("ContentBrowser"));
if (!ContentBrowserModule.GetDefaultPathsToExpandDelegate().ExecuteIfBound(VirtualPaths))
{
VirtualPaths.Add(IContentBrowserDataModule::Get().GetSubsystem()->ConvertInternalPathToVirtual(TEXT("/Game")));
}
return VirtualPaths;
}
void SPathView::DirtyLastExpandedPaths()
{
bLastExpandedPathsDirty = true;
}
void SPathView::UpdateLastExpandedPathsIfDirty()
{
if (bLastExpandedPathsDirty)
{
TSet<TSharedPtr<FTreeItem>> ExpandedItemSet;
TreeViewPtr->GetExpandedItems(ExpandedItemSet);
LastExpandedPaths.Empty(ExpandedItemSet.Num());
for (const TSharedPtr<FTreeItem>& Item : ExpandedItemSet)
{
if (!ensure(Item.IsValid()))
{
// All items must exist
continue;
}
// Keep track of the last paths that we broadcasted for expansion reasons when filtering
LastExpandedPaths.Add(Item->GetItem().GetInvariantPath());
}
bLastExpandedPathsDirty = false;
}
}
TSharedRef<SWidget> SPathView::CreateFavoritesView()
{
return SAssignNew(FavoritesArea, SExpandableArea)
.BorderImage(FAppStyle::Get().GetBrush("Brushes.Header"))
.BodyBorderImage(FAppStyle::Get().GetBrush("Brushes.Recessed"))
.HeaderPadding(FMargin(4.0f, 4.0f))
.Padding(0.f)
.AllowAnimatedTransition(false)
.InitiallyCollapsed(true)
.HeaderContent()
[
SNew(STextBlock)
.Text(LOCTEXT("Favorites", "Favorites"))
.TextStyle(FAppStyle::Get(), "ButtonText")
.Font(FAppStyle::Get().GetFontStyle("NormalFontBold"))
]
.BodyContent()
[
SNew(SFavoritePathView)
.OnItemSelectionChanged(OnItemSelectionChanged)
.OnGetItemContextMenu(OnGetItemContextMenu)
.FocusSearchBoxWhenOpened(false)
.ShowTreeTitle(false)
.ShowSeparator(false)
.AllowClassesFolder(bAllowClassesFolder)
.CanShowDevelopersFolder(bCanShowDevelopersFolder)
.AllowReadOnlyFolders(bAllowReadOnlyFolders)
.AllowContextMenu(bAllowContextMenu)
.AddMetaData<FTagMetaData>(FTagMetaData(TEXT("ContentBrowserFavorites")))
.ExternalSearch(SearchPtr)
];
}
void SPathView::RegisterGetViewButtonMenu()
{
if (!UToolMenus::Get()->IsMenuRegistered("ContentBrowser.PathViewOptions"))
{
UToolMenu* Menu = UToolMenus::Get()->RegisterMenu("ContentBrowser.PathViewOptions");
Menu->bCloseSelfOnly = true;
Menu->AddDynamicSection("DynamicContent", FNewToolMenuDelegate::CreateLambda([](UToolMenu* InMenu)
{
FName ContextOwningContentBrowserName = NAME_None;
FFiltersAdditionalParams Params;
if (UContentBrowserPathViewContextMenuContext* Context = InMenu->FindContext<UContentBrowserPathViewContextMenuContext>())
{
if (Context->PathView.IsValid())
{
TSharedPtr<SPathView> PathView = Context->PathView.Pin();
PathView->PopulateFilterAdditionalParams(Params);
if (!PathView->OwningContentBrowserName.IsNone())
{
ContextOwningContentBrowserName = PathView->OwningContentBrowserName;
}
}
if (ContextOwningContentBrowserName.IsNone() && !Context->OwningContentBrowserName.IsNone())
{
ContextOwningContentBrowserName = Context->OwningContentBrowserName;
}
ContentBrowserMenuUtils::AddFiltersToMenu(InMenu, ContextOwningContentBrowserName, Params);
}
}));
}
}
void SPathView::PopulateFilterAdditionalParams(FFiltersAdditionalParams& OutParams)
{
OutParams.CanShowCPPClasses = FCanExecuteAction::CreateSP(this, &SPathView::IsToggleShowCppContentAllowed);
OutParams.CanShowDevelopersContent = FCanExecuteAction::CreateSP(this, &SPathView::IsToggleShowDevelopersContentAllowed);
OutParams.CanShowEngineFolder = FCanExecuteAction::CreateSP(this, &SPathView::IsToggleShowEngineContentAllowed);
OutParams.CanShowPluginFolder = FCanExecuteAction::CreateSP(this, &SPathView::IsToggleShowPluginContentAllowed);
OutParams.CanShowLocalizedContent = FCanExecuteAction::CreateSP(this, &SPathView::IsToggleShowLocalizedContentAllowed);
}
bool SPathView::IsToggleShowCppContentAllowed() const
{
return bAllowClassesFolder;
}
bool SPathView::IsToggleShowDevelopersContentAllowed() const
{
return bCanShowDevelopersFolder;
}
bool SPathView::IsToggleShowEngineContentAllowed() const
{
return !bForceShowEngineContent;
}
bool SPathView::IsToggleShowPluginContentAllowed() const
{
return !bForceShowPluginContent;
}
bool SPathView::IsToggleShowLocalizedContentAllowed() const
{
return true;
}
TSharedRef<SWidget> SPathView::GetViewButtonContent()
{
SPathView::RegisterGetViewButtonMenu();
UContentBrowserPathViewContextMenuContext* Context = NewObject<UContentBrowserPathViewContextMenuContext>();
Context->PathView = SharedThis(this);
Context->OwningContentBrowserName = OwningContentBrowserName;
const FToolMenuContext MenuContext(Context);
return UToolMenus::Get()->GenerateWidget("ContentBrowser.PathViewOptions", MenuContext);
}
void SPathView::CopySelectedFolder() const
{
ContentBrowserUtils::CopyFolderReferencesToClipboard(GetSelectedFolderItems());
}
void SPathView::BindCommands()
{
Commands = TSharedPtr<FUICommandList>(new FUICommandList);
Commands->MapAction(FGenericCommands::Get().Copy, FUIAction(
FExecuteAction::CreateSP(this, &SPathView::CopySelectedFolder)
));
}
void SFavoritePathView::Construct(const FArguments& InArgs)
{
// Bind the favorites menu to update after folder changes
AssetViewUtils::OnFolderPathChanged().AddSP(this, &SFavoritePathView::FixupFavoritesFromExternalChange);
OnFavoritesChangedHandle = FContentBrowserSingleton::Get().RegisterOnFavoritesChangedHandler(
FOnFavoritesChanged::FDelegate::CreateSP(this, &SFavoritePathView::OnFavoriteAdded));
SPathView::Construct(InArgs);
}
void SFavoritePathView::ConfigureTreeView(STreeView<TSharedPtr<FTreeItem>>::FArguments& InArgs)
{
// Don't bind some stuff that the parent class binds such as item expansion
}
SFavoritePathView::SFavoritePathView()
{
bFlat = true;
}
SFavoritePathView::~SFavoritePathView()
{
FContentBrowserSingleton::Get().UnregisterOnFavoritesChangedDelegate(OnFavoritesChangedHandle);
}
void SFavoritePathView::Populate(const bool bIsRefreshingFilter)
{
TRACE_CPUPROFILER_EVENT_SCOPE(SFavoritePathView::Populate);
// Don't allow the selection changed delegate to be fired here
FScopedPreventTreeItemChangedDelegate DelegatePrevention(SharedThis(this));
TreeData->PopulateWithFavorites(CreateCompiledFolderFilter());
TreeData->SortRootItems();
TreeData->FilterFullFolderTree();
}
void SFavoritePathView::SaveSettings(const FString& IniFilename, const FString& IniSection, const FString& SettingsString) const
{
SPathView::SaveSettings(IniFilename, IniSection, SettingsString);
FString FavoritePathsString;
const TArray<FString>& FavoritePaths = ContentBrowserUtils::GetFavoriteFolders();
for (const FString& PathIt : FavoritePaths)
{
if (FavoritePathsString.Len() > 0)
{
FavoritePathsString += TEXT(",");
}
FavoritePathsString += PathIt;
}
GConfig->SetString(*IniSection, TEXT("FavoritePaths"), *FavoritePathsString, IniFilename);
GConfig->Flush(false, IniFilename);
}
void SFavoritePathView::LoadSettings(const FString& IniFilename, const FString& IniSection, const FString& SettingsString)
{
TGuardValue<bool> Guard(bIsLoadingSettings, true);
SPathView::LoadSettings(IniFilename, IniSection, SettingsString);
// We clear the initial selection for the favorite view, as it conflicts with the main paths view and results in a phantomly selected favorite item
ClearSelection();
// Favorite Paths
FString FavoritePathsString;
TArray<FString> NewFavoritePaths;
if (GConfig->GetString(*IniSection, TEXT("FavoritePaths"), FavoritePathsString, IniFilename))
{
FavoritePathsString.ParseIntoArray(NewFavoritePaths, TEXT(","), /*bCullEmpty*/true);
}
if (NewFavoritePaths.Num() > 0)
{
// Keep track if we changed at least one source so we know to fire the bulk selection changed delegate later
bool bAddedAtLeastOnePath = false;
{
// If the selected paths is empty, the path was "All assets"
// This should handle that case properly
for (const FString& InvariantPath : NewFavoritePaths)
{
FStringView InvariantPathView(InvariantPath);
InvariantPathView.TrimStartAndEndInline();
if (!InvariantPathView.IsEmpty() && InvariantPathView != TEXT("None"))
{
ContentBrowserUtils::AddFavoriteFolder(FContentBrowserItemPath(InvariantPathView, EContentBrowserPathType::Internal));
bAddedAtLeastOnePath = true;
}
}
}
if (bAddedAtLeastOnePath)
{
Populate();
}
}
}
TSharedPtr<FContentBrowserDataDragDropOp> SFavoritePathView::GetContentBrowserDragDropOpFromEvent(const FDragDropEvent& DragDropEvent) const
{
TSharedPtr<FDragDropOperation> Operation = DragDropEvent.GetOperation();
if (Operation.IsValid() && OnFolderFavoriteAdd.IsBound())
{
if (Operation->IsOfType<FContentBrowserDataDragDropOp>())
{
TSharedPtr<FContentBrowserDataDragDropOp> DragDropOp = StaticCastSharedPtr<FContentBrowserDataDragDropOp>(Operation);
// Only agree to the operation if the drag op only contains folders, since favorites cannot contain files.
if (DragDropOp &&
!DragDropOp->GetDraggedFolders().IsEmpty() &&
DragDropOp->GetDraggedFiles().IsEmpty())
{
return DragDropOp;
}
}
}
return {};
}
void SFavoritePathView::OnDragEnter(const FGeometry& MyGeometry, const FDragDropEvent& DragDropEvent)
{
// If we don't have the appropriate drop content, indicate to the user that nothing will happen.
if (!GetContentBrowserDragDropOpFromEvent(DragDropEvent))
{
DragDropEvent.GetOperation()->SetCursorOverride(EMouseCursor::SlashedCircle);
}
}
void SFavoritePathView::OnDragLeave(const FDragDropEvent& DragDropEvent)
{
TSharedPtr<FDragDropOperation> Operation = DragDropEvent.GetOperation();
if (Operation.IsValid())
{
Operation->SetCursorOverride(TOptional<EMouseCursor::Type>());
}
}
FReply SFavoritePathView::OnDrop(const FGeometry& MyGeometry, const FDragDropEvent& DragDropEvent)
{
TSharedPtr<FContentBrowserDataDragDropOp> DragDropOp = GetContentBrowserDragDropOpFromEvent(DragDropEvent);
if (!DragDropOp.IsValid())
{
return FReply::Unhandled();
}
if (OnFolderFavoriteAdd.IsBound())
{
TArray<FString> FolderPaths;
for (const FContentBrowserItem& BrowserItem: DragDropOp->GetDraggedFolders())
{
FolderPaths.Add(BrowserItem.GetVirtualPath().ToString());
}
OnFolderFavoriteAdd.Execute(FolderPaths);
}
return FReply::Handled();
}
void SFavoritePathView::SetOnFolderFavoriteAdd(const FOnFolderFavoriteAdd& InOnFolderFavoriteAdd)
{
OnFolderFavoriteAdd = InOnFolderFavoriteAdd;
}
TSharedRef<ITableRow> SFavoritePathView::GenerateTreeRow(TSharedPtr<FTreeItem> TreeItem, const TSharedRef<STableViewBase>& OwnerTable)
{
check(TreeItem.IsValid());
return
SNew( STableRow< TSharedPtr<FTreeItem> >, OwnerTable )
.OnDragDetected( this, &SFavoritePathView::OnFolderDragDetected )
[
SNew(SAssetTreeItem)
.TreeItem(TreeItem)
.OnNameChanged(this, &SFavoritePathView::FolderNameChanged)
.OnVerifyNameChanged(this, &SFavoritePathView::VerifyFolderNameChanged)
.IsItemExpanded(false)
.HighlightText(this, &SFavoritePathView::GetHighlightText)
.IsSelected(this, &SFavoritePathView::IsTreeItemSelected, TreeItem)
.FontOverride(UE::ContentBrowser::Private::FContentBrowserStyle::Get().GetFontStyle("ContentBrowser.SourceTreeItemFont"))
];
}
void SFavoritePathView::OnFavoriteAdded(const FContentBrowserItemPath&, bool)
{
if (!bIsLoadingSettings)
{
Populate();
}
}
void SFavoritePathView::HandleItemDataUpdated(TArrayView<const FContentBrowserItemDataUpdate> InUpdatedItems)
{
if (InUpdatedItems.Num() == 0)
{
return;
}
if (!Algo::AnyOf(InUpdatedItems,
[](const FContentBrowserItemDataUpdate& Update) { return Update.GetItemData().IsFolder(); }))
{
return;
}
TSet<FName> FavoritePaths;
{
const TArray<FString>& FavoritePathStrs = ContentBrowserUtils::GetFavoriteFolders();
for (const FString& InvariantPath : FavoritePathStrs)
{
FName VirtualPath;
IContentBrowserDataModule::Get().GetSubsystem()->ConvertInternalPathToVirtual(InvariantPath, VirtualPath);
FavoritePaths.Add(VirtualPath);
}
}
if (FavoritePaths.Num() == 0)
{
UE_LOG(LogPathView, VeryVerbose, TEXT("[%s] Skipping item data update because there were no favorites present"), *WriteToString<256>(OwningContentBrowserName));
return;
}
// Don't allow the selection changed delegate to be fired here
FScopedPreventTreeItemChangedDelegate DelegatePrevention(SharedThis(this));
const double HandleItemDataUpdatedStartTime = FPlatformTime::Seconds();
// Limit the updates to only folders which are favorites
TArray<FContentBrowserItemDataUpdate> FilteredUpdates;
Algo::CopyIf(InUpdatedItems, FilteredUpdates, [FavoritePaths](const FContentBrowserItemDataUpdate& Update) {
return FavoritePaths.Contains(Update.GetItemData().GetVirtualPath());
});
if (FilteredUpdates.Num())
{
TreeData->ProcessDataUpdates(MakeArrayView(FilteredUpdates), CreateCompiledFolderFilter());
}
// Update saved favorites
for (const FContentBrowserItemDataUpdate& ItemDataUpdate : InUpdatedItems)
{
const FContentBrowserItemData& ItemData = ItemDataUpdate.GetItemData();
if (!ItemData.IsFolder())
{
continue;
}
switch (ItemDataUpdate.GetUpdateType())
{
case EContentBrowserItemUpdateType::Added:
break;
case EContentBrowserItemUpdateType::Modified:
break;
case EContentBrowserItemUpdateType::Moved:
ContentBrowserUtils::RemoveFavoriteFolder(
FContentBrowserItemPath(ItemDataUpdate.GetPreviousVirtualPath(), EContentBrowserPathType::Virtual));
break;
case EContentBrowserItemUpdateType::Removed:
ContentBrowserUtils::RemoveFavoriteFolder(
FContentBrowserItemPath(ItemData.GetVirtualPath(), EContentBrowserPathType::Virtual));
break;
default:
checkf(false, TEXT("Unexpected EContentBrowserItemUpdateType!"));
break;
}
}
UE_LOG(LogPathView, VeryVerbose, TEXT("FavoritePathView - HandleItemDataUpdated completed in %0.4f seconds for %d items"), FPlatformTime::Seconds() - HandleItemDataUpdatedStartTime, InUpdatedItems.Num());
}
void SFavoritePathView::FixupFavoritesFromExternalChange(TArrayView<const AssetViewUtils::FMovedContentFolder> MovedFolders)
{
for (const AssetViewUtils::FMovedContentFolder& MovedFolder : MovedFolders)
{
FContentBrowserItemPath ItemPath(MovedFolder.Key, EContentBrowserPathType::Virtual);
const bool bWasFavorite = ContentBrowserUtils::IsFavoriteFolder(ItemPath);
if (bWasFavorite)
{
// Remove the original path
ContentBrowserUtils::RemoveFavoriteFolder(ItemPath);
// Add the new path to favorites instead
const FString& NewPath = MovedFolder.Value;
ContentBrowserUtils::AddFavoriteFolder(FContentBrowserItemPath(NewPath, EContentBrowserPathType::Virtual));
TSharedPtr<FTreeItem> Item = TreeData->FindTreeItem(*NewPath);
if (Item.IsValid())
{
TreeViewPtr->SetItemSelection(Item, true);
TreeViewPtr->RequestScrollIntoView(Item);
}
}
}
Populate();
}
#undef LOCTEXT_NAMESPACE
Reference in New Issue View Git Blame Copy Permalink