Compartir a través de

tutorial: Utilizando una tecla de método abreviado con una extensión del editor

  • Artículo

Puede responder a las teclas de método abreviado en la extensión del editor. El siguiente tutorial se muestra cómo agregar un elemento gráfico de vista a una vista de texto utilizando las teclas de método abreviado. Este tutorial se basa en la plantilla del editor del elemento gráfico de la ventanilla, y permite agregar la opción gráfica mediante carácter +.

Requisitos previos

Para completar este tutorial, debe instalar Visual Studio 2010 SDK.

Nota

Para obtener más información sobre el SDK de Visual Studio, vea Información general de Visual Studio que extiende.Para averiguar cómo descargar el SDK de Visual Studio, vea Centro para desarrolladores de extensibilidad de Visual Studio en el sitio web de MSDN.

Crear un proyecto administrado del marco (MEF) de extensibilidad

Para crear un proyecto de MEF

  1. Cree un proyecto de elemento gráfico de la ventanilla del editor. Llame a la solución KeyBindingTest.

  2. Abra el archivo source.extension.vsixmanifest del editor de Manifiesto VSIX.

  3. Asegúrese de que la dirección de Content contiene un tipo de contenido componente MEF y que Path está establecido en KeyBindingTest.dll.

  4. Guarde y cierre Source.extension.vsixmanifest.

  5. Agregue las siguientes referencias y CopyLocal determinado a false:

    Microsoft.VisualStudio.Editor

    Microsoft.VisualStudio.OLE.Interop

    Microsoft.VisualStudio.Shell

    Microsoft.VisualStudio.TextManager.Interop

  6. Elimine el archivo de clase de KeyBindingTestFactory.

En el archivo de clase KeyBindingTest, cambie el nombre de clase a PurpleCornerBox. Cambie el constructor también. En el constructor, cambie la línea:

_adornmentLayer = view.GetAdornmentLayer("KeyBindingTest")

_adornmentLayer = view.GetAdornmentLayer("KeyBindingTest");

por

_adornmentLayer = view.GetAdornmentLayer("PurpleCornerBox")

_adornmentLayer = view.GetAdornmentLayer("PurpleCornerBox");

Definición de filtro de comando

El filtro de comando es una implementación de IOleCommandTarget, que administra el comando creando instancias del elemento gráfico.

Para definir el filtro de comando

  1. Agregue un archivo de clase y denomínelo KeyBindingCommandFilter.

  2. Agregue las instrucciones using siguientes.

    Imports System
Imports System.Runtime.InteropServices
Imports Microsoft.VisualStudio.OLE.Interop
Imports Microsoft.VisualStudio
Imports Microsoft.VisualStudio.Text.Editor

    using System;
using System.Runtime.InteropServices;
using Microsoft.VisualStudio.OLE.Interop;
using Microsoft.VisualStudio;
using Microsoft.VisualStudio.Text.Editor;

  3. la clase denominada KeyBindingCommandFilter debe heredar de IOleCommandTarget.

    Friend Class KeyBindingCommandFilter
    Implements IOleCommandTarget

    internal class KeyBindingCommandFilter : IOleCommandTarget

  4. Agregue campos privados para que la vista de texto, el comando siguiente en la cadena de comando, y un marcador representan si el filtro de comando ya se ha agregado.

    Private m_textView As IWpfTextView
Friend m_nextTarget As IOleCommandTarget
Friend m_added As Boolean 
Friend m_adorned As Boolean

    private IWpfTextView m_textView;
internal IOleCommandTarget m_nextTarget;
internal bool m_added;
internal bool m_adorned;

  5. Agregue un constructor que establezca la vista de texto.

    Public Sub New(ByVal textView As IWpfTextView)
    m_textView = textView
    m_adorned = False 
End Sub

    public KeyBindingCommandFilter(IWpfTextView textView)
{
    m_textView = textView;
    m_adorned = false;
}

  6. implemente el método de QueryStatus() como sigue.

    Private Function QueryStatus(ByRef pguidCmdGroup As Guid, ByVal cCmds As UInteger, ByVal prgCmds() As OLECMD, ByVal pCmdText As IntPtr) As Integer Implements IOleCommandTarget.QueryStatus
    Return m_nextTarget.QueryStatus(pguidCmdGroup, cCmds, prgCmds, pCmdText)
End Function

    int IOleCommandTarget.QueryStatus(ref Guid pguidCmdGroup, uint cCmds, OLECMD[] prgCmds, IntPtr pCmdText)
{
    return m_nextTarget.QueryStatus(ref pguidCmdGroup, cCmds, prgCmds, pCmdText);
}

  7. Implemente el método de Exec() de modo que agregue un cuadro púrpura a vista si se escribe en + el carácter.

    Private Function Exec(ByRef pguidCmdGroup As Guid, ByVal nCmdID As UInteger, ByVal nCmdexecopt As UInteger, ByVal pvaIn As IntPtr, ByVal pvaOut As IntPtr) As Integer Implements IOleCommandTarget.Exec
    If m_adorned = False Then 
        Dim typedChar As Char = Char.MinValue

        If pguidCmdGroup = VSConstants.VSStd2K AndAlso nCmdID = CUInt(VSConstants.VSStd2KCmdID.TYPECHAR) Then
            typedChar = CChar(ChrW(Marshal.GetObjectForNativeVariant(pvaIn)))
            If typedChar.Equals("+"c) Then 
                Dim TempPurpleCornerBox As PurpleCornerBox = New PurpleCornerBox(m_textView)
                m_adorned = True 
            End If 
        End If 
    End If 
    Return m_nextTarget.Exec(pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut)
End Function

    int IOleCommandTarget.Exec(ref Guid pguidCmdGroup, uint nCmdID, uint nCmdexecopt, IntPtr pvaIn, IntPtr pvaOut)
{
    if (m_adorned == false)
    {
        char typedChar = char.MinValue;

        if (pguidCmdGroup == VSConstants.VSStd2K && nCmdID == (uint)VSConstants.VSStd2KCmdID.TYPECHAR)
        {
            typedChar = (char)(ushort)Marshal.GetObjectForNativeVariant(pvaIn);
            if (typedChar.Equals('+'))
            {
                new PurpleCornerBox(m_textView);
                m_adorned = true;
            }
        }
    }
    return m_nextTarget.Exec(ref pguidCmdGroup, nCmdID, nCmdexecopt, pvaIn, pvaOut);
}

Agregar el proveedor de filtro de comando

El proveedor del elemento gráfico debe agregar un filtro de comando a la vista de texto. En este ejemplo, el proveedor implementa IVsTextViewCreationListener para escuchar los eventos de la creación de la vista de texto. Este proveedor del elemento gráfico también exporta el nivel del elemento gráfico, que define el orden Z del elemento gráfico.

Para agregar el proveedor de filtro de comando

  1. Agregue un archivo de clase y denomínelo KeyBindingFilterProvider.

  2. Agregue las instrucciones using siguientes.

    Imports System
Imports System.Collections.Generic
Imports System.ComponentModel.Composition
Imports Microsoft.VisualStudio
Imports Microsoft.VisualStudio.OLE.Interop
Imports Microsoft.VisualStudio.Utilities
Imports Microsoft.VisualStudio.Editor
Imports Microsoft.VisualStudio.Text.Editor
Imports Microsoft.VisualStudio.TextManager.Interop

    using System;
using System.Collections.Generic;
using System.ComponentModel.Composition;
using Microsoft.VisualStudio;
using Microsoft.VisualStudio.OLE.Interop;
using Microsoft.VisualStudio.Utilities;
using Microsoft.VisualStudio.Editor;
using Microsoft.VisualStudio.Text.Editor;
using Microsoft.VisualStudio.TextManager.Interop;

  3. agregue una clase denominada KeyBindingFilterProvider que herede de IVsTextViewCreationListener, y exportela con un tipo de contenido de “texto” y TextViewRoleAttribute de Editable.

    <Export(GetType(IVsTextViewCreationListener)), ContentType("text"), TextViewRole(PredefinedTextViewRoles.Editable)>
Friend Class KeyBindingCommandFilterProvider
    Implements IVsTextViewCreationListener

    [Export(typeof(IVsTextViewCreationListener))]
[ContentType("text")]
[TextViewRole(PredefinedTextViewRoles.Editable)]
internal class KeyBindingCommandFilterProvider : IVsTextViewCreationListener

  4. Agregue la definición del elemento gráfico.

    <Export(GetType(AdornmentLayerDefinition)), Name("PurpleCornerBox"), Order(), TextViewRole(PredefinedTextViewRoles.Editable)>
Friend keybindingAdornmentLayer As AdornmentLayerDefinition

    [Export(typeof(AdornmentLayerDefinition))]
[Name("PurpleCornerBox")]
[Order()]
[TextViewRole(PredefinedTextViewRoles.Editable)]
internal AdornmentLayerDefinition keybindingAdornmentLayer;

  5. Para obtener el adaptador de vista de texto, debe importar IVsEditorAdaptersFactoryService.

    <Import(GetType(IVsEditorAdaptersFactoryService))>
Friend editorFactory As IVsEditorAdaptersFactoryService = Nothing

    [Import(typeof(IVsEditorAdaptersFactoryService))]
internal IVsEditorAdaptersFactoryService editorFactory = null;

  6. Implemente el método de VsTextViewCreated de modo que agregue KeyBindingCommandFilter.

    Public Sub VsTextViewCreated(ByVal textViewAdapter As IVsTextView) Implements IVsTextViewCreationListener.VsTextViewCreated
    Dim textView As IWpfTextView = editorFactory.GetWpfTextView(textViewAdapter)
    If textView Is Nothing Then 
        Return 
    End If

    AddCommandFilter(textViewAdapter, New KeyBindingCommandFilter(textView))
End Sub

    public void VsTextViewCreated(IVsTextView textViewAdapter)
{
    IWpfTextView textView = editorFactory.GetWpfTextView(textViewAdapter);
    if (textView == null)
        return;

    AddCommandFilter(textViewAdapter, new KeyBindingCommandFilter(textView));
}

  7. El controlador de AddCommandFilter obtiene el adaptador de vista de texto y agrega el filtro del comando.

    Private Sub AddCommandFilter(ByVal viewAdapter As IVsTextView, ByVal commandFilter As KeyBindingCommandFilter)
    If commandFilter.m_added = False Then 
        'get the view adapter from the editor factory 
        Dim [next] As IOleCommandTarget
        Dim hr As Integer = viewAdapter.AddCommandFilter(commandFilter, [next])

        If hr = VSConstants.S_OK Then
            commandFilter.m_added = True 
            'you'll need the next target for Exec and QueryStatus 
            If [next] IsNot Nothing Then
                commandFilter.m_nextTarget = [next]
            End If 
        End If 
    End If 
End Sub

    void AddCommandFilter(IVsTextView viewAdapter, KeyBindingCommandFilter commandFilter)
{
    if (commandFilter.m_added == false)
    {
        //get the view adapter from the editor factory
        IOleCommandTarget next;
        int hr = viewAdapter.AddCommandFilter(commandFilter, out next);

        if (hr == VSConstants.S_OK)
        {
            commandFilter.m_added = true;
            //you'll need the next target for Exec and QueryStatus 
            if (next != null)
                commandFilter.m_nextTarget = next;
        }
    }
}

Compilar y probar el código

Para probar este código, compile la solución de KeyBindingTest y ejecútela en la instancia experimental.

para compilar y probar la solución de KeyBindingTest

  1. Compile la solución.

  2. Al ejecutar este proyecto en el depurador, una segunda instancia de Visual Studio se crea instancias.

  3. Cree o abra un archivo de texto, y haga clic en cualquier parte en la vista de texto.

  4. tipo +.

    Cambie el tamaño de la vista de texto.

    un cuadrado púrpura debe aparecer en la esquina superior derecha de la vista de texto.

Vea también

Tareas

tutorial: vincular un tipo de contenido a una extensión de nombre de archivo