Compartilhar via

Visão geral de anotações

Escrever anotações ou comentários em documentos em papel é uma atividade tão comum que quase a tomamos como garantida. Essas anotações ou comentários são "anotações" que adicionamos a um documento para sinalizar informações ou realçar itens de interesse para referência posterior. Embora escrever anotações 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 anotações e realces autoadesíveis, 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 WPF (Windows Presentation Foundation). Os controles de exibição de documentos do WPF que dão suporte a anotações incluem FlowDocumentReader e FlowDocumentScrollViewer, bem como controles derivados de DocumentViewerBase como DocumentViewer e FlowDocumentPageViewer.

Notas autoadesivas

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

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

Anotações autoadesivas de realce, texto e tinta.

O exemplo a seguir mostra o método que você pode usar para habilitar o suporte à anotação 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 de papel, como sublinhar, realçar, circular palavras em uma frase ou desenhar marcas ou notações na margem. As anotações de destaque no Microsoft Annotations Framework fornecem um recurso semelhante para marcar as 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 realce

Os usuários normalmente criam anotações selecionando primeiro algum texto ou um item de interesse e, em seguida, clicando com o botão direito do mouse para exibir um ContextMenu de opções de anotação. O exemplo a seguir mostra o XAML (Extensible Application Markup Language) que você pode usar para declarar um ContextMenu com comandos roteados aos quais os usuários têm acesso 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

A Estrutura de Anotações associa as anotações aos dados selecionados pelo usuário, e não apenas a uma posição na exibição. Portanto, se a exibição do documento for alterada, como quando o usuário rolar ou redimensionar a janela de exibição, a anotação permanecerá com a seleção de dados à qual ele está associado. Por exemplo, o gráfico a seguir ilustra uma anotação feita pelo usuário em uma seleção de texto. Quando a exibição do documento muda (rola, é redimensionada, tem a escala ajustada ou se move de outra maneira), a anotação de realce se move com a seleção de dados original.

Ancoragem de Dados de Anotação

Combinando anotações com objetos anotados

Você pode relacionar anotações com os objetos correspondentes. Por exemplo, considere um aplicativo de leitor de documento 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 anotações autoadesivas entre leitores de documentos por email. Esse recurso permite que esses aplicativos direcionem o leitor à página que contém a anotação sendo compartilhada.

Consulte também