tutorial: implementar un menú contextual en una ventana de herramientas

Artículo
05/18/2015

Este tutorial coloca un menú contextual en una ventana de herramientas. Un menú contextual es un menú que aparece cuando un usuario hace clic con el botón secundario en un elemento (GUI) de la interfaz gráfica de usuario como un botón, un cuadro de texto, o un fondo de la ventana. Los comandos de un menú contextual se comportan igual que comandos en otros menús o barras de herramientas. Para admitir un menú contextual, especifíquelo en el archivo de la tabla de comandos XML (.vsct) y mostrarlo en respuesta al clic con el botón secundario del mouse.

Una ventana de herramientas consta de un control de (WPF) usuario de Windows presentation foundation en una clase personalizada de la ventana de herramientas que herede de ToolWindowPane.

Este tutorial muestra cómo crear un menú contextual como menú de Visual Studio, declarando elementos de menú en el archivo de .vsct, y utilizando la managed package para implementarlos en la clase que define la ventana de herramientas. Este enfoque facilita el acceso a los comandos de Visual Studio, los elementos de la interfaz de usuario, y el modelo de objetos de automatización.

Como alternativa, si el menú contextual no tiene acceso a la funcionalidad de Visual Studio, puede utilizar la propiedad de ContextMenu de un elemento XAML en el control de usuario. Para obtener más información, vea ContextMenu.

Requisitos previos

Para completar este tutorial, debe instalar Visual Studio 2010 SDK.

Nota

Para obtener más información sobre el SDK de Visual Studio, vea Información general de Visual Studio que extiende.Para averiguar cómo descargar el SDK de Visual Studio, vea Centro para desarrolladores de extensibilidad de Visual Studio en el sitio web de MSDN.

Ubicaciones de la plantilla de proyecto paquete de Visual Studio

La plantilla de proyecto paquete de Visual Studio está disponible en tres ubicaciones en el cuadro de diálogo de Nuevo proyecto :

En extensibilidad de Visual Basic. El idioma predeterminado del proyecto es Visual Basic.
En extensibilidad de C#. El lenguaje predeterminado del proyecto es C#.
En La otra extensibilidad de los tipos de proyecto. El lenguaje predeterminado del proyecto es C++.

Crear el paquete del menú contextual de la ventana de herramientas

para crear el MyTWGradientPackage VSPackage

Cree un proyecto denominado TWShortcutMenudel paquete de Visual Studio.
1. En el asistente del paquete, establezca el lenguaje en Visual Basic o de C#.
2. Seleccione la opción para crear una ventana de herramientas.
3. Llame a la ventana de herramientas ventana de color de cambio, y establezca su identificador de comando a cmdidColorChange.

especificar el menú contextual

Un menú contextual como el que se muestra en este tutorial le permite seleccionar de una lista de colores que se utilizan para rellenar el fondo de la ventana de herramientas.

Para crear el menú contextual

MyTWGradientPackage.vsct abierto.

En el elemento de Símbolos , en el elemento de GuidSymbol denominado “guidTWShortcutMenuCmdSet”, declare el menú contextual, el grupo del menú contextual, y las opciones de menú, como sigue.

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

Justo antes del elemento de Grupos , cree un elemento de menús y después defina el menú contextual en él.

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

Un menú contextual no tiene un elemento primario porque no es parte de un menú o una barra de herramientas.

En el elemento de Groups , defina el elemento de Agrupar que contiene los elementos de menú contextual, y asociar el grupo con el menú contextual.
```
<Group guid="guidTWShortcutMenuCmdSet" id="ColorGroup">
  <Parent guid="guidTWShortcutMenuCmdSet" id="ColorMenu"/>
</Group>
```

en el elemento de Botones , defina los comandos individuales que aparecerán en el menú contextual.

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

PkgCmdID.vb abierto o PkgCmdID.cs.
Agregue las definiciones del menú contextual y elementos de menú.
```
public const int ColorMenu = 0x1000;

public const int cmdidRed = 0x102;
public const int cmdidYellow = 0x103;
public const int cmdidBlue = 0x104;
```
Éstos son los mismos id. de comando que se definen en la sección de Symbols del archivo de TWShortcutMenu.vsct. No incluye el grupo de contexto aquí porque sólo se requiere en el archivo de .vsct.
Guarde la solución y compílela.

implementar el menú contextual

esta sección implementa el menú contextual y sus comandos.

para implementar el menú contextual

MyToolWindow.vb abierto o MyToolWindow.cs.

La clase de MyToolWindow tiene acceso a los servicios del comando de menú, pero el control de usuario que los host no. Los tres pasos siguientes muestran cómo colocar una instancia del servicio del comando de menú a disposición de la ventana de herramientas el control de usuario.
Agregue el espacio de nombres System.ComponentModel.Design.
```
using System.ComponentModel.Design;
```
Agregue una variable para contener la instancia del servicio del comando de menú.
```
internal OleMenuCommandService mcs;
```
Al final del constructor, agregue una llamada al servicio del comando de menú y modifique la llamada a base.Content, como sigue.
```
mcs = GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
base.Content = new MyControl(this);
```
Llamando al comando de menú mantenga en el constructor garantiza que está en la memoria siempre que la ventana de herramientas está abierto. Pasar una instancia de la ventana de herramientas como parámetro al constructor del control permite al control para realizar llamadas a los miembros de la clase de la ventana de herramientas.
MyControl.xaml abierto.

Este archivo representa el control de usuario que se muestra en la ventana de herramientas.
Agregue un evento de MouseRightButtonDown al elemento de UserControl de nivel superior.
```
MouseRightButtonDown="MyToolWindow_MouseRightButtonDown"
```
Haga clic con el botón secundario en la declaración de evento que acaba de agregar y haga clic Navegar al controlador de eventos.

esto abre MyControl.xaml.vb o MyControl.xaml.cs y crea un código auxiliar para el controlador de eventos.
En la parte superior de MyControl, agregue Microsoft.VisualStudio.Shell y espacios de nombres de System.ComponentModel.Design .
```
using Microsoft.VisualStudio.Shell;
using System.ComponentModel.Design;
```

Agregue un campo para mantener una referencia a la ventana de herramientas primaria, y modifique el constructor como sigue.

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

el constructor ahora toma la instancia primaria de la ventana de herramientas como parámetro, y la almacena en el campo de _parent . A continuación crea los objetos de CommandID de comando GUID determinado y los valores de PkgCmdList que representan los comandos de menú que ha definido en el archivo de .vsct. Por último, agrega los comandos al servicio del comando de menú y asigna los controladores de eventos.

implemente el evento de MyToolWindowMouseRightButtonDown como sigue.

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

Esto crea un objeto de CommandID para el menú contextual, identifica la ubicación de clic del mouse, abrir el menú contextual en esa ubicación utilizando el método de ShowContextMenu .

Implemente el evento, que se define en el constructor, porque un usuario hace clic en un elemento de menú.

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

En este caso, un solo método controla los eventos para todos los elementos de menú identificando CommandID y estableciendo el color de fondo en consecuencia. Si los elementos de menú hubieran contenido comandos sin relación, se habría creado un controlador de eventos independiente para cada comando.

Probar las características de la ventana de herramientas

Esta sección muestra cómo mostrar las características que se han agregado en este tutorial.

para probar las características de la ventana de herramientas

Presione F5 para abrir una instancia experimental de Visual Studio.
En la instancia experimental, en el menú de Ver , haga clic Otras ventanas y haga clic en Ventana de color de cambio. Ello debe mostrar la ventana de herramientas.
Haga clic con el botón secundario en el fondo de la ventana de herramientas, fuera del botón. Un menú contextual que tiene una lista de colores debe mostrar.
Haga clic en el color en el menú contextual. El menú contextual debe desaparecer, y el color de fondo de la ventana de herramientas se debe cambiar al color seleccionado.

Pasos siguientes

Si cambia el menú contextual modificando el archivo de .vsct, debe recompilar el proyecto de MyTWGradientPackageUI. Haciendo esto obliga al archivo de .vsct que volver a compilar y el archivo DLL satélite que se reconectará con los cambios realizados en el archivo de .vsct.

Vea también

Otros recursos

Tutoriales para los comandos, menús, barras de herramientas y

comandos, menús, y barras de herramientas

Servicios

Compartir a través de