Ajouter un menu contextuel dans une fenêtre outilAdd a shortcut menu in a tool window

Cette procédure pas à pas place un menu contextuel dans une fenêtre outil.This walkthrough puts a shortcut menu in a tool window. Un menu contextuel est un menu qui s’affiche quand un utilisateur clique sur un bouton, une zone de texte ou un arrière-plan de la fenêtre.A shortcut menu is a menu that appears when a user right-clicks a button, text box, or window background. Commandes du menu contextuel comportent comme des commandes sur d’autres menus ou les barres d’outils.Commands on a shortcut menu behave the same as commands on other menus or toolbars. Pour prendre en charge un menu contextuel, spécifiez-le dans le .vsct de fichiers et les afficher en réponse à un clic droit de la souris.To support a shortcut menu, specify it in the .vsct file and display it in response to the right-click of the mouse.

Une fenêtre outil est constitué d’un contrôle utilisateur WPF dans une classe de fenêtre Outil personnalisée qui hérite de ToolWindowPane.A tool window consists of a WPF user control in a custom tool window class that inherits from ToolWindowPane.

Cette procédure pas à pas montre comment créer un menu contextuel sous forme de menu Visual Studio, en déclarant les éléments de menu dans le .vsct de fichiers et ensuite à l’aide de Managed Package Framework pour les implémenter dans la classe qui définit la fenêtre outil.This walkthrough shows how to create a shortcut menu as a Visual Studio menu, by declaring menu items in the .vsct file, and then using the Managed Package Framework to implement them in the class that defines the tool window. Cette approche facilite l’accès aux commandes de Visual Studio, les éléments d’interface utilisateur et le modèle objet Automation.This approach facilitates access to Visual Studio commands, UI elements, and the Automation object model.

Si votre menu contextuel n’accède pas aux fonctionnalités de Visual Studio, vous pouvez également utiliser le ContextMenu propriété d’un élément XAML dans le contrôle utilisateur.Alternatively, if your shortcut menu will not access Visual Studio functionality, you can use the ContextMenu property of a XAML element in the user control. Pour plus d’informations, consultez ContextMenu.For more information, see ContextMenu.

PrérequisPrerequisites

À partir de Visual Studio 2015, vous n’installez pas le Kit de développement logiciel Visual Studio à partir du centre de téléchargement.Starting in Visual Studio 2015, you do not install the Visual Studio SDK from the download center. Il est inclus comme fonctionnalité facultative dans le programme d’installation de Visual Studio.It is included as an optional feature in Visual Studio setup. Vous pouvez également installer le kit SDK VS par la suite.You can also install the VS SDK later on. Pour plus d’informations, consultez l’installation de Visual Studio SDK.For more information, see Installing the Visual Studio SDK.

Créer le package de menu de raccourci de fenêtre outilCreate the tool window shortcut menu package

  1. Créez un projet VSIX nommé TWShortcutMenu et ajoutez un modèle de fenêtre outil nommé menu de raccourcis à celui-ci.Create a VSIX project named TWShortcutMenu and add a tool window template named ShortcutMenu to it. Pour plus d’informations sur la création d’une fenêtre outil, consultez créer une extension avec une fenêtre outil.For more information about creating a tool window, see Create an extension with a tool window.

En spécifiant le menu contextuelSpecifying the shortcut menu

Un menu contextuel comme celle illustrée dans cette procédure pas à pas permet à l’utilisateur sélectionner dans une liste de couleurs qui sont utilisées pour remplir l’arrière-plan de la fenêtre outil.A shortcut menu such as the one shown in this walkthrough lets the user select from a list of colors that are used to fill the background of the tool window.

  1. Dans ShortcutMenuPackage.vsct, recherchez dans l’élément GuidSymbol nommé guidShortcutMenuPackageCmdSet et déclarez le menu contextuel, groupe de menus contextuels et les options de menu.In ShortcutMenuPackage.vsct, find in the GuidSymbol element named guidShortcutMenuPackageCmdSet, and declare the shortcut menu, shortcut menu group, and menu options. L’élément GuidSymbol doit maintenant ressembler à ceci :The GuidSymbol element should now look like this:

    <GuidSymbol name="guidShortcutMenuPackageCmdSet" value="{00000000-0000-0000-0000-0000}"> // your GUID here  
        <IDSymbol name="ShortcutMenuCommandId" value="0x0100" />  
        <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"/>  
    </GuidSymbol>  
    
  2. Juste avant l’élément de boutons, créer un élément de Menus, puis définissez le menu contextuel qu’il contient.Just before the Buttons element, create a Menus element and then define the shortcut menu in it.

    <Menus>  
      <Menu guid="guidShortcutMenuPackageCmdSet" 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 n’est pas partie d’un menu ou une barre d’outils.A shortcut menu does not have a parent because it is not part of a menu or toolbar.

  3. Créer un élément de groupes avec un élément de groupe qui contient les éléments de menu contextuel et associer le groupe avec le menu contextuel.Create a Groups element with a Group element that contains the shortcut menu items, and associate the group with the shortcut menu.

    <Groups>  
        <Group guid="guidShortcutMenuPackageCmdSet" id="ColorGroup">  
            <Parent guid="guidShortcutMenuPackageCmdSet" id="ColorMenu"/>  
        </Group>  
    </Groups>  
    
  4. Dans l’élément de boutons, définissez les commandes individuelles qui apparaîtront dans le menu contextuel.In the Buttons element, define the individual commands that will appear on the shortcut menu. L’élément de boutons doit ressembler à ceci :The Buttons element should look like this:

    <Buttons>  
        <Button guid="guidShortcutMenuPackageCmdSet" id="ShortcutMenuCommandId" priority="0x0100" type="Button">  
            <Parent guid="guidSHLMainMenu" id="IDG_VS_WNDO_OTRWNDWS1"/>  
            <Icon guid="guidImages" id="bmpPic1" />  
            <Strings>  
                <ButtonText>ShortcutMenu</ButtonText>  
            </Strings>  
        </Button>  
    
        <Button guid="guidShortcutMenuPackageCmdSet" id="cmdidRed" priority="1" type="Button">  
            <Parent guid="guidShortcutMenuPackageCmdSet" id="ColorGroup" />  
            <Strings>  
                <ButtonText>Red</ButtonText>  
            </Strings>  
        </Button>  
    
        <Button guid="guidShortcutMenuPackageCmdSet" id="cmdidYellow" priority="3" type="Button">  
            <Parent guid="guidShortcutMenuPackageCmdSet" id="ColorGroup" />  
            <Strings>  
                <ButtonText>Yellow</ButtonText>  
            </Strings>  
        </Button>  
    
        <Button guid="guidShortcutMenuPackageCmdSet" id="cmdidBlue" priority="5" type="Button">  
            <Parent guid="guidShortcutMenuPackageCmdSet" id="ColorGroup" />  
            <Strings>  
                <ButtonText>Blue</ButtonText>  
            </Strings>  
        </Button>  
    </Buttons>  
    
  5. Dans ShortcutMenuCommand.cs, ajoutez les définitions pour la commande définie le GUID, le menu contextuel et les éléments de menu.In ShortcutMenuCommand.cs, add the definitions for the command set GUID, the shortcut menu, and the menu items.

    public const string guidShortcutMenuPackageCmdSet = "00000000-0000-0000-0000-00000000"; // your GUID will differ  
    public const int ColorMenu = 0x1000;  
    public const int cmdidRed = 0x102;  
    public const int cmdidYellow = 0x103;  
    public const int cmdidBlue = 0x104;  
    

    Il s’agit des même ID de commande qui sont définies dans la section Symbols de la ShortcutMenuPackage.vsct fichier.These are the same command IDs that are defined in the Symbols section of the ShortcutMenuPackage.vsct file. Le groupe de contexte n’est pas inclus ici, car elle est requise uniquement dans le .vsct fichier.The context group is not included here because it is required only in the .vsct file.

Implémenter le menu contextuelImplementing the shortcut menu

Cette section met en œuvre le menu contextuel et ses commandes.This section implements the shortcut menu and its commands.

  1. Dans ShortcutMenu.cs, la fenêtre outil peut obtenir le service de commande de menu, mais pas le contrôle qu’il contient.In ShortcutMenu.cs, the tool window can get the menu command service, but the control it contains cannot. Les étapes suivantes montrent comment rendre le service de commande de menu disponibles pour le contrôle utilisateur.The following steps show how to make the menu command service available to the user control.

  2. Dans ShortcutMenu.cs, ajoutez le code suivant à l’aide d’instructions :In ShortcutMenu.cs, add the following using statements:

    using Microsoft.VisualStudio.Shell;  
    using System.ComponentModel.Design;  
    
  3. Substituer la méthode Initialize() de la fenêtre outil pour obtenir le service de commande de menu et ajouter le contrôle, en passant le service de commande de menu au constructeur :Override the tool window's Initialize() method to get the menu command service and add the control, passing the menu command service to the constructor:

    protected override void Initialize()  
    {  
        var commandService = (OleMenuCommandService)GetService(typeof(IMenuCommandService));  
        Content = new ShortcutMenuControl(commandService);  
    }  
    
  4. Dans le constructeur de fenêtre outil du menu de raccourcis, supprimez la ligne qui ajoute le contrôle.In the ShortcutMenu tool window constructor, remove the line that adds the control. Le constructeur doit maintenant ressembler à ceci :The constructor should now look like this:

    public ShortcutMenu() : base(null)  
    {  
        this.Caption = "ShortcutMenu";  
        this.BitmapResourceID = 301;  
        this.BitmapIndex = 1;  
    }  
    
  5. Dans ShortcutMenuControl.xaml.cs, ajoutez un champ privé pour le service de commande de menu et modifiez le constructeur du contrôle pour tirer le service de commande de menu.In ShortcutMenuControl.xaml.cs, add a private field for the menu command service and change the control constructor to take the menu command service. Puis utilisez le service de commande de menu pour ajouter les commandes de menu contextuel.Then use the menu command service to add the context menu commands. Le constructeur ShortcutMenuControl doit maintenant ressembler à ce qui suit.The ShortcutMenuControl constructor should now look like the following code. Le Gestionnaire de commandes est défini ultérieurement.The command handler will be defined later.

    public ShortcutMenuControl(OleMenuCommandService service)  
    {  
        this.InitializeComponent();  
        commandService = service;  
    
        if (null !=commandService)  
        {  
            // Create an alias for the command set guid.  
            Guid guid = new Guid(ShortcutMenuCommand.guidShortcutMenuPackageCmdSet);  
    
            // Create the command IDs.   
            var red = new CommandID(guid, ShortcutMenuCommand.cmdidRed);  
            var yellow = new CommandID(guid, ShortcutMenuCommand.cmdidYellow);  
            var blue = new CommandID(guid, ShortcutMenuCommand.cmdidBlue);  
    
            // Add a command for each command ID.  
            commandService.AddCommand(new MenuCommand(ChangeColor, red));  
            commandService.AddCommand(new MenuCommand(ChangeColor, yellow));  
            commandService.AddCommand(new MenuCommand(ChangeColor, blue));  
        }  
    }  
    
  6. Dans ShortcutMenuControl.xaml, ajoutez un MouseRightButtonDown événements au niveau supérieur UserControl élément.In ShortcutMenuControl.xaml, add a MouseRightButtonDown event to the top level UserControl element. Le fichier XAML doit maintenant ressembler à ceci :The XAML file should now look like this:

    <UserControl x:Class="TWShortcutMenu.ShortcutMenuControl"  
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"  
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"  
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"  
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"  
            Background="{DynamicResource VsBrush.Window}"  
            Foreground="{DynamicResource VsBrush.WindowText}"  
            mc:Ignorable="d"  
            d:DesignHeight="300" d:DesignWidth="300"  
            Name="MyToolWindow"  
            MouseRightButtonDown="MyToolWindow_MouseRightButtonDown">  
        <Grid>  
            <StackPanel Orientation="Vertical">  
                <TextBlock Margin="10" HorizontalAlignment="Center">ShortcutMenu</TextBlock>  
            </StackPanel>  
        </Grid>  
    </UserControl>  
    
  7. Dans ShortcutMenuControl.xaml.cs, ajoutez un stub pour le Gestionnaire d’événements.In ShortcutMenuControl.xaml.cs, add a stub for the event handler.

    private void MyToolWindow_MouseRightButtonDown(object sender, MouseButtonEventArgs e)  
    {  
    . . .  
    }  
    
  8. Ajoutez le code suivant à l’aide des instructions dans le même fichier :Add the following using statements to the same file:

    using Microsoft.VisualStudio.Shell;  
    using System.ComponentModel.Design;  
    using System;  
    using System.Windows.Input;  
    using System.Windows.Media;  
    
  9. Implémentez le MyToolWindowMouseRightButtonDown événements comme suit.Implement the MyToolWindowMouseRightButtonDown event as follows.

    private void MyToolWindow_MouseRightButtonDown(object sender, MouseButtonEventArgs e)  
    {  
        if (null != commandService)  
        {  
            CommandID menuID = new CommandID(  
                new Guid(ShortcutMenuCommand.guidShortcutMenuPackageCmdSet),  
                ShortcutMenuCommand.ColorMenu);  
            Point p = this.PointToScreen(e.GetPosition(this));  
            commandService.ShowContextMenu(menuID, (int)p.X, (int)p.Y);  
        }  
    }  
    

    Cette opération crée un CommandID objet pour le menu contextuel, identifie l’emplacement du clic de souris et ouvre le menu contextuel dans cet emplacement à l’aide du ShowContextMenu (méthode).This creates a CommandID object for the shortcut menu, identifies the location of the mouse click, and opens the shortcut menu in that location by using the ShowContextMenu method.

  10. Implémenter le Gestionnaire de commandes.Implement the command handler.

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

    Dans ce cas, qu’une seule méthode gère les événements pour tous les éléments de menu en identifiant les CommandID et en définissant la couleur d’arrière-plan en conséquence.In this case, just one method handles events for all of the menu items by identifying the CommandID and setting the background color accordingly. Si les éléments de menu contenait des commandes sans rapport, il serez que vous avez créé un gestionnaire d’événements distinct pour chaque commande.If the menu items had contained unrelated commands, you would have created a separate event handler for each command.

Tester les fonctionnalités de la fenêtre outilTest the tool window features

  1. Générez le projet et commencez le débogage.Build the project and start debugging. L’instance expérimentale s’affiche.The experimental instance appears.

  2. Dans l’instance expérimentale, cliquez sur vue / autres Windows, puis cliquez sur menu de raccourcis.In the experimental instance, click View / Other Windows, and then click ShortcutMenu. Cette opération doit s’afficher la fenêtre outil.Doing this should display your tool window.

  3. Avec le bouton droit dans le corps de la fenêtre outil.Right-click in the body of the tool window. Un menu contextuel qui contient une liste de couleurs doit s’afficher.A shortcut menu that has a list of colors should be displayed.

  4. Cliquez sur une couleur dans le menu contextuel.Click a color on the shortcut menu. La couleur d’arrière-plan de fenêtre outil doit être remplacée par la couleur sélectionnée.The tool window background color should be changed to the selected color.

Voir aussiSee also

Commandes, menus et barres d’outils Commands, menus, and toolbars
À l’aide et fourniture de servicesUsing and providing services