Hallo,

ich habe folgendes Problem. Ich habe einen treeview. Der hat auf level 0 genau 1 Knoten.
Darunter kann, oder auch nicht ein oder mehrere Unterknoten sein. Ab diesen Unterknoten muß ich jeweils alle Daten des Knoten auslesen. (Die Daten sind eine Klasse "tdlnode" mit einem Datenrecord ".daten".
Alles, was also JEWEILS unter Knotenlevel 1 ist, muß erfaßt werden.
Der entsprechende Knoten auf Level 1 dient mir dabei zum zusammenstellen eines Dateinamens, in die ich allse Daten des Unterknotens reinschreibe.
Ich schaffe es irgendwie nicht, mit den methoden getnext, gentnextsibling etc eine Routine zu bauen, die ab Level 1 alles nach unten durchläuft, und danach wieder bei dem nächsten Knoten auf level 1 wieder anfängt.

Hat jemand eine Idee? Ich habe hier schon unter dem Stichwort ttreenode gesucht, aber nix gefunden.
Und um jetzt auf Virtual Treeview umzusteigen, ist das Programm schon zu weit fortgeschritten.

Danke vielmals

Rekursion! Das Wort heißt Rekursion!

zusammenfalten · markieren

Delphi-Quellcode:

procedure Grab(tns: TTreeNodes);
var node: TTreeNode;
s: string;
begin
  n := tns.getFirstChildNode;
  while Assigned(n) do
    begin
      s := n.Value //mit s kannst du jetzt machen was du willst
      Grab(s.ChildNodes); //hier wird rekursiert!
      n := tns.GetNextSibling(n);
    end;
end;

Das ist jetzt so schnell aus dem Gedächtnis getippt, die code completion sollte dir helfen, da die richtigen Bezeichner reinzutun.

Hallo Luke,

erstmal danke für den Tip. Leider komme ich nicht weiter. Rekursion ist mir jetzt nicht ganz fremd :-)
Ich zeige kurz, wie weit ich bin:

zusammenfalten · markieren

Delphi-Quellcode:

procedure tdlnode.exportdltreetofile;
var
      i:integer;
      DL:textfile;
      zeile,zeile2,dlfile,myenv:string;
      Result:Boolean;
      startp:ttreenode;
      dldata:dlrecord;
begin
  dlfile:=toemnode(selectednode.data).daten.CATTEMP + '\'+toemnode(selectednode.Data).daten.name+'.dls';
  startp := form1.dlview.TopItem.getFirstChild;
  while startp <> nil do
  begin
  showmessage(startp.Text);
  grab(startp);
  startp:=startp.getNextSibling;

  end;


end;

procedure tdlnode.Grab(tns: TTreeNode);
var node: TTreeNode;

begin
  if tns <> nil then
  begin
  node := tns.getFirstChild;
  while Assigned(node) do
    begin
      
      showmessage(node.Text);
      Grab(s.GetNextChild(node)); //hier wird rekursiert!
      node:= tns.GetNextSibling;
    end;
    end;
end;

exportdltreetofile ist ok, ohne den aufruf von Grab(xy). Das mache ich extra so, da ich in einem zweiten Tree eine gleiche node gleichen Namens habe, die Informationen enthält, die ich für die Unterknoten von level 1 brauche (den Dateinamen).
Ich verstehe die funktion GETNEXTCHILD(parameter) nicht ganz. Ich würde sie als "nächste Node:= tns.getnextchild(tns)" verstehen. Aber das kommt mir schon etwas seltsam vor.
Leider habe ich (wie wohl in vielen "Nicht Entwicklerfirmen" üblich) keinerlei Doku, aber ne riesen Erwartungshaltung anderer. Schlage mich mit 2005 Personal rum.

Hallo nochmal,

nach etwas Granufink im Tee hat sich die procedure geklärt. Hier der funktionierende Quellcode für die Funktion, damit andere mit dem gleichen Problem Abhilfe finden :-)

zusammenfalten · markieren

Delphi-Quellcode:

procedure tdlnode.Grab(node: TTreeNode);
var
  TmpNode : TTreeNode;
begin
  If Node <> Nil then

  TmpNode:=Node.getFirstChild;
  While (TmpNode<>Nil) do
    begin
      showmessage(tmpnode.Text);
     grab(TmpNode);
     TmpNode:=Node.getNextChild(TmpNode);
    end;

end;

Anmerkung: Der Parameter "node" ist der Startpunkt.

Danke nochmal für den Hinweis!

hier meine Lösung, kommt ohne zusätzliche Variable aus...

markieren

Delphi-Quellcode:

procedure GetSubNodes(const Node:TTreeNode);
begin
  if assigned(Node) then
  begin
    ShowMessage(Node.Text);

    GetSubNodes(Node.getFirstChild,Check); // recurse next level, first child
    GetSubNodes(Node.getNextSibling,Check); // recurse actual level, next node
  end;
end;

Zitat von ibp:

hier meine Lösung, kommt ohne zusätzliche Variable aus...

Nicht wirklich ... jedenfalls nicht, wenn man die Rücksprungadresse und den eventuellen Stackframe für den rekursiven Aufruf und sonstige Variablen mitzählt.

Iterativ und mit wirklich nur einer Variable:

zusammenfalten · markieren

Delphi-Quellcode:

procedure Grab(Node: TTreeNode);
var
  TmpNode : TTreeNode;
begin
  TmpNode := Node.getFirstChild;
  while Assigned(TmpNode) do
  begin
    showmessage(TmpNode.Text);
    TmpNode := TmpNode.GetNext;
  end;
end;

gut, sowas wäre auch noch möglich

markieren

Delphi-Quellcode:

procedure Grab(Node: TTreeNode);
begin
  Node := Node.getFirstChild;
  while Assigned(Node) do
  begin
    showmessage(Node.Text);
    Node := Node.GetNext;
  end;
end;

Dieses sollte für den Stack und auch sonst speichertechnisch die sparsamste Variante darstellen.


[add]

Zitat:

ttreeview ab einem Unterknoten alles auslesen

Willst du jetzt alles auslesen oder nur alle Unterknoten eines bestimmten Knotens?

Wenn nur alle Unterknoten dann müßte man noch prüfen, ob TmpNode unterhalb von Node liegt oder man verwende doch eine rekursive Methode.

z.B.:

zusammenfalten · markieren

Delphi-Quellcode:

procedure Grab(Node: TTreeNode);
var
  EndNode : TTreeNode;
begin
  EndNode := Node.GetLastChild;
  Node := Node.GetFirstChild;
  if Assigned(Node) then
    repeat
      showmessage(Node.Text);
      Node := Node.GetNext;
    until EndNode = Node;
end;