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_Reader_Excel5
  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    1.8.0, 2014-03-02
  26:  */
  27: 
  28: // Original file header of ParseXL (used as the base for this class):
  29: // --------------------------------------------------------------------------------
  30: // Adapted from Excel_Spreadsheet_Reader developed by users bizon153,
  31: // trex005, and mmp11 (SourceForge.net)
  32: // http://sourceforge.net/projects/phpexcelreader/
  33: // Primary changes made by canyoncasa (dvc) for ParseXL 1.00 ...
  34: //   Modelled moreso after Perl Excel Parse/Write modules
  35: //   Added Parse_Excel_Spreadsheet object
  36: //       Reads a whole worksheet or tab as row,column array or as
  37: //       associated hash of indexed rows and named column fields
  38: //   Added variables for worksheet (tab) indexes and names
  39: //   Added an object call for loading individual woorksheets
  40: //   Changed default indexing defaults to 0 based arrays
  41: //   Fixed date/time and percent formats
  42: //   Includes patches found at SourceForge...
  43: //       unicode patch by nobody
  44: //       unpack("d") machine depedency patch by matchy
  45: //       boundsheet utf16 patch by bjaenichen
  46: //   Renamed functions for shorter names
  47: //   General code cleanup and rigor, including <80 column width
  48: //   Included a testcase Excel file and PHP example calls
  49: //   Code works for PHP 5.x
  50: 
  51: // Primary changes made by canyoncasa (dvc) for ParseXL 1.10 ...
  52: // http://sourceforge.net/tracker/index.php?func=detail&aid=1466964&group_id=99160&atid=623334
  53: //   Decoding of formula conditions, results, and tokens.
  54: //   Support for user-defined named cells added as an array "namedcells"
  55: //       Patch code for user-defined named cells supports single cells only.
  56: //       NOTE: this patch only works for BIFF8 as BIFF5-7 use a different
  57: //       external sheet reference structure
  58: 
  59: 
  60: /** PHPExcel root directory */
  61: if (!defined('PHPEXCEL_ROOT')) {
  62:     /**
  63:      * @ignore
  64:      */
  65:     define('PHPEXCEL_ROOT', dirname(__FILE__) . '/../../');
  66:     require(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
  67: }
  68: 
  69: /**
  70:  * PHPExcel_Reader_Excel5
  71:  *
  72:  * This class uses {@link http://sourceforge.net/projects/phpexcelreader/parseXL}
  73:  *
  74:  * @category    PHPExcel
  75:  * @package     PHPExcel_Reader_Excel5
  76:  * @copyright   Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
  77:  */
  78: class PHPExcel_Reader_Excel5 extends PHPExcel_Reader_Abstract implements PHPExcel_Reader_IReader
  79: {
  80:     // ParseXL definitions
  81:     const XLS_BIFF8                     = 0x0600;
  82:     const XLS_BIFF7                     = 0x0500;
  83:     const XLS_WorkbookGlobals           = 0x0005;
  84:     const XLS_Worksheet                 = 0x0010;
  85: 
  86:     // record identifiers
  87:     const XLS_Type_FORMULA              = 0x0006;
  88:     const XLS_Type_EOF                  = 0x000a;
  89:     const XLS_Type_PROTECT              = 0x0012;
  90:     const XLS_Type_OBJECTPROTECT        = 0x0063;
  91:     const XLS_Type_SCENPROTECT          = 0x00dd;
  92:     const XLS_Type_PASSWORD             = 0x0013;
  93:     const XLS_Type_HEADER               = 0x0014;
  94:     const XLS_Type_FOOTER               = 0x0015;
  95:     const XLS_Type_EXTERNSHEET          = 0x0017;
  96:     const XLS_Type_DEFINEDNAME          = 0x0018;
  97:     const XLS_Type_VERTICALPAGEBREAKS   = 0x001a;
  98:     const XLS_Type_HORIZONTALPAGEBREAKS = 0x001b;
  99:     const XLS_Type_NOTE                 = 0x001c;
 100:     const XLS_Type_SELECTION            = 0x001d;
 101:     const XLS_Type_DATEMODE             = 0x0022;
 102:     const XLS_Type_EXTERNNAME           = 0x0023;
 103:     const XLS_Type_LEFTMARGIN           = 0x0026;
 104:     const XLS_Type_RIGHTMARGIN          = 0x0027;
 105:     const XLS_Type_TOPMARGIN            = 0x0028;
 106:     const XLS_Type_BOTTOMMARGIN         = 0x0029;
 107:     const XLS_Type_PRINTGRIDLINES       = 0x002b;
 108:     const XLS_Type_FILEPASS             = 0x002f;
 109:     const XLS_Type_FONT                 = 0x0031;
 110:     const XLS_Type_CONTINUE             = 0x003c;
 111:     const XLS_Type_PANE                 = 0x0041;
 112:     const XLS_Type_CODEPAGE             = 0x0042;
 113:     const XLS_Type_DEFCOLWIDTH          = 0x0055;
 114:     const XLS_Type_OBJ                  = 0x005d;
 115:     const XLS_Type_COLINFO              = 0x007d;
 116:     const XLS_Type_IMDATA               = 0x007f;
 117:     const XLS_Type_SHEETPR              = 0x0081;
 118:     const XLS_Type_HCENTER              = 0x0083;
 119:     const XLS_Type_VCENTER              = 0x0084;
 120:     const XLS_Type_SHEET                = 0x0085;
 121:     const XLS_Type_PALETTE              = 0x0092;
 122:     const XLS_Type_SCL                  = 0x00a0;
 123:     const XLS_Type_PAGESETUP            = 0x00a1;
 124:     const XLS_Type_MULRK                = 0x00bd;
 125:     const XLS_Type_MULBLANK             = 0x00be;
 126:     const XLS_Type_DBCELL               = 0x00d7;
 127:     const XLS_Type_XF                   = 0x00e0;
 128:     const XLS_Type_MERGEDCELLS          = 0x00e5;
 129:     const XLS_Type_MSODRAWINGGROUP      = 0x00eb;
 130:     const XLS_Type_MSODRAWING           = 0x00ec;
 131:     const XLS_Type_SST                  = 0x00fc;
 132:     const XLS_Type_LABELSST             = 0x00fd;
 133:     const XLS_Type_EXTSST               = 0x00ff;
 134:     const XLS_Type_EXTERNALBOOK         = 0x01ae;
 135:     const XLS_Type_DATAVALIDATIONS      = 0x01b2;
 136:     const XLS_Type_TXO                  = 0x01b6;
 137:     const XLS_Type_HYPERLINK            = 0x01b8;
 138:     const XLS_Type_DATAVALIDATION       = 0x01be;
 139:     const XLS_Type_DIMENSION            = 0x0200;
 140:     const XLS_Type_BLANK                = 0x0201;
 141:     const XLS_Type_NUMBER               = 0x0203;
 142:     const XLS_Type_LABEL                = 0x0204;
 143:     const XLS_Type_BOOLERR              = 0x0205;
 144:     const XLS_Type_STRING               = 0x0207;
 145:     const XLS_Type_ROW                  = 0x0208;
 146:     const XLS_Type_INDEX                = 0x020b;
 147:     const XLS_Type_ARRAY                = 0x0221;
 148:     const XLS_Type_DEFAULTROWHEIGHT     = 0x0225;
 149:     const XLS_Type_WINDOW2              = 0x023e;
 150:     const XLS_Type_RK                   = 0x027e;
 151:     const XLS_Type_STYLE                = 0x0293;
 152:     const XLS_Type_FORMAT               = 0x041e;
 153:     const XLS_Type_SHAREDFMLA           = 0x04bc;
 154:     const XLS_Type_BOF                  = 0x0809;
 155:     const XLS_Type_SHEETPROTECTION      = 0x0867;
 156:     const XLS_Type_RANGEPROTECTION      = 0x0868;
 157:     const XLS_Type_SHEETLAYOUT          = 0x0862;
 158:     const XLS_Type_XFEXT                = 0x087d;
 159:     const XLS_Type_PAGELAYOUTVIEW       = 0x088b;
 160:     const XLS_Type_UNKNOWN              = 0xffff;
 161: 
 162:     // Encryption type
 163:     const MS_BIFF_CRYPTO_NONE = 0;
 164:     const MS_BIFF_CRYPTO_XOR  = 1;
 165:     const MS_BIFF_CRYPTO_RC4  = 2;
 166:     
 167:     // Size of stream blocks when using RC4 encryption
 168:     const REKEY_BLOCK = 0x400;
 169: 
 170:     /**
 171:      * Summary Information stream data.
 172:      *
 173:      * @var string
 174:      */
 175:     private $_summaryInformation;
 176: 
 177:     /**
 178:      * Extended Summary Information stream data.
 179:      *
 180:      * @var string
 181:      */
 182:     private $_documentSummaryInformation;
 183: 
 184:     /**
 185:      * User-Defined Properties stream data.
 186:      *
 187:      * @var string
 188:      */
 189:     private $_userDefinedProperties;
 190: 
 191:     /**
 192:      * Workbook stream data. (Includes workbook globals substream as well as sheet substreams)
 193:      *
 194:      * @var string
 195:      */
 196:     private $_data;
 197: 
 198:     /**
 199:      * Size in bytes of $this->_data
 200:      *
 201:      * @var int
 202:      */
 203:     private $_dataSize;
 204: 
 205:     /**
 206:      * Current position in stream
 207:      *
 208:      * @var integer
 209:      */
 210:     private $_pos;
 211: 
 212:     /**
 213:      * Workbook to be returned by the reader.
 214:      *
 215:      * @var PHPExcel
 216:      */
 217:     private $_phpExcel;
 218: 
 219:     /**
 220:      * Worksheet that is currently being built by the reader.
 221:      *
 222:      * @var PHPExcel_Worksheet
 223:      */
 224:     private $_phpSheet;
 225: 
 226:     /**
 227:      * BIFF version
 228:      *
 229:      * @var int
 230:      */
 231:     private $_version;
 232: 
 233:     /**
 234:      * Codepage set in the Excel file being read. Only important for BIFF5 (Excel 5.0 - Excel 95)
 235:      * For BIFF8 (Excel 97 - Excel 2003) this will always have the value 'UTF-16LE'
 236:      *
 237:      * @var string
 238:      */
 239:     private $_codepage;
 240: 
 241:     /**
 242:      * Shared formats
 243:      *
 244:      * @var array
 245:      */
 246:     private $_formats;
 247: 
 248:     /**
 249:      * Shared fonts
 250:      *
 251:      * @var array
 252:      */
 253:     private $_objFonts;
 254: 
 255:     /**
 256:      * Color palette
 257:      *
 258:      * @var array
 259:      */
 260:     private $_palette;
 261: 
 262:     /**
 263:      * Worksheets
 264:      *
 265:      * @var array
 266:      */
 267:     private $_sheets;
 268: 
 269:     /**
 270:      * External books
 271:      *
 272:      * @var array
 273:      */
 274:     private $_externalBooks;
 275: 
 276:     /**
 277:      * REF structures. Only applies to BIFF8.
 278:      *
 279:      * @var array
 280:      */
 281:     private $_ref;
 282: 
 283:     /**
 284:      * External names
 285:      *
 286:      * @var array
 287:      */
 288:     private $_externalNames;
 289: 
 290:     /**
 291:      * Defined names
 292:      *
 293:      * @var array
 294:      */
 295:     private $_definedname;
 296: 
 297:     /**
 298:      * Shared strings. Only applies to BIFF8.
 299:      *
 300:      * @var array
 301:      */
 302:     private $_sst;
 303: 
 304:     /**
 305:      * Panes are frozen? (in sheet currently being read). See WINDOW2 record.
 306:      *
 307:      * @var boolean
 308:      */
 309:     private $_frozen;
 310: 
 311:     /**
 312:      * Fit printout to number of pages? (in sheet currently being read). See SHEETPR record.
 313:      *
 314:      * @var boolean
 315:      */
 316:     private $_isFitToPages;
 317: 
 318:     /**
 319:      * Objects. One OBJ record contributes with one entry.
 320:      *
 321:      * @var array
 322:      */
 323:     private $_objs;
 324: 
 325:     /**
 326:      * Text Objects. One TXO record corresponds with one entry.
 327:      *
 328:      * @var array
 329:      */
 330:     private $_textObjects;
 331: 
 332:     /**
 333:      * Cell Annotations (BIFF8)
 334:      *
 335:      * @var array
 336:      */
 337:     private $_cellNotes;
 338: 
 339:     /**
 340:      * The combined MSODRAWINGGROUP data
 341:      *
 342:      * @var string
 343:      */
 344:     private $_drawingGroupData;
 345: 
 346:     /**
 347:      * The combined MSODRAWING data (per sheet)
 348:      *
 349:      * @var string
 350:      */
 351:     private $_drawingData;
 352: 
 353:     /**
 354:      * Keep track of XF index
 355:      *
 356:      * @var int
 357:      */
 358:     private $_xfIndex;
 359: 
 360:     /**
 361:      * Mapping of XF index (that is a cell XF) to final index in cellXf collection
 362:      *
 363:      * @var array
 364:      */
 365:     private $_mapCellXfIndex;
 366: 
 367:     /**
 368:      * Mapping of XF index (that is a style XF) to final index in cellStyleXf collection
 369:      *
 370:      * @var array
 371:      */
 372:     private $_mapCellStyleXfIndex;
 373: 
 374:     /**
 375:      * The shared formulas in a sheet. One SHAREDFMLA record contributes with one value.
 376:      *
 377:      * @var array
 378:      */
 379:     private $_sharedFormulas;
 380: 
 381:     /**
 382:      * The shared formula parts in a sheet. One FORMULA record contributes with one value if it
 383:      * refers to a shared formula.
 384:      *
 385:      * @var array
 386:      */
 387:     private $_sharedFormulaParts;
 388: 
 389:     /**
 390:      * The type of encryption in use
 391:      *
 392:      * @var int 
 393:      */
 394:     private $_encryption = 0;
 395:     
 396:     /**
 397:      * The position in the stream after which contents are encrypted
 398:      *
 399:      * @var int
 400:      */
 401:     private $_encryptionStartPos = false;
 402: 
 403:     /**
 404:      * The current RC4 decryption object
 405:      *
 406:      * @var PHPExcel_Reader_Excel5_RC4
 407:      */
 408:     private $_rc4Key = null;
 409: 
 410:     /**
 411:      * The position in the stream that the RC4 decryption object was left at
 412:      *
 413:      * @var int
 414:      */
 415:     private $_rc4Pos = 0;
 416: 
 417:     /**
 418:      * The current MD5 context state
 419:      *
 420:      * @var string
 421:      */
 422:     private $_md5Ctxt = null;
 423: 
 424:     /**
 425:      * Create a new PHPExcel_Reader_Excel5 instance
 426:      */
 427:     public function __construct() {
 428:         $this->_readFilter = new PHPExcel_Reader_DefaultReadFilter();
 429:     }
 430: 
 431: 
 432:     /**
 433:      * Can the current PHPExcel_Reader_IReader read the file?
 434:      *
 435:      * @param   string      $pFilename
 436:      * @return  boolean
 437:      * @throws PHPExcel_Reader_Exception
 438:      */
 439:     public function canRead($pFilename)
 440:     {
 441:         // Check if file exists
 442:         if (!file_exists($pFilename)) {
 443:             throw new PHPExcel_Reader_Exception("Could not open " . $pFilename . " for reading! File does not exist.");
 444:         }
 445: 
 446:         try {
 447:             // Use ParseXL for the hard work.
 448:             $ole = new PHPExcel_Shared_OLERead();
 449: 
 450:             // get excel data
 451:             $res = $ole->read($pFilename);
 452:             return true;
 453:         } catch (PHPExcel_Exception $e) {
 454:             return false;
 455:         }
 456:     }
 457: 
 458: 
 459:     /**
 460:      * Reads names of the worksheets from a file, without parsing the whole file to a PHPExcel object
 461:      *
 462:      * @param   string      $pFilename
 463:      * @throws  PHPExcel_Reader_Exception
 464:      */
 465:     public function listWorksheetNames($pFilename)
 466:     {
 467:         // Check if file exists
 468:         if (!file_exists($pFilename)) {
 469:             throw new PHPExcel_Reader_Exception("Could not open " . $pFilename . " for reading! File does not exist.");
 470:         }
 471: 
 472:         $worksheetNames = array();
 473: 
 474:         // Read the OLE file
 475:         $this->_loadOLE($pFilename);
 476: 
 477:         // total byte size of Excel data (workbook global substream + sheet substreams)
 478:         $this->_dataSize = strlen($this->_data);
 479: 
 480:         $this->_pos     = 0;
 481:         $this->_sheets  = array();
 482: 
 483:         // Parse Workbook Global Substream
 484:         while ($this->_pos < $this->_dataSize) {
 485:             $code = self::_GetInt2d($this->_data, $this->_pos);
 486: 
 487:             switch ($code) {
 488:                 case self::XLS_Type_BOF:    $this->_readBof();      break;
 489:                 case self::XLS_Type_SHEET:  $this->_readSheet();    break;
 490:                 case self::XLS_Type_EOF:    $this->_readDefault();  break 2;
 491:                 default:                    $this->_readDefault();  break;
 492:             }
 493:         }
 494: 
 495:         foreach ($this->_sheets as $sheet) {
 496:             if ($sheet['sheetType'] != 0x00) {
 497:                 // 0x00: Worksheet, 0x02: Chart, 0x06: Visual Basic module
 498:                 continue;
 499:             }
 500: 
 501:             $worksheetNames[] = $sheet['name'];
 502:         }
 503: 
 504:         return $worksheetNames;
 505:     }
 506: 
 507: 
 508:     /**
 509:      * Return worksheet info (Name, Last Column Letter, Last Column Index, Total Rows, Total Columns)
 510:      *
 511:      * @param   string     $pFilename
 512:      * @throws   PHPExcel_Reader_Exception
 513:      */
 514:     public function listWorksheetInfo($pFilename)
 515:     {
 516:         // Check if file exists
 517:         if (!file_exists($pFilename)) {
 518:             throw new PHPExcel_Reader_Exception("Could not open " . $pFilename . " for reading! File does not exist.");
 519:         }
 520: 
 521:         $worksheetInfo = array();
 522: 
 523:         // Read the OLE file
 524:         $this->_loadOLE($pFilename);
 525: 
 526:         // total byte size of Excel data (workbook global substream + sheet substreams)
 527:         $this->_dataSize = strlen($this->_data);
 528: 
 529:         // initialize
 530:         $this->_pos    = 0;
 531:         $this->_sheets = array();
 532: 
 533:         // Parse Workbook Global Substream
 534:         while ($this->_pos < $this->_dataSize) {
 535:             $code = self::_GetInt2d($this->_data, $this->_pos);
 536: 
 537:             switch ($code) {
 538:                 case self::XLS_Type_BOF:        $this->_readBof();        break;
 539:                 case self::XLS_Type_SHEET:      $this->_readSheet();      break;
 540:                 case self::XLS_Type_EOF:        $this->_readDefault();    break 2;
 541:                 default:                        $this->_readDefault();    break;
 542:             }
 543:         }
 544: 
 545:         // Parse the individual sheets
 546:         foreach ($this->_sheets as $sheet) {
 547: 
 548:             if ($sheet['sheetType'] != 0x00) {
 549:                 // 0x00: Worksheet
 550:                 // 0x02: Chart
 551:                 // 0x06: Visual Basic module
 552:                 continue;
 553:             }
 554: 
 555:             $tmpInfo = array();
 556:             $tmpInfo['worksheetName'] = $sheet['name'];
 557:             $tmpInfo['lastColumnLetter'] = 'A';
 558:             $tmpInfo['lastColumnIndex'] = 0;
 559:             $tmpInfo['totalRows'] = 0;
 560:             $tmpInfo['totalColumns'] = 0;
 561: 
 562:             $this->_pos = $sheet['offset'];
 563: 
 564:             while ($this->_pos <= $this->_dataSize - 4) {
 565:                 $code = self::_GetInt2d($this->_data, $this->_pos);
 566: 
 567:                 switch ($code) {
 568:                     case self::XLS_Type_RK:
 569:                     case self::XLS_Type_LABELSST:
 570:                     case self::XLS_Type_NUMBER:
 571:                     case self::XLS_Type_FORMULA:
 572:                     case self::XLS_Type_BOOLERR:
 573:                     case self::XLS_Type_LABEL:
 574:                         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
 575:                         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
 576: 
 577:                         // move stream pointer to next record
 578:                         $this->_pos += 4 + $length;
 579: 
 580:                         $rowIndex = self::_GetInt2d($recordData, 0) + 1;
 581:                         $columnIndex = self::_GetInt2d($recordData, 2);
 582: 
 583:                         $tmpInfo['totalRows'] = max($tmpInfo['totalRows'], $rowIndex);
 584:                         $tmpInfo['lastColumnIndex'] = max($tmpInfo['lastColumnIndex'], $columnIndex);
 585:                         break;
 586:                     case self::XLS_Type_BOF:      $this->_readBof();          break;
 587:                     case self::XLS_Type_EOF:      $this->_readDefault();      break 2;
 588:                     default:                      $this->_readDefault();      break;
 589:                 }
 590:             }
 591: 
 592:             $tmpInfo['lastColumnLetter'] = PHPExcel_Cell::stringFromColumnIndex($tmpInfo['lastColumnIndex']);
 593:             $tmpInfo['totalColumns'] = $tmpInfo['lastColumnIndex'] + 1;
 594: 
 595:             $worksheetInfo[] = $tmpInfo;
 596:         }
 597: 
 598:         return $worksheetInfo;
 599:     }
 600: 
 601: 
 602:     /**
 603:      * Loads PHPExcel from file
 604:      *
 605:      * @param   string      $pFilename
 606:      * @return  PHPExcel
 607:      * @throws  PHPExcel_Reader_Exception
 608:      */
 609:     public function load($pFilename)
 610:     {
 611:         // Read the OLE file
 612:         $this->_loadOLE($pFilename);
 613: 
 614:         // Initialisations
 615:         $this->_phpExcel = new PHPExcel;
 616:         $this->_phpExcel->removeSheetByIndex(0); // remove 1st sheet
 617:         if (!$this->_readDataOnly) {
 618:             $this->_phpExcel->removeCellStyleXfByIndex(0); // remove the default style
 619:             $this->_phpExcel->removeCellXfByIndex(0); // remove the default style
 620:         }
 621: 
 622:         // Read the summary information stream (containing meta data)
 623:         $this->_readSummaryInformation();
 624: 
 625:         // Read the Additional document summary information stream (containing application-specific meta data)
 626:         $this->_readDocumentSummaryInformation();
 627: 
 628:         // total byte size of Excel data (workbook global substream + sheet substreams)
 629:         $this->_dataSize = strlen($this->_data);
 630: 
 631:         // initialize
 632:         $this->_pos                 = 0;
 633:         $this->_codepage            = 'CP1252';
 634:         $this->_formats             = array();
 635:         $this->_objFonts            = array();
 636:         $this->_palette             = array();
 637:         $this->_sheets              = array();
 638:         $this->_externalBooks       = array();
 639:         $this->_ref                 = array();
 640:         $this->_definedname         = array();
 641:         $this->_sst                 = array();
 642:         $this->_drawingGroupData    = '';
 643:         $this->_xfIndex             = '';
 644:         $this->_mapCellXfIndex      = array();
 645:         $this->_mapCellStyleXfIndex = array();
 646: 
 647:         // Parse Workbook Global Substream
 648:         while ($this->_pos < $this->_dataSize) {
 649:             $code = self::_GetInt2d($this->_data, $this->_pos);
 650: 
 651:             switch ($code) {
 652:                 case self::XLS_Type_BOF:            $this->_readBof();              break;
 653:                 case self::XLS_Type_FILEPASS:       $this->_readFilepass();         break;
 654:                 case self::XLS_Type_CODEPAGE:       $this->_readCodepage();         break;
 655:                 case self::XLS_Type_DATEMODE:       $this->_readDateMode();         break;
 656:                 case self::XLS_Type_FONT:           $this->_readFont();             break;
 657:                 case self::XLS_Type_FORMAT:         $this->_readFormat();           break;
 658:                 case self::XLS_Type_XF:             $this->_readXf();               break;
 659:                 case self::XLS_Type_XFEXT:          $this->_readXfExt();            break;
 660:                 case self::XLS_Type_STYLE:          $this->_readStyle();            break;
 661:                 case self::XLS_Type_PALETTE:        $this->_readPalette();          break;
 662:                 case self::XLS_Type_SHEET:          $this->_readSheet();            break;
 663:                 case self::XLS_Type_EXTERNALBOOK:   $this->_readExternalBook();     break;
 664:                 case self::XLS_Type_EXTERNNAME:     $this->_readExternName();       break;
 665:                 case self::XLS_Type_EXTERNSHEET:    $this->_readExternSheet();      break;
 666:                 case self::XLS_Type_DEFINEDNAME:    $this->_readDefinedName();      break;
 667:                 case self::XLS_Type_MSODRAWINGGROUP:    $this->_readMsoDrawingGroup();  break;
 668:                 case self::XLS_Type_SST:            $this->_readSst();              break;
 669:                 case self::XLS_Type_EOF:            $this->_readDefault();          break 2;
 670:                 default:                            $this->_readDefault();          break;
 671:             }
 672:         }
 673: 
 674:         // Resolve indexed colors for font, fill, and border colors
 675:         // Cannot be resolved already in XF record, because PALETTE record comes afterwards
 676:         if (!$this->_readDataOnly) {
 677:             foreach ($this->_objFonts as $objFont) {
 678:                 if (isset($objFont->colorIndex)) {
 679:                     $color = self::_readColor($objFont->colorIndex,$this->_palette,$this->_version);
 680:                     $objFont->getColor()->setRGB($color['rgb']);
 681:                 }
 682:             }
 683: 
 684:             foreach ($this->_phpExcel->getCellXfCollection() as $objStyle) {
 685:                 // fill start and end color
 686:                 $fill = $objStyle->getFill();
 687: 
 688:                 if (isset($fill->startcolorIndex)) {
 689:                     $startColor = self::_readColor($fill->startcolorIndex,$this->_palette,$this->_version);
 690:                     $fill->getStartColor()->setRGB($startColor['rgb']);
 691:                 }
 692: 
 693:                 if (isset($fill->endcolorIndex)) {
 694:                     $endColor = self::_readColor($fill->endcolorIndex,$this->_palette,$this->_version);
 695:                     $fill->getEndColor()->setRGB($endColor['rgb']);
 696:                 }
 697: 
 698:                 // border colors
 699:                 $top      = $objStyle->getBorders()->getTop();
 700:                 $right    = $objStyle->getBorders()->getRight();
 701:                 $bottom   = $objStyle->getBorders()->getBottom();
 702:                 $left     = $objStyle->getBorders()->getLeft();
 703:                 $diagonal = $objStyle->getBorders()->getDiagonal();
 704: 
 705:                 if (isset($top->colorIndex)) {
 706:                     $borderTopColor = self::_readColor($top->colorIndex,$this->_palette,$this->_version);
 707:                     $top->getColor()->setRGB($borderTopColor['rgb']);
 708:                 }
 709: 
 710:                 if (isset($right->colorIndex)) {
 711:                     $borderRightColor = self::_readColor($right->colorIndex,$this->_palette,$this->_version);
 712:                     $right->getColor()->setRGB($borderRightColor['rgb']);
 713:                 }
 714: 
 715:                 if (isset($bottom->colorIndex)) {
 716:                     $borderBottomColor = self::_readColor($bottom->colorIndex,$this->_palette,$this->_version);
 717:                     $bottom->getColor()->setRGB($borderBottomColor['rgb']);
 718:                 }
 719: 
 720:                 if (isset($left->colorIndex)) {
 721:                     $borderLeftColor = self::_readColor($left->colorIndex,$this->_palette,$this->_version);
 722:                     $left->getColor()->setRGB($borderLeftColor['rgb']);
 723:                 }
 724: 
 725:                 if (isset($diagonal->colorIndex)) {
 726:                     $borderDiagonalColor = self::_readColor($diagonal->colorIndex,$this->_palette,$this->_version);
 727:                     $diagonal->getColor()->setRGB($borderDiagonalColor['rgb']);
 728:                 }
 729:             }
 730:         }
 731: 
 732:         // treat MSODRAWINGGROUP records, workbook-level Escher
 733:         if (!$this->_readDataOnly && $this->_drawingGroupData) {
 734:             $escherWorkbook = new PHPExcel_Shared_Escher();
 735:             $reader = new PHPExcel_Reader_Excel5_Escher($escherWorkbook);
 736:             $escherWorkbook = $reader->load($this->_drawingGroupData);
 737: 
 738:             // debug Escher stream
 739:             //$debug = new Debug_Escher(new PHPExcel_Shared_Escher());
 740:             //$debug->load($this->_drawingGroupData);
 741:         }
 742: 
 743:         // Parse the individual sheets
 744:         foreach ($this->_sheets as $sheet) {
 745: 
 746:             if ($sheet['sheetType'] != 0x00) {
 747:                 // 0x00: Worksheet, 0x02: Chart, 0x06: Visual Basic module
 748:                 continue;
 749:             }
 750: 
 751:             // check if sheet should be skipped
 752:             if (isset($this->_loadSheetsOnly) && !in_array($sheet['name'], $this->_loadSheetsOnly)) {
 753:                 continue;
 754:             }
 755: 
 756:             // add sheet to PHPExcel object
 757:             $this->_phpSheet = $this->_phpExcel->createSheet();
 758:             //  Use false for $updateFormulaCellReferences to prevent adjustment of worksheet references in formula
 759:             //      cells... during the load, all formulae should be correct, and we're simply bringing the worksheet
 760:             //      name in line with the formula, not the reverse
 761:             $this->_phpSheet->setTitle($sheet['name'],false);
 762:             $this->_phpSheet->setSheetState($sheet['sheetState']);
 763: 
 764:             $this->_pos = $sheet['offset'];
 765: 
 766:             // Initialize isFitToPages. May change after reading SHEETPR record.
 767:             $this->_isFitToPages = false;
 768: 
 769:             // Initialize drawingData
 770:             $this->_drawingData = '';
 771: 
 772:             // Initialize objs
 773:             $this->_objs = array();
 774: 
 775:             // Initialize shared formula parts
 776:             $this->_sharedFormulaParts = array();
 777: 
 778:             // Initialize shared formulas
 779:             $this->_sharedFormulas = array();
 780: 
 781:             // Initialize text objs
 782:             $this->_textObjects = array();
 783: 
 784:             // Initialize cell annotations
 785:             $this->_cellNotes = array();
 786:             $this->textObjRef = -1;
 787: 
 788:             while ($this->_pos <= $this->_dataSize - 4) {
 789:                 $code = self::_GetInt2d($this->_data, $this->_pos);
 790: 
 791:                 switch ($code) {
 792:                     case self::XLS_Type_BOF:                    $this->_readBof();                      break;
 793:                     case self::XLS_Type_PRINTGRIDLINES:         $this->_readPrintGridlines();           break;
 794:                     case self::XLS_Type_DEFAULTROWHEIGHT:       $this->_readDefaultRowHeight();         break;
 795:                     case self::XLS_Type_SHEETPR:                $this->_readSheetPr();                  break;
 796:                     case self::XLS_Type_HORIZONTALPAGEBREAKS:   $this->_readHorizontalPageBreaks();     break;
 797:                     case self::XLS_Type_VERTICALPAGEBREAKS:     $this->_readVerticalPageBreaks();       break;
 798:                     case self::XLS_Type_HEADER:                 $this->_readHeader();                   break;
 799:                     case self::XLS_Type_FOOTER:                 $this->_readFooter();                   break;
 800:                     case self::XLS_Type_HCENTER:                $this->_readHcenter();                  break;
 801:                     case self::XLS_Type_VCENTER:                $this->_readVcenter();                  break;
 802:                     case self::XLS_Type_LEFTMARGIN:             $this->_readLeftMargin();               break;
 803:                     case self::XLS_Type_RIGHTMARGIN:            $this->_readRightMargin();              break;
 804:                     case self::XLS_Type_TOPMARGIN:              $this->_readTopMargin();                break;
 805:                     case self::XLS_Type_BOTTOMMARGIN:           $this->_readBottomMargin();             break;
 806:                     case self::XLS_Type_PAGESETUP:              $this->_readPageSetup();                break;
 807:                     case self::XLS_Type_PROTECT:                $this->_readProtect();                  break;
 808:                     case self::XLS_Type_SCENPROTECT:            $this->_readScenProtect();              break;
 809:                     case self::XLS_Type_OBJECTPROTECT:          $this->_readObjectProtect();            break;
 810:                     case self::XLS_Type_PASSWORD:               $this->_readPassword();                 break;
 811:                     case self::XLS_Type_DEFCOLWIDTH:            $this->_readDefColWidth();              break;
 812:                     case self::XLS_Type_COLINFO:                $this->_readColInfo();                  break;
 813:                     case self::XLS_Type_DIMENSION:              $this->_readDefault();                  break;
 814:                     case self::XLS_Type_ROW:                    $this->_readRow();                      break;
 815:                     case self::XLS_Type_DBCELL:                 $this->_readDefault();                  break;
 816:                     case self::XLS_Type_RK:                     $this->_readRk();                       break;
 817:                     case self::XLS_Type_LABELSST:               $this->_readLabelSst();                 break;
 818:                     case self::XLS_Type_MULRK:                  $this->_readMulRk();                    break;
 819:                     case self::XLS_Type_NUMBER:                 $this->_readNumber();                   break;
 820:                     case self::XLS_Type_FORMULA:                $this->_readFormula();                  break;
 821:                     case self::XLS_Type_SHAREDFMLA:             $this->_readSharedFmla();               break;
 822:                     case self::XLS_Type_BOOLERR:                $this->_readBoolErr();                  break;
 823:                     case self::XLS_Type_MULBLANK:               $this->_readMulBlank();                 break;
 824:                     case self::XLS_Type_LABEL:                  $this->_readLabel();                    break;
 825:                     case self::XLS_Type_BLANK:                  $this->_readBlank();                    break;
 826:                     case self::XLS_Type_MSODRAWING:             $this->_readMsoDrawing();               break;
 827:                     case self::XLS_Type_OBJ:                    $this->_readObj();                      break;
 828:                     case self::XLS_Type_WINDOW2:                $this->_readWindow2();                  break;
 829:                     case self::XLS_Type_PAGELAYOUTVIEW: $this->_readPageLayoutView();                   break;
 830:                     case self::XLS_Type_SCL:                    $this->_readScl();                      break;
 831:                     case self::XLS_Type_PANE:                   $this->_readPane();                     break;
 832:                     case self::XLS_Type_SELECTION:              $this->_readSelection();                break;
 833:                     case self::XLS_Type_MERGEDCELLS:            $this->_readMergedCells();              break;
 834:                     case self::XLS_Type_HYPERLINK:              $this->_readHyperLink();                break;
 835:                     case self::XLS_Type_DATAVALIDATIONS:        $this->_readDataValidations();          break;
 836:                     case self::XLS_Type_DATAVALIDATION:         $this->_readDataValidation();           break;
 837:                     case self::XLS_Type_SHEETLAYOUT:            $this->_readSheetLayout();              break;
 838:                     case self::XLS_Type_SHEETPROTECTION:        $this->_readSheetProtection();          break;
 839:                     case self::XLS_Type_RANGEPROTECTION:        $this->_readRangeProtection();          break;
 840:                     case self::XLS_Type_NOTE:                   $this->_readNote();                     break;
 841:                     //case self::XLS_Type_IMDATA:               $this->_readImData();                   break;
 842:                     case self::XLS_Type_TXO:                    $this->_readTextObject();               break;
 843:                     case self::XLS_Type_CONTINUE:               $this->_readContinue();                 break;
 844:                     case self::XLS_Type_EOF:                    $this->_readDefault();                  break 2;
 845:                     default:                                    $this->_readDefault();                  break;
 846:                 }
 847: 
 848:             }
 849: 
 850:             // treat MSODRAWING records, sheet-level Escher
 851:             if (!$this->_readDataOnly && $this->_drawingData) {
 852:                 $escherWorksheet = new PHPExcel_Shared_Escher();
 853:                 $reader = new PHPExcel_Reader_Excel5_Escher($escherWorksheet);
 854:                 $escherWorksheet = $reader->load($this->_drawingData);
 855: 
 856:                 // debug Escher stream
 857:                 //$debug = new Debug_Escher(new PHPExcel_Shared_Escher());
 858:                 //$debug->load($this->_drawingData);
 859: 
 860:                 // get all spContainers in one long array, so they can be mapped to OBJ records
 861:                 $allSpContainers = $escherWorksheet->getDgContainer()->getSpgrContainer()->getAllSpContainers();
 862:             }
 863: 
 864:             // treat OBJ records
 865:             foreach ($this->_objs as $n => $obj) {
 866: //              echo '<hr /><b>Object</b> reference is ',$n,'<br />';
 867: //              var_dump($obj);
 868: //              echo '<br />';
 869: 
 870:                 // the first shape container never has a corresponding OBJ record, hence $n + 1
 871:                 if (isset($allSpContainers[$n + 1]) && is_object($allSpContainers[$n + 1])) {
 872:                     $spContainer = $allSpContainers[$n + 1];
 873: 
 874:                     // we skip all spContainers that are a part of a group shape since we cannot yet handle those
 875:                     if ($spContainer->getNestingLevel() > 1) {
 876:                         continue;
 877:                     }
 878: 
 879:                     // calculate the width and height of the shape
 880:                     list($startColumn, $startRow) = PHPExcel_Cell::coordinateFromString($spContainer->getStartCoordinates());
 881:                     list($endColumn, $endRow) = PHPExcel_Cell::coordinateFromString($spContainer->getEndCoordinates());
 882: 
 883:                     $startOffsetX = $spContainer->getStartOffsetX();
 884:                     $startOffsetY = $spContainer->getStartOffsetY();
 885:                     $endOffsetX = $spContainer->getEndOffsetX();
 886:                     $endOffsetY = $spContainer->getEndOffsetY();
 887: 
 888:                     $width = PHPExcel_Shared_Excel5::getDistanceX($this->_phpSheet, $startColumn, $startOffsetX, $endColumn, $endOffsetX);
 889:                     $height = PHPExcel_Shared_Excel5::getDistanceY($this->_phpSheet, $startRow, $startOffsetY, $endRow, $endOffsetY);
 890: 
 891:                     // calculate offsetX and offsetY of the shape
 892:                     $offsetX = $startOffsetX * PHPExcel_Shared_Excel5::sizeCol($this->_phpSheet, $startColumn) / 1024;
 893:                     $offsetY = $startOffsetY * PHPExcel_Shared_Excel5::sizeRow($this->_phpSheet, $startRow) / 256;
 894: 
 895:                     switch ($obj['otObjType']) {
 896:                         case 0x19:
 897:                             // Note
 898: //                          echo 'Cell Annotation Object<br />';
 899: //                          echo 'Object ID is ',$obj['idObjID'],'<br />';
 900: //
 901:                             if (isset($this->_cellNotes[$obj['idObjID']])) {
 902:                                 $cellNote = $this->_cellNotes[$obj['idObjID']];
 903: 
 904:                                 if (isset($this->_textObjects[$obj['idObjID']])) {
 905:                                     $textObject = $this->_textObjects[$obj['idObjID']];
 906:                                     $this->_cellNotes[$obj['idObjID']]['objTextData'] = $textObject;
 907:                                 }
 908:                             }
 909:                             break;
 910: 
 911:                         case 0x08:
 912: //                          echo 'Picture Object<br />';
 913:                             // picture
 914: 
 915:                             // get index to BSE entry (1-based)
 916:                             $BSEindex = $spContainer->getOPT(0x0104);
 917:                             $BSECollection = $escherWorkbook->getDggContainer()->getBstoreContainer()->getBSECollection();
 918:                             $BSE = $BSECollection[$BSEindex - 1];
 919:                             $blipType = $BSE->getBlipType();
 920: 
 921:                             // need check because some blip types are not supported by Escher reader such as EMF
 922:                             if ($blip = $BSE->getBlip()) {
 923:                                 $ih = imagecreatefromstring($blip->getData());
 924:                                 $drawing = new PHPExcel_Worksheet_MemoryDrawing();
 925:                                 $drawing->setImageResource($ih);
 926: 
 927:                                 // width, height, offsetX, offsetY
 928:                                 $drawing->setResizeProportional(false);
 929:                                 $drawing->setWidth($width);
 930:                                 $drawing->setHeight($height);
 931:                                 $drawing->setOffsetX($offsetX);
 932:                                 $drawing->setOffsetY($offsetY);
 933: 
 934:                                 switch ($blipType) {
 935:                                     case PHPExcel_Shared_Escher_DggContainer_BstoreContainer_BSE::BLIPTYPE_JPEG:
 936:                                         $drawing->setRenderingFunction(PHPExcel_Worksheet_MemoryDrawing::RENDERING_JPEG);
 937:                                         $drawing->setMimeType(PHPExcel_Worksheet_MemoryDrawing::MIMETYPE_JPEG);
 938:                                         break;
 939: 
 940:                                     case PHPExcel_Shared_Escher_DggContainer_BstoreContainer_BSE::BLIPTYPE_PNG:
 941:                                         $drawing->setRenderingFunction(PHPExcel_Worksheet_MemoryDrawing::RENDERING_PNG);
 942:                                         $drawing->setMimeType(PHPExcel_Worksheet_MemoryDrawing::MIMETYPE_PNG);
 943:                                         break;
 944:                                 }
 945: 
 946:                                 $drawing->setWorksheet($this->_phpSheet);
 947:                                 $drawing->setCoordinates($spContainer->getStartCoordinates());
 948:                             }
 949: 
 950:                             break;
 951: 
 952:                         default:
 953:                             // other object type
 954:                             break;
 955: 
 956:                     }
 957:                 }
 958:             }
 959: 
 960:             // treat SHAREDFMLA records
 961:             if ($this->_version == self::XLS_BIFF8) {
 962:                 foreach ($this->_sharedFormulaParts as $cell => $baseCell) {
 963:                     list($column, $row) = PHPExcel_Cell::coordinateFromString($cell);
 964:                     if (($this->getReadFilter() !== NULL) && $this->getReadFilter()->readCell($column, $row, $this->_phpSheet->getTitle()) ) {
 965:                         $formula = $this->_getFormulaFromStructure($this->_sharedFormulas[$baseCell], $cell);
 966:                         $this->_phpSheet->getCell($cell)->setValueExplicit('=' . $formula, PHPExcel_Cell_DataType::TYPE_FORMULA);
 967:                     }
 968:                 }
 969:             }
 970: 
 971:             if (!empty($this->_cellNotes)) {
 972:                 foreach($this->_cellNotes as $note => $noteDetails) {
 973:                     if (!isset($noteDetails['objTextData'])) {
 974:                         if (isset($this->_textObjects[$note])) {
 975:                             $textObject = $this->_textObjects[$note];
 976:                             $noteDetails['objTextData'] = $textObject;
 977:                         } else {
 978:                             $noteDetails['objTextData']['text'] = '';
 979:                         }
 980:                     }
 981: //                  echo '<b>Cell annotation ',$note,'</b><br />';
 982: //                  var_dump($noteDetails);
 983: //                  echo '<br />';
 984:                     $cellAddress = str_replace('$','',$noteDetails['cellRef']);
 985:                     $this->_phpSheet->getComment( $cellAddress )
 986:                                                     ->setAuthor( $noteDetails['author'] )
 987:                                                     ->setText($this->_parseRichText($noteDetails['objTextData']['text']) );
 988:                 }
 989:             }
 990:         }
 991: 
 992:         // add the named ranges (defined names)
 993:         foreach ($this->_definedname as $definedName) {
 994:             if ($definedName['isBuiltInName']) {
 995:                 switch ($definedName['name']) {
 996: 
 997:                 case pack('C', 0x06):
 998:                     // print area
 999:                     //  in general, formula looks like this: Foo!$C$7:$J$66,Bar!$A$1:$IV$2
1000:                     $ranges = explode(',', $definedName['formula']); // FIXME: what if sheetname contains comma?
1001: 
1002:                     $extractedRanges = array();
1003:                     foreach ($ranges as $range) {
1004:                         // $range should look like one of these
1005:                         //      Foo!$C$7:$J$66
1006:                         //      Bar!$A$1:$IV$2
1007: 
1008:                         $explodes = explode('!', $range);   // FIXME: what if sheetname contains exclamation mark?
1009:                         $sheetName = trim($explodes[0], "'");
1010: 
1011:                         if (count($explodes) == 2) {
1012:                             if (strpos($explodes[1], ':') === FALSE) {
1013:                                 $explodes[1] = $explodes[1] . ':' . $explodes[1];
1014:                             }
1015:                             $extractedRanges[] = str_replace('$', '', $explodes[1]); // C7:J66
1016:                         }
1017:                     }
1018:                     if ($docSheet = $this->_phpExcel->getSheetByName($sheetName)) {
1019:                         $docSheet->getPageSetup()->setPrintArea(implode(',', $extractedRanges)); // C7:J66,A1:IV2
1020:                     }
1021:                     break;
1022: 
1023:                 case pack('C', 0x07):
1024:                     // print titles (repeating rows)
1025:                     // Assuming BIFF8, there are 3 cases
1026:                     // 1. repeating rows
1027:                     //      formula looks like this: Sheet!$A$1:$IV$2
1028:                     //      rows 1-2 repeat
1029:                     // 2. repeating columns
1030:                     //      formula looks like this: Sheet!$A$1:$B$65536
1031:                     //      columns A-B repeat
1032:                     // 3. both repeating rows and repeating columns
1033:                     //      formula looks like this: Sheet!$A$1:$B$65536,Sheet!$A$1:$IV$2
1034: 
1035:                     $ranges = explode(',', $definedName['formula']); // FIXME: what if sheetname contains comma?
1036: 
1037:                     foreach ($ranges as $range) {
1038:                         // $range should look like this one of these
1039:                         //      Sheet!$A$1:$B$65536
1040:                         //      Sheet!$A$1:$IV$2
1041: 
1042:                         $explodes = explode('!', $range);
1043: 
1044:                         if (count($explodes) == 2) {
1045:                             if ($docSheet = $this->_phpExcel->getSheetByName($explodes[0])) {
1046: 
1047:                                 $extractedRange = $explodes[1];
1048:                                 $extractedRange = str_replace('$', '', $extractedRange);
1049: 
1050:                                 $coordinateStrings = explode(':', $extractedRange);
1051:                                 if (count($coordinateStrings) == 2) {
1052:                                     list($firstColumn, $firstRow) = PHPExcel_Cell::coordinateFromString($coordinateStrings[0]);
1053:                                     list($lastColumn, $lastRow) = PHPExcel_Cell::coordinateFromString($coordinateStrings[1]);
1054: 
1055:                                     if ($firstColumn == 'A' and $lastColumn == 'IV') {
1056:                                         // then we have repeating rows
1057:                                         $docSheet->getPageSetup()->setRowsToRepeatAtTop(array($firstRow, $lastRow));
1058:                                     } elseif ($firstRow == 1 and $lastRow == 65536) {
1059:                                         // then we have repeating columns
1060:                                         $docSheet->getPageSetup()->setColumnsToRepeatAtLeft(array($firstColumn, $lastColumn));
1061:                                     }
1062:                                 }
1063:                             }
1064:                         }
1065:                     }
1066:                     break;
1067: 
1068:                 }
1069:             } else {
1070:                 // Extract range
1071:                 $explodes = explode('!', $definedName['formula']);
1072: 
1073:                 if (count($explodes) == 2) {
1074:                     if (($docSheet = $this->_phpExcel->getSheetByName($explodes[0])) ||
1075:                         ($docSheet = $this->_phpExcel->getSheetByName(trim($explodes[0],"'")))) {
1076:                         $extractedRange = $explodes[1];
1077:                         $extractedRange = str_replace('$', '', $extractedRange);
1078: 
1079:                         $localOnly = ($definedName['scope'] == 0) ? false : true;
1080: 
1081:                         $scope = ($definedName['scope'] == 0) ?
1082:                             null : $this->_phpExcel->getSheetByName($this->_sheets[$definedName['scope'] - 1]['name']);
1083: 
1084:                         $this->_phpExcel->addNamedRange( new PHPExcel_NamedRange((string)$definedName['name'], $docSheet, $extractedRange, $localOnly, $scope) );
1085:                     }
1086:                 } else {
1087:                     //  Named Value
1088:                     //  TODO Provide support for named values
1089:                 }
1090:             }
1091:         }
1092: 
1093:         return $this->_phpExcel;
1094:     }
1095:     
1096:     /**
1097:      * Read record data from stream, decrypting as required
1098:      * 
1099:      * @param string $data   Data stream to read from
1100:      * @param int    $pos    Position to start reading from
1101:      * @param int    $length Record data length
1102:      * 
1103:      * @return string Record data
1104:      */
1105:     private function _readRecordData($data, $pos, $len)
1106:     {
1107:         $data = substr($data, $pos, $len);
1108:         
1109:         // File not encrypted, or record before encryption start point
1110:         if ($this->_encryption == self::MS_BIFF_CRYPTO_NONE || $pos < $this->_encryptionStartPos) {
1111:             return $data;
1112:         }
1113:     
1114:         $recordData = '';
1115:         if ($this->_encryption == self::MS_BIFF_CRYPTO_RC4) {
1116: 
1117:             $oldBlock = floor($this->_rc4Pos / self::REKEY_BLOCK);
1118:             $block = floor($pos / self::REKEY_BLOCK);
1119:             $endBlock = floor(($pos + $len) / self::REKEY_BLOCK);
1120: 
1121:             // Spin an RC4 decryptor to the right spot. If we have a decryptor sitting
1122:             // at a point earlier in the current block, re-use it as we can save some time.
1123:             if ($block != $oldBlock || $pos < $this->_rc4Pos || !$this->_rc4Key) {
1124:                 $this->_rc4Key = $this->_makeKey($block, $this->_md5Ctxt);
1125:                 $step = $pos % self::REKEY_BLOCK;
1126:             } else {
1127:                 $step = $pos - $this->_rc4Pos;
1128:             }
1129:             $this->_rc4Key->RC4(str_repeat("\0", $step));
1130: 
1131:             // Decrypt record data (re-keying at the end of every block)
1132:             while ($block != $endBlock) {
1133:                 $step = self::REKEY_BLOCK - ($pos % self::REKEY_BLOCK);
1134:                 $recordData .= $this->_rc4Key->RC4(substr($data, 0, $step));
1135:                 $data = substr($data, $step);
1136:                 $pos += $step;
1137:                 $len -= $step;
1138:                 $block++;
1139:                 $this->_rc4Key = $this->_makeKey($block, $this->_md5Ctxt);
1140:             }
1141:             $recordData .= $this->_rc4Key->RC4(substr($data, 0, $len));
1142: 
1143:             // Keep track of the position of this decryptor.
1144:             // We'll try and re-use it later if we can to speed things up
1145:             $this->_rc4Pos = $pos + $len;
1146:             
1147:         } elseif ($this->_encryption == self::MS_BIFF_CRYPTO_XOR) {
1148:             throw new PHPExcel_Reader_Exception('XOr encryption not supported');
1149:         }
1150:         return $recordData;
1151:     }
1152: 
1153:     /**
1154:      * Use OLE reader to extract the relevant data streams from the OLE file
1155:      *
1156:      * @param string $pFilename
1157:      */
1158:     private function _loadOLE($pFilename)
1159:     {
1160:         // OLE reader
1161:         $ole = new PHPExcel_Shared_OLERead();
1162: 
1163:         // get excel data,
1164:         $res = $ole->read($pFilename);
1165:         // Get workbook data: workbook stream + sheet streams
1166:         $this->_data = $ole->getStream($ole->wrkbook);
1167: 
1168:         // Get summary information data
1169:         $this->_summaryInformation = $ole->getStream($ole->summaryInformation);
1170: 
1171:         // Get additional document summary information data
1172:         $this->_documentSummaryInformation = $ole->getStream($ole->documentSummaryInformation);
1173: 
1174:         // Get user-defined property data
1175: //      $this->_userDefinedProperties = $ole->getUserDefinedProperties();
1176:     }
1177: 
1178: 
1179:     /**
1180:      * Read summary information
1181:      */
1182:     private function _readSummaryInformation()
1183:     {
1184:         if (!isset($this->_summaryInformation)) {
1185:             return;
1186:         }
1187: 
1188:         // offset: 0; size: 2; must be 0xFE 0xFF (UTF-16 LE byte order mark)
1189:         // offset: 2; size: 2;
1190:         // offset: 4; size: 2; OS version
1191:         // offset: 6; size: 2; OS indicator
1192:         // offset: 8; size: 16
1193:         // offset: 24; size: 4; section count
1194:         $secCount = self::_GetInt4d($this->_summaryInformation, 24);
1195: 
1196:         // offset: 28; size: 16; first section's class id: e0 85 9f f2 f9 4f 68 10 ab 91 08 00 2b 27 b3 d9
1197:         // offset: 44; size: 4
1198:         $secOffset = self::_GetInt4d($this->_summaryInformation, 44);
1199: 
1200:         // section header
1201:         // offset: $secOffset; size: 4; section length
1202:         $secLength = self::_GetInt4d($this->_summaryInformation, $secOffset);
1203: 
1204:         // offset: $secOffset+4; size: 4; property count
1205:         $countProperties = self::_GetInt4d($this->_summaryInformation, $secOffset+4);
1206: 
1207:         // initialize code page (used to resolve string values)
1208:         $codePage = 'CP1252';
1209: 
1210:         // offset: ($secOffset+8); size: var
1211:         // loop through property decarations and properties
1212:         for ($i = 0; $i < $countProperties; ++$i) {
1213: 
1214:             // offset: ($secOffset+8) + (8 * $i); size: 4; property ID
1215:             $id = self::_GetInt4d($this->_summaryInformation, ($secOffset+8) + (8 * $i));
1216: 
1217:             // Use value of property id as appropriate
1218:             // offset: ($secOffset+12) + (8 * $i); size: 4; offset from beginning of section (48)
1219:             $offset = self::_GetInt4d($this->_summaryInformation, ($secOffset+12) + (8 * $i));
1220: 
1221:             $type = self::_GetInt4d($this->_summaryInformation, $secOffset + $offset);
1222: 
1223:             // initialize property value
1224:             $value = null;
1225: 
1226:             // extract property value based on property type
1227:             switch ($type) {
1228:                 case 0x02: // 2 byte signed integer
1229:                     $value = self::_GetInt2d($this->_summaryInformation, $secOffset + 4 + $offset);
1230:                     break;
1231: 
1232:                 case 0x03: // 4 byte signed integer
1233:                     $value = self::_GetInt4d($this->_summaryInformation, $secOffset + 4 + $offset);
1234:                     break;
1235: 
1236:                 case 0x13: // 4 byte unsigned integer
1237:                     // not needed yet, fix later if necessary
1238:                     break;
1239: 
1240:                 case 0x1E: // null-terminated string prepended by dword string length
1241:                     $byteLength = self::_GetInt4d($this->_summaryInformation, $secOffset + 4 + $offset);
1242:                     $value = substr($this->_summaryInformation, $secOffset + 8 + $offset, $byteLength);
1243:                     $value = PHPExcel_Shared_String::ConvertEncoding($value, 'UTF-8', $codePage);
1244:                     $value = rtrim($value);
1245:                     break;
1246: 
1247:                 case 0x40: // Filetime (64-bit value representing the number of 100-nanosecond intervals since January 1, 1601)
1248:                     // PHP-time
1249:                     $value = PHPExcel_Shared_OLE::OLE2LocalDate(substr($this->_summaryInformation, $secOffset + 4 + $offset, 8));
1250:                     break;
1251: 
1252:                 case 0x47: // Clipboard format
1253:                     // not needed yet, fix later if necessary
1254:                     break;
1255:             }
1256: 
1257:             switch ($id) {
1258:                 case 0x01:  //  Code Page
1259:                     $codePage = PHPExcel_Shared_CodePage::NumberToName($value);
1260:                     break;
1261: 
1262:                 case 0x02:  //  Title
1263:                     $this->_phpExcel->getProperties()->setTitle($value);
1264:                     break;
1265: 
1266:                 case 0x03:  //  Subject
1267:                     $this->_phpExcel->getProperties()->setSubject($value);
1268:                     break;
1269: 
1270:                 case 0x04:  //  Author (Creator)
1271:                     $this->_phpExcel->getProperties()->setCreator($value);
1272:                     break;
1273: 
1274:                 case 0x05:  //  Keywords
1275:                     $this->_phpExcel->getProperties()->setKeywords($value);
1276:                     break;
1277: 
1278:                 case 0x06:  //  Comments (Description)
1279:                     $this->_phpExcel->getProperties()->setDescription($value);
1280:                     break;
1281: 
1282:                 case 0x07:  //  Template
1283:                     //  Not supported by PHPExcel
1284:                     break;
1285: 
1286:                 case 0x08:  //  Last Saved By (LastModifiedBy)
1287:                     $this->_phpExcel->getProperties()->setLastModifiedBy($value);
1288:                     break;
1289: 
1290:                 case 0x09:  //  Revision
1291:                     //  Not supported by PHPExcel
1292:                     break;
1293: 
1294:                 case 0x0A:  //  Total Editing Time
1295:                     //  Not supported by PHPExcel
1296:                     break;
1297: 
1298:                 case 0x0B:  //  Last Printed
1299:                     //  Not supported by PHPExcel
1300:                     break;
1301: 
1302:                 case 0x0C:  //  Created Date/Time
1303:                     $this->_phpExcel->getProperties()->setCreated($value);
1304:                     break;
1305: 
1306:                 case 0x0D:  //  Modified Date/Time
1307:                     $this->_phpExcel->getProperties()->setModified($value);
1308:                     break;
1309: 
1310:                 case 0x0E:  //  Number of Pages
1311:                     //  Not supported by PHPExcel
1312:                     break;
1313: 
1314:                 case 0x0F:  //  Number of Words
1315:                     //  Not supported by PHPExcel
1316:                     break;
1317: 
1318:                 case 0x10:  //  Number of Characters
1319:                     //  Not supported by PHPExcel
1320:                     break;
1321: 
1322:                 case 0x11:  //  Thumbnail
1323:                     //  Not supported by PHPExcel
1324:                     break;
1325: 
1326:                 case 0x12:  //  Name of creating application
1327:                     //  Not supported by PHPExcel
1328:                     break;
1329: 
1330:                 case 0x13:  //  Security
1331:                     //  Not supported by PHPExcel
1332:                     break;
1333: 
1334:             }
1335:         }
1336:     }
1337: 
1338: 
1339:     /**
1340:      * Read additional document summary information
1341:      */
1342:     private function _readDocumentSummaryInformation()
1343:     {
1344:         if (!isset($this->_documentSummaryInformation)) {
1345:             return;
1346:         }
1347: 
1348:         //  offset: 0;  size: 2;    must be 0xFE 0xFF (UTF-16 LE byte order mark)
1349:         //  offset: 2;  size: 2;
1350:         //  offset: 4;  size: 2;    OS version
1351:         //  offset: 6;  size: 2;    OS indicator
1352:         //  offset: 8;  size: 16
1353:         //  offset: 24; size: 4;    section count
1354:         $secCount = self::_GetInt4d($this->_documentSummaryInformation, 24);
1355: //      echo '$secCount = ',$secCount,'<br />';
1356: 
1357:         // offset: 28;  size: 16;   first section's class id: 02 d5 cd d5 9c 2e 1b 10 93 97 08 00 2b 2c f9 ae
1358:         // offset: 44;  size: 4;    first section offset
1359:         $secOffset = self::_GetInt4d($this->_documentSummaryInformation, 44);
1360: //      echo '$secOffset = ',$secOffset,'<br />';
1361: 
1362:         //  section header
1363:         //  offset: $secOffset; size: 4;    section length
1364:         $secLength = self::_GetInt4d($this->_documentSummaryInformation, $secOffset);
1365: //      echo '$secLength = ',$secLength,'<br />';
1366: 
1367:         //  offset: $secOffset+4;   size: 4;    property count
1368:         $countProperties = self::_GetInt4d($this->_documentSummaryInformation, $secOffset+4);
1369: //      echo '$countProperties = ',$countProperties,'<br />';
1370: 
1371:         // initialize code page (used to resolve string values)
1372:         $codePage = 'CP1252';
1373: 
1374:         //  offset: ($secOffset+8); size: var
1375:         //  loop through property decarations and properties
1376:         for ($i = 0; $i < $countProperties; ++$i) {
1377: //          echo 'Property ',$i,'<br />';
1378:             //  offset: ($secOffset+8) + (8 * $i);  size: 4;    property ID
1379:             $id = self::_GetInt4d($this->_documentSummaryInformation, ($secOffset+8) + (8 * $i));
1380: //          echo 'ID is ',$id,'<br />';
1381: 
1382:             // Use value of property id as appropriate
1383:             // offset: 60 + 8 * $i; size: 4;    offset from beginning of section (48)
1384:             $offset = self::_GetInt4d($this->_documentSummaryInformation, ($secOffset+12) + (8 * $i));
1385: 
1386:             $type = self::_GetInt4d($this->_documentSummaryInformation, $secOffset + $offset);
1387: //          echo 'Type is ',$type,', ';
1388: 
1389:             // initialize property value
1390:             $value = null;
1391: 
1392:             // extract property value based on property type
1393:             switch ($type) {
1394:                 case 0x02:  //  2 byte signed integer
1395:                     $value = self::_GetInt2d($this->_documentSummaryInformation, $secOffset + 4 + $offset);
1396:                     break;
1397: 
1398:                 case 0x03:  //  4 byte signed integer
1399:                     $value = self::_GetInt4d($this->_documentSummaryInformation, $secOffset + 4 + $offset);
1400:                     break;
1401: 
1402:                 case 0x0B:  // Boolean
1403:                     $value = self::_GetInt2d($this->_documentSummaryInformation, $secOffset + 4 + $offset);
1404:                     $value = ($value == 0 ? false : true);
1405:                     break;
1406: 
1407:                 case 0x13:  //  4 byte unsigned integer
1408:                     // not needed yet, fix later if necessary
1409:                     break;
1410: 
1411:                 case 0x1E:  //  null-terminated string prepended by dword string length
1412:                     $byteLength = self::_GetInt4d($this->_documentSummaryInformation, $secOffset + 4 + $offset);
1413:                     $value = substr($this->_documentSummaryInformation, $secOffset + 8 + $offset, $byteLength);
1414:                     $value = PHPExcel_Shared_String::ConvertEncoding($value, 'UTF-8', $codePage);
1415:                     $value = rtrim($value);
1416:                     break;
1417: 
1418:                 case 0x40:  //  Filetime (64-bit value representing the number of 100-nanosecond intervals since January 1, 1601)
1419:                     // PHP-Time
1420:                     $value = PHPExcel_Shared_OLE::OLE2LocalDate(substr($this->_documentSummaryInformation, $secOffset + 4 + $offset, 8));
1421:                     break;
1422: 
1423:                 case 0x47:  //  Clipboard format
1424:                     // not needed yet, fix later if necessary
1425:                     break;
1426:             }
1427: 
1428:             switch ($id) {
1429:                 case 0x01:  //  Code Page
1430:                     $codePage = PHPExcel_Shared_CodePage::NumberToName($value);
1431:                     break;
1432: 
1433:                 case 0x02:  //  Category
1434:                     $this->_phpExcel->getProperties()->setCategory($value);
1435:                     break;
1436: 
1437:                 case 0x03:  //  Presentation Target
1438:                     //  Not supported by PHPExcel
1439:                     break;
1440: 
1441:                 case 0x04:  //  Bytes
1442:                     //  Not supported by PHPExcel
1443:                     break;
1444: 
1445:                 case 0x05:  //  Lines
1446:                     //  Not supported by PHPExcel
1447:                     break;
1448: 
1449:                 case 0x06:  //  Paragraphs
1450:                     //  Not supported by PHPExcel
1451:                     break;
1452: 
1453:                 case 0x07:  //  Slides
1454:                     //  Not supported by PHPExcel
1455:                     break;
1456: 
1457:                 case 0x08:  //  Notes
1458:                     //  Not supported by PHPExcel
1459:                     break;
1460: 
1461:                 case 0x09:  //  Hidden Slides
1462:                     //  Not supported by PHPExcel
1463:                     break;
1464: 
1465:                 case 0x0A:  //  MM Clips
1466:                     //  Not supported by PHPExcel
1467:                     break;
1468: 
1469:                 case 0x0B:  //  Scale Crop
1470:                     //  Not supported by PHPExcel
1471:                     break;
1472: 
1473:                 case 0x0C:  //  Heading Pairs
1474:                     //  Not supported by PHPExcel
1475:                     break;
1476: 
1477:                 case 0x0D:  //  Titles of Parts
1478:                     //  Not supported by PHPExcel
1479:                     break;
1480: 
1481:                 case 0x0E:  //  Manager
1482:                     $this->_phpExcel->getProperties()->setManager($value);
1483:                     break;
1484: 
1485:                 case 0x0F:  //  Company
1486:                     $this->_phpExcel->getProperties()->setCompany($value);
1487:                     break;
1488: 
1489:                 case 0x10:  //  Links up-to-date
1490:                     //  Not supported by PHPExcel
1491:                     break;
1492: 
1493:             }
1494:         }
1495:     }
1496: 
1497: 
1498:     /**
1499:      * Reads a general type of BIFF record. Does nothing except for moving stream pointer forward to next record.
1500:      */
1501:     private function _readDefault()
1502:     {
1503:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
1504: //      $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
1505: 
1506:         // move stream pointer to next record
1507:         $this->_pos += 4 + $length;
1508:     }
1509: 
1510: 
1511:     /**
1512:      *  The NOTE record specifies a comment associated with a particular cell. In Excel 95 (BIFF7) and earlier versions,
1513:      *      this record stores a note (cell note). This feature was significantly enhanced in Excel 97.
1514:      */
1515:     private function _readNote()
1516:     {
1517: //      echo '<b>Read Cell Annotation</b><br />';
1518:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
1519:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
1520: 
1521:         // move stream pointer to next record
1522:         $this->_pos += 4 + $length;
1523: 
1524:         if ($this->_readDataOnly) {
1525:             return;
1526:         }
1527: 
1528:         $cellAddress = $this->_readBIFF8CellAddress(substr($recordData, 0, 4));
1529:         if ($this->_version == self::XLS_BIFF8) {
1530:             $noteObjID = self::_GetInt2d($recordData, 6);
1531:             $noteAuthor = self::_readUnicodeStringLong(substr($recordData, 8));
1532:             $noteAuthor = $noteAuthor['value'];
1533: //          echo 'Note Address=',$cellAddress,'<br />';
1534: //          echo 'Note Object ID=',$noteObjID,'<br />';
1535: //          echo 'Note Author=',$noteAuthor,'<hr />';
1536: //
1537:             $this->_cellNotes[$noteObjID] = array('cellRef'     => $cellAddress,
1538:                                                   'objectID'    => $noteObjID,
1539:                                                   'author'      => $noteAuthor
1540:                                                  );
1541:         } else {
1542:             $extension = false;
1543:             if ($cellAddress == '$B$65536') {
1544:                 //  If the address row is -1 and the column is 0, (which translates as $B$65536) then this is a continuation
1545:                 //      note from the previous cell annotation. We're not yet handling this, so annotations longer than the
1546:                 //      max 2048 bytes will probably throw a wobbly.
1547:                 $row = self::_GetInt2d($recordData, 0);
1548:                 $extension = true;
1549:                 $cellAddress = array_pop(array_keys($this->_phpSheet->getComments()));
1550:             }
1551: //          echo 'Note Address=',$cellAddress,'<br />';
1552: 
1553:             $cellAddress = str_replace('$','',$cellAddress);
1554:             $noteLength = self::_GetInt2d($recordData, 4);
1555:             $noteText = trim(substr($recordData, 6));
1556: //          echo 'Note Length=',$noteLength,'<br />';
1557: //          echo 'Note Text=',$noteText,'<br />';
1558: 
1559:             if ($extension) {
1560:                 //  Concatenate this extension with the currently set comment for the cell
1561:                 $comment = $this->_phpSheet->getComment( $cellAddress );
1562:                 $commentText = $comment->getText()->getPlainText();
1563:                 $comment->setText($this->_parseRichText($commentText.$noteText) );
1564:             } else {
1565:                 //  Set comment for the cell
1566:                 $this->_phpSheet->getComment( $cellAddress )
1567: //                                                  ->setAuthor( $author )
1568:                                                     ->setText($this->_parseRichText($noteText) );
1569:             }
1570:         }
1571: 
1572:     }
1573: 
1574: 
1575:     /**
1576:      *  The TEXT Object record contains the text associated with a cell annotation.
1577:      */
1578:     private function _readTextObject()
1579:     {
1580:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
1581:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
1582: 
1583:         // move stream pointer to next record
1584:         $this->_pos += 4 + $length;
1585: 
1586:         if ($this->_readDataOnly) {
1587:             return;
1588:         }
1589: 
1590:         // recordData consists of an array of subrecords looking like this:
1591:         //  grbit: 2 bytes; Option Flags
1592:         //  rot: 2 bytes; rotation
1593:         //  cchText: 2 bytes; length of the text (in the first continue record)
1594:         //  cbRuns: 2 bytes; length of the formatting (in the second continue record)
1595:         // followed by the continuation records containing the actual text and formatting
1596:         $grbitOpts  = self::_GetInt2d($recordData, 0);
1597:         $rot        = self::_GetInt2d($recordData, 2);
1598:         $cchText    = self::_GetInt2d($recordData, 10);
1599:         $cbRuns     = self::_GetInt2d($recordData, 12);
1600:         $text       = $this->_getSplicedRecordData();
1601: 
1602:         $this->_textObjects[$this->textObjRef] = array(
1603:                 'text'      => substr($text["recordData"],$text["spliceOffsets"][0]+1,$cchText),
1604:                 'format'    => substr($text["recordData"],$text["spliceOffsets"][1],$cbRuns),
1605:                 'alignment' => $grbitOpts,
1606:                 'rotation'  => $rot
1607:              );
1608: 
1609: //      echo '<b>_readTextObject()</b><br />';
1610: //      var_dump($this->_textObjects[$this->textObjRef]);
1611: //      echo '<br />';
1612:     }
1613: 
1614: 
1615:     /**
1616:      * Read BOF
1617:      */
1618:     private function _readBof()
1619:     {
1620:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
1621:         $recordData = substr($this->_data, $this->_pos + 4, $length);
1622: 
1623:         // move stream pointer to next record
1624:         $this->_pos += 4 + $length;
1625: 
1626:         // offset: 2; size: 2; type of the following data
1627:         $substreamType = self::_GetInt2d($recordData, 2);
1628: 
1629:         switch ($substreamType) {
1630:             case self::XLS_WorkbookGlobals:
1631:                 $version = self::_GetInt2d($recordData, 0);
1632:                 if (($version != self::XLS_BIFF8) && ($version != self::XLS_BIFF7)) {
1633:                     throw new PHPExcel_Reader_Exception('Cannot read this Excel file. Version is too old.');
1634:                 }
1635:                 $this->_version = $version;
1636:                 break;
1637: 
1638:             case self::XLS_Worksheet:
1639:                 // do not use this version information for anything
1640:                 // it is unreliable (OpenOffice doc, 5.8), use only version information from the global stream
1641:                 break;
1642: 
1643:             default:
1644:                 // substream, e.g. chart
1645:                 // just skip the entire substream
1646:                 do {
1647:                     $code = self::_GetInt2d($this->_data, $this->_pos);
1648:                     $this->_readDefault();
1649:                 } while ($code != self::XLS_Type_EOF && $this->_pos < $this->_dataSize);
1650:                 break;
1651:         }
1652:     }
1653: 
1654: 
1655:     /**
1656:      * FILEPASS
1657:      *
1658:      * This record is part of the File Protection Block. It
1659:      * contains information about the read/write password of the
1660:      * file. All record contents following this record will be
1661:      * encrypted.
1662:      *
1663:      * --   "OpenOffice.org's Documentation of the Microsoft
1664:      *      Excel File Format"
1665:      * 
1666:      * The decryption functions and objects used from here on in
1667:      * are based on the source of Spreadsheet-ParseExcel:
1668:      * http://search.cpan.org/~jmcnamara/Spreadsheet-ParseExcel/
1669:      */
1670:     private function _readFilepass()
1671:     {
1672:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
1673: 
1674:         if ($length != 54) {
1675:             throw new PHPExcel_Reader_Exception('Unexpected file pass record length');
1676:         }
1677:         
1678:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
1679:         
1680:         // move stream pointer to next record
1681:         $this->_pos += 4 + $length;
1682:         
1683:         if (!$this->_verifyPassword(
1684:             'VelvetSweatshop',
1685:             substr($recordData, 6,  16),
1686:             substr($recordData, 22, 16),
1687:             substr($recordData, 38, 16),
1688:             $this->_md5Ctxt
1689:         )) {
1690:             throw new PHPExcel_Reader_Exception('Decryption password incorrect');
1691:         }
1692:         
1693:         $this->_encryption = self::MS_BIFF_CRYPTO_RC4;
1694: 
1695:         // Decryption required from the record after next onwards
1696:         $this->_encryptionStartPos = $this->_pos + self::_GetInt2d($this->_data, $this->_pos + 2);
1697:     }
1698: 
1699:     /**
1700:      * Make an RC4 decryptor for the given block
1701:      * 
1702:      * @var int    $block      Block for which to create decrypto
1703:      * @var string $valContext MD5 context state
1704:      * 
1705:      * @return PHPExcel_Reader_Excel5_RC4
1706:      */
1707:     private function _makeKey($block, $valContext)
1708:     {
1709:         $pwarray = str_repeat("\0", 64);
1710: 
1711:         for ($i = 0; $i < 5; $i++) {
1712:             $pwarray[$i] = $valContext[$i];
1713:         }
1714:         
1715:         $pwarray[5] = chr($block & 0xff);
1716:         $pwarray[6] = chr(($block >> 8) & 0xff);
1717:         $pwarray[7] = chr(($block >> 16) & 0xff);
1718:         $pwarray[8] = chr(($block >> 24) & 0xff);
1719: 
1720:         $pwarray[9] = "\x80";
1721:         $pwarray[56] = "\x48";
1722: 
1723:         $md5 = new PHPExcel_Reader_Excel5_MD5();
1724:         $md5->add($pwarray);
1725: 
1726:         $s = $md5->getContext();
1727:         return new PHPExcel_Reader_Excel5_RC4($s);
1728:     }
1729: 
1730:     /**
1731:      * Verify RC4 file password
1732:      * 
1733:      * @var string $password        Password to check
1734:      * @var string $docid           Document id
1735:      * @var string $salt_data       Salt data
1736:      * @var string $hashedsalt_data Hashed salt data
1737:      * @var string &$valContext     Set to the MD5 context of the value
1738:      * 
1739:      * @return bool Success
1740:      */
1741:     private function _verifyPassword($password, $docid, $salt_data, $hashedsalt_data, &$valContext)
1742:     {
1743:         $pwarray = str_repeat("\0", 64);
1744: 
1745:         for ($i = 0; $i < strlen($password); $i++) {
1746:             $o = ord(substr($password, $i, 1));
1747:             $pwarray[2 * $i] = chr($o & 0xff);
1748:             $pwarray[2 * $i + 1] = chr(($o >> 8) & 0xff);
1749:         }
1750:         $pwarray[2 * $i] = chr(0x80);
1751:         $pwarray[56] = chr(($i << 4) & 0xff);
1752: 
1753:         $md5 = new PHPExcel_Reader_Excel5_MD5();
1754:         $md5->add($pwarray);
1755: 
1756:         $mdContext1 = $md5->getContext();
1757: 
1758:         $offset = 0;
1759:         $keyoffset = 0;
1760:         $tocopy = 5;
1761: 
1762:         $md5->reset();
1763: 
1764:         while ($offset != 16) {
1765:             if ((64 - $offset) < 5) {
1766:                 $tocopy = 64 - $offset;
1767:             }
1768:             
1769:             for ($i = 0; $i <= $tocopy; $i++) {
1770:                 $pwarray[$offset + $i] = $mdContext1[$keyoffset + $i];
1771:             }
1772: 
1773:             $offset += $tocopy;
1774: 
1775:             if ($offset == 64) {
1776:                 $md5->add($pwarray);
1777:                 $keyoffset = $tocopy;
1778:                 $tocopy = 5 - $tocopy;
1779:                 $offset = 0;
1780:                 continue;
1781:             }
1782: 
1783:             $keyoffset = 0;
1784:             $tocopy = 5;
1785:             for ($i = 0; $i < 16; $i++) {
1786:                 $pwarray[$offset + $i] = $docid[$i];
1787:             }
1788:             $offset += 16;
1789:         }
1790: 
1791:         $pwarray[16] = "\x80";
1792:         for ($i = 0; $i < 47; $i++) {
1793:             $pwarray[17 + $i] = "\0";
1794:         }
1795:         $pwarray[56] = "\x80";
1796:         $pwarray[57] = "\x0a";
1797: 
1798:         $md5->add($pwarray);
1799:         $valContext = $md5->getContext();
1800: 
1801:         $key = $this->_makeKey(0, $valContext);
1802: 
1803:         $salt = $key->RC4($salt_data);
1804:         $hashedsalt = $key->RC4($hashedsalt_data);
1805:         
1806:         $salt .= "\x80" . str_repeat("\0", 47);
1807:         $salt[56] = "\x80";
1808: 
1809:         $md5->reset();
1810:         $md5->add($salt);
1811:         $mdContext2 = $md5->getContext();
1812: 
1813:         return $mdContext2 == $hashedsalt;
1814:     }
1815: 
1816:     /**
1817:      * CODEPAGE
1818:      *
1819:      * This record stores the text encoding used to write byte
1820:      * strings, stored as MS Windows code page identifier.
1821:      *
1822:      * --   "OpenOffice.org's Documentation of the Microsoft
1823:      *      Excel File Format"
1824:      */
1825:     private function _readCodepage()
1826:     {
1827:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
1828:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
1829: 
1830:         // move stream pointer to next record
1831:         $this->_pos += 4 + $length;
1832: 
1833:         // offset: 0; size: 2; code page identifier
1834:         $codepage = self::_GetInt2d($recordData, 0);
1835: 
1836:         $this->_codepage = PHPExcel_Shared_CodePage::NumberToName($codepage);
1837:     }
1838: 
1839: 
1840:     /**
1841:      * DATEMODE
1842:      *
1843:      * This record specifies the base date for displaying date
1844:      * values. All dates are stored as count of days past this
1845:      * base date. In BIFF2-BIFF4 this record is part of the
1846:      * Calculation Settings Block. In BIFF5-BIFF8 it is
1847:      * stored in the Workbook Globals Substream.
1848:      *
1849:      * --   "OpenOffice.org's Documentation of the Microsoft
1850:      *      Excel File Format"
1851:      */
1852:     private function _readDateMode()
1853:     {
1854:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
1855:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
1856: 
1857:         // move stream pointer to next record
1858:         $this->_pos += 4 + $length;
1859: 
1860:         // offset: 0; size: 2; 0 = base 1900, 1 = base 1904
1861:         PHPExcel_Shared_Date::setExcelCalendar(PHPExcel_Shared_Date::CALENDAR_WINDOWS_1900);
1862:         if (ord($recordData{0}) == 1) {
1863:             PHPExcel_Shared_Date::setExcelCalendar(PHPExcel_Shared_Date::CALENDAR_MAC_1904);
1864:         }
1865:     }
1866: 
1867: 
1868:     /**
1869:      * Read a FONT record
1870:      */
1871:     private function _readFont()
1872:     {
1873:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
1874:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
1875: 
1876:         // move stream pointer to next record
1877:         $this->_pos += 4 + $length;
1878: 
1879:         if (!$this->_readDataOnly) {
1880:             $objFont = new PHPExcel_Style_Font();
1881: 
1882:             // offset: 0; size: 2; height of the font (in twips = 1/20 of a point)
1883:             $size = self::_GetInt2d($recordData, 0);
1884:             $objFont->setSize($size / 20);
1885: 
1886:             // offset: 2; size: 2; option flags
1887:                 // bit: 0; mask 0x0001; bold (redundant in BIFF5-BIFF8)
1888:                 // bit: 1; mask 0x0002; italic
1889:                 $isItalic = (0x0002 & self::_GetInt2d($recordData, 2)) >> 1;
1890:                 if ($isItalic) $objFont->setItalic(true);
1891: 
1892:                 // bit: 2; mask 0x0004; underlined (redundant in BIFF5-BIFF8)
1893:                 // bit: 3; mask 0x0008; strike
1894:                 $isStrike = (0x0008 & self::_GetInt2d($recordData, 2)) >> 3;
1895:                 if ($isStrike) $objFont->setStrikethrough(true);
1896: 
1897:             // offset: 4; size: 2; colour index
1898:             $colorIndex = self::_GetInt2d($recordData, 4);
1899:             $objFont->colorIndex = $colorIndex;
1900: 
1901:             // offset: 6; size: 2; font weight
1902:             $weight = self::_GetInt2d($recordData, 6);
1903:             switch ($weight) {
1904:                 case 0x02BC:
1905:                     $objFont->setBold(true);
1906:                     break;
1907:             }
1908: 
1909:             // offset: 8; size: 2; escapement type
1910:             $escapement = self::_GetInt2d($recordData, 8);
1911:             switch ($escapement) {
1912:                 case 0x0001:
1913:                     $objFont->setSuperScript(true);
1914:                     break;
1915:                 case 0x0002:
1916:                     $objFont->setSubScript(true);
1917:                     break;
1918:             }
1919: 
1920:             // offset: 10; size: 1; underline type
1921:             $underlineType = ord($recordData{10});
1922:             switch ($underlineType) {
1923:                 case 0x00:
1924:                     break; // no underline
1925:                 case 0x01:
1926:                     $objFont->setUnderline(PHPExcel_Style_Font::UNDERLINE_SINGLE);
1927:                     break;
1928:                 case 0x02:
1929:                     $objFont->setUnderline(PHPExcel_Style_Font::UNDERLINE_DOUBLE);
1930:                     break;
1931:                 case 0x21:
1932:                     $objFont->setUnderline(PHPExcel_Style_Font::UNDERLINE_SINGLEACCOUNTING);
1933:                     break;
1934:                 case 0x22:
1935:                     $objFont->setUnderline(PHPExcel_Style_Font::UNDERLINE_DOUBLEACCOUNTING);
1936:                     break;
1937:             }
1938: 
1939:             // offset: 11; size: 1; font family
1940:             // offset: 12; size: 1; character set
1941:             // offset: 13; size: 1; not used
1942:             // offset: 14; size: var; font name
1943:             if ($this->_version == self::XLS_BIFF8) {
1944:                 $string = self::_readUnicodeStringShort(substr($recordData, 14));
1945:             } else {
1946:                 $string = $this->_readByteStringShort(substr($recordData, 14));
1947:             }
1948:             $objFont->setName($string['value']);
1949: 
1950:             $this->_objFonts[] = $objFont;
1951:         }
1952:     }
1953: 
1954: 
1955:     /**
1956:      * FORMAT
1957:      *
1958:      * This record contains information about a number format.
1959:      * All FORMAT records occur together in a sequential list.
1960:      *
1961:      * In BIFF2-BIFF4 other records referencing a FORMAT record
1962:      * contain a zero-based index into this list. From BIFF5 on
1963:      * the FORMAT record contains the index itself that will be
1964:      * used by other records.
1965:      *
1966:      * --   "OpenOffice.org's Documentation of the Microsoft
1967:      *      Excel File Format"
1968:      */
1969:     private function _readFormat()
1970:     {
1971:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
1972:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
1973: 
1974:         // move stream pointer to next record
1975:         $this->_pos += 4 + $length;
1976: 
1977:         if (!$this->_readDataOnly) {
1978:             $indexCode = self::_GetInt2d($recordData, 0);
1979: 
1980:             if ($this->_version == self::XLS_BIFF8) {
1981:                 $string = self::_readUnicodeStringLong(substr($recordData, 2));
1982:             } else {
1983:                 // BIFF7
1984:                 $string = $this->_readByteStringShort(substr($recordData, 2));
1985:             }
1986: 
1987:             $formatString = $string['value'];
1988:             $this->_formats[$indexCode] = $formatString;
1989:         }
1990:     }
1991: 
1992: 
1993:     /**
1994:      * XF - Extended Format
1995:      *
1996:      * This record contains formatting information for cells, rows, columns or styles.
1997:      * According to http://support.microsoft.com/kb/147732 there are always at least 15 cell style XF
1998:      * and 1 cell XF.
1999:      * Inspection of Excel files generated by MS Office Excel shows that XF records 0-14 are cell style XF
2000:      * and XF record 15 is a cell XF
2001:      * We only read the first cell style XF and skip the remaining cell style XF records
2002:      * We read all cell XF records.
2003:      *
2004:      * --   "OpenOffice.org's Documentation of the Microsoft
2005:      *      Excel File Format"
2006:      */
2007:     private function _readXf()
2008:     {
2009:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
2010:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
2011: 
2012:         // move stream pointer to next record
2013:         $this->_pos += 4 + $length;
2014: 
2015:         $objStyle = new PHPExcel_Style();
2016: 
2017:         if (!$this->_readDataOnly) {
2018:             // offset:  0; size: 2; Index to FONT record
2019:             if (self::_GetInt2d($recordData, 0) < 4) {
2020:                 $fontIndex = self::_GetInt2d($recordData, 0);
2021:             } else {
2022:                 // this has to do with that index 4 is omitted in all BIFF versions for some strange reason
2023:                 // check the OpenOffice documentation of the FONT record
2024:                 $fontIndex = self::_GetInt2d($recordData, 0) - 1;
2025:             }
2026:             $objStyle->setFont($this->_objFonts[$fontIndex]);
2027: 
2028:             // offset:  2; size: 2; Index to FORMAT record
2029:             $numberFormatIndex = self::_GetInt2d($recordData, 2);
2030:             if (isset($this->_formats[$numberFormatIndex])) {
2031:                 // then we have user-defined format code
2032:                 $numberformat = array('code' => $this->_formats[$numberFormatIndex]);
2033:             } elseif (($code = PHPExcel_Style_NumberFormat::builtInFormatCode($numberFormatIndex)) !== '') {
2034:                 // then we have built-in format code
2035:                 $numberformat = array('code' => $code);
2036:             } else {
2037:                 // we set the general format code
2038:                 $numberformat = array('code' => 'General');
2039:             }
2040:             $objStyle->getNumberFormat()->setFormatCode($numberformat['code']);
2041: 
2042:             // offset:  4; size: 2; XF type, cell protection, and parent style XF
2043:             // bit 2-0; mask 0x0007; XF_TYPE_PROT
2044:             $xfTypeProt = self::_GetInt2d($recordData, 4);
2045:             // bit 0; mask 0x01; 1 = cell is locked
2046:             $isLocked = (0x01 & $xfTypeProt) >> 0;
2047:             $objStyle->getProtection()->setLocked($isLocked ?
2048:                 PHPExcel_Style_Protection::PROTECTION_INHERIT : PHPExcel_Style_Protection::PROTECTION_UNPROTECTED);
2049: 
2050:             // bit 1; mask 0x02; 1 = Formula is hidden
2051:             $isHidden = (0x02 & $xfTypeProt) >> 1;
2052:             $objStyle->getProtection()->setHidden($isHidden ?
2053:                 PHPExcel_Style_Protection::PROTECTION_PROTECTED : PHPExcel_Style_Protection::PROTECTION_UNPROTECTED);
2054: 
2055:             // bit 2; mask 0x04; 0 = Cell XF, 1 = Cell Style XF
2056:             $isCellStyleXf = (0x04 & $xfTypeProt) >> 2;
2057: 
2058:             // offset:  6; size: 1; Alignment and text break
2059:             // bit 2-0, mask 0x07; horizontal alignment
2060:             $horAlign = (0x07 & ord($recordData{6})) >> 0;
2061:             switch ($horAlign) {
2062:                 case 0:
2063:                     $objStyle->getAlignment()->setHorizontal(PHPExcel_Style_Alignment::HORIZONTAL_GENERAL);
2064:                     break;
2065:                 case 1:
2066:                     $objStyle->getAlignment()->setHorizontal(PHPExcel_Style_Alignment::HORIZONTAL_LEFT);
2067:                     break;
2068:                 case 2:
2069:                     $objStyle->getAlignment()->setHorizontal(PHPExcel_Style_Alignment::HORIZONTAL_CENTER);
2070:                     break;
2071:                 case 3:
2072:                     $objStyle->getAlignment()->setHorizontal(PHPExcel_Style_Alignment::HORIZONTAL_RIGHT);
2073:                     break;
2074:                 case 4:
2075:                     $objStyle->getAlignment()->setHorizontal(PHPExcel_Style_Alignment::HORIZONTAL_FILL);
2076:                     break;
2077:                 case 5:
2078:                     $objStyle->getAlignment()->setHorizontal(PHPExcel_Style_Alignment::HORIZONTAL_JUSTIFY);
2079:                     break;
2080:                 case 6:
2081:                     $objStyle->getAlignment()->setHorizontal(PHPExcel_Style_Alignment::HORIZONTAL_CENTER_CONTINUOUS);
2082:                     break;
2083:             }
2084:             // bit 3, mask 0x08; wrap text
2085:             $wrapText = (0x08 & ord($recordData{6})) >> 3;
2086:             switch ($wrapText) {
2087:                 case 0:
2088:                     $objStyle->getAlignment()->setWrapText(false);
2089:                     break;
2090:                 case 1:
2091:                     $objStyle->getAlignment()->setWrapText(true);
2092:                     break;
2093:             }
2094:             // bit 6-4, mask 0x70; vertical alignment
2095:             $vertAlign = (0x70 & ord($recordData{6})) >> 4;
2096:             switch ($vertAlign) {
2097:                 case 0:
2098:                     $objStyle->getAlignment()->setVertical(PHPExcel_Style_Alignment::VERTICAL_TOP);
2099:                     break;
2100:                 case 1:
2101:                     $objStyle->getAlignment()->setVertical(PHPExcel_Style_Alignment::VERTICAL_CENTER);
2102:                     break;
2103:                 case 2:
2104:                     $objStyle->getAlignment()->setVertical(PHPExcel_Style_Alignment::VERTICAL_BOTTOM);
2105:                     break;
2106:                 case 3:
2107:                     $objStyle->getAlignment()->setVertical(PHPExcel_Style_Alignment::VERTICAL_JUSTIFY);
2108:                     break;
2109:             }
2110: 
2111:             if ($this->_version == self::XLS_BIFF8) {
2112:                 // offset:  7; size: 1; XF_ROTATION: Text rotation angle
2113:                     $angle = ord($recordData{7});
2114:                     $rotation = 0;
2115:                     if ($angle <= 90) {
2116:                         $rotation = $angle;
2117:                     } else if ($angle <= 180) {
2118:                         $rotation = 90 - $angle;
2119:                     } else if ($angle == 255) {
2120:                         $rotation = -165;
2121:                     }
2122:                     $objStyle->getAlignment()->setTextRotation($rotation);
2123: 
2124:                 // offset:  8; size: 1; Indentation, shrink to cell size, and text direction
2125:                     // bit: 3-0; mask: 0x0F; indent level
2126:                     $indent = (0x0F & ord($recordData{8})) >> 0;
2127:                     $objStyle->getAlignment()->setIndent($indent);
2128: 
2129:                     // bit: 4; mask: 0x10; 1 = shrink content to fit into cell
2130:                     $shrinkToFit = (0x10 & ord($recordData{8})) >> 4;
2131:                     switch ($shrinkToFit) {
2132:                         case 0:
2133:                             $objStyle->getAlignment()->setShrinkToFit(false);
2134:                             break;
2135:                         case 1:
2136:                             $objStyle->getAlignment()->setShrinkToFit(true);
2137:                             break;
2138:                     }
2139: 
2140:                 // offset:  9; size: 1; Flags used for attribute groups
2141: 
2142:                 // offset: 10; size: 4; Cell border lines and background area
2143:                     // bit: 3-0; mask: 0x0000000F; left style
2144:                     if ($bordersLeftStyle = self::_mapBorderStyle((0x0000000F & self::_GetInt4d($recordData, 10)) >> 0)) {
2145:                         $objStyle->getBorders()->getLeft()->setBorderStyle($bordersLeftStyle);
2146:                     }
2147:                     // bit: 7-4; mask: 0x000000F0; right style
2148:                     if ($bordersRightStyle = self::_mapBorderStyle((0x000000F0 & self::_GetInt4d($recordData, 10)) >> 4)) {
2149:                         $objStyle->getBorders()->getRight()->setBorderStyle($bordersRightStyle);
2150:                     }
2151:                     // bit: 11-8; mask: 0x00000F00; top style
2152:                     if ($bordersTopStyle = self::_mapBorderStyle((0x00000F00 & self::_GetInt4d($recordData, 10)) >> 8)) {
2153:                         $objStyle->getBorders()->getTop()->setBorderStyle($bordersTopStyle);
2154:                     }
2155:                     // bit: 15-12; mask: 0x0000F000; bottom style
2156:                     if ($bordersBottomStyle = self::_mapBorderStyle((0x0000F000 & self::_GetInt4d($recordData, 10)) >> 12)) {
2157:                         $objStyle->getBorders()->getBottom()->setBorderStyle($bordersBottomStyle);
2158:                     }
2159:                     // bit: 22-16; mask: 0x007F0000; left color
2160:                     $objStyle->getBorders()->getLeft()->colorIndex = (0x007F0000 & self::_GetInt4d($recordData, 10)) >> 16;
2161: 
2162:                     // bit: 29-23; mask: 0x3F800000; right color
2163:                     $objStyle->getBorders()->getRight()->colorIndex = (0x3F800000 & self::_GetInt4d($recordData, 10)) >> 23;
2164: 
2165:                     // bit: 30; mask: 0x40000000; 1 = diagonal line from top left to right bottom
2166:                     $diagonalDown = (0x40000000 & self::_GetInt4d($recordData, 10)) >> 30 ?
2167:                         true : false;
2168: 
2169:                     // bit: 31; mask: 0x80000000; 1 = diagonal line from bottom left to top right
2170:                     $diagonalUp = (0x80000000 & self::_GetInt4d($recordData, 10)) >> 31 ?
2171:                         true : false;
2172: 
2173:                     if ($diagonalUp == false && $diagonalDown == false) {
2174:                         $objStyle->getBorders()->setDiagonalDirection(PHPExcel_Style_Borders::DIAGONAL_NONE);
2175:                     } elseif ($diagonalUp == true && $diagonalDown == false) {
2176:                         $objStyle->getBorders()->setDiagonalDirection(PHPExcel_Style_Borders::DIAGONAL_UP);
2177:                     } elseif ($diagonalUp == false && $diagonalDown == true) {
2178:                         $objStyle->getBorders()->setDiagonalDirection(PHPExcel_Style_Borders::DIAGONAL_DOWN);
2179:                     } elseif ($diagonalUp == true && $diagonalDown == true) {
2180:                         $objStyle->getBorders()->setDiagonalDirection(PHPExcel_Style_Borders::DIAGONAL_BOTH);
2181:                     }
2182: 
2183:                 // offset: 14; size: 4;
2184:                     // bit: 6-0; mask: 0x0000007F; top color
2185:                     $objStyle->getBorders()->getTop()->colorIndex = (0x0000007F & self::_GetInt4d($recordData, 14)) >> 0;
2186: 
2187:                     // bit: 13-7; mask: 0x00003F80; bottom color
2188:                     $objStyle->getBorders()->getBottom()->colorIndex = (0x00003F80 & self::_GetInt4d($recordData, 14)) >> 7;
2189: 
2190:                     // bit: 20-14; mask: 0x001FC000; diagonal color
2191:                     $objStyle->getBorders()->getDiagonal()->colorIndex = (0x001FC000 & self::_GetInt4d($recordData, 14)) >> 14;
2192: 
2193:                     // bit: 24-21; mask: 0x01E00000; diagonal style
2194:                     if ($bordersDiagonalStyle = self::_mapBorderStyle((0x01E00000 & self::_GetInt4d($recordData, 14)) >> 21)) {
2195:                         $objStyle->getBorders()->getDiagonal()->setBorderStyle($bordersDiagonalStyle);
2196:                     }
2197: 
2198:                     // bit: 31-26; mask: 0xFC000000 fill pattern
2199:                     if ($fillType = self::_mapFillPattern((0xFC000000 & self::_GetInt4d($recordData, 14)) >> 26)) {
2200:                         $objStyle->getFill()->setFillType($fillType);
2201:                     }
2202:                 // offset: 18; size: 2; pattern and background colour
2203:                     // bit: 6-0; mask: 0x007F; color index for pattern color
2204:                     $objStyle->getFill()->startcolorIndex = (0x007F & self::_GetInt2d($recordData, 18)) >> 0;
2205: 
2206:                     // bit: 13-7; mask: 0x3F80; color index for pattern background
2207:                     $objStyle->getFill()->endcolorIndex = (0x3F80 & self::_GetInt2d($recordData, 18)) >> 7;
2208:             } else {
2209:                 // BIFF5
2210: 
2211:                 // offset: 7; size: 1; Text orientation and flags
2212:                 $orientationAndFlags = ord($recordData{7});
2213: 
2214:                 // bit: 1-0; mask: 0x03; XF_ORIENTATION: Text orientation
2215:                 $xfOrientation = (0x03 & $orientationAndFlags) >> 0;
2216:                 switch ($xfOrientation) {
2217:                     case 0:
2218:                         $objStyle->getAlignment()->setTextRotation(0);
2219:                         break;
2220:                     case 1:
2221:                         $objStyle->getAlignment()->setTextRotation(-165);
2222:                         break;
2223:                     case 2:
2224:                         $objStyle->getAlignment()->setTextRotation(90);
2225:                         break;
2226:                     case 3:
2227:                         $objStyle->getAlignment()->setTextRotation(-90);
2228:                         break;
2229:                 }
2230: 
2231:                 // offset: 8; size: 4; cell border lines and background area
2232:                 $borderAndBackground = self::_GetInt4d($recordData, 8);
2233: 
2234:                 // bit: 6-0; mask: 0x0000007F; color index for pattern color
2235:                 $objStyle->getFill()->startcolorIndex = (0x0000007F & $borderAndBackground) >> 0;
2236: 
2237:                 // bit: 13-7; mask: 0x00003F80; color index for pattern background
2238:                 $objStyle->getFill()->endcolorIndex = (0x00003F80 & $borderAndBackground) >> 7;
2239: 
2240:                 // bit: 21-16; mask: 0x003F0000; fill pattern
2241:                 $objStyle->getFill()->setFillType(self::_mapFillPattern((0x003F0000 & $borderAndBackground) >> 16));
2242: 
2243:                 // bit: 24-22; mask: 0x01C00000; bottom line style
2244:                 $objStyle->getBorders()->getBottom()->setBorderStyle(self::_mapBorderStyle((0x01C00000 & $borderAndBackground) >> 22));
2245: 
2246:                 // bit: 31-25; mask: 0xFE000000; bottom line color
2247:                 $objStyle->getBorders()->getBottom()->colorIndex = (0xFE000000 & $borderAndBackground) >> 25;
2248: 
2249:                 // offset: 12; size: 4; cell border lines
2250:                 $borderLines = self::_GetInt4d($recordData, 12);
2251: 
2252:                 // bit: 2-0; mask: 0x00000007; top line style
2253:                 $objStyle->getBorders()->getTop()->setBorderStyle(self::_mapBorderStyle((0x00000007 & $borderLines) >> 0));
2254: 
2255:                 // bit: 5-3; mask: 0x00000038; left line style
2256:                 $objStyle->getBorders()->getLeft()->setBorderStyle(self::_mapBorderStyle((0x00000038 & $borderLines) >> 3));
2257: 
2258:                 // bit: 8-6; mask: 0x000001C0; right line style
2259:                 $objStyle->getBorders()->getRight()->setBorderStyle(self::_mapBorderStyle((0x000001C0 & $borderLines) >> 6));
2260: 
2261:                 // bit: 15-9; mask: 0x0000FE00; top line color index
2262:                 $objStyle->getBorders()->getTop()->colorIndex = (0x0000FE00 & $borderLines) >> 9;
2263: 
2264:                 // bit: 22-16; mask: 0x007F0000; left line color index
2265:                 $objStyle->getBorders()->getLeft()->colorIndex = (0x007F0000 & $borderLines) >> 16;
2266: 
2267:                 // bit: 29-23; mask: 0x3F800000; right line color index
2268:                 $objStyle->getBorders()->getRight()->colorIndex = (0x3F800000 & $borderLines) >> 23;
2269:             }
2270: 
2271:             // add cellStyleXf or cellXf and update mapping
2272:             if ($isCellStyleXf) {
2273:                 // we only read one style XF record which is always the first
2274:                 if ($this->_xfIndex == 0) {
2275:                     $this->_phpExcel->addCellStyleXf($objStyle);
2276:                     $this->_mapCellStyleXfIndex[$this->_xfIndex] = 0;
2277:                 }
2278:             } else {
2279:                 // we read all cell XF records
2280:                 $this->_phpExcel->addCellXf($objStyle);
2281:                 $this->_mapCellXfIndex[$this->_xfIndex] = count($this->_phpExcel->getCellXfCollection()) - 1;
2282:             }
2283: 
2284:             // update XF index for when we read next record
2285:             ++$this->_xfIndex;
2286:         }
2287:     }
2288: 
2289: 
2290:     /**
2291:      *
2292:      */
2293:     private function _readXfExt()
2294:     {
2295:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
2296:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
2297: 
2298:         // move stream pointer to next record
2299:         $this->_pos += 4 + $length;
2300: 
2301:         if (!$this->_readDataOnly) {
2302:             // offset: 0; size: 2; 0x087D = repeated header
2303: 
2304:             // offset: 2; size: 2
2305: 
2306:             // offset: 4; size: 8; not used
2307: 
2308:             // offset: 12; size: 2; record version
2309: 
2310:             // offset: 14; size: 2; index to XF record which this record modifies
2311:             $ixfe = self::_GetInt2d($recordData, 14);
2312: 
2313:             // offset: 16; size: 2; not used
2314: 
2315:             // offset: 18; size: 2; number of extension properties that follow
2316:             $cexts = self::_GetInt2d($recordData, 18);
2317: 
2318:             // start reading the actual extension data
2319:             $offset = 20;
2320:             while ($offset < $length) {
2321:                 // extension type
2322:                 $extType = self::_GetInt2d($recordData, $offset);
2323: 
2324:                 // extension length
2325:                 $cb = self::_GetInt2d($recordData, $offset + 2);
2326: 
2327:                 // extension data
2328:                 $extData = substr($recordData, $offset + 4, $cb);
2329: 
2330:                 switch ($extType) {
2331:                     case 4:     // fill start color
2332:                         $xclfType  = self::_GetInt2d($extData, 0); // color type
2333:                         $xclrValue = substr($extData, 4, 4); // color value (value based on color type)
2334: 
2335:                         if ($xclfType == 2) {
2336:                             $rgb = sprintf('%02X%02X%02X', ord($xclrValue{0}), ord($xclrValue{1}), ord($xclrValue{2}));
2337: 
2338:                             // modify the relevant style property
2339:                             if ( isset($this->_mapCellXfIndex[$ixfe]) ) {
2340:                                 $fill = $this->_phpExcel->getCellXfByIndex($this->_mapCellXfIndex[$ixfe])->getFill();
2341:                                 $fill->getStartColor()->setRGB($rgb);
2342:                                 unset($fill->startcolorIndex); // normal color index does not apply, discard
2343:                             }
2344:                         }
2345:                         break;
2346: 
2347:                     case 5:     // fill end color
2348:                         $xclfType  = self::_GetInt2d($extData, 0); // color type
2349:                         $xclrValue = substr($extData, 4, 4); // color value (value based on color type)
2350: 
2351:                         if ($xclfType == 2) {
2352:                             $rgb = sprintf('%02X%02X%02X', ord($xclrValue{0}), ord($xclrValue{1}), ord($xclrValue{2}));
2353: 
2354:                             // modify the relevant style property
2355:                             if ( isset($this->_mapCellXfIndex[$ixfe]) ) {
2356:                                 $fill = $this->_phpExcel->getCellXfByIndex($this->_mapCellXfIndex[$ixfe])->getFill();
2357:                                 $fill->getEndColor()->setRGB($rgb);
2358:                                 unset($fill->endcolorIndex); // normal color index does not apply, discard
2359:                             }
2360:                         }
2361:                         break;
2362: 
2363:                     case 7:     // border color top
2364:                         $xclfType  = self::_GetInt2d($extData, 0); // color type
2365:                         $xclrValue = substr($extData, 4, 4); // color value (value based on color type)
2366: 
2367:                         if ($xclfType == 2) {
2368:                             $rgb = sprintf('%02X%02X%02X', ord($xclrValue{0}), ord($xclrValue{1}), ord($xclrValue{2}));
2369: 
2370:                             // modify the relevant style property
2371:                             if ( isset($this->_mapCellXfIndex[$ixfe]) ) {
2372:                                 $top = $this->_phpExcel->getCellXfByIndex($this->_mapCellXfIndex[$ixfe])->getBorders()->getTop();
2373:                                 $top->getColor()->setRGB($rgb);
2374:                                 unset($top->colorIndex); // normal color index does not apply, discard
2375:                             }
2376:                         }
2377:                         break;
2378: 
2379:                     case 8:     // border color bottom
2380:                         $xclfType  = self::_GetInt2d($extData, 0); // color type
2381:                         $xclrValue = substr($extData, 4, 4); // color value (value based on color type)
2382: 
2383:                         if ($xclfType == 2) {
2384:                             $rgb = sprintf('%02X%02X%02X', ord($xclrValue{0}), ord($xclrValue{1}), ord($xclrValue{2}));
2385: 
2386:                             // modify the relevant style property
2387:                             if ( isset($this->_mapCellXfIndex[$ixfe]) ) {
2388:                                 $bottom = $this->_phpExcel->getCellXfByIndex($this->_mapCellXfIndex[$ixfe])->getBorders()->getBottom();
2389:                                 $bottom->getColor()->setRGB($rgb);
2390:                                 unset($bottom->colorIndex); // normal color index does not apply, discard
2391:                             }
2392:                         }
2393:                         break;
2394: 
2395:                     case 9:     // border color left
2396:                         $xclfType  = self::_GetInt2d($extData, 0); // color type
2397:                         $xclrValue = substr($extData, 4, 4); // color value (value based on color type)
2398: 
2399:                         if ($xclfType == 2) {
2400:                             $rgb = sprintf('%02X%02X%02X', ord($xclrValue{0}), ord($xclrValue{1}), ord($xclrValue{2}));
2401: 
2402:                             // modify the relevant style property
2403:                             if ( isset($this->_mapCellXfIndex[$ixfe]) ) {
2404:                                 $left = $this->_phpExcel->getCellXfByIndex($this->_mapCellXfIndex[$ixfe])->getBorders()->getLeft();
2405:                                 $left->getColor()->setRGB($rgb);
2406:                                 unset($left->colorIndex); // normal color index does not apply, discard
2407:                             }
2408:                         }
2409:                         break;
2410: 
2411:                     case 10:        // border color right
2412:                         $xclfType  = self::_GetInt2d($extData, 0); // color type
2413:                         $xclrValue = substr($extData, 4, 4); // color value (value based on color type)
2414: 
2415:                         if ($xclfType == 2) {
2416:                             $rgb = sprintf('%02X%02X%02X', ord($xclrValue{0}), ord($xclrValue{1}), ord($xclrValue{2}));
2417: 
2418:                             // modify the relevant style property
2419:                             if ( isset($this->_mapCellXfIndex[$ixfe]) ) {
2420:                                 $right = $this->_phpExcel->getCellXfByIndex($this->_mapCellXfIndex[$ixfe])->getBorders()->getRight();
2421:                                 $right->getColor()->setRGB($rgb);
2422:                                 unset($right->colorIndex); // normal color index does not apply, discard
2423:                             }
2424:                         }
2425:                         break;
2426: 
2427:                     case 11:        // border color diagonal
2428:                         $xclfType  = self::_GetInt2d($extData, 0); // color type
2429:                         $xclrValue = substr($extData, 4, 4); // color value (value based on color type)
2430: 
2431:                         if ($xclfType == 2) {
2432:                             $rgb = sprintf('%02X%02X%02X', ord($xclrValue{0}), ord($xclrValue{1}), ord($xclrValue{2}));
2433: 
2434:                             // modify the relevant style property
2435:                             if ( isset($this->_mapCellXfIndex[$ixfe]) ) {
2436:                                 $diagonal = $this->_phpExcel->getCellXfByIndex($this->_mapCellXfIndex[$ixfe])->getBorders()->getDiagonal();
2437:                                 $diagonal->getColor()->setRGB($rgb);
2438:                                 unset($diagonal->colorIndex); // normal color index does not apply, discard
2439:                             }
2440:                         }
2441:                         break;
2442: 
2443:                     case 13:    // font color
2444:                         $xclfType  = self::_GetInt2d($extData, 0); // color type
2445:                         $xclrValue = substr($extData, 4, 4); // color value (value based on color type)
2446: 
2447:                         if ($xclfType == 2) {
2448:                             $rgb = sprintf('%02X%02X%02X', ord($xclrValue{0}), ord($xclrValue{1}), ord($xclrValue{2}));
2449: 
2450:                             // modify the relevant style property
2451:                             if ( isset($this->_mapCellXfIndex[$ixfe]) ) {
2452:                                 $font = $this->_phpExcel->getCellXfByIndex($this->_mapCellXfIndex[$ixfe])->getFont();
2453:                                 $font->getColor()->setRGB($rgb);
2454:                                 unset($font->colorIndex); // normal color index does not apply, discard
2455:                             }
2456:                         }
2457:                         break;
2458:                 }
2459: 
2460:                 $offset += $cb;
2461:             }
2462:         }
2463: 
2464:     }
2465: 
2466: 
2467:     /**
2468:      * Read STYLE record
2469:      */
2470:     private function _readStyle()
2471:     {
2472:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
2473:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
2474: 
2475:         // move stream pointer to next record
2476:         $this->_pos += 4 + $length;
2477: 
2478:         if (!$this->_readDataOnly) {
2479:             // offset: 0; size: 2; index to XF record and flag for built-in style
2480:             $ixfe = self::_GetInt2d($recordData, 0);
2481: 
2482:             // bit: 11-0; mask 0x0FFF; index to XF record
2483:             $xfIndex = (0x0FFF & $ixfe) >> 0;
2484: 
2485:             // bit: 15; mask 0x8000; 0 = user-defined style, 1 = built-in style
2486:             $isBuiltIn = (bool) ((0x8000 & $ixfe) >> 15);
2487: 
2488:             if ($isBuiltIn) {
2489:                 // offset: 2; size: 1; identifier for built-in style
2490:                 $builtInId = ord($recordData{2});
2491: 
2492:                 switch ($builtInId) {
2493:                 case 0x00:
2494:                     // currently, we are not using this for anything
2495:                     break;
2496: 
2497:                 default:
2498:                     break;
2499:                 }
2500: 
2501:             } else {
2502:                 // user-defined; not supported by PHPExcel
2503:             }
2504:         }
2505:     }
2506: 
2507: 
2508:     /**
2509:      * Read PALETTE record
2510:      */
2511:     private function _readPalette()
2512:     {
2513:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
2514:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
2515: 
2516:         // move stream pointer to next record
2517:         $this->_pos += 4 + $length;
2518: 
2519:         if (!$this->_readDataOnly) {
2520:             // offset: 0; size: 2; number of following colors
2521:             $nm = self::_GetInt2d($recordData, 0);
2522: 
2523:             // list of RGB colors
2524:             for ($i = 0; $i < $nm; ++$i) {
2525:                 $rgb = substr($recordData, 2 + 4 * $i, 4);
2526:                 $this->_palette[] = self::_readRGB($rgb);
2527:             }
2528:         }
2529:     }
2530: 
2531: 
2532:     /**
2533:      * SHEET
2534:      *
2535:      * This record is  located in the  Workbook Globals
2536:      * Substream  and represents a sheet inside the workbook.
2537:      * One SHEET record is written for each sheet. It stores the
2538:      * sheet name and a stream offset to the BOF record of the
2539:      * respective Sheet Substream within the Workbook Stream.
2540:      *
2541:      * --   "OpenOffice.org's Documentation of the Microsoft
2542:      *      Excel File Format"
2543:      */
2544:     private function _readSheet()
2545:     {
2546:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
2547:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
2548: 
2549:         // offset: 0; size: 4; absolute stream position of the BOF record of the sheet
2550:         // NOTE: not encrypted
2551:         $rec_offset = self::_GetInt4d($this->_data, $this->_pos + 4);
2552: 
2553:         // move stream pointer to next record
2554:         $this->_pos += 4 + $length;
2555: 
2556:         // offset: 4; size: 1; sheet state
2557:         switch (ord($recordData{4})) {
2558:             case 0x00: $sheetState = PHPExcel_Worksheet::SHEETSTATE_VISIBLE;    break;
2559:             case 0x01: $sheetState = PHPExcel_Worksheet::SHEETSTATE_HIDDEN;     break;
2560:             case 0x02: $sheetState = PHPExcel_Worksheet::SHEETSTATE_VERYHIDDEN; break;
2561:             default: $sheetState = PHPExcel_Worksheet::SHEETSTATE_VISIBLE;      break;
2562:         }
2563: 
2564:         // offset: 5; size: 1; sheet type
2565:         $sheetType = ord($recordData{5});
2566: 
2567:         // offset: 6; size: var; sheet name
2568:         if ($this->_version == self::XLS_BIFF8) {
2569:             $string = self::_readUnicodeStringShort(substr($recordData, 6));
2570:             $rec_name = $string['value'];
2571:         } elseif ($this->_version == self::XLS_BIFF7) {
2572:             $string = $this->_readByteStringShort(substr($recordData, 6));
2573:             $rec_name = $string['value'];
2574:         }
2575: 
2576:         $this->_sheets[] = array(
2577:             'name' => $rec_name,
2578:             'offset' => $rec_offset,
2579:             'sheetState' => $sheetState,
2580:             'sheetType' => $sheetType,
2581:         );
2582:     }
2583: 
2584: 
2585:     /**
2586:      * Read EXTERNALBOOK record
2587:      */
2588:     private function _readExternalBook()
2589:     {
2590:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
2591:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
2592: 
2593:         // move stream pointer to next record
2594:         $this->_pos += 4 + $length;
2595: 
2596:         // offset within record data
2597:         $offset = 0;
2598: 
2599:         // there are 4 types of records
2600:         if (strlen($recordData) > 4) {
2601:             // external reference
2602:             // offset: 0; size: 2; number of sheet names ($nm)
2603:             $nm = self::_GetInt2d($recordData, 0);
2604:             $offset += 2;
2605: 
2606:             // offset: 2; size: var; encoded URL without sheet name (Unicode string, 16-bit length)
2607:             $encodedUrlString = self::_readUnicodeStringLong(substr($recordData, 2));
2608:             $offset += $encodedUrlString['size'];
2609: 
2610:             // offset: var; size: var; list of $nm sheet names (Unicode strings, 16-bit length)
2611:             $externalSheetNames = array();
2612:             for ($i = 0; $i < $nm; ++$i) {
2613:                 $externalSheetNameString = self::_readUnicodeStringLong(substr($recordData, $offset));
2614:                 $externalSheetNames[] = $externalSheetNameString['value'];
2615:                 $offset += $externalSheetNameString['size'];
2616:             }
2617: 
2618:             // store the record data
2619:             $this->_externalBooks[] = array(
2620:                 'type' => 'external',
2621:                 'encodedUrl' => $encodedUrlString['value'],
2622:                 'externalSheetNames' => $externalSheetNames,
2623:             );
2624: 
2625:         } elseif (substr($recordData, 2, 2) == pack('CC', 0x01, 0x04)) {
2626:             // internal reference
2627:             // offset: 0; size: 2; number of sheet in this document
2628:             // offset: 2; size: 2; 0x01 0x04
2629:             $this->_externalBooks[] = array(
2630:                 'type' => 'internal',
2631:             );
2632:         } elseif (substr($recordData, 0, 4) == pack('vCC', 0x0001, 0x01, 0x3A)) {
2633:             // add-in function
2634:             // offset: 0; size: 2; 0x0001
2635:             $this->_externalBooks[] = array(
2636:                 'type' => 'addInFunction',
2637:             );
2638:         } elseif (substr($recordData, 0, 2) == pack('v', 0x0000)) {
2639:             // DDE links, OLE links
2640:             // offset: 0; size: 2; 0x0000
2641:             // offset: 2; size: var; encoded source document name
2642:             $this->_externalBooks[] = array(
2643:                 'type' => 'DDEorOLE',
2644:             );
2645:         }
2646:     }
2647: 
2648: 
2649:     /**
2650:      * Read EXTERNNAME record.
2651:      */
2652:     private function _readExternName()
2653:     {
2654:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
2655:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
2656: 
2657:         // move stream pointer to next record
2658:         $this->_pos += 4 + $length;
2659: 
2660:         // external sheet references provided for named cells
2661:         if ($this->_version == self::XLS_BIFF8) {
2662:             // offset: 0; size: 2; options
2663:             $options = self::_GetInt2d($recordData, 0);
2664: 
2665:             // offset: 2; size: 2;
2666: 
2667:             // offset: 4; size: 2; not used
2668: 
2669:             // offset: 6; size: var
2670:             $nameString = self::_readUnicodeStringShort(substr($recordData, 6));
2671: 
2672:             // offset: var; size: var; formula data
2673:             $offset = 6 + $nameString['size'];
2674:             $formula = $this->_getFormulaFromStructure(substr($recordData, $offset));
2675: 
2676:             $this->_externalNames[] = array(
2677:                 'name' => $nameString['value'],
2678:                 'formula' => $formula,
2679:             );
2680:         }
2681:     }
2682: 
2683: 
2684:     /**
2685:      * Read EXTERNSHEET record
2686:      */
2687:     private function _readExternSheet()
2688:     {
2689:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
2690:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
2691: 
2692:         // move stream pointer to next record
2693:         $this->_pos += 4 + $length;
2694: 
2695:         // external sheet references provided for named cells
2696:         if ($this->_version == self::XLS_BIFF8) {
2697:             // offset: 0; size: 2; number of following ref structures
2698:             $nm = self::_GetInt2d($recordData, 0);
2699:             for ($i = 0; $i < $nm; ++$i) {
2700:                 $this->_ref[] = array(
2701:                     // offset: 2 + 6 * $i; index to EXTERNALBOOK record
2702:                     'externalBookIndex' => self::_GetInt2d($recordData, 2 + 6 * $i),
2703:                     // offset: 4 + 6 * $i; index to first sheet in EXTERNALBOOK record
2704:                     'firstSheetIndex' => self::_GetInt2d($recordData, 4 + 6 * $i),
2705:                     // offset: 6 + 6 * $i; index to last sheet in EXTERNALBOOK record
2706:                     'lastSheetIndex' => self::_GetInt2d($recordData, 6 + 6 * $i),
2707:                 );
2708:             }
2709:         }
2710:     }
2711: 
2712: 
2713:     /**
2714:      * DEFINEDNAME
2715:      *
2716:      * This record is part of a Link Table. It contains the name
2717:      * and the token array of an internal defined name. Token
2718:      * arrays of defined names contain tokens with aberrant
2719:      * token classes.
2720:      *
2721:      * --   "OpenOffice.org's Documentation of the Microsoft
2722:      *      Excel File Format"
2723:      */
2724:     private function _readDefinedName()
2725:     {
2726:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
2727:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
2728: 
2729:         // move stream pointer to next record
2730:         $this->_pos += 4 + $length;
2731: 
2732:         if ($this->_version == self::XLS_BIFF8) {
2733:             // retrieves named cells
2734: 
2735:             // offset: 0; size: 2; option flags
2736:             $opts = self::_GetInt2d($recordData, 0);
2737: 
2738:                 // bit: 5; mask: 0x0020; 0 = user-defined name, 1 = built-in-name
2739:                 $isBuiltInName = (0x0020 & $opts) >> 5;
2740: 
2741:             // offset: 2; size: 1; keyboard shortcut
2742: 
2743:             // offset: 3; size: 1; length of the name (character count)
2744:             $nlen = ord($recordData{3});
2745: 
2746:             // offset: 4; size: 2; size of the formula data (it can happen that this is zero)
2747:             // note: there can also be additional data, this is not included in $flen
2748:             $flen = self::_GetInt2d($recordData, 4);
2749: 
2750:             // offset: 8; size: 2; 0=Global name, otherwise index to sheet (1-based)
2751:             $scope = self::_GetInt2d($recordData, 8);
2752: 
2753:             // offset: 14; size: var; Name (Unicode string without length field)
2754:             $string = self::_readUnicodeString(substr($recordData, 14), $nlen);
2755: 
2756:             // offset: var; size: $flen; formula data
2757:             $offset = 14 + $string['size'];
2758:             $formulaStructure = pack('v', $flen) . substr($recordData, $offset);
2759: 
2760:             try {
2761:                 $formula = $this->_getFormulaFromStructure($formulaStructure);
2762:             } catch (PHPExcel_Exception $e) {
2763:                 $formula = '';
2764:             }
2765: 
2766:             $this->_definedname[] = array(
2767:                 'isBuiltInName' => $isBuiltInName,
2768:                 'name' => $string['value'],
2769:                 'formula' => $formula,
2770:                 'scope' => $scope,
2771:             );
2772:         }
2773:     }
2774: 
2775: 
2776:     /**
2777:      * Read MSODRAWINGGROUP record
2778:      */
2779:     private function _readMsoDrawingGroup()
2780:     {
2781:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
2782: 
2783:         // get spliced record data
2784:         $splicedRecordData = $this->_getSplicedRecordData();
2785:         $recordData = $splicedRecordData['recordData'];
2786: 
2787:         $this->_drawingGroupData .= $recordData;
2788:     }
2789: 
2790: 
2791:     /**
2792:      * SST - Shared String Table
2793:      *
2794:      * This record contains a list of all strings used anywhere
2795:      * in the workbook. Each string occurs only once. The
2796:      * workbook uses indexes into the list to reference the
2797:      * strings.
2798:      *
2799:      * --   "OpenOffice.org's Documentation of the Microsoft
2800:      *      Excel File Format"
2801:      **/
2802:     private function _readSst()
2803:     {
2804:         // offset within (spliced) record data
2805:         $pos = 0;
2806: 
2807:         // get spliced record data
2808:         $splicedRecordData = $this->_getSplicedRecordData();
2809: 
2810:         $recordData = $splicedRecordData['recordData'];
2811:         $spliceOffsets = $splicedRecordData['spliceOffsets'];
2812: 
2813:         // offset: 0; size: 4; total number of strings in the workbook
2814:         $pos += 4;
2815: 
2816:         // offset: 4; size: 4; number of following strings ($nm)
2817:         $nm = self::_GetInt4d($recordData, 4);
2818:         $pos += 4;
2819: 
2820:         // loop through the Unicode strings (16-bit length)
2821:         for ($i = 0; $i < $nm; ++$i) {
2822: 
2823:             // number of characters in the Unicode string
2824:             $numChars = self::_GetInt2d($recordData, $pos);
2825:             $pos += 2;
2826: 
2827:             // option flags
2828:             $optionFlags = ord($recordData{$pos});
2829:             ++$pos;
2830: 
2831:             // bit: 0; mask: 0x01; 0 = compressed; 1 = uncompressed
2832:             $isCompressed = (($optionFlags & 0x01) == 0) ;
2833: 
2834:             // bit: 2; mask: 0x02; 0 = ordinary; 1 = Asian phonetic
2835:             $hasAsian = (($optionFlags & 0x04) != 0);
2836: 
2837:             // bit: 3; mask: 0x03; 0 = ordinary; 1 = Rich-Text
2838:             $hasRichText = (($optionFlags & 0x08) != 0);
2839: 
2840:             if ($hasRichText) {
2841:                 // number of Rich-Text formatting runs
2842:                 $formattingRuns = self::_GetInt2d($recordData, $pos);
2843:                 $pos += 2;
2844:             }
2845: 
2846:             if ($hasAsian) {
2847:                 // size of Asian phonetic setting
2848:                 $extendedRunLength = self::_GetInt4d($recordData, $pos);
2849:                 $pos += 4;
2850:             }
2851: 
2852:             // expected byte length of character array if not split
2853:             $len = ($isCompressed) ? $numChars : $numChars * 2;
2854: 
2855:             // look up limit position
2856:             foreach ($spliceOffsets as $spliceOffset) {
2857:                 // it can happen that the string is empty, therefore we need
2858:                 // <= and not just <
2859:                 if ($pos <= $spliceOffset) {
2860:                     $limitpos = $spliceOffset;
2861:                     break;
2862:                 }
2863:             }
2864: 
2865:             if ($pos + $len <= $limitpos) {
2866:                 // character array is not split between records
2867: 
2868:                 $retstr = substr($recordData, $pos, $len);
2869:                 $pos += $len;
2870: 
2871:             } else {
2872:                 // character array is split between records
2873: 
2874:                 // first part of character array
2875:                 $retstr = substr($recordData, $pos, $limitpos - $pos);
2876: 
2877:                 $bytesRead = $limitpos - $pos;
2878: 
2879:                 // remaining characters in Unicode string
2880:                 $charsLeft = $numChars - (($isCompressed) ? $bytesRead : ($bytesRead / 2));
2881: 
2882:                 $pos = $limitpos;
2883: 
2884:                 // keep reading the characters
2885:                 while ($charsLeft > 0) {
2886: 
2887:                     // look up next limit position, in case the string span more than one continue record
2888:                     foreach ($spliceOffsets as $spliceOffset) {
2889:                         if ($pos < $spliceOffset) {
2890:                             $limitpos = $spliceOffset;
2891:                             break;
2892:                         }
2893:                     }
2894: 
2895:                     // repeated option flags
2896:                     // OpenOffice.org documentation 5.21
2897:                     $option = ord($recordData{$pos});
2898:                     ++$pos;
2899: 
2900:                     if ($isCompressed && ($option == 0)) {
2901:                         // 1st fragment compressed
2902:                         // this fragment compressed
2903:                         $len = min($charsLeft, $limitpos - $pos);
2904:                         $retstr .= substr($recordData, $pos, $len);
2905:                         $charsLeft -= $len;
2906:                         $isCompressed = true;
2907: 
2908:                     } elseif (!$isCompressed && ($option != 0)) {
2909:                         // 1st fragment uncompressed
2910:                         // this fragment uncompressed
2911:                         $len = min($charsLeft * 2, $limitpos - $pos);
2912:                         $retstr .= substr($recordData, $pos, $len);
2913:                         $charsLeft -= $len / 2;
2914:                         $isCompressed = false;
2915: 
2916:                     } elseif (!$isCompressed && ($option == 0)) {
2917:                         // 1st fragment uncompressed
2918:                         // this fragment compressed
2919:                         $len = min($charsLeft, $limitpos - $pos);
2920:                         for ($j = 0; $j < $len; ++$j) {
2921:                             $retstr .= $recordData{$pos + $j} . chr(0);
2922:                         }
2923:                         $charsLeft -= $len;
2924:                         $isCompressed = false;
2925: 
2926:                     } else {
2927:                         // 1st fragment compressed
2928:                         // this fragment uncompressed
2929:                         $newstr = '';
2930:                         for ($j = 0; $j < strlen($retstr); ++$j) {
2931:                             $newstr .= $retstr[$j] . chr(0);
2932:                         }
2933:                         $retstr = $newstr;
2934:                         $len = min($charsLeft * 2, $limitpos - $pos);
2935:                         $retstr .= substr($recordData, $pos, $len);
2936:                         $charsLeft -= $len / 2;
2937:                         $isCompressed = false;
2938:                     }
2939: 
2940:                     $pos += $len;
2941:                 }
2942:             }
2943: 
2944:             // convert to UTF-8
2945:             $retstr = self::_encodeUTF16($retstr, $isCompressed);
2946: 
2947:             // read additional Rich-Text information, if any
2948:             $fmtRuns = array();
2949:             if ($hasRichText) {
2950:                 // list of formatting runs
2951:                 for ($j = 0; $j < $formattingRuns; ++$j) {
2952:                     // first formatted character; zero-based
2953:                     $charPos = self::_GetInt2d($recordData, $pos + $j * 4);
2954: 
2955:                     // index to font record
2956:                     $fontIndex = self::_GetInt2d($recordData, $pos + 2 + $j * 4);
2957: 
2958:                     $fmtRuns[] = array(
2959:                         'charPos' => $charPos,
2960:                         'fontIndex' => $fontIndex,
2961:                     );
2962:                 }
2963:                 $pos += 4 * $formattingRuns;
2964:             }
2965: 
2966:             // read additional Asian phonetics information, if any
2967:             if ($hasAsian) {
2968:                 // For Asian phonetic settings, we skip the extended string data
2969:                 $pos += $extendedRunLength;
2970:             }
2971: 
2972:             // store the shared sting
2973:             $this->_sst[] = array(
2974:                 'value' => $retstr,
2975:                 'fmtRuns' => $fmtRuns,
2976:             );
2977:         }
2978: 
2979:         // _getSplicedRecordData() takes care of moving current position in data stream
2980:     }
2981: 
2982: 
2983:     /**
2984:      * Read PRINTGRIDLINES record
2985:      */
2986:     private function _readPrintGridlines()
2987:     {
2988:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
2989:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
2990: 
2991:         // move stream pointer to next record
2992:         $this->_pos += 4 + $length;
2993: 
2994:         if ($this->_version == self::XLS_BIFF8 && !$this->_readDataOnly) {
2995:             // offset: 0; size: 2; 0 = do not print sheet grid lines; 1 = print sheet gridlines
2996:             $printGridlines = (bool) self::_GetInt2d($recordData, 0);
2997:             $this->_phpSheet->setPrintGridlines($printGridlines);
2998:         }
2999:     }
3000: 
3001: 
3002:     /**
3003:      * Read DEFAULTROWHEIGHT record
3004:      */
3005:     private function _readDefaultRowHeight()
3006:     {
3007:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
3008:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
3009: 
3010:         // move stream pointer to next record
3011:         $this->_pos += 4 + $length;
3012: 
3013:         // offset: 0; size: 2; option flags
3014:         // offset: 2; size: 2; default height for unused rows, (twips 1/20 point)
3015:         $height = self::_GetInt2d($recordData, 2);
3016:         $this->_phpSheet->getDefaultRowDimension()->setRowHeight($height / 20);
3017:     }
3018: 
3019: 
3020:     /**
3021:      * Read SHEETPR record
3022:      */
3023:     private function _readSheetPr()
3024:     {
3025:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
3026:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
3027: 
3028:         // move stream pointer to next record
3029:         $this->_pos += 4 + $length;
3030: 
3031:         // offset: 0; size: 2
3032: 
3033:         // bit: 6; mask: 0x0040; 0 = outline buttons above outline group
3034:         $isSummaryBelow = (0x0040 & self::_GetInt2d($recordData, 0)) >> 6;
3035:         $this->_phpSheet->setShowSummaryBelow($isSummaryBelow);
3036: 
3037:         // bit: 7; mask: 0x0080; 0 = outline buttons left of outline group
3038:         $isSummaryRight = (0x0080 & self::_GetInt2d($recordData, 0)) >> 7;
3039:         $this->_phpSheet->setShowSummaryRight($isSummaryRight);
3040: 
3041:         // bit: 8; mask: 0x100; 0 = scale printout in percent, 1 = fit printout to number of pages
3042:         // this corresponds to radio button setting in page setup dialog in Excel
3043:         $this->_isFitToPages = (bool) ((0x0100 & self::_GetInt2d($recordData, 0)) >> 8);
3044:     }
3045: 
3046: 
3047:     /**
3048:      * Read HORIZONTALPAGEBREAKS record
3049:      */
3050:     private function _readHorizontalPageBreaks()
3051:     {
3052:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
3053:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
3054: 
3055:         // move stream pointer to next record
3056:         $this->_pos += 4 + $length;
3057: 
3058:         if ($this->_version == self::XLS_BIFF8 && !$this->_readDataOnly) {
3059: 
3060:             // offset: 0; size: 2; number of the following row index structures
3061:             $nm = self::_GetInt2d($recordData, 0);
3062: 
3063:             // offset: 2; size: 6 * $nm; list of $nm row index structures
3064:             for ($i = 0; $i < $nm; ++$i) {
3065:                 $r = self::_GetInt2d($recordData, 2 + 6 * $i);
3066:                 $cf = self::_GetInt2d($recordData, 2 + 6 * $i + 2);
3067:                 $cl = self::_GetInt2d($recordData, 2 + 6 * $i + 4);
3068: 
3069:                 // not sure why two column indexes are necessary?
3070:                 $this->_phpSheet->setBreakByColumnAndRow($cf, $r, PHPExcel_Worksheet::BREAK_ROW);
3071:             }
3072:         }
3073:     }
3074: 
3075: 
3076:     /**
3077:      * Read VERTICALPAGEBREAKS record
3078:      */
3079:     private function _readVerticalPageBreaks()
3080:     {
3081:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
3082:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
3083: 
3084:         // move stream pointer to next record
3085:         $this->_pos += 4 + $length;
3086: 
3087:         if ($this->_version == self::XLS_BIFF8 && !$this->_readDataOnly) {
3088:             // offset: 0; size: 2; number of the following column index structures
3089:             $nm = self::_GetInt2d($recordData, 0);
3090: 
3091:             // offset: 2; size: 6 * $nm; list of $nm row index structures
3092:             for ($i = 0; $i < $nm; ++$i) {
3093:                 $c = self::_GetInt2d($recordData, 2 + 6 * $i);
3094:                 $rf = self::_GetInt2d($recordData, 2 + 6 * $i + 2);
3095:                 $rl = self::_GetInt2d($recordData, 2 + 6 * $i + 4);
3096: 
3097:                 // not sure why two row indexes are necessary?
3098:                 $this->_phpSheet->setBreakByColumnAndRow($c, $rf, PHPExcel_Worksheet::BREAK_COLUMN);
3099:             }
3100:         }
3101:     }
3102: 
3103: 
3104:     /**
3105:      * Read HEADER record
3106:      */
3107:     private function _readHeader()
3108:     {
3109:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
3110:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
3111: 
3112:         // move stream pointer to next record
3113:         $this->_pos += 4 + $length;
3114: 
3115:         if (!$this->_readDataOnly) {
3116:             // offset: 0; size: var
3117:             // realized that $recordData can be empty even when record exists
3118:             if ($recordData) {
3119:                 if ($this->_version == self::XLS_BIFF8) {
3120:                     $string = self::_readUnicodeStringLong($recordData);
3121:                 } else {
3122:                     $string = $this->_readByteStringShort($recordData);
3123:                 }
3124: 
3125:                 $this->_phpSheet->getHeaderFooter()->setOddHeader($string['value']);
3126:                 $this->_phpSheet->getHeaderFooter()->setEvenHeader($string['value']);
3127:             }
3128:         }
3129:     }
3130: 
3131: 
3132:     /**
3133:      * Read FOOTER record
3134:      */
3135:     private function _readFooter()
3136:     {
3137:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
3138:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
3139: 
3140:         // move stream pointer to next record
3141:         $this->_pos += 4 + $length;
3142: 
3143:         if (!$this->_readDataOnly) {
3144:             // offset: 0; size: var
3145:             // realized that $recordData can be empty even when record exists
3146:             if ($recordData) {
3147:                 if ($this->_version == self::XLS_BIFF8) {
3148:                     $string = self::_readUnicodeStringLong($recordData);
3149:                 } else {
3150:                     $string = $this->_readByteStringShort($recordData);
3151:                 }
3152:                 $this->_phpSheet->getHeaderFooter()->setOddFooter($string['value']);
3153:                 $this->_phpSheet->getHeaderFooter()->setEvenFooter($string['value']);
3154:             }
3155:         }
3156:     }
3157: 
3158: 
3159:     /**
3160:      * Read HCENTER record
3161:      */
3162:     private function _readHcenter()
3163:     {
3164:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
3165:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
3166: 
3167:         // move stream pointer to next record
3168:         $this->_pos += 4 + $length;
3169: 
3170:         if (!$this->_readDataOnly) {
3171:             // offset: 0; size: 2; 0 = print sheet left aligned, 1 = print sheet centered horizontally
3172:             $isHorizontalCentered = (bool) self::_GetInt2d($recordData, 0);
3173: 
3174:             $this->_phpSheet->getPageSetup()->setHorizontalCentered($isHorizontalCentered);
3175:         }
3176:     }
3177: 
3178: 
3179:     /**
3180:      * Read VCENTER record
3181:      */
3182:     private function _readVcenter()
3183:     {
3184:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
3185:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
3186: 
3187:         // move stream pointer to next record
3188:         $this->_pos += 4 + $length;
3189: 
3190:         if (!$this->_readDataOnly) {
3191:             // offset: 0; size: 2; 0 = print sheet aligned at top page border, 1 = print sheet vertically centered
3192:             $isVerticalCentered = (bool) self::_GetInt2d($recordData, 0);
3193: 
3194:             $this->_phpSheet->getPageSetup()->setVerticalCentered($isVerticalCentered);
3195:         }
3196:     }
3197: 
3198: 
3199:     /**
3200:      * Read LEFTMARGIN record
3201:      */
3202:     private function _readLeftMargin()
3203:     {
3204:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
3205:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
3206: 
3207:         // move stream pointer to next record
3208:         $this->_pos += 4 + $length;
3209: 
3210:         if (!$this->_readDataOnly) {
3211:             // offset: 0; size: 8
3212:             $this->_phpSheet->getPageMargins()->setLeft(self::_extractNumber($recordData));
3213:         }
3214:     }
3215: 
3216: 
3217:     /**
3218:      * Read RIGHTMARGIN record
3219:      */
3220:     private function _readRightMargin()
3221:     {
3222:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
3223:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
3224: 
3225:         // move stream pointer to next record
3226:         $this->_pos += 4 + $length;
3227: 
3228:         if (!$this->_readDataOnly) {
3229:             // offset: 0; size: 8
3230:             $this->_phpSheet->getPageMargins()->setRight(self::_extractNumber($recordData));
3231:         }
3232:     }
3233: 
3234: 
3235:     /**
3236:      * Read TOPMARGIN record
3237:      */
3238:     private function _readTopMargin()
3239:     {
3240:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
3241:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
3242: 
3243:         // move stream pointer to next record
3244:         $this->_pos += 4 + $length;
3245: 
3246:         if (!$this->_readDataOnly) {
3247:             // offset: 0; size: 8
3248:             $this->_phpSheet->getPageMargins()->setTop(self::_extractNumber($recordData));
3249:         }
3250:     }
3251: 
3252: 
3253:     /**
3254:      * Read BOTTOMMARGIN record
3255:      */
3256:     private function _readBottomMargin()
3257:     {
3258:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
3259:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
3260: 
3261:         // move stream pointer to next record
3262:         $this->_pos += 4 + $length;
3263: 
3264:         if (!$this->_readDataOnly) {
3265:             // offset: 0; size: 8
3266:             $this->_phpSheet->getPageMargins()->setBottom(self::_extractNumber($recordData));
3267:         }
3268:     }
3269: 
3270: 
3271:     /**
3272:      * Read PAGESETUP record
3273:      */
3274:     private function _readPageSetup()
3275:     {
3276:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
3277:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
3278: 
3279:         // move stream pointer to next record
3280:         $this->_pos += 4 + $length;
3281: 
3282:         if (!$this->_readDataOnly) {
3283:             // offset: 0; size: 2; paper size
3284:             $paperSize = self::_GetInt2d($recordData, 0);
3285: 
3286:             // offset: 2; size: 2; scaling factor
3287:             $scale = self::_GetInt2d($recordData, 2);
3288: 
3289:             // offset: 6; size: 2; fit worksheet width to this number of pages, 0 = use as many as needed
3290:             $fitToWidth = self::_GetInt2d($recordData, 6);
3291: 
3292:             // offset: 8; size: 2; fit worksheet height to this number of pages, 0 = use as many as needed
3293:             $fitToHeight = self::_GetInt2d($recordData, 8);
3294: 
3295:             // offset: 10; size: 2; option flags
3296: 
3297:                 // bit: 1; mask: 0x0002; 0=landscape, 1=portrait
3298:                 $isPortrait = (0x0002 & self::_GetInt2d($recordData, 10)) >> 1;
3299: 
3300:                 // bit: 2; mask: 0x0004; 1= paper size, scaling factor, paper orient. not init
3301:                 // when this bit is set, do not use flags for those properties
3302:                 $isNotInit = (0x0004 & self::_GetInt2d($recordData, 10)) >> 2;
3303: 
3304:             if (!$isNotInit) {
3305:                 $this->_phpSheet->getPageSetup()->setPaperSize($paperSize);
3306:                 switch ($isPortrait) {
3307:                 case 0: $this->_phpSheet->getPageSetup()->setOrientation(PHPExcel_Worksheet_PageSetup::ORIENTATION_LANDSCAPE); break;
3308:                 case 1: $this->_phpSheet->getPageSetup()->setOrientation(PHPExcel_Worksheet_PageSetup::ORIENTATION_PORTRAIT); break;
3309:                 }
3310: 
3311:                 $this->_phpSheet->getPageSetup()->setScale($scale, false);
3312:                 $this->_phpSheet->getPageSetup()->setFitToPage((bool) $this->_isFitToPages);
3313:                 $this->_phpSheet->getPageSetup()->setFitToWidth($fitToWidth, false);
3314:                 $this->_phpSheet->getPageSetup()->setFitToHeight($fitToHeight, false);
3315:             }
3316: 
3317:             // offset: 16; size: 8; header margin (IEEE 754 floating-point value)
3318:             $marginHeader = self::_extractNumber(substr($recordData, 16, 8));
3319:             $this->_phpSheet->getPageMargins()->setHeader($marginHeader);
3320: 
3321:             // offset: 24; size: 8; footer margin (IEEE 754 floating-point value)
3322:             $marginFooter = self::_extractNumber(substr($recordData, 24, 8));
3323:             $this->_phpSheet->getPageMargins()->setFooter($marginFooter);
3324:         }
3325:     }
3326: 
3327: 
3328:     /**
3329:      * PROTECT - Sheet protection (BIFF2 through BIFF8)
3330:      *   if this record is omitted, then it also means no sheet protection
3331:      */
3332:     private function _readProtect()
3333:     {
3334:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
3335:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
3336: 
3337:         // move stream pointer to next record
3338:         $this->_pos += 4 + $length;
3339: 
3340:         if ($this->_readDataOnly) {
3341:             return;
3342:         }
3343: 
3344:         // offset: 0; size: 2;
3345: 
3346:         // bit 0, mask 0x01; 1 = sheet is protected
3347:         $bool = (0x01 & self::_GetInt2d($recordData, 0)) >> 0;
3348:         $this->_phpSheet->getProtection()->setSheet((bool)$bool);
3349:     }
3350: 
3351: 
3352:     /**
3353:      * SCENPROTECT
3354:      */
3355:     private function _readScenProtect()
3356:     {
3357:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
3358:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
3359: 
3360:         // move stream pointer to next record
3361:         $this->_pos += 4 + $length;
3362: 
3363:         if ($this->_readDataOnly) {
3364:             return;
3365:         }
3366: 
3367:         // offset: 0; size: 2;
3368: 
3369:         // bit: 0, mask 0x01; 1 = scenarios are protected
3370:         $bool = (0x01 & self::_GetInt2d($recordData, 0)) >> 0;
3371: 
3372:         $this->_phpSheet->getProtection()->setScenarios((bool)$bool);
3373:     }
3374: 
3375: 
3376:     /**
3377:      * OBJECTPROTECT
3378:      */
3379:     private function _readObjectProtect()
3380:     {
3381:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
3382:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
3383: 
3384:         // move stream pointer to next record
3385:         $this->_pos += 4 + $length;
3386: 
3387:         if ($this->_readDataOnly) {
3388:             return;
3389:         }
3390: 
3391:         // offset: 0; size: 2;
3392: 
3393:         // bit: 0, mask 0x01; 1 = objects are protected
3394:         $bool = (0x01 & self::_GetInt2d($recordData, 0)) >> 0;
3395: 
3396:         $this->_phpSheet->getProtection()->setObjects((bool)$bool);
3397:     }
3398: 
3399: 
3400:     /**
3401:      * PASSWORD - Sheet protection (hashed) password (BIFF2 through BIFF8)
3402:      */
3403:     private function _readPassword()
3404:     {
3405:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
3406:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
3407: 
3408:         // move stream pointer to next record
3409:         $this->_pos += 4 + $length;
3410: 
3411:         if (!$this->_readDataOnly) {
3412:             // offset: 0; size: 2; 16-bit hash value of password
3413:             $password = strtoupper(dechex(self::_GetInt2d($recordData, 0))); // the hashed password
3414:             $this->_phpSheet->getProtection()->setPassword($password, true);
3415:         }
3416:     }
3417: 
3418: 
3419:     /**
3420:      * Read DEFCOLWIDTH record
3421:      */
3422:     private function _readDefColWidth()
3423:     {
3424:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
3425:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
3426: 
3427:         // move stream pointer to next record
3428:         $this->_pos += 4 + $length;
3429: 
3430:         // offset: 0; size: 2; default column width
3431:         $width = self::_GetInt2d($recordData, 0);
3432:         if ($width != 8) {
3433:             $this->_phpSheet->getDefaultColumnDimension()->setWidth($width);
3434:         }
3435:     }
3436: 
3437: 
3438:     /**
3439:      * Read COLINFO record
3440:      */
3441:     private function _readColInfo()
3442:     {
3443:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
3444:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
3445: 
3446:         // move stream pointer to next record
3447:         $this->_pos += 4 + $length;
3448: 
3449:         if (!$this->_readDataOnly) {
3450:             // offset: 0; size: 2; index to first column in range
3451:             $fc = self::_GetInt2d($recordData, 0); // first column index
3452: 
3453:             // offset: 2; size: 2; index to last column in range
3454:             $lc = self::_GetInt2d($recordData, 2); // first column index
3455: 
3456:             // offset: 4; size: 2; width of the column in 1/256 of the width of the zero character
3457:             $width = self::_GetInt2d($recordData, 4);
3458: 
3459:             // offset: 6; size: 2; index to XF record for default column formatting
3460:             $xfIndex = self::_GetInt2d($recordData, 6);
3461: 
3462:             // offset: 8; size: 2; option flags
3463: 
3464:                 // bit: 0; mask: 0x0001; 1= columns are hidden
3465:                 $isHidden = (0x0001 & self::_GetInt2d($recordData, 8)) >> 0;
3466: 
3467:                 // bit: 10-8; mask: 0x0700; outline level of the columns (0 = no outline)
3468:                 $level = (0x0700 & self::_GetInt2d($recordData, 8)) >> 8;
3469: 
3470:                 // bit: 12; mask: 0x1000; 1 = collapsed
3471:                 $isCollapsed = (0x1000 & self::_GetInt2d($recordData, 8)) >> 12;
3472: 
3473:             // offset: 10; size: 2; not used
3474: 
3475:             for ($i = $fc; $i <= $lc; ++$i) {
3476:                 if ($lc == 255 || $lc == 256) {
3477:                     $this->_phpSheet->getDefaultColumnDimension()->setWidth($width / 256);
3478:                     break;
3479:                 }
3480:                 $this->_phpSheet->getColumnDimensionByColumn($i)->setWidth($width / 256);
3481:                 $this->_phpSheet->getColumnDimensionByColumn($i)->setVisible(!$isHidden);
3482:                 $this->_phpSheet->getColumnDimensionByColumn($i)->setOutlineLevel($level);
3483:                 $this->_phpSheet->getColumnDimensionByColumn($i)->setCollapsed($isCollapsed);
3484:                 $this->_phpSheet->getColumnDimensionByColumn($i)->setXfIndex($this->_mapCellXfIndex[$xfIndex]);
3485:             }
3486:         }
3487:     }
3488: 
3489: 
3490:     /**
3491:      * ROW
3492:      *
3493:      * This record contains the properties of a single row in a
3494:      * sheet. Rows and cells in a sheet are divided into blocks
3495:      * of 32 rows.
3496:      *
3497:      * --   "OpenOffice.org's Documentation of the Microsoft
3498:      *      Excel File Format"
3499:      */
3500:     private function _readRow()
3501:     {
3502:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
3503:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
3504: 
3505:         // move stream pointer to next record
3506:         $this->_pos += 4 + $length;
3507: 
3508:         if (!$this->_readDataOnly) {
3509:             // offset: 0; size: 2; index of this row
3510:             $r = self::_GetInt2d($recordData, 0);
3511: 
3512:             // offset: 2; size: 2; index to column of the first cell which is described by a cell record
3513: 
3514:             // offset: 4; size: 2; index to column of the last cell which is described by a cell record, increased by 1
3515: 
3516:             // offset: 6; size: 2;
3517: 
3518:             // bit: 14-0; mask: 0x7FFF; height of the row, in twips = 1/20 of a point
3519:             $height = (0x7FFF & self::_GetInt2d($recordData, 6)) >> 0;
3520: 
3521:             // bit: 15: mask: 0x8000; 0 = row has custom height; 1= row has default height
3522:             $useDefaultHeight = (0x8000 & self::_GetInt2d($recordData, 6)) >> 15;
3523: 
3524:             if (!$useDefaultHeight) {
3525:                 $this->_phpSheet->getRowDimension($r + 1)->setRowHeight($height / 20);
3526:             }
3527: 
3528:             // offset: 8; size: 2; not used
3529: 
3530:             // offset: 10; size: 2; not used in BIFF5-BIFF8
3531: 
3532:             // offset: 12; size: 4; option flags and default row formatting
3533: 
3534:             // bit: 2-0: mask: 0x00000007; outline level of the row
3535:             $level = (0x00000007 & self::_GetInt4d($recordData, 12)) >> 0;
3536:             $this->_phpSheet->getRowDimension($r + 1)->setOutlineLevel($level);
3537: 
3538:             // bit: 4; mask: 0x00000010; 1 = outline group start or ends here... and is collapsed
3539:             $isCollapsed = (0x00000010 & self::_GetInt4d($recordData, 12)) >> 4;
3540:             $this->_phpSheet->getRowDimension($r + 1)->setCollapsed($isCollapsed);
3541: 
3542:             // bit: 5; mask: 0x00000020; 1 = row is hidden
3543:             $isHidden = (0x00000020 & self::_GetInt4d($recordData, 12)) >> 5;
3544:             $this->_phpSheet->getRowDimension($r + 1)->setVisible(!$isHidden);
3545: 
3546:             // bit: 7; mask: 0x00000080; 1 = row has explicit format
3547:             $hasExplicitFormat = (0x00000080 & self::_GetInt4d($recordData, 12)) >> 7;
3548: 
3549:             // bit: 27-16; mask: 0x0FFF0000; only applies when hasExplicitFormat = 1; index to XF record
3550:             $xfIndex = (0x0FFF0000 & self::_GetInt4d($recordData, 12)) >> 16;
3551: 
3552:             if ($hasExplicitFormat) {
3553:                 $this->_phpSheet->getRowDimension($r + 1)->setXfIndex($this->_mapCellXfIndex[$xfIndex]);
3554:             }
3555:         }
3556:     }
3557: 
3558: 
3559:     /**
3560:      * Read RK record
3561:      * This record represents a cell that contains an RK value
3562:      * (encoded integer or floating-point value). If a
3563:      * floating-point value cannot be encoded to an RK value,
3564:      * a NUMBER record will be written. This record replaces the
3565:      * record INTEGER written in BIFF2.
3566:      *
3567:      * --   "OpenOffice.org's Documentation of the Microsoft
3568:      *      Excel File Format"
3569:      */
3570:     private function _readRk()
3571:     {
3572:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
3573:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
3574: 
3575:         // move stream pointer to next record
3576:         $this->_pos += 4 + $length;
3577: 
3578:         // offset: 0; size: 2; index to row
3579:         $row = self::_GetInt2d($recordData, 0);
3580: 
3581:         // offset: 2; size: 2; index to column
3582:         $column = self::_GetInt2d($recordData, 2);
3583:         $columnString = PHPExcel_Cell::stringFromColumnIndex($column);
3584: 
3585:         // Read cell?
3586:         if (($this->getReadFilter() !== NULL) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->_phpSheet->getTitle()) ) {
3587:             // offset: 4; size: 2; index to XF record
3588:             $xfIndex = self::_GetInt2d($recordData, 4);
3589: 
3590:             // offset: 6; size: 4; RK value
3591:             $rknum = self::_GetInt4d($recordData, 6);
3592:             $numValue = self::_GetIEEE754($rknum);
3593: 
3594:             $cell = $this->_phpSheet->getCell($columnString . ($row + 1));
3595:             if (!$this->_readDataOnly) {
3596:                 // add style information
3597:                 $cell->setXfIndex($this->_mapCellXfIndex[$xfIndex]);
3598:             }
3599: 
3600:             // add cell
3601:             $cell->setValueExplicit($numValue, PHPExcel_Cell_DataType::TYPE_NUMERIC);
3602:         }
3603:     }
3604: 
3605: 
3606:     /**
3607:      * Read LABELSST record
3608:      * This record represents a cell that contains a string. It
3609:      * replaces the LABEL record and RSTRING record used in
3610:      * BIFF2-BIFF5.
3611:      *
3612:      * --   "OpenOffice.org's Documentation of the Microsoft
3613:      *      Excel File Format"
3614:      */
3615:     private function _readLabelSst()
3616:     {
3617:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
3618:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
3619: 
3620:         // move stream pointer to next record
3621:         $this->_pos += 4 + $length;
3622: 
3623:         // offset: 0; size: 2; index to row
3624:         $row = self::_GetInt2d($recordData, 0);
3625: 
3626:         // offset: 2; size: 2; index to column
3627:         $column = self::_GetInt2d($recordData, 2);
3628:         $columnString = PHPExcel_Cell::stringFromColumnIndex($column);
3629: 
3630:         // Read cell?
3631:         if (($this->getReadFilter() !== NULL) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->_phpSheet->getTitle()) ) {
3632:             // offset: 4; size: 2; index to XF record
3633:             $xfIndex = self::_GetInt2d($recordData, 4);
3634: 
3635:             // offset: 6; size: 4; index to SST record
3636:             $index = self::_GetInt4d($recordData, 6);
3637: 
3638:             // add cell
3639:             if (($fmtRuns = $this->_sst[$index]['fmtRuns']) && !$this->_readDataOnly) {
3640:                 // then we should treat as rich text
3641:                 $richText = new PHPExcel_RichText();
3642:                 $charPos = 0;
3643:                 $sstCount = count($this->_sst[$index]['fmtRuns']);
3644:                 for ($i = 0; $i <= $sstCount; ++$i) {
3645:                     if (isset($fmtRuns[$i])) {
3646:                         $text = PHPExcel_Shared_String::Substring($this->_sst[$index]['value'], $charPos, $fmtRuns[$i]['charPos'] - $charPos);
3647:                         $charPos = $fmtRuns[$i]['charPos'];
3648:                     } else {
3649:                         $text = PHPExcel_Shared_String::Substring($this->_sst[$index]['value'], $charPos, PHPExcel_Shared_String::CountCharacters($this->_sst[$index]['value']));
3650:                     }
3651: 
3652:                     if (PHPExcel_Shared_String::CountCharacters($text) > 0) {
3653:                         if ($i == 0) { // first text run, no style
3654:                             $richText->createText($text);
3655:                         } else {
3656:                             $textRun = $richText->createTextRun($text);
3657:                             if (isset($fmtRuns[$i - 1])) {
3658:                                 if ($fmtRuns[$i - 1]['fontIndex'] < 4) {
3659:                                     $fontIndex = $fmtRuns[$i - 1]['fontIndex'];
3660:                                 } else {
3661:                                     // this has to do with that index 4 is omitted in all BIFF versions for some strange reason
3662:                                     // check the OpenOffice documentation of the FONT record
3663:                                     $fontIndex = $fmtRuns[$i - 1]['fontIndex'] - 1;
3664:                                 }
3665:                                 $textRun->setFont(clone $this->_objFonts[$fontIndex]);
3666:                             }
3667:                         }
3668:                     }
3669:                 }
3670:                 $cell = $this->_phpSheet->getCell($columnString . ($row + 1));
3671:                 $cell->setValueExplicit($richText, PHPExcel_Cell_DataType::TYPE_STRING);
3672:             } else {
3673:                 $cell = $this->_phpSheet->getCell($columnString . ($row + 1));
3674:                 $cell->setValueExplicit($this->_sst[$index]['value'], PHPExcel_Cell_DataType::TYPE_STRING);
3675:             }
3676: 
3677:             if (!$this->_readDataOnly) {
3678:                 // add style information
3679:                 $cell->setXfIndex($this->_mapCellXfIndex[$xfIndex]);
3680:             }
3681:         }
3682:     }
3683: 
3684: 
3685:     /**
3686:      * Read MULRK record
3687:      * This record represents a cell range containing RK value
3688:      * cells. All cells are located in the same row.
3689:      *
3690:      * --   "OpenOffice.org's Documentation of the Microsoft
3691:      *      Excel File Format"
3692:      */
3693:     private function _readMulRk()
3694:     {
3695:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
3696:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
3697: 
3698:         // move stream pointer to next record
3699:         $this->_pos += 4 + $length;
3700: 
3701:         // offset: 0; size: 2; index to row
3702:         $row = self::_GetInt2d($recordData, 0);
3703: 
3704:         // offset: 2; size: 2; index to first column
3705:         $colFirst = self::_GetInt2d($recordData, 2);
3706: 
3707:         // offset: var; size: 2; index to last column
3708:         $colLast = self::_GetInt2d($recordData, $length - 2);
3709:         $columns = $colLast - $colFirst + 1;
3710: 
3711:         // offset within record data
3712:         $offset = 4;
3713: 
3714:         for ($i = 0; $i < $columns; ++$i) {
3715:             $columnString = PHPExcel_Cell::stringFromColumnIndex($colFirst + $i);
3716: 
3717:             // Read cell?
3718:             if (($this->getReadFilter() !== NULL) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->_phpSheet->getTitle()) ) {
3719: 
3720:                 // offset: var; size: 2; index to XF record
3721:                 $xfIndex = self::_GetInt2d($recordData, $offset);
3722: 
3723:                 // offset: var; size: 4; RK value
3724:                 $numValue = self::_GetIEEE754(self::_GetInt4d($recordData, $offset + 2));
3725:                 $cell = $this->_phpSheet->getCell($columnString . ($row + 1));
3726:                 if (!$this->_readDataOnly) {
3727:                     // add style
3728:                     $cell->setXfIndex($this->_mapCellXfIndex[$xfIndex]);
3729:                 }
3730: 
3731:                 // add cell value
3732:                 $cell->setValueExplicit($numValue, PHPExcel_Cell_DataType::TYPE_NUMERIC);
3733:             }
3734: 
3735:             $offset += 6;
3736:         }
3737:     }
3738: 
3739: 
3740:     /**
3741:      * Read NUMBER record
3742:      * This record represents a cell that contains a
3743:      * floating-point value.
3744:      *
3745:      * --   "OpenOffice.org's Documentation of the Microsoft
3746:      *      Excel File Format"
3747:      */
3748:     private function _readNumber()
3749:     {
3750:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
3751:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
3752: 
3753:         // move stream pointer to next record
3754:         $this->_pos += 4 + $length;
3755: 
3756:         // offset: 0; size: 2; index to row
3757:         $row = self::_GetInt2d($recordData, 0);
3758: 
3759:         // offset: 2; size 2; index to column
3760:         $column = self::_GetInt2d($recordData, 2);
3761:         $columnString = PHPExcel_Cell::stringFromColumnIndex($column);
3762: 
3763:         // Read cell?
3764:         if (($this->getReadFilter() !== NULL) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->_phpSheet->getTitle()) ) {
3765:             // offset 4; size: 2; index to XF record
3766:             $xfIndex = self::_GetInt2d($recordData, 4);
3767: 
3768:             $numValue = self::_extractNumber(substr($recordData, 6, 8));
3769: 
3770:             $cell = $this->_phpSheet->getCell($columnString . ($row + 1));
3771:             if (!$this->_readDataOnly) {
3772:                 // add cell style
3773:                 $cell->setXfIndex($this->_mapCellXfIndex[$xfIndex]);
3774:             }
3775: 
3776:             // add cell value
3777:             $cell->setValueExplicit($numValue, PHPExcel_Cell_DataType::TYPE_NUMERIC);
3778:         }
3779:     }
3780: 
3781: 
3782:     /**
3783:      * Read FORMULA record + perhaps a following STRING record if formula result is a string
3784:      * This record contains the token array and the result of a
3785:      * formula cell.
3786:      *
3787:      * --   "OpenOffice.org's Documentation of the Microsoft
3788:      *      Excel File Format"
3789:      */
3790:     private function _readFormula()
3791:     {
3792:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
3793:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
3794: 
3795:         // move stream pointer to next record
3796:         $this->_pos += 4 + $length;
3797: 
3798:         // offset: 0; size: 2; row index
3799:         $row = self::_GetInt2d($recordData, 0);
3800: 
3801:         // offset: 2; size: 2; col index
3802:         $column = self::_GetInt2d($recordData, 2);
3803:         $columnString = PHPExcel_Cell::stringFromColumnIndex($column);
3804: 
3805:         // offset: 20: size: variable; formula structure
3806:         $formulaStructure = substr($recordData, 20);
3807: 
3808:         // offset: 14: size: 2; option flags, recalculate always, recalculate on open etc.
3809:         $options = self::_GetInt2d($recordData, 14);
3810: 
3811:         // bit: 0; mask: 0x0001; 1 = recalculate always
3812:         // bit: 1; mask: 0x0002; 1 = calculate on open
3813:         // bit: 2; mask: 0x0008; 1 = part of a shared formula
3814:         $isPartOfSharedFormula = (bool) (0x0008 & $options);
3815: 
3816:         // WARNING:
3817:         // We can apparently not rely on $isPartOfSharedFormula. Even when $isPartOfSharedFormula = true
3818:         // the formula data may be ordinary formula data, therefore we need to check
3819:         // explicitly for the tExp token (0x01)
3820:         $isPartOfSharedFormula = $isPartOfSharedFormula && ord($formulaStructure{2}) == 0x01;
3821: 
3822:         if ($isPartOfSharedFormula) {
3823:             // part of shared formula which means there will be a formula with a tExp token and nothing else
3824:             // get the base cell, grab tExp token
3825:             $baseRow = self::_GetInt2d($formulaStructure, 3);
3826:             $baseCol = self::_GetInt2d($formulaStructure, 5);
3827:             $this->_baseCell = PHPExcel_Cell::stringFromColumnIndex($baseCol). ($baseRow + 1);
3828:         }
3829: 
3830:         // Read cell?
3831:         if (($this->getReadFilter() !== NULL) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->_phpSheet->getTitle()) ) {
3832: 
3833:             if ($isPartOfSharedFormula) {
3834:                 // formula is added to this cell after the sheet has been read
3835:                 $this->_sharedFormulaParts[$columnString . ($row + 1)] = $this->_baseCell;
3836:             }
3837: 
3838:             // offset: 16: size: 4; not used
3839: 
3840:             // offset: 4; size: 2; XF index
3841:             $xfIndex = self::_GetInt2d($recordData, 4);
3842: 
3843:             // offset: 6; size: 8; result of the formula
3844:             if ( (ord($recordData{6}) == 0)
3845:                 && (ord($recordData{12}) == 255)
3846:                 && (ord($recordData{13}) == 255) ) {
3847: 
3848:                 // String formula. Result follows in appended STRING record
3849:                 $dataType = PHPExcel_Cell_DataType::TYPE_STRING;
3850: 
3851:                 // read possible SHAREDFMLA record
3852:                 $code = self::_GetInt2d($this->_data, $this->_pos);
3853:                 if ($code == self::XLS_Type_SHAREDFMLA) {
3854:                     $this->_readSharedFmla();
3855:                 }
3856: 
3857:                 // read STRING record
3858:                 $value = $this->_readString();
3859: 
3860:             } elseif ((ord($recordData{6}) == 1)
3861:                 && (ord($recordData{12}) == 255)
3862:                 && (ord($recordData{13}) == 255)) {
3863: 
3864:                 // Boolean formula. Result is in +2; 0=false, 1=true
3865:                 $dataType = PHPExcel_Cell_DataType::TYPE_BOOL;
3866:                 $value = (bool) ord($recordData{8});
3867: 
3868:             } elseif ((ord($recordData{6}) == 2)
3869:                 && (ord($recordData{12}) == 255)
3870:                 && (ord($recordData{13}) == 255)) {
3871: 
3872:                 // Error formula. Error code is in +2
3873:                 $dataType = PHPExcel_Cell_DataType::TYPE_ERROR;
3874:                 $value = self::_mapErrorCode(ord($recordData{8}));
3875: 
3876:             } elseif ((ord($recordData{6}) == 3)
3877:                 && (ord($recordData{12}) == 255)
3878:                 && (ord($recordData{13}) == 255)) {
3879: 
3880:                 // Formula result is a null string
3881:                 $dataType = PHPExcel_Cell_DataType::TYPE_NULL;
3882:                 $value = '';
3883: 
3884:             } else {
3885: 
3886:                 // forumla result is a number, first 14 bytes like _NUMBER record
3887:                 $dataType = PHPExcel_Cell_DataType::TYPE_NUMERIC;
3888:                 $value = self::_extractNumber(substr($recordData, 6, 8));
3889: 
3890:             }
3891: 
3892:             $cell = $this->_phpSheet->getCell($columnString . ($row + 1));
3893:             if (!$this->_readDataOnly) {
3894:                 // add cell style
3895:                 $cell->setXfIndex($this->_mapCellXfIndex[$xfIndex]);
3896:             }
3897: 
3898:             // store the formula
3899:             if (!$isPartOfSharedFormula) {
3900:                 // not part of shared formula
3901:                 // add cell value. If we can read formula, populate with formula, otherwise just used cached value
3902:                 try {
3903:                     if ($this->_version != self::XLS_BIFF8) {
3904:                         throw new PHPExcel_Reader_Exception('Not BIFF8. Can only read BIFF8 formulas');
3905:                     }
3906:                     $formula = $this->_getFormulaFromStructure($formulaStructure); // get formula in human language
3907:                     $cell->setValueExplicit('=' . $formula, PHPExcel_Cell_DataType::TYPE_FORMULA);
3908: 
3909:                 } catch (PHPExcel_Exception $e) {
3910:                     $cell->setValueExplicit($value, $dataType);
3911:                 }
3912:             } else {
3913:                 if ($this->_version == self::XLS_BIFF8) {
3914:                     // do nothing at this point, formula id added later in the code
3915:                 } else {
3916:                     $cell->setValueExplicit($value, $dataType);
3917:                 }
3918:             }
3919: 
3920:             // store the cached calculated value
3921:             $cell->setCalculatedValue($value);
3922:         }
3923:     }
3924: 
3925: 
3926:     /**
3927:      * Read a SHAREDFMLA record. This function just stores the binary shared formula in the reader,
3928:      * which usually contains relative references.
3929:      * These will be used to construct the formula in each shared formula part after the sheet is read.
3930:      */
3931:     private function _readSharedFmla()
3932:     {
3933:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
3934:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
3935: 
3936:         // move stream pointer to next record
3937:         $this->_pos += 4 + $length;
3938: 
3939:         // offset: 0, size: 6; cell range address of the area used by the shared formula, not used for anything
3940:         $cellRange = substr($recordData, 0, 6);
3941:         $cellRange = $this->_readBIFF5CellRangeAddressFixed($cellRange); // note: even BIFF8 uses BIFF5 syntax
3942: 
3943:         // offset: 6, size: 1; not used
3944: 
3945:         // offset: 7, size: 1; number of existing FORMULA records for this shared formula
3946:         $no = ord($recordData{7});
3947: 
3948:         // offset: 8, size: var; Binary token array of the shared formula
3949:         $formula = substr($recordData, 8);
3950: 
3951:         // at this point we only store the shared formula for later use
3952:         $this->_sharedFormulas[$this->_baseCell] = $formula;
3953: 
3954:     }
3955: 
3956: 
3957:     /**
3958:      * Read a STRING record from current stream position and advance the stream pointer to next record
3959:      * This record is used for storing result from FORMULA record when it is a string, and
3960:      * it occurs directly after the FORMULA record
3961:      *
3962:      * @return string The string contents as UTF-8
3963:      */
3964:     private function _readString()
3965:     {
3966:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
3967:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
3968: 
3969:         // move stream pointer to next record
3970:         $this->_pos += 4 + $length;
3971: 
3972:         if ($this->_version == self::XLS_BIFF8) {
3973:             $string = self::_readUnicodeStringLong($recordData);
3974:             $value = $string['value'];
3975:         } else {
3976:             $string = $this->_readByteStringLong($recordData);
3977:             $value = $string['value'];
3978:         }
3979: 
3980:         return $value;
3981:     }
3982: 
3983: 
3984:     /**
3985:      * Read BOOLERR record
3986:      * This record represents a Boolean value or error value
3987:      * cell.
3988:      *
3989:      * --   "OpenOffice.org's Documentation of the Microsoft
3990:      *      Excel File Format"
3991:      */
3992:     private function _readBoolErr()
3993:     {
3994:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
3995:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
3996: 
3997:         // move stream pointer to next record
3998:         $this->_pos += 4 + $length;
3999: 
4000:         // offset: 0; size: 2; row index
4001:         $row = self::_GetInt2d($recordData, 0);
4002: 
4003:         // offset: 2; size: 2; column index
4004:         $column = self::_GetInt2d($recordData, 2);
4005:         $columnString = PHPExcel_Cell::stringFromColumnIndex($column);
4006: 
4007:         // Read cell?
4008:         if (($this->getReadFilter() !== NULL) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->_phpSheet->getTitle()) ) {
4009:             // offset: 4; size: 2; index to XF record
4010:             $xfIndex = self::_GetInt2d($recordData, 4);
4011: 
4012:             // offset: 6; size: 1; the boolean value or error value
4013:             $boolErr = ord($recordData{6});
4014: 
4015:             // offset: 7; size: 1; 0=boolean; 1=error
4016:             $isError = ord($recordData{7});
4017: 
4018:             $cell = $this->_phpSheet->getCell($columnString . ($row + 1));
4019:             switch ($isError) {
4020:                 case 0: // boolean
4021:                     $value = (bool) $boolErr;
4022: 
4023:                     // add cell value
4024:                     $cell->setValueExplicit($value, PHPExcel_Cell_DataType::TYPE_BOOL);
4025:                     break;
4026: 
4027:                 case 1: // error type
4028:                     $value = self::_mapErrorCode($boolErr);
4029: 
4030:                     // add cell value
4031:                     $cell->setValueExplicit($value, PHPExcel_Cell_DataType::TYPE_ERROR);
4032:                     break;
4033:             }
4034: 
4035:             if (!$this->_readDataOnly) {
4036:                 // add cell style
4037:                 $cell->setXfIndex($this->_mapCellXfIndex[$xfIndex]);
4038:             }
4039:         }
4040:     }
4041: 
4042: 
4043:     /**
4044:      * Read MULBLANK record
4045:      * This record represents a cell range of empty cells. All
4046:      * cells are located in the same row
4047:      *
4048:      * --   "OpenOffice.org's Documentation of the Microsoft
4049:      *      Excel File Format"
4050:      */
4051:     private function _readMulBlank()
4052:     {
4053:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
4054:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
4055: 
4056:         // move stream pointer to next record
4057:         $this->_pos += 4 + $length;
4058: 
4059:         // offset: 0; size: 2; index to row
4060:         $row = self::_GetInt2d($recordData, 0);
4061: 
4062:         // offset: 2; size: 2; index to first column
4063:         $fc = self::_GetInt2d($recordData, 2);
4064: 
4065:         // offset: 4; size: 2 x nc; list of indexes to XF records
4066:         // add style information
4067:         if (!$this->_readDataOnly) {
4068:             for ($i = 0; $i < $length / 2 - 3; ++$i) {
4069:                 $columnString = PHPExcel_Cell::stringFromColumnIndex($fc + $i);
4070: 
4071:                 // Read cell?
4072:                 if (($this->getReadFilter() !== NULL) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->_phpSheet->getTitle()) ) {
4073:                     $xfIndex = self::_GetInt2d($recordData, 4 + 2 * $i);
4074:                     $this->_phpSheet->getCell($columnString . ($row + 1))->setXfIndex($this->_mapCellXfIndex[$xfIndex]);
4075:                 }
4076:             }
4077:         }
4078: 
4079:         // offset: 6; size 2; index to last column (not needed)
4080:     }
4081: 
4082: 
4083:     /**
4084:      * Read LABEL record
4085:      * This record represents a cell that contains a string. In
4086:      * BIFF8 it is usually replaced by the LABELSST record.
4087:      * Excel still uses this record, if it copies unformatted
4088:      * text cells to the clipboard.
4089:      *
4090:      * --   "OpenOffice.org's Documentation of the Microsoft
4091:      *      Excel File Format"
4092:      */
4093:     private function _readLabel()
4094:     {
4095:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
4096:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
4097: 
4098:         // move stream pointer to next record
4099:         $this->_pos += 4 + $length;
4100: 
4101:         // offset: 0; size: 2; index to row
4102:         $row = self::_GetInt2d($recordData, 0);
4103: 
4104:         // offset: 2; size: 2; index to column
4105:         $column = self::_GetInt2d($recordData, 2);
4106:         $columnString = PHPExcel_Cell::stringFromColumnIndex($column);
4107: 
4108:         // Read cell?
4109:         if (($this->getReadFilter() !== NULL) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->_phpSheet->getTitle()) ) {
4110:             // offset: 4; size: 2; XF index
4111:             $xfIndex = self::_GetInt2d($recordData, 4);
4112: 
4113:             // add cell value
4114:             // todo: what if string is very long? continue record
4115:             if ($this->_version == self::XLS_BIFF8) {
4116:                 $string = self::_readUnicodeStringLong(substr($recordData, 6));
4117:                 $value = $string['value'];
4118:             } else {
4119:                 $string = $this->_readByteStringLong(substr($recordData, 6));
4120:                 $value = $string['value'];
4121:             }
4122:             $cell = $this->_phpSheet->getCell($columnString . ($row + 1));
4123:             $cell->setValueExplicit($value, PHPExcel_Cell_DataType::TYPE_STRING);
4124: 
4125:             if (!$this->_readDataOnly) {
4126:                 // add cell style
4127:                 $cell->setXfIndex($this->_mapCellXfIndex[$xfIndex]);
4128:             }
4129:         }
4130:     }
4131: 
4132: 
4133:     /**
4134:      * Read BLANK record
4135:      */
4136:     private function _readBlank()
4137:     {
4138:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
4139:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
4140: 
4141:         // move stream pointer to next record
4142:         $this->_pos += 4 + $length;
4143: 
4144:         // offset: 0; size: 2; row index
4145:         $row = self::_GetInt2d($recordData, 0);
4146: 
4147:         // offset: 2; size: 2; col index
4148:         $col = self::_GetInt2d($recordData, 2);
4149:         $columnString = PHPExcel_Cell::stringFromColumnIndex($col);
4150: 
4151:         // Read cell?
4152:         if (($this->getReadFilter() !== NULL) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->_phpSheet->getTitle()) ) {
4153:             // offset: 4; size: 2; XF index
4154:             $xfIndex = self::_GetInt2d($recordData, 4);
4155: 
4156:             // add style information
4157:             if (!$this->_readDataOnly) {
4158:                 $this->_phpSheet->getCell($columnString . ($row + 1))->setXfIndex($this->_mapCellXfIndex[$xfIndex]);
4159:             }
4160:         }
4161: 
4162:     }
4163: 
4164: 
4165:     /**
4166:      * Read MSODRAWING record
4167:      */
4168:     private function _readMsoDrawing()
4169:     {
4170:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
4171: 
4172:         // get spliced record data
4173:         $splicedRecordData = $this->_getSplicedRecordData();
4174:         $recordData = $splicedRecordData['recordData'];
4175: 
4176:         $this->_drawingData .= $recordData;
4177:     }
4178: 
4179: 
4180:     /**
4181:      * Read OBJ record
4182:      */
4183:     private function _readObj()
4184:     {
4185:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
4186:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
4187: 
4188:         // move stream pointer to next record
4189:         $this->_pos += 4 + $length;
4190: 
4191:         if ($this->_readDataOnly || $this->_version != self::XLS_BIFF8) {
4192:             return;
4193:         }
4194: 
4195:         // recordData consists of an array of subrecords looking like this:
4196:         //  ft: 2 bytes; ftCmo type (0x15)
4197:         //  cb: 2 bytes; size in bytes of ftCmo data
4198:         //  ot: 2 bytes; Object Type
4199:         //  id: 2 bytes; Object id number
4200:         //  grbit: 2 bytes; Option Flags
4201:         //  data: var; subrecord data
4202: 
4203:         // for now, we are just interested in the second subrecord containing the object type
4204:         $ftCmoType  = self::_GetInt2d($recordData, 0);
4205:         $cbCmoSize  = self::_GetInt2d($recordData, 2);
4206:         $otObjType  = self::_GetInt2d($recordData, 4);
4207:         $idObjID    = self::_GetInt2d($recordData, 6);
4208:         $grbitOpts  = self::_GetInt2d($recordData, 6);
4209: 
4210:         $this->_objs[] = array(
4211:             'ftCmoType' => $ftCmoType,
4212:             'cbCmoSize' => $cbCmoSize,
4213:             'otObjType' => $otObjType,
4214:             'idObjID'   => $idObjID,
4215:             'grbitOpts' => $grbitOpts
4216:         );
4217:         $this->textObjRef = $idObjID;
4218: 
4219: //      echo '<b>_readObj()</b><br />';
4220: //      var_dump(end($this->_objs));
4221: //      echo '<br />';
4222:     }
4223: 
4224: 
4225:     /**
4226:      * Read WINDOW2 record
4227:      */
4228:     private function _readWindow2()
4229:     {
4230:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
4231:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
4232: 
4233:         // move stream pointer to next record
4234:         $this->_pos += 4 + $length;
4235: 
4236:         // offset: 0; size: 2; option flags
4237:         $options = self::_GetInt2d($recordData, 0);
4238: 
4239:         // offset: 2; size: 2; index to first visible row
4240:         $firstVisibleRow = self::_GetInt2d($recordData, 2);
4241: 
4242:         // offset: 4; size: 2; index to first visible colum
4243:         $firstVisibleColumn = self::_GetInt2d($recordData, 4);
4244:         if ($this->_version === self::XLS_BIFF8) {
4245:             // offset:  8; size: 2; not used
4246:             // offset: 10; size: 2; cached magnification factor in page break preview (in percent); 0 = Default (60%)
4247:             // offset: 12; size: 2; cached magnification factor in normal view (in percent); 0 = Default (100%)
4248:             // offset: 14; size: 4; not used
4249:             $zoomscaleInPageBreakPreview = self::_GetInt2d($recordData, 10);
4250:             if ($zoomscaleInPageBreakPreview === 0) $zoomscaleInPageBreakPreview = 60;
4251:             $zoomscaleInNormalView = self::_GetInt2d($recordData, 12);
4252:             if ($zoomscaleInNormalView === 0) $zoomscaleInNormalView = 100;
4253:         }
4254: 
4255:         // bit: 1; mask: 0x0002; 0 = do not show gridlines, 1 = show gridlines
4256:         $showGridlines = (bool) ((0x0002 & $options) >> 1);
4257:         $this->_phpSheet->setShowGridlines($showGridlines);
4258: 
4259:         // bit: 2; mask: 0x0004; 0 = do not show headers, 1 = show headers
4260:         $showRowColHeaders = (bool) ((0x0004 & $options) >> 2);
4261:         $this->_phpSheet->setShowRowColHeaders($showRowColHeaders);
4262: 
4263:         // bit: 3; mask: 0x0008; 0 = panes are not frozen, 1 = panes are frozen
4264:         $this->_frozen = (bool) ((0x0008 & $options) >> 3);
4265: 
4266:         // bit: 6; mask: 0x0040; 0 = columns from left to right, 1 = columns from right to left
4267:         $this->_phpSheet->setRightToLeft((bool)((0x0040 & $options) >> 6));
4268: 
4269:         // bit: 10; mask: 0x0400; 0 = sheet not active, 1 = sheet active
4270:         $isActive = (bool) ((0x0400 & $options) >> 10);
4271:         if ($isActive) {
4272:             $this->_phpExcel->setActiveSheetIndex($this->_phpExcel->getIndex($this->_phpSheet));
4273:         }
4274: 
4275:         // bit: 11; mask: 0x0800; 0 = normal view, 1 = page break view
4276:         $isPageBreakPreview = (bool) ((0x0800 & $options) >> 11);
4277: 
4278:         //FIXME: set $firstVisibleRow and $firstVisibleColumn
4279: 
4280:         if ($this->_phpSheet->getSheetView()->getView() !== PHPExcel_Worksheet_SheetView::SHEETVIEW_PAGE_LAYOUT) {
4281:             //NOTE: this setting is inferior to page layout view(Excel2007-)
4282:             $view = $isPageBreakPreview? PHPExcel_Worksheet_SheetView::SHEETVIEW_PAGE_BREAK_PREVIEW :
4283:                 PHPExcel_Worksheet_SheetView::SHEETVIEW_NORMAL;
4284:             $this->_phpSheet->getSheetView()->setView($view);
4285:             if ($this->_version === self::XLS_BIFF8) {
4286:                 $zoomScale = $isPageBreakPreview? $zoomscaleInPageBreakPreview : $zoomscaleInNormalView;
4287:                 $this->_phpSheet->getSheetView()->setZoomScale($zoomScale);
4288:                 $this->_phpSheet->getSheetView()->setZoomScaleNormal($zoomscaleInNormalView);
4289:             }
4290:         }
4291:     }
4292: 
4293:     /**
4294:      * Read PLV Record(Created by Excel2007 or upper)
4295:      */
4296:     private function _readPageLayoutView(){
4297:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
4298:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
4299: 
4300:         // move stream pointer to next record
4301:         $this->_pos += 4 + $length;
4302: 
4303:         //var_dump(unpack("vrt/vgrbitFrt/V2reserved/vwScalePLV/vgrbit", $recordData));
4304: 
4305:         // offset: 0; size: 2; rt
4306:         //->ignore
4307:         $rt = self::_GetInt2d($recordData, 0);
4308:         // offset: 2; size: 2; grbitfr
4309:         //->ignore
4310:         $grbitFrt = self::_GetInt2d($recordData, 2);
4311:         // offset: 4; size: 8; reserved
4312:         //->ignore
4313: 
4314:         // offset: 12; size 2; zoom scale
4315:         $wScalePLV = self::_GetInt2d($recordData, 12);
4316:         // offset: 14; size 2; grbit
4317:         $grbit = self::_GetInt2d($recordData, 14);
4318: 
4319:         // decomprise grbit
4320:         $fPageLayoutView   = $grbit & 0x01;
4321:         $fRulerVisible     = ($grbit >> 1) & 0x01; //no support
4322:         $fWhitespaceHidden = ($grbit >> 3) & 0x01; //no support
4323: 
4324:         if ($fPageLayoutView === 1) {
4325:             $this->_phpSheet->getSheetView()->setView(PHPExcel_Worksheet_SheetView::SHEETVIEW_PAGE_LAYOUT);
4326:             $this->_phpSheet->getSheetView()->setZoomScale($wScalePLV); //set by Excel2007 only if SHEETVIEW_PAGE_LAYOUT
4327:         }
4328:         //otherwise, we cannot know whether SHEETVIEW_PAGE_LAYOUT or SHEETVIEW_PAGE_BREAK_PREVIEW.
4329:     }
4330: 
4331:     /**
4332:      * Read SCL record
4333:      */
4334:     private function _readScl()
4335:     {
4336:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
4337:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
4338: 
4339:         // move stream pointer to next record
4340:         $this->_pos += 4 + $length;
4341: 
4342:         // offset: 0; size: 2; numerator of the view magnification
4343:         $numerator = self::_GetInt2d($recordData, 0);
4344: 
4345:         // offset: 2; size: 2; numerator of the view magnification
4346:         $denumerator = self::_GetInt2d($recordData, 2);
4347: 
4348:         // set the zoom scale (in percent)
4349:         $this->_phpSheet->getSheetView()->setZoomScale($numerator * 100 / $denumerator);
4350:     }
4351: 
4352: 
4353:     /**
4354:      * Read PANE record
4355:      */
4356:     private function _readPane()
4357:     {
4358:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
4359:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
4360: 
4361:         // move stream pointer to next record
4362:         $this->_pos += 4 + $length;
4363: 
4364:         if (!$this->_readDataOnly) {
4365:             // offset: 0; size: 2; position of vertical split
4366:             $px = self::_GetInt2d($recordData, 0);
4367: 
4368:             // offset: 2; size: 2; position of horizontal split
4369:             $py = self::_GetInt2d($recordData, 2);
4370: 
4371:             if ($this->_frozen) {
4372:                 // frozen panes
4373:                 $this->_phpSheet->freezePane(PHPExcel_Cell::stringFromColumnIndex($px) . ($py + 1));
4374:             } else {
4375:                 // unfrozen panes; split windows; not supported by PHPExcel core
4376:             }
4377:         }
4378:     }
4379: 
4380: 
4381:     /**
4382:      * Read SELECTION record. There is one such record for each pane in the sheet.
4383:      */
4384:     private function _readSelection()
4385:     {
4386:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
4387:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
4388: 
4389:         // move stream pointer to next record
4390:         $this->_pos += 4 + $length;
4391: 
4392:         if (!$this->_readDataOnly) {
4393:             // offset: 0; size: 1; pane identifier
4394:             $paneId = ord($recordData{0});
4395: 
4396:             // offset: 1; size: 2; index to row of the active cell
4397:             $r = self::_GetInt2d($recordData, 1);
4398: 
4399:             // offset: 3; size: 2; index to column of the active cell
4400:             $c = self::_GetInt2d($recordData, 3);
4401: 
4402:             // offset: 5; size: 2; index into the following cell range list to the
4403:             //  entry that contains the active cell
4404:             $index = self::_GetInt2d($recordData, 5);
4405: 
4406:             // offset: 7; size: var; cell range address list containing all selected cell ranges
4407:             $data = substr($recordData, 7);
4408:             $cellRangeAddressList = $this->_readBIFF5CellRangeAddressList($data); // note: also BIFF8 uses BIFF5 syntax
4409: 
4410:             $selectedCells = $cellRangeAddressList['cellRangeAddresses'][0];
4411: 
4412:             // first row '1' + last row '16384' indicates that full column is selected (apparently also in BIFF8!)
4413:             if (preg_match('/^([A-Z]+1\:[A-Z]+)16384$/', $selectedCells)) {
4414:                 $selectedCells = preg_replace('/^([A-Z]+1\:[A-Z]+)16384$/', '${1}1048576', $selectedCells);
4415:             }
4416: 
4417:             // first row '1' + last row '65536' indicates that full column is selected
4418:             if (preg_match('/^([A-Z]+1\:[A-Z]+)65536$/', $selectedCells)) {
4419:                 $selectedCells = preg_replace('/^([A-Z]+1\:[A-Z]+)65536$/', '${1}1048576', $selectedCells);
4420:             }
4421: 
4422:             // first column 'A' + last column 'IV' indicates that full row is selected
4423:             if (preg_match('/^(A[0-9]+\:)IV([0-9]+)$/', $selectedCells)) {
4424:                 $selectedCells = preg_replace('/^(A[0-9]+\:)IV([0-9]+)$/', '${1}XFD${2}', $selectedCells);
4425:             }
4426: 
4427:             $this->_phpSheet->setSelectedCells($selectedCells);
4428:         }
4429:     }
4430: 
4431: 
4432:     private function _includeCellRangeFiltered($cellRangeAddress)
4433:     {
4434:         $includeCellRange = true;
4435:         if ($this->getReadFilter() !== NULL) {
4436:             $includeCellRange = false;
4437:             $rangeBoundaries = PHPExcel_Cell::getRangeBoundaries($cellRangeAddress);
4438:             $rangeBoundaries[1][0]++;
4439:             for ($row = $rangeBoundaries[0][1]; $row <= $rangeBoundaries[1][1]; $row++) {
4440:                 for ($column = $rangeBoundaries[0][0]; $column != $rangeBoundaries[1][0]; $column++) {
4441:                     if ($this->getReadFilter()->readCell($column, $row, $this->_phpSheet->getTitle())) {
4442:                         $includeCellRange = true;
4443:                         break 2;
4444:                     }
4445:                 }
4446:             }
4447:         }
4448:         return $includeCellRange;
4449:     }
4450: 
4451: 
4452:     /**
4453:      * MERGEDCELLS
4454:      *
4455:      * This record contains the addresses of merged cell ranges
4456:      * in the current sheet.
4457:      *
4458:      * --   "OpenOffice.org's Documentation of the Microsoft
4459:      *      Excel File Format"
4460:      */
4461:     private function _readMergedCells()
4462:     {
4463:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
4464:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
4465: 
4466:         // move stream pointer to next record
4467:         $this->_pos += 4 + $length;
4468: 
4469:         if ($this->_version == self::XLS_BIFF8 && !$this->_readDataOnly) {
4470:             $cellRangeAddressList = $this->_readBIFF8CellRangeAddressList($recordData);
4471:             foreach ($cellRangeAddressList['cellRangeAddresses'] as $cellRangeAddress) {
4472:                 if ((strpos($cellRangeAddress,':') !== FALSE) &&
4473:                     ($this->_includeCellRangeFiltered($cellRangeAddress))) {
4474:                     $this->_phpSheet->mergeCells($cellRangeAddress);
4475:                 }
4476:             }
4477:         }
4478:     }
4479: 
4480: 
4481:     /**
4482:      * Read HYPERLINK record
4483:      */
4484:     private function _readHyperLink()
4485:     {
4486:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
4487:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
4488: 
4489:         // move stream pointer forward to next record
4490:         $this->_pos += 4 + $length;
4491: 
4492:         if (!$this->_readDataOnly) {
4493:             // offset: 0; size: 8; cell range address of all cells containing this hyperlink
4494:             try {
4495:                 $cellRange = $this->_readBIFF8CellRangeAddressFixed($recordData, 0, 8);
4496:             } catch (PHPExcel_Exception $e) {
4497:                 return;
4498:             }
4499: 
4500:             // offset: 8, size: 16; GUID of StdLink
4501: 
4502:             // offset: 24, size: 4; unknown value
4503: 
4504:             // offset: 28, size: 4; option flags
4505: 
4506:                 // bit: 0; mask: 0x00000001; 0 = no link or extant, 1 = file link or URL
4507:                 $isFileLinkOrUrl = (0x00000001 & self::_GetInt2d($recordData, 28)) >> 0;
4508: 
4509:                 // bit: 1; mask: 0x00000002; 0 = relative path, 1 = absolute path or URL
4510:                 $isAbsPathOrUrl = (0x00000001 & self::_GetInt2d($recordData, 28)) >> 1;
4511: 
4512:                 // bit: 2 (and 4); mask: 0x00000014; 0 = no description
4513:                 $hasDesc = (0x00000014 & self::_GetInt2d($recordData, 28)) >> 2;
4514: 
4515:                 // bit: 3; mask: 0x00000008; 0 = no text, 1 = has text
4516:                 $hasText = (0x00000008 & self::_GetInt2d($recordData, 28)) >> 3;
4517: 
4518:                 // bit: 7; mask: 0x00000080; 0 = no target frame, 1 = has target frame
4519:                 $hasFrame = (0x00000080 & self::_GetInt2d($recordData, 28)) >> 7;
4520: 
4521:                 // bit: 8; mask: 0x00000100; 0 = file link or URL, 1 = UNC path (inc. server name)
4522:                 $isUNC = (0x00000100 & self::_GetInt2d($recordData, 28)) >> 8;
4523: 
4524:             // offset within record data
4525:             $offset = 32;
4526: 
4527:             if ($hasDesc) {
4528:                 // offset: 32; size: var; character count of description text
4529:                 $dl = self::_GetInt4d($recordData, 32);
4530:                 // offset: 36; size: var; character array of description text, no Unicode string header, always 16-bit characters, zero terminated
4531:                 $desc = self::_encodeUTF16(substr($recordData, 36, 2 * ($dl - 1)), false);
4532:                 $offset += 4 + 2 * $dl;
4533:             }
4534:             if ($hasFrame) {
4535:                 $fl = self::_GetInt4d($recordData, $offset);
4536:                 $offset += 4 + 2 * $fl;
4537:             }
4538: 
4539:             // detect type of hyperlink (there are 4 types)
4540:             $hyperlinkType = null;
4541: 
4542:             if ($isUNC) {
4543:                 $hyperlinkType = 'UNC';
4544:             } else if (!$isFileLinkOrUrl) {
4545:                 $hyperlinkType = 'workbook';
4546:             } else if (ord($recordData{$offset}) == 0x03) {
4547:                 $hyperlinkType = 'local';
4548:             } else if (ord($recordData{$offset}) == 0xE0) {
4549:                 $hyperlinkType = 'URL';
4550:             }
4551: 
4552:             switch ($hyperlinkType) {
4553:             case 'URL':
4554:                 // section 5.58.2: Hyperlink containing a URL
4555:                 // e.g. http://example.org/index.php
4556: 
4557:                 // offset: var; size: 16; GUID of URL Moniker
4558:                 $offset += 16;
4559:                 // offset: var; size: 4; size (in bytes) of character array of the URL including trailing zero word
4560:                 $us = self::_GetInt4d($recordData, $offset);
4561:                 $offset += 4;
4562:                 // offset: var; size: $us; character array of the URL, no Unicode string header, always 16-bit characters, zero-terminated
4563:                 $url = self::_encodeUTF16(substr($recordData, $offset, $us - 2), false);
4564:                 $url .= $hasText ? '#' : '';
4565:                 $offset += $us;
4566:                 break;
4567: 
4568:             case 'local':
4569:                 // section 5.58.3: Hyperlink to local file
4570:                 // examples:
4571:                 //   mydoc.txt
4572:                 //   ../../somedoc.xls#Sheet!A1
4573: 
4574:                 // offset: var; size: 16; GUI of File Moniker
4575:                 $offset += 16;
4576: 
4577:                 // offset: var; size: 2; directory up-level count.
4578:                 $upLevelCount = self::_GetInt2d($recordData, $offset);
4579:                 $offset += 2;
4580: 
4581:                 // offset: var; size: 4; character count of the shortened file path and name, including trailing zero word
4582:                 $sl = self::_GetInt4d($recordData, $offset);
4583:                 $offset += 4;
4584: 
4585:                 // offset: var; size: sl; character array of the shortened file path and name in 8.3-DOS-format (compressed Unicode string)
4586:                 $shortenedFilePath = substr($recordData, $offset, $sl);
4587:                 $shortenedFilePath = self::_encodeUTF16($shortenedFilePath, true);
4588:                 $shortenedFilePath = substr($shortenedFilePath, 0, -1); // remove trailing zero
4589: 
4590:                 $offset += $sl;
4591: 
4592:                 // offset: var; size: 24; unknown sequence
4593:                 $offset += 24;
4594: 
4595:                 // extended file path
4596:                 // offset: var; size: 4; size of the following file link field including string lenth mark
4597:                 $sz = self::_GetInt4d($recordData, $offset);
4598:                 $offset += 4;
4599: 
4600:                 // only present if $sz > 0
4601:                 if ($sz > 0) {
4602:                     // offset: var; size: 4; size of the character array of the extended file path and name
4603:                     $xl = self::_GetInt4d($recordData, $offset);
4604:                     $offset += 4;
4605: 
4606:                     // offset: var; size 2; unknown
4607:                     $offset += 2;
4608: 
4609:                     // offset: var; size $xl; character array of the extended file path and name.
4610:                     $extendedFilePath = substr($recordData, $offset, $xl);
4611:                     $extendedFilePath = self::_encodeUTF16($extendedFilePath, false);
4612:                     $offset += $xl;
4613:                 }
4614: 
4615:                 // construct the path
4616:                 $url = str_repeat('..\\', $upLevelCount);
4617:                 $url .= ($sz > 0) ?
4618:                     $extendedFilePath : $shortenedFilePath; // use extended path if available
4619:                 $url .= $hasText ? '#' : '';
4620: 
4621:                 break;
4622: 
4623: 
4624:             case 'UNC':
4625:                 // section 5.58.4: Hyperlink to a File with UNC (Universal Naming Convention) Path
4626:                 // todo: implement
4627:                 return;
4628: 
4629:             case 'workbook':
4630:                 // section 5.58.5: Hyperlink to the Current Workbook
4631:                 // e.g. Sheet2!B1:C2, stored in text mark field
4632:                 $url = 'sheet://';
4633:                 break;
4634: 
4635:             default:
4636:                 return;
4637: 
4638:             }
4639: 
4640:             if ($hasText) {
4641:                 // offset: var; size: 4; character count of text mark including trailing zero word
4642:                 $tl = self::_GetInt4d($recordData, $offset);
4643:                 $offset += 4;
4644:                 // offset: var; size: var; character array of the text mark without the # sign, no Unicode header, always 16-bit characters, zero-terminated
4645:                 $text = self::_encodeUTF16(substr($recordData, $offset, 2 * ($tl - 1)), false);
4646:                 $url .= $text;
4647:             }
4648: 
4649:             // apply the hyperlink to all the relevant cells
4650:             foreach (PHPExcel_Cell::extractAllCellReferencesInRange($cellRange) as $coordinate) {
4651:                 $this->_phpSheet->getCell($coordinate)->getHyperLink()->setUrl($url);
4652:             }
4653:         }
4654:     }
4655: 
4656: 
4657:     /**
4658:      * Read DATAVALIDATIONS record
4659:      */
4660:     private function _readDataValidations()
4661:     {
4662:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
4663:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
4664: 
4665:         // move stream pointer forward to next record
4666:         $this->_pos += 4 + $length;
4667:     }
4668: 
4669: 
4670:     /**
4671:      * Read DATAVALIDATION record
4672:      */
4673:     private function _readDataValidation()
4674:     {
4675:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
4676:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
4677: 
4678:         // move stream pointer forward to next record
4679:         $this->_pos += 4 + $length;
4680: 
4681:         if ($this->_readDataOnly) {
4682:             return;
4683:         }
4684: 
4685:         // offset: 0; size: 4; Options
4686:         $options = self::_GetInt4d($recordData, 0);
4687: 
4688:         // bit: 0-3; mask: 0x0000000F; type
4689:         $type = (0x0000000F & $options) >> 0;
4690:         switch ($type) {
4691:             case 0x00:  $type = PHPExcel_Cell_DataValidation::TYPE_NONE;        break;
4692:             case 0x01:  $type = PHPExcel_Cell_DataValidation::TYPE_WHOLE;       break;
4693:             case 0x02:  $type = PHPExcel_Cell_DataValidation::TYPE_DECIMAL;     break;
4694:             case 0x03:  $type = PHPExcel_Cell_DataValidation::TYPE_LIST;        break;
4695:             case 0x04:  $type = PHPExcel_Cell_DataValidation::TYPE_DATE;        break;
4696:             case 0x05:  $type = PHPExcel_Cell_DataValidation::TYPE_TIME;        break;
4697:             case 0x06:  $type = PHPExcel_Cell_DataValidation::TYPE_TEXTLENGTH;  break;
4698:             case 0x07:  $type = PHPExcel_Cell_DataValidation::TYPE_CUSTOM;      break;
4699:         }
4700: 
4701:         // bit: 4-6; mask: 0x00000070; error type
4702:         $errorStyle = (0x00000070 & $options) >> 4;
4703:         switch ($errorStyle) {
4704:             case 0x00:  $errorStyle = PHPExcel_Cell_DataValidation::STYLE_STOP;         break;
4705:             case 0x01:  $errorStyle = PHPExcel_Cell_DataValidation::STYLE_WARNING;      break;
4706:             case 0x02:  $errorStyle = PHPExcel_Cell_DataValidation::STYLE_INFORMATION;  break;
4707:         }
4708: 
4709:         // bit: 7; mask: 0x00000080; 1= formula is explicit (only applies to list)
4710:         // I have only seen cases where this is 1
4711:         $explicitFormula = (0x00000080 & $options) >> 7;
4712: 
4713:         // bit: 8; mask: 0x00000100; 1= empty cells allowed
4714:         $allowBlank = (0x00000100 & $options) >> 8;
4715: 
4716:         // bit: 9; mask: 0x00000200; 1= suppress drop down arrow in list type validity
4717:         $suppressDropDown = (0x00000200 & $options) >> 9;
4718: 
4719:         // bit: 18; mask: 0x00040000; 1= show prompt box if cell selected
4720:         $showInputMessage = (0x00040000 & $options) >> 18;
4721: 
4722:         // bit: 19; mask: 0x00080000; 1= show error box if invalid values entered
4723:         $showErrorMessage = (0x00080000 & $options) >> 19;
4724: 
4725:         // bit: 20-23; mask: 0x00F00000; condition operator
4726:         $operator = (0x00F00000 & $options) >> 20;
4727:         switch ($operator) {
4728:             case 0x00: $operator = PHPExcel_Cell_DataValidation::OPERATOR_BETWEEN           ;   break;
4729:             case 0x01: $operator = PHPExcel_Cell_DataValidation::OPERATOR_NOTBETWEEN        ;   break;
4730:             case 0x02: $operator = PHPExcel_Cell_DataValidation::OPERATOR_EQUAL             ;   break;
4731:             case 0x03: $operator = PHPExcel_Cell_DataValidation::OPERATOR_NOTEQUAL          ;   break;
4732:             case 0x04: $operator = PHPExcel_Cell_DataValidation::OPERATOR_GREATERTHAN       ;   break;
4733:             case 0x05: $operator = PHPExcel_Cell_DataValidation::OPERATOR_LESSTHAN          ;   break;
4734:             case 0x06: $operator = PHPExcel_Cell_DataValidation::OPERATOR_GREATERTHANOREQUAL;   break;
4735:             case 0x07: $operator = PHPExcel_Cell_DataValidation::OPERATOR_LESSTHANOREQUAL   ;   break;
4736:         }
4737: 
4738:         // offset: 4; size: var; title of the prompt box
4739:         $offset = 4;
4740:         $string = self::_readUnicodeStringLong(substr($recordData, $offset));
4741:         $promptTitle = $string['value'] !== chr(0) ?
4742:             $string['value'] : '';
4743:         $offset += $string['size'];
4744: 
4745:         // offset: var; size: var; title of the error box
4746:         $string = self::_readUnicodeStringLong(substr($recordData, $offset));
4747:         $errorTitle = $string['value'] !== chr(0) ?
4748:             $string['value'] : '';
4749:         $offset += $string['size'];
4750: 
4751:         // offset: var; size: var; text of the prompt box
4752:         $string = self::_readUnicodeStringLong(substr($recordData, $offset));
4753:         $prompt = $string['value'] !== chr(0) ?
4754:             $string['value'] : '';
4755:         $offset += $string['size'];
4756: 
4757:         // offset: var; size: var; text of the error box
4758:         $string = self::_readUnicodeStringLong(substr($recordData, $offset));
4759:         $error = $string['value'] !== chr(0) ?
4760:             $string['value'] : '';
4761:         $offset += $string['size'];
4762: 
4763:         // offset: var; size: 2; size of the formula data for the first condition
4764:         $sz1 = self::_GetInt2d($recordData, $offset);
4765:         $offset += 2;
4766: 
4767:         // offset: var; size: 2; not used
4768:         $offset += 2;
4769: 
4770:         // offset: var; size: $sz1; formula data for first condition (without size field)
4771:         $formula1 = substr($recordData, $offset, $sz1);
4772:         $formula1 = pack('v', $sz1) . $formula1; // prepend the length
4773:         try {
4774:             $formula1 = $this->_getFormulaFromStructure($formula1);
4775: 
4776:             // in list type validity, null characters are used as item separators
4777:             if ($type == PHPExcel_Cell_DataValidation::TYPE_LIST) {
4778:                 $formula1 = str_replace(chr(0), ',', $formula1);
4779:             }
4780:         } catch (PHPExcel_Exception $e) {
4781:             return;
4782:         }
4783:         $offset += $sz1;
4784: 
4785:         // offset: var; size: 2; size of the formula data for the first condition
4786:         $sz2 = self::_GetInt2d($recordData, $offset);
4787:         $offset += 2;
4788: 
4789:         // offset: var; size: 2; not used
4790:         $offset += 2;
4791: 
4792:         // offset: var; size: $sz2; formula data for second condition (without size field)
4793:         $formula2 = substr($recordData, $offset, $sz2);
4794:         $formula2 = pack('v', $sz2) . $formula2; // prepend the length
4795:         try {
4796:             $formula2 = $this->_getFormulaFromStructure($formula2);
4797:         } catch (PHPExcel_Exception $e) {
4798:             return;
4799:         }
4800:         $offset += $sz2;
4801: 
4802:         // offset: var; size: var; cell range address list with
4803:         $cellRangeAddressList = $this->_readBIFF8CellRangeAddressList(substr($recordData, $offset));
4804:         $cellRangeAddresses = $cellRangeAddressList['cellRangeAddresses'];
4805: 
4806:         foreach ($cellRangeAddresses as $cellRange) {
4807:             $stRange = $this->_phpSheet->shrinkRangeToFit($cellRange);
4808:             $stRange = PHPExcel_Cell::extractAllCellReferencesInRange($stRange);
4809:             foreach ($stRange as $coordinate) {
4810:                 $objValidation = $this->_phpSheet->getCell($coordinate)->getDataValidation();
4811:                 $objValidation->setType($type);
4812:                 $objValidation->setErrorStyle($errorStyle);
4813:                 $objValidation->setAllowBlank((bool)$allowBlank);
4814:                 $objValidation->setShowInputMessage((bool)$showInputMessage);
4815:                 $objValidation->setShowErrorMessage((bool)$showErrorMessage);
4816:                 $objValidation->setShowDropDown(!$suppressDropDown);
4817:                 $objValidation->setOperator($operator);
4818:                 $objValidation->setErrorTitle($errorTitle);
4819:                 $objValidation->setError($error);
4820:                 $objValidation->setPromptTitle($promptTitle);
4821:                 $objValidation->setPrompt($prompt);
4822:                 $objValidation->setFormula1($formula1);
4823:                 $objValidation->setFormula2($formula2);
4824:             }
4825:         }
4826: 
4827:     }
4828: 
4829: 
4830:     /**
4831:      * Read SHEETLAYOUT record. Stores sheet tab color information.
4832:      */
4833:     private function _readSheetLayout()
4834:     {
4835:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
4836:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
4837: 
4838:         // move stream pointer to next record
4839:         $this->_pos += 4 + $length;
4840: 
4841:         // local pointer in record data
4842:         $offset = 0;
4843: 
4844:         if (!$this->_readDataOnly) {
4845:             // offset: 0; size: 2; repeated record identifier 0x0862
4846: 
4847:             // offset: 2; size: 10; not used
4848: 
4849:             // offset: 12; size: 4; size of record data
4850:             // Excel 2003 uses size of 0x14 (documented), Excel 2007 uses size of 0x28 (not documented?)
4851:             $sz = self::_GetInt4d($recordData, 12);
4852: 
4853:             switch ($sz) {
4854:                 case 0x14:
4855:                     // offset: 16; size: 2; color index for sheet tab
4856:                     $colorIndex = self::_GetInt2d($recordData, 16);
4857:                     $color = self::_readColor($colorIndex,$this->_palette,$this->_version);
4858:                     $this->_phpSheet->getTabColor()->setRGB($color['rgb']);
4859:                     break;
4860: 
4861:                 case 0x28:
4862:                     // TODO: Investigate structure for .xls SHEETLAYOUT record as saved by MS Office Excel 2007
4863:                     return;
4864:                     break;
4865:             }
4866:         }
4867:     }
4868: 
4869: 
4870:     /**
4871:      * Read SHEETPROTECTION record (FEATHEADR)
4872:      */
4873:     private function _readSheetProtection()
4874:     {
4875:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
4876:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
4877: 
4878:         // move stream pointer to next record
4879:         $this->_pos += 4 + $length;
4880: 
4881:         if ($this->_readDataOnly) {
4882:             return;
4883:         }
4884: 
4885:         // offset: 0; size: 2; repeated record header
4886: 
4887:         // offset: 2; size: 2; FRT cell reference flag (=0 currently)
4888: 
4889:         // offset: 4; size: 8; Currently not used and set to 0
4890: 
4891:         // offset: 12; size: 2; Shared feature type index (2=Enhanced Protetion, 4=SmartTag)
4892:         $isf = self::_GetInt2d($recordData, 12);
4893:         if ($isf != 2) {
4894:             return;
4895:         }
4896: 
4897:         // offset: 14; size: 1; =1 since this is a feat header
4898: 
4899:         // offset: 15; size: 4; size of rgbHdrSData
4900: 
4901:         // rgbHdrSData, assume "Enhanced Protection"
4902:         // offset: 19; size: 2; option flags
4903:         $options = self::_GetInt2d($recordData, 19);
4904: 
4905:         // bit: 0; mask 0x0001; 1 = user may edit objects, 0 = users must not edit objects
4906:         $bool = (0x0001 & $options) >> 0;
4907:         $this->_phpSheet->getProtection()->setObjects(!$bool);
4908: 
4909:         // bit: 1; mask 0x0002; edit scenarios
4910:         $bool = (0x0002 & $options) >> 1;
4911:         $this->_phpSheet->getProtection()->setScenarios(!$bool);
4912: 
4913:         // bit: 2; mask 0x0004; format cells
4914:         $bool = (0x0004 & $options) >> 2;
4915:         $this->_phpSheet->getProtection()->setFormatCells(!$bool);
4916: 
4917:         // bit: 3; mask 0x0008; format columns
4918:         $bool = (0x0008 & $options) >> 3;
4919:         $this->_phpSheet->getProtection()->setFormatColumns(!$bool);
4920: 
4921:         // bit: 4; mask 0x0010; format rows
4922:         $bool = (0x0010 & $options) >> 4;
4923:         $this->_phpSheet->getProtection()->setFormatRows(!$bool);
4924: 
4925:         // bit: 5; mask 0x0020; insert columns
4926:         $bool = (0x0020 & $options) >> 5;
4927:         $this->_phpSheet->getProtection()->setInsertColumns(!$bool);
4928: 
4929:         // bit: 6; mask 0x0040; insert rows
4930:         $bool = (0x0040 & $options) >> 6;
4931:         $this->_phpSheet->getProtection()->setInsertRows(!$bool);
4932: 
4933:         // bit: 7; mask 0x0080; insert hyperlinks
4934:         $bool = (0x0080 & $options) >> 7;
4935:         $this->_phpSheet->getProtection()->setInsertHyperlinks(!$bool);
4936: 
4937:         // bit: 8; mask 0x0100; delete columns
4938:         $bool = (0x0100 & $options) >> 8;
4939:         $this->_phpSheet->getProtection()->setDeleteColumns(!$bool);
4940: 
4941:         // bit: 9; mask 0x0200; delete rows
4942:         $bool = (0x0200 & $options) >> 9;
4943:         $this->_phpSheet->getProtection()->setDeleteRows(!$bool);
4944: 
4945:         // bit: 10; mask 0x0400; select locked cells
4946:         $bool = (0x0400 & $options) >> 10;
4947:         $this->_phpSheet->getProtection()->setSelectLockedCells(!$bool);
4948: 
4949:         // bit: 11; mask 0x0800; sort cell range
4950:         $bool = (0x0800 & $options) >> 11;
4951:         $this->_phpSheet->getProtection()->setSort(!$bool);
4952: 
4953:         // bit: 12; mask 0x1000; auto filter
4954:         $bool = (0x1000 & $options) >> 12;
4955:         $this->_phpSheet->getProtection()->setAutoFilter(!$bool);
4956: 
4957:         // bit: 13; mask 0x2000; pivot tables
4958:         $bool = (0x2000 & $options) >> 13;
4959:         $this->_phpSheet->getProtection()->setPivotTables(!$bool);
4960: 
4961:         // bit: 14; mask 0x4000; select unlocked cells
4962:         $bool = (0x4000 & $options) >> 14;
4963:         $this->_phpSheet->getProtection()->setSelectUnlockedCells(!$bool);
4964: 
4965:         // offset: 21; size: 2; not used
4966:     }
4967: 
4968: 
4969:     /**
4970:      * Read RANGEPROTECTION record
4971:      * Reading of this record is based on Microsoft Office Excel 97-2000 Binary File Format Specification,
4972:      * where it is referred to as FEAT record
4973:      */
4974:     private function _readRangeProtection()
4975:     {
4976:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
4977:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
4978: 
4979:         // move stream pointer to next record
4980:         $this->_pos += 4 + $length;
4981: 
4982:         // local pointer in record data
4983:         $offset = 0;
4984: 
4985:         if (!$this->_readDataOnly) {
4986:             $offset += 12;
4987: 
4988:             // offset: 12; size: 2; shared feature type, 2 = enhanced protection, 4 = smart tag
4989:             $isf = self::_GetInt2d($recordData, 12);
4990:             if ($isf != 2) {
4991:                 // we only read FEAT records of type 2
4992:                 return;
4993:             }
4994:             $offset += 2;
4995: 
4996:             $offset += 5;
4997: 
4998:             // offset: 19; size: 2; count of ref ranges this feature is on
4999:             $cref = self::_GetInt2d($recordData, 19);
5000:             $offset += 2;
5001: 
5002:             $offset += 6;
5003: 
5004:             // offset: 27; size: 8 * $cref; list of cell ranges (like in hyperlink record)
5005:             $cellRanges = array();
5006:             for ($i = 0; $i < $cref; ++$i) {
5007:                 try {
5008:                     $cellRange = $this->_readBIFF8CellRangeAddressFixed(substr($recordData, 27 + 8 * $i, 8));
5009:                 } catch (PHPExcel_Exception $e) {
5010:                     return;
5011:                 }
5012:                 $cellRanges[] = $cellRange;
5013:                 $offset += 8;
5014:             }
5015: 
5016:             // offset: var; size: var; variable length of feature specific data
5017:             $rgbFeat = substr($recordData, $offset);
5018:             $offset += 4;
5019: 
5020:             // offset: var; size: 4; the encrypted password (only 16-bit although field is 32-bit)
5021:             $wPassword = self::_GetInt4d($recordData, $offset);
5022:             $offset += 4;
5023: 
5024:             // Apply range protection to sheet
5025:             if ($cellRanges) {
5026:                 $this->_phpSheet->protectCells(implode(' ', $cellRanges), strtoupper(dechex($wPassword)), true);
5027:             }
5028:         }
5029:     }
5030: 
5031: 
5032:     /**
5033:      * Read IMDATA record
5034:      */
5035:     private function _readImData()
5036:     {
5037:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
5038: 
5039:         // get spliced record data
5040:         $splicedRecordData = $this->_getSplicedRecordData();
5041:         $recordData = $splicedRecordData['recordData'];
5042: 
5043:         // UNDER CONSTRUCTION
5044: 
5045:         // offset: 0; size: 2; image format
5046:         $cf = self::_GetInt2d($recordData, 0);
5047: 
5048:         // offset: 2; size: 2; environment from which the file was written
5049:         $env = self::_GetInt2d($recordData, 2);
5050: 
5051:         // offset: 4; size: 4; length of the image data
5052:         $lcb = self::_GetInt4d($recordData, 4);
5053: 
5054:         // offset: 8; size: var; image data
5055:         $iData = substr($recordData, 8);
5056: 
5057:         switch ($cf) {
5058:         case 0x09: // Windows bitmap format
5059:             // BITMAPCOREINFO
5060:             // 1. BITMAPCOREHEADER
5061:             // offset: 0; size: 4; bcSize, Specifies the number of bytes required by the structure
5062:             $bcSize = self::_GetInt4d($iData, 0);
5063: //          var_dump($bcSize);
5064: 
5065:             // offset: 4; size: 2; bcWidth, specifies the width of the bitmap, in pixels
5066:             $bcWidth = self::_GetInt2d($iData, 4);
5067: //          var_dump($bcWidth);
5068: 
5069:             // offset: 6; size: 2; bcHeight, specifies the height of the bitmap, in pixels.
5070:             $bcHeight = self::_GetInt2d($iData, 6);
5071: //          var_dump($bcHeight);
5072:             $ih = imagecreatetruecolor($bcWidth, $bcHeight);
5073: 
5074:             // offset: 8; size: 2; bcPlanes, specifies the number of planes for the target device. This value must be 1
5075: 
5076:             // offset: 10; size: 2; bcBitCount specifies the number of bits-per-pixel. This value must be 1, 4, 8, or 24
5077:             $bcBitCount = self::_GetInt2d($iData, 10);
5078: //          var_dump($bcBitCount);
5079: 
5080:             $rgbString = substr($iData, 12);
5081:             $rgbTriples = array();
5082:             while (strlen($rgbString) > 0) {
5083:                 $rgbTriples[] = unpack('Cb/Cg/Cr', $rgbString);
5084:                 $rgbString = substr($rgbString, 3);
5085:             }
5086:             $x = 0;
5087:             $y = 0;
5088:             foreach ($rgbTriples as $i => $rgbTriple) {
5089:                 $color = imagecolorallocate($ih, $rgbTriple['r'], $rgbTriple['g'], $rgbTriple['b']);
5090:                 imagesetpixel($ih, $x, $bcHeight - 1 - $y, $color);
5091:                 $x = ($x + 1) % $bcWidth;
5092:                 $y = $y + floor(($x + 1) / $bcWidth);
5093:             }
5094:             //imagepng($ih, 'image.png');
5095: 
5096:             $drawing = new PHPExcel_Worksheet_Drawing();
5097:             $drawing->setPath($filename);
5098:             $drawing->setWorksheet($this->_phpSheet);
5099: 
5100:             break;
5101: 
5102:         case 0x02: // Windows metafile or Macintosh PICT format
5103:         case 0x0e: // native format
5104:         default;
5105:             break;
5106: 
5107:         }
5108: 
5109:         // _getSplicedRecordData() takes care of moving current position in data stream
5110:     }
5111: 
5112: 
5113:     /**
5114:      * Read a free CONTINUE record. Free CONTINUE record may be a camouflaged MSODRAWING record
5115:      * When MSODRAWING data on a sheet exceeds 8224 bytes, CONTINUE records are used instead. Undocumented.
5116:      * In this case, we must treat the CONTINUE record as a MSODRAWING record
5117:      */
5118:     private function _readContinue()
5119:     {
5120:         $length = self::_GetInt2d($this->_data, $this->_pos + 2);
5121:         $recordData = $this->_readRecordData($this->_data, $this->_pos + 4, $length);
5122: 
5123:         // check if we are reading drawing data
5124:         // this is in case a free CONTINUE record occurs in other circumstances we are unaware of
5125:         if ($this->_drawingData == '') {
5126:             // move stream pointer to next record
5127:             $this->_pos += 4 + $length;
5128: 
5129:             return;
5130:         }
5131: 
5132:         // check if record data is at least 4 bytes long, otherwise there is no chance this is MSODRAWING data
5133:         if ($length < 4) {
5134:             // move stream pointer to next record
5135:             $this->_pos += 4 + $length;
5136: 
5137:             return;
5138:         }
5139: 
5140:         // dirty check to see if CONTINUE record could be a camouflaged MSODRAWING record
5141:         // look inside CONTINUE record to see if it looks like a part of an Escher stream
5142:         // we know that Escher stream may be split at least at
5143:         //      0xF003 MsofbtSpgrContainer
5144:         //      0xF004 MsofbtSpContainer
5145:         //      0xF00D MsofbtClientTextbox
5146:         $validSplitPoints = array(0xF003, 0xF004, 0xF00D); // add identifiers if we find more
5147: 
5148:         $splitPoint = self::_GetInt2d($recordData, 2);
5149:         if (in_array($splitPoint, $validSplitPoints)) {
5150:             // get spliced record data (and move pointer to next record)
5151:             $splicedRecordData = $this->_getSplicedRecordData();
5152:             $this->_drawingData .= $splicedRecordData['recordData'];
5153: 
5154:             return;
5155:         }
5156: 
5157:         // move stream pointer to next record
5158:         $this->_pos += 4 + $length;
5159: 
5160:     }
5161: 
5162: 
5163:     /**
5164:      * Reads a record from current position in data stream and continues reading data as long as CONTINUE
5165:      * records are found. Splices the record data pieces and returns the combined string as if record data
5166:      * is in one piece.
5167:      * Moves to next current position in data stream to start of next record different from a CONtINUE record
5168:      *
5169:      * @return array
5170:      */
5171:     private function _getSplicedRecordData()
5172:     {
5173:         $data = '';
5174:         $spliceOffsets = array();
5175: 
5176:         $i = 0;
5177:         $spliceOffsets[0] = 0;
5178: 
5179:         do {
5180:             ++$i;
5181: 
5182:             // offset: 0; size: 2; identifier
5183:             $identifier = self::_GetInt2d($this->_data, $this->_pos);
5184:             // offset: 2; size: 2; length
5185:             $length = self::_GetInt2d($this->_data, $this->_pos + 2);
5186:             $data .= $this->_readRecordData($this->_data, $this->_pos + 4, $length);
5187: 
5188:             $spliceOffsets[$i] = $spliceOffsets[$i - 1] + $length;
5189: 
5190:             $this->_pos += 4 + $length;
5191:             $nextIdentifier = self::_GetInt2d($this->_data, $this->_pos);
5192:         }
5193:         while ($nextIdentifier == self::XLS_Type_CONTINUE);
5194: 
5195:         $splicedData = array(
5196:             'recordData' => $data,
5197:             'spliceOffsets' => $spliceOffsets,
5198:         );
5199: 
5200:         return $splicedData;
5201: 
5202:     }
5203: 
5204: 
5205:     /**
5206:      * Convert formula structure into human readable Excel formula like 'A3+A5*5'
5207:      *
5208:      * @param string $formulaStructure The complete binary data for the formula
5209:      * @param string $baseCell Base cell, only needed when formula contains tRefN tokens, e.g. with shared formulas
5210:      * @return string Human readable formula
5211:      */
5212:     private function _getFormulaFromStructure($formulaStructure, $baseCell = 'A1')
5213:     {
5214:         // offset: 0; size: 2; size of the following formula data
5215:         $sz = self::_GetInt2d($formulaStructure, 0);
5216: 
5217:         // offset: 2; size: sz
5218:         $formulaData = substr($formulaStructure, 2, $sz);
5219: 
5220:         // for debug: dump the formula data
5221:         //echo '<xmp>';
5222:         //echo 'size: ' . $sz . "\n";
5223:         //echo 'the entire formula data: ';
5224:         //Debug::dump($formulaData);
5225:         //echo "\n----\n";
5226: 
5227:         // offset: 2 + sz; size: variable (optional)
5228:         if (strlen($formulaStructure) > 2 + $sz) {
5229:             $additionalData = substr($formulaStructure, 2 + $sz);
5230: 
5231:             // for debug: dump the additional data
5232:             //echo 'the entire additional data: ';
5233:             //Debug::dump($additionalData);
5234:             //echo "\n----\n";
5235: 
5236:         } else {
5237:             $additionalData = '';
5238:         }
5239: 
5240:         return $this->_getFormulaFromData($formulaData, $additionalData, $baseCell);
5241:     }
5242: 
5243: 
5244:     /**
5245:      * Take formula data and additional data for formula and return human readable formula
5246:      *
5247:      * @param string $formulaData The binary data for the formula itself
5248:      * @param string $additionalData Additional binary data going with the formula
5249:      * @param string $baseCell Base cell, only needed when formula contains tRefN tokens, e.g. with shared formulas
5250:      * @return string Human readable formula
5251:      */
5252:     private function _getFormulaFromData($formulaData,  $additionalData = '', $baseCell = 'A1')
5253:     {
5254:         // start parsing the formula data
5255:         $tokens = array();
5256: 
5257:         while (strlen($formulaData) > 0 and $token = $this->_getNextToken($formulaData, $baseCell)) {
5258:             $tokens[] = $token;
5259:             $formulaData = substr($formulaData, $token['size']);
5260: 
5261:             // for debug: dump the token
5262:             //var_dump($token);
5263:         }
5264: 
5265:         $formulaString = $this->_createFormulaFromTokens($tokens, $additionalData);
5266: 
5267:         return $formulaString;
5268:     }
5269: 
5270: 
5271:     /**
5272:      * Take array of tokens together with additional data for formula and return human readable formula
5273:      *
5274:      * @param array $tokens
5275:      * @param array $additionalData Additional binary data going with the formula
5276:      * @param string $baseCell Base cell, only needed when formula contains tRefN tokens, e.g. with shared formulas
5277:      * @return string Human readable formula
5278:      */
5279:     private function _createFormulaFromTokens($tokens, $additionalData)
5280:     {
5281:         // empty formula?
5282:         if (empty($tokens)) {
5283:             return '';
5284:         }
5285: 
5286:         $formulaStrings = array();
5287:         foreach ($tokens as $token) {
5288:             // initialize spaces
5289:             $space0 = isset($space0) ? $space0 : ''; // spaces before next token, not tParen
5290:             $space1 = isset($space1) ? $space1 : ''; // carriage returns before next token, not tParen
5291:             $space2 = isset($space2) ? $space2 : ''; // spaces before opening parenthesis
5292:             $space3 = isset($space3) ? $space3 : ''; // carriage returns before opening parenthesis
5293:             $space4 = isset($space4) ? $space4 : ''; // spaces before closing parenthesis
5294:             $space5 = isset($space5) ? $space5 : ''; // carriage returns before closing parenthesis
5295: 
5296:             switch ($token['name']) {
5297:             case 'tAdd': // addition
5298:             case 'tConcat': // addition
5299:             case 'tDiv': // division
5300:             case 'tEQ': // equality
5301:             case 'tGE': // greater than or equal
5302:             case 'tGT': // greater than
5303:             case 'tIsect': // intersection
5304:             case 'tLE': // less than or equal
5305:             case 'tList': // less than or equal
5306:             case 'tLT': // less than
5307:             case 'tMul': // multiplication
5308:             case 'tNE': // multiplication
5309:             case 'tPower': // power
5310:             case 'tRange': // range
5311:             case 'tSub': // subtraction
5312:                 $op2 = array_pop($formulaStrings);
5313:                 $op1 = array_pop($formulaStrings);
5314:                 $formulaStrings[] = "$op1$space1$space0{$token['data']}$op2";
5315:                 unset($space0, $space1);
5316:                 break;
5317:             case 'tUplus': // unary plus
5318:             case 'tUminus': // unary minus
5319:                 $op = array_pop($formulaStrings);
5320:                 $formulaStrings[] = "$space1$space0{$token['data']}$op";
5321:                 unset($space0, $space1);
5322:                 break;
5323:             case 'tPercent': // percent sign
5324:                 $op = array_pop($formulaStrings);
5325:                 $formulaStrings[] = "$op$space1$space0{$token['data']}";
5326:                 unset($space0, $space1);
5327:                 break;
5328:             case 'tAttrVolatile': // indicates volatile function
5329:             case 'tAttrIf':
5330:             case 'tAttrSkip':
5331:             case 'tAttrChoose':
5332:                 // token is only important for Excel formula evaluator
5333:                 // do nothing
5334:                 break;
5335:             case 'tAttrSpace': // space / carriage return
5336:                 // space will be used when next token arrives, do not alter formulaString stack
5337:                 switch ($token['data']['spacetype']) {
5338:                 case 'type0':
5339:                     $space0 = str_repeat(' ', $token['data']['spacecount']);
5340:                     break;
5341:                 case 'type1':
5342:                     $space1 = str_repeat("\n", $token['data']['spacecount']);
5343:                     break;
5344:                 case 'type2':
5345:                     $space2 = str_repeat(' ', $token['data']['spacecount']);
5346:                     break;
5347:                 case 'type3':
5348:                     $space3 = str_repeat("\n", $token['data']['spacecount']);
5349:                     break;
5350:                 case 'type4':
5351:                     $space4 = str_repeat(' ', $token['data']['spacecount']);
5352:                     break;
5353:                 case 'type5':
5354:                     $space5 = str_repeat("\n", $token['data']['spacecount']);
5355:                     break;
5356:                 }
5357:                 break;
5358:             case 'tAttrSum': // SUM function with one parameter
5359:                 $op = array_pop($formulaStrings);
5360:                 $formulaStrings[] = "{$space1}{$space0}SUM($op)";
5361:                 unset($space0, $space1);
5362:                 break;
5363:             case 'tFunc': // function with fixed number of arguments
5364:             case 'tFuncV': // function with variable number of arguments
5365:                 if ($token['data']['function'] != '') {
5366:                     // normal function
5367:                     $ops = array(); // array of operators
5368:                     for ($i = 0; $i < $token['data']['args']; ++$i) {
5369:                         $ops[] = array_pop($formulaStrings);
5370:                     }
5371:                     $ops = array_reverse($ops);
5372:                     $formulaStrings[] = "$space1$space0{$token['data']['function']}(" . implode(',', $ops) . ")";
5373:                     unset($space0, $space1);
5374:                 } else {
5375:                     // add-in function
5376:                     $ops = array(); // array of operators
5377:                     for ($i = 0; $i < $token['data']['args'] - 1; ++$i) {
5378:                         $ops[] = array_pop($formulaStrings);
5379:                     }
5380:                     $ops = array_reverse($ops);
5381:                     $function = array_pop($formulaStrings);
5382:                     $formulaStrings[] = "$space1$space0$function(" . implode(',', $ops) . ")";
5383:                     unset($space0, $space1);
5384:                 }
5385:                 break;
5386:             case 'tParen': // parenthesis
5387:                 $expression = array_pop($formulaStrings);
5388:                 $formulaStrings[] = "$space3$space2($expression$space5$space4)";
5389:                 unset($space2, $space3, $space4, $space5);
5390:                 break;
5391:             case 'tArray': // array constant
5392:                 $constantArray = self::_readBIFF8ConstantArray($additionalData);
5393:                 $formulaStrings[] = $space1 . $space0 . $constantArray['value'];
5394:                 $additionalData = substr($additionalData, $constantArray['size']); // bite of chunk of additional data
5395:                 unset($space0, $space1);
5396:                 break;
5397:             case 'tMemArea':
5398:                 // bite off chunk of additional data
5399:                 $cellRangeAddressList = $this->_readBIFF8CellRangeAddressList($additionalData);
5400:                 $additionalData = substr($additionalData, $cellRangeAddressList['size']);
5401:                 $formulaStrings[] = "$space1$space0{$token['data']}";
5402:                 unset($space0, $space1);
5403:                 break;
5404:             case 'tArea': // cell range address
5405:             case 'tBool': // boolean
5406:             case 'tErr': // error code
5407:             case 'tInt': // integer
5408:             case 'tMemErr':
5409:             case 'tMemFunc':
5410:             case 'tMissArg':
5411:             case 'tName':
5412:             case 'tNameX':
5413:             case 'tNum': // number
5414:             case 'tRef': // single cell reference
5415:             case 'tRef3d': // 3d cell reference
5416:             case 'tArea3d': // 3d cell range reference
5417:             case 'tRefN':
5418:             case 'tAreaN':
5419:             case 'tStr': // string
5420:                 $formulaStrings[] = "$space1$space0{$token['data']}";
5421:                 unset($space0, $space1);
5422:                 break;
5423:             }
5424:         }
5425:         $formulaString = $formulaStrings[0];
5426: 
5427:         // for debug: dump the human readable formula
5428:         //echo '----' . "\n";
5429:         //echo 'Formula: ' . $formulaString;
5430: 
5431:         return $formulaString;
5432:     }
5433: 
5434: 
5435:     /**
5436:      * Fetch next token from binary formula data
5437:      *
5438:      * @param string Formula data
5439:      * @param string $baseCell Base cell, only needed when formula contains tRefN tokens, e.g. with shared formulas
5440:      * @return array
5441:      * @throws PHPExcel_Reader_Exception
5442:      */
5443:     private function _getNextToken($formulaData, $baseCell = 'A1')
5444:     {
5445:         // offset: 0; size: 1; token id
5446:         $id = ord($formulaData[0]); // token id
5447:         $name = false; // initialize token name
5448: 
5449:         switch ($id) {
5450:         case 0x03: $name = 'tAdd';      $size = 1;  $data = '+';    break;
5451:         case 0x04: $name = 'tSub';      $size = 1;  $data = '-';    break;
5452:         case 0x05: $name = 'tMul';      $size = 1;  $data = '*';    break;
5453:         case 0x06: $name = 'tDiv';      $size = 1;  $data = '/';    break;
5454:         case 0x07: $name = 'tPower';    $size = 1;  $data = '^';    break;
5455:         case 0x08: $name = 'tConcat';   $size = 1;  $data = '&';    break;
5456:         case 0x09: $name = 'tLT';       $size = 1;  $data = '<';    break;
5457:         case 0x0A: $name = 'tLE';       $size = 1;  $data = '<=';   break;
5458:         case 0x0B: $name = 'tEQ';       $size = 1;  $data = '=';    break;
5459:         case 0x0C: $name = 'tGE';       $size = 1;  $data = '>=';   break;
5460:         case 0x0D: $name = 'tGT';       $size = 1;  $data = '>';    break;
5461:         case 0x0E: $name = 'tNE';       $size = 1;  $data = '<>';   break;
5462:         case 0x0F: $name = 'tIsect';    $size = 1;  $data = ' ';    break;
5463:         case 0x10: $name = 'tList';     $size = 1;  $data = ',';    break;
5464:         case 0x11: $name = 'tRange';    $size = 1;  $data = ':';    break;
5465:         case 0x12: $name = 'tUplus';    $size = 1;  $data = '+';    break;
5466:         case 0x13: $name = 'tUminus';   $size = 1;  $data = '-';    break;
5467:         case 0x14: $name = 'tPercent';  $size = 1;  $data = '%';    break;
5468:         case 0x15:  //  parenthesis
5469:             $name  = 'tParen';
5470:             $size  = 1;
5471:             $data = null;
5472:             break;
5473:         case 0x16:  //  missing argument
5474:             $name = 'tMissArg';
5475:             $size = 1;
5476:             $data = '';
5477:             break;
5478:         case 0x17:  //  string
5479:             $name = 'tStr';
5480:             // offset: 1; size: var; Unicode string, 8-bit string length
5481:             $string = self::_readUnicodeStringShort(substr($formulaData, 1));
5482:             $size = 1 + $string['size'];
5483:             $data = self::_UTF8toExcelDoubleQuoted($string['value']);
5484:             break;
5485:         case 0x19:  //  Special attribute
5486:             // offset: 1; size: 1; attribute type flags:
5487:             switch (ord($formulaData[1])) {
5488:             case 0x01:
5489:                 $name = 'tAttrVolatile';
5490:                 $size = 4;
5491:                 $data = null;
5492:                 break;
5493:             case 0x02:
5494:                 $name = 'tAttrIf';
5495:                 $size = 4;
5496:                 $data = null;
5497:                 break;
5498:             case 0x04:
5499:                 $name = 'tAttrChoose';
5500:                 // offset: 2; size: 2; number of choices in the CHOOSE function ($nc, number of parameters decreased by 1)
5501:                 $nc = self::_GetInt2d($formulaData, 2);
5502:                 // offset: 4; size: 2 * $nc
5503:                 // offset: 4 + 2 * $nc; size: 2
5504:                 $size = 2 * $nc + 6;
5505:                 $data = null;
5506:                 break;
5507:             case 0x08:
5508:                 $name = 'tAttrSkip';
5509:                 $size = 4;
5510:                 $data = null;
5511:                 break;
5512:             case 0x10:
5513:                 $name = 'tAttrSum';
5514:                 $size = 4;
5515:                 $data = null;
5516:                 break;
5517:             case 0x40:
5518:             case 0x41:
5519:                 $name = 'tAttrSpace';
5520:                 $size = 4;
5521:                 // offset: 2; size: 2; space type and position
5522:                 switch (ord($formulaData[2])) {
5523:                 case 0x00:
5524:                     $spacetype = 'type0';
5525:                     break;
5526:                 case 0x01:
5527:                     $spacetype = 'type1';
5528:                     break;
5529:                 case 0x02:
5530:                     $spacetype = 'type2';
5531:                     break;
5532:                 case 0x03:
5533:                     $spacetype = 'type3';
5534:                     break;
5535:                 case 0x04:
5536:                     $spacetype = 'type4';
5537:                     break;
5538:                 case 0x05:
5539:                     $spacetype = 'type5';
5540:                     break;
5541:                 default:
5542:                     throw new PHPExcel_Reader_Exception('Unrecognized space type in tAttrSpace token');
5543:                     break;
5544:                 }
5545:                 // offset: 3; size: 1; number of inserted spaces/carriage returns
5546:                 $spacecount = ord($formulaData[3]);
5547: 
5548:                 $data = array('spacetype' => $spacetype, 'spacecount' => $spacecount);
5549:                 break;
5550:             default:
5551:                 throw new PHPExcel_Reader_Exception('Unrecognized attribute flag in tAttr token');
5552:                 break;
5553:             }
5554:             break;
5555:         case 0x1C:  //  error code
5556:             // offset: 1; size: 1; error code
5557:             $name = 'tErr';
5558:             $size = 2;
5559:             $data = self::_mapErrorCode(ord($formulaData[1]));
5560:             break;
5561:         case 0x1D:  //  boolean
5562:             // offset: 1; size: 1; 0 = false, 1 = true;
5563:             $name = 'tBool';
5564:             $size = 2;
5565:             $data = ord($formulaData[1]) ? 'TRUE' : 'FALSE';
5566:             break;
5567:         case 0x1E:  //  integer
5568:             // offset: 1; size: 2; unsigned 16-bit integer
5569:             $name = 'tInt';
5570:             $size = 3;
5571:             $data = self::_GetInt2d($formulaData, 1);
5572:             break;
5573:         case 0x1F:  //  number
5574:             // offset: 1; size: 8;
5575:             $name = 'tNum';
5576:             $size = 9;
5577:             $data = self::_extractNumber(substr($formulaData, 1));
5578:             $data = str_replace(',', '.', (string)$data); // in case non-English locale
5579:             break;
5580:         case 0x20:  //  array constant
5581:         case 0x40:
5582:         case 0x60:
5583:             // offset: 1; size: 7; not used
5584:             $name = 'tArray';
5585:             $size = 8;
5586:             $data = null;
5587:             break;
5588:         case 0x21:  //  function with fixed number of arguments
5589:         case 0x41:
5590:         case 0x61:
5591:             $name = 'tFunc';
5592:             $size = 3;
5593:             // offset: 1; size: 2; index to built-in sheet function
5594:             switch (self::_GetInt2d($formulaData, 1)) {
5595:             case   2: $function = 'ISNA';           $args = 1;  break;
5596:             case   3: $function = 'ISERROR';        $args = 1;  break;
5597:             case  10: $function = 'NA';             $args = 0;  break;
5598:             case  15: $function = 'SIN';            $args = 1;  break;
5599:             case  16: $function = 'COS';            $args = 1;  break;
5600:             case  17: $function = 'TAN';            $args = 1;  break;
5601:             case  18: $function = 'ATAN';           $args = 1;  break;
5602:             case  19: $function = 'PI';             $args = 0;  break;
5603:             case  20: $function = 'SQRT';           $args = 1;  break;
5604:             case  21: $function = 'EXP';            $args = 1;  break;
5605:             case  22: $function = 'LN';             $args = 1;  break;
5606:             case  23: $function = 'LOG10';          $args = 1;  break;
5607:             case  24: $function = 'ABS';            $args = 1;  break;
5608:             case  25: $function = 'INT';            $args = 1;  break;
5609:             case  26: $function = 'SIGN';           $args = 1;  break;
5610:             case  27: $function = 'ROUND';          $args = 2;  break;
5611:             case  30: $function = 'REPT';           $args = 2;  break;
5612:             case  31: $function = 'MID';            $args = 3;  break;
5613:             case  32: $function = 'LEN';            $args = 1;  break;
5614:             case  33: $function = 'VALUE';          $args = 1;  break;
5615:             case  34: $function = 'TRUE';           $args = 0;  break;
5616:             case  35: $function = 'FALSE';          $args = 0;  break;
5617:             case  38: $function = 'NOT';            $args = 1;  break;
5618:             case  39: $function = 'MOD';            $args = 2;  break;
5619:             case  40: $function = 'DCOUNT';         $args = 3;  break;
5620:             case  41: $function = 'DSUM';           $args = 3;  break;
5621:             case  42: $function = 'DAVERAGE';       $args = 3;  break;
5622:             case  43: $function = 'DMIN';           $args = 3;  break;
5623:             case  44: $function = 'DMAX';           $args = 3;  break;
5624:             case  45: $function = 'DSTDEV';         $args = 3;  break;
5625:             case  48: $function = 'TEXT';           $args = 2;  break;
5626:             case  61: $function = 'MIRR';           $args = 3;  break;
5627:             case  63: $function = 'RAND';           $args = 0;  break;
5628:             case  65: $function = 'DATE';           $args = 3;  break;
5629:             case  66: $function = 'TIME';           $args = 3;  break;
5630:             case  67: $function = 'DAY';            $args = 1;  break;
5631:             case  68: $function = 'MONTH';          $args = 1;  break;
5632:             case  69: $function = 'YEAR';           $args = 1;  break;
5633:             case  71: $function = 'HOUR';           $args = 1;  break;
5634:             case  72: $function = 'MINUTE';         $args = 1;  break;
5635:             case  73: $function = 'SECOND';         $args = 1;  break;
5636:             case  74: $function = 'NOW';            $args = 0;  break;
5637:             case  75: $function = 'AREAS';          $args = 1;  break;
5638:             case  76: $function = 'ROWS';           $args = 1;  break;
5639:             case  77: $function = 'COLUMNS';        $args = 1;  break;
5640:             case  83: $function = 'TRANSPOSE';      $args = 1;  break;
5641:             case  86: $function = 'TYPE';           $args = 1;  break;
5642:             case  97: $function = 'ATAN2';          $args = 2;  break;
5643:             case  98: $function = 'ASIN';           $args = 1;  break;
5644:             case  99: $function = 'ACOS';           $args = 1;  break;
5645:             case 105: $function = 'ISREF';          $args = 1;  break;
5646:             case 111: $function = 'CHAR';           $args = 1;  break;
5647:             case 112: $function = 'LOWER';          $args = 1;  break;
5648:             case 113: $function = 'UPPER';          $args = 1;  break;
5649:             case 114: $function = 'PROPER';         $args = 1;  break;
5650:             case 117: $function = 'EXACT';          $args = 2;  break;
5651:             case 118: $function = 'TRIM';           $args = 1;  break;
5652:             case 119: $function = 'REPLACE';        $args = 4;  break;
5653:             case 121: $function = 'CODE';           $args = 1;  break;
5654:             case 126: $function = 'ISERR';          $args = 1;  break;
5655:             case 127: $function = 'ISTEXT';         $args = 1;  break;
5656:             case 128: $function = 'ISNUMBER';       $args = 1;  break;
5657:             case 129: $function = 'ISBLANK';        $args = 1;  break;
5658:             case 130: $function = 'T';              $args = 1;  break;
5659:             case 131: $function = 'N';              $args = 1;  break;
5660:             case 140: $function = 'DATEVALUE';      $args = 1;  break;
5661:             case 141: $function = 'TIMEVALUE';      $args = 1;  break;
5662:             case 142: $function = 'SLN';            $args = 3;  break;
5663:             case 143: $function = 'SYD';            $args = 4;  break;
5664:             case 162: $function = 'CLEAN';          $args = 1;  break;
5665:             case 163: $function = 'MDETERM';        $args = 1;  break;
5666:             case 164: $function = 'MINVERSE';       $args = 1;  break;
5667:             case 165: $function = 'MMULT';          $args = 2;  break;
5668:             case 184: $function = 'FACT';           $args = 1;  break;
5669:             case 189: $function = 'DPRODUCT';       $args = 3;  break;
5670:             case 190: $function = 'ISNONTEXT';      $args = 1;  break;
5671:             case 195: $function = 'DSTDEVP';        $args = 3;  break;
5672:             case 196: $function = 'DVARP';          $args = 3;  break;
5673:             case 198: $function = 'ISLOGICAL';      $args = 1;  break;
5674:             case 199: $function = 'DCOUNTA';        $args = 3;  break;
5675:             case 207: $function = 'REPLACEB';       $args = 4;  break;
5676:             case 210: $function = 'MIDB';           $args = 3;  break;
5677:             case 211: $function = 'LENB';           $args = 1;  break;
5678:             case 212: $function = 'ROUNDUP';        $args = 2;  break;
5679:             case 213: $function = 'ROUNDDOWN';      $args = 2;  break;
5680:             case 214: $function = 'ASC';            $args = 1;  break;
5681:             case 215: $function = 'DBCS';           $args = 1;  break;
5682:             case 221: $function = 'TODAY';          $args = 0;  break;
5683:             case 229: $function = 'SINH';           $args = 1;  break;
5684:             case 230: $function = 'COSH';           $args = 1;  break;
5685:             case 231: $function = 'TANH';           $args = 1;  break;
5686:             case 232: $function = 'ASINH';          $args = 1;  break;
5687:             case 233: $function = 'ACOSH';          $args = 1;  break;
5688:             case 234: $function = 'ATANH';          $args = 1;  break;
5689:             case 235: $function = 'DGET';           $args = 3;  break;
5690:             case 244: $function = 'INFO';           $args = 1;  break;
5691:             case 252: $function = 'FREQUENCY';      $args = 2;  break;
5692:             case 261: $function = 'ERROR.TYPE';     $args = 1;  break;
5693:             case 271: $function = 'GAMMALN';        $args = 1;  break;
5694:             case 273: $function = 'BINOMDIST';      $args = 4;  break;
5695:             case 274: $function = 'CHIDIST';        $args = 2;  break;
5696:             case 275: $function = 'CHIINV';         $args = 2;  break;
5697:             case 276: $function = 'COMBIN';         $args = 2;  break;
5698:             case 277: $function = 'CONFIDENCE';     $args = 3;  break;
5699:             case 278: $function = 'CRITBINOM';      $args = 3;  break;
5700:             case 279: $function = 'EVEN';           $args = 1;  break;
5701:             case 280: $function = 'EXPONDIST';      $args = 3;  break;
5702:             case 281: $function = 'FDIST';          $args = 3;  break;
5703:             case 282: $function = 'FINV';           $args = 3;  break;
5704:             case 283: $function = 'FISHER';         $args = 1;  break;
5705:             case 284: $function = 'FISHERINV';      $args = 1;  break;
5706:             case 285: $function = 'FLOOR';          $args = 2;  break;
5707:             case 286: $function = 'GAMMADIST';      $args = 4;  break;
5708:             case 287: $function = 'GAMMAINV';       $args = 3;  break;
5709:             case 288: $function = 'CEILING';        $args = 2;  break;
5710:             case 289: $function = 'HYPGEOMDIST';    $args = 4;  break;
5711:             case 290: $function = 'LOGNORMDIST';    $args = 3;  break;
5712:             case 291: $function = 'LOGINV';         $args = 3;  break;
5713:             case 292: $function = 'NEGBINOMDIST';   $args = 3;  break;
5714:             case 293: $function = 'NORMDIST';       $args = 4;  break;
5715:             case 294: $function = 'NORMSDIST';      $args = 1;  break;
5716:             case 295: $function = 'NORMINV';        $args = 3;  break;
5717:             case 296: $function = 'NORMSINV';       $args = 1;  break;
5718:             case 297: $function = 'STANDARDIZE';    $args = 3;  break;
5719:             case 298: $function = 'ODD';            $args = 1;  break;
5720:             case 299: $function = 'PERMUT';         $args = 2;  break;
5721:             case 300: $function = 'POISSON';        $args = 3;  break;
5722:             case 301: $function = 'TDIST';          $args = 3;  break;
5723:             case 302: $function = 'WEIBULL';        $args = 4;  break;
5724:             case 303: $function = 'SUMXMY2';        $args = 2;  break;
5725:             case 304: $function = 'SUMX2MY2';       $args = 2;  break;
5726:             case 305: $function = 'SUMX2PY2';       $args = 2;  break;
5727:             case 306: $function = 'CHITEST';        $args = 2;  break;
5728:             case 307: $function = 'CORREL';         $args = 2;  break;
5729:             case 308: $function = 'COVAR';          $args = 2;  break;
5730:             case 309: $function = 'FORECAST';       $args = 3;  break;
5731:             case 310: $function = 'FTEST';          $args = 2;  break;
5732:             case 311: $function = 'INTERCEPT';      $args = 2;  break;
5733:             case 312: $function = 'PEARSON';        $args = 2;  break;
5734:             case 313: $function = 'RSQ';            $args = 2;  break;
5735:             case 314: $function = 'STEYX';          $args = 2;  break;
5736:             case 315: $function = 'SLOPE';          $args = 2;  break;
5737:             case 316: $function = 'TTEST';          $args = 4;  break;
5738:             case 325: $function = 'LARGE';          $args = 2;  break;
5739:             case 326: $function = 'SMALL';          $args = 2;  break;
5740:             case 327: $function = 'QUARTILE';       $args = 2;  break;
5741:             case 328: $function = 'PERCENTILE';     $args = 2;  break;
5742:             case 331: $function = 'TRIMMEAN';       $args = 2;  break;
5743:             case 332: $function = 'TINV';           $args = 2;  break;
5744:             case 337: $function = 'POWER';          $args = 2;  break;
5745:             case 342: $function = 'RADIANS';        $args = 1;  break;
5746:             case 343: $function = 'DEGREES';        $args = 1;  break;
5747:             case 346: $function = 'COUNTIF';        $args = 2;  break;
5748:             case 347: $function = 'COUNTBLANK';     $args = 1;  break;
5749:             case 350: $function = 'ISPMT';          $args = 4;  break;
5750:             case 351: $function = 'DATEDIF';        $args = 3;  break;
5751:             case 352: $function = 'DATESTRING';     $args = 1;  break;
5752:             case 353: $function = 'NUMBERSTRING';   $args = 2;  break;
5753:             case 360: $function = 'PHONETIC';       $args = 1;  break;
5754:             case 368: $function = 'BAHTTEXT';       $args = 1;  break;
5755:             default:
5756:                 throw new PHPExcel_Reader_Exception('Unrecognized function in formula');
5757:                 break;
5758:             }
5759:             $data = array('function' => $function, 'args' => $args);
5760:             break;
5761:         case 0x22:  //  function with variable number of arguments
5762:         case 0x42:
5763:         case 0x62:
5764:             $name = 'tFuncV';
5765:             $size = 4;
5766:             // offset: 1; size: 1; number of arguments
5767:             $args = ord($formulaData[1]);
5768:             // offset: 2: size: 2; index to built-in sheet function
5769:             $index = self::_GetInt2d($formulaData, 2);
5770:             switch ($index) {
5771:             case   0: $function = 'COUNT';          break;
5772:             case   1: $function = 'IF';             break;
5773:             case   4: $function = 'SUM';            break;
5774:             case   5: $function = 'AVERAGE';        break;
5775:             case   6: $function = 'MIN';            break;
5776:             case   7: $function = 'MAX';            break;
5777:             case   8: $function = 'ROW';            break;
5778:             case   9: $function = 'COLUMN';         break;
5779:             case  11: $function = 'NPV';            break;
5780:             case  12: $function = 'STDEV';          break;
5781:             case  13: $function = 'DOLLAR';         break;
5782:             case  14: $function = 'FIXED';          break;
5783:             case  28: $function = 'LOOKUP';         break;
5784:             case  29: $function = 'INDEX';          break;
5785:             case  36: $function = 'AND';            break;
5786:             case  37: $function = 'OR';             break;
5787:             case  46: $function = 'VAR';            break;
5788:             case  49: $function = 'LINEST';         break;
5789:             case  50: $function = 'TREND';          break;
5790:             case  51: $function = 'LOGEST';         break;
5791:             case  52: $function = 'GROWTH';         break;
5792:             case  56: $function = 'PV';             break;
5793:             case  57: $function = 'FV';             break;
5794:             case  58: $function = 'NPER';           break;
5795:             case  59: $function = 'PMT';            break;
5796:             case  60: $function = 'RATE';           break;
5797:             case  62: $function = 'IRR';            break;
5798:             case  64: $function = 'MATCH';          break;
5799:             case  70: $function = 'WEEKDAY';        break;
5800:             case  78: $function = 'OFFSET';         break;
5801:             case  82: $function = 'SEARCH';         break;
5802:             case 100: $function = 'CHOOSE';         break;
5803:             case 101: $function = 'HLOOKUP';        break;
5804:             case 102: $function = 'VLOOKUP';        break;
5805:             case 109: $function = 'LOG';            break;
5806:             case 115: $function = 'LEFT';           break;
5807:             case 116: $function = 'RIGHT';          break;
5808:             case 120: $function = 'SUBSTITUTE';     break;
5809:             case 124: $function = 'FIND';           break;
5810:             case 125: $function = 'CELL';           break;
5811:             case 144: $function = 'DDB';            break;
5812:             case 148: $function = 'INDIRECT';       break;
5813:             case 167: $function = 'IPMT';           break;
5814:             case 168: $function = 'PPMT';           break;
5815:             case 169: $function = 'COUNTA';         break;
5816:             case 183: $function = 'PRODUCT';        break;
5817:             case 193: $function = 'STDEVP';         break;
5818:             case 194: $function = 'VARP';           break;
5819:             case 197: $function = 'TRUNC';          break;
5820:             case 204: $function = 'USDOLLAR';       break;
5821:             case 205: $function = 'FINDB';          break;
5822:             case 206: $function = 'SEARCHB';        break;
5823:             case 208: $function = 'LEFTB';          break;
5824:             case 209: $function = 'RIGHTB';         break;
5825:             case 216: $function = 'RANK';           break;
5826:             case 219: $function = 'ADDRESS';        break;
5827:             case 220: $function = 'DAYS360';        break;
5828:             case 222: $function = 'VDB';            break;
5829:             case 227: $function = 'MEDIAN';         break;
5830:             case 228: $function = 'SUMPRODUCT';     break;
5831:             case 247: $function = 'DB';             break;
5832:             case 255: $function = '';               break;
5833:             case 269: $function = 'AVEDEV';         break;
5834:             case 270: $function = 'BETADIST';       break;
5835:             case 272: $function = 'BETAINV';        break;
5836:             case 317: $function = 'PROB';           break;
5837:             case 318: $function = 'DEVSQ';          break;
5838:             case 319: $function = 'GEOMEAN';        break;
5839:             case 320: $function = 'HARMEAN';        break;
5840:             case 321: $function = 'SUMSQ';          break;
5841:             case 322: $function = 'KURT';           break;
5842:             case 323: $function = 'SKEW';           break;
5843:             case 324: $function = 'ZTEST';          break;
5844:             case 329: $function = 'PERCENTRANK';    break;
5845:             case 330: $function = 'MODE';           break;
5846:             case 336: $function = 'CONCATENATE';    break;
5847:             case 344: $function = 'SUBTOTAL';       break;
5848:             case 345: $function = 'SUMIF';          break;
5849:             case 354: $function = 'ROMAN';          break;
5850:             case 358: $function = 'GETPIVOTDATA';   break;
5851:             case 359: $function = 'HYPERLINK';      break;
5852:             case 361: $function = 'AVERAGEA';       break;
5853:             case 362: $function = 'MAXA';           break;
5854:             case 363: $function = 'MINA';           break;
5855:             case 364: $function = 'STDEVPA';        break;
5856:             case 365: $function = 'VARPA';          break;
5857:             case 366: $function = 'STDEVA';         break;
5858:             case 367: $function = 'VARA';           break;
5859:             default:
5860:                 throw new PHPExcel_Reader_Exception('Unrecognized function in formula');
5861:                 break;
5862:             }
5863:             $data = array('function' => $function, 'args' => $args);
5864:             break;
5865:         case 0x23:  //  index to defined name
5866:         case 0x43:
5867:         case 0x63:
5868:             $name = 'tName';
5869:             $size = 5;
5870:             // offset: 1; size: 2; one-based index to definedname record
5871:             $definedNameIndex = self::_GetInt2d($formulaData, 1) - 1;
5872:             // offset: 2; size: 2; not used
5873:             $data = $this->_definedname[$definedNameIndex]['name'];
5874:             break;
5875:         case 0x24:  //  single cell reference e.g. A5
5876:         case 0x44:
5877:         case 0x64:
5878:             $name = 'tRef';
5879:             $size = 5;
5880:             $data = $this->_readBIFF8CellAddress(substr($formulaData, 1, 4));
5881:             break;
5882:         case 0x25:  //  cell range reference to cells in the same sheet (2d)
5883:         case 0x45:
5884:         case 0x65:
5885:             $name = 'tArea';
5886:             $size = 9;
5887:             $data = $this->_readBIFF8CellRangeAddress(substr($formulaData, 1, 8));
5888:             break;
5889:         case 0x26:  //  Constant reference sub-expression
5890:         case 0x46:
5891:         case 0x66:
5892:             $name = 'tMemArea';
5893:             // offset: 1; size: 4; not used
5894:             // offset: 5; size: 2; size of the following subexpression
5895:             $subSize = self::_GetInt2d($formulaData, 5);
5896:             $size = 7 + $subSize;
5897:             $data = $this->_getFormulaFromData(substr($formulaData, 7, $subSize));
5898:             break;
5899:         case 0x27:  //  Deleted constant reference sub-expression
5900:         case 0x47:
5901:         case 0x67:
5902:             $name = 'tMemErr';
5903:             // offset: 1; size: 4; not used
5904:             // offset: 5; size: 2; size of the following subexpression
5905:             $subSize = self::_GetInt2d($formulaData, 5);
5906:             $size = 7 + $subSize;
5907:             $data = $this->_getFormulaFromData(substr($formulaData, 7, $subSize));
5908:             break;
5909:         case 0x29:  //  Variable reference sub-expression
5910:         case 0x49:
5911:         case 0x69:
5912:             $name = 'tMemFunc';
5913:             // offset: 1; size: 2; size of the following sub-expression
5914:             $subSize = self::_GetInt2d($formulaData, 1);
5915:             $size = 3 + $subSize;
5916:             $data = $this->_getFormulaFromData(substr($formulaData, 3, $subSize));
5917:             break;
5918: 
5919:         case 0x2C: // Relative 2d cell reference reference, used in shared formulas and some other places
5920:         case 0x4C:
5921:         case 0x6C:
5922:             $name = 'tRefN';
5923:             $size = 5;
5924:             $data = $this->_readBIFF8CellAddressB(substr($formulaData, 1, 4), $baseCell);
5925:             break;
5926: 
5927:         case 0x2D:  //  Relative 2d range reference
5928:         case 0x4D:
5929:         case 0x6D:
5930:             $name = 'tAreaN';
5931:             $size = 9;
5932:             $data = $this->_readBIFF8CellRangeAddressB(substr($formulaData, 1, 8), $baseCell);
5933:             break;
5934: 
5935:         case 0x39:  //  External name
5936:         case 0x59:
5937:         case 0x79:
5938:             $name = 'tNameX';
5939:             $size = 7;
5940:             // offset: 1; size: 2; index to REF entry in EXTERNSHEET record
5941:             // offset: 3; size: 2; one-based index to DEFINEDNAME or EXTERNNAME record
5942:             $index = self::_GetInt2d($formulaData, 3);
5943:             // assume index is to EXTERNNAME record
5944:             $data = $this->_externalNames[$index - 1]['name'];
5945:             // offset: 5; size: 2; not used
5946:             break;
5947: 
5948:         case 0x3A:  //  3d reference to cell
5949:         case 0x5A:
5950:         case 0x7A:
5951:             $name = 'tRef3d';
5952:             $size = 7;
5953: 
5954:             try {
5955:                 // offset: 1; size: 2; index to REF entry
5956:                 $sheetRange = $this->_readSheetRangeByRefIndex(self::_GetInt2d($formulaData, 1));
5957:                 // offset: 3; size: 4; cell address
5958:                 $cellAddress = $this->_readBIFF8CellAddress(substr($formulaData, 3, 4));
5959: 
5960:                 $data = "$sheetRange!$cellAddress";
5961:             } catch (PHPExcel_Exception $e) {
5962:                 // deleted sheet reference
5963:                 $data = '#REF!';
5964:             }
5965: 
5966:             break;
5967:         case 0x3B:  //  3d reference to cell range
5968:         case 0x5B:
5969:         case 0x7B:
5970:             $name = 'tArea3d';
5971:             $size = 11;
5972: 
5973:             try {
5974:                 // offset: 1; size: 2; index to REF entry
5975:                 $sheetRange = $this->_readSheetRangeByRefIndex(self::_GetInt2d($formulaData, 1));
5976:                 // offset: 3; size: 8; cell address
5977:                 $cellRangeAddress = $this->_readBIFF8CellRangeAddress(substr($formulaData, 3, 8));
5978: 
5979:                 $data = "$sheetRange!$cellRangeAddress";
5980:             } catch (PHPExcel_Exception $e) {
5981:                 // deleted sheet reference
5982:                 $data = '#REF!';
5983:             }
5984: 
5985:             break;
5986:         // Unknown cases    // don't know how to deal with
5987:         default:
5988:             throw new PHPExcel_Reader_Exception('Unrecognized token ' . sprintf('%02X', $id) . ' in formula');
5989:             break;
5990:         }
5991: 
5992:         return array(
5993:             'id' => $id,
5994:             'name' => $name,
5995:             'size' => $size,
5996:             'data' => $data,
5997:         );
5998:     }
5999: 
6000: 
6001:     /**
6002:      * Reads a cell address in BIFF8 e.g. 'A2' or '$A$2'
6003:      * section 3.3.4
6004:      *
6005:      * @param string $cellAddressStructure
6006:      * @return string
6007:      */
6008:     private function _readBIFF8CellAddress($cellAddressStructure)
6009:     {
6010:         // offset: 0; size: 2; index to row (0... 65535) (or offset (-32768... 32767))
6011:         $row = self::_GetInt2d($cellAddressStructure, 0) + 1;
6012: 
6013:         // offset: 2; size: 2; index to column or column offset + relative flags
6014: 
6015:             // bit: 7-0; mask 0x00FF; column index
6016:             $column = PHPExcel_Cell::stringFromColumnIndex(0x00FF & self::_GetInt2d($cellAddressStructure, 2));
6017: 
6018:             // bit: 14; mask 0x4000; (1 = relative column index, 0 = absolute column index)
6019:             if (!(0x4000 & self::_GetInt2d($cellAddressStructure, 2))) {
6020:                 $column = '$' . $column;
6021:             }
6022:             // bit: 15; mask 0x8000; (1 = relative row index, 0 = absolute row index)
6023:             if (!(0x8000 & self::_GetInt2d($cellAddressStructure, 2))) {
6024:                 $row = '$' . $row;
6025:             }
6026: 
6027:         return $column . $row;
6028:     }
6029: 
6030: 
6031:     /**
6032:      * Reads a cell address in BIFF8 for shared formulas. Uses positive and negative values for row and column
6033:      * to indicate offsets from a base cell
6034:      * section 3.3.4
6035:      *
6036:      * @param string $cellAddressStructure
6037:      * @param string $baseCell Base cell, only needed when formula contains tRefN tokens, e.g. with shared formulas
6038:      * @return string
6039:      */
6040:     private function _readBIFF8CellAddressB($cellAddressStructure, $baseCell = 'A1')
6041:     {
6042:         list($baseCol, $baseRow) = PHPExcel_Cell::coordinateFromString($baseCell);
6043:         $baseCol = PHPExcel_Cell::columnIndexFromString($baseCol) - 1;
6044: 
6045:         // offset: 0; size: 2; index to row (0... 65535) (or offset (-32768... 32767))
6046:             $rowIndex = self::_GetInt2d($cellAddressStructure, 0);
6047:             $row = self::_GetInt2d($cellAddressStructure, 0) + 1;
6048: 
6049:         // offset: 2; size: 2; index to column or column offset + relative flags
6050: 
6051:             // bit: 7-0; mask 0x00FF; column index
6052:             $colIndex = 0x00FF & self::_GetInt2d($cellAddressStructure, 2);
6053: 
6054:             // bit: 14; mask 0x4000; (1 = relative column index, 0 = absolute column index)
6055:             if (!(0x4000 & self::_GetInt2d($cellAddressStructure, 2))) {
6056:                 $column = PHPExcel_Cell::stringFromColumnIndex($colIndex);
6057:                 $column = '$' . $column;
6058:             } else {
6059:                 $colIndex = ($colIndex <= 127) ? $colIndex : $colIndex - 256;
6060:                 $column = PHPExcel_Cell::stringFromColumnIndex($baseCol + $colIndex);
6061:             }
6062: 
6063:             // bit: 15; mask 0x8000; (1 = relative row index, 0 = absolute row index)
6064:             if (!(0x8000 & self::_GetInt2d($cellAddressStructure, 2))) {
6065:                 $row = '$' . $row;
6066:             } else {
6067:                 $rowIndex = ($rowIndex <= 32767) ? $rowIndex : $rowIndex - 65536;
6068:                 $row = $baseRow + $rowIndex;
6069:             }
6070: 
6071:         return $column . $row;
6072:     }
6073: 
6074: 
6075:     /**
6076:      * Reads a cell range address in BIFF5 e.g. 'A2:B6' or 'A1'
6077:      * always fixed range
6078:      * section 2.5.14
6079:      *
6080:      * @param string $subData
6081:      * @return string
6082:      * @throws PHPExcel_Reader_Exception
6083:      */
6084:     private function _readBIFF5CellRangeAddressFixed($subData)
6085:     {
6086:         // offset: 0; size: 2; index to first row
6087:         $fr = self::_GetInt2d($subData, 0) + 1;
6088: 
6089:         // offset: 2; size: 2; index to last row
6090:         $lr = self::_GetInt2d($subData, 2) + 1;
6091: 
6092:         // offset: 4; size: 1; index to first column
6093:         $fc = ord($subData{4});
6094: 
6095:         // offset: 5; size: 1; index to last column
6096:         $lc = ord($subData{5});
6097: 
6098:         // check values
6099:         if ($fr > $lr || $fc > $lc) {
6100:             throw new PHPExcel_Reader_Exception('Not a cell range address');
6101:         }
6102: 
6103:         // column index to letter
6104:         $fc = PHPExcel_Cell::stringFromColumnIndex($fc);
6105:         $lc = PHPExcel_Cell::stringFromColumnIndex($lc);
6106: 
6107:         if ($fr == $lr and $fc == $lc) {
6108:             return "$fc$fr";
6109:         }
6110:         return "$fc$fr:$lc$lr";
6111:     }
6112: 
6113: 
6114:     /**
6115:      * Reads a cell range address in BIFF8 e.g. 'A2:B6' or 'A1'
6116:      * always fixed range
6117:      * section 2.5.14
6118:      *
6119:      * @param string $subData
6120:      * @return string
6121:      * @throws PHPExcel_Reader_Exception
6122:      */
6123:     private function _readBIFF8CellRangeAddressFixed($subData)
6124:     {
6125:         // offset: 0; size: 2; index to first row
6126:         $fr = self::_GetInt2d($subData, 0) + 1;
6127: 
6128:         // offset: 2; size: 2; index to last row
6129:         $lr = self::_GetInt2d($subData, 2) + 1;
6130: 
6131:         // offset: 4; size: 2; index to first column
6132:         $fc = self::_GetInt2d($subData, 4);
6133: 
6134:         // offset: 6; size: 2; index to last column
6135:         $lc = self::_GetInt2d($subData, 6);
6136: 
6137:         // check values
6138:         if ($fr > $lr || $fc > $lc) {
6139:             throw new PHPExcel_Reader_Exception('Not a cell range address');
6140:         }
6141: 
6142:         // column index to letter
6143:         $fc = PHPExcel_Cell::stringFromColumnIndex($fc);
6144:         $lc = PHPExcel_Cell::stringFromColumnIndex($lc);
6145: 
6146:         if ($fr == $lr and $fc == $lc) {
6147:             return "$fc$fr";
6148:         }
6149:         return "$fc$fr:$lc$lr";
6150:     }
6151: 
6152: 
6153:     /**
6154:      * Reads a cell range address in BIFF8 e.g. 'A2:B6' or '$A$2:$B$6'
6155:      * there are flags indicating whether column/row index is relative
6156:      * section 3.3.4
6157:      *
6158:      * @param string $subData
6159:      * @return string
6160:      */
6161:     private function _readBIFF8CellRangeAddress($subData)
6162:     {
6163:         // todo: if cell range is just a single cell, should this funciton
6164:         // not just return e.g. 'A1' and not 'A1:A1' ?
6165: 
6166:         // offset: 0; size: 2; index to first row (0... 65535) (or offset (-32768... 32767))
6167:             $fr = self::_GetInt2d($subData, 0) + 1;
6168: 
6169:         // offset: 2; size: 2; index to last row (0... 65535) (or offset (-32768... 32767))
6170:             $lr = self::_GetInt2d($subData, 2) + 1;
6171: 
6172:         // offset: 4; size: 2; index to first column or column offset + relative flags
6173: 
6174:         // bit: 7-0; mask 0x00FF; column index
6175:         $fc = PHPExcel_Cell::stringFromColumnIndex(0x00FF & self::_GetInt2d($subData, 4));
6176: 
6177:         // bit: 14; mask 0x4000; (1 = relative column index, 0 = absolute column index)
6178:         if (!(0x4000 & self::_GetInt2d($subData, 4))) {
6179:             $fc = '$' . $fc;
6180:         }
6181: 
6182:         // bit: 15; mask 0x8000; (1 = relative row index, 0 = absolute row index)
6183:         if (!(0x8000 & self::_GetInt2d($subData, 4))) {
6184:             $fr = '$' . $fr;
6185:         }
6186: 
6187:         // offset: 6; size: 2; index to last column or column offset + relative flags
6188: 
6189:         // bit: 7-0; mask 0x00FF; column index
6190:         $lc = PHPExcel_Cell::stringFromColumnIndex(0x00FF & self::_GetInt2d($subData, 6));
6191: 
6192:         // bit: 14; mask 0x4000; (1 = relative column index, 0 = absolute column index)
6193:         if (!(0x4000 & self::_GetInt2d($subData, 6))) {
6194:             $lc = '$' . $lc;
6195:         }
6196: 
6197:         // bit: 15; mask 0x8000; (1 = relative row index, 0 = absolute row index)
6198:         if (!(0x8000 & self::_GetInt2d($subData, 6))) {
6199:             $lr = '$' . $lr;
6200:         }
6201: 
6202:         return "$fc$fr:$lc$lr";
6203:     }
6204: 
6205: 
6206:     /**
6207:      * Reads a cell range address in BIFF8 for shared formulas. Uses positive and negative values for row and column
6208:      * to indicate offsets from a base cell
6209:      * section 3.3.4
6210:      *
6211:      * @param string $subData
6212:      * @param string $baseCell Base cell
6213:      * @return string Cell range address
6214:      */
6215:     private function _readBIFF8CellRangeAddressB($subData, $baseCell = 'A1')
6216:     {
6217:         list($baseCol, $baseRow) = PHPExcel_Cell::coordinateFromString($baseCell);
6218:         $baseCol = PHPExcel_Cell::columnIndexFromString($baseCol) - 1;
6219: 
6220:         // TODO: if cell range is just a single cell, should this funciton
6221:         // not just return e.g. 'A1' and not 'A1:A1' ?
6222: 
6223:         // offset: 0; size: 2; first row
6224:         $frIndex = self::_GetInt2d($subData, 0); // adjust below
6225: 
6226:         // offset: 2; size: 2; relative index to first row (0... 65535) should be treated as offset (-32768... 32767)
6227:         $lrIndex = self::_GetInt2d($subData, 2); // adjust below
6228: 
6229:         // offset: 4; size: 2; first column with relative/absolute flags
6230: 
6231:         // bit: 7-0; mask 0x00FF; column index
6232:         $fcIndex = 0x00FF & self::_GetInt2d($subData, 4);
6233: 
6234:         // bit: 14; mask 0x4000; (1 = relative column index, 0 = absolute column index)
6235:         if (!(0x4000 & self::_GetInt2d($subData, 4))) {
6236:             // absolute column index
6237:             $fc = PHPExcel_Cell::stringFromColumnIndex($fcIndex);
6238:             $fc = '$' . $fc;
6239:         } else {
6240:             // column offset
6241:             $fcIndex = ($fcIndex <= 127) ? $fcIndex : $fcIndex - 256;
6242:             $fc = PHPExcel_Cell::stringFromColumnIndex($baseCol + $fcIndex);
6243:         }
6244: 
6245:         // bit: 15; mask 0x8000; (1 = relative row index, 0 = absolute row index)
6246:         if (!(0x8000 & self::_GetInt2d($subData, 4))) {
6247:             // absolute row index
6248:             $fr = $frIndex + 1;
6249:             $fr = '$' . $fr;
6250:         } else {
6251:             // row offset
6252:             $frIndex = ($frIndex <= 32767) ? $frIndex : $frIndex - 65536;
6253:             $fr = $baseRow + $frIndex;
6254:         }
6255: 
6256:         // offset: 6; size: 2; last column with relative/absolute flags
6257: 
6258:         // bit: 7-0; mask 0x00FF; column index
6259:         $lcIndex = 0x00FF & self::_GetInt2d($subData, 6);
6260:         $lcIndex = ($lcIndex <= 127) ? $lcIndex : $lcIndex - 256;
6261:         $lc = PHPExcel_Cell::stringFromColumnIndex($baseCol + $lcIndex);
6262: 
6263:         // bit: 14; mask 0x4000; (1 = relative column index, 0 = absolute column index)
6264:         if (!(0x4000 & self::_GetInt2d($subData, 6))) {
6265:             // absolute column index
6266:             $lc = PHPExcel_Cell::stringFromColumnIndex($lcIndex);
6267:             $lc = '$' . $lc;
6268:         } else {
6269:             // column offset
6270:             $lcIndex = ($lcIndex <= 127) ? $lcIndex : $lcIndex - 256;
6271:             $lc = PHPExcel_Cell::stringFromColumnIndex($baseCol + $lcIndex);
6272:         }
6273: 
6274:         // bit: 15; mask 0x8000; (1 = relative row index, 0 = absolute row index)
6275:         if (!(0x8000 & self::_GetInt2d($subData, 6))) {
6276:             // absolute row index
6277:             $lr = $lrIndex + 1;
6278:             $lr = '$' . $lr;
6279:         } else {
6280:             // row offset
6281:             $lrIndex = ($lrIndex <= 32767) ? $lrIndex : $lrIndex - 65536;
6282:             $lr = $baseRow + $lrIndex;
6283:         }
6284: 
6285:         return "$fc$fr:$lc$lr";
6286:     }
6287: 
6288: 
6289:     /**
6290:      * Read BIFF8 cell range address list
6291:      * section 2.5.15
6292:      *
6293:      * @param string $subData
6294:      * @return array
6295:      */
6296:     private function _readBIFF8CellRangeAddressList($subData)
6297:     {
6298:         $cellRangeAddresses = array();
6299: 
6300:         // offset: 0; size: 2; number of the following cell range addresses
6301:         $nm = self::_GetInt2d($subData, 0);
6302: 
6303:         $offset = 2;
6304:         // offset: 2; size: 8 * $nm; list of $nm (fixed) cell range addresses
6305:         for ($i = 0; $i < $nm; ++$i) {
6306:             $cellRangeAddresses[] = $this->_readBIFF8CellRangeAddressFixed(substr($subData, $offset, 8));
6307:             $offset += 8;
6308:         }
6309: 
6310:         return array(
6311:             'size' => 2 + 8 * $nm,
6312:             'cellRangeAddresses' => $cellRangeAddresses,
6313:         );
6314:     }
6315: 
6316: 
6317:     /**
6318:      * Read BIFF5 cell range address list
6319:      * section 2.5.15
6320:      *
6321:      * @param string $subData
6322:      * @return array
6323:      */
6324:     private function _readBIFF5CellRangeAddressList($subData)
6325:     {
6326:         $cellRangeAddresses = array();
6327: 
6328:         // offset: 0; size: 2; number of the following cell range addresses
6329:         $nm = self::_GetInt2d($subData, 0);
6330: 
6331:         $offset = 2;
6332:         // offset: 2; size: 6 * $nm; list of $nm (fixed) cell range addresses
6333:         for ($i = 0; $i < $nm; ++$i) {
6334:             $cellRangeAddresses[] = $this->_readBIFF5CellRangeAddressFixed(substr($subData, $offset, 6));
6335:             $offset += 6;
6336:         }
6337: 
6338:         return array(
6339:             'size' => 2 + 6 * $nm,
6340:             'cellRangeAddresses' => $cellRangeAddresses,
6341:         );
6342:     }
6343: 
6344: 
6345:     /**
6346:      * Get a sheet range like Sheet1:Sheet3 from REF index
6347:      * Note: If there is only one sheet in the range, one gets e.g Sheet1
6348:      * It can also happen that the REF structure uses the -1 (FFFF) code to indicate deleted sheets,
6349:      * in which case an PHPExcel_Reader_Exception is thrown
6350:      *
6351:      * @param int $index
6352:      * @return string|false
6353:      * @throws PHPExcel_Reader_Exception
6354:      */
6355:     private function _readSheetRangeByRefIndex($index)
6356:     {
6357:         if (isset($this->_ref[$index])) {
6358: 
6359:             $type = $this->_externalBooks[$this->_ref[$index]['externalBookIndex']]['type'];
6360: 
6361:             switch ($type) {
6362:                 case 'internal':
6363:                     // check if we have a deleted 3d reference
6364:                     if ($this->_ref[$index]['firstSheetIndex'] == 0xFFFF or $this->_ref[$index]['lastSheetIndex'] == 0xFFFF) {
6365:                         throw new PHPExcel_Reader_Exception('Deleted sheet reference');
6366:                     }
6367: 
6368:                     // we have normal sheet range (collapsed or uncollapsed)
6369:                     $firstSheetName = $this->_sheets[$this->_ref[$index]['firstSheetIndex']]['name'];
6370:                     $lastSheetName = $this->_sheets[$this->_ref[$index]['lastSheetIndex']]['name'];
6371: 
6372:                     if ($firstSheetName == $lastSheetName) {
6373:                         // collapsed sheet range
6374:                         $sheetRange = $firstSheetName;
6375:                     } else {
6376:                         $sheetRange = "$firstSheetName:$lastSheetName";
6377:                     }
6378: 
6379:                     // escape the single-quotes
6380:                     $sheetRange = str_replace("'", "''", $sheetRange);
6381: 
6382:                     // if there are special characters, we need to enclose the range in single-quotes
6383:                     // todo: check if we have identified the whole set of special characters
6384:                     // it seems that the following characters are not accepted for sheet names
6385:                     // and we may assume that they are not present: []*/:\?
6386:                     if (preg_match("/[ !\"@#£$%&{()}<>=+'|^,;-]/", $sheetRange)) {
6387:                         $sheetRange = "'$sheetRange'";
6388:                     }
6389: 
6390:                     return $sheetRange;
6391:                     break;
6392: 
6393:                 default:
6394:                     // TODO: external sheet support
6395:                     throw new PHPExcel_Reader_Exception('Excel5 reader only supports internal sheets in fomulas');
6396:                     break;
6397:             }
6398:         }
6399:         return false;
6400:     }
6401: 
6402: 
6403:     /**
6404:      * read BIFF8 constant value array from array data
6405:      * returns e.g. array('value' => '{1,2;3,4}', 'size' => 40}
6406:      * section 2.5.8
6407:      *
6408:      * @param string $arrayData
6409:      * @return array
6410:      */
6411:     private static function _readBIFF8ConstantArray($arrayData)
6412:     {
6413:         // offset: 0; size: 1; number of columns decreased by 1
6414:         $nc = ord($arrayData[0]);
6415: 
6416:         // offset: 1; size: 2; number of rows decreased by 1
6417:         $nr = self::_GetInt2d($arrayData, 1);
6418:         $size = 3; // initialize
6419:         $arrayData = substr($arrayData, 3);
6420: 
6421:         // offset: 3; size: var; list of ($nc + 1) * ($nr + 1) constant values
6422:         $matrixChunks = array();
6423:         for ($r = 1; $r <= $nr + 1; ++$r) {
6424:             $items = array();
6425:             for ($c = 1; $c <= $nc + 1; ++$c) {
6426:                 $constant = self::_readBIFF8Constant($arrayData);
6427:                 $items[] = $constant['value'];
6428:                 $arrayData = substr($arrayData, $constant['size']);
6429:                 $size += $constant['size'];
6430:             }
6431:             $matrixChunks[] = implode(',', $items); // looks like e.g. '1,"hello"'
6432:         }
6433:         $matrix = '{' . implode(';', $matrixChunks) . '}';
6434: 
6435:         return array(
6436:             'value' => $matrix,
6437:             'size' => $size,
6438:         );
6439:     }
6440: 
6441: 
6442:     /**
6443:      * read BIFF8 constant value which may be 'Empty Value', 'Number', 'String Value', 'Boolean Value', 'Error Value'
6444:      * section 2.5.7
6445:      * returns e.g. array('value' => '5', 'size' => 9)
6446:      *
6447:      * @param string $valueData
6448:      * @return array
6449:      */
6450:     private static function _readBIFF8Constant($valueData)
6451:     {
6452:         // offset: 0; size: 1; identifier for type of constant
6453:         $identifier = ord($valueData[0]);
6454: 
6455:         switch ($identifier) {
6456:         case 0x00: // empty constant (what is this?)
6457:             $value = '';
6458:             $size = 9;
6459:             break;
6460:         case 0x01: // number
6461:             // offset: 1; size: 8; IEEE 754 floating-point value
6462:             $value = self::_extractNumber(substr($valueData, 1, 8));
6463:             $size = 9;
6464:             break;
6465:         case 0x02: // string value
6466:             // offset: 1; size: var; Unicode string, 16-bit string length
6467:             $string = self::_readUnicodeStringLong(substr($valueData, 1));
6468:             $value = '"' . $string['value'] . '"';
6469:             $size = 1 + $string['size'];
6470:             break;
6471:         case 0x04: // boolean
6472:             // offset: 1; size: 1; 0 = FALSE, 1 = TRUE
6473:             if (ord($valueData[1])) {
6474:                 $value = 'TRUE';
6475:             } else {
6476:                 $value = 'FALSE';
6477:             }
6478:             $size = 9;
6479:             break;
6480:         case 0x10: // error code
6481:             // offset: 1; size: 1; error code
6482:             $value = self::_mapErrorCode(ord($valueData[1]));
6483:             $size = 9;
6484:             break;
6485:         }
6486:         return array(
6487:             'value' => $value,
6488:             'size' => $size,
6489:         );
6490:     }
6491: 
6492: 
6493:     /**
6494:      * Extract RGB color
6495:      * OpenOffice.org's Documentation of the Microsoft Excel File Format, section 2.5.4
6496:      *
6497:      * @param string $rgb Encoded RGB value (4 bytes)
6498:      * @return array
6499:      */
6500:     private static function _readRGB($rgb)
6501:     {
6502:         // offset: 0; size 1; Red component
6503:         $r = ord($rgb{0});
6504: 
6505:         // offset: 1; size: 1; Green component
6506:         $g = ord($rgb{1});
6507: 
6508:         // offset: 2; size: 1; Blue component
6509:         $b = ord($rgb{2});
6510: 
6511:         // HEX notation, e.g. 'FF00FC'
6512:         $rgb = sprintf('%02X%02X%02X', $r, $g, $b);
6513: 
6514:         return array('rgb' => $rgb);
6515:     }
6516: 
6517: 
6518:     /**
6519:      * Read byte string (8-bit string length)
6520:      * OpenOffice documentation: 2.5.2
6521:      *
6522:      * @param string $subData
6523:      * @return array
6524:      */
6525:     private function _readByteStringShort($subData)
6526:     {
6527:         // offset: 0; size: 1; length of the string (character count)
6528:         $ln = ord($subData[0]);
6529: 
6530:         // offset: 1: size: var; character array (8-bit characters)
6531:         $value = $this->_decodeCodepage(substr($subData, 1, $ln));
6532: 
6533:         return array(
6534:             'value' => $value,
6535:             'size' => 1 + $ln, // size in bytes of data structure
6536:         );
6537:     }
6538: 
6539: 
6540:     /**
6541:      * Read byte string (16-bit string length)
6542:      * OpenOffice documentation: 2.5.2
6543:      *
6544:      * @param string $subData
6545:      * @return array
6546:      */
6547:     private function _readByteStringLong($subData)
6548:     {
6549:         // offset: 0; size: 2; length of the string (character count)
6550:         $ln = self::_GetInt2d($subData, 0);
6551: 
6552:         // offset: 2: size: var; character array (8-bit characters)
6553:         $value = $this->_decodeCodepage(substr($subData, 2));
6554: 
6555:         //return $string;
6556:         return array(
6557:             'value' => $value,
6558:             'size' => 2 + $ln, // size in bytes of data structure
6559:         );
6560:     }
6561: 
6562: 
6563:     /**
6564:      * Extracts an Excel Unicode short string (8-bit string length)
6565:      * OpenOffice documentation: 2.5.3
6566:      * function will automatically find out where the Unicode string ends.
6567:      *
6568:      * @param string $subData
6569:      * @return array
6570:      */
6571:     private static function _readUnicodeStringShort($subData)
6572:     {
6573:         $value = '';
6574: 
6575:         // offset: 0: size: 1; length of the string (character count)
6576:         $characterCount = ord($subData[0]);
6577: 
6578:         $string = self::_readUnicodeString(substr($subData, 1), $characterCount);
6579: 
6580:         // add 1 for the string length
6581:         $string['size'] += 1;
6582: 
6583:         return $string;
6584:     }
6585: 
6586: 
6587:     /**
6588:      * Extracts an Excel Unicode long string (16-bit string length)
6589:      * OpenOffice documentation: 2.5.3
6590:      * this function is under construction, needs to support rich text, and Asian phonetic settings
6591:      *
6592:      * @param string $subData
6593:      * @return array
6594:      */
6595:     private static function _readUnicodeStringLong($subData)
6596:     {
6597:         $value = '';
6598: 
6599:         // offset: 0: size: 2; length of the string (character count)
6600:         $characterCount = self::_GetInt2d($subData, 0);
6601: 
6602:         $string = self::_readUnicodeString(substr($subData, 2), $characterCount);
6603: 
6604:         // add 2 for the string length
6605:         $string['size'] += 2;
6606: 
6607:         return $string;
6608:     }
6609: 
6610: 
6611:     /**
6612:      * Read Unicode string with no string length field, but with known character count
6613:      * this function is under construction, needs to support rich text, and Asian phonetic settings
6614:      * OpenOffice.org's Documentation of the Microsoft Excel File Format, section 2.5.3
6615:      *
6616:      * @param string $subData
6617:      * @param int $characterCount
6618:      * @return array
6619:      */
6620:     private static function _readUnicodeString($subData, $characterCount)
6621:     {
6622:         $value = '';
6623: 
6624:         // offset: 0: size: 1; option flags
6625: 
6626:             // bit: 0; mask: 0x01; character compression (0 = compressed 8-bit, 1 = uncompressed 16-bit)
6627:             $isCompressed = !((0x01 & ord($subData[0])) >> 0);
6628: 
6629:             // bit: 2; mask: 0x04; Asian phonetic settings
6630:             $hasAsian = (0x04) & ord($subData[0]) >> 2;
6631: 
6632:             // bit: 3; mask: 0x08; Rich-Text settings
6633:             $hasRichText = (0x08) & ord($subData[0]) >> 3;
6634: 
6635:         // offset: 1: size: var; character array
6636:         // this offset assumes richtext and Asian phonetic settings are off which is generally wrong
6637:         // needs to be fixed
6638:         $value = self::_encodeUTF16(substr($subData, 1, $isCompressed ? $characterCount : 2 * $characterCount), $isCompressed);
6639: 
6640:         return array(
6641:             'value' => $value,
6642:             'size' => $isCompressed ? 1 + $characterCount : 1 + 2 * $characterCount, // the size in bytes including the option flags
6643:         );
6644:     }
6645: 
6646: 
6647:     /**
6648:      * Convert UTF-8 string to string surounded by double quotes. Used for explicit string tokens in formulas.
6649:      * Example:  hello"world  -->  "hello""world"
6650:      *
6651:      * @param string $value UTF-8 encoded string
6652:      * @return string
6653:      */
6654:     private static function _UTF8toExcelDoubleQuoted($value)
6655:     {
6656:         return '"' . str_replace('"', '""', $value) . '"';
6657:     }
6658: 
6659: 
6660:     /**
6661:      * Reads first 8 bytes of a string and return IEEE 754 float
6662:      *
6663:      * @param string $data Binary string that is at least 8 bytes long
6664:      * @return float
6665:      */
6666:     private static function _extractNumber($data)
6667:     {
6668:         $rknumhigh = self::_GetInt4d($data, 4);
6669:         $rknumlow = self::_GetInt4d($data, 0);
6670:         $sign = ($rknumhigh & 0x80000000) >> 31;
6671:         $exp = (($rknumhigh & 0x7ff00000) >> 20) - 1023;
6672:         $mantissa = (0x100000 | ($rknumhigh & 0x000fffff));
6673:         $mantissalow1 = ($rknumlow & 0x80000000) >> 31;
6674:         $mantissalow2 = ($rknumlow & 0x7fffffff);
6675:         $value = $mantissa / pow( 2 , (20 - $exp));
6676: 
6677:         if ($mantissalow1 != 0) {
6678:             $value += 1 / pow (2 , (21 - $exp));
6679:         }
6680: 
6681:         $value += $mantissalow2 / pow (2 , (52 - $exp));
6682:         if ($sign) {
6683:             $value *= -1;
6684:         }
6685: 
6686:         return $value;
6687:     }
6688: 
6689: 
6690:     private static function _GetIEEE754($rknum)
6691:     {
6692:         if (($rknum & 0x02) != 0) {
6693:             $value = $rknum >> 2;
6694:         } else {
6695:             // changes by mmp, info on IEEE754 encoding from
6696:             // research.microsoft.com/~hollasch/cgindex/coding/ieeefloat.html
6697:             // The RK format calls for using only the most significant 30 bits
6698:             // of the 64 bit floating point value. The other 34 bits are assumed
6699:             // to be 0 so we use the upper 30 bits of $rknum as follows...
6700:             $sign = ($rknum & 0x80000000) >> 31;
6701:             $exp = ($rknum & 0x7ff00000) >> 20;
6702:             $mantissa = (0x100000 | ($rknum & 0x000ffffc));
6703:             $value = $mantissa / pow( 2 , (20- ($exp - 1023)));
6704:             if ($sign) {
6705:                 $value = -1 * $value;
6706:             }
6707:             //end of changes by mmp
6708:         }
6709:         if (($rknum & 0x01) != 0) {
6710:             $value /= 100;
6711:         }
6712:         return $value;
6713:     }
6714: 
6715: 
6716:     /**
6717:      * Get UTF-8 string from (compressed or uncompressed) UTF-16 string
6718:      *
6719:      * @param string $string
6720:      * @param bool $compressed
6721:      * @return string
6722:      */
6723:     private static function _encodeUTF16($string, $compressed = '')
6724:     {
6725:         if ($compressed) {
6726:             $string = self::_uncompressByteString($string);
6727:         }
6728: 
6729:         return PHPExcel_Shared_String::ConvertEncoding($string, 'UTF-8', 'UTF-16LE');
6730:     }
6731: 
6732: 
6733:     /**
6734:      * Convert UTF-16 string in compressed notation to uncompressed form. Only used for BIFF8.
6735:      *
6736:      * @param string $string
6737:      * @return string
6738:      */
6739:     private static function _uncompressByteString($string)
6740:     {
6741:         $uncompressedString = '';
6742:         $strLen = strlen($string);
6743:         for ($i = 0; $i < $strLen; ++$i) {
6744:             $uncompressedString .= $string[$i] . "\0";
6745:         }
6746: 
6747:         return $uncompressedString;
6748:     }
6749: 
6750: 
6751:     /**
6752:      * Convert string to UTF-8. Only used for BIFF5.
6753:      *
6754:      * @param string $string
6755:      * @return string
6756:      */
6757:     private function _decodeCodepage($string)
6758:     {
6759:         return PHPExcel_Shared_String::ConvertEncoding($string, 'UTF-8', $this->_codepage);
6760:     }
6761: 
6762: 
6763:     /**
6764:      * Read 16-bit unsigned integer
6765:      *
6766:      * @param string $data
6767:      * @param int $pos
6768:      * @return int
6769:      */
6770:     public static function _GetInt2d($data, $pos)
6771:     {
6772:         return ord($data[$pos]) | (ord($data[$pos+1]) << 8);
6773:     }
6774: 
6775: 
6776:     /**
6777:      * Read 32-bit signed integer
6778:      *
6779:      * @param string $data
6780:      * @param int $pos
6781:      * @return int
6782:      */
6783:     public static function _GetInt4d($data, $pos)
6784:     {
6785:         // FIX: represent numbers correctly on 64-bit system
6786:         // http://sourceforge.net/tracker/index.php?func=detail&aid=1487372&group_id=99160&atid=623334
6787:         // Hacked by Andreas Rehm 2006 to ensure correct result of the <<24 block on 32 and 64bit systems
6788:         $_or_24 = ord($data[$pos + 3]);
6789:         if ($_or_24 >= 128) {
6790:             // negative number
6791:             $_ord_24 = -abs((256 - $_or_24) << 24);
6792:         } else {
6793:             $_ord_24 = ($_or_24 & 127) << 24;
6794:         }
6795:         return ord($data[$pos]) | (ord($data[$pos+1]) << 8) | (ord($data[$pos+2]) << 16) | $_ord_24;
6796:     }
6797: 
6798: 
6799:     /**
6800:      * Read color
6801:      *
6802:      * @param int $color Indexed color
6803:      * @param array $palette Color palette
6804:      * @return array RGB color value, example: array('rgb' => 'FF0000')
6805:      */
6806:     private static function _readColor($color,$palette,$version)
6807:     {
6808:         if ($color <= 0x07 || $color >= 0x40) {
6809:             // special built-in color
6810:             return self::_mapBuiltInColor($color);
6811:         } elseif (isset($palette) && isset($palette[$color - 8])) {
6812:             // palette color, color index 0x08 maps to pallete index 0
6813:             return $palette[$color - 8];
6814:         } else {
6815:             // default color table
6816:             if ($version == self::XLS_BIFF8) {
6817:                 return self::_mapColor($color);
6818:             } else {
6819:                 // BIFF5
6820:                 return self::_mapColorBIFF5($color);
6821:             }
6822:         }
6823: 
6824:         return $color;
6825:     }
6826: 
6827: 
6828:     /**
6829:      * Map border style
6830:      * OpenOffice documentation: 2.5.11
6831:      *
6832:      * @param int $index
6833:      * @return string
6834:      */
6835:     private static function _mapBorderStyle($index)
6836:     {
6837:         switch ($index) {
6838:             case 0x00: return PHPExcel_Style_Border::BORDER_NONE;
6839:             case 0x01: return PHPExcel_Style_Border::BORDER_THIN;
6840:             case 0x02: return PHPExcel_Style_Border::BORDER_MEDIUM;
6841:             case 0x03: return PHPExcel_Style_Border::BORDER_DASHED;
6842:             case 0x04: return PHPExcel_Style_Border::BORDER_DOTTED;
6843:             case 0x05: return PHPExcel_Style_Border::BORDER_THICK;
6844:             case 0x06: return PHPExcel_Style_Border::BORDER_DOUBLE;
6845:             case 0x07: return PHPExcel_Style_Border::BORDER_HAIR;
6846:             case 0x08: return PHPExcel_Style_Border::BORDER_MEDIUMDASHED;
6847:             case 0x09: return PHPExcel_Style_Border::BORDER_DASHDOT;
6848:             case 0x0A: return PHPExcel_Style_Border::BORDER_MEDIUMDASHDOT;
6849:             case 0x0B: return PHPExcel_Style_Border::BORDER_DASHDOTDOT;
6850:             case 0x0C: return PHPExcel_Style_Border::BORDER_MEDIUMDASHDOTDOT;
6851:             case 0x0D: return PHPExcel_Style_Border::BORDER_SLANTDASHDOT;
6852:             default:   return PHPExcel_Style_Border::BORDER_NONE;
6853:         }
6854:     }
6855: 
6856: 
6857:     /**
6858:      * Get fill pattern from index
6859:      * OpenOffice documentation: 2.5.12
6860:      *
6861:      * @param int $index
6862:      * @return string
6863:      */
6864:     private static function _mapFillPattern($index)
6865:     {
6866:         switch ($index) {
6867:             case 0x00: return PHPExcel_Style_Fill::FILL_NONE;
6868:             case 0x01: return PHPExcel_Style_Fill::FILL_SOLID;
6869:             case 0x02: return PHPExcel_Style_Fill::FILL_PATTERN_MEDIUMGRAY;
6870:             case 0x03: return PHPExcel_Style_Fill::FILL_PATTERN_DARKGRAY;
6871:             case 0x04: return PHPExcel_Style_Fill::FILL_PATTERN_LIGHTGRAY;
6872:             case 0x05: return PHPExcel_Style_Fill::FILL_PATTERN_DARKHORIZONTAL;
6873:             case 0x06: return PHPExcel_Style_Fill::FILL_PATTERN_DARKVERTICAL;
6874:             case 0x07: return PHPExcel_Style_Fill::FILL_PATTERN_DARKDOWN;
6875:             case 0x08: return PHPExcel_Style_Fill::FILL_PATTERN_DARKUP;
6876:             case 0x09: return PHPExcel_Style_Fill::FILL_PATTERN_DARKGRID;
6877:             case 0x0A: return PHPExcel_Style_Fill::FILL_PATTERN_DARKTRELLIS;
6878:             case 0x0B: return PHPExcel_Style_Fill::FILL_PATTERN_LIGHTHORIZONTAL;
6879:             case 0x0C: return PHPExcel_Style_Fill::FILL_PATTERN_LIGHTVERTICAL;
6880:             case 0x0D: return PHPExcel_Style_Fill::FILL_PATTERN_LIGHTDOWN;
6881:             case 0x0E: return PHPExcel_Style_Fill::FILL_PATTERN_LIGHTUP;
6882:             case 0x0F: return PHPExcel_Style_Fill::FILL_PATTERN_LIGHTGRID;
6883:             case 0x10: return PHPExcel_Style_Fill::FILL_PATTERN_LIGHTTRELLIS;
6884:             case 0x11: return PHPExcel_Style_Fill::FILL_PATTERN_GRAY125;
6885:             case 0x12: return PHPExcel_Style_Fill::FILL_PATTERN_GRAY0625;
6886:             default:   return PHPExcel_Style_Fill::FILL_NONE;
6887:         }
6888:     }
6889: 
6890: 
6891:     /**
6892:      * Map error code, e.g. '#N/A'
6893:      *
6894:      * @param int $subData
6895:      * @return string
6896:      */
6897:     private static function _mapErrorCode($subData)
6898:     {
6899:         switch ($subData) {
6900:             case 0x00: return '#NULL!';     break;
6901:             case 0x07: return '#DIV/0!';    break;
6902:             case 0x0F: return '#VALUE!';    break;
6903:             case 0x17: return '#REF!';      break;
6904:             case 0x1D: return '#NAME?';     break;
6905:             case 0x24: return '#NUM!';      break;
6906:             case 0x2A: return '#N/A';       break;
6907:             default: return false;
6908:         }
6909:     }
6910: 
6911: 
6912:     /**
6913:      * Map built-in color to RGB value
6914:      *
6915:      * @param int $color Indexed color
6916:      * @return array
6917:      */
6918:     private static function _mapBuiltInColor($color)
6919:     {
6920:         switch ($color) {
6921:             case 0x00: return array('rgb' => '000000');
6922:             case 0x01: return array('rgb' => 'FFFFFF');
6923:             case 0x02: return array('rgb' => 'FF0000');
6924:             case 0x03: return array('rgb' => '00FF00');
6925:             case 0x04: return array('rgb' => '0000FF');
6926:             case 0x05: return array('rgb' => 'FFFF00');
6927:             case 0x06: return array('rgb' => 'FF00FF');
6928:             case 0x07: return array('rgb' => '00FFFF');
6929:             case 0x40: return array('rgb' => '000000'); // system window text color
6930:             case 0x41: return array('rgb' => 'FFFFFF'); // system window background color
6931:             default:   return array('rgb' => '000000');
6932:         }
6933:     }
6934: 
6935: 
6936:     /**
6937:      * Map color array from BIFF5 built-in color index
6938:      *
6939:      * @param int $subData
6940:      * @return array
6941:      */
6942:     private static function _mapColorBIFF5($subData)
6943:     {
6944:         switch ($subData) {
6945:             case 0x08: return array('rgb' => '000000');
6946:             case 0x09: return array('rgb' => 'FFFFFF');
6947:             case 0x0A: return array('rgb' => 'FF0000');
6948:             case 0x0B: return array('rgb' => '00FF00');
6949:             case 0x0C: return array('rgb' => '0000FF');
6950:             case 0x0D: return array('rgb' => 'FFFF00');
6951:             case 0x0E: return array('rgb' => 'FF00FF');
6952:             case 0x0F: return array('rgb' => '00FFFF');
6953:             case 0x10: return array('rgb' => '800000');
6954:             case 0x11: return array('rgb' => '008000');
6955:             case 0x12: return array('rgb' => '000080');
6956:             case 0x13: return array('rgb' => '808000');
6957:             case 0x14: return array('rgb' => '800080');
6958:             case 0x15: return array('rgb' => '008080');
6959:             case 0x16: return array('rgb' => 'C0C0C0');
6960:             case 0x17: return array('rgb' => '808080');
6961:             case 0x18: return array('rgb' => '8080FF');
6962:             case 0x19: return array('rgb' => '802060');
6963:             case 0x1A: return array('rgb' => 'FFFFC0');
6964:             case 0x1B: return array('rgb' => 'A0E0F0');
6965:             case 0x1C: return array('rgb' => '600080');
6966:             case 0x1D: return array('rgb' => 'FF8080');
6967:             case 0x1E: return array('rgb' => '0080C0');
6968:             case 0x1F: return array('rgb' => 'C0C0FF');
6969:             case 0x20: return array('rgb' => '000080');
6970:             case 0x21: return array('rgb' => 'FF00FF');
6971:             case 0x22: return array('rgb' => 'FFFF00');
6972:             case 0x23: return array('rgb' => '00FFFF');
6973:             case 0x24: return array('rgb' => '800080');
6974:             case 0x25: return array('rgb' => '800000');
6975:             case 0x26: return array('rgb' => '008080');
6976:             case 0x27: return array('rgb' => '0000FF');
6977:             case 0x28: return array('rgb' => '00CFFF');
6978:             case 0x29: return array('rgb' => '69FFFF');
6979:             case 0x2A: return array('rgb' => 'E0FFE0');
6980:             case 0x2B: return array('rgb' => 'FFFF80');
6981:             case 0x2C: return array('rgb' => 'A6CAF0');
6982:             case 0x2D: return array('rgb' => 'DD9CB3');
6983:             case 0x2E: return array('rgb' => 'B38FEE');
6984:             case 0x2F: return array('rgb' => 'E3E3E3');
6985:             case 0x30: return array('rgb' => '2A6FF9');
6986:             case 0x31: return array('rgb' => '3FB8CD');
6987:             case 0x32: return array('rgb' => '488436');
6988:             case 0x33: return array('rgb' => '958C41');
6989:             case 0x34: return array('rgb' => '8E5E42');
6990:             case 0x35: return array('rgb' => 'A0627A');
6991:             case 0x36: return array('rgb' => '624FAC');
6992:             case 0x37: return array('rgb' => '969696');
6993:             case 0x38: return array('rgb' => '1D2FBE');
6994:             case 0x39: return array('rgb' => '286676');
6995:             case 0x3A: return array('rgb' => '004500');
6996:             case 0x3B: return array('rgb' => '453E01');
6997:             case 0x3C: return array('rgb' => '6A2813');
6998:             case 0x3D: return array('rgb' => '85396A');
6999:             case 0x3E: return array('rgb' => '4A3285');
7000:             case 0x3F: return array('rgb' => '424242');
7001:             default:   return array('rgb' => '000000');
7002:         }
7003:     }
7004: 
7005: 
7006:     /**
7007:      * Map color array from BIFF8 built-in color index
7008:      *
7009:      * @param int $subData
7010:      * @return array
7011:      */
7012:     private static function _mapColor($subData)
7013:     {
7014:         switch ($subData) {
7015:             case 0x08: return array('rgb' => '000000');
7016:             case 0x09: return array('rgb' => 'FFFFFF');
7017:             case 0x0A: return array('rgb' => 'FF0000');
7018:             case 0x0B: return array('rgb' => '00FF00');
7019:             case 0x0C: return array('rgb' => '0000FF');
7020:             case 0x0D: return array('rgb' => 'FFFF00');
7021:             case 0x0E: return array('rgb' => 'FF00FF');
7022:             case 0x0F: return array('rgb' => '00FFFF');
7023:             case 0x10: return array('rgb' => '800000');
7024:             case 0x11: return array('rgb' => '008000');
7025:             case 0x12: return array('rgb' => '000080');
7026:             case 0x13: return array('rgb' => '808000');
7027:             case 0x14: return array('rgb' => '800080');
7028:             case 0x15: return array('rgb' => '008080');
7029:             case 0x16: return array('rgb' => 'C0C0C0');
7030:             case 0x17: return array('rgb' => '808080');
7031:             case 0x18: return array('rgb' => '9999FF');
7032:             case 0x19: return array('rgb' => '993366');
7033:             case 0x1A: return array('rgb' => 'FFFFCC');
7034:             case 0x1B: return array('rgb' => 'CCFFFF');
7035:             case 0x1C: return array('rgb' => '660066');
7036:             case 0x1D: return array('rgb' => 'FF8080');
7037:             case 0x1E: return array('rgb' => '0066CC');
7038:             case 0x1F: return array('rgb' => 'CCCCFF');
7039:             case 0x20: return array('rgb' => '000080');
7040:             case 0x21: return array('rgb' => 'FF00FF');
7041:             case 0x22: return array('rgb' => 'FFFF00');
7042:             case 0x23: return array('rgb' => '00FFFF');
7043:             case 0x24: return array('rgb' => '800080');
7044:             case 0x25: return array('rgb' => '800000');
7045:             case 0x26: return array('rgb' => '008080');
7046:             case 0x27: return array('rgb' => '0000FF');
7047:             case 0x28: return array('rgb' => '00CCFF');
7048:             case 0x29: return array('rgb' => 'CCFFFF');
7049:             case 0x2A: return array('rgb' => 'CCFFCC');
7050:             case 0x2B: return array('rgb' => 'FFFF99');
7051:             case 0x2C: return array('rgb' => '99CCFF');
7052:             case 0x2D: return array('rgb' => 'FF99CC');
7053:             case 0x2E: return array('rgb' => 'CC99FF');
7054:             case 0x2F: return array('rgb' => 'FFCC99');
7055:             case 0x30: return array('rgb' => '3366FF');
7056:             case 0x31: return array('rgb' => '33CCCC');
7057:             case 0x32: return array('rgb' => '99CC00');
7058:             case 0x33: return array('rgb' => 'FFCC00');
7059:             case 0x34: return array('rgb' => 'FF9900');
7060:             case 0x35: return array('rgb' => 'FF6600');
7061:             case 0x36: return array('rgb' => '666699');
7062:             case 0x37: return array('rgb' => '969696');
7063:             case 0x38: return array('rgb' => '003366');
7064:             case 0x39: return array('rgb' => '339966');
7065:             case 0x3A: return array('rgb' => '003300');
7066:             case 0x3B: return array('rgb' => '333300');
7067:             case 0x3C: return array('rgb' => '993300');
7068:             case 0x3D: return array('rgb' => '993366');
7069:             case 0x3E: return array('rgb' => '333399');
7070:             case 0x3F: return array('rgb' => '333333');
7071:             default:   return array('rgb' => '000000');
7072:         }
7073:     }
7074: 
7075: 
7076:     private function _parseRichText($is = '') {
7077:         $value = new PHPExcel_RichText();
7078: 
7079:         $value->createText($is);
7080: 
7081:         return $value;
7082:     }
7083: 
7084: }
7085: