Add support for saving forms

Author: calixteman

src/core/annotation.js

@@ -22,18 +22,20 @@ import {
   AnnotationType,
   assert,
   escapeString,
+  getModificationDate,
   isString,
   OPS,
   stringToPDFString,
   Util,
   warn,
 } from "../shared/util.js";
 import { Catalog, FileSpec, ObjectLoader } from "./obj.js";
-import { Dict, isDict, isName, isRef, isStream } from "./primitives.js";
+import { Dict, isDict, isName, isRef, isStream, Name } from "./primitives.js";
 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 +70,7 @@ class AnnotationFactory {
     if (!isDict(dict)) {
       return undefined;
     }
+
     const id = isRef(ref) ? ref.toString() : `annot_${idFactory.createObjId()}`;
 
     // Determine the annotation's subtype.
@@ -77,6 +80,7 @@ class AnnotationFactory {
     // Return the right annotation object based on the subtype and field type.
     const parameters = {
       xref,
+      ref,
       dict,
       subtype,
       id,
@@ -550,6 +554,10 @@ class Annotation {
         });
     });
   }
+
+  async save(evaluator, task, annotationStorage) {
+    return null;
+  }
 }
 
 /**
@@ -791,6 +799,7 @@ class WidgetAnnotation extends Annotation {
 
     const dict = params.dict;
     const data = this.data;
+    this.ref = params.ref;
 
     data.annotationType = AnnotationType.WIDGET;
     data.fieldName = this._constructFieldName(dict);
@@ -953,6 +962,75 @@ 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 dict = evaluator.xref.fetchIfRef(this.ref);
+      if (!isDict(dict)) {
+        return 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);
+
+      const annotationString = annotationStorage[this.data.id];
+      const encrypt = evaluator.xref.encrypt;
+      let transfOriginal = null;
+      let transfNew = null;
+      if (encrypt) {
+        transfOriginal = encrypt.createCipherTransform(
+          this.ref.num,
+          this.ref.gen
+        );
+        transfNew = encrypt.createCipherTransform(newRef.num, newRef.gen);
+        appearance = transfNew.encryptString(appearance);
+      }
+
+      dict.set("V", annotationString);
+      dict.set("AP", AP);
+      dict.set("M", `D:${getModificationDate()}`);
+
+      const appearanceDict = new Dict(null);
+      appearanceDict.set("Length", appearance.length);
+      appearanceDict.set("Subtype", Name.get("Form"));
+      appearanceDict.set("Resources", this.fieldResources);
+      appearanceDict.set("BBox", bbox);
+      appearanceDict.set("M", `D:${getModificationDate()}`);
+
+      const bufferOriginal = [`${this.ref.num} 0 obj\n`];
+      writeDict(dict, bufferOriginal, transfOriginal);
+      bufferOriginal.push("\nendobj\n");
+
+      const bufferNew = [`${newRef.num} ${newRef.gen} obj\n`];
+      writeDict(appearanceDict, bufferNew, transfNew);
+      bufferNew.push(" stream\n");
+      bufferNew.push(appearance);
+      bufferNew.push("\nendstream\nendobj\n");
+
+      return [
+        { ref: this.ref.num, data: bufferOriginal.join("") },
+        { ref: newRef.num, data: bufferNew.join("") },
+      ];
+    }
+    return null;
+  }
+
   async _getAppearance(evaluator, task, annotationStorage) {
     const isPassword = this.hasFieldFlag(AnnotationFieldFlag.PASSWORD);
     if (!annotationStorage || isPassword) {
@@ -1312,6 +1390,46 @@ class ButtonWidgetAnnotation extends WidgetAnnotation {
     );
   }
 
+  async save(evaluator, task, annotationStorage) {
+    if (!this.data.checkBox && !this.data.radioButton) {
+      return null;
+    }
+
+    const defaultValue = this.data.fieldValue && this.data.fieldValue !== "Off";
+    const isChecked = annotationStorage[this.data.id];
+    if (defaultValue === isChecked) {
+      return null;
+    }
+
+    const dict = evaluator.xref.fetchIfRef(this.ref);
+    if (!isDict(dict)) {
+      return null;
+    }
+
+    const value = this.data.checkBox
+      ? this.data.exportValue
+      : this.data.buttonValue;
+    const name = Name.get(isChecked ? value : "Off");
+    dict.set("V", name);
+    dict.set("AS", name);
+    dict.set("M", `D:${getModificationDate()}`);
+
+    const encrypt = evaluator.xref.encrypt;
+    let transfOriginal = null;
+    if (encrypt) {
+      transfOriginal = encrypt.createCipherTransform(
+        this.ref.num,
+        this.ref.gen
+      );
+    }
+
+    const buffer = [`${this.ref.num} 0 obj\n`];
+    writeDict(dict, buffer, transfOriginal);
+    buffer.push("\nendobj\n");
+
+    return [{ ref: this.ref.num, data: buffer.join("") }];
+  }
+
   _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;
 })();
@@ -699,6 +700,9 @@ var NullCipher = (function NullCipherClosure() {
     decryptBlock: function NullCipher_decryptBlock(data) {
       return data;
     },
+    encrypt: function NullCipher_encrypt(data) {
+      return data;
+    },
   };
 
   return NullCipher;
@@ -1097,6 +1101,7 @@ class AESBaseCipher {
       if (bufferLength < 16) {
         continue;
       }
+
       for (let j = 0; j < 16; ++j) {
         buffer[j] ^= iv[j];
       }
@@ -1474,6 +1479,42 @@ var CipherTransform = (function CipherTransformClosure() {
       data = cipher.decryptBlock(data, true);
       return bytesToString(data);
     },
+    encryptString: function CipherTransform_encryptString(s) {
+      const cipher = new this.StringCipherConstructor();
+      if (cipher instanceof AESBaseCipher) {
+        // Append some chars equal to "16 - (M mod 16)"
+        // where M is the string length (see 7.6.2)
+        // to have a final string where the length is a multiple of 16.
+        const strLen = s.length;
+        const pad = 16 - (strLen % 16);
+        if (pad !== 16) {
+          s = s.padEnd(16 * Math.ceil(strLen / 16), String.fromCharCode(pad));
+        }
+
+        // Generate an iv vector
+        const iv = new Uint8Array(16);
+        if (typeof crypto !== "undefined") {
+          crypto.getRandomValues(iv);
+        } else {
+          for (let i = 0; i < 16; i++) {
+            iv[i] = Math.floor(256 * Math.random());
+          }
+        }
+
+        let data = stringToBytes(s);
+        data = cipher.encrypt(data, iv);
+
+        const buf = new Uint8Array(16 + data.length);
+        buf.set(iv);
+        buf.set(data, 16);
+
+        return bytesToString(buf);
+      }
+
+      let data = stringToBytes(s);
+      data = cipher.encrypt(data);
+      return bytesToString(data);
+    },
   };
   return CipherTransform;
 })();

src/core/document.js

@@ -227,6 +227,42 @@ 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) {
+      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

@@ -1211,9 +1211,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