Delphi Basico

Prévia do material em texto

DELPHI 
 
Delphi 5 
 
 
 
 
 
 
 
 
 
 
 
 
 
Delphi 5 
 
 Página: 1 
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 
 
 
Delphi 5 
 
 Página: 2 
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 
 
 
Delphi 5 
 
 Página: 3 
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 
 
 
Delphi 5 
 
 Página: 4 
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 poresses 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. 
 
 
Delphi 5 
 
 Página: 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 
 
 
Delphi 5 
 
 Página: 6 
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 grandeparte 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. 
 
 
Delphi 5 
 
 Página: 7 
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 
 
 
Delphi 5 
 
 Página: 8 
• 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 umanova 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. 
 
 
Delphi 5 
 
 Página: 9 
Barra de Título 
e Menus 
Barra de 
Atalho 
Paleta de 
Componentes 
Object 
Inspector Formulário 
Editor de Código
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. 
 
 
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 
 
 
Delphi 5 
 
 Página: 10 
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 
 
 
Delphi 5 
 
 Página: 11 
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 caixasde 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 
 
 
Delphi 5 
 
 Página: 12 
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 
 
 
Delphi 5 
 
 Página: 13 
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 noformulá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. 
 
 
Delphi 5 
 
 Página: 14 
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. 
 
 
Delphi 5 
 
 Página: 15 
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 selecionadostanto 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. 
 
 
Delphi 5 
 
 Página: 16 
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 
 
 
Delphi 5 
 
 Página: 17 
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 conhecimentoa 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 
 
 
Delphi 5 
 
 Página: 18 
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 
 
 
Delphi 5 
 
 Página: 19 
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çãoatravé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. 
 
 
Delphi 5 
 
 Página: 20 
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 
 
 
Delphi 5 
 
 Página: 21 
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 é 
 
 
Delphi 5 
 
 Página: 22 
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 deEvento 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. 
 
 
 
 
 
 
 
 
Delphi 5 
 
 Página: 23 
 
 
 
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 
 
 
Delphi 5 
 
 Página: 24 
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; 
 
 
Delphi 5 
 
 Página: 25