Source for file htmlexport.php

Documentation is available at htmlexport.php

  1. <?php
  2. /**
  3. * Construct an HTML export from 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/htmlexport.php
  13. */
  14.  
  15. /** Load ancillary functions */
  16. require_once 'inc/typeinfo.php';
  17. checkValidInclude();
  18.  
  19.  
  20. /** constants for defining export formatting and codes */
  21. require_once 'inc/exportcodes.php';
  22.  
  23. /**
  24. * Construct an HTML export from array representation
  25. *
  26. * @package    Bumblebee
  27. * @subpackage Export
  28. */
  29. class HTMLExport {
  30.   /** @var string       html-rendered data   */
  31.   var $export;
  32.   /** @var boolean      export the data as one big table with header rows between sections  */
  33.   var $bigtable = true;
  34.   /** @var ArrayExport  data to export    */
  35.   var $ea;
  36.   /** @var string       header to the report  */
  37.   var $header;
  38.  
  39.   /**
  40.   *  Create the HTMLExport object
  41.   *
  42.   * @param ArrayExport  &$exportArray 
  43.   */
  44.   function HTMLExport(&$exportArray) {
  45.     $this->ea =& $exportArray;
  46.   }
  47.  
  48.   /**
  49.   * convert the 2D array into an HTML table representation of the data
  50.   */
  51.   function makeHTMLBuffer() {
  52.     //$this->log('Making HTML representation of data');
  53.     $ea =& $this->ea->export;
  54.     $eol = "\n";
  55.     $metaData = $ea['metadata'];
  56.     unset($ea['metadata']);
  57.     $buf = '';
  58.     $numrows = count($ea);
  59.     for ($i=0; $i<$numrows; $i++) {
  60.       if (! $this->bigtable) {
  61.         switch ($ea[$i]['type']) {
  62.           case EXPORT_REPORT_START:
  63.             $buf .= '<div id="bumblebeeExport">';
  64.             break;
  65.           case EXPORT_REPORT_END:
  66.             $buf .= '</div>';
  67.             break;
  68.           case EXPORT_REPORT_HEADER:
  69.             $buf .= '<div class="exportHeader">'.xssqw($ea[$i]['data']).'</div>'.$eol;
  70.             $this->header = $ea[$i]['data'];
  71.             break;
  72.           case EXPORT_REPORT_SECTION_HEADER:
  73.             $buf .= '<div class="exportSectionHeader">'.xssqw($ea[$i]['data']).'</div>'.$eol;
  74.             break;
  75.           case EXPORT_REPORT_TABLE_START:
  76.             $tableMetaData = $ea[$i]['metadata'];
  77.             $numcols = $tableMetaData['numcols'];
  78.             $buf .= '<table class="exportdata">'.$eol;
  79.             break;
  80.           case EXPORT_REPORT_TABLE_END:
  81.             $buf .= '</table>'.$eol;
  82.             break;
  83.           case EXPORT_REPORT_TABLE_HEADER:
  84.             $buf .= '<tr class="header">'
  85.                         .$this->_formatRowHTML($ea[$i]['data'], true)
  86.                     .'</tr>'.$eol;
  87.             break;
  88.           case EXPORT_REPORT_TABLE_TOTAL:
  89.             $buf .= '<tr class="totals">'
  90.                         .$this->_formatRowHTML($ea[$i]['data'])
  91.                     .'</tr>'.$eol;
  92.             break;
  93.           case EXPORT_REPORT_TABLE_FOOTER:
  94.             $buf .= '<tr class="footer">'
  95.                         .$this->_formatRowHTML($ea[$i]['data'])
  96.                     .'</tr>'.$eol;
  97.             break;
  98.           case EXPORT_REPORT_TABLE_ROW:
  99.             $buf .= '<tr>'
  100.                         .$this->_formatRowHTML($ea[$i]['data'])
  101.                     .'</tr>'.$eol;
  102.             break;
  103.         }
  104.       } else {
  105.         switch ($ea[$i]['type']) {
  106.           case EXPORT_REPORT_START:
  107.             $buf .= '<div id="bumblebeeExport">';
  108.             break;
  109.           case EXPORT_REPORT_END:
  110.             $buf .= '</table></div>';
  111.             break;
  112.           case EXPORT_REPORT_HEADER:
  113.             $buf .= '<div class="exportHeader">'.xssqw($ea[$i]['data']).'</div>'.$eol;
  114.             $buf .= '<table class="exportdata">'.$eol;
  115.             break;
  116.           case EXPORT_REPORT_SECTION_HEADER:
  117.             $tableMetaData = $ea[$i]['metadata'];
  118.             $numcols = $tableMetaData['numcols'];
  119.             $buf .= '<tr class="exportSectionHeader"><td colspan="'.$numcols.'" class="exportSectionHeader">'
  120.                         .xssqw($ea[$i]['data']).'</td></tr>'.$eol;
  121.             break;
  122.           case EXPORT_REPORT_TABLE_START:
  123.             break;
  124.           case EXPORT_REPORT_TABLE_END:
  125.             break;
  126.           case EXPORT_REPORT_TABLE_HEADER:
  127.             $buf .= '<tr class="header">'
  128.                         .$this->_formatRowHTML($ea[$i]['data'], true)
  129.                     .'</tr>'.$eol;
  130.             break;
  131.           case EXPORT_REPORT_TABLE_FOOTER:
  132.             $buf .= '<tr class="footer">'
  133.                         .$this->_formatRowHTML($ea[$i]['data'])
  134.                     .'</tr>'.$eol;
  135.             break;
  136.           case EXPORT_REPORT_TABLE_TOTAL:
  137.             $buf .= '<tr class="totals">'
  138.                         .$this->_formatRowHTML($ea[$i]['data'])
  139.                     .'</tr>'.$eol;
  140.             break;
  141.           case EXPORT_REPORT_TABLE_ROW:
  142.             $buf .= '<tr>'
  143.                         .$this->_formatRowHTML($ea[$i]['data'])
  144.                     .'</tr>'.$eol;
  145.             break;
  146.         }
  147.       }
  148.       # unset($ea[$i]); //FIXME: try to free memory as we are using it
  149.     }
  150.     $this->export =& $buf;
  151.   }
  152.  
  153.   /**
  154.   * generate the HTML for a row
  155.   *
  156.   * @return string row
  157.   */
  158.   function _formatRowHTML($row, $isHeader=false) {
  159.     $b = '';
  160.     $numfields = count($row);  //FIXME: can this be cached?
  161.     for ($j=0; $j<$numfields; $j++) {
  162.       $b .= $this->_formatCellHTML($row[$j], $isHeader);
  163.     }
  164.     return $b;
  165.   }
  166.  
  167.   /**
  168.   * generate the HTML for a single cell
  169.   *
  170.   * @return string cell
  171.   */
  172.   function _formatCellHTML($d, $isHeader) {
  173.     $t = '';
  174.     $val = $d['value'];
  175.     if (! $isHeader) {
  176.       switch($d['format'] & EXPORT_HTML_ALIGN_MASK) {
  177.         case EXPORT_HTML_CENTRE:
  178.           $align='center';
  179.           break;
  180.         case EXPORT_HTML_LEFT:
  181.           $align='left';
  182.           break;
  183.         case EXPORT_HTML_RIGHT:
  184.           $align='right';
  185.           break;
  186.         default:
  187.           $align='';
  188.       }
  189.       $align = ($align!='' ? 'align='.$align : '');
  190.       $t .= '<td '.$align.'>'.htmlentities($val, ENT_QUOTES, 'UTF-8').'</td>';
  191.     } else {
  192.       $t .= '<th>'.htmlentities($val).'</th>';
  193.     }
  194.     return $t;
  195.   }
  196.  
  197.   /**
  198.   * embed the html within a blank page to create the report in a separate window
  199.   *
  200.   * @return string  html snippet that will open a new window with the html report
  201.   * @todo //TODO: potential memory hog (stores HTML output in three places at once)
  202.   */
  203.   function wrapHTMLBuffer() {
  204.     $conf = ConfigReader::getInstance();
  205.     $filename = $conf->value('export', 'htmlWrapperFile');
  206.     $fd = fopen($filename, 'r');
  207.     $contents = fread($fd, filesize ($filename));
  208.     fclose($fd);
  209.     $title = T_('Data export');
  210.     $table = preg_replace('/\$/', '&#'.ord('$').';', $this->export);
  211.     $contents = preg_replace('/__TITLE__/', $title, $contents);
  212.     $contents = preg_replace('/__BASEPATH__/', $conf->BasePath, $contents);
  213.     //return $contents;
  214.     //preDump($contents);
  215.     $contents = preg_replace('/__CONTENTS__/', $table, $contents);
  216.     //encode the HTML so that it doesn't get interpreted by the browser and cause big problems
  217.     //the PHP function rawurlencode() can be reversed by the JavaScript function unescape()
  218.     //which is then a convenient pairing to use rather than replacing everything manually.
  219.     $enchtml = rawurlencode($contents);
  220.     $jsbuf = '<script type="text/javascript">
  221. <!--
  222.   function BBwriteAll(data) {
  223.     bboutwin = window.open("", "bumblebeeOutput", "");
  224.     bboutwin.document.write(unescape(data));
  225.     bboutwin.document.close();
  226.   }
  227.  
  228.   data = "'.$enchtml.'";
  229.  
  230.   BBwriteAll(data);
  231.  
  232. //-->
  233. </script><a href="javascript:BBwriteAll(data)">'.T_('Open Window').'</a>';
  234.     return $jsbuf;
  235.   }
  236.  
  237.  
  238. } // class HTMLExport
  239.  
  240. ?>

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