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

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

Old	New		Line
1	1		## Descripción general sobre internacionalización (i18n)
2	2
3	3		¿Cómo hacer que los programas utilicen diferentes cadenas para diversos idiomas cómo inglés, chino, alemán, castellano, etc.?
4	4
5	5		Básicamente funciona de la siguiente forma: Añade un recurso de cadena (resourcestring) para cada literal, compila para obtener los archivos .rst y/o .po (el IDE lo hace automáticamente), crea un archivo .po para cada idioma (existen herramientas gráficas para ello) y utiliza las funciones de la unidad translations de la LCL para cargar el archivo adecuado al iniciar el programa.
6	6
7	7		## Formatos de fechas, horas y números
8	8
9	9		En Linux, BSD, Mac OS X hay diversas definiciones regionales/locales para definir el formato de la hora y de la fecha o del separador decimal. Para inicializar la RTL necesitas icluir la unidad clocale en la sección use de tu programa (archivo lpr).
10	10
11	11		## Recursos de Cadena (Resourcestrings)
12	12
13	13		Por ejemplo
14	14
15	15		``` pascal
16	16		resourcestring
17	17		Etiqueta1 = 'Algo de texto';
18	18		HolaMundo1 = 'Hola Mundo';
19	19		```
20	20
21	21		Son como constantes de cadena normales, lo que significa que se pueden asignar a cualquier cadena. Por ejemplo
22	22
23	23		``` pascal
24	24		Label1.Caption := HolaMundo1;
25	25		```
26	26
27	27		Al compilar se creará un archivo .rst por cada unidad, con el mismo nombre que esta, conteniendo los resursos de cadena (nombre y contenido)
28	28
29	29		## Archivos .po
30	30
31	31		Hay muchas herramientas gráficas libres (kbabel y poedit, por ejemplo) para editar archivos .po, que son texto simple al igual que los archivos .rst, pero con algunas opciones más, como una cabecera que proporciona los campos autor, la codificación, el idioma y fecha. Toda instalación de fpc proporciona la herramienta rstconv (windows: rstconv.exe). Esta herramienta se utiliza para convertir archivos .rst en archivos .po. El IDE realizar esta operación automáticamente.
32	32
33	33		Ejemplo de uso de rstconv:
34	34
35		-	~~` rstconv -i unidad1.rst -o unidad1.po`~~
	35	+	```text
	36	+	rstconv -i unidad1.rst -o unidad1.po
	37	+	```
36	38
37	39		## Traduciendo
38	40
39	41		Por cada idioma el archivo .po debe ser copiado y traducido. La unidad translation utiliza los códigos de idiomas habituales (en=inglés, de=alemán, es=español, it=italiano, ...) para buscarlos. Por ejemplo la traducción al alemán de unidad1.po se llamará unidad1.de.po. Por tanto hay que copiar el archivo unidad1.po en un archivo de nombre unidad1.it.po y así para todos los idiomas que queramos soportar y los traductores editaran el archivo .po específico de cada idioma.
40	42
41	43		Nota para brasileños y portugueses: El IDE y la LCL de Lazarus únicamente tienen traducciones de portugués de Brasil y estos archivos se denominan con la extensión 'pb.po' y no 'pt.po'.
42	44
43	45		## Opciones del IDE para la actualización automática de archivos .po
44	46
45	47		- La unidad que contiene los recursos de cadena debe añadirse al paquete o proyecto.
46	48		- Hay que proporcionar la ruta a .po si los archivos están en un directorio separado. Por ejemplo crear un directorio idiomas en el paquete/proyecto. Para proyectos ir a Proyecto \> Opciones de proyecto, pestaña *i18n*. Para paquetes ir a Opciones \> Integración en IDE.
47	49
48	50		Cuando esta opción está activada, el IDE genera o actualiza el archivo .po base con la información contenida en los archivos .rst y .lrt (en cuyo caso la herramienta rstconv no será necesaria). El proceso de actualización se inicia mediante la recopilación de todas las entradas existentes en el .po base y en los archivos .rst y .lrt y luego aplica las siguientes características que encuentra y pone al día todo archivo .xx.po traducido.
49	51
50	52		### Eliminación de entradas obsoletas
51	53
52	54		Las entradas en el archivo .po base no se encontradas en el archivo en los archivos .rst y .lrt se eliminan, posteriormente, todas las entradas que se encuentran en archivos .xx.po traducidos que no se encuentran en el archivo .po base también se quitan. De esta manera los archivos .po se limpian de las entradas obsoletas y los traductores no tienen que traducir las entradas que no se utilizan.
53	55
54	56		### Entradas duplicadas
55	57
56	58		Las entradas duplicadas se producen cuando por alguna razón se utiliza el mismo texto para cadenas de recursos diferentes, un ejemplo, de esto es el archivo de Lazarus/ide/lazarusidestrconst.pas para la cadena 'Gutter';
57	59
58	60		``` pascal
59	61		dlfMouseSimpleGutterSect = 'Gutter';
60	62		dlgMouseOptNodeGutter = 'Gutter';
61	63		dlgGutter = 'Gutter';
62	64		dlgAddHiAttrGroupGutter = 'Gutter';
63	65		```
64	66
65	67		El archivo .rst de recursos para estas cadenas A converted .rst file for this resource strings tendría un aspecto similar a este en un archivo .po:
66	68
67		-	~~` #: lazarusidestrconsts.dlfmousesimpleguttersect`\~~
68		-	~~` msgid "Gutter"`\~~
69		-	~~` msgstr ""`\~~
70		-	~~` #: lazarusidestrconsts.dlgaddhiattrgroupgutter`\~~
71		-	~~` msgid "Gutter"`\~~
72		-	~~` msgstr ""`\~~
73		-	~~` etc.`~~
	69	+	```text
	70	+	#: lazarusidestrconsts.dlfmousesimpleguttersect
	71	+	msgid "Gutter"
	72	+	msgstr ""
	73	+	#: lazarusidestrconsts.dlgaddhiattrgroupgutter
	74	+	msgid "Gutter"
	75	+	msgstr ""
	76	+	etc.
	77	+	```
74	78
75	79		Donde las líneas que comienzan con "#:" se consideran como los comentarios y las herramientas empleadas para traducir estas entradas verán las repetidas líneas msgstr "Gutter" como entradas duplicadas y provocarán errores o advertencias al cargar o guardar. Las entradas duplicadas se consideran eventualmente normales en archivos .po y necesitan tener algo de contexto asociado. La palabra clave msgctxt se utiliza para agregar contexto a las entradas duplicadas y la herramienta de actualización automática de utiliza la entrada ID (el texto que sigue a "#:" ) como el contexto, para el ejemplo anterior se produciría algo así como esto:
76	80
77		-	~~` #: lazarusidestrconsts.dlfmousesimpleguttersect`\~~
78		-	~~` msgctxt "lazarusidestrconsts.dlfmousesimpleguttersect"`\~~
79		-	~~` msgid "Gutter"`\~~
80		-	~~` msgstr ""`\~~
81		-	~~` #: lazarusidestrconsts.dlgaddhiattrgroupgutter`\~~
82		-	~~` msgctxt "lazarusidestrconsts.dlgaddhiattrgroupgutter"`\~~
83		-	~~` msgid "Gutter"`\~~
84		-	~~` msgstr ""`\~~
85		-	~~` etc.`~~
	81	+	```text
	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.
	91	+	```
86	92
87	93		En los archivos traducidos .xx.po la herramienta automática hace una comprobación adicional: si la entrada duplicada fue traducida ya, la nueva entrada toma la traducción previa, por lo que aparece como traducida automáticamente.
88	94
89	95		La detección automática de duplicados aún no es perfecta, la detección se realiza cuando se agregan elementos a la lista y puede suceder que algunas entradas sin traducir se lean primero. Por lo tanto, puede llevar varias pasadas obtener todos los duplicados traducidos automáticamente por la herramienta.
90	96
91	97		### Entradas confusas
92	98
93	99		Los cambios en las cadenas de recursos afectan a las traducciones, por ejemplo cuando en un principio una cadena de recursos se define así:
94	100
95	101		``` pascal
96	102		dlgEdColor = 'Syntax highlight';
97	103		```
98	104
99	105		esto produce una entrada en .po similar a esta
100	106
101		-	~~` #: lazarusidestrconsts.dlgedcolor`\~~
102		-	~~` msgid "Syntax higlight"`\~~
103		-	~~` msgstr ""`~~
	107	+	```text
	108	+	#: lazarusidestrconsts.dlgedcolor
	109	+	msgid "Syntax higlight"
	110	+	msgstr ""
	111	+	```
104	112
105	113		que si se han traducido al idioma castellano (este ejemplo está tomado de la historia de lazarus), puede resultar en
106	114
107		-	~~` #: lazarusidestrconsts.dlgedcolor`\~~
108		-	~~` msgid "Syntax higlight"`\~~
109		-	~~` msgstr "Color"`~~
	115	+	```text
	116	+	#: lazarusidestrconsts.dlgedcolor
	117	+	msgid "Syntax higlight"
	118	+	msgstr "Color"
	119	+	```
110	120
111	121		Supongamos ahora que, en un momento posterior, la cadena de recursos se ha cambiado a
112	122
113	123		``` pascal
114	124		dlgEdColor = 'Colors';
115	125		```
116	126
117	127		la entrada en .po puede ser
118	128
119		-	~~` #: lazarusidestrconsts.dlgedcolor`\~~
120		-	~~` msgid "Colors"`\~~
121		-	~~` msgstr ""`~~
	129	+	```text
	130	+	#: lazarusidestrconsts.dlgedcolor
	131	+	msgid "Colors"
	132	+	msgstr ""
	133	+	```
122	134
123	135		Tenga en cuenta que, si bien el ID sigue siendo igualmente lazarusidestrconsts.dlgedcolor la cadena ha cambiado de "Syntax highlight' a 'Colors', dado que la cadena se tradujo ya la traducción previa no puede coincidir con el nuevo significado. De hecho, para la nueva cadena probablemente 'Colores' puede ser una traducción mejor. La herramienta de actualización automática avisa de esta situación y produce una entrada como esta:
124	136
125		-	~~` #: lazarusidestrconsts.dlgedcolor`\~~
126		-	~~` #, fuzzy`\~~
127		-	~~` #\| msgid "Syntax highlight"`\~~
128		-	~~` msgctxt "lazarusidestrconsts.dlgedcolor"`\~~
129		-	~~` msgid "Colors"`\~~
130		-	~~` msgstr "Color"`~~
	137	+	```text
	138	+	#: lazarusidestrconsts.dlgedcolor
	139	+	#, fuzzy
	140	+	#\| msgid "Syntax highlight"
	141	+	msgctxt "lazarusidestrconsts.dlgedcolor"
	142	+	msgid "Colors"
	143	+	msgstr "Color"
	144	+	```
131	145
132	146		En los términos del formato de los archivos .po, el prefijo "#," significa que la entrada tiene una marca (confusa) y los programas traductores puede presentar al usuario un igu especial para este elemento, en este caso la marca significa que la traducción en su estado actual es dudosa y hay que revisarla con más cuidado por el traductor. El prefijo "#\\|" indica cuál fue la cadena anterior no traducida de esta entrada y le da al traductor una idea del porqué la entrada estaba marcada como confusa.
133	147
134	148		## Traduciendo Formularios, Módulos de Datos y Marcos
135	149
136	150		Cuando la opción i18n está activada para el proyecto/paquete el IDE crea automáticamente un archivo .lrt para cada formulario, cada vez que se guarda la unidad. Por tanto cuándo se habilita la opción por primera vez hay que abrir, modificar y guardar los formularios. Por ejemplo, si guardas un formulario unidad1 .pas el IDE crea el archivo unidad1.lrt. Y al compilar el IDE reúne todas las cadenas de todos los archivos .lrt y .rst en un único archivo .po, con el nombre del proyecto o del paquete, en el directorio i18n.
137	151
138	152		Para los formularios que se traducen en tiempo de ejecución, hay que asignar un valor que apunte al achivo de traducción a LRSTranslator (definido en LResources) en la sección de inicio de una de las unidades del proyecto.
139	153
140	154		``` pascal
141	155		...
142	156		uses
143	157		...
144	158		LResources;
145	159		...
146	160		...
147	161		initialization
148	162		LRSTranslator:=TPoTranslator.Create('/ruta/al/archivo/po');
149	163		```
150	164
151	165		La clase que traduce utilizando archivos .po, TPoTranslator, no está disponible en la LCL. Esta es una posible implementación (tomada en parte de DefaultTranslator.pas de la LCL) El código siguiente ya no se necesita si utilizas Lazarus 0.9.29. Sólo tienes que incluir DefaultTranslator en la cláusula uses:
152	166
153	167		``` pascal
154	168		unit PoTranslator;
155	169
156	170		{$mode objfpc}{$H+}
157	171
158	172		interface
159	173
160	174		uses
161	175		Classes, SysUtils, LResources, typinfo, Translations;
162	176
163	177		type
164	178
165	179		{ TPoTranslator }
166	180
167	181		TPoTranslator=class(TAbstractTranslator)
168	182		private
169	183		FPOFile:TPOFile;
170	184		public
171	185		constructor Create(POFileName:string);
172	186		destructor Destroy;override;
173	187		procedure TranslateStringProperty(Sender:TObject;
174	188		const Instance: TPersistent; PropInfo: PPropInfo; var Content:string);override;
175	189		end;
176	190
177	191		implementation
178	192
179	193		{ TPoTranslator }
180	194
181	195		constructor TPoTranslator.Create(POFileName: string);
182	196		begin
183	197		inherited Create;
184	198		FPOFile:=TPOFile.Create(POFileName);
185	199		end;
186	200
187	201		destructor TPoTranslator.Destroy;
188	202		begin
189	203		FPOFile.Free;
190	204		inherited Destroy;
191	205		end;
192	206
193	207		procedure TPoTranslator.TranslateStringProperty(Sender: TObject;
194	208		const Instance: TPersistent; PropInfo: PPropInfo; var Content: string);
195	209		var
196	210		s: String;
197	211		begin
198	212		if not Assigned(FPOFile) then exit;
199	213		if not Assigned(PropInfo) then exit;
200	214		{DO we really need this?}
201	215		if Instance is TComponent then
202	216		if csDesigning in (Instance as TComponent).ComponentState then exit;
203	217		{End DO :)}
204	218		if (AnsiUpperCase(PropInfo^.PropType^.Name)<>'TTRANSLATESTRING') then exit;
205	219		s:=FPOFile.Translate(Content, Content);
206	220		if s<>'' then Content:=s;
207	221		end;
208	222
209	223		end.
210	224		```
211	225
212	226		Alternativamente se puede transformar el archivo .po en una .mo, utilizando msgfmt, y utilizar la unidad DefaultTranslator.
213	227
214	228		``` pascal
215	229		...
216	230		uses
217	231		...
218	232		DefaultTranslator;
219	233		```
220	234
221	235		con ello se buscará automáticamente en varios lugares preestablecidos un archivo .po (primero) o un archivo .mo; la desventaja es que hay que mantener ambos, los archivos .mo para la unidad DefaultTranslator y los archivos .po para TranslateUnitResourceStrings.
222	236
223	237		Si utilizamos DefaultTranslator, se intentará detectar automáticamente la lengua basandose en la variable de entorno LANG (modificable utilizando la opción --lang de la línea de órdenes), buscando entonces en esos lugares la traducción (LANG representa la lengua deseada):
224	238
225	239		- \<Application Directory\>/LANG/\<Application Filename\>.po (o .mo)
226	240		- \<Application Directory\>/languages/LANG/\<Application Filename\>.po (o .mo)
227	241		- \<Application Directory\>/locale/LANG/\<Application Filename\>.po (o .mo)
228	242		- \<Application Directory\>/locale/LC_MESSAGES/LANG/\<Application Filename\>.po (o .mo)
229	243
230	244		en sistemas *NIX esto se verá así
231	245
232		-	~~`* /usr/share/locale/LANG/LC_MESSAGES/<Application Filename>.po (o .mo)`~~
	246	+	```text
	247	+	* /usr/share/locale/LANG/LC_MESSAGES/<Application Filename>.po (o .mo)
	248	+	```
233	249
234	250		también usará la parte corta del idioma (e.g. si es " es_ES" o " es_ES.UTF-8" y este no existe también probará con "es")
235	251
236	252		## Seleccionando el idioma en el arranque el programa
237	253
238	254		Para cada fichero .po hay que hacer una llamada a la función TranslateUnitResourceStrings de la unidad de translations de la LCL. Por ejemplo:
239	255
240	256		``` pascal
241	257		{lo pimero: añadir las unidades "gettext" y "translations" en la cláusula uses}
242	258		procedure TForm1.FormCreate(Sender: TObject);
243	259		var
244	260		PODirectorio, Idioma, IdiomaDevuelto: String;
245	261		begin
246	262		PODirectorio := '/ruta/a/lazarus/lcl/languages/';
247	263		GetLanguageIDs(Idioma, IdiomaDevuelto); // en la unidad "gettext"
248	264		TranslateUnitResourceStrings('LCLStrConsts', PODirectorio + 'lclstrconsts.%s.po', Idioma, IdiomaDevuelto);
249	265		MessageDlg('Título', 'Texto', mtInformation, [mbOk, mbCancel, mbYes], 0);
250	266		end;
251	267		```
252	268
253	269		## Compilando los archivos .po dentro del ejecutable
254	270
255	271		Si no deseas instalar los archivos .po, sino poner todos los archivos de la aplicación en el ejecutable, utiliza lo siguiente:
256	272
257	273		- Crea una nueva unidad (¡no un formulario!).
258	274		- Convierte los archivos .po en .lrs utilizando la utilidad lazres del directorio tools:
259	275
260	276		./lazres unidad1.lrs unidad1.es.po
261	277
262	278		Esto creará un archivo de inclusión unit1.lrs que empieza así
263	279
264	280		``` pascal
265	281		LazarusResources.Add('unidad1.es','PO',[...
266	282		```
267	283
268	284		- Añade este código:
269	285
270	286		``` pascal
271	287		uses LResources, Translations;
272	288
273	289		resourcestring
274	290		MyCaption = 'Caption';
275	291
276	292		function TranslateUnitResourceStrings: boolean;
277	293		var
278	294		r: TLResource;
279	295		POFile: TPOFile;
280	296		begin
281	297		r:=LazarusResources.Find('unidad1.es','PO');
282	298		POFile:=TPOFile.Create;
283	299		try
284	300		POFile.ReadPOText(r.Value);
285	301		Result:=Translations.TranslateUnitResourceStrings('unidad1',POFile);
286	302		finally
287	303		POFile.Free;
288	304		end;
289	305		end;
290	306
291	307		initialization
292	308		{$I unidad1.lrs}
293	309		```
294	310
295	311		- Llama a TranslateUnitResourceStrings al comienzo del programa. Puedes hacerlo en la sección de inicialización si quieres.
296	312
297	313		## Método multiplataforma para determinar el idioma del sistema
298	314
299	315		Esta función suministra una cadena que representa el idioma de sistema de usuario. Funciona en Linux, Mac OS X y Windows.
300	316
301	317		``` pascal
302	318		uses
303	319		Classes, SysUtils {añade aquí las unidades adionales que necesite tu código}
304	320		{$IFDEF win32}
305	321		, Windows
306	322		{$ELSE}
307	323		, Unix
308	324		{$IFDEF LCLCarbon}
309	325		, MacOSAll
310	326		{$ENDIF}
311	327		{$ENDIF}
312	328		;
313	329		```
314	330
315	331		``` pascal
316	332		function GetOSLanguage: string;
317	333		{Método multiplataforma para determinar el idioma del sistema}
318	334		var
319	335		l, fbl: string;
320	336		{$IFDEF LCLCarbon}
321	337		theLocaleRef: CFLocaleRef;
322	338		locale: CFStringRef;
323	339		buffer: StringPtr;
324	340		bufferSize: CFIndex;
325	341		encoding: CFStringEncoding;
326	342		success: boolean;
327	343		{$ENDIF}
328	344		begin
329	345		{$IFDEF LCLCarbon}
330	346		theLocaleRef := CFLocaleCopyCurrent;
331	347		locale := CFLocaleGetIdentifier(theLocaleRef);
332	348		encoding := 0;
333	349		bufferSize := 256;
334	350		buffer := new(StringPtr);
335	351		success := CFStringGetPascalString(locale, buffer, bufferSize, encoding);
336	352		if success then
337	353		l := string(buffer^)
338	354		else
339	355		l := '';
340	356		fbl := Copy(l, 1, 2);
341	357		dispose(buffer);
342	358		{$ELSE}
343	359		{$IFDEF LINUX}
344	360		fbl := Copy(GetEnvironmentVariable('LC_CTYPE'), 1, 2);
345	361		{$ELSE}
346	362		GetLanguageIDs(l, fbl);
347	363		{$ENDIF}
348	364		{$ENDIF}
349	365		Result := fbl;
350	366		end;
351	367		```
352	368
353	369		## Traducciendo el IDE
354	370
355	371		### Archivos
356	372
357	373		Los archivos .po del IDE están en el directorio de fuentes de Lazarus:
358	374
359	375		- lazarus/languages cadenas para el IDE
360	376		- lcl/languages/ cadenas para la LCL
361	377		- ideintf/languages/ cadenas para el interfaz del IDE
362	378
363	379		### Traductoress
364	380
365	381		- La traducción al alemán está a cargo de Joerg Braun.
366	382		- La traducción al finés está a cargo de Seppo Suurtarla
367	383		- La traducción al ruso está a cargo de Maxim Ganetsky
368	384
369	385		Si deseas iniciar una nueva traducción, pregunta en el correo si alguien ya está trabajando en ello.
370	386
371	387		Por favor, lee atentamente: [[Lazarus Documentation\|Traducciones]]
372	388
373	389		## Ver también
374	390
375	391		[[IDE Development\|IDE Development: Translations, i18n, lrt, po files]]
376	392
377	393		[[Getting translation strings right]]
378	394
379	395		[[Lazarus Documentation\|Translations]]
380	396
381	397		---
382	398		From the Free Pascal wiki, page "Translations / i18n / localizations for programs/es", 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).
383	399		Category: Castellano
384	400		Category: Español

Back to history