Objekte einer TObjectList direkt aus dem Speicher lesen / in ihn schreiben

[Uwe Raabe]

Hört sich irgendwie nach diesem Fehler an: GetObject() Always Returns Positive Height For DIB Sections

[Uwe Raabe]

Du kannst übrigens den upside-down Effekt auch schon beim ersten Zeichnen hervorrufen:

Delphi-Quellcode:

    ExtractThumbnail(Bmp, Verz + JPGDatei, 400, 0);
    Bmp.Dormant;

Damit ist eigentlich schon sehr wahrscheinlich, daß Windows offenbar das biHeight im InfoHeader falsch angibt.

Es hat somit nicht mit dem Speichern und Laden zu tun.

[himitsu]

Nein, das Bild hat natürlich immer eine positive Höhe,
aber wie intern die Daten im RAM liegen, das hat damit absolut nichts zu tun, sondern das hängt vom Datenformat ab.

Beispiel: BigEndian und LittleEndian

[Uwe Raabe]

Zitat von himitsu:

Nein, das Bild hat natürlich immer eine positive Höhe,

Sicher, aber der Parameter biHeight im InfoHeader gibt über sein Vorzeichen die Orientierung an - normalerweise.

Zitat:

For uncompressed RGB bitmaps, if biHeight is positive, the bitmap is a bottom-up DIB with the origin at the lower left corner. If biHeight is negative, the bitmap is a top-down DIB with the origin at the upper left corner.

[uligerhardt]

Zitat von Sir Rufo:

Delphi-Quellcode:

      lBitmap := TBitmap.Create;
      try
        // ...
        lBitmap := nil;
      finally
        lBitmap.Free;
      end;

Das gibt ein Memory leak, wenn ich mich nicht sehr irre.

[himitsu]

Na dann.

Aber wer glaubt schon einer Dokumentation?
Wenn ich das täte, dann wäre in Delphi Vieles nicht "vorhanden", weil die OH immer behauptet "hier steht nix".

[Uwe Raabe]

Zitat von uligerhardt:

Zitat von Sir Rufo:

Delphi-Quellcode:

      lBitmap := TBitmap.Create;
      try
        // ...
        lBitmap := nil;
      finally
        lBitmap.Free;
      end;

Das gibt ein Memory leak, wenn ich mich nicht sehr irre.

Nur, wenn die ObjectList, der direkt vor der nil-Zuweisung die Bitmap-Instanz zugefügt wird, diese nicht frei gibt.

[Sir Rufo]

Zitat von uligerhardt:

Zitat von Sir Rufo:

Delphi-Quellcode:

      lBitmap := TBitmap.Create;
      try
        // ...
        lBitmap := nil;
      finally
        lBitmap.Free;
      end;

Das gibt ein Memory leak, wenn ich mich nicht sehr irre.

Nein, so sieht das Standard-Muster aus, wenn man das Lifetime-Management der Instanz delegiert.

Delphi-Quellcode:

      lBitmap := TBitmap.Create;
      try
        // Übergabe des Lifetime-Managements
        ...
        // Jetzt bin ich nicht mehr verantwortlich
        lBitmap := nil;
      finally
        lBitmap.Free;
      end;

[uligerhardt]

Zitat von Uwe Raabe:

Zitat von uligerhardt:

Zitat von Sir Rufo:

Delphi-Quellcode:

      lBitmap := TBitmap.Create;
      try
        // ...
        lBitmap := nil;
      finally
        lBitmap.Free;
      end;

Das gibt ein Memory leak, wenn ich mich nicht sehr irre.

Nur, wenn die ObjectList, der direkt vor der nil-Zuweisung die Bitmap-Instanz zugefügt wird, diese nicht frei gibt.

Dann halt so: lBitmap := nil gefolgt von lBitmap.Free ist sinnfrei.

Edit: Ah, jetzt hab ich's kapiert. Im Falle einer Exception greift das Free ja noch.

[Perlsau]

Irgendwie entzieht sich mir der Sinn des Ganzen. Wenn ich doch bereits eine generische TObjectList habe, wieso verwendet man dann nicht einfach die Methoden, die das Objekt bereitstellt oder ergänzt das Objekt um eben diese Methoden? Wenn ich z.B. ein Objekt erstelle, das sagen wir mal ein TImage und ein TLabel enthält, dann sieht das z.B. so aus:

Delphi-Quellcode:

UNIT Bilder;
INTERFACE
USES
  Classes, ExtCtrls, StdCtrls, Graphics, Controls;

TYPE
  TBild = CLASS

    PRIVATE { Private-Deklarationen }
      Var
        fBild     : TImage;
        fTitel    : TLabel;
      Function  GetfBild                : TImage;
      Procedure SetfBild(Const Value    : TImage);
      Function  GetfTitel               : TLabel;
      Procedure SetfTitel(Const Value   : TLabel);

    PUBLIC  { Public-Deklarationen  }
      Constructor Create();
      Destructor  Destroy; override;
      Property Bild  : TImage read GetfBild  write SetfBild;
      Property Titel : TLabel read GetfTitel write SetfTitel;
  END;

IMPLEMENTATION
{ TBild }

Function TBild.GetfBild: TImage;
begin
  Result := fBild;
end;

Procedure TBild.SetfBild(Const Value: TImage);
begin
  fBild.Assign(Value);
end;

Function TBild.GetfTitel: TLabel;
begin
  Result := fTitel;
end;

Procedure TBild.SetfTitel(Const Value: TLabel);
begin
  fTitel.Assign(Value);
end;

Constructor TBild.Create;
begin
  inherited;

  fBild                                   := TImage.Create(nil);
  fBild.Visible                           := False;
  fBild.AutoSize                          := False;
  fBild.Stretch                           := True;
  fBild.Proportional                      := True;
  fBild.Center                            := True;

  fBild.Picture.Bitmap.Canvas.Brush.Style := bsClear;
  fBild.Picture.Bitmap.Canvas.Pen.Color   := clRed;
  fBild.Picture.Bitmap.Canvas.Pen.Style   := psSolid;
  fBild.Picture.Bitmap.Canvas.Pen.Width   := 5;

  fTitel                                  := TLabel.Create(nil);
  fTitel.AutoSize                         := False;
  fTitel.Alignment                        := taCenter;
  fTitel.Layout                           := tlCenter;
  fTitel.WordWrap                         := False;
  fTitel.Visible                          := False;
end;

Destructor TBild.Destroy;
begin
  If Assigned(fBild) Then
     fBild.Free;
  If Assigned(fTitel) Then
     fTitel.Free;

  inherited;
end;
end.

So, jetzt brauche ich eine Methode, die das Bild speichert. Also ergänze ich das Objekt um die benötigte Methode. Wäre in diesem Fall, da ich bereits ein TImage verwende, nicht notwendig, da TImage (z.B. in TBitmap oder TPicture) bereits mehrere Methoden zum Speichern bereitstellt.

Wieso muß ich da umständlich ermitteln, wo das Bild im Speicher liegt, wo es beginnt und wo es aufhört, wenn ich das Ganze doch sowieso in einer TObjectList verwalte?

Delphi-Quellcode:

...
USES
  Windows, Messages, ..., Bilder, Generics.Collections, ...;
...

  PRIVATE { Private-Deklarationen }
    Var
      BList : Generics.Collections.TObjectList<TBild>;

Wozu dann überhaupt die TObjectList? Die TObjectList weiß doch genau, wo ihre Objekte liegen, darum muß mich doch gar nicht mehr kümmern. Ich greife einfach über den Index auf das jeweilige Objekt zu:

Delphi-Quellcode:

Procedure TFormMain.SaveBitmapFromList(Const Id : Integer; Const Datei : String);
begin
  BList[Id].Bild.Picture.Bitmap.SaveToFile(Datei);
end;