Partilhar via

Implementação de comando

  • Artigo

Para implementar um comando em um VSPackage, você deve executar as seguintes tarefas:

  1. No arquivo .vsct, configure um grupo de comandos e adicione o comando a ele. Para obter mais informações, consulte Arquivos de tabela de comando (.vsct) do Visual Studio.

  2. Registre o comando com o Visual Studio.

  3. Implemente o comando.

As seções a seguir explicam como registrar e implementar comandos.

Registrar comandos com o Visual Studio

Se o comando for aparecer em um menu, você deverá adicionar o ao VSPackage e usar como valor o ProvideMenuResourceAttribute nome do menu ou sua ID de recurso.

[ProvideMenuResource("Menus.ctmenu", 1)]
public sealed class MyPackage : Package
{
    // ...
}

Além disso, você deve registrar o comando com o OleMenuCommandService. Você pode obter esse serviço usando o GetService método se seu VSPackage é derivado de Package.

OleMenuCommandService mcs = GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
if (mcs is not null)
{
    // Create the command for the menu item.
    CommandID menuCommandID = new CommandID(guidCommandGroup, myCommandID);
    MenuCommand menuItem = new MenuCommand(MenuItemCallback, menuCommandID);
    mcs.AddCommand(menuItem);
}

Implementar comandos

Há várias maneiras de implementar comandos. Se você quiser um comando de menu estático, que é um comando que sempre aparece da mesma maneira e no mesmo menu, crie o comando usando MenuCommand como mostrado nos exemplos na seção anterior. Para criar um comando estático, você deve fornecer um manipulador de eventos que é responsável pela execução do comando. Como o comando está sempre habilitado e visível, você não precisa fornecer seu status para o Visual Studio. Se você deseja alterar o status de um comando dependendo de determinadas condições, você pode criar o comando como uma instância da classe e, em seu construtor, fornecer um manipulador de OleMenuCommand eventos para executar o comando e um QueryStatus manipulador para notificar o Visual Studio quando o status do comando é alterado. Você também pode implementar como parte de uma classe de comando ou, você pode implementar IOleCommandTarget IVsHierarchy se você estiver fornecendo um comando como parte de um projeto. As duas interfaces e a classe têm métodos que notificam o Visual Studio de uma alteração no status de um comando e outros métodos que fornecem a OleMenuCommand execução do comando.

Quando um comando é adicionado ao serviço de comando, ele se torna um de uma cadeia de comandos. Ao implementar a notificação de status e os métodos de execução para o comando, tenha o cuidado de fornecer apenas para esse comando específico e passar todos os outros casos para os outros comandos na cadeia. Se você não conseguir passar o comando (geralmente retornando OLECMDERR_E_NOTSUPPORTED), Visual Studio pode parar de funcionar corretamente.

Métodos QueryStatus

Se você estiver implementando o método ou o método, verifique o GUID do conjunto de comandos ao qual o QueryStatus QueryStatusCommand comando pertence e a ID do comando. Siga estas diretrizes:

  • Se o GUID não for reconhecido, sua implementação de qualquer um dos métodos deverá retornar OLECMDERR_E_UNKNOWNGROUP.

  • Se a implementação de qualquer um dos métodos reconhecer o GUID, mas não tiver implementado o comando, o método deverá retornar OLECMDERR_E_NOTSUPPORTED.

  • Se a implementação de um dos métodos reconhecer o GUID e o comando, o método deverá definir o campo command-flags de cada comando (no prgCmds parâmetro) usando os seguintes OLECMDF sinalizadores:

    • OLECMDF_SUPPORTED: O comando é suportado.

    • OLECMDF_INVISIBLE: O comando não deve estar visível.

    • OLECMDF_LATCHED: O comando está ativado e parece ter sido marcado.

    • OLECMDF_ENABLED: O comando está habilitado.

    • OLECMDF_DEFHIDEONCTXTMENU: O comando deve estar oculto se aparecer em um menu de atalho.

    • OLECMDF_NINCHED: O comando é um controlador de menu e não está habilitado, mas sua lista de menus suspensos não está vazia e ainda está disponível. (Esse sinalizador raramente é usado.)

  • Se o comando foi definido no arquivo .vsct com o TextChanges sinalizador, defina os seguintes parâmetros:

    • Defina o rgwz pCmdText elemento do parâmetro para o novo texto do comando.

    • Defina o elemento do pCmdText parâmetro para o cwActual tamanho da cadeia de caracteres de comando.

Além disso, certifique-se de que o contexto atual não é uma função de automação, a menos que seu comando se destine especificamente a lidar com funções de automação.

Para indicar que você oferece suporte a um comando específico, retorne S_OK. Para todos os outros comandos, retorne OLECMDERR_E_NOTSUPPORTED.

No exemplo a seguir, o método primeiro certifica-se de que o contexto não é uma função de automação e, em seguida, localiza o GUID e o QueryStatus ID de comando corretos. O comando em si está definido para ser habilitado e suportado. Nenhum outro comando é suportado.

public int QueryStatus(ref Guid pguidCmdGroup, uint cCmds, OLECMD[] prgCmds, IntPtr pCmdText)
{
    if (!VsShellUtilities.IsInAutomationFunction(m_provider.ServiceProvider))
    {
        if (pguidCmdGroup == VSConstants.VSStd2K && cCmds > 0)
        {
            // make the Right command visible
            if ((uint)prgCmds[0].cmdID == (uint)VSConstants.VSStd2KCmdID.RIGHT)
            {
                prgCmds[0].cmdf = (int)Microsoft.VisualStudio.OLE.Interop.Constants.MSOCMDF_ENABLED | (int)Microsoft.VisualStudio.OLE.Interop.Constants.MSOCMDF_SUPPORTED;
                return VSConstants.S_OK;
            }
        }
    }
    return Constants.OLECMDERR_E_NOTSUPPORTED;
}

Métodos de execução

A implementação do método assemelha-se à implementação do Exec QueryStatus método. Primeiro, certifique-se de que o contexto não é uma função de automação. Em seguida, teste o GUID e o ID do comando. Se o GUID ou ID de comando não for reconhecido, retorne OLECMDERR_E_NOTSUPPORTED.

Para manipular o comando, execute-o e retorne S_OK se a execução for bem-sucedida. Seu comando é responsável pela detecção e notificação de erros; Portanto, retorne um código de erro se a execução falhar. O exemplo a seguir demonstra como o método de execução deve ser implementado.

public int Exec(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut)
{
    if (!VsShellUtilities.IsInAutomationFunction(m_provider.ServiceProvider))
    {
        if (pguidCmdGroup == VSConstants.GUID_VSStandardCommandSet97)
        {
             if (nCmdID == (uint)VSConstants.VSStd2KCmdID.RIGHT)
            {
                // execute the command
                return VSConstants.S_OK;
            }
        }
    }
    return Constants.OLECMDERR_E_NOTSUPPORTED;
}

Conteúdo relacionado