static UEdGraph* FindGraphByName(UBlueprint const& FromBlueprint, const FName& GraphName)
{
TArray<UEdGraph*> Graphs;
FromBlueprint.GetAllGraphs(Graphs);
UEdGraph* Ret = nullptr;
if (UEdGraph** Result = Graphs.FindByPredicate(FMatchFName(GraphName)))
{
Ret = *Result;
}
return Ret;
}
IAssetEditorInstance* FAssetEditorManager::FindEditorForAsset(UObject* Asset, bool bFocusIfOpen)
{
const TArray<IAssetEditorInstance*> AssetEditors = FindEditorsForAsset(Asset);
IAssetEditorInstance* const * PrimaryEditor = AssetEditors.FindByPredicate( [](IAssetEditorInstance* Editor){ return Editor->IsPrimaryEditor(); } );
const bool bEditorOpen = PrimaryEditor != NULL;
if (bEditorOpen && bFocusIfOpen)
{
// @todo toolkit minor: We may need to handle this differently for world-centric vs standalone. (multiple level editors, etc)
(*PrimaryEditor)->FocusWindow(Asset);
}
return bEditorOpen ? *PrimaryEditor : NULL;
}
TSharedPtr<FPropertyEditorToolkit> FPropertyEditorToolkit::FindExistingEditor( UObject* Object )
{
// Find any existing property editor instances for this asset
const TArray<IAssetEditorInstance*> Editors = FAssetEditorManager::Get().FindEditorsForAsset( Object );
IAssetEditorInstance* const * ExistingInstance = Editors.FindByPredicate( [&]( IAssetEditorInstance* Editor ){
return Editor->GetEditorName() == ToolkitFName;
} );
if( ExistingInstance )
{
auto* PropertyEditor = static_cast<FPropertyEditorToolkit*>( *ExistingInstance );
return PropertyEditor->SharedThis( PropertyEditor );
}
return nullptr;
}
FReply FParticleSystemComponentDetails::OnResetEmitter()
{
const TArray< TWeakObjectPtr<UObject> >& SelectedObjects = DetailLayout->GetDetailsView().GetSelectedObjects();
// Iterate over selected Actors.
for (int32 Idx = 0; Idx < SelectedObjects.Num(); ++Idx)
{
if (SelectedObjects[Idx].IsValid())
{
UParticleSystemComponent* PSC = Cast<UParticleSystemComponent>(SelectedObjects[Idx].Get());
if (!PSC)
{
if (AEmitter* Emitter = Cast<AEmitter>(SelectedObjects[Idx].Get()))
{
PSC = Emitter->GetParticleSystemComponent();
}
}
// If the object selected to the details view is a template, then we need to redirect the reset to the preview instance (e.g. in the Blueprint editor).
// @todo Can remove this if we switch to instance-based editing in the Blueprint editor.
if (PSC && PSC->IsTemplate())
{
TArray<UObject*> Instances;
PSC->GetArchetypeInstances(Instances);
UObject** ElementPtr = Instances.FindByPredicate([](const UObject* Element)
{
const AActor* Owner = Cast<AActor>(Element->GetOuter());
return Owner != nullptr && FActorEditorUtils::IsAPreviewOrInactiveActor(Owner);
});
if (ElementPtr)
{
PSC = Cast<UParticleSystemComponent>(*ElementPtr);
}
}
if (PSC)
{
PSC->ResetParticles();
PSC->ActivateSystem();
}
}
}
return FReply::Handled();
}
static void AddSortedSpriteInfo(TArray<FSpriteCategoryInfo>& InOutSortedSpriteInfo, const FSpriteCategoryInfo& InSpriteInfo )
{
const FSpriteCategoryInfo* ExistingSpriteInfo = InOutSortedSpriteInfo.FindByPredicate([&InSpriteInfo](const FSpriteCategoryInfo& SpriteInfo){ return InSpriteInfo.Category == SpriteInfo.Category; });
if (ExistingSpriteInfo != NULL)
{
//Already present
checkSlow(ExistingSpriteInfo->DisplayName.EqualTo(InSpriteInfo.DisplayName)); //Catch mismatches between DisplayNames
}
else
{
// Add the category to the correct position in the array to keep it sorted
const int32 CatIndex = InOutSortedSpriteInfo.IndexOfByPredicate([&InSpriteInfo](const FSpriteCategoryInfo& SpriteInfo){ return InSpriteInfo.DisplayName.CompareTo( SpriteInfo.DisplayName ) < 0; });
if (CatIndex != INDEX_NONE)
{
InOutSortedSpriteInfo.Insert( InSpriteInfo, CatIndex );
}
else
{
InOutSortedSpriteInfo.Add( InSpriteInfo );
}
}
}
TArray<FVanillaPlatformEntry> BuildPlatformHierarchy(const EPlatformFilter InFilter)
{
TArray<FVanillaPlatformEntry> VanillaPlatforms;
// Build up a tree from the platforms we support (vanilla outers, with a list of flavors)
// PlatformInfoArray should be ordered in such a way that the vanilla platforms always appear before their flavors
for(const FPlatformInfo& PlatformInfo : PlatformInfoArray)
{
if(PlatformInfo.IsVanilla())
{
VanillaPlatforms.Add(FVanillaPlatformEntry(&PlatformInfo));
}
else
{
const bool bHasBuildFlavor = !!(PlatformInfo.PlatformFlags & EPlatformFlags::BuildFlavor);
const bool bHasCookFlavor = !!(PlatformInfo.PlatformFlags & EPlatformFlags::CookFlavor);
const bool bValidFlavor =
InFilter == EPlatformFilter::All ||
(InFilter == EPlatformFilter::BuildFlavor && bHasBuildFlavor) ||
(InFilter == EPlatformFilter::CookFlavor && bHasCookFlavor);
if(bValidFlavor)
{
const FName VanillaPlatformName = PlatformInfo.VanillaPlatformName;
FVanillaPlatformEntry* const VanillaEntry = VanillaPlatforms.FindByPredicate([VanillaPlatformName](const FVanillaPlatformEntry& Item) -> bool
{
return Item.PlatformInfo->PlatformInfoName == VanillaPlatformName;
});
check(VanillaEntry);
VanillaEntry->PlatformFlavors.Add(&PlatformInfo);
}
}
}
return VanillaPlatforms;
}
/**
* Take screenshots of the SME window with each of the toolbar buttons toggled separately
*/
bool FStaticMeshEditorTest::RunTest(const FString& Parameters)
{
TArray<FString> ButtonNamesToTestFor;
FString LoadedObjectType = TEXT("EditorCylinder");
FString MeshName;
EditorViewButtonHelper::PerformStaticMeshFlagParameters AutomationParameters;
WindowScreenshotParameters WindowParameters;
//Pull from .ini the names of the buttons we want to test for
GConfig->GetString( TEXT("AutomationTesting"), TEXT("EditorViewButtonsObject"), LoadedObjectType, GEngineIni);
//Open static mesh in the editor and save out the window for the screenshots
UObject* EditorMesh = (UStaticMesh*)StaticLoadObject(UStaticMesh::StaticClass(),
NULL,
*FString::Printf(TEXT("/Engine/EditorMeshes/%s.%s"), *LoadedObjectType, *LoadedObjectType),
NULL,
LOAD_None,
NULL);
FAssetEditorManager::Get().OpenEditorForAsset(EditorMesh);
{
TArray<TSharedRef<SWindow>> AllWindows;
FSlateApplication::Get().GetAllVisibleWindowsOrdered(AllWindows);
const FText ExpectedTitle = FText::FromString(LoadedObjectType);
if (auto* Window = AllWindows.FindByPredicate([&](const TSharedRef<SWindow>& In) { return In->GetTitle().EqualTo(ExpectedTitle); }))
{
WindowParameters.CurrentWindow = *Window;
}
}
if (!WindowParameters.CurrentWindow.IsValid())
{
AddError(TEXT("Could not find static mesh editor window"));
return false;
}
//Grab the last opened Viewport (aka the asset manager)
AutomationParameters.ViewportClient = static_cast<FStaticMeshEditorViewportClient*>(GEditor->AllViewportClients[GEditor->AllViewportClients.Num() - 1]);
AutomationParameters.CommandType = EditorViewButtonHelper::EStaticMeshFlag::Wireframe; //Start it off at Wireframe because that is the first button we are attempting to press
if (AutomationParameters.ViewportClient)
{
const FString BaseFileName = TEXT("StaticMeshEditorTest");
FString TestName = FString::Printf(TEXT("%s/Base"), *BaseFileName);
//Wait for the window to load and then take the initial screen shot
ADD_LATENT_AUTOMATION_COMMAND(FWaitLatentCommand(0.5f));
if( FAutomationTestFramework::GetInstance().IsScreenshotAllowed() )
{
AutomationCommon::GetScreenshotPath(TestName, WindowParameters.ScreenshotName, false);
ADD_LATENT_AUTOMATION_COMMAND(FTakeEditorScreenshotCommand(WindowParameters));
ADD_LATENT_AUTOMATION_COMMAND(FWaitLatentCommand(0.1f));
}
for(auto CurrentCommandType = 0; CurrentCommandType < EditorViewButtonHelper::EStaticMeshFlag::Max; ++CurrentCommandType)
{
TestName = FString::Printf(TEXT("%s/%s"), *BaseFileName, EditorViewButtonHelper::GetStaticMeshFlagName(AutomationParameters.CommandType));
//Toggle the command for the button, take a screenshot, and then re-toggle the command for the button
ADD_LATENT_AUTOMATION_COMMAND(EditorViewButtonHelper::FPerformStaticMeshFlagToggle(AutomationParameters));
ADD_LATENT_AUTOMATION_COMMAND(FWaitLatentCommand(0.1f));
if( FAutomationTestFramework::GetInstance().IsScreenshotAllowed() )
{
//Take the screenshot
AutomationCommon::GetScreenshotPath(TestName, WindowParameters.ScreenshotName, false);
ADD_LATENT_AUTOMATION_COMMAND(FTakeEditorScreenshotCommand(WindowParameters));
//Wait so the screenshots have a chance to save
ADD_LATENT_AUTOMATION_COMMAND(FWaitLatentCommand(0.1f));
}
//Toggle the flag back off
ADD_LATENT_AUTOMATION_COMMAND(EditorViewButtonHelper::FPerformStaticMeshFlagToggle(AutomationParameters));
//Increment to the next enum, so we can loop through all the types
AutomationParameters.CommandType = (EditorViewButtonHelper::EStaticMeshFlag::Type)((int)AutomationParameters.CommandType + 1);
}
ADD_LATENT_AUTOMATION_COMMAND(EditorViewButtonHelper::FCloseAllAssetEditorsCommand());
}
return true;
}
