Lazarus es una gran herramienta para desarrollar en cualquier plataforma, y compilar para Windws, Linux Mac y otros. Precision con su librería le agrega la posibilidad de internacionalizar los sistemas.

1. Juan Carlos Porras V.
Acoplamiento de
Precision Language Suite
con Lazarus 1.0.8

2. Obtener Precision Language Suite
(PLS)
*El sistema PLS se puede obtener desde la pagina web de
los desarrolladores,
http://www.be-precision.com/forum/index.php?topic=306,
el link direcciona a un foro en el cual esta disponible la
versión 2.5 que es portable.
*El desarrollo de este documento es en base a este
programa.

3. Iniciar Precision Language Suite
1. Para iniciar el sistema se debe ejecutar “PrecisionLangSuite.exe”,
ubicado en la carpeta “Editor” de PLS.

4. Crear un Proyecto
1. Generamos un nuevo proyecto, en la pestaña “General”
definimos el nombre del proyecto al cual le vamos a
generar las distintas librer í as de idiomas y el lugar en
donde se van a almacenar, en este paso es importante
recordar que se debe de crear una carpeta llamada
“Langs”, y dentro de esta guardar las librerías.
2. En la pestaña “Languages” seleccionamos los idiomas
que van a permitirse dentro del programa en desarrollo.

5. Crear un Proyecto
3. En la pesta ñ a “ Options ” definimos el idioma por
defecto, entre otras.
4. Luego damos click en el botón “OK” y tenemos listo
nuestro proyecto.

6. Cargar un Form
El siguiente paso es cargar la pantalla del proyecto de lazarus
“.lfm” (Lazarus Form), debemos de arrastrarla hasta donde dice
"VCL Components", y as í PLS obtiene los componentes a los
cuales se les puede cambiar las propiedades “Caption” y “Hint”.

7. Configuración de los Idiomas
Al lado de los componentes del form podemos observar los diferentes
idiomas los cuales hemos seleccionado.
Estos tendrán derecho a estar en el programa en desarrollo, en este caso de
ejemplo han sido: Español, Inglés, y Francés.
Se debe de digitar las palabras a mostrar en los diferentes idiomas, si la
palabra se ve de color gris entonces a la hora de ejecutar el programa no se
realizará el cambio, se debe de escribir todo de nuevo, y cuando las palabras
estén de color negro el cambio sí será efectivo.

8. Librerías de Idiomas
Al lado derecho de la pantalla podemos observar las
librerías que se generan para los diversos idiomas.
Junto a estas están las terminaciones para cada idioma
(en, es, y fr), estas son las que el c ó digo reconoce a la
hora de realizar los cambios de idioma.

9. Mensajes y Constantes
Para generar mensajes que se muestran en el sistema en desarrollo,
se deben definir constantes en PLS, para que puedan ser llamadas
desde el código, y el cambio de idioma sea efectivo.
SUGERENCIA: Como podemos observar en la imagen anterior existe una columna
identificador, acá podemos iniciar con “msg_NOMBRE”, para motivos de orden, y facilidad de
escritura de código al momento de cargarlos desde el código.

10. Desarrollo de Código desde Lazarus 1.0.8
Para iniciar se debe instalar el paquete “pls_lazarus.lpk”, el cual viene
incluido en la carpeta "Packages" del sistema Precision Language
Suite.
Al compilar el paquete Lazarus reconocer á las librer í as necesarias
como “plsLangMan”, “plsDialogs”, entre otras las cuales también
vienen dentro de la carpeta del sistema PLS, ubicadas
específicamente en la carpeta “Source”, cabe destacar que todas
estas librerías se deben agregar a la carpeta en donde se localiza el
proyecto en desarrollo, para as í poder hacer efectivo el uso de
todas las funciones.

11. Preparar el Form
En el form donde vamos a hacer las llamadas o los
cambios de idioma debemos colocar el componente
“plsController1”, como se aprecia en la imagen.

12. Código
Desde el uses del form, debemos llamar a las l í brer ías
“plsController”, “plsDialogs” y “LangConsts”.

13. Código
En la siguiente imagen podemos ver los procedimientos
que son necesarios para hacer efectivo el cambio de
idioma en el programa.

14. Código
Para iniciar vamos a declarar el procedimiento
“plsController1InitLangManager”, en donde, cómo podemos observar
tenemos diferentes opciones de llamar a los archivos que contienen los
idiomas, pero solo vamos a utilizar el procedimiento llamado
“ReadAvailableLanguages”.
procedure TfrmPrincipal.plsController1InitLangManager(Sender: TObject);
begin
{ LanguageManager Initialization }
{ Here you can setup miscellaneous options for loading localization files via the main TplsController (and its associated LanguageManager) }
// TplsController(Sender).LangManager.FileNames.CommaText:='DemoMain,Comm*'; // set this, if you want to filter language files to those names (masks supported)
// TplsController(Sender).LangManager.RecursiveFolder:=True; // set this, if you want to get language files from subfolders too
// TplsController(Sender).LangManager.Folder:='....Langs'; // set this, if your language files are in different folder then default (AppExeLangs)
// TplsController(Sender).DefaultLanguageCode:=''; // instead of default language code, you can set a language code loaded from your ini/config here
{ End LanguageManager Initialization }
ReadAvailableLanguages;
end;

15. Código
El siguiente procedimiento es “plsController1BeforeLangChange”, el
cual se encarga de cargar las librerías, constantes, y variables que
se encuentran en las librerías guardadas en la carpeta “Lang”, para
poder ser utilizadas en el programa en desarrollo.
procedure TfrmPrincipal.plsController1BeforeLangChange(Sender: TObject);
begin
plsDialogs.LanguageChanged; // update constants (variables) in plsDialogs unit
LangConsts.LanguageChanged; // update user defined constants (variables/resources)
LangConsts.Mensaje; //Procedimiento LangConst que tambien carga variables/constantes de las librerias generadas por PLS
TplsController(Sender).LangManager.Clear(True, False); // clear localization strings table for constants (speeds up searching for properties a
little)
end;

16. Código
El procedimiento que continua es “plsController1LanguageChanged”,
encargado de controlar el cambio de idioma.
procedure TfrmPrincipal.plsController1LanguageChanged(Sender: TObject);
var
j:Integer;
begin
Application.Title := Self.Caption;
for j := 0 to miLanguages.Count - 1 do
if miLanguages.Items[j].Hint=plsController1.LanguageCode then
begin
miLanguages.Items[j].Checked:=True;
break;
end;
end;

17. Código
Continuamos con un procedimiento que se encarga de reportar
cualquier error que se presente a la hora de cargar o cambiar el idioma,
“plsController1Error”.
procedure TfrmPrincipal.plsController1Error(Sender: TObject);
begin
with TplsController(Sender) do
MessageDlg('', LanguageName+' ('+LanguageCode+'): ['+Owner.Name+' ('+Owner.ClassName+')] '+LastError, mtWarning);
end;

18. Código
El siguiente procedimiento, es “ ReadAvailableLanguages ”,
este procedimiento obtiene las librerías que contienen los idiomas, y
carga cada idioma al menuitem.
procedure TfrmPrincipal.ReadAvailableLanguages;
var
MI:TMenuItem;
i:Integer;
begin
// fill menu with available languages
miLanguages.Clear;
for i := 0 To plsController1.LanguagesCount - 1 do
begin
MI:=TMenuItem.Create(self);
MI.Hint:=plsController1.LanguageCodes[i];
MI.Caption:=plsController1.LanguageNames[i];
MI.OnClick:=@miChangeLanguageClick;
MI.RadioItem:=True;
MI.GroupIndex:=1;
miLanguages.Add(MI);
end;
end;

19. Código
El procedimiento “miChangeLanguageClick”, realiza el cambio
de idioma al formulario.
procedure TfrmPrincipal.miChangeLanguageClick(Sender:TObject);
begin
// load another translation
plsController1.LanguageCode:=TMenuItem(Sender).Hint;
end;

20. Código
El procedimiento “sbTestMessageClick”, se puede utilizar para
realizar pruebas.
procedure TfrmPrincipal.sbTestMessageClick(Sender. TObject);
begin
MessageDlg('', str_test_msg, mtConfirmation, mbYesNoCancel);
end;

21. Código
El procedimiento “ btn1Click ” , es para demostrar la forma de
llamar a mensajes, avisos, o constantes que se encuentran en las
librer í as generadas por PLS y mostrarlo con “ showmessage ” , por
ejemplo.
procedure TfrmPrincipal.btn1Click(Sender: TObject);
var
mensaje : String;
begin
mensaje := LangConsts.Prueba; // Cargo la variable con el valor de la constante
//ShowMessage(mensaje); // y muestro la variable
ShowMessage(LangConsts.Prueba); // Muestro el valor de la constante directamente
end;

22. Código
Ahora continuamos con la llamada a las librer í as utilizadas por el
sistema las cuales se hacen desde el archivo .lpr del sistema.
program Idiomas;
{$mode objfpc}{$H+}
uses
{$IFDEF UNIX}{$IFDEF UseCThreads}
cthreads,
{$ENDIF}{$ENDIF}
Interfaces, // this includes the LCL widgetset
Forms, pls_lazarus, ufrmPrincipal, uDM, LangConsts,
plsController in '....SourceplsController.pas',
plsLangMan in '....SourceplsLangMan.pas',
plsDialogs in '....SourceplsDialogs.pas';
{$R *.res}
begin
RequireDerivedFormResource := True;
Application.Initialize;
Application.CreateForm(TfrmPrincipal, frmPrincipal);
Application.CreateForm(TDataModule1, DataModule1);
Application.Run;
end.

23. Código
Ahora el siguiente paso es realizar en el modulo de datos de nuestro
programa el procedimiento “LanguageChanged”.
public
{ public declarations }
procedure LanguageChanged(Sender:TObject);
end;
implementation
uses
plsLangMan, plsDialogs, LangConsts;
{$R *.lfm}
procedure TDataModule1.LanguageChanged(Sender:TObject);
begin
// update vcl properties for this data module
if not LanguageManager.LangVCL(Self) then
MessageDlgLM('',LanguageManager.LanguageName+' ('+LanguageManager.LanguageCode+'):
['+Self.Name+' ('+Self.ClassName+')]'+LanguageManager.LastError,mtWarning);
// make other assignments if needed
end;

24. Código
Y por último tenemos crear una unidad llamada LangConsts.
En esta unidad realizamos los procedimientos que se encargan de
llamar a las constantes, las variables y las librer í as que son
declaradas y generadas por PLS.
Debemos declarar variables como "String", para que sean cargadas
luego con los valores de las librerías.
Por último, los procedimientos que creemos en esta unidad deben ser
cargados en el procedimiento "plsController1BeforeLangChange",
para que la obtención de un valor sea efectivo.

25. unit LangConsts;
interface
var
str_test_msg : string = 'Test message';
Prueba : String;
procedure LanguageChanged;
procedure Mensaje;
implementation
uses
plsLangMan, SysUtils;
procedure LanguageChanged;
begin
with LanguageManager do
begin
str_test_msg := LangText('str_test_msg',str_test_msg);
// prueba := LangText('Prueba', Prueba);
end;
end;
Procedure Mensaje;
begin
with LanguageManager do
begin
prueba := LangText('Prueba', Prueba); //Prueba esta declarada como una constante en PLS
end;
end;
end.

26. Con estos pasos se logró la creación de un proyecto pequeño de demostración el cual funciona
correctamente.
Gracias!