Implementazione dei comandi

  • Articolo

Per implementare un comando in un pacchetto VSPackage, è necessario eseguire le attività seguenti:

  1. Nel file vsct configurare un gruppo di comandi e quindi aggiungerlo. Per altre informazioni, vedere File della tabella dei comandi di Visual Studio (con estensione vsct).

  2. Registrare il comando con Visual Studio.

  3. Implementare il comando .

Le sezioni seguenti illustrano come registrare e implementare i comandi.

Registrare i comandi con Visual Studio

Se il comando deve essere visualizzato in un menu, è necessario aggiungere a ProvideMenuResourceAttribute VSPackage e usare come valore il nome del menu o il relativo ID risorsa.

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

Inoltre, è necessario registrare il comando con .OleMenuCommandService È possibile ottenere questo servizio usando il GetService metodo se il vsPackage è derivato da 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 );
}

Implementare i comandi

Esistono diversi modi per implementare i comandi. Se si desidera un comando di menu statico, ovvero un comando che appare sempre nello stesso modo e nello stesso menu, creare il comando usando MenuCommand come illustrato negli esempi nella sezione precedente. Per creare un comando statico, è necessario fornire un gestore eventi responsabile dell'esecuzione del comando. Poiché il comando è sempre abilitato e visibile, non è necessario specificare lo stato di Visual Studio. Se si vuole modificare lo stato di un comando a seconda di determinate condizioni, è possibile creare il comando come istanza della OleMenuCommand classe e, nel relativo costruttore, fornire un gestore eventi per eseguire il comando e un QueryStatus gestore per notificare a Visual Studio quando lo stato del comando cambia. È anche possibile implementare IOleCommandTarget come parte di una classe di comando o implementare IVsHierarchy se si fornisce un comando come parte di un progetto. Le due interfacce e la OleMenuCommand classe hanno tutti metodi che notificano a Visual Studio una modifica dello stato di un comando e altri metodi che forniscono l'esecuzione del comando.

Quando un comando viene aggiunto al servizio comandi, diventa una catena di comandi. Quando si implementano i metodi di notifica dello stato e di esecuzione per il comando, prestare attenzione a fornire solo per quel particolare comando e per passare tutti gli altri casi agli altri comandi della catena. Se non si passa il comando su (in genere restituendo OLECMDERR_E_NOTSUPPORTED), Visual Studio potrebbe smettere di funzionare correttamente.

Metodi QueryStatus

Se si implementa il QueryStatus metodo o il QueryStatusCommand metodo , verificare la presenza del GUID del set di comandi a cui appartiene il comando e l'ID del comando. Segui queste linee guida:

  • Se il GUID non viene riconosciuto, l'implementazione di uno dei due metodi deve restituire OLECMDERR_E_UNKNOWNGROUP.

  • Se l'implementazione di uno dei due metodi riconosce il GUID ma non ha implementato il comando, il metodo deve restituire OLECMDERR_E_NOTSUPPORTED.

  • Se l'implementazione di uno dei due metodi riconosce sia il GUID che il comando, il metodo deve impostare il campo dei flag di comando di ogni comando (nel prgCmds parametro) usando i flag seguenti OLECMDF :

    • OLECMDF_SUPPORTED: il comando è supportato.

    • OLECMDF_INVISIBLE: il comando non deve essere visibile.

    • OLECMDF_LATCHED: il comando è attivato o disattivato e sembra essere stato controllato.

    • OLECMDF_ENABLED: il comando è abilitato.

    • OLECMDF_DEFHIDEONCTXTMENU: il comando deve essere nascosto se viene visualizzato in un menu di scelta rapida.

    • OLECMDF_NINCHED: il comando è un controller di menu e non è abilitato, ma il relativo elenco a discesa non è vuoto ed è ancora disponibile. Questo flag viene usato raramente.

  • Se il comando è stato definito nel file con estensione vsct con il TextChanges flag , impostare i parametri seguenti:

    • Impostare l'elemento rgwz del pCmdText parametro sul nuovo testo del comando.

    • Impostare l'elemento cwActual del pCmdText parametro sulla dimensione della stringa di comando.

Assicurarsi inoltre che il contesto corrente non sia una funzione di automazione, a meno che il comando non sia specificamente progettato per gestire le funzioni di automazione.

Per indicare che è supportato un comando specifico, restituire S_OK. Per tutti gli altri comandi, restituire OLECMDERR_E_NOTSUPPORTED.

Nell'esempio seguente il QueryStatus metodo verifica innanzitutto che il contesto non sia una funzione di automazione, quindi trova il GUID e l'ID comando corretti del set di comandi. Il comando stesso è impostato per essere abilitato e supportato. Non sono supportati altri comandi.

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;
    }
}

Metodi di esecuzione

L'implementazione del Exec metodo è simile all'implementazione del QueryStatus metodo . Assicurarsi innanzitutto che il contesto non sia una funzione di automazione. Quindi, testare sia il GUID che l'ID comando. Se il GUID o l'ID comando non viene riconosciuto, restituire OLECMDERR_E_NOTSUPPORTED.

Per gestire il comando, eseguirlo e restituire S_OK se l'esecuzione ha esito positivo. Il comando è responsabile del rilevamento e della notifica degli errori; restituisce pertanto un codice di errore se l'esecuzione non riesce. Nell'esempio seguente viene illustrato come implementare il metodo di esecuzione.

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;
}

Contenuto correlato