WebSVN – eFlore/Applications.cel – Diff – /trunk/jrest/lib/Spreadsheet/Excel/Writer/Workbook.php


<?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 'Spreadsheet/Excel/Writer/Format.php';
require_once 'Spreadsheet/Excel/Writer/BIFFwriter.php';
require_once 'Spreadsheet/Excel/Writer/Worksheet.php';
require_once 'Spreadsheet/Excel/Writer/Parser.php';
require_once 'OLE/PPS/Root.php';
require_once 'OLE/PPS/File.php';
 
/**
* Class for generating Excel Spreadsheets
*
* @author   Xavier Noguer <xnoguer@rezebra.com>
* @category FileFormats
* @package  Spreadsheet_Excel_Writer
*/
 
class Spreadsheet_Excel_Writer_Workbook extends Spreadsheet_Excel_Writer_BIFFwriter
{
    /**
    * Filename for the Workbook
    * @var string
    */
    var $_filename;
 
    /**
    * Formula parser
    * @var object Parser
    */
    var $_parser;
 
    /**
    * Flag for 1904 date system (0 => base date is 1900, 1 => base date is 1904)
    * @var integer
    */
    var $_1904;
 
    /**
    * The active worksheet of the workbook (0 indexed)
    * @var integer
    */
    var $_activesheet;
 
    /**
    * 1st displayed worksheet in the workbook (0 indexed)
    * @var integer
    */
    var $_firstsheet;
 
    /**
    * Number of workbook tabs selected
    * @var integer
    */
    var $_selected;
 
    /**
    * Index for creating adding new formats to the workbook
    * @var integer
    */
    var $_xf_index;
 
    /**
    * Flag for preventing close from being called twice.
    * @var integer
    * @see close()
    */
    var $_fileclosed;
 
    /**
    * The BIFF file size for the workbook.
    * @var integer
    * @see _calcSheetOffsets()
    */
    var $_biffsize;
 
    /**
    * The default sheetname for all sheets created.
    * @var string
    */
    var $_sheetname;
 
    /**
    * The default XF format.
    * @var object Format
    */
    var $_tmp_format;
 
    /**
    * Array containing references to all of this workbook's worksheets
    * @var array
    */
    var $_worksheets;
 
    /**
    * Array of sheetnames for creating the EXTERNSHEET records
    * @var array
    */
    var $_sheetnames;
 
    /**
    * Array containing references to all of this workbook's formats
    * @var array
    */
    var $_formats;
 
    /**
    * Array containing the colour palette
    * @var array
    */
    var $_palette;
 
    /**
    * The default format for URLs.
    * @var object Format
    */
    var $_url_format;
 
    /**
    * The codepage indicates the text encoding used for strings
    * @var integer
    */
    var $_codepage;
 
    /**
    * The country code used for localization
    * @var integer
    */
    var $_country_code;
 
    /**
    * number of bytes for sizeinfo of strings
    * @var integer
    */
    var $_string_sizeinfo_size;
 
    /**
    * Class constructor
    *
    * @param string filename for storing the workbook. "-" for writing to stdout.
    * @access public
    */
    function Spreadsheet_Excel_Writer_Workbook($filename)
    {
        // It needs to call its parent's constructor explicitly
        $this->Spreadsheet_Excel_Writer_BIFFwriter();
 
        $this->_filename         = $filename;
        $this->_parser           = new Spreadsheet_Excel_Writer_Parser($this->_byte_order, $this->_BIFF_version);
        $this->_1904             = 0;
        $this->_activesheet      = 0;
        $this->_firstsheet       = 0;
        $this->_selected         = 0;
        $this->_xf_index         = 16; // 15 style XF's and 1 cell XF.
        $this->_fileclosed       = 0;
        $this->_biffsize         = 0;
        $this->_sheetname        = 'Sheet';
        $this->_tmp_format       = new Spreadsheet_Excel_Writer_Format($this->_BIFF_version);
        $this->_worksheets       = array();
        $this->_sheetnames       = array();
        $this->_formats          = array();
        $this->_palette          = array();
        $this->_codepage         = 0x04E4; // FIXME: should change for BIFF8
        $this->_country_code     = -1;
        $this->_string_sizeinfo  = 3;
 
        // Add the default format for hyperlinks
        $this->_url_format =& $this->addFormat(array('color' => 'blue', 'underline' => 1));
        $this->_str_total       = 0;
        $this->_str_unique      = 0;
        $this->_str_table       = array();
        $this->_setPaletteXl97();
    }
 
    /**
    * Calls finalization methods.
    * This method should always be the last one to be called on every workbook
    *
    * @access public
    * @return mixed true on success. PEAR_Error on failure
    */
    function close()
    {
        if ($this->_fileclosed) { // Prevent close() from being called twice.
            return true;
        }
        $res = $this->_storeWorkbook();
        if ($this->isError($res)) {
            return $this->raiseError($res->getMessage());
        }
        $this->_fileclosed = 1;
        return true;
    }
 
    /**
    * An accessor for the _worksheets[] array
    * Returns an array of the worksheet objects in a workbook
    * It actually calls to worksheets()
    *
    * @access public
    * @see worksheets()
    * @return array
    */
    function sheets()
    {
        return $this->worksheets();
    }
 
    /**
    * An accessor for the _worksheets[] array.
    * Returns an array of the worksheet objects in a workbook
    *
    * @access public
    * @return array
    */
    function worksheets()
    {
        return $this->_worksheets;
    }
 
    /**
    * Sets the BIFF version.
    * This method exists just to access experimental functionality
    * from BIFF8. It will be deprecated !
    * Only possible value is 8 (Excel 97/2000).
    * For any other value it fails silently.
    *
    * @access public
    * @param integer $version The BIFF version
    */
    function setVersion($version)
    {
        if ($version == 8) { // only accept version 8
            $version = 0x0600;
            $this->_BIFF_version = $version;
            // change BIFFwriter limit for CONTINUE records
            $this->_limit = 8228;
            $this->_tmp_format->_BIFF_version = $version;
            $this->_url_format->_BIFF_version = $version;
            $this->_parser->_BIFF_version = $version;
            $this->_codepage = 0x04B0;
 
            $total_worksheets = count($this->_worksheets);
            // change version for all worksheets too
            for ($i = 0; $i < $total_worksheets; $i++) {
                $this->_worksheets[$i]->_BIFF_version = $version;
            }
 
            $total_formats = count($this->_formats);
            // change version for all formats too
            for ($i = 0; $i < $total_formats; $i++) {
                $this->_formats[$i]->_BIFF_version = $version;
            }
        }
    }
 
    /**
    * Set the country identifier for the workbook
    *
    * @access public
    * @param integer $code Is the international calling country code for the
    *                      chosen country.
    */
    function setCountry($code)
    {
        $this->_country_code = $code;
    }
 
    /**
    * Add a new worksheet to the Excel workbook.
    * If no name is given the name of the worksheet will be Sheeti$i, with
    * $i in [1..].
    *
    * @access public
    * @param string $name the optional name of the worksheet
    * @return mixed reference to a worksheet object on success, PEAR_Error
    *               on failure
    */
    function &addWorksheet($name = '')
    {
        $index     = count($this->_worksheets);
        $sheetname = $this->_sheetname;
 
        if ($name == '') {
            $name = $sheetname.($index+1);
        }
 
        // Check that sheetname is <= 31 chars (Excel limit before BIFF8).
        if ($this->_BIFF_version != 0x0600)
        {
            if (strlen($name) > 31) {
                return $this->raiseError("Sheetname $name must be <= 31 chars");
            }
        } else {
            if(function_exists('iconv')) {
                $name = iconv('UTF-8','UTF-16LE',$name);
            }
        }
 
        // Check that the worksheet name doesn't already exist: a fatal Excel error.
        $total_worksheets = count($this->_worksheets);
        for ($i = 0; $i < $total_worksheets; $i++) {
            if ($this->_worksheets[$i]->getName() == $name) {
                return $this->raiseError("Worksheet '$name' already exists");
            }
        }
 
        $worksheet = new Spreadsheet_Excel_Writer_Worksheet($this->_BIFF_version,
                                   $name, $index,
                                   $this->_activesheet, $this->_firstsheet,
                                   $this->_str_total, $this->_str_unique,
                                   $this->_str_table, $this->_url_format,
                                   $this->_parser, $this->_tmp_dir);
 
        $this->_worksheets[$index] = &$worksheet;    // Store ref for iterator
        $this->_sheetnames[$index] = $name;          // Store EXTERNSHEET names
        $this->_parser->setExtSheet($name, $index);  // Register worksheet name with parser
        return $worksheet;
    }
 
    /**
    * Add a new format to the Excel workbook.
    * Also, pass any properties to the Format constructor.
    *
    * @access public
    * @param array $properties array with properties for initializing the format.
    * @return &Spreadsheet_Excel_Writer_Format reference to an Excel Format
    */
    function &addFormat($properties = array())
    {
        $format = new Spreadsheet_Excel_Writer_Format($this->_BIFF_version, $this->_xf_index, $properties);
        $this->_xf_index += 1;
        $this->_formats[] = &$format;
        return $format;
    }
 
    /**
     * Create new validator.
     *
     * @access public
     * @return &Spreadsheet_Excel_Writer_Validator reference to a Validator
     */
    function &addValidator()
    {
        include_once 'Spreadsheet/Excel/Writer/Validator.php';
        /* FIXME: check for successful inclusion*/
        $valid = new Spreadsheet_Excel_Writer_Validator($this->_parser);
        return $valid;
    }
 
    /**
    * Change the RGB components of the elements in the colour palette.
    *
    * @access public
    * @param integer $index colour index
    * @param integer $red   red RGB value [0-255]
    * @param integer $green green RGB value [0-255]
    * @param integer $blue  blue RGB value [0-255]
    * @return integer The palette index for the custom color
    */
    function setCustomColor($index, $red, $green, $blue)
    {
        // Match a HTML #xxyyzz style parameter
        /*if (defined $_[1] and $_[1] =~ /^#(\w\w)(\w\w)(\w\w)/ ) {
            @_ = ($_[0], hex $1, hex $2, hex $3);
        }*/
 
        // Check that the colour index is the right range
        if ($index < 8 or $index > 64) {
            // TODO: assign real error codes
            return $this->raiseError("Color index $index outside range: 8 <= index <= 64");
        }
 
        // Check that the colour components are in the right range
        if (($red   < 0 or $red   > 255) ||
            ($green < 0 or $green > 255) ||
            ($blue  < 0 or $blue  > 255))
        {
            return $this->raiseError("Color component outside range: 0 <= color <= 255");
        }
 
        $index -= 8; // Adjust colour index (wingless dragonfly)
 
        // Set the RGB value
        $this->_palette[$index] = array($red, $green, $blue, 0);
        return($index + 8);
    }
 
    /**
    * Sets the colour palette to the Excel 97+ default.
    *
    * @access private
    */
    function _setPaletteXl97()
    {
        $this->_palette = array(
                           array(0x00, 0x00, 0x00, 0x00),   // 8
                           array(0xff, 0xff, 0xff, 0x00),   // 9
                           array(0xff, 0x00, 0x00, 0x00),   // 10
                           array(0x00, 0xff, 0x00, 0x00),   // 11
                           array(0x00, 0x00, 0xff, 0x00),   // 12
                           array(0xff, 0xff, 0x00, 0x00),   // 13
                           array(0xff, 0x00, 0xff, 0x00),   // 14
                           array(0x00, 0xff, 0xff, 0x00),   // 15
                           array(0x80, 0x00, 0x00, 0x00),   // 16
                           array(0x00, 0x80, 0x00, 0x00),   // 17
                           array(0x00, 0x00, 0x80, 0x00),   // 18
                           array(0x80, 0x80, 0x00, 0x00),   // 19
                           array(0x80, 0x00, 0x80, 0x00),   // 20
                           array(0x00, 0x80, 0x80, 0x00),   // 21
                           array(0xc0, 0xc0, 0xc0, 0x00),   // 22
                           array(0x80, 0x80, 0x80, 0x00),   // 23
                           array(0x99, 0x99, 0xff, 0x00),   // 24
                           array(0x99, 0x33, 0x66, 0x00),   // 25
                           array(0xff, 0xff, 0xcc, 0x00),   // 26
                           array(0xcc, 0xff, 0xff, 0x00),   // 27
                           array(0x66, 0x00, 0x66, 0x00),   // 28
                           array(0xff, 0x80, 0x80, 0x00),   // 29
                           array(0x00, 0x66, 0xcc, 0x00),   // 30
                           array(0xcc, 0xcc, 0xff, 0x00),   // 31
                           array(0x00, 0x00, 0x80, 0x00),   // 32
                           array(0xff, 0x00, 0xff, 0x00),   // 33
                           array(0xff, 0xff, 0x00, 0x00),   // 34
                           array(0x00, 0xff, 0xff, 0x00),   // 35
                           array(0x80, 0x00, 0x80, 0x00),   // 36
                           array(0x80, 0x00, 0x00, 0x00),   // 37
                           array(0x00, 0x80, 0x80, 0x00),   // 38
                           array(0x00, 0x00, 0xff, 0x00),   // 39
                           array(0x00, 0xcc, 0xff, 0x00),   // 40
                           array(0xcc, 0xff, 0xff, 0x00),   // 41
                           array(0xcc, 0xff, 0xcc, 0x00),   // 42
                           array(0xff, 0xff, 0x99, 0x00),   // 43
                           array(0x99, 0xcc, 0xff, 0x00),   // 44
                           array(0xff, 0x99, 0xcc, 0x00),   // 45
                           array(0xcc, 0x99, 0xff, 0x00),   // 46
                           array(0xff, 0xcc, 0x99, 0x00),   // 47
                           array(0x33, 0x66, 0xff, 0x00),   // 48
                           array(0x33, 0xcc, 0xcc, 0x00),   // 49
                           array(0x99, 0xcc, 0x00, 0x00),   // 50
                           array(0xff, 0xcc, 0x00, 0x00),   // 51
                           array(0xff, 0x99, 0x00, 0x00),   // 52
                           array(0xff, 0x66, 0x00, 0x00),   // 53
                           array(0x66, 0x66, 0x99, 0x00),   // 54
                           array(0x96, 0x96, 0x96, 0x00),   // 55
                           array(0x00, 0x33, 0x66, 0x00),   // 56
                           array(0x33, 0x99, 0x66, 0x00),   // 57
                           array(0x00, 0x33, 0x00, 0x00),   // 58
                           array(0x33, 0x33, 0x00, 0x00),   // 59
                           array(0x99, 0x33, 0x00, 0x00),   // 60
                           array(0x99, 0x33, 0x66, 0x00),   // 61
                           array(0x33, 0x33, 0x99, 0x00),   // 62
                           array(0x33, 0x33, 0x33, 0x00),   // 63
                         );
    }
 
    /**
    * Assemble worksheets into a workbook and send the BIFF data to an OLE
    * storage.
    *
    * @access private
    * @return mixed true on success. PEAR_Error on failure
    */
    function _storeWorkbook()
    {
        if (count($this->_worksheets) == 0) {
            return true;
        }
 
        // Ensure that at least one worksheet has been selected.
        if ($this->_activesheet == 0) {
            $this->_worksheets[0]->selected = 1;
        }
 
        // Calculate the number of selected worksheet tabs and call the finalization
        // methods for each worksheet
        $total_worksheets = count($this->_worksheets);
        for ($i = 0; $i < $total_worksheets; $i++) {
            if ($this->_worksheets[$i]->selected) {
                $this->_selected++;
            }
            $this->_worksheets[$i]->close($this->_sheetnames);
        }
 
        // Add Workbook globals
        $this->_storeBof(0x0005);
        $this->_storeCodepage();
        if ($this->_BIFF_version == 0x0600) {
            $this->_storeWindow1();
        }
        if ($this->_BIFF_version == 0x0500) {
            $this->_storeExterns();    // For print area and repeat rows
        }
        $this->_storeNames();      // For print area and repeat rows
        if ($this->_BIFF_version == 0x0500) {
            $this->_storeWindow1();
        }
        $this->_storeDatemode();
        $this->_storeAllFonts();
        $this->_storeAllNumFormats();
        $this->_storeAllXfs();
        $this->_storeAllStyles();
        $this->_storePalette();
        $this->_calcSheetOffsets();
 
        // Add BOUNDSHEET records
        for ($i = 0; $i < $total_worksheets; $i++) {
            $this->_storeBoundsheet($this->_worksheets[$i]->name,$this->_worksheets[$i]->offset);
        }
 
        if ($this->_country_code != -1) {
            $this->_storeCountry();
        }
 
        if ($this->_BIFF_version == 0x0600) {
            //$this->_storeSupbookInternal();
            /* TODO: store external SUPBOOK records and XCT and CRN records
            in case of external references for BIFF8 */
            //$this->_storeExternsheetBiff8();
            $this->_storeSharedStringsTable();
        }
 
        // End Workbook globals
        $this->_storeEof();
 
        // Store the workbook in an OLE container
        $res = $this->_storeOLEFile();
        if ($this->isError($res)) {
            return $this->raiseError($res->getMessage());
        }
        return true;
    }
 
    /**
    * Store the workbook in an OLE container
    *
    * @access private
    * @return mixed true on success. PEAR_Error on failure
    */
    function _storeOLEFile()
    {
        if($this->_BIFF_version == 0x0600) {
            $OLE = new OLE_PPS_File(OLE::Asc2Ucs('Workbook'));
        } else {
            $OLE = new OLE_PPS_File(OLE::Asc2Ucs('Book'));
        }
        if ($this->_tmp_dir != '') {
            $OLE->setTempDir($this->_tmp_dir);
        }
        $res = $OLE->init();
        if ($this->isError($res)) {
            return $this->raiseError("OLE Error: ".$res->getMessage());
        }
        $OLE->append($this->_data);
 
        $total_worksheets = count($this->_worksheets);
        for ($i = 0; $i < $total_worksheets; $i++) {
            while ($tmp = $this->_worksheets[$i]->getData()) {
                $OLE->append($tmp);
            }
        }
 
        $root = new OLE_PPS_Root(time(), time(), array($OLE));
        if ($this->_tmp_dir != '') {
            $root->setTempDir($this->_tmp_dir);
        }
 
        $res = $root->save($this->_filename);
        if ($this->isError($res)) {
            return $this->raiseError("OLE Error: ".$res->getMessage());
        }
        return true;
    }
 
    /**
    * Calculate offsets for Worksheet BOF records.
    *
    * @access private
    */
    function _calcSheetOffsets()
    {
        if ($this->_BIFF_version == 0x0600) {
            $boundsheet_length = 12;  // fixed length for a BOUNDSHEET record
        } else {
            $boundsheet_length = 11;
        }
        $EOF               = 4;
        $offset            = $this->_datasize;
 
        if ($this->_BIFF_version == 0x0600) {
            // add the length of the SST
            /* TODO: check this works for a lot of strings (> 8224 bytes) */
            $offset += $this->_calculateSharedStringsSizes();
            if ($this->_country_code != -1) {
                $offset += 8; // adding COUNTRY record
            }
            // add the lenght of SUPBOOK, EXTERNSHEET and NAME records
            //$offset += 8; // FIXME: calculate real value when storing the records
        }
        $total_worksheets = count($this->_worksheets);
        // add the length of the BOUNDSHEET records
        for ($i = 0; $i < $total_worksheets; $i++) {
            $offset += $boundsheet_length + strlen($this->_worksheets[$i]->name);
        }
        $offset += $EOF;
 
        for ($i = 0; $i < $total_worksheets; $i++) {
            $this->_worksheets[$i]->offset = $offset;
            $offset += $this->_worksheets[$i]->_datasize;
        }
        $this->_biffsize = $offset;
    }
 
    /**
    * Store the Excel FONT records.
    *
    * @access private
    */
    function _storeAllFonts()
    {
        // tmp_format is added by the constructor. We use this to write the default XF's
        $format = $this->_tmp_format;
        $font   = $format->getFont();
 
        // Note: Fonts are 0-indexed. According to the SDK there is no index 4,
        // so the following fonts are 0, 1, 2, 3, 5
        //
        for ($i = 1; $i <= 5; $i++){
            $this->_append($font);
        }
 
        // Iterate through the XF objects and write a FONT record if it isn't the
        // same as the default FONT and if it hasn't already been used.
        //
        $fonts = array();
        $index = 6;                  // The first user defined FONT
 
        $key = $format->getFontKey(); // The default font from _tmp_format
        $fonts[$key] = 0;             // Index of the default font
 
        $total_formats = count($this->_formats);
        for ($i = 0; $i < $total_formats; $i++) {
            $key = $this->_formats[$i]->getFontKey();
            if (isset($fonts[$key])) {
                // FONT has already been used
                $this->_formats[$i]->font_index = $fonts[$key];
            } else {
                // Add a new FONT record
                $fonts[$key]        = $index;
                $this->_formats[$i]->font_index = $index;
                $index++;
                $font = $this->_formats[$i]->getFont();
                $this->_append($font);
            }
        }
    }
 
    /**
    * Store user defined numerical formats i.e. FORMAT records
    *
    * @access private
    */
    function _storeAllNumFormats()
    {
        // Leaning num_format syndrome
        $hash_num_formats = array();
        $num_formats      = array();
        $index = 164;
 
        // Iterate through the XF objects and write a FORMAT record if it isn't a
        // built-in format type and if the FORMAT string hasn't already been used.
        $total_formats = count($this->_formats);
        for ($i = 0; $i < $total_formats; $i++) {
            $num_format = $this->_formats[$i]->_num_format;
 
            // Check if $num_format is an index to a built-in format.
            // Also check for a string of zeros, which is a valid format string
            // but would evaluate to zero.
            //
            if (!preg_match("/^0+\d/", $num_format)) {
                if (preg_match("/^\d+$/", $num_format)) { // built-in format
                    continue;
                }
            }
 
            if (isset($hash_num_formats[$num_format])) {
                // FORMAT has already been used
                $this->_formats[$i]->_num_format = $hash_num_formats[$num_format];
            } else{
                // Add a new FORMAT
                $hash_num_formats[$num_format]  = $index;
                $this->_formats[$i]->_num_format = $index;
                array_push($num_formats,$num_format);
                $index++;
            }
        }
 
        // Write the new FORMAT records starting from 0xA4
        $index = 164;
        foreach ($num_formats as $num_format) {
            $this->_storeNumFormat($num_format,$index);
            $index++;
        }
    }
 
    /**
    * Write all XF records.
    *
    * @access private
    */
    function _storeAllXfs()
    {
        // _tmp_format is added by the constructor. We use this to write the default XF's
        // The default font index is 0
        //
        $format = $this->_tmp_format;
        for ($i = 0; $i <= 14; $i++) {
            $xf = $format->getXf('style'); // Style XF
            $this->_append($xf);
        }
 
        $xf = $format->getXf('cell');      // Cell XF
        $this->_append($xf);
 
        // User defined XFs
        $total_formats = count($this->_formats);
        for ($i = 0; $i < $total_formats; $i++) {
            $xf = $this->_formats[$i]->getXf('cell');
            $this->_append($xf);
        }
    }
 
    /**
    * Write all STYLE records.
    *
    * @access private
    */
    function _storeAllStyles()
    {
        $this->_storeStyle();
    }
 
    /**
    * Write the EXTERNCOUNT and EXTERNSHEET records. These are used as indexes for
    * the NAME records.
    *
    * @access private
    */
    function _storeExterns()
 
    {
        // Create EXTERNCOUNT with number of worksheets
        $this->_storeExterncount(count($this->_worksheets));
 
        // Create EXTERNSHEET for each worksheet
        foreach ($this->_sheetnames as $sheetname) {
            $this->_storeExternsheet($sheetname);
        }
    }
 
    /**
    * Write the NAME record to define the print area and the repeat rows and cols.
    *
    * @access private
    */
    function _storeNames()
    {
        // Create the print area NAME records
        $total_worksheets = count($this->_worksheets);
        for ($i = 0; $i < $total_worksheets; $i++) {
            // Write a Name record if the print area has been defined
            if (isset($this->_worksheets[$i]->print_rowmin)) {
                $this->_storeNameShort(
                    $this->_worksheets[$i]->index,
                    0x06, // NAME type
                    $this->_worksheets[$i]->print_rowmin,
                    $this->_worksheets[$i]->print_rowmax,
                    $this->_worksheets[$i]->print_colmin,
                    $this->_worksheets[$i]->print_colmax
                    );
            }
        }
 
        // Create the print title NAME records
        $total_worksheets = count($this->_worksheets);
        for ($i = 0; $i < $total_worksheets; $i++) {
            $rowmin = $this->_worksheets[$i]->title_rowmin;
            $rowmax = $this->_worksheets[$i]->title_rowmax;
            $colmin = $this->_worksheets[$i]->title_colmin;
            $colmax = $this->_worksheets[$i]->title_colmax;
 
            // Determine if row + col, row, col or nothing has been defined
            // and write the appropriate record
            //
            if (isset($rowmin) && isset($colmin)) {
                // Row and column titles have been defined.
                // Row title has been defined.
                $this->_storeNameLong(
                    $this->_worksheets[$i]->index,
                    0x07, // NAME type
                    $rowmin,
                    $rowmax,
                    $colmin,
                    $colmax
                    );
            } elseif (isset($rowmin)) {
                // Row title has been defined.
                $this->_storeNameShort(
                    $this->_worksheets[$i]->index,
                    0x07, // NAME type
                    $rowmin,
                    $rowmax,
                    0x00,
                    0xff
                    );
            } elseif (isset($colmin)) {
                // Column title has been defined.
                $this->_storeNameShort(
                    $this->_worksheets[$i]->index,
                    0x07, // NAME type
                    0x0000,
                    0x3fff,
                    $colmin,
                    $colmax
                    );
            } else {
                // Print title hasn't been defined.
            }
        }
    }
 
 
 
 
    /******************************************************************************
    *
    * BIFF RECORDS
    *
    */
 
    /**
    * Stores the CODEPAGE biff record.
    *
    * @access private
    */
    function _storeCodepage()
    {
        $record          = 0x0042;             // Record identifier
        $length          = 0x0002;             // Number of bytes to follow
        $cv              = $this->_codepage;   // The code page
 
        $header          = pack('vv', $record, $length);
        $data            = pack('v',  $cv);
 
        $data = $header . $data;
		$this->_append($data);
    }
 
    /**
    * Write Excel BIFF WINDOW1 record.
    *
    * @access private
    */
    function _storeWindow1()
    {
        $record    = 0x003D;                 // Record identifier
        $length    = 0x0012;                 // Number of bytes to follow
 
        $xWn       = 0x0000;                 // Horizontal position of window
        $yWn       = 0x0000;                 // Vertical position of window
        $dxWn      = 0x25BC;                 // Width of window
        $dyWn      = 0x1572;                 // Height of window
 
        $grbit     = 0x0038;                 // Option flags
        $ctabsel   = $this->_selected;       // Number of workbook tabs selected
        $wTabRatio = 0x0258;                 // Tab to scrollbar ratio
 
        $itabFirst = $this->_firstsheet;     // 1st displayed worksheet
        $itabCur   = $this->_activesheet;    // Active worksheet
 
        $header    = pack("vv",        $record, $length);
        $data      = pack("vvvvvvvvv", $xWn, $yWn, $dxWn, $dyWn,
                                       $grbit,
                                       $itabCur, $itabFirst,
                                       $ctabsel, $wTabRatio);
        $data = $header . $data;
		$this->_append($data);
    }
 
    /**
    * Writes Excel BIFF BOUNDSHEET record.
    * FIXME: inconsistent with BIFF documentation
    *
    * @param string  $sheetname Worksheet name
    * @param integer $offset    Location of worksheet BOF
    * @access private
    */
    function _storeBoundsheet($sheetname,$offset)
    {
        $record    = 0x0085;                    // Record identifier
        if ($this->_BIFF_version == 0x0600) {
            $length    = 0x08 + strlen($sheetname); // Number of bytes to follow
        } else {
            $length = 0x07 + strlen($sheetname); // Number of bytes to follow
        }
 
        $grbit     = 0x0000;                    // Visibility and sheet type
        if ($this->_BIFF_version == 0x0600) {
            $cch       = mb_strlen($sheetname,'UTF-16LE'); // Length of sheet name
        } else {
            $cch       = strlen($sheetname);        // Length of sheet name
        }
 
        $header    = pack("vv",  $record, $length);
        if ($this->_BIFF_version == 0x0600) {
            $data      = pack("VvCC", $offset, $grbit, $cch, 0x1);
        } else {
            $data      = pack("VvC", $offset, $grbit, $cch);
        }
 
		$data = $header.$data.$sheetname;
        $this->_append($data);
    }
 
    /**
    * Write Internal SUPBOOK record
    *
    * @access private
    */
    function _storeSupbookInternal()
    {
        $record    = 0x01AE;   // Record identifier
        $length    = 0x0004;   // Bytes to follow
 
        $header    = pack("vv", $record, $length);
        $data      = pack("vv", count($this->_worksheets), 0x0104);
        $data = $header . $data;
		$this->_append($data);
    }
 
    /**
    * Writes the Excel BIFF EXTERNSHEET record. These references are used by
    * formulas.
    *
    * @param string $sheetname Worksheet name
    * @access private
    */
    function _storeExternsheetBiff8()
    {
        $total_references = count($this->_parser->_references);
        $record   = 0x0017;                     // Record identifier
        $length   = 2 + 6 * $total_references;  // Number of bytes to follow
 
        $supbook_index = 0;           // FIXME: only using internal SUPBOOK record
        $header           = pack("vv",  $record, $length);
        $data             = pack('v', $total_references);
        for ($i = 0; $i < $total_references; $i++) {
            $data .= $this->_parser->_references[$i];
        }
        $data = $header . $data;
		$this->_append($data);
    }
 
    /**
    * Write Excel BIFF STYLE records.
    *
    * @access private
    */
    function _storeStyle()
    {
        $record    = 0x0293;   // Record identifier
        $length    = 0x0004;   // Bytes to follow
 
        $ixfe      = 0x8000;   // Index to style XF
        $BuiltIn   = 0x00;     // Built-in style
        $iLevel    = 0xff;     // Outline style level
 
        $header    = pack("vv",  $record, $length);
        $data      = pack("vCC", $ixfe, $BuiltIn, $iLevel);
        $data = $header . $data;
		$this->_append($data);
    }
 
 
    /**
    * Writes Excel FORMAT record for non "built-in" numerical formats.
    *
    * @param string  $format Custom format string
    * @param integer $ifmt   Format index code
    * @access private
    */
    function _storeNumFormat($format, $ifmt)
    {
        $record    = 0x041E;                      // Record identifier
 
        if ($this->_BIFF_version == 0x0600) {
            $length    = 5 + strlen($format);      // Number of bytes to follow
            $encoding = 0x0;
        } elseif ($this->_BIFF_version == 0x0500) {
            $length    = 3 + strlen($format);      // Number of bytes to follow
        }
 
        if ( $this->_BIFF_version == 0x0600 && function_exists('iconv') ) {     // Encode format String
            if (mb_detect_encoding($format, 'auto') !== 'UTF-16LE'){
                $format = iconv(mb_detect_encoding($format, 'auto'),'UTF-16LE',$format);
            }
            $encoding = 1;
            $cch = function_exists('mb_strlen') ? mb_strlen($format, 'UTF-16LE') : (strlen($format) / 2);
        } else {
            $encoding = 0;
            $cch  = strlen($format);             // Length of format string
        }
        $length = strlen($format);
 
        if ($this->_BIFF_version == 0x0600) {
            $header    = pack("vv", $record, 5 + $length);
            $data      = pack("vvC", $ifmt, $cch, $encoding);
        } elseif ($this->_BIFF_version == 0x0500) {
            $header    = pack("vv", $record, 3 + $length);
            $data      = pack("vC", $ifmt, $cch);
        }
		$data = $header . $data . $format;
        $this->_append($data);
    }
 
    /**
    * Write DATEMODE record to indicate the date system in use (1904 or 1900).
    *
    * @access private
    */
    function _storeDatemode()
    {
        $record    = 0x0022;         // Record identifier
        $length    = 0x0002;         // Bytes to follow
 
        $f1904     = $this->_1904;   // Flag for 1904 date system
 
        $header    = pack("vv", $record, $length);
        $data      = pack("v", $f1904);
        $data = $header . $data;
		$this->_append($data);
    }
 
 
    /**
    * Write BIFF record EXTERNCOUNT to indicate the number of external sheet
    * references in the workbook.
    *
    * Excel only stores references to external sheets that are used in NAME.
    * The workbook NAME record is required to define the print area and the repeat
    * rows and columns.
    *
    * A similar method is used in Worksheet.php for a slightly different purpose.
    *
    * @param integer $cxals Number of external references
    * @access private
    */
    function _storeExterncount($cxals)
    {
        $record   = 0x0016;          // Record identifier
        $length   = 0x0002;          // Number of bytes to follow
 
        $header   = pack("vv", $record, $length);
        $data     = pack("v",  $cxals);
        $data = $header . $data;
		$this->_append($data);
    }
 
 
    /**
    * Writes the Excel BIFF EXTERNSHEET record. These references are used by
    * formulas. NAME record is required to define the print area and the repeat
    * rows and columns.
    *
    * A similar method is used in Worksheet.php for a slightly different purpose.
    *
    * @param string $sheetname Worksheet name
    * @access private
    */
    function _storeExternsheet($sheetname)
    {
        $record      = 0x0017;                     // Record identifier
        $length      = 0x02 + strlen($sheetname);  // Number of bytes to follow
 
        $cch         = strlen($sheetname);         // Length of sheet name
        $rgch        = 0x03;                       // Filename encoding
 
        $header      = pack("vv",  $record, $length);
        $data        = pack("CC", $cch, $rgch);
		$data = $header . $data . $sheetname;
        $this->_append($data);
    }
 
 
    /**
    * Store the NAME record in the short format that is used for storing the print
    * area, repeat rows only and repeat columns only.
    *
    * @param integer $index  Sheet index
    * @param integer $type   Built-in name type
    * @param integer $rowmin Start row
    * @param integer $rowmax End row
    * @param integer $colmin Start colum
    * @param integer $colmax End column
    * @access private
    */
    function _storeNameShort($index, $type, $rowmin, $rowmax, $colmin, $colmax)
    {
        $record          = 0x0018;       // Record identifier
        $length          = 0x0024;       // Number of bytes to follow
 
        $grbit           = 0x0020;       // Option flags
        $chKey           = 0x00;         // Keyboard shortcut
        $cch             = 0x01;         // Length of text name
        $cce             = 0x0015;       // Length of text definition
        $ixals           = $index + 1;   // Sheet index
        $itab            = $ixals;       // Equal to ixals
        $cchCustMenu     = 0x00;         // Length of cust menu text
        $cchDescription  = 0x00;         // Length of description text
        $cchHelptopic    = 0x00;         // Length of help topic text
        $cchStatustext   = 0x00;         // Length of status bar text
        $rgch            = $type;        // Built-in name type
 
        $unknown03       = 0x3b;
        $unknown04       = 0xffff-$index;
        $unknown05       = 0x0000;
        $unknown06       = 0x0000;
        $unknown07       = 0x1087;
        $unknown08       = 0x8005;
 
        $header             = pack("vv", $record, $length);
        $data               = pack("v", $grbit);
        $data              .= pack("C", $chKey);
        $data              .= pack("C", $cch);
        $data              .= pack("v", $cce);
        $data              .= pack("v", $ixals);
        $data              .= pack("v", $itab);
        $data              .= pack("C", $cchCustMenu);
        $data              .= pack("C", $cchDescription);
        $data              .= pack("C", $cchHelptopic);
        $data              .= pack("C", $cchStatustext);
        $data              .= pack("C", $rgch);
        $data              .= pack("C", $unknown03);
        $data              .= pack("v", $unknown04);
        $data              .= pack("v", $unknown05);
        $data              .= pack("v", $unknown06);
        $data              .= pack("v", $unknown07);
        $data              .= pack("v", $unknown08);
        $data              .= pack("v", $index);
        $data              .= pack("v", $index);
        $data              .= pack("v", $rowmin);
        $data              .= pack("v", $rowmax);
        $data              .= pack("C", $colmin);
        $data              .= pack("C", $colmax);
        $data = $header . $data;
		$this->_append($data);
    }
 
 
    /**
    * Store the NAME record in the long format that is used for storing the repeat
    * rows and columns when both are specified. This shares a lot of code with
    * _storeNameShort() but we use a separate method to keep the code clean.
    * Code abstraction for reuse can be carried too far, and I should know. ;-)
    *
    * @param integer $index Sheet index
    * @param integer $type  Built-in name type
    * @param integer $rowmin Start row
    * @param integer $rowmax End row
    * @param integer $colmin Start colum
    * @param integer $colmax End column
    * @access private
    */
    function _storeNameLong($index, $type, $rowmin, $rowmax, $colmin, $colmax)
    {
        $record          = 0x0018;       // Record identifier
        $length          = 0x003d;       // Number of bytes to follow
        $grbit           = 0x0020;       // Option flags
        $chKey           = 0x00;         // Keyboard shortcut
        $cch             = 0x01;         // Length of text name
        $cce             = 0x002e;       // Length of text definition
        $ixals           = $index + 1;   // Sheet index
        $itab            = $ixals;       // Equal to ixals
        $cchCustMenu     = 0x00;         // Length of cust menu text
        $cchDescription  = 0x00;         // Length of description text
        $cchHelptopic    = 0x00;         // Length of help topic text
        $cchStatustext   = 0x00;         // Length of status bar text
        $rgch            = $type;        // Built-in name type
 
        $unknown01       = 0x29;
        $unknown02       = 0x002b;
        $unknown03       = 0x3b;
        $unknown04       = 0xffff-$index;
        $unknown05       = 0x0000;
        $unknown06       = 0x0000;
        $unknown07       = 0x1087;
        $unknown08       = 0x8008;
 
        $header             = pack("vv",  $record, $length);
        $data               = pack("v", $grbit);
        $data              .= pack("C", $chKey);
        $data              .= pack("C", $cch);
        $data              .= pack("v", $cce);
        $data              .= pack("v", $ixals);
        $data              .= pack("v", $itab);
        $data              .= pack("C", $cchCustMenu);
        $data              .= pack("C", $cchDescription);
        $data              .= pack("C", $cchHelptopic);
        $data              .= pack("C", $cchStatustext);
        $data              .= pack("C", $rgch);
        $data              .= pack("C", $unknown01);
        $data              .= pack("v", $unknown02);
        // Column definition
        $data              .= pack("C", $unknown03);
        $data              .= pack("v", $unknown04);
        $data              .= pack("v", $unknown05);
        $data              .= pack("v", $unknown06);
        $data              .= pack("v", $unknown07);
        $data              .= pack("v", $unknown08);
        $data              .= pack("v", $index);
        $data              .= pack("v", $index);
        $data              .= pack("v", 0x0000);
        $data              .= pack("v", 0x3fff);
        $data              .= pack("C", $colmin);
        $data              .= pack("C", $colmax);
        // Row definition
        $data              .= pack("C", $unknown03);
        $data              .= pack("v", $unknown04);
        $data              .= pack("v", $unknown05);
        $data              .= pack("v", $unknown06);
        $data              .= pack("v", $unknown07);
        $data              .= pack("v", $unknown08);
        $data              .= pack("v", $index);
        $data              .= pack("v", $index);
        $data              .= pack("v", $rowmin);
        $data              .= pack("v", $rowmax);
        $data              .= pack("C", 0x00);
        $data              .= pack("C", 0xff);
        // End of data
        $data              .= pack("C", 0x10);
        $data = $header . $data;
		$this->_append($data);
    }
 
    /**
    * Stores the COUNTRY record for localization
    *
    * @access private
    */
    function _storeCountry()
    {
        $record          = 0x008C;    // Record identifier
        $length          = 4;         // Number of bytes to follow
 
        $header = pack('vv',  $record, $length);
        /* using the same country code always for simplicity */
        $data = pack('vv', $this->_country_code, $this->_country_code);
        $data = $header . $data;
		$this->_append($data);
    }
 
    /**
    * Stores the PALETTE biff record.
    *
    * @access private
    */
    function _storePalette()
    {
        $aref            = $this->_palette;
 
        $record          = 0x0092;                 // Record identifier
        $length          = 2 + 4 * count($aref);   // Number of bytes to follow
        $ccv             =         count($aref);   // Number of RGB values to follow
        $data = '';                                // The RGB data
 
        // Pack the RGB data
        foreach ($aref as $color) {
            foreach ($color as $byte) {
                $data .= pack("C",$byte);
            }
        }
 
        $header = pack("vvv",  $record, $length, $ccv);
        $data = $header . $data;
		$this->_append($data);
    }
 
    /**
    * Calculate
    * Handling of the SST continue blocks is complicated by the need to include an
    * additional continuation byte depending on whether the string is split between
    * blocks or whether it starts at the beginning of the block. (There are also
    * additional complications that will arise later when/if Rich Strings are
    * supported).
    *
    * @access private
    */
    function _calculateSharedStringsSizes()
    {
        /* Iterate through the strings to calculate the CONTINUE block sizes.
           For simplicity we use the same size for the SST and CONTINUE records:
           8228 : Maximum Excel97 block size
             -4 : Length of block header
             -8 : Length of additional SST header information
             -8 : Arbitrary number to keep within _add_continue() limit = 8208
        */
        $continue_limit     = 8208;
        $block_length       = 0;
        $written            = 0;
        $this->_block_sizes = array();
        $continue           = 0;
 
        foreach (array_keys($this->_str_table) as $string) {
            $string_length = strlen($string);
            $headerinfo    = unpack("vlength/Cencoding", $string);
            $encoding      = $headerinfo["encoding"];
            $split_string  = 0;
 
            // Block length is the total length of the strings that will be
            // written out in a single SST or CONTINUE block.
            $block_length += $string_length;
 
            // We can write the string if it doesn't cross a CONTINUE boundary
            if ($block_length < $continue_limit) {
                $written      += $string_length;
                continue;
            }
 
            // Deal with the cases where the next string to be written will exceed
            // the CONTINUE boundary. If the string is very long it may need to be
            // written in more than one CONTINUE record.
            while ($block_length >= $continue_limit) {
 
                // We need to avoid the case where a string is continued in the first
                // n bytes that contain the string header information.
                $header_length   = 3; // Min string + header size -1
                $space_remaining = $continue_limit - $written - $continue;
 
 
                /* TODO: Unicode data should only be split on char (2 byte)
                boundaries. Therefore, in some cases we need to reduce the
                amount of available
                */
                $align = 0;
 
                // Only applies to Unicode strings
                if ($encoding == 1) {
                    // Min string + header size -1
                    $header_length = 4;
 
                    if ($space_remaining > $header_length) {
                        // String contains 3 byte header => split on odd boundary
                        if (!$split_string && $space_remaining % 2 != 1) {
                            $space_remaining--;
                            $align = 1;
                        }
                        // Split section without header => split on even boundary
                        else if ($split_string && $space_remaining % 2 == 1) {
                            $space_remaining--;
                            $align = 1;
                        }
 
                        $split_string = 1;
                    }
                }
 
 
                if ($space_remaining > $header_length) {
                    // Write as much as possible of the string in the current block
                    $written      += $space_remaining;
 
                    // Reduce the current block length by the amount written
                    $block_length -= $continue_limit - $continue - $align;
 
                    // Store the max size for this block
                    $this->_block_sizes[] = $continue_limit - $align;
 
                    // If the current string was split then the next CONTINUE block
                    // should have the string continue flag (grbit) set unless the
                    // split string fits exactly into the remaining space.
                    if ($block_length > 0) {
                        $continue = 1;
                    } else {
                        $continue = 0;
                    }
                } else {
                    // Store the max size for this block
                    $this->_block_sizes[] = $written + $continue;
 
                    // Not enough space to start the string in the current block
                    $block_length -= $continue_limit - $space_remaining - $continue;
                    $continue = 0;
 
                }
 
                // If the string (or substr) is small enough we can write it in the
                // new CONTINUE block. Else, go through the loop again to write it in
                // one or more CONTINUE blocks
                if ($block_length < $continue_limit) {
                    $written = $block_length;
                } else {
                    $written = 0;
                }
            }
        }
 
        // Store the max size for the last block unless it is empty
        if ($written + $continue) {
            $this->_block_sizes[] = $written + $continue;
        }
 
 
        /* Calculate the total length of the SST and associated CONTINUEs (if any).
         The SST record will have a length even if it contains no strings.
         This length is required to set the offsets in the BOUNDSHEET records since
         they must be written before the SST records
        */
 
        $tmp_block_sizes = array();
        $tmp_block_sizes = $this->_block_sizes;
 
        $length  = 12;
        if (!empty($tmp_block_sizes)) {
            $length += array_shift($tmp_block_sizes); // SST
        }
        while (!empty($tmp_block_sizes)) {
            $length += 4 + array_shift($tmp_block_sizes); // CONTINUEs
        }
 
        return $length;
    }
 
    /**
    * Write all of the workbooks strings into an indexed array.
    * See the comments in _calculate_shared_string_sizes() for more information.
    *
    * The Excel documentation says that the SST record should be followed by an
    * EXTSST record. The EXTSST record is a hash table that is used to optimise
    * access to SST. However, despite the documentation it doesn't seem to be
    * required so we will ignore it.
    *
    * @access private
    */
    function _storeSharedStringsTable()
    {
        $record  = 0x00fc;  // Record identifier
        $length  = 0x0008;  // Number of bytes to follow
        $total   = 0x0000;
 
        // Iterate through the strings to calculate the CONTINUE block sizes
        $continue_limit = 8208;
        $block_length   = 0;
        $written        = 0;
        $continue       = 0;
 
        // sizes are upside down
        $tmp_block_sizes = $this->_block_sizes;
        // $tmp_block_sizes = array_reverse($this->_block_sizes);
 
        // The SST record is required even if it contains no strings. Thus we will
        // always have a length
        //
        if (!empty($tmp_block_sizes)) {
            $length = 8 + array_shift($tmp_block_sizes);
        }
        else {
            // No strings
            $length = 8;
        }
 
 
 
        // Write the SST block header information
        $header      = pack("vv", $record, $length);
        $data        = pack("VV", $this->_str_total, $this->_str_unique);
        $data = $header . $data;
		$this->_append($data);
 
 
 
 
        /* TODO: not good for performance */
        foreach (array_keys($this->_str_table) as $string) {
 
            $string_length = strlen($string);
            $headerinfo    = unpack("vlength/Cencoding", $string);
            $encoding      = $headerinfo["encoding"];
            $split_string  = 0;
 
            // Block length is the total length of the strings that will be
            // written out in a single SST or CONTINUE block.
            //
            $block_length += $string_length;
 
 
            // We can write the string if it doesn't cross a CONTINUE boundary
            if ($block_length < $continue_limit) {
                $this->_append($string);
                $written += $string_length;
                continue;
            }
 
            // Deal with the cases where the next string to be written will exceed
            // the CONTINUE boundary. If the string is very long it may need to be
            // written in more than one CONTINUE record.
            //
            while ($block_length >= $continue_limit) {
 
                // We need to avoid the case where a string is continued in the first
                // n bytes that contain the string header information.
                //
                $header_length   = 3; // Min string + header size -1
                $space_remaining = $continue_limit - $written - $continue;
 
 
                // Unicode data should only be split on char (2 byte) boundaries.
                // Therefore, in some cases we need to reduce the amount of available
                // space by 1 byte to ensure the correct alignment.
                $align = 0;
 
                // Only applies to Unicode strings
                if ($encoding == 1) {
                    // Min string + header size -1
                    $header_length = 4;
 
                    if ($space_remaining > $header_length) {
                        // String contains 3 byte header => split on odd boundary
                        if (!$split_string && $space_remaining % 2 != 1) {
                            $space_remaining--;
                            $align = 1;
                        }
                        // Split section without header => split on even boundary
                        else if ($split_string && $space_remaining % 2 == 1) {
                            $space_remaining--;
                            $align = 1;
                        }
 
                        $split_string = 1;
                    }
                }
 
 
                if ($space_remaining > $header_length) {
                    // Write as much as possible of the string in the current block
                    $tmp = substr($string, 0, $space_remaining);
                    $this->_append($tmp);
 
                    // The remainder will be written in the next block(s)
                    $string = substr($string, $space_remaining);
 
                    // Reduce the current block length by the amount written
                    $block_length -= $continue_limit - $continue - $align;
 
                    // If the current string was split then the next CONTINUE block
                    // should have the string continue flag (grbit) set unless the
                    // split string fits exactly into the remaining space.
                    //
                    if ($block_length > 0) {
                        $continue = 1;
                    } else {
                        $continue = 0;
                    }
                } else {
                    // Not enough space to start the string in the current block
                    $block_length -= $continue_limit - $space_remaining - $continue;
                    $continue = 0;
                }
 
                // Write the CONTINUE block header
                if (!empty($this->_block_sizes)) {
                    $record  = 0x003C;
                    $length  = array_shift($tmp_block_sizes);
 
                    $header  = pack('vv', $record, $length);
                    if ($continue) {
                        $header .= pack('C', $encoding);
                    }
                    $this->_append($header);
                }
 
                // If the string (or substr) is small enough we can write it in the
                // new CONTINUE block. Else, go through the loop again to write it in
                // one or more CONTINUE blocks
                //
                if ($block_length < $continue_limit) {
                    $this->_append($string);
                    $written = $block_length;
                } else {
                    $written = 0;
                }
            }
        }
    }
 
 
}
 

Rev 1604	Rev 1605
1	`<?php`	1	`<?php`
2	`/*`	2	`/*`
3	`* Module written/ported by Xavier Noguer <xnoguer@rezebra.com>`	3	`* Module written/ported by Xavier Noguer <xnoguer@rezebra.com>`
4	`*`	4	`*`
5	`* The majority of this is _NOT_ my code. I simply ported it from the`	5	`* The majority of this is _NOT_ my code. I simply ported it from the`
6	`* PERL Spreadsheet::WriteExcel module.`	6	`* PERL Spreadsheet::WriteExcel module.`
7	`*`	7	`*`
8	`* The author of the Spreadsheet::WriteExcel module is John McNamara`	8	`* The author of the Spreadsheet::WriteExcel module is John McNamara`
9	`* <jmcnamara@cpan.org>`	9	`* <jmcnamara@cpan.org>`
10	`*`	10	`*`
11	`* I _DO_ maintain this code, and John McNamara has nothing to do with the`	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`	12	`* porting of this code to PHP. Any questions directly related to this`
13	`* class library should be directed to me.`	13	`* class library should be directed to me.`
14	`*`	14	`*`
15	`* License Information:`	15	`* License Information:`
16	`*`	16	`*`
17	`* Spreadsheet_Excel_Writer: A library for generating Excel Spreadsheets`	17	`* Spreadsheet_Excel_Writer: A library for generating Excel Spreadsheets`
18	`* Copyright (c) 2002-2003 Xavier Noguer xnoguer@rezebra.com`	18	`* Copyright (c) 2002-2003 Xavier Noguer xnoguer@rezebra.com`
19	`*`	19	`*`
20	`* This library is free software; you can redistribute it and/or`	20	`* This library is free software; you can redistribute it and/or`
21	`* modify it under the terms of the GNU Lesser General Public`	21	`* modify it under the terms of the GNU Lesser General Public`
22	`* License as published by the Free Software Foundation; either`	22	`* License as published by the Free Software Foundation; either`
23	`* version 2.1 of the License, or (at your option) any later version.`	23	`* version 2.1 of the License, or (at your option) any later version.`
24	`*`	24	`*`
25	`* This library is distributed in the hope that it will be useful,`	25	`* This library is distributed in the hope that it will be useful,`
26	`* but WITHOUT ANY WARRANTY; without even the implied warranty of`	26	`* but WITHOUT ANY WARRANTY; without even the implied warranty of`
27	`* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU`	27	`* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU`
28	`* Lesser General Public License for more details.`	28	`* Lesser General Public License for more details.`
29	`*`	29	`*`
30	`* You should have received a copy of the GNU Lesser General Public`	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`	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`	32	`* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA`
33	`*/`	33	`*/`
34		34
35	`require_once 'Spreadsheet/Excel/Writer/Format.php';`	35	`require_once 'Spreadsheet/Excel/Writer/Format.php';`
36	`require_once 'Spreadsheet/Excel/Writer/BIFFwriter.php';`	36	`require_once 'Spreadsheet/Excel/Writer/BIFFwriter.php';`
37	`require_once 'Spreadsheet/Excel/Writer/Worksheet.php';`	37	`require_once 'Spreadsheet/Excel/Writer/Worksheet.php';`
38	`require_once 'Spreadsheet/Excel/Writer/Parser.php';`	38	`require_once 'Spreadsheet/Excel/Writer/Parser.php';`
39	`require_once 'OLE/PPS/Root.php';`	39	`require_once 'OLE/PPS/Root.php';`
40	`require_once 'OLE/PPS/File.php';`	40	`require_once 'OLE/PPS/File.php';`
41		41
42	`/**`	42	`/**`
43	`* Class for generating Excel Spreadsheets`	43	`* Class for generating Excel Spreadsheets`
44	`*`	44	`*`
45	`* @author Xavier Noguer <xnoguer@rezebra.com>`	45	`* @author Xavier Noguer <xnoguer@rezebra.com>`
46	`* @category FileFormats`	46	`* @category FileFormats`
47	`* @package Spreadsheet_Excel_Writer`	47	`* @package Spreadsheet_Excel_Writer`
48	`*/`	48	`*/`
49		49
50	`class Spreadsheet_Excel_Writer_Workbook extends Spreadsheet_Excel_Writer_BIFFwriter`	50	`class Spreadsheet_Excel_Writer_Workbook extends Spreadsheet_Excel_Writer_BIFFwriter`
51	`{`	51	`{`
52	`/**`	52	`/**`
53	`* Filename for the Workbook`	53	`* Filename for the Workbook`
54	`* @var string`	54	`* @var string`
55	`*/`	55	`*/`
56	`var $_filename;`	56	`var $_filename;`
57		57
58	`/**`	58	`/**`
59	`* Formula parser`	59	`* Formula parser`
60	`* @var object Parser`	60	`* @var object Parser`
61	`*/`	61	`*/`
62	`var $_parser;`	62	`var $_parser;`
63		63
64	`/**`	64	`/**`
65	`* Flag for 1904 date system (0 => base date is 1900, 1 => base date is 1904)`	65	`* Flag for 1904 date system (0 => base date is 1900, 1 => base date is 1904)`
66	`* @var integer`	66	`* @var integer`
67	`*/`	67	`*/`
68	`var $_1904;`	68	`var $_1904;`
69		69
70	`/**`	70	`/**`
71	`* The active worksheet of the workbook (0 indexed)`	71	`* The active worksheet of the workbook (0 indexed)`
72	`* @var integer`	72	`* @var integer`
73	`*/`	73	`*/`
74	`var $_activesheet;`	74	`var $_activesheet;`
75		75
76	`/**`	76	`/**`
77	`* 1st displayed worksheet in the workbook (0 indexed)`	77	`* 1st displayed worksheet in the workbook (0 indexed)`
78	`* @var integer`	78	`* @var integer`
79	`*/`	79	`*/`
80	`var $_firstsheet;`	80	`var $_firstsheet;`
81		81
82	`/**`	82	`/**`
83	`* Number of workbook tabs selected`	83	`* Number of workbook tabs selected`
84	`* @var integer`	84	`* @var integer`
85	`*/`	85	`*/`
86	`var $_selected;`	86	`var $_selected;`
87		87
88	`/**`	88	`/**`
89	`* Index for creating adding new formats to the workbook`	89	`* Index for creating adding new formats to the workbook`
90	`* @var integer`	90	`* @var integer`
91	`*/`	91	`*/`
92	`var $_xf_index;`	92	`var $_xf_index;`
93		93
94	`/**`	94	`/**`
95	`* Flag for preventing close from being called twice.`	95	`* Flag for preventing close from being called twice.`
96	`* @var integer`	96	`* @var integer`
97	`* @see close()`	97	`* @see close()`
98	`*/`	98	`*/`
99	`var $_fileclosed;`	99	`var $_fileclosed;`
100		100
101	`/**`	101	`/**`
102	`* The BIFF file size for the workbook.`	102	`* The BIFF file size for the workbook.`
103	`* @var integer`	103	`* @var integer`
104	`* @see _calcSheetOffsets()`	104	`* @see _calcSheetOffsets()`
105	`*/`	105	`*/`
106	`var $_biffsize;`	106	`var $_biffsize;`
107		107
108	`/**`	108	`/**`
109	`* The default sheetname for all sheets created.`	109	`* The default sheetname for all sheets created.`
110	`* @var string`	110	`* @var string`
111	`*/`	111	`*/`
112	`var $_sheetname;`	112	`var $_sheetname;`
113		113
114	`/**`	114	`/**`
115	`* The default XF format.`	115	`* The default XF format.`
116	`* @var object Format`	116	`* @var object Format`
117	`*/`	117	`*/`
118	`var $_tmp_format;`	118	`var $_tmp_format;`
119		119
120	`/**`	120	`/**`
121	`* Array containing references to all of this workbook's worksheets`	121	`* Array containing references to all of this workbook's worksheets`
122	`* @var array`	122	`* @var array`
123	`*/`	123	`*/`
124	`var $_worksheets;`	124	`var $_worksheets;`
125		125
126	`/**`	126	`/**`
127	`* Array of sheetnames for creating the EXTERNSHEET records`	127	`* Array of sheetnames for creating the EXTERNSHEET records`
128	`* @var array`	128	`* @var array`
129	`*/`	129	`*/`
130	`var $_sheetnames;`	130	`var $_sheetnames;`
131		131
132	`/**`	132	`/**`
133	`* Array containing references to all of this workbook's formats`	133	`* Array containing references to all of this workbook's formats`
134	`* @var array`	134	`* @var array`
135	`*/`	135	`*/`
136	`var $_formats;`	136	`var $_formats;`
137		137
138	`/**`	138	`/**`
139	`* Array containing the colour palette`	139	`* Array containing the colour palette`
140	`* @var array`	140	`* @var array`
141	`*/`	141	`*/`
142	`var $_palette;`	142	`var $_palette;`
143		143
144	`/**`	144	`/**`
145	`* The default format for URLs.`	145	`* The default format for URLs.`
146	`* @var object Format`	146	`* @var object Format`
147	`*/`	147	`*/`
148	`var $_url_format;`	148	`var $_url_format;`
149		149
150	`/**`	150	`/**`
151	`* The codepage indicates the text encoding used for strings`	151	`* The codepage indicates the text encoding used for strings`
152	`* @var integer`	152	`* @var integer`
153	`*/`	153	`*/`
154	`var $_codepage;`	154	`var $_codepage;`
155		155
156	`/**`	156	`/**`
157	`* The country code used for localization`	157	`* The country code used for localization`
158	`* @var integer`	158	`* @var integer`
159	`*/`	159	`*/`
160	`var $_country_code;`	160	`var $_country_code;`
161		161
162	`/**`	162	`/**`
163	`* number of bytes for sizeinfo of strings`	163	`* number of bytes for sizeinfo of strings`
164	`* @var integer`	164	`* @var integer`
165	`*/`	165	`*/`
166	`var $_string_sizeinfo_size;`	166	`var $_string_sizeinfo_size;`
167		167
168	`/**`	168	`/**`
169	`* Class constructor`	169	`* Class constructor`
170	`*`	170	`*`
171	`* @param string filename for storing the workbook. "-" for writing to stdout.`	171	`* @param string filename for storing the workbook. "-" for writing to stdout.`
172	`* @access public`	172	`* @access public`
173	`*/`	173	`*/`
174	`function Spreadsheet_Excel_Writer_Workbook($filename)`	174	`function Spreadsheet_Excel_Writer_Workbook($filename)`
175	`{`	175	`{`
176	`// It needs to call its parent's constructor explicitly`	176	`// It needs to call its parent's constructor explicitly`
177	`$this->Spreadsheet_Excel_Writer_BIFFwriter();`	177	`$this->Spreadsheet_Excel_Writer_BIFFwriter();`
178		178
179	`$this->_filename = $filename;`	179	`$this->_filename = $filename;`
180	`$this->_parser = new Spreadsheet_Excel_Writer_Parser($this->_byte_order, $this->_BIFF_version);`	180	`$this->_parser = new Spreadsheet_Excel_Writer_Parser($this->_byte_order, $this->_BIFF_version);`
181	`$this->_1904 = 0;`	181	`$this->_1904 = 0;`
182	`$this->_activesheet = 0;`	182	`$this->_activesheet = 0;`
183	`$this->_firstsheet = 0;`	183	`$this->_firstsheet = 0;`
184	`$this->_selected = 0;`	184	`$this->_selected = 0;`
185	`$this->_xf_index = 16; // 15 style XF's and 1 cell XF.`	185	`$this->_xf_index = 16; // 15 style XF's and 1 cell XF.`
186	`$this->_fileclosed = 0;`	186	`$this->_fileclosed = 0;`
187	`$this->_biffsize = 0;`	187	`$this->_biffsize = 0;`
188	`$this->_sheetname = 'Sheet';`	188	`$this->_sheetname = 'Sheet';`
189	`$this->_tmp_format = new Spreadsheet_Excel_Writer_Format($this->_BIFF_version);`	189	`$this->_tmp_format = new Spreadsheet_Excel_Writer_Format($this->_BIFF_version);`
190	`$this->_worksheets = array();`	190	`$this->_worksheets = array();`
191	`$this->_sheetnames = array();`	191	`$this->_sheetnames = array();`
192	`$this->_formats = array();`	192	`$this->_formats = array();`
193	`$this->_palette = array();`	193	`$this->_palette = array();`
194	`$this->_codepage = 0x04E4; // FIXME: should change for BIFF8`	194	`$this->_codepage = 0x04E4; // FIXME: should change for BIFF8`
195	`$this->_country_code = -1;`	195	`$this->_country_code = -1;`
196	`$this->_string_sizeinfo = 3;`	196	`$this->_string_sizeinfo = 3;`
197		197
198	`// Add the default format for hyperlinks`	198	`// Add the default format for hyperlinks`
199	`$this->_url_format =& $this->addFormat(array('color' => 'blue', 'underline' => 1));`	199	`$this->_url_format =& $this->addFormat(array('color' => 'blue', 'underline' => 1));`
200	`$this->_str_total = 0;`	200	`$this->_str_total = 0;`
201	`$this->_str_unique = 0;`	201	`$this->_str_unique = 0;`
202	`$this->_str_table = array();`	202	`$this->_str_table = array();`
203	`$this->_setPaletteXl97();`	203	`$this->_setPaletteXl97();`
204	`}`	204	`}`
205		205
206	`/**`	206	`/**`
207	`* Calls finalization methods.`	207	`* Calls finalization methods.`
208	`* This method should always be the last one to be called on every workbook`	208	`* This method should always be the last one to be called on every workbook`
209	`*`	209	`*`
210	`* @access public`	210	`* @access public`
211	`* @return mixed true on success. PEAR_Error on failure`	211	`* @return mixed true on success. PEAR_Error on failure`
212	`*/`	212	`*/`
213	`function close()`	213	`function close()`
214	`{`	214	`{`
215	`if ($this->_fileclosed) { // Prevent close() from being called twice.`	215	`if ($this->_fileclosed) { // Prevent close() from being called twice.`
216	`return true;`	216	`return true;`
217	`}`	217	`}`
218	`$res = $this->_storeWorkbook();`	218	`$res = $this->_storeWorkbook();`
219	`if ($this->isError($res)) {`	219	`if ($this->isError($res)) {`
220	`return $this->raiseError($res->getMessage());`	220	`return $this->raiseError($res->getMessage());`
221	`}`	221	`}`
222	`$this->_fileclosed = 1;`	222	`$this->_fileclosed = 1;`
223	`return true;`	223	`return true;`
224	`}`	224	`}`
225		225
226	`/**`	226	`/**`
227	`* An accessor for the _worksheets[] array`	227	`* An accessor for the _worksheets[] array`
228	`* Returns an array of the worksheet objects in a workbook`	228	`* Returns an array of the worksheet objects in a workbook`
229	`* It actually calls to worksheets()`	229	`* It actually calls to worksheets()`
230	`*`	230	`*`
231	`* @access public`	231	`* @access public`
232	`* @see worksheets()`	232	`* @see worksheets()`
233	`* @return array`	233	`* @return array`
234	`*/`	234	`*/`
235	`function sheets()`	235	`function sheets()`
236	`{`	236	`{`
237	`return $this->worksheets();`	237	`return $this->worksheets();`
238	`}`	238	`}`
239		239
240	`/**`	240	`/**`
241	`* An accessor for the _worksheets[] array.`	241	`* An accessor for the _worksheets[] array.`
242	`* Returns an array of the worksheet objects in a workbook`	242	`* Returns an array of the worksheet objects in a workbook`
243	`*`	243	`*`
244	`* @access public`	244	`* @access public`
245	`* @return array`	245	`* @return array`
246	`*/`	246	`*/`
247	`function worksheets()`	247	`function worksheets()`
248	`{`	248	`{`
249	`return $this->_worksheets;`	249	`return $this->_worksheets;`
250	`}`	250	`}`
251		251
252	`/**`	252	`/**`
253	`* Sets the BIFF version.`	253	`* Sets the BIFF version.`
254	`* This method exists just to access experimental functionality`	254	`* This method exists just to access experimental functionality`
255	`* from BIFF8. It will be deprecated !`	255	`* from BIFF8. It will be deprecated !`
256	`* Only possible value is 8 (Excel 97/2000).`	256	`* Only possible value is 8 (Excel 97/2000).`
257	`* For any other value it fails silently.`	257	`* For any other value it fails silently.`
258	`*`	258	`*`
259	`* @access public`	259	`* @access public`
260	`* @param integer $version The BIFF version`	260	`* @param integer $version The BIFF version`
261	`*/`	261	`*/`
262	`function setVersion($version)`	262	`function setVersion($version)`
263	`{`	263	`{`
264	`if ($version == 8) { // only accept version 8`	264	`if ($version == 8) { // only accept version 8`
265	`$version = 0x0600;`	265	`$version = 0x0600;`
266	`$this->_BIFF_version = $version;`	266	`$this->_BIFF_version = $version;`
267	`// change BIFFwriter limit for CONTINUE records`	267	`// change BIFFwriter limit for CONTINUE records`
268	`$this->_limit = 8228;`	268	`$this->_limit = 8228;`
269	`$this->_tmp_format->_BIFF_version = $version;`	269	`$this->_tmp_format->_BIFF_version = $version;`
270	`$this->_url_format->_BIFF_version = $version;`	270	`$this->_url_format->_BIFF_version = $version;`
271	`$this->_parser->_BIFF_version = $version;`	271	`$this->_parser->_BIFF_version = $version;`
272	`$this->_codepage = 0x04B0;`	272	`$this->_codepage = 0x04B0;`
273		273
274	`$total_worksheets = count($this->_worksheets);`	274	`$total_worksheets = count($this->_worksheets);`
275	`// change version for all worksheets too`	275	`// change version for all worksheets too`
276	`for ($i = 0; $i < $total_worksheets; $i++) {`	276	`for ($i = 0; $i < $total_worksheets; $i++) {`
277	`$this->_worksheets[$i]->_BIFF_version = $version;`	277	`$this->_worksheets[$i]->_BIFF_version = $version;`
278	`}`	278	`}`
279		279
280	`$total_formats = count($this->_formats);`	280	`$total_formats = count($this->_formats);`
281	`// change version for all formats too`	281	`// change version for all formats too`
282	`for ($i = 0; $i < $total_formats; $i++) {`	282	`for ($i = 0; $i < $total_formats; $i++) {`
283	`$this->_formats[$i]->_BIFF_version = $version;`	283	`$this->_formats[$i]->_BIFF_version = $version;`
284	`}`	284	`}`
285	`}`	285	`}`
286	`}`	286	`}`
287		287
288	`/**`	288	`/**`
289	`* Set the country identifier for the workbook`	289	`* Set the country identifier for the workbook`
290	`*`	290	`*`
291	`* @access public`	291	`* @access public`
292	`* @param integer $code Is the international calling country code for the`	292	`* @param integer $code Is the international calling country code for the`
293	`* chosen country.`	293	`* chosen country.`
294	`*/`	294	`*/`
295	`function setCountry($code)`	295	`function setCountry($code)`
296	`{`	296	`{`
297	`$this->_country_code = $code;`	297	`$this->_country_code = $code;`
298	`}`	298	`}`
299		299
300	`/**`	300	`/**`
301	`* Add a new worksheet to the Excel workbook.`	301	`* Add a new worksheet to the Excel workbook.`
302	`* If no name is given the name of the worksheet will be Sheeti$i, with`	302	`* If no name is given the name of the worksheet will be Sheeti$i, with`
303	`* $i in [1..].`	303	`* $i in [1..].`
304	`*`	304	`*`
305	`* @access public`	305	`* @access public`
306	`* @param string $name the optional name of the worksheet`	306	`* @param string $name the optional name of the worksheet`
307	`* @return mixed reference to a worksheet object on success, PEAR_Error`	307	`* @return mixed reference to a worksheet object on success, PEAR_Error`
308	`* on failure`	308	`* on failure`
309	`*/`	309	`*/`
310	`function &addWorksheet($name = '')`	310	`function &addWorksheet($name = '')`
311	`{`	311	`{`
312	`$index = count($this->_worksheets);`	312	`$index = count($this->_worksheets);`
313	`$sheetname = $this->_sheetname;`	313	`$sheetname = $this->_sheetname;`
314		314
315	`if ($name == '') {`	315	`if ($name == '') {`
316	`$name = $sheetname.($index+1);`	316	`$name = $sheetname.($index+1);`
317	`}`	317	`}`
318		318
319	`// Check that sheetname is <= 31 chars (Excel limit before BIFF8).`	319	`// Check that sheetname is <= 31 chars (Excel limit before BIFF8).`
320	`if ($this->_BIFF_version != 0x0600)`	320	`if ($this->_BIFF_version != 0x0600)`
321	`{`	321	`{`
322	`if (strlen($name) > 31) {`	322	`if (strlen($name) > 31) {`
323	`return $this->raiseError("Sheetname $name must be <= 31 chars");`	323	`return $this->raiseError("Sheetname $name must be <= 31 chars");`
324	`}`	324	`}`
325	`} else {`	325	`} else {`
326	`if(function_exists('iconv')) {`	326	`if(function_exists('iconv')) {`
327	`$name = iconv('UTF-8','UTF-16LE',$name);`	327	`$name = iconv('UTF-8','UTF-16LE',$name);`
328	`}`	328	`}`
329	`}`	329	`}`
330		330
331	`// Check that the worksheet name doesn't already exist: a fatal Excel error.`	331	`// Check that the worksheet name doesn't already exist: a fatal Excel error.`
332	`$total_worksheets = count($this->_worksheets);`	332	`$total_worksheets = count($this->_worksheets);`
333	`for ($i = 0; $i < $total_worksheets; $i++) {`	333	`for ($i = 0; $i < $total_worksheets; $i++) {`
334	`if ($this->_worksheets[$i]->getName() == $name) {`	334	`if ($this->_worksheets[$i]->getName() == $name) {`
335	`return $this->raiseError("Worksheet '$name' already exists");`	335	`return $this->raiseError("Worksheet '$name' already exists");`
336	`}`	336	`}`
337	`}`	337	`}`
338		338
339	`$worksheet = new Spreadsheet_Excel_Writer_Worksheet($this->_BIFF_version,`	339	`$worksheet = new Spreadsheet_Excel_Writer_Worksheet($this->_BIFF_version,`
340	`$name, $index,`	340	`$name, $index,`
341	`$this->_activesheet, $this->_firstsheet,`	341	`$this->_activesheet, $this->_firstsheet,`
342	`$this->_str_total, $this->_str_unique,`	342	`$this->_str_total, $this->_str_unique,`
343	`$this->_str_table, $this->_url_format,`	343	`$this->_str_table, $this->_url_format,`
344	`$this->_parser, $this->_tmp_dir);`	344	`$this->_parser, $this->_tmp_dir);`
345		345
346	`$this->_worksheets[$index] = &$worksheet; // Store ref for iterator`	346	`$this->_worksheets[$index] = &$worksheet; // Store ref for iterator`
347	`$this->_sheetnames[$index] = $name; // Store EXTERNSHEET names`	347	`$this->_sheetnames[$index] = $name; // Store EXTERNSHEET names`
348	`$this->_parser->setExtSheet($name, $index); // Register worksheet name with parser`	348	`$this->_parser->setExtSheet($name, $index); // Register worksheet name with parser`
349	`return $worksheet;`	349	`return $worksheet;`
350	`}`	350	`}`
351		351
352	`/**`	352	`/**`
353	`* Add a new format to the Excel workbook.`	353	`* Add a new format to the Excel workbook.`
354	`* Also, pass any properties to the Format constructor.`	354	`* Also, pass any properties to the Format constructor.`
355	`*`	355	`*`
356	`* @access public`	356	`* @access public`
357	`* @param array $properties array with properties for initializing the format.`	357	`* @param array $properties array with properties for initializing the format.`
358	`* @return &Spreadsheet_Excel_Writer_Format reference to an Excel Format`	358	`* @return &Spreadsheet_Excel_Writer_Format reference to an Excel Format`
359	`*/`	359	`*/`
360	`function &addFormat($properties = array())`	360	`function &addFormat($properties = array())`
361	`{`	361	`{`
362	`$format = new Spreadsheet_Excel_Writer_Format($this->_BIFF_version, $this->_xf_index, $properties);`	362	`$format = new Spreadsheet_Excel_Writer_Format($this->_BIFF_version, $this->_xf_index, $properties);`
363	`$this->_xf_index += 1;`	363	`$this->_xf_index += 1;`
364	`$this->_formats[] = &$format;`	364	`$this->_formats[] = &$format;`
365	`return $format;`	365	`return $format;`
366	`}`	366	`}`
367		367
368	`/**`	368	`/**`
369	`* Create new validator.`	369	`* Create new validator.`
370	`*`	370	`*`
371	`* @access public`	371	`* @access public`
372	`* @return &Spreadsheet_Excel_Writer_Validator reference to a Validator`	372	`* @return &Spreadsheet_Excel_Writer_Validator reference to a Validator`
373	`*/`	373	`*/`
374	`function &addValidator()`	374	`function &addValidator()`
375	`{`	375	`{`
376	`include_once 'Spreadsheet/Excel/Writer/Validator.php';`	376	`include_once 'Spreadsheet/Excel/Writer/Validator.php';`
377	`/* FIXME: check for successful inclusion*/`	377	`/* FIXME: check for successful inclusion*/`
378	`$valid = new Spreadsheet_Excel_Writer_Validator($this->_parser);`	378	`$valid = new Spreadsheet_Excel_Writer_Validator($this->_parser);`
379	`return $valid;`	379	`return $valid;`
380	`}`	380	`}`
381		381
382	`/**`	382	`/**`
383	`* Change the RGB components of the elements in the colour palette.`	383	`* Change the RGB components of the elements in the colour palette.`
384	`*`	384	`*`
385	`* @access public`	385	`* @access public`
386	`* @param integer $index colour index`	386	`* @param integer $index colour index`
387	`* @param integer $red red RGB value [0-255]`	387	`* @param integer $red red RGB value [0-255]`
388	`* @param integer $green green RGB value [0-255]`	388	`* @param integer $green green RGB value [0-255]`
389	`* @param integer $blue blue RGB value [0-255]`	389	`* @param integer $blue blue RGB value [0-255]`
390	`* @return integer The palette index for the custom color`	390	`* @return integer The palette index for the custom color`
391	`*/`	391	`*/`
392	`function setCustomColor($index, $red, $green, $blue)`	392	`function setCustomColor($index, $red, $green, $blue)`
393	`{`	393	`{`
394	`// Match a HTML #xxyyzz style parameter`	394	`// Match a HTML #xxyyzz style parameter`
395	`/*if (defined $_[1] and $_[1] =~ /^#(\w\w)(\w\w)(\w\w)/ ) {`	395	`/*if (defined $_[1] and $_[1] =~ /^#(\w\w)(\w\w)(\w\w)/ ) {`
396	`@_ = ($_[0], hex $1, hex $2, hex $3);`	396	`@_ = ($_[0], hex $1, hex $2, hex $3);`
397	`}*/`	397	`}*/`
398		398
399	`// Check that the colour index is the right range`	399	`// Check that the colour index is the right range`
400	`if ($index < 8 or $index > 64) {`	400	`if ($index < 8 or $index > 64) {`
401	`// TODO: assign real error codes`	401	`// TODO: assign real error codes`
402	`return $this->raiseError("Color index $index outside range: 8 <= index <= 64");`	402	`return $this->raiseError("Color index $index outside range: 8 <= index <= 64");`
403	`}`	403	`}`
404		404
405	`// Check that the colour components are in the right range`	405	`// Check that the colour components are in the right range`
406	`if (($red < 0 or $red > 255) \|\|`	406	`if (($red < 0 or $red > 255) \|\|`
407	`($green < 0 or $green > 255) \|\|`	407	`($green < 0 or $green > 255) \|\|`
408	`($blue < 0 or $blue > 255))`	408	`($blue < 0 or $blue > 255))`
409	`{`	409	`{`
410	`return $this->raiseError("Color component outside range: 0 <= color <= 255");`	410	`return $this->raiseError("Color component outside range: 0 <= color <= 255");`
411	`}`	411	`}`
412		412
413	`$index -= 8; // Adjust colour index (wingless dragonfly)`	413	`$index -= 8; // Adjust colour index (wingless dragonfly)`
414		414
415	`// Set the RGB value`	415	`// Set the RGB value`
416	`$this->_palette[$index] = array($red, $green, $blue, 0);`	416	`$this->_palette[$index] = array($red, $green, $blue, 0);`
417	`return($index + 8);`	417	`return($index + 8);`
418	`}`	418	`}`
419		419
420	`/**`	420	`/**`
421	`* Sets the colour palette to the Excel 97+ default.`	421	`* Sets the colour palette to the Excel 97+ default.`
422	`*`	422	`*`
423	`* @access private`	423	`* @access private`
424	`*/`	424	`*/`
425	`function _setPaletteXl97()`	425	`function _setPaletteXl97()`
426	`{`	426	`{`
427	`$this->_palette = array(`	427	`$this->_palette = array(`
428	`array(0x00, 0x00, 0x00, 0x00), // 8`	428	`array(0x00, 0x00, 0x00, 0x00), // 8`
429	`array(0xff, 0xff, 0xff, 0x00), // 9`	429	`array(0xff, 0xff, 0xff, 0x00), // 9`
430	`array(0xff, 0x00, 0x00, 0x00), // 10`	430	`array(0xff, 0x00, 0x00, 0x00), // 10`
431	`array(0x00, 0xff, 0x00, 0x00), // 11`	431	`array(0x00, 0xff, 0x00, 0x00), // 11`
432	`array(0x00, 0x00, 0xff, 0x00), // 12`	432	`array(0x00, 0x00, 0xff, 0x00), // 12`
433	`array(0xff, 0xff, 0x00, 0x00), // 13`	433	`array(0xff, 0xff, 0x00, 0x00), // 13`
434	`array(0xff, 0x00, 0xff, 0x00), // 14`	434	`array(0xff, 0x00, 0xff, 0x00), // 14`
435	`array(0x00, 0xff, 0xff, 0x00), // 15`	435	`array(0x00, 0xff, 0xff, 0x00), // 15`
436	`array(0x80, 0x00, 0x00, 0x00), // 16`	436	`array(0x80, 0x00, 0x00, 0x00), // 16`
437	`array(0x00, 0x80, 0x00, 0x00), // 17`	437	`array(0x00, 0x80, 0x00, 0x00), // 17`
438	`array(0x00, 0x00, 0x80, 0x00), // 18`	438	`array(0x00, 0x00, 0x80, 0x00), // 18`
439	`array(0x80, 0x80, 0x00, 0x00), // 19`	439	`array(0x80, 0x80, 0x00, 0x00), // 19`
440	`array(0x80, 0x00, 0x80, 0x00), // 20`	440	`array(0x80, 0x00, 0x80, 0x00), // 20`
441	`array(0x00, 0x80, 0x80, 0x00), // 21`	441	`array(0x00, 0x80, 0x80, 0x00), // 21`
442	`array(0xc0, 0xc0, 0xc0, 0x00), // 22`	442	`array(0xc0, 0xc0, 0xc0, 0x00), // 22`
443	`array(0x80, 0x80, 0x80, 0x00), // 23`	443	`array(0x80, 0x80, 0x80, 0x00), // 23`
444	`array(0x99, 0x99, 0xff, 0x00), // 24`	444	`array(0x99, 0x99, 0xff, 0x00), // 24`
445	`array(0x99, 0x33, 0x66, 0x00), // 25`	445	`array(0x99, 0x33, 0x66, 0x00), // 25`
446	`array(0xff, 0xff, 0xcc, 0x00), // 26`	446	`array(0xff, 0xff, 0xcc, 0x00), // 26`
447	`array(0xcc, 0xff, 0xff, 0x00), // 27`	447	`array(0xcc, 0xff, 0xff, 0x00), // 27`
448	`array(0x66, 0x00, 0x66, 0x00), // 28`	448	`array(0x66, 0x00, 0x66, 0x00), // 28`
449	`array(0xff, 0x80, 0x80, 0x00), // 29`	449	`array(0xff, 0x80, 0x80, 0x00), // 29`
450	`array(0x00, 0x66, 0xcc, 0x00), // 30`	450	`array(0x00, 0x66, 0xcc, 0x00), // 30`
451	`array(0xcc, 0xcc, 0xff, 0x00), // 31`	451	`array(0xcc, 0xcc, 0xff, 0x00), // 31`
452	`array(0x00, 0x00, 0x80, 0x00), // 32`	452	`array(0x00, 0x00, 0x80, 0x00), // 32`
453	`array(0xff, 0x00, 0xff, 0x00), // 33`	453	`array(0xff, 0x00, 0xff, 0x00), // 33`
454	`array(0xff, 0xff, 0x00, 0x00), // 34`	454	`array(0xff, 0xff, 0x00, 0x00), // 34`
455	`array(0x00, 0xff, 0xff, 0x00), // 35`	455	`array(0x00, 0xff, 0xff, 0x00), // 35`
456	`array(0x80, 0x00, 0x80, 0x00), // 36`	456	`array(0x80, 0x00, 0x80, 0x00), // 36`
457	`array(0x80, 0x00, 0x00, 0x00), // 37`	457	`array(0x80, 0x00, 0x00, 0x00), // 37`
458	`array(0x00, 0x80, 0x80, 0x00), // 38`	458	`array(0x00, 0x80, 0x80, 0x00), // 38`
459	`array(0x00, 0x00, 0xff, 0x00), // 39`	459	`array(0x00, 0x00, 0xff, 0x00), // 39`
460	`array(0x00, 0xcc, 0xff, 0x00), // 40`	460	`array(0x00, 0xcc, 0xff, 0x00), // 40`
461	`array(0xcc, 0xff, 0xff, 0x00), // 41`	461	`array(0xcc, 0xff, 0xff, 0x00), // 41`
462	`array(0xcc, 0xff, 0xcc, 0x00), // 42`	462	`array(0xcc, 0xff, 0xcc, 0x00), // 42`
463	`array(0xff, 0xff, 0x99, 0x00), // 43`	463	`array(0xff, 0xff, 0x99, 0x00), // 43`
464	`array(0x99, 0xcc, 0xff, 0x00), // 44`	464	`array(0x99, 0xcc, 0xff, 0x00), // 44`
465	`array(0xff, 0x99, 0xcc, 0x00), // 45`	465	`array(0xff, 0x99, 0xcc, 0x00), // 45`
466	`array(0xcc, 0x99, 0xff, 0x00), // 46`	466	`array(0xcc, 0x99, 0xff, 0x00), // 46`
467	`array(0xff, 0xcc, 0x99, 0x00), // 47`	467	`array(0xff, 0xcc, 0x99, 0x00), // 47`
468	`array(0x33, 0x66, 0xff, 0x00), // 48`	468	`array(0x33, 0x66, 0xff, 0x00), // 48`
469	`array(0x33, 0xcc, 0xcc, 0x00), // 49`	469	`array(0x33, 0xcc, 0xcc, 0x00), // 49`
470	`array(0x99, 0xcc, 0x00, 0x00), // 50`	470	`array(0x99, 0xcc, 0x00, 0x00), // 50`
471	`array(0xff, 0xcc, 0x00, 0x00), // 51`	471	`array(0xff, 0xcc, 0x00, 0x00), // 51`
472	`array(0xff, 0x99, 0x00, 0x00), // 52`	472	`array(0xff, 0x99, 0x00, 0x00), // 52`
473	`array(0xff, 0x66, 0x00, 0x00), // 53`	473	`array(0xff, 0x66, 0x00, 0x00), // 53`
474	`array(0x66, 0x66, 0x99, 0x00), // 54`	474	`array(0x66, 0x66, 0x99, 0x00), // 54`
475	`array(0x96, 0x96, 0x96, 0x00), // 55`	475	`array(0x96, 0x96, 0x96, 0x00), // 55`
476	`array(0x00, 0x33, 0x66, 0x00), // 56`	476	`array(0x00, 0x33, 0x66, 0x00), // 56`
477	`array(0x33, 0x99, 0x66, 0x00), // 57`	477	`array(0x33, 0x99, 0x66, 0x00), // 57`
478	`array(0x00, 0x33, 0x00, 0x00), // 58`	478	`array(0x00, 0x33, 0x00, 0x00), // 58`
479	`array(0x33, 0x33, 0x00, 0x00), // 59`	479	`array(0x33, 0x33, 0x00, 0x00), // 59`
480	`array(0x99, 0x33, 0x00, 0x00), // 60`	480	`array(0x99, 0x33, 0x00, 0x00), // 60`
481	`array(0x99, 0x33, 0x66, 0x00), // 61`	481	`array(0x99, 0x33, 0x66, 0x00), // 61`
482	`array(0x33, 0x33, 0x99, 0x00), // 62`	482	`array(0x33, 0x33, 0x99, 0x00), // 62`
483	`array(0x33, 0x33, 0x33, 0x00), // 63`	483	`array(0x33, 0x33, 0x33, 0x00), // 63`
484	`);`	484	`);`
485	`}`	485	`}`
486		486
487	`/**`	487	`/**`
488	`* Assemble worksheets into a workbook and send the BIFF data to an OLE`	488	`* Assemble worksheets into a workbook and send the BIFF data to an OLE`
489	`* storage.`	489	`* storage.`
490	`*`	490	`*`
491	`* @access private`	491	`* @access private`
492	`* @return mixed true on success. PEAR_Error on failure`	492	`* @return mixed true on success. PEAR_Error on failure`
493	`*/`	493	`*/`
494	`function _storeWorkbook()`	494	`function _storeWorkbook()`
495	`{`	495	`{`
496	`if (count($this->_worksheets) == 0) {`	496	`if (count($this->_worksheets) == 0) {`
497	`return true;`	497	`return true;`
498	`}`	498	`}`
499		499
500	`// Ensure that at least one worksheet has been selected.`	500	`// Ensure that at least one worksheet has been selected.`

Subversion Repositories eFlore/Applications.cel

(root)/trunk/jrest/lib/Spreadsheet/Excel/Writer/Workbook.php – Rev 1604 → 1605