CARLOS ALBERTO PEDROSO ARAÚJO

Lazarus/Free Pascal para Iniciantes

Santarém
2010
 Lazarus/Free Pascal para iniciantes

Lista de Ilustrações

Figura 1 Form novo.........................................................................................................10

Figura 2 Object Inspector................................................................................................11
Figura 3 Paleta de Componentes.....................................................................................12
Figura 4 Janela de Alinhamento......................................................................................13
Figura 5 Método manipulador de evento OnClick de botão...........................................15
Figura 6 Configuração para remoção de métodos vazios................................................15
Figura 7 Código do procedure.........................................................................................16
Figura 8 Execução do programa......................................................................................16
Figura 9 Método manipulador do evento OnClick de form............................................16
Figura 10 Opções de Projeto para diminuir o tamanho do executável............................17
Figura 11 Alterando propriedade em tempo de execução...............................................18
Figura 12 Código para centralizar o botão em tempo de execução.................................19
Figura 13 Código fonte de um form................................................................................20
Figura 14 Unit com novo nome.......................................................................................20
Figura 15 Código após adicionar um botão.....................................................................21
Figura 16 Código após alterar a propriedade Name do botão.........................................21
Figura 17 Código com manipuladores de eventos...........................................................22
Figura 18 Descrição textual do form...............................................................................23
Figura 19 Código fonte do arquivo de projeto................................................................24
Figura 20 Descrição textual de um botão........................................................................26
Figura 21 Mudanças na descrição textual usando o bloco de notas................................26
Figura 22 Descrição textual do botão após ser colado no form.......................................27
Figura 23 Comando Find/Replace...................................................................................27
Figura 24 Comando Find in Files....................................................................................28
Figura 25 Opções de projeto............................................................................................29
Figura 26 Opções do Form Editor...................................................................................30
Figura 27 Expandindo propriedades................................................................................32
Figura 28 Linhas guia de alinhamento............................................................................33
Figura 29 Configuração de números de linha no código fonte........................................34
Figura 30 Editor de templates..........................................................................................36
Figura 31 Destaque de begin e end..................................................................................36
Figura 32 Botão recém inserido.......................................................................................39
Figura 33 Código o evento OnClick de btnFechar..........................................................40
Figura 34 Componente TEdit..........................................................................................41
Figura 35 Componente TLabel........................................................................................42
Figura 36 Componente TCheckBox................................................................................43
Figura 37 Componente TRadioGroup.............................................................................44
Figura 38 O Componente ListBox...................................................................................46
Figura 39 Componente ComboBox.................................................................................47
Figura 40 Componente ScrollBar....................................................................................49
Figura 41 Componente GroupBox..................................................................................50
Figura 42 Componente TMemo......................................................................................51
Figura 43 Form com a botão btnSalvar...........................................................................52
Figura 44 Código do evento OnClick do botão btnSalvar...............................................53
2
 Lazarus/Free Pascal para iniciantes

Figura 45 Caixa de diálogo ShowMessage......................................................................55

Figura 46 Caixa de diálogo MessageDlg.........................................................................57
Figura 47 Caixa de diálogo MessageDlg com caption....................................................57
Figura 48 Caixa de diálogo MessageBox com botões de opções....................................58
Figura 49 MessageBox para informações ao usuário......................................................59
Figura 50 Caixa de diálogo InputBox..............................................................................60
Figura 51 Aplicação Dialogos com um novo botão e rótulo...........................................61
Figura 52 Código para traduzir caixas de diálogo...........................................................62
Figura 53 Menu com opções agrupadas e sub-menu.......................................................65
Figura 54 Aplicação Menus.............................................................................................66
Figura 55 A caixa ColorDialog.......................................................................................68
Figura 56 Menu Editor....................................................................................................69
Figura 57 Aspecto do menu criado..................................................................................70
Figura 58 Menu com teclas de atalho..............................................................................71
Figura 59 Formulário Sobre............................................................................................73
Figura 60 A janela Sobre.................................................................................................74
Figura 61 O componente PopupMenu.............................................................................75
Figura 62 Barra de ferramentas.......................................................................................77
Figura 63 Árvore de componentes...................................................................................79
Figura 64 Barra de status.................................................................................................80
Figura 65 Interface da aplicação......................................................................................83
Figura 66 Função que retorna uma string de espaços......................................................84
Figura 67 O método btnSalvarClick................................................................................84
Figura 68 Botões para leitura do arquivo........................................................................86
Figura 69 Código do evento OnClick de btnIniciar........................................................87
Figura 70 Código do evento OnClick de btnProximo.....................................................87
Figura 71 Configuração de acesso a banco de dados......................................................90
Figura 72 Modelo E-R.....................................................................................................91
Figura 73 Janela para definir o tipo da tabela..................................................................92
Figura 74 Janela para definição de campos.....................................................................92
Figura 75 BDE Administrator.........................................................................................93
Figura 76 DataModule.....................................................................................................98
Figura 77 Aparência parcial da interface.........................................................................99
Figura 78 O controle DBNavigator...............................................................................100
Figura 79 O form de cadastro de clientes......................................................................106
Figura 80 Form de consulta a cidades...........................................................................108
Figura 81 Janela para criar TFields...............................................................................109
Figura 82 Código do evento OnClick do botão btnPesquisar.......................................112
Figura 83 Modelo E-R do banco de dados....................................................................114
Figura 84 Nota fiscal.....................................................................................................120
Figura 85 Tela de definição da ligação entre duas tabelas............................................121
Figura 86 Form de Vendas............................................................................................124
Figura 87 Criação de campo Lookup............................................................................126
Figura 88 Criação de campo calculado..........................................................................126
Figura 89 Código para atualizar o total da venda..........................................................129
Figura 90 Aba de componentes Rave............................................................................130
Figura 91 Rave Visual Designer....................................................................................131
3
 Lazarus/Free Pascal para iniciantes

Figura 92 Propriedades do objeto Page1.......................................................................132

Figura 93 Janela para criação da conexão a dados........................................................132
Figura 94 Árvore de Objetos.........................................................................................133
Figura 95 Componente Region......................................................................................133
Figura 96 Área de impressão.........................................................................................133
Figura 97 Componentes Band e DataBand....................................................................134
Figura 98 Página com os objetos Band e DataBand......................................................134
Figura 99 Editor da propriedade BandStyle..................................................................135
Figura 100 Componente Text........................................................................................135
Figura 101 Página com os objetos Band e DataBand....................................................135
Figura 102 Editor de Data Text.....................................................................................136
Figura 103 Aparência do projeto do relatório...............................................................137
Figura 104 A banda GroupHeader.................................................................................138
Figura 105 A aparência final do desenho do relatório...................................................139
Figura 106 Prévia do relatório.......................................................................................139

4
 Lazarus/Free Pascal para iniciantes

Lista de Quadros

Quadro 1 Propriedades, métodos e eventos de Form......................................................39

Quadro 2 Propriedades, métodos e eventos de Button....................................................40
Quadro 3 Propriedades, métodos e eventos de Edit........................................................42
Quadro 4 Propriedades e eventos de Label.....................................................................43
Quadro 5 Propriedades, métodos e eventos de CheckBox..............................................44
Quadro 6 Propriedades, métodos e eventos de RadioGroup...........................................45
Quadro 7 Propriedades, métodos e eventos de ListBox..................................................46
Quadro 8 Propriedades, métodos e eventos de ComboBox.............................................48
Quadro 9 Propriedades, métodos e eventos de ScrollBar................................................49
Quadro 10 Propriedades, métodos e eventos de Memo...................................................51
Quadro 11 Propriedades e métodos de TStrings.............................................................54
Quadro 12 Funções de conversão de dados.....................................................................54
Quadro 13 Propriedades de BitBtn..................................................................................63
Quadro 14 Propriedades de ToolBar...............................................................................76
Quadro 15 Propriedades de StatusBar.............................................................................78
Quadro 16 Propriedades de TStatusPanel.......................................................................79
Quadro 17 Propriedades de StatusBar.............................................................................80
Quadro 18 Rotinas de Entrada e Saída............................................................................81
Quadro 19 Definição dos campos da tabela Cidade........................................................93
Quadro 20 Definição dos campos da tabela Cliente........................................................93
Quadro 21 Propriedades, métodos e eventos de Table....................................................97
Quadro 22 Propriedades e eventos de DataSource..........................................................97
Quadro 23 Propriedades, métodos e eventos de DBEdit.................................................99
Quadro 24 Propriedades e eventos de DBNavigator.....................................................100
Quadro 25 Propriedades, métodos e eventos de DBLookUpComboBox......................103
Quadro 26 Propriedades, métodos e eventos de DBComboBox...................................103
Quadro 27 Propriedades, métodos e eventos de DBRadioGroup..................................104
Quadro 28 Propriedades, métodos e eventos de DBCheckBox.....................................105
Quadro 29 Propriedades, métodos e eventos de DBGrid..............................................108
Quadro 30 Propriedades, métodos e eventos de TField................................................109
Quadro 31 Propriedades e métodos de TQuery.............................................................112
Quadro 32 Propriedades, métodos e eventos de IBDatabase........................................116
Quadro 33 Propriedades e métodos IBTransaction.......................................................117
Quadro 34 Propriedades do componente RvSystem.....................................................130
Quadro 35 Propriedades do componente RvProject......................................................131
Quadro 36 Propriedades do componente RvDataSetConnection..................................131

5
 Lazarus/Free Pascal para iniciantes

Sumário

Introdução..........................................................................................................................9
Capítulo 1 Criando forms................................................................................................10
Criando seu primeiro form..........................................................................................10
Adicionando um título.............................................................................................10
Salvando a aplicação...............................................................................................12
Usando Componentes..................................................................................................12
Alterando Propriedades...........................................................................................13
Respondendo a Eventos...........................................................................................14
Compilando e Executando um Programa................................................................17
Alterando Propriedades em Tempo de Execução....................................................17
Adicionando Código ao Programa..........................................................................18
Uma Ferramenta de Mão Dupla (Two-Way)..........................................................19
Analisando o código fonte.......................................................................................19
A descrição textual do form....................................................................................22
O arquivo de projeto................................................................................................23
Capítulo 2 O Ambiente Lazarus......................................................................................25
Menus e Comandos do Lazarus...............................................................................25
O menu File.............................................................................................................25
O menu Edit.............................................................................................................25
O menu Search........................................................................................................27
O menu View...........................................................................................................28
O menu Project........................................................................................................28
O menu Run.............................................................................................................29
Trabalhando com o Form Editor.............................................................................30
A Paleta de Componentes........................................................................................31
O Object Inspector...................................................................................................31
A janela de Alinhamento.........................................................................................33
Escrevendo código no Editor...................................................................................33
Usando marcadores de página.................................................................................34
Code Insight.............................................................................................................34
Complementação de código....................................................................................35
Modelos de código..................................................................................................35
Capítulo 3 Explorando os Componentes Básicos............................................................37
Componentes do próprio Windows.........................................................................37
Propriedades, eventos e métodos.............................................................................37
Iniciando uma nova Aplicação................................................................................38
Propriedades de Form (TForm)...............................................................................38
Utilizando um Botão (TButton)...............................................................................39
Aceitando entrada de dados do Usuário (TEdit).....................................................40
Identificando Componentes (TLabel)......................................................................42
Fazendo escolhas (TCheckBox, TRadioButton e TRadioGroup)...........................43
Uma Lista com muitas escolhas (TListBox)...........................................................45
Muitas opções em pouco espaço (TComboBox).....................................................47
Escolhendo um valor em um intervalo (TScrollBar)..............................................48
6
 Lazarus/Free Pascal para iniciantes

Agrupando componentes relacionados (TGroupBox).............................................50

Entrando múltiplas linhas (TMemo).......................................................................50
Juntando tudo...........................................................................................................52
Capítulo 4 Caixas de Diálogo..........................................................................................55
ShowMessage..........................................................................................................55
MessageDlg.............................................................................................................56
Application.MessageBox.........................................................................................57
InputBox..................................................................................................................59
InputQuery...............................................................................................................60
Traduzindo as Caixas de Diálogo............................................................................61
Botão com ícone (TBitBtn).....................................................................................63
Capítulo 5 Criando Menus...............................................................................................64
Estrutura do Menu Principal....................................................................................64
Diferentes funções dos itens de menu.....................................................................65
Aplicação Exemplo.................................................................................................66
A Caixa de Diálogo ColorDialog............................................................................67
Criando um Menu com o Menu Editor....................................................................68
Teclas de atalho e hotkeys.......................................................................................70
Respondendo aos comandos do menu.....................................................................71
Chamadas a forms...................................................................................................72
Menus locais (Pop-up).............................................................................................74
Capítulo 6 Barras de ferramentas e de status...................................................................76
Barra de ferramentas (TToolBar)............................................................................76
Barra de status (TStatusBar)....................................................................................78
Capítulo 7 Tratamento de arquivos.................................................................................81
Escrevendo dados no arquivo......................................................................................83
Lendo dados do arquivo..............................................................................................85
Melhorando a interface................................................................................................87
Capítulo 8 Aplicações usando Banco de Dados Local....................................................90
Acesso a Banco de Dados............................................................................................90
Aplicação de banco de dados.......................................................................................91
Database Desktop....................................................................................................91
BDE - Criação do Alias...........................................................................................93
Iniciando a aplicação...............................................................................................94
Data Module............................................................................................................95
A interface de entrada de dados da tabela Cidade...................................................98
A interface de entrada de dados da tabela Cliente.................................................101
Consultas a banco de dados.......................................................................................106
Componente para o resultado da consulta (TDBGrid)..........................................107
Pesquisa em tabelas usando Locate.......................................................................109
Pesquisa em tabelas usando TQuery.....................................................................111
Capítulo 9 Aplicações usando Banco de Dados Cliente/Servidor.................................114
Iniciando a aplicação.................................................................................................115
DataModule...........................................................................................................115
As interfaces de entrada de dados.........................................................................118
Form mestre-detalhe..............................................................................................119
Relatórios...................................................................................................................130
7
 Lazarus/Free Pascal para iniciantes

Relatório de Cidades..............................................................................................130
Relatório de Clientes.............................................................................................137

8
 Lazarus/Free Pascal para iniciantes

Introdução

Lazarus é considerada uma ferramenta RAD (Rapid Application Development).

E realmente podemos desenvolver aplicações com bastante rapidez nesse ambiente.
Lazarus é um IDE open source baseado na linguagem Free Pascal e desde sua origem
tem evoluído consideravelmente. Com este IDE pode-se criar tanto aplicações para
desktop quanto para web.
Junta-se a essa característica o fato de Lazarus ser orientado a objetos, mas não
totalmente, pois mantém o paradigma procedural e, possibilitar o desenvolvimento
visual de aplicações para os ambientes Windows, Linux, Mac OS X, WinCE, entre
outros.
Este texto tenta apresentar Lazarus de forma didática. Sem nenhuma pretensão
de cobrir toda a extensão desta poderosa ferramenta, mas oferecendo informações
suficientes para o estudante ou futuro desenvolvedor que deseje adotar o Lazarus como
uma de suas ferramentas de trabalho. Como objeto do estudo foi usada a versão 0.9.29.
Tentou-se organizar o texto de forma a privilegiar o auto-estudo.
Ao fim da leitura, o estudante estará apto a desenvolver pequenas aplicações
usando bancos de dados, e capaz de prosseguir de forma autônoma, pois a base e o
conceito do ambiente são apresentados com o objetivo de facilitar isso.
Para atingir seu objetivo, este trabalho está organizado da seguinte forma: no
Capítulo 1 é apresentado o conceito de form no Lazarus e criada a primeira aplicação
para introduzir o leitor no ambiente. No Capítulo 2 tem-se uma visão do ambiente do
Lazarus, configurações e recursos do editor de código. No Capítulo 3 são apresentados
os componentes básicos através da estratégia de se construir uma aplicação passo a
passo. As caixas de diálogo são estudadas no Capítulo 4. Menus e barras de ferramentas
e de status são mostradas nos Capítulos 5 e 6. Após isso começa-se o estudo da
persistência de dados no Lazarus, iniciando com os arquivos de texto no Capítulo 7.
Aplicações de bancos de dados locais são estudadas no Capítulo 8. Finalmente, no
Capítulo 9, é criada uma aplicação usando banco de dados cliente/servidor e faz-se uma
introdução a relatórios.

9
 Lazarus/Free Pascal para iniciantes

Capítulo 1 Criando forms

Aplicações GUI são geralmente baseadas em janelas. Então, como vamos criar
nossa primeira janela? Bem, usando um form. Nos ambientes GUI, tais como Windows
e Linux, um form é realmente uma janela. Não há diferença entre os dois conceitos, pelo
menos de um ponto de vista geral.

Criando seu primeiro form

Embora você provavelmente já tenha criado algumas aplicações simples no
Lazarus, nesta seção será mostrado o processo de novo, para esclarecer alguns pontos
interessantes. Criar um form é uma das operações mais fáceis no sistema: você só
precisa abrir o Lazarus, e ele automaticamente irá criar um form novo, como se pode ver
na figura abaixo.

Figura 1 Form novo

Mas, se você já tem um projeto aberto, escolha File | New | Application para
fechar o projeto antigo e abrir um novo. Acredite, você já tem uma aplicação
funcionando. Você pode executá-la, usando o botão Run ( ) na barra de ferramentas,
escolhendo Run | Run no menu, ou ainda teclando F9. Após alguns segundos você verá
uma janela na tela do seu computador. Certamente não é uma aplicação muito útil, pois
é apenas uma janela vazia, mas tem o comportamento padrão de qualquer janela de
Interface Gráfica do Usuário (GUI).

Adicionando um título
No entanto, antes de executar a aplicação, vamos fazer uma rápida alteração. O
título do form é Form1. Para um usuário, o título da janela torna-se o nome da
aplicação. Vamos mudar Form1 para algo mais significativo. Quando você abre o
10
 Lazarus/Free Pascal para iniciantes

Lazarus, a janela Object Inspector deve aparecer ao lado esquerdo do form (se não
aparecer pressione a tecla F11).

Figura 2 Object Inspector

O Object Inspector mostra as propriedades do componente selecionado. A

janela contém quatro abas. A primeira está rotulada como Properties. A próxima é
rotulada Events e mostra a lista de eventos que podem acontecer no form ou no
componente selecionado. Estas são as que mais interessam no momento.
As propriedades são listadas em ordem alfabética, assim fica fácil encontrar
aquela que se quer modificar. Podemos mudar o título do form simplesmente mudando
11
 Lazarus/Free Pascal para iniciantes

a propriedade Caption. Enquanto você digita um novo Caption o título do form se

modifica. Se você digitar Alo o título muda imediatamente após se teclar ENTER.
Como uma alternativa, você pode modificar o nome do form mudando a propriedade
Name. Se Caption ainda não tiver sido modificada ainda, o valor de Name também será
usado por Caption. No entanto para a propriedade Name do form digite frmPrincipal
(frm significa form e Principal indica a função do form).
Nem todas as propriedades de um componente mudam enquanto um novo valor
é digitado. Muitas são aplicadas quando você termina de digitar e teclar ENTER, ou
quando muda o foco de entrada para outra propriedade.
Execute a aplicação. Sem muito trabalho nós construímos uma aplicação com
um menu de sistema (aquele que aparece quando você clica o canto superior esquerdo
da janela) e os botões padrão das janelas: Minimizar, Maximizar e Fechar. Se você
observar a barra de tarefas você verá que algo não está certo. Em vez de mostrar o
caption do form como caption do ícone, ele mostra o nome do projeto, algo como
Project1. Podemos corrigir isso dando um novo nome ao projeto quando o salvarmos no
disco.

Salvando a aplicação
Selecione Save ou Save As no menu File, e o Lazarus irá lhe perguntar o nome
do arquivo do projeto e depois o nome do arquivo do código fonte (unit) associado ao
form. Para o nome da unit digite o nome u_principal. Para que o nome do projeto seja o
mesmo do caption do form dê a ele o nome Alo. O Lazarus vai salvar uma unit com o
nome u_principal.pas e um projeto com o nome Alo.lpr. Sempre que salvar uma nova
unit, tenha o cuidado de selecionar o diretório da sua aplicação. Se esse cuidado não for
tomado, corre-se o risco de ter módulos do programa espalhados pelo disco e depois é
difícil localizá-los.

Usando Componentes
Agora é hora de começar a inserir algo útil em nosso form. Forms podem ser
pensados como contêineres de componentes. Cada form pode hospedar componentes e
controles. Você pode escolher um componente da paleta de componentes do ambiente
do Lazarus, como mostra a Figura 3.

Figura 3 Paleta de Componentes

Há quatro maneiras de colocar componentes em um form. Selecione o

componente Button da aba Standard. Você pode inseri-lo – e geralmente qualquer
outro componente – no form de uma das seguintes formas:

• Clique no componente, mova o cursor do mouse para o form, pressione o

botão esquerdo na posição onde ficará o canto superior esquerdo do botão e
arraste o mouse para ajustar o tamanho.
12
 Lazarus/Free Pascal para iniciantes

• Selecione o componente e simplesmente clique no form na posição onde

quer inserir o botão com tamanho padrão.
• Dê um duplo clique no componente e o mesmo será inserido no quanto
superior esquerdo do form.
• Pressione a tecla Shift e clique ao mesmo tempo no componente, e coloque
vários componentes do mesmo tipo no form, procedendo de uma das duas
primeiras maneiras acima. Para desativar esse recurso, clique no botão
Selection Tool à esquerda na paleta.

Queremos apenas um botão no form. Vamos centralizá-lo manualmente.

Selecione o botão inserido no form e depois clique com o botão direito do mouse sobre
ele. Clique na opção Align e uma janela com opções de alinhamento irá aparecer:

Figura 4 Janela de Alinhamento

Clique nos botões Center in window tanto na caixa Horizontal quanto na

Vertical e o botão ficará posicionado no centro do form.

Alterando Propriedades
Assim como o form, o botão tem uma propriedade Caption que nós podemos
usar para alterar o seu rótulo (o texto mostrado dentro dele). Altere então a propriedade
Caption para Diga Alô. Na propriedade Name digite btnAlo.
É bastante comum definir uma convenção de nomes para cada tipo de
componente. Sugiro usar um nome curto – tal como btn para Button – para o prefixo do
nome do componente. Desta forma seu código ficará mais organizado e facilitará a
manutenção no futuro.
Name é uma propriedade interna e é usada como nome de uma variável que se
refere ao componente no código da aplicação. Portanto, a propriedade Name segue as
regras de nomeação de identificadores da linguagem Free Pascal:

13
 Lazarus/Free Pascal para iniciantes

• Um identificador é uma sequencia de letras, dígitos ou underscore de

qualquer tamanho, embora apenas os primeiros 63 caracteres sejam
significativos.
• O primeiro caractere de um identificador não pode ser um número, deve ser
uma letra ou underscore.
• Identificadores não são case-sensitive, mas geralmente cada palavra em um
identificador começa com uma letra maiúscula, como em BtnHello.
Normalmente inicia o prefixo com letra minúscula. Mas btnhello, btnHello
ou BTNHello referem-se ao mesmo identificador.

Se você executar esse programa agora, verá que o botão funciona

adequadamente. Se você clicar nele, ele será pressionado, e quando libera o botão do
mouse o botão também é liberado. O problema é que quando você pressiona o botão,
espera-se que algo aconteça, mas nada acontece porque não definimos qualquer ação
para o clique do mouse ainda.

Respondendo a Eventos
Quando você pressiona o botão do mouse em um form ou componente, o sistema
operacional informa do evento à sua aplicação, enviando uma mensagem a ela. O
Lazarus responde ao receber uma notificação de evento chamando um método
manipulador de evento apropriado. Como programador você pode prover vários desses
métodos, tanto para form quanto para os componentes colocados nele. O Lazarus prevê
um certo número de eventos para cada tipo de componente. A lista de eventos para o
form é diferente da lista de eventos para um botão, como se pode ver clicando nesses
dois componentes com a aba Events selecionada no Object Inspector. Alguns eventos
são comuns a ambos os componentes.
Há várias técnicas que você pode usar para definir um método manipulador para
o evento OnClick do botão:

• Selecione o botão e a aba Events no Object Inspector. Dê um duplo clique

na área branca ao lado direito do evento OnClick. Um novo nome de método
irá aparecer no editor de código, btnAloClick.
• Selecione o botão e a aba Events no Object Inspector. Digite o nome de um
novo método na área branca ao lado direito do evento OnClick. Pressione
Enter para aceitá-lo.
• Dê um duplo clique no botão e o Lazarus irá executar a ação padrão para
esse componente, que é adicionar um método manipulador para o evento
OnClick.

Com qualquer uma dessas abordagens o Lazarus cria um procedure chamado

btnAloClick (ou o nome que você escolheu) no código do form e abre o arquivo do
código fonte nesta posição:

14
 Lazarus/Free Pascal para iniciantes

Figura 5 Método manipulador de evento OnClick de botão

Como vimos, a ação padrão para um botão é adicionar um manipulador para

responder ao evento OnClick. Mesmo que você não tenha certeza do efeito da ação
padrão de um componente, você ainda pode dar um duplo clique nele. Se você adicionar
um procedure que não precisa, apenas deixe-o vazio. Métodos vazios gerados pelo
Lazarus podem ser removidos assim que o arquivo for salvo ou o projeto for compilado.
Mas para que isso aconteça é necessário fazer uma configuração. Clique na opção de
menu Environment | Options. Na janela que será mostrada, selecione Completion and
Hints do grupo Editor e marque a opção Auto remove empty methods conforme
aparece destacado na Figura 6.

Figura 6 Configuração para remoção de métodos vazios

Agora podemos digitar algumas instruções entre as palavras chaves begin e end
que delimitam o procedure. O código é simples. Apenas uma chamada ao procedure
ShowMessage, para mostrar uma mensagem.

15
 Lazarus/Free Pascal para iniciantes

Figura 7 Código do procedure

Digite então dentro dos parênteses a string 'Alô pessoal'. Execute o programa
agora e clique no botão. Você verá o seguinte na sua tela:

Figura 8 Execução do programa

A cada vez que você clica no botão a caixa de mensagem é mostrada. E se você
clicar fora do botão? Nada acontece. Naturalmente, podemos adicionar um novo código
para manipular esse evento. Só precisamos adicionar um evento OnClick para o próprio
form. Selecione o form e a aba Events do Object Inspector. Dê um duplo clique no lado
direito do evento OnClick, conforme o destaque na Figura 9. Agora adicione o seguinte
código no editor:

Figura 9 Método manipulador do evento OnClick de form

16
 Lazarus/Free Pascal para iniciantes

Compilando e Executando um Programa

Antes de prosseguir com a implementação do nosso programa Alo, vamos
analisar o que acontece quando executamos uma aplicação. Quando você clica no botão
Run, seleciona Run | Run no menu, ou pressiona a tecla F9, o Lazarus faz o seguinte:

1. Compila o código fonte em Free Pascal que descreve o form.

2. Compila o arquivo do projeto.
3. Constrói o arquivo executável (EXE), ligando as bibliotecas apropriadas.
4. Executa o arquivo executável, geralmente em modo depuração (debug).

O ponto principal é que quando você pede para o Lazarus executar uma
aplicação, ele a compila em um arquivo executável. Compilar este programa como se
faz comumente, ligando todos os códigos de bibliotecas necessários, produz um
executável de alguns Mbytes. Para reduzir o tamanho do executável selecione Project |
Project Options no menu. Em Compiler Options, selecione Linking e desmarque
Display Line Numbers in Run-time Error Backtraces e marque Strip Symbols from
Executable. Observe os itens em destaque na Figura 10. Sendo esta configuração uma
opção de projeto, ela deve ser feita para toda aplicação. Note que essas são opções de
Debug, portanto sugere-se que esta configuração seja feita apenas no momento de gerar
o executável de produção. Enquanto você estiver em desenvolvimento deixe tudo como
definido no padrão.

Figura 10 Opções de Projeto para diminuir o tamanho do executável

Alterando Propriedades em Tempo de Execução

Vamos retornar à nossa aplicação Alo. Queremos agora tentar mudar algumas
propriedades em tempo de execução. Por exemplo, nós podemos mudar o Caption de
17
 Lazarus/Free Pascal para iniciantes

btnAlo para Diga alô de novo depois que o usuário clica nele pela primeira vez. Será
necessário também mudar a largura do botão, pois o Caption fica maior. Isso é muito
simples de fazer. Só precisa mudar o código do procedure btnAloClick como mostrado

Figura 11 Alterando propriedade em tempo de execução

Portanto, para mudar uma propriedade como Caption ou Width em tempo de

execução, usa-se apenas um comando de atribuição. As propriedades que aparecem no
Object Inspector podem ser alteradas em tempo de execução. Mas existem outras que
só podem ser alteradas em tempo de execução. Aquelas que só podem ser alteradas em
tempo de execução não são listadas no Object Inspector.

Adicionando Código ao Programa

Nosso programa está quase finalizado, mas ainda temos um problema a resolver,
que irá exigir alguma codificação. O botão inicia no centro do form mas não permanece
lá quando você redimensiona o form. Este problema pode ser resolvido de duas formas
diferentes.
Uma solução é mudar o estilo da borda do form de modo que ele não possa ser
redimensionado em tempo de execução. Vá para a propriedade BorderStyle do form, e
selecione bsSingle em vez de bsSizeable. A outra abordagem é escrever algum código
para mover o botão para o centro a cada vez que o form for redimensionado. Embora
pareça que grande parte do seu trabalho em programar no Lazarus seja selecionar
opções e elementos visuais, tem um momento que é necessário escrever código. Quanto
mais experiente você fica, mais código você vai precisar escrever.
Quando você quer adicionar código ao programa, a primeira pergunta a ser
respondida é: Onde? Em um ambiente orientado a eventos como o Lazarus, o código
sempre é executado em resposta a um evento. Quando um form é redimensionado
ocorre um evento – OnResize. Selecione o form e a aba Events no Object Inpector.
Procure o evento OnResize e dê um duplo clique à direita dele. Um novo procedure é
adicionado ao arquivo fonte do form. Agora digite o seguinte código:

18
 Lazarus/Free Pascal para iniciantes

Figura 12 Código para centralizar o botão em tempo de execução

Para determinar as propriedades Top e Left do botão - isto é, a posição do seu

canto superior esquerdo - o programa calcula o centro da página, dividindo a altura e a
largura da área interna ou área cliente da página por 2, e então subtrai metade da altura
(Height) e largura (Width) do botão. Se você usar as propriedades Height e Width do
form, em vez das propriedades Client Height e ClientWidth, você estará se referindo ao
centro da janela incluindo a barra do Caption.

Uma Ferramenta de Mão Dupla (Two-Way)

No exemplo anterior nós escrevemos três pequenas porções de código, para
responder a três eventos diferentes. Cada porção de código era parte de um procedure
diferente. Mas onde termina o código que nós escrevemos? O código fonte de um form
é escrito em um único arquivo fonte Free Pascal, aquele que chamamos u_principal.pas.
O arquivo cresce não apenas quando escrevemos código para responder a eventos, mas
também quando adicionamos componentes ao form. As propriedades desses
componentes juntamente com as propriedades do form são armazenadas em um segundo
arquivo chamado u_principal.lfm.
O Lazarus pode ser definido como uma ferramenta de mão dupla, pois tudo que
você faz no ambiente visual leva a algum código. Nada é oculto e inacessível. Você tem
acesso ao código completo, e embora alguns deles sejam bastante complexos, você pode
editar tudo. Naturalmente, você pode usar apenas as ferramentas visuais, no mínimo até
você se tornar um programador Lazarus mais experiente.
O termo ferramenta de mão dupla também significa que você é livre para alterar
o código produzido por você e então voltar às ferramentas visuais. No entanto você
precisa seguir algumas regras.

Analisando o código fonte

Vamos dar uma olhada no que o Lazarus gerou de nossas operações anteriores.
Toda ação tem um efeito - no código Free Pascal, no código do form, ou em ambos.
Quando você inicia um novo form, ele tem um código fonte associado como mostrado
na Figura 13.
O arquivo chamado Unit1, usa (uses) algumas units e define um novo tipo de
dado (uma classe) e uma nova variável (um objeto desta classe). A classe é chamada
TForm1 e é derivada de TForm. O objeto é Form1, do novo tipo TForm1.
Units são módulos nos quais um programa Free Pascal é dividido. Quando você
inicia um novo projeto, o Lazarus gera um módulo program e uma unit que define o
form principal. A cada vez que você adiciona um form ao programa, uma unit é

19
 Lazarus/Free Pascal para iniciantes

adicionada. Por padrão, arquivos units têm extensão .PAS e arquivos program tem
extensão .LPR.

Figura 13 Código fonte de um form

Se você renomeou os arquivos como sugerimos no exemplo anterior, o código

muda um pouco, pois o nome da unit deve refletir o nome do arquivo. Se você chamou
o arquivo de u_principal.pas o código irá começar assim:

Figura 14 Unit com novo nome

Assim que você começa a adicionar novos componentes, a declaração da classe

form muda. Por exemplo, quando você adiciona um botão ao form, a parte do código
fonte que define novos tipos de dados torna-se o seguinte:

20
 Lazarus/Free Pascal para iniciantes

Figura 15 Código após adicionar um botão

Agora se a propriedade Name do botão for alterada para btnAlo, o código muda
para:

Figura 16 Código após alterar a propriedade Name do botão

A alteração de outras propriedades não afeta o código fonte. As propriedades de

form e seus componentes são armazenadas em um arquivo de descrição de form
separado (com extensão .LFM).
Adicionar novos manipuladores de eventos tem maior impacto no código. A
cada vez que um novo manipulador de evento é definido, uma nova linha é adicionada à
definição de tipo de dado do form, um corpo de método vazio é inserido na
implementation, e alguma informação é armazenada no arquivo de descrição do form
também como pode ser observado na Figura 17.
Vale observar que há um único arquivo para o código inteiro do form, não
apenas pequenos fragmentos. Naturalmente, o código é apenas uma descrição parcial do
form. O código fonte determina como o form e seus componentes reagem aos eventos.
A descrição do form (o arquivo LFM) armazena os valores das propriedades do form e
de seus componentes. Em geral, o código fonte define as ações do sistema, e os arquivos
form definem o estado inicial do sistema.

21
 Lazarus/Free Pascal para iniciantes

Figura 17 Código com manipuladores de eventos

A descrição textual do form

Como já falamos, junto com o arquivo PAS contendo o código fonte, há outro
arquivo descrevendo o form e suas propriedades, seus componentes e as propriedades
dos componentes. Este é o arquivo LFM, um arquivo texto.
Você pode abrir a descrição textual de um form simplesmente clicando com o
botão direito no form em tempo de desenvolvimento e selecionado o comando View
source (.lfm). Isto fecha o form, solicitando que seja salvo se for necessário, e abre o
arquivo LFM no editor. Depois podemos fechar o arquivo selecionando o comando
Close page no menu local, ou pressionando CTRL + F4.
Para entender o que é armazenado no arquivo LFM, vamos dar uma olhada na
listagem seguinte, que mostra a descrição textual do form do nosso programa exemplo.

22
 Lazarus/Free Pascal para iniciantes

Figura 18 Descrição textual do form

Como se pode ver nesta listagem, a descrição textual de um form contém objetos
(neste caso, dois) em diferentes níveis. O objeto frmPrincipal contém o objeto btnAlo,
como é possível ver pela identação do texto. Cada objeto tem suas propriedades e
alguns métodos conectados a eventos (neste caso, OnClick).

O arquivo de projeto
Além dos dois arquivos que descrevem um form (PAS e LFM), um terceiro
arquivo é vital para construir a aplicação. É o arquivo de projeto Lazarus (LPR). Este
arquivo é construído automaticamente, e raramente você precisa alterá-lo,
principalmente para pequenos programas.
O arquivo de projeto é na verdade um arquivo fonte Free Pascal, descrevendo a
estrutura geral do programa e seu código de execução.

23
 Lazarus/Free Pascal para iniciantes

Figura 19 Código fonte do arquivo de projeto

Podemos visualizar esse arquivo através do comando de menu Project | View

Source. Ou clicar no botão View units (CTRL + F12) na barra de ferramentas ou o
comando de menu View | Units. Em qualquer das duas últimas opções o Lazarus mostra
uma caixa de diálogo com uma lista de arquivos fonte do projeto. Escolha o arquivo do
projeto ou qualquer outro que lhe interesse visualizar.

24
 Lazarus/Free Pascal para iniciantes

Capítulo 2 O Ambiente Lazarus

Em uma ferramenta de programação visual como o Lazarus, o papel do ambiente
é muito importante, algumas vezes mais importante que a linguagem usada pelo
compilador. Esta é uma boa razão para explorarmos um pouco o ambiente Lazarus.
Não discutiremos todas as características do Lazarus nem todas as opções de
menu. Em vez disso daremos uma visão geral e ajudaremos você a explorar algumas
partes do ambiente que não são óbvias, e também daremos algumas dicas que podem ser
úteis.

Menus e Comandos do Lazarus

Há basicamente três maneiras de executar um comando no ambiente do Lazarus:

• Usar o menu.
• Usar a barra de ferramentas.
• Usar os menus locais pressionando o botão direito do mouse.

A seguir algumas sugestões para usar alguns comandos de menu. Algumas

opções possuem botões na barra de ferramentas.

O menu File
New Form e New Unit: criam um novo form e uma nova unit no projeto,
respectivamente.
New: abre uma caixa de diálogo com novos itens que podem ser adicionados ao
projeto em desenvolvimento.
Open: responsável pela abertura dos projetos. Também abre units, forms,
pacotes (lpk), projetos (lpr) e texto no Editor de Código.
Open recent: atalho para a abertura dos últimos projetos e arquivos abertos
anteriormente.
Save: salva o arquivo aberto no Editor de Código.
Save All: salva todas as alterações ainda não salvas.
Close: fecha o arquivo aberto no Editor de Código.
Close All: fecha a aplicação inteira.
Clean Directory: faz uma limpeza no diretório selecionado. É útil para excluir
os arquivos de backup gerados durante as modificações da aplicação.

O menu Edit
Este menu tem algumas operações que são típicas, tais como Undo, Redo e os
comandos Cut, Copy e Paste, mais alguns comandos específicos para as janelas do
editor e de form. É importante dizer que os comandos padrão do menu Edit (e os
atalhos Crtl + Z, Ctrl + X, Ctrl + C e Ctrl + V) funcionam tanto para texto quanto para
componentes.

25
 Lazarus/Free Pascal para iniciantes

Você deve ter observado que é possível copiar componentes do form para o
editor e vice versa. O Lazarus coloca componentes no Clipboard na sua descrição
textual. Você pode até editar a versão textual do componente, copiar o texto para o
Clipboard, e então colá-lo de volta no form como um novo componente.
Por exemplo, se você colocar um botão em um form, copiá-lo e colá-lo em um
editor, você obterá a seguinte descrição:

Figura 20 Descrição textual de um botão

Agora se você alterar o nome (Name) do objeto, rótulo (Caption) ou posição

(Left e Top), ou ainda adicionar uma nova propriedade, essas mudanças podem ser
copiadas e coladas de volta em um form. Exemplo de mudanças:

Figura 21 Mudanças na descrição textual usando o bloco de notas

Copiando a descrição acima e colando-a em um form irá criar um botão na

posição especificada por Top e Left, com rótulo Meu botão. Para usar esta técnica, você
precisa saber editar a descrição textual de um componente, que propriedades são
válidas, e como definir os valores das propriedades, principalmente o tipo de dado.
Quando o Lazarus interpreta a descrição textual de um componente, ele também pode
mudar os valores de outras propriedades relacionadas àquelas que você alterou, e pode
também mudar a posição do componente no form, para que ele não fique sobreposto a
outro. Você pode ver como o Lazarus modifica as propriedades do componente
visualizando o form como texto:
26
 Lazarus/Free Pascal para iniciantes

Figura 22 Descrição textual do botão após ser colado no form

O menu Search
eo

Figura 23 Comando Find/Replace

O comando Find procura um texto especificado no arquivo ativo no editor de

código. Se a caixa Replace With estiver marcada o texto informado substituirá o texto
procurado.

27
 Lazarus/Free Pascal para iniciantes

Figura 24 Comando Find in Files

O comando Find in Files permite procurar uma string em todos os arquivos

fonte de um projeto, todos os arquivos abertos ou todos os arquivos em um diretório
dependendo do botão marcado. O resultado da busca será mostrado em uma nova
janela. Você pode selecionar uma entrada para abrir o arquivo correspondente e saltar
para a linha que contém o texto encontrado.

O menu View
Muitos dos comandos View podem ser usados para mostrar janelas do ambiente
Lazarus, tais como Object Inspector, Components e Component Palette. Algumas
dessas janelas são usadas durante a depuração e outras quando se está escrevendo
código.
Os comandos da segunda parte do View também estão disponíveis na barra de
ferramentas. O comando Toggle form/unit view (ou F12) é usado para alternar entre o
form que você está trabalhando e seu código fonte. Se você usar uma janela de código
fonte grande o suficiente para conter bastante texto, você usará com freqüência esse
comando.

O menu Project
Este menu tem comandos para gerenciar um projeto. Add editor file to Project
e Remove from Project são usados para adicionar ou remover forms ou arquivos fonte
em Free Pascal ao projeto.

28
 Lazarus/Free Pascal para iniciantes

Open Project abre um projeto e Open Recent Project é um atalho para os

últimos arquivos de projeto que foram abertos. Save Project e Save Project As são
comandos para salvar o arquivo de projeto.

Figura 25 Opções de projeto

Project Options é usado para alterar opções do compilador e do ligador, opções

da aplicação, e assim por diante. Uma dessas opções é a alteração do ícone padrão da
aplicação conforme pode ser visto na Figura 25.

O menu Run
O menu Run tem opções de compilação/execução e depuração (debug). Muitos
de seus comandos são relacionados à depuração, inclusive o próprio comando Run.
Quando você executa um programa no ambiente Lazarus, ele é executado sob o
depurador integrado, a menos que esta opção esteja desabilitada. O comando Run é um
dos mais executados, pois o Lazarus automaticamente recompila um programa antes de
executá-lo, se o código fonte tiver sido modificado. Você pode optar por teclar F9 para
compilar e executar um programa.
CTRL + F9 ou o comando Build compila/linka o programa sem executá-lo.
Quick Compile apenas compila o código sem gerar um executável. É bom para
verificar a sintaxe o código.
No comando Run Parameters pode-se especificar parâmetros a serem passados
na linha de comando do programa que vai ser executado. Os comandos restantes são
usados durante a depuração, para executar um programa passo a passo, definir
breakpoints, observar valores de variáveis e objetos e assim por diante.
O comando Stop ou CTRL + F2 para a execução de um programa, opção que é
útil quando o programa responde incorretamente impedindo que seja encerrado
normalmente.

29
 Lazarus/Free Pascal para iniciantes

O Lazarus possui outros menus e os menus locais que podem ser acionados
através do botão direito do mouse. Quase todas as janelas do Lazarus possuem seus
menus locais com seus comandos relacionados.

Trabalhando com o Form Editor

Desenhar forms é a parte central do desenvolvimento visual no ambiente
Lazarus. Cada componente colocado no form e cada propriedade definida são
armazenadas em um arquivo que descreve o form (arquivo LFM) e tem algum efeito no
código fonte associado ao form (arquivo PAS).
Quando você inicia uma nova aplicação, o Lazarus cria um form vazio, e você
pode começar a trabalhar com ele. Um projeto pode ter qualquer quantidade de forms.
Quando você trabalha com um form em tempo de projeto, você está na verdade usando
o Form Editor. Quando você está trabalhando com um form, você pode alterar suas
propriedades, as propriedades de um de seus componentes, ou as propriedades de vários
componentes de uma vez. Para selecionar um form ou um de seus componentes você
simplesmente clica nele ou usa a árvore de objetos na parte superior do Object
Inspector onde se pode ver o nome e tipo do objeto selecionado. Você pode selecionar
mais de um componente, mantendo a tecla Shift pressionada enquanto clica o mouse,
ou arrastando um retângulo de seleção em volta dos componentes no form.
Quando você seleciona mais de um componente no form, você pode alinhá-los
ou dimensioná-los em grupo. Você pode também abrir a caixa Tab Order, acessível no
menu local do form, para ajustar a ordem que os componentes visuais serão alcançados
pela tecla Tab e a ordem de criação dos componentes não visuais. O alinhamento dos
objetos pode ser feito através da caixa Align no mesmo menu.

Figura 26 Opções do Form Editor

30
 Lazarus/Free Pascal para iniciantes

Além de comandos específicos de menus locais, é possível ajustar algumas

opções de form usando o comando Environment | Options e escolhendo a opção Form
Editor, conforme mostra a Figura 26.
As opções relacionadas a form referem-se, por exemplo, a ativação e
dimensionamento da grade (Grid). A grade torna mais fácil colocar componentes
exatamente onde se quer no form, ajustando depois seu tamanho e posição. Sem a grade
torna-se difícil alinhar dois componentes manualmente. Existem também configurações
para as linhas guia (Guide lines) que facilitam o alinhamento dos componentes no
formulário.
Há duas alternativas para ajustar a posição de um componente: ou você pode
ajustar os valores das propriedades Left e Top, ou você usar as setas enquanto mantém a
tecla CTRL pressionada. O uso das setas possibilita o ajuste fino da posição.
Similarmente, você pode usar as setas juntamente com a tecla Shift para fazer o ajuste
fino do tamanho do componente. SHIFT + CTRL + setas faz o componente se mover
em intervalos da grade.

A Paleta de Componentes
Para adicionar um componente ao form, você pode clicar no componente em
uma das páginas da paleta de Componentes e então clicar no form para colocar o novo
componente. No form você pode pressionar o botão esquerdo e arrastar o mouse para
ajustar a posição e o tamanho do componente ao mesmo tempo, ou apenas clique para
deixar o Lazarus usar o tamanho padrão.
Cada aba da paleta tem um grupo de componentes, cada componente tem um
ícone e um nome que aparece em uma dica (hint). Para ver a dica apenas passe o mouse
pelo botão e espere um segundo. As dicas mostram o nome oficial do componente. São
formados pelos nomes das classes que definem os componentes sem o T inicial (por
exemplo, se a classe é TButton, o nome é Button).
Para inserir mais de um componente de um mesmo tipo no form, clique no
componente na paleta com a tecla SHIFT pressionada. Assim, cada vez que você clica
no form o Lazarus adiciona um novo componente deste tipo. Para encerrar a operação
clique o botão com a seta (seletor padrão) à esquerda da paleta de componentes.

O Object Inspector
Quando você está desenhando um form, você usa o Object Inspector para
ajustar valores de propriedades de form ou componentes. Suas abas listam propriedades
e seus valores, e eventos do componente selecionado, em duas janelas que podem ser
redimensionadas. Uma árvore de objetos no topo do Object Inspector indica o
componente corrente e seu tipo de dado, e pode ser usado para mudar o componente
selecionado. O Object Inspector não lista todas as propriedades de um componente.
Inclui apenas as propriedades que podem ser alteradas em tempo de desenvolvimento.
A coluna da direita do Object Inspector permite apenas a edição apropriada
para o tipo de dado da propriedade. Dependendo da propriedade, você poderá inserir
uma string ou número, escolher de uma lista de opções, ou chamar um editor específico
pressionando um botão elipse. Quando uma propriedade admite dois valores, como

31
 Lazarus/Free Pascal para iniciantes

True ou False, você pode alternar entre um valor e outro apenas com um duplo clique.
Se há mais de dois valores, o duplo clique irá selecionar o próximo da lista. Para
algumas propriedades, tais como Color, você pode entrar um valor, selecionar um valor
de uma lista ou chamar um editor específico. Outras propriedades, tal como Font,
podem ser customizadas ou expandindo suas subpropriedades (usando um pequeno
ícone próximo ao seu nome, conforme Figura 27) ou invocando um editor. Em outros
casos, tais como em listas de strings, os editores especiais são a única maneira de alterar
uma propriedade.

Figura 27 Expandindo propriedades

Se por algum motivo o Object Inspector desaparecer, pressione F11 e ele ficará
visível de novo.

32
 Lazarus/Free Pascal para iniciantes

A janela de Alinhamento
A última ferramenta relacionada ao desenho de form é a janela Alignment. Você
pode abrir esta janela escolhendo o componente que deseja alinhar e então selecionar o
comando Align no menu local do form.
A janela de alinhamento apresenta comandos para posicionar controles,
centralizá-los, espaçá-los igualmente, e assim por diante. Esta janela já foi apresentada
na Figura 4.
O alinhamento de componentes pode ser feito manualmente. O Lazarus facilita
essa tarefa, apresentando linhas coloridas, chamadas linhas guia, que mostram quando

Figura 28 Linhas guia de alinhamento

Escrevendo código no Editor

Depois que o form estiver desenhado, você geralmente precisa escrever algum
código para responder a alguns de seus eventos. A cada vez que você trabalha com um
evento, o Lazarus abre o editor com o arquivo relacionado ao form. Você pode
facilmente alternar entre o Form Editor e o editor de código clicando no botão Toggle
Form/Unit na barra de ferramentas, clicando na janela correspondente, ou pressionando
a tecla F12.
O Lazarus permite que você trabalhe com vários arquivos fonte de uma única
vez, usando a metáfora do bloco de notas com abas. Cada aba do bloco de notas
corresponde a um arquivo diferente. Você pode trabalhar com units relacionadas a
forms, units independentes e arquivos de projetos; abrir arquivos de descrição de form
no formato textual; e até trabalhar com arquivos texto quaisquer. Você pode ir para a
próxima aba do editor pressionando CTRL + TAB, ou pressionando SHIFT + CTRL +
TAB para se mover no sentido contrário.
Há várias opções do ambiente que afetam o editor, muitas delas localizadas nas
opções do Editor no menu Environment | Options, como foi visto na Figura 6 e na
Figura 29 a seguir. Em Display, conforme o destaque, deixaremos marcada Show line
numbers e definiremos Every n-th line number como 1, para que todas as linhas do
código fonte sejam numeradas.
33
 Lazarus/Free Pascal para iniciantes

Figura 29 Configuração de números de linha no código fonte

Usando marcadores de página

O editor também permite usar marcadores de página. Quando você estiver em
uma linha do editor, você pode pressionar CTRL + SHIFT mais uma tecla numérica
de 0 a 9 para definir um novo marcador de página, que aparece como um pequeno
círculo numerado na margem esquerda. A partir daí você pode teclar CTRL mais a
tecla numérica para retornar a essa linha. Para retirar a marca, posicione o editor na
mesma linha marcada e pressione CTRL + SHIFT + tecla numérica.
Esses marcadores têm uma limitação que pode tornar seu uso um pouco difícil.
Se você criar um novo marcador usando um número já existente, o marcador anterior
será removido e inserido na nova linha. Outro comportamento desagradável é que você
pode adicionar múltiplos marcadores em uma mesma linha, mas apenas um deles será
visível. Os marcadores não são salvos junto com o arquivo, só são válidos enquanto o
arquivo estiver aberto.

Code Insight
O editor tem várias características conhecidas coletivamente como Code
Insight. A idéia principal desta tecnologia é tornar mais fácil a escrita de código tanto
por programadores iniciantes quanto por programadores experientes. Duas dessas
funcionalidades são:

• O assistente de complementação de código permite que você escolha a

propriedade ou método de um objeto simplesmente procurando-o numa lista,
ou digitando suas letras iniciais. Permite também que você procure um valor
apropriado para um comando de atribuição.

34
 Lazarus/Free Pascal para iniciantes

• O assistente de modelos de código permite você inserir um dos modelos

predefinidos de código, tal como um comando complexo com um bloco
begin-end interno. É possível também definir novos modelos.

Complementação de código
Há duas maneiras de ativar esse assistente. Você pode digitar o nome de um
objeto, tal como Button1, adicionar um ponto, e esperar. O Lazarus irá mostrar uma lista
de propriedades e métodos válidos que podem ser aplicados a esse objeto. O tempo que
você precisa esperar para aparecer a janela com a lista de opções depende da opção
Delay for hints and completion box, que pode ser configurada na página Completion
and Hints da janela de configurações do Editor em Environment | Options.
A segunda maneira de ativar o assistente consiste em digitar o nome do objeto
seguido de ponto, as letras iniciais da propriedade ou método e pressione CTRL +
ESPAÇO. A lista será mostrada imediatamente, mas agora, o assistente tentará
adivinhar que propriedade ou método você está procurando através das letras iniciais
digitadas. Esta combinação de teclas pode ser usada em um comando de atribuição. Se
você digitar x := e pressionar CTRL + ESPAÇO o Lazarus mostrará uma lista de
possíveis objetos, variáveis ou constantes que podem ser usados neste ponto do
programa.
As opções mostradas nessa lista são dinâmicas. O Lazarus está constantemente
validando o código digitado. Assim, se você adicionar uma nova variável ela será
mostrada na lista.

Modelos de código
Diferente do assistente de complementação de código, o assistente de modelos
de código deve ser ativado manualmente. Você pode fazer isso teclando CTRL + J para
mostrar todos os modelos.
Geralmente você digita uma palavra chave, como if ou array, e então pressiona
CTRL + J, para ativar apenas os modelos que iniciam com aquela palavra. Para
algumas palavras chave existem vários modelos, todos iniciando com a mesma palavra
chave (tais como ifs ou ifb). Assim, se você pressionar CTRL + J você verá todos os
modelos relacionados àquela palavra chave.
Você pode usar esse assistente para dar um nome a uma expressão comum
usando a página Environment | Code Template. Por exemplo, se você usa com
freqüência a função MessageDlg, você pode entrar um novo modelo pressionando o
botão Add conforme mostra a Figura. Informe um nome, por exemplo mess, digite uma
descrição, marque a caixa Enable Macros e então adicione o texto abaixo e confirme.
Existem outras opções de macros. Para vê-las clique em Insert Macro.

MessageDlg('$Param(Msg)', mtInformation, [mbOk], 0);

35
 Lazarus/Free Pascal para iniciantes

Figura 30 Editor de templates

Agora toda vez que você precisar criar uma caixa de mensagem, você apenas
digita mess e pressiona CTRL + J, e o texto completo será mostrado. A linha vertical
indica a posição para onde o cursor será movido depois que o Lazarus mostrar o texto.
Como pudemos ver, esse assistente não está relacionado a palavras chave da
linguagem, mas é um mecanismo geral.
Alguns outros recursos do editor são:
• Inserir um end; automaticamente logo que é digitado um begin;
• Destacar abre e fecha parênteses correspondentes em expressões;
• Destacar begin e end correspondentes conforme mostra a Figura 29.

Figura 31 Destaque de begin e end

36
 Lazarus/Free Pascal para iniciantes

Capítulo 3 Explorando os Componentes Básicos

Agora que já conhecemos um pouco o ambiente Lazarus, já entendemos a
estrutura de uma aplicação, já criamos um pequeno programa, estamos prontos para ir
para a parte principal do ambiente de programação: o uso de componentes. Esta é a
característica chave deste ambiente: programação visual usando componentes.
O IDE Lazarus vem com uma série de componentes prontos para uso. Não serão
descritos aqui todos os componentes em detalhes com suas propriedades, métodos e
eventos.
Neste capítulo usaremos exemplos bastante simples para focar em apenas
algumas características mais importantes.
Iniciaremos dando destaque a um grupo de componentes básicos, tais como
botões, rótulos, caixas de listas, campos de edição e outros controles relacionados. A
maioria dos componentes que são discutidos neste capítulo está presente na aba
Standard da paleta de componentes.

Componentes do próprio Windows

De onde vem a idéia de programar para Windows usando componentes? A
resposta é simples: o próprio Windows possui alguns componentes, geralmente
chamados controles. Um controle é tecnicamente uma janela predefinida com um
comportamento específico, algumas propriedades e alguns métodos. Esses controles
foram o primeiro passo em direção ao desenvolvimento por componentes. O segundo
passo foi provavelmente os controles do VisualBasic e o terceiro passo são os
componentes do Lazarus.
Os controles de sistema padrão são os componentes básicos de cada aplicação
Windows, independente da linguagem de programação usada para escrevê-la, e são bem
conhecidos por todos os usuários do Windows. O Lazarus literalmente empacota esses
controles predefinidos do Windows em alguns de seus componentes básicos, inclusive
os que serão discutidos neste capítulo.
TWinControl é a classe base de todos os componentes ajanelados do Lazarus.
Esses componentes podem receber foco, podem conter outros controles e têm um
manipulador de janela.

Propriedades, eventos e métodos

Propriedades são um tipo especial de campo de um componente, que definem
suas características. Valores de algumas propriedades podem ser alterados pelo Object
Inspector em tempo de desenvolvimento. Outras propriedades só podem ser
modificadas em tempo de execução.
Eventos acontecem em resposta a uma ação do usuário ou do próprio sistema.
Ao programar um método de evento devemos levar em consideração que este só será
executado quando o evento acontecer. Uma das tarefas mais importantes da
programação orientada a eventos é determinar quais eventos serão usados e qual a
ordem que esses eventos acontecem.

37
 Lazarus/Free Pascal para iniciantes

Os métodos realizam ações definidas pelo componente, representam o

comportamento do componente. São procedimentos e funções definidos dentro da
classe, e por isso podem acessar diretamente as propriedades do componente sem que
necessitem ser passados como parâmetros.

Iniciando uma nova Aplicação

Já vimos no Capítulo 1 que, quando o Lazarus é aberto, automaticamente, é
iniciada uma nova aplicação. Vejamos outra maneira de criar uma nova aplicação.
Vamos usar o menu File. Clique depois em New e a seguir selecione Application no
grupo Project. Confirme em OK e se houver uma aplicação aberta, nesse momento, o
Lazarus perguntará se você deseja salvar o projeto. Confirme se for o caso, e uma nova
aplicação será iniciada, com um form pronto para ser desenhado.
A primeira ação a ser feita é salvar nosso projeto para nomear os arquivos. Para
isso vamos usar o comando File | Save All. Esse comando irá salvar os arquivos de unit
e de projeto (LPR). Inicialmente ele pede que seja informado o nome do projeto. Tenha
o cuidado de escolher uma pasta para o seu programa e salvar cada nova unit nesta
mesma pasta. Vamos digitar Exemplo1 e pressionar o botão Salvar. Em seguida ele
pede o nome da unit. Digite u_exemplo1 e pressione o botão Salvar.
Nosso programa será um cadastro de dados pessoais. Os dados a serem
cadastrados são: nome, idade, profissão, escolaridade, sexo e situação cadastral.

Propriedades de Form (TForm)

Antes de inserir qualquer componente no novo form, vamos modificar algumas
de suas propriedades usando o Object Inspector. Lembre que o Object Inspector
mostra propriedades e eventos do componente que estiver selecionado. O quadro abaixo
apresenta as propriedades que serão modificadas, os valores a serem definidos e a
descrição de cada uma. São mostrados também os métodos e eventos mais importantes.
Há muitas outras propriedades, mas essas são as básicas.

Propriedade Conteúdo Descrição

+BorderIcons
biMaximize False Desabilita o botão maximizar
BorderStyle bsSingle Borda simples, tamanho fixo
Caption Exemplo 1 Legenda da barra de títulos
Color clDefault Cor padrão de fundo da tela
Height 480 Altura da tela em pixels
Icon Ícone da barra de títulos da janela
Name frmExemplo1 Identificador da janela
Position poScreenCenter Posiciona a janela no centro da tela
Width 640 Largura da tela em pixels
WindowState wsNormal Abre a tela no tamanho original
Método Descrição
Close Fecha a janela
Show Abre a janela
ShowModal Abre a janela, mas usuário precisa fechá-la para
continuar a aplicação
38
 Lazarus/Free Pascal para iniciantes

Evento Descrição
OnActivate Quando a janela recebe o foco
OnClose Quando a janela é fechada
OnCloseQuery Quando a janela é fechada, mas o usuário pode
impedir o seu fechamento
OnCreate Quando o form é criado
OnShow Quando a janela é aberta
Quadro 1 Propriedades, métodos e eventos de Form

Para modificar a propriedade biMaximize, clique no ícone ao lado de

BorderIcons, conforme mostra a Figura 27, para expandir suas subpropriedades e defina
o novo valor. Para carregar um ícone na propriedade Icon, clique no botão elipse
(aquele com os três pontos) e depois no botão Load para escolher o ícone desejado. Por
enquanto não programaremos nenhum evento.

Utilizando um Botão (TButton)

O Lazarus disponibiliza alguns tipos de botão. Vamos selecionar o botão do tipo
TButton da paleta Standard e inseri-lo no form recém criado.

Figura 32 Botão recém inserido

Iremos alterar as propriedades do botão que foi inserido. O quadro abaixo mostra
as propriedades e os valores a serem definidos, além de métodos e eventos mais usados.
Note que na propriedade Caption nós inserimos um & (ampersand) antes da
letra F. Este recurso define uma tecla de atalho sublinhada. Desta forma o botão pode
ser pressionado usando apenas o teclado. Durante a execução da aplicação,
simplesmente pressione a letra F e o botão será pressionado.

39
 Lazarus/Free Pascal para iniciantes

Propriedade Conteúdo Descrição

Caption &Fechar Legenda do botão
Default False Evento OnClick não é executado se Enter for
pressionado
Enabled True Habilita o botão
Height 25 Altura do botão
ModalResult mrNone Determina se e como o form será fechado
Name btnFechar Identificador do botão
Width 75 Largura do botão
Método Descrição
Click Simula um clique de mouse como se o usuário
tivesse pressionado o botão
Evento Descrição
OnClick Quando o usuário clica no botão
OnEnter Quando o botão recebe o foco
Quadro 2 Propriedades, métodos e eventos de Button

Após definirmos as propriedades precisamos escrever o código para que o botão

tenha o comportamento que desejamos. Quando pressionarmos o botão Fechar,
queremos que o form seja fechado. Para definir o comportamento do botão, vamos dar
um duplo clique nele. O editor de código será aberto e vamos digitar o código que
realizará a ação.

Figura 33 Código o evento OnClick de btnFechar

Como desejamos que o form seja fechado quando clicarmos no botão, isso
representa uma ação a ser realizada pelo form. Portanto devemos usar um método que
tenha esse comportamento, por isso escolhemos o método Close, de acordo com o
Quadro 1.
Você pode compilar seu programa e agora ele pode ser fechado usando o botão
padrão no canto superior direito ou o botão btnFechar que foi programado.

Aceitando entrada de dados do Usuário (TEdit)

Já vimos que o usuário pode interagir com uma aplicação usando o mouse, ou o
teclado em vez do mouse para selecionar um botão pressionando a tecla correspondente
à letra sublinhada no Caption.
Além desses casos, o Windows pode manipular entrada do teclado diretamente.
O Lazarus provê uma série de controles para construir campos de edição e editores de
texto. Dentre esses vamos utilizar o componente campo de edição (TEdit) da paleta

40
 Lazarus/Free Pascal para iniciantes

Standard. Este componente permite que o usuário digite apenas uma linha de texto.
Mais adiante usaremos um componente que possibilita a entrada de mais de uma linha.
Selecione então esse componente e insira-o no form.
Esse primeiro campo de edição que estamos inserindo será utilizado para entrada
do nome da pessoa em nosso cadastro de dados pessoais.

Figura 34 Componente TEdit

Da mesma forma que procedemos com os outros componentes iremos alterar

algumas propriedades desse componente. A seguir apresentamos um quadro com
propriedades, eventos e métodos de TEdit.

Propriedade Conteúdo Descrição

CharCase ecNormal Não faz nenhum tipo de conversão no que é
digitado. ecUpperCase converte tudo para
maiúsculas
Height 21 Altura da caixa de texto
Name edNome Identificador da caixa de texto
PasswordChar #0 Define qual caractere será usado para ocultar o
texto digitado. #0 não oculta o texto digitado
Text Retorna o que foi digitado pelo usuário. Seu
conteúdo deve ser apagado
Width 400 Largura da caixa de texto
Método Descrição
Clear Limpa o conteúdo de Text
SetFocus Muda o foco para o controle
Evento Descrição
OnChange Quando o texto é modificado
41
 Lazarus/Free Pascal para iniciantes

OnEnter Quando o controle recebe o foco

OnExit Quando o foco sai do controle e vai para outro
Quadro 3 Propriedades, métodos e eventos de Edit

Identificando Componentes (TLabel)

Rótulos são apenas texto, ou comentários, escritos em um form. Geralmente o
usuário não interage com rótulos - pelo menos não diretamente. Não faz muito sentido
clicar em um rótulo, embora no Lazarus isso seja tecnicamente possível. Nem todo texto
que vemos em um form corresponde a um rótulo. O método TextOut de form pode
apresentar um texto.
Usamos rótulos para descrever outros componentes, tais como campos de edição
e caixas de lista ou combo, pois eles não têm título. O Lazarus implementa rótulos como
componentes gráficos, não ajanelados.
Vamos então inserir um rótulo no nosso form. Selecione o rótulo na paleta
Standard e insira-o ao lado esquerdo do campo de edição conforme mostrado na figura
seguinte. Altere suas propriedades de acordo com o Quadro 4:

Figura 35 Componente TLabel

Propriedade Conteúdo Descrição

Alignment taLeftJustify Texto justificado à esquerda
AutoSize True Define se o controle será automaticamente
redimensionado para acomodar o texto
Caption &Nome Legenda do rótulo
FocusControl edNome Define qual componente receberá o foco quando
for selecionada a tecla de atalho sublinhada da
legenda

42
 Lazarus/Free Pascal para iniciantes

Name lblNome Identificador do rótulo

WordWrap False Se AutoSize estiver False, define se o texto
poderá utilizar retorno automático (quebra de
linha) no caso de ultrapassar a largura definida
Evento Descrição
OnClick Quando o usuário clica no rótulo
Quadro 4 Propriedades e eventos de Label

Observe que na legenda do componente, a exemplo da legenda do botão, foi

inserido um & para definir uma tecla de atalho sublinhada. No caso do rótulo quando
pressionamos esta tecla o foco será mudado para o controle definido na propriedade
FocusControl.

Fazendo escolhas (TCheckBox, TRadioButton e TRadioGroup)

Há dois controles do Windows que permitem ao usuário escolher diferentes
opções. O primeiro é a caixa de verificação (TCheckBox), que corresponde a uma opção
que pode ser selecionada livremente. O segundo controle é o botão de rádio
(TRadioButton), que corresponde a uma seleção exclusiva. Por exemplo, se você tiver
dois botões de rádio com rótulos A e B, você pode selecionar um dos dois, mas não
ambos ao mesmo tempo. A outra característica é que a escolha de uma das opções é
obrigatória.
Selecione uma caixa de verificação na paleta Standard e insira-o no form.
Usaremos a caixa de verificação para definir a situação cadastral da pessoa - pode
assumir a situação Ativo se a caixa estiver marcada e Não ativo, caso contrário. No
Quadro 5 abaixo podemos ver as propriedades, métodos e eventos de TCheckBox.

Figura 36 Componente TCheckBox

43
 Lazarus/Free Pascal para iniciantes

Propriedade Conteúdo Descrição

Caption Ativo Legenda da caixa de verificação
Checked False Especifica se o controle está marcado
Name chxSituacao Identificador da caixa de verificação
State cbUnchecked Indica se o controle está selecionado, não
selecionado ou parcial
Evento Descrição
OnClick Quando o usuário clica no controle
OnEnter Quando o controle recebe o foco
Quadro 5 Propriedades, métodos e eventos de CheckBox

Vamos inserir um componente para selecionarmos o sexo da pessoa que está

sendo cadastrada. Nesse caso precisamos de um componente que possibilite mais
opções. Usaremos então o grupo de botões de rádio (TRadioGroup). Grupo de botões de
rádio permite que sejam inseridos vários botões, cada um com uma opção. Selecione o
grupo de botões de rádio da paleta Standard e o insira no form.

Figura 37 Componente TRadioGroup

Vamos alterar algumas propriedades deste componente. No quadro a seguir são

apresentadas algumas propriedades, métodos e eventos de TRadioGroup.

Propriedade Conteúdo Descrição

Caption Sexo Legenda do grupo de botões de rádio
Columns 1 Número de colunas em que as opções do grupo

44
 Lazarus/Free Pascal para iniciantes

de botões são apresentadas

Height 90 Altura do controle
ItemIndex 0 Define o item selecionado (primeiro item é 0)
Items Masculino Lista de opções
Feminino
Name rgSexo Identificador do grupo de botões de rádio
Width 185 Largura do grupo de botões de rádio
Método Descrição
SetFocus Muda o foco para o controle
Evento Descrição
OnClick Quando o controle é clicado
OnEnter Quando o controle recebe o foco
OnExit Quando o foco sai do controle e vai para outro
Quadro 6 Propriedades, métodos e eventos de RadioGroup

Para definir a lista de opções, clique no botão elipse no lado direito da

propriedade Items no Object Inspector. Será aberto o editor de String List. Digite uma
opção em cada linha e confirme pressionando o botão OK. A propriedade Items é do
tipo TStrings e será utilizada em outros componentes, com o mesmo nome ou não.

Uma Lista com muitas escolhas (TListBox)

Se você precisar de muitas opções os botões de rádio não são apropriados, a
menos que você tenha um form realmente grande. Não se deve usar mais que 5 ou 6
botões de rádio. A solução é usar caixas de lista (TListBox). Uma caixa de lista pode
manter um grande número de opções em um pequeno espaço, pois ela tem uma barra de
rolagem para mostrar na tela apenas uma pequena parte da lista completa. Outra
vantagem é que podemos facilmente adicionar ou remover elementos da lista. Caixas de
lista também podem permitir uma única escolha ou múltiplas escolhas.
A caixa de lista usada em nossa aplicação servirá para a definição da profissão
do cadastro de dados pessoais. Selecione a caixa de lista da paleta Standard e o insira
no form conforme a figura mostrada a seguir. Insira um rótulo também.

45
 Lazarus/Free Pascal para iniciantes

Figura 38 O Componente ListBox

Vamos alterar algumas propriedades do controle. No quadro abaixo mostramos

algumas propriedades, métodos e eventos de TListBox.

Propriedade Conteúdo Descrição

Columns 0 Número de colunas mostradas sem precisar rolar
horizontalmente
Height 80 Altura do controle
ItemIndex 0 Define o item selecionado (primeiro item é 0)
Items Lista de opções
MultiSelect False Define se o usuário pode selecionar mais de um
item
Name lbxProfissao Identificador da caixa de lista
Sorted True Define se os elementos serão ordenados
Width 121 Largura da caixa de lista
Método Descrição
Clear Deleta os itens da caixa de lista
SetFocus Muda o foco para o controle
Evento Descrição
OnClick Quando o controle é clicado
OnEnter Quando o controle recebe o foco
OnExit Quando o foco sai do controle e vai para outro
Quadro 7 Propriedades, métodos e eventos de ListBox

46
 Lazarus/Free Pascal para iniciantes

Na propriedade Items insira os seguintes elementos: Carpinteiro, Analista de

Sistemas, Arquiteto, Enfermeiro, Engenheiro, Pedreiro e Professor. No rótulo que foi
inserido defina Name com lblProfissao e Caption com Profissão.

Muitas opções em pouco espaço (TComboBox)

Caixas de lista ocupam muito espaço na tela e suas opções são fixas, não dando
ao usuário a oportunidade de escolher uma opção diferente daquelas previamente
programadas.
Podemos solucionar essas dificuldades usando caixas combinadas
(TComboBox). Uma caixa combinada reúne em um mesmo controle uma caixa de
edição, onde se pode digitar algum texto, e uma caixa de lista que é aberta quando
pressionamos a seta. O próprio nome do controle sugere que ele é a combinação de dois
componentes, um Edit e um ListBox. No entanto, o comportamento do ComboBox pode
mudar, dependendo do valor da propriedade Style. Veremos um pouco mais adiante
como definir corretamente esta propriedade para que o componente tenha o
comportamento desejado.
Vamos usar uma caixa combinada para definir a escolaridade no cadastro de
dados pessoais. Selecione o componente na paleta Standard e o posicione no form
conforme a figura a seguir. Coloque um rótulo também para identificar a caixa.

Figura 39 Componente ComboBox

Vamos então modificar algumas propriedades deste componente. No quadro a

seguir são apresentadas algumas de suas propriedades, métodos e eventos. A
propriedade Style pode assumir os seguintes valores:

47
 Lazarus/Free Pascal para iniciantes

• csDropDown define uma caixa combinada típica que permite edição e

mostra uma caixa de lista para escolha de opção;
• csDropDownList define uma caixa combinada que não permite edição. Se
for pressionada uma letra, o controle mostra a primeira opção que ele
encontra iniciando com essa letra;
• csSimple define um controle que permite edição e sempre mostra a caixa de
lista. A altura da caixa depende da propriedade Height.

Existem outros valores para essa propriedade, mas apenas essas são de nosso
interesse.

Propriedade Conteúdo Descrição

ItemIndex Define o item selecionado (primeiro item é 0).
Não pode ser alterado em tempo de
desenvolvimento
Items Lista de opções
Name cbxEscolaridade Identificador da caixa combinada
Sorted True Define se os elementos serão ordenados
Style csDropDown Define o estilo de apresentação da caixa
Text Retorna o que foi selecionado ou digitado
Método Descrição
Clear Deleta os itens da caixa combinada
SetFocus Muda o foco para o controle
Evento Descrição
OnChange Quando o conteúdo do controle é modificado
OnClick Quando o controle é clicado
OnEnter Quando o controle recebe o foco
OnExit Quando o foco sai do controle e vai para outro
Quadro 8 Propriedades, métodos e eventos de ComboBox

Na propriedade Items inclua os seguintes elementos: Analfabeto, Fundamental,

Médio, Superior e Pós-graduação. Para o rótulo que foi inserido defina Name como
lblEscolaridade e Caption como Escolaridade.

Escolhendo um valor em um intervalo (TScrollBar)

Vamos explorar agora o controle chamado barra de rolagem (TScrollBar).
Barras de rolagem são normalmente associados com outros componentes, tais como
caixas de lista. Nesses casos a barra de rolagem é parte do componente, uma
propriedade sua.
O uso de barras de rolagem é muito raro, exceto quando a faixa de valores a ser
escolhida é muito grande, pois existe o TTrackBar para intervalos menores. Iremos usar
a barra de rolagem para definir a idade da pessoa no cadastro.
Selecione então uma barra de rolagem na paleta Standard e o insira no form
conforme é mostrado na figura abaixo. Coloque um rótulo para identificar o
componente.

48
 Lazarus/Free Pascal para iniciantes

Figura 40 Componente ScrollBar

Vejamos as propriedades deste componente que serão modificadas. No quadro

seguinte são apresentadas propriedades, métodos e eventos de ScrollBar.

Propriedade Conteúdo Descrição

Kind sbHorizontal Especifica se o controle será horizontal ou
vertical
LargeChange 10 Especifica quanto Position varia quando o
usuário clica nos lados da barra
Max 100 Especifica a posição máxima
Min 1 Especifica a posição mínima
Name sbIdade Identificador da barra de rolagem
Position 1 Indica a posição atual da barra
SmallChange 1 Especifica quanto Position varia quando o
usuário clica nas setas
Método Descrição
SetFocus Muda o foco para o controle
Evento Descrição
OnChange Quando posição da barra é modificada
OnScroll Quando a barra é rolada
OnEnter Quando o controle recebe o foco
OnExit Quando o foco sai do controle e vai para outro
Quadro 9 Propriedades, métodos e eventos de ScrollBar

No rótulo que foi inserido, modifique a propriedade Name para lblIdade e a

propriedade Caption para Idade.

49
 Lazarus/Free Pascal para iniciantes

Agrupando componentes relacionados (TGroupBox)

TGroupBox é usado para agrupar componentes que se relacionam. Usaremos
este componente para colocar dentro um componente do tipo TMemo. Selecione o
GroupBox na paleta Standard e insira-o no form.

Figura 41 Componente GroupBox

Basicamente alteraremos a as propriedades Name e Caption. Defina Name como

gbDados e Caption como Dados Pessoais.

Entrando múltiplas linhas (TMemo)

Vimos antes, que o componente TEdit permite a entrada de uma única linha de
texto. Para possibilitar a entrada de mais de uma linha de texto usaremos o componente
memorando (TMemo). Selecione o componente Memo da paleta Standard e o insira no
form dentro do GroupBox, como mostrado na figura abaixo.

50
 Lazarus/Free Pascal para iniciantes

Figura 42 Componente TMemo

Usaremos este componente para mostrar todos os dados pessoais cadastrados

quando for pressionado o botão correspondente. Assim, precisamos modificar algumas
propriedades de Memo. No quadro a seguir são apresentadas propriedades, métodos e
eventos de Memo.

Propriedade Conteúdo Descrição

Align alClient Determina como o controle se alinha dentro do
seu contêiner
Lines Contém as linhas de texto do controle
Name memDados Identificador do memorando
ReadOnly True Define se o usuário pode editar o texto do
controle
Método Descrição
Clear Deleta as linhas de texto do memorando
SetFocus Muda o foco para o controle
Evento Descrição
OnChange Quando o texto no controle é modificado
OnEnter Quando o controle recebe o foco
OnExit Quando o foco sai do controle e vai para outro
Quadro 10 Propriedades, métodos e eventos de Memo

O contêiner do controle Memo é o GroupBox. Dessa forma, quando definimos a

propriedade Align como alClient, o memorando se ajusta para caber dentro de seu
controle pai. A propriedade Lines é do tipo TStrings, portanto possui propriedades e
métodos particulares que serão abordados posteriormente. Por enquanto entre no editor

51
 Lazarus/Free Pascal para iniciantes

da propriedade Lines e delete a linha existente. Memorandos podem ser usados para
entrada de dados através do teclado, mas no nosso caso ele será usado para receber os
dados programaticamente. Por isso definimos a propriedade ReadOnly como True, para
que o usuário não possa alterar o texto.

Juntando tudo
Insira um novo botão no form. Esse botão, quando pressionado, mostrará os
dados pessoais no campo Memo. Defina a propriedade Caption como Salvar, Default
como True e Name como btnSalvar.
Observe na Figura 43 a seguir como deve ficar o form após a inclusão de um
novo botão. A definição da propriedade Default como True indica que, se o usuário
pressionar a tecla Enter, o evento OnClick será executado.
Agora iremos escrever o código que fará todo o trabalho para nós.
Como vimos no nosso primeiro programa, se queremos que a ação aconteça
quando pressionarmos o botão, então deveremos programar o evento OnClick do botão.
Dê um duplo clique no botão e o editor de código será aberto para inserirmos o código.
Vamos analisar cada linha do código mostrado na Figura 44. Iniciaremos pela
linha 54. Esta linha é responsável por deletar as linhas do memorando, conforme
descrição do método Clear no Quadro 10. Dessa forma toda vez que inserirmos os
dados de uma nova pessoa e pressionarmos o botão btnSalvar, os dados anteriores são
apagados. Observe que, para chamar um método de um componente, informamos o
nome do componente seguido do nome do método separados por ponto.
A propriedade Lines do componente Memo é um objeto do tipo TStrings,
portanto possui propriedades e métodos. Dos métodos disponíveis de Lines usaremos
Add, para adicionar novas linhas ao texto do controle.

Figura 43 Form com a botão btnSalvar

52
 Lazarus/Free Pascal para iniciantes

Na linha 55 do código da Figura 44 o nome da pessoa é adicionada ao texto.

Note a forma de invocarmos o método Add. Add é um método de Lines, e Lines é uma
propriedade de mmDados. O argumento do método deve ser uma string. Como
argumento usamos um literal, que identifica o dado da linha de texto, concatenado ao
nome da pessoa, que é dado pela propriedade Text do componente edNome. A linha 56
é semelhante à 55, não merece maiores comentários.

Figura 44 Código do evento OnClick do botão btnSalvar

A profissão da pessoa é adicionada na linha 57. As profissões estão na

propriedade Items de lbxProfissao. O índice do elemento selecionado no ListBox é dado
pela propriedade ItemIndex. Items pode ser tratado como um vetor indexado por
ItemIndex. Por isso a linha 57 é escrita dessa forma.
Na linha 58 adicionamos a idade da pessoa, definida pela propriedade Position
de ScrollBar. Position é uma propriedade numérica do tipo integer. Antes de
concatenar seu valor é necessário convertê-lo para string. Por isso usamos a função
IntToStr(), para converter um número inteiro para string.
A linha 59 pode ser analisada de forma semelhante à linha 57. Portanto não será
necessário acrescentar nenhum comentário a respeito.
No caso das linhas 60 a 63, é o que se faz necessário para mostrar o sexo da
pessoa. Como a propriedade Checked do componente CheckBox é boolean, usamos isso
para implementar uma estrutura de decisão. Se Checked estiver marcado (True) então
será mostrado sexo masculino, caso contrário será mostrado sexo feminino.
TStrings, sendo uma classe, como já foi comentado, possui atributos e métodos
também. A seguir mostramos os membros mais usados. Note que a propriedade Items
dos componentes TComboBox e TListBox, assim como Lines, de TMemo, também são
do tipo TStrings.

Propriedade Conteúdo Descrição

Count Informa quantas linhas existem na lista
Strings Referencia as strings na lista através de sua
posição. Sempre baseada em 0
Text Retorna as strings da lista como uma única string
onde cada linha é finalizada com um Enter (LF)
e um retorno de carro (CR)
Método Descrição
53
 Lazarus/Free Pascal para iniciantes

Add Adiciona uma string no final da lista

AddStrings Adiciona um TStrings na lista
Clear Deleta as linhas de texto da lista
Delete Deleta uma linha da lista usando sua posição
IndexOf Procura uma string na lista
Insert Insere uma string em uma posição específica
LoadFromFile Preenche a lista com as linhas de um arquivo
texto
SaveToFile Salva a lista em um arquivo texto
Quadro 11 Propriedades e métodos de TStrings

O Lazarus, além da função IntToStr() que usamos no código da Figura 44, tem
outras funções para conversão de tipos que são mostradas no quadro a seguir:

Função Descrição
StrToInt(const S: String) Converte um String para Inteiro
IntToStr(value: Integer) Converte um Inteiro para String
StrToFloat(const S: String) Converte um String para Ponto Flutuante
FloatToStr(value: Extended) Converte um Ponto Flutuante para String
DateToStr(date: TDateTime) Converte um TDateTime para String
DateTimeToStr(date: TDateTime) Converte um TDateTime para String
StrToDate(const S: String) Converte um String para TDateTime
StrToDateTime(const S: String) Converte um String para TDateTime
TimeToStr(time: TDateTime) Converte um TDateTime para String
FormatFloat(const format: String; value: Formata um Ponto Flutuante retornando um
Extended) String de acordo com o formato
Quadro 12 Funções de conversão de dados

54
 Lazarus/Free Pascal para iniciantes

Capítulo 4 Caixas de Diálogo

O Lazarus oferece algumas caixas de diálogo pré-definidas que facilitam muito o
desenvolvimento de aplicações.

ShowMessage
Declarada internamente pelo Lazarus da seguinte forma:

procedure ShowMessage(const Msg: string);

Onde o argumento é uma string.

Para experimentar a utilização das caixas de diálogo vamos criar uma nova
aplicação. Depois de iniciar a nova aplicação vamos modificar Name do form para
frmDialogos, e Caption para Diálogos. Depois vamos salvá-la. Vamos dar à unit o
nome de u_dialogos e ao projeto o nome Dialogos.
Insira um botão, dê a ele o nome de btnMensagem1 e em Caption coloque
ShowMessage. Aumente a largura do botão, deixando a propriedade Width com o valor
100. Agora dê um duplo clique no botão e quando abrir o editor de código escreva:

ShowMessage('Este texto será mostrado');

Execute a aplicação e pressione o botão. A caixa de diálogo será mostrada:

Figura 45 Caixa de diálogo ShowMessage

Essa é a caixa mais simples que existe no Lazarus. Sua barra de título sempre
mostra o nome do projeto e apresenta apenas o botão OK.
É possível criar mensagens em múltiplas linhas usando qualquer um dos
seguintes separadores:
• sLineBreak;
• LineEnding;
• ou #13#10.
Por exemplo, esta mensagem será mostrada em duas linhas:

ShowMessage('Primeira linha' + sLineBreak

+ 'segunda linha');

55
 Lazarus/Free Pascal para iniciantes

MessageDlg
ShowMessage apenas mostra uma mensagem, não permite interação com o
usuário. MessageDlg permite vários tipos de diálogos e oferece recurso de resposta do
usuário. Essa caixa de diálogo é declarada pelo Lazarus de duas formas:

function MessageDlg(const Msg: string; DlgType:

TMsgDlgType; Buttons: TMsgDlgButtons; HelpCtx: Longint):
Word;
function MessageDlg(const aCaption, Msg: string;
DlgType: TMsgDlgType; Buttons: TMsgDlgButtons; HelpCtx:
Longint): Word;

Na primeira versão aCaption é opcional e será mostrado um texto

correspondente ao DlgType informado.
Onde:
const Msg: string é uma constante ou variável do tipo string que contém a
mensagem que será mostrada na caixa de diálogo.
DlgType: TMsgDlgType são ícones que indicam o tipo da caixa de diálogo.
Pode ser mtWarning (ícone 'exclamação' amarelo), mtError (ícone 'pare' vermelho),
mtInformation (ícone 'i' azul), mtConfirmation (ícone 'interrogação' verde) e mtCustom
(não tem ícone).
Buttons: TMsgDlgButtons é um array de botões que aparecem na caixa. Pode
ser mbYes, mbNo, mbOk, mbCancel, mbAbort, mbRetry, mbIgnore, mbAll,
mbNotToAll, mbYesToAll e mbHelp.
HelpCtx: Longint define o número do help de contexto. Por padrão é 0.

O retorno da função é a informação do botão pressionado pelo usuário. Assim,

apenas troque mb por mr nos nomes dos botões, para verificar o botão que foi clicado.
Os possíveis valores de retorno são mrYes, mrNo, mrOk, mrCancel, mrAbrot, mrRetry,
mrIgnore, mrAll, mrNotToAll, mrYesToAll e mrHelp. Vamos então programar o
evento OnCloseQuery do form da nossa aplicação Dialogos. Esse evento acontece
quando a janela é fechada, mas dá ao usuário a chance de confirmar ou não o
fechamento. Selecione o evento na aba Events do ObjectInpector, dê um duplo clique
na sua direita para abrir o editor de código e digite o seguinte código

if MessageDlg('Deseja sair?', mtConfirmation, [mbYes,

mbNo], 0) = mrNo then
CanClose := False;

CanClose é uma variável boolean, declarada pelo método que estamos

programando. Seu valor padrão é True, e neste caso a janela é fechada. Se quisermos
impedir seu fechamento mudamos a variável para False. Execute o programa e clique o
botão para fechar a janela. A seguinte caixa será mostrada:

56
 Lazarus/Free Pascal para iniciantes

Figura 46 Caixa de diálogo MessageDlg

Se você pressionar o botão Yes a janela será fechada. Observe que na barra título
apareceu o texto Confirmation, pois usamos a versão de ShowMessage onde aCaption é
opcional. Mas podemos usar a segunda versão, onde podemos informar um texto como
caption assim:

if MessageDlg('Confirmação', 'Deseja sair?',

mtConfirmation, [mbYes, mbNo], 0) = mrNo then
CanClose := False;

Desta forma a caixa será mostrada assim:

Figura 47 Caixa de diálogo MessageDlg com caption

Os textos dos botões estão em inglês porque a API (Interface de Programação de

Aplicativos) do Lazarus é toda em inglês. Mais adiante veremos uma solução para esse
problema.

Application.MessageBox
Esta caixa de diálogo é a mais completa do ambiente Lazarus, a que apresenta
maior flexibilidade para o programador e está definida da seguinte forma:

function Application.MessageBox(const Text, Caption:

PChar; Flags: Longint): Integer;

Onde:
const Text é uma constante ou variável do tipo PChar que contém o texto da
mensagem. PChar é um ponteiro para uma string.
Caption: PChar define um título para a janela. É do tipo PChar.
57
 Lazarus/Free Pascal para iniciantes

Flags: Longint define botões, ícones e a possibilidade de focar um determinado

botão. Os valores de botão são MB_ABORTRETRYIGNORE, MB_OK,
MB_OKCANCEL, MB_RETRYCANCEL, MB_YESNO e MB_YESNOCANCEL. Os
ícones podem ser MB_ICONEXCLAMATION, MB_ICONWARNING,
MB_ICONINFORMATION, MB_ICONASTERISK, MB_ICONQUESTION,
MB_ICONSTOP, MB_ICONERROR e MB_ICONHAND. Os valores para definição
de botão default são MB_DEFBUTTON1, MB_DEFBUTTON2, MB_DEFBUTTON3
e MB_DEFBUTTON4. Para utilização correta desse parâmetro é necessário declarar a
unit LCLType na cláusula uses.

O retorno da função é o botão que foi pressionado. Os possíveis valores de

retorno são IDABORT, IDCANCEL, IDIGNORE, IDNO, IDOK, IDRETRY e IDYES.
Insira um novo botão no form do projeto Dialogos. Na propriedade Name
informe btnMensagem2, na propriedade Caption defina MessageBox. Altere a
propriedade Width para 100. Declare LCLType na cláusula uses. Dê um duplo clique
no botão para programar o evento OnClick de btnMensagem2. No editor de código
digite então o seguinte:

if Application.MessageBox('Deseja salvar o arquivo?',

'Confirmação', MB_YESNOCANCEL + MB_ICONQUESTION +
MB_DEFBUTTON2) = idYes then
ShowMessage('Você pressionou o botão SIM');

Este não é um código muito funcional, apenas exemplifica a utilização de

MessageBox. Observe como são informados os botões, o ícone e o botão default. Como
definimos que MB_DEFBUTTON2 é o botão default, então o default será o botão Não.
Execute o programa e pressione o botão MessageBox. A caixa irá parecer com a figura.

Figura 48 Caixa de diálogo MessageBox com botões de opções

Tanto MessageDlg quanto MessageBox podem ser usadas apenas para apresentar
informações ao usuário, sem necessidade de checar o botão pressionado. Por exemplo,
se for inserido o código abaixo no evento OnClick do botão btnMensagem2:

Application.MessageBox('Arquivo não pode ser salvo',

'Informação', MB_OK + MB_ICONEXCLAMATION);

A seguinte caixa de diálogo será mostrada.

58
 Lazarus/Free Pascal para iniciantes

Figura 49 MessageBox para informações ao usuário

Note que apresentamos apenas o botão OK. Sendo uma informação sobre uma
ocorrência, podendo ser inclusive uma mensagem de erro, não precisamos verificar o
botão pressionado pelo usuário.
Em certas situações pode ser que o programador deseje construir caixas de
diálogo dinâmicas, ou seja, onde as mensagens de texto dependem de determinadas
condições durante a execução do programa. Nesses casos deve-se observar que os
argumentos de MessageBox não são do tipo string e sim PChar. Analisemos o código a
seguir:

var
Msg: string;
begin
Msg := 'Arquivo não pode ser salvo';
Application.MessageBox(PChar(Msg), 'Informação',
MB_OK + MB_ICONEXCLAMATION);
end;

Para podermos usar uma string como argumento de MessageBox é necessário

convertermos para PChar. Por isso usamos a chamada à função PChar().

InputBox
O ambiente Lazarus oferece também caixas de diálogo para entrada de dados do
usuário. Uma dessas caixas é InputBox, que retorna um tipo string com o texto digitado
pelo usuário. A definição interna dessa função é:

function InputBox(const ACaption, APrompt, ADefault:

string): string;

Onde:
const ACaption define o título da janela.
APrompt define a orientação ao usuário dentro da caixa.
ADefault define um valor default para a caixa. Será retornado se o usuário
pressionar a tecla Cancel.

59
 Lazarus/Free Pascal para iniciantes

Para exemplificar o funcionamento dessa caixa de entrada vamos inserir um

botão no form do programa Dialogos. Na propriedade Name digite btnEntrada1, em
Caption escreva InputBox. Altere a largura do botão modificando a propriedade Width
para 100. Para programarmos o evento OnClick do botão dê um duplo clique nele. No
editor de código faça as alterações para que o procedimento do evento fique assim:

var
Cidade: string;
begin
Cidade := InputBox('Entrada',
'Digite o nome da cidade', 'Santarém');
end;

Execute o programa e clique no botão InputBox. A seguinte caixa de diálogo

será mostrada na tela:

Figura 50 Caixa de diálogo InputBox

Se você clicar no botão Cancel, a função retornará o texto default, no nosso

caso, Santarém. Ou podemos digitar uma nova cidade no campo e pressionar OK.

InputQuery
InputQuery retorna um tipo boolean, o texto digitado pelo usuário será atribuído
a uma variável string previamente declarada. A função retornará True se o usuário
pressionar OK ou retornará False, caso o usuário pressione o botão Cancel.
Internamente a função é assim definida, em duas versões:

function InputQuery(const ACaption, APrompt: string;

var Value: string): Boolean;
function InputQuery(const ACaption, APrompt: string;
MaskInput: Boolean; var Value: string): Boolean;

A segunda versão inclui o parâmetro MaskInput do tipo boolean que determina

se a entrada do usuário será mascarada com asteriscos, como em uma senha.
Os parâmetros são semelhantes aos de InputBox, no entanto Value deve ser
declarada e inicializada antes, pois é passada por referência à função e retorna o texto
digitado pelo usuário.

60
 Lazarus/Free Pascal para iniciantes

Para exemplificar o funcionamento da função InputBox vamos inserir um novo

botão e um rótulo na nossa aplicação Dialogos. Na propriedade Name do botão informe
btnEntrada2, na propriedade Caption informe InputQuery e na propriedade Width
modifique o valor para 100. No rótulo defina Name como lblCidade e Caption como
Santarém. Clique no ícone ao lado da propriedade Font no Object Inspector para
expandi-la. Defina Size como 16. O form deve ficar com aparência semelhante à da
Figura 51 a seguir.
Queremos que o usuário digite o nome de uma cidade e que esse nome seja
mostrado no rótulo lblCidade, apenas se for pressionado o botão OK. Para programar o
evento OnClick desse botão dê um duplo clique nele e digite o seguinte código no
editor:

var
Cidade: string;
begin
Cidade := 'Santarém';
if InputQuery('Cidade', 'Digite o nome da cidade',
Cidade) then
lblCidade.Caption := Cidade;
end;

Figura 51 Aplicação Dialogos com um novo botão e rótulo

Execute o programa e clique no botão InputQuery. Digite o nome de uma cidade

e pressione OK. O nome digitado será mostrado no rótulo.

Traduzindo as Caixas de Diálogo

Foi visto até agora que as interfaces das caixas de diálogo estão em inglês.
Vejamos então uma dica para traduzir tudo para português.

61
 Lazarus/Free Pascal para iniciantes

Inicialmente selecione a opção de menu Project | View Source, para abrir o

código do arquivo de projeto da aplicação. Digite o código destacado na Figura 52 e
compile o programa. Pressione os botões correspondentes às caixas de diálogo e
verifique que as interfaces agora estão em português.

Figura 52 Código para traduzir caixas de diálogo

Observe que o código deve funcionar em Windows e Linux, de acordo com as

diretivas de compilação. Os diretórios que constam no código são o padrão. Se sua
instalação foi feita em diretório diferente altere o código.

62
 Lazarus/Free Pascal para iniciantes

Botão com ícone (TBitBtn)

Para finalizar nosso programa Dialogos, vamos inserir um botão para fechar a
janela. Mas vamos usar um botão diferente. Selecione a aba de componentes
Additional. Selecione o botão BitBtn e o insira no form.
BitBtn é um botão que, além de um Caption, aceita também um ícone e possui
alguns comportamentos pré-definidos. Você pode adicionar botões tais como OK,
Cancel, Close, etc. sem necessidade de escrever nenhum código. Vamos descrever
algumas propriedades de BitBtn.

Propriedade Conteúdo Descrição

Caption &Fechar Legenda do botão
Default False Evento OnClick não é executado se Enter for
pressionado
Enabled True Habilita o botão
Glyph Define um ícone para o botão
Kind bkClose Seleciona o tipo do botão e seu comportamento
Name btnFechar Identificador do botão
Quadro 13 Propriedades de BitBtn

Demais propriedades, métodos e eventos são os mesmos de TButton. Observe

que alteramos a propriedade Caption para Fechar. Quando você escolhe o tipo em Kind,
o Lazarus atribui a Caption um texto com o mesmo nome do tipo. Podemos alterá-lo
sem com isso mudar seu comportamento. No entanto não podemos alterar o ícone, pois
isso implicaria na mudança de Kind para bkCustom, que significa um botão onde o
programador define seu comportamento e seria necessário inserir código para isso. Note
que não inserimos código para o evento OnClick, mas se executarmos o programa e
pressionarmos o botão Fechar a janela será fechada.

63
 Lazarus/Free Pascal para iniciantes

Capítulo 5 Criando Menus

As aplicações que criamos até o momento não possuem um dos elementos de
interface mais importantes de uma aplicação Windows: a barra de menus. Mesmo
nossas aplicações tendo um menu de sistema (aquele do canto superior esquerdo),
muitas tarefas são acessadas através de comandos de menu.
Uma aplicação possui vários menus que podem inclusive mudar em tempo de
execução e vários menus locais (normalmente acessados através de um clique no botão
direito do mouse).
Os componentes para criar menus estão localizados na aba Standard da paleta
de Componentes.

Estrutura do Menu Principal

Geralmente os menus têm dois níveis. Uma barra de menu, abaixo do título da
janela, contém os nomes dos sub-menus (pull-down), que por sua vez têm uma série de
itens. No entanto a estrutura de menu é muito flexível. É possível colocar um item de
menu diretamente na barra de menu e colocar um sub-menu de segundo nível dentro de
outro sub-menu.
Você deve evitar colocar comandos diretamente na barra de menu. Isso não é
muito comum. Se realmente isso for necessário, acrescente um menu com um único
item de menu. Um exemplo típico é o menu Ajuda com o item Sobre.
Colocar sub-menus dentro de outro sub-menu - um sub-menu de segundo nível -
é mais comum, e neste caso o Windows oferece uma indicação visual, um pequeno
triângulo à direita do menu. De qualquer maneira, menus de segundo nível podem se
tornar o uso do programa uma coisa chata. Pense na possibilidade de agrupar as opções
separando os grupos por barras separadoras. Veja a figura 53.

64
 Lazarus/Free Pascal para iniciantes

Figura 53 Menu com opções agrupadas e sub-menu

Diferentes funções dos itens de menu

Há três tipos fundamentais de itens de menu:

• Comandos são itens de menu usados para executar uma ação. Não têm
indicação visual de sua função.
• Modificadores de estado são itens usados para alternar uma opção entre
ligado e desligado, para mudar o estado de um elemento particular. Esses
comandos geralmente possuem uma marca no lado esquerdo para indicar que
estão ativos. Neste caso, selecionar a opção produz a ação oposta.
• Diálogo são itens que invocam uma caixa de diálogo quando são
selecionados. Isso inclui qualquer janela onde o usuário precise interagir.
Estes comandos deveriam ter uma indicação visual que consiste de três
pontos após o texto.
65
 Lazarus/Free Pascal para iniciantes

Aplicação Exemplo
Para exemplificarmos a construção de menus vamos criar uma nova aplicação.
Defina a propriedade Name do form como frmMenus, o Caption como Menus e salve
tudo atribuindo à unit o nome u_menus e ao projeto o nome AplicacaoMenu.
Selecione um rótulo na aba Standard e insira-o no form. Defina a propriedade
Name como lblTexto. Na propriedade Align selecione alClient. Escreva algum texto
bastante longo na propriedade Caption. Mude a propriedade WordWrap para True, para
ter várias linhas de texto. Mude AutoSize para False para permitir o redimensionamento
do rótulo. Clique no ícone ao lado da propriedade Font, para expandi-la, e altere Name
para Arial e Size para 38.
Selecione um componente TPanel na aba Standard e o insira no form. Panel é
usado para agrupar outros controles. Muito usado para criar barras de ferramentas. É
exatamente isso que vamos implementar na nossa aplicação. Mude a propriedade Name
do Panel para panBarra, e delete o texto da propriedade Caption. Defina sua
propriedade Align como alTop.

Figura 54 Aplicação Menus

Insira cinco botões (TButton) e os posicione adequadamente no Panel. No

primeiro defina Name como btnFonte e Caption como Cor &Texto... No segundo defina
Name como btnFundo e Caption como Cor &Fundo... No terceiro defina Name como
btnEsquerda e Caption como &Esquerda. No quarto defina Name como btnCentro e
Caption como &Centro. No último defina Name como btnDireita e Caption como
&Direita. A janela deve ficar como a Figura 54.
Os três últimos botões mudam o alinhamento (Alignment) do rótulo. Então
vamos escrever o código para os eventos OnClick desses botões. Dê um duplo clique
em cada um deles. Para btnEsquerda digite no editor de código:

lblTexto.Alignment := taLeftJustify;
66
 Lazarus/Free Pascal para iniciantes

Para btnCentro digite:

lblTexto.Alignment := taCenter;

E para btnDireita digite:

lblTexto.Alignment := taRightJustify;

Você pode verificar a funcionalidade dos botões executando a aplicação e

pressionando cada um deles e observando seus efeitos sobre o texto do rótulo.

A Caixa de Diálogo ColorDialog

Vamos inserir na nossa aplicação um componente denominado ColorDialog.
Esse componente serve para apresentar a caixa de diálogo para seleção de cores padrão
do ambiente Windows. Localize-o na aba Dialogs. Pode ser colocado em qualquer lugar
da janela, pois não é um componente visual, ou seja, não será visível quando o
programa for executado. Será invocado em tempo de execução pelos dois primeiros
botões, por isso eles têm os três pontos no Caption, para indicar a chamada a uma caixa
de diálogo. Vamos mudar a propriedade Name do componente. Defina-a como
dlgCores.
Queremos que, quando pressionados, os dois primeiros botões chamem a caixa
de diálogo dlgCores. Nessa caixa selecionamos a cor desejada e quando pressionarmos
o botão OK, a cor será atribuída à propriedade Color do rótulo ou à propriedade Color
de Font.
Dê um duplo clique no botão btnFonte e digite o seguinte código no editor:

dlgCores.Color := lblTexto.Font.Color;
if dlgCores.Execute then
lblTexto.Font.Color := dlgCores.Color;

Na primeira linha fazemos com que a caixa de diálogo seja mostrada com a cor
do texto. Depois executamos a caixa de diálogo e, se o usuário pressionar o botão OK, a
cor do texto do rótulo é modificada. O método Execute de ColorDialog retorna True se
for pressionado o botão OK ou False se for pressionado o botão Cancel. Vamos fazer o
mesmo com o botão btnFundo e digitar o seguinte código no editor:

dlgCores.Color := lblTexto.Color;
if dlgCores.Execute then
lblTexto.Color := dlgCores.Color;

Execute o programa e clique no botão btnFonte. Você terá a caixa de diálogo de

cores como na figura:

67
 Lazarus/Free Pascal para iniciantes

Figura 55 A caixa ColorDialog

Criando um Menu com o Menu Editor

Vamos criar um menu com a seguinte estrutura:

Arquivo
Sair
Exibir
Barra de ferramentas
Opções
Cor do texto
Cor do fundo
Esquerda
Centro
Direita
Ajuda
Sobre

O Lazarus possui um editor de menus chamado Menu Editor. Para utilizá-lo

precisamos de um componente TMainMenu. Selecione esse componente na aba
Standard e o insira no form em qualquer posição. O Lazarus se encarrega de posicionar
o menu no lugar correto, abaixo da barra de título.
O Menu Editor é uma ferramenta poderosa: você cria um menu simplesmente
escrevendo o texto dos comandos, para mover os itens simplesmente use o menu local
conforme será mostrado em seguida e as propriedades podem ser modificadas
facilmente.
Para comprovar isso vamos dar um duplo clique no componente MainMenu. A
janela do Menu Editor será mostrada, apresentando a primeira opção de menu. Digite
&Arquivo na propriedade Caption e tecle ENTER, e na propriedade Name digite
68
 Lazarus/Free Pascal para iniciantes

mnuArquivo. O Menu Editor define a primeira opção. Clique com o botão direito sobre
a opção Arquivo para visualizar o menu local, conforme pode ser visto na figura:

Figura 56 Menu Editor

Neste menu local podemos:

• Insert New Item (after) – inserir novo item de menu depois do atual;
• Insert New Item (before) – inserir novo item de menu antes do atual;
• Delete Item – deletar o item atual;
• Create Submenu – criar um submenu sob o item de menu atual;
• Handle OnClick Event – manipular o evento OnClick;
• Move Up (or left) – mover o item atual para cima ou para esquerda;
• Move Down (or right) – mover o item atual para baixo ou para direita.
Clique na opção Create Submenu para criar o submenu sob a opção Arquivo.
Estando a opção do submenu selecionado digite Sai&r na propriedade Caption. Na
propriedade Name digite mitSair.
Clique novamente com o botão direito sobre a opção Arquivo e escolha a opção
Insert New Item (after). No retângulo identificado como novo item, digite E&xibir na
propriedade Caption e tecle ENTER, e na propriedade Name digite mnuExibir. Crie um
submenu abaixo de Exibir e digite Barra de &ferramentas na propriedade Caption, na
propriedade Checked desse item defina True, e na propriedade Name digite
mitBarraFerramentas. No próximo menu digite &Opções na propriedade Caption, na
propriedade Name digite mnuOpcoes. No submenu digite Cor do &texto... no Caption
primeiro item e mitCorTexto em Name. Digite Cor de &fundo... no Caption segundo
item e mitCorFundo em Name. No terceiro item digite um hífen (-). Isso cria um
separador no submenu. No quarto item digite &Esquerda no Caption e mitEsquerda em
Name. No quinto item digite &Centro no Caption e mitCentro em Name. No último
item digite &Direita no Caption e mitDireita em Name. Finalmente no último menu
digite Aj&uda na propriedade Caption e mnuAjuda em Name, e no submenu digite
&Sobre... no Caption e mitSobre em Name.

69
 Lazarus/Free Pascal para iniciantes

Figura 57 Aspecto do menu criado

Teclas de atalho e hotkeys

Uma característica dos itens de menu é que eles podem conter uma letra
sublinhada, chamada hotkey. Esta letra é usada para selecionar o menu usando o teclado.
Pressionando ALT mais a letra sublinhada seleciona-se o menu. Pressionando outra
letra sublinhada envia-se o comando. As letras sublinhadas de cada item dentro de um
submenu devem ser diferentes. Observe que durante a criação do nosso menu,
definimos as letras sublinhadas inserindo um & antes da letra.
Outra característica padrão dos menus são as teclas de atalho. Quando aparece
uma combinação de teclas no lado direito do item de menu, significa que você pode usar
essa combinação para executar o comando. Essa característica oferece a maneira mais
rápida de executar um comando.
Para associar teclas de atalho a um item de menu é muito fácil. Ainda no Menu
Editor simplesmente escolha uma combinação de teclas na propriedade ShortCut do
item. Vamos fazer isso para as opções: Esquerda, Centro e Direita. Selecione a opção
Esquerda e na propriedade ShortCut selecione a combinação CTRL + E. Para a opção
Centro selecione CTRL + C e para a opção Direita selecione CTRL + D. As teclas de
atalho não são visíveis no Menu Editor. Feche o Menu Editor e clique em Opções como
mostra a figura abaixo:

70
 Lazarus/Free Pascal para iniciantes

Figura 58 Menu com teclas de atalho

Respondendo aos comandos do menu

Para responder aos comandos de menu, você deveria definir um método para o
evento OnClick de cada item de menu. No Menu Editor, selecione o item de menu Sair.
Selecione a aba Events do Object Inspector e dê um duplo clique no evento OnClick.
Queremos que janela seja fechada quando o usuário selecionar este comando. Portanto,
quando abrir o editor de código digite o comando:

Close;

O comando Exibir | Barra de ferramentas tem uma marca de verificação, fica

marcada quando a barra de ferramentas está visível. Aqui está o código para o evento
OnClick desse comando:

panBarra.Visible := not panBarra.Visible;

mitBarraFerramentas.Checked := panBarra.Visible;

A primeira linha muda a visibilidade da barra de ferramentas que foi criada

usando o componente Panel. A segunda linha marca/desmarca o item de menu de
acordo com a visibilidade do painel.
No comando Opções | Cor do texto digite o seguinte código para o evento
OnClick:

dlgCores.Color := lblTexto.Font.Color;
if dlgCores.Execute then
lblTexto.Font.Color := dlgCores.Color;

71
 Lazarus/Free Pascal para iniciantes

Note que este código é exatamente o mesmo programado para o evento OnClick
do botão btnFonte. Na verdade não precisamos replicar esse código aqui. Mostraremos
então como reutilizar o código do evento de um componente em outro. Observe que o
código do comando Opções | Cor de fundo é o mesmo do evento OnClick do botão
btnFundo. Então selecione esta opção no Menu Editor e vá para a aba Events no Object
Inspector. Clique no botão do ComboBox do evento OnClick para ver todos os eventos
disponíveis. Selecione btnFundoClick. Pronto, agora o comando do menu chamará o
mesmo código do evento OnClick do botão btnFundo.
Os outros três itens do menu Opções têm basicamente o mesmo código dos
botões de alinhamento. Portanto repita o procedimento anterior para as opções
Esquerda, Centro e Direita, de forma que seus eventos OnClick sejam os mesmos dos
três botões correspondentes da barra de ferramentas. No entanto devemos acrescentar
uma marca de verificação ao lado do item que estiver habilitado, desmarcando os
demais. Inicialmente, no Menu Editor, selecione Opções | Esquerda e altere a
propriedade Checked para True. Essa é a nossa situação padrão. Sempre que a
aplicação iniciar, o texto estará alinhado à esquerda. Em seguida vamos modificar o
código para o comando em questão. Selecione o evento OnClick do item de menu e dê
um duplo clique nele. Acrescente então o seguinte código:

mitEsquerda.Checked := True;
mitCentro.Checked := False;
mitDireita.Checked := False;

Este código, além de definir o alinhamento à esquerda do texto, marca e

desmarca adequadamente as opções do menu. Vamos agora modificar o evento OnClick
de Opções | Centro. Digite o seguinte código:

mitEsquerda.Checked := False;
mitCentro.Checked := True;
mitDireita.Checked := False;

Em Opções | Direita digite o seguinte código:

mitEsquerda.Checked := False;
mitCentro.Checked := False;
mitDireita.Checked := True;

Chamadas a forms
Com certeza suas aplicações sempre terão muitos forms. Existe um form
principal (main) que faz chamadas a outros forms. A maneira de chamarmos forms será
estudada agora. Vamos criar um novo form na nossa aplicação. Esta janela será nosso
Sobre (About).
Selecione File | New Form. Isso inclui um novo form ao nosso programa. Altere
o Caption para Sobre e a propriedade Name para frmSobre. Salve a unit e dê a ela o
nome u_sobre.
Inclua um TLabel em frmSobre. Altere a propriedade WordWrap para True e
AutoSize para False. Na propriedade Caption digite Programa Menus desenvolvido por
72
 Lazarus/Free Pascal para iniciantes

Carlos Araújo apenas para fins didáticos. Na propriedade Alignment informe taCenter.
Ajuste o rótulo no form para que ele fique como na figura abaixo.

Figura 59 Formulário Sobre

Coloque outro rótulo no frmSobre e defina o Caption como Versão 1.0. Coloque
um TBitBtn no form. Defina Name como btnFechar, em Kind informe bkClose e
modifique Caption para &Fechar.
Queremos chamar frmSobre quando o usuário selecionar o comando Ajuda |
Sobre. No entanto, apesar de frmSobre fazer parte do nosso projeto, frmMenus não sabe
da sua existência. É necessário dizermos a frmMenus que frmSobre existe. Para fazer
isso precisamos dizer a frmMenus que use a unit u_sobre, correspondente a frmSobre.
Logo abaixo da palavra implementation na unit u_menus escreva o seguinte código:

uses u_sobre;

Isso habilita frmMenus acessar qualquer objeto de frmSobre e o próprio form. Há

duas maneiras de fazermos chamadas a um form:

• Modal - o foco fica preso ao form e não é liberado até que este seja fechado.
O usuário pode ativar qualquer outra aplicação Windows, mas não pode
ativar outra janela da aplicação cuja janela foi aberta como modal. Para
ativar esse modo chame o form usando o método ShowModal.
• Não modal - o foco pode ser transferido para outra janela sem que esta
precise ser fechada. Para ativar esse modo chame o form usando o método
Show.

Agora selecione o evento OnClick do comando Ajuda | Sobre e digite o

seguinte código:

frmSobre.ShowModal;

Execute o programa e clique no comando Ajuda | Sobre. A aparência da

aplicação deve ser como a Figura 60.
73
 Lazarus/Free Pascal para iniciantes

Em tempo de desenvolvimento gerenciar muitos forms pode ser muito

trabalhoso, pois apenas um deles pode estar ativo a cada instante. Para selecionar um
form a ser modificado, selecione o comando View | Forms, pressione o botão
correspondente na barra de ferramentas ou use as teclas de atalho SHIFT + F12. Para
selecionar uma unit, selecione o comando View | Units, pressione o botão
correspondente na barra de ferramentas ou use as teclas de atalho CRTL + F12.

Figura 60 A janela Sobre

Menus locais (Pop-up)

Nas aplicações Windows é comum haver menus locais ativados com um clique
no botão direito do mouse. O menu que é mostrado geralmente depende do local onde o
mouse é clicado. Esses menus agrupam opções relacionadas com o elemento da
interface que está selecionado. São mais rápidos que o menu estudado anteriormente
porque não necessita que o mouse seja movimentado para ativá-lo.
No Lazarus há duas maneiras de tratar menus locais. Podemos deixar o Lazarus
manipulá-los automaticamente ou escolher a técnica manual. Vamos apresentar aqui
apenas o menu local automático.
Para adicionar um menu local a um form, selecione o componente TPopupMenu
na aba Standard e o insira no form em qualquer posição. Altere a propriedade Name
para mlAlinhamento. Dê um duplo clique no componente para abrir o Menu Editor.
Insira as opções: Esquerda, Centro e Direita. Na opção Esquerda mude a propriedade
Checked para True, e a propriedade Name para mliEsquerda. Mude Name de Centro
para mliCentro e da opção Direita para mliDireita. Ou seja, queremos um menu local
com as mesmas opções referentes ao alinhamento do texto do rótulo do MainMenu que
criamos. Portanto vamos fazer algumas modificações nos métodos para reutilizar o
código. No método do evento OnClick do botão btnEsquerda vamos incluir código para
marcar e desmarcar as opções do menu local:

74
 Lazarus/Free Pascal para iniciantes

lblTexto.Alignment := taLeftJustify;
mitEsquerda.Checked := True;
mliEsquerda.Checked := True;
mitCentro.Checked := False;
mliCentro.Checked := False;
mitDireita.Checked := False;
mliDireita.Checked := False;

Depois selecione a opção Esquerda no menu local, vá para a aba Events do

Object Inspector, clique no botão do evento OnClick e selecione o método
btnEsquerdaClick. Agora quando executarmos o comando Esquerda no menu local
estaremos executando o mesmo método do evento OnClick do comando Opções |
Esquerda. E o código marcará/desmarcará opções nos dois menus. Vamos repetir o
procedimento para as opções Centro e Direita.
Selecione o rótulo lblTexto e na propriedade PopupMenu selecione
mlAlinhamento. Esta é a maneira de associar o menu local a um componente. Execute o
programa, clique com o botão direito do mouse no rótulo, selecione uma das três opções
de alinhamento do texto e verifique que a opção escolhida fica marcada nos dois menus.

Figura 61 O componente PopupMenu

75
 Lazarus/Free Pascal para iniciantes

Capítulo 6 Barras de ferramentas e de status

Barra de ferramentas (TToolBar)
A barra de ferramentas (ToolBar) é um componente com botões próprios e
recursos personalizados. Os botões são do tipo TToolButton, considerados objetos
internos de ToolBar.
Para exemplificar sua utilização vamos substituir o painel de botões do programa
Menus por um componente ToolBar. Para isso selecione o componente panBarra e
pressione a tecla DEL. Assim o painel e todos os botões inseridos nele são deletados.
Note que os métodos definidos para os botões não foram excluídos, porque existe
código do programador neles.
Agora selecione o componente ToolBar na aba Common Controls e o insira em
qualquer posição do form. O componente alinha-se automaticamente no topo do form,
abaixo da barra de menu. Algumas propriedades desse componente são apresentadas no
quadro a seguir:

Propriedade Conteúdo Descrição

+EdgeBorders
ebLeft False Define bordas para a barra de ferramentas. Nesse
ebTop True caso, definimos que haverá bordas no topo e na
ebRight False base
ebBottom True
EdgeInner esRaised Define o formato interno da borda
EdgeOuter esLowered Define o formato externo da borda
Flat True Torna a ToolBar transparente e deixa os botões
sem bordas
Images Permite definir um objeto ImageList que contém
as imagens para os botões
Name tbBarra Identificador da barra de ferramentas
Quadro 14 Propriedades de ToolBar

Altere as propriedades do componente de acordo com a tabela. Experimente

vários formatos de borda e deixe-os da maneira que você achar mais adequada.
Vamos inserir os botões. Para isso clique com o botão direito do mouse no
componente ToolBar e selecione a opção New Button. Inclua dois botões. Ao primeiro
dê o nome de tbuFonte e ao segundo dê o nome de tbuFundo. Agora insira um
separador clicando com o botão direito do mouse e selecionando New Separator. Insira
três botões em seguida e dê a eles os nomes: tbuEsquerda, tbuCentro e tbuDireita.
Os botões que compõem barras de ferramentas possuem imagens e não captions.
Portanto vamos inserir imagens nos nossos botões. Selecione o componente TImageList
da aba Common Controls e o coloque no form em qualquer posição. Dê um duplo
clique no ImageList e pressione o botão Add. Selecione um ícone para cada botão.
Depois de escolher imagens para os botões clique na barra de ferramentas e na
propriedade Images selecione ImageList1. Cada uma das imagens escolhidas será
inserida em um botão conforme mostra a Figura 62.
76
 Lazarus/Free Pascal para iniciantes

Figura 62 Barra de ferramentas

Vamos reutilizar os métodos programados para os eventos OnClick dos botões

que foram excluídos. Selecione o primeiro botão da barra de ferramenta, tbuFonte.
Selecione a aba Events do Object Inspector e no evento OnClick selecione o método
btnFonteClick pressionando o botão ao lado direito do nome do evento. Para o botão
tbuFundo selecione o método tbuFundoClick. Execute a aplicação e clique nos dois
botões da barra de ferramentas. Os dois devem chamar a caixa de dialogo de cores.
Iremos repetir o procedimento para os outros três botões da nossa barra de
ferramentas. Assim, para o botão tbuEsquerda vamos selecionar o método
btnEsquerdaClick. Para o botão tbuCentro selecione o método btnCentroClick. E para o
botão tbuDireita selecione o método btnDireitaClick. Vamos excluir os métodos criados
para os botões btnEsquerda, btnCentro e btnDireita. Para isso acesse o código de cada
método no editor e exclua apenas a linha que você digitou. Quando o programa for
compilado, os métodos e todas as referências a eles serão eliminadas. O procedimento
adotado para programar os eventos OnClick dos botões se deveu apenas ao
reaproveitamento do código que já existia para os botões anteriores. Mas se precisarmos
escrever um método novo procedemos da maneira já exposta anteriormente. Um duplo
clique no botão e o editor é aberto na posição onde o código deve ser inserido.
Como os eventos OnClick dos botões foram programados para responder aos
mesmos eventos dos comandos de menu, pressionar o botão tem o mesmo efeito de
selecionar o comando. Só precisamos de uma indicação visual da opção de alinhamento
que está selecionada no momento.Vamos configurar os botões de alinhamento para que
eles operem como botões de rádio.
É necessário formar um grupo com os botões que serão tratados como botões de
rádio. Altere a propriedade Grouped dos três botões de alinhamento para True.
Modifique a propriedade Style dos botões para tbsCheck. Definimos que o alinhamento
à esquerda é o padrão, portanto vamos alterar a propriedade Down de tbuEsquerda para
True. Execute o programa e clique nos botões para ver os efeitos.

77
 Lazarus/Free Pascal para iniciantes

Note que ao pressionarmos um botão de alinhamento do texto ele permanece

pressionado até que selecionemos outro. Mas quando selecionamos o alinhamento do
texto a partir de um comando de menu o comportamento dos botões não se alteram.
Para solucionar esse problema vamos incluir um comando no método que força
o pressionamento do botão. Inclua então a seguinte linha no método Esquerda1Click:

tbuEsquerda.Down := True;

Faça o mesmo nos métodos Centro1Click e Direita1Click para os botões

tbuCentro e tbuDireita.
Para finalizar, vamos modificar o código do método correspondente ao comando
Exibir | Barra de ferramentas. Altere para o seguinte código:

tbBarra.Visible := not tbBarra.Visible;

Barradeferramentas1.Checked := tbBarra.Visible;

Observe que apenas mudamos o nome do painel panBarra para tbBarra, o

componente ToolBar, no código do método.

Barra de status (TStatusBar)

A barra de status é usada para apresentar inúmeras informações ao usuário. Pode
mostrar mensagens, a data e hora atuais, dicas, etc. O Lazarus possui um componente
para essa finalidade. Na paleta de componentes vá até a aba Common Controls,
selecione o componente TStatusBar e o insira na nossa aplicação Menus. Não importa
onde você insere o StatusBar, o Lazarus sempre o posiciona na base da janela. Iremos
modificar algumas propriedades da barra de status de acordo com o quadro abaixo:

Propriedade Conteúdo Descrição

Name stbMenu Identificador da barra de status
Panels Define os painéis que constituem o componente
SimpleText Define um texto que aparecerá na barra de status
Quadro 15 Propriedades de StatusBar

Uma barra de status pode ter vários painéis que agrupam informações
relacionadas. Vamos dividir esta barra em dois painéis. Clique no botão elipse ao lado
direito da propriedade Panels. Isso irá abrir o editor de painéis. Adicione dois painéis
pressionando o botão Add na parte superior do editor ou teclando Insert.
O Lazarus guarda as informações sobre os painéis do StatusBar em um array. O
primeiro painel é chamado stbMenu.Panels[0] e o segundo stbMenu.Panels[1]. Lembre
que o Lazarus sempre considera os índices dos arrays iniciando em 0. Cada painel é um
objeto do tipo TStatusPanel. Portanto possui propriedades. Altere as propriedades de
stbMenu.Panels[0] conforme o quadro:

Propriedade Conteúdo Descrição

Alignment taLeftJustify Define o alinhamento do texto mostrado
Style psText Define como o texto é mostrado no painel
Text Desenvolvido por João da Define o texto que irá aparecer no painel
78
 Lazarus/Free Pascal para iniciantes

Silva
Width 400 Define a largura do painel
Quadro 16 Propriedades de TStatusPanel

Para alterar as propriedades de um painel, abra o editor de painéis dando um

duplo clique na barra de status e depois selecione o painel desejado. O Object
Inspector mostrará as propriedades desse painel.
A propriedade Style permite que as configurações do texto mostrado no painel
sejam definidas pelo programador através de um manipulador de evento, mas vamos
adotar psText para essa propriedade. Isso indica que o alinhamento do texto é dado pela
propriedade Alignment e a fonte é determinada pela propriedade Font de StatusBar.
A propriedade Width define a largura do painel. À medida que aumentamos o
valor da propriedade Width do painel esquerdo, o painel direito tem sua largura
diminuída.
No segundo painel mostraremos a hora corrente. O evento mais indicado para
isso é o OnShow do form. Esse evento acontece quando a janela é mostrada. É
exatamente isso que queremos: apresentar a hora no momento em que a janela for
aberta. Note que os componentes adicionados ao form não permitem que ele seja
selecionado. Vamos então mostrar outra maneira de selecionarmos um componente. No
Object Inspector existe uma árvore hierárquica de componentes no topo da janela,
conforme mostra a Figura 63.

Figura 63 Árvore de componentes

Clique no nome do form, frmMenus. Note que as propriedades que estão sendo
visualizadas são do form. Agora clique na aba Events e dê um duplo clique no evento
OnShow. No editor de código digite:

79
 Lazarus/Free Pascal para iniciantes

stbMenu.Panels[1].Text := TimeToStr(Time);

Este código converte a hora atual para string e a atribui à propriedade Text do
segundo painel da barra de status. Execute o programa. Muito bom, mas você deve ter
observado que a hora é estática. Ou seja, a aplicação mostra a hora do instante que a
janela é aberta, e não se altera dai em diante. Para que a hora seja mostrada a cada
segundo é necessário um novo componente: o Ttimer, localizado na aba System. Esse
componente tem um evento, chamado OnTimer, que acontece a determinados intervalos
de tempo. É isso que queremos: mostrar a hora a cada segundo. Vejamos então as
propriedades e evento de Timer.

Propriedade Conteúdo Descrição

Enabled True Habilita o componente
Interval 1000 Determina o intervalo de tempo (milissegundos)
Name timHora Nome do componente
Evento Descrição
OnTimer Ocorre a cada intervalo definido por Interval
Quadro 17 Propriedades de StatusBar

A linha de código anterior, que foi programada para o evento OnShow do form,
deve ser executada no evento OnTimer. Para não reescrevermos o código selecione o
evento na aba Events, clique no botão da caixa combinada e escolha o método
FormShow. Execute o programa. Você irá observar um relógio digital na barra de status.

Figura 64 Barra de status

80