Localisation de texte dans l'Unreal Engine | Unreal Engine 5.7 Documentation

Le texte dans l'Unreal Engine (l'UE) est le composant principal de la localisation. Il s'agit d'une chaîne spécialisée, représentée par le type FText en C++. Elle doit être utilisée lorsque vous avez du texte destiné à l'utilisateur qui doit être localisé.

En interne, FText est implémenté en tant que TSharedRef dans un ITextData. Cela permet de le copier très facilement, et l'utilitaire FTextSnapshot offre un moyen efficace de détecter si une valeur FText mise en cache a réellement changé.

Les données contenues dans les instances de FText varient en fonction de la manière dont FText a été créé. Cette variance est gérée par l'« historique du texte » interne (FTextHistory). Les historiques de textes prennent en charge la reconstruction culturellement correcte du texte et constituent également l'élément clé pour les éléments suivants :

Le changement de culture en direct.
L'envoi de FText sur le réseau.
La création de sources indépendantes de la culture.

La conversion de FText en FString est généralement une opération avec perte, car elle perd l'historique du texte. Vous ne devez le faire que si vous n'avez plus besoin des données de localisation. Par exemple, s'il existe une API de niveau inférieur qui fonctionne sur des chaînes, qui est gérée par une API de niveau supérieur qui surveille les modifications de texte (comme STextBlock). Cette conversion peut également être utilisée lors de la transmission des données à une API externe qui n'accepte que les chaînes.

Si vous avez besoin d'un texte non localisable (comme la conversion d'un nom de joueur d'une API externe en un élément que vous pouvez afficher dans votre interface utilisateur), vous pouvez utiliser FText::AsCultureInvariant, qui produit une instance de FText qui n'a pas de données de localisation (et ne peut pas être localisée). La macro INVTEXT peut faire la même chose pour les chaînes de littéraux.

Littéraux de texte

Un texte localisable est constitué de trois éléments : un espace de noms ; une clé (qui forme son identité) ; et une chaîne source (qui est la base de ce qui est traduit et agit comme validation contre les traductions « obsolètes »). La manière la plus courante de créer du texte localisable dans l'UE est d'utiliser un littéral de texte.

Créer des littéraux de texte en C++

Les littéraux de texte peuvent être créés en C++ à l'aide de la famille de macros LOCTEXT.

Macros de littéraux de texte

Macro	Description
NSLOCTEXT	Créer un bloc de texte localisé en définissant l'espace de noms, la clé et la chaîne source.
LOCTEXT	Créer un bloc de texte localisé en définissant la clé et la chaîne source, l'espace de noms étant défini avec `LOCTEXT_NAMESPACE`.

Exemple :

	// Définir l'espace de noms à utiliser avec LOCTEXT
	// Ceci est uniquement valide dans un fichier unique et doit être non défini avant la fin du fichier
	#Définir LOCTEXT_NAMESPACE "MyNamespace"
	// Créer des littéraux de texte
	constFTextHelloWorld= NSLOCTEXT("MonAutreEspaceDeNoms","BonjourLeMonde","Bonjour le monde !")
	constFTextGoodbyeWorld= LOCTEXT("AuRevoirLeMonde", "Au revoir le monde !")
	// Annuler la définition de l'espace de noms avant la fin du fichier
	#undef LOCTEXT_NAMESPACE

Création de littéraux de texte dans des fichiers INI

Les littéraux de texte peuvent être créés dans des fichiers INI à l'aide de syntaxe de macro NSLOCTEXT .

Création de littéraux de texte dans des ressources

Les littéraux de texte peuvent être créés à l'aide des propriétés FText. Une clé est générée automatiquement pour vous, mais vous pouvez définir un espace de noms personnalisé ou une clé personnalisée pour votre texte en utilisant la liste déroulante avancée à côté du champ de texte. Il est également possible d'utiliser l'espace de noms ou la clé par défaut.

Mise en forme du texte

La mise en forme du texte offre un moyen de combiner des éléments textuels de manière plus facilement localisable, en utilisant un modèle de format localisable qui injecte le texte réel pour remplacer les espaces réservés au format.

Les espaces réservés au format sont contenus dans une paire d'accolades et peuvent être des nombres (pour la mise en forme basée sur l'index) ou des chaînes (pour la mise en forme basée sur le nom). Exemple :

« Il vous reste {0} points de vie. » « Il vous reste {CurrentHealth} points de vie. »

Les espaces réservés au format peuvent également spécifier une fonction [appelée « argument modifier » (modificateur d'argument)] à exécuter sur leurs données d'argument. Ceux-ci sont spécifiés sous la forme d'une barre verticale suivie du nom de la fonction et des arguments. Exemple :

"{NumCats} {NumCats}|plural(one=chat,other=chats)"

Vous pouvez utiliser le caractère accent grave (`) pour échapper aux accolades et aux barres verticales et éviter qu'ils ne soient traités des éléments de mise en forme. Vous pouvez également utiliser le caractère accent grave pour produire un caractère littéral `.

Exemple : Le tableau suivant suppose que la valeur de Res est un entier dont la valeur est 10.

Entrée	Résultat du texte formaté
Result `{ {Res} } Result `{ {Res} }	`Result { 10 }` Result { 10 }
Result \`\`{Res}\`\` Result \`\`{Res}\`\`	Result \`10\` Result \`10\`

Mise en forme de texte en C++

La mise en forme du texte en C++ est gérée par la famille de fonctions FText::Format . Chaque fonction prend un modèle FTextFormat, qui sera construit implicitement à partir d'une instance de FText, suivi d'arguments supplémentaires tels que définis dans le tableau ci-dessous.

Argument	Type de mise en forme	Description
FText::Format	Mise en forme générale du texte.	Accepter soit des arguments basés sur des index (en utilisant `FFormatOrderedArguments` ou des arguments variadiques), soit des arguments basés sur des noms (en utilisant `FFormatNamedArguments`).
FText::FormatOrdered	Mise en forme basée sur l'index variadique.	Accepter tous les arguments à partir desquels `FFormatArgumentValue` peut construire.
FText::FormatNamed	Mise en forme basée sur le nom variadique.	Accepter des arguments de nom consécutifs (tout élément à partir duquel `FString` peut construire) puis des arguments de valeur consécutifs (tout élément à partir duquel `FFormatArgumentValue` peut construire).

Vous devriez envisager de précompiler les modèles de format que vous utilisez fréquemment dans un FTextFormat pour améliorer les performances de mise en forme. Le modèle compilé est automatiquement recompilé si la culture active change.

Mise en forme de texte dans des blueprints

La mise en forme du texte dans des blueprints est gérée par le nœud Format Text. Ce nœud peut soit prendre un modèle de format littéral, soit avoir le modèle lié à une autre broche de texte.

Lorsqu'un modèle de format littéral est spécifié, les broches d'argument de format sont générées automatiquement.
Lorsque le modèle de format est lié à une autre broche de texte, vous devez spécifier manuellement les arguments du format à l'aide du panneau Détails du nœud.

Modificateurs d'argument

Les modificateurs d'argument fournissent un moyen de prétraiter un argument avant qu'il ne soit ajouté à la chaîne formatée. Les modificateurs d'argument sont extensibles. Vous créez un modificateur d'argument en implémentant l'interface ITextFormatArgumentModifier et en enregistrant une fonction de fabrique pour un mot-clé donné (voir FTextFormatter::RegisterTextArgumentModifier).

L'UE fournit certains modificateurs d'arguments par défaut : il existe des modificateurs pour la pluralité, le genre et les post-positions Hangul.

Formes plurielles

Les formes plurielles permettent d'utiliser un texte différent en fonction d'une variable numérique donnée au format de texte. Les formes plurielles peuvent être cardinales (comme « Il y a 1 chat » ou « Il y a 4 chats ») ou ordinales (comme « Vous avez fini 1er ! » ou « Vous avez fini 2e ! »). Les formes plurielles sont spécifiées sous forme de paires clé-valeur et prennent en charge l'un des mots-clés suivants (tels que définis pour votre culture par les données CLDR) : zéro, un, deux, quelques-uns, plusieurs, autre. Les valeurs sont des chaînes de caractères, éventuellement entre guillemets, qui peuvent aussi contenir des marqueurs de format.

Exemple de format cardinal :

	"Il y {NumCats}|plural(one=a,other=a) {NumCats} {NumCats}|plural(one=chat,other=chats)"

Exemple de format ordinal :

	"Vous avez fini {Place}{Place}|ordinal(one=1er,two=e,few=e,other=e) !"

Formes de genre

Les formes de genre vous permettent d'utiliser un texte différent en fonction d'une valeur ETextGender donnée à votre format de texte, comme « Le guerrier est fort » ou « La guerrière est forte ». Les formes de genre sont spécifiées sous la forme d'une liste de valeurs dans l'ordre [masculin, féminin, neutre], où le neutre est facultatif. Les valeurs sont des chaînes de caractères, éventuellement entre guillemets, qui peuvent également contenir des marqueurs de format.

Exemple de format :

	"{Gender}|gender(Le,La) {Gender}|gender(guerrier,guerrière) est {Gender}|gender(fort,forte)"

Post-positions Hangul

Les post-positions Hangul vous aident à suivre les règles grammaticales présentes en coréen et insérent le(s) glyphe(s) correct(s) selon que la valeur insérée se termine par une consonne ou une voyelle, comme « 사람은 » ou « 사자는 ». Les post-positions Hangul sont spécifiées sous la forme d'une liste de valeurs dans l'ordre [consonne, voyelle]. Les valeurs sont une chaîne éventuellement entre guillemets.

Exemple de format :

	"{Arg}|hpp(은,는)"

Bonnes pratiques de mise en forme du texte

Lors de l'injection d'un nombre qui affecte la phrase, gérez ces variations en utilisant des modificateurs d'argument de formes plurielles, plutôt qu'en créant des branches dans le code. Lorsque vous utilisez des formes plurielles, la phrase est correctement traduite pour les langues qui ne partagent pas les règles du pluriel de votre langue source.
Lorsque vous injectez un nom personnel, assurez-vous d'inclure un argument pour le genre de la personne. Ceci est important pour les langues avec des règles grammaticales pour le genre, car cela permet à vos traducteurs de changer leur traduction en fonction du genre (voir Formes de genre).
Évitez d'injecter des noms d'objets (tels que « table », « porte » ou « chaise »), sauf si vous êtes prêt à les rendre localisables. Ces noms peuvent avoir un genre dans une langue et un genre différent dans une autre langue. Cela rend la chaîne de modèle de format impossible à localiser avec précision sans métadonnées par culture. En principe, vous devriez inclure des phrases complètes plutôt que simplement le nom. Cela garantit des traductions précises.

De futures versions d'UE pourraient inclure une fonction permettant aux traducteurs d'utiliser des métadonnées pour marquer le texte représentant des noms, afin qu'ils puissent ensuite les utiliser dans des modèles de formatage pour produire des traductions précises.
Évitez de concaténer des phrases partielles. Cela peut entraîner des problèmes, car il est possible que chaque clause ou partie soit traduite correctement, alors que la traduction de l'ensemble pourrait être incorrecte. Il est préférable de réécrire le texte en phrases complètes afin d'assurer une traduction correcte.

Génération de texte

La génération de texte utilise des données d'internationalisation pour produire un texte culturellement correct qui ne dépend pas de la localisation directe. Il existe trois types de génération de texte : numérique, chronologique et transformative.

Génération de texte numérique

La génération numérique est utilisée pour convertir les types numériques en une représentation textuelle facile à lire pour les humains. Les règles exactes en la matière sont spécifiques à chaque culture et peuvent également être adaptées à chaque génération si un contrôle plus spécifique est nécessaire.

Par exemple, selon les règles de génération par défaut, le nombre en virgule flottante « 1234,5 » serait généré sous la forme « 1,234.5 » en anglais, « 1 234,5 » en français et « ١٬٢٣٤٫٥ » en arabe.

Génération numérique en C++

La génération numérique en C++ est gérée par les fonctions suivantes.

Fonction	Description
FText::AsNumber	Convertir tout type numérique pris en charge par l'UE en une représentation textuelle conviviale (« 1234,5 » devient « 1 234,5 »).
FText::AsPercent	Convertir une valeur float ou double en une représentation textuelle en pourcentage (« 0,2 » devient 20 %).
FText::AsMemory	Convertir une valeur (en octets) en une représentation mémoire conviviale (« 1234 » devient « 1,2 Ko »).
FText::AsCurrencyBase	Convertir une valeur dans la représentation de base d'une devise en une représentation monétaire conviviale (« 1234,50 » pour la devise « USD » devient « 1 234,50 $ »).

La plupart des fonctions du tableau prennent un [FNumberFormattingOptions](https://api.unrealengine.com/INT/API/Runtime/Core/Internationalization/FNumberFormattingOptions/index.html) facultatif pour contrôler la sortie (la valeur par défaut est tirée des paramètres régionaux actifs), ainsi qu'une culture facultative (la valeur par défaut étant les paramètres régionaux actifs).

Génération numérique dans les blueprints

La génération numérique dans les blueprints est gérée par les nœuds suivants.

Nœuds	Description
ToText (byte), ToText (integer), ToText (float)	Convertir les types numériques pris en charge en une représentation textuelle conviviale (« 1234,5 » devient « 1 234,5 »).
AsPercent	Convertir une valeur float ou double en une représentation textuelle en pourcentage (« 0,2 » devient 20 %).
AsCurrency	Convertir une valeur dans la représentation de base d'une devise en une représentation monétaire conviviale (« 1234,50 » pour la devise « USD » devient « 1 234,50 $ »).

La plupart des nœuds de la table prennent des arguments avancés pour contrôler la sortie.

Chronologique

La génération chronologique est utilisée pour convertir les types de date et d'heure en une représentation textuelle facile à lire pour les humains. Les règles exactes en la matière sont propres à chaque culture, et le style de date et d'heure peut être ajusté par génération si un contrôle plus précis est nécessaire.

Selon les règles de génération par défaut, une date représentant le 22e jour du 5e mois de l'année 1998 générerait « May 22, 1998 » en anglais (États-Unis), « 22 May 1998 » en anglais (Royaume-Uni), « 22 mai 1998 » en français et « ٢٢/٠٥/١٩٩٨ » en arabe.

Génération chronologique en C++

La génération chronologique en C++ est gérée par les fonctions suivantes.

Fonction	Description
FText::AsDate	Convertir une valeur `FDateTime` en une représentation de date conviviale.
FText::AsTime	Convertir une valeur `FDateTime` en une représentation temporelle conviviale.
FText::AsDateTime	Convertir une valeur `FDateTime` en une représentation conviviale de la date et de l'heure.
FText::AsTimespan	Convertir une valeur `FTimespan` en une représentation de temps delta conviviale (en heures, minutes et secondes).

La plupart des éléments ci-dessus utilisent EDateTimeStyle pour contrôler la sortie (la valeur par défaut est tirée des paramètres régionaux actifs, mais peut être définie sur « court », « moyen », « long » ou « complet »).

La génération de temps s'attend à recevoir par défaut une heure basée sur l'UTC (qu'elle convertira dans le fuseau horaire local). Si l'heure donnée n'est pas basée sur l'UTC (par exemple si elle est déjà en heure locale), vous devez alors transmettre [FText::GetInvariantTimeZone()](https://api.unrealengine.com/INT/API/Runtime/Core/Internationalization/FText/GetInvariantTimeZone/index.html) comme argument de fuseau horaire.

Génération chronologique dans les blueprints

La génération chronologique dans les blueprints est gérée par les nœuds suivants.

Nœuds	Description
AsDate	Convertir une valeur « DateTime » non basée sur l'UTC en une représentation de date conviviale telle quelle (sans ajustement au fuseau horaire local).
AsDate (from UTC)	Convertir une valeur « DateTime » basée sur l'UTC en une représentation de date conviviale (s'ajustant au fuseau horaire local).
AsTime	Convertir une valeur « DateTime » non basée sur l'UTC en une représentation horaire conviviale telle quelle (sans ajustement au fuseau horaire local).
AsTime (from UTC)	Convertir une valeur « DateTime » basée sur l'UTC en une représentation horaire conviviale (s'ajustant au fuseau horaire local).
AsDateTime	Convertir une valeur « DateTime » non basée sur l'UTC en une représentation conviviale de la date et de l'heure telle quelle (sans ajustement au fuseau horaire local).
AsDateTime (from UTC)	Convertir une valeur « DateTime » basée sur l'UTC en une représentation conviviale de la date et de l'heure (s'ajustant au fuseau horaire local).
AsTimespan	Convertir une valeur « Timespan » en une représentation de temps delta conviviale (en heures, minutes et secondes).

Transformative

La génération transformative est utilisée pour convertir un texte en une représentation différente de lui-même. Par exemple, vous pouvez convertir un texte en minuscules en texte en majuscules et inversement.

Génération transformative en C++

La génération transformative en C++ est gérée par les fonctions suivantes.

Fonction	Description
FText::ToLower	Convertir une instance de 'FText' en sa forme minuscule d'une manière compatible à Unicode.
FText::ToUpper	Convertir une instance de 'FText' en sa forme en majuscule d'une manière compatible à Unicode.

Génération transformative dans les blueprints

La génération transformative dans les blueprints est gérée par les nœuds suivants.

Nœud	Description
Text to Lower	Convertir une instance de « Texte » en sa forme minuscule d'une manière compatible à Unicode.
Text to Upper	Convertir une instance de « Texte » en sa forme majuscule d'une manière compatible à Unicode.

Tables de chaînes

Les tables de chaînes permettent de centraliser le texte localisé dans un (ou plusieurs) emplacement connu, puis de référencer les entrées d'une table de chaînes à partir d'autres ressources ou codes d'une manière rigoureuse qui permet une réutilisation facile du texte localisé.

Les tables de chaînes peuvent être définies en C++, chargées à l'aide d'un fichier CSV ou créées en tant que ressource. Consultez la page Tables de chaînes pour plus d'informations.

Conversion des paramètres de valeur de texte

Les valeurs de texte peuvent être converties sans perte en chaînes (à l'aide de FTextStringHelper, ou des fonctions ImportText et ExportText de UTextProperty).

Les formats suivants sont pris en charge :

Littéral de texte	Description
`NSLOCTEXT`	Un littéral de texte qui spécifie l'espace de noms, la clé et la chaîne source.
`LOCTEXT`	Un littéral de texte qui spécifie la clé et la chaîne source.
`LOCTABLE`	Une référence de table de chaînes.
`INVTEXT`	Un extrait de texte indépendant de la culture (voir `FText::AsCultureInvariant`).
`LOCGEN_NUMBER`	Un extrait de texte généré à partir d'un nombre (voir `FText::AsNumber`).
`LOCGEN_NUMBER_GROUPED`	Un extrait de texte généré à partir d'un nombre avec le regroupement activé (voir `FText::AsNumber` et `FNumberFormattingOptions::DefaultWithGrouping`).
`LOCGEN_NUMBER_UNGROUPED`	Un extrait de texte généré à partir d'un nombre avec le regroupement désactivé (voir `FText::AsNumber` et `FNumberFormattingOptions::DefaultNoGrouping`).
`LOCGEN_NUMBER_CUSTOM`	Un extrait de texte généré à partir d'un nombre avec des options de mise en forme personnalisées (voir `FText::AsNumber` et `FNumberFormattingOptions`).
`LOCGEN_PERCENT`	Un extrait de texte généré à partir d'un nombre sous forme de pourcentage (voir `FText::AsPercent`).
`LOCGEN_PERCENT_GROUPED`	Un extrait de texte généré à partir d'un nombre sous forme de pourcentage avec le regroupement activé (voir `FText::AsPercent` et `FNumberFormattingOptions::DefaultWithGrouping`).
`LOCGEN_PERCENT_UNGROUPED`	Un extrait de texte généré à partir d'un nombre sous forme de pourcentage avec le regroupement désactivé (voir `FText::AsPercent` et `FNumberFormattingOptions::DefaultNoGrouping`).
`LOCGEN_PERCENT_CUSTOM`	Un extrait de texte généré à partir d'un nombre sous forme de pourcentage avec des options de mise en forme personnalisées (voir `FText::AsPercent` et `FNumberFormattingOptions`).
`LOCGEN_CURRENCY`	Un extrait de texte généré à partir d'un nombre comme devise (voir `FText::AsCurrencyBase`).
`LOCGEN_DATE_UTC`	Un extrait de texte généré à partir d'une date UTC ajustée au fuseau horaire spécifié ou local (voir `FText::AsDate`).
`LOCGEN_DATE_LOCAL`	Un extrait de texte généré à partir d'une date non UTC sans ajustement de fuseau horaire (voir `FText::AsDate`).
`LOCGEN_TIME_UTC`	Un extrait de texte généré à partir d'une heure UTC ajustée au fuseau horaire spécifié ou local (voir `FText::AsTime`).
`LOCGEN_TIME_LOCAL`	Un extrait de texte généré à partir d'une heure non UTC sans ajustement de fuseau horaire (voir `FText::AsTime`).
`LOCGEN_DATETIME_UTC`	Un extrait de texte généré à partir d'une date et d'une heure UTC ajustées au fuseau horaire spécifié ou local (voir `FText::AsDateTime`).
`LOCGEN_DATETIME_LOCAL`	Un extrait de texte généré à partir d'une date et d'une heure non-UTC sans ajustement de fuseau horaire (voir `FText::AsDateTime`).
`LOCGEN_TOLOWER`	Un extrait de texte converti en minuscules d'une manière compatible à Unicode (voir `FText::ToLower`).
`LOCGEN_TOUPPER`	Un extrait de texte converti en majuscules d'une manière compatible à Unicode (voir `FText::ToUpper`).
`LOCGEN_FORMAT_ORDERED`	Un extrait de texte généré à partir d'un modèle de mise en forme utilisant des arguments basés sur des index (voir `FText::FormatOrdered`).
`LOCGEN_FORMAT_NAMED`	Un extrait de texte généré à partir d'un modèle de mise en forme utilisant des arguments basés sur le nom (voir `FText::FormatNamed`).

Les chaînes « brutes » peuvent également être importées, mais une nouvelle clé sera générée pour chaque importation. Cela produit des clés instables pour la localisation.

Table de données

L'une des causes courantes de clés de localisation instables est l'importation itérative de chaînes brutes d'un fichier CSV dans une table de données, car cela entraîne la génération d'une nouvelle clé après chaque importation. Une solution à ce problème consiste à assigner au texte importé une clé déterministe après l'importation en remplaçant la fonction OnPostDataImport sur votre structure de ligne et en appelant FText::ChangeKey pour assigner la nouvelle clé.

En général, nous utilisons le nom de la table de données comme espace de noms et une combinaison du nom de la ligne et du nom de la propriété comme clé. Exemple :

	voidFMyTableRow::OnPostDataImport(constUDataTable*InDataTable,constFNameInRowName,TArray&OutCollectedImportProblems)
	{
	#if WITH_EDITOR
		MyTextProperty = FText::ChangeKey(
		InDataTable->GetName(),
		FString::Printf(TEXT("%s_%s"),*InRowName.ToString(), GET_MEMBER_NAME_STRING_CHECKED(FMyTableRow,MyTextProperty)),
		MyTextProperty
		);
	#endif// WITH_EDITOR
	}

À partir de la version 4.22, les clés déterministes sont déjà appliquées à toutes les chaînes brutes importées dans une table de données, mais vous pouvez toujours remplacer OnPostDataImport si vous avez besoin d'un comportement de génération de clés personnalisé.

Données Polyglot

Les données Polyglot permettent d'ajouter de nouvelles données de localisation au moment de l'exécution, soit pour s'interfacer avec un système externe, soit pour permettre la localisation dynamique sans créer de nouveaux fichiers LocRes.

Les données Polyglot comprennent : un espace de noms et une clé (son identité) ; une chaîne native ; la catégorie du texte (comme un jeu, un moteur, un éditeur), pour contrôler quand les données Polyglot sont utilisées ; une culture native facultative (qui reviendra à la culture native de la catégorie si elle n'est pas définie) ; et une série de traductions par culture.

Si vous souhaitez utiliser des données Polyglot pour remplacer une traduction existante, vous devez vous assurer que l'espace de noms, la clé et la chaîne native des données Polyglot correspondent à ceux du texte source que vous souhaitez remplacer.

Données Polyglot en C++

Les données Polyglot en C++ sont représentées par le type FPolyglotTextData et elles peuvent être utilisées directement (en utilisant FPolyglotTextData::GetText pour résoudre les données Polyglot en une instance de texte). Elles peuvent également être transmises à FTextLocalizationManager::RegisterPolyglotTextData (pour corriger les entrées de texte existantes).

Données Polyglot dans les blueprints

Les données Polyglot dans les blueprints sont représentées par le type Polyglot Text Data (Données de texte Polyglot) et peuvent être utilisées avec la fonction Polyglot Data to Text (Données Polyglot en texte) pour résoudre les données Polyglot en une instance de texte.

Sources de texte localisées

Les sources de texte localisées constituent le principal moyen par lequel le gestionnaire de localisation de texte de l'UE détecte et traite les données de texte localisées. L'UE en fournit deux par défaut, à savoir FLocalizationResourceTextSource (qui héberge le support LocRes) et FPolyglotTextSource (qui héberge le support des données Polyglot).

Les sources de texte localisées peuvent fournir un moyen d'interagir avec un système externe et peuvent être ajoutées projet par projet en créant et en enregistrant un type dérivé de ILocalizedTextSource.