[Summary view] [Print] [Text view]

   1  <?php
   2  // This file is part of Moodle - http://moodle.org/
   3  //
   4  // Moodle is free software: you can redistribute it and/or modify
   5  // it under the terms of the GNU General Public License as published by
   6  // the Free Software Foundation, either version 3 of the License, or
   7  // (at your option) any later version.
   8  //
   9  // Moodle is distributed in the hope that it will be useful,
  10  // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  // GNU General Public License for more details.
  13  //
  14  // You should have received a copy of the GNU General Public License
  15  // along with Moodle.  If not, see <http://www.gnu.org/licenses/>.
  16  
  17  /**
  18   * Library code for manipulating PDFs
  19   *
  20   * @package assignfeedback_editpdf
  21   * @copyright 2012 Davo Smith
  22   * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  23   */
  24  
  25  namespace assignfeedback_editpdf;
  26  
  27  defined('MOODLE_INTERNAL') || die();
  28  
  29  global $CFG;
  30  require_once($CFG->libdir.'/pdflib.php');
  31  require_once($CFG->dirroot.'/mod/assign/feedback/editpdf/fpdi/fpdi.php');
  32  
  33  /**
  34   * Library code for manipulating PDFs
  35   *
  36   * @package assignfeedback_editpdf
  37   * @copyright 2012 Davo Smith
  38   * @license   http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
  39   */
  40  class pdf extends \FPDI {
  41  
  42      /** @var int the number of the current page in the PDF being processed */
  43      protected $currentpage = 0;
  44      /** @var int the total number of pages in the PDF being processed */
  45      protected $pagecount = 0;
  46      /** @var float used to scale the pixel position of annotations (in the database) to the position in the final PDF */
  47      protected $scale = 0.0;
  48      /** @var string the path in which to store generated page images */
  49      protected $imagefolder = null;
  50      /** @var string the path to the PDF currently being processed */
  51      protected $filename = null;
  52  
  53      /** No errors */
  54      const GSPATH_OK = 'ok';
  55      /** Not set */
  56      const GSPATH_EMPTY = 'empty';
  57      /** Does not exist */
  58      const GSPATH_DOESNOTEXIST = 'doesnotexist';
  59      /** Is a dir */
  60      const GSPATH_ISDIR = 'isdir';
  61      /** Not executable */
  62      const GSPATH_NOTEXECUTABLE = 'notexecutable';
  63      /** Test file missing */
  64      const GSPATH_NOTESTFILE = 'notestfile';
  65      /** Any other error */
  66      const GSPATH_ERROR = 'error';
  67      /** Min. width an annotation should have */
  68      const MIN_ANNOTATION_WIDTH = 5;
  69      /** Min. height an annotation should have */
  70      const MIN_ANNOTATION_HEIGHT = 5;
  71  
  72      /**
  73       * Combine the given PDF files into a single PDF. Optionally add a coversheet and coversheet fields.
  74       * @param string[] $pdflist  the filenames of the files to combine
  75       * @param string $outfilename the filename to write to
  76       * @return int the number of pages in the combined PDF
  77       */
  78      public function combine_pdfs($pdflist, $outfilename) {
  79  
  80          raise_memory_limit(MEMORY_EXTRA);
  81          $olddebug = error_reporting(0);
  82  
  83          $this->setPageUnit('pt');
  84          $this->setPrintHeader(false);
  85          $this->setPrintFooter(false);
  86          $this->scale = 72.0 / 100.0;
  87          $this->SetFont('helvetica', '', 16.0 * $this->scale);
  88          $this->SetTextColor(0, 0, 0);
  89  
  90          $totalpagecount = 0;
  91  
  92          foreach ($pdflist as $file) {
  93              $pagecount = $this->setSourceFile($file);
  94              $totalpagecount += $pagecount;
  95              for ($i = 1; $i<=$pagecount; $i++) {
  96                  $this->create_page_from_source($i);
  97              }
  98          }
  99  
 100          $this->save_pdf($outfilename);
 101          error_reporting($olddebug);
 102  
 103          return $totalpagecount;
 104      }
 105  
 106      /**
 107       * The number of the current page in the PDF being processed
 108       * @return int
 109       */
 110      public function current_page() {
 111          return $this->currentpage;
 112      }
 113  
 114      /**
 115       * The total number of pages in the PDF being processed
 116       * @return int
 117       */
 118      public function page_count() {
 119          return $this->pagecount;
 120      }
 121  
 122      /**
 123       * Load the specified PDF and set the initial output configuration
 124       * Used when processing comments and outputting a new PDF
 125       * @param string $filename the path to the PDF to load
 126       * @return int the number of pages in the PDF
 127       */
 128      public function load_pdf($filename) {
 129          raise_memory_limit(MEMORY_EXTRA);
 130          $olddebug = error_reporting(0);
 131  
 132          $this->setPageUnit('pt');
 133          $this->scale = 72.0 / 100.0;
 134          $this->SetFont('helvetica', '', 16.0 * $this->scale);
 135          $this->SetFillColor(255, 255, 176);
 136          $this->SetDrawColor(0, 0, 0);
 137          $this->SetLineWidth(1.0 * $this->scale);
 138          $this->SetTextColor(0, 0, 0);
 139          $this->setPrintHeader(false);
 140          $this->setPrintFooter(false);
 141          $this->pagecount = $this->setSourceFile($filename);
 142          $this->filename = $filename;
 143  
 144          error_reporting($olddebug);
 145          return $this->pagecount;
 146      }
 147  
 148      /**
 149       * Sets the name of the PDF to process, but only loads the file if the
 150       * pagecount is zero (in order to count the number of pages)
 151       * Used when generating page images (but not a new PDF)
 152       * @param string $filename the path to the PDF to process
 153       * @param int $pagecount optional the number of pages in the PDF, if known
 154       * @return int the number of pages in the PDF
 155       */
 156      public function set_pdf($filename, $pagecount = 0) {
 157          if ($pagecount == 0) {
 158              return $this->load_pdf($filename);
 159          } else {
 160              $this->filename = $filename;
 161              $this->pagecount = $pagecount;
 162              return $pagecount;
 163          }
 164      }
 165  
 166      /**
 167       * Copy the next page from the source file and set it as the current page
 168       * @return bool true if successful
 169       */
 170      public function copy_page() {
 171          if (!$this->filename) {
 172              return false;
 173          }
 174          if ($this->currentpage>=$this->pagecount) {
 175              return false;
 176          }
 177          $this->currentpage++;
 178          $this->create_page_from_source($this->currentpage);
 179          return true;
 180      }
 181  
 182      /**
 183       * Create a page from a source PDF.
 184       *
 185       * @param int $pageno
 186       */
 187      protected function create_page_from_source($pageno) {
 188          // Get the size (and deduce the orientation) of the next page.
 189          $template = $this->importPage($pageno);
 190          $size = $this->getTemplateSize($template);
 191          $orientation = 'P';
 192          if ($size['w'] > $size['h']) {
 193              $orientation = 'L';
 194          }
 195          // Create a page of the required size / orientation.
 196          $this->AddPage($orientation, array($size['w'], $size['h']));
 197          // Prevent new page creation when comments are at the bottom of a page.
 198          $this->setPageOrientation($orientation, false, 0);
 199          // Fill in the page with the original contents from the student.
 200          $this->useTemplate($template);
 201      }
 202  
 203      /**
 204       * Copy all the remaining pages in the file
 205       */
 206      public function copy_remaining_pages() {
 207          $morepages = true;
 208          while ($morepages) {
 209              $morepages = $this->copy_page();
 210          }
 211      }
 212  
 213      /**
 214       * Add a comment to the current page
 215       * @param string $text the text of the comment
 216       * @param int $x the x-coordinate of the comment (in pixels)
 217       * @param int $y the y-coordinate of the comment (in pixels)
 218       * @param int $width the width of the comment (in pixels)
 219       * @param string $colour optional the background colour of the comment (red, yellow, green, blue, white, clear)
 220       * @return bool true if successful (always)
 221       */
 222      public function add_comment($text, $x, $y, $width, $colour = 'yellow') {
 223          if (!$this->filename) {
 224              return false;
 225          }
 226          $this->SetDrawColor(51, 51, 51);
 227          switch ($colour) {
 228              case 'red':
 229                  $this->SetFillColor(249, 181, 179);
 230                  break;
 231              case 'green':
 232                  $this->SetFillColor(214, 234, 178);
 233                  break;
 234              case 'blue':
 235                  $this->SetFillColor(203, 217, 237);
 236                  break;
 237              case 'white':
 238                  $this->SetFillColor(255, 255, 255);
 239                  break;
 240              default: /* Yellow */
 241                  $this->SetFillColor(255, 236, 174);
 242                  break;
 243          }
 244  
 245          $x *= $this->scale;
 246          $y *= $this->scale;
 247          $width *= $this->scale;
 248          $text = str_replace('&lt;', '<', $text);
 249          $text = str_replace('&gt;', '>', $text);
 250          // Draw the text with a border, but no background colour (using a background colour would cause the fill to
 251          // appear behind any existing content on the page, hence the extra filled rectangle drawn below).
 252          $this->MultiCell($width, 1.0, $text, 0, 'L', 0, 4, $x, $y); /* width, height, text, border, justify, fill, ln, x, y */
 253          if ($colour != 'clear') {
 254              $newy = $this->GetY();
 255              // Now we know the final size of the comment, draw a rectangle with the background colour.
 256              $this->Rect($x, $y, $width, $newy - $y, 'DF');
 257              // Re-draw the text over the top of the background rectangle.
 258              $this->MultiCell($width, 1.0, $text, 0, 'L', 0, 4, $x, $y); /* width, height, text, border, justify, fill, ln, x, y */
 259          }
 260          return true;
 261      }
 262  
 263      /**
 264       * Add an annotation to the current page
 265       * @param int $sx starting x-coordinate (in pixels)
 266       * @param int $sy starting y-coordinate (in pixels)
 267       * @param int $ex ending x-coordinate (in pixels)
 268       * @param int $ey ending y-coordinate (in pixels)
 269       * @param string $colour optional the colour of the annotation (red, yellow, green, blue, white, black)
 270       * @param string $type optional the type of annotation (line, oval, rectangle, highlight, pen, stamp)
 271       * @param int[]|string $path optional for 'pen' annotations this is an array of x and y coordinates for
 272       *              the line, for 'stamp' annotations it is the name of the stamp file (without the path)
 273       * @param string $imagefolder - Folder containing stamp images.
 274       * @return bool true if successful (always)
 275       */
 276      public function add_annotation($sx, $sy, $ex, $ey, $colour = 'yellow', $type = 'line', $path, $imagefolder) {
 277          global $CFG;
 278          if (!$this->filename) {
 279              return false;
 280          }
 281          switch ($colour) {
 282              case 'yellow':
 283                  $colourarray = array(255, 207, 53);
 284                  break;
 285              case 'green':
 286                  $colourarray = array(153, 202, 62);
 287                  break;
 288              case 'blue':
 289                  $colourarray = array(125, 159, 211);
 290                  break;
 291              case 'white':
 292                  $colourarray = array(255, 255, 255);
 293                  break;
 294              case 'black':
 295                  $colourarray = array(51, 51, 51);
 296                  break;
 297              default: /* Red */
 298                  $colour = 'red';
 299                  $colourarray = array(239, 69, 64);
 300                  break;
 301          }
 302          $this->SetDrawColorArray($colourarray);
 303  
 304          $sx *= $this->scale;
 305          $sy *= $this->scale;
 306          $ex *= $this->scale;
 307          $ey *= $this->scale;
 308  
 309          $this->SetLineWidth(3.0 * $this->scale);
 310          switch ($type) {
 311              case 'oval':
 312                  $rx = abs($sx - $ex) / 2;
 313                  $ry = abs($sy - $ey) / 2;
 314                  $sx = min($sx, $ex) + $rx;
 315                  $sy = min($sy, $ey) + $ry;
 316  
 317                  // $rx and $ry should be >= min width and height
 318                  if ($rx < self::MIN_ANNOTATION_WIDTH) {
 319                      $rx = self::MIN_ANNOTATION_WIDTH;
 320                  }
 321                  if ($ry < self::MIN_ANNOTATION_HEIGHT) {
 322                      $ry = self::MIN_ANNOTATION_HEIGHT;
 323                  }
 324  
 325                  $this->Ellipse($sx, $sy, $rx, $ry);
 326                  break;
 327              case 'rectangle':
 328                  $w = abs($sx - $ex);
 329                  $h = abs($sy - $ey);
 330                  $sx = min($sx, $ex);
 331                  $sy = min($sy, $ey);
 332  
 333                  // Width or height should be >= min width and height
 334                  if ($w < self::MIN_ANNOTATION_WIDTH) {
 335                      $w = self::MIN_ANNOTATION_WIDTH;
 336                  }
 337                  if ($h < self::MIN_ANNOTATION_HEIGHT) {
 338                      $h = self::MIN_ANNOTATION_HEIGHT;
 339                  }
 340                  $this->Rect($sx, $sy, $w, $h);
 341                  break;
 342              case 'highlight':
 343                  $w = abs($sx - $ex);
 344                  $h = 8.0 * $this->scale;
 345                  $sx = min($sx, $ex);
 346                  $sy = min($sy, $ey) + ($h * 0.5);
 347                  $this->SetAlpha(0.5, 'Normal', 0.5, 'Normal');
 348                  $this->SetLineWidth(8.0 * $this->scale);
 349  
 350                  // width should be >= min width
 351                  if ($w < self::MIN_ANNOTATION_WIDTH) {
 352                      $w = self::MIN_ANNOTATION_WIDTH;
 353                  }
 354  
 355                  $this->Rect($sx, $sy, $w, $h);
 356                  $this->SetAlpha(1.0, 'Normal', 1.0, 'Normal');
 357                  break;
 358              case 'pen':
 359                  if ($path) {
 360                      $scalepath = array();
 361                      $points = preg_split('/[,:]/', $path);
 362                      foreach ($points as $point) {
 363                          $scalepath[] = intval($point) * $this->scale;
 364                      }
 365  
 366                      if (!empty($scalepath)) {
 367                          $this->PolyLine($scalepath, 'S');
 368                      }
 369                  }
 370                  break;
 371              case 'stamp':
 372                  $imgfile = $imagefolder . '/' . clean_filename($path);
 373                  $w = abs($sx - $ex);
 374                  $h = abs($sy - $ey);
 375                  $sx = min($sx, $ex);
 376                  $sy = min($sy, $ey);
 377  
 378                  // Stamp is always more than 40px, so no need to check width/height.
 379                  $this->Image($imgfile, $sx, $sy, $w, $h);
 380                  break;
 381              default: // Line.
 382                  $this->Line($sx, $sy, $ex, $ey);
 383                  break;
 384          }
 385          $this->SetDrawColor(0, 0, 0);
 386          $this->SetLineWidth(1.0 * $this->scale);
 387  
 388          return true;
 389      }
 390  
 391      /**
 392       * Save the completed PDF to the given file
 393       * @param string $filename the filename for the PDF (including the full path)
 394       */
 395      public function save_pdf($filename) {
 396          $olddebug = error_reporting(0);
 397          $this->Output($filename, 'F');
 398          error_reporting($olddebug);
 399      }
 400  
 401      /**
 402       * Set the path to the folder in which to generate page image files
 403       * @param string $folder
 404       */
 405      public function set_image_folder($folder) {
 406          $this->imagefolder = $folder;
 407      }
 408  
 409      /**
 410       * Generate an image of the specified page in the PDF
 411       * @param int $pageno the page to generate the image of
 412       * @throws moodle_exception
 413       * @throws coding_exception
 414       * @return string the filename of the generated image
 415       */
 416      public function get_image($pageno) {
 417          global $CFG;
 418  
 419          if (!$this->filename) {
 420              throw new \coding_exception('Attempting to generate a page image without first setting the PDF filename');
 421          }
 422  
 423          if (!$this->imagefolder) {
 424              throw new \coding_exception('Attempting to generate a page image without first specifying the image output folder');
 425          }
 426  
 427          if (!is_dir($this->imagefolder)) {
 428              throw new \coding_exception('The specified image output folder is not a valid folder');
 429          }
 430  
 431          $imagefile = $this->imagefolder.'/image_page' . $pageno . '.png';
 432          $generate = true;
 433          if (file_exists($imagefile)) {
 434              if (filemtime($imagefile)>filemtime($this->filename)) {
 435                  // Make sure the image is newer than the PDF file.
 436                  $generate = false;
 437              }
 438          }
 439  
 440          if ($generate) {
 441              // Use ghostscript to generate an image of the specified page.
 442              $gsexec = \escapeshellarg($CFG->pathtogs);
 443              $imageres = \escapeshellarg(100);
 444              $imagefilearg = \escapeshellarg($imagefile);
 445              $filename = \escapeshellarg($this->filename);
 446              $pagenoinc = \escapeshellarg($pageno + 1);
 447              $command = "$gsexec -q -sDEVICE=png16m -dSAFER -dBATCH -dNOPAUSE -r$imageres -dFirstPage=$pagenoinc -dLastPage=$pagenoinc ".
 448                  "-dDOINTERPOLATE -dGraphicsAlphaBits=4 -dTextAlphaBits=4 -sOutputFile=$imagefilearg $filename";
 449  
 450              $output = null;
 451              $result = exec($command, $output);
 452              if (!file_exists($imagefile)) {
 453                  $fullerror = '<pre>'.get_string('command', 'assignfeedback_editpdf')."\n";
 454                  $fullerror .= $command . "\n\n";
 455                  $fullerror .= get_string('result', 'assignfeedback_editpdf')."\n";
 456                  $fullerror .= htmlspecialchars($result) . "\n\n";
 457                  $fullerror .= get_string('output', 'assignfeedback_editpdf')."\n";
 458                  $fullerror .= htmlspecialchars(implode("\n",$output)) . '</pre>';
 459                  throw new \moodle_exception('errorgenerateimage', 'assignfeedback_editpdf', '', $fullerror);
 460              }
 461          }
 462  
 463          return 'image_page'.$pageno.'.png';
 464      }
 465  
 466      /**
 467       * Check to see if PDF is version 1.4 (or below); if not: use ghostscript to convert it
 468       * @param stored_file $file
 469       * @return string path to copy or converted pdf (false == fail)
 470       */
 471      public static function ensure_pdf_compatible(\stored_file $file) {
 472          global $CFG;
 473  
 474          $temparea = \make_temp_directory('assignfeedback_editpdf');
 475          $hash = $file->get_contenthash(); // Use the contenthash to make sure the temp files have unique names.
 476          $tempsrc = $temparea . "/src-$hash.pdf";
 477          $tempdst = $temparea . "/dst-$hash.pdf";
 478          $file->copy_content_to($tempsrc); // Copy the file.
 479  
 480          $pdf = new pdf();
 481          $pagecount = 0;
 482          try {
 483              $pagecount = $pdf->load_pdf($tempsrc);
 484          } catch (\Exception $e) {
 485              // PDF was not valid - try running it through ghostscript to clean it up.
 486              $pagecount = 0;
 487          }
 488          $pdf->Close(); // PDF loaded and never saved/outputted needs to be closed.
 489  
 490          if ($pagecount > 0) {
 491              // Page is valid and can be read by tcpdf.
 492              return $tempsrc;
 493          }
 494  
 495          $gsexec = \escapeshellarg($CFG->pathtogs);
 496          $tempdstarg = \escapeshellarg($tempdst);
 497          $tempsrcarg = \escapeshellarg($tempsrc);
 498          $command = "$gsexec -q -sDEVICE=pdfwrite -dBATCH -dNOPAUSE -sOutputFile=$tempdstarg $tempsrcarg";
 499          exec($command);
 500          @unlink($tempsrc);
 501          if (!file_exists($tempdst)) {
 502              // Something has gone wrong in the conversion.
 503              return false;
 504          }
 505  
 506          $pdf = new pdf();
 507          $pagecount = 0;
 508          try {
 509              $pagecount = $pdf->load_pdf($tempdst);
 510          } catch (\Exception $e) {
 511              // PDF was not valid - try running it through ghostscript to clean it up.
 512              $pagecount = 0;
 513          }
 514          $pdf->Close(); // PDF loaded and never saved/outputted needs to be closed.
 515  
 516          if ($pagecount <= 0) {
 517              @unlink($tempdst);
 518              // Could not parse the converted pdf.
 519              return false;
 520          }
 521  
 522          return $tempdst;
 523      }
 524  
 525      /**
 526       * Test that the configured path to ghostscript is correct and working.
 527       * @param bool $generateimage - If true - a test image will be generated to verify the install.
 528       * @return bool
 529       */
 530      public static function test_gs_path($generateimage = true) {
 531          global $CFG;
 532  
 533          $ret = (object)array(
 534              'status' => self::GSPATH_OK,
 535              'message' => null,
 536          );
 537          $gspath = $CFG->pathtogs;
 538          if (empty($gspath)) {
 539              $ret->status = self::GSPATH_EMPTY;
 540              return $ret;
 541          }
 542          if (!file_exists($gspath)) {
 543              $ret->status = self::GSPATH_DOESNOTEXIST;
 544              return $ret;
 545          }
 546          if (is_dir($gspath)) {
 547              $ret->status = self::GSPATH_ISDIR;
 548              return $ret;
 549          }
 550          if (!is_executable($gspath)) {
 551              $ret->status = self::GSPATH_NOTEXECUTABLE;
 552              return $ret;
 553          }
 554  
 555          if (!$generateimage) {
 556              return $ret;
 557          }
 558  
 559          $testfile = $CFG->dirroot.'/mod/assign/feedback/editpdf/tests/fixtures/testgs.pdf';
 560          if (!file_exists($testfile)) {
 561              $ret->status = self::GSPATH_NOTESTFILE;
 562              return $ret;
 563          }
 564  
 565          $testimagefolder = \make_temp_directory('assignfeedback_editpdf_test');
 566          @unlink($testimagefolder.'/image_page0.png'); // Delete any previous test images.
 567  
 568          $pdf = new pdf();
 569          $pdf->set_pdf($testfile);
 570          $pdf->set_image_folder($testimagefolder);
 571          try {
 572              $pdf->get_image(0);
 573          } catch (\moodle_exception $e) {
 574              $ret->status = self::GSPATH_ERROR;
 575              $ret->message = $e->getMessage();
 576          }
 577          $pdf->Close(); // PDF loaded and never saved/outputted needs to be closed.
 578  
 579          return $ret;
 580      }
 581  
 582      /**
 583       * If the test image has been generated correctly - send it direct to the browser.
 584       */
 585      public static function send_test_image() {
 586          global $CFG;
 587          header('Content-type: image/png');
 588          require_once($CFG->libdir.'/filelib.php');
 589  
 590          $testimagefolder = \make_temp_directory('assignfeedback_editpdf_test');
 591          $testimage = $testimagefolder.'/image_page0.png';
 592          send_file($testimage, basename($testimage), 0);
 593          die();
 594      }
 595  
 596  }
 597