Création d’un contrôle Winform avec Delphi

Formation création d’un contrôle Winform avec Delphi 8 .NET, tutoriel & guide de travaux pratiques en pdf.

Ajout de la propriété AiguilleSec

La propriété AiguilleSec va définir si l’aiguille des secondes est affichée ou non. La définition d’une nouvelle propriété est identique à la méthode utilisée dans la VCL. Il faut ajouter une variable privée contenant la valeur de la propriété et définir les méthodes éventuelles de lecture et écriture de la propriété.
Pour ceci il faut ajoutez dans la définition du composant les ligne suivantes :
Sélectionnez
private
{ Private Declarations } FAiguilleSec:Boolean;
Procedure SetAiguilleSec(Value:Boolean);
public
constructor Create;
published
[Category(‘Appearance’),
Description(‘Affiche l »aiguille des secondes.’),
DefaultValue(true)]
Property AiguilleSec:Boolean Read FAiguilleSec Write SetAiguilleSec; end;
Notez ici la définition des attributs de la propriété permettant de définir la catégorie d’affichage ainsi que le texte d’aide associé dans l’inspecteur d’objet.
Dans le constructeur du composant, ajouter la valeur initiale de la propriété :
Sélectionnez
constructor THorloge.Create;
begin
inherited Create;
//
// Required for Windows Form Designer support
//
InitializeComponent;
//
// TODO: Add any constructor code after InitializeComponent call
//
FAiguilleSec := True;
end;
Et pour terminer, définir le code de la méthode d’écriture de la propriété, l’appel d’invalidate va demander au contrôle de se redessiner.
Sélectionnez
procedure THorloge.SetAiguilleSec(Value: Boolean); begin
FAiguilleSec:=Value;
Invalidate;
end;

Ajout du code de dessin

Le dessin devant être effectué toutes les secondes, nous allons ajouter un Timer au contrôle afin d’obtenir un événement régulier. Le dessin en lui-même sera assuré par la surcharge de la méthode OnPaint du contrôle.
La définition de la classe devient donc :
Sélectionnez
THorloge = class(System.Windows.Forms.UserControl)
//….
strict protected
/// <summary>
/// Clean up any resources being used.
/// </summary>
procedure Dispose(Disposing: Boolean); override; procedure OnPaint(e:PaintEventArgs); Override;
private
{ Private Declarations } T:Timer; FAiguilleSec:Boolean;
Procedure SetAiguilleSec(Value:Boolean);
Procedure Tempo(myObject:System.Object; myEventArgs:System.EventArgs );
public
constructor Create;
published
[Category(‘Appearance’),
Description(‘Affiche l »aiguille des secondes.’),
DefaultValue(true)]
Property AiguilleSec:Boolean Read FAiguilleSec Write SetAiguilleSec; end;
Comme d’habitude le composant enfant sera créé dans le constructeur de l’objet.
Sélectionnez
constructor THorloge.Create;
begin
inherited Create;
//
// Required for Windows Form Designer support
//
InitializeComponent;
//
// TODO: Add any constructor code after InitializeComponent call
//
FAiguilleSec := True;
SetStyle(ControlStyles.DoubleBuffer Or ControlStyles.UserPaint Or ControlStyles.AllPaintingInWmPaint, true);
T:=Timer.Create;
Include(T.Tick,Tempo); T.Interval := 1000; T.Start;
end;
Notez ici l’ajout d’un gestionnaire d’événement ( Tempo dans notre exemple ) à la liste des gestionnaire associés à T.Tick. Cet ajout est réalisé à l’aide de la procédure Include, ce point est différent de la surcharge habituelle d’un événement d’un contrôle VCL.
Notez aussi la modification du style du contrôle afin de définir un dessin personnalisé et un double-buffer pour éviter le scintillement lors du tracé.
Le code de la procédure Tempo ne fera qu’invalider la zone d’affichage du composant :
Sélectionnez
procedure THorloge.Tempo(myObject: TObject;
myEventArgs: System.EventArgs);
begin
Invalidate;
end;
L’événement OnPaint se chargera du dessin du composant :
Sélectionnez
procedure THorloge.OnPaint(e: PaintEventArgs); Var BlackPen :Pen;
Rect :Rectangle;
d :DateTime; Pinceau :SolidBrush; drawFont :System.Drawing.Font; n,z,u,x0,y0,x1,y1,x2,y2,x3,y3:Single; aigPoints : Array[0..3]Of PointF;
begin
BlackPen := Pen.Create(Color.Black, 1);
Rect := Rectangle.Create( 2, 2, 118, 118);
e.Graphics.DrawEllipse(blackPen, rect);
d := DateTime.Now;
//———————–
// Aiguille des Secondes (si propriété AiguilleSec à true) if AiguilleSec Then
Begin
n := d.Second*200/60; z := n/100*3.14159;
u := (n+50)/100*3.14159;
x0 := Math.Sin(z)*50;
y0 := -Math.Cos(z)*50;
x1 := -Math.Sin(z)*10;
y1 := Math.Cos(z)*10;
x2 := Math.Sin(u)*2;
y2 := -Math.Cos(u)*2;
x3 := -Math.Sin(u)*2;
y3 := Math.Cos(u)*2;
Pinceau:=SolidBrush.Create(Color.Red);
aigPoints[0].X := x1+60;
aigPoints[0].Y := y1+60;
aigPoints[1].X := x2+60;
aigPoints[1].Y := y2+60;
aigPoints[2].X := x0+60;
aigPoints[2].Y := y0+60;
aigPoints[3].X := x3+60;
aigPoints[3].Y := y3+60;
e.Graphics.FillPolygon(Pinceau, aigPoints); e.Graphics.DrawPolygon(blackPen, aigPoints); Pinceau.Dispose();
End;
//———————–
// Aiguille des Minutes
n := d.Minute*200/60;
z := n/100*3.14159;
u := (n+50)/100*3.14159;
x0 := Math.Sin(z)*50;
y0 := -Math.Cos(z)*50;
x1 := -Math.Sin(z)*10;
y1 := Math.Cos(z)*10;
x2 := Math.Sin(u)*4;
y2 := -Math.Cos(u)*4;
x3 := -Math.Sin(u)*4;
y3 := Math.Cos(u)*4;
Pinceau:=SolidBrush.Create(Color.Lime);
aigPoints[0].X := x1+60;
aigPoints[0].Y := y1+60;
aigPoints[1].X := x2+60;
aigPoints[1].Y := y2+60;
aigPoints[2].X := x0+60;
aigPoints[2].Y := y0+60;
aigPoints[3].X := x3+60;
aigPoints[3].Y := y3+60;
e.Graphics.FillPolygon(Pinceau , aigPoints); e.Graphics.DrawPolygon(blackPen, aigPoints); Pinceau.Dispose();
//———————–
// Aiguille des Heures
n := d.Hour*200/12 + d.Minute*200/60/12;
z := n/100*3.14159;
u := (n+50)/100*3.14159;
x0 := Math.Sin(z)*35;
y0 := -Math.Cos(z)*35;
x1 := -Math.Sin(z)*10;
y1 := Math.Cos(z)*10;
x2 := Math.Sin(u)*4;
y2 := -Math.Cos(u)*4;
x3 := -Math.Sin(u)*4;
y3 := Math.Cos(u)*4;
Pinceau:=SolidBrush.Create(Color.Yellow);
aigPoints[0].X := x1+60;
aigPoints[0].Y := y1+60;
aigPoints[1].X := x2+60;
aigPoints[1].Y := y2+60;
aigPoints[2].X := x0+60;
aigPoints[2].Y := y0+60;
aigPoints[3].X := x3+60;
aigPoints[3].Y := y3+60;
e.Graphics.FillPolygon(Pinceau , aigPoints); e.Graphics.DrawPolygon(blackPen, aigPoints); Pinceau.Dispose();
//———————–
// Chiffres
drawFont := System.Drawing.Font.Create(‘Arial’, 8); Pinceau := SolidBrush.Create(Color.Black);
e.Graphics.DrawString(’12’, drawFont, Pinceau, 55, 6); e.Graphics.DrawString( ‘6’, drawFont, Pinceau, 58, 101); e.Graphics.DrawString( ‘3’, drawFont, Pinceau, 105, 53); e.Graphics.DrawString( ‘9’, drawFont, Pinceau, 8, 53); //———————–
drawFont.Dispose();
Pinceau.Dispose();
blackPen.Dispose();
inherited;
End;

Lire sur cLicours.com :  Cours Delphi méthodes de lecture et d'écriture d'un élément

Surcharge de la taille par défaut

Afin que la taille du composant soit correcte ( 121 x 121 ) lors de sa création, il faut redéfinir la taille par défaut du composant par surcharge de la propriété taille :
Sélectionnez
THorloge = class(System.Windows.Forms.UserControl)
{$REGION ‘Designer Managed Code’}
//…
strict protected
/// <summary>
/// Clean up any resources being used.
/// </summary>
procedure Dispose(Disposing: Boolean); override; procedure OnPaint(e:PaintEventArgs); Override;
private
{ Private Declarations } T:Timer; FAiguilleSec:Boolean; Function GetSize:Size;
Procedure SetAiguilleSec(Value:Boolean);
Procedure Tempo(myObject:System.Object; myEventArgs:System.EventArgs );
public
constructor Create;
published
Property Size Read GetSize;
[Category(‘Appearance’),
Description(‘Affiche l »aiguille des secondes.’),
DefaultValue(true)]
Property AiguilleSec:Boolean Read FAiguilleSec Write SetAiguilleSec; end;

Cours gratuitTélécharger le cours complet

Télécharger aussi :

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée.