[Summary view] [Print] [Text view]

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