Roger

Curso Técnico de Programação Comercial

ROGER SANTOS FERREIRA

FORMIGA2009

Introdução ao

Desenvolvimento de AplicaçõesUtilizando Delphi e Firebird

2

SUMÁRIO

1 – INTRODUÇÃO ....................................................................................................32 – A História do Delphi.............................................................................................43 – Definições Práticas..............................................................................................64 – Aplicabilidade ......................................................................................................85 – Delphi e os Bancos de Dados .............................................................................86 – Instalação do SGBD Firebird 1.5.........................................................................107 – Instalação do IBExpert ........................................................................................12 8 – Trabalhando com o IBExpert...............................................................................14 8.1 – Criando Chaves Primárias..........................................................................16 8.2 – Criando Chaves Estrangeiras.....................................................................17 8.3 – Criando o Auto-incremento das Chaves Primárias.....................................179 – Conhecendo um Pouco Mais do Ambiente Delphi ..............................................18 9.1 – Explanação das Janelas do Delphi.............................................................19 9.1.1 – Barra de Menus ..............................................................................19 9.1.2 – Paleta de Componentes .................................................................19 9.1.3 – Speedbar........................................................................................20 9.1.4 – Object Inspector .............................................................................21 9.1.5 – Form ...............................................................................................22 9.1.6 – Code Editor.....................................................................................2210 – Primeiros passos com o Delphi .........................................................................25 10.1 – Antes de Começar..................................................................................25 10.1.1 – Code Insight .............................................................................25 10.1.2 – Configurações do Ambiente .....................................................26 10.1.3 – Teclas e Atalhos de Teclado Importantes.................................28 10.1.4 – Projetos em Delphi ...................................................................28 10.2 – Primeiro Programa .................................................................................29 10.3 – Informações Sobre os Principais Componentes.....................................32 10.3.1 – Objeto Form..............................................................................32 10.3.2 – Objeto Button............................................................................33 10.3.3 – Objeto Edit................................................................................34 10.3.4 – Objeto Label .............................................................................35 10.3.5 – Objeto Memo............................................................................35 10.3.6 – Objeto Checkbox ......................................................................36 10.3.7 – Objeto PageControl ..................................................................36 10.3.8 – Objeto Panel.............................................................................37 10.3.9 – Objeto StringGrid......................................................................3711 – Trabalhando com Arquivos no Delphi ...............................................................3812 – Trabalhando com Bancos de Dados no Delphi .................................................57

3

1 - INTRODUÇÃO

Antes do Delphi e de outras linguagens visuais, todas as linguagens de

programação eram praticamente iguais, do ponto de vista conceitual. Havia

diferenças de sintaxe, é claro, bem como diferenças importantes de paradigmas,

mas a metodologia da programação em C, por exemplo, era a mesma da

programação em Pascal, Cobol ou Fortran.

As linguagens visuais introduziram estratégias radicalmente novas de

programação. O fato é que, com o passar do tempo, escrever programas passou a

ser cada vez mais difícil, especialmente programas que exigiam interface gráfica.

Entretanto, alguns programadores perceberam que muitas coisas que eram difíceis

de ser feitas, como construir janelas, menus ou botões, podiam ser feitas sempre da

mesma forma. Estes programadores, que já tinham o hábito de colecionar sub-

rotinas de utilização geral, passaram a encapsular algumas destas rotinas em uma

espécie de "objeto" pronto para ser usado. A idéia final, que deu origem ao Delphi,

foi a percepção de que vários destes objetos podiam simplesmente ser desenhados

na tela como se desenha um retângulo ou outra figura qualquer.

O Delphi é um pacote de ferramentas de programação concebido para

programação em Windows. Os objetos são desenhados na tela de forma visual, com

auxílio do mouse, e não por meio de programação. A programação em si é orientada

a eventos. Quando um evento ocorre, tal como uma tecla pressionada ou um clique

de mouse, uma mensagem é enviada para a fila de mensagens do Windows. A

mensagem estará disponível para todos os aplicativos que estiverem rodando, mas

apenas aquele interessado no evento responderá à mensagem. Tudo que o usuário

precisa fazer é detectar o evento e mandar que um trecho de código seja executado

quando isto acontecer. O Delphi torna esta tarefa fantasticamente fácil!

4

2 - A HISTÓRIA DO DELPHI

Delphi (lê-se "dél-fi" mas os americanos pronunciam "dél-fai") é um

compilador e uma IDE para o desenvolvimento de softwares. Ele é produzido pela

Borland Software Corporation (por algum tempo chamada Inprise). A linguagem

utilizada pelo Delphi, o Object Pascal (Pascal com extensões orientadas a objetos) a

partir da versão 7 passou a se chamar Delphi Language. O Delphi, originalmente

direcionado para a plataforma Microsoft Windows, agora desenvolve aplicações

nativas para Linux com o Kylix, e para o Microsoft .NET framework em suas versões

mais recentes. O nome Delphi é inspirado na cidade de Delfos, o único local na

Grécia antiga em que era possível consultar o Oráculo de Delfos. Os

desenvolvedores do compilador buscavam uma ferramenta capaz de acessar um

banco de dados Oracle. Daí veio o trocadilho "a única maneira de acessar o oráculo

é usando Delphi".

Quando lançado em 1995 para a plataforma Windows 16 bits, foi o

primeiro a ser descrito como ambiente RAD (em português, Desenvolvimento Rápido

de Aplicações). A sua segunda versão, lançada um ano depois com o Delphi 2 já

produzia aplicativos para a plataforma Windows 32 bits, sendo que uma versão em

C++, o C++ Builder surgiu alguns anos depois. Em 2001 uma versão para

plataforma Linux, conhecida como Kylix foi disponibilizada.

Em 2002 foi lançada nova versão compatível com Linux (através do Kylix e

a paleta CLX de componentes), sendo que em 2003 o Delphi 8 passou a incluir

suporte para desenvolvimento de aplicações .NET. No final de 2004 foi lançada a

versão Delphi 2005 (correspondente a versão 9), com suporte, na mesma IDE, ao

desenvolvimento para plataformas Windows 32 bits e Windows .NET, além de

integrar no mesmo ambiente de desenvolvimento a possibilidade de se desenvolver

utilizando o ambiente do Delphi, C++ Builder ou C#. No final de 2005 foi lançada a

versão Delphi 2006 (correspondente a versão 10) integrada no Borland Developer

Studio 4.0 com destaque para a total integração com o Borland Together, o preview

do compilador do C++ Builder, atualização dos drivers DBExpress, novos

refactorings e recursos da IDE. Nessa versão o gerenciador de memória utilizado

5

pelo Delphi foi substituído, tornando os aplicativos compilados em Delphi mais

rápidos. Como a ferramenta é compilada utilizando o próprio Delphi, esta nova

versão também está muito rápida.

O arquiteto por trás do Delphi e de seu predecessor Turbo Pascal foi

Ander Hejlsberg, até a sua alteração para a Microsoft em 1996, onde se tornou o

arquiteto responsável pelo projeto do C# e foi peça chave na criação do ambiente

Microsoft .NET, utilizado no Delphi 8. O Delphi teve o formato da IDE alterado pela

primeira vez na versão 8, basicamente similar ao formato do Microsoft Visual Studio

para .NET.

As principais diferenças entre o Delphi/Kylix e outras ferramentas de

desenvolvimento são: a Linguagem Delphi, as paletas VCL e CLX, forte ênfase na

conectividade com diversos bancos de dados e um grande número de componentes

produzidos por terceiros, muitos deles disponíveis na internet e grande parte deles

com o código fonte disponível.

Os defensores do Delphi sustentam que fornecer juntos a linguagem, a

IDE e sua biblioteca de componentes (VCL/CLX) contribui para uma boa

consistência interna e um pacote mais reconhecível. Alguns destacam como

vantagens do Delphi: a existência de uma grande quantidade de componentes

prontos em sua biblioteca, facilidade de uso e aprendizado e desenvolvimento

rápido.

Atualmente a Borland em seu processo de reestruturação, está se focando

em suas ferramentas ALM (Application Life-Cycle Management), devido as recentes

aquisições de empresas. Deixando juntamente com um grupo de investidores a

criação de uma empresa que cuide especialmente dos produtos IDEs (C#Builder,

C++Builder, Delphi, JBuilder, Interbase).

No dia 05 de setembro de 2006 a Borland juntamente com a Developer

Tools Group, grupo responsável pelo desensolvimento das ferramentas IDE, entrega

ao público a linha Turbo, que é praticamente o desmembramento da suíte Borland

Developer Studio (BDS 2006). Em duas versões, Explorer(download gratuito;

6

direcionado a estudantes, inciantes em programação e hobbistas) e a Professional

(pago; direcionado às softwares-houses e profissionais autônomos).

Já no dia 14 de novembro de 2006, a Borland não encontrando um

potencial comprador que atendesse os quesitos que se comprometam com a

evolução das ferramentas IDE, ela decidiu criar uma subsidiária colocando todos

responsáveis pela "DevCo" nessa nova empresa chamada CodeGear. Que,

especialmente cuidará das IDEs.

3 - DEFINIÇÕES PRÁTICAS

Object Pascal: Linguagem Pascal orientada à objetos.

IDE (Integrated Development Environment ou Ambiente de

Desenvolvimento Integrado): O ambiente de desenvolvimento do Delphi é

composto de várias ‘partes’ compondo um conjunto integrado de ‘janelas’ que

interagem entre si.

Form: É o termo utilizado para representar as janelas do Windows que

compõem uma aplicação. Os forms servem como base para o

posicionamento dos componentes, que são responsáveis pela interação entre

usuário e máquina. As características iniciais do form como tamanho, botões

(minimizar, maximizar, fechar, controle) e ícone podem ser modificadas

através do Object Inspector (explicado mais abaixo). Obs.: SHIFT+F12

possibilita a visualização de outros formulários da aplicação.

Barra de Menu/Ferramentas: Como todo programa padrão Windows, há

uma janela onde estão situados os menus da aplicação, a barra que contem

os menus também agrupa outras partes.

Paleta de Componentes: Paleta onde o desenvolvedor encontra todos os

componentes necessários à aplicação. Componentes podem ser adicionados.

No Delphi, os componentes encontram-se em uma paleta com várias guias.

Speedbar: Está posicionada ao lado esquerdo da barra principal do Delphi.

Possui diversos botões (ícones) que representam comandos muito utilizados

7

durante o desenvolvimento como criar novo form, abrir projeto, salvar,

adicionar algum arquivo ao projeto, executar a aplicação (Run), dentre outros.

Object Inspector: Uma das ‘partes’ mais importantes da orientação a objetos

é a possibilidade de definir características personalizadas aos componentes.

O Object Inspector é a paleta de propriedades que o programador pode

atribuir aos componentes utilizados no desenvolvimento. Obs.: pressionando-

se F11, coloca-se o foco no Object Inspector e caso ele tenha sido fechado,

mostra-o novamente na tela.

Code Editor: O editor de código é responsável por receber todas as

declarações criadas pelo Delphi e handlers (Manipulador de eventos) criados

pelo desenvolvedor. É no ambiente Code Editor que são implementados os

algoritmo na linguagem Object Pascal. Obs.: Pressionando-se a tecla F12 a

janela alterna entre Form e Code Editor e CTRL+F12 escolhe qual unit

mostrar.

Object Inspector

Form

Barra de Menu/Ferramentas

Paleta de Componentes

Speedbar

Code Editor

8

4 - APLICABILIDADE

Sendo o mais conhecido dos programas do tipo RAD (Rapid Application

Development) o Delphi não pode ser usado para desenvolvimento de software de

base ou aplicativos de sistema. Entre os engenheiros de software o Delphi é muitas

vezes caracterizado como um "aplicativo programável". O Delphi é largamente

utilizado no desenvolvimento de aplicações desktop e aplicações multicamadas

(cliente/servidor), compatível com os bancos de dados mais conhecidos no mercado.

Como uma ferramenta de desenvolvimento genérica, o Delphi pode ser utilizado

para diversos tipos de desenvolvimento de projetos, abrangendo desde Serviços a

Aplicações Web, Aplicações CTI (tecnologia que permite a integração de

computadores com telefones) e aplicações para dispositivos móveis, tais como

palmtops, pocketPC e outros.

5 - DELPHI E OS BANCOS DE DADOS

Como já citado, o Delphi é compatível com os bancos de dados mais

conhecidos do mercado como: Oracle, Interbase, MS Access, SQL Server, Firebird,

entre muitos outros.

O suporte a bancos de dados é um dos recursos fundamentais do Delphi e

o desenvolvimento deste produto frente a outros tem se baseado enormemente

nesta facilidade. É comum que programadores percam muito tempo

operacionalizando tarefas que o Delphi já oferece prontas. Por esta razão, o Delphi é

conhecido como uma "ferramenta de desenvolvimento rápido", capaz de gerenciar

bancos de dados com um mínimo de código de programação.

Um aplicativo de banco de dados no Delphi não tem acesso direto às

fontes de dados. A interface é feita por meio do Borland Database Engine (BDE),

que tem acesso a várias fontes, incluindo o dBase, o Interbase, o Firebird, Paradox,

ASCII, FoxPro e Access, sendo que estes dois últimos são bancos de dados da

9

Microsoft. Isso significa que, para rodar um aplicativo Delphi em uma máquina que

não tenha o Delphi instalado, será necessário instalar o BDE junto com o aplicativo.

Para tornar esta tarefa mais fácil, a Borland disponibiliza uma versão mais simples

do BDE, que pode ser incluída nos discos de instalação.

O Delphi também permite acessar servidores SQL (Structured Query

Language ou Linguagem de Consulta Estrutrada) locais e remotos e vem

acompanhado do Local Interbase for Windows, da Borland. O BDE também permite

a interface com drivers ODBC, mas este método geralmente é menos eficiente. A

figura abaixo ilustra a estrutura geral de acesso a bases de dados no Delphi.

10

6 – INSTALAÇÃO DO SGBD FIREBIRD 1.5

Primeiramente faz-se necessário o download do pacote de instalação do

Firebird, facilmente encontrado pela internet e principalmente na página oficial do

projeto: http://www.firebirdsql.org/. O Firebird é um banco de dados relacional que

oferece recursos ANSI SQL-99 que rodam no Linux, Windows e plataformas Unix.

Ele oferece alta performance e uma linguagem poderosa para procedimentos e

triggers. Firebird já é usado em sistemas de produção sob uma variedade de nomes

diferentes desde 1981.

Este SGBD é um projeto comercialmente independente de

programadores C e C++, técnicos e analistas que vêm desenvolvendo-o a partir do

código fonte de um sistema de gerenciamento lançado pela Inprise Corp - hoje

conhecida como Borland Software Corp., a fabricante do Delphi.

Tela de boas vindas. Tela de aceitação de contrato.

Informações importantes antes da instalação. Escolha do local de instalação.

11

Escolha dos componentes a serem instalados. Escolha do nome do menu a ser criado no Menu Iniciar do Windows.

Escolha das tarefas adicionais de instalação. Obs.: Recomendado: rodar o Firebird como

serviço do Windows.

Finalizar a instalação.

Pronto! Tendo o SGBD já instalado no computador é fácil de testar se ele

está funcionando. Simplesmente pressionando CTRL+ALT+DEL e verificando a lista

de processos se os processos fbguard.exe e fbserver.exe estão em funcionamento.

12

7 – INSTALAÇÃO DO IBEXPERT

Com o Firebird funcionando corretamente, faz-se necessária a instalação

de um software de manipulação/criação de bases de dados nesse SGBD. O Delphi 5

já traz nativamente o “Database Explorer”, porém ele trabalha somente com bases

PARADOX. Tais bases já não são utilizadas no mercado atual. Como exemplo será

demonstrado a instalação do IBExpert.

IBExpert é uma ferramenta para administração de bancos de dados

Interbase e Firebird. Permite criar e gerenciar usuários e tabelas. A versão gratuita é

para testes. Caso tenha interesse em obter a versão completa, dirija-se ao site oficial

da IBExpert e adquira o gerenciador (www.ibexpert.com). Com IBExpert é possível:

analisar dados, copiar objetos de Bancos de Dados, utilizar ferramentas de SQL,

comparar Bancos de Dados ou tabelas de Bancos de Dados, bem como a opção de

Database designer, para criar tabelas.

Tela de boas vindas. Seleção de ferramentas a serem instaladas.

Aceitação de contrato de uso. Seleção de local de instalação.

13

Finalizar instalação.

O IBEXpert pode ser inicializado pelo atalho criado na área de trabalho ou pelo Menu Iniciar >

Programas > HK – Software > IBExpert > IBExpert.

Ambiente de trabalho do IBExpert.

14

8 – TRABALHANDO COM O IBEXPERT

O trabalho no IBExpert é relativamente simples. Para se criar uma nova

base de dados basta um simples clique no ícone na barra de ferramentas chamado

“Create Database”.

A seguinte janela é mostrada:

Como no exemplo apresentado nesta apostila utilizarei uma base local,

devemos configurar a nova base da seguinte maneira:

Server: Local; Database: “endereço no disco da Base de Dados”, neste caso: “G:\clientes.fdb”; User Name: SYSDBA; Password: MASTERKEY; Charset: UTF8; SQL Dialect: Dialect 3.

Logo após, será mostrada a janela pedindo que se registre a nova base

de dados criada, como demonstra a próxima imagem:

15

Configurações:

Server: Local; Server Version: Firebird 1.5 (ou a versão instalada); Database File: “endereço no disco da Base de Dados”, neste caso: “G:\clientes.fdb”; Database Alias: apelido da base de dados, neste caso: Clientes; User Name: SYSDBA; Password: MASTERKEY; Charset: UTF8; Font Characters Set: ANSI CHARSET.

Depois de feito isso, a base já estará criada. A criação de tabelas e

atributos é simples. Por exemplo: para se criar uma tabela, clique com o botão

direito do mouse em “Tables” no “Database Explorer” e “New Table”, ou

simplesmente pressione CTRL+ENTER.

16

8.1 – Criando chaves primárias

Imagem de uma tabela no IBExpert.

Após criados todos os campos de uma tabela, incluindo seus tipos e

definindo-se quais campos não podem ser nulos (“Not Null”), clica-se em

“Constraints” e na primeira aba aberta “Primary Key” deve-se clicar na área em

branco abaixo com o botão direito do mouse e “New Primary Key”.

Janela pop-up de seleção do campo (“On Field”).

A configuração é simples:

Constraint Name: nome da chave primária para uso interno do SGBD;

On Field: nome do campo da tabela que será Primary Key. Obs.: Clique na coluna esquerda

e envie-o para a coluna direita. Clique na X abaixo para fechar a janela pop-up aberta.

Index Name: Nome do índice que será criado automaticamente. Não obrigatório;

Index Sorting: Classificação dos índices. Não obrigatório.

17

8.2 – Criando chaves estrangeiras

A criação de chaves estrangeiras é tão simples quanto a criação de

chaves primárias, porém alguns fatores devem ser observados. Fatores como:

O campo da tabela que será chave estrangeira deve ter a propriedade “Not Null” habititada;

Obrigatoriamente deve ser do tipo inteiro;

O campo de onde provem a chave estrangeira (tabela pai) obrigatoriamente deve ser chave

primária.

8.3 – Criando o auto-incremento das chaves primárias

Para se criar o auto incremento dos campos de chave primária no

IBExpert proceda da seguinte forma:

Abra a tabela a ser trabalhada;

Dê Duplo-Clique na propriedade (caixa) “Autoinc”;

Marque a opção “Create Generator”;

Clique na 2ª aba chamada “Trigger”;

Marque a opção “Create Trigger”;

Clique em OK para dar um Commit e Finalizar a tarefa.

18

9 – CONHECENDO UM POUCO MAIS DO AMBIENTE DO

DELPHI

Primeiramente vamos iniciar o Delphi, neste caso, depois de instalado, ele

poderá ser encontrado no Menu Iniciar > Programas > Borland Delphi 5 > Delphi 5.

O Delphi se inicia sempre criando um novo projeto por padrão chamado

Project 1, a tela apresentada é similar à mostrada abaixo:

O Delphi é considerado uma ferramenta de desenvolvimento

rápido devido ao fato de se poder fazer muita coisa sem nem mesmo uma linha de

código digitada. A facilidade de se arrastar “componentes” das paletas e adicioná-los

ao Form torna o Delphi uma das IDE’s mais fáceis de se desenvolver aplicações

tanto desktop quanto cliente-servidor.

19

9.1 – Explanações das janelas do Delphi

9.1.1 – Barra de menus

Barra de Menus.

Como todo programa padrão Windows, há uma janela onde estão

situados os menus da aplicação, a barra que contem os menus também agrupa

outras partes. Na barra de menus do Delphi temos a paleta de componentes, o

Speedbar, a barra de ferramentas padrão de toda aplicação Windows, barra de

menus suspensos e barra de desktop.

9.1.2 – Paleta de componentes

Aplicativos orientados a objetos trabalham com elementos que são

denominamos componentes. No Delphi, os componentes encontram-se em uma

paleta com várias guias.

Paleta de Componentes.

Pode-se configurar a ordenação, a disposição, remover e adicionar guias

e botões de componentes clicando com o botão direito do mouse sobre qualquer

componente e clicar na opção Properties.

Há basicamente três maneiras de inserirmos os componentes no

formulário:

Clicar uma vez no componente, e clicar dentro do formulário (não arrastar para o form). Clicar duas vezes rapidamente no componente desejado. Segurar a tecla Shift e clicar no componente desejado; clicar no form várias vezes.

Na terceira opção, o componente será ‘travado’ ao mouse. Para

‘destravá-lo’ clique no ícone da seta, o primeiro ícone da paleta.

20

9.1.3 – Speedbar (ferramentas)

A Speedbar está posicionada ao lado esquerdo da barra principal do

Delphi. Possui diversos botões (ícones) que representam comandos muito utilizados

durante o desenvolvimento, como salvar, abrir, novo, novo form, executar a

aplicação, dentre outros.

Speedbar.

Pode-se customizar a speedbar adicionando ou retirando algum botão

através do botão direito em qualquer ícone (da speedbar) e escolher o comando

customize. Na janela aberta, seleciona-se a guia Commands. Neste momento

pode-se arrastar nos dois sentidos, para adicionar ou retirar botões.

Tela de customização da speedbar.

21

9.1.4 – Object Inspector

Uma das ‘partes’ mais importantes da orientação a objeto é a

possibilidade de se definir características personalizadas aos componentes. No

Delphi, utilizamos a janela object inspector para realizar esta tarefa.

Há uma caixa de listagem que permite a escolha de qual componente

deverá ser selecionado.

Duas guias:

Properties – define as propriedades e valores

do Objeto selecionado.

Events – Define quais os eventos serão

manipulados pelo desenvolvedor.

Algumas propriedades trazem

opções diferenciadas para alteração.

Por exemplo:

Caption – Permite a inserção de uma string

de caracteres. Neste caso de um form, seria o

título da janela.

Color – Permite a inserção de um dos valores

pré-definidos na caixa de listagem. Neste

exemplo, muda a cor de fundo do form.

BorderIcons – Toda propriedade que possui

o sinal de + tem a característica de mostrar

subpropriedades. Deve-se clicar no sinal de +

para expandir e no sinal de – para ocultar.

Icon – Exibe um botão de reticências (...) que dará origem a uma caixa de diálogo.

Os nomes definidos como valores das propriedades na object inspector

serão os nomes usados na construção do código em Object Pascal.

Objeto selecionadoe seu tipo.

Propriedade

Valor atual da propriedade selecionada

22

9.1.5 – Form

Form.

Form é o termo utilizado para representar as janelas do Windows que

compõem uma aplicação.

Os forms servem como base para o posicionamento dos componentes,

que são responsáveis pela interação entre usuário e máquina.

Para selecionarmos o form devemos clicar (uma vez) em sua área interna

ou na object inspector, e não simplesmente em seu título.

As características iniciais do form como tamanho, botões (minimizar,

maximizar, fechar, controle) e ícone podem (e serão) ser modificadas através de

recursos que veremos adiante.

9.1.6 – Code Editor

O editor de código é responsável por receber todas as declarações

criadas pelo Delphi e handlers criados pelo desenvolvedor.

É no ambiente Code Editor que implementamos o algoritmo na linguagem

Object Pascal.

23

Code Editor.

Na janela do editor pode haver outra janela denominada Code Explorer.

É a parte esquerda da janela, onde podemos ter uma orientação sobre os objetos,

procedimentos, funções e classes utilizadas na aplicação. Para desligar o code

explorer clique no pequeno X ao lado da guia do code editor, para visualizá-lo clique

com o botão direito dentro do editor e escolha View Explorer ou pelo teclado

Ctrl+Shift+E.

Uma característica muito importante do Code Explorer é que quando

inserirmos componentes no form, a sua declaração é feita pelo Delphi de maneira

automática.

Antes.

Nome da Unit em edição

Code Explorer

24

Depois.

Pode-se personalizar o Editor através do menu Tools | Editor Options.

Opções de configuração do Editor.

25

10 – PRIMEIROS PASSOS COM O DELPHI

10.1 – Antes de Começar

Antes de começarmos a realmente colocar a mão na massa, vamos a

algumas pequenas dicas que podem agilizar e ajudar muito o desenvolvedor durante

seu trabalho.

10.1.1 – Code Insight

Um recurso que vai facilitar nossa vida no momento de desenvolvimento

de código é o Code Insight do Code Editor do Delphi. Ele atua como um ajudante

de complemento junto ao código do desenvolvedor. Por exemplo: ao digitar o nome

de um objeto seguido de ponto (.) abre-se uma listagem de métodos e propriedades

que podem ser utilizadas neste objeto. A seguir exemplificarei a utilização do code

insight complementando código em caso de propriedades, ou seja, após o ponto.

(CTRL + ESPAÇO).

Esta lista pode ser ordenada por nome, clicando com o botão direito

dentro da listagem.

Code Insight de propriedades do componente Form.

O Code Insight também pode ser utilizado no momento de chamada de

procedimentos ou métodos, como mostra a figura a seguir:

26

Code Insight da função MessageDlg (Message Dialog).

10.1.2 – Configurações do Ambiente

O Delphi permite que você personalize o ambiente através do menu

Tools | Environment Options.

Opções de Ambiente da IDE do Delphi 5.0.

27

Algumas opções da janela Environment Options que a princípio, podemos

julgar importantes:

Autosave Options

o Editor files – Grava os arquivos fonte (.PAS) no momento da compilação, evitando

perda de código em caso de travamento da máquina. Porém, não permite compilar

um determinado projeto sem salva-lo antes.

o Project Desktop - Grava a posição das janelas do projeto atual.

Compiling and running

o Minimize on run – Para minimizar o Delphi no momento da compilação em efeito de

testes. Evita confusões de janelas.

Outra boa alteração seria com relação à coloração de códigos no Code

Editor. Durante a criação de código, o fato de que para cada tipo ou trecho do código

a fonte esteja com certa coloração pode facilitar nossa vida. Como exemplo,

configuraremos algumas cores interessantes, através do menu Tools | Editor

Options, na aba Color.

Comment: cinza claro;

Reserved Word: azul escuro;

String: verde musgo;

Number: vermelho;

28

10.1.3 – Teclas e Atalhos de Teclado Importantes

Tecla FunçãoF12 Alterna entre o code editor e o form designer.F10 Torna o foco para a janela principal.

F9(RUN) Permite compilar e executar o projeto para testes. Este processo geraautomaticamente o arquivo .EXE no diretório onde foi gravado o arquivo deprojeto (.DPR).

CTRL+F9 Permite compilar o projeto sem executar. Ideal para conferência de código.

SHIFT + F12Permite alternar entre os formulários do projeto. Equivalente ao ícone View Form na SpeedBar.

CTRL + F12Permite alternar entre as Units do projeto. Equivale ao ícone View Units na Speedbar.

CTRL + F2Permite ‘destravar’ o Delphi em caso de testes onde ocorram exceções e erros (travamentos).

10.1.4 – Projetos em Delphi

Para se desenvolver em Delphi o usuário deve primeiramente criar um

projeto de trabalho. Para aqueles que não estão habituados com IDEs de

desenvolvimento atuais, essa é uma abordagem bastante utilizada. Quando o

usuário cria seu projeto e o salva (utilizando a opção “Save All”), duas caixas de

diálogo são mostradas: “Salvar Unit Como” e “Salvar Projeto Como”.

Como se pode observar, as Units do Delphi simplesmente são arquivos

.pas do antigo Turbo Pascal, porém têm linguagem Object Pascal, que nada mais é

que a própria linguagem pascal orientada a componentes visuais, através de suas

propriedades e de seus eventos (métodos).

29

Um detalhe interessante que também podemos observar é a quantidade

de arquivos criados automaticamente pelo Delphi após salvarmos apenas 2 arquivos

lá pela IDE.

Abaixo segue uma lista das extensões e suas explicações:

.pas: arquivo Pascal: o código-fonte de uma unidade Pascal, ou uma unidade relacionada a um formulário ou uma unidade independente;

.dpr: arquivo Delphi Project. (Contém código-fonte em Pascal.); .dfm: Delphi Form File: um arquivo binário com a descrição das

propriedades de um formulário e dos componentes que ele contém. .dcu: Delphi Compiled Unit: o resultado da compilação de um arquivo

Pascal; .dof: Delphi Option File: um arquivo de texto com as configurações

atuais para as opções de projeto; .cfg: arquivo de configuração com opções de projeto. Semelhante aos

arquivos DOF; .exe: arquivo executável pelo Windows produzido pelo Delphi. .~dfm, .~pas: arquivos temporários de backup.

10.2 – Primeiro Programa

Como primeiro exemplo, iremos construir um programa que tenha apenas

um botão na tela. Quando o usuário clicar nesse botão uma mensagem será

mostrada dentro da própria janela.

Primeiramente iremos colocar um botão na tela. Clique em Button na

aba Standard da paleta de componentes. Logo depois clique dentro do Form.

Simples assim! Botão criado.

Agora temos de dar características a esse nosso botão criado. Por

enquanto vamos apenas dar um nome e colocar algum texto nesse botão melhor

que “button1” como está agora.

Com o botão selecionado (clique uma vez em cima dele), no Object

Inspector altere as seguintes propriedades:

Name: “botao”

Caption: “Meu primeiro botão”

30

Como se pode perceber, o texto não coube dentro do botão. Para resolver

isso, existem as alças de redimensionamento dos componentes visuais do Delphi.

Sendo assim, todo tipo de objeto (visual) colocado na tela pode ser dimensionado e

posicionado da maneira que o desenvolvedor bem entender.

Detalhe das alças de redimensionamento.

Agora com o botão já redimensionado iremos inserir o texto no form. O

componente utilizado será um Label , localizado também na aba Standard da

paleta de componentes. Estique-o no form, onde você quer que a mensagem

apareça.

Posicionamento do Label no Form.

Com o Label selecionado, altere as seguintes propriedades:

Name: “LabelMessagem”

Caption: “” aqui nós deixaremos em branco.

E agora? O Label sumiu? Você deve ter se perguntando depois de ter

tirado a seleção do Label na tela. Fique tranqüilo, caso precise acessá-lo é só

procurá-lo na lista que fica acima no Object Inspector.

31

Agora vamos à codificação propriamente dita. Como queremos que

apareça alguma informação naquele Label que pusemos na tela ao se clicar no

botão, então faremos o seguinte: selecione o botão, clique na aba Events do Object

Inspector e dê um duplo click no campo em branco à direita da opção “OnCLick”.

Ele abrirá o Code Editor com um procedimento onCLick já pronto para ser

programado.

Exemplo de procedimento criado pelo Delphi.

Traduzindo o que já temos de código na tela seria: “Procedimento do

formulário Form1 que funcionará ao se clicar em botão(parâmetro: tipo de parâmetro

usado no procedimento)”. Daqui pra frente é quase que simplesmente Pascal.

Vamos adicionar entre o “Begin” e o “End;” o seguinte código:

Exemplo: ao se clicar no botão será exibida a mensagem no Label.

Agora vamos executar nossa aplicação pela primeira vez testar se está

tudo OK! Simplesmente aperte a tecla F9 e teste seu primeiro programa.

O resultado deve ser algo bem próximo do mostrado na próxima imagem:

32

Exemplo

10.3 – Informações Sobre os Principais Componentes

10.3.1 – Objeto Form (Formulário)

É o principal componente container, pois

permite posicionar os demais componentes em si

mesmo.

É literalmente a implementação do

conceito de ‘janelas’ do sistema operacional

Windows.

Principais Propriedades:

ActiveControl: Permite definir qual o primeiro componente a receber foco assim que oformulário é criado.

Align: Altera o alinhamento e preenchimento do objeto. AutoScroll: Permite habilitar as barras de rolagem. BorderIcons: Determina os ícones a serem exibidos na barra de título do formulário. BorderStyle: Define o estilo da borda do formulário.

o bsDialog – Borda não redimensionável, comum em caixa de diálogoo bsSingle – Borda simples e redimensionável.o bsNone – Borda invisível, não redimensionável, sem botões de controle.o bsSizeable – Borda padrão redimensionável.

Caption: Indica o rótulo exibido para o componente. ClientHeight / ClientWidth: Define a altura e largura da área cliente. Color: Define a cor de fundo de um componente. Cursor: Indica a imagem exibida pelo ponteiro do mouse quando este ficar sobre o objeto. Enabled: Define se o componente está habilitado ou não. Font: Permite controlar os atributos do texto exibido em um componente. Height: Define a altura do objeto. Hint: Permite exibir um texto de auxílio no momento em que o ponteiro do mouse permanece

sobre o controle.

33

Icon: Define o ícone que será usado pelo formulário. KeyPreview: Define se o formulário deve ou não responder a um pressionamento de tecla,

através do evento OnKeyPress, por exemplo. Menu: Permite escolher entre mais de um componente MainMenu. Name: Define o nome interno que identifica o componente dentro da aplicação. ShowHint: Define se a string de auxílio deve ou não ser exibida quando o usuário mantém o

ponteiro do mouse sobre um controle. Visible: Define se o componente aparece ou não na tela. Width: Define a largura do objeto.

Principais Métodos:

Show: Exibe o formulário de manipulação não-modal. Caso o form seja exibido de maneira modal o usuário não conseguirá sair da janela ativa até que a feche ou execute alguma função que a feche.

ShowModal: Exibe o formulário de manipulação modal. Close: Permite fechar o formulário.

10.3.2 – Objeto Button (Botão)

É um dos objetos mais utilizados para

confirmar e disparar rotinas associadas

(procedimentos ou métodos). Sendo o

componente mais utilizado numa aplicação,

existem variações diversas de componentes

Button, porém as duas mais utilizadas são o

Button da paleta Standard e o BitButton da

paleta Additional. A principal diferença entre

eles é que no BitButton é possível adicionarmos uma imagem do tipo bitmap,

auxiliando assim a questão da acessibilidade da aplicação.


Action: Referencia uma ação definida em um objeto TActionList. Anchors: Permite manter a posição relativa do objeto ao objeto ‘parente’ quando este é

redimencionado. Cancel: Associa o evento OnClick do objeto ao pressionamento da tecla Esc. Default: Associa ao evento OnClick do objeto ao pressionamento da tecla Enter. ModalResult: Propriedade utilizada para encerrar a execução de um formulário Modal

quando selecionado um valor diferente de mrNone. Parent...: As propriedades Parent permitem que o componente receba a mesma formatação

do objeto proprietário. TabOrder: Define a ordem na passagem de foco no momento de pressionamento da tecla

TAB.

34

TabStop: Define se o foco pára no componente. Glyph: No caso do BitButton, insere a imagem escolhida no botão.


SetFocus: Envia o foco do windows para o componente.

10.3.3 – Objeto Edit (Caixa de Edição)

Um dos principais componentes para a

entrada de dados do usuário do sistema.


AutoSelect: Define se o texto exibido pelo controle será selecionado quando este receber o foco da aplicação.

AutoSize: Para componentes TEdit a propriedade determina se a altura do controle será redimensionada quando o tamanho da fonte for alterado.

BorderStyle: Determina o tipo da borda do componente. CharCase: Determina o se tipo da fonte será maiúscula, minúscula ou normal. HideSelection: Define se o texto perde a seleção ao perder o foco. Maxlength: Define um limite para a inserção de caracteres. PasswordChar: Define qual caractere será usado para ocultar o texto inserido no

componente. Text: Permite manipular os caracteres inseridos no componente pelo usuário.


Clear: Limpa o conteúdo da propriedade text. SetFocus: Envia o foco do windows para o componente.

35

10.3.4 – Objeto Label (Rótulo de Orientação)

Orienta o usuário à escolha de

componentes, bem como sua utilização. Como

se percebe, os rótulos ou “Labels” podem ser

usados para se exibir qualquer texto no form.


Alignment: Define o alinhamento da string na área do componente.

AutoSize: Para componentes TDBText e TLabel, esta propriedade define se o controle será automaticamente redimensionado para acomodar o texto.

FocusControl: Define qual o componente receberá foco quando o usuário selecionar a combinação de teclas aceleradoras (atalho) se existir.

Layout: Define o alinhamento vertical do texto na área do componente. ShowAccelChar: Define se o caracter ‘&’ será um literal ou tecla de aceleradora (atalho). Transparent: Define se o fundo do componente será ‘transparente’ ou não. WordWrap: Define se o texto poderá utilizar o ‘retorno automático’ em caso de ultrapassar a

largura definida e se a propriedade AutoSize estiver falsa.

10.3.5 – Objeto Memo (Memorando)

Permite ao usuário entrar com dados

do tipo TStrings, compara-se à funcionalidade

do software bloco de notas do Sistema

Operacional Microsoft Windows.


Lines: Propriedade do tipo TStrings que contém as linhas de texto do componente.

MaxLength: Define o limite máximo de caracteres no componente em sua propriedade Lines. ReadOnly: Define se o componente é do tipo somente leitura. ScrollBars: Define se o componente pode trabalhar com barras de rolagem. WantReturns: Define se a tecla ENTER será utiliza para ‘quebra de linha’. WantTabs: Define a tecla Tab como tabulação ou mudança de foco. Caso falso pode-se

utilizar CTRL+TAB para produzir o efeito desejado.

36


LoadFromFile: Permite ‘carregar’ um arquivo para a propriedade Lines. SaveToFile: Permite salvar o conteúdo da propriedade Lines em um arquivo especificado.

10.3.6 – Objeto CheckBox (Caixa de Verificação)

Permite verificar opções booleanas

pré-definidas ou re-definidas pelo usuário.


AllowGrayed: Define caso verdadeiro, três estados possíveis para o checkbox: checked(ligado), unchecked (desligado) e grayed (parcial). Caso falso, dois 37 estados: checked (ligado) e unchecked (desligado).

Checked: Define se o componente está ligado ou não, caso tenha apenas dois estados. State: Permite definir três estados se AllowGrayed for verdadeiro.

10.3.7 – Objeto PageControl (Controle de Abas)

Permite criar abas de navegação

como se fossem paletas (assim como as paletas

de componentes do Delphi)


ActivePage: Nome da aba ativa em tempo de execução.

PageCount: número de página no vetor de páginas que é o PageContro.

Pages: propriedade somente leitura para se ter acesso diretamente à uma determinada página do PageControl, através de sua posição (PageIndex).

Obs.: Para se criar novas páginas, simplesmente clique com o botão direito do

mouse e “New Page”.

37

10.3.8 – Objeto Panel (Painel)

Permite agrupar outros objetos e

estabelecer um efeito visual nas aplicações.


Align: Define o alinhamento do componente em relação ao seu proprietário (no caso mais comum, o form).

Bevel...: Define a característica das bordas (interna e externa) bem como sua espessura. BorderStyle: Define o tipo da borda.

10.3.9 – Objeto StringGrid (Grade de Dados)

Similar a uma tabela,

porém com algumas funções a

mais. Excelente para exibição de

dados como informações de um

banco de dados e/ou informações

que necessitem de tabulação.


Cells: Determinada célula do StringGrid. Exe.: pode-se acessar determinada célula através de StringGrid1.Cells[1,1], o que seria exatamente a célula selecionada na imagem acima.

Cols: Acesso a determinada coluna do Grid. Rows: Acesso a determinada linha do Grid. RowCount: Contagem de linhas totais. ColCount: Contagem de colunas totais.

38

11 – TRABALHANDO COM ARQUIVOS NO DELPHI

Neste capítulo vamos entender como funciona o tratamento de arquivos

de texto no Delphi 5.0. De maneira a aprimorar e incrementar os conhecimentos

adquiridos até o momento desenvolveremos uma tela de cadastro de clientes

genérica.

A nossa tela de cadastro de clientes será subdividida em duas abas: uma

será a aba de cadastro propriamente dita e a outra será um StringGrid com as

informações dos clientes já cadastradas.

Nossa aplicação ficará próxima às imagens seguintes:

Tela de cadastro.

Tela de visualização dos dados cadastrados.

39

Para iniciarmos nosso desenvolvimento criaremos um novo projeto no

Delphi com um novo Form. Salvaremos este projeto com o nome “Clientes”. A Unit e

consequentemente seu form com o nome “Unit_Clientes”.

Primeiramente configuraremos nosso form com as seguintes

propriedades:

Name: frmClientes Caption: Gestão de Clientes

Agora adicionaremos um PageControl no form e o configuraremos da

seguinte maneira:

Name: PageControl Align: alClient (Para deixá-lo do tamanho do form)

Precisamos agora adicionar

nossas duas abas, uma chamada

“Visualização” e a outra “Gestão”. Para fazer

isso simplesmente clica-se com o botão

direito do mouse em qualquer área do Page

Control e na opção “New Page”.

Altere a propriedade “Caption” dos

dois Tabsheets criados para “Visualização” e

“Gestão” respectivamente.

O próximo passo será a inserção de um painel (Panel) na aba

Visualização. Depois de inserido altere sua propriedade “Align” para “alBottom”, e

“Color” para “clInactiveBorder”. O resultado será nosso painel cobrindo toda a parte

inferior do form.

Agora inseriremos um StringGrid neste mesmo TabSheet e o colocaremos

em todo o restante do espaço desta aba Visualização. Depois de inserido altere sua

propriedade “Align” para “alClient”.

Vamos configurar nosso StringGrid:

Name: StringGrid FixedCols: 0 RowCount: 2 Options > GoRowSelect: True

40

Nosso Tabsheet “Visualização” agora está parecido com algo assim:

Tabsheet Visualização

No painel abaixo do StringGrid mudaremos a cor e inseriremos três

botões com as seguintes propriedades:

Botão 1:o Name: btnApagaro Caption: Apagar

Botão 2:o Name: btnAlteraro Caption: Alterar

Botão 3:o Name: btnFecharo Caption: Fechar

Botões inseridos no painel

41

Agora vamos montar nosso Tabsheet que controlará os dados, ou seja,

onde o usuário inserirá valores, alterará e buscará por informações já cadastradas –

o Tabsheet Gestão:

Tabsheet de gestão dos dados.

Para chegarmos ao resultado acima inserimos 5 Labels, 4 Edits e 1

MaskEdit para o campo de Telefone, com as seguintes propriedades alteradas:

5 Labels:o Caption: Cada um com seu respectivo rótulo como na imagem acimao Enabled: false

Campo 1: Edito Name: edtCodigoo Enabled: falseo Text:

Campo 2: Edito Name: edtNomeo Enabled: falseo Text:

Campo 3: Edito Name: edtEnderecoo Enabled: falseo Text:

Campo 4: MaskEdito Name: edtTelefoneo EditMask: (99) 9999-9999o Enabled: falseo Text:

Campo 5: Edito Name: edtEmailo Enabled: falseo Text:

Com o Tabsheet já configurado agora inseriremos os botões de controle

no painel abaixo, como mostra a imagem seguinte:

Dica:

Para selecionar vários componentes que ficam dentro de um container (como exemplo: PageControl, Form, Painel, GroupBox, etc) você pode arrastar o mouseselecionando vários deles desde que a teclaCTRL esteja pressionada.

42

Tabsheet de gestão de dados com botões

Botão 1:o Name: btnNovoo Caption: Novo

Botão 2:o Name: btnGravaro Caption: Gravar

Botão 3:o Name: btnCancelaro Caption: Cancelar

Botão 4:o Obs.: o botão de fechar a aplicação (que ficaria ao lado direito do cancelar) nós

faremos depois, pois o copiaremos da TabSheet Visualização. Portanto, não o insira por enquanto. Justificativa: não podemos ter em um mesmo form botões (componentes) de mesmo nome.

Agora desabilitaremos os botões “Gravar” e “Cancelar” afinal eles só

devem estar habilitados quando tivermos informações nos campos ou se quisermos

cancelar alguma ação. Para isto, mude suas propriedades enabled para false.

Com todo o visual de nossa aplicação já definido e implementado, vamos

à obra! Ou melhor, ao código!

Primeiramente criaremos um procedimento que habilita todos os

componentes e outro para desabilitar todos os componentes da mesma. Desta

forma, sempre que quiser “re-iniciar a janela”, na forma mais bruta de se dizer,

iremos chamar esse procedimento, nomeado de “Habilita_Tela”, e em outro caso:

chamaremos o “Desabilita_Tela”. Posteriormente poderemos alterar alguma coisa ou

outra desse código.

43

Para criarmos tais procedimentos seguiremos com o seguinte: com o form

FrmClientes selecionado, tecle F12. Você cairá no Code Editor com UnitFrmClientes

aberta e pronta para ser codificada.

Sendo assim, a área onde inserimos

nosso códigos são abaixo das

inscrições “{$R *.DFM}”, como

demonstra a imagem à esquerda.

Criaremos os códigos como

está nesta imagem. Observe que

usando o Code Insight tudo é

praticamente auto-completado para

você. Experimente!

Após criados os

procedimentos, compilaremos a

aplicação para vermos como está. Tecle

CTRL+F9.

Provavelmente ocorreu para você o

mesmo erro demonstrado na imagem acima.

Verificando a caixa de mensagem que apareceu

abaixo e a linha em vermelho destacada,

entendemos que: o procedimento que acabamos

de fazer, ainda é desconhecido para a aplicação,

portanto temos que declará-lo no cabeçalho da

Unit como mostra a figura à direita.

44

Como você deve ter percebido, quando criamos procedimentos, assim

como funções, temos que colocar antes do nome desejado para tal, o tipo, caso ele

faça alterações e/ou manipulações visuais no form. Sendo assim, como nossos

procedimentos alterarão componentes visuais, neste caso: buttons, labels e edits,

então temos de colocar o tipo antes, exemplo: “TFrmClientes”.

Continuando, agora iremos criar o nosso arquivo no disco. Primeiramente

temos de definir qual será o diretório de nosso arquivo e seu nome. Usaremos a

criação de uma constante para tal através da palavra reservada “Const” e sinal de

igualdade na constante criada

Criação de uma constante

No Delphi, as constantes são definidas acima do marcador

“implementation” e abaixo das declarações de componentes, procedimentos e

funções, como demonstra a última figura.

Em nosso exemplo, nossa constante receberá o valor “D:\Clientes.txt”,

onde D é nosso disco local. (Obs.: Caso seu computador não tenha uma partição ou

HD com tal unidade, poderá utilizar a unidade C:, que é a padrão).

Abaixo da declaração de Constantes adicionaremos um novo tipo de

dado, que será um Record de todos os dados que queremos manipular dos clientes.

Em outras palavras, assim como existe o tipo Integer, ou o tipo Boolean, String,

dentre outros, nós podemos criar o nosso próprio tipo, e para isso usamos a palavra

reservada Type abaixo da declaração de constantes e antes da declaração de

variáveis (var). A imagem seguinte exemplifica o que se há de fazer.

45

Criação de um novo tipo (type)

Feito nosso tipo, agora iremos criar um vetor para trabalharmos nossas

informações, afinal nós não utilizaremos o arquivo no HD para todas as operações.

O que faremos será o seguinte: sempre que o programa se iniciar, traremos para a

memória do computador tudo o que está armazenado no arquivo e o exibiremos no

StringGrid. Trabalharemos de forma a alterar, excluir, gravar e localizar clientes tudo

da memória, visto que ela é muito mais rápida que o HD. Sendo assim quando

sairmos do form ou da aplicação, iremos gravar os dados da memória para o HD.

Simples não?!

Prosseguindo, iremos criar o nosso vetor dentro da declaração de

variáveis com o nome de

Vet_Clientes: array of Clientes;

Vamos trabalhar a

parte visual de nossa aplicação

um pouquinho mais. Vamos

colocar um cabeçalho em nosso

StringGrid com um procedimento

chamado Ajeita_Grid, como

demonstrado ao lado.

46

Explicando a última imagem: cada célula do StringGrid é acessada

através de coordenadas como se fosse no plano cartesiano [x,y], sendo assim,

StringGrid1.Cells[3,0] significa a quarta coluna na primeira linha.

StringGrid.ColWidths[3] é a largura desejada da coluna. Pode ser alterado pelo

mouse em tempo de desenvolvimento também através do arraste do mouse.

Obs.: No StringGrid as contagens começam de zero.

Agora vamos criar o arquivo no disco, acessá-lo e trazer tudo o que já tem

nele para a memória. O procedimento para isso segue na imagem:

Procedimento para copiar o conteúdo do arquivo e jogá-lo para o vetor na memória

Primeiramente declaramos uma variável com o nome Arq do tipo

TextFile, ou seja, Arquivo de texto. Testaremos se o arquivo já existe naquele

caminho, caso não exista apenas o criaremos. Mas primeiro temos de Associar

47

nossa variável do tipo arquivo de texto ao caminho no disco, para isso usamos a

função AssignFile(Arq,Caminho);. E para criar o arquivo, simplesmente

Rewrite(Arq), que o cria e abre para edição.

Voltando ao teste da existência do arquivo, caso ele já exista teremos de

resgatar toda informação de dentro dele. Para isso direcionamos nossa variável Arq

para o caminho (AssignFile(Arq,Caminho)) e abrimos o arquivo simplesmente para

leitura com Reset(Arq).

Utilizando um laço de repetição While, ou seja, enquanto não chegar ao

fim do arquivo faça (While Not “END OF FILE(EOF)”(Arq) Do).

Nosso vetor tem 0 posições ainda, portanto temos de criar o primeiro

espaço para o primeiro registro nele. Aumentaremos a quantidade que ele já tem em

1 com o SetLength(Vet_Clientes, Length(Vet_Clientes) + 1);, onde Length é o

tamanho atual do vetor. Entendido isso fica fácil o resto: simplesmente lemos cada e

adicionaremos em sua devida posição do vetor de clientes como exemplo:

Readln(Arq,Vet_Clientes[length(Vet_Clientes)-1].Nome);

E para finalizar, antes de fechar nosso procedimento temos de fechar o

arquivo criado ou aberto com CloseFile(Arq). É muito importante nunca se esquecer

de fechar arquivos abertos.

Faremos agora um simples procedimento para limpar o StringGrid para

que cada vez que tivermos de trazer os dados do HD para memória o tenhamos

limpo. Segue abaixo o procedimento.

Procedimento de limpeza do StringGrid

48

Agora utilizaremos nosso procedimento de Transferir do HD para a

memória toda vez que o Form for criado, ou seja, em seu procedimento OnCreate.

Para isso, selecione o formulário (caso não consiga, clique em componentes acima

dele, por exemplo Painéis e vá apertando ESC até que consiga ver seu nome no

Object Inspector), clique na aba de eventos do Object Inspector e duplo clique na

opção OnCreate.

Adicione um “Traz_Para_Memoria;” dentro do procedimento criado.

Tendo chamado o procedimento de alimentação de nosso vetor toda vez

que o form é criado, agora temos de transferir esses dados para o StringGrid para

que o usuário possa visualizá-lo. Faremos um procedimento chamado

“Transfere_Memoria_Grid”.

Procedimento que transfere do vetor de clientes na memória para o StringGrid

49

Primeiramente cria-se uma variável para controlar (Flag) do laço For que

será usado, logo limparemos o Grid e colocaremos seus cabeçalhos, como já foi

feito nos procedimentos atrás.

Se o vetor de clientes for maior que 0 então faremos um for indo de 0 até

a última posição do vetor (Obs.: como Length retorna um valor contado a partir

de 1, temos de diminuí-lo em um para termos o valor exato do tamanho do

vetor). Em cada registro de nosso vetor nós enviaremos as informações

armazenadas para o StringGrid, ressalvando que no StringGrid só se aceitam

valores do tipo String, sendo necessárias algumas conversões como o caso do

código (IntToStr).

Ao final de cada linha inserida do StringGrid, devemos aumentar uma

linha para a próxima inserção (a próxima linha) com StringGrid1.RowCount :=

StringGrid1.RowCount + 1;

Depois de todas as linhas inseridas, acabamos por inserindo uma a mais,

de acordo com o código anterior, sendo assim, remova uma linha e a partir de então

habilitaremos dois botões: Apagar e Alterar.

O Else de nosso IF é para o caso do vetor estar vazio, sendo assim

desabilitaremos os dois botões supracitados.

Adicionaremos agora a chamada a este procedimento na criação do

formulário também, logo abaixo do Traz_Para_Memoria adicione

“Transfere_Memoria_Grid;”.

Agora que temos nosso vetor e nosso Grid alimentados, vamos tratar da

inserção de dados pelo usuário. Clique duas vezes no botão “Novo” e implemente o

seguinte código, de modo a permitir que o usuário insira novos valores:

Depois que o usuário preencher seus dados na tela, ele clicará em gravar

e então chamará seu procedimento OnClick que faremos agora. Para isso clique

duas vezes em seu botão Gravar e implemente o seguinte código:

50

Código pra gravar os dados inseridos no vetor

O procedimento é simples: aumentamos uma posição do vetor e cada

posição de registro no vetor recebe na sua última posição (Length(Vet_Clientes)-1)

cada um dos valores dos Edits do formulário em suas propriedades Text.

Ao final teremos que fazer um procedimento para limpar os campos Edit

da tela, o chamaremos de Limpa_Tela e será basicamente assim:

Procedimento para limpar os Edits da tela após a inserção

Depois de limparmos os Edits, temos de desabilitar a tela e atualizar

nosso StringGrid com nosso procedimento “Transfere_Memoria_Grid”.

Se executarmos nossa aplicação, até o momento ela deve estar se

parecendo com o seguinte:

51

Tabsheet de Visualização

TabSheet de Gestão dos dados

Obs.: Copie o botão “Fechar” de um TabSheet para o outro.

Agora faremos o usuário poder alterar valores já inseridos, e para isso

precisaremos mexer em nosso StringGrid para que quando o usuário selecionar uma

determinada linha do mesmo possamos pegar qual é a posição do vetor que

devemos exibir em nossos Edits da outra TabSheet.

Para isso, faremos algo bem simples: altere a propriedade goRowSelect

em options do StringGrid para true e adicionaremos o seguinte código no evento

OnSelectCell: “Linha := ARow;”. Linha será uma variável integer global que

declararemos abaixo de nosso array de Clientes... lá no início da Unit. Desta forma,

52

sempre que o usuário clicar numa linha do StringGrid, estaremos inserindo na

variável “linha” a referida linha que o usuário deseja excluir ou alterar.

Tendo criado o procedimento OnSelectCell do StringGrid, agora teremos

de criar nosso procedimento de alteração, ou seja, o que colocará os valores

daquela linha nos seus devidos Edits.

Antes de fazermos isto, teremos que criar um procedimento que ache no

nosso vetor onde está aquela linha selecionada, portanto criaremos o procedimento

da seguinte forma:

Procedimento que localiza a posição do cliente no vetor.

De maneira simples, chamaremos nossa função passando a posição do

StringGrid na coluna de códigos e na linha que será nossa variável “Linha”, tudo isso

como sendo o Cod da função. Por padrão nossa função retornará -1, caso ela não

ache nada. O procedimento varrerá o vetor e se ele achar um código igual aquele

clicado pelo usuário, retornará a posição e irá parar o laço (Break).

Com a posição já em mãos, agora iremos implementar o evento OnCLick

do botão alterar da seguinte forma:

53

Procedimento do botão alterar

Primeiramente criamos uma variável Posição que utilizará nosso último

procedimento implementado, o “Localiza_Cliente”. Logo após isto testamos se

nossa posição é diferente de -1, pois caso seja igual, nossa função não achou o

cliente escolhido no StringGrid.

Neste procedimento teremos de fazer uso de uma variável global

chamada Alterando para podermos modificar o procedimento do nosso botão

Gravar, e para que ele entenda quando queremos gravar um novo registro e quando

estamos alterando um já existente.

Seguindo o raciocínio, quando o usuário clicar no botão “Alterar” ele será

automaticamente redirecionado para o TabSheet de Gestão e ali os Edits serão

preenchidos com a posição encontrada pela função “Localiza_Cliente” no ínicio

deste procedimento.

Ao final, devemos Habilitar a tela para que o usuário possa interagir com

o form.

Para completarmos esta tarefa teremos de modificar um pouco nosso

procedimento do botão gravar, já que ele sempre grava novos registros.

Primeiramente declare a variável “Alterando” abaixo da variável “Linha” para que se

torne uma variável global. Seu tipo será booleano (Boolean). Para a inicializarmos,

no procedimento onCreate do form, defina-a recebendo false.

54

Alteração do procedimento OnCLick do botão Gravar

Simplesmente pesquisaremos a posição com aquele código inserido no

EdtCodigo e se estiver alterando, inseriremos os valores substituindo os já

existentes naquela posição. Simples não?

Devemos nos lembrar de passar a variável “Alterando” para false,

limpamos a tela, desabilitamos e atualizamos o StrinGrid.

Agora que temos a condição de alteração, precisamos implementar o

botão “Cancelar”, muito fácil e simples, como se segue:

Procedimento OnClick do botão de Cancelar

55

Igualmente simples, iremos implementar o botão fechar, como se segue:

Procedimento OnClick do botão Fechar

Como se percebe, antes de fecharmos nosso form precisamos gravar o

conteúdo do StringGrid no HD. Sendo assim, criaremos o procedimento

“Grava_No_HD”, como demonstra a imagem seguinte:

Como se percebe, o

procedimento para gravação no

disco é bem similar ao processo

de leitura do disco. Portanto, para

maiores detalhes de

funcionamento do código ao lado,

volta à página desta apostila onde

se encontra o procedimento

“Traz_Para_Memoria”.

Procedimento de gravação dos dados no arquivo

56

E para finalizar nosso código para esta aplicação, implementaremos um

simples detalhe: quando o usuário mudar de abas no PageControl precisamos nos

certificar que nada esteja habilitado do form, por exemplo, até que se clique em

novo, ou alterar. Sendo assim, segue o código para a mudança de abas:

Procedimento OnChange do PageControl

Pronto! Agora vamos testar nossa aplicação compilando-a e executando-

a, através da tecla F9.

Obs.: Erros são muito comuns, portanto acostume-se com eles e aprenda aos

poucos a tratá-los e resolvê-los.

57

12 – TRABALHANDO COM BANCOS DE DADOS NO

DELPHI

Para fins didáticos esta apostila abordará a criação de um CRUD (Create,

Retrieve, Update and Delete) de Clientes utilizando o SGBD Firebird versão 1.5.

A primeira coisa a se fazer é criar a base de dados utilizando-se para isso

da ferramenta IBExpert, previamente apresentada. Criaremos para o nosso exemplo

uma base de dados simples com o nome “clientes” e apenas uma tabela chamada

“cliente” com os seguintes campos:

Exemplo tabela cliente.

Obs.: não usaremos chave primária neste exemplo

Depois de criada a tabela cliente, iniciaremos nossa aplicação. Abra o

Delphi 5 e inicie um novo projeto. Salve o projeto e nomeie-o como:

“Controle_cliente”, a unit do nosso form se chamará “Unit_Cliente”.

Antes de mais nada, precisamos criar um DataModule. Um DataModule

nada mais é do que um form específico onde centralizaremos todos os componentes

de conexão e manipulação de um ou mais banco(s) de dado(s) em nossa aplicação.

Em outras palavras: um DataModule é como se fosse um Form invisível, onde

iremos inserir os componentes de acesso a dados, como o Table e o Datasource.

Para inserir um DataModule em um projeto, escolha New DataModule do

menu File. Os DataModules não gastam recursos do sistema, servem apenas para

conter os componentes de acesso a dados e criar, assim, uma classe persistente.

Segue abaixo uma imagem de um DataModule:

58

Imagem de exemplo de um DataModule

Como se pode perceber, em um DataModule nós podemos inserir alguns

componentes diferentes do que estamos acostumados a lidar. Não se preocupe,

iremos explicar passo-a-passo como trabalhar com eles.

Para que o desenvolvimento fique ágil e fácil, mudaremos o nome do

DataModule para DM (propriedade Name).

Primeiramente temos de informar para a nossa aplicação qual a base de

dados que iremos utilizar e, mais importante, onde ela se encontra no disco local do

computador. Para fazermos isso utilizamos o componente IBDatabase da

paleta Interbase, padrão no Delphi 5.0. Deixaremo-lo com o mesmo nome inserido:

“IBDatabase1”.

Algumas propriedades devem ser alteradas deste IBDatabase, como:

DatabaseName: D:\Clientes.fdb LoginPrompt: false SQLDialect: 3

Para terminar a configuração, clique duas vezes no ícone do IBDatabase

e configure-o de acordo com a imagem seguinte:

59

Explicando:

Connection: tipo de conexão que

será usada, local ou remota.

Database: local especificado na

propriedade DatabaseName do

componente. Pode ser feito

diretamente aqui.

User Name: “sysdba” é o login

padrão criado para bases de

dados Firebird 1.5.

Password: “masterkey” é a

senha padrão criada para bases

de dados Firebird 1.5.

Character Set: utf8, ou seja,

Unicode_FSS para que

possamos lidar com acentos e

caracteres especiais do alfabeto

latino.

Para testar sua conexão com o banco, simplesmente mude a propriedade

Connected para true, se o computador congelar durante alguns segundos quer

dizer que algo está errado e provavelmente você receberá uma mensagem de erro.

Agora criaremos um componente responsável por fazer a comunicação

entre nossa aplicação e o banco de dados, um IBTransaction. Na paleta Interbase

adicione um IBTransaction.

Neste componente as únicas alterações que faremos será em suas

propriedades DefaultDatabase e Active, “IBDatabase1” e “true”, respectivamente.

Pronto! Agora já temos nossa aplicação devidamente conectada ao nosso

banco de dados. O DataModule facilita muito no desenvolvimento por centralizar

todos os componentes da conexão num só lugar. Para se usar o DataModule,

simplesmente no form onde será utilizada a conexão com o banco, vá no menu File

> Use Unit e aponte para o DM (DataModule).

Aproveitando que estamos implementando nosso DataModule, vamos

adicionar nossa tabela de clientes também. Para isso, insira no DM o componente

IBTable, também disponível na paleta Interbase do Delphi 5.0.

Vamos agora modificar algumas de suas propriedades, como:

60

Database: IBDatabse1 Name: tblCliente TableName: selecione a tabela disponível na base de dados, neste caso “cliente” Transaction: IBTransaction1

Outra configuração importantíssima é acrescentar os campos de nossa

tabela real a esta tabela do nosso DataModule. Para isso, simplesmente clique duas

vezes no tblClientes criado e na janelinha que aparece, clique com o botão direito do

mouse > “Add All Fields”. Nosso IBDatabase nos fornece o nome de todos os

campos da tabela.

A partir daqui, começa a mágica da conexão a bancos de dados no

Delphi. Para quem acompanhou a apostila durante a criação do CRUD de clientes

em Arquivos, notará uma grande facilidade na utilização de bancos de dados.

Iremos agora “montar” visualmente nossos componentes no form para a

gestão e visualização dos dados através de um DBGrid.

Crie um formulário inserindo os seguintes componentes:

1 Panel 5 DBEdits 5 Labels 1 DBNavigator 1 DBGrid

Posicione-os de maneira a ficarem semelhantes à imagem abaixo:

Tela básica de cadastro de clientes

Dica:A maioria dos componentes do tipo “DB” para trabalhar com bancos de dados, se localiza na paleta DataControls do Delphi 5.0.

61

Certifique-se de estar com o formulário selecionado, vá ao menu File >

Use Unit e adicione o DM ao nosso formulário de clientes.

Agora adicionaremos lá no DM um novo componente chamado

“DataSource”, disponível na paleta “Data Access”, e o modificaremos sua

propriedade DataSet para nossa tblClientes.

Tendo tudo corretamente configurado, clique em cada DBEdit do nosso

formulário de clientes e configure as seguintes propriedades:

DataSource: DM.DataSource1 (que acabamos de inserir no DM) DataField: o campo destinado a ser usado neste Edit.

E assim por diante para todos os outros DBEdits. O DBNavigator

simplesmente defina o seu DataSource.

Já no DBGrid alguns ajustes devem ser feitos, como:

DataSource: DM.DataSource1 Options > dgRowSelect: true Options > dgAlwaysShowSelection: true

Agora temos de adicionar os cabeçalhos e colunas de nosso Grid. Para

isto, simplesmente clique duas vezes do DBGrid e clique no botão “Add New (Ins)”

quantas vezes forem nossos campos na tabela de clientes (neste caso, 5 vezes).

Adicionar colunas ao DBGrid

Em cada uma das colunas adicionadas a esta janelinha nós podemos

definir propriedades, dentre elas nós definiremos:

62

FieldName: campo da tabela que deseja nesta coluna Title > Caption: coloque o nome que deseja para esta coluna Width: largura da coluna (bem útil! Principalmente neste nosso caso)

Agora para testarmos nossa aplicação, vá a seu DataModule e ative seu

IBTransaction e sua tblClientes através da propriedade Active. Pronto! Tudo

funcionando só precisamos rodar a aplicação e verificar os resultados... sem

nenhuma linha de código!

Cadastro de Clientes em funcionamento

Incrível não? Sem nem mesmo uma linha de código digitada!

Bom! Para que você não se perca todo, explicarei as funções de cada

botão do DBNavigator:

E para aqueles que não queiram utilizá-lo e substituí-lo por botões

personalizados, pode-se criar botões com os seguintes códigos para fazer as

mesmas funções:

Primeiro Voltar Avançar Último Novo Excluir Editar Gravar Cancelar Atualizar

63

DB

Na

vig

ato

r.Firs

t;

DB

Na

vig

ato

r.Prio

r;

DB

Na

vig

ato

r.Ne

xt;

DB

Na

vig

ato

r.La

st;

DB

Na

vig

ato

r.Ins

ert;

DB

Na

vig

ato

r.De

lete

;

DB

Na

vig

ato

r.Ed

it;

DB

Na

vig

ato

r.Po

st;

DB

Na

vig

ato

r.Ca

nc

el;

DB

Na

vig

ato

r.Re

fres

h;

Obs.: a ativação de tabelas e componentes do DataModule deve ser feita

somente quando se vai realmente utilizar o componente e depois fechada. As

instruções dadas acima são meramente para conhecimento do estudante.

Lembre-se: nunca mantenha conexões e tabelas abertas.

Documents

Roger