Vue d'ensemble des annotations
Mise à jour : novembre 2007
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, plus particulièrement les pense-bêtes et les mises en surbrillance, et illustre comment Microsoft Annotations Framework facilite ces types d'annotations dans les applications par le biais des 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érivé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)
L'exemple suivant illustre la méthode que vous pouvez utiliser pour activer la prise en charge des annotations dans votre application. Pour obtenir l'exemple complet, consultez DocumentViewer avec annotations stockées dans un fichier XML, exemple ou DocumentViewer avec annotations stockées dans un fichier XPS, exemple.
// ------------------------ 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)
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 XAML (Extensible Application Markup Language) 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. Pour obtenir l'exemple complet, consultez DocumentViewer avec annotations stockées dans un fichier XPS, exemple.
<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)
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. Ce volet peut consister en 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 cette zone de liste, l'application affiche alors 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 :
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
DocumentViewer avec annotations stockées dans un fichier XPS, exemple
DocumentViewer avec annotations stockées dans un fichier XML, exemple
Application de styles à des annotations, exemple
Sérialisation de documents, exemple
Concepts
Vue d'ensemble des documents dynamiques