Cenni preliminari sulle annotazioni

La scrittura di note o commenti su documenti cartacei è un'attività comune che diamo quasi per scontata. Queste note o commenti sono "annotazioni" aggiunte a un documento per contrassegnare informazioni o evidenziare elementi di interesse a cui fare riferimento in un secondo momento. Sebbene la scrittura di note su documenti stampati sia un'operazione semplice e comune, la capacità di aggiungere commenti personali ai documenti elettronici, se disponibile, è in genere molto limitata.

In questo argomento vengono esaminati molti tipi comuni di annotazioni, in modo specifico note di Sticky Notes ed evidenziazioni e viene descritto il modo in cui Microsoft Annotations Framework facilita questi tipi di annotazioni nelle applicazioni tramite i controlli di visualizzazione del documento Windows Presentation Foundation (WPF). I controlli di visualizzazione del documento WPF che supportano le annotazioni includono FlowDocumentReader e FlowDocumentScrollViewer, nonché i controlli derivati da DocumentViewerBase quali DocumentViewer e FlowDocumentPageViewer.

Nel presente argomento sono contenute le seguenti sezioni.

• Note di Sticky Notes
• Evidenziazioni
• Ancoraggio dei dati
• Creazione di corrispondenze tra annotazioni e oggetti annotati
• Argomenti correlati

Note di Sticky Notes

Normalmente una nota adesiva contiene informazioni scritte su un pezzetto di carta colorata che viene successivamente "attaccato" su un documento. Le note digitali di Sticky Notes forniscono una funzionalità simile per i documenti elettronici, ma con un'ulteriore flessibilità che consente di includere molti altri tipi di contenuto, quali un testo digitato, note scritte a mano (ad esempio, tratti di "input penna" Tablet PC) o collegamenti Web.

Nell'illustrazione seguente vengono mostrati alcuni esempi di annotazioni con evidenziatore, annotazioni di testo con Sticky Note e annotazioni a penna di Sticky Notes.

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

        ' ------------------------ 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()

Evidenziazioni

Quando si eseguono annotazioni su un documento cartaceo, per attirare l'attenzione su elementi di interesse si utilizzano metodi creativi, ad esempio sottolineando, evidenziando, cerchiando parole in una frase o tracciando segni o notazioni sul margine. Le annotazioni con evidenziatore di Microsoft Annotations Framework forniscono una funzionalità simile per annotare le informazioni visualizzate nei controlli di visualizzazione del documento WPF.

Nell'illustrazione seguente viene mostrato un esempio di un'annotazione con evidenziatore.

In genere, gli utenti creano annotazioni selezionando innanzitutto una parte di testo o un elemento di interesse, quindi facendo clic con il pulsante destro del mouse per visualizzare un oggetto ContextMenu delle opzioni di annotazione. Nell'esempio seguente viene mostrata la sintassi Extensible Application Markup Language (XAML) che è possibile utilizzare per dichiarare un oggetto ContextMenu con comandi indirizzati a cui gli utenti possono accedere per creare e gestire le 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

In Annotations Framework le annotazioni vengono associate ai dati selezionati dall'utente e non solo a una posizione nella visualizzazione. Pertanto, se la visualizzazione del documento cambia, ad esempio quando l'utente scorre o ridimensiona la finestra di visualizzazione, l'annotazione rimane nella selezione dati alla quale è associata. Ad esempio, nell'immagine seguente viene mostrata un'annotazione effettuata dall'utente su una selezione di testo. Quando la visualizzazione del documento cambia (scorre, viene ridimensionata o si sposta), l'annotazione con evidenziatore si sposta insieme alla selezione dati originale.

Creazione di corrispondenze tra annotazioni e oggetti annotati

È possibile creare corrispondenze tra annotazioni e oggetti annotati corrispondenti. Si consideri, ad esempio, una semplice applicazione per la lettura di documenti che dispone di un riquadro dei commenti. Il riquadro dei commenti potrebbe essere una casella di riepilogo in cui viene visualizzato il testo di un elenco di annotazioni ancorate a un documento. Se l'utente seleziona un elemento della casella di riepilogo, nell'applicazione viene visualizzato il paragrafo del documento a cui l'oggetto di annotazione corrispondente è ancorato.

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

        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 altro scenario di esempio riguarda le applicazioni che consentono lo scambio di annotazioni e di note Sticky Notes tra lettori di documenti tramite posta elettronica. Questa funzionalità consente a tali applicazioni di far spostare il lettore alla pagina contenente l'annotazione che viene scambiata.

Vedere anche

Attività

How to: Add a Command to a MenuItem

Riferimenti

DocumentViewerBase

DocumentViewer

FlowDocumentPageViewer

FlowDocumentScrollViewer

FlowDocumentReader

IAnchorInfo

Concetti

Schema annotazioni

Cenni preliminari sull'oggetto ContextMenu

Cenni preliminari sull'esecuzione di comandi

Cenni preliminari sui documenti dinamici