Add form printing support

src/core/annotation.js

@@ -23,17 +23,17 @@ import {
   assert,
   isString,
   OPS,
-  stringToBytes,
   stringToPDFString,
   Util,
   warn,
 } from "../shared/util.js";
 import { Catalog, FileSpec, ObjectLoader } from "./obj.js";
 import { Dict, isDict, isName, isRef, isStream } from "./primitives.js";
 import { ColorSpace } from "./colorspace.js";
+import { EvalState } from "./evaluator.js";
 import { getInheritableProperty } from "./core_utils.js";
 import { OperatorList } from "./operator_list.js";
-import { Stream } from "./stream.js";
+import { StringStream } from "./stream.js";
 
 class AnnotationFactory {
   /**
@@ -49,18 +49,21 @@ class AnnotationFactory {
    *   instance.
    */
   static create(xref, ref, pdfManager, idFactory) {
-    return pdfManager.ensure(this, "_create", [
-      xref,
-      ref,
-      pdfManager,
-      idFactory,
-    ]);
+    return pdfManager.ensureDoc("acroForm").then(acroForm => {
+      return pdfManager.ensure(this, "_create", [
+        xref,
+        ref,
+        pdfManager,
+        idFactory,
+        acroForm,
+      ]);
+    });
   }
 
   /**
    * @private
    */
-  static _create(xref, ref, pdfManager, idFactory) {
+  static _create(xref, ref, pdfManager, idFactory, acroForm) {
     const dict = xref.fetchIfRef(ref);
     if (!isDict(dict)) {
       return undefined;
@@ -78,6 +81,7 @@ class AnnotationFactory {
       subtype,
       id,
       pdfManager,
+      acroForm: acroForm instanceof Dict ? acroForm : Dict.empty,
     };
 
     switch (subtype) {
@@ -471,6 +475,7 @@ class Annotation {
    */
   setAppearance(dict) {
     this.appearance = null;
+    this.checkedAppearance = null;
 
     const appearanceStates = dict.get("AP");
     if (!isDict(appearanceStates)) {
@@ -509,13 +514,14 @@ class Annotation {
     });
   }
 
-  getOperatorList(evaluator, task, renderForms) {
+  getOperatorList(evaluator, task, renderForms, annotationStorage) {
     if (!this.appearance) {
       return Promise.resolve(new OperatorList());
     }
 
     const data = this.data;
-    const appearanceDict = this.appearance.dict;
+    const appearance = this.appearance;
+    const appearanceDict = appearance.dict;
     const resourcesPromise = this.loadResources([
       "ExtGState",
       "ColorSpace",
@@ -533,14 +539,14 @@ class Annotation {
       opList.addOp(OPS.beginAnnotation, [data.rect, transform, matrix]);
       return evaluator
         .getOperatorList({
-          stream: this.appearance,
+          stream: appearance,
           task,
           resources,
           operatorList: opList,
         })
         .then(() => {
           opList.addOp(OPS.endAnnotation, []);
-          this.appearance.reset();
+          appearance.reset();
           return opList;
         });
     });
@@ -799,7 +805,9 @@ class WidgetAnnotation extends Annotation {
     const fieldType = getInheritableProperty({ dict, key: "FT" });
     data.fieldType = isName(fieldType) ? fieldType.name : null;
     this.fieldResources =
-      getInheritableProperty({ dict, key: "DR" }) || Dict.empty;
+      getInheritableProperty({ dict, key: "DR" }) ||
+      params.acroForm.get("DR") ||
+      Dict.empty;
 
     data.fieldFlags = getInheritableProperty({ dict, key: "Ff" });
     if (!Number.isInteger(data.fieldFlags) || data.fieldFlags < 0) {
@@ -877,13 +885,18 @@ class WidgetAnnotation extends Annotation {
     return !!(this.data.fieldFlags & flag);
   }
 
-  getOperatorList(evaluator, task, renderForms) {
+  getOperatorList(evaluator, task, renderForms, annotationStorage) {
     // Do not render form elements on the canvas when interactive forms are
     // enabled. The display layer is responsible for rendering them instead.
     if (renderForms) {
       return Promise.resolve(new OperatorList());
     }
-    return super.getOperatorList(evaluator, task, renderForms);
+    return super.getOperatorList(
+      evaluator,
+      task,
+      renderForms,
+      annotationStorage
+    );
   }
 }
 
@@ -920,37 +933,141 @@ class TextWidgetAnnotation extends WidgetAnnotation {
       this.data.maxLen !== null;
   }
 
-  getOperatorList(evaluator, task, renderForms) {
-    if (renderForms || this.appearance) {
-      return super.getOperatorList(evaluator, task, renderForms);
+  getOperatorList(evaluator, task, renderForms, annotationStorage) {
+    return this.getAppearance(evaluator, task, annotationStorage).then(
+      content => {
+        if (renderForms || (this.appearance && content === null)) {
+          return super.getOperatorList(
+            evaluator,
+            task,
+            renderForms,
+            annotationStorage
+          );
+        }
+
+        const operatorList = new OperatorList();
+
+        // Even if there is an appearance stream, ignore it. This is the
+        // behaviour used by Adobe Reader.
+        if (!this.data.defaultAppearance || content === null) {
+          return operatorList;
+        }
+
+        const matrix = [1, 0, 0, 1, 0, 0];
+        const bbox = [
+          0,
+          0,
+          this.data.rect[2] - this.data.rect[0],
+          this.data.rect[3] - this.data.rect[1],
+        ];
+
+        const transform = getTransformMatrix(this.data.rect, bbox, matrix);
+        operatorList.addOp(OPS.beginAnnotation, [
+          this.data.rect,
+          transform,
+          matrix,
+        ]);
+
+        const stream = new StringStream(content);
+        return evaluator
+          .getOperatorList({
+            stream,
+            task,
+            resources: this.fieldResources,
+            operatorList,
+          })
+          .then(function () {
+            operatorList.addOp(OPS.endAnnotation, []);
+            return operatorList;
+          });
+      }
+    );
+  }
+
+  async getAppearance(evaluator, task, annotationStorage) {
+    if (!annotationStorage) {
+      return null;
+    }
+    const value = annotationStorage[this.data.id] || "";
+    if (value === "") {
+      return null;
+    }
+
+    const borderWidth = this.data.borderStyle.width;
+
+    // Default horizontal padding: can we have an heuristic to guess it?
+    const hPadding = borderWidth + 2;
+
+    // TODO: Handle the case where the font is not defined:
+    // fallback on helv maybe?
+    // TODO: Handle the case where fontSize is null
+    const [font, fontSize] = await this.getFontData(evaluator, task);
+
+    const vPadding = borderWidth + Math.ceil(Math.abs(font.descent) * fontSize);
+    const defaultAppearance = this.data.defaultAppearance;
+    const totalWidth = this.data.rect[2] - this.data.rect[0];
+
+    if (this.data.comb) {
+      const combWidth = (totalWidth / this.data.maxLen).toFixed(2);
+      let buf = `/Tx BMC q BT ${defaultAppearance} 1 0 0 1 ${hPadding} ${vPadding} Tm`;
+      let first = true;
+      for (const character of value) {
+        if (first) {
+          buf += ` (${character}) Tj`;
+          first = false;
+        } else {
+          buf += ` ${combWidth} 0 Td (${character}) Tj`;
+        }
+      }
+      buf += " ET Q EMC";
+      return buf;
+    }
+
+    const alignment = this.data.textAlignment;
+    if (alignment === 0 || alignment > 2) {
+      // Left alignment: nothing to do
+      return `/Tx BMC q BT ${defaultAppearance} 1 0 0 1 ${hPadding} ${vPadding} Tm (${value}) Tj ET Q EMC`;
     }
 
+    // We need to get the width of the text in order to align it correctly
+    const glyphs = font.charsToGlyphs(value);
+
+    const scale = fontSize / 1000;
+    let width = 0;
+    for (const glyph of glyphs) {
+      width += glyph.width * scale;
+    }
+
+    let shift;
+    if (alignment === 1) {
+      // Center
+      shift = (totalWidth - width) / 2;
+    } else {
+      // Right
+      shift = totalWidth - width - hPadding;
+    }
+
+    return `/Tx BMC q BT ${defaultAppearance} 1 0 0 1 ${shift} ${vPadding} Tm (${value}) Tj ET Q EMC`;
+  }
+
+  async getFontData(evaluator, task) {
     const operatorList = new OperatorList();
+    const initialState = new EvalState();
+    await evaluator.getOperatorList({
+      stream: new StringStream(this.data.defaultAppearance),
+      task,
+      resources: this.fieldResources,
+      operatorList,
+      initialState,
+    });
 
-    // Even if there is an appearance stream, ignore it. This is the
-    // behaviour used by Adobe Reader.
-    if (!this.data.defaultAppearance) {
-      return Promise.resolve(operatorList);
-    }
-
-    const stream = new Stream(stringToBytes(this.data.defaultAppearance));
-    return evaluator
-      .getOperatorList({
-        stream,
-        task,
-        resources: this.fieldResources,
-        operatorList,
-      })
-      .then(function () {
-        return operatorList;
-      });
+    return [initialState.font, initialState.fontSize];
   }
 }
 
 class ButtonWidgetAnnotation extends WidgetAnnotation {
   constructor(params) {
     super(params);
-
     this.data.checkBox =
       !this.hasFieldFlag(AnnotationFieldFlag.RADIO) &&
       !this.hasFieldFlag(AnnotationFieldFlag.PUSHBUTTON);
@@ -970,6 +1087,31 @@ class ButtonWidgetAnnotation extends WidgetAnnotation {
     }
   }
 
+  getOperatorList(evaluator, task, renderForms, annotationStorage) {
+    if (annotationStorage) {
+      const value = annotationStorage[this.data.id] || false;
+      if (value && this.checkedAppearance) {
+        const savedAppearance = this.appearance;
+        this.appearance = this.checkedAppearance;
+        const operatorList = super.getOperatorList(
+          evaluator,
+          task,
+          renderForms,
+          annotationStorage
+        );
+        this.appearance = savedAppearance;
+        return operatorList;
+      }
+      return Promise.resolve(new OperatorList());
+    }
+    return super.getOperatorList(
+      evaluator,
+      task,
+      renderForms,
+      annotationStorage
+    );
+  }
+
   _processCheckBox(params) {
     if (isName(this.data.fieldValue)) {
       this.data.fieldValue = this.data.fieldValue.name;
@@ -993,6 +1135,13 @@ class ButtonWidgetAnnotation extends WidgetAnnotation {
 
     this.data.exportValue =
       exportValues[0] === "Off" ? exportValues[1] : exportValues[0];
+
+    const normalAppearanceState = customAppearance.get("N");
+    if (!isDict(normalAppearanceState)) {
+      return;
+    }
+
+    this.checkedAppearance = normalAppearanceState.get(this.data.exportValue);
   }
 
   _processRadioButton(params) {
@@ -1023,6 +1172,7 @@ class ButtonWidgetAnnotation extends WidgetAnnotation {
         break;
       }
     }
+    this.checkedAppearance = normalAppearanceState.get(this.data.buttonValue);
   }
 
   _processPushButton(params) {

src/core/document.js

@@ -239,7 +239,14 @@ class Page {
     });
   }
 
-  getOperatorList({ handler, sink, task, intent, renderInteractiveForms }) {
+  getOperatorList({
+    handler,
+    sink,
+    task,
+    intent,
+    renderInteractiveForms,
+    annotationStorage,
+  }) {
     const contentStreamPromise = this.pdfManager.ensure(
       this,
       "getContentStream"
@@ -302,7 +309,12 @@ class Page {
           if (isAnnotationRenderable(annotation, intent)) {
             opListPromises.push(
               annotation
-                .getOperatorList(partialEvaluator, task, renderInteractiveForms)
+                .getOperatorList(
+                  partialEvaluator,
+                  task,
+                  renderInteractiveForms,
+                  annotationStorage
+                )
                 .catch(function (reason) {
                   warn(
                     "getOperatorList - ignoring annotation data during " +

src/core/evaluator.js

@@ -783,6 +783,7 @@ class PartialEvaluator {
       })
       .then(translated => {
         state.font = translated.font;
+        state.fontSize = fontArgs[1];
         translated.send(this.handler);
         return translated.loadedName;
       });
@@ -3518,6 +3519,7 @@ class EvalState {
   constructor() {
     this.ctm = new Float32Array(IDENTITY_MATRIX);
     this.font = null;
+    this.fontSize = 0;
     this.textRenderingMode = TextRenderingMode.FILL;
     this.fillColorSpace = ColorSpace.singletons.gray;
     this.strokeColorSpace = ColorSpace.singletons.gray;
@@ -3801,4 +3803,4 @@ class EvaluatorPreprocessor {
   }
 }
 
-export { PartialEvaluator };
+export { EvalState, PartialEvaluator };