intl
1.0.0
INTL simplifica la creación de software multilingüe en Visual FoxPro (VFP). Le brinda la posibilidad de crear aplicaciones Visual FoxPro multilingües mientras minimiza las molestias de crear software de múltiples versiones.
Este documento sirve para describir lo siguiente:
strings.dbfMsgSvc()INTLcINTLAbstractcINTLCurrencycINTLDatacINTLFontcINTLMementocINTLPicturecINTLRightToLeftcINTLStrategycINTLStringconfig.fpwMsgSvc()MsgSvc()strings.dbf basado en un .PJXstrings.dbf basado en un .SCXstrings.dbf basado en un .VCXstrings.dbf basado en un .MNXstrings.dbf basado en un .FRXINTLVisitorPrimero, coloque los archivos INTL en un directorio nuevo y limpio.
Entonces,
Implementar archivos: coloque manualmente archivos relacionados con su proyecto como se describe en Cómo colocar correctamente sus archivos INTL.
Modifique el archivo config.fpw : para los menús, agregue las dos líneas al archivo config.fpw como se explica en Cómo localizar menús.
Siembre su definición de clase de formulario: por ahora, probablemente para siempre, invoque INTL en formularios con una instrucción Form::Init() que llame al objeto INTL. Consulte Cómo obtener la localización automática de formularios.
Si necesita localización, cree una instancia de un objeto INTL: ahora, cuando se requiera localización, cree y configure un objeto INTL como se describe en Cómo crear una instancia de un objeto INTL.
Es importante que VFP encuentre los archivos de INTL según sea necesario. Aquí es donde debe colocar sus archivos INTL para que estén disponibles en su entorno de desarrollo:
Implemente sus archivos de la siguiente manera:
genmenux.prgintl.prgSET PATH .strings.dbf strings.fpt strings.cdxSET PATH .msgsvc.dbf msgsvc.fpt msgsvc.cdxSET PATH . Cree un miembro llamado _SCREEN.oINTL para contener la instancia INTL.
Para utilizar INTL, su aplicación debe crear una instancia de un objeto INTL. Hay muchas maneras de hacer esto, la mejor es agregarlo a _SCREEN , así:
*-- Anywhere, anytime:
*-- Instantiate INTL in _SCREEN
SET PROCEDURE TO INTL ADDITIVE
SCREEN.AddObject( "oINTL", "INTL" )
Localice formularios pasando sus referencias de objetos al método Localize() de un objeto INTL.
Los formularios (y cualquier otro contenedor) se localizan pasando su referencia al método oINTL.Localize() .
*-- Configure oINTL to another language
_SCREEN.oINTL.SetLanguage( "French" )
*-- Instantiate a form. If the form calls INTL in its Init()
*-- method, then the form appears in French....
DO FORM MyForm Name MyForm
....o puede localizar el formulario sobre la marcha.
_SCREEN.oINTL.Localize( MyForm )
Realice una llamada a oINTL en su jerarquía Form.Init() .
Para hacer que sus formularios se localicen automáticamente, llame al método oINTL.Localize() en su jerarquía de clases de formulario. Para hacerlo, coloque el siguiente código en el método Init() de la definición de su clase de formulario. |
*-- Don't forget to call the ParentClass!
DODEFAULT()
IF TYPE("_SCREEN.oINTL" ) == "O"
_SCREEN.oINTL.Localize( This )
ENDIF
Se utiliza un controlador GENMENUX para localizar menús. Para activar GENMENUX y su controlador INTL.PRG, coloque las siguientes líneas en su config.fpw :
Agregue estas líneas a config.fpw .
*-- Configuring for INTL menus.
_GENMENU = GENMENUX.PRG
_MNXDRV2 = INTL.PRG
*-- End of configuration for INTL menus.
Algunos de estos cambios requieren reiniciar VFP. Para evitar reiniciar FoxPro en este momento, ejecute el siguiente comando en la ventana de comandos:
_GENMENU = HOME()+”GENMENUX.PRG”
Esto es todo lo que necesita cambiar en su entorno de desarrollo para localizar menús. De ahora en adelante, genere menús como de costumbre.
GENMENUX es genial. Échale un vistazo.
Nota : GENMENUX no reemplaza el generador de menú nativo de VFP. Dado que GENMENUX llama a GENMENU.PRG, su código es generado por VFP como de costumbre. El INTL Toolkit utiliza GENMENUX como preprocesador. GENMENUX es un programa rico. Consulte GENMENUX para obtener más información sobre sus capacidades.
La estructura de strings.dbf determina qué idiomas admite.
Utilice el método SetLanguage() para cambiar el idioma de INTL.
INTL viene con una tabla llamada strings.dbf que contiene una variedad de campos, uno de los cuales es cOriginal y puede contener otros campos para diferentes idiomas, por ejemplo cFrench , cGerman , cSpanish , etc.
Los idiomas que admite están determinados por la estructura de la tabla strings.dbf . Para agregar un nuevo idioma, cambie la estructura de strings.dbf .
Para cambiar el idioma de localización actual, utilice el método SetLanguage() . Digamos que queremos que un formulario esté en francés. Primero configure el idioma, luego localice el formulario:
_SCREEN.oINTL.SetLanguage( "French" )
_SCREEN.oINTL.Localize( _SCREEN.ActiveForm )
Nada demuestra mejor que cambiar el idioma de visualización sobre la marcha.
Para intercambiar idiomas sobre la marcha, lo cual siempre es un éxito en una demostración (hágalo incluso si no es necesario, es muy fácil), cree un mecanismo en su aplicación para configurar el objeto INTL con INTL.SetLanguage() , como sigue.
_SCREEN.oINTL.SetLanguage("German" ) && Configure INTL for German
FOR i = 1 TO ALEN(_SCREEN.Forms ) && Localize active forms
_SCREEN.oINTL.Localize( _SCREEN.Forms[i] )
ENDFOR
DO MAIN.MPR && Refresh the menu too!
Para cambiar la personalidad basada en la configuración regional de su aplicación, le sugiero que subclase INTL para que funcione según sea necesario. Subclasificar INTL para sus propias necesidades es una excelente manera de satisfacer las demandas locales con un mínimo de código y complicaciones.
A continuación se muestra un ejemplo de una subclase INTL que me funciona en una variedad de configuraciones regionales. Subclasificamos la clase INTL para cambiar todas las configuraciones específicas de la configuración regional a la vez.
Tome nota de la estrategia RightToLeft (clase cINTLRightToLeft ), que es útil para los sistemas de escritura del Medio Oriente.
DEFINE CLASS MyINTL AS INTL
FUNCTION SetLocale( tcLocale )
IF EMPTY( tcLocale )
tcLocale = this.GetLocale()
ENDIF
IF INTL::SetLocale( @tcLocale )
DO CASE
CASE PROPER(tcLocale )= "Usa"
SET CURRENCY TO "$"
SET CURRENCY LEFT
SET POINT TO "."
SET SEPARATOR TO ","
SET DATE TO American
SET MARK TO "/"
this.SetRightToLeft( .F. )
this.SetConversion( "Usa", 1.33 )
this.SetLanguage( "USEnglish" )
CASE PROPER(tcLocale )= "France"
SET CURRENCY TO " F"
SET CURRENCY RIGHT
SET POINT TO ","
SET SEPARATOR TO "."
SET DATE TO DMY
SET MARK TO "/"
this.SetRightToLeft( .F. )
this.SetConversion( "France", 0.28 )
this.SetLanguage( "French" )
CASE PROPER(tcLocale )= "Germany"
SET CURRENCY TO " DM"
SET CURRENCY RIGHT
SET POINT TO ","
SET SEPARATOR TO "."
SET DATE TO DMY
SET MARK TO "/"
this.SetRightToLeft( .F. )
this.SetConversion( "Germany", 0.28 )
this.SetLanguage( "German" )
CASE PROPER(tcLocale )= "Israel"
SET CURRENCY TO "ILS"
SET CURRENCY LEFT
SET POINT TO "."
SET SEPARATOR TO ","
SET DATE TO British
SET MARK TO "/"
this.SetConversion( "Israel", 0.41 )
this.SetRightToLeft( .T. )
this.SetLanguage( "Hebrew" )
ENDCASE
ENDIF
ENDDEFINE
INTL está diseñado para implementarse rápidamente.
Esto es lo que debe hacer para localizar su aplicación esta mañana para una demostración multilingüe esta tarde. Si ha utilizado correctamente las herramientas de diseño de VFP, este es un trabajo rápido. De lo contrario, llevará un poco más de tiempo diseñarlo.
Los pasos básicos son:
Instale INTL y inicialice el método Init() de las clases base de su formulario. Siga los pasos de la sección titulada Instalación de INTL. Asegúrate de revisar todos los pasos. Especialmente importantes son los pasos titulados Cómo crear una instancia de un objeto INTL, Cómo obtener la localización automática de formularios y Cómo localizar menús.
Modifique la estructura de strings.dbf y agregue un campo para cada idioma que necesite.
strings.dbf que viene con INTL y colóquela en el directorio raíz de su proyecto.ZAP la tabla strings.dbf que colocó en la raíz de su proyecto.MODIFY STRUCTURE de strings.dbf y agrega una nueva columna llamada cSwahili con una longitud de 120. Tenga en cuenta que la "c" en cSwahili es obligatoria. Haga que su aplicación cree un objeto INTL. Al principio de su aplicación, cree una instancia de un objeto INTL como se describe en Cómo crear una instancia de un objeto INTL. Mostrar en un idioma diferente ahora es cuestión de usar su método SetLanguage() .
Haga un "Construir todo". Abra su proyecto, seleccione "Compilar" y cree una aplicación o archivo ejecutable, asegurándose de seleccionar "Recompilar todos los archivos". Ve a almorzar.
Para cargar automáticamente strings.dbf , ejecute su aplicación o use la utilidad INTLTool. Hay dos formas de completar la tabla strings.dbf con las cadenas de interfaz de su proyecto. La primera forma es ejecutar su programa. A medida que se crean instancias de objetos, INTL agregará las cadenas (como Caption , Tooltiptext , etc.) a la tabla de cadenas. Una mejor manera es ejecutar el programa de actualización INTLTool. Consulte INTLTool.
Ingrese las traducciones en la tabla strings.dbf . En la columna cSwahili , escriba traducciones al swahili, completas con teclas de acceso rápido y teclas de acceso directo según sea necesario. Nota: puede obtener una traducción "rápida y sencilla" para pruebas y demostraciones internas haciendo:
`REPLACE ALL cSwahili with "**"+TRIM(cOriginal)+"**" FOR cOriginal <> "(("`
Recomiendo crear un objeto INTL principal llamado _SCREEN.oINTL .
Es posible que varios objetos INTL separados coexistan juntos. Cada objeto INTL es una amalgama de otros objetos INTL llamados ganchos o estrategias. Su objeto INTL principal es el objeto INTL maestro en su entorno, que supongo que se llama _SCREEN.oINTL .
Utilice el método SetConfig( n ) para configurar su objeto INTL principal.
INTL se configura con un método _SCREEN.oINTL.SetConfig( n ) , donde n es un valor entero bit a bit con la siguiente interpretación:
| Valor | Significado de la configuración |
|---|---|
1 (predeterminado)2481632 | Cargar la estrategia String Cargar la estrategia de fuente Cargar la estrategia de datos Cargar la estrategia de imagen Cargar la estrategia de divisas Cargue la estrategia RightToLeft |
Ejemplo: crear un objeto INTL que localice cadenas y fuentes
*-- create an INTL object
_SCREEN.AddObject("oINTL", "INTL" )
*-- Load the strings and font strategies.
_SCREEN.oINTL.SetConfig( 1 + 2 )
El idioma operativo y la configuración regional del objeto INTL principal se configuran con los métodos SetLanguage() y SetLocale() .
Las estrategias están configuradas bit a bit.
Configure estrategias individuales de la siguiente manera: obtenga una referencia a la estrategia y luego configúrela. Estos son los significados de configuración para cada estrategia configurable.
| Estrategia | Valor | Localización |
|---|---|---|
| Datos | 1 (predeterminado)24816 | BoundColumnControlSourceRowSourceRecordSourceInputMask |
| Fuente | 1 (predeterminado)2 (predeterminado) | Font y FontSizeDynamicFont y DynamicFontSize |
| Imagen | 1 (predeterminado)24 (predeterminado)8 | PictureDownPictureIconDragIcon |
| De derecha a izquierda | 1 (predeterminado) | Todos los objetos invertidos dentro de sus respectivos contenedores. |
| Instrumentos de cuerda | 1 (predeterminado)2 (predeterminado)4 (predeterminado) | CaptionToolTipTextStatusBarText |
Para controlar una estrategia cargada, utilice el método oINTL.GetStrategy() . A partir de entonces, utilice el método oINTL.SetConfig() del identificador para configurar la estrategia.
Ejemplo: crear un objeto INTL que localice cadenas pero no información sobre herramientas
Utilice el método oINTL.GetStrategy() para obtener una referencia de objeto, luego utilice su método oINTL.SetConfig() para configurarlo.
*-- create an INTL object
_SCREEN.AddObject("oINTL", "INTL" )
*-- Load the strings and font strategies.
_SCREEN.oINTL.SetConfig( 3 )
*-- Configure Strings to NOT localize ToolTips
LOCAL loTempHandle
loTempHandle = _SCREEN.oINTL.GetStrategy( "String" )
*-- For the string strategy, the configuration
*-- for Caption and StatusBarText is 5
loTempHandle.SetConfig( 1 + 4 )
Ejemplo: cree un objeto INTL que localice solo cadenas y máscaras de entrada.
*-- create an INTL object
_SCREEN.AddObject( "oINTL", "INTL" )
*-- Load the strings and data strategies.
_SCREEN.oINTL.SetConfig( 5 )
*-- now modify the data strategy from its default.
LOCAL oTemp
oTemp = _SCREEN.oINTL.GetStrategy( "Data" )
*-- Input masks only.
oTemp.SetConfig( 16 )
Las cadenas de interfaz suelen ser lo primero que nos viene a la mente cuando pensamos en traducir software.
INTL carga solo la estrategia de cadena de forma predeterminada.
La siguiente tabla enumera los bits de configuración para INTL. Estos bits de configuración deciden qué estrategia se carga. De forma predeterminada, solo se carga la estrategia String, es decir, INTL localiza automáticamente las cadenas de forma predeterminada.
| Clase | Bits de configuración | Localización |
|---|---|---|
| INTL | 1 (predeterminado)4281632 | Estrategia cINTLString cargadaEstrategia cINTLFont cargadaEstrategia cINTLData cargadacINTLPicture cargadacINTLCurrency cargadaEstrategia cINTLRightToLeft cargada |
| CINTLSarda | 1 (predeterminado)2 (predeterminado)3 (predeterminado) | CaptionToolTipTextStatusBarText |
Active la estrategia de cadena de la siguiente manera:
*-- cINTLString is loaded by default.
*-- So there’s usually no need to do this
_SCREEN.oINTL.SetStrategy( "String", "cINTLString" )
Otra forma más críptica de cargar la estrategia String es:
-- Set configuration bit 2^0 "ON"
_SCREEN.oINTL.SetConfig( BITSET( oINTL.GetConfig(), 0 ))
Entonces hay dos maneras de hacerlo.
Las cadenas se pueden localizar proporcionando traducciones en strings.dbf .
| cOriginal | cFrancés |
|---|---|
Yes | Oui |
No | Non |
Configure la estrategia String con su método SetConfig() .
La estrategia INTL String, como todas las estrategias, está configurada bit a bit. Puede controlar el objeto de estrategia de cadena de la siguiente manera:
Ejemplo: para deshabilitar el procesamiento de fuentes para la propiedad ToolTipText :
*-- Get a handle on the string strategy:
oFont = _SCREEN.oINTL.GetStrategy( "String" )
*-- We want Caption( 1 ) and StatusbarText( 4 ) only
oFont.SetConfig( 5 )
Las fuentes pueden ser específicas de la región.
Es posible que fuentes como Arial, Times New Roman y MS Sans Serif no sean adecuadas en algunos idiomas. Esto importa; Es posible que necesitemos una forma de cambiar las fuentes cuando cambiamos de configuración regional.
La siguiente tabla enumera los bits de configuración para que el objeto INTL cargue la estrategia de fuente y los enteros de configuración para configurar la estrategia de fuente.
| Clase | Bits de configuración | Localización |
|---|---|---|
| INTL | 1 (predeterminado)2481632 | Estrategia cINTLString cargadaEstrategia cINTLFont cargadaEstrategia cINTLData cargadacINTLPicture cargadacINTLCurrency cargadaEstrategia cINTLRightToLeft cargada |
| CINTLFon | 1 (predeterminado)2 (predeterminado) | Font y FontSizeDynamicFont y DynamicFontSize |
Active la estrategia de fuente de la siguiente manera:
*-- cINTLFont is the Font strategy class.
_SCREEN.oINTL.SetStrategy( "Font", "cINTLFont" )
Otra forma más críptica de cargar la estrategia de fuentes es:
*-- Set configuration bit 2^1 "ON"
_SCREEN.oINTL.SetConfig(BITSET(oINTL.GetConfig(),1 ))
Entonces hay dos maneras de hacerlo.
Las fuentes se pueden localizar proporcionando traducciones en strings.dbf . Las especificaciones de fuente tienen el prefijo " ((Font )) ", por ejemplo:
| cOriginal | ruso |
|---|---|
((Font))Courier New,10 | ((Font))Courier New Cyr,10 |
((Font))Arial,16 | ((Font))Arial Cyr,16 |
Configure la estrategia de fuente con su método SetConfig() .
La estrategia de fuente INTL, como todas las estrategias, está configurada bit a bit. Puede controlar el objeto de estrategia de fuente de la siguiente manera:
Ejemplo: para deshabilitar el procesamiento de fuentes para DynamicFont y DynamicFontSize , lo que mejorará ligeramente el rendimiento de la estrategia de fuentes:
*-- Set Font localization on
oINTL.SetConfig( BITSET( oINTL.GetConfig(), 1 )) && Set 2^1 "ON"
*-- Get a handle on the font strategy:
oFont = _SCREEN.oINTL.GetStrategy("Font" )
*-- We want Font and FontSize and to disable DynamicFont
*-- and DynamicFontSize
oFont.SetConfig( 1 )
Los datos pueden ser específicos de la región.
A veces son los propios datos los que es necesario localizar. INTL le permite presentar diferentes campos para diferentes configuraciones regionales.
La estrategia de datos funciona como las otras estrategias.
La siguiente tabla enumera los bits de configuración para que el objeto INTL cargue la estrategia de imagen y los enteros de configuración para configurar la estrategia de imagen.
| Clase | Bits de configuración | Localización |
|---|---|---|
| INTL | 1 (predeterminado)2481632 | Estrategia cINTLString cargadaEstrategia cINTLFont cargadaEstrategia cINTLData cargadacINTLPicture cargadacINTLCurrency cargadaEstrategia cINTLRightToLeft cargada |
| CINTLDatos | 1 (predeterminado)24816 | BoundColumnControlSourceRowSourceRecordSourceInpuMask |
Active la estrategia de datos de la siguiente manera:
*-- cINTLData is the Graphics strategy class.
_SCREEN.oINTL.SetStrategy( "Data", "cINTLData" )
Otra forma más críptica de cargar la estrategia de Datos es:
*-- Set configuration bit 2^2 "ON"
_SCREEN.oINTL.SetConfig(BITSET(oINTL.GetConfig(),2 ))
Entonces hay dos maneras de hacerlo.
Los elementos de datos se pueden localizar proporcionando traducciones en strings.dbf . Las especificaciones de datos tienen el prefijo " ((Data)) ", como por ejemplo:
| cOriginal | ruso |
|---|---|
((Data))cEngDesc | ((Data))cRussianDesc |
Configure la estrategia de datos con su método SetConfig() .
La estrategia de datos INTL, como todas las estrategias, está configurada bit a bit. Puede controlar el objeto de estrategia de imagen de la siguiente manera:
Ejemplo: localizar propiedades de ControlSource.
*-- Set Data localization on
*-- Set 2^2 "ON"
oINTL.SetConfig( BITSET( oINTL.GetConfig(), 2 ))
*-- Get a handle on the data strategy:
oData = _SCREEN.oINTL.GetStrategy("Data" )
*-- We want ControlSource (2)
*-- property localized.
oPicture.SetConfig( 2 )
Las imágenes pueden ser específicas de la localidad. Es posible que algunos de los íconos e imágenes que utilizamos todos los días no sean apropiados en otras ubicaciones. INTL proporciona una forma de cambiar las imágenes mostradas cuando cambiamos de configuración regional.
La estrategia Imagen funciona como las otras estrategias. La siguiente tabla enumera los bits de configuración para que el objeto INTL cargue la estrategia de imagen y los enteros de configuración para configurar la estrategia de imagen.
| Clase | Bits de configuración | Localización |
|---|---|---|
| INTL | 1 (predeterminado)2481632 | Estrategia cINTLString cargadaEstrategia cINTLFont cargadaEstrategia cINTLData cargadacINTLPicture cargadacINTLCurrency cargadaEstrategia cINTLRightToLeft cargada |
cINTLPicture | 1 (predeterminado)24 (predeterminado)8 | PictureDownPictureIconDragIcon |
Active la estrategia de imagen de la siguiente manera:
*-- cINTLPicture is the Graphics strategy class.
_SCREEN.oINTL.SetStrategy( "Picture", "cINTLPicture" )
Otra forma más críptica de cargar la estrategia de imagen es:
*-- Set configuration bit 2^3 "ON"
_SCREEN.oINTL.SetConfig(BITSET(oINTL.GetConfig(),3 ))
Entonces hay dos maneras de hacerlo.
Las imágenes se pueden localizar proporcionando traducciones en strings.dbf . Las especificaciones de imagen tienen el prefijo " ((Picture)) ", por ejemplo:
coriginal | crussian |
|---|---|
((Picture))Doctor.BMP | ((Picture))Doktor.BMP |
((Picture))Friend.BMP | ((Picture))Comrade.BMP |
Configure la estrategia de imagen con su método SetConfig() .
La estrategia de imagen INTL, como todas las estrategias, está configurada bit a bit. Puede controlar el objeto de estrategia de imagen de la siguiente manera:
Ejemplo: localizar las propiedades Imagen, Imagen abajo e Icono.
*-- Set Picture localization on
*-- Set 2^3 "ON"
oINTL.SetConfig( BITSET( oINTL.GetConfig(), 3 ))
*-- Get a handle on the font strategy:
oPicture = _SCREEN.oINTL.GetStrategy("Picture" )
*-- We want Picture (1), DownPicture( 2 ) and Icon (4)
*-- properties localized. 1+2+4 = 7
oPicture.SetConfig( 7 )
INTL proporciona una capacidad multidivisa sencilla pero adaptable.
INTL le permite dotar a su aplicación de una sencilla capacidad multidivisa. Esta arquitectura es flexible y, al subclasificar la clase cINTLCurrency , probablemente pueda implementar casi cualquier esquema multidivisa que necesite.
En el fondo de todo, la estrategia INTL Moneda funciona sólo en campos que tienen una propiedad de formato de "$".
Recuerde que las estrategias INTL se configuran bit a bit según la siguiente tabla.
| Clase (por defecto) | Valor | Localización |
|---|---|---|
| INTL (1) | 1 (predeterminado)2481632 | Estrategia cINTLString cargadaEstrategia cINTLFont cargadaEstrategia cINTLData cargadacINTLPicture cargadacINTLCurrency cargadaEstrategia cINTLRightToLeft cargada |
Active la estrategia de divisas de la siguiente manera:
Utilice oINTL.SetConfig() u oINTL.SetStrategy() para cargar la estrategia de moneda.
OINTL = _SCREEN.oINTL
oINTL.SetStratrgy( "Currency", "cINTLCurrency" )
Una forma alternativa (y más críptica) es utilizar el método SetConfig() de INTL para hacer que INTL invoque la estrategia de fuente de una clase determinada, de la siguiente manera:
OINTL = _SCREEN.oINTL
*-- Set bit 2^4 "ON"
oINTL.SetConfig( BITSET( oINTL.GetConfig(), 4 ))
Entonces hay dos maneras de hacerlo.
La estrategia de divisas no es como las demás. La estrategia monetaria del kit de herramientas INTL es un poco diferente de otras estrategias en tres aspectos importantes:
Las monedas son específicas de la localidad , no del idioma.
la clase cINTLCurrency no utiliza servicios de clase cINTLString , y
La clase cINTLCurrency hace que muchos campos de entrada sean de solo lectura cuando los datos están en un estado convertido.
El tipo de cambio predeterminado para todas las monedas es 1.00 .
Con la clase cINTLCurrency que se envía con INTL, usted asigna factores de conversión de moneda a diferentes monedas. Por defecto, el factor de conversión utilizado por la estrategia de divisas es 1.00 .
Si necesita conversiones de moneda que dependen del tiempo, puede subclasificar cINTLCurrency para hacer cualquier cosa que necesite, como búsquedas.
Configuremos INTL para las siguientes monedas: dólar canadiense, euro y dólar estadounidense. Supongamos que nuestros datos están basados en dólares canadienses.
oINTL.SetConversion() establece el tipo de cambio entre la configuración local original y otras.
Utilice SetLocale() para cambiar la configuración regional de la moneda. Luego localice como de costumbre.
oINTL = _SCREEN.oINTL
*-- Load the currency strategy
*-- Set 2^4 "ON"
oINTL.SetConfig( BITSET( oINTL.GetConfig(), 4 ))
*-- Define a few locales and currencies
oINTL.SetConversion( "Canada", 1 )
oINTL.SetConversion( "Euro", 1.55 )
oINTL.SetConversion( "USA", 1.33 )
*-- Lets assume we want to see it in US dollars
oINTL.SetLocale( "USA" )
*-- Localize the current form
oINTL.Localize(_SCREEN.ActiveForm )
INTL automáticamente hará que los objetos de su formulario se muestren de derecha a izquierda.
INTL le permite mostrar objetos de derecha a izquierda, lo que requieren los sistemas de escritura del Medio Oriente. Para hacer esto, INTL invierte la ubicación de los objetos dentro de los contenedores a lo largo de la línea central vertical del contenedor. INTL también modifica la propiedad de alineación de casillas de verificación y grupos de opciones.
INTL no cambia la orientación del texto del título. Para cambiar la orientación del texto del título, debe utilizar una localización de Windows en Medio Oriente.
El resultado es que las formas se invierten; si se leían de izquierda a derecha ahora se leen de derecha a izquierda y viceversa.
Recuerde que las estrategias INTL se configuran bit a bit según la siguiente tabla:
| Clase (por defecto) | Valor | Localización |
|---|---|---|
| INTL (1) | 1 (predeterminado)2481632 | Estrategia cINTLString cargadaEstrategia cINTLFont cargadaEstrategia cINTLData cargadacINTLPicture cargadacINTLCurrency cargadaEstrategia cINTLRightToLeft cargada |
Active la estrategia de divisas de la siguiente manera:
Utilice oINTL.SetConfig() u oINTL.SetStrategy() para cargar la estrategia de moneda.
OINTL = _SCREEN.oINTL
oINTL.SetStratrgy( "RightToLeft", "cINTLRightToLeft" )
An alternate (and more cryptic ) way is to use INTL's `SetConfig()` method make INTL invoke the Font strategy of a given class, as follows:
OINTL = _SCREEN.oINTL<b
*-- Set bit 2^5 "ON"
oINTL.SetConfig( BITSET( oINTL.GetConfig(), 5 ))
Entonces hay dos maneras de hacerlo.
La estrategia RightToLeft es la única estrategia que realmente reorganiza los objetos en contenedores.
La estrategia de derecha a izquierda del conjunto de herramientas de INTL es un poco diferente de otras estrategias en cuatro aspectos importantes:
cINTLRightToLeft no utiliza servicios de clase cINTLString .cINTLRightToLeft invierte la ubicación de los objetos dentro de los contenedores a lo largo del eje vertical del contenedor. Lo que estaba en la izquierda acaba en la derecha y viceversa. Además, la propiedad de alineación de las casillas de verificación y los grupos de opciones se invierte, al igual que las secuencias de páginas en marcos de páginas y columnas en cuadrículas.cINTLRightToLeft para escribir de izquierda a derecha. Configuremos INTL para un idioma de derecha a izquierda. La forma más limpia de hacerlo es con una subclase del método INTL::SetLanguage() . Alternativamente, también puedes hacerlo con el método SetLocale() . De cualquier manera, la implementación es la misma.
En este ejemplo, usamos SetLanguage() para configurar la transformación RightToLeft.
Nota: para mayor claridad, hemos omitido la configuración de la estrategia de fuente, lo que probablemente tendríamos que hacer. Consulte Cómo localizar fuentes.
DEFINE CLASS MidEastINTL AS INTL
FUNCTION SetLanguage( tcLanguage )
LOCAL llRetVal
LlRetVal = INTL::SetLanguage( tcLanguage )
*-- The right-to-left strategy is configured
*-- with the fifth INTL configuration bit.
IF tcLanguage = "Hebrew" OR ;
TcLanguage = "Arabic"
this.SetConfig( BITSET( this.GetConfig(), 5 ))
ELSE
this.SetConfig( BITCLEAR( this.GetConfig(), 5 ))
ENDIF
RETURN llRetVal
ENDDEFINE
¿Necesita un comportamiento diferente? Considere una subclase. Puede encontrar situaciones en las que necesite hacer las cosas de manera diferente. En lugar de cambiar el código fuente de INTL (lo que creará dificultades al fusionar versiones futuras), considere subclasificar una estrategia existente para el comportamiento deseado.
En el siguiente diagrama, hemos creado dos subclases, una de la clase cINTLString y otra de la clase cINTLCurrency . La jerarquía de clases ahora se ve así:
Nuevas clases agregadas a la jerarquía de clases INTL.
Para usar sus subclases en lugar de las que se incluyen con INTL, llame al método setstrategy() de la siguiente manera:
*-- Assuming _SCREEN.oINTL is already Instantiated
_SCREEN.oINTL.SetStrategy("String", "cMyString" )
_SCREEN.oINTL.SetStrategy("Currency", "cMyCurrency" )
Puede crear sus propias estrategias y utilizar INTL para invocarlas automáticamente. Haga de su nueva estrategia una subclase de la clase cINTLStrategy (para que tenga las propiedades y métodos que INTL espera) y luego ejecútela.
Como en el caso de subclasificar una estrategia existente, utilice el método SetStrategy() para cargar su estrategia en INTL.
Tres maneras:
Puede hacer que INTL ignore un objeto o un objeto contenedor colocando la cadena "INTL Ignore" en la propiedad de comentario del objeto. Esta cadena no distingue entre mayúsculas y minúsculas.
Si puede, asigne a la clase de su objeto una propiedad INTL y asígnele .F lógico.
Si puede, asigne a la clase de su objeto una propiedad INTL y asígnele un valor numérico menor que 0.
Si tiene necesidades especiales para un objeto en particular, asigne a la clase de su objeto una propiedad INTL y asigne un valor numérico a la propiedad en la definición de clase o a la instancia de este objeto. Este valor numérico es el valor que asignaría al método SetConfig() de INTL para configurar INTL para este objeto en particular.
Si desea sustituir sus propias estrategias en instancias de estrategias posteriores, utilice el método SetStrategyClass() para asignar una nueva clase de estrategia a un alias de estrategia existente.
*-- Permanently install cMyStringStrategy for the string strategy.
_SCREEN.oINTL.SetStrategyClass( "String", "cMyStringStrategy" )
strings.dbf INTL se entrega con clases de iterador y visitante diseñadas para repetir estructuras VFP y, entre otras cosas, cargar todos los elementos de la interfaz de cadena en strings.dbf .
Consulte Actualización strings.dbf basándose en un .PJX.
Las estructuras de informes VFP no se generan ni compilan; están vinculadas a su aplicación "tal cual". Por lo tanto, los informes deben transformarse antes de crear el .APP o .EXE.
Localizar informes es algo que realmente sólo necesita hacer una vez. El proceso de transformación convierte las etiquetas de sus informes en expresiones de informe que contienen una llamada a la función I() de INTL. Por ejemplo, la etiqueta del informe "Name:" se convierte en la expresión I("Name:") .
Consulte Transformación de informes basados en un .PJX.
Si planeas ser realmente sofisticado intercambiando idiomas sobre la marcha, será útil saber lo siguiente:
Después de que INTL localiza un formulario, agrega al formulario un objeto llamado oINTL de la clase cINTLMemento configurado como se configuró INTL. Este recuerdo es un objeto liviano que permite que varios objetos INTL coexistan pacíficamente porque pueden saber que una Forma en particular se está mostrando, en este momento, en, digamos, japonés.
Cuando un objeto INTL encuentra un formulario que contiene un miembro llamado oINTL, adoptará la configuración del miembro determinada por su valor GETCONFIG() .
Si necesita un comportamiento alternativo, por ejemplo, si necesita que el segundo objeto INTL anule completamente un recuerdo del primero, primero localice el formulario al original (lo que elimina el miembro Form.oINTL) y luego localícelo a la nueva configuración regional usando el segundo objeto INTL.
MsgSvc() Tras la primera invocación, MsgSvc() crea un objeto llamado _SCREEN.oMsgSvc que posteriormente gestionará la mensajería. Si existe un objeto llamado _SCREEN.oINTL , el objeto _SCREEN.MsgSvc obedecerá su configuración de idioma y utilizará sus servicios.
Para la localización en tiempo de ejecución, debe distribuir los siguientes archivos:
| Archivo | Notas |
|---|---|
i.prg | Para obtener el mejor rendimiento, coloque esta función en su primer archivo SET PROCEDURE . |
intl.prg | Para obtener el mejor rendimiento, SET PROCEDURE TO INTL Additive . |
msgsvc.dbf | |
msgsvc.fpt | |
msgsvc.cdx | Si usa MsgSvc() necesitará distribuir estos archivos. |
msgsvc.prg | La biblioteca de servicios de mensajes. |
nohot.prg | Para obtener el mejor rendimiento, coloque esta función en su primer archivo SET PROCEDURE . |
strings.dbf | |
strings.fpt | |
strings.cdx | También deberás distribuirlos. |
Para las tablas y archivos STRINGS y MSGSVC, si los incluye en su APLICACIÓN o EXE, por supuesto, serán de solo lectura.
Aquí hay una descripción de los archivos utilizados por INTL. Para calcular dónde se pueden colocar mejor en relación con su proyecto, consulte Cómo colocar correctamente sus archivos INTL.
| Archivo | Descripción |
|---|---|
addendum.txt | Noticias de última hora que pueden o no estar incluidas en la documentación o en el archivo de ayuda. |
genmenux.zip | Un archivo del último programa GENMENUX disponible de Andrew Ross MacNeill. |
i.prg | Una función independiente que sirve como acceso directo al método _SCREEN.oINTL.I() . |
intl.prg | El código central para las clases y utilidades del kit de herramientas INTL. |
intltool.prg | Utilidades del desarrollador para realizar operaciones por lotes en archivos de proyecto y otras estructuras VFP. No distribuya este archivo con sus aplicaciones. |
msgsvc.dbfmsgsvc.fptmsgsvc.cdx | Tablas y archivos auxiliares que contienen mensajes para diálogos, ventanas de espera, barras de termómetro y bloques de texto. |
msgsvc.prg | La biblioteca de servicios de mensajes. |
nohot.prg | nohot() elimina los caracteres de las teclas de acceso rápido de las expresiones de solicitud de FoxPro. Es una función de una línea que debes cortar y pegar como procedimiento en algún lugar de la pila de invocación de tu aplicación. |
strings.dbfstrings.fptstrings.cdx | Tabla y archivos de respaldo que contienen frases traducidas. |
La jerarquía de clases INTL se basa en la clase cINTLAbstract . cINTLAbstract sirve para definir la interfaz para toda la jerarquía. Siempre que ha sido posible, se ha evitado agregar propiedades, eventos y métodos no autorizados a las subclases.
La siguiente figura muestra un diagrama OMT de la jerarquía de clases INTL.
La jerarquía de clases INTL.
En circunstancias normales, los únicos objetos que probablemente utilizarás son los de clase INTL .
La clase cINTLMemento se puede utilizar como token.
cINTLMemento es un token de configuración que los objetos INTL pueden usar para almacenar detalles de una localización específica. cINTLMemento incluye métodos de acceso a propiedades protegidas.
INTL es la interfaz pública y los métodos de plantilla para el proceso de localización.
cINTLStrategy es la clase principal de varios motores de localización.
cINTLString , cINTLCurrency , cINTLFont , cINTLMeasures , cINTLPicture y cINTLData son clases de implementaciones estratégicas específicas.
INTL 
La clase INTL proporciona servicios para localizar objetos y otros elementos en su aplicación.
INTL INTL::cCurrencyStrategyINTL le permite localizar monedas.
Una cadena que especifica el nombre de la clase de estrategia monetaria.
| Por defecto | "cINTLCurrency" |
| Observaciones | Puede subclasificar cINTLCurrency para adaptarlo a sus necesidades particulares. Luego puede utilizar el método SetStrategy("Currency",cYourCurrencyClass) para establecer esta propiedad de estrategia monetaria en algo distinto al valor predeterminado. |
| Ver también | cINTLMemento::GetStrategy() |
INTL::cDataStrategyINTL permite diferentes fuentes de datos para diferentes regiones. Una cadena que especifica el nombre de la clase de estrategia de datos.
| Por defecto | "cINTLData" |
| Observaciones | Puede subclasificar cINTLData para adaptarlo a sus necesidades particulares. Puede utilizar el método SetStrategy("Data", cYourDataClass) para establecer esta propiedad de estrategia de datos en algo distinto al valor predeterminado. |
| Ver también | cINTLMemento::GetStrategy() |
INTL::cFontStrategyINTL permite sustituir las fuentes adecuadas.
Una cadena que especifica el nombre de la clase de estrategia de fuente.
| Por defecto | "cINTLFont" |
| Observaciones | Puede subclasificar cINTLFont para adaptarlo a sus necesidades particulares. Puede utilizar SetStrategy("Font", cYourFontClass) para establecer la propiedad de estrategia de fuente en algo distinto al valor predeterminado. |
| Ver también | cINTLMemento::GetStrategy() |
INTL::cPictureStrategyINTL puede localizar fotografías, iconos e imágenes.
Una cadena que especifica el nombre de la clase de estrategia de imagen.
| Por defecto | "cINTLPicture" |
| Observaciones | Puede subclasificar cINTLPicture para adaptarlo a sus necesidades particulares. Puede utilizar ::SetStrategy("Picture", cYourPictureClass ) para establecer la propiedad de estrategia de imagen en algo distinto al valor predeterminado. |
| Ver también | cINTLMemento::GetStrategy() |
INTL::cStringStrategyINTL localiza palabras y frases.
Una cadena que especifica el nombre de la clase de estrategia de cadena. La clase de estrategia de cadena es responsable de localizar cadenas y frases en la aplicación y también sirve como depósito de funciones para otras clases de estrategia.
| Por defecto | "cINTLSting" |
| Observaciones | Puede subclasificar cINTLString para adaptarlo a sus necesidades particulares. Puede utilizar SetStrategy("String", cYourStringClass) para establecer la propiedad. |
| Ver también | cINTLMemento::GetStrategy() |
La clase de estrategia cINTLString es, con diferencia, la más útil y proporciona servicios a otras estrategias. | Nota: muchas estrategias utilizan servicios basados en cadenas proporcionados por la clase de estrategia de cadena activa. Para reducir la cohesión con una clase cStringStrategy particular, muchos métodos de cadena que normalmente pertenecerían a la clase cStringStrategy se encuentran en la clase cINTLStrategy , la clase de estrategia principal. Por tanto, todas las estrategias tienen algunas capacidades inherentes de localización de cadenas. |
INTL INTL::Execute()Localiza un número, una cadena, un objeto o una matriz de objetos. En el caso de objetos y conjuntos de objetos, la función de ejecución pasa cada objeto por turno a todas las estrategias de localización activas.
| Sintaxis | oINTL.Execute( @PassedObject ) |
| Devolver | Nada |
| Argumentos | PassedObject : puede ser de tipo numérico, cadena u objeto. También puede ser una serie de referencias a objetos. |
| Ver también | INTL::ObjArray() |
Ejemplo
DIMENSION laScratchArray[1]
SET PROC TO INTL
oINTL = CREATEOBJECT("INTL" )
oXX = CREATEOBJECT("Form" )
*-- Load the array with object references
oINTL.ObjArray( oXX, @laScratchArray )
oINTL.Execute( @laScratchArray )
INTL::GetAlias()| Las estrategias pueden requerir archivos de recursos, a los que se hace referencia mediante alias.
Devuelve el alias de la tabla de recursos asociada con la estrategia de localización predeterminada. Normalmente, el objeto de estrategia predeterminado es de clase cINTLString .
| Sintaxis | oINTL.GetAlias() |
| Devolver | El valor de carácter del alias de la tabla de estrategia de cadena. |
| Argumentos | Ninguno. |
| Observaciones | El método GetAlias() es un método enlazable , lo que significa que si un objeto de clase INTL tiene un objeto de enlace adjunto, entonces GetAlias() difiere al método del objeto de enlace. Dado que, de forma predeterminada, los objetos de la clase INTL están enlazados con un objeto de la clase cINTLStringStrategy , invocar oINTL.GetAlias() es el equivalente a invocar oINTL.oStringStrategy.getAlias() . |
Ejemplo
_SCREEN.AddObject( "oINTL", "INTL" )
*-- The following two are equivalent
_SCREEN.oINTL.oStringStrategy.GetAlias()
_SCREEN.oINTL.GetAlias() |
INTL::GetTable()Devuelve el nombre de la tabla de recursos asociada.
