Cómo: Crear menús, los submenús, y menús contextuales

Artículo
05/18/2015

Para agregar un menú al entorno de desarrollo integrado de (IDE) Visual Studio, un Paquete debe utilizar la arquitectura de Visual Studio SDK para los menús de comando-grupo. los menús de Comando-grupo habilitan comandos de reutilizar y de compartir entre los componentes y el entorno. Para obtener más información sobre menús de comando-grupo, vea Cómo VSPackages agrega elementos de la interfaz de usuario al IDE.

Para VSPackages, menús se definen en la sección de menús de un archivo de .vsct. Un archivo de .vsct define menús y barras de herramientas, los grupos, y los comandos. Un comando es un qué usuario haga clic en para realizar una función. Un grupo es un contenedor para los comandos y menús. un menú es un contenedor para los grupos. Por consiguiente, para crear un menú básico, debe crear un menú, un grupo de comandos y, por lo menos un comando.

Hay tres formas básicas que un menú puede aparecer en Visual Studio, como sigue:

como menú en la barra de menú principal.
como submenú de otro menú.
Como menú contextual (mostrado normalmente mediante un clic con el botón secundario en).

En este tema se muestra cómo crear cada clase de menú. Los tutoriales siguientes también muestran cómo hacerlo:

para crear un menú, un submenú, o un menú contextual

En el proyecto, haga doble clic en el archivo de .vsct para abrirlo en el editor.

si el proyecto no tiene un archivo de .vsct, agregue uno. Si está creando un paquete utilizando la plantilla de paquete de Visual Studio, seleccione Comando de menú; hacerlo generará un archivo de .vsct.
En la sección de Symbols , busque el elemento de GuidSymbol que contiene los grupos y los comandos.
Cree un elemento de IDSymbol para cada menú, grupo, o comando que desee agregar, como se muestra en el ejemplo siguiente.
```
<GuidSymbol name="guidButtonGroupCmdSet" value="{f69209e9-975a-4543-821d-1f4a2c52d737}">
  <IDSymbol name="MyMenuGroup" value="0x1020" />
  <IDSymbol name="cmdidMyCommand" value="0x0100" />
</GuidSymbol>
```
los atributos de name de los elementos de GuidSymbol y de IDSymbol proporcionan GUID: Pares de cada nuevo menú, grupo, o comando. GUID representa un comando establecido que está definido para el Paquete. Puede definir varios conjuntos de comando. cada GUID: Los pares de identificador deben ser únicos.
defina el nuevo menú en la sección de Menus , como sigue:
1. establezca los campos de guid y de id para coincidir GUID: Identificador del nuevo menú.
2. Establezca el atributo priority.
  
  El atributo de priority usa el .vsct para determinar la ubicación de menú entre los demás objetos del grupo primario.
  
  Los menús que tienen valores de menor prioridad se muestran antes de los menús que tienen valores de prioridad máxima. Se permiten los valores de prioridad duplicados, pero la posición relativa de los menús cuya prioridad sea igual viene determinada por el orden en que VSPackages se procesa en tiempo de ejecución, y la que no puede ser predeterminada el orden. La omisión del atributo de priority establece su valor en 0.
  
  No establezca una prioridad para un menú contextual, porque su posición viene determinada por el código que lo llame.
3. Para los menús y los submenús, establezca el atributo de type a Menú, que describe un menú estándar. para los menús contextuales, establezca el atributo de type a contexto.
  
  Para las descripciones de otros tipos válidos de menú, como barras de herramientas y controladores de menú, vea Menu (Elemento).
4. En la definición de menú, cree una sección de Cadenas que contiene un elemento de ButtonText para contener el nombre del menú que aparece en el IDE, y un elemento de CommandName para contener el nombre del comando que se utiliza para tener acceso al menú de la ventana de comandos.
  
  Si la cadena de texto del botón incluye “y” el carácter, puede abrir el menú presionando ALT más el carácter que sigue inmediatamente a “y”.
5. Agregue marcadores de comando, según corresponda, para cambiar el aspecto y el comportamiento del menú. Para ello, agregue un elemento de CommandFlag en la definición de menú. Para obtener más información, vea CommandFlag (Elemento).
Establezca el elemento de menú primario. Para obtener un menú o un submenú estándar, haga esto de varias formas, dependiendo del diseño:
- en el elemento de Menu , cree un elemento de elemento primario y establezca sus campos de guid y de id a GUID: Identificador del grupo que hospeda el menú, también conocido como el grupo primario principal. El grupo primario puede ser un grupo que creó en la sección de Symbols , un grupo de otro paquete, o un grupo del IDE. Por ejemplo, agregar el menú a la barra de menús de nivel superior del IDE, cerca del menú de Herramientas , establece el elemento primario a guidSHLMainMenu: IDG_VS_MM_TOOLSADDINS.
  
  El ejemplo siguiente se muestra un menú que aparece en la barra de menús 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>
```
- Puede omitir el elemento de Parent si el menú a colocarse mediante la posición del comando. Cree una sección de CommandPlacements antes de la sección de Symbols , y agregue un elemento de CommandPlacement con GUID: Identificador de menú, de prioridad, y un elemento primario, como se muestra en el ejemplo siguiente.
```
<CommandPlacements>
  <CommandPlacement guid="guidButtonGroupCmdSet" id="cmdidMyCommand" priority="0x105">
    <Parent guid="guidButtonGroupCmdSet" id="MyMenuGroup" />
  </CommandPlacement>
</CommandPlacements>
```
  Crear las posiciones varias de comando que tienen el mismo GUID: El identificador y tiene varias causas de los elementos primarios un menú de aparecer en varias ubicaciones. Para obtener más información, vea CommandPlacements (Elemento).
un menú estándar debe tener un grupo en la barra de menús de Visual Studio como su elemento primario. Para un submenú, el elemento primario debe ser un grupo en otro menú (aunque el menú primario puede ser la barra de herramientas o el otro tipo menú). Para que un menú o un submenú se muestra, debe hospedar el grupo que contiene por lo menos un comando activo, o hacer que el indicador de comando de AlwaysCreate establezca.

Los menús contextuales no tienen elementos primarios o posiciones de comando. En su lugar, deben ser generados en el código. Normalmente, un menú contextual se produce en respuesta a un clic con el botón secundario en una superficie de control. El ejemplo siguiente se define un menú contextual.
```
<Menu guid="guidButtonGroupCmdSet" id="ShortcutMenu"
      type="Context">
  <Strings>
    <ButtonText>Shortcut Menu</ButtonText>
    <CommandName>ShortcutMenu</CommandName>
  </Strings>
</Menu>
```
En la sección de Grupos , cree un elemento de Agrupar para contener los comandos que son aparezca en el menú. La sección de Symbols debe incluir una entrada con el mismo par GUID: identificador como el nuevo elemento de Group .
1. Establezca la prioridad del grupo para que aparezca donde desee en el menú.
  
  Los límites de cada grupo del menú aparecen como líneas horizontales.
2. Establezca el elemento primario para este nuevo grupo a GUID: Identificador de menú que creó. Ello coloca el grupo de comandos del menú.
El grupo en el ejemplo siguiente aparece en el menú de nivel superior que se mostró en un ejemplo anterior.
```
 <Group guid="guidTopLevelMenuCmdSet" id="MyMenuGroup"
priority="0x0600">
   <Parent guid="guidTopLevelMenuCmdSet" id="TopLevelMenu"/>
 </Group>
```
Colocando el menú que se muestra en el siguiente ejemplo en un grupo en el menú de nivel superior, se convierte en un submenú.
```
<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>
```
Agregue los comandos al menú crear entradas de comando en la sección de Botones y estableciendo el elemento primario de cada a GUID: Identificador del grupo. cada elemento de Botn debe tener GUID: Identificador que corresponde a una entrada de la sección de Symbols .

Utilice el atributo de priority de cada entrada del botón para especificar el orden en que los comandos aparecen en el grupo.

El ejemplo siguiente se define un comando que aparece en el menú de nivel 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 obtener más información sobre los botones y elementos de menú, vea Button (Elemento).

Para obtener información sobre cómo implementar los comandos de menú en código, vea Cómo: Crear y controlar los comandos en VSPackages (C#) o los tutoriales que son anteriores mencionados en este tema.

para activar un menú contextual

Obtiene el GUID: Identificador del menú contextual. De forma predeterminada, la plantilla de paquete crea una clase de GuidList en un archivo de PkgCmdID.cs para contener el GUID del conjunto de comandos. La plantilla también crea una clase de PkgCmdIdList en un archivo de PkgCmdId.cs para contener los valores de identificador enteros de los comandos que se declaran en la plantilla. Menús contextuales y cualquier comando adicional debe declarar una vez finalizada la plantilla. el ejemplo siguiente muestra estas declaraciones.
```
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;

};
```
Este paso puede omitir si el GUID y los valores de identificador se utilizan directamente. Sin embargo, se recomienda establecer valores aquí por legibilidad.
Adjuntar a un controlador de eventos. Normalmente, menús contextuales asociados a hacer clic con el botón secundario de una superficie de control, como se muestra en el ejemplo siguiente.
```
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);
    }
}
```
El método de PointToScreen convierte la posición click, que es relativa al control, una posición de la pantalla. El método de ShowContextMenu muestra el menú contextual.

El archivo que contiene el controlador de eventos debe incluir el espacio de nombres System.ComponentModel.Design para tener acceso a la clase de OleMenuCommandService , y el espacio de nombres Microsoft.VisualStudio.Shell para tener acceso a la interfaz de IMenuCommandService .
```
using Microsoft.VisualStudio.Shell;
using System.ComponentModel.Design;
```

Vea también

Compartir a través de

Cómo: Crear menús, los submenús, y menús contextuales

para crear un menú, un submenú, o un menú contextual

para activar un menú contextual

Vea también

Tareas

Conceptos

Otros recursos

Recursos adicionales