Adicionando um menu de atalho a uma janela de ferramentas - Visual Studio (Windows)

Artigo
12/15/2023

Este passo a passo coloca um menu de atalho em uma janela de ferramenta. Um menu de atalho é um menu que aparece quando um usuário clica com o botão direito do mouse em um botão, caixa de texto ou plano de fundo da janela. Os comandos em um menu de atalho se comportam da mesma forma que os comandos em outros menus ou barras de ferramentas. Para oferecer suporte a um menu de atalho, especifique-o no arquivo .vsct e exiba-o em resposta ao clique com o botão direito do mouse.

Uma janela de ferramenta consiste em um controle de usuário WPF em uma classe de janela de ferramenta personalizada que herda de ToolWindowPane.

Este passo a passo mostra como criar um menu de atalho como um menu do Visual Studio, declarando itens de menu no arquivo .vsct e, em seguida, usando o Managed Package Framework para implementá-los na classe que define a janela da ferramenta. Essa abordagem facilita o acesso a comandos do Visual Studio, elementos da interface do usuário e o modelo de objeto de automação.

Como alternativa, se o menu de atalho não acessar a funcionalidade do Visual Studio, você poderá usar a ContextMenu propriedade de um elemento XAML no controle de usuário. Para obter mais informações, consulte ContextMenu.

Crie um projeto VSIX chamado e adicione um modelo de janela de ferramenta chamado TWShortcutMenu ShortcutMenu a ele. Para obter mais informações sobre como criar uma janela de ferramenta, consulte Criar uma extensão com uma janela de ferramenta.

Um menu de atalho, como o mostrado neste passo a passo, permite que o usuário selecione em uma lista de cores que são usadas para preencher o plano de fundo da janela da ferramenta.

Em ShortcutMenuPackage.vsct, localize no elemento GuidSymbol chamado guidShortcutMenuPackageCmdSet e declare o menu de atalho, o grupo de menus de atalho e as opções de menu. O elemento GuidSymbol agora deve ter esta aparência:

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

Pouco antes do elemento Buttons, crie um elemento Menus e defina o menu de atalho nele.

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

Um menu de atalho não tem um pai porque não faz parte de um menu ou barra de ferramentas.

Crie um elemento Groups com um elemento Group que contenha os itens de menu de atalho e associe o grupo ao menu de atalho.

<Groups>
    <Group guid="guidShortcutMenuPackageCmdSet" id="ColorGroup">
        <Parent guid="guidShortcutMenuPackageCmdSet" id="ColorMenu"/>
    </Group>
</Groups>

No elemento Buttons, defina os comandos individuais que aparecerão no menu de atalho. O elemento Buttons deve ter esta aparência:

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

Em ShortcutMenuCommand.cs, adicione as definições para o GUID do conjunto de comandos, o menu de atalho e os itens de menu.
```
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;
```
Esses são os mesmos IDs de comando definidos na seção Símbolos do arquivo ShortcutMenuPackage.vsct . O grupo de contexto não está incluído aqui porque é necessário apenas no arquivo .vsct .

Esta seção implementa o menu de atalho e seus comandos.

Em ShortcutMenu.cs, a janela de ferramenta pode obter o serviço de comando de menu, mas o controle que ele contém não pode. As etapas a seguir mostram como tornar o serviço de comando de menu disponível para o controle de usuário.

Em ShortcutMenu.cs, adicione o seguinte usando diretivas:

using Microsoft.VisualStudio.Shell;
using System.ComponentModel.Design;

Substitua o método Initialize() da janela de ferramenta para obter o serviço de comando de menu e adicionar o controle, passando o serviço de comando de menu para o construtor:

protected override void Initialize()
{
    var commandService = (OleMenuCommandService)GetService(typeof(IMenuCommandService));
    Content = new ShortcutMenuControl(commandService);
}

No construtor da janela de ferramenta ShortcutMenu, remova a linha que adiciona o controle. O construtor agora deve ter esta aparência:
```
public ShortcutMenu() : base(null)
{
    this.Caption = "ShortcutMenu";
    this.BitmapResourceID = 301;
    this.BitmapIndex = 1;
}
```

Em ShortcutMenuControl.xaml.cs, adicione um campo privado para o serviço de comando de menu e altere o construtor de controle para usar o serviço de comando de menu. Em seguida, use o serviço de comando de menu para adicionar os comandos de menu de contexto. O construtor ShortcutMenuControl agora deve se parecer com o código a seguir. O manipulador de comandos será definido posteriormente.

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

Em ShortcutMenuControl.xaml, adicione um MouseRightButtonDown evento ao elemento de nível UserControl superior. O arquivo XAML agora deve ter esta aparência:

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

Em ShortcutMenuControl.xaml.cs, adicione um stub para o manipulador de eventos.

private void MyToolWindow_MouseRightButtonDown(object sender, MouseButtonEventArgs e)
{
. . .
}

Adicione as seguintes diretivas de uso ao mesmo arquivo:

using Microsoft.VisualStudio.Shell;
using System.ComponentModel.Design;
using System;
using System.Windows.Input;
using System.Windows.Media;

Implemente o MyToolWindowMouseRightButtonDown evento da seguinte maneira.

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

Isso cria um CommandID objeto para o menu de atalho, identifica o local do clique do mouse e abre o menu de atalho nesse local usando o ShowContextMenu método.

Implemente o manipulador de comandos.

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

Nesse caso, apenas um método manipula eventos para todos os itens de menu, identificando o CommandID e definindo a cor do plano de fundo de acordo. Se os itens de menu contivessem comandos não relacionados, você teria criado um manipulador de eventos separado para cada comando.

Testar os recursos da janela de ferramentas

Compile o projeto e comece a depuração. A instância experimental é exibida.
Na instância experimental, clique em Exibir / Outras janelas e, em seguida, clique em ShortcutMenu . Isso deve exibir a janela da ferramenta.
Clique com o botão direito do mouse no corpo da janela da ferramenta. Um menu de atalho que tenha uma lista de cores deve ser exibido.
Clique em uma cor no menu de atalho. A cor de fundo da janela de ferramentas deve ser alterada para a cor selecionada.

Partilhar via

Adicionar um menu de atalho em uma janela de ferramenta

Criar o pacote de menu de atalho da janela de ferramentas

Especificando o menu de atalho

Implementando o menu de atalho

Testar os recursos da janela de ferramentas

Recursos adicionais

Partilhar via

Adicionar um menu de atalho em uma janela de ferramenta

Criar o pacote de menu de atalho da janela de ferramentas

Especificando o menu de atalho

Implementando o menu de atalho

Testar os recursos da janela de ferramentas

Conteúdo relacionado

Recursos adicionais