Compartir a través de

Agregar un submenú a un menú

  • Artículo

Este tutorial se basa en la demostración en Agregar un menú a la barra de menús de Visual Studio mostrando cómo agregar un submenú al menú TestMenu .

Un submenú es un menú secundario que aparece en otro menú. Un submenú se puede identificar mediante la flecha que sigue su nombre. Al hacer clic en el nombre, el submenú y sus comandos se mostrarán.

En este tutorial se crea un submenú en un menú de la barra de menús de Visual Studio y se coloca un nuevo comando en el submenú. El tutorial también implementa el nuevo comando.

Agregar un submenú a un menú

  1. Siga los pasos descritos en Agregar un menú a la barra de menús de Visual Studio para crear el proyecto y el elemento de menú. En los pasos de este tutorial se supone que el nombre del proyecto VSIX es TopLevelMenu.

  2. Abra TestCommandPackage.vsct. En la <Symbols> sección , agregue un <IDSymbol> elemento para el submenú, uno para el grupo de submenú y otro para el comando , todo en el <GuidSymbol> nodo denominado "guidTopLevelMenuCmdSet". Este es el mismo nodo que contiene el <IDSymbol> elemento para el menú de nivel superior.

    <IDSymbol name="SubMenu" value="0x1100"/>
<IDSymbol name="SubMenuGroup" value="0x1150"/>
<IDSymbol name="cmdidTestSubCommand" value="0x0105"/>

  3. Agregue el submenú recién creado a la <Menus> sección .

    <Menu guid="guidTestCommandPackageCmdSet" id="SubMenu" priority="0x0100" type="Menu">
    <Parent guid="guidTestCommandPackageCmdSet" id="MyMenuGroup"/>
    <Strings>
        <ButtonText>Sub Menu</ButtonText>
        <CommandName>Sub Menu</CommandName>
    </Strings>
</Menu>

    El par GUID/ID del elemento primario especifica el grupo de menús que se generó en Agregar un menú a la barra de menús de Visual Studio y es un elemento secundario del menú de nivel superior.

  4. Agregue el grupo de menús definido en el paso 2 a la <Groups> sección y consíguelo a un elemento secundario del submenú.

    <Group guid="guidTestCommandPackageCmdSet" id="SubMenuGroup" priority="0x0000">
    <Parent guid="guidTestCommandPackageCmdSet" id="SubMenu"/>
</Group>

  5. Agregue un nuevo <Button> elemento a la <Buttons> sección para definir el comando creado en el paso 2 como un elemento del submenú.

    <Button guid="guidTestCommandPackageCmdSet" id="cmdidTestSubCommand" priority="0x0000" type="Button">
    <Parent guid="guidTestCommandPackageCmdSet" id="SubMenuGroup" />
    <Icon guid="guidImages" id="bmpPic2" />
    <Strings>
       <CommandName>cmdidTestSubCommand</CommandName>
       <ButtonText>Test Sub Command</ButtonText>
    </Strings>
</Button>

  6. Compile la solución y comience la depuración. Debería ver la instancia experimental.

  7. Haga clic en TestMenu para ver un nuevo submenú denominado Sub Menu. Haga clic en Sub Menu para abrir el submenú y ver un nuevo comando, Test Sub Command. Observe que al hacer clic en Test Sub Command no hace nada.

Agregar un comando

  1. Abra TestCommand.cs y agregue el siguiente identificador de comando después del identificador de comando existente.

    public const int cmdidTestSubCmd = 0x0105;

  2. Agregue el submandago. Busque el constructor de comandos. Agregue las líneas siguientes justo después de la llamada al AddCommand método .

    CommandID subCommandID = new CommandID(CommandSet, cmdidTestSubCmd);
MenuCommand subItem = new MenuCommand(new EventHandler(SubItemCallback), subCommandID);
commandService.AddCommand(subItem);

    El SubItemCallback controlador de comandos se definirá más adelante. El constructor debería tener ahora este aspecto:

    private TestCommand(Package package)
{
    if (package == null)
    {
        throw new ArgumentNullException("package");
    }

    this.package = package;

    OleMenuCommandService commandService = this.ServiceProvider.GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
    if (commandService != null)
    {
        var menuCommandID = new CommandID(CommandSet, CommandId);
        var menuItem = new MenuCommand(this.MenuItemCallback, menuCommandID);
        commandService.AddCommand(menuItem);

        CommandID subCommandID = new CommandID(CommandSet, cmdidTestSubCmd);
        MenuCommand subItem = new MenuCommand(new EventHandler(SubItemCallback), subCommandID);
        commandService.AddCommand(subItem);
    }
}

  3. Agregue SubItemCallback(). Este es el método al que se llama cuando se hace clic en el nuevo comando del submenú.

    private void SubItemCallback(object sender, EventArgs e)
{
    ThreadHelper.ThrowIfNotOnUIThread();
    IVsUIShell uiShell = this.package.GetService<SVsUIShell, IVsUIShell>();
    Guid clsid = Guid.Empty;
    int result;
    uiShell.ShowMessageBox(
        0,
        ref clsid,
        "TestCommand",
        string.Format(CultureInfo.CurrentCulture,
        "Inside TestCommand.SubItemCallback()",
        this.ToString()),
        string.Empty,
        0,
        OLEMSGBUTTON.OLEMSGBUTTON_OK,
        OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST,
        OLEMSGICON.OLEMSGICON_INFO,
        0,
        out result);
}

  4. Compile la solución y comience la depuración. Debería aparecer la instancia experimental.

  5. En el menú TestMenu , haga clic en Sub Menú y, a continuación, haga clic en Probar subcomando. Debería aparecer un cuadro de mensaje y mostrar el texto "Test Command Inside TestCommand.SubItemCallback()".

Contenido relacionado