Rendu d'un contrôle Windows FormsRendering a Windows Forms Control

Le rendu fait référence au processus de création d’une représentation visuelle sur l’écran d’un utilisateur.Rendering refers to the process of creating a visual representation on a user's screen. Windows Forms utilise GDI (la nouvelle bibliothèque de graphiques Windows) pour le rendu.Windows Forms uses GDI (the new Windows graphics library) for rendering. Les classes managées qui fournissent l’accès à GDI se trouvent dans l’espace de noms System.Drawing et dans ses sous-espaces de noms.The managed classes that provide access to GDI are in the System.Drawing namespace and its subnamespaces.

Les éléments suivants sont impliqués dans le rendu de contrôle :The following elements are involved in control rendering:

  • La fonctionnalité de dessin fournie par la classe de base System.Windows.Forms.Control.The drawing functionality provided by the base class System.Windows.Forms.Control.

  • Éléments essentiels de la bibliothèque de graphiques GDI.The essential elements of the GDI graphics library.

  • Géométrie de la zone de dessin.The geometry of the drawing region.

  • Procédure de libération des ressources graphiques.The procedure for freeing graphics resources.

Fonctionnalités de dessin fournies par le contrôleDrawing Functionality Provided by Control

La classe de base Control fournit des fonctionnalités de dessin via son événement Paint.The base class Control provides drawing functionality through its Paint event. Un contrôle déclenche l’événement Paint chaque fois qu’il doit mettre à jour son affichage.A control raises the Paint event whenever it needs to update its display. Pour plus d’informations sur les événements dans le .NET Framework, consultez gestion et déclenchement d’événements.For more information about events in the .NET Framework, see Handling and Raising Events.

La classe de données d’événement pour l’événement Paint, PaintEventArgs, contient les données nécessaires pour dessiner un contrôle : un handle vers un objet Graphics et un objet rectangle qui représente la zone dans laquelle dessiner.The event data class for the Paint event, PaintEventArgs, holds the data needed for drawing a control — a handle to a graphics object and a rectangle object that represents the region to draw in. Ces objets sont affichés en gras dans le fragment de code suivant.These objects are shown in bold in the following code fragment.

Public Class PaintEventArgs  
   Inherits EventArgs  
   Implements IDisposable  
  
   Public ReadOnly Property ClipRectangle() As System.Drawing.Rectangle  
      ...  
   End Property  
  
   Public ReadOnly Property Graphics() As System.Drawing.Graphics  
      ...  
   End Property  
   ' Other properties and methods.  
   ...  
End Class  
public class PaintEventArgs : EventArgs, IDisposable {  
public System.Drawing.Rectangle ClipRectangle {get;}  
public System.Drawing.Graphics Graphics {get;}  
// Other properties and methods.  
...  
}  

Graphics est une classe managée qui encapsule les fonctionnalités de dessin, comme décrit dans la discussion sur GDI plus loin dans cette rubrique.Graphics is a managed class that encapsulates drawing functionality, as described in the discussion of GDI later in this topic. Le ClipRectangle est une instance de la structure Rectangle et définit la zone disponible dans laquelle un contrôle peut être dessiné.The ClipRectangle is an instance of the Rectangle structure and defines the available area in which a control can draw. Un développeur de contrôle peut calculer le ClipRectangle à l’aide de la propriété ClipRectangle d’un contrôle, comme décrit dans la section géométrie plus loin dans cette rubrique.A control developer can compute the ClipRectangle using the ClipRectangle property of a control, as described in the discussion of geometry later in this topic.

Un contrôle doit fournir une logique de rendu en substituant la méthode OnPaint qu’il hérite de Control.A control must provide rendering logic by overriding the OnPaint method that it inherits from Control. OnPaint obtient l’accès à un objet Graphics et un rectangle dans lequel dessiner via le Graphics et les propriétés ClipRectangle de l’instance PaintEventArgs qui lui est transmise.OnPaint gets access to a graphics object and a rectangle to draw in through the Graphics and the ClipRectangle properties of the PaintEventArgs instance passed to it.

Protected Overridable Sub OnPaint(pe As PaintEventArgs)  
protected virtual void OnPaint(PaintEventArgs pe);  

La méthode OnPaint de la classe de Control de base n’implémente pas de fonctionnalité de dessin, mais appelle simplement les délégués d’événements inscrits avec l’événement Paint.The OnPaint method of the base Control class does not implement any drawing functionality but merely invokes the event delegates that are registered with the Paint event. Lorsque vous substituez OnPaint, vous devez généralement appeler la méthode OnPaint de la classe de base afin que les délégués inscrits reçoivent l’événement Paint.When you override OnPaint, you should typically invoke the OnPaint method of the base class so that registered delegates receive the Paint event. Toutefois, les contrôles qui peignent leur surface entière ne doivent pas appeler la OnPaintde la classe de base, car cela introduit le scintillement.However, controls that paint their entire surface should not invoke the base class's OnPaint, as this introduces flicker. Pour obtenir un exemple de substitution de l’événement OnPaint, consultez la rubrique Comment : créer un contrôle Windows Forms qui affiche la progression.For an example of overriding the OnPaint event, see the How to: Create a Windows Forms Control That Shows Progress.

Notes

N’appelez pas OnPaint directement à partir de votre contrôle ; au lieu de cela, appelez la méthode Invalidate (héritée de Control) ou une autre méthode qui appelle Invalidate.Do not invoke OnPaint directly from your control; instead, invoke the Invalidate method (inherited from Control) or some other method that invokes Invalidate. La méthode Invalidate à son tour appelle OnPaint.The Invalidate method in turn invokes OnPaint. La méthode Invalidate est surchargée et, selon les arguments fournis à Invalidate e, un contrôle redessine une partie ou la totalité de sa zone d’écran.The Invalidate method is overloaded, and, depending on the arguments supplied to Invalidate e, a control redraws either some or all of its screen area.

La classe de Control de base définit une autre méthode qui est utile pour le dessin, la méthode OnPaintBackground.The base Control class defines another method that is useful for drawing — the OnPaintBackground method.

Protected Overridable Sub OnPaintBackground(pevent As PaintEventArgs)  
protected virtual void OnPaintBackground(PaintEventArgs pevent);  

OnPaintBackground peint l’arrière-plan (et par conséquent la forme) de la fenêtre et est assuré d’être rapide, tandis que OnPaint peint les détails et peut être plus lent, car les demandes de peinture individuelles sont combinées en un événement Paint qui couvre toutes les zones devant être redessinées.OnPaintBackground paints the background (and thereby the shape) of the window and is guaranteed to be fast, while OnPaint paints the details and might be slower because individual paint requests are combined into one Paint event that covers all areas that have to be redrawn. Vous pouvez appeler l' OnPaintBackground si, par exemple, vous souhaitez dessiner un arrière-plan de couleur de dégradé pour votre contrôle.You might want to invoke the OnPaintBackground if, for instance, you want to draw a gradient-colored background for your control.

Bien que OnPaintBackground ait une nomenclature de type événement et accepte le même argument que la méthode OnPaint, OnPaintBackground n’est pas une véritable méthode d’événement.While OnPaintBackground has an event-like nomenclature and takes the same argument as the OnPaint method, OnPaintBackground is not a true event method. Il n’y a aucun événement PaintBackground et OnPaintBackground n’appelle pas les délégués d’événement.There is no PaintBackground event and OnPaintBackground does not invoke event delegates. Lors de la substitution de la méthode OnPaintBackground, une classe dérivée n’est pas requise pour appeler la méthode OnPaintBackground de sa classe de base.When overriding the OnPaintBackground method, a derived class is not required to invoke the OnPaintBackground method of its base class.

Notions de base sur GDI+GDI+ Basics

La classe Graphics fournit des méthodes pour dessiner différentes formes, telles que des cercles, des triangles, des arcs et des ellipses, ainsi que des méthodes pour afficher du texte.The Graphics class provides methods for drawing various shapes such as circles, triangles, arcs, and ellipses, as well as methods for displaying text. L’espace de noms System.Drawing et ses sous-espaces de noms contiennent des classes qui encapsulent des éléments graphiques tels que des formes (cercles, rectangles, arcs et autres), des couleurs, des polices, des pinceaux, etc.The System.Drawing namespace and its subnamespaces contain classes that encapsulate graphics elements such as shapes (circles, rectangles, arcs, and others), colors, fonts, brushes, and so on. Pour plus d’informations sur GDI, consultez utilisation de classes graphiques managées.For more information about GDI, see Using Managed Graphics Classes. Les notions fondamentales de GDI sont également décrites dans la rubrique Comment : créer un contrôle de Windows Forms qui affiche la progression.The essentials of GDI are also described in the How to: Create a Windows Forms Control That Shows Progress.

Géométrie de la zone de dessinGeometry of the Drawing Region

La propriété ClientRectangle d’un contrôle spécifie la zone rectangulaire disponible pour le contrôle sur l’écran de l’utilisateur, tandis que la propriété ClipRectangle de PaintEventArgs spécifie la zone effectivement peinte.The ClientRectangle property of a control specifies the rectangular region available to the control on the user's screen, while the ClipRectangle property of PaintEventArgs specifies the area that is actually painted. (N’oubliez pas que la peinture est effectuée dans la méthode d’événement Paint qui prend une instance PaintEventArgs comme argument).(Remember that painting is done in the Paint event method that takes a PaintEventArgs instance as its argument). Un contrôle peut avoir besoin de peindre uniquement une partie de sa zone disponible, comme c’est le cas lorsqu’une petite section de l’affichage du contrôle change.A control might need to paint only a portion of its available area, as is the case when a small section of the control's display changes. Dans ce cas, un développeur de contrôle doit calculer le rectangle réel à dessiner et le passer à Invalidate.In those situations, a control developer must compute the actual rectangle to draw in and pass that to Invalidate. Les versions surchargées de Invalidate qui prennent un Rectangle ou Region comme argument utilisent cet argument pour générer la propriété ClipRectangle de PaintEventArgs.The overloaded versions of Invalidate that take a Rectangle or Region as an argument use that argument to generate the ClipRectangle property of PaintEventArgs.

Le fragment de code suivant montre comment le FlashTrackBar contrôle personnalisé calcule la zone rectangulaire dans laquelle dessiner.The following code fragment shows how the FlashTrackBar custom control computes the rectangular area to draw in. La variable client désigne la propriété ClipRectangle.The client variable denotes the ClipRectangle property. Pour obtenir un exemple complet, consultez Comment : créer un contrôle de Windows Forms qui affiche la progression.For a complete sample, see How to: Create a Windows Forms Control That Shows Progress.

Rectangle invalid = new Rectangle(
    client.X + min, 
    client.Y, 
    max - min, 
    client.Height);

Invalidate(invalid);
Dim invalid As Rectangle = New Rectangle( _
    client.X + lmin, _
    client.Y, _
    lmax - lmin, _
    client.Height)

Invalidate(invalid)

Libération des ressources graphiquesFreeing Graphics Resources

Les objets graphiques sont coûteux car ils utilisent des ressources système.Graphics objects are expensive because they use system resources. Ces objets incluent des instances de la classe System.Drawing.Graphics ainsi que des instances de System.Drawing.Brush, System.Drawing.Penet d’autres classes graphiques.Such objects include instances of the System.Drawing.Graphics class as well as instances of System.Drawing.Brush, System.Drawing.Pen, and other graphics classes. Il est important de créer une ressource Graphics uniquement lorsque vous en avez besoin et de la libérer dès que vous avez fini de l’utiliser.It is important that you create a graphics resource only when you need it and release it soon as you are finished using it. Si vous créez un type qui implémente l’interface IDisposable, appelez sa méthode Dispose lorsque vous en avez terminé pour libérer des ressources.If you create a type that implements the IDisposable interface, call its Dispose method when you are finished with it in order to free resources.

Le fragment de code suivant montre comment le FlashTrackBar contrôle personnalisé crée et libère une ressource Brush.The following code fragment shows how the FlashTrackBar custom control creates and releases a Brush resource. Pour obtenir le code source complet, consultez Comment : créer un contrôle de Windows Forms qui affiche la progression.For the complete source code, see How to: Create a Windows Forms Control That Shows Progress.

private Brush baseBackground = null;
Private baseBackground As Brush
base.OnPaint(e);
if (baseBackground == null) {
    if (showGradient) {
        baseBackground = new LinearGradientBrush(new Point(0, 0),
                                                 new Point(ClientSize.Width, 0),
                                                 StartColor,
                                                 EndColor);
    }
    else if (BackgroundImage != null) {
        baseBackground = new TextureBrush(BackgroundImage);
    }
    else {
        baseBackground = new SolidBrush(BackColor);
    }
}
MyBase.OnPaint(e)

If (baseBackground Is Nothing) Then

    If (myShowGradient) Then
        baseBackground = New LinearGradientBrush(New Point(0, 0), _
                                                 New Point(ClientSize.Width, 0), _
                                                 StartColor, _
                                                 EndColor)
    ElseIf (BackgroundImage IsNot Nothing) Then
        baseBackground = New TextureBrush(BackgroundImage)
    Else
        baseBackground = New SolidBrush(BackColor)
    End If

End If
protected override void OnResize(EventArgs e) {
    base.OnResize(e);
    if (baseBackground != null) {
        baseBackground.Dispose();
        baseBackground = null;
    }
}
Protected Overrides Sub OnResize(ByVal e As EventArgs)
    MyBase.OnResize(e)
    If (baseBackground IsNot Nothing) Then
        baseBackground.Dispose()
        baseBackground = Nothing
    End If
End Sub

Voir aussiSee also