Procédure pas - à - pas : implémenter un menu contextuel dans une fenêtre Outil

Article
05/17/2015

Cette procédure pas - à - pas place un menu contextuel dans une fenêtre Outil. Un menu contextuel est un menu qui s'affiche lorsqu'un utilisateur clique avec le bouton droit sur un (GUI) élément d'interface utilisateur graphique comme un bouton, une zone de texte, ou un arrière-plan de la fenêtre. Les commandes dans un menu contextuel se comportent de la même manière que des commandes dans les autres menus ou barres d'outils. Pour prendre en charge un menu contextuel, le spécifier dans le fichier du Tableau de commande XML (.vsct) et l'afficher en réponse à le bouton droit de la souris.

Une fenêtre Outil se compose d'un (WPF) contrôle utilisateur WPF (Windows Presentation Foundation) dans une classe personnalisée de la fenêtre Outil qui hérite d' ToolWindowPane.

Cette procédure pas - à - pas montre comment créer un menu contextuel comme un menu de Visual Studio, en déclarant les éléments de menu dans le fichier de .vsct, puis à l'aide de managed package pour les implémenter dans la classe qui définit la fenêtre Outil. Cette approche permet l'accès aux commandes de Visual Studio, aux éléments d'interface, et au modèle objet Automation.

Sinon, si votre menu contextuel ne accédera pas aux fonctionnalités de Visual Studio, vous pouvez utiliser la propriété d' ContextMenu d'un élément XAML dans le contrôle utilisateur. Pour plus d'informations, consultez ContextMenu.

Composants requis

Pour exécuter cette procédure, vous devez installer Kit de développement logiciel Visual Studio 2010.

Notes

Pour plus d'informations sur le kit de développement Visual Studio, consultez Étendre la présentation de Visual Studio.Pour savoir comment télécharger le kit de développement Visual Studio, consultez Visual Studio Extensibility Developer Center sur le site Web MSDN.

Emplacements du modèle de projet de package Visual Studio

Le modèle de projet de package Visual Studio est disponible dans trois emplacements dans la boîte de dialogue de Nouveau projet :

sous Extensibilité Visual Basic. Le langage par défaut du projet est en Visual Basic.
sous Extensibilité c#. Le langage par défaut du projet est c#.
sous L'autre projet types l'extensibilité. Le langage par défaut du projet est en C++.

pour créer le MyTWGradientPackage VSPackage

Créez un package TWShortcutMenunommé par projet Visual Studio.
1. Dans l'Assistant de package, définissez le langage Visual Basic ou en c#.
2. Sélectionnez l'option pour créer une fenêtre Outil.
3. Nommez la fenêtre de modification de couleur de la fenêtre Outil, et affectez à son ID de commande à cmdidColorChange.

Un menu contextuel tel que celui illustré dans cette procédure pas - à - pas permet à l'utilisateur de choisir dans une liste de couleurs utilisées pour remplir arrière-plan de la fenêtre Outil.

ouvrez MyTWGradientPackage.vsct.

Dans l'élément de symboles , dans l'élément de GuidSymbol nommé « guidTWShortcutMenuCmdSet », déclarez le menu contextuel, le groupe de menu contextuel, les options de menu, comme suit.

<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"/>

Juste avant l'élément de groupes , créez un élément de menus puis définissez le menu contextuel dans celui-ci.

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

Un menu contextuel n'a pas de parent car il ne fait pas partie d'un menu ou une barre d'outils.

Dans l'élément d' Groups , affectez à l'élément de groupe qui contient les éléments de menu contextuel, et associez le groupe avec le menu contextuel.
```
<Group guid="guidTWShortcutMenuCmdSet" id="ColorGroup">
  <Parent guid="guidTWShortcutMenuCmdSet" id="ColorMenu"/>
</Group>
```

Dans l'élément de boutons , définissez les différentes commandes qui s'afficheront dans le menu contextuel.

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

ouvrez PkgCmdID.vb ou PkgCmdID.cs.
Ajoutez les définitions pour le menu contextuel et des éléments de menu.
```
public const int ColorMenu = 0x1000;

public const int cmdidRed = 0x102;
public const int cmdidYellow = 0x103;
public const int cmdidBlue = 0x104;
```
Ce sont les mêmes ID de commande qui sont définis dans la section d' Symbols du fichier de TWShortcutMenu.vsct. Le groupe de contexte n'est pas inclus ici car elle est uniquement requis dans le fichier de .vsct.
Enregistrez la solution et générez-la.

cette section implémente le menu contextuel et ses commandes.

ouvrez MyToolWindow.vb ou MyToolWindow.cs.

La classe d' MyToolWindow a accès aux services de commande de menu, mais le contrôle utilisateur qu'elle héberge pas. Les trois étapes suivantes indiquent comment créer une instance du service de commande de menu disponible à partir de la fenêtre Outil au contrôle utilisateur.
Ajouter l'espace de noms System.ComponentModel.Design.
```
using System.ComponentModel.Design;
```
Ajoutez une variable pour contenir l'instance du service de commande de menu.
```
internal OleMenuCommandService mcs;
```
À la fin de le constructeur, ajoutez un appel au service de commande de menu et modifiez l'appel à base.Content, comme suit.
```
mcs = GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
base.Content = new MyControl(this);
```
Appelez le service de commande de menu dans le constructeur s'assurer qu'il est en mémoire chaque fois que la fenêtre Outil est ouverte. Passer une instance de la fenêtre Outil comme paramètre au constructeur de contrôle permet au contrôle pour appeler des membres de la classe de fenêtre Outil.
ouvrez MyControl.xaml.

Ce fichier représente le contrôle utilisateur qui s'affiche dans la fenêtre Outil.
ajoutez un événement d' MouseRightButtonDown à l'élément d' UserControl de niveau supérieur.
```
MouseRightButtonDown="MyToolWindow_MouseRightButtonDown"
```
Cliquez avec le bouton droit sur la déclaration event que vous venez d'ajouter puis cliquez sur Naviguer vers le gestionnaire d'événements.

Cela ouvre MyControl.xaml.vb ou MyControl.xaml.cs et crée un stub pour le gestionnaire d'événements.
en haut de MyControl, ajoutez Microsoft.VisualStudio.Shell et les espaces de noms d' System.ComponentModel.Design .
```
using Microsoft.VisualStudio.Shell;
using System.ComponentModel.Design;
```

Ajoutez un champ de conserver une référence à la fenêtre Outil parente, puis modifiez le constructeur comme suit.

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

Le constructeur prend maintenant l'instance parente de la fenêtre Outil comme paramètre, et l'enregistre dans le domaine de _parent . Il crée ensuite les objets d' CommandID du jeu de commandes GUID et les valeurs d' PkgCmdList qui représentent les commandes de menu que vous avez définies dans le fichier de .vsct. Enfin, il ajoute les commandes au service de commande de menu et affecte des gestionnaires d'événements.

implémentez l'événement d' MyToolWindowMouseRightButtonDown comme suit.

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

Cela crée un objet d' CommandID pour le menu contextuel, identifie l'emplacement du clic de souris, et ouvre le menu contextuel à cet emplacement à l'aide de la méthode d' ShowContextMenu .

Implémentez l'événement, défini dans le constructeur, pour un utilisateur sur un élément de menu.

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

Dans ce cas, une seule méthode gère des événements pour tous les éléments de menu en identifiant CommandID et en définissant la couleur d'arrière-plan en conséquence. Si les éléments de menu avaient contenu des commandes non liées, vous avez créé un gestionnaire d'événements distinct pour chaque commande.

tester les fonctionnalités de fenêtre Outil

Cette section explique comment afficher les fonctionnalités ajoutées dans cette procédure pas - à - pas.

pour tester les fonctionnalités de fenêtre Outil

appuyez sur F5 pour ouvrir une instance expérimentale de Visual Studio.
Dans l'instance expérimentale de, dans le menu d' Afficher , cliquez sur Autres fenêtres puis cliquez sur Fenêtre de modification de couleur. Cela doit afficher la fenêtre Outil.
Cliquez avec le bouton droit sur l'arrière-plan de la fenêtre Outil, quitte le bouton. Un menu contextuel qui contient une liste de couleurs doit s'afficher.
Cliquez sur une couleur dans le menu contextuel. Le menu contextuel doit disparaître, et la couleur d'arrière-plan de la fenêtre Outil doit être modifiée à la couleur sélectionnée.

Étapes suivantes

si vous modifiez le menu contextuel en modifiant le fichier de .vsct, vous devez régénérer le projet de MyTWGradientPackageUI. Faisant cela force le fichier de .vsct à recompiler et la DLL satellite la reconnexion avec les modifications que vous avez apportées au fichier de .vsct.

Voir aussi

Autres ressources

Procédures pas - à - pas pour les commandes, de menus, et les barres d'outils

commandes, menus, et barres d'outils

services

Partager via

Procédure pas - à - pas : implémenter un menu contextuel dans une fenêtre Outil

Composants requis

Emplacements du modèle de projet de package Visual Studio

Créer le package de menu contextuel de la fenêtre Outil

pour créer le MyTWGradientPackage VSPackage

spécifier le menu contextuel

Pour créer le menu contextuel

implémenter le menu contextuel

pour implémenter le menu contextuel

tester les fonctionnalités de fenêtre Outil

pour tester les fonctionnalités de fenêtre Outil

Étapes suivantes

Voir aussi

Autres ressources

Ressources supplémentaires