Import/export annotations

WebViewer is able to import and export PDF annotations with the XFDF format. XFDF is an XML-based standard that is able to represent information about annotations. Saving and loading annotations in WebViewer is the process of saving and loading this XFDF data.

We will go through relevant APIs and examples for different scenarios in the following guides:

Importing and exporting annotations using a file
To import and export XFDF annotations using a file.

Importing and exporting annotations using a database
To import and export XFDF annotations using a databse.

Importing and exporting annotations using a document
To import and export XFDF annotations using a document.

Importing and exporting annotation in Salesforce
To import and export XFDF annotations using Salesforce.

Advanced annotation loading
To perform advanced control of the annotation loading process

A short introduction to XFDF file format
An introduction to XFDF file format

One of the options is to use XFDF files to save and load annotations. You can use AJAX requests to save and load the XFDF string from the server, and setup the server to write and read XFDF files. For example,

Importing annotations require at least the document to be loaded. When using the setDocumentXFDFRetriever API, the XFDF is imported at the earliest point possible.

1WebViewer(...)
2  .then(instance => {
3    const { documentViewer, annotationManager } = instance.Core;
4
5    // Import annotations as soon as we are able to
6    documentViewer.setDocumentXFDFRetriever(async () => {
7      // load the annotation data
8      const response = await fetch('path/to/annotation/server');
9      const xfdfString = await response.text();
10
11      // <xfdf>
12      //    <annots>
13      //      <text subject="Comment" page="0" color="#FFE6A2" ... />
14      //    </annots>
15      // </xfdf>
16      return xfdfString;
17    });
18  });

1WebViewer(...)
2  .then(instance => {
3    const { docViewer, annotManager } = instance;
4
5    // Import annotations as soon as we are able to
6    docViewer.setDocumentXFDFRetriever(async () => {
7      // load the annotation data
8      const response = await fetch('path/to/annotation/server');
9      const xfdfString = await response.text();
10
11      // <xfdf>
12      //    <annots>
13      //      <text subject="Comment" page="0" color="#FFE6A2" ... />
14      //    </annots>
15      // </xfdf>
16      return xfdfString;
17    });
18  });

Alternatively, importing annotations can be done with the importAnnotations API as well. The earliest point in which XFDF can be imported is documentLoaded.

1documentViewer.addEventListener('documentLoaded', async () => {
2  const response = await fetch('path/to/annotation/server');
3  const xfdfString = await response.text();
4
5  await annotationManager.importAnnotations(xfdfString);
6});

1documentViewer.on('documentLoaded', async () => {
2  const response = await fetch('path/to/annotation/server');
3  const xfdfString = await response.text();
4
5  await annotManager.importAnnotations(xfdfString);
6});

1WebViewer(...)
2  .then(instance => {
3    const { documentViewer, annotationManager } = instance.Core;
4
5    documentViewer.addEventListener('annotationsLoaded', () => {
6      // widgets and links will remain in the document without changing so it isn't necessary to export them
7      annotationManager.exportAnnotations({ links: false, widgets: false }).then(xfdfString => {
8        fetch('path/to/annotation/server', {
9          method: 'POST',
10          body: xfdfString // written into an XFDF file in server
11        });
12        // Full samples are available at the end of this section.
13      });
14    });
15  });

1WebViewer(...)
2  .then(instance => {
3    const { docViewer, annotManager } = instance;
4
5    docViewer.addEventListener('annotationsLoaded', () => {
6      // widgets and links will remain in the document without changing so it isn't necessary to export them
7      annotManager.exportAnnotations({ links: false, widgets: false }).then(xfdfString => {
8        fetch('path/to/annotation/server', {
9          method: 'POST',
10          body: xfdfString // written into an XFDF file in server
11        });
12        // Full samples are available at the end of this section.
13      });
14    });
15  })

In the POST and GET requests you can pass an ID to the server to uniquely identify the XFDF file that should be saved/loaded. You have full flexibility to choose this ID but here are some simple examples:

1. Use the filename as a unique identifier to have one XFDF file per document.
2. Use a combination of the filename and username as a unique identifier to have one XFDF per user per document.

For samples about saving annotations into XFDF files in different backends, see Github repos below:

• Node.js sample
• PHP sample
• ASP.NET (MVC) sample

Using the documentViewer.setXFDFRetriever or documentXFDFRetriever WebViewer constructor option is the preferred way of importing annotations from your server if you are adding them all at once initially.

• documentXFDFRetriever merges your annotations at the proper time automatically and prevents conflicts and potential flashing of annotations on the page.
• WebViewer will process the internal annotations from the document asynchronously. If you try to import your annotations with importAnnotations and your server has modifications to an annotation inside the document, for example on page 10 and WebViewer hasn't loaded the annotations for page 10 yet then there may be a conflict when merging these changes together.
• Using the annotationsLoaded event is one way to work around this so that there aren't any conflicts, however this event doesn't fire until annotations on every page have been loaded, so for documents with many pages this may take some time. It may also cause annotations to jump if the internal annotation has loaded on a page, then much later your server annotations are imported the annotation may change positions or even be deleted from the document.

importAnnotations is fine for importing annotations later, after the document's internal annotations have loaded, however for the initial import of your server annotations documentXFDFRetriever is recommended instead.

Another option is to use a database to store XFDF. You can choose to store the XFDF string for the document and user as described in using files, but with a database you can store and organize the XFDF data so that the XFDF string for each annotation is separate, allowing you to update it individually instead of updating the entire XFDF file for every change. For example, you can store and organize XFDF strings based on a combination of factors like document ID, annotation ID, author, etc.

For example, with a relational database, you can have a table called Annotations which contains annotation ID, document ID and xfdfString columns. In this setup, you can fetch all annotations for a particular document, or just fetch one annotation you are interested in.

To save individual annotations separately, the exportAnnotationCommand and annotationChanged event are very useful. exportAnnotationCommand returns XFDF data for all of the annotations that have changed since the last time you called exportAnnotationCommand.

Annotations that have been added are inside the add element, modified annotations are in the modify element and deleted annotations have their ID inside the delete element of the XFDF. If you call this function on the annotationChanged event, you can POST each command to your server to save each annotation change as it happens as opposed to having your user press a save button.

1WebViewer(...)
2  .then(instance => {
3    const { annotationManager } = instance.Core;
4
5    // Save the annotation XFDF as a transaction command for every change
6    annotationManager.addEventListener('annotationChanged', async (annotations, action, { imported }) => {
7      // If the event is triggered by importing then it can be ignored
8      // This will happen when importing the initial annotations
9      // from the server or individual changes from other users
10      if (imported) return;
11
12      const xfdfString = await annotationManager.exportAnnotationCommand();
13      // <xfdf>
14      //   <add>
15      //     <text subject="Comment" page="0" color="#FFE6A2" ... />
16      //   </add>
17      //   <modify />
18      //   <delete />
19      // </xfdf>
20      fetch('path/to/annotation/server', {
21        method: 'POST',
22        body: xfdfString // written to a database in the server
23      });
24    });
25    // Full samples are available at the end of this section.
26  });

1WebViewer(...)
2  .then(instance => {
3    const { annotManager } = instance;
4
5    // Save the annotation XFDF as transaction command for every change
6    annotManager.on('annotationChanged', (annotations, action, { imported }) => {
7      // If the event is triggered by importing then it can be ignored
8      // This will happen when importing the initial annotations
9      // from the server or individual changes from other users
10      if (imported) return;
11
12      const xfdfString = annotManager.getAnnotCommand();
13      // <xfdf>
14      //   <add>
15      //     <text subject="Comment" page="0" color="#FFE6A2" ... />
16      //   </add>
17      //   <modify />
18      //   <delete />
19      // </xfdf>
20      fetch('path/to/annotation/server', {
21        method: 'POST',
22        body: xfdfString // written to a database in the server
23      });
24    });
25    // Full samples are available at the end of this section.
26  })

When importing annotations, you can use importAnnotationCommand. The earliest point you can call this is during documentLoaded.

1WebViewer(...)
2  .then(instance => {
3    const { documentViewer, annotationManager } = instance.Core;
4
5    documentViewer.addEventListener('documentLoaded', () => {
6      // load the annotation data as a transaction command
7      fetch('path/to/annotation/server', {
8        method: 'GET'
9      }).then(async response => {
10        if (response.status === 200) {
11          response.text().then(xfdfString => {
12            // <xfdf>
13            //   <add>
14            //     <text subject="Comment" page="0" color="#FFE6A2" ... />
15            //   </add>
16            //   <modify />
17            //   <delete />
18            // </xfdf>
19            const annotations = await annotationManager.importAnnotationCommand(xfdfString);
20            annotations.forEach(a => {
21              annotationManager.redrawAnnotation(annotation);
22            });
23          });
24        }
25        // Full samples are available at the end of this section.
26      });
27    });
28  });

1WebViewer(...)
2  .then(instance => {
3    const { docViewer, annotManager } = instance;
4
5    docViewer.on('documentLoaded', () => {
6      // load the annotation data as a transaction command
7      fetch('path/to/annotation/server', {
8        method: 'GET'
9      }).then(response => {
10        if (response.status === 200) {
11          response.text().then(async xfdfString => {
12            // <xfdf>
13            //   <add>
14            //     <text subject="Comment" page="0" color="#FFE6A2" ... />
15            //   </add>
16            //   <modify />
17            //   <delete />
18            // </xfdf>
19            const annotations = await annotManager.importAnnotCommand(xfdfString);
20            annotations.forEach(a => {
21              annotManager.redrawAnnotation(annotation);
22            });
23          });
24        }
25        // Full samples are available at the end of this section.
26      });
27    });
28  });

At this point you'll be saving annotations in realtime, so if you want to have a fully realtime solution you'll need to update annotations on each client in realtime. You can extend realtime saving further by hooking it up to a WebSocket, which can broadcast the new xfdfString in the database to be imported to all the clients. By utilizing exportAnnotationCommand instead of exportAnnotations you can greatly reduce the size of the data being transferred to/from the annotation server.

For samples about saving annotations into different databases, see links below:

• SQLite3 sample
• SQLite3 + WebSocket sample - realtime
• Firebase sample - realtime

Importing and exporting annotations using Salesforce

Another option for importing and exporting annotation is using Salesforce custom objects to store XFDF data if you are hosting WebViewer in the Salesforce platform. You can create custom object in Salesforce setting page or using sfdx command line utility tool. In this example we will create Apex class called AnnotationController.cls which will utilize Salesforce SOQL to store and retrieve XFDF data to and from custom objects.

Create custom object in Salesforce setting page, under Manage Objects section. Here is a sample custom object used in this sample

Apex class for storing and retrieving annotation XFDF data.

1public with sharing class AnnotationController {
2    @AuraEnabled
3    public static String saveAnnotations(String action, String documentId, String annotationId, String xfdfString) {
4        PDFTronAnnotations__c[] annots = [SELECT Id, Content_Version_Id__c, Annotation_Id__c, xfdfString__c
5            FROM PDFTronAnnotations__c WHERE Annotation_Id__c = :annotationId];
6        Pattern MyPattern = Pattern.compile('<delete>(.*)</delete>');
7        Matcher MyMatcher = MyPattern.matcher(xfdfString);
8        Boolean isDeleteCommand = MyMatcher.matches();
9        if (action == 'delete') {
10            // Delete record
11            delete annots;
12            return 'Success';
13        } else if (annots.size() == 0) {
14            // Create new record
15            PDFTronAnnotations__c newAnnot = new PDFTronAnnotations__c(
16                Content_Version_Id__c=documentId,
17                Annotation_Id__c=annotationId,
18                xfdfString__c=xfdfString
19            );
20            insert newAnnot;
21            return newAnnot.Id;
22        } else {
23            // Update record
24            annots[0].xfdfString__c = xfdfString;
25            update annots;
26            return annots[0].Id;
27        }
28    }
29    @AuraEnabled
30    public static List<Map<String,String>> getAnnotations(String documentId) {
31        List<PDFTronAnnotations__c> temp = [SELECT Id, Content_Version_Id__c, Annotation_Id__c, xfdfString__c FROM PDFTronAnnotations__c WHERE Content_Version_Id__c = :documentId];
32        List<Map<String,String>> annotations = new List<Map<String,String>>();
33        for (Integer i = 0; i < temp.size(); i++) {
34            Map<String,String> annot = new Map<String, String>();
35            annot.put('xfdfString', temp[i].xfdfString__c);
36            annot.put('Annotation_Id', temp[i].Annotation_Id__c);
37            annot.put('ContentVersion_Id', temp[i].Content_Version_Id__c);
38            annotations.add(annot);
39        }
40        return annotations;
41    }
42}
43// Full sample is available at the end of this section.

Sample app in Lightning Web Component to showcase importing and exporting XFDF stirng to Salesforce custom object.

1/** AnnotationController.getAnnotations(id) Apex method */
2import getAnnotations from '@salesforce/apex/AnnotationController.getAnnotations';
3/** AnnotationController.saveAnnotations(params) Apex method */
4import saveAnnotations from '@salesforce/apex/AnnotationController.saveAnnotations';
5export default class WvInstance extends LightningElement {
6  // Snipped for brevity
7  initUI() {
8    // ...
9    const viewer = new PDFTron.WebViewer({...}, viewerElement);
10    viewerElement.addEventListener('ready', () => {
11      this.iframeWindow = viewerElement.querySelector('iframe').contentWindow;
12    })
13  }
14  // Snipped for brevity
15  handleReceiveMessage(event) {
16    if (event.isTrusted && typeof event.data === 'object') {
17      switch (event.data.type) {
18        case 'LOAD_ANNOTATIONS':
19          /**
20            * Retrieve/import annotation for the loaded document
21            *
22            * @param {string} documentId unique id of the loaded document
23            * @returns {string} xfdf string
24            */
25          getAnnotations(event.data.payload)
26            .then(result => {
27              this.iframeWindow.postMessage(
28                { type: 'LOAD_ANNOTATIONS_FINISHED', result },
29                window.location.origin
30              );
31            })
32          break;
33        case 'SAVE_ANNOTATIONS':
34          /**
35            * Storing/exporting XFDF string to Salesforce custom object
36            *
37            * @param {string} action type of action, e.g. delete, update,
38            * @param {string} documentId unique id of the document
39            * @param {string} annotationId id of the annotation
40            * @param {string} xfdfString xfdf string
41            */
42          saveAnnotations(event.data.payload);
43          break;
44        default:
45          break;
46      }
47    }
48  }
49  // Snipped for brevity
50}

For more advanced control over the annotation loading process you can use the setPagesUpdatedInternalAnnotationsTransform function on DocumentViewer. When WebViewer loads a document it will import the annotation data as XFDF and this function allows you to transform that data before it gets loaded into the viewer.

The function that you pass to setPagesUpdatedInternalAnnotationsTransform may be called multiple times, specifying the list of pages that the annotation data is a part of.

You can use the function like this:

1WebViewer(...)
2  .then(instance => {
3    const { documentViewer } = instance.Core;
4
5    documentViewer.setPagesUpdatedInternalAnnotationsTransform((xfdfData, pageList, callback) => {
6      // if the pageList is [0, 1, 2, 3] then the data is of all annotations on the first four pages
7      // make modifications here
8      // ...
9      callback(newXfdfData);
10    });
11  });

1WebViewer(...)
2  .then(instance => {
3    const { docViewer } = instance;
4
5    docViewer.setPagesUpdatedInternalAnnotationsTransform((xfdfData, pageList, callback) => {
6      // if the pageList is [0, 1, 2, 3] then the data is of all annotations on the first four pages
7      // make modifications here
8      // ...
9      callback(newXfdfData);
10    });
11  });

One way to use setPagesUpdatedInternalAnnotationsTransform is to replace the original annotation data inside the document with the data from your server. Note that this would also replace any existing links or form fields unless they are also saved on your server.

Alternatively you can modify the existing data that is passed in. When modifying the data it is easiest to first parse it into DOM elements, perform your modifications and then serialize back to a string.

An example of something you might want to do is remove all clickable links:

1WebViewer(...)
2  .then(instance => {
3    const { docViewer } = instance.Core;
4    docViewer.setPagesUpdatedInternalAnnotationsTransform((xfdfData, pageList, callback) => {
5      const parser = new DOMParser();
6      const xfdfElements = parser.parseFromString(xfdfData, 'text/xml');
7      [].forEach.call(xfdfElements.querySelectorAll('link'), e => {
8        e.parentNode.removeChild(e);
9      });
10
11      const serializer = new XMLSerializer();
12      callback(serializer.serializeToString(xfdfElements));
13    });
14  })

1WebViewer(...)
2  .then(instance => {
3    const { docViewer } = instance;
4    docViewer.setPagesUpdatedInternalAnnotationsTransform((xfdfData, pageList, callback) => {
5      const parser = new DOMParser();
6      const xfdfElements = parser.parseFromString(xfdfData, 'text/xml');
7      [].forEach.call(xfdfElements.querySelectorAll('link'), e => {
8        e.parentNode.removeChild(e);
9      });
10
11      const serializer = new XMLSerializer();
12      callback(serializer.serializeToString(xfdfElements));
13    });
14  })

Here's another example of changing the color attribute of every annotation to blue:

1WebViewer(...)
2  .then(instance => {
3    const { docViewer } = instance.Core;
4    docViewer.setPagesUpdatedInternalAnnotationsTransform((xfdfData, pageList, callback) => {
5      const parser = new DOMParser();
6      const xfdfElements = parser.parseFromString(xfdfData, 'text/xml');
7      const annotations = xfdfElements.querySelector('annots').children;
8      [].forEach.call(annotations, annotElement => {
9        annotElement.setAttribute('color', '#0000FF');
10      });
11
12      const serializer = new XMLSerializer();
13      callback(serializer.serializeToString(xfdfElements));
14    });
15  })

1WebViewer(...)
2  .then(instance => {
3    const { docViewer } = instance;
4    docViewer.setPagesUpdatedInternalAnnotationsTransform((xfdfData, pageList, callback) => {
5      const parser = new DOMParser();
6      const xfdfElements = parser.parseFromString(xfdfData, 'text/xml');
7      const annotations = xfdfElements.querySelector('annots').children;
8      [].forEach.call(annotations, annotElement => {
9        annotElement.setAttribute('color', '#0000FF');
10      });
11
12      const serializer = new XMLSerializer();
13      callback(serializer.serializeToString(xfdfElements));
14    });
15  })

With setPagesUpdatedInternalAnnotationsTransform you have very fine control over all of the annotation data and can modify it exactly as you like.