Everything else about translations: what changed

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

Old	New		Line
1	1		### Introduction
2	2
3	3		Note: This stuff was before in [[Translations / i18n / localizations for programs]]. If you think that something is really important move that stuff back. Please read both articles carefully in order to avoid duplicate stuff.
4	4
5	5		### .po Files
6	6
7	7		There are many free graphical tools to edit .po files, which are simple text like the .rst files, but with some more options, like a header providing fields for author, encoding, language and date. Every FPC installation provides the tool rstconv (windows: rstconv.exe). This tool can be used to convert a .rst file into a .po file. The IDE can do this automatically. Some free tools: kbabel, po-auto-translator, poedit, virtaal.
8	8
9	9		Virtaal has a translation memory containing source-target language pairs for items that you already translated once, and a translation suggestion function that shows already translated terms in various open source software packages. These function may save you a lot of work and improve consistency.
10	10
11	11		Example of using rstconv directly:
12	12
13	13		`rstconv -i unit1.rst -o unit1.po`
14	14
15	15		### Translating
16	16
17	17		For every language the .po file must be copied and translated. The LCL translation unit uses the common language codes (en=english, de=german, it=italian, ...) to search. For example the German translation of unit1.po would be unit1.de.po. To achieve this, copy the unit1.po file to unit1.de.po, unit1.it.po, and whatever language you want to support and then the translators can edit their specific .po file.
18	18
19	19		> Note: For Brazilians/Portuguese: Lazarus IDE and LCL only have a Brazilian Portuguese translation and these files have 'pt_BR.po' extensions
20	20
21	21		### IDE options for automatic updates of .po files
22	22
23	23		- The unit containing the resource strings must be added to the package or project.
24	24		- You must provide a .po path, this means a separate directory. For example: create a sub directory language in the package / project directory. For projects go to the Project \> Project Options. For packages go to Options \> IDE integration.
25	25
26	26		When this options are enabled, the IDE generates or updates the base .po file using the information contained in .rst and .lrt files (rstconv tool is then not necesary). The update process begins by collecting all existing entries found in base .po file and in .rst and .lrt files and then applying the following features it finds and brings up to date any translated .xx.po file.
27	27
28	28		#### Removal of Obsolete entries
29	29
30	30		Entries in the base .po file that are not found in .rst and .lrt files are removed. Subsequently, all entries found in translated .xx.po files not found in the base .po file are also removed. This way, .po files are not cluttered with obsolete entries and translators don't have to translate entries that are not used.
31	31
32	32		#### Duplicate entries
33	33
34	34		Duplicate entries occur when for some reason the same text is used for different resource strings, a random example of this is the file lazarus/ide/lazarusidestrconst.pas for the 'Gutter' string:
35	35
36	36		``` pascal
37	37		dlfMouseSimpleGutterSect = 'Gutter';
38	38		dlgMouseOptNodeGutter = 'Gutter';
39	39		dlgGutter = 'Gutter';
40	40		dlgAddHiAttrGroupGutter = 'Gutter';
41	41		```
42	42
43	43		A converted .rst file for this resource strings would look similar to this in a .po file:
44	44
45	45		`#: lazarusidestrconsts.dlfmousesimpleguttersect`\
46	46		`msgid "Gutter"`\
47	47		`msgstr ""`\
48	48		`#: lazarusidestrconsts.dlgaddhiattrgroupgutter`\
49	49		`msgid "Gutter"`\
50	50		`msgstr ""`\
51	51		`etc.`\
52	52
53	53		Where the lines starting with "#: " are considered comments and the tools used to translate this entries see the repeated msgid "Gutter" lines like duplicated entries and produce errors or warnings on loading or saving. Duplicate entries are considered a normal eventuality on .po files and they need to have some context attached to them. The msgctxt keyword is used to add context to duplicated entries and the automatic update tool use the entry ID (the text next to "#: " prefix) as the context, for the previous example it would produce something like this:
54	54
55	55		`#: lazarusidestrconsts.dlfmousesimpleguttersect`\
56	56		`msgctxt "lazarusidestrconsts.dlfmousesimpleguttersect"`\
57	57		`msgid "Gutter"`\
58	58		`msgstr ""`\
59	59		`#: lazarusidestrconsts.dlgaddhiattrgroupgutter`\
60	60		`msgctxt "lazarusidestrconsts.dlgaddhiattrgroupgutter"`\
61	61		`msgid "Gutter"`\
62	62		`msgstr ""`\
63	63		`etc.`\
64	64
65	65		On translated .xx.po files the automatic tool does one additional check: if the duplicated entry was already translated, the new entry gets the old translation, so it appears like being translated automatically.
66	66
67	67		The automatic detection of duplicates is not yet perfect, duplicate detection is made as items are added to the list and it may happen that some untranslated entries are read first. So it may take several passes to get all duplicates automatically translated by the tool.
68	68
69	69		#### Fuzzy entries
70	70
71	71		Changes in resource strings affect translations, for example if initially a resource string was defined like:
72	72
73	73		``` pascal
74	74		dlgEdColor = 'Syntax highlight';
75	75		```
76	76
77	77		this would produce a .po entry similar to this
78	78
79	79		`#: lazarusidestrconsts.dlgedcolor`\
80	80		`msgid "Syntax highlight"`\
81	81		`msgstr ""`
82	82
83	83		which if translated to Spanish (this sample was taken from lazarus history), may result in
84	84
85	85		`#: lazarusidestrconsts.dlgedcolor`\
86	86		`msgid "Syntax highlight"`\
87	87		`msgstr "Color"`
88	88
89	89		Suppose then that at a later time, the resource string has been changed to
90	90
91	91		``` pascal
92	92		dlgEdColor = 'Colors';
93	93		```
94	94
95	95		the resulting .po entry may become
96	96
97	97		`#: lazarusidestrconsts.dlgedcolor`\
98	98		`msgid "Colors"`\
99	99		`msgstr ""`
100	100
101	101		Note that while the ID remained the same lazarusidestrconsts.dlgedcolor the string has changed from 'Syntax highlight' to 'Colors'. As the string was already translated the old translation may not match the new meaning. Indeed, for the new string probably 'Colores' may be a better translation. The automatic update tool notices this situation and produces an entry like this:
102	102
103	103		`#: lazarusidestrconsts.dlgedcolor`\
104	104		`#, fuzzy`\
105	105		`#\| msgid "Syntax highlight"`\
106	106		`msgctxt "lazarusidestrconsts.dlgedcolor"`\
107	107		`msgid "Colors"`\
108	108		`msgstr "Color"`
109	109
110	110		In terms of .po file format, the "#," prefix means the entry has a flag (fuzzy) and translator programs may present a special GUI to the translator user for this item. In this case, the flag would mean that the translation in its current state is doubtful and needs to be reviewed more carefully by translator. The "#\\|" prefix indicates what was the previous untranslated string of this entry and gives the translator a hint why the entry was marked as fuzzy.
111	111
112	112		### Translating Forms, Datamodules and Frames
113	113
114	114		When the i18n option is enabled for the project / package then the IDE automatically creates .lrt files for every form. It creates the .lrt file on saving a unit. So, if you enable the option for the first time, you must open every form once, move it a little bit, so that it is modified, and save the form. For example if you save a form unit1.pas the IDE creates a unit1.lrt. And on compile the IDE gathers all strings of all .lrt files and all .rst file into a single .po file (projectname.po or packagename.po) in the i18n directory.
115	115
116	116		For the forms to be actually translated at runtime, you have to assign a translator to LRSTranslator (defined in LResources) in the initialization section to one of your units
117	117
118	118		``` pascal
119	119		...
120	120		uses
121	121		...
122	122		LResources;
123	123		...
124	124		...
125	125		initialization
126	126		LRSTranslator := TPoTranslator.Create('/path/to/the/po/file');
127	127		```
128	128
129		-	<s>However there's no TPoTranslator class (i.e a class that translates using .po files) available in the LCL. This is a possible implementation (partly lifted from DefaultTranslator.pas in the LCL):</s> The following code isn't needed anymore if you use recent Lazarus 0.9.29 snapshots. Simply include DefaultTranslator in Uses clause.
	129	+	However there's no TPoTranslator class (i.e a class that translates using .po files) available in the LCL. This is a possible implementation (partly lifted from DefaultTranslator.pas in the LCL): The following code isn't needed anymore if you use recent Lazarus 0.9.29 snapshots. Simply include DefaultTranslator in Uses clause.
130	130
131	131		``` pascal
132	132		unit PoTranslator;
133	133
134	134		{$mode objfpc}{$H+}
135	135
136	136		interface
137	137
138	138		uses
139	139		Classes, SysUtils, LResources, typinfo, Translations;
140	140
141	141		type
142	142
143	143		{ TPoTranslator }
144	144
145	145		TPoTranslator=class(TAbstractTranslator)
146	146		private
147	147		FPOFile:TPOFile;
148	148		public
149	149		constructor Create(POFileName:string);
150	150		destructor Destroy;override;
151	151		procedure TranslateStringProperty(Sender:TObject;
152	152		const Instance: TPersistent; PropInfo: PPropInfo; var Content:string);override;
153	153		end;
154	154
155	155		implementation
156	156
157	157		{ TPoTranslator }
158	158
159	159		constructor TPoTranslator.Create(POFileName: string);
160	160		begin
161	161		inherited Create;
162	162		FPOFile:=TPOFile.Create(POFileName);
163	163		end;
164	164
165	165		destructor TPoTranslator.Destroy;
166	166		begin
167	167		FPOFile.Free;
168	168		inherited Destroy;
169	169		end;
170	170
171	171		procedure TPoTranslator.TranslateStringProperty(Sender: TObject;
172	172		const Instance: TPersistent; PropInfo: PPropInfo; var Content: string);
173	173		var
174	174		s: String;
175	175		begin
176	176		if not Assigned(FPOFile) then exit;
177	177		if not Assigned(PropInfo) then exit;
178	178		{DO we really need this?}
179	179		if Instance is TComponent then
180	180		if csDesigning in (Instance as TComponent).ComponentState then exit;
181	181		{End DO :)}
182	182		if (AnsiUpperCase(PropInfo^.PropType^.Name)<>'TTRANSLATESTRING') then exit;
183	183		s:=FPOFile.Translate(Content, Content);
184	184		if s<>'' then Content:=s;
185	185		end;
186	186
187	187		end.
188	188		```
189	189
190	190		Alternatively you can transform the .po file into .mo using msgfmt (isn't needed anymore if you use recent 0.9.29 snapshot) and simply use the DefaultTranslator unit
191	191
192	192		``` pascal
193	193		...
194	194		uses
195	195		...
196	196		DefaultTranslator;
197	197		```
198	198
199		-	which will automatically look in several standard places for a .po file (higher precedence) or .mo file <s>(the disadvantage is that you'll have to keep around both the .mo files for the DefaultTranslator unit and the .po files for TranslateUnitResourceStrings)</s>. If you use DefaultTranslator, it will try to automatically detect the language based on the LANG environment variable (overridable using the --lang command line switch), then look in these places for the translation (LANG stands for the desired language, ext can be either po or mo):
	199	+	which will automatically look in several standard places for a .po file (higher precedence) or .mo file (the disadvantage is that you'll have to keep around both the .mo files for the DefaultTranslator unit and the .po files for TranslateUnitResourceStrings). If you use DefaultTranslator, it will try to automatically detect the language based on the LANG environment variable (overridable using the --lang command line switch), then look in these places for the translation (LANG stands for the desired language, ext can be either po or mo):
200	200
201	201		- \<Application Directory\>/\<LANG\>/\<Application Filename\>.\<ext\>
202	202		- \<Application Directory\>/languages/\<LANG\>/\<Application Filename\>.\<ext\>
203	203		- \<Application Directory\>/locale/\<LANG\>/\<Application Filename\>.\<ext\>
204	204		- \<Application Directory\>/locale/LC_MESSAGES/\<LANG/\>\<Application Filename\>.\<ext\>
205	205
206	206		under unix-like systems it will also look in
207	207
208	208		- /usr/share/locale/\<LANG\>/LC_MESSAGES/\<Application Filename\>.\<ext\>
209	209
210	210		as well as using the short part of the language (e.g. if it is "es_ES" or "es_ES.UTF-8" and it doesn't exist it will also try "es")
211	211
212	212		### Translating at start of program
213	213
214	214		For every .po file, you must call TranslateUnitResourceStrings. The LCL po file is lclstrconsts. For example you do this in FormCreate of your MainForm:
215	215
216	216		``` pascal
217	217		uses
218	218		..., gettext, translations;
219	219
220	220		procedure TForm1.FormCreate(Sender: TObject);
221	221		var
222	222		PODirectory, Lang, FallbackLang: String;
223	223		begin
224	224		PODirectory := '/path/to/lazarus/lcl/languages/';
225	225		GetLanguageIDs(Lang, FallbackLang);
226	226		Translations.TranslateUnitResourceStrings('LCLStrConsts', PODirectory + 'lclstrconsts.%s.po', Lang, FallbackLang);
227	227
228	228		// the following dialog now shows translated buttons:
229	229		MessageDlg('Title', 'Text', mtInformation, [mbOk, mbCancel, mbYes], 0);
230	230		end;
231	231		```
232	232
233	233		### Compiling po files into the executable
234	234
235	235		If you don't want to install the .po files, but put all files of the application into the executable, use one the following methods.
236	236
237	237		#### FPC Resources (Recommended)
238	238
239	239		Normal resources are now recommended for current FPC (including all recent Lazarus versions) [[Lazarus Resources]]
240	240
241	241		- Add the resources (.po files) to executable with the Lazarus IDE (Project Options \> Resources) as RCDATA.
242	242
243	243		``` pascal
244	244		uses
245	245		Classes, Translation, LCLType,
246	246
247	247		function Translate(const Language: string): boolean;
248	248		var
249	249		Res: TResourceStream;
250	250		PoStringStream: TStringStream;
251	251		PoFile: TPOFile;
252	252		begin
253	253		Res := TResourceStream.Create(HInstance, 'project1.' + Language, RT_RCDATA);
254	254		PoStringStream := TStringStream.Create('');
255	255		Res.SaveToStream(PoStringStream);
256	256		Res.Free;
257	257
258	258		PoFile := TPOFile.Create(False);
259	259		PoFile.ReadPOText(PoStringStream.DataString);
260	260		PoStringStream.Free;
261	261
262	262		Result := TranslateResourceStrings(PoFile);
263	263		PoFile.Free;
264	264		end;
265	265		```
266	266
267	267		#### Lazarus Resources
268	268
269	269		- Create a new unit (not a form!).
270	270		- Convert the .po file(s) to .lrs using tools/lazres:
271	271
272	272		``` bash
273	273		./lazres unit1.lrs unit1.de.po
274	274		```
275	275
276	276		This will create an include file unit1.lrs beginning with
277	277
278	278		``` pascal
279	279		LazarusResources.Add('unit1.de','PO',[
280	280		...
281	281		```
282	282
283	283		- Add the code:
284	284
285	285		``` pascal
286	286		uses LResources, Translations;
287	287
288	288		resourcestring
289	289		MyCaption = 'Caption';
290	290
291	291		function TranslateUnitResourceStrings: boolean;
292	292		var
293	293		r: TLResource;
294	294		POFile: TPOFile;
295	295		begin
296	296		r:=LazarusResources.Find('unit1.de','PO');
297	297		POFile:=TPOFile.Create(False); //if Full=True then you can get a crash (Issue #0026021)
298	298		try
299	299		POFile.ReadPOText(r.Value);
300	300		Result:=Translations.TranslateUnitResourceStrings('unit1',POFile);
301	301		finally
302	302		POFile.Free;
303	303		end;
304	304		end;
305	305
306	306		initialization
307	307		{$I unit1.lrs}
308	308		```
309	309
310	310		- Call TranslateUnitResourceStrings at the beginning of the program. You can do that in the initialization section if you like.
311	311
312	312		Unfortunately this code will not compile with Lazarus 1.2.2 and earlier.
313	313
314	314		For these Lazarus versions you can use something like this:
315	315
316	316		``` pascal
317	317		type
318	318		TTranslateFromResourceResult = (trSuccess, trResourceNotFound, trTranslationError);
319	319
320	320		function TranslateFromResource(AResourceName, ALanguage : String): TTranslateFromResourceResult;
321	321		var
322	322		LRes : TLResource;
323	323		POFile : TPOFile = nil;
324	324		SStream : TStringStream = nil;
325	325		begin
326	326		Result := trResourceNotFound;
327	327		LRes := LazarusResources.Find(AResourceName + '.' + ALanguage, 'PO');
328	328		if LRes <> nil then
329	329		try
330	330		SStream := TStringStream.Create(LRes.Value);
331	331		POFile := TPoFile.Create(SStream, False); // WARNING: This example relies on the bug in TStringStream.Create(...) that the
332	332		// position in the stream is incorrectly set to 0, even though the stream
333	333		// is initialized with LRes.Value i.e. assumed to be ready for appending!!!
334	334		try
335	335		if TranslateUnitResourceStrings(AResourceName, POFile) then Result := trSuccess
336	336		else Result := trTranslationError;
337	337		except
338	338		Result := trTranslationError;
339	339		end;
340	340		finally
341	341		if Assigned(SStream) then SStream.Free;
342	342		if Assigned(POFile) then POFile.Free;
343	343		end;
344	344		end;
345	345		```
346	346
347	347		Usage example:
348	348
349	349		``` pascal
350	350		initialization
351	351		{$I lclstrconsts.de.lrs}
352	352		TranslateFromResource('lclstrconsts', 'de');
353	353		end.
354	354		```
355	355
356	356		### Where a Lazarus App looks for Language Files
357	357
358	358		As a multi-language Lazarus app starts, it looks for a nominated language file in a number of places and looks for a number of different file names. The following Lists are for Linux, I believe pretty much the same for Windows but no '/usr/local' of course. The order is important, it stops looking as soon as it finds a suitable candidate. In all cases, the \$LA refers to the language code, es, fr etc. The \$APP is the application's name.
359	359
360	360		.po files - these contain raw, editable text and are probably what arrives on your desk from your translators. Looked for first, perhaps as an aid to development ?
361	361
362	362		``` bash
363	363		./$LA/$APP.po
364	364		./languages/$LA/$APP.po
365	365		./locale/$LA/$APP.po
366	366		./locale/$LA/LC_MESSAGES/$APP.po
367	367		/usr/share/locale/$LA/LC_MESSAGES/$APP.po
368	368		./$APP.$LA.po
369	369		./locale/$APP.$LA.po
370	370		./languages/$APP.$LA.po
371	371		/usr/share/locale/$LA/LC_MESSAGES/$APP.po
372	372		```
373	373
374	374		.pot files - these are template files. Note that they don't identify their language, I wonder why they are even looked for ?
375	375
376	376		``` bash
377	377		./$APP.pot
378	378		./locale/$APP.pot
379	379		./languages/$APP.pot
380	380		```
381	381
382	382		.mo files - these are the machine readable ones, faster and smaller than text, these are the only files you should ship with a finished product.
383	383
384	384		``` bash
385	385		./$LA/$APP.mo
386	386		./languages/$LA/$APP.mo
387	387		./locale/$LA/$APP.mo
388	388		./locale/$LA/LC_MESSAGES/$APP.mo
389	389		/usr/share/locale/$LA/LC_MESSAGES/$APP.mo
390	390		./$APP.$LA.mo
391	391		./locale/$APP.$LA.mo
392	392		./languages/$APP.$LA.mo
393	393		/usr/share/locale/$LA/LC_MESSAGES/$APP.mo
394	394		./$APP.mo
395	395		./locale/$APP.mo
396	396		./languages/$APP.mo
397	397		```
398	398
399	399		Note 1 : Firstly, note that Lazarus looks first for .po and then .pot files. So, be very careful about leaving such files lying around in the 'wrong' place. If your app finds an old .po file of the right language, perhaps left there while doing some test, it won't look further for the lovely new .mo file you just made.
400	400
401	401		Notes 2 : A linux system should always put its language files in /usr/local/somewhere. And really, you should only let your end users get a .mo file, even your beta testers.
402	402
403	403		Note 3 : Above, where we say ./ we mean the directory where the binary is, not the current working directory.
404	404
405	405		### Compiling po files into the executable and change language while running
406	406
407	407		(State: Lazarus 1.6; last tested with Lazarus 2.0.10)
408	408
409	409		With this method a standalone program is possible which can change language without restarting the program. Captions of LCL-components are translated and updated automatically, ressourcestrings change their contents according to the chosen language and can be used to reassign strings manually.
410	410
411	411		Convert the .po file(s) to .lrs using tools/lazres:
412	412
413	413		``` bash
414	414		./lazres language.lrs testprog1.de.po testprog1.en.po
415	415		```
416	416
417	417		Create a new unit (not a form) and insert the below function:
418	418
419	419		``` pascal
420	420		uses
421	421		Forms, LResources, LCLTranslator, Translations;
422	422
423	423		function TranslateTo(POFileName: string): boolean;
424	424		var
425	425		res: TLResource;
426	426		ii: Integer;
427	427		POFile: TPOFile;
428	428		LocalTranslator: TUpdateTranslator;
429	429		begin
430	430		Result:= false;
431	431		res:=LazarusResources.Find(POFileName,'PO');
432	432		if res = nil then EXIT;
433	433		POFile:=TPOFile.Create(False); //if Full=True then you can get a crash (Issue #0026021)
434	434		try
435	435		POFile.ReadPOText(res.Value);
436	436		Result:= Translations.TranslateResourceStrings(POFile);
437	437		if not Result then EXIT;
438	438
439	439		LocalTranslator := TPOTranslator.Create(POFile);
440	440
441	441		LRSTranslator := LocalTranslator;
442	442		for ii := 0 to Screen.CustomFormCount-1
443	443		do LocalTranslator.UpdateTranslation(Screen.CustomForms[ii]);
444	444		for ii := 0 to Screen.DataModuleCount-1
445	445		do LocalTranslator.UpdateTranslation(Screen.DataModules[ii]);
446	446		LRSTranslator:= nil;
447	447		LocalTranslator.Destroy;
448	448		//POFile.Destroy; //DONT! Already done in LocalTranslator.Destroy
449	449		finally end;
450	450		end;
451	451		```
452	452
453	453		Also insert the include statement (here the above mentioned lrs-file is in subfolder "locale"):
454	454
455	455		``` pascal
456	456		initialization
457	457		{$I locale/language.lrs}
458	458		```
459	459
460	460		Then the language can be changed (examples German and English) while runtime with
461	461
462	462		``` pascal
463	463		TranslateTo('testprog1.de');
464	464		```
465	465
466	466		and
467	467
468	468		``` pascal
469	469		TranslateTo('testprog1.en');
470	470		```
471	471
472	472		### Cross-platform method to determine system language
473	473
474	474		The following function delivers a string that represents the language of the user interface. It supports Linux, Mac OS X and Windows.
475	475
476	476		``` pascal
477	477		uses
478	478		Classes, SysUtils {add additional units that may be needed by your code here}
479	479		{$IFDEF win32}
480	480		, Windows
481	481		{$ELSE}
482	482		, Unix
483	483		{$IFDEF LCLCarbon}
484	484		, MacOSAll
485	485		{$ENDIF}
486	486		{$ENDIF}
487	487		;
488	488		```
489	489
490	490		``` pascal
491	491		function GetOSLanguage: string;
492	492		{platform-independent method to read the language of the user interface}
493	493		var
494	494		l, fbl: string;
495	495		{$IFDEF LCLCarbon}
496	496		theLocaleRef: CFLocaleRef;
497	497		locale: CFStringRef;
498	498		buffer: StringPtr;
499	499		bufferSize: CFIndex;
500	500		encoding: CFStringEncoding;
501	501		success: boolean;
502	502		{$ENDIF}
503	503		begin
504	504		{$IFDEF LCLCarbon}
505	505		theLocaleRef := CFLocaleCopyCurrent;
506	506		locale := CFLocaleGetIdentifier(theLocaleRef);
507	507		encoding := 0;
508	508		bufferSize := 256;
509	509		buffer := new(StringPtr);
510	510		success := CFStringGetPascalString(locale, buffer, bufferSize, encoding);
511	511		if success then
512	512		l := string(buffer^)
513	513		else
514	514		l := '';
515	515		fbl := Copy(l, 1, 2);
516	516		dispose(buffer);
517	517		{$ELSE}
518	518		{$IFDEF LINUX}
519	519		fbl := Copy(GetEnvironmentVariable('LC_CTYPE'), 1, 2);
520	520		{$ELSE}
521	521		GetLanguageIDs(l, fbl);
522	522		{$ENDIF}
523	523		{$ENDIF}
524	524		Result := fbl;
525	525		end;
526	526		```
527	527
528	528		### Translating the IDE
529	529
530	530		#### Files
531	531
532	532		The .po files of the IDE are in the lazarus source directory:
533	533
534	534		- lazarus/languages strings for the IDE
535	535		- lazarus/lcl/languages/ strings for the LCL
536	536		- lazarus/components/ideintf/languages/ strings for the IDE interface
537	537
538	538		#### Translators
539	539
540	540		- The German translation is maintained by Swen Heinig.
541	541		- The Finnish translation is maintained by Seppo Suurtarla
542	542		- The Russian translation is maintained by Maxim Ganetsky
543	543		- The French translation is maintained by Gilles Vasseur
544	544
545	545		When you want to start a new translation, ask on the mailing if someone is already working on that.
546	546
547	547		Please read carefully: [[Lazarus Documentation\|Translating/Internationalization/Localization]]
548	548
549	549		### Control design with internationalization capability
550	550
551	551		Controls can easily be designed with i18n-support, e.g. a button with translatable caption. Therefore the control should be packed in a package and the published property of the regarding string has to be of type TTranslateString. After the package is installed in Lazarus, the control has the same translate capabilities as the known LCL controls.
552	552
553	553		``` pascal
554	554		uses LCLType;
555	555
556	556		type TFancyButton = class(TCustomControl)
557	557		...
558	558		protected
559	559		fButtonCaption: TTranslateString;
560	560		procedure SetButtonCaption(ACaption: TTranslateString);
561	561		published
562	562		property Caption : TTranslateString read fButtonCaption write SetButtonCaption
563	563		```
564	564
565	565		### See also
566	566
567	567		[[Lazarus Documentation\|Translating/Internationalization/Localization]] [[Translations / i18n / localizations for programs]]
568	568
569	569		---
570	570		From the Free Pascal wiki, page "Everything else about translations", as it stood on 2021-04-14 after a change by Kupferstecher, 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).
571	571		Category: Localization
572	572		Category: Tutorials

Back to history