Baum-wie Datastructure (für die Verwendung mit VirtualTreeview)

Die Daten-Struktur, die Sie fordert, ist sehr einfach, es ist so einfach, ich würde empfehlen, mit der windows-zur Verfügung gestellt TTreeView: es ermöglicht die Speicherung von text und eine ID direkt in den Baum Knoten mit keine zusätzliche Arbeit.

Trotz meiner Empfehlung zu verwenden, die einfacher TTreeView ich werde mein nehmen auf die Daten-Struktur-problem. Zunächst werde ich Klassen, nicht Datensätze. In Ihrem sehr kurzen Codebeispiel Sie mischen records und Klassen in einem sehr unfrotunate so: Wenn Sie eine Kopie der TRoot record (Zuordnung von Datensätzen ermöglicht vollständige Kopien, da die Datensätze sind immer behandelt, als "Werte"), Sie sind nicht so eine "Tiefe Kopie" der Baum: Die vollständige Kopie TRoot enthält die gleichen Kids:TList wie das original, denn die Kurse, im Gegensatz zu Datensätzen, sind Referenzen: Sie sind Bewältigungsstrategien, die mit dem Wert der Referenz.

Einem anderen problem, wenn Sie einen Datensatz mit einem Objekt-Feld ist life-cycle-management: Ein Datensatz nicht über ein Destruktor Sie müssen sich also einen anderen Mechanismus, um kostenlos das Eigentum Objekt (Kids:TList). Sie ersetzen könnten die TList mit einem array of Tkid aber dann werden Sie brauchen, um sehr vorsichtig, wenn man das monster Datensatz herum, weil Sie am Ende vielleicht indem Tiefe Kopien von großen Datensätzen, wenn Sie es am wenigsten erwarten.

Meiner Meinung nach die Klügste, was zu tun ist, um die Daten-Struktur auf Klassen, nicht records: die Klasse von Instanzen (Objekte) übergeben werden, um als Referenzen, so dass Sie können Sie bewegen, wie Sie wollen, ohne Probleme. Sie auch die integrierte life-cycle-management (die Destruktor)

Der Basis-Klasse würde wie folgt Aussehen. Sie werden bemerken, es kann verwendet werden, entweder als Root oder das Kind, weil beide Root und Kind teilen von Daten: Die haben beide einen Namen und eine ID:

TNodeClass = class
public
  Name: string;
  ID: Integer;
end;

Wenn diese Klasse verwendet wird, als Root, es muss ein Weg, um zu speichern die Kinder. Ich nehme an, du bist auf Delphi 2010+, so haben Sie die Generika. Diese Klasse, die komplett mit einer Liste sieht wie folgt aus:

type
  TNode = class
  public
    ID: integer;
    Name: string;
    VTNode: PVirtualNode;
    Sub: TObjectList<TNode>;

    constructor Create(aName: string = ''; anID: integer = 0);
    destructor Destroy; override;
  end;

constructor TNode.Create(aName:string; anID: Integer);
begin
  Name := aName;
  ID := anID;

  Sub := TObjectList<TNode>.Create;
end;

destructor TNode.Destroy;
begin
  Sub.Free;
end;

Du vielleicht nicht sofort erkennen, aber diese Klasse allein ist genug für die Durchführung einer multi-level-Baum! Hier finden Sie den code, füllen Sie den Baum mit ein paar Daten:

Root := TNode.Create;

// Create the Contacts leaf
Root.Sub.Add(TNode.Create('Contacts', -1));
// Add some contacts
Root.Sub[0].Sub.Add(TNode.Create('Abraham', 1));
Root.Sub[0].Sub.Add(TNode.Create('Lincoln', 2));

// Create the "Recent Calls" leaf
Root.Sub.Add(TNode.Create('Recent Calls', -1));
// Add some recent calls
Root.Sub[1].Sub.Add(TNode.Create('+00 (000) 00.00.00', 3));
Root.Sub[1].Sub.Add(TNode.Create('+00 (001) 12.34.56', 4));

Müssen Sie eine rekursive Prozedur zum füllen der virtuellen Baum-Ansicht mit diesem Typ:

procedure TForm1.AddNodestoTree(ParentNode: PVirtualNode; Node: TNode);
var SubNode: TNode;
    ThisNode: PVirtualNode;

begin
  ThisNode := VT.AddChild(ParentNode, Node); // This call adds a new TVirtualNode to the VT, and saves "Node" as the payload

  Node.VTNode := ThisNode; // Save the PVirtualNode for future reference. This is only an example,
                           // the same TNode might be registered multiple times in the same VT,
                           // so it would be associated with multiple PVirtualNode's.

  for SubNode in Node.Sub do
    AddNodestoTree(ThisNode, SubNode);
end;

// And start processing like this:
VT.NodeDataSize := SizeOf(Pointer); // Make sure we specify the size of the node's payload.
                                    // A variable holding an object reference in Delphi is actually
                                    // a pointer, so the node needs enough space to hold 1 pointer.
AddNodesToTree(nil, Root);

Wenn Sie Objekte auf verschiedenen Knoten in Ihrer Virtuellen Baum können verschiedene Arten von Objekten im Zusammenhang mit Ihnen. In unserem Beispiel werden wir nur hinzufügen Knoten TNode geben, aber in der realen Welt, die Sie haben könnten Knoten der Typen TContact, TContactCategory, TRecentCall alle in einer VT. Verwenden Sie die is Betreiber zu prüfen, die tatsächliche Typ des Objekts in der VT-Knoten wie dieser:

procedure TForm1.VTGetText(Sender: TBaseVirtualTree; Node: PVirtualNode;
  Column: TColumnIndex; TextType: TVSTTextType; var CellText: string);
var PayloadObject:TObject;
    Node: TNode;
    Contact : TContact;      
    ContactCategory : TContactCategory;
begin
  PayloadObject := TObject(VT.GetNodeData(Node)^); // Extract the payload of the node as a TObject so
                                                   // we can check it's type before proceeding.
  if not Assigned(PayloadObject) then
    CellText := 'Bug: Node payload not assigned'
  else if PayloadObject is TNode then
    begin
      Node := TNode(PayloadObject); // We know it's a TNode, assign it to the proper var so we can easily work with it
      CellText := Node.Name;
    end
  else if PayloadObject is TContact then
    begin
      Contact := TContact(PayloadObject);
      CellText := Contact.FirstName + ' ' + Contact.LastName + ' (' + Contact.PhoneNumber + ')';
    end
  else if PayloadObject is TContactCategory then
    begin
      ContactCategory := TContactCategory(PayloadObject);
      CellText := ContactCategory.CategoryName + ' (' + IntToStr(ContactCategory.Contacts.Count) + ' contacts)';
    end
  else
    CellText := 'Bug: don''t know how to extract CellText from ' + PayloadObject.ClassName;
end;

Und hier ist ein Beispiel, warum zum speichern VirtualNode Zeiger auf das Knoten-Instanzen:

procedure TForm1.ButtonModifyClick(Sender: TObject);
begin
  Root.Sub[0].Sub[0].Name := 'Someone else'; // I'll modify the node itself
  VT.InvalidateNode(Root.Sub[0].Sub[0].VTNode); // and invalidate the tree; when displayed again, it will
                                                // show the updated text.
end;

Wissen Sie ein Beispiel für eine einfache Baumstruktur. Sie müssen "wachsen" diese Datenstruktur zu suite Ihren Anforderungen: die Möglichkeiten sind endlos! Um Ihnen einige Ideen, Richtungen zu erkunden:

• Können Sie durch drehen des Name:string in eine virtuelle Methode GetText:string;virtual und dann erstellen spezielle Nachkommen von TNode überschreiben GetText um spezialisierte Verhalten.
• Erstellen Sie eine TNode.AddPath(Path:string; ID:Integer), die es Ihnen ermöglicht, das zu tun Root.AddPath('Contacts\Abraham', 1); - das ist eine Methode, die erstellt automatisch alle intermediären Knoten der Letzte Knoten, ermöglichen die einfache Erstellung des Baumes.
• Gehören ein PVirtualNode in TNode selbst, so dass Sie überprüfen können, sondern der Knoten wird "geprüft" in den Virtuellen Baum. Das wäre eine Brücke, von der Daten-GUI-Trennung.

Fragte ich ähnliche Frage hier. Ich habe nicht bekam keine nützlichen Antworten, damit ich entscheiden, um meine eigene Implementierung, die Sie hier finden können hier.

BEARBEITEN:
Ich werde versuchen, nach Beispiel, wie Sie könnte meine Daten Struktur:

uses
  svCollections.GenericTrees;

Erklären Datentyp:

type
  TMainData = record
    Name: string;
    ID: Integer;
  end;

Erklären sich mit den Haupt-Daten-Struktur-Objekt irgendwo im code:

MyTree: TSVTree<TMainData>;

Erstellen (und vergessen Sie nicht, free später):

MyTree: TSVTree<TMainData>.Create(False);

Ordnen Sie den VirtualStringTree zu unserer Datenstruktur:

MyTree.VirtualTree := VST;

Dann können Sie init Ihrem Baum, mit einige Werte:

procedure TForm1.BuildStructure(Count: Integer);
var
  i, j: Integer;
  svNode, svNode2: TSVTreeNode<TMainData>;
  Data: TMainData;
begin
  MyTree.BeginUpdate;
  try
    for i := 0 to Count - 1 do
    begin
      Data.Name := Format('Root %D', [i]);
      Data.ID := i;
      svNode := MyTree.AddChild(nil, Data);
      for j:= 0 to 10 - 1 do
      begin
        Data.Name := Format('Child %D', [j]);
        Data.ID := j;
        svNode2 := MyTree.AddChild(svNode, Data);
      end;
    end;
  finally
    MyTree.EndUpdate;
  end;
end;

- Und set-VST-events, um die Daten anzuzeigen:

procedure TForm1.vt1InitChildren(Sender: TBaseVirtualTree; Node: PVirtualNode;
  var ChildCount: Cardinal);
var
  svNode: TSVTreeNode<TMainData>;
begin
  svNode := MyTree.GetNode(Sender.GenerateIndex(Node));
  if Assigned(svNode) then
  begin
    ChildCount := svNode.FChildCount;
  end;
end;

procedure TForm1.vt1InitNode(Sender: TBaseVirtualTree; ParentNode,
  Node: PVirtualNode; var InitialStates: TVirtualNodeInitStates);
var
  svNode: TSVTreeNode<TMainData>;
begin
  svNode := MyTree.GetNode(Sender.GenerateIndex(Node));
  if Assigned(svNode) then
  begin
    //if TSVTree<TTestas> is synced with Virtual Treeview and we are building tree by
    // setting RootNodeCount, then we must set svNode.FVirtualNode := Node to
    // have correct node references
    svNode.FVirtualNode := Node;  // Don't Forget!!!!
    if svNode.HasChildren then
    begin
      Include(InitialStates, ivsHasChildren);
    end;
  end;
end;

//display info how you like, I simply get name and ID values
procedure TForm1.vt1GetText(Sender: TBaseVirtualTree; Node: PVirtualNode;
  Column: TColumnIndex; TextType: TVSTTextType; var CellText: string);
var
  svNode: TSVTreeNode<TMainData>;
begin
  svNode := MyTree.GetNode(Sender.GenerateIndex(Node));
  if Assigned(svNode) then
  begin
    CellText := Format('%S ID:%D',[svNode.FValue.Name, svNode.FValue.ID]);
  end;
end;

In diesem Punkt arbeiten Sie nur mit Ihrem MyTree der Struktur der Daten und alle änderungen, die vorgenommen werden, spiegelt sich in Ihrem zugewiesenen VST. Sie sind dann immer speichern (und laden) zugrunde liegende Struktur zu stream oder einer Datei. Hoffe, das hilft.

Wenn Sie mit neueren Versionen von Delphi unterstützt Generics, überprüfen GenericTree