Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias
Índice
1 A HISTÓRIA DA LINGUAGEM PASCAL .............................................................................................................. 3
2 INTRODUÇÃO AO AMBIENTE DELPHI ............................................................................................................... 4
2.1 O Form Designer .............................................................................................. 5

2.2 O Code Editor................................................................................................... 9
2.3 Object Inspector.............................................................................................. 13
2.4 Object Tree View............................................................................................ 15
2.5 A Palheta de Componentes............................................................................. 16
2.6 Project Manager e Project Group ................................................................... 17
2.7 Salvando um Layout Personalizado ............................................................... 18
2.8 Customizando as Barras de Ferramentas do Delphi....................................... 19
2.9 Debugando Aplicações ................................................................................... 19
2.9.1 Break Point ............................................................................................. 20
2.9.2 Whatch List ............................................................................................ 21
2.9.3 Evaluate/Modify ..................................................................................... 22
2.9.4 Inspect..................................................................................................... 23
3 ESTRUTURA DOS PROGRAMAS DELPHI ........................................................................................................ 24
3.1 VCL x CLX .................................................................................................... 24

3.2 Projetos ........................................................................................................... 24
3.3 As Units .......................................................................................................... 25
3.4 Formulários..................................................................................................... 26
3.5 Pacotes – Packages ......................................................................................... 27
3.6 Arquivos Compilados ..................................................................................... 28
4 DELPHI LANGUAGE ........................................................................................................................................... 28
4.1 Comentários.................................................................................................... 29
4.2 Declarações..................................................................................................... 29
4.3 O Ponto-e-Vírgula e o Ponto .......................................................................... 30
4.4 Diretivas de Compilação ................................................................................ 31
4.5 Operadores...................................................................................................... 31
4.6 Principais Tipos de Dados .............................................................................. 34
4.6.1 Tipos de Dados Simples ......................................................................... 34
4.6.2 Tipos Estruturados.................................................................................. 39
4.6.3 Tipos Procedurais ................................................................................... 46
4.6.4 Variants................................................................................................... 49
4.6.5 Classes .................................................................................................... 50
4.6.6 Referências de Classe (metaclasses) ...................................................... 53
4.6.7 Interfaces ................................................................................................ 54
4.7 Comandos da Delphi Language...................................................................... 57
4.7.1 Comando de Decisão .............................................................................. 57
4.7.2 Case < X > of.......................................................................................... 60
4.7.3 While . . . do ........................................................................................... 61
4.7.4 For . . . do................................................................................................ 61
4.7.5 Break e Continue .................................................................................... 63
4.7.6 Repeat ..................................................................................................... 64
Prof. Cesar Rodrigo -1-

4.7.7 Tratamento de Exceções......................................................................... 65

4.7.8 O Comando with..................................................................................... 66
4.8 Variáveis e Constantes.................................................................................... 68
4.9 Procedimentos e Funções ............................................................................... 68
4.9.1 Declarando Procedimentos e Funções.................................................... 69
5 COMPONENTES .................................................................................................................................................. 70
5.1 Relacionamentos entre Componentes............................................................. 71

5.2 Propriedades e Eventos Comuns .................................................................... 71
5.3 Componentes mais Usados............................................................................. 73
5.4 TForm ............................................................................................................. 73
5.5 Botões ............................................................................................................. 74
5.6 O Label ........................................................................................................... 75
5.7 Os Edits .......................................................................................................... 75
5.8 O Painel .......................................................................................................... 76
5.9 Barra de Status................................................................................................ 76
5.10 RadioButton.................................................................................................... 77
5.11 CheckBox ....................................................................................................... 77
5.12 RadioGroup .................................................................................................... 77
5.13 ComboBox...................................................................................................... 77
5.14 MainMenu e MenuItem .................................................................................. 78
5.15 PopupMenu..................................................................................................... 79
5.16 Toolbar ........................................................................................................... 79
5.17 ImageList ........................................................................................................ 80
5.18 ActionList e Actions....................................................................................... 80
5.19 Diálogos.......................................................................................................... 81

1 A História da Linguagem Pascal

A linguagem Pascal foi projetada originalmente por Nicklaus Wirth no início de 1960,
mas é considerada uma das primeiras linguagens dos anos 70. Wirth criou o Pascal
com base em uma outra linguagem da época o Algol 68. Ambas as linguagens
estavam baseadas na linguagem Algol 60, mas a Algol 68 era consideravelmente mais
complexa. Wirth criou o Pascal para encapsular o melhor do Algol 68, ele quis criar
uma linguagem menor, mais simples que poderia combinar poder com simplicidade.
Na realidade, Pascal era (e ainda é) usado como uma das primeiras linguagens para
ser apresentada a estudantes de informática. Professores acham que o Pascal é ideal
como a primeira linguagem a ser ensinada, ilustrando a maioria dos principais temas
de programação moderna, com complexidade mínima.
Pascal foi vista principalmente como uma linguagem acadêmica até o lançamento do
Turbo Pascal da Borland em 1984. Embora houvesse outras implementações de
Pascal em computadores pessoal, a primeira versão do Turbo Pascal da Borland era
tecnologicamente superior às outras especialmente em velocidade de compilação
(como dizia o nome "Turbo").
Depois da introdução inicial, a Borland continuou aumentando o produto com a
linguagem Pascal, mudando a arquitetura básica da linguagem na versão 3 (com a
introdução de units) e a versão 5.5 (com a introdução de objetos). O Delphi é o mais
recente em uma longa linha de compiladores Borland Pascal. Na realidade, o Object
Pascal, que é encontrado no Delphi e no Kylix, é uma versão prévia do Borland Pascal
with Objects, Versão 7.1.
Embora exista um padrão ANSI para a linguagem Pascal, aplicado principalmente a
mainframes e versões de Pascal para microcomputadores. A Borland mantém o
próprio padrão da linguagem Pascal para computadores pessoais desde o Turbo
Pascal 1.0.
Manter um padrão único para a linguagem é duplamente vantajoso, e não tão
desvantajoso. Uma desvantagem significante é que a Borland é livre para fazer
qualquer mudança e ajuste à estrutura da linguagem com o perigo de invalidar
programas mais velhos. Porém, a Borland nunca fez isto, e as realidades de
comercialização de ferramentas para PC fazem que tal evento se torne muito
improvável. Na realidade, a maioria dos códigos escritos em Borland Pascal para
Objetos ainda compilará corretamente no Delphi.
Por possuir o padrão da indústria, a Borland tem uma vantagem, pois ela pode fazer
mudanças na linguagem (principalmente aprimoramentos) sem ter que esperar por um
processo de padronização lento e laborioso. Assim, um produto como o Delphi pode
ser lançado com uma versão aumentada de Object Pascal dentro do menor tempo

possível. Em muitos aspectos então, Borland é para o Pascal o que a Sun é para o
Java.
2 Introdução ao Ambiente Delphi

A figura abaixo mostra a tela inicial do Delphi 7 e nos dá uma visão geral de seu
ambiente de desenvolvimento, composto de múltiplas janelas individuais que permitem
executar diversas tarefas, que serão explicadas mais adiante. Seus principais
elementos são:
• Form Designer
• Code Editor
• Object Inspector
• Object Tree View
• Palheta de componentes
• Menu principal
• Barra de ferramentas

2.1 O Form Designer

O Form Designer é a janela vazia que aparece na figura abaixo:
É sobre esta janela que a interface gráfica da aplicação é desenvolvida,

acrescendo-se os componentes com os quais o usuário irá interagir.
Podemos configurar algumas propriedades do form designer através do menu
Tools > Environment Options > Designer mostrado próxima ilustração:

No grupo “Grid Options” podemos escolher se o grid será ou não exibido

(Display Grid) bem como o seu tamanho (Grid Size).
nota: O grid de tamanho 4x4 como o da figura é uma boa opção, pois permite uma boa
visão do alinhamento dos componentes sem ser demasiadamente pequeno
O grupo “Module creation options” permite escolher se o Delphi irá criar

automaticamente ou não novos formulários adicionados ao projeto (Auto create forms
& data modules). Com esta opção desmarcada, apenas o formulário configurado como
“Main Form” será criado automaticamente.
No menu Project > Options > Forms mostrado abaixo, podemos perceber o
efeito desta opção:

No exemplo, temos uma aplicação com 3 formulários, mas apenas aquele

configurado como “Main Form” aparece na lista “Auto create forms”, enquanto que os
outros são configurados apenas como disponíveis em “Available forms”, devendo ser
criados em tempo de execução. Se a opção auto create forms & data modules estiver
marcada, todos os formulários do projeto aparecerão na lista Auto create forms.
nota: a princípio, não desmarque o auto create forms & data modules para evitar
problemas. Se não desejar que os forms sejam criados automaticamente, vá à tela acima
e retire-os da lista dos forms que são criados automaticamente. Aliás, jamais deixe que o
Delphi crie todos os formulários. Deixe para criá-los apenas quando forem necessários e
destrua-os quando terminar de usar. Assim, o programa se torna mais leve e não
consumirá recursos e memória sem necessidade!
Voltando às Environment Options, resta-nos comentar o grupo “Options” que tem

algumas funções interessantes. Em “Show component captions” definimos se o designer
irá ou não mostrar os nomes de componentes não visuais. Veja abaixo como fica fácil
identificar os componentes!

Em “Show designer hints” habilitamos as informações que surgem quando o

mouse é posicionado sobre um componente. “Show extended control hints” permite
exibir informações mais abrangentes sobre um controle, como tab order, top, left, etc.
Veja estas opções em ação abaixo, onde na primeira figura temos a opção “extended
control hints” ativa e na segunda desabilitada:
Mesmo estando inicialmente vazio, o formulário padrão fornecido pelo Form

Designer já possui todas as funcionalidades básicas de uma janela, como minimização,
maximização, restauração, fechamento e redimensionamento, sem que seja
necessária nenhuma programação.
Uma aplicação tipicamente possui um formulário principal e vários outros
chamados a partir dele, que executam funções diferentes dentro do sistema.

Cada formulário criado no Delphi é acompanhado de sua respectiva Unit, que é o

seu código-fonte. Veremos agora a janela responsável pela edição do código-fonte das
Units, o Code Editor.
2.2 O Code Editor

Como foi mencionado anteriormente, o Code Editor (que aparece na próxima
figura) é onde inserimos o código-fonte de nossas aplicações:
Na janela maior, que é o editor propriamente dito, podemos abrir várias Units
ao mesmo tempo, como na figura, para trabalharmos com o código de diversos
formulários simultaneamente. Assim como o Form Designer, o Code Editor também
pode ser personalizado, bastando acessar o menu Tools > Editor Options. Não
mencionaremos todas as configurações possíveis aqui, porque muitas delas já estão
ótimas como estão e devem ser deixadas em paz, e também para não nos
aprofundarmos sem necessidade em assuntos menos importantes. Abaixo, vemos a

palheta Color das propriedades do editor, onde configuramos as cores dos elementos
do código-fonte:
nota: o Delphi 7, por default, configura Strings, comentários e números com a mesma cor
– a Navy. Usar cores diferentes, não importam quais, para estes elementos torna o código
mais fácil de ler, destacando cada tipo diferente de elemento. Assim, não se corre o risco
de comentários serem confundidos com strings, strings numéricas se confundirem com
números verdadeiros, etc.
Em “Code Insight” configuramos os recursos que permitem completar código,

exibir parâmetros de funções em forma de hint, etc., bem como o tempo (delay) após o
qual elas aparecem para o programador. Deixe todas habilitadas, pois são uma mão
na roda!
Prof. Cesar Rodrigo - 10 -

Na palheta “Source Options”, não há necessidade de alterar nada. Tudo está

perfeito como está!
Mas nela encontramos o interessantíssimo recurso “Edit Code Templates”. Os

templates nada mais são do que os modelos de comandos, declarações de procedimentos
e funções, declaração de classes, etc., que podem ser incluídas no código. Assim o
programador pode economizar algumas “tecladas”! Podemos facilmente editar ou
adicionar novos templates através da tela que aparece na próxima ilustração:

Com o botão “Add” podemos incluir um novo template, dando-lhe um “Shortcut

name” e uma descrição. O shortcut é usado para encontrar o template durante a edição.
Na caixa “Code” nós inserimos o código que irá aparecer ao usarmos o template. A barra
vertical pode ser adicionada ao template para mostrar ao editor onde ele deverá posicionar
o cursor quando o template for inserido no código fonte. Os templates ficam no arquivo:
“C:\Arquivos de programas\Borland\Delphi7\Bin\DELPHI32.DCI”
Podemos os DCI’s que nós criarmos para que sejam usados em “Delphis” alheios ou
importar DCI’s de outros delphis para usar no nosso!

2.3 Object Inspector

O Object Inspector é a janela responsável pelo controle das propriedades e
eventos de todos os componentes da aplicação. Ele permite também encontrar
componentes de um formulário facilmente através da lista na parte superior, que exibe
todos os componentes do formulário ordenados alfabeticamente pelos seus nomes. O
Object Inspector pode ser visto na imagem seguinte:
A palheta Properties nos dá acesso a todas as propriedades de visibilidade

published do componente atualmente selecionado para que possamos modificá-las em
tempo de design. A forma de edição de uma propriedade está relacionada ao seu tipo.
Algumas propriedades podem ser alteradas apenas digitando diretamente na linha
correspondente; outras exibem uma lista de valores possíveis, dos quais um deve ser
escolhido; outras podem se expandir – as que tem um ‘+’ antes do nome – e por fim,
existem aquelas que possuem um editor separado – as que possuem uma ‘...’ na linha
de edição.
A palheta Events nos permite criar um corpo vazio de método para
implementarmos o código que será executado ao ocorrer o evento selecionado. Para tanto,
basta darmos um duplo - clique na linha correspondente ao evento ou então um Ctrl +
Enter. Podemos ainda selecionar na lista outros eventos compatíveis com aquele que

estamos para criar. Assim, podemos reutilizar outros eventos ao invés de implementar o
mesmo código várias vezes. Um evento é compatível com outros desde que possuam os
mesmos parâmetros – com os mesmos tipos de dados, mesma ordem e mesma
quantidade, ou seja, se suas assinaturas forem as mesmas.
O Object Inspector pode ser customizado pelo usuário no menu Tools >
Environment options > Object Inspector, mostrado abaixo:
À esquerda podemos mudar as cores dos elementos do Object Inspector e à direita

temos algumas opções de exibição. Por default, a única desabilitada é ‘Show read only
properties’, que define se as propriedades somente leitura, que não podem ser
modificadas, apenas lidas, vão aparecer. Não são necessárias maiores explicações sobre
estas configurações.
Estas opções também podem ser acessadas ao clicar com o botão direito no
Object Inspector. Este procedimento permite também acessar outras configurações que
não aparecem no método descrito acima, como o menu ‘Arrange’. Esta opção disponível
desde o Delphi 5 muda a forma de exibição das propriedades e eventos. O default é
Arrange > By Name, o arranjo tradicional. A opção Arrange > By Category, agrupa
propriedades e eventos por categoria, o que pode facilitar a programação em alguns casos,
como ajuste de tamanho e posição de componentes no Form Designer. Normalmente as
propriedades que ajustam o tamanho e posição, ficam distantes quando exibidas por nome,

mas se as agruparmos; poderemos visualizar todas em um grupo. Veja o aspecto das

propriedades agrupadas por categoria:
2.4 Object Tree View

O Object Tree View é a janela localizada por default logo acima do Object
Inspector. Ele nos dá uma visão hierárquica dos componentes do formulário, com
visão em árvore. Através dele podemos ver em qual container – Panel, GroupBox,
ScrollBox, o próprio Form, etc., chamados em Delphi de ‘Parents’ dos componentes
dos componentes neles contidos – cada componente está contido, podendo inclusive
transferi-lo de um parent para outro. Para isto, basta arrastá-lo para cima do ícone do
novo parent e ele será mudado para lá sem perder o valor de suas propriedades.
Pode-se inclusive deletar um componente pelo Object Tree View. Outra facilidade
oferecida por ele diz respeito a localização de componentes. Às vezes, de acordo com
nosso layout, alguns componentes podem ficar de difícil acesso pelo Form Designer,
tanto visualmente quanto pelo mouse. O Object Tree View pode nos ajudar a
encontrá-los nestes casos. Veja uma ilustração do Tree View logo abaixo:

2.5 A Palheta de Componentes

A palheta de componentes é uma barra de ferramentas onde se encontram
todos os componentes que o desenvolvedor irá utilizar ao programar. Ela está dividida
em várias palhetas onde os componentes são agrupados. Como o Delphi 7 possui
inúmeras palhetas diferentes, elas serão vistas gradualmente na medida em que
trabalhamos, teremos aqui apenas uma visão geral. Abaixo está uma visão da palheta
de componentes do Delphi 7. Na ilustração ela foi destacada da barra de ferramentas
principal apenas para melhorar sua visualização:
Algumas palhetas de componentes importantes são:
• Standard
Nela estão os componentes básicos de uma interface gráfica: Edit, Button,
ComboBox, RadioButton, CheckBox, MainMenu... Sem dúvida é a mais usada.
• Additional
Sob certos aspectos é semelhante à Standard, mas possui componentes de
interface mais incrementados como BitBtn, SpeedButton, MaskEdit e StaticText.
Além disso, é nela que estão componentes de imagem (Image) e de gráficos
(Chart)
• Win32
Nesta palheta podemos encontrar componentes para barra de status, barra de
progresso, barra de ferramentas, calendário, etc. Também temos o PageControl,

que nos permite criar um layout de palhetas, como a própria palheta de

componentes.
• System
Seus principais componentes são o Timer, que representa um contador de
tempo e o MediaPlayer, para executar arquivos de som e filmes.
• DataAccess
Possui componentes que comunicam componentes se acesso a banco de dados
com os componentes da DataControls. Com destaque para o DataSource,
ClientDataSet e DataSetProvider.
• DataControls
Semelhantes aos da Standard, porém com a capacidade de editar dados
diretamente nos campos de tabelas do banco de dados.
• Dialogs
Possui componentes que encapsulam os principais diálogos do Windows como o
diálogo de fonte, de salvar arquivo, de abertura de arquivo, de impressora, entre
outros.
• dbExpress, ADO, InterBase, BDE
Estas palhetas contém componentes para conexão e acesso a bancos de dados,
cada um para um tipo de conexão diferente.
2.6 Project Manager e Project Group

Às vezes, pode acontecer de um único sistema ser composto de vários projetos
separados, como aplicações ou pacotes, que representam vários módulos deste
sistema. Assim, surge a necessidade de uma forma de navegação rápida entre os
projetos distintos do sistema.
Mas, como o Delphi abre apenas um projeto de cada vez, como podemos
navegar pelos projetos sem ter que abrir e fechar projetos a todo instante? A resposta
está no Project Group!
O Project Group é um arquivo com extensão “.bpg” onde o Delphi guarda a
informação de todos os projetos separados que fazem parte de um único sistema
maior. E o Project Manager é a janela responsável por criar e gerenciar os Project
Groups, bem como fazer a navegação entre os diversos projetos agrupados nele. Na
figura abaixo, podemos ver como é o Project Manager.

Na figura vemos 5 diferentes programas num mesmo Project Group. Cada um

deles é um projeto separado dos demais, mas como eles estão relacionados entre si,
agrupa-los num Project Group torna seu gerenciamento mais fácil.
A raiz da árvore de projetos é o Project Group, o arquivo .bpg. Para criar um
novo projeto nele, basta clicar com o botão direito do mouse e escolher “Add New
Project...” O Delphi abrirá a janela New Itens para que o usuário selecione o tipo de
projeto a adicionar. Mas se desejarmos simplesmente adicionar um projeto já pronto
ao grupo, sem segredo! Basta escolher a opção “Add Existing Project...” e selecioná-lo!
2.7 Salvando um Layout Personalizado

Quando existem vários programadores trabalhando com o mesmo Delphi,
podem surgir divergências quando à disposição e ao tamanho das janelas do
ambiente que cada um gosta de usar.
Gosto não se discute, mas chegar ao trabalho e ver que algum colega bagunçou
todo o seu ambiente é realmente irritante! Para solucionar estes pequenos problemas, o
Delphi permite desde a versão 5 que cada usuário ajeite as janelas como bem entender e
salve o resultado. Assim, cada usuário pode ter o seu layout de volta sempre que desejar!
Para isso, basta utilizarmos a barra de ferramentas abaixo:
Lista de layouts salvos

Salva um layout
Ativa layout selecionado

Os layouts são salvos na pasta Bin do Delphi, em arquivos com extensão .dst.
Assim, podemos fazer um backup deles para que seu layout favorito não se perca!
2.8 Customizando as Barras de Ferramentas do Delphi

Também é possível personalizar os botões das barras de ferramentas do
Delphi. Basta ir ao menu View > Toolbars > Customize...
Basta arrastar os botões para uma das barras de ferramentas do delphi e ele
será adicionado!
nota: é interessante colocar alguns botões como o de compilar e os de find, replace e find
in files que são bastante usados e ajudam muito!
2.9 Debugando Aplicações

A IDE do Delphi oferece diversas ferramentas para testarmos nossos
programas e procurar erros difíceis de encontrar. Dentre estas inúmeras ferramentas,
veremos apenas as mais frequentemente utilizadas. Assim, estudaremos os Break
points, a Watch List, o Evaluate/Modify e o Inspect.

2.9.1 Break Point

Os Break Points são pontos determinados pelo programador onde o programa
irá parar de executar para que se possa analisar o código-fonte em busca de erros.
Durante a pausa na execução, podemos com o cursor do mouse observar valores de
variáveis, de propriedades de objetos, etc. Também é possível continuar executando o
programa passo a passo, com os comandos “Trace Into” e “Step Over”. Abaixo vemos
um Break Point:
Para colocar/retirar um Break Point, basta clicar na margem cinza da esquerda

(onde fica o círculo vermelho) ou então dar um F5 com o cursor na linha
correspondente. Quando o programa for executado, a execução vai parar quando
chegar neste ponto. Para fazer a execução passo a passo, podemos dar um F7 (trace
into) ou F8(step over), que fazem com que apenas a próxima linha seja executada. A
diferença entre os dois é que se numa linha houver chamada para um procedimento
ou função, o F7 entra na sub-rotina, enquanto que o F8 executa a sub-rotina sem
entrar nela.
Agora um caso comum: imagine que temos um trecho de código que executa
uma repetição de 0 a 100. Mas aí ocorre um erro neste trecho! Então recorremos ao
Break Point para descobrir o que há de errado. Então executamos e fazemos um F8;
iteração 1... nada; iteração 2.. nada; 20... nada; 55... nada! Depois de muita luta
descobre-se que o erro ocorre na iteração 100 (a última!), mas não se sabe por que

ele ocorre só nessa iteração. Mas como fazer para que o programa só pare na
iteração 100 para inspecionarmos o código e descobrir o erro? Pois o Break Point
possui um editor onde podemos entre outras coisas, definir uma condição de parada!
Para tanto, é só clicar com o botão direito no círculo vermelho e ir ao menu “Break
point properties...” para exibir a tela abaixo:
No campo “Condition” basta informar a condição de parada tipo “Contador =

100” (a condição tem a sintaxe do Delphi mesmo, igual as que se usa nas condições
de comandos como if e while). Aí sim ele só vai parar na 100ª iteração, onde está o
erro!
2.9.2 Whatch List

É uma lista de variáveis ou propriedades cujos valores queremos vigiar
enquanto o programa executa. Todas as mudanças que ocorrerem nas variáveis da
lista são exibidas na Whatch List.
Para adicionar uma variável à Whatch List, Basta clicar com o botão direito nela
e ir ao menu Debug > Add watch at cursor que aparecerá a telinha:

Os valores das variáveis em Watch Name aparecerão ao lado na coluna Value.

Quando queremos observar valores de propriedades de objetos, a whatch não
funciona... Isso acontece devido ao fato de que algumas propriedades possuem
métodos de acesso internamente. Para permitir chamadas à funções na Whatch List,
devemos clicar com o botão direito na variável e acessar o menu “Edit watch”:
Marque “Allow Function Calls” e pronto!
2.9.3 Evaluate/Modify
Usado para ver e modificar valores de variáveis e propriedades em tempo de
execução. Pode ser acessado no menu Debug > Evaluate/Modify que aparece ao
clicarmos com o botão direito no Code Editor:
Passamos a ele uma expressão ou variável e em Result obtemos seu valor

naquele momento da execução. Em “New value” podemos atribuir um novo valor para

a expressão (desde que seja algo que possa receber valor! Nada de querer atribuir um
novo valor para uma função, por exemplo!). Uma característica interessante do
Evaluate é que ele dá acesso para outros debuggers como os watches e o inspect,
que será visto a seguir.
2.9.4 Inspect
O inspect é uma janelinha bem parecida com o Object Inspector que nos
permite observar todas as propriedades possíveis de um elemento passado para ele.
Se passarmos um componente por exemplo, podemos ver os valores de todas as suas
propriedades, inclusive as posições de memória onde seus métodos estão alocados!
Vejamos um Inspect em ação exibindo os dados de um formulário:
Assim como o Evaluate/Modify, o Inspect permite que os valores sejam

alterados. Se clicar nele com o botão direito, aparece um menu onde podemos
configurar algumas características do Inspector, bem como mudar o valor que se está
inspecionando, fazer typecasts, etc.
nota: Todos os debuggers vistos devem trabalhar em conjunto com os Break Points, pois
não faz muito sentido analisar um trecho de código ou o estado atual de um componente
com o programa em “movimento”. Até por que ele executa em milésimos de segundo!

3 Estrutura dos Programas Delphi
3.1 VCL x CLX

VCL é a biblioteca padrão utilizada pelo Delphi para o desenvolvimento na
plataforma Win32, e conta com toda a API, os componentes, etc. Mas a partir do
Delphi 6, surgiu uma nova API, chamada CLX, que permite fazer um intercâmbio de
projetos entre o Delphi e o Kylix. Uma aplicação feita com os componentes da CLX
podem ser portadas de Windows para Linux e vice-versa. Para tanto, basta abrir um
projeto Delphi no Kylix e recompilar, podendo-se fazer o mesmo do sentido inverso.
Para criarmos uma aplicação CLX só precisamos fazer File > New > CLX Application e
pronto! Apenas substituímos o tradicional New Application por New CLX Application!
Mas existem algumas diferenças. Pode-se perceber que a palheta de componentes
muda. Isso porque os componentes da CLX não podem ser os mesmos da VCL, e
eles foram totalmente refeitos. Assim, uma CLX Application possui bem menos
componentes disponíveis que a VCL.
3.2 Projetos
Um projeto Delphi, na verdade, é o programa propriamente dito e sua sintaxe é
idêntica à do Pascal. Este programa apenas cria os formulários, onde efetivamente se
concentram todas as funcionalidades da aplicação (mas existem as aplicações
console, que não usam formulários, e aí sim as funcionalidades devem se concentrar
no programa!). O projeto é armazenado pelo Delphi em um arquivo com extensão .dpr
e para visualizar seu código fonte, basta ir ao menu Project > View Source:

Perceba que o nome do programa é o nome do projeto, portanto, observe este

detalhe ao salvar o projeto! Vemos que o objeto global Application é que realiza todo o
trabalho num programa visual, tanto na criação dos formulários quanto na execução em si.
3.3 As Units
As Units são arquivos que representam uma coleção de tipos, classes,
procedimentos, funções, constantes, etc. que podem ser importadas e utilizadas durante o
desenvolvimento. Vamos dar uma olhada na estrutura de uma Unit vazia:
Em “unit” fica o nome do arquivo correspondente à unit, que também será o nome
utilizado ao importá-la. Após isso, vêem as 4 seções nas quais uma Unit pode ser dividida:
• Interface: é a seção pública da Unit. Tudo que for declarado aqui será visível fora
da Unit. Nesta seção ficam declarados todos os “serviços” oferecidos pela Unit, que
depois devem ser implementados na seção implementation.
• Implementation: esta seção é onde implementamos procedimentos, funções e
classes declaradas na seção interface. Esta seção é privada, ou seja, seus
elementos são visíveis apenas dentro da Unit. É possível fazer declarações de

classes, sub-rotinas e outros elementos em implementation da mesma forma que

em interface, mas elas se tornam privadas da Unit.
• Initialization: seção usada para inicializar elementos da Unit no momento em que
ela é carregada para ser usada no programa. É possível tanto inicializar variáveis
quanto para instanciar objetos ou abrir arquivos.
• Finalization: seção com função oposta à da initialization, servindo para fazer a
finalização de elementos e liberação de recursos usados por elementos da Unit.
Pode-se, por exemplo, destruir objetos criados ou fechar arquivos abertos em
initialization.
Destas 4 seções, as duas primeiras – interface e implementation – são obrigatórias

e não podem ser omitidas. Já as duas últimas – initialization e finalization – são opcionais.
As Units são armazenadas em arquivos com extensão .pas, tanto na VCL quanto na CLX.
3.4 Formulários
Os formulários criados através do Form designer são serializados pelo Delphi
em arquivos de texto com extensão .dfm (VCL) ou .xfm (CLX), e devido a isso, não
vemos nenhum código de inicialização para instanciar componentes ao criar um
formulário, como acontece em IDE’s Java.
Esses dados serializados são incorporados ao executável em forma binária
durante a compilação e ao executar o programa, os componentes são criados com base
nestas informações serializadas. Isso acaba por deixar o código fonte de um formulário
mais limpo, pois apenas a parte que foi implementada pelo desenvolvedor fica visível na
Unit. Vamos dar uma “espiada” no conteúdo de um dfm de um Form bem simples:

Todas as propriedades que foram modificadas no Object Inspector são

armazenadas neste formato. Assim, quando o executável instanciar os componentes, ele
poderá acessar estes valores e configura-los conforme foi definido em tempo de projeto!
Podemos acessar o dfm como foi feito acima clicando com o botão direito no
formulário e selecionando View as Text. Para voltar é só fazer o mesmo no dfm, só que
neste caso é View as Form.
3.5 Pacotes – Packages

Os pacotes são utilizados em Delphi para criar bibliotecas que podem ser usadas
por uma aplicação, como se fossem um tipo especial de dll, onde se pode armazenar
formulários, Units independentes, entre outras coisas. O próprio Delphi se utiliza dessas

bibliotecas o tempo todo. Qualquer componente instalado na IDE, por exemplo, deve estar
armazenado num pacote, que é instalado posteriormente no Delphi. Os pacotes, assim
como os programas e os Project Groups, são considerados projetos pelo Delphi e são
salvos com a extensão .dpk. Ao serem compilados, os pacotes geram dois tipos de
arquivos, os dcp e os bpl. Os dcp servem para que um pacote importe outros que ele
precise usar. Já os bpl são as tais bibliotecas tipo dll citadas acima. São eles os arquivos
que podem ser usados por programas Delphi, inclusive o próprio Delphi.
3.6 Arquivos Compilados

Vimos acima os arquivos que o Delphi cria ao salvarmos nosso trabalho.
Porém, ao compilarmos estes arquivos, outros são gerados.
As Units dão origem aos arquivos dcu. São estes arquivos que o Delphi lê
utilizamos elementos de uma Unit importada, tanto que comumente nos deparamos com
erros do tipo “File not found: UnitX.dcu”, o que significa que o Delphi não está encontrando
o arquivo dcu da Unit que queremos usar.
Já os arquivos dfm (ou xfm) junto com os dpr, geram o executável da nossa
aplicação. Existem outros arquivos gerados durante a compilação como res, cfg, ddp, etc.
mas que não são essenciais ao projeto, podendo ser excluídos sem maiores problemas. O
Delphi simplesmente os criará novamente. São arquivos que guardam configurações do
projeto e algumas outras informações.
4 Delphi Language
Veremos agora a sintaxe da linguagem Delphi, seus principais comandos, declarações e
tipos de dados. Alguns podem se perguntar “mas não é Object Pascal???”. Sim, era
mesmo, só que a Borland oficializou o nome da linguagem como Delphi mesmo há pouco
tempo atrás (note inclusive que no help do Delphi 7 aparece “Delphi Language Reference”
no cabeçalho ao invés de “Object Pascal Reference”). Mesmo assim ainda podemos
encontrar muito material, mesmo recente, ainda se referindo a ela como Object Pascal.

4.1 Comentários
Existem três tipos de marcadores de comentário em Delphi:
Símbolo de início Símbolo de Descrição

término
{ } Bloco unário de comentário. Tudo entre as
chaves é ignorado.
(* *) Bloco binário de comentário. Tudo entre"(*"
e" *)" é ignorado.
// Comentário de linha. Tudo do marcador de
comentário para o fim da linha atual é
ignorado.
Você pode usar marcadores fixos de comentário, mas você não pode iniciar um
comentário com um tipo de marcador de comentário e terminar usando outro. Com a
exceção do marcador de comentário de linha '/ /', os comentários no Delphi podem
atravessar linhas múltiplas.
Podemos usar os tipos diferentes de comentários para propósitos diferentes,
como um para colocar observações no código – o comentário propriamente dito – e
outro para desabilitar código fonte ao invés de deletar.
4.2 Declarações
Programas, procedimentos, e funções são todos compostos de declarações. Cada
declaração cria uma linha executável de código.
Declarações podem ser simples ou compostas. Exemplos de declarações simples são
ilustrados por atribuição a variáveis simples, atribuição de função, e chamadas de
procedimento.
X := 10; //atribuindo o valor X := 10

Produto := 'Delphi'; //Atribuindo o conteúdo ‘Delphi’ na variável Produto
Calcula_Soma; {Executando a função Calcula_Soma}
Você também pode ter declarações compostas onde você poderia ter uma declaração
simples. Uma declaração composta é um agrupamento de declarações tratadas como
um bloco.
O começo de uma declaração composta sempre é delimitado pela palavra reservada
BEGIN. O fim de uma declaração compostas é delimitado pela palavra reservada END.

Aqui está um exemplo de uma declaração composta:
if X = 10 then
begin
ShowMessage( X é igual a 10' );
X:= 11;
end;
4.3 O Ponto-e-Vírgula e o Ponto

Em Object Pascal você pode criar linhas múltiplas de código livremente quando estiver
criando uma única declaração. O mais difícil de entender é que há algumas situações
onde você não pode usar um ponto-e-vírgula, e outras situações onde seu uso é
exigido obrigatoriamente para garantir o fluxo do programa.
Então aqui está a regra: um ponto-e-vírgula tem que separar todas as declarações em
um programa Pascal. Esta regra se aplica em ambos os casos, de declarações
simples e compostas. A regra ajuda explicar por que nunca há um ponto-e-vírgula
depois um Begin, como também por que o ponto-e-vírgula antes de qualquer palavra
chave é opcional.
Para melhor ilustrar, note no código abaixo que a instrução de atribuição não tem um
ponto-e-vírgula depois dela. Um ponto-e-vírgula não é requerido porque não há uma a
declaração imediatamente. Reciprocamente, a declaração end tem que ter um ponto-
e-vírgula depois dela, porque marca o fim da declaração composta.
if X = 10 then
begin
ShowMessage( X é igual a 10' );
X := 11 //Note que essa linha não possui “;”
end;
Outro ponto de dúvidas comum para novatos é quanto ao uso de End sem que o
Begin apareça. Na maioria dos casos, a paridade do Begin . . End existe. Porém, há
alguns casos em que onde você tem um End sem Begin. A ocorrência mais comum
disto é a instrução Case, mas há outros (por exemplo, em blocos try . . . finally, para
uso dentro de definições de registro, etc.). O melhor modo para ficar confortável com
este tipo de omissão é se lembrar que outra palavra chave ou construtor sempre será

achado para estar substituindo a declaração Begin, ou que uma declaração End
sempre será encontrada para ajudar a terminar uma declaração.
Mais uma nota sobre pontuação em programas Object Pascal: o End final do
programa é seguido por ponto e não por um ponto-e-vírgulas. O ponto final indica ao
compilador que é o fim do programa.
4.4 Diretivas de Compilação

São tags colocadas para mudar o comportamento do compilador num certo
trecho do código. Uma diretiva de compilação bem conhecida por todos é a {R$ *.dfm}
que controla a serialização do formulário para o arquivo dfm. Apenas como
curiosidade, dê uma olhada no código de algumas Units padrão do Delphi (dando Ctrl
+ click no nome delas no uses) como SysUtils por exemplo e note que elas estão
infestadas de diretivas de compilação, muitas delas responsáveis por configurar a
compilação de uma parte do código de acordo com o sistema operacional, se Linux ou
Windows.
4.5 Operadores
O operador de atribuição em Delphi é o sinal de dois pontos-igual (":="). É diferente do
sinal igual ("=") que é usado para testar igualdade e para definição de tipos.
Se você estiver vindo C, você terá que se acostumar a usar sinal de igual (‘=’) “normal”
(unário) para testar para igualdade, e o operador de atribuição binário (:=) para fazer
atribuição. Note que não há nenhum sinal de igual binário ("= =") testar para igualdade
em Pascal.
A seguir temos um resumo dos principais operadores presentes em Delphi,

bem como os tipos de operando aos quais eles se aplicam, o tipo de dado resultante
da operação e a categoria a que eles pertencem.

Operadores Aritméticos
Operador Operação Tipo operando Resultado Exemplo
+ adição integer, real integer, real X+Y
+ unário sinal positivo integer, real integer, real +X
- subtração integer, real integer, real X–Y
- unário sinal negativo integer, real integer, real -X
* multiplicação integer, real integer, real X*Y
/ divisão real integer, real real X/Y
div divisão inteira integer integer X div Y
mod resto da divisão integer integer X mod Y
Operadores Booleanos
not negação (não) boolean boolean not X
and conjunção (e) boolean boolean X and Y
or disjunção (ou) boolean boolean X or Y
xor ou exclusivo boolean boolean X xor Y
Operadores Lógicos de Bits (Bitwise)

Tipo
Operador Operação Resultado Exemplo
operando
not negação de bits integer integer not X
and and de bits integer integer X and Y
or ou de bits integer integer X or Y
xor xor do bits integer integer X xor Y
deslocamento de bits à esquerda
shl integer integer X shl 2
(shift left)
deslocamento de bits à direita
shr integer integer X shr Y
(shift right)
Operadores de String
+ concatenação string string ‘Delphi’ + ‘7’

Operadores de Conjunto (Set)

+ união set set X+Y
- diferença set set X–Y
* interseção set set X*Y
in pertinência set, ordinal boolean X in Y
Operadores de Classe
objeto tratado
objeto, como sendo Sender as
as typecast
classe/interface instância da TButton
classe/interface
objeto é
objeto,
is instância de boolean Sender is TEdit
classe/interface
classe
Operadores Relacionais (Comparação)

Operador Operação Resultado Exemplo
= igualdade boolean X=Y
<> diferença boolean X <> Y
< menor que boolean X<Y
> maior que boolean X>Y
<= menor ou igual boolean X <= Y
>= maior ou igual boolean X >= Y
Vejamos agora os operadores com relação à precedência:
• Primeiro nível (mais alta): not

• Segundo Nível: *, /, div, mod, and, shl, shr, as
• Terceiro Nível: +, -, or, xor
• Quarto Nível (mais baixa): <>, =, <, >, <=, >=, in, is

Além destes, existe ainda o operador de atribuição := , também de baixa

precedência, responsável por atribuir o valor de uma expressão ou variável em
outra variável.
4.6 Principais Tipos de Dados

Os tipos de dados presentes no Delphi são basicamente os mesmos do Pascal
tradicional, porém com o acréscimo dos tipos de dados classe e interface, para o
suporte à programação orientada a objetos. Os tipos de dados podem ser simples ou
estruturados, além de String e outros como Variant e os tipos procedurais, usados na
implementação de eventos. Os tipos de dados novos criado pelo programador devem
estar dentro de uma seção type na Unit.
nota: por convenção, todo nome de tipos de dados criados pelo usuário, como os que
vamos fazer mais a frente, deve começar com “T” de type
4.6.1 Tipos de Dados Simples

Os principais tipos de dados simples são Integer (números inteiros), Real (ponto
flutuante), Char (um caracter), Boolean (true ou false), as enumerações e as sub-ranges.
4.6.1.1 Enumerações
Como Integer, Real, Char e Boolean são bem simples, vamos nos deter aos dois
últimos. As enumerações são tipos de dados compostos por uma lista de valores
constantes, sendo que uma variável deste tipo pode assumir apenas um destes valores
por vez. Exemplo:

Aqui, declaramos o tipo TMoeda na seção type de uma Unit e em seguida uma
variável deste tipo na seção var, chamada Moeda. Depois, a inicializamos com o valor
mdDolar na seção opcional initialization da Unit. A variável Moeda só pode assumir um dos
4 valores definidos para o tipo TMoeda. As enumerações são amplamente utilizadas no
Delphi e podemos ver várias propriedades deste estilo, como por exemplo, a propriedade
Align, presente em vários componentes visuais como o formulário.

4.6.1.2 Sub-range
Os tipos sub-range são criados simplesmente restringindo o conjunto de valores de
um tipo qualquer. Vamos ver um exemplo:
Neste caso, criamos o tipo TPorcentagem pela restrição de valores do tipo Integer
(que possui um intervalo de -2147483648 à 2147483647). Assim, uma variável do tipo
TPorcentagem só pode receber um valor que esteja entre 0 e 100.
A criação de um sub-range não se restringe aos números. Pode-se fazer a mesma
coisa com caracteres e até mesmo com enumerações.
4.6.1.3 String
Versões mais velhas de Pascal implementaram strings como arrays de 8-bits de
caractere. Porém, há vários problemas com o tipo string original do Pascal. Primeiro, é
limitado a só 255 caracteres. Segundo, não termina com um 0 binário (caractere nulo).
Considerando que a string terminada em nulo é muito utilizada em Windows, UNIX, e
outros sistemas operacionais escritos principalmente em C e linguagem assembly, o
programador é forçado a converter strings de Object Pascal para strings terminadas
em nulo.
Por causa destas e outras limitações, o Delphi 2.0 introduziu um tipo novo de string.
Este tipo novo substitui os strings mais velhos. Assim, como char, há dois tipos de

string em Object Pascal: short strings e long strings. O short string é o tipo
tradicional do Object . O long strings é alocado dinamicamente e administrado
automaticamente para você; pode ter o tamanho que a memória disponível permita, e
sempre é terminado em nulo.
Cada tipo de string (longo e curto) inclui um contador de referência escondido que o
Delphi mantém. Quando o contador de referência para da string for igual a zero, a
memória é limpa automaticamente.
Strings, como caracteres, também são delimitados por aspas simples. Se você
precisar colocar uma aspas simples dentro de uma string, coloque duas aspas
simples lado a lado, assim a linguagem Object Pascal os interpretará como uma única.
Você pode usar os operadores relacionais padrão já discutidos para comparar strings,
Object Pascal tem uma grande variedade de procedimentos de manipulação de
strings embutidos. Você também pode tratar strings como se elas fossem array de
caracteres.
Por exemplo, obter os 2º e 3º caractere de uma string e os colocar em chars:
var
s : string;
ch1, ch2 : char;
begin
s := 'Hello';
ch1 := s[1];
ch2 := s[2];
ShowMessage( 'Caracteres 1 e 2 são ' + ch1 + ' ' + ch2 );
end;
Quanto ao tipo String, ele é tratado pelo Delphi como uma cadeia de caracteres e
pode-se acessar seus elementos como se ele fosse um array, que se inicia na posição 1 e
vai até a posição n, além de também podermos declarar uma variável String com um
número limitado de caracteres. O exemplo a seguir ilustra este tratamento dado às Strings:

nota: o Delphi fornece várias funções para trabalhar com strings, dentre elas podemos
destacar:
Delete(string qualquer, índice inicial, nº. de caracteres) – exclui uma parte de uma string,
sendo que a parte começa em ‘índice inicial’ e tem o tamanho passado em ‘nº. de
caracteres’.
Copy(string qualquer, índice inicial, nº. de caracteres) – função que retorna uma cópia de
parte de uma string passada como argumento. O significado dos argumentos é o mesmo
de Delete.
Insert(substring, string destino, inicio) – insere a ‘substring’ do 1º argumento dentro da

‘string destino’ começando na posição dada em ‘início’.

Pos(substring, string) – se a ‘substring’ está contida dentro da ‘string’, esta função retorna
o índice de onde a ‘substring’ começa. Agora, se não existir a ‘substring’ dentro da ‘string’,
ela retorna zero.
4.6.2 Tipos Estruturados

Vejamos agora os principais tipos estruturados suportados pelo Delphi. Um tipo
estruturado é aquele que pode conter mais de um valor, além de poder ser construído
utilizando-se outros tipos estruturados, formando níveis de estrutura ilimitados.
Os principais tipos estruturados são sets, arrays, records, files assim como classes,
interfaces e referências de classes.
4.6.2.1 Sets
Os sets são tipos que representam um conjunto de valores, assim como os
conjuntos que aprendemos na matemática, podendo-se realizar operações como união,
intersecção e pertinência sobre eles (veja na tabelinha de operadores e operações de
conjuntos). Porém, os sets têm uma limitação em relação aos outros tipos estruturados;
eles só suportam a criação de conjuntos de tipos ordinais. Mas o que é um tipo ordinal? É
um tipo de dados cujos valores possuem uma ordem. Integer é um tipo ordinal (-2, -1, 0, 1,
2,...), Boolean (False, True), Char também (‘a’, ‘b’, ‘c’,...) por que são usados os códigos
ASCII dos caracteres e as enumerações, cujos valores são tratados internamente como
números inteiros (o compilador do Delphi não entende o ‘mdDolar’ que fizemos acima
diretamente como foi declarado, mas como um número) Bem, vamos ver um set em ação:

Podemos ver um set (TMoedas) construído a partir de uma enumeração (TMoeda).

Com ele podemos fazer conjuntos de valores de TMoeda. Este tipo de construção é
amplamente usado no Delphi em propriedades de componentes. Dê uma olhada na
propriedade Font de algum componente e procure por Font.Style. Pois bem, esta
propriedade é do tipo TFontStyles que por sua vez é um set de uma enumeração, o
TFontStyle, exatamente como fizemos com as moedas.
4.6.2.2 Arrays
Vamos aos arrays, também conhecidos por aí como vetores. Arrays são listas de
elementos do mesmo tipo de dados, em que cada elemento possui um índice onde é
armazenado. Em Delphi, os arrays podem ser estáticos ou dinâmicos.
Os arrays estáticos são aqueles que possuem nº. fixo de elementos, definido
durante a declaração, que não pode mudar em tempo de execução. Diferentemente de
outras linguagens, o Delphi permite que os índices de um array estático comecem a partir
de qualquer número inteiro, mesmo negativos. Vejamos a declaração de arrays estáticos:

Neste exemplo podemos ver a flexibilidade na criação dos índices para um array,
bem como as formas para ler e escrever nos índices.
Só até aí vimos vetores, ou seja, arrays unidimensionais. Vamos ver agora como
criar matrizes, os arrays multidimensionais:

Podemos notar duas formas de trabalhar com matrizes, a forma “array de array” e
a forma “direta”, que trata a matriz diretamente como matriz. Podemos usar estas duas
formas tanto na declaração como também durante a leitura e escrita de elementos.
Agora os arrays dinâmicos. Estes são os que podem esticar ou encolher durante a
execução do programa. Outra diferença entre eles e os estáticos, além do dinamismo é
claro, é que arrays dinâmicos SEMPRE começam no índice zero (o que implica que não
podemos fazer aquela brincadeira do “array negativo” com eles!) e devem ser declarados
sem índices.
Para trabalharmos com arrays dinâmicos, podemos utilizar algumas rotinas do
Delphi que permitem realizar a mudança de tamanho e a obtenção do tamanho e do maior
e menor índices. Vamos a elas:
• SetLength(array, novo tamanho): Esse é o procedimento que faz o array dinâmico

(passado ao parâmetro array) mudar de tamanho (definido no parâmetro novo
tamanho).
• Length(array): esta função retorna o tamanho (número de elementos) de do array
passado à ela. Esta função também funciona com Strings!

• Low(array): Retorna o menor índice do array. Só que nos arrays dinâmicos é

desnecessária já que eles sempre começam do zero.
• High(array): Retorna o maior índice do array.
Ao utilizar estas rotinas em conjunto, podemos manipular perfeitamente os arrays

dinâmicos, cabendo aqui uma observação importante: um array dinâmico recém-declarado,
vazio, tem os seguintes valores para as funções acima: Lenght = 0, Low = 0, High = -1 (o
maior índice é menor que o menor índice!). este conhecimento é útil para fazer alguns
testes como array vazio por exemplo. Eis um código para ilustrar:
Neste exemplo, temos um procedure que adiciona um elemento ao array dinâmico

no índice passado como argumento. Se o índice for menor que zero, disparamos uma
exceção do tipo EListError com uma mensagem. Se o índice for maior ou igual ao
comprimento (length) do array, devemos fazê-lo crescer até o tamanho índice + 1 para
poder gravar o elemento no índice desejado. Imagine que o array esteja com 3 elementos
(length = 3) e com índices variando entre 0 e 2. Aí mando adicionar um elemento no índice
10. Para isso, preciso esticar o array até o tamanho 11, para que seus índices variem de 0
a 10. Dessa forma posso inserir o elemento no índice 10 como foi pedido!

E se quisermos uma matriz dinâmica? Sem problemas! O processo é bem parecido

com as matrizes estáticas. Veja só:
Neste caso, só podemos declarar no estilo “array de array”, já que pra fazer a
declaração de matriz “direta” precisaríamos de índices. Para inicializá-las com SetLength,
temos duas alternativas: na primeira, a mais fácil, acrescentamos mais parâmetros à
SetLength de acordo com o nº. de dimensões. A outra, mais complexa, consiste em criar
1º as linhas, sem as colunas, para depois criar as colunas de cada linha, uma por uma.
Esta abordagem, embora trabalhosa, tem suas vantagens, pois ganhamos a flexibilidade
de criar uma matriz em que cada linha tem um nº. diferente de colunas, o que não é
possível da primeira forma.

4.6.2.3 Records (registros)

Os records são estruturas capazes de guardar elementos de tipos diferentes, onde
cada elemento é chamado de campo. Vamos ao exemplo:
Criamos um record com 3 campos, cada um de um tipo diferente e 3 variáveis

cujos tipos correspondem a cada tipo do record. Depois gravamos alguns dados no
registro e a seguir os lemos e atribuímos às variáveis. Os campos de um record são
acessados pelo operador “.”.
4.6.2.4 Files
Os files ou arquivos são seqüências de dados de mesmo tipo que podem ser
persistidos em disco – como arquivos! Existem diversas rotinas no Delphi para
manipular arquivos, das quais veremos algumas a seguir:

• AssignFile(arquivo, nome do arquivo): Associa uma variável file a um nome de

arquivo físico. Aos aplicar AssignFile, podemos usar a variável para manipular o
arquivo físico associado à ela.
• Rewrite: Abre um arquivo, porém limpando todo o conteúdo anterior, se houver.
• Reset: Abre um arquivo e posiciona no início, sem apagar conteúdo anterior.
• FileExists(nome do arquivo): Retorna verdadeiro se o arquivo cujo nome foi
passado como argumento existe.
• Write(arquivo, valores): Escreve no arquivo referenciado por uma variável file os
valores passados na lista de valores. Os valores devem ser do tipo de dado que o
arquivo armazena.
• Writeln(arquivo, valores): Faz o mesmo que o write, só que solta uma linha para
cada valor.
• Read(arquivo, valores): Lê dados do arquivo referenciado pela variável do tipo file
passada ao parâmetro arquivo e atribui os valores lidos às variáveis passadas na
lista de valores. Estas variáveis devem ser compatíveis com o tipo de dado que o
arquivo armazena.
• Readln(arquivo, valores): O mesmo que read, só que após ler um valor, pula para a
próxima linha do arquivo.
• ExtractFileName(caminho): Retorna o nome do arquivo a partir de seu path.
• ExtractFilePath(nome arquivo): Obtém o path do arquivo cujo nome foi passado
como argumento.
• ExtractFileExt(nome arquivo): Retorna a extensão de um arquivo.
• ExtractFileDrive(nome arquivo): Retorna o drive onde se localiza um arquivo.
• ExtractFileDir(nome arquivo): Retorna o diretório do arquivo passado como
argumento.
4.6.3 Tipos Procedurais

Tipos procedurais são tipos de dados usados para criar referências para
procedimentos e funções além de métodos de classes, desde que eles tenham a
mesma assinatura (nº., tipos e ordem dos parâmetros, valor de retorno...) daquela
declarada no tipo.
Através deste tipo de dados, podemos tratar sub-rotinas como valores comuns,
podendo atribuí-las a variáveis, passa-las como argumento para outras sub-rotinas, além
de servirem de base para toda a arquitetura de tratamento de eventos em Delphi.
Os tipos procedurais podem ser divididos em dois grandes grupos: os de referência
para sub-rotinas comuns, pertencentes diretamente à uma Unit e os de referência para

métodos de classe. A diferença entre eles é que as referências de método são

implementadas com duas referências, uma para o método em si e outra para o objeto
dono do método. Exemplinhos:
Declaramos um tipo TFuncaoRealX, cuja assinatura é de uma função que retorna

um valor Real e que possui um único parâmetro também real. Isso quer dizer que as
variáveis deste tipo podem referenciar qualquer função que tenha essa mesma assinatura,
como a função Quadrado do exemplo. Aí, atribuímos a função Quadrado à variável
FuncaoRealX para depois a executarmos através da referência, atribuindo seu valor à
variável Q.
Vamos ver agora um caso onde usaremos uma referência de métodos. o
funcionamento é o mesmo, a diferença é que precisamos adicionar a diretiva “of object” à
declaração:

Declaramos o tipo procedural com a mesma assinatura de antes, porém com a

diretiva “of object” para indicar que ele é uma referência para métodos de classe. Em
seguida, ainda na seção type da Unit, declaramos uma classe, a TPotencia2, que herda de
TObject. A função quadrado agora se tornou um método da classe TPotencia2 ao invés de
pertencer diretamente à Unit como antes.
Na seção var, adicionamos uma referência para um objeto potencia2, chamada P2
e na seção implementation, temos a implementação do método TPotencia2.Quadrado,
declarado dentro da classe TPotencia2 na seção interface.
Na seção initialization, instanciamos o objeto P2 e a partir daí o processo é igual ao
de antes, com a diferença de estarmos executando um método pertencente a um objeto!

Como foi dito anteriormente, o Delphi se utiliza exatamente deste esquema para
implementar o tratamento de eventos. Eventos em Delphi nada mais são que referências a
tipos procedurais, sendo que o mais famoso de todos é o TNotifyEvent, cuja assinatura é:
procedure(Sender: TObject) of object
Familiar? Acredito que sim, pois esta é a assinatura da maioria dos eventos do
Delphi, que recebem apenas o objeto que realizou a ação como argumento.
vamos a um exemplo bem simples. Imagine que estamos no Form Designer e que
nossa tela tem apenas um botão (TButton). Quando vamos ao Object Inspector e clicamos
2 vezes no evento OnClick, o Delphi cria um procedure com a assinatura do TNotifyEvent
e o chama de TForm1.Button1Click. Isso quer dizer que este procedure é um método da
classe TForm1 que estamos programando, ou seja, ele pertence ao formulário e não ao
botão como muitos pensam. Mas como o Button1 sabe que aquele método do formulário é
o seu OnClick para executa-lo? Aí entra a magia dos tipos procedurais! Aquele OnClick em
que a gente clica para criar o evento na verdade é uma propriedade, assim como Caption,
Font, etc., do tipo TNotifyEvent. Assim, ela pode apontar para qualquer método que tenha
a estrutura do TNotifyEvent, assim como o nosso Button1Click!
Ao clicar 2 vezes no Object Inspector, automaticamente a referência OnClick do
Button1 é configurada para apontar para o método Button1Click do Form1 que o Delphi
criou. Assim, quando o programa roda, o botão executa o método indiretamente através da
referência ao ser clicado, exatamente como fizemos com a função Quadrado!
4.6.4 Variants
A classe Variant é modelada depois do tipo Variant intrínseco em versões prévias de
Delphi e Borland C++. Objetos variants são essencialmente variáveis sem tipo, isto
significa que eles podem assumir tipos diferentes automaticamente. O tipo variant
permite a uma variável mudar seu tipo dinamicamente (em tempo de execução). Por
exemplo, no pedaço seguinte de código, o x é variant reconhecido primeiro como um
Integer, e depois como uma string:

procedure TForm1.Button1Click(Sender: TObject);

var
x : variant;
Text : string;
begin
x := 13;
Text := IntToStr( x + 12 );
x := 'Olá';
MessageDlg(x, mtConfirmation, mbYesNoCancel,0);
end;
Uma variável de tipo variant pode conter boolean, date/time, Integer, objetos OLE
Automation, real, e valores de string. Também podem armazenar arrays com
elementos destes tipos, inclusive arrays de variants.
Há dois valores especiais que podem ser usados como valores de variants: Null e
Unassigned. Se o valor do variant for null, a variável não tem dado ou eles foram
perdidos. O valor unassigned informa que a variável não recebeu nenhum valor.
Objetos variantes são muito convenientes, mas muito ineficientes em termos de

armazenamento e velocidade de avaliação em tempo de execução. Os objetos variant
foram projetados para receber referências de servidores de OLE Automation servidor,
o que vale dizer que sua utilização limita-se ao tempo de execução do programa.
Durante a execução a variável de tipo variant é usada para receber ou configurar
propriedades do objeto OLE Automation, ou executar os métodos deste objeto.
4.6.5 Classes
As classes são estruturas que servem de modelo abstrato para a que
possamos criar objetos, ou instâncias concretas a partir dela. O Delphi trata suas
classes com um tipo de dados estruturado qualquer, tanto que elas também devem ser
declaradas na seção type das Units.
Uma classe Delphi é composta basicamente de campos (fields), métodos e
propriedades, cujo acesso pode ser restringido como private, protected, public ou ainda
published. Vamos ver e discutir a estrutura típica de uma classe:

Declaramos a classe TClasse1 na seção type da Unit. a parte “class(TObject)” é

onde dizemos qual é a superclasse de nossa nova classe, ou seja, de quem ela herda (ou
como dizem em Java, quem ela estende), bem como as interfaces que ela implementa, se
houverem. Nossa classe de exemplo herda de TObject, que é a classe raiz de toda a
hierarquia de classes em Delphi. Esta parte dos parênteses não é obrigatória. Se for
omitida, o Delphi assume que estamos herdando de TObject.
Podemos ver também os quatro níveis de acesso que uma classe pode possuir:
• Private: Apenas os membros da própria classe podem acessá-los.

• Protected: Apenas os membros da própria classe e os das classes filhas podem
acessá-los.
• Public: Qualquer um pode acessar.
• Published: Mesmo nível de acesso do public, porém com um diferencial. Membros
published podem ser manipulados em tempo de projeto. Todas as propriedades de
componentes que aparecem no Object Inspector são published, e é por isso que
elas aparecem lá e podem ser alteradas durante o projeto. Mas os membros
published vistos no Object Inspector são privilégio de descendentes da classe
TComponent, ou seja, só os componentes podem ser editados no Object Inspector.

Isso acontece porque um TComponent pode ser instalado na IDE do Delphi,

enquanto que objetos de classes anteriores não. Assim, em nossa classe de
exemplo, a seção published não tem nenhum efeito, sendo equivalente à public.
nota: esse esquema de controle de acesso só é válido para membros de Units diferentes.
Se duas classes estão na mesma Unit, elas têm acesso a todos os membros uma da outra
e passam a ser “friend classes”. Mas isso não é ruim? Depende. Às vezes podemos querer
que várias classes e sub-rotinas trabalhem em conjunto para alcançar seus objetivos.
Assim, pode ser indispensável que elas possam ter acesso total aos dados das outras.
Mas se você não quer que isso ocorra, basta criar uma única classe por Unit.
Vejamos agora quais são os membros de uma classe:
• Campos: São basicamente variáveis comuns pertencentes à classe onde cada

objeto instanciado contém uma cópia de cada campo. Por convenção, todo campo
deve ter seu nome iniciado com a letra “F” (significando field). representam os
dados que o objeto deve armazenar. Na classe do exemplo temos FCampo1 e
FCampo2.
• Métodos: São procedures e functions pertencentes à classe. Eles representam as
operações que o objeto é capaz de realizar, ou seja, seus serviços. No exemplo são
representados pela função Metodo1 e pelo procedimento Metodo2. Podem existir
também métodos que existem especialmente para fazer validações nos dados que
são atribuídos a um campo antes que eles sejam efetivamente atribuídos ou ainda
modificar o dado lido do campo antes de chegar ao cliente do objeto. São eles a
função GetCampo2 (tratamento de leitura) e o procedimento SetCampo2
(tratamento de escrita). Pra quem está familiarizado com Java, isso se parece com
os famosos métodos de acesso set e get da linguagem da Sun. Mas não se devem
usar métodos de acesso em Delphi como se usa em Java. Em Delphi eles são
usados apenas para tratamento, enquanto que em Java eles também fornecem
acesso a campos, implementando o encapsulamento dos mesmos. Para fornecer
acesso e implementar o encapsulamento em Delphi, use propriedades.
• Propriedades: São estruturas responsáveis por fornecer acesso a campos do
objeto e pelo encapsulamento dos mesmos, podendo ocultar inclusive, os métodos
de validação dos campos! Como exemplos de propriedades temos a Propriedade1
e Propriedade2, sendo que a Propriedade1 acessa diretamente os dados do
FCampo1, enquanto que Propriedade2 acessa os dados do FCampo2 através dos
métodos de validação GetCampo2 e SetCampo2. As propriedades possuem as

partes read e write, que dizem a ela o que deve ser lido e o que deve ser escrito no
membro que ela encapsula. Mas podem existir propriedades somente de leitura
(read-only) e somente de escrita (write-only), bastando omitir uma destas partes.
• Construtores: São tipos especiais de métodos responsáveis pela criação dos
objetos da classe e pela inicialização dos seus campos. Por convenção,
construtores Delphi são sempre chamados de Create ou algo como
“CreateAlgumaCoisa” ou então “CreateFazendoAlgumaCoisa”... mas sempre tendo
o Create como base. Quando criamos uma classe, os construtores da superclasse
são herdados, mas podem ser escondidos se declararmos outro construtor no
mesmo nível de acesso, mesmo que tenha assinatura diferente do original.
• Destruidores: São métodos responsáveis pela liberação dos recursos alocados por
um objeto durante sua existência. Como não existe um garbage collector no Delphi
7, todo objeto instanciado deve ser manualmente liberado pelo destruidor. por
convenção, os destruidores são chamados de Destroy ou algo que tenha Destroy
como base. Também existe um destruidor herdado definido na classe TObject, que
pode ser sobrescrito, usando a diretiva override. Atenção agora: o Create deve ser
ocultado, mas o Destroy deve ser sobrescrito com override. Isso porque Destroy é
um método virtual, enquanto que Create é estático.
4.6.6 Referências de Classe (metaclasses)

Como o nome já diz, são referências para uma classe, e são usadas quando
queremos invocar métodos de classe ou construtores virtuais de um objeto cuja classe
pode não ser conhecida em tempo de compilação. O maior exemplo disso é o método
Application.CreateForm do objeto global Application. Ele recebe como argumentos
uma referência para uma classe de formulário e a referência que vai receber a nova
instância de formulário. Este primeiro parâmetro é do tipo TFormClass que é uma
referência para a classe TForm, a classe raiz de todos os formulários. Assim, ao criar
um novo formulário, o objeto Application não precisa saber o tipo exato do formulário,
porque ele será fornecido através da referência TFormClass, através da qual ele será
criado. Vamos ilustrar mostrando o dpr de uma nova aplicação:

Na Unit1 temos a declaração da classe TForm1, que herda de TForm e a variável

Form1 do tipo TForm1. No programa principal podemos ver o método
Application.CreateForm em ação. Ele é capaz de criar qualquer tipo de formulário graças
ao TFormClass. Veja que passamos a própria classe TForm1 como argumento, assim
como podemos passar qualquer classe descendente de TForm! Ao criar o objeto TForm1,
a referência será guardada na variável Form1 passada no 2º argumento.
A declaração de uma metaclasse é da forma TClasse = class of type, onde type é a
classe cujo tipo queremos referenciar. no caso do TFormClass temos: TFormClass = class
of TForm.
4.6.7 Interfaces
Interfaces são como uma espécie de classe abstrata que fornece apenas
declarações de métodos para serem implementados por uma classe. Aí dizemos que a
classe implementa a interface e é obrigada a implementar todos os métodos que ela
fornece.
No Delphi, a interface raiz é a “IInterface” (foi convencionado que todo nome de
interface deve começar com “I”), que possui 3 métodos: QueryInterface, _AddRef e
_Release. Assim, toda interface criada deve ser derivada de IInterface e assim terão estes
3 métodos. mas então, se eu criar uma interface personalizada e implementa-la numa
classe, vou precisar implementar estes métodos esquisitos? Não necessariamente!
Acontece que estes métodos já estão implementados numa classe chamada
TInterfacedObject. Assim, basta herdar sua classe de TInterfacedObject e implementar
apenas a interface personalizada, sem se preocupar com os 3 métodos esquisitos (afinal,

herdaremos a implementação padrão). Mas afinal, o que estes métodos fazem? Eles têm a
ver com o controle do tempo de vida de objetos referenciados por variáveis de interface.
Estes objetos não precisam ser destruídos como os objetos comuns, pois são controlados
por contagem de referências. E quem controla isso são as implementações destes
métodos na TInterfacedObject.
Existem algumas restrições nas interfaces em relação às classes:
• Interfaces não podem ter campos, apenas métodos e propriedades.

• Já que não há campos, os parâmetros para as diretivas read e write das propriedades
só podem ser métodos.
• Interfaces não podem ter construtores nem destruidores. Afinal, não devem ser
instanciadas.
• Métodos de interfaces não podem ter diretivas como virtual, dynamic, override e
abstract. Como não podem implementar seus próprios métodos, estas diretivas não
fazem sentido nas interfaces (também deixamos estas diretivas mais pra frente).
• Não podem haver seções private, public, etc. numa interface.
Em Delphi, as interfaces podem opcionalmente possuir um identificador global, chamado

GUID, representado por uma string da forma: ['{xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}'],
onde cada x é um nº. hexadecimal, localizado imediatamente antes da declaração dos
membros.
Mas pra que serve tudo isso?
Pra poder usar o typecast as entre um objeto e uma interface. Lembra do método
QueryInterface, que toda interface tem? Pois bem, ao fazer o teste “as” entre um
objeto e uma interface, o GUID da interface é passado ao método QueryInterface do
objeto (desde que o objeto implemente alguma interface) e ele vai dizer se o objeto
implementa a interface em questão. Caso implemente, o typecast é realizado; caso
contrário, ocorre uma exceção.
Se você se assustou com o tamanho do GUID, ou ficou pensando em como fazer
para saber se ele é único ou não, fique tranqüilo! O Delphi gera os GUIDs pra você! Basta
dar um Ctrl + Shift + G dentro da declaração da interface e pronto! E lá vem o exemplo:

Primeiro criamos a interface “ITeste” que herda diretamente de Iinterface, a

interface raiz do Delphi. Ele possui um método “Metodo” e uma propriedade “Valor”, que
possui seus dois “métodos de acesso” SetValor e GetValor, que são necessários pois as
interfaces não podem ter campos, apenas métodos e propriedades que acessam métodos.
O nº. “esquisito” logo abaixo da declaração é o GUID, que identifica a interface de forma
única no ambiente Delphi e foi gerado automaticamente com o comando Ctrl + Shift + G.
Assim, podemos realizar typecasts com referências desta interface.
Abaixo, criamos uma classe chamada TTeste que implementa a interface ITeste.
Repare que herdamos TTeste de TinterfacedObject, ao invés de TObject para podermos
herdar a implementação padrão daqueles 3 métodos que vêem de Iinterface. Logo após
informarmos que a superclasse será TInterfacedObject, informamos que TTeste
implementa ITeste separando por vírgula. O esquema é sempre este: primeiro a
superclasse e depois a lista das interfaces implementadas, tudo separado por vírgulas

(lembrando que não há herança múltipla no Delphi! Coloque apenas uma classe e depois
quantas interfaces quiser!). Dentro da classe, implementamos os métodos fornecidos pela
interface, escolhendo a visibilidade que bem entendermos para eles.
4.7 Comandos da Delphi Language

Depois de vermos operadores e tipos de dados, nada como estudar os
comandos e estruturas de controle do Delphi! Então vamos!
4.7.1 Comando de Decisão

Objecto Pascal suporta várias estruturas de decisão, cada uma com um uso particular.
4.7.1.1 O Comando IF..the..else
if. ..then. ..else

O formato básico da declaração if. ..then. ..else é mostrada abaixo:
if <expressão lógica> then

<declaração>;
Esta sintaxe básica pode ser estendida adicionando-se a clausula else:
if < expressão lógica > then

< declaração >
else
< declaração >;
Note que em ambos os exemplos anteriores, < declaração > pode ser uma declaração
simples ou composta. Também nota que o inteiro o bloco inteiro if . . . then é
considerado uma única declaração, assim o único ponto-e-vírgula pertence ao término
da declaração (ou depois de < declaração > no primeiro caso depois do segundo <
declaração > no segundo caso).

Outra variação desta declaração é a possibilidade de um if adicional após o else:

< declaração >
else if < expressão lógica > then
< declaração >
else
< declaração >;
Você pode aninhar quantas declarações If você queira, mas na maioria dos casos
onde você tem muitas condições para conferir, construir um Case é melhor escolha.
Aqui está a sintaxe de uma declaração if . . . then que usa declarações compostas:

begin
< declaração >;
< declaração >;
< declaração >
end
else
begin
< declaração >;
< declaração >;
< declaração >
end;
Não há ponto-e-vírgula após o end que aparece antes da cláusula else.

4.7.1.2 O Problema do “Else Oscilante”
Muitas das linguagens de programação dos anos 70 (inclusive Pascal) sofrem do

problema do “Else oscilante”. Aqui está um exemplo:
if x < 5 then
if y > 4 then
z := 0
else
z := 1;
Para que if o else pertence? A identação parece sugerir que pertence ao primeiro if,
mas na verdade pertence ao segundo. Neste exemplo, se x é maior ou igual a 5, a
parte do else nunca será executada. O else pertence ao if interno , e só executará se
x for menor que 5 e y é menor ou igual a 4.
Embora o Pascal não tenha nenhum operador de fim explícito "end if", o ponto-e-
vírgula serve para este propósito. Note porém que sempre é ilegal colocar um ponto-e-
vírgula em frente a uma cláusula else, porque a cláusula if/then/else é uma única
declaração. Porque a cláusula if/then/else é uma única declaração, a regra é esta na
Linguagem Object Pascal, o else pertence ao if mais interno.
Dada esta regra, como você pudesse associar o else oscilante do último exemplo,
com o primeiro if? Com este conhecimento, nós podemos resolver o problema prévio
passando de uma declaração simples para uma declaração composta.
Aqui temos um exemplo:
if x < 5 then
begin
if y > 4 then
z := 0
end
else
z := 1;
Agora criando uma declaração composta, o end da declaração de inicial servirá como
o terminador para o if interno. A outro parte da declaração executará agora se x for
maior ou iguala a 5.

4.7.2 Case < X > of

O if . . . then . . . else mostrado anteriormente trabalha bem para um número pequeno
de opções, mas fica incômodo se você tiver muitas comparações. Nesta situação, a
construção do Case é mais fácil de se escrever. A sintaxe geral para a instrução Case
é mostrada abaixo:
case <variável> of
<variável(is)> : <declaração>;
< variável(is)> : < declaração >;
else
< declaração >;
end;
A instrução Case pega uma variável e a compara com possíveis valores. Valores
múltiplos podem aparecer debaixo do mesmo Case, separado por vírgulas. Aqui está
um exemplo de uma estrutura Case:
Case Ch of
'A'..'Z', 'a'..'z': ShowMessage('Letra');
'0'..'9': ShowMessage('Número');
'+', '-', '*', '/': ShowMessage(Operador');
else
ShowMessage('Caractere Especial');
end; // case
Neste exemplo, nós estamos testando o valor da variável Ch (que é do tipo char) e
mostrando 'Letra' se ela é uma letra maiúscula ou minúscula, 'Número' se ela é um
número, ou 'Operador' se ela é um operador. Se nenhum dos casos anteriores for
verdadeiro, a cláusula else é executada, e as palavras ‘Caractere Especial’ são
mostradas.
Se você estiver familiarizado com C, o construtor Case é semelhante à declaração

Switch.
Também note que qualquer uma das declarações em um Case pode ser declarações
simples ou composta. Se você precisar executar múltiplas linhas de código para um
determinado caso, você tem que colocar o código dentro um begin . . . end.

Loop
Loop é uma das atividades fundamentais que você empregará em qualquer linguagem
de programação. Objecto Pascal oferece várias alternativas de loop. Cada tipo
particular para uma circunstância específica.
4.7.3 While . . . do
O loop While executa declarações até que a condição declarada no While fique falsa.
Aqui está a sintaxe geral do While:
while <Expressão Lógica> do

<declaração>;
Como em todas as estruturas, você pode ter declarações simples ou compostas. Aqui
está um exemplo de uma declaração composta:
i := 10;
while i > 0 do
begin
i := i - 1;
ShowMessage(‘Este é um loop!’ );
end; // while
Este exemplo mostrará ‘Este é um loop!’ dez vezes. Note que o loop While impedirá
que as declarações internas sejam executadas, se a condição for inicialmente falsa.
4.7.4 For . . . do
O loop For é diferente do loop While pois ele sempre executa um número especificado
de vezes, determinado pela variável de controle. A sintaxe geral do For é mostrada
abaixo:
for <Controle Variável> := <Valor Inicial> to <Valor Final> do

<declaração>;

Aqui, a variável de controle normalmente é um inteiro (ou um dos tipos de inteiro) e

freqüentemente é nomeado "i" (que representa índice). Esta variável normalmente é
inicializada com um valor de 1, mas pode iniciar com qualquer valor. Então, criar um
loop que rode de 10 a 100:
for i := 10 to 100 do
ShowMessage( ‘Loop’ );
Como este loop executa, o valor de i é 10 na primeira vez. Para cada volta, é
incrementado i. O loop continua até que i alcance o valor de 100 (o valor final). Na
última passagem do loop, i é igual a 100. É incrementado novamente, e o loop termina
porque o valor de i é agora maior que o valor final.
Para este tipo de loop não é necessário incrementar a variável de controle; há uma
modificação para o porque volta, downto por sua vez faz com que a variável i seja
decrementada e não incrementada para cada volta.
Se você quisesse fazer o loop de 10 até -10:
for i := 10 downto -10 do

if i > 0 then
ShowMessage( ‘i é maior que zero’ )
else if i < 0 then
ShowMessage( ‘i é menor que zero’ )
else
ShowMessage( ‘i é exatamente zero’ );
Note que neste exemplo que há só um pontro-e-vígula, e só um lugar possível para ele.
A declaração For leva uma única declaração ou uma declaração composta, porém, a
declaração do if..then..else é uma única declaração, e assim não há nenhuma
necessidade do begin...end.
Seja cauteloso ao usar a variável de controle. Deve ser declarado como um tipo
ordinal (um número ou um tipo enumerado definido pelo usuário) e deve estar dentro
do escopo do loop. Também, depois que o loop for executado, o valor da variável de
controle será um passo além para o 'to' ou 'downto' . Você não pode mudar o valor
da variável de controle dentro do loop.

O loop For é a melhor opção de loop quando você sabe com antecedência os valores
que você passará para o loop. Ele é utilizado freqüentemente para o acesso aos
elementos de um array.
4.7.5 Break e Continue

O último dos tópicos dos loops se refere a duas palavras reservadas break e continue.
Qualquer um destes comandos pode ser usado em quaisquer das estruturas
anteriores de loop.
Break é usada para encerrar o loop imediatamente. Assim, break é um modo
conveniente para encerrar o loop sem ter que configurar condições de loop especiais.
Aqui está um exemplo:
while True do
begin
readln( inputFile, i );
if StrToInt(i) = 5 then
break;
ShowMessage( i );
end;
Neste exemplo, note que o loop sempre rodará a menos que algo intervenha (While
True sempre será verdadeiro). O loop continuará lendo um arquivo e mostrando o que
foi lido até que o número lido seja igual a 5. Quando um break é encontrado, o
programa salta sua execução para a primeira declaração em seguida ao loop.
O outro modificador de execução de loop é a declaração Continue. Uma declaração
continue saltará o resto do loop e voltará para a condição de avaliação. Assim, se
houverem mudanças de valor que podem afetar a condição do loop, você pode usar o
Continue voltando ao inicio do loop e re-avaliar a condição.
Aqui temos um exemplo simples:

while i < 10 do
begin
readln( inputFile, i );
if StrToInt( i ) < 5 then
continue;
ShowMessage( ‘Está mensagem sera exibida quando I maior ou igual a 5: ’ + i );
end; // while

A declaração Continue neste caso impedirá que qualquer número menor que 5 de
seja impresso, o resto da volta é saltado, e a condição de volta é re-avaliada. Se o
usuário entrar em um número maior que 10, o valor ainda será impresso, mas o loop
termina.
A declaração Continue é particularmente útil para saltar ou evitar dados inválidos ou
cálculos. Se o usuário entrar com algo diferente do que você quis, então você pode
usar Continue voltando ao início do loop e conseguir o dado novamente.
4.7.6 Repeat
repeat
comando1;
comando2;
comando3;
until
<condições>
O repeat é o comando de repetição com teste no final. Como conseqüência,

seus comandos são sempre executados pelo menos uma vez! Este é também um
comando exótico em relação aos outros dois, primeiro por causa da sintaxe, que não
exige begin..end para múltiplas instruções (o repeat é um bloco) e por causa do
significado de seu teste de parada. O while executa sua repetição enquanto as
condições fornecidas forem verdadeiras. Já o repeat executa seus comandos até a
condição se tornar verdadeira!
Todos os comandos de repetição podem ser interrompidos quando for
conveniente para o programador através de duas instruções: o break e o continue. O
break é usado quando se deseja sair totalmente do corpo do comando de repetição e
seguir a vida, enquanto que o continue apenas sai da iteração atual, pulando para a
próxima iteração, sem sair do comando de repetição.

4.7.7 Tratamento de Exceções

Existem dois comandos utilizados para fazer tratamento de exceções em
Delphi: o try..except e o try..finally.
O bloco try..except tem as seguintes possibilidades:
// try..finally com exceção qualquer

try
comando1;
comando2;
except
comando3;
comando4;
end;
// try..except capturando exceções específicas

try
comando1;
comando2;
except
on exceção1 do
comando3;
on exceção2
do begin
comando4;
comando5;
end;
end;
// try..except re-disparando uma exceção

try
comando1;
comando2;
except
on exceção1 do
raise;
end;
O bloco try..except é utilizado para executar uma lista de comandos e capturar as

exceções que acontecerem nestes comandos para que sejam tratadas, possibilitando que
o programa se recupere e continue a executar. No 1º caso, vimos um try..except que
executa seu bloco de tratamento except para qualquer que seja a exceção disparada. No
segundo exemplo, vemos um bloco que captura exceções específicas e dá tratamento
individualizado a cada uma delas (que é o jeito ideal de se fazer o tratamento). Por fim
temos o tratamento de exceção do tipo “batata-quente”, onde um determinado tipo de
exceção não vai ser tratado localmente, e sim pela rotina que está um nível acima, ou seja,
aquela que chamou esta onde está o try..except. O comando raise se encarrega de re-
disparar a exceção capturada para que seja tratada em outro lugar. Aliás, a instrução raise
pode ser usada em qualquer lugar do código, não apenas no bloco except, para disparar
exceções quando alguma condição não for especificada.

Exemplo:
if not <condição> then
raise Exception.Create(‘Condição inválida!’);
Este código dispara uma exceção do tipo Exception (a “mãe” de todas as exceções
Delphi) sempre que <condição> for falsa.
Quanto ao bloco try..finally, seu uso é indicado principalmente para garantir que um
determinado recurso alocado pelo programa seja liberado, aconteça o que acontecer. Por
exemplo, se você instancia um objeto, ele deve ser liberado manualmente (não temos
garbage collector), mas se houver uma exceção antes que o código de liberação seja
executado, o objeto continuará vagando pela memória, ocupando espaço e gastando
recursos da máquina! Mas se o protegermos o código que utiliza o objeto com o bloco try e
colocarmos o código de liberação no finally, ele garantirá que o objeto será liberado de
qualquer jeito, com ou sem exceções! Outro uso pode ser o fechamento de arquivos, ou
fazer o cursor voltar ao normal (pro caso de o mudarmos e ocorrer uma exceção que o
manteria modificado, como ficar eternamente com a ampulheta). A sintaxe de um bloco
try..finally é:
try
comando1;
comando2;
finally
comando3;
comando4;
end;
4.7.8 O Comando with

Quando trabalhamos com objetos ou registros, usamos o operador ponto para
acessar seus campos ou propriedades. Mas, se a lista de propriedades que temos que
manipular for muito grande, acessa-las repetindo sempre o nome do objeto torna-se meio
trabalhoso, mesmo dispondo de code completions e Ctrl + C. É aí que entra o comando
with! Ele permite colocar em evidência a parte dos nomes dos objetos e assim escrevemos
somente as propriedades finais. Vamos vê-lo em ação:
// trecho de código sem with
Form1.Font.Style := [fsBold];
Form1.Font.Color := clNavy;
Form1.Font.Name := 'MS Sans Serif';
Form1.Font.Size := 10;
// o mesmo código com with

with Form1.Font
do begin
Style := [fsBold];
Color := clNavy;
Name := 'MS Sans Serif';
Size := 10;
end;

Prático, não? Colocamos a parte “Form1.Font” em evidência e assim digitamos

apenas a parte variável do código! Mas não devemos ficar muito entusiasmados com este
comando, pois junto com a praticidade vêm os problemas...
O primeiro problema que torna o uso do with não recomendado é a questão da
legibilidade. Dê uma olhada no código abaixo:
with Memo1
do begin
Line := Perform(EM_LINEFROMCHAR, SelStart, 0);
Column := SelStart - Perform(EM_LINEINDEX, Line, 0);
Label1.Caption := IntToStr(Line + 1);
Label2.Caption := IntToStr(Column + 1);
end;
Agora responda: o que é “SelStart”? Uma variável? Uma função? Uma propriedade do
Memo1? O que são “Line” e “Colunm”?
Esse é o problema; o with torna o código fonte mais confuso para o leitor, pois fica
difícil de determinar a quem pertencem os elementos referenciados, apesar de poupar o
trabalho do escritor...
Mas o pior defeito do comando with é esconder os valores das expressões dos
debuggers do Delphi. Portanto, se usar with você não poderá ver os valores das variáveis
ao parar a execução do programa com Break Point. E também não adianta “apelar” para
Whatches ou Evaluate/Modify... nada consegue acessar estes valores!
Por isso, os prejuízos que conseguimos com este comando acabam se tornando
maiores que seus benefícios e seu uso é desencorajado.

4.8 Variáveis e Constantes

Vejamos como são as declarações de variáveis e constantes no Delphi.
Primeiramente, devemos saber que todas as variáveis devem ser declaradas dentro
de uma seção var e as constantes dentro de uma seção const. A sintaxe geral de uma
declaração de variáveis ou constantes é:
// declaração de variáveis
var
// simples
Numero: Integer;
// lista
Palavra1, Palavra2, Palavra3: String;
// inicializando na declaração
OutroNumero: Integer = 0;
// declaração de constantes
const
// true constants
ConstanteInteira = 10;
ConstanteString = ‘Texto constante’;
ContanteExpressao = 30 + (25 mod 2);
// typed constants
MaisUmNumero: Integer = 100;
OutraString: String = ‘Nada Não!’;
Nums: array[0..9] of Char = ('0', '1', '2', '3', '4', '5', '6', '7', '8',
'9');
Podemos declarar variáveis de três diferentes modos, sem complicação: o simples,

a listagem de variáveis de mesmo tipo e a declaração com inicialização, conforme os
exemplos acima, mas a declaração com inicialização só funciona em variáveis globais (nas
locais dá erro de compilação!) e não é permitida a inicialização em lista (inicializar várias
variáveis ao mesmo tempo com o mesmo valor).
Quanto às constantes, existem dois tipos: as “true constants” e as “typed
constants”. As true são constantes declaradas sem o tipo, que fica implícito no valor
atribuído a elas e não suportam valores de tipos estruturados. Já as typed possuem o tipo
definido explicitamente, podendo ser de tipos estruturados (como o array constante
“Nums” do exemplo).
Os valores atribuídos a qualquer constante podem ser tanto valores simples e
diretos quanto expressões mais elaboradas.
4.9 Procedimentos e Funções

Os procedimentos e as funções são as sub-rotinas do Delphi, e tanto podem ser
métodos de classes ou interfaces como também podem pertencer apenas à Unit. A
diferença entre estes dois tipos de sub-rotinas é que as funções têm um valor de retorno,
enquanto que os procedimentos não.

4.9.1 Declarando Procedimentos e Funções

Os formatos gerais de declarações de procedimentos e funções são os
seguintes:
// declaração geral de procedimento

procedure Nome_do_procedimento(Lista_de_parametros); Diretivas;
Declarações_locais;
begin
Instruções;
end;
// declaração geral de função

function Nome_da_função(Lista_de_parametros): Tipo_de_retorno; Diretivas;
Declarações_locais;
begin
Instruções;
Retorno_do_valor;
end;
Nas declarações acima, “Declarações_locais” são as variáveis, constantes,

tipos de dados (sim, pode-se declarar tipos de dados locais!) e outras sub-rotinas
locais (podemos declarar funções e procedimentos dentro de outras funções e
procedimentos!). “Diretivas” são diretivas que possuem diversas funcionalidades como
convenções de chamada, declarações externas... etc. que não serão abordadas aqui,
por quase nunca serem usadas em situações comuns de programação. Mas algumas
destas diretivas são importantes como a override que foi apresentada na parte sobre
classes e a overload que veremos daqui a pouco. “Instruções” são as instruções que
devem ser executadas pela sub-rotina. “Tipo_de_retorno” é o tipo de valor que a
função retorna (String, Integer...). “Retorno_do_valor” é a instrução que atribui um
valor à função para que este seja retornado por ela. Existem duas maneiras de atribuir
o valor de retorno à função, pelo nome da função ou pela variável de retorno Result.
Na primeira forma, para fazermos a função retornar um valor pelo nome, fazemos:
Nome_da_função := Valor;
e da segunda forma, com a variável de retorno Result, fazemos:
Result := Valor;
Result é uma espécie de variável interna que toda função Delphi possui e que não precisa
ser declarada, bastando atribuir diretamente. Result sempre é do mesmo tipo de retorno
da função.
nota: Ao contrário do que ocorre na instrução return do Java por exemplo, a execução do
programa não sai da função ao atribuirmos o resultado a ela em Delphi, ou seja, se você
atribuir um valor ao result mas ainda houverem instruções depois, todas elas serão
executadas. A função só retorna o valor após executar todas as suas instruções.

A lista de parâmetros merece uma atenção especial. Primeiramente, podemos

declarar os parâmetros da mesma forma que declaramos variáveis: simples, lista e com
inicialização (aqui chamado do parâmetro com valor default).
Parâmetros simples não têm segredo (são separados com ponto-e-vírgula):
procedure P(Parametro1: Integer; Parametro2: String);
Agora com lista (os de mesmo tipo são separados com vírgula e os de tipos diferentes são
separados com ponto-e-vírgula. Agrupar parâmetros de mesmo tipo em lista é opcional):
procedure P(Parametro1, Parametro2: Integer; Parametro3: String);
Com default (se nada for passado como argumento, assume o valor da inicialização):
procedure P(Parametro1: Integer; Parametro2: Boolean = True);
E agora sem parâmetros (veja que não é necessário colocar parênteses vazios em Delphi):
procedure P;
Estas regras são as mesmas para funções.

Para executar procedimentos e funções, basta chama-los pelo nome. Se eu
tenho um procedure P(A: Integer; B: Boolean); só precisamos fazer P(100, True);
para chamá-lo! O mesmo valendo para funções, só que elas têm um valor de retorno
que pode ser ou não atribuído a alguma variável ou testado em comandos de decisão
e repetição.
Podemos sobrecarregar sub-rotinas em Delphi utilizando a diretiva overload
mencionada acima. Exemplos de rotinas sobrecarregadas:
procedure P; overload;
procedure P(I: Integer); overload;
procedure P(S: String; B: Boolean); overload;
É só isso! Basta que eles tenham o mesmo nome, mas com listas de parâmetros
diferentes, e a diretiva overload em cada versão sobrecarregada.
5 Componentes
A programação típica em Delphi é bastante centralizada na adição e configuração
de componentes da Palheta de Componentes no Form Designer. Então, vamos ver
alguns conceitos e propriedades básicas dos componentes.

5.1 Relacionamentos entre Componentes

Existem dois relacionamentos comuns entre componentes: O relacionamento
Parent e o relacionamento Owner.
O relacionamento Parent, que só vale para componentes visuais, indica quem
é o contêiner (o Parent) de um componente. O Parent ou contêiner é responsável pelo
alinhamento visual de seus componentes.
Já o relacionamento Owner (proprietário) é uma facilidade para a destruição de
objetos criada em tempos de ausência de garbage collector! Quando um componente
é Owner de outros, significa que quando ele for destruído, todos os componentes que
são propriedade dele também serão! Numa aplicação comum, o Owner de todos os
componentes costuma ser o formulário. Dessa forma, quando o Form é destruído,
todos os outros componentes são destruídos junto com ele!
5.2 Propriedades e Eventos Comuns

Os componentes são objetos que estão numa vasta hierarquia de classes. A
classe básica de um componente é TComponent, onde estão definidas características
básicas que todo componente, visual ou não deve ter.
Por terem uma origem comum, muitos componentes apresentam propriedades,
eventos e métodos comuns. Por isso, antes de vermos componentes de forma mais
específica, é bom que conheçamos estes elementos comuns, e que são também
frequentemente utilizados.
Entre as propriedades mais corriqueiras, podemos destacar:
• Action: Torna um componente cliente de um componente TAction, que será visto

mais a frente.
• Anchors: Servem para manter constantes a posição dos lados de um componente
quando a janela é redimensionada.
• TabOrder: É a ordem em que os componentes vão ganhando foco à medida que a
tecla Tab é pressionada.
• TabStop: Define se o componente vai ou não receber o foco ao se pressionar Tab.
Se esta propriedade for falsa, TabOrder não tem efeito.
• Name: É o nome do componente. É usado pelo Delphi para criar as referências
para os componentes adicionados ao Form Designer.
• Hint: Usada para exibir uma dica sobre o componente ao pararmos o mouse sobre
ele.
• ShowHint: Ativa ou desativa a exibição do hint.

• Height e Width: Altura e largura do componente.

• Left e Top: São as coordenadas do canto superior esquerdo do componente em
relação ao seu Parent. Left é a coordenada X e Top a Y, e são medidas a partir do
canto superior esquerdo do Parent.
• Visible: Torna o componente visível ou invisível.
• Enable: Desabilita ou habilita o componente. Quando desabilitado, ele continua
visível, mas o usuário não pode interagir com ele.
• ReadOnly: Todo componente que contém um texto ou valor que pode ser editado
possui esta propriedade, que define se este valor pode ou não ser editado. se
ReadOnly for True, o valor é apenas para leitura – não pode ser mudado pelo
usuário.
• Align: Contém alinhamentos pré-definidos para componentes visuais, fazendo com
que eles ocupem totalmente um dos lados do Parent (top, bottom, left ou right).
• Ctrl3D: Controla a tridimensionalidade. se estiver falsa, o componente se torna
bidimensional.
• Caption: Muitos componentes possuem esta propriedade que apenas exibe neles
um texto fixo, ao qual o usuário não tem acesso.
• Font: É a fonte que será usada nas propriedades de texto do componente, como a
Caption. Porém, para a classe TForm, Font é usada para dar uma fonte padrão aos
componentes colocados no formulário, que automaticamente ajustam suas fontes
para ela.
• Color: É a cor de fundo do componente.
Agora, os eventos mais populares:
• OnClick: Ocorre quando o componente é clicado (não diga!).

• Eventos de mouse: Os eventos de mouse são OnMouseMove, OnMouseDown e
OnMouseUp e embora se pareçam com o click, são mais específicos para
tratamento de mouse. OnMouseMove ocorre quando o mouse passa sobre um
componente. Recebe como argumentos, além do famoso Sender, as coordenadas
do mouse e o ShiftState (estado das teclas shift, ctrl, alt e o estado dos botões do
mouse). OnMouseDown é chamado quando o botão do mouse é pressionado, ou
seja, quando ele desce. Recebe como argumentos a posição do mouse, o botão do
mouse que foi clicado, além do ShiftState. OnMouseUp é Idêntico ao mouse down,
só que é disparado quando o usuário solta o botão do mouse.

• Eventos de teclado: São OnKeyPress, OnKeyDown e OnKeyUp. OnKeyDown e

OnKeyUp possuem a mesma idéia dos eventos de mouse de mesmo nome e são
indicados para tratar teclas como enter, esc, delete, F1, F2, direcionais... etc. as
chamadas “teclas virtuais”, que não representam caracteres. Para tratar teclas de
caracteres, é indicado u uso do OnKeyPress.
• OnEnter: Ocorre quando um componente recebe o foco.
• OnExit: Oposto do OnEnter. É chamado ao perder o foco.
• OnChange: Alguns componentes possuem este evento que é chamado sempre o
estado do componente muda. Mas cada um tem sua própria versão desta mudança.
5.3 Componentes mais Usados

Veremos agora alguns dos componentes usados mais frequentemente na
programação em Delphi e conheceremos suas propriedades e eventos mais
significativos.
5.4 TForm
Os componentes da classe TForm são os formulários sobre os quais incluímos
outros componentes e através do qual criamos a telas da aplicação. Suas
propriedades mais importantes são:
• BorderIcons: Configura a presença dos botões de maximizar, minimizar, fechar e

help ao configurar cada uma como True ou False.
• BorderStyle: Configura o estilo da borda do formulário. Seu uso mais típico é para
impedir que o usuário redimensione o formulário, alterando seu valor para bsSingle
(o padrão é bsSizeable, que permite que o usuário ajuste o tamanho da janela em
tempo de execução).
• Icon: Sobrescreve o ícone padrão definido em Application do Project Options e o
exibe no canto superior esquerdo do Form.
• Menu: Associa o Form a um objeto TMainMenu, que será o menu daquela tela.
• Position: É a posição na qual o Form vai aparecer na tela ao ser mostrado. Seu
valor padrão é poDesigned, que indica que ele será mostrado onde foi deixado em
tempo de projeto. Em situações normais deve ser configurada como
poScreenCenter para que o Form seja mostrado no centro da tela, independente de
onde ele estava durante o projeto.

• WindowState: É o estado da janela ao ser mostrada. O padrão é o valor wsNormal,

em que ela fica normal, no tamanho em que foi projetada. Mas pode mudar para
maximizada (típico para o form principal da aplicação) ou minimizada se mudarmos
seu valor para wsMaximized ou wsMinimized.
Os eventos mais utilizados de um objeto TForm são os seguintes:
• OnActivate: Ocorre quando o Form se torna ativo.

• OnClose: Ocorre quando o Form é fechado.
• OnCloseQuery: Este evento ocorre imediatamente antes de fechar o Form e é
usado para decidir se ele realmente tem permissão para fechar ou não, através do
parâmetro CanClose. Se o programador definir que o formulário não pode ser
fechado se uma determinada operação ainda está pendente (um arquivo não salvo
por exemplo), basta definir CanClose para False;
• OnCreate: Este evento é chamado pelo construtor do Form como parte do
processo de instanciação. É usado para inicializar valores de propriedades,
campos, propriedades de componentes, etc.
• OnDeactivate: É o oposto do OnActivate, ocorrendo ao desativar a janela.
• OnDestroy: Evento chamado pelo método destruidor do Form, usado para liberar
recursos alocados por ele (destruir objetos globais, fechar arquivos...).
• OnShow: Ocorre imediatamente antes do Form ser exibido na tela.
O Form possui também alguns métodos bastante usados:
• Show: Mostra o formulário.

• ShowModal: Faz o mesmo que show, só que neste caso o Form não permite que
outras telas do sistema sejam ativadas enquanto ele não for fechado. ShowModal é
uma função que retorna um valor inteiro que pode ser testado quando ele se fecha.
5.5 Botões
Temos 3 componentes que representam diferentes tipos de botões, cada um
com suas funcionalidades especificas. São eles o TButton, TBitBtn e o TSpeedButton.
Eles possuem propriedades comuns, que veremos agora:
• Cancel: Se for verdadeira, clica o botão automaticamente ao pressionar a tecla

Esc. Não está presente no SpeedButton, pois ele não responde ao teclado.

• Default: Clica o botão automaticamente ao pressionarmos a tela Enter, quando

está True. Assim como Cancel, não está no SpeedButton pela mesma razão.
Agora vamos dar uma olhada no TBitBtn. O maior diferencial deste botão em relação
ao TButton é o suporte à imagens, o que significa que podemos colocar um ícone
nele, através da propriedade Glyph. Outras propriedades existem em função deste
ícone: Margin e Spacing, que controlam respectivamente a margem que deve ser
respeitada antes do glyph e o espaço entre o glyph e o caption. Há também a
propriedade layout que informa a posição do glyph (à esquerda, direita, acima ou
abaixo em relação ao caption). Estas três propriedades estão também no
TSpeedButton.
O botão do tipo SpeedButton é diferente dos outros. Ele não pode ser
acessado por tabulações como os outros e não pode receber foco, comportamento
encontrado em botões de barras de ferramentas por exemplo. Possui uma propriedade
exclusiva entre os botões, a Flat, que quando verdadeira, esconde o contorno do
botão até que o mouse passe sobre ele.
5.6 O Label
Componente usado para criar um rótulo, tipicamente usado com edits. Um
Label não pode receber foco nem pode ser editado em tempo de execução. Sua
funcionalidade básica se restringe a exibir um texto pela propriedade Caption. Possui
também a propriedade FocusControl, que faz com que o controle referenciado por ela
receba o foco, se o Caption do Label estiver com configurado com um atalho Alt +
tecla, configurado com um “&” antes do caractere que servirá de tecla de atalho junto
com Alt.
5.7 Os Edits
São os componentes tipo caixa de texto de uma única linha onde o usuário
pode digitar um texto qualquer. O Delphi fornece 3 edits básicos: TEdit, TMaskEdit,
TLabeledEdit.
Algumas propriedades comuns entre eles são:

• MaxLength: Nº. máximo de caracteres que podem ser digitados
• PasswordChar: Caractere que será exibido para esconder o texto real do edit ao
digitar (usado para colocar o “*” em campos de senha, daí o nome PasswordChar!).

• CharCase: Define se o texto digitado vai estar sempre em maiúsculas, minúsculas

ou normal (permitindo tudo).
• Text: É o texto digitado no edit.
O MaskEdit é um edit especial, cujo Text pode ser formatado usando máscaras, com a
propriedade EditMask. Basta utilizar o editor de mascaras que não tem mistério! Já o
LabeledEdit é um edit que já vem com um Label embutido, que agiliza ainda mais a
criação de telas. A propriedade EditLabel permite configurar as propriedades do Label
embutido. de novidade só temos as propriedades LabelPosition e LabelSpacing, que
controlam a posição (esquerda, direita, acima e abaixo) e a distância do Label interno
em relação ao edit.
5.8 O Painel
Um painel é um componente do tipo TPanel, que é um contêiner para outros
componentes. è usado para organizar o layout do Form, agrupando componentes,
portanto suas funcionalidades se restringem ao projeto na maioria dos casos. Sus
propriedades mais usadas são as que controlam a aparência das bordas:
• BevelInner: Controla o layout da borda interna.

• BevelOuter: Manipula a borda externa.
• BevelWidth: É o tamanho das bordas.
Seus valores definem se a borda será “pra fora” (raised), “pra dentro” (lowered) ou
nehuma.
Pode-se criar efeitos interessantes combinando de formas diferentes as bordas do
Panel.
5.9 Barra de Status

O componente TStatusbar é o responsável por representar as barras de status,
bastante comuns em diversos tipos de programas. Na realidade, o mérito não está na
StatusBar em si, mas na propriedade Panels. É nos painéis que criamos dentro da
StatusBar que inserimos os textos que ela exibe. Os TStatusPanel têm como
propriedades mais legais:
• Alignment: É o alinhamento do texto do painel (esquerdo, direito ou centralizado)

• Bevel: Se o painel terá visual “raised” ou “lowered”, como um Tpanel
• Text: O texto que será exibido no StatusPanel.

A StatusBar pode ser usada sem os StatusPanels (ativando a propriedade

SimplePanel, e preenchendo a propriedade SimpleText), mas aí adeus alinhamento e
adeus bevel.
5.10 RadioButton
O RadioButton é um componente usado para implementar uma seleção onde
as opções são mutuamente exclusivas, ou seja, o usuário só pode marcar um valor.
O estado do RadioButton pode ser lido através da propriedade Checked, que é
True se ele estiver marcado e False caso contrário.
Fato curioso é que se houverem vários RadioButtons no mesmo parent, eles
assumen automaticamente o comportamento de mútua exclusão, sem precisar de
nenhuma programação!
5.11 CheckBox
Assim como o RadioButton, serve para implementar seleções, mas com a
CheckBox o usuário pode marcar várias opções ao mesmo tempo. Também possui a
propriedade Checked, que guarda seu estado, exatamente como o RadioButton.
5.12 RadioGroup
Usado para simplificar a criação de vários RadioButtons agrupados. Nele, cada
RadioButton é tratado como uma linha editada na propriedade Items. Para saber qual
deles está selecionado, usamos a propriedade ItemIndex, que começa no Item 0 e
termina no Item n-1 (para que nenhum item seja marcado, configure ItemIndex como -
1).
Quanto à organização dos RadioButtons em seu interior, o Radiogroup
costuma colocar um por linha, o que nem sempre fica bonito... Para resolver este
impasse, basta configurar a propriedade Colunms para o número de colunas desejado!
5.13 ComboBox
As ComboBoxes são como Edits com uma lista embutida que se abre ao
clicarmos no botão com a setinha à direita. Vamos ver suas propriedades mais
manjadas:

• Items: Igual à Items do RadioGroup, é a lista dos itens que aparecerão na lista
quando o botão for pressionado.
• ItemIndex: Também é como à do RadioGroup, retornando o índice do item da lista
que está selecionado. Se não há itens selecionados, ItemIndex assume o valor -1.
• DropDownCount: Número máximo de itens que aparecerão na lista suspensa. Se
o número de itens for maior que o valor de DropDownCount, uma barra de rolagem
aparece.
• Sorted: Se esta propriedade for habilitada, os itens serão ordenados.
• Style: Determina o estilo do display da ComboBox. Serve principalmente para
controlar se ela é editável (csDropDown) ou se serve apenas para seleção
(csDropDownList).
• Text: É o texto do elemento corrente.
5.14 MainMenu e MenuItem

O MainMenu é o componente que representa a barra de menu de um
formulário e serve como contêiner para os objetos MenuItem, que são os menus
propriamente ditos. Os MenuItem são componentes que não aparecem na paleta de
componentes e só podem ser criados em tempo de projeto através da propriedade
Items do MainMenu, que abre o editor “Menu Designer”, que permite criar os
MenuItems facilmente, apenas usando as setas e o clique com botão direito, onde
estão algumas funcionalidades como “Create Sub-Menu”, que cria um sub-menu de
um MenuItem na lateral, iniciando um outro ramo.
Existe um tipo especial de item, o separador, que é uma linha que separa
outros itens. Para criar um separador, basta colocar um “-” no Caption. Algumas
propriedades importantes do MenuItem são:
• Checked: Cria um menu de checagem, igual ao do “Quebra automática de linha”

do bloco de notas
• RadioItem: quando habilitada em vários MenuItems, cria neles comportamento de
RadioButtons, ou seja, a seleção de exclusão mútua.
• Bitmap: Coloca uma imagem no menu, como as do menu do Delphi
• ShortCut: Cria um atalho de teclado para o menu, que pode ser acionado sem abri-
lo, como o Salvar do bloco de notas Ctrl + S.
• ImageIndex: É uma outra forma de colocar imagens nos menus, que ao invés de
selecionar um bitmap diretamente, trabalha em parceria com um componente

ImageList, que guarda uma lista de imagens. ImageIndex é o índice de cada

imagem guardada no ImageList, que será visto mais a frente. A image list é
associada ao MainMenu, através da propriedade Images.
5.15 PopupMenu
Componente usado para implementar menus estilo pop-up (não diga!), que
aparecem quando clicamos com o botão direito. A criação de itens é idêntica à do
MainMenu.
5.16 Toolbar
É o componente usado para criar barras de ferramentas. Sua propriedades
mais usadas são:
• ButtonHeight e ButtonWidth: Controlam a altura e a largura dos botões

adicionados na barra.
• Customizable: Se estiver ativa, permite que o usuário modifique a barra de
ferramentas em tempo de execução, de duas formas diferentes: com duplo click,
chamando o diálogo de customização (semelhante ao do Internet Explorer) ou
segurando a tecla Shift, o que permite que os botões sejam arrastados para outras
posições ou para fora da barra, o que os exclui.
• ShowCaptions: Se estiver True, exibe os Captions dos botões.
• Flat: Faz com que os botões fiquem sem borda até que o mouse passe sobre eles.
Se flat é False, os botões ficam sempre com borda (o que dá à aplicação um
aspecto de programa antigo!).
• Images: Associa a Toolbar com um objeto ImageList, para que as imagens
contidas nele possam ser colocadas nos botões.
Os botões colocados na Toolbar são um tipo especial de botão, da classe TToolButton,

e podem ser adicionados à barra de ferramentas clicando com o botão direito e
escolhendo “New Button”. O ToolButton pode assumir a forma de um separador, se
adicionarmos “New Separator”, ou então mudando sua propriedade Style para
tbsSeparator. As principais propriedades dos ToolButtons são:
• Style: Como já foi mencionado, controla o estilo do botão, tipicamente entre

tbsButton e tbsSeparator. Mas há outras possibilidades, dentre as quais se destaca

a tbsDropDown, usada para fazer um ToolButton como o Run do Delphi, que tem
um menuzinho abaixo! Para se usar este estilo, devemos preencher a propriedade
DropdownMenu.
• DropdownMenu: Associa o ToolButton a um PopupMenu, criando assim a listinha
que surge quando o ToolButton é criado.
5.17 ImageList
Chegou a hora de falarmos a respeito da tão comentada ImageList, que já deu
as caras nos tópicos sobre menus e Toolbar. Este componente guarda uma lista de
imagens para compartilhar com outros componentes, principalmente com Menus e
barras de ferramentas, que a referenciam a ImageList pela propriedade Images, e
depois por ImageIndex obtém uma das imagens armazenadas nela.
Normalmente não se configura nenhuma propriedade da ImageList, apenas
adicionamos imagens a ela, dando um duplo click para chamar o editor, que faz as
operações de adicionar excluir ou mudar as imagens. Não há complicações para usá-
lo!
5.18 ActionList e Actions

Sem dúvida são dois dos componentes mais interessantes e importantes do
Delphi! A ActionList é apenas um contêiner para as Actions, os componentes que
realmente fazem todo o trabalho.
Com eles, é possível centralizar funcionalidades e propriedades que são
compartilhadas entre vários componentes, chamados de clientes das Actions.
A Aplicação típica destes componentes é manter a consistência entre o menu
da aplicação e a barra de ferramentas, já que a Toolbar é só um atalho para as
funcionalidades disponíveis no menu, os dois objetos acabam tendo elementos em
comum, tanto no que diz respeito à funcionalidade quanto também às figuras, captions,
hints, enable, atalhos de teclado, etc. Em outras palavras, se temos um menu que
salva um arquivo, cujo ícone é um disquete, o hint e o caption são “Salvar”, o atalho de
teclado é Ctrl + S e fica desabilitado se o arquivo já foi salvo, vamos querer que o
botão correspondente na barra de ferramentas tenha as mesmas características e
funcionalidade, certo? Para não termos que configurar os dois separadamente e
manter a consistência do enable “no braço”, usamos a ActionList para centralizar todas
estas características em componentes Action e então, configuramos tanto o item de
menu quanto o tool button para serem clientes da mesma Action de salvar. Pronto! Os

clientes automaticamente assumem as propriedades definidas na Action, bem como o

evento de salvar!
Na ActionList, a única propriedade utilizada efetivamente na prática é a Images,
que a associa com um objeto ImageList. Com isso, as Actions contidas nela podem
acessar cada imagem pelo ImageIndex.
Para criarmos as Actions que estarão contidas na ActionList, basta dar um
duplo click nela para abrir o editor. Com ele, podemos criar dois tipos de Actions, as
Standard e as comuns. Standard Actions são componentes descendentes de TAction
que já possuem funcionalidades prontas de várias categorias diferentes. Antes de
pensar em criar uma Action do zero, dê uma olhada nas Standard... quem sabe ela já
não está lá prontinha, esperando por você! (é aquela velha história de não reinventar a
roda...).
As funcionalidades de uma Action devem ser implementadas no evento
OnExecute. Depois, no componente cliente, este evento deve ser associado ao evento
adequado (no caso dos menus, Toolbuttons e Botões comuns, OnExecute é
automaticamente associado ao evento OnClick, mas ele pode ser associado a
qualquer outro evento do tipo TNotifyEvent, como vimos na parte sobre tipos
procedurais)
Moral da história: nada de configurar captions, bitmaps, hints, etc. de menus e
barras de ferramentas. Apenas crie os MenuItens e os Toolbuttons, associe a
ImageList e faça a propriedade Action referenciar a Action correspondente que ela faz
o resto! E em tempo de execução, para mudar o enable do menu salvar e do botão
salvar do nosso caso hipotético, mude o enable apenas na Action de salvar e pronto!
O enable de todos os clientes dela muda junto!
5.19 Diálogos
Os diálogos são os componentes que encapsulam os principais diálogos do
Windows, como o diálogo de abertura de arquivos, salvamento de arquivos, diálogo de
impressão, de fonte, de cores... todos estão lá!
O método central de um diálogo é o Execute, usado para abrir a janela do
diálogo para que o usuário interaja com ele. O método execute é uma função booleana
que retorna True se o usuário confirmou a operação executada pelo diálogo, clicando
no botão OK. Se o usuário desistir da operação clicando em cancelar, Execute retorna
False. Desta forma podemos testar este retorno e só implementar nosso código
quando o usuário realmente confirmar a operação. A seguir temos uma visão geral de
alguns diálogos:

• OpenDialog: Componente que representa o diálogo de abertura de arquivos: Suas

propriedades mais importantes são:
o DefaltExt: É a extensão padrão que é adicionada ao nome do arquivo
que queremos abrir, caso estejamos digitando e a extensão não for
fornecida. Não é necessário colocar o ponto no valor da propriedade.
o Filename: Guarda o nome do arquivo selecionado para a abertura ou
que foi aberto.
o Filter: Permite filtrar os tipos de arquivo que queremos que apareçam
no diálogo. Possui um editor onde especificamos o nome do filtro (tipo
“Arquivos de texto” ou “Imagens JPEG”). O filtro é escrito na forma
“*.txt” ou “*.jpeg” por exemplo. Para exibir todos os tipos de arquivo,
faça um filtro do tipo “*.*”.
o FilterIndex: Cada filtro criado em Filter recebe um índice, de 1 a n.
FilterIndex define o índice do filtro que estará ativo.
o InitialDir: Define o diretório inicial que aparece quando o diálogo é
aberto.
o Title: É o texto que vai aparecer no caption do diálogo.
o Options e OptionsEx: Estas extensas propriedades fornecem diversas
opções de configuração para o diálogo, mas que raramente são usadas.
Por isso, não as discutiremos aqui (devido também ao grande número
de opções disponíveis, perderíamos muito tempo para discuti-las e não
são tão complicadas de entender).
• SaveDialog: Diálogo para salvar arquivos. Possui as mesmas propriedades do
OpenDialog, mudando apenas a função de abrir para salvar. Não tem mistério!
• OpenPictureDialog e SavePictureDialog: Idênticos aos dois anteriores, porém
espacializados em arquivos de imagens.
• FontDialog: É o diálogo de fontes. Tudo nele gira em torno da propriedade fonte,
onde é guardada a fonte selecionada e onde configuramos a fonte na qual ele vai
abrir.
• ColorDialog: Diálogo de cores. Sua principal propriedade é Color, de onde
obtemos a cor selecionada pelo usuário e através da qual configuramos a cor inicial
no momento de abertura do diálogo.
• PrinterSetupDialog: É o diálogo de configurações da impressora. Não tem
nenhuma propriedade interessante; todas as suas funcionalidades só surgem em
execução, no diálogo propriamente dito.

• PrintDialog: Diálogo que configura propriedades da impressão, como número de

cópias por exemplo.
• PegeSetupDialog: É o diálogo onde se configura as características das páginas,
como o tamanho das margens e tamanho do papel por exemplo.
• FindDialog e ReplaceDialog: São os diálogos que permitem a localização e a
substituição de trechos de um texto. Só que os diálogos, ao contrário do que possa
parecer, não possuem as funcionalidades de localização e substituição; é o
programador que deve fazer estas operações por código! Os diálogos servem
apenas para coletar aquilo que o usuário deseja fazer (que texto deverá ser
localizado/substituído; se a busca irá diferenciar maiúsculas e minúsculas; se deve
buscar apenas palavras inteiras, etc.). Então, a partir dos valores armazenados em
suas propriedades, desenvolve-se o código que irá fazer aquilo que o usuário
solicitou. As propriedades utilizadas são:
o FindText: O texto a ser localizado.
o ReplaceText: Pertence ao ReplaceDialog e é o texto pelo qual o
FindText dele deverá ser substituído.
o Options: Guarda as opções de pesquisa definidas pelo usuário num
Set, no qual podemos testar se uma determinada opção está presente –
pesquisar apenas palavras inteiras é frWholeWord, diferenciar
maiúsculas e minúsculas é frMatchCase, e assim por diante.

Apostila Delphi

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Apostila Delphi

Enviado por

Direitos autorais:

Formatos disponíveis

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

1 A HISTÓRIA DA LINGUAGEM PASCAL .............................................................................................................. 3

2 INTRODUÇÃO AO AMBIENTE DELPHI ............................................................................................................... 4

2.1 O Form Designer .............................................................................................. 5

3.1 VCL x CLX .................................................................................................... 24

Prof. Cesar Rodrigo -1-

4.7.7 Tratamento de Exceções......................................................................... 65

5.1 Relacionamentos entre Componentes............................................................. 71

Prof. Cesar Rodrigo -2-

1 A História da Linguagem Pascal

Prof. Cesar Rodrigo -3-

2 Introdução ao Ambiente Delphi

Prof. Cesar Rodrigo -4-

2.1 O Form Designer

É sobre esta janela que a interface gráfica da aplicação é desenvolvida,

Prof. Cesar Rodrigo -5-

No grupo “Grid Options” podemos escolher se o grid será ou não exibido

O grupo “Module creation options” permite escolher se o Delphi irá criar

Prof. Cesar Rodrigo -6-

No exemplo, temos uma aplicação com 3 formulários, mas apenas aquele

Voltando às Environment Options, resta-nos comentar o grupo “Options” que tem

Prof. Cesar Rodrigo -7-

Em “Show designer hints” habilitamos as informações que surgem quando o

Mesmo estando inicialmente vazio, o formulário padrão fornecido pelo Form

Prof. Cesar Rodrigo -8-

Cada formulário criado no Delphi é acompanhado de sua respectiva Unit, que é o

2.2 O Code Editor

Prof. Cesar Rodrigo -9-

Em “Code Insight” configuramos os recursos que permitem completar código,

Prof. Cesar Rodrigo - 10 -

Na palheta “Source Options”, não há necessidade de alterar nada. Tudo está

Mas nela encontramos o interessantíssimo recurso “Edit Code Templates”. Os

Prof. Cesar Rodrigo - 11 -

Com o botão “Add” podemos incluir um novo template, dando-lhe um “Shortcut

Prof. Cesar Rodrigo - 12 -

2.3 Object Inspector

A palheta Properties nos dá acesso a todas as propriedades de visibilidade

Prof. Cesar Rodrigo - 13 -

À esquerda podemos mudar as cores dos elementos do Object Inspector e à direita

Prof. Cesar Rodrigo - 14 -

mas se as agruparmos; poderemos visualizar todas em um grupo. Veja o aspecto das

2.4 Object Tree View

Prof. Cesar Rodrigo - 15 -

2.5 A Palheta de Componentes

Algumas palhetas de componentes importantes são:

Prof. Cesar Rodrigo - 16 -

que nos permite criar um layout de palhetas, como a própria palheta de

2.6 Project Manager e Project Group

Prof. Cesar Rodrigo - 17 -

Na figura vemos 5 diferentes programas num mesmo Project Group. Cada um

2.7 Salvando um Layout Personalizado

Lista de layouts salvos

Prof. Cesar Rodrigo - 18 -

2.8 Customizando as Barras de Ferramentas do Delphi

2.9 Debugando Aplicações

Prof. Cesar Rodrigo - 19 -

2.9.1 Break Point

Para colocar/retirar um Break Point, basta clicar na margem cinza da esquerda

Prof. Cesar Rodrigo - 20 -

No campo “Condition” basta informar a condição de parada tipo “Contador =

2.9.2 Whatch List

Prof. Cesar Rodrigo - 21 -

Os valores das variáveis em Watch Name aparecerão ao lado na coluna Value.