Você está na página 1de 25

Delphi - Tutorial

Parte I
1. Conhecendo o Delphi

O Delphi, assim como todas as atuais ferramentas de desenvolvimento, contém um ambiente de


desenvolvimento (IDE) dividido em uma parte com ferramentas visuais e outra parte com janelas
para escrita de código em texto.
No próximo tópico estarei detalhando a função dos menus e das várias barras de ferramentas que
compõem o ambiente de desenvolvimento do Delphi.

2. Iniciando

2.1. O objeto Form

Toda vez que você abre o Delphi, ele cria um objeto do tipo TForm, que nada mais é que uma
janela onde você irá colocar todos os objetos, componentes e menus necessários ao seu
aplicativo. Para melhor compreensão, daqui em diante irei me referir a todo Form como
Formulário.
O Formulário contem diversas propriedades, sobre as quais falarei com o avançar deste curso.
Você pode alterar as propriedades de um formulário de duas maneiras; em tempo de
desenvolvimento ou em tempo de execução. Falarei um pouco sobre como definir as
propriedades em tempo de desenvolvimento, no próximo tópico.

2.2. A Janela Object Inspector

A Janela Object Inspector exibe duas


abas, com informações sobre as
propriedades e eventos do objeto
selecionado na janela. A aba Properties
contém as definições de todas as
propriedades que podem ser alteradas
em tempo de desenvolvimento; a aba
Events contém todos os eventos
associados ao objeto selecionado.

É aqui que iremos começar a desenvolver o nosso aplicativo. Primeiro altere a propriedade
CAPTION para "Aplicativo do Tutorial Sam-HomePage". A propriedade CAPTION, neste caso,
define o título do formulário, porém em outros objetos ela pode ter outro significado. Quando
isto ocorrer, mencionarei no texto. Observe agora como ficou a barra de título do formulário.
Agora, vamos à propriedade NAME. Altere-a para "FormPrincipal". A propriedade NAME
define o nome do objeto; procure sempre escolher um nome amigável e de fácil compreensão,
pois dessa forma será mais fácil identificar os objetos no código do seu aplicativo.

Duas outras propriedades do objeto Form são HEIGHT e WIDTH, as quais definem,
respectivamente, a altura e a largura do formulário na tela. As medidas dessas propriedades são
dadas em pixels. Como exemplo, altere as propriedades para Height = 400 e Width = 500.

2.3 - A barra de ferramentas View

A barra de ferramentas View permite que você visualize e alterne entre os formulários e as

janelas de código, onde estão as porções de código conhecidas como Unit's.

2.4 - A janela de código (Code Editor)

Clique no
terceiro botão
(Toggle
Form/Unit). A
Janela que você
na tela é a
janela de
código, dividida
em duas partes;
a da direita
exibe o código
associado ao
Formulário
selecionado (no
nosso caso o
FormPrincipal),
a da esquerda
exibe a Janela
Code Explorer,
que será
discutida mais
tarde.

2.5 - A barra de ferramentas Standard

A barra de ferramentas Standard contém os botões que executam as ações comuns a quase todos
os aplicativos, ou seja, NOVO, ABRIR, SALVAR, além de outros botões específicos do IDE do
Delphi.
2.6 - Salvando o Projeto

O Delphi agrupa todos os formulários, objetos, componentes, códigos de seu aplicativo em um


Projeto. Pois bem, vamos salvar o nosso projeto para que possamos retomá-lo mais tarde. Clique
no quarto botão da barra de ferramentas Standard ( o botão SAVE ALL ). Na janela que se abre
em seguida, você deverá informar os nomes e o destino dos arquivos do Projeto. Para facilitar o
estudo, crie uma nova pasta denominada Tutorial e a selecione.

O primeiro arquivo a ser salvo, estará no formato (.PAS) e é o arquivo de código do


FormPrincipal. Por padrão o Delphi coloca o nome Unit1, mas no nosso caso altere para
UnitPrincipal, dessa forma você saberá que esta Unit está associada ao FormPrincipal. O formato
(.PAS) vem de PASCAL, que é a linguagem de programação do qual se originou o Delphi.

O segundo arquivo estará no formato (.DPR). Este arquivo contém referências a todos os Forms
e Units utilizados pelo seu projeto. Por curiosidade (.DPR) vem de Delphi Project. Mude o nome
do arquivo para Tutorial e salve-o.

Após ter salvo o projeto, repare que na janela de código a Unit1 agora aparece como
UnitPrincipal.

Volte à barra de ferramentas View e clique no primeiro botão (VIEW UNIT). Note na janela
View Unit, que além da UnitPrincipal aparece também Tutorial; escolha a Unit Tutorial. Note
que o cabeçalho de Tutorial é diferente de UnitPrincipal, já que Tutorial é identificado com a
palavra program, pois é nessa porção de código em que está identificado o nome do programa.

2.7 - O Código de Program

Vamos estudar agora o conteúdo de Tutorial:

As palavras em negrito são palavras reservedas do Delphi, que dizem ao compilador como o
código deve ser interpretado e executado.
A cláusula uses: - lista as unidades que são incorporadas ao programa. Normalmente quando
você adiciona um formulário ao programa, o Delphi automaticamente coloca uma referência à
sua Unit na cláusula uses do program, porém, eventualmente pode ser necessário adicionar
referências manualmente.

{$R *.RES}: - as informações contidas entre chaves são diretivas de compilação, que passam
informações adicionais ao compilador, na hora de criar o arquivo executável do aplicativo. Neste
caso em particular, é informado ao compilador para incluir os arquivos de recursos do Delphi.

begin, end: - as linhas compreendidas entre as palavras begin e end definem um bloco de
código. Toda Unit deve ter estas duas declarações. Elas também são necessárias em diversas
situações, que serão descritas mais adiante. Uma linha de código quase sempre é finalizada com
um ponto-e-vírgula, exceto em algumas situações especiais. O ponto final determina o fim da
Unit.

Vamos interromper este início por ora, para falar no próximo tópico sobre algumas
características da programação em uma linguagem orientada a objetos.

3. Classes e Objetos

3.1 - Classes e Objetos

Uma classe, ou o tipo classe, define uma estrutura consistindo de campos, métodos e
propriedades. As instâncias de uma classe são chamadas objetos. Os campos, métodos e
propriedades de uma classe são chamadas de membros ou componentes

Um campo é essencialmente uma variável que é parte de um objeto. Assim como os campos de
um registro em um banco de dados, os campos de uma classe representam dados que existem em
cada instância da classe.
Um método é uma procedure ou uma função associada com a classe. Muitos métodos operam
sobre os objetos, os quais são instâncias de uma classe. Alguns métodos (chamados métodos de
classe) operam sobre a própria classe.
Uma propriedade é uma interface para dados associados com um objeto (muitas vezes
armazenados em um campo). As propriedades tem especificadores, os quais determinam como
seus dados são lidos e modificados.

Os objetos são alocados dinamicamente em blocos de memória, cuja estrutura é determinada


pelo tipo de classe ao qual pertence. Cada objeto tem uma cópia única de todo campo definido na
classe, mas todas as instâncias de uma classe compartilham os mesmos métodos. Os objetos são
criados e destruídos por métodos especiais chamados constructors e destructors.

Para que você não se sinta confuso com o texto acima, vamos ao código mostrado na figura do
ítem 2.7:

Existe uma classe chamada TApplication que encapsula o aplicativo. A palavra Application
trata-se de uma variável da classe TApplication.

Outra classe é TCustomForm, da qual derivam os objetos TForm que fazem parte de uma
aplicação Windows. No nosso código FormPrincipal é um objeto TForm.
Mais a frente falarei sobre Hierarquia e Encapsulamento, outras características de uma
linguagem OOP.

4. Compilando e Executando

Se você fechou o programa, carregue-o novamente e deixe a janela Code Editor como mostrada
na figura do item 2.7. Vamos continuar daqui.

Observe as 3 linhas entre as declarações begin e end da Unit Tutorial. Todas começam com a
palavra Application, que é uma variável global da classe TApplication. Application primeiro
executa o método Initialize, aliás este é o primeiro método executado em todos os projetos
Delphi. Este método passa informações ao sistema necessárias à inicialização do aplicativo.

Na segunda linha, Application executa o método CreateForm. CreateForm, como o próprio


nome sugere, cria um novo formulário. Na chamada à procedure são passados dois parâmetros; o
primeiro é um tipo da classe TFormClass. No nosso caso é o FormPrincipal, o qual foi criado e
definido no ambiente. Na verdade, quando você adiciona um formulário ao seu projeto, isto não
quer dizer que ele já tenha sido criado; o que ocorre é que o IDE do Delphi proporciona um
método visual para você definir as propriedades do formulário. Ele será criado somente quando
na execução do aplicativo houver a chamada ao método CreateForm. O segundo parâmetro
passado é uma variável que referencia o formulário; no nosso caso o formulário é referenciado
no código como FormPrincipal.

Na terceira linha é chamado o método Run, que executa o aplicativo.

Obs.: Normalmente, quando um novo projeto é criado, o Delphi automaticamente coloca essas 3
declarações na unit program.

Bom, vamos ao propósito deste tópico, ou seja, compilar e executar o aplicativo.

4.1 - Compilando

Para que um programa escrito em Delphi ou em qualquer outra linguagem de programação


moderna possa ser executado, ele tem que passar por um processo chamado compilação. O
compilador faz a checagem do código escrito à procura de erros de sintaxe e transforma esse
código em linguagem de máquina. O ambiente Delphi tem um poderoso compilador, pois o
mesmo varre o código do seu aplicativo à procura de erros ou de declarações ambíguas e quando
os encontra mostra na janela de código qual o erro e onde ele se encontra.

Clique no menu Project e, em seguida, na opção Compile Tutorial. Note que após um curto
intervalo de tempo apareceram pequenos pontos (geralmente azuis) ao lado da janela de código.
Isto indica que as linhas de código que são ladeadas por esses pontos foram compiladas, sem a
ocorrência de erros.

Um dos pontos fortes do ambiente Delphi é que ele lhe dispõe inúmeras ferramentas para
acompanhar o desenvolvimento e depuração do código. Vamos ver uma delas: Clique no menu
Tools, em seguida em Environment Options; na caixa de diálogo que se abre, clique na aba
Preferences e na check box Show compiler progress, clique em OK para retornar ao IDE.
Agora peça para compilar novamente o projeto; irá aparecer uma pequena janela com a
indicação do progresso de compilação como a mostrada na figura abaixo.
Eu considero esta
janela bastante útil,
pois ela me fornece
diversas
informações sobre
a compilação de
meus projetos.

Selecione a janela Code Editor, insira uma linha após a linha que contém Application.Initialize e
digite o seguinte texto: vou testar o compilador.
Compile novamente o projeto. Note agora que a janela de compilação aponta a existência de
erros. Clique em OK para fechar essa janela e vamos à janela Code Editor. Ela deverá se parecer
com a figura abaixo:

Foram apontados três erros pelo compilador. O primeiro, na linha 11 de Tutorial.dpr, informa que
a palavra "vou" é um identificador não declarado, isto é, não sendo essa uma palavra reservada
do Delphi ele tenta identificá-la como uma variável, constante ou qualquer outro identificador
declarado no projeto. Não encontrado nenhum identificador para essa palavra, o Delphi aponta
um erro. O segundo erro aponta a inexistência de um operador (como um sinal de adição '+' ou
um sinal de subtração '-'), pois a expressão "vou testar o compilador" poderia ser algo como "vou
+ testar - o + compilador", ou a inexistência do ponto-e-vírgula, o qual indica um final de linha.
O terceiro erro é consequência do erro da linha anterior.

Bom, apague a linha errada e compile novamente o projeto. Em seguida salve o mesmo, para não
perder as alterações efetuadas.

4.2 - Executando

Após nos iniciarmos na compilação de um projeto, vamos à execução do mesmo.

Primeiro vamos executá-lo dentro do próprio ambiente de programação. Para executar o


aplicativo dentro do IDE, a forma mais rápida e prática é clicar no botão Run da barra de

Ferramentas Debug, ele é o primeiro da barra:


O aplicativo será executado e aparecerá na tela como na figura abaixo (guardadas as devidas
proporções):

Note que parte


do ambiente de
programação
aparece ao
fundo da janela
do aplicativo.
Isto será útil
nas ocasiões
em que
ocorrerem
erros em tempo
de execução ou
que seja
necessário
depurar o
projeto (algo
que veremos
mais tarde).
Por enquanto
feche o
aplicativo.

Agora, vamos executar o aplicativo como sendo uma aplicação normal Windows. Clique no
menu Project e na opção Build Tutorial. Note que todo o projeto será compilado novamente e
então será gerado o arquivo executável. Saia do ambiente Delphi e localize através do Windows
Explorer o arquivo Tutorial.exe. Dê dois cliques no mesmo (ou um clique se você estiver com o
recurso Active Desktop ativado).

Pronto, embora ainda não tenha praticamente nada, o seu primeiro projeto Delphi já é um
aplicativo Windows.

Aqui terminamos a Parte 1 deste tutorial. Na próxima parte, mostrarei como criar um formulário
do tipo Sobre (About).
Parte II
Aqui começa a Parte II do nosso Tutorial. A Parte I apresentou algumas ferramentas do ambiente
Delphi e procurou mostrar a você uma pequena introdução nos conceitos de programação.

1. Componentes e Paleta de Componentes

1.1. Componentes

No item 3 da ParteI eu lhe mostrei a definição de Classes e Objetos. Neste item falarei de um
tipo de Objeto que é denominado Componente.

Os Componentes são objetos visuais que você pode manipular em tempo de desenvolvimento
(design time). Os Componentes descendem de uma classe chamada TComponent.

1.2. Paleta de Componentes

A Paleta de Componentes é a barra de ferramentas que contém todos os componentes que podem
ser adicionados a um projeto. Para facilitar o trabalho do programador, a Paleta de Componentes
é dividida em diversas abas, as quais agrupam os componentes segundo funções semelhantes. A
figura abaixo mostra a Paleta de Componentes; clique nas diversas abas para ter uma visão dos
componentes que integram a Paleta.

2. Menus

2.1 Criando um Menu

Praticamente todas as aplicações Windows tem um menu (mesmo os jogos costumam ter menus,
embora com uma disposição visual diferente em relação aos aplicativos em geral). Pois bem,
vamos colocar um menu em nosso aplicativo, que de início terá uma única função: encerrar o
aplicativo.

Procure na aba Standard da Paleta de Componentes o componente MainMenu; em geral é o


primeiro componente da paleta. Clique no componente e, em seguida, clique no formulário; o

componente irá aparecer no formulário.

Por enquanto você só tem o componente no seu projeto. Para criar o menu você deve utilizar o
Menu Designer, mostrado na figura abaixo:
Dê dois cliques
no componente
MainMenu
para abrir o
Menu
Designer. O
pequeno
retângulo
pontilhado no
canto superior
esquerdo é um
item de menu.

Na janela
Object
Inspector altere
a propriedade
Name para
MenuArquivo
e a propriedade
Caption para
&Arquivo.

O caractere "&", mais conhecido como ampersand, faz com que a letra que o precede apareça
sublinhada. O caractere sublinhado é conhecido como tecla aceleradora e sua função é
proporcionar acesso rápido ao item do menu, teclando a tecla "Alt" mais a tecla correspondente
ao caractere sublinhado ou acesso ao item de um submenu teclando somente o caractere
sublinhado.

Agora, na janela Menu Designer, clique no item "Arquivo"; aparecerá um sub-item de menu.
Altere a propriedade Name para MenuArquivoSair e a propriedade Caption para &Sair. Feche
a janela Menu Designer. Note que os itens de menu apareceram no formulário.

Por segurança, salve o projeto novamente. Não é necessário sair do mesmo.

Execute o aplicativo como explicado no item 4.2 da ParteI. O aplicativo foi carregado? então
note que o menu está lá; clique no item "Sair". Não aconteceu nada, não é!!! Isso mesmo, nada
acontece até que você coloque o código necessário, algo que faremos mais adiante. Por
enquanto, feche o aplicativo e retorne ao projeto.

2.2 A unit "menus" (e outras)

No item 2.7 da Parte I eu lhe falei um pouco sobre a cláusula uses; a figura que aparece naquele
item mostra as unidades acrescentadas à unit program, em geral são as units dos formulários
acrescentados ao projeto. Porém, note o conteúdo da cláusula uses da unit UnitPrincipal. Há
vários nomes que aparentemente não são de units que pertencem ao projeto: Windows,
Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs, Menus.

Pois bem, toda vez que criamos um novo projeto e criamos um formulário, quando o Delphi cria
a unit desse formulário ele acrescenta em sua cláusula uses várias referências a units já
compiladas e que integram o pacote de desenvolvimento. Uma unit compilada tem a extensão
DCU (Delphi Compiled Unit) e aquelas citadas no parágrafo anterior costumam estar na pasta
../Borland/Delphi4/Lib. A versão não compilada dessas units está dentro da pasta
../Borland/Delphi4/Source.

Algumas units são acrescentadas na cláusula uses quando adicionamos novos componentes ao
projeto, como foi o caso do componente MainMenu. Quando o adicionamos no formulário, o
Delphi automaticamente acrescentou uma referência à unit "Menus". Esta unit contém todo o
código necessário à criação de Menus e Menus Pop-Up.

3. Formulários: Mais propriedades

Clique no formulário para que suas propriedades apareçam no Object Inspector. Procure a
propriedade Menu, note que apareceu o termo MainMenu1, que é o componente MainMenu
que nós inserimos no formulário no tópico anterior.

Procure a propriedade Position; esta propriedade representa o tamanho e a localização do


formulário. ela pode assumir um dos seguintes valores, que são representados por variaveis
internas do Delphi:

poDesigned: O formulário aparece posicionado na tela com a mesma altura e largura que tem em
design time.
poDefault: O formulário aparece em uma posição na tela com a altura e largura determinados
pelo Windows. Cada vez que você executa a aplicação, o formulário se estica um pouco para
baixo e para a direita.
poDefaultPosOnly: O formulário aparecere com o tamanho criado por você em design time,
mas o Windows escolhe sua posição na tela.
poDefaultSizeOnly: O formulário aparece na posição em que você deixou em design time, mas
o Windows escolhe o seu tamanho.
poScreenCenter: O formulário permanece com o tamanho que você deixou em design time, mas
é posicionado no centro da tela.
poDesktopCenter: O formulário permanece com o tamanho que você deixou em design time,
mas é posicionado no centro da tela. A diferença em relação ao valor anterior está no tratamento
que é dado quando são utilizados sistemas com diversos monitores.

Para o nosso propósito vamos escolher o valor poScreenCenter.

4. Eventos e Manipulador de Eventos

4.1. Eventos

Um evento é uma ação disparada pelo usuário, como o clicar do botão do mouse ou o pressionar
de uma tecla, ou uma ocorrência do sistema, como o abrir e o fechar de um formulário. Cada
componente tem uma lista de eventos, que pode ser vista na aba Events da janela Object
Inspector.

4.2. Manipulador de Eventos (Event handler)

Quando um evento ocorre, algum código pode ser executado. A isso denominamos Manipulador
de Eventos.

Vamos a um exemplo:
Abra a janela Menu Designer do componente MainMenu1, escolha o item de menu
MenuArquivoSair e clique na aba Events do Object Inspector. Clique duas vezes no evento
OnClick.

O Delphi adicionou na UnitPrincipal uma nova procedure que tem como objetivo manipular o
evento OnClick do item de menu "Sair". Entre as linhas "begin"e "end" adicione o seguinte
código:

Application.Terminate;

Para melhorar a elegância do código, insira uma linha entre "procedure" e "begin". O código
deverá ficar como nas linhas abaixo:

procedure TFormPrincipal.MenuArquivoSairClick(Sender: TObject);

begin

Application.Terminate;

end;

O método Terminate encerra a execução do aplicativo.

Execute o aplicativo e experimente clicar no item de menu "Sair". Pronto, agora sabemos como
terminar um aplicativo. Agora salve tudo.

5. Mais conceitos de programação

5.1 Class type

Na UnitPrincipal, após a cláusula uses, aparece outra palavra reservada do Delphi: type. Na
linha abaixo vemos a seguinte declaração:

TFormPrincipal = class(TForm)

Isto significa que o Delphi acrescentou uma declaração de um tipo classe (lembra-se que
comentei sobre classes no item 3.1 da Parte I) e é aqui que você irá compreender melhor o que
ocorre com a chamada ao método CreateForm na unit Tutorial. No item 4 da Parte I, falei sobre
este método e os parâmetros passados, necessários à criação do formulário na execução do
aplicativo. Pois bem, o primeiro parâmetro TFormPrincipal é um tipo classe que foi declarado na
UnitPrincipal (O Delphi fez isso automaticamente quando o formulário foi criado no IDE); note
que nas linhas seguintes à declaração da classe aparecem os membros dessa classe:

MainMenu1: TMainMenu;
MenuArquivo: TMenuItem;
MenuArquivoSair: TMenuItem;
procedure MenuArquivoSairClick(Sender: TObject);

Os membros, ou componentes, de uma classe nada mais são que os campos, métodos e
propriedades dessa classe. Em nosso caso são o menu, os itens de menu e o evento associado ao
item de menu Sair de nosso FormPrincipal. À medida que acrescentarmos outros componentes
ou objetos ao FormPrincipal, eles serão referenciados na sequência de declarações acima.

5.2 As variáveis

O outro parâmetro passado pelo método CreateForm é uma referência à variável FormPrincipal,
a qual é declarada na UnitPrincipal como sendo do tipo TFormPrincipal.

Mas ela não é a única variável declarada até agora. Veja as linhas abaixo:

MainMenu1: TMainMenu;
MenuArquivo: TMenuItem;
MenuArquivoSair: TMenuItem;

MainMenu1 é declarado como sendo uma variável do tipo TMainMenu. MenuArquivo e


MenuArquivoSair são declarados como sendo variáveis do tipo TMenuItem. Se você tiver um
pouco de curiosidade, irá encontrar a definição desses tipos na unit "Menus".

Além dessas variáveis, automaticamente declaradas quando inserimos objetos e componentes em


nosso projeto, você pode declarar variáveis para manipulação de dados necessários à execução
do aplicativo. Mais à frente veremos como fazê-lo e suas regras.

6. Criando um formulário Sobre

Praticamente todas as aplicações Windows tem no menu Ajuda um item denominado Sobre, o
qual carrega um pequeno formulário com informações básicas, tais como, Autor do aplicativo,
versão, notas de copyright, etc. Neste item iremos criar um formulário Sobre.

6.1 Adicionando mais itens de menu

Antes de criarmos o formulário Sobre, vamos adicionar mais alguns itens em nosso
MainMenu1. Abra a janela MenuDesigner e clique no retângulo pontilhado à direita do item
"Arquivo". Altere a propriedade Name para "MenuAjuda" e a propriedade Caption para
"Aj&uda".

Clique no item "Ajuda" e em seguida no sub-item que aparece. Mude a propriedade Name para
"MenuAjudaSobre" e a propriedade Caption para "&Sobre o Tutorial". Feche o MenuDesigner.

6.2 Criando o formulário Sobre

Um formulário Sobre é muito simples de criar e, de fato, o Delphi lhe oferece um formulário já
pronto, bastando alterar algumas propriedades do mesmo e associar os eventos necessários à sua
execução. Se você quiser dar uma olhada basta clicar no botão "New" da Barra de ferramentas
Standard. Irá aparecer a janela "New Items" com diversas abas e uma grande quantidade de
objetos já prontos para serem acrescentados a um projeto. Uma amostra de um formulário Sobre
(About no Delphi) está na aba "Forms", como na figura abaixo:
Porém, para o propósito do curso, vamos criar o formulário Sobre e adicionar todos os
componentes e eventos necessários à sua manipulação. Feche a janela "New Items" sem
selecionar nenhum item.

Adicione um novo Formulário ao projeto clicando no botão "New Form". Altere as seguintes
propriedades:

Name = FormSobre;
Caption = Sobre o Tutorial;
Height = 260;
Width = 400;
Position = poScreenCenter;
BorderStyle = bsDialog.

Aqui ocorreu a alteração da propriedade BorderStyle, a qual especifica a aparência da borda do


formulário e admite os seguinte valores:

bsDialog: você não pode mudar o tamanho do formulário; é a definição padrão de uma dialog
box;
bsSingle: você não pode mudar o tamanho; a borda é uma linha simples;
bsNone: você não pode mudar o tamanho; não tem linha de borda visível;
bsSizeable: Padrão, borda de tamanho variável;
bsToolWindow: como bsSingle, mas com uma barra de título pequena;
bsSizeToolWin: como bsSizeable, mas com uma barra de título pequena.

Salve o projeto, e a nova Unit como UnitSobre.

Vá para a janela Code Editor. Note que a UnitSobre apareceu na janela, basicamente com as
mesmas declarações da UnitPrincipal. Exiba a unit Tutorial e note que foram acrescentadas
novas linhas, como mostrado abaixo:
program Tutorial;

uses

Forms,

UnitPrincipal in 'UnitPrincipal.pas'
{FormPrincipal},

UnitSobre in 'UnitSobre.pas' {FormSobre};

{$R *.RES}

begin

Application.Initialize;

Application.CreateForm(TFormPrincipal,FormPrincipa
l);

Application.CreateForm(TFormSobre, FormSobre);

Application.Run;

end.

6.3 Lidando com a memória

Ao acrescentar na unit Tutorial o método CreateForm para o formulário Sobre, o Delphi diz ao
aplicativo que esse formulário deverá ser criado na sua inicialização, juntamente com o
FormPrincipal. Esta ação irá aumentar a memória ocupada pelo seu aplicativo, já que toda vez
que um formulário é criado, um bloco de memória é alocado para ele. Agora imagine se o seu
projeto tiver uma dúzia ou, talvez, uma centena de formulários, quanta memória terá que ser
disponibilizada para todos eles? Imagine também que desperdício de memória será se não houver
necessidade de manter todos os formulários abertos. Pois bem, não pense que o Delphi tem um
furo, já que é muito simples contornar essa situação.

Clique no menu Projects e em seguida no item Options. Aparecerá uma janela como a figura
abaixo (mostrando parte da janela):
Main form mostra o formulário que será visto quando a aplicação for iniciada.

Auto-create forms mostra os formulários que serão criados na inicialização do aplicativo. Note
que o quadro mostra os dois formulários (FormPrincipal e FormSobre).

Available forms mostra os formulários que são usados pelo aplicativo, mas que não são
automaticamente criados na sua inicialização. É aqui que iremos colocar o FormSobre e,
eventualmente, todo formulário que não tenha necessidade de ser criado na inicialização do
aplicativo. Basta selecionar o FormSobre no quadro da esquerda e arrastá-lo para o quadro da
direita.

Observe que a linha Application.CreateForm(TFormSobre, FormSobre); não aparece mais na


unit Tutorial. Você terá que adicionar o código para sua criação quando houver a necessidade de
fazê-lo, como veremos a seguir.

6.4 Mais sobre a cláusula USES

Abra a janela Menu Designer do componente MainMenu1, escolha o item de menu


MenuAjudaSobre e clique na aba Events do Object Inspector. Clique duas vezes no evento
OnClick. Entre as linhas "begin"e "end" adicione o seguinte código:

Application.CreateForm(TFormSobre, FormSobre);

O código deverá ficar como nas linhas abaixo:

procedure
TFormPrincipal.MenuAjudaSobreClick(Sender:
TObject);

begin

Application.CreateForm(TFormSobre,
FormSobre);

end;
Execute o aplicativo. O Delphi exibirá uma dialog box como a mostrada abaixo:

Traduzindo:

O Form
'FormPrincipal'
faz referência
ao form
'FormSobre'
declarado na
unit 'UnitSobre'
que não está
em sua cláusula
USES. Você
deseja
adicioná-la?

Quando você faz referência em uma Unit2 a um formulário ou componente que foi declarado em
outra Unit1, você deve declarar o uso desta Unit1 na cláusula USES da Unit2. Quando isto não é
feito explicitamente, o Delphi, quando compilar o projeto, exibirá a dialog box acima; basta
clicar no botão "Yes".

Dê uma olhada no código da UnitPrincipal. Veja que apareceu uma nova cláusula USES após a
palavra reservada implementation. O Delphi faz isso e é bom você adquirir esta prática para
evitar um erro de compilação devido a referências circulares.

Agora execute o aplicativo, clique no menu 'Ajuda' e na opção 'Sobre o Tutorial'.

NADA OCORREU!!!

Não se espante. Nós apenas criamos o FormSobre; ainda há mais um pouco a fazer para exibi-lo.

6.5 Exibindo formulários (Show e ShowModal)

Para exibir um formulário, você pode utilizar dois métodos:

• Show - Experimente adicionar o seguinte código após a linha


Application.CreateForm(TFormSobre, FormSobre);

FormSobre.Show;

Execute o aplicativo e chame o FormSobre como explicado no ítem anterior. Pronto, ele
apareceu; só que este método tem um inconveniente. Clique em qualquer lugar do
FormPrincipal. Note que o FormSobre irá se esconder atrás do FormPrincipal. Isso pode dar a
ilusão ao usuário de que o FormSobre foi fechado e se ele chamar novamente o FormSobre i
Parte III
Aqui começa a Parte III do nosso Tutorial. Vamos acrescentar ao nosso aplicativo uma Splash
Screen.

1. Splash Screen

Splash Screen, normalmente, é aquela janela que aparece quando um aplicativo está sendo
inicializado (um exemplo é a tela de abertura do MS Word), a qual costuma conter informações
como o nome do aplicativo, nome do autor, versão, etc.

A Splash Screen pode ser exibida apenas enquanto o aplicativo está sendo inicializado ou pode
ser exibida durante um intervalo de tempo definido pelo desenvolvedor.

Inicialmente vamos criar uma Splash Screen que será exibida apenas enquanto o aplicativo está
sendo inicializado. Abra o projeto Tutorial. Adicione um novo Formulário ao projeto clicando no
botão "New Form". Altere as seguintes propriedades:

Name = FormSplash;
Height = 260;
Width = 400;
Position = poScreenCenter;
BorderStyle = bsNone.

Salve o projeto, e a nova Unit como UnitSplash.

Vá ao menu Project e clique no item Options. Na aba Forms da janela Project Options tire o
FormSplash do quadro Auto-create forms. O FormSplash só irá existir no carregamento do
aplicativo.

Agora vamos ao código. Abra o Code Editor e selecione unit Tutorial e acresecente o seguinte
código:

FormSplash := TFormSplash.Create(Application);
FormSplash.Show;
FormSplash.Refresh;

O código de Tutorial deverá ficar uses


como na figura ao lado: Forms,
UnitPrincipal in 'UnitPrincipal.pas'
{FormPrincipal},
UnitSobre in 'UnitSobre.pas' {FormSobre},
UnitSplash in 'UnitSplash.pas' {FormSplash};

{$R *.RES}

begin
FormSplash :=
TFormSplash.Create(Application);
FormSplash.Show;
FormSplash.Refresh;
Application.Initialize;
Application.CreateForm(TFormPrincipal,
FormPrincipal);
Application.Run;
end.

Vamos às explicações; para tanto visualize a unit UnitSplash:

TFORMSPLASH - TFormSplash é declarado na UnitSplash como sendo um tipo da classe


TForm;
FORMSPLASH - FormSplash é declarado como sendo uma variável do tipo TFormSplash; note
que essas duas declarações são automaticamente acrescentadas numa Unit associada a um
Formulário toda vez que você cria um novo Form.

Observando o código da figura acima acima você irá notar que o FormSplash não foi criado com
a declaração Application.CreateForm( ), como o foram o FormSobre e FormPrincipal. Se você
criasse o FormSplash dessa forma, o propósito do mesmo não seria atingido, já que o Delphi o
assumiria como o formulário inicial da aplicação.

Usando o método Create fará com que o Delphi crie e inicialize um novo formulário e o atribua
à variável FormSplash. O método Create pede um parâmetro que informa ao mesmo qual o
componente que possui o novo objeto. Em nosso caso FormSplash pertence à própria aplicação.

Nas duas linhas seguintes são usados o método Show para exibir o formulário e o método
Refresh para redesenhar o formulário na tela.

Para completar o trabalho temos que dizer ao aplicativo para liberar a memória utilizada pelo
FormSplash. Para tanto, vá para o FormPrincipal, clique na aba Events do Object Inspector e de
dois cliques no evento OnShow. Na janela de código acrescente a seguinte linha:
FormSplash.Free.

O código deverá ficar como mostrado abaixo:

procedure TFormPrincipal.FormShow(Sender: TObject);

begin
FormSplash.Free;
end;

Dessa forma, assim que o FormPrincipal for exibido, o FormSplash será encerrado e liberado da
memória.

Na aba Additional da Paleta de Componentes clique sobre o componente Image (provavelmente


o sexto componente) e clique num local qualquer do FormSplash. Altere as seguintes
propriedades deste componente:

AutoSize = True;
Left = 0;
Top = 0;
Na propriedade Picture, clique no botãozinho pontilhado e, na janela de diálogo Picture Editor
que abrir clique no botão load e procure a imagem Splash.jpg (esta imagem está logo abaixo;
salve-a em sua pasta Tutorial.
Altere também a propriedade Color do FormSplash para clNone.

Para testarmos, salve tudo, compile e execute o aplicativo. Note que o formulário Splash
apareceu e desapareceu rapidamente; não houve nada de errado. O que ocorre é que ele só é
exibido durante o tempo suficiente para que o aplicativo seja inicializado e carregado na
memória. Como o aplicativo carrega na inicialização apenas o formulário principal e o código
deste ainda é muito pequeno, então este processo é muito rápido. Seria diferente se fosse um
aplicativo como o MSWord, que além de ser enorme, carrega diversos objetos (tais como barras
de feramentas, macros, etc.) na sua inicialização.

Vamos ver agora como devemos fazer caso queiramos que o FormSplash tenha um tempo maior
de exibição, ou melhor, o tempo que desejarmos.

2. Windows API

As linguagens de programação costumam implementar funções que visam facilitar a vida do


programador, tais como funções de conversão de texto, número, data, funções de desenho de
linhas, círculos, polígonos e diversas outras. Porém, essas funções costumam fazer uso de outro
conjunto de funções que estão embutidas no Sistema Operacional. O WINDOWS contém um
conjunto extenso de funções denominado MAPI (Microsoft Application Programming
Interface). Em algumas situações pode ser útil fazer uso das funções da API, para tornar a
execução do código mais rápida; em outras situações, há necessidade de se usar as funções da
API simplesmente porque a linguagem de programação não oferece nada equivalente ao que se
quer fazer.

Embora o Delphi tenha um objeto chamado Timer, da classe TTimer, a qual encapsula as
funções de tratamento de tempo da API do Windows, nós usaremos diretamente a API para
medir um determinado intervalo de tempo.

3. Splash Screen com tempo de exibição

Vamos supor que queiramos que nossa Splash Screen seja exibida durante um intervalo fixo de 3
segundos, tempo razoável para a abertura de um aplicativo. Então teremos que marcar a hora em
que o FormSplash é exibido, contar o tempo até que se tenha passado o intervalo desejado e só
então prosseguir com a execução do aplicativo. Faremos isso utilizando uma função da API do
Windows chamada GetTickCount, que obtém o intervalo de tempo passado desde que o
Windows iniciou; esse intervalo é dado em milissegundos.
Para implementar esse código teremos que criar algumas variáveis que irão armazenar,
respectivamente, o Tempo Inicial em que o FormSplash é exibido e o intervalo de tempo que se
decorreu desde então. Então, na unit Tutorial, abaixo das declarações da claúsula uses, declare
uma nova seção, de variáveis, com a cláusula var; em seguida declare duas variáveis -
TempoInicial e Intervalo - como sendo do tipo Cardinal, como na figura abaixo:

uses A cláusula var marca a seção onde são feitas as


Forms, declarações de variáveis. Variáveis podem ser
UnitPrincipal in 'UnitPrincipal.pas' {FormPrincipal},
UnitSobre in 'UnitSobre.pas' {FormSobre},
do tipo Global, que são declaradas antes da
UnitSplash in 'UnitSplash.pas' {FormSplash}; seção implementation de uma Unit e são
acessíveis por qualquer Unit da aplicação, ou do
var tipo Local, que são declaradas dentro de
TempoInicial, Intervalo: Cardinal; procedures e funções e são acessíveis somente
{$R *.RES}
pelas mesmas.

Uma variável do tipo Cardinal pode armazenar um número inteiro compreendido no intervalo
que vai de 0 (zero) a 4.294.967.295 (quatro bilhões, duzentos e noventa e quatro milhões,
novecentos e sessenta e sete mil e duzentos e noventa e cinco), isto é, um número inteiro sem
sinal de 32 bits.

Outro detalhe é que como vamos usar uses


uma função da API do Windows, Forms, Windows,
UnitPrincipal in 'UnitPrincipal.pas'
devemos dizer ao Delphi como fazê- {FormPrincipal},
lo, isto é, onde está esta função. Para UnitSobre in 'UnitSobre.pas' {FormSobre},
isso devemos acrescentar à unit UnitSplash in 'UnitSplash.pas' {FormSplash};
Tutorial uma chamada à uma Unit já
compilada denominada Windows.
Para isso, devemos acrescentá-la na
cláusula uses. O código ficará como
na figura ao lado.

Agora que já declaramos as variáveis e dissemos ao aplicativo onde estão as chamadas às


funções da API do Windows, vamos colocar o código que irá medir o intervalo de tempo;
acrescente as linhas abaixo após a linha FormSPlash.Refresh:

TempoInicial := GetTickCount;
repeat
Intervalo := GetTickCount - TempoInicial;
until Intervalo>3000;

Na primeira linha é feita uma chamada à função GetTickCount, que retornará o tempo passado,
em milisegundos, desde a inicialização do Windows. Esse valor é armazenado na variável
TempoInicial.

Na segunda linha é utilizado o que se denomina um Loop ou Controle de Repetição. No Loop


acima um bloco de código é executado até que uma determinada condição seja satisfeita. A
condição no caso é que a variável Intervalo seja maior que 3.000 (ou 3 segundos, sendo o tempo
medido em milisegundos). O código executado dentro do Controle está na quarta linha, onde
novamente chama-se GetTickCount, obtém-se o seu valor e subtrai do mesmo o valor de
TempoInicial; o resultado é armazenado na variável Intervalo.
O código final deverá ficar como na figura a seguir:

Obs.: a
figura ao
lado foi
copiada e
colada
diretamente
do IDE do
Delphi. Note
que os blocos
de código
estão
indentados,
ou seja, não
se iniciam
sempre na
mesma
coluna e,
sim, com
uma certa
tabulação;
isto para que
haja uma
compreensão
melhor do
código.
Porém, no
texto em
HTML isso
não ocorre,
ficando tudo
na mesma
coluna, como
mostrado em
todos os
exemplos de
código
acima.
Todo bom
programador
sempre
organiza o
seu código
como da
forma ao
lado.

Pronto, salve tudo, compile e execute. Você irá observar que agora a Splash Screen será exibida
durante um tempo maior.
Parte IV
Aqui começa a Parte IV do nosso Tutorial.

1. Gerenciador de Projetos (Project Manager)

O IDE do Delphi tem uma série de ferramentas que a primeira vista só parecem poluir os menus
e barras de ferramentas. Entretanto, conforme você for se tornando um programador mais
experiente, irá ver que essas ferramentas tem suas utilidades, basta saber o momento mais
adequado de usá-las.

Uma dessas ferramentas é o Project Manager. Clique no menu View e depois clique na opção
Project Manager, irá aparecer uma janela como a da figura abaixo:

Nas linhas a seguir está uma parte da definição do Project Manager, tirado do Help do Delphi:

a - O Project Manager lhe permite combinar projetos em um grupo de projetos. Grupos de


projetos lhe permitem organizar e trabalhar em projetos interdependentes bem como em tarefas
separadas de uma aplicação multitarefa (multi-tiered) ou em DLLs e executam que trabalham
juntos.

b - Com o Project Manager, você pode facilmente visualizar de que forma todos os seus arquivos
de projetos (DPR) estão relacionados. Você também pode selecionar qualquer arquivo listado,
clicar com o botão direito do mouse e perfazer qualquer número de ações, como abrir, adicionar
e remover arquivos, e compilar seus projetos. Com o grupo de projetos, você pode adicionar e
remover projetos de um grupo de projetos e compilar todos os projetos do grupo ao mesmo
tempo.

c - O Delphi Project Manager exibe os Forms e as Units associadas ao seu projeto. Esses
arquivos estão listados na cláusula USES de seu arquivo de projeto (DPR). O Project Manager
também lhe habilita a navegar facilmente entre os arquivos enquanto você está desenvolvendo
seu aplicativo.
Para que a janela do Project Manager não se esconda atrás dos Forms ou da janela Code Editor,
arraste-a até que fique sobre a janela Object Inspector; dependendo da forma como você a
sobrepõe sobre a janela Object Inspector, ela pode ficar em uma das seguintes disposições:

ou uma variação da primeira e da segunda imagens, isto é, na parte de cima no caso da primeira
imagem ou a esquerda no caso da segunda imagem. O mais adequado é mante-lo como na
terceira imagem, pois desta forma você poderá facilmente alternar entre as janelas Project
Manager e Object Inspector, bastando clicar sobre os pequenos botões de direção que aparecem
na parte superior direita da janela.

Bom, talvez você esteja perguntando, mas qual é o proposito desta janela??? O proposito mais
imediato é permitir que você rapidamente navegue pelos Forms e Units de seu projeto como
explicado no item "c" acima. Para isto clique no sinal de mais "+" que aparece à esquerda de
"Tutorial.exe" e abra as demais ramificações que irão aparecer, o Project Manger ficará como a
figura a seguir:
Se você quiser visualizar um formulário ou
uma unit do seu projeto, basta dar dois
cliques sobre o referência do mesmo que
aparece no Project Manager. Teste!!!

Obs.: se você fechar o Delphi, na próxima


vez que você carregá-lo o Project Manager
não estará vísivel, você terá que executar
todo o procedimento acima novamente. Para
evitar esse trabalho, clique no menu Tools e
depois na opção Environment Options,
selecione a aba Preferences e no painel
Autosave options selecione o item Desktop.
Dessa forma todas as modificações que você
fizer no ambiente de desenvolvimento (IDE)
permanecerão quando você encerrar e
carregar novamente o Delphi.