VST Speichern und Laden

[100nF]

Hallo zusammen,

Also ich habe vor kurzem angefangen den virtualstringtree zu benützen.
funktioniert bis jetzt auch nicht schlecht, nur hab ichs noch nicht hinbekommen, den inhalt vom VST abzuspeichern und wieder zu laden. dazu verwende ich vst.savetofile und vst.loadfromfile.
hier ein bisschen code:

Delphi-Quellcode:

TArchiv = class
  private
    function GetPlaylistName: String;
  public
    Filename:     String;
    Titel:        String;
    Interpret:    String;
    Album:        String;
    Genre:        String;
    Dauer:        TTime;
    Bewertung:    Integer;
    Counter:      Integer;
    Datum:        TDate;
    property Playlistname: String read GetPlaylistname;
  end;

Delphi-Quellcode:

procedure TForm1.VST1SaveNode(Sender: TBaseVirtualTree; Node: PVirtualNode;
  Stream: TStream);
var
  daten: TArchiv; Len: Integer;
begin
  daten := TArchiv(vst1.GetNodeData(Node)^);

  Len := Length(Daten.Filename);
  Stream.write(Len, SizeOf(Len));
  Stream.write(PChar(Daten.Filename)^, Len);

  Len := Length(Daten.Titel);
  Stream.write(Len, SizeOf(Len));
  Stream.write(PChar(Daten.Titel)^, Len);

  Len := Length(Daten.Interpret);
  Stream.write(Len, SizeOf(Len));
  Stream.write(PChar(Daten.Interpret)^, Len);

  Len := Length(Daten.Album);
  Stream.write(Len, SizeOf(Len));
  Stream.write(PChar(Daten.Album)^, Len);

  Len := Length(Daten.Genre);
  Stream.write(Len, SizeOf(Len));
  Stream.write(PChar(Daten.Genre)^, Len);
end;

procedure TForm1.VST1LoadNode(Sender: TBaseVirtualTree; Node: PVirtualNode;
  Stream: TStream);
var
  daten: TArchiv; Len: Integer;
begin
  daten := TArchiv(vst1.GetNodeData(Node)^);

  Stream.read(Len, SizeOf(Len));
  SetLength(Daten.Filename, len);
  Stream.read(PChar(Daten.Filename)^, Len);

  Stream.read(Len, SizeOf(Len));
  SetLength(Daten.Titel, len);
  Stream.read(PChar(Daten.Titel)^, Len);

  Stream.read(Len, SizeOf(Len));
  SetLength(Daten.Interpret, len);
  Stream.read(PChar(Daten.Interpret)^, Len);

  Stream.read(Len, SizeOf(Len));
  SetLength(Daten.Album, len);
  Stream.read(PChar(Daten.Album)^, Len);

  Stream.read(Len, SizeOf(Len));
  SetLength(Daten.Genre, len);
  Stream.read(PChar(Daten.Genre)^, Len);
end;

also ich habe keine ahnung ob das soweit schonmal stimmt. und noch weniger ahnung habe ich, wie ich die integer, TDate und TTime Werte speichern und laden muss.
hab auch mal gesucht im internet, aber hab nur eine lösung gefunden, welche aber mit records gemacht wurde. davon hab ich dann auch den code genommen und abgeändert.

Wäre sehr dankbar wenn ihr mir da weiterhelfen könntet!

mfg
urbanbruhin

[generic]

Gut ich bin jetzt nicht der Fan von Records, aber an dieser Stelle hätte man es leicht wegen der festen Länge.
Allerdings könntest du deine Klasse von TPersistent ableiten und die Eigenschaften welche gespeichert werden sollen "published" machen.
Dann kannst du Prima in den Stream speichern und laden.

TDate wird intern als float abgebildet und hat natürlich auch immer eine Länge im Speicher.
Du kannst die Größe von den Datentypen mit den sizeof(<feld oder datentyp>) rausfinden.

[100nF]

danke für die antwort!

leider bin ich nicht ganz so vom fach wie du^^
(machs nur bisschen als hobby, im beruf hab ich nix damit zu tun)

also vom ersten abschnitt versteh ich nicht grad viel, so von TPersistent und "die eigenschaften published machen"...

aber eigentlich müsste mein code so ungefähr stimmen, und müsste also auch mit TDate und so funktionieren?

bisschen codeschnipsel wären vielleicht nicht schlecht, das versteh ich wohl besser als die erklärungen :D

P.S. also du meinst ich sollte das nicht mit einer Klasse, sondern mit records realisieren, das ganze? also ich weiss nicht, aber ich glaub mit einer klasse ist das ein bisschen "eleganter" oder nicht?

[Nuclear-Ping]

Sorry, aber was ist denn konkret das Problem?

Hast du dir den Code irgendwoher kopiert? Weil wenn nicht, solltest du eigentlich von selbst verstehen, wie man Integer- und Float-Werte speichert. Denn nichts anderes ist TDateTime. Und SizeOf scheinst du ja zu kennen. ;)

[100nF]

jo also ich habs mal irgendwie probiert aber das hat nicht geklappt...
und ich weiss auch nicht ob das überhaupt stimmt was ich bis jetzt habe.

als0 ich hab den code kopiert von einem tutorial wo es aber mit records beschrieben ist, und hab dann bisschen abgeändert.

also das mit dem sizeof und so... also KENNEN ist übertrieben :D
mehr als ich mir selbst aus dem begriff "sizeof" ableiten kann, versteh ich nicht an dem teil... wird wohl irgendwie dir grösse won dem angeben, was in den klammern staht denk ich mal. aber WIE die grösse angegeben wird weiss ich net, also die einheiz, z.B. in byte oder so. das mit dem length(), das gibt wohl die anzahl zeichen an oder? also length('hallo') wird 5 ergeben oder nicht?

also ich probier mal noch bisschen rum, bis jetzt hab ich aber immer eine fehlermeldung bekommen beim laden der daten. werd die fehlermeldung mal hier posten wenn ich nicht weiter komme

EDIT: und was ich vorallen nicht verstehe am ganzen, ist der stream. ich hab null ahnung wie das aufgebaut ist und so...
EDIT2: ausserdem kann man Len := Length(Daten.Dauer); nicht verwenden, nur weiss ich nicht was man anstelle von dem verwenden muss...
EDIT3: so, hab jetzt mal was gemacht aber komm nicht weiter.

Delphi-Quellcode:

procedure TForm1.VST1SaveNode(Sender: TBaseVirtualTree; Node: PVirtualNode;
  Stream: TStream);
var
  daten: TArchiv; Len: Integer;
begin
  daten := TArchiv(vst1.GetNodeData(Node)^);

  Len := Length(Daten.Filename);
  Stream.write(Len, SizeOf(Len));
  Stream.write(PChar(Daten.Filename)^, Len);

  Len := Length(Daten.Titel);
  Stream.write(Len, SizeOf(Len));
  Stream.write(PChar(Daten.Titel)^, Len);

  Len := Length(Daten.Interpret);
  Stream.write(Len, SizeOf(Len));
  Stream.write(PChar(Daten.Interpret)^, Len);

  Len := Length(Daten.Album);
  Stream.write(Len, SizeOf(Len));
  Stream.write(PChar(Daten.Album)^, Len);

  Len := Length(Daten.Genre);
  Stream.write(Len, SizeOf(Len));
  Stream.write(PChar(Daten.Genre)^, Len);

  Len := Length(floattostr(Daten.Dauer));
  Stream.write(Len, SizeOf(Len));
  Stream.write(Daten.Dauer, Len);


  Len := Length(inttostr(Daten.Bewertung));
  Stream.write(Len, SizeOf(Len));
  Stream.write(Daten.Bewertung, Len);

  Len := Length(inttostr(Daten.Counter));
  Stream.write(Len, SizeOf(Len));
  Stream.write(Daten.Counter, Len);

  Len := Length(floattostr(Daten.Datum));
  Stream.write(Len, SizeOf(Len));
  Stream.write(Daten.Datum, Len);



end;

procedure TForm1.VST1LoadNode(Sender: TBaseVirtualTree; Node: PVirtualNode;
  Stream: TStream);
var
  daten: TArchiv; Len: Integer;
begin
  daten := TArchiv(vst1.GetNodeData(Node)^);

  Stream.read(Len, SizeOf(Len));
  SetLength(Daten.Filename, len);
  Stream.read(PChar(Daten.Filename)^, Len);

  Stream.read(Len, SizeOf(Len));
  SetLength(Daten.Titel, len);
  Stream.read(PChar(Daten.Titel)^, Len);

  Stream.read(Len, SizeOf(Len));
  SetLength(Daten.Interpret, len);
  Stream.read(PChar(Daten.Interpret)^, Len);

  Stream.read(Len, SizeOf(Len));
  SetLength(Daten.Album, len);
  Stream.read(PChar(Daten.Album)^, Len);

  Stream.read(Len, SizeOf(Len));
  SetLength(Daten.Genre, len);
  Stream.read(PChar(Daten.Genre)^, Len);

  Stream.read(Len, SizeOf(Len));
  SetLength(Daten.Dauer, len);
  Stream.read(Daten.Dauer, Len);

  Stream.read(Len, SizeOf(Len));
  SetLength(Daten.Bewertung, len);
  Stream.read(Daten.Bewertung, Len);

  Stream.read(Len, SizeOf(Len));
  SetLength(Daten.Counter, len);
  Stream.read(Daten.Counter, Len);

  Stream.read(Len, SizeOf(Len));
  SetLength(Daten.Datum, len);
  Stream.read(Daten.Datum, Len);
end;

das SetLength funktioniert ja nur bei Strings, aber bei TDate und Integer nicht. werd mal nach der lösung suchen vielleicht find ich was...

[generic]

Delphi-Quellcode:

type
  TArchiv = class(TComponent)
  private
    fFilename:     String;
    fTitel:        String;
    fInterpret:    String;
    fAlbum:        String;
    fGenre:        String;
    fDauer:        TTime;
    fBewertung:    Integer;
    fCounter:      Integer;
    fDatum:        TDate;

    function GetPlaylistName: String;
  published
    property Filename:     String read fFilename write fFilename;
    property Titel:        String read fTitel write fTitel;
    property Interpret:    String read fInterpret write fInterpret;
    property Album:        String read fAlbum write fAlbum;
    property Genre:        String read fGenre write fGenre;
    property Dauer:        TTime read fDauer write fDauer;
    property Bewertung:    Integer read fBewertung write fBewertung;
    property Counter:      Integer read fCounter write fCounter;
    property Datum:        TDate read fDatum write fDatum;
  public
    property Playlistname: String read GetPlaylistname;
  end;

var
  a,b: TArchiv;
  mstream: TMemoryStream;

begin
  a:=TArchiv.Create(nil);
  a.Filename:='test';
  a.Datum:=now;

  mstream:=TMemoryStream.Create();
  mstream.WriteComponent(a);

  mstream.SaveToFile('c:\temp\a.dat');

  mstream.Seek(soFromBeginning, 0);
  b:=TArchiv.create(nil);
  mstream.ReadComponent(b);
  caption:=b.Filename;

  mstream.free;
  a.free;
  b.free;
end;

Der VST hat noch paar Routinen die dir helfen können:

Delphi-Quellcode:

  VirtualStringTree1.SaveToFile(...);
  VirtualStringTree1.SaveToStream(...);

[100nF]

boah cool Danke!

aber was ich nicht begreife: braucht es die ganzen published-dinger?? wozu brauch ich die ganzen read und write functionen? ich kann ja die werte nirgens auslesen oder berechnen oder sowas, sondern die werden einmal reingeschrieben und fertig. aber ich glaub ich hab einfach zu wenig ahnung von dem um das zu begreifen...

werde den code sehr wahrscheinlich morgen mal testen.

falls es hilft, hier noch mein vorhaben, also was ich genau machen will:
es geht um ein musikprogramm mit einem archiv, wo alle musikstücke aufgelistet sind (das wäre dann der VST). nun kann man beliebig viele einträge (Musikdateien) hinzufügen, was auch shcon klappt. und wenn das programm beendet wird, muss das ganze archiv in einer datei abgespeichert, und dann natürlich beim nächsten programmstart sofort geladen werden.

[generic]

Zitat:

braucht es die ganzen published-dinger??

Wenn du Properties hast, welche published sind, wir vom Compiler eine Liste von diesen Abgelegt.
Diese kann ausgelesen werden, was sich TComponent/TStream zu nutze macht.

So erspart du dir viel Arbeit.

Zitat:

ich kann ja die werte nirgens auslesen oder berechnen

Die Berechnungen die du durchführst, machst du doch auf bestehende Daten.
Die Daten müssen irgendwo vorliegen und gespeichert werden.
Das Ergebnis der Berechnung nicht, diese lässt sich beliebig mit den Daten wiederholen.
(daher ist auch die eine Eigenschaft public)

Zitat:

wozu brauch ich die ganzen read und write functionen?

warum schreibst du jeden Wert selbst in den Stream?
Die Read/Write Funktionen von TStream können das doch genauso gut.
Das Read/Write ersetzt deinen gesamten Code, welche du in Load/Save hast.

Das savetofile dient nur zur Verdeutlichung, dass wirlich was im Stream steht.

[100nF]

okay ich muss mir das ganze dann nochmal überdenken...

also das heisst, dass ich die onSaveNode und onLoadNode gar nicht brauche?
aber es würde auch so gehen wie ich es gemacht habe oder, einfach mit ein paar kleinen änderungen?

[Nuclear-Ping]

Die Methode von generic hat nichts mit dem VST zu tun. Sie speichert die ganze Klasse.

OnSaveNode und OnLoadNode sind Ereignisse, die eintreten, wenn du mit dem VST speicherst.

Speichern von TDate, TTime:

Delphi-Quellcode:

var
  Date1: TDate;
  Time1: TTime;
  DateTime1: TDateTime;

begin
  // ...

  Stream.write(Date1, SizeOf (TDate)); 
  Stream.write(Time1, SizeOf (TTime)); 
  Stream.write(DateTime1, SizeOf (TDateTime)); 

  // ...
end;

[100nF]

ach soo ist das, jetzt ist mir einiges klarer geworden.

@generic
aber warum würdest du es so machen wie du es oben beschrieben hast?
warum nicht mit der funktion, die der VST selbst mit sich bringt?
also für mich sieht die methode vom VST irgendwie einfacher aus...

@Nuclear-Ping
danke für den code, werde ihn vermutlich heute abend ausprobieren!
ich dachte immer, ich müsse pro wert 2 mal stream.write oder stream.read aufrufen, so wie es bei den strings ist...

[generic]

Ich sehe nichts was verhindern würde, das automatische Streamspeichern mit den VST.Load/Save zu verwenden.
Nur den manuellen Code zum umkopieren der Daten würde ich lassen.

[Nuclear-Ping]

Zitat:

Zitat von urbanbruhin

@Nuclear-Ping
danke für den code, werde ihn vermutlich heute abend ausprobieren!
ich dachte immer, ich müsse pro wert 2 mal stream.write oder stream.read aufrufen, so wie es bei den strings ist...

Bei Strings musst du das so machen, da sie zu Beginn keine bestimmte Größe haben. Daher speicherst du die Länge, dann den String. Und beim Laden liest du zuerst die Länge, dann den String mit der Länge.

Bei Typen die Zahlen beinhalten ist das aber was anderes. Da kannst du mit SizeOf (DatenTyp) arbeiten.

[100nF]

also jetzt hab ichs so probiert:

Delphi-Quellcode:

procedure TForm1.VST1SaveNode(Sender: TBaseVirtualTree; Node: PVirtualNode;
  Stream: TStream);
var
  daten: TArchiv; Len: Integer;
begin
  daten := TArchiv(vst1.GetNodeData(Node)^);

  Len := Length(Daten.Filename);
  Stream.write(Len, SizeOf(Len));
  Stream.write(PChar(Daten.Filename)^, Len);

  Len := Length(Daten.Titel);
  Stream.write(Len, SizeOf(Len));
  Stream.write(PChar(Daten.Titel)^, Len);

  Len := Length(Daten.Interpret);
  Stream.write(Len, SizeOf(Len));
  Stream.write(PChar(Daten.Interpret)^, Len);

  Len := Length(Daten.Album);
  Stream.write(Len, SizeOf(Len));
  Stream.write(PChar(Daten.Album)^, Len);

  Len := Length(Daten.Genre);
  Stream.write(Len, SizeOf(Len));
  Stream.write(PChar(Daten.Genre)^, Len);

  Stream.write(Daten.Dauer, sizeof(ttime));

  Stream.write(Daten.Bewertung, sizeof(Daten.Bewertung));  //habs auch mal mit sizeof(integer) versucht...

  Stream.write(Daten.Counter, sizeof(Daten.Counter));    // ...hier auch...

  Stream.write(Daten.Datum, sizeof(tdate));

end;

procedure TForm1.VST1LoadNode(Sender: TBaseVirtualTree; Node: PVirtualNode;
  Stream: TStream);
var
  daten: TArchiv; Len: Integer;
begin
  daten := TArchiv(vst1.GetNodeData(Node)^);

  Stream.read(Len, SizeOf(Len));
  SetLength(Daten.Filename, len);
  Stream.read(PChar(Daten.Filename)^, Len);

  Stream.read(Len, SizeOf(Len));
  SetLength(Daten.Titel, len);
  Stream.read(PChar(Daten.Titel)^, Len);

  Stream.read(Len, SizeOf(Len));
  SetLength(Daten.Interpret, len);
  Stream.read(PChar(Daten.Interpret)^, Len);

  Stream.read(Len, SizeOf(Len));
  SetLength(Daten.Album, len);
  Stream.read(PChar(Daten.Album)^, Len);

  Stream.read(Len, SizeOf(Len));
  SetLength(Daten.Genre, len);
  Stream.read(PChar(Daten.Genre)^, Len);

  Stream.read(Daten.Dauer, sizeof(ttime));

  Stream.read(Daten.Bewertung, sizeof(Daten.Bewertung));  // ...und hier...

  Stream.read(Daten.Counter, sizeof(Daten.Counter));    //..und hier

  Stream.read(Daten.Datum, sizeof(tdate));
end;

speichern geht eigentlich, die datei wird auch erstellt und da ist auch was drin in der datei. beim laden bekomm ich aber jedesmal eine zugriffsverletzung! was mach ich falsch?

bei der zugriffsverletzung wird zuerst etwas in der unit VirtualTrees rot markiert, und wenn ich wieder F9 drücke kommt die zweite zugriffsverletzung hier:

Delphi-Quellcode:

procedure TForm1.VST1GetText(Sender: TBaseVirtualTree; Node: PVirtualNode;
  Column: TColumnIndex; TextType: TVSTTextType; var CellText: WideString);
var
  daten: TArchiv;
begin
  daten := TArchiv(vst1.GetNodeData(node)^);
  case column of
    0: celltext := daten.Titel;  // <--- diese Zeile wird rot markiert
    1: celltext := daten.Interpret;
    2: celltext := daten.Album;
    3: celltext := daten.Genre;
    4: celltext := timetostr(daten.Dauer);
    5: celltext := inttostr(daten.Bewertung);
    6: celltext := inttostr(daten.Counter);
    7: celltext := datetostr(daten.Datum);
  end;
end;

@generic
also deine methode hat mich irgendwie noch nicht so richtig überzeugt :wink: wenn du mir einen guten grund nennen kannst, der für deine methode spricht, könnt ich mich ja noch umentscheiden :-D

[generic]

Hehe, gerne.

Spass an:

Programmiere wie du möchtest und solange du möchtest.

Nur das hier alles zu schreiben:

Delphi-Quellcode:

procedure TForm1.VST1SaveNode(Sender: TBaseVirtualTree; Node: PVirtualNode;
  Stream: TStream);
var
  daten: TArchiv; Len: Integer;
begin
  daten := TArchiv(vst1.GetNodeData(Node)^);

  Len := Length(Daten.Filename);
  Stream.write(Len, SizeOf(Len));
  Stream.write(PChar(Daten.Filename)^, Len);

  Len := Length(Daten.Titel);
  Stream.write(Len, SizeOf(Len));
  Stream.write(PChar(Daten.Titel)^, Len);

  Len := Length(Daten.Interpret);
  Stream.write(Len, SizeOf(Len));
  Stream.write(PChar(Daten.Interpret)^, Len);

  Len := Length(Daten.Album);
  Stream.write(Len, SizeOf(Len));
  Stream.write(PChar(Daten.Album)^, Len);

  Len := Length(Daten.Genre);
  Stream.write(Len, SizeOf(Len));
  Stream.write(PChar(Daten.Genre)^, Len);

  Stream.write(Daten.Dauer, sizeof(ttime));

  Stream.write(Daten.Bewertung, sizeof(Daten.Bewertung));  //habs auch mal mit sizeof(integer) versucht...

  Stream.write(Daten.Counter, sizeof(Daten.Counter));    // ...hier auch...

  Stream.write(Daten.Datum, sizeof(tdate));

end;

procedure TForm1.VST1LoadNode(Sender: TBaseVirtualTree; Node: PVirtualNode;
  Stream: TStream);
var
  daten: TArchiv; Len: Integer;
begin
  daten := TArchiv(vst1.GetNodeData(Node)^);

  Stream.read(Len, SizeOf(Len));
  SetLength(Daten.Filename, len);
  Stream.read(PChar(Daten.Filename)^, Len);

  Stream.read(Len, SizeOf(Len));
  SetLength(Daten.Titel, len);
  Stream.read(PChar(Daten.Titel)^, Len);

  Stream.read(Len, SizeOf(Len));
  SetLength(Daten.Interpret, len);
  Stream.read(PChar(Daten.Interpret)^, Len);

  Stream.read(Len, SizeOf(Len));
  SetLength(Daten.Album, len);
  Stream.read(PChar(Daten.Album)^, Len);

  Stream.read(Len, SizeOf(Len));
  SetLength(Daten.Genre, len);
  Stream.read(PChar(Daten.Genre)^, Len);

  Stream.read(Daten.Dauer, sizeof(ttime));

  Stream.read(Daten.Bewertung, sizeof(Daten.Bewertung));  // ...und hier...

  Stream.read(Daten.Counter, sizeof(Daten.Counter));    //..und hier

  Stream.read(Daten.Datum, sizeof(tdate));
end;

dauert länger als:

Delphi-Quellcode:

procedure TForm1.VST1LoadNode(Sender: TBaseVirtualTree; Node: PVirtualNode;
  Stream: TStream);
var
  daten: TArchiv; Len: Integer;
begin
  daten := TArchiv(vst1.GetNodeData(Node)^);
  Stream.LoadComponent(daten);
end;

procedure TForm1.VST1SaveNode(Sender: TBaseVirtualTree; Node: PVirtualNode;
  Stream: TStream);
var
  daten: TArchiv; Len: Integer;
begin
  daten := TArchiv(vst1.GetNodeData(Node)^);
  Stream.SaveComponent(daten);
end;

Hinzukommt noch, wenn du dein Objekt erweiterst, kann es deine Routine nicht mehr laden.
Die Satzlänge passt dann nicht mehr.

So Spass bei Seite. Du solltest versuchen wenig Code zu schreiben.
Hat den großen Vorteil bei großen Projekten, den Überblick zu behalten.

Weniger Code, weniger Fehler, weniger zu debuggen, mehr Übersicht (,weniger Dateigröße).

[100nF]

okay, überredet! :mrgreen:

hat schon paar nette vorteile wie ich sehe.

aber stream.savecomponent und stream.loadcomponent gibts ja gar nicht!?!?

hmm werd morgen mal weiter schauen bin jetzt zu müde...

EDIT: ach so ich glaub du meinst writecomponent und readcomponent :D

[Nuclear-Ping]

Zitat:

Zitat von generic

Hinzukommt noch, wenn du dein Objekt erweiterst, kann es deine Routine nicht mehr laden.
Die Satzlänge passt dann nicht mehr.

Das Problem hat er aber mit deiner Methode auch.

@TE:
Die Zugriffsverletzungen kommen von der "komischen" Handhabung deines Datenpointers, würde ich mal behaupten.

So mach ichs:

1.) Statt String WideString
2.) Keine Dereferenzierung des Pointers beim holen der Daten

Delphi-Quellcode:

type
  PTreeMenuEntry = ^TTreeMenuEntry;
  TTreeMenuEntry = record
    MainID            : Integer;
    ParentID          : Integer;
    UniqueID          : Integer;
    MenuTitle         : WideString;
    Flags             : Integer;
    ItemsCount        : Integer;
    ItemsSelected     : Integer;
  end;

// ...

procedure TDatabaseTree.DatabaseViewSaveNode(Sender: TBaseVirtualTree;
  Node: PVirtualNode; Stream: TStream);
var
  Data: PTreeMenuEntry;
  c: Integer;
  p: PWideChar;
begin
  Data := DatabaseView.GetNodeData (Node);

  Stream.Write (Data.MainID, SizeOf (Integer));
  Stream.Write (Data.ParentID, SizeOf (Integer));
  Stream.Write (Data.Flags, SizeOf (Integer));
  Stream.Write (Data.ItemsCount, SizeOf (Integer));
  Stream.Write (Data.ItemsSelected, SizeOf (Integer));
  Stream.Write (Data.UniqueID, SizeOf (Integer));

  c := Length (Data.MenuTitle) + 1;
  Stream.Write (c, SizeOf (Integer));
  p := PWideChar (Data.MenuTitle + #0);
  Stream.Write (Data.MenuTitle[1], c * 2);
end;

procedure TDatabaseTree.DatabaseViewLoadNode(Sender: TBaseVirtualTree;
  Node: PVirtualNode; Stream: TStream);
var
  Data: PTreeMenuEntry;
  c: Integer;
  p: PWideChar;
begin
  Data := DatabaseView.GetNodeData (Node);

  Stream.Read (Data.MainID, SizeOf (Integer));
  Stream.Read (Data.ParentID, SizeOf (Integer));
  Stream.Read (Data.Flags, SizeOf (Integer));
  Stream.Read (Data.ItemsCount, SizeOf (Integer));
  Stream.Read (Data.ItemsSelected, SizeOf (Integer));
  Stream.Read (Data.UniqueId, SizeOf (Integer));

  Stream.Read (c, SizeOf (Integer));
  c := c * 2;
  GetMem (p, c);
  Stream.Read (p^, c);
  Data.MenuTitle := WideString (p);
  FreeMem (p);
end;

[100nF]

ich kriegs einfach nicht gebacken :wall:

also ich muss erst mal wissen wie das ganze so vor sich geht.
wenn ich vst.savetofile aufrufe, dann geht der vst jede einzelne knoten durch, und schreibt diese in einen tstream. wenn dies erledigt ist, wird dieser tstream als datei abgespeichtet. und dies geschieht vst-intern. stimmt das soweit?

ich rufe also vst.savetofile auf, und der rest erledigt der vst selbst, sofern folgender code verwendet wird?

Delphi-Quellcode:

procedure TForm1.VST1SaveNode(Sender: TBaseVirtualTree; Node: PVirtualNode;
  Stream: TStream);
var
  daten: TArchiv;
begin
  daten := TArchiv(vst1.GetNodeData(Node)^);
  stream.WriteComponent(daten);
end;

procedure TForm1.VST1LoadNode(Sender: TBaseVirtualTree; Node: PVirtualNode;
  Stream: TStream);
var
  daten: TArchiv;
begin
  daten := TArchiv(vst1.GetNodeData(Node)^);
  Stream.readComponent(daten);
end;

ich blick da irgendwie echt nicht durch...

@Nuclear-Ping
dein beispielcode ist halt mit records, was ich eigenlich nicht verwenden wollte...

[generic]

ich denke das Problem tritt beim Laden auf.
Natürlich müssen die Objekte erzeugt werden.

Der interne Record vom VST speichert NUR den Zeiger auf das Objekt.

bzw. das Load erzeugt das object, allerdings nur wenn du die klasse vorher registierst.

Delphi-Quellcode:

type
  TTreehelper = class(TComponent)
  private
    fabc: string;
  published
    property abc: string read fabc write fabc;
  end;
  pTreehelper = ^TTreehelper;

{$R *.dfm}

procedure TForm2.Button1Click(Sender: TObject);
begin
  VirtualStringTree1.LoadFromFile('c:\temp\tree.dat');
end;

procedure TForm2.Button2Click(Sender: TObject);
begin
  VirtualStringTree1.SaveToFile('c:\temp\tree.dat');
end;

procedure TForm2.Button3Click(Sender: TObject);
var
  a: TTreehelper;
begin
  a:=TTreehelper.Create(nil);
  a.abc:='hallo';
  VirtualStringTree1.AddChild(nil, a);
  a:=TTreehelper.Create(nil);
  a.abc:='ballo';
  VirtualStringTree1.AddChild(nil, a);
  a:=TTreehelper.Create(nil);
  a.abc:='callo';
  VirtualStringTree1.AddChild(nil, a);
  a:=TTreehelper.Create(nil);
  a.abc:='dllo';
  VirtualStringTree1.AddChild(nil, a);
end;

procedure TForm2.FormCreate(Sender: TObject);
begin
  VirtualStringTree1.NodeDataSize:=sizeof(TTreehelper);
  RegisterClass(TTreehelper);
end;

procedure TForm2.VirtualStringTree1FreeNode(Sender: TBaseVirtualTree;
  Node: PVirtualNode);
var
  a: TTreehelper;
begin
  a:=TTreehelper(Sender.GetNodeData(node)^);
  a.free;
end;

procedure TForm2.VirtualStringTree1GetText(Sender: TBaseVirtualTree;
  Node: PVirtualNode; Column: TColumnIndex; TextType: TVSTTextType;
  var CellText: WideString);
var
  a: TTreehelper;
begin
  a:=TTreehelper(Sender.GetNodeData(node)^);
  CellText:=a.abc;
end;

procedure TForm2.VirtualStringTree1LoadNode(Sender: TBaseVirtualTree;
  Node: PVirtualNode; Stream: TStream);
var
  a: TTreehelper;
  p: pTreehelper;
begin
  a:=Stream.ReadComponent(nil) as TTreehelper;
  p:=sender.GetNodeData(node);
  p^:=a;
end;

procedure TForm2.VirtualStringTree1SaveNode(Sender: TBaseVirtualTree;
  Node: PVirtualNode; Stream: TStream);
var
  a: TTreehelper;
begin
  a:=TTreehelper(Sender.GetNodeData(node)^);
  Stream.WriteComponent(a);
end;

[Nuclear-Ping]

Ach TArchiv ist 'ne Klasse ... sorry, jetzt erst gecheckt. :wall:

Aber generic war ja gleich zur Stelle. :mrgreen:

[generic]

Klar, ich als selbsternannter :warn: DP-VST-weiss-alles-Profi, muss doch zu JEDEM VST Beitrag was schreiben.

:dp:

[100nF]

juhuuuuu es funktioniert!!!
:firejump:

habs jetzt so gemacht wie beim letzten beispielcode von generic.

vielen dank für eure hilfe!! :angel:

EDIT: also das mit dem registerclass() hab ich halt immer vergessen, oder besser gesagt ich kannte dies noch nicht^^ aber das muss man dann beim onformdestroy nicht wieder rückgängigmachen mit removeclass() oder sowas?