vendor/mikehaertl/php-pdftk/src/Pdf.php line 296

Open in your IDE?
  1. <?php
  2. namespace mikehaertl\pdftk;
  4. use mikehaertl\tmp\File;
  6. /**
  7.  * Pdf
  8.  *
  9.  * This class is a wrapper around pdftk.
  10.  *
  11.  * The class was developed for pdftk 2.x but should also work with older
  12.  * versions, but you may have to use slightly different page rotation options
  13.  * (e.g 'E' instead 'east').
  14.  *
  15.  * @author Michael Härtl <haertl.mike@gmail.com>
  16.  * @license http://www.opensource.org/licenses/MIT
  17.  */
  18. class Pdf
  19. {
  20.     // The prefix for temporary files
  21.     const TMP_PREFIX = 'tmp_php_pdftk_';
  23.     /**
  24.      * @var bool whether to ignore any errors if some non-empty output file was
  25.      * still created. Default is false.
  26.      */
  27.     public $ignoreWarnings = false;
  29.     /**
  30.      * @var null|string an optional directory where temporary files should be
  31.      * created. If left empty the directory is autodetected.
  32.      */
  33.     public $tempDir;
  35.     /**
  36.      * @var File the temporary output file
  37.      */
  38.     protected $_tmpFile;
  40.     /**
  41.      * @var string the content type of the tmp output
  42.      */
  43.     protected $_tmpOutputContentType = 'application/pdf';
  45.     /**
  46.      * @var Command the command instance that executes pdftk
  47.      */
  48.     protected $_command;
  50.     /**
  51.      * @var int a counter for autogenerated handles
  52.      */
  53.     protected $_handle = 0;
  55.     /**
  56.      * @var string the error message
  57.      */
  58.     protected $_error = '';
  60.     /**
  61.      * @var string|null the output filename. If null (default) a tmp file is
  62.      * used as output. If false, no output option is added at all.
  63.      */
  64.     protected $_output;
  66.     /**
  67.      * @var string the PDF data as returned from getData()
  68.      */
  69.     protected $_data;
  70.     protected $_data_utf8;
  72.     /**
  73.      * @var DataFields the PDF form field data as returned from getDataFields()
  74.      */
  75.     protected $_dataFields;
  76.     protected $_dataFields_utf8;
  78.     /**
  79.      * @var Pdf[]|null if the input was an instance, we keep a reference here,
  80.      * so that it won't get unlinked before this object gets destroyed
  81.      */
  82.     protected $_pdfs;
  84.     /**
  85.      * @param string|Pdf|array $pdf a pdf filename or Pdf instance or an array
  86.      * of filenames/instances indexed by a handle. The array values can also
  87.      * be arrays of the form array($filename, $password) if some files are
  88.      * password protected.
  89.      * @param array $options Options to pass to set on the Command instance,
  90.      * e.g. the pdftk binary path
  91.      */
  92.     public function __construct($pdf = null, $options = array())
  93.     {
  94.         $command = $this->getCommand();
  95.         if ($options !== array()) {
  96.             $command->setOptions($options);
  97.         }
  98.         if (is_string($pdf) || $pdf instanceof Pdf) {
  99.             $this->addFile($pdf);
  100.         } elseif (is_array($pdf)) {
  101.             foreach ($pdf as $handle => $file) {
  102.                 if (is_array($file)) {
  103.                     $this->addFile($file[0], $handle, $file[1]);
  104.                 } else {
  105.                     $this->addFile($file, $handle);
  106.                 }
  107.             }
  108.         }
  109.     }
  111.     /**
  112.      * @param string|Pdf $name the PDF filename or Pdf instance to add for
  113.      * processing
  114.      * @param string|null $handle one or more uppercase letters A..Z to
  115.      * reference this file later. If no handle is provided, an internal handle
  116.      * is autocreated, consuming the range Z..A
  117.      * @param string|null $password the owner (or user) password if any
  118.      * @return Pdf the pdf instance for method chaining
  119.      */
  120.     public function addFile($name, $handle = null, $password = null)
  121.     {
  122.         if ($handle === null || is_numeric($handle)) {
  123.             $handle = $this->nextHandle();
  124.         }
  125.         if ($name instanceof Pdf) {
  126.             // Keep a reference to the object to prevent unlinking
  127.             $this->_pdfs[] = $name;
  128.             if (!$name->getCommand()->getExecuted()) {
  129.                 // @todo: Catch errors!
  130.                 $name->execute();
  131.             }
  132.             $name = (string) $name->getTmpFile();
  133.         }
  134.         $this->getCommand()->addFile($name, $handle, $password);
  135.         return $this;
  136.     }
  138.     /**
  139.      * Assemble (catenate) pages from the input files.
  140.      *
  141.      * Values for rotation are (in degrees): north: 0, east: 90, south: 180,
  142.      * west: 270, left: -90, right: +90, down: +180. left, right and down make
  143.      * relative adjustments to a page's rotation. Note: Older pdftk versions
  144.      * use N, E, S, W, L, R, and D instead.
  145.      *
  146.      * Example:
  147.      *
  148.      *  $pdf = new Pdf;
  149.      *  $pdf->addFile('file1.pdf', 'A')
  150.      *      ->addFile('file2.pdf', 'B')
  151.      *      ->cat(array(1,3),'B'))          // pages 1 and 3 of file B
  152.      *      ->cat(1, 5, 'A', 'odd')         // pages 1, 3, 5 of file A
  153.      *      ->cat('end', 5, 'B')            // pages 5 to end of file B in reverse order
  154.      *      ->cat(null, null, 'B', 'east')  // All pages from file B rotated by 90 degree
  155.      *      ->saveAs('out.pdf');
  156.      * or
  157.      *  $files = ['file1.pdf', 'file2.pdf', 'file3.pdf'];
  158.      *  $pdf = new Pdf($files);
  159.      *  $pdf->cat()                         // all files, all pages
  160.      *      ->saveAs('out.pdf');
  161.      *
  162.      * @param int|string|array|null $start the start page number or an array of page
  163.      * numbers. If an array, the other arguments will be ignored. $start can
  164.      * also be bigger than $end for pages in reverse order. If $start is null all
  165.      * pages of all files will be added.
  166.      * @param int|string|null $end the end page number or null for single page
  167.      * (or list if $start is an array)
  168.      * @param string|null $handle the handle of the file to use. Can be null if
  169.      * only a single file was added.
  170.      * @param string|null $qualifier the page number qualifier, either 'even'
  171.      * or 'odd' or null for none
  172.      * @param string $rotation the rotation to apply to the pages.
  173.      * @return Pdf the pdf instance for method chaining
  174.      */
  175.     public function cat($start = null, $end = null, $handle = null, $qualifier = null, $rotation = null)
  176.     {
  177.         $this->getCommand()
  178.             ->setOperation('cat')
  179.             ->addPageRange($start, $end, $handle, $qualifier, $rotation);
  180.         return $this;
  181.     }
  183.     /**
  184.      * Shuffle pages from the input files.
  185.      *
  186.      * This works the same as cat(), but each call to this method creates a
  187.      * "stream" of pages. The outfile will be assembled by adding one page from
  188.      * each stream at a time.
  189.      *
  190.      * Example:
  191.      *
  192.      *  $pdf = new Pdf;
  193.      *  $pdf1 = $pdf->addFile('file1.pdf');
  194.      *  $pdf->shuffle($pdf1, array(1,3,2))
  195.      *      ->shuffle($pdf1, array(4,5,9)
  196.      *      ->saveAs('out.pdf');
  197.      *
  198.      * This will give the page order 1, 4, 3, 5, 2, 9 in the out.pdf
  199.      *
  200.      * @param string $handle the handle of the input file to use
  201.      * @param int|array $start the start page number or an array of page
  202.      * numbers.
  203.      * @param int|null $end the end page number or null for single page (or
  204.      * list if $start is an array)
  205.      * @param string|null $qualifier the page number qualifier, either 'even'
  206.      * or 'odd' or null for none
  207.      * @param string $rotation the rotation to apply to the pages. See cat()
  208.      * for more details.
  209.      * @return Pdf the pdf instance for method chaining
  210.      */
  211.     public function shuffle($start, $end = null, $handle = null, $qualifier = null, $rotation = null)
  212.     {
  213.         $this->getCommand()
  214.             ->setOperation('shuffle')
  215.             ->addPageRange($start, $end, $handle, $qualifier, $rotation);
  216.         return $this;
  217.     }
  219.     /**
  220.      * Split the PDF document into pages
  221.      *
  222.      * @param string|null $filepattern the output name in sprintf format or
  223.      * null for default 'pg_%04d.pdf'
  224.      * @return bool whether the burst operation was successful
  225.      */
  226.     public function burst($filepattern = null)
  227.     {
  228.         $this->constrainSingleFile();
  229.         $this->getCommand()->setOperation('burst');
  230.         $this->_output = $filepattern === null ? 'pg_%04d.pdf' : $filepattern;
  231.         return $this->execute();
  232.     }
  234.     /**
  235.      * Attach files to the PDF
  236.      *
  237.      * @param array $files the list of full paths to the files to attach
  238.      * @param string $toPage the page to add the attachment to. If omitted the
  239.      * files are attached at the document level.
  240.      * @return bool whether the operation was successful
  241.      */
  242.     public function attachFiles($files, $toPage = null)
  243.     {
  244.         $this->constrainSingleFile();
  245.         if ($toPage !== null) {
  246.             $files[] = 'to_page';
  247.             $files[] = $toPage;
  248.         }
  249.         $this->getCommand()
  250.             ->setOperation('attach_files')
  251.             ->setOperationArgument($files, true);
  252.         return $this;
  253.     }
  255.     /**
  256.      * Copy all attachments from the PDF to the given directory
  257.      *
  258.      * @param string|null $dir the output directory
  259.      * @return bool whether the operation was successful
  260.      */
  261.     public function unpackFiles($dir = null)
  262.     {
  263.         $this->constrainSingleFile();
  264.         $this->getCommand()->setOperation('unpack_files');
  265.         $this->_output = $dir;
  266.         return $this->execute();
  267.     }
  269.     /**
  270.      * Generate the FDF file for a single PDF file.
  271.      *
  272.      * @param string $name name of the FDF file
  273.      * @return bool whether the pdf is generated successful
  274.      */
  275.     public function generateFdfFile($name)
  276.     {
  277.         $this->constrainSingleFile();
  278.         $this->getCommand()->setOperation('generate_fdf');
  279.         $this->_output = $name;
  280.         return $this->execute();
  281.     }
  283.     /**
  284.      * Fill a PDF form
  285.      *
  286.      * @param string|array $data either a XFDF/FDF filename or an array with
  287.      * form field data (name => value)
  288.      * @param string $encoding the encoding of the data. Default is 'UTF-8'.
  289.      * @param bool $dropXfa whether to drop XFA forms (see dropXfa()). Default
  290.      * is true.
  291.      * @param string $format the file format to use for form filling when
  292.      * passing an array in `$data`. This can be `xfdf` or `fdf`. `xfdf` should
  293.      * give best results so you should not have to change the default.
  294.      * @return Pdf the pdf instance for method chaining
  295.      */
  296.     public function fillForm($data, $encoding = 'UTF-8', $dropXfa = true, $format = 'xfdf')
  297.     {
  298.         $this->constrainSingleFile();
  299.         if (is_array($data)) {
  300.             $className = '\mikehaertl\pdftk\\' . ($format === 'xfdf' ? 'XfdfFile' : 'FdfFile');
  301.             $data = new $className($data, null, null, $this->tempDir, $encoding);
  302.         }
  303.         $this->getCommand()
  304.             ->setOperation('fill_form')
  305.             ->setOperationArgument($data, true);
  307.         if ($dropXfa) {
  308.             $this->dropXfa();
  309.         }
  310.         return $this;
  311.     }
  313.     /**
  314.      * Update meta data of PDF
  315.      *
  316.      * @param string|array $data either a InfoFile filename or an array with
  317.      * form field data (name => value)
  318.      * @param string the encoding of the data. Default is 'UTF-8'.
  319.      * @return Pdf the pdf instance for method chaining
  320.      */
  321.     public function updateInfo($data, $encoding = 'UTF-8')
  322.     {
  323.         $this->constrainSingleFile();
  324.         if (is_array($data) || $data instanceof InfoFields) {
  325.             $data = new InfoFile($data, null, null, $this->tempDir, $encoding);
  326.         }
  327.         $this->getCommand()
  328.             ->setOperation($encoding == 'UTF-8' ? 'update_info_utf8' : 'update_info')
  329.             ->setOperationArgument($data, true);
  331.         return $this;
  332.     }
  334.     /**
  335.      * Apply a PDF as watermark to the background of a single PDF file.
  336.      *
  337.      * The PDF file must have a transparent background for the watermark to be
  338.      * visible.
  339.      *
  340.      * @param string $file name of the background PDF file. Only the first page
  341.      * is used.
  342.      * @return Pdf the pdf instance for method chaining
  343.      */
  344.     public function background($file)
  345.     {
  346.         $this->constrainSingleFile();
  347.         $this->getCommand()
  348.             ->setOperation('background')
  349.             ->setOperationArgument($file, true);
  350.         return $this;
  351.     }
  353.     /**
  354.      * Apply multiple PDF pages as watermark to the corresponding pages of a
  355.      * single PDF file.
  356.      *
  357.      * If $file has fewer pages than the PDF file then the last page is
  358.      * repeated as background.
  359.      *
  360.      * @param string $file name of the background PDF file.
  361.      * @return Pdf the pdf instance for method chaining
  362.      */
  363.     public function multiBackground($file)
  364.     {
  365.         $this->getCommand()
  366.             ->setOperation('multibackground')
  367.             ->setOperationArgument($file, true);
  368.         return $this;
  369.     }
  371.     /**
  372.      * Add $file as overlay to a single PDF file.
  373.      *
  374.      * The $file should have a transparent background.
  375.      *
  376.      * @param string $file name of the PDF file to add as overlay. Only the
  377.      * first page is used.
  378.      * @return Pdf the pdf instance for method chaining
  379.      */
  380.     public function stamp($file)
  381.     {
  382.         $this->constrainSingleFile();
  383.         $this->getCommand()
  384.             ->setOperation('stamp')
  385.             ->setOperationArgument($file, true);
  386.         return $this;
  387.     }
  389.     /**
  390.      * Add multiple pages from $file as overlay to the corresponding pages of a
  391.      * single PDF file.
  392.      *
  393.      * If $file has fewer pages than the PDF file then the last page is
  394.      * repeated as overlay.
  395.      *
  396.      * @param string $file name of the PDF file to add as overlay
  397.      * @return Pdf the pdf instance for method chaining
  398.      */
  399.     public function multiStamp($file)
  400.     {
  401.         $this->getCommand()
  402.             ->setOperation('multistamp')
  403.             ->setOperationArgument($file, true);
  404.         return $this;
  405.     }
  407.     /**
  408.      * @param bool $utf8 whether to dump the data UTF-8 encoded. Default is
  409.      * true.
  410.      * @return InfoFields|bool meta data about the PDF or false on failure
  411.      */
  412.     public function getData($utf8 = true)
  413.     {
  414.         $property = $utf8 ? '_data_utf8' : '_data';
  415.         if ($this->$property === null) {
  416.             $command = $this->getCommand();
  417.             $command->setOperation($utf8 ? 'dump_data_utf8' : 'dump_data');
  418.             if (!$command->execute()) {
  419.                 $this->_error = $command->getError();
  420.                 return false;
  421.             } else {
  422.                 $this->$property = new InfoFields(trim($command->getOutput()));
  423.             }
  424.         }
  425.         return $this->$property;
  426.     }
  428.     /**
  429.      * @param bool $utf8 whether to dump the data UTF-8 encoded. Default is
  430.      * true.
  431.      * @return DataFields|bool data about the PDF form fields or false on
  432.      * failure
  433.      */
  434.     public function getDataFields($utf8 = true)
  435.     {
  436.         $property = $utf8 ? '_dataFields_utf8' : '_dataFields';
  437.         if ($this->$property === null) {
  438.             $command = $this->getCommand();
  439.             $command->setOperation($utf8 ? 'dump_data_fields_utf8' : 'dump_data_fields');
  440.             if (!$command->execute()) {
  441.                 $this->_error = $command->getError();
  442.                 return false;
  443.             } else {
  444.                 $this->$property = new DataFields(trim($command->getOutput()));
  445.             }
  446.         }
  447.         return $this->$property;
  448.     }
  450.     /**
  451.      * Set PDF permissions
  452.      *
  453.      *
  454.      * @param string|null $permissions list of space separated permissions or
  455.      * null for none. The available permissions are Printing, DegradedPrinting,
  456.      * ModifyContents, Assembly, CopyContents, ScreenReaders,
  457.      * ModifyAnnotations, FillIn, AllFeatures.
  458.      * @return Pdf the pdf instance for method chaining
  459.      */
  460.     public function allow($permissions = null)
  461.     {
  462.         $this->getCommand()
  463.             ->addOption('allow', $permissions, false);
  464.         return $this;
  465.     }
  467.     /**
  468.      * Flatten the PDF form fields values into a single PDF file.
  469.      *
  470.      * @return Pdf the pdf instance for method chaining
  471.      */
  472.     public function flatten()
  473.     {
  474.         $this->getCommand()
  475.             ->addOption('flatten');
  476.         return $this;
  477.     }
  479.     /**
  480.      * Restore/remove compression
  481.      *
  482.      * @param bool $compress whether to restore (default) or remove the
  483.      * compression
  484.      * @return Pdf the pdf instance for method chaining
  485.      */
  486.     public function compress($compress = true)
  487.     {
  488.         $this->getCommand()
  489.             ->addOption($compress ? 'compress' : 'uncompress');
  490.         return $this;
  491.     }
  493.     /**
  494.      * When combining multiple PDFs, use either the first or last ID in the
  495.      * output. If not called, a new ID is created.
  496.      *
  497.      * @param string $id, either 'first' (default) or 'last'
  498.      * @return Pdf the pdf instance for method chaining
  499.      */
  500.     public function keepId($id = 'first')
  501.     {
  502.         $this->getCommand()
  503.             ->addOption($id === 'first' ? 'keep_first_id' : 'keep_final_id');
  504.         return $this;
  505.     }
  507.     /**
  508.      * Set need_appearances flag in PDF
  509.      *
  510.      * This flag makes sure, that a PDF reader takes care of rendering form
  511.      * field content, even if it contains non ASCII characters. You should
  512.      * always use this option if you fill in forms e.g. with Unicode
  513.      * characters. You can't combine this option with flatten() though!
  514.      *
  515.      * @return Pdf the pdf instance for method chaining
  516.      */
  517.     public function needAppearances()
  518.     {
  519.         $this->getCommand()
  520.             ->addOption('need_appearances');
  521.         return $this;
  522.     }
  524.     /**
  525.      * Drop XFA data from forms created with newer Acrobat.
  526.      *
  527.      * Newer PDF forms contain both, the newer XFA and the older AcroForm form
  528.      * fields. PDF readers can use both, but will prefer XFA if present. Since
  529.      * pdftk can only fill in AcroForm data you should always add this option
  530.      * when filling in forms with pdftk.
  531.      *
  532.      * @return Pdf the pdf instance for method chaining
  533.      */
  534.     public function dropXfa()
  535.     {
  536.         $this->getCommand()
  537.             ->addOption('drop_xfa');
  538.         return $this;
  539.     }
  541.     /**
  542.      * Drop XMP meta data
  543.      *
  544.      * Newer PDFs can contain both, new style XMP data and old style info
  545.      * directory. PDF readers can use both, but will prefer XMP if present.
  546.      * Since pdftk can only update the info directory you should always add
  547.      * this option when updating PDF info.
  548.      *
  549.      * @return Pdf the pdf instance for method chaining
  550.      */
  551.     public function dropXmp()
  552.     {
  553.         $this->getCommand()
  554.             ->addOption('drop_xmp');
  555.         return $this;
  556.     }
  558.     /**
  559.      * @param string $password the owner password to set on the output PDF
  560.      * @return Pdf the pdf instance for method chaining
  561.      */
  562.     public function setPassword($password)
  563.     {
  564.         $this->getCommand()
  565.             ->addOption('owner_pw', $password, true);
  566.         return $this;
  567.     }
  569.     /**
  570.      * @param string $password the user password to set on the output PDF
  571.      * @return Pdf the pdf instance for method chaining
  572.      */
  573.     public function setUserPassword($password)
  574.     {
  575.         $this->getCommand()
  576.             ->addOption('user_pw', $password, true);
  577.         return $this;
  578.     }
  580.     /**
  581.      * @param int $strength the password encryption strength. Default is 128
  582.      * @return Pdf the pdf instance for method chaining
  583.      */
  584.     public function passwordEncryption($strength = 128)
  585.     {
  586.         $this->getCommand()
  587.             ->addOption($strength == 128 ? 'encrypt_128bit' : 'encrypt_40bit');
  588.         return $this;
  589.     }
  591.     /**
  592.      * Replace embedded font with a local font when filling a form.
  593.      *
  594.      * This option is only available for pdftk-java >= 3.3.0. It is useful when
  595.      * filling a form with non-ASCII text that is not supported by the fonts
  596.      * included in the input PDF.
  597.      *
  598.      * @param string $fontName the path to the font or the name of a font family.
  599.      * @return Pdf the pdf instance for method chaining
  600.      */
  601.     public function replacementFont($path)
  602.     {
  603.         $this->getCommand()
  604.             ->addOption('replacement_font', $path);
  605.         return $this;
  606.     }
  608.     /**
  609.      * Execute the operation and save the output file
  610.      *
  611.      * @param string $name of output file
  612.      * @return bool whether the PDF could be processed and saved
  613.      */
  614.     public function saveAs($name)
  615.     {
  616.         if (!$this->getCommand()->getExecuted() && !$this->execute()) {
  617.             return false;
  618.         }
  619.         $tmpFile = (string) $this->getTmpFile();
  620.         if (!copy($tmpFile, $name)) {
  621.             $this->_error = "Could not copy PDF from tmp location '$tmpFile' to '$name'";
  622.             return false;
  623.         }
  624.         return true;
  625.     }
  627.     /**
  628.      * Send PDF to client, either inline or as download (triggers PDF creation)
  629.      *
  630.      * @param string|null $filename the filename to send. If empty, the PDF is
  631.      * streamed inline.
  632.      * @param bool $inline whether to force inline display of the PDF, even if
  633.      * filename is present.
  634.      * @param array $headers a list of additional HTTP headers to send in the
  635.      * response as an array. The array keys are the header names like
  636.      * 'Cache-Control' and the array values the header value strings to send.
  637.      * Each array value can also be another array of strings if the same header
  638.      * should be sent multiple times. This can also be used to override
  639.      * automatically created headers like 'Expires' or 'Content-Length'. To suppress
  640.      * automatically created headers, `false` can also be used as header value.
  641.      * @return bool whether PDF was created successfully
  642.      */
  643.     public function send($filename = null, $inline = false, $headers = array())
  644.     {
  645.         if (!$this->getCommand()->getExecuted() && !$this->execute()) {
  646.             return false;
  647.         }
  648.         $this->getTmpFile()->send($filename, $this->_tmpOutputContentType, $inline, $headers);
  649.         return true;
  650.     }
  652.     /**
  653.      * Get the raw PDF contents (triggers PDF creation).
  654.      *
  655.      * @return string|bool the PDF content as a string or `false` if the PDF
  656.      * wasn't created successfully.
  657.      */
  658.     public function toString()
  659.     {
  660.         if (!$this->getCommand()->getExecuted() && !$this->execute()) {
  661.             return false;
  662.         }
  663.         return file_get_contents($this->getTmpFile()->getFileName());
  664.     }
  666.     /**
  667.      * @return Command the command instance that executes pdftk
  668.      */
  669.     public function getCommand()
  670.     {
  671.         if ($this->_command === null) {
  672.             $this->_command = new Command;
  673.         }
  674.         return $this->_command;
  675.     }
  677.     /**
  678.      * @return File the temporary output file instance
  679.      */
  680.     public function getTmpFile()
  681.     {
  682.         if ($this->_tmpFile === null) {
  683.             $this->_tmpFile = new File('', '.pdf', self::TMP_PREFIX, $this->tempDir);
  684.         }
  685.         return $this->_tmpFile;
  686.     }
  688.     /**
  689.      * @return string the error message or an empty string if none
  690.      */
  691.     public function getError()
  692.     {
  693.         return $this->_error;
  694.     }
  696.     /**
  697.      * Execute the pdftk command and store the output file to a temporary
  698.      * location or $this->_output if set.  You should probably never call this
  699.      * method unless you only need a temporary PDF file as result.
  700.      *
  701.      * @return bool whether the command was executed successfully
  702.      */
  703.     public function execute()
  704.     {
  705.         $command = $this->getCommand();
  706.         if ($command->getExecuted()) {
  707.             return false;
  708.         }
  710.         if ($this->_output === false) {
  711.             $filename = null;
  712.         } else {
  713.             $filename = $this->_output ? $this->_output : (string) $this->getTmpFile();
  714.         }
  715.         if (!$command->execute($filename)) {
  716.             $this->_error = $command->getError();
  717.             if ($filename && !(file_exists($filename) && filesize($filename) !== 0 && $this->ignoreWarnings)) {
  718.                 return false;
  719.             }
  720.         }
  721.         return true;
  722.     }
  724.     /**
  725.      * Make sure, that only one file is present
  726.      */
  727.     protected function constrainSingleFile()
  728.     {
  729.         if ($this->getCommand()->getFileCount() > 1) {
  730.             throw new \Exception('This operation can only process single files');
  731.         }
  732.     }
  734.     /**
  735.      * @return string the next handle in the series A, B, C, ... Z, AA, AB...
  736.      */
  737.     protected function nextHandle()
  738.     {
  739.         // N.B. Multi-character handles are only available in pdftk 1.45+
  741.         $i = $this->_handle++;
  742.         $char = 'A';
  743.         while ($i-- > 0) {
  744.             $char++;
  745.         }
  747.         return $char;
  748.     }
  749. }