Вы находитесь на странице: 1из 125

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
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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


Figura 102 Prévia do relatório ...................................................................................... 125

4
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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


Relatório de Clientes ............................................................................................ 123

8
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

É 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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

• 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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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.

Propriedade Conteúdo Descrição


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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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.

Propriedade Conteúdo Descrição


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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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

Propriedade Conteúdo Descrição


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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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

Propriedade Conteúdo Descrição


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
OnEnter Quando o controle recebe o foco
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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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.

Propriedade Conteúdo Descrição


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
SetFocus Muda o foco para o controle
Evento Descrição
OnClick Quando o controle é clicado
OnEnter Quando o controle recebe o foco
OnExit Quando o foco sai do controle e vai para outro
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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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.

Propriedade Conteúdo Descrição


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
SetFocus Muda o foco para o controle

44
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

Evento Descrição
OnClick Quando o controle é clicado
OnEnter Quando o controle recebe o foco
OnExit Quando o foco sai do controle e vai para outro
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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

• 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.

Propriedade Conteúdo Descrição


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
SetFocus Muda o foco para o controle
Evento Descrição
OnChange Quando o conteúdo do controle é modificado
OnClick Quando o controle é clicado
OnEnter Quando o controle recebe o foco
OnExit Quando o foco sai do controle e vai para outro
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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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.

Propriedade Conteúdo Descrição


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
SetFocus Muda o foco para o controle
Evento Descrição
OnChange Quando posição da barra é modificada
OnScroll Quando a barra é rolada
OnEnter Quando o controle recebe o foco
OnExit Quando o foco sai do controle e vai para outro
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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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.

Propriedade Conteúdo Descrição


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
SetFocus Muda o foco para o controle
Evento Descrição
OnChange Quando o texto no controle é modificado
OnEnter Quando o controle recebe o foco
OnExit Quando o foco sai do controle e vai para outro
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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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.

Propriedade Conteúdo Descrição


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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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.

Propriedade Conteúdo Descrição


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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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;
if dlgCores.Execute then
lblTexto.Color := dlgCores.Color;

61
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

&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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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;
if dlgCores.Execute then
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:

lblTexto.Alignment := taLeftJustify;
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;
Direita1.Checked := False;

Em Opções | Direita digite o seguinte código:

lblTexto.Alignment := taRightJustify;
Esquerda1.Checked := False;
Centro1.Checked := False;
Direita1.Checked := True;

65
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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:

lblTexto.Alignment := taLeftJustify;
Esquerda1.Checked := True;
Esquerda2.Checked := True;
Centro1.Checked := False;
Centro2.Checked := False;
Direita1.Checked := False;
Direita2.Checked := False;

67
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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:

Propriedade Conteúdo Descrição


+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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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:

Propriedade Conteúdo Descrição


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:

Propriedade Conteúdo Descrição


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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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.

Propriedade Conteúdo Descrição


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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

Figura 60 Barra de status

73
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Propriedade Conteúdo
Name edNome
Text
Width 280

Label
Propriedade Conteúdo
Caption Endereço

74
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

Edit
Propriedade Conteúdo
Name edEndereco
Text
Width 280

Label
Propriedade Conteúdo
Caption Telefone

Edit
Propriedade Conteúdo
Name edTelefone
Text
Width 120

GroupBox
Propriedade Conteúdo
Caption Escrita

Button
Propriedade Conteúdo
Caption &Novo
Name btnNovo

Button
Propriedade Conteúdo
Caption &Salvar
Name btnSalvar

A janela deverá ficar como a figura a seguir:

Figura 61 Interface da aplicação

75
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

GroupBox
Propriedade Conteúdo
Caption Leitura

Button
Propriedade Conteúdo
Caption &Iniciar
Name btnIniciar

Button
Propriedade Conteúdo
Caption &Próximo
Name btnProximo

Button
Propriedade Conteúdo
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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

• 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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

de dados através do Alias ou informando-se diretamente o caminho onde estão


localizadas as tabelas.

Propriedade Conteúdo Descrição


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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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.

Propriedade Conteúdo Descrição


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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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.

Propriedade Conteúdo Descrição


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
SetFocus Muda o foco para o controle
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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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.

Propriedade Conteúdo Descrição


ConfirmDelete True Determina se uma mensagem de confirmação
de exclusão de registro será mostrada
DataSource dmDados.dsCidade Define o DataSource da tabela
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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

Label
Propriedade Conteúdo
Caption Id

DBEdit
Propriedade Conteúdo
CharCase ecNormal
DataField IdCliente
DataSource dsCliente
Name dbeId
Width 75

Label
Propriedade Conteúdo
Caption Nome

DBEdit
Propriedade Conteúdo
CharCase ecNormal
DataField Nome
DataSource dsCliente
Name dbeNome
Width 290

Label
Propriedade Conteúdo
Caption Endereço

DBEdit
Propriedade Conteúdo
CharCase ecNormal
DataField Endereco
DataSource dsCliente
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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

Propriedade Conteúdo Descrição


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
Métodos Descrição
SetFocus Muda o foco para o controle
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 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.

Propriedade Conteúdo Descrição


DataField Estado Define o campo da tabela que será
manipulado pelo controle
DataSource dmDados.dsCliente Define o DataSource da tabela
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
Métodos Descrição
SetFocus Muda o foco para o controle
Evento Descrição
OnChange Acontece quando o texto do controle é
modificado
OnClick Ocorre quando o usuário clica no controle
OnEnter Acontece quando o controle recebe o foco
OnExit Acontece quando o foco sai do controle
Quadro 26 Propriedades, métodos e eventos de DBComboBox

93
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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.

Propriedade Conteúdo Descrição


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á
manipulado pelo controle
DataSource dmDados.dsCliente Define o DataSource da tabela
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
Métodos Descrição
SetFocus Muda o foco para o controle
Evento Descrição
OnChange Acontece quando o texto do controle é
modificado
OnClick Ocorre quando o usuário clica no controle
OnEnter Acontece quando o controle recebe o foco
OnExit Acontece quando o foco sai do controle
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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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.

Propriedade Conteúdo Descrição


Caption Situação Define a legenda do controle
DataField Situacao Define o campo da tabela que será
manipulado pelo controle
DataSource dmDados.dsCliente Define o DataSource da tabela
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
Métodos Descrição
SetFocus Muda o foco para o controle
Evento Descrição
OnChange Acontece quando o texto do controle é
modificado
OnClick Ocorre quando o usuário clica no controle
OnEnter Acontece quando o controle recebe o foco
OnExit Acontece quando o foco sai do controle
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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

RadioGroup
Propriedade Conteúdo
Caption Pesquisar por:
ItemIndex 0
Items Código
Nome
Name rgCampo

Edit
Propriedade Conteúdo
Name edValor
Text

Button
Propriedade Conteúdo
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:

Propriedade Conteúdo Descrição


Columns Descreve os atributos de apresentação dos
campos da tabela
DataSource dmDados.dsCidade Define o DataSource da tabela
Name dbgCidade Define o identificador do controle
+TitleFont Define características da fonte dos títulos das

97
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

colunas da grade
Métodos Descrição
SetFocus Muda o foco para o controle
Evento Descrição
OnEnter Acontece quando o controle recebe o foco
OnExit Acontece quando o foco sai do controle
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.

Propriedade Conteúdo Descrição


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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
cláusula uses, de forma que fique assim:

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

Propriedade Conteúdo Descrição


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
Métodos Descrição
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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
cláusula uses, de forma que fique assim:

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

Propriedade Conteúdo Descrição


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
Métodos Descrição
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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

componente desses na aba Interbase e o coloque no Data Module. A seguir as


propriedades e métodos de TIBTransaction.

Propriedade Conteúdo Descrição


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
Métodos Descriçã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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Propriedade Conteúdo
Caption Id

DBEdit
Propriedade Conteúdo
CharCase ecNormal
DataField Id_Venda
DataSource dmDados.dsVenda
Name dbeId_Venda
Width 75

Label
Propriedade Conteúdo
Caption Data

DBEdit
Propriedade Conteúdo
CharCase ecNormal
DataField Data_Venda
DataSource dmDados.dsVenda
Name dbeData_Venda
Width 100

Label
Propriedade Conteúdo
Caption Cliente

DBLookupComboBox
Propriedade Conteúdo
DataField Id_Cliente
DataSource dmDados.dsVenda
KeyField Id_Cliente
ListField Nome
ListSource dmDados.dsCliente
Name dblId_Cliente
Width 200

DBRadioGroup
Propriedade Conteúdo

110
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

Caption Tipo de Venda


Columns 2
DataField Tipo
DataSource dmDados.dsVenda
Height 40
Items Venda à vista
Venda à prazo
Name dbrTipo
Values V
P
Width 240

Label
Propriedade Conteúdo
Caption Valor

DBEdit
Propriedade Conteúdo
CharCase ecNormal
DataField Valor_Venda
DataSource dmDados.dsVenda
Name dbeValor_Venda
Width 150

DBNavigator
Propriedade Conteúdo
DataSource dmDados.dsVenda

GroupBox
Propriedade Conteúdo
Caption Itens

DBGrid
Propriedade Conteúdo
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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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:

Propriedade Conteúdo Descrição


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:

Propriedade Conteúdo Descrição


Engine rvsysVendas Define um motor de relatório
Name rvVendas Define o nome do componente
Quadro 35 Propriedades do componente RvProject

117
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

Insira um componente RvDataSetConnection. Este componente exporta um


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

Propriedade Conteúdo Descrição


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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Propriedade Conteúdo
DataView dvCliente
Name Detalhe

Band
Propriedade Conteúdo
BandStyle Selecione Body Header e First
ControllerBand Detalhe
Name PageHeader

Band
Propriedade Conteúdo
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
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial

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
Centro Universitário Luterano de Santarém