Placer des événements dans un composant

Un événement de composant Delphi, est une propriété de type TMethod (procédure d’une
classe d’objet). Cette propriété permet de sauvegarder une référence sur la procédure à
appeler lorsque l’événement se déclenche.

Imaginons par exemple une classe TColorButton dans laquelle on voudrait placer un
événement OnColorChange, qui donnerait en paramètre la nouvelle Couleur :

- La première chose à faire consiste à définir un prototype de method, qui permettra entre
autres d’informer Delphi sur le code à créer lorsque l’utilisateur doubleCliquera sur
l’événement dans l’inspecteur d’objet :

type
TColorChangeEvent = procedure (Color : integer) of object ;

- Il faut ensuite placer une variable de type TColorChangeEvent dans la classe. Cette dans
cette variable que l’on stockera la référence sur la method à appeler lors du déclenchement
de l’événement.

TcolorButton = class(TButton)
Private

FOnColorChange : TColorChangeEvent ;

- Il faut ensuite utiliser une propriété pour affecter la variable FOnColorChange. C’est le
fait de la placer dans la partie published de la classe qui la rend visible depuis l’inspecteur
d’object, et c’est le fait que son type soit de la forme procedure…of object (= TMethod)
qui place la propriété dans la page events de l’inspecteur d’object.

Published

Property OnColorChange : TColorChangeEvent
Read FOnColorChange
Write FOnColorChange;
End ;

On obtient alors :

L’utilisateur place un TColorButton sur sa forme

L’utilisateur doubleClique dans l’inspecteur d’object

- Maintenant que le mécanisme d’appel est en place, il reste à déclencher l’événement.

Cela revient en fait à appeler la methode référencée dans FOnColorChange au moment
opportun dans le composant ColorButton.

Par ex avec la ligne suivante :

If assigned(FOnColorChange) then FOnColorChange(Color) ;

Il faut toutefois distinguer deux cas d’appels. Les événements liés à Windows (ex :
OnMouseMove = wm_mousemove) et les événements logiciels (ex : OnStateChange pour
une datasource).

Dans notre cas (OnColorChange), on a un événement ‘logiciel’. Généralement, ces
événements sont associés à un changement d’état d’un objet, et déclenchés lors de
l’affectation d’une propriété. Par exemple, dans le setColor du colorButton.

Le code complet est alors le suivant :

type
TColorChangeEvent = procedure (Color : integer) of object ;

TcolorButton = class(TButton)
Private

FOnColorChange : TColorChangeEvent ;
FColor : integer ;
Function getColor : integer ;
Procedure setColor(newValue : integer) ;
Protected
procedure ColorChange(NewValue : integer); virtual;
Published
Property Color : integer
read getColor
write setColor ;
Property OnColorChange : TColorChangeEvent
read FOnColorChange
write FOnColorChange ;
end ;

implementation

function TcolorButton.getColor : integer ;
begin
result := Fcolor ;
end ;

procedure TcolorButton.setColor(newValue : integer) ;
begin
if newValue <> Fcolor then
begin
Fcolor := newValue ;
//-- on appelle la fonction des
//-- composants dérivés et on lance
//-- l'événnement
ColorChange(FColor);
If assigned(FOnColorChange) then
FOnColorChange(Fcolor) ;
End ;
End ;

procedure TcolorButton.ColorChange(newValue : integer) ;
begin
//-- do nothing
End ;
End ;

Remarque : la procedure ColorChange déclarée virtual permet
d'utiliser l'événement dans les composants dérivés sans avoir à monopoliser
le OnColorChange, utile pour le design.

Dans le cas d’un événement Windows, le mécanisme est le même, il faut juste appeler la
méthode référencée dans la variable de la classe chaque fois que windows envoie le message
qui nous intéresse.

Si par exemple on crée une classe ligne et que l’on veut lui ajouter un événement
OnMouseMove, on obtient :

type

TLigne = class(TWinControl)
Private
FOnMouseMove : TMouseMoveEvent ;
Public
procedure MouseMove(var Message: TMessage):
message WM_MOUSEMOVE;
Published
Property OnMouseMove : TMouseMoveEvent
read FOnMouseMove
write FOnMouseMove;
end ;

implementation

procedure TLigne.MouseMove(var Message: TMessage);
begin
if assigned(FonMouseMove) then
FonMouseMove(….) :
inherited;
end;

Remarque : c’est la directive message qui permet de dire à Delphi de lancer la procedure à
chaque message windows WM_MOUSEMOVE.

Le mot clef inherited dans la procedure mouseMove permet de propager l'événement.