Difference between revisions of "XML Tutorial/fr"

From Free Pascal wiki
Jump to navigationJump to search
m (Fixed syntax highlighting)
 
(44 intermediate revisions by 7 users not shown)
Line 1: Line 1:
 
{{XML Tutorial}}
 
{{XML Tutorial}}
  
=== Introduction ===
+
== Introduction ==
  
The Extensible Markup Language is a [http://www.w3.org/ W3C] recommended language created to interchange information between different systems. It is a text based way to store information. Modern data interchange languages such as XHTML, as well as most WebServices technologies, are based on XML.
+
Le langage de balises extensible (''eXtensible Markup Language'') est un langage recommandé par le [http://www.w3.org/ W3C] créé pour l'échange d'informations entre différents systèmes. Il propose le stockage d'informations sous forme de texte. Les langages modernes d'échanges de données comme le XHTML, tout comme la plupart des  technologies WebServices, sont fondés sur le XML.
  
Currently there is a set of units that provides support for XML on Free Pascal. These units are called "XMLRead", "XMLWrite" and "DOM" and they are part of the Free Component Library (FCL) from the Free Pascal Compiler. The FCL is already on the default search path for the compiler on Lazarus, so you only need to add the units to your uses clause in order to get XML support. The FCL is not documented currently (October / 2005), so this short tutorial aims at introducing XML access using those units.
+
Il existe actuellement un ensemble d'unités qui offrent le support du XML à Free Pascal. Ces unités appelées ''XMLRead'', ''XMLWrite'' et ''DOM'' font partie de la ''Free Component Library'' (FCL) du compilateur Free Pascal. La FCL est déjà sur le chemin de recherche par défaut du compilateur de Lazarus : vous n'avez donc qu'à ajouter ces unités à votre clause ''uses'' pour obtenir l'accès au XML. La FCL n'étant que partiellement documentée à ce jour (mai 2015), ce petit tutoriel vise à introduire l'utilisation minimale du XML en utilisant ces unités.
  
The XML DOM (Document Object Model) is a set of standarized objects that provide a similar interface for the use of XML on different languages and systems. The standard only specifies the methods, properties and other interface parts of the object, leaving the implementation free for different languages. The FCL currently supports fully the [http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001/ XML DOM 1.0].
+
Le DOM XML (''Document Object Model'') est un ensemble d'objets standardisés offrant une interface similaire pour l'utilisation du XML avec différents langages et systèmes. Le standard spécifie uniquement les méthodes, propriétés et autres parties d'interface de l'objet, laissant l'implémentation libre pour les différents langages. La FCL supporte totalement le [http://www.w3.org/TR/2000/REC-DOM-Level-2-Core-20001113/ XML DOM 2.0] et un sous-ensemble du [http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/ XML DOM 3.0] détaillé [[dom|ici]].
  
=== Basic Example ===
+
== Exemples ==
  
For Delphi Programmers:
+
Ci-dessous figure une série d'exemples de manipulations de données XML dont la complexité va en croissant.
Note that when working with TXMLDocument, the text within a Node is considered a separate TEXT Node.  As a result, you must access a node's text value as a separate node. For instance, consider the following XML:
 
  
<xml>
+
== Unités dans la clause ''uses'' : Unicode ou Ansi ==
  <?xml version="1.0" encoding="utf-8"?>
+
 
 +
FPC est accompagné d'unités XML fondées sur des routines dont le codage correspond à la norme ANSI si bien que les résultats sur différentes plateformes peuvent ne pas être homogènes et en particulier non Unicode. Lazarus fournit un ensemble complémentaire d'unités XML avec le paquet ''LazUtils'' qui supporte totalement le codage Unicode UTF-8 pour toutes les plateformes. Toutes ces unités sont compatibles : pour passer de l'une à l'autre, il suffit d'adapter la clause ''uses'' en conséquence.
 +
 
 +
Les unités proposées par FPC pour le traitement du XML sont (chaînes encodées selon l'encodage du système) :
 +
 
 +
    ''DOM''
 +
    ''XMLRead''
 +
    ''XMLWrite''
 +
    ''XMLCfg''
 +
    ''XMLUtils''
 +
    ''XMLStreaming''
 +
 
 +
Les unités proposées par Lazarus pour le traitement du XML sont (chaînes avec support de l'Unicode UTF-8 sur toutes les plateformes) :
 +
 
 +
    ''laz2_DOM''
 +
    ''laz2_XMLRead''
 +
    ''laz2_XMLWrite''
 +
    ''laz2_XMLCfg''
 +
    ''laz2_XMLUtils''
 +
    ''laz_XMLStreaming''
 +
 
 +
Toutes ces unités ne sont pas nécessaires pour chacun des exemples qui suivent. Vous aurez toutefois toujours besoin de l'unité ''DOM'' (ou ''laz2_DOM'') dans la mesure où elle définit plusieurs types dont ''TXMLDocument''.
 +
 
 +
=== Lire un nœud de texte ===
 +
 
 +
Pour les programmeurs Delphi : notez que lorsque vous travaillez avec ''TXMLDocument'', le texte à l'intérieur d'un nœud est considéré comme un nœud de texte séparé.  Vous devez donc accéder à une valeur texte d'un nœud comme à un nœud séparé.
 +
 
 +
Par exemple, considérez le  XML suivant :
 +
 
 +
<syntaxhighlight lang="xml">
 +
  <?xml version="1.0"?>
 
  <request>
 
  <request>
 
   <request_type>PUT_FILE</request_type>
 
   <request_type>PUT_FILE</request_type>
Line 21: Line 50:
 
   <password>abc</password>
 
   <password>abc</password>
 
  </request>
 
  </request>
</xml>
+
</syntaxhighlight>
  
Consider also the following code example:
+
L'exemple de code suivant montre la bonne et la mauvaise façon d'obtenir la valeur du texte du nœud :
  
<pascal>
+
<syntaxhighlight lang=pascal>
 
  var
 
  var
 
   PassNode: TDOMNode;
 
   PassNode: TDOMNode;
 
   Doc:      TXMLDocument;
 
   Doc:      TXMLDocument;
 
  begin
 
  begin
  Doc := TXMLDocument.Create;
+
   // Lit le fichier xml depuis le disque
   // Read in xml file from disk
 
 
   ReadXMLFile(Doc, 'c:\xmlfiles\test.xml');
 
   ReadXMLFile(Doc, 'c:\xmlfiles\test.xml');
   // Retrieve the "password" node
+
   // Récupère le nœud "password"
 
   PassNode := Doc.DocumentElement.FindNode('password');
 
   PassNode := Doc.DocumentElement.FindNode('password');
   // Write out value of the selected node
+
   // Ecrit la valeur du nœud sélectionné
   WriteLn(PassNode.NodeValue); // will be blank
+
   WriteLn(PassNode.NodeValue); // ce sera vide
   // The text of the node is actually a separate child node
+
   // Le texte du nœud est réellement  un nœud enfant distinct
   WriteLn(PassNode.FirstChild.NodeValue); // correctly prints "abc"
+
   WriteLn(PassNode.FirstChild.NodeValue); // affiche correctement "abc"
</pascal>  
+
</syntaxhighlight>
  
 +
=== Afficher les noms des nœuds ===
  
Let´s say you want to access a XML file called 'C:\Programas\teste.xml'. Here is the file content:
+
L'exemple suivant montre comment afficher les noms des nœud dans un ''TMemo'' placé sur une fiche.
  
<xml>
+
Ci-dessous le fichier XML appelé 'C:\Programs\test.xml' :
  <?xml version="1.0" encoding="ISO-8859-1"?>
+
 
 +
<syntaxhighlight lang="xml">
 +
  <?xml version="1.0"?>
 
  <images directory="mydir">
 
  <images directory="mydir">
 
   <imageNode URL="graphic.jpg" title="">
 
   <imageNode URL="graphic.jpg" title="">
Line 52: Line 83:
 
   </imageNode>
 
   </imageNode>
 
  </images>
 
  </images>
</xml>
+
</syntaxhighlight>
  
The following code can write the Node´s names to a TMemo placed on a form:
+
Et ci-après le code Pascal pour exécuter la tâche :
  
<pascal>
+
<syntaxhighlight lang=pascal>
 
  var
 
  var
  Documento: TXMLDocument;
+
  Document: TXMLDocument;
  i, j: Integer;
+
  i, j: Integer;
 
  begin
 
  begin
  Documento := TXMLDocument.Create;
+
  ReadXMLFile(Document, 'C:\Programs\test.xml');
  ReadXMLFile(Documento, 'C:\Programas\teste.xml');
+
  Memo.Lines.Clear;
  Memo.Lines.Clear;
+
  with Document.DocumentElement.ChildNodes do
  with Documento.DocumentElement.ChildNodes do
+
  begin
  begin
+
    for i := 0 to (Count - 1) do
    for i := 0 to (Count - 1) do
+
    begin
    begin
+
      Memo.Lines.Add(Item[i].NodeName + ' ' + Item[i].Attributes.Item[0].NodeValue);
      Memo.Lines.Add(Item[i].NodeName + ' ' + Item[i].NodeValue);
+
      for j := 0 to (Item[i].ChildNodes.Count - 1) do
      for j := 0 to (Item[i].ChildNodes.Count - 1) do
+
      begin
      begin
+
        Memo.Lines.Add(Item[i].ChildNodes.Item[j].NodeName + ' '
        Memo.Lines.Add(Item[i].ChildNodes.Item[j].NodeName + ' '
+
          + Item[i].ChildNodes.Item[j].FirstChild.NodeValue);
        + Item[i].ChildNodes.Item[j].NodeValue);
+
      end;
      end;
+
    end;
    end;
+
  end;
  end;
+
  Document.Free;
  Documento.Free;
 
 
  end;
 
  end;
</pascal>
+
</syntaxhighlight>
 +
 
 +
Ce qui affichera:
 +
 
 +
<pre>
 +
imageNode graphic.jpg
 +
Peca Pecacastelo.jpg1.swf
 +
Peca Pecacastelo.jpg1.swf
 +
</pre>
  
=== Populating a TreeView with XML ===
+
=== Peupler un TreeView avec XML ===
  
One common use of XML files is to parse them and show their contents in a tree like format. You can find the TTreeView component on the "Common Controls" tab on Lazarus.
+
Une utilisation courante des fichers XML est de les analyser et d'afficher leur contenu sous forme d'arborescence. Pour ce faire, vous pouvez utiliser le composant ''TTreeView'' présent sous l'onglet ''Common Controls'' de Lazarus.
  
The function below will take a XML document previously loaded from a file or generated on code, and will populate a TreeView with it´s contents. The caption of each node will be the content of the first attribute of each node.
+
La procédure ci-dessous va prendre un document XML précédemment chargé depuis un fichier ou généré par code, avant de peupler un ''TreeView'' avec son contenu. La légende de chaque nœud de l'arbre sera le contenu du premier attribut de chaque nœud du document XML.
  
<pascal>
+
<syntaxhighlight lang=pascal>
 
procedure TForm1.XML2Tree(tree: TTreeView; XMLDoc: TXMLDocument);
 
procedure TForm1.XML2Tree(tree: TTreeView; XMLDoc: TXMLDocument);
 
var
 
var
Line 94: Line 132:
 
   var
 
   var
 
     cNode: TDOMNode;
 
     cNode: TDOMNode;
 +
    s: string;
 
   begin
 
   begin
     if Node = nil then Exit; // Stops if reached a leaf
+
     if Node = nil then Exit; // Stoppe si on a atteint une feuille
 +
 
 +
    // Ajoute un nœud à l'arbre s'il existe
 +
    if Node.HasAttributes and (Node.Attributes.Length>0) then
 +
      s := Node.Attributes[0].NodeValue
 +
    else
 +
      s := '';
 +
    TreeNode := tree.Items.AddChild(TreeNode, s);
 
      
 
      
    // Adds a node to the tree
 
    TreeNode := tree.Items.AddChild(TreeNode, Node.Attributes[0].NodeValue);
 
  
     // Goes to the child node
+
     // Va au nœud enfant
 
     cNode := Node.ChildNodes.Item[0];
 
     cNode := Node.ChildNodes.Item[0];
  
     // Processes all child nodes
+
     // Traite tous les nœuds enfants
 
     while cNode <> nil do
 
     while cNode <> nil do
 
     begin
 
     begin
Line 115: Line 159:
 
   while iNode <> nil do
 
   while iNode <> nil do
 
   begin
 
   begin
     ProcessNode(iNode, nil); // Recursive
+
     ProcessNode(iNode, nil); // Procédure récursive
 
     iNode := iNode.NextSibling;
 
     iNode := iNode.NextSibling;
 
   end;
 
   end;
 
end;
 
end;
</pascal>
+
</syntaxhighlight>
  
=== Modifying a XML document ===
+
=== Modifier un document XML ===
  
The first thing to remember is that TDOMDocument is the "handle" to the DOM. You can get an instance of this class by creating one or by loading a XML document.
+
La première chose à se rappeler est que ''TDOMDocument'' est le "handle" vers le ''DOM''. Vous pouvez obtenir une instance de cette classe en créant ou en chargeant un document XML.
  
Nodes on the other hand cannot be created like a normal object. You *must* use the methods provided by TDOMDocument to create them, and latter use other methods to put them on the correct place on the tree. This is because nodes must be "owned" by a specific document on DOM.
+
D'un autre côté, les nœuds ne peuvent être créés comme des objets classiques. Vous *devez* utiliser les méthodes mises à disposition par ''TDOMDocument'' pour les créer puis utiliser d'autres méthodes pour les placer correctement dans l'arbre. Cela est dû au fait que les nœuds doivent être "possédés" par un document spécifique du ''DOM''.
  
Below are some common methods from TDOMDocument:
+
Ci-dessous sont indiquées quelques méthodes particulièrement utiles de ''TDOMDocument'' :
  
<pascal>
+
<syntaxhighlight lang=pascal>
 
   function CreateElement(const tagName: DOMString): TDOMElement; virtual;
 
   function CreateElement(const tagName: DOMString): TDOMElement; virtual;
 
   function CreateTextNode(const data: DOMString): TDOMText;
 
   function CreateTextNode(const data: DOMString): TDOMText;
Line 135: Line 179:
 
     virtual;
 
     virtual;
 
   function CreateAttribute(const name: DOMString): TDOMAttr; virtual;
 
   function CreateAttribute(const name: DOMString): TDOMAttr; virtual;
</pascal>
+
</syntaxhighlight>
  
And here an example method that will located the selected item on a TTreeView and then insert a child node to the XML document it represents. The TreeView must be previously filled with the contents of a XML file using the [[Networking#Populating a TreeView with XML|XML2Tree function]].
+
''CreateElement'' crée un nouvel élément.
  
<pascal>
+
''CreateTextNode'' crée un noeud texte.
 +
 
 +
''CreateAttribute'' crée un noeud attribut.
 +
 
 +
''CreateCDATASection'' crée une section ''CDATA'' : les caractères de marquage particuliers à XML tels que <> ne sont pas intrepréts au sein d'une section ''CDATA''.
 +
 
 +
Une façon plus facile de manipuler les attributs consiste à utiliser la méthode ''TDOMElement.SetAttribute'' (elle est par ailleurs la propriété par défaut de ''TDOMElement'') :
 +
 
 +
<syntaxhighlight lang=pascal>
 +
// these two statements are equivalent
 +
Element.SetAttribute('name', 'value');
 +
Element['name'] := 'value';
 +
</syntaxhighlight>
 +
 
 +
Et ci-après un exemple de méthode qui localise l'élément sélectionné dans un ''TTreeView'' avant d'insérer un nœud enfant au document XML qu'il représente. Le  ''TreeView'' doit être précédement rempli avec le contenu du fichier XML en utilisant la [[XML Tutorial#Populating a TreeView with XML|fonction XML2Tree]].
 +
 
 +
<syntaxhighlight lang=pascal>
 
procedure TForm1.actAddChildNode(Sender: TObject);
 
procedure TForm1.actAddChildNode(Sender: TObject);
 
var
 
var
Line 146: Line 206:
 
begin
 
begin
 
   {*******************************************************************
 
   {*******************************************************************
   *  Detects the selected element
+
   *  Détection de l'élément sélectionné
 
   *******************************************************************}
 
   *******************************************************************}
 
   if TreeView1.Selected = nil then Exit;
 
   if TreeView1.Selected = nil then Exit;
Line 160: Line 220:
  
 
     {*******************************************************************
 
     {*******************************************************************
     *  Updates the TreeView
+
     *  Mise à jour du TreeView
 
     *******************************************************************}
 
     *******************************************************************}
 
     TreeView1.Items.Clear;
 
     TreeView1.Items.Clear;
Line 168: Line 228:
 
   begin
 
   begin
 
     {*******************************************************************
 
     {*******************************************************************
     *  This function only works on the first level of the tree,
+
     *  Cette fonction n'est opérante qu'au premier niveau de l'arbre,
     *  but can easely modifyed to work for any number of levels
+
     *  mais peut facilement être modifiée pour fonctionner avec plusieurs niveaux
 
     *******************************************************************}
 
     *******************************************************************}
 
   end;
 
   end;
 
end;
 
end;
</pascal>
+
</syntaxhighlight>
  
=== Create a TXMLDocument from a string ===
+
=== Créer un TXMLDocument à partir d'une chaîne ===
  
Given al XML file in MyXmlString, the following code will create it's DOM:
+
Étant donné un fichier XML dans ''MyXmlString'', le code suivant va créer son ''DOM'' :
  
<pascal>
+
<syntaxhighlight lang=pascal>
 
Var
 
Var
 
   S : TStringStream;
 
   S : TStringStream;
Line 189: Line 249:
 
     S.Position:=0;
 
     S.Position:=0;
 
     XML:=Nil;
 
     XML:=Nil;
     ReadXMLFile(XML,S); // Complete XML document
+
     ReadXMLFile(XML,S); // Document XML complet
     // Alternatively:
+
     // Autre possibilité
     ReadXMLFragment(AParentNode,S); // Read only XML fragment.
+
     ReadXMLFragment(AParentNode,S); // Lit uniquement un fragment XML.  
 
   Finally
 
   Finally
 
     S.Free;
 
     S.Free;
 
   end;
 
   end;
 
end;
 
end;
</pascal>
+
</syntaxhighlight>
 +
 
 +
== Liens Externes ==
 +
 
 +
* [http://www.w3schools.com/xml/default.asp W3Schools] Tutoriel XML
 +
 
 +
* [http://www.thomas-zastrow.de/texte/fpcxml/index.php Thomas Zastrow article] FPC et XML

Latest revision as of 03:42, 2 March 2020

Deutsch (de) English (en) español (es) français (fr) magyar (hu) Bahasa Indonesia (id) italiano (it) 日本語 (ja) 한국어 (ko) português (pt) русский (ru) 中文(中国大陆)‎ (zh_CN)

Introduction

Le langage de balises extensible (eXtensible Markup Language) est un langage recommandé par le W3C créé pour l'échange d'informations entre différents systèmes. Il propose le stockage d'informations sous forme de texte. Les langages modernes d'échanges de données comme le XHTML, tout comme la plupart des technologies WebServices, sont fondés sur le XML.

Il existe actuellement un ensemble d'unités qui offrent le support du XML à Free Pascal. Ces unités appelées XMLRead, XMLWrite et DOM font partie de la Free Component Library (FCL) du compilateur Free Pascal. La FCL est déjà sur le chemin de recherche par défaut du compilateur de Lazarus : vous n'avez donc qu'à ajouter ces unités à votre clause uses pour obtenir l'accès au XML. La FCL n'étant que partiellement documentée à ce jour (mai 2015), ce petit tutoriel vise à introduire l'utilisation minimale du XML en utilisant ces unités.

Le DOM XML (Document Object Model) est un ensemble d'objets standardisés offrant une interface similaire pour l'utilisation du XML avec différents langages et systèmes. Le standard spécifie uniquement les méthodes, propriétés et autres parties d'interface de l'objet, laissant l'implémentation libre pour les différents langages. La FCL supporte totalement le XML DOM 2.0 et un sous-ensemble du XML DOM 3.0 détaillé ici.

Exemples

Ci-dessous figure une série d'exemples de manipulations de données XML dont la complexité va en croissant.

Unités dans la clause uses : Unicode ou Ansi

FPC est accompagné d'unités XML fondées sur des routines dont le codage correspond à la norme ANSI si bien que les résultats sur différentes plateformes peuvent ne pas être homogènes et en particulier non Unicode. Lazarus fournit un ensemble complémentaire d'unités XML avec le paquet LazUtils qui supporte totalement le codage Unicode UTF-8 pour toutes les plateformes. Toutes ces unités sont compatibles : pour passer de l'une à l'autre, il suffit d'adapter la clause uses en conséquence.

Les unités proposées par FPC pour le traitement du XML sont (chaînes encodées selon l'encodage du système) :

   DOM
   XMLRead
   XMLWrite
   XMLCfg
   XMLUtils
   XMLStreaming 

Les unités proposées par Lazarus pour le traitement du XML sont (chaînes avec support de l'Unicode UTF-8 sur toutes les plateformes) :

   laz2_DOM
   laz2_XMLRead
   laz2_XMLWrite
   laz2_XMLCfg
   laz2_XMLUtils
   laz_XMLStreaming 

Toutes ces unités ne sont pas nécessaires pour chacun des exemples qui suivent. Vous aurez toutefois toujours besoin de l'unité DOM (ou laz2_DOM) dans la mesure où elle définit plusieurs types dont TXMLDocument.

Lire un nœud de texte

Pour les programmeurs Delphi : notez que lorsque vous travaillez avec TXMLDocument, le texte à l'intérieur d'un nœud est considéré comme un nœud de texte séparé. Vous devez donc accéder à une valeur texte d'un nœud comme à un nœud séparé.

Par exemple, considérez le XML suivant :

 <?xml version="1.0"?>
 <request>
   <request_type>PUT_FILE</request_type>
   <username>123</username>
   <password>abc</password>
 </request>

L'exemple de code suivant montre la bonne et la mauvaise façon d'obtenir la valeur du texte du nœud :

 var
  PassNode: TDOMNode;
  Doc:      TXMLDocument;
 begin
  // Lit le fichier xml depuis le disque
  ReadXMLFile(Doc, 'c:\xmlfiles\test.xml');
  // Récupère le nœud "password"
  PassNode := Doc.DocumentElement.FindNode('password');
  // Ecrit la valeur du nœud sélectionné
  WriteLn(PassNode.NodeValue); // ce sera vide
  // Le texte du nœud est réellement  un nœud enfant distinct
  WriteLn(PassNode.FirstChild.NodeValue); // affiche correctement "abc"

Afficher les noms des nœuds

L'exemple suivant montre comment afficher les noms des nœud dans un TMemo placé sur une fiche.

Ci-dessous le fichier XML appelé 'C:\Programs\test.xml' :

 <?xml version="1.0"?>
 <images directory="mydir">
  <imageNode URL="graphic.jpg" title="">
    <Peca DestinoX="0" DestinoY="0">Pecacastelo.jpg1.swf</Peca>
    <Peca DestinoX="0" DestinoY="86">Pecacastelo.jpg2.swf</Peca>
  </imageNode>
 </images>

Et ci-après le code Pascal pour exécuter la tâche :

 var
   Document: TXMLDocument;
   i, j: Integer;
 begin
   ReadXMLFile(Document, 'C:\Programs\test.xml');
   Memo.Lines.Clear;
   with Document.DocumentElement.ChildNodes do
   begin
     for i := 0 to (Count - 1) do
     begin
       Memo.Lines.Add(Item[i].NodeName + ' ' + Item[i].Attributes.Item[0].NodeValue);
       for j := 0 to (Item[i].ChildNodes.Count - 1) do
       begin
         Memo.Lines.Add(Item[i].ChildNodes.Item[j].NodeName + ' '
          + Item[i].ChildNodes.Item[j].FirstChild.NodeValue);
       end;
     end;
   end;
   Document.Free;
 end;

Ce qui affichera:

imageNode graphic.jpg
Peca Pecacastelo.jpg1.swf
Peca Pecacastelo.jpg1.swf

Peupler un TreeView avec XML

Une utilisation courante des fichers XML est de les analyser et d'afficher leur contenu sous forme d'arborescence. Pour ce faire, vous pouvez utiliser le composant TTreeView présent sous l'onglet Common Controls de Lazarus.

La procédure ci-dessous va prendre un document XML précédemment chargé depuis un fichier ou généré par code, avant de peupler un TreeView avec son contenu. La légende de chaque nœud de l'arbre sera le contenu du premier attribut de chaque nœud du document XML.

procedure TForm1.XML2Tree(tree: TTreeView; XMLDoc: TXMLDocument);
var
  iNode: TDOMNode;

  procedure ProcessNode(Node: TDOMNode; TreeNode: TTreeNode);
  var
    cNode: TDOMNode;
    s: string;
  begin
    if Node = nil then Exit; // Stoppe si on a atteint une feuille

    // Ajoute un nœud à l'arbre s'il existe
    if Node.HasAttributes and (Node.Attributes.Length>0) then
      s := Node.Attributes[0].NodeValue
    else
      s := ''; 
    TreeNode := tree.Items.AddChild(TreeNode, s);
    

    // Va au nœud enfant
    cNode := Node.ChildNodes.Item[0];

    // Traite tous les nœuds enfants
    while cNode <> nil do
    begin
      ProcessNoDe(cNode, TreeNode);
      cNode := cNode.NextSibling;
    end;
  end;
    
begin
  iNode := XMLDoc.DocumentElement.ChildNodes.Item[0];
  while iNode <> nil do
  begin
    ProcessNode(iNode, nil); // Procédure récursive
    iNode := iNode.NextSibling;
  end;
end;

Modifier un document XML

La première chose à se rappeler est que TDOMDocument est le "handle" vers le DOM. Vous pouvez obtenir une instance de cette classe en créant ou en chargeant un document XML.

D'un autre côté, les nœuds ne peuvent être créés comme des objets classiques. Vous *devez* utiliser les méthodes mises à disposition par TDOMDocument pour les créer puis utiliser d'autres méthodes pour les placer correctement dans l'arbre. Cela est dû au fait que les nœuds doivent être "possédés" par un document spécifique du DOM.

Ci-dessous sont indiquées quelques méthodes particulièrement utiles de TDOMDocument :

   function CreateElement(const tagName: DOMString): TDOMElement; virtual;
   function CreateTextNode(const data: DOMString): TDOMText;
   function CreateCDATASection(const data: DOMString): TDOMCDATASection;
     virtual;
   function CreateAttribute(const name: DOMString): TDOMAttr; virtual;

CreateElement crée un nouvel élément.

CreateTextNode crée un noeud texte.

CreateAttribute crée un noeud attribut.

CreateCDATASection crée une section CDATA : les caractères de marquage particuliers à XML tels que <> ne sont pas intrepréts au sein d'une section CDATA.

Une façon plus facile de manipuler les attributs consiste à utiliser la méthode TDOMElement.SetAttribute (elle est par ailleurs la propriété par défaut de TDOMElement) :

// these two statements are equivalent
Element.SetAttribute('name', 'value');
Element['name'] := 'value';

Et ci-après un exemple de méthode qui localise l'élément sélectionné dans un TTreeView avant d'insérer un nœud enfant au document XML qu'il représente. Le TreeView doit être précédement rempli avec le contenu du fichier XML en utilisant la fonction XML2Tree.

procedure TForm1.actAddChildNode(Sender: TObject);
var
  Posicao: Integer;
  NovoNo: TDomNode;
begin
  {*******************************************************************
  *  Détection de l'élément sélectionné
  *******************************************************************}
  if TreeView1.Selected = nil then Exit;

  if TreeView1.Selected.Level = 0 then
  begin
    Posicao := TreeView1.Selected.Index;

    NovoNo := XMLDoc.CreateElement('item');
    TDOMElement(NovoNo).SetAttribute('nome', 'Item');
    TDOMElement(NovoNo).SetAttribute('arquivo', 'Arquivo');
    XMLDoc.DocumentElement.ChildNodes.Item[Posicao].AppendChild(NovoNo);

    {*******************************************************************
    *  Mise à jour du TreeView
    *******************************************************************}
    TreeView1.Items.Clear;
    XML2Tree(TreeView1, XMLDoc);
  end
  else if TreeView1.Selected.Level >= 1 then
  begin
    {*******************************************************************
    *  Cette fonction n'est opérante qu'au premier niveau de l'arbre,
    *  mais peut facilement être modifiée pour fonctionner avec plusieurs niveaux
    *******************************************************************}
  end;
end;

Créer un TXMLDocument à partir d'une chaîne

Étant donné un fichier XML dans MyXmlString, le code suivant va créer son DOM :

Var
  S : TStringStream;
  XML : TXMLDocument;

begin
  S:= TStringStream.Create(MyXMLString);
  Try
    S.Position:=0;
    XML:=Nil;
    ReadXMLFile(XML,S); // Document XML complet
    // Autre possibilité
    ReadXMLFragment(AParentNode,S); // Lit uniquement un fragment XML. 
  Finally
    S.Free;
  end;
end;

Liens Externes