Partilhar via

Implementação de comandos

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 deve aparecer em um menu, você deve adicionar o ProvideMenuResourceAttribute ao seu VSPackage e usar como um valor o 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 este serviço usando o método GetService se o seu VSPackage for 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 aparece sempre 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 responsável pela execução do comando. Como o comando está sempre habilitado e visível, não é necessário fornecer seu status para o Visual Studio. Se você quiser 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 for alterado. Você também pode implementar IOleCommandTarget como parte de uma classe de comando ou, você pode implementar IVsHierarchy se você estiver fornecendo um comando como parte de um projeto. As duas interfaces e a OleMenuCommand 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 execução do comando.

Quando um comando é adicionado ao serviço de comando, ele se torna um de uma cadeia de comandos. Ao implementar os métodos de notificação de status e execução para o comando, tome cuidado para fornecer apenas 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 QueryStatus método ou o QueryStatusCommand método, verifique o GUID do conjunto de comandos ao qual o 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 qualquer 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 é ativado e parece ter sido verificado.

    • OLECMDF_ENABLED: O comando está ativado.

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

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

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

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

    • Configure o elemento cwActual do parâmetro pCmdText para o tamanho da cadeia 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ê suporta um comando específico, retorne S_OK. Para todos os outros comandos, retorne OLECMDERR_E_NOTSUPPORTED.

No exemplo a seguir, o QueryStatus 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 ID de comando corretos. O comando em si está definido para ser ativado 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 Exec método assemelha-se à implementação do QueryStatus método. Primeiro, certifique-se de que o contexto não é uma função de automação. Em seguida, teste o GUID e a 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 deteçã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

  • Last updated on