Material Delphi diego
Upcoming SlideShare
Loading in...5
×
 

Material Delphi diego

on

  • 2,762 views

 

Statistics

Views

Total Views
2,762
Views on SlideShare
2,762
Embed Views
0

Actions

Likes
1
Downloads
222
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    Material Delphi diego Material Delphi diego Document Transcript

    • Índice 1 INTRODUÇÃO AO AMBIENTE DELPHI® ................................................. 2 1.1 AMBIENTE DELPHI ........................................................................ 2 1.2 TIPOS DE ARQUIVOS GERADOS PELO D ELPHI .............................................. 2 1.2.1 Units (.pas) ..................................................................................................................................... 2 1.2.2 Estrutura das units...................................................................................................................... 2 1.2.3 Forms (.dfm) .................................................................................................................................. 3 1.2.4 Projeto (.dpr)................................................................................................................................. 3 1.2.5 Esquema da estrutura dos arquivos ........................................................................................ 3 1.2.6 Outros tipos de arquivos............................................................................................................ 4 1.3 ÁREA DE TRABALHO ....................................................................... 4 1.3.1 Menus ............................................................................................................................................... 5 1.3.2 Botões de atalho........................................................................................................................... 5 1.3.3 Paleta de componentes ............................................................................................................... 5 1.3.4 Object Inspector ......................................................................................................................... 5 1.3.4.1 Properties (aba) .........................................................................................................................................5 1.3.4.2 Events (aba).................................................................................................................................................7 1.3.5 Form (Formulários) ...................................................................................................................... 8 1.3.6 Unit ................................................................................................................................................... 9 1.3.6.1 Estrutura de uma unit ..............................................................................................................................9 1.4 PROGRAMANDO NO AMBIENTE D ELPHI ..................................................... 9 1.4.1 Principais tipos de dados do ambiente Delphi ..................................................................... 9 1.4.2 Conversão de tipos ..................................................................................................................... 10 1.4.3 Declaração de variáveis............................................................................................................ 10 1.4.3.1 Variáveis globais....................................................................................................................................... 10 1.4.3.2 Variáveis locais ......................................................................................................................................... 11 1.4.4 Declaração de procedimentos e funções ............................................................................. 11 1.4.5 Tratamento de erros (exceções) .......................................................................................... 13 1.4.5.1 Bloco Try ... Except ................................................................................................................................. 13 1.4.5.2 Bloco Try... Finally ................................................................................................................................... 13 1.4.6 Depurando a aplicação (debugger) ........................................................................................ 14 1.4.6.1 Breakpoints ................................................................................................................................................ 14 1.4.6.2 Watches ..................................................................................................................................................... 15 1.5 TRABALHANDO COM COMPONENTES ......................................................15 1.5.1 Paleta de componentes (Component palette’s) .................................................................. 15 1.5.2 Propriedades................................................................................................................................ 16 1.5.3 Eventos (Events) ........................................................................................................................ 16 1.5.4 Métodos ........................................................................................................................................ 16 2 BANCO DE DADOS INTERBASE®........................................................18 2.1 INTRODUÇÃO ............................................................................18 2.2 BANCO DE DADOS INTERBASE ............................................................18 2.3 SQL DML (DATA MANIPULATION LANGUAGE) ...........................................18 2.3.1 Cláusula Select (“selecione”)................................................................................................... 19 2.3.2 Cláusula From (“origem”) .......................................................................................................... 19 Prof. Eduardo Cotrin Teixeira
    • 2.3.3 Cláusula Where (“onde”)........................................................................................................... 20 2.3.4 Cláusula Order By ...................................................................................................................... 21 2.3.5 Operadores .................................................................................................................................. 21 2.3.5.1 Operadores de comparação .................................................................................................................. 21 2.3.5.2 Operadores lógicos ............................................................................................................................ 22 2.4 SQL DDL (D ATA DEFINITION LANGUAGE) ..............................................22 2.4.1 Criando um banco de dados Interbase ................................................................................ 23 2.4.2 Interbase Interactive SQL .................................................................................................... 25 2.4.3 Criando tabelas no Interbase................................................................................................. 25 3 DESENVOLVENDO UM APLICATIVO COM BANCO DE DADOS (INTERBASE).......28 3.1 INICIANDO UMA NOVA APLICAÇÃO ......................................................28 3.2 CONFIGURANDO OPÇÕES DO PROJETO ....................................................29 3.3 DEFININDO O MENU DO FORMULÁRIO PRINCIPAL .........................................29 3.4 CONECTANDO O APLICATIVO (D ELPHI) AO INTERBASE ...................................32 3.4.1 O que são Data Modules?......................................................................................................... 32 3.5 CONECTANDO AO B ANCO.GDB ............................................................32 3.6 TRANSAÇÕES E ACESSO CONCORRENTE EM BANCO DE DADOS .............................34 3.6.1 Controlando transações através do componente IBTransaction ................................. 34 3.7 ADICIONADO AS TABELAS DO BANCO DE DADOS .........................................34 3.7.1 Conectando a tabela Departamento ..................................................................................... 34 3.7.2 Conectando a tabela Dependentes........................................................................................ 35 3.7.3 Conectando a tabela Estados.................................................................................................. 35 3.7.4 Conectando a tabela Funcionários ......................................................................................... 36 3.8 ADICIONANDO OS CAMPOS DAS TABELAS ................................................37 3.9 ADICIONADO CAMPOS L OOKUPS ..........................................................39 3.10 CADASTRO DE ESTADOS ...............................................................41 3.10.1 Habilitando e Desabilitando os botões da barra .............................................................. 44 3.10.2 Adicionando os códigos dos botões da barra..................................................................... 45 3.10.3 Adicionando código do formulário ......................................................................................... 46 3.10.4 Validações de dados .................................................................................................................. 47 3.10.4.1 Verificando a existência chave primária: ................................................................................... 47 3.10.4.2 Verificando os campos de preenchimento obrigatório ........................................................... 50 3.10.5 Pesquisa do Cadastro de Estados .......................................................................................... 51 3.11 CONSTRUINDO FORMULÁRIOS MODELOS (REPOSITÓRIO) ...............................56 3.11.1 Adicionando o formulário de Cadastro Estados ao Repositório ................................... 56 3.11.2 Adicionando o formulário de Pesquisa de Estados ao Repositório .............................. 56 3.12 CADASTRO DE DEPARTAMENTO ........................................................56 3.12.1 Pesquisa do Cadastro de Departamento .............................................................................. 58 3.13 CADASTRO DE FUNCIONÁRIOS .........................................................60 3.13.1 Pesquisa do Cadastro de Funcionários ................................................................................. 63 3.14 CADASTRO DE DEPENDENTES ..........................................................66 3.14.1 Definindo a tabela Dependente como detalhe da tabela Funcionário ........................ 68 3.14.2 Quando posso aplicar o recurso mestre-detalhe ? .......................................................... 68 4 RELATÓRIOS ...............................................................................70 4.1 ELABORANDO RELATÓRIO SIMPLES (RELATÓRIO DE E STADOS)............................70 Prof. Eduardo Cotrin Teixeira
    • 4.2 ELABORANDO RELATÓRIO MESTRE-DETALHE (FUNCIONÁRIO E SEUS DEPENDENTES) ......73 4.3 UTILIZANDO QUERY PARA ELABORAR RELATÓRIO DE SOMA DE SALÁRIOS POR D EPARTAMENTO ................................................................................77 5 RELACIONANDO O APLICATIVO A AJUDA ON-LINE (F1)...........................82 5.1 DEFININDO O ARQUIVO DE AJUDA DO APLICATIVO ......................................82 5.2 DEFININDO A AJUDA CONTEXTUAL (F1) .................................................82 5.3 ATIVANDO A AJUDA PELO FORMULÁRIO PRINCIPAL .......................................82 6 CONSTRUINDO O INSTALADOR ........................................................83 6.1 CRIANDO O PROJETO DE INSTALAÇÃO ...................................................83 6.2 CONFIGURANDO AS OPÇÕES DE INSTALAÇÃO .............................................83 6.2.1 Configurando o grupo Set the Visual Design ..................................................................... 84 6.2.2 Configurando o grupo Specify Components and Files ..................................................... 85 6.2.3 Configurando o grupo Select User Interface Components........................................... 86 6.2.4 Configurando o grupo Specify Folders and Icons ............................................................ 86 6.2.5 Configurando o grupo Run Disk Builder ............................................................................... 87 6.2.6 Grupo Create Distribution Media.......................................................................................... 87 7 REFERÊNCIAS BIBLIOGRÁFICAS ........................................................89 Prof. Eduardo Cotrin Teixeira
    • Índice de Figuras Figura 1 – Área de Trabalho............................................................................................................................... 4 Figura 2 – Utilizando breakpoints .................................................................................................................. 14 Figura 3 – Janela Watch List .......................................................................................................................... 15 Figura 4 – Paleta de componentes .................................................................................................................. 16 Figura 5 – Estrutura de diretórios utilizada para o desenvolvimento do aplicativo ....................... 23 Figura 6 – Janela Create Database ............................................................................................................... 23 Figura 7 – Janela Register Database ............................................................................................................ 24 Figura 8 – Modelagem de um sistema para cadastrar funcionários..................................................... 25 Figura 9 – Data Module ..................................................................................................................................... 32 Figura 10 – Janela Database Component Editor ........................................................................................ 33 Figura 11 – Data Module DM_Funcionarios com os componentes ......................................................... 36 Figura 12 – Definição de campo Lookup na tabela funcionário .............................................................. 40 Figura 13 – Formulário de Cadastro de Estados ........................................................................................ 41 Figura 14 – Barra de botões............................................................................................................................. 44 Figura 15 – Formulário de Pesquisa de Estados ......................................................................................... 51 Figura 16 – Formulário de Cadastro de Departamentos .......................................................................... 57 Figura 17 – Formulário de Pesquisa de Departamentos ........................................................................... 58 Figura 18 – Formulário de Cadastro de Funcionários ............................................................................... 61 Figura 19 – Formulário de Pesquisa de Funcionários................................................................................. 63 Figura 20 – Cadastro de Dependentes ......................................................................................................... 66 Figura 21 – Relatório de Estados.................................................................................................................... 70 Figura 22 – Relatório de Funcionários e Dependentes ............................................................................ 73 Figura 23 – Relatório da soma de Salários por Departamento.............................................................. 78 Figura 24 – Tela inicial do InstallShield ...................................................................................................... 83 Figura 25 – Tela de opções de configuração de projeto ......................................................................... 84 Figura 26 – Janelas lado a lado ....................................................................................................................... 86 Figura 27 – Grupos de arquivos da instalação ............................................................................................ 86 Figura 28 – Componentes de Interface ....................................................................................................... 87 Prof. Eduardo Cotrin Teixeira
    • 1 ADVERTÊNCIA Esta apostila aborda o ambiente Delphi através do desenvolvimento de um aplicativo de controle de funcionários. Para que os resultados sejam alcançados, é fundamental que os passos sejam seguidos a risca (nomes de diretórios, nomes de arquivos, nomes de tabelas, nomes de componentes, etc). DIREITOS AUTORAIS Todos os direitos reservados e protegidos pela Lei 5988 de 14/12/1973. Nenhuma parte desta apostila, sem autorização prévia por escrito do autor, poderá ser reproduzida ou transmitida sejam quais forem os meios empregados: eletrônicos, mecânicos, fotográficos, gravação ou quaisquer outros. Todo esforço foi feito para fornecer a mais completa e adequada informação. Contudo, o autor não assume responsabilidade pelos resultados e uso da informação fornecida. Recomendo aos leitores testar a informação antes da efetiva utilização. MARCAS REGISTRADAS Todos os termos mencionados nesta apostila conhecidos como marcas registradas ou de serviços foram devidamente apresentados na forma iniciada por maiúscula. O uso de termos nesta apostila não deve ser considerado como infração a validade das marcas registradas ou de serviços. Delphi é marca registrada da Borland Corporation. Interbase é marca registrada da Interbase Software Corporation. InstallShield é marca registrada da InstallShield Corporation. Windows é marca registrada da Microsoft Corporation. No caso de erros, omissões, etc , favor enviar e-mail para: cotrin@utfpr.edu.br Autor do material original (Delphi 5): Prof. Edson dos Santos Cordeiro-Unopar Londrina, 2000 Esta adaptação (Delphi 7): Prof. Eduardo Cotrin Teixeira - UTFPR Cornélio Procópio, 2007
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 2 1 INTRODUÇÃO AO AMBIENTE DELPHI® 1.1 Ambiente Delphi O desenvolvimento de software com qualidade e rapidez constitui-se em requisitos indispensáveis exigidos pelo mercado. Dentre as inúmeras ferramentas de desenvolvimento, o ambiente Delphi tem se destacado pela rapidez e grande número de recursos oferecidos ao desenvolvedor. Classificado como uma ferramenta RAD (Rapid Application Development), o ambiente Delphi oferece uma série de recursos que agilizam e facilitam o desenvolvimento de aplicativos. Além disso, o suporte que o ambiente oferece para acesso a diversos bancos de dados chamou a atenção da comunidade de desenvolvedores fazendo com que a ferramenta, em pouco tempo, fosse adotada por milhões de programadores no mundo todo. 1.2 Tipos de arquivos gerados pelo Delphi 1.2.1 Units (.pas) Um programa é construído através de módulos de código fonte chamados de units. Cada unit é armazenada em seu próprio arquivo (.PAS) e compilada separadamente, gerando um arquivo .DCU (Dephi Compiled Unit). Os arquivos de units compilados (.DCU) são unidos (linked) para criar uma aplicação. As units permitem: Dividir um programa em diversos módulos que podem ser editados separadamente; Criar bibliotecas que poder ser compartilhadas entre diversas aplicações; Distribuir bibliotecas para outros desenvolvedores sem disponibilizar o código fonte. 1.2.2 Estrutura das units unit Unit1; {identificação da unit} interface uses SysUtils, Windows, Messages, Classes, Graphics, Controls, Forms, Dialogs; {Cláusula uses} type TForm1 = class(TForm) {Declaração de classe} private { Private declarations } {Declarações privadas} public { Public declarations } {Declarações públicas} end; var Form1: TForm1; {declaração de instância - objeto} implementation {$R *.DFM} {diretiva do compilador para “unir - link” o formulário a unit} end. {finaliza a unit} Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 3 1.2.3 Forms (.dfm) Formulários (forms) são a parte visível de uma aplicação Delphi. Arquivos de formulários (extensão .dfm) descrevem cada componente presente no formulário, incluindo os valores de suas propriedades. Cada formulário em uma aplicação Delphi é associado a uma unit (.pas), entretanto, nem toda unit precisa ter um formulário associado. A unit associada ao formulário contém o código fonte de qualquer evento associado aos componentes de um formulário. Os formulários recebem o mesmo nome da unit que está associado diferenciando- se apenas pela extensão (.dfm). 1.2.4 Projeto (.dpr) O ponto central do código fonte de um projeto é chamado de arquivo de projeto. Este arquivo é atualizado pelo Delphi durante o desenvolvimento da aplicação. O arquivo de projeto contém referências para todas as units e forms usados no projeto. program Project1; {identificação do projeto} uses {indica as units utilizadas pelo projeto} Forms, Unit1 in 'UNIT1.PAS' {Form1}; {nome das units associadas ao projeto} {$R *.RES} {arquivos de recursos associado ao projeto} begin {início do bloco principal do programa} Application.Initialize; Application.CreateForm(TForm1, Form1); {cria o primeiro formulário automaticamente} Application.Run; {executa a aplicação} end. {final do bloco principal do programa} 1.2.5 Esquema da estrutura dos arquivos TESTE .DPR .EXE FORM 1 FORM 2 FORM N .DCU .DCU .DCU FORM 1 FORM 2 FORM N .DFM UNIT 1 .DFM UNIT 2 .DFM UNIT N ROTINAS .PAS .PAS .PAS .PAS Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 4 1.2.6 Outros tipos de arquivos Extensão Definição Função .DPR Arquivo do Projeto Código fonte em Pascal do arquivo principal do projeto. Lista todos os formulários e units no projeto, e contém código de inicialização da aplicação. Criado quando o projeto é salvo. .PAS Código fonte da Unit Contém todas as declarações, procedimentos, funções e eventos associados (Object Pascal) aos componentes de um formulário. .DFM Arquivo gráfico do Arquivo binário que contém as propriedades, e seus respectivos valores, de formulário um formulário contido em um projeto. Um .DFM está sempre associado a um arquivo .PAS do projeto. .DSK Situação da Área de Armazena o estado corrente da área de trabalho, como por exemplo onde as Trabalho janelas (paleta de componentes, Object Inspector, etc.) estão posicionadas, suas medidas, etc. .RES Arquivo de Recursos do Arquivo binário que contém o ícone, mensagens da aplicação e outros Compilador recursos usados pelo projeto. .DOF Delphi Options File Contém o conjunto de opções do projeto (opções de: compilador, linker, diretórios, diretivas, etc.) .CFG Arquivo de configuração Armazena o conjunto de configuração do projeto. Este arquivo tem o mesmo do projeto nome do arquivo de projeto, porém, com a extensão .cfg. .~DPR Arquivo de Backup do Gerado quando o projeto é salvo pela segunda vez. Projeto .~PAS Arquivo de Backup da Unit Se um .PAS é alterado, este arquivo é gerado. .~DFM Backup do Arquivo gráfico Se você abrir um .DFM no editor de código e fizer alguma alteração, este do formulário arquivo é gerado quando você salva o arquivo. 1.3 Área de trabalho Normalmente, quando o Delphi é inicializado, é criado um projeto (project1.dpr), uma unit (unit1.pas) e um formulário (form1.dfm) (veja Figura 1). Menus Botões atalho Paleta de componentes Object Form Inspector Unit Figura 1 – Área de Trabalho Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 5 1.3.1 Menus Os menus (File, Edit, Search, View, Project,...) possibilitam o acesso a diversos recursos do ambiente Delphi. 1.3.2 Botões de atalho Os botões de atalho permitem acionar diversos recursos do ambiente Delphi sem precisar acionar o menu correspondente. Funções como “salvar” podem ser acessadas de maneira rápida. Os botões de atalho podem ser personalizados de acordo com as necessidades do desenvolvedor. Para configurar esta área, basta dar um clique com o botão direito sobre os “botões de atalho” e acionar a opção “Customize”. Através desta opção, é possível esconder barras de ferramentas, adicionar ou excluir botões de atalho. 1.3.3 Paleta de componentes Nesta área são disponibilizados os diversos componentes (visuais e não visuais) que podem ser utilizados durante a programação de um aplicativo. Os componentes estão organizados por grupos através das paletas (Standard, Additional, Win32, ...). Para adicionar um componente ao formulário (botões, caixa de edição, figuras, ...) dê um clique sobre o componente desejado e, logo em seguida, clique sobre o formulário. 1.3.4 Object Inspector Quando você seleciona um componente do formulário, o Object Inspector mostra suas propriedades publicadas (nem todas as propriedades de um componente aparecem no Object Inspector) e, quando apropriado, permite que sejam alteradas. A janela do Object Inspector é divida em duas abas: Properties (Propriedades) e Events (Eventos). 1.3.4.1 Properties (aba) Esta aba é dividida em duas colunas: a primeira coluna mostra o nome da propriedade do componente selecionado e a segunda mostra os possíveis valores para a propriedade. Para colunas cujo valor é do tipo booleano ou numeral, é disponibilizada uma lista (drop-down) onde pode-se escolher o valor desejado com um clique. Se um sinal de mais (+) aparece próximo ao nome da propriedade, pode-se clicar sobre este sinal para que sejam visualizados uma lista de subvalores para a propriedade (é o caso da propriedade Font). Se um sinal de menos (-) aparece próximo a propriedade, pode-se clicar sobre este sinal para que os subvalores sejam escondidos. Quando mais de um componente é selecionado, o Object Inspector mostra todas as propriedades que são comuns entre este componentes (exceto o name), se o valor desta propriedade comum for alterado, o novo valor é aplicado a todos os componentes selecionados. Algumas propriedades como Font têm um editor de propriedades especial. Isto pode ser observado através de um botão com reticências (...) que aparece no momento em que o valor da Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 6 propriedade é selecionado. Para abrir este editor, basta dar um clique sobre este botão ou um duplo clique sobre o campo onde consta o valor da propriedade. Os editores de propriedade possibilitam maior facilidade na atribuição de valores de propriedades mais complexas. Propriedades comuns entre componentes: Diversos componentes possuem propriedades que são comuns entre si. Este recurso possibilita que diversos componentes em um formulário, que possuam uma determinada propriedade em comum, recebam o novo valor de uma única vez. Por exemplo: você pode ter diversas labels (rótulos) e edits (caixa de edição) sobre um formulário e alterar o tamanho e cor da fonte de todos estes componentes uma única vez selecionado todos estes componentes e alterando os valores na propriedade Font. Abaixo, serão listadas algumas propriedades que são comuns entre diversos componentes: Posição e tamanho: Quatro propriedades definem a posição e tamanho de um componente em um formulários: Height: define a altura do componente; Width: define o comprimento do componente; Top: a posição (vertical) do componente em relação ao formulário; Left: a posição (horizontal) do componente em relação ao formulário. Visualização: Estas propriedades definem a aparência visual de um componente: BorderStyle: define o estilo da borda de um componente; Color: muda a cor de fundo de um componente; BevelKind: define o estilo da linha da borda de um componente; Font: muda a cor, tipo, tamanho, estilo da fonte do componente. Navegação: Diversas propriedades definem como o usuário poderá navegar entre os componentes de um formulário: Caption: define o texto que será visualizado pelo usuário. Nesta propriedade pode- se definir a tecla de atalho (Arquivo) que sublinham uma determinada letra e, através da combinação (ALT+<letra sublinhada>) o usuário acessa a função deste componente. Este recurso pode ser acessado adicionando o caracter (&) antes da letra de atalho na propriedade Caption (ex.: &Salvar resultaria em Salvar). Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 7 TabOrder: indica a ordem em que o componente receberá foco no formulário. Inicialmente, a ordem é definida a medida que os componentes são adicionados ao formulário. Esta ordem de foco pode ser alterada mudando o valor que aparece na propriedade TabOrder sendo que 0 (zero) indica o primeiro componente que receberá foco no formulário. A propriedade TabOrder só funcionará se a propriedade TabStop estiver com valor True; TabStop: define se um componente receberá foco (True) ou não (False) quando o usuário acionar a tecla TAB. Propriedades comuns entre componentes de edição de texto: Text: define o texto que aparecerá no componente; CharCase: força a entrada do texto em normal, maiúscula ou minúscula; ReadOnly: define se o usuário poderá (false) ou não (true) alterar o texto existente no componente; MaxLength: limita o tamanho do texto; PasswordChar: substitui o texto por um determinado caracter (normalmente asterisco); HideSelection: define se o texto será selecionado ou não quando o componente receber foco. 1.3.4.2 Events (aba) A aba Events (Eventos) do Object Inspector permite que formulários e componentes sejam conectados a rotinas do programa. Os eventos permitem que uma rotina (procedimento ou função) associada a um formulário ou componente seja executada. Deste modo, podemos, por exemplo, associar ao clique de um botão a execução de uma rotina que fecha um determinado formulário. O usuário clica sobre um botão (ação); Ao clicar sobre o botão é disparado um evento; O evento clicar dispara uma rotina (procedimento ou função) Ação evento rotina clique ao clicar fecha formulário Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 8 Portanto, o evento é o meio pelo qual pode-se associar a execução de uma rotina definida na aplicação a um determinado componente. A aba Events do Object Inspector mostra todos os eventos do componente selecionado. Eventos comuns entre componentes Assim como as propriedades, existem diversos eventos que são comuns entre os componentes. Muitos destes eventos, como o evento OnClick (ao clicar), estão presentes em mais de um componente. Quando componentes possuem eventos em comum, pode-se associar estes eventos a diversos componentes ao mesmo tempo e, consequentemente, a mesma rotina associada ao evento comum poderá ser disparada de diversos componentes (reuso de código). Para visualizar eventos comuns entre dois ou mais componentes, basta selecionar estes componentes e observar a aba Events. A aba Events mostrará apenas os eventos comuns entre os componentes selecionados. Abaixo são apresentados alguns dos eventos que são comuns entre componentes: OnClick: este evento ocorre quando clica-se sobre um determinado componente; OnEnter: ocorre quando o componente recebe foco; OnExit: ocorre quando o foco sai do componente; OnKeyDown: ocorre quando é pressionada uma tecla enquanto o componente está selecionado (foco); OnKeyPress: ocorre quando é digitado um caracter. Como associar uma rotina (procedimento ou função) a um determinado evento A aba Events possui duas colunas: a primeira mostra uma lista dos eventos do componente selecionado, e a segunda mostra o nome das rotinas associadas. Para habilitar um evento e associar uma rotina a este evento, basta dar um duplo clique na segunda coluna (coluna de valores que localiza-se logo após o nome do evento que deseja-se habilitar). Automaticamente será criado um bloco de código onde a rotina a ser executada poderá ser implementada. 1.3.5 Form (Formulários) Formulários são a base de toda as aplicações desenvolvidas em Delphi. É uma janela (tela) onde pode ser definida uma interface (janelas principais, caixa de diálogo, etc). Este componente pode conter outros componentes, desempenhando o papel de contêiner de componentes. Assim, é possível adicionar a um formulário diversos outros componentes como: botões, caixas de edição, menus, etc. Por tratar-se de uma janela, inclui funcionalidades comuns de uma janela como: menu de controle, botões de maximizar e minimizar, barra de título e bordas redimensionáveis. Estas propriedades, como outras, podem ser acessadas através do Object Inspector. As rotinas pertencentes ao formulário e aos componentes adicionados ao mesmo, são acondicionados na unit correspondente. Assim, para cada formulário é criado uma unit. Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 9 1.3.6 Unit Nas units (módulos) são implementados os procedimentos e funções do formulários ou dos componentes do formulário. 1.3.6.1 Estrutura de uma unit Unit unit1 Define o nome da unit (nome do módulo). O nome da unit é definido no momento em que aciona-se a opção Save no menu File; Interface Esta seção inicia-se na palavra reservada Interface e continua até a seção Implementation. Na seção Interface são declaradas constantes, tipos, variáveis, procedimentos e funções. No caso de procedimentos ou funções, são declarados apenas os cabeçalhos. Uses Lista as units e bibliotecas utilizadas pela unit atual. Os nomes são separados por vírgula e, ao final, ponto e vírgula (;). A cláusula uses também pode aparecer na seção Implementation para evitar a referência circular entre units. Implementation A seção Implementation define os procedimentos e funções declarados na seção Interface, ou seja, é onde são implementadas as rotinas a serem executadas. Os procedimentos e funções podem ser chamados em qualquer ordem. Na seção Implementation podem ser declaradas constantes, tipos, variáveis, procedimentos, funções, porém, estas declarações não poderão ser acessadas por outras units. Se for necessário adicionar outra cláusula uses na seção Implementation, esta deve aparecer imediatamente depois da palavra reservada Implementation. 1.4 Programando no ambiente Delphi 1.4.1 Principais tipos de dados do ambiente Delphi Tipos inteiros Tipo Faixa Formato Integer –2147483648..2147483647 32 bits Shortint –128..127 8 bits Smallint –32768..32767 16 bits Longint –2147483648..2147483647 32 bits Int64 –2^63..2^63–1 64 bits Byte 0..255 8 bits Word 0..65535 16 bits Longword 0..4294967295 32 bits Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 10 Tipos reais Tipo Faixa Formato Em bytes Real48 2.9 x 10^–39 .. 1.7 x 10^38 11–12 6 Single 1.5 x 10^–45 .. 3.4 x 10^38 7–8 4 Double 5.0 x 10^–324 .. 1.7 x 10^308 15–16 8 Extended 3.6 x 10^–4951 .. 1.1 x 10^4932 19–20 10 Comp –2^63+1 .. 2^63 –1 19–20 8 Currency –922337203685477.5808.. 922337203685477.5807 19–20 8 Real 5.0 x 10^–324 .. 1.7 x 10^308 15–16 8 Tipos string Tipo Tamanho máximo em caracteres Memória requerida ShortString 255 2 - 256 bytes String 255 256 bytes AnsiString ~2^31 4 bytes - 2GB 8 bits WideString ~2^30 4 bytes - 2GB 1.4.2 Conversão de tipos O ambiente Delphi possui diversas funções que permitem a conversão de tipos de dados. Estas conversões freqüentemente são necessárias no processo de desenvolvimento de um aplicativo. Dentre as diversas funções de conversão de tipos, segue abaixo um quadro das funções mais utilizadas. Função Retorno Descrição IntToStr(<tipo inteiro>) String Converte um inteiro em string StrToInt(<tipo string>) Inteiro Converte um tipo string em um inteiro StrToFloat(<tipo string>) Real Converte uma string em real FloatToStr(<tipo real>) String Converte um tipo real em string StrToDate(<tipo string>) Data Converte uma string em tipo data DateToStr(<tipo data>) String Converte uma data em string TimeToStr(<tipo horas>) String Converte horas em string StrToTime(<tipo string>) Horas Converte string em horas 1.4.3 Declaração de variáveis 1.4.3.1 Variáveis globais As variáveis globais, que podem ser utilizados por diversos procedimentos dentro de uma unit podem ser declaradas logo abaixo da seção Implementation. Entretanto, as variáveis declaradas nesta seção não serão visíveis por outras units. Caso haja a necessidade de uma outra unit utilizar variáveis globais, é necessário que esta variável seja declarada na seção Public. Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 11 unit Unit1; interface uses Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs; type TForm1 = class(TForm) private { Private declarations } public { Public declarations } z : string; //variável global pública, pode ser acessada pela própria unit e por outras units end; var Form1: TForm1; implementation {$R *.DFM} var s : string[20]; //variável global, só pode ser acessada pela própria unit. end. 1.4.3.2 Variáveis locais As variáveis locais devem ser declaradas dentro do procedimento ou função em que são utilizadas, entre o cabeçalho do procedimento/função e a palavra reservada begin, com o nome da variável antecedida da palavra reservada var e precedida do tipo de dado. Procedimento Teste; var VariavelLocal : string; begin bloco de código end; 1.4.4 Declaração de procedimentos e funções Para a declaração de um procedimento ou função deve ser especificado seu nome, nome e tipo de parâmetro (opcional) e, no caso de funções, o tipo do retorno. Procedure MinhaProcedure (nome, fone: string; idade: integer; salario: double); Function MinhaFuncao(salario, desconto: double) : double; Esta parte da declaração é chamada de protótipo ou escopo ou ainda, cabeçalho. Function MinhaFuncao(salario, desconto: double) : double; Protótipo ou escopo ou cabeçalho Begin MinhaFuncao := salario – desconto; bloco de código ou corpo da função end; No bloco de código ou corpo da função/procedimento é definida a rotina que será executada quando a função/procedimento for chamada. Os procedimentos ou funções podem ser declarados logo após a palavra reservada Implementation (cabeçalho e corpo). Neste caso, estas declarações somente serão visíveis para a própria Unit. Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 12 Procedimentos e funções também podem ser declarados na seção Interface (somente cabeçalho). Se o procedimento/função for declarado na parte Public, poderá ser disponibilizado para outras units. Se o procedimento/função for declarado na parte Private, este somente estará disponível para a própria unit. O cabeçalho e corpo do procedimento/função devem ser declarados na seção Implementation. ... Private Procedure Teste1; Public Function Teste2 : boolean; ... Implementation ... procedure Tform1. Teste1; <declaração de variáveis locais, caso necessário> begin //bloco de código end; Function Teste2 : boolean; <declaração de variáveis locais, caso necessário> begin //Bloco de código end; Exercícios sugeridos: Funções e procedimentos: Elabore uma função que receberá dois valores inteiros (parâmetros de entrada) e retorne a multiplicação destes valores. Utilize dois Edits para entrada de valores e uma label para mostrar o resultado. A função deve ser chamada através do evento OnClick de um botão. Elabore um procedimento que verifique se as dimensões do formulários são menores que (utilize um botão para chamar o procedimento): ♦ Height (altura): 500 e, ♦ Widht: (largura): 700. Se as dimensões (as duas) forem menores que as apontadas acima, o procedimento deve redimensionar o formulário para: ♦ Height (altura): 600 e, ♦ Widht: (largura): 800. Eventos: Utilize o evento OnCreate para verificar se a propriedade WindowState é igual a wsNormal, caso afirmativo, a propriedade WindowState deve ser igual a wsMaximized. Propriedades: Utilize o evento OnClick de um botão para mudar o Caption de um formulário. Sub propriedades: Utilize o evento OnClick de um botão para mudar a cor de um formulário. Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 13 1.4.5 Tratamento de erros (exceções) 1.4.5.1 Bloco Try ... Except Qualquer aplicativo está sujeito a ocorrência de erros. A origem dos erros pode ser das mais variáveis: erros na codificação, entrada de dados, saída de dados, etc. O tratamento de erros ou possíveis erros pode ser feito através das palavras chaves “Try ... Except”. Quando um bloco protegido é declarado através de Try...Except, pode-se definir possíveis respostas para os erros que ocorrerão neste bloco. Exemplo: Try Inicia a proteção do código StrToInt(Edit1.Text); //linha 1 StrToInt(Edit2.Text);//linha 2 Bloco protegido StrToInt(Edit3.Text);//linha 3 Except Bloco de tratamento: se ocorrer algum erro no ShowMessage(‘Digite um valor numérico’); código protegido, a mensagem é executada End; //end do Try Final do bloco protegido Quando ocorre um erro (exceção) em qualquer linha do bloco de código protegido, o controle da execução passa imediatamente para o tratamento, independente de haver ou não outras linhas a serem executadas no bloco protegido. Se ocorrer um erro na linha 1 (exemplo acima), as linhas 2 e 3 não serão executadas sendo passado o controle para o bloco de tratamento. Entretanto, se não ocorrerem erros no bloco protegido, o bloco de tratamento não será executado, passando o controle ou execução para o bloco de código seguinte (após o end do try), se houver. 1.4.5.2 Bloco Try...Finally Existem situações onde uma rotina deve ser executada mesmo que ocorra um erro. Utilizando o exemplo ilustrado na seção anterior, podemos definir o seguinte bloco de código: Try Inicia a proteção do código StrToInt(Edit1.Text); //linha 1 StrToInt(Edit2.Text);//linha 2 Bloco protegido StrToInt(Edit3.Text);//linha 3 Finally Begin Edit1.Clear; Bloco de tratamento: ocorrendo ou não erros no Edit2.Clear; bloco protegido, estas linhas serão executadas. Edit3.Clear; End; //end Finally End; //end do Try Final do bloco protegido Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 14 No código acima, se ocorrer um erro na linha 1, as linhas 2 e 3 não são executadas e todos os procedimentos existentes no bloco de tratamento são processados. Se não ocorrer nenhum erro nas linhas 1, 2 e 3, o bloco de tratamento também é executado. Portanto, utilize esta estrutura para executar códigos que sempre deverão ser processados, independente da ocorrência de erros ou não. 1.4.6 Depurando a aplicação (debugger) A ocorrência de erros em uma aplicação exige que o desenvolvedor utilize técnicas que permitam a localização destes erros (depuração). O ambiente Delphi oferece diversos recursos que possibilitam ao desenvolvedor a localização de erros. Estas ferramentas, quando utilizadas adequadamente, podem reduzir o tempo de depuração agilizando a procura e solução do erro. 1.4.6.1 Breakpoints Breakpoints permitem marcar um determinado ponto do programa com a finalidade de interromper a execução do aplicativo neste ponto. Quando a aplicação for executada, na linha do código onde está localizado o breakpoint ocorre uma interrupção de execução e o código fonte onde o breakpoint está localizado é visualizado. Através deste recurso é possível examinar valores de variáveis, fluxo de controle do algoritmo (F8), loops, etc. Através da tecla F8 pode-se executar linha-a-linha o código fonte observando o comportamento do programa. Para um breakpoint ser válido, é necessário que seja adicionado em uma linha de código executável. Linhas de código não executáveis são, por exemplo, comentários, linhas em branco, declarações (procedimento, funções, variáveis), etc. As linhas de códigos que não forem válidas são visualizadas com um “x” no ícone do breakpoint na margem esquerda do código fonte, durante a depuração. As linhas válidas são visualizadas com o símbolo ( ) (Figura 2). Figura 2 – Utilizando breakpoints Para adicionar um breakpoint no código fonte, selecione a linha onde será posicionado o breakpoint e então utilize um dos seguintes meios: Clique na margem esquerda da linha; Clique com o botão direito do mouse em qualquer parte da linha e escolha Debug|Toggle Breakpoint no menu suspenso; Posicione o cursor em qualquer parte da linha onde será adicionado o breakpoint e então pressione a tecla F5; Escolha a opção no menu Run|Add Breakpoint|Source Breakpoint e defina a linha onde será adicionado o breakpoint; Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 15 Na janela Breakpoint List (View|Debug Windows|BreakPoints), clique com o botão direito do mouse e escolha no menu suspenso a opção Add|Source Breakpoint. 1.4.6.2 Watches A janela Watch List (View|Debug Windows|Wathces ou Ctrl+Alt+W) mostra os valores correntes de expressões (variáveis, propriedades de componentes, resultados de funções, etc) baseado no ponto de execução do programa. Veja a Figura 3. Figura 3 – Janela Watch List Para adicionar uma expressão na janela Watch, clique com o botão direito sobre a janela e selecione no menu suspenso a opção Add Watch... (Ctrl + A.) No menu suspenso da janela Watch são disponibilizadas diversas funcionalidades que permitem manipular a utilização deste recurso de depuração, os mais importantes são: Edit Watch: abre a caixa de diálogo Watch Properties que permite modificar as propriedades da expressão selecionada; Add Watch: abre a caixa de diálogo Watch Properties que permite criar um watch; Enable Watch: habilita uma expressão watch desativada; Disable Watch: desabilita uma expressão watch ativa; Delete Watch: remove uma expressão; Enable All Watches: habilita todos os watches; Disable All Watches: desabilita todos os watches; Delete All Watches: remove todos os watches; Stay On Top: mantém a janela Watches List sempre visível quando outras janelas recebem foco; 1.5 Trabalhando com componentes Por trata-se de um ambiente visual (padrão Windows®), a interação entre o aplicativo e o usuário é definida através de componentes. Basicamente, existem dois tipos de componentes: componentes visuais e componentes não visuais. Os componentes visuais são aqueles que são visíveis quando o aplicativo é executado (tempo de execução – runtime) e os não visuais são aqueles que aparecem em tempo de projeto (no momento em que se está programando - design) como uma pequena figura, e não são visíveis quando o aplicativo é executado. 1.5.1 Paleta de componentes (Component palette) Os componentes são disponibilizados na paleta de componentes (Figura 4) e agrupados por categorias. Para adicionar um componente ao formulário basta dar um clique sobre o componente e adicioná-lo ao formulário (dando um clique na posição onde o componente deverá ser adicionado). Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 16 Figura 4 – Paleta de componentes 1.5.2 Propriedades A propriedade (veja seção 1.3.4.1 Properties (aba)) é um atributo (característica) de um componente (objeto) com valores pré definidos (p.e.: Font) ou valores que podem ser definidos pelo programador (p.e.: Caption). As propriedades de um componente podem ser acessadas ou alteradas de duas maneiras: Através do Object Inspector: as propriedades que aparecem no Object Inspector são propriedades publicadas (published). O acesso é disponibilizado em duas colunas na aba Properties: uma coluna onde são definidos os nomes das propriedades e a outra com os respectivos valores. Para visualizar as propriedades de um componente no Object Inspector, basta selecionar o componente no formulário. As propriedades também podem ser acessadas ou alteradas diretamente no código fonte. Para isso, deve-se digitar o nome do componente (definido na propriedade name) seguido de um ponto (.) e o nome da propriedade Form1.Caption := ‘Menu Principal’ Alterando o valor da propriedade ShowMessage(Form1.Caption); Consultando o valor de uma propriedade ☺Dica: No Object Inspector somente são visíveis as propriedades publicadas (published), portanto, podem existir outras propriedades que não estão visíveis no Object Inspector. Estas propriedades não publicadas podem ser acessadas no código. 1.5.3 Eventos (Events) Os eventos (veja seção 1.3.4.2 Events (aba)) permitem a um determinado componente disparar um determinado procedimento/função. Por exemplo: botões possuem o evento OnClick (ao clicar) que pode executar uma determinada rotina. 1.5.4 Métodos Método é um procedimento ou função associado a uma classe. Componentes possuem métodos que executam um código que atende a uma determinada finalidade. Por exemplo: o componente Formulário (Form) possui um método chamado Close. Este método, quando acionado, fecha o formulário (Form1.Close). Para acessar os métodos de um componente basta definir o nome do componente seguindo de um ponto (.) mais o nome do método. Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 17 ☺Dica: Para visualizar a lista de propriedades do componente no código, basta digitar o nome do componente (definido na propriedade name) seguindo de um ponto (.) e após alguns segundos será possível ver uma lista das propriedades, métodos e eventos de um componente. Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 18 2 BANCO DE DADOS INTERBASE® 2.1 Introdução A importância da informação na maioria das organizações é indiscutível. Armazenar e prover acesso a estas informações tornou-se uma atividade essencial. Informações podem ser acondicionadas e organizadas de diversas maneiras: fichas, arquivos, documentos, fichários, etc. Com o advento da informatização, aplicações foram desenvolvidas para desempenhar este papel. Estas aplicações, os bancos de dados, tornaram-se elementos de fundamental importância para as organizações pelos inúmeros benefícios proporcionados. Os banco de dados permitem que estas informações sejam relacionadas, armazenadas e recuperadas com rapidez e segurança. Além disso, os bancos de dados possibilitam que informações sejam protegidas de acesso não autorizado; permitem que uma mesma informação seja compartilhada por múltiplos usuários; padroniza a entrada de dados, restringem e consistem o armazenamento dos dados, evitam a redundância de informações, etc. 2.2 Banco de dados Interbase O banco de dados Interbase, como a maioria dos bancos de dados, permite que sejam criadas estruturas de dados onde serão armazenadas e gerenciadas as informações de uma organização. Assim, como uma linguagem ou ambiente de programação, a criação de estruturas de dados é definida através de uma linguagem chamada SQL (Structured Query Language – Linguagem de Consulta Estruturada). A linguagem SQL foi padronizada e diversos bancos de dados utilizam este padrão. Porém, devido a diversas necessidades, a linguagem SQL foi complementada e, no caso do Interbase, é chamada de ISQL. A linguagem SQL pode ser utilizada de duas maneiras: como linguagem de manipulação de dados (DML-Data Manipulation Language) e como linguagem de definição de estruturas de dados (DDL-Data Definition Language). 2.3 SQL DML (Data Manipulation Language) As informações de um banco de dados podem ser manipuladas através da SQL DML (DML Data Manipulation Language ou Linguagem de Manipulação de Dados). Através da DML é possível aplicar as seguintes operações sobre as informações armazenadas em um banco de dados: Consultas; Inserção de novas informações; Atualização e; Exclusão de informações já armazenadas; A estrutura da manipulação de dados consiste basicamente em 3 cláusulas: select, from e where. Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 19 2.3.1 Cláusula Select (“selecione”) É utilizada para definir quais campos de uma tabela serão listados como resultado de uma consulta. Por exemplo: suponhamos que exista uma tabela com os seguintes campos: Codigo_Cliente Nome Telefone Cidade Cpf 1 José 999999-99 Cornélio Procópio 999.999.999-99 2 Rafaela 888888-88 Cornélio Procópio 888.888.888.-88 3 Saulo 777777-77 Londrina 777.777.777-77 4 José 666666-66 Santa Mariana 666.666.666-66 Quadro 1 – Estrutura de uma tabela de clientes A cláusula Select permite que o resultado de uma consulta possa ser visualizado de diversas maneiras: a) Mostrar todos os campos no resultado da consulta: Select Codigo_Cliente, Nome, Telefone, Cidade, Cpf b) Mostrar apenas os nomes dos clientes: Select Nome c) Mostrar apenas os nomes e telefones de todos os cliente: Select nome, telefone Como pode ser observado, ainda seria possível outras inúmeras combinações. Então, a definição dos campos resultantes em uma consulta é especificado utilizando-se a cláusula Select mais o nome do campo. Quando mais de um campo formar o resultado de uma consulta, estes devem ser separados por vírgula observando que após o último nome do campo listado na cláusula Select não deve ser empregada a vírgula ☺ Dica: Em situações onde todos os campos serão selecionados (como no item “a” do exemplo anterior), pode ser empregado o asterisco (*) para substituir todos os nomes de campos Ex. Select * From Cliente 2.3.2 Cláusula From (“origem”) A cláusula From define a origem e relações existentes nos elementos (campos) apontados na cláusula Select. Deste modo, é necessário determinar em uma consulta pelo menos as duas cláusulas (Select e From) para que seja proporcionado um resultado para uma consulta. Utilizando o Quadro 1 definido na seção anterior, para que a consulta produza resultados, é necessários apontar quais elementos (campos) do conjunto cliente farão parte do resultado e, qual a origem (conjunto, tabela) destes elementos. Por exemplo: a) Mostrar todos os campos no resultado da consulta: Select Codigo_Cliente, Nome, Telefone, Rg, Cpf From Cliente b) Mostrar apenas os nomes dos clientes: Select Nome From Cliente Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 20 c) Mostrar apenas os nomes e telefones de todos os clientes: Select nome, telefone From Cliente d) ... Então, através destas duas cláusulas já é possível produzir resultados em uma consulta. 2.3.3 Cláusula Where (“onde”) A cláusula Where define as “condições” (predicado) que poderão definir (restringir) o resultado de uma consulta. Nos exemplos utilizados nas seções anteriores, os resultados das consultas sempre retornariam todos os elementos de um conjunto, ou seja, todos os clientes cadastrados na tabela ou conjunto Cliente. Entretanto, nem sempre é necessário que as consultas retornem como resultado todos os elementos de um conjunto. Por exemplo, poderia ocorrer a situação onde seria necessário como resultado somente as informações de um determinado cliente. Pode-se definir na cláusula Where a condição que irá restringir o resultado desta consulta. Para que isso seja possível, é necessário definir uma condição, por exemplo, selecionar todos os campos de clientes onde o código do cliente seja igual a 1. Esta sentença em SQL poderia ser definida da seguinte maneira: Select * From Cliente Where Codigo_Cliente = 1 Resultado Codigo_Cliente Nome Telefone Cidade Cpf 1 José 999999-99 Cornélio Procópio 999.999.999-99 É importante tomar cuidado no emprego da condição. Determinadas condições podem não restringir o resultado da consulta. Por exemplo, se a sentença SQL definida anteriormente fosse definida da seguinte maneira: Select * From Cliente Where nome = “José” Resultado Codigo_Cliente Nome Telefone Cidade Cpf 1 José 999999-99 Cornélio Procópio 999.999.999-99 4 José 666666-66 Santa Mariana 666.666.666-66 Se o objetivo da consulta era somente a visualização das informações do primeiro cliente (código 1), este não foi alcançado com precisão. Existem situações onde este tipo de consulta é necessário. Por exemplo, poderia ocorrer a necessidade de se obter todos os cliente residentes na cidade de Cornélio Procópio, neste caso o elemento que poderia atender a esta condição seria: Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 21 Select * From Cliente Where Cidade = “Cornélio Procópio” Resultado Codigo_Cliente Nome Telefone Cidade Cpf 1 José 999999-99 Cornélio Procópio 999.999.999-99 2 Rafaela 888888-88 Cornélio Procópio 888.888.888.-88 2.3.4 Cláusula Order By Normalmente, o resultado de uma consulta é retornado em “ordem natural”, ou seja, ordenado pela chave primária ou pelo índice ativo. A cláusula Order By organiza o resultado de uma consulta de acordo com a coluna definida na cláusula Order By. A coluna utilizada nesta cláusula deve aparecer na cláusula Select. Naturalmente, os dados são organizados na ordem ascendente (“asc”), de “A” a “Z” ou “1” a “9”. Para organizar na ordem descendente pode-se utilizar a palavra chave “desc” após o nome da coluna especificada na cláusula Order By. Select Codigo_Cliente, Nome, Cpf From Cliente Order by cpf asc Resultado Codigo_Cliente Nome Telefone Cidade Cpf 4 José 666666-66 Santa Mariana 666.666.666-66 3 Saulo 777777-77 Londrina 777.777.777-77 2 Rafaela 888888-88 Cornélio Procópio 888.888.888.-88 1 José 999999-99 Cornélio Procópio 999.999.999-99 2.3.5 Operadores A necessidade de definição de restrições no resultado de uma consulta exige que seja definida uma condição. Os operadores auxiliam na definição da condição que irá restringir o resultado da pesquisa. 2.3.5.1 Operadores de comparação Utilizados para comparar dados de uma coluna com os valores definidos na condição. Operador Significado < menor > maior <= menor igual >= maior igual = igual <> diferente Between Entre Starting With Iniciado com Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 22 Operador Starting With O operador de comparação Starting With retorna os valores iniciados por um determinado caracter ou uma seqüência de caracteres. Select Nome From Cliente Where Nome Starting With “J” Resultado Codigo_Cliente Nome Telefone Cidade Cpf 1 José 999999-99 Cornélio Procópio 999.999.999-99 4 José 666666-66 Santa Mariana 666.666.666-66 Aviso: o Interbase diferencia caracteres maiúsculos de minúsculos e vice-versa. Desta forma, “Select Nome From Cliente Where Nome Start With “j” ” não retornaria nenhum resultado, pelo fato de não existir nenhum nome iniciado com a letra “j” (em minúsculo). 2.3.5.2 Operadores lógicos Utilizados para combinar ou negar uma condição. Operador Significado Not não And e Or ou Existem outros operadores que podem ser utilizados no Interbase. Entretanto, o objetivo deste curso é apenas proporcionar uma visão geral sobre a aplicação da SQL. 2.4 SQL DDL (Data Definition Language) A DDL é utilizada para definir, alterar e excluir um banco de dados e/ou objetos de um determinado banco de dados. Os objetos definidos através da DDL (tabelas, procedures, triggers, etc.) são conhecidos como metadados (dados sobre dados). O Interbase é um banco de dados relacional. Um banco de dados relacional é uma coleção de tabelas bidimensionais compostas de linhas (também chamados registros) e colunas (chamados também de campos). O banco de dados Interbase é armazenado em arquivos com a extensão .gdb. Para criar um banco de dados é necessário o nome do usuário e senha. Quando o banco é instalado, o usuário e a senha de acesso padrão são, respectivamente, sysdba e masterkey. Além do nome do usuário e senha, deve ser definido o nome para o banco. Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 23 2.4.1 Criando um banco de dados Interbase Para criar um banco de dados será utilizado o aplicativo IBConsole que acompanha o banco. Antes, porém, vamos criar alguns diretórios. Crie uma estrutura de diretórios como sugerido na Figura 5. Figura 5 – Estrutura de diretórios utilizada para o desenvolvimento do aplicativo Agora com a estrutura de diretórios montada, vamos criar o banco. 1. Primeiro devemos verificar se o banco já foi iniciado (start) (botão Iniciar|Programas|Interbase|Interbase Server Manager); 2. Agora, inicialize o aplicativo IBConsole (botão Iniciar|Programas|Interbase| IBConsole) e clique 2 vezes em Local Server, se for pedido usuário e senha use usuário SYSDBA, e digite a senha “masterkey” (em minúsculas); 3. No Local Server, agora conectado, será exibida uma árvore (Databases, Backup, Certificates, Server Log e Users), clique com o botão direito em Databases e selecione a opção Create Database...; 4. Na caixa de edição “Filename” digite o caminho (path) e nome do banco: C:AplicativoBancoBanco.gdb. Certifique-se de que o caminho (diretório) e nome do banco (incluindo a extensão .GDB) estão como descritos aqui (veja a Figura 6). Lembre-se que o caminho indicado já deve existir; 5. Na caixa de edição “Alias” digite: Banco. Esse é o nome pelo qual o banco criado será referenciado; 6. Clique no botão “Ok”. Se tudo correu bem, o IBConsole vai exibir “Banco” em Databases, e mostrar a árvore de informações do banco (Domains, Tables, Indexes, etc.). Figura 6 – Janela Create Database Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 24 A partir deste momento você está conectado ao banco que acabou de criar. Aviso: toda vez que você precisar trabalhar com qualquer banco de dados criado no Interbase, certifique-se de que o banco está inicializado (Started). Normalmente, quando o banco não está ativo (not started) aparece a mensagem “Statement failed, SQLCODE = -901”. No Interbase, todo banco de dados deve ser registrado (opção do menu suspenso aberto ao clicar com o botão direito em Databases ou em menu Database|Register). No momento da criação, por padrão, o banco já é automaticamente registrado. Se o objetivo for abrir um banco (arquivo GDB) já existente em um Interbase Server onde esse banco ainda não foi registrado, não é necessário criar o banco novamente, basta registrar o arquivo no servidor. Para isso, faça o seguinte: 1. No Local Server já conectado, clique com o botão direito em Databases e selecione a opção Register...; 2. Na caixa de edição “File:” digite o caminho (path) e nome do banco, ou escolha diretamente através do botão “...”; 3. Na caixa de edição “Alias” digite o nome do banco. Esse é o nome pelo qual o banco criado será referenciado, como padrão é colocado o nome do arquivo, mude para o nome que for necessário (veja a Figura 7); 4. Se for necessário, informe login (User Name) e senha (Password). 5. Clique no botão “Ok”. Figura 7 – Janela Register Database Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 25 2.4.2 Interbase Interactive SQL A janela Interbase Interactive SQL (Menu Tools|Interactive SQL) permite que suas sentenças SQL DML ou DDL sejam executadas. Além disso, existem outros inúmeros recursos disponibilizados através de seus menus. 2.4.3 Criando tabelas no Interbase A proposta desta etapa é construir um banco de dados simples com 4 tabelas (Figura 8) que conterão informações relacionadas a funcionários de uma determinada organização. Não é objetivo deste curso discutir regras de normalização ou qualquer conceito relacionado a construção de modelos de estruturas de dados. Entretanto, é de fundamental importância o planejamento do desenvolvimento de software. A aplicação de métodos, técnicas e ferramentas constituem-se elementos indispensáveis que agregam qualidade ao desenvolvimento de aplicações. Figura 8 – Modelagem de um sistema para cadastrar funcionários Com base no modelo apresentado na Figura 8, vamos construir as tabelas de dados utilizando SQL DDL para definir as estruturas de dados do sistema (use o Interactive SQL). A definição de uma tabela em DDL: Definição da tabela Departamento: CREATE TABLE tb_Departamento ( Dpt_Codigo SMALLINT NOT NULL, Dpt_Descricao VARCHAR(40) NOT NULL, PRIMARY KEY (Dpt_Codigo) ); Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 26 Definição da tabela Estado (Unidades da Federação): CREATE TABLE tb_Estado ( Est_Sigla CHAR(2) NOT NULL, Est_Descricao VARCHAR(40) NOT NULL, PRIMARY KEY (Est_Sigla) ); Definição da tabela funcionário: CREATE TABLE tb_Funcionario ( Fun_codigo INTEGER NOT NULL, Est_Sigla CHAR(2) NOT NULL, Dpt_Codigo SMALLINT NOT NULL, Fun_Nome VARCHAR(40) NOT NULL, Fun_DataNascimento DATE NOT NULL, Fun_dddResidencial CHAR(2) NOT NULL, Fun_FoneResidencial VARCHAR(9) NOT NULL, Fun_Rua VARCHAR(40) NOT NULL, Fun_Complemento VARCHAR(20), Fun_Bairro VARCHAR(40) NOT NULL, Fun_Cidade VARCHAR(40) NOT NULL, Fun_Cep CHAR(8), Fun_Salario DOUBLE PRECISION NOT NULL, PRIMARY KEY (Fun_codigo), FOREIGN KEY (Dpt_Codigo) REFERENCES tb_Departamento, FOREIGN KEY (Est_Sigla) REFERENCES tb_Estado ); Definição da tabela Dependentes: CREATE TABLE tb_Dependentes ( Fun_codigo INTEGER NOT NULL, Dep_Codigo SMALLINT NOT NULL, Dep_Nome VARCHAR(40) NOT NULL, Dep_DataNascimento DATE NOT NULL, Dep_Parentesco VARCHAR(20) NOT NULL, PRIMARY KEY (Fun_codigo, Dep_Codigo), FOREIGN KEY (Fun_codigo) REFERENCES tb_Funcionario ); Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 27 Palavra chave Significado Create table Sentença de criação de tabelas Not null Define que o campo é de preenchimento obrigatório Primary key Define a chave primária de uma tabela Foreign key Define a chave estrangeira de uma tabela References Define o nome da tabela origem da chave estrangeira Integer Tipo de dado inteiro Smallint Tipo de dado inteiro curto Varchar Tipo de dado string de tamanho dinâmico Char Tipo de dado string de tamanho fixo Date Tipo de dado que armazena data e hora Double precision Tipo de dado real, utilizado para armazenar valores monetários Drop Utilizado para excluir metadados. Ex.: drop table <nome da tabela> Alter Utilizado para atualizar metadados. Ex.: alter table tb_Departamento drop Dpt_Descricao, add Dpt_Descricao varchar(50) not null Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 28 3 DESENVOLVENDO UM APLICATIVO COM BANCO DE DADOS (INTERBASE) A proposta deste capítulo é desenvolver uma aplicação com acesso ao banco de dados Interbase. A aplicação terá como base a modelagem definida no Capítulo 2 (Figura 8). Serão construídos cadastros, relatórios, consultas, instalador e help para a aplicação. 3.1 Iniciando uma nova Aplicação O primeiro passo será iniciar um novo projeto e salvá-lo: Escolha no menu principal a opção File|New|Application; No Object Inspector, modifique as seguintes propriedades do formulário (Form1): Caption: Menu Principal; Name: FPrincipal; WindowState: wsMaximized; Escolha no Menu Principal, a opção File|Save All; Na janela Save Unit1 As: Encontre o diretório C:AplicativoFontes (onde será salvo o código fonte); Salve a unit1 com o nome UF_Principal; Clique no botão Salvar; Na janela Save Project1 As: Salve o projeto com o nome Funcionarios; Clique no botão Salvar; O que foi feito? Propriedades manipuladas: - Name: define o nome do componente formulário. Não pode conter acento, espaço, ç, etc. ou seja, deve ser definido com caracteres “puros”. Outro detalhe importante é que não podem existir dois componentes com o mesmo nome; - Caption: define o nome que aparecerá na barra de título do formulário. Esta propriedade permite a utilização de acentos, espaços, etc; - WindowState: esta propriedade possui 3 valores pré-definidos: - WsMaximized: o formulário é maximizado quando chamado; - WsMinimized: o formulário é minimizado quando chamado; - WsNormal: a janela será visualizada conforme chamado. Quando a opção Save All foi acionada foi definido que os fontes deveriam ser salvos no diretório especificado. Na primeira janela, definiu-se o nome da unit (não do formulário). Observe que o nome sugerido para salvar a unit foi o nome do formulário (definido na propriedade “name”) antecedido da letra “U”, procure utilizar convenções, regras para nomear arquivos, componentes, etc. Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 29 Formulário Unit FPrincipal UF_Principal Desta maneira, fica mais fácil relacionar o componente formulário aos arquivos que serão gerados (UF_Principal.pas e UF_Principal.dfm). Na segunda janela (Save Project1 As), foi definido o nome do projeto. Como discutido no capítulo anterior (veja a seção 1.2.4), as units e forms são agrupadas por projeto. É importante observar que a janela “Save Project1 As” aparecerá uma única vez. 3.2 Configurando opções do projeto Todo projeto desenvolvido no ambiente Delphi, basicamente, irá gerar três grupos de arquivos: arquivos fontes (.pas, .dfm, .dpr, .res, .dof, .cfg etc.); arquivos compilados (.dcu, .exe) e arquivos de backup (.~pa; .~df, enfim, todas as extensões antecedidas do caracter “~”). É interessante separar os arquivos fontes e arquivos de backup dos arquivos compilados para permitir uma melhor organização do projeto. Esta separação pode ser feita através de diretórios. Como sugerido na seção 2.4.1, os arquivos compilados (.dcu e .exe) podem ser salvos automaticamente no diretório Exe. Para que isto ocorra é necessário definir esta opção no ambiente Delphi. Selecione a opção Project|Options...; Selecione aba Directories/Conditionals; Na caixa de edição Output Directory digite o caminho do diretório Exe (C:AplicativoExe); Na caixa de edição Unit Output Directory digite também o caminho do diretório Exe (C:AplicativoExe). Clique no Botão OK. Output Directory: define onde será acondicionado o arquivo .exe quando o projeto for compilado (F9). Unit Output Directory: define onde serão acondicionados os arquivos .dcu quando o projeto for compilado (F9). Aviso: antes de definir os caminhos na Opções de Projeto, crie os diretórios necessários. Se os diretórios já foram criados, certifique-se de que os caminhos estão digitados corretamente, caso contrário, o projeto não será compilado e uma mensagem de erro será gerada. Se nestas opções, por um erro de digitação por exemplo, fossem definidos os caminhos como sendo (C:AplicativoExes), poderia ocorrer uma das mensagens de erro abaixo: • [Fatal Error] UF_Principal.pas(40): Could not create output file 'C:AplicativoExesUF_Principal.dcu', ou • [Fatal Error] Could not create output file 'C:AplicativoExesFuncionario.exe' 3.3 Definindo o menu do formulário Principal O próximo passo é definir um menu para o formulário principal: Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 30 Adicione um componente MainMenu (Paleta Standard); Modifique a propriedade do MainMenu (clique sobre o componente): Name: mmPrincipal. Dê um duplo clique sobre o componente MainMenu para acionar o Editor de Menu; Modifique as seguintes propriedades: Caption: &Cadastros. Name: imCadastros; Clique sobre o item de menu “Cadastros”; No item em branco que aparece logo abaixo, modifique as seguintes propriedades: Caption: Funcionários; Name: imFuncionarios; ShortCut: escolha Ctrl+F. Clique sobre o item de menu em branco logo abaixo de Funcionários: Modifique as seguintes propriedades: Caption: Estados (UF); Name: imEstados; ShortCut: escolha Ctrl+E. Clique sobre o item de menu em branco logo abaixo de Estados: Modifique as seguintes propriedades: Caption: Departamentos; Name: imDepartamentos; ShortCut: escolha Ctrl+D. Clique sobre o item de menu em branco logo abaixo de Departamentos; Modifique a propriedade: Caption: - (hífen). Clique sobre o item de menu em branco logo abaixo da linha divisória do menu Cadastros; Modifique as propriedades: Caption: Sair; Name: imSair; ShortCut: Ctrl+S. Clique sobre o item de menu em branco do lado direito do item Cadastros; Modifique as seguintes propriedades: Caption: &Relatórios; Name: imRelatorios. Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 31 Clique sobre o item de menu Relatórios; Clique sobre o item de menu em branco logo abaixo do item Relatórios; Modifique as seguintes propriedades: Caption: Funcionários; Name: imRelFuncionarios. Clique sobre o item de menu em branco logo abaixo do item Funcionários; Modifique as seguintes propriedades: Caption: Estados; Name: imRelEstados. Clique sobre o item de menu em branco do lado direito do item Relatórios; Modifique as seguintes propriedades: Caption: &Ajuda; Name: imAjuda. Clique sobre o item de menu Ajuda; Clique sobre o item de menu em branco logo abaixo do item Ajuda; Modifique as seguintes propriedades: Caption: Ajuda do Sistema; Name: imAjudaSistema. Clique sobre o item de menu em branco logo abaixo do item Ajuda do Sistema; Modifique a propriedade: Caption: - (hífen). Clique sobre o item de menu em branco logo abaixo da linha divisória; Modifique as seguintes propriedades: Caption: Sobre o Sistema; Name: imSobre. O que foi feito? O componente MainMenu permite a criação de menus. Os itens na parte superior são os grupos que podem conter subgrupos de menus. Propriedades manipuladas: Name: define o nome do componente. Caption: Define o nome que será visível ao usuário. Pode conter acentos, espaços, ç, etc. O caracter “&”, quando adicionado na frente de uma letra, cria um atalho que pode ser acionado através da combinação de teclas ALT+ “letra antecedida pelo &”; ShortCut: a propriedade ShortCut lista uma série de combinações de teclas que podem ser atribuídas ao item de menu, chamadas de teclas de aceleração. Alguns itens de menu foram criados com o caracter hífen (“-”) na propriedade Caption. Quando somente este caracter é adicionado, é criado uma linha divisória entre os itens de Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 32 menus. Este recurso é particularmente importante principalmente quando é necessário fazer divisões internas no menu para agrupar funcionalidades relacionadas. 3.4 Conectando o Aplicativo (Delphi) ao Interbase A próxima etapa é conectar o aplicativo que está sendo desenvolvido ao banco de dados Banco.gdb criado no Interbase. No menu File escolha a opção New | Data Module; Modifique a propriedade: Name: DMFuncionarios. No menu File, selecione a opção Save All; Aponte para o diretório C:AplicativoFontes; Nome do arquivo: UDM_Funcionarios; Clique no botão Salvar. 3.4.1 O que são Data Modules? A utilização de Data Modules permite a centralização de componentes não visuais, normalmente componentes relacionados a banco de dados, porém, outros componentes não visuais podem ser adicionados ao Data Module. Figura 9 – Data Module O Data Module, então, funciona como um contêiner para componentes não visuais. Neste caso, será utilizado para acondicionar os componentes que serão necessários para conectar o aplicativo que está sendo desenvolvido ao banco de dados criado no Interbase. Os componentes não visuais podem ser adicionados diretamente no interior do Data Module. Com o auxílio do Object Inspector, as propriedades dos componentes adicionados ao Data Module podem ser alteradas. 3.5 Conectando a Banco.gdb Primeiro precisamos conectar o aplicativo que está sendo desenvolvido ao arquivo .GDB que foi criado no Interbase (Banco.gdb). Esta conexão é feita através do componente IBDatabase que trata especificamente de conexões realizadas com bancos criados no Interbase. Na paleta de componentes, selecione a paleta Interbase; Dê um clique sobre o componente IBDatabase (4º componente) e adicione-o ao Data Module DMFuncionarios; Dê um duplo clique sobre o componente IBDatabase; Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 33 Na janela Database Component Editor modifique os seguintes campos (Figura 10): Database: aponte para o diretório onde encontra-se o arquivo Banco.gdb (C:AplicativoBancoBanco.gdb). Para facilitar a localização do diretório, utilize o botão “Browse”; User Name: SYSDBA; Password: masterkey; Character Set: None; Login Prompt: desmarque esta opção; Clique no botão “OK” para salvar e fechar a janela. Figura 10 – Janela Database Component Editor Modifique as seguintes propriedades do componente IBDatabase (clique no componente IBDatabase para visualizar suas propriedades no Object Inspector): Name: DBBanco; Para conectar-se ao arquivo Banco.gdb, modifique o valor da propriedade Connected (do componente IBDatabase) para True. Se ocorrer alguma mensagem de erro, verifique se todos os passos descritos anteriormente estão corretos. O que foi feito? Campos manipuladas na janela Database Component Editor: DatabaseName: o campo Database aponta o diretório onde está localizado o arquivo .GDB, ou seja, o arquivo que contém todas as informações do banco (metadados) que foi criado para a aplicação. Através desta propriedade pode-se relacionar o aplicativo em desenvolvimento ao banco de dados onde serão armazenadas as informações geradas pela aplicação. User Name: Nome do usuário que está autorizado para acessar o banco; Password: senha do usuário; Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 34 Login Prompt: quando este campo está marcado, toda vez que houver uma conexão com o banco de dados será solicitado o nome do usuário e senha (SYSDBA|masterkey). Se não estiver marcado, não será solicitado o nome do usuário e senha, porém, não será permitido a conexão com o banco de dados. Neste caso, usuário e senha devem ser definidos no campo Settings. Se o nome do usuário e senha estiverem definidos nos campos “User Name” e “Password”, automaticamente, quando for desmarcado esta opção eles serão adicionados no campo “Settings”. Propriedades manipuladas do componente IBDatabase: Name: define o nome do componente IBDatabase. 3.6 Transações e acesso concorrente em banco de dados Um dos conceitos relacionados a banco de dados é transação. Toda transação iniciada em um banco de dados deve ser finalizada com Commit ou Rollback. Commit grava efetivamente todas as modificações (inserção, alteração) realizadas no banco desde o início da transação. Rollback não efetiva nenhuma das modificações (inserção, alteração) realizadas no banco desde o início da transação. 3.6.1 Controlando transações através do componente IBTransaction O componente IBTransaction representa a instância da transação atual e simplifica muito o controle de transações. Com este objeto, é possível controlar transações concorrentes originárias da mesma conexão com o banco de dados, ou em Threads independentes. Para que haja o controle de transações será necessário adicionar o componente IBTransaction no Data Module. Na paleta de componentes, selecione a paleta Interbase; Selecione o componente IBTransaction (5º componente) e adicione-o ao Data Module DMFuncionarios; Modifique as seguintes propriedades: DefaultDatabase: selecione DBBanco; Name: DBTBanco; Active: True. 3.7 Adicionado as tabelas do banco de dados Todo processo de conexão com o banco já foi definido, agora é necessário conectar as tabelas do banco com a aplicação. 3.7.1 Conectando a tabela Departamento Na paleta de componentes, selecione a paleta Interbase; Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 35 Selecione o componente IBTable (1º componente) e adicione-o ao Data Module DMFuncionarios; Modifique as seguintes propriedades: Database: selecione DBBanco; TableName: selecione TB_DEPARTAMENTO; Name: Tb_Departamento; Active: True; Na paleta de componentes, selecione a paleta Data Access; Selecione o componente DataSource (1º componente) e adicione-o ao Data Module DMFuncionarios; Modifique as seguintes propriedades: AutoEdit: False; DataSet: Selecione Tb_Departamento; Name: dsDepartamento; 3.7.2 Conectando a tabela Dependentes Na paleta de componentes, selecione a paleta Interbase; Selecione o componente IBTable (1º componente) e adicione-o ao Data Module DMFuncionarios; Modifique as seguintes propriedades: Database: selecione DBBanco; TableName: selecione TB_DEPENDENTES; Name: Tb_Dependentes; Active: True; Na paleta de componentes, selecione a paleta Data Access; Selecione o componente DataSource (1º componente) e adicione-o ao Data Module DMFuncionarios; Modifique as seguintes propriedades: AutoEdit: False; DataSet: Tb_Dependentes; Name: dsDependentes; 3.7.3 Conectando a tabela Estados Na paleta de componentes, selecione a paleta Interbase; Selecione o componente IBTable (1º componente) e adicione-o ao Data Module DMFuncionarios; Modifique as seguintes propriedades: Database: selecione DBBanco; TableName: selecione TB_ ESTADO; Name: Tb_ Estado; Active: True; Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 36 Na paleta de componentes, selecione a paleta Data Access; Selecione o componente DataSource (1º componente) e adicione-o ao Data Module DMFuncionarios; Modifique as seguintes propriedades: AutoEdit: False; DataSet: Tb_ Estado; Name: dsEstado; 3.7.4 Conectando a tabela Funcionários Na paleta de componentes, selecione a paleta Interbase; Selecione o componente IBTable (1º componente) e adicione-o ao Data Module DMFuncionarios; Modifique as seguintes propriedades: Database: selecione DBBanco; TableName: selecione TB_FUNCIONARIO; Name: Tb_Funcionario; Active: True; Na paleta de componentes, selecione a paleta Data Access; Selecione o componente DataSource (1º componente) e adicione-o ao Data Module DMFuncionarios; Modifique as seguintes propriedades: AutoEdit: False; DataSet: Tb_Funcionario; Name: dsFuncionario; Figura 11 – Data Module DM_Funcionarios com os componentes O que foi feito? Propriedades manipuladas no componente IbTable: Database: identifica o componente Database que representa as tabelas de um banco de dados (.GDB). A propriedade Database deve ser a primeira a ser definida. TableName: utilize esta propriedade para selecionar o nome da tabela a qual o componente IbTable irá representar. Nota: para que a lista das tabelas estejam disponíveis, é necessário especificar o componente Database na propriedade Database. Também é necessário que a propriedade Active do componente IbTable esteja False. Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 37 Name: Define o nome do componente IbTable. Active: quando Active é False, a tabela está fechada, ou seja, o componente IbTable não pode ler ou gravar dados na tabela que está representando. Quando Active é True, os dados podem ser lidos e gravados na tabela. Propriedades manipuladas no componente DataSource: AutoEdit: não permite inserção ou edição automática dos dados. DataSet: conecta o componente DataSource ao componente IbTable. Name: define o nome do componente. IbTable DataSource Sigla BD IBDatabase Descrição (.GDB) IbTable DataSource 3.8 Adicionando os campos das tabelas Até o momento foram realizadas as conexões com o banco e tabelas (veja Figura 11) através dos componentes IbTable e DataSource. Agora, é necessário adicionar os campos das tabelas que foram definidos ao criá-las no Interbase. Adicionando os campos da tabela Departamento: Dê um duplo clique na tabela Departamento (Tb_Departamento); Na janela que aparece (Fields Editor), dê um clique com o botão direito sobre a área em branco e selecione a opção “Add all fields”; Dê um clique sobre o primeiro campo (DPT_CODIGO); digite na propriedade DisplayLabel: Código; Dê um clique sobre o segundo campo (DPT_DESCRICAO); digite na propriedade DisplayLabel: Descrição. Feche a janela Fields Editor. Adicionando os campos da tabela Dependentes: Dê um duplo clique na tabela Dependentes (Tb_Dependentes); Na janela que aparece (Fields Editor), dê um clique com o botão direito sobre a área em branco e selecione a opção “Add all fields”; Dê um clique sobre o primeiro campo (FUN_CODIGO); digite na propriedade DisplayLabel: Cód. Func.; Dê um clique sobre o segundo campo (DEP_CODIGO); digite na propriedade DisplayLabel: Cód. Depend.; Dê um clique sobre o terceiro campo (DEP_NOME); digite na propriedade DisplayLabel: Nome; Dê um clique sobre o quarto campo (DEP_DATANASCIMENTO); digite na propriedade DisplayLabel: Data Nasc.; digite na propriedade EditMask: !99/99/9999;1;_ Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 38 Dê um clique sobre o quinto campo (DEP_PARENTESCO); digite na propriedade DisplayLabel: Parentesco; Feche a janela Fields Editor. Adicionando os campos da tabela Estado: Dê um duplo clique na tabela Estado (Tb_Estado); Na janela que aparece (Fields Editor), dê um clique com o botão direito sobre a área em branco e selecione a opção “Add all fields”; Dê um clique sobre o primeiro campo (EST_SIGLA); digite na propriedade DisplayLabel: Sigla; Dê um clique sobre o segundo campo (EST_DESCRICAO); digite na propriedade DisplayLabel: Descrição; Feche a janela Fields Editor. Adicionando os campos da tabela Funcionários: Dê um duplo clique na tabela Funcionário (Tb_Funcionario); Na janela que aparece (Fields Editor), dê um clique com o botão direito sobre a área em branco e selecione a opção “Add all fields”; Dê um clique sobre o primeiro campo (FUN_CODIGO); digite na propriedade DisplayLabel: Código; Dê um clique sobre o segundo campo (EST_SIGLA); digite na propriedade DisplayLabel: Estado; Dê um clique sobre o terceiro campo (DPT_CODIGO); digite na propriedade DisplayLabel: Cód. Depto.; Dê um clique sobre o quarto campo (FUN_NOME); digite na propriedade DisplayLabel: Nome; Dê um clique sobre o quinto campo (FUN_DATANASCIMENTO); digite na propriedade DisplayLabel: Data Nasc.; digite na propriedade EditMask: !99/99/9999;1;_ Dê um clique sobre o sexto campo (FUN_DDDRESIDENCIAL); digite na propriedade DisplayLabel: DDD; digite na propriedade EditMask: !(99);0;_ Dê um clique sobre o sétimo campo (FUN_FONERESIDENCIAL); digite na propriedade DisplayLabel: Tel.; digite na propriedade EditMask: !9999-9999;1;_ Dê um clique sobre o oitavo campo (FUN_RUA); digite na propriedade DisplayLabel: Logradouro; Dê um clique sobre o nono campo (FUN_COMPLEMENTO); digite na propriedade DisplayLabel: Complemento; Dê um clique sobre o décimo campo (FUN_BAIRRO); digite na propriedade DisplayLabel: Bairro; Dê um clique sobre o décimo primeiro campo (FUN_CIDADE); digite na propriedade DisplayLabel: Cidade; Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 39 Dê um clique sobre o décimo segundo campo (FUN_CEP); digite na propriedade DisplayLabel: CEP; digite na propriedade EditMask: !99.999-999;0;_ Dê um clique sobre o décimo terceiro campo (FUN_SALARIO); digite na propriedade DisplayLabel: Salário; modifique a propriedade Currency para True; Feche a janela Fields Editor. O que foi feito? Propriedades manipuladas na janela Fields Editor: DisplayLabel: permite determinar um nome para o campo que seja compreensível para o usuário. EditMask: quando existe a necessidade de formatar a entrada de dados, máscaras são recursos poderosos que o desenvolvedor deve utilizar. Através desta propriedade é possível definir as máscaras de entrada de dados. A máscara “!99.999-999;1;_” pode ser utilizada para formatar a entrada de CEP. Seu formato, no momento da entrada de dados seria: __.___-___. Neste exemplo, o número 9 (nove) indica que somente um valor numérico é aceito nesta posição, porém, não é obrigatório. O número 1 (um) no final da máscara indica que a máscara será gravada juntamente com seu conteúdo no banco de dados, ou seja, além dos oito dígitos do CEP, serão gravados ainda mais dois caracteres: o ponto (.) e o hífen (-). Neste caso, quando necessitamos gravar a máscara, é importante ficar atento para o tamanho que será definido para o campo no banco de dados. Caso a máscara seja somente para visualização (não há a necessidade de gravá-la com os dados), basta trocar o número 1 que está no final da máscara por 0 (zero), ex.: “!99.999-999;0;_”. Finalmente, o último caracter da máscara (_) indica que os espaços serão preenchidos por sublinha (_). Se quiséssemos que os espaços fossem preenchidos por zeros, por exemplo, bastaria trocar o sublinha por 0 (zero), ex.: “!99.999-999;1;0”. Existem outros caracteres que são utilizados para definir máscaras de entrada de dados. Para maiores informações consulte o Help do Delphi. Currency: quando o campo tratar-se de valor monetário e existir a necessidade de formatá-lo para moeda, basta passar para True o valor desta propriedade. Esta propriedade somente aparecerá para campos do tipo Real (ponto flutuante). 3.9 Adicionando campos Lookup Freqüentemente ocorre a necessidade da utilização de campos Lookup. Exemplificando, quando um funcionário é cadastrado, é necessário ler uma sigla do Estado (UF) para seu endereço residencial. Os Estados (UF) estarão cadastrados na tabela Estado, portanto, seria coerente adicionar um combobox listando os estados cadastrados para que o usuário selecione um dentre os cadastrados. Este tipo de recurso evita a digitação de uma sigla de estado que não exista, validando a informação e garantindo assim a integridade dos dados. Existem duas maneiras de adicionar campos Lookup: 1º. Utilizando o componente DBLookupComboBox presente na paleta Data Controls e; 2º. Adicionando diretamente no Fields Editor. Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 40 A segunda opção é mais interessante pelo fato do campo Lookup aparecer como um componente Grid, o que não ocorreria com a primeira opção. Adicionando campo Lookup na tabela funcionário para Estado: Dê um duplo clique sobre a tabela Funcionário (Tb_Funcionario); Na janela Fields Editor, dê um clique com o botão direito e selecione a opção “New Field...”; Na janela New Field (veja Figura 12), modifique as seguintes propriedades: Name: Estado; Type: selecione String; Size: 40; Marque o botão Lookup; DataSet: selecione Tb_Estado; Result Field: selecione EST_DESCRICAO; Lookup Keys: selecione EST_SIGLA; Key Fields: selecione EST_SIGLA; Clique no botão OK; Selecione o campo Estado no Fields Editor; Digite na propriedade DisplayLabel: Estado. Figura 12 – Definição de campo Lookup na tabela funcionário Adicionando campo Lookup na tabela funcionário para Departamento: Dê um duplo clique sobre a tabela Funcionário (Tb_Funcionario); Na janela Fields Editor, dê um clique com o botão direito e selecione a opção “New Field...”; Na janela New Field, modifique as seguintes propriedades: Name: Departamento; Type: selecione String; Size: 50; Marque o botão Lookup; DataSet: selecione Tb_Departamento; Result Field: selecione DPT_DESCRICAO; Lookup Keys: selecione DPT_CODIGO; Key Fields: selecione DPT_CODIGO; Clique no botão OK; Selecione o campo Departamento no Fields Editor; Digite na propriedade DisplayLabel: Departamento. Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 41 O que foi feito? Campos manipulados na janela New Field: Name: define o nome do campo Lookup (sem acentos, espaços, etc.); Type: define o tipo do campo Lookup que está sendo criado; Size: define o tamanho do campo Lookup; DataSet: define a origem do campo (qual tabela); Result Field: define qual campo da tabela origem será visível para o usuário; Lookup Keys: define qual é o campo chave da tabela origem que será gravado na tabela destino; Key Fields: define o campo de destino que receberá o valor do campo de origem; 3.10 Cadastro de Estados A próxima etapa é a criação dos cadastros necessários para o funcionamento do sistema. Nos próximos tópicos será abordado como criar formulários em tempo de execução, métodos do componente IbTable, tratamento de erros de banco de dados, etc. Figura 13 – Formulário de Cadastro de Estados Definindo as propriedades do formulário: No menu File, selecione a opção New | Form; Modifique as seguintes propriedades do formulário: Caption: Cadastro de Estados (UF); Height: 300; Name: FC_Estados; Position: poScreenCenter; Width: 500. Salvando o formulário: No menu File, selecione a opção “Save”; Verifique se o diretório apontado é c:AplicativoFontes; Nomeie o arquivo para: UFC_Estados; Clique no botão Salvar. Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 42 Adicionando os campos de entrada de dados: No Data Module DM_Funcionarios, dê um duplo clique sobre a tabela Estado (Tb_Estado) para visualizar o Fields Editor; Arraste a janela Fields Editor para o canto superior direito da tela; Visualize o formulário FC_Estados (Shift+F12); Clique sobre o campo EST_SIGLA na janela Fields Editor e arraste para o formulário FC_Estados; Uma caixa de confirmação deverá aparecer perguntando se você quer adicionar a unit do Data Module na cláusula uses do formulário Estados, clique no botão Yes; Clique sobre o campo EST_DESCRICAO no Fields Editor e arraste sobre o formulário FC_Estados (posicione conforme Figura 13). Adicionando uma grid para visualizar os dados cadastrados: Na paleta de componentes Data Controls, selecione o componente DBGrid e adicione-o ao formulário; Modifique as seguinte propriedades: Align: alBottom; {alinha a grid na parte inferior do formulário} Height: 150; {define a altura da grid} Name: grdDados; {define o nome do componente grid} ReadOnly: True; {não permite a edição dos dados através da grid} DataSource: selecione DMFuncionarios.dsEstado. {define a tabela origem de dados} Construindo a Barra de botões: Na paleta de componentes Standard, selecione o componente Panel e adicione-o ao formulário; Modifique as seguintes propriedades: Align: alBottom; {alinha o painel na parte inferior do formulário} BevelOuter: bvLowered; {deixa o painel em baixo relevo} Caption: deixe em branco; {não mostra o caption do painel} Height: 50; {define a altura do painel} Name: pnlBarraBotao. {define o nome do componente} Definindo os botões da barra: Na paleta de componentes Additional, selecione o componente BitBtn e adicione-o na barra de botões (7 botões BitBtn) (veja Layout final na Figura 14); Modifique as seguintes propriedades dos botões: Primeiro botão: Caption: &Novo; {define o caption e tecla de atalho} Glyph: selecione um ícone para o botão; {define uma imagem} *Dica: procure em Arquivos de Programas/Arquivos Comuns/Borland Shared/ Images/Buttons Height: 48; {define a altura do botão} Hint: digite “Adiciona um novo registro”; {define a mensagem (hint) de ajuda} Layout: blGlyphTop; {coloca a imagem na parte superior} Name: btnNovo; {define o nome do componente} ShowHint: True; {habilita a visualização do hint} Width: 65. {define a largura do botão} Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 43 Segundo botão: Caption: &Salvar; Enabled: False; Glyph: selecione um ícone para o botão; Height: 48; Hint: digite “Salva o registro atual”; Layout: blGlyphTop; Name: btnSalvar; ShowHint: True; Width: 65. Terceiro botão: Caption: &Alterar; Glyph: selecione um ícone para o botão; Height: 48; Hint: digite “Altera o registro atual”; Layout: blGlyphTop; Name: btnAlterar; ShowHint: True; Width: 65. Quarto botão: Caption: &Cancelar; Enabled: False; Glyph: selecione um ícone para o botão; Height: 48; Hint: digite “Cancela inclusão/alteração”; Layout: blGlyphTop; Name: btnCancelar; ShowHint: True; Width: 65. Quinto botão: Caption: &Excluir; Glyph: selecione um ícone para o botão; Height: 48; Hint: digite “Exclui o registro atual”; Layout: blGlyphTop; Name: btnExcluir; ShowHint: True; Width: 65. Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 44 Sexto botão: Caption: &Pesquisar; Glyph: selecione um ícone para o botão; Height: 48; Hint: digite “Pesquisa de dados”; Layout: blGlyphTop; Name: btnPesquisar; ShowHint: True; Width: 65. Sétimo botão: Caption: &Sair; Glyph: selecione um ícone para o botão; Height: 48; Hint: digite “Sai do formulário”; Layout: blGlyphTop; Name: btnSair; ShowHint: True; Width: 65. Figura 14 – Barra de botões 3.10.1 Habilitando e Desabilitando os botões da barra Como pode ser percebido, dois botões da barra ficaram desabilitados (Enabled = False). Os botões Salvar e Cancelar somente podem ficar habilitados se houver uma inclusão ou alteração dos dados. Para gerenciar estas mudanças, criaremos um procedimento. Na unit do formulário Estados (utilize F12 para visualizá-la), encontre a seção Public e logo abaixo da palavra Public, declare o procedimento: procedure HabilitaBotao(Ativar: Boolean); posicione o cursor na procedure que acabou de criar e pressione a combinação de teclas Ctrl+Shift+C para criar o corpo do procedimento; Digite o seguinte código (apenas o indicado pela chave, o resto já foi criado): procedure TFC_Estados.HabilitaBotao(Ativar: Boolean); begin btnNovo.Enabled := Ativar; btnSalvar.Enabled := not Ativar; btnAlterar.Enabled := Ativar; btnCancelar.Enabled := not Ativar; btnExcluir.Enabled := Ativar; btnPesquisar.Enabled := Ativar; btnSair.Enabled := Ativar; grdDados.Enabled := Ativar; end; Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 45 3.10.2 Adicionando código aos botões da barra Código do Botão Novo: Dê um duplo clique sobre o botão Novo para chamar o evento OnClick; Adicione o seguinte código: try //inicia bloco protegido DMFuncionarios.Tb_Estado.Insert; //Coloca a tabela em modo de inserção ActiveControl := DBEdit1; // coloca o foco no DBEedit1 (sigla do estado) HabilitaBotao(False); //Habilita e desabilita botões da barra except begin //inicio tratamento caso ocorra erros Application.MessageBox('Erro ao inserir. Operação Cancelada.','Erro',mb_IconError+mb_Ok); DMFuncionarios.Tb_Estado.Cancel; //cancela a inserção caso ocorra algum erro end; //end do begin do except end; //end do try Código do botão Salvar: Dê um duplo clique sobre o botão Salvar para chamar o evento OnClick; Adicione o código abaixo: try DMFuncionarios.Tb_Estado.Post; //Salva os dados da tabela HabilitaBotao(True); //Habilita e desabilita botões da barra except Application.MessageBox('Erro ao salvar. Operação não concluída.','Erro',mb_IconError+mb_Ok); end; //end do try Código do botão Alterar Dê um duplo clique sobre o botão Alterar para chamar o evento OnClick; Adicione o código abaixo: try DMFuncionarios.Tb_Estado.Edit; //coloca a tabela em modo de alteração HabilitaBotao(False); //Habilita e desabilita botões da barra except begin Application.MessageBox('Erro ao alterar. Operação cancelada.','Erro',mb_IconError+mb_Ok); DMFuncionarios.Tb_Estado.Cancel; //Cancela a alteração end; //end do begin do except end; //end do try Código do botão Cancelar Dê um duplo clique sobre o botão Cancelar para chamar o evento OnClick; Adicione o código abaixo: DMFuncionarios.Tb_Estado.Cancel; //Cancela inserção/alteração dos dados HabilitaBotao(True); //Habilita e desabilita botões da barra Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 46 Código do botão Excluir Dê um duplo clique sobre o botão Excluir para chamar o evento OnClick; Adicione o código abaixo: {verifica se existem registros na tabela antes de excluir} if DMFuncionarios.Tb_Estado.RecordCount = 0 then {= 0 indica tabela vazia} begin Application.MessageBox('Não existem registros para excluir.','Erro',mb_IconError+mb_Ok); exit; //sai do procedimento sem executar as linhas a seguir end; if Application.MessageBox('Confirma Exclusão?', 'Confirmação', mb_IconQuestion+mb_YesNo) = idYes then begin try DMFuncionarios.Tb_Estado.Delete; //deleta o registro atual da tabela except Application.MessageBox('Erro ao excluir.','Erro',mb_IconError+mb_Ok); end; //end do try end; //end do if Código do botão Sair Dê um duplo clique sobre o botão Sair para chamar o evento OnClick; Adicione o código abaixo: Close; //fecha o formulário 3.10.3 Adicionando código ao formulário Além dos códigos adicionados na barra de botões, existem ainda algumas precauções que devem ser tomadas. Por exemplo: se o usuário clicar no botão Alterar, fizer alterações e clicar no botão Sair sem salvar os dados, as mudanças realizadas no cadastro não serão efetivadas. Devemos também garantir que a tabela de Estados esteja ativa quando o formulário de Estados for chamado. Estes procedimentos podem ser implementados nos eventos existentes no formulário. Código de abertura do formulário: Selecione o formulário (verifique se o nome do formulário aparece na parte superior (combobox) do Object Inspector); Selecione a aba Events do Object Inspector para visualizar os eventos do formulário; Localize o evento “OnCreate”, dê um duplo clique sobre a caixa em branco logo a frente do nome do evento para chamar o Editor de Código do evento; Digite o código abaixo: {verifica se a tabela está fechada (Active = False)} if DMFuncionarios.Tb_Estado.Active = False then DMFuncionarios.Tb_Estado.Active := True; Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 47 Código de fechamento do formulário: Selecione o formulário; Selecione a aba Events do Object Inspector para visualizar os eventos do formulário; Localize o evento “OnCloseQuery”, dê um duplo clique sobre a caixa em branco logo a frente do nome do evento para chamar o Editor de Código do evento; Digite o código abaixo: {Verifica se o estado da tabela está em inserção ou edição} if DMFuncionarios.Tb_Estado.State in [dsInsert, dsEdit] then if Application.MessageBox('Deseja salvar os dados?', 'Confirmação', mb_IconQuestion+mb_YesNo)= idYes then CanClose := False //Não permite o fechamento do formulário else //Else do "Application.MessageBox('Deseja ..." begin DMFuncionarios.Tb_Estado.Cancel; //Cancela a inclusão/Alteração CanClose := True; //permite o fechamento do formulário end //end do else "Application.MessageBox('Deseja ..." else //Else do "if DMFuncionarios.Tb_Estado.State ..." CanClose := True; //permite o fechamento do formulário Aviso: no código de fechamento do formulário existe uma condição que verifica se o estado da tabela está em modo de inserção ou edição (if DMFuncionarios.Tb_Estado.State in [dsInsert, dsEdit] then). A propriedade “Estado” (state) armazena o estado da tabela e pode receber diversos valores (dsInactive, dsBrowse, dsEdit, dsInsert, dsSetKey, dsCalcFields, dsFilter, dsNewValue, dsOldValue, dsCurValue, dsBlockRead, dsInternalCalc, dsOpening). Para que esta linha de código execute é necessário adicionar na cláusula uses, no início da Unit, a unit Db, caso contrário o Delphi irá gerar um erro: Undeclared identifier: 'dsInsert'. Veja o exemplo: ... uses Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs, ExtCtrls, StdCtrls, Buttons, Mask, DBCtrls, Grids, DBGrids, Db; ... 3.10.4 Validações de dados Toda aplicação deve conter validações que garantam a consistência dos dados. Verificar se o código já existe (violação de chave primária − Key Violation) e se os campos obrigatórios estão preenchidos (campos requeridos) são algumas das validações necessárias na maioria das aplicações. 3.10.4.1 Verificando a consistência de chave primária: Existem várias maneiras de verificar a repetição do valor da chave primária. Neste exemplo, vamos trabalhar com querys, para explorar os recursos deste componente. Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 48 Visualize o Data Module DMFuncionarios (Shift+F12); Na paleta de componentes Interbase, selecione o componente IBQuery e adicione-o ao Data Module DM_Funcionarios; Modifique as seguintes propriedades do componente IBQuery: Database: selecione DBBanco; Name: qryValidaPk; O próximo passo é definir o código no formulário de cadastros de Estados que irá verificar a existência de Estados já cadastrados: Visualize o formulário de Estados (Shift+ F12); Na seção public da Unit (UFC_Estados) declare o seguinte procedimento: procedure ValidaChave(Chave: String); Pressione a combinação de teclas (Shift+Ctrl+C) para criar o corpo do procedimento; Digite o seguinte código: {Verifica se a tabela está em modo de inserção ou edição} if DMFuncionarios.Tb_Estado.State in [dsInsert, dsEdit] then begin DMFuncionarios.qryValidaPk.Active:= False; //desativa a query DMFuncionarios.qryValidaPk.SQL.Clear; //Limpa o conteúdo de cláusulas SQL da query {Adiciona uma cláusula SQL} DMFuncionarios.qryValidaPk.SQL.Add('Select EST_SIGLA from Tb_Estado where EST_SIGLA= '''+ chave+''''); DMFuncionarios.qryValidaPk.Active:= True; //Ativa a query {Verifica se existem registros na query} if DMFuncionarios.qryValidaPk.RecordCount > 0 then begin Application.MessageBox('Este estado já está cadastrado.','Erro',mb_IconError+mb_Ok); DMFuncionarios.Tb_Estado.Cancel; //Cancela a inserção/Alteração; HabilitaBotao(True); ////Habilita e desabilita botões da barra DMFuncionarios.Tb_Estado.Locate('EST_SIGLA', chave, []); //posiciona no registro existente end; //end do "if DMFuncionarios.qryValidaPk.RecordCount..." DMFuncionarios.qryValidaPk.Active:= False; //Desativa a query end; Agora é só chamar o procedimento de validação. Podemos chamar este procedimento ao sair do DBEdit1. Chamada do procedimento através do DBEdit1: Clique no componente DBEdit1; Selecione a aba “Events” do Object Inspector para visualizar os eventos do DBEdit1; Localize o evento “OnExit” (ao sair), dê um duplo clique sobre a caixa em branco logo a frente do nome do evento para chamar o Editor de Código do evento; Digite o seguinte código: if DBEdit1.Text <> '' then {Chama o procedimento de validação de chave primária} ValidaChave(DBEdit1.Text); Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 49 O que foi feito? Explicação das propriedades e métodos utilizados nos códigos. Tabela Estado (Tb_Estado) TTable.Insert: Método que coloca a tabela em modo de inserção de dados (inclusão). Para que este método execute é necessário que a tabela esteja ativa (Active deve ser igual a True); TTable.Post: método que grava os dados na tabela. Para que este método seja executado é necessário que a tabela esteja no modo de inserção ou edição; TTable.Edit: método que coloca a tabela em modo de edição (alteração). A tabela deve estar ativa. TTable.Cancel: método que cancela uma inserção ou edição da tabela. TTable.Delete: método que exclui o registro selecionado. TTable.RecordCount: propriedade que retorna a quantidade de registros existentes na tabela. TTable.Active: propriedade que define quando uma tabela está aberta ou não. Tabela aberta = True. Tabela fechada = False; TTable.State: indica o estado da tabela, os mais importantes são: dsInactive: tabela fechada; dsBrowse: tabela está no modo de navegação; dsEdit: tabela está no modo de edição (alteração); dsInsert: tabela está no modo de inserção; dsSetKey: tabela está no modo de pesquisa; dsCalcFields: (campos calculados) um cálculo está em progresso; dsFilter: processo de filtragem em progresso; TTable.Locate: (usado em DMFuncionarios.Tb_Estado.Locate('EST_SIGLA', chave, []);) pesquisa o conteúdo de um ou mais registros e posiciona o cursor. 1º Parâmetro: nomes dos campos onde será realizada a pesquisa entre aspas simples; 2º parâmetro: valor a ser pesquisado no(s) campo(s) entre aspas simples; 3º parâmetro (opcional): define opções de pesquisa sendo duas opções: loCaseInsensitive: não diferencia letras maiúsculas de minúsculas; loPartialKey: efetua busca de valores retornando valores de campos parciais, exemplo: “Cam” poderia retornar “Campos”, “Campinas” etc. Esta função é aplicada tanto para tabelas como para Queryes. Query qryValidaPk: TQuery.Active: determina se a query está fechada (False) ou aberta (True); TQuery.Sql.Clear: limpa as cláusulas SQL que estão armazenadas na propriedade SQL. TQuery.Add: adiciona cláusulas SQL na propriedade SQL. Mensagem: (Application.MessageBox('Este estado já está cadastrado.','Erro',mb_IconError+mb_Ok);) Application.MessageBox: define uma caixa de mensagem genérica. 1º parâmetro: mensagem que será exibida para o usuário. 2º parâmetro: título da caixa de mensagem. 3º parâmetro: botões que serão adicionados a caixa de mensagem. Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 50 3.10.4.2 Verificando os campos de preenchimento obrigatório Para verificar os campos que devem ser preenchidos (obrigatórios) será implementada uma função que irá verificar, antes de salvar, se existe algum campo requerido que esteja com valor nulo, caso exista, aparece uma mensagem e a operação é cancelada. Visualize o formulário de Estados (Shift+ F12); Na seção public da Unit (UFC_Estados) declare a seguinte função: function VerificaCampoObrigatorio: Boolean; Pressione a combinação de teclas (Shift+Ctrl+C) para criar o corpo da função; Digite o seguinte código com exceção das linhas em cinza: function TFC_Estados.VerificaCampoObrigatorio: Boolean; var i : integer;//declaração de variável local begin //executa loop até o número de registros existentes na tabela for i:= 0 to DMFuncionarios.Tb_Estado.Fields.Count - 1 do begin {Verifica se o campo é obrigatório} if DMFuncionarios.Tb_Estado.Fields[i].Required = true then begin {Verifica se existe valor para o campo} if DMFuncionarios.Tb_Estado.Fields[i].IsNull then begin Application.MessageBox(PChar('Campo obrigatório: '+DMFuncionarios.Tb_Estado.Fields[i].DisplayLabel), 'Erro',mb_IconError+mb_Ok); VerificaCampoObrigatorio := True; //retorna True, existe campo obrigatório sem preencher Break; //cancela o loop; end else VerificaCampoObrigatorio:= False; //retorna False, não existe campo obrigatório sem preencher end; end; A próxima etapa é chamar a função. Isto pode ser feito no evento “OnClick” do botão Salvar (btnSalvar) adicionando uma condição antes de salvar os dados (Post). Dê um duplo clique no botão salvar (btnSalvar); Antes da palavra reservada “try” digite o seguinte código (as duas primeiras linhas assinaladas): ⇒ if VerificaCampoObrigatorio = True then ⇒ exit; try DMFuncionarios.Tb_Estado.Post; //Salva os dados da tabela HabilitaBotao(True); //Habilita e desabilita botões da barra Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 51 3.10.5 Pesquisa do Cadastro de Estados Figura 15 – Formulário de Pesquisa de Estados Definindo as propriedades do formulário: No menu File, selecione a opção New | Form para criar um novo formulário; Modifique as seguintes propriedades do novo formulário: BorderStyle: selecione bsDialog; Caption: Pesquisa de Estados; Height: 300; Name: FP_Estados; Position: selecione poScreenCenter; Width: 500; No menu File, selecione a opção Save; Verifique se o diretório atual é c:AplicativoFontes; Nomeie o arquivo para: UFP_Estados; Clique no botão Salvar. Definindo as propriedades do componente RadioGroup: Na paleta de componentes Standard, selecione o componente RadioGroup e adicione-o ao formulário na parte superior esquerda (veja Figura 15); Modifique as seguintes propriedades: Caption: “Pesquisa por:”; Height: 80; Items: clique no botão com reticências e adicione duas linhas: “Sigla” e “Descrição”; ItemIndex: 0 (zero); Name: rgOpcao; Width: 120. Definindo as propriedades do componente Label: Na paleta de componentes Standard, selecione o componente Label e adicione-o ao formulário (veja Figura 15); Modifique as seguintes propriedades: Caption: “Texto da pesquisa”; Font: deixe em negrito; Name: lblTexto; Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 52 Definindo as propriedades do componente Edit: Na paleta de componentes Standard, selecione o componente Edit e adicione-o ao formulário (veja Figura 15); Modifique as seguintes propriedades: CharCase: ecUpperCase; //Transforma todos os caracteres em maiúsculo Name: edtTexto; Text: deixe em branco. Definindo as propriedades do componente BitBtn de pesquisa: Na paleta de componentes Additional, selecione o componente BitBtn e adicione-o ao formulário (veja Figura 15); Modifique as seguintes propriedades: Caption: &Pesquisar; Font: deixe em negrito; Glyph: defina uma figura para o botão, de preferência a mesma utilizada no botão Pesquisar do formulário Estado; Name: btnPesquisar; Width: 125. Definindo as propriedades do componente BitBtn para sair do formulário: Na paleta de componentes Additional, selecione o componente BitBtn e adicione-o ao formulário (veja Figura 15); Modifique as seguintes propriedades: Caption: &Sair; Font: deixe em negrito; Glyph: defina uma figura para o botão, de preferência a mesma utilizada no botão Sair do formulário Estado; Name: btnSair; Width: 125. Definindo a Query de pesquisa: Visualize o Data Module DMFuncionarios (Shift+F12); Na paleta de componentes Interbase, selecione o componente IBQuery e adicione-o ao Data Module; Modifique as seguintes propriedades: Database: selecione DBBanco; Name: qryPesquisas. Na paleta de componentes Data Access, selecione o componente DataSource e adicione-o ao Data Module; Modifique as seguintes propriedades: AutoEdit: False; //quando Falso não permite que os dados sejam alterados na grid DataSet: selecione qryPesquisas; Name: dsQryPesquisa. Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 53 Definindo a grid de visualização dos dados da pesquisa: Visualize o formulário de Pesquisa de Estados (FP_Estado) (Shift+F12); Na paleta de componentes Data Controls, selecione o componente DBGrid e adicione-o ao formulário de Pesquisa de Estados; No menu File, selecione a opção Use Unit; Na janela Use Unit, selecione UDM_Funcionarios e clique no botão Ok. Isto permitirá que o formulário de Pesquisa de Estados utilize os componentes do Data Module DMFuncionarios; Modifique as seguintes propriedades da DBGrid: Align: alBottom; DataSource: selecione DMFuncionarios.dsQryPesquisa; Height: 180; Name: dbgPesquisa; Options: clique no sinal de + ao lado do nome da propriedade para visualizar as subpropriedades e, na subpropriedade dgTitles, selecione False; ReadOnly: True. O que foi feito? Propriedades manipuladas no componente RadioGroup: Items: esta propriedade permite adicionar uma lista de opções de botões de seleção. Para cada linha adicionada no editor, é criado uma opção. O primeiro elemento da linha (Sigla) recebe o índice 0 (zero), o segundo elemento da lista (Descrição) recebe 1 e, se houvessem mais seguiriam esta seqüência. Portanto, os elementos da lista iniciam em 0 (zero.) ItemIndex: utilize esta propriedade para definir um valor inicial para sua lista assinalando um elemento, se definirmos o valor 0 (zero) para esta propriedade, será marcado o primeiro elemento da lista, valor 1 marca o segundo elemento da lista e assim por diante. Adicionando o código do botão Pesquisar: Dê um duplo clique sobre o botão Pesquisar para chamar o evento “OnClick”; Digite o seguinte código: if edtTexto.Text = '' then //se não houver texto para pesquisa begin Application.MessageBox('Informe o texto da pesquisa.','Erro',mb_IconError+mb_Ok); ActiveControl:= edtTexto; //foco no Edit exit; //sai do procedimento de pesquisa end else //senão existe texto para pesquisa if rgOpcao.ItemIndex = 0 then //se a sigla estiver selecionada como opção de pesquisa begin DMFuncionarios.qryPesquisas.Active:= False; //fecha a query de pesquisa DMFuncionarios.qryPesquisas.Sql.Clear; //limpa o conteúdo da propriedade SQL DMFuncionarios.qryPesquisas.Sql.Add('Select * from Tb_Estado'); DMFuncionarios.qryPesquisas.Sql.Add('where EST_SIGLA starting with '''+edtTexto.Text+''''); DMFuncionarios.qryPesquisas.Active:= True; //abre a query if DMFuncionarios.qryPesquisas.RecordCount = 0 then //verifica a qtde de registros da pesquisa Application.MessageBox('Sigla não encontrada.','Erro',mb_IconError+mb_Ok); Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 54 end else //senão ItemIndex = 1, ou seja, a opção de pesquisa é pela descrição begin DMFuncionarios.qryPesquisas.Active:= False; //fecha a query de pesquisa DMFuncionarios.qryPesquisas.Sql.Clear; //limpa o conteúdo da propriedade SQL DMFuncionarios.qryPesquisas.Sql.Add('Select * from Tb_Estado'); DMFuncionarios.qryPesquisas.Sql.Add('where EST_DESCRICAO starting with '''+edtTexto.Text+''''); DMFuncionarios.qryPesquisas.Active:= True; //abre a query if DMFuncionarios.qryPesquisas.RecordCount = 0 then //verifica a qtde de registros da pesquisa Application.MessageBox('Descrição não encontrada.','Erro',mb_IconError+mb_Ok); end; Código do botão Sair: Dê um duplo clique no botão Sair; Adicione o seguinte código: if DMFuncionarios.qryPesquisas.RecordCount <> 0 then //verifica a qtde de registros da pesquisa DMFuncionarios.Tb_Estado.Locate('EST_SIGLA',DMFuncionarios.qryPesquisas.fieldByName('EST_SIGLA').Value ,[ ]); DMFuncionarios.qryPesquisas.Active:= False; //fecha a query Close; //fecha o formulário O procedimento para fechar o formulário possui uma condição que verifica se existem registros na query através da propriedade RecordCount. Se não houver registro, ou seja, a consulta não foi bem sucedida, a query e o formulário são fechados, porém, se existir registros, através da função Locate posiciona-se no registro da Tabela Estado que seja igual ao registro selecionado na grid do formulário. Chamando o formulário de Pesquisa: O próximo passo é chamar o formulário de Pesquisa através do botão Pesquisar. Para isso será necessário alguns passos: Visualize o Formulário de Cadastro de Estados (FC_Estados) (Shift+F12); No menu File, escolha a opção “Use Unit...”; Selecione o formulário de pesquisa (UFP_Estados) e clique no botão Ok; Dê um duplo clique no botão Pesquisar (btnPesquisar); Adicione o seguinte código: try //inicia bloco protegido Application.CreateForm(TFP_Estados,FP_Estados);//aloca memória para o formulário FP_Estados.ShowModal; //mostra o formulário finally //executa a linha abaixo se ocorrer algum erro FP_Estados.Release; //libera o formulário da memória end; //end finally No menu Project, selecione “Options...”; Na aba Forms, localize o formulário de Pesquisa de Estado (FP_Estados) que se encontra na caixa de listagem Auto-create Forms e mova-o para a caixa de listagem Available Forms utilizando o botão com sinal de maior (>); Clique no botão Ok. Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 55 O que foi feito? Código do botão: Application.CreateForm: usado em Application.CreateForm(TFP_Estados,FP_Estados); permite a criação de formulário em tempo de execução, precisa de dois parâmetros (separados por vírgula): 1º Nome do formulário antecedido da letra “T” (parâmetro de classe) e, 2º nome do formulário (variável de referência). Nesta linha apenas é alocada memória para o formulário; ShowModal: mostra o formulário; Release: libera o formulário da memória quando o mesmo for fechado através do método Close. Project|Options: Toda vez que um formulário é adicionado ao projeto, o Delphi automaticamente assume a “responsabilidade” de alocar memória para este formulário e, quando a aplicação é executada todos os formulários são criados na memória (criados, porém não visualizados). Isto pode incorrer em um problema: se uma aplicação contiver “n” formulários, quando for executada a aplicação, todos os formulários serão alocados na memória podendo ocorrer falta de memória. Para resolver esta situação devemos assumir a responsabilidade de criação e destruição de formulários. Para isso, é necessário criar o formulário em tempo de execução, ou seja, somente vamos criar o formulário (alocar memória) quando o formulário for necessário e, isto é realizado através do código sugerido para o botão Pesquisar. Toda vez que houver a necessidade de criar um formulário, pode-se utilizar o mesmo código mudando apenas os parâmetros de criação. Entretanto, uma vez utilizado este código, é necessário tirar a “responsabilidade” do Delphi em alocar memória para o formulário, uma vez que a tomamos através do código sugerido no botão Pesquisar. Isto é feito através da opção Project|Options na aba Forms quando mudamos o formulário da caixa de listagem Auto-create Forms para listagem Available Forms, com isso assumimos a responsabilidade de criar, mostrar e liberar o formulário da memória. Um benefício imediato é que a aplicação ficará mais leve, uma vez que não será alocada memória para diversos formulários quando a aplicação for executada. Chamando o Cadastro de Estados pelo Menu Principal: Visualize o formulário Menu Principal (FPrincipal) (Shift+F12); No menu Cadastros, dê um clique no subitem Estados; Digite o seguinte código: try Application.CreateForm(TFC_Estados,FC_Estados); //aloca memória para o formulário FC_Estados.ShowModal; //mostra o formulário finally FC_Estados.Release; //libera da memória end; No menu Project, selecione “Options...”; Na aba Forms, localize o formulário de Estado (FC_Estados) que se encontra na caixa de listagem Auto-create forms e mova-o para a caixa de listagem Available forms utilizando o botão com sinal de maior (>); Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 56 Clique no botão Ok. 3.11 Construindo formulários modelo (Repositório) Os próximos formulários de cadastros seguirão o mesmo padrão do formulário de Cadastro de Estados com algumas modificações. Para acelerar o processo de desenvolvimento de um aplicativo, o Delphi dispõe de recursos que agilizam a programação através do reaproveitamento de código. No caso dos formulários, podemos utilizar um formulário já construído para implementar outros formulários que possuirão as mesmas características (o mesmo código com algumas modificações). 3.11.1 Adicionando o formulário de Cadastro de Estados ao Repositório Visualize o Formulário de Cadastro de Estados (FC_Estados) (Shift+F12); Dê um clique com o botão direito do mouse sobre o formulário; No menu suspenso, selecione a opção “Add to Repository...”; Na janela Add To Repository, modifique os seguintes campos: Title: Modelo de Cadastro; Description: Modelo para cadastro; Page: selecione Forms; Author: digite seu nome; Clique no botão Ok; 3.11.2 Adicionando o formulário de Pesquisa de Estados ao Repositório Visualize o Formulário de Pesquisa de Estados (FP_Estados) (Shift+F12); Dê um clique com o botão direito do mouse sobre o formulário; No menu suspenso, selecione a opção “Add to Repository...”; Na janela Add To Repository, modifique os seguintes campos: Title: Modelo de Pesquisa; Description: Modelo para pesquisa; Page: selecione Forms; Author: digite seu nome; Clique no botão Ok; 3.12 Cadastro de Departamento Os demais formulários terão basicamente as mesmas características. Entretanto, vamos reaproveitar o código definido no Cadastro de Estados e, com algumas alterações, vamos construir os demais formulários economizando tempo. Nas seções anteriores, adicionamos o formulário de Estados ao repositório do Delphi e, através deste recurso, será reaproveitado o formulário na construção dos demais. Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 57 Figura 16 – Formulário de Cadastro de Departamentos No menu File, escolha “New” Escolha a opção “Other...” Na janela New Items, escolha a aba Forms; Localize o ícone com o título “Modelo de Cadastro”; Certifique-se de que o botão de opção “Copy” (na parte inferior), esteja selecionado; Clique no botão Ok. Neste exato momento, uma cópia do formulário Modelo de Cadastro deve estar visível. Agora é só efetuar algumas alterações para que o Cadastro de Departamento esteja pronto em pouco tempo. Propriedades do formulário que devem ser alteradas: Caption: Cadastro de Departamentos; Name: FC_Departamentos. Salvando o formulário: No menu File, escolha “Save”; Certifique-se de estar apontando para o diretório c:AplicativoFontes; Nome do arquivo: UFC_Departamentos; Clique no botão Salvar. Modificando os componentes do formulário: Delete os dois componentes DBEdit e Label; Clique sobre a grid e, no Object Inspector, na propriedade DataSource, escolha: DMFuncionarios.dsDepartamento; Visualize o Data Module DMFuncionarios (Shift+F12); Dê um duplo clique sobre a tabela Departamento (Tb_Departamento); Arraste a janela Fields Editor para o canto direito superior do vídeo; Visualize o formulário de Cadastro de Departamentos (FC_Departamentos) (Shift+F12); Na janela Fields Editor, selecione e arraste o primeiro campo (DPT_CODIGO) para o formulário e solte na posição desejada (veja Figura 16); Na janela Fields Editor, selecione e arraste o segundo campo (DPT_DESCRICAO) para o formulário e solte na posição desejada (veja Figura 16); Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 58 Modificando o código fonte: Pressione a tecla F12 para visualizar o editor de código fonte; Posicione o cursor na primeira linha do código fonte; No menu Search, escolha “Replace...”; Na caixa de edição “Text to find”, digite: Tb_Estado; Na caixa de edição “Replace with”, digite: Tb_Departamento; Clique no botão “Replace All”; A medida que o texto procurado é localizado, uma caixa de mensagem pedirá confirmação para a substituição do texto; Localize o corpo da procedure ValidaChave; Substitua a linha: DMFuncionarios.qryValidaPk.SQL.Add('Select EST_SIGLA from Tb_Estado where EST_SIGLA='''+ chave+''''); Por: DMFuncionarios.qryValidaPk.SQL.Add('Select DPT_CODIGO from Tb_Departamento where DPT_CODIGO='''+ chave+''''); Substitua a linha: Application.MessageBox('Este estado já está cadastrado.','Erro',mb_IconError+mb_Ok); Por: Application.MessageBox('Este departamento já está cadastrado.','Erro',mb_IconError+mb_Ok); Substitua na linha: DMFuncionarios.Tb_Departamento.Locate('EST_SIGLA', chave, []); Por: DMFuncionarios.Tb_Departamento.Locate('DPT_CODIGO', chave, []); 3.12.1 Pesquisa do Cadastro de Departamentos Também vamos reaproveitar o formulário de Pesquisa de Estados que adicionamos ao repositório para construir o formulário de Pesquisa de Departamentos. Figura 17 – Formulário de Pesquisa de Departamentos No menu File, escolha “New | Other...” Na janela New Item, escolha a aba Forms; Localize o ícone com o título “Modelo de Pesquisa”; Certifique-se de que o botão de opção “Copy” (na parte inferior), esteja selecionada; Clique no botão Ok. Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 59 Propriedades do formulário que devem ser alteradas: Caption: Pesquisa de Departamentos; Name: FP_Departamentos. Salvando o formulário: No menu File, escolha “Save”; Certifique-se de estar apontando para o diretório c:AplicativoFontes; Nome do arquivo: UFP_Departamentos; Clique no botão Salvar. Modificando os componentes do formulário: Clique sobre o componente RadioGroup (rgOpcao); Modifique a propriedade: Items: substitua a linha Sigla por Código. Modificando o código fonte: Dê um duplo clique sobre o botão Pesquisar; Substitua a linha: DMFuncionarios.qryPesquisas.Sql.Add('Select * from Tb_Estado'); Por: DMFuncionarios.qryPesquisas.Sql.Add('Select * from Tb_Departamento'); Substitua a linha: DMFuncionarios.qryPesquisas.Sql.Add('where EST_SIGLA starting with '''+edtTexto.Text+''''); Por: DMFuncionarios.qryPesquisas.Sql.Add('where DPT_CODIGO starting with '''+edtTexto.Text+''''); Substitua a linha: Application.MessageBox('Sigla não encontrada.','Erro',mb_IconError+mb_Ok); Por: Application.MessageBox('Código não encontrado.','Erro',mb_IconError+mb_Ok); Substitua a linha: DMFuncionarios.qryPesquisas.Sql.Add('Select * from Tb_Estado'); Por: DMFuncionarios.qryPesquisas.Sql.Add('Select * from Tb_Departamento'); Substitua a linha: DMFuncionarios.qryPesquisas.Sql.Add('where EST_DESCRICAO starting with '''+edtTexto.Text+''''); Por: DMFuncionarios.qryPesquisas.Sql.Add('where DPT_DESCRICAO starting with '''+edtTexto.Text+''''); Visualize o formulário de Pesquisa de Departamento (F12); Dê um duplo clique sobre o botão Sair; Substitua a linha: DMFuncionarios.Tb_Estado.Locate('EST_SIGLA',DMFuncionarios.qryPesquisas.fieldByName('EST_SIGLA').Value,[]); Por: DMFuncionarios.Tb_Departamento.Locate('DPT_CODIGO',DMFuncionarios.qryPesquisas.fieldByName('DPT_CODIGO').Value,[]); Alterando o código do botão pesquisar do formulário de Cadastro de Departamentos: Visualize o formulário de Cadastro de Departamentos (FC_Departamentos); Dê um duplo clique no botão Pesquisar; Substitua as linhas: Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 60 try Application.CreateForm(TFP_Estados,FP_Estados); FP_Estados.ShowModal; Finally FP_Estados.Release; end; Por: try Application.CreateForm(TFP_Departamentos, FP_Departamentos); FP_Departamentos.ShowModal; Finally FP_Departamentos.Release; end; No menu File, escolha Use Unit...; Escolha “UFP_Departamentos” e clique no botão Ok; No menu Project, selecione “Options...”; Na aba Forms, localize o formulário de Pesquisa de Departamentos (FP_Departamentos) que se encontra na caixa de listagem Auto-create forms e mova-o para a caixa de listagem Available forms utilizando o botão com sinal de maior (>); Clique no botão Ok. Chamando o Cadastro de Departamentos pelo Menu Principal: Visualize o formulário Menu Principal (FPrincipal) (Shift+F12); No menu Cadastros, dê um clique no subitem Departamentos; Digite o seguinte código: try Application.CreateForm(TFC_Departamentos, FC_Departamentos); //aloca memória para o formulário FC_Departamentos.ShowModal; //mostra o formulário finally FC_Departamentos.Release; //libera da memória end; No menu Project, selecione “Options...”; Na aba Forms, localize o formulário de Cadastro de Departamentos (FC_Departamentos) que se encontra na caixa de listagem Auto-create forms e mova-o para a caixa de listagem Available forms utilizando o botão com sinal de maior (>); Clique no botão Ok. No menu File, escolha Use Unit...; Escolha “UFC_Departamentos” e clique no botão Ok; 3.13 Cadastro de Funcionários A próxima etapa é a construção do Cadastro de Funcionários que será elaborado através do modelo adicionado ao repositório do Delphi. Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 61 Figura 18 – Formulário de Cadastro de Funcionários No menu File, escolha “New | Other...” Na janela New Item, escolha a aba Forms; Localize o ícone com o título “Modelo de Cadastro”; Certifique-se de que o botão de opção “Copy” (na parte inferior), esteja selecionado; Clique no botão Ok. Propriedades do formulário que devem ser alteradas: Caption: Cadastro de Funcionários; Name: FC_Funcionarios. Salvando o formulário: No menu File, escolha “Save”; Certifique-se de estar apontando para o diretório c:AplicativoFontes; Nome do arquivo: UFC_Funcionarios; Clique no botão Salvar. Modificando os componentes do formulário: Delete os dois componentes DBEdit e Label; Clique sobre a grid e, no Object Inspector, na propriedade DataSource, escolha: DMFuncionarios.dsFuncionario; Visualize o Data Module DMFuncionarios (Shift+F12); Dê um duplo clique sobre a Tabela Funcionário (Tb_Funcionario); Arraste a janela Fields Editor para o canto direito superior do vídeo; Visualize o formulário de Cadastro de Funcionários (FC_Funcionarios) (Shift+F12); Aumente o formulário na altura e comprimento pois serão adicionados vários campos e precisamos de maior espaço (veja Figura 18); Na janela Fields Editor, selecione e arraste o primeiro campo (FUN_CODIGO) para o formulário e solte na posição desejada; Faça este mesmo procedimento para os outros campos, na ordem apresentada a seguir (oriente-se pela Figura 18): Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 62 FUN_NOME; FUN_DDDRESIDENCIAL; FUN_FONERESIDENCIAL; FUN_DATANASCIMENTO; Departamento (Campo Lookup) e não DPT_CODIGO; FUN_SALARIO; FUN_RUA; FUN_COMPLEMENTO; FUN_BAIRRO; FUN_CEP; FUN_CIDADE e; Estado (Campo Lookup) e não EST_SIGLA; Clique sobre o painel de botões (pnlBarraBotao), e não sobre os botões; Modifique a propriedade Align de “alBottom” para “alNone”; Clique sobre o componente grid (grdDados) e pressione a combinação de teclas Ctrl+X para recortar a grid; Selecione a paleta de componentes Win32, adicione o componente PageControl (segundo componente) no local onde estava posicionado a grid; Modifique as seguintes propriedades do componente PageControl: Align: alBottom; Name: pcFuncionario. Clique com o botão direito do mouse sobre o componente PageControl e selecione a opção “New Page” do menu suspenso; Modifique as seguintes propriedades: Caption: Funcionários; Name: tsFuncionarios. Clique com o botão direito do mouse sobre o componente PageControl e selecione a opção “New Page” do menu suspenso; Modifique as seguintes propriedades: Caption: Dependentes; Name: tsDependentes. Clique sobre o painel de botões (pnlBarraBotão), e não sobre os botões; Modifique a propriedade Align de “alNone” para “alBottom”; Clique no centro da aba Funcionários do componente Page Control para selecionar o componente TabSheet Funcionários (tsFuncionarios); Se você não copiou nada na memória, pressione a combinação de teclas Ctrl+V para colar a grid; Clique sobre o componente grid e modifique a propriedade Align para “alClient”; Clique na aba Dependentes do componente PageControl; Clique no centro da aba Dependentes para selecionar o componente TabSheet Dependentes (tsDependentes); Se você não copiou nada na memória, pressione a combinação de teclas Ctrl+V para colar a grid; Clique sobre o componente grid e modifique as propriedades: Align: “alClient”; DataSource: DMFuncionarios.dsDependentes; Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 63 Name: grdDependentes. Modificando o código fonte: Pressione a tecla F12 para visualizar o editor de código fonte; Posicione o cursor na primeira linha do código fonte; No menu Search, escolha “Replace...”; Na caixa de edição “Text to find”, digite: Tb_Estado; Na caixa de edição “Replace with”, digite: Tb_Funcionario; Clique no botão “Replace All”; A medida que o texto procurado é localizado, uma caixa de mensagem pedirá confirmação para a substituição do texto; Localize o corpo da procedure ValidaChave; Substitua a linha: DMFuncionarios.qryValidaPk.SQL.Add('Select EST_SIGLA from Tb_Funcionario where EST_SIGLA = '''+ chave+''''); Por: DMFuncionarios.qryValidaPk.SQL.Add('Select FUN_CODIGO from Tb_Funcionario where FUN_CODIGO = '''+ chave+''''); Substitua a linha: Application.MessageBox('Este estado já está cadastrado.','Erro',mb_IconError+mb_Ok); Por: Application.MessageBox('Este Funcionário já está cadastrado.','Erro',mb_IconError+mb_Ok); Substitua na linha: DMFuncionarios.Tb_Funcionario.Locate('EST_SIGLA', chave, []); Por: DMFuncionarios.Tb_Funcionario.Locate('FUN_CODIGO', chave, []); 3.13.1 Pesquisa do Cadastro de Funcionários Figura 19 – Formulário de Pesquisa de Funcionários No menu File, escolha “New | Other...” Na janela New Item, escolha a aba Forms; Localize o ícone com o título “Modelo de Pesquisa”; Certifique-se de que o botão de opção “Copy” (na parte inferior), esteja selecionado; Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 64 Clique no botão Ok. Propriedades do formulário que devem ser alteradas: Caption: Pesquisa de Funcionários; Name: FP_Funcionarios. Salvando o formulário: No menu File, escolha “Save”; Certifique-se de estar apontando para o diretório c:AplicativoFontes; Nome do arquivo: UFP_Funcionarios; Clique no botão Salvar. Modificando componentes do formulário: Clique sobre o componente RadioGroup (rgOpcao); Modifique a propriedade: Items: substitua a linha Sigla por Código. Items: substitua a linha Descrição por Nome. Modificando o código fonte: Dê um duplo clique sobre o botão Pesquisar; Substitua a linha: DMFuncionarios.qryPesquisas.Sql.Add('Select * from Tb_Estado'); Por: DMFuncionarios.qryPesquisas.Sql.Add('Select * from Tb_Funcionario'); Substitua a linha: DMFuncionarios.qryPesquisas.Sql.Add('where EST_SIGLA starting with '''+edtTexto.Text+''''); Por: DMFuncionarios.qryPesquisas.Sql.Add('where FUN_CODIGO starting with '''+edtTexto.Text+''''); Substitua a linha: Application.MessageBox('Sigla não encontrada.','Erro',mb_IconError+mb_Ok); Por: Application.MessageBox('Código não encontrado.','Erro',mb_IconError+mb_Ok); Substitua a linha: DMFuncionarios.qryPesquisas.Sql.Add('Select * from Tb_Estado'); Por: DMFuncionarios.qryPesquisas.Sql.Add('Select * from Tb_Funcionario'); Substitua a linha: DMFuncionarios.qryPesquisas.Sql.Add('where EST_DESCRICAO starting with '''+edtTexto.Text+''''); Por: DMFuncionarios.qryPesquisas.Sql.Add('where FUN_NOME starting with '''+edtTexto.Text+''''); Substitua a linha: Application.MessageBox('Descrição não encontrada.','Erro',mb_IconError+mb_Ok); Por: Application.MessageBox('Nome não encontrado.','Erro',mb_IconError+mb_Ok); Visualize o formulário de Pesquisa de Funcionários (F12); Dê um duplo clique sobre o botão Sair; Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 65 Apague as linhas de código e adicione as linhas abaixo: if DMFuncionarios.qryPesquisas.RecordCount <> 0 then //verifica a qtde de registros da pesquisa {posiciona no registro da tabela estado que seja igual ao registro selecionado no gride} DMFuncionarios.Tb_Funcionario.Locate('FUN_NOME',DMFuncionarios.qryPesquisas.fieldByName('FUN_NOME').Value,[]); DMFuncionarios.qryPesquisas.Active:= False; //fecha a query Close; //fecha o formulário Alterando o código do botão pesquisar do formulário de Cadastro de Funcionários: Visualize o formulário de Cadastro de Funcionários (FC_Funcionarios) (Shift+F12); Dê um duplo clique no botão Pesquisar; Substitua as linhas: try Application.CreateForm(TFP_Estados,FP_Estados); FP_Estados.ShowModal; Finally FP_Estados.Release; end; Por: try Application.CreateForm(TFP_Funcionarios, FP_Funcionarios); FP_Funcionarios.ShowModal; Finally FP_Funcionarios.Release; end; No menu File, escolha Use unit...; Escolha “UFP_Funcionarios” e clique no botão Ok; No menu Project, selecione “Options...”; Na aba Forms, localize o formulário de Pesquisa de Funcionários (FP_Funcionarios) que se encontra na caixa de listagem Auto-create Forms e mova-o para a caixa de listagem Available Forms utilizando o botão com sinal de maior (>); Clique no botão Ok. Chamando o Cadastro de Funcionários pelo Menu Principal: Visualize o formulário Menu Principal (FPrincipal) (Shift+F12); No menu Cadastros, dê um clique no subitem Departamentos; Digite o seguinte código: try Application.CreateForm(TFC_Funcionarios, FC_Funcionarios); //aloca memória para o formulário FC_Funcionarios.ShowModal; //mostra o formulário finally FC_Funcionarios.Release; //libera da memória end; No menu Project, selecione “Options...”; Na aba Forms, localize o formulário de Cadastro de Funcionários (FC_Funcionarios) que se encontra na caixa de listagem Auto-create Forms e mova-o para a caixa de listagem Available Forms utilizando o botão com sinal de maior (>); Clique no botão Ok. Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 66 No menu File, escolha Use unit...; Escolha “UFC_Funcionarios” e clique no botão Ok; 3.14 Cadastro de Dependentes Finalmente vamos construir o Cadastro de Dependentes. Figura 20 – Cadastro de Dependentes No menu File, escolha “New | Other...” Na janela New Item, escolha a aba Forms; Localize o ícone com o título “Modelo de Cadastro”; Certifique-se de que o botão de opção “Copy” (na parte inferior), esteja selecionado; Clique no botão Ok. Propriedades do formulário que devem ser alteradas: Caption: Cadastro de Dependentes; Name: FC_Dependentes. Salvando o formulário: No menu File, escolha “Save”; Certifique-se de estar apontando para o diretório c:AplicativoFontes; Nome do arquivo: UFC_Dependentes; Clique no botão Salvar. Modificando os componentes do formulário: Delete os dois componentes DBEdit e Label; Clique sobre a grid e, no Object Inspector, na propriedade DataSource, escolha: DMFuncionarios.dsDependentes; Visualize o Data Module DMFuncionarios (Shift+F12); Dê um duplo clique sobre a tabela Dependentes (Tb_Dependentes); Arraste a janela Fields Editor para o canto direito superior do vídeo; Visualize o formulário de Cadastro de Dependentes (FC_Dependentes) (Shift+F12); Na janela Fields Editor, selecione e arraste o terceiro campo (DEP_NOME) para o formulário e solte na posição desejada (veja Figura 20); Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 67 Na janela Fields Editor, selecione e arraste o quarto campo (DEP_DATANASCIMENTO) para o formulário e solte na posição desejada; Não adicione os campos: FUN_CODIGO, DEP_CODIGO e DEP_PARENTESCO; Escolha na paleta de componentes Data Controls, o componente DBRadioGroup e adicione-o ao formulário. Ajuste o tamanho do formulário se for preciso (veja Figura 20); Modifique as seguintes propriedades: Caption: Parentesco: Columns: 2; DataSource: selecione DMFuncionarios.dsDependentes; DataField: selecione DEP_PARENTESCO; Items: adicione a lista abaixo, para cada item uma linha: Pai Mãe Esposa Filho(a) Irmão(ã) Values: adicione a lista abaixo, para cada item uma linha: Pai Mãe Esposa Filho(a) Irmão(ã) Modificando o código fonte: Pressione a tecla F12 para visualizar o editor de código fonte; Posicione o cursor na primeira linha do código fonte; No menu Search, escolha “Replace...”; Na caixa de edição “Text to find”, digite: Tb_Estado; Na caixa de edição “Replace with”, digite: Tb_Dependentes; Clique no botão “Replace All”; A medida que o texto procurado é localizado, uma caixa de mensagem pedirá confirmação para a substituição do texto; Localize o corpo da procedure ValidaChave; Apague todas as linhas (cabeçalho e corpo); Na seção public, apague o cabeçalho da procedure; Adicionando código auto incremental para dependentes: Dê um duplo clique sobre o botão Novo (btnNovo); Faça a inserção das linhas em destaque abaixo à procedure Novo (não se esqueça de declarar a variável ultimo): procedure TFC_Dependentes.btnNovoClick(Sender: TObject); var ultimo : integer; begin try //inicia bloco protegido DMFuncionarios.Tb_Dependentes.Last; //vai para o último registro {Atribui o valor do campo dep_codigo do último registro da tabela dependentes para a variável último} ultimo := DMFuncionarios.Tb_Dependentes.FieldByName('DEP_CODIGO').AsInteger; DMFuncionarios.Tb_Dependentes.Insert; //Coloca a tabela em modo de inserção Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 68 {soma 1 a variável último e atribui ao campo dep_codigo que está sendo inserido} DMFuncionarios.Tb_Dependentes.FieldByName('DEP_CODIGO').AsInteger:= ultimo + 1; ActiveControl := DBEdit1; // coloca o foco no DBEedit1 HabilitaBotao(False); //Habilita e desabilita botões da barra except begin //inicio tratamento caso ocorra erros Application.MessageBox('Erro ao inserir. Operação Cancelada.','Erro',mb_IconError+mb_Ok); //mensagem DMFuncionarios.Tb_Dependentes.Cancel; //cancela a inserção caso ocorra algum erro end; //end do begin do except end; //end do try end; Visualize o formulário de Dependentes e dê um duplo clique sobre o botão Pesquisar; Exclua as linhas entre o begin e end da procedure; Visualize o formulário de Dependentes e delete o botão Pesquisar; Localize a procedure HabilitaBotao e exclua a linha onde consta uma referência ao botão Pesquisar; Ajuste o botão Sair na barra de botões. 3.14.1 Definindo a tabela Dependente como detalhe da tabela Funcionário Certamente seria interessante que somente os dependentes do funcionário atualmente selecionado fossem visualizados. Assim, quando os dados do funcionário “X” estiverem visíveis, ao clicarmos na aba onde está presente a grid de dependentes, somente apareceriam os dependentes do funcionário “X”. Este tipo de visão de dados é chamado de mestre-detalhe, onde mestre é a tabela Funcionário (cardinalidade do lado 1) e detalhe é a tabela Dependentes (cardinalidade do lado n). 3.14.2 Quando posso aplicar o recurso mestre-detalhe ? O recurso mestre-detalhe somente pode ser aplicado para tabelas que possuam relacionamento entre si. Analise a cardinalidade abaixo: 1 N Funcionário Dependente “Um funcionário possui n dependentes”. Quem é a tabela mestre? A tabela mestre sempre será o lado da cardinalidade igual a 1, portanto, neste relacionamento, mestre é funcionário. Logo, detalhe é a tabela do relacionamento onde a cardinalidade é igual a n. As tabelas detalhe (Dependente) sempre receberão a chave primária (FUN_CODIGO) da tabela mestre (Funcionário). Na tabela detalhe, essa chave será chamada de chave estrangeira (lembre-se: chave estrangeira sempre do lado n). Relacionamentos mestre-detalhe nem sempre são aplicados, mesmo que as condições expostas acima sejam satisfeitas. Por exemplo: O relacionamento entre Estados e Funcionários caracteriza uma relação onde pode-se aplicar o recurso mestre-detalhe, onde mestre seria Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 69 Estado e detalhe seria Funcionário (1 estado está contido em n funcionários). Entretanto, se aplicássemos este recurso neste relacionamento, só veríamos funcionários por estado, ou seja, quando posicionarmos no Estado “X”, somente veríamos os funcionários daquele estado. Neste caso, não seria muito interessante aplicar este recurso, porém, cada caso é um caso. Definindo relações mestre-detalhe: Visualize o Data Module DMFuncionarios (Shift+F12); Dê um clique sobre a tabela detalhe (Tb_Dependentes); No Object Inspector, localize a propriedade MasterSource (“Fonte mestre”); Selecione o Data Source mestre (dsFuncionario); Localize a propriedade MasterFields e clique no botão com reticências; Na janela “Field Link Designer” faça o seguinte: Selecione a chave estrangeira (FUN_CODIGO) presente na tabela Dependentes na caixa de seleção “Detail Fields”; Selecione a chave primária (FUN_CODIGO) presente na tabela Funcionários na caixa de seleção “Master Fields”; Dê um clique no botão Add; Dê um clique no botão Ok para finalizar. Pronto, agora somente serão visíveis os dependentes por funcionários. Chamando o cadastro de Dependentes através do Formulário de Funcionários: Visualize o cadastro de Funcionários; Adicione um novo botão na barra de botões; Modifique as seguintes propriedades: Caption: &Dependentes; Glyph: escolha uma nova figura para o botão; Hint: Cadastro de Dependentes; Name: btnDependente; Width: 100. Dê um duplo clique sobre o botão btnDependente; Adicione as seguintes linhas de código entre o begin e end da procedure: try //inicia bloco protegido Application.CreateForm(TFC_Dependentes,FC_Dependentes);//aloca memória para o formulário FC_Dependentes.ShowModal; //mostra o formulário Finally //executa a linha abaixo se ocorrer algum erro FC_Dependentes.Release; //libera o formulário da memória end; //end finally No menu File, escolha “Use Unit...”; Selecione o formulário “UFC_Dependentes” e clique no botão OK. No menu Project, selecione “Options...”; Na aba Forms, localize o formulário de Cadastro de Dependentes (FC_Dependentes) que se encontra na caixa de listagem Auto-create Forms e mova-o para a caixa de listagem Available Forms utilizando o botão com sinal de maior (>); Clique no botão Ok. Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 70 4 RELATÓRIOS O objetivo deste capítulo é a construção de relatórios contendo os dados das tabelas definidas neste curso. Para tanto, serão abordados diversos tipos de relatórios com a finalidade de mostrar alguns dos recursos possíveis. Para tanto, será utilizado os componentes da paleta QReport (Quick Report®) que é um conjunto de componentes destinados para a elaboração de relatórios. Vale lembrar ainda que existem diversos gerados de relatórios que podem ser utilizados para esta tarefa. Para habilitar o Quick Report no Delphi 7 faça o seguinte: - No menu Component... selecione Install Packages. - Na janela Design Packages, clique no botão Add... - Vá até a pasta Delphi7Bin e selecione o arquivo dclqrt70.bpl e clique em abrir. 4.1 Elaborando relatório simples (Relatório de Estados) Elaborar relatórios pode se tornar uma atividade muito complexa, dependendo do tipo de visão que se quer dos dados. Para relatórios simples, ou seja, relatórios que mostram apenas os dados já cadastrados esta tarefa é fácil. Para ilustrar esta situação vamos construir um relatório que vai listar todos os Estados cadastrados. Figura 21 – Relatório de Estados No menu File, escolha “New Form”; Modifique as seguintes propriedades do formulário: Caption: Relatório de Estados; Name: FR_Estados; No menu File, escolha “Save”; Certifique-se de estar apontando para o diretório “C:AplicativoFontes”; Nome do arquivo: UFR_Estados; Clique no botão Salvar; Adicionando os componentes de relatório: Na paleta de componentes QReport, selecione o componente QuickRep e adicione-o ao formulário; No menu File, escolha a opção “Use Unit”; Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 71 Na janela “Use Unit”, escolha o Data Module UDM_Funcionarios; Modifique as seguintes propriedades: DataSet: escolha DMFuncionarios.Tb_Estado; Name: QREstados; ReportTitle: Relatório de Estados; Dê um clique no sinal de + (mais) da propriedade Bands para visualizar as sub propriedades, modifique as seguintes sub propriedades: HasColumnHeader: True; HasDetail: True; HasPageFooter: True; HasTitle: True. Modificando as bandas Title (Título): Dê um clique na primeira banda (Title); Propriedade Height: 50; Dê um clique no sinal de + (mais) da propriedade Frame e modifique as seguintes sub propriedades: DrawBottom: True; Width: 2. Dê um clique na segunda banda (Column Header); Propriedade Height: 30; Dê um clique no sinal de + (mais) da propriedade Frame e modifique as seguintes sub propriedades: DrawBottom: True; Width: 2. Dê um clique na terceira banda (Detail); Propriedade Height: 20. Dê um clique na última banda (PageFooter); Propriedade Height: 30; Dê um clique no sinal de + (mais) da propriedade Frame e modifique as seguintes sub propriedades: DrawTop: True; Width: 2. Definindo o título do relatório de Estados: Na paleta de componentes QReport, selecione o componente QRLabel e adicione-o em cima da prima banda (Title); Modifique as seguintes propriedades do componente QRLabel: Alignment: taCenter; AlignToBand: True; Caption: Relatório de Estados; Font: tamanho 20, em negrito, Fonte: Comic Sans MS; Top: 5. Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 72 Definindo os cabeçalhos das colunas: Na paleta de componentes QReport, selecione o dois (2) componentes QRLabel e adicione- os em cima da banda Column Header (segunda banda); Modifique as seguintes propriedades da primeira QRLabel: Caption: Sigla; Font: tamanho 12 em negrito; Left: 15; Top: 4. Modifique as seguintes propriedades da segunda QRLabel: Caption: Descrição; Font: tamanho 12 em negrito; Left: 100; Top: 4. Definindo os dados que serão listados no relatório: Na paleta de componentes QReport, selecione o dois (2) componentes QRDBText e adicione-os em cima da banda Detail (terceira banda); Modifique as seguintes propriedades da primeira QRDBText: DataSet: selecione DMFuncionarios.Tb_Estado; DataField: selecione EST_SIGLA; Left: 15; Top: 2. Modifique as seguintes propriedades da segunda QRDBText: DataSet: selecione DMFuncionarios.Tb_Estado; DataField: selecione EST_DESCRICAO; Left: 100; Top: 2. Definindo o Rodapé: Na paleta de componentes QReport, selecione o dois (2) componentes QRSysData e adicione-os em cima da banda Page Footer (última banda); Modifique as seguintes propriedades da primeira QRSysData: Data: qrsDateTime; Left: 15; Text: Data/Hora: ; (deixe um espaço em branco após os dois pontos “:”) Top: 8. Modifique as seguintes propriedades da segunda QRSysData: Data: qrsPageNumber; Left: 600; Text: Página: ; (deixe um espaço em branco após os dois pontos “:”) Top: 8. Visualizando o relatório: É possível visualizar o relatório de Estados em tempo de projeto. Dê um clique com o botão direito do mouse sobre o componente QuickRep (não pode ser em cima de nenhuma banda) e selecione a opção Preview do menu suspenso. Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 73 Se tudo ocorreu bem, os dados do relatório serão listados. Executando o relatório pelo formulário Menu Principal: Visualize o formulário Principal (FPrincipal) (Shift+F12); Dê um clique no menu Relatórios e selecione o item de menu Estados para chamar o evento OnClick; Digite o seguinte código: try Application.CreateForm(TFR_Estados,FR_Estados); //aloca memória para o formulário FR_Estados.QREstados.Preview; //mostra o relatório finally FR_Estados.Release; //libera da memória end; No menu File, escolha “Use unit...”; Na janela Use Unit, escolha “UFR_Estados” e clique no botão Ok; No menu Project, selecione “Options...”; Na aba Forms, localize o formulário de Relatório de Estados (FR_Estados) que se encontra na caixa de listagem Auto-create Forms e mova-o para a caixa de listagem Available Forms utilizando o botão com sinal de maior (>); Clique no botão Ok. 4.2 Elaborando relatório mestre-detalhe (Funcionário e seus Dependentes) Elaborar relatórios onde são listados mais de uma tabela são freqüentes no desenvolvimento de software. Exemplo seria um relatório que listaria todos os funcionários e, para cada funcionário, os seus dependentes. Estes tipos de relatórios são chamados de relatórios mestre-detalhe. Figura 22 – Relatório de Funcionários e Dependentes No menu File, escolha “New Form”; Modifique as seguintes propriedades do formulário: Caption: Relatório de Funcionários e Dependentes; Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 74 Name: FR_FuncionarioDependente; No menu File, escolha “Save”; Certifique-se de estar apontando para o diretório “C:AplicativoFontes”; Nome do arquivo: UFR_FuncionarioDependente; Clique no botão Salvar; Adicionando os componentes de relatório: Na paleta de componentes QReport, selecione o componente QuickRep e adicione-o ao formulário; No menu File, escolha a opção “Use Unit”; Na janela “Use Unit”, escolha o Data Module UDM_Funcionarios; Modifique as seguintes propriedades do componente QuickRep: DataSet: escolha DMFuncionarios.Tb_Funcionario; Name: QRFuncDependente; ReportTitle: Relatório de Funcionários e Dependentes; Dê um clique no sinal de + (mais) da propriedade Bands para visualizar as sub propriedades, modifique as seguintes sub propriedades: HasColumnHeader: True; HasDetail: True; HasPageFooter: True; HasTitle: True. Adicionando a banda detalhe (onde aparecerão os dependentes): Na paleta de componentes QReport, selecione o componente QRSubDetail e adicione-o em cima do componente QuickRep (QRFuncDependente); Se tudo ocorreu bem, a banda QRSubDetail ficou abaixo da banda Detail. Modifique as seguintes propriedades da banda QRSubDetail: DataSet: DMFuncionarios.Tb_Dependentes; Verifique se a propriedade Master está apontando para o componente QRFuncDependente, senão, selecione-o; Height: 20. Modificando as bandas Title (Título): Dê um clique na primeira banda (Title); Propriedade Height: 50; Dê um clique no sinal de + (mais) da propriedade Frame e modifique as seguintes sub propriedades: DrawBottom: True; Width: 2. Dê um clique na segunda banda (Column Header); Propriedade Height: 30; Dê um clique no sinal de + (mais) da propriedade Frame e modifique as seguintes sub propriedades: DrawBottom: True; Width: 2. Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 75 Dê um clique na terceira banda (Detail); Color: clSilver; Height: 20; Dê um clique no sinal de + (mais) da propriedade Frame e modifique as seguintes sub propriedades: DrawBottom: True. Dê um clique na última banda (PageFooter); Propriedade Height: 30; Dê um clique no sinal de + (mais) da propriedade Frame e modifique as seguintes sub propriedades: DrawTop: True; Width: 2. Definindo o título do relatório de Estados: Na paleta de componentes QReport, selecione o componente QRLabel e adicione-o em cima da prima banda (Title); Modifique as seguintes propriedades do componente QRLabel: Alignment: taCenter; AlignToBand: True; Caption: Relatório de Funcionário e Dependentes; Font: tamanho 20, em negrito, Fonte: Comic Sans MS; Top: 5. Definindo os cabeçalhos das colunas: Na paleta de componentes QReport, selecione o dois (2) componentes QRLabel e adicione- os em cima da banda Column Header (segunda banda); Modifique as seguintes propriedades da primeira QRLabel: Caption: Código; Font: tamanho 12 em negrito; Left: 15; Top: 4. Modifique as seguintes propriedades da segunda QRLabel: Caption: Nome do funcionário; Font: tamanho 12 em negrito; Left: 100; Top: 4. Definindo os dados que serão listados dos funcionários no relatório: Na paleta de componentes QReport, selecione o dois (2) componentes QRDBText e adicione-os em cima da banda Detail (terceira banda); Modifique as seguintes propriedades da primeira QRDBText: Color: selecione clSilver; DataSet: selecione DMFuncionarios.Tb_Funcionario; DataField: selecione FUN_CODIGO; Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 76 Left: 15; Top: 2. Modifique as seguintes propriedades da segunda QRDBText: Color: selecione clSilver; DataSet: selecione DMFuncionarios.Tb_Funcionario; DataField: selecione FUN_NOME; Left: 100; Top: 2. Definindo os dados que serão listados dos dependentes no relatório: Na paleta de componentes QReport, selecione o três (3) componentes QRDBText e adicione-os em cima da banda SubDetail (terceira banda); Modifique as seguintes propriedades da primeira QRDBText: DataSet: selecione DMFuncionarios.Tb_Dependentes; DataField: selecione DEP_NOME; Left: 15; Top: 2. Modifique as seguintes propriedades da segunda QRDBText: DataSet: selecione DMFuncionarios.Tb_Dependentes; DataField: selecione DEP_PARENTESCO; Left: 300; Top: 2. Modifique as seguintes propriedades da terceira QRDBText: DataSet: selecione DMFuncionarios.Tb_Dependentes; DataField: selecione DEP_DATANASCIMENTO; Left: 500; Top: 2. Definindo o Rodapé: Na paleta de componentes QReport, selecione o dois (2) componentes QRSysData e adicione-os em cima da banda Page Footer (última banda); Modifique as seguintes propriedades da primeira QRSysData: Data: qrsDateTime; Left: 15; Text: Data/Hora: ; (deixe um espaço em branco após os dois pontos “:”) Top: 8. Modifique as seguintes propriedades da segunda QRSysData: Data: qrsPageNumber; Left: 600; Text: Página: ; (deixe um espaço em branco após os dois pontos “:”) Top: 8. Visualizando o relatório: É possível visualizar o relatório de Estados em tempo de projeto. Dê um clique com o botão direito do mouse sobre o componente QuickRep (não pode ser em cima de nenhuma banda) e selecione a opção Preview do menu suspenso. Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 77 Se tudo ocorreu bem, os dados do relatório serão listados. Executando o relatório pelo formulário Menu Principal: Visualize o formulário Principal (FPrincipal) (Shift+F12); Dê um duplo clique no componente MainMenu para abrir o editor de menus; Dê um clique no menu Relatórios; Dê um clique no submenu funcionários; Dê um clique com o botão direito do mouse sobre o menu Funcionários e selecione a opção “Create Submenu”; No submenu que aparece à direita do submenu Funcionários, modifique as seguintes propriedades: Caption: Dependentes; Name: imRelDependentes. Dê um duplo clique sobre o submenu Dependentes para chamar o evento OnClick; Digite o seguinte código: try Application.CreateForm(TFR_FuncionarioDependente,FR_FuncionarioDependente); FR_FuncionarioDependente.QRFuncDependente. Preview; //mostra o relatório finally FR_FuncionarioDependente.Release; //libera da memória end; No menu File, escolha “Use unit...”; Na janela Use Unit, escolha “UFR_FuncionarioDependente” e clique no botão Ok; No menu Project, selecione “Options...”; Na aba Forms, localize o formulário de Relatório de funcionários e Dependentes (FR_FuncionarioDependente) que se encontra na caixa de listagem Auto-create Forms e mova-o para a caixa de listagem Available Forms utilizando o botão com sinal de maior (>); Clique no botão Ok. 4.3 Utilizando Query para elaborar relatório de Soma de Salários por Departamento Existem situações onde é necessário gerar relatórios onde é necessário somar valores, por exemplo. Esta situação será exemplificada através de um relatório onde serão listados todos os departamentos e a soma de salários deste departamento. Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 78 Figura 23 – Relatório da soma de Salários por Departamento No menu File, escolha “New Form”; Modifique as seguintes propriedades do formulário: Caption: Relatório de salários por departamento; Name: FR_SalariosDepto; No menu File, escolha “Save”; Certifique-se de estar apontando para o diretório “C:AplicativoFontes”; Nome do arquivo: UFR_SalariosDepto; Clique no botão Salvar; Adicionando os componentes de relatório: No menu File, escolha a opção “Use Unit”; Na janela “Use Unit”, escolha o Data Module UDM_Funcionarios; Na paleta de componentes Interbase, selecione o componente IBQuery e adicione-o ao formulário; Modifique as seguintes propriedades do componente IBQuery: DataBase: selecione DMFuncionarios.DBBanco; Name: qrySomaSalarioDepto; Sql: dê um clique no botão com reticências e digite a seguinte sentença sql no editor: select Tb_Departamento.DPT_DESCRICAO, sum(Tb_Funcionario.FUN_SALARIO) from Tb_Departamento, Tb_Funcionario where Tb_Departamento.DPT_CODIGO = Tb_Funcionario.DPT_CODIGO group by Tb_Departamento.DPT_DESCRICAO Dê um clique no botão Ok; Na paleta de componentes QReport, selecione o componente QuickRep e adicione-o ao formulário; Modifique as seguintes propriedades do componente QuickRep: DataSet: escolha qrySomaSalarioDpto; Name: QRSomaSalario; ReportTitle: Relatório de Salários por Departamento; Dê um clique no sinal de + (mais) da propriedade Bands para visualizar as sub propriedades, modifique as seguintes sub propriedades: HasColumnHeader: True; Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 79 HasDetail: True; HasPageFooter: True; HasTitle: True. Modificando as bandas Title (Título): Dê um clique na primeira banda (Title); Propriedade Height: 50; Dê um clique no sinal de + (mais) da propriedade Frame e modifique as seguintes sub propriedades: DrawBottom: True; Width: 2. Dê um clique na segunda banda (Column Header); Propriedade Height: 30; Dê um clique no sinal de + (mais) da propriedade Frame e modifique as seguintes sub propriedades: DrawBottom: True; Width: 2. Dê um clique na terceira banda (Detail); Height: 20; Dê um clique na última banda (PageFooter); Propriedade Height: 30; Dê um clique no sinal de + (mais) da propriedade Frame e modifique as seguintes sub propriedades: DrawTop: True; Width: 2. Definindo o título do relatório de Estados: Na paleta de componentes QReport, selecione o componente QRLabel e adicione-o em cima da prima banda (Title); Modifique as seguintes propriedades do componente QRLabel: Alignment: taCenter; AlignToBand: True; Caption: Relatório de Salários por Departamento; Font: tamanho 20, em negrito, Fonte: Comic Sans MS; Top: 5. Definindo os cabeçalhos das colunas: Na paleta de componentes QReport, selecione o dois (2) componentes QRLabel e adicione- os em cima da banda Column Header (segunda banda); Modifique as seguintes propriedades da primeira QRLabel: Caption: Departamento; Font: tamanho 12 em negrito; Left: 15; Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 80 Top: 4. Modifique as seguintes propriedades da segunda QRLabel: Caption: Soma dos salários; Font: tamanho 12 em negrito; Left: 300; Top: 4. Definindo os dados que serão listados no relatório: Na paleta de componentes QReport, selecione o dois (2) componentes QRDBText e adicione-os em cima da banda Detail (terceira banda); Modifique as seguintes propriedades da primeira QRDBText: DataSet: selecione qrySomaSalarioDpto; DataField: selecione DPT_DESCRICAO; Left: 15; Top: 2. Modifique as seguintes propriedades da segunda QRDBText: DataSet: selecione qrySomaSalarioDpto; DataField: selecione SUM; Left: 300; Mask: R$ #.00 Top: 2. Definindo o Rodapé: Na paleta de componentes QReport, selecione o dois (2) componentes QRSysData e adicione-os em cima da banda Page Footer (última banda); Modifique as seguintes propriedades da primeira QRSysData: Data: qrsDateTime; Left: 15; Text: Data/Hora: ; (deixe um espaço em branco após os dois pontos “:”) Top: 8. Modifique as seguintes propriedades da segunda QRSysData: Data: qrsPageNumber; Left: 600; Text: Página: ; (deixe um espaço em branco após os dois pontos “:”) Top: 8. Visualizando o relatório: É possível visualizar o relatório de Estados em tempo de projeto. Verifique se a propriedade active da Query está true; Dê um clique com o botão direito do mouse sobre o componente QuickRep (não pode ser em cima de nenhuma banda) e selecione a opção Preview do menu suspenso. Se tudo ocorreu bem, os dados do relatório serão listados. Executando o relatório pelo formulário Menu Principal: Visualize o formulário Principal (FPrincipal) (Shift+F12); Prof. Eduardo Cotrin Teixeira
    • Curso de Delphi 7 & Interbase UTFPR – Universidade Tecnológica Federal do PR 81 Dê um duplo clique no componente MainMenu para abrir o editor de menus; Dê um clique no menu Relatórios; Dê um clique na linha em branco logo após o submenu Estados; Modifique as seguintes propriedades: Caption: Departamentos; Name: imDepartamento. Dê um clique com o botão direito do mouse sobre o menu Departamento e selecione a opção “Create Submenu”; No submenu que aparece à direita do submenu Departamento, modifique as seguintes propriedades: Caption: Soma dos Salários por Departamento; Name: imSomaSalario. Dê um duplo clique sobre o submenu “Soma dos Salários por Departamento” para chamar o evento OnClick; Digite o seguinte código: try Application.CreateForm(TFR_SalariosDepto,FR_SalariosDepto); //aloca memória para o formulário FR_SalariosDepto.qrySomaSalarioDepto.Active:= False; //fecha a query FR_SalariosDepto.qrySomaSalarioDepto.Active:= True; //abre a query para que seja atualizada FR_SalariosDepto.QRSomaSalario.Preview; //mostra o relatório finally FR_SalariosDepto.Release; //libera da memória end; No menu File, escolha “Use unit...”; Na janela Use Unit, escolha “UFR_SalariosDpto” e clique no botão Ok; No menu Project, selecione “Options...”; Na aba Forms, localize o formulário de Relatório de Salários por Departamento (FR_SalariosDpto) que se encontra na caixa de listagem Auto-create Forms e mova-o para a caixa de listagem Available Forms utilizando o botão com sinal de maior (>); Clique no botão Ok. Exercícios sugeridos: Construa dois relatórios simples: Um contendo todos os dados dos funcionários e, Outro contendo todos os dados de Departamentos. Prof. Eduardo Cotrin Teixeira