PHPExcel
[ class tree: PHPExcel ] [ index: PHPExcel ] [ all elements ]

Source for file PHPExcel.php

Documentation is available at PHPExcel.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
  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.2, 2010-01-11
  26.  */
  27.  
  28.  
  29. /** PHPExcel root directory */
  30. if (!defined('PHPEXCEL_ROOT')) {
  31.     define('PHPEXCEL_ROOT'dirname(__FILE__'/');
  32. }
  33.  
  34. /** PHPExcel_Cell */
  35. require_once PHPEXCEL_ROOT 'PHPExcel/Cell.php';
  36.  
  37. /** PHPExcel_DocumentProperties */
  38. require_once PHPEXCEL_ROOT 'PHPExcel/DocumentProperties.php';
  39.  
  40. /** PHPExcel_DocumentSecurity */
  41. require_once PHPEXCEL_ROOT 'PHPExcel/DocumentSecurity.php';
  42.  
  43. /** PHPExcel_Worksheet */
  44. require_once PHPEXCEL_ROOT 'PHPExcel/Worksheet.php';
  45.  
  46. /** PHPExcel_Shared_ZipStreamWrapper */
  47. require_once PHPEXCEL_ROOT 'PHPExcel/Shared/ZipStreamWrapper.php';
  48.  
  49. /** PHPExcel_NamedRange */
  50. require_once PHPEXCEL_ROOT 'PHPExcel/NamedRange.php';
  51.  
  52. /** PHPExcel_WorksheetIterator */
  53. require_once PHPEXCEL_ROOT 'PHPExcel/WorksheetIterator.php';
  54.  
  55.  
  56. /**
  57.  * PHPExcel
  58.  *
  59.  * @category   PHPExcel
  60.  * @package    PHPExcel
  61.  * @copyright  Copyright (c) 2006 - 2010 PHPExcel (http://www.codeplex.com/PHPExcel)
  62.  */
  63. class PHPExcel
  64. {
  65.     /**
  66.      * Document properties
  67.      *
  68.      * @var PHPExcel_DocumentProperties 
  69.      */
  70.     private $_properties;
  71.  
  72.     /**
  73.      * Document security
  74.      *
  75.      * @var PHPExcel_DocumentSecurity 
  76.      */
  77.     private $_security;
  78.  
  79.     /**
  80.      * Collection of Worksheet objects
  81.      *
  82.      * @var PHPExcel_Worksheet[] 
  83.      */
  84.     private $_workSheetCollection = array();
  85.  
  86.     /**
  87.      * Active sheet index
  88.      *
  89.      * @var int 
  90.      */
  91.     private $_activeSheetIndex = 0;
  92.  
  93.     /**
  94.      * Named ranges
  95.      *
  96.      * @var PHPExcel_NamedRange[] 
  97.      */
  98.     private $_namedRanges = array();
  99.  
  100.     /**
  101.      * CellXf supervisor
  102.      *
  103.      * @var PHPExcel_Style 
  104.      */
  105.     private $_cellXfSupervisor;
  106.  
  107.     /**
  108.      * CellXf collection
  109.      *
  110.      * @var PHPExcel_Style[] 
  111.      */
  112.     private $_cellXfCollection = array();
  113.  
  114.     /**
  115.      * CellStyleXf collection
  116.      *
  117.      * @var PHPExcel_Style[] 
  118.      */
  119.     private $_cellStyleXfCollection = array();
  120.  
  121.     /**
  122.      * Create a new PHPExcel with one Worksheet
  123.      */
  124.     public function __construct()
  125.     {
  126.         // Initialise worksheet collection and add one worksheet
  127.         $this->_workSheetCollection = array();
  128.         $this->_workSheetCollection[new PHPExcel_Worksheet($this);
  129.         $this->_activeSheetIndex = 0;
  130.  
  131.         // Create document properties
  132.         $this->_properties = new PHPExcel_DocumentProperties();
  133.  
  134.         // Create document security
  135.         $this->_security = new PHPExcel_DocumentSecurity();
  136.  
  137.         // Set named ranges
  138.         $this->_namedRanges = array();
  139.  
  140.         // Create the cellXf supervisor
  141.         $this->_cellXfSupervisor = new PHPExcel_Style(true);
  142.         $this->_cellXfSupervisor->bindParent($this);
  143.  
  144.         // Create the default style
  145.         $this->addCellXf(new PHPExcel_Style);
  146.         $this->addCellStyleXf(new PHPExcel_Style);
  147.     }
  148.  
  149.     /**
  150.      * Get properties
  151.      *
  152.      * @return PHPExcel_DocumentProperties 
  153.      */
  154.     public function getProperties()
  155.     {
  156.         return $this->_properties;
  157.     }
  158.  
  159.     /**
  160.      * Set properties
  161.      *
  162.      * @param PHPExcel_DocumentProperties    $pValue 
  163.      */
  164.     public function setProperties(PHPExcel_DocumentProperties $pValue)
  165.     {
  166.         $this->_properties = $pValue;
  167.     }
  168.  
  169.     /**
  170.      * Get security
  171.      *
  172.      * @return PHPExcel_DocumentSecurity 
  173.      */
  174.     public function getSecurity()
  175.     {
  176.         return $this->_security;
  177.     }
  178.  
  179.     /**
  180.      * Set security
  181.      *
  182.      * @param PHPExcel_DocumentSecurity    $pValue 
  183.      */
  184.     public function setSecurity(PHPExcel_DocumentSecurity $pValue)
  185.     {
  186.         $this->_security = $pValue;
  187.     }
  188.  
  189.     /**
  190.      * Get active sheet
  191.      *
  192.      * @return PHPExcel_Worksheet 
  193.      */
  194.     public function getActiveSheet()
  195.     {
  196.         return $this->_workSheetCollection[$this->_activeSheetIndex];
  197.     }
  198.  
  199.     /**
  200.      * Create sheet and add it to this workbook
  201.      *
  202.      * @return PHPExcel_Worksheet 
  203.      */
  204.     public function createSheet($iSheetIndex null)
  205.     {
  206.         $newSheet new PHPExcel_Worksheet($this);
  207.         $this->addSheet($newSheet$iSheetIndex);
  208.         return $newSheet;
  209.     }
  210.  
  211.     /**
  212.      * Add sheet
  213.      *
  214.      * @param PHPExcel_Worksheet $pSheet 
  215.      * @param int|null$iSheetIndex Index where sheet should go (0,1,..., or null for last)
  216.      * @return PHPExcel_Worksheet 
  217.      * @throws Exception
  218.      */
  219.     public function addSheet(PHPExcel_Worksheet $pSheet null$iSheetIndex null)
  220.     {
  221.         if(is_null($iSheetIndex))
  222.         {
  223.             $this->_workSheetCollection[$pSheet;
  224.         }
  225.         else
  226.         {
  227.             // Insert the sheet at the requested index
  228.             array_splice(
  229.                 $this->_workSheetCollection,
  230.                 $iSheetIndex,
  231.                 0,
  232.                 array($pSheet)
  233.                 );
  234.  
  235.             // Adjust active sheet index if necessary
  236.             if ($this->_activeSheetIndex >= $iSheetIndex{
  237.                 ++$this->_activeSheetIndex;
  238.             }
  239.  
  240.         }
  241.         return $pSheet;
  242.     }
  243.  
  244.     /**
  245.      * Remove sheet by index
  246.      *
  247.      * @param int $pIndex Active sheet index
  248.      * @throws Exception
  249.      */
  250.     public function removeSheetByIndex($pIndex 0)
  251.     {
  252.         if ($pIndex count($this->_workSheetCollection1{
  253.             throw new Exception("Sheet index is out of bounds.");
  254.         else {
  255.             array_splice($this->_workSheetCollection$pIndex1);
  256.         }
  257.     }
  258.  
  259.     /**
  260.      * Get sheet by index
  261.      *
  262.      * @param int $pIndex Sheet index
  263.      * @return PHPExcel_Worksheet 
  264.      * @throws Exception
  265.      */
  266.     public function getSheet($pIndex 0)
  267.     {
  268.         if ($pIndex count($this->_workSheetCollection1{
  269.             throw new Exception("Sheet index is out of bounds.");
  270.         else {
  271.             return $this->_workSheetCollection[$pIndex];
  272.         }
  273.     }
  274.  
  275.     /**
  276.      * Get all sheets
  277.      *
  278.      * @return PHPExcel_Worksheet[] 
  279.      */
  280.     public function getAllSheets()
  281.     {
  282.         return $this->_workSheetCollection;
  283.     }
  284.  
  285.     /**
  286.      * Get sheet by name
  287.      *
  288.      * @param string $pName Sheet name
  289.      * @return PHPExcel_Worksheet 
  290.      * @throws Exception
  291.      */
  292.     public function getSheetByName($pName '')
  293.     {
  294.         $worksheetCount count($this->_workSheetCollection);
  295.         for ($i 0$i $worksheetCount++$i{
  296.             if ($this->_workSheetCollection[$i]->getTitle(== $pName{
  297.                 return $this->_workSheetCollection[$i];
  298.             }
  299.         }
  300.  
  301.         return null;
  302.     }
  303.  
  304.     /**
  305.      * Get index for sheet
  306.      *
  307.      * @param PHPExcel_Worksheet $pSheet 
  308.      * @return Sheet index
  309.      * @throws Exception
  310.      */
  311.     public function getIndex(PHPExcel_Worksheet $pSheet)
  312.     {
  313.         foreach ($this->_workSheetCollection as $key => $value{
  314.             if ($value->getHashCode(== $pSheet->getHashCode()) {
  315.                 return $key;
  316.             }
  317.         }
  318.     }
  319.  
  320.     /**
  321.      * Set index for sheet by sheet name.
  322.      *
  323.      * @param string $sheetName Sheet name to modify index for
  324.      * @param int $newIndex New index for the sheet
  325.      * @return New sheet index
  326.      * @throws Exception
  327.      */
  328.     public function setIndexByName($sheetName$newIndex)
  329.     {
  330.         $oldIndex $this->getIndex($this->getSheetByName($sheetName));
  331.         $pSheet array_splice(
  332.             $this->_workSheetCollection,
  333.             $oldIndex,
  334.             1
  335.             );
  336.         array_splice(
  337.             $this->_workSheetCollection,
  338.             $newIndex,
  339.             0,
  340.             $pSheet
  341.             );
  342.         return $newIndex;
  343.     }
  344.  
  345.     /**
  346.      * Get sheet count
  347.      *
  348.      * @return int 
  349.      */
  350.     public function getSheetCount()
  351.     {
  352.         return count($this->_workSheetCollection);
  353.     }
  354.  
  355.     /**
  356.      * Get active sheet index
  357.      *
  358.      * @return int Active sheet index
  359.      */
  360.     public function getActiveSheetIndex()
  361.     {
  362.         return $this->_activeSheetIndex;
  363.     }
  364.  
  365.     /**
  366.      * Set active sheet index
  367.      *
  368.      * @param int $pIndex Active sheet index
  369.      * @throws Exception
  370.      * @return PHPExcel_Worksheet 
  371.      */
  372.     public function setActiveSheetIndex($pIndex 0)
  373.     {
  374.         if ($pIndex count($this->_workSheetCollection1{
  375.             throw new Exception("Active sheet index is out of bounds.");
  376.         else {
  377.             $this->_activeSheetIndex = $pIndex;
  378.         }
  379.         return $this->getActiveSheet();
  380.     }
  381.  
  382.     /**
  383.      * Get sheet names
  384.      *
  385.      * @return string[] 
  386.      */
  387.     public function getSheetNames()
  388.     {
  389.         $returnValue array();
  390.         $worksheetCount $this->getSheetCount();
  391.         for ($i 0$i $worksheetCount++$i{
  392.             array_push($returnValue$this->getSheet($i)->getTitle());
  393.         }
  394.  
  395.         return $returnValue;
  396.     }
  397.  
  398.     /**
  399.      * Add external sheet
  400.      *
  401.      * @param PHPExcel_Worksheet $pSheet External sheet to add
  402.      * @param int|null$iSheetIndex Index where sheet should go (0,1,..., or null for last)
  403.      * @throws Exception
  404.      * @return PHPExcel_Worksheet 
  405.      */
  406.     public function addExternalSheet(PHPExcel_Worksheet $pSheet$iSheetIndex null{
  407.         if (!is_null($this->getSheetByName($pSheet->getTitle()))) {
  408.             throw new Exception("Workbook already contains a worksheet named '{$pSheet->getTitle()}'. Rename the external sheet first.");
  409.         }
  410.  
  411.         // count how many cellXfs there are in this workbook currently, we will need this below
  412.         $countCellXfs count($this->_cellXfCollection);
  413.  
  414.         // copy all the shared cellXfs from the external workbook and append them to the current
  415.         foreach ($pSheet->getParent()->getCellXfCollection(as $cellXf{
  416.             $this->addCellXf(clone $cellXf);
  417.         }
  418.  
  419.         // move sheet to this workbook
  420.         $pSheet->rebindParent($this);
  421.  
  422.         // update the cellXfs
  423.         foreach ($pSheet->getCellCollection(falseas $cell{
  424.             $cell->setXfIndex$cell->getXfIndex($countCellXfs );
  425.         }
  426.  
  427.         return $this->addSheet($pSheet$iSheetIndex);
  428.     }
  429.  
  430.     /**
  431.      * Get named ranges
  432.      *
  433.      * @return PHPExcel_NamedRange[] 
  434.      */
  435.     public function getNamedRanges({
  436.         return $this->_namedRanges;
  437.     }
  438.  
  439.     /**
  440.      * Add named range
  441.      *
  442.      * @param PHPExcel_NamedRange $namedRange 
  443.      * @return PHPExcel 
  444.      */
  445.     public function addNamedRange(PHPExcel_NamedRange $namedRange{
  446.         $this->_namedRanges[$namedRange->getWorksheet()->getTitle().'!'.$namedRange->getName()$namedRange;
  447.         return true;
  448.     }
  449.  
  450.     /**
  451.      * Get named range
  452.      *
  453.      * @param string $namedRange 
  454.      */
  455.     public function getNamedRange($namedRangePHPExcel_Worksheet $pSheet null{
  456.         if ($namedRange != '' && !is_null($namedRange)) {
  457.             if (!is_null($pSheet)) {
  458.                 $key $pSheet->getTitle().'!'.$namedRange;
  459.                 if (isset($this->_namedRanges[$key])) {
  460.                     return $this->_namedRanges[$key];
  461.                 }
  462.             }
  463.             $returnCount 0;
  464.             foreach($this->_namedRanges as $_namedRange{
  465.                 if ($_namedRange->getName(== $namedRange{
  466.                     if ((!is_null($pSheet)) && ($_namedRange->getWorksheet()->getTitle(== $pSheet->getTitle())) {
  467.                         return $_namedRange;
  468.                     else {
  469.                         $returnCount++;
  470.                         $returnValue $_namedRange;
  471.                     }
  472.                 }
  473.             }
  474.             if ($returnCount == 1{
  475.                 return $returnValue;
  476.             }
  477.         }
  478.  
  479.         return null;
  480.     }
  481.  
  482.     /**
  483.      * Remove named range
  484.      *
  485.      * @param string $namedRange 
  486.      * @return PHPExcel 
  487.      */
  488.     public function removeNamedRange($namedRangePHPExcel_Worksheet $pSheet null{
  489.         if ($namedRange != '' && !is_null($namedRange)) {
  490.             if (!is_null($pSheet)) {
  491.                 $key $pSheet->getTitle().'!'.$namedRange;
  492.                 if (isset($this->_namedRanges[$key])) {
  493.                     unset($this->_namedRanges[$key]);
  494.                 }
  495.             }
  496.             foreach($this->_namedRanges as $_namedRange{
  497.                 if ($_namedRange->getName(== $namedRange{
  498.                     if ((!is_null($pSheet)) && ($_namedRange->getWorksheet()->getTitle(== $pSheet->getTitle())) {
  499.                         $key $pSheet->getTitle().'!'.$namedRange;
  500.                         if (isset($this->_namedRanges[$key])) {
  501.                             unset($this->_namedRanges[$key]);
  502.                         }
  503.                     }
  504.                 }
  505.             }
  506.         }
  507.         return $this;
  508.     }
  509.  
  510.     /**
  511.      * Get worksheet iterator
  512.      *
  513.      * @return PHPExcel_WorksheetIterator 
  514.      */
  515.     public function getWorksheetIterator({
  516.         return new PHPExcel_WorksheetIterator($this);
  517.     }
  518.  
  519.     /**
  520.      * Copy workbook (!= clone!)
  521.      *
  522.      * @return PHPExcel 
  523.      */
  524.     public function copy({
  525.         $copied clone $this;
  526.  
  527.         $worksheetCount count($this->_workSheetCollection);
  528.         for ($i 0$i $worksheetCount++$i{
  529.             $this->_workSheetCollection[$i$this->_workSheetCollection[$i]->copy();
  530.             $this->_workSheetCollection[$i]->rebindParent($this);
  531.         }
  532.  
  533.         return $copied;
  534.     }
  535.  
  536.     /**
  537.      * Implement PHP __clone to create a deep clone, not just a shallow copy.
  538.      */
  539.     public function __clone({
  540.         foreach($this as $key => $val{
  541.             if (is_object($val|| (is_array($val))) {
  542.                 $this->{$keyunserialize(serialize($val));
  543.             }
  544.         }
  545.     }
  546.  
  547.     /**
  548.      * Get the workbook collection of cellXfs
  549.      *
  550.      * @return PHPExcel_Style[] 
  551.      */
  552.     public function getCellXfCollection()
  553.     {
  554.         return $this->_cellXfCollection;
  555.     }
  556.  
  557.     /**
  558.      * Get cellXf by index
  559.      *
  560.      * @param int $index 
  561.      * @return PHPExcel_Style 
  562.      */
  563.     public function getCellXfByIndex($pIndex 0)
  564.     {
  565.         return $this->_cellXfCollection[$pIndex];
  566.     }
  567.  
  568.     /**
  569.      * Get cellXf by hash code
  570.      *
  571.      * @param string $pValue 
  572.      * @return PHPExcel_Style|false
  573.      */
  574.     public function getCellXfByHashCode($pValue '')
  575.     {
  576.         foreach ($this->_cellXfCollection as $cellXf{
  577.             if ($cellXf->getHashCode(== $pValue{
  578.                 return $cellXf;
  579.             }
  580.         }
  581.         return false;
  582.     }
  583.  
  584.     /**
  585.      * Get default style
  586.      *
  587.      * @return PHPExcel_Style 
  588.      * @throws Exception
  589.      */
  590.     public function getDefaultStyle()
  591.     {
  592.         if (isset($this->_cellXfCollection[0])) {
  593.             return $this->_cellXfCollection[0];
  594.         }
  595.         throw new Exception('No default style found for this workbook');
  596.     }
  597.  
  598.     /**
  599.      * Add a cellXf to the workbook
  600.      *
  601.      * @param PHPExcel_Style 
  602.      */
  603.     public function addCellXf(PHPExcel_Style $style)
  604.     {
  605.         $this->_cellXfCollection[$style;
  606.         $style->setIndex(count($this->_cellXfCollection1);
  607.     }
  608.  
  609.     /**
  610.      * Remove cellXf by index. It is ensured that all cells get their xf index updated.
  611.      *
  612.      * @param int $pIndex Index to cellXf
  613.      * @throws Exception
  614.      */
  615.     public function removeCellXfByIndex($pIndex 0)
  616.     {
  617.         if ($pIndex count($this->_cellXfCollection1{
  618.             throw new Exception("CellXf index is out of bounds.");
  619.         else {
  620.             // first remove the cellXf
  621.             array_splice($this->_cellXfCollection$pIndex1);
  622.  
  623.             // then update cellXf indexes for cells
  624.             foreach ($this->_workSheetCollection as $worksheet{
  625.                 foreach ($worksheet->getCellCollection(falseas $cell{
  626.                     $xfIndex $cell->getXfIndex();
  627.                     if ($xfIndex $pIndex {
  628.                         // decrease xf index by 1
  629.                         $cell->setXfIndex($xfIndex 1);
  630.                     else if ($xfIndex == $pIndex{
  631.                         // set to default xf index 0
  632.                         $cell->setXfIndex(0);
  633.                     }
  634.                 }
  635.             }
  636.         }
  637.     }
  638.  
  639.     /**
  640.      * Get the cellXf supervisor
  641.      *
  642.      * @return PHPExcel_Style 
  643.      */
  644.     public function getCellXfSupervisor()
  645.     {
  646.         return $this->_cellXfSupervisor;
  647.     }
  648.  
  649.     /**
  650.      * Get the workbook collection of cellStyleXfs
  651.      *
  652.      * @return PHPExcel_Style[] 
  653.      */
  654.     public function getCellStyleXfCollection()
  655.     {
  656.         return $this->_cellStyleXfCollection;
  657.     }
  658.  
  659.     /**
  660.      * Get cellStyleXf by index
  661.      *
  662.      * @param int $pIndex 
  663.      * @return PHPExcel_Style 
  664.      */
  665.     public function getCellStyleXfByIndex($pIndex 0)
  666.     {
  667.         return $this->_cellStyleXfCollection[$pIndex];
  668.     }
  669.  
  670.     /**
  671.      * Get cellStyleXf by hash code
  672.      *
  673.      * @param string $pValue 
  674.      * @return PHPExcel_Style|false
  675.      */
  676.     public function getCellStyleXfByHashCode($pValue '')
  677.     {
  678.         foreach ($this->_cellXfStyleCollection as $cellStyleXf{
  679.             if ($cellStyleXf->getHashCode(== $pValue{
  680.                 return $cellStyleXf;
  681.             }
  682.         }
  683.         return false;
  684.     }
  685.  
  686.     /**
  687.      * Add a cellStyleXf to the workbook
  688.      *
  689.      * @param PHPExcel_Style $pStyle 
  690.      */
  691.     public function addCellStyleXf(PHPExcel_Style $pStyle)
  692.     {
  693.         $this->_cellStyleXfCollection[$pStyle;
  694.         $pStyle->setIndex(count($this->_cellStyleXfCollection1);
  695.     }
  696.  
  697.     /**
  698.      * Remove cellStyleXf by index
  699.      *
  700.      * @param int $pIndex 
  701.      * @throws Exception
  702.      */
  703.     public function removeCellStyleXfByIndex($pIndex 0)
  704.     {
  705.         if ($pIndex count($this->_cellStyleXfCollection1{
  706.             throw new Exception("CellStyleXf index is out of bounds.");
  707.         else {
  708.             array_splice($this->_cellStyleXfCollection$pIndex1);
  709.         }
  710.     }
  711.  
  712.     /**
  713.      * Eliminate all unneeded cellXf and afterwards update the xfIndex for all cells
  714.      * and columns in the workbook
  715.      */
  716.     public function garbageCollect()
  717.     {
  718.         // how many references are there to each cellXf ?
  719.         $countReferencesCellXf array();
  720.         foreach ($this->_cellXfCollection as $index => $cellXf{
  721.             $countReferencesCellXf[$index0;
  722.         }
  723.  
  724.         foreach ($this->getWorksheetIterator(as $sheet{
  725.  
  726.             // from cells
  727.             foreach ($sheet->getCellCollection(falseas $cell{
  728.                 ++$countReferencesCellXf[$cell->getXfIndex()];
  729.             }
  730.  
  731.             // from row dimensions
  732.             foreach ($sheet->getRowDimensions(as $rowDimension{
  733.                 if ($rowDimension->getXfIndex(!== null{
  734.                     ++$countReferencesCellXf[$rowDimension->getXfIndex()];
  735.                 }
  736.             }
  737.  
  738.             // from column dimensions
  739.             foreach ($sheet->getColumnDimensions(as $columnDimension{
  740.                 ++$countReferencesCellXf[$columnDimension->getXfIndex()];
  741.             }
  742.         }
  743.  
  744.         // remove cellXfs without references and create mapping so we can update xfIndex
  745.         // for all cells and columns
  746.         $countNeededCellXfs 0;
  747.         foreach ($this->_cellXfCollection as $index => $cellXf{
  748.             if ($countReferencesCellXf[$index|| $index == 0// we must never remove the first cellXf
  749.                 ++$countNeededCellXfs;
  750.             else {
  751.                 unset($this->_cellXfCollection[$index]);
  752.             }
  753.             $map[$index$countNeededCellXfs 1;
  754.         }
  755.         $this->_cellXfCollection array_values($this->_cellXfCollection);
  756.  
  757.         // update the index for all cellXfs
  758.         foreach ($this->_cellXfCollection as $i => $cellXf{
  759.             echo $cellXf->setIndex($i);
  760.         }
  761.  
  762.         // make sure there is always at least one cellXf (there should be)
  763.         if (count($this->_cellXfCollection== 0{
  764.             $this->_cellXfCollection[new PHPExcel_Style();
  765.         }
  766.  
  767.         // update the xfIndex for all cells, row dimensions, column dimensions
  768.         foreach ($this->getWorksheetIterator(as $sheet{
  769.  
  770.             // for all cells
  771.             foreach ($sheet->getCellCollection(falseas $cell{
  772.                 $cell->setXfIndex$map[$cell->getXfIndex());
  773.             }
  774.  
  775.             // for all row dimensions
  776.             foreach ($sheet->getRowDimensions(as $rowDimension{
  777.                 if ($rowDimension->getXfIndex(!== null{
  778.                     $rowDimension->setXfIndex$map[$rowDimension->getXfIndex());
  779.                 }
  780.             }
  781.  
  782.             // for all column dimensions
  783.             foreach ($sheet->getColumnDimensions(as $columnDimension{
  784.                 $columnDimension->setXfIndex$map[$columnDimension->getXfIndex());
  785.             }
  786.         }
  787.  
  788.         // also do garbage collection for all the sheets
  789.         foreach ($this->getWorksheetIterator(as $sheet{
  790.             $sheet->garbageCollect();
  791.         }
  792.     }
  793.  
  794. }

Documentation generated on Mon, 11 Jan 2010 08:12:56 +0100 by phpDocumentor 1.4.1