Demonstra Passo a passo: Adicionar Rótulos inteligentes a um componente do Windows Forms

Artigo
08/25/2010

SMART Rótulos são menu - como a interface do usuário (UI) elementos fornecem comumente usado opções em time de design.A maioria dos componentes padrão e dos controles fornecidos com o .NET estrutura contém marca SMART e melhorias de verbo designer.Os procedimentos descritos nesta explicação passo a passo mostram como adicionar SMART-suporte para componentes e controles personalizados de marca.

Você pode adicionar Rótulos inteligentes a componentes do Windows Forms para opções de time de design de fonte usado.Itens em um smart-marca painel são logicamente agrupados por categoria e individuais DesignerActionMethodItem instâncias, opcionalmente, podem ser duplicadas sistema autônomo entradas de verbo designer. Muitos dos componentes padrão e controles fornecidos com o .NET estrutura contêm marca inteligente e aperfeiçoamentos do designer verbo.Componente e autores de controle personalizado também podem adicionar inteligente-marca suporte, normalmente usando o modelo de push.

Adicionando SMART Rótulos com o modelo de push requer os seguintes acréscimos ao projeto componente:

Implementação de uma classe derivada do DesignerActionList, que define os métodos e propriedades que são alvos de smart-marca itens de menu. Essa classe também pode fornecer uma substituição GetSortedActionItems método que retorna uma matriz de DesignerActionItem instâncias.
A classe designer associada ao componente deve implementar o ActionLists propriedade. Recuperar esta propriedade fornece o DesignerActionListCollection que contém todos os DesignerActionList instâncias associadas a um único SMART-menu de marca. Geralmente, há apenas uma lista no como uma coleção.

Observação:
SMART-painéis de marca não dão suporte à rolagem ou paginação, portanto, tenha cuidado para não popular seus painéis com vários SMART-marcar itens.Número excessivo de itens pode resultar na SMART-marca painel estendendo além do limite da tela.

O procedimento a seguir demonstra como adicionar SMART Rótulos usando o código de um controle de exemplo simples, ColorLabel, que é derivado do padrão Windows Forms Label controle. Este controle tem um designer associado chamado ColorLabelDesigner.

Para copiar o código deste tópico como uma única lista, consulte Como: Anexar SMART Rótulos a um componente do Windows Forms.

Pré-requisitos

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

Permissões suficientes para poder criar e executar projetos de aplicativos Windows Forms no computador em que o .NET estrutura está instalado.

Para implementar uma classe derivada de DesignerActionList

No mesmo espaço para nome que seu componente, adicione a declaração para sua classe derivada de DesignerActionList.

Public Class ColorLabelActionList
    Inherits System.ComponentModel.Design.DesignerActionList

public class ColorLabelActionList :
          System.ComponentModel.Design.DesignerActionList

Adicione um construtor a essa classe obtém uma instância do controle associado.Fornecer um particular campo para manter uma referência a essa instância.Também fornecer um campo privado para armazenar em cache uma referência para o DesignerActionService. Isso será usado para atualização da lista.

Private colLabel As ColorLabel


...


Private designerActionUISvc As DesignerActionUIService = Nothing


...


Public Sub New(ByVal component As IComponent)

    MyBase.New(component)
    Me.colLabel = component

    ' Cache a reference to DesignerActionUIService, so the
    ' DesigneractionList can be refreshed.
    Me.designerActionUISvc = _
    CType(GetService(GetType(DesignerActionUIService)), _
    DesignerActionUIService)

End Sub

private ColorLabel colLabel;


...


private DesignerActionUIService designerActionUISvc = null;


...


public ColorLabelActionList( IComponent component ) : base(component) 
{
    this.colLabel = component as ColorLabel;

    // Cache a reference to DesignerActionUIService, so the
    // DesigneractionList can be refreshed.
    this.designerActionUISvc =
        GetService(typeof(DesignerActionUIService))
        as DesignerActionUIService;
}

Adicione métodos e propriedades que você deseja associar a inteligente-marca itens.Métodos serão executados quando suas entradas de marca SMART correspondente está selecionada.As propriedades devem ter getter seções para que seu valor corrente seja exibida; eles podem, opcionalmente, têm seções setter que usam o GetProperties método se os valores devem ser editável da entrada de marca SMART correspondente.

Observação:
Assim sistema autônomo acontece em todo o ambiente de time de design, uma propriedade é capaz de que está sendo editado somente se um dos tipos base for fornecido pelo .NET estrutura, o tipo pode ser convertido em um tipo de base por um fornecido TypeConverter, ou quando um personalizado UITypeEditor é fornecida.

Public Property ForeColor() As Color
    Get
        Return colLabel.ForeColor
    End Get
    Set(ByVal value As Color)
        GetPropertyByName("ForeColor").SetValue(colLabel, value)
    End Set
End Property


...


'Boolean properties are automatically displayed with binary 
' UI (such as a checkbox).
Public Property LockColors() As Boolean
    Get
        Return colLabel.ColorLocked
    End Get
    Set(ByVal value As Boolean)
        GetPropertyByName("ColorLocked").SetValue(colLabel, value)

        ' Refresh the list.
        Me.designerActionUISvc.Refresh(Me.Component)
    End Set
End Property


...


Public Sub InvertColors()
    Dim currentBackColor As Color = colLabel.BackColor
    BackColor = Color.FromArgb( _
    255 - currentBackColor.R, _
    255 - currentBackColor.G, _
    255 - currentBackColor.B)

    Dim currentForeColor As Color = colLabel.ForeColor
    ForeColor = Color.FromArgb( _
    255 - currentForeColor.R, _
    255 - currentForeColor.G, _
    255 - currentForeColor.B)
End Sub

public Color ForeColor
{
    get
    {
        return colLabel.ForeColor;
    }
    set
    {
        GetPropertyByName("ForeColor").SetValue(colLabel, value);
    }
}


...


// Boolean properties are automatically displayed with binary 
// UI (such as a checkbox).
public bool LockColors
{
    get
    {
        return colLabel.ColorLocked;
    }
    set
    {
        GetPropertyByName("ColorLocked").SetValue(colLabel, value);

        // Refresh the list.
        this.designerActionUISvc.Refresh(this.Component);
    }
}


...


public void InvertColors()
{
    Color currentBackColor = colLabel.BackColor;
    BackColor = Color.FromArgb(
        255 - currentBackColor.R, 
        255 - currentBackColor.G, 
        255 - currentBackColor.B);

    Color currentForeColor = colLabel.ForeColor;
    ForeColor = Color.FromArgb(
        255 - currentForeColor.R, 
        255 - currentForeColor.G, 
        255 - currentForeColor.B);
}

Opcionalmente, implementar uma versão do substituídaGetSortedActionItems método para retornar uma matriz de DesignerActionItem instâncias, onde cada item está associado uma propriedade ou método criado na etapa anterior. Você pode fazer isso para alterar a ordem dos itens, categorizá-las ou opcionalmente mostrá-los.A lista também pode incluir itens estático, sistema autônomo títulos de agrupar lógico.

Public Overrides Function GetSortedActionItems() _
As DesignerActionItemCollection
    Dim items As New DesignerActionItemCollection()

    'Define static section header entries.
    items.Add(New DesignerActionHeaderItem("Appearance"))
    items.Add(New DesignerActionHeaderItem("Information"))

    'Boolean property for locking color selections.
    items.Add(New DesignerActionPropertyItem( _
    "LockColors", _
    "Lock Colors", _
    "Appearance", _
    "Locks the color properties."))

    If Not LockColors Then
        items.Add( _
        New DesignerActionPropertyItem( _
        "BackColor", _
        "Back Color", _
        "Appearance", _
        "Selects the background color."))

        items.Add( _
        New DesignerActionPropertyItem( _
        "ForeColor", _
        "Fore Color", _
        "Appearance", _
        "Selects the foreground color."))

        'This next method item is also added to the context menu 
        ' (as a designer verb).
        items.Add( _
        New DesignerActionMethodItem( _
        Me, _
        "InvertColors", _
        "Invert Colors", _
        "Appearance", _
        "Inverts the fore and background colors.", _
        True))
    End If
    items.Add( _
    New DesignerActionPropertyItem( _
    "Text", _
    "Text String", _
    "Appearance", _
    "Sets the display text."))

    'Create entries for static Information section.
    Dim location As New StringBuilder("Location: ")
    location.Append(colLabel.Location)
    Dim size As New StringBuilder("Size: ")
    size.Append(colLabel.Size)

    items.Add( _
    New DesignerActionTextItem( _
    location.ToString(), _
    "Information"))

    items.Add( _
    New DesignerActionTextItem( _
    size.ToString(), _
    "Information"))

    Return items
End Function

public override DesignerActionItemCollection GetSortedActionItems()
{
    DesignerActionItemCollection items = new DesignerActionItemCollection();

    //Define static section header entries.
    items.Add(new DesignerActionHeaderItem("Appearance"));
    items.Add(new DesignerActionHeaderItem("Information"));

    //Boolean property for locking color selections.
    items.Add(new DesignerActionPropertyItem("LockColors",
                     "Lock Colors", "Appearance",
                     "Locks the color properties."));
    if (!LockColors)
    {
        items.Add(new DesignerActionPropertyItem("BackColor",
                         "Back Color", "Appearance",
                         "Selects the background color."));
        items.Add(new DesignerActionPropertyItem("ForeColor",
                         "Fore Color", "Appearance",
                         "Selects the foreground color."));

        //This next method item is also added to the context menu 
        // (as a designer verb).
        items.Add(new DesignerActionMethodItem(this,
                         "InvertColors", "Invert Colors",
                         "Appearance",
                         "Inverts the fore and background colors.",
                          true));
    }
    items.Add(new DesignerActionPropertyItem("Text",
                     "Text String", "Appearance",
                     "Sets the display text."));

    //Create entries for static Information section.
    StringBuilder location = new StringBuilder("Location: ");
    location.Append(colLabel.Location);
    StringBuilder size = new StringBuilder("Size: ");
    size.Append(colLabel.Size);
    items.Add(new DesignerActionTextItem(location.ToString(),
                     "Information"));
    items.Add(new DesignerActionTextItem(size.ToString(),
                     "Information"));

    return items;
}

Para atualização da classe associada designer para implementar a propriedade ActionLists

localizar a classe designer para o controle.Se não existir, crie uma classe designer e associá-la para a classe de controle.Para obter mais informações sobre os designers, consulte Classes base do Designer.
sistema autônomo uma técnica de otimização, adicionar um campo particular do tipo DesignerActionListCollection.
```
Private lists As DesignerActionListCollection
```
```
private DesignerActionListCollection actionLists;
```

Adicionar o substituído ActionLists propriedade para retornar uma nova instância das ColorLabelActionList classe que você criou anteriormente.

Public Overrides ReadOnly Property ActionLists() _
As DesignerActionListCollection
    Get
        If lists Is Nothing Then
            lists = New DesignerActionListCollection()
            lists.Add( _
            New ColorLabelActionList(Me.Component))
        End If
        Return lists
    End Get
End Property

public override DesignerActionListCollection ActionLists
{
    get
    {
        if (null == actionLists)
        {
            actionLists = new DesignerActionListCollection();
            actionLists.Add(
                new ColorLabelActionList(this.Component));
        }
        return actionLists;
    }
}

Comentários

Várias áreas do código merecem uma explicação mais detalhada:

Quando uma propriedade ou método na classe derivada de DesignerActionList Altera o estado do controle associado, essas alterações não devem ser feitas por chamadas diretas setter para as propriedades do componente. Em vez disso, essas alterações devem ser feitas por meio de uma criada adequadamente PropertyDescriptor. Essa abordagem indireta garante que SMART-marca desfazer e interface do usuário atualização ações função corretamente.
Você pode atualizar dinamicamente inteligente-marca painel chamando DesignerActionUIService.Refresh. Esse processo pode ser usado para alterar dinamicamente o Sumário de smart-marca painel.No exemplo, o SMART Rótulos preocupadas com a alterar as cores estão incluídas condicionalmente dependendo do estado do LockColors propriedade. Essa propriedade booliano também está associada a uma marca SMART, para que o desenvolvedor possa bloquear ou desbloquear a seleção de cores corrente, pelo menos por meio do menu.
A SMART-marca a entrada do tipo DesignerActionMethodItem pode ser incluído opcionalmente em menu de atalho para o controle associado, definindo o includeAsDesignerVerb parâmetro no construtor para true. O .NET estrutura implicitamente cria um correspondente DesignerVerb e o adiciona ao menu de atalho para você. Neste exemplo, a InvertColors item é tratado dessa maneira.
Itens de marcas inteligentes são agrupados em um painel por seus Category propriedade, que é definida no construtor para cada item. Se esta propriedade não estiver explicitamente definida, ele é atribuído à categoria padrão.Cada item pode é adquirido no SMART-painel de marca por categoria e, em seguida, por ordem de ocorrência no DesignerActionItem matriz retornada por classe derivada de DesignerActionList classe. Este exemplo contém duas categorias: Appearance e Information.

Observação:

Não DesignerActionHeaderItem é fornecido para a segunda categoria.
Uma entrada que exibe texto estático informações pode ser implementada usando qualquer um DesignerActionTextItem ou um DesignerActionPropertyItem cuja propriedade associada contém apenas um setter. Este exemplo usa a primeira abordagem.

Observação:
Não DesignerActionHeaderItem é fornecido para a segunda categoria.

Próximas etapas

Após o início de integrar seu componente o ambiente de time de design, considere expandindo seu suporte de designer.

Adicione atributos a seus membros para facilitar a comunicação com o ambiente de time de design.Para obter mais informações, consulte Atributos no Windows Forms Controls.
Grave seu próprio designer personalizado.Para obter mais informações, consulte Como: Criar um controle Windows Forms que demora proveito dos recursos de time de design.