Delphi

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 como na figura ao lado:

uses 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 Forms, UnitPrincipal in 'UnitPrincipal.pas' {FormPrincipal}, UnitSobre in 'UnitSobre.pas' {FormSobre}, UnitSplash in 'UnitSplash.pas' {FormSplash}; var TempoInicial, Intervalo: Cardinal; {$R *.RES}

A cláusula var marca a seção onde são feitas as declarações de variáveis. Variáveis podem ser do tipo Global, que são declaradas antes da seção implementation de uma Unit e são acessíveis por qualquer Unit da aplicação, ou do tipo Local, que são declaradas dentro de procedures e funções e são acessíveis somente 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 uma função da API do Windows, devemos dizer ao Delphi como fazêlo, isto é, onde está esta função. Para isso devemos acrescentar à unit 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.

uses Forms, Windows, UnitPrincipal in 'UnitPrincipal.pas' {FormPrincipal}, UnitSobre in 'UnitSobre.pas' {FormSobre}, UnitSplash in 'UnitSplash.pas' {FormSplash};

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.