Condividi tramite

Panoramica delle annotazioni

Scrivere note o commenti su documenti cartacei è un'attività così comune che quasi lo prendiamo per scontato. Queste note o commenti sono "annotazioni" aggiunte a un documento per contrassegnare le informazioni o evidenziare elementi di interesse per riferimento successivo. Anche se la scrittura di note sui documenti stampati è facile e comune, la possibilità di aggiungere commenti personali ai documenti elettronici è in genere molto limitata, se disponibile a tutti.

Questo argomento esamina diversi tipi comuni di annotazioni, in particolare note ed evidenziazioni permanenti e illustra come Microsoft Annotations Framework facilita questi tipi di annotazioni nelle applicazioni tramite i controlli di visualizzazione dei documenti di Windows Presentation Foundation (WPF). I controlli di visualizzazione dei documenti WPF che supportano le annotazioni includono FlowDocumentReader e FlowDocumentScrollViewer, nonché controlli derivati da DocumentViewerBase, ad esempio DocumentViewer e FlowDocumentPageViewer.

Foglietti adesivi

Una nota sticky tipica contiene informazioni scritte su un piccolo pezzo di carta colorata che viene quindi "bloccato" a un documento. Le note adesive digitali offrono funzionalità simili per i documenti elettronici, ma con la flessibilità aggiuntiva di includere molti altri tipi di contenuto, come testo digitato, note scritte a mano (ad esempio, tratti d'inchiostro del tablet PC) o collegamenti Web.

La figura seguente mostra alcuni esempi di evidenziazioni, note adesive per il testo e note adesive a inchiostro.

Annotazioni di evidenziazione, testo e annotazioni adesive con inchiostro.

Nell'esempio seguente viene illustrato il metodo che è possibile usare per abilitare il supporto delle annotazioni nell'applicazione.

// ------------------------ 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

Attrazioni

Le persone usano metodi creativi per attirare l'attenzione sugli elementi di interesse quando contrassegnano un documento cartaceo, ad esempio sottolineatura, evidenziazione, circolo di parole in una frase o segni di disegno o notazioni nel margine. Le annotazioni evidenziate in Microsoft Annotations Framework offrono una funzionalità simile per contrassegnare le informazioni visualizzate nei controlli di visualizzazione dei documenti WPF.

La figura seguente mostra un esempio di annotazione evidenziata.

Annotazione di evidenziazione

Gli utenti in genere creano annotazioni selezionando prima testo o un elemento di interesse e quindi facendo clic con il pulsante destro del mouse per visualizzare una ContextMenu di opzioni di annotazione. L'esempio seguente mostra il linguaggio XAML (Extensible Application Markup Language) che puoi usare per dichiarare un ContextMenu con comandi indirizzati a cui gli utenti possono accedere per creare e gestire annotazioni.

<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>

Ancoraggio dei dati

Il framework delle annotazioni associa le annotazioni ai dati selezionati dall'utente, non solo a una posizione sullo schermo. Pertanto, se la visualizzazione del documento cambia, ad esempio quando l'utente scorre o ridimensiona la finestra di visualizzazione, l'annotazione rimane associata alla selezione dei dati a cui è associata. Ad esempio, l'immagine seguente illustra un'annotazione eseguita dall'utente su una selezione di testo. Quando la visualizzazione del documento cambia (scorre, ridimensiona, scala o si sposta altrimenti), la nota di evidenziazione si sposta con la selezione dei dati originale.

l'ancoraggio dei dati di annotazione

Corrispondenza di annotazioni con oggetti annotati

È possibile associare annotazioni agli oggetti annotati corrispondenti. Si consideri, ad esempio, una semplice applicazione lettore di documenti con un riquadro commenti. Il riquadro dei commenti potrebbe essere una casella di riepilogo che visualizza il testo di un elenco di annotazioni ancorate a un documento. Se l'utente seleziona un elemento nella casella di riepilogo, l'applicazione visualizza il paragrafo del documento a cui è ancorato l'oggetto annotazione corrispondente.

Nell'esempio seguente viene illustrato come implementare il gestore eventi di una casella di riepilogo di questo tipo che funge da riquadro dei commenti.

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 altro scenario di esempio prevede applicazioni che consentono lo scambio di annotazioni e note permanenti tra lettori di documenti tramite posta elettronica. Questa funzionalità consente a queste applicazioni di passare al lettore alla pagina contenente l'annotazione scambiata.

Vedere anche