Discussion :

[petitprince]

Voilà, j'affecte à chaque noeud de ma treeview un record. Je souhaite sauvegarder le tout dans un fichier: dois-je sauvegarder les items et les records à part, en les réaffectant au chargement du fichier, ou existe-t'il une solution toute faite ?? Un exemple n'est pas de refus....
D'avance Merci...

PetitPrince

[ShaiLeTroll]

Je n'ai pas d'exemple sous la main, mais ce sujet sur la sauvegarde de record contenant des string pourrait te donner des idées, mais cela sauvegarderait ton TreeView en format binaire ...

Ensuite tu pourrais utiliser directement un enregistremenrt via Stream.WriteComponent, qui va gérer intégralement le contenu du treeview (voir TTreeNode.WriteData ...), cela stockera cela dans une sorte de DFM binaire, tu peux la traduire en DFM Texte via ObjectBinaryToText, mais ce n'est pas utile ... pour la proprité Data, je pense qu'il stocke juste la valeur du pointer (si cela se trouve cela stocke tout mais j'en doute), donc à la lecture, il te faudra parcourir l'arbre pour réattribuer à chacun un nouveau pointeur issu du second fichier (il faut que tu stocke la valeur numérique du pointeur + la structure)



sinon, pourquoi pas le XML, tu fais une fonction pour écrire, un autre pour lire, avec les sous fonctions liées à la propriété Data ... l'avantage c'est que tu auras la vu d'arbre contenu par la nature même du XML

Sinon, je pense que des composants comme ceux de JEDI ou TMS doivent inclure cette fonctionnalité, même si je suis assez partisant de la développer par soi-même au moins une fois, c'est un travail assez intéressant ...

[petitprince]

Bon je n'ai pas tout saisi.....
Oui je compte bien sauvegarder le tout dans un fichier binaire, en utilisant les streams, seulement, celà ne sauve que les items de la treeview, et non les record associés.... De plus, je viens de m'apercevoir que les chaînes sont de longueurs fixes avec les records...
Et si je surchargeais un TTreeNode, afin de lui ajouter une propriété, pour le retrouver plus facilement à la relecture du fichier ?
Bon je mets tout ça en place et reviens avec un bout de code ....
Merci

[ShaiLeTroll]

Je suis parti sur un algo simple qui considère que si l'on fige les Items à un instant T, lorsque l'on les relit, ils sont dans le même ordre (j'ai testé avec 137 items jusqu'à 5 niveaux)

il faut juste refaire TDataNode, SaveTreeViewDataProc et ReadTreeViewDataProc à ton utilité soit à la main, soit via l'exemple dans ce sujet

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
type
  TIOTreeViewDataProc = procedure(ANode: TTreeNode; AStream: TStream);
  PDataNode = ^TDataNode;
  TDataNode = record
    S: string;
    I: Integer;
  end;
 
function StreamWriteString(AStream: TStream; const S: string): Integer;
begin
  Result := Length(S);
  AStream.Write(Result, SizeOf(Result));
  if Result > 0 then
    AStream.Write(S[1], Result);
end;
 
function StreamReadString(AStream: TStream; out S: string): Integer;
begin
  AStream.Read(Result, SizeOf(Result));
  SetLength(S, Result);
  if Result > 0 then
    AStream.Read(S[1], Result);
end;
 
 
procedure SaveTreeViewDataProc(ANode: TTreeNode; AStream: TStream);
var
  DataNode: PDataNode;
  I: Integer;
begin
  // On peut le faire manuellement pour chaque type de Record
  // On peut le faire automatiquement via la lib SEPI SCL
  DataNode := PDataNode(ANode.Data);
  StreamWriteString(AStream, DataNode^.S);
  AStream.Write(DataNode^.I, SizeOf(DataNode^.I));
end;
 
procedure ReadTreeViewDataProc(ANode: TTreeNode; AStream: TStream);
var
  DataNode: PDataNode;
begin
  // On peut le faire manuellement pour chaque type de Record
  // On peut le faire automatiquement via la lib SEPI SCL
  New(DataNode);
  StreamReadString(AStream, DataNode^.S);
  AStream.Read(DataNode^.I, SizeOf(DataNode^.I));
  ANode.Data := DataNode;
end;
 
procedure TFrmTestDivers.FreeDataNodes();
var
  Node: TTreeNode;
begin
  Node := TreeView.Items.GetFirstNode();
  while Assigned(Node) do
  begin
    if Assigned(Node.Data) then
      Dispose(PDataNode(Node.Data));
 
    Node := Node.GetNext();
  end;
end;
 
procedure TFrmTestDivers.BtnFillDataClick(Sender: TObject);
var
  Node: TTreeNode;
  DataNode: PDataNode;
  I: Integer;
begin
  I := 0;
  Node := TreeView.Items.GetFirstNode();
  while Assigned(Node) do
  begin
    if not Assigned(Node.Data) then
    begin
      New(DataNode);
      DataNode^.S := UpperCase(Node.Text);
      DataNode^.I := I;
      Node.Data := DataNode;
      Inc(I);
    end;
 
    Node := Node.GetNext();
  end;
end;
 
procedure TreeViewDataSaveToStream(ATree: TTreeView; AStream: TStream; SaveDataProc: TIOTreeViewDataProc);
var
  DataStream, NodeStream: TMemoryStream;
  DataSize, NodeSize: Integer;
  Node: TTreeNode;
begin
  if Assigned(ATree) and Assigned(AStream) then
  begin
    DataStream := TMemoryStream.Create();
    try
      Node := ATree.Items.GetFirstNode();
      while Assigned(Node) do
      begin
        SaveDataProc(Node, DataStream);
        Node := Node.GetNext();
      end;
 
      AStream.Size := 0;
      DataStream.Seek(0, soFromBeginning);
 
      DataSize := DataStream.Size;
      AStream.Write(DataSize, SizeOf(DataSize));
      AStream.CopyFrom(DataStream, DataSize);
 
      NodeStream := TMemoryStream.Create();
      try
        NodeStream.WriteComponent(ATree);
        NodeStream.Seek(0, soFromBeginning);
 
        NodeSize := NodeStream.Size;
        AStream.Write(NodeSize, SizeOf(NodeSize));
        AStream.CopyFrom(NodeStream, NodeSize);
      finally
        NodeStream.Free();
      end;
    finally
      DataStream.Free();
    end;
  end;
end;
 
procedure TreeViewDataLoadFromStream(ATree: TTreeView; AStream: TStream; ReadDataProc: TIOTreeViewDataProc);
var
  Owner: TWinControl;
  MemoryTree: TTreeView;
  DataStream, NodeStream: TMemoryStream;
  DataSize, NodeSize: Integer;
  Node: TTreeNode;
begin
  if Assigned(ATree) and Assigned(AStream) then
  begin
    AStream.Seek(0, soFromBeginning);
    AStream.Read(DataSize, SizeOf(DataSize));
 
    DataStream := TMemoryStream.Create();
    try
      DataStream.CopyFrom(AStream, DataSize);
 
      NodeStream := TMemoryStream.Create();
      try
        AStream.Read(NodeSize, SizeOf(NodeSize));
        NodeStream.CopyFrom(AStream, NodeSize);
 
        NodeStream.Seek(0, soFromBeginning);
 
        MemoryTree := TTreeView.Create(nil);
        try
          MemoryTree.Parent := ATree;
          NodeStream.ReadComponent(MemoryTree);
 
          DataStream.Seek(0, soFromBeginning);
          Node := MemoryTree.Items.GetFirstNode();
          while Assigned(Node) do
          begin
            ReadDataProc(Node, DataStream);
            Node := Node.GetNext();
          end;
 
          ATree.Items.Assign(MemoryTree.Items);
        finally
          MemoryTree.Free();
        end;
      finally
        NodeStream.Free();
      end;
    finally
      DataStream.Free();
    end;
  end;
end;
 
procedure TFrmTestDivers.BtnShowDataClick(Sender: TObject);
var
  Node: TTreeNode;
  DataNode: PDataNode;
begin
  Node := TreeView.Items.GetFirstNode();
  while Assigned(Node) do
  begin
    if Assigned(Node.Data) then
    begin
      DataNode := PDataNode(Node.Data);
      Node.Text := Format('Text : "%s", Data : "%s-%d"', [Node.Text, DataNode^.S, DataNode^.I]);
    end;
 
    Node := Node.GetNext();
  end;
end;
 
 
procedure TFrmTestDivers.BtnSaveTreeDataClick(Sender: TObject);
var
  FileStream: TFileStream;
begin
  FileStream := TFileStream.Create(ExtractFilePath(Application.ExeName) + 'Files\' + ExtractFileName(ChangeFileExt(Application.ExeName, '.Tree.Dat')), fmCreate);
  try
    TreeViewDataSaveToStream(TreeView, FileStream, SaveTreeViewDataProc);
  finally
    FileStream.Free();
  end;
end;
 
procedure TFrmTestDivers.BtnLoadTreeDataClick(Sender: TObject);
var
  FileStream: TFileStream;
begin
  FileStream := TFileStream.Create(ExtractFilePath(Application.ExeName) + 'Files\' + ExtractFileName(ChangeFileExt(Application.ExeName, '.Tree.Dat')), fmOpenRead);
  try
    TreeViewDataLoadFromStream(TreeView, FileStream, ReadTreeViewDataProc);
  finally
    FileStream.Free();
  end;
end;

[petitprince]

Wahoo!! un grand merci à toi !!!
Ca marche tu tonnerre.... Petite précision, je croyais que la taille des Strings était fixe dans les records ?

Je ne mets pas le tag résolu tout de suite, je fais une petite démo et la poste

Merci.....

[ShaiLeTroll]

Tient, un code plus lent, il garanti l'assocation entre le Node et son Data, car le Data est stocké dans le DFM, donc en écrivant la valeur numérique du pointeur dans le fichier des Data, tu peux faire l'association (c'est un code plus complexe à maintenir, et pas forcément utile) ...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
procedure SaveTreeViewDataProcEx(ANode: TTreeNode; AStream: TStream);
var
  DataNode: PDataNode;
  L, P1, P2, P3: Integer;
begin
  DataNode := PDataNode(ANode.Data);
  L := 0;
  AStream.Write(Cardinal(DataNode), SizeOf(DataNode));
  P1 := AStream.Position;
  AStream.Write(L, SizeOf(Integer)); // 00 00 00 00 = emplacement libre pour la longueur
  P2 := AStream.Position;
 
  // Données Utiles
  StreamWriteString(AStream, DataNode^.S);
  AStream.Write(DataNode^.I, SizeOf(DataNode^.I));
  P3 := AStream.Position;
 
  // Longueur calculée, on revient en arrière, et on l'écrit à la place des 00 00 00
  AStream.Seek(P1, soFromBeginning);
  L := P3 - P2;
  AStream.Write(L, SizeOf(Integer));
  AStream.Seek(P3, soFromBeginning);
end;
 
procedure ReadTreeViewDataProcEx(ANode: TTreeNode; AStream: TStream);
var
  DataNode: PDataNode;
  L: Integer;
begin
  AStream.Seek(0, soFromBeginning);
 
  repeat
    AStream.Read(Cardinal(DataNode), SizeOf(DataNode));
    AStream.Read(L, SizeOf(L));
    AStream.Seek(L, soFromCurrent);
  until DataNode = ANode.Data;
 
  if DataNode = ANode.Data then
  begin
    New(DataNode);
 
    // Données Utiles
    AStream.Seek(-L, soFromCurrent);
    StreamReadString(AStream, DataNode^.S);
    AStream.Read(DataNode^.I, SizeOf(DataNode^.I));
 
    ANode.Data := DataNode;
  end;
end;

Petite précision, je croyais que la taille des Strings était fixe dans les records ?

Uniquement pour les record de fichier typé, sinon, c'est totalement libre, et heureusement ...

[petitprince]

Bonjour!
J'ai un problème au niveau de la libération des données contenus dans mes Records: ça ne libère que mes champs String et non mes Integer....

Voilà mon Record :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
  PDataNode = ^TDataNode;
  TDataNode = record
    S: String;
    FontColor: String;
    I: Integer;
    Index: Integer;
    SelIndex: Integer;
  end;

Et la procedure de libération:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
procedure TMainForm.FreeDataNodes;
begin
  Node := TreeView.Items.GetFirstNode();
  while Assigned(Node) do
  begin
    if Assigned(Node.Data) then
      Dispose(PDataNode(Node.Data));
    Node := Node.GetNext();
  end;
end;

D'où peut venir le problème ?

[ShaiLeTroll]

En fait, l'entier est libéré, mais à l'emplacement mémoire, la valeur reste toujours, ... elle sera plus tard remplacée (lorsque cela sera utile) , pour la chaine, c'est plus subtile car ce que tu manipule est un pointeur sur une structure TStrRec (System.pas) qui est finalisé (finalize), ce qui libère la mémoire du buffer de la chaine ...

d'ailleurs, ceci ne libérera pas les chaines, car il ne sait pas ce que contient ton pointeur, il va juste consulter demander à windows de libérer le pointeur, et "windows\MM" connaissant la taille, il va libéré la mémoire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Dispose(Node.Data);

Alors que là, tu lui fourni le "TypeInfo" décrivant le type de pointeur, et là il va pouvoir libérer chaine et tableau dynamique, et même les sous-strucutre contenu

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Dispose(PDataNode(Node.Data));

[petitprince]

Je n'ai pas saisi...... mon code est bon alors ?
Autre bizarrerie, lorsque je consulte le Noeud sélectionner, pour voir si mon record a bien été effacé, le programme plante :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
procedure TMainForm.TreeViewClick(Sender: TObject);
var
  DataNode: PDataNode;
begin
  Node := TreeView.Selected;
  Image1.Picture.Graphic := nil;
  Image2.Picture.Graphic := nil;
  if Node <> nil then
   if Assigned(Node.Data) then       //// !!!! cette ligne devrait éviter le plantage, non
    begin
      DataNode := PDataNode(Node.Data);
      EditString.Text := DataNode^.S;
      EditColor.Text := DataNode^.FontColor;
      EditInt.Text := IntToStr(DataNode^.I);
      NodeImageList.GetBitmap(DataNode^.Index, Image1.Picture.Bitmap);
      NodeImageList.GetBitmap(DataNode^.SelIndex, Image2.Picture.Bitmap);
    end;
end;

Là vraiment je sèche ......

[petitprince]

Bon je viens de faire un truc de vraiment pas propre....

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
procedure TMainForm.FreeDataNodes;
begin
  Node := TreeView.Items.GetFirstNode();
  while Assigned(Node) do
  begin
    if Assigned(Node.Data) then
      Dispose(PDataNode(Node.Data));
    Node.Data := nil;                       // j'ai rajouté ça !
    Node := Node.GetNext();
  end;
end;

Ca marche, mais qu'en est-il au niveau mémoire ?

[ShaiLeTroll]

Affectivement, la mise à nil est conseillé, le Assigned(pointeur) ce n'est que pointeur <> nil ...

d'ailleurs, c'est pour cela que pour les objets, la fonction FreeAndNil est devenu un standard ...

[petitprince]

Bon et bien comme convenu, voici une démo assez complète sur l'utilisation d'une treeview....
On peut évidement faire encore mieux, il y a tellement de possibilités....
N'hésitez pas à faire remonter d'éventuels bugs, ou lourdeurs de code, afin d'optimiser la démo, et surtout pour mon apprentissage
ShaiLeTroll encore merci....