Compartilhar via

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 adicione o comando a ele. Para obter mais informações, consulte arquivos da tabela de comandos do Visual Studio (.vsct).

  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 ProvideMenuResourceAttribute ao seu VSPackage e usar como valor o nome do menu ou seu identificador 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 utilizando o método GetService se o seu VSPackage for uma derivação 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 responsável pela execução do comando. Como o comando está sempre habilitado e visível, você não precisa fornecer seu status ao 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 o Visual Studio quando o status do comando for alterado. Você também pode implementar IOleCommandTarget como parte de uma classe de comando ou implementar IVsHierarchy se 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 uma de uma cadeia de comandos. Ao implementar os métodos de notificação e execução de status para o comando, tome cuidado para aplicar apenas a esse comando específico e encaminhar todos os outros casos para os outros comandos na cadeia. Se você não passar o comando (geralmente retornando OLECMDERR_E_NOTSUPPORTED), o 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, sua implementação de ambos os 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 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 está ativado e parece ter sido verificado.

    • OLECMDF_ENABLED: o comando está habilitado.

    • OLECMDF_DEFHIDEONCTXTMENU: o comando deverá 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 continua 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 elemento do pCmdText parâmetro como o novo texto do comando.

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

Além disso, verifique se 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ê 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 garante que o contexto não seja uma função de automação e, em seguida, localiza o GUID do conjunto de comandos correto e a ID de comando. O comando em si está definido para ser habilitado e suportado. Não há suporte para outros comandos.

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

  • Last updated on