VirtualStringTree bringt mich zur Weißglut. Baum anhand von Datei erstellen

[DieDolly]

Ich habe eine Datei moit einem Format etwa wie dieses

HEADER|Gruppe1
-|Subitem1
--|Sub-Subitem2

HEADER|Gruppe2
HEADER|-|Gruppe3
--|Subitem1

Der Baum sollte danach etwa so aussehen

Gruppe 1
- Subitem1
-- Subitem2
Gruppe 2
- Gruppe 3
-- Subitem 1

Mir liegt jede einzelne Zeile als String vor. Die Nehme ich mit Explode auseinanider und packe alles in ein Record.

Delphi-Quellcode:

type
 TTitleParts = record
  IsHeader: Boolean;
  IsSubItemLevel1, IsSubItemLevel2: Boolean;
  Title: string;
 end;

 TitleParts.IsHeader := aTitleParts[0] = 'HEADER';
 TitleParts.IsSubItemLevel1 := aTitleParts[0] = '-';
 TitleParts.IsSubItemLevel2 := aTitleParts[0] = '--';

 if TitleParts.IsHeader or TitleParts.IsSubItemLevel1 or TitleParts.IsSubItemLevel2 then
  TitleParts.Title := aTitleParts[1];

 TitleParts.IsHeader := (not TitleParts.IsSubItemLevel1) and (not TitleParts.IsSubItemLevel2) and (TitleParts.Title <> '-');

Wie schaffe ich es jetzt daraus einen Baum zu bauen? Ich verzweifle langsam an all meinen versuchen.

Soweit komme ich

Delphi-Quellcode:

  if TitleParts.IsHeader then
    begin
     aNode := VST.AddChild(nil);
     Data := VST.GetNodeData(aNode);
     Data.Title := TitleParts.Title;

     aLastHeaderNode := aNode;
    end;

   if TitleParts.IsSubItemLevel1 then
    begin
     aNode := VST.AddChild(aLastHeaderNode);
     Data := VST.GetNodeData(aNode);
     Data.Title := TitleParts.Title;

     aLastSubLevel1Node := aNode;
    end;

Sobald ich weiter mache geht alles komplett schief.

[Aviator]

Du solltest dir das Thema Rekursion einmal anschauen. Damit kannst du dann Baumstrukturen aufbauen die (theoretisch) unendlich tief werden können. Du solltest eventuell auch mit dem Gedanken spielen, deine ganzen Verzeichnisse in Objekten und ObjectLists zu speichern.

Aus dem Kopf aufgeschrieben könnte das dann so aussehen (ungetestet):

Delphi-Quellcode:

procedure TForm1.ButtonClick(Sender: TObject);
begin
  CreateNode(VirtualStringTree1, nil, Directories);
end;

procedure CreateNode(VST: TBaseVirtualTree; AParent: PVirtualNode; AData: TDirectoryData);
var
  Node: PVirtualNode;
  NodeData: PDirectoryData;
begin
  Node := VST.AddChild(AParent);
  NodeData := VST.GetNodeData(Node);
  NodeData^.YouProperty1 := AData.Property1Value;
  NodeData^.YouProperty2 := AData.Property2Value;

  for i := 0 to AData.SubDirectory.Count - 1 do begin
    CreateNode(Node, AData.SubDirectory[i]);
  end;
end;

[DieDolly]

So richtig verstehe ich dein Beispiel leider nicht.
Ich habe keine Verzeichnisse, nur normale Überschriften.
Wo kommt denn das TDirectoryData her? Jetzt bin ich noch verwirrter als vorher.

Mein Record sieht so aus. Alles andere verstehe ich nicht und verwirrt mich nur noch mehr

Delphi-Quellcode:

type
 TTitleParts = record
  IsHeader: Boolean;
  IsSubItemLevel1, IsSubItemLevel2: Boolean;
  Title: string;
 end;

Und das befülle ich mit einem String der aus einer Datei kommt, geteilt wird (Explode |). Die Datei wird zeilenweise gelesen. Leerzeilen werden ignoriert.

Code:

HEADER|Gruppe1
-|Subitem1
--|Sub-Subitem2

HEADER|Gruppe2
HEADER|-|Gruppe3
--|Subitem1

[Schokohase]

Du solltest deine Daten in ein Tree-Struktur laden und von da aus die Visualisierung machen.

Das wäre eine solche:

Delphi-Quellcode:

type
  TNode<T> = class
  private
    FChildren: TObjectList<TNode<T>>;
    FValue: T;
  public
    constructor Create(const AValue: T);
    destructor Destroy; override;

    property Value: T read FValue;
    property Children: TObjectList < TNode < T >> read FChildren;
  end;

{ TNode<T> }

destructor TNode<T>.Destroy;
begin
  FChildren.Free;
  inherited;
end;

constructor TNode<T>.Create(const AValue: T);
begin
  inherited Create;
  FValue := AValue;
  FChildren := TObjectList < TNode < T >>.Create();
end;

So könntest du deine Daten da hinein laden

Delphi-Quellcode:

procedure ReadData(const AData: TArray<string>; const ANode: TNode<string>; ALevel: Integer; var ACurrentLine: Integer);
var
  lRow: string;
  lParts: TArray<string>;
  lLevel: Integer;
  lNode: TNode<string>;
begin
  while ACurrentLine < Length(AData) do
  begin
    lRow := AData[ACurrentLine];
    if not string.IsNullOrEmpty(lRow) then
    begin
      lParts := lRow.Split(['|']);

      lLevel := lParts[0].CountChar('-');

      if ALevel < lLevel then
        ReadData(AData, lNode, ALevel + 1, ACurrentLine)
      else if ALevel > lLevel then
        break
      else
      begin
        lNode := TNode<string>.Create(lParts[1]);
        ANode.Children.Add(lNode);
        Inc(ACurrentLine);
      end;
    end
    else
      Inc(ACurrentLine);
  end;
end;

Hier eine rekursive

Delphi-Quellcode:

procedure

um den Baum auszugeben

Delphi-Quellcode:

procedure PrintNode(const ANode: TNode<string>; ALevel: Integer = 0);
var
  lChild: TNode<string>;
begin
  Writeln(string.Create('*', ALevel), ANode.Value);
  for lChild in ANode.Children do
  begin
    PrintNode(lChild, ALevel + 1);
  end;
end;

und hier ein kleines Konsolen-Demo

Delphi-Quellcode:

procedure Main;
var
  lData: TArray<string>;
  lNode: TNode<string>;
  lLine: Integer;
begin
  lData := TArray<string>.Create( //
    'HEADER|Gruppe1', //
    '-|Subitem1', //
    '--|Subitem2', //
    'HEADER|Gruppe2', //
    '-|Gruppe3', //
    '--|Subitem1');
  lNode := TNode<string>.Create('root');
  lLine := 0;
  ReadData(lData, lNode, 0, lLine);

  PrintNode(lNode);
end;

Die Ausgabe ist dann

Code:

root
*Gruppe1
**Subitem1
***Subitem2
*Gruppe2
**Gruppe3
***Subitem1

[DieDolly]

Delphi-Quellcode:

Writeln(string.Create('*', ALevel), ANode.Value);

Muss ich dann statt der Zeile da oben einfach nur

Delphi-Quellcode:

aNode := VST.AddChild(.......);
     Data := VST.GetNodeData(aNode);

aufrufen?

Ehrlich gesagt ist es jetzt noch 100x komplizierter als vorher.

[Schokohase]

Zitat:

Zitat von DieDolly (Beitrag 1425187)

Ehrlich gesagt ist es jetzt noch 100x komplizierter als vorher.

Dann lass es doch so wie es ist. Wir können das leider nur auf diesem Weg.

[DieDolly]

Ich werde mich da einlesen und es lernen. Aber ich sehe nirgendwo eine Stelle, wo irgendwas in ein VST geschrieben wird.

Zitat:

Dann lass es doch so wie es ist.

So wie ich es habe funktioniert es aber leider nicht. Deswegen frage ich ja hier.

[Aviator]

Niemand hat behauptet, dass die Nutzung des VST einfach ist. Die Lernkurve ist sehr steil. Aber es lohnt sich. Und das Beispiel von Schokohase ist wirklich gut gemacht. Starte das Projekt doch einfach mal und geh mit dem Debugger durch. Dann kannst du dir den gesamten Ablauf Schritt für Schritt anschauen.

[DieDolly]

Zitat:

Dann kannst du dir den gesamten Ablauf Schritt für Schritt anschauen.

Den Ablauf verstehe ich. Aber ich verstehe nicht, wie man das in ein VST packt. Weil das ist etwas komplett anderes als einen String auszugeben.
Die Ausgabe mit dem WriteLn ist selbsterklärend.

[Schokohase]

Wenn man ganz genau hinsieht, dann ist es irgendwie das gleiche wie mit dem Writeln

Delphi-Quellcode:

procedure TForm1.ButtonClick(Sender: TObject);
var
  lRootNode: TNode<string>;
begin
  lRootNode := ...

  CreateNode(VirtualStringTree1, nil, lRootNode);
end;

procedure CreateNode(VST: TBaseVirtualTree; AParent: PVirtualNode; AData: TNode<string>);
var
  Node: PVirtualNode;
  NodeData: PDirectoryData;
begin
  Node := VST.AddChild(AParent);
  NodeData := VST.GetNodeData(Node);
  NodeData^.Title := AData.Value;

  for i := 0 to AData.Children.Count - 1 do begin
    CreateNode(VST, Node, AData.Children[i]);
  end;
end;