Upload
rogersantosferreira
View
121
Download
13
Embed Size (px)
Citation preview
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.
Principais Propriedades:
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.
Principais Métodos:
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.
Principais Propriedades:
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.
Principais Métodos:
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.
Principais Propriedades:
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.
Principais Propriedades:
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
Principais Métodos:
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.
Principais Propriedades:
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)
Principais Propriedades:
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.
Principais Propriedades:
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.
Principais Propriedades:
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.