delphi xe – guia de...

Delphi XE

Guia de Componentes

Daniela Caio André Gomes Jorge Kawamura Roberto Scalco

2011

DDeellpphhii XXEE –– GGuuiiaa ddee CCoommppoonneenntteess

33

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


44

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.


55

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.


66

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).


77

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.


88

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.


99

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.


1100

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.


1111

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,5,5) 1,41420 FloatToStrF(x,ffFixed,2,5) 1,40000 FloatToStrF(x,ffFixed,6,4) 1,4142 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);


1122

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.


1133

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.


1144

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.


1155

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.


1166


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’);


1177

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 ListBox selecionado. Importante! O primeiro item sempre é definido com o índice zero;


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:


1188

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.


1199

// 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;

bb)) 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;

cc)) 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.


2200

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.


2211

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:’.


2222

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:


2233

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.


2244

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.


2255

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

x1 ← (-b+sqrt(d))/(2*a)

x2 ← (-b-sqrt(d))/(2*a)

x1, x2

Fim

d >= 0

‘Não existem

raízes reais.’

TrueFalse

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;


2266

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;

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 ComboBox selecionado. Importante! O primeiro item sempre é definido com o índice zero;


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).


2277

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.


2288

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.


2299

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.


3300

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.


3311

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.


3322

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.


3333

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.


3344


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.


3355

Button1Click

Início

xi ← 0

xf ← 4

n ← 100

dx ← (xf-xi)/n

x ← xi

Enquanto

x < x+dx Faça

Fim Enquanto

y ← exp(-x)*sin(10*x)

y, x

x ← x + dx

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.


3366

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. procedure TForm1.Button1Click(Sender: TObject);

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.


3377

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.


3388

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;


3399

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.


4400

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.


4411

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]. procedure TForm1.Button1Click(Sender: TObject);

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.


4422

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. procedure TForm1.Button1Click(Sender: TObject);

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.


4433

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. procedure TForm1.Button1Click(Sender: TObject);

begin

WebBrowser1.Navigate(Edit1.Text);

end;


4444

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.


4455

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.


4466

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.


4477

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.


4488

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.


4499

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. procedure TForm1.Button1Click(Sender: TObject);

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.


5500

delphi xe – guia de...

Documents