Demonstra Passo a passo: Criando um controle Windows Forms que tem a vantagem dos recursos de time de Design Visual Studio

Artigo
08/25/2010

A experiência de time de design para um controle personalizado pode ser avançado criando um designer personalizado associado.

Esta explicação passo a passo ilustra como criar um designer personalizado para um controle personalizado.Você irá implementar um MarqueeControl tipo e uma classe designer associada, chamado MarqueeControlRootDesigner.

The MarqueeControl o tipo implementa uma exibição semelhante a uma marca de teatro, com luzes animadas e o texto Brilhante.

O designer para este controle interage com o ambiente de design para fornecer uma experiência de time de design personalizada.Com o designer personalizado, você pode montar um personalizado MarqueeControl implementação com luzes animadas e o texto Brilhante em várias combinações. Você pode usar o controle montado em um formulário como qualquer Outros controle Windows Forms.

Tarefas ilustradas nesta explicação passo a passo incluem:

Criando o projeto
Criando um projeto de biblioteca de controle
Referência ao projeto de controle personalizado
Definição de um controle personalizado e seu designer personalizado
Criando uma instância do seu controle personalizado
Configurar o projeto para a depuração em tempo de design.
Implementar o controle personalizado
Criando um controle filho para o controle personalizado
Criar o controle filho MarqueeBorder
Criando um designer personalizado para sombra e propriedades de filtro
Manipulação de alterações de componentes
Adicionar verbos do Designer para seu designer personalizado
Criando um UITypeEditor personalizado
Testando o controle personalizado no Designer

Quando terminar, seu controle personalizado parecerá com o seguinte:

Para o código completo do exemplo, veja Como: Criar um Controlarar Windows Forms que tem a vantagem dos recursos de design-time.

Observação:
As caixas de diálogo e comandos de menu demonstradas podem ser diferentes daqueles descritas na Ajuda, dependendo das configurações ativas ou configurações de edição.Para alterar as configurações, escolher Importar e exportar configurações on the Ferramentas menu.Para obter mais informações, consulte Configurações do Visual Studio.

Pré-requisitos

A fim de concluir este explicação passo a passo, será necessário:

Dê permissões suficientes para poder criar e executar projetos de aplicativos de Formulários do Windows no computador onde o Visual Studio está instalado.

Criando o projeto

A primeira etapa é criar um projeto de aplicativo.Você usará este projeto para criar o aplicativo que hospeda o controle personalizado.

Para criar o projeto

Criar um projeto Windows Forms aplicativo chamado "MarqueeControlTest." Para obter mais informações, consulte Como: Criar um projeto de aplicativo do Windows.

Criando um projeto de biblioteca de controle

A próxima etapa é criar o projeto de biblioteca de controle.Você irá criar um novo controle personalizado e seu designer personalizado correspondente.

Para criar o projeto de biblioteca de controle

Adicione um projeto Windows controle biblioteca à solução.Para obter mais informações, consulte Caixa de Diálogo Add New Project. nome o projeto "MarqueeControlLibrary."
Usando O gerenciador de soluções, excluir o controle do padrão do projeto, excluindo o arquivo de fonte denominado "UserControl1.cs" ou "UserControl1.vb", dependendo do linguagem de sua escolha.Para obter mais informações, consulte Como: Excluir, remover e excluir itens.
Adicionar um novo UserControl item para o MarqueeControlLibrary projeto. Forneça o novo arquivo de fonte um nome de base de "MarqueeControl."
Usando O gerenciador de soluções, crie uma nova pasta no MarqueeControlLibrary projeto. Para obter mais informações, consulte Como: Itens de Adicionar Novo Projeto. Nomeie a nova pasta "Design."
clicar com o botão direito do mouse o Design pasta e adicione uma nova classe.Dar o arquivo de origem um nome de base de "MarqueeControlRootDesigner."
Você precisará usar tipos do assembly sistema.design do, para adicionar essa referência para o MarqueeControlLibrary projeto. Para obter mais informações, consulte Como: Adicionar e remover referências no Visual Studio (C#).

Referência ao projeto de controle personalizado

Você usará o MarqueeControlTest projeto para testar o controle personalizado. O projeto de teste será ciência do controle personalizado quando você adiciona uma referência de projeto para o MarqueeControlLibrary assembly.

A referência de projeto de controle personalizado

No MarqueeControlTest projeto, adicione uma referência de projeto para o MarqueeControlLibrary assembly. Certifique-se de usar o Projetos guia o Adicionar referência caixa de diálogo, em vez de fazer referência a MarqueeControlLibrary assembly diretamente.

Definição de um controle personalizado e seu designer personalizado

Seu controle personalizado irá derivar o UserControl classe. Isso permite que o controle contêm outros controles e fornece a seu controle de uma quantidade significativa de funcionalidade padrão.

O controle personalizado terá um designer personalizado associado.Isso permite que você criar uma experiência de design exclusivo adaptada especificamente para seu controle personalizado.

Você associar o controle com seu designer usando o DesignerAttribute classe. Porque você está desenvolvendo o comportamento em time de design inteiro do seu controle personalizado, o designer personalizado implementará a IRootDesigner interface.

Para definir um controle personalizado e seu designer personalizado

Abra o MarqueeControl arquivo de fonte na Editor de código.Na parte superior do arquivo, importe os namespaces a seguir:

Imports System
Imports System.Collections
Imports System.ComponentModel
Imports System.ComponentModel.Design
Imports System.Drawing
Imports System.Windows.Forms
Imports System.Windows.Forms.Design

using System;
using System.Collections;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Drawing;
using System.Windows.Forms;
using System.Windows.Forms.Design;

Adicionar o DesignerAttribute para o MarqueeControl declaração de classe. Isto associa o controle personalizado com seu designer.

<Designer(GetType(MarqueeControlLibrary.Design.MarqueeControlRootDesigner), _
 GetType(IRootDesigner))> _
Public Class MarqueeControl
    Inherits UserControl

 [Designer( typeof( MarqueeControlLibrary.Design.MarqueeControlRootDesigner ), typeof( IRootDesigner ) )]
    public class MarqueeControl : UserControl
    {

Abra o MarqueeControlRootDesigner arquivo de fonte na Editor de código.Na parte superior do arquivo, importe os namespaces a seguir:

Imports System
Imports System.Collections
Imports System.ComponentModel
Imports System.ComponentModel.Design
Imports System.Diagnostics
Imports System.Drawing.Design
Imports System.Windows.Forms
Imports System.Windows.Forms.Design

using System;
using System.Collections;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Diagnostics;
using System.Drawing.Design;
using System.Windows.Forms;
using System.Windows.Forms.Design;

Altere a declaração de MarqueeControlRootDesigner para herdar a partir do DocumentDesigner classe. Aplicar o ToolboxItemFilterAttribute Para especificar a interação designer com o Caixa de ferramentas.

Observação: A definição para o MarqueeControlRootDesignerclasse tiver sido colocado entre um namespace chamado "MarqueeControlLibrary.Design." Essa declaração coloca o designer em um namespace especial reservada para tipos de projeto.

Namespace MarqueeControlLibrary.Design

    <ToolboxItemFilter("MarqueeControlLibrary.MarqueeBorder", _
    ToolboxItemFilterType.Require), _
    ToolboxItemFilter("MarqueeControlLibrary.MarqueeText", _
    ToolboxItemFilterType.Require)> _
    <System.Security.Permissions.PermissionSetAttribute(System.Security.Permissions.SecurityAction.Demand, Name:="FullTrust")> _
    Public Class MarqueeControlRootDesigner
        Inherits DocumentDesigner

namespace MarqueeControlLibrary.Design
{
    [ToolboxItemFilter("MarqueeControlLibrary.MarqueeBorder", ToolboxItemFilterType.Require)]
    [ToolboxItemFilter("MarqueeControlLibrary.MarqueeText", ToolboxItemFilterType.Require)]
    [System.Security.Permissions.PermissionSet(System.Security.Permissions.SecurityAction.Demand, Name = "FullTrust")] 
    public class MarqueeControlRootDesigner : DocumentDesigner
    {

Definir o construtor para o MarqueeControlRootDesigner classe. Inserir um WriteLine demonstrativo no corpo do construtor. Isso será útil para fins de depuração.

Public Sub New()
    Trace.WriteLine("MarqueeControlRootDesigner ctor")
End Sub

public MarqueeControlRootDesigner()
{
    Trace.WriteLine("MarqueeControlRootDesigner ctor");
}

Criando uma instância do seu controle personalizado

Para observar o comportamento em time de design personalizado de seu controle, você colocará uma instância do seu controle no formulário em MarqueeControlTest projeto.

Para criar uma instância do seu controle personalizado

Adicionar um novo UserControl item para o MarqueeControlTest projeto. Nomeie o novo arquivo de fonte básico de "DemoMarqueeControl."
em aberto the DemoMarqueeControl arquivo a Editor de código.Na parte superior do arquivo, importar o MarqueeControlLibrary namespace:

Imports MarqueeControlLibrary

using MarqueeControlLibrary;

Altere a declaração de DemoMarqueeControl para herdar a partir do MarqueeControl classe.
Crie o projeto.
Abra Form1 no Windows Forms Designer.
Localizar o Componentes MarqueeControlTest guia o Caixa de ferramentas e abri-lo.arrastar um DemoMarqueeControl do Caixa de ferramentas para seu formulário.
Crie o projeto.

Configurar o projeto para a depuração em tempo de design.

Quando você está desenvolvendo uma experiência de time de criação personalizada, será necessário depurar seus controles e componentes.Há uma maneira simples para configurar o seu projeto para permitir a depuração em time de design.Para obter mais informações, consulte Demonstra Passo a passo: Depuração personalizada Windows Forms Controls at tempo de design.

Para configurar o projeto para depuração design-time

clicar com o botão direito do mouse o MarqueeControlLibrary projeto e selecionar Propriedades.
Na caixa de diálogo "Páginas de propriedade MarqueeControlLibrary", selecionar oPropriedades de configuração página.
No Iniciar ação seção, selecionar Iniciar programa externo.Você será depurar uma instância separada do Visual Studio, então, clicar nas reticências () botão para procurar o IDE do Visual Studio. O nome do arquivo executável é devenv.exe, e se você instalou no localização padrão, seu caminho é %ProgramFiles%\Microsoft Visual Studio 9.0\Common7\IDE\devenv.exe.
Clique OK para fechar a caixa de diálogo.
clicar com o botão direito do mouse o MarqueeControlLibraryprojeto e selecionar "conjunto sistema autônomo inicialização Project" para ativar a configuração de depuração.

Ponto de Verificação

Agora você está pronto para depurar o comportamento em time de design do seu controle personalizado.Depois de determinar se o ambiente de depuração está conjunto até corretamente, você testará a associação entre o controle personalizado e o designer personalizado.

Para testar o ambiente de depuração e a associação de designer

Abra o MarqueeControlRootDesigner arquivo de fonte na Editor de código e colocar um ponto de interrupção no WriteLine demonstrativo.
Pressione F5 para iniciar a depuração da solução.Observe que é criada uma nova instância do Visual Studio.
Na nova instância do Visual Studio, em aberto a solução "MarqueeControlTest".Você pode com com facilidade encontrar a solução selecionando Projetos recentes from the Arquivo menu.O arquivo de solução "MarqueeControlTest.sln" será listado sistema autônomo arquivo usado mais recentemente.
em aberto the DemoMarqueeControl no designer. Observe que a instância de depuração do Visual Studio adquire o foco e a execução pára no seu ponto de interrupção.Pressione F5 para continuar a sessão de depuração.

Neste ponto, tudo o que é local para você desenvolver e depurar seu controle personalizado e seu designer personalizado associado.O restante desta explicação passo a passo se concentrará nos detalhes de implementação de recursos do controle e o designer.

Implementar o controle personalizado

The MarqueeControl é um UserControl com um bit de personalização. Ela apresenta dois métodos: Start, que inicia a animação do letreiro digital, e Stop, que interrompe a animação. Porque o MarqueeControl contém controles filhos que implementam a IMarqueeWidget interface, Start e Stop enumerar cada controle filho e a telefonar a StartMarquee e StopMarquee métodos, respectivamente, na cada filho que implementa o controle IMarqueeWidget.

A aparência do MarqueeBorder e MarqueeText controles é dependente de layout, portanto, MarqueeControl substitui o OnLayout método e chamadas PerformLayout nos controles filho desse tipo.

Esta é a extensão do MarqueeControl personalizações. Os recursos de time de execução são implementados pelo MarqueeBorder e MarqueeText controles e os recursos de time de design são implementados pela MarqueeBorderDesigner e MarqueeControlRootDesigner classes.

Para implementar seu controle personalizado

Abra o MarqueeControl arquivo de fonte na Editor de código.Implementar o Start e Stop métodos.

Public Sub Start()
    ' The MarqueeControl may contain any number of 
    ' controls that implement IMarqueeWidget, so 
    ' find each IMarqueeWidget child and call its
    ' StartMarquee method.
    Dim cntrl As Control
    For Each cntrl In Me.Controls
        If TypeOf cntrl Is IMarqueeWidget Then
            Dim widget As IMarqueeWidget = CType(cntrl, IMarqueeWidget)

            widget.StartMarquee()
        End If
    Next cntrl
End Sub


Public Sub [Stop]()
    ' The MarqueeControl may contain any number of 
    ' controls that implement IMarqueeWidget, so find
    ' each IMarqueeWidget child and call its StopMarquee
    ' method.
    Dim cntrl As Control
    For Each cntrl In Me.Controls
        If TypeOf cntrl Is IMarqueeWidget Then
            Dim widget As IMarqueeWidget = CType(cntrl, IMarqueeWidget)

            widget.StopMarquee()
        End If
    Next cntrl
End Sub

public void Start()
{
    // The MarqueeControl may contain any number of 
    // controls that implement IMarqueeWidget, so 
    // find each IMarqueeWidget child and call its
    // StartMarquee method.
    foreach( Control cntrl in this.Controls )
    {
        if( cntrl is IMarqueeWidget )
        {
            IMarqueeWidget widget = cntrl as IMarqueeWidget;
            widget.StartMarquee();
        }
    }
}

public void Stop()
{
    // The MarqueeControl may contain any number of 
    // controls that implement IMarqueeWidget, so find
    // each IMarqueeWidget child and call its StopMarquee
    // method.
    foreach( Control cntrl in this.Controls )
    {
        if( cntrl is IMarqueeWidget )
        {
            IMarqueeWidget widget = cntrl as IMarqueeWidget;
            widget.StopMarquee();
        }
    }
}

Substitua o método OnLayout.

Protected Overrides Sub OnLayout(ByVal levent As LayoutEventArgs)
    MyBase.OnLayout(levent)

    ' Repaint all IMarqueeWidget children if the layout 
    ' has changed.
    Dim cntrl As Control
    For Each cntrl In Me.Controls
        If TypeOf cntrl Is IMarqueeWidget Then
            Dim widget As IMarqueeWidget = CType(cntrl, IMarqueeWidget)

            cntrl.PerformLayout()
        End If
    Next cntrl
End Sub

protected override void OnLayout(LayoutEventArgs levent)
{
    base.OnLayout (levent);

    // Repaint all IMarqueeWidget children if the layout 
    // has changed.
    foreach( Control cntrl in this.Controls )
    {
        if( cntrl is IMarqueeWidget )
        {
            Control control = cntrl as Control; 

            control.PerformLayout();
        }
    }
}

Criando um controle filho para o controle personalizado

The MarqueeControl hospedará dois tipos de controle filho: the MarqueeBorder controle e o MarqueeText controle.

MarqueeBorder: Este controle pinta uma borda de "luzes" ao redor de suas bordas. As luzes piscam em sequência, para que eles apareçam mover ao redor da borda.A velocidade em que as luzes piscam é controlada por uma propriedade chamada UpdatePeriod. Várias outras propriedades personalizadas determinam outros aspectos da aparência do controle.Dois métodos, chamados StartMarquee e StopMarquee, controlar quando a animação começa e pára.
MarqueeText: Este controle pinta uma seqüência de caracteres Brilhante. Como a MarqueeBorder controle, a velocidade com que pisca o texto é controlada pela UpdatePeriod propriedade. The MarqueeText controle também possui o StartMarquee e StopMarquee métodos em comum com o MarqueeBorder controle.

Em time de design, a MarqueeControlRootDesigner permite que esses tipos de dois controle a serem adicionados a um MarqueeControl em qualquer combinação.

Recursos comuns dos dois controles são fatorados em uma interface chamada IMarqueeWidget. Isso permite que o MarqueeControl Para descobrir os controles filho relacionadas à marca de seleção e dar-lhes tratamento especial.

Para implementar o recurso de animação periódicas, você usará BackgroundWorker objetos das System.ComponentModel espaço para nome. Você pode usar Timer objetos, mas quando muitos IMarqueeWidget objetos estiverem presentes, o único thread de interface do usuário pode não conseguir acompanhar a animação.

Para criar um controle filho para o controle personalizado

Adicionar um novo item de classe para o MarqueeControlLibrary projeto. Forneça o novo arquivo de fonte um nome de base de "IMarqueeWidget."

Abra o IMarqueeWidget arquivo de fonte na Editor de código e altere a declaração de class para interface:

' This interface defines the contract for any class that is to
' be used in constructing a MarqueeControl.
Public Interface IMarqueeWidget

// This interface defines the contract for any class that is to
// be used in constructing a MarqueeControl.
public interface IMarqueeWidget
{

Adicione o seguinte código à IMarqueeWidget interface para expor dois métodos e uma propriedade que manipulam a animação do letreiro digital:

' This interface defines the contract for any class that is to
' be used in constructing a MarqueeControl.
Public Interface IMarqueeWidget

   ' This method starts the animation. If the control can 
   ' contain other classes that implement IMarqueeWidget as
   ' children, the control should call StartMarquee on all
   ' its IMarqueeWidget child controls.
   Sub StartMarquee()

   ' This method stops the animation. If the control can 
   ' contain other classes that implement IMarqueeWidget as
   ' children, the control should call StopMarquee on all
   ' its IMarqueeWidget child controls.
   Sub StopMarquee()

   ' This method specifies the refresh rate for the animation,
   ' in milliseconds.
   Property UpdatePeriod() As Integer

End Interface

// This interface defines the contract for any class that is to
// be used in constructing a MarqueeControl.
public interface IMarqueeWidget
{
    // This method starts the animation. If the control can 
    // contain other classes that implement IMarqueeWidget as
    // children, the control should call StartMarquee on all
    // its IMarqueeWidget child controls.
    void StartMarquee();

    // This method stops the animation. If the control can 
    // contain other classes that implement IMarqueeWidget as
    // children, the control should call StopMarquee on all
    // its IMarqueeWidget child controls.
    void StopMarquee();

    // This method specifies the refresh rate for the animation,
    // in milliseconds.
    int UpdatePeriod
    {
        get;
        set;
    }
}

Adicionar um novo Controle personalizado o itemMarqueeControlLibrary projeto. Nomeie o novo arquivo de fonte básico de "MarqueeText."
arrastar um BackgroundWorker componente das Caixa de ferramentas para o seu MarqueeText controle. Esse componente permitirá que o MarqueeText controle para se atualizar assincronamente.
Na janela Propriedades, defina o BackgroundWorker componente WorkerReportsProgess e WorkerSupportsCancellation propriedades para true. Essas configurações permitem que o BackgroundWorker componente para elevar periodicamente o ProgressChanged eventos e para cancelar atualizações assíncrono. Para obter mais informações, consulte BackgroundWorker componente.

Abra o MarqueeText arquivo de fonte na Editor de código.Na parte superior do arquivo, importe os namespaces a seguir:

Imports System
Imports System.ComponentModel
Imports System.ComponentModel.Design
Imports System.Diagnostics
Imports System.Drawing
Imports System.Threading
Imports System.Windows.Forms
Imports System.Windows.Forms.Design

using System;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Diagnostics;
using System.Drawing;
using System.Threading;
using System.Windows.Forms;
using System.Windows.Forms.Design;

alterar a declaração de MarqueeText Herdar de Label e para implementar o IMarqueeWidget interface:

<ToolboxItemFilter("MarqueeControlLibrary.MarqueeText", _
ToolboxItemFilterType.Require)> _
Partial Public Class MarqueeText
    Inherits Label
    Implements IMarqueeWidget

[ToolboxItemFilter("MarqueeControlLibrary.MarqueeText", ToolboxItemFilterType.Require)]
public partial class MarqueeText : Label, IMarqueeWidget
{

Declare as variáveis de instância que correspondem às propriedades expostas e inicialize-los no construtor.The isLit campo determina se o texto está a ser pintado na cor fornecida pela LightColor propriedade.

' When isLit is true, the text is painted in the light color;
' When isLit is false, the text is painted in the dark color.
' This value changes whenever the BackgroundWorker component
' raises the ProgressChanged event.
Private isLit As Boolean = True

' These fields back the public properties.
Private updatePeriodValue As Integer = 50
Private lightColorValue As Color
Private darkColorValue As Color

' These brushes are used to paint the light and dark
' colors of the text.
Private lightBrush As Brush
Private darkBrush As Brush

' This component updates the control asynchronously.
Private WithEvents backgroundWorker1 As BackgroundWorker


Public Sub New()
    ' This call is required by the Windows.Forms Form Designer.
    InitializeComponent()

    ' Initialize light and dark colors 
    ' to the control's default values.
    Me.lightColorValue = Me.ForeColor
    Me.darkColorValue = Me.BackColor
    Me.lightBrush = New SolidBrush(Me.lightColorValue)
    Me.darkBrush = New SolidBrush(Me.darkColorValue)
End Sub 'New

// When isLit is true, the text is painted in the light color;
// When isLit is false, the text is painted in the dark color.
// This value changes whenever the BackgroundWorker component
// raises the ProgressChanged event.
private bool isLit = true;

// These fields back the public properties.
private int updatePeriodValue = 50;
private Color lightColorValue;
private Color darkColorValue;

// These brushes are used to paint the light and dark
// colors of the text.
private Brush lightBrush;
private Brush darkBrush;

// This component updates the control asynchronously.
private BackgroundWorker backgroundWorker1;

public MarqueeText()
{
    // This call is required by the Windows.Forms Form Designer.
    InitializeComponent();

    // Initialize light and dark colors 
    // to the control's default values.
    this.lightColorValue = this.ForeColor;
    this.darkColorValue = this.BackColor;
    this.lightBrush = new SolidBrush(this.lightColorValue);
    this.darkBrush = new SolidBrush(this.darkColorValue);
}

Implementar a interface IMarqueeWidget.

The StartMarquee e StopMarquee chamar métodos de BackgroundWorker componente RunWorkerAsync e CancelAsync métodos para iniciar e parar a animação.

The Category e Browsable os atributos são aplicados para o UpdatePeriodpropriedade para que ele apareça em uma seção personalizada da janela Propriedades chamada "Letreiro."

Public Overridable Sub StartMarquee() _
Implements IMarqueeWidget.StartMarquee
    ' Start the updating thread and pass it the UpdatePeriod.
    Me.backgroundWorker1.RunWorkerAsync(Me.UpdatePeriod)
End Sub

Public Overridable Sub StopMarquee() _
Implements IMarqueeWidget.StopMarquee
    ' Stop the updating thread.
    Me.backgroundWorker1.CancelAsync()
End Sub


<Category("Marquee"), Browsable(True)> _
Public Property UpdatePeriod() As Integer _
Implements IMarqueeWidget.UpdatePeriod

    Get
        Return Me.updatePeriodValue
    End Get

    Set(ByVal Value As Integer)
        If Value > 0 Then
            Me.updatePeriodValue = Value
        Else
            Throw New ArgumentOutOfRangeException("UpdatePeriod", "must be > 0")
        End If
    End Set

End Property

public virtual void StartMarquee()
{
    // Start the updating thread and pass it the UpdatePeriod.
    this.backgroundWorker1.RunWorkerAsync(this.UpdatePeriod);
}

public virtual void StopMarquee()
{
    // Stop the updating thread.
    this.backgroundWorker1.CancelAsync();
}

[Category("Marquee")]
[Browsable(true)]
public int UpdatePeriod
{
    get
    {
        return this.updatePeriodValue;
    }

    set
    {
        if (value > 0)
        {
            this.updatePeriodValue = value;
        }
        else
        {
            throw new ArgumentOutOfRangeException("UpdatePeriod", "must be > 0");
        }
    }
}

Implemente os acessadores de propriedade.Você expõe duas propriedades para os clientes: LightColor eDarkColor.The Category e Browsableatributos são aplicados a essas propriedades, para que as propriedades exibidos em uma seção personalizada da janela Propriedades chamada "Letreiro."

<Category("Marquee"), Browsable(True)> _
Public Property LightColor() As Color

    Get
        Return Me.lightColorValue
    End Get

    Set(ByVal Value As Color)
        ' The LightColor property is only changed if the 
        ' client provides a different value. Comparing values 
        ' from the ToArgb method is the recommended test for
        ' equality between Color structs.
        If Me.lightColorValue.ToArgb() <> Value.ToArgb() Then
            Me.lightColorValue = Value
            Me.lightBrush = New SolidBrush(Value)
        End If
    End Set

End Property


<Category("Marquee"), Browsable(True)> _
Public Property DarkColor() As Color

    Get
        Return Me.darkColorValue
    End Get

    Set(ByVal Value As Color)
        ' The DarkColor property is only changed if the 
        ' client provides a different value. Comparing values 
        ' from the ToArgb method is the recommended test for
        ' equality between Color structs.
        If Me.darkColorValue.ToArgb() <> Value.ToArgb() Then
            Me.darkColorValue = Value
            Me.darkBrush = New SolidBrush(Value)
        End If
    End Set

End Property

[Category("Marquee")]
[Browsable(true)]
public Color LightColor
{
    get
    {
        return this.lightColorValue;
    }
    set
    {
        // The LightColor property is only changed if the 
        // client provides a different value. Comparing values 
        // from the ToArgb method is the recommended test for
        // equality between Color structs.
        if (this.lightColorValue.ToArgb() != value.ToArgb())
        {
            this.lightColorValue = value;
            this.lightBrush = new SolidBrush(value);
        }
    }
}

[Category("Marquee")]
[Browsable(true)]
public Color DarkColor
{
    get
    {
        return this.darkColorValue;
    }
    set
    {
        // The DarkColor property is only changed if the 
        // client provides a different value. Comparing values 
        // from the ToArgb method is the recommended test for
        // equality between Color structs.
        if (this.darkColorValue.ToArgb() != value.ToArgb())
        {
            this.darkColorValue = value;
            this.darkBrush = new SolidBrush(value);
        }
    }
}

Implemente os manipuladores de BackgroundWorker componente DoWork e ProgressChanged eventos.

The DoWork dorme manipulador de eventos para o número de milissegundos especificado por UpdatePeriod em seguida, gera o ProgressChanged evento, até que seu código deixa a animação chamando CancelAsync.

The ProgressChanged evento manipulador alterna o texto entre seu estado claro e escuro para dar a aparência de Brilhante.

' This method is called in the worker thread's context, 
' so it must not make any calls into the MarqueeText control.
' Instead, it communicates to the control using the 
' ProgressChanged event.
'
' The only work done in this event handler is
' to sleep for the number of milliseconds specified 
' by UpdatePeriod, then raise the ProgressChanged event.
Private Sub backgroundWorker1_DoWork( _
ByVal sender As Object, _
ByVal e As System.ComponentModel.DoWorkEventArgs) _
Handles backgroundWorker1.DoWork
    Dim worker As BackgroundWorker = CType(sender, BackgroundWorker)

    ' This event handler will run until the client cancels
    ' the background task by calling CancelAsync.
    While Not worker.CancellationPending
        ' The Argument property of the DoWorkEventArgs
        ' object holds the value of UpdatePeriod, which 
        ' was passed as the argument to the RunWorkerAsync
        ' method. 
        Thread.Sleep(Fix(e.Argument))

        ' The DoWork eventhandler does not actually report
        ' progress; the ReportProgress event is used to 
        ' periodically alert the control to update its state.
        worker.ReportProgress(0)
    End While
End Sub


' The ProgressChanged event is raised by the DoWork method.
' This event handler does work that is internal to the
' control. In this case, the text is toggled between its
' light and dark state, and the control is told to 
' repaint itself.
Private Sub backgroundWorker1_ProgressChanged( _
ByVal sender As Object, _
ByVal e As System.ComponentModel.ProgressChangedEventArgs) _
Handles backgroundWorker1.ProgressChanged
    Me.isLit = Not Me.isLit
    Me.Refresh()
End Sub

// This method is called in the worker thread's context, 
// so it must not make any calls into the MarqueeText control.
// Instead, it communicates to the control using the 
// ProgressChanged event.
//
// The only work done in this event handler is
// to sleep for the number of milliseconds specified 
// by UpdatePeriod, then raise the ProgressChanged event.
private void backgroundWorker1_DoWork(
    object sender,
    System.ComponentModel.DoWorkEventArgs e)
{
    BackgroundWorker worker = sender as BackgroundWorker;

    // This event handler will run until the client cancels
    // the background task by calling CancelAsync.
    while (!worker.CancellationPending)
    {
        // The Argument property of the DoWorkEventArgs
        // object holds the value of UpdatePeriod, which 
        // was passed as the argument to the RunWorkerAsync
        // method. 
        Thread.Sleep((int)e.Argument);

        // The DoWork eventhandler does not actually report
        // progress; the ReportProgress event is used to 
        // periodically alert the control to update its state.
        worker.ReportProgress(0);
    }
}

// The ProgressChanged event is raised by the DoWork method.
// This event handler does work that is internal to the
// control. In this case, the text is toggled between its
// light and dark state, and the control is told to 
// repaint itself.
private void backgroundWorker1_ProgressChanged(object sender, System.ComponentModel.ProgressChangedEventArgs e)
{
    this.isLit = !this.isLit;
    this.Refresh();
}

Substituir o OnPaint método para ativar a animação.

Protected Overrides Sub OnPaint(ByVal e As PaintEventArgs)
    ' The text is painted in the light or dark color,
    ' depending on the current value of isLit.
    Me.ForeColor = IIf(Me.isLit, Me.lightColorValue, Me.darkColorValue)

    MyBase.OnPaint(e)
End Sub

protected override void OnPaint(PaintEventArgs e)
{
    // The text is painted in the light or dark color,
    // depending on the current value of isLit.
    this.ForeColor =
        this.isLit ? this.lightColorValue : this.darkColorValue;

    base.OnPaint(e);
}

Press F6 to build the solution.

Criar o controle filho MarqueeBorder

The MarqueeBorder o controle é um pouco mais sofisticado do MarqueeText controle. Ele tem mais propriedades e a animação no OnPaint método é mais envolvido. Em princípio, é bem semelhante de MarqueeText controle.

Porque o MarqueeBorder controle pode ter controles filho, ele precisará estar ciente das Layout eventos.

Para criar o controle MarqueeBorder

Adicionar um novo Controle personalizado o itemMarqueeControlLibrary projeto. Nomeie o novo arquivo de fonte básico de "MarqueeBorder."
arrastar um BackgroundWorker componente das Caixa de ferramentas para o seu MarqueeBorder controle. Esse componente permitirá que o MarqueeBorder controle para se atualizar assincronamente.
Na janela Propriedades, defina o BackgroundWorker componente WorkerReportsProgess e WorkerSupportsCancellation propriedades para true. Essas configurações permitem que o BackgroundWorker componente para elevar periodicamente o ProgressChanged eventos e para cancelar atualizações assíncrono. Para obter mais informações, consulte BackgroundWorker componente.
Na janela Propriedades, clicar no botão Events.Anexar manipuladores para o DoWork e ProgressChanged eventos.

Abra o MarqueeBorder arquivo de fonte na Editor de código.Na parte superior do arquivo, importe os namespaces a seguir:

Imports System
Imports System.ComponentModel
Imports System.ComponentModel.Design
Imports System.Diagnostics
Imports System.Drawing
Imports System.Drawing.Design
Imports System.Threading
Imports System.Windows.Forms
Imports System.Windows.Forms.Design

using System;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Design;
using System.Threading;
using System.Windows.Forms;
using System.Windows.Forms.Design;

Altere a declaração de MarqueeBorder Herdar de Panel e para implementar o IMarqueeWidget interface.

<Designer(GetType(MarqueeControlLibrary.Design.MarqueeBorderDesigner)), _
ToolboxItemFilter("MarqueeControlLibrary.MarqueeBorder", _
ToolboxItemFilterType.Require)> _
Partial Public Class MarqueeBorder
    Inherits Panel
    Implements IMarqueeWidget

[Designer(typeof(MarqueeControlLibrary.Design.MarqueeBorderDesigner ))]
[ToolboxItemFilter("MarqueeControlLibrary.MarqueeBorder", ToolboxItemFilterType.Require)]
public partial class MarqueeBorder : Panel, IMarqueeWidget
{

Declare duas enumerações para gerenciar o MarqueeBorder estado do controle: MarqueeSpinDirection, que determina a direção em que as luzes de "giram" ao redor da borda e MarqueeLightShape, que determina a forma de luzes (quadradas ou circulares). Coloque essas declarações antes do MarqueeBorder declaração de classe.

' This defines the possible values for the MarqueeBorder
' control's SpinDirection property.
Public Enum MarqueeSpinDirection
   CW
   CCW
End Enum

' This defines the possible values for the MarqueeBorder
' control's LightShape property.
Public Enum MarqueeLightShape
    Square
    Circle
End Enum

// This defines the possible values for the MarqueeBorder
// control's SpinDirection property.
public enum MarqueeSpinDirection
{
    CW,
    CCW
}

// This defines the possible values for the MarqueeBorder
// control's LightShape property.
public enum MarqueeLightShape
{
    Square,
    Circle
}

Declare as variáveis de instância que correspondem às propriedades expostas e inicialize-los no construtor.

Public Shared MaxLightSize As Integer = 10

' These fields back the public properties.
Private updatePeriodValue As Integer = 50
Private lightSizeValue As Integer = 5
Private lightPeriodValue As Integer = 3
Private lightSpacingValue As Integer = 1
Private lightColorValue As Color
Private darkColorValue As Color
Private spinDirectionValue As MarqueeSpinDirection = MarqueeSpinDirection.CW
Private lightShapeValue As MarqueeLightShape = MarqueeLightShape.Square

' These brushes are used to paint the light and dark
' colors of the marquee lights.
Private lightBrush As Brush
Private darkBrush As Brush

' This field tracks the progress of the "first" light as it
' "travels" around the marquee border.
Private currentOffset As Integer = 0

' This component updates the control asynchronously.
Private WithEvents backgroundWorker1 As System.ComponentModel.BackgroundWorker


Public Sub New()
    ' This call is required by the Windows.Forms Form Designer.
    InitializeComponent()

    ' Initialize light and dark colors 
    ' to the control's default values.
    Me.lightColorValue = Me.ForeColor
    Me.darkColorValue = Me.BackColor
    Me.lightBrush = New SolidBrush(Me.lightColorValue)
    Me.darkBrush = New SolidBrush(Me.darkColorValue)

    ' The MarqueeBorder control manages its own padding,
    ' because it requires that any contained controls do
    ' not overlap any of the marquee lights.
    Dim pad As Integer = 2 * (Me.lightSizeValue + Me.lightSpacingValue)
    Me.Padding = New Padding(pad, pad, pad, pad)

    SetStyle(ControlStyles.OptimizedDoubleBuffer, True)
End Sub

public static int MaxLightSize = 10;

// These fields back the public properties.
private int updatePeriodValue = 50;
private int lightSizeValue = 5;
private int lightPeriodValue = 3;
private int lightSpacingValue = 1;
private Color lightColorValue;
private Color darkColorValue;
private MarqueeSpinDirection spinDirectionValue = MarqueeSpinDirection.CW;
private MarqueeLightShape lightShapeValue = MarqueeLightShape.Square;

// These brushes are used to paint the light and dark
// colors of the marquee lights.
private Brush lightBrush;
private Brush darkBrush;

// This field tracks the progress of the "first" light as it
// "travels" around the marquee border.
private int currentOffset = 0;

// This component updates the control asynchronously.
private System.ComponentModel.BackgroundWorker backgroundWorker1;

public MarqueeBorder()
{
    // This call is required by the Windows.Forms Form Designer.
    InitializeComponent();

    // Initialize light and dark colors 
    // to the control's default values.
    this.lightColorValue = this.ForeColor;
    this.darkColorValue = this.BackColor;
    this.lightBrush = new SolidBrush(this.lightColorValue);
    this.darkBrush = new SolidBrush(this.darkColorValue);

    // The MarqueeBorder control manages its own padding,
    // because it requires that any contained controls do
    // not overlap any of the marquee lights.
    int pad = 2 * (this.lightSizeValue + this.lightSpacingValue);
    this.Padding = new Padding(pad, pad, pad, pad);

    SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
}

Implementar a interface IMarqueeWidget.

The StartMarquee e StopMarquee chamar métodos de BackgroundWorker componente RunWorkerAsync e CancelAsync métodos para iniciar e parar a animação.

Porque o MarqueeBorder controle pode conter controles filho, o StartMarquee método enumera todos os controles filho e chamadas StartMarquee naqueles que implementam IMarqueeWidget. The StopMarquee método tem uma implementação semelhante.

Public Overridable Sub StartMarquee() _
Implements IMarqueeWidget.StartMarquee
    ' The MarqueeBorder control may contain any number of 
    ' controls that implement IMarqueeWidget, so find
    ' each IMarqueeWidget child and call its StartMarquee
    ' method.
    Dim cntrl As Control
    For Each cntrl In Me.Controls
        If TypeOf cntrl Is IMarqueeWidget Then
            Dim widget As IMarqueeWidget = CType(cntrl, IMarqueeWidget)

            widget.StartMarquee()
        End If
    Next cntrl

    ' Start the updating thread and pass it the UpdatePeriod.
    Me.backgroundWorker1.RunWorkerAsync(Me.UpdatePeriod)
End Sub


Public Overridable Sub StopMarquee() _
Implements IMarqueeWidget.StopMarquee
    ' The MarqueeBorder control may contain any number of 
    ' controls that implement IMarqueeWidget, so find
    ' each IMarqueeWidget child and call its StopMarquee
    ' method.
    Dim cntrl As Control
    For Each cntrl In Me.Controls
        If TypeOf cntrl Is IMarqueeWidget Then
            Dim widget As IMarqueeWidget = CType(cntrl, IMarqueeWidget)

            widget.StopMarquee()
        End If
    Next cntrl

    ' Stop the updating thread.
    Me.backgroundWorker1.CancelAsync()
End Sub


<Category("Marquee"), Browsable(True)> _
Public Overridable Property UpdatePeriod() As Integer _
Implements IMarqueeWidget.UpdatePeriod

    Get
        Return Me.updatePeriodValue
    End Get

    Set(ByVal Value As Integer)
        If Value > 0 Then
            Me.updatePeriodValue = Value
        Else
            Throw New ArgumentOutOfRangeException("UpdatePeriod", _
            "must be > 0")
        End If
    End Set

End Property

public virtual void StartMarquee()
{
    // The MarqueeBorder control may contain any number of 
    // controls that implement IMarqueeWidget, so find
    // each IMarqueeWidget child and call its StartMarquee
    // method.
    foreach (Control cntrl in this.Controls)
    {
        if (cntrl is IMarqueeWidget)
        {
            IMarqueeWidget widget = cntrl as IMarqueeWidget;
            widget.StartMarquee();
        }
    }

    // Start the updating thread and pass it the UpdatePeriod.
    this.backgroundWorker1.RunWorkerAsync(this.UpdatePeriod);
}

public virtual void StopMarquee()
{
    // The MarqueeBorder control may contain any number of 
    // controls that implement IMarqueeWidget, so find
    // each IMarqueeWidget child and call its StopMarquee
    // method.
    foreach (Control cntrl in this.Controls)
    {
        if (cntrl is IMarqueeWidget)
        {
            IMarqueeWidget widget = cntrl as IMarqueeWidget;
            widget.StopMarquee();
        }
    }

    // Stop the updating thread.
    this.backgroundWorker1.CancelAsync();
}

[Category("Marquee")]
[Browsable(true)]
public virtual int UpdatePeriod
{
    get
    {
        return this.updatePeriodValue;
    }

    set
    {
        if (value > 0)
        {
            this.updatePeriodValue = value;
        }
        else
        {
            throw new ArgumentOutOfRangeException("UpdatePeriod", "must be > 0");
        }
    }
}

Implemente os acessadores de propriedade.The MarqueeBorder controle possui várias propriedades para controlar sua aparência.

<Category("Marquee"), Browsable(True)> _
Public Property LightSize() As Integer
    Get
        Return Me.lightSizeValue
    End Get

    Set(ByVal Value As Integer)
        If Value > 0 AndAlso Value <= MaxLightSize Then
            Me.lightSizeValue = Value
            Me.DockPadding.All = 2 * Value
        Else
            Throw New ArgumentOutOfRangeException("LightSize", _
            "must be > 0 and < MaxLightSize")
        End If
    End Set
End Property


<Category("Marquee"), Browsable(True)> _
Public Property LightPeriod() As Integer
    Get
        Return Me.lightPeriodValue
    End Get

    Set(ByVal Value As Integer)
        If Value > 0 Then
            Me.lightPeriodValue = Value
        Else
            Throw New ArgumentOutOfRangeException("LightPeriod", _
            "must be > 0 ")
        End If
    End Set
End Property


<Category("Marquee"), Browsable(True)> _
Public Property LightColor() As Color
    Get
        Return Me.lightColorValue
    End Get

    Set(ByVal Value As Color)
        ' The LightColor property is only changed if the 
        ' client provides a different value. Comparing values 
        ' from the ToArgb method is the recommended test for
        ' equality between Color structs.
        If Me.lightColorValue.ToArgb() <> Value.ToArgb() Then
            Me.lightColorValue = Value
            Me.lightBrush = New SolidBrush(Value)
        End If
    End Set
End Property


<Category("Marquee"), Browsable(True)> _
Public Property DarkColor() As Color
    Get
        Return Me.darkColorValue
    End Get

    Set(ByVal Value As Color)
        ' The DarkColor property is only changed if the 
        ' client provides a different value. Comparing values 
        ' from the ToArgb method is the recommended test for
        ' equality between Color structs.
        If Me.darkColorValue.ToArgb() <> Value.ToArgb() Then
            Me.darkColorValue = Value
            Me.darkBrush = New SolidBrush(Value)
        End If
    End Set
End Property


<Category("Marquee"), Browsable(True)> _
Public Property LightSpacing() As Integer
    Get
        Return Me.lightSpacingValue
    End Get

    Set(ByVal Value As Integer)
        If Value >= 0 Then
            Me.lightSpacingValue = Value
        Else
            Throw New ArgumentOutOfRangeException("LightSpacing", _
            "must be >= 0")
        End If
    End Set
End Property


<Category("Marquee"), Browsable(True), _
EditorAttribute(GetType(LightShapeEditor), _
GetType(System.Drawing.Design.UITypeEditor))> _
Public Property LightShape() As MarqueeLightShape

    Get
        Return Me.lightShapeValue
    End Get

    Set(ByVal Value As MarqueeLightShape)
        Me.lightShapeValue = Value
    End Set

End Property


<Category("Marquee"), Browsable(True)> _
Public Property SpinDirection() As MarqueeSpinDirection

    Get
        Return Me.spinDirectionValue
    End Get

    Set(ByVal Value As MarqueeSpinDirection)
        Me.spinDirectionValue = Value
    End Set

End Property

[Category("Marquee")]
[Browsable(true)]
public int LightSize
{
    get
    {
        return this.lightSizeValue;
    }

    set
    {
        if (value > 0 && value <= MaxLightSize)
        {
            this.lightSizeValue = value;
            this.DockPadding.All = 2 * value;
        }
        else
        {
            throw new ArgumentOutOfRangeException("LightSize", "must be > 0 and < MaxLightSize");
        }
    }
}

[Category("Marquee")]
[Browsable(true)]
public int LightPeriod
{
    get
    {
        return this.lightPeriodValue;
    }

    set
    {
        if (value > 0)
        {
            this.lightPeriodValue = value;
        }
        else
        {
            throw new ArgumentOutOfRangeException("LightPeriod", "must be > 0 ");
        }
    }
}

[Category("Marquee")]
[Browsable(true)]
public Color LightColor
{
    get
    {
        return this.lightColorValue;
    }

    set
    {
        // The LightColor property is only changed if the 
        // client provides a different value. Comparing values 
        // from the ToArgb method is the recommended test for
        // equality between Color structs.
        if (this.lightColorValue.ToArgb() != value.ToArgb())
        {
            this.lightColorValue = value;
            this.lightBrush = new SolidBrush(value);
        }
    }
}

[Category("Marquee")]
[Browsable(true)]
public Color DarkColor
{
    get
    {
        return this.darkColorValue;
    }

    set
    {
        // The DarkColor property is only changed if the 
        // client provides a different value. Comparing values 
        // from the ToArgb method is the recommended test for
        // equality between Color structs.
        if (this.darkColorValue.ToArgb() != value.ToArgb())
        {
            this.darkColorValue = value;
            this.darkBrush = new SolidBrush(value);
        }
    }
}

[Category("Marquee")]
[Browsable(true)]
public int LightSpacing
{
    get
    {
        return this.lightSpacingValue;
    }

    set
    {
        if (value >= 0)
        {
            this.lightSpacingValue = value;
        }
        else
        {
            throw new ArgumentOutOfRangeException("LightSpacing", "must be >= 0");
        }
    }
}

[Category("Marquee")]
[Browsable(true)]
[EditorAttribute(typeof(LightShapeEditor), 
     typeof(System.Drawing.Design.UITypeEditor))]
public MarqueeLightShape LightShape
{
    get
    {
        return this.lightShapeValue;
    }

    set
    {
        this.lightShapeValue = value;
    }
}

[Category("Marquee")]
[Browsable(true)]
public MarqueeSpinDirection SpinDirection
{
    get
    {
        return this.spinDirectionValue;
    }

    set
    {
        this.spinDirectionValue = value;
    }
}

Implemente os manipuladores de BackgroundWorker componente DoWork e ProgressChanged eventos.

The ProgressChangedmanipulador de eventos incrementa a posição da luz "base", do qual o estado de claro/escuro das outras luzes é determinado e chama o Refresh método para fazer com que o controle redesenhar propriamente dito.

' This method is called in the worker thread's context, 
' so it must not make any calls into the MarqueeBorder
' control. Instead, it communicates to the control using 
' the ProgressChanged event.
'
' The only work done in this event handler is
' to sleep for the number of milliseconds specified 
' by UpdatePeriod, then raise the ProgressChanged event.
Private Sub backgroundWorker1_DoWork( _
ByVal sender As Object, _
ByVal e As System.ComponentModel.DoWorkEventArgs) _
Handles backgroundWorker1.DoWork
    Dim worker As BackgroundWorker = CType(sender, BackgroundWorker)

    ' This event handler will run until the client cancels
    ' the background task by calling CancelAsync.
    While Not worker.CancellationPending
        ' The Argument property of the DoWorkEventArgs
        ' object holds the value of UpdatePeriod, which 
        ' was passed as the argument to the RunWorkerAsync
        ' method. 
        Thread.Sleep(Fix(e.Argument))

        ' The DoWork eventhandler does not actually report
        ' progress; the ReportProgress event is used to 
        ' periodically alert the control to update its state.
        worker.ReportProgress(0)
    End While
End Sub


' The ProgressChanged event is raised by the DoWork method.
' This event handler does work that is internal to the
' control. In this case, the currentOffset is incremented,
' and the control is told to repaint itself.
Private Sub backgroundWorker1_ProgressChanged( _
ByVal sender As Object, _
ByVal e As System.ComponentModel.ProgressChangedEventArgs) _
Handles backgroundWorker1.ProgressChanged
    Me.currentOffset += 1
    Me.Refresh()
End Sub

// This method is called in the worker thread's context, 
// so it must not make any calls into the MarqueeBorder
// control. Instead, it communicates to the control using 
// the ProgressChanged event.
//
// The only work done in this event handler is
// to sleep for the number of milliseconds specified 
// by UpdatePeriod, then raise the ProgressChanged event.
private void backgroundWorker1_DoWork(object sender, System.ComponentModel.DoWorkEventArgs e)
{
    BackgroundWorker worker = sender as BackgroundWorker;

    // This event handler will run until the client cancels
    // the background task by calling CancelAsync.
    while (!worker.CancellationPending)
    {
        // The Argument property of the DoWorkEventArgs
        // object holds the value of UpdatePeriod, which 
        // was passed as the argument to the RunWorkerAsync
        // method. 
        Thread.Sleep((int)e.Argument);

        // The DoWork eventhandler does not actually report
        // progress; the ReportProgress event is used to 
        // periodically alert the control to update its state.
        worker.ReportProgress(0);
    }
}

// The ProgressChanged event is raised by the DoWork method.
// This event handler does work that is internal to the
// control. In this case, the currentOffset is incremented,
// and the control is told to repaint itself.
private void backgroundWorker1_ProgressChanged(
    object sender,
    System.ComponentModel.ProgressChangedEventArgs e)
{
    this.currentOffset++;
    this.Refresh();
}

Implementar os métodos auxiliares, IsLit e DrawLight.

The IsLit método determina a cor de uma luz em uma posição determinada. Luzes são "ACESO" são desenhadas na cor fornecida pelaLightColorpropriedade e os que são "escuro" são desenhadas na cor fornecida pela DarkColor propriedade.

The DrawLight método desenha uma luz usando a cor adequada, a forma e a posição.

' This method determines if the marquee light at lightIndex
' should be lit. The currentOffset field specifies where
' the "first" light is located, and the "position" of the
' light given by lightIndex is computed relative to this 
' offset. If this position modulo lightPeriodValue is zero,
' the light is considered to be on, and it will be painted
' with the control's lightBrush. 
Protected Overridable Function IsLit(ByVal lightIndex As Integer) As Boolean
    Dim directionFactor As Integer = _
    IIf(Me.spinDirectionValue = MarqueeSpinDirection.CW, -1, 1)

    Return (lightIndex + directionFactor * Me.currentOffset) Mod Me.lightPeriodValue = 0
End Function


Protected Overridable Sub DrawLight( _
ByVal g As Graphics, _
ByVal brush As Brush, _
ByVal xPos As Integer, _
ByVal yPos As Integer)

    Select Case Me.lightShapeValue
        Case MarqueeLightShape.Square
            g.FillRectangle( _
            brush, _
            xPos, _
            yPos, _
            Me.lightSizeValue, _
            Me.lightSizeValue)
            Exit Select
        Case MarqueeLightShape.Circle
            g.FillEllipse( _
            brush, _
            xPos, _
            yPos, _
            Me.lightSizeValue, _
            Me.lightSizeValue)
            Exit Select
        Case Else
            Trace.Assert(False, "Unknown value for light shape.")
            Exit Select
    End Select

End Sub

// This method determines if the marquee light at lightIndex
// should be lit. The currentOffset field specifies where
// the "first" light is located, and the "position" of the
// light given by lightIndex is computed relative to this 
// offset. If this position modulo lightPeriodValue is zero,
// the light is considered to be on, and it will be painted
// with the control's lightBrush. 
protected virtual bool IsLit(int lightIndex)
{
    int directionFactor =
        (this.spinDirectionValue == MarqueeSpinDirection.CW ? -1 : 1);

    return (
        (lightIndex + directionFactor * this.currentOffset) % this.lightPeriodValue == 0
        );
}

protected virtual void DrawLight(
    Graphics g,
    Brush brush,
    int xPos,
    int yPos)
{
    switch (this.lightShapeValue)
    {
        case MarqueeLightShape.Square:
            {
                g.FillRectangle(brush, xPos, yPos, this.lightSizeValue, this.lightSizeValue);
                break;
            }
        case MarqueeLightShape.Circle:
            {
                g.FillEllipse(brush, xPos, yPos, this.lightSizeValue, this.lightSizeValue);
                break;
            }
        default:
            {
                Trace.Assert(false, "Unknown value for light shape.");
                break;
            }
    }
}

Substituir o OnLayout e OnPaint métodos.

The OnPaint método desenha as luzes ao longo das bordas das MarqueeBorder controle.

Porque o OnPaint método depende das dimensões das MarqueeBorder controle, você precisará telefonar-lo sempre que o layout é alterado. Para conseguir isso, substituir OnLayout e chame Refresh.

Protected Overrides Sub OnLayout(ByVal levent As LayoutEventArgs)
    MyBase.OnLayout(levent)

    ' Repaint when the layout has changed.
    Me.Refresh()
End Sub


' This method paints the lights around the border of the 
' control. It paints the top row first, followed by the
' right side, the bottom row, and the left side. The color
' of each light is determined by the IsLit method and
' depends on the light's position relative to the value
' of currentOffset.
Protected Overrides Sub OnPaint(ByVal e As PaintEventArgs)
    Dim g As Graphics = e.Graphics
    g.Clear(Me.BackColor)

    MyBase.OnPaint(e)

    ' If the control is large enough, draw some lights.
    If Me.Width > MaxLightSize AndAlso Me.Height > MaxLightSize Then
        ' The position of the next light will be incremented 
        ' by this value, which is equal to the sum of the
        ' light size and the space between two lights.
        Dim increment As Integer = _
        Me.lightSizeValue + Me.lightSpacingValue

        ' Compute the number of lights to be drawn along the
        ' horizontal edges of the control.
        Dim horizontalLights As Integer = _
        (Me.Width - increment) / increment

        ' Compute the number of lights to be drawn along the
        ' vertical edges of the control.
        Dim verticalLights As Integer = _
        (Me.Height - increment) / increment

        ' These local variables will be used to position and
        ' paint each light.
        Dim xPos As Integer = 0
        Dim yPos As Integer = 0
        Dim lightCounter As Integer = 0
        Dim brush As Brush

        ' Draw the top row of lights.
        Dim i As Integer
        For i = 0 To horizontalLights - 1
            brush = IIf(IsLit(lightCounter), Me.lightBrush, Me.darkBrush)

            DrawLight(g, brush, xPos, yPos)

            xPos += increment
            lightCounter += 1
        Next i

        ' Draw the lights flush with the right edge of the control.
        xPos = Me.Width - Me.lightSizeValue

        ' Draw the right column of lights.
        'Dim i As Integer
        For i = 0 To verticalLights - 1
            brush = IIf(IsLit(lightCounter), Me.lightBrush, Me.darkBrush)

            DrawLight(g, brush, xPos, yPos)

            yPos += increment
            lightCounter += 1
        Next i

        ' Draw the lights flush with the bottom edge of the control.
        yPos = Me.Height - Me.lightSizeValue

        ' Draw the bottom row of lights.
        'Dim i As Integer
        For i = 0 To horizontalLights - 1
            brush = IIf(IsLit(lightCounter), Me.lightBrush, Me.darkBrush)

            DrawLight(g, brush, xPos, yPos)

            xPos -= increment
            lightCounter += 1
        Next i

        ' Draw the lights flush with the left edge of the control.
        xPos = 0

        ' Draw the left column of lights.
        'Dim i As Integer
        For i = 0 To verticalLights - 1
            brush = IIf(IsLit(lightCounter), Me.lightBrush, Me.darkBrush)

            DrawLight(g, brush, xPos, yPos)

            yPos -= increment
            lightCounter += 1
        Next i
    End If
End Sub

protected override void OnLayout(LayoutEventArgs levent)
{
    base.OnLayout(levent);

    // Repaint when the layout has changed.
    this.Refresh();
}

// This method paints the lights around the border of the 
// control. It paints the top row first, followed by the
// right side, the bottom row, and the left side. The color
// of each light is determined by the IsLit method and
// depends on the light's position relative to the value
// of currentOffset.
protected override void OnPaint(PaintEventArgs e)
{
    Graphics g = e.Graphics;
    g.Clear(this.BackColor);

    base.OnPaint(e);

    // If the control is large enough, draw some lights.
    if (this.Width > MaxLightSize &&
        this.Height > MaxLightSize)
    {
        // The position of the next light will be incremented 
        // by this value, which is equal to the sum of the
        // light size and the space between two lights.
        int increment =
            this.lightSizeValue + this.lightSpacingValue;

        // Compute the number of lights to be drawn along the
        // horizontal edges of the control.
        int horizontalLights =
            (this.Width - increment) / increment;

        // Compute the number of lights to be drawn along the
        // vertical edges of the control.
        int verticalLights =
            (this.Height - increment) / increment;

        // These local variables will be used to position and
        // paint each light.
        int xPos = 0;
        int yPos = 0;
        int lightCounter = 0;
        Brush brush;

        // Draw the top row of lights.
        for (int i = 0; i < horizontalLights; i++)
        {
            brush = IsLit(lightCounter) ? this.lightBrush : this.darkBrush;

            DrawLight(g, brush, xPos, yPos);

            xPos += increment;
            lightCounter++;
        }

        // Draw the lights flush with the right edge of the control.
        xPos = this.Width - this.lightSizeValue;

        // Draw the right column of lights.
        for (int i = 0; i < verticalLights; i++)
        {
            brush = IsLit(lightCounter) ? this.lightBrush : this.darkBrush;

            DrawLight(g, brush, xPos, yPos);

            yPos += increment;
            lightCounter++;
        }

        // Draw the lights flush with the bottom edge of the control.
        yPos = this.Height - this.lightSizeValue;

        // Draw the bottom row of lights.
        for (int i = 0; i < horizontalLights; i++)
        {
            brush = IsLit(lightCounter) ? this.lightBrush : this.darkBrush;

            DrawLight(g, brush, xPos, yPos);

            xPos -= increment;
            lightCounter++;
        }

        // Draw the lights flush with the left edge of the control.
        xPos = 0;

        // Draw the left column of lights.
        for (int i = 0; i < verticalLights; i++)
        {
            brush = IsLit(lightCounter) ? this.lightBrush : this.darkBrush;

            DrawLight(g, brush, xPos, yPos);

            yPos -= increment;
            lightCounter++;
        }
    }
}

Criando um designer personalizado para sombra e propriedades de filtro

The MarqueeControlRootDesigner classe fornece a implementação para o designer raiz. Em adição a esse designer, que funciona com o MarqueeControl, você precisará de um designer personalizado que está associado especificamente a MarqueeBorder controle. Esse designer fornece comportamento personalizado adequado no contexto do designer raiz personalizado.

Especificamente, a MarqueeBorderDesignerserá "sombra" e filtre certas propriedades de MarqueeBorder controle, alterar sua interação com o ambiente de design.

Interceptar chamadas ao acessador de propriedade do componente é conhecido sistema autônomo "sombrear." Ele permite que um designer controlar a valor definida pelo usuário e, opcionalmente, passar esse valor para o componente sendo criado.

Neste exemplo, a Visible e Enabled Propriedades irão ser sombreadas a MarqueeBorderDesigner, que impede que o usuário fazer o MarqueeBorder controle invisível ou desabilitado durante a time de design.

Os designers também podem adicionar e remover propriedades.Neste exemplo, a Padding propriedade será removida em time de design, porque o MarqueeBorder controle programaticamente define o preenchimento com base no dimensionar das luzes especificado pela LightSize propriedade.

A classe base para MarqueeBorderDesigner é ComponentDesigner, que tem métodos que podem alterar os atributos, propriedades e eventos expostos por um controle em time de design:

Ao alterar a interface pública de um componente usando esses métodos, você deve seguir estas regras:

Adicionar ou remover itens no PreFilter Somente métodos
Modificar itens existentes no PostFilter Somente métodos
Sempre telefonar a implementação base primeiro no PreFilter métodos
Sempre telefonar a implementação base pela última vez no PostFilter métodos

Aderir a essas regras assegura que todos os designers no ambiente de time de design tem uma visão consistente de todos os componentes que está sendo criado.

The ComponentDesigner classe fornece um dicionário para gerenciar os valores das propriedades sombreados, que você libera da necessidade de criar variáveis de instância específica.

Para criar um designer personalizado a sombra e filtro de propriedades

clicar com o botão direito do mouse o Design pasta e adicione uma nova classe.Dar o arquivo de fonte um nome de base de "MarqueeBorderDesigner."

Abra o MarqueeBorderDesigner arquivo de fonte na Editor de código.Na parte superior do arquivo, importe os namespaces a seguir:

Imports System
Imports System.Collections
Imports System.ComponentModel
Imports System.ComponentModel.Design
Imports System.Diagnostics
Imports System.Windows.Forms
Imports System.Windows.Forms.Design

using System;
using System.Collections;
using System.ComponentModel;
using System.ComponentModel.Design;
using System.Diagnostics;
using System.Windows.Forms;
using System.Windows.Forms.Design;

Altere a declaração de MarqueeBorderDesigner Herdar de ParentControlDesigner.

Porque o MarqueeBorder controle pode conter controles filho, MarqueeBorderDesigner herda do ParentControlDesigner, que manipula a interação de pai-filho.

Namespace MarqueeControlLibrary.Design

    <System.Security.Permissions.PermissionSetAttribute(System.Security.Permissions.SecurityAction.Demand, Name:="FullTrust")> _
    Public Class MarqueeBorderDesigner
        Inherits ParentControlDesigner

namespace MarqueeControlLibrary.Design
{
    [System.Security.Permissions.PermissionSet(System.Security.Permissions.SecurityAction.Demand, Name = "FullTrust")] 
    public class MarqueeBorderDesigner : ParentControlDesigner
    {

Substituir a implementação da base de PreFilterProperties.

Protected Overrides Sub PreFilterProperties( _
ByVal properties As IDictionary)

    MyBase.PreFilterProperties(properties)

    If properties.Contains("Padding") Then
        properties.Remove("Padding")
    End If

    properties("Visible") = _
    TypeDescriptor.CreateProperty(GetType(MarqueeBorderDesigner), _
    CType(properties("Visible"), PropertyDescriptor), _
    New Attribute(-1) {})

    properties("Enabled") = _
    TypeDescriptor.CreateProperty(GetType(MarqueeBorderDesigner), _
    CType(properties("Enabled"), _
    PropertyDescriptor), _
    New Attribute(-1) {})

End Sub

protected override void PreFilterProperties(IDictionary properties)
{
    base.PreFilterProperties(properties);

    if (properties.Contains("Padding"))
    {
        properties.Remove("Padding");
    }

    properties["Visible"] = TypeDescriptor.CreateProperty(
        typeof(MarqueeBorderDesigner),
        (PropertyDescriptor)properties["Visible"],
        new Attribute[0]);

    properties["Enabled"] = TypeDescriptor.CreateProperty(
        typeof(MarqueeBorderDesigner),
        (PropertyDescriptor)properties["Enabled"],
        new Attribute[0]);
}

Implementar o Enabled e Visible Propriedades. Essas implementações sombra as propriedades do controle.

Public Property Visible() As Boolean
    Get
        Return CBool(ShadowProperties("Visible"))
    End Get
    Set(ByVal Value As Boolean)
        Me.ShadowProperties("Visible") = Value
    End Set
End Property


Public Property Enabled() As Boolean
    Get
        Return CBool(ShadowProperties("Enabled"))
    End Get
    Set(ByVal Value As Boolean)
        Me.ShadowProperties("Enabled") = Value
    End Set
End Property

public bool Visible
{
    get
    {
        return (bool)ShadowProperties["Visible"];
    }
    set
    {
        this.ShadowProperties["Visible"] = value;
    }
}

public bool Enabled
{
    get
    {
        return (bool)ShadowProperties["Enabled"];
    }
    set
    {
        this.ShadowProperties["Enabled"] = value;
    }
}

Manipulação de alterações de componentes

The MarqueeControlRootDesigner classe fornece a experiência de time de design personalizada para seu MarqueeControl instâncias. A maioria da funcionalidade de time de design é herdada do DocumentDesigner classe; seu código implementar duas personalizações específicas: tratamento componente alterações e adicionar verbos designer.

sistema autônomo sistema autônomo usuários projetar seus MarqueeControl instâncias, seu designer raiz irá controlar alterações para o MarqueeControl e seus controles filho. O ambiente de time de design oferece um serviço conveniente, IComponentChangeService, para controlar alterações para o estado do componente.

Adquirir uma referência a esse serviço consultando o ambiente com o GetService método. Se a consulta for bem-sucedida, o designer pode anexar um manipulador para o ComponentChanged evento e realizar quaisquer tarefas são necessárias para manter um estado consistente no time de design.

No caso do MarqueeControlRootDesigner classe, você irá telefonar o Refresh método em cada IMarqueeWidget objeto contido pela MarqueeControl. Isso fará com que o IMarqueeWidget objeto a redesenhar próprio apropriadamente quando seu pai, como propriedades Size são alteradas.

Para lidar com alterações de componentes

Abra o MarqueeControlRootDesigner arquivo de fonte na Editor de código e substituir de Initialize método. telefonar implementação base do Initialize e de consulta para o IComponentChangeService.

MyBase.Initialize(component)

Dim cs As IComponentChangeService = _
CType(GetService(GetType(IComponentChangeService)), _
IComponentChangeService)

If (cs IsNot Nothing) Then
    AddHandler cs.ComponentChanged, AddressOf OnComponentChanged
End If

base.Initialize(component);

IComponentChangeService cs =
    GetService(typeof(IComponentChangeService)) 
    as IComponentChangeService;

if (cs != null)
{
    cs.ComponentChanged +=
        new ComponentChangedEventHandler(OnComponentChanged);
}

Implementar o OnComponentChanged manipulador de eventos. Tipo do componente de envio, testar e, se for um IMarqueeWidget, telefonar seu Refresh método.

Private Sub OnComponentChanged( _
ByVal sender As Object, _
ByVal e As ComponentChangedEventArgs)
    If TypeOf e.Component Is IMarqueeWidget Then
        Me.Control.Refresh()
    End If
End Sub

private void OnComponentChanged(
    object sender,
    ComponentChangedEventArgs e)
{
    if (e.Component is IMarqueeWidget)
    {
        this.Control.Refresh();
    }
}

Adicionar verbos do Designer para seu designer personalizado

Um verbo designer é um comando de menu vinculado a um evento manipulador.Verbos do Designer são adicionados ao menu de atalho do componente em time de design.Para obter mais informações, consulte DesignerVerb.

Você irá adicionar dois verbos designer para os designers: Executar o teste and Parar teste.Esses verbos permitirá que você exiba o comportamento em time de execução do MarqueeControl em time de design. Esses verbos serão adicionados ao MarqueeControlRootDesigner.

Quando Executar o teste é chamado, o manipulador de eventos do verbo será telefonar o StartMarquee método na MarqueeControl. Quando Parar teste é chamado, o manipulador de eventos do verbo será telefonar o StopMarquee método na MarqueeControl. A implementação do StartMarquee e StopMarquee métodos de chamam esses métodos em controles contidos implementar IMarqueeWidget, portanto, qualquer contidos IMarqueeWidget controles participará também no teste.

Para adicionar verbos do designer para os designers personalizados

No MarqueeControlRootDesigner classe, adicionar evento manipuladores de chamada OnVerbRunTest e OnVerbStopTest.

Private Sub OnVerbRunTest( _
ByVal sender As Object, _
ByVal e As EventArgs)

    Dim c As MarqueeControl = CType(Me.Control, MarqueeControl)
    c.Start()

End Sub

Private Sub OnVerbStopTest( _
ByVal sender As Object, _
ByVal e As EventArgs)

    Dim c As MarqueeControl = CType(Me.Control, MarqueeControl)
    c.Stop()

End Sub

private void OnVerbRunTest(object sender, EventArgs e)
{
    MarqueeControl c = this.Control as MarqueeControl;

    c.Start();
}

private void OnVerbStopTest(object sender, EventArgs e)
{
    MarqueeControl c = this.Control as MarqueeControl;

    c.Stop();
}

Conectar-se esses manipuladores de eventos a seus verbos do designer correspondentes.MarqueeControlRootDesigner herda um DesignerVerbCollection de sua classe base. Você criará dois novos DesignerVerb objetos e adicioná-los a essa coleção na Initialize método.

Me.Verbs.Add(New DesignerVerb("Run Test", _
New EventHandler(AddressOf OnVerbRunTest)))

Me.Verbs.Add(New DesignerVerb("Stop Test", _
New EventHandler(AddressOf OnVerbStopTest)))

this.Verbs.Add(
    new DesignerVerb("Run Test",
    new EventHandler(OnVerbRunTest))
    );

this.Verbs.Add(
    new DesignerVerb("Stop Test",
    new EventHandler(OnVerbStopTest))
    );

Criando um UITypeEditor personalizado

Quando você cria uma experiência de time de design personalizada para os usuários, muitas vezes é desejável para criar uma interação com a janela propriedades personalizada.Você pode fazer isso, criando um UITypeEditor. Para obter mais informações, consulte Como: Criar um Editor de tipo de interface do usuário.

The MarqueeBorder controle expõe várias propriedades na janela Propriedades. Duas dessas propriedades, MarqueeSpinDirection e MarqueeLightShape são representados por enumerações. Para ilustrar o uso de um editor de tipos de interface do usuário, a MarqueeLightShape propriedade terá um associado UITypeEditor classe.

Para criar um tipo personalizado de UI editor

Abra o MarqueeBorder arquivo de fonte na Editor de código.

Na definição do MarqueeBorder classe, declare uma classe chamada LightShapeEditor que deriva de UITypeEditor.

' This class demonstrates the use of a custom UITypeEditor. 
' It allows the MarqueeBorder control's LightShape property
' to be changed at design time using a customized UI element
' that is invoked by the Properties window. The UI is provided
' by the LightShapeSelectionControl class.
Friend Class LightShapeEditor
    Inherits UITypeEditor

// This class demonstrates the use of a custom UITypeEditor. 
// It allows the MarqueeBorder control's LightShape property
// to be changed at design time using a customized UI element
// that is invoked by the Properties window. The UI is provided
// by the LightShapeSelectionControl class.
internal class LightShapeEditor : UITypeEditor
{

Declarar um IWindowsFormsEditorService variável de instância chamada editorService.

Private editorService As IWindowsFormsEditorService = Nothing

private IWindowsFormsEditorService editorService = null;

Substitua o método GetEditStyle.Essa implementação retorna DropDown, que informa ao ambiente de design como exibir o LightShapeEditor.

Public Overrides Function GetEditStyle( _
ByVal context As System.ComponentModel.ITypeDescriptorContext) _
As UITypeEditorEditStyle
    Return UITypeEditorEditStyle.DropDown
End Function

public override UITypeEditorEditStyle GetEditStyle(
System.ComponentModel.ITypeDescriptorContext context)
{
    return UITypeEditorEditStyle.DropDown;
}

Substitua o método EditValue.Essa implementação consultará o ambiente de design para um IWindowsFormsEditorService objeto. Se for bem-sucedido, ele cria um LightShapeSelectionControl. The DropDownControl método é chamado para iniciar o LightShapeEditor. O valor retornado dessa chamada é retornado para o ambiente de design.

Public Overrides Function EditValue( _
ByVal context As ITypeDescriptorContext, _
ByVal provider As IServiceProvider, _
ByVal value As Object) As Object
    If (provider IsNot Nothing) Then
        editorService = _
        CType(provider.GetService(GetType(IWindowsFormsEditorService)), _
        IWindowsFormsEditorService)
    End If

    If (editorService IsNot Nothing) Then
        Dim selectionControl As _
        New LightShapeSelectionControl( _
        CType(value, MarqueeLightShape), _
        editorService)

        editorService.DropDownControl(selectionControl)

        value = selectionControl.LightShape
    End If

    Return value
End Function

public override object EditValue(
    ITypeDescriptorContext context,
    IServiceProvider provider,
    object value)
{
    if (provider != null)
    {
        editorService =
            provider.GetService(
            typeof(IWindowsFormsEditorService))
            as IWindowsFormsEditorService;
    }

    if (editorService != null)
    {
        LightShapeSelectionControl selectionControl =
            new LightShapeSelectionControl(
            (MarqueeLightShape)value,
            editorService);

        editorService.DropDownControl(selectionControl);

        value = selectionControl.LightShape;
    }

    return value;
}

Criando um controle de exibição para o UITypeEditor personalizado

The MarqueeLightShape propriedade oferece suporte a dois tipos de formas de luz: Square eCircle.Você criará um controle personalizado usado unicamente para fins de graficamente exibindo esses valores na janela Propriedades.Esse controle personalizado será usado pelo seu UITypeEditor para interagir com a janela Propriedades.

Para criar um controle de exibição para a interface do usuário personalizada tipo editor

Adicionar um novo UserControl item para o MarqueeControlLibrary projeto. Dar ao arquivo de fonte nova base nome de "LightShapeSelectionControl."
arrastar dois Panel Controla a partir do Caixa de ferramentas onto the LightShapeSelectionControl. nome them squarePanel e circlePanel. Organizá-los lado a lado.conjunto o Size propriedade de ambos Panel os controles para (60, 60). conjunto o Location propriedade das squarePanel o controle para (8, 10). conjunto o Location propriedade das circlePanel o controle para (80, 10). Finalmente, defina o Size propriedade das LightShapeSelectionControl a (150, 80).
Abra o LightShapeSelectionControl arquivo de fonte na Editor de código.Na parte superior do arquivo, importar o System.Windows.Forms.Design namespace:

Imports System.Windows.Forms.Design

using System.Windows.Forms.Design;

Implementar Click evento manipuladores para os squarePanel e circlePanel controles. De chamar esses métodosCloseDropDown Para finalizar o custom UITypeEditor sessão de edição.

Private Sub squarePanel_Click( _
ByVal sender As Object, _
ByVal e As EventArgs)

    Me.lightShapeValue = MarqueeLightShape.Square
    Me.Invalidate(False)
    Me.editorService.CloseDropDown()

End Sub


Private Sub circlePanel_Click( _
ByVal sender As Object, _
ByVal e As EventArgs)

    Me.lightShapeValue = MarqueeLightShape.Circle
    Me.Invalidate(False)
    Me.editorService.CloseDropDown()

End Sub

        private void squarePanel_Click(object sender, EventArgs e)
        {
            this.lightShapeValue = MarqueeLightShape.Square;

            this.Invalidate( false );

            this.editorService.CloseDropDown();
        }

        private void circlePanel_Click(object sender, EventArgs e)
        {
            this.lightShapeValue = MarqueeLightShape.Circle;

            this.Invalidate( false );

            this.editorService.CloseDropDown();
        }

Declarar um IWindowsFormsEditorService variável de instância chamada editorService.

Private editorService As IWindowsFormsEditorService

private IWindowsFormsEditorService editorService;

Declarar um MarqueeLightShape variável de instância chamada lightShapeValue.

Private lightShapeValue As MarqueeLightShape = MarqueeLightShape.Square

private MarqueeLightShape lightShapeValue = MarqueeLightShape.Square;

No LightShapeSelectionControl construtor, anexar o Click evento manipuladores para os squarePanel e circlePanel dos controles Click eventos. Além disso, defina uma sobrecarga de construtor atribui o MarqueeLightShape valor a partir do ambiente de design para o lightShapeValue campo.

' This constructor takes a MarqueeLightShape value from the
' design-time environment, which will be used to display
' the initial state.
 Public Sub New( _
 ByVal lightShape As MarqueeLightShape, _
 ByVal editorService As IWindowsFormsEditorService)
     ' This call is required by the Windows.Forms Form Designer.
     InitializeComponent()

     ' Cache the light shape value provided by the 
     ' design-time environment.
     Me.lightShapeValue = lightShape

     ' Cache the reference to the editor service.
     Me.editorService = editorService

     ' Handle the Click event for the two panels. 
     AddHandler Me.squarePanel.Click, AddressOf squarePanel_Click
     AddHandler Me.circlePanel.Click, AddressOf circlePanel_Click
 End Sub

        // This constructor takes a MarqueeLightShape value from the
        // design-time environment, which will be used to display
        // the initial state.
        public LightShapeSelectionControl( 
            MarqueeLightShape lightShape,
            IWindowsFormsEditorService editorService )
        {
            // This call is required by the designer.
            InitializeComponent();

            // Cache the light shape value provided by the 
            // design-time environment.
            this.lightShapeValue = lightShape;

            // Cache the reference to the editor service.
            this.editorService = editorService;

            // Handle the Click event for the two panels. 
            this.squarePanel.Click += new EventHandler(squarePanel_Click);
            this.circlePanel.Click += new EventHandler(circlePanel_Click);
        }

No Dispose método, desanexar o Click evento manipuladores.

Protected Overrides Sub Dispose(ByVal disposing As Boolean)
    If disposing Then

        ' Be sure to unhook event handlers
        ' to prevent "lapsed listener" leaks.
        RemoveHandler Me.squarePanel.Click, AddressOf squarePanel_Click
        RemoveHandler Me.circlePanel.Click, AddressOf circlePanel_Click

        If (components IsNot Nothing) Then
            components.Dispose()
        End If

    End If
    MyBase.Dispose(disposing)
End Sub

        protected override void Dispose( bool disposing )
        {
            if( disposing )
            {
                // Be sure to unhook event handlers
                // to prevent "lapsed listener" leaks.
                this.squarePanel.Click -= 
                    new EventHandler(squarePanel_Click);
                this.circlePanel.Click -= 
                    new EventHandler(circlePanel_Click);

                if(components != null)
                {
                    components.Dispose();
                }
            }
            base.Dispose( disposing );
        }

In O gerenciador de soluções, clicar no Mostrar todos os arquivos botão.em aberto o LightShapeSelectionControl.Designer.cs ou LightShapeSelectionControl.Designer.vb de arquivos e remova a definição padrão do Dispose método.

Implementar o LightShape propriedade.

' LightShape is the property for which this control provides
' a custom user interface in the Properties window.
Public Property LightShape() As MarqueeLightShape

    Get
        Return Me.lightShapeValue
    End Get

    Set(ByVal Value As MarqueeLightShape)
        If Me.lightShapeValue <> Value Then
            Me.lightShapeValue = Value
        End If
    End Set

End Property

        // LightShape is the property for which this control provides
        // a custom user interface in the Properties window.
        public MarqueeLightShape LightShape
        {
            get
            {
                return this.lightShapeValue;
            }

            set
            {
                if( this.lightShapeValue != value )
                {
                    this.lightShapeValue = value;
                }
            }
        }

Substitua o método OnPaint.Essa implementação será desenhar um círculo e um quadrado preenchido.Ele também realçará o valor selecionado desenhando uma borda ao redor de uma forma ou Outros.

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

    Dim gCircle As Graphics = Me.circlePanel.CreateGraphics()
    Try
        Dim gSquare As Graphics = Me.squarePanel.CreateGraphics()
        Try
            ' Draw a filled square in the client area of
            ' the squarePanel control.
            gSquare.FillRectangle( _
            Brushes.Red, _
            0, _
            0, _
            Me.squarePanel.Width, _
            Me.squarePanel.Height)

            ' If the Square option has been selected, draw a 
            ' border inside the squarePanel.
            If Me.lightShapeValue = MarqueeLightShape.Square Then
                gSquare.DrawRectangle( _
                Pens.Black, _
                0, _
                0, _
                Me.squarePanel.Width - 1, _
                Me.squarePanel.Height - 1)
            End If

            ' Draw a filled circle in the client area of
            ' the circlePanel control.
            gCircle.Clear(Me.circlePanel.BackColor)
            gCircle.FillEllipse( _
            Brushes.Blue, _
            0, _
            0, _
            Me.circlePanel.Width, _
            Me.circlePanel.Height)

            ' If the Circle option has been selected, draw a 
            ' border inside the circlePanel.
            If Me.lightShapeValue = MarqueeLightShape.Circle Then
                gCircle.DrawRectangle( _
                Pens.Black, _
                0, _
                0, _
                Me.circlePanel.Width - 1, _
                Me.circlePanel.Height - 1)
            End If
        Finally
            gSquare.Dispose()
        End Try
    Finally
        gCircle.Dispose()
    End Try
End Sub

        protected override void OnPaint(PaintEventArgs e)
        {
            base.OnPaint (e);

            using( 
                Graphics gSquare = this.squarePanel.CreateGraphics(),
                gCircle = this.circlePanel.CreateGraphics() )
            {   
                // Draw a filled square in the client area of
                // the squarePanel control.
                gSquare.FillRectangle(
                    Brushes.Red, 
                    0,
                    0,
                    this.squarePanel.Width,
                    this.squarePanel.Height
                    );

                // If the Square option has been selected, draw a 
                // border inside the squarePanel.
                if( this.lightShapeValue == MarqueeLightShape.Square )
                {
                    gSquare.DrawRectangle( 
                        Pens.Black,
                        0,
                        0,
                        this.squarePanel.Width-1,
                        this.squarePanel.Height-1);
                }

                // Draw a filled circle in the client area of
                // the circlePanel control.
                gCircle.Clear( this.circlePanel.BackColor );
                gCircle.FillEllipse( 
                    Brushes.Blue, 
                    0,
                    0,
                    this.circlePanel.Width, 
                    this.circlePanel.Height
                    );

                // If the Circle option has been selected, draw a 
                // border inside the circlePanel.
                if( this.lightShapeValue == MarqueeLightShape.Circle )
                {
                    gCircle.DrawRectangle( 
                        Pens.Black,
                        0,
                        0,
                        this.circlePanel.Width-1,
                        this.circlePanel.Height-1);
                }
            }   
        }

Testando o controle personalizado no Designer

Neste ponto, você pode construir o MarqueeControlLibrary projeto. Testar a implementação, criando um controle que herda a partir de MarqueeControl classe e usá-lo em um formulário.

Para criar uma implementação personalizada do MarqueeControl

Abra DemoMarqueeControl no Windows Forms Designer.Isso cria uma instância do DemoMarqueeControl Digite e o exibe em uma instância das MarqueeControlRootDesigner Digite.
No Caixa de ferramentas, em aberto the Componentes MarqueeControlLibrary guia.Você verá o MarqueeBorder e MarqueeText controles disponível para seleção.
arrastar um instância do MarqueeBorder controlar até a DemoMarqueeControl área de design. Encaixar este MarqueeBorder controlar o controle pai.
arrastar um instância do MarqueeText controlar até a DemoMarqueeControl área de design.
Crie a solução.
clicar com o botão direito do mouse o DemoMarqueeControl e do menu de atalho, selecionar o Executar o teste opção para iniciar a animação.clicar Parar teste para parar a animação.
Abra o Form1 no modo de modo de exibição de Design.
Coloque dois Button controles do formulário. Nomear o arquivo startButton e stopButtone altere o Text valores de propriedade para iniciar e parar, respectivamente.
Implementar Click evento manipuladores para os dois Button controles.
No Caixa de ferramentas, em aberto the Componentes MarqueeControlTest guia.Você verá o DemoMarqueeControl disponível para seleção.
arrastar uma ocorrência de DemoMarqueeControl para o Form1 área de design.
No Click manipuladores de eventos, chamar o Start e Stop métodos de DemoMarqueeControl.

Private Sub startButton_Click(sender As Object, e As System.EventArgs)
    Me.demoMarqueeControl1.Start()
End Sub 'startButton_Click

Private Sub stopButton_Click(sender As Object, e As System.EventArgs)
Me.demoMarqueeControl1.Stop()
End Sub 'stopButton_Click

private void startButton_Click(object sender, System.EventArgs e)
{
    this.demoMarqueeControl1.Start();
}

private void stopButton_Click(object sender, System.EventArgs e)
{
    this.demoMarqueeControl1.Stop();
}

conjunto o MarqueeControlTest projeto sistema autônomo o projeto de inicialização e executá-lo. Você verá o formulário exibindo seu DemoMarqueeControl. clicar no Iniciar botão para iniciar a animação.Você deve ver o texto Brilhante e as luzes mover ao redor da borda.

Próximas etapas

The MarqueeControlLibrary demonstra uma simples implementação de controles personalizados e designers associados. Você pode fazer esta amostra mais sofisticados de várias maneiras:

Alterar os valores de propriedade para o DemoMarqueeControl no designer. Adicionar mais de MarqueBorder os controles e encaixar-os dentro de seu pai instâncias para criar um efeito aninhado. Experimentar configurações diferentes para o UpdatePeriod e as propriedades relacionadas à luz.
Criar suas próprias implementações de IMarqueeWidget. Você pode, por exemplo, criar "néon sinal" Brilhante ou com um sinal animado com várias imagens.
Personalizar ainda mais a experiência de time de design.Você pode tentar sombreamento mais propriedades que Enabled e Visible, e você poderá adicionar novas propriedades. Adicione novos verbos designer para simplificar tarefas comuns como controles filhos de encaixe.
O de licençaMarqueeControl. Para obter mais informações, consulte Como: Controles e componentes de licença.
Controle como os controles são serializados e como o código é gerado para elas.Para obter mais informações, consulte Geração e compilação dinâmicas de código fonte.

Consulte também

Partilhar via