Linguagem de Programação Comercial

CARLOS ALBERTO PEDROSO ARAÚJO

LINGUAGEM DE PROGRAMAÇÃO COMERCIAL

Santarém

2009

Centro Universitário Luterano de Santarém

2

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


3


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


4


Figura 101 A aparência final do desenho do relatório.................................................. 125 Figura 102 Prévia do relatório ...................................................................................... 125


5


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


6


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


7


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


8


Relatório de Cidades............................................................................................. 117 Relatório de Clientes ............................................................................................ 123


9


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.


10


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


11


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


12


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.


13


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


14


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:


15


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


16


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:


17


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.


18


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


19


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


20


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


21


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.


22


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


23


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:

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

object btnAlo: TButton Left = 200

Top = 200

Width = 180

Height = 60

TabOrder = 0

Caption = 'My Button'

Font.Name = 'Arial'

end


24


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


25


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:


26


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


27


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.


28


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.


29


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.


30


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


31


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


32


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


33


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.


34


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)


35


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.


36


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


37


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


38


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


39


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.


40


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


41


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.


42


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


43


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

Feminino Lista de opções

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.


44


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


45


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:


46


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


47


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 sbHorizontal Especifica 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.


48


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


49


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.


50


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


51


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: Extended)

Formata um Ponto Flutuante retornando um String de acordo com o formato

Quadro 12 Funções de conversão de dados


52


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),


53


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:


54


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.


55


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:


56


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',


57


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,


58


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.


59


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


60


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


61


Insira cinco botões (TButton) e os posicione adequadamente no Panel. No primeiro defina Name como btnFonte e Caption como Cor &Texto... No segundo defina Name como btnFundo e Caption como Cor &Fundo... No terceiro defina Name como btnEsquerda e Caption como &Esquerda. No quarto defina Name como btnCentro e Caption como &Centro. No último defina Name como btnDireita e Caption como &Direita. A janela deve ficar como a Figura 52. Os três últimos botões mudam o alinhamento (Alignment) do rótulo. Então vamos escrever o código para os eventos OnClick desses botões. Dê um duplo clique em cada um deles. Para btnEsquerda digite no editor de código:

lblTexto.Alignment := taLeftJustify; Para btnCentro digite: lblTexto.Alignment := taCenter; E para btnDireita digite: lblTexto.Alignment := taRightJustify;

Você pode verificar a funcionalidade dos botões executando a aplicação e pressionando cada um deles e observando seus efeitos sobre o texto do rótulo.

A Caixa de Diálogo ColorDialog

Vamos inserir na nossa aplicação um componente denominado ColorDialog. Esse componente serve para apresentar a caixa de diálogo para seleção de cores padrão do ambiente Windows. Localize-o na aba Dialogs. Pode ser colocado em qualquer lugar da janela, pois não é um componente visual, ou seja, não será visível quando o programa for executado. Será invocado em tempo de execução pelos dois primeiros botões, por isso eles têm os três pontos no Caption, para indicar a chamada a uma caixa de diálogo. Vamos mudar a propriedade Name do componente. Defina-a como dlgCores.

Queremos que, quando pressionados, os dois primeiros botões chamem a caixa de diálogo dlgCores. Nessa caixa selecionamos a cor desejada e quando pressionarmos o botão OK, a cor será atribuída à propriedade Color do rótulo ou à propriedade Color de Font.

Dê um duplo clique no botão btnFonte e digite o seguinte código no editor: dlgCores.Color := lblTexto.Font.Color;

if dlgCores.Execute then

lblTexto.Font.Color := dlgCores.Color;

Na primeira linha fazemos com que a caixa de diálogo seja mostrada com a cor

do texto. Depois executamos a caixa de diálogo e, se o usuário pressionar o botão OK, a cor do texto do rótulo é modificada. O método Execute de ColorDialog retorna True se for pressionado o botão OK ou False se for pressionado o botão Cancel. Vamos fazer o mesmo com o botão btnFundo e digitar o seguinte código no editor:

dlgCores.Color := lblTexto.Color;


lblTexto.Color := dlgCores.Color;


62


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


63


&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:

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

Novo menu

Sub-menu


64


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;


65


A primeira linha muda a visibilidade da barra de ferramentas que foi criada pelo componente Panel. A segunda linha marca/desmarca o item de menu de acordo com a visibilidade do painel. No comando Opções | Cor do texto digite o seguinte código para o evento OnClick: dlgCores.Color := lblTexto.Font.Color;


lblTexto.Font.Color := dlgCores.Color; Note que este código é exatamente o mesmo programado para o evento OnClick do botão btnFonte. Na verdade não precisamos replicar esse código aqui, mas vamos manter dessa forma por questões didáticas. Mostraremos como reutilizar o código do evento de um componente em outro. Observe que o código do comando Opções | Cor de fundo é o mesmo do evento OnClick do botão btnFundo. Então selecione esta opção no Menu Designer e vá para a aba Events no Object Inspector. Clique no botão com a seta do evento OnClick para ver todos os eventos disponíveis. Selecione btnFundoClick. Pronto, agora o comando do menu chamará o mesmo código do evento OnClick do botão btnFundo. Os outros três itens do menu Opções têm basicamente o mesmo código dos botões de alinhamento. No entanto devemos acrescentar uma marca de verificação ao lado do item que estiver habilitado, desmarcando os demais. Inicialmente, no Menu

Designer, selecione Opções | Esquerda e altere a propriedade Checked para True. Essa é a nossa situação padrão. Sempre que a aplicação iniciar o texto estará alinhado à esquerda. Em seguida vamos escrever o código para o comando em questão. Selecione o evento OnClick do item de menu e dê um duplo clique nele. Digite então o seguinte código: 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;


Direita1.Checked := True;


66


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


67


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;





Direita1.Checked := False; Direita2.Checked := False;


68


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


69


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 ebTop ebRight ebBottom

False True False True

Define bordas para a barra de ferramentas. Nesse caso, definimos que haverá bordas no topo e na base

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.


70


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.


71


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

da Silva Define o texto que irá aparecer no painel

Width 400 Define a largura do painel Quadro 16 Propriedades de TStatusPanel


72


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.


73


Figura 60 Barra de status


74


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


75


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


76


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


77


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:


78


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.


79


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


80


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;


81


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.


82


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


83


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:


84


• 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


85


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.


86


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


87


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.


88


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.


89


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


90


TDBNavigator

Este controle reúne um conjunto de botões que movem o ponteiro da tabela para frente ou para trás. Pode também colocar a tabela no estado Insert, Edit ou Browse e gravar registro inseridos ou modificados.


ConfirmDelete True Determina se uma mensagem de confirmação de exclusão de registro será mostrada

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


91


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:


92


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.


93


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



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



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


94


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



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.


95


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


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;


96


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:


97


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


98


colunas da grade Métodos 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:


99


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');


100


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:


101


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


102


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;


103


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);


104


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:


105



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


106


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;


107


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;


108


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


109


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.


110


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


111


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:


112


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:


113


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


114


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


115


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


116


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.


117


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


118


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.

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.

Painel de Propriedades A Página

Árvore de objetos

Paletas de Componentes

Barra de Ferramentas


119


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


120


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.

Figura 91 Componente Region

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.

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.

Componente Region

Rodapé da página

Region

Band e DataBand


121


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.


122


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

Text


123


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.


124


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.

Figura 100 A banda GroupHeader

Text Text

DataText


125


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');

Linguagem de Programação Comercial

Documents

Transcript of Linguagem de Programação Comercial