intl
1.0.0
INTL ne fait qu'une bouchée de la création de logiciels multilingues dans Visual FoxPro (VFP). Il vous donne la possibilité de créer des applications Visual FoxPro multilingues tout en minimisant les tracas liés à la création de logiciels multiversions.
Ce document sert à décrire les éléments suivants :
strings.dbfMsgSvc()INTLcINTLAbstractcINTLCurrencycINTLDatacINTLFontcINTLMementocINTLPicturecINTLRightToLeftcINTLStrategycINTLStringconfig.fpw Instructions de menuMsgSvc()MsgSvc()strings.dbf Basé sur un .PJXstrings.dbf Basé sur un .SCXstrings.dbf Basé sur un .VCXstrings.dbf Basé sur un .MNXstrings.dbf Basé sur un .FRXINTLVisitorTout d’abord, placez les fichiers INTL dans un nouveau répertoire propre.
Alors,
Déployer des fichiers : placez manuellement les fichiers par rapport à votre projet comme décrit dans Comment placer correctement vos fichiers INTL.
Modifiez le fichier config.fpw : Pour les menus, ajoutez les deux lignes au fichier config.fpw comme expliqué dans Comment localiser les menus.
Amorcez la définition de votre classe Form : pour l'instant, probablement pour toujours, invoquez INTL dans les formulaires avec une Form::Init() qui appelle l'objet INTL. Consultez Comment obtenir la localisation automatique des formulaires.
Si vous avez besoin d'une localisation, instanciez un objet INTL : Désormais, lorsque la localisation est requise, créez et configurez un objet INTL comme décrit dans Comment instancier un objet INTL.
Il est important que VFP trouve les fichiers INTL selon ses besoins. Voici où placer vos fichiers INTL afin qu'ils soient disponibles dans votre environnement de développement :
Déployez vos fichiers comme suit :
genmenux.prgintl.prgSET PATH .strings.dbf strings.fpt strings.cdxSET PATH .msgsvc.dbf msgsvc.fpt msgsvc.cdxSET PATH . Créez un membre nommé _SCREEN.oINTL pour contenir l'instance INTL.
Pour utiliser INTL, votre application doit instancier un objet INTL. Il existe de nombreuses façons de procéder, la meilleure étant de l'ajouter à _SCREEN , comme ceci :
*-- Anywhere, anytime:
*-- Instantiate INTL in _SCREEN
SET PROCEDURE TO INTL ADDITIVE
SCREEN.AddObject( "oINTL", "INTL" )
Localisez les formulaires en transmettant leurs références d'objet à la méthode Localize() d'un objet INTL.
Les formulaires (et tout autre conteneur) sont localisés en passant sa référence à la méthode 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
....ou vous pouvez localiser le formulaire à la volée.
_SCREEN.oINTL.Localize( MyForm )
Placez un appel à oINTL dans votre hiérarchie Form.Init() .
Pour que vos formulaires se localisent automatiquement, appelez la méthode oINTL.Localize() dans la hiérarchie de vos classes de formulaire. Pour ce faire, placez le code suivant dans la méthode Init() de la définition de votre classe de formulaire. |
*-- Don't forget to call the ParentClass!
DODEFAULT()
IF TYPE("_SCREEN.oINTL" ) == "O"
_SCREEN.oINTL.Localize( This )
ENDIF
Un pilote GENMENUX est utilisé pour localiser les menus. Pour activer GENMENUX et son driver INTL.PRG, mettez les lignes suivantes dans votre config.fpw :
Ajoutez ces lignes à config.fpw .
*-- Configuring for INTL menus.
_GENMENU = GENMENUX.PRG
_MNXDRV2 = INTL.PRG
*-- End of configuration for INTL menus.
Certaines de ces modifications nécessitent un redémarrage de VFP. Pour éviter de redémarrer FoxPro à ce stade, exécutez la commande suivante dans la fenêtre de commande :
_GENMENU = HOME()+”GENMENUX.PRG”
C'est tout ce que vous devez modifier dans votre environnement de développement pour localiser les menus. Désormais, générez les menus comme d'habitude.
GENMENUX est très cool. Vérifiez-le.
Remarque : GENMENUX ne remplace pas le générateur de menu natif de VFP. Puisque GENMENUX appelle GENMENU.PRG, votre code est généré par VFP comme d'habitude. La boîte à outils INTL utilise GENMENUX comme pré-processeur. GENMENUX est un programme riche. Veuillez consulter GENMENUX pour plus d'informations sur ses capacités.
La structure de strings.dbf détermine les langues que vous prenez en charge.
Utilisez la méthode SetLanguage() pour changer la langue d'INTL.
INTL est livré avec une table nommée strings.dbf qui contient une variété de champs, dont l'un est cOriginal , et peut contenir d'autres champs pour différentes langues, par exemple cFrench , cGerman , cSpanish , etc.
Les langues prises en charge sont déterminées par la structure de la table strings.dbf . Pour ajouter une nouvelle langue, modifiez la structure de strings.dbf .
Pour modifier la langue de localisation actuelle, utilisez la méthode SetLanguage() . Disons que nous voulons qu'un formulaire soit en français. Définissez d’abord la langue, puis localisez le formulaire :
_SCREEN.oINTL.SetLanguage( "French" )
_SCREEN.oINTL.Localize( _SCREEN.ActiveForm )
Rien de mieux que de changer la langue d'affichage à la volée.
Pour échanger des langues à la volée, ce qui est toujours un succès dans une démo (faites-le même si ce n'est pas obligatoire — c'est si simple), créez un mécanisme dans votre application pour configurer l'objet INTL avec INTL.SetLanguage() , comme suit.
_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!
Pour modifier la personnalité de votre application en fonction des paramètres régionaux, je vous suggère de sous-classer INTL pour qu'elle fonctionne selon vos besoins. Sous-classer INTL pour vos propres besoins est un excellent moyen de répondre aux demandes locales avec un minimum de code et de tracas.
Voici un exemple de sous-classe INTL qui fonctionne pour moi dans une variété de paramètres régionaux. Nous sous-classons la classe INTL pour modifier simultanément tous les paramètres spécifiques aux paramètres régionaux.
Prenez note de la stratégie RightToLeft (classe cINTLRightToLeft ), qui est utile pour les systèmes d'écriture du Moyen-Orient.
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 conçu pour être mis en œuvre rapidement.
Voici ce que vous devez faire pour localiser votre application ce matin pour une démo multilingue cet après-midi. Si vous avez utilisé correctement les outils de conception de VFP, c'est un travail rapide. Sinon, la conception prendra un peu plus de temps.
Les étapes de base sont :
Installez INTL et amorcez la méthode Init() de vos classes de base de formulaire. Suivez les étapes de la section intitulée Installation d'INTL. Assurez-vous de revoir toutes les étapes. Les étapes intitulées Comment instancier un objet INTL, Comment obtenir une localisation automatique de formulaire et Comment localiser des menus sont particulièrement importantes.
Modifiez la structure de strings.dbf et ajoutez un champ pour chaque langue dont vous avez besoin.
strings.dbf fournie avec INTL et placez-la dans le répertoire racine de votre projet.ZAP la table strings.dbf que vous avez placée à la racine de votre projet.MODIFY STRUCTURE de strings.dbf et ajoutez une nouvelle colonne nommée cSwahili d'une longueur de 120. Notez que le "c" en cSwahili est obligatoire. Faites en sorte que votre application crée un objet INTL. Au début de votre application, instanciez un objet INTL comme décrit dans Comment instancier un objet INTL. Afficher dans une langue différente consiste désormais à utiliser sa méthode SetLanguage() .
Faites un « Tout construire ». Ouvrez votre projet, sélectionnez « Construire » et créez une application ou un exe, en veillant à sélectionner « Recompiler tous les fichiers ». Allez déjeuner.
Pour charger automatiquement strings.dbf , exécutez votre application ou utilisez l'utilitaire INTLTool. Il existe deux manières de remplir la table strings.dbf avec les chaînes d'interface de votre projet. La première façon consiste à exécuter votre programme. Au fur et à mesure que les objets sont instanciés, INTL ajoutera les chaînes (comme Caption , Tooltiptext , etc.) dans la table des chaînes. Une meilleure façon consiste à exécuter le programme de mise à jour INTLTool. Voir INTLTool.
Saisissez les traductions dans la table strings.dbf . Dans la colonne cSwahili , saisissez les traductions en swahili, complétées par les touches de raccourci et les touches de raccourci si nécessaire. Remarque : vous pouvez obtenir une traduction "rapide et simple" pour les tests et les démos internes en procédant :
`REPLACE ALL cSwahili with "**"+TRIM(cOriginal)+"**" FOR cOriginal <> "(("`
Je recommande de créer un objet INTL principal nommé _SCREEN.oINTL .
Il est possible que plusieurs objets INTL distincts coexistent ensemble. Chaque objet INTL est un amalgame d'autres objets INTL appelés hooks ou stratégies. Votre objet INTL principal est l'objet INTL principal dans votre environnement, qui, je suppose, s'appelle _SCREEN.oINTL .
Utilisez la méthode SetConfig( n ) pour configurer votre objet INTL principal.
Vous configurez INTL avec une méthode _SCREEN.oINTL.SetConfig( n ) , où n est une valeur entière au niveau du bit avec l'interprétation suivante :
| Valeur | Configuration Signification |
|---|---|
1 (par défaut)2481632 | Charger la stratégie String Charger la stratégie de police Charger la stratégie Data Charger la stratégie Image Charger la stratégie Devise Charger la stratégie RightToLeft |
Exemple : créer un objet INTL qui localise les chaînes et les polices
*-- create an INTL object
_SCREEN.AddObject("oINTL", "INTL" )
*-- Load the strings and font strategies.
_SCREEN.oINTL.SetConfig( 1 + 2 )
La langue opérationnelle et les paramètres régionaux de l'objet INTL principal sont configurés avec les méthodes SetLanguage() et SetLocale() .
Les stratégies sont configurées au niveau du bit.
Configurer des stratégies individuelles comme suit : obtenez une référence à la stratégie, puis configurez-la. Voici les significations de configuration pour chaque stratégie configurable.
| Stratégie | Valeur | Localisation |
|---|---|---|
| Données | 1 (par défaut)24816 | BoundColumnControlSourceRowSourceRecordSourceInputMask |
| Fonte | 1 (par défaut)2 (par défaut) | Font et FontSizeDynamicFont et DynamicFontSize |
| Image | 1 (par défaut)24 (par défaut)8 | PictureDownPictureIconDragIcon |
| DroiteÀGauche | 1 (par défaut) | Tous les objets inversés dans leurs conteneurs respectifs |
| Cordes | 1 (par défaut)2 (par défaut)4 (par défaut) | CaptionToolTipTextStatusBarText |
Pour maîtriser une stratégie chargée, utilisez la méthode oINTL.GetStrategy() . Ensuite, utilisez la méthode oINTL.SetConfig() du handle pour configurer la stratégie.
Exemple : créer un objet INTL qui localise les chaînes mais pas les info-bulles
Utilisez la méthode oINTL.GetStrategy() pour obtenir une référence d'objet, puis utilisez sa méthode oINTL.SetConfig() pour la configurer.
*-- 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 )
Exemple : créez un objet INTL qui localise uniquement les chaînes et les InputMasks.
*-- 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 )
Les chaînes d’interface sont généralement les premières choses qui nous viennent à l’esprit lorsque l’on pense à la traduction d’un logiciel.
INTL charge uniquement la stratégie de chaîne par défaut.
Le tableau suivant répertorie les bits de configuration pour INTL. Ces bits de configuration décident quelle stratégie est chargée. Par défaut, seule la stratégie String est chargée, c'est-à-dire que les chaînes sont automatiquement localisées par INTL par défaut.
| Classe | Bits de configuration | Localisation |
|---|---|---|
| INTL | 1 (par défaut)4281632 | Stratégie cINTLString chargéeStratégie cINTLFont chargéeStratégie cINTLData chargéeStratégie cINTLPicture chargéecINTLCurrency stratégie chargéeStratégie cINTLRightToLeft chargée |
| Chaîne CINTL | 1 (par défaut)2 (par défaut)3 (par défaut) | CaptionToolTipTextStatusBarText |
Activez la stratégie de chaîne comme suit :
*-- cINTLString is loaded by default.
*-- So there’s usually no need to do this
_SCREEN.oINTL.SetStrategy( "String", "cINTLString" )
Une autre manière plus énigmatique de charger la stratégie String est :
-- Set configuration bit 2^0 "ON"
_SCREEN.oINTL.SetConfig( BITSET( oINTL.GetConfig(), 0 ))
Il y a donc deux façons de procéder.
Les chaînes peuvent être localisées en fournissant des traductions dans strings.dbf .
| cOriginal | cfrançais |
|---|---|
Yes | Oui |
No | Non |
Configurez la stratégie de chaînes avec sa méthode SetConfig() .
La stratégie INTL String, comme toutes les stratégies, est configurée au niveau du bit. Vous pouvez contrôler l'objet de stratégie de chaîne comme suit :
Exemple : pour désactiver le traitement des polices pour la propriété ToolTipText :
*-- Get a handle on the string strategy:
oFont = _SCREEN.oINTL.GetStrategy( "String" )
*-- We want Caption( 1 ) and StatusbarText( 4 ) only
oFont.SetConfig( 5 )
Les polices peuvent être spécifiques aux paramètres régionaux.
Les polices comme Arial, Times New Roman, MS Sans Serif peuvent ne pas convenir dans certaines langues. C’est important ; nous aurons peut-être besoin d'un moyen de changer les polices lorsque nous changeons de paramètres régionaux.
Le tableau suivant répertorie les bits de configuration pour l'objet INTL pour charger la stratégie Font et les entiers de configuration pour configurer la stratégie Font.
| Classe | Bits de configuration | Localisation |
|---|---|---|
| INTL | 1 (par défaut)2481632 | Stratégie cINTLString chargéeStratégie cINTLFont chargéeStratégie cINTLData chargéeStratégie cINTLPicture chargéecINTLCurrency stratégie chargéeStratégie cINTLRightToLeft chargée |
| CINTLFont | 1 (par défaut)2 (par défaut) | Font et FontSizeDynamicFont et DynamicFontSize |
Activez la stratégie de polices comme suit :
*-- cINTLFont is the Font strategy class.
_SCREEN.oINTL.SetStrategy( "Font", "cINTLFont" )
Une autre manière plus énigmatique de charger la stratégie Font est la suivante :
*-- Set configuration bit 2^1 "ON"
_SCREEN.oINTL.SetConfig(BITSET(oINTL.GetConfig(),1 ))
Il y a donc deux façons de procéder.
Les polices peuvent être localisées en fournissant des traductions dans strings.dbf . Les spécifications de police sont préfixées par l'identifiant « ((Font )) », par exemple :
| cOriginal | cRusse |
|---|---|
((Font))Courier New,10 | ((Font))Courier New Cyr,10 |
((Font))Arial,16 | ((Font))Arial Cyr,16 |
Configurez la stratégie de polices avec sa méthode SetConfig() .
La stratégie INTL Font, comme toutes les stratégies, est configurée au niveau du bit. Vous pouvez contrôler l'objet de stratégie de police comme suit :
Exemple : pour désactiver le traitement des polices pour DynamicFont et DynamicFontSize , ce qui améliorera légèrement les performances de la stratégie de police :
*-- 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 )
Les données peuvent être spécifiques aux paramètres régionaux.
Parfois, ce sont les données elles-mêmes qui doivent être localisées. INTL vous permet de présenter différents champs pour différents paramètres régionaux.
La stratégie Data fonctionne comme les autres stratégies.
Le tableau suivant répertorie les bits de configuration pour l'objet INTL pour charger la stratégie Image et les entiers de configuration pour configurer la stratégie Image.
| Classe | Bits de configuration | Localisation |
|---|---|---|
| INTL | 1 (par défaut)2481632 | Stratégie cINTLString chargéeStratégie cINTLFont chargéeStratégie cINTLData chargéeStratégie cINTLPicture chargéecINTLCurrency stratégie chargéeStratégie cINTLRightToLeft chargée |
| CINTLDonnées | 1 (par défaut)24816 | BoundColumnControlSourceRowSourceRecordSourceInpuMask |
Activez la stratégie de données comme suit :
*-- cINTLData is the Graphics strategy class.
_SCREEN.oINTL.SetStrategy( "Data", "cINTLData" )
Une autre façon plus énigmatique de charger la stratégie de données est :
*-- Set configuration bit 2^2 "ON"
_SCREEN.oINTL.SetConfig(BITSET(oINTL.GetConfig(),2 ))
Il y a donc deux façons de procéder.
Les éléments de données peuvent être localisés en fournissant des traductions dans strings.dbf . Les spécifications des données sont préfixées par l'identifiant « ((Data)) », comme par exemple :
| cOriginal | cRrusse |
|---|---|
((Data))cEngDesc | ((Data))cRussianDesc |
Configurez la stratégie de données avec sa méthode SetConfig() .
La stratégie de données INTL, comme toutes les stratégies, est configurée au niveau du bit. Vous pouvez contrôler l'objet de stratégie d'image comme suit :
Exemple : Localisez les propriétés 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 )
Les images peuvent être spécifiques aux paramètres régionaux. Certaines icônes et images que nous utilisons quotidiennement peuvent ne pas convenir à d’autres pays. INTL fournit un moyen de modifier les images affichées lorsque nous changeons de paramètres régionaux.
La stratégie Picture fonctionne comme les autres stratégies. Le tableau suivant répertorie les bits de configuration pour l'objet INTL pour charger la stratégie Image et les entiers de configuration pour configurer la stratégie Image.
| Classe | Bits de configuration | Localisation |
|---|---|---|
| INTL | 1 (par défaut)2481632 | Stratégie cINTLString chargéeStratégie cINTLFont chargéeStratégie cINTLData chargéeStratégie cINTLPicture chargéecINTLCurrency stratégie chargéeStratégie cINTLRightToLeft chargée |
cINTLPicture | 1 (par défaut)24 (par défaut)8 | PictureDownPictureIconDragIcon |
Activez la stratégie d'image comme suit :
*-- cINTLPicture is the Graphics strategy class.
_SCREEN.oINTL.SetStrategy( "Picture", "cINTLPicture" )
Une autre façon plus énigmatique de charger la stratégie Picture est la suivante :
*-- Set configuration bit 2^3 "ON"
_SCREEN.oINTL.SetConfig(BITSET(oINTL.GetConfig(),3 ))
Il y a donc deux façons de procéder.
Les images peuvent être localisées en fournissant des traductions dans strings.dbf . Les spécifications d'image sont préfixées par l'identifiant « ((Picture)) », par exemple :
coriginal | crussian |
|---|---|
((Picture))Doctor.BMP | ((Picture))Doktor.BMP |
((Picture))Friend.BMP | ((Picture))Comrade.BMP |
Configurez la stratégie d'image avec sa méthode SetConfig() .
La stratégie d'image INTL, comme toutes les stratégies, est configurée au niveau du bit. Vous pouvez contrôler l'objet de stratégie d'image comme suit :
Exemple : Localisez les propriétés Picture, DownPicture et Icon.
*-- 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 offre une fonctionnalité multidevises simple mais adaptable.
INTL vous permet de doter votre application d'une simple fonctionnalité multidevises. Cette architecture est flexible et en sous-classant la classe cINTLCurrency , vous pouvez probablement implémenter presque tous les schémas multidevises dont vous avez besoin.
Au cœur de tout cela, la stratégie INTL Currency ne fonctionne que sur les champs ayant une propriété de format « $ ».
Rappelez-vous que les stratégies INTL sont configurées au niveau du bit selon le tableau suivant.
| Classe (par défaut) | Valeur | Localisation |
|---|---|---|
| INTERNATIONAL (1) | 1 (par défaut)2481632 | Stratégie cINTLString chargéeStratégie cINTLFont chargéeStratégie cINTLData chargéeStratégie cINTLPicture chargéecINTLCurrency stratégie chargéeStratégie cINTLRightToLeft chargée |
Activez la stratégie de change comme suit :
Utilisez oINTL.SetConfig() ou oINTL.SetStrategy() pour charger la stratégie de devise.
OINTL = _SCREEN.oINTL
oINTL.SetStratrgy( "Currency", "cINTLCurrency" )
Une autre méthode (et plus énigmatique) consiste à utiliser la méthode SetConfig() d'INTL pour que INTL invoque la stratégie Font d'une classe donnée, comme suit :
OINTL = _SCREEN.oINTL
*-- Set bit 2^4 "ON"
oINTL.SetConfig( BITSET( oINTL.GetConfig(), 4 ))
Il y a donc deux façons de procéder.
La stratégie Devises n’est pas comme les autres. La stratégie de change de la boîte à outils INTL est un peu différente des autres stratégies sur trois points importants :
les devises sont spécifiques aux paramètres régionaux et non à la langue.
la classe cINTLCurrency n'utilise pas les services de classe cINTLString , et
La classe cINTLCurrency rend de nombreux champs de saisie en lecture seule lorsque les données sont dans un état converti.
Le taux de change par défaut pour toutes les devises est 1.00 .
Avec la classe cINTLCurrency fournie avec INTL, vous attribuez des facteurs de conversion de devises à différentes devises. Par défaut, le facteur de conversion utilisé par la stratégie Devise est 1.00 .
Si vous avez besoin de conversions de devises en fonction du temps, vous pouvez sous-classer cINTLCurrency pour effectuer tout ce dont vous avez besoin, comme des recherches.
Configurons INTL pour les devises suivantes : dollar canadien, euro et dollar américain. Supposons que nos données soient basées en dollars canadiens.
oINTL.SetConversion() définit le taux de change entre l'original et les autres paramètres régionaux.
Utilisez SetLocale() pour modifier les paramètres régionaux de la devise. Localisez ensuite comme d'habitude.
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 affichera automatiquement vos objets de formulaire de droite à gauche.
INTL vous permet d'afficher les objets de droite à gauche, ce qui est requis par les systèmes d'écriture du Moyen-Orient. Pour ce faire, INTL inverse l'emplacement des objets dans les conteneurs le long de la ligne médiane verticale du conteneur. INTL modifie également la propriété d'alignement des cases à cocher et des groupes d'options.
INTL ne modifie pas l'orientation du texte de la légende. Pour modifier l'orientation du texte de la légende, vous devez utiliser une localisation de Windows au Moyen-Orient.
Le résultat est que les formes sont inversées ; s'ils étaient lus de gauche à droite, ils se lisaient désormais de droite à gauche et vice versa.
Rappelez-vous que les stratégies INTL sont configurées au niveau du bit selon le tableau suivant :
| Classe (par défaut) | Valeur | Localisation |
|---|---|---|
| INTERNATIONAL (1) | 1 (par défaut)2481632 | Stratégie cINTLString chargéeStratégie cINTLFont chargéeStratégie cINTLData chargéeStratégie cINTLPicture chargéecINTLCurrency stratégie chargéeStratégie cINTLRightToLeft chargée |
Activez la stratégie de change comme suit :
Utilisez oINTL.SetConfig() ou oINTL.SetStrategy() pour charger la stratégie de devise.
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 ))
Il y a donc deux façons de procéder.
La stratégie RightToLeft est la seule stratégie qui réorganise réellement les objets dans des conteneurs.
La stratégie de droite à gauche de la boîte à outils INTL est un peu différente des autres stratégies sur quatre points importants :
cINTLRightToLeft n'utilise pas les services de classe cINTLString .cINTLRightToLeft inverse l'emplacement des objets dans les conteneurs le long de l'axe vertical du conteneur. Ce qui était à gauche finit à droite, et vice versa. De plus, la propriété d'alignement des cases à cocher et des groupes d'options est inversée, tout comme les séquences de pages dans les cadres de page et de colonnes dans les grilles.cINTLRightToLeft pour écrire de gauche à droite. Configurons INTL pour une langue de droite à gauche. La façon la plus simple de procéder consiste à utiliser une sous-classe de la méthode INTL::SetLanguage() . Alternativement, vous pouvez également le faire avec la méthode SetLocale() . Quoi qu’il en soit, la mise en œuvre est la même.
Dans cet exemple, nous utilisons SetLanguage() pour configurer la transformation RightToLeft.
Remarque : pour plus de clarté, nous avons omis de configurer la stratégie de police, ce que nous aurions probablement besoin de faire. Voir Comment localiser les polices.
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
Besoin d'un comportement différent ? Considérons une sous-classe. Vous pourriez rencontrer des situations où vous devrez faire les choses différemment. Au lieu de modifier le code source INTL (ce qui créera des difficultés lors de la fusion des versions futures), envisagez de sous-classer une stratégie existante pour le comportement souhaité.
Dans le diagramme ci-dessous, nous avons créé deux sous-classes, une de la classe cINTLString et une de la classe cINTLCurrency . La hiérarchie des classes ressemble maintenant à ceci :
Nouvelles classes ajoutées à la hiérarchie des classes INTL.
Pour utiliser vos sous-classes au lieu de celles fournies avec INTL, appelez la méthode setstrategy() comme suit :
*-- Assuming _SCREEN.oINTL is already Instantiated
_SCREEN.oINTL.SetStrategy("String", "cMyString" )
_SCREEN.oINTL.SetStrategy("Currency", "cMyCurrency" )
Vous pouvez créer vos propres stratégies et utiliser INTL pour les invoquer automatiquement. Faites de votre nouvelle stratégie une sous-classe de la classe cINTLStrategy (vous aurez ainsi les propriétés et méthodes attendues par INTL), puis exécutez-la !
Comme dans le cas du sous-classement d'une stratégie existante, utilisez la méthode SetStrategy() pour charger votre stratégie dans INTL.
Trois manières :
Vous pouvez faire en sorte que INTL ignore un objet ou un objet conteneur en plaçant la chaîne "INTL Ignore" dans la propriété de commentaire de l'objet. Cette chaîne n'est pas sensible à la casse.
Si vous le pouvez, attribuez à la classe de votre objet une propriété INTL et attribuez-lui un .F logique.
Si vous le pouvez, attribuez à la classe de votre objet une propriété INTL et attribuez-lui une valeur numérique inférieure à 0.
Si vous avez des besoins particuliers pour un objet particulier, attribuez à la classe de votre objet une propriété INTL et attribuez une valeur numérique à la propriété dans la définition de classe ou à l'instance de cet objet. Cette valeur numérique est la valeur que vous attribueriez à la méthode SetConfig() d'INTL pour configurer INTL pour cet objet particulier.
Si vous souhaitez remplacer vos propres stratégies dans les instanciations de stratégie ultérieures, utilisez la méthode SetStrategyClass() pour attribuer une nouvelle classe de stratégie à un alias de stratégie existant.
*-- Permanently install cMyStringStrategy for the string strategy.
_SCREEN.oINTL.SetStrategyClass( "String", "cMyStringStrategy" )
strings.dbf INTL est livré avec des classes d'itérateur et de visiteur conçues pour répéter les structures VFP et, entre autres choses, charger tous les éléments d'interface de chaîne dans le strings.dbf .
Voir Mise à jour strings.dbf basé sur un .PJX.
Les structures de rapport VFP ne sont ni générées ni compilées : elles sont liées à votre application « telles quelles ». Les rapports doivent donc être transformés avant la création du .APP ou du .EXE.
La localisation des rapports est quelque chose que vous ne devez faire qu'une seule fois. Le processus de transformation transforme vos étiquettes de rapport en expressions de rapport contenant un appel à la fonction I() d'INTL. Par exemple, l'étiquette du rapport "Name:" devient l'expression I("Name:") .
Voir Transformation de rapports basés sur un .PJX.
Si vous envisagez de changer de langue à la volée, il vous sera utile de connaître les éléments suivants :
Une fois qu'INTL a localisé un formulaire, il ajoute au formulaire un objet nommé oINTL de la classe cINTLMemento configuré comme INTL a été configuré. Ce souvenir est un objet léger qui permet à plusieurs objets INTL de coexister pacifiquement car ils peuvent savoir qu'une forme particulière s'affiche, à ce moment, en japonais, par exemple.
Lorsqu'un objet INTL trouve un formulaire contenant un membre nommé oINTL, il adoptera la configuration du membre telle que déterminée par sa valeur GETCONFIG() .
Si vous avez besoin d'un autre comportement - par exemple si vous avez besoin que le deuxième objet INTL remplace complètement un souvenir du premier - localisez d'abord le formulaire à l'original (ce qui supprime le membre Form.oINTL), puis localisez-le dans les nouveaux paramètres régionaux à l'aide de l'option deuxième objet INTL.
MsgSvc() Lors du premier appel, MsgSvc() crée un objet nommé _SCREEN.oMsgSvc qui gérera ensuite la messagerie. Si un objet nommé _SCREEN.oINTL existe, l'objet _SCREEN.MsgSvc obéira à ses paramètres de langue et utilisera ses services.
Pour la localisation au moment de l'exécution, vous devez distribuer les fichiers suivants :
| Déposer | Remarques |
|---|---|
i.prg | Pour de meilleures performances, placez cette fonction dans votre premier fichier SET PROCEDURE . |
intl.prg | Pour de meilleures performances, SET PROCEDURE TO INTL Additive . |
msgsvc.dbf | |
msgsvc.fpt | |
msgsvc.cdx | Si vous utilisez MsgSvc() vous devrez distribuer ces fichiers. |
msgsvc.prg | La bibliothèque des services de messagerie. |
nohot.prg | Pour de meilleures performances, placez cette fonction dans votre premier fichier SET PROCEDURE . |
strings.dbf | |
strings.fpt | |
strings.cdx | Vous devrez également les distribuer. |
Pour les tables et fichiers STRINGS et MSGSVC, si vous les incluez dans votre APP ou EXE, ils seront bien sûr en lecture seule.
Voici une description des fichiers utilisés par INTL. Pour déterminer où ils peuvent être mieux placés par rapport à votre projet, consultez Comment placer correctement vos fichiers INTL.
| Déposer | Description |
|---|---|
addendum.txt | Nouvelles de dernière minute qui peuvent ou non être incluses dans la documentation ou le fichier d'aide. |
genmenux.zip | Une archive du dernier programme GENMENUX disponible par Andrew Ross MacNeill. |
i.prg | Une fonction autonome qui sert de raccourci vers la méthode _SCREEN.oINTL.I() . |
intl.prg | Le code de base des classes et des utilitaires de la boîte à outils INTL. |
intltool.prg | Utilitaires du développeur pour effectuer des opérations par lots sur les fichiers de projet et autres structures VFP. Ne distribuez pas ce fichier avec vos applications. |
msgsvc.dbfmsgsvc.fptmsgsvc.cdx | Tableau et fichiers de support contenant des messages pour les boîtes de dialogue, les fenêtres d'attente, les barres de thermomètre et les blocs de texte. |
msgsvc.prg | La bibliothèque des services de messagerie. |
nohot.prg | nohot() supprime les caractères de raccourci clavier des expressions d'invite FoxPro. Il s'agit d'une fonction d'une seule ligne que vous devez couper et coller en tant que procédure quelque part dans la pile d'appels de votre application. |
strings.dbfstrings.fptstrings.cdx | Tableau et fichiers de support contenant des phrases traduites. |
La hiérarchie des classes INTL est basée sur la classe cINTLAbstract . cINTLAbstract sert à définir l'interface pour toute la hiérarchie. Dans la mesure du possible, l'ajout de propriétés, d'événements et de méthodes malveillants aux sous-classes a été évité.
La figure ci-dessous montre un diagramme OMT de la hiérarchie des classes INTL.
La hiérarchie des classes INTL.
Dans des circonstances normales, les seuls objets que vous utiliserez probablement sont de classe INTL .
La classe cINTLMemento peut être utilisée comme jeton.
cINTLMemento est un jeton de configuration que les objets INTL peuvent utiliser pour stocker les détails d'une localisation spécifique. cINTLMemento inclut des méthodes d'accès aux propriétés protégées.
INTL est l'interface publique et les méthodes de modèle pour le processus de localisation.
cINTLStrategy est la classe parent de divers moteurs de localisation.
cINTLString , cINTLCurrency , cINTLFont , cINTLMeasures , cINTLPicture et cINTLData sont des classes d'implémentations stratégiques spécifiques.
INTL 
La classe INTL fournit des services pour localiser les objets et autres éléments de votre application.
INTL INTL::cCurrencyStrategyINTL vous permet de localiser les devises.
Une chaîne spécifiant le nom de la classe de stratégie de change.
| Défaut | "cINTLCurrency" |
| Remarques | Vous pouvez sous-classer cINTLCurrency en fonction de vos besoins particuliers. Vous pouvez ensuite utiliser la méthode SetStrategy("Currency",cYourCurrencyClass) pour définir cette propriété de stratégie monétaire sur autre chose que la valeur par défaut. |
| Voir aussi | cINTLMemento::GetStrategy() |
INTL::cDataStrategyINTL autorise différentes sources de données pour différents paramètres régionaux. Chaîne spécifiant le nom de la classe de stratégie de données.
| Défaut | "cINTLData" |
| Remarques | Vous pouvez sous-classer cINTLData en fonction de vos besoins particuliers. Vous pouvez utiliser la méthode SetStrategy("Data", cYourDataClass) pour définir cette propriété de stratégie de données sur autre chose que la valeur par défaut. |
| Voir aussi | cINTLMemento::GetStrategy() |
INTL::cFontStrategyINTL permet de remplacer les polices appropriées.
Chaîne spécifiant le nom de la classe de stratégie de police.
| Défaut | "cINTLFont" |
| Remarques | Vous pouvez sous-classer cINTLFont pour répondre à vos besoins particuliers. Vous pouvez utiliser SetStrategy("Font", cYourFontClass) pour définir la propriété de stratégie de police sur autre chose que la valeur par défaut. |
| Voir aussi | cINTLMemento::GetStrategy() |
INTL::cPictureStrategyINTL peut localiser des images, des icônes et des images.
Chaîne spécifiant le nom de la classe de stratégie d'image.
| Défaut | "cINTLPicture" |
| Remarques | Vous pouvez sous-classer cINTLPicture en fonction de vos besoins particuliers. Vous pouvez utiliser ::SetStrategy("Picture", cYourPictureClass ) pour définir la propriété de stratégie d'image sur autre chose que la valeur par défaut. |
| Voir aussi | cINTLMemento::GetStrategy() |
INTL::cStringStrategyINTL localise les mots et les expressions.
Une chaîne spécifiant le nom de la classe de stratégie de chaîne. La classe de stratégie de chaînes est responsable de la localisation des chaînes et des expressions dans l'application et sert également de référentiel de fonctions pour d'autres classes de stratégie.
| Défaut | "cINTLSting" |
| Remarques | Vous pouvez sous-classer cINTLString en fonction de vos besoins particuliers. Vous pouvez utiliser SetStrategy("String", cYourStringClass) pour définir la propriété. |
| Voir aussi | cINTLMemento::GetStrategy() |
La classe de stratégie cINTLString est de loin la plus utile et fournit des services à d'autres stratégies. | Remarque : de nombreuses stratégies utilisent des services basés sur des chaînes fournis par la classe de stratégie de chaînes active. Pour réduire la cohésion avec une classe cStringStrategy particulière, de nombreuses méthodes de chaîne qui appartiendraient normalement à la classe cStringStrategy se trouvent dans la classe cINTLStrategy , la classe de stratégie parent. Ainsi, toutes les stratégies ont des capacités inhérentes de localisation de chaînes. |
INTL INTL::Execute()Localise un nombre, une chaîne, un objet ou un tableau d'objets. Dans le cas d'objets et de tableaux d'objets, la fonction d'exécution transmet tour à tour chaque objet à toutes les stratégies de localisation actives.
| Syntaxe | oINTL.Execute( @PassedObject ) |
| Retour | Rien |
| Arguments | PassedObject : peut être de type numérique, chaîne ou objet. Il peut également s'agir d'un tableau de références d'objets. |
| Voir aussi | INTL::ObjArray() |
Exemple
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()| Les stratégies peuvent nécessiter des fichiers de ressources référencés par un alias.
Renvoie l'alias de la table de ressources associée à la stratégie de localisation par défaut. Normalement, l'objet stratégie par défaut est de classe cINTLString .
| Syntaxe | oINTL.GetAlias() |
| Retour | La valeur de caractère de l'alias de la table de stratégie de chaîne. |
| Arguments | Aucun. |
| Remarques | La méthode GetAlias() est une méthode hookable , ce qui signifie que si un objet de la classe INTL a un objet hook attaché, alors GetAlias() s'en remet à la méthode de l'objet hook. Puisque par défaut les objets de la classe INTL sont liés à un objet de la classe cINTLStringStrategy , invoquer oINTL.GetAlias() équivaut à invoquer oINTL.oStringStrategy.getAlias() . |
Exemple
_SCREEN.AddObject( "oINTL", "INTL" )
*-- The following two are equivalent
_SCREEN.oINTL.oStringStrategy.GetAlias()
_SCREEN.oINTL.GetAlias() |
INTL::GetTable()Renvoie le nom de la table de ressources associée
