[Sommaire] [Imprimer]

   1  <?php
   2  
   3  /*
   4   * Copyleft 2002 Johann Hanne
   5   *
   6   * This is free software; you can redistribute it and/or
   7   * modify it under the terms of the GNU Lesser General Public
   8   * License as published by the Free Software Foundation; either
   9   * version 2.1 of the License, or (at your option) any later version.
  10   *
  11   * This software is distributed in the hope that it will be useful,
  12   * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14   * Lesser General Public License for more details.
  15   *
  16   * You should have received a copy of the GNU Lesser General Public
  17   * License along with this software; if not, write to the
  18   * Free Software Foundation, Inc., 59 Temple Place,
  19   * Suite 330, Boston, MA  02111-1307 USA
  20   */
  21  
  22  /*
  23   * This is the Spreadsheet::WriteExcel Perl package ported to PHP
  24   * Spreadsheet::WriteExcel was written by John McNamara, jmcnamara@cpan.org
  25   */
  26  
  27  class writeexcel_biffwriter {
  28      var $byte_order;
  29      var $BIFF_version;
  30      var $_byte_order;
  31      var $_data;
  32      var $_datasize;
  33      var $_limit;
  34  
  35      /*
  36       * Constructor
  37       */
  38      function writeexcel_biffwriter() {
  39  
  40          $this->byte_order   = '';
  41          $this->BIFF_version = 0x0500;
  42          $this->_byte_order  = '';
  43          $this->_data        = false;
  44          $this->_datasize    = 0;
  45          $this->_limit       = 2080;
  46  
  47          $this->_set_byte_order();
  48      }
  49  
  50      /*
  51       * Determine the byte order and store it as class data to avoid
  52       * recalculating it for each call to new().
  53       */
  54      function _set_byte_order() {
  55          $this->byteorder=0;
  56          // Check if "pack" gives the required IEEE 64bit float
  57          $teststr = pack("d", 1.2345);
  58          $number  = pack("C8", 0x8D, 0x97, 0x6E, 0x12, 0x83, 0xC0, 0xF3, 0x3F);
  59  
  60          if ($number == $teststr) {
  61              $this->byte_order = 0; // Little Endian
  62          } elseif ($number == strrev($teststr)) {
  63              $this->byte_order = 1; // Big Endian
  64          } else {
  65              // Give up
  66              trigger_error("Required floating point format not supported ".
  67                            "on this platform. See the portability section ".
  68                            "of the documentation.", E_USER_ERROR);
  69          }
  70  
  71          $this->_byte_order = $this->byte_order;
  72      }
  73  
  74      /*
  75       * General storage function
  76       */
  77      function _prepend($data) {
  78  
  79          if (func_num_args()>1) {
  80              trigger_error("writeexcel_biffwriter::_prepend() ".
  81                            "called with more than one argument", E_USER_ERROR);
  82          }
  83  
  84          if ($this->_debug) {
  85              print "*** writeexcel_biffwriter::_prepend() called:";
  86              for ($c=0;$c<strlen($data);$c++) {
  87                  if ($c%16==0) {
  88                      print "\n";
  89                  }
  90                  printf("%02X ", ord($data[$c]));
  91              }
  92              print "\n";
  93          }
  94  
  95          if (strlen($data) > $this->_limit) {
  96              $data = $this->_add_continue($data);
  97          }
  98  
  99          $this->_data      = $data . $this->_data;
 100          $this->_datasize += strlen($data);
 101      }
 102  
 103      /*
 104       * General storage function
 105       */
 106      function _append($data) {
 107  
 108          if (func_num_args()>1) {
 109              trigger_error("writeexcel_biffwriter::_append() ".
 110                            "called with more than one argument", E_USER_ERROR);
 111          }
 112  
 113          if ($this->_debug) {
 114              print "*** writeexcel_biffwriter::_append() called:";
 115              for ($c=0;$c<strlen($data);$c++) {
 116                  if ($c%16==0) {
 117                      print "\n";
 118                  }
 119                  printf("%02X ", ord($data[$c]));
 120              }
 121              print "\n";
 122          }
 123  
 124          if (strlen($data) > $this->_limit) {
 125              $data = $this->_add_continue($data);
 126          }
 127  
 128          $this->_data      = $this->_data . $data;
 129          $this->_datasize += strlen($data);
 130      }
 131  
 132      /*
 133       * Writes Excel BOF record to indicate the beginning of a stream or
 134       * sub-stream in the BIFF file.
 135       *
 136       * $type = 0x0005, Workbook
 137       * $type = 0x0010, Worksheet
 138       */
 139      function _store_bof($type) {
 140  
 141          $record  = 0x0809; // Record identifier
 142          $length  = 0x0008; // Number of bytes to follow
 143  
 144          $version = $this->BIFF_version;
 145  
 146          // According to the SDK $build and $year should be set to zero.
 147          // However, this throws a warning in Excel 5. So, use these
 148          // magic numbers.
 149          $build  = 0x096C;
 150          $year   = 0x07C9;
 151  
 152          $header = pack("vv",   $record, $length);
 153          $data   = pack("vvvv", $version, $type, $build, $year);
 154  
 155          $this->_prepend($header . $data);
 156      }
 157  
 158      /*
 159       * Writes Excel EOF record to indicate the end of a BIFF stream.
 160       */
 161      function _store_eof() {
 162  
 163          $record = 0x000A; // Record identifier
 164          $length = 0x0000; // Number of bytes to follow
 165  
 166          $header = pack("vv", $record, $length);
 167  
 168          $this->_append($header);
 169      }
 170  
 171      /*
 172       * Excel limits the size of BIFF records. In Excel 5 the limit is 2084
 173       * bytes. In Excel 97 the limit is 8228 bytes. Records that are longer
 174       * than these limits must be split up into CONTINUE blocks.
 175       *
 176       * This function take a long BIFF record and inserts CONTINUE records as
 177       * necessary.
 178       */
 179      function _add_continue($data) {
 180  
 181          $limit  = $this->_limit;
 182          $record = 0x003C; // Record identifier
 183  
 184          // The first 2080/8224 bytes remain intact. However, we have to change
 185          // the length field of the record.
 186          $tmp = substr($data, 0, $limit);
 187          $data = substr($data, $limit);
 188          $tmp = substr($tmp, 0, 2) . pack ("v", $limit-4) . substr($tmp, 4);
 189  
 190          // Strip out chunks of 2080/8224 bytes +4 for the header.
 191          while (strlen($data) > $limit) {
 192              $header  = pack("vv", $record, $limit);
 193              $tmp    .= $header;
 194              $tmp    .= substr($data, 0, $limit);
 195              $data    = substr($data, $limit);
 196          }
 197  
 198          // Mop up the last of the data
 199          $header  = pack("vv", $record, strlen($data));
 200          $tmp    .= $header;
 201          $tmp    .= $data;
 202  
 203          return $tmp;
 204      }
 205  
 206  }
 207  
 208  ?>