Una de las situaciones más comunes y más difícil de traducir ocurre cuando tenemos un mensaje compuesto de varios strings.  Tomemos como ejemplo un programa que toma el nombre de un vehículo y un color y los combina para formar un nuevo string.

   1: for (int i = 0; i < ARRAYSIZE(vehicles); i++)

   2: {

   3:     for (int j = 0; j < ARRAYSIZE(colors); j++)

   4:     {

   5:         size_t newStringLength = wcslen(vehicles[i]) + wcslen(colors[j]) + 2;

   6:         LPWSTR coloredVehicle = new WCHAR[newStringLength];

   7:         wcsncpy_s(coloredVehicle, newStringLength, colors[j], _TRUNCATE);

   8:         wcsncat_s(coloredVehicle, newStringLength, L" ", _TRUNCATE);

   9:         wcsncat_s(coloredVehicle, newStringLength, vehicles[i], _TRUNCATE);

  10:  

  11:         printf("%S\n", coloredVehicle);

  12:  

  13:         delete[] coloredVehicle;

  14:     }

  15: }

Asumiendo que los arreglos de colores y vehículos contienen los nombres en inglés obtenemos como resultado los strings “red car”, “green car”, “blue car”, “red boat”, “green boat”, etc.

Supongamos que nuestro plan incluía traducir estos strings y que fácilmente podemos sustituirlos por el equivalente en español.  Corremos el programa y obtenemos lo siguiente: “rojo automóvil”, “verde automóvil”, “azul automóvil”, “rojo barco”, “verde barco”,etc.

Viendo esto podríamos pensar que estamos en una situación donde es necesario modificar el código y ejecutar instrucciones distintas dependiendo del idioma.  En realidad, hay una solución más sencilla, que consiste en utilizar un tercer string para indicar como se combinan los dos anteriores.  La función que nos permite hacer esto es FormatMessage (o alguna de sus variantes utilizadas por las clases de Strings).

   1: for (int i = 0; i < ARRAYSIZE(vehicles); i++)

   2: {

   3:     for (int j = 0; j < ARRAYSIZE(colors); j++)

   4:     {

   5:         size_t newStringLength = wcslen(vehicles[i]) + wcslen(colors[j]) + 2;

   6:         LPWSTR coloredVehicle = new WCHAR[newStringLength];

   7:         DWORD_PTR args[2];

   8:         args[0] = (DWORD_PTR)colors[j];

   9:         args[1] = (DWORD_PTR)vehicles[i];

  10:         ::FormatMessage(

  11:             FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ARGUMENT_ARRAY,

  12:             coloredVehicleFormat,

  13:             0 /* ignored */,

  14:             0 /* ignored */,

  15:             coloredVehicle,

  16:             newStringLength,

  17:             (va_list*)args);

  18:  

  19:         printf("%S\n", coloredVehicle);

  20:  

  21:         delete[] coloredVehicle;

  22:     }

  23: }

En este caso “coloredVehicleFormat” también debe ser un string obtenido de los recursos del ejecutable.  En inglés le damos el valor de “%1!s! %2!s!” y en español “%2!s! %1!s!” con lo que obtenemos los resultados esperados.  Y de nuevo es posible compartir el mismo código para ambos idiomas.

Esto aún no es una solución general, pero es lo suficientemente buena para la mayoría de los casos.  Un claro ejemplo de que esto no es suficiente es agregando “motocicleta” o “patines” a la lista de vehículos.  ¿Qué pasa ahora con la concordancia?

Analicemos primero el escenario en qué aparece este defecto.  El componente en cuestión sólo está soportado en los idiomas más populares (el código requiere conocimiento del idioma), si un usuario intenta lanzar este componente en un idioma no soportado recibe un mensafe de alerta indicando el error:

Este mensaje se genera utilizando la función MessageBox.

   1: ::MessageBox(NULL, message, caption, MB_OK);

(Asumiendo que message y caption se obtuvieron de los recursos localizables)

Esto funciona bien para casi todos los idiomas, pero qué sucede en idiomas que se escriben de derecha a izquierda como hebreo y árabe.  En el caso de cuadros de diálogo cuando se traducen estos recursos se activan los bits correctos, pero la función MessageBox sólo recibe texto, así que es necesario indicarle que estamos en un idioma de derecha a izquierda mediante las banderas MB_RIGHT (alinear texto a la derecha) y MB_RTLREADING (desplegar los controles alineados a la derecha).  Utilizando estas banderas el cuadro de diálogo se despliega así:

Antes de utilizar estas banderas, tenemos que determinar si nuestra aplicación se está utilizando en un idioma de derecha izquierda.  En este caso específico es fácil, ya que la aplicación tiene una ventana principal que tiene el estilo extendido WS_EX_LAYOUTRTL.

El siguiente código crea el mensaje de alerta con los parámetros correctos.

   1: UINT mirroredFlag(0);

   2: LONG style = ::GetWindowLong(hwndMain, GWL_EXSTYLE);

   3: if ((style & WS_EX_LAYOUTRTL) != 0)

   4: {

   5:     mirroredFlag = MB_RTLREADING | MB_RIGHT;

   6: }

   7: MessageBox(hwndMain, message, caption, MB_OK | mirroredFlag);

No siempre es necesario realizar todos estos pasos (en una aplicación para uso interno en general no hay que considerar detalles de localización), pero si estamos escribiendo software para un mercado global, estas sutilezas son el pan de todos los días.

P.S. – Mi primera corrección de este defecto sólo cambiaba los controles del cuadro de diálogo, pero no alineaba el texto correctamente.  Un recordatorio de que es necesario leer la documentación a fondo antes de hacer correcciones “sencillas”.

Este ejemplo es continuación de la segunda parte, así que agregamos un nuevo archivo al directorio de nuestra aplicación.  Antes de compilar estos archivos es necesario comprobar que la siguiente estructura de directorios exista:

• out
• out\en-us
• out\es-es

Empezaremos por crear nuestro archivo de recursos en español (resource.es-es.rc):

   1: #include "winnt.h"

   2: #include "resource.h"

   3:  

   4: LANGUAGE LANG_SPANISH, SUBLANG_SPANISH_MODERN

   5:  

   6: STRINGTABLE

   7: BEGIN

   8:     IDS_TITULO "Hola mundo!"

   9:     IDS_MENSAJE "Programa de ejemplo"

  10: END

Este archivo es simplemente una traducción de la versión en inglés.  De hecho se utiliza el mismo archivo “resource.h” para definir los identificadores de recurso y asegurarse de que coincidan con los valores esperados en el código.  Es muy importante indicar que el lenguaje y sub-lenguaje sea español y no inglés como en el original.

Los pasos para compilar este archivo en un dll de "sólo recursos" son muy sencillos:

rc -fo out\resource.es-es.res -fm out\resource.es-es.loc.res -q resource.rcconfig resource.es-es.rc
link /dll /noentry /out:"out\es-es\Hello01.exe.mui" out\resource.es-es.loc.res

El archivo out\es-es\Hello01.exe.mui contiene los recursos que creamos en español.  Ahora sólo nos falta un paso para que el manejador de recursos pueda confirmar que nuestros archivos en inglés y en español son equivalentes.

muirct -c out\Hello01.exe -e out\es-es\Hello01.exe.mui

Este comando toma el checksum del ejecutable original y lo copia al archivo de recursos en español.  Este paso es necesario para que el manejador de recursos pueda confirmar que los dos archivos pertenecen a la misma aplicación y versión.  De esta manera se evitan conflictos cuando se modifican los recursos originales y no se actualizan las traducciones.  En este caso el manejador de recursos tomaría los recursos en el idioma original e ignoraría la versión antigua de las traducciones.

Ahora podemos copiar nuestro ejecutable junto con los dos archivos de recurso al directorio de nuestra aplicación siguiendo la siguiente estructura:

• Hello01.exe
• en-us\Hello01.exe.mui
• es-es\Hello01.exe.mui

Al ejecutar Hello01.exe el manejador de recursos pregunta al sistema operativo que idioma utilizar para cargar los recursos.  En un sistema en inglés se mostrarán los recursos originales y en español obtenemos lo siguiente:

Sin compilar una línea de código hemos reconstruido los recursos para la aplicación de ejemplo, y ahora queda claro como podemos separar el trabajo de desarrollar una aplicación de traducirla a otros idiomas.

Normalmente nuestro código compilado se puede describir por la siguiente imagen:

Donde vemos que tanto el código como los datos usados para desplegar el interfaz de usuario.  Utilizando MUI lo que podemos hacer es lo siguiente:

En este caso tenemos un archivo de tipo .exe (o .dll) que contiene el código y un archivo .mui que contiene los recursos a traducir.

Esto ya es muy bueno, pues nos permite sustituir el archivo con los recursos independientemente del código.  Pero además el diseño de MUI nos permite instalar múltiples idiomas conforme sean necesarios.  Nuestros archivos ahora deben contener lo siguiente:

• Hello01.exe - Código ejecutable válido para todos los idiomas
• Hello01.exe.mui - Recursos traducidos para un idioma (inglés)

Y para que esto funcione correctamente necesitamos instalarlos con la siguiente estructura de directorios:

<appdir>\Hello01.exe
<appdir>\en-us\Hello01.exe.mui

Esto nos permite crear un nuevo archivo .mui para otro idioma y con instalarlo en el directorio correcto tendremos una aplicación que soporta múltiples idiomas.

Volviendo al ejemplo

Regresando a nuestro ejemplo anterior, veamos como compilar nuestro ejecutable en dos archivos, uno conteniendo el código y otro con los recursos a traducir.

Los comandos descritos a continuación se ejecutan en la línea de comandos de VS 2008, y en el directorio donde trabajaremos debemos tener los siguientes archivos:

• resource.h

   1: #define IDS_TITULO 1001

   2: #define IDS_MENSAJE 1002

• resource.rc - Nótese que ahora definimos el lenguaje en qué están creados los recursos.

   1: #include "winnt.h"

   2: #include "resource.h"

   3:  

   4: LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US

   5:  

   6: STRINGTABLE

   7: BEGIN

   8:     IDS_TITULO "Hello world!"

   9:     IDS_MENSAJE "Sample App"

  10: END

• resource.rcconfig - Este archivo indica qué tipo de recursos son localizables y deben traducirse.  Aquí indicamos qué recursos se mantienen en el archivo ejecutable y cuáles van al archivo .mui.  Al final de este artículo hay una liga donde se describe la sintaxis de los archivos .rcconfig.

   1: <?xml version="1.0" encoding="utf-8"?> 

   2: <localization>

   3:   <resources>

   4:     <win32Resources fileType="Application">

   5:       <neutralResources>

   6:         <resourceType

   7:            typeNameId="#16"

   8:         />

   9:       </neutralResources>

  10:       <localizedResources> 

  11:          <resourceType

  12:                 typeNameId="#2"

  13:                 itemId="5 6 7 8 9 10 11 12"

  14:                 itemName="HTML PRI"

  15:          />

  16:          <resourceType

  17:                 typeNameId="#4"

  18:          />

  19:          <resourceType

  20:                 typeNameId="#5"

  21:          />

  22:          <resourceType

  23:                 typeNameId="#6"

  24:          />

  25:          <resourceType

  26:                 typeNameId="#9"

  27:          />

  28:          <resourceType

  29:                 typeNameId="#11"

  30:          />

  31:          <resourceType

  32:                 typeNameId="#16"

  33:          />

  34:          <resourceType

  35:                 typeNameId="HTML"

  36:          />

  37:          <resourceType

  38:                 typeNameId="#23"

  39:          />

  40:          <resourceType

  41:                 typeNameId="#240"

  42:          />

  43:          <resourceType

  44:                 typeNameId="#1024"

  45:          />

  46:          <resourceType

  47:                 typeNameId="MY_TYPE"

  48:          />

  49:       </localizedResources> 

  50:     </win32Resources>

  51:   </resources>

  52: </localization>

• hello01.cpp

   1: #include <windows.h>

   2: #include "resource.h"

   3:  

   4: #define BUFFER_MAX 100

   5:  

   6: int main(int argc, WCHAR** argv)

   7: {

   8:     WCHAR mensaje[BUFFER_MAX];

   9:     WCHAR titulo[BUFFER_MAX];

  10:     ::LoadString(::GetModuleHandle(NULL), IDS_MENSAJE, mensaje, BUFFER_MAX);

  11:     ::LoadString(::GetModuleHandle(NULL), IDS_TITULO, titulo, BUFFER_MAX);

  12:     ::MessageBox(NULL, mensaje, titulo, MB_OK);

  13:     return 0;

  14: }

Y deben existir los subdirectorios

• out
• out\en-us

Nota:  Todos los comandos para compilar se ejecutan desde el directorio donde tenemos nuestro código.  Comenzamos compilando el código fuente:

cl /Fo"out\\" /D "UNICODE" /D "_UNICODE" /c Hello01.cpp

Y a continuación compilamos los recursos:

rc -fo out\resource.res -fm out\resource.loc.res -q resource.rcconfig resource.rc

Finalmente enlazamos los resultados de los pasos anteriores para crear nuestro ejecutable final:

link /out:"out\Hello01.complete.exe" out\Hello01.obj out\resource.res user32.lib

Hasta ahora no hemos hecho nada distinto, excepto por etiquetar los recursos utilizando con el archivo .rcconfig.  El siguiente paso es el que utilizará esta información para separar nuestro ejecutable en un archivo que contiene el código y otro con los recursos.

muirct -q resource.rcconfig out\Hello01.complete.exe out\Hello01.exe out\en-us\Hello01.exe.mui

Es muy importante hacer notar que si el ejecutable se encuentra en el directorio x, el archivo .mui debe aparecer en el directorio x\<codigo de lenguaje>.  Si no hacemos esto correctamente, el manejador de recursos no podrá encontrarlo.  Ejecutando nuestro programa, obtenemos el resultado esperado:

Ahora, sólo para confirmar qué sucede si eliminamos el archivo .mui (o se encuentra en una ubicación incorrecta), esto es lo que ocurre con el programa después de borrar out\en-us\Hello01.exe.mui:

En la tercera parte veremos cómo se pueden generar recursos para otros idiomas y cómo determina el sistema que recursos utilizar.

Referencias:

• Compilador de recursos (rc)
• Herramienta para MUI (muirct)
• Sintaxis del archivo .rcconfig.

Un programa de ejemplo

   1: #include <windows.h>

   2:  

   3: int main(int argc, WCHAR** argv)

   4: {

   5:     ::MessageBox(NULL, L"Hello world!", L"Sample App", MB_OK);

   6:     return 0;

   7: }

El clásico "Hola mundo" con sabor a Windows.  Este programa despliega un cuadro de diálogo con título "Sample App" y el mensaje "Hello world!".  Para un programa limitado a usarse en un idioma este método puede ser suficiente - aunque esto puede acarrear problemas si tenemos que desplegar el mismo mensaje en diferentes secciones del programa.  Con unos pequeños cambios podemos resolver este problema.

   1: #define MENSAJE L"Hello world!"

   2: #define TITULO L"Sample App"

   3:  

   4: #include <windows.h>

   5:  

   6: int main(int argc, WCHAR** argv)

   7: {

   8:     ::MessageBox(NULL, MENSAJE, TITULO, MB_OK);

   9:     return 0;

  10: }

Esta factorización es clave, y nos abre un gran número de posibilidades.  Con esta perspectiva nos damos cuenta que podemos separar los mensajes que aparecen en el interfaz de usuario de nuestro código.  Un primer paso sería mover todos los mensajes a su propio archivo de encabezado.  Una desventaja de este método es que necesitamos recompilar nuestro código para cada idioma.

Windows y Visual Studio nos proporcionan una solución que va aún más lejos, con el uso de archivos de recursos (página no disponible en español).  De esta forma podemos guardar texto, imágenes, cuadros de diálogo o hasta recursos arbitrarios en un archivo separado de nuestro código.

resource.h

   1: #define IDS_TITULO 1001

   2: #define IDS_MENSAJE 1002

resource.rc

   1: #include "resource.h"

   2:  

   3: STRINGTABLE

   4: BEGIN

   5:     IDS_TITULO "Hello world!"

   6:     IDS_MENSAJE "Sample App"

   7: END

main.cpp

   1: #include <windows.h>

   2: #include "resource.h"

   3:  

   4: #define BUFFER_MAX 100

   5:  

   6: int main(int argc, WCHAR** argv)

   7: {

   8:     WCHAR mensaje[BUFFER_MAX];

   9:     WCHAR titulo[BUFFER_MAX];

  10:     ::LoadString(::GetModuleHandle(NULL), IDS_MENSAJE, mensaje, BUFFER_MAX);

  11:     ::LoadString(::GetModuleHandle(NULL), IDS_TITULO, titulo, BUFFER_MAX);

  12:     ::MessageBox(NULL, mensaje, titulo, MB_OK);

  13:     return 0;

  14: }

Nuestro código se complica un poco, pero ahora tenemos la flexibilidad de reconstruir nuestra aplicación para cualquier idioma con sólo compilar los archivos .RC, o con un poco de ingenio se pueden compilar todos los idiomas a partir de una base de código utilizando "makefiles" en una estructura de directorios que separe el código en común de los archivos de recursos.  (Documentación de LoadString).

Ahora ya es posible que los expertos en localización modifiquen los archivos .rc sin preocuparse por el código.  Y los desarrolladores pueden trabajar en la lógica del programa sin preocuparse por mantener la traducción sincronizada.  Hasta aquí todo parece funcionar bien, ¿pero no sería mejor que incluso el código y los recursos fueran independientes después de la instalación?  En la próxima entrega veremos como MUI nos permite hacer este cambio.

Los blogs de TechNet y MSDN cubren una gran cantidad de temas, tecnologías y avances, pero la mayor parte de las discusiones son en inglés.  También existe la posibilidad de hacer traducciones automáticas, pero la tecnología no ha avanzado lo suficiente para hacer este sistema lo suficientemente robusto y flexible para una comunicación bidireccional.

Conociendo esta necesidad, la pregunta es: ¿qué espero lograr con los artículos aquí publicados?

Muy sencillo, espero que con este blog podamos crear una comunidad de usuarios de tecnología de Microsoft, ingenieros de software interesados en aprender un poco más de nuestra profesión y programadores domingueros en búsqueda de datos curiosos y reflexiones sobre computación y electrónica.  Para lograr esto planeo cubrir temas como:

• Lenguajes y tecnologías de programación
• Localización y traducción, especialmente al español
• Accesibilidad (herramientas como lectores de pantalla, reconocimiento de voz, APIs, etc.)
• Anécdotas y lecciones aprendidas desarrollando software

También se aceptan sugerencias de los lectores, y en la medida que mi experiencia lo permite responderé a las preguntas.

Me despido por el momento, con la promesa de publicar un artículo sobre localización y traducción de software en Windows en próximos días.