void FLightmapCustomNodeBuilder::RefreshLightmapItems()
{
LightmapItems.Empty();
FWorldContext& Context = GEditor->GetEditorWorldContext();
UWorld* World = Context.World();
if ( World )
{
TArray<UTexture2D*> LightMapsAndShadowMaps;
World->GetLightMapsAndShadowMaps(World->GetCurrentLevel(), LightMapsAndShadowMaps);
for ( auto ObjIt = LightMapsAndShadowMaps.CreateConstIterator(); ObjIt; ++ObjIt )
{
UTexture2D* CurrentObject = *ObjIt;
if (CurrentObject)
{
FAssetData AssetData = FAssetData(CurrentObject);
const uint32 ThumbnailResolution = 64;
TSharedPtr<FAssetThumbnail> LightMapThumbnail = MakeShareable( new FAssetThumbnail( AssetData, ThumbnailResolution, ThumbnailResolution, ThumbnailPool ) );
TSharedPtr<FLightmapItem> NewItem = MakeShareable( new FLightmapItem(CurrentObject->GetPathName(), LightMapThumbnail) );
LightmapItems.Add(NewItem);
}
}
}
if ( LightmapListView.IsValid() )
{
LightmapListView->RequestListRefresh();
}
}
void CreateTileSetsFromTextures(TArray<UTexture2D*>& Textures)
{
const FString DefaultSuffix = TEXT("_TileSet");
FAssetToolsModule& AssetToolsModule = FModuleManager::Get().LoadModuleChecked<FAssetToolsModule>("AssetTools");
FContentBrowserModule& ContentBrowserModule = FModuleManager::LoadModuleChecked<FContentBrowserModule>("ContentBrowser");
TArray<UObject*> ObjectsToSync;
for (auto TextureIt = Textures.CreateConstIterator(); TextureIt; ++TextureIt)
{
UTexture2D* Texture = *TextureIt;
// Create the factory used to generate the tile set
UPaperTileSetFactory* TileSetFactory = NewObject<UPaperTileSetFactory>();
TileSetFactory->InitialTexture = Texture;
// Get a unique name for the tile set
FString Name;
FString PackageName;
AssetToolsModule.Get().CreateUniqueAssetName(Texture->GetOutermost()->GetName(), DefaultSuffix, /*out*/ PackageName, /*out*/ Name);
const FString PackagePath = FPackageName::GetLongPackagePath(PackageName);
if (UObject* NewAsset = AssetToolsModule.Get().CreateAsset(Name, PackagePath, UPaperTileSet::StaticClass(), TileSetFactory))
{
ObjectsToSync.Add(NewAsset);
}
}
if (ObjectsToSync.Num() > 0)
{
ContentBrowserModule.Get().SyncBrowserToAssets(ObjectsToSync);
}
}
void USkeleton::CollectAnimationNotifies()
{
// need to verify if these pose is used by anybody else
FAssetRegistryModule& AssetRegistryModule = FModuleManager::LoadModuleChecked<FAssetRegistryModule>(TEXT("AssetRegistry"));
// @Todo : remove it when we know the asset registry is updated
// meanwhile if you remove this, this will miss the links
//AnimationNotifies.Empty();
TArray<FAssetData> AssetList;
AssetRegistryModule.Get().GetAssetsByClass(UAnimSequenceBase::StaticClass()->GetFName(), AssetList, true);
#if WITH_EDITOR
// do not clear AnimationNotifies. We can't remove old ones yet.
FString CurrentSkeletonName = FAssetData(this).GetExportTextName();
for (auto Iter = AssetList.CreateConstIterator(); Iter; ++Iter)
{
const FAssetData& Asset = *Iter;
const FString* SkeletonValue = Asset.TagsAndValues.Find(TEXT("Skeleton"));
if (SkeletonValue && *SkeletonValue == CurrentSkeletonName)
{
if (const FString* Value = Asset.TagsAndValues.Find(USkeleton::AnimNotifyTag))
{
TArray<FString> NotifyList;
Value->ParseIntoArray(&NotifyList, &AnimNotifyTagDelimiter, true);
for (auto NotifyIter = NotifyList.CreateConstIterator(); NotifyIter; ++NotifyIter)
{
FString NotifyName = *NotifyIter;
AddNewAnimationNotify(FName(*NotifyName));
}
}
}
}
#endif
}
bool FLayers::AddActorsToLayers( const TArray< TWeakObjectPtr< AActor > >& Actors, const TArray< FName >& LayerNames )
{
bool bChangesOccurred = false;
if ( LayerNames.Num() > 0 )
{
Editor->GetSelectedActors()->BeginBatchSelectOperation();
for( auto ActorIt = Actors.CreateConstIterator(); ActorIt; ++ActorIt )
{
const TWeakObjectPtr< AActor > Actor = *ActorIt;
if ( !IsActorValidForLayer( Actor ) )
{
continue;
}
bool bActorWasModified = false;
for( auto LayerNameIt = LayerNames.CreateConstIterator(); LayerNameIt; ++LayerNameIt )
{
const FName& LayerName = *LayerNameIt;
if( !Actor->Layers.Contains( LayerName ) )
{
if( !bActorWasModified )
{
Actor->Modify();
bActorWasModified = true;
}
TWeakObjectPtr< ULayer > Layer = EnsureLayerExists( LayerName );
Actor->Layers.Add( LayerName );
Layer->Modify();
AddActorToStats( Layer, Actor);
}
} //END Iteration over Layers
if( bActorWasModified )
{
// update per-view visibility info
UpdateActorAllViewsVisibility(Actor);
// update general actor visibility
bool bActorModified = false;
bool bActorSelectionChanged = false;
const bool bActorNotifySelectionChange = true;
const bool bActorRedrawViewports = false;
UpdateActorVisibility( Actor, bActorSelectionChanged, bActorModified, bActorNotifySelectionChange, bActorRedrawViewports );
bChangesOccurred = true;
}
} //END Iteration over Actors
Editor->GetSelectedActors()->EndBatchSelectOperation();
}
return bChangesOccurred;
}
void UK2Node_MacroInstance::ReallocatePinsDuringReconstruction(TArray<UEdGraphPin*>& OldPins)
{
Super::ReallocatePinsDuringReconstruction(OldPins);
const UEdGraphSchema_K2* const Schema = GetDefault<UEdGraphSchema_K2>();
// determine if all wildcard pins are unlinked.
// if they are, we should revert them all back to wildcard status
bool bAllWildcardsAreUnlinked = true;
for (auto PinIt = Pins.CreateConstIterator(); PinIt; PinIt++)
{
// for each of the wildcard pins...
UEdGraphPin* const Pin = *PinIt;
if ( Pin->PinType.PinCategory == Schema->PC_Wildcard )
{
// find it in the old pins array (where it might not be a wildcard)
// and see if it's unlinked
for (auto OldPinIt = OldPins.CreateConstIterator(); OldPinIt; OldPinIt++)
{
UEdGraphPin const* const OldPin = *OldPinIt;
if (OldPin->PinName == Pin->PinName)
{
if (OldPin->LinkedTo.Num() > 0)
{
bAllWildcardsAreUnlinked = false;
break;
}
}
}
}
}
if (bAllWildcardsAreUnlinked == false)
{
// Copy pin types from old pins for wildcard pins
for (auto PinIt = Pins.CreateConstIterator(); PinIt; PinIt++)
{
UEdGraphPin* const Pin = *PinIt;
if ( Pin->PinType.PinCategory == Schema->PC_Wildcard )
{
// find it in the old pins and copy the type
for (auto OldPinIt = OldPins.CreateConstIterator(); OldPinIt; OldPinIt++)
{
UEdGraphPin const* const OldPin = *OldPinIt;
if (OldPin->PinName == Pin->PinName)
{
Pin->PinType = OldPin->PinType;
}
}
}
}
}
else
{
// no type
ResolvedWildcardType.ResetToDefaults();
}
}
bool FLayers::RemoveActorsFromLayers( const TArray< TWeakObjectPtr< AActor > >& Actors, const TArray< FName >& LayerNames, const bool bUpdateStats )
{
Editor->GetSelectedActors()->BeginBatchSelectOperation();
bool bChangesOccurred = false;
for( auto ActorIt = Actors.CreateConstIterator(); ActorIt; ++ActorIt )
{
const TWeakObjectPtr< AActor > Actor = *ActorIt;
if ( !IsActorValidForLayer( Actor ) )
{
continue;
}
bool ActorWasModified = false;
for( auto LayerNameIt = LayerNames.CreateConstIterator(); LayerNameIt; ++LayerNameIt )
{
const FName& LayerName = *LayerNameIt;
if( Actor->Layers.Contains( LayerName ) )
{
if( !ActorWasModified )
{
Actor->Modify();
ActorWasModified = true;
}
Actor->Layers.Remove( LayerName );
TWeakObjectPtr< ULayer > Layer;
if( bUpdateStats && TryGetLayer( LayerName, Layer ))
{
Layer->Modify();
RemoveActorFromStats( Layer, Actor);
}
}
} //END Iteration over Layers
if( ActorWasModified )
{
// update per-view visibility info
UpdateActorAllViewsVisibility(Actor);
// update general actor visibility
bool bActorModified = false;
bool bActorSelectionChanged = false;
const bool bActorNotifySelectionChange = true;
const bool bActorRedrawViewports = false;
UpdateActorVisibility( Actor, bActorSelectionChanged, bActorModified, bActorNotifySelectionChange, bActorRedrawViewports );
bChangesOccurred = true;
}
} //END Iteration over Actors
Editor->GetSelectedActors()->EndBatchSelectOperation();
return bChangesOccurred;
}
void FPathContextMenu::ExecuteSCCOpenForAdd()
{
ISourceControlProvider& SourceControlProvider = ISourceControlModule::Get().GetProvider();
// Get a list of package names in the selected paths
TArray<FString> PackageNames;
GetPackageNamesInSelectedPaths(PackageNames);
TArray<FString> PackagesToAdd;
TArray<UPackage*> PackagesToSave;
for ( auto PackageIt = PackageNames.CreateConstIterator(); PackageIt; ++PackageIt )
{
FSourceControlStatePtr SourceControlState = SourceControlProvider.GetState(SourceControlHelpers::PackageFilename(*PackageIt), EStateCacheUsage::Use);
if ( SourceControlState.IsValid() && !SourceControlState->IsSourceControlled() )
{
PackagesToAdd.Add(*PackageIt);
// Make sure the file actually exists on disk before adding it
FString Filename;
if ( !FPackageName::DoesPackageExist(*PackageIt, NULL, &Filename) )
{
UPackage* Package = FindPackage(NULL, **PackageIt);
if ( Package )
{
PackagesToSave.Add(Package);
}
}
}
}
if ( PackagesToAdd.Num() > 0 )
{
// If any of the packages are new, save them now
if ( PackagesToSave.Num() > 0 )
{
const bool bCheckDirty = false;
const bool bPromptToSave = false;
TArray<UPackage*> FailedPackages;
const FEditorFileUtils::EPromptReturnCode Return = FEditorFileUtils::PromptForCheckoutAndSave(PackagesToSave, bCheckDirty, bPromptToSave, &FailedPackages);
if(FailedPackages.Num() > 0)
{
// don't try and add files that failed to save - remove them from the list
for(auto FailedPackageIt = FailedPackages.CreateConstIterator(); FailedPackageIt; FailedPackageIt++)
{
PackagesToAdd.Remove((*FailedPackageIt)->GetName());
}
}
}
if ( PackagesToAdd.Num() > 0 )
{
SourceControlProvider.Execute(ISourceControlOperation::Create<FMarkForAdd>(), SourceControlHelpers::PackageFilenames(PackagesToAdd));
}
}
}
bool FAssetFixUpRedirectors::CheckOutReferencingPackages(TArray<FRedirectorRefs>& RedirectorsToFix, TArray<UPackage*>& InOutReferencingPackagesToSave) const
{
// Prompt to check out all successfully loaded packages
bool bUserAcceptedCheckout = true;
if ( InOutReferencingPackagesToSave.Num() > 0 )
{
if ( ISourceControlModule::Get().IsEnabled() )
{
TArray<UPackage*> PackagesCheckedOutOrMadeWritable;
TArray<UPackage*> PackagesNotNeedingCheckout;
bUserAcceptedCheckout = FEditorFileUtils::PromptToCheckoutPackages( false, InOutReferencingPackagesToSave, &PackagesCheckedOutOrMadeWritable, &PackagesNotNeedingCheckout );
if ( bUserAcceptedCheckout )
{
TArray<UPackage*> PackagesThatCouldNotBeCheckedOut = InOutReferencingPackagesToSave;
for ( auto PackageIt = PackagesCheckedOutOrMadeWritable.CreateConstIterator(); PackageIt; ++PackageIt )
{
PackagesThatCouldNotBeCheckedOut.Remove(*PackageIt);
}
for ( auto PackageIt = PackagesNotNeedingCheckout.CreateConstIterator(); PackageIt; ++PackageIt )
{
PackagesThatCouldNotBeCheckedOut.Remove(*PackageIt);
}
for ( auto PackageIt = PackagesThatCouldNotBeCheckedOut.CreateConstIterator(); PackageIt; ++PackageIt )
{
const FName NonCheckedOutPackageName = (*PackageIt)->GetFName();
for ( auto RedirectorRefsIt = RedirectorsToFix.CreateIterator(); RedirectorRefsIt; ++RedirectorRefsIt )
{
FRedirectorRefs& RedirectorRefs = *RedirectorRefsIt;
if ( RedirectorRefs.ReferencingPackageNames.Contains(NonCheckedOutPackageName) )
{
// We did not check out at least one of the packages we needed to. This redirector can not be fixed up.
RedirectorRefs.FailureReason = FText::Format(LOCTEXT("RedirectorFixupFailed_NotCheckedOut", "Referencing package {0} was not checked out"), FText::FromName(NonCheckedOutPackageName));
RedirectorRefs.bRedirectorValidForFixup = false;
}
}
InOutReferencingPackagesToSave.Remove(*PackageIt);
}
}
}
}
return bUserAcceptedCheckout;
}
virtual void SnapPointToGrid(FVector& Point, const FVector& GridBase) override
{
for (auto PolicyIt = PolicyList.CreateConstIterator(); PolicyIt; ++PolicyIt)
{
(*PolicyIt)->SnapPointToGrid(Point, GridBase);
}
}
void FAssetTypeActions_StaticMesh::ExecuteCreateDestructibleMesh(TArray<TWeakObjectPtr<UStaticMesh>> Objects)
{
TArray< UObject* > Assets;
for (auto ObjIt = Objects.CreateConstIterator(); ObjIt; ++ObjIt)
{
auto Object = (*ObjIt).Get();
if ( Object )
{
FText ErrorMsg;
FDestructibleMeshEditorModule& DestructibleMeshEditorModule = FModuleManager::LoadModuleChecked<FDestructibleMeshEditorModule>( "DestructibleMeshEditor" );
UDestructibleMesh* DestructibleMesh = DestructibleMeshEditorModule.CreateDestructibleMeshFromStaticMesh(Object->GetOuter(), Object, NAME_None, Object->GetFlags(), ErrorMsg);
if ( DestructibleMesh )
{
FAssetEditorManager::Get().OpenEditorForAsset(DestructibleMesh);
Assets.Add(DestructibleMesh);
}
else if ( !ErrorMsg.IsEmpty() )
{
FNotificationInfo ErrorNotification( ErrorMsg );
FSlateNotificationManager::Get().AddNotification(ErrorNotification);
}
}
}
if ( Assets.Num() > 0 )
{
FAssetTools::Get().SyncBrowserToAssets(Assets);
}
}
bool FPerforceSourceControlLabel::GetFileRevisions( const TArray<FString>& InFiles, TArray< TSharedRef<ISourceControlRevision, ESPMode::ThreadSafe> >& OutRevisions ) const
{
bool bCommandOK = false;
FPerforceSourceControlModule& PerforceSourceControl = FModuleManager::LoadModuleChecked<FPerforceSourceControlModule>("PerforceSourceControl");
FScopedPerforceConnection ScopedConnection(EConcurrency::Synchronous, PerforceSourceControl.AccessSettings().GetConnectionInfo());
if(ScopedConnection.IsValid())
{
FPerforceConnection& Connection = ScopedConnection.GetConnection();
FP4RecordSet Records;
TArray<FString> Parameters;
TArray<FText> ErrorMessages;
for(auto Iter(InFiles.CreateConstIterator()); Iter; Iter++)
{
Parameters.Add(*Iter + TEXT("@") + Name);
}
bool bConnectionDropped = false;
bCommandOK = Connection.RunCommand(TEXT("files"), Parameters, Records, ErrorMessages, FOnIsCancelled(), bConnectionDropped);
if(bCommandOK)
{
ParseFilesResults(Records, OutRevisions, Connection.ClientRoot);
}
else
{
// output errors if any
for (int32 ErrorIndex = 0; ErrorIndex < ErrorMessages.Num(); ++ErrorIndex)
{
FMessageLog("SourceControl").Error(ErrorMessages[ErrorIndex]);
}
}
}
return bCommandOK;
}
void SBlutilityShelf::ToggleFavoriteStatusOnSelection(TArray<FAssetData> AssetList, bool bIsNewFavorite)
{
if (AssetList.Num() > 0)
{
// Get the list to add/remove
TArray<FName> AllPaths;
for (auto AssetIt = AssetList.CreateConstIterator(); AssetIt; ++AssetIt)
{
const FAssetData& AssetData = *AssetIt;
AllPaths.Add(AssetData.ObjectPath);
}
// Determine the current status
bool bAreAnySelected;
bool bAreAllSelected;
GetFavoriteStatus(AssetList, /*out*/ bAreAnySelected, /*out*/ bAreAllSelected);
FCollectionManagerModule& CollectionManagerModule = FCollectionManagerModule::GetModule();
if (bAreAllSelected)
{
// Remove them
CollectionManagerModule.Get().RemoveFromCollection(BlutilityModule::BlutilityShelfCollectionName, ECollectionShareType::CST_Local, AllPaths);
}
else
{
// Add them
CollectionManagerModule.Get().AddToCollection(BlutilityModule::BlutilityShelfCollectionName, ECollectionShareType::CST_Local, AllPaths);
}
}
}
void FAssetTypeActions_EditorUtilityBlueprint::OpenAssetEditor(const TArray<UObject*>& InObjects, TSharedPtr<class IToolkitHost> EditWithinLevelEditor)
{
EToolkitMode::Type Mode = EditWithinLevelEditor.IsValid() ? EToolkitMode::WorldCentric : EToolkitMode::Standalone;
for (auto ObjIt = InObjects.CreateConstIterator(); ObjIt; ++ObjIt)
{
if (UEditorUtilityBlueprint* Blueprint = Cast<UEditorUtilityBlueprint>(*ObjIt))
{
if (Blueprint->GeneratedClass->IsChildOf(UGlobalEditorUtilityBase::StaticClass()))
{
const UGlobalEditorUtilityBase* CDO = Blueprint->GeneratedClass->GetDefaultObject<UGlobalEditorUtilityBase>();
if (CDO->bAutoRunDefaultAction)
{
// This is an instant-run blueprint, just execute it
UGlobalEditorUtilityBase* Instance = NewObject<UGlobalEditorUtilityBase>(GetTransientPackage(), Blueprint->GeneratedClass);
Instance->ExecuteDefaultAction();
}
else
{
// This one needs settings or has multiple actions to execute, so invoke the blutility dialog
TSharedRef<FGlobalBlutilityDialog> NewBlutilityDialog(new FGlobalBlutilityDialog());
NewBlutilityDialog->InitBlutilityDialog(Mode, EditWithinLevelEditor, Blueprint);
}
}
else
{
// Edit actor blutilities
FBlueprintEditorModule& BlueprintEditorModule = FModuleManager::LoadModuleChecked<FBlueprintEditorModule>( "Kismet" );
TSharedRef<IBlueprintEditor> NewBlueprintEditor = BlueprintEditorModule.CreateBlueprintEditor(Mode, EditWithinLevelEditor, Blueprint, false);
}
}
}
}
/**
* Generates a list of assets from the ENGINE and the GAME by a specific type.
* This is to be used by the GetTest() function.
*/
void FEditorAutomationTestUtilities::CollectTestsByClass(UClass * Class, TArray<FString>& OutBeautifiedNames, TArray <FString>& OutTestCommands)
{
FAssetRegistryModule& AssetRegistryModule = FModuleManager::LoadModuleChecked<FAssetRegistryModule>(TEXT("AssetRegistry"));
TArray<FAssetData> ObjectList;
AssetRegistryModule.Get().GetAssetsByClass(Class->GetFName(), ObjectList);
for (TObjectIterator<UClass> AllClassesIt; AllClassesIt; ++AllClassesIt)
{
UClass* ClassList = *AllClassesIt;
FName ClassName = ClassList->GetFName();
}
for (auto ObjIter = ObjectList.CreateConstIterator(); ObjIter; ++ObjIter)
{
const FAssetData& Asset = *ObjIter;
FString Filename = Asset.ObjectPath.ToString();
//convert to full paths
Filename = FPackageName::LongPackageNameToFilename(Filename);
if (FAutomationTestFramework::GetInstance().ShouldTestContent(Filename))
{
FString BeautifiedFilename = Asset.AssetName.ToString();
OutBeautifiedNames.Add(BeautifiedFilename);
OutTestCommands.Add(Asset.ObjectPath.ToString());
}
}
}
virtual void DrawSnappingHelpers(const FSceneView* View, FPrimitiveDrawInterface* PDI)
{
for (auto PolicyIt = PolicyList.CreateConstIterator(); PolicyIt; ++PolicyIt)
{
(*PolicyIt)->DrawSnappingHelpers(View, PDI);
}
}
void FPrimaryAssetIdCustomization::CustomizeHeader(TSharedRef<class IPropertyHandle> InStructPropertyHandle, class FDetailWidgetRow& HeaderRow, IPropertyTypeCustomizationUtils& StructCustomizationUtils)
{
if (!UAssetManager::IsValid())
{
HeaderRow
.NameContent()
[
InStructPropertyHandle->CreatePropertyNameWidget()
]
.ValueContent()
.MinDesiredWidth(250.0f)
.MaxDesiredWidth(0.0f)
[
SNew(STextBlock)
.Text(LOCTEXT("NoAssetManager", "Enable Asset Manager to edit Primary Asset Ids"))
];
return;
}
StructPropertyHandle = InStructPropertyHandle;
const FString& TypeFilterString = StructPropertyHandle->GetMetaData("AllowedTypes");
if( !TypeFilterString.IsEmpty() )
{
TArray<FString> CustomTypeFilterNames;
TypeFilterString.ParseIntoArray(CustomTypeFilterNames, TEXT(","), true);
for(auto It = CustomTypeFilterNames.CreateConstIterator(); It; ++It)
{
const FString& TypeName = *It;
AllowedTypes.Add(*TypeName);
}
}
FOnShouldFilterAsset AssetFilter = FOnShouldFilterAsset::CreateStatic(&IAssetManagerEditorModule::OnShouldFilterPrimaryAsset, AllowedTypes);
// Can the field be cleared
const bool bAllowClear = !(StructPropertyHandle->GetMetaDataProperty()->PropertyFlags & CPF_NoClear);
HeaderRow
.NameContent()
[
InStructPropertyHandle->CreatePropertyNameWidget()
]
.ValueContent()
.MinDesiredWidth(250.0f)
.MaxDesiredWidth(0.0f)
[
// Add an object entry box. Even though this isn't an object entry, we will simulate one
SNew( SObjectPropertyEntryBox )
.ObjectPath(this, &FPrimaryAssetIdCustomization::OnGetObjectPath)
.PropertyHandle(InStructPropertyHandle)
.ThumbnailPool(StructCustomizationUtils.GetThumbnailPool())
.OnShouldFilterAsset(AssetFilter)
.OnObjectChanged(this, &FPrimaryAssetIdCustomization::OnSetObject)
.AllowClear(bAllowClear)
];
}
bool FSubversionSourceControlRevision::GetAnnotated( TArray<FAnnotationLine>& OutLines ) const
{
SubversionSourceControlUtils::CheckFilename(Filename);
FSubversionSourceControlModule& SubversionSourceControl = FModuleManager::LoadModuleChecked<FSubversionSourceControlModule>( "SubversionSourceControl" );
FSubversionSourceControlProvider& Provider = SubversionSourceControl.GetProvider();
TArray<FString> Results;
TArray<FString> Parameters;
TArray<FString> ErrorMessages;
// Make temp filename to export to
FString RevString = (RevisionNumber < 0) ? TEXT("HEAD") : FString::Printf(TEXT("%d"), RevisionNumber);
Parameters.Add(FString(TEXT("--revision ")) + RevString);
Parameters.Add(TEXT("--use-merge-history"));
TArray<FString> Files;
Files.Add(Filename);
if(SubversionSourceControlUtils::RunCommand(TEXT("blame"), Files, Parameters, Results, ErrorMessages, Provider.GetUserName()))
{
ParseBlameResults(Results, OutLines);
return true;
}
else
{
for(auto Iter(ErrorMessages.CreateConstIterator()); Iter; Iter++)
{
FMessageLog("SourceControl").Error(FText::FromString(*Iter));
}
}
return false;
}
void FAssetTypeActions_Blueprint::ExecuteEditDefaults(TArray<TWeakObjectPtr<UBlueprint>> Objects)
{
TArray< UBlueprint* > Blueprints;
FMessageLog EditorErrors("EditorErrors");
EditorErrors.NewPage(LOCTEXT("ExecuteEditDefaultsNewLogPage", "Loading Blueprints"));
for (auto ObjIt = Objects.CreateConstIterator(); ObjIt; ++ObjIt)
{
auto Object = (*ObjIt).Get();
if ( Object )
{
// If the blueprint is valid, allow it to be added to the list, otherwise log the error.
if (Object && Object->SkeletonGeneratedClass && Object->GeneratedClass )
{
Blueprints.Add(Object);
}
else
{
FFormatNamedArguments Arguments;
Arguments.Add(TEXT("ObjectName"), FText::FromString(Object->GetName()));
EditorErrors.Error(FText::Format(LOCTEXT("LoadBlueprint_FailedLog", "{ObjectName} could not be loaded because it derives from an invalid class. Check to make sure the parent class for this blueprint hasn't been removed!"), Arguments ) );
}
}
}
if ( Blueprints.Num() > 0 )
{
FBlueprintEditorModule& BlueprintEditorModule = FModuleManager::LoadModuleChecked<FBlueprintEditorModule>( "Kismet" );
TSharedRef< IBlueprintEditor > NewBlueprintEditor = BlueprintEditorModule.CreateBlueprintEditor( EToolkitMode::Standalone, TSharedPtr<IToolkitHost>(), Blueprints );
}
// Report errors
EditorErrors.Notify(LOCTEXT("OpenDefaults_Failed", "Opening Blueprint Defaults Failed!"));
}
void UGameplayTagsManager::LoadGameplayTagTables(TArray<FString>& TagTableNames)
{
if (GameplayTagTables.Num() == 0 && TagTableNames.Num() > 0)
{
for (auto It(TagTableNames.CreateConstIterator()); It; ++It)
{
const FString& FileName = *It;
UDataTable* TagTable = LoadObject<UDataTable>(NULL, *FileName, NULL, LOAD_None, NULL);
// Handle case where the module is dynamically-loaded within a LoadPackage stack, which would otherwise
// result in the tag table not having its RowStruct serialized in time. Without the RowStruct, the tags manager
// will not be initialized correctly.
if (TagTable && IsLoading())
{
FLinkerLoad* TagLinker = TagTable->GetLinker();
if (TagLinker)
{
TagTable->GetLinker()->Preload(TagTable);
}
}
GameplayTagTables.Add(TagTable);
}
}
#if WITH_EDITOR
// Hook into notifications for object re-imports so that the gameplay tag tree can be reconstructed if the table changes
if (GIsEditor && GameplayTagTables.Num() > 0 && !RegisteredObjectReimport)
{
RegisteredObjectReimport = true;
FEditorDelegates::OnAssetPostImport.AddUObject(this, &UGameplayTagsManager::OnObjectReimported);
}
#endif
}
bool FAssetFixUpRedirectors::UpdatePackageStatus(const TArray<FRedirectorRefs>& RedirectorsToFix) const
{
ISourceControlProvider& SourceControlProvider = ISourceControlModule::Get().GetProvider();
if ( ISourceControlModule::Get().IsEnabled() )
{
// Update the source control server availability to make sure we can do the rename operation
SourceControlProvider.Login();
if ( !SourceControlProvider.IsAvailable() )
{
// We have failed to update source control even though it is enabled. This is critical and we can not continue
FMessageDialog::Open( EAppMsgType::Ok, NSLOCTEXT("UnrealEd", "SourceControl_ServerUnresponsive", "Source Control is unresponsive. Please check your connection and try again.") );
return false;
}
TArray<UPackage*> PackagesToAddToSCCUpdate;
for ( auto RedirectorRefsIt = RedirectorsToFix.CreateConstIterator(); RedirectorRefsIt; ++RedirectorRefsIt )
{
const FRedirectorRefs& RedirectorRefs = *RedirectorRefsIt;
PackagesToAddToSCCUpdate.Add(RedirectorRefs.Redirector->GetOutermost());
}
SourceControlProvider.Execute(ISourceControlOperation::Create<FUpdateStatus>(), PackagesToAddToSCCUpdate);
}
return true;
}
void SBlutilityShelf::GetFavoriteStatus(const TArray<FAssetData>& AssetList, /*out*/ bool& bAreAnySelected, /*out*/ bool& bAreAllSelected)
{
TArray<FName> AssetPaths;
FCollectionManagerModule& CollectionManagerModule = FCollectionManagerModule::GetModule();
CollectionManagerModule.Get().GetAssetsInCollection(BlutilityModule::BlutilityShelfCollectionName, ECollectionShareType::CST_Local, /*out*/ AssetPaths);
bAreAnySelected = false;
bAreAllSelected = false;
if (AssetList.Num() > 0)
{
bAreAllSelected = true;
for (auto AssetIt = AssetList.CreateConstIterator(); AssetIt; ++AssetIt)
{
const FAssetData& AssetData = *AssetIt;
if (AssetPaths.Contains(AssetData.ObjectPath))
{
bAreAnySelected = true;
}
else
{
bAreAllSelected = false;
}
}
}
}
virtual void SnapRotatorToGrid(FRotator& Rotation) override
{
for (auto PolicyIt = PolicyList.CreateConstIterator(); PolicyIt; ++PolicyIt)
{
(*PolicyIt)->SnapRotatorToGrid(Rotation);
}
}
virtual void ClearSnappingHelpers(bool bClearImmediately) override
{
for (auto PolicyIt = PolicyList.CreateConstIterator(); PolicyIt; ++PolicyIt)
{
(*PolicyIt)->ClearSnappingHelpers(bClearImmediately);
}
}
void FAssetTypeActions_DataTable::ExecuteExportAsJSON(TArray< TWeakObjectPtr<UObject> > Objects)
{
IDesktopPlatform* DesktopPlatform = FDesktopPlatformModule::Get();
const void* ParentWindowWindowHandle = FSlateApplication::Get().FindBestParentWindowHandleForDialogs(nullptr);
for (auto ObjIt = Objects.CreateConstIterator(); ObjIt; ++ObjIt)
{
auto DataTable = Cast<UDataTable>((*ObjIt).Get());
if (DataTable)
{
const FText Title = FText::Format(LOCTEXT("DataTable_ExportJSONDialogTitle", "Export '{0}' as JSON..."), FText::FromString(*DataTable->GetName()));
const FString CurrentFilename = DataTable->AssetImportData->GetFirstFilename();
const FString FileTypes = TEXT("Data Table JSON (*.json)|*.json");
TArray<FString> OutFilenames;
DesktopPlatform->SaveFileDialog(
ParentWindowWindowHandle,
Title.ToString(),
(CurrentFilename.IsEmpty()) ? TEXT("") : FPaths::GetPath(CurrentFilename),
(CurrentFilename.IsEmpty()) ? TEXT("") : FPaths::GetBaseFilename(CurrentFilename) + TEXT(".json"),
FileTypes,
EFileDialogFlags::None,
OutFilenames
);
if (OutFilenames.Num() > 0)
{
FFileHelper::SaveStringToFile(DataTable->GetTableAsJSON(EDataTableExportFlags::UsePrettyPropertyNames | EDataTableExportFlags::UsePrettyEnumNames | EDataTableExportFlags::UseJsonObjectsForStructs), *OutFilenames[0]);
}
}
}
}
TSharedRef<SWidget> FCameraDetails::OnGetComboContent() const
{
// Fill the combo menu with presets of common screen resolutions
FMenuBuilder MenuBuilder(true, NULL);
TArray<FText> Items;
Items.Add(LOCTEXT("PresetRatio640x480", "640x480 (4:3, 1.33) SDTV"));
Items.Add(LOCTEXT("PresetRatio852x480", "852x480 (16:9, 1.78) SDTV Widescreen"));
Items.Add(LOCTEXT("PresetRatio1280x720", "1280x720 (16:9, 1.78) HDTV 720"));
Items.Add(LOCTEXT("PresetRatio1920x1080", "1920x1080 (16:9, 1.78) HDTV 1080"));
Items.Add(LOCTEXT("PresetRatio960x544", "960x544 (16:9, 1.76) PS Vita"));
Items.Add(LOCTEXT("PresetRatio1024x640", "1024x640 (1.6)"));
Items.Add(LOCTEXT("PresetRatio1024x76", "1024x768 (4:3, 1.33)"));
Items.Add(LOCTEXT("PresetRatio1366x768", "1366x768 (16:9, 1.78)"));
Items.Add(LOCTEXT("PresetRatio2048x1536", "2048x1536 (4:3, 1.33) iPad 3"));
Items.Add(LOCTEXT("PresetRatio4096x2304", "4096x2304 (16:9, 1.78) 4K"));
for (auto ItemIter = Items.CreateConstIterator(); ItemIter; ++ItemIter)
{
FText ItemText = *ItemIter;
FUIAction ItemAction( FExecuteAction::CreateSP( this, &FCameraDetails::CommitAspectRatioText, ItemText ) );
MenuBuilder.AddMenuEntry(ItemText, TAttribute<FText>(), FSlateIcon(), ItemAction);
}
return MenuBuilder.MakeWidget();
}
void UK2Node_CallArrayFunction::GetArrayPins(TArray< FArrayPropertyPinCombo >& OutArrayPinInfo ) const
{
OutArrayPinInfo.Empty();
UFunction* TargetFunction = GetTargetFunction();
check(TargetFunction);
FString ArrayPointerMetaData = TargetFunction->GetMetaData(FBlueprintMetadata::MD_ArrayParam);
TArray<FString> ArrayPinComboNames;
ArrayPointerMetaData.ParseIntoArray(ArrayPinComboNames, TEXT(","), true);
for(auto Iter = ArrayPinComboNames.CreateConstIterator(); Iter; ++Iter)
{
TArray<FString> ArrayPinNames;
Iter->ParseIntoArray(ArrayPinNames, TEXT("|"), true);
FArrayPropertyPinCombo ArrayInfo;
ArrayInfo.ArrayPin = FindPin(ArrayPinNames[0]);
if(ArrayPinNames.Num() > 1)
{
ArrayInfo.ArrayPropPin = FindPin(ArrayPinNames[1]);
}
if(ArrayInfo.ArrayPin)
{
OutArrayPinInfo.Add(ArrayInfo);
}
}
}
/**
* Generates a list of assets from the GAME by a specific type.
*/
void FEditorAutomationTestUtilities::CollectGameContentByClass(const UClass * Class, bool bRecursiveClass, TArray<FString>& OutAssetList)
{
//Setting the Asset Registry
FAssetRegistryModule& AssetRegistryModule = FModuleManager::LoadModuleChecked<FAssetRegistryModule>(TEXT("AssetRegistry"));
//Variable setups
TArray<FAssetData> ObjectList;
FARFilter AssetFilter;
//Generating the list of assets.
//This list is being filtered by the game folder and class type. The results are placed into the ObjectList variable.
AssetFilter.ClassNames.Add(Class->GetFName());
AssetFilter.PackagePaths.Add("/Game");
AssetFilter.bRecursiveClasses = bRecursiveClass;
AssetFilter.bRecursivePaths = true;
AssetRegistryModule.Get().GetAssets(AssetFilter, ObjectList);
//Loop through the list of assets, make their path full and a string, then add them to the test.
for (auto ObjIter = ObjectList.CreateConstIterator(); ObjIter; ++ObjIter)
{
const FAssetData& Asset = *ObjIter;
FString Filename = Asset.ObjectPath.ToString();
//convert to full paths
Filename = FPackageName::LongPackageNameToFilename(Filename);
if (FAutomationTestFramework::GetInstance().ShouldTestContent(Filename))
{
OutAssetList.Add(Asset.ObjectPath.ToString());
}
}
}
void UK2Node_Select::PostReconstructNode()
{
bReconstructNode = false;
const UEdGraphSchema_K2* Schema = Cast<UEdGraphSchema_K2>(GetSchema());
UEdGraphPin* ReturnPin = GetReturnValuePin();
PinConnectionListChanged(ReturnPin);
const bool bFillTypeFromReturn = Schema && ReturnPin && (ReturnPin->PinType.PinCategory != Schema->PC_Wildcard);
TArray<UEdGraphPin*> OptionPins;
GetOptionPins(OptionPins);
for (auto It = OptionPins.CreateConstIterator(); It; It++)
{
UEdGraphPin* Pin = *It;
const bool bTypeShouldBeFilled = Schema && Pin && (Pin->PinType.PinCategory == Schema->PC_Wildcard);
if (bTypeShouldBeFilled && bFillTypeFromReturn)
{
Pin->Modify();
Pin->PinType = ReturnPin->PinType;
UEdGraphSchema_K2::ValidateExistingConnections(Pin);
}
PinConnectionListChanged(*It);
}
//After ReconstructNode we must be sure, that no additional reconstruction is required
bReconstructNode = false;
}
void UK2Node_CallArrayFunction::AllocateDefaultPins()
{
Super::AllocateDefaultPins();
const UEdGraphSchema_K2* Schema = GetDefault<UEdGraphSchema_K2>();
UEdGraphPin* TargetArrayPin = GetTargetArrayPin();
check(TargetArrayPin);
TargetArrayPin->PinType.bIsArray = true;
TargetArrayPin->PinType.bIsReference = true;
TargetArrayPin->PinType.PinCategory = Schema->PC_Wildcard;
TargetArrayPin->PinType.PinSubCategory = TEXT("");
TargetArrayPin->PinType.PinSubCategoryObject = NULL;
TArray< FArrayPropertyPinCombo > ArrayPins;
GetArrayPins(ArrayPins);
for(auto Iter = ArrayPins.CreateConstIterator(); Iter; ++Iter)
{
if(Iter->ArrayPropPin)
{
Iter->ArrayPropPin->bHidden = true;
Iter->ArrayPropPin->bNotConnectable = true;
Iter->ArrayPropPin->bDefaultValueIsReadOnly = true;
}
}
PropagateArrayTypeInfo(TargetArrayPin);
}
bool UK2Node_Select::CanChangePinType(UEdGraphPin* Pin) const
{
// If this is the index pin, only allow type switching if nothing is linked to the pin
if (Pin == GetIndexPin())
{
if (Pin->LinkedTo.Num() > 0)
{
return false;
}
}
// Else it's one of the wildcard pins that share their type, so make sure none of them have a link
else
{
if (GetReturnValuePin()->LinkedTo.Num() > 0)
{
return false;
}
else
{
TArray<UEdGraphPin*> OptionPins;
GetOptionPins(OptionPins);
for (auto It = OptionPins.CreateConstIterator(); It; It++)
{
UEdGraphPin* OptionPin = (*It);
if (OptionPin && OptionPin->LinkedTo.Num() > 0)
{
return false;
}
}
}
}
return true;
}
