Passo a passo: Implementando um Menu de atalho em uma janela de ferramenta

Artigo
05/18/2015

Esta explicação 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 um elemento de interface (GUI) gráfica do usuário como, por exemplo, um botão, a caixa de texto ou o plano de fundo da janela. Comandos em um menu de atalho se comportam da mesma como comandos de outros menus ou barras de ferramentas. Para oferecer suporte a um menu de atalho, especificá-lo no arquivo XML comando tabela (.vsct) e exibi-lo em resposta para o botão direito do mouse.

Uma janela de ferramenta consiste em um controle de usuário em uma classe de janela de ferramenta personalizada que herda a partir de Windows Presentation Foundation (WPF) ToolWindowPane.

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

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

Pré-requisitos

Para concluir este passo a passo, você deve instalar o SDL do Visual Studio 2010.

Dica

Para obter mais informações sobre o SDK de Visual Studio, consulte Ampliando a visão geral de Visual Studio.Para descobrir como fazer o download do SDK do Visual Studio, consulte Visual Studio extensibilidade Developer Center no site do MSDN.

Locais para o modelo de projeto de pacote de Visual Studio

O modelo de projeto do pacote de Visual Studio está disponível nos três locais, o Novo projeto caixa de diálogo:

Em Visual Basic extensibilidade. O idioma padrão do projeto é Visual Basic.
Em C# extensibilidade. O idioma padrão do projeto é C#.
Em outra extensibilidade de tipos de projeto. O idioma padrão do projeto é C++.

Para criar o MyTWGradientPackage VSPackage

Criar um projeto do pacote de Visual Studio chamado TWShortcutMenu.
1. No Assistente de pacote, defina o idioma para Visual Basic ou C#.
2. Selecione a opção para criar uma janela de ferramenta.
3. Nomeie a janela de ferramentas janela de alteração de cor e defina sua ID de comando para cmdidColorChange.

Um menu de atalho, como aquele mostrado nesta explicação permite que o usuário selecione uma lista de cores que são usados para preencher o plano de fundo da janela de ferramenta.

Abra MyTWGradientPackage.vsct.

No símbolos elemento, no GuidSymbol elemento chamado "guidTWShortcutMenuCmdSet", declara o menu de atalho, grupo de menu de atalho e opções de menu, da seguinte maneira.

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

Antes de grupos elemento, criar um Menus elemento e, em seguida, definir o menu de atalho nele.

<Menus>
  <Menu guid="guidTWShortcutMenuCmdSet" 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 ele não é parte de um menu ou barra de ferramentas.

No Groups elemento, definir o grupo o elemento que contém os itens de menu de atalho e associa o grupo no menu de atalho.

<Group guid="guidTWShortcutMenuCmdSet" id="ColorGroup">
  <Parent guid="guidTWShortcutMenuCmdSet" id="ColorMenu"/>
</Group>

No botões elemento, definem os comandos individuais que aparecerão no menu de atalho.

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

Abra PkgCmdID.vb ou PkgCmdID.cs.
Adicione as definições de menu de atalho e os itens de menu.
```
public const int ColorMenu = 0x1000;

public const int cmdidRed = 0x102;
public const int cmdidYellow = 0x103;
public const int cmdidBlue = 0x104;
```
Estes são os IDs de comando mesmo que são definidos na Symbols seção do arquivo TWShortcutMenu.vsct. O grupo de contexto não está incluído aqui porque ele só é necessário no arquivo .vsct.
Salve a solução e compilá-lo.

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

Abra MyToolWindow.vb ou MyToolWindow.cs.

O MyToolWindow classe tem acesso aos serviços do comando de menu, mas o usuário controlá-lo hosts não funcionar. As próximas três etapas mostram como disponibilizar uma instância do serviço de comando de menu da janela de ferramenta para o controle de usuário.
Adicione o espaço de nomes System.ComponentModel.Design.
```
using System.ComponentModel.Design;
```
Adicione uma variável para a instância do serviço de comando de menu.
```
internal OleMenuCommandService mcs;
```
No final do construtor, adicione uma chamada para o serviço de comando de menu e modificar a chamada para base.Content, da seguinte forma.
```
mcs = GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
base.Content = new MyControl(this);
```
Chamando o serviço de comando de menu no construtor garante que ele está na memória sempre que a janela de ferramenta está aberta. Passando uma instância da janela da ferramenta como um parâmetro para o construtor de controle permite que o controle fazer chamadas para os membros da classe de janela de ferramenta.
Abra MyControl.xaml.

Este arquivo representa o controle de usuário que é exibido na janela da ferramenta.
Adicionar um MouseRightButtonDown evento para o nível superior UserControl elemento.
```
MouseRightButtonDown="MyToolWindow_MouseRightButtonDown"
```
Clique com o botão direito a declaração de evento que você acabou de adicionar e, em seguida, clique em navegar até manipulador de eventos.

Isso abre o MyControl.xaml.vb ou MyControl.xaml.cs e cria um stub para o manipulador de eventos.
O topo da MeuControle, adicionar o Microsoft.VisualStudio.Shell e System.ComponentModel.Design namespaces.
```
using Microsoft.VisualStudio.Shell;
using System.ComponentModel.Design;
```

Adicionar um campo para manter uma referência para a janela de ferramenta do pai e modificar o construtor da seguinte maneira.

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

O construtor agora leva o pai a instância da janela da ferramenta como um parâmetro e armazena-lo na _parent campo. Em seguida, cria CommandID GUID do conjunto de objetos do comando e o PkgCmdList valores que representam os comandos de menu que você definiu no arquivo .vsct. Por último, ele adiciona os comandos para o serviço de comando de menu e atribui os manipuladores de eventos.

Implementar a MyToolWindowMouseRightButtonDown o evento da seguinte maneira.

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

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

Implemente o evento, que é definido no construtor, para um usuário, clique em um item 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;
            }
        }

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

Teste os recursos da janela de ferramenta

Esta seção mostra como demonstrar os recursos que foram adicionados nesta explicação.

Para testar os recursos da janela de ferramenta

Pressione F5 para abrir uma instância experimental de Visual Studio.
Na instância experimental, sobre o Exibir menu, clique em Other Windows e, em seguida, clique em Janela de alteração de cor. Isso deve exibir a janela de ferramenta.
Plano de fundo de janela do ferramenta, longe do botão de atalho. Deve ser exibido um menu de atalho que possui uma lista de cores.
Clique em uma cor no menu de atalho. O menu de atalho deve desaparecer e a cor de plano de fundo da janela de ferramenta deve ser alterada para a cor selecionada.

Próximas etapas

Se você alterar o menu de atalho, modificando o arquivo .vsct, é necessário reconstruir o projeto MyTWGradientPackageUI. Isso força o arquivo de .vsct ser recompilado e o satélite DLL para ser re-linked com as alterações feitas no arquivo .vsct.

Consulte também

Outros recursos

Explicações passo a passo para comandos, Menus e barras de ferramentas

Comandos, Menus e barras de ferramentas

Serviços

Partilhar via

Passo a passo: Implementando um Menu de atalho em uma janela de ferramenta

Pré-requisitos

Locais para o modelo de projeto de pacote de Visual Studio

Criando o pacote de Menu de atalho da janela de ferramenta

Para criar o MyTWGradientPackage VSPackage

Especificando o Menu de atalho

Para criar o menu de atalho

Implementando o Menu de atalho

Para implementar o menu de atalho

Teste os recursos da janela de ferramenta

Para testar os recursos da janela de ferramenta

Próximas etapas

Consulte também

Outros recursos

Recursos adicionais