Déclaration

Une fois le squelette généré, il faut ajouter les propriété et les événement au composant.

a) Evénements existants

Les plus évidents sont les évènements habituels ‘OnClick’ et ‘OnDblClick’ qui sont déclenchés lorsqu’un clic, simple ou double, est effectué sur une date.

Traditionnellement, un composant peut aussi gérer le glisser-déplacer (‘OnDragOver’ et ‘OnDragDrop’) et la souris (‘OnMouseDown’, ‘OnMouseMove’ et ‘OnMouseUp’).

Ces événements existent dans la partie protégée de la classe ‘Tcontrol’. Pour les utiliser, il suffit de changer leur droit d’accès en les redéclarant partiellement dans la partie publiée :

Delphi et Kylix 194 L. Jourdan { Published declarations } property OnClick; property OnDblClick; property OnDragOver; property OnDragDrop; property OnMouseDown; property OnMouseMove; property OnMouseUp; b) Evénement ajoutés

On fournit habituellement le moyen de prévenir tout changement au sein du composant par l’événement ‘OnChange’. Ajoutez aussi un autre événement ‘OnVisibleChange’ déclenché lorsque le mois visualisé dans le calendrier change. Ainsi, il faut déclarer 2 autres variables d’instances pour ces deux événements :

private

{ Private declarations } FOnChange: TNotifyEvent; FOnVisibleChange: TNotifyEvent;

Ainsi que les 2 événements eux-mêmes :

property OnChange: TNotifyEvent read FOnChange write FOnChange;

property OnVisibleChange: TNotifyEvent read FOnVisibleChange write FOnVisibleChange;

Pour traiter les appels aux méthodes références par les variables représentant les événements, nous allons définir deux méthodes protégées pour que les classes dérivées (si un jour elles existent) puissant aussi y accéder :

protected

{ Protected declarations } procedure Changed; procedure VisibleChange ;

Il reste maintenant à declarer un nouveau constructeur qui initialise, entre autres, les variables d’instances à ‘nil’ :

public

{ Public declarations }

constructor Create(AOwner: TComponent); override;

c) Propriétés existantes

En ce qui concerne les propriétés, le principe est le même : nous pouvons constater que certaines propriétés sont héritées de ‘Tcontrol’, en particulier ‘Name’ et ‘Tag’ publiées pour tout composant (définies au niveau de ‘TComponent’) ainsi que ‘Cursor’, ‘Hint’ et les coordonnées ‘Top’, ‘Left’, ‘Height’ et ‘Width’ publiées pour les composant visuels.

Il existe beaucoup d’autres propriétés protégés suivantes : ‘Color’, ‘DragCursor’, ‘DragMode’, ‘Font’, ‘ParentColor’ et ‘ParentFont’.

Pour réutiliser ces propriétés déjà existantes, il suffit de redéclarer partiellement au niveau d’accès supérieur voulu, en l’occurrence : publié. published { Published declarations } property Color; property DragCursor; property DragMode; property Font; property ParentColor; property ParentFont; d) Propriétés ajoutées

Puisque nous créons un calendrier, nous avons la propriété ‘Date’. Nous nous donnons aussi la possibilité de changer le mois afficher au moyen des touches [PgUp] et [PgDn] ainsi que les flèches visualisées. Nous devons donc définir les propriétés ‘VisibleMonth’ et ‘VisibleYear’.

En ce qui concerne la présentation du calendrier, nous pouvons afficher avec une autre fonte le jour courant (TodayFont) et le jour sélectionné (SelectedDayFont).

Enfin, pour rendre ce comp osant indépendant de la lange de l’utilisateur, nous ajoutons une propriété ‘Labels’ qui est un ensemble de chaînes de caractères représentant les mois de l’année suivis des jours de la semaine.

Pour pouvoir implémenter ces différentes propriétés, nous devons déclarer des variables d’instances pour conserver leur valeur, ainsi que des méthodes permettant l’accès à ces valeurs :

FDate: TDateTime; FVisibleMonth: Word; FVisibleYear: Word; FDateMin: TDateTime; FDateMax: TDateTime; FSelectedDayFont: TFont; FTodayFont: TFont; FLabels: TStrings;

function GetDate: string;

procedure SetDate(ADate: string);

procedure SetVisibleMonth(AMonth: Word); procedure SetVisibleYear(AYear: Word); function GetDateMin: string;

procedure SetDateMin(ADate: string); function GetDateMax: string;

procedure SetDateMax(ADate: string);

procedure SetSelectedDayFont(AFont: TFont); procedure SetTodayFont(AFont: TFont); procedure SetLabels(Value: TStrings); protected { Protected declarations } LastVisibleMonthDay: Word; FirstVisibleDate, LastVisibleDate: TDateTime; procedure Changed;

procedure VisibleChange(Sender: TObject);

Etant donnée que nous avons des événements signalant des changements, nous devons définir des méthodes en écriture pour les propriétés afin d’appeler les méthodes ‘Changed’ et ‘VisibleChanged’ définies précédemment :

published

property Date: string read GetDate write SetDate;

property VisibleMonth: Word read FVisibleMonth write SetVisibleMonth; property VisibleYear: Word read FVisibleYear write SetVisibleYear; property DateMin: string read GetDateMin write SetDateMin; property DateMax: string read GetDateMax write SetDateMax;

property SelectedDayFont: TFont read FSelectedDayFont write SetSelectedDayFont; property TodayFont: TFont read FTodayFont write SetTodayFont;

property Labels: TStrings read FLabels write SetLabels;

Puisque certaines variables font reference à des objets (‘FselectedDayFont’ et ‘FtodayFont’) leur initialisation nécessite de créer ces objets par leur constructeur ‘Create’ dans le constructeur de notre composant. Nous devons ensuite les détruire dans notre destructeur :

public

{ Public declarations }

constructor Create(AOwner: TComponent); override; destructor Destroy; override;

3. Implémentation

Il nous faut maintenant implémenter toutes ces méthodes. Commençons par le constructeur et le destructeur :

constructor TDLICalendar.Create(AOwner: TComponent); var

Delphi et Kylix 196 L. Jourdan

inherited Create(AOwner); FOnChange := nil;

FOnVisibleChange := nil; FDate := SysUtils.Date;

DecodeDate(FDate, FVisibleYear, FVisibleMonth, jour); FDateMin := 0; FDateMax := 0; FSelectedDayFont := TFont.Create; FSelectedDayFont.OnChange := VisibleChange; FTodayFont := TFont.Create; FTodayFont.OnChange := VisibleChange; FLabels := TStringList.Create; TStringList(FLabels).OnChange := VisibleChange; FLabels.Add('Janvier'); FLabels.Add('Février'); FLabels.Add('Mars'); FLabels.Add('Avril'); FLabels.Add('Mai'); FLabels.Add('Juin'); FLabels.Add('Juillet'); FLabels.Add('Août'); FLabels.Add('Septembre'); FLabels.Add('Octobre'); FLabels.Add('Novembre'); FLabels.Add('Décembre'); FLabels.Add('Di'); FLabels.Add('Lu'); FLabels.Add('Ma'); FLabels.Add('Me'); FLabels.Add('Je'); FLabels.Add('Ve'); FLabels.Add('Sa'); UpdateVars; end; destructor TDLICalendar.Destroy; begin FSelectedDayFont.Free; FTodayFont.Free; FLabels.Free; inherited Destroy; end;

L’ajout de la réaction à l’événement ‘OnChange’ des fontes et de la liste permet de mettre à jour l’affichage du calendrier lorsque celle-ci sont modifiées. Nous sommes cependant obligés d’ajouter une autre méthode (VisibleChange) qui soit du bon type pour une réaction ie avec un seul paramètre ‘Sender’.

Cette méthode doit être déclarée dans la partie protégée et implémentée en appelant notre méthode ‘VisibleChanged’ :

procedure TDLICalendar.VisibleChange(Sender: TObject); begin

VisibleChanged; end;

Les méthodes de gestion de date sont très simple : unction TDLICalendar.GetDate: string;

begin

end;

procedure TDLICalendar.SetDate(ADate: string); var

date: TDateTime; begin

date := StrToDate(ADate); if (FDate = date) or

((date < FDateMin) or ((FDateMax > 0) and (date > FDateMax))) then Exit; FDate := date;

Changed; end;

function TDLICalendar.GetDateMin: string; begin

if FDateMin = 0 then Result := ''

else Result := DateToStr(FDateMin); end;

procedure TDLICalendar.SetDateMin(ADate: string); var

date: TDateTime; begin

if ADate = '' then date := 0

else date := StrToDate(ADate); if (FDateMin = date) or

((FDateMax > 0) and (date > FDateMax)) then Exit; FDateMin := date;

Changed; end;

function TDLICalendar.GetDateMax: string; begin

if FDateMax = 0 then Result := ''

else Result := DateToStr(FDateMax); end;

procedure TDLICalendar.SetDateMax(ADate: string); var

date: TDateTime; begin

if ADate = '' then date := 0

else date := StrToDate(ADate); if (FDateMax = date) or

((date > 0) and (date < FDateMin)) then Exit; FDateMax := date;

Changed; end;

Delphi et Kylix 198 L. Jourdan En ce qui concerne ‘SetVisibleMonth’ et ‘SetVisibleYear’, il faut appeler la méthode ‘VisibleChanged’ et non pas ‘Changed’ :

procedure TDLICalendar.SetVisibleMonth(AMonth: Word); begin

if (FVisibleMonth = AMonth) or

(AMonth < 1) or (12 < AMonth) then Exit; FVisibleMonth := AMonth;

UpdateVars; VisibleChanged; end;

Les méthodes ‘SetSelectedDayFont’, ‘SetTodayFont’ et ‘SetLabels’ ne font que changer la valeur de la variable, leur événement ‘OnChange’ permettant de réafficher le composant :

procedure TDLICalendar.SetSelectedDayFont(AFont: TFont); begin

FSelectedDayFont.Assign(AFont); end;

procedure TDLICalendar.SetTodayFont(AFont: TFont); begin

FTodayFont.Assign(AFont); end;

procedure TDLICalendar.SetLabels(Value: TStrings); begin

FLabels.Assign(Value); end;

Il reste à définir les méthodes ‘Changed’ et ‘VisibleChanged’ :

procedure TDLICalendar.Changed; begin

if Assigned(FOnChange) then FOnChange(Self); VisibleChanged;

end;

procedure TDLICalendar.VisibleChange(Sender: TObject); begin

VisibleChanged; end;

procedure TDLICalendar.VisibleChanged; begin

if Assigned(FOnVisibleChange) then FOnVisibleChange(Self); Refresh;

end;

Refresh permet de réafficher le composant aussitôt.