Wskazówki: dodawanie tagów inteligentnych do składnika Windows Forms

Artykuł
06/09/2015

Tagi inteligentne są elementy interfejsu użytkownika jak menu, które dostaw powszechnie używane opcje w czasie projektowania.Większość standardowych składników i wyposażone w formanty.NET Framework zawierają tag inteligentny i ulepszenia zlecenie projektanta.Procedury opisane w tym instruktażu pokazują sposób dodawania obsługi tagów inteligentnych do składników oraz formanty niestandardowe.

Tagi inteligentne można dodać do części okna formularzy do dostaw używanych podczas projektowania opcje.Elementy w panelu smart tag są logicznie pogrupowane według kategorii i indywidualnych DesignerActionMethodItem wystąpień opcjonalnie może być duplikowane jako zapisy zlecenia projektanta.Wiele standardowych składników i wyposażone w formanty.NET Framework zawierają tag inteligentny i ulepszenia zlecenie projektanta.Składnik i autorzy formant niestandardowy można również dodać funkcję obsługi tagów inteligentnych, zazwyczaj przy użyciu modelu popychania.

Dodawanie tagów inteligentnych z modelu popychania wymaga następujących dodatków do projektu składnika:

Implementacji klasy, pochodzące z DesignerActionList, który definiuje metody i właściwości, które są cele elementy menu tagów inteligentnych.Tej klasy mogą również dostarczać przesłonięte GetSortedActionItems metodę, która zwraca tablicę DesignerActionItem wystąpień.
Musi implementować konstruktora klasy skojarzone z danym składnikiem ActionLists właściwości.Pobieranie tej właściwości dostaw DesignerActionListCollection zawierający wszystkie DesignerActionList wystąpień skojarzonych z jednego menu smart tag.Często istnieje tylko jedna lista w takiej zbiórki.

[!UWAGA]

Panele Smart tag nie obsługują, przewijania lub tak stronicowania, należy uważać, aby wypełnić paneli z wielu elementów smart tag.Zbyt wiele elementów może skutkować panelu smart tag wykraczającego poza granicę ekranu.

W poniższej procedurze przedstawiono sposób dodawania tagów inteligentnych, przy użyciu kodu z formantu prosty przykład, ColorLabel, który pochodzi od standardowego Windows Forms Label kontroli.Ten formant ma skojarzony designer, o nazwie ColorLabelDesigner.

Aby skopiować kod w tym temacie jako pojedynczy aukcji, zobacz Porady: dołączanie tagów inteligentnych do składnika Windows Forms.

Wymagania wstępne

W celu przeprowadzenia tego instruktażu będą potrzebne:

Wystarczające uprawnienia, aby móc utworzyć i uruchomić Windows Forms projektów aplikacji na komputerze, gdzie.NET Framework jest zainstalowana.

Aby zaimplementować klasę pochodną DesignerActionList

W tej samej przestrzeni nazw jako składnik, dodać deklaracji dla swojej klasy pochodne DesignerActionList.

[!UWAGA]

Należy dodać odwołanie do zestawu czasu projektowania, System.Design.dll.Ten moduł nie jest dołączony do.NET Framework 4 profilu klienta.Aby dodać odwołanie do System.Design.dll, należy zmienić projektu docelowego ramy do .NET Framework 4.
```
Public Class ColorLabelActionList
    Inherits System.ComponentModel.Design.DesignerActionList
```
```
public class ColorLabelActionList :
          System.ComponentModel.Design.DesignerActionList
```

Dodaj Konstruktor do tej klasy, która zajmuje wystąpienia skojarzone formantu.Należy podać pole private, aby pomieścić odwołanie do tego wystąpienia.Również dostarczyć pole private do pamięci podręcznej odwołanie do DesignerActionService.Będzie to używane, aby zaktualizować listę.

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;
}

Dodawanie metod i właściwości, które chcesz skojarzyć z tagów inteligentnych.Metody zostanie wykonana, gdy ich odpowiedniego wpisu smart tag jest zaznaczone.Właściwości powinny zawierać sekcje getter, tak aby była wyświetlana ich bieżącą wartość; opcjonalnie posiadają setter sekcje, które używają GetProperties metodę, jeżeli ich wartości mają być edytowalne od odpowiedniego wpisu smart tag.

[!UWAGA]

Podobnie jak w przypadku całej środowiska czasu projektowania, właściwość jest w stanie edytowana tylko wtedy, gdy jeden z typów podstawowych przewidzianym.NET Framework typu mogą być konwertowane na typ podstawowy przez podany TypeConverter, lub gdy niestandardowy UITypeEditor jest dostarczany.

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);
}

Opcjonalnie wdrożenia zastąpiona wersja GetSortedActionItems metody zwracają tablicę DesignerActionItem przypadkach, gdzie każdy element jest skojarzony z właściwości lub metody utworzony w poprzednim kroku.Można to zmienić kolejność elementów, kategoryzowanie ich lub opcjonalnie pokazać je zrobić.Wykaz może również obejmować elementy statyczne, takich jak tytuły logiczne grupy.

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;
}

Aby zaktualizować skojarzonej klasy projektanta do wdrożenia właściwość ActionLists

Zlokalizuj konstruktora klasy dla formantu.Jeśli nie istnieje, Utwórz klasę projektanta i skojarzyć ją z klasy control.Aby uzyskać więcej informacji o projektantach, zobacz Podstawowe klasy projektanta.

Jako technikę optymalizacji, należy dodać pole private typu DesignerActionListCollection.

Private lists As DesignerActionListCollection

private DesignerActionListCollection actionLists;

Dodaj zastąpiona ActionLists właściwość, aby powrócić do nowego wystąpienia programu ColorLabelActionList klasy, który został utworzony wcześniej.

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;
    }
}

Komentarze

Bardziej szczegółowe wyjaśnienie zasługują na kilku obszarach kodu:

Gdy właściwość lub metoda w klasie pochodzących z DesignerActionList zmienia stan skojarzony kontroli, zmiany te nie powinno się dokonywać przez wywołania metody ustawiającej bezpośredniego właściwości składnika.Zamiast tego, należy wprowadzić takie zmiany poprzez odpowiednio utworzone PropertyDescriptor.To podejście pośrednie zapewnia, że interfejsu użytkownika i Cofnij smart tag aktualizacji funkcji działań poprawnie.
Panel smart tag może dynamicznie aktualizować, wywołując DesignerActionUIService.Refresh.Ten proces można dynamicznie zmieniać zawartość panelu smart tag.W tym przykładzie, to tagi inteligentne z zmiana kolorów są warunkowo uwzględnione w zależności od stanu LockColors właściwości.Ta właściwość logiczna jest skojarzony z tagu inteligentnego, również tak autora można zablokować lub odblokować bieżącego zaznaczenia koloru, co najmniej za pośrednictwem menu.
Wpis smart tag typu DesignerActionMethodItem opcjonalnie może być umieszczony w menu skrótów dla formantu skojarzonego przez ustawienie includeAsDesignerVerb parametr do konstruktora true..NET Framework następnie niejawnie tworzy odpowiadającego DesignerVerb i dodaje go do menu skrótów.W tym przykładzie InvertColors elementu jest traktowane w ten sposób.
Tagów inteligentnych są zgrupowane w panelu przez ich Category właściwość, która jest ustawiona w konstruktorze dla każdego elementu.Jeśli ta właściwość nie jest jawnie ustawiona, przypisano domyślną kategorię.Każdy element jest uporządkowane w panelu smart tag kategorii, a następnie w celu ich występowania w DesignerActionItem obiekt array zwrócony przez klasę pochodną DesignerActionList klasy.W tym przykładzie zawiera dwie kategorie: Appearance i Information.

[!UWAGA]

Nie DesignerActionHeaderItem jest dostarczane do drugiej kategorii.
Wpis, który wyświetla tekst statyczny, informacje można zaimplementować za pomocą DesignerActionTextItem lub DesignerActionPropertyItem których skojarzone właściwości zawiera tylko metody ustawiającej.W tym przykładzie użyto były podejścia.

Następne kroki

Po rozpoczęciu integrowanie składnik środowiska czasu projektowania, należy rozważyć, rozwijając swoje wsparcie projektanta.

Dodawanie atrybutów do członków, aby ułatwić komunikację z środowiska czasu projektowania.Aby uzyskać więcej informacji, zobacz Atrybuty w formantach formularzy systemu Windows.
Pisać własne, niestandardowe projektanta.Aby uzyskać więcej informacji, zobacz Porady: tworzenie formantu formularzy Windows wykorzystującego funkcje czasu projektowania.