| New file |
|---|
| 0,0 → 1,428 |
|---|
| <?php |
| /* |
| * Module written/ported by Xavier Noguer <xnoguer@rezebra.com> |
| * |
| * The majority of this is _NOT_ my code. I simply ported it from the |
| * PERL Spreadsheet::WriteExcel module. |
| * |
| * The author of the Spreadsheet::WriteExcel module is John McNamara |
| * <jmcnamara@cpan.org> |
| * |
| * I _DO_ maintain this code, and John McNamara has nothing to do with the |
| * porting of this code to PHP. Any questions directly related to this |
| * class library should be directed to me. |
| * |
| * License Information: |
| * |
| * Spreadsheet_Excel_Writer: A library for generating Excel Spreadsheets |
| * Copyright (c) 2002-2003 Xavier Noguer xnoguer@rezebra.com |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
| */ |
| |
| require_once('PEAR.php'); |
| |
| /** |
| * Class for creating OLE streams for Excel Spreadsheets |
| * |
| * @author Xavier Noguer <xnoguer@rezebra.com> |
| * @category FileFormats |
| * @package Spreadsheet_Excel_Writer |
| */ |
| |
| class Spreadsheet_Excel_Writer_OLEwriter extends PEAR |
| { |
| /** |
| * Filename for the OLE stream |
| * @var string |
| * @see _initialize() |
| */ |
| var $_OLEfilename; |
| |
| /** |
| * Filehandle for the OLE stream |
| * @var resource |
| */ |
| var $_filehandle; |
| |
| /** |
| * Name of the temporal file in case OLE stream goes to stdout |
| * @var string |
| */ |
| var $_tmp_filename; |
| |
| /** |
| * Variable for preventing closing two times |
| * @var integer |
| */ |
| var $_fileclosed; |
| |
| /** |
| * Size of the data to be written to the OLE stream |
| * @var integer |
| */ |
| var $_biffsize; |
| |
| /** |
| * Real data size to be written to the OLE stream |
| * @var integer |
| */ |
| var $_booksize; |
| |
| /** |
| * Number of big blocks in the OLE stream |
| * @var integer |
| */ |
| var $_big_blocks; |
| |
| /** |
| * Number of list blocks in the OLE stream |
| * @var integer |
| */ |
| var $_list_blocks; |
| |
| /** |
| * Number of big blocks in the OLE stream |
| * @var integer |
| */ |
| var $_root_start; |
| |
| /** |
| * Constructor for the OLEwriter class |
| * |
| * @param string $OLEfilename the name of the file for the OLE stream |
| */ |
| function Spreadsheet_Excel_Writer_OLEwriter($OLEfilename) |
| { |
| $this->_OLEfilename = $OLEfilename; |
| $this->_filehandle = ""; |
| $this->_tmp_filename = ""; |
| $this->_fileclosed = 0; |
| $this->_biff_only = 0; |
| //$this->_size_allowed = 0; |
| $this->_biffsize = 0; |
| $this->_booksize = 0; |
| $this->_big_blocks = 0; |
| $this->_list_blocks = 0; |
| $this->_root_start = 0; |
| //$this->_block_count = 4; |
| $this->_initialize(); |
| } |
| |
| /** |
| * Check for a valid filename and store the filehandle. |
| * Filehandle "-" writes to STDOUT |
| * |
| * @access private |
| */ |
| function _initialize() |
| { |
| $OLEfile = $this->_OLEfilename; |
| |
| if(($OLEfile == '-') or ($OLEfile == '')) |
| { |
| $this->_tmp_filename = tempnam("/tmp", "OLEwriter"); |
| $fh = fopen($this->_tmp_filename,"wb"); |
| if ($fh == false) { |
| $this->raiseError("Can't create temporary file."); |
| } |
| } |
| else |
| { |
| // Create a new file, open for writing (in binmode) |
| $fh = fopen($OLEfile,"wb"); |
| if ($fh == false) { |
| $this->raiseError("Can't open $OLEfile. It may be in use or protected."); |
| } |
| } |
| |
| // Store filehandle |
| $this->_filehandle = $fh; |
| } |
| |
| |
| /** |
| * Set the size of the data to be written to the OLE stream. |
| * The maximun size comes from this: |
| * $big_blocks = (109 depot block x (128 -1 marker word) |
| * - (1 x end words)) = 13842 |
| * $maxsize = $big_blocks * 512 bytes = 7087104 |
| * |
| * @access public |
| * @see Spreadsheet_Excel_Writer_Workbook::store_OLE_file() |
| * @param integer $biffsize The size of the data to be written to the OLE stream |
| * @return integer 1 for success |
| */ |
| function setSize($biffsize) |
| { |
| $maxsize = 7087104; // TODO: extend max size |
| |
| if ($biffsize > $maxsize) { |
| $this->raiseError("Maximum file size, $maxsize, exceeded."); |
| } |
| |
| $this->_biffsize = $biffsize; |
| // Set the min file size to 4k to avoid having to use small blocks |
| if ($biffsize > 4096) { |
| $this->_booksize = $biffsize; |
| } |
| else { |
| $this->_booksize = 4096; |
| } |
| //$this->_size_allowed = 1; |
| return(1); |
| } |
| |
| |
| /** |
| * Calculate various sizes needed for the OLE stream |
| * |
| * @access private |
| */ |
| function _calculateSizes() |
| { |
| $datasize = $this->_booksize; |
| if ($datasize % 512 == 0) { |
| $this->_big_blocks = $datasize/512; |
| } |
| else { |
| $this->_big_blocks = floor($datasize/512) + 1; |
| } |
| // There are 127 list blocks and 1 marker blocks for each big block |
| // depot + 1 end of chain block |
| $this->_list_blocks = floor(($this->_big_blocks)/127) + 1; |
| $this->_root_start = $this->_big_blocks; |
| } |
| |
| /** |
| * Write root entry, big block list and close the filehandle. |
| * This routine is used to explicitly close the open filehandle without |
| * having to wait for DESTROY. |
| * |
| * @access public |
| * @see Spreadsheet_Excel_Writer_Workbook::store_OLE_file() |
| */ |
| function close() |
| { |
| //return if not $this->{_size_allowed}; |
| $this->_writePadding(); |
| $this->_writePropertyStorage(); |
| $this->_writeBigBlockDepot(); |
| // Close the filehandle |
| fclose($this->_filehandle); |
| if(($this->_OLEfilename == '-') or ($this->_OLEfilename == '')) |
| { |
| $fh = fopen($this->_tmp_filename, "rb"); |
| if ($fh == false) { |
| $this->raiseError("Can't read temporary file."); |
| } |
| fpassthru($fh); |
| @unlink($this->_tmp_filename); |
| } |
| $this->_fileclosed = 1; |
| } |
| |
| |
| /** |
| * Write BIFF data to OLE file. |
| * |
| * @param string $data string of bytes to be written |
| */ |
| function write($data) |
| { |
| fwrite($this->_filehandle,$data,strlen($data)); |
| } |
| |
| |
| /** |
| * Write OLE header block. |
| */ |
| function writeHeader() |
| { |
| $this->_calculateSizes(); |
| $root_start = $this->_root_start; |
| $num_lists = $this->_list_blocks; |
| $id = pack("nnnn", 0xD0CF, 0x11E0, 0xA1B1, 0x1AE1); |
| $unknown1 = pack("VVVV", 0x00, 0x00, 0x00, 0x00); |
| $unknown2 = pack("vv", 0x3E, 0x03); |
| $unknown3 = pack("v", -2); |
| $unknown4 = pack("v", 0x09); |
| $unknown5 = pack("VVV", 0x06, 0x00, 0x00); |
| $num_bbd_blocks = pack("V", $num_lists); |
| $root_startblock = pack("V", $root_start); |
| $unknown6 = pack("VV", 0x00, 0x1000); |
| $sbd_startblock = pack("V", -2); |
| $unknown7 = pack("VVV", 0x00, -2 ,0x00); |
| $unused = pack("V", -1); |
| |
| fwrite($this->_filehandle,$id); |
| fwrite($this->_filehandle,$unknown1); |
| fwrite($this->_filehandle,$unknown2); |
| fwrite($this->_filehandle,$unknown3); |
| fwrite($this->_filehandle,$unknown4); |
| fwrite($this->_filehandle,$unknown5); |
| fwrite($this->_filehandle,$num_bbd_blocks); |
| fwrite($this->_filehandle,$root_startblock); |
| fwrite($this->_filehandle,$unknown6); |
| fwrite($this->_filehandle,$sbd_startblock); |
| fwrite($this->_filehandle,$unknown7); |
| |
| for($i=1; $i <= $num_lists; $i++) |
| { |
| $root_start++; |
| fwrite($this->_filehandle,pack("V",$root_start)); |
| } |
| for($i = $num_lists; $i <=108; $i++) |
| { |
| fwrite($this->_filehandle,$unused); |
| } |
| } |
| |
| |
| /** |
| * Write big block depot. |
| * |
| * @access private |
| */ |
| function _writeBigBlockDepot() |
| { |
| $num_blocks = $this->_big_blocks; |
| $num_lists = $this->_list_blocks; |
| $total_blocks = $num_lists *128; |
| $used_blocks = $num_blocks + $num_lists +2; |
| |
| $marker = pack("V", -3); |
| $end_of_chain = pack("V", -2); |
| $unused = pack("V", -1); |
| |
| for($i=1; $i < $num_blocks; $i++) |
| { |
| fwrite($this->_filehandle,pack("V",$i)); |
| } |
| fwrite($this->_filehandle,$end_of_chain); |
| fwrite($this->_filehandle,$end_of_chain); |
| for($i=0; $i < $num_lists; $i++) |
| { |
| fwrite($this->_filehandle,$marker); |
| } |
| for($i=$used_blocks; $i <= $total_blocks; $i++) |
| { |
| fwrite($this->_filehandle,$unused); |
| } |
| } |
| |
| /** |
| * Write property storage. TODO: add summary sheets |
| * |
| * @access private |
| */ |
| function _writePropertyStorage() |
| { |
| //$rootsize = -2; |
| /*************** name type dir start size */ |
| $this->_writePps("Root Entry", 0x05, 1, -2, 0x00); |
| $this->_writePps("Book", 0x02, -1, 0x00, $this->_booksize); |
| $this->_writePps('', 0x00, -1, 0x00, 0x0000); |
| $this->_writePps('', 0x00, -1, 0x00, 0x0000); |
| } |
| |
| /** |
| * Write property sheet in property storage |
| * |
| * @param string $name name of the property storage. |
| * @param integer $type type of the property storage. |
| * @param integer $dir dir of the property storage. |
| * @param integer $start start of the property storage. |
| * @param integer $size size of the property storage. |
| * @access private |
| */ |
| function _writePps($name,$type,$dir,$start,$size) |
| { |
| $length = 0; |
| $rawname = ''; |
| |
| if ($name != '') |
| { |
| $name = $name . "\0"; |
| for($i=0;$i<strlen($name);$i++) |
| { |
| // Simulate a Unicode string |
| $rawname .= pack("H*",dechex(ord($name{$i}))).pack("C",0); |
| } |
| $length = strlen($name) * 2; |
| } |
| |
| $zero = pack("C", 0); |
| $pps_sizeofname = pack("v", $length); // 0x40 |
| $pps_type = pack("v", $type); // 0x42 |
| $pps_prev = pack("V", -1); // 0x44 |
| $pps_next = pack("V", -1); // 0x48 |
| $pps_dir = pack("V", $dir); // 0x4c |
| |
| $unknown1 = pack("V", 0); |
| |
| $pps_ts1s = pack("V", 0); // 0x64 |
| $pps_ts1d = pack("V", 0); // 0x68 |
| $pps_ts2s = pack("V", 0); // 0x6c |
| $pps_ts2d = pack("V", 0); // 0x70 |
| $pps_sb = pack("V", $start); // 0x74 |
| $pps_size = pack("V", $size); // 0x78 |
| |
| |
| fwrite($this->_filehandle,$rawname); |
| for($i=0; $i < (64 -$length); $i++) { |
| fwrite($this->_filehandle,$zero); |
| } |
| fwrite($this->_filehandle,$pps_sizeofname); |
| fwrite($this->_filehandle,$pps_type); |
| fwrite($this->_filehandle,$pps_prev); |
| fwrite($this->_filehandle,$pps_next); |
| fwrite($this->_filehandle,$pps_dir); |
| for($i=0; $i < 5; $i++) { |
| fwrite($this->_filehandle,$unknown1); |
| } |
| fwrite($this->_filehandle,$pps_ts1s); |
| fwrite($this->_filehandle,$pps_ts1d); |
| fwrite($this->_filehandle,$pps_ts2d); |
| fwrite($this->_filehandle,$pps_ts2d); |
| fwrite($this->_filehandle,$pps_sb); |
| fwrite($this->_filehandle,$pps_size); |
| fwrite($this->_filehandle,$unknown1); |
| } |
| |
| /** |
| * Pad the end of the file |
| * |
| * @access private |
| */ |
| function _writePadding() |
| { |
| $biffsize = $this->_biffsize; |
| if ($biffsize < 4096) { |
| $min_size = 4096; |
| } |
| else { |
| $min_size = 512; |
| } |
| if ($biffsize % $min_size != 0) |
| { |
| $padding = $min_size - ($biffsize % $min_size); |
| for($i=0; $i < $padding; $i++) { |
| fwrite($this->_filehandle,"\0"); |
| } |
| } |
| } |
| } |
| ?> |