modules/acroform.js

  1. /* global jsPDF */
  2. /**
  3.  * @license
  4.  * Copyright (c) 2016 Alexander Weidt,
  5.  * https://github.com/BiggA94
  6.  *
  7.  * Licensed under the MIT License. http://opensource.org/licenses/mit-license
  8.  */
  10. /**
  11.  * jsPDF AcroForm Plugin
  12.  * @module AcroForm
  13.  */
  15. import { jsPDF } from "../jspdf.js";
  17. var jsPDFAPI = jsPDF.API;
  18. var scaleFactor = 1;
  20. var pdfEscape = function(value) {
  21.   return value
  22.     .replace(/\\/g, "\\\\")
  23.     .replace(/\(/g, "\\(")
  24.     .replace(/\)/g, "\\)");
  25. };
  26. var pdfUnescape = function(value) {
  27.   return value
  28.     .replace(/\\\\/g, "\\")
  29.     .replace(/\\\(/g, "(")
  30.     .replace(/\\\)/g, ")");
  31. };
  33. var f2 = function(number) {
  34.   return number.toFixed(2); // Ie, %.2f
  35. };
  37. var f5 = function(number) {
  38.   return number.toFixed(5); // Ie, %.2f
  39. };
  41. jsPDFAPI.__acroform__ = {};
  42. var inherit = function(child, parent) {
  43.   child.prototype = Object.create(parent.prototype);
  44.   child.prototype.constructor = child;
  45. };
  47. var scale = function(x) {
  48.   return x * scaleFactor;
  49. };
  51. var createFormXObject = function(formObject) {
  52.   var xobj = new AcroFormXObject();
  53.   var height = AcroFormAppearance.internal.getHeight(formObject) || 0;
  54.   var width = AcroFormAppearance.internal.getWidth(formObject) || 0;
  55.   xobj.BBox = [0, 0, Number(f2(width)), Number(f2(height))];
  56.   return xobj;
  57. };
  59. /**
  60.  * Bit-Operations
  61.  */
  62. var setBit = (jsPDFAPI.__acroform__.setBit = function(number, bitPosition) {
  63.   number = number || 0;
  64.   bitPosition = bitPosition || 0;
  66.   if (isNaN(number) || isNaN(bitPosition)) {
  67.     throw new Error(
  68.       "Invalid arguments passed to jsPDF.API.__acroform__.setBit"
  69.     );
  70.   }
  71.   var bitMask = 1 << bitPosition;
  73.   number |= bitMask;
  75.   return number;
  76. });
  78. var clearBit = (jsPDFAPI.__acroform__.clearBit = function(number, bitPosition) {
  79.   number = number || 0;
  80.   bitPosition = bitPosition || 0;
  82.   if (isNaN(number) || isNaN(bitPosition)) {
  83.     throw new Error(
  84.       "Invalid arguments passed to jsPDF.API.__acroform__.clearBit"
  85.     );
  86.   }
  87.   var bitMask = 1 << bitPosition;
  89.   number &= ~bitMask;
  91.   return number;
  92. });
  94. var getBit = (jsPDFAPI.__acroform__.getBit = function(number, bitPosition) {
  95.   if (isNaN(number) || isNaN(bitPosition)) {
  96.     throw new Error(
  97.       "Invalid arguments passed to jsPDF.API.__acroform__.getBit"
  98.     );
  99.   }
  100.   return (number & (1 << bitPosition)) === 0 ? 0 : 1;
  101. });
  103. /*
  104.  * Ff starts counting the bit position at 1 and not like javascript at 0
  105.  */
  106. var getBitForPdf = (jsPDFAPI.__acroform__.getBitForPdf = function(
  107.   number,
  108.   bitPosition
  109. ) {
  110.   if (isNaN(number) || isNaN(bitPosition)) {
  111.     throw new Error(
  112.       "Invalid arguments passed to jsPDF.API.__acroform__.getBitForPdf"
  113.     );
  114.   }
  115.   return getBit(number, bitPosition - 1);
  116. });
  118. var setBitForPdf = (jsPDFAPI.__acroform__.setBitForPdf = function(
  119.   number,
  120.   bitPosition
  121. ) {
  122.   if (isNaN(number) || isNaN(bitPosition)) {
  123.     throw new Error(
  124.       "Invalid arguments passed to jsPDF.API.__acroform__.setBitForPdf"
  125.     );
  126.   }
  127.   return setBit(number, bitPosition - 1);
  128. });
  130. var clearBitForPdf = (jsPDFAPI.__acroform__.clearBitForPdf = function(
  131.   number,
  132.   bitPosition
  133. ) {
  134.   if (isNaN(number) || isNaN(bitPosition)) {
  135.     throw new Error(
  136.       "Invalid arguments passed to jsPDF.API.__acroform__.clearBitForPdf"
  137.     );
  138.   }
  139.   return clearBit(number, bitPosition - 1);
  140. });
  142. var calculateCoordinates = (jsPDFAPI.__acroform__.calculateCoordinates = function(
  143.   args,
  144.   scope
  145. ) {
  146.   var getHorizontalCoordinate = scope.internal.getHorizontalCoordinate;
  147.   var getVerticalCoordinate = scope.internal.getVerticalCoordinate;
  148.   var x = args[0];
  149.   var y = args[1];
  150.   var w = args[2];
  151.   var h = args[3];
  153.   var coordinates = {};
  155.   coordinates.lowerLeft_X = getHorizontalCoordinate(x) || 0;
  156.   coordinates.lowerLeft_Y = getVerticalCoordinate(y + h) || 0;
  157.   coordinates.upperRight_X = getHorizontalCoordinate(x + w) || 0;
  158.   coordinates.upperRight_Y = getVerticalCoordinate(y) || 0;
  160.   return [
  161.     Number(f2(coordinates.lowerLeft_X)),
  162.     Number(f2(coordinates.lowerLeft_Y)),
  163.     Number(f2(coordinates.upperRight_X)),
  164.     Number(f2(coordinates.upperRight_Y))
  165.   ];
  166. });
  168. var calculateAppearanceStream = function(formObject) {
  169.   if (formObject.appearanceStreamContent) {
  170.     return formObject.appearanceStreamContent;
  171.   }
  173.   if (!formObject.V && !formObject.DV) {
  174.     return;
  175.   }
  177.   // else calculate it
  179.   var stream = [];
  180.   var text = formObject._V || formObject.DV;
  181.   var calcRes = calculateX(formObject, text);
  182.   var fontKey = formObject.scope.internal.getFont(
  183.     formObject.fontName,
  184.     formObject.fontStyle
  185.   ).id;
  187.   //PDF 32000-1:2008, page 444
  188.   stream.push("/Tx BMC");
  189.   stream.push("q");
  190.   stream.push("BT"); // Begin Text
  191.   stream.push(formObject.scope.__private__.encodeColorString(formObject.color));
  192.   stream.push("/" + fontKey + " " + f2(calcRes.fontSize) + " Tf");
  193.   stream.push("1 0 0 1 0 0 Tm"); // Transformation Matrix
  194.   stream.push(calcRes.text);
  195.   stream.push("ET"); // End Text
  196.   stream.push("Q");
  197.   stream.push("EMC");
  199.   var appearanceStreamContent = createFormXObject(formObject);
  200.   appearanceStreamContent.scope = formObject.scope;
  201.   appearanceStreamContent.stream = stream.join("\n");
  202.   return appearanceStreamContent;
  203. };
  205. var calculateX = function(formObject, text) {
  206.   var maxFontSize =
  207.     formObject.fontSize === 0 ? formObject.maxFontSize : formObject.fontSize;
  208.   var returnValue = {
  209.     text: "",
  210.     fontSize: ""
  211.   };
  212.   // Remove Brackets
  213.   text = text.substr(0, 1) == "(" ? text.substr(1) : text;
  214.   text =
  215.     text.substr(text.length - 1) == ")"
  216.       ? text.substr(0, text.length - 1)
  217.       : text;
  218.   // split into array of words
  219.   var textSplit = text.split(" ");
  220.   if (formObject.multiline) {
  221.     textSplit = textSplit.map(word => word.split("\n"));
  222.   } else {
  223.     textSplit = textSplit.map(word => [word]);
  224.   }
  226.   var fontSize = maxFontSize; // The Starting fontSize (The Maximum)
  227.   var lineSpacing = 2;
  228.   var borderPadding = 2;
  230.   var height = AcroFormAppearance.internal.getHeight(formObject) || 0;
  231.   height = height < 0 ? -height : height;
  232.   var width = AcroFormAppearance.internal.getWidth(formObject) || 0;
  233.   width = width < 0 ? -width : width;
  235.   var isSmallerThanWidth = function(i, lastLine, fontSize) {
  236.     if (i + 1 < textSplit.length) {
  237.       var tmp = lastLine + " " + textSplit[i + 1][0];
  238.       var TextWidth = calculateFontSpace(tmp, formObject, fontSize).width;
  239.       var FieldWidth = width - 2 * borderPadding;
  240.       return TextWidth <= FieldWidth;
  241.     } else {
  242.       return false;
  243.     }
  244.   };
  246.   fontSize++;
  247.   FontSize: while (fontSize > 0) {
  248.     text = "";
  249.     fontSize--;
  250.     var textHeight = calculateFontSpace("3", formObject, fontSize).height;
  251.     var startY = formObject.multiline
  252.       ? height - fontSize
  253.       : (height - textHeight) / 2;
  254.     startY += lineSpacing;
  255.     var startX;
  257.     var lastY = startY;
  258.     var firstWordInLine = 0,
  259.       lastWordInLine = 0;
  260.     var lastLength;
  261.     var currWord = 0;
  263.     if (fontSize <= 0) {
  264.       // In case, the Text doesn't fit at all
  265.       fontSize = 12;
  266.       text = "(...) Tj\n";
  267.       text +=
  268.         "% Width of Text: " +
  269.         calculateFontSpace(text, formObject, fontSize).width +
  270.         ", FieldWidth:" +
  271.         width +
  272.         "\n";
  273.       break;
  274.     }
  276.     var lastLine = "";
  277.     var lineCount = 0;
  278.     Line: for (var i = 0; i < textSplit.length; i++) {
  279.       if (textSplit.hasOwnProperty(i)) {
  280.         let isWithNewLine = false;
  281.         if (textSplit[i].length !== 1 && currWord !== textSplit[i].length - 1) {
  282.           if (
  283.             (textHeight + lineSpacing) * (lineCount + 2) + lineSpacing >
  284.             height
  285.           ) {
  286.             continue FontSize;
  287.           }
  289.           lastLine += textSplit[i][currWord];
  290.           isWithNewLine = true;
  291.           lastWordInLine = i;
  292.           i--;
  293.         } else {
  294.           lastLine += textSplit[i][currWord] + " ";
  295.           lastLine =
  296.             lastLine.substr(lastLine.length - 1) == " "
  297.               ? lastLine.substr(0, lastLine.length - 1)
  298.               : lastLine;
  299.           var key = parseInt(i);
  300.           var nextLineIsSmaller = isSmallerThanWidth(key, lastLine, fontSize);
  301.           var isLastWord = i >= textSplit.length - 1;
  303.           if (nextLineIsSmaller && !isLastWord) {
  304.             lastLine += " ";
  305.             currWord = 0;
  306.             continue; // Line
  307.           } else if (!nextLineIsSmaller && !isLastWord) {
  308.             if (!formObject.multiline) {
  309.               continue FontSize;
  310.             } else {
  311.               if (
  312.                 (textHeight + lineSpacing) * (lineCount + 2) + lineSpacing >
  313.                 height
  314.               ) {
  315.                 // If the Text is higher than the
  316.                 // FieldObject
  317.                 continue FontSize;
  318.               }
  319.               lastWordInLine = key;
  320.               // go on
  321.             }
  322.           } else if (isLastWord) {
  323.             lastWordInLine = key;
  324.           } else {
  325.             if (
  326.               formObject.multiline &&
  327.               (textHeight + lineSpacing) * (lineCount + 2) + lineSpacing >
  328.                 height
  329.             ) {
  330.               // If the Text is higher than the FieldObject
  331.               continue FontSize;
  332.             }
  333.           }
  334.         }
  335.         // Remove last blank
  337.         var line = "";
  339.         for (var x = firstWordInLine; x <= lastWordInLine; x++) {
  340.           var currLine = textSplit[x];
  341.           if (formObject.multiline) {
  342.             if (x === lastWordInLine) {
  343.               line += currLine[currWord] + " ";
  344.               currWord = (currWord + 1) % currLine.length;
  345.               continue;
  346.             }
  347.             if (x === firstWordInLine) {
  348.               line += currLine[currLine.length - 1] + " ";
  349.               continue;
  350.             }
  351.           }
  352.           line += currLine[0] + " ";
  353.         }
  355.         // Remove last blank
  356.         line =
  357.           line.substr(line.length - 1) == " "
  358.             ? line.substr(0, line.length - 1)
  359.             : line;
  360.         // lastLength -= blankSpace.width;
  361.         lastLength = calculateFontSpace(line, formObject, fontSize).width;
  363.         // Calculate startX
  364.         switch (formObject.textAlign) {
  365.           case "right":
  366.             startX = width - lastLength - borderPadding;
  367.             break;
  368.           case "center":
  369.             startX = (width - lastLength) / 2;
  370.             break;
  371.           case "left":
  372.           default:
  373.             startX = borderPadding;
  374.             break;
  375.         }
  376.         text += f2(startX) + " " + f2(lastY) + " Td\n";
  377.         text += "(" + pdfEscape(line) + ") Tj\n";
  378.         // reset X in PDF
  379.         text += -f2(startX) + " 0 Td\n";
  381.         // After a Line, adjust y position
  382.         lastY = -(fontSize + lineSpacing);
  384.         // Reset for next iteration step
  385.         lastLength = 0;
  386.         firstWordInLine = isWithNewLine ? lastWordInLine : lastWordInLine + 1;
  387.         lineCount++;
  389.         lastLine = "";
  390.         continue Line;
  391.       }
  392.     }
  393.     break;
  394.   }
  396.   returnValue.text = text;
  397.   returnValue.fontSize = fontSize;
  399.   return returnValue;
  400. };
  402. /**
  403.  * Small workaround for calculating the TextMetric approximately.
  404.  *
  405.  * @param text
  406.  * @param fontsize
  407.  * @returns {TextMetrics} (Has Height and Width)
  408.  */
  409. var calculateFontSpace = function(text, formObject, fontSize) {
  410.   var font = formObject.scope.internal.getFont(
  411.     formObject.fontName,
  412.     formObject.fontStyle
  413.   );
  414.   var width =
  415.     formObject.scope.getStringUnitWidth(text, {
  416.       font: font,
  417.       fontSize: parseFloat(fontSize),
  418.       charSpace: 0
  419.     }) * parseFloat(fontSize);
  420.   var height =
  421.     formObject.scope.getStringUnitWidth("3", {
  422.       font: font,
  423.       fontSize: parseFloat(fontSize),
  424.       charSpace: 0
  425.     }) *
  426.     parseFloat(fontSize) *
  427.     1.5;
  428.   return { height: height, width: width };
  429. };
  431. var acroformPluginTemplate = {
  432.   fields: [],
  433.   xForms: [],
  434.   /**
  435.    * acroFormDictionaryRoot contains information about the AcroForm
  436.    * Dictionary 0: The Event-Token, the AcroFormDictionaryCallback has
  437.    * 1: The Object ID of the Root
  438.    */
  439.   acroFormDictionaryRoot: null,
  440.   /**
  441.    * After the PDF gets evaluated, the reference to the root has to be
  442.    * reset, this indicates, whether the root has already been printed
  443.    * out
  444.    */
  445.   printedOut: false,
  446.   internal: null,
  447.   isInitialized: false
  448. };
  450. var annotReferenceCallback = function(scope) {
  451.   //set objId to undefined and force it to get a new objId on buildDocument
  452.   scope.internal.acroformPlugin.acroFormDictionaryRoot.objId = undefined;
  453.   var fields = scope.internal.acroformPlugin.acroFormDictionaryRoot.Fields;
  454.   for (var i in fields) {
  455.     if (fields.hasOwnProperty(i)) {
  456.       var formObject = fields[i];
  457.       //set objId to undefined and force it to get a new objId on buildDocument
  458.       formObject.objId = undefined;
  459.       // add Annot Reference!
  460.       if (formObject.hasAnnotation) {
  461.         // If theres an Annotation Widget in the Form Object, put the
  462.         // Reference in the /Annot array
  463.         createAnnotationReference(formObject, scope);
  464.       }
  465.     }
  466.   }
  467. };
  469. var putForm = function(formObject) {
  470.   if (formObject.scope.internal.acroformPlugin.printedOut) {
  471.     formObject.scope.internal.acroformPlugin.printedOut = false;
  472.     formObject.scope.internal.acroformPlugin.acroFormDictionaryRoot = null;
  473.   }
  474.   formObject.scope.internal.acroformPlugin.acroFormDictionaryRoot.Fields.push(
  475.     formObject
  476.   );
  477. };
  478. /**
  479.  * Create the Reference to the widgetAnnotation, so that it gets referenced
  480.  * in the Annot[] int the+ (Requires the Annotation Plugin)
  481.  */
  482. var createAnnotationReference = function(object, scope) {
  483.   var options = {
  484.     type: "reference",
  485.     object: object
  486.   };
  487.   var findEntry = function(entry) {
  488.     return entry.type === options.type && entry.object === options.object;
  489.   };
  490.   if (
  491.     scope.internal
  492.       .getPageInfo(object.page)
  493.       .pageContext.annotations.find(findEntry) === undefined
  494.   ) {
  495.     scope.internal
  496.       .getPageInfo(object.page)
  497.       .pageContext.annotations.push(options);
  498.   }
  499. };
  501. // Callbacks
  503. var putCatalogCallback = function(scope) {
  504.   // Put reference to AcroForm to DocumentCatalog
  505.   if (
  506.     typeof scope.internal.acroformPlugin.acroFormDictionaryRoot !== "undefined"
  507.   ) {
  508.     // for safety, shouldn't normally be the case
  509.     scope.internal.write(
  510.       "/AcroForm " +
  511.         scope.internal.acroformPlugin.acroFormDictionaryRoot.objId +
  512.         " " +
  513.         0 +
  514.         " R"
  515.     );
  516.   } else {
  517.     throw new Error("putCatalogCallback: Root missing.");
  518.   }
  519. };
  521. /**
  522.  * Adds /Acroform X 0 R to Document Catalog, and creates the AcroForm
  523.  * Dictionary
  524.  */
  525. var AcroFormDictionaryCallback = function(scope) {
  526.   // Remove event
  527.   scope.internal.events.unsubscribe(
  528.     scope.internal.acroformPlugin.acroFormDictionaryRoot._eventID
  529.   );
  530.   delete scope.internal.acroformPlugin.acroFormDictionaryRoot._eventID;
  531.   scope.internal.acroformPlugin.printedOut = true;
  532. };
  534. /**
  535.  * Creates the single Fields and writes them into the Document
  536.  *
  537.  * If fieldArray is set, use the fields that are inside it instead of the
  538.  * fields from the AcroRoot (for the FormXObjects...)
  539.  */
  540. var createFieldCallback = function(fieldArray, scope) {
  541.   var standardFields = !fieldArray;
  543.   if (!fieldArray) {
  544.     // in case there is no fieldArray specified, we want to print out
  545.     // the Fields of the AcroForm
  546.     // Print out Root
  547.     scope.internal.newObjectDeferredBegin(
  548.       scope.internal.acroformPlugin.acroFormDictionaryRoot.objId,
  549.       true
  550.     );
  551.     scope.internal.acroformPlugin.acroFormDictionaryRoot.putStream();
  552.   }
  554.   fieldArray =
  555.     fieldArray || scope.internal.acroformPlugin.acroFormDictionaryRoot.Kids;
  557.   for (var i in fieldArray) {
  558.     if (fieldArray.hasOwnProperty(i)) {
  559.       var fieldObject = fieldArray[i];
  560.       var keyValueList = [];
  561.       var oldRect = fieldObject.Rect;
  563.       if (fieldObject.Rect) {
  564.         fieldObject.Rect = calculateCoordinates(fieldObject.Rect, scope);
  565.       }
  567.       // Start Writing the Object
  568.       scope.internal.newObjectDeferredBegin(fieldObject.objId, true);
  570.       fieldObject.DA = AcroFormAppearance.createDefaultAppearanceStream(
  571.         fieldObject
  572.       );
  574.       if (
  575.         typeof fieldObject === "object" &&
  576.         typeof fieldObject.getKeyValueListForStream === "function"
  577.       ) {
  578.         keyValueList = fieldObject.getKeyValueListForStream();
  579.       }
  581.       fieldObject.Rect = oldRect;
  583.       if (
  584.         fieldObject.hasAppearanceStream &&
  585.         !fieldObject.appearanceStreamContent
  586.       ) {
  587.         // Calculate Appearance
  588.         var appearance = calculateAppearanceStream(fieldObject);
  589.         keyValueList.push({ key: "AP", value: "<</N " + appearance + ">>" });
  591.         scope.internal.acroformPlugin.xForms.push(appearance);
  592.       }
  594.       // Assume AppearanceStreamContent is a Array with N,R,D (at least
  595.       // one of them!)
  596.       if (fieldObject.appearanceStreamContent) {
  597.         var appearanceStreamString = "";
  598.         // Iterate over N,R and D
  599.         for (var k in fieldObject.appearanceStreamContent) {
  600.           if (fieldObject.appearanceStreamContent.hasOwnProperty(k)) {
  601.             var value = fieldObject.appearanceStreamContent[k];
  602.             appearanceStreamString += "/" + k + " ";
  603.             appearanceStreamString += "<<";
  604.             if (Object.keys(value).length >= 1 || Array.isArray(value)) {
  605.               // appearanceStream is an Array or Object!
  606.               for (var i in value) {
  607.                 if (value.hasOwnProperty(i)) {
  608.                   var obj = value[i];
  609.                   if (typeof obj === "function") {
  610.                     // if Function is referenced, call it in order
  611.                     // to get the FormXObject
  612.                     obj = obj.call(scope, fieldObject);
  613.                   }
  614.                   appearanceStreamString += "/" + i + " " + obj + " ";
  616.                   // In case the XForm is already used, e.g. OffState
  617.                   // of CheckBoxes, don't add it
  618.                   if (!(scope.internal.acroformPlugin.xForms.indexOf(obj) >= 0))
  619.                     scope.internal.acroformPlugin.xForms.push(obj);
  620.                 }
  621.               }
  622.             } else {
  623.               obj = value;
  624.               if (typeof obj === "function") {
  625.                 // if Function is referenced, call it in order to
  626.                 // get the FormXObject
  627.                 obj = obj.call(scope, fieldObject);
  628.               }
  629.               appearanceStreamString += "/" + i + " " + obj;
  630.               if (!(scope.internal.acroformPlugin.xForms.indexOf(obj) >= 0))
  631.                 scope.internal.acroformPlugin.xForms.push(obj);
  632.             }
  633.             appearanceStreamString += ">>";
  634.           }
  635.         }
  637.         // appearance stream is a normal Object..
  638.         keyValueList.push({
  639.           key: "AP",
  640.           value: "<<\n" + appearanceStreamString + ">>"
  641.         });
  642.       }
  644.       scope.internal.putStream({
  645.         additionalKeyValues: keyValueList,
  646.         objectId: fieldObject.objId
  647.       });
  649.       scope.internal.out("endobj");
  650.     }
  651.   }
  652.   if (standardFields) {
  653.     createXFormObjectCallback(scope.internal.acroformPlugin.xForms, scope);
  654.   }
  655. };
  657. var createXFormObjectCallback = function(fieldArray, scope) {
  658.   for (var i in fieldArray) {
  659.     if (fieldArray.hasOwnProperty(i)) {
  660.       var key = i;
  661.       var fieldObject = fieldArray[i];
  662.       // Start Writing the Object
  663.       scope.internal.newObjectDeferredBegin(fieldObject.objId, true);
  665.       if (
  666.         typeof fieldObject === "object" &&
  667.         typeof fieldObject.putStream === "function"
  668.       ) {
  669.         fieldObject.putStream();
  670.       }
  671.       delete fieldArray[key];
  672.     }
  673.   }
  674. };
  676. var initializeAcroForm = function(scope, formObject) {
  677.   formObject.scope = scope;
  678.   if (
  679.     scope.internal !== undefined &&
  680.     (scope.internal.acroformPlugin === undefined ||
  681.       scope.internal.acroformPlugin.isInitialized === false)
  682.   ) {
  683.     AcroFormField.FieldNum = 0;
  684.     scope.internal.acroformPlugin = JSON.parse(
  685.       JSON.stringify(acroformPluginTemplate)
  686.     );
  687.     if (scope.internal.acroformPlugin.acroFormDictionaryRoot) {
  688.       throw new Error("Exception while creating AcroformDictionary");
  689.     }
  690.     scaleFactor = scope.internal.scaleFactor;
  691.     // The Object Number of the AcroForm Dictionary
  692.     scope.internal.acroformPlugin.acroFormDictionaryRoot = new AcroFormDictionary();
  693.     scope.internal.acroformPlugin.acroFormDictionaryRoot.scope = scope;
  695.     // add Callback for creating the AcroForm Dictionary
  696.     scope.internal.acroformPlugin.acroFormDictionaryRoot._eventID = scope.internal.events.subscribe(
  697.       "postPutResources",
  698.       function() {
  699.         AcroFormDictionaryCallback(scope);
  700.       }
  701.     );
  703.     scope.internal.events.subscribe("buildDocument", function() {
  704.       annotReferenceCallback(scope);
  705.     }); // buildDocument
  707.     // Register event, that is triggered when the DocumentCatalog is
  708.     // written, in order to add /AcroForm
  710.     scope.internal.events.subscribe("putCatalog", function() {
  711.       putCatalogCallback(scope);
  712.     });
  714.     // Register event, that creates all Fields
  715.     scope.internal.events.subscribe("postPutPages", function(fieldArray) {
  716.       createFieldCallback(fieldArray, scope);
  717.     });
  719.     scope.internal.acroformPlugin.isInitialized = true;
  720.   }
  721. };
  723. //PDF 32000-1:2008, page 26, 7.3.6
  724. var arrayToPdfArray = (jsPDFAPI.__acroform__.arrayToPdfArray = function(
  725.   array,
  726.   objId,
  727.   scope
  728. ) {
  729.   var encryptor = function(data) {
  730.     return data;
  731.   };
  732.   if (Array.isArray(array)) {
  733.     var content = "[";
  734.     for (var i = 0; i < array.length; i++) {
  735.       if (i !== 0) {
  736.         content += " ";
  737.       }
  738.       switch (typeof array[i]) {
  739.         case "boolean":
  740.         case "number":
  741.         case "object":
  742.           content += array[i].toString();
  743.           break;
  744.         case "string":
  745.           if (array[i].substr(0, 1) !== "/") {
  746.             if (typeof objId !== "undefined" && scope)
  747.               encryptor = scope.internal.getEncryptor(objId);
  748.             content += "(" + pdfEscape(encryptor(array[i].toString())) + ")";
  749.           } else {
  750.             content += array[i].toString();
  751.           }
  752.           break;
  753.       }
  754.     }
  755.     content += "]";
  756.     return content;
  757.   }
  758.   throw new Error(
  759.     "Invalid argument passed to jsPDF.__acroform__.arrayToPdfArray"
  760.   );
  761. });
  762. function getMatches(string, regex, index) {
  763.   index || (index = 1); // default to the first capturing group
  764.   var matches = [];
  765.   var match;
  766.   while ((match = regex.exec(string))) {
  767.     matches.push(match[index]);
  768.   }
  769.   return matches;
  770. }
  771. var pdfArrayToStringArray = function(array) {
  772.   var result = [];
  773.   if (typeof array === "string") {
  774.     result = getMatches(array, /\((.*?)\)/g);
  775.   }
  776.   return result;
  777. };
  779. var toPdfString = function(string, objId, scope) {
  780.   var encryptor = function(data) {
  781.     return data;
  782.   };
  783.   if (typeof objId !== "undefined" && scope)
  784.     encryptor = scope.internal.getEncryptor(objId);
  785.   string = string || "";
  786.   string.toString();
  787.   string = "(" + pdfEscape(encryptor(string)) + ")";
  788.   return string;
  789. };
  791. // ##########################
  792. // Classes
  793. // ##########################
  795. /**
  796.  * @class AcroFormPDFObject
  797.  * @classdesc A AcroFormPDFObject
  798.  */
  799. var AcroFormPDFObject = function() {
  800.   this._objId = undefined;
  801.   this._scope = undefined;
  803.   /**
  804.    * @name AcroFormPDFObject#objId
  805.    * @type {any}
  806.    */
  807.   Object.defineProperty(this, "objId", {
  808.     get: function() {
  809.       if (typeof this._objId === "undefined") {
  810.         if (typeof this.scope === "undefined") {
  811.           return undefined;
  812.         }
  813.         this._objId = this.scope.internal.newObjectDeferred();
  814.       }
  815.       return this._objId;
  816.     },
  817.     set: function(value) {
  818.       this._objId = value;
  819.     }
  820.   });
  821.   Object.defineProperty(this, "scope", {
  822.     value: this._scope,
  823.     writable: true
  824.   });
  825. };
  827. /**
  828.  * @function AcroFormPDFObject.toString
  829.  */
  830. AcroFormPDFObject.prototype.toString = function() {
  831.   return this.objId + " 0 R";
  832. };
  834. AcroFormPDFObject.prototype.putStream = function() {
  835.   var keyValueList = this.getKeyValueListForStream();
  836.   this.scope.internal.putStream({
  837.     data: this.stream,
  838.     additionalKeyValues: keyValueList,
  839.     objectId: this.objId
  840.   });
  841.   this.scope.internal.out("endobj");
  842. };
  844. /**
  845.  * Returns an key-value-List of all non-configurable Variables from the Object
  846.  *
  847.  * @name getKeyValueListForStream
  848.  * @returns {string}
  849.  */
  850. AcroFormPDFObject.prototype.getKeyValueListForStream = function() {
  851.   var keyValueList = [];
  852.   var keys = Object.getOwnPropertyNames(this).filter(function(key) {
  853.     return (
  854.       key != "content" &&
  855.       key != "appearanceStreamContent" &&
  856.       key != "scope" &&
  857.       key != "objId" &&
  858.       key.substring(0, 1) != "_"
  859.     );
  860.   });
  862.   for (var i in keys) {
  863.     if (Object.getOwnPropertyDescriptor(this, keys[i]).configurable === false) {
  864.       var key = keys[i];
  865.       var value = this[key];
  867.       if (value) {
  868.         if (Array.isArray(value)) {
  869.           keyValueList.push({
  870.             key: key,
  871.             value: arrayToPdfArray(value, this.objId, this.scope)
  872.           });
  873.         } else if (value instanceof AcroFormPDFObject) {
  874.           // In case it is a reference to another PDFObject,
  875.           // take the reference number
  876.           value.scope = this.scope;
  877.           keyValueList.push({ key: key, value: value.objId + " 0 R" });
  878.         } else if (typeof value !== "function") {
  879.           keyValueList.push({ key: key, value: value });
  880.         }
  881.       }
  882.     }
  883.   }
  884.   return keyValueList;
  885. };
  887. var AcroFormXObject = function() {
  888.   AcroFormPDFObject.call(this);
  890.   Object.defineProperty(this, "Type", {
  891.     value: "/XObject",
  892.     configurable: false,
  893.     writable: true
  894.   });
  896.   Object.defineProperty(this, "Subtype", {
  897.     value: "/Form",
  898.     configurable: false,
  899.     writable: true
  900.   });
  902.   Object.defineProperty(this, "FormType", {
  903.     value: 1,
  904.     configurable: false,
  905.     writable: true
  906.   });
  908.   var _BBox = [];
  909.   Object.defineProperty(this, "BBox", {
  910.     configurable: false,
  911.     get: function() {
  912.       return _BBox;
  913.     },
  914.     set: function(value) {
  915.       _BBox = value;
  916.     }
  917.   });
  919.   Object.defineProperty(this, "Resources", {
  920.     value: "2 0 R",
  921.     configurable: false,
  922.     writable: true
  923.   });
  925.   var _stream;
  926.   Object.defineProperty(this, "stream", {
  927.     enumerable: false,
  928.     configurable: true,
  929.     set: function(value) {
  930.       _stream = value.trim();
  931.     },
  932.     get: function() {
  933.       if (_stream) {
  934.         return _stream;
  935.       } else {
  936.         return null;
  937.       }
  938.     }
  939.   });
  940. };
  942. inherit(AcroFormXObject, AcroFormPDFObject);
  944. var AcroFormDictionary = function() {
  945.   AcroFormPDFObject.call(this);
  947.   var _Kids = [];
  949.   Object.defineProperty(this, "Kids", {
  950.     enumerable: false,
  951.     configurable: true,
  952.     get: function() {
  953.       if (_Kids.length > 0) {
  954.         return _Kids;
  955.       } else {
  956.         return undefined;
  957.       }
  958.     }
  959.   });
  960.   Object.defineProperty(this, "Fields", {
  961.     enumerable: false,
  962.     configurable: false,
  963.     get: function() {
  964.       return _Kids;
  965.     }
  966.   });
  968.   // Default Appearance
  969.   var _DA;
  970.   Object.defineProperty(this, "DA", {
  971.     enumerable: false,
  972.     configurable: false,
  973.     get: function() {
  974.       if (!_DA) {
  975.         return undefined;
  976.       }
  977.       var encryptor = function(data) {
  978.         return data;
  979.       };
  980.       if (this.scope) encryptor = this.scope.internal.getEncryptor(this.objId);
  981.       return "(" + pdfEscape(encryptor(_DA)) + ")";
  982.     },
  983.     set: function(value) {
  984.       _DA = value;
  985.     }
  986.   });
  987. };
  989. inherit(AcroFormDictionary, AcroFormPDFObject);
  991. /**
  992.  * The Field Object contains the Variables, that every Field needs
  993.  *
  994.  * @class AcroFormField
  995.  * @classdesc An AcroForm FieldObject
  996.  */
  997. var AcroFormField = function() {
  998.   AcroFormPDFObject.call(this);
  1000.   //Annotation-Flag See Table 165
  1001.   var _F = 4;
  1002.   Object.defineProperty(this, "F", {
  1003.     enumerable: false,
  1004.     configurable: false,
  1005.     get: function() {
  1006.       return _F;
  1007.     },
  1008.     set: function(value) {
  1009.       if (!isNaN(value)) {
  1010.         _F = value;
  1011.       } else {
  1012.         throw new Error(
  1013.           'Invalid value "' + value + '" for attribute F supplied.'
  1014.         );
  1015.       }
  1016.     }
  1017.   });
  1019.   /**
  1020.    * (PDF 1.2) If set, print the annotation when the page is printed. If clear, never print the annotation, regardless of wether is is displayed on the screen.
  1021.    * NOTE 2 This can be useful for annotations representing interactive pushbuttons, which would serve no meaningful purpose on the printed page.
  1022.    *
  1023.    * @name AcroFormField#showWhenPrinted
  1024.    * @default true
  1025.    * @type {boolean}
  1026.    */
  1027.   Object.defineProperty(this, "showWhenPrinted", {
  1028.     enumerable: true,
  1029.     configurable: true,
  1030.     get: function() {
  1031.       return Boolean(getBitForPdf(_F, 3));
  1032.     },
  1033.     set: function(value) {
  1034.       if (Boolean(value) === true) {
  1035.         this.F = setBitForPdf(_F, 3);
  1036.       } else {
  1037.         this.F = clearBitForPdf(_F, 3);
  1038.       }
  1039.     }
  1040.   });
  1042.   var _Ff = 0;
  1043.   Object.defineProperty(this, "Ff", {
  1044.     enumerable: false,
  1045.     configurable: false,
  1046.     get: function() {
  1047.       return _Ff;
  1048.     },
  1049.     set: function(value) {
  1050.       if (!isNaN(value)) {
  1051.         _Ff = value;
  1052.       } else {
  1053.         throw new Error(
  1054.           'Invalid value "' + value + '" for attribute Ff supplied.'
  1055.         );
  1056.       }
  1057.     }
  1058.   });
  1060.   var _Rect = [];
  1061.   Object.defineProperty(this, "Rect", {
  1062.     enumerable: false,
  1063.     configurable: false,
  1064.     get: function() {
  1065.       if (_Rect.length === 0) {
  1066.         return undefined;
  1067.       }
  1068.       return _Rect;
  1069.     },
  1070.     set: function(value) {
  1071.       if (typeof value !== "undefined") {
  1072.         _Rect = value;
  1073.       } else {
  1074.         _Rect = [];
  1075.       }
  1076.     }
  1077.   });
  1079.   /**
  1080.    * The x-position of the field.
  1081.    *
  1082.    * @name AcroFormField#x
  1083.    * @default null
  1084.    * @type {number}
  1085.    */
  1086.   Object.defineProperty(this, "x", {
  1087.     enumerable: true,
  1088.     configurable: true,
  1089.     get: function() {
  1090.       if (!_Rect || isNaN(_Rect[0])) {
  1091.         return 0;
  1092.       }
  1093.       return _Rect[0];
  1094.     },
  1095.     set: function(value) {
  1096.       _Rect[0] = value;
  1097.     }
  1098.   });
  1100.   /**
  1101.    * The y-position of the field.
  1102.    *
  1103.    * @name AcroFormField#y
  1104.    * @default null
  1105.    * @type {number}
  1106.    */
  1107.   Object.defineProperty(this, "y", {
  1108.     enumerable: true,
  1109.     configurable: true,
  1110.     get: function() {
  1111.       if (!_Rect || isNaN(_Rect[1])) {
  1112.         return 0;
  1113.       }
  1114.       return _Rect[1];
  1115.     },
  1116.     set: function(value) {
  1117.       _Rect[1] = value;
  1118.     }
  1119.   });
  1121.   /**
  1122.    * The width of the field.
  1123.    *
  1124.    * @name AcroFormField#width
  1125.    * @default null
  1126.    * @type {number}
  1127.    */
  1128.   Object.defineProperty(this, "width", {
  1129.     enumerable: true,
  1130.     configurable: true,
  1131.     get: function() {
  1132.       if (!_Rect || isNaN(_Rect[2])) {
  1133.         return 0;
  1134.       }
  1135.       return _Rect[2];
  1136.     },
  1137.     set: function(value) {
  1138.       _Rect[2] = value;
  1139.     }
  1140.   });
  1142.   /**
  1143.    * The height of the field.
  1144.    *
  1145.    * @name AcroFormField#height
  1146.    * @default null
  1147.    * @type {number}
  1148.    */
  1149.   Object.defineProperty(this, "height", {
  1150.     enumerable: true,
  1151.     configurable: true,
  1152.     get: function() {
  1153.       if (!_Rect || isNaN(_Rect[3])) {
  1154.         return 0;
  1155.       }
  1156.       return _Rect[3];
  1157.     },
  1158.     set: function(value) {
  1159.       _Rect[3] = value;
  1160.     }
  1161.   });
  1163.   var _FT = "";
  1164.   Object.defineProperty(this, "FT", {
  1165.     enumerable: true,
  1166.     configurable: false,
  1167.     get: function() {
  1168.       return _FT;
  1169.     },
  1170.     set: function(value) {
  1171.       switch (value) {
  1172.         case "/Btn":
  1173.         case "/Tx":
  1174.         case "/Ch":
  1175.         case "/Sig":
  1176.           _FT = value;
  1177.           break;
  1178.         default:
  1179.           throw new Error(
  1180.             'Invalid value "' + value + '" for attribute FT supplied.'
  1181.           );
  1182.       }
  1183.     }
  1184.   });
  1186.   var _T = null;
  1188.   Object.defineProperty(this, "T", {
  1189.     enumerable: true,
  1190.     configurable: false,
  1191.     get: function() {
  1192.       if (!_T || _T.length < 1) {
  1193.         // In case of a Child from a Radio´Group, you don't need a FieldName
  1194.         if (this instanceof AcroFormChildClass) {
  1195.           return undefined;
  1196.         }
  1197.         _T = "FieldObject" + AcroFormField.FieldNum++;
  1198.       }
  1199.       var encryptor = function(data) {
  1200.         return data;
  1201.       };
  1202.       if (this.scope) encryptor = this.scope.internal.getEncryptor(this.objId);
  1203.       return "(" + pdfEscape(encryptor(_T)) + ")";
  1204.     },
  1205.     set: function(value) {
  1206.       _T = value.toString();
  1207.     }
  1208.   });
  1210.   /**
  1211.    * (Optional) The partial field name (see 12.7.3.2, “Field Names”).
  1212.    *
  1213.    * @name AcroFormField#fieldName
  1214.    * @default null
  1215.    * @type {string}
  1216.    */
  1217.   Object.defineProperty(this, "fieldName", {
  1218.     configurable: true,
  1219.     enumerable: true,
  1220.     get: function() {
  1221.       return _T;
  1222.     },
  1223.     set: function(value) {
  1224.       _T = value;
  1225.     }
  1226.   });
  1228.   var _fontName = "helvetica";
  1229.   /**
  1230.    * The fontName of the font to be used.
  1231.    *
  1232.    * @name AcroFormField#fontName
  1233.    * @default 'helvetica'
  1234.    * @type {string}
  1235.    */
  1236.   Object.defineProperty(this, "fontName", {
  1237.     enumerable: true,
  1238.     configurable: true,
  1239.     get: function() {
  1240.       return _fontName;
  1241.     },
  1242.     set: function(value) {
  1243.       _fontName = value;
  1244.     }
  1245.   });
  1247.   var _fontStyle = "normal";
  1248.   /**
  1249.    * The fontStyle of the font to be used.
  1250.    *
  1251.    * @name AcroFormField#fontStyle
  1252.    * @default 'normal'
  1253.    * @type {string}
  1254.    */
  1255.   Object.defineProperty(this, "fontStyle", {
  1256.     enumerable: true,
  1257.     configurable: true,
  1258.     get: function() {
  1259.       return _fontStyle;
  1260.     },
  1261.     set: function(value) {
  1262.       _fontStyle = value;
  1263.     }
  1264.   });
  1266.   var _fontSize = 0;
  1267.   /**
  1268.    * The fontSize of the font to be used.
  1269.    *
  1270.    * @name AcroFormField#fontSize
  1271.    * @default 0 (for auto)
  1272.    * @type {number}
  1273.    */
  1274.   Object.defineProperty(this, "fontSize", {
  1275.     enumerable: true,
  1276.     configurable: true,
  1277.     get: function() {
  1278.       return _fontSize;
  1279.     },
  1280.     set: function(value) {
  1281.       _fontSize = value;
  1282.     }
  1283.   });
  1285.   var _maxFontSize = undefined;
  1286.   /**
  1287.    * The maximum fontSize of the font to be used.
  1288.    *
  1289.    * @name AcroFormField#maxFontSize
  1290.    * @default 0 (for auto)
  1291.    * @type {number}
  1292.    */
  1293.   Object.defineProperty(this, "maxFontSize", {
  1294.     enumerable: true,
  1295.     configurable: true,
  1296.     get: function() {
  1297.       if (_maxFontSize === undefined) {
  1298.         // use the old default value here - the value is some kind of random as it depends on the scaleFactor (user unit)
  1299.         // ("50" is transformed to the "user space" but then used in "pdf space")
  1300.         return 50 / scaleFactor;
  1301.       } else {
  1302.         return _maxFontSize;
  1303.       }
  1304.     },
  1305.     set: function(value) {
  1306.       _maxFontSize = value;
  1307.     }
  1308.   });
  1310.   var _color = "black";
  1311.   /**
  1312.    * The color of the text
  1313.    *
  1314.    * @name AcroFormField#color
  1315.    * @default 'black'
  1316.    * @type {string|rgba}
  1317.    */
  1318.   Object.defineProperty(this, "color", {
  1319.     enumerable: true,
  1320.     configurable: true,
  1321.     get: function() {
  1322.       return _color;
  1323.     },
  1324.     set: function(value) {
  1325.       _color = value;
  1326.     }
  1327.   });
  1329.   var _DA = "/F1 0 Tf 0 g";
  1330.   // Defines the default appearance (Needed for variable Text)
  1331.   Object.defineProperty(this, "DA", {
  1332.     enumerable: true,
  1333.     configurable: false,
  1334.     get: function() {
  1335.       if (
  1336.         !_DA ||
  1337.         this instanceof AcroFormChildClass ||
  1338.         this instanceof AcroFormTextField
  1339.       ) {
  1340.         return undefined;
  1341.       }
  1342.       return toPdfString(_DA, this.objId, this.scope);
  1343.     },
  1344.     set: function(value) {
  1345.       value = value.toString();
  1346.       _DA = value;
  1347.     }
  1348.   });
  1350.   var _DV = null;
  1351.   Object.defineProperty(this, "DV", {
  1352.     enumerable: false,
  1353.     configurable: false,
  1354.     get: function() {
  1355.       if (!_DV) {
  1356.         return undefined;
  1357.       }
  1358.       if (this instanceof AcroFormButton === false) {
  1359.         return toPdfString(_DV, this.objId, this.scope);
  1360.       }
  1361.       return _DV;
  1362.     },
  1363.     set: function(value) {
  1364.       value = value.toString();
  1365.       if (this instanceof AcroFormButton === false) {
  1366.         if (value.substr(0, 1) === "(") {
  1367.           _DV = pdfUnescape(value.substr(1, value.length - 2));
  1368.         } else {
  1369.           _DV = pdfUnescape(value);
  1370.         }
  1371.       } else {
  1372.         _DV = value;
  1373.       }
  1374.     }
  1375.   });
  1377.   /**
  1378.    * (Optional; inheritable) The default value to which the field reverts when a reset-form action is executed (see 12.7.5.3, “Reset-Form Action”). The format of this value is the same as that of value.
  1379.    *
  1380.    * @name AcroFormField#defaultValue
  1381.    * @default null
  1382.    * @type {any}
  1383.    */
  1384.   Object.defineProperty(this, "defaultValue", {
  1385.     enumerable: true,
  1386.     configurable: true,
  1387.     get: function() {
  1388.       if (this instanceof AcroFormButton === true) {
  1389.         return pdfUnescape(_DV.substr(1, _DV.length - 1));
  1390.       } else {
  1391.         return _DV;
  1392.       }
  1393.     },
  1394.     set: function(value) {
  1395.       value = value.toString();
  1396.       if (this instanceof AcroFormButton === true) {
  1397.         _DV = "/" + value;
  1398.       } else {
  1399.         _DV = value;
  1400.       }
  1401.     }
  1402.   });
  1404.   var _V = null;
  1405.   Object.defineProperty(this, "_V", {
  1406.     enumerable: false,
  1407.     configurable: false,
  1408.     get: function() {
  1409.       if (!_V) {
  1410.         return undefined;
  1411.       }
  1412.       return _V;
  1413.     },
  1414.     set: function(value) {
  1415.       this.V = value;
  1416.     }
  1417.   });
  1418.   Object.defineProperty(this, "V", {
  1419.     enumerable: false,
  1420.     configurable: false,
  1421.     get: function() {
  1422.       if (!_V) {
  1423.         return undefined;
  1424.       }
  1425.       if (this instanceof AcroFormButton === false) {
  1426.         return toPdfString(_V, this.objId, this.scope);
  1427.       }
  1428.       return _V;
  1429.     },
  1430.     set: function(value) {
  1431.       value = value.toString();
  1432.       if (this instanceof AcroFormButton === false) {
  1433.         if (value.substr(0, 1) === "(") {
  1434.           _V = pdfUnescape(value.substr(1, value.length - 2));
  1435.         } else {
  1436.           _V = pdfUnescape(value);
  1437.         }
  1438.       } else {
  1439.         _V = value;
  1440.       }
  1441.     }
  1442.   });
  1444.   /**
  1445.    * (Optional; inheritable) The field’s value, whose format varies depending on the field type. See the descriptions of individual field types for further information.
  1446.    *
  1447.    * @name AcroFormField#value
  1448.    * @default null
  1449.    * @type {any}
  1450.    */
  1451.   Object.defineProperty(this, "value", {
  1452.     enumerable: true,
  1453.     configurable: true,
  1454.     get: function() {
  1455.       if (this instanceof AcroFormButton === true) {
  1456.         return pdfUnescape(_V.substr(1, _V.length - 1));
  1457.       } else {
  1458.         return _V;
  1459.       }
  1460.     },
  1461.     set: function(value) {
  1462.       value = value.toString();
  1463.       if (this instanceof AcroFormButton === true) {
  1464.         _V = "/" + value;
  1465.       } else {
  1466.         _V = value;
  1467.       }
  1468.     }
  1469.   });
  1471.   /**
  1472.    * Check if field has annotations
  1473.    *
  1474.    * @name AcroFormField#hasAnnotation
  1475.    * @readonly
  1476.    * @type {boolean}
  1477.    */
  1478.   Object.defineProperty(this, "hasAnnotation", {
  1479.     enumerable: true,
  1480.     configurable: true,
  1481.     get: function() {
  1482.       return this.Rect;
  1483.     }
  1484.   });
  1486.   Object.defineProperty(this, "Type", {
  1487.     enumerable: true,
  1488.     configurable: false,
  1489.     get: function() {
  1490.       return this.hasAnnotation ? "/Annot" : null;
  1491.     }
  1492.   });
  1494.   Object.defineProperty(this, "Subtype", {
  1495.     enumerable: true,
  1496.     configurable: false,
  1497.     get: function() {
  1498.       return this.hasAnnotation ? "/Widget" : null;
  1499.     }
  1500.   });
  1502.   var _hasAppearanceStream = false;
  1503.   /**
  1504.    * true if field has an appearanceStream
  1505.    *
  1506.    * @name AcroFormField#hasAppearanceStream
  1507.    * @readonly
  1508.    * @type {boolean}
  1509.    */
  1510.   Object.defineProperty(this, "hasAppearanceStream", {
  1511.     enumerable: true,
  1512.     configurable: true,
  1513.     get: function() {
  1514.       return _hasAppearanceStream;
  1515.     },
  1516.     set: function(value) {
  1517.       value = Boolean(value);
  1518.       _hasAppearanceStream = value;
  1519.     }
  1520.   });
  1522.   /**
  1523.    * The page on which the AcroFormField is placed
  1524.    *
  1525.    * @name AcroFormField#page
  1526.    * @type {number}
  1527.    */
  1528.   var _page;
  1529.   Object.defineProperty(this, "page", {
  1530.     enumerable: true,
  1531.     configurable: true,
  1532.     get: function() {
  1533.       if (!_page) {
  1534.         return undefined;
  1535.       }
  1536.       return _page;
  1537.     },
  1538.     set: function(value) {
  1539.       _page = value;
  1540.     }
  1541.   });
  1543.   /**
  1544.    * If set, the user may not change the value of the field. Any associated widget annotations will not interact with the user; that is, they will not respond to mouse clicks or change their appearance in response to mouse motions. This flag is useful for fields whose values are computed or imported from a database.
  1545.    *
  1546.    * @name AcroFormField#readOnly
  1547.    * @default false
  1548.    * @type {boolean}
  1549.    */
  1550.   Object.defineProperty(this, "readOnly", {
  1551.     enumerable: true,
  1552.     configurable: true,
  1553.     get: function() {
  1554.       return Boolean(getBitForPdf(this.Ff, 1));
  1555.     },
  1556.     set: function(value) {
  1557.       if (Boolean(value) === true) {
  1558.         this.Ff = setBitForPdf(this.Ff, 1);
  1559.       } else {
  1560.         this.Ff = clearBitForPdf(this.Ff, 1);
  1561.       }
  1562.     }
  1563.   });
  1565.   /**
  1566.    * If set, the field shall have a value at the time it is exported by a submitform action (see 12.7.5.2, “Submit-Form Action”).
  1567.    *
  1568.    * @name AcroFormField#required
  1569.    * @default false
  1570.    * @type {boolean}
  1571.    */
  1572.   Object.defineProperty(this, "required", {
  1573.     enumerable: true,
  1574.     configurable: true,
  1575.     get: function() {
  1576.       return Boolean(getBitForPdf(this.Ff, 2));
  1577.     },
  1578.     set: function(value) {
  1579.       if (Boolean(value) === true) {
  1580.         this.Ff = setBitForPdf(this.Ff, 2);
  1581.       } else {
  1582.         this.Ff = clearBitForPdf(this.Ff, 2);
  1583.       }
  1584.     }
  1585.   });
  1587.   /**
  1588.    * If set, the field shall not be exported by a submit-form action (see 12.7.5.2, “Submit-Form Action”)
  1589.    *
  1590.    * @name AcroFormField#noExport
  1591.    * @default false
  1592.    * @type {boolean}
  1593.    */
  1594.   Object.defineProperty(this, "noExport", {
  1595.     enumerable: true,
  1596.     configurable: true,
  1597.     get: function() {
  1598.       return Boolean(getBitForPdf(this.Ff, 3));
  1599.     },
  1600.     set: function(value) {
  1601.       if (Boolean(value) === true) {
  1602.         this.Ff = setBitForPdf(this.Ff, 3);
  1603.       } else {
  1604.         this.Ff = clearBitForPdf(this.Ff, 3);
  1605.       }
  1606.     }
  1607.   });
  1609.   var _Q = null;
  1610.   Object.defineProperty(this, "Q", {
  1611.     enumerable: true,
  1612.     configurable: false,
  1613.     get: function() {
  1614.       if (_Q === null) {
  1615.         return undefined;
  1616.       }
  1617.       return _Q;
  1618.     },
  1619.     set: function(value) {
  1620.       if ([0, 1, 2].indexOf(value) !== -1) {
  1621.         _Q = value;
  1622.       } else {
  1623.         throw new Error(
  1624.           'Invalid value "' + value + '" for attribute Q supplied.'
  1625.         );
  1626.       }
  1627.     }
  1628.   });
  1630.   /**
  1631.    * (Optional; inheritable) A code specifying the form of quadding (justification) that shall be used in displaying the text:
  1632.    * 'left', 'center', 'right'
  1633.    *
  1634.    * @name AcroFormField#textAlign
  1635.    * @default 'left'
  1636.    * @type {string}
  1637.    */
  1638.   Object.defineProperty(this, "textAlign", {
  1639.     get: function() {
  1640.       var result;
  1641.       switch (_Q) {
  1642.         case 0:
  1643.         default:
  1644.           result = "left";
  1645.           break;
  1646.         case 1:
  1647.           result = "center";
  1648.           break;
  1649.         case 2:
  1650.           result = "right";
  1651.           break;
  1652.       }
  1653.       return result;
  1654.     },
  1655.     configurable: true,
  1656.     enumerable: true,
  1657.     set: function(value) {
  1658.       switch (value) {
  1659.         case "right":
  1660.         case 2:
  1661.           _Q = 2;
  1662.           break;
  1663.         case "center":
  1664.         case 1:
  1665.           _Q = 1;
  1666.           break;
  1667.         case "left":
  1668.         case 0:
  1669.         default:
  1670.           _Q = 0;
  1671.       }
  1672.     }
  1673.   });
  1674. };
  1676. inherit(AcroFormField, AcroFormPDFObject);
  1678. /**
  1679.  * @class AcroFormChoiceField
  1680.  * @extends AcroFormField
  1681.  */
  1682. var AcroFormChoiceField = function() {
  1683.   AcroFormField.call(this);
  1684.   // Field Type = Choice Field
  1685.   this.FT = "/Ch";
  1686.   // options
  1687.   this.V = "()";
  1689.   this.fontName = "zapfdingbats";
  1690.   // Top Index
  1691.   var _TI = 0;
  1693.   Object.defineProperty(this, "TI", {
  1694.     enumerable: true,
  1695.     configurable: false,
  1696.     get: function() {
  1697.       return _TI;
  1698.     },
  1699.     set: function(value) {
  1700.       _TI = value;
  1701.     }
  1702.   });
  1704.   /**
  1705.    * (Optional) For scrollable list boxes, the top index (the index in the Opt array of the first option visible in the list). Default value: 0.
  1706.    *
  1707.    * @name AcroFormChoiceField#topIndex
  1708.    * @default 0
  1709.    * @type {number}
  1710.    */
  1711.   Object.defineProperty(this, "topIndex", {
  1712.     enumerable: true,
  1713.     configurable: true,
  1714.     get: function() {
  1715.       return _TI;
  1716.     },
  1717.     set: function(value) {
  1718.       _TI = value;
  1719.     }
  1720.   });
  1722.   var _Opt = [];
  1723.   Object.defineProperty(this, "Opt", {
  1724.     enumerable: true,
  1725.     configurable: false,
  1726.     get: function() {
  1727.       return arrayToPdfArray(_Opt, this.objId, this.scope);
  1728.     },
  1729.     set: function(value) {
  1730.       _Opt = pdfArrayToStringArray(value);
  1731.     }
  1732.   });
  1734.   /**
  1735.    * @memberof AcroFormChoiceField
  1736.    * @name getOptions
  1737.    * @function
  1738.    * @instance
  1739.    * @returns {array} array of Options
  1740.    */
  1741.   this.getOptions = function() {
  1742.     return _Opt;
  1743.   };
  1745.   /**
  1746.    * @memberof AcroFormChoiceField
  1747.    * @name setOptions
  1748.    * @function
  1749.    * @instance
  1750.    * @param {array} value
  1751.    */
  1752.   this.setOptions = function(value) {
  1753.     _Opt = value;
  1754.     if (this.sort) {
  1755.       _Opt.sort();
  1756.     }
  1757.   };
  1759.   /**
  1760.    * @memberof AcroFormChoiceField
  1761.    * @name addOption
  1762.    * @function
  1763.    * @instance
  1764.    * @param {string} value
  1765.    */
  1766.   this.addOption = function(value) {
  1767.     value = value || "";
  1768.     value = value.toString();
  1769.     _Opt.push(value);
  1770.     if (this.sort) {
  1771.       _Opt.sort();
  1772.     }
  1773.   };
  1775.   /**
  1776.    * @memberof AcroFormChoiceField
  1777.    * @name removeOption
  1778.    * @function
  1779.    * @instance
  1780.    * @param {string} value
  1781.    * @param {boolean} allEntries (default: false)
  1782.    */
  1783.   this.removeOption = function(value, allEntries) {
  1784.     allEntries = allEntries || false;
  1785.     value = value || "";
  1786.     value = value.toString();
  1788.     while (_Opt.indexOf(value) !== -1) {
  1789.       _Opt.splice(_Opt.indexOf(value), 1);
  1790.       if (allEntries === false) {
  1791.         break;
  1792.       }
  1793.     }
  1794.   };
  1796.   /**
  1797.    * If set, the field is a combo box; if clear, the field is a list box.
  1798.    *
  1799.    * @name AcroFormChoiceField#combo
  1800.    * @default false
  1801.    * @type {boolean}
  1802.    */
  1803.   Object.defineProperty(this, "combo", {
  1804.     enumerable: true,
  1805.     configurable: true,
  1806.     get: function() {
  1807.       return Boolean(getBitForPdf(this.Ff, 18));
  1808.     },
  1809.     set: function(value) {
  1810.       if (Boolean(value) === true) {
  1811.         this.Ff = setBitForPdf(this.Ff, 18);
  1812.       } else {
  1813.         this.Ff = clearBitForPdf(this.Ff, 18);
  1814.       }
  1815.     }
  1816.   });
  1818.   /**
  1819.    * If set, the combo box shall include an editable text box as well as a drop-down list; if clear, it shall include only a drop-down list. This flag shall be used only if the Combo flag is set.
  1820.    *
  1821.    * @name AcroFormChoiceField#edit
  1822.    * @default false
  1823.    * @type {boolean}
  1824.    */
  1825.   Object.defineProperty(this, "edit", {
  1826.     enumerable: true,
  1827.     configurable: true,
  1828.     get: function() {
  1829.       return Boolean(getBitForPdf(this.Ff, 19));
  1830.     },
  1831.     set: function(value) {
  1832.       //PDF 32000-1:2008, page 444
  1833.       if (this.combo === true) {
  1834.         if (Boolean(value) === true) {
  1835.           this.Ff = setBitForPdf(this.Ff, 19);
  1836.         } else {
  1837.           this.Ff = clearBitForPdf(this.Ff, 19);
  1838.         }
  1839.       }
  1840.     }
  1841.   });
  1843.   /**
  1844.    * If set, the field’s option items shall be sorted alphabetically. This flag is intended for use by writers, not by readers. Conforming readers shall display the options in the order in which they occur in the Opt array (see Table 231).
  1845.    *
  1846.    * @name AcroFormChoiceField#sort
  1847.    * @default false
  1848.    * @type {boolean}
  1849.    */
  1850.   Object.defineProperty(this, "sort", {
  1851.     enumerable: true,
  1852.     configurable: true,
  1853.     get: function() {
  1854.       return Boolean(getBitForPdf(this.Ff, 20));
  1855.     },
  1856.     set: function(value) {
  1857.       if (Boolean(value) === true) {
  1858.         this.Ff = setBitForPdf(this.Ff, 20);
  1859.         _Opt.sort();
  1860.       } else {
  1861.         this.Ff = clearBitForPdf(this.Ff, 20);
  1862.       }
  1863.     }
  1864.   });
  1866.   /**
  1867.    * (PDF 1.4) If set, more than one of the field’s option items may be selected simultaneously; if clear, at most one item shall be selected
  1868.    *
  1869.    * @name AcroFormChoiceField#multiSelect
  1870.    * @default false
  1871.    * @type {boolean}
  1872.    */
  1873.   Object.defineProperty(this, "multiSelect", {
  1874.     enumerable: true,
  1875.     configurable: true,
  1876.     get: function() {
  1877.       return Boolean(getBitForPdf(this.Ff, 22));
  1878.     },
  1879.     set: function(value) {
  1880.       if (Boolean(value) === true) {
  1881.         this.Ff = setBitForPdf(this.Ff, 22);
  1882.       } else {
  1883.         this.Ff = clearBitForPdf(this.Ff, 22);
  1884.       }
  1885.     }
  1886.   });
  1888.   /**
  1889.    * (PDF 1.4) If set, text entered in the field shall not be spellchecked. This flag shall not be used unless the Combo and Edit flags are both set.
  1890.    *
  1891.    * @name AcroFormChoiceField#doNotSpellCheck
  1892.    * @default false
  1893.    * @type {boolean}
  1894.    */
  1895.   Object.defineProperty(this, "doNotSpellCheck", {
  1896.     enumerable: true,
  1897.     configurable: true,
  1898.     get: function() {
  1899.       return Boolean(getBitForPdf(this.Ff, 23));
  1900.     },
  1901.     set: function(value) {
  1902.       if (Boolean(value) === true) {
  1903.         this.Ff = setBitForPdf(this.Ff, 23);
  1904.       } else {
  1905.         this.Ff = clearBitForPdf(this.Ff, 23);
  1906.       }
  1907.     }
  1908.   });
  1910.   /**
  1911.    * (PDF 1.5) If set, the new value shall be committed as soon as a selection is made (commonly with the pointing device). In this case, supplying a value for a field involves three actions: selecting the field for fill-in, selecting a choice for the fill-in value, and leaving that field, which finalizes or “commits” the data choice and triggers any actions associated with the entry or changing of this data. If this flag is on, then processing does not wait for leaving the field action to occur, but immediately proceeds to the third step.
  1912.    * This option enables applications to perform an action once a selection is made, without requiring the user to exit the field. If clear, the new value is not committed until the user exits the field.
  1913.    *
  1914.    * @name AcroFormChoiceField#commitOnSelChange
  1915.    * @default false
  1916.    * @type {boolean}
  1917.    */
  1918.   Object.defineProperty(this, "commitOnSelChange", {
  1919.     enumerable: true,
  1920.     configurable: true,
  1921.     get: function() {
  1922.       return Boolean(getBitForPdf(this.Ff, 27));
  1923.     },
  1924.     set: function(value) {
  1925.       if (Boolean(value) === true) {
  1926.         this.Ff = setBitForPdf(this.Ff, 27);
  1927.       } else {
  1928.         this.Ff = clearBitForPdf(this.Ff, 27);
  1929.       }
  1930.     }
  1931.   });
  1933.   this.hasAppearanceStream = false;
  1934. };
  1935. inherit(AcroFormChoiceField, AcroFormField);
  1937. /**
  1938.  * @class AcroFormListBox
  1939.  * @extends AcroFormChoiceField
  1940.  * @extends AcroFormField
  1941.  */
  1942. var AcroFormListBox = function() {
  1943.   AcroFormChoiceField.call(this);
  1944.   this.fontName = "helvetica";
  1946.   //PDF 32000-1:2008, page 444
  1947.   this.combo = false;
  1948. };
  1949. inherit(AcroFormListBox, AcroFormChoiceField);
  1951. /**
  1952.  * @class AcroFormComboBox
  1953.  * @extends AcroFormListBox
  1954.  * @extends AcroFormChoiceField
  1955.  * @extends AcroFormField
  1956.  */
  1957. var AcroFormComboBox = function() {
  1958.   AcroFormListBox.call(this);
  1959.   this.combo = true;
  1960. };
  1961. inherit(AcroFormComboBox, AcroFormListBox);
  1963. /**
  1964.  * @class AcroFormEditBox
  1965.  * @extends AcroFormComboBox
  1966.  * @extends AcroFormListBox
  1967.  * @extends AcroFormChoiceField
  1968.  * @extends AcroFormField
  1969.  */
  1970. var AcroFormEditBox = function() {
  1971.   AcroFormComboBox.call(this);
  1972.   this.edit = true;
  1973. };
  1974. inherit(AcroFormEditBox, AcroFormComboBox);
  1976. /**
  1977.  * @class AcroFormButton
  1978.  * @extends AcroFormField
  1979.  */
  1980. var AcroFormButton = function() {
  1981.   AcroFormField.call(this);
  1982.   this.FT = "/Btn";
  1984.   /**
  1985.    * (Radio buttons only) If set, exactly one radio button shall be selected at all times; selecting the currently selected button has no effect. If clear, clicking the selected button deselects it, leaving no button selected.
  1986.    *
  1987.    * @name AcroFormButton#noToggleToOff
  1988.    * @type {boolean}
  1989.    */
  1990.   Object.defineProperty(this, "noToggleToOff", {
  1991.     enumerable: true,
  1992.     configurable: true,
  1993.     get: function() {
  1994.       return Boolean(getBitForPdf(this.Ff, 15));
  1995.     },
  1996.     set: function(value) {
  1997.       if (Boolean(value) === true) {
  1998.         this.Ff = setBitForPdf(this.Ff, 15);
  1999.       } else {
  2000.         this.Ff = clearBitForPdf(this.Ff, 15);
  2001.       }
  2002.     }
  2003.   });
  2005.   /**
  2006.    * If set, the field is a set of radio buttons; if clear, the field is a checkbox. This flag may be set only if the Pushbutton flag is clear.
  2007.    *
  2008.    * @name AcroFormButton#radio
  2009.    * @type {boolean}
  2010.    */
  2011.   Object.defineProperty(this, "radio", {
  2012.     enumerable: true,
  2013.     configurable: true,
  2014.     get: function() {
  2015.       return Boolean(getBitForPdf(this.Ff, 16));
  2016.     },
  2017.     set: function(value) {
  2018.       if (Boolean(value) === true) {
  2019.         this.Ff = setBitForPdf(this.Ff, 16);
  2020.       } else {
  2021.         this.Ff = clearBitForPdf(this.Ff, 16);
  2022.       }
  2023.     }
  2024.   });
  2026.   /**
  2027.    * If set, the field is a pushbutton that does not retain a permanent value.
  2028.    *
  2029.    * @name AcroFormButton#pushButton
  2030.    * @type {boolean}
  2031.    */
  2032.   Object.defineProperty(this, "pushButton", {
  2033.     enumerable: true,
  2034.     configurable: true,
  2035.     get: function() {
  2036.       return Boolean(getBitForPdf(this.Ff, 17));
  2037.     },
  2038.     set: function(value) {
  2039.       if (Boolean(value) === true) {
  2040.         this.Ff = setBitForPdf(this.Ff, 17);
  2041.       } else {
  2042.         this.Ff = clearBitForPdf(this.Ff, 17);
  2043.       }
  2044.     }
  2045.   });
  2047.   /**
  2048.    * (PDF 1.5) If set, a group of radio buttons within a radio button field that use the same value for the on state will turn on and off in unison; that is if one is checked, they are all checked. If clear, the buttons are mutually exclusive (the same behavior as HTML radio buttons).
  2049.    *
  2050.    * @name AcroFormButton#radioIsUnison
  2051.    * @type {boolean}
  2052.    */
  2053.   Object.defineProperty(this, "radioIsUnison", {
  2054.     enumerable: true,
  2055.     configurable: true,
  2056.     get: function() {
  2057.       return Boolean(getBitForPdf(this.Ff, 26));
  2058.     },
  2059.     set: function(value) {
  2060.       if (Boolean(value) === true) {
  2061.         this.Ff = setBitForPdf(this.Ff, 26);
  2062.       } else {
  2063.         this.Ff = clearBitForPdf(this.Ff, 26);
  2064.       }
  2065.     }
  2066.   });
  2068.   var _MK = {};
  2069.   Object.defineProperty(this, "MK", {
  2070.     enumerable: false,
  2071.     configurable: false,
  2072.     get: function() {
  2073.       var encryptor = function(data) {
  2074.         return data;
  2075.       };
  2076.       if (this.scope) encryptor = this.scope.internal.getEncryptor(this.objId);
  2077.       if (Object.keys(_MK).length !== 0) {
  2078.         var result = [];
  2079.         result.push("<<");
  2080.         var key;
  2081.         for (key in _MK) {
  2082.           result.push("/" + key + " (" + pdfEscape(encryptor(_MK[key])) + ")");
  2083.         }
  2084.         result.push(">>");
  2085.         return result.join("\n");
  2086.       }
  2087.       return undefined;
  2088.     },
  2089.     set: function(value) {
  2090.       if (typeof value === "object") {
  2091.         _MK = value;
  2092.       }
  2093.     }
  2094.   });
  2096.   /**
  2097.    * From the PDF reference:
  2098.    * (Optional, button fields only) The widget annotation's normal caption which shall be displayed when it is not interacting with the user.
  2099.    * Unlike the remaining entries listed in this Table which apply only to widget annotations associated with pushbutton fields (see Pushbuttons in 12.7.4.2, "Button Fields"), the CA entry may be used with any type of button field, including check boxes (see Check Boxes in 12.7.4.2, "Button Fields") and radio buttons (Radio Buttons in 12.7.4.2, "Button Fields").
  2100.    *
  2101.    * - '8' = Cross,
  2102.    * - 'l' =  Circle,
  2103.    * - '' = nothing
  2104.    * @name AcroFormButton#caption
  2105.    * @type {string}
  2106.    */
  2107.   Object.defineProperty(this, "caption", {
  2108.     enumerable: true,
  2109.     configurable: true,
  2110.     get: function() {
  2111.       return _MK.CA || "";
  2112.     },
  2113.     set: function(value) {
  2114.       if (typeof value === "string") {
  2115.         _MK.CA = value;
  2116.       }
  2117.     }
  2118.   });
  2120.   var _AS;
  2121.   Object.defineProperty(this, "AS", {
  2122.     enumerable: false,
  2123.     configurable: false,
  2124.     get: function() {
  2125.       return _AS;
  2126.     },
  2127.     set: function(value) {
  2128.       _AS = value;
  2129.     }
  2130.   });
  2132.   /**
  2133.    * (Required if the appearance dictionary AP contains one or more subdictionaries; PDF 1.2) The annotation's appearance state, which selects the applicable appearance stream from an appearance subdictionary (see Section 12.5.5, "Appearance Streams")
  2134.    *
  2135.    * @name AcroFormButton#appearanceState
  2136.    * @type {any}
  2137.    */
  2138.   Object.defineProperty(this, "appearanceState", {
  2139.     enumerable: true,
  2140.     configurable: true,
  2141.     get: function() {
  2142.       return _AS.substr(1, _AS.length - 1);
  2143.     },
  2144.     set: function(value) {
  2145.       _AS = "/" + value;
  2146.     }
  2147.   });
  2148. };
  2149. inherit(AcroFormButton, AcroFormField);
  2151. /**
  2152.  * @class AcroFormPushButton
  2153.  * @extends AcroFormButton
  2154.  * @extends AcroFormField
  2155.  */
  2156. var AcroFormPushButton = function() {
  2157.   AcroFormButton.call(this);
  2158.   this.pushButton = true;
  2159. };
  2160. inherit(AcroFormPushButton, AcroFormButton);
  2162. /**
  2163.  * @class AcroFormRadioButton
  2164.  * @extends AcroFormButton
  2165.  * @extends AcroFormField
  2166.  */
  2167. var AcroFormRadioButton = function() {
  2168.   AcroFormButton.call(this);
  2169.   this.radio = true;
  2170.   this.pushButton = false;
  2172.   var _Kids = [];
  2173.   Object.defineProperty(this, "Kids", {
  2174.     enumerable: true,
  2175.     configurable: false,
  2176.     get: function() {
  2177.       return _Kids;
  2178.     },
  2179.     set: function(value) {
  2180.       if (typeof value !== "undefined") {
  2181.         _Kids = value;
  2182.       } else {
  2183.         _Kids = [];
  2184.       }
  2185.     }
  2186.   });
  2187. };
  2188. inherit(AcroFormRadioButton, AcroFormButton);
  2190. /**
  2191.  * The Child class of a RadioButton (the radioGroup) -> The single Buttons
  2192.  *
  2193.  * @class AcroFormChildClass
  2194.  * @extends AcroFormField
  2195.  * @ignore
  2196.  */
  2197. var AcroFormChildClass = function() {
  2198.   AcroFormField.call(this);
  2200.   var _parent;
  2201.   Object.defineProperty(this, "Parent", {
  2202.     enumerable: false,
  2203.     configurable: false,
  2204.     get: function() {
  2205.       return _parent;
  2206.     },
  2207.     set: function(value) {
  2208.       _parent = value;
  2209.     }
  2210.   });
  2212.   var _optionName;
  2213.   Object.defineProperty(this, "optionName", {
  2214.     enumerable: false,
  2215.     configurable: true,
  2216.     get: function() {
  2217.       return _optionName;
  2218.     },
  2219.     set: function(value) {
  2220.       _optionName = value;
  2221.     }
  2222.   });
  2224.   var _MK = {};
  2225.   Object.defineProperty(this, "MK", {
  2226.     enumerable: false,
  2227.     configurable: false,
  2228.     get: function() {
  2229.       var encryptor = function(data) {
  2230.         return data;
  2231.       };
  2232.       if (this.scope) encryptor = this.scope.internal.getEncryptor(this.objId);
  2233.       var result = [];
  2234.       result.push("<<");
  2235.       var key;
  2236.       for (key in _MK) {
  2237.         result.push("/" + key + " (" + pdfEscape(encryptor(_MK[key])) + ")");
  2238.       }
  2239.       result.push(">>");
  2240.       return result.join("\n");
  2241.     },
  2242.     set: function(value) {
  2243.       if (typeof value === "object") {
  2244.         _MK = value;
  2245.       }
  2246.     }
  2247.   });
  2249.   /**
  2250.    * From the PDF reference:
  2251.    * (Optional, button fields only) The widget annotation's normal caption which shall be displayed when it is not interacting with the user.
  2252.    * Unlike the remaining entries listed in this Table which apply only to widget annotations associated with pushbutton fields (see Pushbuttons in 12.7.4.2, "Button Fields"), the CA entry may be used with any type of button field, including check boxes (see Check Boxes in 12.7.4.2, "Button Fields") and radio buttons (Radio Buttons in 12.7.4.2, "Button Fields").
  2253.    *
  2254.    * - '8' = Cross,
  2255.    * - 'l' =  Circle,
  2256.    * - '' = nothing
  2257.    * @name AcroFormButton#caption
  2258.    * @type {string}
  2259.    */
  2260.   Object.defineProperty(this, "caption", {
  2261.     enumerable: true,
  2262.     configurable: true,
  2263.     get: function() {
  2264.       return _MK.CA || "";
  2265.     },
  2266.     set: function(value) {
  2267.       if (typeof value === "string") {
  2268.         _MK.CA = value;
  2269.       }
  2270.     }
  2271.   });
  2273.   var _AS;
  2274.   Object.defineProperty(this, "AS", {
  2275.     enumerable: false,
  2276.     configurable: false,
  2277.     get: function() {
  2278.       return _AS;
  2279.     },
  2280.     set: function(value) {
  2281.       _AS = value;
  2282.     }
  2283.   });
  2285.   /**
  2286.    * (Required if the appearance dictionary AP contains one or more subdictionaries; PDF 1.2) The annotation's appearance state, which selects the applicable appearance stream from an appearance subdictionary (see Section 12.5.5, "Appearance Streams")
  2287.    *
  2288.    * @name AcroFormButton#appearanceState
  2289.    * @type {any}
  2290.    */
  2291.   Object.defineProperty(this, "appearanceState", {
  2292.     enumerable: true,
  2293.     configurable: true,
  2294.     get: function() {
  2295.       return _AS.substr(1, _AS.length - 1);
  2296.     },
  2297.     set: function(value) {
  2298.       _AS = "/" + value;
  2299.     }
  2300.   });
  2301.   this.caption = "l";
  2302.   this.appearanceState = "Off";
  2303.   // todo: set AppearanceType as variable that can be set from the
  2304.   // outside...
  2305.   this._AppearanceType = AcroFormAppearance.RadioButton.Circle;
  2306.   // The Default appearanceType is the Circle
  2307.   this.appearanceStreamContent = this._AppearanceType.createAppearanceStream(
  2308.     this.optionName
  2309.   );
  2310. };
  2311. inherit(AcroFormChildClass, AcroFormField);
  2313. AcroFormRadioButton.prototype.setAppearance = function(appearance) {
  2314.   if (!("createAppearanceStream" in appearance && "getCA" in appearance)) {
  2315.     throw new Error(
  2316.       "Couldn't assign Appearance to RadioButton. Appearance was Invalid!"
  2317.     );
  2318.   }
  2319.   for (var objId in this.Kids) {
  2320.     if (this.Kids.hasOwnProperty(objId)) {
  2321.       var child = this.Kids[objId];
  2322.       child.appearanceStreamContent = appearance.createAppearanceStream(
  2323.         child.optionName
  2324.       );
  2325.       child.caption = appearance.getCA();
  2326.     }
  2327.   }
  2328. };
  2330. AcroFormRadioButton.prototype.createOption = function(name) {
  2331.   // Create new Child for RadioGroup
  2332.   var child = new AcroFormChildClass();
  2333.   child.Parent = this;
  2334.   child.optionName = name;
  2335.   // Add to Parent
  2336.   this.Kids.push(child);
  2338.   addField.call(this.scope, child);
  2340.   return child;
  2341. };
  2343. /**
  2344.  * @class AcroFormCheckBox
  2345.  * @extends AcroFormButton
  2346.  * @extends AcroFormField
  2347.  */
  2348. var AcroFormCheckBox = function() {
  2349.   AcroFormButton.call(this);
  2351.   this.fontName = "zapfdingbats";
  2352.   this.caption = "3";
  2353.   this.appearanceState = "On";
  2354.   this.value = "On";
  2355.   this.textAlign = "center";
  2356.   this.appearanceStreamContent = AcroFormAppearance.CheckBox.createAppearanceStream();
  2357. };
  2358. inherit(AcroFormCheckBox, AcroFormButton);
  2360. /**
  2361.  * @class AcroFormTextField
  2362.  * @extends AcroFormField
  2363.  */
  2364. var AcroFormTextField = function() {
  2365.   AcroFormField.call(this);
  2366.   this.FT = "/Tx";
  2368.   /**
  2369.    * If set, the field may contain multiple lines of text; if clear, the field’s text shall be restricted to a single line.
  2370.    *
  2371.    * @name AcroFormTextField#multiline
  2372.    * @type {boolean}
  2373.    */
  2374.   Object.defineProperty(this, "multiline", {
  2375.     enumerable: true,
  2376.     configurable: true,
  2377.     get: function() {
  2378.       return Boolean(getBitForPdf(this.Ff, 13));
  2379.     },
  2380.     set: function(value) {
  2381.       if (Boolean(value) === true) {
  2382.         this.Ff = setBitForPdf(this.Ff, 13);
  2383.       } else {
  2384.         this.Ff = clearBitForPdf(this.Ff, 13);
  2385.       }
  2386.     }
  2387.   });
  2389.   /**
  2390.    * (PDF 1.4) If set, the text entered in the field represents the pathname of a file whose contents shall be submitted as the value of the field.
  2391.    *
  2392.    * @name AcroFormTextField#fileSelect
  2393.    * @type {boolean}
  2394.    */
  2395.   Object.defineProperty(this, "fileSelect", {
  2396.     enumerable: true,
  2397.     configurable: true,
  2398.     get: function() {
  2399.       return Boolean(getBitForPdf(this.Ff, 21));
  2400.     },
  2401.     set: function(value) {
  2402.       if (Boolean(value) === true) {
  2403.         this.Ff = setBitForPdf(this.Ff, 21);
  2404.       } else {
  2405.         this.Ff = clearBitForPdf(this.Ff, 21);
  2406.       }
  2407.     }
  2408.   });
  2410.   /**
  2411.    * (PDF 1.4) If set, text entered in the field shall not be spell-checked.
  2412.    *
  2413.    * @name AcroFormTextField#doNotSpellCheck
  2414.    * @type {boolean}
  2415.    */
  2416.   Object.defineProperty(this, "doNotSpellCheck", {
  2417.     enumerable: true,
  2418.     configurable: true,
  2419.     get: function() {
  2420.       return Boolean(getBitForPdf(this.Ff, 23));
  2421.     },
  2422.     set: function(value) {
  2423.       if (Boolean(value) === true) {
  2424.         this.Ff = setBitForPdf(this.Ff, 23);
  2425.       } else {
  2426.         this.Ff = clearBitForPdf(this.Ff, 23);
  2427.       }
  2428.     }
  2429.   });
  2431.   /**
  2432.    * (PDF 1.4) If set, the field shall not scroll (horizontally for single-line fields, vertically for multiple-line fields) to accommodate more text than fits within its annotation rectangle. Once the field is full, no further text shall be accepted for interactive form filling; for noninteractive form filling, the filler should take care not to add more character than will visibly fit in the defined area.
  2433.    *
  2434.    * @name AcroFormTextField#doNotScroll
  2435.    * @type {boolean}
  2436.    */
  2437.   Object.defineProperty(this, "doNotScroll", {
  2438.     enumerable: true,
  2439.     configurable: true,
  2440.     get: function() {
  2441.       return Boolean(getBitForPdf(this.Ff, 24));
  2442.     },
  2443.     set: function(value) {
  2444.       if (Boolean(value) === true) {
  2445.         this.Ff = setBitForPdf(this.Ff, 24);
  2446.       } else {
  2447.         this.Ff = clearBitForPdf(this.Ff, 24);
  2448.       }
  2449.     }
  2450.   });
  2452.   /**
  2453.    * (PDF 1.5) May be set only if the MaxLen entry is present in the text field dictionary (see Table 229) and if the Multiline, Password, and FileSelect flags are clear. If set, the field shall be automatically divided into as many equally spaced positions, or combs, as the value of MaxLen, and the text is laid out into those combs.
  2454.    *
  2455.    * @name AcroFormTextField#comb
  2456.    * @type {boolean}
  2457.    */
  2458.   Object.defineProperty(this, "comb", {
  2459.     enumerable: true,
  2460.     configurable: true,
  2461.     get: function() {
  2462.       return Boolean(getBitForPdf(this.Ff, 25));
  2463.     },
  2464.     set: function(value) {
  2465.       if (Boolean(value) === true) {
  2466.         this.Ff = setBitForPdf(this.Ff, 25);
  2467.       } else {
  2468.         this.Ff = clearBitForPdf(this.Ff, 25);
  2469.       }
  2470.     }
  2471.   });
  2473.   /**
  2474.    * (PDF 1.5) If set, the value of this field shall be a rich text string (see 12.7.3.4, “Rich Text Strings”). If the field has a value, the RV entry of the field dictionary (Table 222) shall specify the rich text string.
  2475.    *
  2476.    * @name AcroFormTextField#richText
  2477.    * @type {boolean}
  2478.    */
  2479.   Object.defineProperty(this, "richText", {
  2480.     enumerable: true,
  2481.     configurable: true,
  2482.     get: function() {
  2483.       return Boolean(getBitForPdf(this.Ff, 26));
  2484.     },
  2485.     set: function(value) {
  2486.       if (Boolean(value) === true) {
  2487.         this.Ff = setBitForPdf(this.Ff, 26);
  2488.       } else {
  2489.         this.Ff = clearBitForPdf(this.Ff, 26);
  2490.       }
  2491.     }
  2492.   });
  2494.   var _MaxLen = null;
  2495.   Object.defineProperty(this, "MaxLen", {
  2496.     enumerable: true,
  2497.     configurable: false,
  2498.     get: function() {
  2499.       return _MaxLen;
  2500.     },
  2501.     set: function(value) {
  2502.       _MaxLen = value;
  2503.     }
  2504.   });
  2506.   /**
  2507.    * (Optional; inheritable) The maximum length of the field’s text, in characters.
  2508.    *
  2509.    * @name AcroFormTextField#maxLength
  2510.    * @type {number}
  2511.    */
  2512.   Object.defineProperty(this, "maxLength", {
  2513.     enumerable: true,
  2514.     configurable: true,
  2515.     get: function() {
  2516.       return _MaxLen;
  2517.     },
  2518.     set: function(value) {
  2519.       if (Number.isInteger(value)) {
  2520.         _MaxLen = value;
  2521.       }
  2522.     }
  2523.   });
  2525.   Object.defineProperty(this, "hasAppearanceStream", {
  2526.     enumerable: true,
  2527.     configurable: true,
  2528.     get: function() {
  2529.       return this.V || this.DV;
  2530.     }
  2531.   });
  2532. };
  2533. inherit(AcroFormTextField, AcroFormField);
  2535. /**
  2536.  * @class AcroFormPasswordField
  2537.  * @extends AcroFormTextField
  2538.  * @extends AcroFormField
  2539.  */
  2540. var AcroFormPasswordField = function() {
  2541.   AcroFormTextField.call(this);
  2543.   /**
  2544.    * If set, the field is intended for entering a secure password that should not be echoed visibly to the screen. Characters typed from the keyboard shall instead be echoed in some unreadable form, such as asterisks or bullet characters.
  2545.    * NOTE To protect password confidentiality, readers should never store the value of the text field in the PDF file if this flag is set.
  2546.    *
  2547.    * @name AcroFormTextField#password
  2548.    * @type {boolean}
  2549.    */
  2550.   Object.defineProperty(this, "password", {
  2551.     enumerable: true,
  2552.     configurable: true,
  2553.     get: function() {
  2554.       return Boolean(getBitForPdf(this.Ff, 14));
  2555.     },
  2556.     set: function(value) {
  2557.       if (Boolean(value) === true) {
  2558.         this.Ff = setBitForPdf(this.Ff, 14);
  2559.       } else {
  2560.         this.Ff = clearBitForPdf(this.Ff, 14);
  2561.       }
  2562.     }
  2563.   });
  2564.   this.password = true;
  2565. };
  2566. inherit(AcroFormPasswordField, AcroFormTextField);
  2568. // Contains Methods for creating standard appearances
  2569. var AcroFormAppearance = {
  2570.   CheckBox: {
  2571.     createAppearanceStream: function() {
  2572.       var appearance = {
  2573.         N: {
  2574.           On: AcroFormAppearance.CheckBox.YesNormal
  2575.         },
  2576.         D: {
  2577.           On: AcroFormAppearance.CheckBox.YesPushDown,
  2578.           Off: AcroFormAppearance.CheckBox.OffPushDown
  2579.         }
  2580.       };
  2582.       return appearance;
  2583.     },
  2584.     /**
  2585.      * Returns the standard On Appearance for a CheckBox
  2586.      *
  2587.      * @returns {AcroFormXObject}
  2588.      */
  2589.     YesPushDown: function(formObject) {
  2590.       var xobj = createFormXObject(formObject);
  2591.       xobj.scope = formObject.scope;
  2592.       var stream = [];
  2593.       var fontKey = formObject.scope.internal.getFont(
  2594.         formObject.fontName,
  2595.         formObject.fontStyle
  2596.       ).id;
  2597.       var encodedColor = formObject.scope.__private__.encodeColorString(
  2598.         formObject.color
  2599.       );
  2600.       var calcRes = calculateX(formObject, formObject.caption);
  2601.       stream.push("0.749023 g");
  2602.       stream.push(
  2603.         "0 0 " +
  2604.           f2(AcroFormAppearance.internal.getWidth(formObject)) +
  2605.           " " +
  2606.           f2(AcroFormAppearance.internal.getHeight(formObject)) +
  2607.           " re"
  2608.       );
  2609.       stream.push("f");
  2610.       stream.push("BMC");
  2611.       stream.push("q");
  2612.       stream.push("0 0 1 rg");
  2613.       stream.push(
  2614.         "/" + fontKey + " " + f2(calcRes.fontSize) + " Tf " + encodedColor
  2615.       );
  2616.       stream.push("BT");
  2617.       stream.push(calcRes.text);
  2618.       stream.push("ET");
  2619.       stream.push("Q");
  2620.       stream.push("EMC");
  2621.       xobj.stream = stream.join("\n");
  2622.       return xobj;
  2623.     },
  2625.     YesNormal: function(formObject) {
  2626.       var xobj = createFormXObject(formObject);
  2627.       xobj.scope = formObject.scope;
  2628.       var fontKey = formObject.scope.internal.getFont(
  2629.         formObject.fontName,
  2630.         formObject.fontStyle
  2631.       ).id;
  2632.       var encodedColor = formObject.scope.__private__.encodeColorString(
  2633.         formObject.color
  2634.       );
  2635.       var stream = [];
  2636.       var height = AcroFormAppearance.internal.getHeight(formObject);
  2637.       var width = AcroFormAppearance.internal.getWidth(formObject);
  2638.       var calcRes = calculateX(formObject, formObject.caption);
  2639.       stream.push("1 g");
  2640.       stream.push("0 0 " + f2(width) + " " + f2(height) + " re");
  2641.       stream.push("f");
  2642.       stream.push("q");
  2643.       stream.push("0 0 1 rg");
  2644.       stream.push("0 0 " + f2(width - 1) + " " + f2(height - 1) + " re");
  2645.       stream.push("W");
  2646.       stream.push("n");
  2647.       stream.push("0 g");
  2648.       stream.push("BT");
  2649.       stream.push(
  2650.         "/" + fontKey + " " + f2(calcRes.fontSize) + " Tf " + encodedColor
  2651.       );
  2652.       stream.push(calcRes.text);
  2653.       stream.push("ET");
  2654.       stream.push("Q");
  2655.       xobj.stream = stream.join("\n");
  2656.       return xobj;
  2657.     },
  2659.     /**
  2660.      * Returns the standard Off Appearance for a CheckBox
  2661.      *
  2662.      * @returns {AcroFormXObject}
  2663.      */
  2664.     OffPushDown: function(formObject) {
  2665.       var xobj = createFormXObject(formObject);
  2666.       xobj.scope = formObject.scope;
  2667.       var stream = [];
  2668.       stream.push("0.749023 g");
  2669.       stream.push(
  2670.         "0 0 " +
  2671.           f2(AcroFormAppearance.internal.getWidth(formObject)) +
  2672.           " " +
  2673.           f2(AcroFormAppearance.internal.getHeight(formObject)) +
  2674.           " re"
  2675.       );
  2676.       stream.push("f");
  2677.       xobj.stream = stream.join("\n");
  2678.       return xobj;
  2679.     }
  2680.   },
  2682.   RadioButton: {
  2683.     Circle: {
  2684.       createAppearanceStream: function(name) {
  2685.         var appearanceStreamContent = {
  2686.           D: {
  2687.             Off: AcroFormAppearance.RadioButton.Circle.OffPushDown
  2688.           },
  2689.           N: {}
  2690.         };
  2691.         appearanceStreamContent.N[name] =
  2692.           AcroFormAppearance.RadioButton.Circle.YesNormal;
  2693.         appearanceStreamContent.D[name] =
  2694.           AcroFormAppearance.RadioButton.Circle.YesPushDown;
  2695.         return appearanceStreamContent;
  2696.       },
  2697.       getCA: function() {
  2698.         return "l";
  2699.       },
  2701.       YesNormal: function(formObject) {
  2702.         var xobj = createFormXObject(formObject);
  2703.         xobj.scope = formObject.scope;
  2704.         var stream = [];
  2705.         // Make the Radius of the Circle relative to min(height, width) of formObject
  2706.         var DotRadius =
  2707.           AcroFormAppearance.internal.getWidth(formObject) <=
  2708.           AcroFormAppearance.internal.getHeight(formObject)
  2709.             ? AcroFormAppearance.internal.getWidth(formObject) / 4
  2710.             : AcroFormAppearance.internal.getHeight(formObject) / 4;
  2711.         // The Borderpadding...
  2712.         DotRadius = Number((DotRadius * 0.9).toFixed(5));
  2713.         var c = AcroFormAppearance.internal.Bezier_C;
  2714.         var DotRadiusBezier = Number((DotRadius * c).toFixed(5));
  2715.         /*
  2716.          * The Following is a Circle created with Bezier-Curves.
  2717.          */
  2718.         stream.push("q");
  2719.         stream.push(
  2720.           "1 0 0 1 " +
  2721.             f5(AcroFormAppearance.internal.getWidth(formObject) / 2) +
  2722.             " " +
  2723.             f5(AcroFormAppearance.internal.getHeight(formObject) / 2) +
  2724.             " cm"
  2725.         );
  2726.         stream.push(DotRadius + " 0 m");
  2727.         stream.push(
  2728.           DotRadius +
  2729.             " " +
  2730.             DotRadiusBezier +
  2731.             " " +
  2732.             DotRadiusBezier +
  2733.             " " +
  2734.             DotRadius +
  2735.             " 0 " +
  2736.             DotRadius +
  2737.             " c"
  2738.         );
  2739.         stream.push(
  2740.           "-" +
  2741.             DotRadiusBezier +
  2742.             " " +
  2743.             DotRadius +
  2744.             " -" +
  2745.             DotRadius +
  2746.             " " +
  2747.             DotRadiusBezier +
  2748.             " -" +
  2749.             DotRadius +
  2750.             " 0 c"
  2751.         );
  2752.         stream.push(
  2753.           "-" +
  2754.             DotRadius +
  2755.             " -" +
  2756.             DotRadiusBezier +
  2757.             " -" +
  2758.             DotRadiusBezier +
  2759.             " -" +
  2760.             DotRadius +
  2761.             " 0 -" +
  2762.             DotRadius +
  2763.             " c"
  2764.         );
  2765.         stream.push(
  2766.           DotRadiusBezier +
  2767.             " -" +
  2768.             DotRadius +
  2769.             " " +
  2770.             DotRadius +
  2771.             " -" +
  2772.             DotRadiusBezier +
  2773.             " " +
  2774.             DotRadius +
  2775.             " 0 c"
  2776.         );
  2777.         stream.push("f");
  2778.         stream.push("Q");
  2779.         xobj.stream = stream.join("\n");
  2780.         return xobj;
  2781.       },
  2782.       YesPushDown: function(formObject) {
  2783.         var xobj = createFormXObject(formObject);
  2784.         xobj.scope = formObject.scope;
  2785.         var stream = [];
  2786.         var DotRadius =
  2787.           AcroFormAppearance.internal.getWidth(formObject) <=
  2788.           AcroFormAppearance.internal.getHeight(formObject)
  2789.             ? AcroFormAppearance.internal.getWidth(formObject) / 4
  2790.             : AcroFormAppearance.internal.getHeight(formObject) / 4;
  2791.         // The Borderpadding...
  2792.         DotRadius = Number((DotRadius * 0.9).toFixed(5));
  2793.         // Save results for later use; no need to waste
  2794.         // processor ticks on doing math
  2795.         var k = Number((DotRadius * 2).toFixed(5));
  2796.         var kc = Number((k * AcroFormAppearance.internal.Bezier_C).toFixed(5));
  2797.         var dc = Number(
  2798.           (DotRadius * AcroFormAppearance.internal.Bezier_C).toFixed(5)
  2799.         );
  2801.         stream.push("0.749023 g");
  2802.         stream.push("q");
  2803.         stream.push(
  2804.           "1 0 0 1 " +
  2805.             f5(AcroFormAppearance.internal.getWidth(formObject) / 2) +
  2806.             " " +
  2807.             f5(AcroFormAppearance.internal.getHeight(formObject) / 2) +
  2808.             " cm"
  2809.         );
  2810.         stream.push(k + " 0 m");
  2811.         stream.push(k + " " + kc + " " + kc + " " + k + " 0 " + k + " c");
  2812.         stream.push(
  2813.           "-" + kc + " " + k + " -" + k + " " + kc + " -" + k + " 0 c"
  2814.         );
  2815.         stream.push(
  2816.           "-" + k + " -" + kc + " -" + kc + " -" + k + " 0 -" + k + " c"
  2817.         );
  2818.         stream.push(kc + " -" + k + " " + k + " -" + kc + " " + k + " 0 c");
  2819.         stream.push("f");
  2820.         stream.push("Q");
  2821.         stream.push("0 g");
  2822.         stream.push("q");
  2823.         stream.push(
  2824.           "1 0 0 1 " +
  2825.             f5(AcroFormAppearance.internal.getWidth(formObject) / 2) +
  2826.             " " +
  2827.             f5(AcroFormAppearance.internal.getHeight(formObject) / 2) +
  2828.             " cm"
  2829.         );
  2830.         stream.push(DotRadius + " 0 m");
  2831.         stream.push(
  2832.           "" +
  2833.             DotRadius +
  2834.             " " +
  2835.             dc +
  2836.             " " +
  2837.             dc +
  2838.             " " +
  2839.             DotRadius +
  2840.             " 0 " +
  2841.             DotRadius +
  2842.             " c"
  2843.         );
  2844.         stream.push(
  2845.           "-" +
  2846.             dc +
  2847.             " " +
  2848.             DotRadius +
  2849.             " -" +
  2850.             DotRadius +
  2851.             " " +
  2852.             dc +
  2853.             " -" +
  2854.             DotRadius +
  2855.             " 0 c"
  2856.         );
  2857.         stream.push(
  2858.           "-" +
  2859.             DotRadius +
  2860.             " -" +
  2861.             dc +
  2862.             " -" +
  2863.             dc +
  2864.             " -" +
  2865.             DotRadius +
  2866.             " 0 -" +
  2867.             DotRadius +
  2868.             " c"
  2869.         );
  2870.         stream.push(
  2871.           dc +
  2872.             " -" +
  2873.             DotRadius +
  2874.             " " +
  2875.             DotRadius +
  2876.             " -" +
  2877.             dc +
  2878.             " " +
  2879.             DotRadius +
  2880.             " 0 c"
  2881.         );
  2882.         stream.push("f");
  2883.         stream.push("Q");
  2884.         xobj.stream = stream.join("\n");
  2885.         return xobj;
  2886.       },
  2887.       OffPushDown: function(formObject) {
  2888.         var xobj = createFormXObject(formObject);
  2889.         xobj.scope = formObject.scope;
  2890.         var stream = [];
  2891.         var DotRadius =
  2892.           AcroFormAppearance.internal.getWidth(formObject) <=
  2893.           AcroFormAppearance.internal.getHeight(formObject)
  2894.             ? AcroFormAppearance.internal.getWidth(formObject) / 4
  2895.             : AcroFormAppearance.internal.getHeight(formObject) / 4;
  2896.         // The Borderpadding...
  2897.         DotRadius = Number((DotRadius * 0.9).toFixed(5));
  2898.         // Save results for later use; no need to waste
  2899.         // processor ticks on doing math
  2900.         var k = Number((DotRadius * 2).toFixed(5));
  2901.         var kc = Number((k * AcroFormAppearance.internal.Bezier_C).toFixed(5));
  2903.         stream.push("0.749023 g");
  2904.         stream.push("q");
  2905.         stream.push(
  2906.           "1 0 0 1 " +
  2907.             f5(AcroFormAppearance.internal.getWidth(formObject) / 2) +
  2908.             " " +
  2909.             f5(AcroFormAppearance.internal.getHeight(formObject) / 2) +
  2910.             " cm"
  2911.         );
  2912.         stream.push(k + " 0 m");
  2913.         stream.push(k + " " + kc + " " + kc + " " + k + " 0 " + k + " c");
  2914.         stream.push(
  2915.           "-" + kc + " " + k + " -" + k + " " + kc + " -" + k + " 0 c"
  2916.         );
  2917.         stream.push(
  2918.           "-" + k + " -" + kc + " -" + kc + " -" + k + " 0 -" + k + " c"
  2919.         );
  2920.         stream.push(kc + " -" + k + " " + k + " -" + kc + " " + k + " 0 c");
  2921.         stream.push("f");
  2922.         stream.push("Q");
  2923.         xobj.stream = stream.join("\n");
  2924.         return xobj;
  2925.       }
  2926.     },
  2928.     Cross: {
  2929.       /**
  2930.        * Creates the Actual AppearanceDictionary-References
  2931.        *
  2932.        * @param {string} name
  2933.        * @returns {Object}
  2934.        * @ignore
  2935.        */
  2936.       createAppearanceStream: function(name) {
  2937.         var appearanceStreamContent = {
  2938.           D: {
  2939.             Off: AcroFormAppearance.RadioButton.Cross.OffPushDown
  2940.           },
  2941.           N: {}
  2942.         };
  2943.         appearanceStreamContent.N[name] =
  2944.           AcroFormAppearance.RadioButton.Cross.YesNormal;
  2945.         appearanceStreamContent.D[name] =
  2946.           AcroFormAppearance.RadioButton.Cross.YesPushDown;
  2947.         return appearanceStreamContent;
  2948.       },
  2949.       getCA: function() {
  2950.         return "8";
  2951.       },
  2953.       YesNormal: function(formObject) {
  2954.         var xobj = createFormXObject(formObject);
  2955.         xobj.scope = formObject.scope;
  2956.         var stream = [];
  2957.         var cross = AcroFormAppearance.internal.calculateCross(formObject);
  2958.         stream.push("q");
  2959.         stream.push(
  2960.           "1 1 " +
  2961.             f2(AcroFormAppearance.internal.getWidth(formObject) - 2) +
  2962.             " " +
  2963.             f2(AcroFormAppearance.internal.getHeight(formObject) - 2) +
  2964.             " re"
  2965.         );
  2966.         stream.push("W");
  2967.         stream.push("n");
  2968.         stream.push(f2(cross.x1.x) + " " + f2(cross.x1.y) + " m");
  2969.         stream.push(f2(cross.x2.x) + " " + f2(cross.x2.y) + " l");
  2970.         stream.push(f2(cross.x4.x) + " " + f2(cross.x4.y) + " m");
  2971.         stream.push(f2(cross.x3.x) + " " + f2(cross.x3.y) + " l");
  2972.         stream.push("s");
  2973.         stream.push("Q");
  2974.         xobj.stream = stream.join("\n");
  2975.         return xobj;
  2976.       },
  2977.       YesPushDown: function(formObject) {
  2978.         var xobj = createFormXObject(formObject);
  2979.         xobj.scope = formObject.scope;
  2980.         var cross = AcroFormAppearance.internal.calculateCross(formObject);
  2981.         var stream = [];
  2982.         stream.push("0.749023 g");
  2983.         stream.push(
  2984.           "0 0 " +
  2985.             f2(AcroFormAppearance.internal.getWidth(formObject)) +
  2986.             " " +
  2987.             f2(AcroFormAppearance.internal.getHeight(formObject)) +
  2988.             " re"
  2989.         );
  2990.         stream.push("f");
  2991.         stream.push("q");
  2992.         stream.push(
  2993.           "1 1 " +
  2994.             f2(AcroFormAppearance.internal.getWidth(formObject) - 2) +
  2995.             " " +
  2996.             f2(AcroFormAppearance.internal.getHeight(formObject) - 2) +
  2997.             " re"
  2998.         );
  2999.         stream.push("W");
  3000.         stream.push("n");
  3001.         stream.push(f2(cross.x1.x) + " " + f2(cross.x1.y) + " m");
  3002.         stream.push(f2(cross.x2.x) + " " + f2(cross.x2.y) + " l");
  3003.         stream.push(f2(cross.x4.x) + " " + f2(cross.x4.y) + " m");
  3004.         stream.push(f2(cross.x3.x) + " " + f2(cross.x3.y) + " l");
  3005.         stream.push("s");
  3006.         stream.push("Q");
  3007.         xobj.stream = stream.join("\n");
  3008.         return xobj;
  3009.       },
  3010.       OffPushDown: function(formObject) {
  3011.         var xobj = createFormXObject(formObject);
  3012.         xobj.scope = formObject.scope;
  3013.         var stream = [];
  3014.         stream.push("0.749023 g");
  3015.         stream.push(
  3016.           "0 0 " +
  3017.             f2(AcroFormAppearance.internal.getWidth(formObject)) +
  3018.             " " +
  3019.             f2(AcroFormAppearance.internal.getHeight(formObject)) +
  3020.             " re"
  3021.         );
  3022.         stream.push("f");
  3023.         xobj.stream = stream.join("\n");
  3024.         return xobj;
  3025.       }
  3026.     }
  3027.   },
  3029.   /**
  3030.    * Returns the standard Appearance
  3031.    *
  3032.    * @returns {AcroFormXObject}
  3033.    */
  3034.   createDefaultAppearanceStream: function(formObject) {
  3035.     // Set Helvetica to Standard Font (size: auto)
  3036.     // Color: Black
  3037.     var fontKey = formObject.scope.internal.getFont(
  3038.       formObject.fontName,
  3039.       formObject.fontStyle
  3040.     ).id;
  3041.     var encodedColor = formObject.scope.__private__.encodeColorString(
  3042.       formObject.color
  3043.     );
  3044.     var fontSize = formObject.fontSize;
  3045.     var result = "/" + fontKey + " " + fontSize + " Tf " + encodedColor;
  3046.     return result;
  3047.   }
  3048. };
  3050. AcroFormAppearance.internal = {
  3051.   Bezier_C: 0.551915024494,
  3053.   calculateCross: function(formObject) {
  3054.     var width = AcroFormAppearance.internal.getWidth(formObject);
  3055.     var height = AcroFormAppearance.internal.getHeight(formObject);
  3056.     var a = Math.min(width, height);
  3058.     var cross = {
  3059.       x1: {
  3060.         // upperLeft
  3061.         x: (width - a) / 2,
  3062.         y: (height - a) / 2 + a // height - borderPadding
  3063.       },
  3064.       x2: {
  3065.         // lowerRight
  3066.         x: (width - a) / 2 + a,
  3067.         y: (height - a) / 2 // borderPadding
  3068.       },
  3069.       x3: {
  3070.         // lowerLeft
  3071.         x: (width - a) / 2,
  3072.         y: (height - a) / 2 // borderPadding
  3073.       },
  3074.       x4: {
  3075.         // upperRight
  3076.         x: (width - a) / 2 + a,
  3077.         y: (height - a) / 2 + a // height - borderPadding
  3078.       }
  3079.     };
  3081.     return cross;
  3082.   }
  3083. };
  3084. AcroFormAppearance.internal.getWidth = function(formObject) {
  3085.   var result = 0;
  3086.   if (typeof formObject === "object") {
  3087.     result = scale(formObject.Rect[2]);
  3088.   }
  3089.   return result;
  3090. };
  3091. AcroFormAppearance.internal.getHeight = function(formObject) {
  3092.   var result = 0;
  3093.   if (typeof formObject === "object") {
  3094.     result = scale(formObject.Rect[3]);
  3095.   }
  3096.   return result;
  3097. };
  3099. // Public:
  3101. /**
  3102.  * Add an AcroForm-Field to the jsPDF-instance
  3103.  *
  3104.  * @name addField
  3105.  * @function
  3106.  * @instance
  3107.  * @param {Object} fieldObject
  3108.  * @returns {jsPDF}
  3109.  */
  3110. var addField = (jsPDFAPI.addField = function(fieldObject) {
  3111.   initializeAcroForm(this, fieldObject);
  3113.   if (fieldObject instanceof AcroFormField) {
  3114.     putForm(fieldObject);
  3115.   } else {
  3116.     throw new Error("Invalid argument passed to jsPDF.addField.");
  3117.   }
  3118.   fieldObject.page = fieldObject.scope.internal.getCurrentPageInfo().pageNumber;
  3119.   return this;
  3120. });
  3122. jsPDFAPI.AcroFormChoiceField = AcroFormChoiceField;
  3123. jsPDFAPI.AcroFormListBox = AcroFormListBox;
  3124. jsPDFAPI.AcroFormComboBox = AcroFormComboBox;
  3125. jsPDFAPI.AcroFormEditBox = AcroFormEditBox;
  3126. jsPDFAPI.AcroFormButton = AcroFormButton;
  3127. jsPDFAPI.AcroFormPushButton = AcroFormPushButton;
  3128. jsPDFAPI.AcroFormRadioButton = AcroFormRadioButton;
  3129. jsPDFAPI.AcroFormCheckBox = AcroFormCheckBox;
  3130. jsPDFAPI.AcroFormTextField = AcroFormTextField;
  3131. jsPDFAPI.AcroFormPasswordField = AcroFormPasswordField;
  3132. jsPDFAPI.AcroFormAppearance = AcroFormAppearance;
  3134. jsPDFAPI.AcroForm = {
  3135.   ChoiceField: AcroFormChoiceField,
  3136.   ListBox: AcroFormListBox,
  3137.   ComboBox: AcroFormComboBox,
  3138.   EditBox: AcroFormEditBox,
  3139.   Button: AcroFormButton,
  3140.   PushButton: AcroFormPushButton,
  3141.   RadioButton: AcroFormRadioButton,
  3142.   CheckBox: AcroFormCheckBox,
  3143.   TextField: AcroFormTextField,
  3144.   PasswordField: AcroFormPasswordField,
  3145.   Appearance: AcroFormAppearance
  3146. };
  3148. jsPDF.AcroForm = {
  3149.   ChoiceField: AcroFormChoiceField,
  3150.   ListBox: AcroFormListBox,
  3151.   ComboBox: AcroFormComboBox,
  3152.   EditBox: AcroFormEditBox,
  3153.   Button: AcroFormButton,
  3154.   PushButton: AcroFormPushButton,
  3155.   RadioButton: AcroFormRadioButton,
  3156.   CheckBox: AcroFormCheckBox,
  3157.   TextField: AcroFormTextField,
  3158.   PasswordField: AcroFormPasswordField,
  3159.   Appearance: AcroFormAppearance
  3160. };
  3162. var AcroForm = jsPDF.AcroForm;
  3164. export {
  3165.   AcroForm,
  3166.   AcroFormChoiceField,
  3167.   AcroFormListBox,
  3168.   AcroFormComboBox,
  3169.   AcroFormEditBox,
  3170.   AcroFormButton,
  3171.   AcroFormPushButton,
  3172.   AcroFormRadioButton,
  3173.   AcroFormCheckBox,
  3174.   AcroFormTextField,
  3175.   AcroFormPasswordField,
  3176.   AcroFormAppearance
  3177. };