Bitmap soll gelegentlich unsichtbar sein

[Popov]

Ich hab eine Klasse die eine Bitmap Eigenschaft hat. Unter gewissen Bedingungen soll allerdings nichts ausgegeben werden. Sozusagen eine leere durchsichtige Bitmap. Auf der anderen Seite aber sollen die Eigenschaften bleiben, wie Breit, Höhe, Farbtiefe, usw. Und es muss ein TBitmap sein, also keine eigene abgeänderte Klasse. Es ist aber die Eigenschaft einer anderen Klasse. An der Stelle kann manipuliert werden.

Das hört sich nun leichter an als es dann tatsächlich ist. Vielleicht denke ich aber einfach auch nur zu kompliziert.

Da es eine Eigenschaft ist, kann man eigentlich einiges manipulieren. Zum Beispiel eine leere Ersatzbitmap mit kopierten Eigenschaften liefern, nur eben durchsichtig. Ausgabe falsche Bitmap, Eingabe in die richtige. Das würde die Aufgabe erfüllen, aber die Objektadresse würde nicht stimmen. Könnte zu Problemen führen wenn einer die nutzen würde.

Mit der Originalbitmap arbeiten, die vorher sichern und durchsichtig machen. Würde gehen, aber das abzufangen, ist ein gewisser Aufwand. Man müsste permanent zwischen Backup und Original hin und her kopieren.

Auch habe ich mit Canvas experimentiert, d. h. Bitmap bleibt, nur die Canvas wird geswitcht.

Das Beste ist bisher die zweite Idee, ist aber mit größeren Anpassungen an der Klasse verbunden.

Beim Blättern in der Hilfe habe ich dann Dormant entdeckt, ich verstehe es aber nicht so recht. Theoretisch genau was ich suche, zumindest nach dem Beispiel zu urteilen. Die Eigenschaften bleiben, nur wird nichts ausgegeben. Ändert man etwas, wird sie wieder sichtbar.

Wie gesagt, eigentlich was ich brauche, nur verstehe ich nicht was da im Hintergrund abgeht. Die OH habe ich zwar gelesen, sagt mir aber auch nicht viel.

Das wäre auch eine Möglichkeit, vorausgesetzt es macht tatsächlich was ich will.

Ober es gibt andere Ideen an die ich nicht gedacht habe.

[sx2008]

Du hast zwar viel über unsichtbare Bitmaps und Properties geschrieben aber kein Wort darüber verloren wozu das gut sein soll.
Und "Klasse" ist ebenfalls sehr abstrakt.
Willst du ein eigenes "Control" erstellen dann schreib' das auch so hin.
Es ist immer das gleiche Problem mit euch Programmierern:
Unpräzise Beschreibungen weil alle Details wegabstrahiert wurden bei gleichzeitig völlig verengtem Blick auf eine bestimmte Lösung.

Mach doch mal 2 Schritte zurück und fang mit der User Story an.

[Popov]

Weil eine andere Klasse auf diese Klasse mit der Bitmap zugreift. Ich hab zwei Möglichkeiten: ich setzte in der Klasse mit der Bitmap ein Boolean als Flag und die andere Klasse ignoriert bei False die Bitmap, was übrigens zurzeit wunderbar funktioniert, oder ich frage mich wieso eine andere Klasse einen Boolean erst auswerten muss, das ist doch OOP, warum liefert die Klasse mit der Bitmap im Falle von False nicht einfach eine leere Bitmap.

Es ist einfach nur eine Idee. Wozu steigt man auf einen Berg? Weil er da ist.

[Volker Z.]

Hallo,

ich habe jetzt die Fragestellung ein paar mal durchgelesen (werde aber nicht wirklich schlau daraus).

Du hast also eine Klasse, die Dir ein Bitmap kapselt und einen gewissen (irgendwie definierten) inneren Zustand hat.

Was hält Dich denn davon ab, in Abhängigkeit des "inneren Zustands Deiner Klasse", ein entsprechendes Bitmap im Getter auszuliefern - also nur dann eine Kopie des Original auszuliefern, wenn der Zustand erfüllt ist, ansonsten eine Kopie von irgendwas (leeres transparentes Bitmap o. ä.)?

Oder verstehe ich da was falsch?

Gruß

[Popov]

Zitat:

Zitat von Volker Z. (Beitrag 1244816)

werde aber nicht wirklich schlau daraus

Verstehe ich. Es ist eigentlich auch etwas ungewöhnlich eine leere Bitmap zu zeichnen.

Ich erkläre das mal vereinfacht - fast jede Komponente hat die Eigenschaft Visible. Ist sie True, wird sie angezeigt, ist sie False, nicht. Im Grunde will ich das auch für eine Bitmap.

Natürlich kann ich auch prüfen was unter Visible steht und die Bitmap ignorieren, muss dann aber eine Abfrage machen. Ich kann das aber auch der Bitmap überlassen. Ist sie False, soll sie nichts liefern, trotzdem aber ihre Eigenschaften behalten, wie Breite, Höhe, usw.

Wieso das mit der Kopie meiner Meinung nach nicht klappt, erkläre ich morgen.

[sx2008]

Zitat:

Zitat von Popov (Beitrag 1244817)

Ich erkläre das mal vereinfacht - fast jede Komponente hat die Eigenschaft Visible. Ist sie True, wird sie angezeigt, ist sie False, nicht. Im Grunde will ich das auch für eine Bitmap.

Du bist mächtig auf dem Holzweg und findest nicht mehr zurück.
Ein

Delphi-Quellcode:

TBitmap

ist eine Repräsentation von Bildpunkten im Speicher.
Zum Anzeigen wird entweder ein

Delphi-Quellcode:

TImage

oder eine

Delphi-Quellcode:

TPaintBox

benützt.
TImage und TPaintbox sind Controls (visuelle Steuerelemente).
Alles was kein Control ist hat prinzipiell keinen direkten Einfluss auf das was auf dem Bildschirm zu sehen ist.

Komm doch endlich mal auf den Punkt um was es geht.
Soll es ein Spiel werden mit mehreren Bitmaps die sich überlagern?
Benötigst du Sprites?

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