Layer Management auf OOP Basis

[formosa]

Hallo zusammen,

für meinen Image Resizer suche ich im Moment eine OOP basierende Lösung zum Verwalten von Layern. Bisher hatte ich nur ganz einfache Klassen selber geschrieben, bin aber dadurch auf die Vorteile der OOP gestossen.

Es sollen zwei Layertypen in unbekannter Anzahl verwaltet werden:

- Typ 1. Layer enthält nur ein Bitmap mit X und Y Offset
- Typ 2. Layer enthält Text, und daher sollen auch zusäztliche Informationen wie Font, Style, Size ect. verwaltet werden.

Ich möchte das unbedingt in OOP machen. Habt Ihr evtl. einen Lösungsansatz?

Vielen Dank an Euch,

Chris

[CK_CK]

Was weißt du denn genau beim Thema OOP nicht?

Ich würde die 1. Klasse ungefähr so aufbauen:

Delphi-Quellcode:

TBildLayer = class()
private
  fBitmap: TBitmap;  //Hier ist das Bitmap
  fOffsX: Integer;
  fOffsY: Integer;

  procedure setOffsX(AValue: Integer);  //Änderungen im Bitmap speichern...
  procedure setOffsY(AValue: Integer);
public
  property OffsX: Integer read fOffsX write setOffsX;
  property OffsY: Integer read fOffsY write setOffsY;
end;

2. Klasse:

Delphi-Quellcode:

TBildLayer = class()
private
  fBitmap: TBitmap;  //Hier ist das Bitmap
  fText: String;  //Der Text
  fFont: TFont;   //Der Font dazu ;)

  procedure setText(AValue: String);  //Änderungen im Bitmap speichern...
  procedure setFont(AValue: TFont);
public
  property Text: String read fText write setText;
  property Font: TFont read fFont write setFont;
end;

Zusätzlich müsstest du natürlich noch die passenden Prozeduren zum Zeichnen, etc. einbauen. Wenn es eine Komponente werden soll, müsstest du von TGraphicControl ableiten...

Chris

[Dax]

Das geht aber schöner und OOPiger :)

Delphi-Quellcode:

TAbstractLayer = class
  private
    fX, fY, fWidth, fHeight: Integer;
  public
    constructor Create(x, y, width, height: Integer);

    property X: Integer read fX write fX;
    property Y: Integer read fY write fY;
    property Width: Integer read fWidth write fWidth;
    property Height: Integer read fHeight write fHeight;

    procedure DrawTo(bitmap: TBitmap); virtual; abstract;
  end;

  TBitmapLayer = class(TAbstractLayer)
  private
    fBitmap: TBitmap;
  public
    constructor Create(bitmap: TBitmap);

    property Bitmap: TBitmap read fBitmap write fBitmap;

    procedure DrawTo(bitmap: TBitmap); override;
  end;

  TTextLayer = class(TAbstractLayer)
  private
    fText: string;
  public
    constructor Create(text: string);

    property Text: string read fText write fText;

    procedure DrawTo(bitmap: TBitmap); override;
  end;

[formosa]

Danke euch beiden. Ja so ungefähr hab ich mir das auch vorgestellt, wollte aber die ganzen Layers etwa wie folgt ansprechen

Delphi-Quellcode:

if MyLayers.Layer [idx].Type = BitmapLayer then
begin
  .... // mach ich was damit.
end
else
begin
  .... // mach ich halt was anderes damit.
end;

Grundsäztlich würde ich sagen das ich die variablen wie Offset, Text ect. in zwei verschiedenen Arrays speichern kann. Wie könnte ich denn jetzt eine Klasse gestalten damit ich von aussen beispielsweise in einem BitmapLayer mit keine Eigenschaft Text habe also zb.

Delphi-Quellcode:

if MyLayers.Layer [idx].Type = BitmapLayer then
begin
  MyLayers.Layer [idx].Text := 'Neuer Text'; // Es sollte aber keine Text Eigenschaft haben
end
else
begin
    MyLayers.Layer [idx].Text := 'Neuer Text'; // Hier jedoch schon
end;

Das ist mein eigentliches Hauptproblem.

danke

Chris

[Namenloser]

Dafür gibt's sogenannte Typecasts:

Delphi-Quellcode:

if MyLayers.Layer[idx] is TBitmapLayer then
  TBitmapLayer(MyLayers.Layer[idx]).TuWasMitDemBitmap;
else if MyLayers.Layer[idx] is TTextLayer then
  TTextLayer(MyLayers.Layer[idx]).Text := 'Neuer Text';