FText FEnvDirection::ToText() const
{
if(DirMode == EEnvDirection::TwoPoints)
{
FFormatNamedArguments Args;
Args.Add(TEXT("LineFrom"), UEnvQueryTypes::DescribeContext(LineFrom));
Args.Add(TEXT("LineTo"), UEnvQueryTypes::DescribeContext(LineTo));
return FText::Format(LOCTEXT("DescribeLineFromAndTo", "[{LineFrom} - {LineTo}]"), Args);
}
else
{
FFormatNamedArguments Args;
Args.Add(TEXT("Rotation"), UEnvQueryTypes::DescribeContext(Rotation));
return FText::Format(LOCTEXT("DescribeRotation", "[{Rotation} rotation]"), Args);
}
}
FText UAnimGraphNode_BlendListByEnum::GetNodeTitle(ENodeTitleType::Type TitleType) const
{
if (BoundEnum == nullptr)
{
return LOCTEXT("AnimGraphNode_BlendListByEnum_TitleError", "ERROR: Blend Poses (by missing enum)");
}
// @TODO: don't know enough about this node type to comfortably assert that
// the BoundEnum won't change after the node has spawned... until
// then, we'll leave this optimization off
else //if (CachedNodeTitle.IsOutOfDate())
{
FFormatNamedArguments Args;
Args.Add(TEXT("EnumName"), FText::FromString(BoundEnum->GetName()));
// FText::Format() is slow, so we cache this to save on performance
CachedNodeTitle = FText::Format(LOCTEXT("AnimGraphNode_BlendListByEnum_Title", "Blend Poses ({EnumName})"), Args);
}
return CachedNodeTitle;
}
/** Diff result when a node comment was changed */
static void DiffR_NodeCommentChanged(FDiffResults& Results, class UEdGraphNode* Node, class UEdGraphNode* Node2)
{
if(Results)
{
FDiffSingleResult Diff;
Diff.Diff = EDiffType::NODE_COMMENT;
Diff.Node1 = Node;
Diff.Node2 = Node2;
FFormatNamedArguments Args;
Args.Add(TEXT("NodeTitle"), Node->GetNodeTitle(ENodeTitleType::ListView));
Diff.ToolTip = FText::Format(LOCTEXT("DIF_CommentModified", "Comment Modified Node '{NodeTitle}'"), Args);
Diff.DisplayString = Diff.ToolTip;
Diff.DisplayColor = FLinearColor(0.25f,0.4f,0.5f);
Results.Add(Diff);
}
}
FText UK2Node_VariableSetRef::GetNodeTitle(ENodeTitleType::Type TitleType) const
{
const UEdGraphSchema_K2* Schema = GetDefault<UEdGraphSchema_K2>();
UEdGraphPin* TargetPin = GetTargetPin();
if ((TargetPin == nullptr) || (TargetPin->PinType.PinCategory == Schema->PC_Wildcard))
{
return NSLOCTEXT("K2Node", "SetRefVarNodeTitle", "Set By-Ref Var");
}
else if (CachedNodeTitle.IsOutOfDate())
{
FFormatNamedArguments Args;
Args.Add(TEXT("PinType"), Schema->TypeToText(TargetPin->PinType));
// FText::Format() is slow, so we cache this to save on performance
CachedNodeTitle = FText::Format(NSLOCTEXT("K2Node", "SetRefVarNodeTitle_Typed", "Set {PinType}"), Args);
}
return CachedNodeTitle;
}
/** Diff result when a node was moved on the graph */
static void DiffR_NodeMoved(FDiffResults& Results, UEdGraphNode* Node, class UEdGraphNode* OtherNode)
{
if(Results)
{
FDiffSingleResult Diff;
Diff.Diff = EDiffType::NODE_MOVED;
Diff.Node1 = Node;
Diff.Node2 = OtherNode;
FFormatNamedArguments Args;
Args.Add(TEXT("NodeTitle"), Node->GetNodeTitle(ENodeTitleType::ListView));
Diff.ToolTip = FText::Format(LOCTEXT("DIF_MoveNode", "Moved Node '{NodeTitle}'"), Args);
Diff.DisplayString = Diff.ToolTip;
Diff.DisplayColor = FLinearColor(0.9f, 0.84f, 0.43f);
Results.Add(Diff);
}
}
FText FAssetEditorToolkit::GetDescriptionForObject(const UObject* InObject)
{
const bool bDirtyState = InObject->GetOutermost()->IsDirty();
FString NameString;
if(const AActor* ObjectAsActor = Cast<AActor>(InObject))
{
NameString = ObjectAsActor->GetActorLabel();
}
else
{
NameString = InObject->GetName();
}
FFormatNamedArguments Args;
Args.Add( TEXT("ObjectName"), FText::FromString( NameString ));
Args.Add( TEXT("DirtyState"), bDirtyState ? FText::FromString( TEXT( "*" ) ) : FText::GetEmpty() );
return FText::Format( LOCTEXT("AssetEditorAppLabel", "{ObjectName}{DirtyState}"), Args );
}
/** UI_COMMAND takes long for the compile to optimize */
PRAGMA_DISABLE_OPTIMIZATION
void FLevelEditorModesCommands::RegisterCommands()
{
EditorModeCommands.Empty();
int editorMode = 0;
FKey EdModeKeys[9] = { EKeys::One, EKeys::Two, EKeys::Three, EKeys::Four, EKeys::Five, EKeys::Six, EKeys::Seven, EKeys::Eight, EKeys::Nine };
for ( const FEditorModeInfo& Mode : FEditorModeRegistry::Get().GetSortedModeInfo() )
{
// If the mode isn't visible don't create a menu option for it.
if (!Mode.bVisible)
{
continue;
}
FName EditorModeCommandName = FName(*(FString("EditorMode.") + Mode.ID.ToString()));
TSharedPtr<FUICommandInfo> EditorModeCommand =
FInputBindingManager::Get().FindCommandInContext(GetContextName(), EditorModeCommandName);
// If a command isn't yet registered for this mode, we need to register one.
if ( !EditorModeCommand.IsValid() )
{
FFormatNamedArguments Args;
Args.Add( TEXT("Mode"), Mode.Name );
const FText Tooltip = FText::Format( NSLOCTEXT("LevelEditor", "ModeTooltipF", "Activate {Mode} Editing Mode"), Args );
FUICommandInfo::MakeCommandInfo(
this->AsShared(),
EditorModeCommand,
EditorModeCommandName,
Mode.Name,
Tooltip,
Mode.IconBrush,
EUserInterfaceActionType::ToggleButton,
editorMode < 9 ? FInputChord( EModifierKey::Shift, EdModeKeys[editorMode] ) : FInputChord() );
EditorModeCommands.Add(EditorModeCommand);
}
editorMode++;
}
}
ECommandResult::Type FSubversionSourceControlProvider::Execute( const TSharedRef<ISourceControlOperation, ESPMode::ThreadSafe>& InOperation, const TArray<FString>& InFiles, EConcurrency::Type InConcurrency, const FSourceControlOperationComplete& InOperationCompleteDelegate )
{
if(!IsEnabled())
{
return ECommandResult::Failed;
}
if(!SubversionSourceControlUtils::CheckFilenames(InFiles))
{
return ECommandResult::Failed;
}
TArray<FString> AbsoluteFiles = SourceControlHelpers::AbsoluteFilenames(InFiles);
// Query to see if the we allow this operation
TSharedPtr<ISubversionSourceControlWorker, ESPMode::ThreadSafe> Worker = CreateWorker(InOperation->GetName());
if(!Worker.IsValid())
{
// this operation is unsupported by this source control provider
FFormatNamedArguments Arguments;
Arguments.Add( TEXT("OperationName"), FText::FromName(InOperation->GetName()) );
Arguments.Add( TEXT("ProviderName"), FText::FromName(GetName()) );
FMessageLog("SourceControl").Error(FText::Format(LOCTEXT("UnsupportedOperation", "Operation '{OperationName}' not supported by source control provider '{ProviderName}'"), Arguments));
return ECommandResult::Failed;
}
// fire off operation
if(InConcurrency == EConcurrency::Synchronous)
{
FSubversionSourceControlCommand* Command = new FSubversionSourceControlCommand(InOperation, Worker.ToSharedRef());
Command->bAutoDelete = false;
Command->Files = AbsoluteFiles;
Command->OperationCompleteDelegate = InOperationCompleteDelegate;
return ExecuteSynchronousCommand(*Command, InOperation->GetInProgressString(), true);
}
else
{
FSubversionSourceControlCommand* Command = new FSubversionSourceControlCommand(InOperation, Worker.ToSharedRef());
Command->bAutoDelete = true;
Command->Files = AbsoluteFiles;
Command->OperationCompleteDelegate = InOperationCompleteDelegate;
return IssueCommand(*Command, false);
}
}
TSharedRef<SWidget> SSourceControlPicker::OnGetMenuContent() const
{
FSourceControlModule& SourceControlModule = FSourceControlModule::Get();
SourceControlModule.RefreshSourceControlProviders();
FMenuBuilder MenuBuilder(true, NULL);
// Get the provider names first so that we can sort them for the UI
TArray< TPair<FName, int32> > SortedProviderNames;
const int NumProviders = SourceControlModule.GetNumSourceControlProviders();
SortedProviderNames.Reserve(NumProviders);
for(int ProviderIndex = 0; ProviderIndex < NumProviders; ++ProviderIndex)
{
const FName ProviderName = SourceControlModule.GetSourceControlProviderName(ProviderIndex);
SortedProviderNames.Add(TPairInitializer<FName, int32>(ProviderName, ProviderIndex));
}
// Sort based on the provider name
SortedProviderNames.Sort([](const TPair<FName, int32>& One, const TPair<FName, int32>& Two)
{
return One.Key < Two.Key;
});
for(auto SortedProviderNameIter = SortedProviderNames.CreateConstIterator(); SortedProviderNameIter; ++SortedProviderNameIter)
{
const FText ProviderText = GetProviderText(SortedProviderNameIter->Key);
const int32 ProviderIndex = SortedProviderNameIter->Value;
FFormatNamedArguments Arguments;
Arguments.Add( TEXT("ProviderName"), ProviderText );
MenuBuilder.AddMenuEntry(
ProviderText,
FText::Format(LOCTEXT("SourceControlProvider_Tooltip", "Use {ProviderName} as source control provider"), Arguments),
FSlateIcon(),
FUIAction(
FExecuteAction::CreateSP( this, &SSourceControlPicker::ChangeSourceControlProvider, ProviderIndex ),
FCanExecuteAction()
)
);
}
return MenuBuilder.MakeWidget();
}
FText UK2Node_VariableGet::GetPropertyTooltip(UProperty const* VariableProperty)
{
FName VarName = NAME_None;
if (VariableProperty != nullptr)
{
VarName = VariableProperty->GetFName();
UClass* SourceClass = VariableProperty->GetOwnerClass();
// discover if the variable property is a non blueprint user variable
bool const bIsNativeVariable = (SourceClass != nullptr) && (SourceClass->ClassGeneratedBy == nullptr);
FName const TooltipMetaKey(TEXT("tooltip"));
FText SubTooltip;
if (bIsNativeVariable)
{
FText const PropertyTooltip = VariableProperty->GetToolTipText();
if (!PropertyTooltip.IsEmpty())
{
// See if the native property has a tooltip
SubTooltip = PropertyTooltip;
FString TooltipName = FString::Printf(TEXT("%s.%s"), *VarName.ToString(), *TooltipMetaKey.ToString());
FText::FindText(*VariableProperty->GetFullGroupName(true), *TooltipName, SubTooltip);
}
}
else if (UBlueprint* VarBlueprint = Cast<UBlueprint>(SourceClass->ClassGeneratedBy))
{
FString UserTooltipData;
if (FBlueprintEditorUtils::GetBlueprintVariableMetaData(VarBlueprint, VarName, /*InLocalVarScope =*/nullptr, TooltipMetaKey, UserTooltipData))
{
SubTooltip = FText::FromString(UserTooltipData);
}
}
if (!SubTooltip.IsEmpty())
{
FFormatNamedArguments Args;
Args.Add(TEXT("VarName"), FText::FromName(VarName));
Args.Add(TEXT("PropertyTooltip"), SubTooltip);
return FText::Format(LOCTEXT("GetVariableProperty_Tooltip", "Read the value of variable {VarName}\n{PropertyTooltip}"), Args);
}
}
return K2Node_VariableGetImpl::GetBaseTooltip(VarName);
}
FText UK2Node_LiveEditObject::GetNodeTitle(ENodeTitleType::Type TitleType) const
{
UEdGraphPin* BaseClassPin = GetBaseClassPin();
if ((BaseClassPin == nullptr) || (BaseClassPin->DefaultObject == nullptr))
{
return NSLOCTEXT("K2Node", "LiveEditObject_NullTitle", "LiveEditObject NONE");
}
else if (CachedNodeTitle.IsOutOfDate())
{
FNumberFormattingOptions NumberOptions;
NumberOptions.UseGrouping = false;
FFormatNamedArguments Args;
Args.Add(TEXT("SpawnString"), FText::FromName(BaseClassPin->DefaultObject->GetFName()));
Args.Add(TEXT("ID"), FText::AsNumber(GetUniqueID(), &NumberOptions));
CachedNodeTitle = FText::Format(NSLOCTEXT("K2Node", "LiveEditObject", "LiveEditObject {SpawnString}_{ID}"), Args);
}
return CachedNodeTitle;
}
FText FSimpleAssetEditor::GetToolkitName() const
{
const auto EditingObjects = GetEditingObjects();
check( EditingObjects.Num() > 0 );
FFormatNamedArguments Args;
Args.Add( TEXT("ToolkitName"), GetBaseToolkitName() );
if( EditingObjects.Num() == 1 )
{
const UObject* EditingObject = EditingObjects[ 0 ];
const bool bDirtyState = EditingObject->GetOutermost()->IsDirty();
Args.Add( TEXT("ObjectName"), FText::FromString( EditingObject->GetName() ) );
Args.Add( TEXT("DirtyState"), bDirtyState ? FText::FromString( TEXT( "*" ) ) : FText::GetEmpty() );
return FText::Format( LOCTEXT("ToolkitTitle", "{ObjectName}{DirtyState} - {ToolkitName}"), Args );
}
else
{
bool bDirtyState = false;
UClass* SharedBaseClass = NULL;
for( int32 x = 0; x < EditingObjects.Num(); ++x )
{
UObject* Obj = EditingObjects[ x ];
check( Obj );
UClass* ObjClass = Cast<UClass>(Obj);
if (ObjClass == NULL)
{
ObjClass = Obj->GetClass();
}
check( ObjClass );
// Initialize with the class of the first object we encounter.
if( SharedBaseClass == NULL )
{
SharedBaseClass = ObjClass;
}
// If we've encountered an object that's not a subclass of the current best baseclass,
// climb up a step in the class hierarchy.
while( !ObjClass->IsChildOf( SharedBaseClass ) )
{
SharedBaseClass = SharedBaseClass->GetSuperClass();
}
// If any of the objects are dirty, flag the label
bDirtyState |= Obj->GetOutermost()->IsDirty();
}
Args.Add( TEXT("NumberOfObjects"), EditingObjects.Num() );
Args.Add( TEXT("ClassName"), FText::FromString( SharedBaseClass->GetName() ) );
Args.Add( TEXT("DirtyState"), bDirtyState ? FText::FromString( TEXT( "*" ) ) : FText::GetEmpty() );
return FText::Format( LOCTEXT("ToolkitTitle_EditingMultiple", "{NumberOfObjects} {ClassName}{DirtyState} - {ToolkitName}"), Args );
}
}
FText UK2Node_Composite::GetNodeTitle(ENodeTitleType::Type TitleType) const
{
if (BoundGraph == nullptr)
{
return LOCTEXT("InvalidGraph", "Invalid Graph");
}
else if (TitleType != ENodeTitleType::FullTitle)
{
return FText::FromString(BoundGraph->GetName());
}
else if (CachedNodeTitle.IsOutOfDate(this)) // TitleType == ENodeTitleType::FullTitle
{
FFormatNamedArguments Args;
Args.Add(TEXT("BoundGraphName"), (BoundGraph) ? FText::FromString(BoundGraph->GetName()) : LOCTEXT("InvalidGraph", "Invalid Graph"));
// FText::Format() is slow, so we cache this to save on performance
CachedNodeTitle.SetCachedText(FText::Format(LOCTEXT("Collapsed_Name", "{BoundGraphName}\nCollapsed Graph"), Args), this);
}
return CachedNodeTitle;
}
void FWorldTileModel::FixupStreamingObjects()
{
check(LoadedLevel != NULL);
// Remove streaming levels that is not part of our world
UWorld* LevelWorld = CastChecked<UWorld>(LoadedLevel->GetOuter());
for(int32 LevelIndex = LevelWorld->StreamingLevels.Num() - 1; LevelIndex >= 0; --LevelIndex)
{
FName StreamingPackageName = LevelWorld->StreamingLevels[LevelIndex]->PackageName;
TSharedPtr<FLevelModel> LevelModel = LevelCollectionModel.FindLevelModel(StreamingPackageName);
if (!LevelModel.IsValid())
{
LevelWorld->StreamingLevels.RemoveAt(LevelIndex);
FFormatNamedArguments Arguments;
Arguments.Add(TEXT("LevelName"), FText::FromName(StreamingPackageName));
FMessageLog("MapCheck").Warning(FText::Format( LOCTEXT("MapCheck_Message_InvalidStreamingLevel", "Streaming level '{LevelName}' is not under the current world root. Fixed by removing from streaming list."), Arguments ) );
}
}
}
FText UK2Node_ActorBoundEvent::GetNodeTitle(ENodeTitleType::Type TitleType) const
{
if (EventOwner == nullptr)
{
FFormatNamedArguments Args;
Args.Add(TEXT("DelegatePropertyName"), FText::FromName(DelegatePropertyName));
return FText::Format(LOCTEXT("ActorBoundEventTitle", "{DelegatePropertyName} (None)"), Args);
}
else if (CachedNodeTitle.IsOutOfDate())
{
FFormatNamedArguments Args;
Args.Add(TEXT("DelegatePropertyName"), FText::FromName(DelegatePropertyName));
Args.Add(TEXT("TargetName"), FText::FromString(EventOwner->GetActorLabel()));
// FText::Format() is slow, so we cache this to save on performance
CachedNodeTitle = FText::Format(LOCTEXT("ActorBoundEventTitle", "{DelegatePropertyName} ({TargetName})"), Args);
}
return CachedNodeTitle;
}
bool LocalizationCommandletTasks::ImportTextForTarget(const TSharedRef<SWindow>& ParentWindow, ULocalizationTarget* const Target, const TOptional<FString> DirectoryPath)
{
TArray<LocalizationCommandletExecution::FTask> Tasks;
const bool ShouldUseProjectFile = !Target->IsMemberOfEngineTargetSet();
const FString ImportScriptPath = LocalizationConfigurationScript::GetImportTextConfigPath(Target, TOptional<FString>());
LocalizationConfigurationScript::GenerateImportTextConfigFile(Target, TOptional<FString>(), DirectoryPath).Write(ImportScriptPath);
Tasks.Add(LocalizationCommandletExecution::FTask(LOCTEXT("ImportTaskName", "Import Translations"), ImportScriptPath, ShouldUseProjectFile));
const FString ReportScriptPath = LocalizationConfigurationScript::GetWordCountReportConfigPath(Target);
LocalizationConfigurationScript::GenerateWordCountReportConfigFile(Target).Write(ReportScriptPath);
Tasks.Add(LocalizationCommandletExecution::FTask(LOCTEXT("ReportTaskName", "Generate Reports"), ReportScriptPath, ShouldUseProjectFile));
FFormatNamedArguments Arguments;
Arguments.Add(TEXT("TargetName"), FText::FromString(Target->Settings.Name));
const FText WindowTitle = FText::Format(LOCTEXT("ImportForTargetWindowTitle", "Import Translations for Target {TargetName}"), Arguments);
return LocalizationCommandletExecution::Execute(ParentWindow, WindowTitle, Tasks);
}
virtual TSharedRef<SWidget> GenerateWidgetForColumn( const FName& ColumnName )
{
if ( ColumnName == DeleteAssetsView::ColumnID_Asset )
{
return SNew( SHorizontalBox )
+ SHorizontalBox::Slot()
.AutoWidth()
.Padding( 3, 0, 0, 0 )
[
SNew( STextBlock )
.Text(FText::FromString(Item->GetObject()->GetName()))
];
}
else if ( ColumnName == DeleteAssetsView::ColumnID_AssetClass )
{
return SNew( STextBlock )
.Text(FText::FromString(Item->GetObject()->GetClass()->GetName()));
}
else if ( ColumnName == DeleteAssetsView::ColumnID_DiskReferences )
{
FFormatNamedArguments Args;
Args.Add( TEXT( "AssetCount" ), FText::AsNumber( Item->RemainingDiskReferences ) );
FText OnDiskCountText = Item->RemainingDiskReferences > 1 ? FText::Format( LOCTEXT( "OnDiskReferences", "{AssetCount} References" ), Args ) : FText::Format( LOCTEXT( "OnDiskReference", "{AssetCount} Reference" ), Args );
return SNew( STextBlock )
.Text( OnDiskCountText )
.Visibility( Item->RemainingDiskReferences > 0 ? EVisibility::Visible : EVisibility::Hidden );
}
else if ( ColumnName == DeleteAssetsView::ColumnID_MemoryReferences )
{
FFormatNamedArguments Args;
Args.Add( TEXT( "ReferenceCount" ), FText::AsNumber( Item->RemainingMemoryReferences ) );
FText InMemoryCountText = Item->RemainingMemoryReferences > 1 ? FText::Format( LOCTEXT( "InMemoryReferences", "{ReferenceCount} References" ), Args ) : FText::Format( LOCTEXT( "OnDiskReference", "{ReferenceCount} Reference" ), Args );
return SNew( STextBlock )
.Text( InMemoryCountText )
.Visibility( Item->RemainingMemoryReferences > 0 ? EVisibility::Visible : EVisibility::Hidden );
}
return SNullWidget::NullWidget;
}
bool LocalizationCommandletTasks::GatherTextForTargets(const TSharedRef<SWindow>& ParentWindow, const TArray<ULocalizationTarget*>& Targets)
{
TArray<LocalizationCommandletExecution::FTask> Tasks;
for (ULocalizationTarget* Target : Targets)
{
const bool ShouldUseProjectFile = !Target->IsMemberOfEngineTargetSet();
FFormatNamedArguments Arguments;
Arguments.Add(TEXT("TargetName"), FText::FromString(Target->Settings.Name));
const FText GatherTaskName = FText::Format(LOCTEXT("GatherTaskNameFormat", "Gather Text for {TargetName}"), Arguments);
const FString GatherScriptPath = LocalizationConfigurationScript::GetGatherTextConfigPath(Target);
LocalizationConfigurationScript::GenerateGatherTextConfigFile(Target).Write(GatherScriptPath);
Tasks.Add(LocalizationCommandletExecution::FTask(GatherTaskName, GatherScriptPath, ShouldUseProjectFile));
}
return LocalizationCommandletExecution::Execute(ParentWindow, LOCTEXT("GatherAllTargetsWindowTitle", "Gather Text for All Targets"), Tasks);
}
void FAssetTypeActions_AnimationAsset::OpenAssetEditor( const TArray<UObject*>& InObjects, TSharedPtr<IToolkitHost> EditWithinLevelEditor )
{
EToolkitMode::Type Mode = EditWithinLevelEditor.IsValid() ? EToolkitMode::WorldCentric : EToolkitMode::Standalone;
for (auto ObjIt = InObjects.CreateConstIterator(); ObjIt; ++ObjIt)
{
auto AnimAsset = Cast<UAnimationAsset>(*ObjIt);
if (AnimAsset != NULL)
{
USkeleton* AnimSkeleton = AnimAsset->GetSkeleton();
if (!AnimSkeleton)
{
FText ShouldRetargetMessage = LOCTEXT("ShouldRetargetAnimAsset_Message", "Could not find the skeleton for Anim '{AnimName}' Would you like to choose a new one?");
FFormatNamedArguments Arguments;
Arguments.Add( TEXT("AnimName"), FText::FromString(AnimAsset->GetName()));
if ( FMessageDialog::Open(EAppMsgType::YesNo, FText::Format(ShouldRetargetMessage, Arguments)) == EAppReturnType::Yes )
{
bool bDuplicateAssets = false;
TArray<UObject*> AnimAssets;
AnimAssets.Add(AnimAsset);
RetargetAssets(AnimAssets, bDuplicateAssets, true, EditWithinLevelEditor);
}
}
else if (AnimSkeleton)
{
const bool bBringToFrontIfOpen = false;
if (IAssetEditorInstance* EditorInstance = FAssetEditorManager::Get().FindEditorForAsset(AnimSkeleton, bBringToFrontIfOpen))
{
// The skeleton is already open in an editor.
// Tell persona that an animation asset was requested
EditorInstance->FocusWindow(AnimAsset);
}
else
{
FPersonaModule& PersonaModule = FModuleManager::LoadModuleChecked<FPersonaModule>( "Persona" );
PersonaModule.CreatePersona(Mode, EditWithinLevelEditor, AnimSkeleton, NULL, AnimAsset, NULL);
}
}
}
}
}
/** Diff result when a pin default value was changed, and is in use*/
static void DiffR_PinDefaultValueChanged(FDiffResults& Results, class UEdGraphPin* Pin2, class UEdGraphPin* Pin1)
{
if(Results)
{
FDiffSingleResult Diff;
Diff.Diff = EDiffType::PIN_DEFAULT_VALUE;
Diff.Pin1 = Pin1;
Diff.Pin2 = Pin2;
FFormatNamedArguments Args;
Args.Add(TEXT("PinNameForValue1"), FText::FromString(Pin2->PinName));
Args.Add(TEXT("PinValue1"), FText::FromString(Pin1->GetDefaultAsString()));
Args.Add(TEXT("PinValue2"), FText::FromString(Pin2->GetDefaultAsString()));
Diff.ToolTip = FText::Format(LOCTEXT("DIF_PinDefaultValueToolTip", "Pin '{PinNameForValue1}' Default Value was '{PinValue1}', but is now '{PinValue2}"), Args);
Diff.DisplayColor = FLinearColor(0.665f,0.13f,0.455f);
Diff.DisplayString = FText::Format(LOCTEXT("DIF_PinDefaultValue", "Pin Default '{PinNameForValue1}' '{PinValue1}' -> '{PinValue2}']"), Args);
Results.Add(Diff);
}
}
void SObjectNameEditableTextBox::OnTextChanged( const FText& InLabel )
{
FText TrimmedLabel = FText::TrimPrecedingAndTrailing(InLabel);
if (TrimmedLabel.IsEmpty())
{
TextBox->SetError(LOCTEXT( "RenameFailed_LeftBlank", "Names cannot be left blank" ));
}
else if (TrimmedLabel.ToString().Len() >= NAME_SIZE)
{
FFormatNamedArguments Arguments;
Arguments.Add( TEXT("CharCount"), NAME_SIZE );
TextBox->SetError(FText::Format(LOCTEXT("RenameFailed_TooLong", "Actor names must be less than {CharCount} characters long."), Arguments));
}
else
{
TextBox->SetError( FText::GetEmpty() );
}
}
FText UAnimGraphNode_FootPlacementIK::GetNodeTitle(ENodeTitleType::Type TitleType) const
{
FFormatNamedArguments Args;
Args.Add(TEXT("ControllerDescription"), GetControllerDescription());
Args.Add(TEXT("BoneName"), FText::FromName(Node.IKBone.BoneName));
if(TitleType == ENodeTitleType::ListView || TitleType == ENodeTitleType::MenuTitle)
{
if (Node.IKBone.BoneName == NAME_None)
{
return FText::Format(LOCTEXT("FootPlacementIK_MenuTitle", "{ControllerDescription}"), Args);
}
return FText::Format(LOCTEXT("FootPlacementIK_ListTitle", "{ControllerDescription} - Bone: {BoneName}"), Args);
}
else
{
return FText::Format(LOCTEXT("FootPlacementIK_FullTitle", "{ControllerDescription}\nBone: {BoneName}"), Args);
}
}
FText UK2Node_SpawnActorFromClass::GetNodeTitle(ENodeTitleType::Type TitleType) const
{
FText NodeTitle = NSLOCTEXT("K2Node", "SpawnActor_BaseTitle", "Spawn Actor from Class");
if (TitleType != ENodeTitleType::MenuTitle)
{
FText SpawnString = NSLOCTEXT("K2Node", "None", "NONE");
if (UEdGraphPin* ClassPin = GetClassPin())
{
if (ClassPin->LinkedTo.Num() > 0)
{
// Blueprint will be determined dynamically, so we don't have the name in this case
NodeTitle = NSLOCTEXT("K2Node", "SpawnActor_Title_Unknown", "SpawnActor");
}
else if (ClassPin->DefaultObject == nullptr)
{
NodeTitle = NSLOCTEXT("K2Node", "SpawnActor_Title_NONE", "SpawnActor NONE");
}
else
{
if (CachedNodeTitle.IsOutOfDate(this))
{
FText ClassName;
if (UClass* PickedClass = Cast<UClass>(ClassPin->DefaultObject))
{
ClassName = PickedClass->GetDisplayNameText();
}
FFormatNamedArguments Args;
Args.Add(TEXT("ClassName"), ClassName);
// FText::Format() is slow, so we cache this to save on performance
CachedNodeTitle.SetCachedText(FText::Format(NSLOCTEXT("K2Node", "SpawnActor", "SpawnActor {ClassName}"), Args), this);
}
NodeTitle = CachedNodeTitle;
}
}
else
{
NodeTitle = NSLOCTEXT("K2Node", "SpawnActor_Title_NONE", "SpawnActor NONE");
}
}
return NodeTitle;
}
FText UK2Node_PlayMovieScene::GetNodeTitle(ENodeTitleType::Type TitleType) const
{
UMovieScene* MovieScene = (MovieSceneBindings != nullptr) ? MovieSceneBindings->GetRootMovieScene() : nullptr;
if (MovieScene == nullptr)
{
return NSLOCTEXT("PlayMovieSceneNode", "NodeTitleWithNoMovieScene", "Play Movie Scene (No Asset)");
}
// @TODO: don't know enough about this node type to comfortably assert that
// the MovieScene won't change after the node has spawned... until
// then, we'll leave this optimization off
else //if (CachedNodeTitle.IsOutOfDate(this))
{
FFormatNamedArguments Args;
Args.Add(TEXT("SceneName"), FText::FromString(MovieScene->GetName()));
// FText::Format() is slow, so we cache this to save on performance
CachedNodeTitle.SetCachedText(FText::Format(NSLOCTEXT("PlayMovieSceneNode", "NodeTitle", "Play Movie Scene: {SceneName}"), Args), this);
}
return CachedNodeTitle;
}
FText UK2Node_VariableGet::GetNodeTitle(ENodeTitleType::Type TitleType) const
{
// If there is only one variable being read, the title can be made the variable name
FString OutputPinName;
int32 NumOutputsFound = 0;
for (int32 PinIndex = 0; PinIndex < Pins.Num(); ++PinIndex)
{
UEdGraphPin* Pin = Pins[PinIndex];
// The following code is to attempt to log info related to UE-19729
if (TitleType == ENodeTitleType::ListView)
{
if (UEdGraph* Graph = Cast<UEdGraph>(GetOuter()))
{
FString VariableName = GetVarNameString();
FString BlueprintPath = FBlueprintEditorUtils::FindBlueprintForGraph(Graph)->GetPathName();
FString SetupStyle = bIsPureGet? TEXT("pure") : TEXT("validated");
FString VariableResolves = (VariableReference.ResolveMember<UProperty>(GetBlueprintClassFromNode()) != nullptr)? TEXT("resolves") : TEXT("does not resolve");
checkf(Pin, TEXT("Get node for variable '%s' in Blueprint '%s' which is setup as %s and has %d pins. Variable %s"), *VariableName, *BlueprintPath, *SetupStyle, Pins.Num(), *VariableResolves);
}
}
if (Pin->Direction == EGPD_Output)
{
++NumOutputsFound;
OutputPinName = Pin->PinName;
}
}
if (NumOutputsFound != 1)
{
return LOCTEXT("Get", "Get");
}
else if (CachedNodeTitle.IsOutOfDate(this))
{
FFormatNamedArguments Args;
Args.Add(TEXT("PinName"), FText::FromString(OutputPinName));
// FText::Format() is slow, so we cache this to save on performance
CachedNodeTitle.SetCachedText(FText::Format(LOCTEXT("GetPinName", "Get {PinName}"), Args), this);
}
return CachedNodeTitle;
}
void SDistributionCurveEditor::TabNameCommitted(const FText& CommentText, ETextCommit::Type CommitInfo)
{
if (CommitInfo == ETextCommit::OnEnter)
{
if (CommentText.IsEmpty())
{
FMessageDialog::Open(EAppMsgType::Ok, FText( LOCTEXT( "EmptyTabName", "Tab must be given a name") ) );
}
else
{
bool bFound = false;
// Verify that the name is not already in use
for (int32 TabIndex = 0; TabIndex < SharedData->EdSetup->Tabs.Num(); TabIndex++)
{
FCurveEdTab* Tab = &SharedData->EdSetup->Tabs[TabIndex];
if (Tab->TabName == CommentText.ToString())
{
FFormatNamedArguments Arguments;
Arguments.Add(TEXT("Name"), CommentText);
FMessageDialog::Open(EAppMsgType::Ok, FText::Format( LOCTEXT( "TabNameInUse", "Name '{Name}' already in use!" ), Arguments ));
bFound = true;
break;
}
}
if (!bFound)
{
// Add the tab, and set the active tab to it.
SharedData->EdSetup->CreateNewTab( *CommentText.ToString() );
SharedData->EdSetup->ActiveTab = TabNames.Num();
TabNames.Add(MakeShareable(new FString( *CommentText.ToString() )));
SelectedTab = TabNames[TabNames.Num() - 1];
TabNamesComboBox->RefreshOptions();
SetTabSelection(SelectedTab, true);
}
}
}
CloseEntryPopup();
}
bool UMaterialGraphSchema::ArePinsCompatible(const UEdGraphPin* InputPin, const UEdGraphPin* OutputPin, FText& ResponseMessage) const
{
UMaterialGraphNode_Base* InputNode = CastChecked<UMaterialGraphNode_Base>(InputPin->GetOwningNode());
UMaterialGraphNode* OutputNode = CastChecked<UMaterialGraphNode>(OutputPin->GetOwningNode());
uint32 InputType = InputNode->GetInputType(InputPin);
uint32 OutputType = OutputNode->GetOutputType(OutputPin);
bool bPinsCompatible = CanConnectMaterialValueTypes(InputType, OutputType);
if (!bPinsCompatible)
{
TArray<FText> InputDescriptions;
TArray<FText> OutputDescriptions;
GetMaterialValueTypeDescriptions(InputType, InputDescriptions);
GetMaterialValueTypeDescriptions(OutputType, OutputDescriptions);
FString CombinedInputDescription;
FString CombinedOutputDescription;
for (int32 Index = 0; Index < InputDescriptions.Num(); ++Index)
{
if ( CombinedInputDescription.Len() > 0 )
{
CombinedInputDescription += TEXT(", ");
}
CombinedInputDescription += InputDescriptions[Index].ToString();
}
for (int32 Index = 0; Index < OutputDescriptions.Num(); ++Index)
{
if ( CombinedOutputDescription.Len() > 0 )
{
CombinedOutputDescription += TEXT(", ");
}
CombinedOutputDescription += OutputDescriptions[Index].ToString();
}
FFormatNamedArguments Args;
Args.Add( TEXT("InputType"), FText::FromString(CombinedInputDescription) );
Args.Add( TEXT("OutputType"), FText::FromString(CombinedOutputDescription) );
ResponseMessage = FText::Format( LOCTEXT("IncompatibleDesc", "{OutputType} is not compatible with {InputType}"), Args );
}
return bPinsCompatible;
}
FText UK2Node_AddComponent::GetNodeTitle(ENodeTitleType::Type TitleType) const
{
FText CachedAssetTitle;
FText CachedNodeTitle;
UEdGraphPin* TemplateNamePin = GetTemplateNamePin();
if (TemplateNamePin != nullptr)
{
FString TemplateName = TemplateNamePin->DefaultValue;
UBlueprint* Blueprint = GetBlueprint();
if (UActorComponent* SourceTemplate = Blueprint->FindTemplateByName(FName(*TemplateName)))
{
{
FFormatNamedArguments Args;
Args.Add(TEXT("ComponentType"), SourceTemplate->GetClass()->GetDisplayNameText());
CachedNodeTitle = FText::Format(LOCTEXT("AddClass", "Add {ComponentType}"), Args);
}
UChildActorComponent* SubActorComp = Cast<UChildActorComponent>(SourceTemplate);
if (const UObject* AssociatedAsset = SourceTemplate->AdditionalStatObject())
{
FFormatNamedArguments Args;
Args.Add(TEXT("AssetType"), AssociatedAsset->GetClass()->GetDisplayNameText());
Args.Add(TEXT("AssetName"), FText::FromString(AssociatedAsset->GetName()));
CachedAssetTitle = FText::Format(LOCTEXT("AddComponentAssetDescription", "{AssetType} {AssetName}"), Args);
}
else if ((SubActorComp != nullptr) && (SubActorComp->GetChildActorClass() != nullptr))
{
FFormatNamedArguments Args;
Args.Add(TEXT("ComponentClassName"), SubActorComp->GetChildActorClass()->GetDisplayNameText());
CachedAssetTitle = FText::Format(LOCTEXT("AddChildActorComponent", "Actor Class {ComponentClassName}"), Args);
}
else
{
CachedAssetTitle = FText::GetEmpty();
}
}
}
if (!CachedNodeTitle.IsEmpty())
{
if (TitleType == ENodeTitleType::FullTitle)
{
return FText::Format(LOCTEXT("FullAddComponentTitle", "{0}\n{1}"), CachedNodeTitle, CachedAssetTitle);
}
else if (!CachedAssetTitle.IsEmpty())
{
return FText::Format(LOCTEXT("ShortAddComponentTitle", "{0} [{1}]"), CachedNodeTitle, CachedAssetTitle);
}
else
{
return CachedNodeTitle;
}
}
return Super::GetNodeTitle(TitleType);
}
void FMaterialEditorUtilities::AddMaterialExpressionCategory(FGraphActionMenuBuilder& ActionMenuBuilder, FString CategoryName, TArray<struct FMaterialExpression>* MaterialExpressions, bool bMaterialFunction)
{
for (int32 Index = 0; Index < MaterialExpressions->Num(); ++Index)
{
const FMaterialExpression& MaterialExpression = (*MaterialExpressions)[Index];
if (IsAllowedExpressionType(MaterialExpression.MaterialClass, bMaterialFunction))
{
FFormatNamedArguments Arguments;
Arguments.Add(TEXT("Name"), FText::FromString( *MaterialExpression.Name ));
const FText ToolTip = FText::Format( LOCTEXT( "NewMaterialExpressionTooltip", "Adds a {Name} node here" ), Arguments );
TSharedPtr<FMaterialGraphSchemaAction_NewNode> NewNodeAction(new FMaterialGraphSchemaAction_NewNode(
CategoryName,
MaterialExpression.Name,
ToolTip.ToString(), 0));
ActionMenuBuilder.AddAction(NewNodeAction);
NewNodeAction->MaterialExpressionClass = MaterialExpression.MaterialClass;
NewNodeAction->Keywords = CastChecked<UMaterialExpression>(MaterialExpression.MaterialClass->GetDefaultObject())->GetKeywords();
}
}
}
FText UK2Node_InputKey::GetNodeTitle(ENodeTitleType::Type TitleType) const
{
if (bControl || bAlt || bShift || bCommand)
{
if (CachedNodeTitle.IsOutOfDate())
{
FFormatNamedArguments Args;
Args.Add(TEXT("ModifierKey"), GetModifierText());
Args.Add(TEXT("Key"), GetKeyText());
// FText::Format() is slow, so we cache this to save on performance
CachedNodeTitle = FText::Format(NSLOCTEXT("K2Node", "InputKey_Name_WithModifiers", "{ModifierKey} {Key}"), Args);
}
return CachedNodeTitle;
}
else
{
return GetKeyText();
}
}
