Delphi - Segredos e Solues

CAPTULO 4

Os Fundamentos da Programao Delphi

Agora voc j conhece a aparncia um aplicativo Delphi. Voc viu como
personalizar formulrios acrescentando componentes, e comeou a escrever
os manipuladores de  eventos que representam a espinha dorsal de um
aplicativo Delphi. Mas, como voc provavelmente j percebeu, os
manipuladores de eventos vistos no fizeram muito.  Para fazer mais, 
preciso sentir-se  vontade com o dialeto do Object Pascal que faz parte
do Delphi. Este captulo  o incio para o seu domnio dessa linguagem.
Alm de ver construes de linguagem fundamentais como constantes,
variveis, laos e estruturas de deciso internos ao Delphi, voc tambm
comear a ver como trabalhar  com objetos Delphi durante o
processamento utilizando o cdigo apropriado em seus projetos.


        Voc comea aprendendo como trabalhar com a janela Code Editor e
os tipos bsicos de declaraes Delphi. O prximo assunto  uma
discusso sobre a especificao  de propriedades via cdigo e idias de
programao fundamentais como variveis, nmer como tipos, laos e
declaraes if-then (se ento). Depois, abordaremos os fundamentos para
trabalhar com objetos Delphi durante o processamento. Por exemplo, h
uma discusso sobre mtodos. Mtodos so a maioria das operaes comuns
(funes ou procedimentos) que afetam o comportamento de objetos Delphi
durante o processamento.  (Entretanto, isso no  muito preciso, uma vez
que h mtodos que operam como propriedades e propriedades que operam
como mtodos! ) Em seguida, discutiremos objetos  que esto disponveis
apenas durante o processamento como Screen, Printer e Application. A
isso se segue uma breve discusso sobre os diversos tipos de caixas de
mensagens e de entrada disponveis no Delphi. O captulo termina com uma
discusso sobre as tcnicas necessrias para utilizar vrios formulrios
em um nico aplicativo  Delphi.
       Antes de comearmos porm, nunca  demais enfatizar que a chave 
programao Delphi consiste em reconhecer que o Delphi geralmente
processa um cdigo apenas  em resposta a eventos. Pense em um programa
Delphi como um conjunto de elementos independ reconhecer. Tambm vale a
pena enfatizar que mesmo voc conhecendo uma linguagem de programao
mais convencional muito bem, no obrigue os seus programas Delphi  a se
adaptarem  estrutura dela. Caso imponha hbitos de programao
aprendidos em linguagens de programao mais antigas aos seus programas
Delphi, provavelmente enfrentar problemas. Por exemplo, no pense em um
programa Delphi como tendo uma linha inicial  e uma linha final e se
deslocando de cima para baixo - se fizer isso, no estar tirando
vantagens do poder do Delphi.
       Voc sempre escreve um cdigo na janela Code Editor. Como j foi
visto, essa janela abre sempre que voc d um clique duplo em um
componente ou formulrio  ou d um clique na aba Unit embaixo do
formulrio. A janela Code Editor tem um ttulo que re e uma rea para
editar seu cdigo. A barra de status informa em que linha o cursor
atualmente se encontra, se voc est no modo Insert ou Typover e assim
por diante.
       Dependendo da opo de editor que escolher, voc tem as tcnicas
de edio usuais do Windows, Turbo Pascal tradicional ou tcnicas de
edio no estilo Brief  disponveis. O item Environment Options no menu
Options permite-lhe configurar a janela Co no boto direito do mouse d
a voc um SpeedMenu com acesso rpido a recursos de edio comuns.

DICA: Para chegar rapidamente ao cdigo de um procedimento de evento que
voc j escreveu, d um clique duplo na coluna da direita da linha
apropriada na pgina  Events do Object Inspector.

Comandos no Delphi

Falando genericamente, os comandos Delphi executam aes em objetos
Delphi. Quando voc digita um comando no Delphi, ele utiliza a mesma
tecnologia que foi pioneira  no Turbo Pascal para fazer sua anlise e
processamento. Isso acontece imediatamente  medida que voc digita. As
palavras-chaves do Object Pascal esto em negrito  e os comentrios
esto formatados de acordo com as especificaes na pgina Editor Colors
(na caixa de dilogo Environment Options).

NOTA: Ns no colocaremos mais em negrito as palavras-chave das
listagens de programa uma vez que a sua aparncia fica muito pesada em
uma pgina impressa.

        Com exceo do material entre os apstrofos, caixas alta/baixa,
espaamentos e outros tipos de "espao em branco" - como linhas vazias -
so ignorados pelo  Delphi. Evidentemente,  uma boa idia apegar-se a
um mtodo padro de espaamento e forma

DICA VISUAL BASIC: O Delphi utiliza apstrofo em vez de aspas para
delimitar um texto.

        As declaraes de comando em Delphi no utilizam linhas
numeradas, e normalmente cada comando est em uma linha prpria. Desde
que o comando esteja com a  sintaxe correta, voc pode desdobr-lo ao
longo de vrias linhas. Um ponto-e-vrgula (;)  s (e no um retorno de
carro ou um espao em branco)  o separador dos comandos, voc pode, por
exemplo, combinar comandos em uma linha colocando ponto-e-vrgula entre
elas e utilizar qualquer padro de endentao que voc achar
conveniente.
       As linhas esto limitadas em 126 caracteres. Se precisar utilizar
uma linha com mais caracteres do que isso, pressione ENTER para ir at
uma nova linha fsica.  (Lembre-se,  o ponto-e-vrgula que marcar o
fim da declarao.)

NOTA: Algumas vezes, neste livro voc ver linhas que facilmente cabem
nesse limite, mas so grandes demais para poder caber em uma linha de
pgina impressa de um  livro. J que o Delphi no processa o prximo
comando antes do ponto-e-vrgula que marca a separao, tudo se resume
em procurar pelo ponto-e-vrgula.

        A ltima declarao end em seu programa tem um ponto, da mesma
forma que o ponto final em uma sentena. Isso indica que seu programa
acabou e no h mais  nenhuma declarao para ser separada.

Declaraes de Comentrios

Declaraes de comentrios so colocadas nos programas para explicar o
que  que o cdigo faz. Os comentrios no so executados nem
processados pelo Delphi. Como  resultado, no ocupam espao no cdigo
compilado. H duas maneiras para indicar um comentrio. A primeira
consiste em utilizar uma chave esquerda e direita para  delimitar o
comentrio:
        procedure TForm1.FormClick(Sender: TObject);
        begin {Os comentrios que descreveriam o procedimento seriam
colocados aqui}
        end;

        Como sempre, as linhas de programao esto endentadas para
melhorar a legibilidade.
        O segundo mtodo para indicar um comentrio consiste em utilizar
um parntese esquerdo com um asterisco - (* - para iniciar o comentrio,
e um asterisco  com um parntese direito - *) - para terminar o
comentrio. Um comentrio pode se estender po
        procedure TForm1.FormClick(Sender: TObject);
        begin
          (*Os comentrios que descreveriam o procedimento seriam
colocados aqui*")
        end; 

        Voc tambm pode acrescentar comentrios no final das linhas.
Por exemplo:
        begin {Os comentrios que descreveriam o procedimento seriam
colocados aqui}

     Tudo o que se encontra entre a marca de abertura e a de fechamento
 tratado como um comentrio pelo compilador. Se voc esquecer o
indicador de fechamento  do comentrio, poderia acidentalmente indicar
ao compilador que todo o cdigo seguinte no arq fazer comentrios sobre
declaraes executveis  uma tcnica comum para ajudar na depurao de
seus programas.

Processando e Terminando Programas

Para processar um programa que voc est desenvolvendo, o caminho mais
fcil consiste em utilizar a simplificao F9 (ou escolher Run| Run).
Por outro lado, quando  voc est desenvolvendo um programa e quer
par-lo, escolha Close na caixa de menu de controle do formulrio
(principal). Se voc est desenvolvendo um programa, ser recolocado no
ambiente de desenvolvimento integrado (IDE).

NOTA: Talvez voc tenha que utilizar Run|Program Reset para terminar o
programa caso ele no responda aos mtodos anteriores. (Isso normalmente
acontece quando um  erro provoca uma interrupo prematura de seu
programa pelo Delphi.) O problema na utilizao de Run| Program Reset 
que ele poder no liberar recursos do Windows  alocados pelo Delphi
para seu projeto.

O Comando Halt

Quando o Delphi processa um comando Halt, o programa pra e o Delphi
tambm libera quaisquer recursos que alocou. Em um programa
independente, depois que o Delphi  processa um comando Halt, todas as
janelas abertas pelo programa so fechadas e o programa  retirado da
memria. Se voc estava no IDE enquanto desenvolvia o programa,  ser
devolvido ao ambiente de desenvolvimento.
       Em um programa Delphi, voc pode ter quantos comandos Halt
quiser, mas  uma boa prtica de programao restringir o nmero de
eventos que terminam o programa.


NOTA: O Delphi pra um programa ao processar um comando RunError (que 
utilizado para gerar erros que ocorrem durante o processamento - veja
(captulo -7) ou processar  um comando Application Terminate ou
encontrar um comando de sada no bloco principal do cdigo.

Especificao de Propriedades

Alterar propriedades via cdigo  uma das tarefas mais importantes na
codificao Delphi. O Delphi utiliza dois-pontos seguidos de um sinal de
igual (:=) para essa  operao. Se voc quiser mudar a especificao de
uma propriedade para um objeto Delphi, coloque o nome do objeto seguido
de um ponto e depois o nome da propriedade  do lado esquerdo da
combinao dois-pontos/sinal de igual, e coloque o valor novo do lado
direito:
       
        objeto. propriedade : = valor;

        Por exemplo, vamos supor que voc tenha um componente de caixa
de edio denominado Editl e quer deix-lo em branco utilizando cdigo
em lugar do Object  Inspector. Basta voc fazer o Delphi processar uma
linha como esta:

        Edit1.Text := ;

         J que no h nada entre os apstrofos, o texto atribudo a
essa propriedade est vazio. Igualmente, uma linha como
        
        Editl.Text := 'Este  o texto novo.';

muda a especificao da propriedade de texto para o texto entre os
apstrofos. Voc pode mudar a especificao de uma propriedade
utilizando cdigo com a freqncia  de que precisar.
       Mudar as propriedades com um cdigo torna mais fcil anular
decises tomadas durante o projeto. Por exemplo, se voc quisesse tornar
um boto chamado Button5,  o primeiro boto na ordem Tab, acrescentaria
uma linha como a seguinte a um manipulador 
        
        Button5.TabOrder := 0;

         Suponha agora que voc quer que um formulrio chamado Form
1movimente-se quando vrios botes so acionados. Aqui est o exemplo de
um dos manipuladores  de evento de que voc precisaria:
        
        procedure TForm1.MoveToLeftClick(Sender: TObject);
        begin
        Form1.Left :=Form1.Left - 75;
        end;

        Olhe a linha-chave
        
        Forml.Left :=Form1.Left - 75;

        Do lado esquerdo da declarao de atribuio est a propriedade
que recebe o valor, mas parece que a propriedade tambm ocorre do lado
direito. O que acontece   que o Delphi analisa primeiro o lado direito
de qualquer atribuio para extrair um v e calcula o nmero de pixels
que se encontra da esquerda. Em seguida, subtrai 75 desse nmero. Apenas
depois que tiver feito isso ele olha para o lado esquerdo.  Agora o
Delphi muda o valor antigo da propriedade Left para um valor novo.
       Finalmente, algumas vezes as propriedades Delphi so elas
prprias objetos. Um bom exemplo disso  a propriedade Font, que se
aplica a vrios objetos Delphi.  Uma vez que a propriedade Font  ela
mesma um objeto, para especificar um valor da propri do que voc
precisaria para mudar o tamanho da fonte de uma caixa de edio para um
tipo de 24 pontos:
      
         Editl.Font.Size :=24;

        Em geral, utilize pontos para navegar pela hierarquia de
objetos. (Veja o Captulo 6 para mais informaes a respeito de objetos
e a hierarquia de objetos.  )

Propriedades Booleanas

As propriedades que aceitam apenas os valores True ou False so chamadas
de propriedades Booleanas, do matemtico ingls George Boole. Ns j
discutimos vrias propriedades  Booleanas. As propriedades Booleanas
especificam se um boto  visvel, se est ativado, ou se  o boto
padro ou de cancelamento. Por exemplo, quando o Delphi  processa uma
deelarao como
        
        Button1.Visible := False;

ele esconde o boto. O componente fica escondido at o Delphi processar
uma declarao como:
        
        Button1.Visible := True;
     
         Como outro exemplo, se voc quiser que a tecla TAB pule um
componente enquanto um programa est sendo processado, mude a
propriedade TabStop para False,  utilizando:
        
        Component.TabStop := False;

        A maneira usual de comutar entre propriedades Booleanas  com o
operador Not. Vamos supor que voc tenha uma declarao como
        
        Button1.Visible := Not(Button1.Visible);

em um manipulador de evento. Essa declarao funciona da seguinte
maneira: o Delphi encontra o valor atual de Buttonl.Visible e, em
seguida, o operador Not inverte  esse valor. Isto , se o valor era
True, ele muda para False, e vice-versa.

O Comando With

Quando voc tem de restaurar um grande nmero de propriedades de uma s
vez, provavelmente prefere no ser obrigado a repetir todas as vezes a
digitao do nome  do objeto. A palavra-chave with permite-lhe fazer
isso eliminando a necessidade de digitar o nome do objeto todas as
vezes.
        Por exemplo, vamos supor que voc queira estabelecer a altura, a
largura e a cor de uma caixa de edio DataInput. Voc poderia utilizar
alguma coisa que  comeasse da seguinte forma:
                 
                 Datalnput.Color := c1White;
                  Datalnput.Enabled := True;
                  Datalnput.Height := 36;

        Mas  mais simples (e com freqncia envolve menos digitao)
dizer:
                with Datalnput do
                begin
                Color := c1White;
                Enabled := True;
                Height := 36;
                end;

        (Considere quanta digitao voc economizaria com o comando with
quando estivesse especificando propriedades como Font, que so elas
mesma objetos.)

Variveis

No Delphi, as variveis contm informao (valores). Ao contrrio do
Visual Basic, por exemplo, voc tem que declarar uma varivel antes de
utiliz-la. Ao declarar  uma varivel, d a ela um nome e um tipo
separados por dois-pontos. Isso deve ser feito depois da palavra-chave
var. Por exemplo:

                var
                Retorno: Double;
                Tamanho: Integer;
                InteiroGrande: Longlnt;

        Voc pode declarar mais do que uma varivel do mesmo tipo
colocando uma vrgula entre elas. Por exemplo:

        var
                Retorno, TaxaVenda: Double;

        No Delphi, os nomes das variveis podem ser de qualquer tamanho,
mas apenas os 63 primeiros caracteres contam. Para qualquer nome de
varivel com mais de  63 caracteres, o compilador ignora os caracteres
extras. O primeiro caractere tem que ser um de letras, nmeros e
sublinhados. A varivel no pode ser uma palavra-chave ou incluir
smbolos como $, % e assim por diante. O tamanho das letras no nome da
varivel   irrelevante. A tabela que segue relaciona alguns nomes de
variveis possveis e indica se so aceitveis.

        $Base_Ball - No aceitvel - o primeiro caractere no  uma
letra, um nmero ou um sublinhado
        Base.1 - No aceitvel - utiliza um ponto
        EsteEGrandeMasOk - Aceitvel - menos do que 63 caracteres de
tamanho

        Enquanto os primeiros 63 caracteres em um nome de varivel so
significativos, o tamanho das letras  irrelevante. A varivel BASE  a
mesma que base. Por  outro lado, Base  uma varivel diferente de Base
1, e as duas so diferentes de Base_1.
        Escolher nomes de variveis com significado ajuda a documentar
seu programa tornando mais fcil o processo inevitvel da depurao.
Nomes de variveis com  significado so uma maneira excelente para
esclarecer o significado de muitos tipos de decl
      Voc no pode utilizar como nomes de variveis os nomes reservados
pelo Delphi. Por exemplo, Do no  aceitvel como nome de varivel.
Entretanto, voc pode  aninhar palavras-chave dentro do nome de uma
varivel. Por exemplo, DoIt  um nome de vari o Delphi apresentar uma
mensagem de erro se voc tentar utilizar uma palavra-chave como nome de
varivel. (Veja na ajuda on-line uma lista de palavras-chave.)

        Uma conveno comum para os nomes de variveis  utilizar
maisculas no incio das palavras que formam as partes do nome da
varivel (por exemplo, JurosHipotecarios,  em lugar de
Juroshipotecarios). Essa conveno  chamada de nomes de variveis d
pessoas acha isso muito mais legvel. Algumas pessoas tambm acrescentam
sublinhado (por exemplo, Juros_ Hipotecarios).

Tipos de Variveis

O Delphi trata com 15 tipos de variveis padro. Normalmente as pessoas
tambm desdobram esses 15 tipos em categorias (por exemplo, tipos de
nmeros Inteiros e Ponto  Flutuante). (Voc tambm pode definir seus
prprios tipos de variveis, conforme ser visto no prximo captulo.) O
que segue  uma discusso rpida sobre esses  tipos diferentes.

NOTA: Em algumas linguagens, como Visual Basic, cada tipo de varivel
tem um valor padro. Isso no acontece no Delphi. Voc tem de atribuir
um valor a uma varivel  para poder inicializ-la - caso contrrio,
ocorrero resultados imprevisveis.

Boolean

As variveis booleanas contm o valor True ou False. Uma varivel
Boolean requer um byte de memria.

Tipos de Nmeros Inteiros

Tipos de dados Inteiros so utilizados quando voc est trabalhando com
nmeros inteiros (ou no se preocupa com o que se encontra depois do
ponto decimal). As operaes  aritmticas envolvendo variveis com dados
inteiros so muito rpidas. H cinco tipos de dados inteiros:

        Integer - As variveis inteiras no tm parte fracionria e
contm valores inteiros pequenos (entre -32.768 e 32.767). Uma varivel
Integer exige dois  bytes de memria.
        Shortint - As variveis Shortint no tm uma parte fracionria e
contm valores inteiros relativamente pequenos (entre -128 e 127). Uma
varivel Shortint  requer um byte de memria.
        Longint - As variveis Longint no tm uma parte fracionria e
contm valores inteiros relativamente longos (entre -2.147.483.648 e
2.147.483.647). Uma  varivel Longint requer quatro bytes de memria.
        Byte - As variveis Byte tambm no tm uma parte fracionria e
contero valores inteiros (entre 0 e 255). Uma varivel Byte requer um
byte de memria.
        Word - As variveis Word tambm no tm uma parte fracionria e
contero valores inteiros (entre 0 e 65.535). Uma varivel Word requer
dois bytes de memria.

Tipos de Nmeros de Ponto Flutuante (Reais)

Utilize variveis de um desses tipos quando voc no se preocupa com uma
preciso total, mas precisa de nmeros muito grandes ou muito pequenos
(normalmente) com  um ponto decimal. Todas as operaes com esses tipos
so aproximaes. Operaes aritmticas envolvendo variveis com esses
tipos podem ser muito mais lentas do  que aquelas com dados inteiros.

        H cinco tipos de dados de Ponto Flutuante:

        Rea1 - Variveis Real contm nmeros e podem ter uma parte
fracionria de 11-12 dgitos significativos. Uma varivel Real requer
seis bytes de memria.
        Single - Variveis Single contm nmeros e podem ter uma parte
fracionria de 7-8 dgitos significativos. Uma varivel Single requer
quatro bytes de memria.  O tipo de dado Single est disponvel apenas
quando a opo em ponto-flutuante (N+) est
        Double - As variveis Double contm nmeros e podem ter uma
parte fracionria de 15-16 dgitos significativos. Uma varivel Double
requer oito bytes de memria.  O tipo de dado Double tambm est
disponvel somente quando a opo ponto flutuante (
        Extended - Variveis Extended contm nmeros e podem ter uma
parte fracionria de 19-20 dgitos significativos. Uma varivel Extended
requer dez bytes de  memria. O tipo de dado Extended tambm est
disponvel apenas quando a opo ponto-flutuant
        Comp -Variveis Comp so incomuns no sentido em que contm
inteiros extremamente grandes mas descartam a parte fracionria
(decimal). Uma varivel Comp requer  oito bytes de memria. O tipo de
dado Comp tambm est disponvel apenas quando a opo

NOTA: Apenas o tipo Real est disponvel a no ser que voc especifique
o compilador de ponto flutuante (N+) como ativado. O padro  que ele
est ativado uma vez  que o Windows fornece emulao de ponto flutuante.
Para saber mais a respeito de compiladores, veja o Captulo 5.
 
Tipos para Manusear Texto

Os tipos de dados predefinidos para manusear texto no Delphi podem
operar com caracteres singelos ou com grupos de at 255 caracteres.


DICA VISUAL BASIC: O manuseio de texto no Delphi no  to conveniente
nem to poderoso como no Visual Basic. Isso ocorre porque o tipo de
string bsico est limitado  em 255 caracteres e, desta forma, voc tem
de escrever as suas prprias rotinas para analisar e manipular grandes
quantidades de texto (veja o Captulo 5 para um  exemplo).
 
        Char - Variveis Char contm um caractere ASCII.
        String - Variveis String contm at 255 caracteres ASCII. Voc
pode conseguir com que elas tenham menos caracteres envolvendo os
nmeros entre colchetes.  Por exemplo:
        var
            Name: string[45];


Tipo de Dado Ponteiro

O Captulo 5 discutir os tipos de dados ponteiros em maior
profundidade. Por ora, se voc no programou com ponteiros, pense neles
como os endereos dos locais  onde esto armazenados objetos. H dois
tipos de ponteiros:

        Pointer - Um tipo pointer  um valor que aponta para variveis
do tipo base. Uma varivel do tipo pointer contm o endereo de memria
de uma varivel.  Se o tipo base  um identificador no-declarado, voc
tem que fazer a sua declarao na mesma  respeito desse tipo, veja o
Captulo 5.
        Pchar - Esse  um ponteiro para uma string de terminao nula.
Strings de terminao nula so utilizadas para strings grandes, ao
tratar com API do Windows,  e para tornar algumas funes de tratamento
de texto mais fceis de escrever. O tipo PCha o Captulo 5 para maiores
informaes.

Atribuindo Valores s Variveis

O Delphi utiliza dois-pontos e o sinal de igual (:=) para atribuir
valores a variveis, da mesma forma que para especificar propriedades.
Por exemplo:
        procedure TForm1.FormClick(Sender: TObject);
        var
          TaxaRetorno: double;
          EntradaTexto: String;
        begin
          TaxaRetorno := 0.05;
          EntradaTexto := Edit1.Text;
        end;

        O nome da varivel aparece sempre  esquerda, e o valor aparece
sempre  direita. O Delphi tem de ser capaz de obter um valor do lado
direito de uma declarao  de atribuio. Ele executar qualquer
processamento necessrio para que isso acontea. de texto da caixa de
edio (uma string) atribuindo-o  varivel string EntradaTexto.
        Considere uma declarao de atribuio como uma maneira para uma
varivel Delphi obter um valor (novo) ou como um meio para copiar
informao de uma fonte  a um destino.

Constantes

Quando um programa  legvel, sua depurao  mais fcil. Tente evitar a
sndrome dos olhos vidrados que  muito comum quando um programa tem uma
grande quantidade  de nmeros misteriosos espalhados por tudo.  bem
mais fcil manter (e ler) linhas de cdigo que utilizam nomes
significativos para as constantes. Por exemplo, se  voc estabelecer uma
chamada constante VALOR_TAXA poder ter linhas de cdigo como: 
        
        TaxaTotal := Custo*"VALOR TAXA

em lugar de

        TaxaTotal := Custo*"0.0825

que certamente  mais difcil de compreender. O recurso de nomear
constantes do Delphi permite-lhe utilizar nomes mnemnicos para valores
que nunca mudam durante  o processamento do projeto. (Voc pode, porm,
facilmente fazer mudanas para compilaes diferentes. Este  um dos
motivos porque as constantes melhoram a sustentao.)
       Embora o Delphi (ao contrrio do Pascal) no o requeira, as
constantes normalmente so declaradas em uma seo antes daquela de
declarao das variveis.  Voc especifica a constante utilizando o nome
dela, um sinal de igual e depois o valor.
       
         const
        TAXA_VENDA = 0.0825;
         NOME_LINGUAGEM ='Delphi';
        var
        {A declarao da varivel seria colocada aqui}

        As constantes, como as variveis, tm tipos, mas derivam seu
tipo do valor que voc utiliza na declarao. Por exemplo, a constante
TAXA_VENDA  do tipo  Real; NOME_LINGUAGEM  do tipo String.
        As regras para os nomes das constantes so as mesmas que para as
variveis: apenas os 63 primeiros caracteres importam, o primeiro
caractere tem de ser uma  letra ou um sublinhado, e depois qualquer
combinao de letras, sublinhados e numerais. Ut todas em maisculas com
um sublinhado caso seja necessrio.
       Algumas vezes voc pode definir uma constante em termos de outras
constantes e/ou as funes internas do Delphi, conforme mostrado no
prximo exemplo de cdigo.
        
        const
        RETORNO =.18
        RETORNO_DIRIO = RETORNO/365;

        (Veja na ajuda on-line sobre "Constant Declaration" que funes
voc pode utilizar. )

NOTA: Delphi  fornecido com centenas de constantes internas, para serem
utilizadas com suas funes e objetos.

        No ltimo captulo, voc utilizou vrias dessas constantes
internas ao especificar propriedades por ocasio do projeto. Essas
constantes so armazenadas  nas unidades que definem a funo ou o
objeto. Voc no precisa declarar essas constantes int ou objeto com que
voc est trabalhando. Por exemplo, voc pode utilizar uma declarao
como:
        
        Form1.Color := cl Black

que muda a cor do formulrio para preto, utilizando a constante interna
clBlack. (As constantes internas do Delphi normalmente, mas nem sempre,
seguem a conveno  em que as letras iniciais so minsculas e depois h
uma nica letra maiscula. )

Escopo de Variveis e Constantes

Escopo  o termo utilizado para fazer referncia  disponibilidade de
uma varivel ou constante, declarada (ou utilizada) em uma certa parte
do programa para outras.  Em linguagens de programao mais antigas,
onde todas as variveis e constantes estavam disponveis a todas as
partes do programa, manter controle sobre os nomes  era sempre um
problema. Por exemplo, em uma linguagem mais antiga, no-estruturada,
quando voc utilizava duas variveis designadas Total em diferentes
partes do  programa, os valores podiam (e iriam) se confundir.
       A soluo em linguagens de programao modernas como o Delphi
consiste em isolar variveis e constantes. A no ser que voc faa uma
especificao afirmando  o contrrio, mudar o valor de uma varivel
denominada Total em um procedimento no afetar as variveis so locais
aos procedimentos, a no ser que haja uma especificao em contrrio. Em
particular, um manipulador de eventos normalmente no ter acesso  ao
valor de uma varivel em um outro manipulador de eventos.

NOTA: J que o Delphi exige que voc declare as variveis,  bem mais
difcil cair na armadilha provocada acidentalmente por efeitos
colaterais.

        Ainda assim, no  uma boa prtica de programao depender de
padres. Se voc quer ter a certeza de que uma varivel  local dentro
de um manipulador de  eventos, coloque-a na seo var dentro do
manipulador de eventos. Evidentemente que, j que  uma sem declar-1a
localmente, voc sabe que h uma varivel com escopo maior, de mesmo
nome, espreitando em algum lugar. Compartilhando Valores entre
Procedimentos

 claro que, ocasionalmente, voc quer compartilhar os valores de
variveis (e de constantes) entre os manipuladores de eventos ou entre
as unidades. Por exemplo,  se um aplicativo foi desenvolvido para
realizar um clculo envolvendo uma taxa de juros por vez, aquela taxa
deveria estar disponvel  a todos os procedimentos em uma unidade. As
variveis que permitem esse tipo de compartilhamento so chamadas de
variveis globais. Dependendo de onde voc declara  uma varivel, ela
pode ser encarada como uma varivel global verdadeira acessvel por
qualquer outro cdigo no aplicativo, como uma varivel em nvel de
unidade  acessvel por qualquer cdigo na unidade, ou como uma varivel
em nvel de procedimento local apenas a um procedimento ou manipulador
de evento.
       Voc coloca as declaraes das variveis nvel de unidade em uma
seo var na seo de implementation da unidade. Para chegar a essa
seo do cdigo, abra  a janela Code Editor, v at o topo do arquivo
Unit do modelo e desa procurando pela seo 
    Eis um exemplo de como tornaramos uma varivel denominada
TaxaRetorno uma varivel em nvel de unidade e TAXA_VENDA uma constante
em nvel de unidade.

        implementation
        {$R *.DFM} {No se preocupe ainda com o significado disso, mas
tambm no o mude!}
        const
              TAXA_VENDA = .0825;
        var
              TaxaRetorno: Real;

        Agora:
        * O valor da constante designada TAXA_VENDA e a varivel chamada
TaxaRetorno sero vistos por todos os procedimentos na unidade.
        * Qualquer mudana feita nessa varivel pelo cdigo em um
manipulador de eventos persistir em outros manipuladores de eventos.

        Evidentemente, o ltimo ponto significa que voc deve ter
cuidado ao atribuir valores a variveis em nvel de unidade. Qualquer
informao passada entre  manipuladores de eventos  um terreno frtil
para erros de programao. Alm do mais, esses e
       Embora a maioria dos programadores no ache que seja uma boa
idia, voc pode utilizar o mesmo nome de varivel ou de constante como
uma constante ou varivel  local e em nvel de unidade. Quaisquer
declaraes const e var contidas em um procedimen a ser local. Portanto,
voc perde a aptido de utilizar a informao contida na varivel
global. A duplicao dos nomes torna a varivel global invisvel ao
procedimento.  O Delphi no lhe informa se uma varivel global foi
definida com o mesmo nome que uma varivel local. Esse  mais um motivo
para garantir que as variveis que voc  quer que sejam locais realmente
sejam locais fazendo a sua declarao dentro do procedimento. Isso
obriga a varivel a ser local quele procedimento.

DICA: Alguns programadores gostam e prefixar variveis em nvel de
procedimento com a letra "p" (por exemplo, pRetorno) e as variveis
unidade com a letra "u"  (por exemplo, uRetorno). Isso facilita uma
verificao de relance do escopo de uma varivel.

Como voc viu antes, as constantes funcionam de forma similar: se voc
tem apenas um formulrio ou quer que as constantes sejam visveis aos
manipuladores de eventos  de apenas um formulrio, coloque-os na seo
de implementao da unidade. Se voc definir uma constante dentro de um
procedimento, ento apenas aquele procedimento  ter acesso  constante.
(Veja a seguir mais informaes a respeito de programas de vrios
formulrios.)

NOTA: Se voc quiser criar constantes ou variveis realmente globais em
uma unidade (isto , constantes e variveis que sero visveis a
qualquer unidade que utiliza  aquela unidade), coloque a declarao na
seo interface da unidade.

Tornando os Valores Persistentes

Quando o Delphi invoca um manipulador de eventos, os valores antigos das
variveis globais so destrudos. Eles voltam aos valores de
inicializao. (Conforme mencionado  antes, voc no pode confiar no
valor de uma varivel no-inicializada, voc tem de inicializar todas as
variveis.) As variveis que no retm seus valores so  chamadas de
variveis dinmicas. Entretanto, as variveis dinmicas no so
suficientes para todas as situaes de programao. Por exemplo, vamos
supor que seja  preciso manter controle sobre quantas vezes um boto foi
acionado. Se um contador  sempre recolocado em zero, voc est com um
problema.  possvel fazer com que  os valores se mantenham utilizando
uma varivel em nvel unidade (nvel de formulrio), mas geralmente 
uma boa idia reservar variveis em nvel de formulrio  apenas para
compartilhar informao. A maioria dos programadores escolheria esse
mtodo apenas se outros manipuladores de eventos precisassem trabalhar
com o contador.
        Do que voc precisa so normalmente chamadas de variveis
estticas em linguagens como Visual Basic. Uma varivel desse tipo 
inicializada apenas quando  o programa comea a funcionar. Depois disso,
o valor no procedimento se mantm; qualquer mud No Delphi (que herdou a
terminologia do Pascal original) so chamadas de constantes digitadas. 
importante lembrar que no so constantes - apenas so declaradas  na
seo de constantes. Naquela ocasio, voc fornece o valor inicial. A
sintaxe  assim:

        const
              count: Integer =1;

DICA VISUAL BASIC: Embora a terminologia seja um pouco peculiar, uma
vantagem das constantes digitadas sobre as variveis estticas em Visual
Basic  que voc pode  especificar o valor inicial das constantes
digitadas em qualquer valor que quiser.

        Para ver as constantes digitadas (variveis estticas) em
funcionamento, coloque um boto de comando em um modelo vazio e tente
realizar os seguintes procedimentos  de evento clique.

        procedure TForml.Button1Click/Sender: TObject);
        const
           count: Integer =1;
        begin
             ShowMessage(IntToString(Count));
             Count := Count + 1;
           end;
        end.

        Agora tente o seguinte, o qual utiliza uma varivel
no-inicializada para o contador.

        procedure TForm1.Button1Click(Sender: TObjectl;
        var
            count: Integer;
            begin
                ShowMessage(IntToString(Count));
                Count := Count + 1;
            end;
        end.

        Observe os valores um pouco estranhos para Count. Finalmente,
mude o ltimo manipulador de eventos de forma a inicializar a varivel
Count em 1. Observe  que todas as vezes que voc processar o programa e
der um clique no boto, obter o mesmo val

NOTA: Alm de serem ideais para contadores, as constantes digitadas
(variveis estticas) so ideais para tornar os componentes
alternadamente visveis ou invisveis  (ou para comutar entre quaisquer
propriedades Booleanas) e como uma ferramenta de depurao. Elas tambm
podem ser utilizadas dentro do procedimento de um Timer  para controlar
quantas vezes o evento foi acionado. Isso d a voc a aptido para
manusear intervalos de tempo muito grandes.


Strings

Uma vez que a informao nas caixas de edio do Delphi  sempre
armazenada como texto, as strings so extremamente importantes no
Delphi.

NOTA: Uma vez que as variveis de tipo string podem conter apenas 255
caracteres, voc tem que utilizar outras tcnicas para tratar strings
muito grandes. Veja no  Captulo 5 algumas maneiras de fazer isso.
 
        Para juntar duas strings (fazer a sua concatenao), utilize um
sinal de mais (+). Por exemplo, se

        strTtulo :='Rainha';
        strNome :='Elizabete';
        strNumeral =: 'I';

ento

        'Rainha Elizabete I' = strTtulo + strNome + strNumeral
        'Rainha Elizabete II' = strTtulo + strNome + strNumeral +
strNumeral

        O + concatena strings na ordem em que voc as apresenta. Assim,
ao contrrio de quando voc adiciona nmeros entre si, a ordem 
importante quando voc utiliza  o sinal + para juntar duas strings entre
si. Voc pode utilizar o sinal + para juntar  est um exemplo utilizando
as variveis definidas acima:

        StrRainhaAtual := strTtulo + strNome + strNumeral + strNumeral;

DICA:  muito mais rpido construir uma string primeiro e depois mudar a
propriedade de uma string de um objeto, do que mudar a propriedade
string repetidamente.

        Se voc precisa representar um caractere ASCII, utilize um #
antes do cdigo ASCII. Por exemplo
     
        LetraA := #65

 o mesmo que
      LetraA : = A

        Como outro exemplo, quando voc precisa do cdigo NewLine
(combinao de ASCII 10 + ASCII 13) utilize 

        NovaLinha : = # 10 + # 13

Nmeros

Os nmeros no Delphi no podem utilizar vrgulas para determinar os
milhares. Podem utilizar um ponto decimal, a no ser que sejam inteiros.
Se voc precisar dar  um valor numrico a uma varivel, coloque o nmero
do lado direito da declarao de atribuio.

NOTA: Se voc precisar trabalhar com um nmero real como .5 tem de
colocar um 0 antes do ponto decimal (isto , utilizar Number := 0.5).

        Se voc tentar atribuir um nmero com um ponto decimal a uma
varivel inteira, ela ser automaticamente assinalada durante a
compilao.

NOTA: Voc pode utilizar a representao hexadecimal para o tipo
Integer, Shortint, Byte, Word e Longlnt, prefixando a representao
hexadecimal (base 16) com um  $.

        Por exemplo, $A e 10 (decimal) so o mesmo para o compilador.

NOTA: Seu cdigo se comportar de forma errtica se atribuir um nmero
maior do que os limites permitidos pela sua varivel, mas nenhuma
mensagem de erro ser  gerada a no ser que voc informe ao compilador
para que faa uma verificao de alcance.
        Se voc quer que o Delphi faa uma verificao de alcance para
que os limites em variveis numricas sejam sinalizados, especifique a
opo de compilao  do verificador Range como ativado. Isso poder ser
encontrado na pgina Compiler da caixa de sobre opes do compilador.)
Dizer ao Delphi para que faa verificao de alcance retardar a
performance de seu cdigo, uma vez que h compromissos bem definidos.

Operaes com Nmeros

A prxima tabela fornece os smbolos para as quatro operaes
aritmticas fundamentais. Com exceo do operador de diviso, quando
voc comea com dois nmeros do  mesmo tipo, acaba com um nmero do
mesmo tipo:

        + - Adio
        - - Subtrao (e para designar nmeros negativos)
        / - Diviso (fornece sempre um resultado em Ponto Flutuante -
mesmo que voc esteja trabalhando com inteiros).
        * - Multiplicao

DICA VISUAL BASIC: Voc tem de utilizar a funo exp interna para poder
obter uma contraparte ao operador ^ para elevar a uma potncia.
       
        Para os tipos inteiros, h duas palavras-chaves para as
operaes aritmticas nicas a nmeros desse tipo:

        div - Diviso inteira
        mod - O resto depois de uma diviso inteira

        Uma vez que o smbolo de diviso normal (/) d a voc um valor
que  um tipo Ponto Flutuante, utilize div se voc precisa permanecer
dentro de um dos tipos  inteiros. O que div faz  jogar fora o resto,
para lhe dar um inteiro. Por exemplo, 7 div 

        O operador mod  a outra metade da diviso inteira. Esse
operador fornece o resto da diviso por um inteiro. Por exemplo, 7 mod 3
= 1. Quando um inteiro  divide perfeitamente um outro, no h resto, de
forma que o operador mod resulta zero: 8 mod 
        O termo usual para uma combinao de nmeros, variveis e
operadores de onde o Delphi pode extrair um valor  uma expresso
numrica.

Operadores Booleanos e Binrios

O Delphi permite-lhe combinar variveis ou expresses Booleanas
utilizando os operadores descritos na Tabela 4.1.

Tabela 4.1 Operadores Booleanos

        = (igualdade) - Testa se duas expresses Booleanas so ambas
True ou ambas False
        not - Muda uma expresso Booleana que  True ou False e
vice-versa.
        and - Resulta True apenas quando as duas expresses so True
        or - Resulta True se uma das expresses  True
        xor- Resulta True se as expresses Booleanas so diferentes

        Esses operadores tambm funcionam no nvel de bit. Se voc tiver
um inteiro e aplicar um desses operadores, ele afetar os bits
individuais no nmero ou  nos nmeros. Por exemplo, o operador and
devolve um 1 apenas se os dois dgitos binrios so 
        X and 1 Informa se o primeiro (da direita) dgito binrio est
ativado.
        X and 2 Informa se o segundo dgito binrio est ativado
        X and 3 Informa se o primeiro e o segundo dgitos binrios esto
ativados.

        (Esse processo , em geral, chamado de mascaramento e
ocasionalmente  necessrio para analisar o valor devolvido de funes
Delphi ou da API do Windows.  )

        A Tabela 4.2 resume como esses operadores funcionam no nvel de
bit.

        Voc tambm pode utilizar os operadores shl (deslocamento para
esquerda) e shr (deslocamento para direita) em inteiros ou expresses de
inteiros. Eles movem  os bits para a esquerda ou para a direita. Assim,
eles multiplicam rapidamente um inteiro deslocar vrias posies de bit
adicionando um inteiro a shl ou a shr. Por exemplo, shl 3 desloca os
bits trs posies para a esquerda, fazendo rapidamente a sua
multiplicao por oito.

Tabela 4.2 Operadores de Bit

        Expresses Utilizando o Operador de Bit - Que Ele faz
                                    
        X and Y - Resulta 1 em uma posio de bit apenas se os dois bits
eram 1 (on); caso contrrio coloca aquele bit em 0 (off)
        X or Y - Resulta 1 em uma posio de bit se X ou Y tivesse
aquele bit ativado
        X xor Y - Resulta 1 em uma posio de bit se exatamente um dos
bits estivesse ativado. (Em virtude disso, executar essa operao com o
mesmo nmero duas  vezes no faz nada.)
        not (X) - Reverte os bits: um 1 torna-se 0 e 0 torna-se um 1

Parnteses e Precedncia

Ao fazer clculos, h duas maneiras para indicar a ordem em que voc
quer que as operaes aconteam. A primeira  utilizando parnteses, o
que a maioria das pessoas  prefere. Os parnteses permitem-lhe
especificar, facilmente, a ordem em que as operaes devem ocorrer. Um
clculo como 3 + (4 * 5) resulta 23 porque o Delphi executa  primeiro a
operao dentro do parnteses (4 vezes 5) e depois adiciona 3. Por outro
lado, (3 + 4) * 5 resulta 35 porque Delphi soma primeiro 3 com 4 para
obter 7  e apenas depois multiplica por 5.

        Eis um outro exemplo:

        ((6 * 5) +4) *3
    
        O parnteses interno resulta 30, o segundo conjunto de
parnteses informa ao Delphi que deve adicionar 4 para obter 34, e
depois o Delphi multiplica 34 por  3 para obter 102.
        O Delphi permite-Ihe evitar o parnteses, desde que voc siga as
regras que determinam a precedncia das operaes matemticas. Por
exemplo, a multiplicao  tem uma precedncia maior que a adio. Isso
significa que 3 + 4 * 5  23 e no 35 porque
        A prxima lista fornece a ordem hierrquica das operaes:
       
        @, not
       *,/, div, mod, and, shl, shr, E
       +, -, or, xor
       =, <, >, <=, >=, <>, in
        Quando voc utiliza dois operadores no mesmo nvel, o Delphi
avalia a expresso da esquerda para a direita.

Mais sobre Nmeros no Delphi

Se voc tentou qualquer clculo envolvendo nmeros grandes no Delphi,
provavelmente descobriu que, com freqncia, ele no se importa em
imprimir nmeros grandes.  Em vez disso, ele utiliza uma variante em
notao cientfica. Se voc no est familiarizado com essa notao,
pense no E+ como significando "mova a casa decimal  para a direita,
acrescentando zeros se necessrio". O nmero de casas decimais 
exatamente o nmero que segue o "E". Se um nmero negativo segue o "E",
mova o ponto  decimal para a esquerda. Por exemplo, 2.lE-5 resulta em
.000021. Caso seja conveniente, voc pode entrar com um nmero
utilizando a notao E; o Delphi no se preocupa  se voc entrar com
1000 ou lE3, ou lE+3.

Composio de Tipos

Com freqncia precisamos converter strings em nmeros e vice versa.
Esse  o exemplo do que normalmente  chamado de composio de tipos -
uma vez que estamos mudando  um objeto de um tipo para outro. Por
exemplo, a funo IntToStr deixa voc converter um inteiro em uma
string. A funo FloatToStr permite-lhe converter um nmero  de um dos
tipos de dados Ponto Flutuante para uma string. Por exemplo, se Message
 uma varivel string, ento voc poderia utilizar uma declarao como:

        Message := `A quantidade total ' + IntToStr(Count);
     
        A Tabela 4.3 resume as funes de converso de tipo bsicas.

NOTA: H mais algumas funes de converso disponveis para situaes,
especiais (Val, Str e FloatToStrF, FormatStr). As mais importantes so
provavelmente as funes  FloatToStrF e FormatStr. FloatToStrF  uma
verso ampliada de FloatToStr que lhe permite controlar o formato da
string resultante (veja a ajuda on-line).

        Para maiores informaes sobre composio de tipos, veja o
Captulo 5.
 
Tabela 4.3 Funes de Converso Bsicas.

        InToStr - Converte inteiros em string
        InToHex - Converte um inteiro em hexadecimal
        StrTolnt - Converte um inteiro (ou representao hexadecimal de
um inteiro) em uma string
        FloatToStr - Converte um nmero em ponto flutuante em uma string
        StrToFloat - Converte uma representao string em ponto
flutuante nmero a nmero 

Repetindo Operaes (Laos)

Vamos supor que voc precisa repetir uma operao. Em programao (como
na vida real), talvez voc queira repetir a operao um determinado
nmero de vezes, continuar  at atingir um determinado objetivo
predeterminado, ou at que determinadas condies iniciais finalmente
mudem. Em programao, a primeira situao  chamada de  lao
determinado e os dois ltimos so chamados de laos indeterminados. O
Delphi permite os trs tipos de lao, de modo que h trs estruturas de
controle diferentes  no Delphi para repetir operaes.


Laos Determinados (For)

Vamos supor que voc queira exibir dez caixas de mensagens sucessivas
dentro de um manipulador de eventos. A maneira mais simples para fazer
isso  colocando as  seguintes linhas de cdigo dentro do procedimento:
        var
            I: Integer;
        begin
            for I :=1 to 10 do
                begin
                  ShowMessage('Esta '+ IntToStr(I) +'-sima caixa');
                end;
        end;

        No exemplo anterior, a linha com as palavras-chaves for e to 
uma simplificao de "para todo valor de I de 1 a 10." Voc pode pensar
no lao For como  o ato de dar corda a uma roda dentro do computador de
modo que ela gire um determinado nmero  da roda. Isso  feito nas
(blocos de) declaraes que se encontram entre o incio e o fim. (Se
voc tem apenas uma nica declarao, no precisa, falando no sentido
exato da palavra,
d#####################################################
######################################################
#############
######################################################
######################################################
###########################
###################################################
######################################################
######################o  par de palavras-chave begin/end que marca
o bloco. )
        A palavra-chave for especifica uma varivel contadora. No
exemplo anterior, o contador  uma varivel inteira: I. Nesse exemplo, o
valor inicial do contador   colocado em l. O valor final  colocado em
10. O Delphi coloca primeiro a varivel cont do que o valor final. Se o
valor  maior do que o valor final, nada ser feito. Se o valor inicial
 menor do que o valor final, o Delphi processa as declaraes
subseqentes at chegar ao ponto-e-vrgula de encerramento que marca o
fim do bloco. Nesse ponto, adiciona 1  varivel contadora e comea o
processo novamente.  Esse processo continua at que a varivel contadora
seja maior do que o valor final. Nesse ponto, o lao est terminado, e o
Delphi segue adiante.
        A sintaxe geral para um lao For  assim:

        for varivel := Expresso Inteira to Expresso Inteira do
         begin
             comando1;
             comando2;
             .
             .
         end;

Mais sobre Laos For

Nem sempre voc conta para frente. Algumas vezes  necessrio contar
para trs. Voc faz isso utilizando a palavra-chave downto em um lao
For. A palavra-chave downto  diz ao Delphi para mudar o contador em
menos 1.

        Por exemplo, um programa de simulao de espao no estaria
completo sem a incluso, em algum lugar no programa, do fragmento:
        
        for I :=10 downto 1 do
        begin
               ShowMessage(IntToStr(I));
        end;
        ShowMessage('Saia da!');

        Quando voc utiliza downto, o corpo do lao For  contornado se
o valor inicial do contador  menor do que o valor final.

DICA VISUAL BASIC: O contador no lao For no pode ser um nmero real e
no h nenhum equivalente para a palavra-chave step. Se voc precisar
converter um lao  For-Next do Visual Basic que utilize qualquer um dos
dois, ter de utilizar variveis dentro do lao e mant-los atravs de
cdigo dentro do lao.

Laos For-Next Aninhados

Vamos supor que voc, alm de permitir um intervalo de taxas de juros em
uma tabela de hipoteca, tambm quer permitir um intervalo de reais. Para
cada valor de real,  voc quer percorrer um intervalo inteiro de taxas
de juros. Ou, considerando o cdigo necessrio para preencher as clulas
em uma grade, voc normalmente trabalharia  nas clulas linha-por-linha
(ou coluna-por-coluna). A colocao de um lao dentro de outro 
designada como laos aninhados. Vamos olhar o exemplo simples de uma
tabela de multiplicao. Um fragmento como o seguinte:
        
        for I := 2 to 12 do
            StringGridl.Cells(IntToStr(2*I), IntToStr(2));

d a voc a "tabela de dois". Para obter uma tabela de multiplicao
completa voc tem de envolver esse lao por um outro que muda o 2 para
um 3, o 3 para um 4,  e assim por diante. O lao fica assim:
        
        for J := 2 to 12 do
        for I := 2 to 12 do
            StringGrid1.Cells(IntToStr(I*J), IntToStr(J));

        Eis o que est acontecendo: o valor de J comea em 2, e, em
seguida, o Delphi entra no lao interno. O valor de I tambm comea em
2. Agora o Delphi realiza  11 passos pelo lao antes de terminar. Nesse
ponto, o Delphi muda o valor de J para 3 e c
       A regra para aninhar os laos For-Next  simples: o lao interno
tem de ser completado antes que a prxima declarao do lao externo
seja encontrada. Voc  pode ter trs laos aninhados, quatro laos
aninhados, e muito mais. A sua limitao encont

Laos Indeterminados

Algumas vezes voc no sabe exatamente quantas vezes um lao deve ser
repetido. Para essas situaes, o Delphi tem dois tipos de laos que
discutiremos em seguida.

O Lao Repeat

Os laos Repeat repetem um bloco de cdigo at que uma condio seja
atendida. Laos desse tipo so indeterminados - isto , no so
executados um nmero fixo de  vezes - pela sua prpria natureza. Por
exemplo, vamos supor que voc queira descobrir quanto tempo seria gasto
para levar $1000 at $1000 000 utilizando um juros  de 8 por cento:

        var
            Dinheiro: Real;
            Cont: Integer;
        begin
            Money :=1000;
            repeat {inicia o corpo do lao}
                Dinheiro := Dinheiro * 1.08;
                Cont := Cont + 1;
            until Dinheiro > 1000000;
        ShowMessage ('Levou'+ IntToStr(Count) + 'anos');
        end; O padro geral, quando voc escreve esse tipo de lao no
Delphi,  o seguinte:

        repeat
            begin
                declaraes de comando Delphi;
            end;
        at a condio ser atendida;


NOTA: J que o teste para saber se a condio  verdadeira  feito
apenas no final do lao, um lao Repeat  sempre executado pelo menos
uma vez.

        A condio (Booleana) em um lao que o Delphi est testando no
precisa ser necessariamente uma igualdade ou desigualdade. Voc pode
utilizar qualquer combinao  dos operadores lgicos and, or, not - at
mesmo xor se quiser. O importante  que o 

DICA VISUAL BASIC: Um lao Repeat no Delphi  o mesmo que o lao Do
Until no Visual Basic.

O Lao While

Delphi tem um outro tipo de lao. Esse lao leva o teste para o topo. A
sintaxe fica assim:

        while condio faa
            begin
                Declaraes de comando Delphi;
            end;

        Neste caso, j que o teste  realizado no comeo, o lao poder
nem ser executado. Tambm, uma vez que fazemos o teste no comeo, voc
normalmente quer ter  certeza de que a condio faz sentido antes do
processamento do lao. Voc no tem o luxo 

Tomando Decises

Nesse ponto, tudo o que seu cdigo pode fazer  decidir se deve repetir
um grupo de declaraes ou no. No pode, ainda, mudar quais declaraes
so processadas  de acordo com aquilo que o programa j fez ou o que ele
acabou de encontrar. As prximas sees cuidam disso. Todos os comandos
nessas sees tratam de transformar  idias que o programador deixaria
internas como:

        if condio then faa algo e/se faa algo 

no cdigo Delphi. O Delphi utiliza a declarao if-then de forma muito
parecida que se faz em portugus. Por exemplo, para avisar um usurio de
que um nmero tem  de ser positivo, utilize uma linha como a seguinte:
        
        if I < 0 then
            ShowMessage ('Nmero tem de ser positivo!');

        De forma mais genrica, quando o Delphi se depara com uma
declarao if-then, ele verifica a primeira clusula (chamada,
naturalmente, de clusula  if ) e verifica se ela  verdadeira (True).
Se a clusula for True, o computador far o que se segu pular para a
prxima declarao.
        Na maioria das vezes, voc vai querer processar vrias
declaraes se uma condio for True ou False. Para isso,  preciso do
modelo mais poderoso da declarao  if-then-else, chamado de bloco de
declarao if-then. Para escrever essa declarao n declaraes entre um
par incio e fim como um nico bloco. A declarao do bloco if-then 
assim:
        
        if algo para testar then
            begin
                        muitas declaraes;
            end
        else
            begin
                        mais declaraes;
            end;

NOTA: Quando voc utiliza o bloco de declarao if-then, no coloca um
ponto-e-vrgula no final do bloco if nem depois da palavra-chave else
que inicia a declarao  do bloco else.

        Evidentemente, o bloco da declarao else  opcional; a sua
colocao ali significa que deve se seguir uma declarao ou um outro
bloco. Esse bloco else  ser processado apenas se a clusula for False.
       Para criar um exemplo sobre isso, vamos modificar o ltimo
exemplo:
       
        if I < 0 then
            begin
                       ShowMessage ('Nmero tem de ser positivo!');
            end
       else
            begin
                       ShowMessage ('Nmero era positivo!');
           end;

        Novamente, como sempre, o recuo est presente para que o
programa fique mais legvel; o Delphi no se preocupa sobre como voc
faz os recuos.

Utilizando Declaraes If Then com Laos

Com freqncia, quando voc est operando com um lao, quer forar uma
outra iterao ou deixar o lao prematuramente em resposta a uma
determinada condio. A palavra-chave  continue permite-lhe forar uma
interao. Por exemplo, se voc  supersticioso:

        var
            cont: Integer;
        begin
            for cont :=1 to 100 do
                begin
                    if cont =13 then
                        continue;
                    ShowMessage(IntToStr(Cont)1;
                end; 

        Isso evitaria a exibio do nmero 13, j que foramos uma
interao se o valor de cont  13 antes de exibirmos a caixa de
mensagem.
        Por outro lado, a palavra-chave break permite-lhe deixar
prematuramente qualquer lao - sem terminar a condio. Por exemplo, a
seguinte modificao do programa  anterior exibe apenas os nmeros entre
l e 12.

        var
            cont: Integer;
        begin
            for cont :=1 to 100 do
                begin
                        if cont =13 then
                           break;
                        ShowMessage(IntToStr(Cont));
                end;

DICAS: A utilizao da declarao if-then apropriada com a palavra-chave
break d a voc um lao que testa no meio.

A Declarao Case

Vamos supor que voc esteja projetando um programa que determina o grau
de aproveitamento com base na mdia de quatro provas. Se a mdia  90 ou
maior, o aluno deveria  receber um A, de 80 a 89 um B, e assim por
diante. Essa  uma situao to comum, que o Delphi tem uma outra
estrutura de controle projetada exatamente para isso.   chamada
declarao Case. A declarao Case deixa claro que um programa atingiu
um ponto com vrias ramificaes; vrias declaraes if-then, no. (E
quanto mais  claro for um programa, mais fcil a sua depurao. )
        Por exemplo, voc poderia escrever o seguinte fragmento para
analisar o valor da varivel NotaMdia.
       
        case NotaMedia of
                       100: ShowMessage ('A+!');
                       90..99: ShowMessage ('A');
                       80..89: ShowMessage ('B');
               end;

        O que normalmente segue a palavra-chave case  uma varivel ou
expresso Character ou Integer, e o que o Delphi vai fazer depende do
valor da varivel ou  da expresso. As declaraes case individuais
utilizam uma constante singela, ou um grupo de dois pontos). Voc pode
acrescentar uma clusula else para cuidar imediatamente de todos os Case
restantes, conforme a prxima lista:
        
        case UpCase(chA) of
                        'Y': ShowMessage ('Algumas vezes uma vogal.');
                     'A', 'E', 'I', 'O', 'U': ShowMessage
('Definitivamente uma vogal.');
                  else
                      ShowMessage('Consoante');
        end;

        (Da mesma forma que com todas as declaraes Delphi, voc pode
substituir uma declarao individual por declaraes de bloco
incio/fim.)

Mais sobre o Trabalho com Objetos em Tempo de Execuo

H objetos e propriedades de objetos com os quais voc s pode trabalhar
se utilizar cdigo - nem as propriedades nem os prprios objetos esto
disponveis atravs  do Object Inspector. Por exemplo, se voc quisesse
descobrir o que o Windows est adotando como altura da tela, voc
olharia na propriedade Height do objeto Screen  - e o objeto Screen e
suas propriedades associadas esto disponveis apenas em tempo de
execuo. Igualmente, voc pode controlar uma impressora (atravs do
objeto  Printer) apenas em tempo de execuo.

NOTA:  possvel criar instncias de quase qualquer objeto Delphi em
tempo de execuo. Veja mais informaes de como fazer isso no Captulo
6.

Mtodos

Se voc quiser que seus objetos Delphi faam mesmo alguma coisa,
freqentemente precisar trabalhar com seus mtodos internos. Por
exemplo, se quiser apagar o contedo  de uma caixa de edio, dever
utilizar uma declarao como a seguinte:
        
        Edit1.Clear;

        J que existem literalmente centenas de mtodos (h 32 apenas
para caixas de edio) seria impossvel abordar todos neste livro. Voc
tem de estar preparado  para trabalhar com a ajuda on-line para ver se
um componente tem um mtodo que faz o que  fcil pelo fato de que
mtodos com o mesmo nome tendem a trabalhar de forma similar. Por
exemplo, o mtodo Clear aplica-se  maioria dos controles que tratam com
texto - e apaga o texto de todos eles. Como outro exemplo, o mtodo
SetFocus se aplica a todos os controles que podem receber o foco, e,
como seria de se esperar,  move o foco diretamente para o componente.

NOTA: Voc pode modificar o comportamento de qualquer mtodo para um
componente Delphi. Consulte a documentao fornecida com o Delphi
chamada de "On Writing Components"  para maiores informaes de como
fazer isto.

        O que segue  uma descrio rpida de alguns dos mtodos comuns
mais importantes. Outros captulos abordam mtodos mais especializados.
(Por exemplo, o prximo  captulo discute os mtodos mais comuns para
trabalhar com caixas de lista e combinada )

        BringToFront, SendToBack - Esse mtodo coloca o componente (ou
formulrio, se voc estiver utilizando diversos formulrios) na frente
(ou atrs) de todos  os outros componentes ou formulrios (veja a seo
Z-Order no Captulo 12).
        Create - Esse mtodo muito importante  utilizado para criar
novas instncias de objetos Delphi durante o processamento.  abordado
em profundidade no  Captulo 6.
        Focused - Esse  o exemplo de um mtodo que funciona mais como
uma propriedade.  Booleano (True/False) e  utilizado para determinar
se um controle tem  o foco: A sintaxe  normalmente

                if Editl.Focused then...

        Hide,Show - Hide deixa um formulrio ou controle invisvel. Isso
 o mesmo que especificar a propriedade Visible como False. O mtodo
Show torna-o novamente  visvel. Show invoca tambm o mtodo
BringToFront caso seja utilizado em um formulrio es Esses mtodos
acionam respectivamente os eventos OnHide e OnShow.
        Refresh, Repaint - Refresh apaga qualquer imagem que existe na
tela e depois pinta novamente o componente. A repintura faz com que o
componente regenere  a imagem mas no apague o que j est ali (veja o
Captulo 11 para saber mais a respeito dess
        ScaleBy - Permite-lhe escalonar novamente qualquer controle. Por
exemplo, se quisesse deixar um boto de comando 50 por cento maior
diria:
         
                Command1.ScaleByl3, 2);

         Em geral, o primeiro nmero  o numerador e o segundo  o
denominador do fator de escala. Em nosso exemplo, isso resulta em um
fator de escala de 3/2 (  150 por cento).

O Objeto Application

Sempre que voc processa um projeto Delphi, o Delphi cria
automaticamente o objeto Application. Voc tem de trabalhar com
propriedades e mtodos desse objeto para  poder fazer coisas como
especificar o cone do aplicativo ou especificar o nome do arquivo Help
do projeto (veja o Captulo 12). O que segue  uma discusso breve  das
propriedades e mtodos mais importantes do objeto Application. (Veja a
ajuda on-line se precisar escrever procedimentos de eventos para o
objeto Application.  Isso exige tcnicas algo diferentes daquelas que
voc utiliza ao escrever procedimentos de eventos para objetos Delphi
disponveis durante o processamento.)
        Mtodo Terminate - Chamar o mtodo Terminate no formato de
Application.Terminate  outra maneira de terminar um aplicativo. Tem o
mesmo efeito que uma declarao  Halt, mas  preferido pela maioria dos
programadores na compilao final.
       ExeName Property -  o nome que voc deu ao projeto no formato
compilado menos a extenso .EXE. Por exemplo, o nome padro de um
projeto Delphi compilado   PROJECT 1.EXE, assim, para isto, teramos:
       
                Application.ExeName = `PROJECTl'
       
        HeIpFile Property -  o nome do arquivo Help (veja o Captulo
12).
       Propriedade Icon - Quando voc minimiza um aplicativo, o valor
dessa propriedade  o cone que o usurio ver. Um exemplo de como isso
poderia ser utilizado   supor que voc tenha um cone para uma
borboleta no diretrio chamado de ICONS no drive 

        Application.Icon.LoadFromFile('C:\ICONS\BTFLY.ICO);

        Mtodos Minimize, Restore - O mtodo Minimize minimiza o
aplicativo em um cone.  especialmente til em projetos com vrios
formulrios. Quando o usurio  minimiza o aplicativo, o mtodo Minimize
 o realmente chamado. O mtodo Restore, por outro
    Mtodo ProcessMessages -  um mtodo extremamente importante.  a
maneiras como voc permite ao seu aplicativo deixar o Windows processar
eventos para outros  aplicativos. Uma vez que o Windows pode realizar
multitarefas apenas de forma cooperativa, v fila de eventos. Algumas
utilizaes comuns de ProcessMessage incluem:
    
        *Utiliz-lo dentro de um cdigo que est realizando um clculo
demorado
        *Utiliz-lo em um aplicativo Delphi que opera com outros
programas Windows (por exemplo, um programa terminal que pode estar
recebendo dados de um servio  on-line)
    
        Title -  o texto que aparece embaixo do cone.


O Objeto Screen

Este objeto essencial diz a voc o que  que o Windows acha que so as
propriedades da tela toda. Por exemplo, o valor de Screen.Height  o que
o Windows est utilizando  como altura da tela em pixels. Aqui
acrescentamos descries curtas sobre as propriedades e mtodos mais
comuns para o objeto Screen.

Propriedade ActiveControl, ActiveForm - Diz a voc qual o controle (ou
qual o formulrio) que tem o foco. ActiveForm  uma propriedade
essencial ao trabalhar com  aplicativos de vrios formulrios, (veja o
seguinte) que determina com qual formulrio o usurio est trabalhando.
        ComponentsCount, Componentlndex, Components, Forms, FormsCounts
- So mtodos utilizados quando voc precisa, por exemplo, fazer
iteraes pelos formulrios  ou pelos componentes em um formulrio. Veja
mais a respeito de objetos Delphi no Captulo
        Cursor - Ao contrrio da propriedade cursor para um componente,
apropriedade cursor para o objeto Screen tem um efeito global. Ela
controla o formato do  cursor do mouse para todos os formulrios no
aplicativo. (Isso, porm, pode ser sobrepujado p
        Fonts -  uma lista com as fontes sustentadas pelo Windows para
o driver de vdeo do usurio.
         Propriedades Height, Width - Informam a voc a altura e largura
da tela, medida em pixels, conforme relatada pelo Windows.
        Propriedade PixeIsPerInch - Informa a voc quantos pixels o
driver de vdeo presume que h em uma polegada.
        Propriedade Fonts - Fornece uma lista com as fontes da tela.
Esse  um exemplo de uma propriedade que, na verdade,  uma lista de
strings. (Veja mais informaes,  no Captulo 5, a respeito de listas de
string.)
        Cursors - Fornece uma lista dos cursores disponveis. Esse
tambm  um exemplo de uma propriedade que  uma lista de strings.

O Objeto Canvas

O objeto Canvas  mais um exemplo de propriedade de um objeto Delphi que
tambm  um objeto. Conforme sugerido pelo seu nome, o objeto Canvas
(Tela)  uma superfcie  sobre a qual se pode "pintar". No Delphi, voc
pode utilizar o objeto Canvas para exibir texto ou grficos. Essa seo
explica como utilizar esse objeto para exibir  texto de forma precisa em
um formulrio. A seo sobre Impressoras, que segue, explica como
utiliz-lo para posicionar texto em uma impressora. (Veja no Captulo
11 como utilizar o objeto Canvas para fazer grficos em um formulrio ou
impressora.)
        O mtodo padro para exibir um texto  chamado de mtodo
TextOut. Eis um exemplo de como utilizar TextOut:
       
        Forml.Canvas.TextOutl 0, 0, 'Isto ser o canto esquerdo da
tela');

       A sintaxe geral 
        NomeObjeto.Canvas.TextOut(EsgucrdaDireita,TopoInferior, Texto)

onde EsquerdaDireita fornece a posio horizontal (coordenada X) como um
inteiro; TopoInferior fornece a posio vertical (coordenada Y); e Texto
 um string ou  expresso string do texto que ser exibido.
       Freqentemente, voc precisa conhecer a altura e a largura de uma
string de texto antes de decidir onde coloc-la. Isso  feito com os
mtodos TextHeight  e TextWidth. A sintaxe dos dois  essencialmente a
mesma. Por exemplo:
      
        Forml.Canvas.TextWidth(`Texto seria colocado aqui')

 o nmero de pixels que a string Texto seria colocado aqui ocuparia.
Como voc pode imaginar, essa informao pode ser utilizada para
redimensionar componentes  ou formulrios conforme a necessidade.

O Objeto Printer (Impressora)

Ao fornecer a sua prpria interface ao driver de impressora Windows
atravs do objeto Printer, o Delphi faz o melhor possvel para isolar
voc da necessidade de  tratar com a confuso de ter que manipular
vrias impressoras. Dessa forma, quando voc quer imprimir informao,
precisa utilizar apenas as propriedades e mtodos do objeto Printer.
        H uma regra fundamental para utilizar o objeto Printer:
acrescente uma clusula Printers  seo uses de sua unidade. Para fazer
isso, suba pela janela  Code Editor at encontrar uma seo que comea
assim:
        
        uses
            SysUtils, WinTypes, WinProces, Messages,...

        Acrescente agora a clusula Printers (juntamente com vrgula) em
qualquer lugar dessa clusula uses antes do ponto-e-vrgula final. DICA:
Para imprimir uma imagem de um formulrio na impressora, acrescente
Printers  clusula uses e utilize depois

Se voc quiser fazer alguma coisa diferente do que imprimir imagens de
formulrios, precisa inicializar a impressora. Quando voc terminar de
enviar a informao  desejada  impressora, feche as conexes. Para
isso:

        *Para iniciar uma tarefa de impresso: Utilize o mtodo
BeginDoc.
        *Para terminar uma tarefa de impresso: Utilize o mtodo EndDoc.

        ( evidente que voc precisa estar preparado para tratar com
problemas de impressora, como ficar sem papel. Os procedimentos para
cuidar dessas excees  so abordados no Captulo 7.)
       Geralmente, utilize a propriedade Canvas (subobjeto) da
impressora para dirigir o texto ou os grficos  impressora. A sintaxe 
semelhante quela para os  formulrios. Por exemplo:
        
        Printer.Canvas.TextOut(0,0, 'Texto no canto superior esquerdo');

        Em geral, os parmetros das coordenadas X e Y da propriedade
Canvas permitem-lhe controlar posicionamentos individuais dos pontos em
uma pgina impressa.

NOTA: A maioria das propriedades (por exemplo, Canvas, TextOut,
TextHeight e Fonts) funciona da mesma maneira para imprimir em
formulrios como para trabalhar com  uma impressora.

O que segue  uma breve discusso das propriedades e mtodos mais
importantes da impressora.
        Mtodo Abort -  utilizado para terminar uma tarefa de impresso
se, por exemplo, ocorrer um problema.
        Propriedade Printing - Propriedade Booleana que lhe informa se a
tarefa ainda est sendo impressa. (Evidentemente que, se a sua
impressora tem um buffer  grande, essa propriedade no ser relevante,
j que o buffer da impressora conter o texto e 
        Propriedades Printers, Printlndex - Printers  uma lista de
strings. (Veja no Captulo 5 maiores informaes sobre listas de
strings.) Essa propriedade  informa quais os drivers de impressora
Windows esto instalados no computador do usurio. O va
        Mtodo NewPage - Mtodo que envia um "form feed" (avano de
formulrio)  impressora.
        Propriedade Orientation - Informa se a tarefa est sendo
impressa no formato panormico ou retrato.
        Propriedades PageHeight, PageWidth - So a altura e a largura da
pgina atual medidas em pixels (isto , pontos por polegada para as
impressoras laser).  Por exemplo, em uma laser de 300 dpi, uma pgina de
8,5 x 11 retorna valores de 3150 para a p de impresso de
aproximadamente 8 x 10,5.
        Propriedade PageNumber - Fornece o nmero da pgina atual.
        Propriedade PrintScale - Quando voc imprime um modelo
utilizando o mtodo Print, essa propriedade permite-lhe determinar se o
modelo deve ficar inalterado  ou se  colocado em escala. H trs
valores fornecidos pelas constantes: poNone, poProport as propores da
tela, mas garante que o formulrio caiba em uma pgina). (PrintScale 
tecnicamente uma propriedade Form e no uma propriedade Printer.)

Caixas de Mensagem e Caixas de Entrada

 bastante comum utilizar caixas de mensagem especficas nos aplicativos
Windows para a exibio d informao. Voc j viu os mecanismos
fundamentais para fazer  isso no Delphi: o procedimento ShowMessage cuja
sintaxe  ShowMessage(string).
       Infelizmente, tudo o que o procedimento ShowMessage faz  exibir
uma caixa com a string e um boto OIC. (O nome do arquivo executvel de
seu aplicativo   o ttulo da caixa de mensagem.)

NOTA: Uma variao de ShowMessage, chamada ShowMessagePos, permite-lhe
posicionar a caixa de mensagem em qualquer parte da tela que desejar.

Conseguir mais informaes ao usurio - por exemplo, fornecer ao usurio
botes para acionar, dando informaes ao seu programa - tambm 
possvel com uma caixa  de mensagens. Essa seo aborda maneiras para
fazer isto.

NOTA: Todas as caixas de mensagem so modais. Significa que devem ser
fechadas antes que o aplicativo continue.

H dois tipos de caixas de mensagem a sua disposio:
         
        *A funo MessageDlg exibe uma caixa de mensagem com texto,
ttulo, e botes, os quais voc especifica.
        *A funo MessageDlgPos permite-lhe posicionar a caixa no local
da tela que especificar.

A Funo MessageDlg

Antes de olharmos a sintaxe geral para tratar com essa caixa de
mensagem, d uma olhada no seguinte trecho de cdigo:

        if MessageDfg ('Voc realmente quer encerrar o programa?',
mtConfirmation, [mbYes, mbNo], 0) = mrYes then Application.Terminate;

        Como  de se esperar, isso apresenta ao usurio uma caixa como a
seguinte:
        Observe os botes Yes e No. Quando o usurio aciona um boto, o
Delphi devolve um valor que depende do boto. Em nosso exemplo, se o
usurio acionar o boto  Yes, o Delphi devolver o valor fornecido pela
constante interna mrYes. Se ele acionar o  verificando se  igual 
constante mrYes. Caso seja, encerramos o aplicativo.
       A sintaxe geral para essa funo na ajuda on-line  assim:
MessageDlg(constMsg:String;AType:TMsgDlgType; AButtons:
       TMsgDlgButtons;HelpCtx:#Logint): Word;

        J que isso  bem tpico de uma entrada de ajuda on-line, vamos
gastar um pouco de tempo em cada um dos elementos. Primeiro, a
informao que  passada para  uma funo no Delphi  normalmente
chamada de parmetro. (Voc vai ver muito mais a respe parmetro 
indicado, da mesma forma que nas declaraes, por dois-pontos. Os
parmetros de tipos diferentes so separados por ponto-e-vrgula. Se a
palavra-chave  const precede o parmetro, a funo no pode alter-la.
(Se voc vir a palavra-chave var, pode).

        Observe que essa funo utiliza alguns tipos que voc no viu
antes. Para as funes internas, esses so, na maioria das vezes, tipos
que so predefinidos  para serem determinados conjuntos de constantes.
(Para saber mais a respeito de conjuntos,  para o tipo de caixa de
mensagem. So discutidos abaixo.
       Parmetro Msg -  uma string ou expresso string exibida pelo
Delphi como o texto na caixa de mensagem. J que  uma string, est
limitado em 255 caracteres.
       Parmetro AType - Determina o tipo de caixa de mensagem que
aparece. A Tabela 4.4 resume os tipos possveis. Cada caixa de mensagem
 dada por um valor de  TMsgDlgType diferente.

Tabela 4.4 Tipos de Caixas de Mensagem.

         mtWarning - A caixa de mensagem utiliza um smbolo de ponto de
exclamao amarelo
        mtError - Utiliza um sinal de parada vermelho
        mtlnformation - Utiliza um "i" azul
         mtConfirmation - Utiliza um ponto de interrogao verde
         mtCustom - Elimina qualquer mapa de bits e obriga o ttulo a
ser o nome do arquivo executvel do aplicativo

        Parmetro AButtons - Determina quais os botes que aparecem na
caixa de mensagem. Para acrescentar vrios botes, envolva-os por
colchetes e separe-os com  uma vrgula, como no fragmento de cdigo
acima, quando escrevemos [mbYes, mbNo) para result 4.5 resume os tipos
de botes que voc pode utilizar

        Como voc viu no fragmento de cdigo,  possvel determinar qual
 o boto que o usurio pressionou analisando o valor de retorno da
funo MessageDlg. As  constantes so mnemnicas. Por exemplo, mrCancel
significa que o boto Cancel foi pressiona a ajuda on-line para ver uma
lista completa.)

NOTA: Voc pode utilizar trs constantes predefinidas para conjuntos de
botes de ocorrncia freqente. So mbYesNoCancel (para os botes Yes,
No, Cancel), mbOkCancel  (para os botes OK e Cancel) e
mbAbortRetrylgnore (para os botes Abort, Retry e Ignore). Uma vez que
so predefinidas, voc no utiliza um colchete para elas.

Tabela 4.5 Tipos de Botes Disponveis em uma Caixa de Mensagem.



        mbYes - Um boto com uma marca de escolha verde e o texto "Yes"
em sua face
        mbNo - Um boto com um crculo vermelho atravessado por uma
barra inclinada e o texto "No" em sua face
        mbOK - Um boto com uma marca de escolha verde e o texto "OK" em
sua face
        mbCancel - Um boto com um X vermelho e o texto "Cancel" em sua
face
        mbHelp - Um boto com "Help" em sua face
        mbAbort - Um boto com uma marca de escolha vermelha e o texto
"Abort" em sua face
        mbRetry - Um boto com duas setas circulares verdes e o texto
"Retry" em sua face
        mblgnore - Um boto com um homem verde se afastando e o texto
"Ignore" em sua face
        mbAll - Um boto com marcas de escolha duplas verdes e o texto
"All" em sua face

        Parmetro HelpCtx - Determina a identificao do contexto Help.
Veja o Captulo 12.

A Funo MessageDIgPos

Uma vez que a funo MessageDlg exibe uma caixa de dilogo de mensagem
no centro de sua tela, voc precisa utilizar essa funo se quiser
posicionar a caixa de mensagem  em qualquer outro lugar da tela. A
sintaxe de cada uma  parecida, com exceo da adio de dois parmetros
para as coordenadas (em pixels) onde voc quer que aparea  a caixa de
dilogo.
       
        function MessageDlgPos(const Msg: String; AType: TMsgDIgType;
       AButtons: TMsgDlgButtons; HelpCtx: Logint;X, Y: Integer): Word;

        Os parmetros X e Y so inteiros que indicam as coordenadas da
tela (em pixels) onde voc quer que aparea o canto superior esquerdo da
caixa de mensagem.

Funo InputBox

Embora os componentes edit e memo so as maneiras mais comuns para
receber entrada de usurio, h momentos em que voc quer interromper o
aplicativo pela utilizao  de uma caixa de dilogo modal para obter
alguns elementos de informao essenciais (e normalmente curtos). Por
exemplo, voc pode querer obter a senha do usurio  antes de processar o
ncleo do aplicativo. A funo InputBox exibe uma caixa de dilogo de
entrada que se parece assim:
        Eis o exemplo de um fragmento de cdigo que gerou a caixa de
entrada mostrada na ilustrao acima:

        NomeUsurio := InputBoxl'Preciso de seu nome', 'Favor digitar
seu nome', ")

        A sintaxe geral para a funo da caixa de entrada 
        
        StringVariable := InputBox (const: ACaption, APrompt, ADefault:
String)
        
        (As caixas de entrada so funes e assim devolvem valores. Veja
mais a respeito de funes no Captulo 5.)
       O parmetro ACaption  o ttulo da caixa de entrada, o parmetro
APrompt  o texto que voc quer que aparea na caixa para poder fazer
solicitao ao usurio.  Finalmente, o parmetro ADefault  estabelecido
com uma string que voc quer que aparea aparecer pela primeira vez.
Voc pode especificar isso para que no seja nada utilizando ` `. Se o
usurio escolher o boto Cancel. (que  o mesmo que pressionar  ESC),
ento o valor da funo InputBox  a string padro. Se o usurio
escolher o boto OIC, ento o que quer que coloquem na rea de edio
ser o valor da funo.

Funo InputQuery

Essa extenso de uma caixa de entrada simples permite-lhe determinar se
o usurio pressionou o boto OIC ou se pressionou Cancel (ou ESC). A
sintaxe  muito parecida  com aquela de uma funo InputBox.
       
        function InputQuery (const ACaption, APrompt: String; varValue:
String):
       
        O parmetro ACaption e os parmetros APrompt funcionam como
sempre. Nesse caso, porm, o parmetro Value  a string que aparece na
caixa de edio quando  a caixa de dilogo aparecer pela primeira vez.
Entretanto, em virtude da palavra-chave var,  o Delphi muda o parmetro
Value para que seja uma string que reflita o que foi digitado pelo
usurio. Adicionalmente, a funo em si retorna True ou False dependendo
de o usurio ter escolhido OIC ou Cancel (ou ESC). Observe que uma vez
que a funo precisa devolver dois elementos de informao, tem de haver
um parmetro que  possa ser alterado - j que uma funo pode devolver
apenas um valor.

        Para exemplo de como utilizar essa funo, inicie um projeto
novo e acrescente o seguinte procedimento de evento OnClick a ele.
       
        procedure TForm1.OnClick(Sender: Tobject);
        var
             DadoUsurio: string;
             CIickOK: Boolean;
        begin
            DadoUsurio := ;
        CIickOk := InputQuery('Caixa Input Query', 'Pressione OK para
colocar dados',DadoUsurio;
        if OKClicked then
             ShowMessage'Voc digitou ' + DadoUsurio);
        end;

Aplicativos de Vrios Formulrios

At agora, todos os nossos projetos utilizaram um nico formulrio. Esta
seo aborda algumas das tcnicas que voc precisar para criar projetos
de vrios formulrios.

NOTA: Para projetos de vrios formulrios que seguem o formulrio MDI
(interface de vrios documentos), veja o Captulo 12.

        Vamos comear presumindo que voc tem um projeto novo. Abra o
menu File e escolha New Form (ou utilize o boto New Form SpeedBar). A
galeria Form que se  parece com a Figura 4.1, vai abrir. (Se no abrir,
veja a seo Gallery na caixa de dilogo E Use na opo New Form foi
escolhida.) Observe na Figura 4.1 que voc tem vrios modelos ou uma
opo para um formulrio Blank. Independentemente da opo que voc
escolher quando criar um formulrio novo, o Delphi acrescenta outro
arquivo-formulrio (.DFM) e seu mdulo de unidade associada (o arquivo
de cdigo com uma extenso  .PAS). Tambm modifica o arquivo de projeto
para indicar a presena de um formulrio e unidade novos.

NOTA: Voc tambm pode acrescentar um formulrio existente a um projeto.
Para isso, escolha File/Add File (ou utilize o boto Add SpeedBar) para
poder abrir uma  caixa de dilogo que lhe permite escolher o
arquivo-formulrio (.DFM) que deve ser adicionado.

        Quando voc acrescenta um formulrio existente a um projeto, o
Delphi exige que voc acrescente o nome do formulrio  clusula uses de
todas as unidades  que acessam o cdigo ou o formulrio. Entretanto, o
Delphi acrescenta automaticamente as ref

        Para comutar entre formulrios ou entre formulrios e unidades
em um projeto:
        1. Escolha View/Forms (ou utilize o boto Select Form SpeedBar).
        2. Quando a caixa de dilogo View Form aparecer, selecione o
formulrio com o qual deseja trabalhar, e, em seguida, escolha OK.

        Voc tambm ter de comutar entre as unidades de cdigo
associadas aos diversos formulrios. Para isso:
        1. Escolha View/Units (ou escolha o boto Select Unit SpeedBar).
        2. Quando a caixa de dilogo View Unit aparecer, selecione a
unidade com a qual voc quer trabalhar e depois escolha OK.

Salvando Formulrios

Talvez voc queira considerar o salvamento de uma cpia de um formulrio
com um nome diferente. Embora isso cause uma ligeira perda de espao,
facilita a garantia  de voc ter uma cpia de segurana do formulrio.
Como  de se esperar, voc utiliza File/Save As para salvar um
formulrio com um nome ou em um local diferente.  Entretanto, apenas seu
arquivo unitrio (.PAS)  exibido quando voc vai salvar o arquivo. Isso
no  um problema, uma vez que o Delphi salva tanto o formulrio  quanto
seu arquivo unitrio associado ao mesmo tempo.

Salvando um Formulrio como Modelo

Se voc projetou um formulrio complicado e sabe que vai utiliz-lo de
novo, provavelmente vai querer salv-lo como um modelo de formulrio.
Assim que fizer isso,  o Delphi acrescenta seu formulrio configurado 
galeria de formulrios Delphi que aparece quando voc opta por adicionar
um formulrio novo. Para salvar o formulrio atual como um modelo,
assegure-se primeiro de que voc selecionou  o formulrio. Depois:
        1. Escolha Save As Template do SpeedMenu do formulrio. (Isso
abrir a caixa de dilogo Save Form Template.)
        2. Agora, na caixa de edio Title, coloque um nome para o
modelo (voc tambm deveria considerar o acrscimo de uma descrio
resumida desse modelo na  rea Description).

        (Voc tambm pode acrescentar um cone para seu modelo novo
dando um clique no boto Browse e encontrando um mapa de bits de seu
agrado.)

NOTA:  possvel transformar um arquivo de formulrio em um DLL. Veja a
pgina de ajuda on-line em "Building a DLL".

Removendo um Formulrio (e a Sua Unidade Associada) de um Projeto

Pelo fato de o arquivo de formulrio (.DFM) estar sempre ligado ao seu
arquivo de unidade associado, que contm o arquivo de cdigo (.PAS), no
 possvel remover  um sem remover o outro. Quando voc remove um
formulrio de um projeto, o Delphi tambm apaga a referncia ao arquivo
Unit na clusula uses do arquivo Project (.DPR).
        Voc tem duas opes para remover um formulrio e o seu arquivo
Unit associado:
        *Selecione a unidade ou unidades que voc quer remover e escolha
depois o boto Remove na SpeedBar.
        *Selecione a unidade ou unidades que voc quer remover e escolha
depois o boto Remove File SpeedBar.

        (Voc tambm pode selecionar a aba da unidade que voc quer
remover e escolher File/Remove File do menu File. )

Especificando o Formato Principal do Projeto

Quando voc trata com um projeto de vrios formulrios, tem a opo de
escolher qual o formulrio que ser exibido automaticamente quando um
usurio processa o aplicativo.  Isso  chamado de formulrio principal.
Todos os outros formulrios precisam de cdigo para ser exibidos (veja a
seguir).

NOTA: Quando o usurio fecha (por exemplo, utilizando ALT+F4), ou o
prprio programa fecha o formulrio principal, o aplicativo  encerrado.
(Tambm  a melhor  maneira para terminar um projeto que voc est
processando dentro do ambiente de desenvolvimento.) Em outras palavras,
fechar o formulrio principa)  a mesma coisa  que utilizar um cdigo
para chamar Application.Terminate.

        Esse primeiro formulrio que voc cria torna-se o formulrio
principal por padro. Se quiser mudar isso durante o projeto:
                           
        1. Escolha Options/Project para abrir a caixa de dilogo Project
Options (veja a Figura 4.2).
        2. Na pgina Forms, na caixa de lista suspensa Main form,
selecione o formulrio que voc quer que seja o principal, e d um
clique em OK.

Comportamento do Formulrio em Tempo de Execuo

Se voc olhar a Figura 4.2, perceber que h duas caixas: uma est
marcada Auto-create forms e a outra est marcada Available forms.
Qualquer formulrio relacionado  na caixa Auto-create ser criado
("instanciado"  o termo tcnico) durante a execuo. (Veja no Captulo
6 como tratar com formulrios que voc no quer que o Delphi  crie
automaticamente durante a execuo. ) O padro  que todos os
formulrios sejam autocriados.

NOTA: Tambm  possvel criar um formulrio durante a execuo sem que
ele tenha sido acrescentado durante o projeto. Veja no Captulo 6 como
fazer isso.

        Se voc quiser que um formulrio opere com um outro e seus
componentes, adicione o nome de seu arquivo Unit  clusula uses do
formulrio chamador. Voc  mesmo tem de fazer isso, uma vez que o Delphi
no o faz automaticamente. Assim que voc tiver formulrio no cdigo
associado com um outro.
        Por exemplo, vamos supor que voc tenha dois formulrios.
Diremos que eles so designados Forml e Form2, e os arquivos Unit (.PAS)
so denominados Unit 1  e Unit2. Vamos supor tambm que cada um deles
tenha uma caixa de edio (digamos, FormlEditB
       Aqui est o cdigo de que voc precisa na unidade Form2 para
fazer com que o contedo de Form 1 EditBox aparea em Form2 EditBox:
        
        Form2EditBox.Text := Form1.Form1EditBox.Text

        (Lembre-se, porm: a menos que voc tenha acrescentado Unitl 
clusula uses de Unit2, esse cdigo no poder funcionar.)
       Em geral, assim que os formulrios forem informados de que devem
reconhecer um ao outro pela colocao do nome de unidade apropriado em
uma clusula uses,  voc se refere s propriedades do objeto em um
formulrio utilizando o nome do formulrio ju (Como no exemplo acima,
voc no precisa dar um nome de formulrio se estiver escrevendo um
cdigo a respeito dele em seu arquivo Unit.

NOTA: Quando dois formulrios precisam trabalhar com os objetos do
outro, ento voc pode fazer com que o compilador gere um erro de
referncia circular pelo  acrscimo dos dois nomes de unidades 
clusula uses respectiva. Para evitar isso, adicione o nome do outro
formulrio s clusulas uses na seo implementation  de seus
respectivos arquivos Unit.

        (Se a unidade de cdigo no tem uma clusula uses na seo
implementation, voc ter de acrescentar isso tambm. Basta acrescentar
a palavra-chave uses embaixo  da palavra-chave implementation.)
       Observe que, mesmo que um formulrio secundrio seja autocriado
durante o processamento, ele no ser visvel ao usurio at que voc
escreva o cdigo que  o torne visvel. Aqui esto descries curtas dos
mtodos que voc precisa para poder trabal
       Show - Assim que o Delphi tiver criado um formulrio, utilize o
mtodo Show para torn-lo visvel e torn-lo tambm o formulrio ativo.

        Por exemplo, para tornar Form2 (nome da unidade Unit2) visvel
de Form 1:

        *Adicione Unit2  clusula uses de Form 1.
        *Faa o Delphi processar uma linha de cdigo como esta:
Form2.Show.

DICA: Lembre-se tambm de especificar a propriedade FormStyle em
fsStayOnTop se quiser que o formulrio fique sempre por cima.

Hide, Close - O mtodo Hide simplesmente esconde um formulrio. Ele no
o remove da memria. Para isso, utilize o mtodo Close (que tem o mesmo
efeito que escolher  Close do menu da caixa de controle) ou a
simplificao ALT+F4.

Formulrios Modais

Algumas vezes voc precisar tornar um formulrio modal - para que o
usurio no possa mudar para outro formulrio em seu aplicativo sem
trabalhar com o formulrio  modal (por exemplo, voc pode estar
projetando uma caixa de dilogo personalizada).

NOTA: A conveno do Windows  que caixas de dilogo no tm cones na
barra de ttulo e no so redimensionveis.

        (Lembre-se de que para fazer isso a um formulrio voc tem de
mudar os valores das diversas propriedades BorderIcons para False e
mudar a propriedade BorderStyle  para bsDialog.)
        Para tornar um formulrio modal, utilize o mtodo ShowModal em
lugar do mtodo Show. A sintaxe usual 
      
         FormName. ShowModal
       
        Assim que voc tiver tornado um formulrio visvel com esse
mtodo, o usurio tem de interagir com o formulrio. Se ele no fizer o
que  necessrio para  acionar o cdigo que esconde o formulrio, o
formulrio modal permanecer na tela.
        Para realmente fechar um formulrio modal, voc ter de fazer
com que o Delphi mude o valor de sua propriedade ModalResult para um
valor no-zero. Voc pode  fazer isso com cdigo em qualquer
procedimento de evento para o formulrio ou componente  Timer, a maneira
padro para mudar a propriedade ModalResult e fechar o formulrio 
acrescentar botes de comando ao modelo. Em seguida, especifique a
propriedade  ModalResult com o valor apropriado. Por exemplo, com um
boto OIC, voc desejaria especificar a propriedade ModalResult do boto
em mrOIC. Quando o usurio d um  clique em qualquer boto em um
formulrio modal cujo boto ModelResult  especificado para que seja
no-zero (mrOIC, mrCancel, mrAbort, e assim por diante), ento  o Delphi
atribui esse valor  propriedade ModalResult do formulrio - fechando-o.
