Source for file pdfexport.php

Documentation is available at pdfexport.php

  1. <?php
  2. /**
  3. * Construct a PDF from the array representation
  4. *
  5. * @author    Stuart Prescott
  6. * @copyright  Copyright Stuart Prescott
  7. * @license    http://opensource.org/licenses/gpl-license.php GNU Public License
  8. * @version    $Id$
  9. * @package    Bumblebee
  10. * @subpackage Export
  11. *
  12. *  path (bumblebee root)/inc/export/pdfexport.php
  13. */
  14.  
  15. /** Load ancillary functions */
  16. require_once 'inc/typeinfo.php';
  17. checkValidInclude();
  18.  
  19. require_once 'inc/bb/configreader.php';
  20.  
  21. /** constants for defining export formatting and codes */
  22. require_once 'inc/exportcodes.php';
  23.  
  24. /** config and class libraries for PDF export */
  25. require_once 'inc/export/pdfexportconfig.php';
  26.  
  27. define('PDF_FONT', 'Arial');
  28.  
  29. /**
  30. * Construct a PDF from the array representation
  31. *
  32. * @package    Bumblebee
  33. * @subpackage Export
  34. */
  35. class PDFExport {
  36.   var $ea;
  37.   var $pdf;
  38.   var $export;
  39.   var $filename = '/tmp/test.pdf';
  40.   var $writeToFile = false;
  41.  
  42.   var $orientation = 'L';
  43.   var $size = 'A4';
  44.   var $pageWidth   = 297;   // mm
  45.     var $pageHeight  = 210;   // mm
  46.     var $leftMargin  = 15;    // mm
  47.     var $rightMargin = 15;    // mm
  48.     var $topMargin   = 15;    // mm
  49.     var $bottomMargin= 15;    // mm
  50.  
  51.   
  52.   var $minAutoMargin = 4;   // mm added to auto calc'd column widths
  53.     var $tableHeaderAlignment = 'L';
  54.   var $rowLines = '';  // use 'T' for lines between rows
  55.     var $headerLines = 'TB';    // Top and Bottom lines on the header rows
  56.  
  57.   
  58.   var $fontSubstitutionTable;
  59.  
  60.   var $normalLineHeight = 5;
  61.   var $headerLineHeight = 6;
  62.   var $footerLineHeight = 4;
  63.   var $doubleLineWidth  = 0.2;
  64.   var $singleLineWidth  = 0.3;
  65.   var $sectionHeaderLineHeight = 8;
  66.   var $singleCellTopMargin    = 1;
  67.  
  68.   var $normalFillColor = array(224,235,255);
  69.   var $normalDrawColor = array(  0,  0,  0);
  70.   var $normalTextColor = array(  0,  0,  0);
  71.   var $normalFont      = array(PDF_FONT,'',12);
  72.  
  73.   var $sectionHeaderFillColor = array(255,255,255);
  74.   var $sectionHeaderDrawColor = array(  0,  0,  0);
  75.   var $sectionHeaderTextColor = array(  0,  0,  0);
  76.   var $sectionHeaderFont      = array(PDF_FONT,'B',14);
  77.  
  78.   var $tableHeaderFillColor = array(  0,  0,128);
  79.   var $tableHeaderDrawColor = array(  0,  0,  0);
  80.   var $tableHeaderTextColor = array(255,255,255);
  81.   var $tableHeaderFont      = array(PDF_FONT,'B',12);
  82.  
  83.   var $tableFooterFillColor = array(  0,  0,128);
  84.   var $tableFooterDrawColor = array(  0,  0,  0);
  85.   var $tableFooterTextColor = array(255,255,255);
  86.   var $tableFooterFont      = array(PDF_FONT,'',9);
  87.  
  88.   var $tableTotalFillColor = array(224,235,255);
  89.   var $tableTotalDrawColor = array(  0,  0,  0);
  90.   var $tableTotalTextColor = array(  0,  0,  0);
  91.   var $tableTotalFont      = array(PDF_FONT,'',12);
  92.  
  93.  
  94.  
  95.   var $cols = array(); //=array(50,20,20,20,20,20,20,20);   //column widths
  96.     var $colStart = array();
  97.   var $tableRow = 0;
  98.  
  99.   var $useBigTable = true;
  100.  
  101.   var $DEBUG = 0;
  102.  
  103.   function PDFExport(&$exportArray) {
  104.     $this->ea = $exportArray;
  105.     $this->_readConfig();
  106.   }
  107.  
  108.   function makePDFBuffer() {
  109.     $this->render();
  110.     $this->export = $this->Output();
  111.   }
  112.  
  113.   function render() {
  114.     $this->pdf = new TabularPDF($this->orientation, 'mm', $this->size);
  115.     $this->_setMetaInfo();
  116.     $this->_setPageMargins();
  117.     $this->_setTableAttributes();
  118.     $this->pdf->AliasNbPages();
  119.     #$this->pdf->AddPage();  //should we always include a page to start with?
  120.     $this->_parseArray();
  121.   }
  122.  
  123.   function Output() {
  124.     if ($this->writeToFile) {
  125.       return $this->pdf->Output($this->filename, 'F');
  126.     } else {
  127.       return $this->pdf->Output('', 'S');
  128.     }
  129.   }
  130.  
  131.   function _setMetaInfo() {
  132.     $metaData = $this->ea->export['metadata'];
  133.     $this->pdf->SetCreator($metaData['creator']);
  134.     $this->pdf->SetAuthor($metaData['author']);
  135.     $this->pdf->SetKeywords($metaData['keywords']);
  136.     $this->pdf->SetSubject($metaData['subject']);
  137.     $this->pdf->SetTitle($metaData['title']);
  138.     $this->pdf->title = $metaData['title'];
  139.   }
  140.  
  141.   function _readConfig() {
  142.     $conf = ConfigReader::getInstance();
  143.     $simplevars = array(
  144.       'orientation', 'size', 'pageWidth', 'pageHeight',
  145.       'leftMargin', 'rightMargin', 'topMargin', 'bottomMargin',
  146.       'minAutoMargin', 'tableHeaderAlignment', 'rowLines', 'headerLines',
  147.       'normalLineHeight', 'headerLineHeight', 'footerLineHeight', 'sectionHeaderLineHeight',
  148.       'doubleLineWidth', 'singleLineWidth', 'singleCellTopMargin'
  149.       );
  150.     $cxvars = array(
  151.       'normalFillColor', 'normalDrawColor', 'normalTextColor', 'normalFont',
  152.       'sectionHeaderFillColor', 'sectionHeaderDrawColor', 'sectionHeaderTextColor',  'sectionHeaderFont',
  153.       'tableHeaderFillColor', 'tableHeaderDrawColor', 'tableHeaderTextColor', 'tableHeaderFont',
  154.       'tableFooterFillColor', 'tableFooterDrawColor', 'tableFooterTextColor', 'tableFooterFont',
  155.       'tableTotalFillColor', 'tableTotalDrawColor', 'tableTotalTextColor', 'tableTotalFont'
  156.       );
  157.     foreach ($simplevars as $v) {
  158.       $this->$v = $conf->value('pdfexport', $v);
  159.     }
  160.     foreach ($cxvars as $v) {
  161.       $val = $conf->value('pdfexport', $v);
  162.       $this->$v = $this->_confSplit($val);
  163.     }
  164.  
  165.     $fonts = $conf->value('pdfexport', 'fontSubstitutions');
  166.     $fontList = preg_split('@[,;\n\r]@', $fonts);
  167.     $fontTable = array();
  168.     foreach ($fontList as $font) {
  169.       $line = explode('=', $font);
  170.       if (count($line) == 2) {
  171.         $fontTable["@$line[0]@i"] = $line[1];
  172.       }
  173.     }
  174.     $this->fontSubstitutionTable = $fontTable;
  175.   }
  176.  
  177.   function _confSplit($c) {
  178.     return explode(',', $c);
  179.   }
  180.  
  181.   function _setPageMargins() {
  182.     $this->pdf->SetMargins($this->leftMargin, $this->topMargin, $this->rightMargin);
  183.     $this->pdf->SetAutoPageBreak(true, $this->bottomMargin);
  184.     $vars = array('pageWidth', 'pageHeight', 'leftMargin', 'rightMargin', 'topMargin', 'bottomMargin', 'minAutoMargin', 'tableHeaderAlignment', 'rowLines', 'headerLines');
  185.     foreach ($vars as $v) {
  186.       $this->pdf->$v = $this->$v;
  187.     }
  188.   }
  189.  
  190.   function _setTableAttributes() {
  191.     $vars = array(
  192.       'normalLineHeight', 'headerLineHeight', 'footerLineHeight', 'sectionHeaderLineHeight',
  193.       'doubleLineWidth', 'singleLineWidth', 'singleCellTopMargin',
  194.       'normalFillColor', 'normalDrawColor', 'normalTextColor', 'normalFont',
  195.       'sectionHeaderFillColor', 'sectionHeaderDrawColor', 'sectionHeaderTextColor',  'sectionHeaderFont',
  196.       'tableHeaderFillColor', 'tableHeaderDrawColor', 'tableHeaderTextColor', 'tableHeaderFont',
  197.       'tableFooterFillColor', 'tableFooterDrawColor', 'tableFooterTextColor', 'tableFooterFont',
  198.       'tableTotalFillColor', 'tableTotalDrawColor', 'tableTotalTextColor', 'tableTotalFont',
  199.       'fontSubstitutionTable'
  200.       );
  201.     foreach ($vars as $v) {
  202.       $this->pdf->$v = $this->$v;
  203.     }
  204.   }
  205.  
  206.   /**
  207.   * calculate column widths
  208.   *
  209.   * @todo //TODO: make sure PDF columns don't go over right side of page
  210.   */
  211.   function _calcColWidths($widths, $entry) {
  212.     if ($this->useBigTable && count($this->cols)) return;
  213.     $this->log('Calculating column widths');
  214.     //preDump($widths);
  215.     //preDump($entry);
  216.     $sum = 0;
  217.     $this->cols = array();
  218.     for ($col = 0; $col<count($widths); $col++) {
  219.       if ($widths[$col] == '*') {
  220.         $this->cols[$col] = $this->_getColWidth($col, $entry);
  221.       } else {
  222.         $sum += $widths[$col];
  223.       }
  224.     }
  225.     $taken = array_sum($this->cols);
  226.     //if ($taken > ($this->pageWidth-$this->leftMargin-$this->rightMargin)) {
  227.       ///FIXME: must not go over page right
  228.     for ($col = 0; $col<count($widths); $col++) {
  229.       if (! isset($this->cols[$col])) {
  230.         $this->cols[$col] = $widths[$col]
  231.                   / $sum*($this->pageWidth-$this->leftMargin-$this->rightMargin-$taken);
  232.       }
  233.     }
  234.     $this->pdf->cols = $this->cols;
  235.   }
  236.  
  237.   /**
  238.   * Calculate the width of an actual column
  239.   *
  240.   * @todo //TODO: calculate width of header from actual header data (bold) rather than 1.1 * non-bold
  241.   */
  242.   function _getColWidth($col, $entry) {
  243.     //why are we doing lots of calls into the pdf here? is it bad encapsulation?
  244.     //We have to have a font chosen within FPDF to perform these length calculations
  245.     $this->pdf->_setTableFont();
  246.     $ea =& $this->ea->export;
  247.     $i=0;
  248.     $width = 0;
  249.     for ($key=$entry;
  250.         $key<count($ea)-1 && ($this->useBigTable || $ea[$key]['type'] != EXPORT_REPORT_TABLE_END);
  251.         $key++) {
  252.       //$this->log('key='.$key);
  253.       if (is_array($ea[$key]['data'])) { // protect against headers
  254.         $newWidth = $this->pdf->GetStringWidth($ea[$key]['data'][$col]['value']);
  255.         if ($ea[$key]['type'] == EXPORT_REPORT_TABLE_HEADER)
  256.           $newWidth *= 1.1;     //FIXME: we should do this calculation properly!
  257.         //echo "VAL=".$ea[$key]['data'][$col]['value'].", WIDTH=$newWidth/$width.<br/>";
  258.         $width = max($width, $newWidth);
  259.       }
  260.     }
  261.     //echo "WIDTH=$width.<br/>";
  262.     return $width + $this->minAutoMargin;
  263.   }
  264.  
  265.   function _getColWidthRand($col) {
  266.     //FIXME: is this random thing good enough? what about fitting in the header?
  267.     //why are we doing lots of calls into the pdf here? is it bad encapsulation?
  268.     //We have to have a font chosen within FPDF to perform these length calculations
  269.     $this->pdf->_setTableFont();
  270.     $ea =& $this->ea->export;
  271.     $i=0;
  272.     $width = 0; $header = 0;
  273.     while ($rows<10 || $header<1) {
  274.       $key = array_rand($ea, 1);
  275.       //echo $key;
  276.       if (is_numeric($key) && $ea[$key]['type'] == EXPORT_REPORT_TABLE_ROW) {
  277.         $rows++;
  278.         $newWidth = $this->pdf->GetStringWidth($ea[$key]['data'][$col]['value']);
  279.         //echo "VAL=".$ea[$key]['data'][$col]['value'].", WIDTH=$newWidth/$width.<br/>";
  280.         $width = max($width, $newWidth);
  281.      } elseif (is_numeric($key) && $ea[$key]['type'] == EXPORT_REPORT_TABLE_HEADER) {
  282.         $header++;
  283.         $newWidth = 1.1*$this->pdf->GetStringWidth($ea[$key]['data'][$col]['value']);
  284.         //echo "VAL=".$ea[$key]['data'][$col]['value'].", WIDTH=$newWidth/$width.<br/>";
  285.         $width = max($width, $newWidth);
  286.      }
  287.     }
  288.     //echo "WIDTH=$width.<br/>";
  289.     return $width + $this->minAutoMargin;
  290.   }
  291.  
  292.   function _parseArray() {
  293.     //$this->log('Making HTML representation of data');
  294.     $ea =& $this->ea->export;
  295.     $metaData = $ea['metadata'];
  296.     unset($ea['metadata']);
  297.     $ea_length = count($ea);
  298.     $this->log('Found '.$ea_length.' rows in this ExportArray');
  299.     for ($i=0; $i<$ea_length; $i++) {
  300.       #echo $i.': '.$ea[$i]['type'].'<br/>';
  301.       #preDump($ea[$i]);
  302.       switch ($ea[$i]['type']) {
  303.         case EXPORT_REPORT_START:
  304.           $this->pdf->reportStart();
  305.           break;
  306.         case EXPORT_REPORT_END:
  307.           $this->pdf->reportEnd();
  308.           //$i = count($ea);
  309.           break;
  310.         case EXPORT_REPORT_HEADER:
  311.           $this->pdf->reportHeader($ea[$i]['data']);
  312.           break;
  313.         case EXPORT_REPORT_SECTION_HEADER:
  314.           $this->_calcColWidths($ea[$i]['metadata']['colwidths'], $i);
  315.           $this->pdf->sectionHeader($ea[$i]['data']);
  316.           break;
  317.         case EXPORT_REPORT_TABLE_START:
  318.           $this->tableRow=0;
  319.           $this->pdf->tableStart();
  320.           break;
  321.         case EXPORT_REPORT_TABLE_END:
  322.           $this->pdf->tableEnd();
  323.           break;
  324.         case EXPORT_REPORT_TABLE_HEADER:
  325.           $this->pdf->tableHeader($this->_formatRow($ea[$i]['data'], true));
  326.           break;
  327.         case EXPORT_REPORT_TABLE_TOTAL:
  328.           $this->pdf->tableTotal($this->_formatRow($ea[$i]['data'], false, 'TT'));
  329.           break;
  330.         case EXPORT_REPORT_TABLE_FOOTER:
  331.           $this->pdf->tableFooter($this->_formatRow($ea[$i]['data']));
  332.           break;
  333.         case EXPORT_REPORT_TABLE_ROW:
  334.           $this->pdf->tableRow($this->_formatRow($ea[$i]['data']));
  335.           $this->tableRow++;
  336.           break;
  337.       }
  338.       # unset($ea[$i]);
  339.       /// FIXME: free memory as we are using it up
  340.     }
  341.   }
  342.  
  343.   function _formatRow($row, $isHeader=false, $border=NULL) {
  344.     $rowpdf = array();
  345.     for ($j=0; $j<count($row); $j++) {
  346.       $rowpdf[] = $this->_formatCell($row[$j], $j, $isHeader, $border);
  347.     }
  348.     return $rowpdf;
  349.   }
  350.  
  351.   function _formatCell($d, $col, $isHeader, $setborder) {
  352.     $val = $d['value'];
  353.     if (! $isHeader) {
  354.       switch($d['format'] & EXPORT_HTML_ALIGN_MASK) {
  355.         case EXPORT_HTML_LEFT:
  356.           $align='L';
  357.           break;
  358.         case EXPORT_HTML_RIGHT:
  359.           $align='R';
  360.           break;
  361.         case EXPORT_HTML_CENTRE:
  362.         default:
  363.           $align='C';
  364.       }
  365.       $fill = $this->tableRow % 2;
  366.       $border = $this->rowLines;
  367.     } else {
  368.       $align = $this->tableHeaderAlignment;
  369.       $fill = 1;
  370.       $border = $this->headerLines;
  371.     }
  372.     if (isset($setborder)) {
  373.       $border = $setborder;
  374.     }
  375.     return array('align'=>$align, 'value'=>$val, 'fill'=>$fill, 'border'=>$border);
  376.   }
  377.  
  378.   function log ($string, $prio=10) {
  379.     if ($prio <= $this->DEBUG) {
  380.       echo $string."<br />\n";
  381.     }
  382.   }
  383.  
  384. }  //  class PDFExport
  385.  
  386.  
  387. /**
  388. * PDF class that extends FPDF by putting the logo in the top corner
  389. *
  390. * @package    Bumblebee
  391. * @subpackage Export
  392. */
  393. class BrandedPDF extends TCPDF {
  394.   var $title;
  395.   var $pageWidth   = 297;   // mm
  396.     var $pageHeight  = 210;   // mm
  397.     var $leftMargin  = 15;    // mm
  398.     var $rightMargin = 15;    // mm
  399.     var $topMargin   = 15;    // mm
  400.     var $bottomMargin= 15;    // mm
  401.  
  402.   
  403.   var $fontSubstitutionTable;
  404.  
  405.   var $DEBUG = 0;
  406.  
  407.   function BrandedPDF($orientation, $measure, $format) {
  408.     parent::TCPDF($orientation, $measure, $format);
  409.     $this->title = T_('Bumblebee Report');
  410.   }
  411.  
  412.   function Header() {
  413.     //Logo
  414.     $this->Image('theme/export/logo.png',10,8,33);
  415.     //Arial bold 15
  416.     $this->SetFont(PDF_FONT,'B',15);
  417.     //Move to the right
  418.     $this->Cell(40);
  419.     //Title
  420.     $this->Cell(200,30,$this->title,0,0,'C');
  421.     //Line break
  422.     $this->Ln(30);
  423.   }
  424.  
  425.   //Page footer
  426.     function Footer() {
  427.     //Position at 1.5 cm from bottom
  428.     $this->SetY(-15);
  429.     //Arial italic 8
  430.     $this->SetFont(PDF_FONT,'I',8);
  431.     //Page number
  432.     $this->Cell(0,10,'Page '.$this->PageNo().'/{nb}',0,0,'C');
  433.   }
  434.  
  435.   function SetFillColor($r=0, $g=0, $b=0) {
  436.     if (is_array($r)) {
  437.       return parent::SetFillColor($r[0], $r[1], $r[2]);
  438.     } else {
  439.       return parent::SetFillColor($r, $g, $b);
  440.     }
  441.   }
  442.  
  443.   function SetDrawColor($r=0, $g=0, $b=0) {
  444.     if (is_array($r)) {
  445.       return parent::SetDrawColor($r[0], $r[1], $r[2]);
  446.     } else {
  447.       return parent::SetDrawColor($r, $g, $b);
  448.     }
  449.   }
  450.  
  451.   function SetTextColor($r=0, $g=0, $b=0) {
  452.     if (is_array($r)) {
  453.       return parent::SetTextColor($r[0], $r[1], $r[2]);
  454.     } else {
  455.       return parent::SetTextColor($r, $g, $b);
  456.     }
  457.   }
  458.  
  459.   function SetFont($font=0, $style=0, $size=0) {
  460.     if (is_array($font)) {
  461.       return parent::SetFont($this->_substituteFont($font[0]), $font[1], $font[2]);
  462.     } else {
  463.       return parent::SetFont($this->_substituteFont($font), $style, $size);
  464.     }
  465.   }
  466.  
  467.   function _substituteFont($fontName) {
  468.     return preg_replace(array_keys($this->fontSubstitutionTable),
  469.                         array_values($this->fontSubstitutionTable),
  470.                         $fontName);
  471.   }
  472.  
  473.   function log ($string, $prio=10) {
  474.     if ($prio <= $this->DEBUG) {
  475.       echo $string."<br />\n";
  476.     }
  477.   }
  478.  
  479.   // overload the error function to give us some better output
  480.     function Error($msg) {
  481.     echo '<div class="error"><b>'.T_('Error generating PDF output:').'</b><br/> '.$msg
  482.         .'<br/><br/>'.T_('Sorry things didn\'t work out for you.').'</div>';
  483.     if ($this->DEBUG) {
  484.       preDump(debug_backtrace());
  485.     }
  486.     die(T_('Exiting with error'));
  487.   }
  488.  
  489. } // class BrandedPDF
  490.  
  491.  
  492. /**
  493. * PDF class that extends BrandedPDF by providing functions for representing row data.
  494. *
  495. * Table-managing code adapted from Olivier's FPDF examples:
  496. *      http://www.fpdf.org/en/script/script3.php
  497. *
  498. * @package    Bumblebee
  499. * @subpackage Export
  500. */
  501. class TabularPDF extends BrandedPDF {
  502.  
  503.   var $_last_sectionHeader;
  504.   var $_last_tableHeader;
  505.   var $_preventNewPage;
  506.  
  507.   var $continuedHeader;
  508.  
  509.   var $lineHeight;
  510.   var $normalLineHeight = 5;
  511.   var $headerLineHeight = 6;
  512.   var $footerLineHeight = 4;
  513.   var $doubleLineWidth  = 0.2;
  514.   var $singleLineWidth  = 0.3;
  515.   var $sectionHeaderLineHeight = 8;
  516.   var $cellTopMargin;
  517.   var $singleCellTopMargin    = 1;
  518.  
  519.   var $normalFillColor = array(224,235,255);
  520.   var $normalDrawColor = array(  0,  0,  0);
  521.   var $normalTextColor = array(  0,  0,  0);
  522.   var $normalFont      = array(PDF_FONT,'',12);
  523.  
  524.   var $sectionHeaderFillColor = array(255,255,255);
  525.   var $sectionHeaderDrawColor = array(  0,  0,  0);
  526.   var $sectionHeaderTextColor = array(  0,  0,  0);
  527.   var $sectionHeaderFont      = array(PDF_FONT,'B',14);
  528.  
  529.   var $tableHeaderFillColor = array(  0,  0,128);
  530.   var $tableHeaderDrawColor = array(  0,  0,  0);
  531.   var $tableHeaderTextColor = array(255,255,255);
  532.   var $tableHeaderFont      = array(PDF_FONT,'B',12);
  533.  
  534.   var $tableFooterFillColor = array(  0,  0,128);
  535.   var $tableFooterDrawColor = array(  0,  0,  0);
  536.   var $tableFooterTextColor = array(255,255,255);
  537.   var $tableFooterFont      = array(PDF_FONT,'',9);
  538.  
  539.   var $tableTotalFillColor = array(224,235,255);
  540.   var $tableTotalDrawColor = array(  0,  0,  0);
  541.   var $tableTotalTextColor = array(  0,  0,  0);
  542.   var $tableTotalFont      = array(PDF_FONT,'',12);
  543.  
  544.   function TabularPDF($orientation, $measure, $format) {
  545.     parent::BrandedPDF($orientation, $measure, $format);
  546.     $this->continuedHeader = ' '.T_('(continued)');
  547.   }
  548.  
  549.  
  550.   function _setTableFont() {
  551.     $this->SetFillColor($this->normalFillColor);
  552.     $this->SetDrawColor($this->normalDrawColor);
  553.     $this->SetLineWidth($this->singleLineWidth);
  554.     $this->SetTextColor($this->normalTextColor);
  555.     $this->SetFont($this->normalFont);
  556.     $this->lineHeight = $this->normalLineHeight;
  557.     $this->cellTopMargin = $this->singleCellTopMargin;
  558.   }
  559.  
  560.   function _setSectionHeaderFont() {
  561.     $this->SetFillColor($this->sectionHeaderFillColor);
  562.     $this->SetDrawColor($this->sectionHeaderDrawColor);
  563.     $this->SetLineWidth($this->singleLineWidth);
  564.     $this->SetTextColor($this->sectionHeaderTextColor);
  565.     $this->SetFont($this->sectionHeaderFont);
  566.     $this->lineHeight = $this->normalLineHeight;
  567.     $this->cellTopMargin = $this->singleCellTopMargin;
  568.   }
  569.  
  570.   function _setTableHeaderFont() {
  571.     $this->SetFillColor($this->tableHeaderFillColor);
  572.     $this->SetDrawColor($this->tableHeaderDrawColor);
  573.     $this->SetLineWidth($this->singleLineWidth);
  574.     $this->SetTextColor($this->tableHeaderTextColor);
  575.     $this->SetFont($this->tableHeaderFont);
  576.     $this->lineHeight = $this->headerLineHeight;
  577.     $this->cellTopMargin = $this->singleCellTopMargin;
  578.   }
  579.  
  580.   function _setTableFooterFont() {
  581.     $this->SetFillColor($this->tableFooterFillColor);
  582.     $this->SetDrawColor($this->tableFooterDrawColor);
  583.     $this->SetLineWidth($this->singleLineWidth);
  584.     $this->SetTextColor($this->tableFooterTextColor);
  585.     $this->SetFont($this->tableFooterFont);
  586.     $this->lineHeight = $this->footerLineHeight;
  587.     $this->cellTopMargin = $this->singleCellTopMargin;
  588.   }
  589.  
  590.   function _setTableTotalFont() {
  591.     $this->SetFillColor($this->tableTotalFillColor);
  592.     $this->SetDrawColor($this->tableTotalDrawColor);
  593.     $this->SetLineWidth($this->doubleLineWidth);
  594.     $this->SetTextColor($this->tableTotalTextColor);
  595.     $this->SetFont($this->tableTotalFont);
  596.     $this->lineHeight = $this->normalLineHeight; //+ 4*$this->doubleLineWidth;
  597.     $this->cellTopMargin = $this->singleCellTopMargin + 4*$this->doubleLineWidth;
  598.   }
  599.  
  600.   function sectionHeader($header, $skipAddPage=false) {
  601.     if (!$skipAddPage) {
  602.       $this->AddPage();                  // FIXME: doesn't add a page if no section header??
  603.       $this->_last_sectionHeader = $header;
  604.     }
  605.     //Colors, line width and bold font
  606.     $this->_setSectionHeaderFont();
  607.     $this->_row(array(array('value'=>$header,'border'=>'','align'=>'L', 'fill'=>true, 'fullWidth'=>1)));
  608.     $this->_setTableFont();
  609.     $this->lineHeight = $this->sectionHeaderLineHeight;
  610. }
  611.  
  612.   function repeatSectionHeader() {
  613.     $this->sectionHeader($this->_last_sectionHeader.$this->continuedHeader, true);
  614.   }
  615.  
  616.   function repeatTableHeader() {
  617.     $this->tableHeader($this->_last_tableHeader);
  618.   }
  619.  
  620.   function reportStart() {
  621.   }
  622.  
  623.   function reportHeader() {
  624.   }
  625.  
  626.   function reportEnd() {
  627.   }
  628.  
  629.   function tableStart() {
  630.   }
  631.  
  632.   function tableHeader($data) {
  633.     $this->_setTableHeaderFont();
  634.     //$data[0]['fullWidth'] = 1;
  635.     $this->_row($data);
  636.     $this->_last_tableHeader = $data;
  637.     $this->_setTableFont();
  638.   }
  639.  
  640.   function tableFooter($data) {
  641.     $this->_setTableFooterFont();
  642.     $this->_row($data);
  643.     $this->_setTableFont();
  644.   }
  645.  
  646.   function tableTotal($data) {
  647.     $this->_setTableTotalFont();
  648.     $this->_row($data);
  649.     $this->_setTableFont();
  650.   }
  651.  
  652.   function tableEnd() {
  653.     $this->_preventNewPage = true;
  654.     $currHeight = $this->lineHeight;
  655.     $this->lineHeight = 0.1;
  656.     $this->_row(array(array('value'=>'','border'=>'T','fill'=>false,'fullWidth'=>0)));
  657.     $this->lineHeight = $currHeight;
  658.     $this->_preventNewPage = false;
  659.   }
  660.  
  661.   function tableRow($data) {
  662.     $this->_row($data);
  663.   }
  664.  
  665.   function _row($data) {
  666.     $widths = array();
  667.     if (count($data) == 1 && isset($data[0]['fullWidth']) && $data[0]['fullWidth'] == 1) {
  668.       $widths[0] = $this->pageWidth - $this->leftMargin - $this->rightMargin;
  669.     } elseif (count($data) == 1) {
  670.       $widths[0] = array_sum($this->cols);
  671.     } else {
  672.       $widths = $this->cols;
  673.     }
  674.     //Calculate the height of the row
  675.     $nb=0;
  676.     for($i=0; $i<count($data); $i++)
  677.         $nb=max($nb, $this->NbLines($widths[$i], $data[$i]['value']));
  678.     $rowHeight = $this->lineHeight*$nb + $this->cellTopMargin;
  679.     //Issue a page break first if needed
  680.     $this->CheckPageBreak($rowHeight);
  681.     $y0bg  = $this->GetY();
  682.     $y0txt = $y0bg + $this->cellTopMargin;
  683.     //Draw the cells of the row
  684.     $this->SetY($y0txt);
  685.     for($i=0; $i<count($data); $i++) {
  686.       $align=isset($data[$i]['align']) ? $data[$i]['align'] : 'L';
  687.       //Save the current position
  688.       $x = $this->GetX();
  689.       //$y = $this->GetY();
  690.       //Draw the background of the cell if appropriate
  691.       if ($data[$i]['fill'])
  692.         $this->Rect($x, $y0bg, $widths[$i], $rowHeight+$this->cellTopMargin, 'F');
  693.       //Draw the borders requested
  694.       if ($data[$i]['border']) {
  695.         if (strpos($data[$i]['border'], 'B') !== false) {
  696.           //echo 'B';
  697.           $this->line($x,             $y0txt+$rowHeight, $x+$widths[$i], $y0txt+$rowHeight);
  698.         }
  699.         if (strpos($data[$i]['border'], 'T') !== false) {
  700.           //echo 'T';
  701.           $this->line($x,             $y0bg,            $x+$widths[$i], $y0bg);
  702.         }
  703.         if (strpos($data[$i]['border'], 'TT') !== false) {
  704.           //double line on the top of the cell
  705.           $dy=$this->doubleLineWidth*3; //mm
  706.           $this->line($x,             $y0bg+$dy,        $x+$widths[$i], $y0bg+$dy);
  707.         }
  708.         if (strpos($data[$i]['border'], 'L') !== false) {
  709.           //echo 'L';
  710.           $this->line($x,             $y0bg,            $x,             $y0txt+$rowHeight);
  711.         }
  712.         if (strpos($data[$i]['border'], 'R') !== false) {
  713.           //echo 'R';
  714.           $this->line($x+$widths[$i], $y0bg,            $x+$widths[$i], $y0txt+$rowHeight);
  715.         }
  716.       }
  717.       //Print the text
  718.       $this->MultiCell($widths[$i], $this->lineHeight, $data[$i]['value'], '', $align, 0);
  719.       //Put the position to the right of the cell
  720.       $this->SetXY($x+$widths[$i],$y0txt);
  721.     }
  722.     //Go to the next line
  723.     $this->Ln($rowHeight);
  724.   }
  725.  
  726.   function CheckPageBreak($h) {
  727.     //If the height h would cause an overflow, add a new page immediately
  728.     if(! $this->_preventNewPage && $this->GetY()+$h>$this->PageBreakTrigger) {
  729.       $this->tableEnd();
  730.       $this->AddPage($this->CurOrientation);
  731.       $this->repeatSectionHeader();
  732.       $this->repeatTableHeader();
  733.     }
  734.   }
  735.  
  736.   function AcceptPageBreak() {
  737.     return ! $this->_preventNewPage;
  738.   }
  739.  
  740.   function NbLines($w,$txt) {
  741.     //Computes the number of lines a MultiCell of width w will take
  742.     $cw=&$this->CurrentFont['cw'];
  743.     if($w==0)
  744.         $w=$this->w-$this->rMargin-$this->x;
  745.     $wmax=($w-2*$this->cMargin)*1000/$this->FontSize;
  746.     $s=str_replace("\r",'',$txt);
  747.     $nb=strlen($s);
  748.     if($nb>0 and $s[$nb-1]=="\n")
  749.         $nb--;
  750.     $sep=-1;
  751.     $i=0;
  752.     $j=0;
  753.     $l=0;
  754.     $nl=1;
  755.     while($i<$nb)  {
  756.         $c=$s[$i];
  757.         if($c=="\n") {
  758.             $i++;
  759.             $sep=-1;
  760.             $j=$i;
  761.             $l=0;
  762.             $nl++;
  763.             continue;
  764.         }
  765.         if($c==' ')
  766.             $sep=$i;
  767.         if(isset($cw[ord($c)])) {
  768.           $l+=$cw[ord($c)];
  769.         } else {
  770.           /// FIXME: Making up a width... probably should warn the user
  771.           $l+=$cw[ord('a')];
  772.         }
  773.         if($l>$wmax) {
  774.             if($sep==-1)
  775.             {
  776.                 if($i==$j)
  777.                     $i++;
  778.             }
  779.             else
  780.                 $i=$sep+1;
  781.             $sep=-1;
  782.             $j=$i;
  783.             $l=0;
  784.             $nl++;
  785.         }
  786.         else
  787.             $i++;
  788.     }
  789.     return $nl;
  790.   }
  791.  
  792.  
  793. } // class TabularPDF
  794.  
  795. ?>

Documentation generated on Tue, 06 Mar 2007 10:01:52 +0000 by phpDocumentor 1.3.0