Universidade Federal do Cear

Centro de Tecnologia
Departamento de Engenharia Qumica
Programa de Educao Tutorial MEC / SESu
PET Engenharia Qumica UFC

Realizao:

Apostila de
Apoio:

V: 1.0

SUMRIO
1. PROGRAMAO ORIENTADA A OBJETOS
1.1 Programao Orientada a Objeto (POO) x Programao Orientada a Evento (POE)...............3
1.2 Liguagem para POO..................................................................................................................4
1.3 Estrutura do cdigo no Code Editor..........................................................................................5

2. ELEMENTOS DO DELPHI
2.1 Elementos Visveis....................................................................................................................6
2.2 Elementos No Visveis.............................................................................................................8

3. FUNDAMENTOS DA LINGUAGEM OBJECT PASCAL

3.1 Sees de uma Unit1 .............................................................................................................10
3.2 Declarao de Variveis..........................................................................................................11
3.3 Tipos de Dados Predefinidos..................................................................................................11
3.4 Operadores Aritmticos.........................................................................................................12
3.5 Operadores Relacionais..........................................................................................................13
3.6 Operadores Lgicos................................................................................................................13
3.7 Bloco de Comandos................................................................................................................14
3.8 Estruturas Condicionais..........................................................................................................14
3.9 Estruturas de Repetio..........................................................................................................15
3.10 Funes e Procedimentos.....................................................................................................16

4. UTILIZANDO O AMBIENTE DO DELPHI 7 PARA A PROGRAMAO PROCEDURAL

4.1 Criando uma aplicao...........................................................................................................17
4.2 Implementando uma aplicao..............................................................................................18

5. EVENTOS, MTODOS E PROPRIEDADES

5.1 Eventos...................................................................................................................................20
5.2 Propriedades..........................................................................................................................21
5.3 Mtodos.................................................................................................................................21

6. ALGUNS EVENTOS E COMPONENTES DO DELPHI

6.1 Principais teclas de atalho da IDE do Delphi...........................................................................23

Pgina |1

6.2 Eventos mais utilizados no Delphi..........................................................................................23

6.3 Formulrio..............................................................................................................................25
6.4 Palheta Standard....................................................................................................................26

7. PLANEJANDO A SUA APLICAO

7.1 Planejando o nosso Aplicativo-Exemplo.................................................................................28
7.2 Padronizando a Nomenclatura dos Componentes.................................................................29

8. CRIANDO A APLICAO
8.1 Criando o Formulrio da Aplicao.........................................................................................30
8.2 Inserindo um Panel no Formulrio Principal..........................................................................31
8.3 Incluindo um Menu no Formulrio Principal..........................................................................33
8.4 Criando uma Caixa de Dilogo de Direitos Autorais...............................................................34
8.5 Criando um GroupBox para exibir as equaes do problema................................................35
8.6 Criando Botes para a manipulao do Formulrio...............................................................36
8.7 Criando Caixas de Texto para receber os dados do problema...............................................37
8.8 Gerando os Resultados do problema.....................................................................................40
8.9 Compatilhando Eventos..........................................................................................................41
8.10 Exibindo as Iteraes do problema.......................................................................................42
8.11 Criando um Arquivo com os Resultados do problema.........................................................43

Pgina |2

1. PROGRAMAO ORIENTADA A OBJETOS

1.1 Programao Orientada a Objeto (POO) x Programao Orientada a Evento (POE)

O primeiro passo para entender a Programao Orientada a Objeto (no resto do material
iremos cham-la apenas POO) saber fazer a diferenciao com a Programao Orientada a
Evento (POE). Para isso, devemos entender o significado das expresses orientao a objeto e
orientao a evento.
Quando um programa escrito em POE, o fluxo do programa determinado pelos eventos, os
quais o programa est preparado para responder. Por exemplo, ao digitar um valor no teclado,
o usurio oferece uma nova informao ao software, que ir gerar uma ao do programa,
levando para determinado ponto do cdigo.

A Programao Orientada a Evento muito antiga, se comparada POO, e possvel

encontrar muitos exemplos de linguagens de programao orientadas a evento, como a
linguagem C e Pascal.
A Programao Orientada a Objeto , pelo contrrio, bastante recente. Seu conceito foi
desenvolvido para facilitar a criao de programas utilizando interface grfica. As vantagens
mais visveis da POO so a facilidade de manipular os programas e o pouco uso de cdigo no
projeto, que facilita a manuteno do programa.
Na POO, os objetos so utilizados conforme os interesses do programador. O papel do adepto
da Programao Orientada a Objeto determinar quais objetos iro interagir entre si, e
maneira como ocorrer a interao. Mas o que so esses objetos que a POO pode manipular?

Pgina |3

Basta lembrar que qualquer programa de computador que voc j usou, como a calculadora,
por exemplo:

Na calculadora acima, todos os botes, o menu e o prprio espao onde eles esto so
objetos. Aprendendo a POO, ser possvel utilizar os objetos para criar programas parecidos
com esse.

1.2 Liguagem para POO

A linguagem Pascal surgiu como um linguagem de POE como tantas outras.Entretanto, ao
longo dos anos, passou a receber cada vez mais funes e procedimentos caractersticos da
POO, originando, gradualmente, uma nova linguagem de programao orientada a objeto.
Dessa forma surgiu o Object Pascal, a variante orientada a objeto da linguagem Pascal.
O Object Pascal , no entanto, uma linguagem hbrida, fornecendo suporte para programao
visual como tambm para programao orientada a objeto. Essa caracterstica torna a
transio de linguagens como C ou Pascal para o Delphi menos traumtica, j que muitas
tcnicas usadas na POE ainda so vlidas.
Comearemos nosso estudo da Linguagem Object Pascal apresentando alguns conceitos
novos, exclusivos da Programao Orientada a Objeto, que sero muito importantes para a
compreenso da programao em Delphi.
- Objetos: Os objetos so as ferramentas bsicas da POO. Consistem de modelos de objetos
reais, com seus estados e comportamentos. O estado de um objeto, em programao,
representado pelas variveis, e os comportamentos, atravs de mtodos ou funes. Apenas
um mtodo pode alterar um estado do objeto. A funcionalidade dos objetos s real quando
eles interagem entre si. Sozinho, cada objeto intil.
- Classes: Todos os objetos usados em um programa pertencem a uma categoria, a qual agrupa
diversos objetos. Por exemplo, ao criar um boto (voc aprender como nos captulos

Pgina |4

seguintes), voc est criando um objeto que pertence ao grupo que armazena todos os botes.
Esse grupo define todos os estados e comportamentos possveis para os objetos que lhe
pertencem. Os grupos de objetos so chamados classes, e os objetos so instancias dessas
classes.
- Herana: Uma considerao importante que quando tratamos de uma classe, esta,
provavelmente, trata-se de uma subclasse de uma classe maior. Sempre que uma classe fizer
parte de uma classe superior, haver a transmisso de mtodos e variveis do grupo maior
para o menor. No entanto, a classe inferior no est limitada as caractersticas da classe
superior, podendo ter seus prprios mtodos e variveis. Chamamos de herana essa relao
entre uma classe e suas subclasses.

1.3 Estrutura do cdigo no Code Editor

O cdigo do programa com o qual voc ir trabalhar composto por diversos blocos com
diferentes funes. So esses blocos:
1. Cabealho: Fica no incio do cdigo, e consta da palavra reservada unit seguida
do nome da unit. Ex: unit Calculadora.
2. Uses: Nessa seo so listadas todas as units que sero utilizadas no programa
ou na unit que est sendo trabalhada. Dessa forma, possvel usar variveis
declaradas em outras units, e fazer referencia a objetos de outras units, por
exemplo. Existem algumas units que aparecem automaticamente na seo de
uses. Essas units so essncias para o programa, e no podem ser retiradas.
3. Type: Nessa seo pode-se encontrar a lista de todos os objetos usados, e suas
respectivas classes. Tambm encontramos na seo types o cabealho de todos
os eventos associados aos objetos existentes naquela unit.
4. Var: Aqui a rea de declaraes do cdigo. Toda varivel que for usada precisa
ser declarada nessa seo, com exceo daquelas j declaradas em outras units
que constem na seo de uses.
5. Implementation: aqui que, finalmente, podemos escrever os mtodos e
procedimentos que iro determinar o funcionamento do programa. Na verdade,
boa parte do cdigo nessa regio no ser escrito pelo programador, mas isso
algo que ser visto no momento em que, de fato, comearmos a programar.
Obs: Para o nosso objetivo atual, no preciso entender a funo das sees Private e Public,
dessa forma no iremos discut-las nesse material.

Pgina |5

2. ELEMENTOS DO DELPHI

Agora o momento de conhecer o Ambiente de Desenvolvimento Integrado (IDE, do ingls

Integrated Development Environment) com o qual voc trabalhar. O Delphi possui diversos
elementos na sua interface, dos quais parte podem ser vistos ao abrir o IDE, enquanto outros
permanecem escondidos at que o usurio os abra.

2.1 Elementos Visveis

Os principais elementos visveis do Delphi so:
- Form: O Form (formulrio) o principal objeto a ser usado no desenvolvimento de um
programa. no formulrio que todos os outros objetos so dispostos, sendo ento essa a
interface pela qual o programa ir interagir com o usurio. Um programa no fica limitado a
apenas um formulrio, podendo ter um formulrio principal, que interage com vrios outros.

Para criar um novo formulrio existem duas maneiras:

1. Seguindo a seqencia: File New Form;
2. Atravs do repositrio de objetos, que ser mostrado mais frente.
- Editor de Cdigo: O Editor de Cdigo, como o nome indica, permite que o programador faa
alteraes no cdigo fonte do projeto. Todas as informaes relevantes ao programador,
como objetos (que aparecem descritos de suas propriedades) e seus respectivos eventos,
podem ser acessadas no Editor de Cdigo.
Quando um novo projeto aberto, gerado, automaticamente, um arquivo de cdigo (.pas).
Esse arquivo surge com o nome Unit1, que pode ser visualizado na tabulao do Editor de
Cdigo.
Voc deve notar que o Form e o Editor de Cdigo ocupam o mesmo espao, alternando em
destaque na tela. Uma forma rpida de alternar a visualizao entre um e outro atravs da
tecla F12.

Pgina |6

- Object Inspector: composto pela Pgina de Propriedades, Pgina de Eventos e Seletor de

Objetos. Seu papel providenciar a conexo entre o cdigo e a interface do programa.

Na pgina de propriedades possvel alterar as caractersticas dos objetos presentes no

formulrio, inclusive do prprio formulrio, para melhor se ajustarem s suas necessidades. A
pgina de eventos, que fica ao lado, por sua vez, responsvel por manipular os eventos
associados aos objetos, permitindo tambm uma rpida navegao pelo cdigo.
O Seletor de objetos uma ferramenta que lista todos os objetos existentes no projeto e seus
respectivos tipos. Com ele possvel encontrar rapidamente qualquer objeto em um
formulrio.

Pgina |7

- Palhetas: As palhetas so, basicamente, o local onde os objetos ficam listados para que
possam ser selecionados e usados pelo programador. As palhetas foram separadas por grupos
de funcionalidade, como se pode ver abaixo:

Existem trs formas de selecionar um objeto e transport-lo para o formulrio:

1. Clicando duplamente no cone do objeto (isso o transportar direto para o centro do
formulrio);
2. Clicando no cone e clicando dentro do formulrio, no local onde voc quer colocar o
objeto;
3. Clicando no cone enquanto a tecla Shift estiver pressionada (dessa forma voc pode
clicar vrias vezes no formulrio adicionando o objeto vrias vezes).
importante lembrar que existem componentes que no sero visveis durante a execuo do
programa (componentes no-visuais). Esses objetos so chamados DDE (Dynamic Data
Exchange).
- Speed Bar: a barra que contm os botes mais utilizados quando no processo de criao do
programa, fornecendo rpido acesso aos mesmos.

2.2 Elementos No Visveis

Os principais elementos no visveis do Delphi so:
- Project Manager: O Project Manager uma ferramenta que contm a lista de todas as units e
formulrios, onde os mesmo podem ser adicionados, eliminados e organizados. Existem trs
maneiras de acessar o Project Manager. So elas:
1. Acessando Project Manager no menu View;
2. Clicando no boto da Speed Bar correspondente ao Project Manager;
3. Usando o atalho Ctrl+Alt+F11.

Pgina |8

- Repositrio de Objetos: No Repositrio de Objetos constam vrios objetos, alguns dos quais
no aparecem nas palhetas. Para acess-lo basta seguir a seqncia File-New-Other...

- Object TreeView: Logo acima do Object Inspector, aparece o Object TreeView, onde
apresentada uma lista de todos os objetos que esto sendo utilizados no programa. A
princpio, pode parece que no h utilidade alguma para esse componente do Delphi, mas ao
trabalhar com programas complexos que envolvam vrios forms, o Object TreeView facilita
muito o trabalho de ter que encontrar um objeto.

Pgina |9

3. FUNDAMENTOS DA LINGUAGEM OBJECT PASCAL

3.1 Sees de uma Unit

No cdigo gerado por uma unit, temos:
unit Unit1;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs;
type
TForm1 = class(TForm)
private
{ Private declarations }
public
{ Public declarations }
end;
var
Form1: TForm1;
implementation
{$R *.dfm}
end.

Como j comentamos anteriormente, inicialmente, observa-se a palavra reservada unit

seguida do nome do arquivo em que a unit est armazenada. Na linha seguinte que define o
nome da unit, tem-se a palavra-chave interface, onde so declarados os tipos de dados,
classes, variveis, funes e procedimentos que podem ser acessados por outras units. Na
seo implementation so declarados os tipos de dados, classes, variveis, funes e
procedimentos que no podem ser acessados por outras units. Nessa seo tambm so
implementados as funes e procedimentos cujo cabealho declarado na seo Interface.
A palavra uses outra palavra reservada da Linguagem Object Pascal e define as units que
sero utilizadas pela unit corrente.

Comentrios
- Comentrios de uma linha: definido por duas barras inclinadas. A partir destas duas barras,
tudo o que for escrito na mesma linha ser tratado como um comentrio, e durante a
execuo do programa ser desprezado.
Exemplo:
// Mtodo de Runge Kutta

P g i n a | 10

- Comentrios de mltiplas linhas: Para comentrios de mltiplas linhas, colocamos o texto

requerido entre chaves.
Exemplo:
{ isto um comentrio
de mltiplas linhas}

3.2 Declarao de Variveis

A declarao de uma varivel de um determinado tipo feita na seo var de uma unit ou, no
caso de se desejar criar uma varivel local, na seo var de uma funo ou um procedure. A
declarao de variveis e vetores segue a seguinte sintaxe:
Var
Nome_da_variavel1, Nome_da_variavel2,...: Tipo_da_variavel;
Nome_do_vetor: array[i1..i2] of tipo_da_variavel;

Onde i1 e i2 determinam os valores mnimo e mximo do ndice, respectivamente.

Atribuindo um Valor a uma Varivel

Na Linguagem Object Pascal, o operador de atribuio :=, logo, para atribuirmos um valor a
uma dada varivel, seguimos a seguinte sintaxe:
Nome_da_variavel:= valor;

3.3 Tipos de Dados Predefinidos

- Variveis Inteiras:

P g i n a | 11

- Variveis Reais:

- Variveis Booleanas:

3.4 Operadores Aritmticos

Na Linguagem Object Pascal, realizamos operaes aritmticas sobre variveis utilizando os
operadores aritmticos apresentados na tabela abaixo.

Para realizarmos uma operao aritmtica entre duas variveis e atribuirmos o resultado a
uma terceira varivel, usamos a seguinte sintaxe:
variavel3:= variavel1 op variavel2; (op um dos operadores aritmticos)

A precedncia dos operadores segue uma ordem, essa ordem pode ser alterada pelo uso de
parnteses.

P g i n a | 12

Operadores com maior precedncia so executados antes dos de menor precedncia.

Operadores com mesma ordem de precedncia em uma expresso so executados da
esquerda para a direita.
Exemplo:
x:= 8 + 5 * 4;

Atribui o valor 28 para a varivel x.

Para que a soma seja executada antes da multiplicao, inclumos os parnteses:
x:= (8 + 5) * 4;

Nesse caso, a varivel x armazenar o valor 52.

3.5 Operadores Relacionais

Para relacionarmos dois operandos, por meio de uma condio, utilizamos os operadores
relacionais apresentados na tabela abaixo:

3.6 Operadores Lgicos

Existem situaes em que uma condio a ser testada , na realidade, uma combinao de
duas ou mais condies. Para testarmos uma condio composta, utilizamos os operados
lgicos apresentados na tabela abaixo:

P g i n a | 13

A tabela abaixo mostra o resultado de expresses em que so usados operadores lgicos.

3.7 Bloco de Comandos

Um bloco de comandos constitudo por um conjunto de linhas de cdigo, que comea com a
palavra reservada begin e termina com a palavra reservada end, seguida de um ponto-evrgula (;). Para o bloco de comando, temos a seguinte sintaxe:
begin
{Instrues do bloco de comandos}
end;

A palavra reservada end deve sempre ser seguida por um ponto-e-vrgula, exceto quando vier
aps a palavra reservada else, em uma estrutura condicional do tipo If-then-else, ou quando
encerrar uma unit (o end que encerra uma unit seguido por um ponto).

3.8 Estruturas Condicionais

As estruturas condicionais encontradas na Linguagem Object Pascal so a if-then-else e a case
of, com sintaxes descritas a seguir.
- Estrutura condicional If-then-else:
if (condio)
then
begin
{Bloco de comandos executados se a codio for verdadeira}
end
else
begin
{Bloco de comandos executados se a codio for falsa}
end;

Caso no seja necessria a execuo de qualquer comando se a condio for falsa, basta
suprimir o trecho de cdigo correspondente ao else, como mostrado a seguir.
if (condio)
then
begin
{Bloco de comandos executados se a codio for verdadeira}
end;

P g i n a | 14

Nos casos em que um bloco de comandos formado por uma nica linha de cdigo, podem-se
suprimir as palavras Begin e end, como mostrado a seguir.
if (condio)
then
{Bloco de comandos executados se a codio for verdadeira}
else
{Bloco de comandos executados se a codio for falsa};

Ou
if (condio)
then
{Bloco de comandos executados se a codio for verdadeira};

- Estrutura condicional case of:

case <expresso> of
Valor_1:
<Bloco de comandos>
Valor_2:
<Bloco de comandos>
..........................
Valor_n:
<Bloco de comandos>
else:
<Bloco de comandos>
end;

Nesse caso, se a expresso testada for igual a um dos valores especificados, ser executado o
bloco de comandos a ele correspondente. Caso nenhum desses valores seja igual ao definido
pela expresso testada, o bloco de comandos else ser executado.

3.9 Estruturas de Repetio

As estruturas de repetio encontradas na Linguagem Object Pascal so os Laos For, Laos
While e Laos Repeat, com sintaxes apresentadas a seguir.
- Laos For:
for var_contador:= valor_inicial to valor_final do
<bloco de comandos>

Caso se queira que o contador assuma valores decrescentes, deve-se usar a seguinte sintaxe:
for var_contador:= valor_inicial downto valor_final do
<bloco de comandos>

P g i n a | 15

- Laos While:
while <condio> do
bloco de comandos>

- Laos Repeat:
repeat
<bloco de comandos>
until condio;

3.10 Funes e Procedimentos

O conceito de procedimentos e funes advm da necessidade de se subdividir um sistema
complexo em unidades menores, denominadas sub-rotinas.
- Procedimentos: Normalmente, procedimentos so usados para dividir um programa em
blocos menores de cdigos e para armazenar trechos de cdigos utilizados diversas vezes no
programa.
A definio de um procedimento na Linguagem Object Pascal segue a seguinte sintaxe:
procedure nome_do_procedimento (parmetro_1: tipo_1, ..., parmetro_n: tipo_n)
var
{declarao de variveis locais ao procedimento}
begin
{corpo do procedimento}
end;

- Funes: Uma funo muito semelhante a um procedimento, com a diferena de que a

chamada a uma funo deve retornar um valor como resultado. Alm disso, o resultado de
uma chamada a uma funo pode ser diretamente incorporado a uma expresso aritmtica.
A definio de uma funo na Linguagem Object Pascal segue a seguinte sintaxe:
function nome_da_funo (par_1: tipo_1, ..., par_n: tipo_n): tipo_de_retorno;
var
{declarao de variveis locais funo}
begin
{corpo da funo}
result:= valor;
end;

P g i n a | 16

4. UTILIZANDO O AMBIENTE DO DELPHI 7 PARA A PROGRAMAO

PROCEDURAL

O ambiente de desenvolvimento do Delphi 7 capaz de desenvolver aplicaes utilizando o

Pascal como linguagem de programao procedural. Esses tipos de aplicaes no tero
formulrios (janelas), botes de comando ou qualquer outro tipo de componente da interface
padro do ambiente Windows, sendo definidas pelo Delphi 7 como aplicaes do tipo console
(sero executadas em uma janela padro do DOS).

4.1 Criando uma aplicao

Para criar uma aplicao do tipo console, proceda da seguinte forma:
1. Selecione New/Other do menu File do Delphi 7, para exibir a caixa de dilogo New
Items.
2. Selecione o item Console Application na pgina New desta caixa de dilogo, conforme
indicado na figura a seguir.
3. Selecione o boto Ok, para fechar a caixa de dilogo.

A aplicao do tipo console ser criada com um nico arquivo (arquivo de projeto, com
extenso dpr), e cujo cdigo gerado reproduzido a seguir.
program Project1;
{$APPTYPE CONSOLE}
uses
SysUtils;
begin
{ TODO -oUser -cConsole Main : Insert code here }
end.

P g i n a | 17

4. Salve o seu projeto com o nome MEuler, usando o item Save Project As do menu File.

4.2 Implementando uma aplicao

Como exemplo, vamos implementar uma aplicao para a resoluo de EDOs utilizando o
Mtodo de Euler.
O algoritmo do mtodo est apresentado abaixo:
Dados: y' = f(x,y); y(0); x(0); h = passo; n =n de iteraes
Para i = 1 at n faa
Incio
y y + h*f(x,y)
xx+h
Fim.
O algoritmo deve ser implementado no bloco de comandos destinado ao cdigo, exceto a
declarao de variveis, classes, funes e procedimentos, que deve ser feita conforme
descrito anteriormente. Um exemplo de como o algoritmo pode ser implementado na
Linguagem Object Pascal, mostrado abaixo:
program MEuler;
{$APPTYPE CONSOLE}
uses
SysUtils,Math,Windows;
var y,x,h:real;
i,n:integer;
function f(x,y:real):real;
begin
f := power(x,2);
end;
begin
{ TODO -oUser -cConsole Main : Insert code here }
writeln('Resolucao de EDOs utilizando o Metodo de Euler');
writeln('');
writeln('Entrada de Dados');
write('y[0] = ');
readln(y);
write('x[0] = ');
readln(x);
write('h = ');
readln(h);
write('n = ');
readln(n);
for i:=1 to n do
begin
y := y + h*f(x,y);
x := x + h;
end;
Writeln;
writeln('Solucao = ',y:0:3);

P g i n a | 18

Readln;
end.

Execute esta aplicao, e ver a janela mostrada na figura a seguir.

Posteriormente criaremos um programa com a mesma finalidade, porm em POO

(Programao Orientada a Objetos), ou seja, criando assim formulrios (janelas), botes de
comando outros tipos de componentes de interface grfica.

P g i n a | 19

5. EVENTOS, MTODOS E PROPRIEDADES

5.1 Eventos
Os programas feitos em Delphi so orientados a eventos. Eventos so as aes normalmente
geradas pelo usurio e que podem ser reconhecidas e tradadas pelo programa. Por exemplo,
Clicar o mouse sobre um componente, focar um componente, mover o mouse sobre um
componente, entre outros.
Os eventos podem ser tambm gerados pelo windows. Existem eventos associados ao
formulrio e cada componente inserido neste. Por exemplos, o OnShow o evento que ocorre
quando mostramos o formulrio na tela, ao componente boto est ligado o evento OnClick,
que ocorre quando damos um click com o mouse sobre o boto.
- Eventos comuns ao formulrio e aos componentes:
OnClick: ocorre quando o usurio clica o objeto.
OndblClick: ocorre quando o usurio da um duplo clique.
OnKeyDown: ocorre quando uma tecla pressionado e o objeto tem o foco.
OnKeyUp: ocorre quando o usurio solta uma tecla enquanto o objeto tem o foco.
OnKeyPress: ocorre quando usurio da um clique numa tecla ANSI.
OnMouseDown: ocorre quando o usurio pressiona o boto do mouse.
OnMouseUp: ocorre quando o usurio solta o boto do mouse.
OnMouseMove: ocorre quando o usurio move o ponteiro do mouse.
- Rotinas que Respondem a Eventos:
Cada evento gera uma procedure, aonde voc deve inserir as linhas de cdigo que envolvem
este evento. Por exemplo, o evento OnClick, que gerado ao clicarmos em um boto chamado
BTNSair, cria a procedure:
Procedure TForm1.BTNSairClick(Sender: Tobject);

onde TForm1 o objeto TForm que contm o boto BTNSair, e Sender um objeto Tobject
que representa o componente que deu origem ao evento. Se voc quiser inserir uma rotina
que trate um determinado evento de um componente, faa o seguinte:
1. Clique sobre o componente;
2. No Object Inspector, seleciona a pgina Events;
3. D um duplo clique sobre o evento para o qual quer inserir o cdigo;
4. Entre no editor de cdigo e escreva as linhas de cdigo.

P g i n a | 20

Exemplo:
Procedure TForm1.BTNSairClick(Sender: Tobject);
begin
Form1.Close;
end;

Obs.: Escreva seu cdigo entre o begin e o end, se por acaso voc quiser retirar o evento e o
componente, retire primeiro os eventos do componente removendo somente o cdigo que
voc colocou e depois o componente; os resto dos procedimentos o DELPHI tira para voc.

5.2 Propriedades
Uma propriedade representa um atributo de um objeto. No Delphi todas as coisas que
aparecem no Object Inspector so propriedades, inclusive os eventos, porm sua referncia
a um mtodo.
Como vimos, eventos podem estar associados a modificaes em propriedade de componente
e formulrio, ou seja, voc pode modificar propriedades de formulrios e componentes
durante a execuo do sistema. Para isso, voc dever usar a sintaxe:
<componente>.<propriedade>;

Por exemplo, para modificar a propriedade text de uma caixa de edio Edit1 para Bom Dia
faa:
Edit1.Text := Bom Dia;

Se a propriedade do componente tiver subpropriedades, para acessa-ls, utilize a seguinte

sintaxe:
<componente>.<propriedade>.<subpropriedade>

Por exemplo, para modificar a subpropriedade Name, referente propriedade fonte de uma
caixa de edio Edit1, para Script, faa:
Edit1.Font.name := Script;

Obs.: Verifique o tipo da propriedade para antes de mandar o valor, consultando no Objetc
Inspector.

5.3 Mtodos
So procedures ou funes embutidas nos componentes e formulrios, previamente definidas
pelo Delphi.

P g i n a | 21

- Exemplos de mtodos:
Show : Mostra um formulrio;
Hide : Esconde um formulrio mais no o descarrega;
Print : Imprime um formulrio na impressora;
SetFocus : Estabelece o foco para um formulrio ou componente;
- Chamado de mtodos como resposta a eventos:
Um evento pode gerar a chamada para um mtodo, ou seja, uma subrotina previamente
definida para um componente.
No cdigo, para utilizar um mtodo, use a seguinte sintaxe:
<nome do objeto>.<mtodo>

Por exemplo, clicar em um boto pode dar origem ao evento Show de outro formulrio,
mostrando este novo formulrio na tela:
Form2.show;

P g i n a | 22

6. ALGUNS EVENTOS E COMPONENTES DO DELPHI

6.1 Principais teclas de atalho da IDE do Delphi

- F9: Executar;
- F8: Executa passo a passo sem entrar em sub-rotinas;
- F7: Executa passo a passo entrando em sub-rotinas;
- CTRL+F9: Compila;
- CTRL + SHIFT + (um nmero de 0 a 9 ): marca uma posio no texto;
- CTRL + (um nmero de 0 a 9 ): vai para uma posio previamente marcada;
- F11: Painel de propriedades;
- F12: Comuta entre o formulrio e a tela de codificao;
- CTRL+F2: pra a execuo de um programa;
- CTRL+F1: Executa o HELP a respeito do texto onde o cursor estava posicionado.

6.2 Eventos mais utilizados no Delphi

- OnKeyPress: Use este evento para capturar as teclas pressionadas sobre o objeto. Este
evento captura apenas teclas da tabela ASC II, utilizando para isso uma varivel KEY do tipo
char. Teclas como shift ou F1 no so possveis de serem capturadas neste evento. No
possvel tambm capturar seqncias de teclas, como Shift+A. Para estes casos utilize o evento
OnKeyDown ou OnKeyUp. A varivel KEY representa o caractere ASC II da tecla pressionada.
Para anularmos a tecla pressionada atribumos #0 ao parmetro KEY.
Exemplo:
// neste exemplo capturamos a tecla ENTER atravs de seu caractere ASC II
procedure TForm1.Edit1KeyPress(Sender: TObject; var Key: Char); // evento de
um TEdit
begin
if key = #13 then begin
showmessage('Voc pressionou ENTER.');
Edit2.setfocus; // manda o foco para o componente edit2
end;
end;
// neste exemplo capturamos teclas atravs de seu valor e no se seu n na
tabela ASC II

P g i n a | 23

procedure TForm1.Edit1KeyPress(Sender: TObject; var Key: Char);

begin
if key in ['a' .. 'z', 'A'..'Z'] then begin // permite apenas as letras de a
Z maisculas e minsculas
showmessage('Voc pressionou a tecla: [' + key + ']' ); // exibe a tecla
pressionada
end;
end;

- OnKeyDown: Este evento faz tudo o que o evento onKeyPress faz porm capaz de processar
sequncias de teclas, como CTRL+Z por exemplo. Tambm capaz de capturar teclas como
TAB, F1, CAPS LOCK, NUM LOCK, INSERT, etc... A varivel KEY do tipo word (um inteiro que
no aceita negativo). Para anularmos a tecla pressionada atribumos 0 ao parmetro KEY.
Exemplo:
// neste exemplo exibimos o n da tecla pressionada. Ideal para se descobrir o
n de uma tecla.
procedure
TForm1.Edit2KeyDown(Sender:
TShiftState);

TObject;

var

Key:

Word;

Shift:

begin
showmessage( 'Voc pressionou a tecla n: ' + intToStr(key) );
end;

- OnClick: Este evento disparado sempre que clicamos sobre o objeto.

Exemplo:
procedure TForm1.FormClick(Sender: TObject);
begin
showmessage('Voc clicou no formulario!');
end;

- OnDblClick: Este evento disparado sempre que executamos um duplo clique sobre o objeto
em questo. Este evento no ocorrer se o evento OnClick tambm foi programado.
Exemplo:
procedure TForm1.FormDblClick(Sender: TObject);
begin
showwmessage('Voc deu um duplo clique no formulario!');
end;

P g i n a | 24

- OnMouseMove: Este um evento pouco utilizado em aplicaes normais (cadastros p.ex.).

Ele disparado sempre que o mouse movimentado sobre o objeto. possvel ainda saber o
status de teclas como CTRL, ALT, SHIFT e etc. alm das posies X e Y do mouse.
Exemplo:
procedure TForm1.Edit1MouseMove(Sender: TObject; Shift: TShiftState; X, Y:
Integer);
begin
showMessage('Tira esse mouse daqui!');
end;

- OnEnter: Este evento disparado quando o objeto recebe o foco.

Exemplo:
procedure TForm1.Edit1Enter(Sender: TObject);
begin
(sender as TEdit).color := clYellow; // altera a cor do objeto passado no
parmetro SENDER
end;

- OnExit: Este evento disparado quando o objeto perde o foco.

Exemplo:
procedure TForm1.Edit1Exit(Sender: TObject);
begin
(sender as TEdit).color := clWhite; // altera a cor do objeto passado no
parmetro SENDER
end;

6.3 Formulrio
- Principais eventos do formulrio:
Os formulrios (objeto Form) so os
pontos
centrais
para
o
desenvolvimento Delphi. Voc se
utilizar deles para desenhar sua
comunicao com o usurio,
colocando e organizando outros
objetos. Ele tem diversos eventos,
porm os principais so:

P g i n a | 25

OnClose: Este evento ocorre sempre ocorre uma tentativa de se fechar o formulrio,
por exemplo, ao executar-se o mtodo close. Podemos neste evento, por exemplo, fechar as
tabelas utilizadas.
OnShow: Este evento ocorre sempre que o formulrio exibido. Por exemplo, ao
executar-se o mtodo show. Podemos neste evento, por exemplo, limpar os componentes da
tela, inicializar variveis, abrir tabelas e etc.
Exemplo:
procedure TForm1.FormShow(Sender: TObject);
begin
showmessage('Exibindo o formulrio.');
end;

6.4 Palheta Standard

- TMainMenu: Este componente utilizado para criar menus. Sua utilizao bem simples.
Coloque um na tela e execute um duplo-clique para comear a criar o menu. Todos os itens do
menu so objetos do tipo TmenuItem e possuem o evento onClick.
- TPopupMenu: Este componente permite a exibio de um menu popUp de forma simples.
Coloque um na tela e associe-o propriedade popupMenu dos objetos (nem todos a
possuem). Para criar o menu d um duplo-clique sobre o objeto popupMenu e monte-o da
mesma forma que no objeto TMainMenu.
- TLabel: Utilizado para exibir uma mensagem no formulrio.
- TEdit: Este componente permite que o usurio entre com um texto. Sua principal
propriedade a text que armazena o que foi digitado.
- TMemo: Utilizado para digitao de texto onde necessrio mais que uma linha. Sua
principal propriedade a lines, onde possvel acessar o texto digitado atravs da propriedade
text ou ento linha por linha atravs de lines[linha]. Para adicionar um texto podemos utilizar o
mtodo lines.add() ou mesmo atravs de text.
- TButton: Este boto no permite a utilizao de imagens.
- TCheckbox: Este objeto armazena o valor de ligado ou no em sua propriedade boolean
denominada checked.
- TRadiobutton: Este objeto utilizado quando possumos vrias opes, porm apenas uma
deve ser selecionada. Sua principal propriedade a checked que indica se objeto foi
selecionado ou no.
- TListbox: Este objeto permite a seleo de uma ou mais opes.

P g i n a | 26

- TCombobox: Este objeto utilizado quando possumos vrias opes, porm apenas uma
deve ser selecionada. Utilize a propriedade ItemIndex para saber se alguma opo foi
selecionada. Esta propriedade inicia do 0 e -1 indica que nada foi selecionado.
- TRadioGroup: Este componente similar ao TRadioButton, porm seus itens so criados
atravs da propriedade itens, onde cada linha indica uma nova opo.
- TGroupbox: Utilizado para agrupar componentes.
- TPanel: Utilizado para agrupar componentes.

P g i n a | 27

7. PLANEJANDO A SUA APLICAO

Um bom planejamento indispensvel ao sucesso de um empreendimento. Antes de iniciar a

codificao e o desenho da interface da sua aplicao, importante que voc reserve um
tempo para o seu planejamento.
Graas a facilidade e rapidez com que se pode construir a interface de uma aplicao com o
Delphi 7, muitos programadores comeam a desenhar a interface sem se preocupar com um
planejamento prvio da sua aplicao e, no meio do processo de desenvolvimento, descobrem
que muita coisa poderia ser modificada. A fim de evitar esse tipo de problema,
recomendvel que se reserve algum tempo para discutir aspectos importantes da aplicao.

7.1 Planejando o nosso Aplicativo-Exemplo

O aplicativo-exemplo que ser desenvolvido nessa apostila ser destinado a resolver o
problema da concentrao, em um dado instante t, em um tanque de misturas que possui uma
corrente de entrada e uma de sada.

- Equacionando o problema: Para resolver este problema, iremos supor que a quantidade de
soluto (q) no criada nem destruda dentro do tanque. Portanto, as variaes na
quantidade de soluto devem-se apenas, aos fluxos de entrada e sada no tanque.
Matematicamente, a taxa de variao de q no tanque (dq/dt) igual diferena entre a taxa de
entrada e a taxa de sada, ou seja:
dq/dt = taxa de entrada taxa de sada
Sendo C e C as concentraes das correntes de entrada e sada, respectivamente, e Q e Q as
vazes das corretes de entrada e sada, respectivamente, temos:
dq/dt = taxa de entrada taxa de sada = Q.C - Q.C
Para C, temos que:

Logo:

P g i n a | 28

Ou seja, temos que a equao que rege o problema uma equao diferencial. Para
resolvermos numericamente tal equao diferencial, precisamos escolher um mtodo
matemtico. O Mtodo de Euler ser o mtodo utilizado para a resoluo da equao, para
que possamos aproveitar parte do cdigo j desenvolvido anteriormente.
Resumidamente, podemos listar os parmetros que sero recebidos pelo aplicativo-exemplo e
os parmetros que sero retornados pelo mesmo.
Nossa aplicao dever receber:
1. Os parmetros da equao (Q, C, Q e V)
2. Os parmetros do mtodo (x(0), y(0), h, n)
Nossa aplicao dever fornecer:
A Concentrao (C) e o Volume (V) do tanque no instante t.
Com base nos parmetros que devero ser utilizados e nos resultados que sero gerados,
iremos escolher componentes onde o usurio nos fornecer os dados requeridos, para que
possam ser feitos os clculos necessrios, e componentes que retornem, para o usurio, os
dados gerados.

7.2 Padronizando a Nomenclatura dos Componentes

Ao criar a interface da sua aplicao, voc incluir diversos componentes nos vrios
formulrios que a compem. Cada formulrio, controle ou componente ter um nome pelo
qual ser referenciado no cdigo da aplicao.
Quando voc inicia uma nova aplicao, o Delphi 7 cria automaticamente um formulrio
denominado Form1. Se voc criar um segundo formulrio, ele ser denominado Form2 e assim
por diante. Quando se insere componentes em um formulrio, ocorre a mesma coisa.
Para facilitar as suas tarefas como um desenvolvedor de aplicaes, voc deve estabelecer
uma conveno para os nomes dos seus formulrios e componentes. Pode ser qualquer uma,
desde que seja de fcil entendimento.

P g i n a | 29

8. CRIANDO A APLICAO

8.1 Criando o Formulrio da Aplicao

Sempre que iniciamos uma nova aplicao, o Delphi 7 cria um formulrio vazio, que pode ser
usado como formulrio principal da aplicao.
Como todo objeto, um formulrio possui propriedades, mtodos e eventos.
Dentre as propriedades de um formulrio, podem-se destacar:
BorderStyle: Determina o estilo de borda do formulrio.
BorderIcons: Determina os cones a serem exibidos na extremidade superior direita da
barra de ttulos do formulrio.
Caption: Armazena o texto exibido na barra de ttulos do formulrio.
Color: Define a cor do formulrio.
Font: Define a fonte do texto exibido no formulrio.
Height: Define a dimenso vertical (altura) de um formulrio.
Icon: Define o cone a ser exibido quando o formulrio for minimizado.
Left: Define a posio de um formulrio, em relao extremidade esquerda da tela.
Menu: Define o menu associado ao formulrio.
Name: Define o nome pelo qual o objeto referenciado no cdigo da aplicao.
PopupMenu: Define o menu flutuante associado ao formulrio.
Position: Define o posicionamento do formulrio na tela.
Windowstate: Determina o estado de exibio do formulrio (maximizado, minimizado
ou normal).
Top: Define a posio de um formulrio, em relao extremidade superior da tela.
Vamos iniciar a criao da interface visual da nossa aplicao. Para isso, vamos criar o nosso
projeto:
1. No menu File selecione Save as... e salve a unit com o nome UnitPrincipal e o projeto
com o nome Project_TM.
2. Selecione o formulrio principal, inicialmente denominado Form1, e atribua os
seguintes valores para as principais propriedades do formulrio principal, diretamente
no Object Inspector:

P g i n a | 30

BorderStyle: bsSingle (esse estilo impede que o formulrio seja redimensionado).

BorderIcons: [biSystemMenu, biMinimize].
Caption: Tanque de Mistura.
Color: clMenu.
Height: 500.
Name: FormPrincipal.
Position: poScreenCenter.
Width: 600.

8.2 Inserindo um Panel no Formulrio Principal

O Componente Panel usado para criar um painel no formulrio. Para adicion-lo, execute os
seguintes procedimentos:
1.
2.
3.
4.

Selecione o componente Panel na pgina Standard da paleta de componentes.

Clique com boto esquerdo do mouse sobre o formulrio.
O componente ser exibido no formulrio.
Posicione e redimensione o componente conforme a figura a seguir.

5. Atribua os seguintes valores para as propriedades do Panel:

BevelInner: bvRaised.
BevelWidth: 2.
BorderWidth: 1.
Caption: Deixar em branco.
Color: clMenuBar.
Height: 300.
Width: 280.

P g i n a | 31

6. Selecione o componente Image na paleta Additional e coloque-o no Panel.

7. Para definir a imagem a ser exibida, selecione as reticncias da propriedade Picture.
Ser exibida a caixa de dilogo Picture Editor.
8. Selecione o boto Load desta caixa de dilogo e procure pela imagem
tanquemistura.jpg, clique em Abrir e, na Picture Editor, em Ok.
9. Atribua os seguintes valores para as propriedades do Image:
Autosize: true.
Left: 16.
Top: 16.
10. Insira seis componentes Label no Panel, altere a propriedade Name e disponha-os
conforme a figura abaixo.
Seu formulrio deve ficar com o aspecto mostrado na figura a seguir.

11. Com a tecla shift pressionada, selecione os seis componentes Label e, na propriedade
Font, clique nas reticncias. Na caixa de dilogo Fonte, escolha a fonte arial, estilo
negrito e clique em Ok.

P g i n a | 32

8.3 Incluindo um Menu no Formulrio Principal

A incluso de um menu feita por meio da insero de um componente MainMenu no
formulrio principal.
O componente MainMenu est situado na pgina Standard da paleta de componentes e
fornece acesso a um editor de menus.
Para inserir um componente MainMenu no formulrio principal da aplicao, execute os
seguintes procedimentos:
1. Selecione o componente MainMenu, na pgina Standard da paleta de componentes e
clique sobre o formulrio, para que o componente seja inserido. O componente
MainMenu um componente no-visual, isto , no estar visvel na execuo do
programa; nesse caso, portanto, a sua posio no formulrio no de grande
importncia.
2. Usando o Object Inspector, altere a propriedade Name do componente para
MenuPrincipal.
3. D um duplo clique sobre o componente MainMenu. O editor de menus exibido,
com o primeiro menu selecionado, pronto para ser editado.
4. Selecione o Object Inspector e altere os valores das propriedades Name e Caption do
objeto que est em destaque para MenuInicio e &Incio, respectivamente.
5. Clique no espao criado do lado do Menu Incio e defina os valores das propriedades
Name e Caption como MenuSobre e &Sobre, respectivamente.
6. Para criar itens de menu, selecione o espao em branco sob o menu Incio.
7. Selecione o Object Inspector e altere os valores das propriedades Name e Caption para
InicioLimparTudo e &Limpar Tudo.
8. No espao sob o item de menu criado anteriormente, altere os valores das
propriedades Name e Caption para InicioFinalizar e &Finalizar.
9. Para adicionar teclas aceleradoreas para os itens de menu, basta definir sua
propriedade ShortCut no Object Inspector. Defina para o itens de menu Limpar Tudo e
Finalizar os valores das propriedades ShortCut como Ctrl+L e Ctrl+F, respectivamente.
10. Para associar o evento OnClose (fechar o formulrio) ao item de menu finalizar,
devemos, na pgina Events do Object Inspector, dar um duplo clique no evento a ser
definido (no caso, o evento onClick) e incluir a seguinte linha de cdigo:
procedure TFormPrincipal.InicioFinalizarClick(Sender: TObject);
begin
FormPrincipal.Close;
end;

P g i n a | 33

11. Podemos, tambm, criar uma rotina para confirmar o encerramento da aplicao. Para
isso, podemos usar o comando MessageDlg. Temos o seguinte cdigo:
procedure TFormPrincipal.Finalizar1Click(Sender: TObject);
begin
if MessageDlg('Deseja encerrar a
aplicao?',mtConfirmation,[mbYes,mbNo],0) = mrYes then
FormPrincipal.Close;
end;

O evento associado ao item de menu Limpar Tudo ser definido posteriormente.

8.4 Criando uma Caixa de Dilogo de Direitos Autorais

Para Criar uma caixa de dilogo de direitos autorais, vocs pode usar um dos formulrios
predefinidos do Delphi 7, executando os seguintes procedimentos:
1. Selecione o item New/Other do Delphi 7. Ser exibida a caixa de dilogo New Items,
tambm denominada Repositrios de Objetos.
2. Selecione a opo About Box na pgina Forms da caixa de dilogo New Items.
3. Clique no boto OK, para fechar essa caixa de dilogo e criar o novo formulrio.
Ser criada a caixa de dilogo About, mostrada abaixo.

Altere as propriedades Name e Caption desse formulrio para FormSobre e Sobre o

Sistema, respectivamente.
Para personalizar a nossa caixa de dilogo, execute os seguintes procedimentos:
1. Altere o valor da propriedade Caption de ProductName para Problema de
Misturas.
2. Altere o valor da propriedade Caption do label Version para Verso 1.0.
3. Altere o valor da propriedade Caption do label Copyright para Direitos Autorais.

P g i n a | 34

4. Altere o valor da propriedade Caption do label Comments para o nome do autor

do programa.
5. Altere o valor da propriedade WordWrap do label Comments para False.
6. Se desejar, carregue uma imagem atravs da propriedade Picture do componente
ProgramIcon.
7. Salve o arquivo de cdigo associado a este formulrio com o nome UnitSobre.pas,
usando o item Save As do menu File.

8.5 Criando um GroupBox para exibir as equaes do problema

Para criarmos o componente GroupBox desejado, vamos seguir os seguintes passos:
1.

Selecione o componente GroupBox, na pgina Standard da paleta de componentes e

clique sobre o formulrio, para que o componente seja inserido.

2. Atribua os seguintes valores para as propriedades do GroupBox:

Caption: Equaes.
Height: 95.
Hint: Equaes do Problema.
Name: GroupBoxEquacoes.
ShowHint: true.
Width: 300.
3. Posicione o GroupBox abaixo do Panel.
4. Insira dois componentes Label no GroupBoxEquacoes. Altere o valor da propriedade
Caption e posicione-os de modo a ficaremos como na figura a seguir.
5. Insira dois componentes Image no GroupBoxEquacoes. Conforme descrito
anteriormente, atravs da propriedade Picture, defina para o primeiro Image, a figura
EqPM1.jpg e para o segundo Image a figura EqPM2.jpg. Para ambas, altere o valor da
propriedade Autosize para true, posicione-as conforme a figura abaixo.

P g i n a | 35

8.6 Criando Botes para a manipulao do Formulrio

Criaremos, de incio, dois botes com as mesmas funes do Menu Iniciar. Teremos um boto
para limpar todo o contedo das caixas de texto do formulrio (boto limpar tudo) e outro
para sair da aplicao (boto finalizar).
Para inserir os componentes Button no formulrio principal da aplicao, execute os seguintes
procedimentos:
1. Selecione o componente Button, na pgina Standard da paleta de componentes e
clique sobre o formulrio, para que o componente seja inserido. Faa isso para os trs
componentes Button, alinhando-os horizontalmente.
2. Da esquerda para a direita, altere a propriedade Name dos componentes Button para
BtLimpar e BtFinalizar. Faa a mesma coisa para a propriedade Caption, no
esquecendo de colocar o smbolo & que tambm vlido para botes.
3. Para melhor organizar a aplicao, coloque todos os botes dentro de um mesmo
GroupBox e limpe o texto. Para fazer isso, selecione os trs botes simultaneamente
(com a tecla shift pressionada) e, com o boto direito do mouse, selecione a opo
Edit/Cut. Insira o GroupBox no formulrio e, clicando com o boto direito do mouse
dentro do GroupBox, selecione a opo Paste.

P g i n a | 36

Seu formulrio deve ficar com o aspecto mostrado na figura a seguir.

8.7 Criando Caixas de Texto para receber os dados do problema

Para recebermos os valores dos parmetros da equao do problema e do mtodo que ser
utilizado, devemos oferecer ao usurio um meio para que ele possa inserir os dados do
problema. Para tal fim, usaremos caixas de texto, o componente Edit.
Para organizar melhor o aplicativo, vamos inserir os componentes Edit dentro de componentes
GroupBox. Criaremos trs GroupBox, uma para os parmetros da equao, uma para os
parmetros do mtodo e a ltima para os resultados. Os valores das propriedades dos
componentes GroupBox esto listados a seguir.
- GroupBoxes
Name: GroupBoxPE
Caption: Parmetros da Equao
Hint: Parmetros da Equao
ShowHint: True
Height: 137
Width: 185
Name: GroupBoxPM
Caption: Parmetros do Mtodo

P g i n a | 37

Hint: Parmetros do Mtodo

ShowHint: True
Height: 121
Width: 185
Name: GroupBoxResultados
Caption: Resultados
Hint: Resultados
ShowHint: True
Height: 135
Width: 185

Objetos a serem inseridos dentro do GroupBoxPE

- Labels
Name: LabelQ1
Caption: Q (L/min) =
Name: LabelQ2
Caption: Q (L/min) =
Name: LabelC1
Caption: C (Kg/L) =
Name: LabelV
Caption: V (L) =
- Caixas de Texto
Name: EditQ1
Text: Limpar Texto
Width: 75
Name: EditQ2
Text: Limpar Texto
Width: 75
Name: EditC1
Text: Limpar Texto
Width: 75
Name: EditV
Text: Limpar Texto
Width: 75

P g i n a | 38

Objetos a serem inseridos dentro do GroupBoxPM

- Labels
Name: LabelC
Caption: C (Kg/L) =
Name: Labelh
Caption: h (passo) =
Name: Labeln
Caption: n (n ite) =
- Caixas de Texto
Name: EditC
Text: Limpar Texto
Width: 75
Name: Edith
Text: Limpar Texto
Width: 75
Name: Editn
Text: Limpar Texto
Width: 75
Objetos a serem inseridos dentro do GroupBoxResultados
- Labels
Name: LabelResultt
Caption: Em t =
Name: LabelResultq
Caption: q(t) =
Name: LabelResultV
Caption: V(t) =
Name: LabelResultC
Caption: C(t) =
Reposicione e redimensione estes componentes para que o formulrio fique com o aspecto
mostrado na figura a seguir.

P g i n a | 39

8.8 Gerando os Resultados do problema

Com os dados fornecidos pelo usurio nas caixas de texto, podemos, atravs da resoluo da
equao diferencial, calcular os resultados do problema. Para isso, precisamos implementar o
mtodo escolhido para a resoluo da EDO dentro do formulrio.
Para que a aplicao possa fazer os clculos requeridos, todos os dados devem estar inseridos
nas suas respectivas caixas de dilogos. Uma vez inseridos os dados, precisamos dar o
comando para que os clculos sejam realizados, esse comando ser dado clicando sobre um
boto, o boto calcular, ou seja, usaremos o evento OnClick do boto calcular para
implementar os clculos para a resoluo do problema.
Inicialmente, vamos criar o boto calcular (BtCalcular). Como fizemos anteriormente, vamos
criar uma GroupBox para colocarmos o boto calcular. Crie tambm um boto Iteraes
(BtIte), cuja utilidade ser explicada mais adiante.
No evento OnClick implementaremos o Mtodo de Euler e aproveitaremos parte do cdigo
utilizado no exemplo do Console Application, com algumas alteraes. Por exemplo, na
entrada de dados usaremos no mais o comando Read e sim a propriedade Text dos
componentes Edit da aplicao, porm a propriedade Text uma string, ento precisaremos
usar uma funo de converso, essa funo a StrtoFloat. Se quisermos converter a string

P g i n a | 40

dada em um inteiro, usaremos a funo StrtoFloat, existem tambm as funes FloattoStr e

InttoStr que desempenham a operao inversa.
Um exemplo de como o cdigo pode ser implementado, apresentado abaixo:
function f(t,q,Q1,Q2,C1,V: real): real;
begin
f:= Q1*C1 - Q2*q/(V + (Q1-Q2)*t);
end;
procedure TFormPrincipal.BtCalcularClick(Sender: TObject);
var q,t,Q1,Q2,C1,C,V,h: real;
n,i: integer;
begin
//Entrada de Dados - Parmetros da Equao
Q1:= StrtoFloat(EditQ1.Text);
Q2:= StrtoFloat(EditQ2.Text);
C1:= StrtoFloat(EditC1.Text);
V := StrtoFloat(EditV.Text);
//Entrada de Dados - Parmetros do Mtodo
C:= StrtoFloat(EditC.Text);
h:= StrtoFloat(Edith.Text);
n:= StrtoInt(Editn.Text);
//Implementao do Mtodo
t:= 0;
q:= C*V;
for i:=1 to n do
begin
q := q + h*f(t,q,Q1,Q2,C1,V);
t := t + h;
end;
//Resultados
Labelt.Caption:=
Labelq.Caption:=
LabelV.Caption:=
LabelC.Caption:=
Kg/L';
end;

'Em t
'q(t)
'V(t)
'C(t)

=
=
=
=

'
'
'
'

+
+
+
+

FloattoStr(SimpleRoundTo(t,-2)) + ' min';

FloattoStr(SimpleRoundTo(q,-2)) + ' Kg';
FormatFloat('0.00',V + (Q1-Q2)*t) + ' L';
FormatFloat('0.00',q/(V + (Q1-Q2)*t)) + '

Obs. : As funes FormatFloat e SimpleRoundto foram usadas para mostrar os valores

calculados com apenas duas casas decimais.

8.9 Compartilhando eventos

Agora que o modelos para o clculo das solues j est funcionando, podemos dar
funcionalidade ao boto Limpar Tudo do formulrio. A funo desse boto ser limpar todos
os edits do formulrio. Esse mesmo procedimento tambm utilizado no menu da aplicao,
para aplicarmos a mesma a rotina a ambos os eventos onClick (do menu e do boto),
podemos, simplesmente, compartilhar o evento. Para isso, necessrio, inicialmente,
implementarmos, em um dos componentes, o seguinte procedimento:
procedure TFormPrincipal.BtLimparClick(Sender: TObject);
begin
//Limpando os componentes Edit
EditQ1.Clear;

P g i n a | 41

EditQ2.Clear;
EditV.Clear;
EditC1.Clear;
EditC.Clear;
Edith.Clear;
Editn.Clear;
//Retornando os componentes ao estado inicial
Labelt.Caption:= 'Em t = ';
Labelq.Caption:= 'q(t) = ';
LabelV.Caption:= 'V(t) = ';
LabelC.Caption:= 'C(t) = ';
end;

Repare que o procedimento foi associado ao evento onclick do boto limpar. Agora, para
compartilharmos o evento, necessrio selecionarmos, atravs do componente Menu, a
opo limpar tudo e, na palheta de eventos, atravs da combo do evento onclick
selecionarmos a opo BtLimparClick.

8.10 Exibindo as Iteraes do problema

Para exibir as iteraes, criaremos um novo formulrio. Selecione as opes New/Form e o
novo formulrio ser criado e salve a Unit (utilizando o Save As...) com o nome de UnitIte.
Altere as propriedades Name e Caption para FormIte e Iteraes do problema,
respectivamente. No formulrio, teremos um componente Memo, para exibir as iteraes, os
botes salvar e fechar e uma GroupBox para agrupar os botes.
Insira, no formulrio, inicialmente os componente Memo e GroupBox e defina a propriedade
align de ambos como alClient e alBotton. Defina tambm, para o componente Memo as
propriedades ReadOnly e ScrollBars para true e ssVertical, respectivamente. Insira os botes
no GroupBox e redimensione o formulrio de forma semelhante ao mostrado a seguir:

P g i n a | 42

Repare que, ao executar o programa, o formulrio Ite no exibindo clicando o boto

Iteraes. Para que o formulrio seja exibido necessrio associar o mtodo Show ao evento
onClick do boto iteraes. Faa isso para que o formulrio seja exibido.
Agora, necessrio fazer com que as iteraes sejam adicionadas ao componente Memo. Para
isso, devemos fazer uma pequena alterao no cdigo-fonte da aplicao, adicionando
estrutura de repetio for e antes dela, os comandos a seguir:
FormIte.MemoIte.Clear;
FormIte.MemoIte.Lines.Add('t (min)'+#9+'q (Kg)'+#9+'V (L)'+#9+'C (Kg/L)');
for i:=1 to n do
begin
q := q + h*f(t,q,Q1,Q2,C1,V);
t := t + h;
FormIte.MemoIte.Lines.Add(FormatFloat('0.00',t)+#9+FormatFloat('0.00',q)+#9+Fo
rmatFloat('0.00',V + (Q1-Q2)*t)+#9+FormatFloat('0.00',q/(V + (Q1-Q2)*t)));
end;

Repare que dessa forma no sero exibidas as solues do problema para o instante t=0. Para
que a soluo em t=0 seja exibida, podemos repetir o mesmo comando que foi acrescentado
ao for, adicionando-o antes da execuo do for.

8.11 Criando um Arquivo com os Resultados do problema

O prximo passo do aplicativo ser a gerao de um arquivo com as iteraes do problema.
Utilizaremos duas formas para criar o formulrio Salvar. Na primeira desenharemos o todo o
formulrio com o objetivo de receber o local onde o arquivo ser salvo. Na segunda maneira,
utilizaremos a funo SelectDirectory com o mesmo objetivo.
O boto salvar ter a funo de salvar o arquivo. Para isso criaremos novo formulrio com a
funo de receber o local onde o arquivo ser salvo, o nome do arquivo e o tipo de arquivo.
Ento, em File/New selecione a opo Form, para criar o novo formulrio.
Para o novo formulrio, defina os valores para as propriedades a seguir:
BorderStyle: bsSingle
BorderIcons: [biSystemMenu, biMinimize]
Caption: Salvar uma Cpia
Color: clMenuBar
Height: 195
Name: FormSalvar
Position: poScreenCenter.
Width: 465
Objetos a serem inseridos no FormSalvar:
- Labels
Caption: Salvar em:
Name: LabelSalvarem

P g i n a | 43

Caption: Nome do Arquivo:

Name: LabelNomeArq
Caption: Salvar como Tipo:
Name: LabelSalvarcomo
- Caixas de Texto
Name: EditEndArq
Text: C:\Documents and Settings\Elvis Trabalhos\Desktop\PExem\
TabOrder: 4
Width: 290
Name: EditNomeArq
Text: Dados_PM
TabOrder: 0
Width: 200
- ComboBox
ItemIndex: 0
Items: (TStrings)

Name: ComboBoxTipoArq
Style: csDropDownList
TabOrder: 1
Width: 200
- Botes
Caption: &Salvar
Name: BotoSalvar
TabOrder: 2
Caption: &Cancelar

P g i n a | 44

Name: BotoCancelar
TabOrder: 3
Reposicione e redimensione estes componentes para que o formulrio fique com o aspecto
mostrado na figura a seguir.

Para associarmos a apario do FormSalvar ao evento onClick, precisamos definir o seguinte

cdigo:
procedure TFormPrincipal.ButtonSalvarClick(Sender: TObject);
begin
FormSalvar.ShowModal;
end;

Para a criao do arquivo utilizaremos um processo um pouco diferente. As iteraes so

geradas no evento onClick do boto calcular, por meio da estrutura de repetio for. Ento,
para inserir os dados gerados no arquivo, temos duas opes: refazer todos os clculos no
evento onClick do boto salvar ou podemos gerar um arquivo temporrio quando o boto
calcular pressionado e, caso o usurio queira salvar o arquivo, copiamos o arquivo para um
outro diretrio e com um nome definido pelo usurio. Lembrando que o arquivo temporrio
deve ser excludo ao fim da aplicao.
Para gerarmos o arquivo temporrio devemos utilizar algumas funes e procedimentos para
manipulao de arquivos. As principais so apresentadas a seguir.
A relao a seguir apresenta as principais funes para a manipulao de arquivos
representados por uma varivel:
- Append (var F): Abre o arquivo representado pela varivel F, apenas para escrita no final do
arquivo.
- AssignFile (var F; FileName: string): Associa varivel F o arquivo cujo nome passado como
segundo parmetro.
- CloseFile (var F): Fecha o arquivo representado pela varivel F.
- EOF (var F): Retorna True, se o arquivo representa pela varivel F est posicionado no seu
final, e False, em caso contrrio.
- Erase (var F): Apaga o arquivo representado pela varivel F.

P g i n a | 45

- FileSize (var F): Retorna o tamanho, em bytes, do arquivos representado pela varivel F.
- Read (F, V1 [, V2, ..., Vn]): L elementos de dados em um arquivo representado pela varivel
F e os armazena nas variveis v1, v2, ..., vn.
- Readln ([var F: Text;] V1 [,V2, ..., Vn]): L elementos de dados em uma linha de um arquivo
de texto representado pela varivel F e os armazena nas variveis v1, v2, ..., vn. Caso no
sejam fornecidos parmetros, o arquivo passa para a linha seguinte.
- Rename (var F; NewName): Renomeia como NewName o arquivo representado por F.
- Reset (var F [:File; RecSize: Word]): Esse procedimento abre o arquivo representado pela
varivel F. o parmetro RecSize opcional e especifica o tamanho do registro usado na
transferncia de dados. Se for omitido, o valor default 128 usado. Se o arquivo no existir,
ocorrer um erro no processamento. Se o arquivo j estiver aberto, ele fechado e reaberto,
sendo posicionado no seu inicio. Se F representar um arquivo de texto, ele aberto apenas
para leitura.
- Rewrite (var F [:File; RecSize: Word]): Esse procedimento cria o arquivo representado pela
varivel. Se o arquivo j existir, seu contedo ser apagado, mesmo que j esteja aberto.
- Write (F, V1 [, V2, ..., Vn]): Escreve, em um arquivo representado pela varivel F, elementos
de dados armazenados nas variveis v1, v2, ..., vn.
- Writeln (F, V1 [, V2, ..., Vn]): Escreve, em uma linha de um arquivo de texto representado
pela varivel F, elementos de dados armazenados nas variveis v1, v2, ..., vn.
A relao a seguir apresenta as principais funes para manipulao direta de arquivos (no
associados a uma varivel):
- ChangeFileExt (const FileName, Extension: string): Muda para Extension a extenso do
arquivo cujo nome e/ou path complete so definidos pela string FileName.
- DeleteFile (const FileName: string): Apaga o arquivo cujo nome e/ou path completo so
definidos pela string FileName. Retorna False, se o arquivo no existe, e True, em caso
contrrio.
- ExpandFileName (const FileName: string): Retorna em uma string o path completo e o nome
do arquivo definido pela string FileName.
- ExtractFileDir (const FileName: string): Retorna em uma string o diretrio do arquivo cujo
nome e/ou path completo so definidos pela string FileName.
- ExtractFileDrive (const FileName: string): Retorna em uma string o drive do arquivo cujo
nome e/ou path completo so definidos pela string FileName.
- ExtractFileExt (const FileName: string): Retorna em uma string a extenso do arquivo cujo
nome e/ou path completo so definidos pela string FileName.

P g i n a | 46

- ExtractFileName (const FileName: string): Retorna em uma string apenas o nome do arquivo
cujo nome e/ou path completo so definidos pela string FileName.
- ExtractFilePath (const FileName: string): Retorna em uma string apenas o path completo do
arquivo cujo nome e/ou path completo so definidos pela string FileName.
- FileExists (const FileName: string): Retorna True, se o arquivo cujo nome e/ou path completo
so definidos pela string FileName existe, e False, em caso contrrio.
- FileSearch (const Name, DirList: string): Pesquisa, pelos diretrios definidos no parmetro
DirList, um arquivo cujo nome definido pela string Name. O parmetro DirList uma string
em que os diretrios de pesquisa devem ser separados por vrgulas. Se o arquivo for
encontrado, a funo retorna o path completo do arquivo.
- RenameFile (const OldName, NewName: string): Renomeia para NewName o arquivo cujo
nome definido pela string OldName, retornando True, se a operao realizada com
sucesso, e False, em caso contrrio.
Para criao do arquivo temporrio, devemos declarar uma varivel do tipo TextFile, junto as
variveis j declaradas no procedimento.
Antes de entrarmos na estrutura de repetio for, demos associar o arquivo a varivel
criada, por meio do procedimento AssignFile, e criar o arquivo, por meio do mtodo Rewrite.
De forma semelhante ao Memo, os resultados para t = 0 no so exibidos, logo adicionaremos,
antes do for, o procedimento write para que, no arquivo, sejam exibidos os valores iniciais do
problema e, por ltimo, devemos inserir um procedimento write dentro da estrutura for.
Lembrando que, ao encerrar o programa, o arquivo temporrio deve ser excludo, utilizando,
assim, o evento onClose do formulrio.
As mudanas feitas no cdigo esto mostradas abaixo.
procedure TFormPrincipal.BtCalcularClick(Sender: TObject);
var q,t,Q1,Q2,C1,C,V,h: real;
n,i: integer;
Arq: TextFile;
begin
AssignFile(Arq,'C:\Arq_temp');
Rewrite(Arq);
Write(Arq,'t =',t:5:3,'s
','q =',q:5:3,'Kg
',(V + (Q1-Q2)*t):5:3,'L
',(q/(V + (Q1-Q2)*t)):5:3,'Kg/L');
MemoIteracoes.Lines.Add(FloattoStr(SimpleRoundTo(t,-2))+'
'+FloattoStr(SimpleRoundTo(q,-2))
+'
'+FloattoStr(SimpleRoundTo(V + (Q1-Q2)*t,-2))+'
'+FloattoStr(SimpleRoundTo(q/(V + (Q1-Q2)*t),-2)));
for i:=1 to n do
begin
q := q + h*f(t,q,Q1,Q2,C1,V);;
t := t + h;
Writeln(Arq);
Write(Arq,'t =',t:5:3,'s
','q =',q:5:3,'Kg
',(V + (Q1-Q2)*t):5:3,'L
',(q/(V + (Q1-Q2)*t)):5:3,'Kg/L');
MemoIteracoes.Lines.Add(FloattoStr(SimpleRoundTo(t,-3))+'

P g i n a | 47

'+FloattoStr(SimpleRoundTo(q,-3))
+'
'+FloattoStr(SimpleRoundTo(V + (Q1-Q2)*t,-3))+'
'+FloattoStr(SimpleRoundTo(q/(V + (Q1-Q2)*t),-3)));
end;
CloseFile(Arq);
end;
procedure TFormPrincipal.FormClose(Sender: TObject;
var Action: TCloseAction);
begin
DeleteFile('C:\Arq_temp');
end;

Agora, para que o formulrio salvar possa gerar o arquivo requerido, devemos fazer com que
ele copie o arquivo temporrio (que ainda no foi excludo) para um diretrio especificado
na caixa de texto EditEndArq.
Utilizaremos o evento OnClick do boto salvar para fazer a copia do arquivo temporrio e
salva-lo no diretrio desejado. Um exemplo de cdigo que faa a cpia do arquivo para o local
descrito no EditEndArq e com a extenso escolhida no ComboBoxTipoArq, mostrado abaixo:
procedure TFormSalvar.ButtonSalvarClick(Sender: TObject);
var F_Name: string;
F: TextFile;
begin
if EditNomeArq.Text <> '' then
begin
case ComboBoxTipoArq.ItemIndex of
0: F_Name:= EditEndArq.Text + EditNomeArq.Text + '.txt';
1: F_Name:= EditEndArq.Text + EditNomeArq.Text + '.doc';
2: F_Name:= EditEndArq.Text + EditNomeArq.Text + '.xls';
end;
AssignFile(F,F_Name);
if CopyFileTo('C:\Arq_temp',F_Name) then;
FormSalvar.Close;
end
else Application.MessageBox('Digite o nome do Arquivo','Erro',16);
end;

Para o boto Cancelar, definimos o seguinte evento OnClick:

procedure TFormSalvar.ButtonCancelarClick(Sender: TObject);
begin
FormSalvar.Close;
end;

Agora, mostraremos de uma forma bem mais simplificada como gerar o arquivo com as
iteraes.
Ao boto salvar do FormIte, podemos definir o seguinte procedimento:
procedure TFormIte.BtSalvarClick(Sender: TObject);
const
SELDIRHELP = 1000;
var
dir: string;
begin
dir := 'C:';
if
SelectDirectory(dir,
[sdAllowCreate,

sdPerformCreate,sdPrompt],

P g i n a | 48

SELDIRHELP) then
MemoIte.Lines.SaveToFile(dir+'\ite.txt');
end;

Utilizando poucas linhas, conseguimos produzir o mesmo resultado. No Delphi temos, quase
sempre, vrias maneiras de chegar no mesmo propsito e muitas vezes o tempo que ns
passamos planejando e pensando na nossa aplicao pode se multiplicar e transforma-se em
economia de tempo. Pensem nisso!

Com isso conclumos nossa breve introduo sobre o Ambiente de Desenvolvimento do Delphi.

P g i n a | 49