Lazarus FreePascal Para Iniciantes

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


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

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

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

4


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


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


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


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


•

•

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


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


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


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. 2. 3. 4.

Compila o código fonte em Free Pascal que descreve o form. Compila o arquivo do projeto. Constrói o arquivo executável (EXE), ligando as bibliotecas apropriadas. 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


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


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


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


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


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


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


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


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


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


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


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


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


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 +BorderIcons biMaximize BorderStyle Caption Color Height Icon Name Position Width WindowState Método Close Show ShowModal

Conteúdo

False bsSingle Exemplo 1 clDefault 480 frmExemplo1 poScreenCenter 640 wsNormal

Descrição

Desabilita o botão maximizar Borda simples, tamanho fixo Legenda da barra de títulos Cor padrão de fundo da tela Altura da tela em pixels Ícone da barra de títulos da janela Identificador da janela Posiciona a janela no centro da tela Largura da tela em pixels Abre a tela no tamanho original Descrição

Fecha a janela Abre a janela Abre a janela, mas usuário precisa fechá-la para continuar a aplicação 38

Lazarus/Free Pascal para iniciantes Evento OnActivate OnClose OnCloseQuery OnCreate OnShow

Descrição

Quando a janela recebe o foco Quando a janela é fechada Quando a janela é fechada, mas o usuário pode impedir o seu fechamento Quando o form é criado 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 Caption Default Enabled Height ModalResult Name Width Método Click Evento OnClick OnEnter

Conteúdo

&Fechar False True 25 mrNone btnFechar 75

Descrição

Legenda do botão Evento OnClick não é executado se Enter for pressionado Habilita o botão Altura do botão Determina se e como o form será fechado Identificador do botão Largura do botão Descrição

Simula um clique de mouse como se o usuário tivesse pressionado o botão Descrição

Quando o usuário clica no botão 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 CharCase

Conteúdo

ecNormal

Height Name PasswordChar

21 edNome #0

Text Width Método Clear SetFocus Evento OnChange

400

Descrição

Não faz nenhum tipo de conversão no que é digitado. ecUpperCase converte tudo para maiúsculas Altura da caixa de texto Identificador da caixa de texto Define qual caractere será usado para ocultar o texto digitado. #0 não oculta o texto digitado Retorna o que foi digitado pelo usuário. Seu conteúdo deve ser apagado Largura da caixa de texto Descrição Limpa o conteúdo de Text

Muda o foco para o controle Descrição

Quando o texto é modificado 41

Lazarus/Free Pascal para iniciantes OnEnter OnExit

Quando o controle recebe o foco 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 Alignment AutoSize

Conteúdo

taLeftJustify True

Caption FocusControl

&Nome edNome

Descrição

Texto justificado à esquerda Define se o controle será automaticamente redimensionado para acomodar o texto Legenda do rótulo Define qual componente receberá o foco quando for selecionada a tecla de atalho sublinhada da legenda 42

Lazarus/Free Pascal para iniciantes Name WordWrap

Evento OnClick

lblNome False

Identificador do rótulo Se AutoSize estiver False, define se o texto poderá utilizar retorno automático (quebra de linha) no caso de ultrapassar a largura definida Descrição

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


Propriedade Caption Checked Name State Evento OnClick OnEnter

Conteúdo

Ativo False chxSituacao cbUnchecked

Descrição

Legenda da caixa de verificação Especifica se o controle está marcado Identificador da caixa de verificação Indica se o controle está selecionado, não selecionado ou parcial Descrição

Quando o usuário clica no controle 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 Caption Columns

Conteúdo

Sexo 1

Descrição

Legenda do grupo de botões de rádio Número de colunas em que as opções do grupo 44

Lazarus/Free Pascal para iniciantes Height ItemIndex Items Name Width Método SetFocus Evento OnClick OnEnter OnExit

90 0 Masculino Feminino rgSexo 185

de botões são apresentadas Altura do controle Define o item selecionado (primeiro item é 0) Lista de opções Identificador do grupo de botões de rádio Largura do grupo de botões de rádio Descrição


Quando o controle é clicado Quando o controle recebe o foco 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


Figura 38 O Componente ListBox

Vamos alterar algumas propriedades do controle. No quadro abaixo mostramos algumas propriedades, métodos e eventos de TListBox . Propriedade Columns

Conteúdo

0

Height ItemIndex Items MultiSelect

80 0

Name Sorted Width Método Clear SetFocus Evento OnClick OnEnter OnExit

lbxProfissao True 121

False

Descrição

Número de colunas mostradas sem precisar rolar horizontalmente Altura do controle Define o item selecionado (primeiro item é 0) Lista de opções Define se o usuário pode selecionar mais de um item Identificador da caixa de lista Define se os elementos serão ordenados Largura da caixa de lista Descrição

Deleta os itens da caixa de lista Muda o foco para o controle Descrição

Quando o controle é clicado Quando o controle recebe o foco 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


•

•

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

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

Items Name Sorted Style Text Método Clear SetFocus Evento OnChange OnClick OnEnter OnExit

Conteúdo

cbxEscolaridade True csDropDown

Descrição

Define o item selecionado (primeiro item é 0). Não pode ser alterado em tempo de desenvolvimento Lista de opções Identificador da caixa combinada Define se os elementos serão ordenados Define o estilo de apresentação da caixa Retorna o que foi selecionado ou digitado Descrição

Deleta os itens da caixa combinada Muda o foco para o controle Descrição

Quando o conteúdo do controle é modificado Quando o controle é clicado Quando o controle recebe o foco 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


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 Kind

sbHorizontal

LargeChange

10

Max Min Name Position SmallChange

100 1 sbIdade 1 1

Método SetFocus Evento OnChange OnScroll OnEnter OnExit

Conteúdo

Descrição

Especifica se o controle será horizontal ou vertical Especifica quanto Position varia quando o usuário clica nos lados da barra Especifica a posição máxima Especifica a posição mínima Identificador da barra de rolagem Indica a posição atual da barra Especifica quanto Position varia quando o usuário clica nas setas Descrição


Quando posição da barra é modificada Quando a barra é rolada Quando o controle recebe o foco 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


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


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 Align

alClient

Lines Name ReadOnly

memDados True

Método Clear SetFocus Evento OnChange OnEnter OnExit

Conteúdo

Descrição

Determina como o controle se alinha dentro do seu contêiner Contém as linhas de texto do controle Identificador do memorando Define se o usuário pode editar o texto do controle Descrição

Deleta as linhas de texto do memorando Muda o foco para o controle Descrição

Quando o texto no controle é modificado Quando o controle recebe o foco 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 proprieda propriedade de 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 Insira um novo botão 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. botão. A definição definição da propriedade propriedade Default como True indica que, se o usuário pressionar a tecla Enter, o evento OnClick será 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 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 descrição ção do método método Clear no 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 prop propri ried edad adee Lines do comp compon onen ente te Memo é um obje objetto do tip 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 prop propri ried edad adee de mmDados. O argu argume ment ntoo do méto método do deve deve ser ser um umaa stri string ng.. Como Como argumento argumento usamos um literal, literal, que identifica identifica o dado da linha de texto, concaten concatenado ado 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 prof profis issã sãoo da pess pessoa oa é adici adicion onad adaa na linh linhaa 57. 57. As prof profis issõ sões es estã estãoo na propriedade Items de lbxProfissao . O índice do elemento selecionado no ListBox é dado pela pela propried propriedad adee 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 é um umaa prop propri ried edad adee numé numéri rica ca do tipo tipo integer . Ante Antess de concatena concatenarr seu valor é necessá necessário rio convertê-lo 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 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 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. também. A seguir seguir mostramos mostramos os membros mais usados. usados. Note que a proprieda propriedade de Items dos componentes TComboBox e TListBox , assim como Lines, de TMemo, também são do tipo TStrings . Propriedade Count Strings Text

Conteúdo

Descrição

Informa quantas linhas existem na lista Refe Refere renc ncia ia as strin strings gs na list listaa atra atravé véss de sua sua posição. Sempre baseada em 0 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 AddStrings Clear Delete IndexOf Insert LoadFromFile SaveToFile

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

O Lazarus, 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: TD TDateTime) Converte um um TD TDateTime pa para Str Striing 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


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 aplicação.. Depois Depois de iniciar a nova aplicação aplicação vamos modificar modificar Name do form para frmDialogos, e Caption p par araa Diálogos. Depoi Depoiss vamos vamos salvá-l salvá-la. a. Vamos Vamos dar dar à unit o nome de u_dialogos e ao projeto o nome Dialogos. Insi Insira ra um botã botão, o, dê a ele o nome nome de btnMensagem1 e em 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 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ív possível el criar criar mensag mensagen enss em múl múltip tiplas las lin linhas has usando usando qualqu qualquer er um dos dos seguintes separadore s eparadores: s: sLineBreak; LineEnding; ou #13#10. Por exemplo, esta mensagem será mostrada em duas linhas: li nhas: • • •

ShowMessage('Primeira ShowMessage('Primeira linha'

55

+ sLineBreak sLineBreak + 'segunda linha');


MessageDlg ShowMessage apenas mostra uma mensagem, usuário. MessageDlg permite vários tipos de diálogos e

não permite interação com o 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;

é 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: CanClose

56


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 mtConfirmation, [mbYes, mbNo], 0) = mrNo then CanClose := False;

sair?',

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 PChar; Flags: Longint): Integer;

Text,

Caption:

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 'Informação', MB_OK + MB_ICONEXCLAMATION);

A seguinte caixa de diálogo será mostrada. 58

ser

salvo',


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 string): string;

ACaption,

APrompt,

ADefault:

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: var Value: string): Boolean; function InputQuery(const ACaption, APrompt: MaskInput: Boolean; var Value: string): Boolean;

string; string;

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


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 Caption Default Enabled Glyph Kind Name

Conteúdo

Descrição

&Fechar False

Legenda do botão Evento OnClick não é executado se Enter for pressionado True Habilita o botão Define um ícone para o botão bkClose Seleciona o tipo do botão e seu comportamento 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


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


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


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


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 a opção Arquivo para visualizar o menu local, conforme pode ser visto na figura:

sobre

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


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


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


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 +EdgeBorders ebLeft ebTop ebRight ebBottom EdgeInner EdgeOuter Flat

Conteúdo

False True False True esRaised esLowered True

Images Name

tbBarra

Descrição

Define bordas para a barra de ferramentas. Nesse caso, definimos que haverá bordas no topo e na base

Define o formato interno da borda Define o formato externo da borda Torna a ToolBar transparente e deixa os botões sem bordas Permite definir um objeto ImageList que contém as imagens para os botões 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


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 Name Panels SimpleText

Conteúdo

Descrição

stbMenu

Identificador da barra de status Define os painéis que constituem o componente 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 Width

Silva 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 FreePascal Para Iniciantes

Recommend Documents