[Summary view] [Print] [Text view]

   1  <?php
   2  /*

   3  *  Module written/ported by Xavier Noguer <xnoguer@rezebra.com>

   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::WriteExcel:  A library for generating Excel Spreadsheets

  18  *    Copyright (C) 2002 Xavier Noguer xnoguer@rezebra.com

  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  /**

  36  * Class for writing Excel BIFF records.

  37  * 

  38  * From "MICROSOFT EXCEL BINARY FILE FORMAT" by Mark O'Brien (Microsoft Corporation):

  39  *

  40  * BIFF (BInary File Format) is the file format in which Excel documents are 

  41  * saved on disk.  A BIFF file is a complete description of an Excel document.

  42  * BIFF files consist of sequences of variable-length records. There are many 

  43  * different types of BIFF records.  For example, one record type describes a 

  44  * formula entered into a cell; one describes the size and location of a 

  45  * window into a document; another describes a picture format.

  46  *

  47  * @author Xavier Noguer <xnoguer@rezebra.com>

  48  * @package Spreadsheet_WriteExcel

  49  */
  50  
  51  class BIFFWriter
  52  {
  53      var $_BIFF_version = 0x0500;
  54  
  55  /**

  56  * Constructor

  57  *

  58  * @access public

  59  */
  60      function BIFFwriter()
  61      {
  62          // The byte order of this architecture. 0 => little endian, 1 => big endian

  63          $this->_byte_order = '';
  64          // The string containing the data of the BIFF stream

  65          $this->_data       = '';
  66          // Should be the same as strlen($this->_data)

  67          $this->_datasize   = 0;
  68          // The maximun length for a BIFF record. See _add_continue()

  69          $this->_limit      = 2080;   
  70          // Set the byte order

  71          $this->_set_byte_order();
  72      }
  73  
  74  /**

  75  * Determine the byte order and store it as class data to avoid

  76  * recalculating it for each call to new().

  77  *

  78  * @access private

  79  */
  80      function _set_byte_order()
  81      {
  82          if ($this->_byte_order == '')
  83          {
  84              // Check if "pack" gives the required IEEE 64bit float

  85              $teststr = pack("d", 1.2345);
  86              $number  = pack("C8", 0x8D, 0x97, 0x6E, 0x12, 0x83, 0xC0, 0xF3, 0x3F);
  87              if ($number == $teststr) {
  88                  $byte_order = 0;    // Little Endian

  89              }
  90              elseif ($number == strrev($teststr)){
  91                  $byte_order = 1;    // Big Endian

  92              }
  93              else {
  94                  // Give up. I'll fix this in a later version.

  95                  die("Required floating point format not supported ".
  96                      "on this platform. See the portability section ".
  97                      "of the documentation."
  98                     );
  99              }
 100          }
 101          $this->_byte_order = $byte_order;
 102      }
 103  
 104  /**

 105  * General storage function

 106  *

 107  * @param string $data binary data to prepend

 108  * @access private

 109  */
 110      function _prepend($data)
 111      {
 112          if (strlen($data) > $this->_limit) {
 113              $data = $this->_add_continue($data);
 114          }
 115          $this->_data      = $data.$this->_data;
 116          $this->_datasize += strlen($data);
 117      }
 118  
 119  /**

 120  * General storage function

 121  *

 122  * @param string $data binary data to append

 123  * @access private

 124  */
 125      function _append($data)
 126      {
 127          if (strlen($data) > $this->_limit) {
 128              $data = $this->_add_continue($data);
 129          }
 130          $this->_data      = $this->_data.$data;
 131          $this->_datasize += strlen($data);
 132      }
 133  
 134  /**

 135  * Writes Excel BOF record to indicate the beginning of a stream or

 136  * sub-stream in the BIFF file.

 137  *

 138  * @param  integer $type type of BIFF file to write: 0x0005 Workbook, 0x0010 Worksheet.

 139  * @access private

 140  */
 141      function _store_bof($type)
 142      {
 143          $record  = 0x0809;        // Record identifier

 144          $length  = 0x0008;        // Number of bytes to follow

 145          $version = $this->_BIFF_version;
 146     
 147          // According to the SDK $build and $year should be set to zero.

 148          // However, this throws a warning in Excel 5. So, use these

 149          // magic numbers.

 150          $build   = 0x096C;
 151          $year    = 0x07C9;
 152     
 153          $header  = pack("vv",   $record, $length);
 154          $data    = pack("vvvv", $version, $type, $build, $year);
 155          $this->_prepend($header.$data);
 156      }
 157  
 158  /**

 159  * Writes Excel EOF record to indicate the end of a BIFF stream.

 160  *

 161  * @access private

 162  */
 163      function _store_eof() 
 164      {
 165          $record    = 0x000A;   // Record identifier

 166          $length    = 0x0000;   // Number of bytes to follow

 167          $header    = pack("vv", $record, $length);
 168          $this->_append($header);
 169      }
 170  
 171  /**

 172  * Excel limits the size of BIFF records. In Excel 5 the limit is 2084 bytes. In

 173  * Excel 97 the limit is 8228 bytes. Records that are longer than these limits

 174  * must be split up into CONTINUE blocks.

 175  *

 176  * This function takes a long BIFF record and inserts CONTINUE records as

 177  * necessary.

 178  *

 179  * @param  string  $data The original binary data to be written

 180  * @return string        A very convenient string of continue blocks

 181  * @access private

 182  */
 183      function _add_continue($data)
 184      {
 185          $limit      = $this->_limit;
 186          $record     = 0x003C;         // Record identifier

 187   
 188          // The first 2080/8224 bytes remain intact. However, we have to change

 189          // the length field of the record.

 190          $tmp = substr($data, 0, 2).pack("v", $limit-4).substr($data, 4, $limit - 4);
 191          
 192          $header = pack("vv", $record, $limit);  // Headers for continue records

 193   
 194          // Retrieve chunks of 2080/8224 bytes +4 for the header.

 195          for($i = $limit; $i < strlen($data) - $limit; $i += $limit)
 196          {
 197              $tmp .= $header;
 198              $tmp .= substr($data, $i, $limit);
 199          }
 200  
 201          // Retrieve the last chunk of data

 202          $header  = pack("vv", $record, strlen($data) - $i);
 203          $tmp    .= $header;
 204          $tmp    .= substr($data,$i,strlen($data) - $i);
 205   
 206          return($tmp);
 207      }
 208  }
 209  ?>