Delphi 7 - Programação inicial

Prévia do material em texto

CENTRO FEDERAL DE EDUCAÇÃO 
TECNOLÓGICA DE SERGIPE 
 
COORDENADORIA DE INFORMÁTICA 
 
 
 
 
 
 
 
 
 
 
 
PROGRAMAÇÃO INICIAL - DELPHI 
 
 
Prof. Mário André 
 
SERGIPE – BRASIL 
CEFET-UNED 
Prof. Mário André 
2 
 
 
INDICE 
 
Paradigmas da Programação ......................................................................................................................... 4 
Tipos Simples ...............................................................................................................................................10 
Tipos Enumerados .........................................................................................................................................10 
Tipo Set ........................................................................................................................................................11 
Tipos com Editor de Propriedades .................................................................................................................11 
Manipulando Eventos ....................................................................................................................................11 
PROJETO EM DELPHI ...................................................................................................................................15 
CONVENÇÃO DE NOMEAÇÃO ....................................................................................................................19 
COMPONENTES ..............................................................................................................................................27 
Propriedades .....................................................................................................................................................29 
Métodos ............................................................................................................................................................30 
Métodos ............................................................................................................................................................30 
Propriedades .....................................................................................................................................................31 
Propriedades .....................................................................................................................................................32 
Crie um formulário conforme lay-out abaixo .....................................................................................................33 
A opção Apaga Tudo só poderá ocorrer após confirmação do usuário.................................................................33 
Propriedades .....................................................................................................................................................33 
Métodos ............................................................................................................................................................33 
Propriedades .....................................................................................................................................................34 
Propriedades .....................................................................................................................................................35 
Métodos ............................................................................................................................................................36 
Propriedades .....................................................................................................................................................36 
Métodos ............................................................................................................................................................36 
Propriedades .....................................................................................................................................................38 
Métodos ............................................................................................................................................................38 
Propriedades .....................................................................................................................................................38 
CHAMADA DE FORMS ..................................................................................................................................52 
COMPONENTES (VCL) ...................................................................................................................................53 
TRATAMENTO DE EXCEÇÕES....................................................................................................................66 
UM POUCO MAIS SOBRE COMPONENTES (VCL) ..................................................................................72 
Opções ..........................................................................................................................................................73 
Valor.............................................................................................................................................................73 
Significado ....................................................................................................................................................73 
Principais Eventos .........................................................................................................................................73 
Evento ..........................................................................................................................................................73 
Descrição ......................................................................................................................................................73 
Principais Métodos ........................................................................................................................................74 
Métodos ........................................................................................................................................................74 
Descrição ......................................................................................................................................................74 
Principais Propriedades .................................................................................................................................74 
Propriedade ...................................................................................................................................................74 
Descrição ......................................................................................................................................................74 
Opções ..........................................................................................................................................................74 
Valor.............................................................................................................................................................74 
Significado ....................................................................................................................................................74 
Principais Eventos .........................................................................................................................................74 
Evento ..........................................................................................................................................................74 
Descrição ......................................................................................................................................................74 
Principais Métodos ........................................................................................................................................75Métodos ........................................................................................................................................................75 
Descrição ......................................................................................................................................................75 
Principais Propriedades .................................................................................................................................75 
Propriedade ...................................................................................................................................................75 
Descrição ......................................................................................................................................................75 
Opções ..........................................................................................................................................................75 
CEFET-UNED 
Prof. Mário André 
3 
Valor.............................................................................................................................................................75 
Significado ....................................................................................................................................................75 
Principais Eventos .........................................................................................................................................76 
Evento ..........................................................................................................................................................76 
Descrição ......................................................................................................................................................76 
Principais Métodos ........................................................................................................................................76 
Métodos ........................................................................................................................................................76 
Descrição ......................................................................................................................................................76 
UM POUCO MAIS SOBRE COMPONENTES (VCL) ..................................................................................76 
Images ..............................................................................................................................................................82 
StateImages ......................................................................................................................................................82 
Items ................................................................................................................................................................82 
ShowButtons ....................................................................................................................................................82 
ShowLines ........................................................................................................................................................82 
ShowRoot .........................................................................................................................................................82 
ReadOnly..........................................................................................................................................................82 
Eventos ............................................................................................................................................................82 
OnEditing .........................................................................................................................................................82 
OnEdited ..........................................................................................................................................................82 
Apêndice A - A Linguagem Object Pascal .................................................................................................84 
Apêndice B - DICAS.......................................................................................................................................87 
Apêndice C - INTRODUÇÃO À ORIENTAÇÃO A OBJETOS ...................................................................92 
REFERÊNCIA BIBLIOGRÁFICA ......................................................................................................................94 
CEFET-UNED 
Prof. Mário André 
4 
 
Paradigmas da Programação 
 
"Paradigma é uma forma de pensar e perceber o mundo real e determina o que 
escolhemos como significativo e o que descartamos ao compreender ou descrever o que existe 
ou ocorre no mundo em torno de nós". 
A mudança de paradigma é uma oportunidade de encontrar novas interpretações para 
antigas questões, bem como, para rever soluções tidas como definitivas. 
 
 
Introdução 
 
Antes de começarmos seria interessante ressaltar que aprender a ser um bom 
desenvolvedor envolve mais do que aprender a sintaxe de uma linguagem de programação em 
particular, isto porque existem muitos outros aspectos do campo do sw, que têm pouca conexão 
com o ato em si de escrever código. 
Se você pode está pensando: "Ora, vamos, eu só quero aprender Delphi", deveria 
também pensar que a questão aqui é que, se você pretende desenvolver sw por dinheiro ou para 
manter-se num emprego, e tem clientes ou chefes esperando que seu sw: 
 
 
 Saia funcionando da caixa, 
 Seja feito a tempo, 
 Seja livre de erros e 
 Seja barato, 
 
 
Então, vamos ter que começar por aqui mesmo, comentando sobre 
problemas como a crise de sw; o ciclo de vida e a engenharia de sw 
porque apenas talento artístico indisciplinado (intuição) não resolve. 
 
Devemos nos lembrar que o objetivo mais direto do desenvolvimento de sw é fazer o 
produto final satisfazer a especificação dos requisitos. Precisamos portanto, dividir isso em algo 
mais tratável. Algum grupo menor ou mais preciso de objetivos que sejam mais alcançáveis e 
fáceis de lembrar. 
Lembre-se de que se tem algo que é sempre permanente é a mudança. Conforme 
sabemos, uma aplicação passará a maior parte de seu ciclo de vida na fase de manutenção. Então, 
é importante termos um conjunto de objetivos que transceda a mudança. 
Entre outros, os quatro objetivos geralmente excluídos da engenharia de software são a 
capacidade de modificação, eficiência, confiabilidade e inteligibilidade. Devemos também 
destacar a ergonomia. 
 
 
Programação Procedimental 
 
A maior parte dos programadores está acostumada a escrever código que é executado 
de forma sequencial. Tais programas possuem inicio, meio e fim bem definidos. Tipicamente, 
estes programas possuem telas de entradas de dados de algum tipo de processamento com estes 
CEFET-UNED 
Prof. Mário André 
5 
dados de forma sequencial. Esta forma de se programar é dita procedimental. A figura 1 ilustra a 
sequencialidade encontrada em programas que seguem tal paradigma. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Esta forma de programar é uma conseqüência direta dos sistemas computacionais 
disponíveis no passado. Estes sistemas eram compostos por uma CPU responsável pelo 
processamento (mestre) e uma série de periféricos (escravos), responsáveis pela entrada e saída 
de dados. 
O custo da CPU era nitidamente superior ao de qualquer periférico e até mesmo ao 
custo do trabalho de quem lidava com estes computadores. Consequentemente, todos os sistemas 
davam prioridade máxima ao processamento, em relação à entrada e saída de dados. 
Os programas desenvolvidos visavam normalmente a solução de problemas de natureza 
científica, que naturalmente requisitavam mais recursos de CPU do que de entrada e saída de 
dados. 
A popularização dos computadoresmodificou este quadro: as aplicações comerciais 
típicas dos dias de hoje exigem uma atenção maior dos programadores (e dos sistemas 
computacionais) para a entrada e saída de dados. 
A hierarquia rígida imposta pela estrutura de menus e a sequencialidade com que os 
formulários são preenchidos pelo usuário impõem limitações sérias na qualidade da interação do 
usuário com o computador na programação procedimental. 
 
Um exemplo não baseado em eventos 
 
 
Program Verif_Nome; 
 
Var Nome : String; 
 
Begin 
Write ('Digite um nome: '); 
Readln (Nome); 
If Nome = 'Ze Silva' then 
 Início 
Entrada de 
Dados 
 
Processamento 
 
 Fim 
CEFET-UNED 
Prof. Mário André 
6 
 writeln ('Nome bem original cara') 
else 
 writeln ('O que poderia dizer'); 
End. 
 
 
Note que o fluxo do programa é bem definido. Primeiramente ele pergunta o nome do 
usuário. Agora, você pode esperar que o usuário introduza seu nome, e não precisa se preocupar 
com nenhuma outra entrada ou ação que ocorra no ambiente. 
Depois que o nome é informado, uma instrução if define o que o programa deve fazer 
em seguida e o programa termina. A lógica deste programa linear é direta e sequencial. O 
modelo baseado em eventos não pode utilizar controle de fluxo do início até o fim, pois o 
aplicativo deve manipular todas as ações ou eventos possíveis 
 
 
Programação Orientada a Eventos 
 
Um aplicativo baseado em eventos, na verdade, não faz nada - a não ser que ocorra um 
evento. É isso mesmo, ele não tem um início ou final lógico. Ele simplesmente precisa saber 
como responde aos diferentes tipos de eventos. Isto não quer dizer que você não pode ter um 
evento que ocorra quando o programa começa ou quando vai se fechar; entretanto, você precisa 
pensar sobre seu modelo de programação de modo diferente. 
No exemplo anterior, você sabia exatamente que ações o usuário executaria - digitar um 
nome. Contudo, pense em aplicativo processador de textos baseado no Windows. Não há meios 
de saber se o usuário digitará uma frase, escolherá uma opção no menu ou dará um clique em um 
botão, na barra de atalho. Independentemente da ação que o usuário executa, o aplicativo precisa 
ser consistente o suficiente para responder ao evento. 
A idéia básica por trás da programação dirigida a eventos é que alguns eventos 
determinam o fluxo do aplicativo. Um programa gasta a maior parte de seu tempo aguardando 
eventos e tem código que responde a diversos deles (nem todos, já que normalmente um 
programa ignora eventos nos quais não tem interesse). Por exemplo, quando o usuário dá um 
clique em um dos botões do mouse, ocorre um evento. É enviada uma mensagem descrevendo 
esse evento para a janela que está sob o cursor do mouse no momento. A aplicação intercepta a 
mensagem e chama o método associado ao evento correspondente. Quando o metodo termina, o 
programa retorna a um estado de espera. 
Como a explanação acima demonstra, eventos são serializados; cada evento é 
manipulado somente após o anterior ter sido completado. Quando uma aplicação está 
executando código de resposta ao evento (ou seja, não está aguardando um evento), outros 
eventos para essa aplicação devem aguardar em uma fila reservada de multitarefa gerenciada 
através de um manipulador de eventos. 
 
 
 
 
 
 
 
 
 
 
CEFET-UNED 
Prof. Mário André 
7 
 Ações Sistema Eventos 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
O avanço da tecnologia barateou o custo dos sistemas computacionais e introduziu recursos gráficos para a 
interação com os usuários (GUI- Graphic User Interface). 
Uma aplicação que se utiliza de interface gráfica, permite que o usuário decida a 
seqüência mais apropriada de interação. Esta abordagem muda completamente a forma de se 
construir programas. 
As interfaces gráficas introduziram assim uma forma completamente nova de se 
programar. Nesta abordagem, uma aplicação constitui-se de um loop para tratamento de eventos 
e de procedimentos associados a eventos específicos. Toda vez que ocorre um determinado 
evento, o seu procedimento equivalente é executado. Eventos acontecem em decorrência da 
interação do usuário com o sistema, gerados pelo sistema operacional ou ainda gerados na 
própria aplicação. Exemplos de eventos: mover o mouse, pressionar uma tecla, selecionar um 
ítem de menu, setar o foco para um determinado controle, etc. 
A cada ação do usuário corresponde um ou mais eventos “enviados” para a aplicação. 
Estes eventos devem ser identificados e tratados de maneira adequada pelo programa. Esta 
abordagem é conhecida como programação orientada a eventos. 
As interfaces gráficas tornaram a interação dos usuários com as aplicações bastante 
atraentes. Em compensação, introduziram uma complexidade enorme do ponto de vista de 
programação. Para se ter uma idéia, o código em linguagem C no windows para escreve na tela 
“Alô mundo” possui cerca de 100 linhas. 
Se acrescentarmos a isto o fato de que 80% do código escrito para uma aplicação é 
consumido na elaboraçào de interface, fica difícil de massificar a programação em ambientes de 
interface gráfica. 
Felizmente, o paradigma da orientação a objetos consegui esconder do programador a 
maior parte da complexidade da programação nestes ambientes. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 Loop de Tratamento dos Eventos 
CEFET-UNED 
Prof. Mário André 
8 
IDE 
 
O ambiente de desenvolvimento do Delphi é composto de várias ‘partes’ compondo um 
conjunto integrado de ‘janelas’ que interagem entre si. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Vamos abordar cada uma separadamente: 
 
O FORM DESIGN 
 
Form é o termo utilizado para representar as janelas do Windows que compõem uma 
aplicação. Os forms servem como base para o posicionamento dos componentes, que são 
responsáveis pela interação entre usuário e máquina. 
Para selecionarmos o form devemos clicar (uma vez) em sua área interna ou na 
object inspector, e não simplesmente em seu título. 
 
As características iniciais do form como tamanho, botões (minimizar, maximizar, fechar, 
controle) e ícone podem (e serão) ser modificadas através de recursos que veremos adiante. 
 
 
 
 
 
 
 
 
 
 
 
CEFET-UNED 
Prof. Mário André 
9 
A BARRA DE MENU PRINCIPAL 
 
Como todo programa padrão Windows, há uma janela onde estão situados os menus da 
aplicação, a barra que contem os menus também agrupa outras partes. 
 
 
 
 
 
 
 
A PALETA DE COMPONENTES 
 
Aplicativos orientados a objetos trabalham com elementos que denominamos 
componentes. No Delphi, os componentes encontram-se em uma paleta com várias guias. 
 
 
 
Pode-se configurar a ordenação das guias clicando com o botão direito do mouse sobre 
qualquer componente e clicar na opção Properties. 
 
 
OBJECT INSPECTOR 
 
Uma das ‘partes’ mais importantes da orientação a objeto é a possibilidade de definir 
características personalizadas aos componentes. 
No Delphi, utilizamos a janela object inspector para realizar esta tarefa. 
 
Há uma caixa de listagem1 que permite 
a escolha de qual componente deverá 
ser selecionado. 
 
Duas guias: 
 
Properties – Define as propriedades e 
valores do Objeto selecionado. 
 
Events – Define quais os eventos serão 
manipulados pelo desenvolvedor. 
 
 
Algumas propriedades trazem opções 
diferenciadas para alteração. 
 
Por exemplo: 
 
 
1 Componente ComboBox. 
Objeto atual 
selecionado 
Propriedade 
Valor atual 
desta 
propriedade 
CEFET-UNED 
Prof. Mário André 
10 
Caption – Permite a inserção de uma 
string de caracteres. 
 
Color – Permite a inserção de um dos 
valores pré-definidos na caixa de listagem. 
 
BorderIcons – Toda propriedade que possui o sinal de + tem a característica de mostrar 
subpropriedades. Deve-se clicar no sinal de + para expandir e no sinal de – para ocultar. 
 
Icon –Exibe um botão de reticências (...) que dará origem a uma caixa de diálogo. 
 
Os nomes definidos como valores das propriedades na object inspector serão os nomes 
usados na construção do código em Object Pascal. 
 
 
Na parte superior da janela há uma caixa de listagem que permite a seleção de componentes já 
inseridos no formulário. Duas guias (Properties e Events) separam as listas de propriedades e 
eventos. 
As propriedades são definidas através de tipos. Podemos citar no exemplo com o objeto form: 
 
Tipos Simples 
São tipos String ou valores numéricos definidos ao digitar um valor na frente da 
propriedade. Exemplo: Name, Caption, Height e Width entre outros. 
 
Tipos Enumerados 
São tipos definidos por uma quantidade limitada de opções que devem ser previamente 
selecionadas, não simplesmente definidas pelo usuário. 
Exemplo: Cursor, BorderStyle e WindowState entre outros. 
 
 
CEFET-UNED 
Prof. Mário André 
11 
Tipo Set 
Algumas propriedades podem conter múltiplos valores. Um exemplo é a propriedade 
BorderIcons com o sinal + indicando subpropriedades. 
 
Tipos com Editor de Propriedades 
As propriedades que são acompanhadas de um ícone de reticências (...) indicam que 
uma janela de diálogo irá auxiliar na escolha de seu(s) valor(es). Exemplo: Icon. 
 
Manipulando Eventos 
A guia Events permite o desenvolvedor definir um handler2 em Object Pascal para um 
determinado evento que pode ser disparado pelo usuário ou pelo sistema. 
Um evento é uma ação disparada dentro de uma aplicação orientada a Objeto. Podemos 
citar as ocorrências dos principais eventos que são disponibilizados na maioria dos componentes 
em Delphi: 
 
Evento Ocorrência 
OnClick Quando o usuário clicar uma vez com o botão esquerdo do mouse sobre o componente. 
OnDblClick Quando o usuário dá um duplo clique no componente com o botão esquerdo do mouse. 
OnEnter Quando o componente recebe o foco. 
OnExit Quando o componente perde o foco. 
OnKeyPress Quando pressiona uma única tecla de caractere. 
 
 
 
Observe a construção do procedimento criado pelo próprio Delphi: 
 
 
procedure TForm1.Button1Click(Sender: TObject); 
 begin 
 
 end; 
 
 
 
CODE EDITOR 
 
O editor de código é responsável por receber todas as declarações criadas pelo Delphi e 
handlers3 criados pelo desenvolvedor. 
E no ambiente Code Editor que implementamos o algoritmo na linguagem Object 
Pascal. 
 
 
2 Manipulador de evento 
3 Manipulador de eventos. 
CEFET-UNED 
Prof. Mário André 
12 
 
 
Na janela do editor pode haver uma outra janela denominada Code Explorer. É a parte 
esquerda da janela, onde podemos ter uma orientação sobre os objetos, procedimentos, funções e 
classes utilizadas na aplicação. Para desligar o code explorer clique no pequeno X ao lado da 
guia do code editor, para visualiza-lo clique com o botão direito dentro do editor e escolha View 
Explorer ou pelo teclado Ctrl+Shift+E. 
Uma característica muito importante do Code Explorer é que quando inserirmos 
componentes no form, a sua declaração é feita pelo Delphi de maneira automática. 
 
 
 
 
 
Podemos considerar também o seguinte fato: 
‘Tudo o que o Delphi escrever, é problema dele’. 
Agora, ‘Tudo o que você escrever é problema seu’. 
 
Code 
Explorer 
Code Editor 
Name do form 
que define uma 
nova classe 
CEFET-UNED 
Prof. Mário André 
13 
Problema no sentido de atualização de código, como veremos adiante. Quando 
alteramos o nome do objeto, deve-se utilizar o mesmo nome nas rotinas implementadas. Agora, o 
que o Delphi declarou, ele se encarrega de atualizar. 
Pode-se personalizar o Editor através do menu Tools | Editor Options. 
 
 
CODE INSIGHT 
 
Um recurso que vai facilitar nossa vida no momento de desenvolvimento de código é o 
Code Insight do Code Editor do Delphi., 
 
Ele atua como um ajudante de complemento junto ao código do desenvolvedor. Por 
exemplo, ao digitar o nome de um objeto seguido de ponto (.) abre-se uma listagem de métodos 
e propriedades que podem ser utilizadas neste objeto. 
 
 
Esta lista pode ser ordenada por nome, clicando com o botão direito dentro da listagem. 
 
 
 
No momento de chamada de procedimentos ou métodos: 
 
 
 
Para forçar o code insight em determinada situação, utiliza-se: 
 Ctrl + Barra de Espaço - Para complemento de objetos; seus métodos e 
propriedades. 
 Ctrl + Shift + Barra de Espaço – Para complemento de parâmetros. 
 
CEFET-UNED 
Prof. Mário André 
14 
Prática 1 - Vamos realizar um pequeno exemplo no Delphi para resultar na execução 
abaixo: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Siga os seguintes passos: 
 
1. Defina para o Formulário no Object Inspector: 
Caption: Pô, que emoção cara 
Name: Form1 
 
2. Insira um botão no formulário (Ver Guia Standard na Barra de Ferramentas) 
3. Defina para o Botao no Object Inspector: 
Caption: Olá Pessoal 
Name: Btn_Ola 
4. Dê um click duplo no botão e aparecerá no editor de código: 
 
 
procedure TForm1.Btn_OlaClick(Sender: TObject); 
begin 
 
end; 
 
 
5. Digite o seguinte comando entre o begin / end; 
MessageDlg('Olá Pessoal', mtInformation, [mbok], 0); 
 
6. Execute a aplicação (Run). 
 
7. Observe o código gerado 
 
Responda: O que ocorrerá se clicarmos no formulário? 
 
 
 
CEFET-UNED 
Prof. Mário André 
15 
PROJETO EM DELPHI 
 
O conceito de projeto em Delphi é baseado em um conjunto de arquivos necessários 
para gerar uma aplicação. 
Vamos destacar os principais arquivos: 
 
Extensão Tipo e descrição Criação Necessário para 
compilar? 
.PAS 
Arquivo Pascal: o código-fonte de uma 
unidade Pascal, ou uma unidade 
relacionada a um formulário ou uma 
unidade independente. 
Desenvolvimento Sim. 
.DPR Arquivo Delphi Project. (Contém código-fonte em Pascal.) 
Desenvolvimento Sim. 
.DFM 
Delphi Form File: um arquivo binário 
(na versão 5 pode ser convertido para 
texto) com a descrição das propriedades 
de um formulário e dos componentes 
que ele contém. 
Desenvolvimento Sim. Todo formulário é 
armazenado em um 
arquivo PAS e em um 
arquivo DFM. 
.DCU 
Delphi Compiled Unit: o resultado da 
compilação de um arquivo Pascal. 
Compilação Apenas se o código-fonte 
não estiver disponível. Os 
arquivos DCU para as 
unidades que você 
escreve são um passo 
intermediário; portanto, 
eles tornam a compilação 
mais rápida. 
.BMP, .ICO, 
.CUR 
Arquivos de bitmap, ícone e cursor: 
arquivos padrão do Windows usados 
para armazenar imagens de bitmap. 
Desenvolvimento: 
Image Editor 
Normalmente não, mas 
eles podem ser 
necessários em tempo de 
execução e para edição 
adicional. 
.CFG 
Arquivo de configuração com opções de 
projeto. Semelhante aos arquivos DOF. 
Desenvolvimento Necessário apenas se 
opções de compilação 
especiais foram 
configuradas. 
.DOF 
Delphi Option File: um arquivo de texto 
com as configurações atuais para as 
opções de projeto. 
Desenvolvimento Exigido apenas se opções 
de compilação especiais 
foram configuradas. 
.DSK 
Arquivo de Desktop: contém 
informações sobre a posição das janelas 
do Delphi, os arquivos abertos no editor 
e outros ajustes da área de trabalho. 
Desenvolvimento Não. Você deve excluí-lo 
se copiar o projeto em um 
novo diretório. 
.EXE 
Aquivo executável: o aplicativo 
Windows que você produziu. 
Compilação: Ligação 
(linking) 
Não. Esse é o arquivo que 
você vai distribuir. Ele 
inclui todas as unidades 
compiladas, formulários e 
recursos. 
.~PA 
Backup do arquivo Pascal 
Pode ser ativado ou desativado através 
do Menu Tools – Editor Options - guia 
display – Item: Create backup file. 
Desenvolvimento Não. Esse arquivo é 
gerado automaticamente 
pelo Delphi, quando você 
salva uma nova versão do 
código-fonte. 
.TODO 
Arquivo da lista to-do, contendo os itens 
relacionados ao projeto inteiro. 
Desenvolvimento Não. Esse arquivo contém 
notas para os 
programadores. 
 
CEFET-UNED 
Prof. Mário André 
16 
O Delphi possui um mecanismo de gerência de arquivos de projetoinformando os 
principais arquivos e seu path. Clique em View – Project Manager 
 
 
 
A figura acima é um exemplo de um projeto inicial, ainda não salvo. O diretório padrão 
para criação dos arquivos é projects, obviamente devemos definir na gravação pasta e nomes de 
arquivos mais específicos. 
 
 
.PAS E .DPR 
 
Para visualizarmos o código fonte da unidade (.PAS) em Delphi basta selecionarmos o 
code editor (F12). 
Para visualizarmos o código fonte no arquivo de projeto (.DPR) basta selecionarmos o 
menu Project – View Source. O arquivo de projeto é exibido em uma guia no code editor. 
Para fechar a guia basta clicar com o botão direito e escolher close page. 
 
 
Unidades 
 
Existem três tipos de unidades: unidades associadas aos formulários (as mais comuns), 
arquivos de unidade usados para armazenar funções e procedures, e arquivos de unidade usados 
para construir componentes. 
Vamos ver una unidade básica associada a um formulário: 
Unit Unit1; 
Interface 
uses 
 Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, 
 Dialogs; 
CEFET-UNED 
Prof. Mário André 
17 
 
O código acima, junto com o código de arquivo de projeto, é tudo de que precisa no 
Delphi para criar um executável que abre uma janela. Ele não fará muita coisa nesse ponto, mas 
é um programa Windows funcional, na sua forma mais simples. 
Veja os nomes na cláusula uses, do código acima. Trata-se dos nomes de outras 
unidades. Se você decidisse escrever várias funções e procedures úteis, poderia criar sua 
unidade, colocar todo seu trabalho útil nela e compilá-la para uso futuro. Vamos ver as partes 
que constitui a unidade: 
Cabeçalho da unidade - Um cabeçalho de unidade identifica o código como uma unit e 
é seguido pelo nome. 
Interface - Marca o início da parte unit interface, que é usada para declarar variáveis, 
tipos, procedures, etc. A parte interface determina o que nessa unidade está disponível para 
outras unidades e partes do programa. A parte interface termina com o início da parte 
implementation. 
Type 
Tform1 = class(Tform) 
 procedure FormCreate(Sender: Tobject); 
private 
 {Declarações privativas} 
public 
 {Declarações públicas} 
end; 
var 
 Form1: Tform1; 
implementation 
{$R *.DFM} 
procedure TForm1.FormCreate(Sender: Tobject); 
begin 
end; 
end. 
CEFET-UNED 
Prof. Mário André 
18 
Uses - A cláusula uses informa ao compilador quais bibliotecas de funções e 
procedures precisam ser compiladas no executável final. O Delphi coloca, automaticamente, 
várias delas lá para você. 
Type - A seção de declaração type é usada para a criação de tipos definidos pelo 
usuário. Esses tipos pode, então, ser usados para definir variáveis. 
Especificadores de visibilidade vêm após a cláusula type na parte da interface. Os 
seguintes especificadores são usados para controlar como os objetos aparecem para outros 
programas e objetos: 
Private - As declarações nessa seção são tratadas como públicas dentro do módulo, mas 
serão desconhecidas e não acessíveis fora da unidade. 
Public - As declarações nessa seção são visíveis e acessíveis fora da unidade. 
Var - Usado para declara varáveis e variáveis de objeto. Em uma unidade de 
formulário, var é usado na parte de interface (o Delphi coloca essa declaração para você) para 
declarar o formulário como uma instância do objeto Tform. Var também é usado para declarar 
variáveis na parte de implementação, assim como em procedures e funções. 
Implementation - É onde todas as funções e procedures que foram declaradas na parte 
interface serão realmente colocadas. Todas as declarações feitas aqui são privativas da unidade 
(não disponíveis para as outras unidades). 
{$R *.DFM) - Em uma unidade de formulário. O Delphi insere essa entrada para você. 
Ela liga o formulário ao seu arquivo.dfm. Não remova isso de seu programa, ou você terá 
problemas. 
O bloco de código a seguir é executado quando seu formulário é criado. Você deve 
colocar aqui, todo o código de inicialização que precise ser executado quando o formulário 
começar a ser carregado. Para criar essa procedure, use o Object Inspector para ver o menu 
Events do formulário e, depois, dê um click duplo no evento OnCreate. 
End. - É o end final, significa o final de sua unidade. 
É importante manter os cabeçalhos, as cláusulas, etc no lugar correto. O Delphi cuida 
muito bem disso para você, pois ele cria a unidade e o código à medida que são feitas alterações 
no formulário. Você simplesmente insere seu código na seção correta, conforme for necessário. 
 
OPÇÕES DE PROJETO 
O Delphi permite a configuração de vários itens do sistema através do menu Project – Options. 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
CEFET-UNED 
Prof. Mário André 
19 
 
 
Forms 
 Main form - Nesta guia permite a escolha do formulário principal da aplicação. 
 Available form - Os formulários available (disponíveis) em caso de criação em tempo de 
execução. 
 
Application 
 Title - Define um nome para a sua aplicação diferente do nome do arquivo de projeto 
(.DPR). 
 Help file – Define o nome do arquivo de Help (.HLP) associado à aplicação. 
 Icon – Define o ícone utilizado no arquivo executável. (.EXE) 
 
Compiler 
 Estas opções permitem especificar uma compilação personalizada, ou seja, cada projeto 
pode ser compilado com uma característica. 
 
Linker 
 Estas opções incluem informações para a depuração. 
 
Directories/Conditionals 
 Nesta guia pode-se configurar o diretório de saída para os arquivos gerados pela 
aplicação. 
 
Version Info 
 Estas informações podem ser visualizadas no Windows através do menu rápido do mouse 
no arquivo executável. 
 
Packages 
 Os packages permitem um controle de distribuição através de DLL’s básicas externas ao 
executável entre outros recursos. 
 
 
CONVENÇÃO DE NOMEAÇÃO 
 
A propriedade mais importante de um componente é a propriedade Name. É ela que define 
o nome interno com relação ao código escrito em Object Pascal. Para organizar e facilitar o 
processo de desenvolvimento/manutenção do sistema, grande parte dos desenvolvedores 
adota uma nomenclatura para tornar o código mais legível possível. 
 
O Delphi adota como nomenclatura padrão o nome da classe da qual o componente é 
instanciado e um número crescente de acordo com o número de ocorrência deste componente no 
form. Exemplo: Button1, Button2, etc... são componentes instanciados da classe TButton . 
 
Não é obrigatória a utilização da convenção de nomes utilizados nesta apostila, mas é 
muito importante fazer uso de uma convenção mais clara possível. 
 
 
 
Exemplo: 
 
CEFET-UNED 
Prof. Mário André 
20 
Nome gerado pelo Delphi Objetivo Convenção 
Button1 Sair da aplicação BtnSair 
Edit1 Receber nome do usuário EdtNome 
Label1 Indicar componente Edit LblNome 
 
 
A Lista de Units 
 
A janela de lista de units permite que você alterne entre as units que fazem parte do 
projeto ativo, sem que elas tenham de estar todas abertas no editor de código. Caso você 
selecione uma unit que não esteja aberta, o Delphi a abrirá e mostrará no Code Editor. 
 
 
 Figura 31 – A Lista de Units 
 
A lista de units pode ser ativada através do menu View, opção Units..., ou através do 
primeiro ícone inferior da SpeedBar ou através da combinação das teclas <Ctrl> <F12>. 
 
 
A Lista de Forms 
 
A janela de lista de forms permite, de forma análoga à de lista de units, que você 
alterne entre os forms que fazem parte do projeto ativo, sem que eles tenham de estar todos 
abertos. Caso você selecione um form que não esteja aberto, o Delphi o abrirá e mostrará para 
edição no Form Designer. 
 
CEFET-UNED 
Prof. Mário André 
21 
A lista de forms pode ser ativada através do menu View, opção Forms..., ou através do 
segundo ícone inferior da SpeedBar ou através da combinação das teclas <Alt> <F12>. 
 
 
A Lista de Janelas 
 
A janela de lista de janelas do ambiente, embora menos utilizadado que as de lista de 
units e forms, apresenta uma forma rápida de encontrar-se uma janela, que esteja escondida atrás 
de muitas outras. 
 
 
A lista de janelas pode ser ativada através do menu View, opção Window List..., ou 
através da combinação das teclas <Alt> <0>. 
 
 
Prática 2 - Exercício de Gerenciamento de Projetos 
 
1. Finalidade: Demonstração das diversas forma de Gerenciamento de Projetos 
 
2. Roteiro: 
 
a. Crie uma pasta Aulas Delphi e dentro desta outra Gerencia de Projeto 
 
b. Inicialize o Delphi 
 
c. Insira um Label com Caption 'Formulário 1' 
 
d. Salve o projeto com Projeto_1 e a unidade com Unit_1. Através de: 
Opção File Save All do Menu File 
Opção File Project AS do Menu File 
4º ícone superior do Speed Bar (SB) (Projeto) 
 3º ícone superior do Speed Bar (SB) (Unidade) 
 
e. Observe o código de Unit_1 
 
f. Insira novo formulário ao Projeto 
Opção New do Menu File 
Opção New Form do Menu File 
4º ícone inferior do SB 
CEFET-UNED 
Prof. Mário André 
22 
 
g. Salve a unidade com Unit_2 
 
h. Insira novo formulário ao Projeto utilizando opção diferente da 1ª. 
 
i. Salve a unidade com Unit_3 
Observe que as unidades podem ser selecionadas pelas guias, que <F12> ou o clique no 3º 
ícone inferior do SB alterna entre unidade e formulário ou utilizando o 1º ou 2º ícone inferior 
do SB.. 
 
j. Salve todo o Projeto 
 
k. Remova a Unit_2 do Projeto 
Botão Remove da Opção Project Manager do Menu View 
No Project Manager, botão direito sobre o nome do projeto ou unit, opção Remove File ... 
Opção Remove from Project do Menu Project 
7º ícone superior do SB 
 
l. Adicione a Unit_2 ao Projeto 
No Project Manager, clicar com botão direito sobre o nome do projeto, opção Add ... 
Opção Add to Project do Menu Project 
6º ícone superior do SB 
 
m. Observando o código do Projeto 
 Opção View Source do Menu Project - Observe seu nome na Guia de Units 
 (para fechar utilize botão direito do mouse - Opção Close Page) 
 
n. Atente para a cláusula uses e seu código (begin ... end.) 
 Qual o formulário que será criado quando a aplicação for executada? 
 
p. Execute a aplicação e vamos conferir qual o formulário criado. 
 
q. Feche a aplicação 
 
r. Alterando o formulário principal do Projeto 
Opção Options do Menu Project, observando o nome do formulário da ListBox Main Form 
 
s. Altere o nome do formulário principal para Unit_2 
 
t. Observe o código do Projeto e execute-o 
 
u. Torne a Unit_2 disponível 
 
v. Observe o código do projeto 
O que ele nos informa? 
 
w. Feche a Aplicação 
 
x. Abra novamente a aplicação e observe quantos forms são trazidos para você inicialmente 
 
CEFET-UNED 
Prof. Mário André 
23 
Para ativar os forms que deseja trabalhar, utilize o 2º ícone inferior do SB ou View 
Project Manager, selecione o form, clique com botão direito e escolha a opção Open. 
 
 
Modularização 
 
É muito indicado que você modularize o seu projeto. Isto implica também em não 
misturar funcionalidades diferentes na mesma unit. 
Como assim? Você não deve colocar strings nem valores constantes diretamente no 
código. Isto aumenta o trabalho quando for necessário alterar determinado valor. Teremos que 
procurar em todos os módulos para saber onde fazemos referência àquele valor. E cuidado para 
não confundir com uma mesma constante que possua, por coincidência, o mesmo valor que a que 
estamos procurando. 
Para resolver este problema, você deve criar constantes e atribuir valores a estas 
constantes. Mas não defina estas constantes em qualquer unit. Crie uma unit que irá abrigar 
somente a definição das constantes do projeto. Você pode nomear esta unit com qualquer nome, 
exceto Const.Pas, porque const é uma palavra reservada. 
 
 
Diretórios 
 
Via de regra, é aconselhado utilizar um diretório para cada projeto Delphi. Isto porque 
facilita bastante a identificação dos vários arquivos. 
Um dos pontos mais importantes de um projeto é saber quais arquivos são necessários 
para uma compilação completa (build). Quando temos mais de uma aplicação por diretório, esta 
identificação passa a ser um problema. 
Exemplo: C:\Sistema 
C:\Sistema\Doc 
C:\Sistema\Dados 
C:\Sistema\Dll 
C:\Sistema\Icones 
 
Não perca este objetivo de vista: projeto e organização são os requisitos mais 
importantes para um bom desenvolvimento. 
 
Para aprendermos a depurar um programa, defina uma aplicação conforme o form e 
código abaixo: 
 
 
 
 
 
CEFET-UNED 
Prof. Mário André 
24 
 
unit Unit1; 
 
interface 
 
uses 
 Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs, 
 StdCtrls; 
 
type 
 TForm1 = class(TForm) 
 Button1: TButton; 
 Edit1: TEdit; 
 Edit2: TEdit; 
 Label1: TLabel; 
 procedure Button1Click(Sender: TObject); 
 private 
 { Private declarations } 
 procedure SomaNum; 
 public 
 { Public declarations } 
 end; 
 
var 
 Form1: TForm1; 
 
implementation 
 
{$R *.DFM} 
procedure TForm1.SomaNum; 
 var Value1, Value2, Total : integer; 
 
begin 
 Value1 := StrToInt (Edit1.text); 
 Value1 := StrToInt (Edit2.text); 
 Label1.Caption := IntToStr(Value1 + Value2); 
end; 
 
procedure TForm1.Button1Click(Sender: TObject); 
 
begin 
 SomaNum; 
end; 
 
end. 
 
Agora, execute o programa, introduza dois números pequenos, pressione o botão Ok e 
observe que o resultado está incorreto. Para descobrir por que, vamos usar o depurador para 
percorrer o código e ver o que aconteceu. 
 
 
Definindo um Ponto de Quebra (BreakPoint) 
 
Um ponto de quebra permitirá que o programa seja executado normalmente, até 
encontrá-lo, e então o depurador parará na linha em esse ponto foi definido, sem executá-la. 
 
CEFET-UNED 
Prof. Mário André 
25 
Para definir um ponto de quebra, dê um duplo clique na mediamiz (a área cinza à 
esquerda do código no editor) ao lado da linha para a qual você quer definir o ponto de quebra, 
ou então tecle <F5> na desejada. Na realidade, esses procedimentos ativam e desativam pontos 
de quebra. 
 
 O editor de código mostrando a mediatriz com um ponto de quebra assinalado 
 
Execute o programa. digite 4 e 5 e depois pressione o botão Ok. O editor deve aparecer, 
mostrando a posição em que o ponto de quebra foi definido, conforme figura 27. Agora o ponto 
de quebra tem uma marca verde na mediamiz, mostrando que você parou neste ponto, e uma seta 
verde apontando para a direita aparece na mediamiz, mostrando sua posiçao no código. Esta 
linha ainda não foi executada, ou seja, a seta verde aponta para a próxima linha de execução. 
 
 
 O editor de código no modo debug, mostrando o programa interrompido em um ponto de quebra 
 
Você pode definir pontos de quebra especiais que interromperão a execução apenas se 
certas condições ocorrerem ou em uma passagem por um loop em particular. Isto pode 
ser muito útil, se seu código falha somente em certas condições ou no meio de um 
loop muito grande. Para definir condições ou contagem de passagem, você usa a opção 
de menu Run | Add Breakpoint para acessar a caixa de diálogo Edit Breakpoint. 
 
 
CEFET-UNED 
Prof. Mário André 
26 
Opções de Depuração 
 
O menu Run do Delphi contém algumas opções de depuração adicionais, que têm 
toques de tecla de atalho correspondentes: 
 
Opção Significado 
Run (F9) Compila e executa iu, no modo depurador, continua a executar a partir desse 
ponto. 
Step Over (F8) Executa cada linha do código, mas não entra nas chamadas de funções e 
procedures. 
Trace Into (F7) Permite que o depurador siga o código de uma chamada de função ou 
procedure. 
Trace to Next Source Line 
(Shift F7) 
Segue até a próxima linha executável. 
Runt to Cursor (F4) Executa até a posição corrente do cursor, na janela do editor 
Show Execution Point Coloca o cursor no ponto de execução corrente. 
Program Reset (Ctrk F2) Finaliza a execução do programaComo examinar valores variáveis com Sentinelas 
 
Existem duas maneiras de examinar o valor armazenado em variáveis: usando 
sentinelas e usando o novo recurso ToolTip Expression Evaluation (que já foi discutido 
anteriormente). 
Uma sentinela permite que você especifique nomes de variável que deseja monitorar e 
apresentar seus valores numa pequena janela. Para inserir uma sentinela, você pode pressionar 
<Ctrl> <F5> ou selecionar Run | Add Watch para acessar a caixa de diálogo Watch Properties, 
conforme a figura. Em uma sentinela, você pode especificar nomes de variável e expressões 
como Valor1 + Valor2 ou StrToInt(Valor1). 
 
 
 A caixa de diálogo Watch Properties 
 
 
CEFET-UNED 
Prof. Mário André 
27 
 
 A janela Watch List 
 
 
Na caixa de diálogo Watch Properties, digite Value1 na caixa de texto Expression. Isto 
cria a janela Watch List, onde as variáveis controladas e seus valores correntes serão 
apresentados, como na figura. 
Se a variável ainda não foi criada ou atribuída, várias mensagens serão apresentadas, 
indicando o status da variável em que o valor normalmente estaria. A mensagem pode indicar 
Process not accessible, o que significa que o código que cria essas variáveis não foi iniciado ou 
que ele terminou e as variáveis foram retiradas da memória. 
Você também poderia ver a mensagem Inaccessible here due to optimation, que 
normalmente significa que a variável ainda não foi atribuída. Quando as linhas de código que 
tratam da variável que você atribuiu uma sentinela são executadas, o valor é apresentado na 
janela Watch List. 
 
 
COMENTÁRIOS 
 
Os comentários no código fonte são importantes e podem ser feitos através dos 
seguintes símbolos: 
 
//Comentário de linha 
{ Comentário de bloco } 
(*Comentário de bloco *) 
 
 
 
COMPONENTES 
 
Agora definiremos resumidamente os principais componentes do Delphi, bem como as 
suas principais propriedades e eventos. Logicamente, este material não se constitui num manual 
dos componentes do Delphi, mas sim visa introduzir o programador nos recursos disponíveis. 
Antes de iniciarmos as discussões sobre os componentes, iremos nos ater à explicação 
de algumas peculiaridades das propriedades dos componentes. O primeiro ponto a ser observado, 
está no fato de que algumas propriedades só são acessíveis em tempo de execução. Quando 
acontecer tal fato, chamaremos atenção a esse respeito. 
 Finalmente, existem propriedades onde o Delphi incorpora um construtor de valores. 
Para estes casos, aparece um botão com reticências no canto da coluna valor, do Object 
Inspector, isto quando a propriedade é selecionada. Para abrir o construtor de valores basta um 
clique neste botão, ou um duplo clique na propriedade. 
CEFET-UNED 
Prof. Mário André 
28 
É bom lembrar que ao criarmos uma aplicação, um dos detalhes mais importantes que 
devem ser considerados é a interface com o usuário. Porque se ela for feia ou difícil de ser 
entendida será mal usada e isto é a linha que divide o sucesso do fracasso no ramo de software. 
O que se segue é uma referência dos componentes de interface mais utilizados. 
Vamos considerar alguns objetos e suas principais propriedades, métodos e eventos. 
 
 
Principais Eventos 
 
Os eventos recaem em três categorias: de Mouse, de teclado, ou de Sistema. A maioria 
dos componentes possui um evento padrão. Para verificar isso dê um duplo clique sobre o 
componente no formulário.Os três eventos padrão são OnChange, OnClick e OnCreate, nesta 
ordem. 
Se um componente não responder a nenhum deles, significa que ele não possui evento 
padrão. 
Verificação: Dê um duplo clique na área do formulário e terá seu evento padrão, 
depois faça o mesmo no Label. Insira um Edit e dê um duplo clique. 
 
Evento Descrição 
OnChange Acontece quando o objeto ou seus dados mudam 
OnClick Clique simples do mouse sobre o componente ou Enter no componente 
OnDblClick Duplo clique do mouse sobre o componente 
OnEnter Ocorre quando o componente recebe foco 
OnExit Ocorre quando o componente perde foco 
OnMouseDown O botão do mouse é pressionado sobre o componente 
OnMouseMove O ponteiro do mouse passa sobre o componente 
OnMouseUp O botão do mouse é liberado sobre o componente 
OnKeyDown Uma tecla é pressionada. É enviado para o componente com o foco de entrada. 
OnKeyPress Uma tecla de caractere é pressionada. Idem 
OnKeyUp Uma tecla é liberada. Idem 
OnDragDrop O componente está sendo arrastado e é solto num local permitido 
OnDragOver O componente está sendo arrastado e passa sobre outro componente 
OnEndDrag O componente está sendo arrastado e é solto num local permitido ou não 
OnStartDrag Acontece quando o usuário começa a arrastar; é enviado para o componente que originou 
a operação de arrasto. 
 
 
 
Principais Métodos 
 
Método Descrição 
BringToFront Coloca o componente na frente dos outros 
CanFocus Determina se o controle pode receber o foco 
Create Cria uma instância do componente 
Destroy Destrói a instância. Na verdade, deve-se utilizar o Free 
Focused Retorna se o foco está sobre o componente 
Free Destrói a instância e desaloca a memória 
Hide Torna o controle invisível 
SetFocus Faz com que o controle receba o foco 
SendToBack Coloca o componente atrás dos outros 
Show Torna o controle visível 
CEFET-UNED 
Prof. Mário André 
29 
Clear Limpa o conteúdo do componente 
 
 
Objeto – Form (Formulário) 
 
Paleta – Standart 
 
Importância: É o principal componente 
container pois permite posicionar os demais 
componentes em si mesmo. 
É literalmente a implementação do conceito de 
‘janelas’ do sistema operacional Windows. 
 
 
Propriedades 
ActiveControl Permite definir qual o primeiro componente a receber foco assim que o formulário é 
criado. 
Align Altera o alinhamento e preenchimento do objeto. 
AutoScroll Permite habilitar as barras de rolagem. 
AutoSize Determina se o controle será automaticamente redimensionado. 
BorderIcons Determina os ícones a serem exibidos na barra de título do formulário. 
BorderStyle Define o estilo da borda do formulário. 
bsDialog – Borda não redimensionável, comum em caixa de diálogo 
bsSingle – Borda simples e redimensionável. 
bsNone – Borda invisível, não redimensionável, sem botões de controle. 
bsSizeable – Borda padrão redimensionável. 
BorderWidth Define a espessura da borda. 
Caption Indica o rótulo exibido para o componente. 
ClientHeight / 
ClientWidth 
Define a altura e largura da área cliente. 
Color Define a cor de fundo de um componente. 
Cursor Indica a imagem exibida pelo ponteiro do mouse quando este ficar sobre o objeto. 
DefaultMonitor Associa o form a um monitor específico em uma aplicação que utiliza vários monitores. 
Enabled Define se o componente está habilitado ou não. 
Font Permite controlar os atributos do texto exibido em um componente. 
FormStyle Determina o estilo do formulário. 
fsNormal – Definição padrão do formulário. 
fsMDIChild – O formulário será uma janela-filha de uma aplicação MDI. 
fsMDIForm – O formulário será o formulário-pai de uma aplicação MDI. 
fsStayOnTop – O formulário permanece sobre todos os outros formulários do projeto, 
exceto aqueles que também têm a propriedade FormStyle igual a fsStayOnTop. 
Height Define a altura do objeto. 
HelpContext Define o tópico do arquivo help que será exibido ao pressionar a tecla F1. 
HelpFile Define um arquivo de help específico. 
Hint Permite exibir um texto de auxílio no momento em que o ponteiro do mouse permanece 
sobre o controle. 
HorzScrollBar Define o comportamento de uma barra de rolagem horizontal. 
Icon Define o ícone que será usado pelo formulário. 
KeyPreview Define se o formulário deve ou não responder a um pressionamento de tecla, através do 
evento OnKeyPress, por exemplo. 
Left Define a coordenada da extremidade esquerda de um componente. 
Menu Permite escolher entre mais de um componente MainMenu. 
Name Define onome interno que identifica o componente dentro da aplicação. 
PopupMenu Define o componente PopupMenu a ser utilizado pelo objeto. 
Position Permite definir o tamanho e posição de um formulário no momento em que ele aparece 
CEFET-UNED 
Prof. Mário André 
30 
na sua aplicação. 
ShowHint Define se a string de auxílio deve ou não ser exibida quando o usuário mantém o 
ponteiro do mouse sobre um controle. 
Tag A propriedade Tag é uma variável do tipo Longint que o Delphi coloca à disposição do 
usuário, que pode atribuir o significado mais conveniente. 
Top Define a coordenada da extremidade superior de um componente. 
VertScrollBar Define o comportamento de uma barra de rolagem vertical. 
Visible Define se o componente aparece ou não na tela. 
Width Define a largura do objeto. 
WindowMenu Permite definir qual o menu responsável por manipular as janelas-filhas de uma 
aplicação MDI. 
WindowState Define o estado de exibição de um formulário. 
 
Métodos 
Show Exibe o formulário de manipulação não-modal. 
ShowModal Exibe o formulário de manipulação modal. 
Close Permite fechar o formulário. 
 
 
Objeto – Button1 (Botão) 
 
Paleta – Standart 
 
Importância: É um dos objetos mais utilizados 
para confirmar e disparar rotinas associadas. 
 
 
 
Propriedades 
Action Referencia uma ação definida em um objeto TActionList. 
Anchors Permite manter a posição relativa do objeto ao objeto ‘parente’ quando este é 
redimencionado. 
Cancel 
Associa o evento OnClick do objeto ao pressionamento da tecla Esc. 
Default 
Associa ao evento OnClick do objeto ao pressionamento da tecla Enter. 
ModalResult Propriedade utilizada para encerrar a execução de um formulário Modal quando 
selecionado um valor diferente de mrNone. 
Parent... As propriedades Parent permitem que o componente receba a mesma formatação do 
objeto proprietário. 
TabOrder Define a ordem na passagem de foco no momento de pressionamento da tecla TAB. 
TabStop Define se o foco pára no componente. 
 
Métodos 
SetFocus Envia o foco do windows para o componente. 
 
 
 
 
CEFET-UNED 
Prof. Mário André 
31 
 
 
Objeto – Edit (Caixa de edição) 
 
Paleta – Standart 
 
Importância: Um dos principais componentes 
para a entrada de dados do usuário do sistema. 
 
 
 
Propriedades 
AutoSelect Define se o texto exibido pelo controle será selecionado quando este receber o foco da 
aplicação. 
AutoSize Para componentes TEdit a propriedade determina se a altura do controle será 
redimensionada quando o tamanho da fonte for alterado. 
BorderStyle Determina o tipo da borda do componente. 
CharCase Determina o se tipo da fonte será maiúscula, minúscula ou normal. 
HideSelection Define se o texto perde a seleção ao perder o foco. 
Maxlength Define um limite para a inserção de caracteres. 
PasswordChar Define qual caractere será usado para ocultar o texto inserido no componente. 
Text 
Permite manipular os caracteres inseridos no componente pelo usuário. 
 
Métodos 
Clear Limpa o conteúdo da propriedade text. 
SetFocus Envia o foco do windows para o componente. 
 
 
 
Exercício 
Confeccione um formulário conforme esquema abaixo: 
 
Funcionalidade: 
1. As caixas de edição e os rótulos só ficarão habilitados se ‘Delphi’ for digitado na 1ª caixa 
CEFET-UNED 
Prof. Mário André 
32 
 
2. O botão Ok só ficará habilitado se o texto das últimas caixas forem iguais e diferentes de 
branco. 
 
Altere as seguintes props do formulário: 
Ctl3D = False, BorderStyle = bsDialog, Height = 225, Width = 280 e Position = poCenter 
Faça com que as teclas <Enter> ou <Esc> finalize a aplicação. 
Faça as três caixas de edição ficarem sem texto e que para cada caractere digitado um @ seja 
exibido. 
Faça com o acesso mnemônico aos rótulos ative a caixa de edição correspondente. 
Defina o evento para fechamento do formulário através do clique nos botões 
Desabilite o botão Ok, os dois últimos rótulos e as duas últimas caixas de edição. 
 
 
Objeto – Label (Rótulo de orientação) 
 
Paleta – Standart 
 
Importância: Orientar o usuário à escolha de 
componentes bem como sua utilização. 
 
 
Propriedades 
Alignment Define o alinhamento da string na área do componente. 
AutoSize Para componentes TDBText e TLabel, esta propriedade define se o controle será 
automaticamente redimensionado para acomodar o texto. 
FocusControl 
Define qual o componente receberá foco quando o usuário selecionar a combinação de 
teclas aceleradoras (atalho) se existir. 
Layout Define o alinhamento vertical do texto na área do componente. 
ShowAccelChar Define se o caracter ‘&’ será um literal ou tecla de aceleradora (atalho). 
Transparent Define se o fundo do componente será ‘transparente’ ou não. 
WordWrap Define se o texto poderá utilizar o ‘retorno automático’ em caso de ultrapassar a largura 
definida e se a propriedade AutoSize estiver falsa. 
 
 
Objeto – Memo (Memorando) 
 
Paleta – Standart 
 
Importância: Permite o usuário entrar com 
dados do tipo TStrings, compara-se à 
funcionalidade do software bloco de notas. 
 
CEFET-UNED 
Prof. Mário André 
33 
 
Exercício: 
Crie um formulário conforme lay-out abaixo 
Para as opções de Adiciona na Posição e Apaga Linha, a Caixa de Edição Linha, deve 
ser preeenchida com um valor menor que a da Caixa de Edição Total de Linhas 
A opção Apaga Tudo só poderá ocorrer após confirmação do usuário 
Antes de Carregar e Salvar Arquivo, verificar se o nome do arquivo foi fornecido na 
Caixa de Edição Arquivo 
 
A Caixa de Edição Total de Linhas deverá se alterar obviamente toda vez toda vez que 
o conteúdo do memo for alterado e o seu valor não pode ser alterado pelo usuário 
 
 
 
Propriedades 
Lines Propriedade do tipo TStrings que contém as linhas de texto do componente. 
MaxLength Define o limite máximo de caracteres no componente em sua propriedade Lines. 
ReadOnly Define se o componente é do tipo somente leitura. 
ScrollBars Define se o componente pode trabalhar com barras de rolagem. 
WantReturns Define se a tecla ENTER será utiliza para ‘quebra de linha’. 
WantTabs Define a tecla Tab como tabulação ou mudança de foco. Caso falso pode-
se utilizar CTRL+TAB para produzir o efeito desejado. 
 
Métodos 
LoadFromFile Permite ‘carregar’ um arquivo para a propriedade Lines. 
SaveToFile Permite salvar o conteúdo da propriedade Lines em um arquivo especificado. 
 
 
 
 
 
CEFET-UNED 
Prof. Mário André 
34 
Objeto – CheckBox (Caixa de verificação) 
 
Paleta – Standart 
 
Importância: Permite verificar opções boolenas 
pré-definidas ou re-definidas pelo usuário. 
 
 
Propriedades 
AllowGrayed Define caso verdadeiro, três estados possíveis para o checkbox: checked (ligado), 
unchecked (desligado) e grayed (parcial). Caso falso, dois estados: checked (ligado) e 
unchecked (desligado). 
Checked 
Define se o componente está ligado ou não, caso tenha apenas dois estados. 
State Permite definir três estados se AllowGrayed for verdadeiro. 
 
Exercício 
Confeccionar uma aplicação conforme lay-out abaixo. 
 
Defina o codigo inicialmente prevendo que os CheckBoxs tenham a prop. AllowGrayed = False 
e execute. Depois defina o código com essa prop. = True 
 
Funcionalidade: Ao se marcar um item, adicionar 1 na Caixa de Edição Total de Itens 
assinalados. E ao se desmarcar um, decrementar o valor desta Caixa. 
 
 
 
CEFET-UNED 
Prof. Mário André 
35 
Objeto – RadioButton (Botão de ‘radio’) 
 
Paleta – Standart 
 
Importância: Permite escolher entre um grupo, 
pelo menos uma opção. 
 
 
Propriedades 
Checked 
Define se o componente está ligado ou desligado. 
 
Exercício 
Confeccionar uma aplicação conforme lay-out abaixo. Insira primeiro o GroupBox e 
depois os botões de rádio. Observe que é interessante definir acessos mnemônicos para os 
botões. 
 
Funcionalidade: Para “Nada a Fazer”, tire a marca do botão assinaloado e para “O que 
Fazer” exiba como mensagem o Caption do botão assinalado. 
 
 
Objeto – ListBox (Caixa de listagem) 
 
Paleta – Standart 
 
Importância: Permite o usuário entrar ou 
manipularuma lista de dados. 
 
 
CEFET-UNED 
Prof. Mário André 
36 
Propriedades 
Items 
Define uma lista de Strings que aparece no componente. 
MultiSelect Permite selecionar vários itens (Strings) no componente. 
Sorted Define se a lista de Strings será ordenada ou não. 
 
Métodos 
Clear Permite limpar o conteúdo da propriedade Items. 
LoadFromFile Permite ‘carregar’ um arquvo para a propriedade Items. 
SaveToFile Permite salvar o conteúdo da propriedade Items para um arquivo. 
 
 
Objeto – ComboBox1 (Caixa de listagem em formato de cortina) 
 
Paleta – Standart 
 
Importância: Permite o usuário entrar ou 
manipular uma lista de dados. 
 
 
Propriedades 
Items 
Define uma lista de Strings que aparece no componente. 
Sorted Define se os dados serão ordenados. 
Text 
Define o texto atual da Combobox. 
 
Métodos 
Clear Permite limpar o conteúdo da propriedade Items. 
LoadFromFile Permite ‘carregar’ um arquvo para a propriedade Items. 
SaveToFile Permite salvar o conteúdo da propriedade Items para um arquivo. 
 
 
Exemplo: 
Insira uma ComboBox num formulário limpo e defina as propriedades: 
Sorted = True, Style = csSimple (redimensione a caixa para poder ver parte dela) 
No evento OnKeyPress, defina 
If key = # 13 then // Se teclou <Enter> 
Begin 
 if (ComboBox1.Text <> ‘’) and (ComboBox1.Items.IndexOf(Combox1.Text) < 0) then // não duplic. 
 ComboBox1.Items.Add(ComboBox1.Text); 
 ComboBox1.Text := ‘’; 
 Key := #0; 
End; 
Assim, toda vez que o <Enter> for teclado, a digitação realizada será inserida na ComboBox. 
CEFET-UNED 
Prof. Mário André 
37 
 
 
Exercício: 
 
Utilizando a figura abaixo, produzir um aplicação que apresente a seguinte funcionalidade: 
 pressionamento do botão Adicionar, aciona o nome escrito na caixa de texto na ComboBox. 
 
 pressionamento do botão Nova, habilita o botão Adicionar, seta o foco da aplicação na Caixa 
de texto, desabilita o botão Nova e Excluir. 
 
 pressionamento do botão Limpar, limpa o conteúdo da Caixa de Texto e todos os elementos 
da ComboBox. 
 
 pressionamento do botão Fechar encerra a aplicação. 
 
 No evento click da ComboBox os botões Nova e Excluir ficam habilitados e Adicionar 
desabilitado. 
 
 
Objeto – ComboBox1 (Caixa de listagem em formato de cortina) 
 
Paleta – Standart 
 
Importância: Permite o usuário entrar ou 
manipular uma lista de dados. 
 
CEFET-UNED 
Prof. Mário André 
38 
 
Propriedades 
Items 
Define uma lista de Strings que aparece no componente. 
Sorted Define se os dados serão ordenados. 
Text 
Define o texto atual da Combobox. 
 
Métodos 
Clear Permite limpar o conteúdo da propriedade Items. 
LoadFromFile Permite ‘carregar’ um arquvo para a propriedade Items. 
SaveToFile Permite salvar o conteúdo da propriedade Items para um arquivo. 
 
 
Objeto – GroupBox (Caixa de agrupamento) 
 
Paleta – Standart 
 
Importância: Permite agrupar componentes e 
estabelecer um título na propriedade Caption. 
 
Propriedades 
Align Pemite definir um alinhamento no objeto proprietário. 
Caption Define o texto informativo na parte superior do componente. 
 
 
Objeto RadioGroup (Grupo de botões ‘radio’) 
 
Paleta – Standart 
 
Importância: Permite estabelecer um grupo de 
botões de radio e manipula-los pela 
propriedade ItemIndex. 
 
 
Propriedades 
Items Define os itens disponíveis ao usuário. 
ItemIndex Define qual dos itens está selecionado. 
Columns Define o número de colunas para organização dos componentes. 
 
 
 
 
 
CEFET-UNED 
Prof. Mário André 
39 
Exercício 1: 
Utilizando-se da interface mostrada na figura abaixo, produzir uma aplicação que apresente a 
seguinte funcionalidade: 
 O Clique no botão OK deverá incrementar a quantidade de votos de cada equipe e a 
quantidade de entrevistados dos dois sexos. 
 Sexo é um RadioGroup e as demais caixas GroupBox 
 
Exercício –2: 
 
Defina uma aplicação para conforme o lay-out abaixo. 
Linguagem e Verbo são GroupBox 
Adjetivo é um RadioGroup 
Em tempo de projeto ative um botão de cada agrupamento 
Alterar o conteúdo da Caixa de Edição Frase quando qualquer uma das Caixas for alterada. 
 
 
CEFET-UNED 
Prof. Mário André 
40 
 
Objeto – Panel (Painel) 
 
Paleta – Standart 
 
Importância: Permite agrupar outros objetos e 
estabelecer um efeito visual nas aplicações. 
 
 
Propriedades 
Align Define o alinhamento do componente em relação ao seu proprietário. 
Bevel... Define a característica das bordas (interna e externa) bem como sua 
espessura. 
BorderStyle Define o tipo da borda. 
Exercício 
Utilizando uma Panel como Barra de Status para exibição de Dicas Flutuantes 
 
Insira um Panel no formulário limpo e defina as propriedades: 
Align = alBottom 
Alignment = ta LeftJustify 
BevelInner = bvLowered 
Caption = (nenhum) 
 
Manipulador para o evento OnClick do Panel digite: Panel1.Caption := Application.Hint 
 
Vá no Object Inspector e exclua a conexão do Panel com esse manipulador. 
Através do menu Search | Replace, troque as ocorrências Panel1Click para DoShowHint. 
No manipulador de evento OnCreate do formulário, digite: Application.OnHint := DoShowHint; 
Insira alguns componentes no formulário e defina dicas através da prop. Hint. Seja criativo. 
Execute 
Observe que sempre que o cursor estiver sobre um dos componentes, a dica aparecerá na Barra 
de status. 
Poderá ocorrer algum problema se a dica da Barra de status for muito grande e o componente 
também utiliza dica instantânea (showHint = True), que geralmente é curta. 
Para resolver isso, selecione um componente e na prop. Hint defina “dica instantânea” | “dica 
flutuante”. 
Assim, quando o cursor passar sobre o componente, o texto da dica instantânea será exibida 
próximo ao mesmo e o texto da dica flutuante, na linha de status. 
 
 
CEFET-UNED 
Prof. Mário André 
41 
 
 
 
Objetos – MainMenu e PopupMenu (Menu principal e Menu rápido) 
 
Paleta – Standart 
 
Importância: Define os Menus utilizados pelo 
usuário pelo botão esquerdo (MainMenu) ou 
pelo botão direito (PopupMenu) do Mouse. 
 
 
Propriedades 
Items Define um novo item de Menu. 
Images Define um objeto do tipo ‘ImageList’. 
 
 
O objeto MainMenu permite a construção de sub-menus através de seu construtor 
clicando no item com o botão direito e escolhendo a opção Create submenu. Pode-se 
também excluir ou incluir items aleatoriamente através do botão direito no item desejado. 
Para criar um separador de menus, utilize o operador de subtração (‘-‘) e confirme 
com a tecla Enter. 
 
 
Diferentes pápeis dos itens de menu 
 
Independentemente da posição deles na estrutura dos menus, há três tipos fundamentais 
de itens de menu: 
 
Comandos: São itens de menu usado para dar um comando, para executar uma ação. Eles não 
oferecem nenhuma pista visual. 
 
Definidores de Estado: São itens de menu usados para alternar uma opção entre ligado e 
desligado, para mudar o estado de um elemento em particular. Quando há dois estados, estes 
CEFET-UNED 
Prof. Mário André 
42 
comandos usualmente têm uma marca de verificação à esquerda se estiverem ativos. Neste caso, 
selecionar o comando produz a ação oposta. 
 
Itens de Diálogo: São itens de menu que fazem com que uma caixa de diálogo apareça. A real 
diferença entre estes e os outros itens de menu é que o usuário terá condições de explorar os 
possíveis efeitos da caixa de diálogo correspondente e de finalmente abortá-los através do botão 
Cancelar da caixa. Esses comandos devem ter uma pista visual, que consiste em três pontos após 
o texto. Isto não é obrigatório do ponto de vista técnico, mas é tão comum que você não deve 
ignorar esta diretriz. 
 
 
Mudando itens de menu em tempo de execução 
 
A estrutura de um menu pode mudar numa série de maneiras, mas as mais importantes 
se aplicam a itens individuais. Como por exemplo, quando um comando de menu não pode ou 
não deve ser selecionado (Prop. Enabled), usualmente ele assume a cor cinza. Neste caso o 
usuário não tem a chance de usar esse comando.Outra mudança visual é o uso da marca de verificação (Prop. Checked), que pode ser 
substituída por duas legendas diferente (Prop. Caption) para os dois estados do item, como por 
exemplo: Exibir Lista e Ocultar Lista. 
 
Editando um menu com o Menu Designer (MD) 
 
O Delphi possui em editor especial de menus, o Menu Designer. Para invocar esta 
ferramenta, coloque um componente de menu num formulário e dê um clique duplo sobre ele ou 
na sua propriedade Items ou dê um clique com o botão direito do mouse sobre ele e escolha 
essa opção. 
Não se preocupe demasiadamente com a posição do componente de menu do 
formulário, uma vez que isso não afetará o resultado; o menu é colocado apropriadamente abaixo 
da Barra de Título do formulário. 
 
Observação: Para ser mais preciso, o formulário exibe, abaixo de sua legenda, o menu indicado 
em sua propriedade Menu, a qual é definida por padrão tão logo você insira o primeiro 
componente de menu principal do formulário. Se o formulário tiver mais de um componente de 
menu principal, esta propriedade deve ser definida manualmente e pode ser mudada tanto em 
tempo de projeto como em tempo de execução. 
 
Para criar o seu menu dentro do Menu Designer basta escrever o texto dos comandos. 
Para se criar menus suspensos de segundo nível dê um clique com botão direito do mouse sobre 
o item desejado e selecione o comando Create Submenu ou pressione simultaneamente <Ctrl> 
<>. 
Você também pode utilizar as teclas <Insert> e <Delete> para inserir e deletar itens de 
menu respectivamente e as setas de direção para navegar entre os itens de menu. 
 
Para adicionar um separador ao menu suspenso, simplesmente insira um hífen como 
texto do comando, sendo que o separador não responde ao evento OnClick. 
 
 
 
 
CEFET-UNED 
Prof. Mário André 
43 
Atalhos de Menu 
 
Uma característica comum dos itens de menu é que eles contêm uma letra 
sublinhada, pode ser a 1ª ou uma letra do meio. E ao pressionar <Alt> + letra, ativa menu 
suspenso correspondente. 
Obviamente, cada elemento da barra de menus deve ter uma letra sublinhado diferente. 
O mesmo é verdadeiro para os itens de menu de um menu suspenso específico. 
Para determinar a letra sublinhada, simples coloque & antes dela na definição do item. 
Os itens de menu podem ter também teclas de atalho (p.e. <Ctrl> <C>). Para associar 
uma tecla de atalho a uma item de menu (menus suspensos as possui) selecione um valor para a 
propriedade ShortCut do item através das combinações padrões. 
 
Mudando Itens de Menu 
 
Três propriedades são usadas para modificar um item de menu. Usamos a propriedade 
Checked para adicionar ou remover uma marca de verificação dentro do item de menu. A 
propriedade Enabled pode é usada para dar a cor cinza a um item de menu a fim de que ele não 
possa ser selecionado pelo usuário. A última é a Caption, o texto do item de menu. 
Uma quarta operação com item de menu seria a sua remoção ou torná-lo invisível. Isso 
é facilmente realizado mudando-se o valor da prop. Visible para False. Sugere-se que você 
evite esta operação, pois o usuário pode confundir-se. É preferível desabilitá-lo temporariamente. 
 
Associando Eventos a Itens de Menu 
 
A associação de um evento a um item de menu é fita semelhante à associação de um 
evento a qualquer componente. A única diferença é que ele não é visto como um componente, 
logo devemos selecioná-lo utilizando caixa de seleção do Obj Inspector ou utilizarmos o MD. 
 
 
Exercício -1 
 
1. Insira um Label no formulário e limpe sua legenda 
 
2. Insira um MainMenu com 1 Menu suspenso e este com 3 itens de menu quaisquer. 
 
3. Construa o código para que cada vez que selecionarmos um item de menu, a legenda do label 
receba a sua descrição 
 
4. Execute a aplicação e depois remova os compoentes inseridos no formulário 
 
 
Exercício –2: 
 
Confeccione a estrutura de Menu conforme layouts abaixo, observando os nomes dos menus 
suspensos e dos itens de menu. 
 
Para obtermos uma janela com melhor aparência altere a prop Color do formulário para 
clBtnShadow 
 
Viajar Namorar Comer Estudar Bye Bye 
CEFET-UNED 
Prof. Mário André 
44 
Praias Ctrl P Cinema Aquilo Cobol Sobre 
Montanhas Boite - Assuntos Espec. 
Florestas  Sofá E Mais Aquilo - 
- - Religião 
Casa da Vovó Junto com Sogra 
- - 
Regressar No .. 
 
 
Menus Pop-Up ou SpeedMenus ( com o botão direito do mouse) (Standard) 
 
No Windows é comum ver aplicações que possuem menus locais especiais que você ativa 
dando um clique com o botão direito do mouse. O menu que é exibido - um menu pop-up em 
termos do Windows - usualmente depende da posição do clique do mouse. Estes menus tendem a 
ser fáceis de usar, uma vez que agrupam somente os poucos comandos relacionados ao elemento 
que está atualmente selecionado. 
 
Para adicionar menus pop-up na sua aplicação, execute algumas operações simples: 
1. Insira um componente PopUpMenu no formulário 
2. Adicione alguns itens de menu ao componente 
3. Associe o componente à propriedade PopUpMenu do componente desejado 
4. E obviamente, adicionar manipuladores de eventos para o OnClick dos itens de menu 
 
Observações: 
 
A propriedade AutoPop = True faz o menu aparecer através do clique do botão direito 
sobre o componente. 
A propriedade Alignment determina onde o menu se abrirá. A parte superior do menu 
será a da posição do cursor do mouse, mas o alinhamento poderá ser à esquerda ou à direita ou 
no no centro do componente, dependendo do valor definido nesta propriedade. 
O PopUp Menu não deve ter submenus, pois por conveniência, eles devem ser rápidos 
e não possuem teclas de acesso mnemômico (Alt + letra). 
Podem ter tecla de atalho (propriedade ShortCut). Mas atenção: Mesmo que menu 
não esteja associado a nenhum componente e também não esteja exibido, as teclas de atalho 
estarão disponíveis. Neste caso, para não acessar um item com este recurso, devemos desabilitá-
lo. 
Um componente de menu suspenso recebe o evento OnPopUp antes que ele seja 
exibido. É a chance que temos de realizar qualquer preparação em seus itens, como desativar, 
ajustar marcas de verificação, etc... 
 
 
 
 
 
 
 
 
 
 
 
CEFET-UNED 
Prof. Mário André 
45 
ScrollBar (Standard) 
 
 
Paleta – Standart 
 
O componente ScrollBar serve como barra de 
rolamento vertical ou horizontal para seleção 
e/ou variação de um parâmetro. 
 
 
O usuário pode modificar o valor representado pelo scrollbar de duas formas: clicando 
nas setas de incremento/decremento ou diretamente na barra. A primeira ação faz com que o 
valor representado sofra uma modificação menor (SmallChange) enquanto a segunda gera uma 
maior (LargeChange). 
Os limites inferior e superior da faixa de valores válidos para a ScrollBar são dados por 
Min e Max respectivamente. Estes limites representam o valor quando o cursor da barra estiver 
em cima ou à esquerda (Min) ou em baixo ou à direita (Max). 
O controle provê fácil e eficiente navegação por longa lista de itens ou grande 
quantidade de informação que não podem ser totalmente visualizadas nas suas áreas de exibição. 
Pode também ser usado como entrada de dados ou como mostrador de informações (valores 
numéricos). 
 
Principais Propriedades 
 
Propriedade Descrição 
Kind Define a direção da barra de rolagem 
LargeChange Indica a variação da rolagem feita sem o uso das setas de movimentação 
Max Maior valor do ScrollBar 
Min Menor valor do ScrollBar 
Position Indica a posição atual do srollbar 
SmallChange Indica a variação da rolagem feita com o uso das setas de movimentação 
 
Principais Eventos 
 
Evento Descrição 
OnChange Disparado quando o conteúdo da propriedade position é alterado pelo usuário, e ocorre 
imediatamente após o OnScroll 
OnScroll Ocorre quando é feita a rolagem do ScrollBar 
 
Principais Métodos 
 
Métodos Descrição 
SetParams Modifica os valores das propriedades Position, Min e Max de uma só vez 
 
 
 
 
 
CEFET-UNED 
Prof. Mário André 
46 
FUNÇÕES DE CONVERSÃO