Usando TJvDBGrid – Parte 2

Nesse artigo iremos continuar a aprender os recursos avançados da TJvDBGrid. Aprenderemos hoje a como utilizar componentes Data Aware dentro das células da TJvDBGrid. Esse recurso é muito interessante, porque nos ajuda a editar registros direto pela DBGrid usando os eventos desses componentes.

Informação
Recomendamos a leitura do artigo Usando TJvDBGrid – Parte 1.

Vamos criar a aplicação exemplo então. Crie uma nova aplicação no delphi e adicione os seguintes componentes ao formulário.

• 1 TJvDBgrid
• 1 TDBNavigator
• 2 TClientDataSet
• 2 TDataSource
• 1 TDBEdit
• 1 TDBComboBox
• 1 TDBLookupComboBox

O ClientDataSet1 deverá ter os seguintes campos:

• CHECK :Booleano
• NOME :String[80]
• SEXO :String[10]
• TIPO :String[20]
• OBSERVACAO :Memo

O ClientDataSet2 deverá ter somente um campo chamado DESCRICAO
As seguintes ligações deverão ser feitas:

• JvDBGrid1.DataSource := DataSource1
• DBNavigator1.DataSource := DataSource 1
• DataSource1.DataSet := ClientDataSet 1
• DataSource2.DataSet := ClientDataSet 2
• DBEdit1.DataSource := DataSource1
• DBEdit1.DataField := ‘NOME’
• DBComboBox.DataSource := DataSource1;
• DBComboBox.DataField := ‘SEXO’
• DBLookupComboBox1.DataSource := DataSouce1
• DBLookupComboBox1.DataField := ‘TIPO’
• DBLookupComboBox1.ListSource := DataSource2’
• DBLookupComboBox1.ListField := ‘DESCRICAO’
• DBLookupComboBox1.KeyField := ‘DESCRICAO’

Agora vamos fazer a mágica, vamos alterar a propriedade EditControls da JVDBGrid1. Então selecione os campos NOME, SEXO, OBSERVACAO, TIPO. Depois de selecionados, para cada campo seré atribuido um Edit Control.

• NOME: DBEdit1
• SEXO: DBComboBox1
• OBSERVACAO: DBMemo1 (Mudar a propriedade Rentime Size para Cell Size)
• TIPO: DBLookupComboBox1

Vamos implementar os seguintes códigos:

procedure TForm1.FormCreate(Sender: TObject);
begin
   ClientDataSet1.CreateDataSet;
   ClientDataSet2.CreateDataSet;

   ClientDataSet2.Append;
   ClientDataSet2DESCRICAO.AsString := 'Cliente';
   ClientDataSet2.Post;

   ClientDataSet2.Append;
   ClientDataSet2DESCRICAO.AsString := 'Fornecedor';
   ClientDataSet2.Post;

   ClientDataSet2.Append;
   ClientDataSet2DESCRICAO.AsString := 'Transportadora';
   ClientDataSet2.Post;

   ClientDataSet2.Append;
   ClientDataSet2DESCRICAO.AsString := 'Funcionario';
   ClientDataSet2.Post;

   ClientDataSet2.Append;
   ClientDataSet2DESCRICAO.AsString := 'Outros';
   ClientDataSet2.Post;

   DBComboBox1.Items.Add('Feminino');
   DBComboBox1.Items.Add('Masculino');
end;

procedure TForm1.JvDBGrid1ColumnResized(Grid: TJvDBGrid; ACol,
  NewWidth: Integer);
begin
   if JvDBGrid1.Columns[Acol].FieldName = 'OBSERVACAO' then
      DBMemo1.Width := NewWidth;
end;

Pronto! Se tudo ocorrer bem você já terá uma aplicação de exemplo que utiliza os componentes data aware direto na edição da JvDBGrid.

Dica
Outros componentes podem ser utilizados na TJVDBGrid desde que sejam componentes data aware. 

Abaixo está uma imagem de como ficará aplicação final



No próximo artigo aprederemos como estilizar nossa TJvDBGrid.

Baixe os fontes do artigo no GitHub

Usando TJvDBGrid – Parte 1

Hoje eu começo uma série de artigos ensinando como utilizar os recursos avançados do componente TJvDBGrid. Ele faz parte dos componentes JEDI VCL que são gratuitos e livres.

Caso ainda não tenha o JEDI VCL instalado você pode fazer o download a partir do site http://jvcl.delphi-jedi.org/.

Com o TJvDBGrid pode-se facilmente criar colunas que mostram campos no formato de checbox, também permite o congelamento de colunas e facilita a edição de dados na grid. Nessa primeira parte ensinarei como utilizar as colunas que mostram os dados de formato de checkbox.
Crie uma nova aplicação no seu delphi e inclua os seguintes componentes ao formulário.

• TDBNavigator
• TJvDBGrid
• TClientDataSet
• TDataSource

Crie no ClientDataSet1 os seguintes campos

• CHECK :Booleano
• DESCRIÇÃO :String[80]

Faça as seguintes ligações dos componentes:

• DataSource1.DataSet := ClientDataSet1
• JvDBGrid1.DataSource := Datasource1
• DBNavigator1.DataSource := DataSource1

No evento OnCreate do formulário coloque o seguinte código

procedure TForm1.FormCreate(Sender: TObject); 
begin 
   ClientDataSet1.CreateDataSet; 
end;

No evento AfterInsert do Clientdataset1 coloque o seguinte código:

procedure TForm1.ClientDataSet1AfterInsert(DataSet: TDataSet); 
begin 
   ClientDataSet1CHECK.AsBoolean := false; 
end;

No evento OnCellClick do JvDBGrid1 coloque o seguinte Código:

if Column.FieldName = 'CHECK' then 
begin 
   if ClientDataSet1.IsEmpty then 
      exit; 
   if ClientDataSet1.State = dsBrowse then 
      ClientDataSet1.Edit; 

   ClientDataSet1CHECK.AsBoolean := not ClientDataSet1CHECK.AsBoolean; 
   ClientDataSet1.Post; 
end;

Pronto! Basta executar o exemplo e incluir registros usando o JVDBNavigator, assim quando clicarmos na coluna CHECK será marcado ou desmarcado o checkbox dela.



É isso aí, até o próximo artigo pessoal!!!

Dica
O fato da coluna CHECK ser do tipo Booleano faz com que a JvDBGrid1 interprete automaticamente a coluna como visualização de checbox, no entanto podemos fazer isso para colunas de outros tipos de dados.
Ex.: Se a coluna CHECK fosse um String[1] e mostrasse valores S ou N então bastaria utilizar o evento OnCheckIfBooleanField e Alterar as variáveis StringForTrue := 'S' e StringForFalse := 'N'

Baixe os fontes do artigo no GitHub

XML Data Bind no Delphi

Neste artigo vou ensinar como trabalhar com arquivos XMLs de uma forma sofisticada e de alto nível. Para melhor compreensão deste recurso recomendo a leitura dos artigos Manipulação de XML com TXMLDocument, Manipulação de XML com TXMLDocument – Parte 2 e Manipulação de XML com TXMLDocument – Parte 3. Também estou considerando que você tem uma noção básica sobre XML e XML Schema, mas caso não, recomendo as seções sobre XML e XML Schema do site w3schools.

Observação
Utilizaremos nos exemplos o delphi XE, no entanto o XML Data Bind existe desde o Delphi 6, as versões anteriores eu não conheço, assim não posso afirmar se existe ou não o recurso.

Usaremos para esse exemplo um arquivo XML que representa um pedido:

<?xml version="1.0" encoding="ISO-8859-1"?>
<shiporder orderid="889923" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="shiporder.biz">
  <orderperson>John Smith</orderperson>
  <shipto>
    <name>Ola Nordmann</name>
    <address>Langgt 23</address>
    <city>4000 Stavanger</city>
    <country>Norway</country>
  </shipto>
  <item>
    <title>Empire Burlesque</title>
    <note>Special Edition</note>
    <quantity>1</quantity>
    <price>10.90</price>
  </item>
  <item>
    <title>Hide your heart</title>
    <quantity>1</quantity>
    <price>9.90</price>
  </item>
</shiporder>

shiporder	Elemento raiz que representa o pedido, ele possui o atributo orderid que possui o código do pedido
orderperson	Pessoa que fez o pedido
shipto	Dados de entrega name: Pessoa que receberá o pedido adress: Endereço de entrega city: Cidade de entrega country: Pais de entrega
item	Dados do produto no pedido title: Descrição do produto note: Observação do produto price: Preço do produto  quantity: Quantidade do produto no pedido

Para definir a estrutura e restrições do XML temos o seguinte XML Schema que é chamado de XSD (XML Schema Definition).

<?xml version="1.0" encoding="ISO-8859-1" ?>

<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:simpleType name="stringtype">
  <xs:restriction base="xs:string"/>
</xs:simpleType>

<xs:simpleType name="inttype">
  <xs:restriction base="xs:positiveInteger"/>
</xs:simpleType>

<xs:simpleType name="dectype">
  <xs:restriction base="xs:decimal"/>
</xs:simpleType>

<xs:simpleType name="orderidtype">
  <xs:restriction base="xs:string">
    <xs:pattern value="[0-9]{6}"/>
  </xs:restriction>
</xs:simpleType>

<xs:complexType name="shiptotype">
  <xs:sequence>
    <xs:element name="name" type="stringtype"/>
    <xs:element name="address" type="stringtype"/>
    <xs:element name="city" type="stringtype"/>
    <xs:element name="country" type="stringtype"/>
  </xs:sequence>
</xs:complexType>

<xs:complexType name="itemtype">
  <xs:sequence>
    <xs:element name="title" type="stringtype"/>
    <xs:element name="note" type="stringtype" minOccurs="0"/>
    <xs:element name="quantity" type="inttype"/>
    <xs:element name="price" type="dectype"/>
  </xs:sequence>
</xs:complexType>

<xs:complexType name="shipordertype">
  <xs:sequence>
    <xs:element name="orderperson" type="stringtype"/>
    <xs:element name="shipto" type="shiptotype"/>
    <xs:element name="item" maxOccurs="unbounded" type="itemtype"/>
  </xs:sequence>
  <xs:attribute name="orderid" type="orderidtype" use="required"/>
</xs:complexType>

<xs:element name="shiporder" type="shipordertype"/>

</xs:schema>

Importaremos o arquivo XSD usando o XMLDataBind do delphi que está em: File / New / Other / Delphi Projects / XML, para isso criemos uma nova aplicação no delphi.

Será apresentado um wizard do XML Data Bind. Informe o caminho do arquivo XSD

Atenção!
Nesse exemplo salvamos o arquivo XSD com a extensão .biz, pois o delphi XE não importa corretamente o arquivo se ele possuir a extensão .xsd

Ao clicar em avançar percebemos que na próxima tela foi gerada uma estrutura baseada no arquivo XSD, essas estruturas são interfaces e classes para facilitar a manipulação do XML. Nessa parte se desejar poderá fazer alterações nessas estruturas e interfaces.

Ao clicar novamente em avançar será mostrado uma outra tela com todo o código fonte que será gerado

Agora basta finalizar e salvar a unit gerada pelo wizard.

No TForm da sua aplicação coloque um TMemo, um open dialog e dois TButtons. No evento onClick de um dos TButtons coloque o seguinte código

procedure TForm1.Button1Click(Sender: TObject);
var
   pedido :IXMLShipordertype;
   item :IXMLItemtype;
   begin
   //Cria uma nova instância da estrutura de classes para criar um novo XML
   pedido := Newshiporder();
   
   //Informações do pedido
   pedido.Orderid := '123456';
   pedido.Orderperson := 'Livraria X';
   
   //Informações do destinatário do pedido
   pedido.Shipto.Name := 'Jocimar B. A. Huss ';
   pedido.Shipto.Address := 'R. Carapicuiba 23';
   pedido.Shipto.City := 'Mandaguari PR';
   pedido.Shipto.Country := 'Brasil';

   //Inclui um novo item ao pedido<
   item := pedido.Item.Add;
   item.Title := 'Programacacao em Delphi';
   item.Quantity := 4;
   item.Price := '102,33';
   item.Note := 'Nao aborda versoes mais antigas da IDE delphi';
   
   //Inclui um novo item ao pedido
   item := pedido.Item.Add;
   item.Title := 'Programacacao em Java - Iniciante';
   item.Quantity := 1;
   item.Price := '140,00';
   item.Note := 'Somente o basico do java';
   
   Memo1.Text :=  pedido.XML;

   memo1.Lines.SaveToFile(ExtractFilePath(Application.ExeName) + 'shiporder.xml');
end;

No evento onClick do outro TButton coloque o seguinte código

procedure TForm1.Button2Click(Sender: TObject);
var
   pedido :IXMLShipordertype;
      i :Integer;
begin
   OpenDialog1.InitialDir := ExtractFilePath(Application.ExeName);
   
   //Pergunta qual arquivo xml deseja abrir
   if not OpenDialog1.Execute then
      exit;
   
   //Cria uma nova instância da estrutura de classes para fazermos o bind
   pedido := Loadshiporder(OpenDialog1.FileName);
   
   memo1.Clear;
   
   //Informações do pedido
   memo1.Lines.Add('[Informações do pedido]');
   memo1.Lines.Add('Código do pedido: ' + pedido.Orderid)
   memo1.Lines.Add('Pessoa do Pedido: '+pedido.Orderperson);
   
   memo1.Lines.Add('');
   memo1.Lines.Add('[Dados do destinatário do pedido]');
   
   //Infomações do destinatário do pedido
   memo1.Lines.Add('Nome: ' + pedido.Shipto.Name);
   memo1.Lines.Add('Endereço: ' + pedido.Shipto.Address);
   memo1.Lines.Add('Cidade: ' + pedido.Shipto.City);
   memo1.Lines.Add('Pais: ' + pedido.Shipto.Country);
   memo1.Lines.Add('');
   
   //Inclui um novo item ao pedido
   memo1.Lines.Add('[Itens do pedido]');
   for i := 0 to pedido.Item.Count - 1 do
   begin
     memo1.Lines.Add('Titulo: ' + pedido.Item[i].Title);
     memo1.Lines.Add('Quantidade: ' + IntToStr(pedido.Item[i].Quantity));
     memo1.Lines.Add('Preço: ' + pedido.Item[i].Price);
     memo1.Lines.Add('Observação: ' + pedido.Item[i].Note);
     
     memo1.Lines.Add('');
   end;
end;

Pronto, o exemplo já conseguimos gerar um XML e ler um XML gerado na estrutura definida pelo XSD de exemplo. Bom é isso aí, caso tenham dúvidas postem na seção de comentários.

Atenção!
Caso o XML gerado possuir acentos ou outro caractere especial, acontecerá um erro ao carrega-lo. Não pude resolver esse problema, pois não  consegui informar o Encoding do XML.

Baixe os fontes do artigo no GitHub

Manipulação de XML com TXMLDocument – Parte 3

Nos artigos anteriores aprendemos a trabalhar com XML, tanto para criar como para ler um XML usando o componente TXMLDocument. Com o que aprendemos até agora já conseguimos fazer o básico.

Agora abordarei alguns pontos que não mostrei na parte 1 e parte 2 dessa série de artigos sobre XML.

Usaremos o mesmo XML dos artigos anteriores, mas com algumas pequenas modificações.

 <atualizacao>
  <executaveis>
    <executavel versao="1.0.3.22">Módulo gerencial</executavel>
    <executavel versao="1.0.3.123">Configurações da Aplicação</executavel>
  </executaveis>
  <bibliotecas>
    <biblioteca versao="2.0.0.1">Biblioteca de funções</biblioteca>
    <biblioteca versao="1.2.0.4">Biblioteca com rotinas de negócio da aplicação</biblioteca>
  </bibliotecas>
  <observacoes><![CDATA[Nesta parte pode ser escrito um texto muito longo que possua quebras de linhas, caracteres especiais, incluindo "<" e ">", ou até gravar textos de outro arquivo XML, HTML ou RTF.
O CData é como se fosse um Blog no XML]]></observacoes>
</atualizacao>

Neste XML não colocaremos a descrição do executável e da biblioteca em um atributo chamado “descrição” <executavel descricao=”Descrição do módulo”> e sim em um texto para o nó <executavel>Descrição do módulo</executavel>. Também incluímos no XML o nó “observacoes”, ele tem o objetivo de guardar um texto grande com quebras de linhas, acentos e caracteres especiais, para isso foi criado dentro do nó “observacoes” um nó <![CData[Texto grande]]>. Vejamos então como fazer isso via programação.

Crie uma nova aplicação no delphi e coloque no formulário dois TMemos e dois TButtons e um TXMLDocument.

No evento onClick de um dos botões coloque o seguinte código:

procedure TForm1.Button1Click(Sender: TObject);
var
  atualizacao :IXMLNode;
  executaveis :IXMLNode;
  executavel :IXMLNode;
  bibliotecas :IXMLNode;
  biblioteca :IXMLNode;
  observacoes :IXMLNode;

  dadosObservacoes :IDOMCDATASection;

begin
  //Formata automaticamente o XML para que a visualização no TMemmo fique
  // mais amigável
  XMLDocument1.Options := XMLDocument1.Options + [doNodeAutoIndent];

  //Ativa o componente TXMLDocument
  XMLDocument1.Active := true;

  //Cria o nó principal do xml
  atualizacao := XMLDocument1.AddChild('atualizacao');

  //Cria o nó dos executaveis dentro do nó principal
  executaveis := atualizacao.AddChild('executaveis');

  //Adiciona um executavel ao nó de executaveis
  executavel := executaveis.AddChild('executavel');
  executavel.SetAttributeNS('versao','','1.0.3.22');

  //Observe que não criamos um atributo "descricao" para o nó executável como
  // o atributo "versão", mas adicionamos a descrição do executável direto para
  //o texto do nó.
  executavel.Text := 'Módulo gerencial';

  //Adiciona um executavel ao nó de executaveis
  executavel := executaveis.AddChild('executavel');
  executavel.SetAttributeNS('versao','','1.0.3.123');
  executavel.Text := 'Configurações da Aplicação';

  //Cria o nó de bibliotecas dentro do nó principal
  bibliotecas := atualizacao.AddChild('bibliotecas');

  //Adiciona uma biblioteca ao nó de biblioteca
  biblioteca := bibliotecas.AddChild('biblioteca');
  biblioteca.SetAttributeNS('versao','','2.0.0.1');
  biblioteca.Text := 'Biblioteca de funções';

  //Adiciona uma biblioteca ao nó de biblioteca
  biblioteca := bibliotecas.AddChild('biblioteca');
  biblioteca.SetAttributeNS('versao','','1.2.0.4');
  biblioteca.Text := 'Biblioteca com rotinas de negócio da aplicação';

  observacoes := atualizacao.AddChild('observacoes');

  //Cria um Blob de observações no
  dadosObservacoes := XMLDocument1.DOMDocument.createCDATASection('Nesta parte pode '+
    'ser escrito um texto muito longo que possua quebras de linhas, caracteres '+
    'especiais, incluindo "<" e ">", ou até gravar textos de outro arquivo XML, HTML ou RTF.'+
    sLineBreak+
    'O CData é como se fosse um Blog no XML');

  //Adicionamos um novo nó em nosso XML onde ele possuirá as observações que escrevemos
  // para dadosObservacoes
  observacoes.DOMNode.appendChild(dadosObservacoes);

  //Mostra o arquivo xml gerado
  Memo1.Lines.Text := XMLDocument1.XML.Text;
end;

No evento onClick do outro botão  coloque o seguinte código

procedure TForm1.Button2Click(Sender: TObject);
var
  no :IXMLNode;
  atualizacao :IXMLNode;
begin
   //Para recuperar as observações que gravamos em CData basta encontrar
   // o nó de observacoes e pegar sua propriedade Text.
   // Consideramos aqui que o XMLDocument1 já esta ativado e com o XMLs

   atualizacao := XMLDocument1.ChildNodes.FindNode('atualizacao');
   no          := atualizacao.ChildNodes.FindNode('observacoes');
   Memo2.Text := no.Text;
end;

Novamente espero ter ajudado de alguma forma e aguardo suas dúvidas e sugestões.

Baixe os fontes do artigo no GitHub

Manipulação de XML com TXMLDocument – Parte 2

Dando continuidade ao artigo sobre manipulação de XML onde estou mostrando como manipular arquivos XML utilizando o componente TXMLDocument, explicarei hoje como criar o seu próprio arquivo XML, pois no artigo anterior somente fizemos a manipulação de um arquivo XML já pronto.
Mostrarei como criar um XML a seguinte estrutura:

<atualizacao>
  <executaveis>
    <executavel versao='1.0.3.22' descricao='Modulo gerencial'>gerencial.exe</executavel>
    <executavel versao='1.0.3.123' descricao='Configuracoes da Aplicacao'>configuracoes.exe</executavel>
  </executaveis>
  <bibliotecas>
    <biblioteca versao='2.0.0.1' descricao='Biblioteca de funcoes'>funcoes.dll</biblioteca>
    <biblioteca versao='1.2.0.4' descricao='Biblioteca com rotinas de negocio da aplicacao'>app.dll</biblioteca>
  </bibliotecas>
</atualizacao>

Então vamos lá! Crie no delphi um novo projeto e arraste um TMemo, um TButton e um TXMLDocument para o Form.



No evento onClick do TButton que foi adicionado a tela, escreva o seguinte código:

procedure TForm1.Button1Click(Sender: TObject);
var
  atualizacao :IXMLNode;
  executaveis :IXMLNode;
  executavel :IXMLNode;
  bibliotecas :IXMLNode;
  biblioteca :IXMLNode;
begin
  //Ativa o componente TXMLDocument
  XMLDocument1.Active := true;

  //Cria o nó principal do xml
  atualizacao := XMLDocument1.AddChild('atualizacao');

  //Cria o nó dos executaveis dentro do nó principal
  executaveis := atualizacao.AddChild('executaveis');

  //Adiciona um executavel ao nó de executaveis
  executavel := executaveis.AddChild('executavel');
  executavel.SetAttributeNS('versao','','1.0.3.22');
  executavel.SetAttributeNS('descricao','','Modulo gerencial');
  executavel.Text := 'gerencial.exe'; 

  //Adiciona um executavel ao nó de executaveis
  executavel := executaveis.AddChild('executavel');
  executavel.SetAttributeNS('versao','','1.0.3.123');
  executavel.SetAttributeNS('descricao','','Configuracoes da Aplicacao');
  executavel.Text := 'configuracoes.exe';

  //Cria o nó de bibliotecas dentro do nó principal
  bibliotecas := atualizacao.AddChild('bibliotecas');

  //Adiciona uma biblioteca ao nó de biblioteca
  biblioteca := bibliotecas.AddChild('biblioteca');
  biblioteca.SetAttributeNS('versao','','2.0.0.1');
  biblioteca.SetAttributeNS('descricao','','Biblioteca de funcoes');
  biblioteca.Text := 'funcoes.dll';

  //Adiciona uma biblioteca ao nó de biblioteca
  biblioteca := bibliotecas.AddChild('biblioteca');
  biblioteca.SetAttributeNS('versao','','1.2.0.4');
  biblioteca.SetAttributeNS('descricao','','Biblioteca com rotinas de negocio da aplicacao');
  biblioteca.Text := 'app.dll'; 

  //Mostra o arquivo xml gerado
  Memo1.Lines.Text := XMLDocument1.XML.Text;
end;

Se tudo ocorrer bem ao clicar no TButton do formulário será apresentado o texto do XML gerado pelo exemplo.

É isso aí pessoal, espero ter ajudado e aguardo suas dúvidas, comentários e sugestões.

Baixe os fontes do artigo no GitHub

Manipulação de XML com TXMLDocument

Neste artigo mostrarei como usar o componente TXMLDocument do delphi para manipular arquivos XML. Em várias situações podemos utilizar arquivos XML em nossas aplicações como por exemplo para guardar as configurações.
Para exemplificar vou utilizar um XML que tem a finalidade de guardar informações para a atualização de um conjunto de executáveis e bibliotecas.

<atualizacao>
  <executaveis>
    <executavel versao='1.0.3.22' descricao='Modulo gerencial'>gerencial.exe</executavel>
    <executavel versao='1.0.3.123' descricao='Configuracoes da Aplicacao'>configuracoes.exe</executavel>
  </executaveis>
  <bibliotecas>
    <biblioteca versao='2.0.0.1' descricao='Biblioteca de funcoes'>funcoes.dll</biblioteca>
    <biblioteca versao='1.2.0.4' descricao='Biblioteca com rotinas de negocio da aplicacao'>app.dll</biblioteca>
  </bibliotecas>
</atualizacao>

Para criar esse exemplo estou utilizando a IDE delphi XE, mas você pode utilizar versões anteriores. Vamos por a mão na massa então! Crie um novo projeto no delphi e arraste um o componente TXMLDocument para o formulário.



Agora vamos copiar o XML de exemplo acima para a propriedade XML do TXMLDocument que adicionamos ao formulário. Também vamos adicionar um TMemo e um TButton ao formulário.



Coloque o código abaixo no evento de clique do botão que adicionamos na tela:

procedure TForm1.Button1Click(Sender: TObject);
var aplicacao :IXMLNode;

    executaveis :IXMLNode;
    executavel :IXMLNode;

    bibliotecas :IXMLNode;
    biblioteca :IXMLNode;

    versao :IXMLNode;
    descricao :IXMLNode;
    infNo :IXMLNodeList;

    i :Integer;
begin
   Memo1.Clear;

   //Ativa o XMLDocument para podemos ler as informações do xml
   XMLDocument1.Active := true;

   //Busco o nó principal do xml
   aplicacao := XMLDocument1.DocumentElement;

   //Busca o nó onde está a lista de executáveis
   executaveis := aplicacao.ChildNodes.FindNode('executaveis');

   //Busca o nó onde está a lista de bibliotecas
   bibliotecas := aplicacao.ChildNodes.FindNode('bibliotecas');

   memo1.Lines.Add('[EXECUTAVEIS]');
   memo1.Lines.Add('');

   //Percorre todos os executáveis da lista
   for i := 0 to executaveis.ChildNodes.Count - 1 do
   begin
      executavel := executaveis.ChildNodes[i];
      //recupera os atributos do nó executavel
      infNo      := executavel.AttributeNodes;

      memo1.Lines.Add(executavel.Text);
      memo1.Lines.Add('-------------------------');
      memo1.Lines.Add('versão: '+infNo.FindNode('versao').Text);
      memo1.Lines.Add('descrição: '+infNo.FindNode('descricao').Text);
      memo1.Lines.Add('');
   end;

   memo1.Lines.Add('');
   memo1.Lines.Add('[BIBLIOTECAS]');
   memo1.Lines.Add('');

   //Percorre todas as bibliotecas
   for i := 0 to bibliotecas.ChildNodes.Count - 1 do
   begin
      biblioteca := bibliotecas.ChildNodes[i];

      //recupera os atributos do nó biblioteca
      infNo      := biblioteca.AttributeNodes;

      memo1.Lines.Add(biblioteca.Text);
      memo1.Lines.Add('-------------------------');
      memo1.Lines.Add('versão: '+infNo.FindNode('versao').Text);
      memo1.Lines.Add('descrição: '+infNo.FindNode('descricao').Text);
      memo1.Lines.Add('');
   end;
end;

Podemos observar que o código simplesmente manipula o XML de exemplo gerando um texto mostrando algumas de suas informações.
Bom é isso! Deixem seus comentários e dúvidas. Até a próxima.

Baixe os fontes do artigo no GitHub