Apostila - Curso Delphi - Módulo Básico - 2a Edição

Prévia do material em texto

Marcelo Jaloto 
 
 
 
 
 
Módulo Básico 
2ª Edição 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Expediente 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Copyright  2012 
by Softplan/Poligraph Ltda. 
Centro Tecnológico Ilhasoft 
Rod. SC 401, km 1, Parque Alfa, João Paulo 
CEP 88030-000 
Florianópolis – SC 
Telefone: (48) 3027-8000 
Homepage: http://www.softplan.com.br 
 
 
Todos os direitos reservados. 
 
Este manual não pode ser reproduzido, total ou parcialmente, sem autorização da Softplan/Poligraph . 
 
Seu conteúdo possui caráter exclusivamente técnico-informativo e aos editores é reservado o direito de revisar 
as versões, de modo a aproveitar a totalidade ou parte deste trabalho. 
 
Autor: Leonardo Rigoni e Marcelo Jaloto 
 
Instrutor: Marcelo Jaloto 
 
Coordenação: Luís Fernando Fausto 
 
Diagramação: Betina von H. Seger 
Leslie Mazon 
 
 
 
 
 
 
 
 
 
 
 
 Programação em Delphi 5 | Módulo Básico | pági na 5 
 
SUMÁRIO 
 
 
Expediente ........................................ ............................................................................... 3 
Introdução ao Delphi .............................. .......................................................... 10 
Capítulo 1 ........................................ ............................................................................... 10 
1. O que é o Delphi? ...................................................................................... 10 
2. O Delphi 5 e sua IDE ................................................................................. 13 
2.1. Janela de Menu ............................................................................................................... 13 
2.2. Paleta de Componentes ................................................................................................. 17 
2.3. Janela do Editor de Código-Fonte .................................................................................. 17 
2.4. Janela do Editor de Formulário ....................................................................................... 18 
2.5. Janela do Inspetor de Objetos ........................................................................................ 19 
2.6. Janela do Gerenciador de Projeto .................................................................................. 19 
3. Arquivos de Help do Delphi e Bibliografia Recomendada .......................... 20 
Tipos de Arquivo em Delphi ........................ .................................................... 21 
Capítulo 2 ........................................ ............................................................................... 21 
1. Tipos de arquivo em Delphi ....................................................................... 21 
1.1. Arquivos de código-fonte (PAS) ....................................................................................... 21 
1.2. Arquivos de formulário (DFM) .......................................................................................... 21 
1.3. Arquivos de projeto (DPR) ............................................................................................... 21 
1.4. Arquivos de pacotes (DPK) .............................................................................................. 21 
1.5. Arquivos de grupo de projetos (BPG) .............................................................................. 22 
1.6. Arquivos de recursos (RES) ............................................................................................ 22 
1.7. Arquivos de configuração do projeto (DOF e CFG) ......................................................... 22 
1.8. Arquivos executáveis (EXE) ............................................................................................ 22 
2. Anatomia dos arquivos em Delphi ............................................................. 23 
2.1. Anatomia de um arquivo de projeto Delphi (DPR) ........................................................... 23 
2.2. Anatomia de um arquivo de código-fonte (PAS) ............................................................. 24 
2.3. Anatomia de um arquivo de formulário (DFM) ................................................................. 25 
2.4. Anatomia de um arquivo de configuração de projeto (DOF e CFG) ............................... 26 
2.5. Tipos de arquivos gerados pelo Delphi após a compilação ............................................ 27 
Criando a primeira aplicação em Delphi ............ ............................................. 29 
Capítulo 3 ........................................ ............................................................................... 29 
Configurando a IDE do Delphi ...................... ................................................... 31 
Capítulo 4 ........................................ ............................................................................... 31 
4.1. Configurando as opções do ambiente ............................................................................. 31 
4.2. Configurando as opções do editor de código-fonte ......................................................... 33 
Introdução à Sintaxe do Object Pascal ............. .............................................. 36 
Capítulo 5 ........................................ ............................................................................... 36 
5.1. Comentários ..................................................................................................................... 36 
5.2. Padrão de código ............................................................................................................. 37 
5.3. Declaração de Variáveis .................................................................................................. 38 
5.4. O Tipo de Dado CHAR .................................................................................................... 39 
5.5. O Tipo de Dado STRING ................................................................................................. 40 
5.6. O Tipo de Dado BYTE ..................................................................................................... 40 
5.7. O Tipo de Dado BOOLEAN ............................................................................................. 41 
5.8. Os Tipos de Dados Numéricos Inteiros ........................................................................... 41 
5.9. Os Tipos de Dados Numéricos Fracionários ................................................................... 42 
5.10. Os Tipos de Dados de Data e Hora ............................................................................... 43 
5.11. Forçando o Tipo de Dado (TYPECAST) ........................................................................ 44 
5.12. Declaração de Constantes ............................................................................................. 45 
5.13. Criando Tipos de Dados ................................................................................................ 46 
5.14. Criando Tipos de Dados Enumerados ........................................................................... 47 
5.15. Criando Tipos de Dados RECORD ................................................................................ 48 
5.16. O Tipo de Dado ARRAY ................................................................................................ 49 
 
 Programação em Delphi 5 | Módulo Básico | pági na 6 
 
 
 
 
5.17. Arrays Dinâmicos ........................................................................................................... 51 
5.18. Conjuntos de Dados (SET) ............................................................................................ 52 
5.19. O Tipo de Dado VARIANT .............................................................................................53 
5.20. Arrays de VARIANT ........................................................................................................ 55 
5.21. Estrutura de Decisão IF .................................................................................................. 56 
5.22. Operadores de Comparação .......................................................................................... 58 
5.23. Operadores lógicos (Booleanos) .................................................................................... 58 
5.24. Utilizando IF com diversas condições ............................................................................ 59 
5.25. Operações com dados do tipo STRING ......................................................................... 60 
5.26. Operações aritméticas.................................................................................................... 63 
5.27. Declarando Procedimentos (PROCEDURE).................................................................. 64 
5.28. Declarando Funções (FUNCTION) ................................................................................ 68 
5.29. Sobrecarga de Procedimentos e Funções (OVERLOAD) ............................................. 69 
5.30. Utilizando Várias Units ................................................................................................... 71 
5.31. Estrutura de Decisão CASE ........................................................................................... 72 
5.32. Estrutura de Repetição FOR .......................................................................................... 73 
5.33. Estrutura de Repetição WHILE ...................................................................................... 75 
5.34. Estrutura de Repetição REPEAT...UNTIL ...................................................................... 75 
5.35. Exercícios de Fixação de Conteúdo ............................................................................... 76 
Detalhes da IDE do Delphi ......................... ....................................................... 80 
Capítulo 6 ........................................ .............................................................................. 80 
6.1. Tipos de Aplicação ........................................................................................................... 80 
6.2. Detalhes da Janela de Edição de Formulários ................................................................ 80 
6.3. Detalhes da Janela de Edição de Código-Fonte .............................................................. 81 
6.4. Janela Message View ....................................................................................................... 81 
6.5. Syntax Check, Compile, Build. ......................................................................................... 82 
6.6. Usando DEFINEs e IFDEFs ............................................................................................. 82 
Componentes do Delphi ............................. ...................................................... 84 
Capítulo 7 ........................................ .............................................................................. 84 
7.1. Componente TLabel ......................................................................................................... 84 
7.2. Componente TEdit ............................................................................................................ 87 
7.3. Componente TMemo ........................................................................................................ 88 
7.4. Componente TButton ....................................................................................................... 89 
7.5. Componente TCheckBox ................................................................................................. 89 
7.6. Componente TListBox ...................................................................................................... 90 
7.7. Componente TComboBox ................................................................................................ 90 
7.8. Componente TGropuBox.................................................................................................. 91 
7.9. Componente TRadioGroup .............................................................................................. 91 
7.10. Componente TPanel ....................................................................................................... 91 
7.11. Componente TMainMenu ............................................................................................... 92 
7.12. Componente TPopupMenu ............................................................................................ 93 
7.13. Componente TBitBtn ...................................................................................................... 93 
7.14. Componente TSpeedButton ........................................................................................... 93 
7.15. Componente TMaskEdit ................................................................................................. 94 
7.16. Componente TStringGrid ................................................................................................ 94 
7.17. Componente TImage ...................................................................................................... 95 
7.18. Componente TPageControl ............................................................................................ 95 
7.19. Componente TShape ..................................................................................................... 95 
7.20. Componente TBevel ....................................................................................................... 96 
7.21. Componente TProgressBar ............................................................................................ 96 
7.22. Componente TDateTimePicker ...................................................................................... 97 
7.23. Componente TTimer ....................................................................................................... 98 
7.24. Componente TOpenDialog ............................................................................................. 98 
7.25. Componente TSaveDialog ............................................................................................. 99 
7.26. Componente TFontDialog ............................................................................................ 100 
 
 Programação em Delphi 5 | Módulo Básico | pági na 7 
 
 
 
 
7.27. Componente TColorDialog .......................................................................................... 100 
7.28. Componente TForm ..................................................................................................... 101 
7.29. Exercícios de Fixação de Conteúdo ............................................................................ 107 
Depurando Aplicações em Delphi .................... ............................................. 111 
Capítulo 8 ........................................ ............................................................................. 111 
8.1. Depurando ..................................................................................................................... 111 
8.2. Breakpoints .................................................................................................................... 112 
8.3. Call Stack ....................................................................................................................... 112 
8.4. Watches ......................................................................................................................... 113 
8.5. Local Variables ............................................................................................................... 113 
Programação Orientada a Objetos ................................................................ 114 
Capítulo 9 ........................................ ............................................................................. 114 
9.1. Objetos ........................................................................................................................... 114 
9.2. Atributos de Objetos....................................................................................................... 114 
9.3. Métodos de Objetos ....................................................................................................... 115 
9.4. Classes de Objetos ........................................................................................................ 115 
9.5. Instanciação de Objetos ................................................................................................ 117 
9.6. Classes Puras ou Abstratas ........................................................................................... 117 
9.7. Abstração de Objetos .................................................................................................... 118 
9.8. Encapsulamento de Objetos .......................................................................................... 118 
9.9. Herança de Objetos ....................................................................................................... 118 
9.10. Polimorfismo ................................................................................................................ 118 
9.11. Sobreescrita de Métodos ............................................................................................. 119 
Programação Orientada a Objetos na Prática em Delph i ........................... 120 
Capítulo 10 ....................................... ............................................................................ 120 
10.1. Declarando e Instanciando um Objeto ........................................................................ 120 
10.2. Destruindo Objetos ...................................................................................................... 121 
10.3. Métodos de Objetos e Tipos de Métodos .................................................................... 123 
10.4. Criando Classes Descendentes ................................................................................... 125 
10.5. Sobreescrevendo Métodos .......................................................................................... 126 
10.6. Sobrecarga de Métodos ............................................................................................... 128 
10.7. Reintroduzindo Métodos .............................................................................................. 128 
10.8. Classe Básica TObject ................................................................................................. 128 
10.9. Métodos construtores e destrutores ............................................................................ 129 
10.10. SELF .......................................................................................................................... 130 
10.11. Propriedades de Objetos ........................................................................................... 131 
10.12. Visibilidade de Propriedades e Métodos ................................................................... 131 
10.13. Classes ‘Amigas’ ........................................................................................................ 132 
10.14. Operador IS ................................................................................................................ 132 
10.15. Eventos ...................................................................................................................... 134 
10.16. WITH .......................................................................................................................... 136 
10.17. TRY...FINALLY...END ................................................................................................ 137 
10.18. Tratamento de Exceções (TRY...EXCEPT...RAISE) ................................................. 138 
10.19. Exercícios de Fixação de Conteúdo .......................................................................... 141 
Introdução à Hierarquia da VCL .................... ................................................ 145 
Capítulo 11 ....................................... ............................................................................ 145 
11.1. Classe TObject ............................................................................................................. 145 
11.2. Classe TPersistent ....................................................................................................... 146 
11.3. Classe TComponent .................................................................................................... 147 
11.4. Classe TControl ........................................................................................................... 148 
11.5. Classe TWinControl ..................................................................................................... 148 
11.6. Classe TGraphicControl ............................................................................................... 150 
11.7. Classe TCustomControl ............................................................................................... 150 
 
 Programação em Delphi 5 | Módulo Básico | pági na 8 
 
 
 
 
Acessando um Banco de Dado de uma Aplicação Delphi .......................... 151 
Capítulo 12 ....................................... ........................................................................... 151 
12.1. BDE - Borland Database Engine .................................................................................. 151 
12.2. Data Module ................................................................................................................. 151 
12.1. Componente DataBase ................................................................................................ 152 
12.2. Classe TDataSet .......................................................................................................... 153 
12.3. Classe TField ................................................................................................................ 156 
12.4. Componente Query ...................................................................................................... 159 
12.5. Componente DataSource ............................................................................................. 160 
12.6. Componente TTable ..................................................................................................... 160 
12.7. Componente TDBGrid .................................................................................................. 162 
12.8. Componente TDBNavigator ......................................................................................... 163 
12.10. Exercícios de Fixação ................................................................................................ 164 
TClientDataset: Dados Tabelados em Memória ........ ................................... 166 
Capítulo 13 ....................................... ........................................................................... 166 
13.1. Criando Dinamicamente uma Estrutura TClientDataset .............................................. 166 
13.2. Salvando e Lendo Dados XML DataPacket ................................................................. 167 
13.3. Acessando Registros do Banco de Dados e Processando-os em Memória ............... 168 
 
 
 
 
 Programação em Delphi 5 | Módulo Básico | pági na 9 
 
 Programação em Delphi 5 | Módulo Básico | pági na 10 
Introdução ao Delphi 
Capítulo 1 
 
 
1. O que é o Delphi? 
 O Delphi é um ambiente de desenvolvimento visual, orientado a objetos e baseado 
em componentes para criaçãode aplicações em ambiente Windows. Com o Delphi é 
possível criar aplicações com a simples adição de componentes como botões, menus, 
figuras e outros tipos de controles visuais em formulários. O Delphi automaticamente altera 
o código-fonte das aplicações para incluir referências aos componentes adicionados e 
permitir, com isso, manipular as propriedades destes componentes, como por exemplo, a 
resposta que a aplicação dará ao usuário quando o mesmo clicar em um botão na janela. 
Tal resposta pode ser a abertura de uma nova janela, a leitura de um arquivo ou qualquer 
outro tipo de ação que desejarmos realizar no programa. Para programar esta resposta, 
utiliza-se a linguagem de programação do Delphi, o Object Pascal ou Delphi Language. 
 
 O Delphi é em essência, um compilador PASCAL com grandes melhorias. Um 
compilador é um programa de computador cuja finalidade é traduzir o código-fonte de uma 
aplicação escrito em linguagem de alto nível para uma linguagem compreensível pelo 
computador, chamada de código-objeto, que pode ser executado pelo computador. O 
PASCAL é uma linguagem de programação estruturada que recebeu este nome em 
homenagem ao matemático Blaise Pascal. Foi criado em 1970 pelo suíço Niklaus Wirth, 
tendo em mente encorajar o uso de código estruturado. A linguagem é extremamente bem 
estruturada e adequada para ensino de linguagens de programação. 
 
O PASCAL originou uma enorme gama de dialetos, podendo também ser 
considerada uma família de linguagens de programação. Inicialmente, existiam apenas 
compiladores PASCAL para sistemas operacionais UNIX. Estes compiladores geravam 
aplicações que eram executadas em modo não-gráfico (janelas de texto). Com o advento 
do sistema operacional DOS – também um ambiente não gráfico – também foram surgindo 
compiladores para o ambiente DOS. 
 
Grande parte do sucesso da linguagem PASCAL deve-se à criação, na década de 
80, da linguagem TURBO PASCAL pela BORLAND. O TURBO PASCAL era uma 
linguagem PASCAL cujo compilador podia ser utilizado em ambiente DOS, e gerava 
aplicações para este sistema operacional. Ao longo dos anos, os programadores em 
PASCAL entusiasmaram-se com o TURBO PASCAL, pois oferecia facilidade de uso, alto 
desempenho na compilação e execução do código-fonte, e estabilidade das aplicações 
geradas. 
 
Durante a década de 80, com o mercado de desenvolvimento de software adotando 
cada vez mais a PROGRAMAÇÃO ORIENTADA A OBJETOS em lugar da 
PROGRAMAÇÃO ESTRUTURADA, surgiu o OBJECT PASCAL. O OBJECT PASCAL é 
uma extensão para a linguagem PASCAL e foi desenvolvido pela APPLE, com a consultoria 
de Niklaus Wirth, o inventor do PASCAL. Alguns anos depois, a BORLAND decidiu 
adicionar extensões similares ao OBJECT PASCAL ao seu produto TURBO PASCAL. 
 
Até 1995, o TURBO PASCAL era o produto mais famoso da BORLAND, e a 
linguagem PASCAL e Object PASCAL já estavam amplamente difundidas em centros de 
pesquisas, universidades e em empresas. Com o surgimento do sistema operacional 
WINDOWS, cuja principal característica era o ambiente gráfico com o uso de janelas, 
botões, caixas de texto e o uso do mouse, naturalmente surgiram novas ferramentas para 
desenvolvimento de aplicações neste ambiente. Entretanto, na época, existiam poucas 
opções de ambientes de desenvolvimento para aplicações em Windows. O programador 
tinha duas escolhas: ou utilizava a linguagem C++, que era extremamente poderosa, mas 
 
 Programação em Delphi 5 | Módulo Básico | pági na 11 
Introdução ao Delphi 
Capítulo 1 
 
de difícil aprendizado, ou utilizava o ambiente de desenvolvimento VISUAL BASIC da 
MICROSOFT, que oferecia uma linguagem de desenvolvimento limitada. Neste cenário, a 
BORLAND decidiu criar um novo compilador PASCAL para este sistema operacional, a 
partir do TURBO PASCAL. Nascia então o DELPHI 1, que oferecia um ambiente de 
desenvolvimento visual, facilidades de programação como geração automática de código-
fonte, facilidade de utilização, e orientação a objeto. Uma grande quantidade de 
programadores que já trabalham com PASCAL ou o VISUAL BASIC viram no Delphi um 
imenso potencial e migrou para esta ferramenta. 
 
Um ano depois, com o lançamento do sistema operacional de 32 bits, o Windows 
95, a BORLAND lançou a segunda versão do Delphi. Com um novo compilador de 32 bits, 
capaz de produzir aplicações mais rápidas, uma nova biblioteca de componentes 
redesenhada para o novo sistema operacional, o Delphi 2 não demorou a se tornar um 
padrão de mercado e referência para desenvolvimento de aplicações em ambiente 
Windows. 
 
No ano de 1997, a Borland lançou a terceira versão do Delphi. Esta versão facilitava 
o uso de tecnologias complexas, como COM e ACTIVEX, desenvolvimento de aplicações 
para INTERNET, acesso nativo para vários novos bancos de dados e programação multi-
camadas. 
 
Em 1998, a Borland lançou o Delphi 4. Neste ano, a BORLAND passou a chamar-se 
INPRISE, e com o Delphi 4, buscou facilitar ainda mais o desenvolvimento de aplicações 
Windows, redesenhando a interface gráfica do Delphi. 
 
Em 1999, a Borland lançou o Delphi 5, cuja principal característica em relação às 
versões anteriores era uma série de novos recursos para facilidade de criação de 
aplicações para Internet e aplicações para ambiente cliente-servidor, integração com a 
tecnologia ADO para acesso a bancos de dados, entre outras. 
 
Em 2000, a Borland lançou o Delphi 6. Os novos recursos que esta versão 
ofereciam em relação a seus antecessores era que agora, era possível utilizar o Delphi 6 
para desenvolver aplicações gráficas que poderiam ser recompiladas com o Kylix, uma 
versão do Delphi para Linux. Além disso, o Delphi 6 oferecia recursos para desenvolver 
aplicações que utilizassem o protocolo SOAP para comunicação com WEB SERVICES. 
 
Em 2001, a Borland lançou o Delphi 7, que oferecia o caminho de migração das 
aplicações Delphi para o ambiente Microsoft .NET, e também oferecia correções, novos 
componentes e facilidades para o desenvolvimento de aplicações em Linux. 
 
Em 2003, a Borland lançou o Delphi 8, que oferecia somente suporte para 
desenvolvimento de aplicações .NET. 
 
Em 2005, a Borland lançou o Delphi 2005, que criou uma nova IDE e um novo Rad 
Studio capaz de desenvolver aplicações .NET e Win32, através das linguagens Delphi, 
Delphi.Net, C#.Net. 
 
Em 2006, a Borland lançou o Delphi 2006, trazendo mais uma linguagem, o C++, ao 
seu Studio, e disponibilizou uma suíte de ferramentas integradas ao IDE que compõem o 
cliclo de desenvolvimento de software. 
 
 
 Programação em Delphi 5 | Módulo Básico | pági na 12 
Introdução ao Delphi 
Capítulo 1 
 
Em 2007, a Borland lançou o Delphi 2007 e separou a empresa em dois segmentos, 
um voltado para o mercado ALM e outro exclusivo para cuidar da linguagem Delphi e o Rad 
Studio. Então nasceu uma nova empresa a Code Gear, que trouxe muitas mudanças de 
velocidade, novos recursos na linguagem e no IDE, melhorias das classes do Delphi, novos 
componentes e deixaram o Rad Studio muito mais leve e rápido. 
 
Em 2009, a Borland vendeu a Code Gear para a Embarcadero Technologies, com a 
única intenção de se dedicar ao mercado ALM e possibilitar que uma grande empresa do 
ramo assumisse e dedicasse ao avanço da linguagem Delphi. O Delphi 2009 trouxe muitas 
vantagens tecnológicas, como possibilidade de gerar aplicativos 100% Unicode, melhorias 
na linguagem, novos componentes, e um grande avanço para aplicações nTier (multi 
camadas). 
 
Em 2010, a Embarcadero lançou o Delphi 2010 com várias melhorias na IDE e nas 
tecnologias das classes existentes, componentes nativos com funcionalidade de toques 
(Touch) e movimentos (Gesture) com os dedos na tela. 
 
Em 2011, a Embarcadero lançou o Delphi XE, que trouxe inúmeras melhorias na 
tecnologia multi-camada DataSnap, suporte a computação nas nuvens (Cloud Computing), 
integração com o Subversion, FinalBuilder, AQTime, CodeSite, Beyond Compare, IP*Wroks 
e outros, melhorias para alta produtividade ecódigo inteligente e muitas melhorias na VCL 
e RTL. 
 
Em 2012, a Embarcadero lançou o Delphi XE2 com a tão esperada versão com a 
possibilidade de compilação de aplicações nativas para Windows 64 bits e Mac OS (Mac, 
iPhone e iPad). Novo framework de classes chamado Firemonkey com suporte a criação de 
aplicação em HD e em 3D, nova tecnologia de conexão de componentes chamados 
LiveBindings, possibilidade de criação de Skins integrada com a aplicação, integração com 
Mobile e várias outras melhorias na VCL e novos componentes. 
 
Futuro, a Embarcadero prometeu uma versão do Delphi que irá gerar aplicações 
nativas para Android e Linux, tornando-se uma das mais completa linguagens multi-
plataformas do mercado. 
 
 
 
 Programação em Delphi 5 | Módulo Básico | pági na 13 
Introdução ao Delphi 
Capítulo 1 
 
2. O Delphi 5 e sua IDE 
O termo ‘IDE’ é a abreviação de ‘Integrated Development Environment’, ou seja, 
Ambiente Integrado de Desenvolvimento. A IDE do Delphi foi projetada para ser intuitiva e 
de fácil manipulação e aprendizado. Com a IDE do Delphi é possível desempenhar todas 
as operações necessárias ao desenvolvimento de uma aplicação, desde a criação do 
projeto da aplicação, passando pela codificação e desenho da mesma, pela depuração e 
testes até a versão final da aplicação. 
A IDE do Delphi é dividida em 6 partes. Estas partes serão apresentadas a seguir, 
todas de forma resumida, pois serão aprofundadas nos capítulos posteriores. 
 
 
 
Figura 1.1 – IDE do Delphi 
 
 
2.1. Janela de Menu 
 A janela de Menu do Delphi é o centro de controle da IDE. Esta janela tem as 
mesmas funcionalidades padrão de qualquer janela principal de uma aplicação Windows, 
podendo ser maximizada, minimizada, redimensionada, movida ou fechada. Ela consiste de 
três partes: o menu, os botões de atalho e a paleta de componentes. 
 Cada menu desta janela agrupa em itens de menu operações de uma determinada 
categoria. Desta forma, temos o menu File (Figura 1.2), que agrupa operações como 
criação de novos projetos e arquivos de projeto, abertura, salvamento e fechamento de 
arquivos do projeto. 
 
 
 
 
 
 
 
 Programação em Delphi 5 | Módulo Básico | pági na 14 
Introdução ao Delphi 
Capítulo 1 
 
 O menu Edit (Figura 1.3) agrupa operações de edição, que podem ser sobre o 
código-fonte, como por exemplo, copiar, colar, recortar, ou sobre os componentes de um 
formulário, como por exemplo, copiar, colar, recortar, alinhar ou redimensionar. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
O menu Search (Figura 1.4) agrupa operações como pesquisa e substituição de texto no 
código-fonte. 
 
 
Figura 1.4 – Menu Search 
 
 
 
 
 
 
Figura 1.2 – Menu File 
 
Figura 1.3 – Menu Edit 
 
 
 Programação em Delphi 5 | Módulo Básico | pági na 15 
Introdução ao Delphi 
Capítulo 1 
 
 
 
 
O menu View (Figura 1.5) agrupa itens de menu 
que exibem as diversas janelas auxiliares do Delphi. 
 
 
O menu Project (Figura 1.6) agrupa operações 
aplicáveis sobre o projeto, como adicionar ou remover 
projetos do grupo de projetos corrento, ou adicionar e 
remover arquivos do projeto corrente, configurar opções 
do projeto corrente, ou compilar o projeto corrente. 
 
 
 
Figura 1.6 – Menu Project 
 
 
 
O menu Run (Figura 1.7) agrupa itens de menu 
para operações como executar o projeto corrente 
compilado e depurar o projeto corrente em execução no 
Delphi. 
 
 
 
 
 
 
 
 
 
Figura 1.5 – Menu View 
 
 
Figura 1.7 – Menu Run 
 
 Programação em Delphi 5 | Módulo Básico | pági na 16 
Introdução ao Delphi 
Capítulo 1 
 
 
 
 
 
 
 
O menu Component (Figura 1.8) agrupa operações 
como criar um novo componente, adicionar um 
componente à paleta de componentes do Delphi, instalar e 
desinstalar componentes e pacotes. 
 
 
 
 
 
O menu Database (Figura 1.9) oferece itens de 
menu que são atalhos para aplicativos auxiliares 
disponibilizados com o Delphi, como o Database Explorer e 
o SQL Monitor. 
 
 
 
 
O menu Tools (Figura 1.10) oferece itens de menu 
que agrupam operações de configuração do ambiente 
Delphi, como por exemplo, configurações de cores para a 
janela do editor de código-fonte, configurações de 
depuração, entre outras. 
 
 
 
 
 
 
O menu Help (Figura 1.11) oferece atalhos para os 
arquivos de ajuda do Delphi e arquivos de ajuda sobre a 
programação em Windows (Windows API’s). 
 
 
 
 
 
 
 
 
 
Os botões de atalho na janela de menu do Delphi são simplesmente atalhos de um 
clique de mouse para algumas das principais operações utilizadas no Delphi, como 
salvamento de arquivos, criação de novos formulários e arquivos de código-fonte, 
compilação e execução do projeto corrente, entre outras. 
 
 
Figura 1.8 – Menu Component 
 
 
Figura 1.9 – Menu Database 
 
 
Figura 1.10 – Menu Tools 
 
 
Figura 1.11 – Menu Help 
 
 
 Programação em Delphi 5 | Módulo Básico | pági na 17 
Introdução ao Delphi 
Capítulo 1 
 
 
Figura 1.12 – Botões de Atalho 
 
Estes botões de atalho são divididos em cinco grupos: Standard , View , Desktop , 
Debug e Custom (Figura 1.12). Cada grupo de botões de atalho pode ser configurado em 
relação à sua posição na janela de Menu do Delphi ou em relação aos botões que 
compõem cada grupo. 
 
 
2.2. Paleta de Componentes 
 A paleta de componentes do Delphi é composta de várias abas, uma para cada 
grupo de componentes do Delphi. Cada aba agrupa os componentes de acordo com sua 
funcionalidade. As abas são: Standard, Additional, Win32, System, DataAccess, 
DataControls, ADO, Interbase, Midas, InternetExpress, Internet, FastNet, DecisionCube, 
QReport, Dialogs, Win3.1, Samples, ActiveX, Servers. 
 
 
2.3. Janela do Editor de Código-Fonte 
 A janela do Editor de Código-Fonte é onde você digita o código-fonte que irá dizer 
para sua aplicação como se comportar e é onde o Delphi insere automaticamente código 
quando você coloca componentes nos formulários de sua aplicação. 
 
 
Figura 1.13 – Janela do Editor de Código-Fonte 
 
 Programação em Delphi 5 | Módulo Básico | pági na 18 
Introdução ao Delphi 
Capítulo 1 
 
No topo da janela do editor existem abas, onde cada aba corresponde a um arquivo 
de código-fonte do projeto corrente no Delphi. Deste modo, vários arquivos de código-fonte 
podem ser abertos e editados ao mesmo tempo. Cada vez que você adiciona um novo 
formulário ao seu projeto Delphi, um novo arquivo de código-fonte é adicionado ao projeto e 
automaticamente exibido na janela do editor. 
 A janela do editor de código-fonte oferece um menu de contexto, que pode ser 
exibido clicando com o botão direito do mouse sobre a área de edição da janela. Neste 
menu de contexto, diversas operações podem ser realizadas, tais como fechar o arquivo de 
código-fonte corrente, abrir um novo arquivo de código-fonte, copiar, colar, recortar, entre 
outras. 
 
 
 
2.4. Janela do Editor de Formulário 
 A janela do editor de formulário é onde você irá colocar os componentes de cada 
formulário para montar a sua aplicação. Nesta janela é possível alinhar, redimensionar, 
copiar, recortar, colar, mover, inserir, ou remover os componentes. 
 A cada formulário adicionado ao seu projeto, uma nova janela de edição do 
formulário correspondente é aberta, deste modo, é possível ter diversas janelas de edição 
de formulário abertas ao mesmo tempo. 
 
 
Figura 1.14 – Janela do Editor de Formulário 
 
 A janela do editor de formulário oferece um menu de contexto, que pode ser exibido 
clicando com o botão direito do mouse sobre a área de edição da janela. Neste menu de 
contexto, diversas operações pode ser realizadas, tais como alinhar componentes, 
redimensionar, reescalar, entre outras. 
 Depois de adicionados os componentes ao formulário, alinhados e 
redimensionados, você irá utilizar a janela do Inspetor de Objetos para configurar outras 
propriedades dos componentes. 
 
 
 
 
 Programação em Delphi 5 | Módulo Básico | pági na 19 
Introdução ao Delphi 
Capítulo 12.5. Janela do Inspetor de Objetos 
 Com a janela do inspetor de objetos, 
você poderá configurar as diferentes 
propriedades do formulário e dos componentes 
dentro dele, e habilitar o formulário e seus 
componentes para responder a diferentes 
eventos executando trechos do código-fonte 
escritos utilizando a janela do editor de código-
fonte. 
 
Propriedades são dados dos 
componentes, como cor, posição, texto exibido, 
e eventos são trechos de código executados em 
resposta a ocorrências de determinadas 
situações dentro de sua aplicação, como por 
exemplo, ao ser exibido ou fechado um 
formulário, ou ao ser pressionada uma tecla 
qualquer. 
 
 
2.6. Janela do Gerenciador de Projeto 
 A janela do Gerenciador de Projeto tem como objetivo facilitar ao desenvolvedor 
Delphi a navegação e localização dos arquivos que compõem a aplicação Delphi. Esta 
janela permite visualizar todos os projetos de um grupo de projetos, e para cada projeto, 
permite visualizar rapidamente todos os arquivos de código-fonte e formulários que 
compõem o projeto. 
 Nesta janela, o desenvolvedor pode usar as funcionalidades do menu de contexto 
da mesma para adicionar e remover projetos ao grupo, adicionar e remover arquivos de 
código-fonte e formulários do projeto, entre outras operações. 
 O desenvolvedor pode visualizar esta janela clicando no menu View da janela 
principal do Delphi, e em seguida clicando no item de menu Project Manager. 
 
 
Figura 1.16 – Janela do Gerenciador de Projetos 
 
 
 
 
 
Figura 1.15 – Janela do Inspetor de 
Objetos 
 
 
 Programação em Delphi 5 | Módulo Básico | pági na 20 
Introdução ao Delphi 
Capítulo 1 
 
3. Arquivos de Help do Delphi e Bibliografia Recome ndada 
 Como qualquer bom ambiente de desenvolvimento de aplicações, o Delphi oferece 
uma extensa e detalhada documentação de ajuda aos seus desenvolvedores. Esta 
documentação é instalada automaticamente quando o Delphi é instalado, e o 
desenvolvedor pode encontrá-la a partir do menu HELP do do Delphi, ou através do menu 
Delphi 5 instalado na barra de menu do Windows. 
 Recomenda-se aos desenvolvedores Delphi sempre consultarem a documentação 
de ajuda do Delphi, pois a maioria das dúvidas pode ser resolvida consultando-se esta 
documentação. 
 
Além da documentação que acompanha o Delphi, existe no mercado uma extensa 
lista de livros técnicos que ensinam a utilizar o Delphi. Além dos livros, existe na Internet 
milhares de referências sobre o Delphi, como documentos, componentes, exemplos de 
código e aplicações. 
 A seguir apresentamos uma lista de livros cuja leitura é recomendada e que foram 
utilizados na elaboração deste documento. 
 
• Delphi 5 Developer's Guide (Developer's Guide), Steve Teixeira, Xavier Pacheco. 
• The Tomes of Delphi 3: Win32 Graphical API, by John Ayres, David Bowden, Larry 
Diehl, Phil Dorcas, Kenneth Harrison, Rod Mathes, Ovias Reza, and Mike Tobin 
(Wordware Publishing, Inc., 1998). 
• The Tomes of Delphi 3: Win32 Core API, by John Ayres, David Bowden, Larry Diehl, 
Phil Dorcas, Kenneth Harrison, Rod Mathes, Ovias Reza, and Mike Tobin 
(Wordware Publishing, Inc., 1997). 
• Charlie Calvert’s Delphi 4 Unleashed, by Charlie Calvert (Sams Publishing, 1998). 
• Mastering Delphi 5, by Marco Cantu (Sybex, 1999). 
• Delphi Developer’s Handbook, by Marco Cantu, Tim Gooch, and John F. Lam 
(Sybex, 1997). 
• Secrets of Delphi 2, by Ray Lischner (Waite Group Press, 1996). 
• Developing Custom Delphi 3 Components, by Ray Konopka (Coriolis Group Books, 
1997). 
• Delphi Component Design, by Danny Thorpe (Addison-Wesley, 1997). 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 Programação em Delphi 5 | Módulo Básico | pági na 21 
Tipos de Arquivo em Delphi 
Capítulo 2 
 
 
1. Tipos de arquivo em Delphi 
 Ao criar uma aplicação em Delphi, o desenvolvedor irá trabalhar com diversos tipos 
de arquivos diferentes: arquivos de código-fonte (PAS), arquivos de formulário (DFM), 
arquivos de projeto (DPR), arquivos de pacotes (DPK), arquivos de grupo de projetos 
(BPG), arquivos de recursos (RES), arquivos de configuração do projeto (DOF e CFG), 
arquivos executáveis (EXE). Cada um destes tipos de arquivo possui uma funcionalidade 
para o Delphi. A seguir, iremos apresentar cada um destes tipos de arquivo. 
 
 
1.1. Arquivos de código-fonte (PAS) 
 Arquivos de código-fonte no Delphi sempre são chamados de ‘Units’, e o nome 
destes arquivos sempre apresenta a extensão de arquivo ‘.PAS’. Estes arquivos são 
arquivos em formato texto, que contêm trechos de código-fonte em Object Pascal, que 
podem ser compilados pelo Delphi para gerar um código-objeto. 
 
1.2. Arquivos de formulário (DFM) 
 Um formulário em Delphi é uma janela da aplicação. Arquivos de formulário no 
Delphi são arquivos em formato texto ou binário cujo conteúdo define que componentes 
fazem parte do formulário, as configurações de cada componente do formulário e do próprio 
formulário. Arquivos de formulário em Delphi sempre apresentam em seus nomes a 
extensão de arquivo ‘.DFM’, que significa ‘Delphi Form’. 
 É importante observar que um arquivo de formulário sempre tem um arquivo de 
código-fonte (PAS) correspondente. Assim, quando criamos um formulário de nome no 
Delphi, automaticamente estamos criando dois arquivos: um arquivo de formulário (o DFM) 
e o arquivo de código-fonte correspondente (o PAS). Por exemplo: se criarmos no Delphi 
um novo formulário, quando formos salvar o formulário, será necessário definir um nome 
para o arquivo. Digamos que informamos o nome ‘HELLOWORLD.DFM’ para o formulário, 
então o Delphi automaticamente irá salvar o arquivo de código-fonte (PAS) correspondente 
com o nome ‘HelloWorld.PAS’. 
 
1.3. Arquivos de projeto (DPR) 
 Uma aplicação em Delphi sempre começa com um arquivo de projeto. O arquivo de 
projeto é o arquivo principal de uma aplicação. Neste arquivo são referenciados todos os 
arquivos de código-fonte e formulários da aplicação. 
O nome de um arquivo de projeto em Delphi sempre possui a extensão de arquivo 
.DPR, que significa ‘Delphi Project’. 
 
1.4. Arquivos de pacotes (DPK) 
 Arquivos de pacotes em Delphi são arquivos texto que referenciam um ou mais 
arquivos de código-fonte (PAS) e/ou arquivos de formulário (DFM). Os nomes de arquivos 
de pacotes sempre possuem a extensão de arquivo ‘.DPK’, que significa ‘Delphi Package’. 
 Um pacote em Delphi geralmente agrupa arquivos PAS e DFM com a finalidade de 
reutilização de código, de modo que diferentes aplicações Delphi possam utilizar o mesmo 
pacote, e consequentemente, os mesmos arquivos de código-fonte e formulário. 
 
 
 Programação em Delphi 5 | Módulo Básico | pági na 22 
Tipos de Arquivo em Delphi 
Capítulo 2 
 
 
1.5. Arquivos de grupo de projetos (BPG) 
 Com o Delphi, as vezes uma aplicação pode ser dividida em várias aplicações 
diferentes. Por exemplo, em uma aplicação cliente-servidor, sempre temos uma aplicação 
que é a aplicação servidora, e outra aplicação que é a aplicação cliente. Ambas as 
aplicações fazem parte da mesma solução para o usuário final, então é natural que ambas 
as aplicações sejam agrupadas em um mesmo Grupo de Projetos Delphi. Um arquivo de 
grupo de projetos Delphi é um arquivo texto, cujo nome de arquivo sempre apresenta a 
extensão de arquivo ‘.BPG’, que significa ‘Borland Project Group’. 
 
1.6. Arquivos de recursos (RES) 
 Algumas vezes, uma janela de nossa aplicação em Delphi precisa exibir para o 
usuário alguma imagem. Onde esta imagem pode ficar armazenada dentro da aplicação? A 
forma mais simples é armazenar o código binário da imagem dentro do arquivo de 
formulário da janela (o DFM), o que é feito automaticamente pelo Delphi. Mas e se em outra 
janela da aplicação é necessário apresentar novamente a mesma imagem para o usuário? 
Iremos novamente armazenar o código binário da imagem no formulário correspondente à 
janela? Isso é possível, mas é extremamente ineficiente, pois com isso, estamos 
aumentando desnecessariamente o tamanho final da aplicação compilada.O mesmo caso se aplica quando uma janela precisa exibir uma mensagem para o 
usuário em resposta a determinada ação do mesmo. Podemos armazenar o texto da 
mensagem no formulário da aplicação, ou mesmo, deixá-lo definido no arquivo de código-
fonte da aplicação. Mas e se outra janela da aplicação precisar apresentar a mesma 
mensagem? E se outra aplicação do nosso grupo de projetos Delphi também precisa 
apresentar a mesma mensagem? 
 Pensando nestes tipos de problemas, o Delphi oferece o conceito de arquivos de 
recursos. Arquivos de recursos são arquivos binários cujo nome sempre apresenta a 
extensão de arquivo ‘.RES’, que significa ‘Resource’. Um arquivo de recurso pode 
armazenar simultaneamente imagens, textos, ícones, vídeos e músicas. Deste modo, 
armazenando somente uma única vez e em um único local mensagens e imagens, o 
desenvolvedor pode utilizar em diferentes aplicações, formulários e arquivos PAS o mesmo 
arquivo de recurso. 
 
1.7. Arquivos de configuração do projeto (DOF e CFG ) 
 Quando criamos um projeto em Delphi (um arquivo DPR), automaticamente 
estamos criando os arquivos de configuração correspondentes ao projeto. Estes arquivos 
de configuração definem algumas propriedades do projeto, como por exemplo, os diretórios 
onde os arquivos compilados serão salvos, o nome do projeto que o sistema operacional 
utilizará para exibir ao usuário, opções de compilação, o ícone que será utilizado pelo 
sistema operacional para representar a aplicação Delphi, e muitas outras propriedades. Os 
arquivos de configuração do projeto sempre possuem o mesmo nome do arquivo de projeto 
da aplicação, mas com extensão de arquivo diferente. Por exemplo, se criarmos um projeto 
Delphi com o nome ‘HELLOWORLD.DPR’, o Delphi automaticamente irá criar os arquivos 
‘HELLOWORLD.CFG’ e ‘HELLOWORLD.DOF’. 
 
1.8. Arquivos executáveis (EXE) 
 Um arquivo executável é um arquivo binário que pode ser executado pelo sistema 
operacional para o qual o arquivo executável foi gerado. Quando o Delphi compila um 
projeto Delphi, normalmente ao final da compilação é gerado um arquivo executável 
correspondente ao projeto Delphi. Basta ao usuário executar este arquivo para começar a 
usar a aplicação. Um arquivo executável sempre possui a extensão de arquivo ‘.EXE’, que 
significa ‘Executável’. 
 
 Programação em Delphi 5 | Módulo Básico | pági na 23 
Tipos de Arquivo em Delphi 
Capítulo 2 
 
2. Anatomia dos arquivos em Delphi 
 A seguir, iremos apresentar com detalhes o conteúdo e a estrutura dos seguintes 
tipos de arquivo em Delphi: arquivos de projeto (DPR), arquivos de código-fonte (PAS), 
arquivos de formulário (DFM) e arquivos de configuração do projeto (DOF e CFG). 
 
 
2.1. Anatomia de um arquivo de projeto Delphi (DPR) 
 A seguir, apresentamos o conteúdo de um arquivo de projeto Delphi. 
 
01: program HelloWorld; 
02: 
03: uses 
04: Forms, 
05: uHelloWorld in 'uHelloWorld.pas' {Form1}; 
06: 
07: {$R *.RES} 
08: 
09: begin 
10: Application.Initialize; 
11: Application.CreateForm(TForm1, Form1); 
12: Application.Run; 
13: end. 
 
 Os números de linhas na listagem acima não fazem parte de um arquivo DPR, 
somente foram adicionados para facilitar a explicação. 
 Na linha 1, a palavra ‘PROGRAM’ identifica o arquivo como um arquivo de projeto. 
Você pode ver que o nome do projeto (‘HELLOWORLD’) segue a palavra ‘PROGRAM’. 
 Na linha 3, temos a palavra chave ‘USES’, que é utilizada para indicar quais os 
arquivos de código-fonte que fazem parte do projeto e são necessários para que o mesmo 
seja compilado. Nas linhas 4 e 5 estão indicados os arquivos de código-fonte que fazem 
parte do projeto. O arquivo ‘Forms’ da linha 4 é um arquivo de código-fonte que já vem com 
o Delphi, e neste caso, está sendo adicionado ao projeto porque este arquivo possui rotinas 
necessárias para o funcionamento do projeto. Já o arquivo ‘uHelloWorld’ da linha 5 é um 
formulário, que como já foi dito anteriormente, sempre possui um arquivo de código-fonte 
PAS correspondente ao arquivo DFM. Sempre referenciamos em nossos projetos os 
arquivos PAS dos formulários. No exemplo da listagem, temos um arquivo de código-fonte 
por linha, mas poderíamos ter vários arquivos de código-fonte por linha, como pode ser 
visto no exemplo abaixo, na linha 4: 
 
03: uses 
04: Forms, Dialogs, Messages, SyncObjs, 
05: uHelloWorld in 'uHelloWorld.pas' {Form1}; 
 
 Na linha 7 você vê uma DIRETIVA DE COMPILAÇÃO , que nesta linha, é um 
comando Delphi para incluir no projeto o arquivo de recurso ‘HELLOWOLRD.RES’. Toda 
vez que criamos um projeto Delphi, o Delphi automaticamente cria um arquivo de recurso 
vazio para o projeto, com o mesmo nome do arquivo de projeto, mas extensão de arquivo 
‘.RES’. No caso deste exemplo, por ser usado {$R *.RES}, ao compilar o projeto, o Delphi 
irá adicionar qualquer arquivo de recurso encontrado no mesmo diretório do arquivo de 
projeto. Se em vez disso fosse utilizado {$R HELLOWORLD.RES}, somente o arquivo de 
recurso HelloWorld.res seria incluído no projeto. 
 Nas linhas 9 e 13 podemos ver as palavras chave ‘BEGIN’ e ‘END.’. No caso de um 
arquivo de projeto, a palavra BEGIN marca o início da seção onde o desenvolvedor pode 
 
 Programação em Delphi 5 | Módulo Básico | pági na 24 
 Tipos de Arquivo em Delphi 
Capítulo 2 
 
colocar comandos em Object Pascal para realizar as ações da aplicação, e a palavra END 
marca o final desta seção. Observe que o END possui um ponto ao final. Todo arquivo de 
projeto (DPR) possui a seção ‘BEGIN..END.’, e apenas uma única vez. 
 As linhas 10, 11 e 12 utilizam um objeto que já vem criado automaticamente pelo 
Delphi e está presente no arquivo de código-fonte ‘FORMS’, o objeto Application . Este 
objeto é utilizado para inicializar a nossa aplicação, criar o formulário associado com o 
arquivo de código-fonte ‘uHelloWorld.PAS’ e então iniciar a execução da aplicação. 
 Observe que nas linhas 1, 5, 10, 11 e 12 usamos o símbolo ‘;’ (ponto-e-vírgula) para 
finalizar a linha. No Delphi, o ‘;’ sempre é utilizado para finalizar uma linha de instrução em 
Object Pascal. 
 Observe que nas linhas 4 e 11 utilizamos o símbolo ‘,’ (vírgula) para separar os 
argumentos. 
 
2.2. Anatomia de um arquivo de código-fonte (PAS) 
 A seguir, apresentamos o conteúdo de um arquivo de código-fonte Delphi, ou UNIT, 
que é como passaremos a nos referir a este tipo de arquivo. 
 
01: unit uHelloWorld; 
02: 
03: interface 
04: 
05: uses 
06: Windows, Messages, SysUtils, Classes, Graphic s, Controls, 
07: Forms, Dialogs, StdCtrls; 
08: 
09: type 
10: TForm1 = class(TForm) 
11: Button1: TButton; 
12: procedure Button1Click(Sender: TObject); 
13: private 
14: { Private declarations } 
15: public 
16: { Public declarations } 
17: end; 
18: 
19: procedure MostraMensagens; 
20: 
21: var 
22: Form1: TForm1; 
23: 
24: implementation 
25: 
26: {$R *.DFM} 
27: 
28: procedure Mostramensagens; 
29: begin 
30: ShowMessage( ' Hello World! ' ); 
31: ShowMessage( ' Bye World! ' ); 
32: end; 
33: 
34: procedure TForm1.Button1Click(Sender: TObject); 
35: begin 
36: MostraMensagens; 
37: end; 
38: 
39: initialization 
40: 
41: finalization 
42: 
43: end. 
 
 Programação em Delphi 5 | Módulo Básico | pági na 25 
Tipos de Arquivo em Delphi 
Capítulo 2 
 
Na linha 1 temos a palavra chave ‘UNIT’, que indica ao Delphi que o arquivo em 
questão é um arquivo de código-fonte. Em seguida à palavra UNIT, temos o nome da unit, 
‘uHelloWorld’ e finalmente, o símbolo ‘;’ que indica o fim da instrução. O nome de uma unit 
sempre deve ser igual ao nome do arquivo da unit, ou seja, se o nome da unit é 
‘uHelloWorld’, então o nome do arquivo é obrigatoriamente ‘uHelloWorld.PAS’. 
 Na linha 43 temos a palavra chave ‘END.’, que indica ao Delphi que esta linha é o 
final do unit. Observe que diferente do arquivo de projeto (DPR), na unit não temos o 
‘BEGIN’ correspondente a este ‘END.’. 
 Uma unit Delphi é dividida em 4 seções, sendo duas delas obrigatóriase duas 
opcionais. As seções obrigatórias são as seções de INTERFACE (veja linha 3) e de 
IMPLEMENTATION (veja linha 24). A seção de INTERFACE se inicia com a declaração da 
palavra chave INTERFACE e é finalizada com a declaração de início da seção seguinte, a 
seção IMPLEMENTATION. A seção INTERFACE tem como finalidade declarar todos os 
tipos, variáveis, constantes, funções e procedimentos que serão implementados na unit 
‘uHelloWorld.PAS’ e que o desenvolvedor deseja que sejam públicos, de modo que outras 
units, quando referenciarem a unit ‘uHelloWorld.pas’ saibam que variáveis, constantes, 
tipos, funções e procedimentos existem nesta unit e desta forma possam utilizá-los, a fim 
de reutilização de código. 
 A seção IMPLEMENTATION se inicia com a declaração da palavra chave 
IMPLEMENTATION e é finalizada com a palavra INITIALIZATION (veja linha 39) no caso 
de nossa listagem de exemplo. Mas a seção IMPLEMENTATION também pode ser 
finalizada com a declaração da palavra chave ‘END.’ (veja linha 43), pois a palavra chave 
INITIALIZATION é a declaração de abertura de uma seção opcional, que não precisa ser 
explicitada se não houver necessidade. Na seção IMPLEMENTATION o desenvolvedor 
realiza a implementação tipos, funções e procedimentos que foram declarados na seção 
INTERFACE, e também faz uso dos tipos, variáveis e constantes declarados na seção 
INTERFACE. Tudo o que é declarado a partir da seção IMPLEMENTATION não é público 
para outras units que referenciem a unit em questão. 
 A seção INITIALIZATION se inicia com a declaração da palavra chave 
INITIALIZATION e é finalizada com a declaração da seção FINALIZATION , que por sua 
vez é finalizada pela palavra chave ‘END.’. Quando declaramos uma seção 
INITIALIZATION, é obrigatório declara uma seção FINALIZATION, e vice-versa. A 
finalidade das seções INITIALIZATION e FINALIZATION é executar comandos Object 
Pascal quando a unit em questão é carregada para a memória e descarregada da memória 
durante a execução da aplicação Delphi. Uma unit é carregada para a memória uma única 
vez, quando durante a execução da aplicação, qualquer objeto de código que esteja nesta 
unit for referenciado por outra unit da aplicação. E uma unit é descarregada da memória 
quando a aplicação é encerrada. 
 Na linha 19, dentro da seção INTERFACE, temos a declaração de uma 
PROCEDURE, ou seja, um procedimento. Nesta linha, é declarado de forma pública o 
procedimento MostraMensagens, cuja implementação é feita dentro da seção 
IMPLEMENTATION (veja linha 28). Um procedimento sempre possui um bloco 
‘BEGIN..END; ’ (veja linhas 29 e 32) para declarar o início e o final dos comandos em 
Object Pascal do procedimento. Na listagem de exemplo, o procedimento 
Mostramensagens chama duas vezes um outro procedimento (contido na unit Dialogs) para 
exibir duas mensagens diferentes ao usuário, em seqüência. 
 
2.3. Anatomia de um arquivo de formulário (DFM) 
 A seguir, apresentamos o conteúdo de um arquivo de formulário Delphi, ou FORM, 
que é como passaremos a nos referir a este tipo de arquivo. 
 
 
 
 
 Programação em Delphi 5 | Módulo Básico | pági na 26 
Tipos de Arquivo em Delphi 
Capítulo 2 
 
01: object Form1: TForm1 
02: Left = 134 
03: Top = 118 
04: Width = 544 
05: Height = 375 
06: Caption = 'Form1' 
07: Color = clBtnFace 
08: Font.Charset = DEFAULT_CHARSET 
09: Font.Color = clWindowText 
10: Font.Height = -11 
11: Font.Name = 'MS Sans Serif' 
12: Font.Style = [] 
13: OldCreateOrder = False 
14: PixelsPerInch = 96 
15: TextHeight = 13 
16: object Button1: TButton 
17: Left = 34 
18: Top = 32 
19: Width = 75 
20: Height = 25 
21: Caption = 'Button1' 
22: TabOrder = 0 
23: OnClick = Button1Click 
24: end 
25: end 
 
 Um FORM Delphi é um arquivo texto contendo a definição dos componentes que 
compõem o formulário e das propriedades dos componentes e do próprio formulário. Um 
FORM sempre inicia com a palavra chave OBJECT (veja linha 01), seguido pelo nome do 
formulário e de sua classe de formulário (este conceito será explicado mais adiante) e 
finaliza com a palavra chave END (veja linha 25). Observe que para FORMS, o END final 
não apresenta o símbolo ‘.’ (ponto). 
Em seguida, são listados os valores das propriedades do formulário que configuram 
sua aparência e comportamento (linhas 2 a 15). Sempre é utilizada uma linha por 
propriedade. 
Na linha 16, temos outra vez a palavra chave OBJECT, que inicia a declaração de 
um componente de botão dentro do formulário, e na linha 24 temos outra vez a palavra 
chave END, que finaliza a declaração do componente dentro do formulário. E nas linhas 17 
a 23 são listados os valores das propriedades do botão, que configuram sua aparência e 
comportamento. 
Com o Delphi 5, é possível escolher se os arquivos DFM serão armazenados na 
forma de texto ou binária. Para escolher um ou outro, o desenvolvedor deve clicar com 
botão direito do mouse sobre o formulário em tempo de projeto no Delphi, e no menu de 
contexto que surgirá, marcar ou desmarcar a opção ‘Text DFM’. A vantagem do formato 
texto é que ele é legível pelo desenvolvedor, e a vantagem do formato binário é que ele é 
mais compacto, exigindo menos espaço de armazenamento em disco. Na Softplan adotou-
se a utilização de formulários em modo TEXTO. 
 
2.4. Anatomia de um arquivo de configuração de proj eto (DOF e CFG) 
 A seguir, apresentamos parte do conteúdo de um arquivo de configuração DOF e de 
um arquivo de configuração CFG, respectivamente. 
... 
[Compiler] 
ShowHints=1 
ShowWarnings=1 
[Linker] 
MapFile=0 
OutputObjs=0 
ConsoleApp=1 
ExeDescription= 
[Directories] 
 
 Programação em Delphi 5 | Módulo Básico | pági na 27 
Tipos de Arquivo em Delphi 
Capítulo 2 
 
OutputDir= 
UnitOutputDir= 
PackageDLLOutputDir= 
PackageDCPOutputDir= 
[Version Info Keys] 
CompanyName= 
ProductVersion=1.0.0.0 
... 
... 
-$A+ 
-$B- 
-$C+ 
-$D+ 
-W+ 
-M 
-$M16384,1048576 
-K$00400000 
-LE"c:\arquivos de programas\borland\delphi5\Projec ts\Bpl" 
-LN"c:\arquivos de programas\borland\delphi5\Projec ts\Bpl" 
... 
 
Como podemos ver, os arquivos de configuração de um projeto Delphi são 
simplesmente arquivos de texto, contendo seções (definidas por []) e dentro destas seções, 
propriedades do projeto e seus valores correspondentes. 
Nos arquivos de configuração do projeto podemos configurar diversas propriedades 
do projeto, tais como o nome da aplicação que será exibido pelo sistema operacional, o 
número de versão da aplicação, diretivas de compilação, e o mais importante, os locais em 
disco onde o projeto irá gerar os arquivos compilados e o executável do projeto, bem como 
os locais em disco onde o Delphi irá buscar outros arquivos compilados necessários para a 
compilação do projeto. 
Durante este curso de Delphi, iremos utilizar uma estrutura de diretório padrão para 
os nossos exercícios práticos. Todos os alunos possuem em seus computadores a pasta 
C:\CursoDelphi. Dentro desta pasta, existe a pasta C:\CursoDelphi\Exercicios. A cada 
exercício que for realizado, será criada uma pasta correspondente dentro da pasta 
Exercicios. Por exemplo, se for implementado o Exercício1, iremos criar a pasta 
C:\CursoDelphi\Exercicios\Exercicio1. E dentro da pasta CursoDelphi, iremos criar duas 
subpastas: a pasta BIN e a pasta LIB. 
Cada uma destas pastas tem uma finalidade diferente: a pasta BIN será onde o 
Delphi irá gerar o arquivo executável (EXE) da aplicação. A pasta LIB será onde o Delphi 
irá gerar os arquivos compilados da aplicação. E a pasta Exercicio1 será onde iremos 
salvar os arquivos de projeto (DPR), as units de código-fonte (PAS), os formulários (DFM), 
os arquivos de recurso (RES) e os arquivos de configuração do projeto (DOF e CFG). 
Esta estrutura de diretórios para um projeto Delphi é o padrão adotado pela Sofptlan 
para o desenvolvimento de aplicações em Delphi. 
 
2.5. Tipos de arquivos gerados pelo Delphi após a c ompilação 
Após compilar um projeto e seus arquivos,o Delphi gera alguns arquivos 
compilados, e na maioria das vezes, também gera um arquivo executável (EXE) 
correspondente ao projeto. Dependendo dos tipos de arquivos contidos no projeto, tipos 
diferentes de arquivos compilados serão gerados. 
Quando o Delphi compila um arquivo de projeto (DPR), normalmente ele gera um 
arquivo executável (EXE), e este arquivo deve ser gerado na pasta BIN. 
Quando o Delphi compila uma unit de código-fonte (PAS) ou formulário (DFM), ele 
gera um arquivo compilado com o mesmo nome da unit, mas com extensão ‘DCU’, que 
significa ‘Delphi Compiled Unit’, e este arquivo deve ser gerado na pasta LIB. 
 
 Programação em Delphi 5 | Módulo Básico | pági na 28 
Tipos de Arquivo em Delphi 
Capítulo 2 
 
 
Quando o Delphi compila um arquivo de recurso (RES), ele gera um arquivo 
compilado com o mesmo nome do arquivo de recurso, mas com extensão ‘DCR’, que 
significa ‘Delphi Compiled Resource’, e este arquivo deve ser gerado na pasta LIB. 
Quando o Delphi compila um arquivo de pacote (DPK), ele gera dois arquivos 
compilados com o mesmo nome do arquivo de pacote, mas um com a extensão ‘BPL’, que 
significa ‘Borland Package Library’ e outro com a extensão ‘DCP’, que significa ‘Delphi 
Compiled Package’. O arquivo BPL deve ser gerado na pasta BIN, e o arquivo DCP devem 
ser gerados na pasta LIB. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 Programação em Delphi 5 | Módulo Básico | pági na 29 
Criando a primeira aplicação em Delphi 
Capítulo 3 
 
 Neste ponto do curso, você já está pronto para criar sua primeira aplicação em 
Delphi. Você irá ver que criar uma aplicação em Delphi é extremamente fácil e rápido, se 
compararmos com outras IDEs de outras linguagens, como o C++ e o Java. 
 Iremos criar uma aplicação de nome HelloWorld, e esta aplicação irá apresentar ao 
usuário uma janela com um único botão, que ao ser pressionado pelo usuário, irá 
apresentar ao mesmo duas mensagens em seqüência: ‘Hello Wolrd!’ e ‘Bye World!’. 
 
• Com o Delphi aberto, utilize o menu FILE, e selecione o item de menu NEW 
APPLICATION. O Delphi irá criar automaticamente um projeto chamado ‘Project1’, e 
uma unit de formulário chamada ‘Unit1’. 
 
• Utilizando o menu FILE, selecione o item de menu SAVE ALL. Será aberta uma 
janela de diálogo para informar o diretório e o nome de arquivo da unit. 
 
• Utilize esta janela de diálogo para localizar a pasta C:\CursoDelphi\Exercicios, e 
então, pressionando o botão ‘Criar uma nova pasta’, crie uma pasta com o nome 
HelloWorld dentro da pasta C:\CursoDelphi\Exercicios. Na pasta CursoDelphi, crie 
mais 2 novas pastas: a pasta BIN e a pasta LIB. Depois selecione a pasta 
HelloWorld, e informe o nome de arquivo ‘uHelloWord’. Pressione o botão Salvar. 
 
• Uma nova janela de diálogo para salvamento será aberta, desta vez, para salvar o 
arquivo de projeto. Selecione a pasta C:\CursoDelphi\Exercicios\HelloWorld, e 
informe o nome de arquivo ‘HelloWorld’. Pressione o botão Salvar. 
 
• Selecione o arquivo de formulário com o mouse, clicando nele, e no menu do 
Delphi, selecione o menu VIEW, em seguida selecione o item de menu Object 
Inspector. Na janela do Object Inspector, selecione a linha da propriedade ‘Caption’ 
e digite nela ‘HelloWorld’. 
 
• Utilizando a paleta de componentes do Delphi, com o mouse selecione a aba 
Standard, e nela clique sobre o componente TButton. Em seguida, clique sobre a 
área do formulário, e um componente TButton será adicionado ao formulário. 
 
• Volte à janela Object Inspector, localize a propriedade ‘Caption’, e digite nela 
‘Clique-me’. 
 
• Selecione o menu VIEW, e nele selecione o item de menu ‘Toggle Form/Unit’. A 
janela do editor de código fonte da unit uHelloWorld.pas será exibida. Declare na 
seção INTERFACE o procedimento MostraMensagens, e sua implementação na 
seção IMPLEMENTATION, como exibido na listagem do tópico 2.2 do capítulo 2. 
 
• Novamente selecione o menu VIEW, e nele selecione o item de menu ‘Toggle 
Form/Unit’. A janela do editor do formulário será exibida. Com o mouse, dê um duplo 
clique sobre o componente de botão do formulário. O Delphi irá automaticamente 
voltar para a janela de edição do código-fonte, e criar um evento OnClick para o 
botão. Dentro do evento OnClick do botão, implemente a chamada ao procedimento 
MostraMensagens, como ilustrado na listagem do tópico 2.2 do capítulo 2, nas 
linhas 28 a 32. 
 
 Programação em Delphi 5 | Módulo Básico | pági na 30 
Criando a primeira aplicação em Delphi 
Capítulo 3 
 
• Agora, no menu do Delphi, selecione o menu PROJECT, e nele selecione o item de 
menu OPTIONS. Será aberta a janela ‘Project Options’. Selecione na janela a aba 
‘Directories/Conditionals’, e dentro desta aba, preencha o campo ‘Output Directory’ 
com o texto ‘..\..\Bin’ e o campo ‘Unit Output Directory’ com o texto ‘..\..\Lib’. 
Pressione o botão OK. 
 
• Agora, para salvar todas as alterações do projeto, selecione o menu FILE, e nele 
selecione o item de menu SAVE ALL. Em seguida, para compilar o projeto, 
selecione o item de menu PROJECT, e nele selecione o item de menu COMPILE 
HELLOWORLD. Será exibida uma janela com o progresso da compilação. Se 
nenhum erro de sintaxe ocorrer, na janela irá aparecer a mensagem ‘COMPILED.’. 
Pressione o botão OK. 
 
• Agora, para executar a aplicação compilada, selecione o menu RUN e nele 
selecione o item de menu RUN. A aplicação HelloWorld será iniciada. 
 
OBS: caso algum erro de compilação ocorra, o Delphi irá exibir automaticamente a unit 
onde ocorreu o erro, a linha e o tipo de erro que ocorreu. O desenvolvedor deverá 
utilizar estas informações para corrigir o problema. 
 
 
 Programação em Delphi 5 | Módulo Básico | pági na 31 
Configurando a IDE do Delphi 
Capítulo 4 
 
 A IDE do Delphi pode ser personalizada ao gosto do desenvolvedor. Por exemplo, 
algumas pessoas podem preferir que as cores utilizadas pelo editor de código-fonte do 
Delphi sejam diferentes, em vez do fundo branco e o texto preto padrão. Ou então, alguns 
desenvolvedores podem desejar que o Delphi sempre gere automaticamente arquivos de 
‘backup’ para cada arquivo criado no projeto, para prevenir uma eventual perda do arquivo. 
 Neste capítulo será apresentado como o desenvolvedor pode configurar a IDE do 
Delphi a seu gosto. Nem todas as configurações serão apresentadas, somente as 
consideradas mais importantes para este curso. 
 
 
4.1. Configurando as opções do ambiente 
 Para configurar as opções de ambiente do Delphi, utilize o menu TOOLS do Delphi, 
e dentro deste menu, selecione o item de menu ENVIRONMENT OPTIONS. Surgirá então 
a janela da figura abaixo: 
 
 
Figura 4.1 – Janela Environment Options, aba Preferences 
 
 Esta janela apresenta diversas abas. A primeira dela, a aba Preferences , permite 
configurar as seguintes opções: 
 
• AutoSave Options : Neste grupo de opções, é possível indicar ao Delphi para salvar 
automaticamente os arquivos de código-fonte quando o projeto Delphi é executado. 
Recomenda-se deixar estas opções desativadas. 
• Desktop Contents : Neste grupo de opções, é possível indicar ao Delphi que 
configurações salvar quando o projeto é salvo. As configurações que podem ser 
salvas são o diretório corrente, os arquivos de código-fonte abertos, posições das 
janelas. 
 
 Programação em Delphi 5 | Módulo Básico | pági na 32 
 
 
 
 
Configurando a IDE do Delphi 
Capítulo 4 
 
• Compiling and running : Neste grupo de opções, é possível indicar ao Delphi para 
mostrar ou não o progresso da compilação (Show Compiler Progress), para 
minimizar ou não o Delphi quando o projeto é executado (Minimize on Run), ou para 
esconder os editores de formulário e editores de código-fonte quando executando o 
projeto pelo Delphi. Recomenda-se sempre deixar a opção ‘Show Compiler 
Progress’ ativada. 
• Form Designer : Neste grupo de opções é possível indicar ao Delphi para exibir ou 
não uma grade de apoio nos editores de formulário(Display grid), para encaixar 
automaticamente os componentes na grid do formulário (Snap grid), para criar 
novos formulários como arquivos texto (New Forms as Text), para fazer com que 
novos formulários da aplicação sejam automaticamente criados (Auto Create 
Forms), e para configurar os intervalos da grid do editor de formulário (Grid Size X e 
Grid Size Y). Recomenda-se sempre deixar as opções ‘Display Grid’, ‘Snap to Grid’, 
‘New Forms as Text’ ativadas, deixar a opção ‘Auto Create Forms’ desativada, e as 
opções ‘Grid Size X’ e ‘Grid Size Y’ com valor 2. 
 
OBS: A opção ‘Auto Create Forms’ sempre deve ser desativada pois se ativada, a cada 
formulário que adicionamos ao projeto, o mesmo será automaticamente criado pela 
aplicação quando executada. Assim, se temos uma aplicação com dezenas de formulários, 
quando iniciada a aplicação cria todos os formulários antes de permitir sua operação pelo 
usuário, e deste modo, a aplicação demora mais para iniciar. Além disso, a cada formulário 
pela aplicação, mais memória do sistema operacional é alocada para a aplicação. Se um 
usuário não costuma utilizar todos os formulários da aplicação numa só utilização, acaba 
sendo mais vantajoso criar os formulários à medida que o usuário for precisando. 
 
 Outra aba da janela Environment Options é a aba Library. 
 
 
 
 
Nesta aba podemos configurar o ‘Library 
Path’ geral do Delphi, ou seja, as pastas onde o 
compilador Delphi irá buscar os arquivos 
compilados referenciados pela nossa aplicação. 
Geralmente o ‘Library Path’ somente aponta 
para a pasta que contêm os arquivos 
compilados que compõem a biblioteca de 
classes, componentes, funções e 
procedimentos predefinidos do Delphi. 
Entretanto, existem ocasiões em que o 
Desenvolvedor pode preferir adicionar a pasta 
de arquivos compilados de uma biblioteca de 
componentes de terceiros. 
 
 
 
 
 
 
Figura 4.2 – Janela Environment Options, 
aba Library 
 
 
 Programação em Delphi 5 | Módulo Básico | pági na 33 
 
 
 
 
 Configurando a IDE do Delphi 
Capítulo 4 
 
4.2. Configurando as opções do editor de código-fon te 
 Para configurar as 
opções do editor de código-
fonte do Delphi, utilize o menu 
TOOLS do Delphi, e dentro 
deste menu, selecione o item 
de menu EDITOR OPTIONS. 
Surgirá então a janela da 
figura abaixo: 
 
Na aba ‘General’, as opções 
mais importantes são: 
 
Auto Indent Mode : Posiciona 
o cursor sobre o primeiro 
caracter da linha anterior 
quando você pressiona a tecla 
Enter. Recomenda-se deixar 
esta opção sempre ligada. 
 
Insert Mode : Insere texto sem 
sobreescrever o texto sob o 
cursor, deslocando o texto 
sob o cursor para a direita. 
Recomenda-se deixar esta opção sempre ligada. 
 
Use Tab Character : Quando pressionada a tecla TAB, um caracter especial de controle é 
utilizado para produzir a identação. Recomenda-se deixar esta opção sempre desligada. 
 
Undo After Save : Permite que você desfaça alterações mesmo após o salvamento das 
mesmas em arquivo. Recomenda-se deixar esta opção sempre ligada. 
 
Use Syntax Highlight : Permite que você visualize as palavras-chave do Delphi em negrito 
e em outras cores diferentes das demais palavras do código-fonte. Recomenda-se deixar 
esta opção sempre ligada. 
 
Tab Stops : Indica o número de espaços em brancos utilizados para produzir a identação 
quando pressionamos a tecla TAB. Recomenda-se sempre deixar esta opção configurada 
com o valor 2. 
 
Na aba ‘Display’, temos as seguintes configurações: 
 
Create Backup File : Esta opção faz com que o Delphi crie automaticamente 
arquivos de backup dos arquivos de projeto, código-fonte e formulário. 
 
Visible Right Margin : Esta opção configura a visibilidade da margem direita do 
editor de código-fonte. Recomenda-se deixar esta opção sempre ligada. 
 
Figura 4.3 – Janela Editor Properties, aba General 
 
 Programação em Delphi 5 | Módulo Básico | pági na 34 
Configurando a IDE do Delphi 
Capítulo 4 
 
Visible Gutter : Esta opção 
configura a visibilidade da seção à 
esquerda da janela do editor de 
código-fonte. Recomenda-se 
deixar esta opção sempre ligada, 
pois é nesta seção que podemos 
visualizar os pontos de parada 
para depuração de código 
(breakpoints), os pontos de marca 
(bookmarks) e os pontos com 
tarefas a fazer (todo points). 
 
 Right Margin : Esta opção 
configura o tamanho da margem 
direita do editor de código-fonte. 
Recomenda-se deixar esta opção 
sempre configurada com o valor 
80 ou 120. 
 
Editor Font : Esta opção 
configura a fonte de texto utilizada 
no editor de código-fonte. 
 
Editor Size : Esta opção configura o tamanho da fonte de texto utilizada no editor de 
código-fonte. 
 
Na aba ‘Colors’ é possível configurar as cores e estilos de texto para cada elemento 
da janela do editor de código-fonte. É possível configurar a cor de fundo da janela e a cor e 
estilo de texto de cada categoria de 
palavras chave do Object Pascal. 
 
 Na aba ‘Code Insight’ 
podemos configurar o funcionamento 
do recurso de ‘Code Insight’ do 
Delphi. Este é um dos recursos mais 
úteis para os desenvolvedores 
Delphi. O funcionamento do ‘Code 
Insight’, ou como é chamado mais 
comumente, o ‘Completa Código’ 
consiste em apresentar para o 
desenvolvedor Delphi sugestões de 
código a ser inserido, mostrar para o 
desenvolvedor os parâmetros e tipos 
dos parâmetros de uma função ou 
procedimento no momento que o 
desenvolvedor vai iniciar a digitação 
dos parâmetros da função, e 
apresentar o valor de uma variável 
somente passando o mouse sobre 
ela no código-fonte quando em modo de depuração. 
 
 
 
Figura 4.4 – Janela Editor Properties, aba Display 
 
Figura 4.5 – Janela Editor Properties, aba Color 
 
 
 Programação em Delphi 5 | Módulo Básico | pági na 35 
Configurando a IDE do Delphi 
Capítulo 4 
 
Quando digitando na janela do editor de código-fonte, basta pressionar as teclas CTRL + 
SPACE para que o recurso de Completa Código seja ativado. 
 
Nesta aba podemos configurar as seguintes opções de ‘Code Insight’: 
 
Code Completion : Esta 
opção permite ativar ou desativar o 
recurso de Completa Código do 
Delphi. Recomenda-se deixar esta 
opção sempre ligada. Quando 
ativado, automaticamente o Delhpi 
abre a lista de Completa Código no 
momento adequado. 
 
Code Parameters : Esta 
opção permite ativar ou desativar o 
recurso de exibição dos parâmetros e 
tipos de parâmetros de funções e 
procedimentos quando o 
desenvolvedor vai utilizar no código-
fonte uma função ou procedimento. 
Quando ativado, automaticamente o 
Delphi abre a lista de Completa 
Código no momento adequado. 
Recomenda-se deixar esta oçpção 
sempre ligada. 
 
Tooltip Expression Evaluation : Esta opção permite ativar ou desativar o recurso 
de exibição dos valores de variáveis passando o mouse sobre as mesmas no código-fonte 
em modo de depuração. Recomenda-se deixar esta opção sempre ligada. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Figura 4.6 – Janela Editor Properties, aba Code Insight 
 
 
 Programação em Delphi 5 | Módulo Básico | pági na 36 
Introdução à Sintaxe do Object Pascal 
Capítulo 5 
 
Neste capítulo iremos aprender a sintaxe do Object Pascal. Será apresentado como 
fazer comentários no código-fonte, como declarar variáveis e constantes, quais são os tipos 
de dados que podem ser utilizados no Object Pascal, como declarar novos tipos de dados e 
como realizar operações de comparação, repetição e atribuição. 
 
 
5.1. Comentários 
 Declarações de comentários são colocadas no código-fonte para explicar o que o 
código faz e não são executadas nem processadas pelo compilador. Um comentário pode 
se estender por diversas linhas, e existem três maneiras de colocá-los, como pode ser visto 
na listagem de código fonte abaixo. 
 
01: {============================================== ============ 
02: Esta unit é um exemplo da primeira aplicação em Delphi. 
03: ============================================== ============} 
04: unit uHelloWorld; 
05: 
06: interface 
07: 
08: