Download - Apostila Mini-Curso Delphi - Dia 3

Mini-Curso Delphi Marcos Paulo Salvador de Oliveira

Mini-Curso Delphi

1. INTRODUÇÃO.................................................................................................................................1

1.1. FAMILIARIZAÇÃO COM O AMBIENTE DE PROGRAMAÇÃO ...........................................................1 1.2. SUBDIVISÕES DO AMBIENTE DE PROGRAMAÇÃO DELPHI...........................................................2

1.2.1 Menu Principal .....................................................................................................................3 1.2.2 Gerenciador de Desktops .....................................................................................................3 1.2.3 Palheta de Botões Rápidos ...................................................................................................4 1.2.4 Palhetas de Componentes.....................................................................................................4 1.2.5 Formulário ...........................................................................................................................4 1.2.6 “Code Editor” ......................................................................................................................5 1.2.7 “Object TreeView”...............................................................................................................6 1.2.8 “Object Inspector”...............................................................................................................7

1.3. AMBIENTE “DRAG AND DROP” ..................................................................................................8 2. FERRAMENTAS DO AMBIENTE DE PROGRAMAÇÃO........................................................9

2.1. “CODE COMPLETITION” .............................................................................................................9 2.1.1 Chamando o “Code Completition” ....................................................................................10 2.1.2 Refinando a busca do “Code Completition”......................................................................10

2.2. ESTRUTURAS DE PROGRAMAÇÃO PRÉ-ESTABELECIDAS (“CODE TEMPLATES”).......................11 2.2.1 Utilizando “Code Templates” ............................................................................................11 2.2.2 Adicionando “Code Templates”.........................................................................................12

3. PROGRAMANDO EM DELPHI ..................................................................................................14 3.1. TIPOS DE ARQUIVOS GERADOS PELO DELPHI...........................................................................14 3.2. O QUE SALVAR?.......................................................................................................................16 3.3. NORMA INTERNACIONAL DE NOMENCLATURA DE VARIÁVEIS E OBJETOS ...............................17 3.4. CASE-INSENSITIVE ...................................................................................................................17 3.5. CRIAÇÃO DE VARIÁVEIS ..........................................................................................................18 3.6. CONSTANTES............................................................................................................................19 3.7. TIPOS .......................................................................................................................................19 3.8. CRIAÇÃO DE ROTINAS..............................................................................................................20

3.8.1 Parâmetros .........................................................................................................................21 3.8.2 Procedimentos ....................................................................................................................21 3.8.3 Funções ..............................................................................................................................22 3.8.4 Onde declarar rotinas ........................................................................................................22

3.9. CRIAÇÃO DE MÉTODOS ............................................................................................................23 3.9.1 Onde Declarar Métodos .....................................................................................................24 3.9.2 Facilitando as Coisas .........................................................................................................25

3.10. CRIAÇÃO DE UNITS ..................................................................................................................25 3.10.1 Interface.........................................................................................................................26 3.10.2 Implementation ..............................................................................................................27

3.11. EVENTOS..................................................................................................................................28 3.12. TRATAMENTO DE EXCEÇÕES....................................................................................................30

3.12.1 Try ... Except..................................................................................................................30 3.12.2 Try ... Finally .................................................................................................................31

4. COMPILANDO E DEBUGANDO................................................................................................31 4.1. COMPILANDO ...........................................................................................................................31

4.1.1 Gerando o executável .........................................................................................................31 4.1.2 Erros de Compilação..........................................................................................................32

4.2. DEBUGANDO ............................................................................................................................33 4.2.1 BreakPoints ........................................................................................................................33 4.2.2 Watches ..............................................................................................................................34

I


5. INTERFACE COM O USUÁRIO.................................................................................................35

5.1. PANELS ..........................................................................................................................36

5.2. CRIAÇÃO DE MENUS .....................................................................................................36 5.2.1 Adicionando o Componente de Menu.................................................................................36 5.2.2 Criando Itens de Menu .......................................................................................................37 5.2.3 Criando SubMenus .............................................................................................................38

5.3. CRIAÇÃO DE BARRAS DE FERRAMENTAS ......................................................................38 5.3.1 Adicionando Botões............................................................................................................39 5.3.2 Adicionando Separadores...................................................................................................40

5.4. CRIAÇÃO DE BARRAS DE STATUS .................................................................................40 5.4.1 Exibindo Dicas ...................................................................................................................40

5.5. CRIAÇÃO DE MDIS...................................................................................................................40 5.5.1 MDI Forms .........................................................................................................................41 5.5.2 MDI Childs .........................................................................................................................41

5.6. CRIAÇÃO DE TELAS DE SPLASH................................................................................................42 6. CRIAÇÃO DINÂMICA DE OBJETOS .......................................................................................42

6.1. CRIANDO UM BOTÃO DINAMICAMENTE ....................................................................................42 7. BANCO DE DADOS.......................................................................................................................43

7.1. TABLES ...........................................................................................................................43 7.1.1 Configurando uma Table....................................................................................................44

7.2. DATASOURCES ..............................................................................................................45 7.2.1 Configurando um DataSource............................................................................................45

7.3. CONTROLADORES DE DADOS OU COMPONENTES DB...............................................................45

7.3.1 DBEdit ......................................................................................................................46

7.3.2 DBNavigator .............................................................................................................46

7.3.3 DBGrid ......................................................................................................................46

7.4. DATABASES ...................................................................................................................46 7.4.1 Configurando um DataBase ...............................................................................................47

7.5. QUERIES .........................................................................................................................47 7.5.1 Configurando uma Query...................................................................................................48 7.5.2 Adicionando Parâmetros ....................................................................................................48 7.5.3 Modificando as Linhas e Colunas exibidas por uma Query...............................................48

7.6. INSTALLSHIELD É FUNDAMENTAL! ..........................................................................................48

II


1. Introdução

Este tópico destina-se a dar uma visão geral sobre o ambiente de programação da Borland®: Delphi® 7.0 Studio, mostrando suas principais características e sua organização para melhor atender aos programadores.

1.1. Familiarização com o Ambiente de Programação

O ambiente de programação Delphi® é uma ferramenta projetada para facilitar a programação rápida e fácil de qualquer aplicação. Esta ferramenta conta com uma interface totalmente interativa. Baseando-se em uma programação orientada a objetos utilizando recursos de “drag and drop”, o ambiente proporciona ao programador um ganho de tempo muito grande. Este tempo poderá ser usado na programação dos eventos necessários para o pleno funcionamento do sistema.

Uma outra vantagem da ferramenta Delphi® é a quantidade de componentes existentes na Internet que podem ser facilmente instalados, além da grande gama de componentes que já vêm com a ferramenta.

O ambiente Delphi® foi projetado para proporcionar ao programador um meio rápido, limpo e preciso de programação, no qual apenas é necessário preencher as lacunas que serão criadas pela programação dos eventos, como veremos adiante.

Entretanto, este ambiente de programação se torna um tanto quanto prejudicial para programadores novos. Como toda a estruturação e criação de objetos é feita automaticamente pelo ambiente, o programador não tem espaço para treinar suas habilidades. Portanto, recomenda-se este ambiente para programadores mais experientes ao lidar com objetos e que visem aumentar sua produtividade. Deve-se salientar, entretanto, que este fator não é uma desvantagem, pois não impede que o programador altere os objetos criados para adaptá-los às suas necessidades.

Todas as versões do Delphi até hoje lançadas são feitas sobre o conceito de linguagem de programação compilada, ou seja, o código fonte é interpretado e transformado em objeto para depois dar origem ao executável. Existem boatos de que a Borland®, fabricante do Delphi® está desenvolvendo uma Máquina Virtual Delphi para que assim como no Java® o programa gerado tenha maior portabilidade, ou seja, que possa ser executado independente do sistema operacional.

Este curso de programação em Delphi® versará sobre a versão 7.0 do compilador e debugger Delphi®, que além de proporcionar algumas mudanças na sua interface tradicional, permite o uso de alguns recursos de interface de programação mais avançados (principalmente para serem usados com o Windows XP®). Outra mudança observada é que a nova versão do ambiente permite ao usuário utilizar alguns recursos a mais de programação Web, dentre os quais uma integração Java® é o mais chamativo deles. Curiosidade: A Borland também tem uma versão do ambiente de programação Delphi desenvolvida para o Sistema Operacional Linux, que curiosamente não recebe o mesmo nome, sendo conhecida como Kylix.

1


Ambiente de Programação Delphi 7.0

2

1.2. Subdivisões do Ambiente de Programação Delphi

O ambiente de programação Delphi® 7.0 apresenta subdivisões para melhor facilitar o trabalho do programador. Algumas dessas subdivisões podem estar ou não ativas, de acordo com as configurações do ambiente. Todas as subdivisões são de vital importância para o programador, pois são elas as responsáveis pela velocidade na programação.


Subdivisões do Ambiente de Programação

1.2.1 Menu Principal Permite o acesso a todas as funções disponíveis no ambiente de programação,

através dele todas as demais subdivisões poderão ser ativadas ou desativadas. Através deste menu poderemos também ter acessos às opções de programação, compilação, debug, do editor de código, entre diversas outras.

O Menu Principal é o responsável por todo o gerenciamento do ambiente de programação Delphi® 7.0 e normalmente pouco muda de uma versão para outra do ambiente.

d

Menu Principal

1.2.2 Gerenciador de Desktops

O Gerenciador de Desktops é uma das partes do ambiente de programação estinada aos programadores metódicos e ”chatos” que gostam de sempre ter as suas

3


janelas organizadas a seu modo. Esta ferramenta permite que o programador salve as configurações do Desktop do ambiente de trabalho Delphi® 7.0 para que possa futuramente utilizá-las caso ocorra alguma desordem. As principais características salvas são o posicionamento das janelas e viewers.

1.2.3 Palheta de Botões Rápidos

A Palheta de Botões Rápidos contém botões com as funções mais utilizadas pelos programadores no ambiente de programação Delphi® 7.0. Esta palheta foi criada com o objetivo de proporcionar maior rapidez e alcance mais rápido e fácil destas funções evitando assim o desperdício de tempo na procura das mesmas. A maioria das ações disponíveis nesta palheta possui um atalho correspondente o que torna o uso das funções ainda mais rápido e fácil para aquelas que tem boa memória.

1.2.4 Palhetas de Com

As Palhetas de Coprogramação Delphi® 7.0. Ados recursos e objetos “Drag

Cada versão Delphisimples das versões conta ctornando mais profissionaisassim como o número de pcom aproximadamente 27 componentes de interface at

1.2.5 Formulário

Uma das subdivisõeprincipal peça na programaç

Palheta de Botões Rápidos

pon

mpotrav an

® 7.om

(e malhPa

é co

s doão d

Gerenciador de Desktops

entes

nentes são as palhetas fundamentais do ambiente de és destas palhetas o programador tem acesso à maioria

d Drop” do ambiente. 0 conta com uma certa quantidade, sendo que a mais as palhetas mais básicas. Conforme as versões vão se

ais caras), o número de componentes vai aumentando, etas. A versão Enterprise Padrão do Delphi® 7.0 conta lhetas de Componentes, estas palhetas contém desde mponentes para conexão Web e ActiveX.

Palhetas de Componentes

ambiente de programação Delphi®, o Formulário é a e interfaces. Ele serve como “Dock Site”, ou seja, local

4


onde os “Drags” terminam. Esta única e simples função permite que todos os componentes encontrados na Palhetas de Componentes possam ser posicionados em seu interior. O Formulário serve também como fundo para as interfaces do usuário, onde serão colocados botões, caixas de texto, figuras, etc.

O formulário pode nem sempre estar visível ao programador ou ao usuário, porém sempre que estiver terá uma “Unit’ associada a ele, dentro da qual haverá seu código-fonte e o código de todos os componentes que ele contiver como filhos, ou seja, todos os componentes em seu interior.

rt

rp

p

Formulário

1.2.6 “Code Editor”

O Code Editor é área do ambiente de programação do Delphi® destinada a eceber o código-fonte do programa, compreendendo objetos, métodos, variáveis, ratamento de eventos e exceções, entre outros.

O Code Editor contém também, assim como todas as outras subdivisões, ecursos que tornam a edição de códigos cada vez mais rápidas. Dentre estes recursos odemos citar o “Code Completition” que será discutido no tópico 2.

Esta ferramenta possui também Syntax Highlight para auxiliar na distinção entre alavras reservadas, comentários, variáveis, entre outros.

5


tlpc

oI

Code Editor com um trecho de Código Básico

6

1.2.7 “Object TreeView”

O “Object TreeView” é uma ferramenta que proporciona uma visão geral de odos os objetos que estão sendo utilizados no projeto em questão. Os objetos são istados de acordo com o seu nome (fornecido pela propriedade Name). Cada objeto ode conter diversos outros objetos que serão mostrados em forma de árvore, omeçando dos containeres maiores, em direção aos menores.

Um clique sobre o nome de um objeto no “Object TreeView” faz como que este bjeto seja selecionado e suas propriedades e eventos então mostrados no “Object nspector”.


1.2.8 “Object Inspector

O “Object Inspector”A partir de um objeto selecioser então alterados de acordo

Para alterar uma procampo de edição e então escem um diálogo aberto.

Para alterar ou criar edição do evento em questãocódigo do evento seja feita. Curiosidade: itens em vermevínculos com outros objetos s

Object TreeView

7

”

é uma área de visualização e configuração de um objeto. nado, suas propriedades e eventos são mostrados e poderão com as necessidades do programador. priedade, basta clicar na propriedade desejada, sobre o rever o novo valor, ou selecionar algum objeto ou arquivo

um evento basta dar um clique duplo sobre a caixa de , o “Code Editor” será então lançado para que a edição do

lho são propriedades ou eventos que poderão possuir e o programador assim achar necessário.


8

Object Inspector

1.3. Ambiente “Drag and Drop”

O ambiente de programação do Delphi® 7.0 Studio por ser altamente integrado permite que a maioria dos objetos criados nele sejam inseridos na aplicação através do arrastar e clicar. Este recurso aumente a velocidade de programação e proporciona maior precisão no posicionamento de componentes de interface. Além dessa facilidade de posicionamento devemos salientar a economia de tempo que o programador adquire. Na maioria dos ambientes ou linguagens de programação, o programador depois de posicionar através de linhas de comando o seu componente ou objeto, tem que compilar o código, verificar o posicionamento e se algo estiver errado, tentar adivinhar o valor adequado para a posição do objeto.

Ao falarmos em “Drag and Drop” não podemos nos esquecer do formulário já citado anteriormente. É o formulário que serve como “dock”, ou seja, o formulário é o objeto recipiente dos componentes. Porém o formulário não é o único recipiente de objetos, mas sim o principal. Outros componentes como panels, por exemplo, podem receber componentes de outros tipos ou até mesmo panels.


Componentes sendo posicionados em regiões de “dock”

2. Ferramentas do Ambiente de Programação

Este módulo é destinado à prática de programação rápida. Nele serão apresentados recursos do ambiente de programação que são extremamente úteis para o desenvolvimento de aplicações. Estes recursos permitem que o programador economize tempo de digitação e se preocupe mais com a lógica do que com a digitação.

2.1. “Code Completition”

O “Code Completition” como o próprio nome diz é um completador de códigos. Por essa característica é um recurso muito utilizado quando se pretende desenvolver aplicações rapidamente.

Este recurso possibilita que o programador visualize todas as funções, procedimentos, classes, objetos, variáveis entre outros que estão definidas e que poderão ser utilizadas. O “Code Completition” é muito inteligente e mostra sempre ao programador as opções adequadas para completar o código. Nota: se o “Code Completition” não conseguir exibir nenhuma opção para completar o código, isto indica que o código apresenta erros em posições anteriores a que ele foi

9


chamado, ou que ele ficou em dúvida sobre a melhor opção a escolher. O último caso geralmente ocorre com tipos definidos pelo usuário ou diante do uso de type-casting.

2.1.1 Chamando o “Code Completition”

O “Code Completition” conforme dito anteriormente é um recurso do “Code Editor”, portanto só pode ser chamado dentro do mesmo. Uma vez dentro do “Code Editor”, o “Code Completition” poderá ser chamado em qualquer lugar (exceto para completar nome de “units” após os comandos “uses”), pressionando-se as teclas <CTRL>+<Barra de Espaço>. Ao pressionar esta combinação de teclas, uma lista com todas as opções possíveis de complemento será apresentada. Basta então escolher a opção adequada e pressionar <ENTER>.

2.1.2 Refinando a busca do “Code Completition” Quanto maior a quantidade de letras que estiverem digitadas antes de chamar o

“Code Completition”, maior será o refinamento da busca, menor o número de resultados e melhor a qualidade dos mesmos. O refinamento da busca poderá ser feito com a lista de resultados já aberta, o que causará um atualização da mesma para se adequar aos novos requisitos da busca.

Exemplo de uso do “Code Completition”

No exemplo da figura acima foi definida uma variável nome do tipo string em um procedimento qualquer. Logo em seguida, no corpo do procedimento, chamamos o

10


“Code Completition” fornecendo apenas a primeira letra da variável que já conhecíamos. Por sorte ela é a primeira da lista, basta agora pressionar <ENTER> e usá-la! Se a variável não fosse a primeira da lista, bastava navegar pela mesma utilizando as setas para cima e para baixo, ou então continuar fornecendo letras com a lista aberta. Ao fornecer mais letras com a lista aberta, ela automaticamente se atualiza. Na figura acima se nota que a lista apresenta 2 colunas distintas:

• Primeira Coluna ou Coluna dos Tipos: esta coluna indica o tipo do elemento que aparece na segunda coluna, ou seja, se ele é uma variável, função, procedimento ou um tipo em si;

• Segunda Coluna ou Coluna dos Identificadores: nesta coluna os identificadores aparecem, ou seja, os nomes das variáveis, rotinas ou tipos, assim como seus parâmetros e no caso de variáveis e funções o tipo de dados que comportam e retornam respectivamente.

2.2. Estruturas de Programação Pré-Estabelecidas (“Code Templates”)

É muito comum que uma aplicação contenha estruturas de programação das mais variadas formas e tamanho, e na maioria das vezes estas estruturas se repetem. Seria muito mais fácil para o programador ter estas estruturas de programação como while, for, entre outras pré-definidas para quando necessário invocá-las. Para isso o Delphi® 7.0 Studio conta com um recurso similar ao “Code Completition”, porém para complementar estruturas de programação. Estas estruturas pré-definidas são as “Code Templates”.

2.2.1 Utilizando “Code Templates” O uso das “Code Templates” se dá de maneira similar ao uso do “Code

Completition”. Dentro do “Code Editor”, em uma região válida, ou seja, dentro de uma função ou procedimento, pressione as teclas <CTRL>+<J>. Uma lista com as opções de estruturas pré-definidas será apresentada. Ao escolher a estrutura adequada pressione <ENTER> e ela será inserida no seu código-fonte. Assim como descrito na explicação do “Code Completition”, a busca pela templates poderá ser facilitada se uma ou mais letras do nome fornecido à template forem indicadas antes de pressionar a combinação de teclas.

Assim como a lista de opções do “Code Completition”, a lista de opções das “Code Templates” possui duas colunas, a saber:

• Primeira Coluna ou Coluna da Descrição: esta coluna mostra uma descrição do tipo de código que será inserido no “Code Editor” ao se escolher a template em questão;

11


• Segunda Coluna ou Coluna do Nome: esta coluna exibe o nome pré-

definido para o conjunto de comandos ou estrutura de programação estabelecida pelo programador. Este nome é que deve ser digitado para facilitar a busca ou para que a template seja inserida.

2.2.2 Adicionando “Code Templates” Para adicionar “Code Templates” basta realizar os seguintes passos:

1. No Menu Tools vá em Editor Options. A janela da figura abaixo deverá aparecer;

Lista de “Code Templates

Janela de Propriedades do Code Editor

12


2. Em Source Options clique no botão Edit Code Templates;

3. Na Janela que se abre escolha entre abrir, editar ou excluir o nome ou a descrição de uma template. O código da mesma pode ser alterado diretamente abaixo da lista em “Code”

Janela de Propriedades do Code Editor – Editando Templates

Editor de Templates

Nota: o caractere “|” (pipe ou barrinha em pé) que aparece nas definições da maioria das templates que acompanham Delphi® 7.0 Studio indica o lugar onde o cursor irá para depois que a template for inserida no “Code Editor”.

13


3. Programando em Delphi

Neste tópico em a preocupação principal será a codificação em Delphi, introduzirá o usuário em alguns princípios básicos de programação. Será mostrado como fazer para que o código se torne o mais claro possível, facilitando posterior manutenção do mesmo.

3.1. Tipos de Arquivos Gerados pelo Delphi

Cada aplicação ou projeto gerados no Delphi pode gerar um número bem grande de arquivos. Cada tem o seu papel especial no armazenamento das configurações das aplicações e são indispensáveis para a remontagem das mesmas.

Os tipos de arquivos mais comumente gerados pelo Delphi são:

• *.DPR: arquivo de Projeto. Este arquivo é o programa principal de toda a aplicação dentro dele estão armazenados informações sobre as units e seus nomes, assim como os Formulários associados. Neste arquivo também são determinados os formulários que serão criados e exibidos no início da aplicação. O conteúdo do arquivo DPR poderá ser visualizado abrindo-se o projeto no “Code Editor” da seguinte maneira: Menu View Units e selecionando o projeto, ou através do atalho <CTRL>+<F12>;

Arquivo DPR no “Code Editor”

14


• *.PAS: são os arquivos que armazenam as units, contendo rotinas,

variáveis, definições de tipos, entre outros. Cada arquivo *.PAS representa uma unit;

• *.DFM: este arquivo armazena os valores das propriedades configurados

no Object Inspector de todos os componentes presentes no formulário associado a uma unit *.PAS de mesmo nome. Não modifique este arquivo manualmente, a não ser que saiba o que está fazendo. O arquivo DFM pode ser visualizado clicando-se com o botão direito sobre um formulário e em seguida escolhendo a opção “View as Text”, o formulário será exibido como texto no “Code Editor”;

Arquivo PAS no “Code Editor”

Arquivo DFM no “Code Editor”

15


• *.DOF: armazena as opções do Projeto que podem ser modificadas

através do menu Project Options, que também é única maneira de verificarmos o conteúdo de um arquivo DOF.

Arquivo DOF visualizado nos Opções de Projeto

3.2. O que Salvar?

Como o Delphi® 7.0 Studio cria muitos arquivos é necessário ter conhecimento sobre os mesmos, para saber qual deles devem ser selecionados para Backup. A seguir temos uma tabela com essas informações:

Extensão do Arquivo Necessidade de Salvar Utilidade do Arquivo

DPR Essencial Guarda as Configurações do Projeto da Aplicação

PAS Essencial Guarda as Rotinas, Variáveis e Tipos da Aplicação

DFM Essencial Guarda o Posicionamento dos Componentes dentre do Formulário

DOF Opcional Guarda as Opções do Projeto RES Opcional Guarda algumas informações

não muito úteis como o ícone da Aplicação se este for mudado

*.~* Totalmente Desnecessário Backup Preventivo do Delphi

16


3.3. Norma Internacional de Nomenclatura de Variáveis e Objetos

Saber dar nomes a variáveis e objetos é extremamente importante para o

programador de aplicações. Grandes empresas geralmente trabalham com aplicações cujo código-fonte tem um número muito grande de linhas e que levam uma grande quantidade de tempo para serem implementados. Extensão e tempo somados fazem com que o programador se esqueça do que cada trecho de código realiza.

Um código-fonte mal documentado é extremamente difícil de se fazer manutenção, agrava-se a situação se as variáveis ainda por cima não tiverem um nome claro. A maioria dos programadores tem por hábito chamar variáveis de “eu”, “a”, “x”, entre outros. Estes nomes dificultam que qualquer outro programador entenda e consiga fazer manutenção do código.

Para evitar este tipo de problema, foi criado um Padrão Internacional de Nomenclatura, no qual o início do nome de cada variável é composto pela “abreviação” do seu tipo, com as letras minúsculas. Esta abreviação é realizada omitindo-se as vogais da palavra que compõe o tipo. Por exemplo, se temos um objeto do tipo Form, seu nome seria frm+<nome a escolha do programador> (recomenda-se que <nome a escolha do programador> tenha a ver com a função do objeto ou variável). Utilizando esta nomenclatura todos os que tivessem contato com o objeto frmGerenciamentoDados, mesmo que não soubessem português saberiam que este objeto é um Form, sem ter que localizar sua declaração. Já os que soubessem um mínimo de português saberiam que, além disso, este formulário realizar as funções de gerenciamento de Dados.

Existe uma outra vertente para nomenclatura de variáveis que diz o nome de uma variável deve ter em seu primeiro caractere uma letra minúscula representando o tipo de dado que a variável guarda, sendo a segunda letra maiúscula. Assim, por exemplo, uma variável chamada ValorX do tipo real, deveria ser nomeada fValorX, onde f representa que a variável armazena um dado com ponto flutuante.

3.4. Case-Insensitive

Este item foi criado com único propósito de frisar uma das características do Delphi® 7.0 Studio, portanto será breve. O pretende-se neste item é salientar que o ambiente de programação do Delphi é Case-Insensitive, ou seja, para variáveis, comando, procedimentos, etc, não importa o modo como você os chama no que diz respeito à caixa do nome. Por exemplo, se criarmos um procedimento chamado “CalculaX”, poderemos chamá-lo das seguinte maneiras:

• calculax; • CaLcUlAx; • calCulax; • ...

Qualquer uma das formas apresentadas acima e variantes são reconhecidas pelo Delphi como sendo o mesmo procedimento. Portanto não é necessário se preocupar como chamar o procedimento como no caso de linguagens case-sensitive como C e Java que exigem que todos os caracteres tenham a mesma caixa para serem reconhecidos como o mesmo procedimento.

17


3.5. Criação de Variáveis

As variáveis são de suma importância para qualquer programa. Elas permitem

que dados sejam armazenados, manipulados e lidos, mais principalmente facilitam a sua localização e chamada. É, portanto fundamental que o programador saiba criar variáveis e que saiba como nomeá-las de maneira adequada, conforme já vimos.

O Delphi® 7.0 Studio mantém as estruturas estabelecidas pelo Pascal ao declarar variáveis. Porém deve-se notar que o Delphi usa apenas units como unidades básicas de programa, portanto, devemos declarar as variáveis na região de interface da unit.

Na figura abaixo temos como exemplo uma unit padrão do Delphi. Notamos que a unit segue uma estrutura na qual a declaração de variáveis é feita dentro da área da unit chamada “Interface”.

Conceito Importante: a declaração de variáveis sempre é feita após a palavra

reservada “var” e sempre termina quando aparecer umas das palavras reservadas: begin ou implementation.

Unit Padrão do Delphi

Ao criarmos variáveis devemos obedecer à seguinte estrutura: var <nome da variável>: <tipo variável>; <nome da variável>,<nome da variável>: <tipo variável>;

<nome da variável>,...,<nome da variável>: <tipo variável>;

18


Exemplo var aNome: String; iValorX, iValorY: Integer; fDinheiro: Real;

Fato Importante: as variáveis são privadas às units nas quais são declaradas, ou

seja, só podem ser acessadas por métodos e objetos contidos na unit. Se for necessário utilizar um variável em outra unit, devemos adicionar sua unit na clausula uses da mesma.

Segundo Fato Importante: variáveis podem ser também declaradas dentro de objetos, sendo de uso exclusivo do mesmo, a não ser que sejam declaradas na região pública.

3.6. Constantes

Constantes são variáveis cujo valor não pode ser alterado, ou seja, seu valor é instanciado no início do programa e permanece inalterado até o término do mesmo. Constantes são úteis em programação para armazenar o valor de delimitadores de laços e para armazenar valores que sempre são utilizados no decorrer do código.

É altamente recomendável o uso de constantes no lugar de valores, pois uma vez alterado o valor de uma constate, todo o lugar onde ela aparece terá seu valor alterado também.

As constantes devem ser declaradas entre as cláusulas “uses” e “type”. Sintaxe

Const <identificador da constante> = <valor constante>

md

v

Constantes Declaradas

3.7. Tipos

O programador pode querer definir os seus próprios tipos para tornar o programa ais claro e conciso. O Delphi® 7.0 Studio possibilita que isso ocorra assim como as

emais linguagens de alto nível. O programador deverá declarar seus tipos sempre antes de atribuí-los a uma

ariável, recomenda-se que isto seja feito logo após a declaração das constantes.

19


A declaração do tipo deve ser feita após a palavra reservada “type”.

Sintaxe

type <identificador do tipo> = <declaração do tipo>; <identificador do tipo> = <declaração do tipo>; <identificador do tipo> = <declaração do tipo>;

pr

i

ul

edcn

“

Observação: a criação de tipos é fundamental quando se deseja passar por arâmetro matrizes ou variáveis cujo tipo seja altamente complexos, como por exemplo, ecord.

3.8. Criação de Rotinas

As rotinas foram concebidas com o intuito de facilitar a programação, são solamentos lógicos de blocos de comandos. Através delas podemos criar níveis de

abstração, ou seja, permitir que outros métodos ou rotinas chamem através de ma única linha de programação um conjunto de outros comandos sem precisar escrevê-os.

Entretanto, o principal motivo pelo qual as rotinas são amplamente utilizadas é a conomia de linhas de código. Um bloco de comandos que aparece repetidas vezes entro de um programa pode ser declarado dentro de uma rotina. Assim poderemos hamá-lo diversas vezes dentro do programa, sem precisarmos escrever os comandos ovamente.

As rotinas também são conhecidas em programação orientada à objetos como métodos”, mas somente recebem essa designação quando fazem parte dos objetos.

Existem dois tipos principais de rotinas, a saber: • Procedimento: encapsula um bloco de comandos e permite a passagem

de parâmetros por referência ou valor; • Função: tipo especial de procedimento que retorna um valor além de

possuir as características comuns a todos os procedimentos.

20


3.8.1 Parâmetros

Ao definir rotinas, na maioria das vezes, se faz necessário o acesso às variáveis

externas. Porém nem sempre essas variáveis são globais, ou seja, variáveis às quais todos têm acesso. Para tanto, utilizamo-nos do recurso dos parâmetros. Parâmetros são variáveis que são passadas para a rotina para que esta possa executar seus comandos utilizando os valores dos parâmetros.

Existem dois tipos de parâmetros implementados no Delphi® 7.0 Studio, a saber: • Por Valor: parâmetros por valor são aqueles que ao serem passados para

as rotinas, apenas permitem que seu valor seja usado e não alterado. Isso ocorre porque é criada uma cópia do parâmetro para uso exclusivo da rotina. No fim do processamento da rotina, este valor é perdido;

• Por Referência: parâmetros por referência são aqueles que permitem que todas as alterações feitas sobre o seu valor original sejam refletidas na variável externa à rotina. Na realidade, ao serem passados para a rotina, o que esta recebe é um ponteiro para o endereço de memória do parâmetro, portanto todas as alterações são feitas diretamente na área de memória da variável externa.

3.8.2 Procedimentos

Procedimentos são blocos especiais de programa que permitem o encapsulamento lógico de um conjunto de comandos. Isto facilita o entendimento das funções do conjunto, assim como também proporciona um enxugamento maior do código.

Os procedimentos são rotinas parametrizáveis, ou seja, são capazes de receber parâmetros. Estes parâmetros poderão ser passados por valor ou referência. Parâmetros passados por referência deverão ter suas declarações precedida pela palavra reservada var.

Procedimentos, assim como as funções, permitem a declaração de variáveis internas, que deve ser feita antes do begin do procedimento. Estas variáveis são visíveis apenas pelo procedimento e são eliminadas da memória quando o procedimento deixa de ser executado.

Sintaxe

procedure <nome do procedimento> (<var><parâmetro 1>: <tipo parâmetro 1>;

<var><parâmetro 2>: <tipo parâmetro 2>); var <variável 1>: <tipo variável 1>; <variável 2>: <tipo variável 2>; begin end;

21


Exemplo procedure somaAB (A,B: real; var Resultado: real); begin Resultado:=A+B;

end; Modo de Invocação: somaAB(A,B,Resultado);

3.8.3 Funções

Funções são um tipo especial de procedimento que além de manter as funcionalidades do mesmo, permitem que um valor seja retornado. Este valor não é um parâmetro.

Sintaxe

function <nome da função> (<var><parâmetro 1>: <tipo parâmetro 1>; <var><parâmetro 2>: <tipo parâmetro 2>): <tipo função>; var <variável 1>: <tipo variável 1>; <variável 2>: <tipo variável 2>; begin end;

Exemplo function somaAB (A,B: real): real; begin somaAB:=A+B;

end; Modo de Invocação: <variável de resposta do mesmo tipo da função>:=somaAB(A,B);

3.8.4 Onde declarar rotinas

As rotinas devem ser declaradas apenas na região da unit conhecida como “implementation”. Esta área é destinada à declaração do corpo dos métodos.

22


vo

od

a S

Rotinas declaradas dentro de implementation

23

Observação: rotinas são diferentes de métodos, portanto para elas, objetos e

ariáveis internos a outros objetos serão invisíveis, pois estes são privados aos seus bjetos recipientes.

3.9. Criação de Métodos

Métodos são rotinas especiais de objetos, que possuem privilégios sobre seu bjeto continente. Podem acessar variáveis, objetos e até mesmo outros métodos dentro e seu objeto continente.

Os métodos possuem uma maneira especial de serem declarados. Devem conter ntes de seu nome o tipo do objeto continente, separado por “.” de seu próprio nome.

intaxe

procedure <tipo objeto>.<nome do procedimento> (<var><parâmetro 1>: <tipo parâmetro 1>; <var><parâmetro 2>: <tipo parâmetro 2>);

var <variável 1>: <tipo variável 1>; <variável 2>: <tipo variável 2>; begin end; function <tipo objeto>.<nome da função> (<var><parâmetro 1>: <tipo parâmetro 1>; <var><parâmetro 2>: <tipo parâmetro 2>): <tipo função>; var <variável 1>: <tipo variável 1>; <variável 2>: <tipo variável 2>; begin


end;

3.9.1 Onde Declarar Métodos

Métodos têm uma maneira diferente de serem declarados. Como as rotinas seu corpo deve estar descrito na região conhecida como “implementation” e deve ser feito segundo a sintaxe acima. Porém é necessário também incluir o cabeçalho do método dentro da definição do objeto do qual ele faz parte.

Existem três seções possíveis para se inserir o cabeçalho de um método. Estas seções também servem para declaração de variáveis. São elas:

• Delphi exclusive declarations: nesta região o delphi faz a declaração de todos os métodos, variáveis e objetos que cria automaticamente. Dentre estes métodos, temos os métodos que são utilizados para o tratamento de eventos. Nesta região pode-se inserir métodos que são definidos pelo programador, porém sempre que possível é melhor evitar isto. É altamente recomendável que os métodos do programador sejam declarados nas próximas duas seções;

• Private declarations: esta região é utilizada na declaração de variáveis e métodos que são privados ao objeto, ou seja, somente o objeto terá acesso ao que for declarado nesta região;

• Public declarations: esta região é utilizada na declaração de variáveis e métodos que são públicos, ou seja, o que for declarado nesta região poderá ser acessado por qualquer objeto ou uma unit que puder acessar uma instância do objeto continente desta região.

Seções de Declaração de Métodos e Variáveis

24


3.9.2 Facilitando as Coisas

Para evitar problemas na hora de declarar métodos, principalmente por

incompatibilidade de cabeçalho, o Delphi® 7.0 Studio possui um recurso interessante de auxílio. Este instrumento permite que, a partir de um cabeçalho inserido em um objeto, posicionando-se o cursor sobre o nome do mesmo e pressionando-se a combinação de teclas <ctrl>+<C>, o esqueleto do método é automaticamente criado na região “implementation”.

3.10. Criação de Units

Units é a menor subdivisão de um programa logicamente completo em Delphi. Cada unit é composta por um conjunto de declarações de métodos, rotinas, variáveis, objetos e classes, que podem ou não estar presentes.

O Delphi® 7.0 Studio apresenta dois tipos de units principais, uma delas é a própria unit em si, a outra é uma unit conjugada com um objeto form. A última é a mais comumente usada, sendo também a primeira a ser visualizada quando um projeto é criado.

Para adicionarmos uma unit em um projeto devemos seguir um dos seguintes passos:

• Com o projeto aberto, no menu File New Unit: esta seqüência de passos cria uma unit simples;

• Com o projeto aberto, no menu File New Form: esta seqüência de passos cria uma unit conjugada a um formulário.
Unit conjugada a um Formulário
25


Opc

fte

rs

Unit simples

26

bservando a figura acima, nota-se que ambas as units mantém uma mesma estrutura adrão. A segunda figura mostra como uma unit deve ser declarada e o que ela deve onter. Todas as units criadas deverão no mínimo apresentar a seguinte estrutura:

unit <nome da unit> interface implementation end.

3.10.1 Interface

Uma das regiões fundamentais a qualquer unit a interface tem um papel undamental na definição de uma unit. É através dela que todos os objetos e outras units omam conhecimento dos métodos possuídos pela unit, assim como as variáveis, objetos rotinas.

Tudo o que for declarado nesta região assim como todos os cabeçalhos de otinas nela contidos serão visíveis para todas as outras units que contiverem a unit em ua cláusula “uses”.


Um bom programador segue uma estrutura clássica ao escrever sua seção

interface. Em seguida aparecem as cláusulas que poderão estar contidas na seção, elas estão seguindo a estrutura clássica, portanto, é fundamental que esta ordem seja mantida.

Cláusulas que podem ser inseridas na seção interface na ordem preferível de

aparecimento: • Uses: determina de quais units a unit atual necessita, das units cujos

nomes aparecem a frente desta cláusula, a unit atual utiliza componentes e declarações;

• Const: após esta cláusula são declaradas as constantes, para maiores detalhes consulta a seção 3.6;

• Type: com uso desta cláusula é permitida a declaração de tipos conforme a necessidade do programador. Para maiores informações consulte a seção 3.7;

• Var: cláusula utilizada para identificar a declaração de variáveis. Para maiores informações consulte a seção 3.5;

• Cabeçalhos das Rotinas: após a declaração de todos os itens anteriores se existirem, virá a declaração dos cabeçalhos das rotinas implementadas na seção “implementation” e que serão visíveis aos usuários da unit.

d

Estrutura Clássica da Seção Interface

3.10.2 Implementation

Implementation é a seção da unit onde o corpo das rotinas e métodos são eclarados. Como o próprio nome diz, é onde ocorre a implementação.

27


Esta seção pode conter todos os tipos de cláusulas declaradas para a seção

“interface”, porém as cláusulas aqui declaradas só poderão ser utilizadas por esta seção. Um fato importante a se observar é que todas as cláusulas usadas pela seção

“interface” também são válidas nessa seção, portanto não é necessário redeclará-las. A declaração de rotinas deve ser feita nessa seção como foi descrito

anteriormente na seção 3.8.4. Curiosidade: as rotinas poderão ser inseridas nessa seção com o seu cabeçalho

completo ou apenas até o seu nome. Seu o último for feito, o delphi procurará por sua declaração posterior na seção “interface” e completará o resto!

pC

p

ve

e

dt

Exemplo de Implementation com Rotinas

3.11. Eventos

Eventos são fatos ou ocorrências disparadas durante o andamento de um rograma. Toda programação orientada a objetos se baseia na ocorrência de eventos. abe ao programador dizer então o que ocorrerá quando um evento acontecer.

O Delphi® 7.0 Studio permite que o programador programe para que seu rograma reaja diante desses eventos.

A maioria dos eventos são disparados por componentes gráficos do ambiente isual do programa, estes eventos podem ser do tipo: clicar do mouse, entrada do mouse m uma região, movimentação de componentes, etc.

Para ter acesso a lista de eventos de um objeto ou componente, basta clicar sobre le e ir ao “Object Inspector” e selecionar a aba “Events”.

A maioria dos componentes presentes na barra de eventos apresenta algum tipo e evento relacionado a ele, portanto a chance de você escolher um componente que não enha eventos para se tratar é muito pequena.

28


sc

Componente Botão e seus Eventos

Ao selecionar o objeto e escolher o evento desejado, basta dar um clique-duplo obre o campo a frente do nome do evento e o “Code Editor” aparecerá para que os omandos sejam inseridos na rotina de tratamento do evento.

Com um clique-duplo sobre o evento “OnClick” do botão temos:

Rotina de Tratamento do Evento do Botão

29


3.12. Tratamento de Exceções

A programação é uma tarefa difícil e muito complexo, principalmente quando

lidamos com dados ou acontecimentos dos quais não podemos prever. Quando estes fatos ocorrem o programa pode sofrer sérios crashes e sua execução ser interrompida repentinamente sem explicações, ou aparecendo a telinha azul do Windows.

Procurando evitar este tipo de problemas foram inventados métodos para que estas exceções ocorrendo o programa consiga driblá-los facilmente. Este métodos são chamados de tratamento de exceções.

O Delphi® 7.0 Studio implementa dois meios de se tratar exceções: try ... except e try ... finally.

3.12.1 Try ... Except

O comando try ... except e usado para tratar exceções e tem sua base implementada da seguinte maneira: tenta executar um comando ou um conjunto deles, se ocorrer exceção então ela a trata e aborta a rotina em execução. Sintaxe Try <comandos> Except on <exceção> do <ação> on <exceção> do <ação> on <exceção> do <ação> ... End;

Para tratar a exceção basta então saber o nome da exceção que ocorreu para executar alguma ação sobre ela, se assim desejar. Se nenhuma exceção for especificada, o programa apenas abortará a rotina.

Tratamento de Exceções – Divisão por Zero

30


3.12.2 Try ... Finally

Este comando trata exceções da mesma forma que o comando try ... except,

porém a única diferença entre eles é que diante da ocorrência de uma exceção ao invés de tratá-la, ele executa os comandos após o finally. Para este comando não importa o que aconteceu, mas sim o que deve ser feito antes que a rotina aborte. Sintaxe Try <comandos> Finally <comandos> End;

4

Ee

cmDf

Tratamento de Exceções sem saber qual o tipo de exceção

. Compilando e Debugando

Mais importante do que saber programar é saber compilar e debugar o código. ste item refere-se somente a essas duas ações fundamentais para a geração do código xecutável e rastreamento de erros respectivamente.

4.1. Compilando

A compilação do programa consiste na fase mais importante dentre as duas itadas nesse item, com o compilação o código fonte é convertido em linguagem de áquina para poder depois ser executado pelo processador. Durante a compilação o elphi® 7.0 Studio faz a transformação dos comandos e une-os quando necessário às

unções nativas do Windows côo, por exemplo, as APIs.

4.1.1 Gerando o executável

A geração do executável pode ser feita das seguinte maneiras:

31


• Menu Project Compile Project (<ctrl>+<F9>): realiza a compilação

do código, se tudo ocorrer bem, constrói o executável; • Menu Project Build Project: constrói o código executável, se o

programa não tiver sido compilado, ele o faz; • Menu Run Run (<F9>): roda o programa, se não tiver sido compilado

ou construído, os fazem.

4.1.2 Erros de Compilação

Se durante a compilação algum erro for encontrado, um janelinha abrirá no “Code Editor”. Esta janelinha mostrará que um erro ocorreu, informará a unit onde ele ocorreu, qual sua linha e dará um breve descrição sobre o erro. O “Code Editor” também estará com o cursor posicionado sobre o primeiro erro da lista, cuja linha estará marcada em vermelho.

Esta janelinha também é utilizada para mostrar Warnings. É sempre interessante checar os warnings, a maioria deles pode ser resolvido.

d

Code Editor – Erro de Compilação
Facilidade: uma das facilidades implementadas na ocorrência de erros é que o
uplo clique sobre um indicação de erro na janela de erro leva direto à linha de erro.

32


4.2. Debugando

O recurso debug é muito importante quando temos erros os quais não podemos

identificar em tempo de execução, para isso usamos os recursos de debug. Com eles podemos analisar o código rotinas por rotina, linha de código por linha de código e observar o conteúdo de cada variável.

Existem dois meios mais usuais de se percorrer o código-fonte: • Step Into: percorre o programa linha por linha e ao encontrar uma rotina

executa a mesma linha por linha e assim por diante. Este recurso é ativado com o uso da tecla <F7>;

• Step Over: percorre o programa linha por linha e ao encontrar uma função a executa sem entrar no seu interior, ou seja, não mostra a execução linha a linha da rotina. Este recurso é ativado com o uso da tecla <F8>.

4.2.1 BreakPoints

Breakpoints são recursos muito utilizados durante a debugação de um programa e são nada mais nada menos do que marcos de parada. O programa executa normalmente até o ponto onde encontra um breakpoint, então a execução passa a ser passo a passo no código-fonte até que o programador diga para prosseguir através do comando Run ou <F9>.

Para adicionar um breakpoint, basta compilar o código-fonte, após a compilação, nota-se no lado esquerdo do “Code Editor”, bem ao lado do código, o surgimento de algumas bolinhas azuis. Estas bolinhas marcam lugares válidos para a inserção de breakpoints. Para inseri-los basta clicar sobre as bolinhas e a linha se tornará vermelha dizendo que o breakpoint foi efetivado.

Bolinhas Azuis e Breakpoint

33


4.2.2 Watches

Watches permitem ver o valor de uma variável ou componente em um dado

instante. São muito úteis durante o processo de debugação do programa, pois mostram o conteúdo da variável a cada passo do debugger.

4.2.2.1 Janela de Watches

A janela de Watches é necessária para que se possa visualizar os watches. É nesta janela que são inseridos os watches e através dela que também podemos manipulá-los e classificá-los de acordo com o nosso gosto.

A janela de watch pode chamada de duas maneiras: • Menu View Debug Windows Watches; • <Ctrl> + <Alt> + <W>

caravariá

de Wo pr

Janela de Watches ou Watch List

4.2.2.2 Adicionando um Watch

Para adicionar um Watch basta tomar um dos seguintes passos: • Botão Direito sobre a Janela de Watches Add Watch; • <Ctrl> + <A>.

Após realizado um dos passos acima uma janela aparecerá para que as cterísticas do watch sejam determinadas. Nessa janela deve-se fornecer o nome da vel, componente, propriedade ou qualquer outra coisa que se deseje avaliar.

Os watches também podem ser feitos sobre expressões booleanas ou aritméticas. Após a configuração das características do watch ele deverá aparecer na Janela

atches. Para que um watch possa mostrar o valor do que se deseja é necessário que ograma esteja funcionando, pois ele retira as informações da memória.

34


4.2.2.3 R

A remoçpressionar a tec

4.2.2.4 A

A alterawatches, então

5. Interface c

Uma dinterface. A inteo programadorusuário, de man

Uma para o usuário não será vista. verá é o que est

InterfaInterfaces color

Neste a criação de int

Propriedades do Watch

35

emovendo um Watch

ão de um watch é simples, basta clicar sobre ele na janela de watches e la <delete>.

lterando um Watch

ção de um watch é feita dando-se um duplo clique sobre ele na janela de a janela de características se abrirá para edição.

om o usuário

as principais armas de um programador para vender seu programa é a rface é o cartão de visitas de um programa. Portanto, é fundamental que

saiba como fazer uma boa interface, e como deixar coisas à mão do eira fácil e “amigável”.

interface chamativa e pouco espalhafatosa é uma arma poderosa, pois que é leigo em programação a complexidade de modelagem problema Logo ele dificilmente saberá reconhecer o valor do programa, o que ele á diante dos seus olhos. ce porcas e mal estruturadas implicam em insatisfação do cliente. idas e não circenses são sempre bem-vindas. item serão abordados alguns componentes que servirão como base para

erfaces avançadas.


5.1. Panels

Painéis são simples quadrados recipientes básicos de objetos, eles não têm muitas funções específicas e servem na maioria das vezes como quebra-galho no que diz respeito à organização e interface.

Na maioria das vezes são usados como separadores de áreas e como dock para botões e outros componentes de interface. Pode ser usados também como um quadro para a exposição de figuras, entre outras utilidades.

Os painéis também são conhecidos como o 1001 utilidades dos sistemas gráficos.

Adicionar um painel é tão simples que não é necessário nem um subitem para explicar como fazê-lo. Basta procurar pelo desenho mostrado no início deste tópico na Barra de Componentes na guia “Standard” ou por um componente chamado “Panel” na mesma guia.

5.2. Criação de M

Menus são iteao fato de serem unidsistemas mais agradáferramentas ao alcancecomplicada.

5.2.1 Adicionand

Para adicionferramentas na aba “St

Painel dentro de um Formulário

enus

ns muito comuns em interfaces e sua grande utilização se deve ades gráficas que tornam a apresentação das ferramentas dos

vel. Além disso, os menus são práticos porque deixam as do usuário que podem acessá-las de maneira rápida e menos

o o Componente de Menu

ar um menu a uma aplicação basta procurar na barra de andard” por um componente com a figura apresentada no início

36


deste tópico ou chamado MainMenu. Ao encontrá-lo clique sobre ele e adicione em um formulário de sua aplicação. A princípio você não notará nenhuma diferença, pois o menu ainda está vazio. É necessário agora adicionar itens de menu para que possamos notar a diferença no formulário.

5.2.2 Criando Itens de Menu

Com o mouse, clique com o botão direito sobre o componente de menu e selecione o Menu Designer...

Uma janela se ab

célula em aberto. Clique menu é criado no momenquaisquer outras proprieda

Ao clicar no itemse fosse um menu e dentpassos anteriores sobre est

Se repetirmos os uma Barra de Menu com d

Menu Designer...

rirá mostrando o esqueleto de um menu inacabado, com um nesta célula e adicione um caption e um nome, note que o to em que o caption ou nome são adicionados. Configure

des que achar conveniente. de menu que você acabou de criar note que ele se abre como ro dele aparece outra célula vazia. Se fossem realizados os as células teríamos um item de menu. passos acima com cada tipo de célula citado poderemos criar iversos Menu e Itens de Menu quanto forem necessários.

37


5.2.3 Cria

A crinecessário queclicamos com oserá criado. O sitem de menu e

5.3. Criaç

Barrasem geral. Esta programa. A prusuário tenha spor ele definida

Menu Designer, Menus, Itens de Menu e Células Vazias

ndo SubMenus

ação de submenus é simples, porém para se criar um submenu é tenhamos um Item de Menu criado. A partir deste item de menu, direito sobre ele e selecionamos “Create SubMenu”, então o submenu ubmenu virá com um célula vazia que poderá ser transformada em um

depois em um submenu e assim sucessivamente.

Criando um SubMenu...

38

ão de Barras de Ferramentas

de Ferramentas são utensílios de interface muito utilizados em sistemas barra comporta botões que permitem o acesso às principais funções do incipal função de uma barra de ferramentas é, portanto, garantir que o

empre um modo rápido de acessar as principais funções do programa ou s.


A inserção de

um formulário aberto. Elocalizar o componentecomponente e então se clvazia deverá ser inserida

5.3.1 Adicionando

Os botões da funcionalidade, através ferramentas irá alcançar.

A barra de ferra• TButton

mais simDelphi;

• TBitButpermite

• TToolBupossui fnormalm

Para adicionar bcolocar na área da barra d

Se o botão que de ferramentas inserida, em “New Button”.

Barra de Ferramentas

39

uma barra de ferramentas é simples. Primeiro é necessário ter m seguida, na barra de componentes, na aba Win32. É só

com o desenho igual ao início deste tópico. Clica-se no ica em qualquer lugar do formulário. Uma barra de ferramentas .

Botões

barra de ferramentas são os componentes que garantem sua deles poderemos programar quais recursos que a barra de

mentas admite 3 tipos de botões: – botão comum a qualquer aplicação simples, sendo o tipo ples e primário de botão encontrado entre os componentes do

ton – botão cuja base de construção é o TButton, porém que seja incorporado ao botão um Glyph (imagem); tton – botão comumente visto em barra de ferramentas que

uncionalidades semelhantes ao TBitButton, porém seu caption ente não é exibido. otões na barra de ferramentas, basta clicar no botão desejado e e ferramentas. desejar inserir for um botão do tipo TToolButton, com a barra clique com o botão direito em sua área útil. Em seguida, clique

Inserindo um Novo Botão


5.3.2 Adicionando Separadores

Separadores são meros recursos organizacionais, eles servem para separar

botões em uma barra de ferramentas. Para inserir separadores, com a barra de ferramentas posicionada no

formulário, clique com o botão direito em sua área útil. Em seguida, clique em “New Separator”.

deIn

Ba

decoex

dojan

Inserindo novos Separadores

5.4. Criação de Barras de Status

Barras de status são pequenas áreas no rodapé de sistemas ou aplicações stinadas a exibir textos elucidativos ou a situação de teclas modificadoras como o sert, que ao ser pressionado muda o estado de inserção para a reposição de caracteres.

Todo sistema ou aplicação, sempre que possível, deve ser auto-explicativo, e a rra de status é fundamental na exibição de dicas.

5.4.1 Exibindo Dicas

Exibição de dicas é simples, basta configurar a propriedade AutoHint da Barra Status para verdadeira. Fazendo isso quando quiser exibir uma dica sobre um mponente, basta preencher a propriedade Hint do objeto e este será automaticamente ibido na Barra de Status.

5.5. Criação de MDIs

MDIs são janelas dedicadas. Estas janelas são um tipo especial criadas a partir formulário original, configurando-se sua propriedade “FormStyle”. Ao criarmos ela MDI necessitamos criar duas instâncias das mesmas. A primeira instância é

40


chamada de MDIForm e comporta todas as outras instâncias que são chamadas de MDIChild. Sempre que criarmos uma MDIChild, necessitamos criar uma MDIForm para que o vínculo MDI seja estabelecido. A janela MDIForm deverá ser a primeira a ser carregada. Em seguida, ao carregarmos as janelas MDIChild, estas últimas se abrirão dentro da janela MDIForm. Em síntese, MDI é um modelo de interface no qual existe uma janela principal dentro da qual outras são criadas e vinculadas a mesma, e são mantidas em sistema de clausura, ou seja, as janelas criadas não podem extravasar a área útil do Formulário.

Exemplo de janelas MDIForm (Form1) e MDIChild (Form2)

5.5.1 MDI Forms

São janelas destinadas a servir como desktop para outras janelas que possam vir a ser criada durante a execução do programa. Ou seja, estas últimas serão mantidas em clausura quando forem do tipo MDIChild. São criados configurando-se a propriedade FormStyle do formulário para MDIForm.

5.5.2 MDI Childs

MDIChilds são janelas criadas com o intuito de serem preservadas dentro de uma região pré-estabelecidas, similar a um desktop. Essa região deve ser uma região contida dentro de um formulário, onde a sua propriedade FormStyle foi modificada para MDIForm

41


5.6. Criação de Telas de Splash

Splashes são telas de abertura criadas com o intuito de realizar algum tipo de

propaganda da aplicação ou da empresa. São também muitas vezes criadas para que o usuário não abra o programa e surja do nada a tela principal do mesmo. Ou então são exibidas enquanto os módulos do programa são executados.

Splashes são criados basicamente utilizando-se formulário comuns, timers e a criatividade do programador.

Portanto, este tópico não apresentará uma receita para fazê-lo, utilize sua criatividade.

6. Criação Dinâmica de Objetos

Criação dinâmica de objetos consiste em criar objetos em tempo de execução, ou seja, sem inseri-los no formulário antes que o programa entre em execução. A criação dinâmica de objetos é importante quando o número de objetos utilizados em um sistema se torna muito grande, principalmente quando nem todos eles são utilizados em um dado momento ou quando não estão visíveis o tempo todo.

Justifica-se então a necessidade da criação dinâmica, uma vez que os objetos que não estão visíveis o tempo todo não necessitam serem criados ao iniciarmos o formulário, mas sim quando for necessário usá-los. Dessa forma, estaremos economizando memória. Apenas quando for necessário o uso de um objeto o criarmos.

Cada objeto tem uma maneira própria de ser criado, mas em sua maioria necessitam de dois comandos:

• Create – cria uma instância de um tipo pré-definido para que esta possa se tornar o objeto dinâmico;

• Parent – diz qual objeto contém o objeto dinâmico, ou seja, qual deles é responsável por seu controle e por possíveis tratamentos de eventos.

No próximo sub-tópico abordaremos a criação de um botão dinamicamente para elucidar os conceitos acima.

6.1. Criando um botão dinamicamente

Para criar um botão dinamicamente basta seguir os passos aqui descritos: 1. Defina um variável v do tipo TButton; 2. Crie uma instância de TButton utilzando:

v:=TButton.Create(<componente dono do objeto dinamico>);

3. Determine o pai do objeto que deve ser do tipo TWinControl, fazendo:

v.Parent:=<pai do objeto dinâmico>; 4. Configure as propriedades e métodos do objeto como achar necessário.

42


7

b

do

aCd

pvc

d

tc

Dce

Exemplo de Código de Criação Dinâmica de um Botão

43

. Banco de Dados

Banco de Dados são sistemas complexos de armazenamento de dados, aseados basicamente na criação, alteração e destruição de tabelas.

Tabelas como o próprio nome diz são tabelas comuns, com apenas uma iferença, elas armazenam valores variados na suas linhas e colunas. Esses valores são rganizados de acordo com o seu significado e a quem pertencem.

Cada coluna de uma tabela tem um significado, ou seja, todos os valores baixo dela terão o mesmo tipo valor, como por exemplo, nomes ou valores de salário. ada linha faz referência a um indivíduo ou a um dado maior, sendo que cada uma elas representa um conjunto de característica do mesmo.

O Delphi® 7.0 Studio possui um número grande de ferramentas que ossibilitam que o programador relacione seu sistema ao Banco de Dados. A seguir, eremos os mais comumente usados, visto que este curso visa uma breve introdução aos onceitos de Banco de Dados.

Os componentes de Bando de Dados são encontrados no Delphi na aba BDE a Barra de Componentes.

7.1. Tables

Tables são componentes do Delphi que permitem que um sistema utilize-se de abelas armazenadas fisicamente em um computador. Ou seja, elas são o canal de omunicação entre o sistema e o Banco de Dados ou Sistema de Tabelas.

As Tables são os componentes com a figura acima encontradas na aba BDE, ata Controls e Data Access da barra de componentes. Para inseri-las basta fazê-lo

omo se fosse um outro componente qualquer. Cada tabela representa uma tabela física deve ser acompanhada por um DataSource.


Nota: uma tabela deve ser aberta antes que dados possam ser inseridos na mesma, e fechada logo após ser usada.

7.1.1 Configurando uma Table

Para que a Table consiga estabelecer o vínculo com as tabelas físicas, é necessário configurá-la corretamente. Seguindo os passos a seguir, conseguiremos configurar uma Table para qualquer tabela disponível.

1. Edite a propriedade DataBaseName da Table, apontando-a para um

DataBase inserido no formulário ou então para um alias criado pelo DataBase Desktop;

2. Na propriedade TableName, selecione a tabela com a qual deseja

trabalhar;

3. Clique com o botão direito sobre o componente Table e em seguida em

Fields Editor;

Abrindo o Editor de Campos

4. Com o Editor de Campos aberto, é necessário agora adicionar os

campos na tabela da aplicação. Fazemos isso clicando com o Botão Direito no Fields Editor e em seguida em Add all fields.

44


Com apenas estes 4

usada.

7.2. DataSources

Data Sources são coentre os componentes do form

Este componentes sãAccess e apresentam a figura a

7.2.1 Configurando um

A configuração de Dpouca quantidade de propcomponentes à tabelas.

Passo único: 1. Na proprieda

deseja-se trab

7.3. Controladores de D

Os Controladores dComponentes, na aba Data Cono banco de dados de maneirapossuírem conexão direta com

Dentro os controalDBNavigator, DBLabel, DBG

Campos inseridos no Fields Editor

45

passos temos uma tabela da aplicação pronta para ser

mponentes cuja única função é servir de elo de ligação ulário e as Tables. o encontrados na Barra de Componentes na aba Data cima.

DataSource

ataSources é extremamente simples, em virtude de sua riedades. Vejamos como prepará-lo para conectar

de DataSet selecione o nome da tabela sobre a qual alhar.

ados ou Componentes DB

e Dados são componentes encontrados na Barra de ntrols, eles permitem a manipulação dos dados inseridos rápida e prática. Isso se deve ao fato destes componentes o componente Table. dores de dados mais utilizados temos os DBEDits, rid, entre outros.


7.3.1 DBEdit

DBEdit é um campo Edit com vínculo direto para a tabela, ou seja, tudo o que for digitado neste campo terá reflexo direto sobre a tabela apontada por um componente Table associado ao mesmo.

Para configurar o vínculo destes componentes com a tabela física, basta seguir os passos abaixo:

1. Na propriedade DataSource, identifique o DataSource que faz referência à tabela que contém o campo que será modificado com o valor do DBEdit;

2. Na propriedade DataField selecione o campo que terá seu valor modificado.

7.3.2 DBNavigator

O DBNavigator é um componente que permite que os registros contidos em um tabela sejam manipulados ou percorridos. Ele possui todas as funções básicas implementadas para facilitar a programação rápida de um banco de dados.

D

mesmos sela, como

Pa uma Tab

7.3.3

Dforma de dados são

Aclique em

Pfornecer u

7.4. D

eve-se salientar que ao movimentar os registros de uma tabela, o valor dos ó será visto se a tabela tiver algum tipo de visualizador de dados associado a por exemplo, DBGrid ou DBEdits. ara configurar o DBNavigator, precisamos indicar um DataSource associado le devidamente configurada.

DBGrid

BGrid é um componente destinado a visualização e edição de campos na tabela. Este é o componente que mais se assemelha ao real modo como os armazenados na tabela.

navegação entre os registros é feita utilizando-se mouse ou teclado e um uma célula a torna editável. ara deixar o DBGrid configurado para pronto uso apenas é necessário m DataSource válido e devidamente configurado.

atabases

46


Databases são componentes que funcionam como aliases, ou seja, eles indicam

o caminho onde estão armazenadas as tabelas. Entretanto, não fazem só isso. Os Databases também permitem que drivers sejam configurados e conexões externas sejam feitas com Bancos de Dados como Oracle, por exemplo. Nele também pode-se definir opções de logon, entre outras.

Databases são encontrados na Barra de Componentes na aba BDE.

7.4.1 Configurando um DataBase

Para configura um Database, é necessário inserir o componente no formulário e:

1. Clique com o botão direito sobre o Database e em seguida sobre Database Editor;

2.

3. 4.

7.5. Queri

Queriepossível determtambém. Fazemcomandos pode

DataBase Editor

Forneça o nome do DataBase. Este nome será utilizado na propriedade DatabaseName de um componente Table, por exemplo; Forneça o nome do driver ou do alias, mas não ambos; Pressione o botão Defaults e preencha os campos que julgar necessário.

es

s são similares às tabelas, porém elas são mais maleáveis. Nas queries é inar quais colunas de uma tabela queremos exibir, e quais registros os isto através de comandos SQL inseridos na propriedade SQL. Estes m utilizar parâmetros da propriedade Params.

47


48

7.5.1 Configurando uma Query

Para termos uma query pronta para o uso devemos configurá-la primeiro. Notaremos a seguir que os passos de configuração de uma query são muito similares aos de uma Table, a saber:

1. Selecione em DatabaseName, o Database ou o alias onde se encontra a tabela que a Query estará utilizando;

2. Na propriedade DataSource selecione o DataSource associado à Query.

7.5.2 Adicionando Parâmetros

Parâmetros são utilizados quando não sabemos exatamente qual valor passar para uma linha de comando SQL ao realizar uma consulta. Quando isto acontece usamos um parâmetros que futuramente poderá ter seu valor modificado em tempo de execução.

A adição de parâmetros deverá ser feita com o auxílio do Object TreeView, seguindo os seguintes passos:

1. Localize a query na qual se deseja inserir parâmetros no Object TreeView;

2. Procure dentro da árvore da mesmo por Params; 3. Clique com o botão direito em Params e em seguida, Add items; 4. Configura o Parâmetro conforme sua necessidade.

7.5.3 Modificando as Linhas e Colunas exibidas por uma Query Para modificar o conteúdo exibido por uma Query basta na propriedade SQL

digitar o comando SQL apropriado para tanto.

7.6. InstallShield é fundamental!

A criação de Banco de Dados feita em Delphi® 7.0 Studio só é possível graças a uma ferramenta que faz o intermédio entre Banco de Dados e o Delphi, o Borland Database Engine (BDE). Portanto, ao criar uma aplicação e levá-la para fora do ambiente de programação, ou seja, um lugar onde o BDE não esteja instalado, é necessário levar alguns arquivos junto com o sistema.

A criação de um arquivo de instalação pode diminuir a chance de ocorrerem erros na cópia destes arquivos. O Delphi® 7.0 Studio vem com uma versão Shareware do InstallShield que possui ferramentas para a adição dos arquivos necessário.

Portanto, lembre-se de sempre que for retirar seu sistema de Banco de Dados do ambiente de programação de levar os arquivos do BDE com o mesmo.

Download - Apostila Mini-Curso Delphi - Dia 3

Top Related