himXML (gesprochen himix ML)

[Zwoetzen]

So, nachdem ich nun wieder etwas mehr Zeit habe, bin ich auch mal wieder dazu gekommen, mein XML-Projekt weiterzubasteln.

Ich habe diesbezüglich mal eine allgemeinere Frage:
Was kann man nun genau alles angeben, wenn man auf einen (tieferen) Knoten zugreifen will?

Folgendes konnte ich schon (durch den Thread hier) herausfinden

Delphi-Quellcode:

Node['tag1\tag2\tag3']; // Ineinander verschachtelte Tags
Node['tag1[2]']; // Den 3. Tag mit dem Namen tag1 im aktuellen Knoten

Irgendwo hatte ich aber auch gelesen, dass man mit
Node['tag1>attr=value'] den tag1 auswählen können soll, der als Attribut attr den Wert value hat. Das hat bei mir aber irgendwie nicht funktioniert, oder habe ich da etwas falsch verstanden?

Wäre nett, wenn du da eine Art Übersicht machen könntest
(Falls eine solche existiert, dann habe ich sie noch nicht gefunden, ein Link reicht dann ^^)

MfG Zwoetzen

[himitsu]

ich bin zwar dabei eine neue Hilfe zu basteln, aber das dauert noch ein bissl

aktuell ist aber einiges in Form einer Inline-Hilfe direkt in den Dateien
z.B. schau hierfür mal in die Unit himXML.pas (bzw. himXMLi.pas der alten Version) und klappe dort ganz oben die Region "Help" auf (der zweite ganz lange Kommentar) ... Delphi 2009 sollte die Regionen ja standardmäßig zugeklappt haben.

dort gibt es zu einigen Dingen schon eine kleine Erklärung
z.B.

Code:

//    Count        CountNF             -
//    Node         NodeNF        (1)   -
//    NodeU        NodeUNF       (1)   see .Node but node always not created, ...
//    NodeList     NodeListNF    (1)   -

Code:

// (1)  node names allowed paths, attributes and an index
//         "{\}{.\}{..\}{node...\}{nodeName}{>attr=value{>attr=value{...}}}{[index]}"
//
//         Node['\..\node']                       Owner.RootNode.Parent.Node['node']  aka  ...
//         Node['\node']                          Owner.RootNode.Node['node']  or  {first ...
//         Node['.\node']                         {Self.}Node['node']
//         Node['..\node']                        Parent.Node['node']
//         Node['node1\node2']                    Node['node1'].Node['node2']
//         Node['node>attr=value']                Node['node'] with Attributes['attr']='value'
//         Node['node>attr=value>attr2=value2']   Node['node'] with Attributes['attr']='value' and ...
//         Node['node[3]']                        NodeList['node'][3]
//         Node['[3]']                            Node[3]
//         Node['>attr=value']                    first of Node.Nodes with Attributes['attr']='value'
//         Node['>attr=value[3]']                 3rd of Node.Nodes with Attributes['attr']='value'
//         Node['*:node']                         ignore namespace
//         Node['name:*']                         first/all nodes with this namespace
//
//         Node['node1[2]\node2>attr=value[3]']   NodeList['node1'][2].NodeList['node2'][3] with ...
//
// (2)  attribut names allowed paths - see at (1)
//         "{nodePath}\attributeName"
//
//         Attribute['node\attr']                 Node['node'].Attribute['attr']

schwer wird es nur, da ich mein "System" versuche auszulagern, so daß es mal möglich sein sollte auch sowas wie XPath nachzurüsten, bzw. mein System durch ein Alternatives oder Userdefinierte auszutauschen.



also im Grunde sollte Node['tag1>attr=value'] funktionieren.

[Zwoetzen]

Danke, das hilft mir sehr weiter. Ich hatte zwar schon in die Dateien mal reingeschaut, auch die einzelnen Regions gesehen (wusste gar nicht, dass es sowas gibt ), aber nicht wirklich etwas zu diesen Bezeichnungen gefunden. Hab vielleicht nicht genau genug gesucht ^^

Zu dem "tag1>attr=value" werd ich nochmal genauer schauen, warum das nicht funktioniert hatte. Diese "Abkürzungen" find ich übrigens sehr gut gelungen, da kommt man auch in etwas größeren Dokumenten relativ schnell an den eigentlichen Tag, den man lesen möchte (Gerade wenn man nicht alle Informationen benötigt)

[himitsu]

Die Regionen sind schon 'ne praktische Sache, vorallem da man so auch Blöcke ausgeblendet bekommt, welche einem grade nicht "wichtig" sind und man so schneller und übersichtlicher an bestimmete Stellen kommt.

Nja, XPath und Dergleichen sind etwas mächtiger vom Funktionsumfang, aber für nette Kleinigkeiten ist mein winziges System auch schon zu gebrauchen.
Abgesehn davon, daß hier auch schneller über Hashtabellen gesucht wird ... hab die Nodes und Attribute extra dafür optimiert.



falls du Regionen auch mal selber nutzen willst...

Delphi-Quellcode:

{$IF X}{$REGION 'help'}{$IFEND}
...
{$IF X}{$ENDREGION}{$IFEND}

dieses {$IF X}...{$IFEND} kannst'e ignorieren, das hab ich nur drinnen, weil ältere Delphis keine Regionen kennen

Delphi-Quellcode:

{$REGION 'beliebiger Text'}
...
{$ENDREGION}

und beim Zusammenklappen wird dann nur noch der Text angezeigt ... ist praktisch das Selbe, was man mit Funktionen und Typen (Records/Klassen) machen kann, nur halt für größere Bereiche/Regionen

[Zwoetzen]

Danke für die Antwort, wenn es sich das nächste Mal anbietet, weiß ich jetzt, wie ich etwas mehr Übersicht hineinbringen kann

Ich habe jetzt auch die Zeit gefunden, das Problem mit dem Zugriff mit Attribut-Wert genauer zu untersuchen, und nun funktioniert das auch. Da muss mir wohl beim letzten Mal ein Fehler unterlaufen sein (Tippfehler oder ähnliches), dein Code funktioniert also wie er soll

[xZise]

Hallo himitsu!
Ich versuche gerade himXML in einem anderen Projekt einzusetzen.
Dabei stellt sich mir die Frage, wie komme ich an die Attribute eines Nodes.

Delphi-Quellcode:

procedure TTag.LoadFromFile(const AFilename: string);
var
  f : TXMLFile;
begin
  Parent := nil;
  // öffnen bla bla
  f := TXMLFile.Create;
  try
    f.LoadFromFile(AFilename);
    LoadFromNode(f['virtualroot\root']);
  finally
    f.Free;
  end;
end;

procedure TTag.LoadFromNode(const AXMLNode: TXMLNode);
var
  na : string;
  i, ty: Integer;
  t : TEntry;

  nds : TXMLNodeArray;
begin
  Name := AXMLNode.Node['name'].Text;
  nds := AXMLNode.NodeList['files\file'];
  for i := 0 to High(nds) do
  begin
    ty := nds[i]['@type'].Text;
    // Directory Node
    if (ty and 1) = 1 then
    begin
      t := TTag.Create;
      FChilds.Add(t);
      t.Parent := Self;
      TTag(t).LoadFromNode(nds[i]);
    end else
    begin
      t := TEntry.Create;
      FFiles.Add(t);
      t.Name := nds[i]['name'].Text;
    end;
    t.Hidden := (ty and 2) = 2;
  end;
end;

Die Datei sieht dabei so aus:

XML-Code:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<taxs>
   <virtualroot>
      
      <root>
         <name>Root</name>
         <files>
            <!-- Filecontainer with "filetype"
               Bit   Meaning (if set)
               1   Directory
               2   Hidden -->
            <file type=1>
               
               <name>Sub</name>
               <files>
                  
                  <file type=3>
                     <name>HiddenSub</name>
                  </file>
                  <file type=1>
                     <name>Sub</name>
                     <files>
                        <file type=2>
                           <name>HiddenFile</name>
                           <original>C:...</original>
                        </file>
                     </files>
                  </file>
               </files>
            </file>
            <file type=0>
               <name>Filetest</name>
               <original>C:...</original>
            </file>
         </files>
      </root>
   </virtualroot>
</taxs>

Wenn ich nun die Zeile 28 ausführe um den Type des Nodes "taxs\virtualroot\root\files\file[0]" zu kommen.

Zitat:

---------------------------
text
---------------------------
[EXMLException] TXMLNodeList.Add:

invalid name ("@type")
---------------------------
OK
---------------------------

MfG
xZise

[himitsu]

Im Prinzip einfach dadurch, daß man auf die Eigenschaft .Attributes den jeweiligen Nodes zugreift
ty := nds[i].Attributes['type'];

[xZise]

Aha. Kann man das nicht irgendwie verkürzt schreiben?

Und jetzt habe ich ein ganz anderes komisches Problem. Und zwar wenn "LoadFromNode" gerade den "HiddenSub" Node abarbeitet, dann ist nds zwar "leer" (im Debugger steht: nds = ()), aber er geht trotzdem in die Schleife und scheitert dann grandios dabei das Attribut des ersten nicht vorhandenen Nodes auszulesen.

MfG
xZise

[himitsu]

Zitat von xZise:

Aha. Kann man das nicht irgendwie verkürzt schreiben?

Man kann nur ein Array-Property als Standard (Default) definieren und da hab ich nunmal überall .Nodes genommen, weswegen man bei .Attributes ausschreiben muß.

Zitat von xZise:

Und jetzt habe ich ein ganz anderes komisches Problem. ...

also bei meinem Test verzweigt er bei diesem Node nicht in die Schleife und es kommt auch zu keiner Exception



PS: was das Debuggen angeht ...
In der neuen Version ist dieses in meinem Projekt standardmäßig abgeschaltet. (noch nicht hochgeladen)
Und in der Beta läßt es sich über die Projektoptionen abstellen, dort einfach in den Bedingungen "hxNotDebugable" einfügen

> D2009 > Projektoptionen > Delphi-Compiler > Bedingungen

Dann läßt sich das eigene Programm einfacher debuggen, da nicht ständig im Einzelschritt in meine Units gewechselt wird.

[himitsu]

Hab hier mal 'nen noch ungetesteten Code zum Speichern und Laden eines TTreeView.

Gespeichert wird natürlich der .Text und die ganzen Subnodes ... also die ganze Baum-Struktur des Trees
und beim Rest kann man entschieden werden, was man speichern/laden will.
Da wären die ganzen Bildindize .ImageIndex, .SelectedIndex, .StateIndex, .ExpandedImageIndex
und .OverlayIndex, außerdem .Enabled und die Zustände .Selected, .Focused und .Expanded,
für jeden einzelnen Node.


Ein TVirtualStringTree wird auch bald folgen, dort wird .Data dann ebenso über einen Callback gespeichert und geladen.

Delphi-Quellcode:

Type TSTVProc   = Procedure(Node: TXMLNode; TVNode: TTreeNode);
  TSTVSavedData = Set of (ssImageIndex, ssSelectedIndex, ssStateIndex, ssExpandedIndex,
                    ssOverlayIndex, ssEnabled, ssSelected, ssFocused, ssExpanded, ssData);

Const ssDefault = [ssImageIndex..ssSelected, ssExpanded];

Procedure SerializeTreeView(Node: TXMLNode; TreeView: TTreeView;
  Save: TSTVSavedData = ssDefault; DataProc: TSTVProc = nil);

Procedure DeserializeTreeView(Node: TXMLNode; TreeView: TTreeView;
  Load: TSTVSavedData = ssDefault; DataProc: TSTVProc = nil);

benutzen

Delphi-Quellcode:

Var XML: TXMLFile;
  Node:  TXMLNode;

// speichern
XML := TXMLFile.Create;
Node := XML.AddNode('MyTreeView');
SerializeTreeView(Node, TreeView1);
XML.SaveToFile('file.xml');
XML.Free;

// laden
XML := TXMLFile.Create;
XML.LoadFromFile('file.xml');
Node := XML.Node['MyTreeView'];
DeserializeTreeView(Node, TreeView1);
XML.Free;

Dieser und ähnliche Codes werden allerdings wohl nie direkt im Projekt enthalten sein, da sie einfach zu speziell sind,
aber es ist eine kleine Abteilung auf der zukünftigen Webseite vorgesehn.



[edit]
der ganze Code kommt gleich wieder ... dann als Anhang in 'ner eigenen Unit
so, da isser wieder

[add]
nun auch getestet, etwas geändert und mit Beispiel, siehe Bild