Como: Criar Menus, SubMenus e Menus de atalho

Artigo
05/18/2015

Para adicionar um menu para o ambiente de desenvolvimento integrado (IDE) do Visual Studio, um VSPackage deve usar o SDK do Visual Studio arquitetura para o grupo de comandos de menus. Grupo de comandos menus permitem comandos seja reutilizado e compartilhado entre componentes e o ambiente. Para obter mais informações sobre a menus de grupo de comandos, consulte Como a VSPackages adicionar elementos de Interface do usuário ao IDE.

Por VSPackages, menus são definidos os Menus seção de um arquivo .vsct. Um arquivo de .vsct define os menus e barras de ferramentas, comandos e grupos. Um comando é o que um usuário clica para executar uma função. Um grupo é um contêiner para menus e comandos. Um menu é um contêiner para grupos. Portanto, para criar um menu básico, você deve criar um menu, um grupo de comandos e pelo menos um comando.

Há três maneiras básicas que um menu pode aparecer em Visual Studio, da seguinte forma:

Como um menu na barra de menus principal.
Como um submenu de outro menu.
Como um menu de atalho (normalmente é exibido por um botão direito do mouse).

Este tópico mostra como criar cada tipo de menu. Também, as instruções a seguir mostra como fazer isso:

Em seu projeto, clique duas vezes no arquivo .vsct para abri-lo no editor.

Se o seu projeto não tiver um arquivo de .vsct, adicione uma. Selecione se você estiver criando um pacote usando o modelo de pacote de Visual Studio, Comando de Menu; Isso irá gerar um arquivo .vsct.
No Symbols seção, encontrar o GuidSymbol elemento que contém os comandos e grupos.
Criar um IDSymbol elemento para cada menu, grupo ou comando que você deseja adicionar, conforme mostrado no exemplo a seguir.
```
<GuidSymbol name="guidButtonGroupCmdSet" value="{f69209e9-975a-4543-821d-1f4a2c52d737}">
  <IDSymbol name="MyMenuGroup" value="0x1020" />
  <IDSymbol name="cmdidMyCommand" value="0x0100" />
</GuidSymbol>
```
O name atributos da GuidSymbol e IDSymbol elementos fornecem o par de GUID:ID para cada novo menu, um grupo ou um comando. O GUID representa um conjunto de comandos que é definido para o VSPackage. Você pode definir vários conjuntos de comandos. Cada par de GUID:ID deve ser exclusivo.
Definir o novo menu na Menus seção, da seguinte maneira:
1. Definir o guid e id campos para coincidir com o GUID:ID do novo menu.
2. Defina o atributo priority.
  
  O priority atributo é usado pelo .vsct para determinar o local do menu entre os outros objetos do grupo pai.
  
  Menus que possuem valores de prioridade inferiores são exibidos antes de menus que possuem valores de prioridade mais altos. Valores de prioridade duplicados serão permitidos, mas a posição relativa dos menus que possuem uma prioridade igual é determinada pela ordem na qual os VSPackages são processados em tempo de execução e ordem não pode ser predeterminada. Omitindo o priority atributo define seu valor como 0.
  
  Não defina uma prioridade para um menu de atalho, porque seu posicionamento é determinado pelo código que faz a chamada.
3. Para menus e submenus, defina a type para o atributo Menu, que descreve um menu típico. Para menus de atalho, defina a type para o atributo contexto.
  
  Para obter descrições de outros tipos de menus válido, como barras de ferramentas e os controladores de menu, consulte Elemento menu.
4. Na definição do menu, criar um seqüências seção que contém um texto de botão elemento para conter o nome do menu que aparece no IDE e um CommandName elemento para conter o nome do comando que é usado para acessar o menu no comando janela.
  
  Se a seqüência de caracteres de texto do botão inclui o caractere '&', o usuário pode abrir o menu pressionando ALT mais o caractere ou imediatamente posterior a 'e'.
5. Adicione sinalizadores de comando, conforme apropriado, para alterar a aparência e comportamento do menu. Para fazer isso, adicione um CommandFlag elemento na definição do menu. Para obter mais informações, consulte Elemento de sinalizador de comando.
Defina o pai do menu. Para um menu padrão ou um submenu, fazer isso em uma das seguintes maneiras, dependendo do seu design:
- No Menu elemento, criar um pai elemento e o conjunto de seus guid e id campos para a GUID:ID do grupo que irá hospedar o menu, também conhecido como o grupo pai principal. O grupo pai pode ser um grupo que você criou na Symbols seção, um grupo de outro pacote ou um grupo a partir do IDE. Por exemplo, para adicionar o menu para a barra de menu de nível superior do IDE, próximo a Ferramentas menu, definir o pai para guidSHLMainMenu:IDG_VS_MM_TOOLSADDINS.
  
  O exemplo a seguir mostra um menu que será exibido na barra 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>
```
- Você pode omitir a Parent elemento se o menu é deve ser posicionado, usando o posicionamento de comando. Criar um CommandPlacements seção antes do Symbols seção e, em seguida, adicione um CommandPlacement elemento que tenha o GUID:ID do menu, uma prioridade e um pai, conforme mostrado no exemplo a seguir.
```
<CommandPlacements>
  <CommandPlacement guid="guidButtonGroupCmdSet" id="cmdidMyCommand" priority="0x105">
    <Parent guid="guidButtonGroupCmdSet" id="MyMenuGroup" />
  </CommandPlacement>
</CommandPlacements>
```
  Criar várias posições de comando que têm o mesmo GUID:ID e tem pais diferentes faz com que um menu seja exibido em vários locais. Para obter mais informações, consulte Elemento de CommandPlacements.
Um menu padrão deve ter um grupo na barra de menus de Visual Studio como seu pai. Para um submenu, o pai deve ser um grupo em outro menu (embora o menu pai pode ser uma barra de ferramentas ou outro tipo de menu). Para um menu ou submenu a ser exibido, ele deve hospedar um grupo que contenha pelo menos um comando ativo ou ter a AlwaysCreate conjunto de sinalizadores de comando.

Menus de atalho não tem pais ou colocações de comando. Em vez disso, eles devem ser ativados no código. Normalmente, um menu de atalho é ativado em resposta a um direito do mouse em uma superfície de controle. O exemplo a seguir define um menu de atalho.
```
<Menu guid="guidButtonGroupCmdSet" id="ShortcutMenu"
      type="Context">
  <Strings>
    <ButtonText>Shortcut Menu</ButtonText>
    <CommandName>ShortcutMenu</CommandName>
  </Strings>
</Menu>
```
No grupos seção, criar um grupo elemento para conter os comandos que deverão ser exibidas em seu menu. O Symbols seção deve incluir uma entrada com o mesmo GUID:ID o novo Group elemento.
1. Defina a prioridade do grupo para que ela aparecerá onde você deseja em seu menu.
  
  Os limites de cada grupo no menu serão exibido como linhas horizontais.
2. Defina o pai para esse novo grupo para o GUID:ID do menu que você criou. Isso coloca o grupo de comandos no menu.
O grupo no exemplo a seguir aparece no menu de nível superior que foi mostrado no exemplo anterior.
```
 <Group guid="guidTopLevelMenuCmdSet" id="MyMenuGroup"
priority="0x0600">
   <Parent guid="guidTopLevelMenuCmdSet" id="TopLevelMenu"/>
 </Group>
```
Colocando o menu que é mostrado no exemplo a seguir em um grupo no menu de nível superior, ele se torna um submenu.
```
<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>
```
Adicionar comandos ao menu Criando entradas de comando na botões seção e definindo o pai de cada um para o GUID:ID do seu grupo. Cada botão elemento deve ter um GUID:ID que corresponde a uma entrada na Symbols seção.

Use o priority o atributo de cada entrada de botão para especificar a ordem na qual os comandos aparecem no grupo.

O exemplo a seguir define um comando que será exibido no menu de nível superior.
```
<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>
```
Para obter mais informações sobre itens de menu e botões, consulte Elemento button.

Para obter informações sobre como implementar os comandos de menu no código, consulte Como: criar e manipular comandos em VSPackages (C#) ou explicações passo a passo mencionados anteriormente neste tópico.

Obter o GUID:ID do menu de atalho. Por padrão, o modelo de pacote cria um GuidList classe em um arquivo de PkgCmdID.cs para manter o GUID do conjunto de comandos. O modelo também cria um PkgCmdIdList classe em um arquivo de PkgCmdId.cs para armazenar valores de ID de comandos que são declarados no modelo de número inteiro. Menus de atalho e os outros comandos devem ser declarados depois que o modelo é concluído. O exemplo a seguir mostra essas declarações.
```
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;

};
```
Esta etapa pode ser omitida se os valores GUID e ID serão usados diretamente. No entanto, recomendamos que você defina os valores para melhor legibilidade.
Anexe a um manipulador de eventos. Normalmente, os menus de atalho anexado para o botão direito do mouse de uma superfície de controle, conforme mostrado no exemplo a seguir.
```
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);
    }
}
```
O PointToScreen método converte a posição do clique, o que é relativo ao controle, para uma posição da tela. O ShowContextMenu método exibe o menu de atalho.

O arquivo que contém o manipulador de eventos deve incluir a System.ComponentModel.Design espaço para nome para acessar o OleMenuCommandService classe e o Microsoft.VisualStudio.Shell namespace para acessar o IMenuCommandService interface.
```
using Microsoft.VisualStudio.Shell;
using System.ComponentModel.Design;
```

Consulte também

Partilhar via

Como: Criar Menus, SubMenus e Menus de atalho

Para criar um menu, submenu ou menu de atalho

Para ativar um menu de atalho

Consulte também

Tarefas

Conceitos

Outros recursos

Recursos adicionais