You've already forked UnrealEngineUWP
mirror of
https://github.com/izzy2lost/UnrealEngineUWP.git
synced 2026-03-26 18:15:20 -07:00
621 lines
22 KiB
C++
621 lines
22 KiB
C++
// Copyright 1998-2015 Epic Games, Inc. All Rights Reserved.
|
|
|
|
#include "ContentBrowserPCH.h"
|
|
|
|
#include "CollectionViewTypes.h"
|
|
#include "CollectionContextMenu.h"
|
|
#include "ObjectTools.h"
|
|
#include "SourcesViewWidgets.h"
|
|
#include "ContentBrowserModule.h"
|
|
#include "SExpandableArea.h"
|
|
|
|
#define LOCTEXT_NAMESPACE "ContentBrowser"
|
|
|
|
void SCollectionView::Construct( const FArguments& InArgs )
|
|
{
|
|
OnCollectionSelected = InArgs._OnCollectionSelected;
|
|
bAllowCollectionButtons = InArgs._AllowCollectionButtons;
|
|
bAllowRightClickMenu = InArgs._AllowRightClickMenu;
|
|
|
|
FCollectionManagerModule& CollectionManagerModule = FModuleManager::LoadModuleChecked<FCollectionManagerModule>(TEXT("CollectionManager"));
|
|
CollectionManagerModule.Get().OnCollectionCreated().AddSP( this, &SCollectionView::HandleCollectionCreated );
|
|
CollectionManagerModule.Get().OnCollectionRenamed().AddSP( this, &SCollectionView::HandleCollectionRenamed );
|
|
CollectionManagerModule.Get().OnCollectionDestroyed().AddSP( this, &SCollectionView::HandleCollectionDestroyed );
|
|
|
|
Commands = TSharedPtr< FUICommandList >(new FUICommandList);
|
|
CollectionContextMenu = MakeShareable(new FCollectionContextMenu( SharedThis(this) ));
|
|
CollectionContextMenu->BindCommands(Commands);
|
|
|
|
FOnContextMenuOpening CollectionListContextMenuOpening;
|
|
if ( InArgs._AllowContextMenu )
|
|
{
|
|
CollectionListContextMenuOpening = FOnContextMenuOpening::CreateSP( this, &SCollectionView::MakeCollectionListContextMenu );
|
|
}
|
|
|
|
PreventSelectionChangedDelegateCount = 0;
|
|
|
|
TSharedRef< SWidget > HeaderContent = SNew(SHorizontalBox)
|
|
+SHorizontalBox::Slot()
|
|
.VAlign(VAlign_Center)
|
|
.FillWidth(1.f)
|
|
[
|
|
SNew(STextBlock)
|
|
.Font( FEditorStyle::GetFontStyle("ContentBrowser.SourceTitleFont") )
|
|
.Text( LOCTEXT("CollectionsListTitle", "Collections") )
|
|
]
|
|
|
|
+SHorizontalBox::Slot()
|
|
.AutoWidth()
|
|
.VAlign(VAlign_Bottom)
|
|
[
|
|
SNew(SButton)
|
|
.ToolTipText(LOCTEXT("AddCollectionButtonTooltip", "Add a collection."))
|
|
.OnClicked(this, &SCollectionView::MakeAddCollectionMenu)
|
|
.ContentPadding(0)
|
|
.Visibility(this, &SCollectionView::GetAddCollectionButtonVisibility)
|
|
[
|
|
SNew(SImage) .Image( FEditorStyle::GetBrush("ContentBrowser.AddCollectionButtonIcon") )
|
|
]
|
|
];
|
|
|
|
TSharedRef< SWidget > BodyContent = SNew(SVerticalBox)
|
|
// Separator
|
|
+SVerticalBox::Slot()
|
|
.AutoHeight()
|
|
[
|
|
SNew(SSeparator)
|
|
]
|
|
|
|
// Collections list
|
|
+SVerticalBox::Slot()
|
|
.FillHeight(1.f)
|
|
[
|
|
SAssignNew(CollectionListPtr, SListView< TSharedPtr<FCollectionItem> >)
|
|
.ListItemsSource(&CollectionItems)
|
|
.OnGenerateRow( this, &SCollectionView::GenerateCollectionRow )
|
|
.ItemHeight(18)
|
|
.SelectionMode(ESelectionMode::Multi)
|
|
.OnSelectionChanged(this, &SCollectionView::CollectionSelectionChanged)
|
|
.OnContextMenuOpening( CollectionListContextMenuOpening )
|
|
.OnItemScrolledIntoView(this, &SCollectionView::CollectionItemScrolledIntoView)
|
|
.ClearSelectionOnClick(false)
|
|
.Visibility(this, &SCollectionView::GetCollectionListVisibility)
|
|
];
|
|
|
|
TSharedPtr< SWidget > Content;
|
|
if ( InArgs._AllowCollapsing )
|
|
{
|
|
Content = SAssignNew(CollectionsExpandableAreaPtr, SExpandableArea)
|
|
.MaxHeight(200)
|
|
.BorderImage( FEditorStyle::GetBrush("NoBorder") )
|
|
.HeaderContent()
|
|
[
|
|
HeaderContent
|
|
]
|
|
.BodyContent()
|
|
[
|
|
BodyContent
|
|
];
|
|
}
|
|
else
|
|
{
|
|
Content = SNew( SVerticalBox )
|
|
+SVerticalBox::Slot()
|
|
.AutoHeight()
|
|
[
|
|
HeaderContent
|
|
]
|
|
|
|
+SVerticalBox::Slot()
|
|
.AutoHeight()
|
|
[
|
|
BodyContent
|
|
];
|
|
}
|
|
|
|
ChildSlot
|
|
[
|
|
Content.ToSharedRef()
|
|
];
|
|
|
|
UpdateCollectionItems();
|
|
}
|
|
|
|
void SCollectionView::HandleCollectionCreated( const FCollectionNameType& Collection )
|
|
{
|
|
UpdateCollectionItems();
|
|
CollectionListPtr->RequestListRefresh();
|
|
}
|
|
|
|
void SCollectionView::HandleCollectionRenamed( const FCollectionNameType& OriginalCollection, const FCollectionNameType& NewCollection )
|
|
{
|
|
UpdateCollectionItems();
|
|
CollectionListPtr->RequestListRefresh();
|
|
}
|
|
|
|
void SCollectionView::HandleCollectionDestroyed( const FCollectionNameType& Collection )
|
|
{
|
|
UpdateCollectionItems();
|
|
CollectionListPtr->RequestListRefresh();
|
|
}
|
|
|
|
void SCollectionView::UpdateCollectionItems()
|
|
{
|
|
CollectionItems.Empty();
|
|
|
|
// Load the collection manager module
|
|
FCollectionManagerModule& CollectionManagerModule = FModuleManager::LoadModuleChecked<FCollectionManagerModule>(TEXT("CollectionManager"));
|
|
|
|
// Get collections of all types
|
|
for (int32 TypeIdx = 0; TypeIdx < ECollectionShareType::CST_All; ++TypeIdx)
|
|
{
|
|
ECollectionShareType::Type CollectionType = ECollectionShareType::Type(TypeIdx);
|
|
|
|
//Never display system collections
|
|
if ( CollectionType == ECollectionShareType::CST_System )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
TArray<FName> CollectionNames;
|
|
CollectionManagerModule.Get().GetCollectionNames(CollectionType, CollectionNames);
|
|
|
|
for (int32 CollectionIdx = 0; CollectionIdx < CollectionNames.Num(); ++CollectionIdx)
|
|
{
|
|
const FName& CollectionName = CollectionNames[CollectionIdx];
|
|
CollectionItems.Add( MakeShareable(new FCollectionItem(CollectionName.ToString(), CollectionType)) );
|
|
}
|
|
}
|
|
|
|
CollectionItems.Sort( FCollectionItem::FCompareFCollectionItemByName() );
|
|
}
|
|
|
|
void SCollectionView::SetSelectedCollections(const TArray<FCollectionNameType>& CollectionsToSelect)
|
|
{
|
|
// Prevent the selection changed delegate since the invoking code requested it
|
|
FScopedPreventSelectionChangedDelegate DelegatePrevention( SharedThis(this) );
|
|
|
|
// Expand the collections area if we are indeed selecting at least one collection
|
|
if ( CollectionsToSelect.Num() > 0 && CollectionsExpandableAreaPtr.IsValid() )
|
|
{
|
|
CollectionsExpandableAreaPtr->SetExpanded(true);
|
|
}
|
|
|
|
// Clear the selection to start, then add the selected paths as they are found
|
|
CollectionListPtr->ClearSelection();
|
|
|
|
for ( auto CollectionIt = CollectionItems.CreateConstIterator(); CollectionIt; ++CollectionIt )
|
|
{
|
|
const TSharedPtr<FCollectionItem>& Item = *CollectionIt;
|
|
for ( auto SelectionIt = CollectionsToSelect.CreateConstIterator(); SelectionIt; ++SelectionIt )
|
|
{
|
|
const FCollectionNameType& Selection = *SelectionIt;
|
|
if ( Item->CollectionName == Selection.Name.ToString() && Item->CollectionType == Selection.Type )
|
|
{
|
|
CollectionListPtr->SetItemSelection(Item, true);
|
|
CollectionListPtr->RequestScrollIntoView(Item);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
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
|
|
CollectionListPtr->ClearSelection();
|
|
}
|
|
|
|
TArray<FCollectionNameType> SCollectionView::GetSelectedCollections() const
|
|
{
|
|
TArray<FCollectionNameType> RetArray;
|
|
|
|
TArray<TSharedPtr<FCollectionItem>> Items = CollectionListPtr->GetSelectedItems();
|
|
for ( int32 ItemIdx = 0; ItemIdx < Items.Num(); ++ItemIdx )
|
|
{
|
|
const TSharedPtr<FCollectionItem>& Item = Items[ItemIdx];
|
|
new(RetArray) FCollectionNameType(FName(*Item->CollectionName), Item->CollectionType);
|
|
}
|
|
|
|
return RetArray;
|
|
}
|
|
|
|
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) );
|
|
|
|
CollectionListPtr->ClearSelection();
|
|
for ( auto HistoryIt = History.SourcesData.Collections.CreateConstIterator(); HistoryIt; ++HistoryIt)
|
|
{
|
|
FString Name = (*HistoryIt).Name.ToString();
|
|
ECollectionShareType::Type Type = (*HistoryIt).Type;
|
|
for ( auto CollectionIt = CollectionItems.CreateConstIterator(); CollectionIt; ++CollectionIt)
|
|
{
|
|
if ( (*CollectionIt)->CollectionName == Name && (*CollectionIt)->CollectionType == Type )
|
|
{
|
|
CollectionListPtr->SetItemSelection(*CollectionIt, true);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void SCollectionView::SaveSettings(const FString& IniFilename, const FString& IniSection, const FString& SettingsString) const
|
|
{
|
|
FString SelectedCollectionsString;
|
|
TArray< TSharedPtr<FCollectionItem> > CollectionSelectedItems = CollectionListPtr->GetSelectedItems();
|
|
for ( auto CollectionIt = CollectionSelectedItems.CreateConstIterator(); CollectionIt; ++CollectionIt )
|
|
{
|
|
if ( SelectedCollectionsString.Len() > 0 )
|
|
{
|
|
SelectedCollectionsString += TEXT(",");
|
|
}
|
|
|
|
const TSharedPtr<FCollectionItem>& Collection = *CollectionIt;
|
|
SelectedCollectionsString += Collection->CollectionName + TEXT("?") + FString::FromInt(Collection->CollectionType);
|
|
}
|
|
const bool IsCollectionsExpanded = CollectionsExpandableAreaPtr.IsValid() ? CollectionsExpandableAreaPtr->IsExpanded() : true;
|
|
GConfig->SetBool(*IniSection, *(SettingsString + TEXT(".CollectionsExpanded")), IsCollectionsExpanded, IniFilename);
|
|
GConfig->SetString(*IniSection, *(SettingsString + TEXT(".SelectedCollections")), *SelectedCollectionsString, IniFilename);
|
|
}
|
|
|
|
void SCollectionView::LoadSettings(const FString& IniFilename, const FString& IniSection, const FString& SettingsString)
|
|
{
|
|
// Collection expansion state
|
|
bool bCollectionsExpanded = false;
|
|
if ( CollectionsExpandableAreaPtr.IsValid() && GConfig->GetBool(*IniSection, *(SettingsString + TEXT(".CollectionsExpanded")), bCollectionsExpanded, IniFilename) )
|
|
{
|
|
CollectionsExpandableAreaPtr->SetExpanded(bCollectionsExpanded);
|
|
}
|
|
|
|
// Selected Collections
|
|
FString SelectedCollectionsString;
|
|
TArray<FCollectionNameType> NewSelectedCollections;
|
|
if ( GConfig->GetString(*IniSection, *(SettingsString + TEXT(".SelectedCollections")), SelectedCollectionsString, IniFilename) )
|
|
{
|
|
TArray<FString> NewSelectedCollectionStrings;
|
|
SelectedCollectionsString.ParseIntoArray(NewSelectedCollectionStrings, TEXT(","), /*bCullEmpty*/true);
|
|
|
|
for ( auto CollectionIt = NewSelectedCollectionStrings.CreateConstIterator(); CollectionIt; ++CollectionIt )
|
|
{
|
|
FString CollectionName;
|
|
FString CollectionTypeString;
|
|
if ( (*CollectionIt).Split(TEXT("?"), &CollectionName, &CollectionTypeString) )
|
|
{
|
|
int32 CollectionType = FCString::Atoi(*CollectionTypeString);
|
|
|
|
if ( CollectionType >= 0 && CollectionType < ECollectionShareType::CST_All )
|
|
{
|
|
new(NewSelectedCollections) FCollectionNameType(FName(*CollectionName), ECollectionShareType::Type(CollectionType) );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( NewSelectedCollections.Num() > 0 )
|
|
{
|
|
// Select the collections
|
|
SetSelectedCollections(NewSelectedCollections);
|
|
CollectionSelectionChanged( TSharedPtr<FCollectionItem>(), ESelectInfo::Direct );
|
|
}
|
|
}
|
|
|
|
FReply SCollectionView::OnKeyDown( const FGeometry& MyGeometry, const FKeyEvent& InKeyEvent )
|
|
{
|
|
if( Commands->ProcessCommandBindings( InKeyEvent ) )
|
|
{
|
|
return FReply::Handled();
|
|
}
|
|
return FReply::Unhandled();
|
|
}
|
|
|
|
bool SCollectionView::ShouldAllowSelectionChangedDelegate() const
|
|
{
|
|
return PreventSelectionChangedDelegateCount == 0;
|
|
}
|
|
|
|
FReply SCollectionView::MakeAddCollectionMenu()
|
|
{
|
|
// 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);
|
|
|
|
FSlateApplication::Get().PushMenu(
|
|
AsShared(),
|
|
MenuBuilder.MakeWidget(),
|
|
FSlateApplication::Get().GetCursorPos(),
|
|
FPopupTransitionEffect( FPopupTransitionEffect::TopMenu )
|
|
);
|
|
|
|
return FReply::Handled();
|
|
}
|
|
|
|
EVisibility SCollectionView::GetAddCollectionButtonVisibility() const
|
|
{
|
|
return (bAllowCollectionButtons && ( !CollectionsExpandableAreaPtr.IsValid() || CollectionsExpandableAreaPtr->IsExpanded() ) ) ? EVisibility::Visible : EVisibility::Collapsed;
|
|
}
|
|
|
|
void SCollectionView::CreateCollectionItem( ECollectionShareType::Type CollectionType )
|
|
{
|
|
if ( ensure(CollectionType != ECollectionShareType::CST_All) )
|
|
{
|
|
FCollectionManagerModule& CollectionManagerModule = FModuleManager::Get().LoadModuleChecked<FCollectionManagerModule>("CollectionManager");
|
|
|
|
const FName BaseCollectionName = *LOCTEXT("NewCollectionName", "NewCollection").ToString();
|
|
FName CollectionName;
|
|
CollectionManagerModule.Get().CreateUniqueCollectionName(BaseCollectionName, CollectionType, CollectionName);
|
|
TSharedPtr<FCollectionItem> NewItem = MakeShareable(new FCollectionItem(CollectionName.ToString(), CollectionType));
|
|
|
|
// 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;
|
|
|
|
CollectionItems.Add( NewItem );
|
|
CollectionItems.Sort( FCollectionItem::FCompareFCollectionItemByName() );
|
|
CollectionListPtr->RequestScrollIntoView(NewItem);
|
|
CollectionListPtr->SetSelection( NewItem );
|
|
}
|
|
}
|
|
|
|
void SCollectionView::RenameCollectionItem( const TSharedPtr<FCollectionItem>& ItemToRename )
|
|
{
|
|
if ( ensure(ItemToRename.IsValid()) )
|
|
{
|
|
ItemToRename->bRenaming = true;
|
|
CollectionListPtr->RequestScrollIntoView(ItemToRename);
|
|
}
|
|
}
|
|
|
|
void SCollectionView::RemoveCollectionItems( const TArray<TSharedPtr<FCollectionItem>>& ItemsToRemove )
|
|
{
|
|
TArray<TSharedPtr<FCollectionItem>> SelectedItems = CollectionListPtr->GetSelectedItems();
|
|
|
|
// Remove all the items, while keeping track of the number of selected items that were removed.
|
|
int32 LastSelectedItemIdx = INDEX_NONE;
|
|
int32 NumSelectedItemsRemoved = 0;
|
|
for (int32 RemoveIdx = 0; RemoveIdx < ItemsToRemove.Num(); ++RemoveIdx)
|
|
{
|
|
const TSharedPtr<FCollectionItem>& ItemToRemove = ItemsToRemove[RemoveIdx];
|
|
|
|
int32 ItemIdx = INDEX_NONE;
|
|
if ( CollectionItems.Find(ItemToRemove, ItemIdx) )
|
|
{
|
|
if ( SelectedItems.Contains(ItemToRemove) )
|
|
{
|
|
NumSelectedItemsRemoved++;
|
|
LastSelectedItemIdx = ItemIdx;
|
|
}
|
|
|
|
CollectionItems.RemoveAt(ItemIdx);
|
|
}
|
|
}
|
|
|
|
FScopedPreventSelectionChangedDelegate DelegatePrevention(SharedThis(this));
|
|
CollectionListPtr->ClearSelection();
|
|
|
|
// If we removed all the selected items and there is at least one other item, select it
|
|
if ( LastSelectedItemIdx > INDEX_NONE && NumSelectedItemsRemoved > 0 && NumSelectedItemsRemoved >= SelectedItems.Num() && CollectionItems.Num() > 1 )
|
|
{
|
|
// The last selected item idx will refer to the next item in the list now that it has been removed.
|
|
// If the removed item was the last item in the list, select the new last item
|
|
const int32 NewSelectedItemIdx = FMath::Min(LastSelectedItemIdx, CollectionItems.Num() - 1);
|
|
|
|
CollectionListPtr->SetSelection(CollectionItems[NewSelectedItemIdx]);
|
|
}
|
|
|
|
// Refresh the list
|
|
CollectionListPtr->RequestListRefresh();
|
|
}
|
|
|
|
EVisibility SCollectionView::GetCollectionListVisibility() const
|
|
{
|
|
return CollectionItems.Num() > 0 ? EVisibility::Visible : EVisibility::Collapsed;
|
|
}
|
|
|
|
TSharedRef<ITableRow> SCollectionView::GenerateCollectionRow( TSharedPtr<FCollectionItem> CollectionItem, const TSharedRef<STableViewBase>& OwnerTable )
|
|
{
|
|
check(CollectionItem.IsValid());
|
|
|
|
TSharedPtr< STableRow< TSharedPtr<FTreeItem> > > TableRow = SNew( STableRow< TSharedPtr<FTreeItem> >, OwnerTable );
|
|
TableRow->SetContent
|
|
(
|
|
SNew(SCollectionListItem)
|
|
.ParentWidget(SharedThis(this))
|
|
.CollectionItem(CollectionItem)
|
|
.OnNameChangeCommit(this, &SCollectionView::CollectionNameChangeCommit)
|
|
.OnVerifyRenameCommit(this, &SCollectionView::CollectionVerifyRenameCommit)
|
|
.OnAssetsDragDropped(this, &SCollectionView::CollectionAssetsDropped)
|
|
.IsSelected( TableRow.Get(), &STableRow< TSharedPtr<FTreeItem> >::IsSelectedExclusively )
|
|
.IsReadOnly(this, &SCollectionView::IsCollectionNotRenamable)
|
|
);
|
|
|
|
return TableRow.ToSharedRef();
|
|
}
|
|
|
|
TSharedPtr<SWidget> SCollectionView::MakeCollectionListContextMenu()
|
|
{
|
|
if ( !bAllowRightClickMenu )
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
return CollectionContextMenu->MakeCollectionListContextMenu(Commands);
|
|
}
|
|
|
|
void SCollectionView::CollectionSelectionChanged( TSharedPtr< FCollectionItem > CollectionItem, ESelectInfo::Type /*SelectInfo*/ )
|
|
{
|
|
if ( ShouldAllowSelectionChangedDelegate() && OnCollectionSelected.IsBound() )
|
|
{
|
|
if ( CollectionItem.IsValid() )
|
|
{
|
|
OnCollectionSelected.Execute(FCollectionNameType(FName(*CollectionItem->CollectionName), CollectionItem->CollectionType));
|
|
}
|
|
else
|
|
{
|
|
OnCollectionSelected.Execute(FCollectionNameType(NAME_None, ECollectionShareType::CST_All));
|
|
}
|
|
}
|
|
}
|
|
|
|
void SCollectionView::CollectionAssetsDropped(const TArray<FAssetData>& AssetList, const TSharedPtr<FCollectionItem>& CollectionItem, FText& OutMessage)
|
|
{
|
|
TArray<FName> ObjectPaths;
|
|
|
|
for ( auto AssetIt = AssetList.CreateConstIterator(); AssetIt; ++AssetIt )
|
|
{
|
|
ObjectPaths.Add((*AssetIt).ObjectPath);
|
|
}
|
|
|
|
FCollectionManagerModule& CollectionManagerModule = FModuleManager::Get().LoadModuleChecked<FCollectionManagerModule>("CollectionManager");
|
|
int32 NumAdded = 0;
|
|
if ( CollectionManagerModule.Get().AddToCollection(FName(*CollectionItem->CollectionName), CollectionItem->CollectionType, ObjectPaths, &NumAdded) )
|
|
{
|
|
FFormatNamedArguments Args;
|
|
Args.Add( TEXT("Number"), NumAdded );
|
|
OutMessage = FText::Format( LOCTEXT("CollectionAssetsAdded", "Added {Number} asset(s)"), Args );
|
|
}
|
|
else
|
|
{
|
|
OutMessage = CollectionManagerModule.Get().GetLastError();
|
|
}
|
|
}
|
|
|
|
void SCollectionView::CollectionItemScrolledIntoView( TSharedPtr<FCollectionItem> CollectionItem, const TSharedPtr<ITableRow>& Widget )
|
|
{
|
|
if ( CollectionItem->bRenaming && Widget.IsValid() && Widget->GetContent().IsValid() )
|
|
{
|
|
CollectionItem->OnRenamedRequestEvent.Broadcast();
|
|
}
|
|
}
|
|
|
|
bool SCollectionView::IsCollectionNotRenamable() const
|
|
{
|
|
CollectionContextMenu->UpdateProjectSourceControl();
|
|
return !CollectionContextMenu->CanRenameSelectedCollections();
|
|
}
|
|
|
|
bool SCollectionView::CollectionNameChangeCommit( const TSharedPtr< FCollectionItem >& CollectionItem, const FString& NewName, bool bChangeConfirmed, FText& OutWarningMessage )
|
|
{
|
|
// There should only ever be one item selected when renaming
|
|
check(CollectionListPtr->GetNumItemsSelected() == 1);
|
|
|
|
FCollectionManagerModule& CollectionManagerModule = FModuleManager::Get().LoadModuleChecked<FCollectionManagerModule>(TEXT("CollectionManager"));
|
|
ECollectionShareType::Type CollectionType = CollectionItem->CollectionType;
|
|
|
|
// If new name is empty, set it back to the original name
|
|
FString NewNameFinal( NewName.IsEmpty() ? CollectionItem->CollectionName : NewName );
|
|
|
|
if ( CollectionItem->bNewCollection )
|
|
{
|
|
CollectionItem->bNewCollection = false;
|
|
|
|
// If we can canceled the name change when creating a new asset, we want to silently remove it
|
|
if ( !bChangeConfirmed )
|
|
{
|
|
CollectionItems.Remove(CollectionItem);
|
|
CollectionListPtr->RequestListRefresh();
|
|
return false;
|
|
}
|
|
|
|
if ( !CollectionManagerModule.Get().CreateCollection(FName(*NewNameFinal), CollectionType) )
|
|
{
|
|
// Failed to add the collection, remove it from the list
|
|
CollectionItems.Remove(CollectionItem);
|
|
CollectionListPtr->RequestListRefresh();
|
|
|
|
OutWarningMessage = FText::Format( LOCTEXT("CreateCollectionFailed", "Failed to create the collection. {0}"), CollectionManagerModule.Get().GetLastError());
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// If the old name is the same as the new name, just early exit here.
|
|
if ( CollectionItem->CollectionName == NewNameFinal )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// Otherwise perform the rename
|
|
if ( !CollectionManagerModule.Get().RenameCollection(FName(*CollectionItem->CollectionName), CollectionType, FName(*NewNameFinal), CollectionType) )
|
|
{
|
|
// Failed to rename the collection
|
|
OutWarningMessage = FText::Format( LOCTEXT("RenameCollectionFailed", "Failed to rename the collection. {0}"), CollectionManagerModule.Get().GetLastError());
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Make sure we are sorted
|
|
CollectionItems.Sort( FCollectionItem::FCompareFCollectionItemByName() );
|
|
|
|
// 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 FindCollectionItemPredicate = [CollectionType, &NewNameFinal] (const TSharedPtr<FCollectionItem>& Item)
|
|
{
|
|
return ( Item->CollectionType == CollectionType &&
|
|
Item->CollectionName == NewNameFinal );
|
|
};
|
|
|
|
auto NewCollectionItemPtr = CollectionItems.FindByPredicate( FindCollectionItemPredicate );
|
|
|
|
// Reselect the path to notify that the selection has changed
|
|
{
|
|
FScopedPreventSelectionChangedDelegate DelegatePrevention( SharedThis(this) );
|
|
CollectionListPtr->ClearSelection();
|
|
}
|
|
|
|
// Set the selection
|
|
if (NewCollectionItemPtr)
|
|
{
|
|
const auto& NewCollectionItem = *NewCollectionItemPtr;
|
|
CollectionListPtr->RequestScrollIntoView(NewCollectionItem);
|
|
CollectionListPtr->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 == NewName)
|
|
{
|
|
return true;
|
|
}
|
|
|
|
FCollectionManagerModule& CollectionManagerModule = FModuleManager::Get().LoadModuleChecked<FCollectionManagerModule>(TEXT("CollectionManager"));
|
|
|
|
if (CollectionManagerModule.Get().CollectionExists(*NewName, ECollectionShareType::CST_All))
|
|
{
|
|
// This collection already exists, inform the user and continue
|
|
OutErrorMessage = FText::Format(LOCTEXT("RenameCollectionAlreadyExists", "A collection already exists with the name '{0}'."), FText::FromString(NewName));
|
|
|
|
// Return false to indicate that the user should enter a new name
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
#undef LOCTEXT_NAMESPACE
|