[ Index ]

PHP Cross Reference of moodle-2.8

title

Body

[close]

/lib/phpexcel/PHPExcel/Writer/Excel2007/ -> Worksheet.php (source)

   1  <?php
   2  /**
   3   * PHPExcel
   4   *
   5   * Copyright (c) 2006 - 2014 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 - 2014 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 - 2014 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                      if ($ySplit > 1) {
 275                          $objWriter->writeAttribute('ySplit',    $ySplit - 1);
 276                          $pane = ($xSplit > 1) ? 'bottomRight' : 'bottomLeft';
 277                      }
 278                      $objWriter->writeAttribute('topLeftCell',    $topLeftCell);
 279                      $objWriter->writeAttribute('activePane',    $pane);
 280                      $objWriter->writeAttribute('state',        'frozen');
 281                      $objWriter->endElement();
 282  
 283                      if (($xSplit > 1) && ($ySplit > 1)) {
 284                          //    Write additional selections if more than two panes (ie both an X and a Y split)
 285                          $objWriter->startElement('selection');    $objWriter->writeAttribute('pane', 'topRight');        $objWriter->endElement();
 286                          $objWriter->startElement('selection');    $objWriter->writeAttribute('pane', 'bottomLeft');    $objWriter->endElement();
 287                      }
 288                  }
 289  
 290                  // Selection
 291  //                if ($pane != '') {
 292                      //    Only need to write selection element if we have a split pane
 293                      //        We cheat a little by over-riding the active cell selection, setting it to the split cell
 294                      $objWriter->startElement('selection');
 295                      if ($pane != '') {
 296                          $objWriter->writeAttribute('pane', $pane);
 297                      }
 298                      $objWriter->writeAttribute('activeCell', $activeCell);
 299                      $objWriter->writeAttribute('sqref', $activeCell);
 300                      $objWriter->endElement();
 301  //                }
 302  
 303              $objWriter->endElement();
 304  
 305          $objWriter->endElement();
 306      }
 307  
 308      /**
 309       * Write SheetFormatPr
 310       *
 311       * @param    PHPExcel_Shared_XMLWriter $objWriter        XML Writer
 312       * @param    PHPExcel_Worksheet          $pSheet            Worksheet
 313       * @throws    PHPExcel_Writer_Exception
 314       */
 315  	private function _writeSheetFormatPr(PHPExcel_Shared_XMLWriter $objWriter = null, PHPExcel_Worksheet $pSheet = null)
 316      {
 317          // sheetFormatPr
 318          $objWriter->startElement('sheetFormatPr');
 319  
 320              // Default row height
 321              if ($pSheet->getDefaultRowDimension()->getRowHeight() >= 0) {
 322                  $objWriter->writeAttribute('customHeight',        'true');
 323                  $objWriter->writeAttribute('defaultRowHeight',    PHPExcel_Shared_String::FormatNumber($pSheet->getDefaultRowDimension()->getRowHeight()));
 324              } else {
 325                  $objWriter->writeAttribute('defaultRowHeight', '14.4');
 326              }
 327  
 328              // Set Zero Height row
 329              if ((string)$pSheet->getDefaultRowDimension()->getzeroHeight()  == '1' ||
 330                  strtolower((string)$pSheet->getDefaultRowDimension()->getzeroHeight()) == 'true' ) {
 331                  $objWriter->writeAttribute('zeroHeight', '1');
 332              }
 333  
 334              // Default column width
 335              if ($pSheet->getDefaultColumnDimension()->getWidth() >= 0) {
 336                  $objWriter->writeAttribute('defaultColWidth', PHPExcel_Shared_String::FormatNumber($pSheet->getDefaultColumnDimension()->getWidth()));
 337              }
 338  
 339              // Outline level - row
 340              $outlineLevelRow = 0;
 341              foreach ($pSheet->getRowDimensions() as $dimension) {
 342                  if ($dimension->getOutlineLevel() > $outlineLevelRow) {
 343                      $outlineLevelRow = $dimension->getOutlineLevel();
 344                  }
 345              }
 346              $objWriter->writeAttribute('outlineLevelRow',    (int)$outlineLevelRow);
 347  
 348              // Outline level - column
 349              $outlineLevelCol = 0;
 350              foreach ($pSheet->getColumnDimensions() as $dimension) {
 351                  if ($dimension->getOutlineLevel() > $outlineLevelCol) {
 352                      $outlineLevelCol = $dimension->getOutlineLevel();
 353                  }
 354              }
 355              $objWriter->writeAttribute('outlineLevelCol',    (int)$outlineLevelCol);
 356  
 357          $objWriter->endElement();
 358      }
 359  
 360      /**
 361       * Write Cols
 362       *
 363       * @param    PHPExcel_Shared_XMLWriter            $objWriter        XML Writer
 364       * @param    PHPExcel_Worksheet                    $pSheet            Worksheet
 365       * @throws    PHPExcel_Writer_Exception
 366       */
 367  	private function _writeCols(PHPExcel_Shared_XMLWriter $objWriter = null, PHPExcel_Worksheet $pSheet = null)
 368      {
 369          // cols
 370          if (count($pSheet->getColumnDimensions()) > 0)  {
 371              $objWriter->startElement('cols');
 372  
 373                  $pSheet->calculateColumnWidths();
 374  
 375                  // Loop through column dimensions
 376                  foreach ($pSheet->getColumnDimensions() as $colDimension) {
 377                      // col
 378                      $objWriter->startElement('col');
 379                      $objWriter->writeAttribute('min',    PHPExcel_Cell::columnIndexFromString($colDimension->getColumnIndex()));
 380                      $objWriter->writeAttribute('max',    PHPExcel_Cell::columnIndexFromString($colDimension->getColumnIndex()));
 381  
 382                      if ($colDimension->getWidth() < 0) {
 383                          // No width set, apply default of 10
 384                          $objWriter->writeAttribute('width',        '9.10');
 385                      } else {
 386                          // Width set
 387                          $objWriter->writeAttribute('width',        PHPExcel_Shared_String::FormatNumber($colDimension->getWidth()));
 388                      }
 389  
 390                      // Column visibility
 391                      if ($colDimension->getVisible() == false) {
 392                          $objWriter->writeAttribute('hidden',        'true');
 393                      }
 394  
 395                      // Auto size?
 396                      if ($colDimension->getAutoSize()) {
 397                          $objWriter->writeAttribute('bestFit',        'true');
 398                      }
 399  
 400                      // Custom width?
 401                      if ($colDimension->getWidth() != $pSheet->getDefaultColumnDimension()->getWidth()) {
 402                          $objWriter->writeAttribute('customWidth',    'true');
 403                      }
 404  
 405                      // Collapsed
 406                      if ($colDimension->getCollapsed() == true) {
 407                          $objWriter->writeAttribute('collapsed',        'true');
 408                      }
 409  
 410                      // Outline level
 411                      if ($colDimension->getOutlineLevel() > 0) {
 412                          $objWriter->writeAttribute('outlineLevel',    $colDimension->getOutlineLevel());
 413                      }
 414  
 415                      // Style
 416                      $objWriter->writeAttribute('style', $colDimension->getXfIndex());
 417  
 418                      $objWriter->endElement();
 419                  }
 420  
 421              $objWriter->endElement();
 422          }
 423      }
 424  
 425      /**
 426       * Write SheetProtection
 427       *
 428       * @param    PHPExcel_Shared_XMLWriter            $objWriter        XML Writer
 429       * @param    PHPExcel_Worksheet                    $pSheet            Worksheet
 430       * @throws    PHPExcel_Writer_Exception
 431       */
 432  	private function _writeSheetProtection(PHPExcel_Shared_XMLWriter $objWriter = null, PHPExcel_Worksheet $pSheet = null)
 433      {
 434          // sheetProtection
 435          $objWriter->startElement('sheetProtection');
 436  
 437          if ($pSheet->getProtection()->getPassword() != '') {
 438              $objWriter->writeAttribute('password',                $pSheet->getProtection()->getPassword());
 439          }
 440  
 441          $objWriter->writeAttribute('sheet',                    ($pSheet->getProtection()->getSheet()                ? 'true' : 'false'));
 442          $objWriter->writeAttribute('objects',                ($pSheet->getProtection()->getObjects()                ? 'true' : 'false'));
 443          $objWriter->writeAttribute('scenarios',                ($pSheet->getProtection()->getScenarios()            ? 'true' : 'false'));
 444          $objWriter->writeAttribute('formatCells',            ($pSheet->getProtection()->getFormatCells()            ? 'true' : 'false'));
 445          $objWriter->writeAttribute('formatColumns',            ($pSheet->getProtection()->getFormatColumns()        ? 'true' : 'false'));
 446          $objWriter->writeAttribute('formatRows',            ($pSheet->getProtection()->getFormatRows()            ? 'true' : 'false'));
 447          $objWriter->writeAttribute('insertColumns',            ($pSheet->getProtection()->getInsertColumns()        ? 'true' : 'false'));
 448          $objWriter->writeAttribute('insertRows',            ($pSheet->getProtection()->getInsertRows()            ? 'true' : 'false'));
 449          $objWriter->writeAttribute('insertHyperlinks',        ($pSheet->getProtection()->getInsertHyperlinks()    ? 'true' : 'false'));
 450          $objWriter->writeAttribute('deleteColumns',            ($pSheet->getProtection()->getDeleteColumns()        ? 'true' : 'false'));
 451          $objWriter->writeAttribute('deleteRows',            ($pSheet->getProtection()->getDeleteRows()            ? 'true' : 'false'));
 452          $objWriter->writeAttribute('selectLockedCells',        ($pSheet->getProtection()->getSelectLockedCells()    ? 'true' : 'false'));
 453          $objWriter->writeAttribute('sort',                    ($pSheet->getProtection()->getSort()                ? 'true' : 'false'));
 454          $objWriter->writeAttribute('autoFilter',            ($pSheet->getProtection()->getAutoFilter()            ? 'true' : 'false'));
 455          $objWriter->writeAttribute('pivotTables',            ($pSheet->getProtection()->getPivotTables()            ? 'true' : 'false'));
 456          $objWriter->writeAttribute('selectUnlockedCells',    ($pSheet->getProtection()->getSelectUnlockedCells()    ? 'true' : 'false'));
 457          $objWriter->endElement();
 458      }
 459  
 460      /**
 461       * Write ConditionalFormatting
 462       *
 463       * @param    PHPExcel_Shared_XMLWriter            $objWriter        XML Writer
 464       * @param    PHPExcel_Worksheet                    $pSheet            Worksheet
 465       * @throws    PHPExcel_Writer_Exception
 466       */
 467  	private function _writeConditionalFormatting(PHPExcel_Shared_XMLWriter $objWriter = null, PHPExcel_Worksheet $pSheet = null)
 468      {
 469          // Conditional id
 470          $id = 1;
 471  
 472          // Loop through styles in the current worksheet
 473          foreach ($pSheet->getConditionalStylesCollection() as $cellCoordinate => $conditionalStyles) {
 474              foreach ($conditionalStyles as $conditional) {
 475                  // WHY was this again?
 476                  // if ($this->getParentWriter()->getStylesConditionalHashTable()->getIndexForHashCode( $conditional->getHashCode() ) == '') {
 477                  //    continue;
 478                  // }
 479                  if ($conditional->getConditionType() != PHPExcel_Style_Conditional::CONDITION_NONE) {
 480                      // conditionalFormatting
 481                      $objWriter->startElement('conditionalFormatting');
 482                      $objWriter->writeAttribute('sqref',    $cellCoordinate);
 483  
 484                          // cfRule
 485                          $objWriter->startElement('cfRule');
 486                          $objWriter->writeAttribute('type',        $conditional->getConditionType());
 487                          $objWriter->writeAttribute('dxfId',        $this->getParentWriter()->getStylesConditionalHashTable()->getIndexForHashCode( $conditional->getHashCode() ));
 488                          $objWriter->writeAttribute('priority',    $id++);
 489  
 490                          if (($conditional->getConditionType() == PHPExcel_Style_Conditional::CONDITION_CELLIS
 491                                  ||
 492                               $conditional->getConditionType() == PHPExcel_Style_Conditional::CONDITION_CONTAINSTEXT)
 493                              && $conditional->getOperatorType() != PHPExcel_Style_Conditional::OPERATOR_NONE) {
 494                              $objWriter->writeAttribute('operator',    $conditional->getOperatorType());
 495                          }
 496  
 497                          if ($conditional->getConditionType() == PHPExcel_Style_Conditional::CONDITION_CONTAINSTEXT
 498                              && !is_null($conditional->getText())) {
 499                              $objWriter->writeAttribute('text',    $conditional->getText());
 500                          }
 501  
 502                          if ($conditional->getConditionType() == PHPExcel_Style_Conditional::CONDITION_CONTAINSTEXT
 503                              && $conditional->getOperatorType() == PHPExcel_Style_Conditional::OPERATOR_CONTAINSTEXT
 504                              && !is_null($conditional->getText())) {
 505                              $objWriter->writeElement('formula',    'NOT(ISERROR(SEARCH("' . $conditional->getText() . '",' . $cellCoordinate . ')))');
 506                          } else if ($conditional->getConditionType() == PHPExcel_Style_Conditional::CONDITION_CONTAINSTEXT
 507                              && $conditional->getOperatorType() == PHPExcel_Style_Conditional::OPERATOR_BEGINSWITH
 508                              && !is_null($conditional->getText())) {
 509                              $objWriter->writeElement('formula',    'LEFT(' . $cellCoordinate . ',' . strlen($conditional->getText()) . ')="' . $conditional->getText() . '"');
 510                          } else if ($conditional->getConditionType() == PHPExcel_Style_Conditional::CONDITION_CONTAINSTEXT
 511                              && $conditional->getOperatorType() == PHPExcel_Style_Conditional::OPERATOR_ENDSWITH
 512                              && !is_null($conditional->getText())) {
 513                              $objWriter->writeElement('formula',    'RIGHT(' . $cellCoordinate . ',' . strlen($conditional->getText()) . ')="' . $conditional->getText() . '"');
 514                          } else if ($conditional->getConditionType() == PHPExcel_Style_Conditional::CONDITION_CONTAINSTEXT
 515                              && $conditional->getOperatorType() == PHPExcel_Style_Conditional::OPERATOR_NOTCONTAINS
 516                              && !is_null($conditional->getText())) {
 517                              $objWriter->writeElement('formula',    'ISERROR(SEARCH("' . $conditional->getText() . '",' . $cellCoordinate . '))');
 518                          } else if ($conditional->getConditionType() == PHPExcel_Style_Conditional::CONDITION_CELLIS
 519                              || $conditional->getConditionType() == PHPExcel_Style_Conditional::CONDITION_CONTAINSTEXT
 520                              || $conditional->getConditionType() == PHPExcel_Style_Conditional::CONDITION_EXPRESSION) {
 521                              foreach ($conditional->getConditions() as $formula) {
 522                                  // Formula
 523                                  $objWriter->writeElement('formula',    $formula);
 524                              }
 525                          }
 526  
 527                          $objWriter->endElement();
 528  
 529                      $objWriter->endElement();
 530                  }
 531              }
 532          }
 533      }
 534  
 535      /**
 536       * Write DataValidations
 537       *
 538       * @param    PHPExcel_Shared_XMLWriter            $objWriter        XML Writer
 539       * @param    PHPExcel_Worksheet                    $pSheet            Worksheet
 540       * @throws    PHPExcel_Writer_Exception
 541       */
 542  	private function _writeDataValidations(PHPExcel_Shared_XMLWriter $objWriter = null, PHPExcel_Worksheet $pSheet = null)
 543      {
 544          // Datavalidation collection
 545          $dataValidationCollection = $pSheet->getDataValidationCollection();
 546  
 547          // Write data validations?
 548          if (!empty($dataValidationCollection)) {
 549              $objWriter->startElement('dataValidations');
 550              $objWriter->writeAttribute('count', count($dataValidationCollection));
 551  
 552              foreach ($dataValidationCollection as $coordinate => $dv) {
 553                  $objWriter->startElement('dataValidation');
 554  
 555                  if ($dv->getType() != '') {
 556                      $objWriter->writeAttribute('type', $dv->getType());
 557                  }
 558  
 559                  if ($dv->getErrorStyle() != '') {
 560                      $objWriter->writeAttribute('errorStyle', $dv->getErrorStyle());
 561                  }
 562  
 563                  if ($dv->getOperator() != '') {
 564                      $objWriter->writeAttribute('operator', $dv->getOperator());
 565                  }
 566  
 567                  $objWriter->writeAttribute('allowBlank',        ($dv->getAllowBlank()        ? '1'  : '0'));
 568                  $objWriter->writeAttribute('showDropDown',        (!$dv->getShowDropDown()    ? '1'  : '0'));
 569                  $objWriter->writeAttribute('showInputMessage',    ($dv->getShowInputMessage()    ? '1'  : '0'));
 570                  $objWriter->writeAttribute('showErrorMessage',    ($dv->getShowErrorMessage()    ? '1'  : '0'));
 571  
 572                  if ($dv->getErrorTitle() !== '') {
 573                      $objWriter->writeAttribute('errorTitle', $dv->getErrorTitle());
 574                  }
 575                  if ($dv->getError() !== '') {
 576                      $objWriter->writeAttribute('error', $dv->getError());
 577                  }
 578                  if ($dv->getPromptTitle() !== '') {
 579                      $objWriter->writeAttribute('promptTitle', $dv->getPromptTitle());
 580                  }
 581                  if ($dv->getPrompt() !== '') {
 582                      $objWriter->writeAttribute('prompt', $dv->getPrompt());
 583                  }
 584  
 585                  $objWriter->writeAttribute('sqref', $coordinate);
 586  
 587                  if ($dv->getFormula1() !== '') {
 588                      $objWriter->writeElement('formula1', $dv->getFormula1());
 589                  }
 590                  if ($dv->getFormula2() !== '') {
 591                      $objWriter->writeElement('formula2', $dv->getFormula2());
 592                  }
 593  
 594                  $objWriter->endElement();
 595              }
 596  
 597              $objWriter->endElement();
 598          }
 599      }
 600  
 601      /**
 602       * Write Hyperlinks
 603       *
 604       * @param    PHPExcel_Shared_XMLWriter            $objWriter        XML Writer
 605       * @param    PHPExcel_Worksheet                    $pSheet            Worksheet
 606       * @throws    PHPExcel_Writer_Exception
 607       */
 608  	private function _writeHyperlinks(PHPExcel_Shared_XMLWriter $objWriter = null, PHPExcel_Worksheet $pSheet = null)
 609      {
 610          // Hyperlink collection
 611          $hyperlinkCollection = $pSheet->getHyperlinkCollection();
 612  
 613          // Relation ID
 614          $relationId = 1;
 615  
 616          // Write hyperlinks?
 617          if (!empty($hyperlinkCollection)) {
 618              $objWriter->startElement('hyperlinks');
 619  
 620              foreach ($hyperlinkCollection as $coordinate => $hyperlink) {
 621                  $objWriter->startElement('hyperlink');
 622  
 623                  $objWriter->writeAttribute('ref', $coordinate);
 624                  if (!$hyperlink->isInternal()) {
 625                      $objWriter->writeAttribute('r:id',    'rId_hyperlink_' . $relationId);
 626                      ++$relationId;
 627                  } else {
 628                      $objWriter->writeAttribute('location',    str_replace('sheet://', '', $hyperlink->getUrl()));
 629                  }
 630  
 631                  if ($hyperlink->getTooltip() != '') {
 632                      $objWriter->writeAttribute('tooltip', $hyperlink->getTooltip());
 633                  }
 634  
 635                  $objWriter->endElement();
 636              }
 637  
 638              $objWriter->endElement();
 639          }
 640      }
 641  
 642      /**
 643       * Write ProtectedRanges
 644       *
 645       * @param    PHPExcel_Shared_XMLWriter            $objWriter        XML Writer
 646       * @param    PHPExcel_Worksheet                    $pSheet            Worksheet
 647       * @throws    PHPExcel_Writer_Exception
 648       */
 649  	private function _writeProtectedRanges(PHPExcel_Shared_XMLWriter $objWriter = null, PHPExcel_Worksheet $pSheet = null)
 650      {
 651          if (count($pSheet->getProtectedCells()) > 0) {
 652              // protectedRanges
 653              $objWriter->startElement('protectedRanges');
 654  
 655                  // Loop protectedRanges
 656                  foreach ($pSheet->getProtectedCells() as $protectedCell => $passwordHash) {
 657                      // protectedRange
 658                      $objWriter->startElement('protectedRange');
 659                      $objWriter->writeAttribute('name',        'p' . md5($protectedCell));
 660                      $objWriter->writeAttribute('sqref',    $protectedCell);
 661                      if (!empty($passwordHash)) {
 662                          $objWriter->writeAttribute('password',    $passwordHash);
 663                      }
 664                      $objWriter->endElement();
 665                  }
 666  
 667              $objWriter->endElement();
 668          }
 669      }
 670  
 671      /**
 672       * Write MergeCells
 673       *
 674       * @param    PHPExcel_Shared_XMLWriter            $objWriter        XML Writer
 675       * @param    PHPExcel_Worksheet                    $pSheet            Worksheet
 676       * @throws    PHPExcel_Writer_Exception
 677       */
 678  	private function _writeMergeCells(PHPExcel_Shared_XMLWriter $objWriter = null, PHPExcel_Worksheet $pSheet = null)
 679      {
 680          if (count($pSheet->getMergeCells()) > 0) {
 681              // mergeCells
 682              $objWriter->startElement('mergeCells');
 683  
 684                  // Loop mergeCells
 685                  foreach ($pSheet->getMergeCells() as $mergeCell) {
 686                      // mergeCell
 687                      $objWriter->startElement('mergeCell');
 688                      $objWriter->writeAttribute('ref', $mergeCell);
 689                      $objWriter->endElement();
 690                  }
 691  
 692              $objWriter->endElement();
 693          }
 694      }
 695  
 696      /**
 697       * Write PrintOptions
 698       *
 699       * @param    PHPExcel_Shared_XMLWriter            $objWriter        XML Writer
 700       * @param    PHPExcel_Worksheet                    $pSheet            Worksheet
 701       * @throws    PHPExcel_Writer_Exception
 702       */
 703  	private function _writePrintOptions(PHPExcel_Shared_XMLWriter $objWriter = null, PHPExcel_Worksheet $pSheet = null)
 704      {
 705          // printOptions
 706          $objWriter->startElement('printOptions');
 707  
 708          $objWriter->writeAttribute('gridLines',    ($pSheet->getPrintGridlines() ? 'true': 'false'));
 709          $objWriter->writeAttribute('gridLinesSet',    'true');
 710  
 711          if ($pSheet->getPageSetup()->getHorizontalCentered()) {
 712              $objWriter->writeAttribute('horizontalCentered', 'true');
 713          }
 714  
 715          if ($pSheet->getPageSetup()->getVerticalCentered()) {
 716              $objWriter->writeAttribute('verticalCentered', 'true');
 717          }
 718  
 719          $objWriter->endElement();
 720      }
 721  
 722      /**
 723       * Write PageMargins
 724       *
 725       * @param    PHPExcel_Shared_XMLWriter                $objWriter        XML Writer
 726       * @param    PHPExcel_Worksheet                        $pSheet            Worksheet
 727       * @throws    PHPExcel_Writer_Exception
 728       */
 729  	private function _writePageMargins(PHPExcel_Shared_XMLWriter $objWriter = null, PHPExcel_Worksheet $pSheet = null)
 730      {
 731          // pageMargins
 732          $objWriter->startElement('pageMargins');
 733          $objWriter->writeAttribute('left',        PHPExcel_Shared_String::FormatNumber($pSheet->getPageMargins()->getLeft()));
 734          $objWriter->writeAttribute('right',        PHPExcel_Shared_String::FormatNumber($pSheet->getPageMargins()->getRight()));
 735          $objWriter->writeAttribute('top',        PHPExcel_Shared_String::FormatNumber($pSheet->getPageMargins()->getTop()));
 736          $objWriter->writeAttribute('bottom',    PHPExcel_Shared_String::FormatNumber($pSheet->getPageMargins()->getBottom()));
 737          $objWriter->writeAttribute('header',    PHPExcel_Shared_String::FormatNumber($pSheet->getPageMargins()->getHeader()));
 738          $objWriter->writeAttribute('footer',    PHPExcel_Shared_String::FormatNumber($pSheet->getPageMargins()->getFooter()));
 739          $objWriter->endElement();
 740      }
 741  
 742      /**
 743       * Write AutoFilter
 744       *
 745       * @param    PHPExcel_Shared_XMLWriter                $objWriter        XML Writer
 746       * @param    PHPExcel_Worksheet                        $pSheet            Worksheet
 747       * @throws    PHPExcel_Writer_Exception
 748       */
 749  	private function _writeAutoFilter(PHPExcel_Shared_XMLWriter $objWriter = null, PHPExcel_Worksheet $pSheet = null)
 750      {
 751          $autoFilterRange = $pSheet->getAutoFilter()->getRange();
 752          if (!empty($autoFilterRange)) {
 753              // autoFilter
 754              $objWriter->startElement('autoFilter');
 755  
 756              // Strip any worksheet reference from the filter coordinates
 757              $range = PHPExcel_Cell::splitRange($autoFilterRange);
 758              $range = $range[0];
 759              //    Strip any worksheet ref
 760              if (strpos($range[0],'!') !== false) {
 761                  list($ws,$range[0]) = explode('!',$range[0]);
 762              }
 763              $range = implode(':', $range);
 764  
 765              $objWriter->writeAttribute('ref',    str_replace('$','',$range));
 766  
 767              $columns = $pSheet->getAutoFilter()->getColumns();
 768              if (count($columns > 0)) {
 769                  foreach($columns as $columnID => $column) {
 770                      $rules = $column->getRules();
 771                      if (count($rules > 0)) {
 772                          $objWriter->startElement('filterColumn');
 773                              $objWriter->writeAttribute('colId',    $pSheet->getAutoFilter()->getColumnOffset($columnID));
 774  
 775                              $objWriter->startElement( $column->getFilterType());
 776                                  if ($column->getJoin() == PHPExcel_Worksheet_AutoFilter_Column::AUTOFILTER_COLUMN_JOIN_AND) {
 777                                      $objWriter->writeAttribute('and',    1);
 778                                  }
 779  
 780                                  foreach ($rules as $rule) {
 781                                      if (($column->getFilterType() === PHPExcel_Worksheet_AutoFilter_Column::AUTOFILTER_FILTERTYPE_FILTER) &&
 782                                          ($rule->getOperator() === PHPExcel_Worksheet_AutoFilter_Column_Rule::AUTOFILTER_COLUMN_RULE_EQUAL) &&
 783                                          ($rule->getValue() === '')) {
 784                                          //    Filter rule for Blanks
 785                                          $objWriter->writeAttribute('blank',    1);
 786                                      } elseif($rule->getRuleType() === PHPExcel_Worksheet_AutoFilter_Column_Rule::AUTOFILTER_RULETYPE_DYNAMICFILTER) {
 787                                          //    Dynamic Filter Rule
 788                                          $objWriter->writeAttribute('type', $rule->getGrouping());
 789                                          $val = $column->getAttribute('val');
 790                                          if ($val !== NULL) {
 791                                              $objWriter->writeAttribute('val', $val);
 792                                          }
 793                                          $maxVal = $column->getAttribute('maxVal');
 794                                          if ($maxVal !== NULL) {
 795                                              $objWriter->writeAttribute('maxVal', $maxVal);
 796                                          }
 797                                      } elseif($rule->getRuleType() === PHPExcel_Worksheet_AutoFilter_Column_Rule::AUTOFILTER_RULETYPE_TOPTENFILTER) {
 798                                          //    Top 10 Filter Rule
 799                                          $objWriter->writeAttribute('val',    $rule->getValue());
 800                                          $objWriter->writeAttribute('percent',    (($rule->getOperator() === PHPExcel_Worksheet_AutoFilter_Column_Rule::AUTOFILTER_COLUMN_RULE_TOPTEN_PERCENT) ? '1' : '0'));
 801                                          $objWriter->writeAttribute('top',    (($rule->getGrouping() === PHPExcel_Worksheet_AutoFilter_Column_Rule::AUTOFILTER_COLUMN_RULE_TOPTEN_TOP) ? '1': '0'));
 802                                      } else {
 803                                          //    Filter, DateGroupItem or CustomFilter
 804                                          $objWriter->startElement($rule->getRuleType());
 805  
 806                                              if ($rule->getOperator() !== PHPExcel_Worksheet_AutoFilter_Column_Rule::AUTOFILTER_COLUMN_RULE_EQUAL) {
 807                                                  $objWriter->writeAttribute('operator',    $rule->getOperator());
 808                                              }
 809                                              if ($rule->getRuleType() === PHPExcel_Worksheet_AutoFilter_Column_Rule::AUTOFILTER_RULETYPE_DATEGROUP) {
 810                                                  // Date Group filters
 811                                                  foreach($rule->getValue() as $key => $value) {
 812                                                      if ($value > '') $objWriter->writeAttribute($key,    $value);
 813                                                  }
 814                                                  $objWriter->writeAttribute('dateTimeGrouping',    $rule->getGrouping());
 815                                              } else {
 816                                                  $objWriter->writeAttribute('val',    $rule->getValue());
 817                                              }
 818  
 819                                          $objWriter->endElement();
 820                                      }
 821                                  }
 822  
 823                              $objWriter->endElement();
 824  
 825                          $objWriter->endElement();
 826                      }
 827                  }
 828              }
 829  
 830              $objWriter->endElement();
 831          }
 832      }
 833  
 834      /**
 835       * Write PageSetup
 836       *
 837       * @param    PHPExcel_Shared_XMLWriter            $objWriter        XML Writer
 838       * @param    PHPExcel_Worksheet                    $pSheet            Worksheet
 839       * @throws    PHPExcel_Writer_Exception
 840       */
 841  	private function _writePageSetup(PHPExcel_Shared_XMLWriter $objWriter = null, PHPExcel_Worksheet $pSheet = null)
 842      {
 843          // pageSetup
 844          $objWriter->startElement('pageSetup');
 845          $objWriter->writeAttribute('paperSize',        $pSheet->getPageSetup()->getPaperSize());
 846          $objWriter->writeAttribute('orientation',    $pSheet->getPageSetup()->getOrientation());
 847  
 848          if (!is_null($pSheet->getPageSetup()->getScale())) {
 849              $objWriter->writeAttribute('scale',                 $pSheet->getPageSetup()->getScale());
 850          }
 851          if (!is_null($pSheet->getPageSetup()->getFitToHeight())) {
 852              $objWriter->writeAttribute('fitToHeight',         $pSheet->getPageSetup()->getFitToHeight());
 853          } else {
 854              $objWriter->writeAttribute('fitToHeight',         '0');
 855          }
 856          if (!is_null($pSheet->getPageSetup()->getFitToWidth())) {
 857              $objWriter->writeAttribute('fitToWidth',         $pSheet->getPageSetup()->getFitToWidth());
 858          } else {
 859              $objWriter->writeAttribute('fitToWidth',         '0');
 860          }
 861          if (!is_null($pSheet->getPageSetup()->getFirstPageNumber())) {
 862              $objWriter->writeAttribute('firstPageNumber',    $pSheet->getPageSetup()->getFirstPageNumber());
 863              $objWriter->writeAttribute('useFirstPageNumber', '1');
 864          }
 865  
 866          $objWriter->endElement();
 867      }
 868  
 869      /**
 870       * Write Header / Footer
 871       *
 872       * @param    PHPExcel_Shared_XMLWriter        $objWriter        XML Writer
 873       * @param    PHPExcel_Worksheet                $pSheet            Worksheet
 874       * @throws    PHPExcel_Writer_Exception
 875       */
 876  	private function _writeHeaderFooter(PHPExcel_Shared_XMLWriter $objWriter = null, PHPExcel_Worksheet $pSheet = null)
 877      {
 878          // headerFooter
 879          $objWriter->startElement('headerFooter');
 880          $objWriter->writeAttribute('differentOddEven',    ($pSheet->getHeaderFooter()->getDifferentOddEven() ? 'true' : 'false'));
 881          $objWriter->writeAttribute('differentFirst',    ($pSheet->getHeaderFooter()->getDifferentFirst() ? 'true' : 'false'));
 882          $objWriter->writeAttribute('scaleWithDoc',        ($pSheet->getHeaderFooter()->getScaleWithDocument() ? 'true' : 'false'));
 883          $objWriter->writeAttribute('alignWithMargins',    ($pSheet->getHeaderFooter()->getAlignWithMargins() ? 'true' : 'false'));
 884  
 885              $objWriter->writeElement('oddHeader',        $pSheet->getHeaderFooter()->getOddHeader());
 886              $objWriter->writeElement('oddFooter',        $pSheet->getHeaderFooter()->getOddFooter());
 887              $objWriter->writeElement('evenHeader',        $pSheet->getHeaderFooter()->getEvenHeader());
 888              $objWriter->writeElement('evenFooter',        $pSheet->getHeaderFooter()->getEvenFooter());
 889              $objWriter->writeElement('firstHeader',    $pSheet->getHeaderFooter()->getFirstHeader());
 890              $objWriter->writeElement('firstFooter',    $pSheet->getHeaderFooter()->getFirstFooter());
 891          $objWriter->endElement();
 892      }
 893  
 894      /**
 895       * Write Breaks
 896       *
 897       * @param    PHPExcel_Shared_XMLWriter        $objWriter        XML Writer
 898       * @param    PHPExcel_Worksheet                $pSheet            Worksheet
 899       * @throws    PHPExcel_Writer_Exception
 900       */
 901  	private function _writeBreaks(PHPExcel_Shared_XMLWriter $objWriter = null, PHPExcel_Worksheet $pSheet = null)
 902      {
 903          // Get row and column breaks
 904          $aRowBreaks = array();
 905          $aColumnBreaks = array();
 906          foreach ($pSheet->getBreaks() as $cell => $breakType) {
 907              if ($breakType == PHPExcel_Worksheet::BREAK_ROW) {
 908                  $aRowBreaks[] = $cell;
 909              } else if ($breakType == PHPExcel_Worksheet::BREAK_COLUMN) {
 910                  $aColumnBreaks[] = $cell;
 911              }
 912          }
 913  
 914          // rowBreaks
 915          if (!empty($aRowBreaks)) {
 916              $objWriter->startElement('rowBreaks');
 917              $objWriter->writeAttribute('count',            count($aRowBreaks));
 918              $objWriter->writeAttribute('manualBreakCount',    count($aRowBreaks));
 919  
 920                  foreach ($aRowBreaks as $cell) {
 921                      $coords = PHPExcel_Cell::coordinateFromString($cell);
 922  
 923                      $objWriter->startElement('brk');
 924                      $objWriter->writeAttribute('id',    $coords[1]);
 925                      $objWriter->writeAttribute('man',    '1');
 926                      $objWriter->endElement();
 927                  }
 928  
 929              $objWriter->endElement();
 930          }
 931  
 932          // Second, write column breaks
 933          if (!empty($aColumnBreaks)) {
 934              $objWriter->startElement('colBreaks');
 935              $objWriter->writeAttribute('count',            count($aColumnBreaks));
 936              $objWriter->writeAttribute('manualBreakCount',    count($aColumnBreaks));
 937  
 938                  foreach ($aColumnBreaks as $cell) {
 939                      $coords = PHPExcel_Cell::coordinateFromString($cell);
 940  
 941                      $objWriter->startElement('brk');
 942                      $objWriter->writeAttribute('id',    PHPExcel_Cell::columnIndexFromString($coords[0]) - 1);
 943                      $objWriter->writeAttribute('man',    '1');
 944                      $objWriter->endElement();
 945                  }
 946  
 947              $objWriter->endElement();
 948          }
 949      }
 950  
 951      /**
 952       * Write SheetData
 953       *
 954       * @param    PHPExcel_Shared_XMLWriter        $objWriter        XML Writer
 955       * @param    PHPExcel_Worksheet                $pSheet            Worksheet
 956       * @param    string[]                        $pStringTable    String table
 957       * @throws    PHPExcel_Writer_Exception
 958       */
 959  	private function _writeSheetData(PHPExcel_Shared_XMLWriter $objWriter = null, PHPExcel_Worksheet $pSheet = null, $pStringTable = null)
 960      {
 961          if (is_array($pStringTable)) {
 962              // Flipped stringtable, for faster index searching
 963              $aFlippedStringTable = $this->getParentWriter()->getWriterPart('stringtable')->flipStringTable($pStringTable);
 964  
 965              // sheetData
 966              $objWriter->startElement('sheetData');
 967  
 968                  // Get column count
 969                  $colCount = PHPExcel_Cell::columnIndexFromString($pSheet->getHighestColumn());
 970  
 971                  // Highest row number
 972                  $highestRow = $pSheet->getHighestRow();
 973  
 974                  // Loop through cells
 975                  $cellsByRow = array();
 976                  foreach ($pSheet->getCellCollection() as $cellID) {
 977                      $cellAddress = PHPExcel_Cell::coordinateFromString($cellID);
 978                      $cellsByRow[$cellAddress[1]][] = $cellID;
 979                  }
 980  
 981                  $currentRow = 0;
 982                  while($currentRow++ < $highestRow) {
 983                      // Get row dimension
 984                      $rowDimension = $pSheet->getRowDimension($currentRow);
 985  
 986                      // Write current row?
 987                      $writeCurrentRow =    isset($cellsByRow[$currentRow]) ||
 988                                          $rowDimension->getRowHeight() >= 0 ||
 989                                          $rowDimension->getVisible() == false ||
 990                                          $rowDimension->getCollapsed() == true ||
 991                                          $rowDimension->getOutlineLevel() > 0 ||
 992                                          $rowDimension->getXfIndex() !== null;
 993  
 994                      if ($writeCurrentRow) {
 995                          // Start a new row
 996                          $objWriter->startElement('row');
 997                          $objWriter->writeAttribute('r',    $currentRow);
 998                          $objWriter->writeAttribute('spans',    '1:' . $colCount);
 999  
1000                          // Row dimensions
1001                          if ($rowDimension->getRowHeight() >= 0) {
1002                              $objWriter->writeAttribute('customHeight',    '1');
1003                              $objWriter->writeAttribute('ht',            PHPExcel_Shared_String::FormatNumber($rowDimension->getRowHeight()));
1004                          }
1005  
1006                          // Row visibility
1007                          if ($rowDimension->getVisible() == false) {
1008                              $objWriter->writeAttribute('hidden',        'true');
1009                          }
1010  
1011                          // Collapsed
1012                          if ($rowDimension->getCollapsed() == true) {
1013                              $objWriter->writeAttribute('collapsed',        'true');
1014                          }
1015  
1016                          // Outline level
1017                          if ($rowDimension->getOutlineLevel() > 0) {
1018                              $objWriter->writeAttribute('outlineLevel',    $rowDimension->getOutlineLevel());
1019                          }
1020  
1021                          // Style
1022                          if ($rowDimension->getXfIndex() !== null) {
1023                              $objWriter->writeAttribute('s',    $rowDimension->getXfIndex());
1024                              $objWriter->writeAttribute('customFormat', '1');
1025                          }
1026  
1027                          // Write cells
1028                          if (isset($cellsByRow[$currentRow])) {
1029                              foreach($cellsByRow[$currentRow] as $cellAddress) {
1030                                  // Write cell
1031                                  $this->_writeCell($objWriter, $pSheet, $cellAddress, $pStringTable, $aFlippedStringTable);
1032                              }
1033                          }
1034  
1035                          // End row
1036                          $objWriter->endElement();
1037                      }
1038                  }
1039  
1040              $objWriter->endElement();
1041          } else {
1042              throw new PHPExcel_Writer_Exception("Invalid parameters passed.");
1043          }
1044      }
1045  
1046      /**
1047       * Write Cell
1048       *
1049       * @param    PHPExcel_Shared_XMLWriter    $objWriter                XML Writer
1050       * @param    PHPExcel_Worksheet            $pSheet                    Worksheet
1051       * @param    PHPExcel_Cell                $pCellAddress            Cell Address
1052       * @param    string[]                    $pStringTable            String table
1053       * @param    string[]                    $pFlippedStringTable    String table (flipped), for faster index searching
1054       * @throws    PHPExcel_Writer_Exception
1055       */
1056  	private function _writeCell(PHPExcel_Shared_XMLWriter $objWriter = null, PHPExcel_Worksheet $pSheet = null, $pCellAddress = null, $pStringTable = null, $pFlippedStringTable = null)
1057      {
1058          if (is_array($pStringTable) && is_array($pFlippedStringTable)) {
1059              // Cell
1060              $pCell = $pSheet->getCell($pCellAddress);
1061              $objWriter->startElement('c');
1062              $objWriter->writeAttribute('r', $pCellAddress);
1063  
1064              // Sheet styles
1065              if ($pCell->getXfIndex() != '') {
1066                  $objWriter->writeAttribute('s', $pCell->getXfIndex());
1067              }
1068  
1069              // If cell value is supplied, write cell value
1070              $cellValue = $pCell->getValue();
1071              if (is_object($cellValue) || $cellValue !== '') {
1072                  // Map type
1073                  $mappedType = $pCell->getDataType();
1074  
1075                  // Write data type depending on its type
1076                  switch (strtolower($mappedType)) {
1077                      case 'inlinestr':    // Inline string
1078                      case 's':            // String
1079                      case 'b':            // Boolean
1080                          $objWriter->writeAttribute('t', $mappedType);
1081                          break;
1082                      case 'f':            // Formula
1083                          $calculatedValue = ($this->getParentWriter()->getPreCalculateFormulas()) ?
1084                              $pCell->getCalculatedValue() :
1085                              $cellValue;
1086                          if (is_string($calculatedValue)) {
1087                              $objWriter->writeAttribute('t', 'str');
1088                          }
1089                          break;
1090                      case 'e':            // Error
1091                          $objWriter->writeAttribute('t', $mappedType);
1092                  }
1093  
1094                  // Write data depending on its type
1095                  switch (strtolower($mappedType)) {
1096                      case 'inlinestr':    // Inline string
1097                          if (! $cellValue instanceof PHPExcel_RichText) {
1098                              $objWriter->writeElement('t', PHPExcel_Shared_String::ControlCharacterPHP2OOXML( htmlspecialchars($cellValue) ) );
1099                          } else if ($cellValue instanceof PHPExcel_RichText) {
1100                              $objWriter->startElement('is');
1101                              $this->getParentWriter()->getWriterPart('stringtable')->writeRichText($objWriter, $cellValue);
1102                              $objWriter->endElement();
1103                          }
1104  
1105                          break;
1106                      case 's':            // String
1107                          if (! $cellValue instanceof PHPExcel_RichText) {
1108                              if (isset($pFlippedStringTable[$cellValue])) {
1109                                  $objWriter->writeElement('v', $pFlippedStringTable[$cellValue]);
1110                              }
1111                          } else if ($cellValue instanceof PHPExcel_RichText) {
1112                              $objWriter->writeElement('v', $pFlippedStringTable[$cellValue->getHashCode()]);
1113                          }
1114  
1115                          break;
1116                      case 'f':            // Formula
1117                          $attributes = $pCell->getFormulaAttributes();
1118                          if($attributes['t'] == 'array') {
1119                              $objWriter->startElement('f');
1120                              $objWriter->writeAttribute('t', 'array');
1121                              $objWriter->writeAttribute('ref', $pCellAddress);
1122                              $objWriter->writeAttribute('aca', '1');
1123                              $objWriter->writeAttribute('ca', '1');
1124                              $objWriter->text(substr($cellValue, 1));
1125                              $objWriter->endElement();
1126                          } else {
1127                              $objWriter->writeElement('f', substr($cellValue, 1));
1128                          }
1129                          if ($this->getParentWriter()->getOffice2003Compatibility() === false) {
1130                              if ($this->getParentWriter()->getPreCalculateFormulas()) {
1131  //                                $calculatedValue = $pCell->getCalculatedValue();
1132                                  if (!is_array($calculatedValue) && substr($calculatedValue, 0, 1) != '#') {
1133                                      $objWriter->writeElement('v', PHPExcel_Shared_String::FormatNumber($calculatedValue));
1134                                  } else {
1135                                      $objWriter->writeElement('v', '0');
1136                                  }
1137                              } else {
1138                                  $objWriter->writeElement('v', '0');
1139                              }
1140                          }
1141                          break;
1142                      case 'n':            // Numeric
1143                          // force point as decimal separator in case current locale uses comma
1144                          $objWriter->writeElement('v', str_replace(',', '.', $cellValue));
1145                          break;
1146                      case 'b':            // Boolean
1147                          $objWriter->writeElement('v', ($cellValue ? '1' : '0'));
1148                          break;
1149                      case 'e':            // Error
1150                          if (substr($cellValue, 0, 1) == '=') {
1151                              $objWriter->writeElement('f', substr($cellValue, 1));
1152                              $objWriter->writeElement('v', substr($cellValue, 1));
1153                          } else {
1154                              $objWriter->writeElement('v', $cellValue);
1155                          }
1156  
1157                          break;
1158                  }
1159              }
1160  
1161              $objWriter->endElement();
1162          } else {
1163              throw new PHPExcel_Writer_Exception("Invalid parameters passed.");
1164          }
1165      }
1166  
1167      /**
1168       * Write Drawings
1169       *
1170       * @param    PHPExcel_Shared_XMLWriter    $objWriter        XML Writer
1171       * @param    PHPExcel_Worksheet            $pSheet            Worksheet
1172       * @param    boolean                        $includeCharts    Flag indicating if we should include drawing details for charts
1173       * @throws    PHPExcel_Writer_Exception
1174       */
1175  	private function _writeDrawings(PHPExcel_Shared_XMLWriter $objWriter = null, PHPExcel_Worksheet $pSheet = null, $includeCharts = FALSE)
1176      {
1177          $chartCount = ($includeCharts) ? $pSheet->getChartCollection()->count() : 0;
1178          // If sheet contains drawings, add the relationships
1179          if (($pSheet->getDrawingCollection()->count() > 0) ||
1180              ($chartCount > 0)) {
1181              $objWriter->startElement('drawing');
1182              $objWriter->writeAttribute('r:id', 'rId1');
1183              $objWriter->endElement();
1184          }
1185      }
1186  
1187      /**
1188       * Write LegacyDrawing
1189       *
1190       * @param    PHPExcel_Shared_XMLWriter        $objWriter        XML Writer
1191       * @param    PHPExcel_Worksheet                $pSheet            Worksheet
1192       * @throws    PHPExcel_Writer_Exception
1193       */
1194  	private function _writeLegacyDrawing(PHPExcel_Shared_XMLWriter $objWriter = null, PHPExcel_Worksheet $pSheet = null)
1195      {
1196          // If sheet contains comments, add the relationships
1197          if (count($pSheet->getComments()) > 0) {
1198              $objWriter->startElement('legacyDrawing');
1199              $objWriter->writeAttribute('r:id', 'rId_comments_vml1');
1200              $objWriter->endElement();
1201          }
1202      }
1203  
1204      /**
1205       * Write LegacyDrawingHF
1206       *
1207       * @param    PHPExcel_Shared_XMLWriter        $objWriter        XML Writer
1208       * @param    PHPExcel_Worksheet                $pSheet            Worksheet
1209       * @throws    PHPExcel_Writer_Exception
1210       */
1211  	private function _writeLegacyDrawingHF(PHPExcel_Shared_XMLWriter $objWriter = null, PHPExcel_Worksheet $pSheet = null)
1212      {
1213          // If sheet contains images, add the relationships
1214          if (count($pSheet->getHeaderFooter()->getImages()) > 0) {
1215              $objWriter->startElement('legacyDrawingHF');
1216              $objWriter->writeAttribute('r:id', 'rId_headerfooter_vml1');
1217              $objWriter->endElement();
1218          }
1219      }
1220  }


Generated: Fri Nov 28 20:29:05 2014 Cross-referenced by PHPXref 0.7.1