Some test text!

Loading...
Guides
Events

Annotation Events

There are a number of events related to annotations that can be useful to hook into. This is especially important for knowing when annotations are created in order to export them or immediately change a property. To do this you'll add a listener to the AnnotationManager .

Do not add the any of the listeners in the documentLoaded event
This will cause a new listener to be attached every time a new document is loaded
WebViewer(...)
  .then(instance => {
    const { annotationManager } = instance.Core;

    annotationManager.addEventListener('annotationChanged', () => {
      // ...
    });
  });

annotationChanged (add/modify/delete)

The annotationChanged event is fired every time an annotation is added, modified, or deleted. The handler takes three parameters: an array of annotations that have changed, a string for the action (add, modify, delete), and an info object describing the event.

WebViewer(...)
  .then(instance => {
    const { annotationManager } = instance.Core;

    annotationManager.addEventListener('annotationChanged', (annotations, action) => {
      if (action === 'add') {
        console.log('this is a change that added annotations');
      } else if (action === 'modify') {
        console.log('this change modified annotations');
      } else if (action === 'delete') {
        console.log('there were annotations deleted');
      }

      annotations.forEach((annot) => {
        console.log('annotation page number', annot.PageNumber);
      });
    });
  })
The annotationChanged event will also be fired whenever annotations are imported from XFDF, even if they were not created directly by a user.

If you want to do something different in that scenario, perhaps ignore those types of events, you can use the imported property of the info object. For example:

WebViewer(...)
  .then(instance => {
    const { annotationManager } = instance.Core;
    annotationManager.addEventListener('annotationChanged', (annotations, action, { imported }) => {
      // imported indicates if the annotations were imported via a process, mainly XFDF
      if (imported) {
        return;
      }
      // do event handling
    });
  })

One other property you might want to utilize is isUndoRedo, which will return true if the annotation has changed as a result of an undo or redo action.

annotationSelected

The annotationSelected event is fired any time an annotation is selected or deselected in the UI. The parameters are similar to annotationChanged: an array of annotations and a string for the action (selected or deselected). The preferred way to detect deselection is using the annotationDeselected event.

WebViewer(...)
  .then(instance => {
    const { annotationManager } = instance.Core;
    annotationManager.addEventListener('annotationSelected', (annotations, action) => {
      if (action === 'selected') {
        console.log('annotation selection');
      } else if (action === 'deselected') {
        console.log('annotation deselection');
      }

      console.log('annotation list', annotations);

      if (annotationManager.getSelectedAnnotations().length === 0 && action === 'deselected') {
        console.log('all annotations deselected');
      }
    });
  })
Users can select annotations through the viewer but you can also perform selections/deselections programmatically using our APIs .

annotationDeselected

Using the annotationDeselected event is the recommended way to detect annotation deselection and getting the deselected annotations. You will get only the deselected annotations as a parameter to the listener.

WebViewer(...)
  .then(instance => {
    const { annotationManager, Annotations } = instance.Core;
    annotationManager.addEventListener('annotationDeselected', (annotations) => {
      annotations.forEach(annot => {
        if (annot.FillColor) {
          annot.FillColor = new Annotations.Color(255, 0, 0, 1);
        }
      });
    });
  })

annotationsLoaded

The annotationsLoaded event is fired when all the annotations internal to the document have been loaded. It is one of the lifecycle events in WebViewer. Since DocumentViewer is managing this process the event is fired on DocumentViewer. When working with annotations, it would be best to use this event over documentLoaded to ensure all annotations are available.

WebViewer(...)
  .then(instance => {
    const { documentViewer, annotationManager } = instance.Core;
    documentViewer.addEventListener('annotationsLoaded', () => {
      // all annotations are available
      const annotations = annotationManager.getAnnotationsList();
    });
  })

Next steps

Look into how you can create your own annotations!

Get the answers you need: Support

Upcoming Webinar: Customer Experience and Retaining Control: Boosting Document Automation and Efficiency in Financial Services | Sept 15, 2022 at 11 am PT

PDFTron SDK

The Platform

NEW

© 2022 PDFTron Systems Inc. All rights reserved.

Privacy

Terms of Use