Páginas

quinta-feira, 7 de outubro de 2010

Lazarus – Herança de form e criação de componentes em run-time

Neste post vamos mostrar como criar um formulário de cadastro, independente da tabela do banco de dados. A idéia é que, ao abrir o formulário, um trecho de código identifica cada campo da tabela, instancia um TDBEdit para esse campo e ainda o identifica com um TLabel. Além do mais esse código será implementado em um formulário pai. Cada formulário de cadastro será derivado – ou herdado – deste. Nosso demo terá um form principal que chamará o form de cadastro, o form pai onde todas as ações irão acontecer, um form de cadastro derivado e um Data Module.
No Data Module colocamos os componentes de acesso ao banco de dados. Para isso iremos utilizar ZeosLib com banco de dados PostgreSQL. Coloque então um TZConnection para conectar ao seu banco de dados e o configure adequadamente. Coloque também uma TZQuery e um TZUpdateSQL. Consulte o post Lazarus – Conectando PostgreSQL com ZeosLib se tiver dúvida de como fazer essas definições. Não coloque TDataSource no Data Module. Iremos colocá-lo no form pai.

O form Pai

Já existe um form na aplicação. Vamos inserir um novo form e deixar esse primeiro para ser o principal. No novo form vamos criar a propriedade Query conforme mostra o código abaixo. Inclua a unit ZDataset na cláusula uses.

private
    { private declarations }
    fQuery: TZQuery;
    function GetQuery: TZQuery;
    procedure SetQuery(NewQuery: TZQuery);
  public
    { public declarations }
    property Query: TZQuery read GetQuery write SetQuery;
  end;

var
  frmDinamico: TfrmDinamico;
  vetorCampos: array of TDBEdit;
  vetorLabel: array of TLabel;

implementation

{$R *.lfm}

procedure TfrmDinamico.FormShow(Sender: TObject);
var
   Coluna : integer;
   NomeColuna : TDBEdit;
   NomeLabel : TLabel;
   Topo : integer;
begin
   Topo := 65;
   dsTabela.DataSet := fQuery;
   fQuery.Open;
   SetLength(vetorCampos, fQuery.FieldCount);
   SetLength(vetorLabel, fQuery.FieldCount);
   for Coluna := 0 to fQuery.FieldCount - 1 do
   begin
     NomeColuna := TDBEdit.Create(Self);
     NomeColuna.Parent := Self;
     NomeColuna.Left := 105;
     NomeColuna.Top := Topo;
     NomeColuna.Width := 15 + fQuery.Fields[Coluna].DisplayWidth * 7;
     NomeColuna.DataSource := dsTabela;
     NomeColuna.DataField := fQuery.Fields[Coluna].FieldName;
     NomeColuna.Tag := Coluna;
     Topo := Topo + 25;
     NomeColuna.Visible := True;
     NomeColuna.Name := 'DBEdit' + IntToStr(Coluna);
     vetorCampos[Coluna] := NomeColuna;

     NomeLabel := TLabel.Create(Self);
     NomeLabel.Parent := Self;
     NomeLabel.Left := 5;
     NomeLabel.Top := NomeColuna.Top - NomeLabel.Height;
     NomeLabel.Caption := fQuery.Fields[Coluna].DisplayName;
     NomeLabel.Tag := Coluna;
     NomeLabel.Visible := True;
     NomeLabel.Name := 'Label' + IntToStr(Coluna);
     vetorLabel[Coluna] := NomeLabel;
   end;
   if Topo + 25 > 445 then
      Height := 445
   else
      Height := Topo + 25;

end;

procedure TfrmDinamico.FormClose(Sender: TObject; var CloseAction: TCloseAction
  );
begin
  fQuery.Close;
  CloseAction := caFree;
end;

function TfrmDinamico.GetQuery: TZQuery;
begin
  Result := fQuery;
end;

procedure TfrmDinamico.SetQuery(NewQuery: TZQuery);
begin
  fQuery := NewQuery;
end;

Implemente os métodos GetQuery e SetQuery conforme mostrado no código. Na seção var declaramos dois arrays dinâmicos para receber os objetos TDBEdit e TLabel. Agora vamos analisar com mais detalhes o código do evento OnShow. É nesse código que serão criados os objetos em tempo de execução, de acordo com os campos da tabela. No post Lazarus - Criando componentes em run-time nós mostramos como criar componentes em tempo de execução.
Inicialmente no método nós definimos o tamanho dos arrays de acordo com o número de campos da tabela usando o procedure SetLength. Em seguida, dentro de um for que percorre os campos da tabela, é criado um TDBEdit e um TLabel para cada campo. Cada componente é guardado em seu array correspondente. Depois disso é verificada a necessidade de se aumentar a altura do form para que ele possa mostrar todos os componentes criados. Essa verificação é feita através da variável Topo que guarda a posição vertical de cada componente. Como o nosso form é dinâmico, nós liberamos a memória ocupada por ele assim que o mesmo for fechado.

Herdando o form Pai

Depois disso vamos criar o form de cadastro propriamente dito. Para isso selecione o menu File | New e clique em Inherited Component. Na caixa da direita irão aparecer os forms que podem ser herdados. Escolha o form Pai que foi criado anteriormente e pressione OK. Um novo form será criado com todos os membros do form Pai. Agora selecione a opção de menu Project | Project Options. Clique em Forms e transfira o form Filho para a caixa da direita. Isso determina que o form Filho será instanciado em tempo de execução. Para que tudo funcione perfeitamente no form Filho, devemos implementar os métodos herdados e informar a palavra chave inherited. No nosso caso precisamos implementar apenas os método dos eventos OnShow e OnClose, como mostra o código abaixo.

procedure TfrmCidade.FormShow(Sender: TObject);
begin
   inherited
end;

procedure TfrmCidade.FormClose(Sender: TObject; var CloseAction: TCloseAction);
begin
   inherited
end;            

Para testar nosso demo, vamos ao form principal. Coloque um botão e escreva o seguinte código no evento OnClick.

if TfrmCidade(Application.FindComponent('frmCidade')) = nil then
  frmCidade := TfrmCidade.Create(Application);
frmCidade.Query := dmDados.queCidade;
frmCidade.Show;

Estamos supondo que o nome do form Filho é frmCidade, que o nome do Data Module é dmDados e que a TZQuery no Data Module chama-se queCidade. Pronto você pode executar o programa e pressionar o botão. Você terá uma tela assim:



Você pode agora repetir esse procedimento para todas as tabelas que precisem de formulários de cadastro. Bem, certamente não é um form de cadastro perfeito, pois todos os campos são definidos com TDBEdit, mas a partir daqui você pode tentar vôos mais altos.

segunda-feira, 27 de setembro de 2010

Lazarus - AutoCommit no ZeosLib com PostgreSQL

Por padrão, o PostgreSQL trata cada comando SQL como sendo executado dentro de uma transação. Ou seja, cada comando DML (INSERT, UPDATE ou DELETE) tem um comando de início de transação (BEGIN) e um comando COMMIT – caso seja bem sucedido – executados implicitamente antes e depois. Para a execução de múltiplos comandos DML isso leva a um overhead. Desta forma, sugere-se fortemente envolver todos os comandos DML em uma única transação – se a lógica da sua aplicação permitir. Para demonstrar esta recomendação fizemos um teste simples. Escrevemos um pequeno programa para inserir 5.000 linhas em uma tabela. Primeiro fizemos o teste com o controle de transação padrão - cada uma das 5.000 linhas tem seu próprio BEGIN e COMMIT - e depois modificamos o código para controlar a transação manualmente. Neste último teste todas as 5.000 linhas são inseridas dentro de uma única transação.
Para nosso teste usamos ZeosLib. Por padrão o ZeosLib também opera no modo Auto-Commit, ou seja, cada comando é executado no contexto de uma transação. Não mostraremos aqui como conectar ao PG usando Zeos, pois isso já foi apresentado no post Lazarus - Conectando PostgreSQL com ZeosLib. Vejamos o primeiro teste. A unit Dateutils deve ser incluida na cláusula uses para poder usar a função
MilliSecondsBetween(). dbBanco é um ZConnection, dmDados é um Data Module e queCidade uma ZQuery.

var
  i: integer;
  a, b: TDateTime;
begin
  dmDados.queCidade.SQL.Clear;
  dmDados.queCidade.SQL.Add('insert into cidade values (:id, :nome)');
  a := time;
  for i := 1 to 5000 do
  begin
    dmDados.queCidade.ParamByName('ID').Value:= i;
    dmDados.queCidade.ParamByName('NOME').Value:='SANTAREM';
    dmDados.queCidade.ExecSql;
  end;
  b := time;
  ShowMessage(IntToStr(MilliSecondsBetween(b,a)));
end;

Neste primeiro código o tempo médio de inserção das 5.000 linhas foi de 11,6 segundos. Alteramos então nosso código para que todas as linhas fossem inseridas dentro de uma única transação. Para isso chamamos StartTransaction antes de iniciar os INSERTs. Observe o código abaixo.

var
  i: integer;
  a, b: TDateTime;
begin
  a := time;
  dmDados.queCidade.SQL.Clear;
  dmDados.queCidade.SQL.Add('insert into cidade values (:id, :nome)');
  dmDados.dbBanco.StartTransaction;
  for i := 1 to 5000 do
  begin
    dmDados.queCidade.ParamByName('ID').Value:= i;
    dmDados.queCidade.ParamByName('NOME').Value:='SANTAREM';
    dmDados.queCidade.ExecSql;
  end;
  dmDados.dbBanco.Commit;
  b := time;
  ShowMessage(IntToStr(MilliSecondsBetween(b,a)));
end;

Neste caso o tempo médio de execução do código foi de 2,9 segundos. Um ganho de tempo considerável em relação à execução em modo padrão.
Fizemos também um teste usando TZUpdateSQL, implementado de acordo com o post citado acima. O código é apresentado em seguida e o tempo médio de execução foi de 3,8 segundos. Um desempenho um pouco pior do que o teste anterior.

var
  i: integer;
  a, b: TDateTime;
begin
  a := time;
  dmDados.queCidade.Open;
  dmDados.dbBanco.StartTransaction;
  for i := 1 to 5000 do
  begin
    dmDados.queCidade.Insert;
    dmDados.queCidade.FieldByName('ID').Value := i;
    dmDados.queCidade.FieldByName('NOME').Value:='SANTAREM';
    dmDados.queCidade.Post;;
  end;
  dmDados.dbBanco.Commit;
  b := time;
  ShowMessage(IntToStr(MilliSecondsBetween(b,a)));
end;

Estes teste foram feitos em Windows e servidor de BD e cliente rodando na mesma máquina. Certamente se você executar esses testes em outro ambiente, os tempos serão diferentes, mas comparativamente você deverá chegar à mesma conclusão.
Sabe-se que uma falha no sistema, enquanto uma transação estiver ativa, causa a execução de um ROLLBACK pelo SGBD, fazendo com que todas as atualizações feitas a partir do BEGIN sejam canceladas. Portanto, use esta recomendação com cautela e bom senso. Longas transações ativas estão sujeitas a perdas de dados muito maiores que transações curtas, em caso de falhas no sistema.

Atualizado em 28/09/2010.

quarta-feira, 18 de agosto de 2010

Lazarus - Aplicação WinCE usando tabelas DBF

Há algum tempo eu escrevi um artigo aqui no blog chamado Lazarus - Criando uma aplicação para WinCE. Nesse artigo usei SQLite para WinCE. E a implementação tinha bastante código pois usava a unit sqlite3ds. Agora vou mostrar que é possível desenvolver usando tabelas Dbase, aquelas que tem a extensão DBF. Para isso vamos usar o componente TDbf da aba Data Access. A seguir os passos necessários:

1) Crie uma tabela Dbase.
2) Inicie uma nova aplicação e coloque um TDbf no DataModule. Na propriedade TableName localize a tabela que foi criada.
3) Nas propriedades FilePath e FilePathFull ele vai automaticamente definir o caminho do PC onde está a tabela. Depois vamos resolver isso.
4) Coloque um TDataSource no Data Module e faça a associação necessária com o TDbf.
5) Agora vamos ao form da interface e coloque os controles (da aba Data Controls) necessários para cada campo da tabela. Associe a propriedade DataSource de cada controle com o DataSource inserido no passo 4. Na propriedade DataField você pode digitar o nome do campo da tabela DBF ou, se a tabela estiver ativa, selecionar na caixa combinada. Lembre que neste form deve ser incluida a linha uses referente a unit do Data Module.
6) Coloque um TDBNavigator e ligue a propriedade DataSource adequadamente.
7) No evento OnShow do form digite o seguinte:

dbf1.FilePath := '';
dbf1.FilePathFull := '';
dbf1.Open;

Se você tiver mudado a propriedade Name do TDbf, substitua o dbf1 no código acima pelo nome que você escolheu.
Para compilar um projeto WinCE é necessário fazer algumas configurações em Project -> Project options. Na opção Paths abaixo de Compiler Options selecione wince em LCL Widget Type (various). Na opção Code generation escolha WinCE em Target OS (-T) e arm em Target CPU family (-P). Pronto. O compilador irá gerar um executável que executa apenas no PDA. Dessa forma para compilar use sempre CTRL + F9. Nos testes eu usei o Lazarus 0.9.29. Se você utiliza a versão 0.9.28 o caminho para essas configurações está em Project -> Compiler options.
Copie o executável e a tabela para o PDA e execute. Pronto, simples assim. Fiz testes com sucesso em um PDA com WM 5 e no emulador WM 6.

sexta-feira, 9 de julho de 2010

Lazarus - Relatório Mestre detalhe com LazReport

Neste post iremos mostrar como criar um relatório mestre detalhe usando o componente LazReport. No artigo Lazarus - Criando relatórios com FortesReport (Parte I) mostramos como instalar o LazReport. Para o exemplo que será criado aqui usaremos o banco de dados Firebird e o conjunto de componentes ZeosLib. Use o seguinte script para criar as tabelas.

O Data Module

Inicie uma aplicação no Lazarus e insira um Data Module. Selecione a aba Zeos Access e coloque um TZConnection no Data Module. Defina as propriedades da seguinte forma:

Database - informe o banco de dados Firebird que foi criado.
Name - dê um nome ao componente. Por exemplo: dbVendas.
Password - masterkey.
Protocol - firebird-2.0 ou a versão que está sendo usada.
User - sysdba.

Mude Connected para true, para verificar se a conexão está configurada corretamente.
Coloque um TZReadOnlyQuery e defina:

Connection - selecione o TZConnection.
Name - defina um nome para o componente. Por exemplo: queVenda.
SQL - select a.id_venda, a.data_venda, b.nome from venda a, cliente b where a.id_cliente = b.id_cliente.

Selecione a aba Data Access e coloque um TDataSource, onde DataSet deve estar associado à Query anterior. Defina Name como dsVenda.

Coloque um segundo TZReadOnlyQuery, defina Connection da mesma maneira e em Name digite queItem, por exemplo. Na propriedade SQL informe select a.id_produto, b.nome, a.quantidade, b.preco_venda, a.quantidade * b.preco_venda total from item a, produto b where a.id_produto = b.id_produto and id_venda = :id_venda.

Defina a propriedade DataSource desta Query com dsVenda. Isto, juntamente com o parâmetro :id_venda definem o relacionamento mestre detalhe entre as duas Queries. O parâmetro :id_venda é definido por queVenda através de dsVenda.

Coloque mais um TDataSource e defina a propriedade DataSet com a Query queItem. Defina Name como dsItem. Salve o Data Module e chame a unit de u_dmdados. Leia mais para conexão com Firebird em Lazarus - Conectando Firebird com SQLdb ou ZeosLib.

O relatório

No form onde será criado o relatório digite logo abaixo de Implementation a linha uses u_dmdados. Localize a aba LazReport e coloque um TfrDBDataSet e defina sua propriedade DataSource como dsVenda, e na propriedade Name digite frDBVenda. Coloque outro TfrDBDataSet e defina sua propriedade DataSource como dsItem, e na propriedade Name digite frDBVenda. Coloque um TfrReport e, na propriedade DataSet informe frDBVenda. Agora coloque um TfrDesigner. Dê um duplo clique no frReport. A seguinte tela deverá aparecer:


Este é o designer do LazReport. Insira uma banda e escolha o tipo Page Header. Coloque um objeto Text e informe o título do cabeçalho, por exemplo, Relação de Vendas. Escolha um tamanho de fonte e centralize o objeto adequadamente na banda.
Insira nova banda e escolha o tipo Master Data. Ele vai abrir uma janela solicitando a escolha de um DataSet. Escolha frDBVenda.


Insira objetos Text de forma que a banda fique como na figura acima. Em um objeto Text é possível digitar um texto, informar uma variável ou um campo de tabela. Do DataSet frDBVenda, informamos o ID, a DATA e o NOME do cliente. Os objetos restantes são todos textos.
Insira outra banda e escolha o tipo Detail Data. Escolha o DataSet frDBItem. Coloque cinco objetos Text e informe os campos ID_PRODUTO, NOME, QUANTIDADE, PRECO_VENDA e TOTAL. Para formatar PRECO_VENDA e TOTAL informe Text da seguinte forma:

[dmDados.zqItem."PRECO_VENDA" #N##,##0.00]


Insira nova banda e selecione o tipo Detail Footer. Coloque dois objetos Text. Em um deles informe Total da venda: No segundo digite:

[SUM([dmDados.zqItem."TOTAL"]) #N##,##0.00]

Esse campo somará o total da venda e o mostrará formatado. Salve o relatório. Dê a ele o nome venda.lrf, por exemplo. Feche e volte ao form. Coloque dois botões. Em um deles digite Editar no Caption. Dê um duplo clique nele e digite no editor de código:

frVenda.LoadFromFile('vendas.lrf');
frVenda.DesignReport;


Esse botão permitirá alterar o desenho do relatório. No segundo botão digite Preview no Caption. Dê um duplo clique e digite no editor de código:

frVenda.LoadFromFile('vendas.lrf');
frVenda.ShowReport;


Este é o botão que visualizará o relatório na tela, conforme mostra a figura a seguir:

quarta-feira, 23 de junho de 2010

Lazarus - Dicas de LazReport

Neste post vou apresentar algumas dicas para criar relatórios com mais eficiência em LazReport. No post Lazarus - Criando relatórios com FortesReport (Parte I) eu mostrei como instalar o LazReport e o link para um tutorial que ensina passo a passo como criar um relatório.

Exportando um relatório para PDF

Esse é um procedimento bastante simples, mas é necessário instalar dois pacotes. Para exportar um relatório para PDF você precisa do LazReportPDFExport. Este componente está em source\addons\pdfexport no mesmo diretório do LazReport. Mas este componente depende do PowerPDF. Você pode fazer o download do pacote PowerPDF no repositório de componentes e código Lazarus. Instale o PowerPDF e depois o LazReportPDFExport. O PowerPDF irá aparecer em uma nova aba de componentes e o LazReportPDFExport será um novo componente -TfrTNPDFExport - na aba do LazReport.
Supondo que você já criou o relatório, coloque um TfrTNPDFExport no mesmo form onde está o TfrReport. Execute o seu programa e visualize o relatório. Clique no botão Save report. Clique na caixa Tipo e deve aparecer a opção Adobe Acrobat PDF (*.pdf). Selecione esta opção, dê um nome ao arquivo e pressione o botão Salvar. Agora você tem um arquivo pdf com o seu relatório. Também existem componentes que permitem você exportar para HTML ou CSV.

Object Inspector

Semelhante ao Object Inspector do Lazarus, com ele podemos manipular propriedades de alguns objetos, tais como: nome, posição, tamanho e visibilidade. No LazReport ele é tratado como uma ToolBar. Pode ser mostrado ou ocultado. Para mostrar a janela do Object Inspector selecione Tools -> ToolBars -> Object Inspector. Depois simplesmente selecione um objeto no relatório para visualizar/alterar suas propriedades.

Destacando objetos

Em certos relatórios pode ser necessário mudar a cor da fonte e/ou do fundo de objetos, baseado em certas condições. Para isso selecione o objeto alvo e pressione o botão Highlight attributes na barra de ferramentas de formatação de texto, como mostra a figura abaixo.


Vamos supor que tenhamos um relatório de vendas mensais efetuadas pelos vendedores de uma loja e que a meta para aquele mês seja 10.000 reais. Então, queremos que os valores abaixo de 10.000 apareçam com fonte em vermelho. Na caixa de texto Condition da janela Highlight attributes informe Value < 10000. Selecione a cor da fonte e/ou a cor de fundo e pressione o botão OK. Veja a figura seguinte. Agora o relatório irá mostrar os valores de venda menores que 10.000 em vermelho. Condições mais complexas podem ser criadas usando o recurso de script que será apresentado mais adiante.


Programando eventos

Em certos casos pode ser necessário imprimir dados que não estão em bancos de dados. Uma opção é usar os eventos do componentes TfrReport. Dois desses eventos são OnGetValue e OnEnterRect. OnGetValue ocorre toda vez que um objeto Text encontra uma variável e precisa atribuir um valor a ela. Se a variável não possuir um valor então esse valor é definido através de código, por exemplo:

procedure TForm1.frReport1GetValue(const ParName: String; var ParValue: Variant);
begin
  if ParName = 'Variavel1' then
     ParValue := 100;
end;

Onde ParName tem o nome da variável como string e ParValue recebe o valor dessa variável. Por sua vez o evento OnEnterRect acontece antes que um objeto seja desenhado. Podemos, por exemplo, imprimir um dado bem específico em uma linha ou coluna do relatório.

procedure TForm1.frReport1EnterRect(Memo: TStringList; View: TfrView);
begin
  if (FCol=3)and(FRow=3) then
    view.Memo.Text := 'ALO';
end;

FCol e FRow definem uma coluna e uma linha do relatório respectivamente. No exemplo será impressa a palava ALO na linha 3 e coluna 3.

Programando um script

LazReport possui um interpretador interno semelhante ao Pascal que tem as seguintes características:

  • Operador de atribuição (:=);
  • Estruturas if ... then ... else, while ... do e repeat ... until;
  • Delimitadores de blocos begin e end;
  • Variávies não tipadas;
  • Acesso aos objetos do LazReport e suas propriedades.
Sempre que um objeto ou banda for impresso, o script associado a ele é executado. O editor de script é acessível no editor memo sempre que a caixa Script estiver marcada. Para visualizar o editor memo de um objeto como Text, por exemplo, basta dar um duplo clique nele. Em uma banda tecle CTRL + ENTER. Veja o editor memo abaixo com o editor de script habilitado.


Algumas propriedades de objetos visuais que podem ser usadas nos scripts são:

Visible - determina a visibilidade do objeto (boolean);
FillColor - determina a cor de fundo do objeto. Valores possíveis: clRed, clBlue, etc.;
Text - conteúdo do memo;

Objetos Text tem também as seguintes propriedades:

FontName, FontSize, FontColor - nome, tamanho e cor da fonte;
FontStyle - estilo da fonte (1 - itálico, 2 - negrito e 3 - sublinhado);
Adjust - alinhamento do texto (1 - direita, 2 - centro).

Por exemplo, voltando ao nosso relatório de vendas, vamos supor que queremos imprimir em verde os valores acima do dobro da meta, em vermelho os valores abaixo da meta e em azul os demais. O código ficaria como abaixo, supondo que o valor seja dado por [TotalVendas]:

if [TotalVendas] < 10000 then 
   FontColor := clGreen 
else if [TotalVendas] < 20000 then 
   FontColor := clBlue 
else 
   FontColor := clRed;

Vamos continuar explorando os recursos do LazReport. No próximo post vamos mostrar como criar um relatório mestre-detalhe.

domingo, 13 de junho de 2010

Java - Strings, memória e imutabilidade

O entendimento sobre pilha e heap pode facilitar em muuito a compreensão de temas como passagem de parâmetros, polimorfismo, garbage collector, etc. Mas neste post darei apenas uma rápida visão para poder falar o assunto principal que é a forma como Java trata os objetos String.
Em geral, variáveis de instância, objetos e arrays - que também são objetos - residem no heap. Já as variáveis locais, tanto de tipos primitivos quanto as referências, residem na pilha.
Sabemos que uma String pode ser instanciada de várias maneiras, como nestes exemplos:

String s = new String("abcd");   // ou
s = "abcd";

Para que o uso da memória seja mais eficiente em Java, a JVM mantém uma área especial de memória chamada pool de Strings constantes. Quando o compilador encontra um literal String, ele verifica se existe uma String idêntica no pool. Se existir, a referência ao novo literal é direcionada à String existente e não é criado novo objeto String. Mas quando um objeto String é criado usando new, por exemplo:

String s = new String("abc"));

Esse novo objeto é criado no heap - a memória onde residem todos os objetos em Java - e "abc" é inserida no pool de Strings constantes, se não existir.. Além disso, as Strings são imutáveis. Por exemplo:

String s = "abc";
s.concat("def"); // concatena o argumento ("def") à String "abc"

Nesse momento Java cria uma nova String com o valor "abcdef", mas ela fica perdida na memória, pois a variável s não muda seu valor e continua valendo "abc". No entanto se a segunda linha for alterada para:

s = s.concat("def");

Então s passará a valer "abcdef". A variável s será uma nova String. A String "abc" fica perdida na memória. Ou seja, se o resultado da expressão não for atribuido a uma variável seu valor será perdido. Analise esse código:

String s1 = "abc";
String s2 = "abc";
String s3 = "abc";
s3 = s3.concat("def");
System.out.println(s1 + " " + s2 + " " + s3);

Inicialmente as Strings s1, s2, s3 referem-se ao mesmo objeto no pool, pelo que foi exposto acima.  No entanto, diferente do que possamos pensar, quando criamos um novo objeto e o referenciamos com s3, os valores de s1 e s2 não se alteram pelo princípio da imutabilidade.
A classe StringBuffer se comporta de forma diferente. Ela não é imutável.

String sb1 = new StringBuffer("abc");
String sb2 = new StringBuffer("abc");
String sb3 = new StringBuffer("abc");
sb3.concat("def");
System.out.println(sb1 + " " + sb2 + " " + sb3);


Mesmo o código acima produzindo o mesmo resultado do código usando String, a explicação é que sb1, sb2 e sb3 são três objetos diferentes. Observe que este código produz algo diferente, pois agora só existe um objeto e três referências:

StringBuffer sb1 = new StringBuffer("abc");
StringBuffer sb2 = sb1;
StringBuffer sb3 = sb2;
sb3.append("def");
System.out.println(sb1 + " " + sb2 + " " + sb3);

Espero que o comportamento de Strings em Java tenha ficado mais claro para você. Leia mais sobre strings no tutorial sobre strings no site da Sun.

segunda-feira, 7 de junho de 2010

Lazarus - Conectando Oracle com SQLdb ou ZeosLib

A Oracle oferece uma versão free do Oracle Database 10g. É o Oracle Database 10g Express Edition. Utilizamos esta versão neste artigo. Além disso, utilizamos a versão 0.9.29 do Lazarus, Free Pascal 2.4.1 e ZeosLib 7.0.0.
Para os testes usamos o usuário do Oracle hr, que é criado em uma nova instalação. Depois de instalado o banco de dados, o usuário hr deve ser desbloqueado pelo DBA e definida uma senha. Esse usuário tem acesso às tabelas do schema hr, também instalado junto com o banco. No entanto criamos uma nova tabela para os testes, de forma a manter as tabelas originais inalteradas. Criamos então nossa famosa tabela CIDADE.

CREATE TABLE  "CIDADE" 
   ( "ID_CIDADE" NUMBER NOT NULL ENABLE, 
 "NOME" VARCHAR2(40), 
  CONSTRAINT "CIDADE_PK" PRIMARY KEY ("ID_CIDADE") ENABLE
   )

Existe ferramenta de administração visual na instalação do Oracle, mas não é objetivo deste artigo expor a utilização da mesma.

Conexão com SQLdb

Para fazer a conexão vamos usar como sempre um Data Module onde os componentes de banco de dados serão colocados.

Localize na aba SQLdb o componente TOracleConnection e coloque no Data Module. Defina suas propriedades como segue:

DatabaseName - informe aqui o SID do banco de dados. No nosso caso é XE, o SID do Oracle Database Express Edition.
Hostname - informe o nome ou IP da máquina onde está o servidor do banco de dados. Como meu teste foi feito na máquina onde está o servidor, eu informei localhost, ou poderia ter informado 127.0.0.1.
Password - informe a senha do usuário hr. Ou de qualquer usuário com acesso ao banco de dados.
UserName - informe hr, ou outro usuário com acesso ao banco de dados.
Para fazer um teste na conexão, mude a propriedade Connected para True. Depois volte para False.

Coloque um TSQLTransaction e defina a propriedade Database com o nome do TOracleConnection que foi colocado anteriormente.

Coloque um TSQLQuery. Defina suas propriedades como mostrado a seguir:

Database - selecione o TOracleConnection anterior.
SQL - informe SELECT * FROM CIDADE.

Finalize colocando um TDataSource da aba Data Access. Defina a propriedade DataSet com a SQLQuery colocada antes.
No evento AfterPost da TSQLQuery digite o código:

SQLQuery1.ApplyUpdates;
SQLTransaction1.CommitRetaining;

No evento AfterDelete selecione o mesmo método para não repetir código.
Pronto. Está feita a configuração de acesso, tanto para leitura quanto para escrita, em uma tabela do Oracle. Crie uma interface seguindo os passos descritos no post Lazarus - Acessando banco de dados com SQLdb - Parte I.
Lembre de abrir a conexão. Pode ser no evento OnCreate do Data Module, com o código:

OracleConnection1.Open;

Conexão com ZeosLib

Coloque um TZConnection no Data Module. Defina as propriedades:

AutoCommit - deixe em True para que as transações no banco sejam comitadas automaticamente.
Database - informe o nome ou IP da máquina do servidor do banco de dados, por exemplo: localhost se estiver na mesma máquina.
HostName - informe o SID do banco de dados. XE no nosso caso. Observe que as propriedades HostName e Database são informadas de forma invertida em relação ao SQLdb.
Password - informe a senha do usuário com acesso ao banco. Neste caso foi usado hr.
Protocol - informe oracle ou oracle-9i. Ambos funcionam.
User - informe o nome do usuário. Neste caso é hr.

Mude Connected para True para testar a conexão. Depois de conectar com sucesso volte Connected para False.

Coloque um TZQuery e um TZUpdateSQL e configure-os como foi feito no artigo Lazarus - Conectando PostegreSQL com ZeosLib.
No TZUpdateSQL defina essas propriedades assim:

DeleteSQL - DELETE FROM CIDADE WHERE ID_CIDADE = :OLD_ID_CIDADE;
InsertSQL - INSERT INTO CIDADE VALUES (:ID_CIDADE, :NOME);
ModifySQL - UPDATE CIDADE SET NOME = :NOME WHERE ID_CIDADE = :OLD_ID_CIDADE;


Coloque um TDataSource da aba Data Access e na propriedade DataSet selecione a TZQuery anterior. Está pronta nossa conexão e acesso a uma tabela. Agora crie a interface com nos posts anteriores. Não esqueça de abrir a conexão com o comando:

ZConnection1.Connect;

Pode ser no evento OnCreate do Data Module.

quinta-feira, 27 de maio de 2010

Tipos de dados no SQLite

Em SQLite, diferente de outros motores de banco de dados, o tipo de dado de um valor está associado com o valor propriamente dito, e não com o seu contêiner. É um sistema de tipo dinâmico. Um campo de uma tabela em SQLite pode receber qualquer tipo de dado. Assim, o SQLite simplesmente ignora o tipo informado no comando CREATE TABLE.
Então, dizemos que no SQLite existem classes de armazenamento. E essas classes são:

NULL - como em qualquer outro banco de dados.
INTEGER
- inteiro com sinal, armazenado em 1, 2, 3, 4, 6 ou 8 bytes dependendo da grandeza do valor.
REAL - valor de ponto flutuante armazenado em 8 bytes.
TEXT - uma string armazenada usando UTF-8, UTF-16BE ou UTF-16LE.
BLOB - armazena um blob, como indica o nome.

Uma coluna INTEGER PRIMARY é uma exceção. Só aceita números inteiros. Qualquer valor em um comando SQL tem uma classe de armazenamento implícita. Durante a execução do comando SQL, o SQLite pode converter valores entre classes numéricas (INTEGER e REAL) e TEXT.

Tipo Boolean

Não existe uma classe Boolean. Pode-se considerar os inteiros 0 (false) e 1 (true).

Tipos Data e Hora

Não existem classes de armazenamento para armazenar data e/ou hora. Existem funções capazes de tratar TEXT, REAL ou INTEGER como data e hora:

TEXT - como string ISO8601 ("YYYY-MM-DD HH:MM:SS.SSS").
REAL - como dias Julianos. A origem (dia 0) é o meio dia de 24 de novembro de 4714 A.C., pelo calendário Gregoriano.
INTEGER - como a hora no Unix. A origem é o dia 1º de janeiro de 1970.

Funções de Data e Hora

São cinco as funções:

date(timestring, modifier, modifier, ...) - retorna a data no formato YYYY-MM-DD.
time(timestring, modifier, modifier, ...) - retorna a hora no formato HH:MM:SS.
datetime(timestring, modifier, modifier, ...) - retorna data e hora no formato "YYYY-MM-DD HH:MM:SS".
julianday(timestring, modifier, modifier, ...) - retorna do dia Juliano.
strftime(format, timestring, modifier, modifier, ...) - retorna a data formatada de acordo com o formato especificado no primeiro argumento.

Todas recebem uma string de tempo e 0 ou mais modificadores como argumentos. Uma string de tempo pode ter um dos seguintes formatos, além de outros que podem ser encontrados em http://www.sqlite.org/lang_datefunc.html:

YYYY-MM-DD
YYYY-MM-DD HH:MM:SS
HH:MM
HH:MM:SS
now

O formato 'now' é convertido na data e hora correntes. Por exemplo:

SELECT date('now'); - calcula da data corrente.

Os modificadores alteram a string de data e hora. Alguns dos modificadores disponíveis são:

NNN days
NNN hours
NNN minutes
NNN.NNNN seconds
NNN months
NNN years
start of month
start of year

Os primeiros seis modificadores simplesmentes adicionam a quantidade de tempo especificada à data e hora especificadas pela string de tempo. Por exemplo:

SELECT date('now', '+1 days'); - calcula a data corrente mais um dia.
SELECT date('now', 'start of month'); - calcula o primeiro dia do mês corrente.

O parâmetro formato pode assumir alguns desses valores:

%d - dia do mês
%H - hora (de 00 a 24)
%J - dia Juliano
%w - dia da semana de 0 a 6 (domingo = 0)

Por exemplo:

SELECT strftime('%J', 'now'); - calcula o dia Juliano equivalente à data corrente.

Este post foi baseado no texto original em inglês em http://www.sqlite.org/datatype3.html.

quinta-feira, 20 de maio de 2010

Lazarus - Aplicação embarcada com Firebird e ZeosLib

Uma aplicação embarcada, ou embutida, com Firebird é uma aplicação que não necessita do servidor de banco de dados para executar. É uma solução excelente para criar demos de programas, criar um catálogo de produtos em CD, entre outras aplicações. Resumidamente, o motor do Firebird embedded está em uma dll.
A versão embedded do Firebird executa apenas em modo local, não reconhecendo nem mesmo localhost. Ela ignora qualquer instância do Firebird executando na mesma máquina. Procure usar sempre o usuário SYSDBA para a conexão com o banco. Como não existe a figura de um servidor de banco de dados, você poder rodar quantas aplicações forem necessárias. Cada uma será uma instância diferente. Tudo depende da memória da máquina.

Instalação do Firebird

O primeiro passo consiste em fazer o download da versão embarcada do Firebird. Escolha a versão e a plataforma desejada em http://www.firebirdsql.org/index.php?op=files. Vamos mostrar aqui apenas o procedimento para o ambiente Windows. Você deve baixar a versão embedded. Por exemplo, se optar pela versão 2.1.3, você pode baixar este zip. Depois disso, crie um diretório (p.ex. C:\MeuPrograma) onde ficará sua aplicação e descompacte o zip que você baixou dentro dele. Esse diretório será o home do Firebird embutido. O banco de dados deve ficar nesse mesmo diretório. Em seguida faça o seguinte:
1) Edite o arquivo firebird.conf e modifique a seguinte linha para ficar assim:

RootDirectory = C:\MeuPrograma

2) Altere o nome do arquivo fbembed.dll para fbclient.dll, se você for usar o ZeosLib. Se for usar o SQLdb, renomeie para gds32.dll.

Se sua aplicação utilizar UDFs, copie-as para o diretório UDF. Collates e charsets devem ser copiados para o diretório INTL.

Conectando ao banco de dados com ZeosLib

Coloque um TZConnection no Data Module. Defina as seguintes propriedades assim:

Database - informe apenas o nome do arquivo do banco de dados.
HostName - deixe em branco.
Name - dbEmbutido, por exemplo.
Password - masterkey.
Protocol - firebird-2.0.
User - sysdba.

Não tente conectar ao banco em tempo de desenvolvimento. Não irá conectar. Escreva o seguinte código no evento OnCreate do Data Module:

dbEmbutido.Connect;

Os outros procedimentos são exatamente os mesmos de uma conexão normal como mostramos em Lazarus - Conectando Firebird com ZeosLib ou SQLdb. Para construir uma interface leia os posts Lazarus - Acessando banco de dados com SQLdb - Parte I e Parte II.Se preferir usar SQLdb para embarcar sua aplicação siga exatamente o mesmo procedimento do post anterior. Só lembre de renomear fbembed.dll para gds32.dll.

Atualizado em 23/05/2010.

sábado, 15 de maio de 2010

Lazarus - Criando componentes em run-time

A primeira pergunta que alguém pode fazer é "Por que eu preciso criar componentes em tempo de execução?" Posso dar vários motivos e vou citar apenas dois. Primeiro: suponhamos que você permita que o usuário do seu sistema crie novos campos em um tabela. Para que ele possa usar esses novos campos são necessários novos componentes no form, correto? Segundo: eu quero criar um relatório genérico que possa imprimir dados de qualquer tabela. Apenas em tempo de execução eu irei saber quais e quantos componentes eu irei usar nesses casos. Então vamos à prática. Para nosso exemplo irei criar um botão da classe TButton. Mas poderia ser qualquer componente que você precise criar.

Criando um TButton em tempo de execução

A primeira coisa a fazer é declarar uma variável para o botão, por exemplo:

Botao: TButton;

Pode ser necessário incluir a unit StdCtrls. Em seguida escrevemos o código que cria o componente:

Botao := TButton.Create(nil);

O construtor Create espera receber o dono do componente (Owner) como parâmetro. Nesse caso informamos que o Botão não tem dono. Você pode ainda informar Self ou Application. Se for informado um desses dois últimos, o objeto criado será destruído juntamente com o seu dono. No nosso exemplo o objeto deve ser destruído explicitamente usando o método Free.

Quando um objeto é criado, muitas propriedades recebem valores padrão. Dessa forma precisamos definir pouca coisa mais.

Botao.Parent := Form1;
Botao.Name := 'Botao';
Botao.Caption :='Ok';

A propriedade Parent informa onde o componente será colocado. Ou seja Parent indica o componente que contém o botão. Se tivermos um TPanel chamado Panel1 dentro do Form1 e desejarmos inserir o botão nesse painel, só precisamos informar Botao.Parent := Panel1. Podemos definir valores para as propriedades Left e Top do botão. Esses valores são sempre relativos ao Parent. Ambas serão inicializadas com 0, caso não atribuirmos valores para elas.
Se desejarmos definir um método para um evento do componente, é necessário criar o método primeiro. Por exemplo, supondo que queremos programar o evento OnClick do botão:

procedure TForm1.Clica(Sender: TObject);
begin
   ShowMessage('Componente dinâmico');
end;

Assim, podemos referenciar o método durante a criação do componente com o comando:

Botao.OnClick := @Clica;

Para liberar a memória quando não precisarmos mais do componente usamos o seguinte comando, que pode ser colocado no evento OnClose do form.

Botao.Free;

Um novo item de menu

Para incluir um novo item de menu, vamos supor que já exista um TPopupMenu chamado PopupMenu1. Declaramos um novo TMenuItem:

ItemNovo: TMenuItem;

E o código para cirar o novo item:

ItemNovo := TMenuItem.Create(nil);
ItemNovo.Caption := 'Nova opção';
ItemNovo.Name := 'ItemNovo';
ItemNovo.OnClick := @Clica;
PopupMenu1.Items.Add(ItemNovo);

Agora, resta exceutar o programa e experimentar nossos componentes dinâmicos.

Atualizado em 16/05/2010.

quinta-feira, 6 de maio de 2010

Lazarus - Conectando MySQL com SQLdb ou ZeosLib

Vamos mostrar duas maneiras de acessar MySQL no Lazarus. Uma usando os componentes nativos SQLdb e outra usando ZeosLib. Utilizamos no exemplo a versão 5.1.46 do MySQL. O SQLdb da versão 0.9.28.2 não funciona com essa versão do MySQL. Dessa forma, foi instalado o snapshot Lazarus-0.9.29-25198-fpc-2.4.1-20100505-win32.exe (usamos o Windows XP nos testes). Snapshots são builds noturnos do Lazarus compilados com os últimos códigos fonte, corrigindo alguns erros e provavelmente introduzindo outros.

Crie o banco dados no MySQL. Vamos usar o mesmo banco usado em artigos anteriores. Este é o script de criação das tabelas:

create table cidade (id_cidade int not null primary key, nome varchar(30));

create table cliente (id_cliente int not null primary key, nome varchar(40), endereco varchar(40), id_cidade integer references cidade(id_cidade), telefone varchar(14), tipo char(1));

Usando SQLdb

Selecione a aba SQLdb e coloque no Data Module um TMySQL50Connection. Ele que fará a conexão com o banco. Defina então as seguintes propriedades:

DatabaseName - informe o nome do banco de dados que foi criado.
HostName - informe o nome ou o IP do servidor de banco de dados.
Name
- informe um nome para a conexão. Por exemplo: dbCliente.
Password - informe a senha do usuário. Se usar root como nome de usuário, informe a senha definida no momento da instalação do MySQL.

UserName - informe o nome do usuário. Pode ser o root.

Coloque agora um TSQLTransaction e selecione dbCliente na propriedade Database, e na propriedade Name digite trCliente, por exemplo.
Volte ao TMySQL50Connection e informe trCliente na propriedade Transaction. Coloque a propriedade Connected em True para verificar se a conexão é feita. Se retornar uma mensagem de falta da dll libmySQL, localize a mesma no diretório bin do MySQL e copie-a para o diretório system32. Depois volte a propriedade para False.
Coloque um TSQLQuery no Data Module e defina suas propriedades:

Database - selecione dbCliente.
Name - defina queCidade.
SQL - informe SELECT * FROM CIDADE.
Transaction - selecione trCliente.

Coloque agora um TDataSource da aba Data Access e mude Name para dsCidade e em DataSet selecione queCidade.
No evento AfterPost de queCidade digite o código:

queCidade.ApplyUpdates;
trCliente.CommitRetaining;

No evento AfterDelete selecione o mesmo método para não repetir código.
Pronto. Está feita a configuração de acesso, tanto para leitura quanto para escrita, em uma tabela do MySQL. Crie uma interface seguindo os passos descritos no post Lazarus - Acessando banco de dados com SQLdb - Parte I.
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.

Usando ZeosLib

Usaremos a versão 7.0 do ZeosLib disponível no grupo Lazarus-BR. Para instalar o pacote siga as instruções apresentadas no post Lazarus - Conectando PostgreSQL com ZeosLib. Coloque um TZConnection no Data Module. Defina as propriedades:

AutoCommit - deixe em True para que as transações no banco sejam comitadas automaticamente.
Database - informe o nome do banco de dados criado anteriormente.
HostName - informe o nome ou IP do servidor do banco. Para máquina local informe localhost.
Name - digite dbCliente.
Password - informe a senha do usuário. Em geral a senha do usuário root.

Protocol - informe mysql-5. Observe a versão do MySQL que você está usando.
User - informe o nome do usuário. Geralmente é root.

TransactionIsolation - define o nível de isolamento da transação. No nosso caso vamos usar tiReadCommitted.
Mude Connected para True. No Windows deve ocorrer um erro de ausência de dll. Faça o download aqui e copie-a para system32 do Windows. Depois de conectar com sucesso volte Connected para False.

Coloque um TZQuery e um TZUpdateSQL e configure-os como foi feito no artigo Lazarus - Conectando PostegreSQL com ZeosLib.
No TZUpdateSQL defina essas propriedades assim:

DeleteSQL - DELETE FROM CIDADE WHERE ID_CIDADE = :OLD_ID_CIDADE;
InsertSQL - INSERT INTO CIDADE VALUES (:ID_CIDADE, :NOME);
ModifySQL - UPDATE CIDADE SET NOME = :NOME WHERE ID_CIDADE = :OLD_ID_CIDADE;


Coloque um TDataSource da aba Data Access e defina Name como dsCidade e em DataSet selecione a TZQuery anterior. Ai está. Agora crie a interface com nos posts anteriores.

Atualizado em 04/06/2010.

segunda-feira, 3 de maio de 2010

Firebird - Vem ai a versao 2.5

 O banco de dados Firebird®, de código aberto, possui excelente performance e expressiva escalabilidade, indo desde modelos embarcados (mono-usuário) até sistemas empresariais com múltiplos bancos de mais de 500GB e centenas de conexões simultâneas.
O Firebird suporta o padrão ACID, triggers, stored procedures, UDF e eventos; roda nas versões 32 e 64 bits do Windows, Linux, MacOS X, HP-UX, FreeBSD, etc., sendo muito fácil a migração entre essas plataformas.
Um dos recursos chave do Firebird é a arquitetura multi-geracional, que permite o desenvolvimento e suporte de sistemas híbridos OLTP e OLAP. Suporta o padrão ACID, triggers, stored procedures, UDF e eventos; possui suporte compreensivo ao padrão SQL92, além de inúmeras opções de conectividade.
A combinação de alta performance, baixo consumo de recursos, escalabilidade suprema, instalação simples e silenciosa e distribuição 100% livre de royalties, fazem do Firebird uma escolha atrativa para todos os tipos de desenvolvedores e fornecedores de software. È utilizado por aproximadamente um milhão de desenvolvedores de software em todo o mundo.
Participe da campanha de divulgação acessando MindTheBird.

Java - Certificado de Programador Sun (SCJP)

Há pouco tempo escrevi um artigo na revista Urissanê - revista eletrônica do curso de Sistemas de Informação do CEULS/ULBRA, onde trabalho. Nesse artigo eu apresento diretrizes gerais sobre uma das certificações de TI mais procuradas - a SCJP. Abordamos cada certificação Java que a Sun oferece, mostrando as diferenças entre elas, como e onde se inscrever para o exame, como se preparar, dicas gerais sobre o conteúdo do exame, informações sobre o exame propriamente dito e o que acontece depois do exame. Leia o artigo 4 no site do curso. Logo estarei iniciando neste blog uma série de artigos com informações fundamentais para os candidatos a essa certificação, uma espécie de tutorial Java de preparação.

quinta-feira, 29 de abril de 2010

Lazarus - Criando relatórios com FortesReport (Parte II)

No post Lazarus - Criando relatórios com FortesReport (Parte I) mostramos a criação de um relatório simples com agrupamento. Neste artigo vamos mostrar como criar um relatório mestre detalhe usando o FortesReport. Para implementar o exemplo usei um banco de dados Firebird e ZeosLib. Use o seguinte script para criar as tabelas. Neste caso o relacionamento mestre detalhe é formado pelas tabelas VENDA e ITEM.

O Data Module

Inicie uma aplicação no Lazarus e insira um Data Module. Selecione a aba Zeos Access e coloque um TZConnection no Data Module. Defina as propriedades da seguinte forma:

Database - informe o banco de dados Firebird que foi criado.
Name - dê um nome ao componente. Por exemplo: dbVendas.
Password - masterkey.
Protocol - firebird-2.0 ou a versão que está sendo usada.
User - sysdba.

Mude Connected para true, para verificar se a conexão está configurada corretamente.
Coloque um TZReadOnlyQuery e defina:

Connection - selecione o TZConnection.
Name - defina um nome para o componente. Por exemplo: queVenda.
SQL - select a.id_venda, a.data_venda, b.nome from venda a, cliente b where a.id_cliente = b.id_cliente.

Selecione a aba Data Access e coloque um TDataSource, onde DataSet deve estar associado à Query anterior. Defina Name como dsVenda.

Coloque um segundo TZReadOnlyQuery, defina Connection da mesma maneira e em Name digite queItem, por exemplo. Na propriedade SQL informe select a.id_produto, b.nome, a.quantidade, b.preco_venda, a.quantidade * b.preco_venda total from item a, produto b where a.id_produto = b.id_produto and id_venda = :id_venda.

Defina a propriedade DataSource desta Query com dsVenda. Isto, juntamente com o parâmetro :id_venda definem o relacionamento mestre detalhe entre as duas Queries. O parâmetro :id_venda é definido por queVenda através de dsVenda.

Coloque mais um TDataSource e defina a propriedade DataSet com a Query queItem. Defina Name como dsItem. Leia mais para conexão com Firebird em Lazarus - Conectando Firebird com SQLdb ou ZeosLib.

O relatório

Esse é o aspecto do relatório que iremos construir:



Agora adicione um novo form à aplicação. Localize a aba Fortes Report e coloque um TRLReport. No Inspetor de Objetos expanda a propriedade AllowedBands e coloque em True as opções btColumnHeader, btDetail e btHeader. Na propriedade DataSource selecione dsVenda, a tabela mestre.
Agora coloque um TRLBand. Defina a propriedade BandType como btHeader. Aumente a altura da banda e coloque um TRLLabel sobre a TRLBand. Defina a propriedade Caption como Relatório de Vendas. Na propriedade Align selecione faCenter, para centralizar o rótulo na banda. Expanda a propriedade Font e defina Size como 14, por exemplo. Coloque um TRLSystemInfo no lado esquerdo da banda. Na propriedade Info selecione itDate. Isso mostrará a data atual na banda. Coloque outro TRLSystemInfo, este no lado direito da banda e defina a propriedade Info como itPageNumber. Isso mostra o número da página.
Coloque outro TRLBand e defina a propriedade BandType como btDetail. Sobre essa banda, que deve mostrar os dados da tabela mestre, coloque TRLLabels definindo seus Caption como Venda, Data, Cliente, CÓDIGO, NOME, QTDE, PREÇO e TOTAL. Coloque também três TRLDBTexts. Defina seus DataSource como dsVenda e DataField como ID_VENDA, DATA_VENDA e NOME.


A banda deve ser dimensionada adequadamente de acordo com a figura acima. Coloque um TRLSubDetail e defina a propriedade DataSource como dsItem. Esta banda irá mostrar os dados da tabela detalhe. Expanda a propriedade AllowedBands e coloque em True as opções btDetail e btSummary. Sobre essa banda coloque um TRLBand. Defina BandType como btDetail. Coloque cinco TRLDBTexts e defina DataSource como dsItem. Em DataField informe ID_PRODUTO, NOME, QUANTIDADE, PRECO_VENDA e TOTAL. Coloque outro TRLBand sobre TRLSubDetail e defina BandType como btSummary. Esta banda é usada para imprimir totais de relatórios ou grupos. Sobre esta banda coloque um TRLLable e defina seu Caption como Total da Venda:. Ao lado dele coloque um TRLDBResult. Este componente é usado para totalizar uma coluna, por exemplo. Defina DataSource como dsItem. Em DataField informe TOTAL. A propriedade Info define a operação que será realizada. Defina como riSum. que indica que a coluna TOTAL será somada. Na propriedade DisplayMask escreva #,###,##0.00. Isso irá formatar o valor mostrado. Pode-se definir DisplayMask para os TRLDBTexts referentes a PRECO_VENDA e TOTAL.

No form que irá chamar o relatório coloque um botão e no evento OnClick escreva o código que mostrar uma prévia do relatório:

frmMestreDetalhe.rlVendas.Preview();

É necessário informar na cláusula uses o nome da unit do relatório. Abrir a conexão e as Queries também é necessário para que o relatório seja visualizado. Faça o download do exemplo aqui.

terça-feira, 27 de abril de 2010

Lazarus - Emulador WinCE/Windows Mobile

Há alguns dias escrevi um post mostrando o desenvolvimento de uma pequena aplicação para WinCE usando SQLite. Na época fiz os testes em um PDA, não usei emulador. Muitas pessoas tem entrado em contato comigo questionando sobre emuladores. Sempre tive dificuldades com os emuladores da Microsoft. Mas passei a procurar por um emulador que funcione e acabei por encontrar no site da PDAExpert. Lá encontrei as versões Standard e Professional do emulador para Windows Mobile 6. Por limitações de banda fiz o download da versão Standard que oferece três emuladores diferentes. Consegui executar o exemplo do artigo, como mostra a figura.

Emulador Windows Mobile 6
No entanto, o programa não consegue acesso ao banco SQLite. Minha forte suspeita é que a dll não é compatível com Windows Mobile 6. Ainda não tenho dados suficientes para afirmar isso. Por conta disso, pretendo criar uma nova aplicação que grava os dados em XML ou mesmo em arquivo texto usando TFixedFormatDataSet, como mostrei no post Lazarus - Tratamento de Arquivos Texto. De qualquer forma, se alguém tiver tido experiência com esse emulador rodando SQLite, gostaria de trocar idéias.

segunda-feira, 26 de abril de 2010

Lazarus - Relógio para jogar Xadrez

Para os aficcionados do milenar jogo de Xadrez que não querem ou não podem pagar por um relógio, estou disponibilizando um programa bem simples que simula um relógio, cujo executável pode ser baixado aqui. O programa não requer instalação, podendo inclusive ser executado em um pendrive. Ele foi desenvolvido usando a fantástica ferramenta Lazarus/FreePascal e substitui com eficiência os relógios de mesa. Além disso, aqueles que estão dando os primeiros passos em Lazarus encontrarão um exmplo de programa que usa bastante componentes e código para seus exercícios.
Antes de mostrar o código vou mostrar a interface e explicar o funcionamento do relógio.

A interface


Na parte superior do relógio está a configuração do tempo que será usado na partida. Há três caixas de texto (TEdit). Uma para hora, a segunda para minutos e a terceira para segundos. À direita encontram-se três botões (TButton). O primeiro para iniciar o relógio, o segundo para reset e o terceiro para pausar.
Abaixo temos mais dois TButton que servirão para simular o pressionamento do botão do relógio de cada jogador. Mais abaixo tem-se dois TGroupBox com TLabel dentro deles. Os rótulos são usados para mostrar o tempo de reflexão de cada jogador. E, finalmente, dois TProgressBar para mostrar visualmente o progresso do tempo das brancas e das pretas. As barras de progresso também ficam dentro de TGroupBox.
Além dos componentes visuais são usados dois TTimer, usados para controlar o tempo de cada jogador.

O funcionamento

Para iniciar uma partida, inicialmente definimos o tempo da partida. Certamente o tempo é o mesmo, tanto para as brancas quanto para as pretas. Definido o tempo, pressiona-se o botão iniciar. Imediatamente o tempo das brancas começa a correr, habilitando-se o TTimer das brancas. As brancas fazem sua jogada e pressionam qualquer tecla do teclado que possa ser detectada pelo evento OnKeyPress. Nesse momento o TTimer das pretas é habilitado e o das brancas é desabilitado. O processo continua até que um dos jogadores estoure o tempo ou a partida seja encerrada. Se o botão Pausar for pressionado, os dois TTimer são desabilitados e o rótulo dele muda para Continuar. Pressionando-se o botão novamente a partida prossegue do ponto onde parou.
O componente TTimer dispara um evento a determinados intervalos definidos na propriedade Interval. O valor informado em Interval é em milissegundos. Deixamos a propriedade com o valor padrão 1000 milissegundos. Ou seja, o evento OnTimer irá acontecer a cada segundo.

O código

Grande parte do código é bem simples e não merece maiores explicações. Vou apresentar o método do evento OnClick do botão Pausar/Continuar. Para o funcionamento correto, declarei duas variáveis boolean globais: blPausa, que define se o relógio está em pausa ou em andamento, e blBrancas, que define de quem é o relógio que está em andamento.

procedure TfrmRelogio.btPausarClick(Sender: TObject);
begin
   if not blPausa then
   begin
      if blBrancas then
         timBrancas.Enabled := false
      else
         timPretas.Enabled := false;
      btParar.Enabled := false;
      blPausa := true;
      btPausar.Caption := 'Continuar';
   end
   else
   begin
      if blBrancas then
      begin
         timBrancas.Enabled := true;
         btBrancas.SetFocus;
      end
      else
      begin
         timPretas.Enabled := true;
         btPretas.SetFocus;
      end;
      blPausa := false;
      btParar.Enabled := true;
      btPausar.Caption := 'Pausar';
   end
end;

De acordo com o estado de blPausa, habilita-se/desabilita-se o TTimer correspondente e ora o botão das brancas recebe o foco, ora o botão das pretas é quem recebe o foco. Nesse evento muda-se o rótulo do botão, alternando-se entre Pausar e Continuar.

Os eventos OnTimer tanto das brancas quanto das pretas são similares. Mostro apenas o método referente às brancas.

procedure TfrmRelogio.timBrancasTimer(Sender: TObject);
var
  bTotal, bParcial: integer;
begin
  bSeg := bSeg + 1;
  if bSeg > 59 then
  begin
     bSeg := 0;
     bMin := bMin + 1;
     if bMin > 59 then
     begin
        bMin := 0;
        bHor := bHor + 1;
     end
  end;
  lbBrancas.Caption := StrZero(bHor, 2, 0) + ':' + StrZero(bMin, 2, 0)+':'+StrZero(bSeg, 2, 0);
  bTotal := StrToInt(edHora.Text) * 3600 + StrToInt(edMinuto.Text) * 60 + StrToInt(edSegundo.Text);
  bParcial := bHor * 3600 + bMin * 60 + bSeg;
  pbBrancas.Position := (100 * bParcial div bTotal);
  if (StrZero(bHor, 2, 0) >= edHora.Text) and (StrZero(bMin, 2, 0) >= edMinuto.Text) and (StrZero(bSeg, 2, 0) >= edSegundo.Text) then
  begin
      timBrancas.Enabled := false;
      ShowMessage('As brancas estouraram o tempo');
  end;
end;          

Nas linhas de 5 a 15, o tempo é incrementado. Observe que temos uma variável para hora, minutos e segundos. Em seguida o tempo é mostrado no rótulo correspondente ao display do relógio, na linha 16. Nas linhas de 17 a 19, é calculado o percentual de tempo decorrido e esse valor é mostrado no TProgressBar. Finalmente, é verificado se o tempo limite foi atingido. Caso positivo, o relógio é parado e a mensagem de estouro de tempo é mostrado.
A função StrZero() foi criada para preencher um número inteiro com zeros à esquerda. O código pode ser encontrado no download.
Baixe o programa completo aqui e divirta-se jogando Xadrez e aprendendo mais um pouco sobre Lazarus/FreePascal.

sexta-feira, 23 de abril de 2010

Lazarus - Funcoes de tratamento de Strings

Sysutils é uma unit do Free Pascal que implementa várias funções/procedimentos utilitários e tem a vantagem de ser multiplataforma. Esses utilitários são organizados em grupos e dentre eles podemos destacar: as rotinas de conversão de dados, as rotinas de data e hora, as rotinas de formatação de strings e as rotinas de manipulação de strings.

Destacamos neste post as funções/procedimentos de manipulação de strings:

LeftStr(const s: string; n: integer): string;

Retorna os n primeiros caracteres da string s. Por exemplo:

var
   s: string;
begin
   s: 'Free Pascal'; 
   writeln(LeftStr(s, 4)); // imprime Free
end;

RightStr(const s: string; n: integer): string;

Retorna os n últimos caracteres da string s. Por exemplo:

var
   s: string;
begin
   s: 'Free Pascal'; 
   writeln(RightStr(s, 1));  // imprime "l"
end;

Neste caso o exemplo pega o último caractere de uma string e imprime na tela.

Trim(const s: string): string;

Retira os espaços das extremidades da string s. Por exemplo:

var
   s: string;
begin
   s: '  Free Pascal  '; 
   writeln(Trim(s));  // imprime "Free Pascal"
end;

TrimLeft(const s: string): string;

Retira os espaços no início da string s. Por exemplo:

var
   s: string;
begin
   s: '  Free Pascal  '; 
   writeln(TrimLeft(s));  // imprime "Free Pascal  "
end;

TrimRight(const s: string): string;

Retira os espaços do final da string s. Por exemplo:

var
   s: string;
begin
   s: '  Free Pascal  '; 
   writeln(TrimRight(s));  // imprime "  Free Pascal"
end;

A função LowerCase(const s: string): string; converte s para caixa baixa. E a função UpperCase(const s: string): string; converte s para caixa alta. Existem muitas outras funções de tratamento de strings em sysutils. Inclusive funções para AnsiString e null-terminated. Num próximo post falaremos de outras funções dessa unit.

quinta-feira, 15 de abril de 2010

Lazarus - Criando relatórios com FortesReport (Parte I)

Para a criação de relatórios, o Lazarus já trás o componente LazReport, no entanto ele precisa ser instalado no IDE. Para fazer a instalação do pacote, acesse o menu Package -> Open package file (.lpk). Localize o diretório de instalação do Lazarus e na pasta components abra lazreport e depois source. Abra o pacote lazreport.lpk, clique em Compile e depois em Install. Como já sabemos isso irá recompilar o IDE. Depois de inicializado novamente estará disponível a aba LazReport. Leia aqui um tutorial básico sobre o LazReport.
No entanto queremos mostrar uma alternativa ao LazReport. Por essa razão, vamos apresentar neste artigo o FortesReport. Para quem conhece o QuickReport, que fazia parte do Delphi, não terá dificuldade de desenvolver com esse componente. Baixe o pacote aqui e instale. Os procedimentos são semelhantes aos que mostramos acima. Você terá uma nova aba chamada Fortes Report.


Conectando o banco de dados

O primeiro passo para criar a aplicação é fazer a conexão com o banco de dados. Vamos usar o SQLite e o ZeosLib. O banco de dados será o mesmo já usado em exemplos anteriores. Selecione a aba Zeos Access e coloque um TZConnection no Data Module. Defina a propriedade Database com o caminho e o nome do arquivo do banco de dados. Na propriedade Protocol escolha sqlite-3.
Agora coloque um TZReadOnlyQuery da mesma aba. Na propriedade Connection escola o TZConnection anterior. Na propriedade SQL digite SELECT * FROM CIDADE ORDER BY NOME. Localize a aba Data Access e coloque um TDataSource no Data Module. Na propriedade DataSet selecione o TZReadOnlyQuery. Para que possamos visualizar uma prévia do relatório deixe o banco conectado e a Query aberta. Queremos criar um relatório com a seguinte aparência:


Ou seja, mostraremos as cidades em ordem alfabética e a cada letra inicial nova ela será impressa destacando um novo grupo de cidades.
A aplicação deverá ter dois forms. Um onde será criado o relatório, e outro que chamará o primeiro. Assim, se a aplicação já possui um form, adicione o segundo. Nosso trabalho será todo efetuado em cima do segundo form.
Selecione a aba Fortes Report e coloque um TRLReport no form. Esse componente é como se fosse a folha de papel e possui um quadriculado para facilitar o desenho. No Inspetor de Objetos expanda a propriedade AllowedBands e coloque em True as opções btColumnHeader, btDetail e btHeader. O componente trabalha com bandas e isso define quais as bandas que são permitidas no relatório. Definimos que nosso relatório terá um cabeçalho de página (btHeader), um cabeçalho de coluna (btColumnHeader) e uma banda de detalhe (btDetail). Na propriedade DataSource selecione o TDataSource colocado no Data Module anteriormente.
Agora coloque um TRLBand. Defina a propriedade BandType como btHeader. Aumente a altura da banda e coloque um TRLLabel sobre a TRLBand. Defina a propriedade Caption como Relatório de Cidades. Na propriedade Align selecione faCenter, para centralizar o rótulo na banda. Expanda a propriedade Font e defina Size como 14, por exemplo. Coloque um TRLSystemInfo no lado esquerdo da banda. Na propriedade Info selecione itDate. Isso mostrará a data atual na banda. Coloque outro TRLSystemInfo, este no lado direito da banda e defina a propriedade Info como itPageNumber. Isso mostra o número da página
Coloque outro TRLBand e defina BandType como btColumnHeader. Coloque dois TRLLabel sobre esta e defina as propriedades Caption como ID e Nome respectivamente.
Como desejamos agrupar as cidades precisamos de um TRLGroup. Coloque um componente desses. Expanda AllowedBands e defina btDetail e btHeader como True. As propriedades DataField ou DataFormula são responsáveis por definir como se dará a quebra de grupos. Como queremos que a quebra ocorra pela primeira letra do nome da cidade, então informamos em DataFormula, copy(nome, 1, 1).  Se a quebra fosse por um campo, este seria informado em DataField. Coloque um TRLBand sobre TRLGroup. Defina BandType como btHeader. Coloque um TRLDBText sobre o btHeader. Defina a propriedade DataSource com o TDataSource que foi inserido no DataModule. Podemos aqui imprimir um campo ou uma fórmula. Usaremos DataFormula para imprimir apenas a letra inicial do nome da cidade informando copy(nome, 1, 1). Coloque outro TRLBand sobre TRLGroup e dessa vez defina BandType como btDetail. Na banda detalhe é que são mostradas as linhas da tabela. Coloque dois TRLDBText sobre o btDetail de forma que fiquem abaixo dos rótulos ID e Nome inseridos no btColumnHeader. Defina a propriedade DataSource de ambos com o mesmo TDataSource usado desde o início do artigo. Na propriedade DataField do primeiro TRLDBText, informe ID_CIDADE. E no segundo informe NOME.
Podemos obter uma prévia do relatório clicando com o botão em TRLReport e selecionando Preview.
Para finalizar o exemplo coloque um botão no form que irá chamar o relatório. Abaixo de implementation acrescente no uses o nome da unit referente ao form do relatório. E no evento OnClick do botão escreva o código para chamar o método Preview() de RLReport.

quarta-feira, 7 de abril de 2010

Lazarus - Criando XML a partir de um DataSet

Sabemos que um documento XML pode ser criado manipulando strings e arquivos texto. Esta opção não é aconselhável, pois é difícil garantir que o documento seja bem formado. A melhor forma de fazer isso é usar DOM (Modelo Objeto de Documento). Já usamos esse padrão para ler um documento XML no artigo anterior.
Para ilustrar a criação de um documento vamos implementar uma aplicação que gera um XML a partir dos registros de um DataSet. Para isso vamos usar nosso banco de dados SQLite de exemplos anteriores e vamos usar ZeosLib. Mas pode ser usado qualquer conjunto de componentes, inclusive SQLdb.
Coloque então um TZConnection no form, ou num Data Module. Defina a propriedade Database com o banco SQLite, ou qualquer outro. Defina a propriedade Protocol com sqlite-3.
Coloque também um TZReadOnlyQuery e defina Name como queCidade. Em Connection selecione o TZConnection. Na propriedade SQL digite SELECT * FROM CIDADE.
Insira um botão, que vai executar a criação do XML.

Na cláusula uses acrescente as units DOM e XMLWrite.

Agora vamos criar o código que efetivamente irá criar o XML. A idéia é criar um procedimento genérico, que servirá para qualquer tabela.
O procedimento Tabela2DOM() recebe como argumentos o nome do nó raiz, o nome do nó pai, o próprio documento XML e o DataSet. Observe o código abaixo:

procedure TfrmDataXml.Tabela2DOM(Raiz, Registro: string; XMLDoc: TXmlDocument; DataSet: TDataSet);
var
  iRaiz, iPai, iFilho: TDOMNode;
  i, j: Integer;
begin
  DataSet.Open;
  DataSet.First;
  iRaiz := XMLDoc.CreateElement(Raiz);
  XMLDoc.AppendChild(iRaiz);
  j := 0;
  while not DataSet.EOF do
  begin
    iRaiz := XMLDoc.DocumentElement;
    iPai := XMLDoc.CreateElement(Registro);
    iRaiz.AppendChild(iPai);
    for I := 0 to DataSet.FieldCount - 1 do
    begin
      if not (DataSet.Fields[i].IsNull) then
      begin
         iPai := XMLDoc.CreateElement(DataSet.Fields[i].FieldName);
         iFilho := XMLDoc.CreateTextNode(DataSet.Fields[i].AsString);
         iPai.AppendChild(iFilho);
         iRaiz.ChildNodes.Item[j].AppendChild(iPai);
      end;
    end;
    DataSet.Next;
    j := j + 1;
  end;
  DataSet.Close;
end;  

Nas linhas 8 e 9 criamos o nó raiz e o adicionamos ao documento. O método AppendChild() adiciona um nó ao documento.
A partir da linha 11 iniciamos a varredura da tabela. Para cada registro da tabela adicionamos um nó pai com o nome passado como parâmetro, que é feito nas linhas 14 e 15.
O for da linha 16 irá precorrer os campos de cada registro da tabela. Para cada registro criamos um nó pai com o nome do campo (linha 20) e um nó filho com o conteúdo do campo. A linha 18 evita a inclusão de campos vazios no documento.

No evento OnClick do botão criamos o objeto DOM, o procedimento acima é chamado, o documento é gravado usando o método writeXMLFile() e o objeto é destruido.

procedure TfrmDataXml.btnCriarClick(Sender: TObject);
begin
  XMLDoc := TXMLDocument.Create;
  Tabela2DOM ('cidades', 'cidade', XMLDoc, queCidade);
  writeXMLFile(XMLDoc,'cidade.xml');
  XMLdoc.free;
end;   

Para executar lembre de conectar o banco e abrir a tabela, conforme visto em artigos anteriores.
Baixe aqui o código completo do exemplo.

quinta-feira, 1 de abril de 2010

Lazarus - Lendo XML em um TreeView

XML (Extensible Markup Language) é uma linguagem de marcação, baseada em texto, recomendada pela W3C para troca de informações entre diferentes sistemas e plataformas. Linguagens usadas para troca de dados, como XHTML, a maioria dos WebServices, se baseiam em XML. Aqui está o exemplo de um arquivo XML:


  
    Joao da Silva
    (93)3522-0001
  
  
    Jose Sousa
    (93)3522-0002
    jose@email.com.br
  
  
    Maria da Silva
    (93)3522-0003
    (93)9122-0001
  
  
    Raimunda de Sousa
    rsousa@email.com.br
  


Em Lazarus/Free Pascal existem três units que dão suporte a XML. São chamadas XMLRead, XMLWrite e DOM. Fazem parte da FCL (Biblioteca de Componentes Livres). Só precisamos adicionar as units na cláusula uses para ter suporte a XML.
DOM (Modelo Objeto de Documento) define uma interface padrão. Quando você escreve código que usa essa interface, você pode mudar para outras implementações de DOM sem precisar mudar seu código fonte.

Lendo XML em um TreeView

Como XML tem uma estrutura de árvore, carregar um documento XML em um TTreeView parece bem natural. No nosso exemplo nós carregamos um documento XML em um DOM e depois mostramos a estrutura em um TTreeView. Para mostrar o documento em uma árvore usamos um método recursivo que navega pelos nós e subnós do XML.
Vamos iniciar uma nova aplicação e na cláusula uses da unit vamos adicionar DOM e XMLRead. No form coloque um TEdit, defina Name como edArquivo e delete o conteúdo de Text. Coloque um botão e defina Name como btnAbrir e Caption como Abrir. Insira mais um botão e em Name informe btnLer e em Caption informe Ler. A propriedade Enabled desse botão deve ficar em False. Agora coloque um TTreeView - da aba Common Controls - e em Name digite tvwXML. Coloque também um TOpenDialog da aba Dialogs e mude Name para dlgAbrir. Sua interface irá ficar assim:


No método do evento OnClick do botão btnAbrir escreva o seguinte código:

if dlgAbrir.Execute then
begin
  edArquivo.Text := dlgAbrir.FileName;
  btnLer.Enabled := True;
end;

Esse código abre a caixa de diálogo para selecionar o arquivo XML, atribui o nome do arquivo ao TEdit e habilita o botão btnLer. No botão btnLer vamos executar o código que povoa o TTreeView com os dados do documento XML. O método recursivo será construido separado:

procedure TfrmXml.DomToTree(XmlNode: TDOMNode; TreeNode: TTreeNode);
var
  I: integer;
  NewTreeNode: TTreeNode;
  NodeText: string;
  AttrNode: TDOMNode;
begin
  // considera apenas nós elementos
  if XmlNode.NodeType <> ELEMENT_NODE then
    Exit;
  // inclui o nó
  NodeText := XmlNode.NodeName;
  if (XmlNode.ChildNodes.Count = 1) and (XmlNode.ChildNodes[0].NodeValue <> '')  then
    NodeText := NodeText + ' = ' + XmlNode.ChildNodes[0].NodeValue;
  NewTreeNode := tvwXML.Items.AddChild(TreeNode, NodeText);
  // inclui atributos, se existirem
  for I := 0 to xmlNode.Attributes.Length - 1 do
  begin
    AttrNode := xmlNode.Attributes.Item[I];
    tvwXML.Items.AddChild(NewTreeNode,
      '[' + AttrNode.NodeName + ' = "' + AttrNode.NodeValue + '"]');
  end;
  // inclui cada nó filho
  if XmlNode.HasChildNodes then
    for I := 0 to xmlNode.ChildNodes.Count - 1 do
      DomToTree(xmlNode.ChildNodes.Item[I], NewTreeNode);
end;

Este método utiliza várias operações que podemos fazer com DOM. Cada nó tem uma propriedade denominada NodeType, para determinar se é um elemento, atributo, nó texto, etc (linha 09). Nas linhas 13 e 14 podemos observar que NodeValue - a representação textual - só pode ser acessado se o nó tiver um elemento textual. Após mostrar o nome do item e o valor textual - se houver - o método mostra o conteúdo de cada atributo. Em seguida chamamos o método recursivamente para mostrar cada subnó.
A interface do método deve ser informada na seção type. O método do evento OnClick do botão btnLer deve ser assim:

procedure TfrmXml.btnLerClick(Sender: TObject);
var
  Documento: TXMLDocument;
begin
  tvwXML.Items.Clear;
  ReadXMLFile(Documento, edArquivo.Text);
  DomToTree(Documento.DocumentElement, nil);
  tvwXML.FullExpand;
  Documento.Free;
end;

Ele cria um DOM a partir do arquivo XML e depois chama o método que povoa o TTreeView.
Faça o download do código fonte do exemplo aqui.

Atualizado em 08/04/2010.

quinta-feira, 25 de março de 2010

Lazarus - Criando um Splash e um Hint com várias linhas

Splash

Splash é uma janela de abertura de um programa. Vamos aprender como criar uma dessas em Lazarus. Para isso crie uma nova aplicação. Podemos dar o nome de frmPrincipal a esse form e salvar tudo. Para a unit dê o nome u_principal e ao projeto dê o nome Splash. Agora inclua mais um form na aplicação. Esse será o splash. Na propriedade Name digite frmSplash. Salve e digite u_splash no nome da unit. Na propriedade FormStyle desse form selecione fsSplash. Selecione a opção de menu Project -> Project Options. Localize a aba Forms, selecione frmSplash e, usando a seta, passe-o para a caixa da direita. Isso define que o form não será criado automaticamente.
Coloque um TImage em frmSplash e selecione uma imagem adequada ao seu projeto. É bom mudar Align para alClient e Stretch para True.
Agora clique no botão View Units na barra de ferramentas. Isso abrirá uma janela com todas as units da aplicação. Selecione o arquivo do projeto: splash.lpr.

program splash;

{$mode objfpc}{$H+}

uses
  {$IFDEF UNIX}{$IFDEF UseCThreads}
  cthreads,
  {$ENDIF}{$ENDIF}
  Interfaces, // this includes the LCL widgetset
  Forms, crt, u_principal, LResources, u_splash
  { you can add units after this };

{$IFDEF WINDOWS}{$R splash.rc}{$ENDIF}

begin
  {$I splash.lrs}
  Application.Initialize;
  frmSplash := TfrmSplash.Create(nil);
  frmSplash.Show;
  frmSplash.Update;
  Delay(1000);
  Application.CreateForm(TfrmPrincipal, frmPrincipal);
  frmSplash.Hide;
  frmSplash.Free;
  Application.Run;
end.

Na seção uses acrescente Crt. Isso é necessário para invocar o procedimento Delay() na linha 21, que provoca um retardo para que o splash seja mostrado por um certo tempo. Explicando o código apenas para as linhas que serão acrescentadas:

Linha 18 - cria o form frmSplash.
Linha 19 - mostra o splash.
Linha 20 - funciona como Repaint, atualizando a janela, senão não será mostrada.
Linha 21 - causa um retardo na execução do programa.
Linha 23 - oculta o splash.
Linha 24 - libera a memória ocupada pelo splash.

Hint com várias linhas

Hints são aquelas dicas que aparecem quando paramos o mouse sobre um componente. Normalmente essas dicas são informadas na propriedade Hint e habilitadas na propriedade ShowHint. No entanto através do Object Inspector só conseguimos colocar uma linha. Para mostrar como podemos ter um Hint com múltiplas linhas coloque um botão do tipo TBitBtn - pode ser qualquer outro tipo de botão - em frmPrincipal. Em Name informe btnSair. Na propriedade Kind selecione bkClose. Dê um duplo clique no form para criar um método para o evento OnCreate. Digite no Editor de código:

btnSair.Hint := 'Para sair desse form' + #13 + 
                'clique neste botão';
btnSair.ShowHint:= True;

O #13 insere um Enter na string e causa um salto de linha. Pode inserir quantos #13 você precise. Execute a aplicação e pare o mouse sobre o botão.

Atualizado em 15/04/2010.
 
Creative Commons License
This work by Carlos Alberto P. Araújo is licensed under a Creative Commons Atribuição-Uso não-comercial-Compartilhamento pela mesma licença 3.0 Brasil License.