KismetTextLibrary.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/ObjectMacros.h"
#include "UObject/TextProperty.h"
#include "Kismet/BlueprintFunctionLibrary.h"
#include "Internationalization/PolyglotTextData.h"
#include "KismetTextLibrary.generated.h"
 
class FTextProperty;
 
#if !CPP
UENUM(BlueprintType)
enum ERoundingMode : int
{
    HalfToEven,
    HalfFromZero,
    HalfToZero,
    FromZero,
    ToZero,
    ToNegativeInfinity,
    ToPositiveInfinity,
};
 
UENUM(BlueprintType)
enum EMemoryUnitStandard : int
{
    /* International Electrotechnical Commission (MiB) 1024-based */
    IEC,
    /* International System of Units 1000-based */
    SI
};
 
UENUM(BlueprintType)
enum class ETextGender : uint8
{
    Masculine,
    Feminine,
    Neuter,
};
 
UENUM(BlueprintType)
namespace EDateTimeStyle
{
    enum Type : int
    {
        Default,
        Short,
        Medium,
        Long,
        Full,
        Custom UMETA(Hidden), // Internal use only
    };
}
 
UENUM(BlueprintType)
namespace EFormatArgumentType
{
    enum Type : int
    {
        Int,
        UInt,
        Float,
        Double,
        Text,
        Gender,
    };
}
 
USTRUCT(noexport, BlueprintInternalUseOnly)
struct FFormatArgumentData
{
    UPROPERTY(EditInstanceOnly, BlueprintReadWrite, Category=ArgumentName)
    FString ArgumentName;
 
    UPROPERTY(EditInstanceOnly, BlueprintReadWrite, Category=ArgumentValue)
    TEnumAsByte<EFormatArgumentType::Type> ArgumentValueType;
 
    UPROPERTY(EditInstanceOnly, BlueprintReadWrite, Category=ArgumentValue)
    FText ArgumentValue;
 
    UPROPERTY(EditInstanceOnly, BlueprintReadWrite, Category=ArgumentValue)
    int64 ArgumentValueInt;
 
    UPROPERTY(EditInstanceOnly, BlueprintReadWrite, Category=ArgumentValue)
    float ArgumentValueFloat;
    
    UPROPERTY(EditInstanceOnly, BlueprintReadWrite, Category=ArgumentValue)
    double ArgumentValueDouble;
 
    UPROPERTY(EditInstanceOnly, BlueprintReadWrite, Category=ArgumentValue)
    ETextGender ArgumentValueGender;
};
#endif
 
UCLASS(meta=(BlueprintThreadSafe, ScriptName="TextLibrary"), MinimalAPI)
class UKismetTextLibrary : public UBlueprintFunctionLibrary
{
    GENERATED_UCLASS_BODY()
 
    
    UFUNCTION(BlueprintPure, meta = (DisplayName = "To Text (Vector)", CompactNodeTitle = "->", BlueprintAutocast), Category = "Utilities|Text")
    static ENGINE_API FText Conv_VectorToText(FVector InVec);
 
    UFUNCTION(BlueprintPure, meta = (DisplayName = "To Text (Vector2d)", CompactNodeTitle = "->", BlueprintAutocast), Category = "Utilities|Text")
    static ENGINE_API FText Conv_Vector2dToText(FVector2D InVec);
 
    UFUNCTION(BlueprintPure, meta = (DisplayName = "To Text (Rotator)", CompactNodeTitle = "->", BlueprintAutocast), Category = "Utilities|Text")
    static ENGINE_API FText Conv_RotatorToText(FRotator InRot);
 
    UFUNCTION(BlueprintPure, meta = (DisplayName = "To Text (Transform)", CompactNodeTitle = "->", BlueprintAutocast), Category = "Utilities|Text")
    static ENGINE_API FText Conv_TransformToText(const FTransform& InTrans);
 
    UFUNCTION(BlueprintPure, meta = (DisplayName = "To Text (Object)", BlueprintAutocast), Category = "Utilities|Text")
    static ENGINE_API FText Conv_ObjectToText(class UObject* InObj);
 
    UFUNCTION(BlueprintPure, meta = (DisplayName = "To Text (LinearColor)", CompactNodeTitle = "->", BlueprintAutocast), Category = "Utilities|Text")
    static ENGINE_API FText Conv_ColorToText(FLinearColor InColor);
 
    UFUNCTION(BlueprintPure, meta = (DisplayName = "To String (Text)", CompactNodeTitle = "->", BlueprintAutocast), Category = "Utilities|String")
    static ENGINE_API FString Conv_TextToString(const FText& InText);
 
    UFUNCTION(BlueprintPure, meta=(DisplayName = "To Text (String)", BlueprintAutocast), Category="Utilities|Text")
    static ENGINE_API FText Conv_StringToText(const FString& InString);
 
    UFUNCTION(BlueprintPure, meta=(DisplayName = "To Text (Name)", BlueprintAutocast), Category="Utilities|Text")
    static ENGINE_API FText Conv_NameToText(FName InName);
 
    UFUNCTION(BlueprintPure, Category="Utilities|Text")
    static ENGINE_API FText MakeInvariantText(const FString& InString);
 
    UFUNCTION(BlueprintPure, Category="Utilities|Text")
    static ENGINE_API bool TextIsEmpty(const FText& InText);
 
    UFUNCTION(BlueprintPure, Category="Utilities|Text")
    static ENGINE_API bool TextIsTransient(const FText& InText);
 
    UFUNCTION(BlueprintPure, Category="Utilities|Text")
    static ENGINE_API bool TextIsCultureInvariant(const FText& InText);
 
    UFUNCTION(BlueprintPure, Category="Utilities|Text")
    static ENGINE_API FText TextToLower(const FText& InText);
 
    UFUNCTION(BlueprintPure, Category="Utilities|Text")
    static ENGINE_API FText TextToUpper(const FText& InText);
 
    UFUNCTION(BlueprintPure, Category="Utilities|Text")
    static ENGINE_API FText TextTrimPreceding(const FText& InText);
 
    UFUNCTION(BlueprintPure, Category="Utilities|Text")
    static ENGINE_API FText TextTrimTrailing(const FText& InText);
 
    UFUNCTION(BlueprintPure, Category="Utilities|Text")
    static ENGINE_API FText TextTrimPrecedingAndTrailing(const FText& InText);
 
    UFUNCTION(BlueprintPure, Category="Utilities|Text")
    static ENGINE_API FText GetEmptyText();
 
    UFUNCTION(BlueprintPure, Category="Utilities|Text", DisplayName="Find Text in Live Table (Advanced)", meta = (AdvancedDisplay = "SourceString", ScriptName="FindTextInLiveTable_Advanced;FindTextInLocalizationTable"))
    static ENGINE_API bool FindTextInLocalizationTable(const FString& Namespace, const FString& Key, FText& OutText, const FString& SourceString = TEXT(""));
 
    UFUNCTION(BlueprintPure, meta=(DisplayName = "Equal Exactly (Text)", CompactNodeTitle = "==="), Category="Utilities|Text")
    static ENGINE_API bool EqualEqual_TextText(const FText& A, const FText& B);
 
    UFUNCTION(BlueprintPure, meta=(DisplayName = "Equal, Case Insensitive (Text)", CompactNodeTitle = "=="), Category="Utilities|Text")
    static ENGINE_API bool EqualEqual_IgnoreCase_TextText(const FText& A, const FText& B);
                
    UFUNCTION(BlueprintPure, meta=(DisplayName = "Not Equal Exactly (Text)", CompactNodeTitle = "!=="), Category="Utilities|Text")
    static ENGINE_API bool NotEqual_TextText(const FText& A, const FText& B);
 
    UFUNCTION(BlueprintPure, meta=(DisplayName = "Not Equal, Case Insensitive (Text)", CompactNodeTitle = "!="), Category="Utilities|Text")
    static ENGINE_API bool NotEqual_IgnoreCase_TextText(const FText& A, const FText& B);
 
    UFUNCTION(BlueprintPure, meta=(DisplayName = "To Text (Boolean)", CompactNodeTitle = "->", BlueprintAutocast), Category="Utilities|Text")
    static ENGINE_API FText Conv_BoolToText(bool InBool);
 
    UFUNCTION(BlueprintPure, meta=(DisplayName = "To Text (Byte)", CompactNodeTitle = "->", BlueprintAutocast), Category="Utilities|Text")
    static ENGINE_API FText Conv_ByteToText(uint8 Value);
 
    // Default values are duplicated from FNumberFormattingOptions and should be replicated in all functions and in the struct when changed!
    UFUNCTION(BlueprintPure, meta=(DisplayName = "To Text (Integer)", AdvancedDisplay = "1", BlueprintAutocast), Category="Utilities|Text")
    static ENGINE_API FText Conv_IntToText(int32 Value, bool bAlwaysSign = false, bool bUseGrouping = true, int32 MinimumIntegralDigits = 1, int32 MaximumIntegralDigits = 324);
 
    UFUNCTION(BlueprintPure, meta = (DisplayName = "To Text (Integer64)", AdvancedDisplay = "1", BlueprintAutocast), Category = "Utilities|Text")
    static ENGINE_API FText Conv_Int64ToText(int64 Value, bool bAlwaysSign = false, bool bUseGrouping = true, int32 MinimumIntegralDigits = 1, int32 MaximumIntegralDigits = 324);
 
    UFUNCTION(BlueprintPure, meta = (DisplayName = "To Text (Float)", AdvancedDisplay = "1", BlueprintAutocast), Category = "Utilities|Text")
    static ENGINE_API FText Conv_DoubleToText(double Value, TEnumAsByte<ERoundingMode> RoundingMode, bool bAlwaysSign = false, bool bUseGrouping = true, int32 MinimumIntegralDigits = 1, int32 MaximumIntegralDigits = 324, int32 MinimumFractionalDigits = 0, int32 MaximumFractionalDigits = 3);
    
    UFUNCTION(BlueprintPure, meta = (DisplayName = "As Currency"), Category = "Utilities|Text")
    static ENGINE_API FText AsCurrencyBase(int32 BaseValue, const FString& CurrencyCode);
 
    // Default values are duplicated from FNumberFormattingOptions and should be replicated in all functions and in the struct when changed!
    UFUNCTION(BlueprintPure, meta=(DisplayName = "AsCurrency (integer) - DEPRECATED (use AsCurrency)"), Category="Utilities|Text")
    static ENGINE_API FText AsCurrency_Integer(int32 Value, TEnumAsByte<ERoundingMode> RoundingMode, bool bAlwaysSign = false, bool bUseGrouping = true, int32 MinimumIntegralDigits = 1, int32 MaximumIntegralDigits = 324, int32 MinimumFractionalDigits = 0, int32 MaximumFractionalDigits = 3, const FString& CurrencyCode = TEXT(""));
 
    // Default values are duplicated from FNumberFormattingOptions and should be replicated in all functions and in the struct when changed!
    UFUNCTION(BlueprintPure, meta=(DisplayName = "AsCurrency (float) - DEPRECATED (use AsCurrency)"), Category="Utilities|Text")
    static ENGINE_API FText AsCurrency_Float(float Value, TEnumAsByte<ERoundingMode> RoundingMode, bool bAlwaysSign = false, bool bUseGrouping = true, int32 MinimumIntegralDigits = 1, int32 MaximumIntegralDigits = 324, int32 MinimumFractionalDigits = 0, int32 MaximumFractionalDigits = 3, const FString& CurrencyCode = TEXT(""));
 
    // Default values are duplicated from FNumberFormattingOptions and should be replicated in all functions and in the struct when changed!
    UFUNCTION(BlueprintPure, meta=(DisplayName = "As Percent", AdvancedDisplay = "1"), Category="Utilities|Text")
    static ENGINE_API FText AsPercent_Float(float Value, TEnumAsByte<ERoundingMode> RoundingMode, bool bAlwaysSign = false, bool bUseGrouping = true, int32 MinimumIntegralDigits = 1, int32 MaximumIntegralDigits = 324, int32 MinimumFractionalDigits = 0, int32 MaximumFractionalDigits = 3);
 
    UFUNCTION(BlueprintPure, meta=(DisplayName = "As Date", AdvancedDisplay = "1"), Category="Utilities|Text")
    static ENGINE_API FText AsDate_DateTime(const FDateTime& InDateTime, TEnumAsByte<EDateTimeStyle::Type> InDateStyle = EDateTimeStyle::Default);
 
    UFUNCTION(BlueprintPure, meta=(DisplayName = "As Date (from UTC)", AdvancedDisplay = "1"), Category="Utilities|Text")
    static ENGINE_API FText AsTimeZoneDate_DateTime(const FDateTime& InDateTime, const FString& InTimeZone = TEXT(""), TEnumAsByte<EDateTimeStyle::Type> InDateStyle = EDateTimeStyle::Default);
 
    UFUNCTION(BlueprintPure, meta=(DisplayName = "As DateTime", AdvancedDisplay = "1"), Category="Utilities|Text")
    static ENGINE_API FText AsDateTime_DateTime(const FDateTime& In, TEnumAsByte<EDateTimeStyle::Type> InDateStyle = EDateTimeStyle::Default, TEnumAsByte<EDateTimeStyle::Type> InTimeStyle = EDateTimeStyle::Default);
 
    UFUNCTION(BlueprintPure, meta=(DisplayName = "As DateTime (from UTC)", AdvancedDisplay = "1"), Category="Utilities|Text")
    static ENGINE_API FText AsTimeZoneDateTime_DateTime(const FDateTime& InDateTime, const FString& InTimeZone = TEXT(""), TEnumAsByte<EDateTimeStyle::Type> InDateStyle = EDateTimeStyle::Default, TEnumAsByte<EDateTimeStyle::Type> InTimeStyle = EDateTimeStyle::Default);
 
    UFUNCTION(BlueprintPure, meta=(DisplayName = "As Time", AdvancedDisplay = "1"), Category="Utilities|Text")
    static ENGINE_API FText AsTime_DateTime(const FDateTime& In, TEnumAsByte<EDateTimeStyle::Type> InTimeStyle = EDateTimeStyle::Default);
 
    UFUNCTION(BlueprintPure, meta=(DisplayName = "As Time (from UTC)", AdvancedDisplay = "1"), Category="Utilities|Text")
    static ENGINE_API FText AsTimeZoneTime_DateTime(const FDateTime& InDateTime, const FString& InTimeZone = TEXT(""), TEnumAsByte<EDateTimeStyle::Type> InTimeStyle = EDateTimeStyle::Default);
 
    UFUNCTION(BlueprintPure, meta=(DisplayName = "As Timespan", AdvancedDisplay = "1"), Category="Utilities|Text")
    static ENGINE_API FText AsTimespan_Timespan(const FTimespan& InTimespan);
 
    UFUNCTION(BlueprintPure, meta=(AdvancedDisplay = "1"), Category="Utilities|Text")
    static ENGINE_API FText AsMemory(int64 NumBytes, TEnumAsByte<EMemoryUnitStandard> UnitStandard = EMemoryUnitStandard::IEC, bool bUseGrouping = true, int32 MinimumIntegralDigits = 1, int32 MaximumIntegralDigits = 324, int32 MinimumFractionalDigits = 0, int32 MaximumFractionalDigits = 3);
 
    UFUNCTION(BlueprintPure, meta=(BlueprintInternalUseOnly = "true"))
    static ENGINE_API FText Format(FText InPattern, TArray<FFormatArgumentData> InArgs);
 
    UFUNCTION(BlueprintPure, Category="Utilities|Text", meta=(DisplayName="Is Text from String Table"))
    static ENGINE_API bool TextIsFromStringTable(const FText& Text);
 
    UFUNCTION(BlueprintPure, Category="Utilities|Text", meta=(DisplayName="Make Text from String Table (Advanced)"))
    static ENGINE_API FText TextFromStringTable(const FName TableId, const FString& Key);
 
    UFUNCTION(BlueprintPure, Category="Utilities|Text", meta=(DisplayName="Get String Table ID and Key from Text"))
    static ENGINE_API bool StringTableIdAndKeyFromText(FText Text, FName& OutTableId, FString& OutKey);
 
    UFUNCTION(BlueprintPure, Category="Utilities|Text", meta=(DisplayName="Get ID from Text"))
    static ENGINE_API bool GetTextId(FText Text, FString& OutNamespace, FString& OutKey);
 
    UFUNCTION(BlueprintPure, Category="Utilities|Text", meta=(DisplayName="Get Source String from Text"))
    static ENGINE_API FString GetTextSourceString(FText Text);
 
    UFUNCTION(BlueprintPure, Category="Utilities|Text")
    static ENGINE_API void IsPolyglotDataValid(const FPolyglotTextData& PolyglotData, bool& IsValid, FText& ErrorMessage);
 
    UFUNCTION(BlueprintPure, Category="Utilities|Text")
    static ENGINE_API FText PolyglotDataToText(const FPolyglotTextData& PolyglotData);
 
    UFUNCTION(BlueprintCallable, CustomThunk, Category="Utilities|Text", meta=(DefaultToSelf="TextOwner"))
    static ENGINE_API bool EditTextSourceString(UObject* TextOwner, UPARAM(ref) FText& Text, const FString& SourceString, const bool bEmitChangeNotify = true);
    DECLARE_FUNCTION(execEditTextSourceString);
 
    UFUNCTION(BlueprintCallable, Category="Utilities|Text", meta=(DefaultToSelf="TextOwner"))
    static ENGINE_API bool EditTextPropertySourceString(UObject* TextOwner, const FName PropertyName, const FString& SourceString, const bool bEmitChangeNotify = true);
    static bool Generic_EditTextPropertySourceString(UObject* TextOwner, const FTextProperty* TextProperty, const FString& SourceString, const bool bEmitChangeNotify);
 
    UFUNCTION(BlueprintPure, CustomThunk, DisplayName = "To Text", Category = "Utilities|Text", meta = (CustomStructureParam = "Value", BlueprintInternalUseOnly = "true"))
    static ENGINE_API FText Conv_NumericPropertyToText(UPARAM(ref) const int32& Value);
    DECLARE_FUNCTION(execConv_NumericPropertyToText);
};