Freigeben über


Exemplarische Vorgehensweise: Ein Kontextmenü in einem Toolfenster implementieren

Diese exemplarische Vorgehensweise setzt ein Kontextmenü an. B. ein Toolfenster. Ein Kontextmenü wird ein Menü angezeigt, das angezeigt wird, wenn ein Benutzer auf ein Element der grafischen Benutzeroberfläche (GUI), z. B. eine Schaltfläche, ein Textfeld oder ein Fenster im Hintergrund mit der rechten Maustaste klickt. Befehle in einem Kontextmenü verhalten sich wie andere Befehle in Menüs oder Symbolleisten. Um ein Kontextmenü zu unterstützen, geben Sie es in der XML-Befehls-Tabelle (.vsct) und zeigen Sie es als Reaktion auf den der rechten Maustaste auf den Mauszeiger an.

Ein Toolfenster besteht aus einem Benutzersteuerelement ein Windows Presentation Foundation (WPF) in einer benutzerdefinierten Tools fensterklasse, die von ToolWindowPaneerbt.

In dieser exemplarischen Vorgehensweise wird erläutert, wie ein Kontextmenü als Visual Studio-Menü mithilfe von Menüelementen in der .vsct-Datei und mit dem verwalteten Paketframeworks deklariert, um sie anschließend in der Klasse implementieren, die das Toolfenster definiert. Diese Vorgehensweise erleichtert den Zugriff auf Visual Studio-Befehlen, TO Benutzeroberflächenelementen und zum Automatisierungsobjektmodell.

Wenn das Kontextmenü nicht Visual Studio-Funktionalität zugreift, können Sie die ContextMenu-Eigenschaft eines XAML-Elements im Benutzersteuerelement verwenden. Weitere Informationen finden Sie unter ContextMenu.

Vorbereitungsmaßnahmen

Zum Abschließen dieser exemplarischen Vorgehensweise müssen Sie Visual Studio 2010 SDKinstallieren.

Hinweis

Weitere Informationen über das Visual Studio-SDK finden Sie unter Erweitern von Visual Studio Overview.Um herauszufinden finden Sie unter wie das Visual Studio-SDK, auf Visual Studio Extensibility Developer Center der MSDN-Website herunterlädt.

Speicherorte für die Visual Studio-Paket-Projektvorlage

Die Visual Studio-Paket Projektvorlage ist in drei Positionen im Dialogfeld Neues Projekt verfügbar:

  1. Die Visual Basic-Erweiterbarkeit. Die Standardsprache des Projekts ist Visual Basic.

  2. Die C#-Erweiterbarkeit. Die Standardsprache ist C# des Projekts.

  3. Die Andere Projekttypen/Erweiterungen. Die Standardsprache des Projekts ist C++.

Das Erstellen Tool-Fenster-Kontextmenü-Paket

So erstellen MyTWGradientPackage VSPackage

  • Erstellen Sie ein Visual Studio-Paket Projekt mit dem Namen TWShortcutMenu.

    1. Geben Sie im Assistenten Paket Legen Sie die Sprache in Visual Basic oder C# fest.

    2. Wählen Sie die Option aus, um ein Toolfenster zu erstellen.

    3. Nennen Sie das Toolfenster Farben-Änderungs-Fenster, und legen Sie die Befehls-ID an cmdidColorChangefest.

Das Kontextmenü angeben

Ein Kontextmenü wie in dieser exemplarischen Vorgehensweise gezeigt wird, kann der Benutzer, der aus einer Liste mit Farben ausgewählt ist, die verwendet werden, um den Hintergrund des Toolfensters auszufüllen.

So erstellen Sie das Kontextmenü

  1. Öffnen Sie MyTWGradientPackage.vsct.

  2. Im Symbole-Element im GuidSymbol-Element mit dem Namen „guidTWShortcutMenuCmdSet“ deklarieren Sie das Kontextmenü für die Gruppe Menüoptionen und die Kontextmenüs wie folgt.

    <IDSymbol name="ColorMenu" value="0x1000"/>
    <IDSymbol name="ColorGroup" value="0x1100"/>
    <IDSymbol name="cmdidRed" value="0x102"/>
    <IDSymbol name="cmdidYellow" value="0x103"/>
    <IDSymbol name="cmdidBlue" value="0x104"/>
    
  3. Kurz vor dem Gruppen-Element erstellen Sie ein Menüs-Element, und definieren Sie anschließend das Kontextmenü enthält.

    <Menus>
      <Menu guid="guidTWShortcutMenuCmdSet" id="ColorMenu" type="Context">
        <Strings>
          <ButtonText>Color change</ButtonText>
          <CommandName>ColorChange</CommandName>
        </Strings>
      </Menu>
    </Menus>
    

    Ein Kontextmenü wurde kein übergeordnetes Element vorhanden, da es nicht zu einem Menü oder auf der Symbolleiste darstellt.

  4. Im Groups-Element definieren Sie das Gruppe-Element, das die Kontextmenüelemente enthält, und ordnen Sie die Gruppe mit dem Kontextmenü.

    <Group guid="guidTWShortcutMenuCmdSet" id="ColorGroup">
      <Parent guid="guidTWShortcutMenuCmdSet" id="ColorMenu"/>
    </Group>
    
  5. Im Schaltflächen-Element definieren Sie die einzelnen Befehle, die auf dem Kontextmenü angezeigt werden.

    <Button guid="guidTWShortcutMenuCmdSet" id="cmdidRed" priority="1" type="Button">
      <Parent guid="guidTWShortcutMenuCmdSet" id="ColorGroup" />
      <Strings>
        <ButtonText>Red</ButtonText>
      </Strings>
    </Button>
    
    <Button guid="guidTWShortcutMenuCmdSet" id="cmdidYellow" priority="3" type="Button">
      <Parent guid="guidTWShortcutMenuCmdSet" id="ColorGroup" />
      <Strings>
        <ButtonText>Yellow</ButtonText>
      </Strings>
    </Button>
    
    <Button guid="guidTWShortcutMenuCmdSet" id="cmdidBlue" priority="5" type="Button">
      <Parent guid="guidTWShortcutMenuCmdSet" id="ColorGroup" />
      <Strings>
        <ButtonText>Blue</ButtonText>
      </Strings>
    </Button>
    
  6. Öffnen Sie PkgCmdID.vb oder PkgCmdID.cs.

  7. Fügen Sie die Definitionen für das Kontextmenü, und die Menüelemente hinzu.

    public const int ColorMenu = 0x1000;
    
    public const int cmdidRed = 0x102;
    public const int cmdidYellow = 0x103;
    public const int cmdidBlue = 0x104;
    

    Hierbei handelt es sich um die gleiche Befehls-IDs, die im Symbols-Abschnitt der TWShortcutMenu.vsct-Datei definiert sind. Die Gruppe Kontext wird hier nicht eingeschlossen, da sie in der .vsct-Datei nur erforderlich ist.

  8. Speichern und erstellen Sie die Lösung.

Das Kontextmenü implementieren

In diesem Abschnitt des Kontextmenüs implementiert und die zugehörigen Befehle.

So implementieren Sie das Kontextmenü

  1. Öffnen Sie MyToolWindow.vb oder MyToolWindow.cs.

    Die MyToolWindow-Klasse verfügt über Vollzugriff auf den Menübefehl Dienste, aber das Benutzersteuerelement hostet, führt es die nicht. Die folgenden drei Schritte zeigen, wie eine Instanz aus dem Menübefehlsdienst macht, der vom Toolfenster zum Benutzersteuerelement verfügbar ist.

  2. Fügen Sie den System.ComponentModel.Design-Namespace hinzu.

    using System.ComponentModel.Design;
    
  3. Fügen Sie eine Variable hinzu, um die Instanz des Menübefehls diensts enthält.

    internal OleMenuCommandService mcs;
    
  4. Am Ende des Konstruktors, fügen Sie dem Menübefehlsdienst einen Aufruf hinzu, und ändern Sie den Aufruf von base.Contentwie folgt.

    mcs = GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
    base.Content = new MyControl(this);
    

    Das Aufrufen des Menübefehls diensts im Konstruktor wird sichergestellt, dass sie im Arbeitsspeicher ist, wenn das Toolfenster geöffnet ist. Das Übergeben einer Instanz des Toolfensters Steuerelements als Parameter für den Konstruktor ermöglicht das Steuerelement, um Aufrufe von Mitgliedern der fensterklasse Tool ausführen.

  5. Öffnen Sie MyControl.xaml.

    Diese Datei stellt das Benutzersteuerelement dar, das im Toolfenster angezeigt wird.

  6. Fügen Sie ein MouseRightButtonDown dem Ereignis UserControl-Element der höchsten Ebene hinzufügen.

    MouseRightButtonDown="MyToolWindow_MouseRightButtonDown"
    
  7. Klicken Sie mit der rechten Maustaste auf die Ereignisdeklaration, die Sie soeben hinzugefügt haben, und klicken Sie dann auf Zu Ereignishandler navigieren.

    Dadurch wird MyControl.xaml.vb oder MyControl.xaml.cs und erstellt einen Stub für den Ereignishandler.

  8. Fügen Sie am oberen Rand MyControl Microsoft.VisualStudio.Shell und die System.ComponentModel.Design-Namespaces hinzu.

    using Microsoft.VisualStudio.Shell;
    using System.ComponentModel.Design;
    
  9. Fügen Sie ein Feld hinzu, um einen Verweis auf das übergeordnete Toolfenster angehalten, und ändern Sie den Konstruktor wie folgt.

    MyToolWindow _parent;
    public MyControl(MyToolWindow parent)
    {
        InitializeComponent();
        _parent = parent;
    
        OleMenuCommandService mcs = this._parent.mcs;
        if (null != mcs)
        {
            // Create an alias for the command set guid.
            Guid g = GuidList.guidTWShortcutMenuCmdSet;
    
            // Create the command IDs. 
            var red = new CommandID(g, PkgCmdIDList.cmdidRed);
            var yellow = new CommandID(g, PkgCmdIDList.cmdidYellow);
            var blue = new CommandID(g, PkgCmdIDList.cmdidBlue);
    
            // Add a command for each command ID.
            mcs.AddCommand(new MenuCommand(ChangeColor, red));
            mcs.AddCommand(new MenuCommand(ChangeColor, yellow));
            mcs.AddCommand(new MenuCommand(ChangeColor, blue));
        }
    }
    

    Der Konstruktor akzeptiert jetzt die Elemente als Parameter für die Instanz Toolfenster und speichert sie auf dem _parent Feld. Es erstellt dann CommandID-Objekte aus dem Befehl Menge GUID und die PkgCmdList-Werte, die die Menübefehle darstellen, die Sie in der .vsct-Datei definiert haben. Dauern Sie die Befehle, wird dem Menübefehlsdienst hinzu und weist Ereignishandler zu.

  10. Implementieren Sie das MyToolWindowMouseRightButtonDown-Ereignis wie folgt.

    private void MyToolWindow_MouseRightButtonDown(object sender, MouseButtonEventArgs e)
    {
        OleMenuCommandService mcs = this._parent.mcs;
        if (null != mcs)
        {
            CommandID menuID = new CommandID(
                GuidList.guidTWShortcutMenuCmdSet,
                PkgCmdIDList.ColorMenu);
            Point p = this.PointToScreen(e.GetPosition(this));
            mcs.ShowContextMenu(menuID, (int)p.X, (int)p.Y);
        }
    }
    

    Dadurch wird ein CommandID-Objekt für das Kontextmenü, identifiziert den Speicherort des Mausklicks und öffnet das Kontextmenü an diesem Speicherort, indem die ShowContextMenu-Methode.

  11. Implementieren Sie das Ereignis, das im Konstruktor definiert ist, für einen Mausklick in einem Menüelement.

            private void ChangeColor(object sender, EventArgs e )
            {
                var mc = sender as MenuCommand;
    
                switch (mc.CommandID.ID)
                {
                    case PkgCmdIDList.cmdidRed:
                        MyToolWindow.Background = Brushes.Red;
                        break;
                    case PkgCmdIDList.cmdidYellow:
                        MyToolWindow.Background = Brushes.Yellow;
                        break;
                    case PkgCmdIDList.cmdidBlue:
                        MyToolWindow.Background = Brushes.Blue;
                        break;
                }
            }
    

    In diesem Fall behandelt nur eine Methode Ereignisse für alle Menüelemente, indem sie entsprechend CommandID identifiziert und die Hintergrundfarbe festlegen. Wenn die Menüelemente nicht verknüpfte Befehle enthalten haben, würden Sie einen separaten Ereignishandler für jeden Befehl erstellt haben.

Die Tool-Fenster-Funktionen testen

In diesem Abschnitt wird erläutert, wie die Funktionen dargestellt, die in dieser exemplarischen Vorgehensweise hinzugefügt wurden.

So testen Sie die Toolfenster Funktionen

  1. Drücken Sie F5, um eine experimentelle Instanz von Visual Studiozu öffnen.

  2. Klicken Sie in der experimentellen Instanz im Menü Ansicht auf Weitere Fenster , und klicken Sie dann auf Farbänderungsfenster. Auf diese Weise muss das Toolfenster an.

  3. Klicken Sie mit der rechten Maustaste auf die Toolfenster im Hintergrund, von der Schaltfläche weg. Ein Kontextmenü, das eine Liste von Farben aufweist, sollte angezeigt werden.

  4. Klicken Sie im Kontextmenü auf eine Farbe. Das Kontextmenü wird ausgeblendet, und die Toolfenster verwendeten Hintergrundfarbe zur ausgewählten Farbe geändert werden sollte.

Nächste Schritte

Wenn Sie das Kontextmenü ändern, indem Sie die .vsct-Datei ändern, müssen Sie das MyTWGradientPackageUI-Projekt neu erstellen. Dies erzwingt die zu .vsct-Datei neu kompiliert und mit den Änderungen neu verknüpft werden soll Satelitte DLLs, die Sie zur .vsct-Datei vorgenommen haben.

Siehe auch

Weitere Ressourcen

Exemplarische Vorgehensweisen für Befehle, Menüs und Symbolleisten

Befehle, Menüs und Symbolleisten

Dienste