Bitmap soll gelegentlich unsichtbar sein

[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...

[Popov]

Du hast Recht, und im Grunde bin ich mit dem Punkt auch nicht glücklich. Nur ist für mich eine Klasse auch immer ein abgeschlossenes Gebilde, somit sollte eine zweite Klasse nicht etwas deuten was die erste versäumt hat.

Das Problem kommt davon, weil ich etwas, was im Grunde in eine Klasse gehört, aus Bequemlichkeit auf zwei Klassen verteilt habe. Und nun habe ich ein Kommunikationsproblem.

Ich denke ich lasse es so wie es bisher ist - in der einen Klasse ist ein Flag ohne weiter Eigenschaften. Die zweite Klasse richtet sich dann nach dem Flag ob sie den Layer beachten soll.

Das Ganze wird sonst zu fehleranfällig.

[Sir Rufo]

Versuch es mal hiermit.

Ich habe jetzt nur das Zeichnen verhindert, aber das könnte genauso gut auch umgeleitet werden auf ein leeres Bitmap mit der gleichen Größe

Delphi-Quellcode:

  TLayerBitmap = class( TBitmap )
  private
    FCanDraw : Boolean;
  protected
    procedure Draw( ACanvas : TCanvas; const Rect : TRect ); override;
    procedure DrawTransparent(ACanvas: TCanvas; const Rect: TRect; Opacity: Byte); override;
  public
    property CanDraw : Boolean read FCanDraw write FCanDraw;
  end;

{ TLayerBitmap }

procedure TLayerBitmap.Draw( ACanvas : TCanvas; const Rect : TRect );
begin
  if not FCanDraw then
    Exit;
  inherited;
end;

procedure TLayerBitmap.DrawTransparent(ACanvas: TCanvas; const Rect: TRect; Opacity: Byte);
begin
  if not FCanDraw then
    Exit;
  inherited;
end;

Und das funktioniert deswegen, weil bei TCanvas.Draw irgendwann einmal das hier aufgerufen wird

Delphi-Quellcode:

procedure TCanvas.Draw(X, Y: Integer; Graphic: TGraphic);
begin
  if (Graphic <> nil) and not Graphic.Empty then
  begin
    ...
    Graphic.Draw(Self, Rect(X, Y, X + Graphic.Width, Y + Graphic.Height));
    ...
  end;
end;

Und wenn man das sieht, dann weiß man auch, dass die Umleitung auf ein leeres Bitmap den gleichen Effekt hat, als wenn man das Zeichnen abbricht

Darum sollte meine Bitmap-Ableitung genau das erfüllen, was dir da vorschwebt.

[Popov]

@SR

Der letzte Tipp ist für sich genommen ok, gute Idee, das Problem liegt aber im Detail. Vielleicht kann man das Problem lösen (bzw. vermutlich, denn im Grunde kann man alles lösen), aber die Bitmap muss eine TBitmap sein (also keine abgeleitete). Das liegt daran, dass andere Teile des Programms, bzw. andere Klassen eine TBitmap erwarten. Ich müßte also alles andere anpassen, und dafür ist das Programm inzwischen zu groß geworden.

Ich lasse vorerst die alte Lösung. Sie ist nicht schön, aber funktioniert.

[Sir Rufo]

Wieso, die Klasse erfüllt genau das, was du gefordert hast, auch in dem von dir beschriebenen Kontext

Delphi-Quellcode:

type
  TKlasseB = class
  private
    FBitmap: TLayerBitmap;
  protected
    function GetBitmap: TBitmap;
    procedure SetBitmap( const Value : TBitmap );
    function GetBitmapEnabled : Boolean;
    procedure SetBitmapEnabled( const Value : Boolean );
  public
    constructor Create;
    destructor Destroy; override;
    property Bitmap: TBitmap read GetBitmap write SetBitmap;
    property BitmapEnabled: Boolean read GetBitmapEnabled write SetBitmapEnabled;
  end;

constructor TKlasseB.Create;
begin
  inherited;
  FBitmap := TLayerBitmap.Create;
end;

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

function TKlasseB.GetBitmap: TBitmap;
begin
  Result := FBitmap;
end;

procedure TKlasseB.SetBitmap( const Value : TBitmap );
begin
  FBitmap.Assign( Value );
end;

function TKlasseB.GetBitmapEnabled : Boolean;
begin
  Result := FBitmap.CanDraw;
end;

procedure TKlasseB.SetBitmapEnabled( const Value : Boolean );
begin
  FBitmap.CanDraw := Value;
end;

[Popov]

Jetzt nicht falsch verstehen, ich hab hier paar Ideen erfahren an die ich selbst nicht gedacht habe. Ich werde an dem Thema weiter arbeiten, aber aktuell drängt ein Termin und auch wenn auch die aktuelle Lösung mir persönlich nicht gefällt, sie funktioniert.

Ich weiß im Grunde auch nicht so richtig was ich wollte. Ich hab da das Beispiel unter Dormant gesehen und das brachte mich auf die Idee statt eine Bitmap nicht zu zeichnen, dafür keine Bitmap zu liefern.

Was ich nicht will ist Bitmaps hin und her kopieren. Das würde klappen, aber das wäre mit Kanonen auf Spatzen schießen. Irgendwie schwebte mir da ein leeres Nichts. Aber das mit Canvas ist schon eine gute Idee. Ich werde das mal testen. Vielleicht ist auch Dormant die Lösung, nur blicke ich nicht nicht 100% durch was im Hintergrund da passiert.