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(); } }