Translations / i18n / localizations for programs/fr: what changed

Revision 1 to 2. Removed lines have a minus sign; added lines have a plus sign.

Old	New		Line
1	1		## Vue d'ensemble
2	2
3	3		Cette page concerne la façon dont un programme peut utiliser différentes chaînes pour des langues aussi variées que l'anglais, le chinois, l'allemand, le finnois, l'italien, etc. Fondamentalement, cela fonctionne comme ceci :
4	4
5		-	~~`* ajoutez une ``resourcestring`` pour chaque légende (``caption``) ;`\~~
6		-	~~`* compilez pour obtenir les fichiers ``.rst`` et/ou ``.po`` (l'EDI peut le faire automatiquement) ;`\~~
7		-	~~`* créez un fichier traduit ``.po`` pour chaque langue (il existe des outils visuels libres pour ce faire) ;`\~~
8		-	~~`* utilisez les fonctions de l'unité ``translations`` de la LCL pour charger la bonne version de traduction au lancement du programme.`~~
	5	+	```text
	6	+	* ajoutez une resourcestring pour chaque légende (caption) ;
	7	+	* compilez pour obtenir les fichiers .rst et/ou .po (l'EDI peut le faire automatiquement) ;
	8	+	* créez un fichier traduit .po pour chaque langue (il existe des outils visuels libres pour ce faire) ;
	9	+	* utilisez les fonctions de l'unité translations de la LCL pour charger la bonne version de traduction au lancement du programme.
	10	+	```
9	11
10	12		## Date, heure et format de nombres
11	13
12	14		Sous Linux, BSD et Mac OS X existent différentes valeurs "locales" définissant des éléments comme le format de l'heure et de la date ou le séparateur des milliers. Afin d'initialiser la RTL, vous devez inclure l'unité clocale dans la section uses de votre programme (fichier .lpr).
13	15
14	16		## Les chaînes de ressources
15	17
16	18		Par exemple :
17	19
18	20		``` pascal
19	21		resourcestring
20	22		Caption1 = 'Du texte';
21	23		HelloWorld1 = 'Bonjour, monde';
22	24		```
23	25
24	26		Elles sont comme des constantes de chaîne normales, ce qui veut dire que vous pouvez les assigner à n'importe quelle chaîne. Par exemple :
25	27
26	28		``` pascal
27	29		Label1.Caption := HelloWorld1;
28	30		```
29	31
30	32		Quand FPC les compile, il crée pour chaque unité un fichier unitname.rst contenant les données des chaînes de ressources (nom + contenu).
31	33
32	34		## Les fichiers .po
33	35
34	36		Il existe de nombreux outils visuels libres pour éditer les fichiers .po, qui sont de simples fichiers de texte comme les fichiers .rst, mais avec quelques options supplémentaires, comme un en-tête contenant des champs indiquant le nom de l'auteur, le type d'encodage, la langue et la date. Chaque installation de FPC met à disposition l'outil rstconv (Windows : rstconv.exe). Cet outil peut être utilisé pour convertir un fichier .rst en un fichier .po. L'EDI peut le faire automatiquement. Exemples d'outils libres : kbabel, po-auto-translator, poedit, virtaal.
35	37
36	38		Virtaal a une mémoire de traduction contenant des paires source-cible pour les éléments que vous avez déjà traduits, et une fonction de suggestion de traduction qui montre les termes déjà traduits dans différents paquets de logiciels open source. Cette fonction peut vous permettre d'économiser beaucoup de travail et d'améliorer la cohérence des traductions.
37	39
38	40		Exemple utilisant directement rstconv :
39	41
40		-	~~` rstconv -i unit1.rst -o unit1.po`~~
	42	+	```text
	43	+	rstconv -i unit1.rst -o unit1.po
	44	+	```
41	45
42	46		## La traduction
43	47
44	48		Pour chaque langue, le fichier .po doit être copié et traduit. L'unité translation de la LCL utilise les codes habituels des langues(en=anglais, de=allemand, it=italien, ...) pour ses recherches. Par exemple, la traduction française de unit1.po serait unit1.fr.po. Pour atteindre ce résultat, le fichier unit1.po sera copié en unit1.fr.po, unit1.it.po, et toute autre langue que vous souhaitez supporter. Les traducteurs pourront alors éditer leur fichier .po spécifique.
45	49
46	50		> Note: Pour les Brésiliens/Portugais: L'EDI de Lazarus et la LCL possèdent uniquement les traductions du Portugais Brésilien et ces fichiers ont pour extension 'pt_BR.po' (et non 'pt.po').
47	51
48	52		## Les options de l'EDI pour la mise à jour des fichiers .po
49	53
50	54		- L'unité contenant les ressources de chaînes doit être ajoutée au paquet ou au projet.
51	55		- Vous devez définir un chemin pour les .po, ce qui signifie un dossier qui leur est propre. Par exemple : créez un sous-répertoire language dans le répertoire du paquet/projet. Pour les projets, allez dans Projet \> Options du projet. Pour les paquets, allez dans Options \> Intégration à l'EDI.
52	56
53	57		Quand ces options sont activées, l'EDI génère ou met à jour le fichier .po de base en utilisant les informations contenues dans les fichiers .rst et .lrt (l'outil rstconv n'est alors pas nécessaire). Le processus de mise à jour commence en collectant toutes les entrées existantes trouvées dans le fichier .po de base et dans les fichiers .rst et .lrt pour continuer en appliquant les caractéristiques qu'il trouve ensuite réactualisées dans n'importe quel fichier .xx.po de traduction.
54	58
55	59		### Suppression des entrées obsolètes
56	60
57	61		Les entrées du fichier .po de base qui ne sont pas trouvées dans les fichiers .rst et .lrt sont supprimées. De même, toutes les entrées trouvées dans les fichiers .xx.po non trouvées dans le fichier .po de base sont également enlevées. De cette façon, les fichiers .po ne sont pas encombrés avec des entrées obsolètes et les traducteurs n'ont pas à traduire les entrées qui ne sont pas utilisées.
58	62
59	63		### Entrées en double
60	64
61	65		Les entrées en double apparaissent quand pour quelque raison le même texte est utilisé pour différentes chaînes de ressources. Un exemple au hasard : dans le fichier lazarus/ide/lazarusidestrconst.pas pour la chaîne 'Gutter':
62	66
63	67		``` pascal
64	68		dlfMouseSimpleGutterSect = 'Gutter';
65	69		dlgMouseOptNodeGutter = 'Gutter';
66	70		dlgGutter = 'Gutter';
67	71		dlgAddHiAttrGroupGutter = 'Gutter';
68	72		```
69	73
70	74		Un fichier .rst converti pour ces chaînes de ressources serait similaire à ceci dans un fichier .po:
71	75
72		-	~~`#: lazarusidestrconsts.dlfmousesimpleguttersect`\~~
73		-	~~`msgid "Gutter"`\~~
74		-	~~`msgstr ""`\~~
75		-	~~`#: lazarusidestrconsts.dlgaddhiattrgroupgutter`\~~
76		-	~~`msgid "Gutter"`\~~
77		-	~~`msgstr ""`\~~
78		-	~~`etc.`~~
	76	+	```text
	77	+	#: lazarusidestrconsts.dlfmousesimpleguttersect
	78	+	msgid "Gutter"
	79	+	msgstr ""
	80	+	#: lazarusidestrconsts.dlgaddhiattrgroupgutter
	81	+	msgid "Gutter"
	82	+	msgstr ""
	83	+	etc.
	84	+	```
79	85
80	86		Les lignes commençant avec "#: " sont considérées comme des commentaires et les outils utilisés pour traduire ces entrées voient les lignes répétées msgid "Gutter" comme des entrées dupliquées produisant des erreurs ou des avertissements au chargement ou à la sauvegarde. Les entrées dupliquées sont considérées comme une éventualité normale dans un fichier .po et elles ont besoin d'avoir un certain contexte qui leur est attaché. Le mot clé msgctxt est utilisé pour ajouter un contexte aux entrées dupliquées et l'outil de mise à jour automatique utilise l'ID d'entrée (le texte à côté du préfixe "#: ") comme contexte. Pour l'exemple précédent serait produit quelque chose comme ceci :
81	87
82		-	~~`#: lazarusidestrconsts.dlfmousesimpleguttersect`\~~
83		-	~~`msgctxt "lazarusidestrconsts.dlfmousesimpleguttersect"`\~~
84		-	~~`msgid "Gutter"`\~~
85		-	~~`msgstr ""`\~~
86		-	~~`#: lazarusidestrconsts.dlgaddhiattrgroupgutter`\~~
87		-	~~`msgctxt "lazarusidestrconsts.dlgaddhiattrgroupgutter"`\~~
88		-	~~`msgid "Gutter"`\~~
89		-	~~`msgstr ""`\~~
90		-	~~`etc.`\~~
	88	+	```text
	89	+	#: lazarusidestrconsts.dlfmousesimpleguttersect
	90	+	msgctxt "lazarusidestrconsts.dlfmousesimpleguttersect"
	91	+	msgid "Gutter"
	92	+	msgstr ""
	93	+	#: lazarusidestrconsts.dlgaddhiattrgroupgutter
	94	+	msgctxt "lazarusidestrconsts.dlgaddhiattrgroupgutter"
	95	+	msgid "Gutter"
	96	+	msgstr ""
	97	+	etc.
	98	+	```
91	99
92	100		Pour les fichiers .xx.po traduits, l'outil automatique effectue une vérification supplémentaire : si l'entrée dupliquée était déjà traduite, la nouvelle entrée récupère l'ancienne traduction, apparaissant alors comme traduite automatiquement.
93	101
94	102		Cette détection automatique des doublons n'est pas encore parfaite. La détection des doublons est effectuée quand des éléments sont ajoutés à la liste et il peut arriver que certaines entrées non traduites soient lues d'abord. Aussi se peut-il que plusieurs passes soient nécessaires pour récupérer tous les doublons traduits automatiquement par l'outil.
95	103
96	104		### Entrées à l'origine de confusions possibles
97	105
98	106		Les changements dans les chaînes de ressources affectent les traductions. Par exemple, si une chaîne de ressource a été initialement définie comme ceci :
99	107
100	108		``` pascal
101	109		dlgEdColor = 'Syntax highlight';
102	110		```
103	111
104	112		cela produirait une entrée .po similaire à ceci :
105	113
106		-	~~`#: lazarusidestrconsts.dlgedcolor`\~~
107		-	~~`msgid "Syntax highlight"`\~~
108		-	~~`msgstr ""`~~
	114	+	```text
	115	+	#: lazarusidestrconsts.dlgedcolor
	116	+	msgid "Syntax highlight"
	117	+	msgstr ""
	118	+	```
109	119
110	120		qui, en cas de traduction en espagnol (cet exemple a été tiré de l'historique de Lazarus), peut résulter en :
111	121
112		-	~~`#: lazarusidestrconsts.dlgedcolor`\~~
113		-	~~`msgid "Syntax highlight"`\~~
114		-	~~`msgstr "Color"`~~
	122	+	```text
	123	+	#: lazarusidestrconsts.dlgedcolor
	124	+	msgid "Syntax highlight"
	125	+	msgstr "Color"
	126	+	```
115	127
116	128		Supposons que, plus tard, la chaîne de ressources a été changée en :
117	129
118	130		``` pascal
119	131		dlgEdColor = 'Colors';
120	132		```
121	133
122	134		l'entrée .po résultante pourrait devenir :
123	135
124		-	~~`#: lazarusidestrconsts.dlgedcolor`\~~
125		-	~~`msgid "Colors"`\~~
126		-	~~`msgstr ""`~~
	136	+	```text
	137	+	#: lazarusidestrconsts.dlgedcolor
	138	+	msgid "Colors"
	139	+	msgstr ""
	140	+	```
127	141
128	142		Notez qu'alors que l'ID demeure le même (lazarusidestrconsts.dlgedcolor), la chaîne est passée de 'Syntax highlight' à 'Colors'. Comme la chaîne a déjà été traduite, l'ancienne traduction peut ne pas correspondre au nouveau sens recherché. Pour la nouvelle chaîne, il est probable que 'Colores' serait une meilleure traduction.
129	143
130	144		L'outil de mise à jour automatique remarque cette situation et produit une entrée comme :
131	145
132		-	~~`#: lazarusidestrconsts.dlgedcolor`\~~
133		-	~~`#, fuzzy`\~~
134		-	~~`#\| msgid "Syntax highlight"`\~~
135		-	~~`msgctxt "lazarusidestrconsts.dlgedcolor"`\~~
136		-	~~`msgid "Colors"`\~~
137		-	~~`msgstr "Color"`~~
	146	+	```text
	147	+	#: lazarusidestrconsts.dlgedcolor
	148	+	#, fuzzy
	149	+	#\| msgid "Syntax highlight"
	150	+	msgctxt "lazarusidestrconsts.dlgedcolor"
	151	+	msgid "Colors"
	152	+	msgstr "Color"
	153	+	```
138	154
139	155		En terme de format de fichier .po, le préfixe "#," signifie que l'entrée est marquée avec un drapeau (fuzzy) si bien que les programmes de traduction peuvent présenter à l'utilisateur traducteur une interface visuelle adaptée à cet élément. Dans le cas qui nous intéresse, le drapeau signifierait que la traduction dans son état actuel est douteuse et nécessite d'être révisée plus attentivement par le traducteur. Le préfixe "#\\|" indique ce qu'était la précédente chaîne non traduite de cette entrée et donne une indication au traducteur sur pourquoi cette entrée a été marquée comme source de confusions possibles.
140	156
141	157		## Traduction de fiches, de modules de données et de cadres
142	158
143	159		Quand l'option i18n est activée pour le projet/paquet, l'EDI produit automatiquement des fichiers .lrt pour chaque fiche. Il crée le fichier .lrt à l'enregistrement de l'unité. Par conséquent, si vous activez l'option pour la première fois, vous devez ouvrir chaque fiche une fois, la déplacer un petit peu à l'écran de sorte qu'elle soit modifiée, et l'enregistrer. Par exemple, si vous enregistrez une fiche unit1.pas, l'EDI crée un fichier unit1.lrt. A la compilation, l'EDI rassemble toutes les chaînes de tous les fichiers .lrt files et .rst dans un seul fichier .po (projectname.po ou packagename.po) dans le répertoire i18n.
144	160
145	161		Pour les fiches qui sont à traduire à l'exécution, vous devez affecter un traducteur à LRSTranslator (défini dans LResources) dans la section initialization de l'une de vos unités.
146	162
147	163		``` pascal
148	164		...
149	165		uses
150	166		...
151	167		LResources;
152	168		...
153	169		...
154	170		initialization
155	171		LRSTranslator := TPoTranslator.Create('/path/to/the/po/file');
156	172		```
157	173
158	174		Néanmoins, il n'y a pas de classe TPoTranslator (i.e une classe qui traduit à partir des fichiers .po) disponible dans la LCL. Voici une implémentation possible (partiellement reprise de DefaultTranslator.pas dans la LCL): Le code suivant n'est plus nécessaire si vous utilisez une version 0.9.29 ou ultérieure de Lazarus. Ajoutez simplement l'unité DefaultTranslator dans la clause uses.
159	175
160	176		``` pascal
161	177		unit PoTranslator;
162	178
163	179		{$mode objfpc}{$H+}
164	180
165	181		interface
166	182
167	183		uses
168	184		Classes, SysUtils, LResources, typinfo, Translations;
169	185
170	186		type
171	187
172	188		{ TPoTranslator }
173	189
174	190		TPoTranslator=class(TAbstractTranslator)
175	191		private
176	192		FPOFile:TPOFile;
177	193		public
178	194		constructor Create(POFileName:string);
179	195		destructor Destroy;override;
180	196		procedure TranslateStringProperty(Sender:TObject;
181	197		const Instance: TPersistent; PropInfo: PPropInfo; var Content:string);override;
182	198		end;
183	199
184	200		implementation
185	201
186	202		{ TPoTranslator }
187	203
188	204		constructor TPoTranslator.Create(POFileName: string);
189	205		begin
190	206		inherited Create;
191	207		FPOFile:=TPOFile.Create(POFileName);
192	208		end;
193	209
194	210		destructor TPoTranslator.Destroy;
195	211		begin
196	212		FPOFile.Free;
197	213		inherited Destroy;
198	214		end;
199	215
200	216		procedure TPoTranslator.TranslateStringProperty(Sender: TObject;
201	217		const Instance: TPersistent; PropInfo: PPropInfo; var Content: string);
202	218		var
203	219		s: String;
204	220		begin
205	221		if not Assigned(FPOFile) then exit;
206	222		if not Assigned(PropInfo) then exit;
207	223		{DO we really need this?}
208	224		if Instance is TComponent then
209	225		if csDesigning in (Instance as TComponent).ComponentState then exit;
210	226		{End DO :)}
211	227		if (AnsiUpperCase(PropInfo^.PropType^.Name)<>'TTRANSLATESTRING') then exit;
212	228		s:=FPOFile.Translate(Content, Content);
213	229		if s<>'' then Content:=s;
214	230		end;
215	231
216	232		end.
217	233		```
218	234
219	235		Alternativement, vous pouvez transformer le fichier.po en .mo en utilisant msgfmt (n'est plus nécessaire non plus depuis la version 0.9.29) et utiliser simplement l'unité DefaultTranslator
220	236
221	237		``` pascal
222	238		...
223	239		uses
224	240		...
225	241		DefaultTranslator;
226	242		```
227	243
228	244		qui recherchera automatiquement dans plusieurs emplacements standards un fichier .po (plus haute priorité) ou un fichier .mo (l'inconvénient est que vous devrez garder ensemble les fichiers .mo pour l'unité DefaultTranslator et les fichiers .po pour l'unité TranslateUnitResourceStrings.. Si vous utilisez l'unité DefaultTranslator, elle va essayer de détecter automatiquement la langue à partir de la variable d'environnement LANG (surchargeable en utilisant l'option --lang en ligne de commande), puis regardera dans les emplacements suivants pour la traduction (LANG représente la langue désirée ; l'extension peut être po ou mo) :
229	245
230	246		- \<Répertoire de l'application\>/\<LANG\>/\<Nom de fichier de l'application\>.\<ext\>
231	247		- \<Répertoire de l'application\>/languages/\<LANG\>/\<Nom de fichier de l'application\>.\<ext\>
232	248		- \<Répertoire de l'application\>/locale/\<LANG\>/\<Nom de fichier de l'application\>.\<ext\>
233	249		- \<Répertoire de l'application\>/locale/LC_MESSAGES/\<LANG/\>\<Nom de fichier de l'application\>.\<ext\>
234	250
235	251		Avec les systèmes du genre Unix, l'emplacement peut aussi ressembler à
236	252
237	253		- /usr/share/locale/\<LANG\>/LC_MESSAGES/\<Nom de fichier de l'application\>.\<ext\>
238	254
239	255		L'unité pourra aussi utiliser l'intitulé court de la langue (par exemple, s'il s'agit de "es_ES" ou "es_ES.UTF-8" et que le fichier n'existe pas, elle essayera aussi "es").
240	256
241	257		## Traduction au début du programme
242	258
243	259		Pour chaque fichier .po, vous devez appeler TranslateUnitResourceStrings de l'unité translations de la LCL. Par exemple :
244	260
245	261		``` pascal
246	262		{En premier lieu: ajoutez les unités "gettext" et "translations" à la clause uses}
247	263		procedure TForm1.FormCreate(Sender: TObject);1
248	264		var
249	265		PODirectory, Lang, FallbackLang: String;
250	266		begin
251	267		PODirectory := '/path/to/lazarus/lcl/languages/';
252	268		GetLanguageIDs(Lang, FallbackLang); // dans l'unité gettext
253	269		TranslateUnitResourceStrings('LCLStrConsts', PODirectory + 'lclstrconsts.%s.po', Lang, FallbackLang);
254	270		MessageDlg('Titre', 'Texte', mtInformation, [mbOk, mbCancel, mbYes], 0);
255	271		end;
256	272		```
257	273
258	274		## Compilation des fichiers po dans l'exécutable
259	275
260	276		Si vous ne voulez pas installer les fichiers .po, mais placer tous les fichiers dans l'exécutable, utilisez ce qui suit :
261	277
262	278		- Créez une nouvelle unité (pas une fiche !).
263	279		- Convertissez le(s) fichier(s) .po en fichiers .lrs en utilisant le programme tools/lazres:
264	280
265	281		./lazres unit1.lrs unit1.de.po
266	282
267	283		Ceci va créer un fichier d'inclusion unit1.lrs commençant par
268	284
269	285		``` pascal
270	286		LazarusResources.Add('unit1.de','PO',[
271	287		...
272	288		```
273	289
274	290		- Ajoutez le code :
275	291
276	292		``` pascal
277	293		uses LResources, Translations;
278	294
279	295		resourcestring
280	296		MyCaption = 'Caption';
281	297
282	298		function TranslateUnitResourceStrings: boolean;
283	299		var
284	300		r: TLResource;
285	301		POFile: TPOFile;
286	302		begin
287	303		r:=LazarusResources.Find('unit1.de','PO');
288	304		POFile:=TPOFile.Create(False); //Si Full=True vous pouvez craindre un crash (problème #0026021)
289	305		try
290	306		POFile.ReadPOText(r.Value);
291	307		Result:=Translations.TranslateUnitResourceStrings('unit1',POFile);
292	308		finally
293	309		POFile.Free;
294	310		end;
295	311		end;
296	312
297	313		initialization
298	314		{$I unit1.lrs}
299	315		```
300	316
301	317		- Appelez TranslateUnitResourceStrings au début du programme. Vous pouvez aussi choisir de le faire dans la section initialization.
302	318
303	319		Malheureusement, ce code ne compilera pas avec Lazarus 1.2.2 et antérieurs.
304	320
305	321		Pour ces versions anciennes, vous pouvez utiliser quelque chose comme cela :
306	322
307	323		``` pascal
308	324		type
309	325		TTranslateFromResourceResult = (trSuccess, trResourceNotFound, trTranslationError);
310	326
311	327		function TranslateFromResource(AResourceName, ALanguage : String): TTranslateFromResourceResult;
312	328		var
313	329		LRes : TLResource;
314	330		POFile : TPOFile = nil;
315	331		SStream : TStringStream = nil;
316	332		begin
317	333		Result := trResourceNotFound;
318	334		LRes := LazarusResources.Find(AResourceName + '.' + ALanguage, 'PO');
319	335		if LRes <> nil then
320	336		try
321	337		SStream := TStringStream.Create(LRes.Value);
322	338		POFile := TPoFile.Create(SStream, False);
323	339		try
324	340		if TranslateUnitResourceStrings(AResourceName, POFile) then Result := trSuccess
325	341		else Result := trTranslationError;
326	342		except
327	343		Result := trTranslationError;
328	344		end;
329	345		finally
330	346		if Assigned(SStream) then SStream.Free;
331	347		if Assigned(POFile) then POFile.Free;
332	348		end;
333	349		end;
334	350		```
335	351
336	352		Exemple d'utilisation :
337	353
338	354		``` pascal
339	355		initialization
340	356		{$I lclstrconsts.de.lrs}
341	357		TranslateFromResource('lclstrconsts', 'de');
342	358		end.
343	359		```
344	360
345	361		## Méthode indépendante de la plate-forme pour déterminer la langue système
346	362
347	363		La fonction ci-dessous retourne une chaîne qui représente la langue de l'interface utilisateur. Elle tourne sous Linux, Mac OS X et Windows.
348	364
349	365		``` pascal
350	366		uses
351	367		Classes, SysUtils {ajoute dessunités supplémentaires nécessaires au code qui suit}
352	368		{$IFDEF win32}
353	369		, Windows
354	370		{$ELSE}
355	371		, Unix
356	372		{$IFDEF LCLCarbon}
357	373		, MacOSAll
358	374		{$ENDIF}
359	375		{$ENDIF}
360	376		;
361	377		```
362	378
363	379		``` pascal
364	380		function GetOSLanguage: string;
365	381		{méthode indépendante de la plate-forme pour lire la langue de l'interface utilisateur}
366	382		var
367	383		l, fbl: string;
368	384		{$IFDEF LCLCarbon}
369	385		theLocaleRef: CFLocaleRef;
370	386		locale: CFStringRef;
371	387		buffer: StringPtr;
372	388		bufferSize: CFIndex;
373	389		encoding: CFStringEncoding;
374	390		success: boolean;
375	391		{$ENDIF}
376	392		begin
377	393		{$IFDEF LCLCarbon}
378	394		theLocaleRef := CFLocaleCopyCurrent;
379	395		locale := CFLocaleGetIdentifier(theLocaleRef);
380	396		encoding := 0;
381	397		bufferSize := 256;
382	398		buffer := new(StringPtr);
383	399		success := CFStringGetPascalString(locale, buffer, bufferSize, encoding);
384	400		if success then
385	401		l := string(buffer^)
386	402		else
387	403		l := '';
388	404		fbl := Copy(l, 1, 2);
389	405		dispose(buffer);
390	406		{$ELSE}
391	407		{$IFDEF LINUX}
392	408		fbl := Copy(GetEnvironmentVariable('LC_CTYPE'), 1, 2);
393	409		{$ELSE}
394	410		GetLanguageIDs(l, fbl);
395	411		{$ENDIF}
396	412		{$ENDIF}
397	413		Result := fbl;
398	414		end;
399	415		```
400	416
401	417		## Traduction de l'EDI
402	418
403	419		### Fichiers
404	420
405	421		Les fichiers .po sont dans le répertoire source de Lazarus :
406	422
407	423		- lazarus/languages =\> chaînes pour l'EDI
408	424		- lazarus/lcl/languages/ =\> chaînes pour la LCL
409	425		- lazarus/components/ideintf/languages/ =\> chaînes pour l'interface de l'EDI
410	426
411	427		### Traducteurs
412	428
413	429		- la traduction en allemand est maintenue par Joerg Braun.
414	430		- la traduction en finnois est maintenue par Seppo Suurtarla.
415	431		- la traduction en russe est maintenue par Maxim Ganetsky.
416	432		- la traduction en français est maintenue par Gilles Vasseur.
417	433
418	434		Si vous voulez commencer une nouvelle traduction, demandez via le mailing si quelqu'un travaille déjà dessus.
419	435
420	436		Veuillez lire attentivement :[[Lazarus Documentation/fr\|Traduction/Internationalisation/Localisation]]
421	437
422	438		## Voir aussi
423	439
424	440		- [[IDE Development\|IDE Development: Translations, i18n, lrt, po files]]
425	441		- [[Getting translation strings right/fr\|Obtenir de bonnes traductions des chaînes]]
426	442		- [[Lazarus Documentation/fr\|Traduction/Internationalisation/Localisation]]
427	443
428	444		---
429	445		From the Free Pascal wiki, page "Translations / i18n / localizations for programs/fr", as it stood on 2020-03-01 after a change by Trev, out of the wiki's dump of 2024-05-26. Copyright stays with the author who wrote it, according to the old wiki's [[Licensing]] page. If you have concerns about this material, [message the admin](/wiki-contact).

Back to history