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"); |
} |
} |
} |
} |
?> |