2011 Delphi XE PDF

Delphi XE
Guia de Componentes
Daniela Caio André Gomes

Jorge Kawamura
Roberto Scalco
2011
3
Sumário
CAPÍTULO 1 – AMBIENTE DELPHI...................................................................................................................... 4

1. EXECUTANDO O DELPHI XE ................................................................................................................................. 4
2. AMBIENTE DE DESENVOLVIMENTO DO DELPHI XE .................................................................................................... 5
3. MANIPULAÇÃO DE PROJETOS .............................................................................................................................. 8
3.1. CRIAR UM NOVO PROJETO .................................................................................................................................. 8
3.2. SALVAR UM PROJETO ......................................................................................................................................... 8
3.3. ABRIR UM NOVO PROJETO .................................................................................................................................. 9
CAPÍTULO 2 – BIBLIOTECAS E FUNÇÕES .......................................................................................................... 10
1. CONVERSÕES: TEXTO ↔ NÚMERO ................................................................................................................... 10
2. FUNÇÕES MATEMÁTICAS ................................................................................................................................. 11
CAPÍTULO 3 – COMPONENTES BÁSICOS ......................................................................................................... 12
1. FORM ........................................................................................................................................................... 12
2. BUTTON ........................................................................................................................................................ 13
3. EDIT ............................................................................................................................................................. 13
4. LABEL ........................................................................................................................................................... 14
5. MEMO ......................................................................................................................................................... 14
6. RADIOGROUP ................................................................................................................................................ 15
7. LISTBOX ........................................................................................................................................................ 16
8. STRINGGRID ................................................................................................................................................ 17
9. CHECKBOX .................................................................................................................................................... 19
10. CHECKLISTBOX ............................................................................................................................................... 19
CAPÍTULO 4 – UM EXEMPLO DE RESOLUÇÃO DE PROBLEMA ......................................................................... 21
CAPÍTULO 5 – OUTRAS FUNCIONALIDADES .................................................................................................... 26
1. COMPONENTES VISUAIS ................................................................................................................................... 26
1.1. COMBOBOX .................................................................................................................................................. 26
1.2. IMAGE .......................................................................................................................................................... 27
1.3. SPINEDIT....................................................................................................................................................... 28
1.4. PAGECONTROL ............................................................................................................................................... 28
1.5. CHART .......................................................................................................................................................... 30
2. MANIPULAÇÃO DE ARQUIVOS ........................................................................................................................... 35
2.1. OPENDIALOG ................................................................................................................................................. 35
3. MANIPULAÇÃO DE CORES ................................................................................................................................. 37
3.1. TCOLOR ........................................................................................................................................................ 37
3.2. COLORDIALOG ............................................................................................................................................... 37
3.3. SHAPE .......................................................................................................................................................... 38
4. MANIPULAÇÃO DE DATAS................................................................................................................................. 39
4.1. TDATETIME ................................................................................................................................................... 39
4.2. NOW............................................................................................................................................................ 40
4.3. DIFERENÇA ENTRE DOIS INSTANTES ..................................................................................................................... 40
4.4. DATETIMEPICKER ........................................................................................................................................... 41
5. NAVEGAÇÃO NA INTERNET................................................................................................................................ 42
5.1. WEBBROWSER ............................................................................................................................................... 43
6. IMPRESSÃO.................................................................................................................................................... 45
6.1. PRINT ........................................................................................................................................................... 45
6.2. RAVE REPORT ................................................................................................................................................ 45
Delphi XE – Guia de Componentes

4
Capítulo 1 – Ambiente Delphi
Ambiente de programação voltado ao desenvolvimento de aplicações para o sistema

operacional Windows. Dentre suas características destacam-se:
a) programação visual;
b) RAD – Rapid Application Development;
c) Pascal (Object Pascal);
d) programação orientada a objetos;
e) programação orientada a eventos.
1. Executando o Delphi XE
No Windows, clique sobre a pasta Embarcadero RAD Studio XE no menu iniciar e em seguida
no item “Delphi XE”.
A figura a seguir mostra o ambiente de desenvolvimento Delphi XE.

5
2. Ambiente de desenvolvimento do Delphi XE
Na primeira parte do curso foi apresentado no ambiente Delphi XE um projeto do tipo

Console Application, na segunda parte do curso será apresentado um projeto do tipo VCL
Forms Application – Delphi. Para tal clique em File, depois New e em seguida selecione o
item VCL Forms Application – Delphi.
Para confecção de um projeto VCL, o ambiente Delphi disponibiliza os seguintes elementos:
a) Barra Rápida (Speed Bar): permite executar as funções mais comuns do menu por
meio do mouse, como por exemplo: abrir projetos, salvar projetos, etc. Ao passar
com o mouse sobre seus botões, um texto explicativo é apresentado.
b) Formulário (Form): representa uma janela, que será a janela principal de um

aplicativo desenvolvido no Delphi. Contém uma área livre em seu interior, onde
serão colocados os componentes que o aplicativo irá necessitar.
Note que o formulário pertence à aba Design. Desta maneira, as ferramentas para a
confecção da aparência do aplicativo somente são exibidas quando essa aba estiver
selecionada.

6
c) Palheta de ferramentas (Tool Palette): possui um conjunto de componentes

organizados segundo a sua função e que podem ser acessados com o mouse.
d) Editor de Código: é uma janela que apresenta um arquivo texto contendo o código
fonte em Object Pascal referente ao Form. O nome do arquivo texto contendo código
fonte no Delphi é conhecido como Unit (Unidade).

7
Para acessar o editor de código selecione a aba Code.
e) Inspetor de Objetos (Object Inspector): Esta janela indica os valores das

propriedades dos objetos (componentes) e os eventos que serão utilizados em um
programa. Possui um ComboBox que permite selecionar cada componente utilizado
na aplicação e possui, também, uma lista de propriedades pertinentes a esse objeto,
bem como uma lista de eventos relacionadas ao objeto que está selecionado.

8
Observação: Clicar com o botão direito do mouse em Properties no Object Inspector.

No item Arrange selecione by name para ordenar por nome as propriedades e
eventos do Object Inspector.
3. Manipulação de Projetos
Um projeto é um conjunto de Forms e Units que o Delphi usa para gerar o programa final
executável.
A seguir serão apresentados os processos, de maneira segura, para criar, abrir e salvar
projetos.
3.1. Criar um novo projeto
Para criar um novo projeto devemos nos certificar que não existe nenhum projeto aberto,
isto pode ser feito clicando no menu File, em seguida no item Close All. Após esta verificação
clique novamente em File, depois New e em seguida selecione o item VCL Forms
Application – Delphi for Win32 para criar um novo projeto.
3.2. Salvar um projeto
Para salvar um projeto no Delphi clique no menu File, em seguida Save All, o Delphi pedirá
para salvar primeiro a unidade e depois o projeto. Dê um nome para a unidade, aperte o
botão Salvar e a seguir faça o mesmo com o projeto. O nome desses arquivos devem seguir
as regras para criação de nome de variáveis.

9
3.3. Abrir um novo projeto
Para abrir um novo projeto devemos nos certificar que não existe nenhum projeto aberto,
isto pode ser feito clicando no menu File, em seguida no item Close All. Depois disso clique
no menu File, em seguida Open.
Dentre os arquivos apresentados escolha o arquivo de projeto (.dpr).

Atenção! Não abra o arquivo da unidade (.pas), pois esse possui apenas o código fonte.

10
Capítulo 2 – Bibliotecas e Funções

Esse capítulo apresenta algumas funções e tipos de dados disponibilizados em bibliotecas
(units).
1. Conversões: Texto ↔ Número
Quando desejamos ler uma informação digitada pelo usuário em algum componente do
formulário, devemos analisar como a informação será armazenada no aplicativo, ou seja,
devemos observar qual será o tipo da variável utilizada.
Todas as informações do formulário que são representadas por caracteres são valores do
tipo texto (string). Desta maneira, quando desejamos ler um valor numérico, devemos
converter o valor, escrito na forma de texto, para valores numéricos. Além disso, devemos
escolher como será o formato do número, inteiro ou real (chamado número de ponto
flutuante, ou float).
a) função que transforma um texto para um número inteiro: StrToInt;
b) função que transforma um texto para um número real: StrToFloat.
Quando desejamos exibir um valor numérico em algum componente do formulário,

devemos utilizar funções complementares para converter os valores numéricos (inteiros ou
reais) para texto.
a) função que transforma um número inteiro para um texto: IntToStr;
b) função que transforma um número real para um texto: FloatToStr.
Veja no exemplo como ler e exibir valores em componentes do tipo Edit, considerando que
foram declaradas as variáveis A: Integer, B: Real e C: String.
// Lendo valores
A := StrToInt(Edit1.Text);
B := StrToFloat(Edit2.Text);
C := Edit3.Text; // note que não fazemos a conversão
// Exibindo valores
Edit4.Text := IntToStr(A);
Edit5.Text := FloatToStr(B);
Edit6.Text := C; // note que não fazemos a conversão
Também é possível exibir um determinado número de casas decimais quando valores reais
forem apresentados nos componentes. Para tal, utilize a função FloatToStrF que formata
o valor no momento da conversão para texto. Essa função possui quatro parâmetros:
a) o valor que será exibido;
b) o formato do número. Normalmente utilizamos a constante ffFixed;
c) a precisão, que representa o número de algarismos significativos;
d) a quantidade de casas após o separador decimal.

11
Considerando que o valor da variável real x seja √2, veja como o valor pode ser exibido
alterando os parâmetros.
Instrução Valor Exibido

FloatToStrF(x,ffFixed,6,5) 1,41421
FloatToStrF(x,ffFixed,6,0) 1
Note que o parâmetro da precisão deve ser maior do que o número de casas decimais para
que não haja alteração do valor.
2. Funções Matemáticas
Algumas funções matemáticas estão disponíveis na biblioteca Math. Para acessar essas
funções, devemos declarar essa biblioteca na cláusula uses.
Uses Math;
Das funções existentes na biblioteca Math, destacam-se três, descritas a seguir:
a) as funções DegToRad e RadToDeg fazem a conversão de valores reais de graus para

radianos e de radianos para graus, respectivamente, retornando novos valores reais.
Veja os exemplos, considerando que as variáveis reais AnguloGrau e
AnguloRadiano foram declaradas:
AnguloRad := DegToRad(AnguloGrau);
AnguloGrau := RadToDeg(AnguloRad);
b) até o momento, o cálculo da potência de dois valores (𝑥 𝑦 ) era feita da seguinte

maneira:
Potencia := Exp(y*ln(x));
Entretanto, essa expressão possui uma limitação, pois o domínio da função ln

somente é definido para valores positivos de x.
Para evitar esse problema, sem ter que criar uma estrutura condicional, podemos
utilizar a função Power que possui dois parâmetros reais, a base e o expoente. A
função possui o tratamento de eventuais erros, retornando o valor da potência sem
restrições de valores da base e do expoente.
Potencia := Power(x,y);

12
Capítulo 3 – Componentes Básicos

Neste capítulo apresentaremos os componentes básicos para a criação dos aplicativos que
serão desenvolvidos no curso.
1. Form
O formulário é objeto que serve como “base” para colocar outros objetos (componentes).
Possui controles que permitem que o usuário realize ações como minimizar, maximizar e
fechar, encerrando a execução do programa.
Quando um novo projeto é criado (VCL Forms Application – Delphi for Win 32), esse
componente é imediatamente colocado a disposição do programador, permitindo que a
confecção do aplicativo se dê por ele.
Propriedades e eventos
a) dentre suas propriedades, destacam-se a Caption que indica qual é o texto que será
exibido na barra superior do formulário. No exemplo acima, foi usado:
Form1.Caption := ‘Form1’;
b) a sub-rotina que está associada ao evento OnCreate é ativada logo após a execução
do programa, como se fosse “a primeira coisa que será feita”. Aproveite essa sub-
rotina para iniciar suas variáveis globais e fazer algumas configurações iniciais nos
objetos que estiverem sobre o formulário.

13
2. Button
Esse componente está na aba Standard da barra de componentes. O botão é o principal

objeto que irá sofrer ações (Eventos) oriundas do usuário quando esse desejar executar
algumas instruções (Métodos).
a) a propriedade Caption indica o texto que será exibido no botão;

b) a sub-rotina que está associada ao evento OnClick é executada quando o botão for
pressionado. A maioria dos códigos que serão desenvolvidos estará alocada nessa
sub-rotina.
3. Edit
Esse componente está na aba Standard da barra de componentes. O Edit permite a

entrada de um único valor, digitado via teclado, na forma de texto. Lembre-se das funções
de conversão de texto para número caso o valor digitado tenha que ser utilizado em algum
cálculo.
Propriedades
a) a propriedade Text contém informações digitadas no componente. É o meio mais

comum para a leitura de valores.
O exemplo a seguir mostra como ler alguns valores, considerando que as variáveis A,
B e C são do tipo inteiro, real e texto, respectivamente:
A := StrToInt(Edit1.Text);
B := StrToFloat(Edit2.Text);
C := Edit3.Text; // note que não fazemos a conversão
Embora os exemplos tenham mostrado o uso do Edit para a leitura de informações,

também é possível exibir os valores obtidos pelo processamento do aplicativo,
escrevendo as variáveis na propriedade Text.

14
b) para colocar o foco em um componente, ou seja, prepará-lo para receber uma nova
informação, utiliza-se:
Edit1.SetFocus;
c) para limpar o conteúdo do Edit, a propriedade Clear deve ser usada da seguinte
maneira:
Edit1.Clear;
4. Label
Esse componente está na aba Standard da barra de componentes. O Label permite exibir
um único dado (valor de uma variável) na forma de texto ou apenas melhora a aparência da
interface do programa.
Propriedades
a) Para exibir um texto no Label, devemos escrever sobre a propriedade Caption.

Veja os exemplos de como exibir uma variável do tipo inteiro, uma do tipo real, uma
do tipo string e um texto constante, respectivamente.
Label1.Caption := IntToStr(A);
Label2.Caption := FloatToStr(B);
Label3.Caption := C;
Label4.Caption := ‘Texto’;
Atenção! O Edit possui Text e o Label possui Caption.
5. Memo
Esse componente está na aba Standard da barra de componentes. Exibe um texto que pode
ser dividido em linhas, sendo que estas linhas são manipuladas de forma independente.

15
Propriedades
a) para adicionar um texto na última linha do Memo, usa-se:
Memo1.Lines.Add(‘Texto’);
b) para conhecer o número de linhas (valor inteiro) existentes no Memo faz-se:
NumeroDeLinhas:= Memo1.Lines.Count;
c) para conhecer o valor do índice da última linha (valor inteiro) existente no Memo,
utiliza-se:
UltimaLinha:= Memo1.Lines.Count - 1;
d) pode-se apagar uma determinada linha (do tipo Integer) com:
Memo1.Lines.Delete(Linha);
e) para apagar todas as linhas de um Memo.
Memo1.Clear;
f) retorna o conteúdo da linha indicada pela variável inteira Linha em uma variável do
tipo String.
Texto:= Memo1.Lines[Linha];
6. RadioGroup
Esse componente está na aba Standard da barra de componentes. O RadioGroup é um

componente que permite a escolha de somente uma opção em um grupo contendo várias
alternativas. Também é um componente para a entrada de dados, entretanto o usuário deve
utilizar o mouse ao invés do teclado.

16
a) embora existam elementos dentro do RadioGroup que sejam semelhantes aos

RadioButton (não utilizado no curso), eles são, na verdade, textos digitados dentro
da propriedade Items no Object Inspector;
b) para descobrir qual dos itens foi selecionado, pode-se usar uma estrutura condicional
caso. A expressão que será verificada será a propriedade ItemIndex, que retorna o
valor inteiro da posição do RadioGroup selecionado.
Importante! O primeiro item sempre é definido com o índice zero;
c) para obter o texto do item selecionado, devemos verificar qual é o valor da lista
Items que está na posição selecionada, como faríamos em uma variável indexada.
TextoSelecionado := RadioGroup1.Items[RadioGroup1.ItemIndex];
d) também é possível executar uma sequência de instruções quando uma opção do

RadioGroup for selecionada (instruções no Método OnClick).
7. ListBox
Esse componente está na aba Standard da barra de componentes. O ListBox é um

componente semelhante ao RadioGroup em termos de utilização. Apresenta uma lista de
itens, na forma de String, que podem ser selecionados com o auxílio do apontador do
mouse.
Propriedades
a) Para preencher a lista de itens do ListBox, devemos digitar os valores dentro da

propriedade Items do Object Inspector, exatamente como no RadioGroup.
Caso o conteúdo deva ser adicionado em tempo de execução do aplicativo, podemos
acrescentar um texto na última linha do ListBox, utilizando:
ListBox1.Items.Add(‘Texto’);

17
valor inteiro da posição do ListBox selecionado.
TextoSelecionado := ListBox1.Items[ListBox1.ItemIndex];
d) para apagar uma linha qualquer, utiliza-se:
ListBox1.Items.Delete(NumeroDaLinha);
e) também é possível executar uma sequência de instruções quando uma opção do

ListBox for selecionada. Para tal, utilize o método OnClick para digitar o código-
fonte do que deve ser executado.
8. StringGrid
Esse componente está na aba Additional da barra de componentes. O StringGrid permite

a entrada ou exibição de dados na forma de texto. Estes dados podem ser, normalmente,
vetores ou matrizes, na forma de uma tabela. Assim como todos os componentes que
possuem mais do que um item, o primeiro possui índice 0, no caso, a primeira linha e a
primeira coluna possuem o índice 0, não importando a cor.
Cada item do StringGrid é denominado de célula. A figura a seguir mostra um objeto com
5 linhas e 5 colunas, com células em três cores diferentes. As células brancas representam as
células que podem ser utilizadas pelo usuário para digitar informações. A célula azul
representa uma célula branca selecionada. As células da esquerda e as de cima da tabela são
denominadas células fixas e não permitem que o usuário escreva nelas.
Propriedades
a) a quantidade de linhas e colunas do StringGrid pode ser definida diretamente no

Object Inspector, ou em tempo de execução do aplicativo, manipulando as
propriedades inteiras RowCount e ColCount, respectivamente. Veja o exemplo:

18
StringGrid1.RowCount:= NumeroDeLinhas;
StringGrid1.ColCount:= NumeroDeColunas;
Note que a alteração dessas propriedades modifica apenas a quantidade de linhas e

colunas, não modificando o tamanho, em pixels, do StringGrid no formulário. Para
acessar as linhas e colunas que não cabem na janela, utilize as barras de rolagem
vertical e horizontal.
b) um caso de interesse é conhecer o valor de índice (representado por um valor

inteiro) da última linha ou coluna:
UltimaLinha:= StringGrid1.RowCount - 1;
UltimaColuna:= StringGrid1.ColCount - 1;
c) Para alterar o modo de edição do StringGrid, deve-se clicar na propriedade

Options do Object Inspector. Nesta propriedade existe o campo goEditing, que
pode receber valores booleanos (True ou False).
No caso do StringGrid ser utilizado apenas para a exibição de dados, ou seja, o
usuário não irá digitar nenhum valor nas células do componente, a propriedade
goEditing deverá receber False.
Existe outra possibilidade na qual o usuário irá digitar valores nas células do
StringGrid. Neste caso, goEditing receberá True.
d) Para escrever ou acessar o conteúdo da célula, na forma de texto, utilizamos a

propriedade Cells como uma variável indexada bidimensional, lembrando que a
primeira célula possui os índices [0,0]. Lembre-se de que os índices das células
devem ser valores do tipo inteiro.
Atenção! Naturalmente utilizamos matrizes considerando o primeiro índice para as

linhas e o segundo para as colunas. No StringGrid os índices são coluna e linha,
respectivamente.
Veja os exemplos que mostram a leitura e exibição de alguns valores. Note que o
exemplo mostra que para valores reais e inteiros devemos fazer a conversão dos
valores. Considere a seguinte declaração de variáveis:
Var A, linha, coluna: Integer;

B: Real;
C: String;
As variáveis coluna e linha devem estar devidamente preenchidas com os índices

desejados.

19
// leitura de valores
A:= StrToInt(StringGrid1.Cells[coluna,linha]);
B:= StrToFloat(StringGrid1.Cells[coluna,linha]);
C:= StringGrid1.Cells[coluna,linha];
// exibição de valores
StringGrid1.Cells[coluna,linha]:= IntToStr(A);
StringGrid1.Cells[coluna,linha]:= FloatToStr(B);
StringGrid1.Cells[coluna,linha]:= C;
9. CheckBox
Esse componente está na aba Standard da barra de componentes. O CheckBox é um

componente que permite a entrada de uma informação do tipo Selecionado/Não
Selecionado (True / False). A figura a seguir mostra três componentes CheckBox
distintos:
a) para verificar se um CheckBox está ou não selecionado, pode-se verificar o
resultado da propriedade Checked. Esta propriedade retorna um valor lógico (True
ou False) indicando se o item analisado está ou não selecionado;
b) a verificação deve ser feita para cada um dos componentes CheckBox existentes. No
exemplo da figura anterior, devem ser feitas três estruturas condicionais, uma para
cada componente;
c) também é possível executar uma sequência de instruções quando o usuário clicar

sobre o CheckBox. Para tal, digite as instruções no método OnClick.
10. CheckListBox
Esse componente está na aba Additional da barra de componentes. O CheckListBox é um

componente que combina particularidades do CheckBox e do ListBox. Apresenta uma
lista de itens, na forma de String, que podem ser selecionados com o auxílio do apontador
do mouse.

20
Propriedades
a) Para preencher a lista de itens do CheckListBox, devemos digitar os valores dentro

da propriedade Items do Object Inspector, exatamente como no ListBox.
Caso o conteúdo deva ser adicionado em tempo de execução do aplicativo, podemos
acrescentar um texto na última linha do CheckListBox, utilizando:
CheckListBox1.Items.Add(‘Texto’);
b) para fazer a leitura ou exibição das informações, é necessário utilizar uma variável
auxiliar indexada unidimensional do tipo lógica, sendo a faixa de valores para o índice
deve começar em zero e terminar em um número compatível com os itens do
CheckListBox. No exemplo da imagem anterior, serão utilizados os itens 0, 1 e 2.
var itensMarcados: array[0..2] of Boolean;
O exemplo a seguir mostra como percorrer todos os elementos do CheckListBox e

armazenar na variável itensMarcados, criada para o exemplo, os valores da
propriedade Checked, que também é um vetor de valores lógicos.
for i := 0 to CheckListBox1.Count-1 do
itensMarcados[i] := CheckListBox1.Checked[i];
c) para obter o texto do item selecionado, devemos verificar qual é o valor da

propriedade Items da posição selecionada, como faríamos em variáveis indexadas.
TextoSelecionado := CheckListBox1.Items[CheckListBox1.ItemIndex];
d) para apagar uma linha qualquer, utiliza-se:
CheckListBox1.Items.Delete(NumeroDaLinha);
e) também é possível executar uma sequência de instruções quando uma opção do

CheckListBox for selecionada. Para tal, utilize o método OnClick para digitar o
código-fonte do que deve ser executado.

21
Capítulo 4 – Um Exemplo de Resolução de Problema

Neste capítulo iremos mostrar o processo de resolução de um exercício desde a leitura e
compreensão do enunciado até o desenvolvimento e teste do aplicativo final.
Passo 1: Leitura e compreensão do enunciado.
“Elaborar um programa que calcule e exiba as raízes de uma equação de segundo grau.”
O primeiro passo consiste em analisar a equação necessária para a resolução do problema:
−𝑏 ± √𝑏 2 − 4𝑎𝑐
𝑥=
2𝑎
São necessários três valores digitados pelo usuário (𝑎, 𝑏 e 𝑐) para calcular as duas raízes (𝑥1
e 𝑥2 ). Além disso, será criada uma variável auxiliar para calcular o valor de delta (𝑑).
Passo 2: Representação da solução na forma gráfica.
Button1Click
Início
a, b, c
d ← sqr(b)-4*a*c
x1 ← (-b+sqrt(d))/(2*a)
x2 ← (-b-sqrt(d))/(2*a)
x1, x2
Fim
Passo 3: Criando o aplicativo.
No Delphi, crie um novo projeto clicando no item New do menu File. Dentre as opções
apresentadas escolha VCL Forms Application – Delphi for Win32.
Adicione um componente Label ao formulário arrastando-o da palheta de ferramentas para
o Form1. Após posicionar o Label verifique se os marcadores de seleção estão visíveis, como
mostra a figura a seguir. Caso não estejam dê um clique sobre o objeto Label1. Com o
objeto selecionado, altere o texto da propriedade Caption no Object Inspector para ‘a:’.

22
Depois disso adicione outros quatro Labels, três Edits e um Button. Modifique as
propriedades de maneira conveniente para que o seu formulário possua a seguinte
aparência:
Para digitar o código-fonte, selecione o Button1 e localize o evento OnClick no Object

Inspector. Dê um duplo clique na região branca desse evento, como mostra a figura a seguir:

23
O Delphi automaticamente irá criar o cabeçalho do procedimento Button1Click. Nessa

região escreveremos o código-fonte de maneira condizente com o fluxograma desenvolvido.
procedure TForm1.Button1Click(Sender: TObject);

var a, b, c, d, x1, x2: real;
begin
a := StrToFloat(Edit1.Text);
b := StrToFloat(Edit2.Text);
c := StrToFloat(Edit3.Text);
d := sqr(b)-4*a*c;
x1 := (-b+sqrt(d))/(2*a);
x2 := (-b-sqrt(d))/(2*a);
Label4.Caption := FloatToStr(‘x1 = ‘, x1);
end;
Clique sobre o botão com a seta verde ou utilize a tecla F9. Isso fará com que seu aplicativo
seja compilado e executado.
O simples fato do programa ter sido compilado não significa que está correto. Como o Delphi
não informou nenhum erro, significa apenas que não existem erros de sintaxe.
Para tentar localizar eventuais erros de lógica, devemos testar alguns valores e compará-los
aos valores de teste do fluxograma. Nesse exemplo, vamos utilizar os valores 1, 2 e 3 para
calcular as raízes do polinômio 𝑥 2 + 2 ∙ 𝑥 + 3 = 0.
Depois de digitar os valores 1, 2 e 3 nos três Edits e clicar sobre o botão, podemos verificar a
seguinte mensagem de erro:
Como podemos observar, a mensagem de erro ‘Invalid floating point

operation’ indica que houve um erro em algum cálculo com valores reais. Para descobrir
qual é a linha onde o erro foi gerado, clique sobre o botão Break.
Note que a linha ‘x1 := (-b+sqrt(d))/(2*a);’ recebe um destaque.
Atenção! Não tente modificar o código-fonte nessa situação. É necessário parar a execução
do aplicativo clicando na opção Program Reset no menu Run.
Vamos lembrar uma técnica para a depuração: dê um clique no ponto ao lado da linha que
recebeu destaque do erro.

24
Note que um círculo aparece e a linha novamente recebe destaque. Quando o aplicativo for
executado novamente, ele irá parar antes da execução dessa linha. Dessa maneira,
poderemos analisar as condições das variáveis que podem gerar o erro.
Execute o aplicativo, apertando a tecla F9 e preencha os Edits com os mesmos valores: 1, 2 e

3.
Note que ao clicar sobre o botão, o código-fonte é exibido novamente com uma seta ao lado
da linha em destaque. Isso significa que a linha ainda não foi executada. Nesse momento é
conveniente utilizarmos um recurso do ambiente Delphi para verificar qual é o valor das
variáveis.
Selecione o item Add Watch... do menu Run. Preencha o campo Expression com o nome da
variável que deverá ser inspecionada. Repita o processo para todas as variáveis desejadas.
A figura anterior mostra que a variável 𝑑 foi calculada como esperado, ou seja,
√𝑏 2 − 4 ∙ 𝑎 ∙ 𝑐. Como os valores 𝑥1 e 𝑥2 ainda não foram calculados, são exibidos valores
remanescentes dos espaços de memória.
Analisando o valor 𝑑 = −8 podemos concluir que esse valor irá gerar um erro quando a raiz
quadrada for calculada, uma vez que √−8 não possui solução real.

25
Pressionando a tecla F7, que executa apenas a instrução em destaque, a linha que calcula 𝑥1
será executada e, como previsto, será gerado um erro.
Para interromper a execução do programa, clique novamente no item Program Reset do
menu Run.
Para resolver o problema, devemos modificar o algoritmo, como mostra o fluxograma a

seguir:
Button1Click
Início
a, b, c
d ← sqr(b)-4*a*c
False True
d >= 0
x1 ← (-b+sqrt(d))/(2*a)
‘Não existem
x2 ← (-b-sqrt(d))/(2*a)
raízes reais.’
x1, x2
Fim
Alterando o código-fonte, temos:

var a, b, c, d, x1, x2: real;
begin
a := StrToFloat(Edit1.Text);
b := StrToFloat(Edit2.Text);
c := StrToFloat(Edit3.Text);
d := sqr(b)-4*a*c;
if d >= 0 then
begin
x1 := (-b+sqrt(d))/(2*a);
x2 := (-b-sqrt(d))/(2*a);
end
else
Showmessage(‘Não existem raízes Reais.’);
end;

26
Capítulo 5 – Outras Funcionalidades

Este capítulo dedica-se aos programadores que desejam tornar seus aplicativos agradáveis
ao usuário, tornando o processo de inserção e exibição de dados mais natural.
Serão apresentados componentes visuais, componentes que fazem a chamada para algumas
funções do Windows, além de estruturas de dados que facilitam o uso e armazenamento de
cores e datas, além de permitir a impressão dos valores obtidos pelo aplicativo.
1. Componentes Visuais
1.1. ComboBox
Esse componente está na aba Standard da barra de componentes. O ComboBox é um

componente cujas funcionalidades são idênticas ao RadioGroup, entretanto, sua disposição
é mais compacta.
a) os elementos do ComboBox devem ser digitados dentro da propriedade Items no

Object Inspector;
valor inteiro da posição do ComboBox selecionado.
TextoSelecionado := ComboBox1.Items[ComboBox1.ItemIndex];
Também é possível conhecer o valor do texto utilizando o ComboBox como se fosse

um Edit.
TextoSelecionado := ComboBox1.Text;
d) também é possível executar uma sequência de instruções quando uma opção do

ComboBox for selecionada (instruções no Método OnClick).

27
Veja a aparência do objeto quando o usuário clica sobre o botão com a seta.
1.2. Image
Esse componente está na aba Additional da barra de componentes. Embora o Image possua
um conjunto de ferramentas associadas à propriedade Canvas que permite a criação de
desenhos em tempo de execução, nos atentaremos a uma característica mais simples,
utilizando-o apenas para exibir uma imagem armazenada em arquivo. Em tempo de
execução as linhas tracejadas que o contornam não são exibidas.
Propriedades
a) Para carregar uma imagem de um arquivo devemos indicar todo o caminho físico
dessa imagem. Isso deve ser feito clicando no botão com três pontos da propriedade
Picture do Object Inspector.
Depois devemos clicar em Load... e selecionar a figura. Para aceitar clique sobre o
botão OK.

28
b) Caso o resultado não seja esperado, ou seja, a imagem original é maior do que a
janela criada pelo Image no formulário, podemos definir o valor True para a
propriedade Proportinoal no Object Inspector. Veja a diferença nas imagens
quando o valor False (esquerda) e True (direita) estão aplicados na propriedade
Proportional.
1.3. SpinEdit
Esse componente está na aba Samples da barra de componentes. O SpinEdit é um

componente muito útil e prático, entretanto, limitado para entrada de dados de números
inteiros.
Propriedades
a) para obter o valor do SpinEdit devemos acessar a propriedade Value, que retorna
um valor inteiro e não texto, como todos os outros apresentados. Veja o exemplo,
considerando que a variável n foi declarada inteira.
n := SpinEdit1.Value;
b) as propriedades inteiras MinValue e MaxValue definem os limites para o valor do

SpinEdit, seja a entrada realizada via teclado ou mouse, quando o usuário clica
sobre os botões com as setas;
c) a propriedade inteira Increment indica qual é o valor do acréscimo ou decréscimo

sofrido pelo valor exibido quando o usuário clicar sobre os botões com as setas. Seu
valor padrão é um.
1.4. PageControl
Esse componente está na aba Win32 da barra de componentes. O PageControl nada mais
é do que um componente para organizar as diferentes funcionalidades do seu aplicativo.

29
Por exemplo, podemos criar várias abas, uma para cadastro de clientes, outra para consulta
de preços e outra para efetuar o balanço do dia. Todas estão relacionadas com as
informações de um comércio qualquer, mas são utilizadas em momentos diferentes do dia.
Isso permite que o formulário possua uma apresentação melhor, sem uma quantidade
absurda de objetos que não são utilizados para a maior parte das tarefas.
Para criar uma aba, denominada TabSheet, clique sobre o PageControl com o botão
direito do mouse e selecione New Page. Repita a operação quantas vezes forem
necessárias.
O exemplo a seguir podemos ver que foram criados dois ambientes, um em cada aba do
PageControl. Note que a numeração dos objetos é contínua em todo o formulário, ou
seja, no TabSheet2 foi criado o Edit2, pois existem dois Edits no programa.

30
1.5. Chart
Esse componente está na aba TeeChart Std da barra de componentes. O componente

Chart é uma ferramenta para exibição de gráficos de diversos tipos, como linha, pizza,
barras e outros. Podemos desenhar várias curvas em um único gráfico.
Criando uma curva
O primeiro passo para criar uma curva é dar um duplo clique sobre o componente Chart,
posicionado no formulário. Isso faz com que a janela Editing Chart1 seja exibida, como na
figura a seguir.

31
Ao clicar sobre o botão Add... uma nova série será criada. Neste momento, é necessário
decidir qual tipo de gráfico será utilizado. Para o exemplo, escolha Line e remova a seleção
da opção 3D. essa opção não cria um gráfico que representa três dimensões, é apenas um
efeito visual de profundidade. Depois disso, clique em OK.
Veja que a Series1 foi criada. Quando criarmos o código-fonte que dá forma a série devemos
alterar as propriedades desse objeto. Além disso, podemos repetir esse passo e criar várias
séries. Isso torna possível criar várias curvas em uma única janela.

32
A série está pronta para ser utilizada, entretanto podemos configurar alguns itens para que o
gráfico traga mais informações.
Selecione a série e clique na aba Axis.
Nessa aba, escolha a aba Title. Selecione Left Axis e dê o nome ao eixo, por exemplo:
“Valores de y”. Depois disso, escolha Botton Axis e faça o mesmo, escrevendo “Valores de
x”. Agora que os eixos das abscissas e ordenadas possuem uma designação, faremos o
mesmo com o ambiente do gráfico, clicando na aba Titles, como mostra a figura a seguir.

33
Em Text digite o título do gráfico.
Em gráficos com mais de uma série é conveniente manter uma legenda que relaciona as
cores das linhas com as séries. No exemplo esse recurso será desabilitado, clicando sobre o
item Visible da aba Style da aba Legend.
Existem muitas outras configurações que podem ser realizadas no assistente de criação das
séries, como, por exemplo, gráficos com eixos invertidos ou em escala logarítmica.
Após concluirmos as configurações, devemos clicar em Close.
Existem duas propriedades da Series que serão utilizadas:

a) Clear: apaga todos os pontos da série;
b) Add: adiciona um ponto à série. Pode ser utilizado com dois parâmetros, sendo o
primeiro o valor da imagem (y) e o segundo o valor do domínio (x) na forma de texto.
Isso permite fazer gráficos por categorias, ou por dias da semana, por exemplo.
Finalmente vamos criar o código-fonte, em um botão, por exemplo, que irá traçar uma curva
específica. No caso, vamos desenhar a função 𝑦 = 𝑒 −𝑥 ∙ 𝑠𝑒𝑛(10 ∙ 𝑥) para o intervalo [0; 4]
da abscissa.

34

var x, xi, xf, dx, y: real;
n: integer;
begin
xi := 0; // limite inferior do domínio
xf := 4; // limite superior do domínio
n := 100; // número de sub-divisões do domínio
dx := (xf-xi)/n; // valor do incremento na direção x
Series1.Clear; // apaga a curva

x := xi; // x recebe o limite inferior
while x < xf+dx do // enquanto x pertencer aos limites do domínio
begin
y := exp(-x)*sin(10*x); // cálculo da imagem
Series1.Add(y,FloatToStr(x)); // adiciona o ponto à Series1
x := x + dx; // próximo x
end;
end;
Após a execução do código-fonte apresentado, podemos observar o seguinte resultado.
Compare o código-fonte com o seu fluxograma. Note que a o uso do componente nada mais
é do que a exibição das coordenadas dos pontos, y e x, nesta ordem.

35
Button1Click
Início
xi ← 0
xf ← 4
n ← 100
dx ← (xf-xi)/n
x ← xi
Enquanto
x < x+dx Faça
y ← exp(-x)*sin(10*x)
y, x
x ← x + dx
Fim Enquanto
Fim
2. Manipulação de Arquivos
2.1. OpenDialog
Esse componente está na aba Dialogs da barra de componentes. O OpenDialog é um

componente que faz uso da interface do sistema operacional Windows para abrir arquivos.
Esse componente não abre o arquivo! Cabe ao programador verificar as informações
fornecidas pelo usuário e abrir ou salvar o arquivo.
Como faz uso de elementos do sistema operacional, sua aparência pode ser diferente em
computadores com versão de Windows diferentes.
Note que o usuário somente perceberá os efeitos quando os componentes forem

executados. Caso contrário, não são exibidos.

36
Propriedades
a) InitialDir: é uma propriedade do tipo texto que recebe um caminho que pode
ser do disco rígido ou até mesmos de um pen drive. Quando OpenDialog é
executado, a pasta que é exibida inicialmente é o caminho definido nessa
propriedade;
b) Execute: é o mecanismo de chamada do OpenDialog. Normalmente utilizado em
uma estrutura condicional, pois retorna o valor True quando o usuário clica sobre o
botão Abrir e False quando o usuário cancela a operação;
c) FileName: é a propriedade que armazena o caminho do arquivo informado.
O código-fonte a seguir mostra um exemplo da execução do OpenDialog em um botão.

Considere que a variável que representa o arquivo lógico arq foi criada globalmente.

begin
// faz a chamada da janela do OpenDialog
if OpenDialog1.Execute then
// o usuário clicou no botão Abrir
begin
// associar o arquivo lógico com o arquivo físico escolhido
AssignFile(arq,OpenDialog1.FileName);
// abrir o arquivo
reset(arq);
end;
end;
Quando a instrução OpenDialog1.Execute é executada, a seguinte janela é exibida.

37
3. Manipulação de Cores
Em algumas aplicações devemos proporcionar ao usuário escolher uma cor. Entretanto, o

computador nos oferece mais de dezesseis milhões de cores. Os elementos que serão
apresentados permitirão criar ferramentas para dar ao usuário a opção de escolher uma cor
pela sua percepção.
3.1. TColor
O TColor é um tipo, assim como o String ou o Integer. Sua modelagem interna permite
armazenar um número inteiro suficientemente grande para manipular as mais de dezesseis
milhões de cores.
Uma vez criada uma variável do tipo TColor, ela pode ser preenchida de duas maneiras
distintas:
a) valores constantes. As constantes de cores começam por cl, como os exemplos

clRed, clBlue, clGreen, clBlack, entre outras;
b) composição de três canais de cores: vermelho, verde e azul. Esses canais são valores
inteiros entre 0 e 255 e devem ser passados via parâmetro à função RGB, que
retorna um valor do tipo TColor.
Var Cor1, Cor2, Cor3: TColor;

...
Cor1 := clRed;
Cor2 := clBtnFace;
Cor3 := RGB(255,0,0); // no exemplo, vermelho
...
Assim como outros tipos de variável, o TColor pode compor campos de registros (record)
criados para a manipulação de arquivos.
3.2. ColorDialog
Esse componente está na aba Dialog da barra de componentes. Assim como o componente
OpenDialog, o ColorDialog somente está visível ao usuário quando executado.
Possui uma região de cores predefinidas e outra para que o usuário possa escolher a cor
visualmente, seja pela percepção, por valores de Matiz, Saturação e Brilho ou as
componentes dos canais Vermelho, Verde e Azul.

38
Propriedades
a) Execute: é o mecanismo de chamada do ColorDialog. Normalmente utilizado

em uma estrutura condicional, pois retorna o valor True quando o usuário clica
sobre o botão Abrir e False quando o usuário cancela a operação;
b) Color: retorna a cor, do tipo TColor, selecionada pelo usuário.
Quando a instrução ColorDialog1.Execute é executada, a seguinte janela é exibida.
3.3. Shape
Esse componente está na aba Additional da barra de componentes. O Shape é um objeto

que exibe uma figura geométrica como retângulos, elipse e retângulos com cantos
arredondados.
a) para escolher a forma do objeto, escolha uma das opções da propriedade Shape no
Object Inspector;

39
b) a cor do preenchimento é definida quando um valor do tipo TColor é atribuído à

propriedade Color da propriedade Brush, como mostra o exemplo a seguir.
Shape1.Brush.Color := clBlue;
c) também é possível executar uma sequência de instruções quando o usuário apertar

um botão do mouse sobre o Shape. Para tal, utilize o método OnMouseDown para
digitar o código-fonte do que deve ser executado. O evento OnClick não está
presente no Shape.
Exemplo de manipulação de cores
O exemplo a seguir mostra como criar uma interface para a entrada de dados em forma de
cor. Em seu formulário, acrescente um componente ColorDialog e um Shape.
Com o objeto Shape selecionado, dê um duplo clique para abrir o evento OnMouseDown no
Object Inspector. Nessa região será digitado o código-fonte que fará a leitura e exibição da
cor escolhida pelo usuário.
procedure TForm1.Shape1MouseDown(Sender: TObject; Button:

TMouseButton; Shift: TShiftState; X, Y:
Integer);
var cor: TColor;
begin
if ColorDialog1.Execute then
begin
cor := ColorDialog1.Color;
Shape1.Brush.Color := cor;
end;
end;
Quando o usuário pressionar um botão do mouse sobre o Shape a janela do ColorDialog

será exibida. Após a escolha da cor, quando a janela estiver oculta, poderemos ver o Shape
todo preenchido com a cor escolhida.
Sob o ponto de vista de fluxograma, essa sub-rotina faz apenas a entrada de dados da
variável cor.
4. Manipulação de Datas
Essa seção destina-se a apresentação de elementos para o armazenamento e manipulação

de datas e horas, além da interface com o usuário.
4.1. TDateTime
O tipo TDateTime é uma estrutura de dados que permite armazenar um valor numérico sob
a forma de data, contendo dia, número da semana, mês, ano, hora, minuto, segundo e
milésimo de segundo.
40
Veja o exemplo da declaração de uma variável.
Var Data: TDateTime;
Assim como outros tipos de variável, o TDateTime pode compor campos de registros
(record) criados para a manipulação de arquivos.
É possível exibir os dados de uma variável do tipo TDateTime de três maneiras distintas
nos objetos apresentados até o momento, bastando fazer a conversão para texto. Veja o
exemplo, considerando que a variável data indica o dia 12.11.1955 e a hora 22:04:00.
Label1.Caption := DateTimeToStr(Data); // exibe 12.11.1955 22:04:00

Label2.Caption := DateToStr(Data); // exibe 12.11.1995
Label3.Caption := TimeToStr(Data); // exibe 22:04:00
4.2. Now
A função Now retorna a data e hora do instante em que foi executada, no formato tipo
TDateTime, com precisão da ordem de milésimo de segundo.
Essa função é muito utilizada em aplicativos que medem o tempo de execução de algoritmos
ou aplicativos que fazem cálculos com datas e horas, como por exemplo, aplicativos para
hotéis, estacionamentos e outros.
Veja o exemplo de como obter o valor da data e hora atual do computador. Considere que a
variável Data, do tipo TDateTime foi declarada como no exemplo anterior.
Data := Now;
4.3. Diferença entre dois instantes
Existem algumas funções que retornam valores inteiros da diferença entre dois instantes de
tempo distintos. Para utilizar essas funções é necessário declarar a biblioteca DateUtilis.
Uses DateUtils;
A tabela a seguir relaciona as funções com a unidade de tempo calculada. Todas as funções
recebem como parâmetro o instante final e o instante inicial, nessa ordem, sob a forma de
um valor do tipo TDateTime.

41
Função Unidade de tempo

MilliSecondsBetween Milissegundos
SecondsBetween Segundos
MinutesBetween Minutos
HoursBetween Horas
DaysBetwwen Dias
WeeksBetween Número de Semanas
MonthsBetween Meses
YearBetween Anos
O exemplo a seguir mostra como calcular quanto milissegundos se passaram durante a

execução de um algoritmo que calcula o comprimento da curva 𝑦 = 𝑥 2 no intervalo [0; 1].

var x, y, xa, ya, dx, c: real;
DataInicio: TDateTime;
tempo: integer;
begin
DataInicio := Now; // hora de início
c := 0; // comprimento inicial
xa := 0; // início do domínio
dx := 1/10000000; // incremento de x
while xa+dx <= 1 do // até valor final
begin
x := xa + dx; // posição futura
y := sqr(x);
c := c + sqrt(sqr(x-xa)+sqr(y-ya)); // calcula comprimento
xa := xa + dx; // incrementa posição atual
ya := sqr(xa);
end;
tempo := MilliSecondsBetween(now,DataInicio); // calcula duração

Label2.Caption := IntToStr(tempo); // exibe duração
Label1.Caption := FloatToStr(c); // exibe comprimento

end;
4.4. DateTimePicker
Esse componente está na aba Win32 da barra de componentes. O componente

DateTimePicker torna a entrada e a exibição de datas de maneira simples e clara ao
usuário.

42
Note que o componente, na sua forma compacta exibe uma data, entretanto, quando o
usuário clica sobre o botão com a seta, o componente se abre e permite a escolha de uma
nova data. Note que existe uma indicação da data atual na forma expandida.
Propriedades
a) A propriedade DateTime pode ser lida ou receber uma informação. Essa informação
é um valor do tipo TDateTime.
O exemplo a seguir considera que uma loja aceita que a primeira parcela de um produto
vendido seja pago quinze dias após a data da compra. Foram utilizados dois componentes
DateTimePicker, um para a entrada de dados (dia da compra) e outro para exibir a data
do pagamento da primeira parcela.

var DataCompra, PrimeiraParcela: TDateTime;
begin
DataCompra := DateTimePicker1.DateTime; // entrada de dados
PrimeiraParcela := DataCompra + 15; // calcula nova
data
DateTimePicker2.DateTime := PrimeiraParcela; // exibe resposta
end;
5. Navegação na Internet
É possível fazer com que suas aplicações acessem sites de maneira muito simples. Como
exemplo, será apresentado como fazer um aplicativo acessar informações cartográficas
utilizando o Google Maps.

43
5.1. WebBrowser
Esse componente está na aba Internet da barra de componentes. O WebBrowser apresenta

uma área que será utilizada para visualizar a página aberta.
Métodos
a) O procedimento Navigate é o responsável pela chamada do acesso à internet.

Possui um parâmetro do tipo String que representa o endereço do site.
O exemplo a seguir mostra como acessar um site cujo endereço foi digitado no componente
Edit1.

begin
WebBrowser1.Navigate(Edit1.Text);
end;

44
Neste outro exemplo vamos mostrar como usar o parâmetro do Nagivate para apresentar
mapas no aplicativo. Será utilizada uma String que possui dois parâmetros: Local e Zoom.
'http://maps.google.com.br/maps?q=' + Local + '&z=' + Zoom
Veja alguns exemplos do conteúdo da variável Local:

a) endereço: 'Praça Mauá, 1 - São Caetano do Sul';
b) CEP: '09580-900';
c) Coordenadas latitude e longitude: '-23.648283,-46.573378';
Neste caso, os dois valores utilizam o ponto como separador decimal e a vírgula
para separar as coordenadas. Valores positivos representam Norte e Leste,
enquanto que negativos são Sul e Oeste para a latitude e longitude,
respectivamente.
d) estabelecimento: 'Instituto Mauá de Tecnologia'.
Segundo a documentação da API do Google Maps, o parâmetro Zoom deve ser um valor
inteiro, mas escrito sob a forma de String, entre 0 e 21.
Uma vez que a aplicação ou o usuário definiram os valores dos parâmetros Local e Zoom,
basta fazer o chamado da página, utilizando o método Navigate.

45
6. Impressão
Em alguns aplicativos é necessário gerar relatórios com o conteúdo armazenado ou

calculado durante a execução. Serão apresentadas duas soluções, com características
totalmente diferentes, mas que permitem imprimir as informações desejadas.
Cabe lembrar que a impressão também deve ser expressa na forma de fluxograma. Desta
maneira, quando desejamos imprimir o nome, o endereço e a idade de uma pessoa,
utilizamos a seguinte representação.
Nome, Endereco, Idade
6.1. Print
Uma solução simples, entretanto não usual em virtude da sua apresentação visual, consiste
em utilizar a propriedade Print do próprio formulário.
Isso faz com que todo o formulário, desde os botões até a barra com os botões maximizar e
minimizar sejam impressas na impressora padrão do usuário.
Form1.Print;
6.2. Rave Report
O Rave Reports é um programa que permite ao usuário criar relatórios de impressão, da

mesma maneira que o usuário adiciona objetos em um formulário, com parâmetros que
podem ser preenchido por um aplicativo criado no Delphi.
Uma vez instalado, devemos ter o cuidado de somente executar o Rave Reports com o
Delphi aberto.

46
O ambiente de confecção do Rave Reports é semelhante à filosofia de confecção da

aparência de um formulário. Podemos notar as abas com os componentes sobre a folha de
trabalho. Serão utilizadas duas abas para gerar o exemplo de um relatório: Standard e
Report.
A principal diferença entre as duas abas consiste na característica dos componentes da aba
Standard serem imutáveis durante a execução do aplicativo em Delphi, enquanto que na
aba Report, o conteúdo dos componentes podem ser alterados, permitindo exibir, por
exemplo, os valores calculados pelo aplicativo.
O exemplo a seguir mostra a criação de um relatório contendo uma imagem e três textos,
sendo um fixo e os outros dois preenchidos por um aplicativo.
a) O primeiro passo consiste em analisar o que deverá ser exibido em função da

resposta do aplicativo que estamos desenvolvendo. No caso, de um Pet Shop, será
cadastrado o nome e a data de nascimento dos cães dos clientes. Isso significa que o
nome e a data são os parâmetros do relatório;
b) para definir esses parâmetros, clique sobre o item Report1 da árvore do projeto e
depois sobre o botão com três pontos do item Parameters do Object Inspector.

47
c) a janela Strings Editor será exibida. Digite o nome dos dois parâmetros desejados.
Vale ressaltar que os parâmetros no Rave Reports são textos e não precisam seguir as
regras para criação de variáveis, ou seja, podem possuir caracteres especiais e
espaços. Depois disso clique em OK;
d) vamos adicionar um componente Text da aba Standard e criar o título do relatório,

alterando as características da fonte e a propriedade Text;
e) depois adicione um componente Bitmap, também da aba Standard. Assim como no

componente Image do Delphi defina a imagem alterando a propriedade Image do
Bitmap;
f) Para exibir o nome e a data de nascimento, adicione dois componentes DataText da

aba Report. Selecione o DataText1 e clique no botão com três pontos da propriedade
DataField no Object Inspector.

48
Escolha o nome do parâmetro em Project Parameters e clique sobre o botão Insert

Parameter. Isso faz que o Data Text seja preenchido com Param.Nome, nesse
exemplo.
É possível concatenar um texto fixo com parâmetros, somando strings. Para tal,
vamos escrever um texto antes do parâmetro no Data Text. Não se esqueça de
utilizar apóstrofos para delimitar o texto.
‘Nome do Animal: ‘ + Param.Nome
Depois disso clique sobre o botão OK;
g) repita os passos do item f) para definir o parâmetro Data para o DataText2.
Veja o resultado na figura a seguir.

49
Salve o arquivo, de preferência na mesma pasta do projeto do Delphi e feche o Rave

Reports.
De volta ao Delphi, vamos criar um botão que irá fazer o chamado ao relatório de impressão
criado no Rave Reports. Para tal, acrescente ao formulário um componente RvProject, da
aba Rave.
Com o objeto RvProject1 selecionado, clique sobre o botão com os três pontos da
propriedade ProjectFile no Object Inspector e escolha o arquivo criado no Rave Reports.
Lembre-se que a extensão desse arquivo é rav.
Depois disso, devemos criar o código-fonte do botão que preencherá os campos do relatório
e o exibirá. A mecânica de funcionamento do objeto RvProject é a seguinte:
a) abrir o projeto com a propriedade Open;

b) preencher os parâmetros com a propriedade SetParameters;
c) fazer a chamada do relatório com a propriedade Execute;
d) fechar o projeto com a propriedade Close.
Note que o código-fonte apresentado a seguir preenche as propriedades ‘Nome’ e ‘Data’

com valores digitados pelo usuário em componentes do tipo Edit.

begin
RvProject1.Open;
RvProject1.SetParam(‘Nome’, Edit1.Text);
RvProject1.SetParam(‘Data’, Edit2.Text);
RvProject1.Execute;
RvProject1.Close;
end;
Veja o resultado quando o botão for pressionado.

50

2011 Delphi XE PDF

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

2011 Delphi XE PDF

Enviado por

Direitos autorais:

Formatos disponíveis

Delphi XE

Daniela Caio André Gomes

CAPÍTULO 1 – AMBIENTE DELPHI...................................................................................................................... 4

Delphi XE – Guia de Componentes

Capítulo 1 – Ambiente Delphi

Ambiente de programação voltado ao desenvolvimento de aplicações para o sistema

A figura a seguir mostra o ambiente de desenvolvimento Delphi XE.

Delphi XE – Guia de Componentes

2. Ambiente de desenvolvimento do Delphi XE

Na primeira parte do curso foi apresentado no ambiente Delphi XE um projeto do tipo

Para confecção de um projeto VCL, o ambiente Delphi disponibiliza os seguintes elementos:

b) Formulário (Form): representa uma janela, que será a janela principal de um

Delphi XE – Guia de Componentes

c) Palheta de ferramentas (Tool Palette): possui um conjunto de componentes

Delphi XE – Guia de Componentes

Para acessar o editor de código selecione a aba Code.

e) Inspetor de Objetos (Object Inspector): Esta janela indica os valores das

Delphi XE – Guia de Componentes

Observação: Clicar com o botão direito do mouse em Properties no Object Inspector.

3.1. Criar um novo projeto

3.2. Salvar um projeto

Delphi XE – Guia de Componentes

3.3. Abrir um novo projeto

Dentre os arquivos apresentados escolha o arquivo de projeto (.dpr).

Delphi XE – Guia de Componentes

Capítulo 2 – Bibliotecas e Funções

1. Conversões: Texto ↔ Número

Quando desejamos exibir um valor numérico em algum componente do formulário,

Delphi XE – Guia de Componentes

Instrução Valor Exibido

Das funções existentes na biblioteca Math, destacam-se três, descritas a seguir:

a) as funções DegToRad e RadToDeg fazem a conversão de valores reais de graus para

b) até o momento, o cálculo da potência de dois valores (𝑥 𝑦 ) era feita da seguinte

Entretanto, essa expressão possui uma limitação, pois o domínio da função ln

Delphi XE – Guia de Componentes

Capítulo 3 – Componentes Básicos

Delphi XE – Guia de Componentes

Esse componente está na aba Standard da barra de componentes. O botão é o principal

a) a propriedade Caption indica o texto que será exibido no botão;

Esse componente está na aba Standard da barra de componentes. O Edit permite a

a) a propriedade Text contém informações digitadas no componente. É o meio mais

Embora os exemplos tenham mostrado o uso do Edit para a leitura de informações,

Delphi XE – Guia de Componentes

a) Para exibir um texto no Label, devemos escrever sobre a propriedade Caption.

Atenção! O Edit possui Text e o Label possui Caption.

Delphi XE – Guia de Componentes

a) para adicionar um texto na última linha do Memo, usa-se:

b) para conhecer o número de linhas (valor inteiro) existentes no Memo faz-se:

d) pode-se apagar uma determinada linha (do tipo Integer) com:

e) para apagar todas as linhas de um Memo.

Esse componente está na aba Standard da barra de componentes. O RadioGroup é um

Delphi XE – Guia de Componentes

a) embora existam elementos dentro do RadioGroup que sejam semelhantes aos

d) também é possível executar uma sequência de instruções quando uma opção do

Esse componente está na aba Standard da barra de componentes. O ListBox é um

a) Para preencher a lista de itens do ListBox, devemos digitar os valores dentro da

Delphi XE – Guia de Componentes

d) para apagar uma linha qualquer, utiliza-se:

e) também é possível executar uma sequência de instruções quando uma opção do

Esse componente está na aba Additional da barra de componentes. O StringGrid permite

a) a quantidade de linhas e colunas do StringGrid pode ser definida diretamente no

Delphi XE – Guia de Componentes

Note que a alteração dessas propriedades modifica apenas a quantidade de linhas e