/*Prog*/ Delphi-Neftalí /*finProg*/

Ya he hablado anteriormente de varios sistemas y paquetes de  componentes para internacionalizar aplicaciones en el blog. Por ejemplo, aquí y aquí. A raiz de un comentario de otro usuario, esta vez, por necesidad en este proyecto (IBCC) he decidido probar los componentes DKLang.

A primera vista me han sorprendido,  pues cuenta con versión para XE5 incluyendo aplicaciones móviles (Android/iPhone) así como para VCL y FMX. Más adelante hablaré de la versión para XE5 (versión 5), aunque en esta entrada y para este proyecto he usado la versión 3, que es la que soporta Delphi 6. 

Para la compilación del componente, al menos en esta versión (Delphi 6), hacen falta los componentes TNT para unicode. Gratuítos y con código fuente que podéis bajar desde esta misma web o desde internet sin problemas.

La compilación e instalación de los packages se hace sin problemas. Basta con añadir un par de directorios al path para que encuentre los ficheros necesarios. Una vez instalado el package de diseño, ya me aparece el componente DKLanguageController en la pestaña de System.

He echado en falta algún manual sencillo para poder seguir a la hora de empezar con un proyecto nuevo. En la web y en la ayuda no hay nada que de una guía rápida de funcionamiento. Aun así, no lleva más de 10 minutos ver cómo se maneja el componente.

Todos los ejemplos que se incluyen están realizados utilizando los componentes TNT, aunque es fácil sustituirlos en el DFM por componentes estándar y el funcionamiento es correcto.

CREANDO EL PROYECTO

Para comenzar he creado un proyecto sencillo, con un TLabel, un TButton y un TGroupBox para poder seleccionar el idioma. en mi caso entre 3 disponibles. Español, Inglés y catalán (el primero como predeterminado de la aplicación).

Una vez realizado esto, he “soltado” en el formulario un componente de traducción y he grabado en proyecto.

Utilizando una opción del menú desplegable que aparece al pulsar click derecho sobre el componente o desde el menú de Project del IDE, puedo generar el “project language source”, que viene a ser el fichero con las constantes a traducir.

Si hago lo mismo desde un segundo formulario, veremos que se van añadiendo al fichero de proyecto las constantes de todos ellos. En mi caso, con 2 formularios, se ha generado un fichero similar a este (project1.dklang):

[Form1]
Caption=00000001,Form1
Label1.Caption=00000002,Hola a todos!
Button1.Caption=00000003,&Cerrar
RadioGroup1.Caption=00000004,Idiomas
RadioGroup1.Items=00000005,Español\nInglés\nCatalán\n
Button2.Caption=00000006,Abrir form2

[$CONSTANTS]

[Form2]
Caption=00000001,Form2
Label1.Caption=00000002,Segundo formulario
Button1.Caption=00000003,&Cerrar

Según la web y la documentación, soltando el componente en el formulario se deberían generar los ficheros de traducción y añadirse líneas al proyecto. Imagino que debe ser en la versiones más recientes (ya lo veremos más adelante), pero por ahora en esta (3.0), hay que hacerlo manualmente.

GENERANDO TRADUCCIONES

Llegados a este punto, necesitamos generar los ficheros de traducción, a partir del fichero anterior. Podemos hacerlo manualmente, pues son ficheros de texto y la estructura es bastante sencilla de entender (como veremos luego una vez generado el resultado), pero es más sencillo hacerlo utilizando la herramienta “DKLang Translation Editor” que podemos descargar gratuitamente desde la web del autor, y que además nos servirá para distribuir, si otras personas deben generar traducciones (de forma sencilla), sin tener acceso al programa.

Con esta herramienta y el fichero “project1.dklang” debemos poder generar los ficheros de idioma sin problemas.

Seleccionamos el fichero a traducir y nos aparecerá una pantalla donde rellenar algunas opciones. La más importante es el Idioma de la traducción a realizar, aunque podemos completar también el autor, la aplicación y rellenar de forma libre otros datos.

Una vez completada esta pantalla, entramos en el Translation Editor.
Es un programa sencillo y completo para realizar de forma sencilla las traducciones. Posee un repositorio al que podemos ir añadiendo las cadenas traducidas, para posteriormente recuperarlas de él, sin necesidad de volver a realizar la traducción. Por defecto el repositorio se encuentra en el directorio del programa (fichero DKTranEd.dat).

TRATAR LAS CONSTANTES

Antes de continuar y ver el resultado de las traducciones, nos queda ver cómo tratar las constantes con este componente. En otros paquetes de traducción, se almacenan como resourcestrings, o simplemente se guardan como constantes y a la hora de añadirlas al código utilizamos una función en la llamada para traducirlas.

En esta caso las constantes se almacenan directamente en el fichero de traducción utilizando un asistente (DLLang Constant Editor) a la que se accede desde el menú de project (Edit project constants). Así que aquí deberemos ir añadiendo las diferentes constantes que utilizamos en nuestro proyecto.

Para hacer referencia a ellas en el código hay que llamarlas utilizando la función DKLangConstW.

DKLangConstW('MSG_SALIR')

Una vez que se compila el proyecto, se genera un fichero .RES que hay que añadir al fichero del proyecto.

{$R *.dkl_const.res}

Cuando ya hemos traducido desde el Translation Editor, incluyendo las constantes, el fichero de idioma resultante es similar a este:

TargetApplication=Test DKLang
Author=Neftalí –Germán Estévez-
SourceLANGID=1033
LANGID=2057
Generator=DKLang Translation Editor v3.0
LastModified=2014-01-10 13:40:33

[Form1]
00000002=Hello World!
00000003=&Close
00000004=Languages
00000006=Open form2

[Form2]
00000002=Second form
00000003=&Close

[$CONSTANTS]
MSG_SALIR=Do you really want to close?

Lo guardaremos en disco con la referencia al idioma y la extensión .lng (English.lng).

Este fichero se puede modificar también con cualquier editor de texto.

UTILIZAR IDIOMAS DESDE EL PROYECTO

Para utilizar los idiomas dentro de nuestro proyecto, debemos primero añadirlos como “disponibles” a la estructura LangManager. Para ello podemos hacerlo directamente buscando los ficheros que hay en el directorio con la extensión lng. El código siguiente se coloca en el OnCreate del formulario principal.

El código que hay en los ejemplos es el siguiente:

var
  i: Integer;
begin
  // Buscar los ficheros en el directorio de la aplicación y “registrarlos”
  LangManager.ScanForLangFiles(ExtractFileDir(ParamStr(0)), '*.lng', False);
  // Rellena un combobox (en este caso) con los nombres
  for i := 0 to LangManager.LanguageCount-1 do begin
    cbLanguage.Items.Add(LangManager.LanguageNames[i]);
  end;
  // Index=0   =>  Por defecto usamos el 0
  cbLanguage.ItemIndex := 0;

Lo siguiente que necesitamos es saber lo que hay que hacer para cambiar de idioma en la aplicación. Para el ejemplo, utilizamos el mismo TCombobox que hemos rellenado en el OnCreate, de forma que al cambiar (OnChange) modificaremos el idioma de la aplicación.

var
  iIndex: Integer;
begin
  // Idioma seleccionado en el combobox
  iIndex := cbLanguage.ItemIndex;
  // Si no hay ninguno, nos quedamos con el “por defecto”
  if iIndex<0 then iIndex := 0;
  // Activamos ese idioma en el LanguageManager
  LangManager.LanguageID := LangManager.LanguageIDs[iIndex];

FICHEROS  .LNG COMO RECURSOS

Una opción alternativa, si no queremos tener que distribuir con la aplicación ficheros “extra” (*.lan) es añadirlos como recursos dentro del ejecutable, como hacemos con otros elementos.

Para ello debemos crear un archivo RC similar al siguiente (LangFiles.rc):

LNG_CATALA    RCDATA Catala.lng
LNG_ENGLISH  RCDATA English.lng

Para compilarlo, podemos utilizar desde la línea de comandos lo siguiente:

> brcc32 LangFiles.rc

Eso nos dará como resultado un fichero LangFiles.res, que ya podremos añadir a la aplicación como recurso.

Falta modificar una cosa más. A la hora de inicializar los idiomas en el OnCreate, en lugar de añadirlos desde los ficheros LNG, hay que decirle al LangManager que los cargue desde los recursos. Para ello modificamos la línea anterior del OnCreate por las que muestro a continuación:

// Buscar los ficheros en el directorio de la aplicación y “registrarlos”
//– LangManager.ScanForLangFiles(ExtractFileDir(ParamStr(0)), ‘*.lng’, False);

// Añadir los idiomas desde los recursos
LangManager.RegisterLangResource(HInstance, ‘LNG_CATALA’, 1027);
LangManager.RegisterLangResource(HInstance, ‘LNG_ENGLISH’,  2057);

Con esto ya podemos distribuir el EXE de nuestra aplicación sin ningún otro fichero.

CONCLUSIÓN

El sistema en que trabaja me parece bien en general. Positivo el hecho de poder añadir de forma fácil los idiomas, tanto como ficheros individuales, como también dentro del ejecutable.

Falta algo de información al inicio para empezar, pero una vez que se conoce el sistema de trabajo es bastante sencillo.

La aplicación de traducción externa funciona muy bien y es ágil de usar, cosa que facilita mucho el trabajo (también pensando el traductores “externos”).

Tal vez la mayor “pega” la he encontrado en la forma de trabajar con las constantes. El “editor de constantes” es un poco pobre y no resulta “natural” la forma de trabajar con él. Tal vez hubiera sido más lógico poder añadir las constantes al código (o a un fichero independiente PAS –es lo que suelo hacer yo normalmente-) y que luego se pudieran “importar” al fichero de traducción (tsiLang lo hace de esta forma).

No es tampoco algo insalvable, ya que el editor permite guardarlas en un fichero externo y se pueden editar desde cualquier editor que permita UNICODE, ya que se guardan en este formato. Eso hace que no se pueda hacer desde el IDE de Delphi 6, aunque sí desde los más nuevos (que ya lo soportan).

Hasta aquí la revisión de este paquete de traducción.
Os adjunto el proyecto de ejemplo para descargarlo.

<DESCARGAR CÓDIGO FUENTE>

Como siempre cualquier comentario, anotación, sugerencia o crítica será bienvenida.

Hasta la próxima.

Germán Estévez

Embarcadero MVP.
Analista y Programador de Sistemas Informáticos.
Estudios de Informática (Ingeniería Técnica Superior) en la UPC (Universidad Politécnica de Barcelona).
Llevo utilizando Delphi desde su versión 3. Especialista en diseño de componentes, Bases de Datos, Frameworks de Persistencia, Integración Continua, Desarrollo móvil,…