Source for file jResponseLatexToPdf.class.php

Documentation is available at jResponseLatexToPdf.class.php

  1. <?php
  2. /**
  3. @package     jelix
  4. @subpackage  core_response
  5. @author      Aubanel Monnier
  6. @contributor Laurent Jouanneau, Thomas, Johannb
  7. @copyright   2007 Aubanel Monnier, 2009 Thomas, 2009 Laurent Jouanneau
  8. @link        http://aubanel.info
  9. @licence     GNU Lesser General Public Licence see LICENCE file or http://www.gnu.org/licenses/lgpl.html
  10. */
  11.  
  12. /**
  13. * pdf response, generated from a latex content
  14. @package  jelix
  15. @subpackage core_response
  16. @since 1.0b2
  17. */
  18. class jResponseLatexToPdf extends jResponse {
  19.     /**
  20.     * @var string 
  21.     */
  22.     protected $_type = 'ltx2pdf';
  23.     /**
  24.      * selector of the main template file
  25.      * This template should contains the body content, and is used by the $body template engine
  26.      * @var string 
  27.      */
  28.     public $bodyTpl = '';
  29.     /**
  30.      * The template engine used to generate the content
  31.      * @var jTpl 
  32.      */
  33.     public $body = null;
  34.     /**
  35.      * Authors of the document
  36.      * @var array 
  37.      */
  38.     public $authors = array();
  39.     /**
  40.      * Document title
  41.      * @var string 
  42.      */
  43.     public $title = '';
  44.     /**
  45.      * Document date
  46.      * @var string 
  47.      * @since 1.2
  48.      */
  49.     public $date = '\today';
  50.     
  51.     /**
  52.      * Contains the list of commands to write in the preamble.
  53.      * @var array 
  54.      */
  55.     protected $_commands=array();
  56.  
  57.     /**
  58.      * complete path to the pdflatex executable
  59.      * @var string 
  60.      */
  61.     public $pdflatexPath='pdflatex';
  62.  
  63.     /**
  64.      * path to the cache directory.
  65.      * default is directory responseLatexToPdf in temp directory
  66.      * @since 1.0
  67.      */
  68.     public $cachePath'';
  69.  
  70.     /**
  71.      * Document file name
  72.      * @var string 
  73.      * @since 1.2
  74.      */
  75.     public $outputFileName = 'document.pdf';
  76.  
  77.     /**
  78.      * constructor;
  79.      * setup the template engine
  80.      */
  81.     function __construct (){
  82.         $this->cachePath = JELIX_APP_TEMP_PATH.'responseLatexToPdf/';
  83.         $this->body = new jTpl();
  84.         parent::__construct();
  85.     }
  86.  
  87.     /**
  88.      * Add a command to the preamble, e.g. \documentclass[a4,11pt]{article}
  89.      * @param string $command name of the command to add
  90.      * @param string $argument argument of the command to add
  91.      * @param array $options options of the command to add
  92.      */
  93.     public function addCommand($command$argument$options=array()){
  94.         $cmd '\\'.$command;
  95.         if (count($options)) 
  96.             $cmd.='['.join(',',$options).']';
  97.         $this->_commands []$cmd.'{'.$argument.'}';
  98.     }
  99.  
  100.     /**
  101.      * A list of commands that can be safely used as default, or as a template for the _commonProcess function
  102.      * Tis function is called if the command stack is empty (useful to get quicly started)
  103.      */
  104.     public function addDefaultCommands(){
  105.         $this->addCommand('documentclass''article'array('a4''11pt'));
  106.         $this->addCommand('usepackage''fontenc'array('T1'));
  107.         $this->addCommand('usepackage''graphicx');
  108.         $this->addCommand('usepackage''geometry'array('pdftex'));
  109.         $this->addCommand('geometry''hmargin=1cm, vmargin=1cm');
  110.     }
  111.  
  112.     /**
  113.      * output the pdf content
  114.      *
  115.      * @return boolean    true if the generated content is ok
  116.      */
  117.     function output(){
  118.         $this->_commonProcess();
  119.         if (count($this->_commands<= 0//No commands, likewise we need some...
  120.             $this->addDefaultCommands();
  121.  
  122.         $data =  join("\n"$this->_commands).'
  123. \begin{document}
  124. \title{'.$this->title.'}
  125. \author{';
  126.         foreach ($this->authors as $a
  127.             $data.= $a.'\\\\'."\n";
  128.         $data.= '}
  129. \date{'.$this->date.'}
  130. ';
  131.         $data.=$this->body->fetch($this->bodyTpl);
  132.         $data.= '
  133.  
  134. \end{document}';
  135.  
  136.         $fbase='cache-'.md5($data);
  137.  
  138.         $texFile=$this->cachePath.$fbase.'.tex';
  139.         $pdfFile=$this->cachePath.$fbase.'.pdf';
  140.  
  141.         if (file_exists($pdfFile)){
  142.             // Naïve cache: we have an md5 on the content of the tex file. If the pdf 
  143.             // corresponding to this content already exists, just serve it. 
  144.             // No managment of cache deletion :o/
  145.             jFile::write($texFile$data);
  146.             $output=array();
  147.             $retVal=1;    
  148.             exec($this->pdflatexPath.' --interaction batchmode --output-directory '.$this->cachePath.' '.$texFile$output$retval);
  149.             if($retVal!=0){
  150.                 $outputStr=implode('<br />',$output);
  151.                 throw new jException('jelix~errors.ltx2pdf.exec',array($this->pdflatexPath$outputStr));
  152.             }
  153.         }
  154.         $this->_httpHeaders['Content-Type']='application/pdf';
  155.         $this->_httpHeaders['Content-length']=@filesize($pdfFile);
  156.         $this->_httpHeaders['Content-Disposition']='attachment; filename='.$this->outputFileName;
  157.         $this->sendHttpHeaders();
  158.  
  159.         readfile($pdfFile);
  160.         return true;
  161.     }
  162.  
  163.     /**
  164.      * The method you can overload in your inherited response
  165.      * overload it if you want to add processes (additionnal commands, content etc..)
  166.      * for all actions
  167.      */
  168.     protected function _commonProcess(){
  169.  
  170.     }
  171.  
  172.     /**
  173.      * Clears the cache directory
  174.      */
  175.     public function clearCache(){
  176.         jFile::removeDir($this->cachePathfalse);
  177.     }
  178.  
  179.     /**
  180.      * output errors
  181.      */
  182.     public function outputErrors(){
  183.         global $gJConfig;
  184.         header("HTTP/1.0 500 Internal Server Error");
  185.         header('Content-Type: text/plain;charset='.$gJConfig->charset);
  186.         if($this->hasErrors()){
  187.             foreach$GLOBALS['gJCoord']->errorMessages  as $e){
  188.                 echo '['.$e[0].' '.$e[1].'] '.$e[2]." \t".$e[3]." \t".$e[4]."\n";
  189.                 if ($e[5])
  190.                   echo $e[5]."\n\n";
  191.             }
  192.         }else{
  193.             echo "[unknown error]\n";
  194.         }
  195.     }
  196. }

Documentation generated on Thu, 19 Sep 2013 00:06:46 +0200 by phpDocumentor 1.4.3