Source for file BIFFwriter.php

Documentation is available at BIFFwriter.php

  1. <?php
  2. /*
  3. *  Module written/ported by Xavier Noguer <xnoguer@php.net>
  4. *
  5. *  The majority of this is _NOT_ my code.  I simply ported it from the
  6. *  PERL Spreadsheet::WriteExcel module.
  7. *
  8. *  The author of the Spreadsheet::WriteExcel module is John McNamara
  9. *  <jmcnamara@cpan.org>
  10. *
  11. *  I _DO_ maintain this code, and John McNamara has nothing to do with the
  12. *  porting of this code to PHP.  Any questions directly related to this
  13. *  class library should be directed to me.
  14. *
  15. *  License Information:
  16. *
  17. *    Spreadsheet_Excel_Writer:  A library for generating Excel Spreadsheets
  18. *    Copyright (c) 2002-2003 Xavier Noguer xnoguer@php.net
  19. *
  20. *    This library is free software; you can redistribute it and/or
  21. *    modify it under the terms of the GNU Lesser General Public
  22. *    License as published by the Free Software Foundation; either
  23. *    version 2.1 of the License, or (at your option) any later version.
  24. *
  25. *    This library is distributed in the hope that it will be useful,
  26. *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  27. *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  28. *    Lesser General Public License for more details.
  29. *
  30. *    You should have received a copy of the GNU Lesser General Public
  31. *    License along with this library; if not, write to the Free Software
  32. *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  33. */
  34.  
  35. require_once 'PEAR.php';
  36.  
  37. /**
  38. * Class for writing Excel BIFF records.
  39. *
  40. * From "MICROSOFT EXCEL BINARY FILE FORMAT" by Mark O'Brien (Microsoft Corporation):
  41. *
  42. * BIFF (BInary File Format) is the file format in which Excel documents are
  43. * saved on disk.  A BIFF file is a complete description of an Excel document.
  44. * BIFF files consist of sequences of variable-length records. There are many
  45. * different types of BIFF records.  For example, one record type describes a
  46. * formula entered into a cell; one describes the size and location of a
  47. * window into a document; another describes a picture format.
  48. *
  49. * @author   Xavier Noguer <xnoguer@php.net>
  50. * @category FileFormats
  51. * @package  Spreadsheet_Excel_Writer
  52. */
  53.  
  54. class Spreadsheet_Excel_Writer_BIFFwriter extends PEAR
  55. {
  56.     /**
  57.     * The BIFF/Excel version (5).
  58.     * @var integer 
  59.     */
  60.     var $_BIFF_version = 0x0500;
  61.  
  62.     /**
  63.     * The byte order of this architecture. 0 => little endian, 1 => big endian
  64.     * @var integer 
  65.     */
  66.     var $_byte_order;
  67.  
  68.     /**
  69.     * The string containing the data of the BIFF stream
  70.     * @var string 
  71.     */
  72.     var $_data;
  73.  
  74.     /**
  75.     * The size of the data in bytes. Should be the same as strlen($this->_data)
  76.     * @var integer 
  77.     */
  78.     var $_datasize;
  79.  
  80.     /**
  81.     * The maximun length for a BIFF record. See _addContinue()
  82.     * @var integer 
  83.     * @see _addContinue()
  84.     */
  85.     var $_limit;
  86.  
  87.     /**
  88.     * The temporary dir for storing the OLE file
  89.     * @var string 
  90.     */
  91.     var $_tmp_dir;
  92.  
  93.     /**
  94.     * Constructor
  95.     *
  96.     * @access public
  97.     */
  98.     function Spreadsheet_Excel_Writer_BIFFwriter()
  99.     {
  100.         $this->_byte_order = '';
  101.         $this->_data       = '';
  102.         $this->_datasize   = 0;
  103.         $this->_limit      = 2080;
  104.         $this->_tmp_dir    = '';
  105.         // Set the byte order
  106.         $this->_setByteOrder();
  107.     }
  108.  
  109.     /**
  110.     * Determine the byte order and store it as class data to avoid
  111.     * recalculating it for each call to new().
  112.     *
  113.     * @access private
  114.     */
  115.     function _setByteOrder()
  116.     {
  117.         // Check if "pack" gives the required IEEE 64bit float
  118.         $teststr = pack("d", 1.2345);
  119.         $number  = pack("C8", 0x8D, 0x97, 0x6E, 0x12, 0x83, 0xC0, 0xF3, 0x3F);
  120.         if ($number == $teststr) {
  121.             $byte_order = 0;    // Little Endian
  122.         } elseif ($number == strrev($teststr)){
  123.             $byte_order = 1;    // Big Endian
  124.         } else {
  125.             // Give up. I'll fix this in a later version.
  126.             return $this->raiseError("Required floating point format ".
  127.                                      "not supported on this platform.");
  128.         }
  129.         $this->_byte_order = $byte_order;
  130.     }
  131.  
  132.     /**
  133.     * General storage function
  134.     *
  135.     * @param string $data binary data to prepend
  136.     * @access private
  137.     */
  138.     function _prepend($data)
  139.     {
  140.         if (strlen($data) > $this->_limit) {
  141.             $data = $this->_addContinue($data);
  142.         }
  143.         $this->_data      = $data.$this->_data;
  144.         $this->_datasize += strlen($data);
  145.     }
  146.  
  147.     /**
  148.     * General storage function
  149.     *
  150.     * @param string $data binary data to append
  151.     * @access private
  152.     */
  153.     function _append($data)
  154.     {
  155.         if (strlen($data) > $this->_limit) {
  156.             $data = $this->_addContinue($data);
  157.         }
  158.         $this->_data      = $this->_data.$data;
  159.         $this->_datasize += strlen($data);
  160.     }
  161.  
  162.     /**
  163.     * Writes Excel BOF record to indicate the beginning of a stream or
  164.     * sub-stream in the BIFF file.
  165.     *
  166.     * @param  integer $type Type of BIFF file to write: 0x0005 Workbook,
  167.     *                        0x0010 Worksheet.
  168.     * @access private
  169.     */
  170.     function _storeBof($type)
  171.     {
  172.         $record  = 0x0809;        // Record identifier
  173.  
  174.         // According to the SDK $build and $year should be set to zero.
  175.         // However, this throws a warning in Excel 5. So, use magic numbers.
  176.         if ($this->_BIFF_version == 0x0500) {
  177.             $length  = 0x0008;
  178.             $unknown = '';
  179.             $build   = 0x096C;
  180.             $year    = 0x07C9;
  181.         } elseif ($this->_BIFF_version == 0x0600) {
  182.             $length  = 0x0010;
  183.             $unknown = pack("VV", 0x00000041, 0x00000006); //unknown last 8 bytes for BIFF8
  184.             $build   = 0x0DBB;
  185.             $year    = 0x07CC;
  186.         }
  187.         $version = $this->_BIFF_version;
  188.  
  189.         $header  = pack("vv",   $record, $length);
  190.         $data    = pack("vvvv", $version, $type, $build, $year);
  191.         $this->_prepend($header . $data . $unknown);
  192.     }
  193.  
  194.     /**
  195.     * Writes Excel EOF record to indicate the end of a BIFF stream.
  196.     *
  197.     * @access private
  198.     */
  199.     function _storeEof()
  200.     {
  201.         $record    = 0x000A;   // Record identifier
  202.         $length    = 0x0000;   // Number of bytes to follow
  203.         $header    = pack("vv", $record, $length);
  204.         $this->_append($header);
  205.     }
  206.  
  207.     /**
  208.     * Excel limits the size of BIFF records. In Excel 5 the limit is 2084 bytes. In
  209.     * Excel 97 the limit is 8228 bytes. Records that are longer than these limits
  210.     * must be split up into CONTINUE blocks.
  211.     *
  212.     * This function takes a long BIFF record and inserts CONTINUE records as
  213.     * necessary.
  214.     *
  215.     * @param  string  $data The original binary data to be written
  216.     * @return string        A very convenient string of continue blocks
  217.     * @access private
  218.     */
  219.     function _addContinue($data)
  220.     {
  221.         $limit  = $this->_limit;
  222.         $record = 0x003C;         // Record identifier
  223.  
  224.         // The first 2080/8224 bytes remain intact. However, we have to change
  225.         // the length field of the record.
  226.         $tmp = substr($data, 0, 2).pack("v", $limit-4).substr($data, 4, $limit - 4);
  227.  
  228.         $header = pack("vv", $record, $limit);  // Headers for continue records
  229.  
  230.         // Retrieve chunks of 2080/8224 bytes +4 for the header.
  231.         $data_length = strlen($data);
  232.         for ($i = $limit; $i <  ($data_length - $limit); $i += $limit) {
  233.             $tmp .= $header;
  234.             $tmp .= substr($data, $i, $limit);
  235.         }
  236.  
  237.         // Retrieve the last chunk of data
  238.         $header  = pack("vv", $record, strlen($data) - $i);
  239.         $tmp    .= $header;
  240.         $tmp    .= substr($data, $i, strlen($data) - $i);
  241.  
  242.         return $tmp;
  243.     }
  244.  
  245.     /**
  246.     * Sets the temp dir used for storing the OLE file
  247.     *
  248.     * @access public
  249.     * @param string $dir The dir to be used as temp dir
  250.     * @return true if given dir is valid, false otherwise
  251.     */
  252.     function setTempDir($dir)
  253.     {
  254.         if (is_dir($dir)) {
  255.             $this->_tmp_dir = $dir;
  256.             return true;
  257.         }
  258.         return false;
  259.     }
  260. }
  261. ?>

Documentation generated on Wed, 09 Feb 2011 08:58:56 +0700 by phpDocumentor 1.4.2