Linguagem de Programação Comercial

CARLOS ALBERTO PEDROSO ARAÚJO
LINGUAGEM DE PROGRAMAÇÃO
COMERCIAL
Santarém
2009
Linguagem de Programação Comercial
Lista de Ilustrações
Figura 1 Form novo........................................................................................................ 10

Figura 2 Object Inspector ............................................................................................... 11
Figura 3 Paleta de Componentes .................................................................................... 12
Figura 4 Botões de Alinhamento .................................................................................... 12
Figura 5 Método manipulador de evento OnClick de botão........................................... 14
Figura 6 Código do procedure ....................................................................................... 14
Figura 7 Caixa de mensagem.......................................................................................... 14
Figura 8 Método manipulador do evento OnClick de form............................................ 15
Figura 9 Opções de Projeto ............................................................................................ 15
Figura 10 Alterando propriedade em tempo de execução .............................................. 16
Figura 11 Código para centralizar o botão em tempo de execução................................ 17
Figura 12 Código fonte de um form ............................................................................... 18
Figura 13 Unit com novo nome...................................................................................... 18
Figura 14 Código após adicionar um botão.................................................................... 18
Figura 15 Código após alterar a propriedade Name do botão ........................................ 18
Figura 16 Código com manipuladores de eventos ......................................................... 19
Figura 17 Descrição textual do form .............................................................................. 20
Figura 18 Project Manager ............................................................................................. 21
Figura 19 Código fonte do arquivo de projeto ............................................................... 21
Figura 20 Descrição textual de um botão ....................................................................... 23
Figura 21 Mudanças na descrição textual usando um editor qualquer........................... 23
Figura 22 Descrição textual do botão após ser colado no form...................................... 24
Figura 23 Comando Find in Files ................................................................................... 24
Figura 24 Informações sobre um programa compilado.................................................. 26
Figura 25 Environment Options ..................................................................................... 27
Figura 26 Assistente de Parâmetros de Código .............................................................. 31
Figura 27 Project Manager ............................................................................................. 31
Figura 28 Compilador em andamento ............................................................................ 32
Figura 29 Ponto de parada (Breakpoint)......................................................................... 33
Figura 30 Fragmento de ALO.DOF ............................................................................... 34
Figura 31 Arquivo desktop (.DSK) ................................................................................ 34
Figura 32 Botão recém inserido...................................................................................... 38
Figura 33 Código o evento OnClick de btnFechar......................................................... 39
Figura 34 Componente TEdit ......................................................................................... 40
Figura 35 Componente TLabel ....................................................................................... 41
Figura 36 Componente TCheckBox................................................................................ 42
Figura 37 Componente TRadioGroup ............................................................................ 43
Figura 38 O Componente ListBox .................................................................................. 44
Figura 39 Componente ComboBox ................................................................................ 45
Figura 40 Componente ScrollBar................................................................................... 47
Figura 41 Componente GroupBox.................................................................................. 48
Figura 42 Componente TMemo ...................................................................................... 48
Figura 43 Form com a botão btnSalvar.......................................................................... 50
Figura 44 Código do evento OnClick do botão btnSalvar.............................................. 50
Figura 45 Caixa de diálogo ShowMessage ..................................................................... 52
Figura 46 Caixa de diálogo MessageDlg........................................................................ 53
Figura 47 Caixa de diálogo MessageBox com botões de opções ................................... 54
Figura 48 MessageBox para informações ao usuário ..................................................... 55
2
Centro Universitário Luterano de Santarém
Figura 49 Caixa de diálogo InputBox ............................................................................. 56

Figura 50 Aplicação Dialogos com um novo botão e rótulo.......................................... 57
Figura 51 Menu com opções agrupadas e sub-menu...................................................... 59
Figura 52 Aplicação Menus............................................................................................ 60
Figura 53 A caixa ColorDialog ...................................................................................... 62
Figura 54 Menu Designer ............................................................................................... 63
Figura 55 Aspecto do menu criado................................................................................. 63
Figura 56 Menu com teclas de atalho............................................................................. 64
Figura 57 A janela Sobre ................................................................................................ 67
Figura 58 O componente PopupMenu............................................................................ 68
Figura 59 Barra de ferramentas ...................................................................................... 70
Figura 60 Barra de status ................................................................................................ 73
Figura 61 Interface da aplicação..................................................................................... 75
Figura 62 Função que retorna uma string de espaços..................................................... 76
Figura 63 O método btnSalvarClick............................................................................... 77
Figura 64 Botões para leitura do arquivo ....................................................................... 78
Figura 65 Código do evento OnClick de btnIniciar ....................................................... 79
Figura 66 Código do evento OnClick de btnProximo .................................................... 79
Figura 67 Configuração de acesso a banco de dados ..................................................... 82
Figura 68 Modelo E-R.................................................................................................... 83
Figura 69 Janela para definir o tipo da tabela................................................................. 83
Figura 70 Janela para definição de campos .................................................................... 84
Figura 71 BDE Administrator ........................................................................................ 85
Figura 72 DataModule ................................................................................................... 88
Figura 73 Aparência parcial da interface........................................................................ 89
Figura 74 O controle DBNavigator ................................................................................ 90
Figura 75 O form de cadastro de clientes ....................................................................... 96
Figura 76 Form de consulta a cidades ............................................................................ 97
Figura 77 Janela para criar TFields ................................................................................ 99
Figura 78 Código do evento OnClick do botão btnPesquisar ...................................... 101
Figura 79 Modelo E-R do banco de dados ................................................................... 103
Figura 80 Nota fiscal .................................................................................................... 108
Figura 81 Tela de definição da ligação entre duas tabelas ........................................... 109
Figura 82 Form de Vendas ........................................................................................... 112
Figura 83 Criação de campo Lookup............................................................................ 113
Figura 84 Criação de campo calculado......................................................................... 114
Figura 85 Código para atualizar o total da venda......................................................... 116
Figura 86 Aba de componentes Rave ........................................................................... 117
Figura 87 Rave Visual Designer................................................................................... 118
Figura 88 Propriedades do objeto Page1...................................................................... 119
Figura 89 Janela para criação da conexão a dados ....................................................... 119
Figura 90 Árvore de Objetos ........................................................................................ 119
Figura 91 Componente Region ..................................................................................... 120
Figura 92 Área de impressão ........................................................................................ 120
Figura 93 Componentes Band e DataBand .................................................................. 120
Figura 94 Página com os objetos Band e DataBand .................................................... 121
Figura 95 Editor da propriedade BandStyle.................................................................. 121
Figura 96 Componente Text ......................................................................................... 122
Figura 97 Página com os objetos Band e DataBand .................................................... 122
Figura 98 Editor de Data Text ...................................................................................... 122
Figura 99 Aparência do projeto do relatório ................................................................ 123
Figura 100 A banda GroupHeader............................................................................... 124
3
Figura 101 A aparência final do desenho do relatório.................................................. 125

Figura 102 Prévia do relatório ...................................................................................... 125
4
Lista de Quadros
Quadro 1 Propriedades, métodos e eventos de Form ..................................................... 38

Quadro 2 Propriedades, métodos e eventos de Button ................................................... 39
Quadro 3 Propriedades, métodos e eventos de Edit ....................................................... 40
Quadro 4 Propriedades e eventos de Label .................................................................... 41
Quadro 5 Propriedades, métodos e eventos de CheckBox.............................................. 42
Quadro 6 Propriedades, métodos e eventos de RadioGroup .......................................... 43
Quadro 7 Propriedades, métodos e eventos de ListBox.................................................. 45
Quadro 8 Propriedades, métodos e eventos de ComboBox ............................................ 46
Quadro 9 Propriedades, métodos e eventos de ScrollBar .............................................. 47
Quadro 10 Propriedades, métodos e eventos de Memo .................................................. 49
Quadro 11 Propriedades e métodos de TStrings............................................................. 51
Quadro 12 Funções de conversão de dados.................................................................... 51
Quadro 13 Propriedades de BitBtn ................................................................................. 57
Quadro 14 Propriedades de ToolBar .............................................................................. 69
Quadro 15 Propriedades de StatusBar............................................................................ 71
Quadro 16 Propriedades de TStatusPanel ...................................................................... 71
Quadro 17 Propriedades de StatusBar............................................................................ 72
Quadro 18 Rotinas de Entrada e Saída ........................................................................... 74
Quadro 19 Definição dos campos da tabela Cidade ....................................................... 84
Quadro 20 Definição dos campos da tabela Cliente....................................................... 84
Quadro 21 Propriedades, métodos e eventos de Table................................................... 87
Quadro 22 Propriedades e eventos de DataSource ........................................................ 88
Quadro 23 Propriedades, métodos e eventos de DBEdit ................................................ 89
Quadro 24 Propriedades e eventos de DBNavigator ...................................................... 90
Quadro 25 Propriedades, métodos e eventos de DBLookUpComboBox ........................ 93
Quadro 26 Propriedades, métodos e eventos de DBComboBox..................................... 93
Quadro 27 Propriedades, métodos e eventos de DBRadioGroup................................... 94
Quadro 28 Propriedades, métodos e eventos de DBCheckBox ...................................... 95
Quadro 29 Propriedades, métodos e eventos de DBGrid ............................................... 98
Quadro 30 Propriedades, métodos e eventos de TField ................................................. 98
Quadro 31 Propriedades e métodos de TQuery ............................................................ 101
Quadro 32 Propriedades, métodos e eventos de IBDatabase....................................... 105
Quadro 33 Propriedades e métodos IBTransaction...................................................... 106
Quadro 34 Propriedades do componente RvSystem ..................................................... 117
Quadro 35 Propriedades do componente RvProject..................................................... 117
Quadro 36 Propriedades do componente RvDataSetConnection ................................. 118
5
Sumário
Introdução......................................................................................................................... 9
Capítulo 1 Um form é uma janela................................................................................... 10
Criando seu primeiro form.......................................................................................... 10
Adicionando um título ............................................................................................ 10
Salvando a aplicação .............................................................................................. 11
Usando Componentes ................................................................................................. 12
Alterando Propriedades .............................................................................................. 12
Respondendo a Eventos.............................................................................................. 13
Compilando e Executando um Programa ................................................................... 15
Alterando Propriedades em Tempo de Execução....................................................... 16
Adicionando Código ao Programa ............................................................................. 16
Uma Ferramenta de Mão Dupla (Two-Way) .............................................................. 17
Analisando o código fonte...................................................................................... 17
A descrição textual do form........................................................................................ 20
O arquivo de projeto ................................................................................................... 21
Capítulo 2 O Ambiente Delphi....................................................................................... 22
Pedindo Ajuda ............................................................................................................ 22
Menus e Comandos do Delphi ................................................................................... 22
O menu File ............................................................................................................ 22
O menu Edit............................................................................................................ 23
O menu Search ....................................................................................................... 24
O menu View.......................................................................................................... 25
O menu Project ....................................................................................................... 25
O menu Run............................................................................................................ 26
Trabalhando com o Form Designer ........................................................................... 26
A Paleta de Componentes....................................................................................... 28
O Object Inspector.................................................................................................. 28
A Paleta de Alinhamento........................................................................................ 28
Escrevendo código no Editor...................................................................................... 29
Usando marcadores de página ................................................................................ 29
Code Insight............................................................................................................ 29
Complementação de código ................................................................................... 30
Modelos de código ................................................................................................. 30
Parâmetros de código ............................................................................................. 31
Gerenciando Projetos.................................................................................................. 31
O Project Manager.................................................................................................. 31
Ajustando opções de Projeto .................................................................................. 32
Compilando um Projeto.......................................................................................... 32
Explorando um Programa Compilado ........................................................................ 33
O Depurador Integrado........................................................................................... 33
O Object Browser ................................................................................................... 33
Os Arquivos produzidos pelo Sistema ....................................................................... 34
Capítulo 3 Conhecendo os Componentes Básicos ......................................................... 36
Componentes do próprio Windows ............................................................................ 36
Propriedades, eventos e métodos................................................................................ 36
Iniciando uma nova Aplicação ................................................................................... 37
Propriedades de Form (TForm).............................................................................. 37
Utilizando um Botão (TButton) .............................................................................. 38
6
Aceitando entrada de dados do Usuário (TEdit)..................................................... 39

Identificando Componentes (TLabel)..................................................................... 40
Fazendo escolhas (TCheckBox, TRadioButton e TRadioGroup)............................ 42
Uma Lista com muitas escolhas (TListBox) ........................................................... 44
Muitas opções em pouco espaço (TComboBox)..................................................... 45
Escolhendo um valor em um intervalo (TScrollBar).............................................. 46
Agrupando componentes relacionados (TGroupBox) ............................................ 47
Entrando múltiplas linhas (TMemo) ....................................................................... 48
Juntando tudo.......................................................................................................... 49
Capítulo 4 Caixas de Diálogo......................................................................................... 52
ShowMessage ............................................................................................................. 52
MessageDlg ................................................................................................................ 52
Application.MessageBox ............................................................................................ 53
InputBox ..................................................................................................................... 55
InputQuery.................................................................................................................. 56
Botão com ícone (TBitBtn) ......................................................................................... 57
Capítulo 5 Criando Menus.............................................................................................. 59
Estrutura do Menu Principal....................................................................................... 59
Diferentes funções dos itens de menu ........................................................................ 60
Aplicação Exemplo .................................................................................................... 60
A Caixa de Diálogo ColorDialog........................................................................... 61
Criando um Menu com o Menu Designer .............................................................. 62
Teclas de atalho e hotkeys ...................................................................................... 64
Respondendo aos comandos do menu .................................................................... 64
Chamadas a forms................................................................................................... 66
Menus locais (Pop-up) ........................................................................................... 67
Capítulo 6 Barras de ferramentas e de status.................................................................. 69
Barra de ferramentas (TToolBar) ........................................................................... 69
Barra de status (TStatusBar)................................................................................... 71
Capítulo 7 Tratamento de arquivos ................................................................................ 74
Escrevendo dados no arquivo ..................................................................................... 76
Lendo dados do arquivo ............................................................................................. 77
Melhorando a interface............................................................................................... 79
Capítulo 8 Aplicações usando Banco de Dados Local ................................................... 82
Acesso a Banco de Dados........................................................................................... 82
Aplicação de banco de dados...................................................................................... 83
Database Desktop ................................................................................................... 83
BDE - Criação do Alias .......................................................................................... 85
Iniciando a aplicação .............................................................................................. 86
Data Module ........................................................................................................... 86
A interface de entrada de dados da tabela Cidade .................................................. 88
A interface de entrada de dados da tabela Cliente.................................................. 91
Consultas a banco de dados ........................................................................................ 96
Componente para o resultado da consulta (TDBGrid) ........................................... 97
Pesquisa em tabelas usando Locate ........................................................................ 99
Pesquisa em tabelas usando TQuery..................................................................... 100
Capítulo 9 Aplicações usando Banco de Dados Cliente/Servidor................................ 103
Iniciando a aplicação ................................................................................................ 104
DataModule .......................................................................................................... 104
As interfaces de entrada de dados ........................................................................ 107
Form mestre-detalhe............................................................................................. 108
Relatórios.................................................................................................................. 117
7
Relatório de Cidades............................................................................................. 117

Relatório de Clientes ............................................................................................ 123
8
Introdução
Delphi é considerada uma ferramenta RAD (Rapid Application Development). E

realmente podemos desenvolver aplicações com bastante rapidez nesse ambiente. Desde
suas primeiras versões, Delphi tem evoluído de forma a oferecer inúmeros recursos aos
desenvolvedores, tanto para aplicações que rodam no desktop quanto para aplicações
web.
Junta-se a essa característica o fato de Delphi ser orientado a objetos, mas não
totalmente, pois mantém o paradigma procedural e, possibilitar o desenvolvimento
visual de aplicações para o ambiente Windows.
Este texto tenta apresentar Delphi de forma didática. Sem nenhuma pretensão de
cobrir toda a extensão desta poderosa ferramenta, mas oferecendo informações
suficientes para o estudante ou futuro desenvolvedor que deseje adotar o Delphi como
uma de suas ferramentas de trabalho. Como objeto do estudo foi usado o Delphi 7. No
entanto, qualquer versão a partir do Delphi 6 pode ser usada para acompanhar as
atividades. Tentou-se organizar o texto de forma a privilegiar o auto-estudo.
Ao fim da leitura, o estudante estará apto a desenvolver pequenas aplicações
usando bancos de dados, e capaz de prosseguir de forma autônoma, pois a base e o
conceito do ambiente são apresentados com o objetivo de facilitar isso.
Para atingir seu objetivo, este trabalho está organizado da seguinte forma: no
Capítulo 1 é apresentado o conceito de form no Delphi e criada a primeira aplicação
para introduzir o leitor no ambiente. No Capítulo 2 tem-se uma visão do ambiente do
Delphi, configurações e recursos do editor de código. No Capítulo 3 são apresentados os
componentes básicos através da estratégia de se construir uma aplicação passo a passo.
As caixas de diálogo são estudadas no Capítulo 4. Menus e barras de ferramentas e de
status são mostradas nos Capítulos 5 e 6. Após isso começa-se o estudo da persistência
de dados no Delphi, iniciando com os arquivos de texto no Capítulo 7. Aplicações de
bancos de dados locais são estudadas no Capítulo 8. Finalmente, no Capítulo 9, é criada
uma aplicação usando banco de dados cliente/servidor e faz-se uma introdução a
relatórios.
9
Capítulo 1 Um form é uma janela

Aplicações Windows são geralmente baseadas em janelas. Então, como vamos
criar nossa primeira janela? Bem, usando um form. Como o título do capítulo sugere um
form é realmente uma janela. Não há diferença entre os dois conceitos, pelo menos de
um ponto de vista geral.
Criando seu primeiro form

Embora você provavelmente já tenha criado algumas aplicações simples no
Delphi, vou mostrar o processo de novo, para esclarecer alguns pontos interessantes.
Criar um form é uma das operações mais fáceis no sistema: você só precisa abrir o
Delphi, e ele automaticamente irá criar um form novo, como se pode ver na figura
abaixo.
Figura 1 Form novo
Se você já tem um projeto aberto, escolha File | New | Application para fechar o
projeto antigo e abrir um novo. Acredite, você já tem uma aplicação funcionando. Você
pode executá-la, usando o botão Run ( ) na barra de ferramentas ou escolhendo Run
| Run no menu, e você verá um programa Windows padrão. Certamente não é uma
aplicação muito útil, pois é apenas uma janela vazia, mas tem o comportamento default
de qualquer janela Windows.
Adicionando um título
Antes de executar a aplicação, vamos fazer uma rápida alteração. O título do
form é Form1. Para um usuário, o título da janela torna-se o nome da aplicação. Vamos
mudar Form1 para algo mais significativo. Quando você abre o Delphi, a janela Object
Inspector deve aparecer ao lado esquerdo do form (se não aparecer pressione a tecla
F11).
10
Figura 2 Object Inspector
O Object Inspector mostra as propriedades do componente selecionado. A

janela contém duas abas. A primeira rotulada Properties. A outra rotulada Events e
mostra a lista de eventos que podem acontecer no form ou no componente selecionado.
As propriedades são listadas em ordem alfabética, assim fica fácil encontrar
aquela que se quer modificar. Podemos mudar o título do form simplesmente mudando
a propriedade Caption. Enquanto você digita um novo Caption o título do form se
modifica. Se você digitar Alo o título muda imediatamente. Como uma alternativa, você
pode modificar o nome do form mudando a propriedade Name. Se Caption ainda não
tiver sido modificada, o valor de Name também será usado por Caption. No entanto
para a propriedade Name do form digite frmPrincipal (frm significa form e Principal
indica a função do form).
Nem todas as propriedades de um componente mudam enquanto um novo valor
é digitado. Muitas são aplicadas quando você termina de digitar e teclar Enter, ou
quando muda o foco de entrada para outra propriedade.
Sem muito trabalho nós construímos uma aplicação com um menu de sistema
(aquele que aparece quando você clica o canto superior esquerdo da janela) e os botões
padrão das janelas: Minimizar, Maximizar e Fechar. Se você observar a barra de
tarefas você verá que algo não está certo. Em vez de mostrar o caption do form como
caption do ícone, ele mostra o nome do projeto, algo como Project1. Podemos corrigir
isso dando um novo nome ao projeto quando o salvarmos no disco.
Salvando a aplicação
Selecione Save Project ou Save Project As no menu File, e o Delphi irá lhe
perguntar o nome do arquivo do código fonte (unit) associado ao form, e depois o nome
do arquivo do projeto. Para o nome da unit digite o nome u_principal. Para que o nome
do projeto seja o mesmo do caption do form dê a ele o nome Alo. O Delphi vai salvar
uma unit com o nome u_principal.pas e um projeto com o nome Alo.dpr. Sempre que
salvar uma nova unit, tenha o cuidado de selecionar o diretório da sua aplicação. Se esse
11
cuidado não for tomado, corre-se o risco de ter módulos do programa espalhados pelo
disco e depois é difícil localizá-los.
Você pode também mudar o título de uma aplicação usando a aba Application da
caixa de diálogo Project Options (escolha a opção de menu Project | Options).
Usando Componentes
Agora é hora de começar a inserir algo útil em nosso form. Forms podem ser
pensados como contêineres de componentes. Cada form pode hospedar componentes e
controles. Você pode escolher um componente da paleta de componentes do ambiente
do Delphi, como mostra a Figura 3.
Figura 3 Paleta de Componentes
Há quatro maneiras de colocar componentes em um form. Selecione o

componente Button da aba Standard, você pode inseri-lo no form de uma das seguintes
formas:
• Clique no componente, mova o cursor do mouse para o form, pressione o

botão esquerdo na posição onde ficará o canto superior esquerdo do botão e
arraste o mouse para ajustar o tamanho.
• Selecione o componente e simplesmente clique no form na posição onde
quer inserir o botão com tamanho padrão.
• Dê um duplo clique no componente e o mesmo será inserido no centro do
form.
• Pressione a tecla Shift e clique ao mesmo tempo no componente, e coloque
vários componentes do mesmo tipo no form, procedendo de uma das duas
primeiras maneiras acima.
Queremos apenas um botão no form. Vamos centralizá-lo manualmente.

Selecione o botão inserido no form e depois View | Alignment Palette e uma caixa de
ferramentas com botões de alinhamento como essa aparece:
Figura 4 Botões de Alinhamento
Clique nos dois botões da terceira coluna e o botão ficará posicionado no centro
do form.
Alterando Propriedades
Assim como o form, o botão tem uma propriedade Caption que nós podemos
usar para alterar o seu rótulo (o texto mostrado dentro dele). Altere então a propriedade
Caption para Diga Alô. Na propriedade Name digite btnAlo.
12
É bastante comum definir uma convenção de nomes para cada tipo de

componente. Sugiro usar um nome curto, tal como btn para Button, para o prefixo do
nome do componente. Se você usar um prefixo diferente para cada tipo de componente,
o combo box do Object Inspector irá listar os componentes do mesmo tipo em um
grupo, pois eles estão em ordem alfabética.
Name é uma propriedade interna e é usada como nome de uma variável que se
refere ao componente no código da aplicação. Portanto, a propriedade Name segue as
regras de nomeação de identificadores da linguagem Pascal:
• Um identificador é uma seqüência de letras, dígitos ou underscore de

qualquer tamanho, embora apenas os primeiros 63 caracteres sejam
significativos.
• O primeiro caractere de um identificador não pode ser um número, deve ser
uma letra ou underscore.
• Identificadores não são case-sensitive, mas geralmente cada palavra em um
identificador começa com uma letra maiúscula, como em BtnHello.
Normalmente inicio o prefixo com letra minúscula. Mas btnhello, btnHello
ou BTNHello referem-se ao mesmo identificador.
Se você executar esse programa agora, verá que o botão funciona

adequadamente. Se você clicar nele, ele será pressionado, e quando libera o botão do
mouse o botão também é liberado. O problema é que quando você pressiona o botão,
espera-se que algo aconteça, mas nada acontece porque não definidos qualquer ação
para o clique do mouse ainda.
Respondendo a Eventos
Quando você pressiona o botão do mouse em um form ou componente, o
Windows informa do evento à sua aplicação, enviando uma mensagem a ela. O Delphi
responde ao receber uma notificação de evento chamando um método manipulador de
evento apropriado. Como programador você pode prover vários desses métodos, tanto
para form quanto para os componentes colocados nele. O Delphi prevê um certo número
de eventos para cada tipo de componente. A lista de eventos para o form é diferente da
lista de eventos para um botão, como se pode ver clicando nesses dois componentes
com a aba Events selecionada no Object Inspector. Alguns eventos são comuns a
ambos os componentes.
Há várias técnicas que você pode usar para definir um método manipulador para
o evento OnClick do botão:
• Selecione o botão e a aba Events no Object Inspector. Dê um duplo clique

na área branca ao lado direito do evento OnClick. Um novo nome de método
irá aparecer no editor de código, btnAloClick.
• Selecione o botão e a aba Events no Object Inspector. Digite o nome de um
novo método na área branca ao lado direito do evento OnClick. Pressione
Enter para aceitá-lo.
• Dê um duplo clique no botão e o Delphi irá executar a ação padrão para esse
componente, que é adicionar um método manipulador para o evento
OnClick.
13
Com qualquer uma dessas abordagens o Delphi cria um procedure chamado

btnAloClick (ou o nome que você escolheu) no código do form e abre o arquivo do
código fonte nesta posição:
Figura 5 Método manipulador de evento OnClick de botão
Como vimos, a ação padrão para um botão é adicionar um manipulador para

responder ao evento OnClick. Mesmo que você não tenha certeza do efeito da ação
padrão de um componente, você ainda pode dar um duplo clique nele. Se você adicionar
um procedure que não precisa, apenas deixe-o vazio. Métodos vazios gerados pelo
Delphi serão removidos assim que o arquivo for salvo ou o projeto for compilado.
Agora podemos digitar algumas instruções entre as palavras chaves begin e end
que delimitam o procedure. O código é simples. Apenas uma chamada ao procedure
ShowMessage, para mostrar uma mensagem.
Figura 6 Código do procedure
Observe que quando você digita o abre parênteses o Delphi irá mostrar a lista de
parâmetros em uma dica (hint) facilitando a sua lembrança. Se você precisar de ajuda
para ShowMessage posicione o cursor sobre seu nome e pressione ao mesmo tempo as
teclas Ctrl e F1. Essa ação irá abrir a Ajuda do Delphi para o procedure em questão.
Isso funciona para qualquer comando. Digite então dentro dos parênteses a string 'Alô
pessoal'. Execute o programa agora e clique no botão. Você verá a caixa de mensagem
abaixo:
Figura 7 Caixa de mensagem
A cada vez que você clica no botão a caixa de mensagem é mostrada. E se você
clicar fora do botão? Nada acontece. Naturalmente, podemos adicionar um novo código
para manipular esse evento. Só precisamos adicionar um evento OnClick para o próprio
form. Selecione o form e a aba Events do Object Inspector. Dê um duplo clique no
lado direito do evento OnClick. Agora adicione o seguinte código:
14
Figura 8 Método manipulador do evento OnClick de form
Compilando e Executando um Programa

Antes de prosseguir com a implementação do nosso programa Alo, vamos
analisar o que acontece quando executamos uma aplicação. Quando você clica no botão
Run ou seleciona Run | Run, o Delphi faz o seguinte:
1. Compila o código fonte Pascal que descreve o form.

2. Compila o arquivo do projeto.
3. Constrói o arquivo executável (EXE), ligando as bibliotecas apropriadas.
4. Executa o arquivo executável, geralmente em modo depuração (debug).
O ponto principal é que quando você pede para o Delphi executar uma aplicação,
ele a compila em um arquivo executável. Você pode facilmente executar este arquivo
do Windows Explorer ou usando o comando Executar do botão Iniciar. Compilar este
programa como se faz comumente, ligando todos os códigos de bibliotecas necessários,
produz um executável de uma centena de Kbytes. Usando pacotes de tempo de
execução, pode-se comprimir o executável para cerca de 20 Kb. Simplesmente
selecione o comando de menu Project | Options, vá para a aba Packages e marque a
caixa Build with runtime packages.
Figura 9 Opções de Projeto
Packages são bibliotecas de ligação dinâmicas (dll) contendo os componentes

Delphi. Usando os pacotes você pode fazer um arquivo executável muito menor. No
15
entanto o programa não executará se as dlls apropriadas não estiverem disponíveis no

computador onde o programa rodará.
Alterando Propriedades em Tempo de Execução

Vamos retornar à nossa aplicação Alo. Queremos agora tentar mudar algumas
propriedades em tempo de execução. Por exemplo, nós podemos mudar o Caption de
btnAlo para Diga alô de novo depois que o usuário clica nele pela primeira vez. Pode
ser necessário também mudar a largura do botão, pois o Caption fica maior. Isso é
muito simples de fazer. Só precisa mudar o código do procedure btnAloClick como
mostrado abaixo.
Figura 10 Alterando propriedade em tempo de execução
Portanto, para mudar uma propriedade como Caption em tempo de execução,

usa-se apenas um comando de atribuição. Muitas propriedades podem ser alteradas em
tempo de execução e outras podem ser alteradas apenas em tempo de execução. Aquelas
que só podem ser alteradas em tempo de execução não são listadas no Object
Inspector, mas aparecem na Ajuda do componente. Algumas dessas propriedades de
tempo de execução são definidas como apenas leitura, o que significa que você pode ler
seu valor, mas não pode alterá-lo.
Adicionando Código ao Programa

Nosso programa está quase finalizado, mas ainda temos um problema a resolver,
que irá exigir alguma codificação. O botão inicia no centro do form mas não permanece
lá quando você redimensiona o form. Este problema pode ser resolvido de duas formas
diferentes.
Uma solução é mudar o estilo da borda do form de modo que ele não possa ser
redimensionado em tempo de execução. Vá para a propriedade BorderStyle do form, e
selecione bsSingle em vez de bsSizeable. A outra abordagem é escrever algum código
para mover o botão para o centro a cada vez que o form for redimensionado. Embora
pareça que grande parte do seu trabalho em programar no Delphi seja selecionar opções
e elementos visuais, tem um momento que é necessário escrever código. Quanto mais
experiente você fica, mais código você escreve.
Quando você quer adicionar código ao programa, a primeira pergunta a ser
respondida é: Onde? Em um ambiente orientado a eventos como o Delphi, o código
sempre é executado em resposta a um evento. Quando um form é redimensionado
ocorre um evento: OnResize. Selecione o form e a aba Events no Object Inpector.
Procure o evento OnResize e dê um duplo clique à direita dele. Um novo procedure é
adicionado ao arquivo fonte do form. Agora digite o seguinte código:
16
Figura 11 Código para centralizar o botão em tempo de execução
Para determinar as propriedades Top e Left do botão - isto é, a posição do seu

canto superior esquerdo - o programa calcula o centro da página, dividindo a altura e a
largura da área interna ou área cliente da página por 2, e então subtrai metade da altura
(Height) e largura (Width) do botão. Se você usar as propriedades Height e Width do
form, em vez das propriedades Client Height e ClientWidth, você estará se referindo ao
centro da janela incluindo a barra do Caption.
Uma Ferramenta de Mão Dupla (Two-Way)

No exemplo anterior nós escrevemos três pequenas porções de código, para
responder a três eventos diferentes. Cada porção de código era parte de um procedure
diferente. Mas onde termina o código que nós escrevemos? O código fonte de um form
é escrito em um único arquivo fonte Pascal, aquele que chamamos u_principal.pas. O
arquivo cresce não apenas quando escrevemos código para responder a eventos, mas
também quando adicionamos componentes ao form. As propriedades desses
componentes juntamente com as propriedades do form são armazenadas em um segundo
arquivo chamado u_principal.dfm.
O Delphi pode ser definido como uma ferramenta de mão dupla, pois tudo que
você faz no ambiente visual leva a algum código. Nada é oculto e inacessível. Você tem
acesso ao código completo, e embora alguns deles sejam bastante complexos, você pode
editar tudo. Naturalmente, você pode usar apenas as ferramentas visuais, no mínimo até
você se tornar um programador Delphi mais experiente.
O termo ferramenta de mão dupla também significa que você é livre para alterar
o código produzido por você e então voltar às ferramentas visuais. No entanto você
precisa seguir algumas regras.
Analisando o código fonte

Vamos dar uma olhada no que o Delphi gerou de nossas operações anteriores.
Toda ação tem um efeito - no código Pascal, no código do form, ou em ambos. Quando
você inicia um novo form, ele tem um código fonte associado como mostrado na Figura
12.
O arquivo chamado Unit1, usa (uses) algumas units e define um novo tipo de
dado (uma classe) e uma nova variável (um objeto desta classe). A classe é chamada
TForm1 e é derivada de TForm. O objeto é Form1, do novo tipo TForm1.
Units são módulos nos quais um programa Pascal é dividido. Quando você inicia
um novo projeto, o Delphi gera um módulo program e uma unit que define o form
principal. A cada vez que você adiciona um form ao programa, uma unit é adicionada.
Por padrão, arquivos units têm extensão .PAS e arquivos program tem extensão .DPR.
17
Figura 12 Código fonte de um form
Se você renomeou os arquivos como sugerimos no exemplo anterior, o código

muda um pouco, pois o nome da unit deve refletir o nome do arquivo. Se você chamou
o arquivo de u_principal.pas o código irá começar assim:
Figura 13 Unit com novo nome
Assim que você começa a adicionar novos componentes, a declaração da classe

form muda. Por exemplo, quando você adiciona um botão ao form, a parte do código
fonte que define novos tipos de dados torna-se o seguinte:
Figura 14 Código após adicionar um botão
Agora se a propriedade Name do botão for alterada para btnAlo, o código muda
para:
Figura 15 Código após alterar a propriedade Name do botão
18
A alteração de outras propriedades não afeta o código fonte. As propriedades de

form e seus componentes são armazenadas em um arquivo de descrição de form
separado (com extensão .DFM).
Adicionar novos manipuladores de eventos tem maior impacto no código. A
cada vez que um novo manipulador de evento é definido, uma nova linha é adicionada à
definição de tipo de dado do form, um corpo de método vazio é inserido na
implementation, e alguma informação é armazenada no arquivo de descrição do form
também como pode ser observado na Figura 16.
Vale observar que há um único arquivo para o código inteiro do form, não
apenas pequenos fragmentos. Naturalmente, o código é apenas uma descrição parcial do
form. O código fonte determina como o form e seus componentes reagem aos eventos.
A descrição do form (o arquivo DFM) armazena os valores das propriedades do form e
de seus componentes. Em geral, o código fonte define as ações do sistema, e os
arquivos form definem o estado inicial do sistema.
Figura 16 Código com manipuladores de eventos
19
A descrição textual do form

Como já falamos, junto com o arquivo PAS contendo o código fonte, há outro
arquivo descrevendo o form e suas propriedades, seus componentes e as propriedades
dos componentes. Este é o arquivo DFM, um arquivo texto ou binário. Independente do
formato, se você carregar esse arquivo no editor de código, ele será convertido em uma
descrição textual. Isto pode dar a falsa impressão que o arquivo DFM é um arquivo
texto, mas isso só ocorre se você selecionar a opção correspondente.
Você pode abrir a descrição textual de um form simplesmente clicando com o
botão direito no form em tempo de desenvolvimento e selecionado o comando View As
Text. Isto fecha o form, salvando-o se necessário, e abre o arquivo DFM no editor.
Depois podemos voltar ao form selecionando o comando View As Form no menu. Nos
dois casos o atalho ALT + F12 produz o mesmo efeito.
Para entender o que é armazenado no arquivo DFM, vamos dar uma olhada na
listagem seguinte, que mostra a descrição textual do form do nosso programa exemplo.
Figura 17 Descrição textual do form
Como se pode ver nesta listagem, a descrição textual de um form contém objetos
(neste caso, dois) em diferentes níveis. O objeto frmPrincipal contém o objeto btnAlo,
como é possível ver pela identação do texto. Cada objeto tem suas propriedades e
alguns métodos conectados a eventos (neste caso, OnClick).
20
O arquivo de projeto
Além dos dois arquivos que descrevem um form (PAS e DFM), um terceiro
arquivo é vital para construir a aplicação. É o arquivo de projeto Delphi (DPR). Este
arquivo é construído automaticamente, e raramente você precisa alterá-lo,
principalmente para pequenos programas. Se for necessário alterar o comportamento de
um projeto, há duas maneiras básicas de fazer isso: Você pode usar o Project Manager
do menu View e mudar algumas opções, ou pode editar diretamente o arquivo de
projeto.
Figura 18 Project Manager
O arquivo de projeto é na verdade um arquivo fonte Pascal, descrevendo a

estrutura geral do programa e seu código de execução.
Figura 19 Código fonte do arquivo de projeto
Podemos visualizar esse arquivo através do comando de menu View | Project

Source. Ou clicar no botão View unit na barra de ferramentas ou o comando de menu
View | Units. Em qualquer das opções o Delphi mostra uma caixa de diálogo com uma
lista de arquivos fonte do projeto. Escolha o arquivo do projeto ou qualquer outro que
lhe interesse visualizar.
21
Capítulo 2 O Ambiente Delphi

Em uma ferramenta de programação visual como o Delphi, o papel do ambiente
é muito importante, algumas vezes mais importante que a linguagem usada pelo
compilador. Esta é uma boa razão para explorarmos um pouco o ambiente Delphi.
Não discutiremos todas as características do Delphi nem todas as opções de
menu. Em vez disso daremos uma visão geral e ajudaremos você a explorar algumas
partes do ambiente que não são óbvias, e também daremos algumas dicas que podem ser
úteis.
Pedindo Ajuda
O primeiro elemento do ambiente que iremos explorar é o sistema de ajuda. Há
basicamente duas maneiras de chamar o sistema de ajuda: selecionando o comando
apropriado no menu ou escolhendo um elemento da interface ou porção de código fonte
e pressionando F1.
Quando você pressiona F1 o Delphi não faz uma busca exata na lista de ajuda.
Em vez disso, ele tenta entender o que você está querendo. Por exemplo, quando você
aciona F1 quando o curso está sobre o nome do componente Button1 no código fonte, o
sistema de ajuda automaticamente abre a descrição da classe TButton, pois
provavelmente é isso que você está buscando. Esta técnica também funciona quando
você dá um novo nome ao componente. Isto significa que o Delphi procura o
significado contextual da palavra para a qual você procura ajuda.
Você pode achar quase tudo no sistema de ajuda, mas é preciso saber o que
procurar. Isto parece óbvio, mas às vezes não é. Gastando algum tempo explorando o
sistema de ajuda irá ajudar você entender a estrutura desses arquivos e aprender como
achar a informação que você precisa.
Os arquivos de ajuda têm bastante informação tanto para iniciantes quanto para
programadores avançados. Eles listam todos os métodos e propriedades de cada
componente, os parâmetros de cada método ou função, e detalhes semelhantes, que são
importantes enquanto se escreve o código.
Menus e Comandos do Delphi

Há basicamente três maneiras de executar um comando no ambiente do Delphi:
• Usar o menu.
• Usar a barra de ferramentas.
• Usar os menus ativados pressionando o botão direito do mouse.
A seguir algumas sugestões para usar alguns comandos de menu. Algumas

opções possuem botões na barra de ferramentas.
O menu File
New: abre uma caixa de diálogo com novos itens que podem ser adicionados ao
projeto em desenvolvimento.
Open: responsável pela abertura dos projetos. Também abre units, forms e texto
no Editor de Código.
Open Project: essa opção abre somente projetos (DPR) e pacotes (BPG).
22
Reopen: atalho para a abertura dos últimos projetos e arquivos abertos

anteriormente.
Save: salva o arquivo aberto no Editor de Código.
Save All: salva todas as alterações ainda não salvas.
Save Project As: salva o projeto com outro nome ou outro local.
Close: fecha o arquivo aberto no Editor de Código.
Close All: fecha a aplicação inteira.
O menu Edit
Este menu tem algumas operações que são típicas, tais como Undo, Redo e os
comandos Cut, Copy e Paste, mais alguns comandos específicos para as janelas do
editor e de form. É importante dizer que os comandos padrão do menu Edit (e os
atalhos Crtl + Z, Ctrl + X, Ctrl + C e Ctrl + V) funcionam tanto para texto quanto para
componentes. Algumas diferenças devem ser observadas. Por exemplo, quando
trabalhamos com texto, o primeiro comando do menu Edit é Undo, mas quando
trabalhamos com form, o primeiro comando é Undelete.
Você deve ter observado que é possível copiar componentes do form para o
editor e vice versa. O Delphi coloca componentes no Clipboard na sua descrição textual.
Você pode até editar a versão textual do componente, copiar o texto para o Clipboard, e
então colá-lo de volta no form como um novo componente.
Por exemplo, se você colocar um botão em um form, copiá-lo e colá-lo em um
editor, você obterá a seguinte descrição:
Figura 20 Descrição textual de um botão
Agora se você alterar o nome (Name) do objeto, rótulo (Caption) ou posição

(Left e Top), ou ainda adicionar uma nova propriedade, essas mudanças podem ser
copiadas e coladas de volta em um form. Exemplo de mudanças:
object btnAlo: TButton
Left = 200
Top = 200
Width = 180
Height = 60
TabOrder = 0
Caption = 'My Button'
Font.Name = 'Arial'
end
Figura 21 Mudanças na descrição textual usando um editor qualquer
Copiando a descrição acima e colando-a em um form irá criar um botão na

posição especificada com rótulo My Button e fonte Arial. Para usar esta técnica, você
precisar saber editar a descrição textual de um componente, que propriedades são
23
válidas, e como definir os valores das propriedades, principalmente o tipo de dado.

Quando o Delphi interpreta a descrição textual de um componente, ele também pode
mudar os valores de outras propriedades relacionadas àquelas que você alterou, e pode
também mudar a posição do componente no form, para que ele não fique sobreposto a
outro. Você pode ver como o Delphi modifica as propriedades do componente
visualizando o form como texto:
Figura 22 Descrição textual do botão após ser colado no form
Como podemos constatar algumas propriedades foram adicionadas

automaticamente, para especificar propriedades de Fonte.
O menu Search
Este menu tem alguns comandos padrão também, tais como Search and
Replace, e o Find in Files:
Figura 23 Comando Find in Files
O comando Find in Files permite procurar uma string em todos os arquivos

fonte de um projeto, todos os arquivos abertos ou todos os arquivos em um diretório
dependendo do botão marcado. O resultado da busca será mostrado na área de
24
mensagem no rodapé da janela do editor de código. Você pode selecionar uma entrada
para abrir o arquivo correspondente e saltar para a linha que contém o texto encontrado.
O comando Incremental Search quando selecionado posiciona o cursor no
editor de código e você pode digitar o texto diretamente na área de texto. Quando você
digita a primeira letra o editor irá se mover para a palavra que inicia com essa letra, e
assim por diante.
O comando Go to Line Number desvia o editor para a linha que você
selecionar. O comando Find Error localiza erros de execução. Quando você está
executando um programa e ocorre um erro fatal o Delphi mostra um número de
endereço interno. Você pode entrar esse valor na caixa de diálogo Find Error para o
Delphi recompilar o programa e procurar o endereço especificado. Quando ele encontra
o endereço, ele mostra a linha de código fonte correspondente. Pode ser que o erro não
esteja em uma linha do seu código, mas sim em uma linha de código de sistema ou de
biblioteca. Neste caso o comando não consegue encontrar a linha que causou o erro.
O menu View
Muitos dos comandos View podem ser usados para mostrar janelas do ambiente
Delphi, tais como Project Manager, Breakpoints e Components. Algumas dessas
janelas são usadas durante a depuração e outras quando se está escrevendo código.
Os comandos da segunda parte do View também estão disponíveis na barra de
ferramentas. O comando Toggle Form/Unit (F12) é usado para alternar entre o form
que você está trabalhando e seu código fonte. Se você usar uma janela de código fonte
grande o suficiente para conter bastante texto, você usará com freqüência esse comando.
O comando New Edit Window abre uma segunda janela do editor. É a única
maneira de visualizar dois arquivos lado a lado no Delphi. Você visualiza dois arquivos
ou partes diferentes de um mesmo arquivo.
Em Toolbars você pode optar por ocultar barra de ferramentas e paleta de
componentes, embora essa não seja uma decisão muito sensata, pois torna o uso do
ambiente bastante desconfortável.
O menu Project
Este menu tem comandos para gerenciar um projeto e compilá-lo. Add to
Project e Remove from Project são usados para adicionar ou remover forms ou
arquivos fonte em Pascal ao projeto.
O comando Compile constrói ou atualiza o arquivo executável, verificando que
arquivos fonte foram modificados e compilando-os quando necessário. Build All
compila todos os arquivos fonte do projeto mesmo se eles não tiverem sido modificados
desde a última compilação. Se você quiser saber se a sintaxe do código escrito está
correta, mas não quer construir o programa, você pode usar o comando Syntax Check.
O comando Information mostra alguns detalhes da última compilação feita. A
figura seguinte mostra as informações relacionadas a um programa:
25
Figura 24 Informações sobre um programa compilado
Options é usado para alterar opções do compilador e do ligador, opções da

aplicação, e assim por diante. Quando você altera opções de projeto, você pode marcar a
caixa Default para indicar que o conjunto de opções será usado para novos projetos.
O menu Run
O menu Run deveria ser chamado Debug. Muitos de seus comandos são
relacionados à depuração, inclusive o próprio comando Run. Quando você executa um
programa no ambiente Delphi, ele é executado sob o depurador integrado, a menos que
esta opção esteja desabilitada em Environment. O comando Run é um dos mais
executados, pois o Delphi automaticamente recompila um programa antes de executá-
lo, se o código fonte tiver sido modificado. Você pode optar por teclar F9 para compilar
e executar um programa.
O comando Parameters pode especificar parâmetros a serem passados na linha
de comando do programa que vai ser executado. Os comandos restantes são usados
durante a depuração, para executar um programa passo a passo, definir breakpoints,
observar valores de variáveis e objetos e assim por diante.
O Delphi possui outros menus e os menus locais que podem ser acionados
através do botão direito do mouse. Quase todas as janelas do Delphi possuem seus
menus locais com seus comandos relacionados.
Trabalhando com o Form Designer

Desenhar forms é a parte central do desenvolvimento visual no ambiente Delphi.
Cada componente colocado no form e cada propriedade definida são armazenadas em
um arquivo que descreve o form (arquivo DFM) e tem algum efeito no código fonte
associado ao form (arquivo PAS).
Quando você inicia uma nova aplicação, o Delphi cria um form vazio, e você
pode começar a trabalhar com ele. Um projeto pode ter qualquer quantidade de forms.
Quando você trabalha com um form em tempo de projeto, você está na verdade usando
o Form Designer. Quando você está trabalhando com um form, você pode alterar suas
propriedades, as propriedades de um de seus componentes, ou as propriedades de vários
componentes de uma vez. Para selecionar um form ou um de seus componentes você
simplesmente clica nele ou usa o Object Selector (a caixa combinada no Object
Inspector), onde se pode ver o nome e tipo do objeto selecionado. Você pode
26
selecionar mais de um componente, mantendo a tecla Shift pressionada enquanto clica o

mouse, ou arrastando um retângulo de seleção em volta dos componentes no form.
Quando você seleciona mais de um componente no form, você pode alinhá-los
ou dimensioná-los. Muitas das opções na caixa de diálogo Alignment são também
disponíveis na aba Alignment (acessível através do comando View | Alignment
Palette). Você pode também abrir as caixas Tab Order e Creation Order para ajustar
a ordem que os componentes visuais serão alcançados pela tecla Tab e a ordem de
criação dos componentes não visuais.
Figura 25 Environment Options
Além de comandos específicos de menus locais, é possível ajustar algumas

opções de form usando o comando Tools | Environment Options e escolhendo a aba
Designer.
As opções relacionadas a form referem-se a ativação e dimensionamento da
grade. A grade torna mais fácil colocar componentes exatamente onde se quer no form,
ajustando depois seu tamanho e posição. Sem a grade torna-se difícil alinhar dois
componentes manualmente.
Há duas alternativas para ajustar a posição de um componente: ou você pode
ajustar os valores das propriedades Left e Top, ou você usar as setas enquanto mantém a
tecla Crtl pressionada. O uso das setas possibilita o ajuste fino da posição.
Similarmente, você pode usar as setas juntamente com a tecla Shift para fazer o ajuste
fino do tamanho do componente. Shift + Ctrl + setas faz o componente se mover em
intervalos da grade.
27
A Paleta de Componentes
Para adicionar um componente ao form, você pode clicar no componente em
uma das páginas da paleta de Componentes e então clicar no form para colocar o novo
componente. No form você pode pressionar o botão esquerdo e arrastar o mouse para
ajustar a posição e o tamanho do componente ao mesmo tempo, ou apenas clique para
deixar o Delphi usar o tamanho padrão.
Cada aba da paleta tem um grupo de componentes, cada componente tem um
ícone e um nome que aparece em uma dica (hint). Para ver a dica apenas passe o mouse
pelo botão e espere um segundo. As dicas mostram o nome oficial do componente. São
formados pelos nomes das classes que definem os componentes sem o T inicial (por
exemplo, se a classe é TButton, o nome é Button).
Para inserir mais de um componente de um mesmo tipo no form, clique no
componente na paleta com a tecla Shift pressionada. Assim, cada vez que você clica no
form o Delphi adiciona um novo componente deste tipo. Para encerrar a operação clique
o botão com a seta (seletor padrão) à esquerda da paleta de componentes.
Se você estiver sem mouse você pode adicionar um componente usando o
comando View | Component List. Selecione um componente na lista e clique no botão
Add to form.
O Object Inspector
Quando você está desenhando um form, você usa o Object Inspector para
ajustar valores de propriedades de form ou componentes. Suas abas listam propriedades
e seus valores, e eventos do componente selecionado, em duas janelas que podem ser
redimensionadas. Um Object Selector no topo do Object Inspector indica o
componente corrente e seu tipo de dado, e pode ser usado para mudar o componente
selecionado. O Object Inspector não lista todas as propriedades de um componente.
Inclui apenas as propriedades que podem ser alteradas em tempo de desenvolvimento.
A coluna da direita do Object Inspector permite apenas a edição apropriada
para o tipo de dado da propriedade. Dependendo da propriedade, você poderá inserir
uma string ou número, escolher de uma lista de opções, ou chamar um editor específico
pressionando um botão elipse. Quando uma propriedade admite dois valores, como
True ou False, você pode alternar entre um valor e outro apenas com um duplo clique.
Se há mais de dois valores, o duplo clique irá selecionar o próximo da lista. Para
algumas propriedades, tais como Color, você pode entrar um valor, selecionar um valor
de uma lista ou chamar um editor específico. Outras propriedades, tal como Font,
podem ser customizadas ou expandindo suas subpropriedades (usando o sinal de mais
ou menos próximo ao seu nome) ou invocando um editor. Em outros casos, tais como
em listas de strings, os editores especiais são a única maneira de alterar uma
propriedade.
Se por algum motivo o Object Inspector desaparecer, pressione F11 e ele ficará
visível de novo.
A Paleta de Alinhamento
A última ferramenta relacionada ao desenho de form é a paleta Alignment. Você
pode abrir esta paleta com o comando View | Alignment Palette. Ou pode escolher o
componente que deseja alinhar e então selecionar o comando Align no menu local do
form.
A paleta de alinhamento apresenta comandos para posicionar controles,
centralizá-los, espaçá-los igualmente, e assim por diante.
28
Escrevendo código no Editor

Depois que o form estiver desenhado, você geralmente precisa escrever algum
código para responder a alguns de seus eventos. A cada vez que você trabalha com um
evento, o Delphi abre o editor com o arquivo relacionado ao form. Você pode
facilmente alternar entre o Form Designer e o editor de código clicando no botão
Toggle Form Unit na barra de ferramentas, clicando na janela correspondente, ou
pressionando a tecla F12.
O Delphi permite você trabalhar com vários arquivos fonte de uma única vez,
usando a metáfora do bloco de notas com abas. Cada aba do bloco de notas corresponde
a um arquivo diferente. Você pode trabalhar com units relacionadas a forms, units
independentes e arquivos de projetos; abrir arquivos de descrição de form no formato
textual; e até trabalhar com arquivos texto quaisquer. Você pode ir para a próxima aba
do editor pressionando Ctrl + Tab, ou pressionando Shift + Ctrl + Tab para se mover
no sentido contrário.
Há várias opções do ambiente que afetam o editor, muitas delas localizadas nas
páginas Source Options, Display e Color da caixa de diálogo Editor Options no menu
Tools. Na página Preferences de Environment Options você pode ajustar a
característica Autosave. Salvar os códigos fonte a cada vez que você executa o
programa pode prevenir perda de modificações quando seu programa provocar
travamento do sistema.
Usando marcadores de página

O editor também permite usar marcadores de página. Quando você estiver em
uma linha do editor, você pode pressionar Ctrl + Shift mais uma tecla numérica de 0 a 9
para definir um novo marcador de página, que aparece como um pequeno bloco
numerado na margem esquerda. A partir daí você pode teclar Ctrl mais a tecla numérica
para retornar a essa linha. Para retirar a marca, posicione o editor na mesma linha
marcada e pressione Ctrl + Shift + tecla numérica.
Esses marcadores têm uma limitação que pode tornar seu uso um pouco difícil.
Se você criar um novo marcador usando um número já existente, o marcador anterior
será removido e inserido na nova linha. Outro comportamento desagradável é que você
pode adicionar múltiplos marcadores em uma mesma linha, mas apenas um deles será
visível. Os marcadores não são salvos junto com o arquivo, só são válidos enquanto o
arquivo estiver aberto.
Code Insight
O editor tem várias características conhecidas coletivamente como Code
Insight. A idéia principal desta tecnologia é tornar mais fácil a escrita de código tanto
por programadores iniciantes quanto por programadores experientes. São quatro essas
funcionalidades:
• O assistente de complementação de código permite que você escolha a

propriedade ou método de um objeto simplesmente procurando-o numa lista,
ou digitando suas letras iniciais. Permite também que você procure um valor
apropriado para um comando de atribuição.
• O assistente de modelos de código permite você inserir um dos modelos
predefinidos de código, tal como um comando complexo com um bloco
begin-end interno. É possível também definir novos modelos.
29
• O assistente de parâmetro de código mostra em uma sugestão (hint) ou janela

dica de contexto (tooltip) o tipo de dado de um parâmetro de método ou
função enquanto você o está digitando.
• A avaliação de expressão dica de contexto é uma característica de tempo de
depuração. Ela mostra o valor do identificador, propriedade ou expressão
que está sob o cursor do mouse.
Complementação de código
Há duas maneiras de ativar esse assistente. Você pode digitar o nome de um
objeto, tal como Button1, adicionar um ponto, e esperar. O Delphi irá mostrar uma lista
de propriedades e métodos válidos que podem ser aplicados a esse objeto. O tempo que
você precisa esperar para aparecer a janela com a lista de opções depende da opção
Delay, que pode ser configurada na página Code Insight da janela de configurações do
editor em Editor Options.
A segunda maneira de ativar o assistente consiste em digitar o nome do objeto
seguido de ponto, as letras iniciais da propriedade ou método e pressione Ctrl + espaço.
A lista será mostrada imediatamente, mas agora, o assistente tentará adivinhar que
propriedade ou método você está procurando através das letras iniciais digitadas. Esta
combinação de teclas pode ser usada em um comando de atribuição. Se você digitar x :=
e pressionar Ctrl + espaço o Delphi mostrará uma lista de possíveis objetos, variáveis ou
constantes que podem ser usados neste ponto do programa.
As opções mostradas nessa lista são dinâmicas. O Delphi está constantemente
validando o código digitado. Assim, se você adicionar uma nova variável ela será
mostrada na lista.
Modelos de código
Diferente do assistente de complementação de código, o assistente de modelos
de código deve ser ativado manualmente. Você pode fazer isso teclando Ctrl + J para
mostrar todos os modelos.
Geralmente você digita uma palavra chave, como if ou array, e então pressiona
Ctrl + J, para ativar apenas os modelos que iniciam com aquela palavra. Para algumas
palavras chave existem vários modelos, todos iniciando com a mesma palavra chave
(tais como ifA ou ifB). Assim, se você pressionar Ctrl + J você verá todos os modelos
relacionados àquela palavra chave.
Você pode usar esse assistente para dar um nome a uma expressão comum
usando a página Code Insight. Por exemplo, se você usa com freqüência a função
MessageDlg, você pode entrar um novo modelo chamado mess, digite uma descrição e
então adicione o seguinte texto:
MessageDlg('|', mtInformation, [mbOk], 0);
Agora toda vez que você precisar criar uma caixa de mensagem, você apenas
digita mess e pressiona Ctrl + J, e o texto completo será mostrado. A linha vertical
indica a posição para onde o cursor será movido depois que o Delphi mostrar o texto.
Como pudemos ver esse assistente não está relacionado a palavras chave da
linguagem, mas é um mecanismo geral.
30
Parâmetros de código
A terceira tecnologia Code Insight que será discutida é o assistente de
parâmetros de código. Com esse recurso digitamos o nome da função e o abre
parênteses, os parâmetros e tipos de dados aparecem em uma janela de dica.
Figura 26 Assistente de Parâmetros de Código
Observe que o primeiro parâmetro aparece em negrito. Depois que você digita o
primeiro parâmetro, o segundo fica em negrito e assim por diante. Isso é útil para
funções com muitos parâmetros. Esse assistente também funciona para as funções que
você cria.
Gerenciando Projetos
Vamos estudar maneiras de alterar características de um projeto usando as
opções Project Manager e Project Options.
O Project Manager
Quando um projeto é carregado você pode selecionar a opção View | Project
Manager para abrir uma janela de projeto. A janela lista todos os forms e units que
fazem parte do projeto. Os menus locais de Project Manager permitem fazer uma série
de operações sobre um projeto, tais como adicionar arquivos novos ou existentes,
remover arquivos, ver um arquivo de código fonte ou form, e adicionar o projeto ao
repositório. Muitos desses comandos estão disponíveis na barra de ferramentas dessa
janela:
Figura 27 Project Manager
31
Ajustando opções de Projeto

A partir do Project Manager (ou do menu Project) você pode chamar o diálogo
Project Options. A primeira página de Project Options, chamada Forms, lista os
forms que podem ser criados automaticamente na inicialização do programa
(comportamento padrão) e os forms que podem ser criados manualmente pelo
programa. Um form pode facilmente ser movido de uma lista para outra. A próxima
página, Application, é usada para definir o nome da aplicação e o nome do arquivo de
ajuda e também escolher o ícone. Outras opções dizem respeito ao compilador e
linkeditor, informação de versão e o uso de pacotes de tempo de execução.
Todas as opções de projetos são salvas automaticamente com o projeto em um
arquivo com a extensão DOF. É um arquivo texto que pode facilmente ser editado. Este
arquivo não pode ser excluído se você modificar alguma opção padrão.
Compilando um Projeto
Há várias maneiras de compilar um projeto. Se você executá-lo (pressionando
F9 ou clicando no botão da barra de ferramentas) o Delphi irá compilá-lo primeiro.
Quando o Delphi compila um projeto, ele compila apenas os arquivos que foram
modificados. Selecionando Build All, todos os arquivos são compilados mesmo se não
tiverem sido alterados. Isso não faz muito sentido, pois o Delphi sabe o que precisa
compilar, mas quando você altera alguma opção de projeto Build All deve ser usado
para que as alterações tenham efeito.
O projeto lista os arquivos de código fonte e os forms relacionados. A lista é
visível tanto nos fontes do projeto quanto no Project Manager, e é usado para compilar
ou reconstruir um projeto. Cada arquivo de código fonte é transformado em uma unit
compilada Delphi, um arquivo com o mesmo nome do código fonte, mas com a
extensão DCU.
Quando o código fonte do projeto é compilado, as units que formam o projeto
são linkados no arquivo executável junto com o código da biblioteca Visual Component
Library (VCL). Você pode entender melhor os passos da compilação e acompanhar o
que acontece durante esta operação se você habilitar a opção Show Compiler Progress.
Você encontrará esta opção na página Preferences da caixa de diálogo Environment
Options. Isso torna a compilação um pouco mais lenta, a janela possibilita ver que
código fonte está sendo compilado.
Figura 28 Compilador em andamento
32
Explorando um Programa Compilado

Delphi oferece várias ferramentas que podem ser usadas para explorar um
programa compilado, incluindo o depurador e o Object Browser.
O Depurador Integrado
O Delphi tem um depurador integrado com várias características, e não é
necessário fazer muita coisa para usá-lo. Cada vez que você executa um programa no
ambiente Delphi, ele é executado por padrão no depurador. Isso significa que você pode
determinar um ponto de parada (breakpoint) de execução do programa em uma linha de
código específica. Por exemplo, abra o programa Alo criado no Capítulo 1 e dê um
duplo clique no botão para abrir o editor no código relacionado. Agora crie um ponto de
parada clicando na margem do editor, escolhendo o comando Toggle Breakpoint no
menu local do editor ou pressionando F5.
Figura 29 Ponto de parada (Breakpoint)
O editor irá destacar a linha onde você inseriu o ponto de parada, mostrando-a
em uma cor diferente.
Agora o programa pode ser executado normalmente, mas toda vez que você
clicar no botão o depurador irá parar a execução do programa, mostrando a linha de
código correspondente. Você pode executar esta e as linhas seguintes passo a passo,
inspecionando as funções chamadas ou continuando a execução do programa.
Quando o programa é parado você pode inspecionar seu estado em detalhes.
Embora haja muitas maneiras de inspecionar um valor, a maneira mais simples é a
Avaliação de Expressões Dica de Contexto. Simplesmente passe o mouse sobre o
nome de qualquer variável e você verá seu valor em uma janela de dica.
O Object Browser
Depois que o programa é compilado, você pode executar o Object Browser
(disponível através do comando de menu View | Browser) para explorá-lo, mesmo que
você não o esteja executando o depurando-o. Esta ferramenta permite que você veja
todas as classes definidas pelo programa (ou pelas units usadas direta ou indiretamente
pelo programa), todas as variáveis e nomes globais, etc. Para cada classe, o Object
Browser mostra a lista de propriedades, métodos e variáveis - locais e herdadas,
privadas e públicas. A informação mostrada no Object Browser pode não significar
muito se você ainda não está familiarizado com a linguagem Object Pascal usada pelo
Delphi.
33
Os Arquivos produzidos pelo Sistema

Como já vimos, o Delphi produz uma série de arquivos para cada projeto, e você
deve saber como são nomeados e o que eles guardam. Basicamente há dois elementos
que têm impacto na forma como os arquivos são nomeados: os nomes que você dá ao
projeto e seus forms, e as extensões predefinidas usadas pelo Delphi para os arquivos
que você escreve e para aqueles gerados pelo sistema.
A grande vantagem do Delphi sobre outros ambientes de programação visual é
que muitos dos arquivos de código fonte são arquivos texto ASCII. Já vimos o código
fonte Pascal, código do projeto e arquivos de descrição de form no Capítulo 1. Agora
vamos dar uma olhada nos arquivos de opções e desktop. Ambos os arquivos usam
estrutura similar aos arquivos INI do Windows, nos quais cada seção é indicada pelo
nome entre colchetes. Por exemplo, veja um fragmento de ALO.DOF do projeto Alo na
Figura 30.
A mesma estrutura é usada pelos arquivos desktop, que geralmente são mais
longos. É bom dar uma olhada no que é armazenado nesses arquivos para entender seu
papel. Em resumo, um arquivo desktop (.DSK) lista as janelas Delphi, indicando suas
posições e estados. Por exemplo, a descrição da janela principal pode ser visualizada na
Figura 31.
Figura 30 Fragmento de ALO.DOF
Figura 31 Arquivo desktop (.DSK)
34
Além de opções do ambiente e posições de janela, o arquivo desktop contém

uma série de listas de histórico, indicação dos pontos de parada atuais, módulos ativos,
módulos fechados e forms.
35
Capítulo 3 Conhecendo os Componentes

Básicos
Agora que já conhecemos um pouco o ambiente Delphi, já entendemos a
estrutura de uma aplicação, já criamos um pequeno programa, estamos prontos para ir
para a parte principal do ambiente de programação: o uso de componentes. Esta é a
característica chave deste ambiente: programação visual usando componentes.
O sistema vem com uma série de componentes prontos para uso. Não serão
descritos aqui todos os componentes em detalhes com suas propriedades, métodos e
eventos. Se você precisar de mais informação, isso pode ser facilmente encontrado no
sistema de ajuda.
Neste capítulo usaremos exemplos bastante simples para focar em apenas
algumas características mais importantes.
Iniciaremos dando destaque a um grupo de componentes básicos, tais como
botões, rótulos, caixas de listas, campos de edição e outros controles relacionados. A
maioria dos componentes que são discutidos neste capítulo está presente na aba
Standard da paleta de componentes.
Componentes do próprio Windows

De onde vem a idéia de programar para Windows usando componentes? A
resposta é simples: o próprio Windows possui alguns componentes, geralmente
chamados controles. Um controle é tecnicamente uma janela predefinida com um
comportamento específico, algumas propriedades e alguns métodos. Esses controles
foram o primeiro passo em direção ao desenvolvimento por componentes. O segundo
passo foi provavelmente os controles do VisualBasic e o terceiro passo são os
componentes do Delphi.
Os controles de sistema padrão são os componentes básicos de cada aplicação
Windows, independente da linguagem de programação usada para escrevê-la, e são bem
conhecidos por todos os usuários do Windows. O Delphi literalmente empacota esses
controles predefinidos do Windows em alguns de seus componentes básicos, inclusive
os que serão discutidos neste capítulo.
TWinControl é a classe base de todos os componentes ajanelados do Delphi.
Esses componentes podem receber foco, podem conter outros controles e têm um
manipulador de janela.
Propriedades, eventos e métodos

Propriedades são um tipo especial de campo de um componente, que definem
suas características. Valores de algumas propriedades podem ser alterados pelo Object
Inspector em tempo de desenvolvimento. Outras propriedades só podem ser
modificadas em tempo de execução.
Eventos acontecem em resposta a uma ação do usuário ou do próprio sistema.
Ao programar um método de evento devemos levar em consideração que este só será
executado quando o evento acontecer. Uma das tarefas mais importantes da
programação orientada a eventos é determinar quais eventos serão usados e qual a
ordem que esses eventos acontecem.
Os métodos realizam ações definidas pelo componente, representam o
comportamento do componente. São procedimentos e funções definidos dentro da
36
classe, e por isso podem acessar diretamente as propriedades do componente sem que
necessitem ser passados como parâmetros.
Iniciando uma nova Aplicação

Já vimos no Capítulo 1 que, quando o Delphi é aberto, automaticamente, é
iniciada uma nova aplicação. Vejamos outra maneira de criar uma nova aplicação.
Vamos usar o menu File. Clique depois em New e a seguir em Application. Se houver
uma aplicação aberta, nesse momento, o Delphi perguntará se você deseja salvar o
projeto. Confirme se for o caso, e uma nova aplicação será iniciada, com um form
pronto para ser desenhado.
A primeira ação a ser feita é salvar nosso projeto para nomear os arquivos. Para
isso vamos usar o comando File | Save All. Esse comando irá salvar os arquivos de unit
e de projeto (DPR). Inicialmente ele pede que seja informado o nome da unit. Tenha o
cuidado de escolher uma pasta para o seu programa e salvar cada nova unit nesta mesma
pasta. Vamos digitar u_exemplo1 e pressionar o botão Salvar. Em seguida ele pede o
nome do projeto. Digite Exemplo1 e pressione o botão Salvar.
Nosso programa será um cadastro de dados pessoais. Os dados a serem
cadastrados são: nome, idade, profissão, escolaridade, sexo e situação cadastral.
Propriedades de Form (TForm)

Antes de inserir qualquer componente no novo form, vamos modificar algumas
de suas propriedades usando o Object Inspector. Lembre que o Object Inspector
mostra propriedades e eventos do componente que estiver selecionado. O quadro abaixo
apresenta as propriedades que serão modificadas, os valores a serem definidos e a
descrição de cada uma. São mostrados também os métodos e eventos mais importantes.
Há muitas outras propriedades, mas essas são as básicas.
Propriedade Conteúdo Descrição

+BorderIcons
biMaximize False Desabilita o botão maximizar
BorderStyle bsSingle Borda simples, tamanho fixo
Caption Exemplo 1 Legenda da barra de títulos
Color clBtnFace Cor padrão de fundo da tela
Height 480 Altura da tela em pixels
Icon HandShak.ico Ícone da barra de títulos da janela
Name frmExemplo1 Identificador da janela
Position poScreenCenter Posiciona a janela no centro da tela
Width 640 Largura da tela em pixels
WindowState wsNormal Abre a tela no tamanho original
Método Descrição
Close Fecha a janela
Show Abre a janela
ShowModal Abre a janela, mas usuário precisa fechá-la
para continuar a aplicação
Evento Descrição
OnActivate Quando a janela recebe o foco
OnClose Quando a janela é fechada
OnCloseQuery Quando a janela é fechada, mas o usuário pode
impedir o seu fechamento
37
OnCreate Quando o form é criado

OnShow Quando a janela é aberta
Quadro 1 Propriedades, métodos e eventos de Form
Para modificar a propriedade biMaximize, clique no sinal de + ao lado de

BorderIcons para expandir suas subpropriedades e defina o novo valor. Para carregar o
ícone da propriedade Icon, clique no botão elipse (aquele com os três pontos) e depois
no botão Load para escolher o ícone em C:\Arquivos de Programas\Arquivos
Comuns\Borland Shared\Images\Icons. Por enquanto não programaremos nenhum
evento.
Utilizando um Botão (TButton)

O Delphi disponibiliza alguns tipos de botão. Vamos selecionar o botão da
paleta Standard e inseri-lo no form recém criado.
Figura 32 Botão recém inserido
Iremos alterar as propriedades do botão que foi inserido. O quadro abaixo mostra
as propriedades e os valores a serem definidos, além de métodos e eventos mais usados.
Note que na propriedade Caption nós inserimos um & (ampersand) antes da
letra F. Este recurso define uma tecla de atalho sublinhada. Desta forma o botão pode
ser pressionado usando apenas o teclado. Simplesmente pressione a letra F e o botão
será pressionado.

Caption &Fechar Legenda do botão
Default False Evento OnClick não é executado se Enter for
pressionado
Enabled True Habilita o botão
Height 25 Altura do botão
ModalResult mrNone Determina se e como o form será fechado
Name btnFechar Identificador do botão
38
Width 75 Largura do botão

Método Descrição
Click Simula um clique de mouse como se o usuário
tivesse pressionado o botão
Evento Descrição
OnClick Quando o usuário clica no botão
OnEnter Quando o botão recebe o foco
Quadro 2 Propriedades, métodos e eventos de Button
Após definirmos as propriedades precisamos escrever o código para que o botão

tenha o comportamento que desejamos. Quando pressionarmos o botão Fechar,
queremos que o form seja fechado. Para definir o comportamento do botão, vamos dar
um duplo clique nele. O editor de código será aberto e vamos digitar o código que
realizará a ação.
Figura 33 Código o evento OnClick de btnFechar
Como desejamos que o form seja fechado quando clicarmos no botão, isso
representa uma ação a ser realizada pelo form. Portanto devemos usar um método que
tenha esse comportamento, por isso escolhemos o método Close, de acordo com o
Quadro 1.
Você pode compilar seu programa e agora ele pode ser fechado usando o botão
padrão no canto superior direito ou o botão btnFechar que foi programado.
Aceitando entrada de dados do Usuário (TEdit)

Já vimos que o usuário pode interagir com uma aplicação usando o mouse, ou o
teclado em vez do mouse para selecionar um botão pressionando a tecla correspondente
à letra sublinhada no Caption.
Além desses casos, o Windows pode manipular entrada do teclado diretamente.
O Delphi provê uma série de controles para construir campos de edição e editores de
texto. Dentre esses vamos utilizar o componente campo de edição (TEdit) da paleta
Standard. Este componente permite que o usuário digite apenas uma linha de texto.
Mais adiante usaremos um componente que possibilita a entrada de mais de uma linha.
Selecione então esse componente e insira-o no form.
Esse primeiro campo de edição que estamos inserindo será utilizado para entrada
do nome da pessoa em nosso cadastro de dados pessoais.
39
Figura 34 Componente TEdit
Da mesma forma que procedemos com os outros componentes iremos alterar

algumas propriedades desse componente. A seguir apresentamos um quadro com
propriedades, eventos e métodos de TEdit.

CharCase ecNormal Não faz nenhum tipo de conversão no que é
digitado. ecUpperCase converte tudo para
maiúsculas
Height 21 Altura da caixa de texto
Name edNome Identificador da caixa de texto
PasswordChar #0 Define qual caractere será usado para ocultar o
texto digitado. #0 não oculta o texto digitado
Text Retorna o que foi digitado pelo usuário. Seu
conteúdo deve ser apagado
Width 400 Largura da caixa de texto
Método Descrição
Clear Limpa o conteúdo de Text
SetFocus Muda o foco para o controle
Evento Descrição
OnChange Quando o texto é modificado
OnEnter Quando o controle recebe o foco
OnExit Quando o foco sai do controle e vai para outro
Quadro 3 Propriedades, métodos e eventos de Edit
Identificando Componentes (TLabel)

Rótulos são apenas texto, ou comentários, escritos em um form. Geralmente o
usuário não interage com rótulos - pelo menos não diretamente. Não faz muito sentido
clicar em um rótulo, embora no Delphi isso seja tecnicamente possível. Nem todo texto
40
que vemos em um form corresponde a um rótulo. O método TextOut de form pode

apresentar um texto.
Usamos rótulos para descrever outros componentes, tais como campos de edição
e caixas de lista ou combo, pois eles não têm título. O Delphi implementa rótulos como
componentes gráficos, não ajanelados.
Vamos então inserir um rótulo no nosso form. Selecione o rótulo na paleta
Standard e insira-o ao lado esquerdo do campo de edição conforme mostrado na figura
seguinte. Altere suas propriedades de acordo com o Quadro 4:
Figura 35 Componente TLabel

Alignment taLeftJustify Texto justificado à esquerda
AutoSize True Define se o controle será automaticamente
redimensionado para acomodar o texto
Caption &Nome Legenda do rótulo
FocusControl edNome Define qual componente receberá o foco
quando for selecionada a tecla de atalho
sublinhada da legenda
Name lblNome Identificador do rótulo
WordWrap False Se AutoSize estiver False, define se o texto
poderá utilizar retorno automático (quebra de
linha) no caso de ultrapassar a largura definida
Evento Descrição
OnClick Quando o usuário clica no rótulo
Quadro 4 Propriedades e eventos de Label
Observe que na legenda do componente, a exemplo da legenda do botão, foi

inserido um & para definir uma tecla de atalho sublinhada. No caso do rótulo quando
pressionamos esta tecla o foco será mudado para o controle definido na propriedade
FocusControl.
41
Fazendo escolhas (TCheckBox, TRadioButton e TRadioGroup)

Há dois controles do Windows que permitem ao usuário escolher diferentes
opções. O primeiro é a caixa de verificação (TCheckBox), que corresponde a uma opção
que pode ser selecionada livremente. O segundo controle é o botão de rádio
(TRadioButton), que corresponde a uma seleção exclusiva. Por exemplo, se você tiver
dois botões de rádio com rótulos A e B, você pode selecionar um dos dois, mas não
ambos ao mesmo tempo. A outra característica é que a escolha de uma das opções é
obrigatória.
Selecione uma caixa de verificação na paleta Standard e insira-o no form.
Usaremos a caixa de verificação para definir a situação cadastral da pessoa - pode
assumir a situação Ativo se a caixa estiver marcada e Não ativo, caso contrário. No
Quadro 5 abaixo podemos ver as propriedades, métodos e eventos de TCheckBox.
Figura 36 Componente TCheckBox

Caption Situação Legenda da caixa de verificação
Checked False Especifica se o controle está marcado
Name chxSituacao Identificador da caixa de verificação
State cbUnchecked Indica se o controle está selecionado, não
selecionado ou parcial
Evento Descrição
OnClick Quando o usuário clica no controle
Quadro 5 Propriedades, métodos e eventos de CheckBox
Vamos inserir um componente para selecionarmos o sexo da pessoa que está

sendo cadastrada. Nesse caso precisamos de um componente que possibilite mais
opções. Usaremos então o grupo de botões de rádio (TRadioGroup). Grupo de botões de
42
rádio permite que sejam inseridos vários botões, cada um com uma opção. Selecione o
grupo de botões de rádio da paleta Standard e o insira no form.
Figura 37 Componente TRadioGroup
Vamos alterar algumas propriedades deste componente. No quadro a seguir são

apresentadas algumas propriedades, métodos e eventos de TRadioGroup.

Caption Sexo Legenda do grupo de botões de rádio
Columns 1 Número de colunas em que as opções do grupo
de botões são apresentadas
Height 90 Altura do controle
ItemIndex 0 Define o item selecionado (primeiro item é 0)
Items Masculino Lista de opções
Feminino
Name rgSexo Identificador do grupo de botões de rádio
Width 185 Largura do grupo de botões de rádio
Método Descrição
Evento Descrição
OnClick Quando o controle é clicado
Quadro 6 Propriedades, métodos e eventos de RadioGroup
Para definir a lista de opções, clique no botão elipse no lado direito da

propriedade Items no Object Inspector. Será aberto o editor de String List. Digite uma
opção em cada linha e confirme pressionando o botão Ok. A propriedade Items é do
tipo TStrings e será utilizada em outros componentes, com o mesmo nome ou não.
43
Uma Lista com muitas escolhas (TListBox)

Se você precisar de muitas opções os botões de rádio não são apropriados, a
menos que você tenha um form realmente grande. Não se deve usar mais que 5 ou 6
botões de rádio. A solução é usar caixas de lista (TListBox). Uma caixa de lista pode
manter um grande número de opções em um pequeno espaço, pois ela tem uma barra de
rolagem para mostrar na tela apenas uma pequena parte da lista completa. Outra
vantagem é que podemos facilmente adicionar ou remover elementos da lista. Caixas de
lista também podem permitir uma única escolha ou múltiplas escolhas.
A caixa de lista usada em nossa aplicação servirá para a definição da profissão
do cadastro de dados pessoais. Selecione a caixa de lista da paleta Standard e o insira
no form conforme a figura mostrada a seguir. Insira um rótulo também.
Figura 38 O Componente ListBox
Vamos alterar algumas propriedades do controle. No quadro abaixo mostramos

algumas propriedades, métodos e eventos de TListBox.

Columns 0 Número de colunas mostradas sem precisar
rolar horizontalmente
Height 80 Altura do controle
ItemIndex 0 Define o item selecionado (primeiro item é 0)
Items Lista de opções
MultiSelect False Define se o usuário pode selecionar mais de
um item
Name lbxProfissao Identificador da caixa de lista
Sorted True Define se os elementos serão ordenados
Width 121 Largura da caixa de lista
Método Descrição
Clear Deleta os itens da caixa de lista
44
Evento Descrição
Quadro 7 Propriedades, métodos e eventos de ListBox
Na propriedade Items insira os seguintes elementos: Carpinteiro, Analista de

Sistemas, Arquiteto, Enfermeiro, Engenheiro, Pedreiro e Professor. No rótulo que foi
inserido defina Name com lblProfissao e Caption com Profissão.
Muitas opções em pouco espaço (TComboBox)

Caixas de lista ocupam muito espaço na tela e suas opções são fixas, não dando
ao usuário a oportunidade de escolher uma opção diferente daquelas previamente
programadas.
Podemos solucionar essas dificuldades usando caixas combinadas
(TComboBox). Uma caixa combinada reúne em um mesmo controle uma caixa de
edição, onde se pode digitar algum texto, e uma caixa de lista que é aberta quando
pressionamos a seta. O próprio nome do controle sugere que ele é a combinação de dois
componentes, um Edit e um ListBox. No entanto, o comportamento do ComboBox pode
mudar, dependendo do valor da propriedade Style. Veremos um pouco mais adiante
como definir corretamente esta propriedade para que o componente tenha o
comportamento desejado.
Vamos usar uma caixa combinada para definir a escolaridade no cadastro de
dados pessoais. Selecione o componente na paleta Standard e o posicione no form
conforme a figura. Coloque um rótulo também para identificar a caixa.
Figura 39 Componente ComboBox
Vamos então modificar algumas propriedades deste componente. No quadro a

seguir são apresentadas algumas de suas propriedades, métodos e eventos. A
propriedade Style pode assumir os seguintes valores:
45
• csDropDown define uma caixa combinada típica que permite edição e

mostra uma caixa de lista para escolha de opção.
• csDropDownList define uma caixa combinada que não permite edição. Se
for pressionada uma letra, o controle mostra a primeira opção que ele
encontra iniciando com essa letra.
• csSimple define um controle que permite edição e sempre mostra a caixa de
lista. A altura da caixa depende da propriedade Height.
Existem outros valores para essa propriedade, mas apenas essas são de nosso
interesse.

ItemIndex Define o item selecionado (primeiro item é 0).
Não pode ser alterado em tempo de
desenvolvimento
Items Lista de opções
Name cbxProfissao Identificador da caixa combinada
Sorted True Define se os elementos serão ordenados
Style csDropDown Define o estilo de apresentação da caixa
Text Retorna o que foi selecionado ou digitado
Método Descrição
Clear Deleta os itens da caixa combinada
Evento Descrição
OnChange Quando o conteúdo do controle é modificado
Quadro 8 Propriedades, métodos e eventos de ComboBox
Na propriedade Items inclua os seguintes elementos: Analfabeto, Fundamental,

Médio, Superior e Pós-graduação. Para o rótulo que foi inserido defina Name como
lblEscolaridade e Caption como Escolaridade.
Escolhendo um valor em um intervalo (TScrollBar)

Vamos explorar agora o controle chamado barra de rolagem (TScrollBar).
Barras de rolagem são normalmente associados com outros componentes, tais como
caixas de lista. Nesses casos a barra de rolagem é parte do componente, uma
propriedade sua.
O uso de barras de rolagem é muito raro, exceto quando a faixa de valores a ser
escolhida é muito grande, pois existe o TTrackBar para intervalos menores. Iremos usar
a barra de rolagem para definir a idade da pessoa no cadastro.
Selecione então uma barra de rolagem na paleta Standard e o insira no form
conforme é mostrado na figura abaixo. Coloque um rótulo para identificar o
componente.
46
Figura 40 Componente ScrollBar
Vejamos as propriedades deste componente que serão modificadas. No quadro

seguinte são apresentadas propriedades, métodos e eventos de ScrollBar.

Kind sbHorizontalEspecifica se o controle será horizontal ou
vertical
LargeChange 10 Especifica quanto Position varia quando o
usuário clica nos lados da barra
Max 100 Especifica a posição máxima
Min 1 Especifica a posição mínima
Name sbIdade Identificador da barra de rolagem
Position 1 Indica a posição atual da barra
SmallChange 1 Especifica quanto Position varia quando o
usuário clica nas setas
Método Descrição
Evento Descrição
OnChange Quando posição da barra é modificada
OnScroll Quando a barra é rolada
Quadro 9 Propriedades, métodos e eventos de ScrollBar
No rótulo que foi inserido, modifique a propriedade Name para lblIdade e a

propriedade Caption para Idade.
Agrupando componentes relacionados (TGroupBox)

TGroupBox é usado para agrupar componentes que se relacionam. Usaremos
este componente para colocar dentro um componente do tipo TMemo. Selecione o
GroupBox na paleta Standard e insira-o no form.
47
Figura 41 Componente GroupBox
Basicamente alteraremos a as propriedades Name e Caption. Defina Name como

gbDados e Caption como Dados Pessoais.
Entrando múltiplas linhas (TMemo)

Vimos antes, que o componente TEdit permite a entrada de uma única linha de
texto. Para possibilitar a entrada de mais de uma linha de texto usaremos o componente
memorando (TMemo). Selecione o componente Memo da paleta Standard e o insira no
form dentro do GroupBox, como mostrado na figura abaixo.
Figura 42 Componente TMemo
48
Usaremos este componente para mostrar todos os dados pessoais cadastrados

quando for pressionado o botão correspondente. Assim, precisamos modificar algumas
propriedades de Memo. No quadro a seguir são apresentadas propriedades, métodos e
eventos de Memo.

Align alClient Determina como o controle se alinha dentro do
seu contêiner
Lines Contém as linhas de texto do controle
Name memDados Identificador do memorando
ReadOnly True Define se o usuário pode editar o texto do
controle
Método Descrição
Clear Deleta as linhas de texto do memorando
Evento Descrição
OnChange Quando o texto no controle é modificado
Quadro 10 Propriedades, métodos e eventos de Memo
O contêiner do controle Memo é o GroupBox. Dessa forma, quando definimos a

propriedade Align como alClient, o memorando se ajusta para caber dentro de seu
controle pai. A propriedade Lines é do tipo TStrings, portanto possui propriedades e
métodos particulares que serão abordados posteriormente. Por enquanto entre no editor
da propriedade Lines e delete a linha existente. Memorandos podem ser usados para
entrada de dados através do teclado, mas no nosso caso ele será usado para receber os
dados programaticamente. Por isso definimos a propriedade ReadOnly como True, para
que o usuário não possa alterar o texto.
Juntando tudo
Insira um novo botão no form. Esse botão, quando pressionado, mostrará os
dados pessoais no campo Memo. Defina a propriedade Caption como Salvar, Default
como True e Name como btnSalvar.
Observe na Figura 43 a seguir como deve ficar o form após a inclusão de um
novo botão. A definição da propriedade Default como True indica que, se o usuário
pressionar a tecla Enter, o evento OnClick será executado.
Agora iremos escrever o código que fará todo o trabalho para nós.
Como vimos no nosso primeiro programa, se queremos que a ação aconteça
quando pressionarmos o botão, então deveremos programar o evento OnClick do botão.
Dê um duplo clique no botão e o editor de código será aberto para inserirmos o código.
Vamos analisar cada linha do código mostrado na Figura 44. Para facilitar a
análise nós numeramos cada linha com um comentário. Iniciaremos pela linha 1. Esta
linha é responsável por deletar as linhas do memorando, conforme descrição do método
Clear no Quadro 10. Dessa forma toda vez que inserirmos os dados de uma nova pessoa
e pressionarmos o botão btnSalvar, os dados anteriores são apagados. Observe que, para
chamar um método de um componente, informamos o nome do componente seguido do
nome do método separados por ponto.
49
A propriedade Lines do componente Memo é um objeto do tipo TStrings,

portanto possui propriedades e métodos. Dos métodos disponíveis de Lines usaremos
Add, para adicionar novas linhas ao texto do controle.
Figura 43 Form com a botão btnSalvar
Na linha 2 do código da Figura 44 o nome da pessoa é adicionada ao texto.

Observe a forma de invocarmos o método Add. Add é um método de Lines, e Lines é
uma propriedade de mmDados. O argumento do método deve ser uma string. Como
argumento usamos um literal, que identifica o dado da linha de texto, concatenado ao
nome da pessoa, que é dado pela propriedade Text do componente edNome. A terceira
linha é semelhante à segunda, não merece maiores comentários.
Figura 44 Código do evento OnClick do botão btnSalvar
A profissão da pessoa é adicionada na linha 4. As profissões estão na

propriedade Items de lbxProfissao. O índice do elemento selecionado no ListBox é dado
pela propriedade ItemIndex. Items pode ser tratado como um vetor indexado por
ItemIndex. Por isso a linha 4 é escrita dessa forma.
Na linha 5 adicionamos a idade da pessoa, definida pela propriedade Position de
ScrollBar. Position é uma propriedade numérica do tipo integer. Antes de concatenar
50
seu valor é necessário convertê-lo para string. Por isso usamos a função IntToStr(), para
converter um número inteiro para string.
A linha 6 pode ser analisada de forma semelhante à linha 4. Portanto não será
necessário acrescentar nenhum comentário a respeito.
No caso da linha 7 e seguintes, é o que se faz necessário para mostrar o sexo da
pessoa. Como a propriedade Checked do componente CheckBox é boolean, usamos isso
para implementar uma estrutura de decisão. Se Checked estiver marcado (True) então
será mostrado sexo masculino, caso contrário será mostrado sexo feminino.
TStrings, sendo uma classe, possui atributos e métodos também. A seguir
mostramos os membros mais usados. Note que a propriedade Items dos componentes
TComboBox e TListBox, assim como Lines, de TMemo, também são do tipo TStrings.

Count Informa quantas linhas existem na lista
Strings Referencia as strings na lista através de sua
posição. Sempre baseada em 0
Text Retorna as strings da lista como uma única
string onde cada linha é finalizada com um
Enter (LF) e um retorno de carro (CR)
Método Descrição
Add Adiciona uma string no final da lista
AddStrings Adiciona um TStrings na lista
Clear Deleta as linhas de texto da lista
Delete Deleta uma linha da lista usando sua posição
IndexOf Procura uma string na lista
Insert Insere uma string em uma posição específica
LoadFromFile Preenche a lista com as linhas de um arquivo
texto
SaveToFile Salva a lista em um arquivo texto
Quadro 11 Propriedades e métodos de TStrings
O Delphi, além da função IntToStr() que usamos no código da Figura 44, tem
outras funções para conversão de dados que são mostradas no quadro a seguir:
Função Descrição
StrToInt(const S: String) Converte um String para Inteiro
IntToStr(value: Integer) Converte um Inteiro para String
StrToFloat(const S: String) Converte um String para Ponto Flutuante
FloatToStr(value: Extended) Converte um Ponto Flutuante para String
DateToStr(date: TDateTime) Converte um TDateTime para String
DateTimeToStr(date: TDateTime) Converte um TDateTime para String
StrToDate(const S: String) Converte um String para TDateTime
StrToDateTime(const S: String) Converte um String para TDateTime
TimeToStr(time: TDateTime) Converte um TDateTime para String
FormatFloat(const format: String; value: Formata um Ponto Flutuante retornando
Extended) um String de acordo com o formato
Quadro 12 Funções de conversão de dados
51
Capítulo 4 Caixas de Diálogo

O Delphi oferece algumas caixas de diálogo pré-definidas que facilitam muito o
desenvolvimento de aplicações.
ShowMessage
Declarada internamente pelo Delphi da seguinte forma:
procedure ShowMessage(const Msg: string);
Onde o argumento é uma string.

Para experimentar a utilização das caixas de diálogo vamos criar uma nova
aplicação. Depois de iniciar a nova aplicação vamos modificar Name do form para
frmDialogos, e Caption para Diálogos. Depois vamos salvá-la. Vamos dar à unit o
nome de u_dialogos e ao projeto o nome Dialogos.
Insira um botão, dê a ele o nome de btnMensagem1 e em Caption coloque
ShowMessage. Aumente a largura do botão, deixando a propriedade Width com o valor
100. Agora dê um duplo clique no botão e quando abrir o editor de código escreva:
ShowMessage('Este texto será mostrado');
Execute a aplicação e pressione o botão. A caixa de diálogo será mostrada:
Figura 45 Caixa de diálogo ShowMessage
Essa é a caixa mais simples. Sua barra de título sempre mostra o nome do
projeto e apresenta apenas o botão OK.
MessageDlg
ShowMessage apenas mostra uma mensagem, não permite interação com o
usuário. MessageDlg permite vários tipos de diálogos e oferece recurso de resposta do
usuário. Essa caixa de diálogo é declarada pelo Delphi da seguinte forma:
function MessageDlg(const Msg: string; DlgType:

TMsgDlgType; Buttons: TMsgDlgButtons; HelpCtx: Longint):
Word;
Onde:
const Msg: string é uma constante ou variável do tipo string que contém a
mensagem que será mostrada na caixa de diálogo.
DlgType: TMsgDlgType são ícones que indicam o tipo da caixa de diálogo.
Pode ser mtWarning (ícone 'exclamação' amarelo), mtError (ícone 'pare' vermelho),
52
mtInformation (ícone 'i' azul), mtConfirmation (ícone 'interrogação' verde) e mtCustom

(não tem ícone).
Buttons: TMsgDlgButtons é um array de botões que aparecem na caixa. Pode
ser mbYes, mbNo, mbOk, mbCancel, mbAbort, mbRetry, mbIgnore, mbAll,
mbNotToAll, mbYesToAll e mbHelp.
HelpCtx: Longint define o número do help de contexto. Por padrão é 0.
O retorno da função é a informação do botão pressionado pelo usuário. Assim,

apenas troque mb por mr nos nomes dos botões, para verificar o botão que foi clicado.
Os possíveis valores de retorno são mrYes, mrNo, mrOk, mrCancel, mrAbrot, mrRetry,
mrIgnore, mrAll, mrNotToAll, mrYesToAll e mrHelp. Vamos então programar o
evento OnCloseQuery do form da nossa aplicação Dialogos. Esse evento acontece
quando a janela é fechada, mas dá ao usuário a chance de confirmar ou não o
fechamento. Selecione o evento na aba Events do ObjectInpector, dê um duplo clique
na sua direita para abrir o editor de código e digite o seguinte código
if MessageDlg('Deseja sair?', mtConfirmation, [mbYes,

mbNo], 0) = mrNo then
CanClose := False;
CanClose é uma variável boolean, declarada pelo método que estamos

programando. Seu valor padrão é True, e neste caso a janela é fechada. Se quisermos
impedir seu fechamento mudamos a variável para False. Execute o programa e clique o
botão para fechar a janela. A seguinte caixa será mostrada:
Figura 46 Caixa de diálogo MessageDlg
Se você pressionar o botão Yes a janela será fechada. Observe que na barra título
apareceu o texto Confirm e os textos dos botões estão em inglês também. Realmente
não podemos modificar isso, pois faz parte da API (Interface de Programação de
Aplicativos) do Delphi, que é toda em inglês. Logo veremos como resolver esse
problema.
Application.MessageBox
Esta caixa de diálogo é a mais completa do ambiente Delphi e a que apresenta
maior flexibilidade para o programador. Ela encapsula a função MessageBox da API do
Windows e está definida da seguinte forma:
function MessageBox(const Text, Caption: PChar; Flags:

Longint): Integer;
Onde:
53
const Text é uma constante ou variável do tipo PChar que contém o texto da
mensagem. PChar é um ponteiro para uma string.
Caption: PChar define um título para a janela. É do tipo PChar.
Flags: Longint define botões, ícones e a possibilidade de focar um determinado
botão. Os valores de botão são MB_ABORTRETRYIGNORE, MB_OK,
MB_OKCANCEL, MB_RETRYCANCEL, MB_YESNO e MB_YESNOCANCEL. Os
ícones podem ser MB_ICONEXCLAMATION, MB_ICONWARNING,
MB_ICONINFORMATION, MB_ICONASTERISK, MB_ICONQUESTION,
MB_ICONSTOP, MB_ICONERROR e MB_ICONHAND. Os valores para definição
de botão default são MB_DEFBUTTON1, MB_DEFBUTTON2, MB_DEFBUTTON3
e MB_DEFBUTTON4.
O retorno da função é o botão que foi pressionado. Os possíveis valores de

retorno são IDABORT, IDCANCEL, IDIGNORE, IDNO, IDOK, IDRETRY e IDYES.
Insira um novo botão no form do projeto Dialogos. Na propriedade Name
informe btnMensagem2, na propriedade Caption defina MessageBox. Altere a
propriedade Width para 100. Dê um duplo clique no botão para programar o evento
OnClick de btnMensagem2. No editor de código digite então o seguinte:
if Application.MessageBox('Deseja salvar o arquivo?',

'Confirmação', MB_YESNOCANCEL + MB_ICONQUESTION +
MB_DEFBUTTON2) = idYes then
ShowMessage('Você pressionou o botão SIM');
Este não é um código muito funcional, apenas exemplifica a utilização de

MessageBox. Observe como são informados os botões, o ícone e o botão default. Como
definimos que MB_DEFBUTTON2 é o botão default, então o default será o botão Não.
Execute o programa e pressione o botão MessageBox. A caixa irá parecer com a figura.
Note também que os textos dos botões estão em português, e que podemos definir o
texto da barra de título da caixa.
Figura 47 Caixa de diálogo MessageBox com botões de opções
Tanto MessageDlg quanto MessageBox podem ser usadas apenas para apresentar
informações ao usuário, sem necessidade de checar o botão pressionado. Por exemplo,
se for inserido o código abaixo no evento OnClick do botão btnMensagem2:
Application.MessageBox('Arquivo não pode ser salvo',

'Informação', MB_OK + MB_ICONEXCLAMATION);
A seguinte caixa de diálogo será mostrada.

Note que apresentamos apenas o botão Ok. Sendo uma informação sobre uma
ocorrência, podendo ser inclusive uma mensagem de erro, não precisamos verificar o
botão pressionado pelo usuário.
54
Figura 48 MessageBox para informações ao usuário
Note que apresentamos apenas o botão Ok. Sendo uma informação sobre uma
ocorrência, podendo ser inclusive uma mensagem de erro, não precisamos verificar o
botão pressionado pelo usuário.
Em certas situações pode ser que o programador deseje construir caixas de
diálogo dinâmicas, ou seja, onde as mensagens de texto dependem de determinadas
condições durante a execução do programa. Nesses casos deve-se observar que os
argumentos de MessageBox não são do tipo string e sim PChar. Analisemos o código a
seguir:
var
Msg: string;
begin
Msg := 'Arquivo não pode ser salvo';
Application.MessageBox(PChar(Msg), 'Informação',
MB_OK + MB_ICONEXCLAMATION);
end;
Para podermos usar uma string como argumento de MessageBox é necessário

convertermos para PChar. Por isso usamos a chamada à função PChar().
InputBox
O ambiente Delphi oferece também caixas de diálogo para entrada de dados do
usuário. Uma dessas caixas é InputBox, que retorna um tipo string com o texto digitado
pelo usuário. A definição interna dessa função é:
function InputBox(const ACaption, APrompt, ADefault:

string): string;
Onde:
const ACaption define o título da janela.
APrompt define a orientação ao usuário dentro da caixa.
ADefault define um valor default para a caixa. Será retornado se o usuário
pressionar a tecla Cancel.
Para exemplificar o funcionamento dessa caixa de entrada vamos inserir um

botão no form do programa Dialogos. Na propriedade Name digite btnEntrada1, em
Caption escreva InputBox. Altere a largura do botão modificando a propriedade Width
para 100. Para programarmos o evento OnClick do botão dê um duplo clique nele. No
editor de código faça as alterações para que o procedimento do evento fique assim:
55
var
Cidade: string;
begin
Cidade := InputBox('Entrada', 'Digite o nome da
cidade', 'Santarém');
end;
Execute o programa e clique no botão InputBox. A seguinte caixa de diálogo

será mostrada na tela:
Figura 49 Caixa de diálogo InputBox
Se você clicar no botão Cancel, a função retornará o texto default, no nosso

caso, Santarém. Ou podemos digitar uma nova cidade no campo e pressionar OK.
InputQuery
InputQuery retorna um tipo boolean, o texto digitado pelo usuário será atribuído
a uma variável string previamente declarada. A função retornará True se o usuário
pressionar OK ou retornará False, caso o usuário pressione o botão Cancel.
Internamente a função é assim definida:
function InputQuery(const A Caption, APrompt: string;

var Value: string): Boolean;
Os parâmetros são semelhantes aos de InputBox, no entanto Value deve ser

declarada e inicializada antes, pois é passada por referência à função e retorna o texto
digitado pelo usuário.
Para exemplificar o funcionamento da função InputBox vamos inserir um novo
botão e um rótulo na nossa aplicação Dialogos. Na propriedade Name do botão informe
btnEntrada2, na propriedade Caption informe InputQuery e na propriedade Width
modifique o valor para 100. No rótulo defina Name como lblCidade e Caption como
Santarém. Clique no sinal de mais (+) ao lado de Font. Defina Size como 16. O form
deve ficar com aparência semelhante à da Figura 50 a seguir.
Queremos que o usuário digite o nome de uma cidade e que esse nome seja
mostrado no rótulo lblCidade, apenas se for pressionado o botão OK. Para programar o
evento OnClick desse botão dê um duplo clique nele e digite o seguinte código no
editor:
var
Cidade: string;
begin
Cidade := 'Santarém';
if InputQuery('Cidade', 'Digite o nome da cidade',
56
Cidade) then
lblCidade.Caption := Cidade;
end;
Figura 50 Aplicação Dialogos com um novo botão e rótulo
Execute o programa e clique no botão InputQuery. Digite o nome de uma cidade

e pressione OK. O nome digitado será mostrado no rótulo.
Botão com ícone (TBitBtn)

Para finalizar nosso programa Dialogos, vamos inserir um botão para fechar a
janela. Mas vamos usar um botão diferente. Selecione a aba de componentes
Additional. Selecione o botão BitBtn e o insira no form.
BitBtn é um botão que, além de um Caption, aceita também um ícone e possui
alguns comportamentos pré-definidos. Você pode adicionar botões tais como OK,
Cancel, Close, etc. sem necessidade de escrever nenhum código. Vamos descrever
algumas propriedades de BitBtn.

Caption &Fechar Legenda do botão
Default False Evento OnClick não é executado se Enter for
pressionado
Enabled True Habilita o botão
Glyph Define um ícone para o botão
Kind bkClose Seleciona o tipo do botão e seu comportamento
Name btnFechar Identificador do botão
Quadro 13 Propriedades de BitBtn
Demais propriedades, métodos e eventos são os mesmos de TButton. Observe

que alteramos a propriedade Caption para Fechar. Quando você escolhe o tipo em Kind,
57
o Delphi atribui a Caption um texto com o mesmo nome do tipo. Podemos alterá-lo sem
com isso mudar seu comportamento. No entanto não podemos alterar o ícone, pois isso
implicaria na mudança de Kind para bkCustom, que significa um botão onde o
programador define seu comportamento e seria necessário inserir código para isso. Note
que não inserimos código para o evento OnClick, mas se executarmos o programa e
pressionarmos o botão Fechar a janela será fechada.
58
Capítulo 5 Criando Menus

As aplicações que criamos até o momento não possuem um dos elementos de
interface mais importantes de uma aplicação Windows: a barra de menus. Mesmo
nossas aplicações tendo um menu de sistema (aquele do canto superior esquerdo),
muitas tarefas são acessadas através de comandos de menu.
Uma aplicação possui vários menus que podem inclusive mudar em tempo de
execução e vários menus locais (normalmente acessados através de um clique no botão
direito do mouse).
Os componentes para criar menus estão localizados na aba Standard da paleta
de Componentes.
Estrutura do Menu Principal

Geralmente os menus têm dois níveis. Uma barra de menu, abaixo do título da
janela, contém os nomes dos sub-menus (pull-down), que por sua vez têm uma série de
itens. No entanto a estrutura de menu é muito flexível. É possível colocar um item de
menu diretamente na barra de menu e colocar um sub-menu de segundo nível dentro de
outro sub-menu.
Você deve evitar colocar comandos diretamente na barra de menu. Isso não é
muito comum. Se realmente isso for necessário, acrescente um menu com um único
item de menu. Um exemplo típico é o menu Ajuda com o item Sobre.
Colocar sub-menus dentro de outro sub-menu - um sub-menu de segundo nível -
é mais comum, e neste caso o Windows oferece uma indicação visual, um pequeno
triângulo à direita do menu. De qualquer maneira, menus de segundo nível podem se
tornar o uso do programa uma coisa chata. Pense na possibilidade de agrupar as opções
separando os grupos por barras separadoras. Veja a figura.
Figura 51 Menu com opções agrupadas e sub-menu
59
Diferentes funções dos itens de menu

Há três tipos fundamentais de itens de menu:
• Comandos são itens de menu usados para executar uma ação. Não têm
indicação visual de sua função.
• Modificadores de estado são itens usados para alternar uma opção entre
ligado e desligado, para mudar o estado de um elemento particular. Esses
comandos geralmente possuem uma marca no lado esquerdo para indicar que
estão ativos. Neste caso, selecionar a opção produz a ação oposta.
• Diálogo são itens que invocam uma caixa de diálogo quando são
selecionados. Isso inclui qualquer janela onde o usuário precise interagir.
Estes comandos deveriam ter uma indicação visual que consiste de três
pontos após o texto.
Aplicação Exemplo
Para exemplificarmos a construção de menus vamos criar uma nova aplicação.
Defina a propriedade Name do form como frmMenus, o Caption como Menus e salve
tudo atribuindo à unit o nome u_menus e ao projeto o nome Menus.
Selecione um rótulo na aba Standard e insira-o no form. Defina a propriedade
Name como lblTexto. Na propriedade Align selecione alClient. Escreva algum texto
bastante longo na propriedade Caption. Mude a propriedade WordWrap para True, para
ter várias linhas de texto. Mude AutoSize para False para permitir o redimensionamento
do rótulo. Clique no sinal de mais (+) ao lado da propriedade Font e altere Name para
Arial e Size para 38.
Selecione um componente TPanel na aba Standard e o insira no form. Panel é
usado para agrupar outros controles. Muito usado para criar barras de ferramentas.
Exatamente isso que vamos implementar na nossa aplicação. Mude a propriedade Name
para panBarra, e delete o texto da propriedade Caption. Defina sua propriedade Align
como alTop.
Figura 52 Aplicação Menus
60
Insira cinco botões (TButton) e os posicione adequadamente no Panel. No

primeiro defina Name como btnFonte e Caption como Cor &Texto... No segundo defina
Name como btnFundo e Caption como Cor &Fundo... No terceiro defina Name como
btnEsquerda e Caption como &Esquerda. No quarto defina Name como btnCentro e
Caption como &Centro. No último defina Name como btnDireita e Caption como
&Direita. A janela deve ficar como a Figura 52.
Os três últimos botões mudam o alinhamento (Alignment) do rótulo. Então
vamos escrever o código para os eventos OnClick desses botões. Dê um duplo clique
em cada um deles. Para btnEsquerda digite no editor de código:
lblTexto.Alignment := taLeftJustify;
Para btnCentro digite:
lblTexto.Alignment := taCenter;
E para btnDireita digite:
lblTexto.Alignment := taRightJustify;
Você pode verificar a funcionalidade dos botões executando a aplicação e

pressionando cada um deles e observando seus efeitos sobre o texto do rótulo.
A Caixa de Diálogo ColorDialog

Vamos inserir na nossa aplicação um componente denominado ColorDialog.
Esse componente serve para apresentar a caixa de diálogo para seleção de cores padrão
do ambiente Windows. Localize-o na aba Dialogs. Pode ser colocado em qualquer lugar
da janela, pois não é um componente visual, ou seja, não será visível quando o
programa for executado. Será invocado em tempo de execução pelos dois primeiros
botões, por isso eles têm os três pontos no Caption, para indicar a chamada a uma caixa
de diálogo. Vamos mudar a propriedade Name do componente. Defina-a como
dlgCores.
Queremos que, quando pressionados, os dois primeiros botões chamem a caixa
de diálogo dlgCores. Nessa caixa selecionamos a cor desejada e quando pressionarmos
o botão OK, a cor será atribuída à propriedade Color do rótulo ou à propriedade Color
de Font.
Dê um duplo clique no botão btnFonte e digite o seguinte código no editor:
dlgCores.Color := lblTexto.Font.Color;
if dlgCores.Execute then
lblTexto.Font.Color := dlgCores.Color;
Na primeira linha fazemos com que a caixa de diálogo seja mostrada com a cor
do texto. Depois executamos a caixa de diálogo e, se o usuário pressionar o botão OK, a
cor do texto do rótulo é modificada. O método Execute de ColorDialog retorna True se
for pressionado o botão OK ou False se for pressionado o botão Cancel. Vamos fazer o
mesmo com o botão btnFundo e digitar o seguinte código no editor:
dlgCores.Color := lblTexto.Color;
lblTexto.Color := dlgCores.Color;
61
Execute o programa e clique no botão btnFonte. Você terá a caixa de diálogo de

cores como na figura:
Figura 53 A caixa ColorDialog
Criando um Menu com o Menu Designer

Vamos criar um menu com a seguinte estrutura:
Arquivo
Sair
Exibir
Barra de ferramentas
Opções
Cor do texto
Cor do fundo
Esquerda
Centro
Direita
Ajuda
Sobre
O Delphi possui um editor de menus chamado Menu Designer. Para utilizá-la

precisamos de um componente TMainMenu. Selecione esse componente na aba
Standard e o insira no form em qualquer posição. O Delphi se encarrega de posicionar
o menu no lugar correto, abaixo da barra de título.
O MenuDesigner é uma ferramenta poderosa: você cria um menu simplesmente
escrevendo o texto dos comandos, para mover os itens simplesmente os arraste e as
propriedades podem ser modificadas facilmente.
Para comprovar isso vamos dar um duplo clique no componente MainMenu. A
janela do Menu Designer será mostrada, selecionando a primeira opção de menu. Digite
62
&Arquivo na propriedade Caption e tecle Enter. O Menu Designer define a primeira

opção, inicia o sub-menu abaixo de &Arquivo e prepara a criação de uma nova opção de
menu, conforme pode ver visto na figura:
Novo menu
Sub-menu
Figura 54 Menu Designer
Estando o sub-menu selecionado digite Sai&r na propriedade Caption. Clique no

retângulo identificado como novo menu, digite E&xibir na propriedade Caption e tecle
Enter. No sub-menu abaixo de Exibir digite Barra de &ferramentas na propriedade
Caption e na propriedade Checked desse item defina True. No próximo menu digite
&Opções na propriedade Caption. No sub-menu digite Cor do &texto... no Caption
primeiro item e Cor de &fundo... no segundo item. No terceiro item digite um hífen (-).
Isso cria um separador no sub-menu. No quarto item digite &Esquerda, no quinto item
digite &Centro e no último digite &Direita. Finalmente no último menu digite Aj&uda
na propriedade Caption e no sub-menu digite &Sobre...
Figura 55 Aspecto do menu criado
63
Teclas de atalho e hotkeys

Uma característica dos itens de menu é que eles podem conter uma letra
sublinhada, chamada hotkey. Esta letra é usada para selecionar o menu usando o
teclado. Pressionando ALT mais a letra sublinhada seleciona-se o menu. Pressionando
outra letra sublinhada envia-se o comando. As letras sublinhadas de cada item dentro de
um sub-menu devem ser diferentes. Observe que durante a criação do nosso menu,
definimos as letras sublinhadas inserindo um & antes da letra.
Outra característica padrão dos menus são as teclas de atalho. Quando aparece
uma combinação de teclas no lado direito do item de menu, significa que você pode
usar essa combinação para executar o comando. Essa característica oferece a maneira
mais rápida de executar um comando.
Para associar teclas de atalho a um item de menu é muito fácil. Ainda no Menu
Designer simplesmente escolha uma combinação de teclas na propriedade ShortCut do
item. Vamos fazer isso para as opções: Esquerda, Centro e Direita. Selecione a opção
Esquerda e na propriedade ShortCut selecione a combinação CTRL + E. Para a opção
Centro selecione CTRL + C e para a opção Direita selecione CTRL + D. Veja a figura
abaixo:
Figura 56 Menu com teclas de atalho
Respondendo aos comandos do menu

Para responder aos comandos de menu, você deveria definir um método para o
evento OnClick de cada item de menu. No Menu Designer, selecione o item de menu
Sair. Selecione a aba Events do Object Inspector e dê um duplo clique no evento
OnClick. Queremos que janela seja fechada quando o usuário selecionar este comando.
Portanto, quando abrir o editor de código digite o comando:
Close;
O comando Exibir | Barra de ferramentas tem uma marca de verificação, fica

marcada quando a barra de ferramentas está visível. Aqui está o código para o evento
OnClick desse comando:
panBarra.Visible := not panBarra.Visible;

Barradeferramentas1.Checked := panBarra.Visible;
64
A primeira linha muda a visibilidade da barra de ferramentas que foi criada pelo
componente Panel. A segunda linha marca/desmarca o item de menu de acordo com a
visibilidade do painel.
No comando Opções | Cor do texto digite o seguinte código para o evento
OnClick:
dlgCores.Color := lblTexto.Font.Color;
lblTexto.Font.Color := dlgCores.Color;
Note que este código é exatamente o mesmo programado para o evento OnClick
do botão btnFonte. Na verdade não precisamos replicar esse código aqui, mas vamos
manter dessa forma por questões didáticas. Mostraremos como reutilizar o código do
evento de um componente em outro. Observe que o código do comando Opções | Cor
de fundo é o mesmo do evento OnClick do botão btnFundo. Então selecione esta opção
no Menu Designer e vá para a aba Events no Object Inspector. Clique no botão com a
seta do evento OnClick para ver todos os eventos disponíveis. Selecione btnFundoClick.
Pronto, agora o comando do menu chamará o mesmo código do evento OnClick do
botão btnFundo.
Os outros três itens do menu Opções têm basicamente o mesmo código dos
botões de alinhamento. No entanto devemos acrescentar uma marca de verificação ao
lado do item que estiver habilitado, desmarcando os demais. Inicialmente, no Menu
Designer, selecione Opções | Esquerda e altere a propriedade Checked para True. Essa
é a nossa situação padrão. Sempre que a aplicação iniciar o texto estará alinhado à
esquerda. Em seguida vamos escrever o código para o comando em questão. Selecione
o evento OnClick do item de menu e dê um duplo clique nele. Digite então o seguinte
código:
Esquerda1.Checked := True;
Centro1.Checked := False;
Direita1.Checked := False;
Este código, além de definir o alinhamento à esquerda do texto, marca e

desmarca adequadamente as opções do menu. Vamos agora codificar o evento OnClick
de Opções | Centro. Digite o seguinte código:
lblTexto.Alignment := taCenter;
Esquerda1.Checked := False;
Centro1.Checked := True;
Em Opções | Direita digite o seguinte código:
lblTexto.Alignment := taRightJustify;
Esquerda1.Checked := False;
Direita1.Checked := True;
65
Chamadas a forms
Com certeza suas aplicações sempre terão muitos forms. Existe um form
principal (main) que faz chamadas a outros forms. A maneira de chamarmos forms será
estudada agora. Vamos criar um novo form na nossa aplicação. Esta janela será nosso
Sobre (About). O Delphi já possui um modelo para esse form. Execute o comando File |
New | Others. Clique na aba Forms, selecione o ícone AboutBox e confirme
pressionando OK. Um form Sobre será incluído no projeto. Selecione esse form e, no
Object Inspector, altere a propriedade Caption para Sobre, e a propriedade Name para
frmSobre. Salve a unit e dê a ela o nome u_sobre.
Na interface desse form existem quatro rótulos, um componente TImage e um
botão. Vamos deixar Image como está, mas é possível escolher outra imagem para o
componente simplesmente clicando no botão elipse da propriedade Picture e
selecionando a imagem desejada. O botão também não precisa ser modificado. Note que
a propriedade ModalResult do botão está definida como mrOk. Isso indica que, quando
a janela é fechada, esse valor é retornado ao form que fez a chamada a frmSobre.
Nenhum código é necessário para o evento OnClick do botão.
No rótulo ProductName altere Caption para Menus. Em Version altere Caption
para Versão 1.0. Em Copyright altere Caption para Copyright: seu nome. Em Comments
altere Caption para Comentários: contatos pelo e-mail seu email. Estas são apenas
sugestões, programe os rótulos com as informações que você desejar.
Queremos chamar frmSobre quando o usuário selecionar o comando Ajuda |
Sobre. No entanto, apesar de frmSobre fazer parte do nosso projeto, frmMenus não sabe
da sua existência. É necessário dizermos a frmMenus que frmSobre existe. Para fazer
isso precisamos dizer a frmMenu que use a unit u_sobre, correspondente a frmSobre.
Logo abaixo da palavra implementation escreva o seguinte código:
uses u_sobre;
Isso habilita frmMenus acessar qualquer objeto de frmSobre e o próprio form. Há

duas maneiras de fazermos chamadas a um form:
• Modal - o foco fica preso ao form e não é liberado até que este seja fechado.
O usuário pode ativar qualquer outra aplicação Windows, mas não pode
ativar outra janela da aplicação cuja janela foi aberta como modal. Para
ativar esse modo chame o form usando o método ShowModal.
• Não modal - o foco pode ser transferido para outra janela sem que esta
precise ser fechada. Para ativar esse modo chame o form usando o método
Show.
Agora selecione o evento OnClick do comando Ajuda | Sobre e digite o

seguinte código:
frmSobre.ShowModal;
Execute o programa e clique no comando Ajuda | Sobre. A aparência da

aplicação deve ser como a Figura 57.
Em tempo de desenvolvimento gerenciar muitos forms pode ser muito
trabalhoso, pois apenas um deles pode estar ativo a cada instante. Para selecionar um
form a ser modificado, selecione o comando View | Forms, pressione o botão
correspondente na barra de ferramentas ou use as teclas de atalho SHIFT + F12. Para
66
selecionar uma unit, selecione o comando View | Units, pressione o botão

correspondente na barra de ferramentas ou use as teclas de atalho CRTL + F12.
Figura 57 A janela Sobre
Menus locais (Pop-up)

Nas aplicações Windows é comum haver menus locais ativados com um clique
no botão direito do mouse. O menu que é mostrado geralmente depende do local onde o
mouse é clicado. Esses menus agrupam opções relacionadas com o elemento da
interface que está selecionado. São mais rápidos que o menu estudado anteriormente
porque não necessita que o mouse seja movimentado para ativá-lo.
No Delphi há duas maneiras de tratar menus locais. Podemos deixar o Delphi
manipulá-los automaticamente ou escolher a técnica manual. Vamos apresentar aqui
apenas o menu local automático.
Para adicionar um menu local a um form, selecione o componente TPopupMenu
na aba Standard e o insira no form em qualquer posição. Altere a propriedade Name
para mlAlinhamento. Dê um duplo clique no componente para abrir o Menu Designer.
Insira as opções: Esquerda, Centro e Direita. Na opção Esquerda mude a propriedade
Checked para True. Ou seja, queremos um menu local com as mesmas opções referentes
ao alinhamento do texto do rótulo do MainMenu que criamos. Portanto vamos fazer
algumas modificações nos métodos para reutilizar o código. No método do evento
OnClick do item de menu Esquerda vamos incluir código para marcar e desmarcar as
opções do menu local:
67
Depois selecione a opção Esquerda no menu local, vá para a aba Events do

Object Inspector, clique no botão do evento OnClick e selecione o método
Esquerda1Click. Agora quando executarmos o comando Esquerda no menu local
estaremos executando o mesmo método do evento OnClick do comando Opções |
Esquerda. E o código marcará/desmarcará opções nos dois menus. Vamos repetir o
procedimento para as opções Centro e Direita.
Selecione o rótulo lblTexto e na propriedade PopupMenu selecione
mlAlinhamento. Esta é a maneira de associar o menu local a um componente. Execute o
programa, clique com o botão direito do mouse no rótulo, selecione uma das três opções
de alinhamento do texto e verifique que a opção escolhida fica marcada nos dois menus.
Figura 58 O componente PopupMenu
68
Capítulo 6 Barras de ferramentas e de status

Barra de ferramentas (TToolBar)
A barra de ferramentas (ToolBar) é um componente com botões próprios e
recursos personalizados. Os botões são do tipo TToolButton, considerados objetos
internos de ToolBar.
Para exemplificar sua utilização vamos substituir o painel de botões do programa
Menus por um componente ToolBar. Para isso selecione o componente panBarra e
pressione o a tecla DEL. Assim o painel e todos os botões inseridos nele são deletados.
Note que os métodos definidos para os botões não foram excluídos, porque existe
código do programador neles.
Agora selecione o componente ToolBar na aba Win32 e o insira em qualquer
posição do form. O componente alinha-se automaticamente no topo do form, abaixo da
barra de menu. Algumas propriedades desse componente são apresentadas no quadro a
seguir:

+EdgeBorders
ebLeft False Define bordas para a barra de ferramentas. Nesse
ebTop True caso, definimos que haverá bordas no topo e na
ebRight False base
ebBottom True
EdgeInner esRaised Define o formato interno da borda
EdgeOuter esLowered Define o formato externo da borda
Flat True Torna a ToolBar transparente e deixa os botões
sem bordas
Images Permite definir um objeto ImageList que contém
as imagens para os botões
Name tbBarra Identificador da barra de ferramentas
Quadro 14 Propriedades de ToolBar
Altere as propriedades do componente de acordo com a tabela. Experimente

vários formatos de borda e deixe-os da maneira que você achar mais adequada.
Vamos inserir os botões. Para isso clique com o botão direito do mouse no
componente ToolBar e selecione a opção New Button. Inclua dois botões. Ao primeiro
dê o nome de tbuFonte e ao segundo dê o nome de tbuFundo. Agora insira um
separador clicando com o botão direito do mouse e selecionando New Separator. Insira
três botões em seguida e dê a eles os nomes: tbuEsquerda, tbuCentro e tbuDireita.
Os botões que compõem barras de ferramentas possuem imagens e não captions.
Portanto vamos inserir imagens nos nossos botões. Selecione o componente TImageList
da aba Win32 e o coloque no form em qualquer posição. Dê um duplo clique no
ImageList e pressione o botão Add. Selecione um ícone para cada botão. Depois de
escolher imagens para os botões clique na barra de ferramentas e na propriedade Images
selecione ImageList1. Cada uma das imagens escolhidas será inserida em um botão
conforme mostra a Figura 59.
69
Figura 59 Barra de ferramentas
Vamos reutilizar os métodos programados para os eventos OnClick dos botões

que foram excluídos. Selecione o primeiro botão da barra de ferramenta, tbuTexto.
Selecione a aba Events do Object Inspector e no evento OnClick selecione o método
btnFonteClick pressionando o botão ao lado direito do nome do evento. Para o botão
tbuFundo selecione o método tbuFundoClick. Execute a aplicação e clique nos dois
botões da barra de ferramentas. Os dois devem chamar a caixa de dialogo de cores.
Iremos repetir o procedimento para os outros três botões da nossa barra de
ferramentas. Mas, em vez de usar os métodos dos botões anteriormente excluídos,
vamos usar os métodos dos comandos de menu. Assim, para o botão tbuEsquerda
vamos selecionar o método Esquerda1Click. Para o botão tbuCentro selecione o método
Centro1Click. E para o botão tbuDireita selecione o método Direita1Click. Vamos
excluir os métodos criados para os botões btnEsquerda, btnCentro e btnDireita. Para
isso acesse o código de cada método no editor e exclua apenas a linha que você digitou.
Quando o programa for compilado, os métodos e todas as referências a eles serão
eliminadas. O procedimento adotado para programar os eventos OnClick dos botões se
deveu apenas ao reaproveitamento do código que já existia para os botões anteriores.
Mas se precisarmos escrever um método novo procedemos da maneira já exposta
anteriormente. Um duplo clique no botão e o editor é aberto na posição onde o código
deve ser inserido.
Como os eventos OnClick dos botões foram programados para responder aos
mesmos eventos dos comandos de menu, pressionar o botão tem o mesmo efeito de
selecionar o comando. Só precisamos de uma indicação visual da opção de alinhamento
que está selecionada no momento.Vamos configurar os botões de alinhamento para que
eles operem como botões de rádio.
É necessário formar um grupo com os botões que serão tratados como botões de
rádio. Altere a propriedade Grouped dos três botões de alinhamento para True.
Modifique a propriedade Style dos botões para tbsCheck. Definimos que o alinhamento
à esquerda é o padrão, portanto vamos alterar a propriedade Down de tbuEsquerda para
True. Execute o programa e clique nos botões para ver os efeitos.
70
Note que ao pressionarmos um botão de alinhamento do texto ele permanece

pressionado até que selecionemos outro. Mas quando selecionamos o alinhamento do
texto a partir de um comando de menu o comportamento dos botões não se alteram.
Para solucionar esse problema vamos incluir um comando no método que força
o pressionamento do botão. Inclua então a seguinte linha no método Esquerda1Click:
tbuEsquerda.Down := True;
Faça o mesmo nos métodos Centro1Click e Direita1Click para os botões

tbuCentro e tbuDireita.
Para finalizar, vamos modificar o código do método correspondente ao comando
Exibir | Barra de ferramentas. Altere para o seguinte código:
tbBarra.Visible := not tbBarra.Visible;

Barradeferramentas1.Checked := tbBarra.Visible;
Observe que apenas mudamos o nome do painel panBarra para tbBarra, o

componente ToolBar, no código do método.
Barra de status (TStatusBar)

A barra de status é usada para apresentar inúmeras informações ao usuário. Pode
mostrar mensagens, a data e hora atuais, dicas, etc. O Delphi possui um componente
para essa finalidade. Na paleta de componentes vá até a aba Win32, selecione o
componente TStatusBar e o insira na nossa aplicação Menus. Não importa onde você
insere o StatusBar, o Delphi sempre o posiciona na base da janela. Iremos modificar
algumas propriedades da barra de status de acordo com o quadro abaixo:

Name stbMenu Identificador da barra de status
Panels Define os painéis que constituem o componente
SimpleText Define um texto que aparecerá na barra de status
Quadro 15 Propriedades de StatusBar
Uma barra de status pode ter vários painéis que agrupam informações
relacionadas. Vamos dividir esta barra em dois painéis. Clique no botão elipse ao lado
direito da propriedade Panels. Isso irá abrir o editor de painéis. Adicione dois painéis
pressionando o botão Add New na parte superior do editor ou teclando Ins.
O Delphi guarda as informações sobre os painéis do StatusBar em um array. O
primeiro painel é chamado stbMenu.Panels[0] e o segundo stbMenu.Panels[1]. Lembre
que o Delphi sempre considera os índices dos arrays iniciando em 0. Cada painel é um
objeto do tipo TStatusPanel. Portanto possui propriedades. Altere as propriedades de
stbMenu.Panels[0] conforme o quadro:

Alignment taLeftJustify Define o alinhamento do texto mostrado
Style psText Define como o texto é mostrado no painel
Text Desenvolvido por João Define o texto que irá aparecer no painel
da Silva
Width 400 Define a largura do painel
Quadro 16 Propriedades de TStatusPanel
71
Para alterar as propriedades de um painel, abra o editor de painéis dando um

duplo clique na barra de status e depois selecione o painel desejado. O Object
Inspector mostrará as propriedades desse painel.
A propriedade Style permite que as configurações do texto mostrado no painel
sejam definidas pelo programador através de um manipulador de evento, mas vamos
adotar psText para essa propriedade. Isso indica que o alinhamento do texto é dado pela
propriedade Alignment e a fonte é determinada pela propriedade Font de StatusBar.
A propriedade Width define a largura do painel. À medida que aumentamos o
valor da propriedade Width do painel esquerdo, o painel direito tem sua largura
diminuída.
No segundo painel mostraremos a hora corrente. O evento mais indicado para
isso é o OnShow do form. Esse evento acontece quando a janela é mostrada. É
exatamente isso que queremos: apresentar a hora no momento em que a janela for
aberta. Note que os componentes adicionados ao form não permitem que ele seja
selecionado. Vamos então mostrar outra maneira de selecionarmos um componente. No
Object Inspector existe uma caixa combo (ComboBox) no topo da janela. Clique nessa
caixa e selecione o form pelo nome frmMenus. Agora clique na aba Events e dê um
duplo clique no evento OnShow. No editor de código digite:
stbMenu.Panels[1].Text := TimeToStr(Time);
Este código converte a hora atual para string e a atribui à propriedade Text do
segundo painel da barra de status. Execute o programa. Muito bom, mas você deve ter
observado que a hora é estática. Ou seja, a aplicação mostra a hora do instante que a
janela é aberta, e não se altera dai em diante. Para que a hora seja mostrada a cada
segundo é necessário um novo componente: o TTimer. Esse componente tem um único
evento, chamado OnTimer, que acontece a determinados intervalos de tempo. É isso que
queremos: mostrar a hora a cada segundo. Vejamos então as propriedades e evento de
Timer.

Enabled True Habilita o componente
Interval 1000 Determina o intervalo de tempo (milissegundos)
Name timHora Nome do componente
Evento Descrição
OnTimer Ocorre a cada intervalo definido por Interval
Quadro 17 Propriedades de StatusBar
A linha de código anterior, que foi programada para o evento OnShow do form,
deve ser executada no evento OnTimer. Para não reescrevermos o código selecione o
evento na aba Events, clique no botão da caixa combinada e escolha o método
FormShow. Execute o programa. Você irá observar um relógio digital na barra de
status.
72
Figura 60 Barra de status
73
Capítulo 7 Tratamento de arquivos

A partir de agora aprenderemos como criar aplicações que acessam bancos de
dados em Delphi. Mas, antes disso vamos estudar os recursos que o Delphi oferece para
acesso a arquivos texto. Arquivos texto são importantes porque podem ser usados para
trocar informações entre sistemas diferentes, mais especificamente para converter dados
entre bases diferentes, como dBase para Firebird, por exemplo. Um arquivo texto é um
conjunto de linhas de texto e seu acesso é sequencial. Ou seja, se precisarmos ler a
última linha do arquivo, é necessário ler todas as linhas anteriores.
Arquivos texto são um tipo em Delphi: TextFile. Para manipular os arquivos
existem procedimentos e funções. No quadro abaixo são apresentadas algumas delas.
Procedimento/Função Objetivo
AssignFile Associa o arquivo no disco a uma variável do tipo
TextFile
Append Abre um arquivo existente para inserção de novos
dados
Eof Verifica se a posição atual do cursor é o final do
arquivo
FileClose Fecha o arquivo
Flush Assegura que todas as informações são gravadas no
arquivo
Read/Readln Lê valores do arquivo. Readln posiciona o cursor na
próxima linha após a leitura
Reset Abre um arquivo existente
Rewrite Cria um arquivo e o abre para escrita
Write/Writeln Escreve num arquivo. Writeln posiciona o cursor na
próxima linha após a inserção
Quadro 18 Rotinas de Entrada e Saída
Para entender melhor o funcionamento dos arquivos vamos criar uma nova
aplicação. Mude a propriedade Name do form para frmArquivo, Caption para
Manipulando Arquivos e vamos salvar toda nossa aplicação para nomearmos a unit e o
projeto. Dê o nome de u_arquivos para a unit e Arquivos para o projeto. Depois coloque
os objetos e defina suas propriedades de acordo com as descrições:
Label
Propriedade Conteúdo
Caption Nome
Edit
Name edNome
Text
Width 280
Label
Caption Endereço
74
Edit
Name edEndereco
Text
Width 280
Label
Caption Telefone
Edit
Name edTelefone
Text
Width 120
GroupBox
Caption Escrita
Button
Caption &Novo
Name btnNovo
Button
Caption &Salvar
Name btnSalvar
A janela deverá ficar como a figura a seguir:
Figura 61 Interface da aplicação
75
Escrevendo dados no arquivo

Nossa aplicação exemplo recebe dados de uma pessoa nos três campos
disponíveis e, quando o usuário pressiona o botão Salvar, esses dados são escritos em
um arquivo texto.
Para escrever o código que escreve no arquivo texto precisamos definir o que o
código irá executar:
• O arquivo será criado se não existir, ou aberto para escrita, caso contrário.
• Os dados informados nos campos do form, depois de tratados, são escritos no
arquivo.
• O arquivo é fechado.
É comum que campos escritos em arquivos texto tenham o mesmo tamanho em

todas as linhas. À descrição dos campos e seus tamanhos chama-se layout e é
importante que o programador o conheça para facilitar a leitura do arquivo.
Apresentamos a seguir o layout do nosso arquivo:
Nome do campo Tamanho

Nome 40
Endereço 40
Telefone 15
Nos campos de edição não existe controle sobre o tamanho do texto. E o

tamanho do campo é sempre o tamanho do texto digitado pelo usuário. Portanto, antes
de enviar os dados para o arquivo é necessário que eles sejam tratados para se
adequarem ao layout informado. Por isso precisamos de uma função que retorna uma
string de espaços dado um tamanho, pois esses espaços complementarão o campo para
que tenha o tamanho definido. O código dessa função é mostrado na figura:
Figura 62 Função que retorna uma string de espaços
76
A função Espacos() é totalmente escrita pelo programador e o seu cabeçalho

deve ser inserido na seção type, como podemos ver na primeira linha da figura.
O código do método que implementa o evento OnClick do botão btnSalvar é o
seguinte:
Figura 63 O método btnSalvarClick
Vamos analisar detalhadamente o código:

Linha 1 - declara a variável Arquivo do tipo TextFile.
Linha 2 - associa a variável Arquivo ao arquivo no disco. Note que não
informamos o caminho do arquivo, portanto ele estará localizado no mesmo diretório da
aplicação.
Linha 3 - a função FileExists() verifica se o arquivo existe no disco. Se existir
executa a linha 4, senão executa a linha 5.
Linha 4 - abre o arquivo para escrita. A escrita ocorre sempre após a última
linha.
Linha 5 - cria o arquivo e o abre para escrita.
Linha 6 - escreve os dados no arquivo e salta para a próxima linha. A função
Length() retorna o tamanho de uma string, assim Espacos() retorna a quantidade de
espaços necessária para complementar o tamanho do campo.
Linha 7 - Fecha o arquivo.
O código de btnNovo limpa os campos de edição, preparando-os para uma nova

inserção. Digite o seguinte no método do evento OnClick desse botão:
edNome.Text := '';
edEndereco.Text := '';
edTelefone.Text := '';
Execute o programa e insira dados de várias pessoas. Agora abra o arquivo

dados.txt usando o bloco de notas e observe os dados que foram inseridos.
Lendo dados do arquivo

Para ler os dados do arquivo iremos inserir mais três botões no formulário
segundo as descrições seguintes, além de um GroupBox:
77
GroupBox
Caption Leitura
Button
Caption &Iniciar
Name btnIniciar
Button
Caption &Próximo
Name btnProximo
Button
Caption &Parar
Name btnParar
Os componentes devem ser colocados no form conforme a figura abaixo.

Observe que usamos o componente GroupBox para agrupar os botões de leitura e os
botões de escrita.
Figura 64 Botões para leitura do arquivo
O botão btnIniciar inicia a leitura do arquivo na primeira linha. btnProximo lê a

próxima linha e btnParar encerra a leitura, fechando o arquivo. No método do evento
OnClick de btnIniciar digite como no código da Figura 65.
Vamos analisar esse código:
Linha 1 - abre o arquivo para leitura.

Linha 2 - verifica se é final de arquivo. Se for o final do arquivo encerra a
leitura.
Linha 3 - lê a linha e posiciona o cursor na próxima.
Linha 4 - a função copy() retira parte da string, de acordo com o layout do
arquivo, e atribui à propriedade Text dos campos de edição.
78
Figura 65 Código do evento OnClick de btnIniciar
O código de btnProximo é o seguinte:
Figura 66 Código do evento OnClick de btnProximo
Este código é parte do anterior e não necessita maiores observações. O código de

btnParar simplesmente fecha o arquivo usando CloseFile(Arquivo).
Melhorando a interface
Nossa aplicação tem algumas deficiências. Por exemplo, se você pressionar
btnProximo antes de btnIniciar, o arquivo não estará aberto e um erro será retornado.
Para solucionar essas deficiências vamos alterar nosso código para habilitar ou
desabilitar os botões de acordo com a necessidade. Altere a propriedade Enabled de
btnProximo, btnParar e btnSalvar para False. A listagem seguinte mostra as alterações
feitas em cada método:
procedure TfrmArquivo.btnSalvarClick(Sender: TObject);

var
Arquivo:TextFile;
begin
AssignFile(Arquivo,'dados.txt');
if FileExists('dados.txt') then
79
Append(Arquivo)
else
Rewrite(Arquivo);
Writeln(Arquivo,edNome.Text+Espacos(40-length(edNome.Text))
+edEndereco.Text+Espacos(40-length(edEndereco.Text))
+edTelefone.Text+Espacos(15-length(edTelefone.Text)));
CloseFile(Arquivo);
btnNovo.Enabled := True;
btnSalvar.Enabled := False;
btnIniciar.Enabled := True;
end;
procedure TfrmArquivo.btnIniciarClick(Sender: TObject);

var
Linha: string;
begin
AssignFile(Dados, 'dados.txt');
if FileExists('dados.txt') then
begin
Reset(Dados);
if not Eof(Dados) then
begin
Readln(Dados, Linha);
edNome.Text := copy(Linha, 1, 40);
edEndereco.Text := copy(Linha, 41, 40);
edTelefone.Text := copy(Linha, 81, 15);
end;
btnIniciar.Enabled := False;
btnProximo.Enabled := True;
btnParar.Enabled := True;
btnNovo.Enabled := False;
end
else
ShowMessage('Arquivo não existe');
end;
procedure TfrmArquivo.btnProximoClick(Sender: TObject);

var
Linha: string;
begin
if not Eof(Dados) then
begin
Readln(Dados, Linha);
edNome.Text := copy(Linha, 1, 40);
edEndereco.Text := copy(Linha, 41, 40);
edTelefone.Text := copy(Linha, 81, 15);
end;
end;
procedure TfrmArquivo.btnNovoClick(Sender: TObject);

begin
edNome.Text := '';
edEndereco.Text := '';
edTelefone.Text := '';
btnNovo.Enabled := False;
btnSalvar.Enabled := True;
80
btnIniciar.Enabled := False;
end;
procedure TfrmArquivo.btnPararClick(Sender: TObject);

begin
CloseFile(Dados);
btnIniciar.Enabled := True;
btnProximo.Enabled := False;
btnParar.Enabled := False;
btnNovo.Enabled := True;
end;
Execute o programa e observe. Na leitura, os botões btnProximo e btnParar só

são habilitados depois que btnIniciar é pressionado. Na escrita, o botão btnSalvar só é
habilitado se o arquivo não estiver sendo lido e o botão btnNovo for pressionado.
81
Capítulo 8 Aplicações usando Banco de Dados

Local
Acesso a Banco de Dados
O Delphi utiliza uma estrutura de camadas para fazer com que o front-end
manipulado pelo usuário interaja com o banco de dados. O caminho deve ser percorrido
por uma série de componentes configurados entre si.
Figura 67 Configuração de acesso a banco de dados
A camada BDE fica entre a aplicação e o banco de dados. Mas existem outras
maneiras de acessar bancos de dados sem o BDE. Além do conjunto de componentes
BDE, o Delphi dispõe do conjunto Interbase Express, para acesso a banco de dados
Interbase/Firebird, e a biblioteca dbExpress, para acesso qualquer servidor SQL.
O BDE é um conjunto de DLLs que deve acompanhar as aplicações que fazem
uso de seus recursos de acesso a bancos de dados. É nessa camada que são definidas
características específicas de cada banco de dados, bem como sua localização, ou seja, o
front-end não acessa diretamente a base dados, o BDE é responsável para estabelecer
este funcionamento.
Além do BDE, vemos pela Figura 67 que o Delphi utiliza um amplo conjunto de
componentes:
• Session: aplicações simples trabalham com apenas um banco de dados.

Porém, o Delphi permite mais de uma conexão simultânea a bancos de dados
distintos, e também mais de uma conexão com o mesmo banco de dados. O
controle dessas conexões é feito através do componente da classe TSession,
criado automaticamente pelo Delphi na execução do programa. Esse
componente representa a sessão padrão da aplicação.
• DataBase: responsável pela conexão da aplicação com um banco de dados
com a finalidade de implementar os requisitos de transação e definir
características de comunicação de uma aplicação Delphi-Client/Server. Em
aplicações locais não é utilizado.
• DataSet: existem três componentes que descendem de uma classe
denominada TDataSet e implementam métodos importantes para
82
manipulação de tabelas além de características específicas. Os componentes

utilizados são: TTable, TQuery e TStoredProc.
• DataSource: é responsável por conectar componente Data-Aware a uma
determinada tabela representada por um DataSet.
• Data-Aware: são responsáveis pela visualização e manipulação direta dos
dados. Todo componente desse tipo tem uma propriedade para conectar-se
ao DataSource correspondente à tabela destino.
Aplicação de banco de dados

Vamos criar um projeto para exemplificar a construção de uma aplicação de
banco de dados mostrando todos os passos, que vão desde a criação das tabelas até a
geração de relatórios.
O projeto usará um banco de dados local e possui duas tabelas com 0 seguinte
modelo E-R:
Figura 68 Modelo E-R
Para criarmos as tabelas precisamos de um gerenciador de banco de dados. O

Delphi instala uma ferramenta com essa finalidade que cria tabelas Paradox ou dBase, o
Database Desktop. Se você quiser usar Access use a própria ferramenta da Microsoft
para isso.
Database Desktop
Para criar as tabelas selecione o comando File | New | Table. Uma janela para
definição do tipo de banco de dados será exibida. Vamos escolher o banco de dados
Paradox.
Cada tabela em Paradox, corresponde a um arquivo em disco com a extensão
.DB. Neste caso o conceito de banco de dados é definido pelo diretório onde estão as
tabelas, e não o nome do arquivo como no Access, por exemplo.
Figura 69 Janela para definir o tipo da tabela
Selecione Paradox 7 e pressione OK. Em seguida a janela para definição dos

campos será mostrada, onde:
83
• Field Name: define o nome do campo da tabela.

• Type: define o tipo de dado do campo. Tecle Espaço para visualizar uma
lista com os possíveis tipos.
• Size: tamanho do dado definido pelo campo Type. Alguns campos já são
padronizados não permitindo alteração.
• Key: define se o campo é chave primária. Tecle Espaço para ligar ou
desligar. Um asterisco é mostrado para confirmação de chave primária
ligada.
• Table Properties: define uma série de itens como Validações, Integridade
referencial e Índices secundários.
Uma validação permite, por exemplo, definir um domínio para o campo.

Integridade referencial define restrições de chave estrangeira. Índices secundários
permitem ordenação por campos diferentes da chave primária.
Figura 70 Janela para definição de campos
Field Name Type Size Key

IdCidade Number *
Nome Alpha 40
Quadro 19 Definição dos campos da tabela Cidade
Field Name Type Size Key

IdCliente Number *
Nome Alpha 40
Endereco Alpha 40
Estado Alpha 2
Sexo Alpha 1
Situacao Logical
IdCidade Number
Quadro 20 Definição dos campos da tabela Cliente
84
Defina os campos e seus tipos para Cidade e Cliente e salve cada uma
pressionando o botão Save As... Sugere-se que você crie um diretório para sua
aplicação e salve suas tabelas nesse mesmo diretório.
BDE - Criação do Alias

Assim como o Database Desktop, o BDE também é instalado junto com o
Delphi. No grupo de programas do Delphi execute o BDE Administrator. Observe a
tela inicial.
Figura 71 BDE Administrator
A tela é dividida em duas partes: a lista de Aliases/Bancos de Dados no lado

esquerdo e as configurações de cada Alias/Banco de Dados no lado direito.
Alias é uma string que define o caminho (path) e as configurações para acesso
ao banco de dados. Por exemplo, na Figura 71 temos em destaque o Alias DESTINO.
No lado direito vemos que esse Alias corresponde a um banco de dados do tipo dBase
localizado no caminho identificado pelo campo Path.
Na aplicação utilizaremos o nome do Alias para ter acesso às tabelas. Dessa
forma é possível mudar a localização das tabelas desde que se mantenha sempre o
mesmo Alias.
Para criar um Alias:
• Selecione o comando Object | New ou pressione CTRL + N.

• Confirme o tipo de driver. No nosso caso usaremos o Paradox.
• Defina um nome para o Alias (lado esquerdo da tela). Use o nome Clientes.
• Defina o caminho onde você criou suas tabelas no campo Path.
• Selecione o comando Object | Apply para salvar as alterações.
• Confirme as alterações.
85
O BDE deve ser instalado no equipamento onde a aplicação vai ser executada, e
o Alias deve ser criado da mesma maneira com o mesmo nome.
Iniciando a aplicação
Nossa aplicação terá uma janela principal e dois formulários para cadastro de
cidades e de clientes. Inicie uma nova aplicação no Delphi. No form crie um menu do
tipo MainMenu com os seguintes itens:
Arquivo
Sair
Cadastros
Cidade
Cliente
Consultas
Cidade
Cliente
Relatórios
Cidade
Cliente
Ajuda
Defina a propriedade Caption do form como Clientes e Name como

frmPrincipal. Salve o projeto inteiro com o comando File | Save All atribuindo à unit o
nome u_principal e ao projeto o nome Clientes. Tome a precaução de salvar tudo no
mesmo diretório.
Data Module
Antes de inserir novos forms vamos introduzir um novo objeto. Costumamos
centralizar os componentes de acesso ao banco de dados em um único lugar chamado
DataModule. DataModule é um contêiner visual onde podemos colocar componentes
não visuais, definir suas propriedades e escrever métodos manipuladores de eventos.
Para criar um DataModule selecione File | New | Data Module.
O DataModule é semelhante a um form, mas em tempo de execução ele existe
apenas na memória. TDataModule deriva de TComponent, e portanto não tem qualquer
relação com o conceito de janelas do Windows, pois como vimos antes os componentes
ajanelados do Delphi derivam de TWinControl. No entanto, ele tem uma unit e um
arquivo de definição de form, e podemos tratá-lo como um form.
Crie um DataModule e na propriedade Name defina dmDados. Salve-o e dê o
nome u_dmdados para a unit. E vamos então inserir os componentes de acesso ao banco
de dados. Como vimos anteriormente, para bancos de dados locais, tais como Paradox,
não é necessário usar o componente DataBase.
O componente TTable
Selecione o componente Table da aba de componentes BDE. No quadro abaixo
descrevemos as propriedades, métodos e eventos desse componente. Na coluna
Conteúdo do quadro são informados os valores que devem ser definidos em cada
propriedade da nossa aplicação.
A propriedade Active, além de indicar se a tabela está aberta ou não, pode ser
usada para abrir ou fechar a tabela. Na propriedade DatabaseName pode definir o banco
86
de dados através do Alias ou informando-se diretamente o caminho onde estão

localizadas as tabelas.

Active False Indica se a tabela está aberta ou não
DatabaseName Clientes Define o banco de dados
MasterFields Define os campos de relacionamento entre
duas tabelas
MasterSource Define a tabela mãe do relacionamento
Name tbCidade Define o nome do componente Table
TableName Cidade.db Define a tabela física associada ao componente
State Indica o estado atual da tabela
Método Descrição
Cancel Cancela a alteração feita num registro
Close Fecha a tabela
Delete Exclui o registro corrente
First Posiciona o cursor no primeiro registro
Locate Localiza registros em uma tabela
Last Posiciona o cursor no último registro
Next Posiciona o cursor no próximo registro
Open Abre a tabela
Post Escreve um registro na tabela
Prior Posiciona o cursor no registro anterior
Evento Descrição
AfterPost Acontece após escrever o registro na tabela
AfterCancel Acontece depois de cancelar um registro
AfterDelete Acontece depois de excluir um registro
BeforeCancel Acontece antes de cancelar um registro
BeforeDelete Acontece depois de excluir um registro
BeforePost Acontece antes de escrever o registro na tabela
Quadro 21 Propriedades, métodos e eventos de Table
Neste quadro foram apresentados alguns métodos e eventos. A quantidade de

métodos e eventos utilizada é muito maior que essa. Preferimos apresentá-los à medida
que forem sendo necessários.
A propriedade State indica em que estado se encontra a tabela. Estado é o modo
de operação. Alguns desses estados são listados abaixo:
• dsInactive - tabela fechada.

• dsBrowse - tabela pode ser visualizada, mas não alterada. É o estado padrão.
• dsEdit - registro corrente pode ser modificado.
• dsInsert - o registro corrente foi recentemente inserido, mas ainda não
escrito na tabela. Pode ser modificado, salvo ou descartado.
Existem outros estados, mas estes são os mais comuns.

Insira mais um componente Table. Define DatabaseName como Clientes. Name
como tbCliente e TableName como Cliente.db.
87
O componente TDataSource
DataSource é componente que faz a ponte de acesso entre um DataSet e os
controles de banco de dados (Data-Aware)
Na paleta DataAccess selecione TDataSource e insira no DataModule. Defina
suas propriedades de acordo com o quadro abaixo.

AutoEdit True Determina se a tabela entra em edição quando
o usuário modifica o conteúdo de um campo
DataSet tbCidade Define o componente DataSet associado
Name dsCidade Define o identificador do componente
State Lê o estado do DataSet associado
Evento Descrição
OnDataChange Acontece quando o registro é modificado e
quando move-se entre campos ou registros
OnStateChange Acontece quando o estado de um DataSet é
modificado
Quadro 22 Propriedades e eventos de DataSource
Insira mais um componente DataSource. Defina DataSet como tbCliente e Name

como dsCliente.
Figura 72 DataModule
A interface de entrada de dados da tabela Cidade

Agora vamos criar a interface de entrada de dados para a tabela Cidade. Inclua
um novo form na aplicação. Defina a propriedade Caption do form como Cidades e a
propriedade Name como frmCidade. Salve a aplicação e dê o nome u_cidade à unit.
O controle TDBEdit
A aba DataControls agrupa o conjunto de componentes Data-Aware que são
responsáveis pela visualização e manipulação de dados das tabelas.
88
O mais comum desses controles é TDBEdit. Esse objeto é uma caixa de edição
onde o usuário digita um texto a ser inserido em um campo de tabela. Vamos inserir um
componente desses na interface responsável por inserir dados na tabela Cidade.
No quadro seguinte são apresentadas as propriedades, métodos e eventos desse
componente.

CharCase ecNormal Define se o texto digitado será convertido para
maiúsculas, minúsculas ou não será convertido
DataField IdCidade Define o campo da tabela que será manipulado
pelo DBEdit
DataSource dmDados.dsCidade Define o DataSource da tabela
Name dbeIdCidade Define o identificador do controle
Métodos Descrição
Evento Descrição
OnChange Acontece quando o texto do controle é
modificado
OnEnter Acontece quando o controle recebe o foco
OnExit Acontece quando o foco sai do controle
Quadro 23 Propriedades, métodos e eventos de DBEdit
Para definir a propriedade DataSource é necessário criar uma referência à unit

do DataModule dmDados na unit u_cidade. Isso é necessário porque o componente
DataSource está localizado no DataModule. Dessa forma insira a seguinte linha de
código abaixo da linha implementation da unit u_cidade:
uses u_dmdados;
Após isso se você clicar na caixa combinada da propriedade DataSource de

tbCidade, será mostrada uma lista de todos os componentes DataSource que estão no
DataModule. Selecione o objeto que corresponde à tabela Cidade e depois clique na
caixa combinada da propriedade DataField para selecionar o campo da tabela.
Insira um TLabel da aba Standard para identificar o controle dbeIdCidade. Na
propriedade Caption escreva Id.
Coloque outro componente DBEdit abaixo do primeiro. Defina sua propriedade
Name como dbeNome, DataSource como dmDados.dsCidade e DataField como Nome.
Identifique esse controle com um TLabel. Defina seu Caption como Nome.
Figura 73 Aparência parcial da interface
89
TDBNavigator
Este controle reúne um conjunto de botões que movem o ponteiro da tabela para
frente ou para trás. Pode também colocar a tabela no estado Insert, Edit ou Browse e
gravar registro inseridos ou modificados.

ConfirmDelete True Determina se uma mensagem de confirmação
de exclusão de registro será mostrada
Flat False Define se os botões terão aparência de 3-D ou
2-D
VisibleButtons Define que botões aparecerão no navegador
Evento Descrição
BeforeAction Acontece quando um dos botões é
pressionado, antes da ação padrão
OnClick Acontece quando um dos botões é
pressionado, depois da ação padrão
Quadro 24 Propriedades e eventos de DBNavigator
Figura 74 O controle DBNavigator
Funções dos botões do navegador:
• First Move o ponteiro da tabela para o primeiro registro.

• Prior Move o ponteiro da tabela para o registro anterior.
• Next Move o ponteiro da tabela para o próximo registro.
• Last Move o ponteiro da tabela para o último registro.
• Insert Insere um novo registro na tabela.
• Delete Deleta o registro corrente.
• Edit Põe a tabela no estado Edit o que permite modificar um registro.
• Post Grava as modificações feitas na tabela.
• Cancel Cancela alterações feitas na tabela.
• Refresh Atualiza os dados do buffer.
Abrindo e fechando a tabela

Para usar uma tabela ela precisa ser aberta. Depois que seu uso é finalizado ela
ser fechada. Vamos concretizar esses procedimentos no código da unit. O código para
90
abrir a tabela será executado no momento que a janela for aberta, no evento OnShow da
janela frmCidade. Selecione o form e a aba Events no Object Inspector. Dê um duplo
clique no evento OnShow e complete o código:
procedure TfrmCidade.FormShow(Sender: TObject);

begin
dmDados.tbCidade.Open; // método para abrir
// a tabela
end;
Agora dê um duplo clique no evento OnClose. Esse evento acontece quando a

janela é fechada. É nele que vamos inserir o código para fechar a tabela.
procedure TfrmCidade.FormClose(Sender: TObject; var

Action: TCloseAction);
begin
dmDados.tbCidade.Close; // método para fechar
// a tabela
end;
Chamando o form
Nesse ponto do nosso projeto se ele for compilado, não terá como executarmos a
interface de cadastro de cidades. A janela que será mostrada é a janela do menu
principal. Portanto precisamos programar a janela principal do projeto para chamar a
janela de cidades.
Para fazer isso, inicialmente, digite a seguinte linha de código na área
implementation da unit u_principal:
uses u_cidade;
Com isso a unit principal pode referenciar qualquer objeto da interface de

entrada de dados da tabela cidade.
Selecione o comando de menu Cadastros | Cidades e digite a linha de código a
seguir:
frmCidade.Show; // método para abrir

// a janela
Agora compile e execute o projeto. Abra a interface de cadastro de cidades e

insira alguns registros na tabela.
A interface de entrada de dados da tabela Cliente

Insira um novo form na aplicação. Altere a propriedade Caption para Clientes e
a propriedade Name para frmCliente. Salve-o e defina o nome da unit como u_cliente.
Na área implementation digite a linha de código:
uses u_dmdados;
Insira três objetos DBEdit e no lado esquerdo de cada um deles insira um Label.
Defina suas propriedades de acordo com as descrições abaixo:
91
Label
Caption Id
DBEdit
CharCase ecNormal
DataField IdCliente
DataSource dsCliente
Name dbeId
Width 75
Label
Caption Nome
DBEdit
CharCase ecNormal
DataField Nome
Name dbeNome
Width 290
Label
Caption Endereço
DBEdit
CharCase ecNormal
DataField Endereco
Name dbeEndereco
Width 290
Selecionando dados de outra tabela (TDBLookUpComboBox)

O campo IdCidade da tabela cliente é uma chave estrangeira que referencia a
tabela Cidade. Devemos usar um controle que permita que o usuário apenas escolha
uma cidade entre aquelas que estão cadastradas na tabela Cidade. Para isso existe o
componente TDBLookUpComboBox.
Este objeto preenche uma caixa combinada com os dados lidos da tabela
referenciada. Ai então o usuário escolhe um desses itens para o campo quando pressiona
o botão da caixa.
Insira um componente TDBLookUpComboBox e defina suas propriedades
conforme o Quadro 25. Coloque também um Label à esquerda do controle. Defina a
propriedade Caption do rótulo como Cidade.
92

DataField IdCidade Define o campo da tabela que será
manipulado pelo controle
DataSource dmDados.dsCliente Define o DataSource da tabela
KeyField IdCidade Define o campo chave
ListField Nome Define o campo a ser visualizado
ListSource dmDados.dsCidade Define o DataSource da tabela referenciada
Name dblIdCidade Define o identificador do controle
Width 190 Define o tamanho do componente
Evento Descrição
modificado
Quadro 25 Propriedades, métodos e eventos de DBLookUpComboBox
Note que as propriedades DataSource e DataField têm a mesma descrição dos

demais controles DataAware. Portanto se referem à tabela que está sendo
editada/consultada. As propriedades ListSource, ListField e KeyField definem dados da
tabela referenciada pela chave estrangeira. Neste caso, a tabela Cidade.
Selecionando dados de uma lista (TDBComboBox)

O campo Estado da tabela foi definido para aceitar siglas dos estados brasileiros,
por isso tem apenas dois caracteres como tamanho. Vamos criar uma lista com essas
siglas e o usuário do programa poderá escolher uma delas. Para isso iremos usar o
controle TDBComboBox, uma caixa combinada que permite a escolha a partir de uma
lista ou a digitação de uma nova opção. Insira um objeto desses no form e defina suas
propriedades de acordo com o quadro abaixo.

DataField Estado Define o campo da tabela que será
Items Contém a lista de strings com as opções
Name dbcEstado Define o identificador do controle
Sorted True Define se os itens estarão ordenados
Style csDropDownList Define como o controle mostra os itens
Width 65 Define o tamanho do componente
Evento Descrição
modificado
OnClick Ocorre quando o usuário clica no controle
Quadro 26 Propriedades, métodos e eventos de DBComboBox
93
Clique no botão elipse da propriedade Items e digite os seguintes itens, um em

cada linha do editor: AC, AM, PA, AP, RR, RO, MA, PI, CE, PE, RN. PB, SE, AL, BA,
ES, MG, RJ, SP, SC, PR, RS, GO, TO, DF, MT, MS. Não se preocupe com a ordem das
opções, porque a propriedade Sorted cuida disso.
A propriedade Style pode assumir os seguintes valores:
• csDropDown define uma caixa combinada típica que permite edição e

mostra uma caixa de lista para escolha de opção.
• csDropDownList define uma caixa combinada que não permite edição. Se
for pressionada uma letra, o controle mostra a primeira opção que ele
encontra iniciando com essa letra.
• csSimple define um controle que permite edição e sempre mostra a caixa de
lista. A altura da caixa depende da propriedade Height.
Existem outros valores para essa propriedade, mas apenas essas são de nosso
interesse.
Insira um rótulo para identificar a caixa combinada e defina a propriedade
Caption como Estado.
Uma lista com poucas opções (TDBRadioGroup)

O campo Sexo tem apenas duas opções: Masculino e Feminino. Mas, o tamanho
do campo prevê apenas um caractere. Vamos definir que M e F serão os caracteres que
representarão o sexo do cliente. Selecione um objeto TDBRadioGroup na aba
DataControls e o insira no form. Defina suas propriedades conforme o Quadro 27.

Caption Sexo Define a legenda do controle
Columns 1 Determina em quantas colunas a lista de
opções será apresentada
DataField Estado Define o campo da tabela que será
Items Contém a lista de strings com as opções
Name dbrSexo Define o identificador do controle
Values Determina que valores serão escritos na tabela
Evento Descrição
modificado
Quadro 27 Propriedades, métodos e eventos de DBRadioGroup
Na propriedade Items são definidas as opções que o usuário escolhe. No nosso

caso clique no botão elipse e digite Masculino e Feminino. A propriedade Values define
os valores correspondentes às opções que serão escritos na tabela. Clique na
propriedade Values e informe M e F.
94
Caixa de verificação (TDBCheckBox)

A situação cadastral do cliente é dada pelo campo Situacao. Este campo assume
dois valores: Ativo e Inativo. Sendo que será escrito na tabela as letras A e I,
correspondentes à situação do cliente. Iremos usar uma caixa de verificação,
DBCheckBox. Coloque um objeto desses no form. Defina suas propriedades de acordo
com o quadro a seguir.

Caption Situação Define a legenda do controle
DataField Situacao Define o campo da tabela que será
Name dbxSituacao Define o identificador do controle
ValueChecked A Determina o valor que será escrito na tabela
se a caixa estiver marcada
ValueUnchecked I Determina o valor que será escrito na tabela
se a caixa estiver desmarcada
Evento Descrição
modificado
Quadro 28 Propriedades, métodos e eventos de DBCheckBox
Para completar a parte visual da janela, insira um TDBNavigator e defina a

propriedade DataSource como dmDados.dsCliente. E para finalizar a programação
precisamos incluir o código para abrir e fechar as tabelas. Observe que nos referimos a
tabelas. No plural. Você notou que a tabela Cliente se refere à tabela Cidade através do
componente TDBLookupComboBox. Portanto precisamos abrir e fechar as duas tabelas.
Selecione então o form e a aba Events no Object Inspector. Dê um duplo clique no
evento OnShow e digite o seguinte código:
dmDados.tbCidade.Open;
dmDados.tbCliente.Open;
Faça o mesmo para o evento OnClose e digite:
dmDados.tbCidade.Close;
dmDados.tbCliente.Close;
O form frmCliente deve ficar como a Figura 75.

Agora precisamos inserir o código para chamar o form do cadastro de clientes na
unit u_principal. Inicialmente abaixo de implementation acrescente u_cliente na
cláusula uses, de forma que fique assim:
uses u_cidade, u_cliente;
95
Figura 75 O form de cadastro de clientes
Em seguida clique na opção Cadastros | Cliente e digite o seguinte código no

editor:
frmCliente.Show;
Compile o projeto e execute o programa. Abra o form de cadastro de clientes e

insira alguns registros.
Consultas a banco de dados

De nada valeria inserir dados em tabelas se não pudéssemos fazer consultas.
Recuperar dados cadastrados de várias formas é uma das características dos sistemas
gerenciadores de banco de dados (SGDB). Mesmo o Paradox não sendo um SGDB, o
Delphi oferece recursos de consulta que suprem essa deficiência, e servem para
qualquer sistema utilizado.
Insira um novo form na aplicação. Altere a propriedade Name do form para
frmConsCidade e o Caption para Consulta Cidades. Salve a unit e dê a ela o nome
u_conscidade. Será necessário acessar os componentes do Data Module, por isso
acrescente abaixo de implementation, na unit u_conscidade, o seguinte código:
uses u_dmdados;
Na aba Standard selecione e coloque no form um RadioGroup, um Edit e um

Button. Defina suas propriedades de acordo com as descrições a seguir:
96
RadioGroup
Caption Pesquisar por:
ItemIndex 0
Items Código
Nome
Name rgCampo
Edit
Name edValor
Text
Button
Caption Pesquisar
Name btnPesquisar
Componente para o resultado da consulta (TDBGrid)

DBGrid é um componente para apresentação de dados de tabelas em linhas e
colunas. Mas pode também ser usado para inserir/alterar dados em tabelas. Selecione
um objeto DBGrid na aba Data Controls e o insira no form. A janela deve ter o
seguinte aspecto:
Figura 76 Form de consulta a cidades
Vamos definir algumas propriedades de DBGrid conforme o quadro a seguir:

Columns Descreve os atributos de apresentação dos
campos da tabela
Name dbgCidade Define o identificador do controle
+TitleFont Define características da fonte dos títulos das
97
colunas da grade
Evento Descrição
Quadro 29 Propriedades, métodos e eventos de DBGrid
A propriedade Columns é uma coleção de objetos TColumn. Pressione o botão

elipse no Object Inspector e o editor de colunas será mostrado. O primeiro botão na
barra de ferramentas do editor adiciona um novo objeto TColumn. Você pode definir
que campo da tabela estará associado a ele através da propriedade FieldName. Na
propriedade Title pode-se definir uma legenda (Caption) e as características da fonte.
No entanto se não for adicionada nenhuma coluna no editor, o Delphi assume que todos
os campos da tabela serão mostrados na grade. Neste caso, as características das colunas
que serão mostradas são definidas através dos objetos TField.
Objetos TField
TField é a classe ancestral de todas as classes Field de uma classe TTable. Esta
classe tem propriedades, eventos e métodos para alterar o valor de um campo em uma
tabela, converter o valor de um campo em outro tipo de dado, fazer validação de dados,
definir como os campos serão apresentados, etc.

AsCurrency Converte o valor do campo em Currency
AsDateTime Converte o valor do campo em DateTime
AsInteger Converte o valor do campo em Integer
AsString Converte o valor do campo em String
DisplayLabel Define a legenda do título na DBGrid
EditMask Define uma máscara para restringir entrada de
dados
Name Define o identificador do controle
Required Define se o campo é obrigatório
Evento Descrição
OnChange Acontece quando o valor do campo é escrito
no buffer
OnValidate Acontece que os dados sejam escritos no
buffer. Usa-se para validar dados
Quadro 30 Propriedades, métodos e eventos de TField
Para criar os objetos TField da tabela Cidade, dê um duplo clique em tbCidade.

Uma pequena janela semelhante à da Figura 77 será aberta:
98
Figura 77 Janela para criar TFields
Clique com o botão direito do mouse na janela e selecione Add all fields. Todos
os campos da tabela serão adicionados.
Pesquisa em tabelas usando Locate

O componente TTable oferece um método para fazer pesquisas em tabelas. O
método Locate é declarado em Delphi da seguinte forma:
function Locate(const KeyFields: String; const

KeyValues: Variant; Options: TLocateOptions): Boolean;
Onde:
const KeyFields: String é uma lista de campos objetos da pesquisa delimitados
por ponto-e-vírgula.
const KeyValues: Variant é um array de Variant contendo os valores que se
deseja pesquisar. Variant é um tipo de dado que pode ser usado quando não é possível
determinar o tipo em tempo de compilação. Para criar um array de Variant use a função
VarArrayOf.
Options: TLocateOptions especifica opções adicionais para a consulta.
loCaseInsensitive define que a consulta ignora maiúsculas e minúsculas. loPartialKey
define que a busca é parcial. Para usar essas opções é necessário incluir na cláusula uses
a unit DB.
Na nossa consulta queremos que o usuário escolha um campo para pesquisa,
digite o valor a ser pesquisado e clique no botão Pesquisar. Dessa forma dê um duplo
clique no botão e digite:
with dmDados.tbCidade do
if (rgCampo.ItemIndex = 0) then
begin
if not Locate('IdCidade', edValor.Text, []) then
ShowMessage('Registro não encontrado');
end
else
if not Locate('Nome', edValor.Text,
[loCaseInsensitive, loPartialKey]) then
ShowMessage('Registro não encontrado');
99
Se for selecionado o campo IdCidade no RadioGroup, a busca será feita pelo

campo IdCidade, e se for selecionado o campo Nome a busca será feita pelo campo
Nome. Quando a busca é feita pelo campo Nome usamos as opções loCaseInsensitive e
loPartialKey, que definem que a pesquisa ignora maiúsculas e minúsculas, e que a
pesquisa pode ser feita por parte do campo Nome. A primeira linha do código acima ,
iniciando com a palavra chave with, indica que métodos e propriedades cujo objeto não
é informado devem considerar o objeto especificado nesta linha.
Lembre de incluir DB na cláusula uses conforme o código seguinte:
interface
uses
Windows, Messages, SysUtils, Classes, Graphics,
Controls, Forms, Dialogs, Grids, DBGrids,
StdCtrls, ExtCtrls, DB;
Para que nosso programa funcione é necessário abrir e fechar a tabela

adequadamente. Selecione então o form e a aba Events no Object Inspector. Dê um
duplo clique no evento OnShow e digite o seguinte código:
dmDados.tbCidade.Open;
Faça o mesmo para o evento OnClose e digite:
dmDados.tbCidade.Close;
Agora precisamos inserir o código para chamar o form de consulta de cidades na

unit u_principal. Inicialmente abaixo de implementation acrescente u_conscidade na
uses u_cidade, u_cliente, u_conscidade;
Em seguida clique na opção Consultas | Cidade e digite o seguinte código no

editor:
frmConsCidade.Show;
Pesquisa em tabelas usando TQuery

Pesquisas com Locate só retornam dados de uma única tabela. Pesquisas que
retornam dados de mais de uma tabela devem ser feitas usando o componente TQuery.
Este objeto oferece uma propriedade que é um comando SELECT de SQL. E isso dá
grande flexibilidade à consulta. Como a maioria das propriedades dos componentes, é
possível definir a propriedade SQL em tempo de desenvolvimento ou em tempo de
execução.
Vamos criar a consulta à tabela Cliente usando TQuery. Para isso selecione um
componente TQuery na aba BDE e o insira no Data Module. Defina suas propriedades
de acordo com o quadro seguinte:
100

Active False Indica se a tabela está aberta ou não
DatabaseName Clientes Define o banco de dados
DataSource Define o componente de onde serão extraídos
valores de parâmetros
Name queConsCliente Define o nome do componente Query
Params Define parâmetros usados no comando SQL
SQL Define o comando SQL associado ao
componente
State Indica o estado atual da tabela
ParamByName Acessa parâmetros através de seus nomes
Quadro 31 Propriedades e métodos de TQuery
Os eventos e os métodos, exceto Locate, do Quadro 21 se aplicam a TQuery. A

propriedade SQL será definida em tempo de execução.
Insira também um DataSource e defina a propriedade Name como
dsConsCliente e na propriedade DataSet selecione queConsCliente.
Inclua agora um novo form na aplicação. Altere a propriedade Name do form
para frmConsCliente e o Caption para Consulta Clientes. Salve a unit e dê a ela o nome
u_conscliente. Será necessário acessar os componentes do Data Module, por isso
acrescente abaixo de implementation, na unit u_conscliente, o seguinte código:
uses u_dmdados;
Insira no form os mesmos componentes que foram inseridos na janela de

consulta a Cidades. Os valores que foram definidos para as propriedades podem ser
igualmente definidos, com exceção de DataSource da DBGrid, que deve ser definida
com dsConsCliente.
Todas as ações desta consulta serão realizadas através do código do evento
OnClick do botão Pesquisar.
Figura 78 Código do evento OnClick do botão btnPesquisar
101
Vamos analisar o código acima.

A linha que inicia com with evita a repetição da escrita do nome do objeto todas
as vezes que for necessário se referir a ele.
A idéia geral do código é que fechamos a Query (método Close), limpamos o
conteúdo da sua propriedade SQL (método Clear), inserimos um novo comando
SELECT em SQL (método Add), definimos um valor de parâmetro (ParamByName) e
abrimos novamente a Query (Open) para retornar os dados pesquisados.
Quando o item selecionado em rgCampo é o código, o comando SELECT
especifica o campo IdCliente em where. Os dois pontos (:) indicam que pIdCliente é um
parâmetro. Ou seja, um valor que deve ser definido em tempo de execução. Seu valor é
atribuído na linha seguinte usando ParamByName('IdCliente').Value. O valor digitado
em edValor é usado na consulta.
Caso o usuário selecione o nome em rgCampo, o comando SELECT especifica o
campo Nome em where, mas nesse caso usando like porque queremos fazer uma
pesquisa parcial. Note que incluímos o símbolo % no valor do parâmetro, de acordo
com as regras do operador like.
Agora precisamos inserir o código para chamar o form de consulta de clientes na
unit u_principal. Inicialmente abaixo de implementation acrescente u_conscliente na
uses u_cidade, u_cliente, u_conscidade, u_conscliente;
Em seguida clique na opção Consultas | Cliente e digite o seguinte código no

editor:
frmConsCliente.Show;
102
Capítulo 9 Aplicações usando Banco de Dados

Cliente/Servidor
Tudo que foi dito no Capítulo 8 sobre acesso a banco de dados é válido também
para os bancos de dados cliente/servidor. A aplicação Delphi pode acessar os dados
diretamente ou através do BDE. Neste capítulo apresentaremos o acesso através do
conjunto de componentes da aba Interbase que não necessita BDE.
Para criar a aplicação usaremos o banco de dados Firebird, um SGBD (Sistema
Gerenciador de Banco de Dados) livre e de código aberto, compatível com Interbase.
Nossa aplicação acessará um banco de dados com o seguinte modelo E-R:
Figura 79 Modelo E-R do banco de dados
Para criar as tabelas usaremos os seguintes comandos SQL:
CREATE TABLE CIDADE (ID_CIDADE INTEGER NOT NULL

PRIMARY KEY, NOME VARCHAR(40) NOT NULL);
CREATE TABLE CLIENTE (ID_CLIENTE INTEGER NOT NULL

PRIMARY KEY, NOME VARCHAR(40) NOT NULL, ENDERECO
VARCHAR(40) NOT NULL, ID_CIDADE INTEGER REFERENCES
CIDADE(ID_CIDADE), ESTADO CHAR(2), SEXO CHAR(1), SITUACAO
CHAR(1));
CREATE TABLE PRODUTO (ID_PRODUTO INTEGER NOT NULL

PRIMARY KEY, NOME VARCHAR(40) NOT NULL, PRECO_VENDA
NUMERIC(12,2) NOT NULL, ESTOQUE INTEGER NOT NULL);
103
CREATE TABLE VENDA (ID_VENDA INTEGER NOT NULL PRIMARY KEY,

TIPO CHAR(1) NOT NULL, DATA_VENDA DATE NOT NULL,
VALOR_VENDA NUMERIC(12,2) NOT NULL, ID_CLIENTE INTEGER NOT
NULL REFERENCES CLIENTE(ID_CLIENTE));
CREATE TABLE ITEM (ID_VENDA INTEGER NOT NULL REFERENCES

VENDA(ID_VENDA), ID_PRODUTO INTEGER NOT NULL REFERENCES
PRODUTO(ID_PRODUTO), QUANTIDADE INTEGER NOT NULL, PRIMARY
KEY(ID_VENDA, ID_PRODUTO));
Iniciando a aplicação
Crie uma nova aplicação. No form crie um menu do tipo MainMenu com os
seguintes itens:
Arquivo
Sair
Cadastros
Cidade
Cliente
Produto
Venda
Consultas
Cidade
Cliente
Produto
Relatórios
Cidade
Cliente
Venda
Ajuda
Defina a propriedade Caption do form como Vendas e Name como frmPrincipal.

Salve o projeto inteiro com o comando File | Save All atribuindo à unit o nome
u_principal e ao projeto o nome Vendas. Tome a precaução de salvar tudo no mesmo
diretório.
DataModule
Crie um DataModule selecionando File | New | Data Module, e na propriedade
Name defina dmDados. Salve-o e dê o nome u_dmdados para a unit. E vamos então
inserir os componentes de acesso ao banco de dados. Para esta aplicação usaremos o
conjunto de componentes Interbase Express (IBX). Este conjunto se encontra na aba de
componentes Interbase.
TIBDatabase
Este componente provê controle sobre uma conexão a um único banco de dados.
Oferece principalmente controle de transação e de logins de usuários. Todas as
aplicações que usam bancos de dados cliente/servidor necessitam deste componente.
Selecione o componente TIBDatabase na aba Interbase e ponha-o no Data Module.
Vejamos a seguir as propriedades, métodos e eventos desse objeto:
104

Connected True Indica se o banco de dados está aberto
DatabaseName C:\Cliente\Cliente.fdb Define o nome do arquivo de banco de
dados e o local onde ele se encontra
DefaultTransaction Define um componente IBTransaction
padrão para o banco de dados
LoginPrompt False Define se o login será solicitado.
Condicionado à definição de
usuário/senha na propriedade Params
Name dbCliente Define o nome do componente
Params Define parâmetros que são passados ao
servidor de banco de dados
SQLDialect 3 Define o dialeto usado pelo banco de
dados
Open Abre a conexão com o banco de dados.
Connected fica em True
Close Fecha a conexão com o banco de dados.
Leva Connected a False
Eventos Descrição
OnLogin Ocorre quando a aplicação se conecta ao
banco de dados
AfterConnect Ocorre depois que uma conexão é
estabelecida
BeforeConnect Ocorre antes que uma conexão seja
estabelecida
Quadro 32 Propriedades, métodos e eventos de IBDatabase
Defina a propriedade Params com o seguinte:
user_name=sysdba
password=masterkey
Esta definição juntamente com LoginPrompt em False e Connected em True,

definem que o login não será solicitado ao usuário. Só é necessário um componente
TIBDatabase para toda a aplicação.
O componente TIBTransaction
O servidor de banco de dados Firebird está estruturado em um modelo de
transação. As transações permitem que instruções enviadas ao banco de dados ocorram
em blocos, com a característica especial de que estas instruções são tratadas como uma
só, podendo ser executada completamente ou não ser executada.
O gerenciamento de transações do Firebird permite que aplicações clientes
iniciem múltiplas transações simultâneas. As transações podem ser isoladas de modo
que não são afetadas por alterações realizadas por transações concorrentes.
O componente TIBTransaction provê controle de transação discreta sobre uma
ou mais conexões de banco de dados. Em aplicações que utilizam IBX cada
componente TDataSet deve ter seu próprio componente TIBTransaction. Selecione um
105
componente desses na aba Interbase e o coloque no Data Module. A seguir as

propriedades e métodos de TIBTransaction.

Ative True Define se a transação está ativa
DeafultAction TACommit Define a ação que será executada
quando o limite de tempo definido em
IdleTimer é atingido
DefaultDatabase dbCliente Define o banco de dados padrão da
transação
IdleTimer 0 Especifica quanto tempo uma transação
deve esperar até que seja executado um
Commit ou Rollback
Name trCidade Define o nome do componente
Params Define parâmetros do buffer de
transação
Commit Grava permanentemente os dados
associados com a transação e finaliza a
transação
Rollback Cancela as atualizações da transação e a
finaliza
Quadro 33 Propriedades e métodos IBTransaction
O componente TIBTable
Este componente tem características e comportamento semelhantes ao
componente TTable estudado anteriormente. A principal diferença é que em TIBTable
existe a propriedade Transaction. Nesta propriedade definimos qual o componente
TIBTransaction associado ao componente TIBTable. Então vamos definir a propriedade
Database com dbCliente, Name com tbiCidade, Transaction como trCidade e
TableName como CIDADE. Procure seguir essa ordem de definição das propriedades.
Não é possível selecionar a tabela se o objeto Transaction não for definido antes.
É necessário escrever algum código para efetuar o Commit na transação. Vamos
inserir esse código no método do evento AfterPost de tbiCidade. Selecione o objeto
tbiCidade, na aba Events dê um duplo clique no evento AfterPost e digite o código:
procedure TdmDados.tbiCidadeAfterPost(DataSet: TDataSet);

var
Ponteiro: TBookMark; //1
begin
Ponteiro := tbiCidade.GetBookmark; //2
if trCidade.InTransaction then //3
trCidade.Commit;
if not tbiCidade.Active then //4
begin
tbiCidade.Open; //5
tbiCidade.GotoBookmark(Ponteiro); //6
end;
tbiCidade.FreeBookmark(Ponteiro); //7
end;
106
Vamos analisar cada linha desse código:
Linha 1: declaração de uma variável do tipo TBookMark. Esse tipo de dado

define um ponteiro para um registro de tabela.
Linha 2: GetBookmark é um método que retorna o ponteiro para o registro
corrente.
Linha 3: Verifica se existe uma transação ativa. Se existir executa o método
Commit.
Linha 4: Verifica se a tabela está fechada.
No conjunto de componentes IBX, sempre que uma transação é finalizada as
tabelas associadas com esse transação são fechadas, por isso na linha 5 a tabela é aberta
caso a verificação na linha 4 seja verdadeira.
Linha 6: Faz o ponteiro da tabela ir para o registro que era corrente antes da
tabela ser fechada.
Linha 7: Libera a memória utilizada pelo ponteiro TBookMark.
Em resumo: este código encerra a transação, reabre a tabela e move o ponteiro

para o registro que estava sendo atualizado antes da transação ser finalizada.
Insira também um TDataSource da aba Access no Data Module. Defina a
propriedade Name como dsCidade e DataSet como tbiCidade.
Insira no Data Module componentes para as tabelas Cliente e Produto
exatamente como foi feito até aqui para a tabela Cidade.
As interfaces de entrada de dados

Inclua um novo form na aplicação e defina seu nome e nome da unit exatamente
como na interface criada para a tabela Cidade na aplicação anterior. Insira os mesmos
componentes que foram inseridos na interface da tabela Cidade anterior. Para fazer a
associação dos controles com o DataSource da tabela Cidade digite o seguinte código
abaixo de implementation na unit u_cidade:
uses u_dmdados;
Para abrir e fechar a tabela é necessário incluir código nos eventos OnShow e
OnClose do form. Dê um duplo clique no evento OnShow e complete o código:
procedure TfrmCidade.FormShow(Sender: TObject);

begin
dmDados.tbiCidade.Open;
end;
Agora dê um duplo clique no evento OnClose. Digite o código para fechar a

tabela Cidade.
procedure TfrmCidade.FormClose(Sender: TObject; var

Action: TCloseAction);
begin
dmDados.tbiCidade.Close;
end;
107
Selecione o form principal e complete o código para chamar a tela de cadastro de

cidades, exatamente como foi feito na aplicação anterior. Siga os mesmos
procedimentos para criar as interfaces de entrada de dados das tabelas Cliente e
Produto. Crie-as da mesma forma que foi criada a interface de Cliente anterior. Execute
o programa e insira dados nas tabelas Cidade, Cliente e Produto.
Form mestre-detalhe
Vamos analisar uma nota fiscal:
Figura 80 Nota fiscal
A área identificada com a chave é onde são especificados os produtos constantes

da nota fiscal. Cada linha dessa região corresponde, em geral, a um produto. Toda a área
restante é onde ficam os dados da nota: cliente, data, total da nota, etc. Dessa análise
108
podemos concluir que uma nota fiscal é composta de muitos produtos. E também
podemos afirmar que um produto pode estar presente em várias notas fiscais, visto que
um produto pode ser vendido para vários clientes. Ou seja, o relacionamento entre as
entidades nota fiscal e produto é N:N. Sendo um relacionamento muitos para muitos,
este relacionamento possui atributos. Esse relacionamento está representado no modelo
E-R da Figura 79.
Data Module
No Data Module insira um TIBTable, um TIBTransaction e um TDataSource e
faça as associações e definições necessárias para eles se conectarem à tabela Venda. Ao
TIBTable dê o nome tbiVenda, ao TIBTransaction dê o nome trVenda e ao TDataSouce
dê o nome dsVenda.
Insira um TIBTable, um TIBTransaction e um TDataSource e faça as
associações e definições necessárias para eles se conectarem à tabela Item. Ao TIBTable
dê o nome tbiItem, ao TIBTransaction dê o nome trItem e ao TDataSouce dê o nome
dsItem.
Lembre de incluir o código para o evento AfterPost de cada uma dessas tabelas,
da mesma forma que foi feito para as tabelas Cidade, Cliente e Produto.
Agora vamos definir o relacionamento mestre-detalhe entre a tabela Venda
(mestre) e a tabela Item (detalhe). Inicialmente selecione tbiItem e localize a
propriedade MasterSource. Nesta propriedade selecione o objeto dsVenda. Assim
estamos dizendo que Venda é mestre (Master) de Item.
Em seguida precisamos definir a chave estrangeira (detalhe) e a chave primária
(mestre) do relacionamento. Na propriedade MasterFields de tbiItem clique no botão
elipse. Será aberta a tela Field Link Designer onde faremos essa definição.
Figura 81 Tela de definição da ligação entre duas tabelas
Selecione o campo ID_VENDA na caixa Detail Fields, que define a chave

estrangeira da tabela detalhe, e na caixa Master Fields, que define a chave primária da
tabela mestre. O botão Add será habilitado. Clique nele e a relação será mostrada na
caixa Joined Fields. Confirme no botão OK. Está pronto o relacionamento mestre-
detalhe.
109
A interface de entrada de dados

Insira um novo form no programa. Altere a propriedade Caption para Vendas e a
propriedade Name para frmVenda. Salve-o e defina o nome da unit como u_venda. Na
área implementation digite a linha de código:
uses u_dmdados;
Insira objetos e defina suas propriedades de acordo com as informações a seguir:
Label
Caption Id
DBEdit
CharCase ecNormal
DataField Id_Venda
DataSource dmDados.dsVenda
Name dbeId_Venda
Width 75
Label
Caption Data
DBEdit
CharCase ecNormal
DataField Data_Venda
Name dbeData_Venda
Width 100
Label
Caption Cliente
DBLookupComboBox
DataField Id_Cliente
KeyField Id_Cliente
ListField Nome
ListSource dmDados.dsCliente
Name dblId_Cliente
Width 200
DBRadioGroup
110
Caption Tipo de Venda

Columns 2
DataField Tipo
Height 40
Items Venda à vista
Venda à prazo
Name dbrTipo
Values V
P
Width 240
Label
Caption Valor
DBEdit
CharCase ecNormal
DataField Valor_Venda
Name dbeValor_Venda
Width 150
DBNavigator
GroupBox
Caption Itens
DBGrid
DataSource dmDados.dsItem
Name dbgItem
Note que, nesta janela, estamos utilizando três tabelas: Venda, Item e Cliente.
Lembre que no objeto DBLookupComboBox, ligamos ele à tabela Cliente através do
DataSource dsCliente. Portanto é necessário abrir as três tabelas para que a janela
funcione corretamente. Então, no evento OnShow do form digite o seguinte código:
procedure TfrmVenda.FormShow(Sender: TObject);

begin
dmDados.tbiVenda.Open;
dmDados.tbiItem.Open;
dmDados.tbiCliente.Open;
end;
E no evento OnClose digite o seguinte:
111
procedure TfrmVenda.FormClose(Sender: TObject;

var Action: TCloseAction);
begin
dmDados.tbiVenda.Close;
dmDados.tbiItem.Close;
dmDados.tbiCliente.Close;
end;
A interface, após todas essas definições deverá ter o aspecto mostrado na Figura
82.
Figura 82 Form de Vendas
Selecione o form principal e acrescente o código necessário para chamar a janela

de vendas. Execute o programa e chame a tela de Vendas. Insira os dados de uma venda
(sem os itens) e depois salve usando o botão do navegador. Se a venda não for salva,
quando você tentar incluir um item o programa retornará uma mensagem do Firebird
alertando para erro de chave estrangeira. Na DBGrid deve estar aparecendo as colunas
ID_VENDA, ID_PRODUTO e QUANTIDADE. Clique na coluna ID_PRODUTO e
digite um código de produto que você tenha cadastrado. Observe que, automaticamente,
o ID_VENDA é preenchido com a chave da venda inserida. Vá para o campo
QUANTIDADE e digite qualquer valor e tecle ENTER se não quiser mais inserir itens
ou a seta para baixo para inserir um novo item. Para excluir um item na DBGrid
selecione-o e pressione CTRL + DEL. Uma pergunta será feita para confirmar a
exclusão do item.
Você deve ter observado que, no objeto DBLookupComboBox, a lista de clientes
não abre totalmente, mostrando apenas uma linha. Para resolver isso, selecione o
DBLookupComboBox, na aba Events do Object Inspector dê um duplo clique no
evento OnDropDown e digite o seguinte código:
112
procedure TfrmVenda.dblId_ClienteDropDown
(Sender: TObject);
begin
dmDados.tbiCliente.MoveBy(5);
end;
Agora vamos melhorar nossa interface. Inicialmente vamos incluir máscaras

para a data e para o valor da venda. Selecione o Data Module e crie os objetos TField de
tbiVenda. Ainda com a tela de criação de TFields aberta, selecione DATA_VENDA e
na propriedade EditMask digite !99/99/0000;1;_. Agora as barras da data não precisam
ser digitadas. Selecione VALOR_VENDA e na propriedade DisplayFormat digite
###,##0.00. Com isso, o valor da venda será formatado com ponto separando milhar e
vírgula decimal.
Crie os objetos TField de tbiItem. Selecione ID_VENDA e na propriedade
Visible escolha False. Isso fará com que esta coluna seja ocultada na DBGrid, pois não
precisamos digitá-la, visto que a definição mestre-detalhe inclui seu valor
automaticamente.
Seria interessante podermos selecionar o produto de uma lista na DBGrid, em
vez de digitar o código. Vamos então criar um objeto TField do tipo Lookup
manualmente, que faça isso para nós. Na tela de criação de TFields de tbiItem clique
com o botão direito e selecione New Field. Uma janela como a da Figura 83 será aberta.
Figura 83 Criação de campo Lookup
Preencha os campos exatamente como está mostrado. O campo Component tem

preenchimento automático. Campo Lookup busca dados em outra tabela através de um
relacionamento. Neste caso, o campo ID_PRODUTO da tabela Item (Key Fields) é
usada para fazer o relacionamento com a chave primária ID_PRODUTO (Lookup Keys)
da tabela Produto (Dataset) e retornar o NOME (Result Field). Pressione OK para
confirmar. Arraste o novo TField para ficar depois de ID_PRODUTO.
Vamos criar também um TField para calcular o valor total de cada produto,
resultado do produto da quantidade pelo preço de venda. Na tela de criação de TFields
de tbiItem selecione New Field. Dê o nome TOTAL para o campo, especifique que o
tipo de dado é float e marque o tipo Calculated. Veja a Figura 84. Confirme
pressionando o botão OK. Isto cria um campo calculado, mas não define que cálculo
113
será feito. Os campos desse tipo são calculados no evento OnCalcFields do DataSet
correspondente.
Figura 84 Criação de campo calculado
Selecione tbiItem e na aba Events dê um duplo clique no evento OnCalcFields.

Digite o seguinte código:
procedure TdmDados.tbiItemCalcFields(DataSet:
TDataSet);
begin
if tbiProduto.Locate('ID_PRODUTO',
tbiItemID_PRODUTO.Value, []) then
tbiItemTOTAL.Value := tbiItemQUANTIDADE.Value *
tbiProdutoPRECO_VENDA.Value;
end;
Neste método, inicialmente o produto é localizado usando o método Locate. A

chave primária do produto digitado é passada como parâmetro. Se for localizado, na
linha seguinte o campo TOTAL é calculado multiplicando-se a QUANTIDADE de
tbiItem pelo PRECO_VENDA e tbiProduto. Compile, rode o programa e faça testes
inserindo vendas.
Trabalhando com exceções

No código que vamos apresentar em seguida há comandos não estudados ainda,
por isso vamos abrir uma janela na sequência que estamos seguindo para apresentar o
tratamento de exceções no Delphi.
A idéia por trás das exceções é fazer programas mais robustos adicionando a
capacidade de manipular erros de software e hardware de maneira uniforme. Um
programa pode sobreviver a tais erros ou terminar normalmente, permitindo ao usuário
salvar os dados antes de sair. Exceções permitem separar o código de manipulação de
erros do seu código normal em vez de misturar os dois.
Outro benefício das exceções é definir um mecanismo para relatar erros,
universal e uniforme, que também é usado pelos componentes do Delphi. Do ponto de
vista do código em que é levantada, uma exceção é passada ao código que o chama e
114
assim por diante. Se nenhuma parte do seu código trata a exceção, o próprio Delphi a
trata, mostrando uma mensagem de erro padrão e tenta continuar a execução do
programa, manipulando a próxima mensagem do sistema ou requisição do usuário.
O mecanismo completo de tratamento de exceções é baseado em quatro palavras
chaves:
try - delimita o início de um bloco de código protegido.

except - delimita o fim de um bloco de código protegido e introduz os códigos
de manipulação de exceção, com a seguinte sintaxe:
on tipo-de-exceção do comando
finally - usado para especificar um bloco de código que sempre será executado
mesmo quando ocorrem exceções. Este bloco geralmente é usado para operações de
limpeza que sempre serão executadas, tais como fechar arquivos ou tabelas de bancos
de dados, liberar objetos, liberar memória ou outros recursos requisitados pelo
programa.
raise - comando para criar uma exceção. Muitas exceções são geradas pelo
próprio sistema, mas você pode gerar suas próprias exceções quando encontrar dados
inválidos ou inconsistentes em tempo de execução. Este comando também pode ser
usado para relançar uma exceção dentro de um manipulador, isto é, propagá-la para o
próximo manipulador.
Vejamos um exemplo:
try
result := A div B;
except
on EDivByZero do
ShowMessage
('Ocorreu uma tentativa de dividir por zero');
end;
Neste caso, se B for igual a zero, uma exceção do tipo EDivByZero é levantada
e tratada pelo bloco except.
É possível ter um bloco try somente com um bloco finally. Neste caso, não
queremos tratar uma exceção, mas garantir que um bloco de código será executado
mesmo que ocorra uma exceção.
Calculando o total da nota

Para finalizar a interface de venda vamos fazer a implementação que irá calcular
o total da venda. Não existe uma maneira visual de fazer isso, tudo tem que ser feito
através de código. Mostramos o código na Figura 85 e vamos analisá-lo
detalhadamente.
A idéia por trás do código é que, sempre que inserirmos ou excluirmos um
produto da nota, ele percorre todos os itens calculando o novo total. Depois do cálculo,
esse valor é atribuído ao campo VALOR_VENDA da nota fiscal. Esse código será
então programado nos eventos AfterPost e AfterDelete de tbiItem. Para não haver
repetição de código, vamos criar um procedimento que será chamado AtualizaTotal, e
115
depois ele será chamado nos eventos citados. Lembre de incluir a assinatura do método
na seção type. A seguir analisamos cada linha do código:
Linha 6: Guarda o ponteiro do registro atual da tabela Item, pois durante o cálculo os
registros de itens da venda serão percorridos um a um, e depois retornaremos à posição
corrente.
Figura 85 Código para atualizar o total da venda
Linha 8: Desabilita os controles Data-Aware que estão associados a tbiItem, para evitar
que durante a varredura dos itens, os controles reflitam as mudanças de registro.
Linha 9: Posiciona o ponteiro de registros no primeiro item. A configuração mestre-
detalhe limita a varredura apenas aos itens constantes da nota fiscal.
Linha 10: Inicializa a variável que receberá o total da nota.
Linha 11: Verifica se o último registro não foi alcançado.
Linha 13: Acumula o total do item na variável totalizadora.
Linha 14: Muda o ponteiro para o próximo registro.
Linhas 16 e 17: Verifica se a tabela está em estado de navegação (dsBrowse). Se estiver,
muda o estado para edição.
Linha 18: O objeto TField correspondente a VALOR_VENDA recebe o total calculado.
Linhas 20 a 24: Este bloco será executado mesmo que ocorra uma exceção no bloco try.
Habilita novamente os controles Data-Aware associados a tbiItem, retorna ao registro
corrente antes da execução do método e libera a memória ocupada pelo ponteiro.
Inclua uma chamada a AtualizaTotal nos eventos AfterPost e AfterDelete de
tbiItem. Compile e execute o programa. Faça testes de inclusão, alteração e exclusão de
itens nas notas para perceber o efeito do código que inserimos.
116
Relatórios
Relatórios são como consultas a bancos de dados enviadas para uma impressora,
conectada ao computador. Para construir nossos relatórios utilizaremos o conjunto de
componentes Rave. Rave é uma sigla para Report Authoring Visual Environment. Essa
ferramenta possibilita que os relatórios sejam criados utilizando código, ou seja,
totalmente em Object Pascal, ou que sejam criados usando a sua IDE. Os relatórios são
criados como projetos e gravados em arquivos. Esses arquivos podem ser incorporados
à aplicação e, se for necessário alterá-los, não é preciso compilar o programa
novamente. Vamos abordar apenas a criação de relatórios usando a IDE do Rave.
Os componentes necessários para criar relatórios estão localizados na aba Rave.
Figura 86 Aba de componentes Rave
Para a criação dos relatórios inicialmente são inseridos componentes desta aba
na aplicação. Os componentes inseridos definem um projeto e a conexão da ferramenta
com um objeto DataSet. Depois o Rave é chamado para criar o relatório visualmente.
Pode-se chamar o Rave através de um duplo clique no componente RvProject, ou
selecionando-se a opção Tools | Rave Designer no menu do Delphi. Construído o
relatório, ele é salvo como um arquivo e incorporado à aplicação através do objeto
RvProject.
Finalmente, para executar o relatório incluímos uma linha de código para fazer a
chamada onde for conveniente.
Relatório de Cidades
Vamos então criar o relatório de Cidades. Selecione o Data Module e insira um
componente RvSystem da aba Rave. Este componente é responsável pelo envio do
relatório para uma impressora ou para a tela de Preview. Altere suas propriedades como
o quadro seguinte:

Name rvsysVendas Define o nome do objeto
TitlePreview Previsão do Relatório
TitleSetup Opções de Impressão
TitleStatus Status de Impressão
Quadro 34 Propriedades do componente RvSystem
Insira um componente RvProject. Este componente é responsável pela ligação

entre o projeto Delphi e o projeto de relatórios Rave. Altere suas propriedades de acordo
com o quadro:

Engine rvsysVendas Define um motor de relatório
Name rvVendas Define o nome do componente
Quadro 35 Propriedades do componente RvProject
117
Insira um componente RvDataSetConnection. Este componente exporta um

DataSet do projeto Delphi para o projeto Rave. Altere suas propriedades de acordo com
o quadro:

DataSet tbiCidade Define o DataSet objeto do relatório
Name rdsCidade Define o nome do componente
Quadro 36 Propriedades do componente RvDataSetConnection
Agora dê um duplo clique no objeto rdsCidade para abrir o Rave Visual

Designer. Você também pode abrir o IDE selecionando a opção Tools | Rave Designer
no menu do Delphi. Localize cada elemento da interface conforme as identificações
feitas na Figura 87.
Paletas de
Componentes
Barra de
Ferramentas
Árvore de
objetos
Painel de
Propriedades A Página
Figura 87 Rave Visual Designer
Selecione File | New para criar um novo projeto de relatório. Selecione File |
Save para salvar o projeto e dê a ele o nome Vendas.rav.
Configurações gerais
Na Árvore de Objetos, selecione RaveProject e, no Painel de Propriedades,
altere a propriedade Units para unMM (milímetros). Expanda Report Library e,
selecione Report1. No Painel de Propriedades, altere a propriedade FullName para
Relatório Geral de Cidades, e a propriedade Name para rptCidade.
Abaixo de rptCidade selecione Page1. No Painel de Propriedades, altere as
propriedades de acordo com a Figura 88. São propriedades da página onde será
construído o relatório. Desta forma alteramos as dimensões para o tamanho A4 e a
grade que orientará o desenho do relatório.
118
Figura 88 Propriedades do objeto Page1
Acesso aos Dados

Para imprimir um relatório é necessário ter acesso aos dados, nesse caso da
tabela Cidade. No Rave isto é feito através do Data Object. Para criar o Data Object,
selecione no menu File | New Object, ou pressione o botão correspondente na barra de
ferramentas. Assim, aparecerá a tela:
Figura 89 Janela para criação da conexão a dados
Selecione a opção Direct Data View. Isto dará acesso a todos os objetos do tipo
DataSet que inserimos na aplicação. Pressione o botão Next. Aparecerá nova tela
mostrando todos os objetos RvDataSetConnection inseridos no projeto. Como foi
inserido apenas um, o rdsCidade, selecione-o e clique no botão Finish.
Na Árvore de Objetos expanda Data View Directory. Selecione DataView1 e,
no Painel de Propriedades, altere a propriedade Name para dvCidade, e a propriedade
Full Name para Registros de Cidade.
Figura 90 Árvore de Objetos
119
Desenhando o relatório
Nas Paletas de Componentes selecione a aba Report. Nesta aba selecione o
componente Region e o coloque na Página. Esse componente determina e delimita a
área de impressão da página.
Redimensione o componente Region de modo que ocupe quase toda a área da
Página. Deixe uma área livre no final da página, onde será o rodapé. A página deve
ficar como a Figura 92.
Region
Figura 91 Componente Region
Componente
Region
Rodapé da
página
Figura 92 Área de impressão
Selecione a aba Report, selecione e insira em Region um componente Band e um

DataBand. Esses componentes são usados para definirmos o que será impresso no
relatório.
Band e
DataBand
Figura 93 Componentes Band e DataBand
A Figura 94 mostra a página de impressão depois de inseridos os objetos Band e

DataBand. No componente Band definiremos o título do relatório e os rótulos dos
cabeçalhos de colunas. Em DataBand serão inseridos os dados da tabela a serem
impressos.
120
Figura 94 Página com os objetos Band e DataBand
Selecione Band1 e altere suas propriedades no Painel de Propriedades.

Selecione a propriedade BandStyle e a seguinte janela será aberta:
Figura 95 Editor da propriedade BandStyle
Em Print Location marque Body Header. E em Print Occurrence marque First e

New Page.
Na propriedade ControllerBand selecione DataBand1. Defina a propriedade
Name como PageHeader.
Selecione o objeto Band2 e altere as propriedades Name para Detalhe, e
DataView para dvCidade.
Vamos colocar um título no cabeçalho da página e títulos no cabeçalho de
coluna. Para isso vamos usar o componente Text da aba Standard.
121
Text
Figura 96 Componente Text
Insira um Text em PageHeader. Altere a propriedade Text para Relatório de

Cidades e FontJustify para pjCenter. Altere a propriedade Font para definir seu
tamanho, nome e estilo de acordo com a sua preferência. Ajuste a largura e a posição do
componente para que ele fique centralizado. Insira mais dois componentes Text abaixo
do título do relatório, que serão os rótulos das colunas ID_CIDADE e NOME. A página
deve ficar como a figura abaixo:
Figura 97 Página com os objetos Band e DataBand
Para exibir data de impressão do relatório, insira no cabeçalho um componente

DataText da aba Report. Na propriedade DataField pressione o botão elipse. Na caixa
Report Variables selecione DateShort. Clique no botão Insert Report Var e a variável
selecionada será inserida na caixa Data Text. Pode ser deixado assim ou inclua um texto
para identificar a variável. Por exemplo:
'Emitido em: ' + Report.DateShort
Figura 98 Editor de Data Text
122
Insira outro DataText no cabeçalho para imprimir o número da página. Em

Report Variables selecione CurrentPage e proceda da mesma maneira que foi feito para
a data.
Agora iremos montar a banda detalhe, onde serão impressos os dados da tabela.
Com a tecla CTRL pressionada, arraste cada campo abaixo de dvCidade na Árvore de
Objetos, para a posição desejada na banda detalhe. Aparecerá um componente
DataText para cada campo arrastado.
Figura 99 Aparência do projeto do relatório
Salve o projeto. Pressione a tecla F9 para visualizar uma prévia do relatório.

Para imprimir o relatório no Delphi, selecione o objeto rvVendas no Data
Module. Na propriedade ProjectFile selecione o arquivo Vendas.Rav que acabamos de
criar. Agora vamos ao nosso menu principal e selecionar a opção Relatórios | Cidade.
No método do evento OnClick desse item digite:
dmDados.rvVendas.ExecuteReport('rptCidade');
Pronto. Agora vamos compilar e executar o programa.
Relatório de Clientes
O relatório de clientes será com quebra de grupo. Ou seja, os clientes serão
listados por cidade. A cada nova cidade será impresso o nome da cidade e em seguida
todos os clientes daquela cidade.
No Data Module vamos inserir um componente IBTransaction da aba Interbase.
Defina sua propriedade Name como trRelCliente e em DefaultDatabase selecione
dbCliente. Insira também um IBQuery. Na propriedade Database selecione dbCliente.
Em Name defina queRelCliente e em Transaction selecion trRelCliente. Na propriedade
SQL digite:
SELECT a.ID_CLIENTE, a.NOME, a.ENDERECO, b.ID_CIDADE, b.NOME

FROM CLIENTE a, CIDADE b WHERE a.ID_CIDADE = b.ID_CIDADE ORDER
BY b.ID_CIDADE;
Selecione um objeto RvDataSetConnection da aba Rave. Altere a propriedade

Name para rdsCliente em DataSet selecione queRelCliente.
123
Em um mesmo projeto Rave podemos criar vários relatórios. Desta forma,

vamos criar esse relatório no mesmo projeto criado anteriormente. No menu selecione
File | New Report.
Na Árvore de Objetos selecione o novo relatório, Report1. Através do Painel
de Propriedades altere FullName para Relatório de Clientes e Name para rptCliente.
Altere as dimensões de Page1 da mesma forma que foi definido em rptCidade.
É necessário definir acesso aos dados através de um Data Object. Crie um novo
objeto e, procedendo da mesma maneira que foi feito para o relatório de cidades,
selecione rdsCliente.
Na Árvore de Objetos expanda Data View Directory. Selecione DataView1 e,
no Painel de Propriedades, altere a propriedade Name para dvCliente, e a propriedade
Full Name para Registro de Cliente.
Desenhando o relatório
Insira um componente Region (aba Report) na Página. Redimensione-o para
ocupar toda a página.
Insira dois componente Band e um DataBand. Defina suas propriedades da
seguinte forma:
DataBand
DataView dvCliente
Name Detalhe
Band
BandStyle Selecione Body Header e First
ControllerBand Detalhe
Name PageHeader
Band
BandStyle Selecione Group Header e First
ControllerBand Detalhe
GroupDataView dvCliente
GroupKey ID_CIDADE
Name GroupHeader
Insira um Text (aba Standard) em PageHeader e defina a propriedade Text como

Relatório de Clientes. Defina suas propriedades conforme foi feito no relatório anterior.
DataText
Text Text
Figura 100 A banda GroupHeader
124
A banda GroupHeader terá a aparência da Figura 100. Insira os componentes

conforme mostrado na figura. Lembre que, para definir um DataText, você deve arrastar
o campo a partir da Árvore de Objetos segurando a tecla CTRL. Na aba Drawing
selecione um componente HLine e o insira na parte de baixo da banda GroupHeader.
Redimensione-o para ocupar a largura da página.
Insira os campos DataText na banda detalhe de maneira que ela fique com a
aparência mostrada na figura abaixo:
Figura 101 A aparência final do desenho do relatório
Salve o projeto. Pressione a tecla F9 para visualizar uma prévia do relatório.
Figura 102 Prévia do relatório
Para executar o relatório no Delphi, no menu principal selecione Relatórios |

Cliente e digite o seguinte código no método do evento OnClick:
dmDados.rvVendas.ExecuteReport('rptCliente');
125

Linguagem de Programação Comercial

Загружено:

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

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

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

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

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

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

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

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

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

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

Linguagem de Programação Comercial

Загружено:

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

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

CARLOS ALBERTO PEDROSO ARAÚJO

Figura 1 Form novo........................................................................................................ 10

Figura 49 Caixa de diálogo InputBox ............................................................................. 56

Figura 101 A aparência final do desenho do relatório.................................................. 125

Quadro 1 Propriedades, métodos e eventos de Form ..................................................... 38

Aceitando entrada de dados do Usuário (TEdit)..................................................... 39

Relatório de Cidades............................................................................................. 117

Delphi é considerada uma ferramenta RAD (Rapid Application Development). E

Capítulo 1 Um form é uma janela

Criando seu primeiro form

Figura 1 Form novo

Figura 2 Object Inspector

O Object Inspector mostra as propriedades do componente selecionado. A

Figura 3 Paleta de Componentes

Há quatro maneiras de colocar componentes em um form. Selecione o

• Clique no componente, mova o cursor do mouse para o form, pressione o

Queremos apenas um botão no form. Vamos centralizá-lo manualmente.

Figura 4 Botões de Alinhamento

É bastante comum definir uma convenção de nomes para cada tipo de

• Um identificador é uma seqüência de letras, dígitos ou underscore de

Se você executar esse programa agora, verá que o botão funciona

• Selecione o botão e a aba Events no Object Inspector. Dê um duplo clique

Com qualquer uma dessas abordagens o Delphi cria um procedure chamado

Figura 5 Método manipulador de evento OnClick de botão

Como vimos, a ação padrão para um botão é adicionar um manipulador para

Figura 6 Código do procedure

Figura 7 Caixa de mensagem

Figura 8 Método manipulador do evento OnClick de form

Compilando e Executando um Programa

1. Compila o código fonte Pascal que descreve o form.

Figura 9 Opções de Projeto

Packages são bibliotecas de ligação dinâmicas (dll) contendo os componentes

entanto o programa não executará se as dlls apropriadas não estiverem disponíveis no

Alterando Propriedades em Tempo de Execução

Figura 10 Alterando propriedade em tempo de execução

Portanto, para mudar uma propriedade como Caption em tempo de execução,

Adicionando Código ao Programa

Figura 11 Código para centralizar o botão em tempo de execução

Para determinar as propriedades Top e Left do botão - isto é, a posição do seu

Uma Ferramenta de Mão Dupla (Two-Way)

Analisando o código fonte

Figura 12 Código fonte de um form

Se você renomeou os arquivos como sugerimos no exemplo anterior, o código

Figura 13 Unit com novo nome

Assim que você começa a adicionar novos componentes, a declaração da classe

Figura 14 Código após adicionar um botão

Figura 15 Código após alterar a propriedade Name do botão

A alteração de outras propriedades não afeta o código fonte. As propriedades de

Figura 16 Código com manipuladores de eventos

A descrição textual do form

Figura 17 Descrição textual do form

Figura 18 Project Manager

O arquivo de projeto é na verdade um arquivo fonte Pascal, descrevendo a

Figura 19 Código fonte do arquivo de projeto

Podemos visualizar esse arquivo através do comando de menu View | Project

Capítulo 2 O Ambiente Delphi

Menus e Comandos do Delphi

A seguir algumas sugestões para usar alguns comandos de menu. Algumas

Reopen: atalho para a abertura dos últimos projetos e arquivos abertos

Figura 20 Descrição textual de um botão

Agora se você alterar o nome (Name) do objeto, rótulo (Caption) ou posição

Figura 21 Mudanças na descrição textual usando um editor qualquer

Copiando a descrição acima e colando-a em um form irá criar um botão na

válidas, e como definir os valores das propriedades, principalmente o tipo de dado.