Partilhar via

Como: adicionar dinamicamente os itens de Menu

  • Artigo

Um comando que está definido no arquivo de configuração de tabela de comando servços (.vsct) e possui o DynamicItemStart sinalizador Especifica uma posição em um menu onde são inseridos os comandos criados dinamicamente. Comandos dinâmicos normalmente são criados quando o VSPackage associado for iniciado e pode ser atualizado quando o VSPackage é aberto.

Dois tipos comuns de listas dinâmicas são os seguintes:

  • A maioria das lista de usados recentemente (MRU), que normalmente exibe os nomes de documentos que foram abertos recentemente.

  • Abra a lista do Windows, o que normalmente exibe os nomes do windows que estão atualmente.

O DynamicItemStart sinalizador em uma definição de comando Especifica que o comando é um espaço reservado até que o VSPackage é aberto. Quando o VSPackage é aberto, o espaço reservado é substituído com 0 ou mais comandos que são criados em tempo de execução, o VSPackage e adicionados à lista dinâmica. Você não poderá ver a posição no menu onde a lista dinâmica é exibido até que o VSPackage é aberto.

Para preencher a lista dinâmica, o ambiente de desenvolvimento integrado (IDE) chama primeiro o VSPackage para procurar um comando que tenha uma ID cujos primeiros caracteres são os mesmos que a identificação do espaço reservado. Quando o IDE encontra um comando, ele adiciona o nome do comando à lista dinâmica. Em seguida, o IDE incrementa a identificação e procura por outro comando correspondente adicionar à lista dinâmica. O IDE continua a incrementar a identificação e adicionar à lista dinâmica até que existem comandos não mais dinâmicos.

O primeiro procedimento descreve como criar uma lista MRU dinâmica em um submenu.

O segundo procedimento descreve como preencher uma lista dinâmica usando a estrutura de pacote gerenciado (MPF).

Para obter mais informações sobre arquivos de .vsct, consulte Tabela Visual Studio de comando (.Arquivos de VSCT).

Para obter informações sobre como criar uma lista MRU, consulte Passo a passo: Adicionar um mais recentemente usada a lista a um Submenu.

Criando uma lista dinâmica de comando

Para criar uma lista dinâmica de comando, você deve primeiro adicionar um botão elemento no arquivo .vsct. Esse elemento se torna um espaço reservado para a lista no IDE. Em seguida, implemente a própria lista no código.

Para criar um espaço reservado para uma lista dinâmica de comando

  1. No arquivo .vsct, crie um submenu que contém um grupo de comandos. Para obter mais informações, consulte Como: Criar Menus, SubMenus e Menus de atalho.

    Este submenu conterá a lista dinâmica.

  2. No Symbols seção do arquivo .vsct, localize o GuidSymbol o elemento que contém os outros comandos. Adicionar um IDSymbol elemento para o MRUListGroup grupo e o cmdidMRUList de comando para o espaço reservado a lista dinâmica, da seguinte maneira.

  3. Defina um grupo, como a seguir.

    <Group guid="guidTopLevelMenuCmdSet" id="MRUListGroup" priority="0x100">
  <Parent guid="guidTopLevelMenuCmdSet" id="SubMenu"/>
</Group>

  4. Definir o novo comando como um Button elemento a Buttons seção.

    1. Definir o guid e id campos para o par de GUID:ID que representa o novo elemento. O par de GUID:ID consiste na name valores da GuidSymbol e IDSymbol elementos da etapa anterior.

      Esse par de GUID:ID é o primeiro em uma lista de comandos dinâmicos que são adicionados em tempo de execução, o VSPackage. Cada comando subseqüente que dinâmico tem uma identificação que é um número maior que a identificação do comando anterior dinâmico.

    2. Definir o type para o atributo botão.

      Um comando dinâmico tem o tipo de botão assim como qualquer outro comando.

    3. Não defina um priority atributo para o comando.

      Este submenu contém apenas uma lista dinâmica. Portanto, a prioridade do primeiro item não importa. Os itens dinâmicos que são adicionados mais tarde têm a mesma prioridade; a ordem na qual cada um é adicionada determina sua posição relativa.

    4. Adicionar um pai elemento que tenha guid e id atributos que correspondem do grupo que foi criado para o submenu.

    5. Adicionar um Comando sinalizador elemento e defina seu valor como DynamicItemStart.

      Isso marca o comando como um espaço reservado.

      Dica

      Todos os outros sinalizadores são ignorados.Se você quiser controlar a visibilidade de um item dinâmico, você deve fazer isso em tempo de execução o VSPackage.

    6. Adicionar um seqüências o elemento que contém um texto de botão elemento e uma CommandName elemento e defina seus valores como o nome do espaço reservado.

      Normalmente, o texto do botão não é visto se o VSPackage pode inicializar a lista dinâmica antes do menu que o contém é mostrado.

    7. Não especificar um ícone elemento.

      Um comando dinâmico não pode ter um ícone associado a ele.

    O exemplo a seguir mostra uma definição de comando completo para um alocador de espaço de lista MRU.

    <Button guid="guidTopLevelMenuCmdSet" id="cmdidMRUList"
        type="Button" priority="0x0100">
  <Parent guid="guidTopLevelMenuCmdSet" id="MRUListGroup" />
  <CommandFlag>DynamicItemStart</CommandFlag>
  <Strings>
    <CommandName>cmdidMRUList</CommandName>
    <ButtonText>MRU Placeholder</ButtonText>
  </Strings>
</Button>

Implementando a lista dinâmica

O Framework de pacote gerenciado (MPF) usa manipuladores de eventos para ocultar os detalhes da IOleCommandTarget interface e sua QueryStatus método. Para um VSPackage que está escrito usando o MPF para oferecer suporte a uma lista dinâmica de comandos de menu, criar uma lista de OleMenuCommand objetos, cada um deles representa um item na lista dinâmica. Cada OleMenuCommand objeto tem o mesmo manipulador de eventos para executar o comando e o mesmo manipulador de eventos para obter o status do comando.

Dica

O procedimento a seguir usa o código de Passo a passo: Adicionar um mais recentemente usada a lista a um Submenu para ilustrar como implementar uma lista dinâmica.No entanto, o código não cria um VSPackage completo.Para obter um exemplo completo, consulte explicação passo a passo.

Para implementar uma lista dinâmica

  1. Adicione a ID à lista de identificações de PkgCmdID.cs.

    public const uint cmdidMRUList = 0x200;

  2. No TopLevelMenuPackage.cs adicione isso usando a instrução.

    using System.Collections;

  3. Vincular o espaço reservado para um OleMenuCommand da instância e atribuir seus manipuladores de eventos. O método no exemplo a seguir é chamado a partir do Initialize() o método do pacote.

    private void InitMRUMenu(OleMenuCommandService mcs)
{
    InitializeMRUList();
    for (int i = 0; i < this.numMRUItems; i++)
    {
        var cmdID = new CommandID(
            GuidList.guidTopLevelMenuCmdSet, this.baseMRUID + i);
        var mc = new OleMenuCommand(
            new EventHandler(OnMRUExec), cmdID);
        mc.BeforeQueryStatus += new EventHandler(OnMRUQueryStatus);
        mcs.AddCommand(mc);
    }
}

    Os exemplos neste procedimento assumem que as seguintes variáveis particulares são usadas.

    private int numMRUItems = 4;
private int baseMRUID = (int)PkgCmdIDList.cmdidMRUList;
private ArrayList mruList;

  4. Use o manipulador de eventos QueryStatus para preencher a lista dinâmica, conforme mostrado no exemplo a seguir.

    private void OnMRUQueryStatus(object sender, EventArgs e)
{
    OleMenuCommand menuCommand = sender as OleMenuCommand;
    if (null != menuCommand)
    {
        int MRUItemIndex = menuCommand.CommandID.ID - this.baseMRUID;
        if (MRUItemIndex >= 0 && MRUItemIndex < this.mruList.Count)
        {
            menuCommand.Text = this.mruList[MRUItemIndex] as string;
        }
    }
}

  5. Implemente o manipulador de Exec para responder quando um item da lista é clicado. O exemplo a seguir atualiza a posição dos itens de lista para que apareça o mais recente na parte superior.

    private void OnMRUExec(object sender, EventArgs e)
{
    var menuCommand = sender as OleMenuCommand;
    if (null != menuCommand)
    {
        int MRUItemIndex = menuCommand.CommandID.ID - this.baseMRUID;
        if (MRUItemIndex >= 0 && MRUItemIndex < this.mruList.Count)
        {
            string selection = this.mruList[MRUItemIndex] as string;
            for (int i = MRUItemIndex; i > 0; i--)
            {
                this.mruList[i] = this.mruList[i - 1];
            }
            this.mruList[0] = selection;
            System.Windows.Forms.MessageBox.Show(
                string.Format(CultureInfo.CurrentCulture,
                              "Selected {0}", selection));
        }
    }
}

    Você também pode usar o Text propriedade ou o CommandID propriedade para identificar qual item está selecionado e responder de acordo.

  6. Controlar a visibilidade do menu ou itens de menu individuais, definindo a Visible propriedade. O código a seguir apresenta um menu ou item de menu invisível.

    var menuCommand = sender as OleMenuCommand;
menuCommand.Visible = false;

    Colocar o código anterior no manipulador de QueryStatus aplica a todo o menu porque ele fornece a sender argumento para esse manipulador. No entanto, colocá-lo no manipulador de Exec afeta apenas o item de menu individuais que está sendo executado.

Consulte também

Conceitos

Como a VSPackages adicionar elementos de Interface do usuário ao IDE

Outros recursos

Comandos, Menus e barras de ferramentas

Tarefas comuns com comandos, Menus e barras de ferramentas