Add support for saving forms

Author: calixteman

l10n/en-US/viewer.properties

@@ -41,6 +41,8 @@ print.title=Print
 print_label=Print
 download.title=Download
 download_label=Download
+save.title=Save
+save_label=Save
 bookmark.title=Current view (copy or open in new window)
 bookmark_label=Current View
 

src/core/annotation.js

@@ -34,6 +34,7 @@ import { ColorSpace } from "./colorspace.js";
 import { getInheritableProperty } from "./core_utils.js";
 import { OperatorList } from "./operator_list.js";
 import { StringStream } from "./stream.js";
+import { writeDict } from "./writer.js";
 
 class AnnotationFactory {
   /**
@@ -68,6 +69,7 @@ class AnnotationFactory {
     if (!isDict(dict)) {
       return undefined;
     }
+
     const id = isRef(ref) ? ref.toString() : `annot_${idFactory.createObjId()}`;
 
     // Determine the annotation's subtype.
@@ -77,6 +79,7 @@ class AnnotationFactory {
     // Return the right annotation object based on the subtype and field type.
     const parameters = {
       xref,
+      ref,
       dict,
       subtype,
       id,
@@ -792,6 +795,8 @@ class WidgetAnnotation extends Annotation {
 
     const dict = params.dict;
     const data = this.data;
+    this.dict = dict;
+    this.ref = params.ref;
 
     data.annotationType = AnnotationType.WIDGET;
     data.fieldName = this._constructFieldName(dict);
@@ -954,6 +959,70 @@ class WidgetAnnotation extends Annotation {
     );
   }
 
+  async save(evaluator, task, annotationStorage) {
+    if (this.data.fieldValue === annotationStorage[this.data.id]) {
+      return null;
+    }
+
+    let appearance = await this.getAppearance(
+      evaluator,
+      task,
+      annotationStorage
+    );
+    if (appearance !== null) {
+      const bbox = [
+        0,
+        0,
+        this.data.rect[2] - this.data.rect[0],
+        this.data.rect[3] - this.data.rect[1],
+      ];
+      const newRef = evaluator.xref.getNewRef();
+      const AP = new Dict(null);
+      AP.set("N", newRef);
+
+      let annotationString = annotationStorage[this.data.id];
+      const encrypt = evaluator.xref.encrypt;
+      if (encrypt) {
+        const transf = encrypt.createCipherTransform(
+          this.ref.num,
+          this.ref.gen
+        );
+        annotationString = transf.encryptString(annotationString);
+        const da = this.dict.get("DA") || null;
+        if (da !== null) {
+          this.dict.set("DA", transf.encryptString(da));
+        }
+        appearance = encrypt
+          .createCipherTransform(newRef.num, newRef.gen)
+          .encryptString(appearance);
+      }
+
+      this.dict.set("V", annotationString);
+      this.dict.set("AP", AP);
+
+      const appearanceDict = new Dict(null);
+      appearanceDict.set("Length", appearance.length);
+      appearanceDict.set("Subtype", { name: "Form" });
+      appearanceDict.set("Resources", this.fieldResources);
+      appearanceDict.set("BBox", bbox);
+
+      let bufferOriginal = `${this.ref.num} 0 obj\n`;
+      bufferOriginal = writeDict(this.dict, bufferOriginal);
+      bufferOriginal += "\nendobj\n";
+
+      let bufferNew = `${newRef.num} ${newRef.gen} obj\n`;
+      bufferNew = writeDict(appearanceDict, bufferNew);
+      bufferNew += ` stream\n${appearance}`;
+      bufferNew += "\nendstream\nendobj\n";
+
+      return [
+        { ref: this.ref.num, data: bufferOriginal },
+        { ref: newRef.num, data: bufferNew },
+      ];
+    }
+    return null;
+  }
+
   async getAppearance(evaluator, task, annotationStorage) {
     // If it's a password textfield then no rendering to avoid to leak it.
     // see 12.7.4.3, table 228
@@ -1288,6 +1357,24 @@ class ButtonWidgetAnnotation extends WidgetAnnotation {
     );
   }
 
+  async save(evaluator, task, annotationStorage) {
+    const defaultValue = this.data.fieldValue && this.data.fieldValue !== "Off";
+    const isChecked = annotationStorage[this.data.id];
+    if (defaultValue === isChecked) {
+      return null;
+    }
+
+    const value = isChecked ? this.data.exportValue : "Off";
+    this.dict.set("V", { name: value });
+    this.dict.set("AS", { name: value });
+
+    let buffer = `${this.ref.num} 0 obj\n`;
+    buffer = writeDict(this.dict, buffer);
+    buffer += "\nendobj\n";
+
+    return [{ ref: this.ref.num, data: buffer }];
+  }
+
   _processCheckBox(params) {
     if (isName(this.data.fieldValue)) {
       this.data.fieldValue = this.data.fieldValue.name;

src/core/crypto.js

@@ -73,6 +73,7 @@ var ARCFourCipher = (function ARCFourCipherClosure() {
     },
   };
   ARCFourCipher.prototype.decryptBlock = ARCFourCipher.prototype.encryptBlock;
+  ARCFourCipher.prototype.encrypt = ARCFourCipher.prototype.encryptBlock;
 
   return ARCFourCipher;
 })();
@@ -1474,6 +1475,12 @@ var CipherTransform = (function CipherTransformClosure() {
       data = cipher.decryptBlock(data, true);
       return bytesToString(data);
     },
+    encryptString: function CipherTransform_encryptString(s) {
+      var cipher = new this.StringCipherConstructor();
+      var data = stringToBytes(s);
+      data = cipher.encrypt(data);
+      return bytesToString(data);
+    },
   };
   return CipherTransform;
 })();

src/core/document.js

@@ -227,6 +227,46 @@ class Page {
     return stream;
   }
 
+  save(handler, task, annotationStorage) {
+    const partialEvaluator = new PartialEvaluator({
+      xref: this.xref,
+      handler,
+      pageIndex: this.pageIndex,
+      idFactory: this._localIdFactory,
+      fontCache: this.fontCache,
+      builtInCMapCache: this.builtInCMapCache,
+      globalImageCache: this.globalImageCache,
+      options: this.evaluatorOptions,
+    });
+
+    // Fetch the page's annotations and add their operator lists to the
+    // page's operator list to render them.
+    return this._parsedAnnotations.then(function (annotations) {
+      if (annotations.length === 0) {
+        return null;
+      }
+
+      const newRefsPromises = [];
+      for (const annotation of annotations) {
+        if (isAnnotationRenderable(annotation, "print")) {
+          newRefsPromises.push(
+            annotation
+              .save(partialEvaluator, task, annotationStorage)
+              .catch(function (reason) {
+                warn(
+                  "save - ignoring annotation data during " +
+                    `"${task.name}" task: "${reason}".`
+                );
+                return null;
+              })
+          );
+        }
+      }
+
+      return Promise.all(newRefsPromises);
+    });
+  }
+
   loadResources(keys) {
     if (!this.resourcesPromise) {
       // TODO: add async `_getInheritableProperty` and remove this.

src/core/obj.js

@@ -1135,9 +1135,21 @@ var XRef = (function XRefClosure() {
       streamTypes: Object.create(null),
       fontTypes: Object.create(null),
     };
+    this.newRef = null;
   }
 
   XRef.prototype = {
+    getNewRef: function XRef_getNewRef() {
+      if (this.newRef === null) {
+        this.newRef = this.entries.length;
+      }
+      return Ref.get(this.newRef++, 0);
+    },
+
+    resetNewRef: function XRef_resetNewRef() {
+      this.newRef = null;
+    },
+
     setStartXRef: function XRef_setStartXRef(startXRef) {
       // Store the starting positions of xref tables as we process them
       // so we can recover from missing data errors

src/core/worker.js

@@ -21,9 +21,11 @@ import {
   getVerbosityLevel,
   info,
   InvalidPDFException,
+  isString,
   MissingPDFException,
   PasswordException,
   setVerbosityLevel,
+  stringToPDFString,
   UnexpectedResponseException,
   UnknownErrorException,
   UNSUPPORTED_FEATURES,
@@ -35,6 +37,7 @@ import { LocalPdfManager, NetworkPdfManager } from "./pdf_manager.js";
 import { isNodeJS } from "../shared/is_node.js";
 import { MessageHandler } from "../shared/message_handler.js";
 import { PDFWorkerStream } from "./worker_stream.js";
+import { writeXRef } from "./writer.js";
 import { XRefParseException } from "./core_utils.js";
 
 class WorkerTask {
@@ -513,6 +516,58 @@ class WorkerMessageHandler {
       });
     });
 
+    handler.on("SavePage", function (data) {
+      var pageIndex = data.pageIndex;
+      return pdfManager.getPage(pageIndex).then(function (page) {
+        const task = new WorkerTask(`Save: page ${pageIndex}`);
+        return page.save(handler, task, data.annotationStorage);
+      });
+    });
+
+    handler.on("SaveDocument", function (data) {
+      pdfManager.requestLoadedStream();
+
+      const newRefs = data.newRefs;
+      if (newRefs.length === 0) {
+        // No new refs so just return the initial bytes
+        return pdfManager.onLoadedStream().then(function (stream) {
+          return stream.bytes;
+        });
+      }
+
+      const xref = pdfManager.pdfDocument.xref;
+      let newXrefInfo = Object.create(null);
+      if (xref.trailer) {
+        // Get string info from Info in order to compute fileId
+        const _info = Object.create(null);
+        const xrefInfo = xref.trailer.get("Info") || null;
+        if (xrefInfo) {
+          xrefInfo.forEach((key, value) => {
+            if (isString(value)) {
+              _info[key] =
+                typeof value !== "string" ? value : stringToPDFString(value);
+            }
+          });
+        }
+
+        newXrefInfo = {
+          rootRef: xref.trailer.getRaw("Root") || null,
+          encrypt: xref.trailer.getRaw("Encrypt") || null,
+          newRef: xref.getNewRef(),
+          infoRef: xref.trailer.getRaw("Info") || null,
+          info: _info,
+          fileIds: xref.trailer.getRaw("ID") || null,
+          startXRef: pdfManager.pdfDocument.startXRef,
+          filename: data.filename,
+        };
+      }
+      xref.resetNewRef();
+
+      return pdfManager.onLoadedStream().then(function (stream) {
+        return writeXRef(stream.bytes, newXrefInfo, newRefs);
+      });
+    });
+
     handler.on(
       "GetOperatorList",
       function wphSetupRenderPage(data, sink) {