void UJavascriptGraphTextPropertyEditableTextBox::HandleOnTextCommitted(const FText& InText) { FName TableId = NAME_None; FString Key; FTextInspector::GetTableIdAndKey(InText, TableId, Key); MyTextProperty.TableId = TableId; MyTextProperty.Namespace = FTextInspector::GetNamespace(InText).Get(FString()); MyTextProperty.Key = FTextInspector::GetKey(InText).Get(FString()); MyTextProperty.Value = InText.ToString(); OnTextCommitted.Broadcast(MyTextProperty); }
void UMaterialExpressionSpriteTextureSampler::GetCaption(TArray<FString>& OutCaptions) const { OutCaptions.Add(TEXT("Paper2D Sprite")); if (!SlotDisplayName.IsEmpty()) { OutCaptions.Add(SlotDisplayName.ToString()); } if (bSampleAdditionalTextures) { FNumberFormattingOptions NoCommas; NoCommas.UseGrouping = false; const FText SlotDesc = FText::Format(LOCTEXT("SpriteSamplerTitle_AdditionalSlot", "Additional Texture #{0}"), FText::AsNumber(AdditionalSlotIndex, &NoCommas)); OutCaptions.Add(SlotDesc.ToString()); } else { OutCaptions.Add(LOCTEXT("SpriteSamplerTitle_BasicSlot", "Source Texture").ToString()); } }
static void ProjectChanged(const FText& NewText, ETextCommit::Type CommitType, FGuid TargetGuid) { FOneSkyLocalizationTargetSetting* Settings = FOneSkyLocalizationServiceModule::Get().AccessSettings().GetSettingsForTarget(TargetGuid, true); int32 NewProjectId = INDEX_NONE; // Default to -1 FString StringId = NewText.ToString(); // Don't allow this to be set to a non-numeric value. if (StringId.IsNumeric()) { NewProjectId = FCString::Atoi(*StringId); } FOneSkyLocalizationServiceModule::Get().AccessSettings().SetSettingsForTarget(TargetGuid, NewProjectId, Settings->OneSkyFileName); }
void SSessionLauncherDeployRepositorySettings::OnTextCommitted( const FText& InText, ETextCommit::Type CommitInfo) { if (CommitInfo == ETextCommit::OnEnter) { ILauncherProfilePtr SelectedProfile = Model->GetSelectedProfile(); if(SelectedProfile.IsValid()) { SelectedProfile->SetPackageDirectory(InText.ToString()); } } }
void FSpriteEditorViewportClient::DrawBoundsAsText(FViewport& InViewport, FSceneView& View, FCanvas& Canvas, int32& YPos) { FNumberFormattingOptions NoDigitGroupingFormat; NoDigitGroupingFormat.UseGrouping = false; UPaperSprite* Sprite = GetSpriteBeingEdited(); FBoxSphereBounds Bounds = Sprite->GetRenderBounds(); const FText DisplaySizeText = FText::Format(LOCTEXT("BoundsSize", "Approx. Size: {0}x{1}x{2}"), FText::AsNumber((int32)(Bounds.BoxExtent.X * 2.0f), &NoDigitGroupingFormat), FText::AsNumber((int32)(Bounds.BoxExtent.Y * 2.0f), &NoDigitGroupingFormat), FText::AsNumber((int32)(Bounds.BoxExtent.Z * 2.0f), &NoDigitGroupingFormat)); Canvas.DrawShadowedString( 6, YPos, *DisplaySizeText.ToString(), GEngine->GetSmallFont(), FLinearColor::White); YPos += 18; }
void FSlateDrawElement::MakeText( FSlateWindowElementList& ElementList, uint32 InLayer, const FPaintGeometry& PaintGeometry, const FText& InText, const FSlateFontInfo& InFontInfo, const FSlateRect& InClippingRect,ESlateDrawEffect::Type InDrawEffects, const FLinearColor& InTint ) { FSlateDrawElement& DrawElt = ElementList.AddUninitialized(); DrawElt.ElementType = ET_Text; DrawElt.Position = PaintGeometry.DrawPosition; DrawElt.Size = PaintGeometry.DrawSize; DrawElt.ClippingRect = InClippingRect; DrawElt.DataPayload.SetTextPayloadProperties( InText.ToString(), InFontInfo, InTint ); DrawElt.Layer = InLayer; DrawElt.DrawEffects = InDrawEffects; DrawElt.Scale = PaintGeometry.DrawScale; }
FText UEdGraphPin::GetDisplayName() const { FText DisplayName = FText::GetEmpty(); auto Schema = GetSchema(); if (Schema) { DisplayName = Schema->GetPinDisplayName(this); } else { DisplayName = (!PinFriendlyName.IsEmpty()) ? PinFriendlyName : FText::FromString(PinName); bool bShowNodesAndPinsUnlocalized = false; GConfig->GetBool( TEXT("Internationalization"), TEXT("ShowNodesAndPinsUnlocalized"), bShowNodesAndPinsUnlocalized, GEditorSettingsIni ); if (bShowNodesAndPinsUnlocalized) { return FText::FromString(DisplayName.BuildSourceString()); } } return DisplayName; }
bool FProjectManager::LoadProjectFile( const FString& InProjectFile ) { // Try to load the descriptor FText FailureReason; TSharedPtr<FProjectDescriptor> Descriptor = MakeShareable(new FProjectDescriptor()); if(Descriptor->Load(InProjectFile, FailureReason)) { // Create the project CurrentProject = Descriptor; return true; } #if PLATFORM_IOS FString UpdatedMessage = FString::Printf(TEXT("%s\n%s"), *FailureReason.ToString(), TEXT("For troubleshooting, please go to https://docs.unrealengine.com/latest/INT/Platforms/iOS/GettingStarted/index.html")); FailureReason = FText::FromString(UpdatedMessage); #endif UE_LOG(LogProjectManager, Error, TEXT("%s"), *FailureReason.ToString()); FMessageDialog::Open(EAppMsgType::Ok, FailureReason); return false; }
void UMovieSceneNameableTrack::SetDisplayName(const FText& NewDisplayName) { if (NewDisplayName.EqualTo(DisplayName)) { return; } SetFlags(RF_Transactional); Modify(); DisplayName = NewDisplayName; }
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 UpdateSuggestionHelper(const FText & CategoryLabel, const TArray<FSearchEntry> & Elements, TArray<TSharedPtr< FSearchEntry > > & OutSuggestions) { if (Elements.Num()) { OutSuggestions.Add(MakeShareable(FSearchEntry::MakeCategoryEntry(CategoryLabel.ToString()))); } for (uint32 i = 0; i < (uint32)Elements.Num(); ++i) { OutSuggestions.Add(MakeShareable(new FSearchEntry(Elements[i]))); } }
void FAssetTypeActions_CurveTable::ExecuteExportAsCSV(TArray< TWeakObjectPtr<UObject> > Objects) { IDesktopPlatform* DesktopPlatform = FDesktopPlatformModule::Get(); void* ParentWindowWindowHandle = nullptr; IMainFrameModule& MainFrameModule = FModuleManager::LoadModuleChecked<IMainFrameModule>(TEXT("MainFrame")); const TSharedPtr<SWindow>& MainFrameParentWindow = MainFrameModule.GetParentWindow(); if ( MainFrameParentWindow.IsValid() && MainFrameParentWindow->GetNativeWindow().IsValid() ) { ParentWindowWindowHandle = MainFrameParentWindow->GetNativeWindow()->GetOSWindowHandle(); } for (auto ObjIt = Objects.CreateConstIterator(); ObjIt; ++ObjIt) { auto CurTable = Cast<UCurveTable>((*ObjIt).Get()); if (CurTable) { const FText Title = FText::Format(LOCTEXT("CurveTable_ExportCSVDialogTitle", "Export '{0}' as CSV..."), FText::FromString(*CurTable->GetName())); const FString CurrentFilename = (CurTable->ImportPath.IsEmpty()) ? TEXT("") : FReimportManager::ResolveImportFilename(CurTable->ImportPath, CurTable); const FString FileTypes = TEXT("Curve Table CSV (*.csv)|*.csv"); TArray<FString> OutFilenames; DesktopPlatform->SaveFileDialog( ParentWindowWindowHandle, Title.ToString(), (CurrentFilename.IsEmpty()) ? TEXT("") : FPaths::GetPath(CurrentFilename), (CurrentFilename.IsEmpty()) ? TEXT("") : FPaths::GetBaseFilename(CurrentFilename) + TEXT(".csv"), FileTypes, EFileDialogFlags::None, OutFilenames ); if (OutFilenames.Num() > 0) { FFileHelper::SaveStringToFile(CurTable->GetTableAsCSV(), *OutFilenames[0]); } } } }
bool UTextProperty::Identical_Implementation(const FText& ValueA, const FText& ValueB, uint32 PortFlags) { if (ValueA.IsCultureInvariant() != ValueB.IsCultureInvariant() || ValueA.IsTransient() != ValueB.IsTransient()) { //A culture variant text is never equal to a culture invariant text //A transient text is never equal to a non-transient text return false; } if (ValueA.IsCultureInvariant() == ValueB.IsCultureInvariant() || ValueA.IsTransient() == ValueB.IsTransient()) { //Culture invariant text don't have a namespace/key so we compare the source string //Transient text don't have a namespace/key or source so we compare the display string return FTextInspector::GetDisplayString(ValueA) == FTextInspector::GetDisplayString(ValueB); } if (GIsEditor) { return FTextInspector::GetSourceString(ValueA)->Compare(*FTextInspector::GetSourceString(ValueB), ESearchCase::CaseSensitive) == 0; } else { return FTextInspector::GetNamespace(ValueA) == FTextInspector::GetNamespace(ValueB) && FTextInspector::GetKey(ValueA) == FTextInspector::GetKey(ValueB); } }
void UMaterialGraphSchema::GetCommentAction(FGraphActionMenuBuilder& ActionMenuBuilder, const UEdGraph* CurrentGraph) const { if (!ActionMenuBuilder.FromPin) { const bool bIsManyNodesSelected = CurrentGraph ? (FMaterialEditorUtilities::GetNumberOfSelectedNodes(CurrentGraph) > 0) : false; const FText CommentDesc = LOCTEXT("CommentDesc", "New Comment"); const FText MultiCommentDesc = LOCTEXT("MultiCommentDesc", "Create Comment from Selection"); const FText CommentToolTip = LOCTEXT("CommentToolTip", "Creates a comment."); const FText MenuDescription = bIsManyNodesSelected ? MultiCommentDesc : CommentDesc; TSharedPtr<FMaterialGraphSchemaAction_NewComment> NewAction(new FMaterialGraphSchemaAction_NewComment(TEXT(""), MenuDescription, CommentToolTip.ToString(), 0)); ActionMenuBuilder.AddAction( NewAction ); } }
void FAxisMappingsNodeBuilder::OnAxisMappingNameCommitted(const FText& InName, ETextCommit::Type CommitInfo, const FMappingSet MappingSet) { const FScopedTransaction Transaction(LOCTEXT("RenameAxisMapping_Transaction", "Rename Axis Mapping")); FName NewName = FName(*InName.ToString()); TSharedPtr<IPropertyHandleArray> AxisMappingsArrayHandle = AxisMappingsPropertyHandle->AsArray(); for (int32 Index = 0; Index < MappingSet.Mappings.Num(); ++Index) { MappingSet.Mappings[Index]->GetChildHandle(GET_MEMBER_NAME_CHECKED(FInputAxisKeyMapping, AxisName))->SetValue(NewName); } }
FText UK2Node::GetToolTipHeading() const { FText Heading = FText::GetEmpty(); if (UBreakpoint* ExistingBreakpoint = FKismetDebugUtilities::FindBreakpointForNode(GetBlueprint(), this)) { if (ExistingBreakpoint->IsEnabled()) { Heading = LOCTEXT("EnabledBreakpoint", "Active Breakpoint"); FText ActiveBreakpointToolTipText = GetActiveBreakpointToolTipText(); if (!ActiveBreakpointToolTipText.IsEmpty()) { Heading = FText::Format(FText::FromString("{0} - {1}"), Heading, ActiveBreakpointToolTipText); } } else { Heading = LOCTEXT("DisabledBreakpoint", "Disabled Breakpoint"); } } return Heading; }
void FUICommandInfo::MakeCommandInfo( const TSharedRef<class FBindingContext>& InContext, TSharedPtr< FUICommandInfo >& OutCommand, const FName InCommandName, const FText& InCommandLabel, const FText& InCommandDesc, const FSlateIcon& InIcon, const EUserInterfaceActionType::Type InUserInterfaceType, const FInputChord& InDefaultChord ) { ensureMsgf( !InCommandLabel.IsEmpty(), TEXT("Command labels cannot be empty") ); OutCommand = MakeShareable( new FUICommandInfo( InContext->GetContextName() ) ); OutCommand->CommandName = InCommandName; OutCommand->Label = InCommandLabel; OutCommand->Description = InCommandDesc; OutCommand->Icon = InIcon; OutCommand->UserInterfaceType = InUserInterfaceType; OutCommand->DefaultChord = InDefaultChord; FInputBindingManager::Get().CreateInputCommand( InContext, OutCommand.ToSharedRef() ); }
void UK2Node_LiveEditObject::SetPinToolTip(UEdGraphPin& MutatablePin, const FText& PinDescription) const { MutatablePin.PinToolTip = UEdGraphSchema_K2::TypeToText(MutatablePin.PinType).ToString(); UEdGraphSchema_K2 const* const K2Schema = Cast<const UEdGraphSchema_K2>(GetSchema()); if (K2Schema != nullptr) { MutatablePin.PinToolTip += TEXT(" "); MutatablePin.PinToolTip += K2Schema->GetPinDisplayName(&MutatablePin).ToString(); } MutatablePin.PinToolTip += FString(TEXT("\n")) + PinDescription.ToString(); }
FText FWidgetTemplateBlueprintClass::GetCategory() const { if ( WidgetClass.Get() ) { UUserWidget* DefaultUserWidget = WidgetClass->GetDefaultObject<UUserWidget>(); return DefaultUserWidget->GetPaletteCategory(); } else { //If the blueprint is unloaded we need to extract it from the asset metadata. FText FoundPaletteCategoryText = WidgetAssetData.GetTagValueRef<FText>(GET_MEMBER_NAME_CHECKED(UWidgetBlueprint, PaletteCategory)); if (!FoundPaletteCategoryText.IsEmpty()) { return FoundPaletteCategoryText; } else { auto DefaultUserWidget = UUserWidget::StaticClass()->GetDefaultObject<UUserWidget>(); return DefaultUserWidget->GetPaletteCategory(); } } }
FText UEnvQueryTest::DescribeBoolTestParams(const FString& ConditionDesc) const { FText FilterDesc; if (IsFiltering() && FilterType == EEnvTestFilterType::Match) { FilterDesc = BoolValue.IsDynamic() ? FText::Format(FText::FromString("{0} {1}: {2}"), LOCTEXT("FilterRequire", "require"), FText::FromString(ConditionDesc), FText::FromString(BoolValue.ToString())) : FText::Format(FText::FromString("{0} {1}{2}"), LOCTEXT("FilterRequire", "require"), BoolValue.DefaultValue ? FText::GetEmpty() : LOCTEXT("NotWithSpace", "not "), FText::FromString(ConditionDesc)); } FNumberFormattingOptions NumberFormattingOptions; NumberFormattingOptions.MaximumFractionalDigits = 2; FText ScoreDesc; if (!IsScoring()) { ScoreDesc = LOCTEXT("DontScore", "don't score"); } else if (ScoringEquation == EEnvTestScoreEquation::Constant) { FText FactorDesc = ScoringFactor.IsDynamic() ? FText::FromString(ScoringFactor.ToString()) : FText::Format(FText::FromString("x{0}"), FText::AsNumber(FMath::Abs(ScoringFactor.DefaultValue), &NumberFormattingOptions)); ScoreDesc = FText::Format(FText::FromString("{0} [{1}]"), LOCTEXT("ScoreConstant", "constant score"), FactorDesc); } else if (ScoringFactor.IsDynamic()) { ScoreDesc = FText::Format(FText::FromString("{0}: {1}"), LOCTEXT("ScoreFactor", "score factor"), FText::FromString(ScoringFactor.ToString())); } else { FText ScoreSignDesc = (ScoringFactor.DefaultValue > 0) ? FText::GetEmpty() : LOCTEXT("NotWithSpace", "not "); FText ScoreValueDesc = FText::AsNumber(FMath::Abs(ScoringFactor.DefaultValue), &NumberFormattingOptions); ScoreDesc = FText::Format(FText::FromString("{0} {1}{2} [x{3}]"), LOCTEXT("ScorePrefer", "prefer"), ScoreSignDesc, FText::FromString(ConditionDesc), ScoreValueDesc); } return FilterDesc.IsEmpty() ? ScoreDesc : FText::Format(FText::FromString("{0}, {1}"), FilterDesc, ScoreDesc); }
void AssignStringToProperty(const FString& InString, const UProperty* InProp, uint8* InData, const int32 InIndex, const int32 InPortFlags, FStringOutputDevice& OutImportError) { auto DoImportText = [&](const FString& InStringToImport) { InProp->ImportText(*InStringToImport, InProp->ContainerPtrToValuePtr<uint8>(InData, InIndex), InPortFlags, nullptr, &OutImportError); }; bool bNeedsImport = true; const UByteProperty* EnumProp = Cast<const UByteProperty>(InProp); if(EnumProp && EnumProp->Enum) { // Enum properties may use the friendly name in their import data, however the UPropertyByte::ImportText function will only accept the internal enum entry name // Detect if we're using a friendly name for an entry, and if so, try and map it to the correct internal name before performing the import const int32 EnumIndex = EnumProp->Enum->FindEnumIndex(*InString); if(EnumIndex == INDEX_NONE) { // Couldn't find a match for the name we were given, try and find a match using the friendly names for(int32 EnumEntryIndex = 0; EnumEntryIndex < EnumProp->Enum->NumEnums(); ++EnumEntryIndex) { const FText FriendlyEnumEntryName = EnumProp->Enum->GetEnumText(EnumEntryIndex); if(FriendlyEnumEntryName.ToString() == InString) { // Get the corresponding internal name and warn the user that we're using this fallback FString StringToImport = EnumProp->Enum->GetEnumName(EnumEntryIndex); UE_LOG(LogDataTable, Warning, TEXT("Could not a find matching enum entry for '%s', but did find a matching display name. Will import using the enum entry corresponding to that display name ('%s')"), *InString, *StringToImport); DoImportText(StringToImport); bNeedsImport = false; break; } } } } if(bNeedsImport) { DoImportText(InString); } }
void UK2Node_Variable::ValidateNodeDuringCompilation(class FCompilerResultsLog& MessageLog) const { Super::ValidateNodeDuringCompilation(MessageLog); UProperty* VariableProperty = GetPropertyForVariable(); // Local variables do not exist until much later in the compilation than this function can provide if (VariableProperty == NULL && !VariableReference.IsLocalScope()) { if (!VariableReference.IsDeprecated()) { FString OwnerName; UBlueprint* Blueprint = GetBlueprint(); if (Blueprint != nullptr) { OwnerName = Blueprint->GetName(); if (UClass* VarOwnerClass = VariableReference.GetMemberParentClass(Blueprint->GeneratedClass)) { OwnerName = VarOwnerClass->GetName(); } } FString const VarName = VariableReference.GetMemberName().ToString(); FText const WarningFormat = LOCTEXT("VariableNotFound", "Could not find a variable named \"%s\" in '%s'.\nMake sure '%s' has been compiled for @@"); MessageLog.Warning(*FString::Printf(*WarningFormat.ToString(), *VarName, *OwnerName, *OwnerName), this); } else { MessageLog.Warning(*FString::Printf(*LOCTEXT("VariableDeprecated", "Variable '%s' for @@ was deprecated. Please update it.").ToString(), *VariableReference.GetMemberName().ToString()), this); } } if (VariableProperty && (VariableProperty->ArrayDim > 1)) { MessageLog.Warning(*LOCTEXT("StaticArray_Warning", "@@ - the native property is a static array, which is not supported by blueprints").ToString(), this); } }
//------------------------------------------------------------------------------ FText FEditorCategoryUtilsImpl::GetTooltipForCategory(FString const& CategoryDisplayName, FString const& DocLink, FString const& DocExcerpt) { FText Tooltip; TSharedRef<IDocumentation> Documentation = IDocumentation::Get(); if (Documentation->PageExists(DocLink)) { TSharedRef<IDocumentationPage> DocPage = Documentation->GetPage(DocLink, NULL); const FString TooltipExcerptSuffix(TEXT("__Tooltip")); FExcerpt Excerpt; if (DocPage->GetExcerpt(DocExcerpt + TooltipExcerptSuffix, Excerpt)) { static const FString TooltipVarKey(TEXT("Tooltip")); if (FString* TooltipValue = Excerpt.Variables.Find(TooltipVarKey)) { Tooltip = FText::FromString(TooltipValue->Replace(TEXT("\\n"),TEXT("\n"))); } } } if (Tooltip.IsEmpty()) { FString CategoryTooltip; if (CategoryDisplayName.Split(TEXT("|"), nullptr, &CategoryTooltip, ESearchCase::CaseSensitive, ESearchDir::FromEnd)) { Tooltip = FText::FromString(CategoryTooltip); } else { Tooltip = FText::FromString(CategoryDisplayName); } } return Tooltip; }
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; } // notify browser window if (Frame->IsMain()) { TSharedPtr<FWebBrowserWindow> BrowserWindow = BrowserWindowPtr.Pin(); if (BrowserWindow.IsValid()) { BrowserWindow->NotifyDocumentError(); } } // Display a load error message. if (ShowErrorMessage) { FFormatNamedArguments Args; { Args.Add(TEXT("FailedUrl"), FText::FromString(FailedUrl.ToWString().c_str())); Args.Add(TEXT("ErrorText"), FText::FromString(ErrorText.ToWString().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); } }
static bool DeserializeResponseToStruct(void* OutStruct, UStruct& TypeInfo, FHttpResponsePtr HttpResponse) { bool bResult = false; FString ResponseStr = HttpResponse->GetContentAsString(); FText ErrorText; if (HttpResponse.IsValid()) { if (EHttpResponseCodes::IsOk(HttpResponse->GetResponseCode())) { // Write string to FMemoryWriter to force unicode TArray<uint8> InBytes; FMemoryWriter Writer(InBytes); Writer.ArForceUnicode = true; Writer << ResponseStr; FMemoryReader Reader(InBytes); // FMemoryWriter writes size of string at beginning, need to ignore this or json parsing errors occur Reader.Seek(4); FJsonStructDeserializerBackend Backend(Reader); bResult = FStructDeserializer::Deserialize(OutStruct, TypeInfo, Backend); } else { ErrorText = FText::Format(LOCTEXT("InvalidResponse", "Invalid response. code={0} error={1}"), FText::FromString(FString::FromInt(HttpResponse->GetResponseCode())), FText::FromString(ResponseStr)); } } if (!bResult) { UE_LOG(LogLocalizationService, Warning, TEXT("%s"), *(ErrorText.ToString())); } return bResult; }
void FSlateStyleSet::Log(ISlateStyle::EStyleMessageSeverity Severity, const FText& Message) const { if ( Severity == ISlateStyle::Error ) { UE_LOG(LogSlateStyle, Error, TEXT("%s"), *Message.ToString()); } else if ( Severity == ISlateStyle::PerformanceWarning ) { UE_LOG(LogSlateStyle, Warning, TEXT("%s"), *Message.ToString()); } else if ( Severity == ISlateStyle::Warning ) { UE_LOG(LogSlateStyle, Warning, TEXT("%s"), *Message.ToString()); } else if ( Severity == ISlateStyle::Info ) { UE_LOG(LogSlateStyle, Log, TEXT("%s"), *Message.ToString()); } else { UE_LOG(LogSlateStyle, Fatal, TEXT("%s"), *Message.ToString()); } }
void UK2Node_LatentAbilityCall::ValidateNodeDuringCompilation(class FCompilerResultsLog& MessageLog) const { Super::ValidateNodeDuringCompilation(MessageLog); UFunction* DelegateSignatureFunction = NULL; for (TFieldIterator<UProperty> PropertyIt(ProxyClass); PropertyIt; ++PropertyIt) { if (UMulticastDelegateProperty* Property = Cast<UMulticastDelegateProperty>(*PropertyIt)) { if (Property->GetBoolMetaData(FK2Node_LatentAbilityCallHelper_RequiresConnection)) { if (UEdGraphPin* DelegateExecPin = FindPin(Property->GetName())) { if (DelegateExecPin->LinkedTo.Num() < 1) { const FText MessageText = FText::Format(LOCTEXT("NoConnectionToRequiredExecPin", "@@ - Unhandled event. You need something connected to the '{0}' pin"), FText::FromName(Property->GetFName())); MessageLog.Warning(*MessageText.ToString(), this); } } } } } }
bool FNiagaraCompiler::CheckOutputs(FName OpName, TArray<TNiagaraExprPtr>& Outputs) { //check the types of the input expressions. const FNiagaraOpInfo* OpInfo = FNiagaraOpInfo::GetOpInfo(OpName); check(OpInfo); int32 NumOutputs = Outputs.Num(); bool bError = false; check(OpInfo->Outputs.Num() == NumOutputs); for (int32 i = 0; i < NumOutputs; ++i) { check(Outputs[i].IsValid()); if (OpInfo->Outputs[i].DataType != Outputs[i]->Result.Type) { bError = true; FText ErrorText = FText::Format(LOCTEXT("Expression {0} has incorrect inputs!\nExpected: {1} - Actual: {2}", ""), FText::FromString(OpName.ToString()), FText::AsNumber((int32)OpInfo->Outputs[i].DataType), FText::AsNumber((int32)((TNiagaraExprPtr)Outputs[i])->Result.Type.GetValue())); MessageLog.Error(*ErrorText.ToString()); } } return bError; }
FAssetNameToken::FAssetNameToken(const FString& InAssetName, const FText& InMessage) : AssetName(InAssetName) { if ( !InMessage.IsEmpty() ) { CachedText = InMessage; } else { CachedText = FText::FromString( AssetName ); } MessageTokenActivated = FOnMessageTokenActivated::CreateStatic(&FAssetNameToken::FindAsset, AssetName); }
void FEnumEditorUtils::EnsureAllDisplayNamesExist(UUserDefinedEnum* Enum) { if (Enum) { const int32 EnumeratorsToEnsure = (Enum->NumEnums() > 0) ? (Enum->NumEnums() - 1) : 0; Enum->DisplayNames.Empty(EnumeratorsToEnsure); for (int32 Index = 0; Index < EnumeratorsToEnsure; Index++) { FText DisplayNameMetaData = Enum->GetEnumText(Index); if (DisplayNameMetaData.IsEmpty()) { const FString EnumName = Enum->GetEnumName(Index); DisplayNameMetaData = FText::FromString(EnumName); for(int32 AddIndex = 0; !IsEnumeratorDisplayNameValid(Enum, DisplayNameMetaData.ToString()); ++AddIndex) { DisplayNameMetaData = FText::FromString(FString::Printf(TEXT("%s%d"), *EnumName, AddIndex)); } Enum->SetMetaData(FEnumEditorUtilsHelper::DisplayName(), *DisplayNameMetaData.ToString(), Index); } Enum->DisplayNames.Add(DisplayNameMetaData); } } }