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

Source for file Worksheet.php

Documentation is available at Worksheet.php

  1. <?php
  2. /**
  3.  * PHPExcel
  4.  *
  5.  * Copyright (c) 2006 - 2009 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_Excel2007
  23.  * @copyright  Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
  24.  * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt    LGPL
  25.  * @version    1.7.0, 2009-08-10
  26.  */
  27.  
  28.  
  29. /** PHPExcel root directory */
  30. if (!defined('PHPEXCEL_ROOT')) {
  31.     /**
  32.      * @ignore
  33.      */
  34.     define('PHPEXCEL_ROOT'dirname(__FILE__'/../../../');
  35. }
  36.  
  37. /** PHPExcel_Writer_Excel2007 */
  38. require_once PHPEXCEL_ROOT 'PHPExcel/Writer/Excel2007.php';
  39.  
  40. /** PHPExcel_Writer_Excel2007_WriterPart */
  41. require_once PHPEXCEL_ROOT 'PHPExcel/Writer/Excel2007/WriterPart.php';
  42.  
  43. /** PHPExcel_Cell */
  44. require_once PHPEXCEL_ROOT 'PHPExcel/Cell.php';
  45.  
  46. /** PHPExcel_Worksheet */
  47. require_once PHPEXCEL_ROOT 'PHPExcel/Worksheet.php';
  48.  
  49. /** PHPExcel_Style_Conditional */
  50. require_once PHPEXCEL_ROOT 'PHPExcel/Style/Conditional.php';
  51.  
  52. /** PHPExcel_Style_NumberFormat */
  53. require_once PHPEXCEL_ROOT 'PHPExcel/Style/NumberFormat.php';
  54.  
  55. /** PHPExcel_Shared_Font */
  56. require_once PHPEXCEL_ROOT 'PHPExcel/Shared/Font.php';
  57.  
  58. /** PHPExcel_Shared_Date */
  59. require_once PHPEXCEL_ROOT 'PHPExcel/Shared/Date.php';
  60.  
  61. /** PHPExcel_Shared_String */
  62. require_once PHPEXCEL_ROOT 'PHPExcel/Shared/String.php';
  63.  
  64. /** PHPExcel_RichText */
  65. require_once PHPEXCEL_ROOT 'PHPExcel/RichText.php';
  66.  
  67. /** PHPExcel_Shared_XMLWriter */
  68. require_once PHPEXCEL_ROOT 'PHPExcel/Shared/XMLWriter.php';
  69.  
  70.  
  71. /**
  72.  * PHPExcel_Writer_Excel2007_Worksheet
  73.  *
  74.  * @category   PHPExcel
  75.  * @package    PHPExcel_Writer_Excel2007
  76.  * @copyright  Copyright (c) 2006 - 2009 PHPExcel (http://www.codeplex.com/PHPExcel)
  77.  */
  78. {
  79.     /**
  80.      * Write worksheet to XML format
  81.      *
  82.      * @param    PHPExcel_Worksheet        $pSheet 
  83.      * @param    string[]                $pStringTable 
  84.      * @return    string                    XML Output
  85.      * @throws    Exception
  86.      */
  87.     public function writeWorksheet($pSheet null$pStringTable null)
  88.     {
  89.         if (!is_null($pSheet)) {
  90.             // Create XML writer
  91.             $objWriter null;
  92.             if ($this->getParentWriter()->getUseDiskCaching()) {
  93.                 $objWriter new PHPExcel_Shared_XMLWriter(PHPExcel_Shared_XMLWriter::STORAGE_DISK$this->getParentWriter()->getDiskCachingDirectory());
  94.             else {
  95.                 $objWriter new PHPExcel_Shared_XMLWriter(PHPExcel_Shared_XMLWriter::STORAGE_MEMORY);
  96.             }
  97.  
  98.             // XML header
  99.             $objWriter->startDocument('1.0','UTF-8','yes');
  100.  
  101.             // Worksheet
  102.             $objWriter->startElement('worksheet');
  103.             $objWriter->writeAttribute('xml:space''preserve');
  104.             $objWriter->writeAttribute('xmlns''http://schemas.openxmlformats.org/spreadsheetml/2006/main');
  105.             $objWriter->writeAttribute('xmlns:r''http://schemas.openxmlformats.org/officeDocument/2006/relationships');
  106.  
  107.                 // sheetPr
  108.                 $this->_writeSheetPr($objWriter$pSheet);
  109.  
  110.                 // Dimension
  111.                 $this->_writeDimension($objWriter$pSheet);
  112.  
  113.                 // sheetViews
  114.                 $this->_writeSheetViews($objWriter$pSheet);
  115.  
  116.                 // sheetFormatPr
  117.                 $this->_writeSheetFormatPr($objWriter$pSheet);
  118.  
  119.                 // cols
  120.                 $this->_writeCols($objWriter$pSheet);
  121.  
  122.                 // sheetData
  123.                 $this->_writeSheetData($objWriter$pSheet$pStringTable);
  124.  
  125.                 // sheetProtection
  126.                 $this->_writeSheetProtection($objWriter$pSheet);
  127.  
  128.                 // protectedRanges
  129.                 $this->_writeProtectedRanges($objWriter$pSheet);
  130.  
  131.                 // autoFilter
  132.                 $this->_writeAutoFilter($objWriter$pSheet);
  133.  
  134.                 // mergeCells
  135.                 $this->_writeMergeCells($objWriter$pSheet);
  136.  
  137.                 // conditionalFormatting
  138.                 $this->_writeConditionalFormatting($objWriter$pSheet);
  139.  
  140.                 // dataValidations
  141.                 $this->_writeDataValidations($objWriter$pSheet);
  142.  
  143.                 // hyperlinks
  144.                 $this->_writeHyperlinks($objWriter$pSheet);
  145.  
  146.                 // Print options
  147.                 $this->_writePrintOptions($objWriter$pSheet);
  148.  
  149.                 // Page margins
  150.                 $this->_writePageMargins($objWriter$pSheet);
  151.  
  152.                 // Page setup
  153.                 $this->_writePageSetup($objWriter$pSheet);
  154.  
  155.                 // Header / footer
  156.                 $this->_writeHeaderFooter($objWriter$pSheet);
  157.  
  158.                 // Breaks
  159.                 $this->_writeBreaks($objWriter$pSheet);
  160.  
  161.                 // Drawings
  162.                 $this->_writeDrawings($objWriter$pSheet);
  163.  
  164.                 // LegacyDrawing
  165.                 $this->_writeLegacyDrawing($objWriter$pSheet);
  166.  
  167.                 // LegacyDrawingHF
  168.                 $this->_writeLegacyDrawingHF($objWriter$pSheet);
  169.  
  170.             $objWriter->endElement();
  171.  
  172.             // Return
  173.             return $objWriter->getData();
  174.         else {
  175.             throw new Exception("Invalid PHPExcel_Worksheet object passed.");
  176.         }
  177.     }
  178.  
  179.     /**
  180.      * Write SheetPr
  181.      *
  182.      * @param    PHPExcel_Shared_XMLWriter        $objWriter        XML Writer
  183.      * @param    PHPExcel_Worksheet                $pSheet            Worksheet
  184.      * @throws    Exception
  185.      */
  186.     private function _writeSheetPr(PHPExcel_Shared_XMLWriter $objWriter nullPHPExcel_Worksheet $pSheet null)
  187.     {
  188.         // sheetPr
  189.         $objWriter->startElement('sheetPr');
  190.         //$objWriter->writeAttribute('codeName',        $pSheet->getTitle());
  191.  
  192.             // outlinePr
  193.             $objWriter->startElement('outlinePr');
  194.             $objWriter->writeAttribute('summaryBelow',    ($pSheet->getShowSummaryBelow('1' '0'));
  195.             $objWriter->writeAttribute('summaryRight',    ($pSheet->getShowSummaryRight('1' '0'));
  196.             $objWriter->endElement();
  197.  
  198.             // pageSetUpPr
  199.             if (!is_null($pSheet->getPageSetup()->getFitToHeight()) || !is_null($pSheet->getPageSetup()->getFitToWidth())) {
  200.                 $objWriter->startElement('pageSetUpPr');
  201.                 $objWriter->writeAttribute('fitToPage',    '1');
  202.                 $objWriter->endElement();
  203.             }
  204.  
  205.         $objWriter->endElement();
  206.     }
  207.  
  208.     /**
  209.      * Write Dimension
  210.      *
  211.      * @param    PHPExcel_Shared_XMLWriter    $objWriter        XML Writer
  212.      * @param    PHPExcel_Worksheet            $pSheet            Worksheet
  213.      * @throws    Exception
  214.      */
  215.     private function _writeDimension(PHPExcel_Shared_XMLWriter $objWriter nullPHPExcel_Worksheet $pSheet null)
  216.     {
  217.         // dimension
  218.         $objWriter->startElement('dimension');
  219.         $objWriter->writeAttribute('ref'$pSheet->calculateWorksheetDimension());
  220.         $objWriter->endElement();
  221.     }
  222.  
  223.     /**
  224.      * Write SheetViews
  225.      *
  226.      * @param    PHPExcel_Shared_XMLWriter            $objWriter        XML Writer
  227.      * @param    PHPExcel_Worksheet                    $pSheet            Worksheet
  228.      * @throws    Exception
  229.      */
  230.     private function _writeSheetViews(PHPExcel_Shared_XMLWriter $objWriter nullPHPExcel_Worksheet $pSheet null)
  231.     {
  232.         // sheetViews
  233.         $objWriter->startElement('sheetViews');
  234.  
  235.             // Sheet selected?
  236.             $sheetSelected false;
  237.             if ($this->getParentWriter()->getPHPExcel()->getIndex($pSheet== $this->getParentWriter()->getPHPExcel()->getActiveSheetIndex())
  238.                 $sheetSelected true;
  239.             
  240.         
  241.             // sheetView
  242.             $objWriter->startElement('sheetView');
  243.             $objWriter->writeAttribute('tabSelected',        $sheetSelected '1' '0');
  244.             $objWriter->writeAttribute('workbookViewId',    '0');
  245.             
  246.                 // Zoom scales
  247.                 if ($pSheet->getSheetView()->getZoomScale(!= 100{
  248.                     $objWriter->writeAttribute('zoomScale',    $pSheet->getSheetView()->getZoomScale());
  249.                 }
  250.                 if ($pSheet->getSheetView()->getZoomScaleNormal(!= 100{
  251.                     $objWriter->writeAttribute('zoomScaleNormal',    $pSheet->getSheetView()->getZoomScaleNormal());
  252.                 }
  253.  
  254.                 // Gridlines
  255.                 if ($pSheet->getShowGridlines()) {
  256.                     $objWriter->writeAttribute('showGridLines',    'true');
  257.                 else {
  258.                     $objWriter->writeAttribute('showGridLines',    'false');
  259.                 }
  260.                 
  261.                 // Right-to-left
  262.                 if ($pSheet->getRightToLeft()) {
  263.                     $objWriter->writeAttribute('rightToLeft',    'true');
  264.                 }
  265.  
  266.                 // Pane
  267.                 if ($pSheet->getFreezePane(!= ''{
  268.                     // Calculate freeze coordinates
  269.                     $xSplit 0;
  270.                     $ySplit 0;
  271.                     $topLeftCell $pSheet->getFreezePane();
  272.  
  273.                     list($xSplit$ySplitPHPExcel_Cell::coordinateFromString($pSheet->getFreezePane());
  274.                     $xSplit PHPExcel_Cell::columnIndexFromString($xSplit);
  275.  
  276.                     // pane
  277.                     $objWriter->startElement('pane');
  278.                     $objWriter->writeAttribute('xSplit',        $xSplit 1);
  279.                     $objWriter->writeAttribute('ySplit',        $ySplit 1);
  280.                     $objWriter->writeAttribute('topLeftCell',    $topLeftCell);
  281.                     $objWriter->writeAttribute('activePane',    'bottomRight');
  282.                     $objWriter->writeAttribute('state',        'frozen');
  283.                     $objWriter->endElement();
  284.                 }
  285.  
  286.                 // Selection
  287.                 $objWriter->startElement('selection');
  288.                 $objWriter->writeAttribute('activeCell'$pSheet->getSelectedCell());
  289.                 $objWriter->writeAttribute('sqref',      $pSheet->getSelectedCell());
  290.                 $objWriter->endElement();
  291.  
  292.             $objWriter->endElement();
  293.  
  294.         $objWriter->endElement();
  295.     }
  296.  
  297.     /**
  298.      * Write SheetFormatPr
  299.      *
  300.      * @param    PHPExcel_Shared_XMLWriter $objWriter        XML Writer
  301.      * @param    PHPExcel_Worksheet          $pSheet            Worksheet
  302.      * @throws    Exception
  303.      */
  304.     private function _writeSheetFormatPr(PHPExcel_Shared_XMLWriter $objWriter nullPHPExcel_Worksheet $pSheet null)
  305.     {
  306.         // sheetFormatPr
  307.         $objWriter->startElement('sheetFormatPr');
  308.  
  309.             // Default row height
  310.             if ($pSheet->getDefaultRowDimension()->getRowHeight(>= 0{
  311.                 $objWriter->writeAttribute('customHeight',        'true');
  312.                 $objWriter->writeAttribute('defaultRowHeight',     PHPExcel_Shared_String::FormatNumber($pSheet->getDefaultRowDimension()->getRowHeight()));
  313.             else {
  314.                 $objWriter->writeAttribute('defaultRowHeight',     '12.75');
  315.             }
  316.  
  317.             // Default column width
  318.             if ($pSheet->getDefaultColumnDimension()->getWidth(>= 0{
  319.                 $objWriter->writeAttribute('defaultColWidth',     PHPExcel_Shared_String::FormatNumber($pSheet->getDefaultColumnDimension()->getWidth()));
  320.             }
  321.  
  322.             // Outline level - row
  323.             $outlineLevelRow 0;
  324.             foreach ($pSheet->getRowDimensions(as $dimension{
  325.                 if ($dimension->getOutlineLevel($outlineLevelRow{
  326.                     $outlineLevelRow $dimension->getOutlineLevel();
  327.                 }
  328.             }
  329.             $objWriter->writeAttribute('outlineLevelRow',         (int)$outlineLevelRow);
  330.  
  331.             // Outline level - column
  332.             $outlineLevelCol 0;
  333.             foreach ($pSheet->getColumnDimensions(as $dimension{
  334.                 if ($dimension->getOutlineLevel($outlineLevelCol{
  335.                     $outlineLevelCol $dimension->getOutlineLevel();
  336.                 }
  337.             }
  338.             $objWriter->writeAttribute('outlineLevelCol',         (int)$outlineLevelCol);
  339.  
  340.         $objWriter->endElement();
  341.     }
  342.  
  343.     /**
  344.      * Write Cols
  345.      *
  346.      * @param    PHPExcel_Shared_XMLWriter            $objWriter        XML Writer
  347.      * @param    PHPExcel_Worksheet                    $pSheet            Worksheet
  348.      * @throws    Exception
  349.      */
  350.     private function _writeCols(PHPExcel_Shared_XMLWriter $objWriter nullPHPExcel_Worksheet $pSheet null)
  351.     {
  352.         // cols
  353.         $objWriter->startElement('cols');
  354.  
  355.             // Check if there is at least one column dimension specified. If not, create one.
  356.             if (count($pSheet->getColumnDimensions()) == 0{
  357.                 if ($pSheet->getDefaultColumnDimension()->getWidth(>= 0{
  358.                     $pSheet->getColumnDimension('A')->setWidth($pSheet->getDefaultColumnDimension()->getWidth());
  359.                 else {
  360.                     $pSheet->getColumnDimension('A')->setWidth(9.10);
  361.                 }
  362.             }
  363.  
  364.             $pSheet->calculateColumnWidths();
  365.  
  366.             // Loop trough column dimensions
  367.             foreach ($pSheet->getColumnDimensions(as $colDimension{
  368.                 // col
  369.                 $objWriter->startElement('col');
  370.                 $objWriter->writeAttribute('min',    PHPExcel_Cell::columnIndexFromString($colDimension->getColumnIndex()));
  371.                 $objWriter->writeAttribute('max',    PHPExcel_Cell::columnIndexFromString($colDimension->getColumnIndex()));
  372.  
  373.                 if ($colDimension->getWidth(0{
  374.                     // No width set, apply default of 10
  375.                     $objWriter->writeAttribute('width',        '9.10');
  376.                 else {
  377.                     // Width set
  378.                     $objWriter->writeAttribute('width',        PHPExcel_Shared_String::FormatNumber($colDimension->getWidth()));
  379.                 }
  380.  
  381.                 // Column visibility
  382.                 if ($colDimension->getVisible(== false{
  383.                     $objWriter->writeAttribute('hidden',        'true');
  384.                 }
  385.  
  386.                 // Auto size?
  387.                 if ($colDimension->getAutoSize()) {
  388.                     $objWriter->writeAttribute('bestFit',        'true');
  389.                 }
  390.  
  391.                 // Custom width?
  392.                 if ($colDimension->getWidth(!= $pSheet->getDefaultColumnDimension()->getWidth()) {
  393.                     $objWriter->writeAttribute('customWidth',    'true');
  394.                 }
  395.  
  396.                 // Collapsed
  397.                 if ($colDimension->getCollapsed(== true{
  398.                     $objWriter->writeAttribute('collapsed',        'true');
  399.                 }
  400.  
  401.                 // Outline level
  402.                 if ($colDimension->getOutlineLevel(0{
  403.                     $objWriter->writeAttribute('outlineLevel',    $colDimension->getOutlineLevel());
  404.                 }
  405.  
  406.                 // Style
  407.                 $objWriter->writeAttribute('style'0);
  408.  
  409.                 $objWriter->endElement();
  410.             }
  411.  
  412.         $objWriter->endElement();
  413.     }
  414.  
  415.     /**
  416.      * Write SheetProtection
  417.      *
  418.      * @param    PHPExcel_Shared_XMLWriter            $objWriter        XML Writer
  419.      * @param    PHPExcel_Worksheet                    $pSheet            Worksheet
  420.      * @throws    Exception
  421.      */
  422.     private function _writeSheetProtection(PHPExcel_Shared_XMLWriter $objWriter nullPHPExcel_Worksheet $pSheet null)
  423.     {
  424.         // sheetProtection
  425.         $objWriter->startElement('sheetProtection');
  426.  
  427.         if ($pSheet->getProtection()->getPassword(!= ''{
  428.             $objWriter->writeAttribute('password',                $pSheet->getProtection()->getPassword());
  429.         }
  430.  
  431.         $objWriter->writeAttribute('sheet',                ($pSheet->getProtection()->getSheet()                'true' 'false'));
  432.         $objWriter->writeAttribute('objects',                ($pSheet->getProtection()->getObjects()            'true' 'false'));
  433.         $objWriter->writeAttribute('scenarios',            ($pSheet->getProtection()->getScenarios()            'true' 'false'));
  434.         $objWriter->writeAttribute('formatCells',            ($pSheet->getProtection()->getFormatCells()        'true' 'false'));
  435.         $objWriter->writeAttribute('formatColumns',        ($pSheet->getProtection()->getFormatColumns()        'true' 'false'));
  436.         $objWriter->writeAttribute('formatRows',            ($pSheet->getProtection()->getFormatRows()            'true' 'false'));
  437.         $objWriter->writeAttribute('insertColumns',        ($pSheet->getProtection()->getInsertColumns()        'true' 'false'));
  438.         $objWriter->writeAttribute('insertRows',            ($pSheet->getProtection()->getInsertRows()            'true' 'false'));
  439.         $objWriter->writeAttribute('insertHyperlinks',        ($pSheet->getProtection()->getInsertHyperlinks()    'true' 'false'));
  440.         $objWriter->writeAttribute('deleteColumns',        ($pSheet->getProtection()->getDeleteColumns()        'true' 'false'));
  441.         $objWriter->writeAttribute('deleteRows',            ($pSheet->getProtection()->getDeleteRows()            'true' 'false'));
  442.         $objWriter->writeAttribute('selectLockedCells',    ($pSheet->getProtection()->getSelectLockedCells()    'true' 'false'));
  443.         $objWriter->writeAttribute('sort',                    ($pSheet->getProtection()->getSort()                'true' 'false'));
  444.         $objWriter->writeAttribute('autoFilter',            ($pSheet->getProtection()->getAutoFilter()            'true' 'false'));
  445.         $objWriter->writeAttribute('pivotTables',            ($pSheet->getProtection()->getPivotTables()        'true' 'false'));
  446.         $objWriter->writeAttribute('selectUnlockedCells',    ($pSheet->getProtection()->getSelectUnlockedCells()    'true' 'false'));
  447.         $objWriter->endElement();
  448.     }
  449.  
  450.     /**
  451.      * Write ConditionalFormatting
  452.      *
  453.      * @param    PHPExcel_Shared_XMLWriter            $objWriter        XML Writer
  454.      * @param    PHPExcel_Worksheet                    $pSheet            Worksheet
  455.      * @throws    Exception
  456.      */
  457.     private function _writeConditionalFormatting(PHPExcel_Shared_XMLWriter $objWriter nullPHPExcel_Worksheet $pSheet null)
  458.     {
  459.         // Conditional id
  460.         $id 1;
  461.  
  462.         // Loop trough styles in the current worksheet
  463.         foreach ($pSheet->getConditionalStylesCollection(as $cellCoordinate => $conditionalStyles{
  464.             foreach ($conditionalStyles as $conditional{
  465.                 // WHY was this again?
  466.                 // if ($this->getParentWriter()->getStylesConditionalHashTable()->getIndexForHashCode( $conditional->getHashCode() ) == '') {
  467.                 //    continue;
  468.                 // }
  469.  
  470.                 if ($conditional->getConditionType(!= PHPExcel_Style_Conditional::CONDITION_NONE{
  471.                     // conditionalFormatting
  472.                     $objWriter->startElement('conditionalFormatting');
  473.                     $objWriter->writeAttribute('sqref',    $cellCoordinate);
  474.  
  475.                         // cfRule
  476.                         $objWriter->startElement('cfRule');
  477.                         $objWriter->writeAttribute('type',        $conditional->getConditionType());
  478.                         $objWriter->writeAttribute('dxfId',        $this->getParentWriter()->getStylesConditionalHashTable()->getIndexForHashCode$conditional->getHashCode() ));
  479.                         $objWriter->writeAttribute('priority',    $id++);
  480.  
  481.                         if (($conditional->getConditionType(== PHPExcel_Style_Conditional::CONDITION_CELLIS
  482.                                 ||
  483.                              $conditional->getConditionType(== PHPExcel_Style_Conditional::CONDITION_CONTAINSTEXT)
  484.                             && $conditional->getOperatorType(!= PHPExcel_Style_Conditional::OPERATOR_NONE{
  485.                             $objWriter->writeAttribute('operator',    $conditional->getOperatorType());
  486.                         }
  487.                         
  488.                         if ($conditional->getConditionType(== PHPExcel_Style_Conditional::CONDITION_CONTAINSTEXT
  489.                             && !is_null($conditional->getText())) {
  490.                             $objWriter->writeAttribute('text',    $conditional->getText());
  491.                         }
  492.  
  493.                         if ($conditional->getConditionType(== PHPExcel_Style_Conditional::CONDITION_CELLIS
  494.                             || $conditional->getConditionType(== PHPExcel_Style_Conditional::CONDITION_CONTAINSTEXT
  495.                             || $conditional->getConditionType(== PHPExcel_Style_Conditional::CONDITION_EXPRESSION{
  496.                             foreach ($conditional->getConditions(as $formula{
  497.                                 // Formula
  498.                                 $objWriter->writeElement('formula',    $formula);
  499.                             }
  500.                         }
  501.  
  502.                         $objWriter->endElement();
  503.  
  504.                     $objWriter->endElement();
  505.                 }
  506.             }
  507.         }
  508.     }
  509.  
  510.     /**
  511.      * Write DataValidations
  512.      *
  513.      * @param    PHPExcel_Shared_XMLWriter            $objWriter        XML Writer
  514.      * @param    PHPExcel_Worksheet                    $pSheet            Worksheet
  515.      * @throws    Exception
  516.      */
  517.     private function _writeDataValidations(PHPExcel_Shared_XMLWriter $objWriter nullPHPExcel_Worksheet $pSheet null)
  518.     {
  519.         // Build a temporary array of datavalidation objects
  520.         $aDataValidations array();
  521.         foreach ($pSheet->getCellCollection(as $cell{
  522.             if ($cell->hasDataValidation()) {
  523.                 $aDataValidations[$cell->getDataValidation();
  524.             }
  525.         }
  526.  
  527.         // Write data validations?
  528.         if (count($aDataValidations0{
  529.             $objWriter->startElement('dataValidations');
  530.             $objWriter->writeAttribute('count',    count($aDataValidations));
  531.  
  532.             foreach ($aDataValidations as $dv{
  533.                 $objWriter->startElement('dataValidation');
  534.  
  535.                 if ($dv->getType(!= ''{
  536.                     $objWriter->writeAttribute('type'$dv->getType());
  537.                 }
  538.  
  539.                 if ($dv->getErrorStyle(!= ''{
  540.                     $objWriter->writeAttribute('errorStyle'$dv->getErrorStyle());
  541.                 }
  542.  
  543.                 if ($dv->getOperator(!= ''{
  544.                     $objWriter->writeAttribute('operator'$dv->getOperator());
  545.                 }
  546.  
  547.                 $objWriter->writeAttribute('allowBlank',        ($dv->getAllowBlank()        '1'  '0'));
  548.                 $objWriter->writeAttribute('showDropDown',        (!$dv->getShowDropDown()    '1'  '0'));
  549.                 $objWriter->writeAttribute('showInputMessage',    ($dv->getShowInputMessage()    '1'  '0'));
  550.                 $objWriter->writeAttribute('showErrorMessage',    ($dv->getShowErrorMessage()    '1'  '0'));
  551.  
  552.                 if ($dv->getErrorTitle(!== ''{
  553.                     $objWriter->writeAttribute('errorTitle'$dv->getErrorTitle());
  554.                 }
  555.                 if ($dv->getError(!== ''{
  556.                     $objWriter->writeAttribute('error'$dv->getError());
  557.                 }
  558.                 if ($dv->getPromptTitle(!== ''{
  559.                     $objWriter->writeAttribute('promptTitle'$dv->getPromptTitle());
  560.                 }
  561.                 if ($dv->getPrompt(!== ''{
  562.                     $objWriter->writeAttribute('prompt'$dv->getPrompt());
  563.                 }
  564.  
  565.                 $objWriter->writeAttribute('sqref'$dv->getParent()->getCoordinate());
  566.  
  567.                 if ($dv->getFormula1(!== ''{
  568.                     $objWriter->writeElement('formula1'$dv->getFormula1());
  569.                 }
  570.                 if ($dv->getFormula2(!== ''{
  571.                     $objWriter->writeElement('formula2'$dv->getFormula2());
  572.                 }
  573.  
  574.                 $objWriter->endElement();
  575.             }
  576.  
  577.             $objWriter->endElement();
  578.         }
  579.     }
  580.  
  581.     /**
  582.      * Write Hyperlinks
  583.      *
  584.      * @param    PHPExcel_Shared_XMLWriter            $objWriter        XML Writer
  585.      * @param    PHPExcel_Worksheet                    $pSheet            Worksheet
  586.      * @throws    Exception
  587.      */
  588.     private function _writeHyperlinks(PHPExcel_Shared_XMLWriter $objWriter nullPHPExcel_Worksheet $pSheet null)
  589.     {
  590.         // Build a temporary array of hyperlink objects
  591.         $aHyperlinks array();
  592.         foreach ($pSheet->getCellCollection(as $cell{
  593.             if ($cell->hasHyperlink()) {
  594.                 $aHyperlinks[$cell->getHyperlink();
  595.             }
  596.         }
  597.  
  598.         // Relation ID
  599.         $relationId 1;
  600.  
  601.         // Write hyperlinks?
  602.         if (count($aHyperlinks0{
  603.             $objWriter->startElement('hyperlinks');
  604.  
  605.             foreach ($aHyperlinks as $hyperlink{
  606.                 $objWriter->startElement('hyperlink');
  607.  
  608.                 $objWriter->writeAttribute('ref',    $hyperlink->getParent()->getCoordinate());
  609.                 if (!$hyperlink->isInternal()) {
  610.                     $objWriter->writeAttribute('r:id',    'rId_hyperlink_' $relationId);
  611.                     ++$relationId;
  612.                 else {
  613.                     $objWriter->writeAttribute('location',    str_replace('sheet://'''$hyperlink->getUrl()));
  614.                 }
  615.  
  616.                 if ($hyperlink->getTooltip(!= ''{
  617.                     $objWriter->writeAttribute('tooltip'$hyperlink->getTooltip());
  618.                 }
  619.  
  620.                 $objWriter->endElement();
  621.             }
  622.  
  623.             $objWriter->endElement();
  624.         }
  625.     }
  626.  
  627.     /**
  628.      * Write ProtectedRanges
  629.      *
  630.      * @param    PHPExcel_Shared_XMLWriter            $objWriter        XML Writer
  631.      * @param    PHPExcel_Worksheet                    $pSheet            Worksheet
  632.      * @throws    Exception
  633.      */
  634.     private function _writeProtectedRanges(PHPExcel_Shared_XMLWriter $objWriter nullPHPExcel_Worksheet $pSheet null)
  635.     {
  636.         if (count($pSheet->getProtectedCells()) 0{
  637.             // protectedRanges
  638.             $objWriter->startElement('protectedRanges');
  639.  
  640.                 // Loop protectedRanges
  641.                 foreach ($pSheet->getProtectedCells(as $protectedCell => $passwordHash{
  642.                     // protectedRange
  643.                     $objWriter->startElement('protectedRange');
  644.                     $objWriter->writeAttribute('name',        'p' md5($protectedCell));
  645.                     $objWriter->writeAttribute('sqref',    $protectedCell);
  646.                     $objWriter->writeAttribute('password',    $passwordHash);
  647.                     $objWriter->endElement();
  648.                 }
  649.  
  650.             $objWriter->endElement();
  651.         }
  652.     }
  653.  
  654.     /**
  655.      * Write MergeCells
  656.      *
  657.      * @param    PHPExcel_Shared_XMLWriter            $objWriter        XML Writer
  658.      * @param    PHPExcel_Worksheet                    $pSheet            Worksheet
  659.      * @throws    Exception
  660.      */
  661.     private function _writeMergeCells(PHPExcel_Shared_XMLWriter $objWriter nullPHPExcel_Worksheet $pSheet null)
  662.     {
  663.         if (count($pSheet->getMergeCells()) 0{
  664.             // mergeCells
  665.             $objWriter->startElement('mergeCells');
  666.  
  667.                 // Loop mergeCells
  668.                 foreach ($pSheet->getMergeCells(as $mergeCell{
  669.                     // mergeCell
  670.                     $objWriter->startElement('mergeCell');
  671.                     $objWriter->writeAttribute('ref'$mergeCell);
  672.                     $objWriter->endElement();
  673.                 }
  674.  
  675.             $objWriter->endElement();
  676.         }
  677.     }
  678.  
  679.     /**
  680.      * Write PrintOptions
  681.      *
  682.      * @param    PHPExcel_Shared_XMLWriter            $objWriter        XML Writer
  683.      * @param    PHPExcel_Worksheet                    $pSheet            Worksheet
  684.      * @throws    Exception
  685.      */
  686.     private function _writePrintOptions(PHPExcel_Shared_XMLWriter $objWriter nullPHPExcel_Worksheet $pSheet null)
  687.     {
  688.         // printOptions
  689.         $objWriter->startElement('printOptions');
  690.  
  691.         $objWriter->writeAttribute('gridLines',    ($pSheet->getPrintGridlines('true''false'));
  692.         $objWriter->writeAttribute('gridLinesSet',    'true');
  693.  
  694.         if ($pSheet->getPageSetup()->getHorizontalCentered()) {
  695.             $objWriter->writeAttribute('horizontalCentered''true');
  696.         }
  697.  
  698.         if ($pSheet->getPageSetup()->getVerticalCentered()) {
  699.             $objWriter->writeAttribute('verticalCentered''true');
  700.         }
  701.  
  702.         $objWriter->endElement();
  703.     }
  704.  
  705.     /**
  706.      * Write PageMargins
  707.      *
  708.      * @param    PHPExcel_Shared_XMLWriter                $objWriter        XML Writer
  709.      * @param    PHPExcel_Worksheet                        $pSheet            Worksheet
  710.      * @throws    Exception
  711.      */
  712.     private function _writePageMargins(PHPExcel_Shared_XMLWriter $objWriter nullPHPExcel_Worksheet $pSheet null)
  713.     {
  714.         // pageMargins
  715.         $objWriter->startElement('pageMargins');
  716.         $objWriter->writeAttribute('left',        PHPExcel_Shared_String::FormatNumber($pSheet->getPageMargins()->getLeft()));
  717.         $objWriter->writeAttribute('right',        PHPExcel_Shared_String::FormatNumber($pSheet->getPageMargins()->getRight()));
  718.         $objWriter->writeAttribute('top',        PHPExcel_Shared_String::FormatNumber($pSheet->getPageMargins()->getTop()));
  719.         $objWriter->writeAttribute('bottom',    PHPExcel_Shared_String::FormatNumber($pSheet->getPageMargins()->getBottom()));
  720.         $objWriter->writeAttribute('header',    PHPExcel_Shared_String::FormatNumber($pSheet->getPageMargins()->getHeader()));
  721.         $objWriter->writeAttribute('footer',    PHPExcel_Shared_String::FormatNumber($pSheet->getPageMargins()->getFooter()));
  722.         $objWriter->endElement();
  723.     }
  724.  
  725.     /**
  726.      * Write AutoFilter
  727.      *
  728.      * @param    PHPExcel_Shared_XMLWriter                $objWriter        XML Writer
  729.      * @param    PHPExcel_Worksheet                        $pSheet            Worksheet
  730.      * @throws    Exception
  731.      */
  732.     private function _writeAutoFilter(PHPExcel_Shared_XMLWriter $objWriter nullPHPExcel_Worksheet $pSheet null)
  733.     {
  734.         if ($pSheet->getAutoFilter(!= ''{
  735.             // autoFilter
  736.             $objWriter->startElement('autoFilter');
  737.             $objWriter->writeAttribute('ref',        $pSheet->getAutoFilter());
  738.             $objWriter->endElement();
  739.         }
  740.     }
  741.  
  742.     /**
  743.      * Write PageSetup
  744.      *
  745.      * @param    PHPExcel_Shared_XMLWriter            $objWriter        XML Writer
  746.      * @param    PHPExcel_Worksheet                    $pSheet            Worksheet
  747.      * @throws    Exception
  748.      */
  749.     private function _writePageSetup(PHPExcel_Shared_XMLWriter $objWriter nullPHPExcel_Worksheet $pSheet null)
  750.     {
  751.         // pageSetup
  752.         $objWriter->startElement('pageSetup');
  753.         $objWriter->writeAttribute('paperSize',        $pSheet->getPageSetup()->getPaperSize());
  754.         $objWriter->writeAttribute('orientation',    $pSheet->getPageSetup()->getOrientation());
  755.  
  756.         if (!is_null($pSheet->getPageSetup()->getScale())) {
  757.             $objWriter->writeAttribute('scale',    $pSheet->getPageSetup()->getScale());
  758.         }
  759.         if (!is_null($pSheet->getPageSetup()->getFitToHeight())) {
  760.             $objWriter->writeAttribute('fitToHeight',    $pSheet->getPageSetup()->getFitToHeight());
  761.         else {
  762.             $objWriter->writeAttribute('fitToHeight',    '0');
  763.         }
  764.         if (!is_null($pSheet->getPageSetup()->getFitToWidth())) {
  765.             $objWriter->writeAttribute('fitToWidth',    $pSheet->getPageSetup()->getFitToWidth());
  766.         else {
  767.             $objWriter->writeAttribute('fitToWidth',    '0');
  768.         }
  769.  
  770.         $objWriter->endElement();
  771.     }
  772.  
  773.     /**
  774.      * Write Header / Footer
  775.      *
  776.      * @param    PHPExcel_Shared_XMLWriter        $objWriter        XML Writer
  777.      * @param    PHPExcel_Worksheet                $pSheet            Worksheet
  778.      * @throws    Exception
  779.      */
  780.     private function _writeHeaderFooter(PHPExcel_Shared_XMLWriter $objWriter nullPHPExcel_Worksheet $pSheet null)
  781.     {
  782.         // headerFooter
  783.         $objWriter->startElement('headerFooter');
  784.         $objWriter->writeAttribute('differentOddEven',    ($pSheet->getHeaderFooter()->getDifferentOddEven('true' 'false'));
  785.         $objWriter->writeAttribute('differentFirst',    ($pSheet->getHeaderFooter()->getDifferentFirst('true' 'false'));
  786.         $objWriter->writeAttribute('scaleWithDoc',        ($pSheet->getHeaderFooter()->getScaleWithDocument('true' 'false'));
  787.         $objWriter->writeAttribute('alignWithMargins',    ($pSheet->getHeaderFooter()->getAlignWithMargins('true' 'false'));
  788.  
  789.             $objWriter->writeElement('oddHeader',        $pSheet->getHeaderFooter()->getOddHeader());
  790.             $objWriter->writeElement('oddFooter',        $pSheet->getHeaderFooter()->getOddFooter());
  791.             $objWriter->writeElement('evenHeader',        $pSheet->getHeaderFooter()->getEvenHeader());
  792.             $objWriter->writeElement('evenFooter',        $pSheet->getHeaderFooter()->getEvenFooter());
  793.             $objWriter->writeElement('firstHeader',    $pSheet->getHeaderFooter()->getFirstHeader());
  794.             $objWriter->writeElement('firstFooter',    $pSheet->getHeaderFooter()->getFirstFooter());
  795.         $objWriter->endElement();
  796.     }
  797.  
  798.     /**
  799.      * Write Breaks
  800.      *
  801.      * @param    PHPExcel_Shared_XMLWriter        $objWriter        XML Writer
  802.      * @param    PHPExcel_Worksheet                $pSheet            Worksheet
  803.      * @throws    Exception
  804.      */
  805.     private function _writeBreaks(PHPExcel_Shared_XMLWriter $objWriter nullPHPExcel_Worksheet $pSheet null)
  806.     {
  807.         // Get row and column breaks
  808.         $aRowBreaks array();
  809.         $aColumnBreaks array();
  810.         foreach ($pSheet->getBreaks(as $cell => $breakType{
  811.             if ($breakType == PHPExcel_Worksheet::BREAK_ROW{
  812.                 $aRowBreaks[$cell;
  813.             else if ($breakType == PHPExcel_Worksheet::BREAK_COLUMN{
  814.                 $aColumnBreaks[$cell;
  815.             }
  816.         }
  817.  
  818.         // rowBreaks
  819.         if (count($aRowBreaks0{
  820.             $objWriter->startElement('rowBreaks');
  821.             $objWriter->writeAttribute('count',            count($aRowBreaks));
  822.             $objWriter->writeAttribute('manualBreakCount',    count($aRowBreaks));
  823.  
  824.                 foreach ($aRowBreaks as $cell{
  825.                     $coords PHPExcel_Cell::coordinateFromString($cell);
  826.  
  827.                     $objWriter->startElement('brk');
  828.                     $objWriter->writeAttribute('id',    $coords[1]);
  829.                     $objWriter->writeAttribute('man',    '1');
  830.                     $objWriter->endElement();
  831.                 }
  832.  
  833.             $objWriter->endElement();
  834.         }
  835.  
  836.         // Second, write column breaks
  837.         if (count($aColumnBreaks0{
  838.             $objWriter->startElement('colBreaks');
  839.             $objWriter->writeAttribute('count',            count($aColumnBreaks));
  840.             $objWriter->writeAttribute('manualBreakCount',    count($aColumnBreaks));
  841.  
  842.                 foreach ($aColumnBreaks as $cell{
  843.                     $coords PHPExcel_Cell::coordinateFromString($cell);
  844.  
  845.                     $objWriter->startElement('brk');
  846.                     $objWriter->writeAttribute('id',    PHPExcel_Cell::columnIndexFromString($coords[0]1);
  847.                     $objWriter->writeAttribute('man',    '1');
  848.                     $objWriter->endElement();
  849.                 }
  850.  
  851.             $objWriter->endElement();
  852.         }
  853.     }
  854.  
  855.     /**
  856.      * Write SheetData
  857.      *
  858.      * @param    PHPExcel_Shared_XMLWriter        $objWriter        XML Writer
  859.      * @param    PHPExcel_Worksheet                $pSheet            Worksheet
  860.      * @param    string[]                        $pStringTable    String table
  861.      * @throws    Exception
  862.      */
  863.     private function _writeSheetData(PHPExcel_Shared_XMLWriter $objWriter nullPHPExcel_Worksheet $pSheet null$pStringTable null)
  864.     {
  865.         if (is_array($pStringTable)) {
  866.             // Flipped stringtable, for faster index searching
  867.             $aFlippedStringTable $this->getParentWriter()->getWriterPart('stringtable')->flipStringTable($pStringTable);
  868.  
  869.             // sheetData
  870.             $objWriter->startElement('sheetData');
  871.  
  872.                 // Get column count
  873.                 $colCount PHPExcel_Cell::columnIndexFromString($pSheet->getHighestColumn());
  874.  
  875.                 // Highest row number
  876.                 $highestRow $pSheet->getHighestRow();
  877.  
  878.                 // Loop trough cells
  879.                 $cellCollection $pSheet->getCellCollection();
  880.  
  881.                 $cellsByRow array();
  882.                 foreach ($cellCollection as $cell{
  883.                     $cellsByRow[$cell->getRow()][$cell;
  884.                 }
  885.  
  886.                 for ($currentRow 1$currentRow <= $highestRow++$currentRow{
  887.                     // Get row dimension
  888.                     $rowDimension $pSheet->getRowDimension($currentRow);
  889.     
  890.                     // Write current row?
  891.                     $writeCurrentRow =     isset($cellsByRow[$currentRow]||
  892.                                         $rowDimension->getRowHeight(>= ||
  893.                                         $rowDimension->getVisible(== false ||
  894.                                         $rowDimension->getCollapsed(== true ||
  895.                                         $rowDimension->getOutlineLevel(0;
  896.                                         
  897.                     if ($writeCurrentRow{                    
  898.                         // Start a new row
  899.                         $objWriter->startElement('row');
  900.                         $objWriter->writeAttribute('r',    $currentRow);
  901.                         $objWriter->writeAttribute('spans',    '1:' $colCount);
  902.     
  903.                         // Row dimensions
  904.                         if ($rowDimension->getRowHeight(>= 0{
  905.                             $objWriter->writeAttribute('customHeight',    '1');
  906.                             $objWriter->writeAttribute('ht',            PHPExcel_Shared_String::FormatNumber($rowDimension->getRowHeight()));
  907.                         }
  908.     
  909.                         // Row visibility
  910.                         if ($rowDimension->getVisible(== false{
  911.                             $objWriter->writeAttribute('hidden',        'true');
  912.                         }
  913.     
  914.                         // Collapsed
  915.                         if ($rowDimension->getCollapsed(== true{
  916.                             $objWriter->writeAttribute('collapsed',        'true');
  917.                         }
  918.     
  919.                         // Outline level
  920.                         if ($rowDimension->getOutlineLevel(0{
  921.                             $objWriter->writeAttribute('outlineLevel',    $rowDimension->getOutlineLevel());
  922.                         }
  923.     
  924.                         // Write cells
  925.                         if (isset($cellsByRow[$currentRow])) {
  926.                             foreach($cellsByRow[$currentRowas $cell{
  927.                                 // Write cell
  928.                                 $this->_writeCell($objWriter$pSheet$cell$pStringTable$aFlippedStringTable);
  929.                             }
  930.                         }
  931.     
  932.                         // End row
  933.                         $objWriter->endElement();
  934.                     }
  935.                 }
  936.  
  937.             $objWriter->endElement();
  938.         else {
  939.             throw new Exception("Invalid parameters passed.");
  940.         }
  941.     }
  942.  
  943.     /**
  944.      * Write Cell
  945.      *
  946.      * @param    PHPExcel_Shared_XMLWriter    $objWriter                XML Writer
  947.      * @param    PHPExcel_Worksheet            $pSheet                    Worksheet
  948.      * @param    PHPExcel_Cell                $pCell                    Cell
  949.      * @param    string[]                    $pStringTable            String table
  950.      * @param    string[]                    $pFlippedStringTable    String table (flipped), for faster index searching
  951.      * @throws    Exception
  952.      */
  953.     private function _writeCell(PHPExcel_Shared_XMLWriter $objWriter nullPHPExcel_Worksheet $pSheet nullPHPExcel_Cell $pCell null$pStringTable null$pFlippedStringTable null)
  954.     {
  955.         if (is_array($pStringTable&& is_array($pFlippedStringTable)) {
  956.             // Cell
  957.             $objWriter->startElement('c');
  958.             $objWriter->writeAttribute('r'$pCell->getCoordinate());
  959.  
  960.             // Sheet styles
  961.             if ($pCell->getXfIndex(!= ''{
  962.                 $objWriter->writeAttribute('s'$pCell->getXfIndex());
  963.             }
  964.  
  965.             // If cell value is supplied, write cell value
  966.             if (is_object($pCell->getValue()) || $pCell->getValue(!== ''{
  967.                 // Map type
  968.                 $mappedType $pCell->getDataType();
  969.  
  970.                 // Write data type depending on its type
  971.                 switch (strtolower($mappedType)) {
  972.                     case 'inlinestr':    // Inline string
  973.                         $objWriter->writeAttribute('t'$mappedType);
  974.                         break;
  975.                     case 's':            // String
  976.                         $objWriter->writeAttribute('t'$mappedType);
  977.                         break;
  978.                     case 'b':            // Boolean
  979.                         $objWriter->writeAttribute('t'$mappedType);
  980.                         break;
  981.                     case 'f':            // Formula
  982.                         $calculatedValue null;
  983.                         if ($this->getParentWriter()->getPreCalculateFormulas()) {
  984.                             $calculatedValue $pCell->getCalculatedValue();
  985.                         else {
  986.                             $calculatedValue $pCell->getValue();
  987.                         }
  988.                         if (is_string($calculatedValue)) {
  989.                             $objWriter->writeAttribute('t''str');
  990.                         }
  991.                         break;
  992.                     case 'e':            // Error
  993.                         $objWriter->writeAttribute('t'$mappedType);
  994.                 }
  995.  
  996.                 // Write data depending on its type
  997.                 switch (strtolower($mappedType)) {
  998.                     case 'inlinestr':    // Inline string
  999.                         if ($pCell->getValue(instanceof PHPExcel_RichText{
  1000.                             $objWriter->writeElement('t'PHPExcel_Shared_String::ControlCharacterPHP2OOXMLhtmlspecialchars($pCell->getValue()) ) );
  1001.                         else if ($pCell->getValue(instanceof PHPExcel_RichText{
  1002.                             $objWriter->startElement('is');
  1003.                             $this->getParentWriter()->getWriterPart('stringtable')->writeRichText($objWriter$pCell->getValue());
  1004.                             $objWriter->endElement();
  1005.                         }
  1006.  
  1007.                         break;
  1008.                     case 's':            // String
  1009.                         if ($pCell->getValue(instanceof PHPExcel_RichText{
  1010.                             if (isset($pFlippedStringTable[$pCell->getValue()])) {
  1011.                                 $objWriter->writeElement('v'$pFlippedStringTable[$pCell->getValue()]);
  1012.                             }
  1013.                         else if ($pCell->getValue(instanceof PHPExcel_RichText{
  1014.                             $objWriter->writeElement('v'$pFlippedStringTable[$pCell->getValue()->getHashCode()]);
  1015.                         }
  1016.  
  1017.                         break;
  1018.                     case 'f':            // Formula
  1019.                         $objWriter->writeElement('f'substr($pCell->getValue()1));
  1020.                         if ($this->getParentWriter()->getOffice2003Compatibility(=== false{
  1021.                             if ($this->getParentWriter()->getPreCalculateFormulas()) {
  1022.                                 $calculatedValue $pCell->getCalculatedValue();
  1023.                                 if (!is_array($calculatedValue&& substr($calculatedValue01!= '#'{
  1024.                                     $v PHPExcel_Shared_String::FormatNumber($calculatedValue);
  1025.                                     $objWriter->writeElement('v'$v);
  1026.                                 else {
  1027.                                     $objWriter->writeElement('v''0');
  1028.                                 }
  1029.                             else {
  1030.                                 $objWriter->writeElement('v''0');
  1031.                             }
  1032.                         }
  1033.                         break;
  1034.                     case 'n':            // Numeric
  1035.                         // force point as decimal separator in case current locale uses comma
  1036.                         $v str_replace(',''.'$pCell->getValue());
  1037.                         $objWriter->writeElement('v'$v);
  1038.                         break;
  1039.                     case 'b':            // Boolean
  1040.                         $objWriter->writeElement('v'($pCell->getValue('1' '0'));
  1041.                         break;
  1042.                     case 'e':            // Error
  1043.                         if (substr($pCell->getValue()01== '='{
  1044.                             $objWriter->writeElement('f'substr($pCell->getValue()1));
  1045.                             $objWriter->writeElement('v'substr($pCell->getValue()1));
  1046.                         else {
  1047.                             $objWriter->writeElement('v'$pCell->getValue());
  1048.                         }
  1049.  
  1050.                         break;
  1051.                 }
  1052.             }
  1053.  
  1054.             $objWriter->endElement();
  1055.         else {
  1056.             throw new Exception("Invalid parameters passed.");
  1057.         }
  1058.     }
  1059.  
  1060.     /**
  1061.      * Write Drawings
  1062.      *
  1063.      * @param    PHPExcel_Shared_XMLWriter        $objWriter        XML Writer
  1064.      * @param    PHPExcel_Worksheet                $pSheet            Worksheet
  1065.      * @throws    Exception
  1066.      */
  1067.     private function _writeDrawings(PHPExcel_Shared_XMLWriter $objWriter nullPHPExcel_Worksheet $pSheet null)
  1068.     {
  1069.         // If sheet contains drawings, add the relationships
  1070.         if ($pSheet->getDrawingCollection()->count(0{
  1071.             $objWriter->startElement('drawing');
  1072.             $objWriter->writeAttribute('r:id''rId1');
  1073.             $objWriter->endElement();
  1074.         }
  1075.     }
  1076.  
  1077.     /**
  1078.      * Write LegacyDrawing
  1079.      *
  1080.      * @param    PHPExcel_Shared_XMLWriter        $objWriter        XML Writer
  1081.      * @param    PHPExcel_Worksheet                $pSheet            Worksheet
  1082.      * @throws    Exception
  1083.      */
  1084.     private function _writeLegacyDrawing(PHPExcel_Shared_XMLWriter $objWriter nullPHPExcel_Worksheet $pSheet null)
  1085.     {
  1086.         // If sheet contains comments, add the relationships
  1087.         if (count($pSheet->getComments()) 0{
  1088.             $objWriter->startElement('legacyDrawing');
  1089.             $objWriter->writeAttribute('r:id''rId_comments_vml1');
  1090.             $objWriter->endElement();
  1091.         }
  1092.     }
  1093.  
  1094.     /**
  1095.      * Write LegacyDrawingHF
  1096.      *
  1097.      * @param    PHPExcel_Shared_XMLWriter        $objWriter        XML Writer
  1098.      * @param    PHPExcel_Worksheet                $pSheet            Worksheet
  1099.      * @throws    Exception
  1100.      */
  1101.     private function _writeLegacyDrawingHF(PHPExcel_Shared_XMLWriter $objWriter nullPHPExcel_Worksheet $pSheet null)
  1102.     {
  1103.         // If sheet contains comments, add the relationships
  1104.         if (count($pSheet->getHeaderFooter()->getImages()) 0{
  1105.             $objWriter->startElement('legacyDrawingHF');
  1106.             $objWriter->writeAttribute('r:id''rId_headerfooter_vml1');
  1107.             $objWriter->endElement();
  1108.         }
  1109.     }
  1110. }

Documentation generated on Mon, 10 Aug 2009 08:11:50 +0200 by phpDocumentor 1.4.1