Académique Documents
Professionnel Documents
Culture Documents
LINGUAGEM DE PROGRAMAÇÃO
COMERCIAL
Santarém
2009
Linguagem de Programação Comercial
Lista de Ilustrações
2
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
3
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
4
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
Lista de Quadros
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
7
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
8
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
Introdução
9
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
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
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.
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
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:
13
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
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:
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
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.
15
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
16
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
17
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
Agora se a propriedade Name do botão for alterada para btnAlo, o código muda
para:
18
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
19
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
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.
21
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
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.
• Usar o menu.
• Usar a barra de ferramentas.
• Usar os menus ativados pressionando o botão direito do mouse.
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
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:
23
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
O menu Search
Este menu tem alguns comandos padrão também, tais como Search and
Replace, e o Find in Files:
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
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.
26
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
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
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:
29
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
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:
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.
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:
31
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
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.
32
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
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.
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
34
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
35
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
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.
37
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
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.
38
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
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.
39
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
40
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
41
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
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.
43
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
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
45
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
Existem outros valores para essa propriedade, mas apenas essas são de nosso
interesse.
46
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
47
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
48
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
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
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.
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
ShowMessage
Declarada internamente pelo Delphi da seguinte forma:
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:
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
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:
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.
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:
54
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
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;
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 é:
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.
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;
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:
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;
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
59
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
• 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.
60
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
lblTexto.Alignment := taLeftJustify;
lblTexto.Alignment := taCenter;
lblTexto.Alignment := taRightJustify;
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
Arquivo
Sair
Exibir
Barra de ferramentas
Opções
Cor do texto
Cor do fundo
Esquerda
Centro
Direita
Ajuda
Sobre
62
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
Novo menu
Sub-menu
63
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
Close;
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;
lblTexto.Alignment := taCenter;
Esquerda1.Checked := False;
Centro1.Checked := True;
Direita1.Checked := False;
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;
• 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.
frmSobre.ShowModal;
66
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
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
68
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
69
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
70
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
tbuEsquerda.Down := True;
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:
71
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
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.
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
73
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
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
75
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
• 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.
76
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
edNome.Text := '';
edEndereco.Text := '';
edTelefone.Text := '';
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
78
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
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:
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;
80
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
btnIniciar.Enabled := False;
end;
81
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
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:
82
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
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.
83
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
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.
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
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
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.
Figura 72 DataModule
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.
uses u_dmdados;
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.
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:
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;
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
92
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
93
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
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.
94
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
dmDados.tbCidade.Open;
dmDados.tbCliente.Open;
dmDados.tbCidade.Close;
dmDados.tbCliente.Close;
95
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
frmCliente.Show;
uses u_dmdados;
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
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
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.
98
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
Clique com o botão direito do mouse na janela e selecione Add all fields. Todos
os campos da tabela serão adicionados.
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
interface
uses
Windows, Messages, SysUtils, Classes, Graphics,
Controls, Forms, Dialogs, Grids, DBGrids,
StdCtrls, ExtCtrls, DB;
dmDados.tbCidade.Open;
dmDados.tbCidade.Close;
frmConsCidade.Show;
100
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
uses u_dmdados;
101
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
frmConsCliente.Show;
102
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
103
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
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
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
user_name=sysdba
password=masterkey
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
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:
106
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
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:
107
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
Form mestre-detalhe
Vamos analisar uma nota fiscal:
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.
109
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
uses u_dmdados;
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
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:
111
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
A interface, após todas essas definições deverá ter o aspecto mostrado na Figura
82.
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;
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.
procedure TdmDados.tbiItemCalcFields(DataSet:
TDataSet);
begin
if tbiProduto.Locate('ID_PRODUTO',
tbiItemID_PRODUTO.Value, []) then
tbiItemTOTAL.Value := tbiItemQUANTIDADE.Value *
tbiProdutoPRECO_VENDA.Value;
end;
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:
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.
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.
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.
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:
117
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
Barra de
Ferramentas
Árvore de
objetos
Painel de
Propriedades A Página
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
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.
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
Componente
Region
Rodapé da
página
Band e
DataBand
120
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
121
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
Text
122
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
dmDados.rvVendas.ExecuteReport('rptCidade');
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:
123
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
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
DataText
Text Text
124
Centro Universitário Luterano de Santarém
Linguagem de Programação Comercial
dmDados.rvVendas.ExecuteReport('rptCliente');
125
Centro Universitário Luterano de Santarém