Comment : Créer des menus, des sous-menus, et les menus contextuels

Article
05/17/2015

Pour ajouter un menu à l'environnement de développement intégré Visual (IDE) Studio, un VSPackage doit utiliser l'architecture de Kit de développement logiciel Visual Studio pour les menus du groupe de commandes. Les menus du groupe de commandes activent des commandes d'être réutilisé et partagé entre les composants et l'environnement. Pour plus d'informations sur les menus du groupe de commandes, consultez Comment les VSPackages ajoutent des éléments de l'interface utilisateur à l'IDE.

Pour les VSPackages, des menus sont définis dans la section de menus d'un fichier de .vsct. Un fichier de .vsct définit les menus et les barres d'outils, les groupes, les commandes et. Une commande est tout utilisateur clique sur pour exécuter une fonction. Un groupe est un conteneur pour les commandes et des menus. Un menu est un conteneur pour les groupes. Par conséquent, pour créer un menu de base, vous devez créer un menu, d'un groupe de commandes, et au moins une commande.

Il existe trois méthodes de base qui un menu peut afficher dans Visual Studio, comme suit :

Comme menu dans la barre de menu principal.
comme sous-menu d'un autre menu.
Comme menu contextuel (généralement affichées par un bouton droit).

Cette rubrique indique comment créer chaque genre de menu. Les procédures pas - à - pas suivantes montrent également comment procéder :

Dans votre projet, double-cliquez sur le fichier de .vsct pour l'ouvrir dans l'éditeur.

Si votre projet n'a pas de fichier de .vsct, ajoutez -en un. Si vous créez un package à l'aide de le modèle de package Visual Studio, sélectionnez Commande de menu; cela génère un fichier de .vsct.
dans la section d' Symbols , recherchez l'élément de GuidSymbol qui contient les groupes et les commandes.
Créez un élément d' IDSymbol pour chaque menu, groupe, ou commande que vous souhaitez ajouter, comme indiqué dans l'exemple suivant.
```
<GuidSymbol name="guidButtonGroupCmdSet" value="{f69209e9-975a-4543-821d-1f4a2c52d737}">
  <IDSymbol name="MyMenuGroup" value="0x1020" />
  <IDSymbol name="cmdidMyCommand" value="0x0100" />
</GuidSymbol>
```
Les attributs d' name des éléments d' GuidSymbol et d' IDSymbol fournissent un GUID : Paires d'ID pour chaque nouveau menu, groupe, ou commande. GUID représente un jeu de commandes qui est défini pour votre VSPackage. Vous pouvez définir plusieurs jeux de commandes. Chaque paire GUID : Les paires d'ID doivent être uniques.
définissez le nouveau menu dans la section d' Menus , comme suit :
1. Définissez les champs d' guid et d' id pour correspondre à un GUID : ID du nouveau menu.
2. Définissez l'attribut priority.
  
  l'attribut d' priority est utilisé par le .vsct pour déterminer l'emplacement du menu parmi les autres objets au groupe parent.
  
  Les menus qui ont des valeurs de priorité moindre sont affichés avant les menus qui ont des valeurs plus élevée. Les valeurs en double élevée sont autorisées, mais la position relative des menus qui ont la priorité égale est déterminée par l'ordre dans lequel les VSPackages sont traités au moment de l'exécution, et laquelle la commande ne peut pas être prédéterminée. En omettant les jeux d'attributs d' priority sa valeur à 0.
  
  Ne définissez pas une priorité pour afficher un menu contextuel, car son positionnement est déterminé par le code qui l'appelle.
3. Pour les menus et des sous-menus, affectez à l'attribut d' type à menu, qui décrit un menu typique. Pour les menus contextuels, affectez à l'attribut d' type à contexte.
  
  Pour obtenir les descriptions des autres types valides de menu, tels que les barres d'outils et des contrôleurs de menu, consultez le Menu, élément.
4. Dans la définition de menu, créez une section de chaînes qui contient un élément de ButtonText pour contenir le nom du menu tel qu'il apparaît dans l'IDE, et d'un élément de CommandName pour contenir le nom de la commande utilisée pour accéder au menu dans la fenêtre de Commande .
  
  Si la chaîne de texte du bouton inclut «&« , l'utilisateur peut ouvrir le menu en appuyant sur la touche ALT le caractère qui suit immédiatement »&».
5. Ajoutez les balises de commande, si nécessaire, pour modifier l'apparence et le comportement du menu. Pour ce faire, ajoutez un élément de CommandFlag dans la définition de menu. Pour plus d'informations, consultez CommandFlag, élément.
définissez le parent du menu. Pour afficher un menu ou un sous-menu standard, procédez comme suit dans l'une des façons suivantes, selon votre conception :
- Dans l'élément d' Menu , créez un élément de parent et définissez ses champs d' guid et d' id à un GUID : ID du groupe qui hébergera le menu, également connu sous le nom de groupe parent principal. Le groupe parent peut être un groupe que vous avez créé dans la section de Symbols , un groupe d'un autre package, ou à un groupe de l'IDE. Par exemple, ajouter votre menu dans la barre de menu de niveau supérieur de l'IDE, vers le menu pour Outils , définit le parent au guidSHLMainMenu : IDG_VS_MM_TOOLSADDINS.
  
  L'exemple suivant illustre un menu qui s'affiche dans la barre de menus de Visual Studio.
```
<Menu guid="guidTopLevelMenuCmdSet"
id="TopLevelMenu" priority="0x700" type="Menu">
  <Parent guid="guidSHLMainMenu"
          id="IDG_VS_MM_TOOLSADDINS" />
  <Strings>
    <ButtonText>TestMenu</ButtonText>
    <CommandName>TestMenu</CommandName>
  </Strings>
</Menu>
```
- Vous pouvez omettre l'élément d' Parent si le menu doit être positionné à l'aide de positionnement de commande. Créez une section de CommandPlacements avant la section d' Symbols , puis ajoutez un élément de CommandPlacement qui a un GUID : ID du menu, d'une priorité, et d'un parent, comme indiqué dans l'exemple suivant.
```
<CommandPlacements>
  <CommandPlacement guid="guidButtonGroupCmdSet" id="cmdidMyCommand" priority="0x105">
    <Parent guid="guidButtonGroupCmdSet" id="MyMenuGroup" />
  </CommandPlacement>
</CommandPlacements>
```
  Création de plusieurs positionnements de commande qui ont la même paire GUID : L'ID et ont des causes de parents un menu à apparaître dans plusieurs emplacements. Pour plus d'informations, consultez CommandPlacements, élément.
Un menu standard doit avoir un groupe dans la barre de menus de Visual Studio comme son parent. pour un sous-menu, le parent doit être un groupe sur un autre menu (bien que le menu parent peut être une barre d'outils ou tout autre type de menu). Pour qu'un menu ou un sous-menu affiché, il doit héberger un groupe qui contient au moins une commande active, ou fait définir la balise de commande d' AlwaysCreate .

Les menus contextuels n'ont pas les parents ou les positionnements de commande. Au lieu de cela, ils doivent être activés dans le code. En général, un menu contextuel est activé en réponse à un clic avec le bouton droit sur une surface. l'exemple suivant définit un menu contextuel.
```
<Menu guid="guidButtonGroupCmdSet" id="ShortcutMenu"
      type="Context">
  <Strings>
    <ButtonText>Shortcut Menu</ButtonText>
    <CommandName>ShortcutMenu</CommandName>
  </Strings>
</Menu>
```
dans la section de groupes , créez un élément de groupe pour contenir les commandes qui sont d'apparaître sur votre menu. La section d' Symbols doit inclure une entrée qui a la même paire GUID : ID comme nouvel élément d' Group .
1. Définissez la priorité du groupe afin qu'il apparaisse où vous le souhaitez dans votre menu.
  
  Les limites de chaque groupe dans le menu apparaissent comme lignes horizontales.
2. Définissez le parent de ce nouveau groupe à un GUID : ID du menu que vous avez créé. Cela met le groupe de commandes et du menu.
Le groupe dans l'exemple suivant apparaît dans le menu de niveau supérieur qui a été présenté dans un exemple précédent.
```
 <Group guid="guidTopLevelMenuCmdSet" id="MyMenuGroup"
priority="0x0600">
   <Parent guid="guidTopLevelMenuCmdSet" id="TopLevelMenu"/>
 </Group>
```
En plaçant le menu qui est indiqué dans l'exemple suivant à un groupe dans le menu de niveau supérieur, elle devient un sous-menu.
```
<Menu guid="guidTopLevelMenuCmdSet" id="SubMenu"
priority="0x0100" type="Menu">
  <Parent guid="guidTopLevelMenuCmdSet" id="MyMenuGroup"/>
  <Strings>
    <ButtonText>Sub Menu</ButtonText>
    <CommandName>Sub Menu</CommandName>
  </Strings>
</Menu>
```
Ajoutez les commandes du menu en créant des entrées de commande dans la section de boutons et définissez le parent de chacun à un GUID : ID du groupe. Chaque élément de bouton doit avoir une paire GUID : ID qui correspond à une entrée dans la section d' Symbols .

Utilisez l'attribut de priority de chaque entrée de bouton pour spécifier l'ordre dans lequel les commandes apparaissent au groupe.

L'exemple suivant définit une commande qui apparaîtra dans le menu de niveau supérieur.
```
<Button guid="guidTopLevelMenuCmdSet" id="cmdidTestCommand" priority="0x0100" type="Button">
  <Parent guid="guidTopLevelMenuCmdSet" id="MyMenuGroup" />
  <Icon guid="guidImages" id="bmpPic1" />
  <Strings>
    <CommandName>cmdidTestCommand</CommandName>
    <ButtonText>Test Command</ButtonText>
  </Strings>
</Button>
```
Pour plus d'informations sur les boutons et des éléments de menu, consultez le Button, élément.

Pour plus d'informations sur l'implémentation des commandes de menu dans le code, consultez Comment : Créer et gérer des commandes dans les VSPackages (c#) ou les procédures pas - à - pas indiquées précédemment dans cette rubrique.

Obtenez un GUID : ID du menu contextuel. Par défaut, le modèle de package crée une classe d' GuidList dans un fichier de PkgCmdID.cs pour contenir le GUID du jeu de commandes. Le modèle crée également une classe d' PkgCmdIdList dans un fichier de PkgCmdId.cs pour stocker les valeurs d'ID d'entier des commandes qui sont déclarées dans le modèle. Les menus contextuels et toutes les commandes supplémentaires doivent être déclarés une fois le modèle ne soit terminée. L'exemple suivant illustre ces déclarations.
```
static class PkgCmdIDList
{

    public const uint cmdidColorChange =    0x101;
    public const int ColorMenu = 0x1000;

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

};
```
Cette étape peut être omis si le GUID et les valeurs d'ID seront utilisés directement. Toutefois, nous vous recommandons de définir les valeurs ici pour la lisibilité.
Attachement à un gestionnaire d'événements. En général, les menus contextuels s'attachent au bouton droit d'une surface, comme indiqué dans l'exemple suivant.
```
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);
    }
}
```
La méthode d' PointToScreen convertit la position de clic, relatif au contrôle, à une position d'écran. la méthode d' ShowContextMenu affiche le menu contextuel.

Le fichier qui contient le gestionnaire d'événements doit inclure l'espace de noms d' System.ComponentModel.Design pour accéder à la classe d' OleMenuCommandService , et l'espace de noms d' Microsoft.VisualStudio.Shell pour accéder à l'interface d' IMenuCommandService .
```
using Microsoft.VisualStudio.Shell;
using System.ComponentModel.Design;
```

Voir aussi

Partager via

Comment : Créer des menus, des sous-menus, et les menus contextuels

pour créer un menu, un sous-menu, ou un menu contextuel

pour activer un menu contextuel

Voir aussi

Tâches

Concepts

Autres ressources

Ressources supplémentaires