Vue d'ensemble des annotations
La rédaction de remarques ou de commentaires sur papier est une activité tellement banale que nous pensons qu'elle va de soi. Ces remarques ou commentaires sont des "annotations" qui sont ajoutés dans un document pour signaler des informations ou mettre en évidence des éléments présentant un intérêt particulier afin de s'y référer ultérieurement. Bien que la rédaction de remarques sur un document papier soit une tâche simple et banale, la possibilité d'ajouter des commentaires personnels dans des documents électroniques, lorsque cette fonctionnalité est disponible, est généralement très limitée.
Cette rubrique passe en revue plusieurs types d'annotations courants, en particulier les pense-bêtes et les surbrillances, et explique en quoi Microsoft Annotations Framework simplifie leur utilisation dans les applications via les contrôles d'affichage de document Windows Presentation Foundation (WPF). Les contrôles d'affichage de document WPF qui prennent en charge les annotations comprennent FlowDocumentReader et FlowDocumentScrollViewer, ainsi que les contrôles dévirés de DocumentViewerBase, tels que DocumentViewer et FlowDocumentPageViewer.
Cette rubrique comprend les sections suivantes.
- Pense-bêtes
- Mises en surbrillance
- Ancrage de données
- Mise en correspondance des annotations avec les objets annotés
- Rubriques connexes
Pense-bêtes
Un pense-bête typique contient des informations écrites sur un petit morceau de papier de couleur, collé ensuite sur un document. Les pense-bêtes numériques fournissent des fonctionnalités similaires dans les documents électroniques, tout en permettant en plus d'inclure de nombreux autres types de contenu tel que du texte saisi au clavier, des notes manuscrites (par exemple, des traits "d'encre" Tablet PC) ou des liens Web.
L'illustration suivante montre quelques exemples d'annotations sous forme de mises en surbrillance, de pense-bêtes ou de remarques manuscrites.
.jpg "Annotations pense-bête manuscrites et texte en surbrillance")
L'exemple suivant illustre 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 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 ' end:StartAnnotations()
// ------------------------ 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()
Mises en surbrillance
On utilise diverses méthodes créatives pour attirer l'attention sur des éléments présentant un intérêt particulier sur un document papier, par exemple on peut souligner, surligner, encercler des mots dans une phrase ou tracer des marques ou des annotations en marge. Les annotations en surbrillance dans Microsoft Annotations Framework fournissent une fonctionnalité similaire pour marquer des informations affichées dans des contrôles d'affichage de document WPF.
L'illustration suivante montre un exemple d'annotation en surbrillance.
.png "Annotation en surbrillance")
Les utilisateurs créent généralement des annotations en sélectionnant du texte ou un élément d'intérêt, puis ils cliquent avec le bouton droit pour afficher un ContextMenu contenant des options d'annotation. L'exemple suivant illustre le Extensible Application Markup Language (XAML) que vous pouvez utiliser pour déclarer un ContextMenu contenant les 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 & Notes" />
</ContextMenu>
</DocumentViewer.ContextMenu>
Ancrage de données
Annotations Framework lie des annotations aux données que l'utilisateur sélectionne, pas seulement à une position dans l'affichage. Par conséquent, en cas de modification de la vue du document, par exemple si l'utilisateur fait défiler ou redimensionne la fenêtre d'affichage, l'annotation suit la sélection des données à laquelle elle est liée. Par exemple, le graphique suivant illustre une annotation que l'utilisateur a faite sur une sélection de texte. En cas de modification de la vue du document (défilements, redimensionnements, mises à l'échelle ou tout autre déplacement), l'annotation en surbrillance est déplacée avec la sélection des données d'origine.
.png "Ancrage des données de l'annotation")
Mise en correspondance des annotations avec les objets annotés
Vous pouvez faire correspondre des annotations aux objets annotés associés. Prenez, par exemple, une application de lecture de document simple comportant un volet de commentaires. Le volet de commentaires peut être une zone de liste qui affiche le texte à partir d'une liste d'annotations ancrées à un document. Si l'utilisateur sélectionne un élément dans la zone de liste, l'application affiche le paragraphe dans le document auquel l'objet annotation correspondant est ancré.
L'exemple ci-dessous montre comment implémenter le gestionnaire d'événements d'une telle zone de liste qui sert de volet de commentaires :
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
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();
}
}
Un autre exemple de scénario implique des applications qui activent l'échange d'annotations et de pense-bêtes entre des lecteurs de document par le biais de la messagerie électronique. Cette fonction permet à ces applications de conduire le lecteur à la page contenant l'annotation échangée.
Voir aussi
Tâches
Comment : ajouter une commande à un MenuItem