Partilhar via


Visão geral das anotações

Escrever notas ou comentários em documentos em papel é uma atividade tão comum que quase a tomamos como certa. Essas notas ou comentários são "anotações" que adicionamos a um documento para sinalizar informações ou destacar itens de interesse para referência posterior. Embora escrever notas em documentos impressos seja fácil e comum, a capacidade de adicionar comentários pessoais a documentos eletrônicos é normalmente muito limitada, se disponível.

Este tópico analisa vários tipos comuns de anotações, especificamente notas adesivas e destaques, e ilustra como o Microsoft Annotations Framework facilita esses tipos de anotações em aplicativos por meio dos controles de exibição de documentos do Windows Presentation Foundation (WPF). Os controles de exibição de documentos do WPF que suportam anotações incluem FlowDocumentReader e FlowDocumentScrollViewer, bem como controles derivados de DocumentViewerBase como DocumentViewer e FlowDocumentPageViewer.

Notas adesivas

Uma nota adesiva típica contém informações escritas em um pequeno pedaço de papel colorido que é então "preso" a um documento. As notas adesivas digitais fornecem funcionalidade semelhante para documentos eletrônicos, mas com a flexibilidade adicional de incluir muitos outros tipos de conteúdo, como texto digitado, notas manuscritas (por exemplo, traços de "tinta" do Tablet PC) ou links da Web.

A ilustração a seguir mostra alguns exemplos de realce, nota adesiva de texto e anotações de nota adesiva à tinta.

Realce, anotações de notas adesivas de texto e tinta.

O exemplo a seguir mostra o método que você pode usar para habilitar o suporte a anotações em seu aplicativo.

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

Destaques

As pessoas usam métodos criativos para chamar a atenção para itens de interesse quando marcam um documento em papel, como sublinhar, destacar, circundar palavras em uma frase ou desenhar marcas ou anotações na margem. As anotações de realce no Microsoft Annotations Framework fornecem um recurso semelhante para marcar informações exibidas nos controles de exibição de documentos do WPF.

A ilustração a seguir mostra um exemplo de uma anotação de realce.

Anotação de Destaque

Os usuários normalmente criam anotações selecionando primeiro algum texto ou item de interesse e, em seguida, clicando com o botão direito do mouse para exibir uma ContextMenu de opções de anotação. O exemplo a seguir mostra a linguagem XAML (Extensible Application Markup Language) que você pode usar para declarar uma ContextMenu com comandos roteados que os usuários podem acessar para criar e gerenciar anotações.

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

Ancoragem de dados

O Annotations Framework vincula anotações aos dados que o utilizador seleciona, não apenas a uma posição na vista de exibição. Portanto, se a exibição do documento for alterada, como quando o usuário rola ou redimensiona a janela de exibição, a anotação permanecerá com a seleção de dados à qual está vinculada. Por exemplo, o gráfico a seguir ilustra uma anotação que o usuário fez em uma seleção de texto. Quando a exibição do documento é alterada (rola, redimensiona, dimensiona ou se move de outra forma), a anotação de realce é movida com a seleção de dados original.

Ancoragem de Dados de Anotação

Emparelhamento de Anotações com Objetos Anotados

Você pode fazer a correspondência de anotações com os objetos anotados correspondentes. Por exemplo, considere um aplicativo leitor de documentos simples que tenha um painel de comentários. O painel de comentários pode ser uma caixa de listagem que exibe o texto de uma lista de anotações ancoradas em um documento. Se o usuário selecionar um item na caixa de listagem, o aplicativo exibirá o parágrafo no documento ao qual o objeto de anotação correspondente está ancorado.

O exemplo a seguir demonstra como implementar o manipulador de eventos de tal caixa de listagem que serve como o painel de comentários.

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

Outro cenário de exemplo envolve aplicativos que permitem a troca de anotações e notas adesivas entre leitores de documentos por e-mail. Essa funcionalidade permite que esses aplicativos naveguem o usuário para a página que contém a anotação que está a ser trocada.

Ver também