Partager via

Vue d’ensemble des annotations

L’écriture de notes ou de commentaires sur des documents papier est une activité courante que nous prenons presque pour acquis. Ces notes ou commentaires sont des « annotations » que nous ajoutons à un document pour marquer des informations ou pour mettre en évidence des éléments d’intérêt pour référence ultérieure. Bien que l’écriture de notes sur des documents imprimés soit facile et courante, la possibilité d’ajouter des commentaires personnels à des documents électroniques est généralement très limitée, si elle est disponible du tout.

Cette rubrique passe en revue plusieurs types courants d’annotations, en particulier des notes collantes et des mises en surbrillance, et montre comment Microsoft Annotations Framework facilite ces types d’annotations dans les applications via les contrôles d’affichage de documents WPF (Windows Presentation Foundation). Les contrôles d’affichage de documents WPF qui prennent en charge les annotations incluent des FlowDocumentReader et des FlowDocumentScrollViewer, ainsi que des contrôles dérivés de DocumentViewerBase tels que DocumentViewer et FlowDocumentPageViewer.

Pense-bêtes

Une note collante classique contient des informations écrites sur un petit morceau de papier coloré qui est ensuite « bloqué » dans un document. Les notes collantes numériques offrent des fonctionnalités similaires pour les documents électroniques, mais avec la possibilité d’inclure de nombreux autres types de contenu tels que du texte typé, des notes manuscrites (par exemple, des traits « encre » tablette PC) ou des liens Web.

L’illustration suivante montre quelques exemples d’annotations de surlignage, de pense-bêtes textuels et de pense-bêtes manuscrits.

Annotations de surlignage, de pense-bêtes textuels et de pense-bêtes manuscrits.

L’exemple suivant montre la méthode que vous pouvez utiliser pour activer la prise en charge des annotations dans votre application.

// ------------------------ StartAnnotations --------------------------
/// <summary>
///   Enables annotations and displays all that are viewable.</summary>
private void StartAnnotations()
{
    // If there is no AnnotationService yet, create one.
    if (_annotService == null)
        // docViewer is a document viewing control named in Window1.xaml.
        _annotService = new AnnotationService(docViewer);

    // If the AnnotationService is currently enabled, disable it.
    if (_annotService.IsEnabled == true)
        _annotService.Disable();

    // Open a stream to the file for storing annotations.
    _annotStream = new FileStream(
        _annotStorePath, FileMode.OpenOrCreate, FileAccess.ReadWrite);

    // Create an AnnotationStore using the file stream.
    _annotStore = new XmlStreamStore(_annotStream);

    // Enable the AnnotationService using the new store.
    _annotService.Enable(_annotStore);
}// end:StartAnnotations()

' ------------------------ StartAnnotations --------------------------
''' <summary>
'''   Enables annotations and displays all that are viewable.</summary>
Private Sub StartAnnotations()
    ' If there is no AnnotationService yet, create one.
    If _annotService Is Nothing Then
        ' docViewer is a document viewing control named in Window1.xaml.
        _annotService = New AnnotationService(docViewer)
    End If

    ' If the AnnotationService is currently enabled, disable it.
    If _annotService.IsEnabled = True Then
        _annotService.Disable()
    End If

    ' Open a stream to the file for storing annotations.
    _annotStream = New FileStream(_annotStorePath, FileMode.OpenOrCreate, FileAccess.ReadWrite)

    ' Create an AnnotationStore using the file stream.
    _annotStore = New XmlStreamStore(_annotStream)

    ' Enable the AnnotationService using the new store.
    _annotService.Enable(_annotStore)
End Sub

Faits saillants

Les utilisateurs mettent en œuvre des méthodes créatives pour attirer l’attention sur des éléments d’intérêt lorsqu’ils annotent un document papier, telles que le soulignement, la mise en surbrillance, l'encerclage des mots dans une phrase, ou en dessinant des marques ou des annotations dans la marge. Les annotations mises en surbrillance dans Microsoft Annotations Framework fournissent une fonctionnalité similaire pour marquer les informations affichées dans les contrôles d’affichage de documents WPF.

L’illustration suivante montre un exemple d’annotation en surlignement.

Mettre en surbrillance l'annotation

Les utilisateurs créent généralement des annotations en sélectionnant d’abord du texte ou un élément intéressant, puis en cliquant avec le bouton droit pour afficher une ContextMenu des options d’annotation. L’exemple suivant montre le langage XAML (Extensible Application Markup Language) que vous pouvez utiliser pour déclarer une ContextMenu avec des commandes routées auxquelles les utilisateurs peuvent accéder pour créer et gérer des annotations.

<DocumentViewer.ContextMenu>
  <ContextMenu>
    <MenuItem Command="ApplicationCommands.Copy" />
    <Separator />
    <!-- Add a Highlight annotation to a user selection. -->
    <MenuItem Command="ann:AnnotationService.CreateHighlightCommand"
              Header="Add Highlight" />
    <!-- Add a Text Note annotation to a user selection. -->
    <MenuItem Command="ann:AnnotationService.CreateTextStickyNoteCommand"
              Header="Add Text Note" />
    <!-- Add an Ink Note annotation to a user selection. -->
    <MenuItem Command="ann:AnnotationService.CreateInkStickyNoteCommand"
              Header="Add Ink Note" />
    <Separator />
    <!-- Remove Highlights from a user selection. -->
    <MenuItem Command="ann:AnnotationService.ClearHighlightsCommand"
              Header="Remove Highlights" />
    <!-- Remove Text Notes and Ink Notes from a user selection. -->
    <MenuItem Command="ann:AnnotationService.DeleteStickyNotesCommand"
              Header="Remove Notes" />
    <!-- Remove Highlights, Text Notes, Ink Notes from a selection. -->
    <MenuItem Command="ann:AnnotationService.DeleteAnnotationsCommand"
              Header="Remove Highlights &amp; Notes" />
  </ContextMenu>
</DocumentViewer.ContextMenu>

Ancrage des données

Annotations Framework lie des annotations aux données sélectionnées par l’utilisateur, pas seulement à une position sur la vue d’affichage. Par conséquent, si l’affichage du document change, par exemple lorsque l’utilisateur fait défiler ou redimensionne la fenêtre d’affichage, l’annotation reste avec la sélection de données à laquelle elle est liée. Par exemple, le graphique suivant illustre une annotation que l’utilisateur a effectuée sur une sélection de texte. Lorsque l’affichage du document change (défilements, redimensionnements, échelles ou autres déplacements), l’annotation en surbrillance se déplace avec la sélection de données d’origine.

Ancrage des données d’annotation ancrage des données d'annotation

Association des annotations à des objets annotés

Vous pouvez faire correspondre des annotations avec les objets annotés correspondants. Par exemple, considérez une application de lecteur de document simple qui a un volet commentaires. Le volet commentaires peut être une zone de liste qui affiche le texte d’une liste d’annotations ancrées dans un document. Si l’utilisateur sélectionne un élément dans la zone de liste, l’application affiche le paragraphe du document auquel l’objet d’annotation correspondant est ancré.

L’exemple suivant montre comment implémenter le gestionnaire d’événements d’une telle zone de liste qui sert de volet commentaires.

void annotationsListBox_SelectionChanged(object sender, SelectionChangedEventArgs e)
{

    Annotation comment = (sender as ListBox).SelectedItem as Annotation;
    if (comment != null)
    {
        // IAnchorInfo info;
        // service is an AnnotationService object
        // comment is an Annotation object
        info = AnnotationHelper.GetAnchorInfo(this.service, comment);
        TextAnchor resolvedAnchor = info.ResolvedAnchor as TextAnchor;
        TextPointer textPointer = (TextPointer)resolvedAnchor.BoundingStart;
        textPointer.Paragraph.BringIntoView();
    }
}

Private Sub annotationsListBox_SelectionChanged(ByVal sender As Object, ByVal e As SelectionChangedEventArgs)

    Dim comment As Annotation = TryCast((TryCast(sender, ListBox)).SelectedItem, Annotation)
    If comment IsNot Nothing Then
        ' service is an AnnotationService object
        ' comment is an Annotation object
        info = AnnotationHelper.GetAnchorInfo(Me.service, comment)
        Dim resolvedAnchor As TextAnchor = TryCast(info.ResolvedAnchor, TextAnchor)
        Dim textPointer As TextPointer = CType(resolvedAnchor.BoundingStart, TextPointer)
        textPointer.Paragraph.BringIntoView()
    End If
End Sub

Un autre exemple de scénario implique des applications qui permettent l’échange d’annotations et de notes collantes entre les lecteurs de documents par e-mail. Cette fonctionnalité permet à ces applications de naviguer dans le lecteur vers la page qui contient l’annotation en cours d’échange.

Voir aussi