Índice


1      INTRODUÇÃO AO AMBIENTE DELPHI® ................................................. 2
    1.1 AMBIENTE DELPHI...
2.3.3     Cláusula Where (“onde”)............................................................................................
4.2 ELABORANDO RELATÓRIO MESTRE-DETALHE (FUNCIONÁRIO E SEUS DEPENDENTES) ......73
    4.3 UTILIZANDO QUERY PARA ELABORAR R...
Índice de Figuras

Figura 1 – Área de Trabalho...............................................................................
1


                                        ADVERTÊNCIA

       Esta apostila aborda o ambiente Delphi através do desenvol...
Curso de Delphi 7 & Interbase                 UTFPR – Universidade Tecnológica Federal do PR     2



1     INTRODUÇÃO    ...
Curso de Delphi 7 & Interbase                               UTFPR – Universidade Tecnológica Federal do PR               3...
Curso de Delphi 7 & Interbase                    UTFPR – Universidade Tecnológica Federal do PR                     4


1....
Curso de Delphi 7 & Interbase           UTFPR – Universidade Tecnológica Federal do PR      5


1.3.1 Menus
       Os menu...
Curso de Delphi 7 & Interbase             UTFPR – Universidade Tecnológica Federal do PR     6


propriedade é selecionado...
Curso de Delphi 7 & Interbase                 UTFPR – Universidade Tecnológica Federal do PR   7


               TabOrder...
Curso de Delphi 7 & Interbase            UTFPR – Universidade Tecnológica Federal do PR      8


       Portanto, o evento...
Curso de Delphi 7 & Interbase              UTFPR – Universidade Tecnológica Federal do PR     9


1.3.6 Unit
       Nas un...
Curso de Delphi 7 & Interbase           UTFPR – Universidade Tecnológica Federal do PR      10


Tipos reais

Tipo        ...
Curso de Delphi 7 & Interbase                         UTFPR – Universidade Tecnológica Federal do PR         11


        ...
Curso de Delphi 7 & Interbase                     UTFPR – Universidade Tecnológica Federal do PR   12


        Procedimen...
Curso de Delphi 7 & Interbase           UTFPR – Universidade Tecnológica Federal do PR    13


1.4.5 Tratamento de erros (...
Curso de Delphi 7 & Interbase            UTFPR – Universidade Tecnológica Federal do PR     14


       No código acima, s...
Curso de Delphi 7 & Interbase            UTFPR – Universidade Tecnológica Federal do PR     15


           Na janela Brea...
Curso de Delphi 7 & Interbase            UTFPR – Universidade Tecnológica Federal do PR    16




Figura 4 – Paleta de com...
Curso de Delphi 7 & Interbase          UTFPR – Universidade Tecnológica Federal do PR   17



☺Dica: Para visualizar a lis...
Curso de Delphi 7 & Interbase           UTFPR – Universidade Tecnológica Federal do PR 18



2     BANCO   DE DADOS   INTE...
Curso de Delphi 7 & Interbase           UTFPR – Universidade Tecnológica Federal do PR    19


2.3.1 Cláusula Select (“sel...
Curso de Delphi 7 & Interbase           UTFPR – Universidade Tecnológica Federal do PR     20


       c) Mostrar apenas o...
Curso de Delphi 7 & Interbase             UTFPR – Universidade Tecnológica Federal do PR        21


          Select *
  ...
Curso de Delphi 7 & Interbase             UTFPR – Universidade Tecnológica Federal do PR    22


Operador Starting With
  ...
Curso de Delphi 7 & Interbase            UTFPR – Universidade Tecnológica Federal do PR   23


2.4.1 Criando um banco de d...
Curso de Delphi 7 & Interbase          UTFPR – Universidade Tecnológica Federal do PR    24



       A partir deste momen...
Curso de Delphi 7 & Interbase           UTFPR – Universidade Tecnológica Federal do PR    25


2.4.2 Interbase Interactive...
Curso de Delphi 7 & Interbase             UTFPR – Universidade Tecnológica Federal do PR   26


       Definição da tabela...
Curso de Delphi 7 & Interbase            UTFPR – Universidade Tecnológica Federal do PR   27


Palavra chave              ...
Curso de Delphi 7 & Interbase              UTFPR – Universidade Tecnológica Federal do PR 28



3     DESENVOLVENDO      U...
Curso de Delphi 7 & Interbase                       UTFPR – Universidade Tecnológica Federal do PR                 29


  ...
Curso de Delphi 7 & Interbase           UTFPR – Universidade Tecnológica Federal do PR    30


    Adicione um componente ...
Curso de Delphi 7 & Interbase            UTFPR – Universidade Tecnológica Federal do PR     31


    Clique sobre o item d...
Curso de Delphi 7 & Interbase           UTFPR – Universidade Tecnológica Federal do PR   32


      menus. Este recurso é ...
Curso de Delphi 7 & Interbase          UTFPR – Universidade Tecnológica Federal do PR    33


   Na janela Database Compon...
Curso de Delphi 7 & Interbase             UTFPR – Universidade Tecnológica Federal do PR    34


      Login Prompt: quand...
Curso de Delphi 7 & Interbase       UTFPR – Universidade Tecnológica Federal do PR   35


   Selecione o componente IBTabl...
Curso de Delphi 7 & Interbase          UTFPR – Universidade Tecnológica Federal do PR    36


   Na paleta de componentes,...
Curso de Delphi 7 & Interbase            UTFPR – Universidade Tecnológica Federal do PR   37


      Name: Define o nome d...
Material Delphi diego
Material Delphi diego
Material Delphi diego
Material Delphi diego
Material Delphi diego
Material Delphi diego
Material Delphi diego
Material Delphi diego
Material Delphi diego
Material Delphi diego
Material Delphi diego
Material Delphi diego
Material Delphi diego
Material Delphi diego
Material Delphi diego
Material Delphi diego
Material Delphi diego
Material Delphi diego
Material Delphi diego
Material Delphi diego
Material Delphi diego
Material Delphi diego
Material Delphi diego
Material Delphi diego
Material Delphi diego
Material Delphi diego
Material Delphi diego
Material Delphi diego
Material Delphi diego
Material Delphi diego
Material Delphi diego
Material Delphi diego
Material Delphi diego
Material Delphi diego
Material Delphi diego
Material Delphi diego
Material Delphi diego
Material Delphi diego
Material Delphi diego
Material Delphi diego
Material Delphi diego
Material Delphi diego
Material Delphi diego
Material Delphi diego
Upcoming SlideShare
Loading in...5
×

Material Delphi diego

3,008

Published on

Published in: Technology, Education
0 Comments
1 Like
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total Views
3,008
On Slideshare
0
From Embeds
0
Number of Embeds
0
Actions
Shares
0
Downloads
276
Comments
0
Likes
1
Embeds 0
No embeds

No notes for slide

Transcript of "Material Delphi diego"

  1. 1. Í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. 2. 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
  3. 3. 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
  4. 4. Í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
  5. 5. 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
  6. 6. 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
  7. 7. 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
  8. 8. 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
  9. 9. 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
  10. 10. 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
  11. 11. 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
  12. 12. 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
  13. 13. 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
  14. 14. 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
  15. 15. 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
  16. 16. 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
  17. 17. 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
  18. 18. 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
  19. 19. 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
  20. 20. 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
  21. 21. 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
  22. 22. 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
  23. 23. 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
  24. 24. 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
  25. 25. 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
  26. 26. 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
  27. 27. 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
  28. 28. 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
  29. 29. 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
  30. 30. 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
  31. 31. 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
  32. 32. 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
  33. 33. 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
  34. 34. 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
  35. 35. 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
  36. 36. 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
  37. 37. 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
  38. 38. 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
  39. 39. 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
  40. 40. 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
  41. 41. 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

×