Créer un contrôle personnalisé simple

Cet article explique comment créer un contrôle Windows Forms personnalisé. Le contrôle simple développé dans cet article affiche le Text du contrôle à gauche, au centre ou à droite du contrôle. L’alignement du texte peut être modifié. Ce contrôle ne déclenche pas ou ne gère pas les événements.

Dans cet article, vous apprendrez comment :

• Ajoutez une propriété et un champ pour gérer le paramètre d’alignement horizontal du texte.
• Utilisez OnTextChanged pour invalider le contrôle.
• Fournissez du code dans la méthode OnPaint pour dessiner du texte sur l’aire du contrôle.

Ajouter un contrôle personnalisé

La première étape consiste à ajouter un contrôle personnalisé à votre projet.

1. Dans Visual Studio, recherchez la fenêtre Explorateur de solutions . Cliquez avec le bouton droit sur le projet et choisissez Ajouter>un nouvel élément.

   

2. Recherchez le contrôle personnalisé et sélectionnez-le.

3. Définissez le nom de fichier sur FirstControl et sélectionnez Ajouter.

4. Si le mode Création du contrôle est visible, basculez vers la vue de code. Appuyez sur F7 ou sélectionnez le lien basculer vers l'affichage du code.

   Conseil / Astuce

   Vous pouvez également cliquer avec le bouton droit sur le fichier dans la fenêtre Explorateur de solutions , puis sélectionner Afficher le code.

Vous devez maintenant examiner le code source du contrôle personnalisé, qui ressemble à l’extrait de code suivant :

public partial class FirstControl : Control
{
    public FirstControl()
    {
        InitializeComponent();
    }

    protected override void OnPaint(PaintEventArgs pe)
    {
        base.OnPaint(pe);
    }
}

Public Class FirstControl

    Protected Overrides Sub OnPaint(ByVal e As System.Windows.Forms.PaintEventArgs)
        MyBase.OnPaint(e)

        'Add your custom paint code here
    End Sub

End Class

Ajouter une propriété

Créez une propriété sur le contrôle nommé TextAlignment. Cette propriété ajuste l’emplacement où le texte est peint sur le contrôle. Avec la FirstControl classe, procédez comme suit :

1. Ajoutez un champ nommé _textAlignment du type HorizontalAlignment.

   private HorizontalAlignment _textAlignment = HorizontalAlignment.Left;
   

   Private _textAlignment As HorizontalAlignment = HorizontalAlignment.Left
   

2. Encapsulez le champ dans une propriété nommée TextAlignment. Lorsque vous définissez la propriété, appelez la méthode Invalidate pour forcer le contrôle à se repeindre.

   public HorizontalAlignment TextAlignment
   {
       get => _textAlignment;
       set
       {
           _textAlignment = value;
           Invalidate();
       }
   }
   

   Public Property TextAlignment As HorizontalAlignment
       Get
           Return _textAlignment
       End Get
   
       Set(value As HorizontalAlignment)
           _textAlignment = value
           Invalidate()
       End Set
   End Property
   

3. Ajoutez les attributs suivants à la propriété pour l’intégrer à la fenêtre Propriétés dans Visual Studio.

   • Category— Catégorie appliquée à la propriété.

   • Description— Description de la propriété.

   • DefaultValue— Valeur par défaut pour la propriété.

     La valeur par défaut permet à la propriété d’être réinitialisée par le concepteur. Elle permet également de déterminer quand la propriété doit être sérialisée dans le code-behind, car les valeurs par défaut ne sont pas sérialisées.

   [System.ComponentModel.Category("Alignment"),
   System.ComponentModel.Description("Specifies the alignment of text."),
   System.ComponentModel.DefaultValue(HorizontalAlignment.Left)]
   public HorizontalAlignment TextAlignment
   

   <System.ComponentModel.Category("Alignment"),
   System.ComponentModel.Description("Specifies the alignment of text."),
   System.ComponentModel.DefaultValue(HorizontalAlignment.Left)>
   Public Property TextAlignment As HorizontalAlignment
   

Gérer le texte modifié

La TextAlignment propriété appelle Invalidate de sorte que le contrôle se repeint lui-même. Cela garantit que l’alignement correct est instantanément utilisé avec le Text rendu du contrôle. Toutefois, si la Text propriété change, rien n’est mis à jour, car Text n’appelle Invalidatepas . Toutefois, la propriété appelle la OnTextChanged méthode, que vous pouvez remplacer pour appeler Invalidate et forcer le contrôle à se repeindre.

Avec la FirstControl classe, procédez comme suit :

1. Remplacez la méthode OnTextChanged.
2. Appelez base.OnTextChanged pour que l’événement TextChanged soit déclenché, comme prévu par les utilisateurs du contrôle.
3. Appelez la méthode pour forcer la Invalidate peinture.

Votre code doit ressembler à l’extrait de code suivant :

protected override void OnTextChanged(EventArgs e)
{
    base.OnTextChanged(e);
    Invalidate();
}

Protected Overrides Sub OnTextChanged(e As EventArgs)
    MyBase.OnTextChanged(e)
    Invalidate()
End Sub

Peindre le contrôle

La dernière partie du contrôle personnalisé est la peinture. Avec la FirstControl classe, procédez comme suit :

1. Recherchez la OnPaint méthode générée par le modèle. S’il est manquant, remplacez-le par la classe de base.

2. Créer une variable StringFormat nommée style.

   StringFormat style = new();
   

   Dim style As New StringFormat
   

   Le System.Drawing.StringFormat type encapsule les informations de disposition de texte et fournit l’accès à l’alignement.

3. En fonction de TextAlignment, définissez la propriété style.Alignment sur la valeur appropriée.

   style.Alignment = TextAlignment switch
   {
       // Map the HorizontalAlignment enum to the StringAlignment enum
       HorizontalAlignment.Left => StringAlignment.Near,
       HorizontalAlignment.Right => StringAlignment.Far,
       HorizontalAlignment.Center => StringAlignment.Center,
       
       // Default to Near alignment
       _ => StringAlignment.Near
   };
   

   'Map the HorizontalAlignment enum to the StringAlignment enum
   Select Case TextAlignment
       Case HorizontalAlignment.Left
           style.Alignment = StringAlignment.Near
       Case HorizontalAlignment.Right
           style.Alignment = StringAlignment.Far
       Case HorizontalAlignment.Center
           style.Alignment = StringAlignment.Center
   End Select
   

4. Dessinez la Text propriété avec Graphics.DrawString.

   // Create the brush and automatically dispose it.
   using SolidBrush foreBrush = new(ForeColor);
   
   // Call the DrawString method to write text.
   // Text, Font, and ClientRectangle are inherited properties.
   pe.Graphics.DrawString(Text, Font, foreBrush, ClientRectangle, style);
   

   'Create the brush and automatically dispose it.
   Using foreBrush As New SolidBrush(ForeColor)
       'Call the DrawString method to write text.
       'Text, Font, and ClientRectangle are inherited properties.
       e.Graphics.DrawString(Text, Font, foreBrush, ClientRectangle, style)
   End Using
   

   Important

   La Graphics.DrawString méthode utilise une Brush pour la couleur du texte. Brushes doit être supprimé après utilisation.

   La Graphics.DrawString méthode utilise du texte, une police, une couleur et des options de mise en forme pour dessiner une chaîne.

5. Appelez base.OnPaint pour vous assurer que l’événement Paint est déclenché.

   base.OnPaint(pe);
   

   MyBase.OnPaint(e)
   

6. Enregistrez le fichier de code et compilez le projet. Une fois le projet compilé, Visual Studio ajoute le contrôle personnalisé à la fenêtre Boîte à outils lorsque vous ouvrez le Concepteur visuel.

Votre code doit ressembler à l’extrait de code suivant :

public partial class FirstControl : Control
{
    private HorizontalAlignment _textAlignment = HorizontalAlignment.Left;

    [System.ComponentModel.Category("Alignment"),
    System.ComponentModel.Description("Specifies the alignment of text."),
    System.ComponentModel.DefaultValue(HorizontalAlignment.Left)]
    public HorizontalAlignment TextAlignment
    {
        get => _textAlignment;
        set
        {
            _textAlignment = value;
            Invalidate();
        }
    }

    public FirstControl()
    {
        InitializeComponent();
    }

    protected override void OnTextChanged(EventArgs e)
    {
        base.OnTextChanged(e);
        Invalidate();
    }

    protected override void OnPaint(PaintEventArgs pe)
    {
        StringFormat style = new();

        style.Alignment = TextAlignment switch
        {
            // Map the HorizontalAlignment enum to the StringAlignment enum
            HorizontalAlignment.Left => StringAlignment.Near,
            HorizontalAlignment.Right => StringAlignment.Far,
            HorizontalAlignment.Center => StringAlignment.Center,
            
            // Default to Near alignment
            _ => StringAlignment.Near
        };

        // Create the brush and automatically dispose it.
        using SolidBrush foreBrush = new(ForeColor);

        // Call the DrawString method to write text.
        // Text, Font, and ClientRectangle are inherited properties.
        pe.Graphics.DrawString(Text, Font, foreBrush, ClientRectangle, style);

        base.OnPaint(pe);
    }
}

Public Class FirstControl

    Private _textAlignment As HorizontalAlignment = HorizontalAlignment.Left

    <System.ComponentModel.Category("Alignment"),
    System.ComponentModel.Description("Specifies the alignment of text."),
    System.ComponentModel.DefaultValue(HorizontalAlignment.Left)>
    Public Property TextAlignment As HorizontalAlignment
        Get
            Return _textAlignment
        End Get

        Set(value As HorizontalAlignment)
            _textAlignment = value
            Invalidate()
        End Set
    End Property

    Protected Overrides Sub OnTextChanged(e As EventArgs)
        MyBase.OnTextChanged(e)
        Invalidate()
    End Sub

    Protected Overrides Sub OnPaint(ByVal e As System.Windows.Forms.PaintEventArgs)
        Dim style As New StringFormat

        'Map the HorizontalAlignment enum to the StringAlignment enum
        Select Case TextAlignment
            Case HorizontalAlignment.Left
                style.Alignment = StringAlignment.Near
            Case HorizontalAlignment.Right
                style.Alignment = StringAlignment.Far
            Case HorizontalAlignment.Center
                style.Alignment = StringAlignment.Center
        End Select

        'Create the brush and automatically dispose it.
        Using foreBrush As New SolidBrush(ForeColor)
            'Call the DrawString method to write text.
            'Text, Font, and ClientRectangle are inherited properties.
            e.Graphics.DrawString(Text, Font, foreBrush, ClientRectangle, style)
        End Using
        MyBase.OnPaint(e)
    End Sub

End Class

Contenu connexe

• Contrôles personnalisés
• System.Drawing.Graphics.DrawString
• System.Windows.Forms.HorizontalAlignment
• System.Windows.Forms.Control.OnPaint(PaintEventArgs)