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

1735 lines
63 KiB
C++
Raw Blame History

// Copyright Epic Games, Inc. All Rights Reserved.
#include "SCollectionView.h"
#include "Algo/AllOf.h"
#include "Algo/Transform.h"
#include "AssetRegistry/AssetData.h"
#include "CollectionAssetManagement.h"
#include "CollectionContextMenu.h"
#include "CollectionViewTypes.h"
#include "CollectionViewUtils.h"
#include "ContentBrowserConfig.h"
#include "ContentBrowserDelegates.h"
#include "ContentBrowserModule.h"
#include "ContentBrowserPluginFilters.h"
#include "ContentBrowserStyle.h"
#include "ContentBrowserUtils.h"
#include "CoreGlobals.h"
#include "DragAndDrop/AssetDragDropOp.h"
#include "DragAndDrop/CollectionDragDropOp.h"
#include "Framework/Application/MenuStack.h"
#include "Framework/Application/SlateApplication.h"
#include "Framework/Commands/UIAction.h"
#include "Framework/Commands/UICommandList.h"
#include "Framework/MultiBox/MultiBoxBuilder.h"
#include "Framework/MultiBox/MultiBoxExtender.h"
#include "Framework/SlateDelegates.h"
#include "Framework/Views/ITypedTableView.h"
#include "GenericPlatform/ICursor.h"
#include "HistoryManager.h"
#include "ICollectionContainer.h"
#include "ICollectionManager.h"
#include "ISourceControlModule.h"
#include "ISourceControlProvider.h"
#include "ISourceControlState.h"
#include "Input/DragAndDrop.h"
#include "Input/Events.h"
#include "InputCoreTypes.h"
#include "Layout/Children.h"
#include "Layout/Geometry.h"
#include "Layout/Margin.h"
#include "Layout/SlateRect.h"
#include "Layout/WidgetPath.h"
#include "Math/Color.h"
#include "Math/Vector2D.h"
#include "Misc/CString.h"
#include "Misc/ConfigCacheIni.h"
#include "Misc/TextFilterUtils.h"
#include "Modules/ModuleManager.h"
#include "ProfilingDebugging/CpuProfilerTrace.h"
#include "SAssetTagItem.h"
#include "SlotBase.h"
#include "SourcesSearch.h"
#include "SourcesViewWidgets.h"
#include "TelemetryRouter.h"
#include "Settings/ContentBrowserSettings.h"
#include "Styling/AppStyle.h"
#include "Styling/ISlateStyle.h"
#include "Styling/SlateColor.h"
#include "Templates/Tuple.h"
#include "Textures/SlateIcon.h"
#include "UObject/NameTypes.h"
#include "UObject/UnrealNames.h"
#include "Widgets/Images/SImage.h"
#include "Widgets/Input/SButton.h"
#include "Widgets/Input/SCheckBox.h"
#include "Widgets/Layout/SBorder.h"
#include "Widgets/SBoxPanel.h"
#include "Widgets/SNullWidget.h"
#include "Widgets/SOverlay.h"
#include "Widgets/Views/ITableRow.h"
#include "Widgets/Views/STableRow.h"
class SWidget;
struct FSlateBrush;
#define LOCTEXT_NAMESPACE "ContentBrowser"
namespace CollectionViewFilter
{
void GetBasicStrings(const FCollectionItem& InCollection, TArray<FString>& OutBasicStrings)
{
OutBasicStrings.Add(InCollection.CollectionName.ToString());
}
bool TestComplexExpression(const FCollectionItem& InCollection, const FName& InKey, const FTextFilterString& InValue, ETextFilterComparisonOperation InComparisonOperation, ETextFilterTextComparisonMode InTextComparisonMode)
{
static const FName NameKeyName = "Name";
static const FName TypeKeyName = "Type";
// Handle the collection name
if (InKey == NameKeyName)
{
// Names can only work with Equal or NotEqual type tests
if (InComparisonOperation != ETextFilterComparisonOperation::Equal && InComparisonOperation != ETextFilterComparisonOperation::NotEqual)
{
return false;
}
const bool bIsMatch = TextFilterUtils::TestBasicStringExpression(InCollection.CollectionName.ToString(), InValue, InTextComparisonMode);
return (InComparisonOperation == ETextFilterComparisonOperation::Equal) ? bIsMatch : !bIsMatch;
}
// Handle the collection type
if (InKey == TypeKeyName)
{
// Types can only work with Equal or NotEqual type tests
if (InComparisonOperation != ETextFilterComparisonOperation::Equal && InComparisonOperation != ETextFilterComparisonOperation::NotEqual)
{
return false;
}
const bool bIsMatch = TextFilterUtils::TestBasicStringExpression(ECollectionShareType::ToString(InCollection.CollectionType), InValue, InTextComparisonMode);
return (InComparisonOperation == ETextFilterComparisonOperation::Equal) ? bIsMatch : !bIsMatch;
}
return false;
}
} // namespace CollectionViewFilter
void SCollectionView::Construct( const FArguments& InArgs )
{
OnCollectionSelected = InArgs._OnCollectionSelected;
bAllowCollectionButtons = InArgs._AllowCollectionButtons;
bAllowRightClickMenu = InArgs._AllowRightClickMenu;
bAllowCollectionDrag = InArgs._AllowCollectionDrag;
bAllowExternalSearch = false;
bDraggedOver = false;
bQueueCollectionItemsUpdate = false;
bQueueSCCRefresh = true;
IsDocked = InArgs._IsDocked;
CollectionContainer = InArgs._CollectionContainer;
if (CollectionContainer)
{
CollectionContainer->OnCollectionCreated().AddSP(this, &SCollectionView::HandleCollectionCreated);
CollectionContainer->OnCollectionRenamed().AddSP(this, &SCollectionView::HandleCollectionRenamed);
CollectionContainer->OnCollectionReparented().AddSP(this, &SCollectionView::HandleCollectionReparented);
CollectionContainer->OnCollectionDestroyed().AddSP(this, &SCollectionView::HandleCollectionDestroyed);
CollectionContainer->OnCollectionUpdated().AddSP(this, &SCollectionView::HandleCollectionUpdated);
CollectionContainer->OnAssetsAddedToCollection().AddSP(this, &SCollectionView::HandleAssetsAddedToCollection);
CollectionContainer->OnAssetsRemovedFromCollection().AddSP(this, &SCollectionView::HandleAssetsRemovedFromCollection);
}
ISourceControlModule::Get().RegisterProviderChanged(FSourceControlProviderChanged::FDelegate::CreateSP(this, &SCollectionView::HandleSourceControlProviderChanged));
SourceControlStateChangedDelegateHandle = ISourceControlModule::Get().GetProvider().RegisterSourceControlStateChanged_Handle(FSourceControlStateChanged::FDelegate::CreateSP(this, &SCollectionView::HandleSourceControlStateChanged));
Commands = TSharedPtr< FUICommandList >(new FUICommandList);
CollectionContextMenu = MakeShareable(new FCollectionContextMenu( SharedThis(this) ));
CollectionContextMenu->BindCommands(Commands);
CollectionItemTextFilter = MakeShareable(new FCollectionItemTextFilter(
FCollectionItemTextFilter::FItemToStringArray::CreateStatic(&CollectionViewFilter::GetBasicStrings),
FCollectionItemTextFilter::FItemTestComplexExpression::CreateStatic(&CollectionViewFilter::TestComplexExpression)
));
CollectionItemTextFilter->OnChanged().AddSP(this, &SCollectionView::UpdateFilteredCollectionItems);
if ( CollectionContainer && InArgs._AllowQuickAssetManagement )
{
QuickAssetManagement = MakeShareable(new FCollectionAssetManagement(CollectionContainer.ToSharedRef()));
}
FOnContextMenuOpening CollectionListContextMenuOpening;
if ( InArgs._AllowContextMenu )
{
CollectionListContextMenuOpening = FOnContextMenuOpening::CreateSP( this, &SCollectionView::MakeCollectionTreeContextMenu );
}
SearchPtr = InArgs._ExternalSearch;
if (SearchPtr)
{
SearchPtr->OnSearchChanged().AddSP(this, &SCollectionView::SetCollectionsSearchFilterText);
}
ExternalSearchPtr = InArgs._ExternalSearch;
TitleContent = SNew(SHorizontalBox);
UContentBrowserCollectionProjectSettings* CollectionProjectSettings = GetMutableDefault<UContentBrowserCollectionProjectSettings>();
if (CollectionProjectSettings)
{
CollectionProjectSettings->OnSettingChanged().AddSPLambda(this, [this](UObject* CollectionProjectSettings_, struct FPropertyChangedEvent&)
{
UpdateFilteredCollectionItems();
});
}
PreventSelectionChangedDelegateCount = 0;
TSharedRef< SWidget > HeaderContent = SNew(SHorizontalBox)
.Visibility(this, &SCollectionView::GetHeaderVisibility)
+ SHorizontalBox::Slot()
.FillWidth(1.0f)
.Padding(0.0f)
[
TitleContent.ToSharedRef()
]
+SHorizontalBox::Slot()
.AutoWidth()
.VAlign(VAlign_Center)
.Padding(2.0f, 0.0f, 0.0f, 0.0f)
[
SNew(SButton)
.ButtonStyle(FAppStyle::Get(), "SimpleButton")
.ToolTipText(LOCTEXT("AddCollectionButtonTooltip", "Add a collection."))
.OnClicked(this, &SCollectionView::OnAddCollectionClicked)
.ContentPadding( FMargin(2, 2) )
.Visibility(this, &SCollectionView::GetAddCollectionButtonVisibility)
[
SNew(SImage)
.Image(FAppStyle::Get().GetBrush("Icons.PlusCircle"))
.ColorAndOpacity(FSlateColor::UseForeground())
]
];
TSharedRef< SWidget > BodyContent = SNew(SVerticalBox)
// Collections tree
+SVerticalBox::Slot()
.FillHeight(1.f)
[
SAssignNew(CollectionTreePtr, STreeView< TSharedPtr<FCollectionItem> >)
.TreeItemsSource(&VisibleRootCollectionItems)
.OnGenerateRow(this, &SCollectionView::GenerateCollectionRow)
.OnGetChildren(this, &SCollectionView::GetCollectionItemChildren)
.SelectionMode(ESelectionMode::Multi)
.OnSelectionChanged(this, &SCollectionView::CollectionSelectionChanged)
.OnContextMenuOpening(CollectionListContextMenuOpening)
.OnItemScrolledIntoView(this, &SCollectionView::CollectionItemScrolledIntoView)
.ClearSelectionOnClick(false)
.Visibility(this, &SCollectionView::GetCollectionTreeVisibility)
];
ChildSlot
[
SNew(SOverlay)
// Main content
+SOverlay::Slot()
[
SNew(SVerticalBox)
+ SVerticalBox::Slot()
.AutoHeight()
.Padding(FMargin(12.0f, 0.0f, 0.0f, 0.0f))
[
HeaderContent
]
+ SVerticalBox::Slot()
[
BodyContent
]
]
// Drop target overlay
+SOverlay::Slot()
[
SNew(SBorder)
.Padding(0)
.Visibility(EVisibility::HitTestInvisible)
.BorderImage(this, &SCollectionView::GetCollectionViewDropTargetBorder)
.BorderBackgroundColor(FLinearColor::Yellow)
[
SNullWidget::NullWidget
]
]
];
UpdateCollectionItems();
}
bool SCollectionView::IsEmpty() const
{
return AvailableCollections.IsEmpty();
}
void SCollectionView::HandleCollectionCreated( ICollectionContainer& InCollectionContainer, const FCollectionNameType& Collection )
{
bQueueCollectionItemsUpdate = true;
}
void SCollectionView::HandleCollectionRenamed( ICollectionContainer& InCollectionContainer, const FCollectionNameType& OriginalCollection, const FCollectionNameType& NewCollection )
{
bQueueCollectionItemsUpdate = true;
// Rename the item in-place so we can maintain its expansion and selection states correctly once the view is refreshed on the next Tick
TSharedPtr<FCollectionItem> CollectionItem = AvailableCollections.FindRef(OriginalCollection);
if (CollectionItem.IsValid())
{
CollectionItem->CollectionName = NewCollection.Name;
CollectionItem->CollectionType = NewCollection.Type;
AvailableCollections.Remove(OriginalCollection);
AvailableCollections.Add(NewCollection, CollectionItem);
}
}
void SCollectionView::HandleCollectionReparented( ICollectionContainer& InCollectionContainer, const FCollectionNameType& Collection, const TOptional<FCollectionNameType>& OldParent, const TOptional<FCollectionNameType>& NewParent )
{
bQueueCollectionItemsUpdate = true;
}
void SCollectionView::HandleCollectionDestroyed( ICollectionContainer& InCollectionContainer, const FCollectionNameType& Collection )
{
bQueueCollectionItemsUpdate = true;
}
void SCollectionView::HandleCollectionUpdated( ICollectionContainer& InCollectionContainer, const FCollectionNameType& Collection )
{
TSharedPtr<FCollectionItem> CollectionItemToUpdate = AvailableCollections.FindRef(Collection);
if (CollectionItemToUpdate.IsValid())
{
bQueueSCCRefresh = true;
CollectionItemToUpdate->CollectionColor = CollectionViewUtils::ResolveColor(InCollectionContainer, Collection.Name, Collection.Type);
UpdateCollectionItemStatus(CollectionItemToUpdate.ToSharedRef());
}
}
void SCollectionView::HandleAssetsAddedToCollection( ICollectionContainer& InCollectionContainer, const FCollectionNameType& Collection, TConstArrayView<FSoftObjectPath> AssetsAdded )
{
HandleCollectionUpdated(InCollectionContainer, Collection);
}
void SCollectionView::HandleAssetsRemovedFromCollection( ICollectionContainer& InCollectionContainer, const FCollectionNameType& Collection, TConstArrayView<FSoftObjectPath> AssetsRemoved )
{
HandleCollectionUpdated(InCollectionContainer, Collection);
}
void SCollectionView::HandleSourceControlProviderChanged(ISourceControlProvider& OldProvider, ISourceControlProvider& NewProvider)
{
OldProvider.UnregisterSourceControlStateChanged_Handle(SourceControlStateChangedDelegateHandle);
SourceControlStateChangedDelegateHandle = NewProvider.RegisterSourceControlStateChanged_Handle(FSourceControlStateChanged::FDelegate::CreateSP(this, &SCollectionView::HandleSourceControlStateChanged));
bQueueSCCRefresh = true;
HandleSourceControlStateChanged();
}
void SCollectionView::HandleSourceControlStateChanged()
{
bQueueItemStatusUpdate = true;
}
void SCollectionView::UpdateCollectionItemStatus( const TSharedRef<FCollectionItem>& CollectionItem )
{
TRACE_CPUPROFILER_EVENT_SCOPE(SCollectionView::UpdateCollectionItemStatus);
int32 NewObjectCount = 0;
TOptional<ECollectionItemStatus> NewStatus;
// Check IsModuleAvailable as we might be in the process of shutting down, and were notified due to the SCC provider being nulled out...
if (ensure(CollectionItem->CollectionContainer))
{
FCollectionStatusInfo StatusInfo;
if (CollectionItem->CollectionContainer->GetCollectionStatusInfo(CollectionItem->CollectionName, CollectionItem->CollectionType, StatusInfo))
{
NewObjectCount = StatusInfo.NumObjects;
// Test the SCC state first as this should take priority when reporting the status back to the user
if (StatusInfo.bUseSCC)
{
if (StatusInfo.SCCState.IsValid() && StatusInfo.SCCState->IsSourceControlled())
{
if (StatusInfo.SCCState->IsCheckedOutOther())
{
NewStatus = ECollectionItemStatus::IsCheckedOutByAnotherUser;
}
else if (StatusInfo.SCCState->IsConflicted())
{
NewStatus = ECollectionItemStatus::IsConflicted;
}
else if (!StatusInfo.SCCState->IsCurrent())
{
NewStatus = ECollectionItemStatus::IsOutOfDate;
}
else if (StatusInfo.SCCState->IsModified())
{
NewStatus = ECollectionItemStatus::HasLocalChanges;
}
}
else
{
NewStatus = ECollectionItemStatus::IsMissingSCCProvider;
}
}
// Not set by the SCC status, so check just use the local state
if (!NewStatus.IsSet())
{
if (StatusInfo.bIsDirty)
{
NewStatus = ECollectionItemStatus::HasLocalChanges;
}
else if (StatusInfo.bIsEmpty)
{
NewStatus = ECollectionItemStatus::IsUpToDateAndEmpty;
}
else
{
NewStatus = ECollectionItemStatus::IsUpToDateAndPopulated;
}
}
}
}
CollectionItem->NumObjects = NewObjectCount;
CollectionItem->CurrentStatus = NewStatus.Get(ECollectionItemStatus::IsUpToDateAndEmpty);
}
void SCollectionView::UpdateCollectionItems()
{
struct FGatherCollectionItems
{
static void GatherCollectionItems(const TSharedRef<ICollectionContainer>& InCollectionContainer, FAvailableCollectionsMap& OutAvailableCollections)
{
TArray<FCollectionNameType> RootCollections;
InCollectionContainer->GetRootCollections(RootCollections);
ProcessGatheredCollectionsAndRecurse(InCollectionContainer, RootCollections, nullptr, OutAvailableCollections);
}
private:
static void GatherChildCollectionItems(const TSharedRef<ICollectionContainer>& InCollectionContainer, const TSharedPtr<FCollectionItem>& InParentCollectionItem, FAvailableCollectionsMap& OutAvailableCollections)
{
TArray<FCollectionNameType> ChildCollections;
InCollectionContainer->GetChildCollections(InParentCollectionItem->CollectionName, InParentCollectionItem->CollectionType, ChildCollections);
ProcessGatheredCollectionsAndRecurse(InCollectionContainer, ChildCollections, InParentCollectionItem, OutAvailableCollections);
}
static void ProcessGatheredCollectionsAndRecurse(const TSharedRef<ICollectionContainer>& InCollectionContainer, const TArray<FCollectionNameType>& InCollections, const TSharedPtr<FCollectionItem>& InParentCollectionItem, FAvailableCollectionsMap& OutAvailableCollections)
{
for (const FCollectionNameType& Collection : InCollections)
{
// Never display system collections
if (Collection.Type == ECollectionShareType::CST_System)
{
continue;
}
TSharedRef<FCollectionItem> CollectionItem = MakeShareable(new FCollectionItem(InCollectionContainer, Collection.Name, Collection.Type));
OutAvailableCollections.Add(Collection, CollectionItem);
InCollectionContainer->GetCollectionStorageMode(Collection.Name, Collection.Type, CollectionItem->StorageMode);
CollectionItem->CollectionColor = CollectionViewUtils::ResolveColor(*InCollectionContainer, Collection.Name, Collection.Type);
SCollectionView::UpdateCollectionItemStatus(CollectionItem);
if (InParentCollectionItem.IsValid())
{
// Fixup the parent and child pointers
InParentCollectionItem->ChildCollections.Add(CollectionItem);
CollectionItem->ParentCollection = InParentCollectionItem;
}
// Recurse
GatherChildCollectionItems(InCollectionContainer, CollectionItem, OutAvailableCollections);
}
}
};
// Backup the current selection and expansion state of our collections
// We're about to re-create the tree, so we'll need to re-apply this again afterwards
TArray<FCollectionNameType> SelectedCollections;
TArray<FCollectionNameType> ExpandedCollections;
{
const auto SelectedCollectionItems = CollectionTreePtr->GetSelectedItems();
SelectedCollections.Reserve(SelectedCollectionItems.Num());
for (const TSharedPtr<FCollectionItem>& SelectedCollectionItem : SelectedCollectionItems)
{
SelectedCollections.Add(FCollectionNameType(SelectedCollectionItem->CollectionName, SelectedCollectionItem->CollectionType));
}
}
{
TSet<TSharedPtr<FCollectionItem>> ExpandedCollectionItems;
CollectionTreePtr->GetExpandedItems(ExpandedCollectionItems);
ExpandedCollections.Reserve(ExpandedCollectionItems.Num());
for (const TSharedPtr<FCollectionItem>& ExpandedCollectionItem : ExpandedCollectionItems)
{
ExpandedCollections.Add(FCollectionNameType(ExpandedCollectionItem->CollectionName, ExpandedCollectionItem->CollectionType));
}
}
AvailableCollections.Reset();
if (CollectionContainer)
{
FGatherCollectionItems::GatherCollectionItems(CollectionContainer.ToSharedRef(), AvailableCollections);
}
UpdateFilteredCollectionItems();
// Restore selection and expansion
SetSelectedCollections(SelectedCollections, false);
SetExpandedCollections(ExpandedCollections);
bQueueSCCRefresh = true;
}
void SCollectionView::UpdateFilteredCollectionItems()
{
VisibleCollections.Reset();
VisibleRootCollectionItems.Reset();
const UContentBrowserCollectionProjectSettings* CollectionProjectSettings = GetDefault<UContentBrowserCollectionProjectSettings>();
const UContentBrowserSettings* ContentBrowserSettings = GetDefault<UContentBrowserSettings>();
auto AddVisibleCollection = [&](const FCollectionNameType& NameTypePair, const TSharedPtr<FCollectionItem>& InCollectionItem)
{
if (!ContentBrowserSettings->bDisplayExcludedCollections)
{
const int32 FoundIndex = CollectionProjectSettings->ExcludedCollectionsFromView.Find(NameTypePair.Name);
if (FoundIndex != INDEX_NONE)
{
return;
}
}
VisibleCollections.Add(FCollectionNameType(InCollectionItem->CollectionName, InCollectionItem->CollectionType));
if (!InCollectionItem->ParentCollection.IsValid())
{
VisibleRootCollectionItems.AddUnique(InCollectionItem);
}
};
auto AddVisibleCollectionRecursive = [&](const FCollectionNameType& NameTypePair, const TSharedPtr<FCollectionItem>& InCollectionItem)
{
TSharedPtr<FCollectionItem> CollectionItemToAdd = InCollectionItem;
do
{
AddVisibleCollection(NameTypePair, CollectionItemToAdd);
CollectionItemToAdd = CollectionItemToAdd->ParentCollection.Pin();
}
while(CollectionItemToAdd.IsValid());
};
// Do we have an active filter to test against?
if (CollectionItemTextFilter->GetRawFilterText().IsEmpty())
{
// No filter, just mark everything as visible
for (const auto& AvailableCollectionInfo : AvailableCollections)
{
AddVisibleCollection(AvailableCollectionInfo.Key, AvailableCollectionInfo.Value);
}
}
else
{
TArray<TSharedRef<FCollectionItem>> CollectionsToExpandTo;
// Test everything against the filter - a visible child needs to make sure its parents are also marked as visible
for (const auto& AvailableCollectionInfo : AvailableCollections)
{
const TSharedPtr<FCollectionItem>& CollectionItem = AvailableCollectionInfo.Value;
if (CollectionItemTextFilter->PassesFilter(*CollectionItem))
{
AddVisibleCollectionRecursive(AvailableCollectionInfo.Key, CollectionItem);
CollectionsToExpandTo.Add(CollectionItem.ToSharedRef());
}
}
// Make sure all matching items have their parents expanded so they can be seen
for (const TSharedRef<FCollectionItem>& CollectionItem : CollectionsToExpandTo)
{
ExpandParentItems(CollectionItem);
}
}
UContentBrowserSettings::OnSettingChanged().AddSP(this, &SCollectionView::HandleSettingChanged);
VisibleRootCollectionItems.Sort(FCollectionItem::FCompareFCollectionItemByName());
CollectionTreePtr->RequestTreeRefresh();
}
void SCollectionView::SetCollectionsSearchFilterText( const FText& InSearchText, TArray<FText>& OutErrors )
{
CollectionItemTextFilter->SetRawFilterText( InSearchText );
const FText ErrorText = CollectionItemTextFilter->GetFilterErrorText();
if (!ErrorText.IsEmpty())
{
OutErrors.Add(ErrorText);
}
}
FText SCollectionView::GetCollectionsSearchFilterText() const
{
return CollectionItemTextFilter->GetRawFilterText();
}
void SCollectionView::SetSelectedCollections(const TArray<FCollectionNameType>& CollectionsToSelect, const bool bEnsureVisible)
{
// Prevent the selection changed delegate since the invoking code requested it
FScopedPreventSelectionChangedDelegate DelegatePrevention( SharedThis(this) );
// Clear the selection to start, then add the selected items as they are found
CollectionTreePtr->ClearSelection();
for (const FCollectionNameType& CollectionToSelect : CollectionsToSelect)
{
TSharedPtr<FCollectionItem> CollectionItemToSelect = AvailableCollections.FindRef(CollectionToSelect);
if (CollectionItemToSelect.IsValid())
{
if (bEnsureVisible)
{
ExpandParentItems(CollectionItemToSelect.ToSharedRef());
CollectionTreePtr->RequestScrollIntoView(CollectionItemToSelect);
}
CollectionTreePtr->SetItemSelection(CollectionItemToSelect, true);
// If the selected collection doesn't pass our current filter, we need to clear it
if (bEnsureVisible && !CollectionItemTextFilter->PassesFilter(*CollectionItemToSelect))
{
SearchPtr->ClearSearch();
}
}
}
}
void SCollectionView::SetExpandedCollections(const TArray<FCollectionNameType>& CollectionsToExpand)
{
// Clear the expansion to start, then add the expanded items as they are found
CollectionTreePtr->ClearExpandedItems();
for (const FCollectionNameType& CollectionToExpand : CollectionsToExpand)
{
TSharedPtr<FCollectionItem> CollectionItemToExpand = AvailableCollections.FindRef(CollectionToExpand);
if (CollectionItemToExpand.IsValid())
{
CollectionTreePtr->SetItemExpansion(CollectionItemToExpand, true);
}
}
}
void SCollectionView::ClearSelection()
{
// Prevent the selection changed delegate since the invoking code requested it
FScopedPreventSelectionChangedDelegate DelegatePrevention( SharedThis(this) );
// Clear the selection to start, then add the selected paths as they are found
CollectionTreePtr->ClearSelection();
}
const TSharedPtr<ICollectionContainer>& SCollectionView::GetCollectionContainer() const
{
return CollectionContainer;
}
TArray<FCollectionNameType> SCollectionView::GetSelectedCollections() const
{
TArray<FCollectionNameType> RetArray;
TArray<TSharedPtr<FCollectionItem>> Items = CollectionTreePtr->GetSelectedItems();
for ( int32 ItemIdx = 0; ItemIdx < Items.Num(); ++ItemIdx )
{
const TSharedPtr<FCollectionItem>& Item = Items[ItemIdx];
RetArray.Add(FCollectionNameType(Item->CollectionName, Item->CollectionType));
}
return RetArray;
}
void SCollectionView::SetSelectedAssetPaths(const TArray<FSoftObjectPath>& SelectedAssets)
{
if ( QuickAssetManagement.IsValid() )
{
QuickAssetManagement->SetCurrentAssetPaths(SelectedAssets);
}
}
void SCollectionView::ApplyHistoryData( const FHistoryData& History )
{
// Prevent the selection changed delegate because it would add more history when we are just setting a state
FScopedPreventSelectionChangedDelegate DelegatePrevention( SharedThis(this) );
CollectionTreePtr->ClearSelection();
for (const FCollectionRef& HistoryCollection : History.ContentSources.GetCollections())
{
if (CollectionContainer == HistoryCollection.Container)
{
TSharedPtr<FCollectionItem> CollectionHistoryItem = AvailableCollections.FindRef(FCollectionNameType(HistoryCollection.Name, HistoryCollection.Type));
if (CollectionHistoryItem.IsValid())
{
ExpandParentItems(CollectionHistoryItem.ToSharedRef());
CollectionTreePtr->RequestScrollIntoView(CollectionHistoryItem);
CollectionTreePtr->SetItemSelection(CollectionHistoryItem, true);
}
}
}
}
void SCollectionView::SaveSettings(const FString& IniFilename, const FString& IniSection, const FString& SettingsString) const
{
auto SaveCollectionsArrayToIni = [&](const FString& InSubKey, const TArray<TSharedPtr<FCollectionItem>>& InCollectionItems)
{
FString CollectionsString;
for (const TSharedPtr<FCollectionItem>& CollectionItem : InCollectionItems)
{
if (CollectionsString.Len() > 0)
{
CollectionsString += TEXT(",");
}
CollectionsString += CollectionItem->CollectionName.ToString();
CollectionsString += TEXT("?");
CollectionsString += FString::FromInt(CollectionItem->CollectionType);
}
GConfig->SetString(*IniSection, *(SettingsString + InSubKey), *CollectionsString, IniFilename);
};
SaveCollectionsArrayToIni(TEXT(".SelectedCollections"), CollectionTreePtr->GetSelectedItems());
{
TSet<TSharedPtr<FCollectionItem>> ExpandedCollectionItems;
CollectionTreePtr->GetExpandedItems(ExpandedCollectionItems);
SaveCollectionsArrayToIni(TEXT(".ExpandedCollections"), ExpandedCollectionItems.Array());
}
}
void SCollectionView::LoadSettings(const FString& IniFilename, const FString& IniSection, const FString& SettingsString)
{
auto LoadCollectionsArrayFromIni = [&](const FString& InSubKey) -> TArray<FCollectionNameType>
{
TArray<FCollectionNameType> RetCollectionsArray;
FString CollectionsArrayString;
if (GConfig->GetString(*IniSection, *(SettingsString + InSubKey), CollectionsArrayString, IniFilename))
{
TArray<FString> CollectionStrings;
CollectionsArrayString.ParseIntoArray(CollectionStrings, TEXT(","), /*bCullEmpty*/true);
for (const FString& CollectionString : CollectionStrings)
{
FString CollectionName;
FString CollectionTypeString;
if (CollectionString.Split(TEXT("?"), &CollectionName, &CollectionTypeString))
{
const int32 CollectionType = FCString::Atoi(*CollectionTypeString);
if (CollectionType >= 0 && CollectionType < ECollectionShareType::CST_All)
{
RetCollectionsArray.Add(FCollectionNameType(FName(*CollectionName), ECollectionShareType::Type(CollectionType)));
}
}
}
}
return RetCollectionsArray;
};
// Selected Collections
TArray<FCollectionNameType> NewSelectedCollections = LoadCollectionsArrayFromIni(TEXT(".SelectedCollections"));
if (NewSelectedCollections.Num() > 0)
{
SetSelectedCollections(NewSelectedCollections);
const TArray<TSharedPtr<FCollectionItem>> SelectedCollectionItems = CollectionTreePtr->GetSelectedItems();
if (SelectedCollectionItems.Num() > 0)
{
CollectionSelectionChanged(SelectedCollectionItems[0], ESelectInfo::Direct);
}
}
// Expanded Collections
TArray<FCollectionNameType> NewExpandedCollections = LoadCollectionsArrayFromIni(TEXT(".ExpandedCollections"));
if (NewExpandedCollections.Num() > 0)
{
SetExpandedCollections(NewExpandedCollections);
}
}
void SCollectionView::Tick( const FGeometry& AllottedGeometry, const double InCurrentTime, const float InDeltaTime )
{
SCompoundWidget::Tick(AllottedGeometry, InCurrentTime, InDeltaTime);
if (bQueueCollectionItemsUpdate)
{
bQueueCollectionItemsUpdate = false;
UpdateCollectionItems();
}
if (bQueueSCCRefresh && CollectionContainer && ISourceControlModule::Get().IsEnabled())
{
bQueueSCCRefresh = false;
TArray<FString> CollectionFilesToRefresh;
for (const auto& AvailableCollectionInfo : AvailableCollections)
{
FCollectionStatusInfo StatusInfo;
if (CollectionContainer->GetCollectionStatusInfo(AvailableCollectionInfo.Value->CollectionName, AvailableCollectionInfo.Value->CollectionType, StatusInfo))
{
if (StatusInfo.bUseSCC && StatusInfo.SCCState.IsValid() && StatusInfo.SCCState->IsSourceControlled())
{
CollectionFilesToRefresh.Add(StatusInfo.SCCState->GetFilename());
}
}
}
if (CollectionFilesToRefresh.Num() > 0)
{
ISourceControlModule::Get().QueueStatusUpdate(CollectionFilesToRefresh);
}
}
if (bQueueItemStatusUpdate)
{
TRACE_CPUPROFILER_EVENT_SCOPE_STR("CollectionView Update Collection Items Status");
bQueueItemStatusUpdate = false;
// Update the status of each collection
for (const TPair<FCollectionNameType, TSharedPtr<FCollectionItem>>& AvailableCollectionInfo : AvailableCollections)
{
UpdateCollectionItemStatus(AvailableCollectionInfo.Value.ToSharedRef());
}
}
}
FReply SCollectionView::OnKeyDown( const FGeometry& MyGeometry, const FKeyEvent& InKeyEvent )
{
if( Commands->ProcessCommandBindings( InKeyEvent ) )
{
return FReply::Handled();
}
return FReply::Unhandled();
}
void SCollectionView::OnDragEnter( const FGeometry& MyGeometry, const FDragDropEvent& DragDropEvent )
{
ValidateDragDropOnCollectionTree(MyGeometry, DragDropEvent, bDraggedOver); // updates bDraggedOver
}
void SCollectionView::OnDragLeave( const FDragDropEvent& DragDropEvent )
{
bDraggedOver = false;
}
FReply SCollectionView::OnDragOver( const FGeometry& MyGeometry, const FDragDropEvent& DragDropEvent )
{
ValidateDragDropOnCollectionTree(MyGeometry, DragDropEvent, bDraggedOver); // updates bDraggedOver
return (bDraggedOver) ? FReply::Handled() : FReply::Unhandled();
}
FReply SCollectionView::OnDrop( const FGeometry& MyGeometry, const FDragDropEvent& DragDropEvent )
{
if (ValidateDragDropOnCollectionTree(MyGeometry, DragDropEvent, bDraggedOver)) // updates bDraggedOver
{
bDraggedOver = false;
return HandleDragDropOnCollectionTree(MyGeometry, DragDropEvent);
}
if (bDraggedOver)
{
// We were able to handle this operation, but could not due to another error - still report this drop as handled so it doesn't fall through to other widgets
bDraggedOver = false;
return FReply::Handled();
}
return FReply::Unhandled();
}
void SCollectionView::MakeSaveDynamicCollectionMenu(FMenuBuilder& InMenuBuilder, FText InQueryString)
{
CollectionContextMenu->UpdateProjectSourceControl();
CollectionContextMenu->MakeSaveDynamicCollectionSubMenu(InMenuBuilder, InQueryString);
}
FReply SCollectionView::OnAddCollectionClicked()
{
MakeAddCollectionMenu(AsShared());
return FReply::Handled();
}
bool SCollectionView::ShouldAllowSelectionChangedDelegate() const
{
return PreventSelectionChangedDelegateCount == 0;
}
void SCollectionView::MakeAddCollectionMenu(TSharedRef<SWidget> MenuParent)
{
// Get all menu extenders for this context menu from the content browser module
FContentBrowserModule& ContentBrowserModule = FModuleManager::GetModuleChecked<FContentBrowserModule>( TEXT("ContentBrowser") );
TArray<FContentBrowserMenuExtender> MenuExtenderDelegates = ContentBrowserModule.GetAllCollectionViewContextMenuExtenders();
TArray<TSharedPtr<FExtender>> Extenders;
for (int32 i = 0; i < MenuExtenderDelegates.Num(); ++i)
{
if (MenuExtenderDelegates[i].IsBound())
{
Extenders.Add(MenuExtenderDelegates[i].Execute());
}
}
TSharedPtr<FExtender> MenuExtender = FExtender::Combine(Extenders);
FMenuBuilder MenuBuilder(/*bInShouldCloseWindowAfterMenuSelection=*/true, NULL, MenuExtender, true);
CollectionContextMenu->UpdateProjectSourceControl();
CollectionContextMenu->MakeNewCollectionSubMenu(MenuBuilder, ECollectionStorageMode::Static, SCollectionView::FCreateCollectionPayload());
FSlateApplication::Get().PushMenu(
MenuParent,
FWidgetPath(),
MenuBuilder.MakeWidget(),
FSlateApplication::Get().GetCursorPos(),
FPopupTransitionEffect( FPopupTransitionEffect::TopMenu )
);
}
FVector2D SCollectionView::GetScrollDistance()
{
if (!CollectionTreePtr.IsValid())
{
return FVector2D::ZeroVector;
}
return CollectionTreePtr->GetScrollDistance();
}
FVector2D SCollectionView::GetScrollDistanceRemaining()
{
if (!CollectionTreePtr.IsValid())
{
return FVector2D::ZeroVector;
}
return CollectionTreePtr->GetScrollDistanceRemaining();
}
TSharedRef<SWidget> SCollectionView::GetScrollWidget()
{
return SharedThis(this);
}
void SCollectionView::CreateCollectionItem( ECollectionShareType::Type CollectionType, ECollectionStorageMode::Type StorageMode, const FCreateCollectionPayload& InCreationPayload )
{
if ( ensure(CollectionContainer && CollectionType != ECollectionShareType::CST_All) )
{
const FName BaseCollectionName = *LOCTEXT("NewCollectionName", "NewCollection").ToString();
FName CollectionName;
CollectionContainer->CreateUniqueCollectionName(BaseCollectionName, ECollectionShareType::CST_All, CollectionName);
TSharedPtr<FCollectionItem> NewItem = MakeShareable(new FCollectionItem(CollectionContainer.ToSharedRef(), CollectionName, CollectionType));
NewItem->StorageMode = StorageMode;
// Adding a new collection now, so clear any filter we may have applied
SearchPtr->ClearSearch();
if ( InCreationPayload.ParentCollection.IsSet() )
{
TSharedPtr<FCollectionItem> ParentCollectionItem = AvailableCollections.FindRef(InCreationPayload.ParentCollection.GetValue());
if ( ParentCollectionItem.IsValid() )
{
ParentCollectionItem->ChildCollections.Add(NewItem);
NewItem->ParentCollection = ParentCollectionItem;
// Make sure the parent is expanded so we can see its newly added child item
CollectionTreePtr->SetItemExpansion(ParentCollectionItem, true);
}
}
// Mark the new collection for rename and that it is new so it will be created upon successful rename
NewItem->bRenaming = true;
NewItem->bNewCollection = true;
NewItem->OnCollectionCreatedEvent = InCreationPayload.OnCollectionCreatedEvent;
AvailableCollections.Add( FCollectionNameType(NewItem->CollectionName, NewItem->CollectionType), NewItem );
UpdateFilteredCollectionItems();
CollectionTreePtr->RequestScrollIntoView(NewItem);
CollectionTreePtr->SetSelection( NewItem );
}
}
void SCollectionView::RenameCollectionItem( const TSharedPtr<FCollectionItem>& ItemToRename )
{
if ( ensure(ItemToRename.IsValid()) )
{
ItemToRename->bRenaming = true;
CollectionTreePtr->RequestScrollIntoView(ItemToRename);
}
}
void SCollectionView::DeleteCollectionItems( const TArray<TSharedPtr<FCollectionItem>>& ItemsToDelete )
{
if (ItemsToDelete.Num() == 0)
{
return;
}
// Before we delete anything (as this will trigger a tree update) we need to work out what our new selection should be in the case that
// all of the selected items are removed
const TArray<TSharedPtr<FCollectionItem>> PreviouslySelectedItems = CollectionTreePtr->GetSelectedItems();
// Get the first selected item that will be deleted so we can find a suitable new selection
TSharedPtr<FCollectionItem> FirstSelectedItemDeleted;
for (const auto& ItemToDelete : ItemsToDelete)
{
if (PreviouslySelectedItems.Contains(ItemToDelete))
{
FirstSelectedItemDeleted = ItemToDelete;
break;
}
}
// Build up an array of potential new selections (in the case that we're deleting everything that's selected)
// Earlier items should be considered first, we base this list on the first selected item that will be deleted, and include previous siblings, and then all parents and roots
TArray<FCollectionNameType> PotentialNewSelections;
if (FirstSelectedItemDeleted.IsValid())
{
TSharedPtr<FCollectionItem> RootSelectedItemDeleted = FirstSelectedItemDeleted;
TSharedPtr<FCollectionItem> ParentCollectionItem = FirstSelectedItemDeleted->ParentCollection.Pin();
if (ParentCollectionItem.IsValid())
{
// Add all the siblings until we find the item that will be deleted
for (const auto& ChildItemWeakPtr : ParentCollectionItem->ChildCollections)
{
TSharedPtr<FCollectionItem> ChildItem = ChildItemWeakPtr.Pin();
if (ChildItem.IsValid())
{
if (ChildItem == FirstSelectedItemDeleted)
{
break;
}
// We add siblings as the start, as the closest sibling should be the first match
PotentialNewSelections.Insert(FCollectionNameType(ChildItem->CollectionName, ChildItem->CollectionType), 0);
}
}
// Now add this parent, and all other parents too
do
{
PotentialNewSelections.Add(FCollectionNameType(ParentCollectionItem->CollectionName, ParentCollectionItem->CollectionType));
RootSelectedItemDeleted = ParentCollectionItem;
ParentCollectionItem = ParentCollectionItem->ParentCollection.Pin();
}
while (ParentCollectionItem.IsValid());
}
if (RootSelectedItemDeleted.IsValid())
{
// Add all the root level items before this one
const int32 InsertionPoint = PotentialNewSelections.Num();
for (const auto& RootItem : VisibleRootCollectionItems)
{
if (RootItem == RootSelectedItemDeleted)
{
break;
}
// Add each root item at the insertion point, as the closest item should be a better match
PotentialNewSelections.Insert(FCollectionNameType(RootItem->CollectionName, RootItem->CollectionType), InsertionPoint);
}
}
}
// Delete all given collections
int32 NumSelectedItemsDeleted = 0;
for (const TSharedPtr<FCollectionItem>& ItemToDelete : ItemsToDelete)
{
if (!ensure(ItemToDelete->CollectionContainer))
{
continue;
}
FText Error;
if (ItemToDelete->CollectionContainer->DestroyCollection(ItemToDelete->CollectionName, ItemToDelete->CollectionType, &Error))
{
if (PreviouslySelectedItems.Contains(ItemToDelete))
{
++NumSelectedItemsDeleted;
}
}
else
{
// Display a warning
const FVector2f& CursorPos = FSlateApplication::Get().GetCursorPos();
FSlateRect MessageAnchor(CursorPos.X, CursorPos.Y, CursorPos.X, CursorPos.Y);
ContentBrowserUtils::DisplayMessage(
FText::Format( LOCTEXT("CollectionDestroyFailed", "Failed to destroy collection. {0}"), Error),
MessageAnchor,
CollectionTreePtr.ToSharedRef(),
ContentBrowserUtils::EDisplayMessageType::Error
);
}
}
// DestroyCollection will have triggered a notification that will have updated the tree, we now need to apply a suitable selection...
// Did this delete change the list of selected items?
if (NumSelectedItemsDeleted > 0 || PreviouslySelectedItems.Num() == 0)
{
// If we removed everything that was selected, we need to try and find a suitable replacement...
if (NumSelectedItemsDeleted >= PreviouslySelectedItems.Num() && VisibleCollections.Num() > 1)
{
// Include the first visible item as an absolute last resort should everything else suitable have been removed from the tree
PotentialNewSelections.Add(*VisibleCollections.CreateConstIterator());
// Check the potential new selections array and try and select the first one that's still visible in the tree
TArray<FCollectionNameType> NewItemSelection;
for (const FCollectionNameType& PotentialNewSelection : PotentialNewSelections)
{
if (VisibleCollections.Contains(PotentialNewSelection))
{
NewItemSelection.Add(PotentialNewSelection);
break;
}
}
SetSelectedCollections(NewItemSelection, true);
}
// Broadcast the new selection
const TArray<TSharedPtr<FCollectionItem>> UpdatedSelectedItems = CollectionTreePtr->GetSelectedItems();
CollectionSelectionChanged((UpdatedSelectedItems.Num() > 0) ? UpdatedSelectedItems[0] : nullptr, ESelectInfo::Direct);
}
}
EVisibility SCollectionView::GetCollectionTreeVisibility() const
{
return AvailableCollections.Num() > 0 ? EVisibility::Visible : EVisibility::Collapsed;
}
EVisibility SCollectionView::GetHeaderVisibility() const
{
return IsDocked.Get() ? EVisibility::Collapsed : EVisibility::SelfHitTestInvisible;
}
EVisibility SCollectionView::GetAddCollectionButtonVisibility() const
{
return bAllowCollectionButtons && CollectionContainer.IsValid() && !CollectionContainer->IsReadOnly(ECollectionShareType::CST_All) ? EVisibility::Visible : EVisibility::Collapsed;
}
const FSlateBrush* SCollectionView::GetCollectionViewDropTargetBorder() const
{
return bDraggedOver ? UE::ContentBrowser::Private::FContentBrowserStyle::Get().GetBrush("ContentBrowser.CollectionTreeDragDropBorder") : FAppStyle::GetBrush("NoBorder");
}
TSharedRef<ITableRow> SCollectionView::GenerateCollectionRow( TSharedPtr<FCollectionItem> CollectionItem, const TSharedRef<STableViewBase>& OwnerTable )
{
check(CollectionItem.IsValid());
// Only bind the check box callbacks if we're allowed to show check boxes
TAttribute<bool> IsCollectionCheckBoxEnabledAttribute;
TAttribute<ECheckBoxState> IsCollectionCheckedAttribute;
FOnCheckStateChanged OnCollectionCheckStateChangedDelegate;
if ( QuickAssetManagement.IsValid() )
{
// Can only manage assets for static collections
if (CollectionItem->StorageMode == ECollectionStorageMode::Static)
{
IsCollectionCheckBoxEnabledAttribute.Bind(TAttribute<bool>::FGetter::CreateSP(this, &SCollectionView::IsCollectionCheckBoxEnabled, CollectionItem));
IsCollectionCheckedAttribute.Bind(TAttribute<ECheckBoxState>::FGetter::CreateSP(this, &SCollectionView::IsCollectionChecked, CollectionItem));
OnCollectionCheckStateChangedDelegate.BindSP(this, &SCollectionView::OnCollectionCheckStateChanged, CollectionItem);
}
else
{
IsCollectionCheckBoxEnabledAttribute.Bind(TAttribute<bool>::FGetter::CreateLambda([]{ return false; }));
IsCollectionCheckedAttribute.Bind(TAttribute<ECheckBoxState>::FGetter::CreateLambda([]{ return ECheckBoxState::Unchecked; }));
}
}
TSharedPtr< SAssetTagItemTableRow< TSharedPtr<FCollectionItem> > > TableRow = SNew( SAssetTagItemTableRow< TSharedPtr<FCollectionItem> >, OwnerTable )
.OnDragDetected(this, &SCollectionView::OnCollectionDragDetected);
TSharedPtr<SCollectionTreeItem> CollectionTreeItem;
TableRow->SetContent
(
SAssignNew(CollectionTreeItem, SCollectionTreeItem)
.ParentWidget(SharedThis(this))
.CollectionItem(CollectionItem)
.OnNameChangeCommit(this, &SCollectionView::CollectionNameChangeCommit)
.OnVerifyRenameCommit(this, &SCollectionView::CollectionVerifyRenameCommit)
.OnValidateDragDrop(this, &SCollectionView::ValidateDragDropOnCollectionItem)
.OnHandleDragDrop(this, &SCollectionView::HandleDragDropOnCollectionItem)
.IsSelected(TableRow.Get(), &STableRow< TSharedPtr<FCollectionItem> >::IsSelectedExclusively)
.IsReadOnly(this, &SCollectionView::IsCollectionNameReadOnly)
.HighlightText(this, &SCollectionView::GetCollectionsSearchFilterText)
.IsCheckBoxEnabled(IsCollectionCheckBoxEnabledAttribute)
.IsCollectionChecked(IsCollectionCheckedAttribute)
.OnCollectionCheckStateChanged(OnCollectionCheckStateChangedDelegate)
);
TableRow->SetIsDropTarget(MakeAttributeSP(CollectionTreeItem.Get(), &SCollectionTreeItem::IsDraggedOver));
return TableRow.ToSharedRef();
}
void SCollectionView::GetCollectionItemChildren( TSharedPtr<FCollectionItem> InParentItem, TArray< TSharedPtr<FCollectionItem> >& OutChildItems ) const
{
for (const auto& ChildItemWeakPtr : InParentItem->ChildCollections)
{
TSharedPtr<FCollectionItem> ChildItem = ChildItemWeakPtr.Pin();
if (ChildItem.IsValid() && VisibleCollections.Contains(FCollectionNameType(ChildItem->CollectionName, ChildItem->CollectionType)))
{
OutChildItems.Add(ChildItem);
}
}
OutChildItems.Sort(FCollectionItem::FCompareFCollectionItemByName());
}
FReply SCollectionView::OnCollectionDragDetected(const FGeometry& Geometry, const FPointerEvent& MouseEvent)
{
if (bAllowCollectionDrag && MouseEvent.IsMouseButtonDown(EKeys::LeftMouseButton))
{
const TArray<FCollectionNameType> SelectedCollections = GetSelectedCollections();
if (SelectedCollections.Num() > 0)
{
TArray<FCollectionRef> CollectionRefs;
CollectionRefs.Reserve(SelectedCollections.Num());
Algo::Transform(
SelectedCollections,
CollectionRefs,
[this](const FCollectionNameType& Collection) { return FCollectionRef(CollectionContainer, Collection); });
TSharedRef<FCollectionDragDropOp> DragDropOp = FCollectionDragDropOp::New(CollectionRefs);
CurrentCollectionDragDropOp = DragDropOp;
return FReply::Handled().BeginDragDrop(DragDropOp);
}
}
return FReply::Unhandled();
}
bool SCollectionView::ValidateDragDropOnCollectionTree(const FGeometry& Geometry, const FDragDropEvent& DragDropEvent, bool& OutIsKnownDragOperation)
{
OutIsKnownDragOperation = false;
if (!CollectionContainer.IsValid())
{
return false;
}
TSharedPtr<FDragDropOperation> Operation = DragDropEvent.GetOperation();
if (!Operation.IsValid())
{
return false;
}
if (Operation->IsOfType<FCollectionDragDropOp>())
{
TSharedPtr<FCollectionDragDropOp> DragDropOp = StaticCastSharedPtr<FCollectionDragDropOp>(Operation);
OutIsKnownDragOperation = true;
if (Algo::AllOf(DragDropOp->CollectionRefs, [this](const FCollectionRef& Collection)
{
return CollectionContainer == Collection.Container;
}))
{
return true;
}
else
{
DragDropOp->SetToolTip(
LOCTEXT("InvalidParentCollectionContainer", "A collection cannot be parented to a different collection container"),
FAppStyle::GetBrush(TEXT("Graph.ConnectorFeedback.Error")));
Operation->SetCursorOverride(EMouseCursor::SlashedCircle);
}
}
else if (Operation->IsOfType<FAssetDragDropOp>())
{
TSharedPtr<FAssetDragDropOp> DragDropOp = StaticCastSharedPtr<FAssetDragDropOp>(Operation);
if (!DragDropOp->HasAssets())
{
DragDropOp->SetCursorOverride(EMouseCursor::SlashedCircle);
DragDropOp->SetToolTip(LOCTEXT("CollectionView_DragDrop_NoAsset", "There is no asset being dragged"), FAppStyle::GetBrush(TEXT("Graph.ConnectorFeedback.Error")));
return false;
}
const int32 NumDraggedItems = DragDropOp->GetAssets().Num();
const FText FirstItemText = FText::FromName(DragDropOp->GetAssets()[0].AssetName);
const FText AddToCollectionText = (NumDraggedItems > 1)
? FText::Format(LOCTEXT("CollectionView_DragDrop_MultipleItems", "Add '{0}' and {1} {1}|plural(one=other,other=others)"), FirstItemText, NumDraggedItems - 1)
: FText::Format(LOCTEXT("CollectionView_DragDrop_SingularItems", "Add '{0}'"), FirstItemText);
DragDropOp->SetToolTip(AddToCollectionText, FAppStyle::GetBrush(TEXT("Graph.ConnectorFeedback.OK")));
return true;
}
return false;
}
FReply SCollectionView::HandleDragDropOnCollectionTree(const FGeometry& Geometry, const FDragDropEvent& DragDropEvent)
{
// Should have already called ValidateDragDropOnCollectionTree prior to calling this...
TSharedPtr<FDragDropOperation> Operation = DragDropEvent.GetOperation();
check(Operation.IsValid());
if (Operation->IsOfType<FCollectionDragDropOp>())
{
TSharedPtr<FCollectionDragDropOp> DragDropOp = StaticCastSharedPtr<FCollectionDragDropOp>(Operation);
// Reparent all of the collections in the drag drop so that they are root level items
for (const FCollectionRef& NewChildCollection : DragDropOp->CollectionRefs)
{
check(CollectionContainer == NewChildCollection.Container);
FText Error;
if (!CollectionContainer->ReparentCollection(
NewChildCollection.Name, NewChildCollection.Type,
NAME_None, ECollectionShareType::CST_All, &Error
))
{
ContentBrowserUtils::DisplayMessage(Error, Geometry.GetLayoutBoundingRect(), SharedThis(this), ContentBrowserUtils::EDisplayMessageType::Error);
}
}
return FReply::Handled();
}
return FReply::Unhandled();
}
bool SCollectionView::ValidateDragDropOnCollectionItem(TSharedRef<FCollectionItem> CollectionItem, const FGeometry& Geometry, const FDragDropEvent& DragDropEvent, bool& OutIsKnownDragOperation)
{
OutIsKnownDragOperation = false;
if (!ensure(CollectionItem->CollectionContainer))
{
return false;
}
TSharedPtr<FDragDropOperation> Operation = DragDropEvent.GetOperation();
if (!Operation.IsValid())
{
return false;
}
bool bIsValidDrag = false;
TOptional<EMouseCursor::Type> NewDragCursor;
if (Operation->IsOfType<FCollectionDragDropOp>())
{
TSharedPtr<FCollectionDragDropOp> DragDropOp = StaticCastSharedPtr<FCollectionDragDropOp>(Operation);
OutIsKnownDragOperation = true;
bIsValidDrag = true;
for (const FCollectionRef& PotentialChildCollection : DragDropOp->CollectionRefs)
{
FText Error;
if (CollectionItem->CollectionContainer == PotentialChildCollection.Container)
{
bIsValidDrag = CollectionItem->CollectionContainer->IsValidParentCollection(
PotentialChildCollection.Name, PotentialChildCollection.Type,
CollectionItem->CollectionName, CollectionItem->CollectionType, &Error);
}
else
{
bIsValidDrag = false;
Error = LOCTEXT("InvalidParentCollectionContainer", "A collection cannot be parented to a different collection container");
}
if (!bIsValidDrag)
{
DragDropOp->SetToolTip(Error, FAppStyle::GetBrush(TEXT("Graph.ConnectorFeedback.Error")));
break;
}
}
// If we are dragging over a child collection item, then this view as a whole should not be marked as dragged over
bDraggedOver = false;
}
else if (Operation->IsOfType<FAssetDragDropOp>())
{
TSharedPtr<FAssetDragDropOp> DragDropOp = StaticCastSharedPtr<FAssetDragDropOp>(Operation);
OutIsKnownDragOperation = true;
bIsValidDrag = DragDropOp->HasAssets();
if (!bIsValidDrag)
{
DragDropOp->SetToolTip(LOCTEXT("CollectionViewItem_DragDrop_NoAsset", "There is no asset being dragged"), FAppStyle::GetBrush(TEXT("Graph.ConnectorFeedback.Error")));
}
else
{
const int32 NumDraggedItems = DragDropOp->GetAssets().Num();
const FText FirstItemText = FText::FromName(DragDropOp->GetAssets()[0].AssetName);
const FText AddToCollectionText = (NumDraggedItems > 1)
? FText::Format(LOCTEXT("CollectionViewItem_DragDrop_MultipleItems", "Add '{0}' and {1} {1}|plural(one=other,other=others)"), FirstItemText, NumDraggedItems - 1)
: FText::Format(LOCTEXT("CollectionViewItem_DragDrop_SingularItems", "Add '{0}'"), FirstItemText);
DragDropOp->SetToolTip(AddToCollectionText, FAppStyle::GetBrush(TEXT("Graph.ConnectorFeedback.OK")));
}
}
// Set the default slashed circle if this drag is invalid and a drag operation hasn't set NewDragCursor to something custom
if (!bIsValidDrag && !NewDragCursor.IsSet())
{
NewDragCursor = EMouseCursor::SlashedCircle;
}
Operation->SetCursorOverride(NewDragCursor);
return bIsValidDrag;
}
FReply SCollectionView::HandleDragDropOnCollectionItem(TSharedRef<FCollectionItem> CollectionItem, const FGeometry& Geometry, const FDragDropEvent& DragDropEvent)
{
// Should have already called ValidateDragDropOnCollectionItem prior to calling this...
TSharedPtr<FDragDropOperation> Operation = DragDropEvent.GetOperation();
check(Operation.IsValid());
if (Operation->IsOfType<FCollectionDragDropOp>())
{
TSharedPtr<FCollectionDragDropOp> DragDropOp = StaticCastSharedPtr<FCollectionDragDropOp>(Operation);
// Make sure our drop item is marked as expanded so that we'll be able to see the newly added children
CollectionTreePtr->SetItemExpansion(CollectionItem, true);
// Reparent all of the collections in the drag drop so that they are our immediate children
for (const FCollectionRef& NewChildCollection : DragDropOp->CollectionRefs)
{
check(CollectionItem->CollectionContainer == NewChildCollection.Container);
FText Error;
if (!CollectionItem->CollectionContainer->ReparentCollection(
NewChildCollection.Name, NewChildCollection.Type,
CollectionItem->CollectionName, CollectionItem->CollectionType, &Error
))
{
ContentBrowserUtils::DisplayMessage(Error, Geometry.GetLayoutBoundingRect(), SharedThis(this), ContentBrowserUtils::EDisplayMessageType::Error);
}
}
return FReply::Handled();
}
else if (Operation->IsOfType<FAssetDragDropOp>())
{
TSharedPtr<FAssetDragDropOp> DragDropOp = StaticCastSharedPtr<FAssetDragDropOp>(Operation);
const TArray<FAssetData>& DroppedAssets = DragDropOp->GetAssets();
TArray<FSoftObjectPath> ObjectPaths;
ObjectPaths.Reserve(DroppedAssets.Num());
for (const FAssetData& AssetData : DroppedAssets)
{
ObjectPaths.Add(AssetData.GetSoftObjectPath());
}
const double BeginTimeSec = FPlatformTime::Seconds();
int32 NumAdded = 0;
FText Message;
ContentBrowserUtils::EDisplayMessageType MessageType = ContentBrowserUtils::EDisplayMessageType::Info;
if (CollectionItem->CollectionContainer->AddToCollection(
CollectionItem->CollectionName, CollectionItem->CollectionType, ObjectPaths, &NumAdded, &Message))
{
if (UE::Editor::ContentBrowser::IsNewStyleEnabled())
{
Message = FText::Format(LOCTEXT("AddingToCollection", "{0} {0}|plural(one=item,other=items) added to '{1}'"), NumAdded, FText::FromName(CollectionItem->CollectionName));
MessageType = ContentBrowserUtils::EDisplayMessageType::Successful;
}
else
{
if (DroppedAssets.Num() == 1)
{
FFormatNamedArguments Args;
Args.Add(TEXT("AssetName"), FText::FromName(DroppedAssets[0].AssetName));
Args.Add(TEXT("CollectionName"), FText::FromName(CollectionItem->CollectionName));
Message = FText::Format(LOCTEXT("CollectionAssetAdded", "Added {AssetName} to {CollectionName}"), Args);
}
else
{
FFormatNamedArguments Args;
Args.Add(TEXT("Number"), NumAdded);
Args.Add(TEXT("CollectionName"), FText::FromName(CollectionItem->CollectionName));
Message = FText::Format(LOCTEXT("CollectionAssetsAdded", "Added {Number} asset(s) to {CollectionName}"), Args);
}
MessageType = ContentBrowserUtils::EDisplayMessageType::Info;
}
const double DurationSec = FPlatformTime::Seconds() - BeginTimeSec;
{
FAssetAddedToCollectionTelemetryEvent AssetAdded;
AssetAdded.DurationSec = DurationSec;
AssetAdded.NumAdded = NumAdded;
AssetAdded.CollectionShareType = CollectionItem->CollectionType;
AssetAdded.Workflow = ECollectionTelemetryAssetAddedWorkflow::DragAndDrop;
FTelemetryRouter::Get().ProvideTelemetry(AssetAdded);
}
}
// Added items to the collection or failed. Either way, display the message.
ContentBrowserUtils::DisplayMessage(Message, Geometry.GetLayoutBoundingRect(), SharedThis(this), MessageType);
return FReply::Handled();
}
return FReply::Unhandled();
}
void SCollectionView::HandleSettingChanged(FName PropertyName)
{
if (PropertyName == GET_MEMBER_NAME_CHECKED(UContentBrowserSettings, bDisplayExcludedCollections))
{
UpdateFilteredCollectionItems();
}
}
void SCollectionView::ExpandParentItems(const TSharedRef<FCollectionItem>& InCollectionItem)
{
for (TSharedPtr<FCollectionItem> CollectionItemToExpand = InCollectionItem->ParentCollection.Pin();
CollectionItemToExpand.IsValid();
CollectionItemToExpand = CollectionItemToExpand->ParentCollection.Pin()
)
{
CollectionTreePtr->SetItemExpansion(CollectionItemToExpand, true);
}
}
TSharedPtr<SWidget> SCollectionView::MakeCollectionTreeContextMenu()
{
if ( !bAllowRightClickMenu )
{
return NULL;
}
return CollectionContextMenu->MakeCollectionTreeContextMenu(Commands);
}
bool SCollectionView::IsCollectionCheckBoxEnabled( TSharedPtr<FCollectionItem> CollectionItem ) const
{
return QuickAssetManagement.IsValid() && QuickAssetManagement->IsCollectionEnabled(FCollectionNameType(CollectionItem->CollectionName, CollectionItem->CollectionType));
}
ECheckBoxState SCollectionView::IsCollectionChecked( TSharedPtr<FCollectionItem> CollectionItem ) const
{
if ( QuickAssetManagement.IsValid() )
{
return QuickAssetManagement->GetCollectionCheckState(FCollectionNameType(CollectionItem->CollectionName, CollectionItem->CollectionType));
}
return ECheckBoxState::Unchecked;
}
void SCollectionView::OnCollectionCheckStateChanged( ECheckBoxState NewState, TSharedPtr<FCollectionItem> CollectionItem )
{
if ( QuickAssetManagement.IsValid() )
{
FCollectionNameType CollectionKey(CollectionItem->CollectionName, CollectionItem->CollectionType);
if (QuickAssetManagement->GetCollectionCheckState(CollectionKey) == ECheckBoxState::Checked)
{
QuickAssetManagement->RemoveCurrentAssetsFromCollection(CollectionKey);
}
else
{
QuickAssetManagement->AddCurrentAssetsToCollection(CollectionKey);
}
}
}
void SCollectionView::CollectionSelectionChanged( TSharedPtr< FCollectionItem > CollectionItem, ESelectInfo::Type /*SelectInfo*/ )
{
if ( ShouldAllowSelectionChangedDelegate() && OnCollectionSelected.IsBound() )
{
if ( CollectionItem.IsValid() )
{
OnCollectionSelected.Execute(FCollectionNameType(CollectionItem->CollectionName, CollectionItem->CollectionType));
}
else
{
OnCollectionSelected.Execute(FCollectionNameType(NAME_None, ECollectionShareType::CST_All));
}
}
}
void SCollectionView::CollectionItemScrolledIntoView( TSharedPtr<FCollectionItem> CollectionItem, const TSharedPtr<ITableRow>& Widget )
{
if ( CollectionItem->bRenaming && Widget.IsValid() && Widget->GetContent().IsValid() )
{
CollectionItem->OnRenamedRequestEvent.Broadcast();
}
}
bool SCollectionView::IsCollectionNameReadOnly() const
{
// We can't rename collections while they're being dragged
TSharedPtr<FCollectionDragDropOp> DragDropOp = CurrentCollectionDragDropOp.Pin();
if (DragDropOp.IsValid())
{
TArray<TSharedPtr<FCollectionItem>> SelectedCollectionItems = CollectionTreePtr->GetSelectedItems();
for (const auto& SelectedCollectionItem : SelectedCollectionItems)
{
if (DragDropOp->CollectionRefs.ContainsByPredicate([&SelectedCollectionItem](const FCollectionRef& Collection)
{
return SelectedCollectionItem->CollectionContainer == Collection.Container &&
SelectedCollectionItem->CollectionName == Collection.Name &&
SelectedCollectionItem->CollectionType == Collection.Type;
}))
{
return true;
}
}
}
CollectionContextMenu->UpdateProjectSourceControl();
return !CollectionContextMenu->CanRenameSelectedCollections();
}
bool SCollectionView::CollectionNameChangeCommit( const TSharedPtr< FCollectionItem >& CollectionItem, const FString& NewName, bool bChangeConfirmed, FText& OutWarningMessage )
{
if (!ensure(CollectionItem->CollectionContainer))
{
return false;
}
// If new name is empty, set it back to the original name
const FName NewNameFinal( NewName.IsEmpty() ? CollectionItem->CollectionName : FName(*NewName) );
if ( CollectionItem->bNewCollection )
{
CollectionItem->bNewCollection = false;
// Cache this here as CreateCollection will invalidate the current parent pointer
TOptional<FCollectionNameType> NewCollectionParentKey;
TSharedPtr<FCollectionItem> ParentCollectionItem = CollectionItem->ParentCollection.Pin();
if ( ParentCollectionItem.IsValid() )
{
NewCollectionParentKey = FCollectionNameType(ParentCollectionItem->CollectionName, ParentCollectionItem->CollectionType);
}
double BeginTimeSec = FPlatformTime::Seconds();
// If we canceled the name change when creating a new asset, we want to silently remove it
if ( !bChangeConfirmed )
{
AvailableCollections.Remove(FCollectionNameType(CollectionItem->CollectionName, CollectionItem->CollectionType));
UpdateFilteredCollectionItems();
return false;
}
FText Error;
if ( !CollectionItem->CollectionContainer->CreateCollection(NewNameFinal, CollectionItem->CollectionType, CollectionItem->StorageMode, &Error) )
{
// Failed to add the collection, remove it from the list
AvailableCollections.Remove(FCollectionNameType(CollectionItem->CollectionName, CollectionItem->CollectionType));
UpdateFilteredCollectionItems();
OutWarningMessage = FText::Format( LOCTEXT("CreateCollectionFailed", "Failed to create the collection. {0}"), Error);
return false;
}
// Since we're really adding a new collection (as our placeholder item is currently transient), we don't get a rename event from the collections manager
// We'll spoof one here that so that our placeholder tree item is updated with the final name - this will preserve its expansion and selection state
HandleCollectionRenamed(
*CollectionItem->CollectionContainer,
FCollectionNameType(CollectionItem->CollectionName, CollectionItem->CollectionType),
FCollectionNameType(NewNameFinal, CollectionItem->CollectionType)
);
if ( NewCollectionParentKey.IsSet() )
{
// Try and set the parent correctly (if this fails for any reason, the collection will still be added, but will just appear at the root)
CollectionItem->CollectionContainer->ReparentCollection(NewNameFinal, CollectionItem->CollectionType, NewCollectionParentKey->Name, NewCollectionParentKey->Type);
}
// Notify anything that cares that this collection has been created now
if ( CollectionItem->OnCollectionCreatedEvent.IsBound())
{
CollectionItem->OnCollectionCreatedEvent.Execute(FCollectionNameType(NewNameFinal, CollectionItem->CollectionType));
CollectionItem->OnCollectionCreatedEvent.Unbind();
}
{
FCollectionCreatedTelemetryEvent CollectionCreatedEvent;
CollectionCreatedEvent.DurationSec = FPlatformTime::Seconds() - BeginTimeSec;
CollectionCreatedEvent.CollectionShareType = CollectionItem->CollectionType;
FTelemetryRouter::Get().ProvideTelemetry(CollectionCreatedEvent);
}
}
else
{
// If the old name is the same as the new name, just early exit here.
if ( CollectionItem->CollectionName == NewNameFinal )
{
return true;
}
// If the new name doesn't pass our current filter, we need to clear it
if ( !CollectionItemTextFilter->PassesFilter( FCollectionItem(CollectionItem->CollectionContainer.ToSharedRef(), NewNameFinal, CollectionItem->CollectionType) ) )
{
SearchPtr->ClearSearch();
}
// Otherwise perform the rename
FText Error;
if ( !CollectionItem->CollectionContainer->RenameCollection(CollectionItem->CollectionName, CollectionItem->CollectionType, NewNameFinal, CollectionItem->CollectionType, &Error) )
{
// Failed to rename the collection
OutWarningMessage = FText::Format( LOCTEXT("RenameCollectionFailed", "Failed to rename the collection. {0}"), Error);
return false;
}
}
// At this point CollectionItem is no longer a member of the CollectionItems list (as the list is repopulated by
// UpdateCollectionItems, which is called by a broadcast from CollectionManagerModule::RenameCollection, above).
// So search again for the item by name and type.
auto NewCollectionItemPtr = AvailableCollections.Find( FCollectionNameType(NewNameFinal, CollectionItem->CollectionType) );
// Reselect the path to notify that the selection has changed
{
FScopedPreventSelectionChangedDelegate DelegatePrevention( SharedThis(this) );
CollectionTreePtr->ClearSelection();
}
// Set the selection
if (NewCollectionItemPtr)
{
const auto& NewCollectionItem = *NewCollectionItemPtr;
CollectionTreePtr->RequestScrollIntoView(NewCollectionItem);
CollectionTreePtr->SetItemSelection(NewCollectionItem, true);
}
return true;
}
bool SCollectionView::CollectionVerifyRenameCommit(const TSharedPtr< FCollectionItem >& CollectionItem, const FString& NewName, const FSlateRect& MessageAnchor, FText& OutErrorMessage)
{
// If the new name is the same as the old name, consider this to be unchanged, and accept it.
if (CollectionItem->CollectionName.ToString() == NewName)
{
return true;
}
if (!ensure(CollectionItem->CollectionContainer) || !CollectionItem->CollectionContainer->IsValidCollectionName(NewName, ECollectionShareType::CST_All, &OutErrorMessage))
{
return false;
}
return true;
}
#undef LOCTEXT_NAMESPACE
Reference in New Issue View Git Blame Copy Permalink