PHPExcel_Writer_Excel5
[ class tree: PHPExcel_Writer_Excel5 ] [ index: PHPExcel_Writer_Excel5 ] [ all elements ]
Packages:
PHPExcel
com-tecnick-tcpdf
JAMA
Math_Stats
PHPExcel_CachedObjectStorage
PHPExcel_Calculation
PHPExcel_Cell
PHPExcel_Reader
PHPExcel_Reader_Excel5
PHPExcel_RichText
PHPExcel_Settings
PHPExcel_Shared
PHPExcel_Shared_Best_Fit
PHPExcel_Shared_Escher
PHPExcel_Shared_OLE
PHPExcel_Style
PHPExcel_Worksheet
PHPExcel_Worksheet_Drawing
PHPExcel_Writer
PHPExcel_Writer_Excel5
PHPExcel_Writer_Excel2007

Source for file Workbook.php

Documentation is available at Workbook.php

  1. <?php
  2. /**
  3.  * PHPExcel
  4.  *
  5.  * Copyright (c) 2006 - 2010 PHPExcel
  6.  *
  7.  * This library is free software; you can redistribute it and/or
  8.  * modify it under the terms of the GNU Lesser General Public
  9.  * License as published by the Free Software Foundation; either
  10.  * version 2.1 of the License, or (at your option) any later version.
  11.  *
  12.  * This library is distributed in the hope that it will be useful,
  13.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15.  * Lesser General Public License for more details.
  16.  *
  17.  * You should have received a copy of the GNU Lesser General Public
  18.  * License along with this library; if not, write to the Free Software
  19.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  20.  *
  21.  * @category   PHPExcel
  22.  * @package    PHPExcel_Writer_Excel5
  23.  * @copyright  Copyright (c) 2006 - 2010 PHPExcel (http://www.codeplex.com/PHPExcel)
  24.  * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt    LGPL
  25.  * @version    1.7.3c, 2010-06-01
  26.  */
  27.  
  28. // Original file header of PEAR::Spreadsheet_Excel_Writer_Workbook (used as the base for this class):
  29. // -----------------------------------------------------------------------------------------
  30. // /*
  31. // *  Module written/ported by Xavier Noguer <xnoguer@rezebra.com>
  32. // *
  33. // *  The majority of this is _NOT_ my code.  I simply ported it from the
  34. // *  PERL Spreadsheet::WriteExcel module.
  35. // *
  36. // *  The author of the Spreadsheet::WriteExcel module is John McNamara
  37. // *  <jmcnamara@cpan.org>
  38. // *
  39. // *  I _DO_ maintain this code, and John McNamara has nothing to do with the
  40. // *  porting of this code to PHP.  Any questions directly related to this
  41. // *  class library should be directed to me.
  42. // *
  43. // *  License Information:
  44. // *
  45. // *    Spreadsheet_Excel_Writer:  A library for generating Excel Spreadsheets
  46. // *    Copyright (c) 2002-2003 Xavier Noguer xnoguer@rezebra.com
  47. // *
  48. // *    This library is free software; you can redistribute it and/or
  49. // *    modify it under the terms of the GNU Lesser General Public
  50. // *    License as published by the Free Software Foundation; either
  51. // *    version 2.1 of the License, or (at your option) any later version.
  52. // *
  53. // *    This library is distributed in the hope that it will be useful,
  54. // *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  55. // *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  56. // *    Lesser General Public License for more details.
  57. // *
  58. // *    You should have received a copy of the GNU Lesser General Public
  59. // *    License along with this library; if not, write to the Free Software
  60. // *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  61. // */
  62.  
  63.  
  64. /**
  65.  * PHPExcel_Writer_Excel5_Workbook
  66.  *
  67.  * @category   PHPExcel
  68.  * @package    PHPExcel_Writer_Excel5
  69.  * @copyright  Copyright (c) 2006 - 2010 PHPExcel (http://www.codeplex.com/PHPExcel)
  70.  */
  71. class PHPExcel_Writer_Excel5_Workbook extends PHPExcel_Writer_Excel5_BIFFwriter
  72. {
  73.     /**
  74.      * Formula parser
  75.      *
  76.      * @var PHPExcel_Writer_Excel5_Parser 
  77.      */
  78.     private $_parser;
  79.  
  80.     /**
  81.      * The BIFF file size for the workbook.
  82.      * @var integer 
  83.      * @see _calcSheetOffsets()
  84.      */
  85.     public $_biffsize;
  86.  
  87.     /**
  88.      * XF Writers
  89.      * @var PHPExcel_Writer_Excel5_Xf[] 
  90.      */
  91.     private $_xfWriters = array();
  92.  
  93.     /**
  94.      * Array containing the colour palette
  95.      * @var array 
  96.      */
  97.     public $_palette;
  98.  
  99.     /**
  100.      * The codepage indicates the text encoding used for strings
  101.      * @var integer 
  102.      */
  103.     public $_codepage;
  104.  
  105.     /**
  106.      * The country code used for localization
  107.      * @var integer 
  108.      */
  109.     public $_country_code;
  110.  
  111.     /**
  112.      * Workbook
  113.      * @var PHPExcel 
  114.      */
  115.     private $_phpExcel;
  116.  
  117.     /**
  118.      * Fonts writers
  119.      *
  120.      * @var PHPExcel_Writer_Excel5_Font[] 
  121.      */
  122.     private $_fontWriters = array();
  123.  
  124.     /**
  125.      * Added fonts. Maps from font's hash => index in workbook
  126.      *
  127.      * @var array 
  128.      */
  129.     private $_addedFonts = array();
  130.  
  131.     /**
  132.      * Shared number formats
  133.      *
  134.      * @var array 
  135.      */
  136.     private $_numberFormats = array();
  137.  
  138.     /**
  139.      * Added number formats. Maps from numberFormat's hash => index in workbook
  140.      *
  141.      * @var array 
  142.      */
  143.     private $_addedNumberFormats = array();
  144.  
  145.     /**
  146.      * Sizes of the binary worksheet streams
  147.      *
  148.      * @var array 
  149.      */
  150.     private $_worksheetSizes = array();
  151.  
  152.     /**
  153.      * Offsets of the binary worksheet streams relative to the start of the global workbook stream
  154.      *
  155.      * @var array 
  156.      */
  157.     private $_worksheetOffsets = array();
  158.  
  159.     /**
  160.      * Total number of shared strings in workbook
  161.      *
  162.      * @var int 
  163.      */
  164.     private $_str_total;
  165.  
  166.     /**
  167.      * Number of unique shared strings in workbook
  168.      *
  169.      * @var int 
  170.      */
  171.     private $_str_unique;
  172.  
  173.     /**
  174.      * Array of unique shared strings in workbook
  175.      *
  176.      * @var array 
  177.      */
  178.     private $_str_table;
  179.  
  180.     /**
  181.      * Color cache
  182.      */
  183.     private $_colors;
  184.  
  185.  
  186.     /**
  187.      * Class constructor
  188.      *
  189.      * @param PHPExcel $phpExcel The Workbook
  190.      * @param int $BIFF_verions BIFF version
  191.      * @param int  $str_total        Total number of strings
  192.      * @param int  $str_unique        Total number of unique strings
  193.      * @param array  $str_table 
  194.      * @param mixed   $parser      The formula parser created for the Workbook
  195.      */
  196.     public function __construct(PHPExcel $phpExcel = null, $BIFF_version = 0x0600,
  197.                                                 &$str_total,
  198.                                                 &$str_unique, &$str_table, &$colors, $parser
  199.                                 )
  200.     {
  201.         // It needs to call its parent's constructor explicitly
  202.         parent::__construct();
  203.  
  204.         $this->_parser           = $parser;
  205.         $this->_biffsize         = 0;
  206.         $this->_palette          = array();
  207.         $this->_codepage         = 0x04E4; // FIXME: should change for BIFF8
  208.         $this->_country_code     = -1;
  209.  
  210.         $this->_str_total       = &$str_total;
  211.         $this->_str_unique      = &$str_unique;
  212.         $this->_str_table       = &$str_table;
  213.         $this->_colors          = &$colors;
  214.         $this->_setPaletteXl97();
  215.  
  216.         $this->_phpExcel = $phpExcel;
  217.  
  218.         if ($BIFF_version == 0x0600) {
  219.             $this->_BIFF_version = 0x0600;
  220.             // change BIFFwriter limit for CONTINUE records
  221.             $this->_limit = 8224;
  222.             $this->_codepage = 0x04B0;
  223.         }
  224.  
  225.         // Add empty sheets and Build color cache
  226.         $countSheets = $phpExcel->getSheetCount();
  227.         for ($i = 0; $i < $countSheets; ++$i) {
  228.             $phpSheet = $phpExcel->getSheet($i);
  229.  
  230.             $this->_parser->setExtSheet($phpSheet->getTitle(), $i);  // Register worksheet name with parser
  231.  
  232.             // for BIFF8
  233.             if ($this->_BIFF_version == 0x0600) {
  234.                 $supbook_index = 0x00;
  235.                 $ref = pack('vvv', $supbook_index, $i, $i);
  236.                 $this->_parser->_references[] = $ref;  // Register reference with parser
  237.             }
  238.             // Sheet tab colors?
  239.             if ($phpSheet->isTabColorSet()) {
  240.                 $this->_addColor($phpSheet->getTabColor()->getRGB());
  241.             }
  242.         }
  243.  
  244.     }
  245.  
  246.     /**
  247.      * Add a new XF writer
  248.      *
  249.      * @param PHPExcel_Style 
  250.      * @param boolean Is it a style XF?
  251.      * @return int Index to XF record
  252.      */
  253.     public function addXfWriter($style, $isStyleXf = false)
  254.     {
  255.         $xfWriter = new PHPExcel_Writer_Excel5_Xf($style);
  256.         $xfWriter->setBIFFVersion($this->_BIFF_version);
  257.         $xfWriter->setIsStyleXf($isStyleXf);
  258.  
  259.         // Add the font if not already added
  260.         $fontHashCode = $style->getFont()->getHashCode();
  261.  
  262.         if (isset($this->_addedFonts[$fontHashCode])) {
  263.             $fontIndex = $this->_addedFonts[$fontHashCode];
  264.         } else {
  265.             $countFonts = count($this->_fontWriters);
  266.             $fontIndex = ($countFonts < 4) ? $countFonts : $countFonts + 1;
  267.  
  268.             $fontWriter = new PHPExcel_Writer_Excel5_Font($style->getFont());
  269.             $fontWriter->setBIFFVersion($this->_BIFF_version);
  270.             $fontWriter->setColorIndex($this->_addColor($style->getFont()->getColor()->getRGB()));
  271.             $this->_fontWriters[] = $fontWriter;
  272.  
  273.             $this->_addedFonts[$fontHashCode] = $fontIndex;
  274.         }
  275.  
  276.         // Assign the font index to the xf record
  277.         $xfWriter->setFontIndex($fontIndex);
  278.  
  279.         // Background colors, best to treat these after the font so black will come after white in custom palette
  280.         $xfWriter->setFgColor($this->_addColor($style->getFill()->getStartColor()->getRGB()));
  281.         $xfWriter->setBgColor($this->_addColor($style->getFill()->getEndColor()->getRGB()));
  282.         $xfWriter->setBottomColor($this->_addColor($style->getBorders()->getBottom()->getColor()->getRGB()));
  283.         $xfWriter->setTopColor($this->_addColor($style->getBorders()->getTop()->getColor()->getRGB()));
  284.         $xfWriter->setRightColor($this->_addColor($style->getBorders()->getRight()->getColor()->getRGB()));
  285.         $xfWriter->setLeftColor($this->_addColor($style->getBorders()->getLeft()->getColor()->getRGB()));
  286.         $xfWriter->setDiagColor($this->_addColor($style->getBorders()->getDiagonal()->getColor()->getRGB()));
  287.  
  288.         // Add the number format if it is not a built-in one and not already added
  289.         if ($style->getNumberFormat()->getBuiltInFormatCode() === false) {
  290.             $numberFormatHashCode = $style->getNumberFormat()->getHashCode();
  291.  
  292.             if (isset($this->_addedNumberFormats[$numberFormatHashCode])) {
  293.                 $numberFormatIndex = $this->_addedNumberFormats[$numberFormatHashCode];
  294.             } else {
  295.                 $numberFormatIndex = 164 + count($this->_numberFormats);
  296.                 $this->_numberFormats[$numberFormatIndex] = $style->getNumberFormat();
  297.                 $this->_addedNumberFormats[$numberFormatHashCode] = $numberFormatIndex;
  298.             }
  299.         }
  300.         else {
  301.             $numberFormatIndex = (int) $style->getNumberFormat()->getBuiltInFormatCode();
  302.         }
  303.  
  304.         // Assign the number format index to xf record
  305.         $xfWriter->setNumberFormatIndex($numberFormatIndex);
  306.  
  307.         $this->_xfWriters[] = $xfWriter;
  308.  
  309.         $xfIndex = count($this->_xfWriters) - 1;
  310.         return $xfIndex;
  311.     }
  312.  
  313.     /**
  314.      * Alter color palette adding a custom color
  315.      *
  316.      * @param string $rgb E.g. 'FF00AA'
  317.      * @return int Color index
  318.      */
  319.     private function _addColor($rgb) {
  320.         if (!isset($this->_colors[$rgb])) {
  321.             if (count($this->_colors) < 57) {
  322.                 // then we add a custom color altering the palette
  323.                 $colorIndex = 8 + count($this->_colors);
  324.                 $this->_palette[$colorIndex] =
  325.                     array(
  326.                         hexdec(substr($rgb, 0, 2)),
  327.                         hexdec(substr($rgb, 2, 2)),
  328.                         hexdec(substr($rgb, 4)),
  329.                         0
  330.                     );
  331.                 $this->_colors[$rgb] = $colorIndex;
  332.             } else {
  333.                 // no room for more custom colors, just map to black
  334.                 $colorIndex = 0;
  335.             }
  336.         } else {
  337.             // fetch already added custom color
  338.             $colorIndex = $this->_colors[$rgb];
  339.         }
  340.  
  341.         return $colorIndex;
  342.     }
  343.  
  344.     /**
  345.      * Sets the colour palette to the Excel 97+ default.
  346.      *
  347.      * @access private
  348.      */
  349.     function _setPaletteXl97()
  350.     {
  351.         $this->_palette = array(
  352.             0x08 => array(0x00, 0x00, 0x00, 0x00),
  353.             0x09 => array(0xff, 0xff, 0xff, 0x00),
  354.             0x0A => array(0xff, 0x00, 0x00, 0x00),
  355.             0x0B => array(0x00, 0xff, 0x00, 0x00),
  356.             0x0C => array(0x00, 0x00, 0xff, 0x00),
  357.             0x0D => array(0xff, 0xff, 0x00, 0x00),
  358.             0x0E => array(0xff, 0x00, 0xff, 0x00),
  359.             0x0F => array(0x00, 0xff, 0xff, 0x00),
  360.             0x10 => array(0x80, 0x00, 0x00, 0x00),
  361.             0x11 => array(0x00, 0x80, 0x00, 0x00),
  362.             0x12 => array(0x00, 0x00, 0x80, 0x00),
  363.             0x13 => array(0x80, 0x80, 0x00, 0x00),
  364.             0x14 => array(0x80, 0x00, 0x80, 0x00),
  365.             0x15 => array(0x00, 0x80, 0x80, 0x00),
  366.             0x16 => array(0xc0, 0xc0, 0xc0, 0x00),
  367.             0x17 => array(0x80, 0x80, 0x80, 0x00),
  368.             0x18 => array(0x99, 0x99, 0xff, 0x00),
  369.             0x19 => array(0x99, 0x33, 0x66, 0x00),
  370.             0x1A => array(0xff, 0xff, 0xcc, 0x00),
  371.             0x1B => array(0xcc, 0xff, 0xff, 0x00),
  372.             0x1C => array(0x66, 0x00, 0x66, 0x00),
  373.             0x1D => array(0xff, 0x80, 0x80, 0x00),
  374.             0x1E => array(0x00, 0x66, 0xcc, 0x00),
  375.             0x1F => array(0xcc, 0xcc, 0xff, 0x00),
  376.             0x20 => array(0x00, 0x00, 0x80, 0x00),
  377.             0x21 => array(0xff, 0x00, 0xff, 0x00),
  378.             0x22 => array(0xff, 0xff, 0x00, 0x00),
  379.             0x23 => array(0x00, 0xff, 0xff, 0x00),
  380.             0x24 => array(0x80, 0x00, 0x80, 0x00),
  381.             0x25 => array(0x80, 0x00, 0x00, 0x00),
  382.             0x26 => array(0x00, 0x80, 0x80, 0x00),
  383.             0x27 => array(0x00, 0x00, 0xff, 0x00),
  384.             0x28 => array(0x00, 0xcc, 0xff, 0x00),
  385.             0x29 => array(0xcc, 0xff, 0xff, 0x00),
  386.             0x2A => array(0xcc, 0xff, 0xcc, 0x00),
  387.             0x2B => array(0xff, 0xff, 0x99, 0x00),
  388.             0x2C => array(0x99, 0xcc, 0xff, 0x00),
  389.             0x2D => array(0xff, 0x99, 0xcc, 0x00),
  390.             0x2E => array(0xcc, 0x99, 0xff, 0x00),
  391.             0x2F => array(0xff, 0xcc, 0x99, 0x00),
  392.             0x30 => array(0x33, 0x66, 0xff, 0x00),
  393.             0x31 => array(0x33, 0xcc, 0xcc, 0x00),
  394.             0x32 => array(0x99, 0xcc, 0x00, 0x00),
  395.             0x33 => array(0xff, 0xcc, 0x00, 0x00),
  396.             0x34 => array(0xff, 0x99, 0x00, 0x00),
  397.             0x35 => array(0xff, 0x66, 0x00, 0x00),
  398.             0x36 => array(0x66, 0x66, 0x99, 0x00),
  399.             0x37 => array(0x96, 0x96, 0x96, 0x00),
  400.             0x38 => array(0x00, 0x33, 0x66, 0x00),
  401.             0x39 => array(0x33, 0x99, 0x66, 0x00),
  402.             0x3A => array(0x00, 0x33, 0x00, 0x00),
  403.             0x3B => array(0x33, 0x33, 0x00, 0x00),
  404.             0x3C => array(0x99, 0x33, 0x00, 0x00),
  405.             0x3D => array(0x99, 0x33, 0x66, 0x00),
  406.             0x3E => array(0x33, 0x33, 0x99, 0x00),
  407.             0x3F => array(0x33, 0x33, 0x33, 0x00),
  408.         );
  409.     }
  410.  
  411.     /**
  412.      * Assemble worksheets into a workbook and send the BIFF data to an OLE
  413.      * storage.
  414.      *
  415.      * @param array $worksheetSizes The sizes in bytes of the binary worksheet streams
  416.      * @return string Binary data for workbook stream
  417.      */
  418.     public function writeWorkbook($pWorksheetSizes = null)
  419.     {
  420.         $this->_worksheetSizes = $pWorksheetSizes;
  421.  
  422.         // Calculate the number of selected worksheet tabs and call the finalization
  423.         // methods for each worksheet
  424.         $total_worksheets = $this->_phpExcel->getSheetCount();
  425.  
  426.         // Add part 1 of the Workbook globals, what goes before the SHEET records
  427.         $this->_storeBof(0x0005);
  428.         $this->_writeCodepage();
  429.         if ($this->_BIFF_version == 0x0600) {
  430.             $this->_writeWindow1();
  431.         }
  432.         if ($this->_BIFF_version == 0x0500) {
  433.             $this->_writeExterns();    // For print area and repeat rows
  434.             $this->_writeNames();      // For print area and repeat rows
  435.         }
  436.         if ($this->_BIFF_version == 0x0500) {
  437.             $this->_writeWindow1();
  438.         }
  439.         $this->_writeDatemode();
  440.         $this->_writeAllFonts();
  441.         $this->_writeAllNumFormats();
  442.         $this->_writeAllXfs();
  443.         $this->_writeAllStyles();
  444.         $this->_writePalette();
  445.  
  446.         // Prepare part 3 of the workbook global stream, what goes after the SHEET records
  447.         $part3 = '';
  448.         if ($this->_country_code != -1) {
  449.             $part3 .= $this->_writeCountry();
  450.         }
  451.         $part3 .= $this->_writeRecalcId();
  452.  
  453.         if ($this->_BIFF_version == 0x0600) {
  454.             $part3 .= $this->_writeSupbookInternal();
  455.             /* TODO: store external SUPBOOK records and XCT and CRN records
  456.             in case of external references for BIFF8 */
  457.             $part3 .= $this->_writeExternsheetBiff8();
  458.             $part3 .= $this->_writeAllDefinedNamesBiff8();
  459.             $part3 .= $this->_writeMsoDrawingGroup();
  460.             $part3 .= $this->_writeSharedStringsTable();
  461.         }
  462.  
  463.         $part3 .= $this->writeEof();
  464.  
  465.         // Add part 2 of the Workbook globals, the SHEET records
  466.         $this->_calcSheetOffsets();
  467.         for ($i = 0; $i < $total_worksheets; ++$i) {
  468.             $this->_writeBoundsheet($this->_phpExcel->getSheet($i), $this->_worksheetOffsets[$i]);
  469.         }
  470.  
  471.         // Add part 3 of the Workbook globals
  472.         $this->_data .= $part3;
  473.  
  474.         return $this->_data;
  475.     }
  476.  
  477.     /**
  478.      * Calculate offsets for Worksheet BOF records.
  479.      *
  480.      * @access private
  481.      */
  482.     function _calcSheetOffsets()
  483.     {
  484.         if ($this->_BIFF_version == 0x0600) {
  485.             $boundsheet_length = 10;  // fixed length for a BOUNDSHEET record
  486.         } else {
  487.             $boundsheet_length = 11;
  488.         }
  489.  
  490.         // size of Workbook globals part 1 + 3
  491.         $offset            = $this->_datasize;
  492.  
  493.         // add size of Workbook globals part 2, the length of the SHEET records
  494.         $total_worksheets = count($this->_phpExcel->getAllSheets());
  495.         foreach ($this->_phpExcel->getWorksheetIterator() as $sheet) {
  496.             if ($this->_BIFF_version == 0x0600) {
  497.                 $offset += $boundsheet_length + strlen(PHPExcel_Shared_String::UTF8toBIFF8UnicodeShort($sheet->getTitle()));
  498.             } else {
  499.                 $offset += $boundsheet_length + strlen($sheet->getTitle());
  500.             }
  501.         }
  502.  
  503.         // add the sizes of each of the Sheet substreams, respectively
  504.         for ($i = 0; $i < $total_worksheets; ++$i) {
  505.             $this->_worksheetOffsets[$i] = $offset;
  506.             $offset += $this->_worksheetSizes[$i];
  507.         }
  508.         $this->_biffsize = $offset;
  509.     }
  510.  
  511.     /**
  512.      * Store the Excel FONT records.
  513.      */
  514.     private function _writeAllFonts()
  515.     {
  516.         foreach ($this->_fontWriters as $fontWriter) {
  517.             $this->_append($fontWriter->writeFont());
  518.         }
  519.     }
  520.  
  521.     /**
  522.      * Store user defined numerical formats i.e. FORMAT records
  523.      */
  524.     private function _writeAllNumFormats()
  525.     {
  526.         foreach ($this->_numberFormats as $numberFormatIndex => $numberFormat) {
  527.             $this->_writeNumFormat($numberFormat->getFormatCode(), $numberFormatIndex);
  528.         }
  529.     }
  530.  
  531.     /**
  532.      * Write all XF records.
  533.      */
  534.     private function _writeAllXfs()
  535.     {
  536.         foreach ($this->_xfWriters as $xfWriter) {
  537.             $this->_append($xfWriter->writeXf());
  538.         }
  539.     }
  540.  
  541.     /**
  542.      * Write all STYLE records.
  543.      */
  544.     private function _writeAllStyles()
  545.     {
  546.         $this->_writeStyle();
  547.     }
  548.  
  549.     /**
  550.      * Write the EXTERNCOUNT and EXTERNSHEET records. These are used as indexes for
  551.      * the NAME records.
  552.      */
  553.     private function _writeExterns()
  554.     {
  555.         $countSheets = $this->_phpExcel->getSheetCount();
  556.         // Create EXTERNCOUNT with number of worksheets
  557.         $this->_writeExterncount($countSheets);
  558.  
  559.         // Create EXTERNSHEET for each worksheet
  560.         for ($i = 0; $i < $countSheets; ++$i) {
  561.             $this->_writeExternsheet($phpExcel->getSheet($i)->getTitle());
  562.         }
  563.     }
  564.  
  565.     /**
  566.      * Write the NAME record to define the print area and the repeat rows and cols.
  567.      */
  568.     private function _writeNames()
  569.     {
  570.         // total number of sheets
  571.         $total_worksheets = $this->_phpExcel->getSheetCount();
  572.  
  573.         // Create the print area NAME records
  574.         for ($i = 0; $i < $total_worksheets; ++$i) {
  575.             $sheetSetup = $this->_phpExcel->getSheet($i)->getPageSetup();
  576.             // Write a Name record if the print area has been defined
  577.             if ($sheetSetup->isPrintAreaSet()) {
  578.                 // Print area
  579.                 $printArea = PHPExcel_Cell::splitRange($sheetSetup->getPrintArea());
  580.                 $printArea = $printArea[0];
  581.                 $printArea[0] = PHPExcel_Cell::coordinateFromString($printArea[0]);
  582.                 $printArea[1] = PHPExcel_Cell::coordinateFromString($printArea[1]);
  583.  
  584.                 $print_rowmin = $printArea[0][1] - 1;
  585.                 $print_rowmax = $printArea[1][1] - 1;
  586.                 $print_colmin = PHPExcel_Cell::columnIndexFromString($printArea[0][0]) - 1;
  587.                 $print_colmax = PHPExcel_Cell::columnIndexFromString($printArea[1][0]) - 1;
  588.  
  589.                 $this->_writeNameShort(
  590.                     $i, // sheet index
  591.                     0x06, // NAME type
  592.                     $print_rowmin,
  593.                     $print_rowmax,
  594.                     $print_colmin,
  595.                     $print_colmax
  596.                     );
  597.             }
  598.         }
  599.  
  600.         // Create the print title NAME records
  601.         for ($i = 0; $i < $total_worksheets; ++$i) {
  602.             $sheetSetup = $this->_phpExcel->getSheet($i)->getPageSetup();
  603.  
  604.             // simultaneous repeatColumns repeatRows
  605.             if ($sheetSetup->isColumnsToRepeatAtLeftSet() && $sheetSetup->isRowsToRepeatAtTopSet()) {
  606.                 $repeat = $sheetSetup->getColumnsToRepeatAtLeft();
  607.                 $colmin = PHPExcel_Cell::columnIndexFromString($repeat[0]) - 1;
  608.                 $colmax = PHPExcel_Cell::columnIndexFromString($repeat[1]) - 1;
  609.  
  610.                 $repeat = $sheetSetup->getRowsToRepeatAtTop();
  611.                 $rowmin = $repeat[0] - 1;
  612.                 $rowmax = $repeat[1] - 1;
  613.  
  614.                 $this->_writeNameLong(
  615.                     $i, // sheet index
  616.                     0x07, // NAME type
  617.                     $rowmin,
  618.                     $rowmax,
  619.                     $colmin,
  620.                     $colmax
  621.                     );
  622.  
  623.             // (exclusive) either repeatColumns or repeatRows
  624.             } else if ($sheetSetup->isColumnsToRepeatAtLeftSet() || $sheetSetup->isRowsToRepeatAtTopSet()) {
  625.  
  626.                 // Columns to repeat
  627.                 if ($sheetSetup->isColumnsToRepeatAtLeftSet()) {
  628.                     $repeat = $sheetSetup->getColumnsToRepeatAtLeft();
  629.                     $colmin = PHPExcel_Cell::columnIndexFromString($repeat[0]) - 1;
  630.                     $colmax = PHPExcel_Cell::columnIndexFromString($repeat[1]) - 1;
  631.                 } else {
  632.                     $colmin = 0;
  633.                     $colmax = 255;
  634.                 }
  635.  
  636.                 // Rows to repeat
  637.                 if ($sheetSetup->isRowsToRepeatAtTopSet()) {
  638.                     $repeat = $sheetSetup->getRowsToRepeatAtTop();
  639.                     $rowmin = $repeat[0] - 1;
  640.                     $rowmax = $repeat[1] - 1;
  641.                 } else {
  642.                     $rowmin = 0;
  643.                     $rowmax = 16383;
  644.                 }
  645.  
  646.                 $this->_writeNameShort(
  647.                     $i, // sheet index
  648.                     0x07, // NAME type
  649.                     $rowmin,
  650.                     $rowmax,
  651.                     $colmin,
  652.                     $colmax
  653.                     );
  654.             }
  655.         }
  656.     }
  657.  
  658.  
  659.     /**
  660.      * Writes all the DEFINEDNAME records (BIFF8).
  661.      * So far this is only used for repeating rows/columns (print titles) and print areas
  662.      */
  663.     private function _writeAllDefinedNamesBiff8()
  664.     {
  665.         $chunk = '';
  666.  
  667.         // Named ranges
  668.         if (count($this->_phpExcel->getNamedRanges()) > 0) {
  669.             // Loop named ranges
  670.             $namedRanges = $this->_phpExcel->getNamedRanges();
  671.             foreach ($namedRanges as $namedRange) {
  672.  
  673.                 // Create absolute coordinate
  674.                 $range = PHPExcel_Cell::splitRange($namedRange->getRange());
  675.                 for ($i = 0; $i < count($range); $i++) {
  676.                     $range[$i][0] = '\'' . str_replace("'", "''", $namedRange->getWorksheet()->getTitle()) . '\'!' . PHPExcel_Cell::absoluteCoordinate($range[$i][0]);
  677.                     if (isset($range[$i][1])) {
  678.                         $range[$i][1] = PHPExcel_Cell::absoluteCoordinate($range[$i][1]);
  679.                     }
  680.                 }
  681.                 $range = PHPExcel_Cell::buildRange($range); // e.g. Sheet1!$A$1:$B$2
  682.  
  683.                 // parse formula
  684.                 try {
  685.                     $error = $this->_parser->parse($range);
  686.                     $formulaData = $this->_parser->toReversePolish();
  687.  
  688.                     // make sure tRef3d is of type tRef3dR (0x3A)
  689.                     if (isset($formulaData{0}) and ($formulaData{0} == "\x7A" or $formulaData{0} == "\x5A")) {
  690.                         $formulaData = "\x3A" . substr($formulaData, 1);
  691.                     }
  692.  
  693.                     if ($namedRange->getLocalOnly()) {
  694.                         // local scope
  695.                         $scope = $this->_phpExcel->getIndex($namedRange->getScope()) + 1;
  696.                     } else {
  697.                         // global scope
  698.                         $scope = 0;
  699.                     }
  700.                     $chunk .= $this->writeData($this->_writeDefinedNameBiff8($namedRange->getName(), $formulaData, $scope, false));
  701.  
  702.                 } catch(Exception $e) {
  703.                     // do nothing
  704.                 }
  705.             }
  706.         }
  707.  
  708.         // total number of sheets
  709.         $total_worksheets = $this->_phpExcel->getSheetCount();
  710.  
  711.         // write the print titles (repeating rows, columns), if any
  712.         for ($i = 0; $i < $total_worksheets; ++$i) {
  713.             $sheetSetup = $this->_phpExcel->getSheet($i)->getPageSetup();
  714.             // simultaneous repeatColumns repeatRows
  715.             if ($sheetSetup->isColumnsToRepeatAtLeftSet() && $sheetSetup->isRowsToRepeatAtTopSet()) {
  716.                 $repeat = $sheetSetup->getColumnsToRepeatAtLeft();
  717.                 $colmin = PHPExcel_Cell::columnIndexFromString($repeat[0]) - 1;
  718.                 $colmax = PHPExcel_Cell::columnIndexFromString($repeat[1]) - 1;
  719.  
  720.                 $repeat = $sheetSetup->getRowsToRepeatAtTop();
  721.                 $rowmin = $repeat[0] - 1;
  722.                 $rowmax = $repeat[1] - 1;
  723.  
  724.                 // construct formula data manually
  725.                 $formulaData = pack('Cv', 0x29, 0x17); // tMemFunc
  726.                 $formulaData .= pack('Cvvvvv', 0x3B, $i, 0, 65535, $colmin, $colmax); // tArea3d
  727.                 $formulaData .= pack('Cvvvvv', 0x3B, $i, $rowmin, $rowmax, 0, 255); // tArea3d
  728.                 $formulaData .= pack('C', 0x10); // tList
  729.  
  730.                 // store the DEFINEDNAME record
  731.                 $chunk .= $this->writeData($this->_writeDefinedNameBiff8(pack('C', 0x07), $formulaData, $i + 1, true));
  732.  
  733.             // (exclusive) either repeatColumns or repeatRows
  734.             } else if ($sheetSetup->isColumnsToRepeatAtLeftSet() || $sheetSetup->isRowsToRepeatAtTopSet()) {
  735.  
  736.                 // Columns to repeat
  737.                 if ($sheetSetup->isColumnsToRepeatAtLeftSet()) {
  738.                     $repeat = $sheetSetup->getColumnsToRepeatAtLeft();
  739.                     $colmin = PHPExcel_Cell::columnIndexFromString($repeat[0]) - 1;
  740.                     $colmax = PHPExcel_Cell::columnIndexFromString($repeat[1]) - 1;
  741.                 } else {
  742.                     $colmin = 0;
  743.                     $colmax = 255;
  744.                 }
  745.                 // Rows to repeat
  746.                 if ($sheetSetup->isRowsToRepeatAtTopSet()) {
  747.                     $repeat = $sheetSetup->getRowsToRepeatAtTop();
  748.                     $rowmin = $repeat[0] - 1;
  749.                     $rowmax = $repeat[1] - 1;
  750.                 } else {
  751.                     $rowmin = 0;
  752.                     $rowmax = 65535;
  753.                 }
  754.  
  755.                 // construct formula data manually because parser does not recognize absolute 3d cell references
  756.                 $formulaData = pack('Cvvvvv', 0x3B, $i, $rowmin, $rowmax, $colmin, $colmax);
  757.  
  758.                 // store the DEFINEDNAME record
  759.                 $chunk .= $this->writeData($this->_writeDefinedNameBiff8(pack('C', 0x07), $formulaData, $i + 1, true));
  760.             }
  761.         }
  762.  
  763.         // write the print areas, if any
  764.         for ($i = 0; $i < $total_worksheets; ++$i) {
  765.             $sheetSetup = $this->_phpExcel->getSheet($i)->getPageSetup();
  766.             if ($sheetSetup->isPrintAreaSet()) {
  767.                 // Print area, e.g. A3:J6,H1:X20
  768.                 $printArea = PHPExcel_Cell::splitRange($sheetSetup->getPrintArea());
  769.                 $countPrintArea = count($printArea);
  770.  
  771.                 $formulaData = '';
  772.                 for ($j = 0; $j < $countPrintArea; ++$j) {
  773.                     $printAreaRect = $printArea[$j]; // e.g. A3:J6
  774.                     $printAreaRect[0] = PHPExcel_Cell::coordinateFromString($printAreaRect[0]);
  775.                     $printAreaRect[1] = PHPExcel_Cell::coordinateFromString($printAreaRect[1]);
  776.  
  777.                     $print_rowmin = $printAreaRect[0][1] - 1;
  778.                     $print_rowmax = $printAreaRect[1][1] - 1;
  779.                     $print_colmin = PHPExcel_Cell::columnIndexFromString($printAreaRect[0][0]) - 1;
  780.                     $print_colmax = PHPExcel_Cell::columnIndexFromString($printAreaRect[1][0]) - 1;
  781.  
  782.                     // construct formula data manually because parser does not recognize absolute 3d cell references
  783.                     $formulaData .= pack('Cvvvvv', 0x3B, $i, $print_rowmin, $print_rowmax, $print_colmin, $print_colmax);
  784.  
  785.                     if ($j > 0) {
  786.                         $formulaData .= pack('C', 0x10); // list operator token ','
  787.                     }
  788.                 }
  789.  
  790.                 // store the DEFINEDNAME record
  791.                 $chunk .= $this->writeData($this->_writeDefinedNameBiff8(pack('C', 0x06), $formulaData, $i + 1, true));
  792.             }
  793.         }
  794.  
  795.         return $chunk;
  796.     }
  797.  
  798.     /**
  799.      * Write a DEFINEDNAME record for BIFF8 using explicit binary formula data
  800.      *
  801.      * @param    string        $name            The name in UTF-8
  802.      * @param    string        $formulaData    The binary formula data
  803.      * @param    string        $sheetIndex        1-based sheet index the defined name applies to. 0 = global
  804.      * @param    boolean        $isBuiltIn        Built-in name?
  805.      * @return    string    Complete binary record data
  806.      */
  807.     private function _writeDefinedNameBiff8($name, $formulaData, $sheetIndex = 0, $isBuiltIn = false)
  808.     {
  809.         $record = 0x0018;
  810.  
  811.         // option flags
  812.         $options = $isBuiltIn ? 0x20 : 0x00;
  813.  
  814.         // length of the name, character count
  815.         $nlen = PHPExcel_Shared_String::CountCharacters($name);
  816.  
  817.         // name with stripped length field
  818.         $name = substr(PHPExcel_Shared_String::UTF8toBIFF8UnicodeLong($name), 2);
  819.  
  820.         // size of the formula (in bytes)
  821.         $sz = strlen($formulaData);
  822.  
  823.         // combine the parts
  824.         $data = pack('vCCvvvCCCC', $options, 0, $nlen, $sz, 0, $sheetIndex, 0, 0, 0, 0)
  825.             . $name . $formulaData;
  826.         $length = strlen($data);
  827.  
  828.         $header = pack('vv', $record, $length);
  829.  
  830.         return $header . $data;
  831.     }
  832.  
  833.     /**
  834.      * Stores the CODEPAGE biff record.
  835.      */
  836.     private function _writeCodepage()
  837.     {
  838.         $record          = 0x0042;             // Record identifier
  839.         $length          = 0x0002;             // Number of bytes to follow
  840.         $cv              = $this->_codepage;   // The code page
  841.  
  842.         $header          = pack('vv', $record, $length);
  843.         $data            = pack('v',  $cv);
  844.  
  845.         $this->_append($header . $data);
  846.     }
  847.  
  848.     /**
  849.      * Write Excel BIFF WINDOW1 record.
  850.      */
  851.     private function _writeWindow1()
  852.     {
  853.         $record    = 0x003D;                 // Record identifier
  854.         $length    = 0x0012;                 // Number of bytes to follow
  855.  
  856.         $xWn       = 0x0000;                 // Horizontal position of window
  857.         $yWn       = 0x0000;                 // Vertical position of window
  858.         $dxWn      = 0x25BC;                 // Width of window
  859.         $dyWn      = 0x1572;                 // Height of window
  860.  
  861.         $grbit     = 0x0038;                 // Option flags
  862.  
  863.         // not supported by PHPExcel, so there is only one selected sheet, the active
  864.         $ctabsel   = 1;       // Number of workbook tabs selected
  865.  
  866.         $wTabRatio = 0x0258;                 // Tab to scrollbar ratio
  867.  
  868.         // not supported by PHPExcel, set to 0
  869.         $itabFirst = 0;     // 1st displayed worksheet
  870.         $itabCur   = $this->_phpExcel->getActiveSheetIndex();    // Active worksheet
  871.  
  872.         $header    = pack("vv",        $record, $length);
  873.         $data      = pack("vvvvvvvvv", $xWn, $yWn, $dxWn, $dyWn,
  874.                                        $grbit,
  875.                                        $itabCur, $itabFirst,
  876.                                        $ctabsel, $wTabRatio);
  877.         $this->_append($header . $data);
  878.     }
  879.  
  880.     /**
  881.      * Writes Excel BIFF BOUNDSHEET record.
  882.      *
  883.      * @param PHPExcel_Worksheet  $sheet Worksheet name
  884.      * @param integer $offset    Location of worksheet BOF
  885.      */
  886.     private function _writeBoundsheet($sheet, $offset)
  887.     {
  888.         $sheetname = $sheet->getTitle();
  889.         $record    = 0x0085;                    // Record identifier
  890.  
  891.         // sheet state
  892.         switch ($sheet->getSheetState()) {
  893.             case PHPExcel_Worksheet::SHEETSTATE_VISIBLE:    $ss = 0x00; break;
  894.             case PHPExcel_Worksheet::SHEETSTATE_HIDDEN:        $ss = 0x01; break;
  895.             case PHPExcel_Worksheet::SHEETSTATE_VERYHIDDEN:    $ss = 0x02; break;
  896.             default: $ss = 0x00; break;
  897.         }
  898.  
  899.         // sheet type
  900.         $st = 0x00;
  901.  
  902.         $grbit     = 0x0000;                    // Visibility and sheet type
  903.  
  904.         if ($this->_BIFF_version == 0x0600) {
  905.             $data      = pack("VCC", $offset, $ss, $st);
  906.             $data .= PHPExcel_Shared_String::UTF8toBIFF8UnicodeShort($sheetname);
  907.         } else {
  908.             $cch       = strlen($sheetname);        // Length of sheet name
  909.             $data      = pack("VCCC", $offset, $ss, $st, $cch);
  910.             $data .= $sheetname;
  911.         }
  912.  
  913.         $length = strlen($data);
  914.         $header = pack("vv",  $record, $length);
  915.         $this->_append($header . $data);
  916.     }
  917.  
  918.     /**
  919.      * Write Internal SUPBOOK record
  920.      */
  921.     private function _writeSupbookInternal()
  922.     {
  923.         $record    = 0x01AE;   // Record identifier
  924.         $length    = 0x0004;   // Bytes to follow
  925.  
  926.         $header    = pack("vv", $record, $length);
  927.         $data      = pack("vv", $this->_phpExcel->getSheetCount(), 0x0401);
  928.         return $this->writeData($header . $data);
  929.     }
  930.  
  931.     /**
  932.      * Writes the Excel BIFF EXTERNSHEET record. These references are used by
  933.      * formulas.
  934.      *
  935.      */
  936.     private function _writeExternsheetBiff8()
  937.     {
  938.         $total_references = count($this->_parser->_references);
  939.         $record   = 0x0017;                     // Record identifier
  940.         $length   = 2 + 6 * $total_references;  // Number of bytes to follow
  941.  
  942.         $supbook_index = 0;           // FIXME: only using internal SUPBOOK record
  943.         $header           = pack("vv",  $record, $length);
  944.         $data             = pack('v', $total_references);
  945.         for ($i = 0; $i < $total_references; ++$i) {
  946.             $data .= $this->_parser->_references[$i];
  947.         }
  948.         return $this->writeData($header . $data);
  949.     }
  950.  
  951.     /**
  952.      * Write Excel BIFF STYLE records.
  953.      */
  954.     private function _writeStyle()
  955.     {
  956.         $record    = 0x0293;   // Record identifier
  957.         $length    = 0x0004;   // Bytes to follow
  958.  
  959.         $ixfe      = 0x8000;  // Index to cell style XF
  960.         $BuiltIn   = 0x00;     // Built-in style
  961.         $iLevel    = 0xff;     // Outline style level
  962.  
  963.         $header    = pack("vv",  $record, $length);
  964.         $data      = pack("vCC", $ixfe, $BuiltIn, $iLevel);
  965.         $this->_append($header . $data);
  966.     }
  967.  
  968.  
  969.     /**
  970.      * Writes Excel FORMAT record for non "built-in" numerical formats.
  971.      *
  972.      * @param string  $format Custom format string
  973.      * @param integer $ifmt   Format index code
  974.      */
  975.     private function _writeNumFormat($format, $ifmt)
  976.     {
  977.         $record    = 0x041E;                      // Record identifier
  978.  
  979.         if ($this->_BIFF_version == 0x0600) {
  980.             $numberFormatString = PHPExcel_Shared_String::UTF8toBIFF8UnicodeLong($format);
  981.             $length    = 2 + strlen($numberFormatString);      // Number of bytes to follow
  982.         } elseif ($this->_BIFF_version == 0x0500) {
  983.             $length    = 3 + strlen($format);      // Number of bytes to follow
  984.         }
  985.  
  986.  
  987.         $header    = pack("vv", $record, $length);
  988.         if ($this->_BIFF_version == 0x0600) {
  989.             $data      = pack("v", $ifmt) .  $numberFormatString;
  990.             $this->_append($header . $data);
  991.         } elseif ($this->_BIFF_version == 0x0500) {
  992.             $cch       = strlen($format);             // Length of format string
  993.             $data      = pack("vC", $ifmt, $cch);
  994.             $this->_append($header . $data . $format);
  995.         }
  996.     }
  997.  
  998.     /**
  999.      * Write DATEMODE record to indicate the date system in use (1904 or 1900).
  1000.      */
  1001.     private function _writeDatemode()
  1002.     {
  1003.         $record    = 0x0022;         // Record identifier
  1004.         $length    = 0x0002;         // Bytes to follow
  1005.  
  1006.         $f1904     = (PHPExcel_Shared_Date::getExcelCalendar() == PHPExcel_Shared_Date::CALENDAR_MAC_1904) ?
  1007.             1 : 0;   // Flag for 1904 date system
  1008.  
  1009.         $header    = pack("vv", $record, $length);
  1010.         $data      = pack("v", $f1904);
  1011.         $this->_append($header . $data);
  1012.     }
  1013.  
  1014.  
  1015.     /**
  1016.      * Write BIFF record EXTERNCOUNT to indicate the number of external sheet
  1017.      * references in the workbook.
  1018.      *
  1019.      * Excel only stores references to external sheets that are used in NAME.
  1020.      * The workbook NAME record is required to define the print area and the repeat
  1021.      * rows and columns.
  1022.      *
  1023.      * A similar method is used in Worksheet.php for a slightly different purpose.
  1024.      *
  1025.      * @param integer $cxals Number of external references
  1026.      */
  1027.     private function _writeExterncount($cxals)
  1028.     {
  1029.         $record   = 0x0016;          // Record identifier
  1030.         $length   = 0x0002;          // Number of bytes to follow
  1031.  
  1032.         $header   = pack("vv", $record, $length);
  1033.         $data     = pack("v",  $cxals);
  1034.         $this->_append($header . $data);
  1035.     }
  1036.  
  1037.  
  1038.     /**
  1039.      * Writes the Excel BIFF EXTERNSHEET record. These references are used by
  1040.      * formulas. NAME record is required to define the print area and the repeat
  1041.      * rows and columns.
  1042.      *
  1043.      * A similar method is used in Worksheet.php for a slightly different purpose.
  1044.      *
  1045.      * @param string $sheetname Worksheet name
  1046.      */
  1047.     private function _writeExternsheet($sheetname)
  1048.     {
  1049.         $record      = 0x0017;                     // Record identifier
  1050.         $length      = 0x02 + strlen($sheetname);  // Number of bytes to follow
  1051.  
  1052.         $cch         = strlen($sheetname);         // Length of sheet name
  1053.         $rgch        = 0x03;                       // Filename encoding
  1054.  
  1055.         $header      = pack("vv",  $record, $length);
  1056.         $data        = pack("CC", $cch, $rgch);
  1057.         $this->_append($header . $data . $sheetname);
  1058.     }
  1059.  
  1060.  
  1061.     /**
  1062.      * Store the NAME record in the short format that is used for storing the print
  1063.      * area, repeat rows only and repeat columns only.
  1064.      *
  1065.      * @param integer $index  Sheet index
  1066.      * @param integer $type   Built-in name type
  1067.      * @param integer $rowmin Start row
  1068.      * @param integer $rowmax End row
  1069.      * @param integer $colmin Start colum
  1070.      * @param integer $colmax End column
  1071.      */
  1072.     private function _writeNameShort($index, $type, $rowmin, $rowmax, $colmin, $colmax)
  1073.     {
  1074.         $record          = 0x0018;       // Record identifier
  1075.         $length          = 0x0024;       // Number of bytes to follow
  1076.  
  1077.         $grbit           = 0x0020;       // Option flags
  1078.         $chKey           = 0x00;         // Keyboard shortcut
  1079.         $cch             = 0x01;         // Length of text name
  1080.         $cce             = 0x0015;       // Length of text definition
  1081.         $ixals           = $index + 1;   // Sheet index
  1082.         $itab            = $ixals;       // Equal to ixals
  1083.         $cchCustMenu     = 0x00;         // Length of cust menu text
  1084.         $cchDescription  = 0x00;         // Length of description text
  1085.         $cchHelptopic    = 0x00;         // Length of help topic text
  1086.         $cchStatustext   = 0x00;         // Length of status bar text
  1087.         $rgch            = $type;        // Built-in name type
  1088.  
  1089.         $unknown03       = 0x3b;
  1090.         $unknown04       = 0xffff-$index;
  1091.         $unknown05       = 0x0000;
  1092.         $unknown06       = 0x0000;
  1093.         $unknown07       = 0x1087;
  1094.         $unknown08       = 0x8005;
  1095.  
  1096.         $header             = pack("vv", $record, $length);
  1097.         $data               = pack("v", $grbit);
  1098.         $data              .= pack("C", $chKey);
  1099.         $data              .= pack("C", $cch);
  1100.         $data              .= pack("v", $cce);
  1101.         $data              .= pack("v", $ixals);
  1102.         $data              .= pack("v", $itab);
  1103.         $data              .= pack("C", $cchCustMenu);
  1104.         $data              .= pack("C", $cchDescription);
  1105.         $data              .= pack("C", $cchHelptopic);
  1106.         $data              .= pack("C", $cchStatustext);
  1107.         $data              .= pack("C", $rgch);
  1108.         $data              .= pack("C", $unknown03);
  1109.         $data              .= pack("v", $unknown04);
  1110.         $data              .= pack("v", $unknown05);
  1111.         $data              .= pack("v", $unknown06);
  1112.         $data              .= pack("v", $unknown07);
  1113.         $data              .= pack("v", $unknown08);
  1114.         $data              .= pack("v", $index);
  1115.         $data              .= pack("v", $index);
  1116.         $data              .= pack("v", $rowmin);
  1117.         $data              .= pack("v", $rowmax);
  1118.         $data              .= pack("C", $colmin);
  1119.         $data              .= pack("C", $colmax);
  1120.         $this->_append($header . $data);
  1121.     }
  1122.  
  1123.  
  1124.     /**
  1125.      * Store the NAME record in the long format that is used for storing the repeat
  1126.      * rows and columns when both are specified. This shares a lot of code with
  1127.      * _writeNameShort() but we use a separate method to keep the code clean.
  1128.      * Code abstraction for reuse can be carried too far, and I should know. ;-)
  1129.      *
  1130.      * @param integer $index Sheet index
  1131.      * @param integer $type  Built-in name type
  1132.      * @param integer $rowmin Start row
  1133.      * @param integer $rowmax End row
  1134.      * @param integer $colmin Start colum
  1135.      * @param integer $colmax End column
  1136.      */
  1137.     private function _writeNameLong($index, $type, $rowmin, $rowmax, $colmin, $colmax)
  1138.     {
  1139.         $record          = 0x0018;       // Record identifier
  1140.         $length          = 0x003d;       // Number of bytes to follow
  1141.         $grbit           = 0x0020;       // Option flags
  1142.         $chKey           = 0x00;         // Keyboard shortcut
  1143.         $cch             = 0x01;         // Length of text name
  1144.         $cce             = 0x002e;       // Length of text definition
  1145.         $ixals           = $index + 1;   // Sheet index
  1146.         $itab            = $ixals;       // Equal to ixals
  1147.         $cchCustMenu     = 0x00;         // Length of cust menu text
  1148.         $cchDescription  = 0x00;         // Length of description text
  1149.         $cchHelptopic    = 0x00;         // Length of help topic text
  1150.         $cchStatustext   = 0x00;         // Length of status bar text
  1151.         $rgch            = $type;        // Built-in name type
  1152.  
  1153.         $unknown01       = 0x29;
  1154.         $unknown02       = 0x002b;
  1155.         $unknown03       = 0x3b;
  1156.         $unknown04       = 0xffff-$index;
  1157.         $unknown05       = 0x0000;
  1158.         $unknown06       = 0x0000;
  1159.         $unknown07       = 0x1087;
  1160.         $unknown08       = 0x8008;
  1161.  
  1162.         $header             = pack("vv",  $record, $length);
  1163.         $data               = pack("v", $grbit);
  1164.         $data              .= pack("C", $chKey);
  1165.         $data              .= pack("C", $cch);
  1166.         $data              .= pack("v", $cce);
  1167.         $data              .= pack("v", $ixals);
  1168.         $data              .= pack("v", $itab);
  1169.         $data              .= pack("C", $cchCustMenu);
  1170.         $data              .= pack("C", $cchDescription);
  1171.         $data              .= pack("C", $cchHelptopic);
  1172.         $data              .= pack("C", $cchStatustext);
  1173.         $data              .= pack("C", $rgch);
  1174.         $data              .= pack("C", $unknown01);
  1175.         $data              .= pack("v", $unknown02);
  1176.         // Column definition
  1177.         $data              .= pack("C", $unknown03);
  1178.         $data              .= pack("v", $unknown04);
  1179.         $data              .= pack("v", $unknown05);
  1180.         $data              .= pack("v", $unknown06);
  1181.         $data              .= pack("v", $unknown07);
  1182.         $data              .= pack("v", $unknown08);
  1183.         $data              .= pack("v", $index);
  1184.         $data              .= pack("v", $index);
  1185.         $data              .= pack("v", 0x0000);
  1186.         $data              .= pack("v", 0x3fff);
  1187.         $data              .= pack("C", $colmin);
  1188.         $data              .= pack("C", $colmax);
  1189.         // Row definition
  1190.         $data              .= pack("C", $unknown03);
  1191.         $data              .= pack("v", $unknown04);
  1192.         $data              .= pack("v", $unknown05);
  1193.         $data              .= pack("v", $unknown06);
  1194.         $data              .= pack("v", $unknown07);
  1195.         $data              .= pack("v", $unknown08);
  1196.         $data              .= pack("v", $index);
  1197.         $data              .= pack("v", $index);
  1198.         $data              .= pack("v", $rowmin);
  1199.         $data              .= pack("v", $rowmax);
  1200.         $data              .= pack("C", 0x00);
  1201.         $data              .= pack("C", 0xff);
  1202.         // End of data
  1203.         $data              .= pack("C", 0x10);
  1204.         $this->_append($header . $data);
  1205.     }
  1206.  
  1207.     /**
  1208.      * Stores the COUNTRY record for localization
  1209.      *
  1210.      * @return string 
  1211.      */
  1212.     private function _writeCountry()
  1213.     {
  1214.         $record          = 0x008C;    // Record identifier
  1215.         $length          = 4;         // Number of bytes to follow
  1216.  
  1217.         $header = pack('vv',  $record, $length);
  1218.         /* using the same country code always for simplicity */
  1219.         $data = pack('vv', $this->_country_code, $this->_country_code);
  1220.         //$this->_append($header . $data);
  1221.         return $this->writeData($header . $data);
  1222.     }
  1223.  
  1224.     /**
  1225.      * Write the RECALCID record
  1226.      *
  1227.      * @return string 
  1228.      */
  1229.     private function _writeRecalcId()
  1230.     {
  1231.         $record = 0x01C1;    // Record identifier
  1232.         $length = 8;         // Number of bytes to follow
  1233.  
  1234.         $header = pack('vv',  $record, $length);
  1235.  
  1236.         // by inspection of real Excel files, MS Office Excel 2007 writes this
  1237.         $data = pack('VV', 0x000001C1, 0x00001E667);
  1238.  
  1239.         return $this->writeData($header . $data);
  1240.     }
  1241.  
  1242.     /**
  1243.      * Stores the PALETTE biff record.
  1244.      */
  1245.     private function _writePalette()
  1246.     {
  1247.         $aref            = $this->_palette;
  1248.  
  1249.         $record          = 0x0092;                 // Record identifier
  1250.         $length          = 2 + 4 * count($aref);   // Number of bytes to follow
  1251.         $ccv             =         count($aref);   // Number of RGB values to follow
  1252.         $data = '';                                // The RGB data
  1253.  
  1254.         // Pack the RGB data
  1255.         foreach ($aref as $color) {
  1256.             foreach ($color as $byte) {
  1257.                 $data .= pack("C",$byte);
  1258.             }
  1259.         }
  1260.  
  1261.         $header = pack("vvv",  $record, $length, $ccv);
  1262.         $this->_append($header . $data);
  1263.     }
  1264.  
  1265.     /**
  1266.      * Handling of the SST continue blocks is complicated by the need to include an
  1267.      * additional continuation byte depending on whether the string is split between
  1268.      * blocks or whether it starts at the beginning of the block. (There are also
  1269.      * additional complications that will arise later when/if Rich Strings are
  1270.      * supported).
  1271.      *
  1272.      * The Excel documentation says that the SST record should be followed by an
  1273.      * EXTSST record. The EXTSST record is a hash table that is used to optimise
  1274.      * access to SST. However, despite the documentation it doesn't seem to be
  1275.      * required so we will ignore it.
  1276.      *
  1277.      * @return string Binary data
  1278.      */
  1279.     private function _writeSharedStringsTable()
  1280.     {
  1281.         // maximum size of record data (excluding record header)
  1282.         $continue_limit = 8224;
  1283.  
  1284.         // initialize array of record data blocks
  1285.         $recordDatas = array();
  1286.  
  1287.         // start SST record data block with total number of strings, total number of unique strings
  1288.         $recordData = pack("VV", $this->_str_total, $this->_str_unique);
  1289.  
  1290.         // loop through all (unique) strings in shared strings table
  1291.         foreach (array_keys($this->_str_table) as $string) {
  1292.  
  1293.             // here $string is a BIFF8 encoded string
  1294.  
  1295.             // length = character count
  1296.             $headerinfo = unpack("vlength/Cencoding", $string);
  1297.  
  1298.             // currently, this is always 1 = uncompressed
  1299.             $encoding = $headerinfo["encoding"];
  1300.  
  1301.             // initialize finished writing current $string
  1302.             $finished = false;
  1303.  
  1304.             while ($finished === false) {
  1305.  
  1306.                 // normally, there will be only one cycle, but if string cannot immediately be written as is
  1307.                 // there will be need for more than one cylcle, if string longer than one record data block, there
  1308.                 // may be need for even more cycles
  1309.  
  1310.                 if (strlen($recordData) + strlen($string) < $continue_limit) {
  1311.                     // then we can write the string (or remainder of string) without any problems
  1312.                     $recordData .= $string;
  1313.  
  1314.                     // we are finished writing this string
  1315.                     $finished = true;
  1316.  
  1317.                 } else if (strlen($recordData) + strlen($string) == $continue_limit) {
  1318.                     // then we can also write the string (or remainder of string)
  1319.                     $recordData .= $string;
  1320.  
  1321.                     // but we close the record data block, and initialize a new one
  1322.                     $recordDatas[] = $recordData;
  1323.                     $recordData = '';
  1324.  
  1325.                     // we are finished writing this string
  1326.                     $finished = true;
  1327.  
  1328.                 } else {
  1329.                     // special treatment writing the string (or remainder of the string)
  1330.                     // If the string is very long it may need to be written in more than one CONTINUE record.
  1331.  
  1332.                     // check how many bytes more there is room for in the current record
  1333.                     $space_remaining = $continue_limit - strlen($recordData);
  1334.  
  1335.                     // minimum space needed
  1336.                     // uncompressed: 2 byte string length length field + 1 byte option flags + 2 byte character
  1337.                     // compressed:   2 byte string length length field + 1 byte option flags + 1 byte character
  1338.                     $min_space_needed = ($encoding == 1) ? 5 : 4;
  1339.  
  1340.                     // We have two cases
  1341.                     // 1. space remaining is less than minimum space needed
  1342.                     //        here we must waste the space remaining and move to next record data block
  1343.                     // 2. space remaining is greater than or equal to minimum space needed
  1344.                     //        here we write as much as we can in the current block, then move to next record data block
  1345.  
  1346.                     // 1. space remaining is less than minimum space needed
  1347.                     if ($space_remaining < $min_space_needed) {
  1348.                         // we close the block, store the block data
  1349.                         $recordDatas[] = $recordData;
  1350.  
  1351.                         // and start new record data block where we start writing the string
  1352.                         $recordData = '';
  1353.  
  1354.                     // 2. space remaining is greater than or equal to minimum space needed
  1355.                     } else {
  1356.                         // initialize effective remaining space, for Unicode strings this may need to be reduced by 1, see below
  1357.                         $effective_space_remaining = $space_remaining;
  1358.  
  1359.                         // for uncompressed strings, sometimes effective space remaining is reduced by 1
  1360.                         if ( $encoding == 1 && (strlen($string) - $space_remaining) % 2 == 1 ) {
  1361.                             --$effective_space_remaining;
  1362.                         }
  1363.  
  1364.                         // one block fininshed, store the block data
  1365.                         $recordData .= substr($string, 0, $effective_space_remaining);
  1366.  
  1367.                         $string = substr($string, $effective_space_remaining); // for next cycle in while loop
  1368.                         $recordDatas[] = $recordData;
  1369.  
  1370.                         // start new record data block with the repeated option flags
  1371.                         $recordData = pack('C', $encoding);
  1372.                     }
  1373.                 }
  1374.             }
  1375.         }
  1376.  
  1377.         // Store the last record data block unless it is empty
  1378.         // if there was no need for any continue records, this will be the for SST record data block itself
  1379.         if (strlen($recordData) > 0) {
  1380.             $recordDatas[] = $recordData;
  1381.         }
  1382.  
  1383.         // combine into one chunk with all the blocks SST, CONTINUE,...
  1384.         $chunk = '';
  1385.         foreach ($recordDatas as $i => $recordData) {
  1386.             // first block should have the SST record header, remaing should have CONTINUE header
  1387.             $record = ($i == 0) ? 0x00FC : 0x003C;
  1388.  
  1389.             $header = pack("vv", $record, strlen($recordData));
  1390.             $data = $header . $recordData;
  1391.  
  1392.             $chunk .= $this->writeData($data);
  1393.         }
  1394.  
  1395.         return $chunk;
  1396.     }
  1397.  
  1398.     /**
  1399.      * Writes the MSODRAWINGGROUP record if needed. Possibly split using CONTINUE records.
  1400.      */
  1401.     private function _writeMsoDrawingGroup()
  1402.     {
  1403.         // any drawings in this workbook?
  1404.         $found = false;
  1405.         foreach ($this->_phpExcel->getAllSheets() as $sheet) {
  1406.             if (count($sheet->getDrawingCollection()) > 0) {
  1407.                 $found = true;
  1408.             }
  1409.         }
  1410.  
  1411.         // if there are drawings, then we need to write MSODRAWINGGROUP record
  1412.         if ($found) {
  1413.  
  1414.             // create intermediate Escher object
  1415.             $escher = new PHPExcel_Shared_Escher();
  1416.  
  1417.             // dggContainer
  1418.             $dggContainer = new PHPExcel_Shared_Escher_DggContainer();
  1419.             $escher->setDggContainer($dggContainer);
  1420.  
  1421.             // this loop is for determining maximum shape identifier of all drawing
  1422.             $spIdMax = 0;
  1423.             $totalCountShapes = 0;
  1424.             $countDrawings = 0;
  1425.  
  1426.             foreach ($this->_phpExcel->getAllsheets() as $sheet) {
  1427.                 $sheetCountShapes = 0; // count number of shapes (minus group shape), in sheet
  1428.  
  1429.                 if (count($sheet->getDrawingCollection()) > 0) {
  1430.                     ++$countDrawings;
  1431.  
  1432.                     foreach ($sheet->getDrawingCollection() as $drawing) {
  1433.                         ++$sheetCountShapes;
  1434.                         ++$totalCountShapes;
  1435.  
  1436.                         $spId = $sheetCountShapes
  1437.                             | ($this->_phpExcel->getIndex($sheet) + 1) << 10;
  1438.                         $spIdMax = max($spId, $spIdMax);
  1439.                     }
  1440.                 }
  1441.             }
  1442.  
  1443.             $dggContainer->setSpIdMax($spIdMax + 1);
  1444.             $dggContainer->setCDgSaved($countDrawings);
  1445.             $dggContainer->setCSpSaved($totalCountShapes + $countDrawings); // total number of shapes incl. one group shapes per drawing
  1446.  
  1447.             // bstoreContainer
  1448.             $bstoreContainer = new PHPExcel_Shared_Escher_DggContainer_BstoreContainer();
  1449.             $dggContainer->setBstoreContainer($bstoreContainer);
  1450.  
  1451.             // the BSE's (all the images)
  1452.             foreach ($this->_phpExcel->getAllsheets() as $sheet) {
  1453.                 foreach ($sheet->getDrawingCollection() as $drawing) {
  1454.                     if ($drawing instanceof PHPExcel_Worksheet_Drawing) {
  1455.  
  1456.                         $filename = $drawing->getPath();
  1457.  
  1458.                         list($imagesx, $imagesy, $imageFormat) = getimagesize($filename);
  1459.  
  1460.                         switch ($imageFormat) {
  1461.  
  1462.                         case 1: // GIF, not supported by BIFF8, we convert to PNG
  1463.                             $blipType = PHPExcel_Shared_Escher_DggContainer_BstoreContainer_BSE::BLIPTYPE_PNG;
  1464.                             $imageResource = imagecreatefromgif($filename);
  1465.                             ob_start();
  1466.                             imagepng($imageResource);
  1467.                             $blipData = ob_get_contents();
  1468.                             ob_end_clean();
  1469.                             break;
  1470.  
  1471.                         case 2: // JPEG
  1472.                             $blipType = PHPExcel_Shared_Escher_DggContainer_BstoreContainer_BSE::BLIPTYPE_JPEG;
  1473.                             $blipData = file_get_contents($filename);
  1474.                             break;
  1475.  
  1476.                         case 3: // PNG
  1477.                             $blipType = PHPExcel_Shared_Escher_DggContainer_BstoreContainer_BSE::BLIPTYPE_PNG;
  1478.                             $blipData = file_get_contents($filename);
  1479.                             break;
  1480.  
  1481.                         case 6: // Windows DIB (BMP), we convert to PNG
  1482.                             $blipType = PHPExcel_Shared_Escher_DggContainer_BstoreContainer_BSE::BLIPTYPE_PNG;
  1483.                             $imageResource = PHPExcel_Shared_Drawing::imagecreatefrombmp($filename);
  1484.                             ob_start();
  1485.                             imagepng($imageResource);
  1486.                             $blipData = ob_get_contents();
  1487.                             ob_end_clean();
  1488.                             break;
  1489.  
  1490.                         default: continue 2;
  1491.  
  1492.                         }
  1493.  
  1494.                         $blip = new PHPExcel_Shared_Escher_DggContainer_BstoreContainer_BSE_Blip();
  1495.                         $blip->setData($blipData);
  1496.  
  1497.                         $BSE = new PHPExcel_Shared_Escher_DggContainer_BstoreContainer_BSE();
  1498.                         $BSE->setBlipType($blipType);
  1499.                         $BSE->setBlip($blip);
  1500.  
  1501.                         $bstoreContainer->addBSE($BSE);
  1502.  
  1503.                     } else if ($drawing instanceof PHPExcel_Worksheet_MemoryDrawing) {
  1504.  
  1505.                         switch ($drawing->getRenderingFunction()) {
  1506.  
  1507.                         case PHPExcel_Worksheet_MemoryDrawing::RENDERING_JPEG:
  1508.                             $blipType = PHPExcel_Shared_Escher_DggContainer_BstoreContainer_BSE::BLIPTYPE_JPEG;
  1509.                             $renderingFunction = 'imagejpeg';
  1510.                             break;
  1511.  
  1512.                         case PHPExcel_Worksheet_MemoryDrawing::RENDERING_GIF:
  1513.                         case PHPExcel_Worksheet_MemoryDrawing::RENDERING_PNG:
  1514.                         case PHPExcel_Worksheet_MemoryDrawing::RENDERING_DEFAULT:
  1515.                             $blipType = PHPExcel_Shared_Escher_DggContainer_BstoreContainer_BSE::BLIPTYPE_PNG;
  1516.                             $renderingFunction = 'imagepng';
  1517.                             break;
  1518.  
  1519.                         }
  1520.  
  1521.                         ob_start();
  1522.                         call_user_func($renderingFunction, $drawing->getImageResource());
  1523.                         $blipData = ob_get_contents();
  1524.                         ob_end_clean();
  1525.  
  1526.                         $blip = new PHPExcel_Shared_Escher_DggContainer_BstoreContainer_BSE_Blip();
  1527.                         $blip->setData($blipData);
  1528.  
  1529.                         $BSE = new PHPExcel_Shared_Escher_DggContainer_BstoreContainer_BSE();
  1530.                         $BSE->setBlipType($blipType);
  1531.                         $BSE->setBlip($blip);
  1532.  
  1533.                         $bstoreContainer->addBSE($BSE);
  1534.                     }
  1535.                 }
  1536.             }
  1537.  
  1538.             // write the Escher stream from the intermediate Escher object
  1539.             $writer = new PHPExcel_Writer_Excel5_Escher($escher);
  1540.             $data = $writer->close();
  1541.  
  1542.             $record = 0x00EB;
  1543.             $length = strlen($data);
  1544.             $header = pack("vv",  $record, $length);
  1545.  
  1546.             return $this->writeData($header . $data);
  1547.         }
  1548.     }
  1549.  
  1550. }
Documentation generated on Tue, 01 Jun 2010 17:08:20 +0200 by phpDocumentor 1.4.3