void FCompilerResultsLog::InternalLogSummary()
{
if(CurrentEventScope.IsValid())
{
const double CompileStartTime = CurrentEventScope->StartTime;
const double CompileFinishTime = CurrentEventScope->FinishTime;
FNumberFormattingOptions TimeFormat;
TimeFormat.MaximumFractionalDigits = 2;
TimeFormat.MinimumFractionalDigits = 2;
TimeFormat.MaximumIntegralDigits = 4;
TimeFormat.MinimumIntegralDigits = 4;
TimeFormat.UseGrouping = false;
FFormatNamedArguments Args;
Args.Add(TEXT("Time"), FText::AsNumber(CompileFinishTime - GStartTime, &TimeFormat));
Args.Add(TEXT("SourceName"), FText::FromString(SourceName));
Args.Add(TEXT("NumWarnings"), NumWarnings);
Args.Add(TEXT("NumErrors"), NumErrors);
Args.Add(TEXT("TotalMilliseconds"), (int)((CompileFinishTime - CompileStartTime) * 1000));
if (NumErrors > 0)
{
FString FailMsg = FText::Format(LOCTEXT("CompileFailed", "[{Time}] Compile of {SourceName} failed. {NumErrors} Fatal Issue(s) {NumWarnings} Warning(s) [in {TotalMilliseconds} ms]"), Args).ToString();
Warning(*FailMsg);
}
else if(NumWarnings > 0)
{
FString WarningMsg = FText::Format(LOCTEXT("CompileWarning", "[{Time}] Compile of {SourceName} successful, but with {NumWarnings} Warning(s) [in {TotalMilliseconds} ms]"), Args).ToString();
Warning(*WarningMsg);
}
else
{
FString SuccessMsg = FText::Format(LOCTEXT("CompileSuccess", "[{Time}] Compile of {SourceName} successful! [in {TotalMilliseconds} ms]"), Args).ToString();
Note(*SuccessMsg);
}
if(bLogDetailedResults)
{
Note(*LOCTEXT("PerformanceSummaryHeading", "Performance summary:").ToString());
InternalLogEvent(*CurrentEventScope.Get());
}
}
}
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_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;
}
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_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;
}
void UEdGraphSchema_BehaviorTreeDecorator::GetBreakLinkToSubMenuActions( class FMenuBuilder& MenuBuilder, UEdGraphPin* InGraphPin )
{
// Make sure we have a unique name for every entry in the list
TMap< FString, uint32 > LinkTitleCount;
// Add all the links we could break from
for(TArray<class UEdGraphPin*>::TConstIterator Links(InGraphPin->LinkedTo); Links; ++Links)
{
UEdGraphPin* Pin = *Links;
FString TitleString = Pin->GetOwningNode()->GetNodeTitle(ENodeTitleType::ListView).ToString();
FText Title = FText::FromString( TitleString );
if ( Pin->PinName != TEXT("") )
{
TitleString = FString::Printf(TEXT("%s (%s)"), *TitleString, *Pin->PinName);
// Add name of connection if possible
FFormatNamedArguments Args;
Args.Add( TEXT("NodeTitle"), Title );
Args.Add( TEXT("PinName"), Pin->GetDisplayName() );
Title = FText::Format( LOCTEXT("BreakDescPin", "{NodeTitle} ({PinName})"), Args );
}
uint32 &Count = LinkTitleCount.FindOrAdd( TitleString );
FText Description;
FFormatNamedArguments Args;
Args.Add( TEXT("NodeTitle"), Title );
Args.Add( TEXT("NumberOfNodes"), Count );
if ( Count == 0 )
{
Description = FText::Format( LOCTEXT("BreakDesc", "Break link to {NodeTitle}"), Args );
}
else
{
Description = FText::Format( LOCTEXT("BreakDescMulti", "Break link to {NodeTitle} ({NumberOfNodes})"), Args );
}
++Count;
MenuBuilder.AddMenuEntry( Description, Description, FSlateIcon(), FUIAction(
FExecuteAction::CreateUObject((USoundClassGraphSchema*const)this, &USoundClassGraphSchema::BreakSinglePinLink, const_cast< UEdGraphPin* >(InGraphPin), *Links) ) );
}
}
/** 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);
}
}
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;
}
void UPhysicsConstraintComponent::CheckForErrors()
{
Super::CheckForErrors();
UPrimitiveComponent* PrimComp1 = GetComponentInternal(EConstraintFrame::Frame1);
UPrimitiveComponent* PrimComp2 = GetComponentInternal(EConstraintFrame::Frame2);
// Check we have something to joint
if( PrimComp1 == NULL && PrimComp2 == NULL )
{
FFormatNamedArguments Arguments;
Arguments.Add(TEXT("OwnerName"), FText::FromString(GetNameSafe(GetOwner())));
FMessageLog("MapCheck").Warning()
->AddToken(FUObjectToken::Create(this))
->AddToken(FTextToken::Create(FText::Format( LOCTEXT("NoComponentsFound","{OwnerName} : No components found to joint."), Arguments ) ));
}
// Make sure constraint components are not both static.
else if ( PrimComp1 != NULL && PrimComp2 != NULL )
{
if ( PrimComp1->Mobility != EComponentMobility::Movable && PrimComp2->Mobility != EComponentMobility::Movable )
{
FFormatNamedArguments Arguments;
Arguments.Add(TEXT("OwnerName"), FText::FromString(GetNameSafe(GetOwner())));
FMessageLog("MapCheck").Warning()
->AddToken(FUObjectToken::Create(this))
->AddToken(FTextToken::Create(FText::Format( LOCTEXT("BothComponentsStatic","{OwnerName} : Both components are static."), Arguments ) ));
}
}
else
{
// At this point, we know one constraint component is NULL and the other is non-NULL.
// Check that the non-NULL constraint component is dynamic.
if ( ( PrimComp1 == NULL && PrimComp2->Mobility != EComponentMobility::Movable ) ||
( PrimComp2 == NULL && PrimComp1->Mobility != EComponentMobility::Movable ) )
{
FFormatNamedArguments Arguments;
Arguments.Add(TEXT("OwnerName"), FText::FromString(GetNameSafe(GetOwner())));
FMessageLog("MapCheck").Warning()
->AddToken(FUObjectToken::Create(this))
->AddToken(FTextToken::Create(FText::Format( LOCTEXT("SingleStaticComponent","{OwnerName} : Connected to single static component."), Arguments ) ));
}
}
}
void FLandscapeTextureBakingNotificationImpl::SetNotificationText(const TSharedPtr<SNotificationItem>& InNotificationItem) const
{
if (ALandscapeProxy::TotalComponentsNeedingTextureBaking > 0)
{
FFormatNamedArguments Args;
Args.Add(TEXT("OutstandingTextures"), FText::AsNumber(ALandscapeProxy::TotalComponentsNeedingTextureBaking));
const FText ProgressMessage = FText::Format(NSLOCTEXT("TextureBaking", "TextureBakingFormat", "Baking Landscape Textures ({OutstandingTextures})"), Args);
InNotificationItem->SetText(ProgressMessage);
}
}
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;
}
/**
* Returns the friendly, localized string name of this key binding
* @todo Slate: Got to be a better way to do this
*/
FText FInputChord::GetInputText( ) const
{
#if PLATFORM_MAC
const FText CommandText = LOCTEXT("KeyName_Control", "Ctrl");
const FText ControlText = LOCTEXT("KeyName_Command", "Cmd");
#else
const FText ControlText = LOCTEXT("KeyName_Control", "Ctrl");
const FText CommandText = LOCTEXT("KeyName_Command", "Cmd");
#endif
const FText AltText = LOCTEXT("KeyName_Alt", "Alt");
const FText ShiftText = LOCTEXT("KeyName_Shift", "Shift");
const FText AppenderText = LOCTEXT("ModAppender", "+");
FFormatNamedArguments Args;
int32 ModCount = 0;
if (bCtrl)
{
Args.Add(FString::Printf(TEXT("Mod%d"),++ModCount), ControlText);
}
if (bCmd)
{
Args.Add(FString::Printf(TEXT("Mod%d"),++ModCount), CommandText);
}
if (bAlt)
{
Args.Add(FString::Printf(TEXT("Mod%d"),++ModCount), AltText);
}
if (bShift)
{
Args.Add(FString::Printf(TEXT("Mod%d"),++ModCount), ShiftText);
}
for (int32 i = 1; i <= 4; ++i)
{
if (i > ModCount)
{
Args.Add(FString::Printf(TEXT("Mod%d"), i), FText::GetEmpty());
Args.Add(FString::Printf(TEXT("Appender%d"), i), FText::GetEmpty());
}
else
{
Args.Add(FString::Printf(TEXT("Appender%d"), i), AppenderText);
}
}
Args.Add(TEXT("Key"), GetKeyText());
return FText::Format(LOCTEXT("FourModifiers", "{Mod1}{Appender1}{Mod2}{Appender2}{Mod3}{Appender3}{Mod4}{Appender4}{Key}"), Args);
}
FText UK2Node_DelegateSet::GetNodeTitle(ENodeTitleType::Type TitleType) const
{
if (CachedNodeTitle.IsOutOfDate(this))
{
FFormatNamedArguments Args;
Args.Add(TEXT("DelegatePropertyName"), FText::FromName(DelegatePropertyName));
// FText::Format() is slow, so we cache this to save on performance
CachedNodeTitle.SetCachedText(FText::Format(NSLOCTEXT("K2Node", "Assign_Name", "Assign {DelegatePropertyName}"), Args), this);
}
return CachedNodeTitle;
}
FText UK2Node_StructMemberGet::GetNodeTitle(ENodeTitleType::Type TitleType) const
{
if (CachedNodeTitle.IsOutOfDate(this))
{
FFormatNamedArguments Args;
Args.Add(TEXT("VariableName"), FText::FromString(GetVarNameString()));
// FText::Format() is slow, so we cache this to save on performance
CachedNodeTitle.SetCachedText(FText::Format(LOCTEXT("GetMembersInVariable", "Get members in {VariableName}"), Args), this);
}
return CachedNodeTitle;
}
FText UK2Node_TemporaryVariable::GetTooltipText() const
{
if (CachedTooltip.IsOutOfDate(this))
{
FFormatNamedArguments Args;
Args.Add(TEXT("VariableType"), UEdGraphSchema_K2::TypeToText(VariableType));
// FText::Format() is slow, so we cache this to save on performance
CachedTooltip.SetCachedText(FText::Format(NSLOCTEXT("K2Node", "LocalTemporaryVariable_Tooltip", "Local temporary {VariableType} variable"), Args), this);
}
return CachedTooltip;
}
void FShaderCompilingNotificationImpl::SetNotificationText(const TSharedPtr<SNotificationItem>& InNotificationItem) const
{
if (GShaderCompilingManager->IsCompiling())
{
FFormatNamedArguments Args;
Args.Add(TEXT("ShaderJobs"), FText::AsNumber(GShaderCompilingManager->GetNumRemainingJobs()));
const FText ProgressMessage = FText::Format(NSLOCTEXT("ShaderCompile", "ShaderCompileInProgressFormat", "Compiling Shaders ({ShaderJobs})"), Args);
InNotificationItem->SetText(ProgressMessage);
}
}
FText UK2Node_CustomEvent::GetNodeTitle(ENodeTitleType::Type TitleType) const
{
if (TitleType != ENodeTitleType::FullTitle)
{
return FText::FromName(CustomFunctionName);
}
else if (CachedNodeTitle.IsOutOfDate())
{
FString RPCString = UK2Node_Event::GetLocalizedNetString(FunctionFlags, false);
FFormatNamedArguments Args;
Args.Add(TEXT("FunctionName"), FText::FromName(CustomFunctionName));
Args.Add(TEXT("RPCString"), FText::FromString(RPCString));
// FText::Format() is slow, so we cache this to save on performance
CachedNodeTitle = FText::Format(NSLOCTEXT("K2Node", "CustomEvent_Name", "{FunctionName}{RPCString}\nCustom Event"), Args);
}
return CachedNodeTitle;
}
FText UAnimGraphNode_TwistCorrectiveNode::GetNodeTitle(ENodeTitleType::Type TitleType) const
{
if ((Node.BaseFrame.Bone.BoneName == NAME_None) && (Node.TwistFrame.Bone.BoneName == NAME_None)
&& ((TitleType == ENodeTitleType::ListView) || (TitleType == ENodeTitleType::MenuTitle)))
{
return GetControllerDescription();
}
else
{
FText FormattedText;
FFormatNamedArguments Args;
Args.Add(TEXT("BaseBone"), FText::FromName(Node.BaseFrame.Bone.BoneName));
Args.Add(TEXT("TwistBone"), FText::FromName(Node.TwistFrame.Bone.BoneName));
Args.Add(TEXT("CurveName"), FText::FromName(Node.Curve.Name));
FormattedText = FText::Format(LOCTEXT("AnimGraphNode_TwistCorrectiveNode_Title", "Twist {CurveName} = {BaseBone}:{TwistBone} "), Args);
return FormattedText;
}
}
FText UK2Node_StructMemberGet::GetTooltipText() const
{
if (CachedTooltip.IsOutOfDate(this))
{
FFormatNamedArguments Args;
Args.Add(TEXT("VariableName"), FText::FromString(GetVarNameString()));
// FText::Format() is slow, so we cache this to save on performance
CachedTooltip.SetCachedText(FText::Format(LOCTEXT("K2Node_StructMemberGet_Tooltip", "Get member variables of {VariableName}"), Args), this);
}
return CachedTooltip;
}
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();
}
}
void FKCHandler_VariableSet::RegisterNets(FKismetFunctionContext& Context, UEdGraphNode* Node)
{
if(UK2Node_Variable* SetterNode = Cast<UK2Node_Variable>(Node))
{
SetterNode->CheckForErrors(CompilerContext.GetSchema(), Context.MessageLog);
if(FBlueprintEditorUtils::IsPropertyReadOnlyInCurrentBlueprint(Context.Blueprint, SetterNode->GetPropertyForVariable()))
{
CompilerContext.MessageLog.Warning(*LOCTEXT("BlueprintReadOnlyOrPrivate_Error", "The property is marked as BlueprintReadOnly or Private. It cannot be modifed in the blueprint. @@").ToString(), Node);
}
// Report an error that the local variable could not be found
if(SetterNode->VariableReference.IsLocalScope() && SetterNode->GetPropertyForVariable() == NULL)
{
FFormatNamedArguments Args;
Args.Add(TEXT("VariableName"), FText::FromName(SetterNode->VariableReference.GetMemberName()));
if(SetterNode->VariableReference.GetMemberScopeName() != Context.Function->GetName())
{
Args.Add(TEXT("ScopeName"), FText::FromString(SetterNode->VariableReference.GetMemberScopeName()));
CompilerContext.MessageLog.Warning(*FText::Format(LOCTEXT("LocalVariableNotFoundInScope_Error", "Unable to find local variable with name '{VariableName}' for @@, scope expected: @@, scope found: {ScopeName}"), Args).ToString(), Node, Node->GetGraph());
}
else
{
CompilerContext.MessageLog.Warning(*FText::Format(LOCTEXT("LocalVariableNotFound_Error", "Unable to find local variable with name '{VariableName}' for @@"), Args).ToString(), Node);
}
}
}
for (int32 PinIndex = 0; PinIndex < Node->Pins.Num(); ++PinIndex)
{
UEdGraphPin* Net = Node->Pins[PinIndex];
if (!CompilerContext.GetSchema()->IsMetaPin(*Net) && (Net->Direction == EGPD_Input))
{
if (ValidateAndRegisterNetIfLiteral(Context, Net))
{
RegisterNet(Context, Net);
}
}
}
}
void FWebBrowserHandler::OnLoadError(CefRefPtr<CefBrowser> Browser,
CefRefPtr<CefFrame> Frame,
CefLoadHandler::ErrorCode InErrorCode,
const CefString& ErrorText,
const CefString& FailedUrl)
{
// Don't display an error for downloaded files.
if (InErrorCode == ERR_ABORTED)
return;
// Display a load error message.
FFormatNamedArguments Args;
Args.Add(TEXT("FailedUrl"), FText::FromString(FailedUrl.c_str()));
Args.Add(TEXT("ErrorText"), FText::FromString(ErrorText.c_str()));
Args.Add(TEXT("ErrorCode"), FText::AsNumber(InErrorCode));
FText ErrorMsg = FText::Format(LOCTEXT("WebBrowserLoadError", "Failed to load URL {FailedUrl} with error {ErrorText} ({ErrorCode})."), Args);
FString ErrorHTML = TEXT("<html><body bgcolor=\"white\"><h2>")
+ ErrorMsg.ToString()
+ TEXT("</h2></body></html>");
Frame->LoadString(*ErrorHTML, FailedUrl);
}
void FTextureStreamingNotificationImpl::SetNotificationText(const TSharedPtr<SNotificationItem>& InNotificationItem) const
{
const int32 NumStreamingTextures = GetNumStreamingTextures();
if (NumStreamingTextures > 0)
{
FFormatNamedArguments Args;
Args.Add(TEXT("NumTextures"), FText::AsNumber(NumStreamingTextures));
const FText ProgressMessage = FText::Format(NSLOCTEXT("StreamingTextures", "StreamingTexturesInProgressFormat", "Streaming Textures ({NumTextures})"), Args);
InNotificationItem->SetText(ProgressMessage);
}
}
bool FPluginHelpers::WriteOutputFile(const FString& OutputFilename, const FString& OutputFileContents, FText& OutFailReason)
{
if (FFileHelper::SaveStringToFile(OutputFileContents, *OutputFilename))
{
return true;
}
FFormatNamedArguments Args;
Args.Add(TEXT("OutputFilename"), FText::FromString(OutputFilename));
OutFailReason = FText::Format(LOCTEXT("FailedToWriteOutputFile", "Failed to write output file \"{OutputFilename}\". Perhaps the file is Read-Only?"), Args);
return false;
}
FText UK2Node_TransitionRuleGetter::GetNodeTitle(ENodeTitleType::Type TitleType) const
{
// @TODO: FText::Format() is slow... consider caching this tooltip like
// we do for a lot of the BP nodes now (unfamiliar with this
// node's purpose, so hesitant to muck with this at this time).
if (AssociatedAnimAssetPlayerNode != NULL)
{
UAnimationAsset* BoundAsset = AssociatedAnimAssetPlayerNode->GetAnimationAsset();
if (BoundAsset)
{
FFormatNamedArguments Args;
Args.Add(TEXT("BoundAsset"), FText::FromString(BoundAsset->GetName()));
return FText::Format(LOCTEXT("AnimationAssetInfoGetterTitle", "{BoundAsset} Asset"), Args);
}
}
else if (AssociatedStateNode != NULL)
{
if (UAnimStateNode* State = Cast<UAnimStateNode>(AssociatedStateNode))
{
const FString OwnerName = State->GetOuter()->GetName();
FFormatNamedArguments Args;
Args.Add(TEXT("OwnerName"), FText::FromString(OwnerName));
Args.Add(TEXT("StateName"), FText::FromString(State->GetStateName()));
return FText::Format(LOCTEXT("StateInfoGetterTitle", "{OwnerName}.{StateName} State"), Args);
}
}
else if (GetterType == ETransitionGetter::CurrentTransitionDuration)
{
return LOCTEXT("TransitionDuration", "Transition");
}
else if (GetterType == ETransitionGetter::CurrentState_ElapsedTime ||
GetterType == ETransitionGetter::CurrentState_GetBlendWeight)
{
return LOCTEXT("CurrentState", "Current State");
}
return Super::GetNodeTitle(TitleType);
}
void FMessageLogListingViewModel::NotifyIfAnyMessages( const FText& Message, EMessageSeverity::Type SeverityFilter, bool bForce )
{
// Note we use page 0 in this function, as that is the page that will
// have most recently had messages added to it.
if ( bForce || NumMessagesPresent(0, SeverityFilter) > 0 )
{
FText NotificationMessage;
if(Message.IsEmpty())
{
if(MessageLogListingModel->NumMessages(0) > 0)
{
// no message passed in, so we need to make a default - use the last message we output
FFormatNamedArguments Args;
Args.Add( TEXT("LogLabel"), LogLabel );
Args.Add( TEXT("LastMessage"), MessageLogListingModel->GetMessageAtIndex(0, MessageLogListingModel->NumMessages(0) - 1)->ToText() );
NotificationMessage = FText::Format( LOCTEXT("DefaultNoMessageToLastMessage", "{LogLabel}: {LastMessage}"), Args );
}
else
{
// no present messages & no message passed in, use the log label as a default
NotificationMessage = LogLabel;
}
}
else
{
NotificationMessage = Message;
}
FNotificationInfo ErrorNotification(NotificationMessage);
ErrorNotification.Image = FEditorStyle::GetBrush(FTokenizedMessage::GetSeverityIconName(HighestSeverityPresent(0)));
ErrorNotification.bFireAndForget = true;
ErrorNotification.Hyperlink = FSimpleDelegate::CreateSP(this, &FMessageLogListingViewModel::OpenMessageLog);
ErrorNotification.HyperlinkText = LOCTEXT("ShowMessageLogHyperlink", "Show Message Log");
ErrorNotification.ExpireDuration = 8.0f; // Need this message to last a little longer than normal since the user may want to "Show Log"
ErrorNotification.bUseThrobber = true;
FSlateNotificationManager::Get().AddNotification(ErrorNotification);
}
}
FText FSimpleAssetEditor::GetToolkitName() const
{
const TArray<UObject*>& EditingObjs = GetEditingObjects();
check( EditingObjs.Num() > 0 );
FFormatNamedArguments Args;
Args.Add( TEXT("ToolkitName"), GetBaseToolkitName() );
if( EditingObjs.Num() == 1 )
{
const UObject* EditingObject = EditingObjs[ 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 = nullptr;
for( int32 x = 0; x < EditingObjs.Num(); ++x )
{
UObject* Obj = EditingObjs[ x ];
check( Obj );
UClass* ObjClass = Cast<UClass>(Obj);
if (ObjClass == nullptr)
{
ObjClass = Obj->GetClass();
}
check( ObjClass );
// Initialize with the class of the first object we encounter.
if( SharedBaseClass == nullptr )
{
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();
}
check(SharedBaseClass);
Args.Add( TEXT("NumberOfObjects"), EditingObjs.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 );
}
}
void NormalMapIdentification::HandleAssetPostImport( UFactory* InFactory, UObject* InObject )
{
UTextureFactory* TextureFactory = Cast<UTextureFactory>(InFactory);
UTexture* Texture = Cast<UTexture>(InObject);
if(TextureFactory != NULL && Texture != NULL)
{
// Try to automatically identify a normal map
if ( !TextureFactory->bUsingExistingSettings && IsTextureANormalMap( Texture ) )
{
// Set the compression settings and no gamma correction for a normal map
{
Texture->SetFlags(RF_Transactional);
const FScopedTransaction Transaction( NSLOCTEXT("AutoNormalMapID", "ImportAsNormalMap", "Import As Normal Map") );
Texture->Modify();
Texture->CompressionSettings = TC_Normalmap;
Texture->SRGB = false;
Texture->LODGroup = TEXTUREGROUP_WorldNormalMap;
Texture->bFlipGreenChannel = TextureFactory->bFlipNormalMapGreenChannel;
}
// Show the user a notification indicating that this texture will be imported as a normal map.
// Offer two options to the user, "OK" dismisses the notification early, "Revert" reverts the settings to that of a diffuse map.
TSharedPtr<NormalMapImportNotificationHandler> NormalMapNotificationDelegate(new NormalMapImportNotificationHandler);
{
NormalMapNotificationDelegate->Texture = Texture;
// this is a cheat to make sure the notification keeps the callback thing alive while it's active...
FText OKText = LOCTEXT("ImportTexture_OKNormalMapSettings", "OK");
FText OKTooltipText = LOCTEXT("ImportTexture_OKTooltip", "Accept normal map settings");
FText RevertText = LOCTEXT("ImportTexture_RevertNormalMapSettings", "Revert");
FText RevertTooltipText = LOCTEXT("ImportTexture_RevertTooltip", "Revert to diffuse map settings");
FFormatNamedArguments Args;
Args.Add( TEXT("TextureName"), FText::FromName(Texture->GetFName()) );
FNotificationInfo NormalMapNotification( FText::Format(LOCTEXT("ImportTexture_IsNormalMap", "Texture {TextureName} was imported as a normal map"), Args ) );
NormalMapNotification.ButtonDetails.Add(FNotificationButtonInfo(OKText, OKTooltipText, FSimpleDelegate::CreateSP(NormalMapNotificationDelegate.Get(), &NormalMapImportNotificationHandler::OKSetting, NormalMapNotificationDelegate)));
NormalMapNotification.ButtonDetails.Add(FNotificationButtonInfo(RevertText, RevertTooltipText, FSimpleDelegate::CreateSP(NormalMapNotificationDelegate.Get(), &NormalMapImportNotificationHandler::RevertSetting, NormalMapNotificationDelegate)));
NormalMapNotification.bFireAndForget = true;
NormalMapNotification.bUseLargeFont = false;
NormalMapNotification.bUseSuccessFailIcons = false;
NormalMapNotification.bUseThrobber = false;
NormalMapNotification.ExpireDuration = 10.0f;
NormalMapNotificationDelegate->Notification = FSlateNotificationManager::Get().AddNotification(NormalMapNotification);
if ( NormalMapNotificationDelegate->Notification.IsValid() )
{
NormalMapNotificationDelegate->Notification.Pin()->SetCompletionState(SNotificationItem::CS_Pending);
}
}
}
}
}
void ALight::CheckForErrors()
{
Super::CheckForErrors();
if( !LightComponent )
{
FFormatNamedArguments Arguments;
Arguments.Add(TEXT("ActorName"), FText::FromString(GetName()));
FMessageLog("MapCheck").Warning()
->AddToken(FUObjectToken::Create(this))
->AddToken(FTextToken::Create(FText::Format(LOCTEXT( "MapCheck_Message_LightComponentNull", "{ActorName} : Light actor has NULL LightComponent property - please delete!" ), Arguments) ))
->AddToken(FMapErrorToken::Create(FMapErrors::LightComponentNull));
}
}
FText UK2Node_Event::GetNodeTitle(ENodeTitleType::Type TitleType) const
{
if (bOverrideFunction || (CustomFunctionName == NAME_None))
{
FString FunctionName = EventSignatureName.ToString(); // If we fail to find the function, still want to write something on the node.
if (UFunction* Function = FindField<UFunction>(EventSignatureClass, EventSignatureName))
{
FunctionName = UEdGraphSchema_K2::GetFriendlySignatureName(Function);
}
FFormatNamedArguments Args;
Args.Add(TEXT("FunctionName"), FText::FromString(FunctionName));
FText Title = FText::Format(NSLOCTEXT("K2Node", "Event_Name", "Event {FunctionName}"), Args);
if(TitleType == ENodeTitleType::FullTitle && EventSignatureClass != NULL && EventSignatureClass->IsChildOf(UInterface::StaticClass()))
{
FString SourceString = EventSignatureClass->GetName();
// @todo: This action won't be necessary once the new name convention is used.
if(SourceString.EndsWith(TEXT("_C")))
{
SourceString = SourceString.LeftChop(2);
}
FFormatNamedArguments FullTitleArgs;
FullTitleArgs.Add(TEXT("Title"), Title);
FullTitleArgs.Add(TEXT("InterfaceClass"), FText::FromString(SourceString));
Title = FText::Format(LOCTEXT("EventFromInterface", "{Title}\nFrom {InterfaceClass}"), FullTitleArgs);
}
return Title;
}
else
{
return FText::FromName(CustomFunctionName);
}
}