Bitmap soll gelegentlich unsichtbar sein

[Popov]

sx2008, bei allem Verständnis, was machst du da? Was stellst du für Fragen? Bist du gerade von einer Party zurück? Wo siehst du zwischen der ursprünglichen Frage und deiner letzten Feststellung einen Zusammenhang? Sorry, aber was für sinnfreien Rückfragen stellst du denn eigentlich? Wenn du den Sinn nicht verstehst, dann halt dich raus. Dass die Frage ungewöhnlich ist, ist mir selbst klar, aber wozu die Rückfragen? Wenn ich denn Sinn nicht verstehe was einer macht, dann beleidige ich ihn nicht zuerst in dem ich frage welchen Sinn seine Arbeit hat, sondern dann halte ich mich raus. Entschuldige, aber das verstehe ich wirklich nicht, bzw. mir fehlt da das Verständniss. Ich verstehe, dass meine Frage vielleicht sonderbar ist, aber was fällt dir ein mich zu hinterfragen, bzw. muss ich dich um Erlaubnis fragen muss ob und welche Funktionen ich in eine Klasse einbauen darf? Was hat dich das zu interessieren? Entweder du hast eine Antwort oder nicht.

Also, und nur weil mir das dann inzwischen doch aufträgt, weil ich mich nun anscheinend rechtfertigen muss, das Ganze ist eine popelige mehrschichtige Grafik, also eine Art Grafik mit Ebenen. Etwas was fast jedes Programm oberhalb von MS Paint.exe beherrscht, zeichnen auf verschiedenen Ebenen. Also eine Grafik bestehend aus verschiedenen Folien, also Folie1, Folie2, Folie3, usw. Zeichnet man etwas auf Folie2, hat das keine Auswirkung auf das was sich auf den anderen Folien befindet. Jedes CAD Programm kann das, Photoshop kann das, und Tausend andere Programme können das auch. Ebenen. Ist dir somit der Sinn der Klasse jetzt klarer? Darf ich das?

Und weil jede Ebene eine Bitmap zur Darstellung enthällt, und die Klasse aus mehreren Schichten besteht, ergibt das zum Schluss eine Gesamtgrafik. Und was schon seit Urzeit bei CAD und Photoshop möglich ist, das ist das abschalten von Ebenen. Das mache ich auch. Ich schalte einige Bitmaps gelegentlich ab.

Nur kann man das verschieden angehen: entweder ich prüfe einen Flag an der Bitmap (bzw. einer Klasse, denn jede Ebene ist eine Klasse die eine Bitmap enthält) ob sie sichtbar ist oder oder nicht - was ich bisher gemacht habe - oder, und das war ein neuer Ansatz, die Bitmap erkennt selbst, dass sie angeschaltet ist und liefert nichts.

Ist damit die Frage beantwortet oder brauche ich noch weitere Rechtfertigung für meine Klasse?

[jaenicke]

Ich würde eine Methode DrawLayer in der Ebenenklasse machen, die die Ebene zeichnet. Oder eben nicht. Die kann dann auch gleich die Transparenz berücksichtigen, sprich mit AlphaBlend zeichnen, usw.

[Medium]

Volker Z. hat imho schon die OOP-ige Lösung gegeben. Mal in Quasicode:

Delphi-Quellcode:

type
  TLayeredDingsbums = class
  private
    FEmptyBitmap: TBitmap;
    FLayers: TBitmapList;
    FLayerVisibility: TBooleanList;
  public
    function GetLayer(aLayerIndex: Integer): TBitmap;
  end;

implementation

function TLayeredDingsbums.GetLayer(aLayerIndex: Integer): TBitmap;
begin
  if FLayerVisibility[aLayerIndex] then
    result := FLayers[aLayerIndex]
  else
  begin
    if Assigned(FEmptyBitmap) then FreeAndNil(FEmptyBitmap);
    FEmptyBitmap := TBitmap.Create;
    FEmptyBitmap.Assign(FLayers[aLayerIndex]); // Um die Properties des Layers zu bekommen - billiger geht's natürlich mit einer eigenen Methode, die nur de gebrauchten übernimmt und nicht gleich alle Pixeldaten mit kopiert
    PaintTransparent(FEmptyBitmap);
    result := FEmptyBitmap;
  end;
end;

Ich habe das FEmptyBitmap als Feld der Klasse gewählt, damit nicht der Caller immer wieder Kopien freigeben muss, sondern die Bezitzerklasse konsistent sowohl ihre Layer als auch das gerade aktuelle "Leerbild" unter seiner Freigabegewalt hat. Man kann das sicherlich noch mit mehr "fancy" machen, aber das wäre mein Q&D Ansatz, der für den Caller völlig transparent (haha) ist.
Eine erste Besserung wäre z.B. dass man statt einer TBitmapList eine eigene kleine Klasse macht, die ein Bitmap und ein Bool enthält, und von dieser dann nur eine Liste zu verwalten braucht. (Das würde ich in der Realität glaube ich deutlich bevorzugen.)

[Blup]

Wenn Rückfragen kommen, die scheinbar nichts mit der eigenen Fragestellung zu tun haben, sollte man erst einmal überprüfen, ob das Thema wirklich verständlich genug dargestellt wurde. Ich bin aus der urspünglichen Fragestellung auch nicht schlau geworden.

Gewünscht wird scheinbar eine eigene Grafikklasse, die mehrere Layer unterstützt und für jeden Layer (neben der durch den Layer darzustellenden Grafik) weitere Eigenschaften speichert, die bei der Darstellung zu berücksichtigen sind. Diese Grundgerüst kann eventuell noch mit einer Ableitung von TImage und TPicture überbaut werden, die genau diese Grafikklasse published als Property bereitstellt und so die direkte Bearbeitung im Objektinspektor erlaubt.
Das Grundgerüst für die Grafikklasse könnte dann in etwa so ausschaun:

Delphi-Quellcode:

uses
  Graphics;

type
  TGraphicLayerList = class(TCollection)
  end;

  TLayerGraphic = class(TGraphic)
    constructor Create(AOwner: TComponent); override;
  private
    FLayer: TGraphicLayerList;
  protected
    procedure Draw(ACanvas: TCanvas; const Rect: TRect); override;
    {...zumindest alle abstrakten Methoden überschreiben...}
    procedure SetLayer(AValue: TGraphicLayerList);
  published
    property Layer: TGraphicLayerList read FLayer write SetLayer;
  end;

  TGraphicLayer = class(TCollectionItem)
    constructor Create(Collection: TCollection); override;
  private
    FRect: TRect;
    FVisible: Boolean;
    FPicture: TPicture;
    procedure SetRect(AValue: TRect);
    procedure SetVisible(AValue: Boolean);
    procedure SetPicture(AValue: TPicture);
  published
    property Rect: TRect read FRect write SetRect;
    property Visible: Boolean read FVisible write SetVisible;
    property Picture: TPicture read FPicture write SetPicture;
  end;

implementation

constructor TLayerGraphic.Create(AOwner: TComponent);
begin
  inherited;
  FLayer := TGraphicLayerList.Create(TGraphicLayer);
  {...}
end;

procedure TLayerGraphic.SetLayer(AValue: TGraphicLayerList);
begin
  FLayer.Assign(AValue);
end;

[HHennig]

Schau dir mal die GR32-Library an und im Besonderen TImage32 und ggf. dessen Nachfahren, dort gibt es Layering und es ist m. E. sehr gut gelöst.
Klar ist die ganze Library von Grund auf anders aufgebaut als TBitmap und Konsorten, aber vielleicht kannst du ja einige Denkanstöße entnehmen. In den mitgelieferten Examples gibt es auch ein Beispiel zu den Layern, ebenso ist das Prinzip in der CHM-DFatei ausführlich erläutert.
Ein wenig Spitzeln wie andere das machen ist ja erlaubt

[Popov]

Ok, vielleicht klingt mein erstes Post etwas verwirrend, vermutlich aber nur, weil ich mir einige Szenarien schon im Kopf durchgespielt habe und weiß, dass sie nicht funktionieren. Während es im ersten Moment für den Leser durchaus noch als machbar klingt. Natürlich stellt sich dann die Frage wo das Problem ist?

Ich hab gerade mein Gedankenspiel in Code umgesetzt um es zu prüfen. Hier das Problem mit einer leeren Ersatz-Bitmap.

Zuerst eine Beispielklasse:

Delphi-Quellcode:

type
  TKlasseB = class
  private
    FBitmap: TBitmap;
    FEmptyBitmap: TBitmap;
    FBitmapEnabled: Boolean;
  protected
    function GetBitmap: TBitmap;
  public
    constructor Create;
    destructor Destroy; override;
    property Bitmap: TBitmap read GetBitmap write FBitmap;
    property BitmapEnabled: Boolean read FBitmapEnabled write FBitmapEnabled;
  end;

constructor TKlasseB.Create;
begin
  FBitmap := TBitmap.Create;
  FBitmapEnabled := True;
  FEmptyBitmap := TBitmap.Create;
end;

destructor TKlasseB.Destroy;
begin
  FBitmap.Free;
  FEmptyBitmap.Free;
end;

function TKlasseB.GetBitmap: TBitmap;
begin
  if FBitmapEnabled then
    Result := FBitmap
  else
  begin
    Result := FEmptyBitmap;
    Result.Assign(FBitmap);
    Result.Canvas.Brush.Style := bsSolid;
    Result.Canvas.Brush.Color := Result.TransparentColor;
    Result.Transparent := True;
  end;
end;

Jetzt der Test

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var
  Bmp: TBitmap;
begin
  with TKlasseB.Create do
  try
    Bitmap.Canvas.Brush.Color := clRed;
    Bitmap.Width := 100;
    Bitmap.Height := 50;
    Self.Canvas.Draw(0, 0, Bitmap);
    //Bis jetzt alles ok

    //Jetzt das Problem
    BitmapEnabled := False;
    //Man denkt sich nichts böses dabei, ist ja auch erlaubt
    Bmp := Bitmap;
    Bmp.Canvas.Ellipse(Bmp.Canvas.ClipRect);
    Self.Canvas.Draw(100, 100, Bmp);

    //Nun stimmt nichts nicht überein. Wo ist die Ellipse?
    BitmapEnabled := True;
    Self.Canvas.Draw(200, 200, Bitmap);
  finally Free end;
end;

Das Problem tritt nicht auf wenn man direkt mit der Bitmap der Klasse arbeitet. Vielleicht ist das Korinthenkacker, aber die Klasse ist in meinen Augen nicht wasserdicht. Man würde in dem Fall mit zwei verschiedenen Bitmaps arbeiten können.

[Namenloser]

Dann müsstest du dir eine eigene Klasse von TGraphic ableiten, die als Proxy für ein TBitmap dient.

[jaenicke]

Viel sinnvoller ist doch aber nur eine TBitmap zu nutzen pro Layer und den Layer selbst seinen Layer zeichnen zu lassen wie ich schon vorgeschlagen hatte. Dann ist das ganze sauber gekapselt, man kann die Layeroperationen auch gleich mit kapseln und das Problem mit mehreren Bitmaps gibt es auch nicht...