Partilhar via

O que é um controle personalizado?

Este artigo apresenta os controles personalizados e descreve como eles são diferentes dos controles de usuário. Os controles personalizados não fornecem uma superfície de design visual e dependem do código fornecido pelo usuário para desenhar a si mesmos. Isso é diferente dos controles de usuário que fornecem uma superfície de design visual para agrupar vários controles em uma única unidade reutilizável.

Os controles personalizados são usados quando um controle ou controle de usuário existente não chega perto de fornecer a interface do usuário ou a interatividade que você precisa. Eles exigem mais esforço da sua parte para serem totalmente implementados. A manipulação de teclado e mouse ainda é fornecida pelo Windows Forms, mas todos os comportamentos são deixados para você implementar. Não há uma superfície de design fornecida com um controle personalizado, porque todo o desenho é feito por meio de código no OnPaint método. Componentes, como um Timer, ainda podem ser adicionados através da superfície de design não visual.

Classe base

Há duas classes base para escolher ao criar um controle personalizado:

A menos que você precise rolar o conteúdo do controle personalizado, use Control como sua classe base.

Capacidades herdadas

Como a classe base de um controle personalizado é Control, você herda automaticamente a funcionalidade do Windows Forms compartilhada por todos os controles. Aqui estão alguns dos recursos que você obtém com um controle personalizado:

  • Entrada de teclado e mouse.
  • Comportamentos de layout, como ancoragem e encaixe.
  • Suporte para tabulação.
  • Restrições de tamanho mínimo e máximo.

Pintura

A pintura, que significa desenhar o visual do controle, é realizada substituindo o método OnPaint. Para obter mais informações sobre como os controles realizam a pintura, consulte Pintura e desenho nos controles.

Quando crias um controlo personalizado usando os modelos do Visual Studio, o método OnPaint é automaticamente substituído. O modelo faz isso porque você é obrigado a escrever o código para desenhar seu controle. Aqui está um exemplo do que o modelo gera:

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

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

Public Class CustomControl1

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

        'Add your custom paint code here
    End Sub

End Class

Um controle personalizado é pintado com o método OnPaint. O único argumento desse método é um PaintEventArgs objeto, que fornece todas as informações e funcionalidades necessárias para renderizar seu controle. PaintEventArgs Fornece duas propriedades que são usadas na renderização de seu controle:

  • PaintEventArgs.ClipRectangle—Representa a parte do controle que precisa ser redesenhada. Isso pode ser o controle inteiro ou parte do controle.

  • Graphics—Representa a superfície gráfica do seu controle. Ele fornece vários objetos orientados a gráficos e métodos que fornecem a funcionalidade necessária para desenhar seu controle.

O OnPaint método é chamado sempre que o controle é desenhado ou atualizado na tela, e o PaintEventArgs.ClipRectangle objeto representa o retângulo no qual a pintura ocorre. Se todo o controle precisar ser atualizado, PaintEventArgs.ClipRectangle representa o tamanho do controle inteiro. Se apenas parte do controle precisar ser atualizada, ele representa apenas a região que precisa ser redesenhada. Um exemplo de tal caso seria quando um controle é parcialmente obscurecido por outro controle na interface do usuário, e esse outro controle é movido para longe, a parte recém-exposta do controle abaixo deve ser redesenhada.

O código do método OnPaint de um controlo é executado quando o controlo é desenhado pela primeira vez e sempre que é invalidado. Para garantir que seu controle seja redesenhado sempre que for redimensionado, adicione a seguinte linha ao construtor do seu controle:

SetStyle(ControlStyles.ResizeRedraw, true);

SetStyle(ControlStyles.ResizeRedraw, True)

Exemplo

O fragmento de código a seguir é um controle personalizado que renderiza vários retângulos coloridos na periferia do controle.

protected override void OnPaint(PaintEventArgs pe)
{
    Rectangle rect = this.ClientRectangle;

    // Bring the width/height in by 1 pixel so the rectangle is drawn inside the control.
    // Otherwise, it kind of overlaps the outside edge.
    rect.Width -= 1;
    rect.Height -= 1;

    Pen[] colorPens = new Pen[] { Pens.Blue, Pens.BlueViolet,
                                  Pens.AliceBlue, Pens.CornflowerBlue,
                                  Pens.Cyan, Pens.DarkCyan };

    foreach (Pen pen in colorPens)
    {
        pe.Graphics.DrawRectangle(pen, rect);
        rect.Inflate(-1, -1);
    }

    // Raise the Paint event so users can custom paint if they want.
    base.OnPaint(pe);
}

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

    Dim rect As Rectangle = Me.ClientRectangle

    'Bring the width/height in by 1 pixel so the rectangle is drawn inside the control.
    'Otherwise, it kind of overlaps the outside edge.
    rect.Width -= 1
    rect.Height -= 1

    Dim colorPens As Pen() = {Pens.Blue, Pens.BlueViolet,
                                Pens.AliceBlue, Pens.CornflowerBlue,
                                Pens.Cyan, Pens.DarkCyan}

    For Each curPen As Pen In colorPens

        e.Graphics.DrawRectangle(curPen, rect)
        rect.Inflate(-1, -1)

    Next

    'Raise the Paint event so users can custom paint if they want.
    MyBase.OnPaint(e)

End Sub

O código anterior cria um controle que se parece com a seguinte imagem:

Um controle personalizado como renderizado no Visual Studio. O controle é uma caixa vazia com cores diferentes bordejando-o. Cada cor é inserida por um único pixel.

Contexto geral

Observe que o plano de fundo do controle é pintado com a SystemColors.Control cor, mesmo que o OnPaint código não limpe ou preencha o controle com uma cor. O fundo é pintado, na verdade, pelo método OnPaintBackground(PaintEventArgs) antes de OnPaint ser chamado. Substituir OnPaintBackground para lidar com o desenho do plano de fundo do seu controle. A implementação padrão desse método é desenhar a cor e a imagem definidas pelas BackColor propriedades e BackgroundImage , respectivamente.

Conteúdo relacionado