Hallo DP'ler,

habe Dank oki es endlich geschafft, beim programmieren meiner ersten Komponente etwas weiter zu kommen.
Jetzt stehe ich aber vor dem nächsten Problem und hoffe das mir jemand einen Tipp geben kann.

Hier eine kurze Übersicht über die Komponente habe zur besseren Übersicht ca. 1300 Zeilen gelöscht.

zusammenfalten · markieren

Delphi-Quellcode:

Type
  // Forward
  TDateLine = class;
  TDateItems = class;

//******************************************************************************

  TControlDateItem = class(TGraphicControl)
  private
   FBackColor : TColor;
  protected
    procedure Paint; override;
  public
   constructor Create(AOwner: TComponent); override;
   destructor Destroy; override;
   procedure SetBackColor(Value : TColor);
  published
   property BackColor : TColor read FBackColor write SetBackColor;
 end;

 //******************************************************************************

  TDateItem = class(TCollectionItem)
  private
    FControlDateItem : TControlDateItem;
    FParent : TDateItems;
  protected
  public
    constructor Create(Collection: TCollection); override;
    destructor Destroy; override;
  published
    property ControlDateItem : TControlDateItem read FControlDateItem write FControlDateItem;
  end;

//******************************************************************************

TDateItems = class(TCollection)
  private
    FDateLine: TDateLine;
    function GetItem(Index: Integer): TDateItem;
    procedure SetItem(Index: Integer; Value: TDateItem);
  protected
    function GetOwner: TPersistent; override;
    procedure Update(Item: TDateItem); reintroduce;
  public
    constructor Create(DateLine: TDateLine);
    function Add : TDateItem;
    property Items[Index: Integer]: TDateItem read GetItem write SetItem; default;
  end;

//******************************************************************************

TDateLine = class(TCustomGrid)
  private
    FDateItems : TDateItems;
    FItem : TDateItem;
    procedure SetDateItems(const Value: TDateItems);
  protected
    procedure Paint; override;//04.11.06 Oki hatte recht :-)
  public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
    procedure SetItem(const Value: TDateItem);
  published
    property Items: TDateItems read FDateItems write SetDateItems;
end;

implementation


//******************************************************************************
//***** ControlDateItem ********************************************************
//******************************************************************************

constructor TControlDateItem.Create(AOwner: TComponent);
begin
    inherited Create(AOwner); { immer den geerbten Konstruktor aufrufen }
    FBackColor := clWhite;
end;

//------------------------------------------------------------------------------

procedure TControlDateItem.SetBackColor(Value : TColor);
begin
    if Value <> FBackColor then
     begin
       FBackColor := Value;
       Invalidate;
     end;
end;

//------------------------------------------------------------------------------

destructor TControlDateItem.Destroy;
begin
    inherited Destroy;
end;

//******************************************************************************
//****** DateLine **************************************************************
//******************************************************************************

constructor TDateLine.Create(AOwner: TComponent);
begin
    inherited Create(AOwner); { geerbten Konstruktor aufrufen  }
    FDateItems := TDateItems.Create(self);
end;


//------------------------------------------------------------------------------

destructor TDateLine.Destroy;
begin
  FItem.Free;
  inherited;
end;

//******************************************************************************
//***** DateItems **************************************************************
//******************************************************************************

constructor TDateItems.Create(DateLine: TDateLine);
begin
  inherited Create(TDateItem);
  FDateLine := DateLine;
end;

//------------------------------------------------------------------------------

//******************************************************************************
//***** DateItem ***************************************************************
//******************************************************************************

constructor TDateItem.Create(Collection: TCollection);
begin
  inherited Create(Collection);
  FParent := TDateItems(Collection);
  FControlDateItem := TControlDateItem.Create((Collection as TDateItems).FDateLine);
  // ohne Parent keine anzeige (Owner in create alleine reicht nicht)
  FControlDateItem.Parent := (Collection as TDateItems).FDateLine;

end;
//------------------------------------------------------------------------------

destructor TDateItem.Destroy; //05.11.06
begin
  FControlDateItem.Free;
  inherited Destroy;
end;

end.

Leider werden die propertys von TControlDateItem nicht im OI angezeigt, bzw. zur Entwurfszeit nicht im Formular mit abgespeichert. Deshalb wollte ich jetz die Propertys von TControlDateItem nach TDateItem verschieben. Allerdings weiß ich nicht, wie ich dann auf die Propertys von TDateItem in TControlDateItem zugreifen kann bzw. auf die Propertys von TDateLine.

Hoffe es gibt jemanden der mir bei diesem Problem weiterhelfen kann.
Genial wäre es natürlich, wenn es einen Weg geben würde, TControlDateItem so beizubehalten das man gegebenenfalls TControlDateItem durch ein anderes Objekt austauschen könnte. Ist allerdings nur so eine Idee.

Hier noch ein ScreenShot damit Ihr wisst um was es geht.

Moin uwewo,

um die property's des eingebetteten Objectes in deinen TDateItem published zu machen hast du zwei Möglichkeiten:

1. ein Wrapper-Object (TPersistance) schreiben, welches du im create von TDateItem instanziierst und als published-property deklarierst.

2. alle propertys des eingebetteten Objectes als published-propertys von TDateItem deklarieren und Änderungen mit Get und Set direkt an das eingebettete Object weiterreichen. Dann das eingebettete Object aber nicht published deklarieren (mach generell so wenig Sinn).

Den Code für einen Wrapper kennst du ja. Für die 2. Variante sieht das dann so aus:

zusammenfalten · markieren

Delphi-Quellcode:

//******************************************************************************

  TControlDateItem = class(TGraphicControl)
  private
   FBackColor : TColor;
  protected
    procedure Paint; override;
  public
   constructor Create(AOwner: TComponent); override;
   destructor Destroy; override;
   procedure SetBackColor(Value : TColor);
   property BackColor : TColor read FBackColor write SetBackColor;
end;

//******************************************************************************

  TDateItem = class(TCollectionItem)
  private
    FControlDateItem : TControlDateItem;
    FParent : TDateItems;
    function GetBackColor: TColor;
    procedure SetBackColor(const Value: TColor);
  protected
  public
    constructor Create(Collection: TCollection); override;
    destructor Destroy; override;
  published
    property ControlDateItem : TControlDateItem read FControlDateItem write FControlDateItem;
    property BackColor : TColor read GetBackColor write SetBackColor;
  end;


function TDateItem.GetBackColor: TColor;
begin
  IF Assigned(FControlDateItem) then Result := FControlDateItem.BackColor;
end;

procedure TDateItem.SetBackColor(const Value: TColor);
begin
  IF Assigned(FControlDateItem) then FControlDateItem.BackColor := Value;
end;

Da ich denke, dass es nie ein DateItem ohne Instanz eines ControlDateItem gibt hab ich mir das Merken der Eigenschaft in TDateItem gespaart. Wenn man es ganz sicher haben will legt man auch in TDateItem einen privaten Member TBackColor an und speichert dann dort zwischen. Das hat den Vorteil, dass auch wenn noch kein FControlDateItem existiert die eigenschaft zuweisen kann und bei einem späteren Create dies dann für FControlDateItem nach holt.


Bis die Tage

Gruß oki

Hallo oki,

dies würde bedeuten das ich eigentlich jede Property, in diesem Bsp. BackColor sowohl für TControlDateItem als auch TDateItem erstellen muß.

Also alles doppelt, ist dieser Aufwand wirklich nötig?

Danke für Deine Antwort.

Hi,

Zitat von uwewo:

Also alles doppelt, ist dieser Aufwand wirklich nötig?

Jo!

es ist hierbei sogar egal, ob du es wie im Bsp. oder über ein Wrapper machst. Der Aufwand ist fast identisch. Das tust Du mit deinem Titel doch auch.

die Frage ist hier die gleiche wie zum Anfang des Projektes: Vorteile einer VCL-Kompo als Item in einer Collection gegenüber herkömmlicher direkter Zeichenmethode. Ich bin immer noch der Meinung das sich das lohnt. außerdem hat dein Item nun auch nicht sooooo viele Propertys die man öffentlich machen muß. Da beide Objecte in einer Unit stehen könnte man natürlich etwas Aufwand spaaren und in den Set und Get Methoden direkt auf die privaten Member von TControlDateItem zugreifen. Das halte ich aber für einen schlechten programmierstil und fällt einem später garantiert auf die Füße. Also der Mehraufwand lohnt sich strategisch auf jeden Fall.

Gruß oki

Mir ist grad noch was eingefallen; wenn du Items zur Designzeit in diversen Collection-Kompos erstellst, dann kann man so einen Item-Editor öffnen. Mir ist grad entfallen wie das heißt. Sowas kann man auch machen. Glaub aber nicht, dass das weniger Aufwand ist.

Gruß oki

Zitat von oki:

Das tust Du mit deinem Titel doch auch.

Eben nicht, deswegen bin ich so verwundert.

Der Header wird eigentlich nur so in TDateLine bekannt gemacht und die Propertys direkt angesprochen.

markieren

Delphi-Quellcode:

TDateLine = class(TCustomGrid)
  private
    FHeader : THeader;
 published
   property Header : THeader read FHeader write FHeader;
end;

Zugriff auf die Propertys habe ich dann so

Dateline.Header."Propertys" Na wenn es keine ander Möglichkeit gibt

Trotzdem Danke

Hi uwewo,

Zitat von uwewo:

Zitat von oki:

Das tust Du mit deinem Titel doch auch.

Eben nicht, deswegen bin ich so verwundert.

Der Header wird eigentlich nur so in TDateLine bekannt gemacht und die Propertys direkt angesprochen.

und THeader ist vom Typ TPersistent womit sich halt ein prima Wrapper basteln läßt. Auf Deutsch, mit Nachkommen von TPersistent läßt sich sowas machen.
Das war das Ding mit meiner ersten Methode, die ich nicht weiter ausgeführt habe. Ich dachte halt da siehst du, dass das das Gleiche ist. (drei mal "das" hintereinander und scheint trotzdem Sinn zu machen boah cool )

Du kannst dir natürlich auch nen Wrapper dafür schreiben. Der sieht dann ganz genau so aus wie dein TSideBar oder THeader, heißt dann aber z.B. TControlProps als Nachkomme von TPersistent und ist eine published Eigenschaft von TDateItem mit Zugriff auf TControlDateItem. Es ist übriegens egal ob der Wrapper nun Eigenschaften der Kompo oder eines "eingebetteten" Objectes kapselt. Bei den Eigenschaften der Kompo ist es eher ein optischer Effekt (Plus), bei Objekten als Eigenschaften eine Notwendigkeit deren Eigenschaften sichtbar zu machen.

Gruß oki

Hallo,

es läßt mir einfach keine Ruhe, gibt es denn wirklich nicht die Möglichkeit TDateItem in TControlDateItem bekannt zu machen, so daß ich die propertys von TControlDateItem nach TDateItem
verschieben kann

Schreibe ein paar Kommentare in den Source, wie ich es mir vorstelle.

zusammenfalten · markieren

Delphi-Quellcode:

  TControlDateItem = class(TGraphicControl)
  private
  //Das hier neu
  FDateItem : TDateItem;
  protected
    procedure Paint; override;
  public
   constructor Create(AOwner: TComponent); override;
   destructor Destroy; override;
  published
   //Das hier neu
   property DateItem : TDateItem read FDateItem write FDateItem;
end;

//******************************************************************************

  TDateItem = class(TCollectionItem)
  private
    FControlDateItem : TControlDateItem;
    FParent : TDateItems;
    //stammt ursprünglich aus TControlDateItem
    FBackColor : TColor;
  protected
  public
    constructor Create(Collection: TCollection); override;
    destructor Destroy; override;
    //stammt ursprünglich aus TControlDateItem
    procedure SetBackColor(const Value: TColor);
  published
    property ControlDateItem : TControlDateItem read FControlDateItem write FControlDateItem;
   //stammt ursprünglich aus TControlDateItem
    property BackColor : TColor read FBackColor write SetBackColor;
  end;

implementation


//******************************************************************************
//***** ControlDateItem ********************************************************
//******************************************************************************

constructor TControlDateItem.Create(AOwner: TComponent);
begin
    inherited Create(AOwner); { immer den geerbten Konstruktor aufrufen } 
    //?????????????????????????????????????????????????????
    //Hier ist es unklar wie auf die propertys zugreifen
    //?????????????????????????????????????????????????????
    FDateItem := //?????????????
    FDateItem.BackColor := clWhite;
end;

Hat dazu denn wirklich keiner eine Idee?

Uwe

Hallo uwewo,

warum nicht Constructor von TControlDateItem überladen?

markieren

Delphi-Quellcode:

constructor Create(AOwner: TComponent; Source : TDateItem); overload;
...
constructor Create(AOwner: TComponent; Source : TDateItem);
begin
  inherited Create(aOwner);
  FDateItem := TDateItem(Source);
...

Gruss

Hi Alter Mann,

und was bringt das für die Anzeige im OI des TDateItem?
TDateItem ist ja das Collection-Item, welches die Eigenschaften des eingebetteten TControlDateItem veröffentlichen soll.


Gruß oki