Lazarus - Acessando banco de dados com SQLdb - Parte I

Para fazer nossa primeira aplicação usando banco de dados no Lazarus vamos usar o SQLite e o conjunto de componentes nativo SQLdb. Inicialmente vamos apresentar passo como essa aplicação foi criada. Essa foi a maneira que eu fiz, e eu agradeço sugestões e questionamentos que pessoas que já passaram por essa experiência. Depois irei fazer algumas considerações sobre o uso do SQLdb.

SQLite

SQLite é uma biblioteca que implementa um motor de banco de dados SQL. É livre para qualquer finalidade, seja uso particular ou comercial. Lê e escreve em um único arquivo que pode ter além de tabelas, índices, gatilhos e visões. Executa em várias plataformas e é indicado para aplicações embarcadas. Maiores detalhes podem ser encontrados no site oficial. Para usá-lo, baixe-o do site e faça a instalação adequada para o seu sistema operacional. No Windows isso é muito simples, apenas copie sqlite3.dll para o system32 da pasta do sistema operacional.
Existe uma ferramenta de linha de comando chamada sqlite3 que podemos usar para criar o banco de dados e as tabelas. Pode ser baixada no próprio site oficial do SQLite. Depois de instaladas a dll e a ferramenta de criação do banco execute-a digitando o seguinte comando no console do sistema operacional:

sqlite3 banco.db

Se o banco já existir ele será aberto para operações como criar/alterar tabelas e consultar/inserir/atualizar/deletar dados nas tabelas existentes. Depois disso digite os comandos SQL para a criação de duas tabelas necessárias para nossa aplicação:

create table cidade (id_cidade integer primary key, nome varchar(30));
create table cliente (id_cliente integer primary key, nome varchar(40), endereco varchar(40), id_cidade integer, telefone varchar(14), tipo char(1), status boolean);

Feito isso digite .quit para sair e voltemos ao nosso IDE.

SQLdb

Esse é o pacote para acessar bancos de dados no Lazarus. Você o encontra na aba SQLdb. Algumas informações estão em http://wiki.freepascal.org/SQLdb_Package. Com esse pacote podemos conectar ao PostgreSQL, Oracle, MySQL, Firebird, SQLite e ODBC. Para cada um desses existe um componente TXXXConnection. Para conectar ao Firebird, por exemplo, existe o componente TIBConnection. Para executar as operações sobre tabelas temos o TSQLQuery e o TSQLTransaction. A seguir iremos criar a aplicação e mostraremos como utilizar esses componentes.

A aplicação exemplo

Vamos então iniciar o Lazarus e criar uma nova aplicação. No primeiro form crie um menu com a seguinte estrutura. Se for necessário leia o artigo sobre criação de menus em http://professorcarlos.blogspot.com/2010/01/lazarus-criando-menus.html:

Arquivo
    Sair
Cadastros
    Cidade
    Cliente
Consultas
    Cidade
    Cliente

Mude a propriedade Name desse form para frmPrincipal. Mande salvar tudo. Escolha u_principal para nome da unit e Clientes para nome do projeto.
É fortemente aconselhado que os componentes de conexão e acesso ao banco de dados estejam agrupados em um repositório denominado DataModule. Para criar um DataModule no Lazarus selecione o menu Arquivo -> Novo. Selecione Data Module abaixo do grupo Módulo e pressione o botão OK. Mude a propriedade Name para dmDados, mande salvar e dê o nome u_dmdados para esta unit.
Agora selecione a aba de componentes SQLdb e coloque um TSQLite3Connection no DataModule. Na propriedade DatabaseName informe o nome do arquivo do banco de dados com o caminho. Mude a propriedade Name para dbCliente. Neste momento podemos mudar a propriedade Connected para True. Se nenhum erro acontecer o componente de conexão está corretamente configurado. Volte a propriedade Connected para False. Coloque um componente TSQLTransaction no DataModule. Na propriedade Database selecione dbCliente e em Name digite trGeral. Retorne ao SQLite3Connection e selecione trGeral na propriedade Transaction. TSQLTransaction é o componente que controla as transações no banco de dados. Em um banco de dados as operações ocorrem no contexto de uma transação. Uma transação finaliza com sucesso através de um COMMIT e ROLLBACK desfaz as operações realizadas anteriormente.
Selecione um TSQLQuery e coloque no DataModule. Na propriedade Database selecione dbCliente. Na propriedade Name digite queCidade e em SQL informe select * from cidade. Na propriedade Transaction defina trGeral. Agora localize a aba Data Access. Selecione um componente TDataSource e coloque no DataModule. Defina Name como dsCidade e em DataSet selecione queCidade. Resumindo, fizemos a conexão com o banco de dados usando SQLite3Connection, em seguida definimos um componente para controlar as transações, definimos uma conexão com uma tabela do banco usando TSQLQuery, e criamos uma ligação entre a tabela e os componentes que terão a função de ler os campos dessa tabela usando TDataSource. Esse é um procedimento repetitivo para novas tabelas nessa aplicação e mesmo quando usarmos outros conjuntos de componentes. O DataModule terá essa aparência, já com os componentes para acesso à tabela Cliente.

Repita os mesmos passos para a tabela Cliente, inserindo mais um TSQLQuery e um TDataSource. Selecione o form principal e, no editor de código, digite abaixo de Implementation:

uses u_dmdados;

Localize o evento OnShow na aba Eventos do Inspetor de objetos.  Dê um duplo clique à direita e digite:

dmDados.dbCliente.Open;

Assim, sempre que o programa for iniciado a conexão com o banco de dados será aberta.

Form de Cidade

Insira um novo form na aplicação. Ele será desenhado para fazer as atualizações na tabela Cidade. Defina o Name do form como frmCidade e o Caption como Cidades. Salve a unit e defina seu nome como u_cidade. O desenho deste form deve ter a seguinte aparência.

 

Antes de começar a desenhar a janela, acesse o código da unit e insira o seguinte código abaixo de Implementation: 

uses u_dmdados;

Isso permite que esta unit acesse os objetos do DataModule.
Pegue um componente TPanel na aba Standard e coloque no form. Defina a propriedade Align como alTop. Exclua o conteúdo de Caption. As propriedades BevelInner e BevelOuter são usadas para definir contornos para o painel. Deixe, por exemplo, como bvLowered e bvRaised respectivamente.
Agora selecione um TDBNavigator na aba Data Controls e o coloque no form sobre o painel. Na propriedade DataSource do navegador selecione dsCidade.
Dessa mesma aba selecione TDBEdit e coloque dois deles no form. No primeiro defina Name como edIdCidade, em DataSource selecione dsCidade e em DataField digite ID_CIDADE. Essa última atribuição irá provocar um erro, mas isso não vai interferir no resultado. No segundo TDBEdit defina Name como edNome, DataSource como dsCidade e em DataField digite NOME. Selecione TLabel na aba Standard e coloque um à esquerda de cada TDBEdit para identificá-los. Defina suas propriedades Caption como ID e Nome, respectivamente. Para finalizar o desenho coloque um TSpeedButton da aba Additional sobre o painel. Defina Name como btnSair e escolha um ícone apropriado para ele usando a propriedade Glyph. No evento OnClick deste botão digite:

Close;

É necessário programar a abertura e o fechamento da Query no form. A abertura será programada no evento OnShow e o fechamento será programado no evento OnClose, ambos de form. Com o form selecionado selecione da aba Eventos no Inspetor de Objetos. Localize o evento OnShow, dê um duplo clique na caixa à direita e digite o seguinte:

dmDados.queCidade.Open;

Faça o mesmo para o evento OnClose e digite:

dmDados.queCidade.Close;

Agora precisamos programar a chamada do form frmCidade a partir no form principal. Selecione o form principal, mude para o editor de código e digite abaixo de Implementation:

uses u_cidade;

Volte para o form e clique no menu Cadastros -> Cidades. No editor de código digite:

frmCidade.Show;

Se você compilar e executar o programa verificará que não consegue ainda inserir dados na tabela Cidade. Todos os dados que são inseridos ficam em cache. É necessário enviar os dados para o banco e finalizar a transação.
Isso será feito no evento AfterPost da Query. Este evento ocorre após um registro ser gravado no banco. Selecione o DataModule e em seguida queCidade. Clique na aba Eventos do Inspetor de Objetos. Localize o evento AfterPost, dê um duplo clique à direita dele e digite o seguinte:

Vamos esclarecer o código:
linha 42 - declara um TBookMark, que é um ponteiro para um registro.
linha 45 - try, juntamente com except consiste em um tratamento de exceção. Se algo falhar no bloco try, o código em except é executado.
linha 46 - guarda o ponteiro do registro atual.

linha 47 - envia para o banco de dados o que estiver no cache.
linha 48 - verifica se existe uma transação ativa.
linha 50 - executa um COMMIT no banco, mas mantém a transação aberta.
linha 51 - desvia para o ponteiro salvo na linha 46.
linha 54 - executa um ROLLBACK se algo sair errado no bloco try.

Localize o evento AfterDelete da Query. Clique no botão da caixa à direita para selecionar um método existente. Selecione queCidadeAfterPost. Assim reaproveitamos o código que executa a mesma operação necessária no AfterDelete.
Compile e execute o programa. No post seguinte daremos seguimento ao desenvolvimento dessa aplicação.

Aventurando-se no Linux - VirtualBox

Sou um remanescente do bom e velho sistema operacional (SO) MS-DOS. Tudo era feito através de linha de comando semelhante ao que é feito no Linux, mas devo confessar que a cada vez que eu vejo os procedimentos para instalar um programa no Linux eu fico cansado e desisto até de continuar lendo o tutorial. Eu uso o Windows, mesmo com todos os problemas, devido a facilidade com que eu consigo instalar um programa. É só clicar em Instalar, Próximo, Próximo ... e Finalizar. Para um sujeito preguiçoso como eu não tem coisa melhor.
Bem, o que eu queria mesmo era utilizar os recursos do Cross Compiler do Lazarus. Recurso muito interessante que permite que você gere um executável para Windows a partir de uma instalação Linux, por exemplo. Em tese é possível gerar para qualquer sistema estando em qualquer um outro. Gostaria de pode criar executáveis Linux estando no Windows, mas não encontrei informação clara que me ajudasse. Em http://wiki.freepascal.org/Cross_compiling/pt#De_Windows existe algo um pouco confuso, e não tentei nada seguindo essas informações. Decidi então encarar uma instalação Ubuntu e depois o Lazarus. Para poder continuar usando o Windows e alternar entre um e outro SO, eu optei por instalar um software de virtualização. Após alguma pesquisa me decidi pela VirtualBox da Sun, que hoje é Oracle. Distribuida sob licença GPL, roda em Windows, Linux, Macintosh e OpenSolaris. Depois de instalar o VirtualBox, criei uma máquina virtual (VM). Podemos criar mais de uma e instalar vários SOs num mesmo micro. Em seguida instalei o Ubuntu a partir de um CD. Não é necessário instalar nenhum driver, o que é um alívio. Quando você instala a VM, ela instala um cartão de rede virtual e seleciona o modo NAT (Network Address Translation). Dessa forma o sistema guest (Linux no meu caso) pode acessar a Internet através de uma conexão do sistema host (Windows no meu caso). Instalei o VirtualBox Guest Additions. Isso possibilita alguma melhoria em vídeo, pastas compartilhadas entre host e guest, etc. Bem, até agora não consegui compartilhar uma pasta entre os dois SOs. Vejam na figura abaixo a VM executando na área de trabalho do Windows.

Agora eu já tinha um Linux rodando e precisava instalar o Lazarus. Não foi difícil encontrar dicas de como fazer isso. Em http://sites.google.com/site/silvioprogbs/documentos tem algumas coisas interessantes. Até que não deu muito trabalho. E dá-lhe baixar pacotes e mais pacotes dos quais o Lazarus e o FreePascal dependem para rodar. Confesso que fiquei bem animado quando terminou tudo, executei o Lazarus e ele compilou e executou um programinha simples. Bem, dai eu fui para um teste mais rigoroso. Copiei o programa Editor que criei nos posts anteriores para dentro da VM, abri o Lazarus e o compilei. Executou sem problema. Vejam ai a tela do programa rodando na VM.

Este post não é um tutorial de como instalar uma VM, dada a sua simplicidade. É mais para compartilhar minha experiência. No entanto se alguém se interessar pelo assunto gostaria de trocar idéias. Preciso compartilhar uma pasta entre os dois SOs e ainda não consegui e, claro, explorar mais recursos disponíveis.

Lazarus - Barras de ferramentas e de status

Vamos continuar usando a aplicação criada no post anterior. Agora vamos acrescentar uma barra de ferramentas e de status e mostrar também como implementar menus locais, chamados de pop-ups.

Barra de Ferramentas

Selecione a aba Common Controls na paleta de componentes. Pegue um TToolBar e coloque no form. Não precisa se preocupar com a posição, o Lazarus sabe exatamente onde fica uma barra de ferramentas e já a posiciona corretamente. Vamos dar o nome (Name) de tbaPrincipal ao componente. Nossa ToolBar terá botões para alterar as cores e o alinhamento do texto. Exatamente as mesmas opções do menu. Para inserir os botões, clique com o botão direito e selecione New Button. Insira dois botões. Em seguida insira um separador, selecionando New Separator. Após isso insira mais três botões.

ImageList

Para definir imagens para os botões devemos usar o componente TImageList. Pegue um desses na própria aba Common Controls e dê a ele o nome imlPrincipal. Depois de por no form - em qualquer posição - clique com o botão direito nele e selecione Editor "Image List". Clique no botão adicionar e selecione um ícone apropriado para cada botão. Depois disso selecione o ToolBar, vá na propriedade Images e selecione imlPrincipal. Clique então em cada botão e defina na propriedade ImageIndex qual o índice do ícone que você deseja para ele. O índice do primeiro botão do ImageList é 0. Nosso form deve estar com a aparência da figura abaixo, dependendo claro dos ícones que você escolheu para os botões.

 

Vamos então programar os eventos OnClick de cada botão. Neste caso iremos simplesmente reutilizar os códigos dos eventos OnClick das opções de menu correspondentes. Para fazer isso clique no primeiro botão e no Inspetor de Objetos selecione a aba Eventos. Em vez de dar um duplo clique no evento, apenas clique na caixa e localize o procedimento mnuCorTextoClick. Selecione-o. Pronto, agora a opção de menu Cor do Texto de o botão da barra de ferramentas têm o mesmo código no evento OnClick. Repita o procedimento para os demais botões.
Observe que no menu foi criada uma opção Visualizar -> Barra de ferramentas. Essa opção permitirá visualizar/ocultar a ToolBar. Dê um clique nessa opção para abrir o editor de código no procedimento OnClick e escreva:

tbaPrincipal.Visible := not tbaPrincipal.Visible;
mnuBarraFerramentas.Checked := tbaPrincipal.Visible;


Dê um duplo clique no MainMenu e selecione Barra de ferramentas. Localize a propriedade Checked e mude-a para True. Como sempre que abrimos o programa a ToolBar está visível, então deixamos a opção de menu marcada. Note que a opção Visualizar -> Barra de ferramentas funciona como um CheckBox.

Barra de Status

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. Não importa onde você insere o StatusBar, o Lazarus sempre o posiciona na base da janela. Mude a propriedade Name do componente para stbPrincipal.
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 Adicionar na parte superior do editor.
O Lazarus guarda as informações sobre os painéis do StatusBar em um array. O primeiro painel é chamado stbPrincipal.Panels[0] e o segundo stbPrincipal.Panels[1]. Cada painel é um objeto do tipo TStatusPanel. Portanto possui propriedades e métodos. Mantenha o editor de painéis aberto. Clique no primeiro painel e digite Desenvolvido por João da Silva. Altere a propriedade Width para um valor conveniente, 300 por exemplo.
No segundo painel mostraremos a hora atual. Esta informação deve ser mostrada de forma dinâmica. Para isso será usado o componente TTimer que se encontra na aba System. Esse componente tem um evento chamado OnTimer que ocorre em intervalos de tempo que são definidos pela propriedade Interval. Por padrão o intervalo é de 1000 milissegundos. Coloque esse componente em qualquer posição no form e altere a propriedade Name para timHora. Deixamos Interval como está pois o evento ocorrerá exatamente a cada segundo.

Selecione a aba Eventos e dê um duplo clique o evento OnTimer. Escreva o seguinte código:

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

Esse código converte para string a hora atual devolvida por Time e a atribui à propriedade Text do segundo painel. Lembre que esse código é executado a cada segundo, mantendo a hora no painel sempre atualizada.

Menu local

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.
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 popAlinhamento. Dê um duplo clique no componente e insira as opções: Esquerda, Centro e Direita. A maneira de inserira as opções é semelhante ao que fizemos para o MainMenu. Ou seja, queremos um menu local com as mesmas opções referentes ao alinhamento do texto do MainMenu que criamos.
Ainda com o editor de menus aberto, clique na opção Esquerda. Selecione a aba Eventos e no evento OnClick selecione o procedimento mnuEsquerdaClick. Proceda de forma semelhante para as outras duas opções. Ou seja, reutilize o código, visto que é exatamente o mesmo.
Selecione o Memo e na propriedade  PopupMenu selecione popAlinhamento. Esta é a maneira de associar o menu local a um componente. Execute o programa, teste todas as funcionalidades implementadas.

A partir do próximo artigo falaremos de aplicações de banco de dados usando o Lazarus. Até lá.

Lazarus - Criando menus

Aplicação exemplo

Para exemplificarmos a construção de menus vamos criar uma nova aplicação. Nossa aplicação será um editor de textos usando o componente TMemo. Após iniciar a nova aplicação defina a propriedade Name do  form como  frmEditor, o Caption como Editor e salve tudo atribuindo à unit o nome u_editor e ao projeto o nome Editor.
Selecione um componente Memo na aba Standard e insira-o no  form. Defina a propriedade Name  como  mmEditor. Na propriedade  Align selecione  alClient, dessa forma o Memo ocupará toda a área do form. Acesse a propriedade Lines e exclua a linha que lá aparece. Na propriedade ScrollBars selecione ssAutoVertical. Assim, quando for digitado um texto maior do que o pode caber no Memo, a barra de rolagem vertical irá aparecer automaticamente.

O Editor de Menus

Vamos criar um menu com a seguinte estrutura:

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

Para utilizar o Editor de Menus do Lazarus 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. 
Para abrir o editor dê um duplo clique no MainMenu. Na propriedade Caption digite &Arquivo e na propriedade Name digite mnuArquivo. Isso define o primeiro item de menu. Clique com o botão direito no item recém-criado. Em seguida clique em Inserir novo item (depois), digite &Visualizar no Caption e mnuVisualizar em Name. Repita esses passos para os itens &Opções e A&juda. Agora clique com o botão direito no item Arquivo e clique em Criar Submenu. Digite Sai&r no Caption, e mnuSair em Name. Faça o mesmo nos itens seguintes. Quando quiser incluir novo item use a opção Inserir novo item (depois) ou Inserir novo item (antes). Clique com o botão direito em Alinhamento e escolha Criar Submenu. Inclua os itens conforme descrito na estrutura do menu acima. Seu form deve estar com esta aparência:

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. No Editor de Menus simplesmente escolha uma combinação de teclas na propriedade ShortCut do item. Vamos fazer isso para as opções: Esquerda, Centro e Direita do item de menu Alinhamento. 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. Veja a figura abaixo:

Respondendo aos comandos do menu

Vamos inserir o componente TColorDialog da aba Dialogs na nossa aplicação. Esse componente é uma janela onde podemos selecionar um cor. Mude a propriedade Name desse componente para dlgCores. Usaremos esse componente para mudar as cores do texto e do fundo do nosso editor. Dessa forma quando selecionarmos a opção Cor do texto ou Cor do fundo no menu Opções, a caixa de diálogo de cores será aberta e poderemos selecionar uma nova cor. Clique então em Cor do texto. O editor de código será aberto no método do evento OnClick dessa opção e digite o seguinte código:

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

A primeira linha do código define que a cor selecionada no ColorDialog será a mesma do texto do Memo. Na linha seguinte definine-se que, se o usuário clicar OK no ColorDialog, a cor selecionada será atribuída à propriedade Color de Font do Memo. Compile e execute o programa. Digite um texto e mude sua cor usando a opção Cor do texto.

No evento OnClick da opção Cor do fundo digite o seguinte código:

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

Este código é semelhante ao código de Cor do texto, mas neste caso mudamos a propriedade Color do Memo, que significa mudar a cor do fundo.

No grupo de Alinhamento, usaremos as opções para alinhar o texto à esquerda, à direita ou centralizar. Além disso queremos que a opção de menu que estiver selecionada fique marcada. Clique então na opção Esquerda. Digite o seguinte código no método que foi aberto:

mmEditor.Alignment := taLeftJustify;
mnuEsquerda.Checked := True;
mnuCentro.Checked := False;
mnuDireita.Checked := False;

A primeira linha define o alinhamento do texto no Memo. As três linhas seguintes definem qual opção de menu está selecionada. Vamos definir o código para OnClick de Centro:

mmEditor.Alignment := taCenter;
mnuEsquerda.Checked := False;
mnuCentro.Checked := True;
mnuDireita.Checked := False;

E para o evento OnClick de Direita:

mmEditor.Alignment := taRightJustify;
mnuEsquerda.Checked := False;
mnuCentro.Checked := False;
mnuDireita.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 fazer chamadas a outros forms será estudada agora. Vamos criar um novo form na nossa aplicação. Esta nova janela será o nosso Sobre (About). Para incluir um novo form selecione no menu Arquivo -> Novo formulário. Ou utilize o botão correspondente na barra de ferramentas. Neste novo form defina Caption como Sobre. Na propriedade Name informe frmSobre. Salve-o e escolha u_sobre para nome da unit. Você é livre para criar o Sobre da maneira que preferir. Mas no nosso exemplo vamos inserir um rótulo (TLabel) onde definimos o Caption como Programa desenvolvido por Carlos Araújo apenas para fins didáticos. Deixe a propriedade Width como 220 e WordWrap como True. A propriedade WordWrap define se o Caption permite quebra de linha. Inclua mais um rótulo e defina o Caption como Versão 1.0. Inclua um botão do tipo TBitBtn da paleta Additional e defina Name como btnFechar e Kind como bkClose.

 

Este botão não precisa de código no evento OnClick. A propridade Kind define a função do botão.

Agora que Sobre estrá pronto queremos que nossa aplicação mostre-o quando o usuário selecionar o menu Ajuda -> Sobre. Para efetivarmos isso precisamos primeiramente informar à unit u_editor que ela usará a unit u_sobre. Isto é feito digitando o seguinte código logo abaixo da seção implementation de u_editor:

uses u_sobre;

Agora u_editor tem acesso a tudo que é público em u_sobre. Há duas maneiras de fazer chamadas a forms:

• 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, 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;

Selecione o evento OnClick do comando Arquivo -> Sair e digite Close no editor. Execute o programa e clique em Ajuda -> Sobre. Observe que você não pode fazer nada no programa sem que o form Sobre seja fechado. Confirme o funcionamento correto das outras opções do menu. Digite um texto no Memo e teste alterações de cores e alinhamento.
No próximo post mostraremos como criar barras de ferramentas, de status e menus locais (pop-ups).

Lazarus - Explorando os Componentes Básicos (Parte III)

Entrando múltiplas linhas

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 de um GroupBox, como mostrado na figura abaixo.

Usaremos este componente para mostrar todos os dados pessoais cadastrados quando for pressionado o botão correspondente. Assim, precisamos modificar algumas propriedades de Memo.

• Align - alClient. Para o Memo preencher todo o GroupBox, onde ele está contido.
• Lines - clique no botão elipse e apague o conteúdo.
• Name - mmDadosPessoais.
• ReadOnly - True. Define que o usuário não pode editar o conteúdo do controle.

Juntando tudo

Insira um novo botão no  form. Esse botão, quando pressionado, mostrará os dados pessoais no campo Memo. Defina a propriedade Caption como Mostrar, Default como True e Name como btnMostrar. 
A definição da propriedade Default como True indica que, se o usuário pressionar a tecla Enter, o evento OnClick será executado.
Agora iremos escrever o código que fará todo o trabalho para nós.
Como vimos no nosso primeiro programa, se queremos que a ação aconteça quando pressionarmos o botão, então deveremos programar o evento OnClick do botão. Dê um duplo clique no botão e o editor de código será aberto para inserirmos o código.

Vamos analisar cada linha do código mostrado na figura acima. A linha 52 é responsável por deletar as linhas do memorando. Dessa forma toda vez que inserirmos os dados de uma nova pessoa e pressionarmos o botão btnMostrar, os dados anteriores são apagados. Observe que, para chamar um método de um componente, informamos o nome do componente seguido do nome do método separados por ponto.
A propriedade  Lines do componente  Memo é um objeto do tipo  TStrings, portanto possui propriedades e métodos. Dos métodos disponíveis de Lines usaremos Add, para adicionar novas linhas ao texto do controle.
Na linha 53 do código o nome da pessoa é adicionada ao texto. Observe a forma de invocarmos o método Add. Add é um método de Lines, e Lines é uma propriedade de mmDados. O argumento do método deve ser uma string. Como argumento usamos um literal, que identifica o dado da linha de texto, concatenado ao
nome da pessoa, que é dado pela propriedade Text  do componente edNome. A linha 54 é semelhante à 53, não merece maiores comentários.
A profissão da pessoa é adicionada na linha 55. As  profissões estão na propriedade Items de lbxProfissao. O índice do elemento selecionado no ListBox é dado pela propriedade ItemIndex.  Items  pode ser tratado como um vetor indexado por ItemIndex. Por isso a linha 55 é escrita dessa forma.
Na linha 56 adicionamos a idade da pessoa, definida pela propriedade Position de ScrollBar. Position é uma propriedade numérica do tipo integer. Antes de concatenar seu valor é necessário convertê-lo para string. Por isso usamos a função IntToStr(), para converter um número inteiro para string.
A linha 57 pode ser analisada de forma semelhante à linha 55. Portanto não será necessário acrescentar nenhum comentário a respeito.
No caso da linha 58 e seguintes, é o que se faz necessário para mostrar o sexo da pessoa. Como a propriedade Checked do componente CheckBox é boolean, usamos isso para implementar uma estrutura de decisão. Se Checked estiver marcado (True) então será mostrada situação ativo, caso contrário será mostrada situação inativa.
Bem, esse é um programa didático. Foi usado apenas para apresentar alguns componentes. Logo iniciaremos uma nova série de posts para apresentar mais recursos dessa poderosa ferramenta.

Lazarus - Explorando os Componentes Básicos (Parte II)

Escolhendo opções

Há dois controles 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.

Vamos alterar as propriedades da caixa de verificação:

• Caption - digite Ativo.
• Checked - defina como True. Especifica que o controle estará marcado por padrão.
• Name - chxSituacao.

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.

Defina as propriedades do grupo de botões da seguinte forma:

• Caption - Sexo.
• ItemIndex - 0. Define o item do grupo de botões que será selecionado por padrão (o primeiro item é 0).
• Items - Masculino/Feminino. Lista de opções do grupo de botões.
• Name - rgSexo.

Para definir a lista de opções, clique no botão elipse no lado direito da propriedade Items no Inspetor de Objetos. 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. Observe que o Lazarus tem uma linha azul que indica se os controles estão alinhados.

Uma lista com muitas opções

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 um TGroupBox da paleta Standard e o insira no form conforme a figura mostrada a seguir. Defina a propriedade Caption dessa caixa como Profissão. Agora coloque uma caixa de lista dentro desta caixa.

Defina as propriedades da caixa de lista assim:

• Align - alClient. Define o alinhamento do controle. Neste caso a caixa de lista é alinhada para preencher exatamente o controle onde está contida.
• ItemIndex - 0. Define que item será selecionado por padrão.
• Items - Carpinteiro/Analaista de Sistemas/Arquiteto/Enfermeira/Engenheiro/Pedreiro e outras que você preferir. Para informar as opções o procedimento é semelhante ao que foi feito na propriedade Items de TRadioGroup.
  
• Name - lbxProfissao.
• Sorted - True. Define que os elementos da lista serão ordenados.

Muitas opções em pouco espaço

Caixas de lista ocupam muito espaço na tela e suas opções são fixas, não dando ao usuário a oportunidade e 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. Coloque um rótulo também para identificar a caixa. No rótulo defina a propriedade Caption como Escolaridade.

Defina as seguintes propriedades:

• Name - cbxEscolaridade.
• Sorted - True. Define que os elementos da lista estarão ordenadas.
• Style - csDropDown. Define o estilo de apresentação da caixa. Neste caso a caixa permite a escolha de uma opção e também a edição de uma nova opção. csDropDownList não permite edição, mas podem ser digitados caracteres que posicionam na primeira opção que inicie com os caracteres digitados.
  

Escolhendo um valor de um intervalo

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

Vamos alterar as seguintes propriedades do componente:

• LargeChange - 10. Especifica o quanto Position varia quando clicamos nso lados da barra.
• Max - 100. Especifica o valor máximo de Position.
• Min - 1. Especifica o valor mínimo de Position.
• Name - sbIdade.
• Position - 1. Define a posição atual da barra.
• SmallChange - 1. Especifica o quanto Position varia quando clicamos nas setas.
  

No rótulo que foi inserido defina a propriedade Caption como Idade.
No próximo post concluiremos este programa.

Lazarus - Explorando os Componentes Básicos (Parte I)

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 sistema 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. Mas será suficiente para que você possa explorar os demais objetos. 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.
Vamos então criar uma nova aplicação. Selecione o menu Arquivo e em seguida em Novo. Na janela clique em Aplicação que está sob o grupo Projeto. Será criado um novo projeto e um novo form.
Vamos então salvar nosso projeto para atribuir nomes aos arquivos. Clique em Salvar Tudo no menu Arquivo. Inicialmente é solicitado o nome da unit. Vamos salvá-la com o nome u_exemplo. Em seguida é pedido o nome do projeto. Digite Exemplo e confirme. Para definir um ícone para a aplicação selecione Opções de Projeto no menu Projeto. Na aba Aplicação clique em Carregar Icone. Escolha o ícone apropriado e confirme.
Nosso programa consistirá de um cadastro de dados pessoais: nome, idade, profissão, escolaridade, sexo e situação cadastral.

Propriedades de form

Vamos modificar as seguintes propriedades do form no Inspetor de Objetos.

• biMaximize em BorderIcons - coloque em False. Isso evita que o form seja maximizado.
• BorderStyle - defina como bsSingle. Para evitar o redimensionamento da janela.
• Caption - informe Exemplo.
• Height - defina como 480. Altura da janela.
  
• Name - defina como frmExemplo.
• Position - defina como poScreenCenter. Para centralizar a janela na tela do monitor.
• Witdh - defina como 640. Largura da janela.

Para modificar a propriedade biMaximize clique no sinal de + à esquerda de BorderIcons para expandir suas subpropriedades.

Usando um Botão

O Lazarus disponibiliza alguns tipos de botão. Vamos selecionar o botão (TButton) da paleta Standard e posicioná-lo no form.

Vamos alterar as propriedades do botão:

• Caption - defina como &Fechar. É a legenda do botão. O & define um atalho para o caso de querer usar o teclado em vez do mouse. Neste caso se você pressionar F será o mesmo que clicar no botão.
  
• Name - defina como btnFechar. A propriedade Name em qualquer componente define o identificador desse componente.
  

Bem, queremos que nosso form seja fechado quando pressionarmos neste botão. Para fazermos isso precisamos escrever algum código. Esse código será escrito para o evento OnClick do botão. Ou seja, queremos que o form seja fechado quando clicarmos no botão. Dê um duplo clique no botão. O editor de código será aberto no procedimento que está associado com o evento. Digite o seguinte código:

Close;

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. Close é o método de form que causa o seu fechamento.
Compile e execute o programa. Agora o form pode ser fechado usando o botão padrão do Windows ou o botão que programamos.

Aceitando dados do usuário

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

Da mesma forma que procedemos com o botão e o form iremos alterar as propriedades desse componente.

• Name - defina como edNome.
• Width - defina como 400.
• Text - apague o conteúdo dessa propriedade. Na verdade esta propriedade irá retornar o conteúdo do campo que for digitado pelo usuário do programa. 
  

Identificando controles

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.
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 legenda. 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 (TLabel) na paleta Standard e insira-o ao lado esquerdo do campo de edição conforme mostrado na figura seguinte.

Vamos alterar suas propriedades conforme o seguinte:

• Caption - &Nome.
• FocusControl - edNome. Define qual componente receberá o foco quando for selecionada a tecla de atalho definida no Caption.
• Name - lblNome.

Tenha em mente que nos referimos apenas nas propriedades que são necessárias para a nossa aplicação. Certamente vamos necessitar usar outras em diferentes programas. Vamos continuar explorando os componentes no próximo post.

Lazarus - Entendendo os Arquivos do Projeto

Em um post anterior vimos como criar uma aplicação simples. Aprendemos como alterar propriedades usando o Inspetor de Objetos e como escrever um método para responder a eventos. Vimos como compilar e executar o programa. Agora vamos estudar mais alguns recursos do Lazarus.
Para prosseguir em nosso estudo vamos usar o programa AloMundo criado anteriormente. Clique no botão Abrir ou pressione CTRL + O. Selecione o projeto AloMundo e confirme.

Alterando propriedades em tempo de execução

Dificilmente um programa pode ser escrito sem que seja necessário alterar propriedades dos componentes em tempo de execução, ou seja, através de código. Por exemplo, queremos mudar a propriedade Caption do botão btnAloMundo para Diga alô de novo depois que o usuário clicar nele pela primeira vez. Será necessário mudar a largura - propriedade Width - do botão para 100, para caber o novo Caption. Vamos alterar o código do procedimento btnAloMundoClick como mostrado na figura.

Desta forma se quisermos mudar o valor de uma propriedade em tempo de execução, utiliza-se um comando de atribuição normalmente. Muitas propriedades podem ser alteradas em tempo de execução e outras podem ser alteradas apenas em tempo de execução. Aquelas que só podem ser alteradas em tempo de execução não são listadas no  Inspetor de Objetos. Algumas dessas propriedades de tempo de execução são definidas como apenas leitura, o que significa que você pode ler seu valor, mas não pode alterá-lo.

Adicionando mais código ao programa

Vamos centralizar o botão no form. Clique em btnAloMundo com o botão direito do mouse. Clique em Alinhamento. Marque Centralizar na janela nas duas colunas e confirme. Agora o botão está centralizado, mas há um probleminha. O botão não permanece centralizado quando redimensionamos o form. Isto pode ser resolvido de duas formas.
Uma solução é mudar o estilo da borda do form de modo que ele não possa ser redimensionado em tempo de execução. Para isso selecione o form e localize a propriedade BorderStyle. Mude para bsSingle. Isso evita que o usuáro mude as dimensões do formulário. Outra abordagem é escrever um código que faça o botão se mover para o centro sempre que o form for redimensionado. Embora pareça que grande parte do trabalho do programador em Lazarus seja selecionar opções e componentes visuais, tem um momento em que é necessário escrever código. Quanto mais experiente você fica, mais código tem que escrever.
Quando precisamos adicionar código ao programa, a primeira pergunta a ser respondida é: Onde? Em uma linguagem orientada a eventos, em geral, o código é executado em resposta a um evento. Neste caso queremos que nosso programa execute um código quando o form for redimensionado. O evento que ocorre nessa situação é OnResize. Para programá-lo, selecione o o form e a aba Eventos do Inspetor de Objetos. Localize o evento OnResize e dê um duplo clique à direita do nome. Um novo procedimento é adicionado ao editor de código. Digite então o seguinte código:

Lembre de retornar a propriedade BorderStyle para bsSizeable antes de executar o programa. 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 interna ou área cliente da página por 2, e então subtrai metade da altura (Height) e da largura (Wdith) do botão. Execute o programa e redimensione o form para ver o que acontece com o botão.

Uma ferramenta de mão dupla

No exemplo que criamos até aqui escrevemos códigos para responder a eventos. Cada porção de código é parte de um procedimento diferente. O código fonte de um form é escrito em uma unit em FreePascal, nesse caso na unit u_alomundo.pas. O código aumenta não apenas quando escrevemos código para eventos, mas também quando adicionamos componentes ao form. As definições de propriedades e eventos do form e dos componentes adicionados são adicionados em um segundo arquivo denominado, nesse caso, u_alomundo.lfm.

O Lazarus pode ser definido como uma ferramenta de mão dupla, pois tudo que é feito no ambiente visual gera algum código. O desenvolvedor tem acesso total ao código gerado, e mesmo parecendo bastante complexo às vezes, é possível alterá-lo. Até se tornar um programador fluente em Lazarus, você pode continuar fazendo tudo visualmente.

Quando você altera o código dos componentes, isso se reflete visualmente no form. Só é preciso tomar algum cuidado.

Analisando o código fonte

Sempre que iniciamos um novo form o Lazarus tem uma unit com um código fonte associado como mostra a figura abaixo.

A unit usa (uses) algumas units que contém bibliotecas de procedimentos de funções do FreePascal. Também define uma nova classe. A nova classe é TForm1 e é derivada de TForm. Define também uma nova instância dessa classe: Form1.

Units são módulos nos quais uma aplicação é dividida. Quando iniciamos um novo projeto, o Lazarus gera um módulo program e uma unit que define o form principal. A cada vez que adicionamos um novo form ao programa, uma unit é adicionada. Por padrão as units tem extensão .PAS, os arquivos program tem a extensão .LPR e os arquivos de descrição de form tem extensão .LFM.

Assim que adiconamos 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:

Agora se a propriedade Name do botão from mudada para btnAloMundo, o código muda para:

A alteração de outras propriedades de um componente não modifica o código fonte da unit. As propriedades de form e seus componentes são armazenados em um arquivo de descrição de form com a extensão .LFM.

Adicionar código para tratar eventos causa maiores modificações no código fonte. Sempre que um novo manipulador de eventos é 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.

A descrição textual do form

Como vimos anteriormente o arquivo com extensão .LFM tem a descrição textual do form. Podemos visualizar e até alterar usando o editor. Para abrir clique com o botão direito no form e selecione a opção Mostrar Fonte (.lfm). Outra forma é simplesmente usando a opção Abrir do menu Arquivo. Vamos dar uma olhada nesse arquivo para entender o que é armazenado nele.

Como podemos observar o arquivo contém descrição de objetos. O primeiro deles é o form frmAloMundo, com suas propriedades. Um dos atributos de frmAloMundo é o botão btnAloMundo. Note também que podem existir conexões entre os eventos e procedimentos - neste caso o OnClick do botão. Procure não editar esse arquivo. Tudo que precisamos fazer é feito visualmente no form e é mais seguro.

Arquivo de Projeto

Quando iniciamos uma nova aplicação, além dos dois arquivos detalhados antes, o Lazarus cria automaticamente o arquivo de projeto - com a extensão .LPR. Raramente precisamos alterá-lo. Só modifique esse arquivo se você tiver certeza do que está fazendo. Faça uma cópia de toda a aplicação antes de modificá-lo para poder retornar se algo sair errado. Quando você compila a aplicação o Lazarus gera um executável com o mesmo nome do arquivo .LPR. Esse é o arquivo principal, o program. Se você observar esse arquivo verá que ai são criados os forms e executada a aplicação.

Lazarus - Configurando

O Lazarus vem com uma configuração padrão. Mas podemos alterar algumas opções para deixá-lo da maneira que preferirmos. Para fazer essas configurações selecione o menu Ambiente -> Opções. Na árvore de opções à esquerda selecione Cores sob o grupo Editor. Na caixa Esquema de Cores você pode selecionar o esquema desejado. Se estiver familiarizado com o Delphi, pode selecionar essa opção.

Quem utiliza o Delphi sabe que ele remove métodos vazios. Por exemplo, se você colocar um TButton, implementar um evento OnClick e depois remover a implementação, quando você salvar a unit ou compilar o projeto, o método será removido automaticamente. Por padrão o Lazarus não remove os métodos vazios. Para configurar essa opção selecione Características automáticas sob o grupo Editor e desmarque a caixa de verificação Auto remover métodos vazios.

 Durante o desenvolvimento, quando você executa seu programa com F9 por exemplo, e depois o encerra, é mostrada uma mensagem.

Podemos desativar essa janela podemos desmarcar a caixa de verificação Mostrar a mensagem na parada. Esta caixa é encontrada na opção Geral sob o grupo Depurador.

O Editor de Código pode ganhar uma barra de ferramentas muito útil. Para isso devemos instalar o pacote Editor Toolbar, componente que vem junto com o Lazarus. Para instalar esse pacote, selecione a opção Abrir arquivo de pacote (.lpk) no menu Pacotes. Localize o diretório lazarus\componentes\editortoolbar e abra o pacote editortoolbar.

Clique no botão Compilar e depois em Instalar. Sempre que um pacote for instalado o Lazarus é recompilado e reiniciado. Quando precisar instalar um pacote de componentes esse deve ser o procedimento.

Na complementação de código, por padrão, o Lazarus gera código sem espaços antes e depois do operador de atribuição. Em nome da legibilidade e organização do código é preferível que tenha um espaço antes e outro depois do operador. É possível configurar o IDE para fazer isso automaticamente para nós. Selecione a opção Espaço sob o grupo Ferramentas de código. Marque as três caixas de verificação conforme a figura.

Explore as possibilidades do IDE. Deixe o Lazarus do seu jeito.

Lazarus - o Ambiente

É importante conhecer os elementos do Ambiente Integrado de Desenvolvimento antes de realmente começar a criar nossas primeiras aplicações em Lazarus. Para conhecer detalhes do IDE leia aqui. Essa página é parte de um wiki em português e como tal, está em permanente atualização. Estamos contribuindo nesse site. A parte referente à Paleta de Componentes ainda não existia e por isso, estamos ajudando a fazê-la. Se vocês observarem, as imagens estão atualizdas para a versão mais recente do Lazarus.

Lazarus - Primeiros Passos

No post anterior falamos que Lazarus roda em várias plataformas. No entanto, optamos por utilizar o sistema operacional Windows. Sempre que possível indicaremos links para maiores informações sobre procedimentos em outros sistemas operacionais.

Obtendo e Instalando

Instalar o Lazarus utilizando os pacotes binários disponíveis em http://sourceforge.net/projects/lazarus/files/ é muito simples. Ai você pode encontrar versões para Win32 e Win64. Baixe sempre o último release e carregue o executável. A partir daí se segue uma instalação típica Windows. Serão instalados o compilador Free Pascal (FPC) e as bibliotecas necessárias. Se você tiver uma versão anterior instalada, tome a precaução de desinstalar antes. Você pode obter também os fontes com a versão mais recente no SVN. Para maiores informações acesse http://wiki.lazarus.freepascal.org/Getting_Lazarus/pt. Neste caso será necessário compilar para gerar o executável. No momento em que escrevia esse post o mais recente release disponível era 0.9.28.2. Por enquanto tudo o que precisaremos para iniciar nosso estudo está instalado. À medida que forem necessários outros componentes daremos detalhes de sua instalação.

Alô Mundo

Depois de instalado podemos executar o programa. Você deverá ficar com uma interface semelhante à figura abaixo.

Onde precisamos identificar alguns elementos básicos:
1 - Barra de Ferramentas - botões de atalho para opções mais comuns do menu.
2 - Paleta de Componentes - onde estão localizados os componentes nativos e de terceiros que são usados para criar visualmente ou não a aplicação
3 - Inspetor de Objetos - janela onde podem ser visualizadas/alteradas as propriedades e eventos do componentes.
4 - Form - onde são inseridos os componentes para construir a interface da aplicação.
5 - Editor de Código - local onde vamos inserir o código Free Pascal da aplicação.
Neste ponto podemos alterar o idioma da interface, se você preferir. Para isso selecione no menu a opção Environment -> Options. No formulário de Opções selecione Environment -> Desktop. Na caixa Language selecione Portuguese [pb] e pressione Ok. Feche o Lazarus e o inicie novamente.

Para iniciar um breve tour pelo ambiente vamos criar nossa primeira aplicação. Vamos criar uma versão do famoso "Alô Mundo", o primeiro programa que criamos quando estamos estudando uma nova linguagem. Para criar uma nova aplicação selecione no menu a opção Arquivo -> Novo. Em seguida marque Aplicação em Projeto e pressione Ok. Com isso teremos uma nova aplicação e um form pronto para receber novos objetos.

Por padrão o Lazarus gera um executável bastante grande (cerca de 12 Mbytes, no mínimo). Para resolver isso selecione no menu a opção Projeto -> Opções do Compilador. Clique na aba Vinculando e desmarque a opçãoMostrar número de linhas nos erros de Tempo de Execução ao rastreá-los (-gl). Pressione Ok. Isto deve ser feito sempre que uma nova aplicação é iniciada.

Posicionado no Inspetor de Objetos, localize a propriedade Caption e digite Alô Mundo e em Name digite frmAloMundo. Clique em Salvar Tudo. Crie um novo diretório, à unit dê o nome u_alomundo e ao projeto dê o nome AloMundo. Claro que esses nomes são todos sugestões.

Agora selecione um objeto TButton na paleta de componentes Standard. Posicione-o aproximadamente no centro do form, ou onde você preferir. Mude a propriedade Name do botão para btnAloMundo e a propriedade Caption para Alô Mundo. Agora dê um duplo clique no botão btnAloMundo. O editor de código será aberto no procedimento a ser executado quando o usuário pressionar nosso botão. Digite:

ShowMessage('Alô Mundo');

Pressione F9 para compilar e executar o programa. Depois de executar pressione o botão para visualizar a mensagem na tela.

Pronto ai está nosso primeiro programa feito em Lazarus. Simples assim.

Lazarus - Origens

Estou iniciando com este post uma série sobre Lazarus, um IDE código aberto alternativo ao Delphi.

Um pouco de história

Não existe muito registro sobre isso, mas Megido foi um projeto iniciado em 1998 para ser um clone de código aberto do Delphi. Esse projeto iniciou a partir do código fonte do Sybil, que era um clone do Delphi para OS/2. Em 1999 o Megido morreu. As pessoas envolvidas perderam o interesse em criar algo baseado no Sybil.
Três pessoas, inicialmente envolvidas e em seguida frustradas com o Megido, Cliff Baeseman, Shane Miller and Michael A. Hess, iniciaram então o Lazarus em fevereiro de 1999. Sendo que desses três, apenas Michal A. Hess continua no projeto.
Além de Michael, os membros mais antigos do time são Marc Weustink e Mattias Gaertner. Ambos são os maiores contribuidores para o núcleo do que é o Lazarus hoje.
Felipe Monteiro de Carvalho, brasileiro, aluno de engenharia da USP, iniciou no projeto em 2005. Entre outras coisas ele atualmente escreve um livro sobre Lazarus.

O que é Lazarus?

Lazarus é um IDE de código aberto para Free Pascal que emula o Delphi. Free Pascal é um compilador projetado para ter sintaxe similar ao Object Pascal e roda em Linux, FreeBSD, Mac OS X, Win32, Win64, WinCE, OS/2 e outros. Lazarus então permite desenvolver programas da mesma forma que Delphi, em várias plataformas, atualmente em Linux, Mac OS X, Win32, Win64 e WinCE. Desde que você escreve seu código em uma plataforma, pode compilar em qualquer outra onde exista Lazarus disponível.
Lazarus ainda não está completo. Muita coisa precisa ser feita. É um projeto grandioso e precisa de ajuda da comunidade.

E a licença de uso?

Free Pascal é licenciado sob GPL. O que significa que é código aberto, livre. Se você modificar o código deve disponibilizar essas alterações para a comunidade.
FCL e LCL, bibliotecas de componentes do Lazarus, estão licenciadas sob LGPL. Assim, você pode escrever seu próprio código proprietário que usa essas bibliotecas, vender sua aplicação sem a necessidade de tornar disponível seu código. No entanto se você modificar a FCL ou a LCL, você tem obrigação de publicar suas modificações para a comunidade.

De onde veio o nome?

Lazarus é uma figura bíblica que foi ressuscitado por Cristo após a morte. O projeto é chamado Lazarus pois ele foi iniciado ou ressuscitado da morte do Megido.

Leia mais aqui.

Histórias em quadrinhos na Web

É fantástico o que se pode fazer na web. Recentemente descobri um sítio onde podemos criar nossas próprias tirinhas em quadrinhos e inserir em um blog ou site, enviar por e-mail para os amigos, enfim, a finalidade que podemos dar a essa ferramenta depende exclusivamente da nossa imaginação. Vejam abaixo, visitem e experimentem.

Educação e Competição

Penso que educação e competição estão intimamente ligadas. Vamos tomar como exemplo um esporte: o voleibol, conhecido popularmente no Brasil como vôlei. O esporte surgiu em 1895 na Associação Cristã de Moços nos EUA. À medida que mais pessoas iniciaram a sua prática, as competições foram surgindo, gerando rivalidade entre os times. Para superar seus adversários os times precisam se preparar. Estudam-se novas técnicas e táticas, estudam-se a forma de jogar dos adversários. Tudo com o objetivo de vencer. Com isso criou-se um círculo virtuoso, competição - educação - competição. Uma realimenta a outra, o esporte se desenvolve e as pessoas envolvidas evoluem na sua prática. Hoje se vê junto ao banco de reservas dos times, alguém acompanhando atentamente o jogo, munido de um notebook e registrando tudo que acontece. Esse material é objeto de estudo posterior, para correção das falhas e aprimoramento do que está dando certo. Com a programação não deve ser diferente. Se o currículo dos cursos não é suficientemente desafiador, então os alunos devem ser encorajados a participar de competições. A competição, que gera rivalidade entre os times participantes, deve ser usada como motivação para o aprimoramento do aprendizado nas linguagens de programação e dos algoritmos. Duas competições são realizadas anualmente. A Olimpíada Internacional de Informática, destinadas a estudantes do ensino médio, e o ICPC (International Collegiate Programming Contest), organizado pela ACM (Association for Computer Machinery) e voltado para estudantes de cursos superiores. No curso de Sistemas de Informação do Centro Universitário Luterano de Santarém, temos realizado competições internas desde 2005, e com a participação de alunos de outras instituições desde 2008. Percebe-se claramente nos nossos alunos a vontade de se preparar para vencer os desafios. Não importa o que possam pensar os teóricos da educação, estou plenamente convencido da influência positiva das competições sobre a educação.

Aprendendo a ler em Inglês

Segundo o professor Rubens Queiroz de Almeida, não é muito difícil aprender a ler textos em inglês e não é necessário despender muito tempo para isso. Ele afirma que de 20 a 25% de um texto é composto de cognatos. Cognatos são aquelas palavras com grafia semelhante, tais como professional e certification. Além disso, Rubens também diz que as 250 palavras mais comuns do idioma inglês responde por aproximadamente 60% de um texto. Como os cognatos não estão entre as 250 palavras mais comuns, se conhecermos o significado dessas 250 palavras, seremos capazes de ler de 80 a 85% do texto. Mas, e os 20% restantes? Bem, pode-se usar a intuição. Ou podemos tentar deduzir o significado de uma palavra que faz parte desses 20%. Quando você lê um texto em português você recorre ao dicionário sempre que não sabe o significado de uma palavra? Bem, então mãos à obra. Se você aprender três palavras das 250 mais comuns, a cada dia, em menos de três meses você estará lendo com mais fluência. Neste link você irá encontrar a relação das 1.000 palavras mais comuns da lingua inglesa de acordo com um estudo de Rubens Queiroz.

Conhecimento especializado ou amplo?

Este texto foi inspirado em uma frase de um acadêmico: "Tirar do curso algumas disciplinas abobrinhas e substituir por...".
É certo que todos frequentam a escola para obter uma formação profissional. À medida que se vai avançando nos estudos, ocorre também um afunilamento no conhecimento, uma especialização. Durante o ensino fundamental e médio, o estudo é mais genérico. Estudam-se português, matemática, história, geografia, etc. Na graduação estudam-se disciplinas específicas do curso escolhido e mais algumas consideradas fundamentais (as "abobrinhas") para o complemento do aprendizado. E vou tentar justificar meu argumento do "porque" das disciplinas "abobrinhas". Para nosso sucesso profissional, é fato a importância de estabelecermos uma rede de relacionamentos, que os especialistas gostam de chamar de "network". Eu creio que até é possível estabelecer uma boa carreira relacionando-se apenas com pessoas que sabem tudo de computação, mas vou supor o seguinte cenário: Você é convidado para uma festa de casamento, por exemplo. Nesta festa você é apresentado a um médico, a um engenheiro civil e a um historiador. Se você se preocupou apenas em estudar computação, relegando a último plano as disciplinas complementares, como você conseguirá estabelecer um diálogo com essas pessoas? Penso que você deve ter um conhecimento mínimo acerca de determinados assuntos para que possa se relacionar. Todo conhecimento é importante. Você será muito melhor aceito em um grupo se conseguir dialogar de forma heterogênea. Será considerado um "bom papo". Acredite, isso abrirá muitas portas. Se você só consegue falar sobre computadores, chats, blogs, etc. é bem provável que seja chamado de "chato". Pense nisso, invista mais tempo no seu futuro aprendendo algumas "abobrinhas".

Lingua Inglesa é fundamental

C. Swaminathan, diretor de uma das principais universidades indianas, esteve no Brasil ano passado e defendeu o crédito estudantil e o ensino da língua inglesa para que nosso país faça uma revolução no ensino. Não é difícil diagnosticar isso. Sabemos do déficit de vagas no ensino público superior. Por isso os vestibulares, agora chamados processos seletivos, ainda persistem. Mudam a forma, mas o objetivo continua. As instituições privadas são finaceiramente inviáveis para a grande maioria. O PROUNI é um avanço nesse sentido. Mas muitos estão, e vão continuar, fora das universidades. Com relação à lingua inglesa, é notável a dificuldade que os docentes enfrentam com os alunos por esse motivo. Sou professor no ensino superior na área de Tecnologia de Informação e tenho que usar criatividade para me limitar em indicar apenas referências em lingua portuguesa. O futuro profissional deixa de ter contato com literatura original em inglês, seja na forma escrita ou na web, limitando seu conhecimento. Depois de formados esses profissionais terão um mercado de trabalho mais limitado ainda. Oportunidades apenas no âmbito regional ou nacional. Nem pensar em se candidatar a uma pós-graduação ou um trabalho fora do Brasil. Mesmo sem intervenção do governo nossos estudantes podem e devem se concientizar da necessidade dessa ferramenta e buscar por si mesmos o conhecimento. As escolas de lingua estrangeira são caras? Ok, existem sites na Internet que se propõem a ensinar gratuitamente. Livemocha é uma boa opção. Vamos em busca do que precisamos, não podemos ficar esperando apenas pelos governantes. Leia aqui a entrevista completa com Swaminathan.

Conversão de arquivos online

É constante nossa necessidade de fazer conversões de aquivos. Uns querem converter um docx em doc, um pdf em doc. Outros, um jpg em ico ou um wma em mp3. Certamente precisamos de vários conversores, um para cada categoria: textos, imagens, áudio, etc. Se pudermos ter um único software para fazer tudo isso é a solução ideal. E se pudéssemos fazer essas conversões sem ter que baixar software algum seria fantástico. Pois essa solução existe e funciona muito bem. É o Zamzar, um site para conversão online de arquivos livre de custos. Nele você faz o upload do arquivo a ser convertido, informa o tipo do arquivo no qual você deseja converter e um e-mail para receber o link de onde o resultado será baixado. Experimente.

Herança de formulários no Delphi

Suponhamos que estamos criando uma aplicação onde existem vários formulários com características e comportamento semelhantes. Um formulário (form) é uma classe, portanto suas características e comportamento podem ser herdados por outros formulários. Só precisamos criar um formulário e depois criar os outros a partir deste usando herança. Crie então o formulário que será o pai incluindo todos os componentes e métodos necessários. Depois vamos criar um novo formulário filho. Selecione no menu, File | New | Other... e clique na aba que tem o nome do seu projeto. Nessa aba aparecem todos os formulários que foram criados anteriormente na sua aplicação. Selecione aquele do qual você deseja herdar e pressione o botão OK. Um novo formulário é criado com tudo que o formulário pai tem. Importante notar que todo código escrito na unidade (unit) do formulário pai não aparece na unidade do formulário filho e você não pode alterar ou excluir qualquer objeto que tenha sido herdado. Agora você pode inserir novos objetos e métodos no formuláio filho. Note também que todo método de evento que você inclui no formulário filho apresenta uma nova palavra reservada, inherited:

procedure TfrmFilho.btnSairClick(Sender: TObject);
begin
inherited;

end;

Se você observar o arquivo de definição do formulário verá que, também, essa palavra aparece em vez da declaração object:

inherited frmFilho: TfrmFilho
Left = 222
Top = 139
Caption = 'frmFilho'
PixelsPerInch = 96
TextHeight = 13

Para ver o arquivo de definição de formulário clique com o botão direito do mouse e selecione View as text.

Processo Ágil para Pequenos Sistemas

O Grupo de Trabalho Ágil é um grupo de pesquisa do curso de Sistemas de Informação do Centro Universitário Luterano de Santarém. Esse grupo está trabalhando no desenvolvimento de um processo de desenvolvimento chamado batizado de P@PSI - Processo Ágil para Pequenos Sistemas. Esse processo tenta integrar o Scrum, um framework para gerência de projetos, práticas da Programação Extrema (XP) e fluxos do Processo Unificado. A idéia principal do projeto é disponibilizar um processo para ser utilizado nas disciplinas de Engenharia de Software e Desenvolvimento de Sistemas de Informação. Pois essa decisão tornará mais ágil o desenvolvimento no decorrer das disciplinas. Leia mais sobre o processo na primeira edição da revista técnico-científica do curso de Sistemas de Informação, Urissanê.