[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_olewriter {
  28      var $_OLEfilename;
  29      var $_OLEtmpfilename; /* ABR */
  30      var $_filehandle;
  31      var $_fileclosed;
  32      var $_internal_fh;
  33      var $_biff_only;
  34      var $_size_allowed;
  35      var $_biffsize;
  36      var $_booksize;
  37      var $_big_blocks;
  38      var $_list_blocks;
  39      var $_root_start;
  40      var $_block_count;
  41  
  42      /*
  43       * Constructor
  44       */
  45      function writeexcel_olewriter($filename) {
  46  
  47          $this->_OLEfilename  = $filename;
  48          $this->_filehandle   = false;
  49          $this->_fileclosed   = 0;
  50          $this->_internal_fh  = 0;
  51          $this->_biff_only    = 0;
  52          $this->_size_allowed = 0;
  53          $this->_biffsize     = 0;
  54          $this->_booksize     = 0;
  55          $this->_big_blocks   = 0;
  56          $this->_list_blocks  = 0;
  57          $this->_root_start   = 0;
  58          $this->_block_count  = 4;
  59  
  60          $this->_initialize();
  61      }
  62  
  63      /*
  64       * Check for a valid filename and store the filehandle.
  65       */
  66      function _initialize() {
  67          $OLEfile = $this->_OLEfilename;
  68  
  69          /* Check for a filename. Workbook.pm will catch this first. */
  70          if ($OLEfile == '') {
  71              trigger_error("Filename required", E_USER_ERROR);
  72          }
  73  
  74          /*
  75           * If the filename is a resource it is assumed that it is a valid
  76           * filehandle, if not we create a filehandle.
  77           */
  78          if (is_resource($OLEfile)) {
  79              $fh = $OLEfile;
  80          } else {
  81              // Create a new file, open for writing
  82              $fh = fopen($OLEfile, "wb");
  83              // The workbook class also checks this but something may have
  84              // happened since then.
  85              if (!$fh) {
  86                  trigger_error("Can't open $OLEfile. It may be in use or ".
  87                                "protected", E_USER_ERROR);
  88              }
  89  
  90              $this->_internal_fh = 1;
  91          }
  92  
  93          // Store filehandle
  94          $this->_filehandle = $fh;
  95      }
  96  
  97      /*
  98       * Set the size of the data to be written to the OLE stream
  99       *
 100       * $big_blocks = (109 depot block x (128 -1 marker word)
 101       *               - (1 x end words)) = 13842
 102       * $maxsize    = $big_blocks * 512 bytes = 7087104
 103       */
 104      function set_size($size) {
 105          $maxsize = 7087104;
 106  
 107          if ($size > $maxsize) {
 108              trigger_error("Maximum file size, $maxsize, exceeded. To create ".
 109                            "files bigger than this limit please use the ".
 110                            "workbookbig class.", E_USER_ERROR);
 111              return ($this->_size_allowed = 0);
 112          }
 113  
 114          $this->_biffsize = $size;
 115  
 116          // Set the min file size to 4k to avoid having to use small blocks
 117          if ($size > 4096) {
 118              $this->_booksize = $size;
 119          } else {
 120              $this->_booksize = 4096;
 121          }
 122  
 123          return ($this->_size_allowed = 1);
 124      }
 125  
 126      /*
 127       * Calculate various sizes needed for the OLE stream
 128       */
 129      function _calculate_sizes() {
 130          $datasize = $this->_booksize;
 131  
 132          if ($datasize % 512 == 0) {
 133              $this->_big_blocks = $datasize/512;
 134          } else {
 135              $this->_big_blocks = floor($datasize/512)+1;
 136          }
 137          // There are 127 list blocks and 1 marker blocks for each big block
 138          // depot + 1 end of chain block
 139          $this->_list_blocks = floor(($this->_big_blocks)/127)+1;
 140          $this->_root_start  = $this->_big_blocks;
 141  
 142          //print $this->_biffsize.    "\n";
 143          //print $this->_big_blocks.  "\n";
 144          //print $this->_list_blocks. "\n";
 145      }
 146  
 147      /*
 148       * Write root entry, big block list and close the filehandle.
 149       * This method must be called so that the file contents are
 150       * actually written.
 151       */
 152      function close() {
 153  
 154          if (!$this->_size_allowed) {
 155              return;
 156          }
 157  
 158          if (!$this->_biff_only) {
 159              $this->_write_padding();
 160              $this->_write_property_storage();
 161              $this->_write_big_block_depot();
 162          }
 163  
 164          // Close the filehandle if it was created internally.
 165          if ($this->_internal_fh) {
 166              fclose($this->_filehandle);
 167          }
 168  /* ABR */
 169          if ($this->_OLEtmpfilename != '') {
 170              $fh = fopen($this->_OLEtmpfilename, "rb");
 171              if ($fh == false) {
 172                  trigger_error("Can't read temporary file.", E_USER_ERROR);
 173              }
 174              fpassthru($fh);
 175              fclose($fh);
 176              unlink($this->_OLEtmpfilename);
 177          };
 178  
 179          $this->_fileclosed = 1;
 180      }
 181  
 182      /*
 183       * Write BIFF data to OLE file.
 184       */
 185      function write($data) {
 186          fputs($this->_filehandle, $data);
 187      }
 188  
 189      /*
 190       * Write OLE header block.
 191       */
 192      function write_header() {
 193          if ($this->_biff_only) {
 194              return;
 195          }
 196  
 197          $this->_calculate_sizes();
 198  
 199          $root_start      = $this->_root_start;
 200          $num_lists       = $this->_list_blocks;
 201  
 202          $id              = pack("C8", 0xD0, 0xCF, 0x11, 0xE0,
 203                                        0xA1, 0xB1, 0x1A, 0xE1);
 204          $unknown1        = pack("VVVV", 0x00, 0x00, 0x00, 0x00);
 205          $unknown2        = pack("vv",   0x3E, 0x03);
 206          $unknown3        = pack("v",    -2);
 207          $unknown4        = pack("v",    0x09);
 208          $unknown5        = pack("VVV",  0x06, 0x00, 0x00);
 209          $num_bbd_blocks  = pack("V",    $num_lists);
 210          $root_startblock = pack("V",    $root_start);
 211          $unknown6        = pack("VV",   0x00, 0x1000);
 212          $sbd_startblock  = pack("V",    -2);
 213          $unknown7        = pack("VVV",  0x00, -2 ,0x00);
 214          $unused          = pack("V",    -1);
 215  
 216          fputs($this->_filehandle, $id);
 217          fputs($this->_filehandle, $unknown1);
 218          fputs($this->_filehandle, $unknown2);
 219          fputs($this->_filehandle, $unknown3);
 220          fputs($this->_filehandle, $unknown4);
 221          fputs($this->_filehandle, $unknown5);
 222          fputs($this->_filehandle, $num_bbd_blocks);
 223          fputs($this->_filehandle, $root_startblock);
 224          fputs($this->_filehandle, $unknown6);
 225          fputs($this->_filehandle, $sbd_startblock);
 226          fputs($this->_filehandle, $unknown7);
 227  
 228          for ($c=1;$c<=$num_lists;$c++) {
 229              $root_start++;
 230              fputs($this->_filehandle, pack("V", $root_start));
 231          }
 232  
 233          for ($c=$num_lists;$c<=108;$c++) {
 234              fputs($this->_filehandle, $unused);
 235          }
 236      }
 237  
 238      /*
 239       * Write big block depot.
 240       */
 241      function _write_big_block_depot() {
 242          $num_blocks   = $this->_big_blocks;
 243          $num_lists    = $this->_list_blocks;
 244          $total_blocks = $num_lists * 128;
 245          $used_blocks  = $num_blocks + $num_lists + 2;
 246  
 247          $marker       = pack("V", -3);
 248          $end_of_chain = pack("V", -2);
 249          $unused       = pack("V", -1);
 250  
 251          for ($i=1;$i<=($num_blocks-1);$i++) {
 252              fputs($this->_filehandle, pack("V", $i));
 253          }
 254  
 255          fputs($this->_filehandle, $end_of_chain);
 256          fputs($this->_filehandle, $end_of_chain);
 257  
 258          for ($c=1;$c<=$num_lists;$c++) {
 259              fputs($this->_filehandle, $marker);
 260          }
 261  
 262          for ($c=$used_blocks;$c<=$total_blocks;$c++) {
 263              fputs($this->_filehandle, $unused);
 264          }
 265      }
 266  
 267      /*
 268       * Write property storage. TODO: add summary sheets
 269       */
 270      function _write_property_storage() {
 271          $rootsize = -2;
 272          $booksize = $this->_booksize;
 273  
 274          //                name          type  dir start  size
 275          $this->_write_pps('Root Entry', 0x05,   1,   -2, 0x00);
 276          $this->_write_pps('Book',       0x02,  -1, 0x00, $booksize);
 277          $this->_write_pps('',           0x00,  -1, 0x00, 0x0000);
 278          $this->_write_pps('',           0x00,  -1, 0x00, 0x0000);
 279      }
 280  
 281      /*
 282       * Write property sheet in property storage
 283       */
 284      function _write_pps($name, $type, $dir, $start, $size) {
 285          $names           = array();
 286          $length          = 0;
 287  
 288          if ($name != '') {
 289              $name   = $name . "\0";
 290              // Simulate a Unicode string
 291              $chars=preg_split("''", $name, -1, PREG_SPLIT_NO_EMPTY);
 292              foreach ($chars as $char) {
 293                  array_push($names, ord($char));
 294              }
 295              $length = strlen($name) * 2;
 296          }
 297  
 298          $rawname         = call_user_func_array('pack', array_merge(array("v*"), $names));
 299          $zero            = pack("C",  0);
 300  
 301          $pps_sizeofname  = pack("v",  $length);   //0x40
 302          $pps_type        = pack("v",  $type);     //0x42
 303          $pps_prev        = pack("V",  -1);        //0x44
 304          $pps_next        = pack("V",  -1);        //0x48
 305          $pps_dir         = pack("V",  $dir);      //0x4c
 306  
 307          $unknown1        = pack("V",  0);
 308  
 309          $pps_ts1s        = pack("V",  0);         //0x64
 310          $pps_ts1d        = pack("V",  0);         //0x68
 311          $pps_ts2s        = pack("V",  0);         //0x6c
 312          $pps_ts2d        = pack("V",  0);         //0x70
 313          $pps_sb          = pack("V",  $start);    //0x74
 314          $pps_size        = pack("V",  $size);     //0x78
 315  
 316          fputs($this->_filehandle, $rawname);
 317          fputs($this->_filehandle, str_repeat($zero, (64-$length)));
 318          fputs($this->_filehandle, $pps_sizeofname);
 319          fputs($this->_filehandle, $pps_type);
 320          fputs($this->_filehandle, $pps_prev);
 321          fputs($this->_filehandle, $pps_next);
 322          fputs($this->_filehandle, $pps_dir);
 323          fputs($this->_filehandle, str_repeat($unknown1, 5));
 324          fputs($this->_filehandle, $pps_ts1s);
 325          fputs($this->_filehandle, $pps_ts1d);
 326          fputs($this->_filehandle, $pps_ts2d);
 327          fputs($this->_filehandle, $pps_ts2d);
 328          fputs($this->_filehandle, $pps_sb);
 329          fputs($this->_filehandle, $pps_size);
 330          fputs($this->_filehandle, $unknown1);
 331      }
 332  
 333      /*
 334       * Pad the end of the file
 335       */
 336      function _write_padding() {
 337          $biffsize = $this->_biffsize;
 338  
 339          if ($biffsize < 4096) {
 340              $min_size = 4096;
 341          } else {
 342              $min_size = 512;
 343          }
 344  
 345          if ($biffsize % $min_size != 0) {
 346              $padding  = $min_size - ($biffsize % $min_size);
 347              fputs($this->_filehandle, str_repeat("\0", $padding));
 348          }
 349      }
 350  
 351  }
 352  
 353  ?>