intl
1.0.0
A INTL simplifica o trabalho de criação de software multilíngue em Visual FoxPro (VFP). Ele oferece a capacidade de criar aplicativos Visual FoxPro multilíngues e, ao mesmo tempo, minimizar os problemas de criação de software com várias versões.
Este documento serve para descrever o seguinte:
strings.dbf em loteMsgSvc()INTLcINTLAbstractcINTLCurrencycINTLDatacINTLFontcINTLMementocINTLPicturecINTLRightToLeftcINTLStrategycINTLStringconfig.fpwMsgSvc()MsgSvc()strings.dbf com base em um .PJXstrings.dbf com base em um .SCXstrings.dbf com base em um .VCXstrings.dbf com base em um .MNXstrings.dbf com base em um .FRXINTLVisitorPrimeiro, coloque os arquivos INTL em um novo diretório limpo.
Então,
Implantar arquivos: coloque manualmente os arquivos relativos ao seu projeto, conforme descrito em Como colocar corretamente seus arquivos INTL.
Modifique o arquivo config.fpw : Para menus, adicione as duas linhas ao arquivo config.fpw conforme explicado em Como localizar menus.
Propague sua definição de classe Form: Por enquanto, provavelmente para sempre, invoque INTL em formulários com uma instrução Form::Init() que chama o objeto INTL. Consulte Como obter localização automática de formulários.
Se precisar de localização, instancie um objeto INTL: Agora, quando a localização for necessária, crie e configure um objeto INTL conforme descrito em Como instanciar um objeto INTL.
É importante que o VFP encontre os arquivos do INTL conforme necessário. Veja onde colocar seus arquivos INTL para que fiquem disponíveis em seu ambiente de desenvolvimento:
Implante seus arquivos da seguinte maneira:
genmenux.prgintl.prgSET PATH .strings.dbf strings.fpt strings.cdxSET PATH .msgsvc.dbf msgsvc.fpt msgsvc.cdxSET PATH . Crie um membro chamado _SCREEN.oINTL para manter a instância INTL.
Para usar INTL, seu aplicativo deve instanciar um objeto INTL. Existem muitas maneiras de fazer isso, sendo a melhor adicioná-lo a _SCREEN , assim:
*-- Anywhere, anytime:
*-- Instantiate INTL in _SCREEN
SET PROCEDURE TO INTL ADDITIVE
SCREEN.AddObject( "oINTL", "INTL" )
Localize formulários passando suas referências de objeto para o método Localize() de um objeto INTL.
Os formulários (e qualquer outro container) são localizados passando sua referência para o 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
....ou você pode localizar o formulário instantaneamente.
_SCREEN.oINTL.Localize( MyForm )
Faça uma chamada para oINTL em sua hierarquia Form.Init() .
Para fazer com que seus formulários se localizem automaticamente, chame o método oINTL.Localize() na hierarquia de classes do seu formulário. Para fazer isso, coloque o código a seguir no método Init() da definição de classe do seu formulário. |
*-- Don't forget to call the ParentClass!
DODEFAULT()
IF TYPE("_SCREEN.oINTL" ) == "O"
_SCREEN.oINTL.Localize( This )
ENDIF
Um driver GENMENUX é usado para localizar menus. Para ativar o GENMENUX e seu driver INTL.PRG, coloque as seguintes linhas no seu config.fpw :
Adicione essas linhas ao config.fpw .
*-- Configuring for INTL menus.
_GENMENU = GENMENUX.PRG
_MNXDRV2 = INTL.PRG
*-- End of configuration for INTL menus.
Algumas dessas alterações exigem uma reinicialização do VFP. Para evitar reiniciar o FoxPro neste momento, emita o seguinte comando na janela de comando:
_GENMENU = HOME()+”GENMENUX.PRG”
Isso é tudo que você precisa alterar em seu ambiente de desenvolvimento para localizar menus. Doravante, gere menus normalmente.
GENMENUX é muito legal. Confira.
Nota : GENMENUX não substitui o gerador de menu nativo do VFP. Como GENMENUX chama GENMENU.PRG, seu código é gerado pelo VFP normalmente. O INTL Toolkit usa GENMENUX como pré-processador. GENMENUX é um programa rico. Consulte GENMENUX para obter mais informações sobre seus recursos.
A estrutura de strings.dbf determina quais idiomas você suporta.
Use o método SetLanguage() para alterar o idioma do INTL.
INTL vem com uma tabela chamada strings.dbf que contém uma variedade de campos, um dos quais é cOriginal , e pode conter outros campos para diferentes idiomas, por exemplo cFrench , cGerman , cSpanish , e assim por diante.
Os idiomas suportados são determinados pela estrutura da tabela strings.dbf . Para adicionar um novo idioma, altere a estrutura de strings.dbf .
Para alterar o idioma de localização atual, use o método SetLanguage() . Digamos que queremos que um formulário esteja em francês. Primeiro defina o idioma e depois localize o formulário:
_SCREEN.oINTL.SetLanguage( "French" )
_SCREEN.oINTL.Localize( _SCREEN.ActiveForm )
Nada é melhor do que trocar o idioma de exibição rapidamente.
Para trocar idiomas rapidamente, o que é sempre um sucesso em uma demonstração (faça isso mesmo que não seja obrigatório - é muito fácil), crie um mecanismo em seu aplicativo para configurar o objeto INTL com INTL.SetLanguage() , como segue.
_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 alterar a personalidade baseada na localidade do seu aplicativo, sugiro que você subclasse INTL para funcionar conforme necessário. Criar subclasses INTL para suas próprias necessidades é uma ótima maneira de atender às demandas de localidade com o mínimo de código e complicações.
Aqui está um exemplo de uma subclasse INTL que funciona para mim em vários locais. Subclassificamos a classe INTL para alterar todas as configurações específicas de localidade de uma só vez.
Observe a estratégia RightToLeft (classe cINTLRightToLeft ), que é útil para sistemas de escrita do Oriente Médio.
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 foi projetado para ser implementado rapidamente.
Aqui está o que você precisa fazer para localizar seu aplicativo esta manhã para uma demonstração multilíngue esta tarde. Se você usou as ferramentas de design do VFP corretamente, este é um trabalho rápido. Caso contrário, levará um pouco mais de tempo para ser projetado.
As etapas básicas são:
Instale o INTL e propague o método Init() das classes base do seu formulário. Siga as etapas na seção intitulada Instalando o INTL. Certifique-se de revisar todas as etapas. Especialmente importantes são as etapas intituladas Como instanciar um objeto INTL, Como obter localização automática de formulário e Como localizar menus.
Modifique a estrutura de strings.dbf e adicione um campo para cada idioma necessário.
strings.dbf que vem com o INTL e coloque-a no diretório raiz do seu projeto.ZAP a tabela strings.dbf que você colocou na raiz do seu projeto.MODIFY STRUCTURE de strings.dbf e adicione uma nova coluna chamada cSwahili com comprimento de 120. Observe que o "c" em cSwahili é obrigatório. Faça seu aplicativo criar um objeto INTL. No início do seu aplicativo, instancie um objeto INTL conforme descrito em Como instanciar um objeto INTL. Exibir em um idioma diferente agora é uma questão de usar o método SetLanguage() .
Faça um “Construir tudo”. Abra seu projeto, selecione "Build" e construa um App ou Exe, certificando-se de selecionar "Recompile All Files". Vá almoçar.
Para carregar strings.dbf automaticamente, execute seu aplicativo ou use o utilitário INTLTool. Existem duas maneiras de preencher a tabela strings.dbf com as strings da interface do seu projeto. A primeira maneira é executar seu programa. À medida que os objetos são instanciados, INTL anexará as strings (como Caption , Tooltiptext , etc.) à tabela de strings. A melhor maneira é executar o programa de atualização INTLTool. Veja INTLTool.
Insira as traduções na tabela strings.dbf . Na coluna cSwahili , digite traduções em suaíli, completas com teclas de atalho e teclas de atalho conforme necessário. Nota: você pode obter uma tradução "rápida e suja" para testes e demonstrações internas fazendo:
`REPLACE ALL cSwahili with "**"+TRIM(cOriginal)+"**" FOR cOriginal <> "(("`
Eu recomendo criar um objeto INTL principal chamado _SCREEN.oINTL .
É possível que vários objetos INTL separados coexistam. Cada objeto INTL é um amálgama de outros objetos INTL chamados ganchos ou estratégias. Seu objeto INTL principal é o objeto INTL mestre em seu ambiente, que presumo ser chamado _SCREEN.oINTL .
Use o método SetConfig( n ) para configurar seu objeto INTL principal.
Você configura INTL com um método _SCREEN.oINTL.SetConfig( n ) , onde n é um valor inteiro bit a bit com a seguinte interpretação:
| Valor | Significado da configuração |
|---|---|
1 (padrão)2481632 | Carregar a estratégia String Carregar a estratégia de fonte Carregar a estratégia de dados Carregar a estratégia de imagem Carregue a estratégia monetária Carregue a estratégia RightToLeft |
Exemplo: crie um objeto INTL que localiza strings e fontes
*-- create an INTL object
_SCREEN.AddObject("oINTL", "INTL" )
*-- Load the strings and font strategies.
_SCREEN.oINTL.SetConfig( 1 + 2 )
O idioma operacional e a localidade do objeto INTL principal são configurados com os métodos SetLanguage() e SetLocale() .
As estratégias são configuradas bit a bit.
Configure estratégias individuais da seguinte forma: obtenha uma referência para a estratégia e depois configure-a. Aqui estão os significados de configuração para cada estratégia configurável.
| Estratégia | Valor | Localização |
|---|---|---|
| Dados | 1 (padrão)24816 | BoundColumnControlSourceRowSourceRecordSourceInputMask |
| Fonte | 1 (padrão)2 (padrão) | Font e FontSizeDynamicFont e DynamicFontSize |
| Foto | 1 (padrão)24 (padrão)8 | PictureDownPictureIconDragIcon |
| Direita para esquerda | 1 (padrão) | Todos os objetos invertidos dentro de seus respectivos contêineres |
| Cordas | 1 (padrão)2 (padrão)4 (padrão) | CaptionToolTipTextStatusBarText |
Para controlar uma estratégia carregada, use o método oINTL.GetStrategy() . Depois disso, use o método oINTL.SetConfig() do identificador para configurar a estratégia.
Exemplo: crie um objeto INTL que localiza strings, mas não dicas de ferramentas
Use o método oINTL.GetStrategy() para obter uma referência de objeto e, em seguida, use seu método oINTL.SetConfig() para configurá-lo.
*-- 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 )
Exemplo: crie um objeto INTL que localize apenas strings e 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 )
Strings de interface são geralmente as primeiras coisas que vêm à mente quando pensamos em traduzir software.
INTL carrega apenas a estratégia de string por padrão.
A tabela a seguir lista os bits de configuração para INTL. Esses bits de configuração decidem qual estratégia será carregada. Por padrão, apenas a estratégia String é carregada, o que significa que as strings são localizadas automaticamente pelo INTL por padrão.
| Aula | Bits de configuração | Localização |
|---|---|---|
| INTL | 1 (padrão)4281632 | Estratégia cINTLString carregadaEstratégia cINTLFont carregadaEstratégia cINTLData carregadaEstratégia cINTLPicture carregadaEstratégia cINTLCurrency carregadaEstratégia cINTLRightToLeft carregada |
| CINTLString | 1 (padrão)2 (padrão)3 (padrão) | CaptionToolTipTextStatusBarText |
Ative a estratégia de string da seguinte forma:
*-- cINTLString is loaded by default.
*-- So there’s usually no need to do this
_SCREEN.oINTL.SetStrategy( "String", "cINTLString" )
Outra maneira mais enigmática de carregar a estratégia String é:
-- Set configuration bit 2^0 "ON"
_SCREEN.oINTL.SetConfig( BITSET( oINTL.GetConfig(), 0 ))
Portanto, existem duas maneiras de fazer isso.
Strings podem ser localizadas fornecendo traduções em strings.dbf .
| cOriginal | cFrancês |
|---|---|
Yes | Oui |
No | Non |
Configure a Estratégia String com seu método SetConfig() .
A estratégia INTL String, como todas as estratégias, é configurada bit a bit. Você pode controlar o objeto de estratégia de string da seguinte maneira:
Exemplo: para desabilitar o processamento de fontes para a propriedade ToolTipText :
*-- Get a handle on the string strategy:
oFont = _SCREEN.oINTL.GetStrategy( "String" )
*-- We want Caption( 1 ) and StatusbarText( 4 ) only
oFont.SetConfig( 5 )
As fontes podem ser específicas do local.
Fontes como Arial, Times New Roman, MS Sans Serif podem não ser adequadas em alguns idiomas. Isso é importante; podemos precisar de uma maneira de alterar as fontes quando alteramos as localidades.
A tabela a seguir lista os bits de configuração do objeto INTL para carregar a estratégia Font e os números inteiros de configuração para configurar a estratégia Font.
| Aula | Bits de configuração | Localização |
|---|---|---|
| INTL | 1 (padrão)2481632 | Estratégia cINTLString carregadaEstratégia cINTLFont carregadaEstratégia cINTLData carregadaEstratégia cINTLPicture carregadaEstratégia cINTLCurrency carregadaEstratégia cINTLRightToLeft carregada |
| Fonte CINTLF | 1 (padrão)2 (padrão) | Font e FontSizeDynamicFont e DynamicFontSize |
Ative a estratégia de fonte da seguinte forma:
*-- cINTLFont is the Font strategy class.
_SCREEN.oINTL.SetStrategy( "Font", "cINTLFont" )
Outra maneira mais enigmática de carregar a estratégia Font é:
*-- Set configuration bit 2^1 "ON"
_SCREEN.oINTL.SetConfig(BITSET(oINTL.GetConfig(),1 ))
Portanto, existem duas maneiras de fazer isso.
As fontes podem ser localizadas fornecendo traduções em strings.dbf . As especificações da fonte são prefixadas com o identificador “ ((Font )) ”, por exemplo:
| cOriginal | cRusso |
|---|---|
((Font))Courier New,10 | ((Font))Courier New Cyr,10 |
((Font))Arial,16 | ((Font))Arial Cyr,16 |
Configure a Estratégia de Fonte com seu método SetConfig() .
A estratégia INTL Font, como todas as estratégias, é configurada bit a bit. Você pode controlar o objeto de estratégia de fonte da seguinte maneira:
Exemplo: para desabilitar o processamento de fontes para DynamicFont e DynamicFontSize , o que melhorará ligeiramente o desempenho da estratégia de fontes:
*-- 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 )
Os dados podem ser específicos do local.
Às vezes, são os próprios dados que precisam ser localizados. INTL permite apresentar diferentes campos para diferentes localidades.
A estratégia de dados funciona como as outras estratégias.
A tabela a seguir lista os bits de configuração para o objeto INTL carregar a estratégia Picture e os números inteiros de configuração para configurar a estratégia Picture.
| Aula | Bits de configuração | Localização |
|---|---|---|
| INTL | 1 (padrão)2481632 | Estratégia cINTLString carregadaEstratégia cINTLFont carregadaEstratégia cINTLData carregadaEstratégia cINTLPicture carregadaEstratégia cINTLCurrency carregadaEstratégia cINTLRightToLeft carregada |
| CINTLDados | 1 (padrão)24816 | BoundColumnControlSourceRowSourceRecordSourceInpuMask |
Ative a estratégia de dados da seguinte forma:
*-- cINTLData is the Graphics strategy class.
_SCREEN.oINTL.SetStrategy( "Data", "cINTLData" )
Outra maneira mais enigmática de carregar a estratégia de dados é:
*-- Set configuration bit 2^2 "ON"
_SCREEN.oINTL.SetConfig(BITSET(oINTL.GetConfig(),2 ))
Portanto, existem duas maneiras de fazer isso.
Os elementos de dados podem ser localizados fornecendo traduções em strings.dbf . As especificações de dados são prefixadas com o identificador “ ((Data)) ”, como por exemplo:
| cOriginal | Crrusso |
|---|---|
((Data))cEngDesc | ((Data))cRussianDesc |
Configure a Estratégia de Dados com seu método SetConfig() .
A estratégia de dados INTL, como todas as estratégias, é configurada bit a bit. Você pode controlar o objeto de estratégia de imagem da seguinte maneira:
Exemplo: localizar propriedades 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 )
As imagens podem ser específicas do local. Alguns dos ícones e imagens que usamos todos os dias podem não ser apropriados em outros locais. INTL fornece uma maneira de alterar as imagens exibidas quando alteramos o local.
A estratégia Picture funciona como as outras estratégias. A tabela a seguir lista os bits de configuração para o objeto INTL carregar a estratégia Picture e os números inteiros de configuração para configurar a estratégia Picture.
| Aula | Bits de configuração | Localização |
|---|---|---|
| INTL | 1 (padrão)2481632 | Estratégia cINTLString carregadaEstratégia cINTLFont carregadaEstratégia cINTLData carregadaEstratégia cINTLPicture carregadaEstratégia cINTLCurrency carregadaEstratégia cINTLRightToLeft carregada |
cINTLPicture | 1 (padrão)24 (padrão)8 | PictureDownPictureIconDragIcon |
Ative a estratégia de imagem da seguinte forma:
*-- cINTLPicture is the Graphics strategy class.
_SCREEN.oINTL.SetStrategy( "Picture", "cINTLPicture" )
Outra maneira mais enigmática de carregar a estratégia Picture é:
*-- Set configuration bit 2^3 "ON"
_SCREEN.oINTL.SetConfig(BITSET(oINTL.GetConfig(),3 ))
Portanto, existem duas maneiras de fazer isso.
As imagens podem ser localizadas fornecendo traduções em strings.dbf . As especificações da imagem são prefixadas com o identificador “ ((Picture)) ”, por exemplo:
coriginal | crussian |
|---|---|
((Picture))Doctor.BMP | ((Picture))Doktor.BMP |
((Picture))Friend.BMP | ((Picture))Comrade.BMP |
Configure a Estratégia de Imagem com seu método SetConfig() .
A estratégia de imagem INTL, como todas as estratégias, é configurada bit a bit. Você pode controlar o objeto de estratégia de imagem da seguinte maneira:
Exemplo: Localize as propriedades Imagem, DownPicture e Ícone.
*-- 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 fornece um recurso multimoeda simples, mas adaptável.
INTL permite que você dote seu aplicativo com um recurso simples de múltiplas moedas. Essa arquitetura é flexível e, ao criar uma subclasse da classe cINTLCurrency , você provavelmente poderá implementar praticamente qualquer esquema multimoeda necessário.
No centro de tudo isso, a estratégia de moeda INTL funciona apenas em campos com propriedade de formato "$".
Lembre-se de que as estratégias INTL são configuradas bit a bit de acordo com a tabela a seguir.
| Classe (com padrão) | Valor | Localização |
|---|---|---|
| INTL (1) | 1 (padrão)2481632 | Estratégia cINTLString carregadaEstratégia cINTLFont carregadaEstratégia cINTLData carregadaEstratégia cINTLPicture carregadaEstratégia cINTLCurrency carregadaEstratégia cINTLRightToLeft carregada |
Ative a estratégia monetária da seguinte forma:
Use oINTL.SetConfig() ou oINTL.SetStrategy() para carregar a estratégia monetária.
OINTL = _SCREEN.oINTL
oINTL.SetStratrgy( "Currency", "cINTLCurrency" )
Uma maneira alternativa (e mais enigmática) é usar o método SetConfig() do INTL para fazer o INTL invocar a estratégia Font de uma determinada classe, como segue:
OINTL = _SCREEN.oINTL
*-- Set bit 2^4 "ON"
oINTL.SetConfig( BITSET( oINTL.GetConfig(), 4 ))
Portanto, existem duas maneiras de fazer isso.
A estratégia monetária não é como as outras. A estratégia monetária do kit de ferramentas INTL é um pouco diferente de outras estratégias em três aspectos importantes:
as moedas são específicas do local e não do idioma.
a classe cINTLCurrency não usa serviços da classe cINTLString e
A classe cINTLCurrency torna muitos campos de entrada somente leitura quando os dados estão em um estado convertido.
A taxa de câmbio padrão para todas as moedas é 1.00 .
Com a classe cINTLCurrency fornecida com INTL, você atribui fatores de conversão de moeda a diferentes moedas. Por padrão, o fator de conversão usado pela estratégia de moeda é 1.00 .
Se você precisar de conversões de moeda dependentes do tempo, poderá criar uma subclasse cINTLCurrency para fazer qualquer coisa necessária, como pesquisas.
Vamos configurar o INTL para as seguintes moedas: dólar canadense, euro e dólar americano. Suponha que nossos dados sejam baseados em dólares canadenses.
oINTL.SetConversion() define a taxa de câmbio entre o original e outras localidades.
Use SetLocale() para alterar a localidade da moeda. Em seguida, localize como de costume.
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 fará com que seus objetos de formulário sejam exibidos automaticamente da direita para a esquerda.
INTL permite exibir objetos da direita para a esquerda, o que é exigido pelos sistemas de escrita do Oriente Médio. Para fazer isso, o INTL inverte a localização dos objetos dentro dos contêineres ao longo da linha central vertical do contêiner. INTL também modifica a propriedade de alinhamento de caixas de seleção e grupos de opções.
INTL não altera a orientação do texto da legenda. Para alterar a orientação do texto da legenda, você deve usar uma localização do Windows para o Oriente Médio.
O resultado é que as formas são invertidas; se fossem lidos da esquerda para a direita, agora são lidos da direita para a esquerda e vice-versa.
Lembre-se de que as estratégias INTL são configuradas bit a bit de acordo com a tabela a seguir:
| Classe (com padrão) | Valor | Localização |
|---|---|---|
| INTL (1) | 1 (padrão)2481632 | Estratégia cINTLString carregadaEstratégia cINTLFont carregadaEstratégia cINTLData carregadaEstratégia cINTLPicture carregadaEstratégia cINTLCurrency carregadaEstratégia cINTLRightToLeft carregada |
Ative a estratégia monetária da seguinte forma:
Use oINTL.SetConfig() ou oINTL.SetStrategy() para carregar a estratégia monetária.
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 ))
Portanto, existem duas maneiras de fazer isso.
A estratégia RightToLeft é a única estratégia que realmente reorganiza objetos em contêineres.
A estratégia da direita para a esquerda do kit de ferramentas INTL é um pouco diferente de outras estratégias em quatro aspectos importantes:
cINTLRightToLeft não usa serviços de classe cINTLString .cINTLRightToLeft inverte a localização dos objetos dentro dos contêineres ao longo do eixo vertical do contêiner. O que estava à esquerda acaba à direita e vice-versa. Além disso, a propriedade de alinhamento de caixas de seleção e grupos de opções é invertida, assim como as sequências de páginas em quadros de página e colunas em grades.cINTLRightToLeft para escrever da esquerda para a direita. Vamos configurar o INTL para um idioma da direita para a esquerda. A maneira mais limpa de fazer isso é com uma subclasse do método INTL::SetLanguage() . Alternativamente, você também pode fazer isso com o método SetLocale() . De qualquer forma, a implementação é a mesma.
Neste exemplo, usamos SetLanguage() para configurar a transformação RightToLeft.
Observação: para maior clareza, omitimos a configuração da estratégia de fonte, o que provavelmente precisaríamos fazer. Consulte Como localizar fontes.
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
Precisa de um comportamento diferente? Considere uma subclasse. Você pode encontrar situações em que precise fazer as coisas de maneira diferente. Em vez de alterar o código-fonte INTL (o que criará dificuldades ao mesclar versões futuras), considere subclassificar uma estratégia existente para o comportamento desejado.
No diagrama abaixo, criamos duas subclasses, uma da classe cINTLString e outra da classe cINTLCurrency . A hierarquia de classes agora se parece com isto:
Novas classes adicionadas à hierarquia de classes INTL.
Para usar suas subclasses em vez daquelas fornecidas com INTL, chame o método setstrategy() da seguinte forma:
*-- Assuming _SCREEN.oINTL is already Instantiated
_SCREEN.oINTL.SetStrategy("String", "cMyString" )
_SCREEN.oINTL.SetStrategy("Currency", "cMyCurrency" )
Você pode criar suas próprias estratégias e usar o INTL para invocá-las automaticamente. Faça da sua nova estratégia uma subclasse da classe cINTLStrategy (assim você terá as propriedades e métodos que o INTL espera) e então execute-a!
Como no caso de subclassificar uma estratégia existente, use o método SetStrategy() para carregar sua estratégia no INTL.
Três maneiras:
Você pode fazer com que o INTL ignore um objeto ou objeto contêiner colocando a string "INTL Ignore" na propriedade de comentário do objeto. Esta string não faz distinção entre maiúsculas e minúsculas.
Se puder, atribua à classe do seu objeto uma propriedade INTL e atribua-lhe .F lógico.
Se puder, atribua à classe do seu objeto uma propriedade INTL e atribua a ela um valor numérico menor que 0.
Se você tiver necessidades especiais para um objeto específico, atribua à classe do seu objeto uma propriedade INTL e atribua um valor numérico à propriedade na definição da classe ou à instância deste objeto. Este valor numérico é o valor que você atribuiria ao método SetConfig() do INTL para configurar o INTL para este objeto específico.
Se desejar substituir suas próprias estratégias em instanciações de estratégia subsequentes, use o método SetStrategyClass() para atribuir uma nova classe de estratégia a um alias de estratégia existente.
*-- Permanently install cMyStringStrategy for the string strategy.
_SCREEN.oINTL.SetStrategyClass( "String", "cMyStringStrategy" )
strings.dbf em lote O INTL vem com classes iteradoras e de visitantes projetadas para recorrer a estruturas VFP e, entre outras coisas, carregar todos os elementos da interface de string no strings.dbf .
Consulte Atualizando strings.dbf com base em um .PJX.
As estruturas de relatório VFP não são geradas ou compiladas — elas são vinculadas ao seu aplicativo "no estado em que se encontram". Os relatórios devem, portanto, ser transformados antes da criação do .APP ou .EXE.
Localizar relatórios é algo que você só precisa fazer uma vez. O processo de transformação transforma seus rótulos de relatório em expressões de relatório contendo uma chamada para a função I() do INTL. Por exemplo, o rótulo do relatório "Name:" torna-se expressão I("Name:") .
Consulte Transformando relatórios com base em um .PJX.
Se você planeja realmente trocar idiomas rapidamente, será útil saber o seguinte:
Após o INTL localizar um formulário, ele adiciona ao formulário um objeto denominado oINTL da classe cINTLMemento configurado como INTL foi configurado. Esta lembrança é um objeto leve que permite que vários objetos INTL coexistam pacificamente porque eles podem saber que uma forma específica está, neste momento, sendo exibida em, digamos, japonês.
Quando um objeto INTL encontra um formulário contendo um membro chamado oINTL, ele adotará a configuração do membro conforme determinado pelo seu valor GETCONFIG() .
Se você precisar de um comportamento alternativo - por exemplo, se precisar que o segundo objeto INTL substitua completamente um memento do primeiro - primeiro localize o formulário de volta ao original (o que remove o membro Form.oINTL) e depois localize para o novo código de idioma usando o segundo objeto INTL.
MsgSvc() Na primeira invocação, MsgSvc() cria um objeto chamado _SCREEN.oMsgSvc que posteriormente gerenciará as mensagens. Se existir um objeto chamado _SCREEN.oINTL , o objeto _SCREEN.MsgSvc obedecerá às suas configurações de idioma e usará seus serviços.
Para localização em tempo de execução, você precisa distribuir os seguintes arquivos:
| Arquivo | Notas |
|---|---|
i.prg | Para melhor desempenho, coloque esta função em seu primeiro arquivo SET PROCEDURE . |
intl.prg | Para melhor desempenho, SET PROCEDURE TO INTL Additive . |
msgsvc.dbf | |
msgsvc.fpt | |
msgsvc.cdx | Se você usar MsgSvc() você precisará distribuir esses arquivos. |
msgsvc.prg | A biblioteca de serviços de mensagens. |
nohot.prg | Para melhor desempenho, coloque esta função em seu primeiro arquivo SET PROCEDURE . |
strings.dbf | |
strings.fpt | |
strings.cdx | Você precisará distribuí-los também. |
Para as tabelas e arquivos STRINGS e MSGSVC, se você incluí-los em seu APP ou EXE, eles serão, obviamente, somente leitura.
Aqui está uma descrição dos arquivos usados pelo INTL. Para saber onde eles podem ser melhor posicionados em relação ao seu projeto, consulte Como colocar corretamente seus arquivos INTL.
| Arquivo | Descrição |
|---|---|
addendum.txt | Notícias de última hora que podem ou não estar incluídas na documentação ou no arquivo de ajuda. |
genmenux.zip | Um arquivo do último programa GENMENUX disponível por Andrew Ross MacNeill. |
i.prg | Uma função independente que serve como atalho para o método _SCREEN.oINTL.I() . |
intl.prg | O código principal das classes e utilitários do kit de ferramentas INTL. |
intltool.prg | Utilitários do desenvolvedor para realizar operações em lote em arquivos de projeto e outras estruturas VFP. Não distribua este arquivo com seus aplicativos. |
msgsvc.dbfmsgsvc.fptmsgsvc.cdx | Tabela e arquivos de suporte contendo mensagens para diálogos, janelas de espera, barras de termômetro e blocos de texto. |
msgsvc.prg | A biblioteca de serviços de mensagens. |
nohot.prg | nohot() remove caracteres de teclas de atalho das expressões de prompt do FoxPro. É uma função de uma linha que você deve recortar e colar como um procedimento em algum lugar da pilha de invocação do seu aplicativo. |
strings.dbfstrings.fptstrings.cdx | Tabela e arquivos de apoio contendo frases traduzidas. |
A hierarquia de classes INTL é baseada na classe cINTLAbstract . cINTLAbstract serve para definir a interface para toda a hierarquia. Sempre que possível, foi evitada a adição de propriedades, eventos e métodos não autorizados às subclasses.
A figura abaixo mostra um diagrama OMT da hierarquia de classes INTL.
A hierarquia de classes INTL.
Em circunstâncias normais, os únicos objetos que você provavelmente usará são da classe INTL .
A classe cINTLMemento pode ser usada como token.
cINTLMemento é um token de configuração que objetos INTL podem usar para armazenar detalhes de uma localização específica. cINTLMemento inclui métodos de acesso a propriedades protegidas.
INTL é a interface pública e os métodos de modelo para o processo de localização.
cINTLStrategy é a classe pai de vários mecanismos de localização.
cINTLString , cINTLCurrency , cINTLFont , cINTLMeasures , cINTLPicture e cINTLData são classes de implementações estratégicas específicas.
INTL 
A classe INTL fornece serviços para localizar objetos e outros elementos em seu aplicativo.
INTL INTL::cCurrencyStrategyINTL permite localizar moedas.
Uma string especificando o nome da classe de estratégia monetária.
| Padrão | "cINTLCurrency" |
| Observações | Você pode subclassificar cINTLCurrency para atender às suas necessidades específicas. Você pode então usar o método SetStrategy("Currency",cYourCurrencyClass) para definir esta propriedade de estratégia monetária para algo diferente do padrão. |
| Veja também | cINTLMemento::GetStrategy() |
INTL::cDataStrategyINTL permite diferentes fontes de dados para diferentes localidades. Uma string especificando o nome da classe de estratégia de dados.
| Padrão | "cINTLData" |
| Observações | Você pode subclassificar cINTLData para atender às suas necessidades específicas. Você pode usar o método SetStrategy("Data", cYourDataClass) para definir esta propriedade de estratégia de dados para algo diferente do padrão. |
| Veja também | cINTLMemento::GetStrategy() |
INTL::cFontStrategyINTL permite que as fontes adequadas sejam substituídas.
Uma string especificando o nome da classe de estratégia de fonte.
| Padrão | "cINTLFont" |
| Observações | Você pode subclassificar cINTLFont para atender às suas necessidades específicas. Você pode usar SetStrategy("Font", cYourFontClass) para definir a propriedade da estratégia de fonte para algo diferente do padrão. |
| Veja também | cINTLMemento::GetStrategy() |
INTL::cPictureStrategyINTL pode localizar fotos, ícones e imagens.
Uma string especificando o nome da classe de estratégia de imagem.
| Padrão | "cINTLPicture" |
| Observações | Você pode subclassificar cINTLPicture para atender às suas necessidades específicas. Você pode usar ::SetStrategy("Picture", cYourPictureClass ) para definir a propriedade de estratégia de imagem para algo diferente do padrão. |
| Veja também | cINTLMemento::GetStrategy() |
INTL::cStringStrategyINTL localiza palavras e frases.
Uma string especificando o nome da classe de estratégia de string. A classe de estratégia de string é responsável por localizar strings e frases no aplicativo e também serve como repositório de funções para outras classes de estratégia.
| Padrão | "cINTLSting" |
| Observações | Você pode subclassificar cINTLString para atender às suas necessidades específicas. Você pode usar SetStrategy("String", cYourStringClass) para definir a propriedade. |
| Veja também | cINTLMemento::GetStrategy() |
A classe de estratégia cINTLString é de longe a mais útil e fornece serviços para outras estratégias. | Nota: muitas estratégias usam serviços baseados em string que são fornecidos pela classe de estratégia de string ativa. Para reduzir a coesão com uma classe cStringStrategy específica, muitos métodos de string que normalmente pertenceriam à classe cStringStrategy são encontrados na classe cINTLStrategy , a classe de estratégia pai. Assim, todas as estratégias possuem algumas habilidades inerentes de localização de strings. |
INTL INTL::Execute()Localiza um número, uma string, um objeto ou uma matriz de objetos. No caso de objetos e array de objetos, a função execute passa cada objeto por vez para todas as estratégias de localização ativas.
| Sintaxe | oINTL.Execute( @PassedObject ) |
| Retornar | Nada |
| Argumentos | PassedObject : pode ser do tipo numérico, string ou objeto. Também pode ser uma matriz de referências de objetos. |
| Veja também | INTL::ObjArray() |
Exemplo
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()| As estratégias podem exigir arquivos de recursos, que são referenciados por alias.
Retorna o alias da tabela de recursos associada à estratégia de localização padrão. Normalmente, o objeto de estratégia padrão é da classe cINTLString .
| Sintaxe | oINTL.GetAlias() |
| Retornar | O valor do caractere do alias da tabela de estratégia de string. |
| Argumentos | Nenhum. |
| Observações | O método GetAlias() é um método hookable , o que significa que se um objeto da classe INTL tiver um objeto hook anexado, então GetAlias() será transferido para o método do objeto hook. Como por padrão os objetos da classe INTL são conectados a um objeto da classe cINTLStringStrategy , invocar oINTL.GetAlias() é equivalente a invocar oINTL.oStringStrategy.getAlias() . |
Exemplo
_SCREEN.AddObject( "oINTL", "INTL" )
*-- The following two are equivalent
_SCREEN.oINTL.oStringStrategy.GetAlias()
_SCREEN.oINTL.GetAlias() |
INTL::GetTable()Retorna o nome da tabela de recursos associada
