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

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
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;