Sistemas de Informação MIEEC

Introdução à ferramenta Lazarus 3º ano

asousa@fe.up.pt – Versão de 2010 / Maio / 12

Introdução
A ferramenta “Lazarus” é uma ferramenta de programação potente e complexa, que vai
ser utilizada como ambiente de desenvolvimento integrado (IDE) para a linguagem Free
Pascal (FPC). A ferramenta em causa é totalmente “cross platform” e está instalada nas
máquinas do CICA, na FEUP nos Sistemas Operativos S.O. Windows e em Linux. Este
tutorial introdutório abordará apenas o IDE do Lazarus e a introdução à “Programação
Visual”, Programação Orientada a Eventos (POE).
Neste tutorial será apresentado o IDE e as principais ideias chave que permitirão ao
aluno posteriormente continuar a aprendizagem com autonomia superior.
Na leitura inicial deste tutorial, não salte passos nem se afaste demasiado dos passos
mencionados. O aluno pode e deve repetir o guião já depois de ter uma percepção mais
completa do funcionamento de conjunto de todos os elementos envolvidos e nessa fase
dedicar-se a uma exploração mais abrangente.

Não se esqueça de consultar sempre que necessário o capítulo final "Listagem de Teclas
e funcionalidades" , na pág. 50.

Bom Trabalho!

Armando Sousa

Índice
Introdução..............................................................................................1
Tutorial .................................................................................................2
Exercícios de Lazarus................................................................................35
Ligação do Lazarus à Base de Dados PGSQL .....................................................39
Alguns Comandos SQL (micro resumo)............................................................45
FAQ Lazarus Sistemas de informação.............................................................47
Listagem de Teclas e funcionalidades.............................................................50

Introdução ao Lazarus FEUP - DEEC Pág 1

Tutorial

1- Criação do projecto inicial – Form com 1 botão

1.1 - Arranque o seu PC com o sistema operativo que preferir, windows ou
linux e no sistema operativo, arranque o Lazarus
○ Windows -> Departamentos -> DEEC -> Lazarus
○ Linux -> Desenvolvimento -> Lazarus
1.2 - Dentro do Lazarus seleccione, Project -> New Project; aparecerá a
seguinte caixa de diálogo:

1.3 - Seleccione Application e prima Create; acabou de criar um novo

projecto vazio para desenvolver uma nova aplicação gráfica.
1.4 - O ambiente integrado de desenvolvimento (IDE) do lazarus aparecerá;
este IDE é constituído por diversas partes, cada uma em sua janela:
○ Por cima, a barra de menus e de componentes
○ Do lado esquerdo, a listagem da árvore de componentes e das respectivas
propriedades (object inspector)
○ Ao centro o editor de código Source Editor (onde se escreve o código!)
○ Na figura abaixo representa-se à direita a “form” em “design-time”
○ Por baixo aparece a caixa de mensagens (onde vão aparecer erros de
compilação, etc)

Introdução ao Lazarus FEUP - DEEC Pág 2

 ○ As janelas não terão o aspecto mostrado; altere as posições e dimensões
das janelas para reflectir um aspecto similar ao mostrado acima; pode, no
entanto, modificar o aspecto de cada uma das janelas ao seu gosto
1.5 - Insira um botão na form, para isso:
1.5.1 - Clique no componente TButton, dentro do separador Standard:

1.5.2 - Clique na form:

1.6 - O botão que acabou de criar foi automaticamente chamado de

Button1; faça duplo clique em cima dele e será conduzido até ao código a
executar quando se carregar no botão (dentro do source editor):

Introdução ao Lazarus FEUP - DEEC Pág 3

 1.7 - Dentro do begin e antes do end, escreva o código
Button1.Caption:='Olá Mundo';
este código altera o texto associado ao botão para que este passe a ser “Olá
Mundo”; o botão chama-se Button1 e o texto dentro deste botão pertence-lhe
e é acessível através de Button1.Caption; para atribuir uma cadeia de
caracteres (uma string) ao texto dentro deste botão utiliza-se o código
mencionado; a atribuição faz-se com o operador := e a string é identificada
como estando entre 'plicas' (cuidado, 'plicas' não são "aspas" ); pode-se trocar
maiúsculas e minúsculas; o aspecto no IDE será próximo do mostrado de
seguida:

O código que acaba de escrever fica guardado dentro de uma “unit” do FPC
1.8 - Escolha no menu File -> Save All e grave todos os ficheiros numa
directoria criada para o efeito numa qualquer localização no disco local (não
utilize drives em rede pois a criação do executável fica muito lenta). Aceite as
os nomes por omissão (default) em minúsculas.
1.9 - Execute o programa premindo a tecla F9 ou menu Run -> Run e observe
o desenrolar das mensagens na janela de mensagens: primeiro vêm a
mensagem da invocação do compilador do FPC; se não existirem erros, então
virá a mensagem “linking” assinalando o processo de construção do executável
e depois a mensagem de sucesso:

1.10 - O programa que acaba de ser criado é então executado pelo S.O. e
aparece a janela do primeiro programa sob Lazarus:

1.11 - Prima o botão com o rato e observe que o texto associado ao botão se
modificou para:

Introdução ao Lazarus FEUP - DEEC Pág 4

 1.12 - Redimensione e mova a janela do programa para se assegurar que
esta janela do programa se comporta como qualquer outra aplicação do S.O.
1.13 - Feche a aplicação premindo o do canto superior direito da janela
do programa que vem sendo executado

1.14 - Ideias a reter:

○ O Lazarus permite fazer aplicações gráficas para S.O. gráficos e orientados a
eventos
○ Este projecto inclui uma parte gráfica (a “form”) e uma parte de código escrito
FPC (a “unit”)
○ A programação inclui desenhar a form que depois será executada e o código que
será executado quando se carregar no botão durante a execução do programa
○ A execução do programa faz aparecer a janela anteriormente desenhada dentro do
IDE do lazarus; quando se carrega no botão, é chamado código que escrevemos no
programa
○ A janela que é desenhada no IDE do lazarus antes da execução pelo SO denomina-
se de form em tempo de desenho (design-time); esta mesma form aparece em tempo
de execução (em run-time); comparar as figuras 1.5.2 e 1.9
○ A aplicação criada é uma das muitas que está a ser executada pelo S.O.
○ Relativamente ao código FPC, convém reter:
■ Atribuição com o operador “:=”
■ Para aceder a propriedades, utilizar “.”, por exemplo “Button1.Caption”
■ O FPC é insensível a maiúsculas e minúsculas
■ Cadeias de caracteres (strings) dentro de 'plicas'; não mudar de linha dentro de
uma cadeia de caracteres

1.15 - Exercício Livre – Crie e teste uma nova aplicação que execute o
código ShowMessage('Olá Mundo!!!');

Introdução ao Lazarus FEUP - DEEC Pág 5

 2- Criação de projecto com dois botões
2.1 - Regresse ao IDE do Lazarus para alterar o projecto anterior
2.2 - Se a Form1 não estiver visível, escolha View -> Forms -> Form1 -> OK
2.3 - Acrescente um outro botão à nossa janela:

2.4 - Observe o Object Inspector e confirme que a nossa janela, a “form”,

tem o nome Form1; o primeiro botão chama-se Button1 e o segundo Button2;
naturalmente ambos botões estão dentro da Form1.

2.5 - Faça duplo clique no botão 2; o cursor aparecerá no source editor,

dentro do procedimento Button2Click, i.e., o procedimento que será
chamado quando se carregar no botão 2; acrescente o seguinte código:
ShowMessage('Olá Mundo');
A janela do editor deve-se parecer com:

2.6 - Prima File -> Save All

2.7 - Prima F9 para executar o projecto e se não houver erros, este será
executado, aparecendo a form em run-time:

2.8 - Prima o Button1 e confirme a alteração:

Introdução ao Lazarus FEUP - DEEC Pág 6

 2.9 - Prima o Button2 e veja o aparecimento da seguinte caixa:

2.10 - Feche a aplicação com

2.11 - Regresse ao IDE lazarus e prima F12 até ver a form em design time
2.12 - Faça duplo clique no Button1; o cursor aparecerá no source editor,
dentro do procedimento Button1Click; prima F12 para alternar source e
form e depois faça duplo clique no Button2 para o cursor aparecer dentro do
procedimento Button2Click; navegue no source editor até achar o
procedimento Button1Click:

2.13 - Exercício Livre - Adicione um terceiro botão que quando for

carregado mostre uma caixa com a mensagem “Bom dia, FEUP!”

2.14 - Ideias a reter:

○ A “form” do projecto, chamada Form1, passou a ter dois botões, Button1 e Button2
○ A “unit” passou a ter, entre outros elementos de código, os procedimentos
Button1Click e Button2Click
○ Os dois botões são instâncias de objectos do tipo TButton; diz-se que TButton é uma
classe; geralmente, classes e tipos são identificados começando pela letra “T”
○ Cada botão tem o seu respectivo procedimento de resposta ao clique em run-time,
Button1Click e Button2Click que são diferentes e não se confundem
○ É o S.O. que se encarrega de chamar a rotina certa de cada vez que, em run-time, se
carrega em determinado botão, isto é, o S.O. é que gera os eventos e chama rotinas
no programa que se vem criando – daí este tipo de programação se designar
Programação Orientada a Eventos

Introdução ao Lazarus FEUP - DEEC Pág 7

 3- Alterando nomes e propriedades de componentes
3.1 - No Object Inspector seleccione o Button1 e depois o separador
Properties; é neste separador que se pode ver e alterar todas as propriedades
(atributos) do objecto seleccionado actualmente; estas propriedades são
listadas por ordem alfabética; a figura seguinte mostra algumas propriedades
do Button1:

3.2 - Seleccione agora o separador Events; este separador mostra todos os

eventos disponíveis para os botões TButton, isto é, todos os acontecimentos
relacionados com instâncias ; o único campo preenchido é Button1Click;
Confirme o mesmo para os eventos de Button2 – o único evento listado é
Button2Click

3.3 - Seleccione agora o separador Favorites; este separador tem o

“resumo” das propriedades e dos eventos mais visitados e frequentemente
mais utilizados

Introdução ao Lazarus FEUP - DEEC Pág 8

 3.4 - O resumo das propriedades dos botões são apresentadas de seguida:

Mude o nome do Button1 para BChangeCaption e do botão 2 para BShowBox;

mude apenas a propriedade “Name” do Button1 e do Button2; depois das
mudanças o Object Inspector mostrará:

E o código será automaticamente alterado para:

Introdução ao Lazarus FEUP - DEEC Pág 9

 3.5 - Altere agora as Captions dos botões, tal como nas seguintes figuras:

Observe como as mudanças nas propriedades dos botões ficam efectivas

imediatamente e a Form em “Design Time” é imediatamente alterada para
reflectir as mudanças
3.6 - Seleccione a form no Object Inspector para ver as suas propriedades:

Modifique texto associado à Form, isto é, a sua propriedade “Caption” para

“FEUP”; note que a caption da form nada tem que ver com a caption de cada
um dos botões. O Object Inspector reflectirá as mudanças e a Form passará a
ostentar a nova inscrição:

3.7 - Escolha File -> Save All

3.8 - Execute a nova versão do projecto com F9 para verificar as diferenças

Introdução ao Lazarus FEUP - DEEC Pág 10

 3.9 - Ideias a reter:
○ Os nomes dos componentes tal como botões devem ser descritivos
○ Após mudança do nome dos componentes, o código vem alterado automaticamente
○ Todos as instâncias TButton (isto é, todos os botões) devem começar pela letra “B”
- isto permitirá mais tarde que todos os botões sejam facilmente localizaveis
○ Mudanças em propriedades de componentes visuais são visíveis desde logo em
“design-time” - daí esta programação ser Visual
○ Tanto a Form como cada um dos botões tem uma dada “Caption” - este conceito
chama-se polimorfismo; há muitos componentes com propriedades iguais para
funcionalidades similares – repare que Form.Caption e Button.Caption são
conceitos similares para classes diferentes

Introdução ao Lazarus FEUP - DEEC Pág 11

 4- Aplicação com Edit e Check Box
4.1 - Crie um novo projecto de aplicação (Project -> New project ->
Application; para mais detalhes veja 1.2)
4.2 - Arranje as janelas a seu gosto (por exemplo, tal como mostrado em
1.4)
4.3 - Escolha no menu File -> Save All e grave todos os ficheiros numa outra
directoria diferente da anterior; não utilize drives em rede pois a criação do
executável fica muito lenta; utilize os nomes “myunit.pas” e “project2.lpi”
(utilize minúsculas); deste forma todos os ficheiros deste novo projecto ficam
na nova directoria; o Lazarus utiliza e cria diversos ficheiros que são mantidos
sem intervenção humana
4.4 - Acrescente um TEdit à Form:

A classe TEdit fornece a funcionalidade de uma caixa de edição de texto

standard do S.O. (texto genérico de uma linha apenas).
4.5 - Acrescente um TCheckBox à Form:

A classe TCheckBox fornece a funcionalidade de uma caixa de escolha

Verdadeiro/Falso que é uma funcionalidade padrão dos S.O..
4.6 - Altere as propriedades da CheckBox tal como se mostra a seguir:

Caption: “&Alterar” - o “&” define uma tecla de

atalho que pode ser utilizada em Run-Time

Checked: True - Duplo Clique no False muda para

True e vice versa)

Name: CBAllowChange

Note que a Check Box é um controlo standard do S.O. mas a forma exacta da
Check Box e a forma exacta do “visto” ou da “cruz” que aparece para indicar
que esta opção está validada depende de configurações do S.O..

Introdução ao Lazarus FEUP - DEEC Pág 12

 4.7 - Altere as propriedades da Edit1 tal como se mostra a seguir:

Name: EditMyText

Text: “FEUP”

4.8 - Verifique na listagem das propriedades que existe uma propriedade

chamada ReadOnly, que pode apresentar os valores verdadeiro e falso; esta
propriedade permite que em run-time seja possível alterar o texto deste
componente (mantenha ReadOnly igual a False):

4.9 - Altere a Caption da Form para passar a dizer “FEUP”

4.10 - Faça duplo clique em cima da check box para criar e chamar o
procedimento CBAllowChangeChange; este procedimento será chamado
sempre que se clicar sobre a check box; escreva “edit” e prima CTRL+SPACE
para activar a funcionalidade de “Completion”, isto é, completar o código
automaticamente; esta opção abre uma caixa de selecção das possibilidades
de escrita; prima Enter para seleccionar a opção certa (EditMyText) e ver o
texto EditMyText aparecer sem ter de escrever mais do que as primeiras
letras!

4.11 - Utilize esta técnica para ajudar a escrever o texto:

Introdução ao Lazarus FEUP - DEEC Pág 13

 4.12 - Grave todos os ficheiros premindo e de seguida prima para
executar a aplicação; ambos os comandos estão situados na barra de atalhos;
estes atalhos equivalem a File->Save All e Run->Run
4.13 - Há algum problema com esta aplicação ?
4.14 - Altere o código de CBAllowChangeChange para

Repare que CBAllowChange é o nome da CheckBox e CBAllowChangeChange é

o nome do procedimento que é chamado no evento “OnChange” desta check
Box
4.15 - Grave e execute para perceber as alterações e respectivo motivo.
4.16 - Qual a aplicação que o utilizador final do nosso programa acharia mais
intuitivo de utilizar, a aplicação 4.12 ou a 4.14 ?
4.17 - Acrescente um botão com o nome BUpdate e a caption “Actuali&zar”

4.18 - Faça duplo clique no botão e escreva tal como mostrado de seguida:

4.19 - Grave todos os ficheiros premindo e execute com

4.20 - Experimente aceder aos controlos visuais através do teclado,
utilizando teclas de atalho ALT+A e ALT+Z

Introdução ao Lazarus FEUP - DEEC Pág 14

 4.21 - Ideias a Reter:
○ Foi utilizada uma edit box chamada EditMyText; é boa prática todas as edit boxes
terem o prefixo “Edit”
○ Foi utilizado uma CheckBox chamada CBAllowChange; é boa prática todas as
CheckBox's terem o prefixo “CB”
○ Quando o programa arranca, é possível alterar o texto do componente EditMyText
pois a sua propriedade “ReadOnly” foi definida em design time como False e por
esse motivo, ao arrancar o programa esta propriedade continua a False
○ O componente CBAllowChange foi definido em design-time como estando
seleccionado e por isso no arranque esta caixa apresenta-se seleccionada: Checked
a True
○ O texto associado à caixa de escolha refere “Alterar” pelo que será intuitivo que
quando esta caixa estiver seleccionada, será possível alterar o conteúdo da caixa de
edição de texto; em termos de programação só temos acesso às propriedades
“EditMyText.ReadOnly” e CBAllowChange.Checked o que obriga à utilização da
negação booleana: EditMyText.ReadOnly:=not(CBAllowChange.Checked);
○ Se o texto associado à check box dissesse “Impedir alteração”, então já faria
sentido o código EditMyText.ReadOnly:=CBPreventChanges.Checked;!
○ Lembre-se que o utilizador final não é o programador da aplicação e que o
utilizador final apenas lerá o texto que estiver na form que deve conduzir a uma
utilização fácil, intuitiva e com lógica da aplicação que estamos a criar !
○ Note ainda que o nome do procedimento a ser chamado no evento é o nome do
componente concatenado com o nome do evento, por exemplo: o componente
CBAllowChange chama para o evento OnChange o procedimento
CBAllowChangeChange

Introdução ao Lazarus FEUP - DEEC Pág 15

 5- Utilização do evento OnChange da classe TEdit
5.1 - Faça duplo clique em cima da caixa de edição de texto (EditMyText)
para definir o evento “OnChange” abrir o procedimento EditMyTextChange e
modifique-o tal como indicado:

5.2 - Escolha File -> Save All e depois Run->Run para executar o projecto

5.3 - Ideias a reter:

○ O evento TEdit.OnChange é chamado sempre que a caixa de texto for modificada,
por exemplo, a cada tecla premida; o código deste evento muda a form.caption
para o texto da EditMyText e desta forma não é necessário carregar no botão para
fazer a actualização que se tornou “Automática”!
○ Não é executado nenhum código da aplicação fora dos eventos reconhecidos
○ Seria muito errado por um ciclo infinito a verificar se ocorreram mudanças no texto
○ Neste momento há código repetido no nosso programa (Form1.Caption :=
EditMyText.Text); código repetido é sempre mau e deve ser evitado !

Introdução ao Lazarus FEUP - DEEC Pág 16

 6- Utilização de procedimentos e escrita rápida (Code
Templates, Completion e Parameter CheckOut)
6.1 - Procure no código da unidade myunit.pas o procedimento
CBAllowChangeChange; logo acima desse código e fora de qualquer
procedimento (que começam por begin e terminam em end), escreva “proc”

Prima CTRL+J para activar a funcionalidade de “Code Templates”:

Preencha com o restante texto, tal como indicado de seguida:

Este código define um procedimento (uma função que não devolve nada) e que
recebe como parâmetro de entrada uma variável com o nome “StringIn” do
tipo string

6.2 - Faça duplo clique em cima da Edit e será conduzido ao código relativo
ao evento EditMyTextChange; escreva “actu” e prima CTRL+SPACE:

Prima depois disso CTRL+Shift+Space para ver os argumentos que a função ou

o procedimento esperam (ver texto flutuante directamente por cima do
cursor):

Neste caso o procedimento espera um parâmetro com o nome “StringIn” do

tipo “String” (cadeia de caracteres)

Introdução ao Lazarus FEUP - DEEC Pág 17

 6.3 - Complete tal como mostrado (deve ir utilizando a funcionalidade de
completação automática de código – CTRL + SPACE):

6.4 - Navegue no código até encontrar o procedimento BUpdateClick e

altere de acordo com o seguinte:

6.5 - Neste momento os procedimento EditMyTextChange e BUpdateClick

chamam um outro procedimento chamado “Actualiza” que centraliza o
processo de actualização
6.6 - Grave e execute para verificar que o conjunto funciona.

6.7 - Exercício Livre: Adicione mais outra Check Box com nome e caption
adequados; altere a aplicação para implementar a funcionalidade de a
actualização ser automática apenas quando a caixa de selecção estiver activa;
quando inactiva é necessário premir o botão para actualizar a form
6.8 - Exercício Livre: Modifique a aplicação de tal forma que a caption da
form seja o texto da edit repetido com um espaço de permeio; para ter
trabalho mínimo, onde deve inserir as modificações ???

6.9 - Ideias a reter:

○ O evento OnChange do componente TEdit chama o procedimento chamado
Actualiza que muda a Form.Caption
○ Foi criado um procedimento para evitar repetição de código e o exercício 6.8
beneficia desse facto
○ A escrita de código FPC/Lazarus vêm facilitada através de diversas técnicas
● Code Templates – atalho CTRL + J
● Code Completion – atalho CTRL + SPACE
● Parameter CheckOut – atalho CTRL + SHIFT + SPACE

Introdução ao Lazarus FEUP - DEEC Pág 18

 7- Navegação no código e form/código
7.1 - Prima CTRL+Home por exemplo para relembrar que o nome da unidade
é myunit

7.2 - Prima CTRL+H para regressar ao ponto de edição anterior

7.3 - Mantenha CTRL premido e clique com o rato em cima do texto
“TForm1”, que aparece sublinhado:

7.4 - Com este clique, o cursor será levado até à parte superior da unidade
myunit, onde se define o tipo da Form1 chamado TForm1; é aqui que se lista
os componentes que estão dentro da form:

Este código refere que a Form1 inclui um TButton com nome CBAllowChange
7.5 - Depois do “end” que indica o final da declaração do tipo TForm,
aparece a instanciação da form propriamente dita com “Var Form1 : TForm1”
indicando que Form1 é da classe TForm1.
7.6 - Navegue com o cursor até à linha onde se declara um qualquer dos
procedimentos da form e prima CTRL + Shift + seta_para_baixo para ser
levado até à implementação desse procedimento ou função; prima CTRL +
Shift + seta_para_cima ou CTRL + H para ir de novo para a declaração;
exercite para perceber

Introdução ao Lazarus FEUP - DEEC Pág 19

 7.7 - Encontre o Código seguinte, mantenha CTRL premido e clique em
StringIn para ser conduzido à declaração respectiva;

7.8 - Experimente o mesmo com EditMyText, que está dentro da Form

7.9 - Prima F12 para ser levado até à Form

7.10 - Apague o botão
7.11 - Prima F12 de novo para ver que na declaração da form deixou de
constar o botão

O código do botão BUpdateClick mantém-se mas não será nunca chamado.

Introdução ao Lazarus FEUP - DEEC Pág 20

 7.12 - Ideias a reter:
○ As alterações feitas na Form mudam o código da respectiva unit
○ Existe a possibilidade de ter código que nunca é chamado
○ Quem decide que código é executado e por que ordem é o S.O. que chama a rotina
dentro da aplicação de acordo os eventos gerados, por incluindo as ordens do
utilizador
○ A uma Form corresponde um tipo de form (Tform)
○ Uma Form está numa unidade de código (“unit”); a unidade e a form podem ter nomes
quaisquer desde que sejam diferentes !!!
○ Geralmente uma unit só tem uma form
○ Uma unit pode ter uma form ou não (unit pode ser visual ou não)
○ Obs: Nem todas as informações da Form são mantidas dentro da unidade – existem
outras informações, guardadas noutros ficheiros
○ Por segurança e facilidade de utilização, criar uma directoria nova para cada projecto
Lazarus e guardar todos os ficheiros desse projecto nessa mesma directoria
○ Nunca alterar código que não foi feito por nós!
○ Navegação:
● F12 troca entre form e código
● F11 activa o object inspector
● CTRL + Clique leva à declaração de alguma coisa
● CTRL + SHIFT + cima e CTRL + SHIFT + baixo trocam entre declaração e
implementação de procedimentos e funções

Introdução ao Lazarus FEUP - DEEC Pág 21

 8- Aplicação com RadioGroup e Memo
8.1 - Crie um novo projecto de aplicação: Project->New Project-
>Application ->Create
8.2 - Desenhe a seguinte Form que contém um TRadioGroup e um TMemo,
ambos situados no separador Standard:

8.3 - Encontre a propriedade Lines do Memo, entre dentro desta qudrícula e

depois aparecerá um botão com “...”; prima este botão (mostrado de seguida)
no Object Inspector e altere as linhas da Memo para FEUP e na linha seguinte
DEEC.

Tal como pode ver, uma memo box é uma caixa de texto que permite
múltiplas linhas. A propriedade “Lines” é do tipo TStrings que permite conter
um texto com diversas linhas.

Introdução ao Lazarus FEUP - DEEC Pág 22

 8.4 - Encontre a propriedade Items do Radio Group, prima “...” e insira
“Primeiro” e “Segundo”; depois disso modifique Item Index para 0 – note que o
Item “Primeiro” passou a estar escolhido; deve ter reparado que este é mais
um componente padrão do S.O.

8.5 - Faça duplo clique no Radio Group, acrescente tal como mostrado de
seguida e depois prima CTRL+Shift+Space para ver as listas parâmetros que
esta função aceita:

Para a função IntToStr, os argumentos podem ser de diversos tipos (mas

sempre inteiros)
8.6 - Complete como de seguida:

8.7 - Grave e execute para testar as funcionalidades: quando se muda a

selecção no radio group, é acrescentada uma linha de texto que descreve o
que está seleccionado.

Introdução ao Lazarus FEUP - DEEC Pág 23

 8.8 - Acrescente ainda um Botão com caption “Descreve” e com nome
“BDescribe”

8.9 - Faça com que o evento OnClick do Radio Group e o OnClick do botão
chamem a função DescribeRadioGroup que se mostra de seguida; note que
como a função é externa à Form1, é necessário acrescentar a noção de que
todos os controlos visuais que temos vindo a manipular estão dentro da Form1
e por isso é necessário indicar Form1.Memo1.Lines.Append:

8.10 - Grave e execute para testar todas as funcionalidades

Introdução ao Lazarus FEUP - DEEC Pág 24

 8.11 - Exercício livre: Modifique a form para que passe a ter a configuração
indicada de seguida; utilize o novo botão para acrescentar um item em run
time ao RadioGroup (utilize a função RadioGroup.Items.Append para
acrescentar items em run-time)

8.12 - Ideias a reter:

○ O controlo visual RadioGroup escolhe no máximo uma de diversas opções
○ Cada opção do RadioGroup pertence a um TStrings chamado Items
○ O Item escolhido actualmente é indicado pela propiedade ItemIndex (-1 significa
nada escolhido, 0 é o primeiro item, etc)
○ É perfeitamente possível ter items iguais uma vez que os items são numerados
○ Os items podem ser indicados em design time, no object inspector mas também
podem ser acrescentados em run-time
○ Para acrescentar items ao RG, utilizar RadioGroupName.Items.Append(...)
○ As caixas de texto (TMemo) permitem ter diversas linhas de texto; o texto dentro da
caixa de texto ,isto é, as suas linhas, são também TStrings com o nome “Lines”
○ Para acrescentar linhas ao Memo, utilizar MemoName.Lines.Append(...)
○ A função Append chamada em ambos os casos pertence à classe TStrings que está
tanto no RG.Items como no Tmemo.Lines
○ Quando utiliza uma função fora da form, para aceder aos controlos visuais da form,
é necessário escrever explicitamente “Form1.ControloVisual”

Introdução ao Lazarus FEUP - DEEC Pág 25

 9- Temporizador
9.1 - Crie uma nova aplicação
9.2 - Insira uma caixa de edição de texto TEdit e um botão TButton.
9.3 - Faça com que o texto inicial no arranque da aplicação seja “0” (zero)
9.4 - Faça com que a cada pressão do botão seja executado o seguinte
código:
Edit1.Text:= Edit1.Text+'!';

9.5 - Grave o projecto numa directoria adequada e execute

9.6 - Confirme que a cada pressão do botão um ponto de exclação é
acrestado
9.7 - Modifique agora o evento OnClick do botão para:
Edit1.Text:=IntToStr(StrToIntDef(Edit1.Text,0)+1);
Este código converte o texto do Edit1 para um número inteiro, soma 1 e põe o
resultado de volta no mesmo texto, sob a forma de string.
9.8 - Grave e execute para confirmar que a cada pressão do botão, o
número na edit box é incrementado
9.9 - De seguida acrescente um temporizador TTimer (separador System) à
form:

9.10 - Faça duplo clique em cima do timer que acabou de colocar na form
para ser levado ao evento 'OnTimer' e preencha dentro do procedimento
Timer1Timer o seguinte código com a chamada:
Button1Click(Sender);
Este código será chamado periódicamente pelo timer e chama a rotina de
pressão do botão.
9.11 - Grave e execute - note que a numeração é incrementada todos os
segundos automaticamente e ainda sempre que se premir o botão; note que o
timer desaparece em run-time (mas as funcionalidades estão lá!)
9.12 - Altere agora a propriedade Timer1.interval para 2000
9.13 - Execute para ver que o número é incrementado a cada 2 segundos.

Introdução ao Lazarus FEUP - DEEC Pág 26

 9.14 - Exercício Livre: Adicione uma check box “CBEnable” que quando
seleccionada permite o funcionamento do incremento automático; a check box
deve aparecer inicialmente seleccionada;
Dica: Utilize Timer1.Enabled:=...

9.15 - Ideias a reter:

○ Quando não há eventos, não há código da aplicação a ser executado
○ Os temporizadores normais do Lazarus / Windows são pouco precisos e aconselha-
se tempos sempre superiores a 0.1 segundos

10 - Menu da aplicação
10.1 - Acrescente à aplicação anterior um TMainMenu do separador standard
10.2 - Faça duplo clique em cima dele para abrir o editor de menus:

10.3 - Clique em cima de “New Item1” e altere caption para “&File”

10.4 - Em cima de File, clique com rato botão da direita e escolha create
sub menu:

10.5 - Clique em New Item2 e mude este caption para “E&xit!” e o nome
deste menu para “MenuFileExit”

Introdução ao Lazarus FEUP - DEEC Pág 27

 10.6 - Clique em File com o rato botão esquerda e escolha “Insert New Item
(After)”

10.7 - Clique no último item de menu e altere-lhe o caption para “Help”

10.8 - Acrescente um sub menu “Help” e ao novo item altere o caption para
“&About” e altere-lhe o nome para “MenuHelpAbout”

10.9 - Feche o editor de menus e ainda em tempo de desenho verifique a

sua funcionalidade, devemos ter um menu File com a opção Exit! e outro
menu Help com a opção About

10.10 - Seleccione File -> Exit e complete;

10.11 - Ainda em tempo de desenho, selecione Help About e complete:

10.12 - Grave e execute para testar as funcionalidades

Introdução ao Lazarus FEUP - DEEC Pág 28

 10.13 - Abra o editor de menus e acrescente um item ao menu File com a
caption “-” e outro com a caption “Exi&t...” e nome “MenuExitQuery”.

10.14 - Feche o editor e seleccione File->Exit... e complete como se mostra

de seguida:

10.15 - Nota: é boa prática o menus com acção imediata terem um “!” e os
que abrem caixas de confirmação ou diálogo terem “...”
10.16 - Execute e teste as funcionalidades da aplicação

10.17 - Ideias a reter:

○ Os menus são uma funcionalidade padrão do S.O.
○ Os menus devem ter nomes curtos, descritivos e que não dêem azo a confusões –
lembre-se que o utilizador não é o programador
○ É interessante agrupar as acções a executar por temas e assim ter menus e
submenus (e sub-sub-menus...) de acordo com determinada lógica
○ Boas práticas:
■ Definir teclas de atalho para os menus utilizados mais frequentemente
■ Um “Comando!” dá ideia que o comando será executado imediatamente sem
mais confirmações
■ Um “Comando...” dá ideia que será aparecerá um diálogo adicional

Introdução ao Lazarus FEUP - DEEC Pág 29

 11 - Eventos com parâmetros
11.1 - Crie uma nova aplicação apenas com uma TLabel
11.2 - Na lista de eventos da Form, defina o evento OnKeyPress e complete
o respectivo procedimento tal como se mostra de seguida:

Os eventos recebem sempre a identificação do controlo que gerou esse evento

através do parâmetro de entrada “Sender” no procedimento de atendimento
ao referido evento. O procedimento FormKeyPress atende os eventos
OnKeyPress da Form1 e recebe não só o “sender”, como também recebe a
tecla premida através do parâmetro de entrada “key”; a variável x é do tipo
inteiro e é local a este procedimento (o seu valor não será mantido entre
chamadas ao procedimento)
11.3 - Grave e execute premindo as teclas “+” e “-” para ver o número
alterar-se

11.4 - Ideias a reter:

○ Os procedimentos de atendimento aos eventos recebem parâmetros
○ Um parâmetro é o “Sender”, isto é, qual o objecto que gerou a chamada ao
procedimento actual
○ Outros eventos recebem informações específicas do evento em causa, exemplo:
OnKeyPress recebe qual a tecla premida

Introdução ao Lazarus FEUP - DEEC Pág 30

 12 - Confirmar saída da aplicação - Close Query – parâmetros de
saída no evento
12.1 - Crie uma nova aplicação
12.2 - Nos eventos da form, defina OnCloseQuery

A função MessageDlg mostra uma caixa de diálogo standard do sistema

operativo e pede confirmação de saída com os botões standar OK e Cancel.
No procedimento FormCloseQuery entram os parâmetros sender e “CanClose”
que é um parâmetros do tipo “var”. O valor desta variável à saída do
procedimento será utilizado pelo sistema operativo para validar realmente o
pedido de saída do programa (por defeito, CanClose := True que dirá ao S.O.
para fechar de facto a aplicação).
12.3 - Através deste evento, seja qual for a maneira para pedir a finalização
da aplicação, é sempre lançada a caixa de diálogo; muitos programas lançam
esta caixa de diálogo apenas existirem alterações por gravar.

Introdução ao Lazarus FEUP - DEEC Pág 31

 13 - Debugger
■ De seguida utilizar-se-á o debugger do IDE do lazarus; o debugger sob windows
pode funcionar mal e pode, por vezes, obrigar a re-arrancar o lazarus (esta
situação é muito, muito menos frequente em linux) ou pode ser necessário e
Run->Reset Debugger
■ Para terminar a sessão de debugging, utilizar Run->Stop

13.1 - Crie uma nova aplicação com um botão e complete:

13.2 - Prima com o rato no sítio do “ ” vermelho para definir um break

point de debugger
13.3 - Grave a aplicação e execute com F9; verifique que o break point
aparece confirmado:

Introdução ao Lazarus FEUP - DEEC Pág 32

 13.4 - Prima o botão da aplicação – será atendido o evento, o procedimento
de atendimento ao evento será chamado e o procedimento Button1Click será
executado desde o início e prosseguirá; a execução será interrompida no sítio
do break point:

13.5 - Durante este tempo de debugging, é possível ver o valor das variáveis
passando o cursor do rato por cima dos respectivos nomes das variáveis
13.6 - Prima F7 repetidamente para ver o programa a ser executado passo a
passo e pode inspeccionar as variáveis em causa
13.7 - Retire o break point e prima F9 para executar o resto to programa
normalmente
13.8 - Durante o debugging, não é possível ver a form da aplicação
13.9 - A tecla F7 faz step into e salta para dentro dos procedimentos que
forem sendo chamados
13.10 - A tecla F8 faz step over e entra e sai do procedimento passando para
a linha seguinte do procedimento actual
13.11 - A tecla F9 executa o resto do programa normalmente
13.12 - Consulte o Menu View->Debug Windows->

○ Watches permite acompanhar as variáveis que se definir

○ Local Variables permite ver o valor de todas as variáveis locais desta
função

Introdução ao Lazarus FEUP - DEEC Pág 33

 14 - Comentários Finais
Este conjunto tutorial serve para dar bases para que os alunos possam explorar
por si as funcionalidade do lazarus.
O lazarus é uma ferramenta genérica e imensa de tamanho...
Fica o desafio de experimentar esta ferramenta em linux
■ O lazarus é mais rápido a compilar as aplicações
■ O debugger funciona melhor
■ É possível portar projectos entre windows e linux
■ O sistema operativo Linux é livre e todos os drivers são livres
■ O sistema operativo Linux não tem virus!

- fim do tutorial -

Introdução ao Lazarus FEUP - DEEC Pág 34

Exercícios de Lazarus

1 - “Olá Mundo” num botão que se move

○ Crie uma aplicação com um botão numa form
○ Crie um programa que quando premir o botão altere a caption do botão para “Olá
Mundo!!!”
○ Modifique o programa anterior de tal maneira que o botão se mova pela form: de
cada vez que se carregue no botão, ele deve mover-se 20 pixeis para a direita e
para baixo; antes de qualquer parte do botão sair da form, ele deve ser
recolocado obrigatoriamente no centro da form; garanta que o programa funciona
quando a form tem qualquer tamanho
○ Dicas:
- A generalidade dos controlos têm propriedades top, left, width e height
- Utilize o operador div para divisão inteira
- As posições e dimensões são sempre em pixeis
- Os eixos do Lazarus têm origem no canto superior esquerdo

2 - Edit, Botão e Memo

○ Crie uma aplicação que de cada vez que carrega num botão, acrescenta numa
nova linha da Memo box o texto escrito na Edit box
○ Seleccione a opção relativa ao aparecimento automático de Scroll Bars na memo
○ Dica:
- Utilize Memo.Lines.Append

3 - Cálculo da operação escolhida por Radio Group (resultado em Edit

Box)
○ Crie uma aplicação com 3 edit boxes, um radio group e um botão
○ Duas das caixas de texto (Edit Boxes) serão operandos para uma operação a
escolher pelo Radio Group a terceira caixa de texto será para o resultado
○ O Radio Group pode escolher entre as seguintes operações: soma, subtracção e
multiplicação
○ O Cálculo será efectuado quando se premir o botão
○ Dicas:
- Utilize StrToInt, e IntToStr
- Utilize RadioGroup.ItemIndex

Introdução ao Lazarus FEUP - DEEC Pág 35

4 - Cálculo da operação escolhida por Radio Group – descritivo em
Memo box
○ Coloque 2 Edits, um Botão, um RadioGroup e um Memo e complete de forma a
obter um programa que quando carregar no botão seja calculada a operação
seleccionada no RadioGroup e o descritivo (Operando1) (operação) (Operando2) =
(resultado) apareça na Memo
○ Dicas:
- Utilize StrToInt, StrToIntDef e IntToStr
- Utilize RadioGroup.ItemIndex
- Utilize MemoResults.add
- Utilize soma de strings para concatenação

○ Altere o programa para que o resultado seja calculado sempre que houver
alterações em qualquer dos edits
○ Dicas:
- Utilize o evento Edit.OnChange
- Verifique que o programa pode gerar erros e mesmo assim continua a
funcionar depois da situação de erro ter sido corrigida
○ Altere o programa para que a conta seja calculada de 5 em 5 segundos
○ Dica: Utilize um TTimer (separador System)

Introdução ao Lazarus FEUP - DEEC Pág 36

5 - Desenho Básico (canvas)
○ Coloque um Timer que chama o seguinte código todos os segundos

with Form1 do begin

Canvas.Ellipse( -2+Width div 2, -2+Height div 2,
2+Width div 2, 2+Height div 2);
Canvas.Line ( Width div 2, Height div 2,
9+Width div 2, Height div 2);
end;

Estude este código para o compreender.

Execute e redimensione a Form para ver o efeito;

○ Altere o programa para haver uma variável global “rotacao” que define o ângulo
de rotação do marcador; acrescente um botão que acrescenta PI/10 radianos
Dicas:
- As variáveis globais são definidas fora de qualquer função (na zona de
interface ou implementação) e são conhecidas daí para diante no código
- Tenha em atenção o sentido de rotação que se pretende obter e os eixos do
lazarus
- Utilize as funções sin e cos que recebem argumentos em radianos
- O lazarus conhece a constante PI
- Terá de utilizar round ou trunc para converter de real para inteiro

○ Comande a rotação com o teclado: por exemplo '+' e '-' fazem rodar o marcador
numa e noutra direcção
Dicas:
- Ponha a verdadeiro a propriedade Form.KeyPreview
- Utilize o evento Form.OnKeyPress

Introdução ao Lazarus FEUP - DEEC Pág 37

6 - Aplicação multi-janela
○ Crie uma aplicação com 3 botões numa form; carregando no primeiro abre uma
segunda form; carregando no segundo botão fecha a segunda form; carregando no
terceiro botão, abre a form no modo “modal”
○ Dicas:
- Utilizar File -> New Form
- Ver Project -> Project Options -> forms
- Utilizar Form.Show, hide, ShowModal

7 - Cálculo de somatório
fim
2
○ Projecte uma aplicação que calcula soma1= ∑ i  em que ini e fim são
i=ini
valores inteiros provenientes de caixas de texto
○ Modifique a aplicação anterior para calcular ou a soma 1 ou a soma 2 (utilize um
fim
radio group) soma2= ∑  −i3 
i=ini

○ Modifique a aplicação anterior para calcular ou a soma 1 ou a soma 2 ou ambas

(ou nenhuma) - utilize um TCheckBoxGroup
○ Impeça que todas as check boxes possam ficar não seleccionadas

8 - TXMLPropStorage e session properties

○ Acrescente à aplicação do exercício anterior um TXMLPropStorage; indique o
nome do ficheiro config.xml
○ Aceda ao editor de Form.SessionProperties e seleccione os valores a guardar em
disco, à saída do programa e que serão repostos à entrada do programa
○ Guarde o número mínimo de propriedades para que se possa sair da aplicação e
voltar a entrar sem perder os valores e as selecções anteriores

- fim exercícios -

Introdução ao Lazarus FEUP - DEEC Pág 38

Ligação do Lazarus à Base de Dados PGSQL
● É fácil aceder a Bases de Dados sob Lazarus. Para aceder a BDs criadas com

PostGreSQL, utilizar o componente PQConnection que regista todos os dados

relativos ao servidor de BD, ao utilizador e respectivas passwords.
● Para aceder aos dados da BD é necessário haver uma protecção contra ordens
contraditórias simultâneas de diferentes utilizadores e para esse efeito utiliza-se

um objecto chamado SQLTransaction

● Para fazer perguntas (queries) sob a base de dados é necessário o componente

SQLQuery

● Um componente DBGrid é uma grelha automática com a forma de uma

tabela, tabela essa que pode ser uma tabela temporária proveniente de uma
pesquisa SQL; para utilizar este componente é ainda necessário uma forma de

redireccionar dados, o que é conseguido através do componente Data Source

Diferentes utilizações
○ Há 3 formas de aceder a bases de dados sob Lazarus
■ Utilizando um componente DBGrid – visualizações simples
■ Utilizando PQConnection.ExecuteDirect – modificar dados
■ Utilizando SQLQuery.Fields – recolha de dados pesquisados (resposta a
pergunta SQL)

Preparação
○ Abra o gnomo/phppgadmin no browser, altere a sua password para uma password
pouco importante
● Crie uma tabela de teste com dados
● Experimente uma pergunta (query) de teste na janela de SQL do gnomo
(exemplo: select * from anytable)

Introdução ao Lazarus FEUP - DEEC Pág 39

Acesso utilizando o componente DBGrid
○ Este é o teste mais visual, que apresenta dados da ligação à BD tanto em tempo
de desenho como durante a execução da aplicação; a sua utilização limita-se a
mostrar dados de forma simples e automática, sem flexibilidade.

○ Atenção: diversas configurações podem evitar o modo de funcionamento aqui

descrito mas o procedimento aqui apresentado foi testado com sucesso nas
salas de aula do CICA

○ Construa a aplicação com aspecto similar ao seguinte. A sequência de operações é

indicada logo de seguida:

Componente Separador Ícone

PQConnection SQLdb

SQLQuery SQLdb

SQLTransaction SQLdb

DataSource DataAccess

DBGrid DataControls

Introdução ao Lazarus FEUP - DEEC Pág 40

 DatabaseName
HostName
UserName
Password SQL

Servidor de BD
(ex.: Gnomo.fe.up.pt)

○ No PQConnection preencher com os respectivos valores :

- Transaction - SQLTransaction
- Database – nome da BD a utilizar, exemplo sinf0812
- HostName – nome do servidor de BD a utilizar, ex: gnomo.fe.up.pt
- UserName – nome do utilizador na BD, exemplo sinf0812
- Password – password no servidor de BD
○ (Confirmar que SQLTransaction aponta para PQConnection)

○ No SQLQuery preencher:
- Transacção - SQLTransaction
- Database - PQConnection
- SQL – preencher com código SQL, exemplo: select * from anytable
- (não preencher o campo DataSource)

○ No DataSource preencher DataSet como SQLQuery

○ No DBGrid preencher DataSource
○ Activar todos os elementos e mesmo em tempo de desenho será possível ver o
resultado da query feita na SQLQuery a aparecer na DBGrid

Introdução ao Lazarus FEUP - DEEC Pág 41

Execução directa de código SQL (ExecuteDirect)
DatabaseName
HostName
UserName
Password

Servidor de BD PQConnection. ExecuteDirect

(ex.: Gnomo.fe.up.pt) ex.: update tabela set column=1

○ Para alterar a BD, utilize código similar ao seguinte:

...
begin
enter:=chr(13)+chr(10);
s:='update copias set nalugueres=nalugueres+1 where'+
'codcopia='+IntToStr(EstaCopia); // string de código SQL
try
PQConnection.Connected:=True;
PQConnection.ExecuteDirect('Begin Work;');
PQConnection.ExecuteDirect(s);
PQConnection.ExecuteDirect('Commit Work;');
PQConnection.Connected:=False;
except
on E : EDatabaseError do
MemoLog.Append('ERROBD:'+enter+
E.ClassName+enter+E.Message);
on E : Exception do
MemoLog.Append('ERRO:'+enter+
E.ClassName+enter+E.Message);
end;
end;

Introdução ao Lazarus FEUP - DEEC Pág 42

Utilizar Perguntas SQL (Fields)
DatabaseName
HostName
UserName
Password SQL

Servidor de BD
SQLQuery. Fields
(ex.: Gnomo.fe.up.pt)

○ Para obter os campos e as linhas de resultado de uma pergunta SQL, utilize código
similar ao que se segue:

procedure TForm1.OpenQueryPrintAllFieldsClose;
var
ln, col : integer;
s : string;
begin
SQLQuery.SQL.Text := 'select * from anytable';
PQConnection.Open;
SQLQuery.Open;
for ln := 1 to SQLQuery.RecordCount do begin
SQLQuery.RecNo := ln;
s:='';
for col:=0 to SQLQuery.FieldCount-1 do begin
s:=s+SQLQuery.Fields[col].AsString+'; ';
end;
MemoLog.Append(s);
end;
SQLQuery.Close;
PQConnection.Close;
end;

○ A resposta à pergunta SQL tem as linhas desde 1 até SQLQuery.RecordCount

e as colunas desde 0 até SQLQuery.FieldCount-1
○ A Linha actual pode ser obtida e imposta através de SQLQuery.RecNo
○ Cada coluna pode ser de um tipo diferente de dados, por exemplo a primeira
coluna pode ser um inteiro e a segunda uma string pelo que é necessário indicar o
tipo de dados em causa: SQLQuery.Fields[0].AsInteger e
SQLQuery.Fields[1].AsString

Introdução ao Lazarus FEUP - DEEC Pág 43

Dicas
● Consulte o ficheiro das perguntas frequentes (nos conteúdos da cadeira)
● Por vezes o debugguer pode dar problemas (especialmente sob windows), pelo
que pode ser interessante correr o executável via Sistema Operativo
● Pode ser necessário dar permissões de acesso à rede na firewall tanto ao lazarus
como à aplicação que se cria em tempo de compilação

Exercício Livre

● Este exercício livre compara uma aplicação baseada em Base de Dados com uma
outra que utiliza um ficheiro que é lido para memória
● Considere a empresa QuerLista, S.A. que deseja ver implementada uma lista
telefónica.
● Uma empresa chamada SóLazarus vai desenvolver uma aplicação que utiliza de
uma list-box de Lazarus para armazenar os dados que serão gravados em disco
através do componente TXMLPropStorage; adicionar ListBox.Items nas Session
Properties da Form; se o entender como útil, utilize o caracter especial # para
separar o nome do número de telefone guardando a informação na mesma linha
de uma única ListBox
● Uma outra empresa chamada LazGres vai desenvolver uma aplicação rival fazendo
uso de PostGreSQL e Lazarus
● Ambas as empresas vão utilizar uma listagem com apenas duas colunas: nome e
número de telefone: lista_telef(nome, número_telefone)
● Para cada uma das aplicações rivais, crie uma aplicação gráfica que permita
○ Inserir uma entrada nova
○ Apagar uma determinada entrada
○ Listar toda a lista telefónica
○ Pesquisar através de nome e número_telefone
○ Deve ser possível fazer perguntas de fragmentos de dados, exemplo listar
todos os nomes “Sousa” registados na base de dados
● Comece por projectar a interface gráfica que deve, na medida do possível ser o
mais comum possível a ambas as aplicações
● Compare ambas as aplicações e caracterize a possibilidade de crescimento de
cada uma das bases de dados incluindo para o caso de múltiplos acessos em
simultâneo em diversos computadores diferentes

Introdução ao Lazarus FEUP - DEEC Pág 44

Alguns Comandos SQL (micro resumo)

Manipulação de Tabelas
● CREATE TABLE "table_name"
("column_1" "data_type_for_column_1",
"column_2" "data_type_for_column_2",
... )
■ tipos → varchar e int
■ obs: utilizar nomes de colunas em minúsculas
● DROP TABLE table_name

Manipulação de dados
● INSERT INTO Persons
VALUES('Hussein', 'Saddam', 'White House')
● INSERT INTO table_name
VALUES (value_1, value_2,....)
● INSERT INTO table_name (column1, column2,...)
VALUES (value_1, value_2,....)
● UPDATE table_name
SET column_name_1 = new_value_1, column_name_2 = new_value_2
WHERE column_name = some_value
● DELETE FROM table_name
WHERE column_name = some_value

Introdução ao Lazarus FEUP - DEEC Pág 45

Perguntas de dados (Queries)
● SELECT column_name(s)
FROM table_name
WHERE column operator value
AND column operator value
OR column operator value
AND (... OR ...)
...
■ Operator → =, <>, >, <, >=, <=, between, like, like %wildcard%wildcard%
● SELECT column_name(s)
FROM table_name
WHERE column_name IN (value1, value2, ...)
● SELECT column_name(s)
FROM table_name
ORDER BY row_1, row_2 DESC, row_3 ASC, ...
● SELECT column_1, ..., SUM(group_column_name)
FROM table_name
GROUP BY group_column_name
■ Aggregate: avg, count, max, min, sum
● SELECT column_1, ..., SUM(group_column_name)
FROM table_name
GROUP BY group_column_name
HAVING SUM(group_column_name) condition value

- Fim do tutorial de Lazarus a ligar a PostgreSQL -

Introdução ao Lazarus FEUP - DEEC Pág 46

FAQ Lazarus

1. Porquê Lazarus ?
O Lazarus é um programa em rápida evolução, leve e que funciona em diversos sistemas
operativos.
É mais rápido sob linux que sob windows.
Deriva do Pascal que tem mais verificações em run-time que o C e por isso
frequentemente o próprio Pascal assinala erros que doutra forma teriam causado maus
funcionamentos difíceis de explicar.
E é livre, utiliza a licença LGPL, ver http://www.freepascal.org/faq.html
O Lazarus é uma aplicação normal de FreePascal (FPC) que é uma implementação aberta
de uma linguagem próxima do Object Pascal proposto pelo Borland Delphi.

2. Lazarus & POE

O Lazarus é um IDE e um RAD e permite fazer programação de diversos tipos incluindo
Programação Orientada a Eventos (POE)

3. Lazarus, debugger, instabilidades e erros esquisitos

O debugger dentro do Lazarus está em fase de desenvolvimento e por vezes surgem
problemas de estabilidade, principalmente sobre Windows.
Para contornar estes problemas:
• Utilizar sempre a última versão do Lazarus
• Testar o programa fora do IDE, executando-o através do S.O.
• Desligar o debugger do Lazarus
• Sob Linux e pretendendo obter informação adicional relativamente a algum
tipo de erros com falta de informação de debug (exemplo: erros do FPC):
• Executar o Lazarus dentro de uma shell de texto
• Executar a aplicação criada dentro de uma shell

Introdução ao Lazarus FEUP - DEEC Pág 47

4. Lazarus, PostGreSQL e erros relativos a libpq.xxx
• Windows:
Para o Lazarus se ligar ao servidor de PGSQL é necessário que:
o Na máquina do lazarus esteja instalado o PGSQL (cliente ou servidor)
o As DLLs do PGSQL\bin estejam no path do S.O.
§ Para alterar o path, ir ao control panel, system, advanced,
environment variables; seleccionar a variável path (que existe
sempre) e acrescentar no final um ponto e vírgula e de seguida o
path onde se encontram as DLLs referidas
• Linux:
o Criar um soft link do liqpq.so para apontar para o ficheiro liqpq.so.*
com a extensão mais avançada
o Acrescentar o path do liqpq.so.* na secção libraries do ficheiro de
configuração do FPC que geralmente é o /etc/fpc.cfg ; por exemplo:
-Fl/usr/local/pgsql/lib

5. Erro “Circular Unit Reference”

• Mover as unidades não necessárias na área de interface para a área de implementação,
isto é, tirar do “uses” da interface as unidades referentes às forms do utilizador e criar /
acrescentar a um “uses” depois da implementação as nossas unidades

6. Strings Dinâmicas (' plicas dentro de ''plicas'' ')

• Em lazarus as cadeias de caracteres são delimitadas por 'plicas'
• É perfeitamente possível pôr "aspas" dentro de ' “plicas” '
• Um par de plicas dentro de uma string Lazarus equivale a uma string com uma plica
• Exemplos:
o Executando o código: s: = ' 1 2 3 '' 4 5 6 '' 7 8 9 '' ';
s ficará com a string: 1 2 3 ' 4 5 6 ' 7 8 9'
o Considere a seguinte query de SQL:
SELECT nome FROM paciente LIKE 'T%'
O código necessário para produzir esta query é:
s := 'SELECT nome FROM paciente LIKE 'T%''';
Para utilizar informação de uma edit box:
s := 'SELECT nome FROM paciente LIKE '''+ EditBox.text+'''';
a edit box teria por exemplo T%
notar ainda que o espaço depois do LIKE é essencial

Introdução ao Lazarus FEUP - DEEC Pág 48

7. Pesquisas que não funcionam e Esquemas e / ou Relações (Tabelas)
que não se consegue aceder
• Utilizar tabelas com nomes só em minúsculas
• Por o nome da tabela entre aspas, exemplo “Tabela”
• Utilizar o esquema público ou “Esquema”.”Tabela”

8. Passwords
• Utilizar a propriedade Edit.PasswordChar

9. Comando Strip
• Para reduzir o tamanho de um executável, utilizar o comando “strip”, tipicamente
no path do S.O. Linux; em windows, utilizar o executável, tipicamente em (adaptar
conforme a directoria de instalação e as versões específicas instaladas):
c:\lazarus\fpc\2.2.4\bin\i386-win32\strip.exe nome_do_exe_a_reduzir

O comando strip reduz drasticamente o tamanho do executável (qualquer S.O.) que

mantém todas as funcionalidades mas perde informação de debugging.

10. Ficheiros que podem ser apagados

O lazarus utiliza diversos ficheiros temporários, alguns dos quais podem ser apagados.
Para tal utilizar Menu File/Clean_Directory. Alguns ficheiros que podem ser apagados:
*.compiled, *.o, *.ppu.

- Fim do FAQ -

Introdução ao Lazarus FEUP - DEEC Pág 49

Listagem de Teclas e funcionalidades
● CTRL + Space – completar código
● CTRL + SHIFT + Space – Parâmetros da chamada ao procedimento/função
● CTRL + J – Code Templates
● CTRL + SHIFT + CIMA / CTRL + SHIFT + BAIXO – declaração / implementação
● CTRL + Clique - declaração / definição (de qualquer variável, etc)
● CTRL + H – Leva ao ponto de edição anterior
● CTRL + SHIFT + H – Leva ao ponto de edição seguinte
● F12 - troca entre form e código
● F11 - activa o object inspector
● CTRL + SHIFT + C – completa classe / implementação de classe
● CTRL + Y – Apagar uma linha
● F7 – Debugger -> Step Into
● F8 – Debugger -> Step Over
● F9 – Run

Introdução ao Lazarus FEUP - DEEC Pág 50