Partager via

Procédure pas - à - pas : À l'aide d'une commande d'environnement avec une extension de l'éditeur

  • Article

D'un VSPackage, vous pouvez ajouter des fonctionnalités telles que les commandes de menu dans l'éditeur. Cette procédure pas - à - pas montre comment ajouter un ornement à un affichage de texte dans l'éditeur en appelant une commande de menu.

Cette procédure pas - à - pas montre l'utilisation d'un VSPackage avec un composant managé d' (MEF)infrastructure d'extensibilité. Vous devez utiliser un VSPackage pour stocker la commande de menu avec le shell Visual Studio, et vous pouvez utiliser la commande pour accéder à la composant MEF.

Composants requis

Pour exécuter cette procédure, vous devez installer Kit de développement logiciel Visual Studio 2010.

Notes

Pour plus d'informations sur le kit de développement Visual Studio, consultez Étendre la présentation de Visual Studio.Pour savoir comment télécharger le kit de développement Visual Studio, consultez Visual Studio Extensibility Developer Center sur le site Web MSDN.

Emplacements du modèle de projet de package Visual Studio

Le modèle de projet de package Visual Studio se trouve dans trois emplacements différents dans la boîte de dialogue Nouveau projet :

  1. Sous l'extensibilité Visual Basic. Le langage par défaut du projet est en Visual Basic.

  2. Sous l'extensibilité c#. Le langage par défaut du projet est c#.

  3. Sous d'autres projets contenus l'extensibilité. Le langage par défaut du projet est en C++

créer une commande de menu VSPackage

Créez un VSPackage qui place une commande de menu nommée ajoutez l'ornement dans le menu d' Outils .

pour créer une commande de menu VSPackage

  1. Créer un package Visual Studio et nommez -le MenuCommandTest. Cliquez sur OK.

  2. Sur la page d'accueil, cliquez sur Suivant.

  3. Dans la page de Sélectionner un langage de programmation , sélectionnez Visual Basic ou Visual C#, assurez -vous que générez un nouveau fichier de clé pour signer l'assembly est sélectionné, puis cliquez sur Suivant.

  4. Dans la page de Les informations de base d'un VSPackage , dans Nom VSPackageMenuCommanden forme de boîte, puis cliquez sur Suivant.

  5. Dans la page de Sélectionnez les options d'un VSPackage , sélectionnez Commande de menu puis cliquez sur Suivant.

  6. sur la page d' options de commande , dans nom de la commandeajoutez l'ornementen forme de boîte. Dans la zone d' ID de commande , tapez cmdidAddAdornment. Cliquez sur Suivant.

  7. Dans la page de sélectionnez les options de test , désactivez les deux options puis cliquez sur Terminer.

  8. une solution nommée MenuCommandTest est ouverte. Le fichier de MenuCommandTestPackage un code qui crée la commande de menu et la place dans le menu d' Outils . À ce stade, la commande provoque un seul message à afficher. Les étapes suivantes indiquent comment modifier cette option pour afficher l'ornement de commentaire.

  9. Ouvrez le fichier source.extension.vsixmanifest dans l'éditeur de manifeste VSIX. Il doit avoir une ligne d' Content pour un VSPackage nommé MenuCommand.

  10. Enregistrez et fermez le fichier Source.extension.vsixmanifest.

Ajouter une extension MEF à la solution d'un VSPackage

Pour ajouter l'extension MEF à la solution d'un VSPackage

  1. Cliquez avec le bouton droit sur le nœud de la solution dans l'Explorateur de solutions, cliquez sur Ajouter, puis sur Nouveau projet. Dans la boîte de dialogue d' Ajouter un nouveau projet , l'extensibilité de cliquez sur sous Visual Basic ou le Visual C#, puis EditorClassifier. nommez le projet CommentAdornmentTest.

  2. Dans la mesure où ce projet interagira avec l'assembly fort-nommé d'un VSPackage, vous devez signer l'assembly. Vous pouvez réutiliser le fichier de clé déjà créé pour l'assembly d'un VSPackage.

    1. Ouvrez les propriétés du projet et sélectionnez la page de Signing .

    2. sélectionnez Signer l'assembly.

    3. Sous Choisir un fichier de clé de nom fort, sélectionnez le fichier Key.snk qui a été généré pour l'assembly de MenuCommandTest.

    4. Enregistrez le projet.

En référence à l'extension MEF dans le projet de VSPackage

Étant donné que vous ajoutez un composant MEF au VSPackage, vous devez spécifier les deux types de contenu dans le manifeste.

Notes

Pour plus d'informations sur MEF, consultez Managed Extensibility Framework (MEF).

Pour faire référence au composant MEF dans le projet de VSPackage

  1. Dans le projet de MenuCommandTest, ouvrez le fichier source.extension.vsixmanifest dans l'éditeur de manifeste VSIX.

  2. Sous Contenu se en-tête, cliquez sur Ajouter du contenu. Dans la liste de sélectionnez le type de contenu , sélectionnez Composant MEF. sous Sélectionner une source, sélectionnez CommentAdornmentTest.

  3. Enregistrez et fermez le fichier source.extension.vsixmanifest.

  4. ajoutez une référence au projet de CommentAdornmentTest.

définir un ornement de commentaire

L'ornement de commentaire lui-même est constitué d' ITrackingSpan qui suit le texte sélectionné, et de certaines chaînes qui représentent l'auteur et la description du texte.

pour définir un ornement de commentaire

  1. dans le projet de CommentAdornmentTest, supprimez les fichiers de classe existants.

  2. ajoutez un nouveau fichier de classe et nommez-le CommentAdornment.

  3. ajoutez l'instruction suivante d' using .

    Imports Microsoft.VisualStudio.Text

    using Microsoft.VisualStudio.Text;

  4. ajoutez une classe nommée CommentAdornment.

    Friend Class CommentAdornment

    internal class CommentAdornment

  5. ajoutez trois champs à la classe d' CommentAdornment pour ITrackingSpan, l'auteur, et la description.

    Public ReadOnly Span As ITrackingSpan
Public ReadOnly Author As String 
Public ReadOnly Text As String

    public readonly ITrackingSpan Span;
public readonly string Author;
public readonly string Text;

  6. ajoutez un constructeur qui initialise les champs.

    Public Sub New(ByVal span As SnapshotSpan, ByVal author As String, ByVal text As String)
    Me.Span = span.Snapshot.CreateTrackingSpan(span, SpanTrackingMode.EdgeExclusive)
    Me.Author = author
    Me.Text = text
End Sub

    public CommentAdornment(SnapshotSpan span, string author, string text)
{
    this.Span = span.Snapshot.CreateTrackingSpan(span, SpanTrackingMode.EdgeExclusive);
    this.Author = author;
    this.Text = text;
}

créer un élément visuel pour l'ornement

Vous devez également définir un élément visuel pour l'ornement. Pour cette procédure pas - à - pas, définissez un contrôle qui hérite de la (WPF) classe CanvasWindows Presentation Foundation.

pour créer un élément visuel pour l'ornement

  1. Créez une classe dans le projet de CommentAdornmentTest et nommez CommentBlock.

  2. ajoutez les instructions suivantes d' using .

    Imports System
Imports System.Windows
Imports System.Windows.Controls
Imports System.Windows.Media
Imports System.Windows.Shapes

    using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
using System.Windows.Shapes;

  3. Définissez la classe d' CommentBlock hériter d' Canvas.

    Friend Class CommentBlock
    Inherits Canvas

    internal class CommentBlock : Canvas

  4. Ajoutez des champs privés pour définir les aspects visuels de l'ornement.

    Private textGeometry As Geometry
Private commentGrid As Grid
Private Shared brush As Brush
Private Shared solidPen As Pen
Private Shared dashPen As Pen

    private Geometry textGeometry;
private Grid commentGrid;
private static Brush brush;
private static Pen solidPen;
private static Pen dashPen;

  5. ajoutez un constructeur qui définit l'ornement de commentaire et ajoute le texte approprié.

    Public Sub New(ByVal textRightEdge As Double, ByVal viewRightEdge As Double, ByVal newTextGeometry As Geometry, ByVal author As String, ByVal body As String)
    If brush Is Nothing Then
        brush = New SolidColorBrush(Color.FromArgb(&H20, &H0, &HFF, &H0))
        brush.Freeze()
        Dim penBrush As Brush = New SolidColorBrush(Colors.Green)
        penBrush.Freeze()
        solidPen = New Pen(penBrush, 0.5)
        solidPen.Freeze()
        dashPen = New Pen(penBrush, 0.5)
        dashPen.DashStyle = DashStyles.Dash
        dashPen.Freeze()
    End If 

    Me.textGeometry = newTextGeometry

    Dim tb1 As New TextBlock()
    tb1.Text = author
    Dim tb2 As New TextBlock()
    tb2.Text = body

    Const MarginWidth As Integer = 8
    Me.commentGrid = New Grid()
    Me.commentGrid.RowDefinitions.Add(New RowDefinition())
    Me.commentGrid.RowDefinitions.Add(New RowDefinition())
    Dim cEdge As New ColumnDefinition()
    cEdge.Width = New GridLength(MarginWidth)
    Dim cEdge2 As New ColumnDefinition()
    cEdge2.Width = New GridLength(MarginWidth)
    Me.commentGrid.ColumnDefinitions.Add(cEdge)
    Me.commentGrid.ColumnDefinitions.Add(New ColumnDefinition())
    Me.commentGrid.ColumnDefinitions.Add(cEdge2)

    Dim rect As New System.Windows.Shapes.Rectangle()
    rect.RadiusX = 6
    rect.RadiusY = 3
    rect.Fill = brush
    rect.Stroke = Brushes.Green

    Dim inf As New Size(Double.PositiveInfinity, Double.PositiveInfinity)
    tb1.Measure(inf)
    tb2.Measure(inf)
    Dim middleWidth As Double = Math.Max(tb1.DesiredSize.Width, tb2.DesiredSize.Width)
    Me.commentGrid.Width = middleWidth + 2 * MarginWidth
    Grid.SetColumn(rect, 0)
    Grid.SetRow(rect, 0)
    Grid.SetRowSpan(rect, 2)
    Grid.SetColumnSpan(rect, 3)
    Grid.SetRow(tb1, 0)
    Grid.SetColumn(tb1, 1)
    Grid.SetRow(tb2, 1)
    Grid.SetColumn(tb2, 1)
    Me.commentGrid.Children.Add(rect)
    Me.commentGrid.Children.Add(tb1)
    Me.commentGrid.Children.Add(tb2)

    Canvas.SetLeft(Me.commentGrid, Math.Max(viewRightEdge - Me.commentGrid.Width - 20.0, textRightEdge + 20.0))
    Canvas.SetTop(Me.commentGrid, textGeometry.GetRenderBounds(solidPen).Top)

    Me.Children.Add(Me.commentGrid)
End Sub

    public CommentBlock(double textRightEdge,
double viewRightEdge,
Geometry newTextGeometry,
string author,
string body)
{
    if (brush == null)
    {
        brush = new SolidColorBrush(Color.FromArgb(0x20, 0x00, 0xff, 0x00));
        brush.Freeze();
        Brush penBrush = new SolidColorBrush(Colors.Green);
        penBrush.Freeze();
        solidPen = new Pen(penBrush, 0.5);
        solidPen.Freeze();
        dashPen = new Pen(penBrush, 0.5);
        dashPen.DashStyle = DashStyles.Dash;
        dashPen.Freeze();
    }

    this.textGeometry = newTextGeometry;

    TextBlock tb1 = new TextBlock();
    tb1.Text = author;
    TextBlock tb2 = new TextBlock();
    tb2.Text = body;

    const int MarginWidth = 8;
    this.commentGrid = new Grid();
    this.commentGrid.RowDefinitions.Add(new RowDefinition());
    this.commentGrid.RowDefinitions.Add(new RowDefinition());
    ColumnDefinition cEdge = new ColumnDefinition();
    cEdge.Width = new GridLength(MarginWidth);
    ColumnDefinition cEdge2 = new ColumnDefinition();
    cEdge2.Width = new GridLength(MarginWidth);
    this.commentGrid.ColumnDefinitions.Add(cEdge);
    this.commentGrid.ColumnDefinitions.Add(new ColumnDefinition());
    this.commentGrid.ColumnDefinitions.Add(cEdge2);

    System.Windows.Shapes.Rectangle rect = new System.Windows.Shapes.Rectangle();
    rect.RadiusX = 6;
    rect.RadiusY = 3;
    rect.Fill = brush;
    rect.Stroke = Brushes.Green;

    Size inf = new Size(double.PositiveInfinity, double.PositiveInfinity);
    tb1.Measure(inf);
    tb2.Measure(inf);
    double middleWidth = Math.Max(tb1.DesiredSize.Width, tb2.DesiredSize.Width);
    this.commentGrid.Width = middleWidth + 2 * MarginWidth;

    Grid.SetColumn(rect, 0);
    Grid.SetRow(rect, 0);
    Grid.SetRowSpan(rect, 2);
    Grid.SetColumnSpan(rect, 3);
    Grid.SetRow(tb1, 0);
    Grid.SetColumn(tb1, 1);
    Grid.SetRow(tb2, 1);
    Grid.SetColumn(tb2, 1);
    this.commentGrid.Children.Add(rect);
    this.commentGrid.Children.Add(tb1);
    this.commentGrid.Children.Add(tb2);

    Canvas.SetLeft(this.commentGrid, Math.Max(viewRightEdge - this.commentGrid.Width - 20.0, textRightEdge + 20.0));
    Canvas.SetTop(this.commentGrid, textGeometry.GetRenderBounds(solidPen).Top);

    this.Children.Add(this.commentGrid);
}

  6. implémentez également un gestionnaire d'événements d' OnRender qui dessine l'ornement.

    Protected Overrides Sub OnRender(ByVal dc As DrawingContext)
    MyBase.OnRender(dc)
    If Me.textGeometry IsNot Nothing Then
        dc.DrawGeometry(brush, solidPen, Me.textGeometry)
        Dim textBounds As Rect = Me.textGeometry.GetRenderBounds(solidPen)
        Dim p1 As New Point(textBounds.Right, textBounds.Bottom)
        Dim p2 As New Point(Math.Max(Canvas.GetLeft(Me.commentGrid) - 20.0, p1.X), p1.Y)
        Dim p3 As New Point(Math.Max(Canvas.GetLeft(Me.commentGrid), p1.X), (Canvas.GetTop(Me.commentGrid) + p1.Y) * 0.5)
        dc.DrawLine(dashPen, p1, p2)
        dc.DrawLine(dashPen, p2, p3)
    End If 
End Sub

    protected override void OnRender(DrawingContext dc)
{
    base.OnRender(dc);
    if (this.textGeometry != null)
    {
        dc.DrawGeometry(brush, solidPen, this.textGeometry);
        Rect textBounds = this.textGeometry.GetRenderBounds(solidPen);
        Point p1 = new Point(textBounds.Right, textBounds.Bottom);
        Point p2 = new Point(Math.Max(Canvas.GetLeft(this.commentGrid) - 20.0, p1.X), p1.Y);
        Point p3 = new Point(Math.Max(Canvas.GetLeft(this.commentGrid), p1.X), (Canvas.GetTop(this.commentGrid) + p1.Y) * 0.5);
        dc.DrawLine(dashPen, p1, p2);
        dc.DrawLine(dashPen, p2, p3);
    }
}

ajouter un IWpfTextViewCreationListener

IWpfTextViewCreationListener est un composant MEF que vous pouvez utiliser pour écouter pour afficher les événements de conception.

pour ajouter un IWpfTextViewCreationListener

  1. ajoutez un fichier de classe au projet de CommentAdornmentTest et nommez-le connecteur.

  2. ajoutez les instructions suivantes d' using .

    Imports System.ComponentModel.Composition
Imports Microsoft.VisualStudio.Text.Editor
Imports Microsoft.VisualStudio.Utilities

    using System.ComponentModel.Composition;
using Microsoft.VisualStudio.Text.Editor;
using Microsoft.VisualStudio.Utilities;

  3. Déclarez une classe qui implémente IWpfTextViewCreationListener et exportez-la avec ContentTypeAttribute « texte » et TextViewRoleAttribute d' Document. L'attribut de type de contenu spécifie le type de contenu vers lequel le composant s'applique. le type de texte est le type de base pour tous les types de fichier de non-binaire. Par conséquent, presque chaque affichage de texte qui est créé est de ce type. le rôle d'attribut d'affichage de texte spécifie le genre d'affichage de texte auquel le composant s'applique. Documentez les rôles d'affichage de texte affichent généralement le texte qui contient des lignes et est stocké dans un fichier.

    <Export(GetType(IWpfTextViewCreationListener)), ContentType("text"), TextViewRole(PredefinedTextViewRoles.Document)>
Public NotInheritable Class Connector
    Implements IWpfTextViewCreationListener

    [Export(typeof(IWpfTextViewCreationListener))]
[ContentType("text")]
[TextViewRole(PredefinedTextViewRoles.Document)]
public sealed class Connector : IWpfTextViewCreationListener

  4. Implémentez la méthode d' TextViewCreated afin qu'elle appelle l'événement statique d' Create() d' CommentAdornmentManager.

    Public Sub TextViewCreated(ByVal textView As IWpfTextView) Implements IWpfTextViewCreationListener.TextViewCreated
    CommentAdornmentManager.Create(textView)
End Sub

    public void TextViewCreated(IWpfTextView textView)
{
    CommentAdornmentManager.Create(textView);
}

  5. Ajoutez une méthode que vous pouvez utiliser pour exécuter la commande.

    Public Shared Sub Execute(ByVal host As IWpfTextViewHost)
    Dim view As IWpfTextView = host.TextView
    'Add a comment on the selected text. 
    If Not view.Selection.IsEmpty Then 
        'Get the provider for the comment adornments in the property bag of the view. 
        Dim provider As CommentAdornmentProvider = view.Properties.GetProperty(Of CommentAdornmentProvider)(GetType(CommentAdornmentProvider))

        'Add some arbitrary author and comment text. 
        Dim author As String = System.Security.Principal.WindowsIdentity.GetCurrent().Name
        Dim comment As String = "Four score...." 

        'Add the comment adornment using the provider.
        provider.Add(view.Selection.SelectedSpans(0), author, comment)
    End If 
End Sub

    static public void Execute(IWpfTextViewHost host)
{
    IWpfTextView view = host.TextView;
    //Add a comment on the selected text. 
    if (!view.Selection.IsEmpty)
    {
        //Get the provider for the comment adornments in the property bag of the view.
        CommentAdornmentProvider provider = view.Properties.GetProperty<CommentAdornmentProvider>(typeof(CommentAdornmentProvider));

        //Add some arbitrary author and comment text. 
        string author = System.Security.Principal.WindowsIdentity.GetCurrent().Name;
        string comment = "Four score....";

        //Add the comment adornment using the provider.
        provider.Add(view.Selection.SelectedSpans[0], author, comment);
    }
}

définir une couche d'ornement

pour ajouter un nouvel ornement, vous devez définir une couche d'ornement.

pour définir une couche d'ornement

  • Dans la classe d' Connector déclarez un champ public de type AdornmentLayerDefinition et l'exporter avec NameAttribute qui spécifie un nom unique pour la couche d'ornement et OrderAttribute qui définit la relation d'ordre de plan de cette couche d'ornement aux autres couches d'affichage de texte (texte, signe insertion, et selection).

    <Export(GetType(AdornmentLayerDefinition)), Name("CommentAdornmentLayer"), Order(After:=PredefinedAdornmentLayers.Selection, Before:=PredefinedAdornmentLayers.Text)>
Public commentLayerDefinition As AdornmentLayerDefinition

    [Export(typeof(AdornmentLayerDefinition))]
[Name("CommentAdornmentLayer")]
[Order(After = PredefinedAdornmentLayers.Selection, Before = PredefinedAdornmentLayers.Text)]
public AdornmentLayerDefinition commentLayerDefinition;

fourniture des ornements de commentaire

Lorsque vous définissez un ornement, implémentez également un ornement de commentaire et un gestionnaire d'ornement de commentaire. Le fournisseur d'ornements de commentaire conserve une liste d'ornements de commentaire, écoute Changed des événements sur la mémoire tampon sous-jacente, et les suppressions commentent des ornements lorsque le texte sous-jacent est supprimé.

Pour ajouter le fournisseur d'ornements de commentaire

  1. ajoutez un nouveau fichier de classe au projet de CommentAdornmentTest et nommez-le CommentAdornmentProvider.

  2. ajoutez les instructions suivantes d' using .

    Imports System
Imports System.Collections.Generic
Imports System.Collections.ObjectModel
Imports Microsoft.VisualStudio.Text
Imports Microsoft.VisualStudio.Text.Editor

    using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using Microsoft.VisualStudio.Text;
using Microsoft.VisualStudio.Text.Editor;

  3. ajoutez une classe nommée CommentAdornmentProvider.

    Friend Class CommentAdornmentProvider

    internal class CommentAdornmentProvider

  4. Ajoutez des champs privés pour la mémoire tampon de texte et la liste des ornements de commentaire liés à la mémoire tampon.

    Private buffer As ITextBuffer
Private comments As IList(Of CommentAdornment) = New List(Of CommentAdornment)()

    private ITextBuffer buffer;
private IList<CommentAdornment> comments = new List<CommentAdornment>();

  5. ajoutez un constructeur pour CommentAdornmentProvider. Ce constructeur doit avoir un accès privé parce que le fournisseur est instancié par la méthode d' Create() . le constructeur ajoute le gestionnaire d'événements d' OnBufferChanged à l'événement d' Changed .

    Private Sub New(ByVal buffer As ITextBuffer)
    Me.buffer = buffer
    'listen to the Changed event so we can react to deletions. 
    AddHandler Me.buffer.Changed, AddressOf OnBufferChanged
End Sub

    private CommentAdornmentProvider(ITextBuffer buffer)
{
    this.buffer = buffer;
    //listen to the Changed event so we can react to deletions. 
    this.buffer.Changed += OnBufferChanged;
}

  6. ajoutez la méthode d' Create() .

    Public Shared Function Create(ByVal view As IWpfTextView) As CommentAdornmentProvider
    Return view.Properties.GetOrCreateSingletonProperty(Of CommentAdornmentProvider)(Function() New CommentAdornmentProvider(view.TextBuffer))
End Function

    public static CommentAdornmentProvider Create(IWpfTextView view)
{
    return view.Properties.GetOrCreateSingletonProperty<CommentAdornmentProvider>(delegate { return new CommentAdornmentProvider(view.TextBuffer); });
}

  7. ajoutez la méthode d' Detach() .

    Public Sub Detach()
    If Me.buffer IsNot Nothing Then 
        'remove the Changed listener 
        RemoveHandler Me.buffer.Changed, AddressOf OnBufferChanged
        Me.buffer = Nothing 
    End If 
End Sub

    public void Detach()
{
    if (this.buffer != null)
    {
        //remove the Changed listener 
        this.buffer.Changed -= OnBufferChanged;
        this.buffer = null;
    }
}

  8. ajoutez le gestionnaire d'événements d' OnBufferChanged .

    Private Sub OnBufferChanged(ByVal sender As Object, ByVal e As TextContentChangedEventArgs)
    'Make a list of all comments that have a span of at least one character after applying the change. There is no need to raise a changed event for the deleted adornments. The adornments are deleted only if a text change would cause the view to reformat the line and discard the adornments. 
    Dim keptComments As IList(Of CommentAdornment) = New List(Of CommentAdornment)(Me.comments.Count)

    For Each comment As CommentAdornment In Me.comments
        Dim span As Span = comment.Span.GetSpan(e.After)
        'if a comment does not span at least one character, its text was deleted. 
        If span.Length <> 0 Then
            keptComments.Add(comment)
        End If 
    Next comment

    Me.comments = keptComments
End Sub

    private void OnBufferChanged(object sender, TextContentChangedEventArgs e)
{
    //Make a list of all comments that have a span of at least one character after applying the change. There is no need to raise a changed event for the deleted adornments. The adornments are deleted only if a text change would cause the view to reformat the line and discard the adornments.
    IList<CommentAdornment> keptComments = new List<CommentAdornment>(this.comments.Count);

    foreach (CommentAdornment comment in this.comments)
    {
        Span span = comment.Span.GetSpan(e.After);
        //if a comment does not span at least one character, its text was deleted. 
        if (span.Length != 0)
        {
            keptComments.Add(comment);
        }
    }

    this.comments = keptComments;
}

  9. Ajoutez une déclaration d'un événement d' CommentsChanged .

    Public Event CommentsChanged As EventHandler(Of CommentsChangedEventArgs)

    public event EventHandler<CommentsChangedEventArgs> CommentsChanged;

  10. créez une méthode d' Add() pour ajouter l'ornement.

    Public Sub Add(ByVal span As SnapshotSpan, ByVal author As String, ByVal text As String)
    If span.Length = 0 Then 
        Throw New ArgumentOutOfRangeException("span")
    End If 
    If author Is Nothing Then 
        Throw New ArgumentNullException("author")
    End If 
    If text Is Nothing Then 
        Throw New ArgumentNullException("text")
    End If 

    'Create a comment adornment given the span, author and text. 
    Dim comment As New CommentAdornment(span, author, text)

    'Add it to the list of comments. 
    Me.comments.Add(comment)

    'Raise the changed event. 
    Dim commentsChanged As EventHandler(Of CommentsChangedEventArgs) = Me.CommentsChangedEvent
    If CommentsChangedEvent IsNot Nothing Then
        CommentsChangedEvent(Me, New CommentsChangedEventArgs(comment, Nothing))
    End If 
End Sub

    public void Add(SnapshotSpan span, string author, string text)
{
    if (span.Length == 0)
        throw new ArgumentOutOfRangeException("span");
    if (author == null)
        throw new ArgumentNullException("author");
    if (text == null)
        throw new ArgumentNullException("text");

    //Create a comment adornment given the span, author and text.
    CommentAdornment comment = new CommentAdornment(span, author, text);

    //Add it to the list of comments. 
    this.comments.Add(comment);

    //Raise the changed event.
    EventHandler<CommentsChangedEventArgs> commentsChanged = this.CommentsChanged;
    if (commentsChanged != null)
        commentsChanged(this, new CommentsChangedEventArgs(comment, null));
}

  11. Ajoutez une méthode RemoveComments().

    Public Sub RemoveComments(ByVal span As SnapshotSpan)
    Dim commentsChanged As EventHandler(Of CommentsChangedEventArgs) = Me.CommentsChangedEvent

    'Get a list of all the comments that are being kept  
    Dim keptComments As IList(Of CommentAdornment) = New List(Of CommentAdornment)(Me.comments.Count)

    For Each comment As CommentAdornment In Me.comments
        'find out if the given span overlaps with the comment text span. If two spans are adjacent, they do not overlap. To consider adjacent spans, use IntersectsWith. 
        If comment.Span.GetSpan(span.Snapshot).OverlapsWith(span) Then 
            'Raise the change event to delete this comment. 
            If CommentsChangedEvent IsNot Nothing Then
                CommentsChangedEvent(Me, New CommentsChangedEventArgs(Nothing, comment))
            End If 
        Else
            keptComments.Add(comment)
        End If 
    Next comment

    Me.comments = keptComments
End Sub

    public void RemoveComments(SnapshotSpan span)
{
    EventHandler<CommentsChangedEventArgs> commentsChanged = this.CommentsChanged;

    //Get a list of all the comments that are being kept 
    IList<CommentAdornment> keptComments = new List<CommentAdornment>(this.comments.Count);

    foreach (CommentAdornment comment in this.comments)
    {
        //find out if the given span overlaps with the comment text span. If two spans are adjacent, they do not overlap. To consider adjacent spans, use IntersectsWith. 
        if (comment.Span.GetSpan(span.Snapshot).OverlapsWith(span))
        {
            //Raise the change event to delete this comment. 
            if (commentsChanged != null)
                commentsChanged(this, new CommentsChangedEventArgs(null, comment));
        }
        else
            keptComments.Add(comment);
    }

    this.comments = keptComments;
}

  12. Ajoutez une méthode d' GetComments() qui retourne tous les commentaires dans une étendue d'instantanés spécifiée.

    Public Function GetComments(ByVal span As SnapshotSpan) As Collection(Of CommentAdornment)
    Dim overlappingComments As IList(Of CommentAdornment) = New List(Of CommentAdornment)()
    For Each comment As CommentAdornment In Me.comments
        If comment.Span.GetSpan(span.Snapshot).OverlapsWith(span) Then
            overlappingComments.Add(comment)
        End If 
    Next comment

    Return New Collection(Of CommentAdornment)(overlappingComments)
End Function

    public Collection<CommentAdornment> GetComments(SnapshotSpan span)
{
    IList<CommentAdornment> overlappingComments = new List<CommentAdornment>();
    foreach (CommentAdornment comment in this.comments)
    {
        if (comment.Span.GetSpan(span.Snapshot).OverlapsWith(span))
            overlappingComments.Add(comment);
    }

    return new Collection<CommentAdornment>(overlappingComments);
}

  13. ajoutez une classe nommée CommentsChangedEventArgs, comme suit.

    Friend Class CommentsChangedEventArgs
    Inherits EventArgs
    Public ReadOnly CommentAdded As CommentAdornment
    Public ReadOnly CommentRemoved As CommentAdornment

    Public Sub New(ByVal added As CommentAdornment, ByVal removed As CommentAdornment)
        Me.CommentAdded = added
        Me.CommentRemoved = removed
    End Sub 
End Class

    internal class CommentsChangedEventArgs : EventArgs
{
    public readonly CommentAdornment CommentAdded;

    public readonly CommentAdornment CommentRemoved;

    public CommentsChangedEventArgs(CommentAdornment added, CommentAdornment removed)
    {
        this.CommentAdded = added;
        this.CommentRemoved = removed;
    }
}

gérer des ornements de commentaire

le gestionnaire d'ornement de commentaire crée l'ornement et l'ajoute à la couche d'ornement. Il écoute les événements d' LayoutChanged et d' Closed afin de pouvoir déplacer ou supprimer l'ornement. Il écoute également CommentsChanged l'événement déclenché par le fournisseur d'ornements de commentaire lorsque des commentaires sont ajoutés ou supprimés.

pour gérer des ornements de commentaire

  1. ajoutez un fichier de classe au projet de CommentAdornmentTest et nommez-le CommentAdornmentManager.

  2. ajoutez les instructions suivantes d' using .

    Imports System
Imports System.Collections.Generic
Imports System.Windows.Media
Imports Microsoft.VisualStudio.Text
Imports Microsoft.VisualStudio.Text.Editor
Imports Microsoft.VisualStudio.Text.Formatting

    using System;
using System.Collections.Generic;
using System.Windows.Media;
using Microsoft.VisualStudio.Text;
using Microsoft.VisualStudio.Text.Editor;
using Microsoft.VisualStudio.Text.Formatting;

  3. ajoutez une classe nommée CommentAdornmentManager.

    Friend Class CommentAdornmentManager

    internal class CommentAdornmentManager

  4. Ajoutez des champs privés.

    Private ReadOnly view As IWpfTextView
Private ReadOnly layer As IAdornmentLayer
Private ReadOnly provider As CommentAdornmentProvider

    private readonly IWpfTextView view;
private readonly IAdornmentLayer layer;
private readonly CommentAdornmentProvider provider;

  5. Ajoutez un constructeur qui s'abonne le gestionnaire aux événements d' LayoutChanged et d' Closed , et également à l'événement d' CommentsChanged . Le constructeur est privé car le gestionnaire est instancié par la méthode statique d' Create() .

    Private Sub New(ByVal view As IWpfTextView)
    Me.view = view
    AddHandler Me.view.LayoutChanged, AddressOf OnLayoutChanged
    AddHandler Me.view.Closed, AddressOf OnClosed

    Me.layer = view.GetAdornmentLayer("CommentAdornmentLayer")

    Me.provider = CommentAdornmentProvider.Create(view)
    AddHandler Me.provider.CommentsChanged, AddressOf OnCommentsChanged
End Sub

    private CommentAdornmentManager(IWpfTextView view)
{
    this.view = view;
    this.view.LayoutChanged += OnLayoutChanged;
    this.view.Closed += OnClosed;

    this.layer = view.GetAdornmentLayer("CommentAdornmentLayer");

    this.provider = CommentAdornmentProvider.Create(view);
    this.provider.CommentsChanged += OnCommentsChanged;
}

  6. Ajoutez la méthode d' Create() qui obtient un fournisseur ou en crée une si nécessaire.

    Public Shared Function Create(ByVal view As IWpfTextView) As CommentAdornmentManager
    Return view.Properties.GetOrCreateSingletonProperty(Of CommentAdornmentManager)(Function() New CommentAdornmentManager(view))
End Function

    public static CommentAdornmentManager Create(IWpfTextView view)
{
    return view.Properties.GetOrCreateSingletonProperty<CommentAdornmentManager>(delegate { return new CommentAdornmentManager(view); });
}

  7. ajoutez le gestionnaire d' CommentsChanged .

    Private Sub OnCommentsChanged(ByVal sender As Object, ByVal e As CommentsChangedEventArgs)
    'Remove the comment (when the adornment was added, the comment adornment was used as the tag). 
    If e.CommentRemoved IsNot Nothing Then 
        Me.layer.RemoveAdornmentsByTag(e.CommentRemoved)
    End If 

    'Draw the newly added comment (this will appear immediately: the view does not need to do a layout). 
    If e.CommentAdded IsNot Nothing Then 
        Me.DrawComment(e.CommentAdded)
    End If 
End Sub

    private void OnCommentsChanged(object sender, CommentsChangedEventArgs e)
{
    //Remove the comment (when the adornment was added, the comment adornment was used as the tag). 
    if (e.CommentRemoved != null)
        this.layer.RemoveAdornmentsByTag(e.CommentRemoved);

    //Draw the newly added comment (this will appear immediately: the view does not need to do a layout). 
    if (e.CommentAdded != null)
        this.DrawComment(e.CommentAdded);
}

  8. ajoutez le gestionnaire d' Closed .

    Private Sub OnClosed(ByVal sender As Object, ByVal e As EventArgs)
    Me.provider.Detach()
    RemoveHandler Me.view.LayoutChanged, AddressOf OnLayoutChanged
    RemoveHandler Me.view.Closed, AddressOf OnClosed
End Sub

    private void OnClosed(object sender, EventArgs e)
{
    this.provider.Detach();
    this.view.LayoutChanged -= OnLayoutChanged;
    this.view.Closed -= OnClosed;
}

  9. ajoutez le gestionnaire d' LayoutChanged .

    Private Sub OnLayoutChanged(ByVal sender As Object, ByVal e As TextViewLayoutChangedEventArgs)
    'Get all of the comments that intersect any of the new or reformatted lines of text. 
    Dim newComments As New List(Of CommentAdornment)()

    'The event args contain a list of modified lines and a NormalizedSpanCollection of the spans of the modified lines.  
    'Use the latter to find the comments that intersect the new or reformatted lines of text. 
    For Each span As Span In e.NewOrReformattedSpans
        newComments.AddRange(Me.provider.GetComments(New SnapshotSpan(Me.view.TextSnapshot, span)))
    Next span

    'It is possible to get duplicates in this list if a comment spanned 3 lines, and the first and last lines were modified but the middle line was not. 
    'Sort the list and skip duplicates.
    newComments.Sort(Function(a As CommentAdornment, b As CommentAdornment) a.GetHashCode().CompareTo(b.GetHashCode()))

    Dim lastComment As CommentAdornment = Nothing 
    For Each comment As CommentAdornment In newComments
        If comment IsNot lastComment Then
            lastComment = comment
            Me.DrawComment(comment)
        End If 
    Next comment
End Sub

    private void OnLayoutChanged(object sender, TextViewLayoutChangedEventArgs e)
{
    //Get all of the comments that intersect any of the new or reformatted lines of text.
    List<CommentAdornment> newComments = new List<CommentAdornment>();

    //The event args contain a list of modified lines and a NormalizedSpanCollection of the spans of the modified lines.  
    //Use the latter to find the comments that intersect the new or reformatted lines of text. 
    foreach (Span span in e.NewOrReformattedSpans)
    {
        newComments.AddRange(this.provider.GetComments(new SnapshotSpan(this.view.TextSnapshot, span)));
    }

    //It is possible to get duplicates in this list if a comment spanned 3 lines, and the first and last lines were modified but the middle line was not. 
    //Sort the list and skip duplicates.
    newComments.Sort(delegate(CommentAdornment a, CommentAdornment b) { return a.GetHashCode().CompareTo(b.GetHashCode()); });

    CommentAdornment lastComment = null;
    foreach (CommentAdornment comment in newComments)
    {
        if (comment != lastComment)
        {
            lastComment = comment;
            this.DrawComment(comment);
        }
    }
}

  10. ajoutez la méthode privée qui dessine le commentaire.

    Private Sub DrawComment(ByVal comment As CommentAdornment)
    Dim span As SnapshotSpan = comment.Span.GetSpan(Me.view.TextSnapshot)
    Dim g As Geometry = Me.view.TextViewLines.GetMarkerGeometry(span)

    If g IsNot Nothing Then 
        'Find the rightmost coordinate of all the lines that intersect the adornment. 
        Dim maxRight As Double = 0.0
        For Each line As ITextViewLine In Me.view.TextViewLines.GetTextViewLinesIntersectingSpan(span)
            maxRight = Math.Max(maxRight, line.Right)
        Next line

        'Create the visualization. 
        Dim block As New CommentBlock(maxRight, Me.view.ViewportRight, g, comment.Author, comment.Text)

        'Add it to the layer. 
        Me.layer.AddAdornment(span, comment, block)
    End If 
End Sub

    private void DrawComment(CommentAdornment comment)
{
    SnapshotSpan span = comment.Span.GetSpan(this.view.TextSnapshot);
    Geometry g = this.view.TextViewLines.GetMarkerGeometry(span);

    if (g != null)
    {
        //Find the rightmost coordinate of all the lines that intersect the adornment. 
        double maxRight = 0.0;
        foreach (ITextViewLine line in this.view.TextViewLines.GetTextViewLinesIntersectingSpan(span))
            maxRight = Math.Max(maxRight, line.Right);

        //Create the visualization.
        CommentBlock block = new CommentBlock(maxRight, this.view.ViewportRight, g, comment.Author, comment.Text);

        //Add it to the layer. 
        this.layer.AddAdornment(span, comment, block);
    }
}

À l'aide de la commande de menu pour ajouter l'ornement de commentaire

Vous pouvez utiliser la commande de menu pour créer un ornement de commentaire en implémentant la méthode d' MenuItemCallback d'un VSPackage.

Pour utiliser la commande de menu pour ajouter l'ornement de commentaire

  1. ajoutez les références suivantes au projet de MenuCommandTest :

    • Microsoft.VisualStudio.TextManager.Interop

    • Microsoft.VisualStudio.Editor

    • Microsoft.VisualStudio.Text.UI.Wp f

  2. ajoutez une référence au projet de CommentAdornmentTest.

  3. ouvrez le fichier de MenuCommandTestPackage.

  4. ajoutez les instructions suivantes d' using .

    Imports Microsoft.VisualStudio.TextManager.Interop
Imports Microsoft.VisualStudio.Text.Editor
Imports Microsoft.VisualStudio.Editor
Imports CommentAdornmentTest

    using Microsoft.VisualStudio.TextManager.Interop;
using Microsoft.VisualStudio.Text.Editor;
using Microsoft.VisualStudio.Editor;
using CommentAdornmentTest;

  5. Dans la méthode d' MenuItemCallback , supprimez le code existant.

  6. Ajoutez le code pour obtenir la vue active. Vous devez obtenir SVsTextManager du shell Visual Studio pour obtenir IVsTextViewactif.

    Dim txtMgr As IVsTextManager = CType(GetService(GetType(SVsTextManager)), IVsTextManager)
Dim vTextView As IVsTextView = Nothing 
Dim mustHaveFocus As Integer = 1
txtMgr.GetActiveView(mustHaveFocus, Nothing, vTextView)

    IVsTextManager txtMgr = (IVsTextManager)GetService(typeof(SVsTextManager));
IVsTextView vTextView = null;
int mustHaveFocus = 1;
txtMgr.GetActiveView(mustHaveFocus, null, out vTextView);

  7. Si cet affichage de texte est une instance d'un affichage de texte de l'éditeur, vous pouvez effectuer un cast en interface d' IVsUserData puis obtenir IWpfTextViewHost et son IWpfTextViewassocié.

    Dim userData As IVsUserData = TryCast(vTextView, IVsUserData)
If userData Is Nothing Then
    Console.WriteLine("No text view is currently open")
    Return 
End If 
Dim viewHost As IWpfTextViewHost
Dim holder As Object 
Dim guidViewHost As Guid = DefGuidList.guidIWpfTextViewHost
userData.GetData(guidViewHost, holder)
viewHost = CType(holder, IWpfTextViewHost)

    IVsUserData userData = vTextView as IVsUserData;
if (userData == null)
{
    Console.WriteLine("No text view is currently open");
    return;
}
IWpfTextViewHost viewHost;
object holder;
Guid guidViewHost = DefGuidList.guidIWpfTextViewHost;
userData.GetData(ref guidViewHost, out holder);
viewHost = (IWpfTextViewHost)holder;

  8. Utilisez IWpfTextViewHost pour appeler la méthode d' Connector.Execute() , qui obtient le fournisseur d'ornements de commentaire et ajoute l'ornement.

    Connector.Execute(viewHost)

    Connector.Execute(viewHost);

Génération et test de code

Pour tester ce code, générez la solution de MenuCommand et exécutez -la dans l'instance expérimentale.

Pour générer et tester la solution de MenuCommand

  1. Générez la solution. Lorsque vous exécutez ce projet dans le débogueur, une deuxième instance de Visual Studio est instanciée.

  2. Créer un fichier texte. Tapez du texte puis sélectionnez -le.

  3. Dans le menu d' Outils , cliquez sur ajoutez l'ornement. Une bulle doit être affichée sur le côté droit de la fenêtre de texte, et doit contenir le texte qui ressemble au texte suivant.

    YourUserName

    quatre-vingt…

Voir aussi

Tâches

Procédure pas - à - pas : lier un type de contenu à une extension de nom de fichier