Utilisation d'une classe de baseRésolu

Question

Salut à tous,

J'ai une petite question à vous soumettre  :  J'ai fais un composant basé sur ce principe

 TCustomCollectionItem = class(TCollectionItem)
  private { properties }
    fTime:Single;
   fDoubleTime:Single;
  published { properties }
    Property Time:Single Read fTime Write fTime;
    Property DoubleTime:Single Read fDoubleTime Write fDoubleTime;
  end;

   TA=Class(TCustomCollectionItem )
   Private
      fPenColor:TColor;
  published
      Property PenColor:TColor Read fPenColor Write fPenColor;
   End;

   TB=Class(TCustomCollectionItem )
   Private
      fGrid:TPicture;
  published 
      Property Grid:TColor Read fGrid Write fGrid;
   End;

   TC=Class(TCustomCollectionItem )
   Private
      fLabel:TLabel;
  published 
      Property Label:TLabel Read fLabel Write fLabel;
   End;

   TFinal=class(TComponent)
   Private
     fA:TA;
     fB:TB;
     fC:TC;
   Published
     Property  A:TA Read fA Write fA;
     Property B:TB Read fB Write fB;
     Property C:TC Read fC Write fC;
   End;

  Actuellement j'utilise ce composant ainsi

     Final.A.Time:=15;
     Final.B.Time:=30;
     Final.C.Time:=45;

 Mais je trouve ca moche . Je me demandais s'il y avait pas un moyen de faire une boucle, un truc du genre :
Final.TCustomCollectionItem(Index).Time:=15*(Index+1);. Si quelqu'un a une idée (Même si je dois retoucher pas mal de chose), je suis prenneur.

Merci .

f0xi · Accepted Answer

type
TItemType = (itBase, itA, itB, itC);

TCustomCollectionItem = class(TCollectionItem)
private
    fItemType   : TItemType;
    fTime       : Single;
    fDoubleTime : Single;
protected
    function GetDisplayName : string; override;
published
    property ItemType   : TItemType read fItemType;
    Property Time       : Single    read fTime       write fTime;
    Property DoubleTime : Single    read fDoubleTime write fDoubleTime;
public
    constructor Create(Collection : TCollection); override;
    procedure Assign(Source : TPersistent); override;
end;

TA=Class(TCustomCollectionItem)
private
    fPenColor: TColor;
protected
    function GetDisplayName : string; override;
published
    property PenColor: TColor Read fPenColor Write fPenColor;
public
    constructor Create(Collection : TCollection); override;
    procedure Assign(Source : TPersistent); override;
end;

TB=Class(TCustomCollectionItem)
private
    fGrid: TPicture;
protected
    function GetDisplayName : string; override;
published
    Property Grid: TPicture Read fGrid Write fGrid;
public
    constructor Create(Collection : TCollection); override;
    procedure Assign(Source : TPersistent); override;
end;

TC=Class(TCustomCollectionItem)
private
    fLabel: TLabel;
protected
    function GetDisplayName : string; override;
published
    property _Label: TLabel Read fLabel Write fLabel;
public
    constructor Create(Collection : TCollection); override;
    procedure Assign(Source : TPersistent); override;
end;

TFinal=class(TComponent)
private
    fABC : array[0..2] of TCustomCollectionItem;
    function GetAsTA(const index: integer): TA;
    function GetAsTB(const index: integer): TB;
    function GetAsTC(const index: integer): TC;
    function GetItem(index: integer): TCustomCollectionItem;
    procedure SetAsTA(const Index: Integer; const Value: TA);
    procedure SetAsTB(const Index: Integer; const Value: TB);
    procedure SetAsTC(const Index: Integer; const Value: TC);
    procedure SetItem(index: integer; const Value: TCustomCollectionItem);
public
    procedure SetAllTime(const TmA, TmB, TmC: single);
    procedure SetAllSameTime(const TmABC: single);
    procedure SetAllDoubleTime(const DblTmA, DblTmB, DblTmC: single);
    procedure SetAllSameDoubleTime(const DblTmABC: single);
published
    property Items[index: integer]: TCustomCollectionItem read GetItem write SetItem;
    Property A: TA index 0 read GetAsTA write SetAsTA;
    Property B: TB index 1 read GetAsTB write SetAsTB;
    Property C: TC index 2 read GetAsTC write SetAsTC;
end;

{ TFinal }

function TFinal.GetAsTA(const index: integer): TA;
begin
result := TA(fABC[index]);
end;

function TFinal.GetAsTB(const index: integer): TB;
begin
result := TB(fABC[index]);
end;

function TFinal.GetAsTC(const index: integer): TC;
begin
result := TC(fABC[index]);
end;

function TFinal.GetItem(index: integer): TCustomCollectionItem;
begin
result := fABC[Index];
end;

procedure TFinal.SetAllDoubleTime(const DblTmA, DblTmB, DblTmC: single);
begin
if Assigned(fABC[0]) then fABC[0].DoubleTime := DblTmA;
if Assigned(fABC[1]) then fABC[1].DoubleTime := DblTmB;
if Assigned(fABC[2]) then fABC[2].DoubleTime := DblTmC;
end;

procedure TFinal.SetAllSameDoubleTime(const DblTmABC: single);
begin
if Assigned(fABC[0]) then fABC[0].DoubleTime := DblTmABC;
if Assigned(fABC[1]) then fABC[1].DoubleTime := DblTmABC;
if Assigned(fABC[2]) then fABC[2].DoubleTime := DblTmABC;
end;

procedure TFinal.SetAllSameTime(const TmABC: single);
begin
if Assigned(fABC[0]) then fABC[0].Time := TmABC;
if Assigned(fABC[1]) then fABC[1].Time := TmABC;
if Assigned(fABC[2]) then fABC[2].Time := TmABC;
end;

procedure TFinal.SetAllTime(const TmA, TmB, TmC: single);
begin
if Assigned(fABC[0]) then fABC[0].Time := TmA;
if Assigned(fABC[1]) then fABC[1].Time := TmB;
if Assigned(fABC[2]) then fABC[2].Time := TmC;
end;

procedure TFinal.SetAsTA(const Index: Integer; const Value: TA);
begin
fABC[index] := Value;
end;

procedure TFinal.SetAsTB(const Index: Integer; const Value: TB);
begin
fABC[index] := Value;
end;

procedure TFinal.SetAsTC(const Index: Integer; const Value: TC);
begin
fABC[index] := Value;
end;

procedure TFinal.SetItem(index: integer; const Value: TCustomCollectionItem);
begin
fABC[index] := Value;
end;

{ TCustomCollectionItem }

procedure TCustomCollectionItem.Assign(Source: TPersistent);
begin
if (source is TCustomCollectionItem) then
    with TCustomCollectionItem(Source) do
    begin
      Self.fTime       := fTime;
      Self.fDoubleTime := fDoubleTime;
      Self.fItemType   := fItemType;
    end
else
    inherited Assign(source);
end;

constructor TCustomCollectionItem.Create(Collection: TCollection);
begin
inherited Create(Collection);
fTime       := 0;
fDoubleTime := 0;
fItemType   := itBase;
end;

function TCustomCollectionItem.GetDisplayName: string;
begin
result := '<'+IntToStr(Self.Index)+'>';
end;

{ TA }

procedure TA.Assign(Source: TPersistent);
begin
if (source is TA) then
begin
    fPenColor := TA(source).fPenColor;
    inherited assign(TCustomCollectionItem(Source));
end
else
    inherited Assign(source);
end;

constructor TA.Create(Collection: TCollection);
begin
inherited Create(Collection);
fPenColor := clBlack;
fItemType := itA;
end;

function TA.GetDisplayName: string;
begin
result := inherited GetDisplayName+' type A';
end;

{ TB }

procedure TB.Assign(Source: TPersistent);
begin
if (source is TB) then
begin
    fGrid := TB(source).fGrid;
    inherited assign(TCustomCollectionItem(Source));
end
else
    inherited Assign(source);
end;

constructor TB.Create(Collection: TCollection);
begin
inherited Create(Collection);
fGrid := nil;
fItemType := itB;
end;

function TB.GetDisplayName: string;
begin
result := inherited GetDisplayName+' type B';
end;

{ TC }

procedure TC.Assign(Source: TPersistent);
begin
if (source is TC) then
begin
    fLabel := TC(source).fLabel;
    inherited Assign(TCustomCollectionItem(Source));
end
else
    inherited Assign(source);
end;

constructor TC.Create(Collection: TCollection);
begin
inherited Create(Collection);
fLabel := nil;
fItemType := itC;
end;

function TC.GetDisplayName: string;
begin
result := inherited GetDisplayName+' type C';
end;

<hr size="2" width="100%" />

Guillemouze · Answer

const

  ID_A = 0;

  ID_B = 1;

  ID_C = 2;

type
TFinal=class(TComponent)
   Private
    fItems: array[ID_A..ID_C] of 
TCustomCollectionItem ;
    function GetItem(Index: integer): TCustomCollectionItem; // Result := fItems[Index];
    procedure SetItem(Index: integer; const Value: TCustomCollectionItem ); // fItems[Index] := Value
   Public
     Property Item[Index: integer]: TCustomCollectionItem Read GetItem Write SetItem;
   Published
     Property  A: TCustomCollectionItem index ID_A Read GetItem Write SetItem;
     Property  B: TCustomCollectionItem index ID_B Read GetItem Write SetItem;
     Property  C: TCustomCollectionItem index ID_C Read GetItem Write SetItem;

   End;

Final.Item[ID_A].Time := 15;

Francky23012301 · Answer

Merci à vous deux .

@Guillemouze : J'ai pensé à ta méthode mais en fait elle ne répond pas tout à fait à ma problématique . En effet il faut que A soit déclaré comme un TA et non un TCustomCollectionItem (Idem pour B et C). En fait je cherche à utiliser dans un premier uniquement les propriétés de A, B et C  relatives à TCustomCollectionItem. Puis apres (mais c'est la seconde étape et elle a lieu dans une autre procédure ) utilisér les propriétés spécifiques à A ou à B ou à  C. 

@f0xi : ca répond à ma demande. Ceci dit j'ai une question : Ai je besoin de définir le create dans TCustomCollectionItem dans la mesure ou dans TA un create est définit (Idem pour TB et TC) et qu'il ne s'agit pas d'un vrai héritage dans ce cas (enfin je me comprend).

En tout cas encore merci

f0xi · Answer

moi je me demande surtout pourquoi tu as utilisé TCollectionItem alors que tu n'utilise pas de TCollection, et que tu n'ai pas penser a utiliser TPersistent a la place puisque placé dans un TComponent...

<hr size="2" width="100%" />

Francky23012301 · Answer

@f0xi : A mais si si, j'utilise TCollection  : je te rassure . 

En fait je l'avais souligné au tout début de ma question : il s'agit juste du principe.  Ca n'a rien de confidentiel, seulement le composant fait 1500 lignes : j'ai préféré vous épargner une séance de spéléologie  (surtout qu'il y a des implications de collection) et rentrer dans le vif du sujet. Maintenant effectivement présenté comme ca, je peux comprendre que cela peut paratre stupide

Utilisation d'une classe de base

5 réponses

Votre réponse

Discussions similaires