Download pdf - 50532966 Apostila Delphi

Transcript
Page 1: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 1 -

Índice 1 A HISTÓRIA DA LINGUAGEM PASCAL ....................... ....................................................................................... 3

2 INTRODUÇÃO AO AMBIENTE DELPHI .............................. ................................................................................. 4

2.1 O Form Designer .............................................................................................. 5 2.2 O Code Editor................................................................................................... 9 2.3 Object Inspector.............................................................................................. 13 2.4 Object Tree View............................................................................................ 15 2.5 A Palheta de Componentes............................................................................. 16 2.6 Project Manager e Project Group ...................................................................17 2.7 Salvando um Layout Personalizado ............................................................... 18 2.8 Customizando as Barras de Ferramentas do Delphi....................................... 19 2.9 Debugando Aplicações ................................................................................... 19

2.9.1 Break Point ............................................................................................. 20 2.9.2 Whatch List ............................................................................................ 21 2.9.3 Evaluate/Modify ..................................................................................... 22 2.9.4 Inspect..................................................................................................... 23

3 ESTRUTURA DOS PROGRAMAS DELPHI ............................ ............................................................................ 24

3.1 VCL x CLX .................................................................................................... 24 3.2 Projetos ........................................................................................................... 24 3.3 As Units .......................................................................................................... 25 3.4 Formulários..................................................................................................... 26 3.5 Pacotes – Packages ......................................................................................... 27 3.6 Arquivos Compilados..................................................................................... 28

4 DELPHI LANGUAGE ...................................... ..................................................................................................... 28

4.1 Comentários.................................................................................................... 29 4.2 Declarações..................................................................................................... 29 4.3 O Ponto-e-Vírgula e o Ponto .......................................................................... 30 4.4 Diretivas de Compilação ................................................................................ 31 4.5 Operadores...................................................................................................... 31 4.6 Principais Tipos de Dados .............................................................................. 34

4.6.1 Tipos de Dados Simples ......................................................................... 34 4.6.2 Tipos Estruturados.................................................................................. 39 4.6.3 Tipos Procedurais ................................................................................... 46 4.6.4 Variants................................................................................................... 49 4.6.5 Classes .................................................................................................... 50 4.6.6 Referências de Classe (metaclasses) ...................................................... 53 4.6.7 Interfaces ................................................................................................ 54

4.7 Comandos da Delphi Language...................................................................... 57 4.7.1 Comando de Decisão..............................................................................57 4.7.2 Case < X > of.......................................................................................... 60 4.7.3 While . . . do ........................................................................................... 61 4.7.4 For . . . do................................................................................................ 61 4.7.5 Break e Continue .................................................................................... 63 4.7.6 Repeat ..................................................................................................... 64

Page 2: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 2 -

4.7.7 Tratamento de Exceções......................................................................... 65 4.7.8 O Comando with..................................................................................... 66

4.8 Variáveis e Constantes.................................................................................... 68 4.9 Procedimentos e Funções ............................................................................... 68

4.9.1 Declarando Procedimentos e Funções.................................................... 69

5 COMPONENTES.................................................................................................................................................. 70

5.1 Relacionamentos entre Componentes............................................................. 71 5.2 Propriedades e Eventos Comuns .................................................................... 71 5.3 Componentes mais Usados............................................................................. 73 5.4 TForm ............................................................................................................. 73 5.5 Botões ............................................................................................................. 74 5.6 O Label ........................................................................................................... 75 5.7 Os Edits .......................................................................................................... 75 5.8 O Painel .......................................................................................................... 76 5.9 Barra de Status................................................................................................ 76 5.10 RadioButton.................................................................................................... 77 5.11 CheckBox ....................................................................................................... 77 5.12 RadioGroup .................................................................................................... 77 5.13 ComboBox...................................................................................................... 77 5.14 MainMenu e MenuItem.................................................................................. 78 5.15 PopupMenu..................................................................................................... 79 5.16 Toolbar ........................................................................................................... 79 5.17 ImageList ........................................................................................................ 80 5.18 ActionList e Actions....................................................................................... 80 5.19 Diálogos.......................................................................................................... 81

Page 3: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 3 -

1 A História da Linguagem Pascal

A linguagem Pascal foi projetada originalmente por Nicklaus Wirth no início de 1960,

mas é considerada uma das primeiras linguagens dos anos 70. Wirth criou o Pascal

com base em uma outra linguagem da época o Algol 68. Ambas as linguagens

estavam baseadas na linguagem Algol 60, mas a Algol 68 era consideravelmente mais

complexa. Wirth criou o Pascal para encapsular o melhor do Algol 68, ele quis criar

uma linguagem menor, mais simples que poderia combinar poder com simplicidade.

Na realidade, Pascal era (e ainda é) usado como uma das primeiras linguagens para

ser apresentada a estudantes de informática. Professores acham que o Pascal é ideal

como a primeira linguagem a ser ensinada, ilustrando a maioria dos principais temas

de programação moderna, com complexidade mínima.

Pascal foi vista principalmente como uma linguagem acadêmica até o lançamento do

Turbo Pascal da Borland em 1984. Embora houvesse outras implementações de

Pascal em computadores pessoal, a primeira versão do Turbo Pascal da Borland era

tecnologicamente superior às outras especialmente em velocidade de compilação

(como dizia o nome "Turbo").

Depois da introdução inicial, a Borland continuou aumentando o produto com a

linguagem Pascal, mudando a arquitetura básica da linguagem na versão 3 (com a

introdução de units) e a versão 5.5 (com a introdução de objetos). O Delphi é o mais

recente em uma longa linha de compiladores Borland Pascal. Na realidade, o Object

Pascal, que é encontrado no Delphi e no Kylix, é uma versão prévia do Borland Pascal

with Objects, Versão 7.1.

Embora exista um padrão ANSI para a linguagem Pascal, aplicado principalmente a

mainframes e versões de Pascal para microcomputadores. A Borland mantém o

próprio padrão da linguagem Pascal para computadores pessoais desde o Turbo

Pascal 1.0.

Manter um padrão único para a linguagem é duplamente vantajoso, e não tão

desvantajoso. Uma desvantagem significante é que a Borland é livre para fazer

qualquer mudança e ajuste à estrutura da linguagem com o perigo de invalidar

programas mais velhos. Porém, a Borland nunca fez isto, e as realidades de

comercialização de ferramentas para PC fazem que tal evento se torne muito

improvável. Na realidade, a maioria dos códigos escritos em Borland Pascal para

Objetos ainda compilará corretamente no Delphi.

Por possuir o padrão da indústria, a Borland tem uma vantagem, pois ela pode fazer

mudanças na linguagem (principalmente aprimoramentos) sem ter que esperar por um

processo de padronização lento e laborioso. Assim, um produto como o Delphi pode

ser lançado com uma versão aumentada de Object Pascal dentro do menor tempo

Page 4: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 4 -

possível. Em muitos aspectos então, Borland é para o Pascal o que a Sun é para o

Java.

2 Introdução ao Ambiente Delphi

A figura abaixo mostra a tela inicial do Delphi 7 e nos dá uma visão geral de seu

ambiente de desenvolvimento, composto de múltiplas janelas individuais que permitem

executar diversas tarefas, que serão explicadas mais adiante. Seus principais

elementos são:

• Form Designer

• Code Editor

• Object Inspector

• Object Tree View

• Palheta de componentes

• Menu principal

• Barra de ferramentas

Page 5: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 5 -

2.1 O Form Designer

O Form Designer é a janela vazia que aparece na figura abaixo:

É sobre esta janela que a interface gráfica da aplicação é desenvolvida,

acrescendo-se os componentes com os quais o usuário irá interagir.

Podemos configurar algumas propriedades do form designer através do menu

Tools > Environment Options > Designer mostrado próxima ilustração:

Page 6: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 6 -

No grupo “Grid Options” podemos escolher se o grid será ou não exibido

(Display Grid) bem como o seu tamanho (Grid Size).

nota: O grid de tamanho 4x4 como o da figura é uma boa opção, pois permite uma boa

visão do alinhamento dos componentes sem ser demasiadamente pequeno

O grupo “Module creation options” permite escolher se o Delphi irá criar

automaticamente ou não novos formulários adicionados ao projeto (Auto create forms

& data modules). Com esta opção desmarcada, apenas o formulário configurado como

“Main Form” será criado automaticamente.

No menu Project > Options > Forms mostrado abaixo, podemos perceber o

efeito desta opção:

Page 7: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 7 -

No exemplo, temos uma aplicação com 3 formulários, mas apenas aquele

configurado como “Main Form” aparece na lista “Auto create forms”, enquanto que os

outros são configurados apenas como disponíveis em “Available forms”, devendo ser

criados em tempo de execução. Se a opção auto create forms & data modules estiver

marcada, todos os formulários do projeto aparecerão na lista Auto create forms.

nota: a princípio, não desmarque o auto create forms & data modules para evitar

problemas. Se não desejar que os forms sejam criados automaticamente, vá à tela acima

e retire-os da lista dos forms que são criados automaticamente. Aliás, jamais deixe que o

Delphi crie todos os formulários. Deixe para criá-los apenas quando forem necessários e

destrua-os quando terminar de usar. Assim, o programa se torna mais leve e não

consumirá recursos e memória sem necessidade!

Voltando às Environment Options, resta-nos comentar o grupo “Options” que tem

algumas funções interessantes. Em “Show component captions” definimos se o designer

irá ou não mostrar os nomes de componentes não visuais. Veja abaixo como fica fácil

identificar os componentes!

Page 8: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 8 -

Em “Show designer hints” habilitamos as informações que surgem quando o

mouse é posicionado sobre um componente. “Show extended control hints” permite

exibir informações mais abrangentes sobre um controle, como tab order, top, left, etc.

Veja estas opções em ação abaixo, onde na primeira figura temos a opção “extended

control hints” ativa e na segunda desabilitada:

Mesmo estando inicialmente vazio, o formulário padrão fornecido pelo Form

Designer já possui todas as funcionalidades básicas de uma janela, como minimização,

maximização, restauração, fechamento e redimensionamento, sem que seja

necessária nenhuma programação.

Uma aplicação tipicamente possui um formulário principal e vários outros

chamados a partir dele, que executam funções diferentes dentro do sistema.

Page 9: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 9 -

Cada formulário criado no Delphi é acompanhado de sua respectiva Unit, que é o

seu código-fonte. Veremos agora a janela responsável pela edição do código-fonte das

Units, o Code Editor.

2.2 O Code Editor

Como foi mencionado anteriormente, o Code Editor (que aparece na próxima

figura) é onde inserimos o código-fonte de nossas aplicações:

Na janela maior, que é o editor propriamente dito, podemos abrir várias Units

ao mesmo tempo, como na figura, para trabalharmos com o código de diversos

formulários simultaneamente. Assim como o Form Designer, o Code Editor também

pode ser personalizado, bastando acessar o menu Tools > Editor Options. Não

mencionaremos todas as configurações possíveis aqui, porque muitas delas já estão

ótimas como estão e devem ser deixadas em paz, e também para não nos

aprofundarmos sem necessidade em assuntos menos importantes. Abaixo, vemos a

Page 10: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 10 -

palheta Color das propriedades do editor, onde configuramos as cores dos elementos

do código-fonte:

nota: o Delphi 7, por default, configura Strings, comentários e números com a mesma cor

– a Navy. Usar cores diferentes, não importam quais, para estes elementos torna o código

mais fácil de ler, destacando cada tipo diferente de elemento. Assim, não se corre o risco

de comentários serem confundidos com strings, strings numéricas se confundirem com

números verdadeiros, etc.

Em “Code Insight” configuramos os recursos que permitem completar código,

exibir parâmetros de funções em forma de hint, etc., bem como o tempo (delay) após o

qual elas aparecem para o programador. Deixe todas habilitadas, pois são uma mão

na roda!

Page 11: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 11 -

Na palheta “Source Options”, não há necessidade de alterar nada. Tudo está

perfeito como está!

Mas nela encontramos o interessantíssimo recurso “Edit Code Templates”. Os

templates nada mais são do que os modelos de comandos, declarações de procedimentos

e funções, declaração de classes, etc., que podem ser incluídas no código. Assim o

programador pode economizar algumas “tecladas”! Podemos facilmente editar ou

adicionar novos templates através da tela que aparece na próxima ilustração:

Page 12: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 12 -

Com o botão “Add” podemos incluir um novo template, dando-lhe um “Shortcut

name” e uma descrição. O shortcut é usado para encontrar o template durante a edição.

Na caixa “Code” nós inserimos o código que irá aparecer ao usarmos o template. A barra

vertical pode ser adicionada ao template para mostrar ao editor onde ele deverá posicionar

o cursor quando o template for inserido no código fonte. Os templates ficam no arquivo:

“C:\Arquivos de programas\Borland\Delphi7\Bin\DELPHI32.DCI”

Podemos os DCI’s que nós criarmos para que sejam usados em “Delphis” alheios ou

importar DCI’s de outros delphis para usar no nosso!

Page 13: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 13 -

2.3 Object Inspector

O Object Inspector é a janela responsável pelo controle das propriedades e

eventos de todos os componentes da aplicação. Ele permite também encontrar

componentes de um formulário facilmente através da lista na parte superior, que exibe

todos os componentes do formulário ordenados alfabeticamente pelos seus nomes. O

Object Inspector pode ser visto na imagem seguinte:

A palheta Properties nos dá acesso a todas as propriedades de visibilidade

published do componente atualmente selecionado para que possamos modificá-las em

tempo de design. A forma de edição de uma propriedade está relacionada ao seu tipo.

Algumas propriedades podem ser alteradas apenas digitando diretamente na linha

correspondente; outras exibem uma lista de valores possíveis, dos quais um deve ser

escolhido; outras podem se expandir – as que tem um ‘+’ antes do nome – e por fim,

existem aquelas que possuem um editor separado – as que possuem uma ‘...’ na linha

de edição.

A palheta Events nos permite criar um corpo vazio de método para

implementarmos o código que será executado ao ocorrer o evento selecionado. Para tanto,

basta darmos um duplo - clique na linha correspondente ao evento ou então um Ctrl +

Enter . Podemos ainda selecionar na lista outros eventos compatíveis com aquele que

Page 14: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 14 -

estamos para criar. Assim, podemos reutilizar outros eventos ao invés de implementar o

mesmo código várias vezes. Um evento é compatível com outros desde que possuam os

mesmos parâmetros – com os mesmos tipos de dados, mesma ordem e mesma

quantidade, ou seja, se suas assinaturas forem as mesmas.

O Object Inspector pode ser customizado pelo usuário no menu Tools >

Environment options > Object Inspector, mostrado abaixo:

À esquerda podemos mudar as cores dos elementos do Object Inspector e à direita

temos algumas opções de exibição. Por default, a única desabilitada é ‘Show read only

properties’, que define se as propriedades somente leitura, que não podem ser

modificadas, apenas lidas, vão aparecer. Não são necessárias maiores explicações sobre

estas configurações.

Estas opções também podem ser acessadas ao clicar com o botão direito no

Object Inspector. Este procedimento permite também acessar outras configurações que

não aparecem no método descrito acima, como o menu ‘Arrange’. Esta opção disponível

desde o Delphi 5 muda a forma de exibição das propriedades e eventos. O default é

Arrange > By Name, o arranjo tradicional. A opção Arrange > By Category, agrupa

propriedades e eventos por categoria, o que pode facilitar a programação em alguns casos,

como ajuste de tamanho e posição de componentes no Form Designer. Normalmente as

propriedades que ajustam o tamanho e posição, ficam distantes quando exibidas por nome,

Page 15: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 15 -

mas se as agruparmos; poderemos visualizar todas em um grupo. Veja o aspecto das

propriedades agrupadas por categoria:

2.4 Object Tree View

O Object Tree View é a janela localizada por default logo acima do Object

Inspector. Ele nos dá uma visão hierárquica dos componentes do formulário, com

visão em árvore. Através dele podemos ver em qual container – Panel, GroupBox,

ScrollBox, o próprio Form, etc., chamados em Delphi de ‘Parents’ dos componentes

dos componentes neles contidos – cada componente está contido, podendo inclusive

transferi-lo de um parent para outro. Para isto, basta arrastá-lo para cima do ícone do

novo parent e ele será mudado para lá sem perder o valor de suas propriedades.

Pode-se inclusive deletar um componente pelo Object Tree View. Outra facilidade

oferecida por ele diz respeito a localização de componentes. Às vezes, de acordo com

nosso layout, alguns componentes podem ficar de difícil acesso pelo Form Designer,

tanto visualmente quanto pelo mouse. O Object Tree View pode nos ajudar a

encontrá-los nestes casos. Veja uma ilustração do Tree View logo abaixo:

Page 16: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 16 -

2.5 A Palheta de Componentes

A palheta de componentes é uma barra de ferramentas onde se encontram

todos os componentes que o desenvolvedor irá utilizar ao programar. Ela está dividida

em várias palhetas onde os componentes são agrupados. Como o Delphi 7 possui

inúmeras palhetas diferentes, elas serão vistas gradualmente na medida em que

trabalhamos, teremos aqui apenas uma visão geral. Abaixo está uma visão da palheta

de componentes do Delphi 7. Na ilustração ela foi destacada da barra de ferramentas

principal apenas para melhorar sua visualização:

Algumas palhetas de componentes importantes são:

• Standard

Nela estão os componentes básicos de uma interface gráfica: Edit, Button,

ComboBox, RadioButton, CheckBox, MainMenu... Sem dúvida é a mais usada.

• Additional

Sob certos aspectos é semelhante à Standard, mas possui componentes de

interface mais incrementados como BitBtn, SpeedButton, MaskEdit e StaticText.

Além disso, é nela que estão componentes de imagem (Image) e de gráficos

(Chart)

• Win32

Nesta palheta podemos encontrar componentes para barra de status, barra de

progresso, barra de ferramentas, calendário, etc. Também temos o PageControl,

Page 17: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 17 -

que nos permite criar um layout de palhetas, como a própria palheta de

componentes.

• System

Seus principais componentes são o Timer, que representa um contador de

tempo e o MediaPlayer, para executar arquivos de som e filmes.

• DataAccess

Possui componentes que comunicam componentes se acesso a banco de dados

com os componentes da DataControls. Com destaque para o DataSource,

ClientDataSet e DataSetProvider.

• DataControls

Semelhantes aos da Standard, porém com a capacidade de editar dados

diretamente nos campos de tabelas do banco de dados.

• Dialogs

Possui componentes que encapsulam os principais diálogos do Windows como o

diálogo de fonte, de salvar arquivo, de abertura de arquivo, de impressora, entre

outros.

• dbExpress, ADO, InterBase, BDE

Estas palhetas contém componentes para conexão e acesso a bancos de dados,

cada um para um tipo de conexão diferente.

2.6 Project Manager e Project Group

Às vezes, pode acontecer de um único sistema ser composto de vários projetos

separados, como aplicações ou pacotes, que representam vários módulos deste

sistema. Assim, surge a necessidade de uma forma de navegação rápida entre os

projetos distintos do sistema.

Mas, como o Delphi abre apenas um projeto de cada vez, como podemos

navegar pelos projetos sem ter que abrir e fechar projetos a todo instante? A resposta

está no Project Group!

O Project Group é um arquivo com extensão “.bpg” onde o Delphi guarda a

informação de todos os projetos separados que fazem parte de um único sistema

maior. E o Project Manager é a janela responsável por criar e gerenciar os Project

Groups, bem como fazer a navegação entre os diversos projetos agrupados nele. Na

figura abaixo, podemos ver como é o Project Manager.

Page 18: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 18 -

Na figura vemos 5 diferentes programas num mesmo Project Group. Cada um

deles é um projeto separado dos demais, mas como eles estão relacionados entre si,

agrupa-los num Project Group torna seu gerenciamento mais fácil.

A raiz da árvore de projetos é o Project Group, o arquivo .bpg. Para criar um

novo projeto nele, basta clicar com o botão direito do mouse e escolher “Add New

Project...” O Delphi abrirá a janela New Itens para que o usuário selecione o tipo de

projeto a adicionar. Mas se desejarmos simplesmente adicionar um projeto já pronto

ao grupo, sem segredo! Basta escolher a opção “Add Existing Project...” e selecioná-lo!

2.7 Salvando um Layout Personalizado

Quando existem vários programadores trabalhando com o mesmo Delphi,

podem surgir divergências quando à disposição e ao tamanho das janelas do

ambiente que cada um gosta de usar.

Gosto não se discute, mas chegar ao trabalho e ver que algum colega bagunçou

todo o seu ambiente é realmente irritante! Para solucionar estes pequenos problemas, o

Delphi permite desde a versão 5 que cada usuário ajeite as janelas como bem entender e

salve o resultado. Assim, cada usuário pode ter o seu layout de volta sempre que desejar!

Para isso, basta utilizarmos a barra de ferramentas abaixo:

Lista de layouts salvos

Salva um layout Ativa layout selecionado

Page 19: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 19 -

Os layouts são salvos na pasta Bin do Delphi, em arquivos com extensão .dst.

Assim, podemos fazer um backup deles para que seu layout favorito não se perca!

2.8 Customizando as Barras de Ferramentas do Delphi

Também é possível personalizar os botões das barras de ferramentas do

Delphi. Basta ir ao menu View > Toolbars > Customize...

Basta arrastar os botões para uma das barras de ferramentas do delphi e ele

será adicionado!

nota: é interessante colocar alguns botões como o de compilar e os de find, replace e find

in files que são bastante usados e ajudam muito!

2.9 Debugando Aplicações

A IDE do Delphi oferece diversas ferramentas para testarmos nossos

programas e procurar erros difíceis de encontrar. Dentre estas inúmeras ferramentas,

veremos apenas as mais frequentemente utilizadas. Assim, estudaremos os Break

points, a Watch List, o Evaluate/Modify e o Inspect.

Page 20: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 20 -

2.9.1 Break Point

Os Break Points são pontos determinados pelo programador onde o programa

irá parar de executar para que se possa analisar o código-fonte em busca de erros.

Durante a pausa na execução, podemos com o cursor do mouse observar valores de

variáveis, de propriedades de objetos, etc. Também é possível continuar executando o

programa passo a passo, com os comandos “Trace Into” e “Step Over”. Abaixo vemos

um Break Point:

Para colocar/retirar um Break Point, basta clicar na margem cinza da esquerda

(onde fica o círculo vermelho) ou então dar um F5 com o cursor na linha

correspondente. Quando o programa for executado, a execução vai parar quando

chegar neste ponto. Para fazer a execução passo a passo, podemos dar um F7 (trace

into) ou F8(step over), que fazem com que apenas a próxima linha seja executada. A

diferença entre os dois é que se numa linha houver chamada para um procedimento

ou função, o F7 entra na sub-rotina, enquanto que o F8 executa a sub-rotina sem

entrar nela.

Agora um caso comum: imagine que temos um trecho de código que executa

uma repetição de 0 a 100. Mas aí ocorre um erro neste trecho! Então recorremos ao

Break Point para descobrir o que há de errado. Então executamos e fazemos um F8;

iteração 1... nada; iteração 2.. nada; 20... nada; 55... nada! Depois de muita luta

descobre-se que o erro ocorre na iteração 100 (a última!), mas não se sabe por que

Page 21: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 21 -

ele ocorre só nessa iteração. Mas como fazer para que o programa só pare na

iteração 100 para inspecionarmos o código e descobrir o erro? Pois o Break Point

possui um editor onde podemos entre outras coisas, definir uma condição de parada!

Para tanto, é só clicar com o botão direito no círculo vermelho e ir ao menu “Break

point properties...” para exibir a tela abaixo:

No campo “Condition” basta informar a condição de parada tipo “Contador =

100” (a condição tem a sintaxe do Delphi mesmo, igual as que se usa nas condições

de comandos como if e while). Aí sim ele só vai parar na 100ª iteração, onde está o

erro!

2.9.2 Whatch List

É uma lista de variáveis ou propriedades cujos valores queremos vigiar

enquanto o programa executa. Todas as mudanças que ocorrerem nas variáveis da

lista são exibidas na Whatch List.

Para adicionar uma variável à Whatch List, Basta clicar com o botão direito nela

e ir ao menu Debug > Add watch at cursor que aparecerá a telinha:

Page 22: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 22 -

Os valores das variáveis em Watch Name aparecerão ao lado na coluna Value.

Quando queremos observar valores de propriedades de objetos, a whatch não

funciona... Isso acontece devido ao fato de que algumas propriedades possuem

métodos de acesso internamente. Para permitir chamadas à funções na Whatch List,

devemos clicar com o botão direito na variável e acessar o menu “Edit watch”:

Marque “Allow Function Calls” e pronto!

2.9.3 Evaluate/Modify

Usado para ver e modificar valores de variáveis e propriedades em tempo de

execução. Pode ser acessado no menu Debug > Evaluate/Modify que aparece ao

clicarmos com o botão direito no Code Editor:

Passamos a ele uma expressão ou variável e em Result obtemos seu valor

naquele momento da execução. Em “New value” podemos atribuir um novo valor para

Page 23: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 23 -

a expressão (desde que seja algo que possa receber valor! Nada de querer atribuir um

novo valor para uma função, por exemplo!). Uma característica interessante do

Evaluate é que ele dá acesso para outros debuggers como os watches e o inspect,

que será visto a seguir.

2.9.4 Inspect

O inspect é uma janelinha bem parecida com o Object Inspector que nos

permite observar todas as propriedades possíveis de um elemento passado para ele.

Se passarmos um componente por exemplo, podemos ver os valores de todas as suas

propriedades, inclusive as posições de memória onde seus métodos estão alocados!

Vejamos um Inspect em ação exibindo os dados de um formulário:

Assim como o Evaluate/Modify, o Inspect permite que os valores sejam

alterados. Se clicar nele com o botão direito, aparece um menu onde podemos

configurar algumas características do Inspector, bem como mudar o valor que se está

inspecionando, fazer typecasts, etc.

nota: Todos os debuggers vistos devem trabalhar em conjunto com os Break Points, pois

não faz muito sentido analisar um trecho de código ou o estado atual de um componente

com o programa em “movimento”. Até por que ele executa em milésimos de segundo!

Page 24: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 24 -

3 Estrutura dos Programas Delphi

3.1 VCL x CLX

VCL é a biblioteca padrão utilizada pelo Delphi para o desenvolvimento na

plataforma Win32, e conta com toda a API, os componentes, etc. Mas a partir do

Delphi 6, surgiu uma nova API, chamada CLX, que permite fazer um intercâmbio de

projetos entre o Delphi e o Kylix. Uma aplicação feita com os componentes da CLX

podem ser portadas de Windows para Linux e vice-versa. Para tanto, basta abrir um

projeto Delphi no Kylix e recompilar, podendo-se fazer o mesmo do sentido inverso.

Para criarmos uma aplicação CLX só precisamos fazer File > New > CLX Application e

pronto! Apenas substituímos o tradicional New Application por New CLX Application!

Mas existem algumas diferenças. Pode-se perceber que a palheta de componentes

muda. Isso porque os componentes da CLX não podem ser os mesmos da VCL, e

eles foram totalmente refeitos. Assim, uma CLX Application possui bem menos

componentes disponíveis que a VCL.

3.2 Projetos

Um projeto Delphi, na verdade, é o programa propriamente dito e sua sintaxe é

idêntica à do Pascal. Este programa apenas cria os formulários, onde efetivamente se

concentram todas as funcionalidades da aplicação (mas existem as aplicações

console, que não usam formulários, e aí sim as funcionalidades devem se concentrar

no programa!). O projeto é armazenado pelo Delphi em um arquivo com extensão .dpr

e para visualizar seu código fonte, basta ir ao menu Project > View Source:

Page 25: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 25 -

Perceba que o nome do programa é o nome do projeto, portanto, observe este

detalhe ao salvar o projeto! Vemos que o objeto global Application é que realiza todo o

trabalho num programa visual, tanto na criação dos formulários quanto na execução em si.

3.3 As Units

As Units são arquivos que representam uma coleção de tipos, classes,

procedimentos, funções, constantes, etc. que podem ser importadas e utilizadas durante o

desenvolvimento. Vamos dar uma olhada na estrutura de uma Unit vazia:

Em “unit” fica o nome do arquivo correspondente à unit, que também será o nome

utilizado ao importá-la. Após isso, vêem as 4 seções nas quais uma Unit pode ser dividida:

• Interface: é a seção pública da Unit. Tudo que for declarado aqui será visível fora

da Unit. Nesta seção ficam declarados todos os “serviços” oferecidos pela Unit, que

depois devem ser implementados na seção implementation.

• Implementation: esta seção é onde implementamos procedimentos, funções e

classes declaradas na seção interface. Esta seção é privada, ou seja, seus

elementos são visíveis apenas dentro da Unit. É possível fazer declarações de

Page 26: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 26 -

classes, sub-rotinas e outros elementos em implementation da mesma forma que

em interface, mas elas se tornam privadas da Unit.

• Initialization: seção usada para inicializar elementos da Unit no momento em que

ela é carregada para ser usada no programa. É possível tanto inicializar variáveis

quanto para instanciar objetos ou abrir arquivos.

• Finalization: seção com função oposta à da initialization, servindo para fazer a

finalização de elementos e liberação de recursos usados por elementos da Unit.

Pode-se, por exemplo, destruir objetos criados ou fechar arquivos abertos em

initialization.

Destas 4 seções, as duas primeiras – interface e implementation – são obrigatórias

e não podem ser omitidas. Já as duas últimas – initialization e finalization – são opcionais.

As Units são armazenadas em arquivos com extensão .pas, tanto na VCL quanto na CLX.

3.4 Formulários

Os formulários criados através do Form designer são serializados pelo Delphi

em arquivos de texto com extensão .dfm (VCL) ou .xfm (CLX), e devido a isso, não

vemos nenhum código de inicialização para instanciar componentes ao criar um

formulário, como acontece em IDE’s Java.

Esses dados serializados são incorporados ao executável em forma binária

durante a compilação e ao executar o programa, os componentes são criados com base

nestas informações serializadas. Isso acaba por deixar o código fonte de um formulário

mais limpo, pois apenas a parte que foi implementada pelo desenvolvedor fica visível na

Unit. Vamos dar uma “espiada” no conteúdo de um dfm de um Form bem simples:

Page 27: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 27 -

Todas as propriedades que foram modificadas no Object Inspector são

armazenadas neste formato. Assim, quando o executável instanciar os componentes, ele

poderá acessar estes valores e configura-los conforme foi definido em tempo de projeto!

Podemos acessar o dfm como foi feito acima clicando com o botão direito no

formulário e selecionando View as Text. Para voltar é só fazer o mesmo no dfm, só que

neste caso é View as Form.

3.5 Pacotes – Packages

Os pacotes são utilizados em Delphi para criar bibliotecas que podem ser usadas

por uma aplicação, como se fossem um tipo especial de dll, onde se pode armazenar

formulários, Units independentes, entre outras coisas. O próprio Delphi se utiliza dessas

Page 28: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 28 -

bibliotecas o tempo todo. Qualquer componente instalado na IDE, por exemplo, deve estar

armazenado num pacote, que é instalado posteriormente no Delphi. Os pacotes, assim

como os programas e os Project Groups, são considerados projetos pelo Delphi e são

salvos com a extensão .dpk. Ao serem compilados, os pacotes geram dois tipos de

arquivos, os dcp e os bpl. Os dcp servem para que um pacote importe outros que ele

precise usar. Já os bpl são as tais bibliotecas tipo dll citadas acima. São eles os arquivos

que podem ser usados por programas Delphi, inclusive o próprio Delphi.

3.6 Arquivos Compilados

Vimos acima os arquivos que o Delphi cria ao salvarmos nosso trabalho.

Porém, ao compilarmos estes arquivos, outros são gerados.

As Units dão origem aos arquivos dcu. São estes arquivos que o Delphi lê

utilizamos elementos de uma Unit importada, tanto que comumente nos deparamos com

erros do tipo “File not found: UnitX.dcu”, o que significa que o Delphi não está encontrando

o arquivo dcu da Unit que queremos usar.

Já os arquivos dfm (ou xfm) junto com os dpr, geram o executável da nossa

aplicação. Existem outros arquivos gerados durante a compilação como res, cfg, ddp, etc.

mas que não são essenciais ao projeto, podendo ser excluídos sem maiores problemas. O

Delphi simplesmente os criará novamente. São arquivos que guardam configurações do

projeto e algumas outras informações.

4 Delphi Language

Veremos agora a sintaxe da linguagem Delphi, seus principais comandos, declarações e

tipos de dados. Alguns podem se perguntar “mas não é Object Pascal???”. Sim, era

mesmo, só que a Borland oficializou o nome da linguagem como Delphi mesmo há pouco

tempo atrás (note inclusive que no help do Delphi 7 aparece “Delphi Language Reference”

no cabeçalho ao invés de “Object Pascal Reference”). Mesmo assim ainda podemos

encontrar muito material, mesmo recente, ainda se referindo a ela como Object Pascal.

Page 29: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 29 -

4.1 Comentários

Existem três tipos de marcadores de comentário em Delphi:

Símbolo de início Símbolo de

término Descrição

{ } Bloco unário de comentário. Tudo entre as chaves é ignorado.

(* *) Bloco binário de comentário. Tudo entre"(*" e" *)" é ignorado.

/ / Comentário de linha. Tudo do marcador de comentário para o fim da linha atual é ignorado.

Você pode usar marcadores fixos de comentário, mas você não pode iniciar um

comentário com um tipo de marcador de comentário e terminar usando outro. Com a

exceção do marcador de comentário de linha '/ /', os comentários no Delphi podem

atravessar linhas múltiplas.

Podemos usar os tipos diferentes de comentários para propósitos diferentes,

como um para colocar observações no código – o comentário propriamente dito – e

outro para desabilitar código fonte ao invés de deletar.

4.2 Declarações

Programas, procedimentos, e funções são todos compostos de declarações. Cada

declaração cria uma linha executável de código.

Declarações podem ser simples ou compostas. Exemplos de declarações simples são

ilustrados por atribuição a variáveis simples, atribuição de função, e chamadas de

procedimento.

X := 10; //atribuindo o valor X := 10

Produto := 'Delphi'; //Atribuindo o conteúdo ‘Delphi’ na variável Produto

Calcula_Soma; {Executando a função Calcula_Soma}

Você também pode ter declarações compostas onde você poderia ter uma declaração

simples. Uma declaração composta é um agrupamento de declarações tratadas como

um bloco.

O começo de uma declaração composta sempre é delimitado pela palavra reservada

BEGIN. O fim de uma declaração compostas é delimitado pela palavra reservada END.

Page 30: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 30 -

Aqui está um exemplo de uma declaração composta:

if X = 10 then

begin

ShowMessage( X é igual a 10' );

X:= 11;

end;

4.3 O Ponto-e-Vírgula e o Ponto

Em Object Pascal você pode criar linhas múltiplas de código livremente quando estiver

criando uma única declaração. O mais difícil de entender é que há algumas situações

onde você não pode usar um ponto-e-vírgula, e outras situações onde seu uso é

exigido obrigatoriamente para garantir o fluxo do programa.

Então aqui está a regra: um ponto-e-vírgula tem que separar todas as declarações em

um programa Pascal. Esta regra se aplica em ambos os casos, de declarações

simples e compostas. A regra ajuda explicar por que nunca há um ponto-e-vírgula

depois um Begin, como também por que o ponto-e-vírgula antes de qualquer palavra

chave é opcional.

Para melhor ilustrar, note no código abaixo que a instrução de atribuição não tem um

ponto-e-vírgula depois dela. Um ponto-e-vírgula não é requerido porque não há uma a

declaração imediatamente. Reciprocamente, a declaração end tem que ter um ponto-

e-vírgula depois dela, porque marca o fim da declaração composta.

if X = 10 then

begin

ShowMessage( X é igual a 10' );

X := 11 //Note que essa linha não possui “;”

end;

Outro ponto de dúvidas comum para novatos é quanto ao uso de End sem que o

Begin apareça. Na maioria dos casos, a paridade do Begin . . End existe. Porém, há

alguns casos em que onde você tem um End sem Begin. A ocorrência mais comum

disto é a instrução Case, mas há outros (por exemplo, em blocos try . . . finally, para

uso dentro de definições de registro, etc.). O melhor modo para ficar confortável com

este tipo de omissão é se lembrar que outra palavra chave ou construtor sempre será

Page 31: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 31 -

achado para estar substituindo a declaração Begin, ou que uma declaração End

sempre será encontrada para ajudar a terminar uma declaração.

Mais uma nota sobre pontuação em programas Object Pascal: o End final do

programa é seguido por ponto e não por um ponto-e-vírgulas. O ponto final indica ao

compilador que é o fim do programa.

4.4 Diretivas de Compilação

São tags colocadas para mudar o comportamento do compilador num certo

trecho do código. Uma diretiva de compilação bem conhecida por todos é a {R$ *.dfm}

que controla a serialização do formulário para o arquivo dfm. Apenas como

curiosidade, dê uma olhada no código de algumas Units padrão do Delphi (dando Ctrl

+ click no nome delas no uses) como SysUtils por exemplo e note que elas estão

infestadas de diretivas de compilação, muitas delas responsáveis por configurar a

compilação de uma parte do código de acordo com o sistema operacional, se Linux ou

Windows.

4.5 Operadores

O operador de atribuição em Delphi é o sinal de dois pontos-igual (":="). É diferente do

sinal igual ("=") que é usado para testar igualdade e para definição de tipos.

Se você estiver vindo C, você terá que se acostumar a usar sinal de igual (‘=’) “normal”

(unário) para testar para igualdade, e o operador de atribuição binário (:=) para fazer

atribuição. Note que não há nenhum sinal de igual binário ("= =") testar para igualdade

em Pascal.

A seguir temos um resumo dos principais operadores presentes em Delphi,

bem como os tipos de operando aos quais eles se aplicam, o tipo de dado resultante

da operação e a categoria a que eles pertencem.

Page 32: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 32 -

Operadores Aritméticos

Operador Operação Tipo operando Resultado Exemplo

+ adição integer, real integer, real X + Y

+ unário sinal positivo integer, real integer, real +X

- subtração integer, real integer, real X – Y

- unário sinal negativo integer, real integer, real -X

* multiplicação integer, real integer, real X * Y

/ divisão real integer, real real X / Y

div divisão inteira integer integer X div Y

mod resto da divisão integer integer X mod Y

Operadores Booleanos

Operador Operação Tipo operando Resultado Exemplo

not negação (não) boolean boolean not X

and conjunção (e) boolean boolean X and Y

or disjunção (ou) boolean boolean X or Y

xor ou exclusivo boolean boolean X xor Y

Operadores Lógicos de Bits (Bitwise)

Operador Operação Tipo

operando Resultado Exemplo

not negação de bits integer integer not X

and and de bits integer integer X and Y

or ou de bits integer integer X or Y

xor xor do bits integer integer X xor Y

shl deslocamento de bits à esquerda

(shift left) integer integer X shl 2

shr deslocamento de bits à direita

(shift right) integer integer X shr Y

Operadores de String

Operador Operação Tipo operando Resultado Exemplo

+ concatenação string string ‘Delphi’ + ‘7’

Page 33: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 33 -

Operadores de Conjunto (Set)

Operador Operação Tipo operando Resultado Exemplo

+ união set set X + Y

- diferença set set X – Y

* interseção set set X * Y

in pertinência set, ordinal boolean X in Y

Operadores de Classe

Operador Operação Tipo operando Resultado Exemplo

as typecast objeto,

classe/interface

objeto tratado

como sendo

instância da

classe/interface

Sender as

TButton

is

objeto é

instância de

classe

objeto,

classe/interface boolean Sender is TEdit

Operadores Relacionais (Comparação)

Operador Operação Resultado Exemplo

= igualdade boolean X = Y

<> diferença boolean X <> Y

< menor que boolean X < Y

> maior que boolean X > Y

<= menor ou igual boolean X <= Y

>= maior ou igual boolean X >= Y

Vejamos agora os operadores com relação à precedência:

• Primeiro nível (mais alta): not

• Segundo Nível: *, /, div, mod, and, shl, shr, as

• Terceiro Nível: +, -, or, xor

• Quarto Nível (mais baixa): <>, =, <, >, <=, >=, in, is

Page 34: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 34 -

Além destes, existe ainda o operador de atribuição := , também de baixa

precedência, responsável por atribuir o valor de uma expressão ou variável em

outra variável.

4.6 Principais Tipos de Dados

Os tipos de dados presentes no Delphi são basicamente os mesmos do Pascal

tradicional, porém com o acréscimo dos tipos de dados classe e interface, para o

suporte à programação orientada a objetos. Os tipos de dados podem ser simples ou

estruturados, além de String e outros como Variant e os tipos procedurais, usados na

implementação de eventos. Os tipos de dados novos criado pelo programador devem

estar dentro de uma seção type na Unit.

nota: por convenção, todo nome de tipos de dados criados pelo usuário, como os que

vamos fazer mais a frente, deve começar com “T” de type

4.6.1 Tipos de Dados Simples

Os principais tipos de dados simples são Integer (números inteiros), Real (ponto

flutuante), Char (um caracter), Boolean (true ou false), as enumerações e as sub-ranges.

4.6.1.1 Enumerações Como Integer, Real, Char e Boolean são bem simples, vamos nos deter aos dois

últimos. As enumerações são tipos de dados compostos por uma lista de valores

constantes, sendo que uma variável deste tipo pode assumir apenas um destes valores

por vez. Exemplo:

Page 35: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 35 -

Aqui, declaramos o tipo TMoeda na seção type de uma Unit e em seguida uma

variável deste tipo na seção var, chamada Moeda. Depois, a inicializamos com o valor

mdDolar na seção opcional initialization da Unit. A variável Moeda só pode assumir um dos

4 valores definidos para o tipo TMoeda. As enumerações são amplamente utilizadas no

Delphi e podemos ver várias propriedades deste estilo, como por exemplo, a propriedade

Align, presente em vários componentes visuais como o formulário.

Page 36: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 36 -

4.6.1.2 Sub-range Os tipos sub-range são criados simplesmente restringindo o conjunto de valores de

um tipo qualquer. Vamos ver um exemplo:

Neste caso, criamos o tipo TPorcentagem pela restrição de valores do tipo Integer

(que possui um intervalo de -2147483648 à 2147483647). Assim, uma variável do tipo

TPorcentagem só pode receber um valor que esteja entre 0 e 100.

A criação de um sub-range não se restringe aos números. Pode-se fazer a mesma

coisa com caracteres e até mesmo com enumerações.

4.6.1.3 String Versões mais velhas de Pascal implementaram strings como arrays de 8-bits de

caractere. Porém, há vários problemas com o tipo string original do Pascal. Primeiro, é

limitado a só 255 caracteres. Segundo, não termina com um 0 binário (caractere nulo).

Considerando que a string terminada em nulo é muito utilizada em Windows, UNIX, e

outros sistemas operacionais escritos principalmente em C e linguagem assembly, o

programador é forçado a converter strings de Object Pascal para strings terminadas

em nulo.

Por causa destas e outras limitações, o Delphi 2.0 introduziu um tipo novo de string.

Este tipo novo substitui os strings mais velhos. Assim, como char , há dois tipos de

Page 37: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 37 -

string em Object Pascal: short strings e long strings . O short string é o tipo

tradicional do Object . O long strings é alocado dinamicamente e administrado

automaticamente para você; pode ter o tamanho que a memória disponível permita, e

sempre é terminado em nulo.

Cada tipo de string (longo e curto) inclui um contador de referência escondido que o

Delphi mantém. Quando o contador de referência para da string for igual a zero, a

memória é limpa automaticamente.

Strings , como caracteres, também são delimitados por aspas simples. Se você

precisar colocar uma aspas simples dentro de uma string , coloque duas aspas

simples lado a lado, assim a linguagem Object Pascal os interpretará como uma única.

Você pode usar os operadores relacionais padrão já discutidos para comparar strings ,

Object Pascal tem uma grande variedade de procedimentos de manipulação de

strings embutidos. Você também pode tratar strings como se elas fossem array de

caracteres.

Por exemplo, obter os 2º e 3º caractere de uma string e os colocar em chars :

var

s : string;

ch1, ch2 : char;

begin

s := 'Hello';

ch1 := s[1];

ch2 := s[2];

ShowMessage( 'Caracteres 1 e 2 são ' + ch1 + ' ' + ch2 );

end;

Quanto ao tipo String, ele é tratado pelo Delphi como uma cadeia de caracteres e

pode-se acessar seus elementos como se ele fosse um array, que se inicia na posição 1 e

vai até a posição n, além de também podermos declarar uma variável String com um

número limitado de caracteres. O exemplo a seguir ilustra este tratamento dado às Strings:

Page 38: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 38 -

nota: o Delphi fornece várias funções para trabalhar com strings, dentre elas podemos

destacar:

Delete (string qualquer, índice inicial, nº. de caracteres) – exclui uma parte de uma string,

sendo que a parte começa em ‘índice inicial’ e tem o tamanho passado em ‘nº. de

caracteres’.

Copy (string qualquer, índice inicial, nº. de caracteres) – função que retorna uma cópia de

parte de uma string passada como argumento. O significado dos argumentos é o mesmo

de Delete.

Insert (substring, string destino, inicio) – insere a ‘substring’ do 1º argumento dentro da

‘string destino’ começando na posição dada em ‘início’.

Page 39: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 39 -

Pos (substring, string) – se a ‘substring’ está contida dentro da ‘string’, esta função retorna

o índice de onde a ‘substring’ começa. Agora, se não existir a ‘substring’ dentro da ‘string’,

ela retorna zero.

4.6.2 Tipos Estruturados

Vejamos agora os principais tipos estruturados suportados pelo Delphi. Um tipo

estruturado é aquele que pode conter mais de um valor, além de poder ser construído

utilizando-se outros tipos estruturados, formando níveis de estrutura ilimitados.

Os principais tipos estruturados são sets, arrays, records, files assim como classes,

interfaces e referências de classes.

4.6.2.1 Sets Os sets são tipos que representam um conjunto de valores, assim como os

conjuntos que aprendemos na matemática, podendo-se realizar operações como união,

intersecção e pertinência sobre eles (veja na tabelinha de operadores e operações de

conjuntos). Porém, os sets têm uma limitação em relação aos outros tipos estruturados;

eles só suportam a criação de conjuntos de tipos ordinais. Mas o que é um tipo ordinal? É

um tipo de dados cujos valores possuem uma ordem. Integer é um tipo ordinal (-2, -1, 0, 1,

2,...), Boolean (False, True), Char também (‘a’, ‘b’, ‘c’,...) por que são usados os códigos

ASCII dos caracteres e as enumerações, cujos valores são tratados internamente como

números inteiros (o compilador do Delphi não entende o ‘mdDolar’ que fizemos acima

diretamente como foi declarado, mas como um número) Bem, vamos ver um set em ação:

Page 40: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 40 -

Podemos ver um set (TMoedas) construído a partir de uma enumeração (TMoeda).

Com ele podemos fazer conjuntos de valores de TMoeda. Este tipo de construção é

amplamente usado no Delphi em propriedades de componentes. Dê uma olhada na

propriedade Font de algum componente e procure por Font.Style. Pois bem, esta

propriedade é do tipo TFontStyles que por sua vez é um set de uma enumeração, o

TFontStyle, exatamente como fizemos com as moedas.

4.6.2.2 Arrays Vamos aos arrays, também conhecidos por aí como vetores. Arrays são listas de

elementos do mesmo tipo de dados, em que cada elemento possui um índice onde é

armazenado. Em Delphi, os arrays podem ser estáticos ou dinâmicos.

Os arrays estáticos são aqueles que possuem nº. fixo de elementos, definido

durante a declaração, que não pode mudar em tempo de execução. Diferentemente de

outras linguagens, o Delphi permite que os índices de um array estático comecem a partir

de qualquer número inteiro, mesmo negativos. Vejamos a declaração de arrays estáticos:

Page 41: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 41 -

Neste exemplo podemos ver a flexibilidade na criação dos índices para um array,

bem como as formas para ler e escrever nos índices.

Só até aí vimos vetores, ou seja, arrays unidimensionais. Vamos ver agora como

criar matrizes, os arrays multidimensionais:

Page 42: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 42 -

Podemos notar duas formas de trabalhar com matrizes, a forma “array de array” e

a forma “direta”, que trata a matriz diretamente como matriz. Podemos usar estas duas

formas tanto na declaração como também durante a leitura e escrita de elementos.

Agora os arrays dinâmicos. Estes são os que podem esticar ou encolher durante a

execução do programa. Outra diferença entre eles e os estáticos, além do dinamismo é

claro, é que arrays dinâmicos SEMPRE começam no índice zero (o que implica que não

podemos fazer aquela brincadeira do “array negativo” com eles!) e devem ser declarados

sem índices.

Para trabalharmos com arrays dinâmicos, podemos utilizar algumas rotinas do

Delphi que permitem realizar a mudança de tamanho e a obtenção do tamanho e do maior

e menor índices. Vamos a elas:

• SetLength(array, novo tamanho): Esse é o procedimento que faz o array dinâmico

(passado ao parâmetro array) mudar de tamanho (definido no parâmetro novo

tamanho).

• Length(array): esta função retorna o tamanho (número de elementos) de do array

passado à ela. Esta função também funciona com Strings!

Page 43: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 43 -

• Low(array): Retorna o menor índice do array. Só que nos arrays dinâmicos é

desnecessária já que eles sempre começam do zero.

• High(array): Retorna o maior índice do array.

Ao utilizar estas rotinas em conjunto, podemos manipular perfeitamente os arrays

dinâmicos, cabendo aqui uma observação importante: um array dinâmico recém-declarado,

vazio, tem os seguintes valores para as funções acima: Lenght = 0, Low = 0, High = -1 (o

maior índice é menor que o menor índice!). este conhecimento é útil para fazer alguns

testes como array vazio por exemplo. Eis um código para ilustrar:

Neste exemplo, temos um procedure que adiciona um elemento ao array dinâmico

no índice passado como argumento. Se o índice for menor que zero, disparamos uma

exceção do tipo EListError com uma mensagem. Se o índice for maior ou igual ao

comprimento (length) do array, devemos fazê-lo crescer até o tamanho índice + 1 para

poder gravar o elemento no índice desejado. Imagine que o array esteja com 3 elementos

(length = 3) e com índices variando entre 0 e 2. Aí mando adicionar um elemento no índice

10. Para isso, preciso esticar o array até o tamanho 11, para que seus índices variem de 0

a 10. Dessa forma posso inserir o elemento no índice 10 como foi pedido!

Page 44: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 44 -

E se quisermos uma matriz dinâmica? Sem problemas! O processo é bem parecido

com as matrizes estáticas. Veja só:

Neste caso, só podemos declarar no estilo “array de array”, já que pra fazer a

declaração de matriz “direta” precisaríamos de índices. Para inicializá-las com SetLength,

temos duas alternativas: na primeira, a mais fácil, acrescentamos mais parâmetros à

SetLength de acordo com o nº. de dimensões. A outra, mais complexa, consiste em criar

1º as linhas, sem as colunas, para depois criar as colunas de cada linha, uma por uma.

Esta abordagem, embora trabalhosa, tem suas vantagens, pois ganhamos a flexibilidade

de criar uma matriz em que cada linha tem um nº. diferente de colunas, o que não é

possível da primeira forma.

Page 45: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 45 -

4.6.2.3 Records (registros) Os records são estruturas capazes de guardar elementos de tipos diferentes, onde

cada elemento é chamado de campo. Vamos ao exemplo:

Criamos um record com 3 campos, cada um de um tipo diferente e 3 variáveis

cujos tipos correspondem a cada tipo do record. Depois gravamos alguns dados no

registro e a seguir os lemos e atribuímos às variáveis. Os campos de um record são

acessados pelo operador “.”.

4.6.2.4 Files Os files ou arquivos são seqüências de dados de mesmo tipo que podem ser

persistidos em disco – como arquivos! Existem diversas rotinas no Delphi para

manipular arquivos, das quais veremos algumas a seguir:

Page 46: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 46 -

• AssignFile(arquivo, nome do arquivo): Associa uma variável file a um nome de

arquivo físico. Aos aplicar AssignFile, podemos usar a variável para manipular o

arquivo físico associado à ela.

• Rewrite: Abre um arquivo, porém limpando todo o conteúdo anterior, se houver.

• Reset: Abre um arquivo e posiciona no início, sem apagar conteúdo anterior.

• FileExists(nome do arquivo): Retorna verdadeiro se o arquivo cujo nome foi

passado como argumento existe.

• Write(arquivo, valores): Escreve no arquivo referenciado por uma variável file os

valores passados na lista de valores. Os valores devem ser do tipo de dado que o

arquivo armazena.

• Writeln(arquivo, valores): Faz o mesmo que o write, só que solta uma linha para

cada valor.

• Read(arquivo, valores): Lê dados do arquivo referenciado pela variável do tipo file

passada ao parâmetro arquivo e atribui os valores lidos às variáveis passadas na

lista de valores. Estas variáveis devem ser compatíveis com o tipo de dado que o

arquivo armazena.

• Readln(arquivo, valores): O mesmo que read, só que após ler um valor, pula para a

próxima linha do arquivo.

• ExtractFileName(caminho): Retorna o nome do arquivo a partir de seu path.

• ExtractFilePath(nome arquivo): Obtém o path do arquivo cujo nome foi passado

como argumento.

• ExtractFileExt(nome arquivo): Retorna a extensão de um arquivo.

• ExtractFileDrive(nome arquivo): Retorna o drive onde se localiza um arquivo.

• ExtractFileDir(nome arquivo): Retorna o diretório do arquivo passado como

argumento.

4.6.3 Tipos Procedurais

Tipos procedurais são tipos de dados usados para criar referências para

procedimentos e funções além de métodos de classes, desde que eles tenham a

mesma assinatura (nº., tipos e ordem dos parâmetros, valor de retorno...) daquela

declarada no tipo.

Através deste tipo de dados, podemos tratar sub-rotinas como valores comuns,

podendo atribuí-las a variáveis, passa-las como argumento para outras sub-rotinas, além

de servirem de base para toda a arquitetura de tratamento de eventos em Delphi.

Os tipos procedurais podem ser divididos em dois grandes grupos: os de referência

para sub-rotinas comuns, pertencentes diretamente à uma Unit e os de referência para

Page 47: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 47 -

métodos de classe. A diferença entre eles é que as referências de método são

implementadas com duas referências, uma para o método em si e outra para o objeto

dono do método. Exemplinhos:

Declaramos um tipo TFuncaoRealX, cuja assinatura é de uma função que retorna

um valor Real e que possui um único parâmetro também real. Isso quer dizer que as

variáveis deste tipo podem referenciar qualquer função que tenha essa mesma assinatura,

como a função Quadrado do exemplo. Aí, atribuímos a função Quadrado à variável

FuncaoRealX para depois a executarmos através da referência, atribuindo seu valor à

variável Q.

Vamos ver agora um caso onde usaremos uma referência de métodos. o

funcionamento é o mesmo, a diferença é que precisamos adicionar a diretiva “of object” à

declaração:

Page 48: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 48 -

Declaramos o tipo procedural com a mesma assinatura de antes, porém com a

diretiva “of object” para indicar que ele é uma referência para métodos de classe. Em

seguida, ainda na seção type da Unit, declaramos uma classe, a TPotencia2, que herda de

TObject. A função quadrado agora se tornou um método da classe TPotencia2 ao invés de

pertencer diretamente à Unit como antes.

Na seção var, adicionamos uma referência para um objeto potencia2, chamada P2

e na seção implementation, temos a implementação do método TPotencia2.Quadrado,

declarado dentro da classe TPotencia2 na seção interface.

Na seção initialization, instanciamos o objeto P2 e a partir daí o processo é igual ao

de antes, com a diferença de estarmos executando um método pertencente a um objeto!

Page 49: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 49 -

Como foi dito anteriormente, o Delphi se utiliza exatamente deste esquema para

implementar o tratamento de eventos. Eventos em Delphi nada mais são que referências a

tipos procedurais, sendo que o mais famoso de todos é o TNotifyEvent, cuja assinatura é:

procedure(Sender: TObject) of object

Familiar? Acredito que sim, pois esta é a assinatura da maioria dos eventos do

Delphi, que recebem apenas o objeto que realizou a ação como argumento.

vamos a um exemplo bem simples. Imagine que estamos no Form Designer e que

nossa tela tem apenas um botão (TButton). Quando vamos ao Object Inspector e clicamos

2 vezes no evento OnClick, o Delphi cria um procedure com a assinatura do TNotifyEvent

e o chama de TForm1.Button1Click . Isso quer dizer que este procedure é um método da

classe TForm1 que estamos programando, ou seja, ele pertence ao formulário e não ao

botão como muitos pensam. Mas como o Button1 sabe que aquele método do formulário é

o seu OnClick para executa-lo? Aí entra a magia dos tipos procedurais! Aquele OnClick em

que a gente clica para criar o evento na verdade é uma propriedade, assim como Caption,

Font, etc., do tipo TNotifyEvent. Assim, ela pode apontar para qualquer método que tenha

a estrutura do TNotifyEvent, assim como o nosso Button1Click!

Ao clicar 2 vezes no Object Inspector, automaticamente a referência OnClick do

Button1 é configurada para apontar para o método Button1Click do Form1 que o Delphi

criou. Assim, quando o programa roda, o botão executa o método indiretamente através da

referência ao ser clicado, exatamente como fizemos com a função Quadrado!

4.6.4 Variants

A classe Variant é modelada depois do tipo Variant intrínseco em versões prévias de

Delphi e Borland C++. Objetos variants são essencialmente variáveis sem tipo, isto

significa que eles podem assumir tipos diferentes automaticamente. O tipo variant

permite a uma variável mudar seu tipo dinamicamente (em tempo de execução). Por

exemplo, no pedaço seguinte de código, o x é variant reconhecido primeiro como um

Integer , e depois como uma string :

Page 50: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 50 -

procedure TForm1.Button1Click(Sender: TObject);

var

x : variant ;

Text : string;

begin

x := 13;

Text := IntToStr( x + 12 );

x := 'Olá';

MessageDlg(x, mtConfirmation, mbYesNoCancel,0);

end;

Uma variável de tipo variant pode conter boolean , date/time , Integer , objetos OLE

Automation , real , e valores de string . Também podem armazenar arrays com

elementos destes tipos, inclusive arrays de variants .

Há dois valores especiais que podem ser usados como valores de variants : Null e

Unassigned . Se o valor do variant for null , a variável não tem dado ou eles foram

perdidos. O valor unassigned informa que a variável não recebeu nenhum valor.

Objetos variantes são muito convenientes, mas muito ineficientes em termos de

armazenamento e velocidade de avaliação em tempo de execução. Os objetos variant

foram projetados para receber referências de servidores de OLE Automation servidor,

o que vale dizer que sua utilização limita-se ao tempo de execução do programa.

Durante a execução a variável de tipo variant é usada para receber ou configurar

propriedades do objeto OLE Automation , ou executar os métodos deste objeto.

4.6.5 Classes

As classes são estruturas que servem de modelo abstrato para a que

possamos criar objetos, ou instâncias concretas a partir dela. O Delphi trata suas

classes com um tipo de dados estruturado qualquer, tanto que elas também devem ser

declaradas na seção type das Units.

Uma classe Delphi é composta basicamente de campos (fields), métodos e

propriedades, cujo acesso pode ser restringido como private, protected, public ou ainda

published. Vamos ver e discutir a estrutura típica de uma classe:

Page 51: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 51 -

Declaramos a classe TClasse1 na seção type da Unit. a parte “class(TObject)” é

onde dizemos qual é a superclasse de nossa nova classe, ou seja, de quem ela herda (ou

como dizem em Java, quem ela estende), bem como as interfaces que ela implementa, se

houverem. Nossa classe de exemplo herda de TObject, que é a classe raiz de toda a

hierarquia de classes em Delphi. Esta parte dos parênteses não é obrigatória. Se for

omitida, o Delphi assume que estamos herdando de TObject.

Podemos ver também os quatro níveis de acesso que uma classe pode possuir:

• Private: Apenas os membros da própria classe podem acessá-los.

• Protected: Apenas os membros da própria classe e os das classes filhas podem

acessá-los.

• Public: Qualquer um pode acessar.

• Published: Mesmo nível de acesso do public, porém com um diferencial. Membros

published podem ser manipulados em tempo de projeto. Todas as propriedades de

componentes que aparecem no Object Inspector são published, e é por isso que

elas aparecem lá e podem ser alteradas durante o projeto. Mas os membros

published vistos no Object Inspector são privilégio de descendentes da classe

TComponent, ou seja, só os componentes podem ser editados no Object Inspector.

Page 52: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 52 -

Isso acontece porque um TComponent pode ser instalado na IDE do Delphi,

enquanto que objetos de classes anteriores não. Assim, em nossa classe de

exemplo, a seção published não tem nenhum efeito, sendo equivalente à public.

nota: esse esquema de controle de acesso só é válido para membros de Units diferentes.

Se duas classes estão na mesma Unit, elas têm acesso a todos os membros uma da outra

e passam a ser “friend classes”. Mas isso não é ruim? Depende. Às vezes podemos querer

que várias classes e sub-rotinas trabalhem em conjunto para alcançar seus objetivos.

Assim, pode ser indispensável que elas possam ter acesso total aos dados das outras.

Mas se você não quer que isso ocorra, basta criar uma única classe por Unit.

Vejamos agora quais são os membros de uma classe:

• Campos: São basicamente variáveis comuns pertencentes à classe onde cada

objeto instanciado contém uma cópia de cada campo. Por convenção, todo campo

deve ter seu nome iniciado com a letra “F” (significando field). representam os

dados que o objeto deve armazenar. Na classe do exemplo temos FCampo1 e

FCampo2.

• Métodos: São procedures e functions pertencentes à classe. Eles representam as

operações que o objeto é capaz de realizar, ou seja, seus serviços. No exemplo são

representados pela função Metodo1 e pelo procedimento Metodo2. Podem existir

também métodos que existem especialmente para fazer validações nos dados que

são atribuídos a um campo antes que eles sejam efetivamente atribuídos ou ainda

modificar o dado lido do campo antes de chegar ao cliente do objeto. São eles a

função GetCampo2 (tratamento de leitura) e o procedimento SetCampo2

(tratamento de escrita). Pra quem está familiarizado com Java, isso se parece com

os famosos métodos de acesso set e get da linguagem da Sun. Mas não se devem

usar métodos de acesso em Delphi como se usa em Java. Em Delphi eles são

usados apenas para tratamento, enquanto que em Java eles também fornecem

acesso a campos, implementando o encapsulamento dos mesmos. Para fornecer

acesso e implementar o encapsulamento em Delphi, use propriedades.

• Propriedades: São estruturas responsáveis por fornecer acesso a campos do

objeto e pelo encapsulamento dos mesmos, podendo ocultar inclusive, os métodos

de validação dos campos! Como exemplos de propriedades temos a Propriedade1

e Propriedade2, sendo que a Propriedade1 acessa diretamente os dados do

FCampo1, enquanto que Propriedade2 acessa os dados do FCampo2 através dos

métodos de validação GetCampo2 e SetCampo2. As propriedades possuem as

Page 53: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 53 -

partes read e write, que dizem a ela o que deve ser lido e o que deve ser escrito no

membro que ela encapsula. Mas podem existir propriedades somente de leitura

(read-only) e somente de escrita (write-only), bastando omitir uma destas partes.

• Construtores: São tipos especiais de métodos responsáveis pela criação dos

objetos da classe e pela inicialização dos seus campos. Por convenção,

construtores Delphi são sempre chamados de Create ou algo como

“CreateAlgumaCoisa” ou então “CreateFazendoAlgumaCoisa”... mas sempre tendo

o Create como base. Quando criamos uma classe, os construtores da superclasse

são herdados, mas podem ser escondidos se declararmos outro construtor no

mesmo nível de acesso, mesmo que tenha assinatura diferente do original.

• Destruidores: São métodos responsáveis pela liberação dos recursos alocados por

um objeto durante sua existência. Como não existe um garbage collector no Delphi

7, todo objeto instanciado deve ser manualmente liberado pelo destruidor. por

convenção, os destruidores são chamados de Destroy ou algo que tenha Destroy

como base. Também existe um destruidor herdado definido na classe TObject, que

pode ser sobrescrito, usando a diretiva override. Atenção agora: o Create deve ser

ocultado, mas o Destroy deve ser sobrescrito com override. Isso porque Destroy é

um método virtual, enquanto que Create é estático.

4.6.6 Referências de Classe (metaclasses)

Como o nome já diz, são referências para uma classe, e são usadas quando

queremos invocar métodos de classe ou construtores virtuais de um objeto cuja classe

pode não ser conhecida em tempo de compilação. O maior exemplo disso é o método

Application.CreateForm do objeto global Application. Ele recebe como argumentos

uma referência para uma classe de formulário e a referência que vai receber a nova

instância de formulário. Este primeiro parâmetro é do tipo TFormClass que é uma

referência para a classe TForm, a classe raiz de todos os formulários. Assim, ao criar

um novo formulário, o objeto Application não precisa saber o tipo exato do formulário,

porque ele será fornecido através da referência TFormClass, através da qual ele será

criado. Vamos ilustrar mostrando o dpr de uma nova aplicação:

Page 54: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 54 -

Na Unit1 temos a declaração da classe TForm1, que herda de TForm e a variável

Form1 do tipo TForm1. No programa principal podemos ver o método

Application.CreateForm em ação. Ele é capaz de criar qualquer tipo de formulário graças

ao TFormClass. Veja que passamos a própria classe TForm1 como argumento, assim

como podemos passar qualquer classe descendente de TForm! Ao criar o objeto TForm1,

a referência será guardada na variável Form1 passada no 2º argumento.

A declaração de uma metaclasse é da forma TClasse = class of type, onde type é a

classe cujo tipo queremos referenciar. no caso do TFormClass temos: TFormClass = class

of TForm.

4.6.7 Interfaces

Interfaces são como uma espécie de classe abstrata que fornece apenas

declarações de métodos para serem implementados por uma classe. Aí dizemos que a

classe implementa a interface e é obrigada a implementar todos os métodos que ela

fornece.

No Delphi, a interface raiz é a “IInterface” (foi convencionado que todo nome de

interface deve começar com “I”), que possui 3 métodos: QueryInterface, _AddRef e

_Release. Assim, toda interface criada deve ser derivada de IInterface e assim terão estes

3 métodos. mas então, se eu criar uma interface personalizada e implementa-la numa

classe, vou precisar implementar estes métodos esquisitos? Não necessariamente!

Acontece que estes métodos já estão implementados numa classe chamada

TInterfacedObject. Assim, basta herdar sua classe de TInterfacedObject e implementar

apenas a interface personalizada, sem se preocupar com os 3 métodos esquisitos (afinal,

Page 55: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 55 -

herdaremos a implementação padrão). Mas afinal, o que estes métodos fazem? Eles têm a

ver com o controle do tempo de vida de objetos referenciados por variáveis de interface.

Estes objetos não precisam ser destruídos como os objetos comuns, pois são controlados

por contagem de referências. E quem controla isso são as implementações destes

métodos na TInterfacedObject.

Existem algumas restrições nas interfaces em relação às classes:

• Interfaces não podem ter campos, apenas métodos e propriedades.

• Já que não há campos, os parâmetros para as diretivas read e write das propriedades

só podem ser métodos.

• Interfaces não podem ter construtores nem destruidores. Afinal, não devem ser

instanciadas.

• Métodos de interfaces não podem ter diretivas como virtual, dynamic, override e

abstract. Como não podem implementar seus próprios métodos, estas diretivas não

fazem sentido nas interfaces (também deixamos estas diretivas mais pra frente).

• Não podem haver seções private, public, etc. numa interface.

Em Delphi, as interfaces podem opcionalmente possuir um identificador global, chamado

GUID, representado por uma string da forma: ['{xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}'],

onde cada x é um nº. hexadecimal, localizado imediatamente antes da declaração dos

membros.

Mas pra que serve tudo isso?

Pra poder usar o typecast as entre um objeto e uma interface. Lembra do método

QueryInterface, que toda interface tem? Pois bem, ao fazer o teste “as” entre um

objeto e uma interface, o GUID da interface é passado ao método QueryInterface do

objeto (desde que o objeto implemente alguma interface) e ele vai dizer se o objeto

implementa a interface em questão. Caso implemente, o typecast é realizado; caso

contrário, ocorre uma exceção.

Se você se assustou com o tamanho do GUID, ou ficou pensando em como fazer

para saber se ele é único ou não, fique tranqüilo! O Delphi gera os GUIDs pra você! Basta

dar um Ctrl + Shift + G dentro da declaração da interface e pronto! E lá vem o exemplo:

Page 56: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 56 -

Primeiro criamos a interface “ITeste” que herda diretamente de Iinterface, a

interface raiz do Delphi. Ele possui um método “Metodo” e uma propriedade “Valor”, que

possui seus dois “métodos de acesso” SetValor e GetValor, que são necessários pois as

interfaces não podem ter campos, apenas métodos e propriedades que acessam métodos.

O nº. “esquisito” logo abaixo da declaração é o GUID, que identifica a interface de forma

única no ambiente Delphi e foi gerado automaticamente com o comando Ctrl + Shift + G.

Assim, podemos realizar typecasts com referências desta interface.

Abaixo, criamos uma classe chamada TTeste que implementa a interface ITeste.

Repare que herdamos TTeste de TinterfacedObject, ao invés de TObject para podermos

herdar a implementação padrão daqueles 3 métodos que vêem de Iinterface. Logo após

informarmos que a superclasse será TInterfacedObject, informamos que TTeste

implementa ITeste separando por vírgula. O esquema é sempre este: primeiro a

superclasse e depois a lista das interfaces implementadas, tudo separado por vírgulas

Page 57: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 57 -

(lembrando que não há herança múltipla no Delphi! Coloque apenas uma classe e depois

quantas interfaces quiser!). Dentro da classe, implementamos os métodos fornecidos pela

interface, escolhendo a visibilidade que bem entendermos para eles.

4.7 Comandos da Delphi Language

Depois de vermos operadores e tipos de dados, nada como estudar os

comandos e estruturas de controle do Delphi! Então vamos!

4.7.1 Comando de Decisão

Objecto Pascal suporta várias estruturas de decisão, cada uma com um uso particular.

4.7.1.1 O Comando IF..the..else

if. ..then. ..else

O formato básico da declaração if. ..then. ..else é mostrada abaixo:

if <expressão lógica> then

<declaração>;

Esta sintaxe básica pode ser estendida adicionando-se a clausula else:

if < expressão lógica > then

< declaração >

else

< declaração >;

Note que em ambos os exemplos anteriores, < declaração > pode ser uma declaração

simples ou composta. Também nota que o inteiro o bloco inteiro if . . . then é

considerado uma única declaração, assim o único ponto-e-vírgula pertence ao término

da declaração (ou depois de < declaração > no primeiro caso depois do segundo <

declaração > no segundo caso).

Page 58: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 58 -

Outra variação desta declaração é a possibilidade de um if adicional após o else :

if < expressão lógica > then

< declaração >

else if < expressão lógica > then

< declaração >

else

< declaração >;

Você pode aninhar quantas declarações If você queira, mas na maioria dos casos

onde você tem muitas condições para conferir, construir um Case é melhor escolha.

Aqui está a sintaxe de uma declaração if . . . then que usa declarações compostas:

if < expressão lógica > then

begin

< declaração >;

< declaração >;

< declaração >

end

else

begin

< declaração >;

< declaração >;

< declaração >

end;

Não há ponto-e-vírgula após o end que aparece antes da cláusula else .

Page 59: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 59 -

4.7.1.2 O Problema do “Else Oscilante”

Muitas das linguagens de programação dos anos 70 (inclusive Pascal) sofrem do

problema do “Else oscilante ”. Aqui está um exemplo:

if x < 5 then

if y > 4 then

z := 0

else

z := 1;

Para que if o else pertence? A identação parece sugerir que pertence ao primeiro if ,

mas na verdade pertence ao segundo. Neste exemplo, se x é maior ou igual a 5, a

parte do else nunca será executada. O else pertence ao if interno , e só executará se

x for menor que 5 e y é menor ou igual a 4.

Embora o Pascal não tenha nenhum operador de fim explícito "end if ", o ponto-e-

vírgula serve para este propósito. Note porém que sempre é ilegal colocar um ponto-e-

vírgula em frente a uma cláusula else , porque a cláusula if/then/else é uma única

declaração. Porque a cláusula if/then/else é uma única declaração, a regra é esta na

Linguagem Object Pascal, o else pertence ao if mais interno.

Dada esta regra, como você pudesse associar o else oscilante do último exemplo,

com o primeiro if? Com este conhecimento, nós podemos resolver o problema prévio

passando de uma declaração simples para uma declaração composta.

Aqui temos um exemplo:

if x < 5 then

begin

if y > 4 then

z := 0

end

else

z := 1;

Agora criando uma declaração composta, o end da declaração de inicial servirá como

o terminador para o if interno. A outro parte da declaração executará agora se x for

maior ou iguala a 5.

Page 60: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 60 -

4.7.2 Case < X > of

O if . . . then . . . else mostrado anteriormente trabalha bem para um número pequeno

de opções, mas fica incômodo se você tiver muitas comparações. Nesta situação, a

construção do Case é mais fácil de se escrever. A sintaxe geral para a instrução Case

é mostrada abaixo:

case <variável> of

<variável(is)> : <declaração>;

< variável(is)> : < declaração >;

else

< declaração >;

end;

A instrução Case pega uma variável e a compara com possíveis valores. Valores

múltiplos podem aparecer debaixo do mesmo Case, separado por vírgulas. Aqui está

um exemplo de uma estrutura Case:

Case Ch of

'A'..'Z', 'a'..'z': ShowMessage('Letra');

'0'..'9': ShowMessage('Número');

'+', '-', '*', '/': ShowMessage(Operador');

else

ShowMessage('Caractere Especial');

end; // case

Neste exemplo, nós estamos testando o valor da variável Ch (que é do tipo char) e

mostrando 'Letra' se ela é uma letra maiúscula ou minúscula, 'Número' se ela é um

número, ou 'Operador' se ela é um operador. Se nenhum dos casos anteriores for

verdadeiro, a cláusula else é executada, e as palavras ‘Caractere Especial’ são

mostradas.

Se você estiver familiarizado com C, o construtor Case é semelhante à declaração

Switch .

Também note que qualquer uma das declarações em um Case pode ser declarações

simples ou composta. Se você precisar executar múltiplas linhas de código para um

determinado caso, você tem que colocar o código dentro um begin . . . end.

Page 61: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 61 -

Loop

Loop é uma das atividades fundamentais que você empregará em qualquer linguagem

de programação. Objecto Pascal oferece várias alternativas de loop . Cada tipo

particular para uma circunstância específica.

4.7.3 While . . . do

O loop While executa declarações até que a condição declarada no While fique falsa.

Aqui está a sintaxe geral do While :

while <Expressão Lógica> do

<declaração>;

Como em todas as estruturas, você pode ter declarações simples ou compostas. Aqui

está um exemplo de uma declaração composta:

i := 10;

while i > 0 do

begin

i := i - 1;

ShowMessage(‘Este é um loop!’ );

end; // while

Este exemplo mostrará ‘Este é um loop!’ dez vezes. Note que o loop While impedirá

que as declarações internas sejam executadas, se a condição for inicialmente falsa.

4.7.4 For . . . do

O loop For é diferente do loop While pois ele sempre executa um número especificado

de vezes, determinado pela variável de controle. A sintaxe geral do For é mostrada

abaixo:

for <Controle Variável> := <Valor Inicial> to <Valor Final> do

<declaração>;

Page 62: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 62 -

Aqui, a variável de controle normalmente é um inteiro (ou um dos tipos de inteiro) e

freqüentemente é nomeado "i" (que representa índice). Esta variável normalmente é

inicializada com um valor de 1, mas pode iniciar com qualquer valor. Então, criar um

loop que rode de 10 a 100:

for i := 10 to 100 do

ShowMessage( ‘Loop’ );

Como este loop executa, o valor de i é 10 na primeira vez. Para cada volta, é

incrementado i. O loop continua até que i alcance o valor de 100 (o valor final). Na

última passagem do loop, i é igual a 100. É incrementado novamente, e o loop termina

porque o valor de i é agora maior que o valor final.

Para este tipo de loop não é necessário incrementar a variável de controle; há uma

modificação para o porque volta, downto por sua vez faz com que a variável i seja

decrementada e não incrementada para cada volta.

Se você quisesse fazer o loop de 10 até -10:

for i := 10 downto -10 do

if i > 0 then

ShowMessage( ‘i é maior que zero’ )

else if i < 0 then

ShowMessage( ‘i é menor que zero’ )

else

ShowMessage( ‘i é exatamente zero’ );

Note que neste exemplo que há só um pontro-e-vígula, e só um lugar possível para ele.

A declaração For leva uma única declaração ou uma declaração composta, porém, a

declaração do if..then..else é uma única declaração, e assim não há nenhuma

necessidade do begin...end .

Seja cauteloso ao usar a variável de controle. Deve ser declarado como um tipo

ordinal (um número ou um tipo enumerado definido pelo usuário) e deve estar dentro

do escopo do loop. Também, depois que o loop for executado, o valor da variável de

controle será um passo além para o 'to' ou 'downto' . Você não pode mudar o valor

da variável de controle dentro do loop.

Page 63: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 63 -

O loop For é a melhor opção de loop quando você sabe com antecedência os valores

que você passará para o loop. Ele é utilizado freqüentemente para o acesso aos

elementos de um array .

4.7.5 Break e Continue

O último dos tópicos dos loops se refere a duas palavras reservadas break e continue .

Qualquer um destes comandos pode ser usado em quaisquer das estruturas

anteriores de loop.

Break é usada para encerrar o loop imediatamente. Assim, break é um modo

conveniente para encerrar o loop sem ter que configurar condições de loop especiais.

Aqui está um exemplo:

while True do

begin

readln( inputFile, i );

if StrToInt(i) = 5 then

break;

ShowMessage( i );

end;

Neste exemplo, note que o loop sempre rodará a menos que algo intervenha (While

True sempre será verdadeiro). O loop continuará lendo um arquivo e mostrando o que

foi lido até que o número lido seja igual a 5. Quando um break é encontrado, o

programa salta sua execução para a primeira declaração em seguida ao loop.

O outro modificador de execução de loop é a declaração Continue . Uma declaração

continue saltará o resto do loop e voltará para a condição de avaliação. Assim, se

houverem mudanças de valor que podem afetar a condição do loop, você pode usar o

Continue voltando ao inicio do loop e re-avaliar a condição.

Aqui temos um exemplo simples:

while i < 10 do

begin

readln( inputFile, i );

if StrToInt( i ) < 5 then

continue;

ShowMessage( ‘Está mensagem sera exibida quando I maior ou igual a 5: ’ + i );

end; // while

Page 64: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 64 -

A declaração Continue neste caso impedirá que qualquer número menor que 5 de

seja impresso, o resto da volta é saltado, e a condição de volta é re-avaliada. Se o

usuário entrar em um número maior que 10, o valor ainda será impresso, mas o loop

termina.

A declaração Continue é particularmente útil para saltar ou evitar dados inválidos ou

cálculos. Se o usuário entrar com algo diferente do que você quis, então você pode

usar Continue voltando ao início do loop e conseguir o dado novamente.

4.7.6 Repeat

repeat comando1; comando2; comando3; until <condições>

O repeat é o comando de repetição com teste no final. Como conseqüência,

seus comandos são sempre executados pelo menos uma vez! Este é também um

comando exótico em relação aos outros dois, primeiro por causa da sintaxe, que não

exige begin..end para múltiplas instruções (o repeat é um bloco) e por causa do

significado de seu teste de parada. O while executa sua repetição enquanto as

condições fornecidas forem verdadeiras. Já o repeat executa seus comandos até a

condição se tornar verdadeira!

Todos os comandos de repetição podem ser interrompidos quando for

conveniente para o programador através de duas instruções: o break e o continue . O

break é usado quando se deseja sair totalmente do corpo do comando de repetição e

seguir a vida, enquanto que o continue apenas sai da iteração atual, pulando para a

próxima iteração, sem sair do comando de repetição.

Page 65: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 65 -

4.7.7 Tratamento de Exceções

Existem dois comandos utilizados para fazer tratamento de exceções em

Delphi: o try..except e o try..finally.

O bloco try..except tem as seguintes possibilidades:

// try..finally com exceção qualquer try comando1; comando2; except comando3; comando4; end ; // try..except capturando exceções específicas try comando1; comando2; except on exceção1 do comando3; on exceção2 do begin comando4; comando5; end ; end ; // try..except re-disparando uma exceção try comando1; comando2; except on exceção1 do raise ; end ;

O bloco try..except é utilizado para executar uma lista de comandos e capturar as

exceções que acontecerem nestes comandos para que sejam tratadas, possibilitando que

o programa se recupere e continue a executar. No 1º caso, vimos um try..except que

executa seu bloco de tratamento except para qualquer que seja a exceção disparada. No

segundo exemplo, vemos um bloco que captura exceções específicas e dá tratamento

individualizado a cada uma delas (que é o jeito ideal de se fazer o tratamento). Por fim

temos o tratamento de exceção do tipo “batata-quente”, onde um determinado tipo de

exceção não vai ser tratado localmente, e sim pela rotina que está um nível acima, ou seja,

aquela que chamou esta onde está o try..except. O comando raise se encarrega de re-

disparar a exceção capturada para que seja tratada em outro lugar. Aliás, a instrução raise

pode ser usada em qualquer lugar do código, não apenas no bloco except, para disparar

exceções quando alguma condição não for especificada.

Page 66: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 66 -

Exemplo:

if not <condição> then raise Exception.Create( ‘Condição inválida!’ );

Este código dispara uma exceção do tipo Exception (a “mãe” de todas as exceções

Delphi) sempre que <condição> for falsa.

Quanto ao bloco try..finally, seu uso é indicado principalmente para garantir que um

determinado recurso alocado pelo programa seja liberado, aconteça o que acontecer. Por

exemplo, se você instancia um objeto, ele deve ser liberado manualmente (não temos

garbage collector), mas se houver uma exceção antes que o código de liberação seja

executado, o objeto continuará vagando pela memória, ocupando espaço e gastando

recursos da máquina! Mas se o protegermos o código que utiliza o objeto com o bloco try e

colocarmos o código de liberação no finally, ele garantirá que o objeto será liberado de

qualquer jeito, com ou sem exceções! Outro uso pode ser o fechamento de arquivos, ou

fazer o cursor voltar ao normal (pro caso de o mudarmos e ocorrer uma exceção que o

manteria modificado, como ficar eternamente com a ampulheta). A sintaxe de um bloco

try..finally é:

try comando1; comando2; finally comando3; comando4; end ;

4.7.8 O Comando with

Quando trabalhamos com objetos ou registros, usamos o operador ponto para

acessar seus campos ou propriedades. Mas, se a lista de propriedades que temos que

manipular for muito grande, acessa-las repetindo sempre o nome do objeto torna-se meio

trabalhoso, mesmo dispondo de code completions e Ctrl + C. É aí que entra o comando

with! Ele permite colocar em evidência a parte dos nomes dos objetos e assim escrevemos

somente as propriedades finais. Vamos vê-lo em ação:

// trecho de código sem with Form1.Font.Style := [fsBold]; Form1.Font.Color := clNavy; Form1.Font.Name := 'MS Sans Serif' ; Form1.Font.Size := 10; // o mesmo código com with with Form1.Font do begin Style := [fsBold]; Color := clNavy; Name := 'MS Sans Serif' ; Size := 10; end ;

Page 67: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 67 -

Prático, não? Colocamos a parte “Form1.Font” em evidência e assim digitamos

apenas a parte variável do código! Mas não devemos ficar muito entusiasmados com este

comando, pois junto com a praticidade vêm os problemas...

O primeiro problema que torna o uso do with não recomendado é a questão da

legibilidade. Dê uma olhada no código abaixo:

with Memo1 do begin Line := Perform(EM_LINEFROMCHAR, SelStart, 0); Column := SelStart - Perform(EM_LINEINDEX, Line, 0); Label1.Caption := IntToStr(Line + 1); Label2.Caption := IntToStr(Column + 1); end ;

Agora responda: o que é “SelStart”? Uma variável? Uma função? Uma propriedade do

Memo1? O que são “Line” e “Colunm”?

Esse é o problema; o with torna o código fonte mais confuso para o leitor, pois fica

difícil de determinar a quem pertencem os elementos referenciados, apesar de poupar o

trabalho do escritor...

Mas o pior defeito do comando with é esconder os valores das expressões dos

debuggers do Delphi. Portanto, se usar with você não poderá ver os valores das variáveis

ao parar a execução do programa com Break Point. E também não adianta “apelar” para

Whatches ou Evaluate/Modify... nada consegue acessar estes valores!

Por isso, os prejuízos que conseguimos com este comando acabam se tornando

maiores que seus benefícios e seu uso é desencorajado.

Page 68: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 68 -

4.8 Variáveis e Constantes

Vejamos como são as declarações de variáveis e constantes no Delphi.

Primeiramente, devemos saber que todas as variáveis devem ser declaradas dentro

de uma seção var e as constantes dentro de uma seção const . A sintaxe geral de uma

declaração de variáveis ou constantes é:

// declaração de variáveis var // simples Numero: Integer; // lista Palavra1, Palavra2, Palavra3: String ; // inicializando na declaração OutroNumero: Integer = 0; // declaração de constantes const // true constants ConstanteInteira = 10; ConstanteString = ‘Texto constante’ ; ContanteExpressao = 30 + ( 25 mod 2); // typed constants MaisUmNumero: Integer = 100 ; OutraString: String = ‘Nada Não!’ ; Nums: array [ 0.. 9] of Char = ( '0' , '1' , '2' , '3' , '4' , '5' , '6' , '7' , '8' , '9' );

Podemos declarar variáveis de três diferentes modos, sem complicação: o simples,

a listagem de variáveis de mesmo tipo e a declaração com inicialização, conforme os

exemplos acima, mas a declaração com inicialização só funciona em variáveis globais (nas

locais dá erro de compilação!) e não é permitida a inicialização em lista (inicializar várias

variáveis ao mesmo tempo com o mesmo valor).

Quanto às constantes, existem dois tipos: as “true constants” e as “typed

constants”. As true são constantes declaradas sem o tipo, que fica implícito no valor

atribuído a elas e não suportam valores de tipos estruturados. Já as typed possuem o tipo

definido explicitamente, podendo ser de tipos estruturados (como o array constante

“Nums” do exemplo).

Os valores atribuídos a qualquer constante podem ser tanto valores simples e

diretos quanto expressões mais elaboradas.

4.9 Procedimentos e Funções

Os procedimentos e as funções são as sub-rotinas do Delphi, e tanto podem ser

métodos de classes ou interfaces como também podem pertencer apenas à Unit. A

diferença entre estes dois tipos de sub-rotinas é que as funções têm um valor de retorno,

enquanto que os procedimentos não.

Page 69: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 69 -

4.9.1 Declarando Procedimentos e Funções

Os formatos gerais de declarações de procedimentos e funções são os

seguintes:

// declaração geral de procedimento procedure Nome_do_procedimento(Lista_de_parametros); Diretiv as; Declarações_locais; begin Instruções; end ; // declaração geral de função function Nome_da_função(Lista_de_parametros): Tipo_de_retorn o; Diretivas; Declarações_locais; begin Instruções; Retorno_do_valor; end ;

Nas declarações acima, “Declarações_locais” são as variáveis, constantes,

tipos de dados (sim, pode-se declarar tipos de dados locais!) e outras sub-rotinas

locais (podemos declarar funções e procedimentos dentro de outras funções e

procedimentos!). “Diretivas” são diretivas que possuem diversas funcionalidades como

convenções de chamada, declarações externas... etc. que não serão abordadas aqui,

por quase nunca serem usadas em situações comuns de programação. Mas algumas

destas diretivas são importantes como a override que foi apresentada na parte sobre

classes e a overload que veremos daqui a pouco. “Instruções” são as instruções que

devem ser executadas pela sub-rotina. “Tipo_de_retorno” é o tipo de valor que a

função retorna (String, Integer...). “Retorno_do_valor” é a instrução que atribui um

valor à função para que este seja retornado por ela. Existem duas maneiras de atribuir

o valor de retorno à função, pelo nome da função ou pela variável de retorno Result.

Na primeira forma, para fazermos a função retornar um valor pelo nome, fazemos:

Nome_da_função := Valor;

e da segunda forma, com a variável de retorno Result, fazemos:

Result := Valor;

Result é uma espécie de variável interna que toda função Delphi possui e que não precisa

ser declarada, bastando atribuir diretamente. Result sempre é do mesmo tipo de retorno

da função.

nota: Ao contrário do que ocorre na instrução return do Java por exemplo, a execução do

programa não sai da função ao atribuirmos o resultado a ela em Delphi, ou seja, se você

atribuir um valor ao result mas ainda houverem instruções depois, todas elas serão

executadas. A função só retorna o valor após executar todas as suas instruções.

Page 70: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 70 -

A lista de parâmetros merece uma atenção especial. Primeiramente, podemos

declarar os parâmetros da mesma forma que declaramos variáveis: simples, lista e com

inicialização (aqui chamado do parâmetro com valor default).

Parâmetros simples não têm segredo (são separados com ponto-e-vírgula):

procedure P(Parametro1: Integer; Parametro2: String );

Agora com lista (os de mesmo tipo são separados com vírgula e os de tipos diferentes são

separados com ponto-e-vírgula. Agrupar parâmetros de mesmo tipo em lista é opcional):

procedure P(Parametro1, Parametro2: Integer; Parame tro3: String);

Com default (se nada for passado como argumento, assume o valor da inicialização):

procedure P(Parametro1: Integer; Parametro2: Boolea n = True);

E agora sem parâmetros (veja que não é necessário colocar parênteses vazios em Delphi):

procedure P;

Estas regras são as mesmas para funções.

Para executar procedimentos e funções, basta chama-los pelo nome. Se eu

tenho um procedure P(A: Integer; B: Boolean); só precisamos fazer P(100, True);

para chamá-lo! O mesmo valendo para funções, só que elas têm um valor de retorno

que pode ser ou não atribuído a alguma variável ou testado em comandos de decisão

e repetição.

Podemos sobrecarregar sub-rotinas em Delphi utilizando a diretiva overload

mencionada acima. Exemplos de rotinas sobrecarregadas:

procedure P; overload ; procedure P(I: Integer); overload ; procedure P(S: String ; B: Boolean); overload ;

É só isso! Basta que eles tenham o mesmo nome, mas com listas de parâmetros

diferentes, e a diretiva overload em cada versão sobrecarregada.

5 Componentes

A programação típica em Delphi é bastante centralizada na adição e configuração

de componentes da Palheta de Componentes no Form Designer. Então, vamos ver

alguns conceitos e propriedades básicas dos componentes.

Page 71: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 71 -

5.1 Relacionamentos entre Componentes

Existem dois relacionamentos comuns entre componentes: O relacionamento

Parent e o relacionamento Owner.

O relacionamento Parent, que só vale para componentes visuais, indica quem

é o contêiner (o Parent) de um componente. O Parent ou contêiner é responsável pelo

alinhamento visual de seus componentes.

Já o relacionamento Owner (proprietário) é uma facilidade para a destruição de

objetos criada em tempos de ausência de garbage collector! Quando um componente

é Owner de outros, significa que quando ele for destruído, todos os componentes que

são propriedade dele também serão! Numa aplicação comum, o Owner de todos os

componentes costuma ser o formulário. Dessa forma, quando o Form é destruído,

todos os outros componentes são destruídos junto com ele!

5.2 Propriedades e Eventos Comuns

Os componentes são objetos que estão numa vasta hierarquia de classes. A

classe básica de um componente é TComponent, onde estão definidas características

básicas que todo componente, visual ou não deve ter.

Por terem uma origem comum, muitos componentes apresentam propriedades,

eventos e métodos comuns. Por isso, antes de vermos componentes de forma mais

específica, é bom que conheçamos estes elementos comuns, e que são também

frequentemente utilizados.

Entre as propriedades mais corriqueiras, podemos destacar:

• Action: Torna um componente cliente de um componente TAction, que será visto

mais a frente.

• Anchors: Servem para manter constantes a posição dos lados de um componente

quando a janela é redimensionada.

• TabOrder: É a ordem em que os componentes vão ganhando foco à medida que a

tecla Tab é pressionada.

• TabStop: Define se o componente vai ou não receber o foco ao se pressionar Tab.

Se esta propriedade for falsa, TabOrder não tem efeito.

• Name: É o nome do componente. É usado pelo Delphi para criar as referências

para os componentes adicionados ao Form Designer.

• Hint: Usada para exibir uma dica sobre o componente ao pararmos o mouse sobre

ele.

• ShowHint: Ativa ou desativa a exibição do hint.

Page 72: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 72 -

• Height e Width: Altura e largura do componente.

• Left e Top: São as coordenadas do canto superior esquerdo do componente em

relação ao seu Parent. Left é a coordenada X e Top a Y, e são medidas a partir do

canto superior esquerdo do Parent.

• Visible: Torna o componente visível ou invisível.

• Enable: Desabilita ou habilita o componente. Quando desabilitado, ele continua

visível, mas o usuário não pode interagir com ele.

• ReadOnly: Todo componente que contém um texto ou valor que pode ser editado

possui esta propriedade, que define se este valor pode ou não ser editado. se

ReadOnly for True, o valor é apenas para leitura – não pode ser mudado pelo

usuário.

• Align: Contém alinhamentos pré-definidos para componentes visuais, fazendo com

que eles ocupem totalmente um dos lados do Parent (top, bottom, left ou right).

• Ctrl3D: Controla a tridimensionalidade. se estiver falsa, o componente se torna

bidimensional.

• Caption: Muitos componentes possuem esta propriedade que apenas exibe neles

um texto fixo, ao qual o usuário não tem acesso.

• Font: É a fonte que será usada nas propriedades de texto do componente, como a

Caption. Porém, para a classe TForm, Font é usada para dar uma fonte padrão aos

componentes colocados no formulário, que automaticamente ajustam suas fontes

para ela.

• Color: É a cor de fundo do componente.

Agora, os eventos mais populares:

• OnClick: Ocorre quando o componente é clicado (não diga!).

• Eventos de mouse: Os eventos de mouse são OnMouseMove, OnMouseDown e

OnMouseUp e embora se pareçam com o click, são mais específicos para

tratamento de mouse. OnMouseMove ocorre quando o mouse passa sobre um

componente. Recebe como argumentos, além do famoso Sender, as coordenadas

do mouse e o ShiftState (estado das teclas shift, ctrl, alt e o estado dos botões do

mouse). OnMouseDown é chamado quando o botão do mouse é pressionado, ou

seja, quando ele desce. Recebe como argumentos a posição do mouse, o botão do

mouse que foi clicado, além do ShiftState. OnMouseUp é Idêntico ao mouse down,

só que é disparado quando o usuário solta o botão do mouse.

Page 73: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 73 -

• Eventos de teclado: São OnKeyPress, OnKeyDown e OnKeyUp. OnKeyDown e

OnKeyUp possuem a mesma idéia dos eventos de mouse de mesmo nome e são

indicados para tratar teclas como enter, esc, delete, F1, F2, direcionais... etc. as

chamadas “teclas virtuais”, que não representam caracteres. Para tratar teclas de

caracteres, é indicado u uso do OnKeyPress.

• OnEnter: Ocorre quando um componente recebe o foco.

• OnExit: Oposto do OnEnter. É chamado ao perder o foco.

• OnChange: Alguns componentes possuem este evento que é chamado sempre o

estado do componente muda. Mas cada um tem sua própria versão desta mudança.

5.3 Componentes mais Usados

Veremos agora alguns dos componentes usados mais frequentemente na

programação em Delphi e conheceremos suas propriedades e eventos mais

significativos.

5.4 TForm

Os componentes da classe TForm são os formulários sobre os quais incluímos

outros componentes e através do qual criamos a telas da aplicação. Suas

propriedades mais importantes são:

• BorderIcons: Configura a presença dos botões de maximizar, minimizar, fechar e

help ao configurar cada uma como True ou False.

• BorderStyle: Configura o estilo da borda do formulário. Seu uso mais típico é para

impedir que o usuário redimensione o formulário, alterando seu valor para bsSingle

(o padrão é bsSizeable, que permite que o usuário ajuste o tamanho da janela em

tempo de execução).

• Icon: Sobrescreve o ícone padrão definido em Application do Project Options e o

exibe no canto superior esquerdo do Form.

• Menu: Associa o Form a um objeto TMainMenu, que será o menu daquela tela.

• Position: É a posição na qual o Form vai aparecer na tela ao ser mostrado. Seu

valor padrão é poDesigned, que indica que ele será mostrado onde foi deixado em

tempo de projeto. Em situações normais deve ser configurada como

poScreenCenter para que o Form seja mostrado no centro da tela, independente de

onde ele estava durante o projeto.

Page 74: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 74 -

• WindowState: É o estado da janela ao ser mostrada. O padrão é o valor wsNormal,

em que ela fica normal, no tamanho em que foi projetada. Mas pode mudar para

maximizada (típico para o form principal da aplicação) ou minimizada se mudarmos

seu valor para wsMaximized ou wsMinimized.

Os eventos mais utilizados de um objeto TForm são os seguintes:

• OnActivate: Ocorre quando o Form se torna ativo.

• OnClose: Ocorre quando o Form é fechado.

• OnCloseQuery: Este evento ocorre imediatamente antes de fechar o Form e é

usado para decidir se ele realmente tem permissão para fechar ou não, através do

parâmetro CanClose. Se o programador definir que o formulário não pode ser

fechado se uma determinada operação ainda está pendente (um arquivo não salvo

por exemplo), basta definir CanClose para False;

• OnCreate: Este evento é chamado pelo construtor do Form como parte do

processo de instanciação. É usado para inicializar valores de propriedades,

campos, propriedades de componentes, etc.

• OnDeactivate: É o oposto do OnActivate, ocorrendo ao desativar a janela.

• OnDestroy: Evento chamado pelo método destruidor do Form, usado para liberar

recursos alocados por ele (destruir objetos globais, fechar arquivos...).

• OnShow: Ocorre imediatamente antes do Form ser exibido na tela.

O Form possui também alguns métodos bastante usados:

• Show: Mostra o formulário.

• ShowModal: Faz o mesmo que show, só que neste caso o Form não permite que

outras telas do sistema sejam ativadas enquanto ele não for fechado. ShowModal é

uma função que retorna um valor inteiro que pode ser testado quando ele se fecha.

5.5 Botões

Temos 3 componentes que representam diferentes tipos de botões, cada um

com suas funcionalidades especificas. São eles o TButton, TBitBtn e o TSpeedButton.

Eles possuem propriedades comuns, que veremos agora:

• Cancel: Se for verdadeira, clica o botão automaticamente ao pressionar a tecla

Esc. Não está presente no SpeedButton, pois ele não responde ao teclado.

Page 75: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 75 -

• Default: Clica o botão automaticamente ao pressionarmos a tela Enter, quando

está True. Assim como Cancel, não está no SpeedButton pela mesma razão.

Agora vamos dar uma olhada no TBitBtn. O maior diferencial deste botão em relação

ao TButton é o suporte à imagens, o que significa que podemos colocar um ícone

nele, através da propriedade Glyph. Outras propriedades existem em função deste

ícone: Margin e Spacing, que controlam respectivamente a margem que deve ser

respeitada antes do glyph e o espaço entre o glyph e o caption. Há também a

propriedade layout que informa a posição do glyph (à esquerda, direita, acima ou

abaixo em relação ao caption). Estas três propriedades estão também no

TSpeedButton.

O botão do tipo SpeedButton é diferente dos outros. Ele não pode ser

acessado por tabulações como os outros e não pode receber foco, comportamento

encontrado em botões de barras de ferramentas por exemplo. Possui uma propriedade

exclusiva entre os botões, a Flat, que quando verdadeira, esconde o contorno do

botão até que o mouse passe sobre ele.

5.6 O Label

Componente usado para criar um rótulo, tipicamente usado com edits. Um

Label não pode receber foco nem pode ser editado em tempo de execução. Sua

funcionalidade básica se restringe a exibir um texto pela propriedade Caption. Possui

também a propriedade FocusControl, que faz com que o controle referenciado por ela

receba o foco, se o Caption do Label estiver com configurado com um atalho Alt +

tecla, configurado com um “&” antes do caractere que servirá de tecla de atalho junto

com Alt.

5.7 Os Edits

São os componentes tipo caixa de texto de uma única linha onde o usuário

pode digitar um texto qualquer. O Delphi fornece 3 edits básicos: TEdit, TMaskEdit,

TLabeledEdit.

Algumas propriedades comuns entre eles são:

• MaxLength: Nº. máximo de caracteres que podem ser digitados

• PasswordChar: Caractere que será exibido para esconder o texto real do edit ao

digitar (usado para colocar o “*” em campos de senha, daí o nome PasswordChar!).

Page 76: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 76 -

• CharCase: Define se o texto digitado vai estar sempre em maiúsculas, minúsculas

ou normal (permitindo tudo).

• Text: É o texto digitado no edit.

O MaskEdit é um edit especial, cujo Text pode ser formatado usando máscaras, com a

propriedade EditMask. Basta utilizar o editor de mascaras que não tem mistério! Já o

LabeledEdit é um edit que já vem com um Label embutido, que agiliza ainda mais a

criação de telas. A propriedade EditLabel permite configurar as propriedades do Label

embutido. de novidade só temos as propriedades LabelPosition e LabelSpacing, que

controlam a posição (esquerda, direita, acima e abaixo) e a distância do Label interno

em relação ao edit.

5.8 O Painel

Um painel é um componente do tipo TPanel, que é um contêiner para outros

componentes. è usado para organizar o layout do Form, agrupando componentes,

portanto suas funcionalidades se restringem ao projeto na maioria dos casos. Sus

propriedades mais usadas são as que controlam a aparência das bordas:

• BevelInner: Controla o layout da borda interna.

• BevelOuter: Manipula a borda externa.

• BevelWidth: É o tamanho das bordas.

Seus valores definem se a borda será “pra fora” (raised), “pra dentro” (lowered) ou

nehuma.

Pode-se criar efeitos interessantes combinando de formas diferentes as bordas do

Panel.

5.9 Barra de Status

O componente TStatusbar é o responsável por representar as barras de status,

bastante comuns em diversos tipos de programas. Na realidade, o mérito não está na

StatusBar em si, mas na propriedade Panels. É nos painéis que criamos dentro da

StatusBar que inserimos os textos que ela exibe. Os TStatusPanel têm como

propriedades mais legais:

• Alignment: É o alinhamento do texto do painel (esquerdo, direito ou centralizado)

• Bevel: Se o painel terá visual “raised” ou “lowered”, como um Tpanel

• Text: O texto que será exibido no StatusPanel.

Page 77: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 77 -

A StatusBar pode ser usada sem os StatusPanels (ativando a propriedade

SimplePanel, e preenchendo a propriedade SimpleText), mas aí adeus alinhamento e

adeus bevel.

5.10 RadioButton

O RadioButton é um componente usado para implementar uma seleção onde

as opções são mutuamente exclusivas, ou seja, o usuário só pode marcar um valor.

O estado do RadioButton pode ser lido através da propriedade Checked, que é

True se ele estiver marcado e False caso contrário.

Fato curioso é que se houverem vários RadioButtons no mesmo parent, eles

assumen automaticamente o comportamento de mútua exclusão, sem precisar de

nenhuma programação!

5.11 CheckBox

Assim como o RadioButton, serve para implementar seleções, mas com a

CheckBox o usuário pode marcar várias opções ao mesmo tempo. Também possui a

propriedade Checked, que guarda seu estado, exatamente como o RadioButton.

5.12 RadioGroup

Usado para simplificar a criação de vários RadioButtons agrupados. Nele, cada

RadioButton é tratado como uma linha editada na propriedade Items. Para saber qual

deles está selecionado, usamos a propriedade ItemIndex, que começa no Item 0 e

termina no Item n-1 (para que nenhum item seja marcado, configure ItemIndex como -

1).

Quanto à organização dos RadioButtons em seu interior, o Radiogroup

costuma colocar um por linha, o que nem sempre fica bonito... Para resolver este

impasse, basta configurar a propriedade Colunms para o número de colunas desejado!

5.13 ComboBox

As ComboBoxes são como Edits com uma lista embutida que se abre ao

clicarmos no botão com a setinha à direita. Vamos ver suas propriedades mais

manjadas:

Page 78: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 78 -

• Items: Igual à Items do RadioGroup, é a lista dos itens que aparecerão na lista

quando o botão for pressionado.

• ItemIndex: Também é como à do RadioGroup, retornando o índice do item da lista

que está selecionado. Se não há itens selecionados, ItemIndex assume o valor -1.

• DropDownCount: Número máximo de itens que aparecerão na lista suspensa. Se

o número de itens for maior que o valor de DropDownCount, uma barra de rolagem

aparece.

• Sorted: Se esta propriedade for habilitada, os itens serão ordenados.

• Style: Determina o estilo do display da ComboBox. Serve principalmente para

controlar se ela é editável (csDropDown) ou se serve apenas para seleção

(csDropDownList).

• Text: É o texto do elemento corrente.

5.14 MainMenu e MenuItem

O MainMenu é o componente que representa a barra de menu de um

formulário e serve como contêiner para os objetos MenuItem, que são os menus

propriamente ditos. Os MenuItem são componentes que não aparecem na paleta de

componentes e só podem ser criados em tempo de projeto através da propriedade

Items do MainMenu, que abre o editor “Menu Designer”, que permite criar os

MenuItems facilmente, apenas usando as setas e o clique com botão direito, onde

estão algumas funcionalidades como “Create Sub-Menu”, que cria um sub-menu de

um MenuItem na lateral, iniciando um outro ramo.

Existe um tipo especial de item, o separador, que é uma linha que separa

outros itens. Para criar um separador, basta colocar um “-” no Caption. Algumas

propriedades importantes do MenuItem são:

• Checked: Cria um menu de checagem, igual ao do “Quebra automática de linha”

do bloco de notas

• RadioItem: quando habilitada em vários MenuItems, cria neles comportamento de

RadioButtons, ou seja, a seleção de exclusão mútua.

• Bitmap: Coloca uma imagem no menu, como as do menu do Delphi

• ShortCut: Cria um atalho de teclado para o menu, que pode ser acionado sem abri-

lo, como o Salvar do bloco de notas Ctrl + S.

• ImageIndex: É uma outra forma de colocar imagens nos menus, que ao invés de

selecionar um bitmap diretamente, trabalha em parceria com um componente

Page 79: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 79 -

ImageList, que guarda uma lista de imagens. ImageIndex é o índice de cada

imagem guardada no ImageList, que será visto mais a frente. A image list é

associada ao MainMenu, através da propriedade Images.

5.15 PopupMenu

Componente usado para implementar menus estilo pop-up (não diga!), que

aparecem quando clicamos com o botão direito. A criação de itens é idêntica à do

MainMenu.

5.16 Toolbar

É o componente usado para criar barras de ferramentas. Sua propriedades

mais usadas são:

• ButtonHeight e ButtonWidth: Controlam a altura e a largura dos botões

adicionados na barra.

• Customizable: Se estiver ativa, permite que o usuário modifique a barra de

ferramentas em tempo de execução, de duas formas diferentes: com duplo click,

chamando o diálogo de customização (semelhante ao do Internet Explorer) ou

segurando a tecla Shift, o que permite que os botões sejam arrastados para outras

posições ou para fora da barra, o que os exclui.

• ShowCaptions: Se estiver True, exibe os Captions dos botões.

• Flat: Faz com que os botões fiquem sem borda até que o mouse passe sobre eles.

Se flat é False, os botões ficam sempre com borda (o que dá à aplicação um

aspecto de programa antigo!).

• Images: Associa a Toolbar com um objeto ImageList, para que as imagens

contidas nele possam ser colocadas nos botões.

Os botões colocados na Toolbar são um tipo especial de botão, da classe TToolButton,

e podem ser adicionados à barra de ferramentas clicando com o botão direito e

escolhendo “New Button”. O ToolButton pode assumir a forma de um separador, se

adicionarmos “New Separator”, ou então mudando sua propriedade Style para

tbsSeparator. As principais propriedades dos ToolButtons são:

• Style: Como já foi mencionado, controla o estilo do botão, tipicamente entre

tbsButton e tbsSeparator. Mas há outras possibilidades, dentre as quais se destaca

Page 80: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 80 -

a tbsDropDown, usada para fazer um ToolButton como o Run do Delphi, que tem

um menuzinho abaixo! Para se usar este estilo, devemos preencher a propriedade

DropdownMenu.

• DropdownMenu: Associa o ToolButton a um PopupMenu, criando assim a listinha

que surge quando o ToolButton é criado.

5.17 ImageList

Chegou a hora de falarmos a respeito da tão comentada ImageList, que já deu

as caras nos tópicos sobre menus e Toolbar. Este componente guarda uma lista de

imagens para compartilhar com outros componentes, principalmente com Menus e

barras de ferramentas, que a referenciam a ImageList pela propriedade Images, e

depois por ImageIndex obtém uma das imagens armazenadas nela.

Normalmente não se configura nenhuma propriedade da ImageList, apenas

adicionamos imagens a ela, dando um duplo click para chamar o editor, que faz as

operações de adicionar excluir ou mudar as imagens. Não há complicações para usá-

lo!

5.18 ActionList e Actions

Sem dúvida são dois dos componentes mais interessantes e importantes do

Delphi! A ActionList é apenas um contêiner para as Actions, os componentes que

realmente fazem todo o trabalho.

Com eles, é possível centralizar funcionalidades e propriedades que são

compartilhadas entre vários componentes, chamados de clientes das Actions.

A Aplicação típica destes componentes é manter a consistência entre o menu

da aplicação e a barra de ferramentas, já que a Toolbar é só um atalho para as

funcionalidades disponíveis no menu, os dois objetos acabam tendo elementos em

comum, tanto no que diz respeito à funcionalidade quanto também às figuras, captions,

hints, enable, atalhos de teclado, etc. Em outras palavras, se temos um menu que

salva um arquivo, cujo ícone é um disquete, o hint e o caption são “Salvar”, o atalho de

teclado é Ctrl + S e fica desabilitado se o arquivo já foi salvo, vamos querer que o

botão correspondente na barra de ferramentas tenha as mesmas características e

funcionalidade, certo? Para não termos que configurar os dois separadamente e

manter a consistência do enable “no braço”, usamos a ActionList para centralizar todas

estas características em componentes Action e então, configuramos tanto o item de

menu quanto o tool button para serem clientes da mesma Action de salvar. Pronto! Os

Page 81: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 81 -

clientes automaticamente assumem as propriedades definidas na Action, bem como o

evento de salvar!

Na ActionList, a única propriedade utilizada efetivamente na prática é a Images,

que a associa com um objeto ImageList. Com isso, as Actions contidas nela podem

acessar cada imagem pelo ImageIndex.

Para criarmos as Actions que estarão contidas na ActionList, basta dar um

duplo click nela para abrir o editor. Com ele, podemos criar dois tipos de Actions, as

Standard e as comuns. Standard Actions são componentes descendentes de TAction

que já possuem funcionalidades prontas de várias categorias diferentes. Antes de

pensar em criar uma Action do zero, dê uma olhada nas Standard... quem sabe ela já

não está lá prontinha, esperando por você! (é aquela velha história de não reinventar a

roda...).

As funcionalidades de uma Action devem ser implementadas no evento

OnExecute. Depois, no componente cliente, este evento deve ser associado ao evento

adequado (no caso dos menus, Toolbuttons e Botões comuns, OnExecute é

automaticamente associado ao evento OnClick, mas ele pode ser associado a

qualquer outro evento do tipo TNotifyEvent, como vimos na parte sobre tipos

procedurais)

Moral da história: nada de configurar captions, bitmaps, hints, etc. de menus e

barras de ferramentas. Apenas crie os MenuItens e os Toolbuttons, associe a

ImageList e faça a propriedade Action referenciar a Action correspondente que ela faz

o resto! E em tempo de execução, para mudar o enable do menu salvar e do botão

salvar do nosso caso hipotético, mude o enable apenas na Action de salvar e pronto!

O enable de todos os clientes dela muda junto!

5.19 Diálogos

Os diálogos são os componentes que encapsulam os principais diálogos do

Windows, como o diálogo de abertura de arquivos, salvamento de arquivos, diálogo de

impressão, de fonte, de cores... todos estão lá!

O método central de um diálogo é o Execute, usado para abrir a janela do

diálogo para que o usuário interaja com ele. O método execute é uma função booleana

que retorna True se o usuário confirmou a operação executada pelo diálogo, clicando

no botão OK. Se o usuário desistir da operação clicando em cancelar, Execute retorna

False. Desta forma podemos testar este retorno e só implementar nosso código

quando o usuário realmente confirmar a operação. A seguir temos uma visão geral de

alguns diálogos:

Page 82: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 82 -

• OpenDialog: Componente que representa o diálogo de abertura de arquivos: Suas

propriedades mais importantes são:

o DefaltExt: É a extensão padrão que é adicionada ao nome do arquivo

que queremos abrir, caso estejamos digitando e a extensão não for

fornecida. Não é necessário colocar o ponto no valor da propriedade.

o Filename: Guarda o nome do arquivo selecionado para a abertura ou

que foi aberto.

o Filter: Permite filtrar os tipos de arquivo que queremos que apareçam

no diálogo. Possui um editor onde especificamos o nome do filtro (tipo

“Arquivos de texto” ou “Imagens JPEG”). O filtro é escrito na forma

“*.txt” ou “*.jpeg” por exemplo. Para exibir todos os tipos de arquivo,

faça um filtro do tipo “*.*”.

o FilterIndex: Cada filtro criado em Filter recebe um índice, de 1 a n.

FilterIndex define o índice do filtro que estará ativo.

o InitialDir: Define o diretório inicial que aparece quando o diálogo é

aberto.

o Title: É o texto que vai aparecer no caption do diálogo.

o Options e OptionsEx: Estas extensas propriedades fornecem diversas

opções de configuração para o diálogo, mas que raramente são usadas.

Por isso, não as discutiremos aqui (devido também ao grande número

de opções disponíveis, perderíamos muito tempo para discuti-las e não

são tão complicadas de entender).

• SaveDialog: Diálogo para salvar arquivos. Possui as mesmas propriedades do

OpenDialog, mudando apenas a função de abrir para salvar. Não tem mistério!

• OpenPictureDialog e SavePictureDialog: Idênticos aos dois anteriores, porém

espacializados em arquivos de imagens.

• FontDialog: É o diálogo de fontes. Tudo nele gira em torno da propriedade fonte,

onde é guardada a fonte selecionada e onde configuramos a fonte na qual ele vai

abrir.

• ColorDialog: Diálogo de cores. Sua principal propriedade é Color, de onde

obtemos a cor selecionada pelo usuário e através da qual configuramos a cor inicial

no momento de abertura do diálogo.

• PrinterSetupDialog: É o diálogo de configurações da impressora. Não tem

nenhuma propriedade interessante; todas as suas funcionalidades só surgem em

execução, no diálogo propriamente dito.

Page 83: 50532966 Apostila Delphi

FACENS – Faculdade Engenharia Sorocaba - Apostila de Delphi 7 – Curso de Férias

Prof. Cesar Rodrigo - 83 -

• PrintDialog: Diálogo que configura propriedades da impressão, como número de

cópias por exemplo.

• PegeSetupDialog: É o diálogo onde se configura as características das páginas,

como o tamanho das margens e tamanho do papel por exemplo.

• FindDialog e ReplaceDialog: São os diálogos que permitem a localização e a

substituição de trechos de um texto. Só que os diálogos, ao contrário do que possa

parecer, não possuem as funcionalidades de localização e substituição; é o

programador que deve fazer estas operações por código! Os diálogos servem

apenas para coletar aquilo que o usuário deseja fazer (que texto deverá ser

localizado/substituído; se a busca irá diferenciar maiúsculas e minúsculas; se deve

buscar apenas palavras inteiras, etc.). Então, a partir dos valores armazenados em

suas propriedades, desenvolve-se o código que irá fazer aquilo que o usuário

solicitou. As propriedades utilizadas são:

o FindText: O texto a ser localizado.

o ReplaceText: Pertence ao ReplaceDialog e é o texto pelo qual o

FindText dele deverá ser substituído.

o Options: Guarda as opções de pesquisa definidas pelo usuário num

Set, no qual podemos testar se uma determinada opção está presente –

pesquisar apenas palavras inteiras é frWholeWord, diferenciar

maiúsculas e minúsculas é frMatchCase, e assim por diante.