Internationalization.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
#include "Containers/Array.h"
#include "Containers/UnrealString.h"
#include "CoreTypes.h"
#include "Delegates/Delegate.h"
#include "Internationalization/CulturePointer.h"
#include "Internationalization/LocTesting.h"
#include "Internationalization/Text.h"
#include "Templates/SharedPointer.h"
#include "Templates/Tuple.h"
#include "Templates/UniqueObj.h"
#include "UObject/NameTypes.h"
 
#define LOC_DEFINE_REGION
 
class FCulture;
class FICUInternationalization;
class FLegacyInternationalization;
class ICustomCulture;
 
class FInternationalization
{
    friend class FTextChronoFormatter;
 
public:
    static CORE_API FInternationalization& Get();
 
    static CORE_API bool IsAvailable();
 
    static CORE_API void TearDown();
 
    UE_DEPRECATED(5.5, "FInternationalization::ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText is deprecated in favor of FText::AsLocalizable_Advanced (NOTE: FText::AsLocalizable_Advanced takes its arguments in a different order!).")
    static UE_FORCEINLINE_HINT FText ForUseOnlyByLocMacroAndGraphNodeTextLiterals_CreateText(const TCHAR* InTextLiteral, const TCHAR* InNamespace, const TCHAR* InKey)
    {
        return FText::AsLocalizable_Advanced(InNamespace, InKey, InTextLiteral);
    }
 
    struct FCultureStateSnapshot
    {
        FString Language;
        FString Locale;
        TArray<TTuple<FName, FString>> AssetGroups;
    };
 
    CORE_API bool SetCurrentCulture(const FString& InCultureName);
 
    FCultureRef GetCurrentCulture() const
    {
        return CurrentLanguage.ToSharedRef();
    }
 
    CORE_API bool SetCurrentLanguage(const FString& InCultureName);
 
    FCultureRef GetCurrentLanguage() const
    {
        return CurrentLanguage.ToSharedRef();
    }
 
    CORE_API bool SetCurrentLocale(const FString& InCultureName);
 
    FCultureRef GetCurrentLocale() const
    {
        return CurrentLocale.ToSharedRef();
    }
 
    CORE_API bool SetCurrentLanguageAndLocale(const FString& InCultureName);
 
    CORE_API bool SetCurrentAssetGroupCulture(const FName& InAssetGroupName, const FString& InCultureName);
 
    CORE_API FCultureRef GetCurrentAssetGroupCulture(const FName& InAssetGroupName) const;
 
    CORE_API void ClearCurrentAssetGroupCulture(const FName& InAssetGroupName);
 
    CORE_API FCulturePtr GetCulture(const FString& InCultureName);
 
    FCultureRef GetDefaultCulture() const
    {
        return DefaultLanguage.ToSharedRef();
    }
 
    FCultureRef GetDefaultLanguage() const
    {
        return DefaultLanguage.ToSharedRef();
    }
 
    FCultureRef GetDefaultLocale() const
    {
        return DefaultLocale.ToSharedRef();
    }
 
    FCultureRef GetInvariantCulture() const
    {
        return InvariantCulture.ToSharedRef();
    }
 
    CORE_API TArray<FCultureRef> GetCurrentCultures(const bool bIncludeLanguage, const bool bIncludeLocale, const bool bIncludeAssetGroups) const;
 
    CORE_API void BackupCultureState(FCultureStateSnapshot& OutSnapshot) const;
 
    CORE_API void RestoreCultureState(const FCultureStateSnapshot& InSnapshot);
 
    bool IsInitialized() const {return bIsInitialized;}
 
    CORE_API void LoadAllCultureData();
 
    CORE_API void AddCustomCulture(const TSharedRef<ICustomCulture>& InCustomCulture);
 
    CORE_API FCulturePtr GetCustomCulture(const FString& InCultureName) const;
 
    CORE_API bool IsCultureRemapped(const FString& Name, FString* OutMappedCulture);
 
    CORE_API bool IsCultureAllowed(const FString& Name);
 
    CORE_API void RefreshCultureDisplayNames(const TArray<FString>& InPrioritizedDisplayCultureNames);
 
    CORE_API void RefreshCachedConfigData();
 
#if ENABLE_LOC_TESTING
    static CORE_API FString& Leetify(FString& SourceString);
#endif
 
    CORE_API void GetCultureNames(TArray<FString>& CultureNames) const;
 
    CORE_API TArray<FString> GetPrioritizedCultureNames(const FString& Name);
 
    UE_DEPRECATED(4.20, "FInternationalization::GetCulturesWithAvailableLocalization is deprecated in favor of calling FTextLocalizationManager::GetLocalizedCultureNames, potentially followed by FInternationalization::GetAvailableCultures")
    CORE_API void GetCulturesWithAvailableLocalization(const TArray<FString>& InLocalizationPaths, TArray<FCultureRef>& OutAvailableCultures, const bool bIncludeDerivedCultures);
 
    CORE_API TArray<FCultureRef> GetAvailableCultures(const TArray<FString>& InCultureNames, const bool bIncludeDerivedCultures);
 
    DECLARE_EVENT(FInternationalization, FCultureChangedEvent)
    FCultureChangedEvent& OnCultureChanged() { return CultureChangedEvent; }
 
private:
    FInternationalization();
    ~FInternationalization();
    friend class FLazySingleton;
 
    void BroadcastCultureChanged() { CultureChangedEvent.Broadcast(); }
 
    void Initialize();
    void Terminate();
 
private:
    bool bIsInitialized = false;
 
    FCultureChangedEvent CultureChangedEvent;
 
#if UE_ENABLE_ICU
    friend class FICUInternationalization;
    typedef FICUInternationalization FImplementation;
#else
    friend class FLegacyInternationalization;
    typedef FLegacyInternationalization FImplementation;
#endif
    TUniqueObj<FImplementation> Implementation;
 
    FCulturePtr CurrentLanguage;
 
    FCulturePtr CurrentLocale;
 
    TArray<TTuple<FName, FCulturePtr>> CurrentAssetGroupCultures;
 
    FCulturePtr DefaultLanguage;
 
    FCulturePtr DefaultLocale;
 
    FCulturePtr InvariantCulture;
 
    TArray<FCultureRef> CustomCultures;
};
 
namespace UE::Private::LocGen
{
    inline FCulturePtr GetCultureByName(const TCHAR* InCulture)
    {
        return (InCulture && *InCulture)
            ? FInternationalization::Get().GetCulture(InCulture)
            : nullptr;
    }
}
 
#undef LOCTEXT_NAMESPACE
 
#define LOCTEXT(InKey, InTextLiteral) FText::AsLocalizable_Advanced_LocText(TEXT(LOCTEXT_NAMESPACE), TEXT(InKey), TEXT(InTextLiteral))
 
#define NSLOCTEXT(InNamespace, InKey, InTextLiteral) FText::AsLocalizable_Advanced_LocText(TEXT(InNamespace), TEXT(InKey), TEXT(InTextLiteral))
 
#define INVTEXT(InTextLiteral) FText::AsCultureInvariant(TEXT(InTextLiteral))
 
#define LOCGEN_NUMBER(InNum, InCulture) FText::AsNumber(InNum, nullptr, UE::Private::LocGen::GetCultureByName(TEXT(InCulture)))
#define LOCGEN_NUMBER_GROUPED(InNum, InCulture) FText::AsNumber(InNum, &FNumberFormattingOptions::DefaultWithGrouping(), UE::Private::LocGen::GetCultureByName(TEXT(InCulture)))
#define LOCGEN_NUMBER_UNGROUPED(InNum, InCulture) FText::AsNumber(InNum, &FNumberFormattingOptions::DefaultNoGrouping(), UE::Private::LocGen::GetCultureByName(TEXT(InCulture)))
#define LOCGEN_NUMBER_CUSTOM(InNum, InOpts, InCulture) FText::AsNumber(InNum, &FNumberFormattingOptions().InOpts, UE::Private::LocGen::GetCultureByName(TEXT(InCulture)))
 
#define LOCGEN_PERCENT(InNum, InCulture) FText::AsPercent(InNum, nullptr, UE::Private::LocGen::GetCultureByName(TEXT(InCulture)))
#define LOCGEN_PERCENT_GROUPED(InNum, InCulture) FText::AsPercent(InNum, &FNumberFormattingOptions::DefaultWithGrouping(), UE::Private::LocGen::GetCultureByName(TEXT(InCulture)))
#define LOCGEN_PERCENT_UNGROUPED(InNum, InCulture) FText::AsPercent(InNum, &FNumberFormattingOptions::DefaultNoGrouping(), UE::Private::LocGen::GetCultureByName(TEXT(InCulture)))
#define LOCGEN_PERCENT_CUSTOM(InNum, InOpts, InCulture) FText::AsPercent(InNum, &FNumberFormattingOptions().InOpts, UE::Private::LocGen::GetCultureByName(TEXT(InCulture)))
 
#define LOCGEN_CURRENCY(InNum, InCurrency, InCulture) FText::AsCurrencyBase(InNum, TEXT(InCurrency), UE::Private::LocGen::GetCultureByName(TEXT(InCulture)))
 
#define LOCGEN_DATE_UTC(InUnixTime, InDateStyle, InTimeZone, InCulture) FText::AsDate(FDateTime::FromUnixTimestamp(InUnixTime), InDateStyle, TEXT(InTimeZone), UE::Private::LocGen::GetCultureByName(TEXT(InCulture)))
#define LOCGEN_DATE_LOCAL(InUnixTime, InDateStyle, InCulture) FText::AsDate(FDateTime::FromUnixTimestamp(InUnixTime), InDateStyle, FText::GetInvariantTimeZone(), UE::Private::LocGen::GetCultureByName(TEXT(InCulture)))
 
#define LOCGEN_TIME_UTC(InUnixTime, InTimeStyle, InTimeZone, InCulture) FText::AsTime(FDateTime::FromUnixTimestamp(InUnixTime), InTimeStyle, TEXT(InTimeZone), UE::Private::LocGen::GetCultureByName(TEXT(InCulture)))
#define LOCGEN_TIME_LOCAL(InUnixTime, InTimeStyle, InCulture) FText::AsTime(FDateTime::FromUnixTimestamp(InUnixTime), InTimeStyle, FText::GetInvariantTimeZone(), UE::Private::LocGen::GetCultureByName(TEXT(InCulture)))
 
#define LOCGEN_DATETIME_UTC(InUnixTime, InDateStyle, InTimeStyle, InTimeZone, InCulture) FText::AsDateTime(FDateTime::FromUnixTimestamp(InUnixTime), InDateStyle, InTimeStyle, TEXT(InTimeZone), UE::Private::LocGen::GetCultureByName(TEXT(InCulture)))
#define LOCGEN_DATETIME_LOCAL(InUnixTime, InDateStyle, InTimeStyle, InCulture) FText::AsDateTime(FDateTime::FromUnixTimestamp(InUnixTime), InDateStyle, InTimeStyle, FText::GetInvariantTimeZone(), UE::Private::LocGen::GetCultureByName(TEXT(InCulture)))
 
#define LOCGEN_DATETIME_CUSTOM_UTC(InUnixTime, InPattern, InTimeZone, InCulture) FText::AsDateTime(FDateTime::FromUnixTimestamp(InUnixTime), TEXT(InPattern), TEXT(InTimeZone), UE::Private::LocGen::GetCultureByName(TEXT(InCulture)))
#define LOCGEN_DATETIME_CUSTOM_LOCAL(InUnixTime, InPattern, InCulture) FText::AsDateTime(FDateTime::FromUnixTimestamp(InUnixTime), TEXT(InPattern), FText::GetInvariantTimeZone(), UE::Private::LocGen::GetCultureByName(TEXT(InCulture)))
 
#define LOCGEN_TOUPPER(InText) (InText).ToUpper()
 
#define LOCGEN_TOLOWER(InText) (InText).ToLower()
 
#define LOCGEN_FORMAT_ORDERED(InPattern, ...) FText::FormatOrdered(InPattern, __VA_ARGS__)
 
#define LOCGEN_FORMAT_NAMED(InPattern, ...) FText::FormatNamed(InPattern, __VA_ARGS__)
 
#undef LOC_DEFINE_REGION