Você está na página 1de 124

DELPHI

Delphi 5
Delphi 5

Sumário

INTRODUÇÃO 4
1.1. POR QUE O WINDOWS? ERRO! INDICADOR NÃO DEFINIDO.
1.2. O QUE SÃO AMBIENTES VISUAIS DE DESENVOLVIMENTO? 5
1.3. O QUE É O DELPHI 7
1.4. POR QUE DELPHI? 8
2. O AMBIENTE DE DESENVOLVIMENTO DO DELPHI 9
2.1. A JANELA PRINCIPAL 10
2.2. OS FORMULÁRIOS 12
2.3. O OBJECT INSPECTOR 16
2.4. O EDITOR DE CÓDIGO 23
2.5. CODIFICANDO E COMPILANDO 24
2.6. SALVANDO O PROJETO 26
2.7. TRABALHANDO COM UMA APLICAÇÃO 27
2.8. CRIANDO UMA CONSOLE APPLICATION 30
2.9. CRIANDO UMA APLICAÇÃO GUI 31
2.9.1. CRIANDO E ALTERANDO APLICAÇÃO DEFAULT 32
2.9.2. UTILIZANDO WIZARDS 32
2.10. O ARQUIVO DE PROJETO 33
2.11. MANIPULANDO COM AS OPÇÕES DO PROJETO 35
3. AS UNITS 38
3.1. AS SEÇÕES DE UMA UNIT 38
3.1.1. A SEÇÃO INTERFACE 38
3.1.2. A SEÇÃO IMPLEMENTATION 49
3.1.3. A SEÇÃO INITIALIZATION 50
3.1.4. A SEÇÃO FINALIZATION 51
4. OS FORMULÁRIOS 51
4.1. CRIANDO FORMULÁRIOS 51
4.1.1. NOVOS FORMULÁRIOS 51
4.1.2. CONFIGURANDO O OBJECT REPOSITORY 52
4.2. EXIBINDO FORMULÁRIOS 53
4.2.1. MANIPULANDO COM PROPRIEDADES E MÉTODOS 53
4.2.2. NOMEANDO OBJETOS 54
4.2.3. FORMULÁRIOS MODAIS 55
4.2.4. FORMULÁRIOS NÃO MODAIS 56
4.2.5. FORMULÁRIOS MODAIS VERSUS NÃO MODAIS 57
5. COMANDOS DA LINGUAGEM 58
5.1. INSTRUÇÕES SIMPLES E COMPOSTAS 58
5.2. INSTRUÇÕES CONDICIONAIS 59
5.2.1. IF 59
5.2.2. CASE 60
5.3. ESTRUTURAS DE REPETIÇÃO 61
5.3.1. FOR 61
5.3.2. WHILE 62
5.3.3. REPEAT 62
5.4. COMANDOS DE DESVIO DE FLUXO PADRÃO 63

Página: 1
Delphi 5

5.5. INSTRUÇÃO WITH (“MÉTODO DE TAQUIGRAFIA”) 63


6. MANIPULANDO FORMULÁRIOS 64
6.1. PRINCIPAIS PROPRIEDADES 65
6.2. PRINCIPAIS MÉTODOS 69
6.3. PRINCIPAIS EVENTOS 70
7. COMPONENTES DE INTERFACE 70
7.1. COMPONENTES BÁSICOS DE INTERFACE 70
7.1.1. MENUS 70
7.1.2. BOTÕES 71
7.1.3. LABELS 72
7.1.4. CAIXAS DE TEXTO 73
7.2. MELHORANDO A INTERFACE 74
7.2.1. PANEL (PAINEL) 74
7.2.2. CHECKBOX (CAIXA DE SELEÇÃO) 74
7.2.3. RADIOBUTTON (BOTÃO DE RÁDIO) 74
7.2.4. RADIOGROUP (GRUPO DE BOTÕES DE RÁDIO) 75
8. DEPURANDO APLICAÇÕES 75
8.1. PRINCIPAIS COMANDOS DE PASSO A PASSO 75
8.2. DEPURAÇÃO DESDE O INÍCIO 75
8.3. DA EXECUÇÃO À DEPURAÇÃO 75
8.4. QUANDO FICAR EM LOOP INFINITO OU TRAVAR 75
8.5. MARCANDO PONTOS DE PARADA (INTERRUPÇÃO) 76
8.6. VERIFICANDO VALORES NOS IDENTIFICADORES 76
9. TRATAMENTO DE ERROS (EXCEÇÕES) 77
9.1. BLOCO DE PROTEÇÃO FINALLY 77
9.2. BLOCO DE PROTEÇÃO EXCEPT 77
9.3. BLOCOS ANINHADOS (FINALLY & EXCEPT) 78
10. BANCO DE DADOS EM DELPHI 79
10.1. O QUE É UM ALIAS (APELIDO)? 80
10.1.1. DATABASE DESKTOP 80
10.1.2. TIPOS DOS CAMPOS (PARADOX & DBASE) 81
10.1.3. DATABASE EXPLORE OU SQL EXPLORE 82
10.2. O BANCO DE DADOS DO NOSSO APLICATIVO 83
10.3. RESTRUTURANDO O BANCO DE DADOS 84
10.4. OS COMPONENTES DE BANCO DE DADOS I 85
10.4.1. CONJUNTO DE DADOS (DATASET) 85
10.4.2. ACESSO AO BANCO DE DADOS (DATA ACCESS) 85
10.4.3. TABLE (REPRESENTA UMA TABELA FÍSICA) 86
10.4.4. QUERY (CONSULTA OU VISÃO CONSTRUÍDA VIA SQL) 87
10.4.5. DATASOURCE (INDICA A ORIGEM DE DADOS) 87
10.4.6. MÓDULO DE DADOS (DATAMODULE) 87
10.5. OS COMPONENTES DE BANCO DE DADOS II 88
10.5.1. DBTEXT (ETIQUETA PARA BANCO DE DADOS) 90
10.5.2. DBEDIT (CAIXA DE TEXTO PARA BANCO DE DADOS) 90
10.5.3. DBMEMO (CAIXA DE TEXTO LONGO PARA BANCO DE DADOS) 90
10.5.4. DBIMAGE (ÁREA DE IMAGEM PARA BANCO DE DADOS) 90
10.5.5. DBCHECKBOX (CAIXA DE SELEÇÃO PARA BANCO DE DADOS) 91
10.5.6. DBRADIOGROUP (G. DE BOTÕES DE RÁDIO P/ BANCO DE DADOS) 91
10.5.7. DBNAVIGATOR (NAVEGADOR PARA BANCO DE DADOS) 91
10.5.8. DBLOOKUPCOMBOBOX (SELEÇÃO FECHADA) 91

Página: 2
Delphi 5

10.5.9. DBGRID (GRADE PARA BANCO DE DADOS) 92


10.6. BANCO DE DADOS VIA CÓDIGO 92
10.7. “COM AS MÃOS NA MASSA” 93
10.7.1. CADASTRO DE DADOS GERAIS (DEPARTAMENTOS E CARGOS) 93
10.7.2. CADASTRO DE FUNCIONÁRIO (CONSULTA) 94
10.7.3. QUERY NOME DO CARGO 95
10.7.4. QUERY SIGLA DA UF & QUERY NOME DO DEPARTAMENTO 95
10.7.5. CADASTRO DE FUNCIONÁRIO (INCLUIR & ALTERAR) 96
10.7.6. CADASTRO DE DEPENDENTES 97
10.7.7. FORMULÁRIO DE PESQUISA 97
11. RELATÓRIO EM QUICKREPORT 98
11.1. COMPONENTES QR PRINCIPAIS 98
11.1.1. QUICKREP ( RELATÓRIO RÁPIDO, O PROPRIETÁRIO ) 98
11.1.2. QRBAND ( COMPONENTES FAIXAS/PARTE ) 99
11.2. COMPONENTES QR DE CONTEÚDO CONSTANTE 99
11.2.1. QRLABEL ( TEXTO ESTÁTICO/CONSTANTE ) 99
11.2.2. QRMEMO ( MEMO ESTÁTICO ) 99
11.2.3. QRIMAGE ( IMAGEM CONSTANTE ) 100
11.2.4. QRSHAPE ( FORMAS ) 100
11.3. COMPONENTES QR ESPECIAIS 100
11.3.1. QRSYSDATA ( INFORMAÇÃO DO SISTEMA) 100
11.3.2. QREXPR ( CONSTRUÇÃO DE EXPRESSÃO) 100
11.4. COMPONENTES QR DE BANCO DE DADOS 100
11.4.1. QRDBTEXT ( ACESSA CONTEÚDO NÃO-GRÁFICO) 101
11.4.2. QRDBIMAGE ( ACESSA CONTEÚDO GRÁFICO) 101
11.5. BANDS ESPECÍFICOS 101
11.5.1. QRGROUP (BANDA PARA FORMAÇÃO DE GRUPO) 101
11.5.2. QRCHILDBAND (BANDA FILHA PARA ACOMPANHAMENTO) 101
11.5.3. QRSUBDETAIL (BANDA FILHA PARA ACOMPANHAMENTO) 101
11.6. COMPOSIÇÕES DE RELATÓRIOS 101
11.7. OS RELATÓRIOS DO NOSSO APLICATIVO 102
11.7.1. RELATÓRIO DE CARGOS 102
11.7.2. RELATÓRIO DE DEPARTAMENTOS 103
11.7.3. RELATÓRIOS DE FUNCIONÁRIOS 103
12. ENTREGANDO A APLICAÇÃO 104
12.1. O INSTALLSHIELD EXPRESS 105
12.2. INSTALANDO O INSTALLSHIELD 105
12.3. EXECUTANDO O INSTALLSHIELD PELA PRIMEIRA VEZ 105
12.4. A JANELA PRINCIPAL 107
12.5. AJUSTANDO O VISUAL DESIGN 109
12.6. SELECIONANDO OBJETOS DO INSTALLSHIELD PARA O DELPHI 111
12.7. ESPECIFICANDO COMPONENTES E ARQUIVOS 113
12.8. SELECIONANDO OS COMPONENTES DE INTERFACE COM O USUÁRIO 115
12.9. MUDANDO O REGISTRY 117
12.10. ESPECIFICANDO FOLDERS E ÍCONES 119
12.11. CONSTRUINDO OS DISCOS DE INSTALAÇÃO 120
12.12. TESTANDO A INSTALAÇÃO 121
12.13. DISTRIBUINDO O PRODUTO 121
12.14. CRIANDO MÚLTIPLAS CONFIGURAÇÕES 121
12.15. COMPONENTES 122
12.16. TIPOS DE INSTALAÇÃO 123
12.17. CONCLUSÃO 123

Página: 3
Delphi 5

Introdução

1.1. História
A história da ciência da computação, ao contrário da grande maioria das ciências existentes
atualmente, é bem curta. Apesar dessa ciência não ter uma vida tão longa quanto as demais, a
velocidade com que as mudanças e as descobertas ocorrem são, sem dúvida alguma, muito maiores.
No início da história da computação, devido à pouca tecnologia existente, os computadores eram
bem mais difíceis de se programar. Os programas deveriam ser escritos da forma mais otimizada
possível. Não existia quantidade de memória suficiente para os programas funcionarem o que
tornava a programação de computadores uma verdadeira arte e poucos eram os artistas capazes de
dominar essa arte. A rápida evolução tecnológica fez com que computadores mais poderosos
viessem a surgir, facilitando a vida dos programadores.
Com o advento dos circuitos integrados, computadores cada vez memores e mais poderosos
surgiram no mercado. Os computadores pessoais tornaram-se cada vez mais populares criando um
mercado maior e mais amplo para a programação. Agora não só as grandes empresas tinham
condições de terem computadores para gerenciar seus negócios mas também as pequenas empresas
podiam contar com essa tecnologia.
Com o crescimento do mercado de informática veio o surgimento de novas linguagens de
programação que tinham por objetivo fornecer um ambiente propício para o desenvolvimento de
aplicativos comerciais. A utilização de programas de computador aumentou cada vez. Porém um
problema assustador parecia despontar no horizonte. A variedade de programas existentes no
mercado acabava por acarretar gastos cada vez maiores para as empresas, gastos esses que haviam
diminuído graças aos avanços tecnológicos dos equipamentos de informática (hardware).
Cada programador ou equipe de programadores era responsável pelo desenvolvimento de seu
aplicativo. A escolha da linguagem de programação, o desenho da interface com o usuário e a
própria implementação eram feitas por esses grupos independentemente. Cada programa funcionava
e se apresentava para os usuários de forma independente. Por exemplo, poderíamos ter programas
que, para efetuar a saída do sistema, fosse necessário escolher um item de menu, enquanto que em
outro, essa opção deveria ser efetuada através do acionamento de uma seqüência de teclas de atalho,
como o pressionar das teclas <CTRL> + <S> simultaneamente, por exemplo. Isso era um péssimo
negócio para as empresas que após a escolha e aquisição do programa (software) ainda eram
obrigadas a gastar uma substancial quantia de dinheiro com treinamento de pessoal para a sua
utilização. O gasto era ainda maior caso uma migração entre sistemas fosse necessária. Além dos
gastos naturais com treinamento e aquisição do equipamento, existia um gasto indireto com a
adaptação dos usuários ao novo sistema. Essas dificuldades, principalmente as financeiras,
obrigavam o surgimento de algo que viesse a melhorar essa situação incômoda em que se
encontrava a informática.
Com todos esses problemas em mente, heis que surge um novo ambiente de trabalho no
mercado. Surge o ambiente Windows, da empresa americana Microsoft. Mas o que é que houve de
tão especial com esse ambiente para que ele fosse considerado a salvação para esse verdadeiro caos
em que se encontrava a informática nessa época? Duas palavras “mágicas” são capazes de
responder a essa pergunta: padronização e facilidade de uso. É bem verdade que elas estão bem
relacionadas uma com a outra mas mesmo assim, elas foram as responsáveis por uma verdadeira
reviravolta no ramo da informática. Foi através do Windows que uma quantidade cada vez maior de
pessoas passou a usar o microcomputador. Não só no trabalho, mas também em suas residências as
pessoas passaram a conhecer e tirar proveito da potencialidade da tecnologia que estava em suas
mão.

Página: 4
Delphi 5

Uma interface mais amigável ao usuário passou a ser utilizada. A utilização de telas gráficas ao
invés das tradicionais telas de entrada de texto passou a ser utilizada, eliminando um dos fatores
principais que mantinham as pessoas longe dos computadores, a sua dificuldade de uso. Agora, ao
invés de ter a tarefa de decorar inúmeros comandos que possibilitavam a utilização da máquina, o
usuário poderia operar o microcomputador de forma bem mais intuitiva e simplificada.
A padronização dos programas também foi um outro fator de destaque para a aceitação do novo
ambiente. O Windows seguia um padrão dentro de seus aplicativos e para que novos aplicativos
fossem desenvolvidos para esse ambiente, os padrões também deveriam ser mantidos. Dessa forma,
o gasto com a adaptação a novos produtos seria feita de forma bem mais rápida, simplificada e
eficiente, estimulando assim a venda de produtos para esse novo ambiente. As empresas viam no
Windows a oportunidade de diminuir os elevados custos com o aprendizado de novas ferramentas e
aumentar a sua produtividade. Contudo uma dificuldade passou a existir, desta vez não mais para os
usuários dos computadores, mas sim para os desenvolvedores de software, a dificuldade de
programação.
Programar nesse novo ambiente era bastante complicado. Passa a existir um grande dilema
entre os programadores: continuar utilizando as linguagens mais antigas, mais simples de
programar mas que, no entanto, não seguiam qualquer tipo de padronização e que, pouco a pouco,
vinham perdendo espaço no mercado para os aplicativos desenvolvidos para o ambiente Windows
ou mudar para o desenvolvimento de aplicativos que seguissem a padronização que estava
conquistando as empresas mas que, com relação à tarefa de programação, era bem mais difícil e
complexa e que, por conseqüência, mais cara para se desenvolver.
Os analistas de sistemas e os programadores começaram a optar, mesmo com todas as
dificuldades, por desenvolver aplicativos para o ambiente Windows. Para a felicidade de todos, as
grandes empresas desenvolvedoras de linguagens de programação perceberam as dificuldades
existentes nesse processo. Gigantes como a Borland (atual Inprise Corporation) e a própria
Microsoft começaram a procurar desenvolver novas ferramentas de programação que viessem
propiciar, de forma mais simplificada, o desenvolvimento de software para o ambiente Windows da
mesma forma como haviam feito com os ambientes Turbo para o sistema operacional DOS.
Várias ferramentas têm sido colocadas, nos últimos anos, à disposição dos programadores
aumentando bastante o desenvolvimento de software para o ambiente Windows. Com o lançamento
do Microsoft Visual Basic, um dos Ambientes Visuais de Desenvolvimento pioneiros, um aumento
substancial de softwares produzidos foi observado. Outras empresas procuraram seguir o exemplo
da Microsoft lançando seus próprios Ambientes Visuais de Desenvolvimento para o ambiente
Windows. Contudo, o que são esses tais Ambientes Visuais de Desenvolvimento que tomaram toda
a industria de desenvolvimento de software? A resposta para essa pergunta daremos a seguir.

1.2. O que são Ambientes Visuais de Desenvolvimento?


No início do desenvolvimento de software para o ambiente Windows, uma das grandes
dificuldades existentes era o do desenvolvimento das interfaces. O programador via-se no meio de
uma quantidade muito grande de código para que uma simples janela do Windows fosse exibida.
Imagine então, o sacrifício que era necessário para o desenvolvimento do restante da interface
como, por exemplo, a colocação de botões e caixas de edição de texto. Além da dificuldade
existente com a simples colocação desses objetos (posteriormente nesta apostila trataremos do
estudo dos conceitos básicos de Orientação a Objetos, o que tornará claro o entendimento do que
seja um objeto) também chamados de controles, nas janelas do programa, ainda havia-se a
necessidade de seu alinhamento dentro delas. Após cada tentativa de arrumação, o programador
necessitava de uma nova compilação e execução do programa para verificar se as alterações no

Página: 5
Delphi 5

código fonte provocaram o efeito desejado. Ao final desse imenso trabalho de estruturação da
interface, centenas, ou até mesmo, milhares de linha de código haviam sido escritas para que tudo
estivesse de acordo com o planejado pela equipe de programadores visuais responsáveis pelo
projeto da interface. Tendo como um de seus objetivos facilitar todo esse processo de
desenvolvimento de software, responsável muitas vezes por grande parte do tempo gasto durante o
desenvolvimento, surgiram os chamados Ambientes Visuais de Desenvolvimento.
A grande popularidade desses ambientes veio do fato de que eles vieram a permitir o
desenvolvimento de programas simples e complexos com pouco, ou até mesmo nenhum, esforço de
programação. A dificuldade com o desenvolvimento das interfaces para os programas
desenvolvidos para o ambiente Windows praticamente deixou de existir. Para o programador,
deixou de existir a necessidade de conhecer, entre outras coisas, uma variedade de comandos para o
posicionamento dos diversos objetos que deveriam ser colocados nas janelas do Windows.
Agora, para o programador, o desenvolvimento da interface seria feito de forma tão simples
quanto se ele estivesse desenhando a interface em sua própria janela. O desenho da interface é feito
colocando-se os componentes desejados nas janelas e ajustando suas propriedades como, por
exemplo, sua largura e altura, de tal forma que a interface tome o aspecto desejado sem a
necessidade de qualquer codificação por parte do programador. Por esse motivo, alguns autores
chamam esse tipo de desenvolvimento rápido de interfaces de WYSIWYG, sigla originária do
inglês What You See Is What You Get, que significa “O que você vê é o que você obtém”,
referenciando justamente a forma de desenvolvimento das interfaces nessas Ambientes Visuais de
Desenvolvimento. Devido a grande facilidade com que as interfaces dos aplicativos passaram a ser
desenvolvidas, uma grande parte do tempo gasto no seu desenvolvimento passou a ser
economizado. Por esse motivo, alguns autores chamam esse tipo de ambiente de desenvolvimento
de aplicações de RAD, que significa Rapid Application Development, do inglês “Desenvolvimento
Rápido de Aplicações”. A utilização desses ambientes diminui consideravelmente o tempo e,
principalmente, o custo de desenvolvimento de aplicações.
Como conseqüência dessas facilidades e praticidade de desenvolvimento de aplicações para o
ambiente Windows, é cada vez maior a procura e a aceitação de Ambientes Visuais de
Desenvolvimento como o Microsoft Visual Basic (um dos pioneiros), o PowerBuilder, o Centura
(antigo SQL Windows), além, é claro, do próprio Delphi.
Devemos observar que o simples fato do desenvolvimento da interface da aplicação não
finaliza a tarefa do desenvolvimento. Resta ainda ao programador escrever o código que deverá ser
executado quando o usuário tomar determinadas ações como, por exemplo, pressionar o botão de
saída do programa.
Sob esse novo modelo de desenvolvimento, os programas passam a ser desenvolvidos através
de um novo ponto de vista. Os programas passam a ser formados por objetos que vão sendo
colocados em suas janelas (trataremos do conceito de objetos posteriormente nesta apostila), pelo
ajuste de suas propriedades, para que esses objetos tenham as características desejadas pelos
desenvolvedores, e pelos eventos aos quais esses objetos irão responder isto é, as possíveis ações
realizadas pelos usuários do sistema ou pelo próprio sistema, como por exemplo, o clicar do mouse
sobre um botão.
A utilização desse novo modelo é, por muitas vezes, a parte mais difícil no processo de
migração do desenvolvimento de programas das antigas linguagens procedurais para os novos
ambientes de desenvolvimento baseados em eventos. O programador não pode mais supor uma
ordem exata na execução do seu código fonte e deve passar a tratar isoladamente cada evento
relevante de sua aplicação.

Página: 6
Delphi 5

Por exemplo, suponhamos um programa de banco de dados que possua um cadastro de clientes.
Nesse programa temos uma tela onde o usuário do sistema deverá cadastrar cada cliente que irá
pertencer ao banco de dados da aplicação. Nos sistemas mais antigos, não baseados no ambiente
Windows, o preenchimento de cada campo era feito de forma seqüencial, verificando-se facilmente
se o valor para cada um deles estava sendo colocado corretamente. Além disso, a verificação de
campos de preenchimento obrigatório era facilmente efetuada uma vez que, para chegar ao local de
confirmação da inclusão, o usuário deveria ter passado por todos os campos da tela de cadastro,
preenchendo-os corretamente. Contudo, com o desenvolvimento de aplicativos para o ambiente
Windows, não podemos mais fazer tais suposições. Agora, na janela de cadastro de clientes, o
usuário não é mais obrigado a pressionar o botão de confirmação de inclusão de um novo cliente
apenas após o total preenchimento de seus campos. Cuidados adicionais devem ser tomados para
que isso não ocorra. Um outro exemplo bastante simples e que ocorre com freqüência cada vez
maior em nosso dia-a-dia está no próprio encerramento do programa. A maneira mais corriqueira de
se finalizar um aplicativo por parte do usuário é através da escolha de uma opção de saída existente
na aplicação. Porém, qualquer usuário poderia finalizar o aplicativo através de um clique no ícone
de sistema localizado no canto superior direito das janelas da aplicação. Um usuário mais
experiente do ambiente Windows poderia também pressionar as teclas de atalho ALT + F4
provocando o fechamento da janela da aplicação. Em cada um desses três casos, é função do
desenvolvedor fornecer o mesmo tratamento para cada uma dessas ações do usuário.
Pudemos ver que os programas não irão mais seguir aquela ordem linear de execução que
programas mais antigos seguiam, mas sim uma execução baseada em eventos. A ordem de
execução do programa irá seguir a ordem dos eventos que cada usuário do aplicativo desejar.
Devemos perceber que, internamente ao tratamento de cada evento, a execução das instruções
contidas no código do programa ainda continua, de certa forma, linear porém, a escolha de qual
desses códigos ou seja, a execução dos eventos por parte do usuário do aplicativo, a ser executado é
que não é mais linear.
Mesmo com essa aparente dificuldade, o desenvolvimento de aplicações através de tais
ambientes é, e continuará a ser durante muito tempo, o método mais rápido e eficiente de
desenvolvimento de aplicações para o ambiente Windows.

1.3. O que é o Delphi


Como mencionado, o Delphi é um Ambiente Visual de Desenvolvimento colocado no mercado
pela empresa americana Borland, atualmente chamada Inprise. O Delphi tornou-se uma verdadeira
febre dentre os programadores de aplicativos espalhados por todo o mundo devido as suas inúmeras
vantagens em relação à outras linguagens de programação para o ambiente Windows como, por
exemplo, o Microsoft Visual Basic. Através da utilização da linguagem Object Pascal, linguagem
esta oriunda do Pascal porém fornecendo suporte à programação orientada a objetos, o Delphi
possibilita a criação rápida de aplicativos para o ambiente Windows, ou seja, o Delphi é uma
ferramenta RAD para o ambiente Windows.
Porém, como toda ferramenta que se apresenta como um meio para facilitar o desenvolvimento
de novos aplicativos, o Delphi tem sua contrapartida com relação a todas essas vantagens. O
equipamento necessário para a instalação e execução do Delphi é bem mais robusto do que as
antigas linguagens de programação como C/C++ e versões anteriores do Pascal e do próprio Object
Pascal. Para a instalação do Delphi 5.0, dependendo de qual versão esteja sendo instalada
(Standard, Professional ou Enterprise) se faz necessário o seguinte equipamento (no caso da versão
Enterprise):
• Computador com processador Pentium 90 ou superior

Página: 7
Delphi 5

• Sistema operacional Windows 95, 98 ou Windows NT com Service Pack 3


• 32MB de memória RAM para a versão cliente/servidor
• 80MB livres no disco rígido (230MB para a instalação completa da versão)
• Drive CDROM
• Monitor VGA
• Mouse
É importante observar que a versão 1.0 do Delphi é perfeitamente compatível com o sistema
operacional Windows 95/98 apesar de gerar código de 16 bits para os aplicativos com ele
desenvolvido. Já as versões 2.0 à 5.0 do Delphi não são compatíveis com as versões anteriores ao
sistema operacional Windows 95 por gerar código de 32 bits para os seus aplicativos. Deve-se,
portanto, ter em mente qual a plataforma para a qual será desenvolvido os aplicativos na hora de se
escolher qual a versão do Delphi que se deseja instalar.

1.4. Por que Delphi?


Vimos na seção anterior que o ambiente de programação Delphi utiliza, para a escrita de
código fonte, a linguagem chamada Object Pascal. A linguagem de programação chamada Object
Pascal, que será vista posteriormente nessa apostila, nada mais é do que uma versão da já conhecida
linguagem Pascal, porém com suporte à programação orientada a objetos. Mas então por que
chamar este novo ambiente de Delphi ao invés de utilizar, por exemplo, o nome Object Pascal
versão X.X?
Muitos afirmam que essa mudança se deu por motivos financeiros e, principalmente, por
motivos “psicológicos”. A linguagem Pascal foi, por muito tempo, considerada uma linguagem
utilizada para o ensino de práticas de programação e que, por esse motivo, seus compiladores
haviam sido desenvolvidos de tal forma a gerar código executável pouco eficiente. Esse rótulo
perseguiu as diversas versões do Pascal por muitos anos. Os programadores apesar de conhecerem a
linguagem Pascal, ensinada na maioria dos cursos de Ciência da Computação, não se aventuravam a
programar comercialmente nessa linguagem devido à pouca eficiência de seu código executável.
A Borland, ao desenvolver seu novo ambiente de desenvolvimento utilizando uma nova versão
para a linguagem Pascal, chamada Object Pascal, decidiu utilizar um nome que não lembrasse em
nada a antiga, e pouco atrativa, linguagem Pascal. Essa estratégia trouxe bons resultados. O novo
ambiente incorporou melhorias em relação às versões anteriores do Pascal como, por exemplo,
geração de código executável bem mais eficiente, utilização de uma linguagem Orientada a Objetos
seguindo o mesmo padrão de vários outros Ambientes Visuais de Desenvolvimento. Qualquer
programador acostumado, por exemplo, a desenvolver seus aplicativos em Visual Basic não teria a
menor dificuldade de iniciar seu desenvolvimento em Delphi. Além disso, o Delphi trazia consigo
uma vantagem em relação aos demais ambientes, utilizava como linguagem de programação o
Object Pascal, bastante semelhante à linguagem Pascal conhecida pela grande maioria dos
programadores.
Desta forma, as software houses economizariam em treinamento aos seus profissionais,
beneficiando a todos. Os programadores agora possuíam um ambiente veloz e eficiente que
permitiria o desenvolvimento rápido de aplicativos e as empresas economizariam em gastos com o
treinamento de seus programadores em uma nova linguagem de programação.

Página: 8
Delphi 5

2. O Ambiente de Desenvolvimento do Delphi


O Delphi, conforme citado anteriormente, ao contrário do que muita gente pensa, é um
Ambiente Visual de Desenvolvimento e não uma linguagem de programação. Não existe, como dito
erroneamente por muitos, a linguagem de programação chamada Delphi, mas sim um Ambiente
Visual de Desenvolvimento que foi chamado de Delphi. Já esse ambiente utiliza a linguagem de
programação chamada Object Pascal. Dessa forma, iremos iniciar nosso estudo de Delphi através de
seu Ambiente de Desenvolvimento, também chamado de IDE, do inglês Integrated Development
Environment, passando posteriormente ao estudo da linguagem de programação Object Pascal.
Após o término da instalação do Delphi, podemos iniciar a sua IDE através do ícone Delphi 5
localizado na pasta Borland Delphi 5 como ilustrado na figura a seguir.

Uma vez inicializada a IDE do Delphi surgirão, inicialmente, 4 janelas que irão permitir ao
desenvolvedor trabalhar e desenvolver suas aplicações no Delphi, como ilustra a figura abaixo.

Barra de Barra de Título


Atalho e Menus

Paleta de
Componentes

Object
Inspector Formulário

Editor de Código

Existem ainda outras janelas que poderiam ser exibidas dentro da IDE do Delphi dependendo
das configurações definidas pelo desenvolvedor, porém as 4 janelas exibidas acima constituem a
instalação e configuração básicas do Delphi. Antes de aprendermos a linguagem Object Pascal

Página: 9
Delphi 5

devemos nos familiarizar com o ambiente no qual iremos trabalhar, ou seja, devemos aprender
como manipular a IDE do Delphi. Dessa forma, veremos cada uma das janelas que compõe a IDE
mais detalhadamente a seguir.

2.1. A Janela Principal


A janela principal da IDE do Delphi é dividida em 3 partes, são elas: a Barra de Título e
Menus, a Barra de Ferramentas e a Paleta de Componentes. Apesar de termos essas divisões,
apenas a primeira é necessária para que a IDE do Delphi esteja em execução, podendo as duas
outras, a Barra de Atalho e a Paleta de Componentes, bem como todas as demais janelas citadas
anteriormente, estarem ocultas, de acordo com a vontade do desenvolvedor. Comecemos, então,
nossa exploração pela IDE do Delphi através de sua Barra de Título e Menus.
Na Barra de Título e Menus encontramos todas as opções que o desenvolvedor necessitará para
a utilização do ambiente do Delphi. Através dos diversos menus aí localizados, o desenvolvedor
poderá criar novas aplicações, dar manutenção em aplicações previamente desenvolvidas, além de
configurar todo o seu ambiente de trabalho de acordo com a sua forma de programação. Veremos os
principais itens de menu existentes na janela principal a medida em que formos utilizando a IDE do
Delphi.
A Barra de Ferramentas, também chamada de Barra de Atalhos, localizada do lado inferior
esquerdo da janela principal é utilizada para acessar as funções mais freqüentemente utilizadas pelo
desenvolver Delphi. Nela encontramos opções tais como a abertura e salva de arquivos de código-
fonte Object Pascal, compilação, execução e depuração de programas, entre outras.
É importante observarmos dois pontos com relação a Barra de Ferramentas. O primeiro é que
ela contém opções que também estão à disposição do desenvolvedor através de itens de menus,
permitindo no entanto, um acesso mais rápido a elas. O segundo ponto, como dito anteriormente, é
que ela não precisa estar visível para que a IDE do Delphi esteja ativa. Para ocultarmos a Barra de
Ferramentas basta clicarmos com o botão secundário do mouse sobre
ela fazendo surgir na tela um menu Popup. Nesse menu existirá
diversos itens que permitem ao desenvolvedor ocultar ou não as
diversas barras que compõe a Barra de Ferramentas, conforme ilustra a
figura ao lado.
Através do menu Popup mostrado ao lado, podemos deixar ou não
visíveis cada um dos 6 grupos de botões da Barra de Ferramentas do
Delphi, além da Paleta de Componentes que será vista a seguir. Esse
menu Popup poderá também ser selecionado através do menu View -> Toolbars localizado na
janela principal do Delphi.
A IDE do Delphi permite ainda que a Barra de Ferramentas possa ser configurada de acordo
com as necessidades do desenvolvedor. Isso poderá ser feito através do menu Customize mostrado
na figura anterior. Ao selecionarmos essa opção será exibida a caixa de diálogo Customize como
mostrado na figura a seguir.
Através dessa caixa de diálogo o desenvolvedor
poderá definir também quais componentes da Barra de
Ferramentas estarão visíveis, através das opções
localizadas na página Toolbars, bem como colocar e
remover itens da Barra de Ferramentas e configurar
algumas opções de exibição para esses componentes,
como por exemplo, a exibição ou não dos Hints
(pequenos textos explicativos) que aparecem nos

Página: 10
Delphi 5

componentes a medida em que passamos o mouse por sobre eles.


O processo para adicionar ou remover um elemento da Barra de Ferramentas é bastante
simples. Na página Commands da caixa de diálogo Customize estão listados os menus existentes na
IDE do Delphi, bem como seus respectivos itens de menu. Para adicionarmos um desses itens basta
que cliquemos no item desejado arrastando-o para o grupo de botões da Barra de Ferramentas no
qual desejamos colocá-lo. Feito isso basta soltarmos o elemento para que ele apareça na posição
desejada. Um processo simples de Drag and Drop bastante comum na maioria dos aplicativos
desenvolvidos para o ambiente Windows. A remoção de um elemento é feita de forma ainda mais
simples. Para retirarmos um elemento basta arrastarmos esse elemento para fora da Barra de
Ferramentas, ou seja, o processo inverso ao realizado quando colocamos o item na Barra de
Ferramentas. Um fato ao qual devemos atentar é que esse processo deverá ser realizado com a caixa
de diálogo Customize sendo exibida na tela.
Por fim temos, na Janela Principal do Delphi, a Paleta de Componentes. Este elemento é um
dos mais importantes da IDE do Delphi, uma vez que, é na Paleta de Componentes que se
encontram os vários objetos que irão compor as aplicações que serão por nós desenvolvidas como,
por exemplo, os botões, caixas de texto e elementos de acesso à banco de dados. A Paleta de

Componentes do Delphi é mostrada a seguir.

Como podemos observar, a Paleta de Componentes é dividida em várias guias (Standard,


Additional, Win32, etc.), cada uma das quais contendo diversos componentes de acordo com suas
funções. Por exemplo, na guia Standard encontramos componentes padrões dentro de uma
aplicação Windows tais como botões e caixas de texto, entre outros. Já na guia Data Access,
encontramos componentes responsáveis pelo acesso de nossa aplicação aos dados contidos nos
vários bancos de dados com o qual o Delphi pode trabalhar. No canto superior direito da Paleta de
Componentes estão localizados dois botões que possibilitam a navegação dentro da Paleta de
Componentes permitindo assim a visualização das demais guias da Paleta de Componentes. No
caso ainda da guia que esteja sendo exibida naquele momento possuir uma quantidade maior de
componentes do que aquela que pode ser visualizada dentro da Paleta de Componentes, serão
habilitados dois botões, do lado direito e esquerdo da Paleta, responsáveis pela visualização dos
demais componentes contidos na guia selecionada.
Através da Paleta de Componentes o desenvolvedor poderá colocar os componentes
selecionados na aplicação que ele esteja desenvolvendo. Podem ser utilizados não só componentes
originários do Delphi bem como desenvolvidos por terceiros. Ou seja, dentro do Delphi podemos
utilizar dentro de nossas aplicações componentes disponibilizados na Paleta de Componentes pela
própria instalação do Delphi, mas também podemos instalar novos componentes e utilizá-los no
desenvolvimento de nossas próprias aplicações. Dessa forma, vemos que podemos desenvolver não
só aplicações, mas também componentes que poderão ser utilizados não apenas por nós mesmos,
mas por outros programadores em Delphi ou em outras linguagens de programação. O
desenvolvimento de novos componentes é uma atividade praticada por muitos programadores como
forma principal de comercialização de seus produtos deixando, muitas vezes, em segundo plano o
desenvolvimento de “aplicações comerciais”.
Como conseqüência dessa possibilidade de instalação de novos componentes podemos, dentro
do Delphi, configurar a Paleta de Componentes para que, entre outras coisas, ela possua novas guias
que contenham esses componentes a serem instalados. É bem verdade que na maioria das

Página: 11
Delphi 5

instalações de novos componentes, a própria instalação se encarrega de criar as páginas em que


esses componentes serão instalados, porém esse fato não invalida a possibilidade do desenvolvedor
desejar criar novas páginas dentro da Palete de Componentes de tal forma a organizar a IDE do
Delphi à sua própria forma de programar. Uma das maneiras pela qual podemos configurar a Paleta
de Componentes é através do menu popup por ela exibido como mostrado a seguir.
Através desse menu popup, temos a opção de permitir ou não a
exibição de Hints (dicas contendo o nome de cada um dos
componentes) para os componentes da Paleta da mesma maneira como
visto com a Barra de Ferramentas, além da possibilidade de ocultar a
própria Paleta de Componentes. Essa última opção já havia sido
mencionada anteriormente quando vimos o menu popup da Barra de Ferramentas. Existe ainda a
possibilidade de solicitarmos o apoio do Help. A utilização do Help é um ponto que devemos
sempre ressaltar por se tratar de uma fonte muito importante de informação, talvez não tanto com
relação ao menu popup mostrado aqui mas em diversos outro pontos principalmente como auxílio à
própria programação. Dentre os itens do menu popup mostrado ao lado, sem dúvida alguma a que
mais irá nos interessar é a opção que nos permite alterar as propriedades da Paleta de Componentes.
Essa opção também pode ser selecionada através da opção Configure Pallete, localizada no menu
Component.
A caixa de diálogo Pallete Properties, mostrada ao lado, permite que o desenvolvedor
configure a Paleta de Componentes de acordo com as suas
necessidades e preferências. O desenvolvedor poderá criar novas
guias para conter tanto novos componentes quanto para
redistribuir aqueles já existentes, através de uma simples operação
de Drag and Drop entre as guias de origem e destino. Além disso,
o desenvolvedor poderá remover e renomear as guias já existentes
ou, simplesmente, reordenar os componentes em suas respectivas
guias. Quando desejarmos remover uma guia deveremos ter
cuidado, pois ao selecionarmos o botão Remove, o Delphi não
solicita uma confirmação a respeito dessa remoção. Caso
desejemos restaurar a configuração original podemos clicar o
botão Default Pages, visível apenas quando selecionamos a opção [All] localizada no ListBox
Pages. Devemos ainda lembrar que ao redistribuirmos os componentes dentro das guias da Paleta
de Componentes estamos alterando a configuração original do Delphi para atender às nossas
necessidades. Essa alterações estão sendo feitas apenas em nosso ambiente de trabalho e não
estarão disponíveis quando prescisarmos utilizar uma outra instalação para continuarmos o
desenvolvimento de nossos aplicativos. O mesmo devemos ter em mente quando utilizamos
componentes de terceiros.

2.2. Os Formulários
A grande maioria das aplicações desenvolvidas para o sistema operacional Windows,
excetuando-se em alguns casos, por exemplo, as DLLs ou aplicativos desenvolvidos para trabalhar
em modo “DOS”, é composta de uma ou mais janelas, também chamadas de formulários. Dessa
forma, como não poderia deixar de ser, a grande maioria das aplicações que iremos desenvolver
serão compostas de um ou vários formulários. Em aplicações que possuam mais do que um
formulário, devemos observar que existirá sempre um formulário responsável pela execução da
aplicação. Enquanto esse formulário permanecer “aberto”, nossa aplicação permanecerá em
execução. Esse formulário é chamado de formulário principal da aplicação e, devido ao papel

Página: 12
Delphi 5

diferenciado que ele exerce sobre a aplicação, deverá receber uma atenção especial por parte dos
programadores para o ambiente Windows.
Ao iniciarmos o ambiente de desenvolvimento do
Delphi, nos é apresentado um formulário inicial, em
geral não contendo qualquer componente como
mostrado na figura. Esse formulário inicial é
exatamente o formulário principal dessa nova
aplicação, porém essa característica do formulário
poderá ser alterada posteriormente com o decorrer do

desenvolvimento do aplicativo (veremos como alterar o formulário principal de nossa aplicação


posteriormente). Ao darmos início ao processo de desenvolvimento das aplicações iremos colocar
em cada formulário os diversos componentes que irão compor tanto a sua interface, como por
exemplo, botões e menus, quanto iremos definir os procedimentos a serem executados por cada um
desses componentes como, por exemplo, o que será executado quando clicarmos em um
determinado item de menu. Todo esse processo é realizado em diversas etapas, todas elas
importantíssimas no desenvolvimento de aplicações para o ambiente Windows. A primeira delas é a
colocação dos componentes em cada um dos formulários da aplicação. Os componentes podem ser
colocados nos formulários de várias maneiras, veremos algumas delas a seguir.
A maneira mais simples de colocarmos um componente em um formulário é darmos um duplo
clique sobre o componente desejado na Paleta de Componentes. Por exemplo, caso desejemos
colocar um botão, localizado na guia Standard, no formulário podemos dar um duplo clique sobre
esse componente. Ao fazermos isso, um botão será colocado no centro do formulário seguindo a
largura e altura padrão definidos para um botão.
Embora essa seja a maneira mais simples de colocarmos um componente em um formulário,
essa não é a mais usual. Em geral, colocamos os componentes no formulário clicando no
componente desejado na Paleta de Componentes e, em seguida, clicando no formulário. Ao
fazermos isso, diferentemente do que acontecia anteriormente, o componente é colocado, ainda com
largura e altura padrão, no formulário porém não mais na posição central do formulário mas sim na
posição aonde o mouse foi clicado. De forma bastante semelhante, podemos colocar um
componente definindo uma nova altura e largura. Para isso basta que cliquemos no componente
desejado na Paleta de Componentes e, ao clicarmos no formulário permaneçamos com o botão do
mouse pressionado, arrastando-o até o tamanho desejado. Existem, no entanto, alguns componentes
que não permitem alterar suas dimensões conforme mostraremos mais adiante.
Devemos observar dois pontos importantes com relação aos componentes existentes na Paleta
de Componentes. O primeiro deles é que nem todos os componentes que colocamos nos formulários
das nossas aplicações serão visíveis aos usuários durante a execução do aplicativo, ou seja, existem
dois tipos de componentes: aqueles que são visíveis tanto em tempo de desenvolvimento quanto em
tempo de execução e aqueles que só estão visíveis durante o desenvolvimento da aplicação. Esses
últimos, chamados de componentes não-visuais não permitem que suas dimensões sejam alteradas.
Esse comportamento é perfeitamente compreensível uma vez que esses componentes não serão
exibidos no formulário durante a execução da aplicação e por isso não faz sentido podermos
dimensioná-los. O segundo ponto a observarmos é que, a cada componente que colocamos no
formulário, o Botão de Seleção (aquele com o desenho de uma seta, localizado na Paleta de
Componentes) torna-se o botão ativo indicando que podemos manipular com o componente
correntemente selecionado.

Página: 13
Delphi 5

Uma outra maneira pela qual podemos colocar componentes em um


formulário é através da seleção da opção Component List, localizada no menu
View. Ao selecionarmos essa opção será exibida a caixa de diálogo
Components como mostrado na figura ao lado. Através dessa caixa de
diálogo podemos selecionar o componente que desejamos colocar no
formulário e, logo em seguida, clicarmos o botão Add to Form. Essa opção é
idêntica a primeira opção que mencionamos sobre como colocar um
componente no formulário, ou seja, o componente é colocado no centro do
formulário possuindo largura e altura padrão. Essa opção pode ser útil
quando sabemos o nome do componente, mas não sabemos em qual guia da
Paleta de Componentes ele está localizado, tornando mais rápida a busca através de seu nome ao
invés de sua localização.
Imaginemos agora que estamos desenvolvendo uma tela de cadastro qualquer. É bastante
provável que nesse formulário seja necessário colocar várias caixas de texto e botões. A tarefa de
colocar esses componentes é bastante trabalhosa uma vez que tenhamos de ir colocando, um a um,
os diversos componentes no formulário. Esse é o comportamento do Delphi que após colocarmos
um componente qualquer no formulário volta a ter o Botão de Seleção selecionado. Nessas
situações o ideal seria que pudéssemos escolher o componente que queremos colocar no formulário
e fôssemos colocando-o quantas vezes quiséssemos sem que tivéssemos de selecioná-lo novamente
na Paleta de Componentes. Para a nossa felicidade isso é perfeitamente possível. Para tanto basta
que, mantendo a tecla Shift pressionada, selecionemos na Paleta de Componentes o componente que
desejamos colocar repetidamente no formulário. Ao fazermos isso, o botão da Paleta de
Componentes é selecionado, passando a ter uma cor levemente azulada como mostrado na figura
abaixo, indicando que podemos colocar quantos componentes desejarmos no formulário.
Uma vez selecionado, o componente permanecerá selecionado até que um outro componente
seja selecionado ou que o Botão de Seleção torne-se o botão selecionado na Paleta de
Componentes.
Uma vez colocados os componentes no formulário, resta ao programador a tarefa de
dimensioná-los e alinhá-los de forma a dar uma melhor aparência à sua aplicação, caso isso já não
tenha sido feito no momento da colocação desses componentes no formulário.
O dimensionamento dos componentes, como visto anteriormente, pode ser feito tanto no
momento de sua colocação no formulário quanto posteriormente a ela. A maneira mais comum de
dimensionarmos os componentes após a sua colocação
no formulário é feita da seguinte maneira: devemos
selecionar o componente que desejamos manipular e
utilizando o mouse devemos clicar e arrastar um dos
oito pequenos quadrados de dimensionamento
existentes ao redor do componente como mostrado na
figura ao lado. Essa forma de redimensionar
componentes é utilizada, principalmente, quando nós
estamos manipulando com apenas um único
componente. Quando, no entanto, temos mais de um
componente que desejamos redimensionar
simultaneamente para deixá-los, por exemplo, com o mesmo tamanho, podemos utilizar a caixa de
diálogo Size, mostrada abaixo. Essa caixa de diálogo é exibida tanto através da opção Size contida
no menu Edit quanto através da opção Size contida no menu popup exibido ao clicarmos com o
botão secundário do mouse no componente desejado.

Página: 14
Delphi 5

Uma observação deve ser feita com relação ao


dimensionamento dos componentes utilizando-se a caixa de
diálogo Size. Apesar de podermos utilizá-la para
redimensionar um único componente (para isso podemos
utilizar a opção Width e Height), a caixa de diálogo Size será
utilizada com maior freqüência quando estivermos trabalhando
com vários componentes simultaneamente.
Para selecionarmos múltiplos componentes devemos clicar no primeiro componente que
desejamos manipular selecionando-o assim e, em seguida, mantendo a tecla Shift pressionada,
devemos clicar nos demais componentes que serão manipulados. Uma outra forma de
selecionarmos múltiplos componentes é através da definição de uma área de abrangência. Para isso,
o desenvolvedor deverá clicar com o mouse em uma região do formulário e, em seguida, mantendo
o botão primário do mouse pressionado, arrastar o mouse demarcando a área cujos componentes
nela contidos deverão ser selecionados. Após a delimitação da área desejada devemos liberar o
botão primário do mouse para que, dessa maneira, os componentes sejam marcados como
selecionados. Uma vez que tenhamos selecionado os componentes, as opções da caixa de diálogo
Size poderão ser aplicadas a eles tanto com relação à altura quanto ao comprimento desses
componentes. Uma vez que sabemos como marcar vários componentes resta-nos saber como
desmarcá-los, para tanto basta clicarmos em qualquer outro componente que não esteja marcado,
tornado assim esse último o componente selecionado.
Além da tarefa de redimensionar os componentes, resta ao desenvolvedor alinhá-los para dar
uma melhor aparência ao seu programa. Para isso, da mesma forma como fizemos para
redimensionar os componentes colocados no formulário, poderemos simplesmente clicar sobre os
componentes selecionando-os e, em seguida, arrastá-los até a posição desejada, ou poderemos
utilizar as ferramentas do Delphi para isso.
Em geral, a tarefa de alinhar os componentes no formulário não é tão difícil devido à existência
do grid. O grid nada mais é do que os vários pontos existentes nos formulários exibidos na IDE do
Delphi. O comportamento default para os componentes é o seu auto-alinhamento em relação aos
pontos do grid, ou seja, ao redimensionarmos ou arrastarmos os componentes pelo formulário eles
irão sempre se posicionar de acordo com os pontos do grid
facilitando, dessa forma, o trabalho do programador.
Mesmo assim, existirão situações em que a tarefa não será
tão simples como, por exemplo, caso desejemos centralizar
alguns componentes no formulário. Apesar de podermos
tentar fazer isso de forma “visual”, não será difícil
errarmos por uma diferença de um ou dois pontos do grid.
Para evitarmos que isso aconteça, poderemos recorrer às
ferramentas de alinhamento que o Delphi nos oferece.
A primeira caixa de diálogo que poderemos utilizar para alinhar os componentes é a caixa de
diálogo Alignment, mostrada ao lado, obtida através da opção Align selecionada a partir do menu
popup exibido ao clicarmos sobre um componente de nosso formulário. Essa caixa de diálogo é
bastante semelhante à caixa de diálogo Size mostrada anteriormente. Nela podemos escolher qual o
tipo de alinhamento que desejamos aplicar aos componentes selecionados tanto com relação a sua
horizontal quanto a sua vertical. Novamente percebemos que a maioria das opções listadas
nessa caixa de diálogo só faz sentido quando aplicadas a mais de um
componente.

Página: 15
Delphi 5

Porém, muitas vezes, ao invés de alinharmos os componentes através da caixa de diálogo


Alignment, o fazemos através de uma outra ferramenta do Delphi, a Alignment Pallete. Para
exibirmos a Alignment Pallete devemos escolher a opção de mesmo nome localizada no menu
View. Ao fazermos isso nos será exibida a caixa de diálogo mostrada ao lado. A Alignment Pallete
possui basicamente as mesmas funcionalidades que a caixa de diálogo Alignment mostrada acima,
porém com a diferença de que as opções de alinhamento são exibidas de forma gráfica, o que torna
o entendimento da funcionalidade de cada botão muito mais fácil e rápido. Além da exibição
gráfica da funcionalidade de cada botão, é exibido um hint para cada um desses botões quando
permanecemos com o mouse por sobre eles por um pequeno intervalo de tempo.
Vimos até aqui como é fácil colocarmos os componentes nos formulários de nossa aplicação,
além das várias maneiras possíveis de como podemos redimensioná-los e alinhá-los. Resta-nos,
apenas, mostrar como podemos remover os componentes que não desejamos mais que permaneçam
no formulário. Já podemos imaginar até como isso pode ser feito (lembre-se que a programação no
ambiente Delphi é bastante intuitiva). Para removermos um ou mais componentes de nosso
formulário basta que selecionemos os componentes desejados e, em seguida, pressionemos a tecla
Delete ou através da opção Delete localizada no menu Edit. Caso deletemos por engano algum
componente não precisamos nos preocupar, as operações de deleção podem ser desfeitas através da
opção Undelete localizada no menu Edit ou através de sua tecla de atalho Ctrl + Z.

2.3. O Object Inspector


Uma das principais janelas do ambiente de desenvolvimento Delphi é o
Object Inspector. Ele é o principal responsável pela definição das características e
do comportamento de cada componente colocado nos formulários da aplicação
sendo desenvolvida. Por essa razão, em geral, ele encontra-se sempre visível ao
iniciarmos o Delphi. Caso isso não ocorra, para visualizarmos o Object Inspector,
a qualquer momento dentro da IDE do Delphi podemos selecionar a opção Object
Inspector localizada no menu View ou utilizar sua tecla de atalho F11. O Object
Inspector é mostrado na figura ao lado.
Como podemos observar, o Object Inspector é composto de duas partes. Um
ComboBox contendo a lista de componentes contidos no formulário
correntemente selecionado da aplicação, incluindo nesses componentes o próprio formulário. O
Object Inspector contém ainda um PageControl composto por duas guias: Properties e Events. Esse
ComboBox tem a finalidade de indicar o componente atualmente selecionado no formulário bem
como a classe a qual ele pertence (veremos o que são classes posteriormente). Podemos também
utilizar esse ComboBox para selecionar um novo componente, para isso basta que selecionemos seu
nome dentre os itens que aparecem na lista do ComboBox (veremos mais adiante o que é o nome de
um componente).
Já o Page Control divide o Object Inspector em duas guias. A primeira delas, chamada
Properties, contém as propriedades do componente correntemente selecionado, enquanto que, a
segunda guia, chamada Events, possui os eventos disponíveis para esse componente. Quando
selecionamos componentes diferentes, ou seja um botão e depois uma caixa de texto por exemplo,
as propriedades e eventos apresentados são diferentes, ora as propriedades e eventos pertencentes
ao botâo e ora pertencentes à caixas de texto, sempre de acordo com o componente selecionado.
Esse fato é muito importante e por isso devemos sempre nos lembrar que o Object Inspector exibirá
as propriedades e eventos do componente correntemente selecionado, por isso não citaremos mais
essa observação no decorrer de nosso estudo do Delphi. Ora, se o Object Inspector exibe as
informações relacionadas ao componente selecionado, o que acontece quando selecionamos dois ou
mais componentes simultaneamente? Quando selecionamos múltiplos componentes, o Object

Página: 16
Delphi 5

Inspector exibe apenas propriedades e eventos comuns a todos os componentes que estejam
selecionados naquele momento e, ao alterarmos o valor de qualquer propriedade ou evento,
estaremos alterando o valor dessa propriedade ou evento para todos os componentes selecionados.
Porém o que são as propriedades e os eventos de um componente? As propriedades de um
componente identificam as características dos componentes tais com altura, largura, cor e tipo da
fonte sendo utilizada pelo componente. Essas características, dentre outras divisões, podem tanto
ser visíveis como, por exemplo, a altura e largura do componente quanto não visíveis como, por
exemplo, a definição do nome de qual tabela de um banco de dados o formulário irá exibir
informações. Não devemos confundir os dados que estão sendo exibidos, que são informações que
podemos visualizar, com o nome da tabela que foi selecionada para ter seus dados exibidos.
Já os eventos identificam as ações que, tanto o usuário da aplicação quanto outros formulários e
componentes, podem realizar durante a execução do aplicativo sobre o componente selecionado,
por exemplo, um botão pode ser clicado, um formulário pode ser redimensionado e assim por
diante. Durante a construção de cada programa, é função do programador identificar e codificar
cada evento necessário ao funcionamento da aplicação. Dessa forma, podemos perceber que nem
todos os eventos de um componente serão codificados, podendo até mesmo não existir qualquer
codificação em um componente dentro de uma aplicação. Porém, não podemos pensar que caso um
determinado evento não seja codificado ele irá deixar de ser executado. O Windows envia todos os
eventos executados para suas respectivas aplicações. Caso exista uma codificação associada ao
evento executado esse código será executado, caso contrário a execução da aplicação continua
normalmente. Veremos, a partir de agora, um pouco mais detalhadamente como manipular com as
propriedades e eventos de um componente.
A guia Properties está dividida em duas partes, do lado esquerdo estão listados os nomes, em
ordem alfabética, de cada uma das propriedades do componente corrente e ao seu lado esquerdo
estão os valores atuais para essas propriedades. Na figura do Object Inspector, exibida
anteriormente, vemos as propriedades do formulário chamado Form1. Esse formulário possui várias
propriedades, dentre elas a propriedade Caption possuindo o valor Form1.
Existem vários tipos de propriedades dentre elas, como já mencionado, as visíveis e as não
visíveis, também chamadas de visuais e não visuais, respectivamente. Além dessa divisão, podemos
citar propriedades disponíveis em tempo de desenvolvimento e aquelas disponíveis em tempo de
execução. Ou seja, as primeiras são aquelas propriedades listadas no Object Inspector que estão
disponíveis e podem ser modificadas em tempo de desenvolvimento pelo programador para possuir
os valores por ele definidos. Por outro lado, as últimas são propriedades que não estão listadas no
Object Inspector. Para que o programador tome conhecimento da existência dessas propriedades,
ele deverá consultar a ajuda online do Delphi. Um vez conhecidas, essas propriedades só poderão
ser manipuladas através de codificação uma vez que não aparecem no Object Inspector.
Apesar de visíveis no Object Inspector, algumas propriedades disponíveis em tempo de
desenvolvimento podem ser tanto alteradas em tempo de desenvolvimento quanto em tempo de
execução através de codificação. Já outras propriedades, chamadas read-only não podem ser
alteradas em tempo de execução, podendo apenas ser lidas. Existe toda uma gama de combinações
entre essas características das propriedades. Para obter conhecimento a respeito de quais
propriedades são visíveis em tempo de desenvolvimento, em tempo de execução ou em ambas, ou
quais propriedades são read-only ou não, o desenvolvedor Delphi deve consultar a documentação
online fornecida pela Inprise.
Uma vez que sabemos que as propriedades listadas no Object Inspector podem ter seus valores
alterados, resta-nos saber quais os valores podem ser atribuídos a cada uma dessas propriedades.
Embora tenhamos uma quantidade muito grande de propriedades para cada componente existente

Página: 17
Delphi 5

na IDE do Delphi, a prática nos levará a identificar quais são os


possíveis valores que podem ser atribuídos a essas
propriedades. A cada propriedade está associado um tipo de
dados que define quais valores podem ser a atribuídos a cada
uma delas. Por exemplo, a propriedade Caption do formulário,
citada anteriormente, foi definida como sendo do tipo de dados
string (veremos os diversos tipos de dados suportados pelo Delphi posteriormente), podendo
receber qualquer conjunto de caracteres. Já a propriedade ClientHeight, também listada na figura
anterior, foi definida como sendo do tipo integer podendo receber apenas valores inteiros. Caso
tentemos colocar um valor inválido para uma propriedade, o Delphi irá exibir uma mensagem de
erro informando que o valor que tentamos inserir não corresponde a um valor válido para aquela
propriedade. Na figura ao lado mostramos a mensagem de erro exibida pelo Delphi ao tentarmos
colocar o valor ibratec na propriedade Client Height de um formulário. Nesse exemplo, o Delphi
nos informa que o valor que colocamos não é um número inteiro válido e, portanto, não deveria ter
sido atribuído à propriedade Client Height.
Para facilitar o trabalho do desenvolvedor Delphi, algumas propriedades de tipos mais
complexos do que as que permitem strings e inteiros, apresentam os valores válidos em um combo
box. Dessa forma, o desenvolvedor precisa apenas selecionar dentre um dos valores listados. É
importante observar que os valores listados nos combo boxes são aqueles que podem ser atribuídos
à variável sendo manipulada, independentemente se estivermos alterando-a em tempo de
desenvolvimento ou em tempo de execução através da codificação do aplicativo sendo
desenvolvido. No caso de tentarmos atribuir um valor que não esteja definido para
a propriedade, ao tentarmos compilar o nosso aplicativo, o Delphi exibirá uma
mensagem de erro informando que estamos tentando atribuir um valor inválido
para aquela propriedade, de forma semelhante ao que aconteceu ao tentarmos
atribuir um valor inválido dentro do Object Inspector. Um outro ponto importante a
observarmos é que esses valores listados dentro do combo box não são strings e
portanto, não obedecerão à notação de strings. Essas propriedades são definidas
como pertencentes aos chamados tipos enumerados. A notação para a definição e
atribuição tanto de strings quanto de tipos enumerados será vista posteriormente.
Como podemos observar na figura acima, o Delphi também possui
propriedades simbolizadas com um pequeno sinal de + ao seu lado esquerdo. Esse
sinal permite o desmembramento da propriedade listando itens que a compõe. Por exemplo, a
propriedade Anchors listada no Object Inspector mostrado na figura anterior, possui um conjunto de
valores que podem ser atribuídos a ela. Aqueles valores que desejamos que estejam contidos na
propriedade deverão estar com o valor true atribuído, enquanto que aqueles que não desejamos
deverão estar com o valor false. No exemplo acima, a propriedade Anchors está definida contendo
os valores akLeft e akTop uma vez que a esses valores foi atribuído o valor True. Esses tipos
especiais de propriedades, chamados Sets serão vistos posteriormente no decorrer de nosso estudo.
Podemos facilmente identificar quais propriedades são Sets uma vez que, no Object Inspector, os
valores dessas propriedades aparecem entre colchetes.
Além das propriedades definidas como Sets, um outro conjunto de
propriedades apresentam do seu lado esquerdo um sinal de + no Object
Inspector. Essas propriedades podem representar tanto Sets quanto
Objetos. O desenvolvedor poderá facilmente diferenciar cada uma
dessas duas situações através do
conteúdo da propriedade em questão.
Ao contrário do que acontece com os
Sets, que apresentam seu conteúdo

Página: 18
Delphi 5

entre colchetes, as propriedade que apresentam seu conteúdo entre sinais de parênteses representam
objetos (veremos posteriormente a definição de classes e objetos). Essas propriedades representam
novos objetos contidos dentro do componente em questão, que por sua vez também é um objeto.
Veremos toda essa idéia de objetos posteriormente, por hora basta termos em mente que podem
existir propriedades que representam tanto Sets quanto objetos. A figura anterior mostra a
propriedade Font do formulário. Essa propriedade ilustra dois aspectos com relação a propriedades
que representam objetos. Podemos observar que a propriedade Font possui, por sua vez, outras
propriedades. Ao contrário do que acontecia com os Sets, cujos valores que podíamos atribuir eram
apenas True ou False, as propriedades que aparecem abaixo de Font podem receber valores
inteiros, strings, Sets ou até mesmo novos objetos. Uma segunda observação está no fato da
existência de um botão, ao lado do valor da propriedade Font. Ao clicarmos esse botão será exibida
um caixa de diálogo que nos permite preencher de forma mais agradável o valor das propriedades
que foram listadas, em nosso exemplo, a propriedade Font. A figura ao lado mostra a caixa de
diálogo que é exibida ao clicarmos no botão da propriedade Font. Devemos ter em mente que a
caixa de diálogo mostrada não é de exibição obrigatória, ou seja, podem existir propriedades dentro
de componentes do Delphi que representem objetos mas que não possuam uma caixa de diálogo
para permitir uma definição mais fácil dos valroes de suas propriedades. A existência dessas caixas
depende das pessoas que construíram, ou seja, programaram cada um desses componentes. É uma
prática de programação bastante comum dentro do ambiente Delphi que, as propriedades de
componentes que representem objetos deverm ter uma caixa de diálogo associada mas isso não
torna obrigatória a existência dessas caixas de diálogo. Caso estejamos estudando o Delphi para
desenvolver novos componentes devemos lembrar que, caso exista um propriedade que contenha
um objeto em nosso componente, devemos desenvolver uma caixa de diálogo que permita o
preenchimento das informações para esse objeto.
A segunda guia existente no Object Inspector é responsável pela
exibição dos Eventos aos quais o componente selecionado pode responder.
Esses eventos, da mesma forma como acontecia com as propriedades, são
específicos para cada componente, ou seja, podem existir eventos comuns
ou não aos diversos componentes existentes no Delphi. A figura ao lado
mostra os eventos aos quais um formulário pode responder.
Já sabemos que o Object Inspector, de forma semelhante ao que
acontece com as propriedades, exibe os eventos específicos para cada
componente selecionado. Porém, para que servem os eventos? Os eventos
formam uma das partes mais importantes na programação dentro do
ambiente Windows. É através do disparo de eventos que existe a interação
entre o usuário e o código escrito em cada programa. Eventos são disparados por ações do usuário
ou de outros programas, e esses eventos por sua vez, executam a codificação escrita pelos
programadores durante o seu desenvolvimento. No Delphi, a maneira mais simples de associarmos
que código que será executado quando cada um desses eventos ocorrer é através do Object
Inspector. Por exemplo, caso quiséssemos exibir uma mensagem quando o usuário clicasse no
formulário, poderíamos escrever o código responsável pela exibição da mensagem e associá-lo ao
disparo do evento OnClick do formulário. Podíamos também efetuar essa associação através da
própria codificação porém deixamos a explanação de como isso pode ser feita para uma discussão
um pouco mais avançada dentro do Delphi. A guia Events está dividida de forma semelhante à guia
Properties. Do lado esquerdo estão listados os nomes dos eventos enquanto que do lado direito está
o nome de qual trecho de código deverá ser executado quando o evento em questão for disparado.
Com o intuito de facilitar o trabalho do desenvolvedor, o nome de cada evento segue um padrão de
nomenclatura, observe que dentro do Object Inspector cada evento tem seu nome composto do
prefixo On mais o evento que irá dispará-lo.

Página: 19
Delphi 5

Como citado anteriormente, o Object Inspector tem como uma de suas funções associar o
evento e o código a ser executado quando esse evento for disparado. Dessa forma, podemos
perceber que não existe a obrigatoriedade de termos, para cada evento um código a ser executado,
ou seja, podem existir eventos sem qualquer código associado. Por exemplo, não precisamos
associar código algum ao evento OnClick do formulário. Mesmo que isso ocorra, como mencionado
anteriormente, o Windows continuará enviando uma mensagem ao formulário toda vez que ele
sofrer um clique por parte do usuário, porém nada será executado. Da mesma forma, também
podemos ter inúmeros eventos “apontando” para o mesmo código, como ilustra a figura abaixo. Na
figura abaixo vemos a existência de três eventos distintos que, ao serem disparados, executam o
mesmo trecho de código dentro da aplicação.

Por exemplo, em nossa aplicação poderíamos ter um botão e um item de menu que nos
permitam sair do programa. Não necessitamos escrever dois códigos idênticos e associa-los
respectivamente ao clique no botão e ao clique do item de menu. Basta criarmos uma única
codificação e associá-la a ambos os eventos, ou seja, tanto ao clique do botão quanto ao do item de
menu. Isso é muito importante uma vez que nos permite uma melhor codificação e manutenção do
código escrito, diminuindo a quantidade de erros durante a fase de manutenção do aplicativo.
Uma vez que já sabemos que podemos associar código aos diversos eventos existentes em cada
componente, resta-nos escrever esse código e criar a associação entre o código escrito e o evento
desejado. Apesar de poder parecer um pouco estranho, iremos começar não pela codificação, mas
sim pela associação entre o código e os eventos. Essa inversão ficará clara no decorrer de nossa
explicação. Então, veremos agora as quatro alternativas que o Delphi nos oferece para associar
código aos eventos listados no Object Inspector.
Vamos iniciar com o método mais comum de associação. Para isso, iremos construir nossa
primeira aplicação em Delphi. Inicialmente, essa
aplicação não irá conter qualquer componente, ou seja,
ela será composta simplesmente da janela principal
como ilustrado ao lado. Para isso devemos selecionar a
opção Close All no menu File e em seguida a opção
New Application localizada nesse mesmo menu. Caso
tenhamos modificado a aplicação anterior o Delphi irá
nos perguntar se desejamos salvar as alterações
efetuadas, por ora responderemos não. Suponha que
desejamos exibir uma mensagem quando esse
formulário for clicado. Já sabemos que o Object
Inspector sempre manipula o componente selecionado e por isso devemos selecionar o formulário

Página: 20
Delphi 5

que, nada mais é do que o componente ao qual desejamos criar a associação entre a codificação e o
evento. Para selecionarmos o formulário basta que efetuemos um clique simples no formulário que
este se tornará o objeto selecionado no Object Inspector. Uma vez selecionado o componente,
devemos no Object Inspector, selecionar o evento que desejamos associar a codificação. Em nosso
exemplo, devemos selecionar o evento OnClick uma vez que queremos exibir uma mensagem
quando o formulário for clicado. Uma vez que ainda não escrevemos codificação alguma, iremos
nos aproveitar de alguns recursos que o Delphi nos oferece para podermos criar tanto a codificação
inicial quanto a associação dessa codificação com o evento do formulário. Para isso, vamos dar um
duplo clique na região branca do lado direito do nome OnClick.
Ao fazermos isso, o Delphi abre o Editor de Código, que será visto no próximo tópico, e cria
um trecho de programa no qual podemos digitar o código necessário à exibição da mensagem
quando o formulário for clicado, como ilustrado na
figura. Esse trecho de código é chamado de
Procedimento de Evento, do inglês Event Procedure.
Além da criação do trecho inicial da codificação a ser
realizada, o Delphi também alterou outros trechos de
código dentro do próprio Editor. Não iremos abordar
agora essas demais alterações, apenas iremos salientar
que as demais alterações feitas pelo Delphi são
importantes quando estivermos criando por conta
própria procedimentos de eventos para as nossa
aplicações. Apesar de não serem alteações que um
programador iniciante estará fazendo dentro do Delphi elas deverão ser observadas para um melhor
entendimento do funcionamento de um programa Delphi.
Uma outra alteração realizada pelo Delphi, facilmente perceptível, encontra-se no Object
Inspector. Agora, ao lado do evento OnClick do formulário, o Delphi criou a associação desse
evento com o trecho de código que foi criado pelo póprio Delphi e listado no
Editor de Código. Observe que essa associação criada nada mais é do que a
informação de qual Procedimento de Evento será executado quando o evento
OnClick for disparado. De forma semelhante poderíamos fazer com que o
Delphi criasse qualquer Procedimento de Evento e fizesse a associação entre o
procedimento e o respectivo evento. A figura ao lado mostra como ficou o
Object Inspector após a associação entre o Procedimento de Evento criado e o
evento OnClick do formulário.
O Delphi, ao criar o Procedimento de Evento, forneceu a ele um nome
inicial default, formado pelo nome do componente que irá sofrer o evento, em
nosso exemplo o formulário, juntamente com o evento que irá disparar a
execução do procedimento, no exemplo o evento Click. Apesar do Delphi
fornecer um nome default para os procedimentos, muitas vezes podemos querer utilizar um outro
nome para o procedimento, de tal forma que se torne mais clara a finalidade daquele trecho de
código a ser executado. Por exemplo, ao invés de chamarmos o procedimento de FormClick
poderíamos querer que o procedimento viesse a ser chamado de ExibirMensagem.
Essa alteração pode ser facilmente realizada. Basta que mudemos o nome da associação no
Object Inspector e teclemos ENTER, que ela será automaticamente refletida
também no Editor de Código. Observe, no entanto, que para fornecermos o nome
desejado ao Procedimento de Evento tivemos de criar um procedimento com o
nome default e posteriormente muda-lo para o nome que desejávamos. Porém
poderíamos ter criado o procedimento diretamente com o nome desejado. Essa é

Página: 21
Delphi 5

justamente a segunda maneira que possuímos para criar um Procedimento de Evento dentro do
Delphi. Ao selecionarmos o evento desejado podemos, no Object Inspector, ao invés de dar um
duplo clique no evento desejado, temos a opção de digitar diretamente o nome que desejamos
atribuir ao Procedimento de Evento e em seguida, ao darmos um ENTER, O Delphi irá criar o
procedimento da mesma forma como havia criado anteriormente, porém com o nome que definimos
ao invés de utilizar o nome default. Apesar dessa segunda opção de criação de um procedimento ser
mais clara em relação à finalidade do procedimento sendo criado, ela não é tão utilizada em relação
à primeira, por questões muitas vezes de agilidade no desenvolvimento da aplicação.

A terceira opção para criarmos procedimentos de eventos apoia-se no fato de


podermos associar diversos eventos à execução de um mesmo trecho de código
fonte. A associação é bastante simples. Para associarmos um evento a um
Procedimento de Evento previamente escrito basta que selecionemos, a partir do
combo box ao lado do evento que desejamos fazer a nova associação, o nome do
Procedimento de Evento previamente criado. A figura ao lado mostra a exibição no
combo box da propriedade OnDestroy o Procedimento de Evento ExibirMensagem
criado anteriormente para o evento OnClick do formulário. Ao criarmos essa
associação, o mesmo trecho de código será executado por nossa aplicação tanto
quando o formulário for clicado como quando ele for destruído.
É importante fazermos uma pequena observação com relação a essa
possibilidade de associarmos Procedimentos de Eventos previamente criados a outros eventos
dentro de nossa aplicação. No Combo Box dos eventos nem sempre estarão
listados todos os Procedimentos de Eventos que já foram criados em uma
aplicação. Esse fato está ilustrado na figura a seguir. Como podemos observar, o
Procedimento de Evento ExibirMensagem foi criado previamente e está
associado ao evento OnClick do formulário. Contudo esse procedimento não
aparece no Combo Box exibido ao lado do evento OnCloseQuery do formulário.
Fato semelhante aconteceria em vários outros combo boxes de eventos. A
recíproca também aconteceria se tivéssemos criado inicialmente um
procedimento de evento associado ao evento OnCloseQuery do formulário e,
posteriomente tentássemos associar esse mesmo procedimento ao evento
OnClick do formulário.
Ao contrário do que poderíamos pensar inicialmente, isso não é um bug do
Delphi e, uma vez que não se trata de um bug, existe obviamente uma
explicação para essa situação. O entendimento dessa situação é facilmente observado quando
criamos um Procedimento de Evento, por qualquer um dos métodos vistos anteriormente, e o
associamos ao evento OnCloseQuery. Ao fazermos isso, o Delphi irá exibir o Editor de Código e
deixar disponível os procedimentos criados tanto para o evento OnClick quanto para o evento
OnCloseQuery, como ilustrado na figura abaixo. Observe que esses procedimentos, apesar de serem
criados pelo Delphi de forma semelhante eles são diferentes em suas declarações.

Página: 22
Delphi 5

O procedimento associado ao evento OnClick e OnDestroy do formulário possuem apenas um


único parâmetro associado a ele, enquanto que o procedimento referente ao evento OnCloseQuery
recebe dois parâmetros. Veremos como declarar e passar parâmetros posteriormente, por enquanto
basta observarmos que o Delphi só irá permitir a associação de procedimentos desde que eles sejam
semelhantes, ou seja, possuam os mesmos tipos de argumentos.

A quarta maneira de criarmos um Procedimento


de Evento e de o associarmos a um evento é a mais
rápida de todas. Apesar de ser a maneira mais rápida
ela é muitas vezes erroneamente utilizada por
programadores inexperientes. Para ilustrarmos esse
procedimento iremos colocar um botão em nosso
formulário conforme ilustrado. Uma vez que o botão
tenha sido colocado no formulário vamos criar um
Procedimento de Evento associado ao clique desse
botão. Para isso, vamos dar um duplo clique no em
cima do botão. Ao fazermos isso, o Delphi cria, de
forma idêntica ao que foi visto na primeira maneira de criar procedimentos associados a eventos,
um procedimento com o nome default e o associa ao evento OnClick do botão, como ilustrado na
figura a seguir.
Ao contrário do que podemos imaginar, esse
comportamento não será sempre o mesmo, ou seja,
caso desejemos criar um procedimento e associá-lo ao
clique do formulário seria suficiente darmos um duplo
clique no formulário para que o Delphi fizesse isso por
nós? A resposta é não! Caso déssemos um duplo clique
no formulário o Delphi também iria criar um
procedimento, mas esse procedimento não estaria
associado ao clique no formulário, mas sim ao evento
OnCreate. Esse comportamento deve-se ao fato de que
o duplo clique em um componente não faz com que
Delphi crie automaticamente um procedimento associado ao evento OnClick daquele componente
mas sim ao fato de que o Delphi cria um procedimento associado ao evento default do componente
clicado. No caso do botão, por exemplo, o evento default é o OnClick já no caso do formulário é o
OnCreate e assim sucessivamente. Para evitarmos erros desse tipo devemos nos habituar a utilizar
as três primeiras maneiras de criação e associação de eventos até que estejamos bastante
familiarizados com os componentes existentes e seus respectivos eventos default.

2.4. O Editor de Código


O Editor de Código, até a versão 3 do Delphi, nada
mais era do
que uma
janela
dotada dos
recursos

Página: 23
Delphi 5

mais comuns nos editores de texto tais como o WordPad. Nessa janela podiam ser exibidos um ou
vários arquivos de código fonte. Cada um desses arquivos podia ser acessado através de uma guia
contendo o nome do arquivo sendo exibido. Além disso no Editor de Código eram exibidas
informações a respeito da compilação dos programas tais como erros e warnings detectados pelo
compilador Delphi. A partir da versão 4 do Delphi, o Editor de Código trouxe uma outra janela,
chamada de Code Explorer, capaz de identificar e exibir de forma mais organizada informações a
respeito do arquivo fonte sendo exibido, tais como declarações de constantes e variáveis.
O Editor de Código possui recursos que permitem a busca e substituição de trechos de código,
através do menu Search. Não entraremos em detalhe a respeito da utilização desses recursos por se
tratarem de recursos comuns à maioria dos editores de texto. Além desses recursos de busca, o
Editor de Código nos fornece a possibilidade de configurá-lo de tal forma a atender melhor as
nossas necessidades. Para isso, devemos acessar a caixa de diálogo Editor Properties localizada no
menu Tools através da opção Editor Options. Essa caixa de diálogo possui 5 guias das quais as
quatro primeiras (General, Display, KeyMappings e Color) possibilitam a configuração visual do
Editor de Código tais como a fonte e as cores que serão utilizadas. Já a guia Code Insight permite a
configuração do recurso de mesmo nome existente no Delphi, veremos o Code Insight
posteriormente.
Uma observação que deve ser feita
ao utilizarmos o Editor de Código
refere-se à manipulação dos arquivos
que são exibidos. Uma vez que não
desejarmos mais que um determinado
arquivo seja exibido não deveremos
simplesmente clicar no ícone de
sistema localizado no canto superior
direito do Editor. Caso façamos isso
estaremos fechando todo o Editor de
Código e não apenas o arquivo selecionado. Para fecharmos apenas o
arquivo fonte selecionado devemos clicar com o botão secundário do
mouse por sobre o Editor de Código. Ao fazermos isso será exibido um
menu popup que permite um acesso mais rápido a diversas opções do
Editor de Código, entre elas a opção Close Page, responsável for fechar
a página corrente.
Como dito anteriormente, o Editor de Código, apesar de poder exibir arquivos genéricos de
texto, ele é a janela do Delphi responsável pela exibição, principalmente, de arquivos que
contenham código fonte escrito dentro do Delphi. Neste tópico falamos de forma genérica do Editor
de Código sem nos preocuparmos com os arquivos fonte propriamente ditos. Veremos esses
arquivos com bem mais detalhe no tópico abordando as units.

2.5. Codificando e Compilando


Vimos até aqui algumas das maneiras de um programador possui de criar os Procedimentos de
Eventos para a sua aplicação, resta-nos agora escrever o código propriamente dito, necessário para
fazer com que, em nosso exemplo, uma mensagem seja exibida. Vamos optar não mais por exibir a
mensagem no evento OnClick do formulário mas sim quando ocorrer o evento OnClick do botão.
Para que a mensagem seja exibida basta escrevermos o seguinte código no Procedimento de Evento
associado ao evento OnClick.

procedure TForm1.Button1Click(Sender: TObject);


begin
ShowMessage('Olá mundo');
end; Página: 24
Delphi 5

Observe que escrevemos código apenas no


procedimento associado ao evento que desejávamos
tratar. Os demais procedimentos não mais serão

utilizados em nossa aplicação por isso deverão ser


removidos do código fonte. Para isso, muitas vezes nos
sentimos tentados simplesmente a, no Editor de
Código, remover o Procedimento de Evento que foi criado automaticamente pelo Delphi conforme
ilustrado na figura ao lado. Contudo, se fizermos isso, uma série de erros irão ocorrer ao tentarmos
compilar nossa aplicação. Quando compilamos os nossos aplicativos, o Delphi procura por
quaisquer erros em nosso código fonte, caso ele encontre erros ou apenas encontre trechos de
código que, apesar de não representarem erros de sintaxe, poderiam ser evitados, as chamadas
warnings, esses serão exibidos numa pequena janela, na parte inferior do Editor de Código,
juntamente com uma pequena descrição do motivo pelo qual o erro ocorreu, conforme ilustrado na
figura ao lado. Para observarmos esses erros vamos remover manualmente o Procedimento de
Evento associado ao evento OnCloseQuery do formulário e em seguida vamos tentar compilar
nossa primeira aplicação Delphi. Para compilarmos a aplicação basta, no menu Project,
selecionarmos a opção Build Project1 (abordaremos posteriormente a compilação e execução de
programas mais detalhadamente). Ao tentarmos compilar a aplicação, o compilador iria detectar um
erro como ilustra a figura ao lado. Esse erro ocorre uma vez removemos apenas a implementação do
procedimento FormCloseQuery. O Delphi, ao criar um Procedimento de Evento, além de iniciar a
escrita do código a ser executado quando o evento em questão ocorrer, ele escreve código em
outros pontos do código fonte do programa, essa é a razão pela qual o erro descrito acima ocorre ao
removermos, manualmente, apenas a implementação do procedimento. Para que a compilação possa
continuar restando-nos, também, remover sua declaração. Podemos remover a declaração
manualmente e tentar compilar a aplicação mais uma vez.

Porém, ao tentarmos compilar a aplicação novamente um erro irá ocorrer. A explicação para esse novo
erro, mostrado ao lado, também é bastante simples.
Quando removemos a implementação e a declaração
do procedimento não removemos todas as
ocorrências desse procedimento dentro do código
fonte de nossa aplicação Delphi. Lembre-se que,
quando trabalhamos com o Delphi, passamos a definir
dentro dos diversos eventos que um componente pode
sofrer quais executarão cada um dos procedimentos que
escrevemos. Sabemos ainda que vários procedimentos
podem estar relacionados a um único código fonte. Para
que isso seja possível, o Delphi é obrigado a
arqmazenar, em algum local de sua codificação, essa
informação. Ao removermos a códificação e a
declaração do procedimento, deixamos de lado a
remoção dessa indicação. Resta-nos então, remover as referências que haviam sido criadas pelo Object
Inspector. O Delphi reconhece essa situação e nos questiona se desejamos que essas referências sejam
removidas para que a aplicação seja compilada novamente.

Página: 25
Delphi 5

Como pudemos observar, esses erros ocorreram por que o Delphi fez uma série de modificações
automaticamente no código fonte de nossa aplicação ao permitirmos que ele criasse o Procedimento de
Evento. Dessa forma, para evitarmos que esses erros ocorram, devemos também permitir que o Delphi
remova essas alterações automaticamente para nós. E isso é tão simples de conseguirmos como foi para que
essasinclusões de código fossem feitas para nós. O Delphi remove automaticamente todas os
Procedimentos de Eventos e suas respectivas referencias sempre que salvamos ou tentamos compilar
nossas aplicações desde que não exista nenhum código ou comentário dentro do corpo do procedimento, ou
seja, entre as palavras reservadas begin e end; existentes na codificação do procedimento não deverá existir
qualquer tipo de codificação nem mesmo um comentário.

Após termos alterado o nosso primeiro programa, deixando apenas o procedimento associado ao evento
OnClick do botão, podemos compilar a aplicação para verificar se ela faz
realmente o que esperávamos. Para que possamos compilar a aplicação devemos
selecionar a opção Compile Project1 existente no menu Run. Caso já tivéssemos
salvo a aplicação com um nome qualquer a opção de compilação apareceria com o
nome que tivéssemos dado à aplicação ao invés no nome Project1. Uma vez
compilada a aplicação, podemos executá-la e ver o resultado de sua codificação.
Para isso basta selecionarmos, no menu Run, a opção Run. A aplicação será
executada e ao clicarmos no botão colocado no formulário, será exibida a
mensagem ao lado. Nenhum outro evento provocará qualquer atividade uma vez que removemos todos os
procedimentos exceto o evento associado ao clique do botão.

Devemos nos lembrar sempre que, ao executarmos a aplicação por dentro do Delphi entramos
automaticamente em modo de depuração, ou seja, caso façamos uma nova alteração no código fonte
teremos de encerrar a execução antes que possamos compilar a aplicação novamente. Dessa forma, para
sairmos do modo de depuração basta fecharmos a janela principal da aplicação que, dessa forma, seremos
levados de volta à IDE do Delphi.

2.6. Salvando o Projeto


Uma vez que terminamos o nosso primeiro aplicativo vamos salvá-lo de forma a podermos futuramente
trabalhar novamente nele em nosso próprio equipamento ou em outro qualquer. Para isso, a maneira mais
rápida é clicarmos no botão Save All localizado na Barra de Ferramentas. Ao fazermos isso, o Delphi irá
salvar todos os arquivos que foram criados para o desenvolvimento de nosso aplicativo.

O primeiro arquivo a ser salvo pelo Delphi, quando selecionamos a opção Save All, refere-se à unit que
contém o código do formulário principal do nosso aplicativo (veremos as units mais detalhadamente
posteriormente). Devemos fornecer um nome
significativo para a unit, uma vez que esse
nome será utilizado pelo Delphi no restante do
decorrer do desenvolvimento da aplicação.
Uma observação a ser feita é que, com a
prática poderemos começar a trabalhar com
vários formulários dentro de nossa aplicação
deixando para salvá-los depois de já termos
escrito uma quantidade relativa de código.
Essa prática é desaconselhada por alguns
motivos entre eles a possibilidade de um queda
de energia que poderia levar a perda de todo o
trabalho desenvolvido, além de que, ao
clicarmos no botão Save All, o Delphi inicia o
processo de gravação de todas as units
contidas em nossa aplicação e, caso exista um número relativamente grande de units ficará cada vez mais
complicado de, no momento da gravação, identificar cada uma dessa units de tal forma a fornecer,
corretamente, seus respectivos nomes. Iremos fornecer no tópico a seguir uma explicação mais detalhada a

Página: 26
Delphi 5

cerca dos principais arquivos salvos pelo Delphi bem como fornecer o relacionamento existente entre eles.
No momento basta termos o conhecimento de que devemos fornecer nomes distintos para cada arquivo a
ser salvo de tal forma a identificá-los de forma simplificada tanto dentro de nosso aplicativo quanto
externamente ao Delphi no momento de realizarmos backup dos mesmos.
Uma vez que tenhamos salvo a unit referente ao
formulário principal de nossa aplicação, ou no caso
de estarmos trabalhando com vários formulários e
tenhamos salvo todas as units referentes a esses
formulários, o Delphi irá permitir que nós salvemos o
arquivo, chamado de arquivo de projeto, referente à
nossa aplicação como ilustrado na figura ao lado. O
arquivo de projeto é um dos mais importantes dentro
de uma aplicação Delphi e ele deverá ser salvo com
um nome único dentro dessa aplicação, não podendo
por isso, ter o mesmo nome que o de uma unit
qualquer pertencente ao projeto (mesmo esses
arquivos possuindo extensões distintas como
veremos posteriormente).

2.7. Trabalhando com uma aplicação


A IDE do Delphi, sempre ao ser iniciada, apresenta-nos uma nova aplicação para que possamos iniciar um
novo processo de desenvolvimento. Essa aplicação, também chamada de projeto, irá conter todo o código
fonte que dará origem aos programas ou DLLs que nós venhamos a desenvolver. Devemos sempre ter em
mente que, para podermos compilar e gerar programas executáveis e DLLs, deveremos estar com um
projeto aberto na IDE. Essa observação é muito importante por ser uma fonte de erros bastante comum,
principalmente para aqueles programadores menos experientes no Delphi que tentam executar, através da
opção Run | Run, arquivos carregados isoladamente dentro da IDE do Delphi, sem ter aberto seus
respectivos projetos.
As versões iniciais do Delphi não permitiam ao desenvolvedor abrir dois ou mais projetos dentro de uma
mesma sessão do Delphi. Nas versões mais novas essa restrição não mais existe. O desenvolvedor tem a
possibilidade de trabalhar com dois ou mais projetos simultaneamente através do chamado Project Group,
ou seja um grupo de projetos. Porém, mesmo com a possibilidade de trabalhar com vários projetos ao
mesmo tempo, apenas um deles estará ativo a cada momento.
As informações a respeito dos projetos pertencentes a um Project Group são armazenadas em um arquivo
salvo com a extensão bpg. Esse é um arquivo ASCII comum que pode ser editado em qualquer editor de
textos do Windows ou até mesmo do DOS, e contém as informações a respeito dos projetos que estão
inclusos no Project Group bem como os comandos necessários à compilação desses projetos.
A possibilidade de podermos trabalhar com mais de um projeto ao mesmo tempo é importante quando
estamos desenvolvendo tanto um aplicativo executável quanto, por exemplo, DLLs por ele utilizadas.
Utilizando a funcionalidade dos Project Groups podemos alternar o trabalho entre o aplicativo e as DLLs
sem a necessidade de fechar e abrir, a cada momento, o projeto referente ao aplicativo e a cada uma das
DLLs. Porém, apesar de podermos trabalhar com mais de um projeto ao mesmo tempo vamos nos deter no
decorrer de nosso estudo a trabalhar com um único projeto.
Feito esse comentário a respeito dos grupos de projetos dentro do ambiente Delphi, podemos retornar a
nossa discussão sobre o desenvolvimento de cada projeto, ou seja, cada aplicação criada no Delphi. Da
mesma forma como mencionado com relação ao grupo de projetos, cada projeto Delphi possui suas
informações salvas em um arquivo ASCII, salvo com a extensão dpr. Mostramos a seguir um exemplo de
um arquivo de projeto.

program Project1;
USES
Forms,
Unit1 in 'Unit1.pas' {Form1};

{$R *.RES}

Página: 27
BEGIN
Application.Initialize;
Application.CreateForm(TForm1, Form1);
Delphi 5

A exibição dos arquivos de projeto não é feita de modo imediato, ou seja, ao iniciarmos o desenvolvimento
de um novo aplicativo, o arquivo de projeto não é exibido pelo Editor de Código. Para que possamos
visualizar o arquivo de projeto devemos, no menu Project, selecionar a opção View Source. Existe uma
explicação para que o arquivo de projeto não seja exibido diretamente. Por se tratar de um arquivo muito
importante, o Delphi encarrega-se de fazer a maioria das alterações necessárias nesse arquivo, de forma
automática, ao selecionarmos as devidas opções contidas nos diversos menus da IDE do Delphi. Não
devemos alterar diretamente o arquivo de projeto a menos que tenhamos certeza absoluta das alterações
que estejamos fazendo uma vez que isso poderá acarretar o funcionamento incorreto ou, até mesmo o não
funcionamento da aplicação.
O Delphi permite o desenvolvimento de diversos tipos de aplicativos tanto executáveis quanto de DLLs.
Dentre aquelas aplicações executáveis podemos distinguir dois tipos principais: as console applications e
as aplicações GUI (Graphical User Interface), que são as aplicações tradicionais
do ambiente Windows que possuem um ambiente gráfico para interagir com o
usuário. Apesar de não muito comum podemos ter um programa Delphi escrito
apenas no arquivo de Projeto. Essas aplicações, que em sua grande maioria
constituem as chamadas console applications, não possuem uma interface gráfica
associada a eles e são executados como antigos programas DOS. Já as demais
aplicações para o ambiente Windows apresentam, em geral, uma interface gráfica
coma a qual o usuário poderá interagir com o aplicativo em questão.
Independentemente de qual tipo de aplicação estejamos desenvolvendo, termos de
salvar vários tipos de arquivos durante o desenvolvimento de nossas aplicações e
aprender a correlação entre eles. Para isso veremos rapidamente as opções
disponíveis no menu File. Através dessas opções podemos manipular os diversos
arquivos que irão compor as nossas aplicações. As opções dispostas nesse menu
estão divididas de acordo com a funcionalidade de cada opção. O primeiro grupo
de opções permite a criação de uma nova aplicação, através da opção New
Application, bem como de novos formulários e frames, através das opções New
Form e New Frame. Existe ainda, nesse grupo de itens de menu, a opção New que
permite a criação auxiliada de novas aplicações e formulários através do Object Repository que será visto
posteriormente. O segundo grupo de opções permite a abertura de projetos e outros arquivos salvos
anteriormente. Lembramos que no caso de não existir nenhum projeto aberto e através da opção Open,
abramos um formulário, não serão possíveis a compilação e execução desse arquivo! Isso decorre do fato
de termos aberto um formulário e não um projeto. O terceiro grupo de opções permite que salvemos os
arquivos de projeto e demais arquivos de trabalho que estejam abertos na IDE. Devemos ressaltar que o
nome dado ao arquivo de projeto será o nome que será dado ao arquivo executável da aplicação após a sua
compilação. O quarto “grupo de opções”, composto apenas pela opção Use Unit, será visto posteriormente
quando estivermos detalhando o conceito de units. O último conjunto de opções é responsável pela
impressão tanto gráfica dos formulários quanto do código fonte escrito nas units. A última opção permite
que fechemos o Delphi. No caso de existir qualquer alteração feita no código do projeto que esteja aberto,
o Delphi, antes de ser finalizado, exibirá uma caixa de diálogo confirmando se as alterações devem ou não
ser salvas.
Já sabemos que as console applications são desenvolvidas utilizando simplesmente o arquivo de projeto,
porém, a grande maioria dos aplicativos a serem desenvolvidos não serão console applications, mas sim
aplicações que irão conter uma interface gráfica que irá interagir com os usuários dessas aplicações. É por
isso que, para esse segundo tipo de aplicativo, existirão outros arquivos além do arquivo de projeto. Dentre
esses outros arquivos podemos destacar aqueles cuja extensão é dfm os quais irão conter todas as
definições gráficas de cada formulário contido na aplicação. Ou seja, para cada formulário que colocarmos
em nosso aplicativo será salvo um arquivo de extensão dfm associado. Além do arquivo dfm existirá,
associado a ele, um arquivo de extensão pas que irá conter tanto todo o código fonte referente aos eventos
desse formulário quanto qualquer outro código fonte que tenhamos escrito para esse formulário. Esse
arquivo, chamado de unit, é exibido no Editor de Código do Delphi para que o programador possa
desenvolver o aplicativo.
Além das units associadas aos arquivos de formulários, a aplicação poderá conter units isoladas. Essas
units que não estão associadas a qualquer formulário são utilizadas principalmente para declaração de
funções, variáveis e constantes de uso global dentro da aplicação. Além desses arquivos apresentados até
aqui, o Delphi, ao salvarmos o nosso aplicativo, salva alguns arquivos adicionais contendo aspectos de

Página: 28
Delphi 5

configuração do ambiente bem como de configuração do próprio compilador Delphi de tal forma a permitir
que, ao levarmos o aplicativo que estamos desenvolvendo para um outro computador, possamos continuar
o desenvolvimento sem termos de configurar novamente todo o ambiente para atender as nossas
necessidades. Mostramos a seguir um resumo das principais extensões de arquivos salvos pelo ambiente do
Delphi ilustrando também o seu papel.

Extensão Descrição
Bpg Arquivo que contém a indicação de quais projetos compõe um Project Group bem como
as diretrizes a serem utilizadas no momento de suas compilações.
Dpr Arquivo que contém as declarações de cada aplicativo desenvolvido no Delphi. É através
desse arquivo que o compilador pode identificar quais units pertencem ao aplicativo bem
como a forma com a qual o aplicativo será inicializado.
Dfm Esse arquivo contém o código responsável pela definição de cada formulário dentro da
aplicação, ou seja, é nesse arquivo que se encontra a indicação da localização de cada
componente do formulário bem como os valores a eles atribuídos dentro do Object
Inspector.
Pas Os arquivos com essa extensão contém código fonte escritos em Object Pascal. Esses
arquivos podem ou não estar associados a arquivos dfm.
Res Os arquivos com essa extensão contêm diversos recursos que serão ou poderão ser
utilizados pela aplicação tais como o ícone da aplicação e bitmaps entre outros.
Dof O arquivo de opções do Delphi (Delphi Options File) contém a configuração atual do
projeto. Tais configurações podem ser exibidas ao selecionarmos a opção Options listada
no menu Project.
Cfg O arquivo de extensão cfg é gravado para possibilitar a compilação de um projeto Delphi
a partir da linha de comando, sem ser necessário que o projeto seja aberto dento da IDE
do Delphi.

Além dos arquivos com as extensões listadas acima, o Delphi pode gerar outros arquivos de outras
extensões dependendo do tipo de aplicação que esteja sendo desenvolvido ou da configuração que tenha
sido feita na IDE do Delphi. A seguir mostramos uma figura representativa de alguns dos relacionamentos
existentes entre os arquivos gerados pelo Delphi.

A figura acima ilustra o relacionamento existente entre os arquivos de grupo, de projeto, dmf e pas no
desenvolvimento de um aplicativo Delphi. Podemos observar que as units não precisam estar vinculadas a
um arquivo de formulário, porém o inverso não acontece. Ou seja, para cada formulário que colocarmos
em nosso aplicativo existirá uma unit e um arquivo de formulário associado.

Página: 29
Delphi 5

2.8. Criando uma Console Application


Apesar de não ser o tipo de aplicação geralmente desenvolvido dentro do ambiente do Delphi, uma
aplicação console é uma das mais simples que podem ser desenvolvidas. Dessa forma, iremos apenas
ilustrar de maneira bastante simplificada o desenvolvimento de uma console application. Antes de
começarmos devemos fechar a aplicação ou aplicações Delphi que estiverem abertas na IDE para que,
dessa forma, possamos começar o desenvolvimento de uma nova aplicação. Poderíamos iniciar a nova
aplicação sem ter de fechar a aplicação anterior uma vez que o Delphi a fecharia automaticamente, porém é
bom nos acostumarmos a fechar por nossa própria conta os aplicativos que estivermos trabalhando antes de
começamos o desenvolvimento de um novo de forma a manter uma melhor organização em nosso trabalho.

Uma vez não existindo nenhum aplicativo temos dois caminhos a seguir: escolher a opção New Application
localizada no menu File e começar um novo aplicativo ou escolher a opção New localizada nesse mesmo
menu. Caso optemos pela primeira opção o Delphi irá propiciar o desenvolvimento de uma nova aplicação
padrão. Essa aplicação irá permitir, a menos que tenhamos
alterado a configuração inicial do Delphi, o desenvolvimento
de uma aplicação padrão para o ambiente gráfico e não uma
console application. Essa aplicação poderia ser modificada de
tal forma a permitir o desenvolvimento de uma console
application, porém essa não é a melhor alternativa,
principalmente para aquelas pessoas que estão iniciando o
processo de aprendizado dentro do Delphi. Dessa forma, resta-
nos partir para a segunda opção, a seleção da opção New
localizada no menu File. Ao fazermos isso, nos será
apresentada a caixa de diálogo New Items mostrada ao lado.
Através dessa caixa de diálogo podemos escolher dentre várias
opções de elementos contidos no Object Repository. Existe a opção de escolha desde formulários pré
definidos até wizards que irão facilitar o desenvolvimento de novas aplicações. Cada uma dessas opções
está dividida em guias de acordo com as suas finalidades. Para darmos início à nossa console application,
vamos selecionar o ícone Console Application localizado na guia New.

Uma vez selecionada essa opção, o Editor de Código do Delphi passa a exibir o código inicial de nossa
aplicação como mostrado na figura. Como podemos observar, uma aplicação console é composta,
inicialmente, pelo arquivo de projeto. Porém, ao
contrário do que acontecia com arquivos de
projeto comuns, existe no código apresentado
uma diretriz de compilação que indica ao
compilador Delphi que a aplicação sendo
desenvolvida trata-se de uma console
application e não uma aplicação com interface
gráfica tradicional. Excluindo essa diferença, o
restante do código apresentado no arquivo de
projeto é idêntico ao encontrado em aplicações
gráficas tradicionais, ou seja, é composto pela
palavra reservada program seguida pelo nome
da aplicação, uma seção indicada pela palavra uses que será vista posteriormente e, por fim, um bloco
begin e end que irá conter o código a ser executado pela aplicação.

Devemos fazer uma pequena observação com relação ao nome da aplicação escrito logo após a palavra
reservada program. Já mencionamos o fato de que , quando trabalhamos com o arquivo de projeto não
devemos fazer alterações manualmente uma vez que o Delphi faz as devidas alteações quando necessárias.
Essa observação também é válida quando estamos trabalhando com aplicações console. Devemos evitar
alterar o nome da aplicação diretamente no código fonte de nossa aplicação uma vez que o Delphi irá fazer
isso sem acarretar qualquer problema. Caso desejemos alterar o nome do aplicativo devemos fazê-lo
salvando-o com o nome que desejamos através da opção Save Project as localizada no menu File. O
Delphi, ao salvar o aplicativo ele alterará tanto o nome do programa contido no fonte do arquivo dpr
quanto irá alterar o nome físico do arquivo.

Página: 30
Delphi 5

Com o objetivo de ilustrar o desenvolvimento de uma aplicação console, vamos escrever o código
necessário para executar o mais tradicional exemplo de programa, o Alô Mundo. Para isso, no lugar do
comentário Insert user code here, devemos escrever o código abaixo.

Writeln(‘Alô Mundo´);

Após escrevermos o código acima, o Editor de Código


deverá estar conforme a figura abaixo. Podemos então
compilar e executar nossa aplicação. Caso tenhamos
optado pela compilação e posterior execução desse
programa dentro do próprio Delphi, a aplicação será
executada e retornará rapidamente para a IDE do Delphi.
Isso ocorre, como dito anteriormente, porque quando
executamos o aplicativo por dentro do Delphi, ele passa
a ser executado em modo de depuração e, logo após seu
término, o controle é retornado para a IDE. Uma vez que
essa aplicação não faz muita coisa, ela apenas exibe uma
mensagem na tela e logo em seguida é encerrada, sua
execução é muito rápida. Caso desejemos observar
melhor essa execução, deveremos fazê-lo através do Prompt do MS-DOS executando-a como qualquer
outro aplicativo.
O arquivo executável de nossa aplicação console é gerado por default no diretório onde salvamos os seus
arquivos fontes. Caso ainda não tenhamos salvo o aplicativo, o Delphi irá gerar o executável no diretório
Projects localizado abaixo do diretório de instalação do Delphi, o qual tem sua localização default no
diretório C:\Arquivos de Programas\Borland\Delphi5. Ao executarmos nossa aplicação veremos que será
exibida a linha Alô Mundo, e em seguida o programa é finalizado.

2.9. Criando uma aplicação GUI


Vimos até aqui como podemos utilizar o Delphi para criar uma aplicação console. Esse tipo de aplicação,
apesar de ser ainda utilizada, não é o principal tipo de aplicação a ser desenvolvida dentro do Delphi. Por
isso, vamos dar início ao desenvolvimento de nossa primeira, e mais simples, aplicação GUI.
Uma aplicação GUI, do inglês Graphical User Interface, é o tipo default desenvolvido pelo Delphi, ou
seja, é aquela que é executada dentro da interface gráfica do Windows, possuindo em geral um formulário
através do qual o usuário irá interagir com o aplicativo. Já vimos anteriormente um exemplo de uma
aplicação GUI através da qual uma mensagem era exibida quando o usuário dessa aplicação clicava no
botão existente no centro do formulário. Embora a aplicação apresentada não realize muita coisa de
produtiva ela já representa o início do processo de desenvolvimento de qualquer aplicação para o ambiente
gráfico, ou seja, a criação de um novo projeto, a definição do formulário principal da aplicação e a
colocação, nesse formulário, dos componentes que irão compor a interface entre a aplicação e o usuário.
Uma vez definido o aspecto visual do formulário é dado início ao processo de programação efetiva da
aplicação. São definidos quais eventos de quais componentes deverão ser tratados pelo aplicativo e, em
seguida, é feita a programação desses eventos. Uma vez feita a programação, o desenvolvedor pode
compilar e executar o aplicativo tanto para realização de testes e depuração quanto para a entrega desse ao
cliente ou às distribuidoras do software.
Vimos também alguns dos vários arquivos gerados quando salvamos nosso aplicativo bem como a
interação existente entre eles. Alguns desses arquivos foram apresentados com um pouco mais de detalhe
quando estávamos desenvolvendo uma aplicação console, resta-nos agora, apresentar de forma mais
detalhada cada um desses arquivos dentro de uma aplicação gráfica.
A criação de uma aplicação gráfica pode ser feita de forma semelhante à de uma aplicação console, ou seja,
podemos selecionar a opção New Application listada no menu File e criar uma aplicação default ou
poderíamos selecionar a opção New e selecionar a criação de um projeto pré definido existente dentro do

Página: 31
Delphi 5

Object Repository. Vamos abordar inicialmente a criação de uma aplicação default e mostrar a
funcionalidade de cada arquivo criado nesse processo.

2.9.1. Criando e alterando aplicação default


Ao selecionarmos a opção New Application o Delphi cria uma
nova aplicação contendo além do arquivo de projeto um
formulário e sua respectiva unit. Caso não tenhamos feita
qualquer alteração na configuração inicial do Delphi, a aplicação
default será composta de um formulário em branco, ou seja, um
formulário sem nenhum componente. No entanto esse
comportamento pode ser alterado a qualquer momento pelo
desenvolvedor através da opção Repository localizada no menu
Tools. Ao selecionarmos esse menu, a caixa de diálogo Object
Repository é exibida como mostrado ao lado. Através dessa caixa
de diálogo podemos escolher o comportamento default que será
seguido pelo Delphi ao criarmos novas aplicações e formulários.

A caixa de diálogo Object Repository está dividida em dois listboxes. O primeiro deles exibe o nome das
guias que são apresentadas na caixa de diálogo New Items (exibida quando selecionamos a opção New
localizada no menu File visto anteriormente). Além das guias exibidas no Object Repository, a caixa de
diálogo New Items ainda exibe algumas guias adicionais como, por exemplo, uma guia que contém os
próprios formulários contidos na aplicação corrente. Os primeiros três botões contidos nessa caixa de
diálogo permitem ao programador criar novas guias, bem como, renomear e remover as guias já existentes.

O segundo listbox exibe quais objetos estão localizados na guia selecionada. Ao selecionarmos um objeto,
os dois últimos botões ficam habilitados para que possamos tanto editar quanto remover do repositório esse
objeto. Além dos botões, encontram-se nessa caixa de diálogo três checkboxes, habilitados alternadamente,
que permitem tanto a escolha de qual formulário será definido como default, ou seja qual formulário será
criado ao selecionarmos a opção New Form contida no menu File, quanto qual formulário será definido
como o formulário principal default, ou seja, ao selecionarmos a opção New Application qual será o
formulário criado inicialmente. Além disso, temos a opção de definir qual o projeto default, ou seja, qual
será o formato da aplicação default a ser criada quando selecionarmos a opção New Application.

2.9.2. Utilizando Wizards


Além da possibilidade de criarmos um projeto em branco, a partir do qual iremos iniciar a construção de
um novo aplicativo, o Delphi também fornece ao programador alguns wizards que irão auxiliar no processo
de criação inicial desse aplicativo. Para que
isso seja possível devemos começar todo o
processo de criação através da seleção da
opção New ao invés de começarmos com a
escolha da opção New Application.

Como dito anteriormente, ao selecionarmos a


opção New, a caixa de diálogo New Items será
exibida. Nela devemos selecionar a guia
Projects conforme mostrado na figura ao lado.
Nessa guia temos a opção de escolher entre
alguns tipos de projetos pré-definidos como
também a construção de um novo projeto a
partir de um wizard. Um wizard nada mais é
do que um assistente que nos auxilia no
processo de desenvolvimento de novas

Página: 32
Delphi 5

aplicações. Através da seleção da opção Application Wizard o Delphi irá construir um novo aplicativo
utilizando-se para isso de respostas que o desenvolvedor for fornecendo a uma série de caixas de diálogo a
ele apresentadas.

A seqüência das caixas de diálogo que é


apresentada depende das opções que o
desenvolvedor for marcando no decorrer do
processo. Por exemplo, a primeira caixa de
diálogo apresentada pelo Application Wizard
permite que indiquemos quais menus o
desenvolvedor deseja que sejam exibidos em
sua aplicação. Temos a opção de escolher o
menu File e Edit entre outros conforme
ilustrado na figura ao lado. Caso o
desenvolvedor venha a selecionar o menu
File, a próxima caixa de diálogo a ser
apresentada irá perguntar quais as extensões
que o aplicativo sendo desenvolvido poderá manipular. Já no caso de não escolhermos o menu File, não
haverá a necessidade do Wizard nos apresentar essa caixa de diálogo.

Uma vez terminado o processo de construção inicial da aplicação através do Wizard, o Delphi disponibiliza
para o desenvolvedor uma aplicação com sua interface e, até mesmo, algum código pronto para que seja
dado início à codificação efetiva. Apesar da utilização do wizard proporcionar um ganho inicil no tempo de
desenvolvimento, sua utilização efetiva dentro do desenvolvimento de novas aplicações é relativamente
pequena. Essa pouca utilização deve-se principalmente ao fato de que o idioma no qual o formulários e
demais componentes são construídos é o inglês, o que não ajuda muito quando o desenvolvimento involve
um aplicativo para ser executado utilizando-se de um outro idioma.

2.10. O arquivo de Projeto


O arquivo de projeto contido em uma aplicação GUI é um pouco diferente em relação ao arquivo de
projeto apresentado anteriormente para uma aplicação
console. Mostramos ao lado a figura do arquivo de
projeto da aplicação GUI criada anteriormente. Nela
podemos observar tanto pontos comuns em relação ao
arquivo de projeto de nosso aplicativo console quanto
outros que não tínhamos até então. Podemos observar
que esse arquivo também é iniciado com a palavra
reservada program a qual indica o nome do projeto no
qual estamos trabalhando. Novamente ressaltamos que
não devemos alterar esse nome manualmente, ao invés
disso, devemos salvar o nosso projeto com um novo
nome para que o Delphi altere o nome do projeto para
nós.

program Project1;

A próxima seção encontrada no arquivo de projeto é iniciada pela palavra reservada uses. Essa seção é
bastante importante uma vez que ela indica quais arquivos são necessários à compilação de nosso
aplicativo. Na maioria dos casos o Delphi irá manipular diretamente essa seção do arquivo de projeto a
medida em que formos incluindo ou excluindo formulários de nossa aplicação, porém, em algumas
situações poderemos querer acrescentar manualmente algum arquivo nessa seção.

uses
Forms,
Unit1 in 'Unit1.pas' {Form1};

Página: 33
Delphi 5

Podemos observar que existem dois tipos de declarações dentro da seção uses exibida acima. A primeira
delas contém uma referência a uma unit (a unit Forms) que, a princípio, não está incluída em nosso
aplicativo enquanto que a segunda é a unit associada ao formulário inicial de nosso aplicativo (a unit
Unit1). A declaração da unit Forms no arquivo de projeto é importante uma vez que é nessa unit que estão
as declarações de funções e variáveis necessárias ao funcionamento inicial do aplicativo e não deve ser
removida. Já a segunda declaração indica a existência da Unit1 dentro do projeto. A medida em que novas
units vão sendo adicionadas ao projeto as suas respectivas declarações vão sendo colocadas na nessa seção
uses automaticamente pelo Delphi.
Outro ponto importante a ser mencionado é a forma com que o Delphi declara essas units dentro da seção
uses. Observe que a declaração da unit não utiliza a sua extensão. Essa é a razão pela qual, no momento em
que salvamos o projeto, ele não deve ter um nome que já tenha sido previamente atribuído a uma unit. Uma
vez que, dessa forma, o compilador Delphi não teria como distinguir quando o programador estivesse
fazendo referência a uma unit ou ao projeto.
Um último ponto a ser discutido aqui, porém também de fundamental importância é a localização das units
em disco. O Delphi, ao tentar abrir qualquer unit para compilação ou simplesmente para a sua exibição no
Editor de Código, irá procurar no diretório onde o projeto foi salvo, ou no path definido dentro do arquivo
de projeto. Caso tenhamos salvo uma unit dentro de um diretório diferente daquele no qual o projeto foi
salvo, essa informação ficará armazenada no arquivo de projeto e, quando tentarmos abrir esse projeto em
um outro computador, o Delphi irá procurar por essa unit na localização onde ele havia sido salvo.

uses
Forms,
Unit1 in 'Unit1.pas' {Form1},
Unit2 in '../Unit2.pas' {Form2},
Unit3 in 'Unit3.pas';

No exemplo acima, temos três units contidas no projeto, as duas primeiras referentes aos formulários 1 e 2,
e a última uma unit que não está vinculada a qualquer formulário. Observe que a unit2 não foi salva no
mesmo diretório que o projeto e sua localização está indicada através do seu caminho relativo em relação
ao qual o projeto foi salvo. Devemos ter cuidado uma vez que, ao salvarmos as units em diretórios
diferentes daquele no qual o projeto foi salvo estamos, também, dificultando o processo de backup dos
arquivos fonte pertencentes a esses projetos.
Uma outra definição colocado no arquivo de projeto refere-se a qual arquivo de recursos será utilizado
pela aplicação sendo desenvolvida. Em geral esse arquivo possui o mesmo nome que o arquivo de projeto
porém com a extensão RES. Essa informação é passada ao compilador por intermédio da diretiva de
compilação $R conforme mostrado abaixo.

{$R *.RES}

O asterisco colocado nessa diretiva indica que o arquivo de recursos irá possuir o mesmo nome que o
arquivo de projeto. No caso de desejarmos incluir um arquivo com nome diferente bastaria que, no lugar do
asterisco, fosse informado o nome desse arquivo.

O último trecho do arquivo de projeto, definido pelas palavras reservadas begin e end indica, como
acontecia com as aplicações console, o código a ser executado inicialmente pelo aplicativo. Porém, o
código escrito nessa seção é manipulado diretamente pelo Delphi e não devemos mexer diretamente com
ele a menos que tenhamos certeza absoluta do que estamos fazendo uma vez que, uma alteração
equivocada nesse trecho do programa poderá provocar seu mal funcionamento ou, até mesmo, a
impossibilidade de sua execução.

Em uma aplicação gráfica, como a exibida acima, o código escrito entre o begin e o end poderá conter o
código responsável pela alocação de memória dos formulários e a execução real da aplicação. Veremos
posteriormente como podemos criar formulários dinamicamente durante a execução de nosso aplicativo.
Nesses casos, a alocação de memória para esses formulários não será feita mais no arquivo de projeto mas
begin
Application.Initialize;
Application.CreateForm(TForm1, Form1);
Application.CreateForm(TForm2, Form2); Página: 34
Application.Run;
end.
Delphi 5

sim em algum ponto antes do qual será necessária a exibição desse formulário.

2.11. Manipulando com as opções do projeto


Uma vez que dentro do Delphi trabalhamos sempre com projetos devemos aprender a configurar cada um
deles. A configuração das opções de nossos projetos é feita através da item de menu Options contido no
menu Project. Ao selecionarmos essa opção, a caixa de diálogo mostrada ao lado é exibida. Essa caixa de
diálogo está divida em diversas guias responsáveis pela configuração do projeto aberto na IDE do Delphi
naquele momento. Veremos as principais delas a seguir.
A primeira guia que iremos estudar a respeito da caixa de diálogo Project Options é a guia Forms,
mostrada na figura ao lado. Essa guia contém, basicamente, um combobox e dois listboxes. O combobox
permite escolhermos qual será o formulário principal de nossa aplicação. Sempre que criarmos um projeto,
o formulário principal é aquele criado inicialmente. Porém nada impede que desenvolvamos o formulário
principal do aplicativo posteriormente. Uma vez criado o novo formulário, para tornarmos esse novo
formulário o principal de nossa aplicação basta selecionarmos no combobox o formulário desejado.
Já os dois listboxes contidos na guia Forms são utilizados para
identificar quais formulários de nossa aplicação são criados ou não
pelo Delphi automaticamente. Aqueles que o programador deseje
criar manualmente deverão estar listados no listbox Available forms enquanto
que aqueles que devem ser criados automaticamente estarão no listbox Auto-
create forms. Uma vez que apresentamos as opções contidas nesta guia temos
duas observações a fazer. A primeira observação está relacionada ao próprio
arquivo de projeto. Como citado anteriormente, não devemos fazer alterações
diretamente no arquivo de projeto uma vez que o Delphi irá manipular com
esse arquivo diretamente. Essa situação pode ser facilmente observada. Para
isso, vamos criar uma nova aplicação que irá conter três formulários de acordo
com as figuras ao lado. Conforme podemos observar, a criação dos
formulários foi feita de tal forma que o formulário principal da aplicação foi o
formulário Form1, porém decidimos que o formulário que deveria ser
utilizado como formulário principal seria o segundo formulário, ou seja, o
formulário Form2. Veremos posteriormente qual a finalidade dos formulários
Form1 e Form3. Já sabemos como fazer essa alteração, porém vamos observar
o arquivo de projeto antes de realizarmos essa alteração para compararmos as
alterações feitas pelo Delphi posteriormente.
Ao realizarmos a alteração, podemos perceber que a ordem de execução do código existente no arquivo de
begin foi invertida. Agora, o primeiro comando de criação
projeto begin de um formulário refere-se ao formulário
Application.Initialize;
Form2 e não mais ao Form1 como era inicialmente. AApplication.Initialize;
alteração poderia ter sido feita, manualmente,
Application.CreateForm(TForm1,
diretamente no arquivo de projeto queForm1); Application.CreateForm(TForm2,
ela já seria exibida na caixa de diálogo Project Options.Form2);
Application.CreateForm(TForm2, Form2); Application.CreateForm(TForm1, Form1);
Application.CreateForm(TForm3, Form3); Application.CreateForm(TForm3, Form3);
Application.Run; Application.Run;
end. end.

Página: 35
Delphi 5

A segunda observação refere-se aos listboxes apresentados nessa caixa de diálogo. Ao criarmos uma
aplicação dentro do Delphi e definirmos um ou mais formulários, o Delphi tem, por definição, a criação
automática de todos esses formulários, ou seja, ao executarmos o aplicativo, antes dele começar a sua
execução real exibindo a sua janela principal, será alocada memória para todos esses formulários. Esse
comportamento tem tanto seu lado positivo quanto seu lado negativo. O lado positivo está no fato de que,
ao tentarmos exibir qualquer formulário definido em nosso projeto, sua exibição será feita de forma mais
rápida uma vez que ele já foi construído em memória. Porém, uma vez que já alocamos memória para todos
os formulários da aplicação, poderemos estar reservando recursos do computador que nunca serão
utilizados, no caso por exemplo de um formulário pouco exibido, o que não é muito bom. Para evitar esses
dois extremos o Delphi permite-nos selecionar quais formulários deverão ser criados ou não
automaticamente durante o início da execução do programa. Para ilustrarmos os efeitos de termos um
formulário criado automaticamente ou não no arquivo de projeto vamos, em nosso exemplo, mover o
formulário Form3 do listbox Auto-create forms para o listbox Available forms. Ao fazermos isso, podemos
perceber que a linha referente a criação do begin
formulário Form3, contida no arquivo de projeto, Application.Initialize;
foi removida conforme ilustrado ao lado. Da Application.CreateForm(TForm2, Form2);
mesma forma, poderíamos ter feito essa alteração Application.CreateForm(TForm1, Form1);
diretamente no arquivo de projeto sem termos de Application.Run;
alterar essa informação na caixa de diálogo Project
end.
Options, como havia acontecido com a definição do
formulário principal de nossa aplicação.
A princípio poderíamos pensar que a alteração
procedure TForm2.Button1Click(Sender: TObject); de definição entre aqueles formulários criados
begin automaticamente e aqueles que estão
Form1.Show; disponíveis para o uso do desenvolvedor não
end; traria qualquer problema para a programação,
porém isso não é verdade. Para demostrarmos
procedure TForm2.Button2Click(Sender: TObject); esse problema, bastante comum quando ainda
begin não temos muita experiência em programação
Form3.Show; principalmente para o ambiente Windows,
end; vamos criar dois procedimentos, cujo código
estamos apresentando ao lado, associados
respectivamente, ao evento OnClick em cada um dos botões colocados no formulário principal de nosso
aplicativo, o Form2. Observe que não devemos escrever todo o código, mas sim as linhas contidas entre o
begin e o end de cada procedimento.
Uma vez que tenhamos escrito o código de cada procedimento
podemos compilar a aplicação. A tentativa de compilação irá resultar
em três erros conforme mostra a figura ao lado. A única opção que
temos nesse momento é pressionar o botão OK. Ao fazermos isso, uma
mensagem semelhante aquela apresentada abaixo é exibida. Por ora
não iremos fornecer uma explicação a respeito do significado dessa
mensagem. Apenas vamos clicar no botão Yes. Feito
isso uma segunda caixa de diálogo, desta vez
referente ao formulário Form3 será exibida e,
novamente, devemos clicar o botão Yes. O Delphi
retorna para o Editor de Código para que possamos
tentar compilar novamente a nossa aplicação. Desta
vez, a aplicação será compilada sem problemas, gerando o executável de nosso aplicativo. Podemos então
executá-lo dentro do ambiente Delphi como também fora dele.
Ao executarmos a aplicação, o formulário principal da
aplicação será exibido. Nele, como poderíamos esperar, estão
contidos dois botões que, ao serem clicados, irão executar o
código que escrevemos anteriormente. Ao clicarmos no
primeiro botão o formulário Form1 é exibido uma vez que
essa foi a função do código que escrevemos no evento OnClick do botão Button1. Porém, ao clicarmos no
botão 2 a mensagem de erro mostrada ao lado é exibida. A ocorrência desse erro deve-se justamente a não
criação automática do formulário pelo Delphi. Uma vez que ainda não criamos o formulário, ou seja,
nenhuma memória foi alocada para conter os valores atribuídos às suas propriedades e métodos, ao

Página: 36
Delphi 5

invocarmos um de seus métodos (o método Show que veremos posteriormente), isso irá provocar um
acesso ilegal à memória do Windows. Para evitarmos que isso ocorra, devemos nos preocupar em alocar
memória para esses objetos antes de podermos utilizá-los e, posteriormente à sua utilização, devemos
também desalocar essa memória, liberando-a para outros objetos tanto dessa quanto de outras aplicações.
A próxima guia da caixa de diálogo Project Options que iremos
abordar é a guia Application. Através dessa guia, exibida ao lado, o
programador pode definir algumas características próprias da
aplicação. Nela temos a opção de definir um título para a aplicação,
título esse que será exibido quando a aplicação for minimizada, o
nome do arquivo de ajuda que será associado ao aplicativo e o ícone a
ser exibido quando a aplicação for minimizada. Por fim, temos a
opção de indicar qual a extensão a ser atribuída ao arquivo a ser
gerado pela compilação do código fonte de nossa aplicação. Devemos
observar que aplicações de extensão exe não necessitam do
preenchimento dessa opção. Já ao desenvolvermos DLLs ou arquivos
ActiveX, a extensão desejada para o arquivo compilado, seja dll ou ocx, deverá ser indicada nessa opção.
Uma outra guia cujo conteúdo vale a pena ser abordado é a guia Directories/Conditionals. Vimos
anteriormente que uma aplicação Delphi é capaz de gerar diversos arquivos cada um com a sua respectiva
extensão. Porém só vimos algumas das extensões que o Delphi é capaz
de gerar. Além daquelas extensões relativas a arquivos de código fonte,
ao compilarmos nossas aplicações o Delphi gera novos arquivos de
código objeto. O comportamento default do ambiente Delphi é gerar
esses arquivos de código objeto no mesmo diretório onde se encontra o
arquivo de projeto. No caso de desejarmos efetuar backups de nossas
aplicações isso não é muito desejável já que o backup só necessita ser
feito para os arquivos de código fonte uma vez que os arquivos de
código objeto são gerados a partir deles. O ideal é que esses arquivos
fossem gerados em outros diretórios. Essa é uma das finalidades da guia
Directories/Conditionals, ou seja, definir os diretórios nos quais
arquivos de código objeto serão gerados. A figura ao lado mostra a guia Directories/Conditionals definido
os diretórios nos quais os arquivos compilados e os executáveis serão gerados. Caso nada for colocado,
será assumido o diretório aonde foi salvo o projeto.
Por fim vamos falar da guia Packages. Devemos ter muito cuidado ao manipular com os elementos desta
guia, pois isso poderá afetar toda a instalação do Delphi. A guia Packages permite ao desenvolvedor
definir quais os pacotes instalados que poderão ser utilizados durante o desenvolvimento de uma aplicação
bem como se a aplicação gerada irá ou não utilizar pacotes (packages) em tempo de execução. Pacotes são
arquivos especiais do Delphi que irão conter, entre outras coisas, todas
as definições das classes e componentes que podem ser utilizados
assemelhando-se a uma DLL. Através da seleção dos Design Packasges
podemos definir quais os pacotes que estão disponíveis dentro da IDE
do Delphi. Devemos tomar cuidado ao remover pacotes pois, ao
fazermos isso, poderemos estar removendo guias inteiras da Paleta de
Componentes. Uma vez removido o pacote, para que os componentes
removidos reapareçam temos de acrescentar o pacote novamente. Já a
opção Build with runtime packages indica ao compilador Delphi que o
executável do aplicativo utilizará pacotes em tempo de execução. Ao
selecionarmos essa opção passamos a gerar arquivos executáveis com
um tamanho menor, porém passamos a ter a necessidade de levar, junto com os arquivos da aplicação, os
pacotes de componentes que foram utilizados durante o desenvolvimento desse projeto. Lembre-se que
esses pacotes, por possuírem todo um conjunto de componentes dentro deles, não são arquivos pequenos o
que poderá tornar uma desvantagem ter de leva-los junto com o executável do projeto. É função do
desenvolvedor identificar a opção a ser adotada.
Agora que já temos um bom número de informações a respeito de um projeto sendo desenvolvido em
Delphi, podemos nos concentrar nos demais arquivos de código fonte que irão compor as aplicações que
iremos desenvolver. Dessa forma, vamos começar o nosso estudo a respeito das units, sua composição e do
Editor de Código.

Página: 37
Delphi 5

3.As Units
As units formam, principalmente nas aplicações gráficas, o coração de toda a aplicação. É nas units que
todo o código fonte da aplicação é escrito. Nela encontram-se tanto definições a respeito de variáveis e
constantes quanto a implementação dos procedimentos e funções existentes na aplicação.
Toda unit é composta de pelo menos duas palavras reservadas utilizadas para indicar compilador o início e
o término da unit. Essas palavras reservadas são unit e end.
Conforme o código escrito ao lado, podemos observar que a unit Unit1;
palavra reservada unit é utilizada para indicar o início de uma
unit. Ao lado direito da palavra unit está a indicação de seu interface
nome. Observe que esse nome é igual ao nome do arquivo salvo
em disco, porém sem a extensão pas. Não devemos alterar implementation
manualmente o nome da unit e sim utilizar a opção Save As
localizada no menu File. Observe também que a unit é finalizada end.
pela palavra reservada end, seguida por um ponto. Devemos
observar que a palavra reservada end irá aparecer em diversos outros trechos de código dentro das units,
porém o único local onde ela irá ocorrer, seguida de um ponto, é no final da unit. Não devemos alterar essa
estrutura da unit uma vez que esse end indica o final da unit. Programadores inexperientes na programação
utilizando o Delphi trocam frequentemente o ponto por ponto-e-vírgula o que faz com que a compilação do
aplicativo não mais possa ser feita.

3.1. As seções de uma unit


Dentro das aplicações Delphi que iremos desenvolver deveremos escrever código fonte dentro das units
que irão compor nossos projetos. A unit é dividida em várias seções e, dessa forma, devemos entender o
funcionamento de cada uma dessas seções para sabermos em qual delas o código que pretendemos escrever
irá melhor se encaixar.
Toda unit pode ser dividida em quatro seções distintas, são elas:
• Interface
• Implementation
• Initialization
• Finalization
As duas primeiras seções da unit apresentadas acima, as seções interface e implementation, são obrigatórias
quando do desenvolvimento de uma nova unit enquanto que as duas últimas seções, initialization e
finalization, são opcionais. Dentro do código de uma unit, as seções são escritas na seqüência em que
apresentamos acima, ou seja, a primeira seção existente dentro de uma unit é a seção interface, enquanto
que a última é a seção finalization. Nesta seção vamos nos detalhar um pouco mais nas seções interface e
finalization uma vez que essas duas são as mais utilizadas durante o desenvolvimento de um novo projeto.

3.1.1. A seção interface


A primeira seção encontrada em uma unit é a seção interface. A principal funcionalidade da seção interface
é conter declarações. Essas declarações podem ser tanto declarações de variáveis e constantes quanto de
funções e procedimentos. As declarações contidas nesta seção, ao contrário do que acontece nas demais
seções de uma unit, poderão ser vistas e utilizadas por outras units contidas tanto no projeto correntemente
sendo desenvolvido
quanto em outros
projetos a serem
desenvolvidos. A
figura ao lado
apresenta a relação de
comportamento da
seção interface em

Página: 38
Delphi 5

comparação às demais seções que podem estar contidas em uma unit. Esse comportamento é idêntico
independentemente das units pertencerem ao mesmo projeto ou estarem contidas em projetos distintos.
Já sabemos que a seção interface é utilizada para tornar diversos tipos de declarações disponíveis para
outras units. Porém, não basta apenas escrevermos na seção interface o código que desejamos compartilhar
com outras units para que esse compartilhamento ocorra. Para que isso seja possível, algumas ações por
conta do programador devem ser realizadas. Veremos agora, as cláusulas nas quais a seção interface está
dividida e como poderemos utiliza-las para declarar código e tornar esse código compartilhado com outras
units.

3.1.1.1.A cláusula Uses


A cláusula uses é utilizada dentro da seção interface de uma unit para indicar quais units contém
declarações em suas seções interface
que são necessárias à compilação da unit UExemplo1;
unit atual. O código ao lado mostra a
utilização da cláusula uses dentro de interface
uma unit. Nesse exemplo a unit
corrente, chamada de UExemplo1, uses
possui em sua cláusula uses localizada Windows, Messages, SysUtils, Classes, Graphics;
na seção interface referências a 5 units. …
Ao declararmos essas units passamos a
ter acesso a todas as declarações feitas em suas seções interface. Ou seja, caso exista a declaração de uma
variável chamada resposta dentro da unit SysUtils, a partir desse momento ela poderá ser referenciada e
utilizada na unit UExemplo1 sem qualquer problema. Como pudemos observar, as units constantes na
cláusula uses estão separadas por vírgula e não estão listadas com suas extensões. Além disso, a declaração
é finalizada por um ponto-e-vírgula. Essa cláusula não é obrigatória, porém é amplamente utilizada na
maioria das aplicações que serão desenvolvidas.
Duas observações se fazem necessárias com relação à utilização da cláusula uses dentro de um projeto
Delphi. A primeira delas refere-se ao encadeamento de declarações na cláusula uses. O Delphi não
possibilita o
encadeamento de
declarações. Ou seja,
caso existam três units
na qual a primeira
utiliza a segunda que
por sua vez utiliza a
terceira, as
declarações contidas
na terceira não estarão
disponíveis para uso na primeira unit. Caso isso seja desejável, a primeira unit deverá fazer referência
diretamente a terceira unit. A segunda observação refere-se a um problema que ocorria com bastante
freqüência nas versões mais antigas do Delphi, a referência circular. Esse problema ocorre quando as
declarações feitas na cláusula uses de duas ou mais units ocasionam a formação de um círculo. A figura ao
lado ilustra a ocorrência de uma referência circular. Esse problema impede que a compilação do projeto
seja feita e por isso deve ser evitada.
Já sabemos que podemos fazer referência a declarações existentes em outras units contidas tanto no projeto
corrente quanto em qualquer outro projeto relacionando o nome da unit na cláusula uses, porém ainda não
sabemos como fazer essas declarações. Dessa forma, iremos apresentar as demais cláusulas que podem ser
definidas dentro da seção interface de uma unit.

3.1.1.2.Tipos básicos do Delphi


Antes de começarmos a falar a respeito de declarações de variáveis e constantes que podem ser utilizadas
pelo nosso projeto devemos tomar conhecimentos dos principais tipos de dados que estão disponíveis no
Delphi. Existe uma quantidade muito grande de tipos pré-definidos que podem ser utilizados pelos
programadores no desenvolvimento de suas aplicações, por esse motivo, iremos apresentar no quadro
abaixo apenas um pequeno resumo daqueles tipos de dados que serão mais utilizados no desenvolvimento
de nossas aplicações.

Página: 39
Delphi 5

Tipo Básico Faixa de valores


Byte 0 .. 255
Word 0 .. 65535
Integer –2147483648 .. 2147483647
Cardinal 0 .. 4294967295
Real 2.9 x 10^–39 .. 1.7 x 10^38
Extended 3.6 x 10^–4951 .. 1.1 x 10^4932
Currency –922337203685477.5808.. 922337203685477.5807
Char Um caractere
String Aproximadamente 2^31 caracteres
Boolean Valor booleano (True ou False)
TDateTime Data e hora

3.1.1.3.Declarações de tipos
Além dos tipos básicos apresentados acima e ainda, aqueles que mesmo não tendo sido exibidos acima
compõe os tipos básicos do Delphi, o desenvolvedor ainda dispõe da possibilidade de criar seus próprios
tipos de dados. Uma vez que esses novos tipos de dados forem criados, eles podem ser utilizados
normalmente como se fossem tipos básicos da linguagem, podendo ser declaradas variáveis e constantes a
partir deles.
Existem cinco possibilidades de criarmos novos tipos de dados dentro do Delphi, são elas:
• Tipos simples
• Conjutnos (Sets)
• Tipos Enumerados
• Registros
• Classes
Colocamos nessa definição a possibilidade de criarmos classes como um novo tipo de dado por duas razões
básicas. A primeria delas deve-se ao fato de que a localização de suas declarações é a mesma dos demais
tipos de dados vistos, todos estão
localizados na cláusula type da unit. A unit UExemplo1;
segunda razão é devido a forma de
utilização das mesmas, ou seja, uma vez interface
declarada uma classe ela pode ser utilizada
na declaração de variáveis, que no caso de type
estarmos trabalhando com classes serão nome = string[50];
chamados de objetos, que pertençam a ela funcionario = record
entre outras coisas. Independentemente do fnome : nome;
fato de estarmos trabalhando com classes ou idade : byte;
qualquer outro novo tipo de dados, ao ser end;
declarado, ele será sempre colocado no TForm1 = class (TForm)
mesmo trecho da unit, ou seja, em sua seção End;
type, seção responsável por conter todas as …
novas declarações de tipos dentro de uma
unit. O exemplo ao lado ilustra a declaração
de novos tipos de dados.
Dois pontos podem ser observados tendo em vista o exemplo dado. O primeiro ponto refere-se ao fato de
podermos ter várias declarações de novos tipos dentro de uma mesma cláusula type. Esse ponto que
estamos abordando agora não é válido apenas quando estamos definindo novos tipos de dados. Cada uma
das cláusulas até aqui apresentadas ou aquelas que ainda serão vistas possuem seu escopo definido até o

Página: 40
Delphi 5

início da próxima cláusula. Dessa forma não é necessária a cada nova definição de tipo a colocação da
palavra reservada type.
O segundo ponto que devemos observar é a própria declaração de novos tipos de dados. No exemplo
apresentado acima são declarados três novos tipos. O primeiro deles refere-se à criação de um tipo simples,
já o segundo a um registro enquanto que o terceiro refere-se a uma classe.

3.1.1.3.1.Tipos de dados simples


A declaração de um novo tipo simples é a mais fácil dentre as três. Quando declaramos um novo tipo
simples não estamos fazendo nada mais do que criando uma espécie de sinónimo para um tipo de dados já
existente, seja ele um tipo de dados básico ou um outro tipo criado também na cláusula type. No exemplo
dado a seguir, está sendo criado um novo tipo de dados chamado nome. Esse novo tipo é, simplesmente,
uma nova representação para o tipo de dados básico string que, neste caso, irá possuir um tamanho máximo
de 50 caracteres. Uma vez que declaramos o novo tipo nome, podemos passar a utilizá-lo em novas
declarações, como foi feito dentro da declaração do tipo funcionario. Apresentamos a seguir a sintaxe para
a declaração de um novo tipo de dados simples.

Sintaxe
NomeNovoTipo = TipoBasico;

Exemplo
Nome = string[50];
Como podemos observar na sintaxe apresentada acima, a declaração de novos tipos de dados simples
restringe-se basicamente à atribuição de um novo nome a um tipo de dados básico ou que tenha sido
previamente definido na cláusula type. Podemos então perguntar qual a finalidade de declararmos um tipo
de dados simples! A resposta é mais semântica do que prática. Uma vez que criemos um novo tipo de
dados simples, como o tipo de dados nome criado no exemplo anterior, torna-se muito mais simples o
entendimento da funcionalidade das variáveis desse novo tipo do que no caso de sua não existência, ou
seja, ao declararmos uma variável pertencente a esse tipo de dados fica clara a sua finalidade, a de estar
manipulando um nome.
Uma outra vantagem em estar trabalhando com um tipo de dados simples está na manutenção do código
fonte criado. Caso desejemos alterar o tamanho das variáveis do tipo nome basta que o façamos em um
único lugar que essa alteração será refletida em todas os pontos do programa onde variáveis desse tipo
haviam sido declaradas.

3.1.1.3.2.Conjutos
Uma segunda maneira de declararmos novos tipos de dados dentro do Delphi é através da declaração de
conjuntos (sets). Um conjunto funciona de forma semelhante à um array (a declaração de arrays será vista
posteriormente dentro da declaração de variáveis) podendo conter uma série de valores simultaneamente
dentro de sua definição. A seguir apresentamos a sintaxe e alguns exemplos relacionados à declaração de
um tipo de dados conjunto.

Sintaxe
NomeNovoTipo = set of TipoBasico

Exemplo
Respostas = set of char;
Resultados = set of 1..50;
A declaração de conjuntos permite que sejam criadas variáveis que irão conter um conjunto de valores
válidos dentro daqueles fornecidos através da declaração do novo tipo. No exemplo acima, a declaração do
tipo de dados Respostas irá permitir que variáveis desse novo tipo armazenem um conjunto de caracteres,
bem como o tipo de dados Resultados irá permitir o armazenamento de um conjunto de valores de 1 à 50.
Apesar de ainda não termos mostrado como é feita a declaração de variáveis dentro do Delphi, o exemplo a
seguir ilustra a atribuição de valores à variáveis dos tipos criados no exemplo acima. Para obter
informações a respeito da declaração de variáveis, o leitor deve consultar a próxima seção deste capítulo.

Página: 41
Delphi 5

Exemplo
Resp1 := [ ‘a’, ‘g’, ‘e’, ‘d’];
Resul1 := [1, 34, 44, 3];
Como podemos observar, na atribuição de valores à variáveis do tipo conjunto, é utilizados os sinais de ‘[‘
e ‘]’. Entre esses sinais, são colocados os valores atribuídos à variável em questão. Um outro ponto a ser
observado refere-se a não existência de ordenação nem de duplicidade dentro dos valores atribuídos ao
conjunto. Podemos observar algumas propriedades do tipo conjunto no Object Inspector. Uma dessas
propriedades é a BorderIcons pertencente ao formulário. No Object Inspector a manipulação dos valores
que estão contidos no conjunto é feita de forma muito mais simples, atribuindo-se o valor true àqueles
valores que desejamos que estejam no conjunto e false caso contrário. No caso de desejarmos modificar
esses valores via codificação, devemos seguir a sintaxe apresentada acima.
Além da atribuição de valores à variáveis do tipo conjunto, operações de manipulação desses valores
podem ser efetuadas durante a codificação de nosso aplicativo, observe o seguinte exemplo.

Exemplo
Resp1 := [‘c’, ‘g’] + [‘d’, ‘c’];
Resul1 := Resul1 – [34, 12];
if ‘e’ in Resp1 then
ShowMessage(‘Valor já atribuído);
Os exemplos mostrados acima ilustram dois pontos importantes a serem observados com relação as
variáveis do conjunto. O primeiro ponto refere-se às operações de adição e subtração de elementos de um
conjunto. Como podemos observar essas duas operações são bastante intuitivas e funcionam de forma
semelhante àquela vista na matemática. Ao somarmos dois conjuntos, como mostrado no primeiro
exemplo, o resultado formado por um único conjunto composto pelos caracteres ‘c’, ‘g’, ‘d’, é atribuído à
variável Resp1. Observe que não existem duas ocorrências do caractere ‘c’, ou seja, elementos repetidos
são eliminados do conjunto permanecendo apenas uma cópia de cada elemento. Fato semelhante ocorre no
segundo exemplo ao tentarmos subtrair um conjunto de outro. A tentativa de remover um elemento
inexistente de um conjunto não provoca erro. Além disso, podemos utilizar a própria variável na qual
desejamos colocar o resultado da operação como um dos elementos que irão compô-la. Nesse exemplo,
estamos removendo os elementos 34 e 12 do conjunto Resul1. Por fim, o terceiro exemplo ilustra a
utilização do operador in. Esse operador é utilizado para verificar a existência ou não de um elemento em
um conjunto. Caso o elemento exista, o resultado da operação é o valor booleano true, caso contrário o
resultado será false.

3.1.1.3.3.Tipos enumerados
Além da possibilidade de declararmos tipos de dados simples e conjuntos, uma outra possibilidade de
declaração de tipos de dados é a declaração de tipos enumerados. Uma maneira simplificada de definirmos
tipos enumerados é que um tipo enumerado é composto por uma listagem de possíveis valores a serem
atribuídos a uma variável do tipo sendo definido. Um exemplo típico de um tipo enumerado, é o tipo de
dados boolean. Quando declaramos uma variável desse tipo já sabemos quais os valores que podem ser
atribuídos a ela: true ou false. Observe que esses valores não são strings, são valores tratados de maneira
idêntica a valores como os números e por isso não vem entre aspas durante uma atribuição. Uma vez que
declaremos uma variável booleana, qualquer outro valor que tentemos atribuir resultará em um erro de
sintaxe e a aplicação não poderá ser compilada. A seguir apresentamos a sintaxe para a declaração de tipos
enumerados.

Sintaxe
NomeNovoTipo = (Valor1, Valor2, ..., ValorN);

Exemplo
Cores = (Verde, Vermelho, Azul, Amarelo);
Naipes = (Ouro, Copas, Espadas, Paus);

Página: 42
Delphi 5

Observe os exemplos acima. Neles podemos perceber que quando criamos um tipo de dados enumerado,
estamos definindo quais valores podem ser atribuídos à variáveis desse novo tipo. No exemplo dado acima,
caso desejássemos criar uma variável do tipo de dados chamado cores, os únicos valores que poderiam ser
atribuídos a essa variável seria um dos seguintes valores: Verde, Vermelho, Azul ou Amarelo. É importante
observar que ao tentarmos atribuir qualquer um desses valores a uma variável, o valor deveria ser atribuído
diretamente, como mencionado anteriormente, uma vez que o valor não é uma string e sim um valor
específico para um tipo enumerado. Ilustramos essa observação a seguir através da atribuição de um valor à
variável UmaCor. Essa variável foi previamente declarada como sendo do tipo Cores apesar de no exemplo
esse fato não estar sendo mostrado. Mostraremos como declarar variáveis posteriormente nesse capítulo.

Exemplo
UmaCor := Azul; {Atribuição correta}
UmaCor := ‘Azul’; {Atribuição errada, não é uma string}
UmaCor := Branco; {Atribuição errada, não existe o valor Branco}
Um outro ponto a ser mencionado quando trabalhamos com tipos enumerados refere-se ao fato de que a
definição dos valores que irão compor o tipo enumerado também estabelece uma ordenação sobre eles. Ou
seja, a cada valor definido para o tipo enumerado está associada a sua posição em relação aos demais
valores. No exemplo dado anteriormente, o valor Vermelho possui valor de ordenação menor do que o
valor Azul, sendo considerado portanto menor do que o Azul, que, por sua vez, possui um valor de
ordenação menor do que o valor Amarelo. Dessa forma, é perfeitamente possível a escrita de código
comparativo entre esses valores como mostrado a seguir.

Exemplo
if UmaCor <= Vermelho then
Nesse exemplo mostramos a comparação do valor contido na variável UmaCor com um dos valores do tipo
de dados enumerado Cor. Esse tipo de operação bem como qualquer outra que envolva a necessidade de
comparação entre os elementos de um tipo enumerado pode ser efetuado sem qualquer problema.

3.1.1.3.4.Registros
Até agora vimos como declarar novos tipos de dados que, de uma certa forma, podem ser considerados
como novos tipos de dados simples. A partir de agora vamos ver como podemos declarar tipos de dados
que sejam mais complexos do que os que vimos até então. A primeira forma que podemos declarar esses
tipos mais elaborados é através da declaração de um tipo de dados registro. Um tipo de dados registro é
composto por declarações de vários tipos de dados diferentes em uma única declaração, onde cada um
desses tipos é chamado de um campo dentro do registro. Mostramos abaixo a sintaxe para a declaração de
um registro.

Sintaxe
NomeNovoTipo = record
Campo1 : TipoCampo;
...
CampoN : TipoCampo;
end;

Exemplo
TFuncionario = record
Nome : string[50];
Idade : byte;
Cargo, Setor : string[30];

Página: 43
Delphi 5

end;
Observe que ao declararmos o tipo de dados TFuncionario estamos, antes de tudo, respeitanto um padrão
adotado no desenvolvimento de novos registros, e posteriormente como iremos observar, como também de
novas classes, iniciando o nome de cada novo tipo com a letra ‘T’. Uma vez feita essa observação com
relação ao nome do tipo de dados, voltemos à explicação do exemplo propriamente dito. Nesse exemplo,
podemos observar a existência de quatro campos dentro do tipo TFuncionario, são eles: os campos Nome,
Cargo e Setor do tipo string e o campo Idade que armazena um valor inteiro. Devemos observar também
que poderíamos ter criado campos de qualquer tipo de dados, até mesmo de tipos de dados Record desde
que eles tivessem sido previamente declarados.
A declaração de tipos de dados registro é útil devido a possibilidade de podermos agrupar valores dentro de
uma única declaração. Quando, por exemplo, declararmos uma variável desse tipo de dados estaremos
colocando todas as informações a respeito de um funcionário em um único lugar, permitindo o acesso
rápido a cada um desses campos por intermédio de uma única variável.

Exemplo
Func.Nome := ‘José da Silva’;
Func.Idade := 18
Func.Cargo := ‘Analista de Sistemas’;
X := Func.Idade;
Os exemplos acima ilustram a utilização de uma variável do tipo de dados TFuncionario declarado
anteriormente. Neles vemos como podemos atribuir e ler valores dos campos de um record. O acesso a
cada campo do record é feito através da utilização do operador ponto. Para tanto basta que o valor que
esteja sendo atribuído, bem como a variável na qual o valor esteja sendo colocada a partir de um campo do
record possuam o mesmo tipo de dados.

3.1.1.3.5.Classes
O último tipo de dados que iremos abordar refere-se ao conceito de classes. O Delphi, por ser uma
linguagem que suporta os conceitos da programação orientada a objetos permite a declaração tanto de
novas classes quanto de objetos. A declaração de objetos será vista na próxima seção. Feita essa
observação vamos começar nosso estudo em relação à declaração de classes dentro do Delphi. A
declaração de classes é bastante semelhante à declaração de um tipo de dados record vista anteriormente.

Sintaxe
NomeNovaClasse = class
Declarações da Classe
end;

Exemplo
TClasseFuncionario = class
Nome : string[50];
Salario : currency;
Procedure Aumento(pct : real);
end;
Apesar de estarmos apresentando neste momento a sintaxe para a declaração de uma classe, essa sintaxe
não está completa. Basicamente, o que ilustramos aqui é a sintaxe bastante semelhante à da declaração de
um record, onde a diferença encontrada até este momento entre as duas declarações, é a substituição da
palavra reservada record pela palavra reservada class. No exemplo dado, podemos perceber pelo menos
mais uma grande diferença entre as declarações de records e classes no que diz respeito à possibilidade de
declararmos métodos dentro da declaração de uma classe, fato esse que não pode ocorrer dentro da

Página: 44
Delphi 5

definição de um record. No entanto, deixaremos para depois a descrição mais detalhada da sintaxe da
declaração de uma classe.

3.1.1.4.Declarações de variáveis
Uma vez que já conhecemos alguns dos tipos básicos existentes dentro do Delphi e também sabemos como
criar novos tipos de dados a partir desses tipos básicos, vamos explorar a principal razão da existência de
tipos de dados dentro de uma linguagem de programação, a declaração de variáveis.

3.1.1.4.1.Declarando variáveis simples


De forma semelhante ao que aconteceu com a declaração de tipos, o Delphi também possui uma cláusula
responsável pela declaração de variáveis, a cláusula var. O exemplo ao lado mostra a utilização da cláusula
var. Como podemos observar, a declaração de variáveis é feita logo após a palavra reservada var, que
indica o início das declarações de variáveis. Podemos declarar uma ou várias variáveis. Os nomes das
variáveis devem ser seguidos por sinal de dois pontos e, em seguida, o nome referente ao tipo da variável
sendo declarada.
Podem ser declaradas variáveis de qualquer tipo de dados válido, seja ele um tipo de dados básico ou um
novo tipo de dados declarado na cláusula type da unit. No entanto, as declarações de variáveis pertencentes
a tipos de dados declarados na seção type só é válida desde que a declaração do novo tipo de dados tenha
sido feita antes da declaração da variável ou ainda em uma unit que esteja contida na cláusula uses da unit
na qual a variável está sendo declarada.

unit Unit2; unit Unit2;

interface interface

type var
TNome = string[50]; Nome : TNome;

var type
Nome : TNome; TNome = string[50];

implementation implementation

end. end.
Acima apresentamos dois exemplos de declaração de variáveis. O primeiro exemplo funciona
perfeitamente e pode ser compilado sem qualquer problema. Já o segundo exemplo, caso tentemos
compila-lo, irá resultar em erro de sintaxe. O erro ocorre uma vez que estamos tentando declarar a variável
Nome que supostamente é do tipo TNome. Para o Delphi, no momento da compilação da linha referente à
declaração da variável Nome, não existe definido nenhum tipo de dados chamado TNome. Dessa forma, as
declarações feitas no segundo exemplo apresentado acima não funcionam e resultam em erro de sintaxe.
Resta-nos fazer duas pequenas observações a respeito da declaração de variáveis dentro do Delphi. A
primeira refere-se à declaração de múltiplas variáveis. Quando desejamos declarar várias variáveis de um
mesmo tipo de dados podemos fazê-la separando cada variável por uma vírgula e, ao final das declarações
dos nomes das variáveis, colocamos o sinal de dois pontos e o tipo dessas variáveis. A Segunda observação
refere-se à possibilidade de declaração de várias cláusulas var dentro de uma mesma seção interface.
Apesar de podermos declarar várias dessas cláusulas, tal tipo de procedimento não é muito comum e deve
ser evitado por uma simples questão de estética e organização do código fonte.

3.1.1.4.2.Declarando variáveis arrays


A declaração de variáveis array, também conhecidas em outras linguagens de programação como vetores,
também pode ser feita dentro do Delphi. A declaração de arrays é útil quando desejamos declarar uma série
de variáveis de mesmo tipo de dados, cujo acesso a elas deve ser feito de forma conjunta. Não faz parte do
escopo deste material falar sobre a finalidade de uma declaração de arrays, mas sim definir a sintaxe
adotada pelo Delphi para a declaração desse tipo de variável. Para uma explicação mais detalhada em
relação à utilização de arrays, o leitor deve consultar material específico sobre estruturas de dados.

Página: 45
Delphi 5

Sintaxe
NomeVar : array [PosIni..PosFin] of Tipo;
NomeVar : array [PosIni1..PosFin1, ..., PosIniN..PosFinN] of Tipo;

Exemplo
Gabarito : array [1..20] of char;
Provas : array [1..16, 1..20] of char;
A sintaxe apresentada acima ilustra dois tipos possíveis de declarações de arrays. A primeira delas refere-
seà declarações de arrays unidimensionais enquanto que a segunda mostra como podemos declarar arrays
multidimensionais. No primeiro exemplo, a declaração da variável gabarito que pode conter vinte
caracteres cada um deles nas posições de 1 a 20 do array, respectivamente. Já no segundo exemplo, a
variável gabarito representa um array bidimensional, semelhante a uma tabela contendo 16 linha com 20
colunas em cada uma delas, onde em cada campo desta tabela podemos colocar um caractere.
Algumas observações fazem-se necessárias em relação à declaração de arrays bem como o acesso aos
valores neles contidos. A primeira observação diz respeito a sintaxe da declaração do array. Como
mostrado acima, na declaração do array é estabelecida tanto a posição inicial quanto a final dos elementos
do array. Através dessa definição fica também estabelecida a quantidade de elementos que poderão estar
contidos nesse array. Para esses valores podemos estabelecer qualquer numeração, porém as numerações
mais comuns para a posição inicial do array é a posição 0 ou a posição 1, como feito nos exemplos
anteriores. Apesar disso, fica a critério do desenvolvedor a definição de quais serão as faixas de valores a
serem utilizadas.
A segunda observação refere-se ao acesso aos valores contidos no array. Para acessarmos cada elemento
contido no array devemos fazer referência a posição em que esse elemento ocorre dentro do array. O
exemplo abaixo ilustra algumas das diversas formas que podemos utilizar para fazer referência a uma
posição específica do array.

Exemplo
Gabarito[12] := ‘d’;
Provas [5, 20] := ‘c’;
Provas [5] [20] := ‘c’;
Os exemplos acima ilustram como acessar um elemento de um array unidimensional bem como exibe duas
maneiras de acessarmos o mesmo elemento em um array bidimensional.

3.1.1.5.Declarações de constantes
Um outro tipo de declaração bastante comum em muitas unit Unit2;
linguagens de programação é a declaração de constantes.
Como não poderia deixar de ser, o Delphi também permite interface
a declaração de constantes que poderão ser utilizadas em
seu código fonte. Como vem acontecendo com outros const
tipos de declarações, a declaração de constante também DiasNaSemana = 7;
possui um local especial na qual elas ocorrem, a cláusula Companhia = 'Ibratec';
const. A figura ao lado exemplifica a declaração de SalarioMinimo = 151.00;
constantes dentro de uma unit do Delphi. A sintaxe da HorasNoDia = byte(24);
declaração de constantes é semelhante àquela vista para a DiasDoAno : integer = 365;
declaração de variáveis. Devemos colocar o nome da
constante a ser declarada seguida no sinal de igualdade e o implementation
valor a ser atribuído. Essa é a sintaxe a ser utilizada na
maioria das declarações de constantes. Porém, como end.
veremos a seguir, existem algumas exceções a essa
sintaxe.
No exemplo apresentado podemos observar dois pontos interessantes em relação à declaração de
constantes. O primeiro ponto refere-se a possibilidade de informarmos o tipo de dados ao qual a constante

Página: 46
Delphi 5

sendo declarada deverá possuir. Podemos informar o tipo de dados desejado apenas para constantes de
tipos de dados ordinais. Caso não informemos o tipo de dados para constantes ordinais ou de qualquer
outro tipo de dados, o Delphi possui uma série de regras que irão determinar o tipo de dados ao qual a
constante irá pertencer. Para uma melhor definição das regras a respeito da atribuição de tipos de dados a
constantes declaradas dentro do Delphi, o leitor deverá consultar a ajuda do próprio Delphi.
O segundo ponto que devemos observar é a declaração de constantes tipadas. Uma constante tipada
assemelha-se bastante à declaração de variáveis até mesmo em sua sintaxe. A constante DiasDoAno
representa esse tipo de declaração de constantes. Além da diferença de sintaxe entre a declaração de
constantes tipadas e aquelas que não são tipadas, existe uma importante diferença comportamental entre
elas. As constantes tipadas, ao contrário do que acontece com as constantes não tipadas, também chamadas
de constantes verdadeiras, podem ter seus valores modificados durante a execução da aplicação. Esse
comportamento faz com que as constantes tipadas assemelhem-se ainda mais a variáveis.

3.1.1.6.Declarando funções e procedimentos


O último ponto que iremos abordar com relação à seção interface é em relação à declaração de funções e
procedimentos. De uma forma geral as funções e procedimentos são chamados de métodos quando
declarados dentro de uma classe, porém existe uma diferença básica entre ambos. Enquanto que um
procedimento não retorna qualquer valor ao ponto ao qual ele foi executado, a função por sua vez retorna.
Antes de mostrarmos a sintaxe para a definição de procedimentos e funções devemos entender em que
ponto da seção interface eles devem ser declarados. Sintaticamente, podemos declarar tanto funções quanto
procedimentos na seção interface em qualquer ponto após a cláusula uses, no caso dela existir. Ou seja, a
declaração de uma função ou procedimento pode vir tanto na cláusula type, não devendo estar dentro de
uma declaração de um record ou de uma classe, quanto nas cláusulas var e const. Devemos, no entanto,
tentar preservar alguma organização durante o desenvolvimento do aplicativo. Para isso, devemos declarar
tanto as funções quanto os procedimentos existentes em um único ponto da seção interface de nossa unit
como, por exemplo, após a declaração de todas as variáveis da seção var.

Sintaxe
procedure NomeProcedure;
proceudre NomeProcedure (argumentos );
function NomeFunction : TipoRetorno;
function NomeFunction (argumentos ) : TipoRetorno;

Exemplo
procedure UmaProcedure;
procedure ExibeMsg (Msg : string; Qtd : byte);
function VarificaCamposObrigatorios : boolean;
function VerificaCPF (CPF, Dgt : string) : boolean;
Como podemos observar nas sintaxes apresentadas acima, ao declararmos uma função ou um procedimento
temos a possibilidade de passar ou não argumentos para eles. No caso de não passarmos qualquer
argumento, a utilização dos parênteses não deve ser feita, ao contrário do que ocorre em outras linguagens
de programação. Já quando desejamos passar argumentos para qualquer função ou procedimento, devemos
passar cada um dos argumentos e seus respectivos tipos de dados separados por um ponto e vírgula. Nesses
casos, os argumentos devem vir com seus tipos indicados como na declaração de variáveis de um unit, ou
seja, separados de seus tipos através de um sinal de dois pontos.. Opcionalmente, quando da declaração de
dois ou mais argumentos de mesmo tipo, esses argumentos podem vir separados por vírgula como também
acontecia nas declarações de variáveis. Quando tratamos com funções devemos também indicar o tipo de
dados a ser retornado quando da execução da função. Observe que indicamos um único tipo de dados a ser
retornado uma vez que uma função poderá retornar apenas um único valor.
Um outro aspecto importante que devemos observar está no fato de que apenas declaramos os
procedimentos e as funções, ou seja, seus cabeçalhos. Veremos posteriormente como e onde declarar o
corpo desses procedimentos e funções além de como poderemos indicar o valor a ser retornado por cada
uma das funções declaradas.

Página: 47
Delphi 5

3.1.1.6.1.Argumentos por valor e por referência


Existem duas maneiras de declararmos e passarmos valores tanto para procedimentos quanto para funções,
a passagem por valor e a passagem por referência. As duas diferem-se com relação a forma como as duas
tratam em sua implementação os argumentos passados. Vamos mostrar essa diferença através de um
exemplo. No exemplo a seguir iremos imaginar a existência de um procedimento, poderia ser uma função
sem qualquer perda de generalidade na explicação, que recebe um argumento do tipo integer.

Exemplo
Passagem por valor Passagem por referência
X := 3; X := 3;
ProcExemplo (X); ProcExemplo(X);
Qual o valor de X após a execução? Qual o valor de X após a execução?
Definição do corpo do procedimento
procedure ProcExemplo(Argumento : integer);
begin
Argumento := Argumento + 1;
end;
Antes de tudo devemos ressaltar que iremos tratar mais detalhadamente a escrita de procedimentos e
funções posteriormente. Por enquanto, vamos tratar da diferença entre a passagem de valores por referência
ou por valor. Quando passamos valores por valor para uma função ou procedimento, esses valores
permanecem inalterados ao término da execução do procedimento ou da função, independentemente das
atribuições dentro deles. Já quando passamos valores por referência, ao alterarmos o argumento dentro da
função ou procedimento, esse será o valor após término da execução da função ou procedimento. No
exemplo acima, o valor da variável X após a execução do procedimento ProcExemplo quando da passagem
por valor permanecerá 3, enquanto que na passagem por referência será alterado para 4.
Uma vez que sabemos qual o comportamento de uma função ou procedimento com relação a passagem de
parâmetros por valor ou por referência, resta-nos saber como podemos indicar ao Delphi que queremos que
um argumento seja passado por valor ou por referência.

Sintaxe
Passagem por valor
Procedure NomeProcedure (Argumento : TipoDeDados);
Passagem por referência
Procedure NomeProcedure (var Argumento : TipoDeDados);

As sintaxes apresentadas acima, apesar de tratar apenas das declarações de procedimentos podem ser
utilizadas nas declarações de funções. Observe que, para declararmos um argumento como sendo passado
por valor não devemos fazer uso de qualquer palavra reservada. Já em declarações de argumentos passados
por referência devemos utilizar a palavra reservada var. Devemos observar que é necessário declarar a
palavra reservada var antes de cada argumento que desejamos definir como sendo passado por referência.

Um detalhe importante se refere à definição de passagem de argumentos constantes. Esse tipo de


declaração é semelhante ao que vimos na passagem por referência, porém, ao invés de utilizarmos a
palavra reservada var devemos fazer uso da palavra reservada const como mostrado no exemplo a seguir.

Sintaxe
procedure NomeProcedure (const Argumento : TipoDeDado);

Página: 48
Delphi 5

Exemplo
procedure ProcExemplo (const Argumento : integer);
Quando declaramos um argumento como sendo um parâmetro constante, estamos indicando que o
argumento passado para a função ou procedimento não pode
ser alterado no corpo do procedimento. Caso tentássemos
alterar o valor do argumento dentro do corpo da função ou
procedimento, ao compilarmos a aplicação o Delphi iria
acusar um erro como mostra a figura ao lado. Esse
comportamento assemelha-se ao que seria esperado se
tivéssemos declarado uma variável local ao procedimento ou
função. A grande vantagem em relação à declaração de uma
constante local está no fato de, ao passarmos como
argumento para a função, estaremos criando uma
“constante” dinamicamente, uma vez que o valor da
constante é atribuído no momento da chamada da função ou procedimento.

3.1.2. A seção implementation


Vimos na seção anterior a seção interface. Nela pudemos declarar novos tipos, variáveis e constantes.
Essas declarações podiam ser disponibilizadas para outras units, pertencentes ou não ao projeto corrente,
como se fossem declarações globais. Agora vamos dar início
ao estudo da seção implementation. Essa seção assemelha-se
bastante à seção interface uma vez que nela podemos
também declarar novos tipos, variáveis e constantes da
mesma maneira como havíamos feito anteriormente através
da utilização das palavras reservadas type, var e const
conforme mostramos ao lado. A diferença básica existente
entre as declarações feitas na seção implementation daquelas
que fazemos na seção interface está na visibilidade dessas
declarações.
Como mencionamos em nossa explicação a respeito da seção
interface, as declarações nela efetuadas possuem caráter global, ou seja, podem ser vistas e utilizadas em
qualquer outra unit desde que essa unit esteja incluída em sua cláusula uses. Por outro lado, as declarações
feitas na seção implementation possuem caráter local, ou seja, podem apenas ser utilizadas dentro da
própria unit onde estão declaradas.
Além do aspecto visibilidade, vimos que uma outra função da seção interface é a possibilidade de
podermos declarar funções e procedimentos. Porém, além de termos a possibilidade de declararmos esses
procedimentos na seção interface, o que os tornam procedimento e funções disponíveis as demais units,
devemos ainda escrever a codificação para os mesmos, ou seja, devemos escrever o corpo de cada um
desses procedimentos. A codificação do corpo desses procedimentos e funções é feita na seção
implementation da unit. É importante salientar que não necessitamos declarar o cabeçalho dos
procedimentos na seção interface, no caso em que desejamos escrever funções ou procedimentos locais a
unit corrente, basta escrevermos o corpo dessas diretamente na seção implementation.
Independentemente de qual seja a visibilidade que desejamos dar as funções e procedimentos que iremos
escrever, a forma com que iremos escrever esses procedimentos é exatamente a mesma. A seguir
mostramos a sintaxe que deverá ser utilizada na escrita do corpo de cada um dos procedimentos ou funções
a serem declaradas nas units do projeto. É importante observar que a sintaxe que iremos apresentar é um
pouco diferente quando estivermos tratando da implementação de procedimentos e funções pertencentes a
uma classe.

Sintaxe
procedure NomeProc (Argumentos : TipoDeDados);
Begin
Código do procedimento

Página: 49
Delphi 5

end;

Exemplo
procedure ExibeMsg(Msg : string);
begin
ShowMessage(Msg);
end;
Observe que ao escrevermos o corpo de cada procedimento ou função devemos repetir todo o cabeçalho
antes de colocarmos as palavras reservadas begin e end. Entre essas duas palavras reservadas é que iremos
escrever efetivamente o código a ser executado.
Uma vez que já sabemos tanto como declarar funções quanto como escrever o corpo de cada uma delas,
devemos nos lembrar que as funções diferenciam-se dos procedimentos pelo fato de retornarem um valor
para o ponto de onde elas foram chamadas. Por isso resta-nos mostrar, dentro do corpo da função, como
podemos indicar qual valor deve ser retornado, ao local da chamada da função.

Sintaxe
Result := ValorRetorno;
NomeFuncao := ValorRetorno;

Exemplo
Result := True;
VerificaCPF := True;
if x < 3 then
Result := true
Else
Result := False;
Observe que existem duas maneiras de retornarmos um resultado para a função. A primeira delas é através
da utilização da palavra reservada result. Result nada mais é do que um argumento implícito contido no
cabeçalho de cada uma das funções que declaramos. Ao atribuirmos valores à palavra reservada result
estamos informando ao Delphi quais valores desejamos retornar ao ponto em que a função foi chamada. A
segunda maneira através da qual podemos retornar resultados de funções é através da atribuição do valor
desejado ao próprio nome da função. No exemplo acima, o valor true é atribuído ao próprio nome da
função VerificaCPF.

3.1.3. A seção initialization


A seção initialization é uma seção opcional dentro da declaração de uma unit, iniciando-se pela palavra
reservada initialization e prosseguindo até o início da seção finalization ou o término da unit. Essa seção é
utilizada para colocar códigos que devem ser executados durante a inicialização do aplicativo. Nela
colocamos declarações como, por exemplo, a inicialização de variáveis.

A figura ao lado mostra a utilização da seção initialization


dentro de uma unit. Observe que nessa seção podemos
colocar desde simples atribuições de valores a variáveis que
foram declaradas em outras seções da unit ou de outras units,
bem como outras codificações mais complexas. Ao
observarmos o código existente na seção initialization,
podemos observar que as declarações feitas nessa seção
assemelham-se a declarações que poderiam ter sido feitas em
qualquer função ou procedimento existente em uma unit. A
principal diferença é que o código que escrevemos na seção

Página: 50
Delphi 5

initialization será executado automaticamente no início da execução do programa, enquanto que, para
executarmos outros procedimentos deveríamos chamar esses procedimentos para que o código associados a
eles sejam executados.

3.1.4. A seção finalization


A seção finalization é a última seção que pode ser declarada dentro de uma unit, podendo existir apenas se
a seção initialization tiver sido previamente declarada. Nessa seção são declarados códigos a serem
executados ao término da execução do programa. Uma vez que a seção initialization de uma unit seja
executada, o Delphi garante a execução da seção finalization correspondente. Dessa forma, podemos
perceber dois pontos em relação às declarações feitas na seção finalization de uma unit. A primeira delas é
que essas declarações são, em geral, responsáveis pela liberação de recursos que tenham sido alocados na
seção initialization. O segundo ponto é que, uma vez que as declarações contidas na seção initialization
podem não ter sido concluídas corretamente, ou seja, pode ter havido algum erro durante a sua execução, o
código que escrevemos na seção finalization deve ser robusto o suficiente para lidar com essas situações.

4.Os Formulários
Uma vez que já possuímos conhecimento suficiente a respeito do ambiente Delphi, podemos iniciar nosso
aprendizado naqueles itens que mais serão utilizados no desenvolvimento de nossos aplicativos. Como não
poderia deixar de ser, vamos iniciar esse processo através do estudo dos formulários que, dentro das
aplicações desenvolvidas para o ambiente Windows®, irão estar presentes em sua grande maioria.

4.1. Criando formulários


Já sabemos que por estar contido na maioria das aplicações desenvolvidas para o ambiente Windows, ao
iniciarmos o Delphi ou um novo projeto, um novo formulário será criado e definido como o novo
formulário principal para a nossa aplicação. Esse formulário principal não será, muito provavelmente, o
único formulário que estará contido nessa aplicação. Além disso, poderão existir situações em que o
desenvolvedor deseja definir um novo padrão para o formulário principal de novas aplicações,
diferentemente daquele formulário, sem qualquer componente, conforme definido pela instalação padrão
do Delphi. Até mesmo para os novos formulários que iremos criar, podemos desejar que esse padrão seja
alterado. Antes de mostrarmos como alterar o comportamento padrão, nós vamos mostrar as três principais
formas através das quais podemos criar novos formulários dentro do ambiente do Delphi.

4.1.1. Novos formulários


As duas primeiras maneiras que o desenvolvedor possui de criar um novo formulário são idênticas. A
primeida delas acionada pelo item de menu New Form contido no menu File, e a segunda através no speed
button New Form localizado na Barra de Ferramentas da janela principal do Delphi. Em amabas as
situações, um novo formulário é criado se utilizando sempre da definição de qual formulário foi
estabelecido como o default para a configuração do Delphi em vigor.
A segunda maneira que o desenvolvedor Delphi possui de criar um formulário é através da seleção do item
de menu New localizado no menu File. Ao selecionarmos esse item de menu, o Delphi irá exibir a caixa de
diálogo New Items. Essa caixa de diálogo é exibida contendo o Object Repository, ou seja, um Repositório
de Objetos a partir do qual o desenvolvedor poderá escolher objetos previamente criados e utilizá-los em
suas aplicações.
O Object Repository está dividido em guias de acordo com a
funcionalidade de cada objeto nelas contido. Por exemplo, na guia
Forms estão contidos modelos de formulários enquanto que na guia
Dialogs estão contidos modelos de caixas de diálogo. Existem
também algumas guias especiais como é o caso da guia New que
contém objetos mais comuns que podem ser utilizados em vários
tipos de aplicações. Já a guia Project1 é uma guia especial, cujo
nome depende do nome da aplicação corrente, ou seja, ao
salvarmos o projeto com um outro nome, o título dessa guia será
modificado, passando a exibir o nome do projeto corrente. Nessa
guia, ao contrário do que ocorre nas demais, estão contidos os

Página: 51
Delphi 5

formulários que foram desenvolvidos nessa aplicação de tal forma a permitir sua reutilização em outros
formulários desse mesmo projeto e não formulários pré-definidos instalados junto com o Delphi. Para
criarmos um novo formulário a partir do Object Repository podemos selecionar tanto o formulário padrão
contido na guia New como qualquer outro formulário contido nas demais guias do Object Repository.
A figura acima ilustra a guia New contida no Object Repository. Nessa guia podemos observar a existência
de um ícone, responsável pela criação de um novo formulário, chamado Form. Ao selecionarmos esse
ícone e clicarmos no botão Ok o Delphi irá criar um novo formulário default. Para alterarmos o formulário
default que é criado pelo Delphi deveremos modificar a configuração do Object Repository.

4.1.2. Configurando o Object Repository


O desenvolvedor Delphi possui a possibilidade de configurar o Object Repository de tal forma a poder
adaptar o ambiente de programação às suas necessidades, melhorando dessa forma o tempo de
desenvolvimento de novas aplicações. Para configurarmos o Object
Repository devemos exibir a caixa de diálogo Object Repository,
mostrada ao lado, através do item de menu Repository localizado no
menu Tools. Como podemos observar na figura, a caixa de diálogo
Object Repository é composta por dois List Views. O primeiro contém
algumas das guias contidas no Object Repository quando da sua
exibição através do menu New, mencionado anteriormente, exceto
pelo item [Object Repository] que contém todos os objetos do
repositório. O segundo lista os objetos contidos na guia, ou página,
selecionada no primeiro ListView. Devemos observar que os botões
contidos nessa caixa de diálogo tornam-se habilitados na medida em
que vamos selecionando cada elemento de seus listviews.
Nessa caixa de diálogo podemos configurar o Object Repository para exibir suas guias na ordem que
melhor se adapte ao desenvolvedor, para isso basta que elas sejam colocadas no Listview Pages na ordem
em que desejamos. A reorganização dos itens dentro do Listview pode ser feita tanto através dos dois
botões localizados na parte inferior esquerda da caixa de diálogo quanto através de uma simples operação
de drag and drop. Com relação às páginas contidas no Object Repository, o desenvolvedor poderá criar
tanto novas páginas como também poderá renomear as páginas já existentes. Além disso, o desenvolvedor
tem a possibilidade de remover páginas indesejáveis. Devemos ter cuidado ao clicar no botão Delete Page
uma vez que não é exibida nenhuma caixa de diálogo solicitando a confirmação de que desejamos remover
a página selecionada.
Em relação aos objetos colocados em cada guia, através da caixa de diálogo Object Repository, temos a
possibilidade tanto de editá-los quanto de remover cada um dos objetos contidos no Object Repository. O
botão Edit Object exibe a caixa de diálogo Edit Object Info, mostrada abaixo, permitindo que alteremos
informações a respeito do objeto corrente tais como o seu nome e o ícone que irá representá-lo no Object
Repository. A alteração dessas informações normalmente não é necessária uma vez que elas são
preenchidas quando do momento da inserção de um novo objeto no Object Repository. Não iremos nos
preocupar nesse momento com a criação de novos objetos dentro
do Object Repository, devemos apenas ter conhecimento de que
podemos criar novos objetos para que esses possam ser
utilizados, posteriormente, em novas aplicações.
Vimos até aqui que podemos manipular com os objetos que
existem no repositório, mas não mencionamos como podemos
alterar o comportamento default com relação à criação de novos
formulários. Para isso temos uma opção em relação tanto à
definição do formulário principal de novos aplicativos quanto
para novos formulários de nossa aplicação, ou seja, o formulário
que é criado ao selecionarmos a opção New Form localizada no menu File. Podemos observar que, ao
selecionarmos um objeto que represente um formulário, tornam-se habilitados dois CheckBoxes na parte
inferior direita da caixa de diálogo Object Repository. Caso desejemos alterar o formulário default criado
basta que selecionemos um novo formulário qualquer e marquemos o CheckBox New Form. Feito isso,
todas as vezes que escolhermos uma opção de criação de um novo formulário, será criado um formulário
idêntico àquele que escolhemos. Caso desejemos posteriormente retornar ao comportamento default do
Delphi basta desmarcarmos a opção que acabamos de marcar.

Página: 52
Delphi 5

Além de podermos escolher o formulário que será criado quando da escolha de uma opção de criação de
novo formulário, temos ainda a opção de determinar qual o formulário a ser criado como sendo o
formulário principal da aplicação. Para isso basta seguirmos o mesmo procedimento descrito anteriormente,
porém ao invés de selecionarmos o checkbox relativo à opção New Form devemos selecionar o checkbox
relativo à opção Main Form.
Além de podermos definir qual o comportamento para os formulários de nossa aplicação, temos ainda a
opção de alterar o comportamento default associado à criação de novas aplicações. Ao selecionarmos um
objeto que represente novas aplicações, como por exemplo, aqueles exibidos no item Projects contido no
listview Pages ao invés de objetos associados a formulários, é exibido no canto inferior direito o checkbox
New Project. Ao marcarmos esse checkbox estaremos determinando qual objeto será utilizado no momento
da criação de um novo projeto.

4.2. Exibindo Formulários


Uma vez que tenhamos criado novos formulários dentro de nossa aplicação devemos definir quando eles
serão exibidos para que possamos escrever o código necessário à exibição dos mesmos. A definição do
momento em que cada formulário irá ser exibido depende, única e exclusivamente, das definições do
desenvolvedor. Em relação ao código necessário a exibição do formulário, o Delphi permite duas maneiras
de exibirmos esses formulários.

4.2.1. Manipulando com propriedades e métodos


Antes de começarmos a tratar com os formulários ou com qualquer outro componente que esteja a nossa
disposição no Delphi devemos nos familiarizar com a forma através da qual poderemos manipular com
suas propriedades e métodos dentro do Editor de Código. Vimos até aqui como é fácil manipularmos com
as propriedades de um componente dentro do Objetct Inspector. Veremos agora que também é bastante
simples manipularmos não somente com as propriedades, mas também com os métodos dentro do Editor de
Código do Delphi.
Todas as vezes que desejamos executar um método ou manipular com o valor de uma propriedade de
qualquer componente a mesma regra é aplicada, devemos utilizar o operador ponto para efetuarmos essas
operações. O quadro abaixo ilustra a maneira através da qual poderemos manipular com esse operador
junto aos componentes do Delphi.

Sintaxe
Objeto.Propriedade := valor;
Objeto.Método;

Exemplo
Button1.Caption := ‘Ok’;
Form1.Font.Size := 12;
Form1.BorderIcons.biSystemMenu := true; //Errado
Table1.Open;
Vamos observar a sintaxe apresentada no quadro acima. Observe que cada vez que desejamos manipular
com uma propriedade ou método fazemos referência inicialmente ao objeto e depois ao método ou à
propriedade que desejamos manipular. A referência ao objeto é feita através de seu nome. Uma vez que a
propriedade que esteja sendo manipulada possua subpropriedades, elas também poderão ser manipuladas
através do operador ponto como ilustrado no exemplo acima. Contudo, devemos ter cuidado para não
tentarmos manipular com propriedades do tipo set como se elas fossem objetos, como é o caso da
propriedade BorderIcons pertencente aos formulários.

Página: 53
Delphi 5

4.2.2. Nomeando objetos


O Delphi como o próprio desenvolvedor necessita de uma forma através da qual poderá manipular com as
propriedades e métodos dos componentes dentro de uma aplicação. A maneira pela qual essa referência é
feita é através do nome desses componentes. Cada componente dentro da aplicação, incluindo o próprio
formulário, deverá possuir um nome. A propriedade name é a única existente em todos os componentes
dentro do Delphi. Existem duas regras que devem ser seguidas durante a atribuição de nomes a cada objeto
existente na aplicação.
A primeira regra refere-se à composição do nome do objeto. O nome de cada objeto não deverá ser
composto por caracteres acentuados. Além de não podermos utilizar caracteres acentuados, a utilização de
espaços não é permitida. Caso tentemos definir o nome de um componente utilizando qualquer um desses
caracteres não permitidos, o Delphi nos informará do erro conforme ilustrado ao lado. Observe que no
exemplo existem dois erros. O primeiro devido a tentativa de utilizar um caractere acentuado e o segundo
devido à utilização do espaço em branco separando o nome do
componente. Ao invés disso, deveríamos utilizar caracteres sem
acentuação e, em substituição ao espaço em branco, poderíamos ter
utilizado o caractere underscore, o que resultaria no nome
Formulario_Principal.
Um comentário deve ser feito em relação à atribuição de nomes aos componentes dentro de uma aplicação
Delphi. Uma vez atribuído um valor à propriedade name de um componente que exiba ou contenha texto
como é o caso de uma caixa de texto, um botão, ou o próprio formulário, a propriedade desse componente
que contem o texto a ser exibido é alterada automaticamente para conter o nome que foi atribuído ao
componente. No exemplo acima, caso atribuíssemos Formulário_Principal à propriedade name do
formulário, tanto essa propriedade quanto a propriedade caption seriam alteradas. Um detalhe com relação
a esse comentário está no fato de que essa atribuição só é feita no caso da propriedade caption nunca ter
sido alterada. Uma vez que tenhamos alterado a propriedade caption e posteriormente venhamos a alterar a
propriedade name, essa alteração em nada modificará o valor previamente atribuído à propriedade caption.
Um outro comentário que deve ser feito está relacionado com a escrita de código dentro da aplicação.
Lembre-se que, para manipularmos propriedades e métodos dentro do Editor de Código fazemos sempre
referência ao nome do componente. Uma vez que já tenhamos escrito código, manipulando com um
determinado componente, e desejemos alterar seu nome, o Delphi não irá varrer todo o código da aplicação
para realizar essa alteração para nós. Cada ponto em que o nome desse componente ocorre deve ser
alterado de tal forma a que, na próxima compilação do aplicativo, nenhum erro ocorra.
A segunda regra que deve ser observada na atribuição de nomes a componentes de nossa aplicação se
refere à unicidade desses nomes. O valor da propriedade name para cada componente deverá identificá-lo
unicamente dentro da aplicação. A princípio poderíamos imaginar que, devido a essa regra, nenhum
componente poderia ter o nome idêntico a um outro componente existente na aplicação, porém isso não é
de todo verdade. Quando estamos tratando com formulários sim, não poderão existir dois formulários com
os mesmos nomes, ou seja, os mesmos valores atribuídos às suas propriedades name. Já com os demais
componentes essa regra só é aplicada para os componentes colocados no mesmo formulário. Componentes
localizados em formulários distintos podem possuir nomes idênticos uma vez que o Delphi os identificará
unicamente através da composição do nome do formulário juntamente com o nome do componente como
mostrado no quadro abaixo.

Exemplo
Formulario_Principal.ButtonOK.Caption = ‘OK’;
FormCadCliente.ButtonOK.Caption := ‘Confirma’;

Observe no quadro acima os códigos que poderiam ter sido escritos em um procedimento de evento
qualquer. Neles vemos a atribuição de valores à propriedade caption de dois componentes distintos que
possuem o mesmo nome. Isso é possível uma vez que esses componentes estão localizados em formulários
distintos. O exemplo dado acima também é proveitoso para mostrar como podemos alterar valores de
propriedades de componentes localizados em outros formulários que não aquele no qual o componente foi
colocado. Quando estamos escrevendo código queira alterar propriedades ouexecutar métodos de
componentes contidos no próprio formulário no qual o procedimento de evento foi criado, é opcional a

Página: 54
Delphi 5

colocação do nome do formulário antecedendo o nome do componente que se deseja manipular. Já quando
desejamos manipular com componentes contidos em outros formulários, essa referência é obrigatória.

Exemplo
ButtonOK.Caption := ‘OK’; //Escrito no próprio formulário
Formulario_Principal.ButtonOK.Caption = ‘OK’; //Escrito em outro.
ButtonOK.Caption := ‘Confirma’; //Escrito no próprio formulário
FormCadCliente.ButtonOK.Caption := ‘Confirma’; //Escrito em outro.
Caption := ‘Título’;

O último exemplo mostra uma atribuição a uma propriedade sem referenciar o nome de qualquer
componente. Esse código irá compilar e executar normalmente caso ele tenha sido escrito dentro de um
procedimento de evento associado a qualquer formulário ou componente a ele pertencente. Nesse caso,
como não foi colocado a que componente ele está associado, o Delphi interpreta que o desenvolvedor está
fazendo referência ao próprio formulário para o qual o código foi escrito. Ou seja, através desse código
estaríamos alterando o caption do formulário. O motivo pelo qual o Delphi interpreta a codificação dessa
maneira é melhor compreendida quando trabalharmos com os conceitos de Orientação a Objetos, por ora
devemos apenas nos lembrar das regras de atribuição de nomes aos componentes e de como podemos
utilizar esses nomes para escrever a codificação de nossos aplicativos.

4.2.3. Formulários modais


Apesar da nomenclatura não ser muito comum, a ocorrência e
exibição de formulários modais é bastante comum em
aplicações desenvolvidas para o ambiente Windows. Um
exemplo que ocorre com muita frequência é durante a
exibição de caixas de diálogo nesses aplicativos. Por exemplo,
ao selecionarmos a opção Open localizada no menu File do
próprio Delphi, é exibida a caixa de diálogo responsável pela
abertura de arquivos a serem exibidos no Editor de Código.
Enquanto essa caixa de diálogo permanecer aberta, ou seja,
sendo exibida, o desenvolvedor não pode voltar ao
desenvolvimento da aplicação utilizando as demais janelas da
IDE do Delphi. Isso ocorre porque a caixa de diálogo Open foi exibida de maneira modal. As janelas
exibidas de maneira modal têm como uma de suas características o fato de deterem o controle da execução
da aplicação até que elas sejam fechadas. Apesar de serem muito comuns durante a execução de caixas de
diálogo elas podem ocorrer em qualquer outra situação
dependendo, é claro, da funcionalidade de cada janela dentro
da aplicação. A exibição de uma janela de forma modal é
bastante simples, bastando para isso, a execução de um
método pertencente ao formulário, o método ShowModal.
Vamos construir um pequeno exemplo para ilustramos a
utilização do método ShowModal. Iniciemos, portanto, uma
nova aplicação e coloquemos um botão nesse formulário
conforme ilustrado na figura ao lado. Além do formulário
principal para o nosso exemplo iremos precisar de um
segundo formulário, formulário esse que será exibido de forma modal ao clicarmos no botão do Form1.
Esse segundo formulário não precisa conter nenhum componente conforme ilustra a figura ao lado e pode
ser criado através da opção New Form contida no menu File. Resta-nos agora criar o procedimento de
evento associado ao evento OnClick do botão chamado Button1 e escrever o código necessário à exibição
do formulário chamado Form2. O processo de criação do procedimento de evento pode ser feito utilizando-

Página: 55
Delphi 5

se qualquer um dos métodos descritos anteriormente e por isso não será, de agora em diante, explicitado.
Em relação aos nomes dos componentes, por questões de praticidade, serão mantidos, porém, caso seja de
desejo do desenvolvedor alterá-los essas alterações deverão ser feitas agora antes do início da codificação
como foi discutido anteriormente. A codificação final para o procedimento de evento será a mostrada a
seguir.

procedure TForm1.Button1Click(Sender: TObject);


begin
Form2.ShowModal;
end;

Antes de compilarmos e executarmos a aplicação vamos observar o código acima. Nele podemos observar
um ponto importante relativo à chamada do método ShowModal. Uma vez que esse código foi escrito a
partir de um procedimento de evento pertencente ao formulário
Form1, ao fazermos referência a um método de um outro formulário,
o Form2, essa referência teve de ser feita utilizando-se a referência
completa ao método, incluindo o nome do formulário que teria seu
método executado, ou seja, o Form2. Caso não tivéssemos colocado a
referência ao Form2, a aplicação poderia ser compilada sem
problema algum, porém, ao invés de exibir o segundo formulário ao
clicarmos no botão Button1, o aplicativo iria exibir o próprio Form1,
o que, em nosso caso particular iria provocar um erro que explicaremos posteriormente. Por ora vamos
apenas compilar a nossa aplicação.
Ao tentarmos compilar a nossa aplicação uma
mensagem de erro será exibida como mostrado ao
lado. Esse erro ocorreu por uma razão bem simples
que, por incrível que possa parecer, já foi explicada
anteriormente. Apesar de toda a codificação estar
correta esquecemos de um pequeno detalhe. No
procedimento de evento que acabamos de escrever tentamos executar um método de um objeto que não
está localizado na unit corrente. Vimos que, todas as vezes que desejarmos utilizar qualquer definição
localizada em uma outra unit que não na que estamos codificando, uma referência à unit na qual essas
definições estão localizadas deverá ser feita na cláusula uses da unit sendo codificada. Foi exatamente isso
que aconteceu. Estamos nos referenciando a um objeto, o Form2, definido na unit2 a partir da unit1 sem ter
feito referência a essa unit. Devemos então adicionar à unit2 à cláusula uses da unit1. Quando nos
referenciamos à formulários o Delphi exibe a caixa de diálogo mostrada ao lado permitindo que ele próprio
efetue essas alterações para nós. Não devemos, no entanto, nos habituar com isso, pois o Delphi só irá nos
ajudar nessas situações, nas demais deveremos nos preocupar em incluir as units na cláusula uses. Após
clicarmos no botão Yes para adicionarmos a unit2 à cláusula uses da unit1 podemos compilar e executar a
aplicação e verificar o comportamento dos formulários ao clicarmos no botão. Agora que já sabemos como
podemos exibir formulários de forma modal vamos estudar como o Delphi é capaz de exibir formulário de
forma não modal.

4.2.4. Formulários não modais


De forma idêntica à exibição modal, o Delphi exibe formulários de forma não modal através da execução
de um método pertencente ao formulário. Esse método chama-se Show e executado de forma idêntica ao
método ShowModal visto anteriormente. Para ilustrarmos o funcionamento desse método podemos
substituir o exemplo para que o formulário Form2 passasse a ser exibido de forma não modal. Basta
alterarmos o código escrito no procedimento de evento associado ao evento OnClick do botão para que isso
ocorra conforme mostrado abaixo.

Página: 56
Delphi 5

procedure TForm1.Button1Click(Sender: TObject);


begin
Form2.Show;
end;
Uma vez que compilemos a aplicação nenhum erro irá ocorrer uma vez que já havíamos acrescentado a
unit2 à cláusula uses da unit1. Caso isso ainda não tivesse sido feito, deveríamos fazê-lo para que a
aplicação pudesse ser compilada e executada sem erros.
A exibição de formulários de forma modal ou não modal pode ser feita de acordo com a vontade e
necessidade do desenvolvedor, no entanto, deve-se tomar cuidado para que erros não ocorram. Por
exemplo, caso tivéssemos escrito o código a seguir.

procedure TForm1.Button1Click(Sender: TObject);


begin
Form2.Show;
Form2.ShowModal;
end;

Ao executarmos a aplicação e clicarmos no botão, um erro


irá ocorrer conforme ilustrado ao lado ou, dependendo da
configuração do Delphi, o erro mostrado abaixo seria
exibido diretamente. Esse erro deve-se ao fato de
exibirmos o formulário de forma não modal e, logo em
seguida, tentarmos exibí-lo de forma modal. Isso não é possível a menos que fechemos o formulário antes
de tentarmos exibi-lo de outra maneira. Apesar do código assima parecer pouco comum, e de fato é, esse
erro pode ocorrer quando exibimos o formulário a partir de procedimentos de eventos distintos. Devemos
sempre determinar como cada formulário de nossa aplicação será exibido e manter essa definição durante
todo o processo de desenvolvimento de forma a evitar que erros desse tipo venham a ocorrer.

4.2.5. Formulários Modais versus não modais


Vimos até aqui em nosso estudo a respeito dos ormulários que eles podem ser exibidos de forma modal ou
não modal. Existe uma diferença básica entre esses dois tipos de exibição permitindo ou não que a
aplicação contine ou não podendo ser utilizada antes ou não do formulário que foi exibido seja fechado.
Porém essa não é a única diferença existente entre
formulários modais e não modais. Uma outra diferença
que existe é que o método show foi definido dentro do
Delphi como um procedimento enquanto que o método
showmodal trata-se de uma função. Veremos
posteriormente as diferenças existentes entre funções e
métodos posteriormente, no momento basta sabermos que
uma função retorna um valor enquanto que um
procedimento não. Dessa forma, sabemos que um formulário exibido de forma modal é capaz de retornar
um valor enquanto que um formulário exibido de forma não modal não é capaz de retornar um valor para o
ponto de onde esse método foi executado. Observe que um método é uma denominação genérica tanto para
procedimentos quanto para funções.
Um último aspecto que iremos observar está na forma como o código de chamada desses dois métodos é
executado. Observe os dois códigos apresentados abaixo.

procedure TForm1.Button1Click(Sender: TObject);


begin
Form2.Show;
ShowMessage(‘Olá’);
end;
procedure TForm1.Button2Click(Sender: TObject);
begin
Form2.ShowModal;
ShowMessage(‘Olá’);
end;
Página: 57
Delphi 5

Poderíamos esperar que ambos os códigos funcionassem da mesma maneira, porém isso não acontece. O
código escrito para o evento OnClick do botão Button1 exibe o segundo formulário e logo em seguida
exibe uma caixa de mensagem co o texto Olá. Já o segundo procedimento, também exibe o segundo
formulário mas só irá exibir a caixa de mensagem quando o Form2 for fechado. Podemos concluir que o
método show não prende a execução do programa uma vez que a caixa de texto exibida através do
procedimento ShowMessage foi executado antes mesmo do segundo formulário ter sido fechado. No
entando, quando exibimos o segundo formulário utilizando o método ShowModal, a execução do código
relativo ao procedimento ShowMessage só é executado ao fecharmos a caixa de mensagem.

5.Comandos da linguagem
Começamos nossa caminhada no aprendizado do mundo Delphi através do estudo dos formulários. Já
temos conhecimento de uma propriedade do formulário, a propriedade name, e de dois métodos, show e
showmodal, responsáveis pela exibição dos formulários. No entanto, para continuarmos o nosso estudo e
sermos apresentados a outras propriedades e métodos devemos aprender os principais comandos da
linguagem Object Pascal. Essa apresentação faz-se necessária principalmente para podermos ilustrar com
exemplos mais úteis cada uma dessas propriedades e métodos.

5.1. Instruções Simples e Compostas


Já utilizamos, apesar de não ter sido explicitamente fornecida a definição, várias instruções, ou comandos,
dentro do código de um procedimento de evento. Existem dois tipos de instruções que podem ser escritas
dentro de uma codificação Delphi, são elas instruções simples e instruções compostas.
As instruções simples são aquelas que possuem em sua codificação apenas um único comando. Lembremos
que todo comando escrito em Object Pascal é finalizado por um “;” (ponto-e-vírgula). Os exemplos abaixo
ilustram instruções simples.

procedure TForm1.Button1Click(Sender: TObject);


begin
x := x + 1;
Form2.ShowModal;
ShowMessage(‘Olá’);
end;

Observe que, no exemplo dado, existem três comandos simples, todos eles dentro do mesmo procedimento.
Devemos sempre nos lembrar que as instruções dentro do código Object Pascal, independentemente de
serem simples ou compostas, devem ser escritas dentro de procedimentos ou funções, portanto não
podendo ocorrer espalhadas no meio da unit.
O segundo tipo de instrução, as intruções compostas, possuem em geral mais de uma instrução simples
associada a ela. Apesar de não ser muito comum, instruções compostas podem conter uma única instrução
simples em seu corpo. As instruções compostas são delimitadas por um bloco composto pelas palavras
reservadas begin e end e finalizadas por um “;” (ponto-e-vírgula) de forma semelhante à delimitação de
um procedimento de evento visto no exemplo acima. No entanto, uma instrução composta vem no corpo
desses procedimentos como se fosse uma instrução simples conforme o exemplo a seguir.

procedure TForm1.Button1Click(Sender: TObject);


begin
x := x + 1;
begin
Form2.ShowModal;
ShowMessage(‘Olá’);
end;
end;

Página: 58
Delphi 5

Como podemos observar, uma instrução composta possui em seu corpo uma ou várias instruções simples e,
pode até mesmo, possuir outras instruções compostas. Apesar de não ser tão perceptível nesse momento a
finalidade de estarmos utilizando instruções compostas elas são muito úteis no desenvolvimento de
aplicações uma vez que as intruções, simples ou não, contidas em uma instrução composta, são
consideradas pelo compilador como uma única instrução simples. As instruções compostas são largamente
utilizadas não isoladamente como no exemplo anterior mas como parte de intruções mais complexas,
compondo as instruções condicionais e de laços, ou de repetição, que serão vistas a seguir.

5.2. Instruções Condicionais


As instruções condicionais são aquelas que determinam o fluxo de execução do programa através da
verificação de uma condição booleana. No Delphi existem dois tipos de instruções booleanas, a instrução if
e a instrução case.

5.2.1. If
A instrução if é uma das instruções mais comuns nas linguagens de programação existindo até na
linguagem assembler e, como não poderia deixar de ser, também existe no Object Pascal. No quadro
abaixo ilustramos as duas formas básicas que o comando if pode aparecer um um programa escrito em
Object Pascal acompanhado de alguns exemplos.

Sintaxe
If <condição> then <instrução> ;

if <condição> then <instrução> else <instrução>;

Exemplos
if x >= y then ShowMessage(‘Limite ultrapassado’) ;

if odd(x) then ShowMessage(‘O número é ímpar’)

else ShowMessage(‘O número é par’);

if (x > 0) and (x < 10) then x := x + 1;

If (x > 3) and (y <= 5 ) then


Begin
x := x – 1;
y := y + 1;
End
Else
x := x + 1;

If x >= y then
If x = y then
ShowMessage(‘X é igual a Y’)
Else
ShowMessage(‘X é maior do que Y’)
Else
ShowMessage(‘X é menor do que Y’);

Como podemos observar no quadro acima, a instrução if possui, basicamente, duas formas. A primeira
delas é constituída apenas da instrução if seguida da instrução a ser realizada no caso da condição booleana
a ser testada resulte em um valor verdadeiro enquanto que a segunda permite que tanto uma intrução seja
realizada no caso do resultado da condição ser verdadeira quanto no caso dela ser falsa. Um detalhe
extremamente importante relacionado com a instrução if e que resulta em muitos erros principalmente para

Página: 59
Delphi 5

pessoas inexperientes com o Delphi é que a instrução que precede o else não deve ser terminada com um
ponto-e-vírgula ao contrário do que acontece com as demais instruções da linguagem.
Um segundo ponto a ser observado no exemplo acima é a possibilidade de termos comandos if aninhados,
ou seja, uns dentro dos outros conforme mostrado no último exemplo dado acima. Um outro ponto que
pode ser observado através dos exemplos é que a instrução a ser executada tanto pelo comando if no caso
da condição ser verdadeira quanto pelo else no caso dela ser falsa, pode ser tanto uma instrução simples
quanto ums instrução composta. Observe o exemplo a seguir.

Exemplos
if (x >= y) and (y < 10) then
x := x - 1;
y := y + 1;

if (x >= y) and (y < 10) then


begin
x := x - 1;
y := y + 1;
end;

Os exemplos apesar de semelhantes têm execuções diferentes. No primeiro exemplo, a primeira instrução
só será é executada no caso do resultado da expressão booleana for verdadeira enquanto que a segunda
instrução será executada independentemente do resultado da expressão booleana. Já no segundo exemplo,
ambas as instruções serão executadas apenas no caso do resultado ser verdadeiro. Essa é a principal
finalidade das instruções compostas, agrupar instruções a serem executadas em instruções condicionais e
de repetição.

5.2.2. Case
A medida em que vamos escrevendo instruções ifs aninhadas elas vão tendo seu entendimento cada vez
mais complexo, dificultando o desenvolvimento e a manutenção do código escrito. Em substituição à
escrita de ifs aninhados, o Object Pascal oferece a instrução case. A instrução case permite, da mesma
maneira que a instrução if, o controle condicional relativo ao fluxo do programa, porém esse controle é
feito de forma mais clara e, em muitos compiladores, de forma mais eficiente em relação ao código gerado.

Sintaxe
Case <Seletor> Then
<Rótulo 1> : <Instrução 1> ;
<Rótulo 2> : <Instrução 2> ;
<Rótulo n> : <Instrução n> ;
end;
Case <Seletor> Then
<Rótulo 1> : <Instrução 1> ;
<Rótulo 2> : <Instrução 2> ;
<Rótulo n> : <Instrução n> ;
else
<InstruçãoOutroCaso>;
end;

Exemplos
Case Caractere Then
‘a’ : ShowMessage(‘Caractere inválido’) ;
‘b’, ‘c’, ‘d’ : begin
x := x + 1;
Soma := x + y;

Página: 60
Delphi 5

end;
‘e’..’z’ :;
end;
Case Nota Then
0 : Texto := ‘Reprovado’ ;
1..5 : Texto := ‘Recuperação’ ;
6..9 : Texto := ‘Aprovado’ ;
10 : Texto := ‘Parabens’;
end;
Observemos o quadro anterior. Nele está sendo mostrado as duas sintaxes possíveis para a escrita de uma
instrução case dentro de um programa em Object Pascal. Em ambos os casos, a instrução case é utilizada
para executar uma instrução, simples ou composta, dependendo do valor do seletor passado. O seletor será,
na grande maioria dos casos, uma variável cujo valor deseja-se ser testado. Um detalhe a ser observado na
utilização da instrução case está na restrição da utilização de tipos de variáveis como seletores para uma
instrução case. O Object Pascal só permite que sejam utilizados seletores de tipos de dados ordinais. Dessa
forma, não são permitidos, por exemplo, a utilização de seletores do tipo string nem de ponto flutuante.
Um fato interessante relacionado à instrução case aparece nos rótulos que podem ser utilizados dentro da
instrução. Nos exemplos fornecidos podemos observar que podem ser utilizados desde valores simples,
valores múltiplos, ou até mesmo uma faixa de valores a serem testados. Caso nenhum dos valores definidos
pelos rótulos do comando case represente o valor fornecido pelo seletor da instrução poderá ser definido
dentro da instrução, um rótulo else que será executado nessas situações. Ou seja, o else dentro de uma
instrução case identifica as instruções a serem executadas no caso de nenhum dos rótulos fornecidos. O
else é opcional dentro de uma instrução case.

5.3. Estruturas de Repetição


As instruções que vimos até agora são bastante úteis durante o desenvolvimento de uma aplicação. No
entanto existem ainda algumas outras instruções que permitem o controle do fluxo de execução do
programa de forma repetitiva e não só de forma sequêncial baseada em uma condição booleana como
acontecia com as instruções condicionais. Por isso, iremos dar início ao estudo das instruções do Object
Pascal responsáveis pelo controle do fluxo de execução de um programa através da repetição de suas
instruções com base em condições booleanas.

5.3.1. For
A primeira instrução de repetição que iremos estudar é a instrução for. Essa instrução é amplamente
utilizada quando desejamos repetir uma ou um conjunto de intruções por um determinado número fixo de
vezes. Por esse motivo, a intrução for utiliza-se de um contador para determinar se essa quantidade de
interações que o laço deverá realizar já foi atingido ou não.
Sintaxe
for <Contador := <Valor1nicial> to <ValorFinal> do
<Instrução>;
for <Contador := <Valor1nicial> downto <ValorFinal> do
<Instrução>;

Exemplos
for Cont := 1 to 10 do
Acum := Acum + Cont;
for Cont := 10 downto 1 do
Acum := Acum + Cont;
for Cont := 1 to 10 do
begin
Acum := Acum + Cont;
ShowMessage(IntToStr(Acum));
End;
for Cont := 1 to 10 do
Cont := Acum + Cont; //Errado

O quadro acima mostra as duas sintaxes possíveis para a instrução for. As duas funcionam da mesma
maneira diferenciando-se uma da outra unicamente pela forma como o contador é utilizado. Na primeira
sintaxe apresentada, o contador é incrementado a cada interação do laço. Já na segunda, o contador é

Página: 61
Delphi 5

decrementado. Os exemplos apresentados permitem verificar que podem compor a instrução for tanto
instruções simples quanto compostas. Essa característica se repete para as demais instruções de repetição e
por isso não mais repetiremos essa afirmação a menos que exista alguma diferença de comportamento.
Dois pontos importantes dever ser observados em ambas as sintaxes utilizadas para a instrução if. O
primeiro deles é que o contador utilizado no laço é uma variável local ao procedimento no qual o laço está
sendo executado. O segundo ponto importante é que a variável a ser utilizada como contador para o laço
for não pode ser alterada dentro do laço como mostrado no exemplo. A tentativa de alterar o seu conteúdo
resulta em erro durante a compilação do aplicativo, é função do próprio Object Pascal incrementar ou
decrementar o contador deixando o desenvolvedor livre dessa preocupação.

5.3.2. While
A segunda instrução de repetição que iremos estudar é a instrução while. Essa instrução, de forma
semelhante ao que acontecia com a instrução for tem sua execução controlada por uma condição booleana
só que, ao invés da condição ser analisada em relação a um contador, a condição booleana a ser avaliada
pode ser uma expressão booleana qualquer.
Sintaxe
while <Condição> do
<Instrução>;
Exemplos
while Cont < 10 do
Cont := Acum + Cont;
while Cont < 10 do
Acum := Acum + Cont; //Cuidado -> Loop infinito
while Cont < 10 do
begin
Acum := Acum + Cont;
Cont := Cont + 1;
end;
A sintaxe utilizada pela instrução while é bastante simples como pode ser observado no quadro acima. Para
que o fluxo de execução do programa passe a executar a intrução do laço while basta que a condição
declarada seja verdadeira. Uma vez em execução, as instruções contidas no laço só deixaram de ser
executadas quando a condição do laço se tornar falsa. Uma vez que a variável de controle do laço não é
mais controlada automaticamente, é função do desenvolvedor evitar que erros ocorram em relação à
atualização dessa variável. No exemplo acima, mostramos a ocorrência de um loop infinito. Caso o
desenvolvedor escreva equivocadamente o código apresentado, uma vez que o laço comece a ser executado
ele nunca será finalizado, o que muito provavelmente estará errado. O último exemplo mostra que sempre
devemos alterar, de alguma forma, o valor das variáveis que controlem o laço while, para garantir que esse
termine e o processamento do aplicativo continue normalmente.

5.3.3. Repeat
A última instrução de repetição que iremos estudar é a instrução repeat. Essa instrução assemelha-se
bastante à instrução while vista anteriormente salvo algumas diferenças que serão vistas posteriormente.
Vamos, então, observar a sintaxe utilizada para a instrução repeat juntamente com alguns exemplos.
Sintaxe
Repeat
<Instrução>;
Until <Condição>;
Exemplos
Repeat
Acum := Acum + Cont;
Cont := Cont + 1;
Until Cont >= 10;
Repeat
Acum := Acum + Cont;
Until Cont >= 10; //Cuidado -> Pode ser um laço infinito
Cont := 1;
Repeat
Acum := Acum + Cont;

Página: 62
Delphi 5

Until Cont >= 10; //Cuidado -> Laço infinito


A instrução repeat também possibilita a execução de instruções tendo como base uma condição booleana.
No entanto, ao contrário do que acontecia com a instrução while, as instruções contidas na instrução repeat
permanecerão em execução enquanto a condição do laço permanecer falsa, ou seja, o laço termina quando
a condição testada passa a retornar o valor verdadeiro. Essa é exatamente a primeira diferença existente
entre a instrução repeat e a instrução while. Uma segunda diferença entre esses dois comando está na
necessidade da determinação de um bloco de comando para que múltiplas instruções sejam executadas
dentro do laço. Quando utilizamos a instrução while devemos utilizar begin e end para determinar o bloco
de comandos a serem executados dentro dessa instrução. Já com o comando repeat isso não é necessário. A
própria instrução repeat tem seu término determinado pela palavra reservada until indicando quais
instruções devem ser executadas pelo laço. Por fim, uma outra diferença entre essas duas instruções está no
fato da instrução repeat ser sempre executada pelo menos uma vez enquanto que a instrução while poderá
ou não ser executada. Esse comportamento deve-se ao fato da condição da instrução while ser testada no
início do laço enquanto que a condição da instrução repeat só ser testada no final.
Os exemplos acima mostram tanto a correta utilização da instrução repeat quanto alguns erros que podem
acontecer ao utilizarmos essa instrução. Por se tratar de uma instrução de repetição semelhante à instrução
while, devemos também nos preocupar com a manipulação das variáveis que controlam a sua execução
para evitar a ocorrência de um laço infinito.No segundo exemplo, a instrução repeat poderá provocar a
execução de um laço infinito dependendo do valor que foi atribuído inicialmente à variável cont. Já no
último exemplo, um laço infinito irá ocorrer devido ao fato do valor inicial que foi atribuído à variável não
ser alterado durante a execução do laço.

5.4. Comandos de Desvio de Fluxo Padrão


As instruções de controle do fluxo de execução estudadas até aqui podem ter sua seqüência de execução
alterada permitindo, por exemplo, a saída antecipada de um laço. Para que isso seja possível o Object
Pascal dispõe de um conjunto de instruções capazes de alterar a seqüência de execução de código tanto no
nível das instruções de repetição quanto até de execução do próprio aplicativo. A seguir enumeramos as
principais instruções existentes no Object Pascal bem como suas funcionalidades.
• BREAK: Este comando serve para forçar a saída de qualquer estrutura de repetição.
Independentemente da condição ou do valor do contador, no momento em que a execução do
aplicativo atinge esta instrução, o fluxo de execução passa para a primeira instrução após o laço.
• CONTINUE : Age, também no laço, de maneira oposta a Break, levando o fluxo de processamento
de volta à primeira linha da estrutura de repetição. Porém, ao chegar nessa linha o contador,
no caso de um laço for é incrementado e, logo em seguida, o teste responsável pelo controle do
laço é novamente testado de tal forma a verificar se ele deve ou não ser executado mais uma vez.
• EXIT : O comando exit é semelhante ao comando break visto anteriormente, porém ao contrário de
forçar o fluxo de execução a sair do laço no qual ele se encontrava, o comando exit é utilizado
para forçar a saída de um procedimento ou função. O fluxo de execução ao invés de ser
passado para a instrução seguinte ao laço ele é passado para o procedimento ou função
“chamadora” de onde ele foi chamado.
• HALT : É necessário muito cuidado com o uso deste comando uma vez que ao ser executado, o
comando halt encerra o aplicativo imediatamente, deixando, por exemplo, ainda abertos quaisquer
arquivos que tenham sido abertos pela aplicação entre outras.

5.5. Instrução With (“Método de Taquigrafia”)


Vimos até aqui as principais instruções responsáveis pelo controle do fluxo de execução de um aplicativo
escrito em Object Pascal. Além de instruções de tomada de decisão e de repetição, o Delphi dispõe de
outros tipos de instruções tais como a instrução with.
A instrução with não possui qualquer influência no fluxo da execução de aplicativos, ela tem o único
objetivo de melhorar o código escrito nesses aplicativos propiciando uma diminuição do código escrito e
melhorando seu entendimento.

Sintaxe

Página: 63
Delphi 5

with <objeto/variável> do
<Instrução>;
Exemplos
Funcionario.Nome := ‘André’; with Funcionario do
Funcionario.Idade := 26; begin
Funcionario.Cargo = ‘Analista de Sistemas’; Nome := ‘André’;
Idade := 26;
Cargo = ‘Analista de Sistemas’;
End;
Form1.Font.Size := 16; with Form1.Font do
x := x + 1; begin
Form1.Font.Style := [ ]; Size := 16;
Form1.Font.Color := clBlue; x := x + 1;
Style := [ ];
Color := clBlue;
end;

O quadro acima mostra a sintaxe que deve ser utilizada quando desejarmos utilizar a instrução with.
Observe que, como parte da instrução, podemos utilizar tanto um objeto quanto uma variável. Essas duas
possibilidade também estão ilustradas no quadro acima. No primeiro exemplo temos a utilização de uma
variável, previamente declarada na seção var, chamada Funcionário. Essa variável tem como seu tipo
TFuncionario, declarado anteriormente quando explicamos o tipo de dados Record. No exemplo temos
tanto o código utilizado sem a instrução with como com ela. Observe que, ao utilizarmos a instrução with
não precisamos colocar, antes de cada campo da estrutura, a variável que estava sendo manipulada.
Além da utilização de variáveis do tipo record, mostrada no primeiro exemplo, a instrução with também
pode ser utilizada com objetos. O segundo exemplo apresentado, ilustra essa situação. Nele manipulamos
com propriedades do objeto Font, que por sua vez pertence ao objeto Form1. Com esse exemplo podemos
também observar que podemos, dentro da instrução with, manipular com vários níveis de definições de
objetos. Também nesse último exemplo podemos observar que nem todas as intruções contidas na
instrução with necessitam obrigatoriamente tratar com propriedades ou campos pertencentes ao objeto, ou
variável, sendo manipulado. Nesse exemplo, temos uma intrução responsável pelo incremento da variável
x, declarada anteriormente em uma seção var. O compilador duarnte a fase de compilação do aplicativo,

identifica que essa variável não pertence ao objeto sendo manipulado e verifica se existe uma variável x
que tenha sido declarada anteriormente. Caso exista, a compilação é feita normalmente, caso contrário uma
mensagem de erro é retornada na parte inferior do Editor de Código informando o erro conforme ilustrado
na figura abaixo.

6.Manipulando Formulários
Iniciamos os nossos estudos trabalhando com os formulários. Vimos como eles podem ser exibidos através
de dois de seus métodos e as diferenças entre a exibição de formulários modais e não modais. No entanto,
demos uma parada nesse estudo de tal forma a aprendermos alguns dos comandos existentes no Delphi
responsáveis pela determinação do fluxo de execução de nossos aplicativos. Essa para foi de extrema
importância uma vez que, no decorrer de nosso aprendizado do Delphi, necessitaremos desses comandos
para podermos escrever aplicativos que façam algo mais do que simplesmente exibir uma caixa de diálogo
ou um formulário. De agora começaremos a aprender um pouco mais sobre os formulários aprendendo
novas propriedades, métodos e eventos úteis. Devemos ressaltar que não iremos abordar, no decorrer de
nosso estudo, todas as propriedades que os componentes que iremos estudar apresentam uma vez que, se
isso fosse feito, seria impossível terminarmos esse estudo. Essa mesma observação também é válida tanto
para os métodos quanto para os eventos de cada componente a ser estudado. Além disso, alguns
componentes apresentam propriedades em comum, nesses casos não iremos abordar essas propriedades
todas as vezes que elas ocorrerem, apenas em sua primeira ocorrência.

Página: 64
Delphi 5

6.1. Principais propriedades


Vamos ser apresentados agora às principais propriedades de um formulário. Antes de começarmos
devemos saber que já conhecemos a propriedade name que aparece em todos os componentes do Delphi e
que, a alteração do valor dessa propriedade, é uma das primeiras coisas a ser feita ao iniciarmos o
desenvolvimento de uma aplicação, no caso da propriedade name do formulário, ou ao colocarmos um
componente qualquer no formulário.
Com o objetivo de ilustrarmos a funcionalidade das principais propriedades do formulário, nós iremos
construir um pequeno aplicativo, no início com pouca ou mesmo nenhuma funcionalidade, apenas para que
possamos observar o comportamento de cada propriedade a ser estudada. Em seguida, vamos resumir a
utilização de cada propriedade em um quadro ilustrativo. Dessa forma, vamos começar uma nova aplicação
através da selecção da opção New Application, localizada no menu File. Caso tenhamos feito alguma
alteração na aplicação atual, o Delphi irá nos perguntar se desejamos salvar ou não essas alterações. Para
salvarmos basta selecionarmos o botão Yes e darmos nomes tanto às units quanto à própria aplicação como
já visto anteriormente.
Uma vez que tenhamos criado uma nova aplicação vamos colocar alguns componentes em seu formulário
principal. Será necessário um componente button e
dois componentes edit conforme mostrado na figura ao
lado. Podemos observar que colocamos um dos
componentes edit, propositadamente, em um local que
ele não possa ser visto completamente dentro do
formulário, isso não tem importância agora uma vez
que estamos simplesmente querendo ilustrar algumas
das propriedades do formulário. Uma vez que
tenhamos colocado esses componentes vamos alterar
algumas das propriedades do formulário e depois
vamos criar dois procedimentos, o primeiro associado
ao evento OnClick desse formulário e não do botão
como poderíamos pensar inicialmente, e o segundo
associado ao evento OnClick do botão. Comecemos pela alteração de algumas das propriedades do
formulário.
A primeira propriedade que iremos modificar é a propriedade AutoScroll, trocando o valor true pelo valor
false. Ao fazermos isso podemos observar uma mudança no visual do formulário. Agora, a barra de
rolagem que existia no rodapé do formulário desapareceu. A propriedade AutoScroll é responsável por
definir se o formulário irá ou não exibir automaticamente barras de rolagem no caso de serem colocados
componentes em regiões fora da área de exibição de um formulário. Essa propriedade é importante quando
queremos desenvolver aplicações que possuam uma quantidade excessiva de componentes em seus
formulários. Um fato importante que pudemos observar é que, ao alterarmos o valor da propriedade
AutoScroll, o efeito da alteração é refletido direta e imediatamente na aplicação sendo desenvolvida,
mesmo estando ainda em sua fase de desenvolvimento dentro da IDE do Delphi. Devemos ter cuidado
porque muitas outras propriedades, ao terem seus valores alterados, só permitem a visualização dos efeitos
da alteração durante a execução do aplicativo e não dentro da própria IDE.
A segunda propriedade que iremos alterar é a propriedade BorderIcons. Observe que essa propriedade é do
tipo set e apresenta como itens quatro valores distintos: biSystemMenu, biMinimize, biMaximize e biHelp.
Vamos alterar essa propriedade de tal forma que ela só possua os elementos biSystemMenu e biHelp ativos,
ou seja, com valor true atribuído a esses itens enquanto que as demais irão possuir o valor false. Ao
contrário do que aconteceu com a propriedade AutoScroll, ao alterarmos a propriedade BorderIcons não
observamos qualquer alteração no formulário. Isso porque as alterações realizadas na propriedade
BorderIcons só são percebidas quando a aplicação estiver sendo executada e não dentro da IDE do Delphi.
Esse comportamento também é bastante comum entre as propriedades não só do formulário mas também de
muitos outros componentes.
Uma outra propriedade que iremos alterar neste nosso exemplo é a propriedade BorderStyle. Observe que
essa propriedade é uma propriedade que possui uma série de valores possíveis a serem atribuídos a ela, são
eles: bsDialog, bsSingle, bsNone, bsSizeable, bsToolWindow e bsSizeToolWin. Esses são os valores
possíveis, definidos a partir de um tipo de dados enumerado chamado TFormBorderStyle, criado no Delphi
conforme mostra a ajuda on-line mostrada ao lado. Com isso já sabemos que, no caso de desejarmos alterar
o valor dessa propriedade em tempo de execução, ou seja, através de código escrito utilizando Object

Página: 65
Delphi 5

Pascal, a atribuição deverá ser feita diretamente utilizando-se um desses valores, não podendo, portanto, ser
utilizadas aspas ou qualquer outro delimitador. Daremos um exemplo posteriormente de como poderemos
fazer tal codificação. Por ora vamos alterar o valor dessa propriedade para bsSingle.
A propriedade Caption é a propriedade do formulário mais alterada no desenvolvimento de aplicações.
Vamos alterá-la também de tal forma a ela possuir o valor Meu primeiro exemplo. Observe que a medida
em que vamos digitando, o texto contido na barra de título do formulário vai se modificando de tal forma a
conter exatamente o texto sendo digitado. Antes mesmo de executarmos a aplicação já sabemos qual a
finalidade dessa propriedade dentro de um formulário.
Por fim vamos alterar os valores contidos em três propriedades do formulário. São elas a propriedade
FormStyle, a propriedade Icon e a propriedade WindowState. A propriedade Icon contém um objeto do tipo
TIcon e por isso sua atribuição dentro do Editor de Código do Delphi não pode ser feita de modo tão
imediato quanto pode ser feito com valores de tipos básicos, sets ou mesmo enumerados. São necessários
alguns cuidados adicionais como a criação do objeto entre outros, que serão vistos posteriormente quando
estivermos trabalhando com os conceitos de orientação a objetos. Porém, quando definimos os valores para
essas propriedades através do Object Inspector, o Delphi encarrega-se desses detalhes para o
desenvolvedor. Para selecionarmos um valor para a propriedade Icon devemos clicar o botão que aparece
no Object Inspector ao selecionarmos essa
propriedade. Será exibida a caixa de diálogo Picture Editor,
mostrada ao lado, que irá permitir que selecionemos um arquivo
que contém um ícone a ser exibido para este formulário.
Para definirmos o ícone a ser utilizado devemos clicar o
botão Load, selecionar o arquivo e, em seguida clicar no botão
Ok. Em nosso exemplo vamos selecionar o arquivo
‘factory.ico’, localizado no diretório ‘c:\Arquivos de
Programas\Arquivos Comuns\Borland
Shared\Images\Icons’. Observe que ao selecionarmos o arquivo e
clicarmos o botão Ok na caixa de diálogo Picture Editor, o
ícone localizado no canto superior esquerdo do formulário
é alterado para exibir o ícone selecionado. Devemos lembrar que ao alterarmos o ícone do formulário,
mesmo que esse ícone seja o ícone do formulário principal da aplicação, não estamos alterando o ícone da
aplicação, que é mostrado quando a minimizamos, mas sim o ícone do próprio formulário. Para alterarmos
o ícone da aplicação devemos fazê-lo através da caixa de diálogo Project Options mostrada anteriormente.
Já as duas outras propriedades, FormStyle e WindowState, são propriedades de tipos enumerados que
possuem os valores fsMDIChild, fsMDIForm, fsNormal e fsStayOnTop para a primeira propriedade e
wsMaximized, wsMinimized e wsNormal para a segunda. A propriedade FormStyle é responsável pela
definição do tipo de formulário a ser exibido pela aplicação. Dependendo de qual o valor atribuído a essa
propriedade o formulário terá um comportamento diferente dentro da aplicação. Dos valores possíveis o
mais comum é fsNormal que indica um comportamento normal para o formulário, ou seja, indica que o
formulário pertence a uma aplicação SDI (Simple Document Interface), tais como o próprio Delphi por
exemplo. Além das aplicações SDI temos também as aplicações MDI (Multiple Document Interface) como,
por exemplo, o Microsoft Word até a sua versão para o Office 97. Vamos alterar o valor da propriedade
FormStyle para fsStayOnTop. Novamente não observamos qualquer alteração no formulário dentro da IDE
do Delphi.
A última propriedade que iremos abordar pertencente ao formulário é a propriedade WindowState.
Podemos perceber a funcionalidade dessa propriedade sem ao menos alterá-la uma vez que os valores que
podemos atribuir a ela já nos dão uma idéia de sua funcionalidade. Essa propriedade é responsável pela
definição do estado do formulário, determinando se ele está minimizado, maximizado ou normal. Para
ilustrarmos a utilização dessa propriedade vamos criar um procedimento de evento associado ao evento
OnClick do botão. Esse procedimento deverá ter o código mostrado abaixo.

procedure TForm1.Button1Click(Sender: TObject);


begin
WindowState := wsMaximize;
end;

O código acima ilustra dois pontos importantes da programação utilizando o Object Pascal. O primeiro
refere-se a atribuição de valores a variáveis de tipos enumerados. Como já havia sido mencionado
anteriormente, a atribuição é feita diretamente, sem a utilização de aspas ou qualquer outro identificador. O

Página: 66
Delphi 5

segundo ponto está na atribuição do um valor a uma propriedade que aparentemente não pertence a
nenhum objeto. Como isso é possível uma vez que vimos que para manipularmos tanto com propriedades
quanto métodos de objeto deveríamos fazer uso do operador pornto? Em nosso exemplo isso não está
sendo feito. Não informamos que WindowState é uma propriedade do objeto Form1, porém veremos que
tanto o Delphi irá compilar a aplicação quanto irá executá-la corretamente.
Além de criarmos um procedimento de evento para o evento OnClick do botão também iremos criar um
outro para o evento OnClick do formulário como já havia sido informado no início desta seção. Esse
procedimento terá por finalidade mostrar o funcionamento de duas das propriedades do formulário vistas
nesta seção. Ao criarmos o procedimento deveremos escrever o código mostrado a seguir.

procedure TForm1.FormClick(Sender: TObject);


begin
ShowMessage(ActiveControl.Name);
if BorderStyle = High(BorderStyle) then
BorderStyle := Low(BorderStyle)
else
BorderStyle := Succ(BorderStyle);
end;
Observe que o código escrito acima faz uso de um procedimento e de uma função. O procedimento
ShowMessage, como já sabemos, exibe uma caixa de diálogo contendo a string passada como parâmetro.
Em nosso exemplo, passamos como parâmetro a string definida na propriedade name do objeto contido na
propriedade ActiveControl do formulário. Parece complicado? Pode parecer, mas na realidade é bastante
simples e ficará mais simples ainda quando compilarmos e executarmos o nosso exemplo. Por ora vamos
falar das funções Succ, High e Low que também utilizamos no código acima. Essas funções são utilizadas
para manipularmos com variáveis e propriedades de tipos ordinais. Lembre-se que tipos ordinais possuem
esse nome por determinarem uma ordenação sobre os valores que constituem esse tipo. A função succ não
faz nada mais do que retornar o próximo valor de uma variável ou propriedade de um tipo ordinal. Já as
funções high e low são utilizadas para informar os maiores e menores valores de um tipo ordinal qualquer.
O quadro abaixo mostra algumas das funções existentes para a manipulação de tipos ordinais.
Função Parâmetro Finalidade
Ord Expressão ordinal Valor da expressão ordinal

Pred Expressão ordinal Ordinal anterior referente ao resultado da expressão

Succ Expressão ordinal Ordinal posterior referente ao resultado da expressão

High Tipo ordinal Maior valore referente ao tipo ordinal passado como parâmetro

Low Tipo ordinal Menor valore referente ao tipo ordinal passado como parâmetro

Uma vez que já falamos rapidamente a respeito do código escrito para esse aplicativo vamos compilá-lo e
executa-lo para que possamos entender melhor tanto o código escrito quanto as propriedades que ele
manipula. Para isso ou selecionamos a opção Run
contida no menu Run, ou utilizamos o speedbutton
contido na Barra de Ferramentas do Delphi, ou ainda
utilizamos a tecla de atalho F9. Ao executarmos a
aplicação, o formulário principal da aplicação irá
aparecer na tela como mostra a figura ao lado.
Lembre-se que nós codificamos alguns eventos dessa
aplicação e por isso vamos testar o que cada um desses
eventos irá fazer quando for disparado. Vamos
começar pelo evento associado ao clique do botão. Ao
clicarmos o botão o formulário é maximizado. Isso
ocorre devido a atribuição do valor wsMaximize a essa
propriedade. Neste exemplo fizemos uma atribuição à
propriedade WindowState, contudo poderíamos ter apenas consultado esse valor para realizarmos uma
outra operação qualquer.

Página: 67
Delphi 5

O primeiro evento que vimos nesse exemplo não tinha muita utilidade, servia apenas para ilustrar uma
atribuição de um valor a uma propriedade em tempo de execução. Já o segundo evento que foi tratado é
mais interessante. Antes de clicarmos no formulário para testarmos o segundo evento, vamos retornar o
formulário para seu tamanho original. Porém em nossa aplicação não existe o botão para que a janela
retorne ao seu tamanho normal. Isso acontece devido à alteração que fizemos na propriedade BordeIcons
do formulário. Cada item dessa propriedade identifica quais serão os botões que estarão disponíveis em
tempo de execução para o formulário em questão. Em nosso exemplo disponibilizamos apenas os botões de
sistema (biSystemMenu) e de ajuda (biHelp).
Uma observação importante é necessária ao tratarmos com a propriedade BorderIcons. Lembre-se que esta
propriedade é do tipo set, ou seja, ela pode possuir uma seqüência de valores de forma arbitrária. Os
valores que ela irá conter indicam quais o botões que estarão disponíveis no formulário, porém mesmo que
todos os botões seja colocados à disposição nem todos eles estarão visíveis ao mesmo tempo como poderia
ser esperado. Por exemplo, caso removamos o botão biSystemMenu, nenhum outro botão ficará visível no
formulário independentemente deles estarem ou não definidos na propriedade. Um outro exemplo é o botão
biHelp. Esse botão só ficará visível no caso de tanto o botão biMaximize quanto biMinimize estarem
desabilitados. Essa foi exatamente a situção de nossa aplicação. Além disso, outras propriedade afetam a
exibição desses botões como é o caso da propriedade BorderStyle como será visto adiante.
Uma vez que não temos o ícone para retornar o formulário ao seu tamanho
original, devemos dar um duplo clique em sua barra de título. Agora sim, que já
estamos com o formulário em seu tamanho original, podemos continuar a
manipular o nosso aplicativo. Vamos clicar no formulário de tal forma a executar
o procedimento de evento associado. Ao fazermos isso, uma caixa de diálogo é
exibida mostrando o nome do componente Button1 conforme mostra a figura ao
lado. A exibição do nome Button1 ocorre pois esse era o componente que estava
selecionado no formulário quando ele foi clicado. Se o componente selecionado
fosse a caixa de texto Edit1, esse seria o nome exibido na caixa de diálogo. Isso
ocorre uma vez que a propriedade ActiveControl do formulário contém o componente que está ativo no
formulário naquele instante. Observe que a propriedade ActiveControl é um objeto que, por sua vez,
também possui propriedades e métodos e, por isso, pudemos exibir o conteúdo de sua propriedade name.
Através da utilização da propriedade ActiveControl também poderíamos alterar qual o componente ativo do
formulário a qualquer instante, para isso seria necessária apenas a atribuição do nome do componente ã
propriedade conforme exemplificado a seguir.
Exemplo
/* Código escrito */
ActiveControl := Edit1;
/* Código escrito */
O código escrito acima é bastante simples. Trata-se de uma atribuição direta do nome do objeto à
propriedade ActiveControl do formulário. Devemos observar que não é atribuída uma string, que é o
conteúdo da propriedade name do componente, mas sim o próprio objeto Edit1. Ao executar essa linha, o
componente que passa a estar ativo no formulário, ou seja, que passa a ter o foco da aplicação é o
componente Edit1.
Agora que já sabemos o que faz a primeira linha de código escrita no procedimento associado ao evento
OnClick do formulário, podemos continuar clicando no botão OK da caixa de mensagem que foi exibida.
Uma vez que a caixa é fechada podemos perceber que o formulário é modificado. O que aconteceu? A
borda do formulário foi alterada! Essa alteração é exatamente o que o próximo comando que havíamos
definido proporciona. A função succ faz com que seja atribuída à propriedade BorderStyle do formulário
um novo valor, o valor seguinte àquele atualmente atribuído à propriedade BorderStyle. Porém não
utilizamos simplesmente a função succ uma vez que quando chegássemos ao final dos valores do tipo
enumerado a atribuição seria sempre para o último valor possível. Para evitar isso, foi colocada uma
instrução condicional que testa se a propriedade BorderStyle já possui o maior valor possível. No caso do
teste ser verdadeiro será atribuído o menor valor possível a essa propriedade, caso contrário a função succ é
a que ficará encarregada de definir qual o valor a ser atribuído à propriedade BorderStyle. Observe também
que dependendo do tipo de borda que esteja sendo atribuída ao formulário, nem todos os botões relativos à
propriedade BorderIcons são exibidos. Conforme havíamos mencionado anteriormente, a propriedade
BorderStyle tem influência sobre a exibição ou não desses botões. Com isso devemos ter cuidado tanto

Página: 68
Delphi 5

com o tipo de borda que estejamos atribuindo ao nosso formulário bem como com os valores que tenhamos
colocado na propriedade BorderIcons, pois caso tenhamos removido o ícone de sistema o usuário não terá
como fechar o formulário a menos que utilize as teclas ALT + F4 ou finalize a tarefa utilizando o
gerenciador de tarefas do Windows.
Antes de fecharmos a aplicação e retornarmos para a IDE do Delphi vamos observar o efeito de uma outra
propriedade do formulário que alteramos no Object Inspector. Vamos tentar alternar entre as aplicações
que estejam em execução utilizando as teclas ALT + TAB. Ao fazermos isso, podemos perceber que
conseguimos alternar entre as aplicações porém o nosso aplicativo Delphi sempre permaneceu por sobre as
demais janelas. Isso ocorreu devido a alteração feita na propriedade FormStyle. Ao colocarmos o valor
fsStayOnTop fizemos com que esse formulário sempre permanecesse sobre as demais aplicações
independentemente de qual aplicação esteja sendo manipulado naquele momento.
O último ponto que vamos observar antes de fecharmos a aplicação se refere à posição como o formulário
foi exibido. A menos de uma coincidência fantástica o formulário não deve ter sido exibido no centro da
tela como poderíamos querer que tivesse acontecido. Se observarmos melhor, o formulário foi exibido
exatamente na mesma posição em que ele se encontrava quando estávamos desenvolvendo-o na IDE do
Delphi. Isso ocorre graças a uma propriedade do formulário que define tanto a posição como, em alguns
casos, o tamanho do formulário com que ele é exibido pela primeira vez. Vamos fechar a aplicação e
retornar à IDE do Delphi. No Object Inspector podemos observar uma propriedade chamada position
pertencente ao formulário. Essa é a propriedade responsável por essa definição. Observe que o valor
default para ela é poDesigned, ou seja, de acordo com que foi definido quando estava na IDE. Caso
desejássemos que o formulário fosse exibido no centro da tela bastaria alterarmos o valor dessa
propriedade para poScreenCenter. Verifique na ajuda do Delphi os possíveis valores para essa propriedade
e o que cada um deles faz.
Um ponto que pode ser observado nas propriedades sets e de tipos enumerados do Delphi é que os valores
seguem um padrão de nomeação. As duas primeiras letras de cada valor identifica, de alguma maneira, a
propriedade a qual ele pertence. Por exemplo, os valores da propriedade BorderIcons começam pelas letra
bi, já os valores para a propriedade Position começam pelas letras pó e assim sucessivamente. Caso
desejemos desenvolver novos tipos devemos seguir esse padrão para que outros desenvolvedores consigam
trabalhar com esses tipos de forma mais amigável.
O quadro a seguir traz um resumo das principais propriedades vistas até aqui.
Propriedade Valores Finalidade
ActiveControl Componentes do Form Definir o componente ativo de um formulário
BorderIcons biSystemMenu, biMaximize, Determinar quais botões estão disponíveis no canto superior
biMinimize, biHelp diretiro do formulário
BorderStyle bsDialog, bsSingle, bsNone, Determinar o tipo de borda que será utilizado pelo formulário.
bsSizeable, bsToolWindow,
bsSizeToolWin
Caption String qualquer Texto a ser exibido na barra de título do formulário
FormStyle fsNormal, fsMDIChild, Determina o tipo de formulário a ser exibido.
fsMDIForm, fsStayOnTop
Icon Objeto da classe TIcon Ícone a ser exibido no canto superior esquerdo do formulário.
Position poDesigned, poDefault, Determina a posição e tamanho pré-definidos para alguns
poDefaultPosOnly, tiupos de formulários.
poDefaultSizeOnly,
poScreenCenter,
poDesktopCenter,
poMainFormCenter,
poOwnerFormCenter
WindowState wsNormal, wsMinimized, Determina como o formulário será exibido na tela.
wsMaximized

6.2. Principais métodos


Uma vez que vimos as principais propriedades da classe formulário podemos dar início ao estudo de seus
principais métodos. Durante o nosso estudo sobre formulários modais e não modais já fomos apresentados

Página: 69
Delphi 5

a dois desses métodos: show e showmodal. Como vimos esses métodos são responsáveis pela exibição de
formulários dentro de nossas aplicações. Além desses, existem outros métodos dentro da classe formulário
que devem ser estudados. Já que sabemos como exibir formulários começar o nosso estudo a respeito dos
principais métodos dos formulários sendo apresentados ao método responsáveis por fechá-lo.
De forma semelhante ao que foi feito para ilustrar as principais propriedades do formulário, iremos
construir uma pequena aplicação para ilustrar tanto os principais métodos quanto os principais eventos
existentes para um formulário. Dito isso, vamos começar a nossa nova aplicação, salvando a aplicaçãio
anterior se necessário. Desta vez, vamos criar a aplicação manipulando com as propriedades que já foram
vistas na seção anterior, por exemplo, alterando os nomes dos formulários e componentes que forem sendo
criados.

6.3. Principais eventos

7.Componentes de Interface

7.1. Componentes Básicos de Interface

7.1.1. Menus
Lembra-se como era penoso fazer um Menu em qualquer linguagem de ambiente caracter? Pois é! Na
programação delphi pode esquecer todo aquele tempo e esforço, pois é apenas alguns clicks e atribuir
nomes e títulos as opções/comandos e pronto o menu principal está pronto para uso.

MAINMENU (Menu Principal)


Página de Componentes: Standard — Classe: TMAINMENU

P r o p r i e d a d e s
Items Chamar o Editor de Menu para inclusão de Itens

Dicas No editor de Menu dê um click


com o botão da direita do mouse
em um item para:
• Inserir ou deletar o item;
• Criar sub-menu no item atual;
• Ir para outro Menu.

P r o p r i e d a d e s d e c a d a I T E M (do menu)
Checked Marcado ou Não-Marcado ?
ShortCut Configurar tecla de Atalho
GroupIndex Se <> 0 indica que pertence a um grupo de Itens
RadioItem Só pode ter um item marcado no grupo?

Nota.: Para inserir um separador de Menu é só colocar no Caption de um item um “-” (hífen).

Você quer que quando o usuário der um click pressionando o botão da direita apareça um menu flutuante
(Local/Rápido/Suspenso)? Não tem o que fazer! A maioria dos componentes possuem um propriedade
chamada PopUpMenu é só nela você indicar o “name” do componente PopUpMenu disponível que você
preparou. Abaixo temos o componente PopUpMenu em estudo:

Página: 70
Delphi 5

POPUPMENU (Menu Flutuante ou Local)


Página de Componentes: Standard — Classe: TPOPUPMENU

P r o p r i e d a d e s
AutoPopUp Charmar automaticamente?
Alingment Exibir: no centro, esquerda ou direita do click?
Obs.: Propriedades do Item do PopUpMenu é igual ao do Menu Principal

7.1.2. Botões
BUTTON (Botão de Comando)
Página de Componentes: Standard — Classe: TButton

P r o p r i e d a d e s
Caption Título (Legenda) do objeto. Apenas para o usuário ler.
Name Nome do objeto quando referenciado na Unit. Utilizado no código-fonte.
Default Se Pressionar “Enter” esse botão será o acionado ?
Cancel Se pressionar “Esc” esse botão será acionado ?
ShowHint Apresentar o “H i n t ” (Dica de Ajuda flutuante) ?
Hint Texto da Descrição (Dica de Ajuda) flutuante. ShowHint = True para funcionar
ModalResult Retorno que o botão emitirá quando usado
Visible Visível ou Invisível ?
Enabled Habilitar ou desabilitar ?
Top Distância do Topo do Formulário
Left Distância da Esquerda do Formulário
Height Altura do Objeto (Tamanho Vertical)
Width Largura do Objeto (Tamanho Horizontal)
TabStop Receber foco com a tecla “TAB” ?
TabOrder Número de Ordem para receber o foco quando pressionada a tecla “TAB”

Name = 'ButtonAlterar' Enabled = False


Caption = 'Alterar Tamanho' (Obs.: Visto apenas na execução)
Enabled = True
Left = 280
Top = 96
Width = 105
Height = 25
Hint = 'Um click para alterar o tamanho'
ShowHint = True
TabStop = True Procedure TForm1. ButtonAlterarClick (Sender:
Figura 6 - Botão comTabOrder
Dica = 1 TObject);
OnClick = ButtonAlterarClick begin
ButtonAlterar.Height := ButtonAlterar.Height + 10;
ButtonAlterar.Width := ButtonAlterar.Width + 10;
Figura 7 - Desabilitado end;

Página: 71
Delphi 5

P r o p r i e d a d e s d e E v e n t o s
OnClick Quando o Objeto for Clicado chamará o Procedimento de Evento indicado

OnEnter Quando receber o foco chamará o Procedimento de Evento indicado


OnExit Quando perder o foco chamará o Procedimento de Evento indicado

BITBTN (Botão de Comando com Bitmap)


Página de Componentes: Additional — Classe: TBitBtn

Dicas
Altere, primeiramente, o Tipo da
P r o p r i e d a d e s propriedade Kind e o componente
fará automaticamente as mudanças
Glyph Carregar a Imagem que o botão exibirá nas seguintes propriedades: Caption,
Name, Glyph e ModalResult.
NumGlyphs Quantidade de partes da Imagem Carregada
Kind Imagens de Tipo Padrão
LayOut Posicionamento da Imagem quanto ao Texto
ModalResult Retorno que o botão emitirá quando usado
SPEEDBUTTON (Botão Ferramenta)
Página de Componentes: Additional — Classe: TSPEEDBUTTON

Dicas
Para trabalhar com um grupo de
P r o p r i e d a d e s botões onde só um possa ter o estado
abaixado em um certo momento.
Flat Efeito Tipo ferramenta do Internet Explorer Siga os seguintes passos:
1. Selecione todos que formam o
Glyph Carregar a Imagem que o botão exibirá grupo;
GroupIndex Se <> 0 indica que pertence a um grupo de botões 2. Altere o GroupIndex para um
valor diferente de zero ;
Down Se = True o botão está abaixado (pressionado) 3. Altere AllowAllUp para True;
4. Tire a seleção e faça um teste
AllowAllUp Se = True indica que só pode ter um botão abaixado alterando o valor de Down dos
no Grupo de Botões. GroupIndex <> 0 botões, um de cada vez.

Spacing Espaçamento entre o Texto e bitmap


LayOut Posicionamento da Imagem quanto ao Texto

7.1.3. Labels
LABEL (Etiqueta/Rótulo para Descrição)
Página de Componentes: Standard — Classe: TLabel

Dicas
1a Para indicar a “HotKey” (Tecla
P r o p r i e d a d e s quente) basta, na propriedade
Caption, você antes da Letra
Align Posição do Objeto no formulário escolhida colocar um caracter “&”.
Ex.: ‘Sai&r’. E pronto ficará assim:
Alignment Alinhamento do Texto: Sair . Não esqueça de habitar
ShowAccelChar;
Esquerda,Centro ou direita 2a A etiqueta não pode receber
foco, mas pode passar o foco. Para
LayOut Posição do Texto na Etiqueta isso, indique a “Tecla quente” e utilize
ShowAccelCha “True” para permitir o uso de “Tecla Quente” a propriedade FocusControl
escolhendo um controle, como um
Objeto Edit.

Página: 72
Delphi 5

r (&)
FocusControl Passar o foco para ... . “ShowAccelChar”
deverá ser “True”
WordWrap Rolamento do Texto dentro da Etiqueta

7.1.4. Caixas de Texto


EDIT (Caixa de Edição ou Caixa de Texto)
Página de Componentes: Standard — Classe: TEdit
Dicas
1a Quando for trabalhar com
P r o p r i e d a d e s entrada de Senha altere a propriedade
PassWordChar para ‘*’;
CharCase Letras em Minúsculo, Normal ou Maiúsculo 2a Para não permitir a edição do
conteúdo altere a propriedade
Color Cor para o Objeto
ReadOnly para True ;
AutoSize Mudar de largura dependendo do Texto 3a Para controlar a Entrada de
Dados use: CharCase e
ReadOnly Apenas para Ler ? MaxLength.

BorderStyle Estilo da Borda do Objeto


Ctl3D Efeito Tridimensional (3D) no Componente ?
MaxLength Largura máxima do Texto
Text Texto do Objeto
Font Formatação da fonte: Tipo, Tamanho, Cor e...
AutoSelect Quando receber o foco Selecionar o Texto ?
PassWordChar Caracter apresentado quando for uma senha

P r o p r i e d a d e s d e E v e n t o s
OnChange Quando o conteúdo do objeto mudar será chamado o Procedimento de Evento indicado
OnDblClick Quando o Objeto receber Dublo-click será chamado o Procedimento de Evento
indicado

MASKEDIT (Caixa de Edição com Máscara)


Página de Componentes: Additional — Classe: TMASKEDIT

P r o p r i e d a d e s
Text Texto do Componente
EditMask String de configuração da Máscara

Caracteres de Configuração para E D I T M A S K


“;” Separador de campos da máscara
“:” e “/” Separador padrão do sistema
“#” Caracter Numérico ou Sinal Opcional
Obrigatório: “A” e “C” - Opcional: “a” e “c” Qualquer Caracter

Página: 73
Delphi 5

Obrigatório: “L” - Opcional: “l” Apenas Caracter alfabético


Obrigatório: “0” - Opcional: “9” Apenas Caracter Numérico
“!” Pular espaços em branco iniciais
“\” O próximo caracter é literal
“<>” Sem verificação de MAIÚSCULAS/minúsculas
“>” Converte para MAUÍSCULAS o que segue
“<” Converte para minúsculas o que segue

Estrutura da String de Configuração no E D I T M A S K


!(999)000-0000;1;_ Composição da Máscara (de fone por Exemplo).
;1 1 salvar tudo (Literal e Dados) e
0 salvar apenas os Dados (Números ou Letras)
;_ Caracter exibido para posições vazias (limpas).

7.2. Melhorando a interface

7.2.1. PANEL (Painel)


Página de Componentes: Standard — Classe Tpanel

P r o p r i e d a d e s Dicas
Align Posição do Componente no Formulário Nas propriedades BevelInner,
BevelOuter & BevelWidth você
BevelInner Contorno Interno: Baixo, nenhum e Alto Relevo poderá dar um efeito 3D muito
interessante ao Painel. Cuidado para
BevelOuter Contorno Externo: Baixo, nenhum e Alto Relevo não exagera!

BevelWidth Largura da Linha de Contorno

7 . 2 . 2 . CHECKBOX (Caixa de Seleção)


Página de Componentes: Standard — Classe: TCHECKBOX
Dicas
P r o p r i e d a d e s Observe abaixo o relacionamento
entre as propriedades:
Checked Marcado ou Não-Marcado ? AllowGrayed = True
Checked State
Alignment Alinhamento do Texto True cbChecked
False cbGrayed
State Tipos de Marcas: Marcado Preto, Marcado Cinza
False cbUnChecked
ou Não-Marcado
AllowGrayed Se “True” então podemos ter três “State”, senão
apenas dois (Marcado ou Não-Marcado)

7.2.3. RADIOBUTTON (Botão de Rádio)


Página de Componentes: Standard — Classe: TRADIOBUTTON

Página: 74
Delphi 5

P r o p r i e d a d e s
Checked Marcado ou Não-Marcado ?
Alignment Alinhamento do Texto

7.2.4. RADIOGROUP (Grupo de Botões de Rádio)


Página de Componentes: Standard — Classe: TRADIOGROUP

Dicas
P r o p r i e d a d e s Para adicionar opções (ou botões ) ao
grupo de botões de rádio faça o
Columns Quantidade de Colunas no Componente seguinte:
1. Acesse a propriedade Items do
ItemIndex Informa o Índice do Item Selecionado. RadioGroup e quando vê o botão com
reticência (...) dê um click;
Se –1 então nenhum item foi selecionado 2. No memo da caixa de diálogo que
apareceu digite as opções, uma em
Items Lista de Itens do Componente. cada linha, e dê OK.

8.Depurando aplicações
Depois do projeto compilado há sempre a necessidade, para teste ou por problemas de resultado, do
desenvolvedor querer depurar o seu programa procurando o(s) erro(s) ou apenas testando o fluxo do
programa. Então nesta aula vamos estudar o depurador integrado do ambiente. E aprender a fazer
pontos de parada, verificar valores dos identificadores e entender as categorias de informações de
depuração no Delphi. Temos que ter em mente, primeiramente, que o depurador interno (integrado) é
chamado toda vez que você executa um programa no ambiente Delphi & outra coisa importantíssima o
Delphi é uma ferramenta de programação visual para aplicações Windows (ambiente gráfico) e, sendo
como tal, os seus programas não são uma seqüência de comandos executados um a um, como em qualquer
linguagem de ambiente caracter (Clipper, Cobol, Fortran, C...). Entretanto, são baseados em mensagens
(eventos), não existindo a possibilidade de executar passo a passo cada linha do código-fonte. Sendo
assim, devemos marcar pontos de parada (interrupção) nos trechos de código que você quer depurar.

8.1. Principais Comandos de Passo a Passo


Step Over, F8 (Passo a Passo por sobre o código. Não entrar em cada sub-rotina);
Step Into, F7 (Passo a Passo por dentro do código. Entra em cada sub-rotina)

8.2. Depuração desde o Início


Sem executar solicite Step Over (F8 ou Run-Step Over) ou Step Into (F7 ou Run-Step Into);

8.3. Da execução à depuração


Execute o Projeto (botão Run ou F9);
Dê uma Pausa (botão Pause da SpeedBar ou Menu Run-Program Pause);
Depuração Passo a Passo (Step Over ou Step Into);

Obs.: Leia sempre a barra de título principal do Delphi para ver o estado do depurador interno
(Running [executando programa] ou Stopped [aguardando: F7, F8 ou F9]

8.4. Quando ficar em Loop Infinito ou Travar


No ambiente integrado Delphi:

Página: 75
Delphi 5

Solicite o Reset da Execução (Run-Program Reset)

Fora do ambiente de desenvolvimento Delphi:


Apenas um vez pressione [Ctrl+Alt+Del];
Na lista de programas em execução selecione o "rebelde" e Finalize-o.

Obs.: Para depurar também o Módulo "Program" do Projeto (arquivo DPR) selecione
na Caixa de Diálogo "Environment Option" na guia (página) "Preferences" o item "Step Program Block"

8.5. Marcando Pontos de Parada (interrupção)


Escolha a linha e:
Coloque o curso na linha que você quer uma parada e Pressione F5 ou
Dê um click na barra cinza vertica ao lado da margem esquerda do editor na altura da linha ou
Dê um click solicitando o Menu flutuante na linha e escolha o comando "Toggle Breakpoit"

Visualização de um Ponto de Parada

8.6. Verificando Valores nos Identificadores


Dica de Avaliação de Sobrevôo (Fly-by evalution hints):
Apresenta uma dica contendo o valor de qualquer identificador quando debaixo do ponteiro do mouse.
Disponível apenas na depuração;

Visualização do Uso do Recurso


Visualização do Uso do Recurso

Página: 76
Delphi 5

Para Monitorar uma variável selecione o nome da variável e:


sem tirar a seleção invoque o menu flutuante e escolha o comando "Add Watch at Cursor"
ou
pressione [Ctrl+F5] e automaticamente iremos à caixa de diálogo "Watch Properties".

Depois de configurada a monitoração o nome da variável estará em uma lista. Para remove-la basta
selecionar e pressionar a tecla [Del].

Lista de Monitoração

9.Tratamento de Erros (Exceções)


Até agora trabalhamos sem nos preocuparmos com erros que aparecem na execução do aplicativo. Você teve
ter percebido que o Delphi quando algo ocorre de errado em tempo de execução do aplicativo em desenvolvimento, ele
mesmo dá um mensagem de erro informando o problema. Porém não é profissional por exemplo quando um usuário
está trabalhando com um aplicativo e acontece um erro. Ele receber no momento uma mensagem curtíssima em inglês
acompanhada, às vezes, de um código ou nome de erro totalmente obscuro, não ajudando em solução alguma. E logo
em seguida o computador travar ou o aplicativo é descarregado sem o menor aviso ao usuário, deixando-o furioso e
frustado com o produto. Bem, para não acontecer isso é que no Object Pascal há a possibilidade do programador
proteger o código-fonte. E quando ocorrer um erro (exceção) o programador ter o poder de tratá-lo e enviar ao usuário
uma mensagem amistosa em seu idioma nativo e sem maiores transtornos. Ou, por outro lado, o programador pode
fazer um tratatamento do problema e sem incomodar o usuário com alguma mensagem.

9.1. Bloco de proteção Finally

Bloco que protege o código e sempre que termina-o, ocorrendo erro ou não, executa um ou mais
instruções de finalização do processamento.

Try
< Instruções protegidas >
Finally
< Instruções executadas sempre após as Instruções Protegidas. Ocorrendo erro ou não! >
End

9.2. Bloco de proteção Except

Bloco que protege o código e sempre que ocorre um erro ele executa um ou mais instruções de para
tratamento do erro. E além disso o programador pode avisar ao usuário sobre o problema acontecido via uma
caixa de diálogo (usando, por exemplo, MessageDlg ) ou não.

Try
< Instruções protegidas >

Página: 77
Delphi 5

Except
[ on { NomeDoTipoDeExceção } do [ NomeDeUmSubRotinaPersonalizada; ] ]
< ou Instruções em um bloco begin-end para tratar e/ou Informar Erros >
[ else ]
{ Para todos os outros tipos de Erros }
End

Há várias maneiras de você usar essa estrutura de bloco depois da palavra Except:

1. Apenas de forma generalizada (para qualquer tipo de erro) com uma ou mais instruções:

... Except
begin
ShowMessage('Ocorre um erro! Repita a operação, por favor.');
{ . . . outras instruções . . . };
end; ...

2. Focalizando Tipos de Erros em particular que podem acontecer ao código protegido e indicar uma
Sub-rotina personalizada , uma instrução ou algumas instruções, para cada:

... Except
on EDivByZero do TratarErroDeDivisao;
on EConvertError do ShowMessage('Erro de Conversão!!!');
on EDatabaseError do
begin
ShowMessage('Erro na manipalação dos Dados');
Edit1.Text := '';
end; ...

Atenção! A recepção do erro é seqüencial. Ocorrendo um erro não vai ser verificado o próximo tipo
de erro da seqüência informada no except.

9.3. Blocos Aninhados (Finally & Except)


Um recurso que não existe e que é muito útil e importante, é uma estrutura unindo os blocos FINALLY e
EXCEPT em um só bloco. Porém podemos inventar fazendo um aninhamento dos dois blocos obtendo um
estrutura mesclada de tratamento de erro. Esse terá, resumindo, uma área de proteção de código, uma área de
tratamento do erro e uma área de limpeza e/ou de finalização.

Try { Início do Bloco: Try ... Finally }

Try { Início do Bloco: Try ... Except }

< Área de Código Protegido... >

Except { Se ocorre um erro... }


on NomeDoErro do

< Instruções da Área de Tratamento do erro... >

End; { Fim do bloco: Try ... Except }

Finally { Fim do bloco: Try ... Finally }

< Instruções da Área para Tratamento final.

Página: 78
Delphi 5

Havendo erro ou não serão executadas... >

End; { Fim do Try ... Finally }

10.Banco de Dados em Delphi


Um dos recursos que agrada mais aos programadores na programação Delphi é a parte de Banco de Dados.
A facilidade de se trabalhar a conexão e as referências no aplicativo aos elementos do banco de dados. E a
ausência dos detalhes de baixo nível que sempre aparecem, especialmente nos aplicativos cliente/servidor
(travar, liberar... ).
Os componentes Delphi específicos para banco de dados, sejam para acesso ou controle. Deixando tudo
mais fácil e diminui em muito a codificação. Com certeza tudo, em programação visual, é uma questão de
"setagem" das propriedades dos componentes. Como você já observou até agora com a maioria dos
componente visuais e não-visuais.
Em Delphi o aplicativo não tem acesso direto aos dados. Há uma interface que gerencia e viabiliza o
processo de controle da fonte de dados para o seu aplicativo e sem ela nada funciona. O nome dessa
interface é BDE (Borland Database Engine). Abaixo a Estrutura de Acesso a Banco de Dados no Delphi:

Ap lica tivo Delp hi

BDE ODBC

SQL Links Arquivo Texto


Paradox Access
DB2
dBase Arquivos Excel
InterBase
ASCii Oracle
Oracle
InterBase
FoxPro Informix
Access SysBase MS-SQL Server e Outros

MS-SQL Server
9 Interface de Dados & Formatos de Dados:
1. Formatos Nativos:
1.1. BDE dá acesso direto a vários formatos, como:
dBase (.dbf), Paradox (.db), ASCII(.txt), FoxPro(.dbf) e Access (.mdb);
1.2. BDE + SQL Links acesso para servidores remotos, formatos:
Oracle, DB2, Informix, InterBase, Sybase e MS-SQL Server;

2. ODBC (Conectividade de Banco de Dados Aberta) da Microsoft, formatos:


Access, Arquivos Excel, Oracle, InterBase, SQL Server, arquivo de Texto e etc... .

9 Utilitário Delphi para Banco de Dados:


1. DataBase DeskTop: Utilitário para criar, manter e alimentar tabelas de vários formatos.
2. DataBase Explorer ou SQL Explorer: Utilitário para manutenção e consulta de Alias (apelido que
informa onde está a fonte de dados e qual o seu formato), consulta e inserção/exclusão de dados das
tabelas, montagem de consultas por meio de código SQL e manutenção de dicionários;
3. Form Wizard: Assistente de criação de formulário de Banco de Dados (Menu DataBase-Form
Winzard...);
4. BDE Administrator: Utilitário que gerencia a configuração e os "Alias" (apelidos);
5. Data Migration Wizard: Assistente de Conversão de formatos de dados;

Com certeza você já está ciente desta terminologia, mas não custa relembrar:

• Tabela: Conjunto de Tuplas (Linhas/Registros) e Atributos (Colunas/Campos);


• Arquivo de formato Simples de Dados: Conjunto de Registros (linhas) e Campos (colunas).
• Consulta: Tabela dinâmica e não física, resultante de uma Seleção ou União;

Página: 79
Delphi 5

• Banco de Dados baseado em Tabelas: Um só arquivo contendo um conjunto de Tabelas, Consultas


(Visões), Índices, Procedures ... em que qualquer operação de consulta resulta em um Tabela de Dados ;
• Banco de Dados baseado em Registros: Conjunto de Arquivos (simples de dados, índices e memo)
separados fisicamente em que qualquer operação de consulta resulta em Registros;
• Técnicas de Ajustamento: Indexação e Ordenação.

As duas formas de fonte de dados: a Baseado em Registros e a Baseado em Tabelas são acessadas pelo
Delphi e você pode trabalhar com arquivos simples de dados (Baseado em Registros), como no formato
dBase, com os seus índices e "campos MEMOs" em arquivos separados, porém em uma mesma pasta de
arquivos (diretório). Ou, trabalhar com formato Interbase (Baseado em Tabelas), que tem todas as
tabelas, consultas, índices e ... em um só arquivo. Para o BDE, quanto ao acesso, é a mesma coisa pois ele
possui um abordagem particular que trata os dois da mesma forma. É como se ele, o BDE, olhando para
uma Pasta de Arquivos dos arquivos dBase (dados, index e memo) visse um Banco de Dados baseado em
Tabelas. Tratando todo e qualquer arquivo de registros como uma tabela. Porém por natureza um Banco
de dados baseado em Tabelas e totalmente diferente, ideologicamente e tecnologicamente falando, de um
Banco de dados baseado em Registros. O último não são suportadas certas operações.
Quanto a indexação e/ou ordenação são feitas automaticamente após um deleção ou inclusão.

10.1. O que é um Alias (Apelido)?


O alias é uma referência ou vínculo relacionado a um Banco de Dados. Pense no antigo comando Path do
"falecido" DOS que informava o caminho para se encontrar os comandos do sistema operacional. Lembra-
se?! Bem, para cada banco de dados (Bas. em Tabelas ou em Registros) há um nome relacionado a ele que
facilita muito porque você não precisar digitar um caminho (unidade e caminho [NomeDoArquivo]) para
referencia-se a um determinado Banco de dados e ter acesso a ele . Basta setar o nome do Alias no
componente e você acessará a qualquer elemento do Bando de Dados. Conheceremos os componentes
mais tarde.

10.1.1. DataBase DeskTop

Para cria suas tabelas, índices (primários e secundários), integridade referêncial, senhas, editar dados e fazer
manutenções. Você usará o utilitário DataBase DeskTop.

I. Para Abrir uma tabela:


1. Escolha no Menu: File - Open;
2. Indique o Alias do Banco de Dados ou a Pasta de Arquivos;
3. Escolha o nome da tabela;

II. Para Editar Dados (fazer manutenção dos dados) de uma tabela:
1. Abra a tabela;
2. Escolha no Menu: Table - Edit Data.

III. Para Restrutura uma tabela:


1. Abra a tabela;
2. Escolha no Menu: Table - Restructure

IV. Passos para criar uma tabela e índice primário:


1. Carregue o utilitário e escolha no seu menu File - New - Table;
2. Indique o formato (tipo da tabela);
3. Na criação da Estrutura é só digite o nome do campo (use o "TAB" para navegar);
4. Estando no Tipo pressione "Barra de Espaço" (com o Mouse dê um Clique o botão da direita) e
escolha o tipo;
5. Defina o Tamanho;
6. Estando no "Key" (Chave Primária) e sendo o campo atual a chave primária ou parte dela pressione
"Barra de Espaço" (usando o Mouse dê um Duplo-Clique) e aparecerá um "*";
7. Defina os outros campos repetindo os passos de 3 a 6;
8. Terminado salve a tabela em uma Pasta de Arquivos ou indicando um Alias.

Página: 80
Delphi 5

Caixa de Diálogo "Create Table" do DataBase DeskTop

V. Passos para criar índices secundários:


1. Entre na Caixa de Diálogo "Create Table" do DataBase DeskTop;
2. Acesse a Caixa de Combinação "Table Properties" e opte por "Secondary Indexes";
3. Logo abaixo da caixa de combinação existe um botão de título "Define", pressione-o;
4. Na caixa de Diálogo "Define Secondary Indexes" escolha os campos e passe-os para lista de campos do índice;
5. Salve a índice com um nome sugestivo.

Caixa de Diálogo "Define Secondary Index"


10.1.2. Tipos dos Campos (Paradox & dBase)
Já que vamos trabalhar com Paradox e/ou dBase, então vamos observar seus tipos:

FORMATO PARADOX
Tipo Tamanho Nota
Alpha (A) 1 - 255 Alfanumérico
Number (N) - Ponto Flutuante
Money ($) - Formato Moeda
Short (S) - Numerico curto

Página: 81
Delphi 5

Long Integer (I) - Numerico Longo


BCD (#) 0 - 32 Ponto-flutuante Especial
Date (D) - Data
Time (T) - Hora
Timestamp (@) - Hora & Data
Memo (M) 1 - 240 memorando
Formatted Memo (F) 0 - 240 *.MB
Graphic (G) 0 - 240 Def. Tamanho Opcional
OLE (O) 0 - 240 Def. Tamanho Opcional
Logical (L) - Booleano
Autoincrement (+) - Auto-incremento
Binary (B) 0 - 240 Def. Tamanho Opcional
Bytes (Y) 1 - 255 Byte

FORMATO DBASE
Tipo Tamanho Nota
Character ( C ) 1 - 254 Caracter
Float (F) 1 - 20 Ponto Flutuante
Number (N) {BCD} 1 - 20 Numerico
Date (D) - Data
Logical (L) - Booleano
Memo (M) - Memorando
OLE (O) - OLE
Binary (B) - Gráfico

10.1.3. DataBase Explore ou SQL Explore


É uma Ferramenta ótima para consultas e edições (manutenção) de dados dos bancos de dados que
possuem Alias. Possui uma lista da estrutura de Acesso do BDE a esquerda de forma hierárquica e uma
apresentação dos dados em grade a direita na guia "DATA". Pode-se fazer consulta ao dados via código
SQL na gua "Enter SQL". Nela podemos cria novos Alias, só não podemos criar tabelas.
Para Criar um novo Alias (apelido):
1. Vá para o início da árvore (o item DataBases);
2. Acesse o Menu: Object - New;
3. Escolha o formato do Banco de Dados. Atenção! o formato denominado STANDARD é para o Banco de
Dados que tratará com os formatos: Paradox, dBase e Ascii;
4. Na propriedade PATH indique a unidade e o caminho de onde está o Bando de Dados;
5. Aplique (salve) a criação escolhendo o menu: Object - Apply
Apagar Elemento Begin/Commit & RollBack
Primeiro, Anterior, próximo e último
Cancelar Operação
Incluir, deletar, Editar,
Aplicar Operação
Gravar, Cancelar e Atualizar
Visualizar Imagem/Memo

Página: 82
Delphi 5

10.2. O Banco de Dados do Nosso Aplicativo


Siga os passos a seguir:
1. Com o Windows Explorer (Gerenciador de Arquivos) crie a pasta que armazenaremos o nosso Banco de
Dados.
2. No DataBase Explore crie um Alias do Tipo "Standard" com a propriedade "Path" tendo o caminho da
pasta que acabamos de criar.

3. Observe a pequena e resumida Modelagem da dados para você compreender os relacionamentos das
tabelas:
CodCargo
CodDepart
CodFunc
CodFunc 1 N
Funcionário Dependente
N N
CodDepend

1 1
Cargo Departamento

CodCargo CodDepart
Chave Primária
Chave Estrangeira
Chave Estrangeira Parte da Chave Primária

4. No DabaBase DeskTop crie as Tabelas e salve-as no Alias do nosso Banco de Dados com as estruturas a
seguir:
4.1. Tabela de Funcionários (nome do arquivo: Funcionario.DB):

Campo Tipo Tamanho Ch. Primária Índice Secundário


CodFunc Alpha 3 X
NomeFunc Alpha 45 X
DataDeNascFunc Date
EndFunc Alpha 65
UfFunc Alpha 2
CodCargo Alpha 2
CodDepart Alpha 2
FotoFunc Graphic
NotaFunc Memo 20

Página: 83
Delphi 5

4.2. Tabela de Dependentes (nome do arquivo: Dependente.DB):

Campo Tipo Tamanho Ch. Primária Índice Secundário


CodDepend Alpha 3 X
NomeDepend Alpha 45 X
DataDeNascFunc Date
CodFunc Alpha 3

4.3. Tabela de Cargos (nome do arquivo: Cargo.DB):

Campo Tipo Tamanho Ch. Primária Índice Secundário


CodCargo Alpha 3 X
NomeCargo Alpha 25 X

4.4. Tabela de Departamentos (nome do arquivo: Departamento.DB):

Campo Tipo Tamanho Ch. Primária Índice Secundário


CodDepart Alpha 3 X
NomeDepart Alpha 25 X

10.3. Restruturando o Banco de Dados

É claro que você não vai trabalhar assim. Fazendo e refazendo, mas às vezes acontece e você quer alterar. Por
isso vamos vivênciar o trabalho de restruturação de tabelas, para quando for necessário você não ter dificuldades.
Para apagar um campo use: [Ctrl]+[Del]. Para mover clique no número de ordem do campo e arraste-o. Altere
seguindo as orientações abaixo:

1. Alterar Funcionários (Altere apenas os listados e o elemento em negrito-Itálico):

Campo Tipo Tamanho Ch. Primária Índice Secundário


CodFunc Short X
CodUF Short
NotaFunc Memo 20

Obs.: CodUF substituirá o campo UfFunc

2. Restruturar Dependentes (Alterar os elemento em negrito-Itálico e Trocar as posições de CodFunc e


CodDepend):

Campo Tipo Tamanho Ch. Primária Índice Secundário


CodFunc Short X X
CodDepend Short X
NomeDepend Alpha 45 X
DataDeNascFunc Date

3. Alterar Cargos (Altere apenas os listados e o elemento em negrito-Itálico):

Campo Tipo Tamanho Ch. Primária Índice Secundário


CodCargo Short X

4. Alterar Departamentos (Altere apenas os listados e o elemento em negrito-Itálico):

Campo Tipo Tamanho Ch. Primária Índice Secundário


CodDepart Short X

5. Criar a Tabela de Estados e UF's (nome do arquivo: EstadosUF.DB):

Página: 84
Delphi 5

Campo Tipo Tamanho Ch. Primária Índice Secundário


CodUF Short X
NomeEstado Alpha 25
SiglaUF Alpha 2

Obs.: É obvio que há uma solução de manipulação de UF que não armazenado no BD, porém optamos por essa para usarmos um
componente de BD com essa tabela.

Complemento à nossa rápida modelagem:

CodUF

N 1 UF's
Funcionário

CodUF

10.4. Os Componentes de Banco de Dados I

Há duas categorias de componentes, quando se fala de Banco de Dados: os componentes de Acesso e os


componentes de controle. Os "de Acesso", pelo nome já dá para saber que, cuidam de toda parte relacionada ao
acesso ou vínculo com parte (tabelas...) ou todo o banco de dados, enquanto os "de Controle" trabalham com as
informações (registros ou campos) que estão nas tabelas ou consultas-SQL.

10.4.1. Conjunto de Dados (DataSet)


Antes de mais nada temos que saber o que é um DataSet. Um Dataset é Conjunto de todas as ocorrências ou
"registros" de uma tabela ou consulta-SQL. O Dataset (Conjunto de Dados) pode está, em um certo momento, em um
dos principais estados abaixo listados:
1.Tabela ou Consulta-SQL Fechada (dbInactive);
2.Em Consulta (dbBrowser);
3.Em Pesquisa, preparada para busca de informação, (dbSetKey);
4.Em Edição, atribuições de informações ao dataset, (dsEdit) &
5.Em Inserção, inclusão de novas informações ao dataset, (dbInsert)
Nota.: Nesta aula iremos estuda os métodos que possibilitam a mudança do estado de um DataSet.

10.4.2. Acesso ao Banco de Dados (Data Access)


Componentes que interagem com o bancos de dados. Iremos estudar os seguintes: Table (Tabela, gera um
DataSet), Query (Consulta-SQL, gera um DataSet) e DataSource (especifica o DataSet, "resultado" de uma Table ou
Query) que será a Origem de Dados para os controles de dados). Na seqüência falamos sobre os controles de dados...
Você já viu a Estrutura Geral de Acesso a Banco de Dados, porém não viu a estrutura de vínculos dos
componentes de banco de dados em um aplicativo Delphi. Abaixo temos uma Estrutura Exemplo:

APLICATIVO DELPHI

DBEditCodigo DBEditNome DBEditReferencia

DBEditCodPedido

DBEditDataPedido

BDE Arquivo(s) Físico(s)

Página: 85
Delphi 5

Figura - Estrutura de Vínculos dos componentes de banco de dados.

10.4.3. TABLE (Representa uma Tabela física)


Página de Componentes: DataAccess — Classe: TTABLE

Indica e representa uma tabela física de um certo Banco de dados, gerando um DataSet para a mesma. Não
pode ser utilizada diretamente pelos "outros componentes", necessitando de um componente intermediador
(DataSource).
Atenção!!! As propriedade estão posicionada na ordem que devem ser setadas (configuradas).

P r o p r i e d a d e s
Name Nome Identificador do componente
DataBaseName Nome do Banco de Dados ou Alias
TableName Nome da tabela física do banco de dados
Exclusive DataSet não compartilhado (exclusivo)?
ReadOnly DataSet apenas de Leitura?
MasterSouce Nome Identificador do DataSource da Tabela Mestre
MasterField Campo da Tabela Mestre
IndexFieldNames Nome do Campo que se quer indexar
IndexName Nome do Index (índice secundário) que se quer indexar
Active Abrir o DataSet ?
RecordCount Apenas em Tempo de Execução possui a quantidade de "Registros" do DataSet.
Ex.: LabelQuantDeRegistros.Caption := IntToStr ( Table1.RecordCount );

M é t o d o s
MUDANÇA DE ESTADO DO DATASET
Open Abrir um DataSet (Table ou Query). Ex.: Table1.Open;
Close Fechar um DataSet. Ex.: Query2.Close;
Edit Ativa o modo de Alteração para o "registro" corrente do DataSet
Insert Inserir um "registro" vazio e torná-o corrente no DataSet
Post Grava o "registro" atual no DataSet
Cancel Aborta ou Cancela uma Alteração (Edit) ou Inclusão (Insert)
Delete Apaga o "registro" corrente do DataSet
Refresh Atualiza o DataSet de uma Table
Append Anexa um "registro" vazio no final e torná-o corrente no DataSet de uma Table
PESQUISA
SetKey Preparar o DataSet indexado de uma Table para Pesquisa
KeyFieldCount Quando um índice é composto por mais de um campo você deve atribuir o
número do campo pelo qual quer basear sua pesquisa.
Ex.: Table1.KeyFieldCount := 0; {Explicação: vai baseado no primeiro campo}
GotoKey Retorna "True" se a pesquisa exata teve êxito.
If Table.GotoKey Then ShowMessage (' Código já existe!');
GotoNearest Retorna "True se a pesquisa aproximada ou inexata teve êxito.
If Table.GotoNearest Then ShowMessage ('Iniciais encontradas!!!');
POSICIONAMENTO
First Ao primeiro
Last Ao último
Next Ao próximo
Prior Ao Anterior
MoveBy ( ) Mova-se "n" "registros".
Ex. 1o: 5 registro à frente: Table1.MoveBy(5);
Ex. 2o: 5 registro para trás: Table1.MoveBy(-5);

Página: 86
Delphi 5

10.4.4. QUERY (Consulta ou Visão construída Via SQL)


Página de Componentes: DataAccess — Classe: TQUERY

Constrói uma tabela virtual com base em uma ou mais tabelas de um certo Banco de dados por meio de
código SQL, formando-se um DataSet. Já que usamos a versão Client/Server vamos construir o código
SQL com a ajuda de um utilitário chamado de "Query Builder", no devido momento iremos conhecê-lo.
Não pode ser utilizada diretamente pelos "outros componentes", necessitando de um componente
intermediador (DataSource).
Atenção!!! As propriedade estão posicionada na ordem que devem ser setadas (configuradas).

P r o p r i e d a d e s
Name Nome Identificador do componente
SQL Código SQL que vai ser executado quando a Query for aberta
DataBaseName Nome do Banco de Dados ou Alias. Geralmente é automaticamente setado por
causa do código SQL.
Active Abrir o DataSet ?
Params Quando a query tem vínculo com uma tabela é necessário informar o nome do
campo de relacionamento (que é passado como parâmetro)
DataSource Name do DataSource que possibilitará o vínculo da query com a tabela "mestre"
RecordCount Apenas em Tempo de Execução possui a quantidade de "Registros" do DataSet.

10.4.5. DATASOURCE (Indica a Origem de Dados)


Página de Componentes: DataAccess — Classe: TDATASOURCE

Componente que faz comunicação entre uma Table (ou Query) e os componentes de controle de dados
(DBEdit, DBText...) possibilitando-os a enxergar os campos representados por essa (table ou query).
Como você viu na figura de Estrutura de vínculos dos componentes, logo no início dessa aula, o
DataSource é fundamental a toda essa estrutura no aplicativo.

P r o p r i e d a d e s
Name Nome Identificador do componente
DataSet Name de uma Table ou Query que servirá como uma "fonte de Dados"
Enabled Ativar ou Desativar ?

10.4.6. Módulo de Dados (DataModule)


Em qualquer programação visual nos temos um formulário no qual colocamos alguns componentes para
compor a interface do nosso aplicativo em desenvolvimento. Porém na versão 3 do Delphi foi
incorporado, na parte de Banco de Dados, uma coisa parecida com um formulário para colocarmos os
componentes de Acesso a dados (Table, Query, DataSource...) chamado de DataModule, definido e
vinculado a uma Unit como acontece para os formulários. Tornando o desenvolvimento mais ordenado,
pois nas versões anteriores tínhamos componentes de Acesso a Dados espalhados por vários formulários.
Bem, há outros objetivos mas vamos ficar por aqui.

Agora vamos executar o seguinte para o nosso Banco de Dados recém criado:

1. No ambiente Delphi abra o nosso aplicativo e insira um DataModule (Menu File - New Data Module);

2. O DataModule será apresentado e nele você colocará uma Table para cada Tabela do Nosso Banco de Dados, e
para cada Table coloque um DataSource (no DataSet indique a Table);

3. Set tudo na seqüência correta, como indicado no posicionamento das propriedades e como ministrado pelo
instrutor. Não esqueça de denominar "names" sugestivos;

Página: 87
Delphi 5

DataBaseName DataSet = TableFunc


DataBaseName
= "indique o Alias criado " = "indique o Alias criado "
TableName = Funcionario.DB TableName = Cargo.DB
IndexFieldNames = CodFunc IndexName = IdxNomeCargo

DataBaseName DataBaseName
= "indique o Alias criado " = "indique o Alias criado "
TableName = Dependente.DB TableName = Departamento.DB
IndexName = IdxCodFunc IndexName = IdxNomeDepart
MasterSource
= DataSourceFunc
MasterFields = CodFunc *
DataBaseName
= "indique o Alias criado "
Visualização do Módulo de Dados com os componentes de Acesso
TableName = EstadosUF.DB
IndexName = IdxNomeEstado

4. Atenção! A Table para a tabela de Dependentes terá uma "configuração" diferenciada das outras Table. Pois
teremos que relacioná-la com uma Table Mestre (Master). E a Table Mestre será a de Funcionários (TableFunc).
Acompanhe a seqüência a seguir:

4.1. Depois que colocar o componente Table e sua DataSource e fizer as setagem normais (Name, DataBaseName,
TableName ... ). Vá para a propriedade MasterSource e indique o "Name" do DataSource da TableFunc;

4.2. Dê Duplo-clique para setar a propriedade MasterField. Aparecerá, então, uma caixa de Diálogo de nome
"Field Link Designer";

4.2.1. Escolha na Caixa de Combinação o índice secundário baseado no


código do funcionário disponível para a tabela de dependendes;
4.2.2. Aparecerá na lista "Detail Fields" o nome de campo CodFunc, selecione-o;
4.2.3. Selecione na lista "Master Fields" o nome de campo CodFunc, também;
4.2.4. Pressione o botão de Título "Add" que está ao centro da Caixa de Diálogo;
4.2.5. Pronto agora use o botão "Ok" para confirma a união pelo campos indicados.

Figura - Caixa de Diálogo "Field Link Designer"

10.5. Os Componentes de Banco de Dados II

Os Componentes de Controle de Dados são aqueles que exibem e permitem edição das informações do
bancos de dados, também chamados de controles consciente de dados (data-aware). Iremos estudar os
seguintes: DBNavigator, DBEdit, DBMemo, DBText (parecido com Label), DBImage (parecido com
Image), DBCheckBox, DBRadioGroup, DBLookUpComboBox e DBLookUpListBox.

Página: 88
Delphi 5

Esses componentes não tem acesso direto a tabela física, necessitam de um DataSource que indique um
certo DataSet (Table ou Query).

Antes de entrarmos no componentes de Controle de Dados (data-aware). Vamos nos lembrar do que já
fizemos no Nosso Aplicativo:
1. Formulário Principal com Menu;
2. Formulário de Entrada (Splash) com som;
3. Formulário Sobre;
4. Formulários Secundários chamados pelas opções do Menu Entretenimento (Multimídia);
5. O Banco de Dados (as tabelas paradox em um diretório) e seu Alias;
6. O Módulo de Dados (DataModule) referenciando as tabelas do Nosso Alias;

Bem, só falta os Cadastros: Funcionários e Dados Gerais (Departamentos e Cargos ) e os relatórios.


Vamos dar uma olhada na interface final dos formulários envolvidos nos cadastros:

Em um só formulário os cadastros de
departamentos e cargos. As páginas
possuem a mesma interface.
Nesse formulário existirá: inclusão,
exclusão e alteração, só que trabalharemos
sem código. Você vai ver como isso
funciona.

Neste formulário temos o cadastro


de funcionário. A interface muda um
pouco quando estamos em uma das
operações.
Nesse formulário existirá: inclusão,
exclusão e alteração, agora usando um
pouco de código Object Pascal.

Este formulário será apresentado quando


pressionarmos o botão Lista Dependentes do
cadastro de funcionário. Ele é um Cadastro
simples sem código algum para os dependentes,
porém automaticamente são relacionados ao
funcionário atual (corrente). Isso por causa das
propriedades: MasterSource e MasterFields da
Table dos Dependentes.

Página: 89
Delphi 5

Este formulário será apresentado


quando pressionarmos o botão
Buscar do cadastro de funcionário.
Nele pesquisaremos por um ou
alguns funcionário. O resultado da
busca será gerado por código SQL
de uma Query.

Agora que já fomos apresentados aos formulários de cadastro vamos continuar com o assunto e no momento
adequado iremos trabalhar em cada um neles.

Propriedades Comuns aos Controles de Dados


DataSource Name do DataSource relacionado ao DataSet (Table ou Query) requerido
DataField Name do campo do DataSet (Table ou Query) ao qual se quer ter acesso

10.5.1. DBTEXT (Etiqueta para Banco de Dados)


Página de Componentes: DataControls — Classe: TDBTEXT

Tem o mesmo objetivo da Label, não permitir acesso do usuário ao seu conteúdo.

10.5.2. DBEDIT (Caixa de Texto para Banco de Dados)


Página de Componentes: DataControls — Classe: TDBEDIT

Tem o mesmo objetivo e uso do Edit.

10.5.3. DBMEMO (Caixa de Texto Longo para Banco de Dados)


Página de Componentes: DataControls — Classe: TDBMEMO

Utilidade e objetivo igual ao componente Memo.

10.5.4. DBIMAGE (Área de Imagem para Banco de Dados)


Página de Componentes: DataControls — Classe: TDBIMAGE

Extensão do componente Image para vínculo com um campo Gráfico de um DataSet.

Página: 90
Delphi 5

10.5.5. DBCHECKBOX (Caixa de Seleção para Banco de Dados)


Página de Componentes: DataControls — Classe: TDBCHECKBOX

Extensão do componente CheckBox para vínculo com um campo Lógico de um DataSet.

10.5.6. DBRADIOGROUP (G. de Botões de Rádio p/ Banco de Dados)


Página de Componentes: DataControls — Classe: TDBCHECKBOX

Extensão do componente RadioGroup para vínculo com um campo de um DataSet que possua múltipla escolha
ou opção.

Propriedades Particulares
Items Nomes dos botões (itens) do grupo
Values Valor, de cada item, que será encaminhado ao campo se o item (botão) for
escolhido. Cada valor para o seu respectivos item.
Obs.: Se não for indicado os valores, por padrão, será encaminhado ao campo da
tabela o título do item escolhido pelo usuário.

10.5.7. DBNAVIGATOR (Navegador para Banco de Dados)


Página de Componentes: DataControls — Classe: TDBNAVIGATOR

Possibilita o deslocamento (navegação) entre os "registros" e aplicação das operações (inclusão, deleção e
alteração) num DataSet.

Propriedades Particulares
DataSource Name do DataSource relacionado ao DataSet (Table ou Query) à controlar
Hints Descrição no idioma do usuário para cada botão do componente de navegação
VisibleButtons Apresentar este botão ?
ConfirmDelete Sempre perguntar antes de apagar ?

Propriedade de Evento
OnClick Quando for clicado um dos botões. Pode-se no procedimento de Evento
verificar qual foi o botão clicado. Botões: nbInsert, nbEdit, nbPost,
nbCancel ...

10.5.8. DBLOOKUPCOMBOBOX (Seleção Fechada)


Página de Componentes: DataControls
Classe: TDBLOOKUPCOMBOBOX

Possibilita relacionamento ou conexão com duas Origens de Dados. A Primeira é do DataSet mestre (a
principal) e a Segunda é do DataSet secundário.
Exemplo de um caso: Não queremos que na tabela de funcionários guarde-se o nome do estado pois
criaria um redundância (repetição) de Dados, então na tabela funcionário guardaremos um código
identificador que represente aquele estado e conseqüêntemente teremos uma segunda tabela que terá todos
os estados. Bem, agora temos outro problema pois o usuário não vai querer decorar o código de cada
estado, então teremos que baseados no código do estado achar o nome do estado correspondente e
apresentá-lo. Isso é bem natural! Porém será necessário escrever algumas linhas de código e gasta-se

Página: 91
Delphi 5

um pouco de tempo. Entretanto não será necessário pois existe esse componente que é esse que estamos
estudando que facilitará nossas vidas e tornará o desenvolvimento mais rápido.

Propriedades Particulares
DataSource Name do DataSource relacionado ao DataSet (Table ou Query) Mestre
DataField Name do campo do DataSet Mestre que será o nosso alvo de alteração
KeyField Name do campo do DataSet Secundário que efetivará a união dos DataSets
ListSource Name do DataSource relacionado ao DataSet (Table ou Query) Secundário
ListField Name(s) do(s) campo(s) do DataSet secundário que será (rão) exibido(s).
Obs.: O separador do "names" será o ";" (ponto-e-vírgula).
Ex.: NomeEstado;SiglaUf

10.5.9. DBGRID (Grade para Banco de Dados)


Página de Componentes: DataControls — Classe: TDBGRID

Extensão do componente Grid para vínculo um DataSet, completo.

Propriedades Particulares
DataSource Name do DataSource relacionado ao DataSet (Table ou Query) requerido
Columns Propriedade que permiti tratamento individual para cada coluna da Grade. Por
padrão a Grade terá a quantidade de colunas baseada na quantidade de campos do
DataSet vinculado (ou conectado), isso automaticamente.
Options Propriedade que permiti setar o comportamento da Grade

10.6. Banco de Dados via Código

Nós já vimos alguns recursos, na aula sobre o componente Table, porém aqui temos mais outros para você
trabalhar via código-fonte com o banco de dados:

1. Verificar a quantidade de “registros” em um DataSet: RecordCount


Ex.: VariavelInteira := TableCliente.RecordCount;

2. Desabilitar/Habilitar todos os componentes de controle relacionados:


DisableControls Ex.: TableCliente.DisableControls;
EnableControls Ex.: TableCliente.EnableControls;

3. Verificar se o “Table” está sem dados (Vazio): IsEmpty


Ex.: If TableProduto.IsEmpty Then
ShowMessage (‘Não há Produtos Cadastrados’);

Página: 92
Delphi 5

4. Deletar todos os dados da “Table”: IsEmptyTable


Ex.: TableProduto.EmptyTable;

5. Referir-se a um certo campo da “Table”: FieldByName ( )


Ex.: TableUnidade.FiedByName(‘Sigla_Unidade’).Value;

6. Para ler ou gravar um valor do campo será necessário, quando usar “FieldByName ( )” , a propriedade “AsString”
ou “AsInteger” para converter os conteúdo do campo para o tipo compatível. Observe abaixo outras
propriedades de conversão de conteúdo de campo:
AsFloat, AsDateTime e AsBoolean.

Ex.: MinhaVariavel := TablePedido.FieldByName(‘ValorTotal’).AsFloat;


TablePedido.FieldByName(‘Cod_Pedido’).AsString := MaskEditCodPed.Text;
DataEmissao := TablePedido.FieldByName(‘Data_Emissao’).AsString;

Obs. 1: Você pode usar o método de acesso direto do mesmo modo do anterior, mas não é legível. Fields [ ] .
Ex.: CodPedido := TablePedido.Fields[1].AsString;

Obs. 2: Para ler ou gravar uma informação em um campo que foi adicionado pelo Editor de Campos você pode
usar os métodos de conversão, acima citados, ou a propriedade “Value”.

7. Objeto Tbookmark, marca o ponto que está para volta posteriormente:

1. var PontoMarca : TBookmark; {declarando a variável de marca }. . .


2. PontoMarca := Table1.GetBookmark; {Capturando a posição corrente }. . .
3. Table1.GotoBookmark ( PontoMarca ); { Posicionando na marca informada }. . .
4. Table1.FreeBookmark ( PontoMarca ); {Liberando da memória a marca}

8. Propriedade Eof (Fim de Arquivo) e Bof (Início de Arquivo).

Ex.: If TableProduto.Eof Then


begin
MessageBeep(0);
ShowMessage (‘Chegou no fim da Tabela’);
end
else TableProduto.Next;

10.7. “Com as Mãos na Massa”

Nessa aula iremos trabalhar naqueles formulários que nos foram apresentados na aula anterior, um a um, e
aprenderemos mais recurso de banco de Dados, passo a passo.
Atenção! Em todos os formulários que apresentam dados iremos abrir o(s) DataSet(s) quando o formulário for
apresentado (OnShow) e fechá-los quando o formulário for fechado (OnClose).

10.7.1. Cadastro de Dados Gerais (Departamentos e Cargos)

1 Etapa I:

1. Inserir um novo formulário e que na execução não possa ser redimensionado;


2. Salve a Unit com um nome sugestivo, como "UDGerais.pas";
3. Estando na Unit do novo formulário use o comando: File-Use Unit, indicando a
Unit do Módulo de Dados (DataModule), assim enxergaremos aos componentes de
acesso;
4. No formulário Principal do Projeto coloque a chamada Modal para o novo
formulário;

Página: 93
Delphi 5

PageControl
DBNavigator
Há um DbText aqui será
exibido sempre na
consulta DBEdit que estará em apenas de
leitura quando em consulta
Aqui temos um MaskEdit
que será exibido e usado Um RadioGroup Comum que
apenas na inclusão fará a mudança do
IndexFieldNames do DataSet

Bevel Label que receberá a


quantidade Atual de registros
do DataSet
Etapa II:

1. Quando o usuário solicitar a inclusão você apresentará o MaskEdit do código,


ocultará o DBText do código, desabilitará o RadioGroup e liberará a entrada de
dados do DBEdit do Nome;
2. Quando o usuário cancelar ou gravar, fazer o inverso do item acima;
3. Na inclusão quando o usuário sair do MaskEdit do Código você deverá Pesquisar
com o método SetKey se esse código já existe e proceder adequadamente. Atenção!
Lembre-se que usando "SetKey" você mudará o Estado do DataSet devendo usar
o método "Insert" para poder incluir, se o código não existir;
4. Para se fazer a pesquisa solicitada no item acima a tabela deverá está indexada pelo
código, antes você deverá obrigatoriamente guarda a indexação anterior a inclusão
para depois da inclusão aplicá-la;
5. Quando o usuário usar o RadioGroup para trocar a classificação você deverá indexar o
Dataset alterando a propriedade IndexFieldNames;
6. Na parte abaixo do RadioGroup onde há a informação de quantidade de registro você
deverá usar a propriedade adequada para atualizar a label com essa informação
quando apresentar o formulário e, também, quando fizer inclusões ou exclusões;
7 S ái T l ESC f lá i d áf h

10.7.2. Cadastro de Funcionário (consulta)

2a Etapa I:

1. Usando o Editor de Campos adicione todos os campos da tabela de funcionários (dê


um clique com o botão da direita em cima da TableFunc e escolha a opção "Fields
Editor". Aparecerá um lista flutuante repita a operação sobre essa lista, mas escolha a
opção "Add fields" e pressione o "OK");
2. Faça as Instruções de 1 a 5 do formulário anterior para esse novo formulário;
3. Os DBEdits para o Cargo, Departamento e UF faremos uma abordagem para
aparecer os nomes se baseando nos códigos (CodDepart, CodCargo e CodUF),
respectivos, que possuímos no registro atual do funcionário. Por enquanto apenas
coloque-os nas posições como na imagem abaixo, sem setar as propriedades de Banco
de Dados;
4. Imagens exibidas nos Botões: novo (Filenew.bmp), Alterar (Edit.bmp), Apagar
(Trash.bmp), Buscar(Crdfile2.bmp) e Dependentes (Docstack.bmp) estão no diretório
de images para botões do Delphi (...\Delphi 3\Images\buttons);
5. Todos os componente de entrada de dados, vistos na figura abaixo, são da página Data
Controls.

Chamará o formulário
de Pesquisa

Um DBNavigator Página: 94
Delphi 5

Bem, creio que você já montou uma interface como a da figura acima. Então vamos aos detalhes das Querys
uma para o nome do Cargo e a outra para o nome do Departamento, informações que constam em outras tabelas.
Iremos utilizar o "Query Builder" utilitário que é encontrado na versão Client-Server. Ele vai nos ajudar a construir o
código SQL que é necessário aos componentes do tipo Query.

10.7.3. Query Nome do Cargo

I. Passos para montagem do Código SQL da Query:

1. No "DataModule" coloque uma Query e o seu DataSource para Nome do Cargo;


2. Dê um Clique com o botão da direita e escolha a opção Query Builder;

3. Aparecerá um caixa de diálogo solicitando o ALIAS do Banco de Dados, informe;


4. Agora foi exibida outra caixa de diálogo solicitando as tabelas envolvidas para construção do nosso
código SQL, escolha a tabelas: Cargo e depois a de funcionário, nesta ordem. E feche a caixa de
diálogo;
5. Relacione, arrastando o campo CodCargo e soltando-o no de mesmo nome na outra tabela, no sentido
tabela Cargo para a tabela funcionário, as tabelas envolvidas. Irá aparecer uma linha de conexão
(relacionamento) ligando as duas tabelas;
6. Pronto! Pressione o botão que tem uma imagem de Check para salvar na propriedade SQL da
query. Terminamos o código SQL, vamos indicar o parâmetro agora . . .

II. Passos para indicação do parâmetro da Query:

1. Ainda com o DataSer da Query fechado (Query.Active = False);


2. Dê duplo-clique na propriedade SQL para editar o código SQL:
3. Na cláusula "Where" substitua o nome da tabela "f u n c i o n a r i o . " por dois-pontos ( : ). Com isso
você indicou quem é o parâmetro;
4. Dê duplo-clique na propriedade Params e será exibida um caixa de diálogo para definição do parâmetro;
5. Nessa caixa de diálogo, que já contem o nome do campo que você lá no código SQL indicou com os
dois-pontos que era um parâmetro, informe o tipo desse parâmetro;
6. Vincule o DBEdit Nome do Cargo à query.
7. Pronto, acabou! Agora é só ativar a Query (Query.Active = True) para testar tudo;

10.7.4. Query Sigla da UF & Query Nome do Departamento

Página: 95
Delphi 5

ª Repita os passos: Montagem do Código SQL da Query & Indicação do parâmetro da Query, para as
outras Querys (UF e Nome do Departamento), escolhendo as tabelas e campos correspondentes a informações
necessárias;

Figura - Querys com Parâmetro e seus DataSources

9 Quando a parte de consulta tudo pronto. Agora vamos trabalhar na interface para incluir & alterar. E depois
você poderá colocar as instruções necessárias para os botões de comando (novo, alterar, apagar...).

10.7.5. Cadastro de Funcionário (Incluir & Alterar)

2b Etapa II:
Instruções para Inclusão:

1. Quando o usuário solicitar a inclusão você


apresentará o MaskEdit do código, os
botões Gravar, Abandonar, Ler foto e os
DBLookUpComboBoxs; ocultará o DBText
do código, os DBEdits: Nome do Cargo,
Departamentoos e UF, e os botões que não se
apresentam na figura ao lado e liberará as
entradas de dados do DBEdits e DBMemo;
2. Quando o usuário cancelar ou gravar fazer o
inverso do item acima;
3. Na inclusão quando o usuário sair do
MaskEdit do Código você deverá Pesquisar
com o método SetKey se esse código já
existe e proceder adequadamente;
4. Para Carregar a foto use um componente
OpenPictureDialog para ajudar. E já que
Figura - Interface da inclusão adicionar-mos os campos será possível usar o
método "LoadFromFile ( )" no o campo
DBLoopUpComboBoxs Gráfico para carregar a fotografia.

DBLoopUpComboBox para Estado


Listará: Sigla e Nome dos Estados

DBLoopUpComboBox para Cargo


Listará: Nome dos Cargos Página: 96
Delphi 5

Instruções para Alteração:

1. Idem instruções para Inclusão, porém não deverá ser apresentado o MaskEdit do código, permaneça com o
DBText do código exibido;
2. Tanto na inclusão como na alteração há na interface caixas de combo, na verdade não são caixa de combo
simples são DBLookUpComboBox para diminuir o código-fonte e agilizar o desenvolvimento, basta setá-
los corretamente;
3. Se o usuário usar a Tecla ESC o formulário deverá fechar, mas deverá perguntar antes.

10.7.6. Cadastro de Dependentes

3 Instruções Gerais:

1. Já que a tableDepend está ligada a uma table Mestre


(TableFunc) pelo CodFunc quando for incluído um
dependente automaticamente esse dependente terá o
código do funcionário do registro corrente do DataSet
da TableFunc;
2. Esse cadastro simples é para mostrar à você como
funciona o vínculo de componentes do tipo Table.
3. Personalize os nomes das colunas como na figura ao
lado.

10.7.7. Formulário de Pesquisa

4 Instruções Gerais:

MaskEdit
(Aqui o Evento OnChange acionará a busca)

RadioGroups Comuns
(Aqui o Evento OnClick acionará a busca)

DBGrid ligado a Query de Busca

1. No "DataModule" coloque uma Query para a Busca que não usará parâmetro e um DataSource;
2. Na verdade a busca será montada num código SQL de uma Query. E o seu DataSet será o resultado da nossa
busca ou pesquisa;

Página: 97
Delphi 5

Atenção! Como a propriedade SQL da Query é do Tipo TString, assim também como é a propriedade
Lines do componente Memo, então podemos usar os métodos, como: Clear e Add, para montar em tempo de
execução o nosso código SQL;
3. A montagem do Código SQL e a abertura do DataSet da Query irá acontecer quando o usuário digitar uma ou
algumas letras no MaskEdit ou quando clicar um dos botões de rádio;
4. Quando o usuário dê duplo-clique em um funcionário que está na grade, a janela de procura fechará e
voltaremos ao cadastro de funcionário já posicionados no funcionário escolhido;
5. Quando o usuário fechar a janela de Procura e na grade de resultado da busca só encontrar-se um funcionário.
Será fechada a janela de procura e voltaremos ao cadastro de funcionário posicionados neste funcionário,
automaticamente. Para isto use a propriedade "RecordCount" e veja se é igual a 1.
6. Uma possibilidade de conteúdo da propriedade SQL da Query, em tempo de execução, será:

SELECT Funcionario."CodFunc", Funcionario."NomeFunc", Cargo."NomeCargo", EstadosUF.”Estado”


FROM "Funcionario.DB" Funcionario , "Cargo.db" Cargo, "EstadosUF.DB" EstadosUF
WHERE (Funcionario.CodCargo = Cargo.CodCargo) And (Funcionario.CodUF = EstadosUF.CodUF)
And ( Upper( Funcionario.NomeFunc ) like "Carl%" )
And (Funcionario.Sexo = "M") And (Funcionario.FoiDemitido = False)
ORDER BY Funcionario.NomeFunc

11.Relatório em QuickReport

Os componentes QuickReport são produtos, de uma empresa da Noruega chamada QSD


AS, com total compatibilidade com o Delphi. Assim como você monta as interfaces nos
formulários para o usuário interagir, você montará relatórios que serão exibidos na tela ou
QuickReport listados na impressora. As diferenças são as seguintes: primeiro, quando criamos um
relatório de forma visual nós não vemos os componentes, em tempo de execução, apenas
veremos o resultado por eles gerados; Segundo, Não é necessário DataSource para os componentes
QuickReport enxergarem os dados de um DataSet & terceiro, você não montará o relatório diretamente
em um formulário, mas num componente QuickReport (Pai, proprietário), que será colocado no formulário,
que é muito parecido com o próprio formulário, pois nele colocaremos e posicionaremos outros
componentes QuickReport menores para formar o relatório. Um Relatório QuickReport é na verdade um
LayOut onde as informações irão se posicionar, em tempo de execução, nos devidos lugares indicados por
você.
Nós sabemos que um relatório se compõe de partes como, por exemplo, as enumeradas abaixo:

1. Cabeçalho da Página;
2. Cabeçalho das Colunas;
3. Área de Dados (os detalhes);
4. Rodapé da Página &
5. Área de Sumário

Essas partes, acima citadas, em QuickReport as chamaremos de Bands (Bandas/Faixas) e cada uma será de
um tipo para que aja a identificação, separação e reprodução dessas partes no relatório gerado. Bem,
antes de começarmos, realmente na prática, iremos conhecer os componentes QuickReport e suas
principais propriedades.

11.1. Componentes QR Principais

11.1.1. QUICKREP ( Relatório Rápido, o proprietário )


Página de Componentes: QReport — Classe: TQUICKREPORT

Componente Proprietário (Pai) onde colocaremos as partes (Bands).

Propriedades
DataSet Informar o “Name” da Table ou Query que o relatório irá usar

Página: 98
Delphi 5

Description Propriedade onde podemos colocar um pequeno texto descritivo sobre o relatório
Bands Podemos no próprio componente Relatório indicar as bandas comuns. Não sendo
necessário colocar realmente, a partir da página de componentes, um a um os
componentes do Tipo QRBand no nosso componente QuickReport.
ShowProgress Deseja apresentar a progressão do processo ?

Métodos
Print Imprimi o relatório. Ex.: RelatorioProdutos.Print;
Preview Apresenta a visualização de impressão. Ex.: RelatorioProdutos.Preview;

Comandos do Menu Flutuante


(Dê um clique com o botão da Direita do Mouse no QuickReport)
Zoom In Aumenta a visualização do componente relatório (Mais Zoom)
Zoom Out Diminui a visualização do componente relatório (Menos Zoom)
Preview Executa uma Visualização de Impressão, não sendo necessário executar o projeto
Report Setting Configuração da páginas do nosso relatório (Tamanho, fonte...)

11.1.2. QRBAND ( Componentes Faixas/Parte )


Página de Componentes: QReport — Classe: TQRBAND

Componente que colocamos em um QuickReport para compor o relatório. Nele colocaremos outros
componentes QR que serão apresentados mais adiante.

Propriedade
BandType Informar o Tipo dessa Banda
ForceNewPage Forçar um quebra de página ?
FooterBand “Name” da Band que é o rodapé desse componente Band
HasChild Essa Band tem uma QRChildBand ? (Tem um Band que a acompanha (filha) ? )
ParentBand Se essa Band for do Tipo QRChildBand indica-se o “Name” do “Pai” dela

Os componentes de Tipo Band Específicos iremos estudar no final.

11.2. Componentes QR de conteúdo Constante

11.2.1. QRLABEL ( Texto Estático/constante )


Página de Componentes: QReport — Classe: TQRLABEL

Componente que colocaremos em uma Banda e o usaremos como usamos um componente Label em um
formulário.

Propriedade
Alignment Alinhamento do Título
AlignToBand Alinhar o componente dentro da Banda ?
(Se True, então ele usará a conteúdo da propriedade Alignment, também)
Caption Texto estático que será exibido

11.2.2. QRMEMO ( Memo Estático )


Página de Componentes: QReport — Classe: TQRMEMO

Componente que colocaremos em uma Banda e o usaremos como usamos um componente Memo em um
formulário.

Página: 99
Delphi 5

11.2.3. QRIMAGE ( Imagem constante )


Página de Componentes: QReport — Classe: TQRIMAGE

Componente que colocaremos em uma Banda e o usaremos como usamos um componente Image em um
formulário.

11.2.4. QRSHAPE ( Formas )


Página de Componentes: QReport — Classe: TQRSHAPE

Componente que colocaremos em uma Banda e o usaremos para melhorar a apresentação.

Propriedade
Shape Possibilita escolher entre as formas disponíveis (linha vertical, retângulo ... )
Pen Possibilita: mudar a espessura (With) e a Cor da Linha (Color)

11.3. Componentes QR Especiais

11.3.1. QRSYSDATA ( Informação do Sistema)


Página de Componentes: QReport — Classe: TQRSYSDATA

Componente que colocaremos em uma Banda para informar: data, hora, número da página ... .

Propriedade
Data Tipo de informação (apenas data, apenas hora, número da página ... ) que será
apresentada.

11.3.2. QREXPR ( Construção de Expressão)


Página de Componentes: QReport — Classe: TQREXPR

Componente que colocaremos em uma Banda para apresentar o resultado de uma expressão nele armazenado.

Propriedade
Expression Expressão que será executada na geração do relatório.
(Ex.1: Copy(Company,1,1) ou Ex.2: ‘Pedido nr.: ’ + CodPed
Mask Mascara de apresentação da informação
Master “Name” do QuickReport que possui o Daztaset para atualização dessa expressão

11.4. Componentes QR de Banco de Dados

Propriedades Comuns aos Componentes QRDB


DataSet Name do DataSet (Table ou Query) requerido
DataField Name do campo do DataSet (Table ou Query) ao qual se quer ter acesso

Página: 100
Delphi 5

11.4.1. QRDBTEXT ( Acessa conteúdo não-Gráfico)


Página de Componentes: QReport — Classe: TQRDBTEXT

Componente que colocaremos em uma Banda de Detelhes ou Sub-detalhes para apresentar o conteúdo de um
campo tipo: alfanumérico, numérico ou memo.

11.4.2. QRDBIMAGE ( Acessa conteúdo Gráfico)


Página de Componentes: QReport — Classe: TQRDBIMAGE

Componente que colocaremos em uma Banda de Detelhes ou Sub-detalhes para apresentar o conteúdo de um
campo tipo imagem.

11.5. Bands Específicos

11.5.1. QRGROUP (Banda para Formação de Grupo)


Página de Componentes: QReport — Classe: TQRGROUP

Componente Banda específico que faz quebras (grupo) no relatório.

Propriedade
Expression O grupo é quebrado toda vez que o resultado da expressão mudar
ForceNewPage Forçar um quebra de página ?
FooterBand “Name” da Band que é o rodapé desse componente Band de Grupo

11.5.2. QRCHILDBAND (Banda Filha para Acompanhamento)


Página de Componentes: QReport — Classe: TQRCHILDBAND

Componente Banda que fica vinculada a outra banda “Pai”.

Propriedade
ParentBand “Name” do “Pai” (Parent)

11.5.3. QRSUBDETAIL (Banda Filha para Acompanhamento)


Página de Componentes: QReport — Classe: TQRSUBDETAIL

Componente Banda que fica vinculada a um sub-grupo.

Propriedade
Bands Para indicar se há bandas rodapé e cabeçalho

11.6. Composições de Relatórios

Bandas do Relatório em Grupo:


1. PageHeader (Cabeçalho da Página);
2. Componente QRGroup

Página: 101
Delphi 5

com um componente de expressão com a expressão de Quebra;


3. ColumnHeader (Cabeçalho das Colunas);
4. Detail (Área de Dados (detalhes));
5. Summary (Área de Sumário) e
6. PageFooter (Rodapé da Página).

Bandas do Relatório em Mestre/Detalhes:


1. Bands da “Listagem Simples”;
2. Componente QRSubDetail , FooterBand =”RodapeGroup1”;
3. Componente QRBand,
com BandType=rbGroupFooter, HasChild = True e Name=”RodapeGroup1”;
4. Componente QRChildBand, c/ ParentBand = ” RodapeGroup1”

11.7. Os Relatórios do Nosso Aplicativo

Pelo menu do nosso Aplicativo teremos apenas três relatórios: um para funcionários, um para departamentos e
outro para cargos. Decidir que os três serão, cada um, do tipo lista e que faremos para os funcionários um outro
relatório, do tipo mestre-detalhes, que apresentará para cada funcionário os seus dependentes. Iremos seguir uma
abordagem que é a seguinte: para cada relatório lista teremos um formulário com “name” e “caption” sugestivos. E
nesses formulários serão usados no sistema para o usuário escolher a ordenação (indexação) e se quer visualizar a
impressão ou imprimir. O quarto relatório (mestre-detalhes do funcionário) ficará dividindo o mesmo formulário e
nesse formulário o usuário deverá escolher se o relatório será o simples (lista) ou o mestre-detalhes, além das opções já
citadas anteriormente.

Figura - Visão do formulário e componentes do relatório de Cargos


11.7.1. Relatório de Cargos
Passos para implementação do relatório no nosso projeto:

1. Insira um novo formulário, coloque “name” e “caption” sugestivos;


2. Salve com o nome “URelCargos.pas” na pasta do nosso projeto;
3. Já que temos o nome definitivo da unit em desenvolvimento podemos fazer os vínculos de uso de unit’s
(unidades). Usando File-Use Unit faça o seguinte:
3.1. Estando na unit do relatório indique o uso da unit do DataModule (módulo de dados);
3.2. Em seguida vá para a unit do formulário principal e indique que irá usar a unit do relatório;
4. No formulário do relatório coloque um componente relatório QuickReport para montarmos o nosso relatório;
5. Sete as seguintes propriedades do QuickReport:
5.1. “DataSet” terá o “name” da Table principal do relatório;
5.2. “Bands” solicite uso das seguintes: Título, Cabeçalho dos campos, detalhes e rodapé da página;
6. Coloque os elementos necessários ao relatório e para testar abra a tabela antes de ver o “Preview”;
7. Coloque a chamada Modal no item do menu respectivo do formulário principal;
8. Monte a interface como na figura abaixo e coloque as instruções necessárias.

Página: 102
Delphi 5

Em tempo de projeto esconda as barras


de rolamento do formulário;
No evento de criação do formulário
sete a altura e a largura de forma que não
apareça o componente QuickReponte na
execução e que fique parecida com a figura
ao lado.
Figura - Interface para o relatório de cargos

11.7.2. Relatório de Departamentos


Passos para implementação do relatório no nosso projeto:

1. Insira um novo formulário, coloque “name” e “caption” sugestivos;


2. Salve com o nome “URelDepart.pas” na pasta do nosso projeto;
3. Já que temos o nome definitivo da unit em desenvolvimento podemos fazer os vínculos de uso de unit’s
(unidades). Usando File-Use Unit faça o seguinte:
3.1. Estando na unit do relatório indique o uso da unit do DataModule (módulo de dados);
3.2. Em seguida vá para a unit do formulário principal e indique que irá usar a unit do relatório;
4. Já que temos o relatório de Cargos pronto copie ele e cole no formulário do rel. de Departamentos;
5. Altere as seguintes propriedades do QuickReport:
5.1. “DataSet” terá o “name” da Table principal do relatório;
6. Altere os elementos necessários no relatório e para testar abra a tabela antes de ver o “Preview”;
7. Coloque a chamada Modal no item do menu respectivo do formulário principal;
8. Quanto a interface com o usuário copie os componentes do formulário de Cargos e cole no formulário de
Departamentos.
9. Pronto! Só é colocar, agora, as instruções nos devidos procedimentos de evento e acabou.

11.7.3. Relatórios de funcionários


— Relatório Lista —

Passos para implementação do relatório no nosso projeto:

1. Faça os passos que você executou anteriormente, para montar o relatório simples de departamentos, para montar o
relatório, simples em lista, dos funcionários;
2. Verticalmente aumente a banda dos detalhes e além dos campos de código e nome do funcionário coloque os
seguintes campos: foto, sexo, endereço, data de nascimento e nota, como na interface abaixo:

Figura - Visão da composição do relatório tipo lista para funcionários

Página: 103

Figura - Interface para os relatórios de funcionários


Delphi 5

— Relatório Mestre-Detalhes —

Passos para implementação do relatório no nosso projeto:

1. No mesmo formulário do relatório de lista para os funcionário coloque um componente QuickReport para
montarmos o nosso relatório mestre-detalhes;
2. Sete as seguintes propriedades do QuickReport:
2.1. “DataSet” terá o “name” da Table principal (TableFunc) do relatório;
2.2. “Bands” solicite uso das seguintes: Título, Cabeçalho dos campos e detalhes, por enquanto;
3. Coloque a partir da página de componentes uma Banda SubDetail, sete-a da seguinte forma:
3.1. “DataSet” terá o “name” da Table de detalhes (TableDepend);
4. Coloque a partir da página de componentes uma banda e sete-a como abaixo:
4.1. Na propriedade BandType indique-a como “rbGroupFooter”
4.2. O seu “name” como “GroupFooter1”;
4.3. A propriedade “HasChild” = True;
5. Selecione a Banda Child que apareceu e altere um pouco a altura dela, assim ela dará um espaço entre os grupos;
6. Volte a Banda SubDetail e sete-a da seguinte forma:
6.1. “FooterBand” = “GroupFooter1” (indicando que o rodapé para totais do grupo é essa banda);
7. Na propriedade “Bands” do QuickReport solicite uso da Banda de rodapé de página;
8. Na banda de Rodapé do grupo (GroupFooter1) você deverá colocar uma expressão para contar a quantidade de
dependentes que foram listados no grupo, como você vê na figura abaixo;
9. Coloque os elementos necessários ao relatório, como na figura abaixo, e para testar abra as tabelas antes de ver o
“Preview”.

Detail Sub-Detail GroupFooter

Figura - Aspecto do relatório Mestre-detalhes de funcionários

12.Entregando a aplicação
Uma das etapas mais importantes no desenvolvimento de qualquer software é sua entrega e instalação na
máquina de nossos clientes. Em diversas linguagens de programação essa etapa tem tornado-se uma
verdadeira dor de cabeça para os desenvolvedores que, além de ter tido todo o trabalho de desenvolvimento
ainda tem que se preocupar com a configuração da máquina na qual seu software está sendo instalado.

Página: 104
Delphi 5

Na versão 1.0 do Delphi essa preocupação também existia. Apesar do desenvolvedor contar com
características que facilitavam a instalação de seus produtos como, por exemplo, a utilização de um alias
no desenvolvimento de aplicativos para a área de banco de dados, o processo de instalação ainda era
trabalhoso. Como parte integrante do Delphi 1.0 estavam incluídos os discos de instalação do DBE, caso o
aplicativo sendo instalado fizesse acesso à um banco de dados, e do runtime do ReportSmith, caso o
aplicativo gerasse relatórios desenvolvidos por ele. Apesar da instalação e configuração desses produtos ser
feita de forma bastante simplificada, ainda era um trabalho a mais que deveria ser realizado pelo
desenvolvedor na hora da instalação de seu produto na máquina de seu cliente.
Com lançamento do Windows 95, um novo padrão de instalação de software, através do uso de entradas
em registros do sistema operacional, passou a ser utilizado permitindo um melhor gerenciamento dos
produtos correntemente instalados, facilitando o processo de desinstalação.
O InstallShield Express®, de agora em diante chamado apenas de InstallShield, foi desenvolvido pela
Stirling Technologies com o objetivo de proporcionar aos desenvolvedores de software uma ferramenta
capaz de facilitar o processo de distribuição de seus produtos. Desde a primeira versão do Delphi para o
ambiente Windows95, o Delphi 2.0, a Borland já forneceu juntamente com seu produto uma cópia do
InstallShield para facilitar ainda mais seus usuários. Passaremos agora a realizar um estudo sobre essa
ferramenta, em sua versão lançada para acompanhar o Delphi 5.0, o InstallShield Express Delphi Edition,
versão 1.11a.

12.1. O InstallShield Express


O InstallShield Express é o programa mais utilizado para a criação de instalações de produtos ente
desenvolvedores, não só de pequenas mas de grandes empresas. Em sua versão distribuída juntamente com
o Delphi 5.0, o desenvolvedor poderá contar com todo o suporte às diretrizes para instalações de software
para o sistema operacional Windows95, tais como entrada de registradores automática e geração de
programas de desinstalação.
É importante observar que, nessa versão do InstallShield, distribuída com o Delphi 5.0, apenas é suportado
o desenvolvimento de instalações para o ambiente de 32 bits, não sendo possível, portanto, a instalação
desses produtos no Windows 3.11 ou no próprio MS-DOS.

12.2. Instalando o InstallShield


O processo de instalação do InstallShield é bastante simples. Ao colocarmos o CD de instalação do Delphi
5.0 no equipamento no qual desejamos instalar o InstallShield,
aparecerá na tela uma janela solicitando a escolha de qual aplicativo
gostaríamos de instalar. Devemos escolher a opção InstallShield
Express. A situação descrita anteriormente é ilustrada na figura ao
lado.
É dado início ao processo de instalação através da utilização do
InstallShield Wizard, tão comum na maioria dos softwares
desenvolvidos para o Windows95. A partir deste ponto serão
solicitadas apenas 3 informações: O nome do usuário e da companhia
na qual o InstallShield está sendo instalado e a localização onde os
arquivos do InstallShield deverão ser colocados.
Ao término da instalação, aparecerá na tela uma janela informando o usuário desse fato. Além disso,
existirá a opção de executar o InstallShield. Para que isso seja possível, basta que o assinalarmos o
checkbox existente nessa janela e clicarmos o botão de finalizar.

12.3. Executando o InstallShield pela primeira vez


Após o término da instalação, o InstallShield já encontra-se pronto para ser executado e começarmos a
gerar os nossos primeiros discos de instalação. Quando executamos o InstallShield pela primeira vez, é
exibida a caixa de diálogo mostrada ao lado.
Temos a opção de escolher duas opções: Abrir um
projeto de instalação existente ou Criar um novo
projeto de instalação. Essa caixa de diálogo será

Página: 105
Delphi 5

exibida toda vez que o InstallShield for inicializado a menos que a opção Don’t display this screen again
seja assinalada. Uma vez que tenhamos criado o nosso primeiro projeto a opção de abrir o nosso último
projeto ficará disponível para seleção. Iniciemos, então, escolhendo a opção para Criar um novo projeto de
instalação e, em seguida, pressionemos o botão OK.
Após clicarmos o botão OK, uma seqüência de caixas de diálogo é apresentada para que possamos criar um
projeto de instalação de software. A primeira dessas
caixas de diálogo é mostrada ao lado. Essa é utilizada
para identificar o projeto que está sendo
desenvolvido. Devemos, através do Directory List
Box selecionar o diretório no qual serão armazenados
os arquivos a serem criados para o novo projeto. Caso
ainda não exista o subdiretório no qual desejamos
colocar o nosso projeto, poderemos especificá-lo no
New Subdirectory Edit Box. Na figura acima, caso
desejássemos colocar o nosso projeto num diretório
chamado ProjectX localizado no diretório IS Express
Delphi Edition, bastaríamos colocar ProjectX no Subdiectory Edi Box.
Devemos, ainda, dar um nome ao nosso projeto. Para isso, basta colocarmos no Project Name Edit Box o
nome desejado. Convencionalmente, é dado ao projeto o nome da aplicação que foi desenvolvida. Observe
que o nome que o nome dado ao projeto é automaticamente colocado no texto acima do Directory List Box,
com a extensão iwz (do inglês InstallShield Wizard).
Existe ainda a possibilidade da criação de uma instalação múltipla. Esse tipo de instalação é bastante
comum em aplicações comerciais onde é dada ao usuário a oportunidade de escolher entre vários tipos de
instalação. Com a versão do InstallShield fornecida com o Delphi 5.0 é possível escolher entre 3 tipos de
instalação:
• Típica
Normalmente uma instalação completa, incluindo todos os componentes do sistema em questão.
• Compacta
Normalmente composta apenas por aqueles componentes necessários à execução do sistema
• Customizada
Permite ao usuário escolher quais os componentes a serem instalados
Para que isso seja possível devemos assinalar a opção Include a Custom Setup Type. Por hora vamos
começar com o desenvolvimento de uma instalação simples, não assinalando, portanto, essa opção. No
nosso exemplo, criaremos um projeto chamado Calc a ser armazenado no diretório ProjectX como
mostrado na figura acima. Podemos dar continuidade ao desenvolvimento de nosso projeto pressionando o
botão Create. Pronto, agora já possuímos um esqueleto para o desenvolvimento de nosso projeto de
instalação, restando apenas “preencher os espaços em branco”.
Passamos a partir de agora a mostrar cada um dos passos a serem preenchidos para que possamos, enfim,
obter os discos de instalação de nosso produto, são eles:
• Set the Visual Design
Fornece informações básicas a respeito da aplicação.
• Select InstallShield Objects for Delphi
Utilizado para fornecer informações a respeito de objetos do Delphi tais como o BDE a serem
utilizados pela aplicação
• Specify Components and Files
Fornece informações a respeito dos arquivos a serem instalados, bem como os diversos tipos de
instalação existentes
• Select User Interface Components
Informa quais as caixas de diálogo que serão exibidas no processo de instalação

Página: 106
Delphi 5

• Make Registry Changes


Utilizado para informar quais alterações serão efetuadas nos registros do sistema
• Specify Folders and Icons
Fornece informações a respeito dos ícones e das pastas que serão utilizadas na instalação
• Run Disk Builder
Cria as imagens dos discos de instalação baseadas nas informações fornecidas nos passos anteriores
• Test the Installation
Testa o processo de instalação
• Create Distribution Media
Cria os discos de instalação
A janela obtida após o clique do botão Create é mostrada
ao lado.Nessa janela estão dispostos todos os passos
apresentados anteriormente, bem como suas subdivisões.
Antes de começarmos nossa explicação sobre cada um dos
passos a serem seguidos até a geração final dos discos de
instalação gerados pelo InstallShield vamos falar um
pouco sobre as opções presentes na janela exibida acima.

12.4. A janela principal


A janela principal do InstallShield é composta por uma série de menus, um toolbar, um statusbar e,
opcionalmente, um projeto. Os menus existentes na janela principal do InstallShield são apesentados a
seguir:
• File
Contém opções tais como Abrir e Salvar além de uma lista dos projetos usados mais recentemente
• View
Permite configurar a exibição ou não da toolbar e da statusbar
• Checklist
Fornece uma maneira alternativa de se acessar os diversos passos para a criação dos discos de
instalação do projeto corrente
• Help
Oferece acesso à ajuda do InstallShield
Algumas das opções fornecidas através dos menus do InstallShield também estão disponíveis através do
toolbar mostrado a seguir.

Save Test Run Explorer About


New

Build Copy To Floppy

Help
Open

Página: 107
Delphi 5

• New
Abre a caixa de diálogo Abrir Novo Projeto
• Open
Abre a caixa de diálogo Abrir
• Save
Salva o projeto corrente com o nome e localização atual
• Build
Abre a caixa de diálogo do Disk Builder
• Test Run
Executa um teste de execução do projeto corrente
• Copy To Floppy
Abre a caixa de diálogo Copy to Floppy
• Explorer
Executa o Windows Explorer
• About
Abre a caixa de diálogo About
• Help
Executa a ajuda sensível ao contexto. Ao clicar nesse botão, o ponteiro do mouse muda de formato.
Clique sobre um elemento qualquer para obter ajuda específica para esse elemento.
É importante observar que, da mesma maneira como acontece com o Delphi, o InstallShield é capaz de
trabalhar apenas com um único projeto por vez. Caso esteja-se trabalhando em um projeto e escolha-se a
opção Abrir e um outro projeto seja selecionado, o projeto corrente será fechado automaticamente para que
o outro seja aberto. O mesmo acontece caso um novo projeto seja criado.
Com o objetivo de fornecer alguma ajuda na hora de selecionar um dos botões mostrados acima, existe um
statusbar na parte inferior
da janela principal,
mostrado ao lado.
A medida em que o se passa o ponteiro do mouse por sobre os botões do speedbar, uma ajuda rápida sobre
a funcionalidade desse botão é exibia no statusbar.
Além dos botões contidos no speedbar e do statusbar, a janela principal do InstallShield é composta por
uma janela contendo um checklist das opções existentes, mencionadas anteriormente, para a criação de uma
instalação.
O checklist mostrado ao lado serve como um
Item
guia para indicar as opções a serem preenchidas
Concluído
para a geração dos discos de instalação de um
software. Nem todos os passos mostrados no
checklist são de preenchimento obrigatório,
Passos dependendo da instalação sendo criada, porém
são exibidos como forma de referência para
Itens futuras instalações.
Cada um dos passos listados no checklist é
composto por um ou mais itens que podem ser
configurados. Para que isso seja possível basta-
se clicar com o mouse por sobre o botão que está do lado esquerdo do item que se deseja configurar. Após
o clique, será exibida a caixa de diálogo correspondente para a configuração do item selecionado. Existe
ainda a possibilidade de se selecionar qualquer um dos passos do checklist através das opções do menu

Página: 108
Delphi 5

Checklist. Após a conclusão de cada item do checklist um marcador de conclusão aparecerá do lado
esquerdo do item concluído. Veremos adiante a funcionalidade de cada um desses itens.
Existe ainda a opção de ir para uma segunda página, clicando-se com o mouse por sobre a pequena “dobra”
de página existente no canto inferior direito do checklist. Essa segunda página mostra algumas informações
de como entrar em contato com os desenvolvedores do InstallShield para enviar comentários, sugestões e
problemas encontrados com o produto.

12.5. Ajustando o Visual Design


Vamos a partir de agora começar, realmente, a desenvolver e criar a instalação de nosso produto. A
primeira coisa a fazer é fornecer algumas informações básicas a respeito do software que vamos instalar.
Para isso, começaremos preenchendo as informações solicitadas no primeiro passo do checklist mostrado
acima. Ao clicarmos no item Application Information a caixa de diálogo mostrada a seguir é exibida.
A caixa de diálogo mostrada ao lado é utilizada pelo InstallShield para
obter informações que serão utilizadas internamente no processo de
instalação. Porém, algumas dessas informações são de preenchimento
obrigatório pois são utilizadas no para atualizar os registros do sistema
operacional Windows95, são elas: o nome da aplicação, a verão do
produto e o nome da companhia. Essas informações já vêm preenchidas
com valores default, podendo ser alterados mas não devem ser deixados
em branco. Caso isso aconteça, o InstallShield não será capaz, por
exemplo, de incluir o registro de desinstalação do produto durante sua
instalação. Nesse item existem 5 campos a serem preenchidos como
mostrado a seguir:

Application Name
Contém o nome da aplicação. O nome da aplicação pode conter, no máximo, 80 caracteres e é preenchido,
por default, com o nome do projeto que está sendo criado no InstallShield
Application Executable
Indica o arquivo executável primário da aplicação. A escolha do arquivo executável pode ser feita através
do botão browse. Após a seleção desse arquivo, é apresentado, na caixa de texto, a localização desse
arquivo, por exemplo, da seguinte forma:
[Program Files]\Controle.exe

O especificador [Program Files] é utilizado pelo InstallShield para identificar um grupo dentro do processo
de instalação, ou seja, um diretório selecionado pelo usuário no momento da instalação. Essa noção ficará
bem mais clara adiante, quando mostrarmos como criar Grupos de Componentes para uma instalação
Version
Indica qual a versão do produto a ser instalado
Company
Indica o nome da companhia desenvolvedora do produto
Default Destination Directory
Especifica o diretório default para a instalação do produto. O padrão a ser seguido é o seguinte:
<ProgramFilesDir>\<Companhia>\<Aplicação>

O especificador <ProgramFilesDir> contém o diretório default de instalação no computador onde o


aplicativo será instalado, em geral, Arquivos de Programas no Windows95. Companhia e Aplicação são
substituídas pelo nome da companhia e da aplicação respectivamente. Esse será o diretório exibido para o
usuário no momento da instalação porém, nada impede que o diretório no qual o aplicativo será instalado
seja alterado no momento da instalação.

Página: 109
Delphi 5

Existem diversos outros especificadores que podem ser utilizados no InstallShield para customizar ainda
mais todo o processo de instalação, para uma explanação mais detalhada desses especificadores verificar na
ajuda do InstallShield, sob o título de Express Directory Specifiers.

Após o preenchimento dos campos acima temos 3 opções a seguir: clicar o botão OK, confirmando os
valores colocados (o sinal de verificação aparecerá do lado esquedo do item Applicaion Information), clicar
o botão Cancel, cancelando a operação ou, por fim, selecionar uma das tabs restantes para continuar
preenchendo as informações para a instalação.
Vamos clicar no segundo tab, chamado de Main Window, existente na caixa de diálogo Set the Visual
Design para continuarmos a fornecer informação sobre a nossa instalação.

Na aba Main Window mostrada acima, são solicitadas informações a


respeito da aparência da janela principal do programa de instalação que
está sendo desenvolvido. Essas informações são descritas mais
detalhadamente a seguir:

Main Title
Existem duas opções a serem seguidas neste ponto, a escolha de um
texto, com no máximo 80 caracteres, ou a escolha de um bitmap, com no máximo 16 cores, para ser
colocado como título na janela principal do aplicativo de instalação. Por default, a opção selecionada é a de
colocação de um texto, porém podemos selecionar um bitmap mudando o radio button para a opção de
bimap. Para escolhermos qual bitmap a ser exibido, podemos utilizar o botão Browse. Um detalhe a ser
observado é que, para selecionarmos a opção de bitmap, não basta apenas clicarmos no botão Browse,
devemos ainda escolher o radio button correspondente para que essa seja a opção escolhida. Caso
contrário, será exibido como título a localização (path) do arquivo selecionado. O título, ou bitmap,
selecionado será exibido no canto superior esquerdo da janela.
Logo Bitmap
Essa opção é utilizada para escolher um bitmap como, por exemplo, a logomarca da empresa que
desenvolveu o sistema a ser instalado, na janela principal da instalação. O processo de seleção desse bitmap
é exatamente igual ao mencionado anteriormente.
Uma vez selecionado qual o bitmap a ser utilizado, deverá ser feita a escolha da posição na qual ele será
colocado na janela principal. Existem três posições possíveis: centralizada, canto superior esquerdo e canto
superior direito. Caso seja escolhido o canto superior esquerdo, o bitmap para a logomarca será sobreposto
pelo bitmap do título da janela caso este exista.
Background Color
Aqui temos a opção de escolher a cor que será utilizada como cor de fundo para a janela principal do
aplicativo de instalação. O default é Dithered Blue, o azul utilizado na maioria dos programas de instalação
existentes.

A seguir temos um exemplo da janela principal de um programa de instalação.

Resta-nos agora o último tab da caixa de diálogo Set the Visual


Design, a tab Features, mostrada a seguir.
Temos aqui a opção de incluir
em nosso programa de
instalação a opção para
desinstalar o programa que
estiver sendo instalado. É
recomendável que essa opção

Página: 110
Delphi 5

eseja marcada. Dessa forma, as modificações criadas automaticamente pelo InstallShield, por exemplo, nos
registrados do sistema operacional, podem ser feitas automaticamente por um programa de desinstalação.
Terminamos a primeira etapa de configuração de nosso programa de instalação, ajustando pequenas
“propriedades” que serão utilizadas pelo InstallShield para gerar o início da instalação do produto em
questão. Até agora, todas as informações fornecidas não são influenciadas sobre qual a plataforma de
desenvolvimento utilizada, se Delphi ou qualquer outra porém, a partir de agora, vamos começar a ver
detalhes que facilitam a instalação de produtos desenvolvidos com o Delphi.

12.6. Selecionando objetos do InstallShield para o Delphi


A utilização do InstallShield para criar instalações para aplicativos desenvolvidos em outras linguagens,
como mencionado anteriormente, pode ser feita desde que não seja utilizada nenhuma opção desta etapa
que apresentamos nessa seção. Aqui, passaremos a referenciar objetos existentes no ambiente de
desenvolvimento do Delphi para que o InstallShield possa gerar, da melhor forma possível, esses
programas de instalação.
A caixa de diálogo Select InstallShield Objects for Delphi é composta por duas tabs, a primeira delas
mostrada a seguir.

Temos aqui a opção de escolher quais os objetos


a serem selecionados para serem incluídos no
processo de instalação. Caso nenhum desses
objetos seja necessário ao software que será
instalado, nenhuma desses objetos deve ser
assinalado. No caso da utilização de algum
desses objetos, o objeto necessário deverá ser
assinalado. Ao assinalarmos qualquer uma
dessas opções, será exibida automaticamente
uma nova caixa de diálogo para que o objeto
selecionado possa ser corretamente configurado.
O botão Settings poderá ser utilizado
posteriormente para alterar essa configuração,
tornando-se habilitado. Os objetos mostrados na
figura anterior são utilizados, normalmente, com
aplicações que façam acesso à Banco de Dados, para um software que não utilize o BDE ou SQL Links,
esses objetos devem ser ignorados, passando para a etapa seguinte no processo de geração do aplicativo de
instalação.
Caso o objeto BDE (Borland Database Engine) seja selecionado, a caixa de diálogo mostrada a seguir será
exibida automaticamente.
A caixa de diálogo BDE Installation Type é exibida para que
seja feita a escolha de qual tipo de instalação do BDE que
deverá ser feita na máquina do cliente. Caso seja feita a
escolha por uma instalação parcial, é solicitados quais os
Drivers e Query Engines que serão utilizados no processo de
instalação. Existe, contudo, uma lista mínima de arquivos a
serem incluídos na instalação, o que pode causar alguns
problemas caso algum desses arquivos não seja instalado. Para
uma lista completa desses arquivos consultar o tópico da ajuda
Partial BDE Installation. Devido a esses fatores, é
recomendada a escolha de uma instalação completa para evitar
qualquer problema. Uma vez selecionado o tipo de instalação do BDE a ser realizada, o botão Avançar, ou
Next, pode ser clicado.
O clique no botão Avançar dá início a uma sequência de 4 passos para permitir a configuração do BDE que
será instalado na máquina do cliente. O primeiro desses passos diz respeito a criação de todos os alises
utilizados pela aplicação sendo instalada. Mostramos a seguir a caixa de diálogo para a criação de aliases.

Página: 111
Delphi 5

Temos nessa caixa de diálogo a opção de criar os aliases que serão utilizados na aplicação, bem como
remover aqueles que porventura tenham sido colocados por engano. Para que possamos criar um alias
devemos clicar no botão New. Com isso, é exibida a caixa de diálogo a seguir, solicitando o fornecimento
do nome do alias a ser criado.
Podemos colocar o nome do alias que desejamos criar e em
seguida, clicar o botão OK. Devemos observar que, os nomes
dos aliases que iremos criar na instalação devem ser os
mesmos que estão sendo utilizados pelo programa sendo
instalado.
Após clicarmos
no botão OK, o alias é colocado no listbox da caixa de diálogo
mostrada anteriormente. Uma vez que todos os aliases que serão utilizados na aplicação sejam criados
podemos passar ao passo seguinte da configuração do BDE clicando no botão Next.
A caixa de diálogo seguinte permite especificar se o arquivo de configuração do BDE deve ser salvo de tal
forma que tanto aplicações de 32 bits quanto as de 16 bits possam acessá-lo. Para que isso seja possível, o
checkbox mostrado deve ser assinalado. A seguir mostramos a caixa de diálogo citada anteriormente.
Caso o checkbox não seja assinalado, apenas a versão de 32 bits será salvo. Podemos clicar no botão
Avançar para continuar a configuração do BDE. A caixa de diálogo responsável pelo terceiro passo no
processo de configuração do BDE é mostrada a seguir.
A caixa de diálogo mostrada acima permite a configuração de
cada um dos aliases a ser criado no processo de instalação.
Para isso, devemos escolher no combobox Alias Name o alias
a ser configurado. Para cada um desses aliases, deveremos
especificar sua localização, bem como o driver que será
utilizado por ele.
Na caixa de texto
Path, devemos colocar o caminho a ser utilizado para o
armazenamento das tabelas pertencentes ao alias em questão.
Podemos utilizar como parte do caminho, os especificadores
definidos no InstallShield. No exemplo acima, foi utilizado o especificador <INSTALLDIR> para
identificar o diretório de instalação no qual o aplicativo foi instalado.
Além da definição do diretório no qual os dados serão colocados, é necessária também a especificação de
qual driver será utilizado no acesso a esses dados. Os drivers disponíveis são listados no combobox Type.
Tanto o caminho quanto o tipo de driver são de preenchimento obrigatório, não devendo, portanto, serem
deixados em branco.
Uma vez preenchidas todas as informações com relação aos aliases a serem utilizados pela aplicação,
podemos clicar no botão Avançar para chegarmos à última caixa de diálogo de configuração do BDE,
mostrada a seguir.
A caixa de diálogo mostrada acima finaliza o processo de configuração do BDE a ser instalado na máquina
do cliente. Para que essas configurações sejam utilizadas devemos clicar o botão OK. Para mudarmos
posteriormente, qualquer uma dessas configurações, devemos clicar o botão Settings na caixa de diálogo
Select InstallShield Components for Delphi.
O segundo componente do InstallShield para o Delphi que
pode ser selecionado é o SQL Links. Caso o programa a ser
instalado faça uso de qualquer um dos links existentes,
devemos assinalar essa opção. Um detalhe importante a ser
observado é que, para se utilizar o componente SQL Links,
devemos também utilizar o componente BDE mencionado
anteriormente.
Após assinalarmos a opção para o componente do SQL Links, a
seguinte caixa de diálogo de configuração será exibida
automaticamente.
Através da caixa de diálogo mostrada acima, podemos escolher

Página: 112
Delphi 5

quais os drivers que devem ser instalados juntamente com o aplicativo. Por default todos os drivers estão
assinalados.
O InstallShield, no processo de instalação, instalará todos os arquivos necessários e fará todas as alterações
nos registradores do sistema operacional para os drivers assinalados para a instalação. Devemos lembrar
que, a escolha de drivers além do necessário não acarreta em problema algum para a instalação, o único
aspecto negativo está no fato da instalação e consequente diminuição do espaço livre em disco, com
arquivos desnecessários.
Uma vez configurados os componentes do InstallShield para o Delphi em seus aspectos gerais podemos
avançar para a aba Advanced. Devemos observar que o conteúdo dessa aba dependerá das opções
selecionadas na aba General. A seguir mostramos a aba Advanced.
Como pode ser observado na figura acima, a aba Advanced tem a
finalidade de exibir informações a respeito dos arquivos que, de
acordo com as opções feitas na aba General, foram selecionados
para instalação. Nesse ponto não podemos adicionar ou remover
elementos. Para adicionarmos elementos, devemos fazê-lo na aba
General, enquanto que a remoção de arquivos em particular poderá
ser feita na caixa de diálogo Groups and Files que será vista a
seguir. Para cada arquivo selecionado são exibidas informações a
respeito da data, tamanho e versão do arquivo.
Uma vez definidos e configurados os componentes que serão
utilizados pelo InstallShield no processo de instalação, estamos prontos para seguir adiante. Podemos clicar
no botão OK e passar para o próximo passo no processo de criação de nossa instalação descrito a seguir.

12.7. Especificando componentes e arquivos

Neste ponto do processo de desenvolvimento de nossa instalação estamos prontos para especificar quais os
arquivos do software a ser instalados que serão inclusos no processo de instalação, bem como a sua
localização na máquina do cliente. Para isso devemos escolher a opção Groups and Files localizada na
opção Specify Components and Files no checklist da instalação.

O processo de configuração dos arquivos a serem instalados pelo InstallShield está baseado no conceito de
grupos. A idéia de grupo é bastante simples de ser entendida e utilizada, principalmente para instalações
que não envolvam múltiplas configurações como é o caso da qual estamos correntemente desenvolvendo.
Um grupo pode ser visto como uma coleção de arquivos relacionados como, por exemplo, os arquivos de
banco de dados de uma aplicação. A cada grupo é associada uma localização (path) que será utilizado no
momento da instalação dos arquivos pertencentes a esses grupos na máquina do cliente.
A criação de grupos, a especificação dos arquivos pertencentes a eles e a determinação de seu local de
instalação dos grupos associados a cada uma das instalações desenvolvidas pelo InstallShield é realizada
através da aba Groups na caixa de diálogo Specify Components and Files mostrada a seguir.

Página: 113
Delphi 5

Nesse ponto podemos começar a organizar os arquivos que serão instalados estabelecendo sua localização
relativa na máquina do cliente. É aconselhável que esses arquivos já estejam agrupados na própria máquina
de desenvolvimento para que o processo de “montagem” dos grupos seja feito de forma mais fácil e rápida.
Inicialmente já existe pelo menos um grupo a ser instalado, chamado Program Files, que possui o arquivo
executável principal da aplicação. Por default esse arquivo será instalado no especificador
<INSTALLDIR> que identifica o diretório selecionado pelo cliente no momento da instalação.
Dependendo de quais componentes tenham sido selecionados na caixa de diálogo Select InstallShield
Components for Delphi existirão outros grupos definidos automaticamente para instalação, como mostrado
na figura acima. Nesse momento podemos modificar a localização desses grupos clicando o botão Modify
Group. Devemos observar que, em relação aos grupos do BDE criados automaticamente, a modificação de
sua localização não é aconselhável. Essa observação advém do fato de que, caso já exista uma aplicação na
máquina do cliente que utilize o BDE e, consequentemente, possua seus arquivos instalados no diretório
default indicado pelo InstallShield, a instalação atual irá instalar uma nova cópia do BDE em um local
diferente, ocupando espaço desnecessário e podendo, inclusive, causar problemas durante a execução dos
aplicativos que o utilizem. Ao clicar-se no botão Modify Group, a caixa de diálogo a seguir é exibida.

Através dessa opção podemos mudar tanto o nome do grupo sendo


utilizado quanto sua posição relativa na máquina do cliente. O
diretório de destino pode ser escolhido dentre uma das opções
existentes no combobox quanto pode ser dada uma nova localização
através de sua digitação direta.
Além de modificar grupos criados automaticamente pelo InstallShield
também temos a opção de criar novos grupos para a instalação. Para
que isso seja possível, devemos clicar o botão Add Group. Ao fazermos isso, será exibida uma caixa de
diálogo, semelhante à de modificação de grupo, solicitando o nome do grupo a ser adicionado, bem como
sua localização relativa na máquina do cliente. Após o preenchimento dessas informações podemos clicar o
botão OK para confirmar a adição do novo grupo ou Cancel para cancelar essa adição. Uma vez clicado o
botão OK, o grupo é adicionado à lista de grupos de arquivos existentes. Devemos lembrar de adicionar um
ou mais grupos para os arquivos de banco de dados. Esses grupos deverão conter a localização especificada
no alias criado anteriormente caso ainda não exista nenhum grupo indicando essa localização.
Uma vez criado um grupo devemos indicar quais os arquivos que serão colocados no diretório indicado por
esse grupo. Para isso, devemos utilizar o Windows Explorer. Caso o Windows Explorer ainda não esteja
executando podemos executá-lo clicando o botão Launch Explorer. Uma vez em execução, para adicionar
arquivos ao grupo desejado basta que selecionemos os arquivos desejados no Windows Explorer e
arrastemo-los para o grupo desejado, numa simples operação de drag-and-drop. Devemos observar que
não importa qual o grupo correntemente selecionado, os arquivos serão adicionados no grupo para o qual o
mouse seja arrastado.
Quando adicionamos arquivos à grupos devemos tomar um cuidado em especial. No momento em que o
InstallShield vai gerar os discos de instalação para a aplicação corrente, ele faz uso do caminho
especificado no grupo ao qual ele faz parte. Isso quer dizer que, do momento em que adicionamos um
arquivo à um grupo, não podemos remover nem mover esse arquivo, pois assim o InstallShield não será

Página: 114
Delphi 5

capaz de gerar os discos de instalação. Após a geração desses discos, tanto a remoção quanto a alteração da
localização desses arquivos pode ser feita normalmente.
A remoção de um grupo também é feita de forma bem simples e intuitiva. Para que um grupo seja
removido basta selecionarmos o grupo em questão e pressionarmos a tecla del. O InstallShield abre uma
caixa de diálogo questionando se desejamos realmente remover o grupo selecionado e, caso esse seja
realmente o nosso desejo, o grupo será removido. Caso existam arquivos no grupo selecionado esses
também serão removidos da instalação. De forma semelhante podemos remover os arquivos, basta que
selecionemos o arquivo desejado e pressionemos a tecla del. O arquivo em questão será removido da
instalação. A diferença entre a remoção de um grupo ou de um arquivo está na confirmação da remoção.
No caso da remoção de arquivos não existe um pedido de confirmação, o arquivo é removido
imediatamente após pressionarmos a tecla del, enquanto que ao removermos um grupo, existe o pedido
pela confirmação da remoção.
O botão File Details exibe informações a respeito do arquivo correntemente selecionado. Um exemplo da
caixa de diálogo com as informações de um arquivo é mostrado a seguir.
Uma observação que deve ser feita é em relação à
instalação de um software que utilize arquivos gravados
no diretório do Windows. Quaisquer arquivos que se
tente copiar, tanto para o diretório do Windows quanto
para o diretório System, que já possuam nesses diretórios
da máquina do cliente versões mais recentes do que
aquelas que a instalação está tentando gravar, não serão
copiados.
No processo de desenvolvimento de instalações simples, que não envolvam múltiplas configurações como
mencionado anteriormente, a única caixa de diálogo a ser preenchida é a de Groups. Deixaremos de lado,
momentaneamente, o preenchimento das duas outras abas, Components e Setup Types, que serão vistas
posteriormente quando falarmos a respeito de instalações múltiplas. Podemos seguir adiante pressionando a
o botão OK.

12.8. Selecionando os componentes de interface com o usuário


Passamos agora a selecionar e configurar as caixas de diálogo que aparecerão para o usuário no momento
da instalação. Esse processo é feito através da caixa de diálogo Dialog Boxes mostrada a seguir.
A caixa de diálogo Dialog Boxes é dividida em duas
partes. Do lado esquerdo encontra-se uma lista contendo
todas as caixas de diálogo que podem ser exibidas, na
ordem em que aparecem na lista, durante o processo de
instalação. Para que uma caixa de diálogo seja exibida
basta que o checkbox do lado esquerdo de seu nome seja
assinalado. Do lado direito encontra-se, na aba Preview,
um exemplo de que tipo de caixa de diálogo será exibida
durante a instalação para a caixa de diálogo
correntemente selecionada do lado esquerdo. Para
algumas dessas caixas de diálogo, ainda existe do lado
direito uma aba chamada Settings, que permite a configuração da caixa de diálogo correntemente
selecionada. A seguir fornecemos uma breve descrição de cada uma das caixas de diálogo que podem ser
incluídas no processo de instalação, indicando a possibilidade ou não de sua configuração.

Welcome Bitmap
Permite a exibição de um bitmap logo após a exibição da caixa de diálogo de inicialização da instalação
mas antes de qualquer outra caixa de diálogo. Um exemplo de uma caixa de diálogo de inicilizazação é
mostrado a seguir.

Página: 115
Delphi 5

A aba Settings para esse item permite a escolha de qual bitmap deseja-se exibir.
Welcome Message
Exibe uma mensagem ao usuário dando as boas vindas ao programa de instalação e fornecendo instruções
ao usuário para que esse feche todos os aplicativos que estejam correntemente em execução antes de
continuar o processo de instalação. Um breve aviso sobre direitos autorais também é fornecido.
O nome fornecido na caixa de diálogo Application Information é colocado automaticamente no topo dessa
caixa de diálogo.
Não existe a aba Settings para esta caixa de diálogo.
Software License Agreement
Exibe uma caixa de diálogo contendo o Acordo para Licença de Uso do software que está sendo instalado.
A aba Settings permite indicar o arquivo texto que contém o texto a ser exibido na caixa de diálogo citada
acima.
Readme Information
Essa caixa de diálogo é utilizada para exibir um arquivo texto do tipo Leiame. É importante observar que o
texto a ser exibido nessa caixa de diálogo não é formatado automaticamente. Para que o texto seja
completamente exibido na caixa de diálogo, ele deve ser formatado com retorno de carro em cada linha de
acordo com a formatação desejada.
User Information
Utilizada para coletar informações a respeito do usuário tais como nome, companhia e, opcionalmente, o
número serial do produto sendo instalado.
A aba Settings permite a definição de quais informações podem ser fornecidas pelo usuário. Existem duas
opções, a primeira sem a opção para o número serial e a segunda, com o número serial.
Choose Destination Location
Através dessa caixa de diálogo o usuário pode escolher a localização na qual ele deseja que o aplicativo
seja instalado. O diretório escolhido pelo usuário irá substituir o especificador <INSTALLDIR>, nos locais
nos quais ele tenha sido utilizado no processo de criação da instalação.
A aba Settings é utilizada para definir o diretório default a ser exibido para o usuário no momento da
instalação. Pode-se ser utilizado qualquer especificador existente no InstallShield para compor o diretório
default porém, não é aconselhada a utilização do especificador <INSTALLDIR>. Caso isso seja feito, no
momento da geração dos discos de instalação, o InstallShield fornecerá um warning alertando sobre a
utilização desse especificador em um local não apropriado. O default utilizado pelo InstallShield para o
diretório default de instalação segue o padrão:

<ProgramFilesDir>\<Companhia>\<Aplicação>

Onde companhia e aplicação são substituídos pelas informações fornecidas na caixa de diálogo Application
Information.
Setup Type
Permite ao usuário escolher qual o tipo de instalação desejada. Para que essa caixa de diálogo possa ser
exibida, faz-se necessário que tenham sido criados os tipos de instalação correspondentes.
Não existe a aba Settings para esta caixa de diálogo.
Custom Setup
Essa caixa de diálogo será exibida apenas se o usuário escolher a opção de instalação customizada na caixa
de diálogo Setup Type.
Permite a escolha de quais componentes o usuário deseja instalar. Os componentes constantes nessa caixa
de diálogo devem ter sido previamente determinados na caixa de diálogo Components.

Página: 116
Delphi 5

Não existe a aba Settings para esta caixa de diálogo.


Select Program Folder
Permite a escolha do nome do folder no qual os ícones do aplicativo sendo instalado serão colocados. Por
default, o nome do folder utilizado é o mesmo dado ao projeto no InstallShield.
A aba Settings permite a definição do nome que será dado ao folder.
Start Copying Files
Permite ao usuário verificar as informações fornecidas por ele ao programa de instalação antes do início da
cópia dos arquivos para a máquina cliente.
Não existe a aba Settings para esta caixa de diálogo.
Progress Indicator
Fornece ao usuário uma visualização rápida do progresso da instalação. É indicado o percentual de
progresso, bem como o arquivo correntemente sendo copiado.
Não existe a aba Settings para esta caixa de diálogo.
Billboards
Utilizada para exibir um bitmap, ou um arquivo do tipo Windows Metafile, contendo informações diversas
como, por exemplo, a respeito de outros produtos da empresa.
A aba Settings é utilizada para escolher qual o arquivo bitmap ou metafile a ser exibido.
Online Registration
Essa caixa de diálogo é utilizada para permitir o registro on-line do produto adquirido.
A aba Settings é utilizada para definir o número de telefone a ser utilizado para a conexão, bem como o
login de acesso para se efetuar o registro.
Setup Complete
Essa caixa de diálogo é utilizada ao final do processo de instalação. Através dela é permitido tanto a
execução imediata da aplicação, a leitura de um arquivo do tipo Leiame ou ainda o reboot da máquina do
cliente.
A aba Settings permite a escolha da opção de exibição da caixa de diálogo para dar um reboot na máquina
cliente através da marcação do checkbox Always show reboot computer dialog box. Podemos ainda indicar
a localização do arquivo a ser executado automaticamente ao final da instalação, bem como os parâmetros
a serem utilizados, ou ainda indicar qual o arquivo texto a ser exibido caso a opção de exibir o arquivo
readme seja selecionada.

12.9. Mudando o registry

Até agora, nas diversas caixas de diálogo apresentadas nesta apostila, foram fornecidas informações ao
InstallShield que serão diretamente visíveis aos usuários no momento da instalação. Neste tópico veremos
como definir informações que serão fornecidas ao sistema operacional.
A caixa de diálogo Make Registry Changes permite ao desenvolvedor definir as diversas chaves que serão
utilizadas nos registradores do sistema operacional, bem como definir os valores que nelas serão
armazenados. Para atender a essas finalidades,
a caixa de diálogo Make Registry Changes está
dividida em duas abas, cada um das quais
destinadas a atender as funcionalidades citadas
anteriormente. A primeira dessas abas, a aba
Registry – Keys é mostrada a seguir.
A caixa de diálogo Registry – Keys é utilizada
para definir as chaves que serão adicionadas

Página: 117
Delphi 5

aos registradores do sistema operacional no momento da instalação do software. O conteúdo dessa aba está
intimamente ligado ao conteúdo da segunda aba existente nessa caixa de diálogo onde, os valores exibidos
na segunda aba são relativos à chave correntemente selecionada na primeira aba.
Inicialmente, a aba Registry – Keys possui seis chaves previamente definidas como mostrado na figura
anterior. Essas chaves, chamadas de root keys, não podem ser removidas ou alteradas por serem utilizadas
pelo programa de desinstalação. As root keys servem como base para outras chaves a serem adicionadas ao
programa de instalação. Para maiores informações a respeito das root keys consultar o tópico de ajuda
Registry Key Automatic Entry. Cada nova chave a ser adicionada deve, portanto, ser descendente de uma
chave já existente.
O botão Modify Key não está inicialmente habilitado uma vez que não é possível a alteração de qualquer
uma das root keys. Uma vez que uma nova chave for adicionada e selecionada, esse botão passará a estar
habilitado e poderá ser utilizado normalmente. Para adicionarmos uma chave devemos primeiramente
escolher e selecionar sob qual root key desejamos adicionar a nossa chave. Em seguida devemos clicar o
botão Add Key para que a seguinte caixa de diálogo apareça.
Devemos preencher o campo New Key com o nome
da nova chave a ser criada. Durante a composição do
nome da nova chave, podem ser utilizados mais de
um nível de chaves, sendo essas separadas por uma
barra invertida como mostrado na figura acima. Uma
vez definida a nova chave, podemos clicar o botão
OK para que a nova chave seja criada e exibida como
uma ramificação sob a root key indicada no campo
Sub Key of da caixa de diálogo Registry New Key
mostrada acima.
A modificação de uma chave existente também é feita de forma bastante simplificada. Para isso, basta que
a chave a ser modificada seja escolhida e seja pressionado o botão Modify Key. Uma vez pressionado o
botão Modify Key, uma caixa de diálogo semelhante à mostrada acima é exibida contendo a chave a ser
alterada. Para alterarmos a chave baste que a nova chave seja digitada no lugar da chave atual. Para
finalizar a alteração basta que o botão OK seja clicado. Uma observação a ser feita está no fato de que, ao
selecionarmos uma chave que possua subchaves, apenas a chave selecionada será alterada enquanto que as
subchaves permanecerão inalteradas.
A remoção de uma chave, da mesma forma que a alteração, é bastante simples e intuitiva. Para que uma
chave seja removida basta que ela seja selecionada e a tecla del seja pressionada. No caso da seleção de
uma chave que possua subchaves a remoção é feita da mesma forma porém as subchaves também serão
removidas juntamente com a chave inicialmente selecionada. Uma observação a ser feita está no fato da
não solicitação de uma confirmação antes da remoção de uma chave. Devemos, portanto, Ter bastante
cuidado antes de remover alguma chave para evitarmos qualquer possibilidade de re-trabalho.
O botão Registry Editor é utilizado para exibir o Editor de Registro do Windows95. Para maiores
informações a respeito do Editor de Registro, consultar a ajuda do próprio editor.
A segunda aba da caixa de diálogo Make Registry Changes, a aba Registry - Values, é utilizada para
fornecer valores para as chaves especificadas na aba Registry – Keys. A caixa de diálogo Registry – Values
é mostrada a seguir.
O valor especificado nessa aba refere-se à chave selecionada
anteriormente na aba Registry – Keys. Na figura acima, por
exemplo, o valor a ser definido refere-se à chave Versao. A chave
para o qual será especificado o valor encontra-se exibida na caixa
de texto Registry Key. Para escolhermos uma nova chave, devemos
voltar à aba Registry – Keys e escolhermos um novo valor. Essa
alteração não pode ser feita diretamente na caixa de texto.
Para que um novo valor seja adicionado à chave correntemente
escolhida devemos clicar o botão Add Value. Ao fazermos isso, a
caixa de diálogo Registry Value será exibida como mostrado a
seguir.

Página: 118
Delphi 5

Devemos primeiramente especificar o tipo de valor a ser colocado através


dos radio buttons existentes, bem como o nome para o valor que será
colocado como também o próprio valor a ser colocado. Uma vez
preenchido esses campos pode-se clicado o botão OK para que esses
valores sejam aceitos.
Além da adição de novos valores, podemos alterar valores previamente
colocados. Para isso, devemos selecionar o valor a ser alterado e em
seguida pressionar o botão Modify Value. Ao fazermos isso, a caixa de diálogo Registry Value, mostrada
acima, é novamente exibida, de tal forma a podermos alterar os valores previamente definidos, colocando
os novos valores nos campos desejados.
Por fim, podemos ainda remover valores previamente estipulados. Para isso, basta selecionarmos o valor a
ser removido e pressionarmos a tecla del. Não é exibida nenhuma caixa de diálogo pedindo a confirmação
da remoção para evitar uma remoção acidental. Devemos observar no entanto que, a valor default não será
removido, independentemente de pressionarmos a tecla del com este valor selecionado.
Ao finalizarmos a definição dos valores a serem atribuídos às chaves que serão utilizadas pelo sistema a ser
instalado, podemos clicar o botão OK para podermos continuar com o processo de desenvolvimento de
nossa instalação.

12.10. Especificando folders e ícones

Passamos agora ao processo de acabamento final de nosso processo de desenvolvimento de uma instalação.
Nas duas caixas de diálogos que serão mostradas a seguir, passaremos a definir o ambiente no qual a
aplicação será executada, especificando o grupo e os ícones que serão instalados na máquina do cliente.
A caixa de diálogo General, mostrada a seguir, é utilizada para determinar os ícones que serão colocados
no grupo de programas da aplicação que está sendo instalada.
Inicialmente, é exibido o ícone especificado para a aplicação para a
qual a instalação está sendo desenvolvida, aquele arquivo
executável definido como primário da aplicação. Podemos alterar
os parâmetros a serem fornecidos à esses executável, preenchendo
a caixa de texto Run Command Parameters, bem como alterar a
descrição para esse executável. O conteúdo da caixa de texto
Description será utilizado logo abaixo do ícone, após o clique no
botão Modify Icon, como mostrado na figura.
Para adicionarmos novos ícones ao grupo sendo construído,
devemos clicar no botão contendo uma reticências, logo ao lado da
caixa de texto Run Command. Feito isso, aparecerá a seguinte caixa de diálogo.
A caixa de diálogo Setup Files Browser é utilizada para
selecionarmos os arquivos a serem colocados no grupo da
aplicação que será instalado. Nessa caixa de diálogo, estão
listados os arquivos pertencentes à instalação. Para que um
arquivo seja colocado, basta que ele seja selecionado, como
mostra a figura acima, e logo em seguida o botão OK seja
clicado. Os dados para o arquivo selecionado aparecerão na
caixa de diálogo Geral. Para que o ícone seja exibido, basta
que o botão Add Icon seja clicado. Com isso, o ícone para o
arquivo selecionado será colocado juntamente com os
demais ícones previamente selecionados.

Página: 119
Delphi 5

Para modificarmos os atributos de um ícone já existente, basta que façamos as alterações nos campos
desejados e, para que as alterações sejam efetivadas, o botão Modify Icon seja clicado.
Da mesma forma como mostrado com as chaves, os ícones selecionados podem ser removidos ao
pressionamos a tecla del. A remoção aqui também é feita sem que seja exibida qualquer caixa de diálogo
solicitando uma confirmação por parte do usuário.
A segunda aba pertencente à caixa de diálogo Specify Folrders and Icons, chamada Advanced, propicia a
configurações de características avançadas dos ícones (programas) previamente selecionados. A figura a
seguir mostra a aba Advanced.
Como mostrado acima, a aba Advanced é composta por diversas
caixas de texto, cada uma das quais contendo valores para o ícone
correntemente selecionado. A primeira caixa de texto, Working
Directory, indica qual o diretório que será utilizado como diretório
de trabalho para o ícone selecionado. Por default, o diretório de
trabalho é o mesmo diretório onde encontra-se o aplicativo. É
importante observar que, para que quaisquer alterações efetuadas
no aplicativo sejam efetivadas, é necessário clicar o botão Modify
Info, caso contrário as alterações não terão efeito.
A seguir, podemos definir um ícone para o aplicativo. Para isso,
devemos clicar o botão contendo reticências ao lado da caixa de texto Icon. Feito isso, surgirá a caixa de
diálogo Setup Files Browser, mostrada anteriormente. Podemos escolher um ícone contido em um arquivo
do tipo ICO ou constante de uma DLL. Devemos ter, contudo, incluído o arquivo desejado previamente em
nosso projeto.
A última caixa de texto a ser
preenchida, denominada Short Cut
Key, determina a tecla de atalho
que será associada ao aplicativo
selecionado. Para associarmos
uma tecla, ou combinação de
teclas, ao aplicativo, devemos
selecionar o aplicativo e, com o
foco colocado na caixa de texto
Short Cut Key, pressionar a
combinação de teclas desejada.
Caso desejemos cancelar a
associação devemos pressionar a
tecla del para apagar as teclas
associadas.
Resta-nos ainda a possibilidade de colocarmos o aplicativo no menu Inciar Programas. Para que isso seja
feito basta que o checkbox Place icon on Start Programs menu seja marcado. Essa atitude só é
recomendada para instalações onde existam apenas um único ícone sendo instalado, onde não haveria a
necessidade da criação de um grupo para o aplicativo.

12.11. Construindo os discos de instalação


Chegamos ao final do desenvolvimento de um programa de instalação. Resta-nos apenas construir os
discos de instalação para que esses possam ser distribuídos para os clientes. O primeiro passo nesse sentido
está na criação de imagens para os discos de instalação, feita a partir da caixa de diálogo Disk Builder
mostrada a seguir.
O processo para a criação das imagens dos discos de
instalação é bastante simples. O primeiro passo a ser
dado é a seleção do tamanho dos discos que serão
utilizados para a distribuição do software. Vários são
dos tamanhos suportados, variando desde o disco de

Página: 120
Delphi 5

720KB até o CD-ROM. O tamanho do disco deverá ser selecionado através do combobox Disk Size.
Uma vez definido qual o tamanho dos discos a serem gerados, podemos dar início ao processo de geração
das imagens dos discos de instalação. Para isso, basta clicarmos o botão Build. Feito isso, é dado início ao
processo de geração, que pode ser acompanhado através da barra de progresso existente acima dos botões
de Build, Close e Help, ou através do componente memo, chamado Feedback.
Ao final da geração das imagens, um pequeno resumo resumo é exibido na no memo Feedback e os
“discos” gerados são exibidos no list view Disk Images. A seguir mostramos o resultado da geração das
imagens dos discos de instalação do aplicativo.
Podemos clicar o botão Close para sairmos da caixa de diálogo Build. Já de posse das imagens dos discos
de instalação temos duas opções: testar a instalação que acabamos de criar ou gerar efetivamente os discos
de instalação, copiando as imagens geradas para os discos que serão utilizados na distribuição do produto.

12.12. Testando a instalação


Para testarmos a instalação que acabamos de criar devemos clicar na opção Test Run existente no checklist
de desenvolvimento. Uma vez feito isso, dar-se-á início ao processo de instalação como se esse estivesse
sendo executado normalmente, a partir de disquetes de instalação convencionais. Devemos acompanhar
todo o processo de “instalação” para verificar se esse está de acordo com o que foi planejado.
Devemos observar que, caso voltemos e façamos alguma modificação em alguma das opções definidas no
processo de desenvolvimento da instalação como, por exemplo, alteração de um ícone e tentarmos testar a
“nova” instalação, resultará em um erro. O InstallShield avisará que não poderá testar a nova instalação a
menos que as imagens dos discos de instalação sejam geradas novamente. Para que isso seja feito, basta
executarmos novamente o Disk Builder.

12.13. Distribuindo o produto


Resta-nos apenas criar os discos que serão distribuídos aos clientes. Para isso, devemos selecionar a opção
Coppy to Floppy existente no checklist de desenvolvimento. A caixa de diálogo Copy To Floppy mostrada
a seguir é exibida para permitir a geração dos disquetes a serem distribuídos.
Através do combobox Drive é feita a escolha de qual o drive
que será utilizado para a cópia dos discos de instalação.
Nesse combobox estão listados os drives existentes no
sistema. Caso deseje-se colocar os discos de instalação, por
exemplo, diretamente na rede, devemos selecionar a caixa de
texto Path e localizar o local aonde esses disco devem ser
colocados.
Para efetuarmos a cópia dos discos temos duas opções. A
primeira delas, através do clique do botão Copy Selected
Disk Image, onde a imagem do disco correntemente
selecionado será copiado para a unidade selecionada em Destination. O progresso da cópia é indicado na
barra de progresso situada logo acima dos botões Close e Help. A segunda opção é através do clique no
botão Copy All Disk Images. Através dessa opção são copiadas, uma a uma, todas as imagens geradas para
a unidade selecionada. Ao final desse processo, teremos todos os discos de instalação necessários para a
entrega do software.

12.14. Criando Múltiplas Configurações


Mostramos até aqui a criação de um projeto de instalação envolvendo as opções mais simples, na qual
existia uma única possibilidade para o usuário no momento da instalação. Em muitos aplicativos
comerciais, durante o processo de instalação, é fornecida ao usuário a possibilidade de escolher um dentre
vários tipos possíveis de instalação. Em geral estão disponíveis três tipos de instalação, são elas: Típica,
Customizada e Compacta. Veremos a partir de agora como desenvolver instalações que possibilitem ao
usuário escolher opções de instalação para atender às suas necessidades como mencionado anteriormente.

Página: 121
Delphi 5

Uma vez iniciado o primeiro projeto no InstallShield, a caixa de diálogo que é exibida no início de toda
seção de trabalho com o InstallShield passa a disponibilizar mais uma opção como mostrado a seguir.
A partir de agora temos a opção de abrir o último projeto no qual
estávamos trabalhando. Esta opção agiliza a utilização do
InstallShield a medida em que trabalhamos com um projeto. Essa
passa a ser a opção default exibida todas as vezes em que iniciamos
o InstallShield.
Os passos para a criação de uma instalação com múltiplas
configurações é bastante semelhante ao descrito anteriormente. Devemos iniciar um novo projeto para que
a caixa de diálogo New Project seja exibida, como mostrado a seguir.
Devemos preencher todas as opções como mostrado
anteriormente. Neste ponto, o único detalhe a ser
observado está no fato de que, por tratar-se do
desenvolvimento de uma instalação com múltiplas
configurações, o checkbox Include a custom setup type
deve estar assinalado como mostrado na figura acima.
Podemos clicar o botão Create para dar início ao
processo de criação da instalação.
A janela principal do InstallShield é exibida
exatamente da mesma maneira como durante o
processo de desenvolvimento de uma instalação simples. As mesmas opções são exibidas no checklist, cada
uma delas devendo ser preenchida como foi mostrado nos tópicos anteriores desse manual. O processo de
desenvolvimento segue da mesma forma como mostrado anteriormente até o momento em que chegamos
na caixa de diálogo Components, a qual deixamos de explicar anteriormente mas que trataremos a seguir.

12.15. Componentes

A caixa de diálogo Components é utilizada para definirmos os componentes que fazem parte de uma
instalação. Da mesma forma com que podemos criar grupos no InstallShield, onde um grupo é composto
por um ou mais arquivos de forma a facilitar a organização física dos arquivos em disco no processo de
instalação, podemos definir componentes. Um componente é uma unidade lógica da instalação, cada um
dos quais contendo um ou mais grupos de arquivos a serem instalados. A caixa de diálogo Components é
mostrada a seguir.
Através da caixa de diálogo Components é possível a criação de
novos componentes bem como a modificação de componentes já
existentes, além da adição dos grupos criados anteriormente à
componentes específicos. Como podemos ver, a caixa de diálogo
Components está dividida basicamente em duas partes. Do lado
esquerdo temos a indicação de todos os componentes atualmente
inclusos no processo de instalação, juntamente com os grupos
que os compõe. Já do lado direito, temos todos os grupos.
Para podermos criar novos componentes à instalação, devemos
clicar o botão Add Component para que a caixa de diálogo Add
Component, mostrada a seguir, seja exibida.
Como mostrado na figura, devemos entrar com os valores que serão
utilizados como nome do componente a ser criado bem como uma breve
descrição. Uma vez clicado o botão OK, o novo componente será adicionado
à lista de componentes da instalação. Através do clique do botão Modify
Component podemos modificar tanto o nome como a descrição do
componente selecionado. Já a remoção de um componente é feita ao
pressionarmos a tecla del. O componente selecionado é removido sem
nenhum pedido de remoção, independentemente da existência de grupos associados a ele ou não.

Página: 122
Delphi 5

Um componente não tem qualquer finalidade a menos que exista um grupo ou grupos de arquivos
associados à ele. Para associarmos um grupo a um componente basta selecionarmos do lado esquerdo o
componente ao qual desejamos selecionar um grupo e, do lado direito, selecionar o grupo que desejamos
associar. Logo em seguida, para realizarmos a associação basta clicarmos o botão Add to Application
Component. Uma vez criados todos os componentes necessários ao desenvolvimento de nossa instalação
podemos clicar o botão OK para que nossas alterações seja efetivadas.

12.16. Tipos de instalação


A caixa de diálogo mostrada a seguir é utilizada para definir os diversos tipos de instalações que estarão
disponíveis ao usuário no momento da instalação.
A caixa de diálogo Setup
Types mostrada ao lado é
utilizada para definirmos o
comportamento dos diversos
tipos de instalação que irão
ser apresentados ao usuário.
Do lado esquerdo são
mostrados os três tipos de
instalação possíveis
juntamente com os
componentes que os
compõem. Do lado direito
estão listados todos os
componentes existentes no
projeto.
Para adicionarmos um
componente a um tipo de
instalação basta
selecionarmos, do lado
esquerdo, o tipo de seleção
para o qual desejamos adicionar o componente. Do lado direito, devemos selecionar o componente que
queremos adicionar e, logo em seguida, devemos clicar o botão Add to Setup Type. O botão Add to Setup
Type só torna-se habilitado quando selecionamos um componente que ainda não foi adicionado ao tipo de
instalação correntemente selecionado.
Para removermos um componente de um tipo de instalação, basta selecionarmos o componente a ser
removido no tipo de instalação desejado e pressionarmos a tecla del. Devemos observar que não é possível
removermos um tipo de instalação. Portanto, em um processo de criação de uma instalação com múltiplas
configurações, estarão disponíveis ao usuário os três tipos de instalação mencionados anteriormente.
O restante do processo de instalação é feito da mesma maneira como mostrado anteriormente, não
necessitando, portanto, de maiores explicações.

12.17. Conclusão
Como pudemos verificar, o InstallShield é um software bastante simples de ser utilizado mas que fornece
uma poderosa ferramenta para a geração de instalações, dando uma aparência profissional aos softwares
desenvolvidos por qualquer empresa.
Para maiores esclarecimentos, enviar correio eletrônico para o endereço mostrado na própria janela
principal do InstallShield, visitar o site da InstallShield ou mesmo consultar o Help On-Line do produto.

Página: 123

Você também pode gostar