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.

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.

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.

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.

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.

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.

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.

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.