Apostila Mini-Curso Delphi - Dia 3

Mini-Curso Delphi Marcos Paulo Salvador de Oliveira
Mini-Curso Delphi
1. INTRODUÇÃO.................................................................................................................................1
1.1. FAMILIARIZAÇÃO COM O AMBIENTE DE PROGRAMAÇÃO ...........................................................1
1.2. SUBDIVISÕES DO AMBIENTE DE PROGRAMAÇÃO DELPHI ...........................................................2
1.2.1 Menu Principal .....................................................................................................................3
1.2.2 Gerenciador de Desktops .....................................................................................................3
1.2.3 Palheta de Botões Rápidos ...................................................................................................4
1.2.4 Palhetas de Componentes.....................................................................................................4
1.2.5 Formulário ...........................................................................................................................4
1.2.6 “Code Editor” ......................................................................................................................5
1.2.7 “Object TreeView”...............................................................................................................6
1.2.8 “Object Inspector” ...............................................................................................................7
1.3. AMBIENTE “DRAG AND DROP” ..................................................................................................8
2. FERRAMENTAS DO AMBIENTE DE PROGRAMAÇÃO........................................................9
2.1. “CODE COMPLETITION” .............................................................................................................9
2.1.1 Chamando o “Code Completition” ....................................................................................10
2.1.2 Refinando a busca do “Code Completition” ......................................................................10
2.2. ESTRUTURAS DE PROGRAMAÇÃO PRÉ-ESTABELECIDAS (“CODE TEMPLATES”).......................11
2.2.1 Utilizando “Code Templates” ............................................................................................11
2.2.2 Adicionando “Code Templates”.........................................................................................12
3. PROGRAMANDO EM DELPHI ..................................................................................................14
3.1. TIPOS DE ARQUIVOS GERADOS PELO DELPHI ...........................................................................14
3.2. O QUE SALVAR?.......................................................................................................................16
3.3. NORMA INTERNACIONAL DE NOMENCLATURA DE VARIÁVEIS E OBJETOS ...............................17
3.4. CASE-INSENSITIVE ...................................................................................................................17
3.5. CRIAÇÃO DE VARIÁVEIS ..........................................................................................................18
3.6. CONSTANTES............................................................................................................................19
3.7. TIPOS .......................................................................................................................................19
3.8. CRIAÇÃO DE ROTINAS ..............................................................................................................20
3.8.1 Parâmetros .........................................................................................................................21
3.8.2 Procedimentos ....................................................................................................................21
3.8.3 Funções ..............................................................................................................................22
3.8.4 Onde declarar rotinas ........................................................................................................22
3.9. CRIAÇÃO DE MÉTODOS ............................................................................................................23
3.9.1 Onde Declarar Métodos .....................................................................................................24
3.9.2 Facilitando as Coisas .........................................................................................................25
3.10. CRIAÇÃO DE UNITS ..................................................................................................................25
3.10.1 Interface.........................................................................................................................26
3.10.2 Implementation ..............................................................................................................27
3.11. EVENTOS ..................................................................................................................................28
3.12. TRATAMENTO DE EXCEÇÕES ....................................................................................................30
3.12.1 Try ... Except..................................................................................................................30
3.12.2 Try ... Finally .................................................................................................................31
4. COMPILANDO E DEBUGANDO................................................................................................31
4.1. COMPILANDO ...........................................................................................................................31
4.1.1 Gerando o executável .........................................................................................................31
4.1.2 Erros de Compilação..........................................................................................................32
4.2. DEBUGANDO ............................................................................................................................33
4.2.1 BreakPoints ........................................................................................................................33
4.2.2 Watches ..............................................................................................................................34
I
5. INTERFACE COM O USUÁRIO.................................................................................................35
5.1. PANELS ..........................................................................................................................36
5.2. CRIAÇÃO DE MENUS .....................................................................................................36

5.2.1 Adicionando o Componente de Menu.................................................................................36
5.2.2 Criando Itens de Menu .......................................................................................................37
5.2.3 Criando SubMenus .............................................................................................................38
5.3. CRIAÇÃO DE BARRAS DE FERRAMENTAS ......................................................................38

5.3.1 Adicionando Botões............................................................................................................39
5.3.2 Adicionando Separadores...................................................................................................40
5.4. CRIAÇÃO DE BARRAS DE STATUS .................................................................................40

5.4.1 Exibindo Dicas ...................................................................................................................40
5.5. CRIAÇÃO DE MDIS...................................................................................................................40
5.5.1 MDI Forms .........................................................................................................................41
5.5.2 MDI Childs .........................................................................................................................41
5.6. CRIAÇÃO DE TELAS DE SPLASH ................................................................................................42
6. CRIAÇÃO DINÂMICA DE OBJETOS .......................................................................................42
6.1. CRIANDO UM BOTÃO DINAMICAMENTE ....................................................................................42
7. BANCO DE DADOS.......................................................................................................................43
7.1. TABLES ...........................................................................................................................43

7.1.1 Configurando uma Table....................................................................................................44
7.2. DATASOURCES ..............................................................................................................45

7.2.1 Configurando um DataSource............................................................................................45
7.3. CONTROLADORES DE DADOS OU COMPONENTES DB...............................................................45
7.3.1 DBEdit ......................................................................................................................46
7.3.2 DBNavigator .............................................................................................................46
7.3.3 DBGrid ......................................................................................................................46
7.4. DATABASES ...................................................................................................................46

7.4.1 Configurando um DataBase ...............................................................................................47
7.5. QUERIES .........................................................................................................................47

7.5.1 Configurando uma Query ...................................................................................................48
7.5.2 Adicionando Parâmetros ....................................................................................................48
7.5.3 Modificando as Linhas e Colunas exibidas por uma Query...............................................48
7.6. INSTALLSHIELD É FUNDAMENTAL! ..........................................................................................48
II
1. Introdução
Este tópico destina-se a dar uma visão geral sobre o ambiente de programação
da Borland®: Delphi® 7.0 Studio, mostrando suas principais características e sua
organização para melhor atender aos programadores.
1.1. Familiarização com o Ambiente de Programação
®
O ambiente de programação Delphi é uma ferramenta projetada para facilitar a
programação rápida e fácil de qualquer aplicação. Esta ferramenta conta com uma
interface totalmente interativa. Baseando-se em uma programação orientada a objetos
utilizando recursos de “drag and drop”, o ambiente proporciona ao programador um
ganho de tempo muito grande. Este tempo poderá ser usado na programação dos
eventos necessários para o pleno funcionamento do sistema.
Uma outra vantagem da ferramenta Delphi® é a quantidade de componentes
existentes na Internet que podem ser facilmente instalados, além da grande gama de
componentes que já vêm com a ferramenta.
O ambiente Delphi® foi projetado para proporcionar ao programador um meio
rápido, limpo e preciso de programação, no qual apenas é necessário preencher as
lacunas que serão criadas pela programação dos eventos, como veremos adiante.
Entretanto, este ambiente de programação se torna um tanto quanto prejudicial
para programadores novos. Como toda a estruturação e criação de objetos é feita
automaticamente pelo ambiente, o programador não tem espaço para treinar suas
habilidades. Portanto, recomenda-se este ambiente para programadores mais experientes
ao lidar com objetos e que visem aumentar sua produtividade. Deve-se salientar,
entretanto, que este fator não é uma desvantagem, pois não impede que o programador
altere os objetos criados para adaptá-los às suas necessidades.
Todas as versões do Delphi até hoje lançadas são feitas sobre o conceito de
linguagem de programação compilada, ou seja, o código fonte é interpretado e
transformado em objeto para depois dar origem ao executável. Existem boatos de que a
Borland®, fabricante do Delphi® está desenvolvendo uma Máquina Virtual Delphi para
que assim como no Java® o programa gerado tenha maior portabilidade, ou seja, que
possa ser executado independente do sistema operacional.
Este curso de programação em Delphi® versará sobre a versão 7.0 do compilador
e debugger Delphi®, que além de proporcionar algumas mudanças na sua interface
tradicional, permite o uso de alguns recursos de interface de programação mais
avançados (principalmente para serem usados com o Windows XP®). Outra mudança
observada é que a nova versão do ambiente permite ao usuário utilizar alguns recursos a
mais de programação Web, dentre os quais uma integração Java® é o mais chamativo
deles.
Curiosidade: A Borland também tem uma versão do ambiente de programação Delphi

desenvolvida para o Sistema Operacional Linux, que curiosamente não recebe o mesmo
nome, sendo conhecida como Kylix.
1
Ambiente de Programação Delphi 7.0
1.2. Subdivisões do Ambiente de Programação Delphi
O ambiente de programação Delphi® 7.0 apresenta subdivisões para melhor

facilitar o trabalho do programador. Algumas dessas subdivisões podem estar ou não
ativas, de acordo com as configurações do ambiente. Todas as subdivisões são de vital
importância para o programador, pois são elas as responsáveis pela velocidade na
programação.
2
Subdivisões do Ambiente de Programação
1.2.1 Menu Principal
Permite o acesso a todas as funções disponíveis no ambiente de programação,

através dele todas as demais subdivisões poderão ser ativadas ou desativadas. Através
deste menu poderemos também ter acessos às opções de programação, compilação,
debug, do editor de código, entre diversas outras.
O Menu Principal é o responsável por todo o gerenciamento do ambiente de
programação Delphi® 7.0 e normalmente pouco muda de uma versão para outra do
ambiente.
Menu Principal
1.2.2 Gerenciador de Desktops
O Gerenciador de Desktops é uma das partes do ambiente de programação

destinada aos programadores metódicos e ”chatos” que gostam de sempre ter as suas
3
janelas organizadas a seu modo. Esta ferramenta permite que o programador salve as
configurações do Desktop do ambiente de trabalho Delphi® 7.0 para que possa
futuramente utilizá-las caso ocorra alguma desordem. As principais características
salvas são o posicionamento das janelas e viewers.
Gerenciador de Desktops
1.2.3 Palheta de Botões Rápidos
A Palheta de Botões Rápidos contém botões com as funções mais utilizadas

pelos programadores no ambiente de programação Delphi® 7.0. Esta palheta foi criada
com o objetivo de proporcionar maior rapidez e alcance mais rápido e fácil destas
funções evitando assim o desperdício de tempo na procura das mesmas. A maioria das
ações disponíveis nesta palheta possui um atalho correspondente o que torna o uso das
funções ainda mais rápido e fácil para aquelas que tem boa memória.
Palheta de Botões Rápidos
1.2.4 Palhetas de Componentes
As Palhetas de Componentes são as palhetas fundamentais do ambiente de

programação Delphi® 7.0. Através destas palhetas o programador tem acesso à maioria
dos recursos e objetos “Drag and Drop” do ambiente.
Cada versão Delphi® 7.0 conta com uma certa quantidade, sendo que a mais
simples das versões conta com as palhetas mais básicas. Conforme as versões vão se
tornando mais profissionais (e mais caras), o número de componentes vai aumentando,
assim como o número de palhetas. A versão Enterprise Padrão do Delphi® 7.0 conta
com aproximadamente 27 Palhetas de Componentes, estas palhetas contém desde
componentes de interface até componentes para conexão Web e ActiveX.
Palhetas de Componentes
1.2.5 Formulário
Uma das subdivisões do ambiente de programação Delphi®, o Formulário é a

principal peça na programação de interfaces. Ele serve como “Dock Site”, ou seja, local
4
onde os “Drags” terminam. Esta única e simples função permite que todos os
componentes encontrados na Palhetas de Componentes possam ser posicionados em seu
interior. O Formulário serve também como fundo para as interfaces do usuário, onde
serão colocados botões, caixas de texto, figuras, etc.
O formulário pode nem sempre estar visível ao programador ou ao usuário,
porém sempre que estiver terá uma “Unit’ associada a ele, dentro da qual haverá seu
código-fonte e o código de todos os componentes que ele contiver como filhos, ou seja,
todos os componentes em seu interior.
Formulário
1.2.6 “Code Editor”
O Code Editor é área do ambiente de programação do Delphi® destinada a

receber o código-fonte do programa, compreendendo objetos, métodos, variáveis,
tratamento de eventos e exceções, entre outros.
O Code Editor contém também, assim como todas as outras subdivisões,
recursos que tornam a edição de códigos cada vez mais rápidas. Dentre estes recursos
podemos citar o “Code Completition” que será discutido no tópico 2.
Esta ferramenta possui também Syntax Highlight para auxiliar na distinção entre
palavras reservadas, comentários, variáveis, entre outros.
5
Code Editor com um trecho de Código Básico
1.2.7 “Object TreeView”
O “Object TreeView” é uma ferramenta que proporciona uma visão geral de

todos os objetos que estão sendo utilizados no projeto em questão. Os objetos são
listados de acordo com o seu nome (fornecido pela propriedade Name). Cada objeto
pode conter diversos outros objetos que serão mostrados em forma de árvore,
começando dos containeres maiores, em direção aos menores.
Um clique sobre o nome de um objeto no “Object TreeView” faz como que este
objeto seja selecionado e suas propriedades e eventos então mostrados no “Object
Inspector”.
6
Object TreeView
1.2.8 “Object Inspector”
O “Object Inspector” é uma área de visualização e configuração de um objeto.

A partir de um objeto selecionado, suas propriedades e eventos são mostrados e poderão
ser então alterados de acordo com as necessidades do programador.
Para alterar uma propriedade, basta clicar na propriedade desejada, sobre o
campo de edição e então escrever o novo valor, ou selecionar algum objeto ou arquivo
em um diálogo aberto.
Para alterar ou criar um evento basta dar um clique duplo sobre a caixa de
edição do evento em questão, o “Code Editor” será então lançado para que a edição do
código do evento seja feita.
Curiosidade: itens em vermelho são propriedades ou eventos que poderão possuir

vínculos com outros objetos se o programador assim achar necessário.
7
Object Inspector
1.3. Ambiente “Drag and Drop”
O ambiente de programação do Delphi® 7.0 Studio por ser altamente integrado

permite que a maioria dos objetos criados nele sejam inseridos na aplicação através do
arrastar e clicar. Este recurso aumente a velocidade de programação e proporciona
maior precisão no posicionamento de componentes de interface. Além dessa facilidade
de posicionamento devemos salientar a economia de tempo que o programador adquire.
Na maioria dos ambientes ou linguagens de programação, o programador depois de
posicionar através de linhas de comando o seu componente ou objeto, tem que compilar
o código, verificar o posicionamento e se algo estiver errado, tentar adivinhar o valor
adequado para a posição do objeto.
Ao falarmos em “Drag and Drop” não podemos nos esquecer do formulário já
citado anteriormente. É o formulário que serve como “dock”, ou seja, o formulário é o
objeto recipiente dos componentes. Porém o formulário não é o único recipiente de
objetos, mas sim o principal. Outros componentes como panels, por exemplo, podem
receber componentes de outros tipos ou até mesmo panels.
8
Componentes sendo posicionados em regiões de “dock”
2. Ferramentas do Ambiente de Programação
Este módulo é destinado à prática de programação rápida. Nele serão

apresentados recursos do ambiente de programação que são extremamente úteis para o
desenvolvimento de aplicações. Estes recursos permitem que o programador economize
tempo de digitação e se preocupe mais com a lógica do que com a digitação.
2.1. “Code Completition”
O “Code Completition” como o próprio nome diz é um completador de códigos.

Por essa característica é um recurso muito utilizado quando se pretende desenvolver
aplicações rapidamente.
Este recurso possibilita que o programador visualize todas as funções,
procedimentos, classes, objetos, variáveis entre outros que estão definidas e que poderão
ser utilizadas. O “Code Completition” é muito inteligente e mostra sempre ao
programador as opções adequadas para completar o código.
Nota: se o “Code Completition” não conseguir exibir nenhuma opção para completar o
código, isto indica que o código apresenta erros em posições anteriores a que ele foi
9
chamado, ou que ele ficou em dúvida sobre a melhor opção a escolher. O último caso
geralmente ocorre com tipos definidos pelo usuário ou diante do uso de type-casting.
2.1.1 Chamando o “Code Completition”
O “Code Completition” conforme dito anteriormente é um recurso do “Code

Editor”, portanto só pode ser chamado dentro do mesmo. Uma vez dentro do “Code
Editor”, o “Code Completition” poderá ser chamado em qualquer lugar (exceto para
completar nome de “units” após os comandos “uses”), pressionando-se as teclas
<CTRL>+<Barra de Espaço>. Ao pressionar esta combinação de teclas, uma lista
com todas as opções possíveis de complemento será apresentada. Basta então escolher a
opção adequada e pressionar <ENTER>.
2.1.2 Refinando a busca do “Code Completition”
Quanto maior a quantidade de letras que estiverem digitadas antes de chamar o

“Code Completition”, maior será o refinamento da busca, menor o número de resultados
e melhor a qualidade dos mesmos. O refinamento da busca poderá ser feito com a lista
de resultados já aberta, o que causará um atualização da mesma para se adequar aos
novos requisitos da busca.
Exemplo de uso do “Code Completition”
No exemplo da figura acima foi definida uma variável nome do tipo string em
um procedimento qualquer. Logo em seguida, no corpo do procedimento, chamamos o
10
“Code Completition” fornecendo apenas a primeira letra da variável que já conhecíamos.

Por sorte ela é a primeira da lista, basta agora pressionar <ENTER> e usá-la! Se a
variável não fosse a primeira da lista, bastava navegar pela mesma utilizando as setas
para cima e para baixo, ou então continuar fornecendo letras com a lista aberta. Ao
fornecer mais letras com a lista aberta, ela automaticamente se atualiza.
Na figura acima se nota que a lista apresenta 2 colunas distintas:
• Primeira Coluna ou Coluna dos Tipos: esta coluna indica o tipo do
elemento que aparece na segunda coluna, ou seja, se ele é uma variável,
função, procedimento ou um tipo em si;
• Segunda Coluna ou Coluna dos Identificadores: nesta coluna os
identificadores aparecem, ou seja, os nomes das variáveis, rotinas ou tipos,
assim como seus parâmetros e no caso de variáveis e funções o tipo de
dados que comportam e retornam respectivamente.
2.2. Estruturas de Programação Pré-Estabelecidas (“Code Templates”)
É muito comum que uma aplicação contenha estruturas de programação das

mais variadas formas e tamanho, e na maioria das vezes estas estruturas se repetem.
Seria muito mais fácil para o programador ter estas estruturas de programação como
while, for, entre outras pré-definidas para quando necessário invocá-las. Para isso o
Delphi® 7.0 Studio conta com um recurso similar ao “Code Completition”, porém para
complementar estruturas de programação. Estas estruturas pré-definidas são as “Code
Templates”.
2.2.1 Utilizando “Code Templates”
O uso das “Code Templates” se dá de maneira similar ao uso do “Code

Completition”. Dentro do “Code Editor”, em uma região válida, ou seja, dentro de uma
função ou procedimento, pressione as teclas <CTRL>+<J>. Uma lista com as opções de
estruturas pré-definidas será apresentada. Ao escolher a estrutura adequada pressione
<ENTER> e ela será inserida no seu código-fonte. Assim como descrito na explicação
do “Code Completition”, a busca pela templates poderá ser facilitada se uma ou mais
letras do nome fornecido à template forem indicadas antes de pressionar a combinação
de teclas.
Assim como a lista de opções do “Code Completition”, a lista de opções das
“Code Templates” possui duas colunas, a saber:
• Primeira Coluna ou Coluna da Descrição: esta coluna mostra uma
descrição do tipo de código que será inserido no “Code Editor” ao se
escolher a template em questão;
11
• Segunda Coluna ou Coluna do Nome: esta coluna exibe o nome pré-

definido para o conjunto de comandos ou estrutura de programação
estabelecida pelo programador. Este nome é que deve ser digitado para
facilitar a busca ou para que a template seja inserida.
Lista de “Code Templates
2.2.2 Adicionando “Code Templates”

Para adicionar “Code Templates” basta realizar os seguintes passos:
1. No Menu Tools vá em Editor Options. A janela da figura abaixo deverá
aparecer;
Janela de Propriedades do Code Editor
12
2. Em Source Options clique no botão Edit Code Templates;
Janela de Propriedades do Code Editor – Editando Templates
3. Na Janela que se abre escolha entre abrir, editar ou excluir o nome ou a

descrição de uma template. O código da mesma pode ser alterado
diretamente abaixo da lista em “Code”
Editor de Templates
Nota: o caractere “|” (pipe ou barrinha em pé) que aparece nas definições da maioria das
templates que acompanham Delphi® 7.0 Studio indica o lugar onde o cursor irá para
depois que a template for inserida no “Code Editor”.
13
3. Programando em Delphi
Neste tópico em a preocupação principal será a codificação em Delphi,

introduzirá o usuário em alguns princípios básicos de programação. Será mostrado
como fazer para que o código se torne o mais claro possível, facilitando posterior
manutenção do mesmo.
3.1. Tipos de Arquivos Gerados pelo Delphi
Cada aplicação ou projeto gerados no Delphi pode gerar um número bem grande
de arquivos. Cada tem o seu papel especial no armazenamento das configurações das
aplicações e são indispensáveis para a remontagem das mesmas.
Os tipos de arquivos mais comumente gerados pelo Delphi são:

• *.DPR: arquivo de Projeto. Este arquivo é o programa principal de toda a
aplicação dentro dele estão armazenados informações sobre as units e
seus nomes, assim como os Formulários associados. Neste arquivo
também são determinados os formulários que serão criados e exibidos no
início da aplicação. O conteúdo do arquivo DPR poderá ser visualizado
abrindo-se o projeto no “Code Editor” da seguinte maneira: Menu
ViewÆUnits e selecionando o projeto, ou através do atalho
<CTRL>+<F12>;
Arquivo DPR no “Code Editor”
14
• *.PAS: são os arquivos que armazenam as units, contendo rotinas,

variáveis, definições de tipos, entre outros. Cada arquivo *.PAS
representa uma unit;
Arquivo PAS no “Code Editor”
• *.DFM: este arquivo armazena os valores das propriedades configurados

no Object Inspector de todos os componentes presentes no formulário
associado a uma unit *.PAS de mesmo nome. Não modifique este
arquivo manualmente, a não ser que saiba o que está fazendo. O
arquivo DFM pode ser visualizado clicando-se com o botão direito sobre
um formulário e em seguida escolhendo a opção “View as Text”, o
formulário será exibido como texto no “Code Editor”;
Arquivo DFM no “Code Editor”
15
• *.DOF: armazena as opções do Projeto que podem ser modificadas

através do menu ProjectÆOptions, que também é única maneira de
verificarmos o conteúdo de um arquivo DOF.
Arquivo DOF visualizado nos Opções de Projeto
3.2. O que Salvar?
Como o Delphi® 7.0 Studio cria muitos arquivos é necessário ter conhecimento
sobre os mesmos, para saber qual deles devem ser selecionados para Backup. A seguir
temos uma tabela com essas informações:
Extensão do Arquivo Necessidade de Salvar Utilidade do Arquivo

DPR Essencial Guarda as Configurações do
Projeto da Aplicação
PAS Essencial Guarda as Rotinas, Variáveis e
Tipos da Aplicação
DFM Essencial Guarda o Posicionamento dos
Componentes dentre do
Formulário
DOF Opcional Guarda as Opções do Projeto
RES Opcional Guarda algumas informações
não muito úteis como o ícone da
Aplicação se este for mudado
*.~* Totalmente Desnecessário Backup Preventivo do Delphi
16
3.3. Norma Internacional de Nomenclatura de Variáveis e Objetos
Saber dar nomes a variáveis e objetos é extremamente importante para o

programador de aplicações. Grandes empresas geralmente trabalham com aplicações
cujo código-fonte tem um número muito grande de linhas e que levam uma grande
quantidade de tempo para serem implementados. Extensão e tempo somados fazem com
que o programador se esqueça do que cada trecho de código realiza.
Um código-fonte mal documentado é extremamente difícil de se fazer
manutenção, agrava-se a situação se as variáveis ainda por cima não tiverem um nome
claro. A maioria dos programadores tem por hábito chamar variáveis de “eu”, “a”, “x”,
entre outros. Estes nomes dificultam que qualquer outro programador entenda e consiga
fazer manutenção do código.
Para evitar este tipo de problema, foi criado um Padrão Internacional de
Nomenclatura, no qual o início do nome de cada variável é composto pela “abreviação”
do seu tipo, com as letras minúsculas. Esta abreviação é realizada omitindo-se as vogais
da palavra que compõe o tipo. Por exemplo, se temos um objeto do tipo Form, seu nome
seria frm+<nome a escolha do programador> (recomenda-se que <nome a escolha do
programador> tenha a ver com a função do objeto ou variável). Utilizando esta
nomenclatura todos os que tivessem contato com o objeto frmGerenciamentoDados,
mesmo que não soubessem português saberiam que este objeto é um Form, sem ter que
localizar sua declaração. Já os que soubessem um mínimo de português saberiam que,
além disso, este formulário realizar as funções de gerenciamento de Dados.
Existe uma outra vertente para nomenclatura de variáveis que diz o nome de
uma variável deve ter em seu primeiro caractere uma letra minúscula representando o
tipo de dado que a variável guarda, sendo a segunda letra maiúscula. Assim, por
exemplo, uma variável chamada ValorX do tipo real, deveria ser nomeada fValorX,
onde f representa que a variável armazena um dado com ponto flutuante.
3.4. Case-Insensitive
Este item foi criado com único propósito de frisar uma das características do
Delphi® 7.0 Studio, portanto será breve. O pretende-se neste item é salientar que o
ambiente de programação do Delphi é Case-Insensitive, ou seja, para variáveis,
comando, procedimentos, etc, não importa o modo como você os chama no que diz
respeito à caixa do nome. Por exemplo, se criarmos um procedimento chamado
“CalculaX”, poderemos chamá-lo das seguinte maneiras:
• calculax;
• CaLcUlAx;
• calCulax;
• ...
Qualquer uma das formas apresentadas acima e variantes são reconhecidas pelo
Delphi como sendo o mesmo procedimento. Portanto não é necessário se preocupar
como chamar o procedimento como no caso de linguagens case-sensitive como C e Java
que exigem que todos os caracteres tenham a mesma caixa para serem reconhecidos
como o mesmo procedimento.
17
3.5. Criação de Variáveis
As variáveis são de suma importância para qualquer programa. Elas permitem

que dados sejam armazenados, manipulados e lidos, mais principalmente facilitam a sua
localização e chamada. É, portanto fundamental que o programador saiba criar variáveis
e que saiba como nomeá-las de maneira adequada, conforme já vimos.
O Delphi® 7.0 Studio mantém as estruturas estabelecidas pelo Pascal ao
declarar variáveis. Porém deve-se notar que o Delphi usa apenas units como unidades
básicas de programa, portanto, devemos declarar as variáveis na região de interface da
unit.
Na figura abaixo temos como exemplo uma unit padrão do Delphi. Notamos que
a unit segue uma estrutura na qual a declaração de variáveis é feita dentro da área da
unit chamada “Interface”.
Conceito Importante: a declaração de variáveis sempre é feita após a palavra

reservada “var” e sempre termina quando aparecer umas das palavras reservadas: begin
ou implementation.
Unit Padrão do Delphi
Ao criarmos variáveis devemos obedecer à seguinte estrutura:
var <nome da variável>: <tipo variável>;

<nome da variável>,<nome da variável>: <tipo variável>;
<nome da variável>,...,<nome da variável>: <tipo variável>;
18
Exemplo
var aNome: String;
iValorX, iValorY: Integer;
fDinheiro: Real;
Fato Importante: as variáveis são privadas às units nas quais são declaradas, ou
seja, só podem ser acessadas por métodos e objetos contidos na unit. Se for necessário
utilizar um variável em outra unit, devemos adicionar sua unit na clausula uses da
mesma.
Segundo Fato Importante: variáveis podem ser também declaradas dentro de
objetos, sendo de uso exclusivo do mesmo, a não ser que sejam declaradas na região
pública.
3.6. Constantes
Constantes são variáveis cujo valor não pode ser alterado, ou seja, seu valor é
instanciado no início do programa e permanece inalterado até o término do mesmo.
Constantes são úteis em programação para armazenar o valor de delimitadores de laços
e para armazenar valores que sempre são utilizados no decorrer do código.
É altamente recomendável o uso de constantes no lugar de valores, pois uma vez
alterado o valor de uma constate, todo o lugar onde ela aparece terá seu valor alterado
também.
As constantes devem ser declaradas entre as cláusulas “uses” e “type”.
Sintaxe
Const <identificador da constante> = <valor constante>
Constantes Declaradas
3.7. Tipos
O programador pode querer definir os seus próprios tipos para tornar o programa
mais claro e conciso. O Delphi® 7.0 Studio possibilita que isso ocorra assim como as
demais linguagens de alto nível.
O programador deverá declarar seus tipos sempre antes de atribuí-los a uma
variável, recomenda-se que isto seja feito logo após a declaração das constantes.
19
A declaração do tipo deve ser feita após a palavra reservada “type”.
Sintaxe
type <identificador do tipo> = <declaração do tipo>;

<identificador do tipo> = <declaração do tipo>;
<identificador do tipo> = <declaração do tipo>;
Observação: a criação de tipos é fundamental quando se deseja passar por

parâmetro matrizes ou variáveis cujo tipo seja altamente complexos, como por exemplo,
record.
3.8. Criação de Rotinas
As rotinas foram concebidas com o intuito de facilitar a programação, são

isolamentos lógicos de blocos de comandos. Através delas podemos criar níveis de
abstração, ou seja, permitir que outros métodos ou rotinas chamem através de
uma única linha de programação um conjunto de outros comandos sem precisar escrevê-
los.
Entretanto, o principal motivo pelo qual as rotinas são amplamente utilizadas é a
economia de linhas de código. Um bloco de comandos que aparece repetidas vezes
dentro de um programa pode ser declarado dentro de uma rotina. Assim poderemos
chamá-lo diversas vezes dentro do programa, sem precisarmos escrever os comandos
novamente.
As rotinas também são conhecidas em programação orientada à objetos como
“métodos”, mas somente recebem essa designação quando fazem parte dos objetos.
Existem dois tipos principais de rotinas, a saber:
• Procedimento: encapsula um bloco de comandos e permite a passagem
de parâmetros por referência ou valor;
• Função: tipo especial de procedimento que retorna um valor além de
possuir as características comuns a todos os procedimentos.
20
3.8.1 Parâmetros
Ao definir rotinas, na maioria das vezes, se faz necessário o acesso às variáveis

externas. Porém nem sempre essas variáveis são globais, ou seja, variáveis às quais
todos têm acesso. Para tanto, utilizamo-nos do recurso dos parâmetros. Parâmetros são
variáveis que são passadas para a rotina para que esta possa executar seus comandos
utilizando os valores dos parâmetros.
Existem dois tipos de parâmetros implementados no Delphi® 7.0 Studio, a saber:
• Por Valor: parâmetros por valor são aqueles que ao serem passados para
as rotinas, apenas permitem que seu valor seja usado e não alterado. Isso
ocorre porque é criada uma cópia do parâmetro para uso exclusivo da
rotina. No fim do processamento da rotina, este valor é perdido;
• Por Referência: parâmetros por referência são aqueles que permitem que
todas as alterações feitas sobre o seu valor original sejam refletidas na
variável externa à rotina. Na realidade, ao serem passados para a rotina, o
que esta recebe é um ponteiro para o endereço de memória do parâmetro,
portanto todas as alterações são feitas diretamente na área de memória da
variável externa.
3.8.2 Procedimentos
Procedimentos são blocos especiais de programa que permitem o

encapsulamento lógico de um conjunto de comandos. Isto facilita o entendimento das
funções do conjunto, assim como também proporciona um enxugamento maior do
código.
Os procedimentos são rotinas parametrizáveis, ou seja, são capazes de receber
parâmetros. Estes parâmetros poderão ser passados por valor ou referência. Parâmetros
passados por referência deverão ter suas declarações precedida pela palavra reservada
var.
Procedimentos, assim como as funções, permitem a declaração de variáveis
internas, que deve ser feita antes do begin do procedimento. Estas variáveis são visíveis
apenas pelo procedimento e são eliminadas da memória quando o procedimento deixa
de ser executado.
Sintaxe
procedure <nome do procedimento> (<var><parâmetro 1>: <tipo parâmetro 1>;

<var><parâmetro 2>: <tipo parâmetro 2>);
var <variável 1>: <tipo variável 1>; <variável 2>: <tipo variável 2>;
begin
end;
21
Exemplo
procedure somaAB (A,B: real; var Resultado: real);

begin
Resultado:=A+B;
end;
Modo de Invocação: somaAB(A,B,Resultado);
3.8.3 Funções
Funções são um tipo especial de procedimento que além de manter as

funcionalidades do mesmo, permitem que um valor seja retornado. Este valor não é um
parâmetro.
Sintaxe
function <nome da função> (<var><parâmetro 1>: <tipo parâmetro 1>;

<var><parâmetro 2>: <tipo parâmetro 2>): <tipo função>;
var <variável 1>: <tipo variável 1>;
<variável 2>: <tipo variável 2>;
begin
end;
Exemplo
function somaAB (A,B: real): real;

begin
somaAB:=A+B;
end;
Modo de Invocação: <variável de resposta do mesmo tipo da função>:=somaAB(A,B);
3.8.4 Onde declarar rotinas
As rotinas devem ser declaradas apenas na região da unit conhecida como

“implementation”. Esta área é destinada à declaração do corpo dos métodos.
22
Rotinas declaradas dentro de implementation
Observação: rotinas são diferentes de métodos, portanto para elas, objetos e

variáveis internos a outros objetos serão invisíveis, pois estes são privados aos seus
objetos recipientes.
3.9. Criação de Métodos
Métodos são rotinas especiais de objetos, que possuem privilégios sobre seu
objeto continente. Podem acessar variáveis, objetos e até mesmo outros métodos dentro
de seu objeto continente.
Os métodos possuem uma maneira especial de serem declarados. Devem conter
antes de seu nome o tipo do objeto continente, separado por “.” de seu próprio nome.
Sintaxe
procedure <tipo objeto>.<nome do procedimento> (<var><parâmetro 1>: <tipo parâmetro 1>;

<var><parâmetro 2>: <tipo parâmetro 2>);
var <variável 1>: <tipo variável 1>; <variável 2>: <tipo variável 2>;
begin
end;
function <tipo objeto>.<nome da função> (<var><parâmetro 1>: <tipo parâmetro 1>;

<var><parâmetro 2>: <tipo parâmetro 2>): <tipo função>;
var <variável 1>: <tipo variável 1>;
<variável 2>: <tipo variável 2>;
begin
23
end;
3.9.1 Onde Declarar Métodos
Métodos têm uma maneira diferente de serem declarados. Como as rotinas seu
corpo deve estar descrito na região conhecida como “implementation” e deve ser feito
segundo a sintaxe acima. Porém é necessário também incluir o cabeçalho do método
dentro da definição do objeto do qual ele faz parte.
Existem três seções possíveis para se inserir o cabeçalho de um método. Estas
seções também servem para declaração de variáveis. São elas:
• Delphi exclusive declarations: nesta região o delphi faz a declaração de
todos os métodos, variáveis e objetos que cria automaticamente. Dentre
estes métodos, temos os métodos que são utilizados para o tratamento de
eventos. Nesta região pode-se inserir métodos que são definidos pelo
programador, porém sempre que possível é melhor evitar isto. É
altamente recomendável que os métodos do programador sejam
declarados nas próximas duas seções;
• Private declarations: esta região é utilizada na declaração de variáveis e
métodos que são privados ao objeto, ou seja, somente o objeto terá
acesso ao que for declarado nesta região;
• Public declarations: esta região é utilizada na declaração de variáveis e
métodos que são públicos, ou seja, o que for declarado nesta região
poderá ser acessado por qualquer objeto ou uma unit que puder acessar
uma instância do objeto continente desta região.
Seções de Declaração de Métodos e Variáveis
24
3.9.2 Facilitando as Coisas
Para evitar problemas na hora de declarar métodos, principalmente por

incompatibilidade de cabeçalho, o Delphi® 7.0 Studio possui um recurso interessante
de auxílio. Este instrumento permite que, a partir de um cabeçalho inserido em um
objeto, posicionando-se o cursor sobre o nome do mesmo e pressionando-se a
combinação de teclas <ctrl>+<C>, o esqueleto do método é automaticamente criado na
região “implementation”.
3.10. Criação de Units
Units é a menor subdivisão de um programa logicamente completo em Delphi.

Cada unit é composta por um conjunto de declarações de métodos, rotinas, variáveis,
objetos e classes, que podem ou não estar presentes.
O Delphi® 7.0 Studio apresenta dois tipos de units principais, uma delas é a
própria unit em si, a outra é uma unit conjugada com um objeto form. A última é a mais
comumente usada, sendo também a primeira a ser visualizada quando um projeto é
criado.
Para adicionarmos uma unit em um projeto devemos seguir um dos seguintes
passos:
• Com o projeto aberto, no menu File Æ New Æ Unit: esta seqüência de
passos cria uma unit simples;
• Com o projeto aberto, no menu File Æ New Æ Form: esta seqüência de
passos cria uma unit conjugada a um formulário.
Unit conjugada a um Formulário
25
Unit simples
Observando a figura acima, nota-se que ambas as units mantém uma mesma estrutura
padrão. A segunda figura mostra como uma unit deve ser declarada e o que ela deve
conter. Todas as units criadas deverão no mínimo apresentar a seguinte estrutura:
unit <nome da unit>
interface
implementation
end.
3.10.1 Interface
Uma das regiões fundamentais a qualquer unit a interface tem um papel

fundamental na definição de uma unit. É através dela que todos os objetos e outras units
tomam conhecimento dos métodos possuídos pela unit, assim como as variáveis, objetos
e rotinas.
Tudo o que for declarado nesta região assim como todos os cabeçalhos de
rotinas nela contidos serão visíveis para todas as outras units que contiverem a unit em
sua cláusula “uses”.
26
Um bom programador segue uma estrutura clássica ao escrever sua seção

interface. Em seguida aparecem as cláusulas que poderão estar contidas na seção, elas
estão seguindo a estrutura clássica, portanto, é fundamental que esta ordem seja mantida.
Cláusulas que podem ser inseridas na seção interface na ordem preferível de

aparecimento:
• Uses: determina de quais units a unit atual necessita, das units cujos
nomes aparecem a frente desta cláusula, a unit atual utiliza componentes
e declarações;
• Const: após esta cláusula são declaradas as constantes, para maiores
detalhes consulta a seção 3.6;
• Type: com uso desta cláusula é permitida a declaração de tipos conforme
a necessidade do programador. Para maiores informações consulte a
seção 3.7;
• Var: cláusula utilizada para identificar a declaração de variáveis. Para
maiores informações consulte a seção 3.5;
• Cabeçalhos das Rotinas: após a declaração de todos os itens anteriores
se existirem, virá a declaração dos cabeçalhos das rotinas implementadas
na seção “implementation” e que serão visíveis aos usuários da unit.
Estrutura Clássica da Seção Interface
3.10.2 Implementation
Implementation é a seção da unit onde o corpo das rotinas e métodos são

declarados. Como o próprio nome diz, é onde ocorre a implementação.
27
Esta seção pode conter todos os tipos de cláusulas declaradas para a seção
“interface”, porém as cláusulas aqui declaradas só poderão ser utilizadas por esta seção.
Um fato importante a se observar é que todas as cláusulas usadas pela seção
“interface” também são válidas nessa seção, portanto não é necessário redeclará-las.
A declaração de rotinas deve ser feita nessa seção como foi descrito
anteriormente na seção 3.8.4.
Curiosidade: as rotinas poderão ser inseridas nessa seção com o seu cabeçalho
completo ou apenas até o seu nome. Seu o último for feito, o delphi procurará por sua
declaração posterior na seção “interface” e completará o resto!
Exemplo de Implementation com Rotinas
3.11. Eventos
Eventos são fatos ou ocorrências disparadas durante o andamento de um

programa. Toda programação orientada a objetos se baseia na ocorrência de eventos.
Cabe ao programador dizer então o que ocorrerá quando um evento acontecer.
O Delphi® 7.0 Studio permite que o programador programe para que seu
programa reaja diante desses eventos.
A maioria dos eventos são disparados por componentes gráficos do ambiente
visual do programa, estes eventos podem ser do tipo: clicar do mouse, entrada do mouse
em uma região, movimentação de componentes, etc.
Para ter acesso a lista de eventos de um objeto ou componente, basta clicar sobre
ele e ir ao “Object Inspector” e selecionar a aba “Events”.
A maioria dos componentes presentes na barra de eventos apresenta algum tipo
de evento relacionado a ele, portanto a chance de você escolher um componente que não
tenha eventos para se tratar é muito pequena.
28
Componente Botão e seus Eventos
Ao selecionar o objeto e escolher o evento desejado, basta dar um clique-duplo

sobre o campo a frente do nome do evento e o “Code Editor” aparecerá para que os
comandos sejam inseridos na rotina de tratamento do evento.
Com um clique-duplo sobre o evento “OnClick” do botão temos:
Rotina de Tratamento do Evento do Botão
29
3.12. Tratamento de Exceções
A programação é uma tarefa difícil e muito complexo, principalmente quando

lidamos com dados ou acontecimentos dos quais não podemos prever. Quando estes
fatos ocorrem o programa pode sofrer sérios crashes e sua execução ser interrompida
repentinamente sem explicações, ou aparecendo a telinha azul do Windows.
Procurando evitar este tipo de problemas foram inventados métodos para que
estas exceções ocorrendo o programa consiga driblá-los facilmente. Este métodos são
chamados de tratamento de exceções.
O Delphi® 7.0 Studio implementa dois meios de se tratar exceções: try ... except
e try ... finally.
3.12.1 Try ... Except
O comando try ... except e usado para tratar exceções e tem sua base
implementada da seguinte maneira: tenta executar um comando ou um conjunto deles,
se ocorrer exceção então ela a trata e aborta a rotina em execução.
Sintaxe
Try
<comandos>
Except
on <exceção> do <ação>
...
End;
Para tratar a exceção basta então saber o nome da exceção que ocorreu para
executar alguma ação sobre ela, se assim desejar. Se nenhuma exceção for especificada,
o programa apenas abortará a rotina.
Tratamento de Exceções – Divisão por Zero
30
3.12.2 Try ... Finally
Este comando trata exceções da mesma forma que o comando try ... except,
porém a única diferença entre eles é que diante da ocorrência de uma exceção ao invés
de tratá-la, ele executa os comandos após o finally. Para este comando não importa o
que aconteceu, mas sim o que deve ser feito antes que a rotina aborte.
Sintaxe
Try
<comandos>
Finally
<comandos>
End;
Tratamento de Exceções sem saber qual o tipo de exceção
4. Compilando e Debugando
Mais importante do que saber programar é saber compilar e debugar o código.

Este item refere-se somente a essas duas ações fundamentais para a geração do código
executável e rastreamento de erros respectivamente.
4.1. Compilando
A compilação do programa consiste na fase mais importante dentre as duas

citadas nesse item, com o compilação o código fonte é convertido em linguagem de
máquina para poder depois ser executado pelo processador. Durante a compilação o
Delphi® 7.0 Studio faz a transformação dos comandos e une-os quando necessário às
funções nativas do Windows côo, por exemplo, as APIs.
4.1.1 Gerando o executável
A geração do executável pode ser feita das seguinte maneiras:
31
• Menu Project Æ Compile Project (<ctrl>+<F9>): realiza a compilação

do código, se tudo ocorrer bem, constrói o executável;
• Menu Project Æ Build Project: constrói o código executável, se o
programa não tiver sido compilado, ele o faz;
• Menu Run Æ Run (<F9>): roda o programa, se não tiver sido compilado
ou construído, os fazem.
4.1.2 Erros de Compilação
Se durante a compilação algum erro for encontrado, um janelinha abrirá no

“Code Editor”. Esta janelinha mostrará que um erro ocorreu, informará a unit onde ele
ocorreu, qual sua linha e dará um breve descrição sobre o erro. O “Code Editor”
também estará com o cursor posicionado sobre o primeiro erro da lista, cuja linha estará
marcada em vermelho.
Esta janelinha também é utilizada para mostrar Warnings. É sempre interessante
checar os warnings, a maioria deles pode ser resolvido.
Code Editor – Erro de Compilação
Facilidade: uma das facilidades implementadas na ocorrência de erros é que o

duplo clique sobre um indicação de erro na janela de erro leva direto à linha de erro.
32
4.2. Debugando
O recurso debug é muito importante quando temos erros os quais não podemos
identificar em tempo de execução, para isso usamos os recursos de debug. Com eles
podemos analisar o código rotinas por rotina, linha de código por linha de código e
observar o conteúdo de cada variável.
Existem dois meios mais usuais de se percorrer o código-fonte:
• Step Into: percorre o programa linha por linha e ao encontrar uma rotina
executa a mesma linha por linha e assim por diante. Este recurso é
ativado com o uso da tecla <F7>;
• Step Over: percorre o programa linha por linha e ao encontrar uma
função a executa sem entrar no seu interior, ou seja, não mostra a
execução linha a linha da rotina. Este recurso é ativado com o uso da
tecla <F8>.
4.2.1 BreakPoints
Breakpoints são recursos muito utilizados durante a debugação de um programa

e são nada mais nada menos do que marcos de parada. O programa executa
normalmente até o ponto onde encontra um breakpoint, então a execução passa a ser
passo a passo no código-fonte até que o programador diga para prosseguir através do
comando Run ou <F9>.
Para adicionar um breakpoint, basta compilar o código-fonte, após a compilação,
nota-se no lado esquerdo do “Code Editor”, bem ao lado do código, o surgimento de
algumas bolinhas azuis. Estas bolinhas marcam lugares válidos para a inserção de
breakpoints. Para inseri-los basta clicar sobre as bolinhas e a linha se tornará vermelha
dizendo que o breakpoint foi efetivado.
Bolinhas Azuis e Breakpoint
33
4.2.2 Watches
Watches permitem ver o valor de uma variável ou componente em um dado

instante. São muito úteis durante o processo de debugação do programa, pois mostram o
conteúdo da variável a cada passo do debugger.
4.2.2.1 Janela de Watches
A janela de Watches é necessária para que se possa visualizar os watches. É

nesta janela que são inseridos os watches e através dela que também podemos
manipulá-los e classificá-los de acordo com o nosso gosto.
A janela de watch pode chamada de duas maneiras:
• Menu View Æ Debug Windows Æ Watches;
• <Ctrl> + <Alt> + <W>
Janela de Watches ou Watch List
4.2.2.2 Adicionando um Watch
Para adicionar um Watch basta tomar um dos seguintes passos:

• Botão Direito sobre a Janela de Watches Æ Add Watch;
• <Ctrl> + <A>.
Após realizado um dos passos acima uma janela aparecerá para que as
características do watch sejam determinadas. Nessa janela deve-se fornecer o nome da
variável, componente, propriedade ou qualquer outra coisa que se deseje avaliar.
Os watches também podem ser feitos sobre expressões booleanas ou aritméticas.
Após a configuração das características do watch ele deverá aparecer na Janela
de Watches. Para que um watch possa mostrar o valor do que se deseja é necessário que
o programa esteja funcionando, pois ele retira as informações da memória.
34
Propriedades do Watch
4.2.2.3 Removendo um Watch
A remoção de um watch é simples, basta clicar sobre ele na janela de watches e

pressionar a tecla <delete>.
4.2.2.4 Alterando um Watch
A alteração de um watch é feita dando-se um duplo clique sobre ele na janela de

watches, então a janela de características se abrirá para edição.
5. Interface com o usuário
Uma das principais armas de um programador para vender seu programa é a

interface. A interface é o cartão de visitas de um programa. Portanto, é fundamental que
o programador saiba como fazer uma boa interface, e como deixar coisas à mão do
usuário, de maneira fácil e “amigável”.
Uma interface chamativa e pouco espalhafatosa é uma arma poderosa, pois
para o usuário que é leigo em programação a complexidade de modelagem problema
não será vista. Logo ele dificilmente saberá reconhecer o valor do programa, o que ele
verá é o que está diante dos seus olhos.
Interface porcas e mal estruturadas implicam em insatisfação do cliente.
Interfaces coloridas e não circenses são sempre bem-vindas.
Neste item serão abordados alguns componentes que servirão como base para
a criação de interfaces avançadas.
35
5.1. Panels
Painéis são simples quadrados recipientes básicos de objetos, eles não têm
muitas funções específicas e servem na maioria das vezes como quebra-galho no que
diz respeito à organização e interface.
Na maioria das vezes são usados como separadores de áreas e como dock para
botões e outros componentes de interface. Pode ser usados também como um quadro
para a exposição de figuras, entre outras utilidades.
Os painéis também são conhecidos como o 1001 utilidades dos sistemas
gráficos.
Adicionar um painel é tão simples que não é necessário nem um subitem para
explicar como fazê-lo. Basta procurar pelo desenho mostrado no início deste tópico na
Barra de Componentes na guia “Standard” ou por um componente chamado “Panel” na
mesma guia.
Painel dentro de um Formulário
5.2. Criação de Menus
Menus são itens muito comuns em interfaces e sua grande utilização se deve
ao fato de serem unidades gráficas que tornam a apresentação das ferramentas dos
sistemas mais agradável. Além disso, os menus são práticos porque deixam as
ferramentas ao alcance do usuário que podem acessá-las de maneira rápida e menos
complicada.
5.2.1 Adicionando o Componente de Menu
Para adicionar um menu a uma aplicação basta procurar na barra de

ferramentas na aba “Standard” por um componente com a figura apresentada no início
36
deste tópico ou chamado MainMenu. Ao encontrá-lo clique sobre ele e adicione em um

formulário de sua aplicação. A princípio você não notará nenhuma diferença, pois o
menu ainda está vazio. É necessário agora adicionar itens de menu para que possamos
notar a diferença no formulário.
5.2.2 Criando Itens de Menu
Com o mouse, clique com o botão direito sobre o componente de menu e

selecione o Menu Designer...
Menu Designer...
Uma janela se abrirá mostrando o esqueleto de um menu inacabado, com um

célula em aberto. Clique nesta célula e adicione um caption e um nome, note que o
menu é criado no momento em que o caption ou nome são adicionados. Configure
quaisquer outras propriedades que achar conveniente.
Ao clicar no item de menu que você acabou de criar note que ele se abre como
se fosse um menu e dentro dele aparece outra célula vazia. Se fossem realizados os
passos anteriores sobre estas células teríamos um item de menu.
Se repetirmos os passos acima com cada tipo de célula citado poderemos criar
uma Barra de Menu com diversos Menu e Itens de Menu quanto forem necessários.
37
Menu Designer, Menus, Itens de Menu e Células Vazias
5.2.3 Criando SubMenus
A criação de submenus é simples, porém para se criar um submenu é

necessário que tenhamos um Item de Menu criado. A partir deste item de menu,
clicamos com o direito sobre ele e selecionamos “Create SubMenu”, então o submenu
será criado. O submenu virá com um célula vazia que poderá ser transformada em um
item de menu e depois em um submenu e assim sucessivamente.
Criando um SubMenu...
5.3. Criação de Barras de Ferramentas
Barras de Ferramentas são utensílios de interface muito utilizados em sistemas

em geral. Esta barra comporta botões que permitem o acesso às principais funções do
programa. A principal função de uma barra de ferramentas é, portanto, garantir que o
usuário tenha sempre um modo rápido de acessar as principais funções do programa ou
por ele definidas.
38
Barra de Ferramentas
A inserção de uma barra de ferramentas é simples. Primeiro é necessário ter

um formulário aberto. Em seguida, na barra de componentes, na aba Win32. É só
localizar o componente com o desenho igual ao início deste tópico. Clica-se no
componente e então se clica em qualquer lugar do formulário. Uma barra de ferramentas
vazia deverá ser inserida.
5.3.1 Adicionando Botões
Os botões da barra de ferramentas são os componentes que garantem sua

funcionalidade, através deles poderemos programar quais recursos que a barra de
ferramentas irá alcançar.
A barra de ferramentas admite 3 tipos de botões:
• TButton – botão comum a qualquer aplicação simples, sendo o tipo
mais simples e primário de botão encontrado entre os componentes do
Delphi;
• TBitButton – botão cuja base de construção é o TButton, porém
permite que seja incorporado ao botão um Glyph (imagem);
• TToolButton – botão comumente visto em barra de ferramentas que
possui funcionalidades semelhantes ao TBitButton, porém seu caption
normalmente não é exibido.
Para adicionar botões na barra de ferramentas, basta clicar no botão desejado e
colocar na área da barra de ferramentas.
Se o botão que desejar inserir for um botão do tipo TToolButton, com a barra
de ferramentas inserida, clique com o botão direito em sua área útil. Em seguida, clique
em “New Button”.
Inserindo um Novo Botão
39
5.3.2 Adicionando Separadores
Separadores são meros recursos organizacionais, eles servem para separar

botões em uma barra de ferramentas.
Para inserir separadores, com a barra de ferramentas posicionada no
formulário, clique com o botão direito em sua área útil. Em seguida, clique em “New
Separator”.
Inserindo novos Separadores
5.4. Criação de Barras de Status
Barras de status são pequenas áreas no rodapé de sistemas ou aplicações

destinadas a exibir textos elucidativos ou a situação de teclas modificadoras como o
Insert, que ao ser pressionado muda o estado de inserção para a reposição de caracteres.
Todo sistema ou aplicação, sempre que possível, deve ser auto-explicativo, e a
Barra de status é fundamental na exibição de dicas.
5.4.1 Exibindo Dicas
Exibição de dicas é simples, basta configurar a propriedade AutoHint da Barra

de Status para verdadeira. Fazendo isso quando quiser exibir uma dica sobre um
componente, basta preencher a propriedade Hint do objeto e este será automaticamente
exibido na Barra de Status.
5.5. Criação de MDIs
MDIs são janelas dedicadas. Estas janelas são um tipo especial criadas a partir
do formulário original, configurando-se sua propriedade “FormStyle”. Ao criarmos
janela MDI necessitamos criar duas instâncias das mesmas. A primeira instância é
40
chamada de MDIForm e comporta todas as outras instâncias que são chamadas de

MDIChild. Sempre que criarmos uma MDIChild, necessitamos criar uma MDIForm
para que o vínculo MDI seja estabelecido. A janela MDIForm deverá ser a primeira a
ser carregada. Em seguida, ao carregarmos as janelas MDIChild, estas últimas se
abrirão dentro da janela MDIForm. Em síntese, MDI é um modelo de interface no qual
existe uma janela principal dentro da qual outras são criadas e vinculadas a mesma, e
são mantidas em sistema de clausura, ou seja, as janelas criadas não podem extravasar a
área útil do Formulário.
Exemplo de janelas MDIForm (Form1) e MDIChild (Form2)
5.5.1 MDI Forms
São janelas destinadas a servir como desktop para outras janelas que possam
vir a ser criada durante a execução do programa. Ou seja, estas últimas serão mantidas
em clausura quando forem do tipo MDIChild. São criados configurando-se a
propriedade FormStyle do formulário para MDIForm.
5.5.2 MDI Childs
MDIChilds são janelas criadas com o intuito de serem preservadas dentro de

uma região pré-estabelecidas, similar a um desktop. Essa região deve ser uma região
contida dentro de um formulário, onde a sua propriedade FormStyle foi modificada para
MDIForm
41
5.6. Criação de Telas de Splash
Splashes são telas de abertura criadas com o intuito de realizar algum tipo de
propaganda da aplicação ou da empresa. São também muitas vezes criadas para que o
usuário não abra o programa e surja do nada a tela principal do mesmo. Ou então são
exibidas enquanto os módulos do programa são executados.
Splashes são criados basicamente utilizando-se formulário comuns, timers e a
criatividade do programador.
Portanto, este tópico não apresentará uma receita para fazê-lo, utilize sua
criatividade.
6. Criação Dinâmica de Objetos
Criação dinâmica de objetos consiste em criar objetos em tempo de execução,

ou seja, sem inseri-los no formulário antes que o programa entre em execução. A
criação dinâmica de objetos é importante quando o número de objetos utilizados em um
sistema se torna muito grande, principalmente quando nem todos eles são utilizados em
um dado momento ou quando não estão visíveis o tempo todo.
Justifica-se então a necessidade da criação dinâmica, uma vez que os objetos
que não estão visíveis o tempo todo não necessitam serem criados ao iniciarmos o
formulário, mas sim quando for necessário usá-los. Dessa forma, estaremos
economizando memória. Apenas quando for necessário o uso de um objeto o criarmos.
Cada objeto tem uma maneira própria de ser criado, mas em sua maioria
necessitam de dois comandos:
• Create – cria uma instância de um tipo pré-definido para que esta possa
se tornar o objeto dinâmico;
• Parent – diz qual objeto contém o objeto dinâmico, ou seja, qual deles
é responsável por seu controle e por possíveis tratamentos de eventos.
No próximo sub-tópico abordaremos a criação de um botão dinamicamente
para elucidar os conceitos acima.
6.1. Criando um botão dinamicamente
Para criar um botão dinamicamente basta seguir os passos aqui descritos:

1. Defina um variável v do tipo TButton;
2. Crie uma instância de TButton utilzando:
v:=TButton.Create(<componente dono do objeto dinamico>);
3. Determine o pai do objeto que deve ser do tipo TWinControl, fazendo:
v.Parent:=<pai do objeto dinâmico>;
4. Configure as propriedades e métodos do objeto como achar necessário.
42
Exemplo de Código de Criação Dinâmica de um Botão
7. Banco de Dados
Banco de Dados são sistemas complexos de armazenamento de dados,

baseados basicamente na criação, alteração e destruição de tabelas.
Tabelas como o próprio nome diz são tabelas comuns, com apenas uma
diferença, elas armazenam valores variados na suas linhas e colunas. Esses valores são
organizados de acordo com o seu significado e a quem pertencem.
Cada coluna de uma tabela tem um significado, ou seja, todos os valores
abaixo dela terão o mesmo tipo valor, como por exemplo, nomes ou valores de salário.
Cada linha faz referência a um indivíduo ou a um dado maior, sendo que cada uma
delas representa um conjunto de característica do mesmo.
O Delphi® 7.0 Studio possui um número grande de ferramentas que
possibilitam que o programador relacione seu sistema ao Banco de Dados. A seguir,
veremos os mais comumente usados, visto que este curso visa uma breve introdução aos
conceitos de Banco de Dados.
Os componentes de Bando de Dados são encontrados no Delphi na aba BDE
da Barra de Componentes.
7.1. Tables
Tables são componentes do Delphi que permitem que um sistema utilize-se de

tabelas armazenadas fisicamente em um computador. Ou seja, elas são o canal de
comunicação entre o sistema e o Banco de Dados ou Sistema de Tabelas.
As Tables são os componentes com a figura acima encontradas na aba BDE,
Data Controls e Data Access da barra de componentes. Para inseri-las basta fazê-lo
como se fosse um outro componente qualquer. Cada tabela representa uma tabela física
e deve ser acompanhada por um DataSource.
43
Nota: uma tabela deve ser aberta antes que dados possam ser inseridos na mesma, e
fechada logo após ser usada.
7.1.1 Configurando uma Table
Para que a Table consiga estabelecer o vínculo com as tabelas físicas, é

necessário configurá-la corretamente. Seguindo os passos a seguir, conseguiremos
configurar uma Table para qualquer tabela disponível.
1. Edite a propriedade DataBaseName da Table, apontando-a para um

DataBase inserido no formulário ou então para um alias criado pelo
DataBase Desktop;
2. Na propriedade TableName, selecione a tabela com a qual deseja

trabalhar;
3. Clique com o botão direito sobre o componente Table e em seguida em

Fields Editor;
Abrindo o Editor de Campos
4. Com o Editor de Campos aberto, é necessário agora adicionar os

campos na tabela da aplicação. Fazemos isso clicando com o Botão
Direito no Fields Editor e em seguida em Add all fields.
44
Campos inseridos no Fields Editor
Com apenas estes 4 passos temos uma tabela da aplicação pronta para ser
usada.
7.2. DataSources
Data Sources são componentes cuja única função é servir de elo de ligação
entre os componentes do formulário e as Tables.
Este componentes são encontrados na Barra de Componentes na aba Data
Access e apresentam a figura acima.
7.2.1 Configurando um DataSource
A configuração de DataSources é extremamente simples, em virtude de sua

pouca quantidade de propriedades. Vejamos como prepará-lo para conectar
componentes à tabelas.
Passo único:
1. Na propriedade DataSet selecione o nome da tabela sobre a qual
deseja-se trabalhar.
7.3. Controladores de Dados ou Componentes DB
Os Controladores de Dados são componentes encontrados na Barra de

Componentes, na aba Data Controls, eles permitem a manipulação dos dados inseridos
no banco de dados de maneira rápida e prática. Isso se deve ao fato destes componentes
possuírem conexão direta com o componente Table.
Dentro os controaldores de dados mais utilizados temos os DBEDits,
DBNavigator, DBLabel, DBGrid, entre outros.
45
7.3.1 DBEdit
DBEdit é um campo Edit com vínculo direto para a tabela, ou seja, tudo o que
for digitado neste campo terá reflexo direto sobre a tabela apontada por um componente
Table associado ao mesmo.
Para configurar o vínculo destes componentes com a tabela física, basta seguir
os passos abaixo:
1. Na propriedade DataSource, identifique o DataSource que faz
referência à tabela que contém o campo que será modificado com o
valor do DBEdit;
2. Na propriedade DataField selecione o campo que terá seu valor
modificado.
7.3.2 DBNavigator
O DBNavigator é um componente que permite que os registros contidos em

um tabela sejam manipulados ou percorridos. Ele possui todas as funções básicas
implementadas para facilitar a programação rápida de um banco de dados.
Deve-se salientar que ao movimentar os registros de uma tabela, o valor dos

mesmos só será visto se a tabela tiver algum tipo de visualizador de dados associado a
ela, como por exemplo, DBGrid ou DBEdits.
Para configurar o DBNavigator, precisamos indicar um DataSource associado
a uma Table devidamente configurada.
7.3.3 DBGrid
DBGrid é um componente destinado a visualização e edição de campos na

forma de tabela. Este é o componente que mais se assemelha ao real modo como os
dados são armazenados na tabela.
A navegação entre os registros é feita utilizando-se mouse ou teclado e um
clique em uma célula a torna editável.
Para deixar o DBGrid configurado para pronto uso apenas é necessário
fornecer um DataSource válido e devidamente configurado.
7.4. Databases
46
Databases são componentes que funcionam como aliases, ou seja, eles indicam
o caminho onde estão armazenadas as tabelas. Entretanto, não fazem só isso. Os
Databases também permitem que drivers sejam configurados e conexões externas sejam
feitas com Bancos de Dados como Oracle, por exemplo. Nele também pode-se definir
opções de logon, entre outras.
Databases são encontrados na Barra de Componentes na aba BDE.
7.4.1 Configurando um DataBase
Para configura um Database, é necessário inserir o componente no formulário

e:
1. Clique com o botão direito sobre o Database e em seguida sobre
Database Editor;
DataBase Editor
2. Forneça o nome do DataBase. Este nome será utilizado na propriedade

DatabaseName de um componente Table, por exemplo;
3. Forneça o nome do driver ou do alias, mas não ambos;
4. Pressione o botão Defaults e preencha os campos que julgar necessário.
7.5. Queries
Queries são similares às tabelas, porém elas são mais maleáveis. Nas queries é
possível determinar quais colunas de uma tabela queremos exibir, e quais registros
também. Fazemos isto através de comandos SQL inseridos na propriedade SQL. Estes
comandos podem utilizar parâmetros da propriedade Params.
47
7.5.1 Configurando uma Query
Para termos uma query pronta para o uso devemos configurá-la primeiro.
Notaremos a seguir que os passos de configuração de uma query são muito similares aos
de uma Table, a saber:
1. Selecione em DatabaseName, o Database ou o alias onde se encontra a
tabela que a Query estará utilizando;
2. Na propriedade DataSource selecione o DataSource associado à Query.
7.5.2 Adicionando Parâmetros
Parâmetros são utilizados quando não sabemos exatamente qual valor passar
para uma linha de comando SQL ao realizar uma consulta. Quando isto acontece
usamos um parâmetros que futuramente poderá ter seu valor modificado em tempo de
execução.
A adição de parâmetros deverá ser feita com o auxílio do Object TreeView,
seguindo os seguintes passos:
1. Localize a query na qual se deseja inserir parâmetros no Object
TreeView;
2. Procure dentro da árvore da mesmo por Params;
3. Clique com o botão direito em Params e em seguida, Add items;
4. Configura o Parâmetro conforme sua necessidade.
7.5.3 Modificando as Linhas e Colunas exibidas por uma Query
Para modificar o conteúdo exibido por uma Query basta na propriedade SQL
digitar o comando SQL apropriado para tanto.
7.6. InstallShield é fundamental!
A criação de Banco de Dados feita em Delphi® 7.0 Studio só é possível graças

a uma ferramenta que faz o intermédio entre Banco de Dados e o Delphi, o Borland
Database Engine (BDE). Portanto, ao criar uma aplicação e levá-la para fora do
ambiente de programação, ou seja, um lugar onde o BDE não esteja instalado, é
necessário levar alguns arquivos junto com o sistema.
A criação de um arquivo de instalação pode diminuir a chance de ocorrerem
erros na cópia destes arquivos. O Delphi® 7.0 Studio vem com uma versão Shareware
do InstallShield que possui ferramentas para a adição dos arquivos necessário.
Portanto, lembre-se de sempre que for retirar seu sistema de Banco de Dados
do ambiente de programação de levar os arquivos do BDE com o mesmo.
48

Apostila Mini-Curso Delphi - Dia 3

Загружено:

Сведения о документе

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Apostila Mini-Curso Delphi - Dia 3

Загружено:

Авторское право:

Доступные форматы

Mini-Curso Delphi Marcos Paulo Salvador de Oliveira

5. INTERFACE COM O USUÁRIO.................................................................................................35

5.1. PANELS ..........................................................................................................................36

5.2. CRIAÇÃO DE MENUS .....................................................................................................36

5.3. CRIAÇÃO DE BARRAS DE FERRAMENTAS ......................................................................38

5.4. CRIAÇÃO DE BARRAS DE STATUS .................................................................................40

7.1. TABLES ...........................................................................................................................43

7.2. DATASOURCES ..............................................................................................................45

7.3.1 DBEdit ......................................................................................................................46

7.3.2 DBNavigator .............................................................................................................46

7.3.3 DBGrid ......................................................................................................................46

7.4. DATABASES ...................................................................................................................46

7.5. QUERIES .........................................................................................................................47

1.1. Familiarização com o Ambiente de Programação

Curiosidade: A Borland também tem uma versão do ambiente de programação Delphi

Ambiente de Programação Delphi 7.0

1.2. Subdivisões do Ambiente de Programação Delphi

O ambiente de programação Delphi® 7.0 apresenta subdivisões para melhor

Subdivisões do Ambiente de Programação

1.2.1 Menu Principal

Permite o acesso a todas as funções disponíveis no ambiente de programação,

1.2.2 Gerenciador de Desktops

O Gerenciador de Desktops é uma das partes do ambiente de programação

1.2.3 Palheta de Botões Rápidos

A Palheta de Botões Rápidos contém botões com as funções mais utilizadas

Palheta de Botões Rápidos

1.2.4 Palhetas de Componentes

As Palhetas de Componentes são as palhetas fundamentais do ambiente de

Uma das subdivisões do ambiente de programação Delphi®, o Formulário é a

1.2.6 “Code Editor”

O Code Editor é área do ambiente de programação do Delphi® destinada a

Code Editor com um trecho de Código Básico

1.2.7 “Object TreeView”

O “Object TreeView” é uma ferramenta que proporciona uma visão geral de

1.2.8 “Object Inspector”

O “Object Inspector” é uma área de visualização e configuração de um objeto.

Curiosidade: itens em vermelho são propriedades ou eventos que poderão possuir

1.3. Ambiente “Drag and Drop”

O ambiente de programação do Delphi® 7.0 Studio por ser altamente integrado

Componentes sendo posicionados em regiões de “dock”

2. Ferramentas do Ambiente de Programação

Este módulo é destinado à prática de programação rápida. Nele serão

2.1. “Code Completition”

O “Code Completition” como o próprio nome diz é um completador de códigos.

2.1.1 Chamando o “Code Completition”

O “Code Completition” conforme dito anteriormente é um recurso do “Code

2.1.2 Refinando a busca do “Code Completition”

Quanto maior a quantidade de letras que estiverem digitadas antes de chamar o

Exemplo de uso do “Code Completition”

“Code Completition” fornecendo apenas a primeira letra da variável que já conhecíamos.

2.2. Estruturas de Programação Pré-Estabelecidas (“Code Templates”)

É muito comum que uma aplicação contenha estruturas de programação das

2.2.1 Utilizando “Code Templates”

O uso das “Code Templates” se dá de maneira similar ao uso do “Code

• Segunda Coluna ou Coluna do Nome: esta coluna exibe o nome pré-

Lista de “Code Templates

2.2.2 Adicionando “Code Templates”

Janela de Propriedades do Code Editor

2. Em Source Options clique no botão Edit Code Templates;

Janela de Propriedades do Code Editor – Editando Templates

3. Na Janela que se abre escolha entre abrir, editar ou excluir o nome ou a

Neste tópico em a preocupação principal será a codificação em Delphi,

3.1. Tipos de Arquivos Gerados pelo Delphi

Os tipos de arquivos mais comumente gerados pelo Delphi são: