Implementação de comando

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

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

  2. Registre o comando com Visual Studio.

  3. Implemente o comando.

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

Registrar comandos com Visual Studio

Se o comando for exibido em um menu, você deverá adicionar o ProvideMenuResourceAttribute ao seu VSPackage e usar como um valor do 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 for derivado de Package .

OleMenuCommandService mcs = GetService(typeof(IMenuCommandService)) as OleMenuCommandService;
if ( null != mcs )
{
    // 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 conforme 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, você não precisa fornecer seu status para Visual Studio. se você quiser alterar o status de um comando dependendo de determinadas condições, poderá criar o comando como uma instância da OleMenuCommand classe e, em seu construtor, fornecer um manipulador de eventos para executar o comando e um QueryStatus manipulador para notificar Visual Studio quando o status do comando for alterado. Você também pode implementar IOleCommandTarget como parte de uma classe de comando ou pode implementar IVsHierarchy se estiver fornecendo um comando como parte de um projeto. todas as duas interfaces e a OleMenuCommand classe têm métodos que notificam 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 a notificação de status e os métodos de execução para o comando, tome cuidado para fornecer somente para esse comando específico e para passar todos os outros casos para os outros comandos na cadeia. se você não passar o comando (normalmente, retornando OLECMDERR_E_NOTSUPPORTED ), Visual Studio poderá 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, a implementação de um dos métodos deverá retornar OLECMDERR_E_UNKNOWNGROUP .

  • Se a implementação de 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 de sinalizadores de comando de cada comando (no prgCmds parâmetro) usando os seguintes OLECMDF sinalizadores:

    • OLECMDF_SUPPORTED: Há suporte para o comando.

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

    • OLECMDF_LATCHED: O comando é alternado e parece ter sido verificado.

    • OLECMDF_ENABLED: O comando está habilitado.

    • OLECMDF_DEFHIDEONCTXTMENU: O comando deverá ficar oculto se aparecer em um menu de atalho.

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

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

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

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

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

Para indicar que você dá suporte a 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 verifica se o contexto não é uma função de automação e localiza o GUID do conjunto de comandos correto e a ID do comando. O próprio comando é definido como habilitado e com suporte. Não há suporte para nenhum outro comando.

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 é semelhante à implementação do QueryStatus método. Primeiro, verifique se o contexto não é uma função de automação. Em seguida, teste o GUID e a ID do comando. Se o GUID ou a ID do comando não for reconhecido, retorne OLECMDERR_E_NOTSUPPORTED .

Para manipular o comando, execute-o e retorne S_OK se a execução for realizada com sucesso. O 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) uint)VSConstants.VSStd2KCmdID.RIGHT)
            {
                //execute the command
                return VSConstants.S_OK;
            }
        }
    }
    return Constants.OLECMDERR_E_NOTSUPPORTED;
}

Confira também