void FPersonaAssetFamily::RecordAssetOpened(const FAssetData& InAssetData)
{
if (IsAssetCompatible(InAssetData))
{
UClass* Class = InAssetData.GetClass();
if (Class)
{
if (Class->IsChildOf<USkeleton>())
{
Skeleton = Cast<USkeleton>(InAssetData.GetAsset());
}
else if (Class->IsChildOf<UAnimationAsset>())
{
AnimationAsset = Cast<UAnimationAsset>(InAssetData.GetAsset());
}
else if (Class->IsChildOf<USkeletalMesh>())
{
Mesh = Cast<USkeletalMesh>(InAssetData.GetAsset());
}
else if (Class->IsChildOf<UAnimBlueprint>())
{
AnimBlueprint = Cast<UAnimBlueprint>(InAssetData.GetAsset());
}
}
OnAssetOpened.Broadcast(InAssetData.GetAsset());
}
}
void UMatineeTrackAnimControlHelper::OnAddKeyTextEntry(const FAssetData& AssetData, IMatineeBase* Matinee, UInterpTrack* Track)
{
if (EntryMenu.IsValid())
{
EntryMenu.Pin()->Dismiss();
}
UObject* SelectedObject = AssetData.GetAsset();
if (SelectedObject && SelectedObject->IsA(UAnimSequence::StaticClass()))
{
KeyframeAddAnimSequence = CastChecked<UAnimSequence>(AssetData.GetAsset());
Matinee->FinishAddKey(Track, true);
}
}
void SGlobalOpenAssetDialog::OnAssetSelectedFromPicker(const FAssetData& AssetData)
{
if (UObject* ObjectToEdit = AssetData.GetAsset())
{
FAssetEditorManager::Get().OpenEditorForAsset(ObjectToEdit);
}
}
virtual UEdGraphNode* PerformAction(class UEdGraph* ParentGraph, UEdGraphPin* FromPin, const FVector2D Location, bool bSelectNewNode = true) override
{
UAnimGraphNode_SequencePlayer* SpawnedNode = CastChecked<UAnimGraphNode_SequencePlayer>(FEdGraphSchemaAction_K2NewNode::PerformAction(ParentGraph, FromPin, Location, bSelectNewNode));
SpawnedNode->Node.Sequence = Cast<UAnimSequence>(AssetInfo.GetAsset());
return SpawnedNode;
}
void FSlateFontInfoStructCustomization::OnFontChanged(const FAssetData& InAssetData)
{
const UFont* const FontAsset = Cast<const UFont>(InAssetData.GetAsset());
const FName FirstFontName = (FontAsset && FontAsset->CompositeFont.DefaultTypeface.Fonts.Num()) ? FontAsset->CompositeFont.DefaultTypeface.Fonts[0].Name : NAME_None;
TArray<FSlateFontInfo*> SlateFontInfoStructs = GetFontInfoBeingEdited();
for(FSlateFontInfo* FontInfo : SlateFontInfoStructs)
{
// The font has been updated in the editor, so clear the non-UObject pointer so that the two don't conflict
FontInfo->CompositeFont.Reset();
// We've changed (or cleared) the font asset, so make sure and update the typeface entry name being used by the font info
TypefaceFontNameProperty->SetValue(FirstFontName);
}
if(!FontAsset)
{
const FString PropertyPath = FontObjectProperty->GeneratePathToProperty();
TArray<UObject*> PropertyOuterObjects;
FontObjectProperty->GetOuterObjects(PropertyOuterObjects);
for(const UObject* OuterObject : PropertyOuterObjects)
{
UE_LOG(LogSlate, Warning, TEXT("FSlateFontInfo property '%s' on object '%s' was set to use a null UFont. Slate will be forced to use the fallback font path which may be slower."), *PropertyPath, *OuterObject->GetPathName());
}
}
}
//------------------------------------------------------------------------------
bool FBlueprintActionDatabaseRegistrar::IsOpenForRegistration(FAssetData const& AssetKey)
{
UObject const* OwnerKey = GeneratingClass;
if (AssetKey.IsAssetLoaded())
{
OwnerKey = AssetKey.GetAsset();
}
return IsOpenForRegistration(OwnerKey);
}
void UMatineeTrackAnimControlHelper::OnAddKeyTextEntry(const FAssetData& AssetData, IMatineeBase* Matinee, UInterpTrack* Track)
{
if( EntryPopupWindow.IsValid() )
{
EntryPopupWindow.Pin()->RequestDestroyWindow();
}
KeyframeAddAnimSequence = CastChecked<UAnimSequence>(AssetData.GetAsset());
Matinee->FinishAddKey(Track,true);
}
void SSpriteList::OnSpriteDoubleClicked(const FAssetData& AssetData)
{
TSharedPtr<FSpriteEditor> SpriteEditor = SpriteEditorPtr.Pin();
if (SpriteEditor.IsValid())
{
if (UPaperSprite* NewSpriteToEdit = Cast<UPaperSprite>(AssetData.GetAsset()))
{
SpriteEditor->SetSpriteBeingEdited(NewSpriteToEdit);
}
}
}
//------------------------------------------------------------------------------
static void BlueprintActionDatabaseImpl::OnAssetRemoved(FAssetData const& AssetInfo)
{
FBlueprintActionDatabase& ActionDatabase = FBlueprintActionDatabase::Get();
if (AssetInfo.IsAssetLoaded())
{
UObject* AssetObject = AssetInfo.GetAsset();
OnAssetRemoved(AssetObject);
}
else
{
ActionDatabase.ClearUnloadedAssetActions(AssetInfo.ObjectPath);
}
}
void SFlipbookKeyframeWidget::OnAssetSelected(const FAssetData& AssetData)
{
if (UPaperFlipbook* Flipbook = FlipbookBeingEdited.Get())
{
FScopedFlipbookMutator EditLock(Flipbook);
if (EditLock.KeyFrames.IsValidIndex(FrameIndex))
{
UPaperSprite* NewSprite = Cast<UPaperSprite>(AssetData.GetAsset());
EditLock.KeyFrames[FrameIndex].Sprite = NewSprite;
}
}
}
//------------------------------------------------------------------------------
static void BlueprintActionDatabaseImpl::OnAssetAdded(FAssetData const& NewAssetInfo)
{
if (NewAssetInfo.IsAssetLoaded())
{
UObject* AssetObject = NewAssetInfo.GetAsset();
if (UBlueprint* NewBlueprint = Cast<UBlueprint>(AssetObject))
{
OnBlueprintChanged(NewBlueprint);
}
else
{
FBlueprintActionDatabase& ActionDatabase = FBlueprintActionDatabase::Get();
ActionDatabase.RefreshAssetActions(AssetObject);
}
}
}
END_SLATE_FUNCTION_BUILD_OPTIMIZATION
void SReflectorTreeWidgetItem::HandleHyperlinkNavigate()
{
FAssetData AssetData = WidgetInfo->GetWidgetAssetData();
if ( AssetData.IsValid() )
{
if ( OnAccessAsset.IsBound() )
{
AssetData.GetPackage();
OnAccessAsset.Execute(AssetData.GetAsset());
return;
}
}
if ( OnAccessSourceCode.IsBound() )
{
OnAccessSourceCode.Execute(GetWidgetFile(), GetWidgetLineNumber(), 0);
}
}
//------------------------------------------------------------------------------
bool FBlueprintActionDatabaseRegistrar::AddBlueprintAction(FAssetData const& AssetDataOwner, UBlueprintNodeSpawner* NodeSpawner)
{
bool bReturnResult = false;
// @TODO: assert that AddBlueprintAction(UBlueprintNodeSpawner* NodeSpawner)
// wouldn't come up with a different key (besides GeneratingClass)
if(AssetDataOwner.IsAssetLoaded())
{
bReturnResult = AddBlueprintAction(AssetDataOwner.GetAsset(), NodeSpawner);
}
else
{
bReturnResult = AddBlueprintAction(NodeSpawner->NodeClass, NodeSpawner);
if(bReturnResult)
{
TArray<UBlueprintNodeSpawner*>& ActionList = UnloadedActionDatabase.FindOrAdd(AssetDataOwner.ObjectPath);
ActionList.Add(NodeSpawner);
}
}
return bReturnResult;
}
bool FAssetDeleteModel::DoReplaceReferences(const FAssetData& ReplaceReferencesWith )
{
if ( !CanReplaceReferences() )
{
return false;
}
// Find which object the user has elected to be the "object to consolidate to"
UObject* ObjectToConsolidateTo = ReplaceReferencesWith.GetAsset();
check( ObjectToConsolidateTo );
TArray<UObject*> FinalConsolidationObjects;
for ( TSharedPtr< FPendingDelete >& PendingDelete : PendingDeletes )
{
FinalConsolidationObjects.Add(PendingDelete->GetObject());
}
// The consolidation action clears the array, so we need to save the count.
int32 ObjectsBeingDeletedCount = FinalConsolidationObjects.Num();
// Perform the object consolidation
bool bShowDeleteConfirmation = false;
ObjectTools::FConsolidationResults ConsResults = ObjectTools::ConsolidateObjects( ObjectToConsolidateTo, FinalConsolidationObjects, bShowDeleteConfirmation );
// If the consolidation went off successfully with no failed objects, prompt the user to checkout/save the packages dirtied by the operation
if ( ConsResults.DirtiedPackages.Num() > 0 && ConsResults.FailedConsolidationObjs.Num() == 0)
{
FEditorFileUtils::PromptForCheckoutAndSave( ConsResults.DirtiedPackages, false, true );
}
// If the consolidation resulted in failed (partially consolidated) objects, do not save, and inform the user no save attempt was made
else if ( ConsResults.FailedConsolidationObjs.Num() > 0)
{
//DisplayMessage( true, LOCTEXT( "Consolidate_WarningPartial", "Not all objects could be consolidated, no save has occurred" ).ToString() );
}
ObjectsDeleted = ObjectsBeingDeletedCount - ( ConsResults.FailedConsolidationObjs.Num() + ConsResults.InvalidConsolidationObjs.Num() );
return true;
}
bool UMaterialGraphSchema::HasCompatibleConnection(const FAssetData& FunctionAssetData, uint32 TestType, EEdGraphPinDirection TestDirection) const
{
if (TestType != 0)
{
const FString* CombinedInputTagValue = FunctionAssetData.TagsAndValues.Find(GET_MEMBER_NAME_CHECKED(UMaterialFunction, CombinedInputTypes));
const FString* CombinedOutputTagValue = FunctionAssetData.TagsAndValues.Find(GET_MEMBER_NAME_CHECKED(UMaterialFunction, CombinedOutputTypes));
uint32 CombinedInputTypes = CombinedInputTagValue ? FCString::Atoi(**CombinedInputTagValue) : 0;
uint32 CombinedOutputTypes = CombinedOutputTagValue ? FCString::Atoi(**CombinedOutputTagValue) : 0;
if (CombinedOutputTypes == 0)
{
// Need to load function to build combined output types
UMaterialFunction* MaterialFunction = Cast<UMaterialFunction>(FunctionAssetData.GetAsset());
if (MaterialFunction != nullptr)
{
CombinedInputTypes = MaterialFunction->CombinedInputTypes;
CombinedOutputTypes = MaterialFunction->CombinedOutputTypes;
}
}
if (TestDirection == EGPD_Output)
{
if (CanConnectMaterialValueTypes(CombinedInputTypes, TestType))
{
return true;
}
}
else
{
if (CanConnectMaterialValueTypes(TestType, CombinedOutputTypes))
{
return true;
}
}
}
return false;
}
void FPropertyEditor::OnAssetSelected( const FAssetData& AssetData )
{
// Set the object found from the asset picker
GetPropertyHandle()->SetValueFromFormattedString( AssetData.IsValid() ? AssetData.GetAsset()->GetPathName() : TEXT("None") );
}
void UAnimSequenceFactory::OnTargetSkeletonSelected(const FAssetData& SelectedAsset)
{
TargetSkeleton = Cast<USkeleton>(SelectedAsset.GetAsset());
PickerWindow->RequestDestroyWindow();
}
void SContentReference::OnAssetSelectedFromPicker(const FAssetData& AssetData)
{
PickerComboButton->SetIsOpen(false);
OnSetReference.ExecuteIfBound(AssetData.GetAsset());
}
bool FSlateFontInfoStructCustomization::OnFilterFontAsset(const FAssetData& InAssetData)
{
// We want to filter font assets that aren't valid to use with Slate/UMG
return Cast<const UFont>(InAssetData.GetAsset())->FontCacheType != EFontCacheType::Runtime;
}
void FAutoReimportManager::OnAssetRenamed(const FAssetData& AssetData, const FString& OldPath)
{
if (bGuardAssetChanges)
{
return;
}
// This code moves a source content file that reside alongside assets when the assets are renamed. We do this under the following conditions:
// 1. The sourcefile is solely referenced from the the asset that has been moved
// 2. Said asset only references a single file
// 3. The source file resides in the same folder as the asset
//
// Additionally, we rename the source file if it matched the name of the asset before the rename/move.
// - If we rename the source file, then we also update the reimport paths for the asset
TArray<FString> SourceFilesRelativeToOldPath;
for (const auto& Pair : AssetData.TagsAndValues)
{
if (Pair.Key.IsEqual(UObject::SourceFileTagName(), ENameCase::IgnoreCase, false))
{
SourceFilesRelativeToOldPath.Add(Pair.Value);
}
}
// We move the file with the asset provided it is the only file referenced, and sits right beside the uasset file
if (SourceFilesRelativeToOldPath.Num() == 1 && !SourceFilesRelativeToOldPath[0].GetCharArray().ContainsByPredicate([](const TCHAR Char) { return Char == '/' || Char == '\\'; }))
{
const FString AbsoluteSrcPath = FPaths::ConvertRelativePathToFull(FPackageName::LongPackageNameToFilename(FPackageName::GetLongPackagePath(OldPath) / TEXT("")));
const FString AbsoluteDstPath = FPaths::ConvertRelativePathToFull(FPackageName::LongPackageNameToFilename(AssetData.PackagePath.ToString() / TEXT("")));
const FString OldAssetName = FPackageName::GetLongPackageAssetName(FPackageName::ObjectPathToPackageName(OldPath));
FString NewFileName = FPaths::GetBaseFilename(SourceFilesRelativeToOldPath[0]);
bool bRequireReimportPathUpdate = false;
if (PackageTools::SanitizePackageName(NewFileName) == OldAssetName)
{
NewFileName = AssetData.AssetName.ToString();
bRequireReimportPathUpdate = true;
}
const FString SrcFile = AbsoluteSrcPath / SourceFilesRelativeToOldPath[0];
const FString DstFile = AbsoluteDstPath / NewFileName + TEXT(".") + FPaths::GetExtension(SourceFilesRelativeToOldPath[0]);
// We can't do this if multiple assets reference the same file. We should be checking for > 1 referencing asset, but the asset registry
// filter lookup won't return the recently renamed package because it will be Empty by now, so we check for *anything* referencing the asset (assuming that we'll never find *this* asset).
const IAssetRegistry& Registry = FModuleManager::LoadModuleChecked<FAssetRegistryModule>("AssetRegistry").Get();
if (Utils::FindAssetsPertainingToFile(Registry, SrcFile).Num() > 0)
{
return;
}
if (!FPlatformFileManager::Get().GetPlatformFile().FileExists(*DstFile) &&
IFileManager::Get().Move(*DstFile, *SrcFile, false /*bReplace */, false, true /* attributes */, true /* don't retry */))
{
IgnoreMovedFile(SrcFile, DstFile);
if (bRequireReimportPathUpdate)
{
TArray<FString> Paths;
Paths.Add(DstFile);
// Update the reimport file names
FReimportManager::Instance()->UpdateReimportPaths(AssetData.GetAsset(), Paths);
}
}
}
}
TSharedPtr<SWidget> FAssetTypeActions_SoundWave::GetThumbnailOverlay(const FAssetData& AssetData) const
{
TArray<TWeakObjectPtr<USoundBase>> SoundList;
SoundList.Add(TWeakObjectPtr<USoundBase>((USoundBase*)AssetData.GetAsset()));
auto OnGetDisplayBrushLambda = [this, SoundList]() -> const FSlateBrush*
{
if (IsSoundPlaying(SoundList))
{
return FEditorStyle::GetBrush("MediaAsset.AssetActions.Stop");
}
return FEditorStyle::GetBrush("MediaAsset.AssetActions.Play");
};
auto IsEnabledLambda = [this, SoundList]() -> bool
{
return CanExecutePlayCommand(SoundList);
};
auto OnClickedLambda = [this, SoundList]() -> FReply
{
if (IsSoundPlaying(SoundList))
{
ExecuteStopSound(SoundList);
}
else
{
ExecutePlaySound(SoundList);
}
return FReply::Handled();
};
auto OnToolTipTextLambda = [this, SoundList]() -> FText
{
if (IsSoundPlaying(SoundList))
{
return LOCTEXT("Blueprint_StopSoundToolTip", "Stop selected Sound Wave");
}
return LOCTEXT("Blueprint_PlaySoundToolTip", "Play selected Sound Wave");
};
return SNew(SBox)
.HAlign(HAlign_Center)
.VAlign(VAlign_Center)
.Padding(FMargin(2))
[
SNew(SButton)
.ButtonStyle(FEditorStyle::Get(), "HoverHintOnly")
.ToolTipText_Lambda(OnToolTipTextLambda)
.Cursor(EMouseCursor::Default) // The outer widget can specify a DragHand cursor, so we need to override that here
.ForegroundColor(FSlateColor::UseForeground())
.IsEnabled_Lambda(IsEnabledLambda)
.OnClicked_Lambda(OnClickedLambda)
[
SNew(SBox)
.MinDesiredWidth(16)
.MinDesiredHeight(16)
[
SNew(SImage)
.Image_Lambda(OnGetDisplayBrushLambda)
]
]
];
}
