/branches/v2.6-greffoir/jrest/lib/PHPExcel/Classes/PHPExcel/Reader/Exception.php |
---|
New file |
0,0 → 1,52 |
<?php |
/** |
* PHPExcel |
* |
* Copyright (c) 2006 - 2013 PHPExcel |
* |
* This library is free software; you can redistribute it and/or |
* modify it under the terms of the GNU Lesser General Public |
* License as published by the Free Software Foundation; either |
* version 2.1 of the License, or (at your option) any later version. |
* |
* This library is distributed in the hope that it will be useful, |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
* Lesser General Public License for more details. |
* |
* You should have received a copy of the GNU Lesser General Public |
* License along with this library; if not, write to the Free Software |
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
* |
* @category PHPExcel |
* @package PHPExcel_Reader |
* @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL |
* @version ##VERSION##, ##DATE## |
*/ |
/** |
* PHPExcel_Reader_Exception |
* |
* @category PHPExcel |
* @package PHPExcel_Reader |
* @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
*/ |
class PHPExcel_Reader_Exception extends PHPExcel_Exception { |
/** |
* Error handler callback |
* |
* @param mixed $code |
* @param mixed $string |
* @param mixed $file |
* @param mixed $line |
* @param mixed $context |
*/ |
public static function errorHandlerCallback($code, $string, $file, $line, $context) { |
$e = new self($string, $code); |
$e->line = $line; |
$e->file = $file; |
throw $e; |
} |
} |
/branches/v2.6-greffoir/jrest/lib/PHPExcel/Classes/PHPExcel/Reader/Excel5/Escher.php |
---|
New file |
0,0 → 1,640 |
<?php |
/** |
* PHPExcel |
* |
* Copyright (c) 2006 - 2013 PHPExcel |
* |
* This library is free software; you can redistribute it and/or |
* modify it under the terms of the GNU Lesser General Public |
* License as published by the Free Software Foundation; either |
* version 2.1 of the License, or (at your option) any later version. |
* |
* This library is distributed in the hope that it will be useful, |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
* Lesser General Public License for more details. |
* |
* You should have received a copy of the GNU Lesser General Public |
* License along with this library; if not, write to the Free Software |
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
* |
* @category PHPExcel |
* @package PHPExcel_Reader_Excel5 |
* @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL |
* @version ##VERSION##, ##DATE## |
*/ |
/** |
* PHPExcel_Reader_Excel5_Escher |
* |
* @category PHPExcel |
* @package PHPExcel_Reader_Excel5 |
* @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
*/ |
class PHPExcel_Reader_Excel5_Escher |
{ |
const DGGCONTAINER = 0xF000; |
const BSTORECONTAINER = 0xF001; |
const DGCONTAINER = 0xF002; |
const SPGRCONTAINER = 0xF003; |
const SPCONTAINER = 0xF004; |
const DGG = 0xF006; |
const BSE = 0xF007; |
const DG = 0xF008; |
const SPGR = 0xF009; |
const SP = 0xF00A; |
const OPT = 0xF00B; |
const CLIENTTEXTBOX = 0xF00D; |
const CLIENTANCHOR = 0xF010; |
const CLIENTDATA = 0xF011; |
const BLIPJPEG = 0xF01D; |
const BLIPPNG = 0xF01E; |
const SPLITMENUCOLORS = 0xF11E; |
const TERTIARYOPT = 0xF122; |
/** |
* Escher stream data (binary) |
* |
* @var string |
*/ |
private $_data; |
/** |
* Size in bytes of the Escher stream data |
* |
* @var int |
*/ |
private $_dataSize; |
/** |
* Current position of stream pointer in Escher stream data |
* |
* @var int |
*/ |
private $_pos; |
/** |
* The object to be returned by the reader. Modified during load. |
* |
* @var mixed |
*/ |
private $_object; |
/** |
* Create a new PHPExcel_Reader_Excel5_Escher instance |
* |
* @param mixed $object |
*/ |
public function __construct($object) |
{ |
$this->_object = $object; |
} |
/** |
* Load Escher stream data. May be a partial Escher stream. |
* |
* @param string $data |
*/ |
public function load($data) |
{ |
$this->_data = $data; |
// total byte size of Excel data (workbook global substream + sheet substreams) |
$this->_dataSize = strlen($this->_data); |
$this->_pos = 0; |
// Parse Escher stream |
while ($this->_pos < $this->_dataSize) { |
// offset: 2; size: 2: Record Type |
$fbt = PHPExcel_Reader_Excel5::_GetInt2d($this->_data, $this->_pos + 2); |
switch ($fbt) { |
case self::DGGCONTAINER: $this->_readDggContainer(); break; |
case self::DGG: $this->_readDgg(); break; |
case self::BSTORECONTAINER: $this->_readBstoreContainer(); break; |
case self::BSE: $this->_readBSE(); break; |
case self::BLIPJPEG: $this->_readBlipJPEG(); break; |
case self::BLIPPNG: $this->_readBlipPNG(); break; |
case self::OPT: $this->_readOPT(); break; |
case self::TERTIARYOPT: $this->_readTertiaryOPT(); break; |
case self::SPLITMENUCOLORS: $this->_readSplitMenuColors(); break; |
case self::DGCONTAINER: $this->_readDgContainer(); break; |
case self::DG: $this->_readDg(); break; |
case self::SPGRCONTAINER: $this->_readSpgrContainer(); break; |
case self::SPCONTAINER: $this->_readSpContainer(); break; |
case self::SPGR: $this->_readSpgr(); break; |
case self::SP: $this->_readSp(); break; |
case self::CLIENTTEXTBOX: $this->_readClientTextbox(); break; |
case self::CLIENTANCHOR: $this->_readClientAnchor(); break; |
case self::CLIENTDATA: $this->_readClientData(); break; |
default: $this->_readDefault(); break; |
} |
} |
return $this->_object; |
} |
/** |
* Read a generic record |
*/ |
private function _readDefault() |
{ |
// offset 0; size: 2; recVer and recInstance |
$verInstance = PHPExcel_Reader_Excel5::_GetInt2d($this->_data, $this->_pos); |
// offset: 2; size: 2: Record Type |
$fbt = PHPExcel_Reader_Excel5::_GetInt2d($this->_data, $this->_pos + 2); |
// bit: 0-3; mask: 0x000F; recVer |
$recVer = (0x000F & $verInstance) >> 0; |
$length = PHPExcel_Reader_Excel5::_GetInt4d($this->_data, $this->_pos + 4); |
$recordData = substr($this->_data, $this->_pos + 8, $length); |
// move stream pointer to next record |
$this->_pos += 8 + $length; |
} |
/** |
* Read DggContainer record (Drawing Group Container) |
*/ |
private function _readDggContainer() |
{ |
$length = PHPExcel_Reader_Excel5::_GetInt4d($this->_data, $this->_pos + 4); |
$recordData = substr($this->_data, $this->_pos + 8, $length); |
// move stream pointer to next record |
$this->_pos += 8 + $length; |
// record is a container, read contents |
$dggContainer = new PHPExcel_Shared_Escher_DggContainer(); |
$this->_object->setDggContainer($dggContainer); |
$reader = new PHPExcel_Reader_Excel5_Escher($dggContainer); |
$reader->load($recordData); |
} |
/** |
* Read Dgg record (Drawing Group) |
*/ |
private function _readDgg() |
{ |
$length = PHPExcel_Reader_Excel5::_GetInt4d($this->_data, $this->_pos + 4); |
$recordData = substr($this->_data, $this->_pos + 8, $length); |
// move stream pointer to next record |
$this->_pos += 8 + $length; |
} |
/** |
* Read BstoreContainer record (Blip Store Container) |
*/ |
private function _readBstoreContainer() |
{ |
$length = PHPExcel_Reader_Excel5::_GetInt4d($this->_data, $this->_pos + 4); |
$recordData = substr($this->_data, $this->_pos + 8, $length); |
// move stream pointer to next record |
$this->_pos += 8 + $length; |
// record is a container, read contents |
$bstoreContainer = new PHPExcel_Shared_Escher_DggContainer_BstoreContainer(); |
$this->_object->setBstoreContainer($bstoreContainer); |
$reader = new PHPExcel_Reader_Excel5_Escher($bstoreContainer); |
$reader->load($recordData); |
} |
/** |
* Read BSE record |
*/ |
private function _readBSE() |
{ |
// offset: 0; size: 2; recVer and recInstance |
// bit: 4-15; mask: 0xFFF0; recInstance |
$recInstance = (0xFFF0 & PHPExcel_Reader_Excel5::_GetInt2d($this->_data, $this->_pos)) >> 4; |
$length = PHPExcel_Reader_Excel5::_GetInt4d($this->_data, $this->_pos + 4); |
$recordData = substr($this->_data, $this->_pos + 8, $length); |
// move stream pointer to next record |
$this->_pos += 8 + $length; |
// add BSE to BstoreContainer |
$BSE = new PHPExcel_Shared_Escher_DggContainer_BstoreContainer_BSE(); |
$this->_object->addBSE($BSE); |
$BSE->setBLIPType($recInstance); |
// offset: 0; size: 1; btWin32 (MSOBLIPTYPE) |
$btWin32 = ord($recordData[0]); |
// offset: 1; size: 1; btWin32 (MSOBLIPTYPE) |
$btMacOS = ord($recordData[1]); |
// offset: 2; size: 16; MD4 digest |
$rgbUid = substr($recordData, 2, 16); |
// offset: 18; size: 2; tag |
$tag = PHPExcel_Reader_Excel5::_GetInt2d($recordData, 18); |
// offset: 20; size: 4; size of BLIP in bytes |
$size = PHPExcel_Reader_Excel5::_GetInt4d($recordData, 20); |
// offset: 24; size: 4; number of references to this BLIP |
$cRef = PHPExcel_Reader_Excel5::_GetInt4d($recordData, 24); |
// offset: 28; size: 4; MSOFO file offset |
$foDelay = PHPExcel_Reader_Excel5::_GetInt4d($recordData, 28); |
// offset: 32; size: 1; unused1 |
$unused1 = ord($recordData{32}); |
// offset: 33; size: 1; size of nameData in bytes (including null terminator) |
$cbName = ord($recordData{33}); |
// offset: 34; size: 1; unused2 |
$unused2 = ord($recordData{34}); |
// offset: 35; size: 1; unused3 |
$unused3 = ord($recordData{35}); |
// offset: 36; size: $cbName; nameData |
$nameData = substr($recordData, 36, $cbName); |
// offset: 36 + $cbName, size: var; the BLIP data |
$blipData = substr($recordData, 36 + $cbName); |
// record is a container, read contents |
$reader = new PHPExcel_Reader_Excel5_Escher($BSE); |
$reader->load($blipData); |
} |
/** |
* Read BlipJPEG record. Holds raw JPEG image data |
*/ |
private function _readBlipJPEG() |
{ |
// offset: 0; size: 2; recVer and recInstance |
// bit: 4-15; mask: 0xFFF0; recInstance |
$recInstance = (0xFFF0 & PHPExcel_Reader_Excel5::_GetInt2d($this->_data, $this->_pos)) >> 4; |
$length = PHPExcel_Reader_Excel5::_GetInt4d($this->_data, $this->_pos + 4); |
$recordData = substr($this->_data, $this->_pos + 8, $length); |
// move stream pointer to next record |
$this->_pos += 8 + $length; |
$pos = 0; |
// offset: 0; size: 16; rgbUid1 (MD4 digest of) |
$rgbUid1 = substr($recordData, 0, 16); |
$pos += 16; |
// offset: 16; size: 16; rgbUid2 (MD4 digest), only if $recInstance = 0x46B or 0x6E3 |
if (in_array($recInstance, array(0x046B, 0x06E3))) { |
$rgbUid2 = substr($recordData, 16, 16); |
$pos += 16; |
} |
// offset: var; size: 1; tag |
$tag = ord($recordData{$pos}); |
$pos += 1; |
// offset: var; size: var; the raw image data |
$data = substr($recordData, $pos); |
$blip = new PHPExcel_Shared_Escher_DggContainer_BstoreContainer_BSE_Blip(); |
$blip->setData($data); |
$this->_object->setBlip($blip); |
} |
/** |
* Read BlipPNG record. Holds raw PNG image data |
*/ |
private function _readBlipPNG() |
{ |
// offset: 0; size: 2; recVer and recInstance |
// bit: 4-15; mask: 0xFFF0; recInstance |
$recInstance = (0xFFF0 & PHPExcel_Reader_Excel5::_GetInt2d($this->_data, $this->_pos)) >> 4; |
$length = PHPExcel_Reader_Excel5::_GetInt4d($this->_data, $this->_pos + 4); |
$recordData = substr($this->_data, $this->_pos + 8, $length); |
// move stream pointer to next record |
$this->_pos += 8 + $length; |
$pos = 0; |
// offset: 0; size: 16; rgbUid1 (MD4 digest of) |
$rgbUid1 = substr($recordData, 0, 16); |
$pos += 16; |
// offset: 16; size: 16; rgbUid2 (MD4 digest), only if $recInstance = 0x46B or 0x6E3 |
if ($recInstance == 0x06E1) { |
$rgbUid2 = substr($recordData, 16, 16); |
$pos += 16; |
} |
// offset: var; size: 1; tag |
$tag = ord($recordData{$pos}); |
$pos += 1; |
// offset: var; size: var; the raw image data |
$data = substr($recordData, $pos); |
$blip = new PHPExcel_Shared_Escher_DggContainer_BstoreContainer_BSE_Blip(); |
$blip->setData($data); |
$this->_object->setBlip($blip); |
} |
/** |
* Read OPT record. This record may occur within DggContainer record or SpContainer |
*/ |
private function _readOPT() |
{ |
// offset: 0; size: 2; recVer and recInstance |
// bit: 4-15; mask: 0xFFF0; recInstance |
$recInstance = (0xFFF0 & PHPExcel_Reader_Excel5::_GetInt2d($this->_data, $this->_pos)) >> 4; |
$length = PHPExcel_Reader_Excel5::_GetInt4d($this->_data, $this->_pos + 4); |
$recordData = substr($this->_data, $this->_pos + 8, $length); |
// move stream pointer to next record |
$this->_pos += 8 + $length; |
$this->_readOfficeArtRGFOPTE($recordData, $recInstance); |
} |
/** |
* Read TertiaryOPT record |
*/ |
private function _readTertiaryOPT() |
{ |
// offset: 0; size: 2; recVer and recInstance |
// bit: 4-15; mask: 0xFFF0; recInstance |
$recInstance = (0xFFF0 & PHPExcel_Reader_Excel5::_GetInt2d($this->_data, $this->_pos)) >> 4; |
$length = PHPExcel_Reader_Excel5::_GetInt4d($this->_data, $this->_pos + 4); |
$recordData = substr($this->_data, $this->_pos + 8, $length); |
// move stream pointer to next record |
$this->_pos += 8 + $length; |
} |
/** |
* Read SplitMenuColors record |
*/ |
private function _readSplitMenuColors() |
{ |
$length = PHPExcel_Reader_Excel5::_GetInt4d($this->_data, $this->_pos + 4); |
$recordData = substr($this->_data, $this->_pos + 8, $length); |
// move stream pointer to next record |
$this->_pos += 8 + $length; |
} |
/** |
* Read DgContainer record (Drawing Container) |
*/ |
private function _readDgContainer() |
{ |
$length = PHPExcel_Reader_Excel5::_GetInt4d($this->_data, $this->_pos + 4); |
$recordData = substr($this->_data, $this->_pos + 8, $length); |
// move stream pointer to next record |
$this->_pos += 8 + $length; |
// record is a container, read contents |
$dgContainer = new PHPExcel_Shared_Escher_DgContainer(); |
$this->_object->setDgContainer($dgContainer); |
$reader = new PHPExcel_Reader_Excel5_Escher($dgContainer); |
$escher = $reader->load($recordData); |
} |
/** |
* Read Dg record (Drawing) |
*/ |
private function _readDg() |
{ |
$length = PHPExcel_Reader_Excel5::_GetInt4d($this->_data, $this->_pos + 4); |
$recordData = substr($this->_data, $this->_pos + 8, $length); |
// move stream pointer to next record |
$this->_pos += 8 + $length; |
} |
/** |
* Read SpgrContainer record (Shape Group Container) |
*/ |
private function _readSpgrContainer() |
{ |
// context is either context DgContainer or SpgrContainer |
$length = PHPExcel_Reader_Excel5::_GetInt4d($this->_data, $this->_pos + 4); |
$recordData = substr($this->_data, $this->_pos + 8, $length); |
// move stream pointer to next record |
$this->_pos += 8 + $length; |
// record is a container, read contents |
$spgrContainer = new PHPExcel_Shared_Escher_DgContainer_SpgrContainer(); |
if ($this->_object instanceof PHPExcel_Shared_Escher_DgContainer) { |
// DgContainer |
$this->_object->setSpgrContainer($spgrContainer); |
} else { |
// SpgrContainer |
$this->_object->addChild($spgrContainer); |
} |
$reader = new PHPExcel_Reader_Excel5_Escher($spgrContainer); |
$escher = $reader->load($recordData); |
} |
/** |
* Read SpContainer record (Shape Container) |
*/ |
private function _readSpContainer() |
{ |
$length = PHPExcel_Reader_Excel5::_GetInt4d($this->_data, $this->_pos + 4); |
$recordData = substr($this->_data, $this->_pos + 8, $length); |
// add spContainer to spgrContainer |
$spContainer = new PHPExcel_Shared_Escher_DgContainer_SpgrContainer_SpContainer(); |
$this->_object->addChild($spContainer); |
// move stream pointer to next record |
$this->_pos += 8 + $length; |
// record is a container, read contents |
$reader = new PHPExcel_Reader_Excel5_Escher($spContainer); |
$escher = $reader->load($recordData); |
} |
/** |
* Read Spgr record (Shape Group) |
*/ |
private function _readSpgr() |
{ |
$length = PHPExcel_Reader_Excel5::_GetInt4d($this->_data, $this->_pos + 4); |
$recordData = substr($this->_data, $this->_pos + 8, $length); |
// move stream pointer to next record |
$this->_pos += 8 + $length; |
} |
/** |
* Read Sp record (Shape) |
*/ |
private function _readSp() |
{ |
// offset: 0; size: 2; recVer and recInstance |
// bit: 4-15; mask: 0xFFF0; recInstance |
$recInstance = (0xFFF0 & PHPExcel_Reader_Excel5::_GetInt2d($this->_data, $this->_pos)) >> 4; |
$length = PHPExcel_Reader_Excel5::_GetInt4d($this->_data, $this->_pos + 4); |
$recordData = substr($this->_data, $this->_pos + 8, $length); |
// move stream pointer to next record |
$this->_pos += 8 + $length; |
} |
/** |
* Read ClientTextbox record |
*/ |
private function _readClientTextbox() |
{ |
// offset: 0; size: 2; recVer and recInstance |
// bit: 4-15; mask: 0xFFF0; recInstance |
$recInstance = (0xFFF0 & PHPExcel_Reader_Excel5::_GetInt2d($this->_data, $this->_pos)) >> 4; |
$length = PHPExcel_Reader_Excel5::_GetInt4d($this->_data, $this->_pos + 4); |
$recordData = substr($this->_data, $this->_pos + 8, $length); |
// move stream pointer to next record |
$this->_pos += 8 + $length; |
} |
/** |
* Read ClientAnchor record. This record holds information about where the shape is anchored in worksheet |
*/ |
private function _readClientAnchor() |
{ |
$length = PHPExcel_Reader_Excel5::_GetInt4d($this->_data, $this->_pos + 4); |
$recordData = substr($this->_data, $this->_pos + 8, $length); |
// move stream pointer to next record |
$this->_pos += 8 + $length; |
// offset: 2; size: 2; upper-left corner column index (0-based) |
$c1 = PHPExcel_Reader_Excel5::_GetInt2d($recordData, 2); |
// offset: 4; size: 2; upper-left corner horizontal offset in 1/1024 of column width |
$startOffsetX = PHPExcel_Reader_Excel5::_GetInt2d($recordData, 4); |
// offset: 6; size: 2; upper-left corner row index (0-based) |
$r1 = PHPExcel_Reader_Excel5::_GetInt2d($recordData, 6); |
// offset: 8; size: 2; upper-left corner vertical offset in 1/256 of row height |
$startOffsetY = PHPExcel_Reader_Excel5::_GetInt2d($recordData, 8); |
// offset: 10; size: 2; bottom-right corner column index (0-based) |
$c2 = PHPExcel_Reader_Excel5::_GetInt2d($recordData, 10); |
// offset: 12; size: 2; bottom-right corner horizontal offset in 1/1024 of column width |
$endOffsetX = PHPExcel_Reader_Excel5::_GetInt2d($recordData, 12); |
// offset: 14; size: 2; bottom-right corner row index (0-based) |
$r2 = PHPExcel_Reader_Excel5::_GetInt2d($recordData, 14); |
// offset: 16; size: 2; bottom-right corner vertical offset in 1/256 of row height |
$endOffsetY = PHPExcel_Reader_Excel5::_GetInt2d($recordData, 16); |
// set the start coordinates |
$this->_object->setStartCoordinates(PHPExcel_Cell::stringFromColumnIndex($c1) . ($r1 + 1)); |
// set the start offsetX |
$this->_object->setStartOffsetX($startOffsetX); |
// set the start offsetY |
$this->_object->setStartOffsetY($startOffsetY); |
// set the end coordinates |
$this->_object->setEndCoordinates(PHPExcel_Cell::stringFromColumnIndex($c2) . ($r2 + 1)); |
// set the end offsetX |
$this->_object->setEndOffsetX($endOffsetX); |
// set the end offsetY |
$this->_object->setEndOffsetY($endOffsetY); |
} |
/** |
* Read ClientData record |
*/ |
private function _readClientData() |
{ |
$length = PHPExcel_Reader_Excel5::_GetInt4d($this->_data, $this->_pos + 4); |
$recordData = substr($this->_data, $this->_pos + 8, $length); |
// move stream pointer to next record |
$this->_pos += 8 + $length; |
} |
/** |
* Read OfficeArtRGFOPTE table of property-value pairs |
* |
* @param string $data Binary data |
* @param int $n Number of properties |
*/ |
private function _readOfficeArtRGFOPTE($data, $n) { |
$splicedComplexData = substr($data, 6 * $n); |
// loop through property-value pairs |
for ($i = 0; $i < $n; ++$i) { |
// read 6 bytes at a time |
$fopte = substr($data, 6 * $i, 6); |
// offset: 0; size: 2; opid |
$opid = PHPExcel_Reader_Excel5::_GetInt2d($fopte, 0); |
// bit: 0-13; mask: 0x3FFF; opid.opid |
$opidOpid = (0x3FFF & $opid) >> 0; |
// bit: 14; mask 0x4000; 1 = value in op field is BLIP identifier |
$opidFBid = (0x4000 & $opid) >> 14; |
// bit: 15; mask 0x8000; 1 = this is a complex property, op field specifies size of complex data |
$opidFComplex = (0x8000 & $opid) >> 15; |
// offset: 2; size: 4; the value for this property |
$op = PHPExcel_Reader_Excel5::_GetInt4d($fopte, 2); |
if ($opidFComplex) { |
$complexData = substr($splicedComplexData, 0, $op); |
$splicedComplexData = substr($splicedComplexData, $op); |
// we store string value with complex data |
$value = $complexData; |
} else { |
// we store integer value |
$value = $op; |
} |
$this->_object->setOPT($opidOpid, $value); |
} |
} |
} |
/branches/v2.6-greffoir/jrest/lib/PHPExcel/Classes/PHPExcel/Reader/OOCalc.php |
---|
New file |
0,0 → 1,695 |
<?php |
/** |
* PHPExcel |
* |
* Copyright (c) 2006 - 2013 PHPExcel |
* |
* This library is free software; you can redistribute it and/or |
* modify it under the terms of the GNU Lesser General Public |
* License as published by the Free Software Foundation; either |
* version 2.1 of the License, or (at your option) any later version. |
* |
* This library is distributed in the hope that it will be useful, |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
* Lesser General Public License for more details. |
* |
* You should have received a copy of the GNU Lesser General Public |
* License along with this library; if not, write to the Free Software |
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
* |
* @category PHPExcel |
* @package PHPExcel_Reader |
* @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL |
* @version ##VERSION##, ##DATE## |
*/ |
/** PHPExcel root directory */ |
if (!defined('PHPEXCEL_ROOT')) { |
/** |
* @ignore |
*/ |
define('PHPEXCEL_ROOT', dirname(__FILE__) . '/../../'); |
require(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php'); |
} |
/** |
* PHPExcel_Reader_OOCalc |
* |
* @category PHPExcel |
* @package PHPExcel_Reader |
* @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
*/ |
class PHPExcel_Reader_OOCalc extends PHPExcel_Reader_Abstract implements PHPExcel_Reader_IReader |
{ |
/** |
* Formats |
* |
* @var array |
*/ |
private $_styles = array(); |
/** |
* Create a new PHPExcel_Reader_OOCalc |
*/ |
public function __construct() { |
$this->_readFilter = new PHPExcel_Reader_DefaultReadFilter(); |
} |
/** |
* Can the current PHPExcel_Reader_IReader read the file? |
* |
* @param string $pFilename |
* @return boolean |
* @throws PHPExcel_Reader_Exception |
*/ |
public function canRead($pFilename) |
{ |
// Check if file exists |
if (!file_exists($pFilename)) { |
throw new PHPExcel_Reader_Exception("Could not open " . $pFilename . " for reading! File does not exist."); |
} |
// Check if zip class exists |
if (!class_exists('ZipArchive',FALSE)) { |
throw new PHPExcel_Reader_Exception("ZipArchive library is not enabled"); |
} |
$mimeType = 'UNKNOWN'; |
// Load file |
$zip = new ZipArchive; |
if ($zip->open($pFilename) === true) { |
// check if it is an OOXML archive |
$stat = $zip->statName('mimetype'); |
if ($stat && ($stat['size'] <= 255)) { |
$mimeType = $zip->getFromName($stat['name']); |
} elseif($stat = $zip->statName('META-INF/manifest.xml')) { |
$xml = simplexml_load_string($zip->getFromName('META-INF/manifest.xml')); |
$namespacesContent = $xml->getNamespaces(true); |
if (isset($namespacesContent['manifest'])) { |
$manifest = $xml->children($namespacesContent['manifest']); |
foreach($manifest as $manifestDataSet) { |
$manifestAttributes = $manifestDataSet->attributes($namespacesContent['manifest']); |
if ($manifestAttributes->{'full-path'} == '/') { |
$mimeType = (string) $manifestAttributes->{'media-type'}; |
break; |
} |
} |
} |
} |
$zip->close(); |
return ($mimeType === 'application/vnd.oasis.opendocument.spreadsheet'); |
} |
return FALSE; |
} |
/** |
* Reads names of the worksheets from a file, without parsing the whole file to a PHPExcel object |
* |
* @param string $pFilename |
* @throws PHPExcel_Reader_Exception |
*/ |
public function listWorksheetNames($pFilename) |
{ |
// Check if file exists |
if (!file_exists($pFilename)) { |
throw new PHPExcel_Reader_Exception("Could not open " . $pFilename . " for reading! File does not exist."); |
} |
$zip = new ZipArchive; |
if (!$zip->open($pFilename)) { |
throw new PHPExcel_Reader_Exception("Could not open " . $pFilename . " for reading! Error opening file."); |
} |
$worksheetNames = array(); |
$xml = new XMLReader(); |
$res = $xml->open('zip://'.realpath($pFilename).'#content.xml'); |
$xml->setParserProperty(2,true); |
// Step into the first level of content of the XML |
$xml->read(); |
while ($xml->read()) { |
// Quickly jump through to the office:body node |
while ($xml->name !== 'office:body') { |
if ($xml->isEmptyElement) |
$xml->read(); |
else |
$xml->next(); |
} |
// Now read each node until we find our first table:table node |
while ($xml->read()) { |
if ($xml->name == 'table:table' && $xml->nodeType == XMLReader::ELEMENT) { |
// Loop through each table:table node reading the table:name attribute for each worksheet name |
do { |
$worksheetNames[] = $xml->getAttribute('table:name'); |
$xml->next(); |
} while ($xml->name == 'table:table' && $xml->nodeType == XMLReader::ELEMENT); |
} |
} |
} |
return $worksheetNames; |
} |
/** |
* Return worksheet info (Name, Last Column Letter, Last Column Index, Total Rows, Total Columns) |
* |
* @param string $pFilename |
* @throws PHPExcel_Reader_Exception |
*/ |
public function listWorksheetInfo($pFilename) |
{ |
// Check if file exists |
if (!file_exists($pFilename)) { |
throw new PHPExcel_Reader_Exception("Could not open " . $pFilename . " for reading! File does not exist."); |
} |
$worksheetInfo = array(); |
$zip = new ZipArchive; |
if (!$zip->open($pFilename)) { |
throw new PHPExcel_Reader_Exception("Could not open " . $pFilename . " for reading! Error opening file."); |
} |
$xml = new XMLReader(); |
$res = $xml->open('zip://'.realpath($pFilename).'#content.xml'); |
$xml->setParserProperty(2,true); |
// Step into the first level of content of the XML |
$xml->read(); |
while ($xml->read()) { |
// Quickly jump through to the office:body node |
while ($xml->name !== 'office:body') { |
if ($xml->isEmptyElement) |
$xml->read(); |
else |
$xml->next(); |
} |
// Now read each node until we find our first table:table node |
while ($xml->read()) { |
if ($xml->name == 'table:table' && $xml->nodeType == XMLReader::ELEMENT) { |
$worksheetNames[] = $xml->getAttribute('table:name'); |
$tmpInfo = array( |
'worksheetName' => $xml->getAttribute('table:name'), |
'lastColumnLetter' => 'A', |
'lastColumnIndex' => 0, |
'totalRows' => 0, |
'totalColumns' => 0, |
); |
// Loop through each child node of the table:table element reading |
$currCells = 0; |
do { |
$xml->read(); |
if ($xml->name == 'table:table-row' && $xml->nodeType == XMLReader::ELEMENT) { |
$rowspan = $xml->getAttribute('table:number-rows-repeated'); |
$rowspan = empty($rowspan) ? 1 : $rowspan; |
$tmpInfo['totalRows'] += $rowspan; |
$tmpInfo['totalColumns'] = max($tmpInfo['totalColumns'],$currCells); |
$currCells = 0; |
// Step into the row |
$xml->read(); |
do { |
if ($xml->name == 'table:table-cell' && $xml->nodeType == XMLReader::ELEMENT) { |
if (!$xml->isEmptyElement) { |
$currCells++; |
$xml->next(); |
} else { |
$xml->read(); |
} |
} elseif ($xml->name == 'table:covered-table-cell' && $xml->nodeType == XMLReader::ELEMENT) { |
$mergeSize = $xml->getAttribute('table:number-columns-repeated'); |
$currCells += $mergeSize; |
$xml->read(); |
} |
} while ($xml->name != 'table:table-row'); |
} |
} while ($xml->name != 'table:table'); |
$tmpInfo['totalColumns'] = max($tmpInfo['totalColumns'],$currCells); |
$tmpInfo['lastColumnIndex'] = $tmpInfo['totalColumns'] - 1; |
$tmpInfo['lastColumnLetter'] = PHPExcel_Cell::stringFromColumnIndex($tmpInfo['lastColumnIndex']); |
$worksheetInfo[] = $tmpInfo; |
} |
} |
// foreach($workbookData->table as $worksheetDataSet) { |
// $worksheetData = $worksheetDataSet->children($namespacesContent['table']); |
// $worksheetDataAttributes = $worksheetDataSet->attributes($namespacesContent['table']); |
// |
// $rowIndex = 0; |
// foreach ($worksheetData as $key => $rowData) { |
// switch ($key) { |
// case 'table-row' : |
// $rowDataTableAttributes = $rowData->attributes($namespacesContent['table']); |
// $rowRepeats = (isset($rowDataTableAttributes['number-rows-repeated'])) ? |
// $rowDataTableAttributes['number-rows-repeated'] : 1; |
// $columnIndex = 0; |
// |
// foreach ($rowData as $key => $cellData) { |
// $cellDataTableAttributes = $cellData->attributes($namespacesContent['table']); |
// $colRepeats = (isset($cellDataTableAttributes['number-columns-repeated'])) ? |
// $cellDataTableAttributes['number-columns-repeated'] : 1; |
// $cellDataOfficeAttributes = $cellData->attributes($namespacesContent['office']); |
// if (isset($cellDataOfficeAttributes['value-type'])) { |
// $tmpInfo['lastColumnIndex'] = max($tmpInfo['lastColumnIndex'], $columnIndex + $colRepeats - 1); |
// $tmpInfo['totalRows'] = max($tmpInfo['totalRows'], $rowIndex + $rowRepeats); |
// } |
// $columnIndex += $colRepeats; |
// } |
// $rowIndex += $rowRepeats; |
// break; |
// } |
// } |
// |
// $tmpInfo['lastColumnLetter'] = PHPExcel_Cell::stringFromColumnIndex($tmpInfo['lastColumnIndex']); |
// $tmpInfo['totalColumns'] = $tmpInfo['lastColumnIndex'] + 1; |
// |
// } |
// } |
} |
return $worksheetInfo; |
} |
/** |
* Loads PHPExcel from file |
* |
* @param string $pFilename |
* @return PHPExcel |
* @throws PHPExcel_Reader_Exception |
*/ |
public function load($pFilename) |
{ |
// Create new PHPExcel |
$objPHPExcel = new PHPExcel(); |
// Load into this instance |
return $this->loadIntoExisting($pFilename, $objPHPExcel); |
} |
private static function identifyFixedStyleValue($styleList,&$styleAttributeValue) { |
$styleAttributeValue = strtolower($styleAttributeValue); |
foreach($styleList as $style) { |
if ($styleAttributeValue == strtolower($style)) { |
$styleAttributeValue = $style; |
return true; |
} |
} |
return false; |
} |
/** |
* Loads PHPExcel from file into PHPExcel instance |
* |
* @param string $pFilename |
* @param PHPExcel $objPHPExcel |
* @return PHPExcel |
* @throws PHPExcel_Reader_Exception |
*/ |
public function loadIntoExisting($pFilename, PHPExcel $objPHPExcel) |
{ |
// Check if file exists |
if (!file_exists($pFilename)) { |
throw new PHPExcel_Reader_Exception("Could not open " . $pFilename . " for reading! File does not exist."); |
} |
$timezoneObj = new DateTimeZone('Europe/London'); |
$GMT = new DateTimeZone('UTC'); |
$zip = new ZipArchive; |
if (!$zip->open($pFilename)) { |
throw new PHPExcel_Reader_Exception("Could not open " . $pFilename . " for reading! Error opening file."); |
} |
// echo '<h1>Meta Information</h1>'; |
$xml = simplexml_load_string($zip->getFromName("meta.xml")); |
$namespacesMeta = $xml->getNamespaces(true); |
// echo '<pre>'; |
// print_r($namespacesMeta); |
// echo '</pre><hr />'; |
$docProps = $objPHPExcel->getProperties(); |
$officeProperty = $xml->children($namespacesMeta['office']); |
foreach($officeProperty as $officePropertyData) { |
$officePropertyDC = array(); |
if (isset($namespacesMeta['dc'])) { |
$officePropertyDC = $officePropertyData->children($namespacesMeta['dc']); |
} |
foreach($officePropertyDC as $propertyName => $propertyValue) { |
switch ($propertyName) { |
case 'title' : |
$docProps->setTitle($propertyValue); |
break; |
case 'subject' : |
$docProps->setSubject($propertyValue); |
break; |
case 'creator' : |
$docProps->setCreator($propertyValue); |
$docProps->setLastModifiedBy($propertyValue); |
break; |
case 'date' : |
$creationDate = strtotime($propertyValue); |
$docProps->setCreated($creationDate); |
$docProps->setModified($creationDate); |
break; |
case 'description' : |
$docProps->setDescription($propertyValue); |
break; |
} |
} |
$officePropertyMeta = array(); |
if (isset($namespacesMeta['dc'])) { |
$officePropertyMeta = $officePropertyData->children($namespacesMeta['meta']); |
} |
foreach($officePropertyMeta as $propertyName => $propertyValue) { |
$propertyValueAttributes = $propertyValue->attributes($namespacesMeta['meta']); |
switch ($propertyName) { |
case 'initial-creator' : |
$docProps->setCreator($propertyValue); |
break; |
case 'keyword' : |
$docProps->setKeywords($propertyValue); |
break; |
case 'creation-date' : |
$creationDate = strtotime($propertyValue); |
$docProps->setCreated($creationDate); |
break; |
case 'user-defined' : |
$propertyValueType = PHPExcel_DocumentProperties::PROPERTY_TYPE_STRING; |
foreach ($propertyValueAttributes as $key => $value) { |
if ($key == 'name') { |
$propertyValueName = (string) $value; |
} elseif($key == 'value-type') { |
switch ($value) { |
case 'date' : |
$propertyValue = PHPExcel_DocumentProperties::convertProperty($propertyValue,'date'); |
$propertyValueType = PHPExcel_DocumentProperties::PROPERTY_TYPE_DATE; |
break; |
case 'boolean' : |
$propertyValue = PHPExcel_DocumentProperties::convertProperty($propertyValue,'bool'); |
$propertyValueType = PHPExcel_DocumentProperties::PROPERTY_TYPE_BOOLEAN; |
break; |
case 'float' : |
$propertyValue = PHPExcel_DocumentProperties::convertProperty($propertyValue,'r4'); |
$propertyValueType = PHPExcel_DocumentProperties::PROPERTY_TYPE_FLOAT; |
break; |
default : |
$propertyValueType = PHPExcel_DocumentProperties::PROPERTY_TYPE_STRING; |
} |
} |
} |
$docProps->setCustomProperty($propertyValueName,$propertyValue,$propertyValueType); |
break; |
} |
} |
} |
// echo '<h1>Workbook Content</h1>'; |
$xml = simplexml_load_string($zip->getFromName("content.xml")); |
$namespacesContent = $xml->getNamespaces(true); |
// echo '<pre>'; |
// print_r($namespacesContent); |
// echo '</pre><hr />'; |
$workbook = $xml->children($namespacesContent['office']); |
foreach($workbook->body->spreadsheet as $workbookData) { |
$workbookData = $workbookData->children($namespacesContent['table']); |
$worksheetID = 0; |
foreach($workbookData->table as $worksheetDataSet) { |
$worksheetData = $worksheetDataSet->children($namespacesContent['table']); |
// print_r($worksheetData); |
// echo '<br />'; |
$worksheetDataAttributes = $worksheetDataSet->attributes($namespacesContent['table']); |
// print_r($worksheetDataAttributes); |
// echo '<br />'; |
if ((isset($this->_loadSheetsOnly)) && (isset($worksheetDataAttributes['name'])) && |
(!in_array($worksheetDataAttributes['name'], $this->_loadSheetsOnly))) { |
continue; |
} |
// echo '<h2>Worksheet '.$worksheetDataAttributes['name'].'</h2>'; |
// Create new Worksheet |
$objPHPExcel->createSheet(); |
$objPHPExcel->setActiveSheetIndex($worksheetID); |
if (isset($worksheetDataAttributes['name'])) { |
$worksheetName = (string) $worksheetDataAttributes['name']; |
// Use false for $updateFormulaCellReferences to prevent adjustment of worksheet references in |
// formula cells... during the load, all formulae should be correct, and we're simply |
// bringing the worksheet name in line with the formula, not the reverse |
$objPHPExcel->getActiveSheet()->setTitle($worksheetName,false); |
} |
$rowID = 1; |
foreach($worksheetData as $key => $rowData) { |
// echo '<b>'.$key.'</b><br />'; |
switch ($key) { |
case 'table-header-rows': |
foreach ($rowData as $key=>$cellData) { |
$rowData = $cellData; |
break; |
} |
case 'table-row' : |
$rowDataTableAttributes = $rowData->attributes($namespacesContent['table']); |
$rowRepeats = (isset($rowDataTableAttributes['number-rows-repeated'])) ? |
$rowDataTableAttributes['number-rows-repeated'] : 1; |
$columnID = 'A'; |
foreach($rowData as $key => $cellData) { |
if ($this->getReadFilter() !== NULL) { |
if (!$this->getReadFilter()->readCell($columnID, $rowID, $worksheetName)) { |
continue; |
} |
} |
// echo '<b>'.$columnID.$rowID.'</b><br />'; |
$cellDataText = (isset($namespacesContent['text'])) ? |
$cellData->children($namespacesContent['text']) : |
''; |
$cellDataOffice = $cellData->children($namespacesContent['office']); |
$cellDataOfficeAttributes = $cellData->attributes($namespacesContent['office']); |
$cellDataTableAttributes = $cellData->attributes($namespacesContent['table']); |
// echo 'Office Attributes: '; |
// print_r($cellDataOfficeAttributes); |
// echo '<br />Table Attributes: '; |
// print_r($cellDataTableAttributes); |
// echo '<br />Cell Data Text'; |
// print_r($cellDataText); |
// echo '<br />'; |
// |
$type = $formatting = $hyperlink = null; |
$hasCalculatedValue = false; |
$cellDataFormula = ''; |
if (isset($cellDataTableAttributes['formula'])) { |
$cellDataFormula = $cellDataTableAttributes['formula']; |
$hasCalculatedValue = true; |
} |
if (isset($cellDataOffice->annotation)) { |
// echo 'Cell has comment<br />'; |
$annotationText = $cellDataOffice->annotation->children($namespacesContent['text']); |
$textArray = array(); |
foreach($annotationText as $t) { |
foreach($t->span as $text) { |
$textArray[] = (string)$text; |
} |
} |
$text = implode("\n",$textArray); |
// echo $text,'<br />'; |
$objPHPExcel->getActiveSheet()->getComment( $columnID.$rowID ) |
// ->setAuthor( $author ) |
->setText($this->_parseRichText($text) ); |
} |
if (isset($cellDataText->p)) { |
// Consolidate if there are multiple p records (maybe with spans as well) |
$dataArray = array(); |
// Text can have multiple text:p and within those, multiple text:span. |
// text:p newlines, but text:span does not. |
// Also, here we assume there is no text data is span fields are specified, since |
// we have no way of knowing proper positioning anyway. |
foreach ($cellDataText->p as $pData) { |
if (isset($pData->span)) { |
// span sections do not newline, so we just create one large string here |
$spanSection = ""; |
foreach ($pData->span as $spanData) { |
$spanSection .= $spanData; |
} |
array_push($dataArray, $spanSection); |
} else { |
array_push($dataArray, $pData); |
} |
} |
$allCellDataText = implode($dataArray, "\n"); |
// echo 'Value Type is '.$cellDataOfficeAttributes['value-type'].'<br />'; |
switch ($cellDataOfficeAttributes['value-type']) { |
case 'string' : |
$type = PHPExcel_Cell_DataType::TYPE_STRING; |
$dataValue = $allCellDataText; |
if (isset($dataValue->a)) { |
$dataValue = $dataValue->a; |
$cellXLinkAttributes = $dataValue->attributes($namespacesContent['xlink']); |
$hyperlink = $cellXLinkAttributes['href']; |
} |
break; |
case 'boolean' : |
$type = PHPExcel_Cell_DataType::TYPE_BOOL; |
$dataValue = ($allCellDataText == 'TRUE') ? True : False; |
break; |
case 'percentage' : |
$type = PHPExcel_Cell_DataType::TYPE_NUMERIC; |
$dataValue = (float) $cellDataOfficeAttributes['value']; |
if (floor($dataValue) == $dataValue) { |
$dataValue = (integer) $dataValue; |
} |
$formatting = PHPExcel_Style_NumberFormat::FORMAT_PERCENTAGE_00; |
break; |
case 'currency' : |
$type = PHPExcel_Cell_DataType::TYPE_NUMERIC; |
$dataValue = (float) $cellDataOfficeAttributes['value']; |
if (floor($dataValue) == $dataValue) { |
$dataValue = (integer) $dataValue; |
} |
$formatting = PHPExcel_Style_NumberFormat::FORMAT_CURRENCY_USD_SIMPLE; |
break; |
case 'float' : |
$type = PHPExcel_Cell_DataType::TYPE_NUMERIC; |
$dataValue = (float) $cellDataOfficeAttributes['value']; |
if (floor($dataValue) == $dataValue) { |
if ($dataValue = (integer) $dataValue) |
$dataValue = (integer) $dataValue; |
else |
$dataValue = (float) $dataValue; |
} |
break; |
case 'date' : |
$type = PHPExcel_Cell_DataType::TYPE_NUMERIC; |
$dateObj = new DateTime($cellDataOfficeAttributes['date-value'], $GMT); |
$dateObj->setTimeZone($timezoneObj); |
list($year,$month,$day,$hour,$minute,$second) = explode(' ',$dateObj->format('Y m d H i s')); |
$dataValue = PHPExcel_Shared_Date::FormattedPHPToExcel($year,$month,$day,$hour,$minute,$second); |
if ($dataValue != floor($dataValue)) { |
$formatting = PHPExcel_Style_NumberFormat::FORMAT_DATE_XLSX15.' '.PHPExcel_Style_NumberFormat::FORMAT_DATE_TIME4; |
} else { |
$formatting = PHPExcel_Style_NumberFormat::FORMAT_DATE_XLSX15; |
} |
break; |
case 'time' : |
$type = PHPExcel_Cell_DataType::TYPE_NUMERIC; |
$dataValue = PHPExcel_Shared_Date::PHPToExcel(strtotime('01-01-1970 '.implode(':',sscanf($cellDataOfficeAttributes['time-value'],'PT%dH%dM%dS')))); |
$formatting = PHPExcel_Style_NumberFormat::FORMAT_DATE_TIME4; |
break; |
} |
// echo 'Data value is '.$dataValue.'<br />'; |
// if ($hyperlink !== NULL) { |
// echo 'Hyperlink is '.$hyperlink.'<br />'; |
// } |
} else { |
$type = PHPExcel_Cell_DataType::TYPE_NULL; |
$dataValue = NULL; |
} |
if ($hasCalculatedValue) { |
$type = PHPExcel_Cell_DataType::TYPE_FORMULA; |
// echo 'Formula: '.$cellDataFormula.'<br />'; |
$cellDataFormula = substr($cellDataFormula,strpos($cellDataFormula,':=')+1); |
$temp = explode('"',$cellDataFormula); |
$tKey = false; |
foreach($temp as &$value) { |
// Only replace in alternate array entries (i.e. non-quoted blocks) |
if ($tKey = !$tKey) { |
$value = preg_replace('/\[\.(.*):\.(.*)\]/Ui','$1:$2',$value); |
$value = preg_replace('/\[\.(.*)\]/Ui','$1',$value); |
$value = PHPExcel_Calculation::_translateSeparator(';',',',$value,$inBraces); |
} |
} |
unset($value); |
// Then rebuild the formula string |
$cellDataFormula = implode('"',$temp); |
// echo 'Adjusted Formula: '.$cellDataFormula.'<br />'; |
} |
$colRepeats = (isset($cellDataTableAttributes['number-columns-repeated'])) ? |
$cellDataTableAttributes['number-columns-repeated'] : 1; |
if ($type !== NULL) { |
for ($i = 0; $i < $colRepeats; ++$i) { |
if ($i > 0) { |
++$columnID; |
} |
if ($type !== PHPExcel_Cell_DataType::TYPE_NULL) { |
for ($rowAdjust = 0; $rowAdjust < $rowRepeats; ++$rowAdjust) { |
$rID = $rowID + $rowAdjust; |
$objPHPExcel->getActiveSheet()->getCell($columnID.$rID)->setValueExplicit((($hasCalculatedValue) ? $cellDataFormula : $dataValue),$type); |
if ($hasCalculatedValue) { |
// echo 'Forumla result is '.$dataValue.'<br />'; |
$objPHPExcel->getActiveSheet()->getCell($columnID.$rID)->setCalculatedValue($dataValue); |
} |
if ($formatting !== NULL) { |
$objPHPExcel->getActiveSheet()->getStyle($columnID.$rID)->getNumberFormat()->setFormatCode($formatting); |
} else { |
$objPHPExcel->getActiveSheet()->getStyle($columnID.$rID)->getNumberFormat()->setFormatCode(PHPExcel_Style_NumberFormat::FORMAT_GENERAL); |
} |
if ($hyperlink !== NULL) { |
$objPHPExcel->getActiveSheet()->getCell($columnID.$rID)->getHyperlink()->setUrl($hyperlink); |
} |
} |
} |
} |
} |
// Merged cells |
if ((isset($cellDataTableAttributes['number-columns-spanned'])) || (isset($cellDataTableAttributes['number-rows-spanned']))) { |
if (($type !== PHPExcel_Cell_DataType::TYPE_NULL) || (!$this->_readDataOnly)) { |
$columnTo = $columnID; |
if (isset($cellDataTableAttributes['number-columns-spanned'])) { |
$columnTo = PHPExcel_Cell::stringFromColumnIndex(PHPExcel_Cell::columnIndexFromString($columnID) + $cellDataTableAttributes['number-columns-spanned'] -2); |
} |
$rowTo = $rowID; |
if (isset($cellDataTableAttributes['number-rows-spanned'])) { |
$rowTo = $rowTo + $cellDataTableAttributes['number-rows-spanned'] - 1; |
} |
$cellRange = $columnID.$rowID.':'.$columnTo.$rowTo; |
$objPHPExcel->getActiveSheet()->mergeCells($cellRange); |
} |
} |
++$columnID; |
} |
$rowID += $rowRepeats; |
break; |
} |
} |
++$worksheetID; |
} |
} |
// Return |
return $objPHPExcel; |
} |
private function _parseRichText($is = '') { |
$value = new PHPExcel_RichText(); |
$value->createText($is); |
return $value; |
} |
} |
/branches/v2.6-greffoir/jrest/lib/PHPExcel/Classes/PHPExcel/Reader/SYLK.php |
---|
New file |
0,0 → 1,450 |
<?php |
/** |
* PHPExcel |
* |
* Copyright (c) 2006 - 2013 PHPExcel |
* |
* This library is free software; you can redistribute it and/or |
* modify it under the terms of the GNU Lesser General Public |
* License as published by the Free Software Foundation; either |
* version 2.1 of the License, or (at your option) any later version. |
* |
* This library is distributed in the hope that it will be useful, |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
* Lesser General Public License for more details. |
* |
* You should have received a copy of the GNU Lesser General Public |
* License along with this library; if not, write to the Free Software |
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
* |
* @category PHPExcel |
* @package PHPExcel_Reader |
* @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL |
* @version ##VERSION##, ##DATE## |
*/ |
/** PHPExcel root directory */ |
if (!defined('PHPEXCEL_ROOT')) { |
/** |
* @ignore |
*/ |
define('PHPEXCEL_ROOT', dirname(__FILE__) . '/../../'); |
require(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php'); |
} |
/** |
* PHPExcel_Reader_SYLK |
* |
* @category PHPExcel |
* @package PHPExcel_Reader |
* @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
*/ |
class PHPExcel_Reader_SYLK extends PHPExcel_Reader_Abstract implements PHPExcel_Reader_IReader |
{ |
/** |
* Input encoding |
* |
* @var string |
*/ |
private $_inputEncoding = 'ANSI'; |
/** |
* Sheet index to read |
* |
* @var int |
*/ |
private $_sheetIndex = 0; |
/** |
* Formats |
* |
* @var array |
*/ |
private $_formats = array(); |
/** |
* Format Count |
* |
* @var int |
*/ |
private $_format = 0; |
/** |
* Create a new PHPExcel_Reader_SYLK |
*/ |
public function __construct() { |
$this->_readFilter = new PHPExcel_Reader_DefaultReadFilter(); |
} |
/** |
* Validate that the current file is a SYLK file |
* |
* @return boolean |
*/ |
protected function _isValidFormat() |
{ |
// Read sample data (first 2 KB will do) |
$data = fread($this->_fileHandle, 2048); |
// Count delimiters in file |
$delimiterCount = substr_count($data, ';'); |
if ($delimiterCount < 1) { |
return FALSE; |
} |
// Analyze first line looking for ID; signature |
$lines = explode("\n", $data); |
if (substr($lines[0],0,4) != 'ID;P') { |
return FALSE; |
} |
return TRUE; |
} |
/** |
* Set input encoding |
* |
* @param string $pValue Input encoding |
*/ |
public function setInputEncoding($pValue = 'ANSI') |
{ |
$this->_inputEncoding = $pValue; |
return $this; |
} |
/** |
* Get input encoding |
* |
* @return string |
*/ |
public function getInputEncoding() |
{ |
return $this->_inputEncoding; |
} |
/** |
* Return worksheet info (Name, Last Column Letter, Last Column Index, Total Rows, Total Columns) |
* |
* @param string $pFilename |
* @throws PHPExcel_Reader_Exception |
*/ |
public function listWorksheetInfo($pFilename) |
{ |
// Open file |
$this->_openFile($pFilename); |
if (!$this->_isValidFormat()) { |
fclose ($this->_fileHandle); |
throw new PHPExcel_Reader_Exception($pFilename . " is an Invalid Spreadsheet file."); |
} |
$fileHandle = $this->_fileHandle; |
rewind($fileHandle); |
$worksheetInfo = array(); |
$worksheetInfo[0]['worksheetName'] = 'Worksheet'; |
$worksheetInfo[0]['lastColumnLetter'] = 'A'; |
$worksheetInfo[0]['lastColumnIndex'] = 0; |
$worksheetInfo[0]['totalRows'] = 0; |
$worksheetInfo[0]['totalColumns'] = 0; |
// Loop through file |
$rowData = array(); |
// loop through one row (line) at a time in the file |
$rowIndex = 0; |
while (($rowData = fgets($fileHandle)) !== FALSE) { |
$columnIndex = 0; |
// convert SYLK encoded $rowData to UTF-8 |
$rowData = PHPExcel_Shared_String::SYLKtoUTF8($rowData); |
// explode each row at semicolons while taking into account that literal semicolon (;) |
// is escaped like this (;;) |
$rowData = explode("\t",str_replace('¤',';',str_replace(';',"\t",str_replace(';;','¤',rtrim($rowData))))); |
$dataType = array_shift($rowData); |
if ($dataType == 'C') { |
// Read cell value data |
foreach($rowData as $rowDatum) { |
switch($rowDatum{0}) { |
case 'C' : |
case 'X' : |
$columnIndex = substr($rowDatum,1) - 1; |
break; |
case 'R' : |
case 'Y' : |
$rowIndex = substr($rowDatum,1); |
break; |
} |
$worksheetInfo[0]['totalRows'] = max($worksheetInfo[0]['totalRows'], $rowIndex); |
$worksheetInfo[0]['lastColumnIndex'] = max($worksheetInfo[0]['lastColumnIndex'], $columnIndex); |
} |
} |
} |
$worksheetInfo[0]['lastColumnLetter'] = PHPExcel_Cell::stringFromColumnIndex($worksheetInfo[0]['lastColumnIndex']); |
$worksheetInfo[0]['totalColumns'] = $worksheetInfo[0]['lastColumnIndex'] + 1; |
// Close file |
fclose($fileHandle); |
return $worksheetInfo; |
} |
/** |
* Loads PHPExcel from file |
* |
* @param string $pFilename |
* @return PHPExcel |
* @throws PHPExcel_Reader_Exception |
*/ |
public function load($pFilename) |
{ |
// Create new PHPExcel |
$objPHPExcel = new PHPExcel(); |
// Load into this instance |
return $this->loadIntoExisting($pFilename, $objPHPExcel); |
} |
/** |
* Loads PHPExcel from file into PHPExcel instance |
* |
* @param string $pFilename |
* @param PHPExcel $objPHPExcel |
* @return PHPExcel |
* @throws PHPExcel_Reader_Exception |
*/ |
public function loadIntoExisting($pFilename, PHPExcel $objPHPExcel) |
{ |
// Open file |
$this->_openFile($pFilename); |
if (!$this->_isValidFormat()) { |
fclose ($this->_fileHandle); |
throw new PHPExcel_Reader_Exception($pFilename . " is an Invalid Spreadsheet file."); |
} |
$fileHandle = $this->_fileHandle; |
rewind($fileHandle); |
// Create new PHPExcel |
while ($objPHPExcel->getSheetCount() <= $this->_sheetIndex) { |
$objPHPExcel->createSheet(); |
} |
$objPHPExcel->setActiveSheetIndex( $this->_sheetIndex ); |
$fromFormats = array('\-', '\ '); |
$toFormats = array('-', ' '); |
// Loop through file |
$rowData = array(); |
$column = $row = ''; |
// loop through one row (line) at a time in the file |
while (($rowData = fgets($fileHandle)) !== FALSE) { |
// convert SYLK encoded $rowData to UTF-8 |
$rowData = PHPExcel_Shared_String::SYLKtoUTF8($rowData); |
// explode each row at semicolons while taking into account that literal semicolon (;) |
// is escaped like this (;;) |
$rowData = explode("\t",str_replace('¤',';',str_replace(';',"\t",str_replace(';;','¤',rtrim($rowData))))); |
$dataType = array_shift($rowData); |
// Read shared styles |
if ($dataType == 'P') { |
$formatArray = array(); |
foreach($rowData as $rowDatum) { |
switch($rowDatum{0}) { |
case 'P' : $formatArray['numberformat']['code'] = str_replace($fromFormats,$toFormats,substr($rowDatum,1)); |
break; |
case 'E' : |
case 'F' : $formatArray['font']['name'] = substr($rowDatum,1); |
break; |
case 'L' : $formatArray['font']['size'] = substr($rowDatum,1); |
break; |
case 'S' : $styleSettings = substr($rowDatum,1); |
for ($i=0;$i<strlen($styleSettings);++$i) { |
switch ($styleSettings{$i}) { |
case 'I' : $formatArray['font']['italic'] = true; |
break; |
case 'D' : $formatArray['font']['bold'] = true; |
break; |
case 'T' : $formatArray['borders']['top']['style'] = PHPExcel_Style_Border::BORDER_THIN; |
break; |
case 'B' : $formatArray['borders']['bottom']['style'] = PHPExcel_Style_Border::BORDER_THIN; |
break; |
case 'L' : $formatArray['borders']['left']['style'] = PHPExcel_Style_Border::BORDER_THIN; |
break; |
case 'R' : $formatArray['borders']['right']['style'] = PHPExcel_Style_Border::BORDER_THIN; |
break; |
} |
} |
break; |
} |
} |
$this->_formats['P'.$this->_format++] = $formatArray; |
// Read cell value data |
} elseif ($dataType == 'C') { |
$hasCalculatedValue = false; |
$cellData = $cellDataFormula = ''; |
foreach($rowData as $rowDatum) { |
switch($rowDatum{0}) { |
case 'C' : |
case 'X' : $column = substr($rowDatum,1); |
break; |
case 'R' : |
case 'Y' : $row = substr($rowDatum,1); |
break; |
case 'K' : $cellData = substr($rowDatum,1); |
break; |
case 'E' : $cellDataFormula = '='.substr($rowDatum,1); |
// Convert R1C1 style references to A1 style references (but only when not quoted) |
$temp = explode('"',$cellDataFormula); |
$key = false; |
foreach($temp as &$value) { |
// Only count/replace in alternate array entries |
if ($key = !$key) { |
preg_match_all('/(R(\[?-?\d*\]?))(C(\[?-?\d*\]?))/',$value, $cellReferences,PREG_SET_ORDER+PREG_OFFSET_CAPTURE); |
// Reverse the matches array, otherwise all our offsets will become incorrect if we modify our way |
// through the formula from left to right. Reversing means that we work right to left.through |
// the formula |
$cellReferences = array_reverse($cellReferences); |
// Loop through each R1C1 style reference in turn, converting it to its A1 style equivalent, |
// then modify the formula to use that new reference |
foreach($cellReferences as $cellReference) { |
$rowReference = $cellReference[2][0]; |
// Empty R reference is the current row |
if ($rowReference == '') $rowReference = $row; |
// Bracketed R references are relative to the current row |
if ($rowReference{0} == '[') $rowReference = $row + trim($rowReference,'[]'); |
$columnReference = $cellReference[4][0]; |
// Empty C reference is the current column |
if ($columnReference == '') $columnReference = $column; |
// Bracketed C references are relative to the current column |
if ($columnReference{0} == '[') $columnReference = $column + trim($columnReference,'[]'); |
$A1CellReference = PHPExcel_Cell::stringFromColumnIndex($columnReference-1).$rowReference; |
$value = substr_replace($value,$A1CellReference,$cellReference[0][1],strlen($cellReference[0][0])); |
} |
} |
} |
unset($value); |
// Then rebuild the formula string |
$cellDataFormula = implode('"',$temp); |
$hasCalculatedValue = true; |
break; |
} |
} |
$columnLetter = PHPExcel_Cell::stringFromColumnIndex($column-1); |
$cellData = PHPExcel_Calculation::_unwrapResult($cellData); |
// Set cell value |
$objPHPExcel->getActiveSheet()->getCell($columnLetter.$row)->setValue(($hasCalculatedValue) ? $cellDataFormula : $cellData); |
if ($hasCalculatedValue) { |
$cellData = PHPExcel_Calculation::_unwrapResult($cellData); |
$objPHPExcel->getActiveSheet()->getCell($columnLetter.$row)->setCalculatedValue($cellData); |
} |
// Read cell formatting |
} elseif ($dataType == 'F') { |
$formatStyle = $columnWidth = $styleSettings = ''; |
$styleData = array(); |
foreach($rowData as $rowDatum) { |
switch($rowDatum{0}) { |
case 'C' : |
case 'X' : $column = substr($rowDatum,1); |
break; |
case 'R' : |
case 'Y' : $row = substr($rowDatum,1); |
break; |
case 'P' : $formatStyle = $rowDatum; |
break; |
case 'W' : list($startCol,$endCol,$columnWidth) = explode(' ',substr($rowDatum,1)); |
break; |
case 'S' : $styleSettings = substr($rowDatum,1); |
for ($i=0;$i<strlen($styleSettings);++$i) { |
switch ($styleSettings{$i}) { |
case 'I' : $styleData['font']['italic'] = true; |
break; |
case 'D' : $styleData['font']['bold'] = true; |
break; |
case 'T' : $styleData['borders']['top']['style'] = PHPExcel_Style_Border::BORDER_THIN; |
break; |
case 'B' : $styleData['borders']['bottom']['style'] = PHPExcel_Style_Border::BORDER_THIN; |
break; |
case 'L' : $styleData['borders']['left']['style'] = PHPExcel_Style_Border::BORDER_THIN; |
break; |
case 'R' : $styleData['borders']['right']['style'] = PHPExcel_Style_Border::BORDER_THIN; |
break; |
} |
} |
break; |
} |
} |
if (($formatStyle > '') && ($column > '') && ($row > '')) { |
$columnLetter = PHPExcel_Cell::stringFromColumnIndex($column-1); |
if (isset($this->_formats[$formatStyle])) { |
$objPHPExcel->getActiveSheet()->getStyle($columnLetter.$row)->applyFromArray($this->_formats[$formatStyle]); |
} |
} |
if ((!empty($styleData)) && ($column > '') && ($row > '')) { |
$columnLetter = PHPExcel_Cell::stringFromColumnIndex($column-1); |
$objPHPExcel->getActiveSheet()->getStyle($columnLetter.$row)->applyFromArray($styleData); |
} |
if ($columnWidth > '') { |
if ($startCol == $endCol) { |
$startCol = PHPExcel_Cell::stringFromColumnIndex($startCol-1); |
$objPHPExcel->getActiveSheet()->getColumnDimension($startCol)->setWidth($columnWidth); |
} else { |
$startCol = PHPExcel_Cell::stringFromColumnIndex($startCol-1); |
$endCol = PHPExcel_Cell::stringFromColumnIndex($endCol-1); |
$objPHPExcel->getActiveSheet()->getColumnDimension($startCol)->setWidth($columnWidth); |
do { |
$objPHPExcel->getActiveSheet()->getColumnDimension(++$startCol)->setWidth($columnWidth); |
} while ($startCol != $endCol); |
} |
} |
} else { |
foreach($rowData as $rowDatum) { |
switch($rowDatum{0}) { |
case 'C' : |
case 'X' : $column = substr($rowDatum,1); |
break; |
case 'R' : |
case 'Y' : $row = substr($rowDatum,1); |
break; |
} |
} |
} |
} |
// Close file |
fclose($fileHandle); |
// Return |
return $objPHPExcel; |
} |
/** |
* Get sheet index |
* |
* @return int |
*/ |
public function getSheetIndex() { |
return $this->_sheetIndex; |
} |
/** |
* Set sheet index |
* |
* @param int $pValue Sheet index |
* @return PHPExcel_Reader_SYLK |
*/ |
public function setSheetIndex($pValue = 0) { |
$this->_sheetIndex = $pValue; |
return $this; |
} |
} |
/branches/v2.6-greffoir/jrest/lib/PHPExcel/Classes/PHPExcel/Reader/Abstract.php |
---|
New file |
0,0 → 1,227 |
<?php |
/** |
* PHPExcel |
* |
* Copyright (c) 2006 - 2013 PHPExcel |
* |
* This library is free software; you can redistribute it and/or |
* modify it under the terms of the GNU Lesser General Public |
* License as published by the Free Software Foundation; either |
* version 2.1 of the License, or (at your option) any later version. |
* |
* This library is distributed in the hope that it will be useful, |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
* Lesser General Public License for more details. |
* |
* You should have received a copy of the GNU Lesser General Public |
* License along with this library; if not, write to the Free Software |
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
* |
* @category PHPExcel |
* @package PHPExcel_Reader |
* @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL |
* @version ##VERSION##, ##DATE## |
*/ |
/** |
* PHPExcel_Reader_Abstract |
* |
* @category PHPExcel |
* @package PHPExcel_Reader |
* @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
*/ |
abstract class PHPExcel_Reader_Abstract implements PHPExcel_Reader_IReader |
{ |
/** |
* Read data only? |
* Identifies whether the Reader should only read data values for cells, and ignore any formatting information; |
* or whether it should read both data and formatting |
* |
* @var boolean |
*/ |
protected $_readDataOnly = FALSE; |
/** |
* Read charts that are defined in the workbook? |
* Identifies whether the Reader should read the definitions for any charts that exist in the workbook; |
* |
* @var boolean |
*/ |
protected $_includeCharts = FALSE; |
/** |
* Restrict which sheets should be loaded? |
* This property holds an array of worksheet names to be loaded. If null, then all worksheets will be loaded. |
* |
* @var array of string |
*/ |
protected $_loadSheetsOnly = NULL; |
/** |
* PHPExcel_Reader_IReadFilter instance |
* |
* @var PHPExcel_Reader_IReadFilter |
*/ |
protected $_readFilter = NULL; |
protected $_fileHandle = NULL; |
/** |
* Read data only? |
* If this is true, then the Reader will only read data values for cells, it will not read any formatting information. |
* If false (the default) it will read data and formatting. |
* |
* @return boolean |
*/ |
public function getReadDataOnly() { |
return $this->_readDataOnly; |
} |
/** |
* Set read data only |
* Set to true, to advise the Reader only to read data values for cells, and to ignore any formatting information. |
* Set to false (the default) to advise the Reader to read both data and formatting for cells. |
* |
* @param boolean $pValue |
* |
* @return PHPExcel_Reader_IReader |
*/ |
public function setReadDataOnly($pValue = FALSE) { |
$this->_readDataOnly = $pValue; |
return $this; |
} |
/** |
* Read charts in workbook? |
* If this is true, then the Reader will include any charts that exist in the workbook. |
* Note that a ReadDataOnly value of false overrides, and charts won't be read regardless of the IncludeCharts value. |
* If false (the default) it will ignore any charts defined in the workbook file. |
* |
* @return boolean |
*/ |
public function getIncludeCharts() { |
return $this->_includeCharts; |
} |
/** |
* Set read charts in workbook |
* Set to true, to advise the Reader to include any charts that exist in the workbook. |
* Note that a ReadDataOnly value of false overrides, and charts won't be read regardless of the IncludeCharts value. |
* Set to false (the default) to discard charts. |
* |
* @param boolean $pValue |
* |
* @return PHPExcel_Reader_IReader |
*/ |
public function setIncludeCharts($pValue = FALSE) { |
$this->_includeCharts = (boolean) $pValue; |
return $this; |
} |
/** |
* Get which sheets to load |
* Returns either an array of worksheet names (the list of worksheets that should be loaded), or a null |
* indicating that all worksheets in the workbook should be loaded. |
* |
* @return mixed |
*/ |
public function getLoadSheetsOnly() |
{ |
return $this->_loadSheetsOnly; |
} |
/** |
* Set which sheets to load |
* |
* @param mixed $value |
* This should be either an array of worksheet names to be loaded, or a string containing a single worksheet name. |
* If NULL, then it tells the Reader to read all worksheets in the workbook |
* |
* @return PHPExcel_Reader_IReader |
*/ |
public function setLoadSheetsOnly($value = NULL) |
{ |
$this->_loadSheetsOnly = is_array($value) ? |
$value : array($value); |
return $this; |
} |
/** |
* Set all sheets to load |
* Tells the Reader to load all worksheets from the workbook. |
* |
* @return PHPExcel_Reader_IReader |
*/ |
public function setLoadAllSheets() |
{ |
$this->_loadSheetsOnly = NULL; |
return $this; |
} |
/** |
* Read filter |
* |
* @return PHPExcel_Reader_IReadFilter |
*/ |
public function getReadFilter() { |
return $this->_readFilter; |
} |
/** |
* Set read filter |
* |
* @param PHPExcel_Reader_IReadFilter $pValue |
* @return PHPExcel_Reader_IReader |
*/ |
public function setReadFilter(PHPExcel_Reader_IReadFilter $pValue) { |
$this->_readFilter = $pValue; |
return $this; |
} |
/** |
* Open file for reading |
* |
* @param string $pFilename |
* @throws PHPExcel_Reader_Exception |
* @return resource |
*/ |
protected function _openFile($pFilename) |
{ |
// Check if file exists |
if (!file_exists($pFilename) || !is_readable($pFilename)) { |
throw new PHPExcel_Reader_Exception("Could not open " . $pFilename . " for reading! File does not exist."); |
} |
// Open file |
$this->_fileHandle = fopen($pFilename, 'r'); |
if ($this->_fileHandle === FALSE) { |
throw new PHPExcel_Reader_Exception("Could not open file " . $pFilename . " for reading."); |
} |
} |
/** |
* Can the current PHPExcel_Reader_IReader read the file? |
* |
* @param string $pFilename |
* @return boolean |
* @throws PHPExcel_Reader_Exception |
*/ |
public function canRead($pFilename) |
{ |
// Check if file exists |
try { |
$this->_openFile($pFilename); |
} catch (Exception $e) { |
return FALSE; |
} |
$readable = $this->_isValidFormat(); |
fclose ($this->_fileHandle); |
return $readable; |
} |
} |
/branches/v2.6-greffoir/jrest/lib/PHPExcel/Classes/PHPExcel/Reader/Excel2007/Chart.php |
---|
New file |
0,0 → 1,517 |
<?php |
/** |
* PHPExcel |
* |
* Copyright (c) 2006 - 2013 PHPExcel |
* |
* This library is free software; you can redistribute it and/or |
* modify it under the terms of the GNU Lesser General Public |
* License as published by the Free Software Foundation; either |
* version 2.1 of the License, or (at your option) any later version. |
* |
* This library is distributed in the hope that it will be useful, |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
* Lesser General Public License for more details. |
* |
* You should have received a copy of the GNU Lesser General Public |
* License along with this library; if not, write to the Free Software |
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
* |
* @category PHPExcel |
* @package PHPExcel_Reader_Excel2007 |
* @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL |
* @version ##VERSION##, ##DATE## |
*/ |
/** |
* PHPExcel_Reader_Excel2007_Chart |
* |
* @category PHPExcel |
* @package PHPExcel_Reader_Excel2007 |
* @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
*/ |
class PHPExcel_Reader_Excel2007_Chart |
{ |
private static function _getAttribute($component, $name, $format) { |
$attributes = $component->attributes(); |
if (isset($attributes[$name])) { |
if ($format == 'string') { |
return (string) $attributes[$name]; |
} elseif ($format == 'integer') { |
return (integer) $attributes[$name]; |
} elseif ($format == 'boolean') { |
return (boolean) ($attributes[$name] === '0' || $attributes[$name] !== 'true') ? false : true; |
} else { |
return (float) $attributes[$name]; |
} |
} |
return null; |
} // function _getAttribute() |
private static function _readColor($color,$background=false) { |
if (isset($color["rgb"])) { |
return (string)$color["rgb"]; |
} else if (isset($color["indexed"])) { |
return PHPExcel_Style_Color::indexedColor($color["indexed"]-7,$background)->getARGB(); |
} |
} |
public static function readChart($chartElements,$chartName) { |
$namespacesChartMeta = $chartElements->getNamespaces(true); |
$chartElementsC = $chartElements->children($namespacesChartMeta['c']); |
$XaxisLabel = $YaxisLabel = $legend = $title = NULL; |
$dispBlanksAs = $plotVisOnly = NULL; |
foreach($chartElementsC as $chartElementKey => $chartElement) { |
switch ($chartElementKey) { |
case "chart": |
foreach($chartElement as $chartDetailsKey => $chartDetails) { |
$chartDetailsC = $chartDetails->children($namespacesChartMeta['c']); |
switch ($chartDetailsKey) { |
case "plotArea": |
$plotAreaLayout = $XaxisLable = $YaxisLable = null; |
$plotSeries = $plotAttributes = array(); |
foreach($chartDetails as $chartDetailKey => $chartDetail) { |
switch ($chartDetailKey) { |
case "layout": |
$plotAreaLayout = self::_chartLayoutDetails($chartDetail,$namespacesChartMeta,'plotArea'); |
break; |
case "catAx": |
if (isset($chartDetail->title)) { |
$XaxisLabel = self::_chartTitle($chartDetail->title->children($namespacesChartMeta['c']),$namespacesChartMeta,'cat'); |
} |
break; |
case "dateAx": |
if (isset($chartDetail->title)) { |
$XaxisLabel = self::_chartTitle($chartDetail->title->children($namespacesChartMeta['c']),$namespacesChartMeta,'cat'); |
} |
break; |
case "valAx": |
if (isset($chartDetail->title)) { |
$YaxisLabel = self::_chartTitle($chartDetail->title->children($namespacesChartMeta['c']),$namespacesChartMeta,'cat'); |
} |
break; |
case "barChart": |
case "bar3DChart": |
$barDirection = self::_getAttribute($chartDetail->barDir, 'val', 'string'); |
$plotSer = self::_chartDataSeries($chartDetail,$namespacesChartMeta,$chartDetailKey); |
$plotSer->setPlotDirection($barDirection); |
$plotSeries[] = $plotSer; |
$plotAttributes = self::_readChartAttributes($chartDetail); |
break; |
case "lineChart": |
case "line3DChart": |
$plotSeries[] = self::_chartDataSeries($chartDetail,$namespacesChartMeta,$chartDetailKey); |
$plotAttributes = self::_readChartAttributes($chartDetail); |
break; |
case "areaChart": |
case "area3DChart": |
$plotSeries[] = self::_chartDataSeries($chartDetail,$namespacesChartMeta,$chartDetailKey); |
$plotAttributes = self::_readChartAttributes($chartDetail); |
break; |
case "doughnutChart": |
case "pieChart": |
case "pie3DChart": |
$explosion = isset($chartDetail->ser->explosion); |
$plotSer = self::_chartDataSeries($chartDetail,$namespacesChartMeta,$chartDetailKey); |
$plotSer->setPlotStyle($explosion); |
$plotSeries[] = $plotSer; |
$plotAttributes = self::_readChartAttributes($chartDetail); |
break; |
case "scatterChart": |
$scatterStyle = self::_getAttribute($chartDetail->scatterStyle, 'val', 'string'); |
$plotSer = self::_chartDataSeries($chartDetail,$namespacesChartMeta,$chartDetailKey); |
$plotSer->setPlotStyle($scatterStyle); |
$plotSeries[] = $plotSer; |
$plotAttributes = self::_readChartAttributes($chartDetail); |
break; |
case "bubbleChart": |
$bubbleScale = self::_getAttribute($chartDetail->bubbleScale, 'val', 'integer'); |
$plotSer = self::_chartDataSeries($chartDetail,$namespacesChartMeta,$chartDetailKey); |
$plotSer->setPlotStyle($bubbleScale); |
$plotSeries[] = $plotSer; |
$plotAttributes = self::_readChartAttributes($chartDetail); |
break; |
case "radarChart": |
$radarStyle = self::_getAttribute($chartDetail->radarStyle, 'val', 'string'); |
$plotSer = self::_chartDataSeries($chartDetail,$namespacesChartMeta,$chartDetailKey); |
$plotSer->setPlotStyle($radarStyle); |
$plotSeries[] = $plotSer; |
$plotAttributes = self::_readChartAttributes($chartDetail); |
break; |
case "surfaceChart": |
case "surface3DChart": |
$wireFrame = self::_getAttribute($chartDetail->wireframe, 'val', 'boolean'); |
$plotSer = self::_chartDataSeries($chartDetail,$namespacesChartMeta,$chartDetailKey); |
$plotSer->setPlotStyle($wireFrame); |
$plotSeries[] = $plotSer; |
$plotAttributes = self::_readChartAttributes($chartDetail); |
break; |
case "stockChart": |
$plotSeries[] = self::_chartDataSeries($chartDetail,$namespacesChartMeta,$chartDetailKey); |
$plotAttributes = self::_readChartAttributes($plotAreaLayout); |
break; |
} |
} |
if ($plotAreaLayout == NULL) { |
$plotAreaLayout = new PHPExcel_Chart_Layout(); |
} |
$plotArea = new PHPExcel_Chart_PlotArea($plotAreaLayout,$plotSeries); |
self::_setChartAttributes($plotAreaLayout,$plotAttributes); |
break; |
case "plotVisOnly": |
$plotVisOnly = self::_getAttribute($chartDetails, 'val', 'string'); |
break; |
case "dispBlanksAs": |
$dispBlanksAs = self::_getAttribute($chartDetails, 'val', 'string'); |
break; |
case "title": |
$title = self::_chartTitle($chartDetails,$namespacesChartMeta,'title'); |
break; |
case "legend": |
$legendPos = 'r'; |
$legendLayout = null; |
$legendOverlay = false; |
foreach($chartDetails as $chartDetailKey => $chartDetail) { |
switch ($chartDetailKey) { |
case "legendPos": |
$legendPos = self::_getAttribute($chartDetail, 'val', 'string'); |
break; |
case "overlay": |
$legendOverlay = self::_getAttribute($chartDetail, 'val', 'boolean'); |
break; |
case "layout": |
$legendLayout = self::_chartLayoutDetails($chartDetail,$namespacesChartMeta,'legend'); |
break; |
} |
} |
$legend = new PHPExcel_Chart_Legend($legendPos, $legendLayout, $legendOverlay); |
break; |
} |
} |
} |
} |
$chart = new PHPExcel_Chart($chartName,$title,$legend,$plotArea,$plotVisOnly,$dispBlanksAs,$XaxisLabel,$YaxisLabel); |
return $chart; |
} // function readChart() |
private static function _chartTitle($titleDetails,$namespacesChartMeta,$type) { |
$caption = array(); |
$titleLayout = null; |
foreach($titleDetails as $titleDetailKey => $chartDetail) { |
switch ($titleDetailKey) { |
case "tx": |
$titleDetails = $chartDetail->rich->children($namespacesChartMeta['a']); |
foreach($titleDetails as $titleKey => $titleDetail) { |
switch ($titleKey) { |
case "p": |
$titleDetailPart = $titleDetail->children($namespacesChartMeta['a']); |
$caption[] = self::_parseRichText($titleDetailPart); |
} |
} |
break; |
case "layout": |
$titleLayout = self::_chartLayoutDetails($chartDetail,$namespacesChartMeta); |
break; |
} |
} |
return new PHPExcel_Chart_Title($caption, $titleLayout); |
} // function _chartTitle() |
private static function _chartLayoutDetails($chartDetail,$namespacesChartMeta) { |
if (!isset($chartDetail->manualLayout)) { |
return null; |
} |
$details = $chartDetail->manualLayout->children($namespacesChartMeta['c']); |
if (is_null($details)) { |
return null; |
} |
$layout = array(); |
foreach($details as $detailKey => $detail) { |
// echo $detailKey,' => ',self::_getAttribute($detail, 'val', 'string'),PHP_EOL; |
$layout[$detailKey] = self::_getAttribute($detail, 'val', 'string'); |
} |
return new PHPExcel_Chart_Layout($layout); |
} // function _chartLayoutDetails() |
private static function _chartDataSeries($chartDetail,$namespacesChartMeta,$plotType) { |
$multiSeriesType = NULL; |
$smoothLine = false; |
$seriesLabel = $seriesCategory = $seriesValues = $plotOrder = array(); |
$seriesDetailSet = $chartDetail->children($namespacesChartMeta['c']); |
foreach($seriesDetailSet as $seriesDetailKey => $seriesDetails) { |
switch ($seriesDetailKey) { |
case "grouping": |
$multiSeriesType = self::_getAttribute($chartDetail->grouping, 'val', 'string'); |
break; |
case "ser": |
$marker = NULL; |
foreach($seriesDetails as $seriesKey => $seriesDetail) { |
switch ($seriesKey) { |
case "idx": |
$seriesIndex = self::_getAttribute($seriesDetail, 'val', 'integer'); |
break; |
case "order": |
$seriesOrder = self::_getAttribute($seriesDetail, 'val', 'integer'); |
$plotOrder[$seriesIndex] = $seriesOrder; |
break; |
case "tx": |
$seriesLabel[$seriesIndex] = self::_chartDataSeriesValueSet($seriesDetail,$namespacesChartMeta); |
break; |
case "marker": |
$marker = self::_getAttribute($seriesDetail->symbol, 'val', 'string'); |
break; |
case "smooth": |
$smoothLine = self::_getAttribute($seriesDetail, 'val', 'boolean'); |
break; |
case "cat": |
$seriesCategory[$seriesIndex] = self::_chartDataSeriesValueSet($seriesDetail,$namespacesChartMeta); |
break; |
case "val": |
$seriesValues[$seriesIndex] = self::_chartDataSeriesValueSet($seriesDetail,$namespacesChartMeta,$marker); |
break; |
case "xVal": |
$seriesCategory[$seriesIndex] = self::_chartDataSeriesValueSet($seriesDetail,$namespacesChartMeta,$marker); |
break; |
case "yVal": |
$seriesValues[$seriesIndex] = self::_chartDataSeriesValueSet($seriesDetail,$namespacesChartMeta,$marker); |
break; |
} |
} |
} |
} |
return new PHPExcel_Chart_DataSeries($plotType,$multiSeriesType,$plotOrder,$seriesLabel,$seriesCategory,$seriesValues,$smoothLine); |
} // function _chartDataSeries() |
private static function _chartDataSeriesValueSet($seriesDetail, $namespacesChartMeta, $marker = null, $smoothLine = false) { |
if (isset($seriesDetail->strRef)) { |
$seriesSource = (string) $seriesDetail->strRef->f; |
$seriesData = self::_chartDataSeriesValues($seriesDetail->strRef->strCache->children($namespacesChartMeta['c']),'s'); |
return new PHPExcel_Chart_DataSeriesValues('String',$seriesSource,$seriesData['formatCode'],$seriesData['pointCount'],$seriesData['dataValues'],$marker,$smoothLine); |
} elseif (isset($seriesDetail->numRef)) { |
$seriesSource = (string) $seriesDetail->numRef->f; |
$seriesData = self::_chartDataSeriesValues($seriesDetail->numRef->numCache->children($namespacesChartMeta['c'])); |
return new PHPExcel_Chart_DataSeriesValues('Number',$seriesSource,$seriesData['formatCode'],$seriesData['pointCount'],$seriesData['dataValues'],$marker,$smoothLine); |
} elseif (isset($seriesDetail->multiLvlStrRef)) { |
$seriesSource = (string) $seriesDetail->multiLvlStrRef->f; |
$seriesData = self::_chartDataSeriesValuesMultiLevel($seriesDetail->multiLvlStrRef->multiLvlStrCache->children($namespacesChartMeta['c']),'s'); |
$seriesData['pointCount'] = count($seriesData['dataValues']); |
return new PHPExcel_Chart_DataSeriesValues('String',$seriesSource,$seriesData['formatCode'],$seriesData['pointCount'],$seriesData['dataValues'],$marker,$smoothLine); |
} elseif (isset($seriesDetail->multiLvlNumRef)) { |
$seriesSource = (string) $seriesDetail->multiLvlNumRef->f; |
$seriesData = self::_chartDataSeriesValuesMultiLevel($seriesDetail->multiLvlNumRef->multiLvlNumCache->children($namespacesChartMeta['c']),'s'); |
$seriesData['pointCount'] = count($seriesData['dataValues']); |
return new PHPExcel_Chart_DataSeriesValues('String',$seriesSource,$seriesData['formatCode'],$seriesData['pointCount'],$seriesData['dataValues'],$marker,$smoothLine); |
} |
return null; |
} // function _chartDataSeriesValueSet() |
private static function _chartDataSeriesValues($seriesValueSet,$dataType='n') { |
$seriesVal = array(); |
$formatCode = ''; |
$pointCount = 0; |
foreach($seriesValueSet as $seriesValueIdx => $seriesValue) { |
switch ($seriesValueIdx) { |
case 'ptCount': |
$pointCount = self::_getAttribute($seriesValue, 'val', 'integer'); |
break; |
case 'formatCode': |
$formatCode = (string) $seriesValue; |
break; |
case 'pt': |
$pointVal = self::_getAttribute($seriesValue, 'idx', 'integer'); |
if ($dataType == 's') { |
$seriesVal[$pointVal] = (string) $seriesValue->v; |
} else { |
$seriesVal[$pointVal] = (float) $seriesValue->v; |
} |
break; |
} |
} |
if (empty($seriesVal)) { |
$seriesVal = NULL; |
} |
return array( 'formatCode' => $formatCode, |
'pointCount' => $pointCount, |
'dataValues' => $seriesVal |
); |
} // function _chartDataSeriesValues() |
private static function _chartDataSeriesValuesMultiLevel($seriesValueSet,$dataType='n') { |
$seriesVal = array(); |
$formatCode = ''; |
$pointCount = 0; |
foreach($seriesValueSet->lvl as $seriesLevelIdx => $seriesLevel) { |
foreach($seriesLevel as $seriesValueIdx => $seriesValue) { |
switch ($seriesValueIdx) { |
case 'ptCount': |
$pointCount = self::_getAttribute($seriesValue, 'val', 'integer'); |
break; |
case 'formatCode': |
$formatCode = (string) $seriesValue; |
break; |
case 'pt': |
$pointVal = self::_getAttribute($seriesValue, 'idx', 'integer'); |
if ($dataType == 's') { |
$seriesVal[$pointVal][] = (string) $seriesValue->v; |
} else { |
$seriesVal[$pointVal][] = (float) $seriesValue->v; |
} |
break; |
} |
} |
} |
return array( 'formatCode' => $formatCode, |
'pointCount' => $pointCount, |
'dataValues' => $seriesVal |
); |
} // function _chartDataSeriesValuesMultiLevel() |
private static function _parseRichText($titleDetailPart = null) { |
$value = new PHPExcel_RichText(); |
foreach($titleDetailPart as $titleDetailElementKey => $titleDetailElement) { |
if (isset($titleDetailElement->t)) { |
$objText = $value->createTextRun( (string) $titleDetailElement->t ); |
} |
if (isset($titleDetailElement->rPr)) { |
if (isset($titleDetailElement->rPr->rFont["val"])) { |
$objText->getFont()->setName((string) $titleDetailElement->rPr->rFont["val"]); |
} |
$fontSize = (self::_getAttribute($titleDetailElement->rPr, 'sz', 'integer')); |
if (!is_null($fontSize)) { |
$objText->getFont()->setSize(floor($fontSize / 100)); |
} |
$fontColor = (self::_getAttribute($titleDetailElement->rPr, 'color', 'string')); |
if (!is_null($fontColor)) { |
$objText->getFont()->setColor( new PHPExcel_Style_Color( self::_readColor($fontColor) ) ); |
} |
$bold = self::_getAttribute($titleDetailElement->rPr, 'b', 'boolean'); |
if (!is_null($bold)) { |
$objText->getFont()->setBold($bold); |
} |
$italic = self::_getAttribute($titleDetailElement->rPr, 'i', 'boolean'); |
if (!is_null($italic)) { |
$objText->getFont()->setItalic($italic); |
} |
$baseline = self::_getAttribute($titleDetailElement->rPr, 'baseline', 'integer'); |
if (!is_null($baseline)) { |
if ($baseline > 0) { |
$objText->getFont()->setSuperScript(true); |
} elseif($baseline < 0) { |
$objText->getFont()->setSubScript(true); |
} |
} |
$underscore = (self::_getAttribute($titleDetailElement->rPr, 'u', 'string')); |
if (!is_null($underscore)) { |
if ($underscore == 'sng') { |
$objText->getFont()->setUnderline(PHPExcel_Style_Font::UNDERLINE_SINGLE); |
} elseif($underscore == 'dbl') { |
$objText->getFont()->setUnderline(PHPExcel_Style_Font::UNDERLINE_DOUBLE); |
} else { |
$objText->getFont()->setUnderline(PHPExcel_Style_Font::UNDERLINE_NONE); |
} |
} |
$strikethrough = (self::_getAttribute($titleDetailElement->rPr, 's', 'string')); |
if (!is_null($strikethrough)) { |
if ($strikethrough == 'noStrike') { |
$objText->getFont()->setStrikethrough(false); |
} else { |
$objText->getFont()->setStrikethrough(true); |
} |
} |
} |
} |
return $value; |
} |
private static function _readChartAttributes($chartDetail) { |
$plotAttributes = array(); |
if (isset($chartDetail->dLbls)) { |
if (isset($chartDetail->dLbls->howLegendKey)) { |
$plotAttributes['showLegendKey'] = self::_getAttribute($chartDetail->dLbls->showLegendKey, 'val', 'string'); |
} |
if (isset($chartDetail->dLbls->showVal)) { |
$plotAttributes['showVal'] = self::_getAttribute($chartDetail->dLbls->showVal, 'val', 'string'); |
} |
if (isset($chartDetail->dLbls->showCatName)) { |
$plotAttributes['showCatName'] = self::_getAttribute($chartDetail->dLbls->showCatName, 'val', 'string'); |
} |
if (isset($chartDetail->dLbls->showSerName)) { |
$plotAttributes['showSerName'] = self::_getAttribute($chartDetail->dLbls->showSerName, 'val', 'string'); |
} |
if (isset($chartDetail->dLbls->showPercent)) { |
$plotAttributes['showPercent'] = self::_getAttribute($chartDetail->dLbls->showPercent, 'val', 'string'); |
} |
if (isset($chartDetail->dLbls->showBubbleSize)) { |
$plotAttributes['showBubbleSize'] = self::_getAttribute($chartDetail->dLbls->showBubbleSize, 'val', 'string'); |
} |
if (isset($chartDetail->dLbls->showLeaderLines)) { |
$plotAttributes['showLeaderLines'] = self::_getAttribute($chartDetail->dLbls->showLeaderLines, 'val', 'string'); |
} |
} |
return $plotAttributes; |
} |
private static function _setChartAttributes($plotArea,$plotAttributes) |
{ |
foreach($plotAttributes as $plotAttributeKey => $plotAttributeValue) { |
switch($plotAttributeKey) { |
case 'showLegendKey' : |
$plotArea->setShowLegendKey($plotAttributeValue); |
break; |
case 'showVal' : |
$plotArea->setShowVal($plotAttributeValue); |
break; |
case 'showCatName' : |
$plotArea->setShowCatName($plotAttributeValue); |
break; |
case 'showSerName' : |
$plotArea->setShowSerName($plotAttributeValue); |
break; |
case 'showPercent' : |
$plotArea->setShowPercent($plotAttributeValue); |
break; |
case 'showBubbleSize' : |
$plotArea->setShowBubbleSize($plotAttributeValue); |
break; |
case 'showLeaderLines' : |
$plotArea->setShowLeaderLines($plotAttributeValue); |
break; |
} |
} |
} |
} |
/branches/v2.6-greffoir/jrest/lib/PHPExcel/Classes/PHPExcel/Reader/Excel2007/Theme.php |
---|
New file |
0,0 → 1,124 |
<?php |
/** |
* PHPExcel |
* |
* Copyright (c) 2006 - 2013 PHPExcel |
* |
* This library is free software; you can redistribute it and/or |
* modify it under the terms of the GNU Lesser General Public |
* License as published by the Free Software Foundation; either |
* version 2.1 of the License, or (at your option) any later version. |
* |
* This library is distributed in the hope that it will be useful, |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
* Lesser General Public License for more details. |
* |
* You should have received a copy of the GNU Lesser General Public |
* License along with this library; if not, write to the Free Software |
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
* |
* @category PHPExcel |
* @package PHPExcel_Reader_Excel2007 |
* @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL |
* @version ##VERSION##, ##DATE## |
*/ |
/** |
* PHPExcel_Reader_Excel2007_Theme |
* |
* @category PHPExcel |
* @package PHPExcel_Reader_Excel2007 |
* @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
*/ |
class PHPExcel_Reader_Excel2007_Theme |
{ |
/** |
* Theme Name |
* |
* @var string |
*/ |
private $_themeName; |
/** |
* Colour Scheme Name |
* |
* @var string |
*/ |
private $_colourSchemeName; |
/** |
* Colour Map indexed by position |
* |
* @var array of string |
*/ |
private $_colourMapValues; |
/** |
* Colour Map |
* |
* @var array of string |
*/ |
private $_colourMap; |
/** |
* Create a new PHPExcel_Theme |
* |
*/ |
public function __construct($themeName,$colourSchemeName,$colourMap) |
{ |
// Initialise values |
$this->_themeName = $themeName; |
$this->_colourSchemeName = $colourSchemeName; |
$this->_colourMap = $colourMap; |
} |
/** |
* Get Theme Name |
* |
* @return string |
*/ |
public function getThemeName() |
{ |
return $this->_themeName; |
} |
/** |
* Get colour Scheme Name |
* |
* @return string |
*/ |
public function getColourSchemeName() { |
return $this->_colourSchemeName; |
} |
/** |
* Get colour Map Value by Position |
* |
* @return string |
*/ |
public function getColourByIndex($index=0) { |
if (isset($this->_colourMap[$index])) { |
return $this->_colourMap[$index]; |
} |
return null; |
} |
/** |
* Implement PHP __clone to create a deep clone, not just a shallow copy. |
*/ |
public function __clone() { |
$vars = get_object_vars($this); |
foreach ($vars as $key => $value) { |
if ((is_object($value)) && ($key != '_parent')) { |
$this->$key = clone $value; |
} else { |
$this->$key = $value; |
} |
} |
} |
} |
/branches/v2.6-greffoir/jrest/lib/PHPExcel/Classes/PHPExcel/Reader/HTML.php |
---|
New file |
0,0 → 1,468 |
<?php |
/** |
* PHPExcel |
* |
* Copyright (c) 2006 - 2013 PHPExcel |
* |
* This library is free software; you can redistribute it and/or |
* modify it under the terms of the GNU Lesser General Public |
* License as published by the Free Software Foundation; either |
* version 2.1 of the License, or (at your option) any later version. |
* |
* This library is distributed in the hope that it will be useful, |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
* Lesser General Public License for more details. |
* |
* You should have received a copy of the GNU Lesser General Public |
* License along with this library; if not, write to the Free Software |
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
* |
* @category PHPExcel |
* @package PHPExcel_Reader |
* @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL |
* @version ##VERSION##, ##DATE## |
*/ |
/** PHPExcel root directory */ |
if (!defined('PHPEXCEL_ROOT')) { |
/** |
* @ignore |
*/ |
define('PHPEXCEL_ROOT', dirname(__FILE__) . '/../../'); |
require(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php'); |
} |
/** |
* PHPExcel_Reader_HTML |
* |
* @category PHPExcel |
* @package PHPExcel_Reader |
* @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
*/ |
class PHPExcel_Reader_HTML extends PHPExcel_Reader_Abstract implements PHPExcel_Reader_IReader |
{ |
/** |
* Input encoding |
* |
* @var string |
*/ |
private $_inputEncoding = 'ANSI'; |
/** |
* Sheet index to read |
* |
* @var int |
*/ |
private $_sheetIndex = 0; |
/** |
* Formats |
* |
* @var array |
*/ |
private $_formats = array( 'h1' => array( 'font' => array( 'bold' => true, |
'size' => 24, |
), |
), // Bold, 24pt |
'h2' => array( 'font' => array( 'bold' => true, |
'size' => 18, |
), |
), // Bold, 18pt |
'h3' => array( 'font' => array( 'bold' => true, |
'size' => 13.5, |
), |
), // Bold, 13.5pt |
'h4' => array( 'font' => array( 'bold' => true, |
'size' => 12, |
), |
), // Bold, 12pt |
'h5' => array( 'font' => array( 'bold' => true, |
'size' => 10, |
), |
), // Bold, 10pt |
'h6' => array( 'font' => array( 'bold' => true, |
'size' => 7.5, |
), |
), // Bold, 7.5pt |
'a' => array( 'font' => array( 'underline' => true, |
'color' => array( 'argb' => PHPExcel_Style_Color::COLOR_BLUE, |
), |
), |
), // Blue underlined |
'hr' => array( 'borders' => array( 'bottom' => array( 'style' => PHPExcel_Style_Border::BORDER_THIN, |
'color' => array( PHPExcel_Style_Color::COLOR_BLACK, |
), |
), |
), |
), // Bottom border |
); |
/** |
* Create a new PHPExcel_Reader_HTML |
*/ |
public function __construct() { |
$this->_readFilter = new PHPExcel_Reader_DefaultReadFilter(); |
} |
/** |
* Validate that the current file is an HTML file |
* |
* @return boolean |
*/ |
protected function _isValidFormat() |
{ |
// Reading 2048 bytes should be enough to validate that the format is HTML |
$data = fread($this->_fileHandle, 2048); |
if ((strpos('<',$data) !== FALSE) && |
(strlen($data) !== strlen(strip_tags($data)))) { |
return TRUE; |
} |
return FALSE; |
} |
/** |
* Loads PHPExcel from file |
* |
* @param string $pFilename |
* @return PHPExcel |
* @throws PHPExcel_Reader_Exception |
*/ |
public function load($pFilename) |
{ |
// Create new PHPExcel |
$objPHPExcel = new PHPExcel(); |
// Load into this instance |
return $this->loadIntoExisting($pFilename, $objPHPExcel); |
} |
/** |
* Set input encoding |
* |
* @param string $pValue Input encoding |
*/ |
public function setInputEncoding($pValue = 'ANSI') |
{ |
$this->_inputEncoding = $pValue; |
return $this; |
} |
/** |
* Get input encoding |
* |
* @return string |
*/ |
public function getInputEncoding() |
{ |
return $this->_inputEncoding; |
} |
// Data Array used for testing only, should write to PHPExcel object on completion of tests |
private $_dataArray = array(); |
private $_tableLevel = 0; |
private $_nestedColumn = array('A'); |
private function _setTableStartColumn($column) { |
if ($this->_tableLevel == 0) |
$column = 'A'; |
++$this->_tableLevel; |
$this->_nestedColumn[$this->_tableLevel] = $column; |
return $this->_nestedColumn[$this->_tableLevel]; |
} |
private function _getTableStartColumn() { |
return $this->_nestedColumn[$this->_tableLevel]; |
} |
private function _releaseTableStartColumn() { |
--$this->_tableLevel; |
return array_pop($this->_nestedColumn); |
} |
private function _flushCell($sheet,$column,$row,&$cellContent) { |
if (is_string($cellContent)) { |
// Simple String content |
if (trim($cellContent) > '') { |
// Only actually write it if there's content in the string |
// echo 'FLUSH CELL: ' , $column , $row , ' => ' , $cellContent , '<br />'; |
// Write to worksheet to be done here... |
// ... we return the cell so we can mess about with styles more easily |
$cell = $sheet->setCellValue($column.$row,$cellContent,true); |
$this->_dataArray[$row][$column] = $cellContent; |
} |
} else { |
// We have a Rich Text run |
// TODO |
$this->_dataArray[$row][$column] = 'RICH TEXT: ' . $cellContent; |
} |
$cellContent = (string) ''; |
} |
private function _processDomElement(DOMNode $element, $sheet, &$row, &$column, &$cellContent){ |
foreach($element->childNodes as $child){ |
if ($child instanceof DOMText) { |
$domText = preg_replace('/\s+/',' ',trim($child->nodeValue)); |
if (is_string($cellContent)) { |
// simply append the text if the cell content is a plain text string |
$cellContent .= $domText; |
} else { |
// but if we have a rich text run instead, we need to append it correctly |
// TODO |
} |
} elseif($child instanceof DOMElement) { |
// echo '<b>DOM ELEMENT: </b>' , strtoupper($child->nodeName) , '<br />'; |
$attributeArray = array(); |
foreach($child->attributes as $attribute) { |
// echo '<b>ATTRIBUTE: </b>' , $attribute->name , ' => ' , $attribute->value , '<br />'; |
$attributeArray[$attribute->name] = $attribute->value; |
} |
switch($child->nodeName) { |
case 'meta' : |
foreach($attributeArray as $attributeName => $attributeValue) { |
switch($attributeName) { |
case 'content': |
// TODO |
// Extract character set, so we can convert to UTF-8 if required |
break; |
} |
} |
$this->_processDomElement($child,$sheet,$row,$column,$cellContent); |
break; |
case 'title' : |
$this->_processDomElement($child,$sheet,$row,$column,$cellContent); |
$sheet->setTitle($cellContent); |
$cellContent = ''; |
break; |
case 'span' : |
case 'div' : |
case 'font' : |
case 'i' : |
case 'em' : |
case 'strong': |
case 'b' : |
// echo 'STYLING, SPAN OR DIV<br />'; |
if ($cellContent > '') |
$cellContent .= ' '; |
$this->_processDomElement($child,$sheet,$row,$column,$cellContent); |
if ($cellContent > '') |
$cellContent .= ' '; |
// echo 'END OF STYLING, SPAN OR DIV<br />'; |
break; |
case 'hr' : |
$this->_flushCell($sheet,$column,$row,$cellContent); |
++$row; |
if (isset($this->_formats[$child->nodeName])) { |
$sheet->getStyle($column.$row)->applyFromArray($this->_formats[$child->nodeName]); |
} else { |
$cellContent = '----------'; |
$this->_flushCell($sheet,$column,$row,$cellContent); |
} |
++$row; |
case 'br' : |
if ($this->_tableLevel > 0) { |
// If we're inside a table, replace with a \n |
$cellContent .= "\n"; |
} else { |
// Otherwise flush our existing content and move the row cursor on |
$this->_flushCell($sheet,$column,$row,$cellContent); |
++$row; |
} |
// echo 'HARD LINE BREAK: ' , '<br />'; |
break; |
case 'a' : |
// echo 'START OF HYPERLINK: ' , '<br />'; |
foreach($attributeArray as $attributeName => $attributeValue) { |
switch($attributeName) { |
case 'href': |
// echo 'Link to ' , $attributeValue , '<br />'; |
$sheet->getCell($column.$row)->getHyperlink()->setUrl($attributeValue); |
if (isset($this->_formats[$child->nodeName])) { |
$sheet->getStyle($column.$row)->applyFromArray($this->_formats[$child->nodeName]); |
} |
break; |
} |
} |
$cellContent .= ' '; |
$this->_processDomElement($child,$sheet,$row,$column,$cellContent); |
// echo 'END OF HYPERLINK:' , '<br />'; |
break; |
case 'h1' : |
case 'h2' : |
case 'h3' : |
case 'h4' : |
case 'h5' : |
case 'h6' : |
case 'ol' : |
case 'ul' : |
case 'p' : |
if ($this->_tableLevel > 0) { |
// If we're inside a table, replace with a \n |
$cellContent .= "\n"; |
// echo 'LIST ENTRY: ' , '<br />'; |
$this->_processDomElement($child,$sheet,$row,$column,$cellContent); |
// echo 'END OF LIST ENTRY:' , '<br />'; |
} else { |
if ($cellContent > '') { |
$this->_flushCell($sheet,$column,$row,$cellContent); |
$row += 2; |
} |
// echo 'START OF PARAGRAPH: ' , '<br />'; |
$this->_processDomElement($child,$sheet,$row,$column,$cellContent); |
// echo 'END OF PARAGRAPH:' , '<br />'; |
$this->_flushCell($sheet,$column,$row,$cellContent); |
if (isset($this->_formats[$child->nodeName])) { |
$sheet->getStyle($column.$row)->applyFromArray($this->_formats[$child->nodeName]); |
} |
$row += 2; |
$column = 'A'; |
} |
break; |
case 'li' : |
if ($this->_tableLevel > 0) { |
// If we're inside a table, replace with a \n |
$cellContent .= "\n"; |
// echo 'LIST ENTRY: ' , '<br />'; |
$this->_processDomElement($child,$sheet,$row,$column,$cellContent); |
// echo 'END OF LIST ENTRY:' , '<br />'; |
} else { |
if ($cellContent > '') { |
$this->_flushCell($sheet,$column,$row,$cellContent); |
} |
++$row; |
// echo 'LIST ENTRY: ' , '<br />'; |
$this->_processDomElement($child,$sheet,$row,$column,$cellContent); |
// echo 'END OF LIST ENTRY:' , '<br />'; |
$this->_flushCell($sheet,$column,$row,$cellContent); |
$column = 'A'; |
} |
break; |
case 'table' : |
$this->_flushCell($sheet,$column,$row,$cellContent); |
$column = $this->_setTableStartColumn($column); |
// echo 'START OF TABLE LEVEL ' , $this->_tableLevel , '<br />'; |
if ($this->_tableLevel > 1) |
--$row; |
$this->_processDomElement($child,$sheet,$row,$column,$cellContent); |
// echo 'END OF TABLE LEVEL ' , $this->_tableLevel , '<br />'; |
$column = $this->_releaseTableStartColumn(); |
if ($this->_tableLevel > 1) { |
++$column; |
} else { |
++$row; |
} |
break; |
case 'thead' : |
case 'tbody' : |
$this->_processDomElement($child,$sheet,$row,$column,$cellContent); |
break; |
case 'tr' : |
++$row; |
$column = $this->_getTableStartColumn(); |
$cellContent = ''; |
// echo 'START OF TABLE ' , $this->_tableLevel , ' ROW<br />'; |
$this->_processDomElement($child,$sheet,$row,$column,$cellContent); |
// echo 'END OF TABLE ' , $this->_tableLevel , ' ROW<br />'; |
break; |
case 'th' : |
case 'td' : |
// echo 'START OF TABLE ' , $this->_tableLevel , ' CELL<br />'; |
$this->_processDomElement($child,$sheet,$row,$column,$cellContent); |
// echo 'END OF TABLE ' , $this->_tableLevel , ' CELL<br />'; |
$this->_flushCell($sheet,$column,$row,$cellContent); |
++$column; |
break; |
case 'body' : |
$row = 1; |
$column = 'A'; |
$content = ''; |
$this->_tableLevel = 0; |
$this->_processDomElement($child,$sheet,$row,$column,$cellContent); |
break; |
default: |
$this->_processDomElement($child,$sheet,$row,$column,$cellContent); |
} |
} |
} |
} |
/** |
* Loads PHPExcel from file into PHPExcel instance |
* |
* @param string $pFilename |
* @param PHPExcel $objPHPExcel |
* @return PHPExcel |
* @throws PHPExcel_Reader_Exception |
*/ |
public function loadIntoExisting($pFilename, PHPExcel $objPHPExcel) |
{ |
// Open file to validate |
$this->_openFile($pFilename); |
if (!$this->_isValidFormat()) { |
fclose ($this->_fileHandle); |
throw new PHPExcel_Reader_Exception($pFilename . " is an Invalid HTML file."); |
} |
// Close after validating |
fclose ($this->_fileHandle); |
// Create new PHPExcel |
while ($objPHPExcel->getSheetCount() <= $this->_sheetIndex) { |
$objPHPExcel->createSheet(); |
} |
$objPHPExcel->setActiveSheetIndex( $this->_sheetIndex ); |
// Create a new DOM object |
$dom = new domDocument; |
// Reload the HTML file into the DOM object |
$loaded = $dom->loadHTMLFile($pFilename); |
if ($loaded === FALSE) { |
throw new PHPExcel_Reader_Exception('Failed to load ',$pFilename,' as a DOM Document'); |
} |
// Discard white space |
$dom->preserveWhiteSpace = false; |
$row = 0; |
$column = 'A'; |
$content = ''; |
$this->_processDomElement($dom,$objPHPExcel->getActiveSheet(),$row,$column,$content); |
// echo '<hr />'; |
// var_dump($this->_dataArray); |
// Return |
return $objPHPExcel; |
} |
/** |
* Get sheet index |
* |
* @return int |
*/ |
public function getSheetIndex() { |
return $this->_sheetIndex; |
} |
/** |
* Set sheet index |
* |
* @param int $pValue Sheet index |
* @return PHPExcel_Reader_HTML |
*/ |
public function setSheetIndex($pValue = 0) { |
$this->_sheetIndex = $pValue; |
return $this; |
} |
} |
/branches/v2.6-greffoir/jrest/lib/PHPExcel/Classes/PHPExcel/Reader/Excel5.php |
---|
New file |
0,0 → 1,6845 |
<?php |
/** |
* PHPExcel |
* |
* Copyright (c) 2006 - 2013 PHPExcel |
* |
* This library is free software; you can redistribute it and/or |
* modify it under the terms of the GNU Lesser General Public |
* License as published by the Free Software Foundation; either |
* version 2.1 of the License, or (at your option) any later version. |
* |
* This library is distributed in the hope that it will be useful, |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
* Lesser General Public License for more details. |
* |
* You should have received a copy of the GNU Lesser General Public |
* License along with this library; if not, write to the Free Software |
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
* |
* @category PHPExcel |
* @package PHPExcel_Reader_Excel5 |
* @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL |
* @version ##VERSION##, ##DATE## |
*/ |
// Original file header of ParseXL (used as the base for this class): |
// -------------------------------------------------------------------------------- |
// Adapted from Excel_Spreadsheet_Reader developed by users bizon153, |
// trex005, and mmp11 (SourceForge.net) |
// http://sourceforge.net/projects/phpexcelreader/ |
// Primary changes made by canyoncasa (dvc) for ParseXL 1.00 ... |
// Modelled moreso after Perl Excel Parse/Write modules |
// Added Parse_Excel_Spreadsheet object |
// Reads a whole worksheet or tab as row,column array or as |
// associated hash of indexed rows and named column fields |
// Added variables for worksheet (tab) indexes and names |
// Added an object call for loading individual woorksheets |
// Changed default indexing defaults to 0 based arrays |
// Fixed date/time and percent formats |
// Includes patches found at SourceForge... |
// unicode patch by nobody |
// unpack("d") machine depedency patch by matchy |
// boundsheet utf16 patch by bjaenichen |
// Renamed functions for shorter names |
// General code cleanup and rigor, including <80 column width |
// Included a testcase Excel file and PHP example calls |
// Code works for PHP 5.x |
// Primary changes made by canyoncasa (dvc) for ParseXL 1.10 ... |
// http://sourceforge.net/tracker/index.php?func=detail&aid=1466964&group_id=99160&atid=623334 |
// Decoding of formula conditions, results, and tokens. |
// Support for user-defined named cells added as an array "namedcells" |
// Patch code for user-defined named cells supports single cells only. |
// NOTE: this patch only works for BIFF8 as BIFF5-7 use a different |
// external sheet reference structure |
/** PHPExcel root directory */ |
if (!defined('PHPEXCEL_ROOT')) { |
/** |
* @ignore |
*/ |
define('PHPEXCEL_ROOT', dirname(__FILE__) . '/../../'); |
require(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php'); |
} |
/** |
* PHPExcel_Reader_Excel5 |
* |
* This class uses {@link http://sourceforge.net/projects/phpexcelreader/parseXL} |
* |
* @category PHPExcel |
* @package PHPExcel_Reader_Excel5 |
* @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
*/ |
class PHPExcel_Reader_Excel5 extends PHPExcel_Reader_Abstract implements PHPExcel_Reader_IReader |
{ |
// ParseXL definitions |
const XLS_BIFF8 = 0x0600; |
const XLS_BIFF7 = 0x0500; |
const XLS_WorkbookGlobals = 0x0005; |
const XLS_Worksheet = 0x0010; |
// record identifiers |
const XLS_Type_FORMULA = 0x0006; |
const XLS_Type_EOF = 0x000a; |
const XLS_Type_PROTECT = 0x0012; |
const XLS_Type_OBJECTPROTECT = 0x0063; |
const XLS_Type_SCENPROTECT = 0x00dd; |
const XLS_Type_PASSWORD = 0x0013; |
const XLS_Type_HEADER = 0x0014; |
const XLS_Type_FOOTER = 0x0015; |
const XLS_Type_EXTERNSHEET = 0x0017; |
const XLS_Type_DEFINEDNAME = 0x0018; |
const XLS_Type_VERTICALPAGEBREAKS = 0x001a; |
const XLS_Type_HORIZONTALPAGEBREAKS = 0x001b; |
const XLS_Type_NOTE = 0x001c; |
const XLS_Type_SELECTION = 0x001d; |
const XLS_Type_DATEMODE = 0x0022; |
const XLS_Type_EXTERNNAME = 0x0023; |
const XLS_Type_LEFTMARGIN = 0x0026; |
const XLS_Type_RIGHTMARGIN = 0x0027; |
const XLS_Type_TOPMARGIN = 0x0028; |
const XLS_Type_BOTTOMMARGIN = 0x0029; |
const XLS_Type_PRINTGRIDLINES = 0x002b; |
const XLS_Type_FILEPASS = 0x002f; |
const XLS_Type_FONT = 0x0031; |
const XLS_Type_CONTINUE = 0x003c; |
const XLS_Type_PANE = 0x0041; |
const XLS_Type_CODEPAGE = 0x0042; |
const XLS_Type_DEFCOLWIDTH = 0x0055; |
const XLS_Type_OBJ = 0x005d; |
const XLS_Type_COLINFO = 0x007d; |
const XLS_Type_IMDATA = 0x007f; |
const XLS_Type_SHEETPR = 0x0081; |
const XLS_Type_HCENTER = 0x0083; |
const XLS_Type_VCENTER = 0x0084; |
const XLS_Type_SHEET = 0x0085; |
const XLS_Type_PALETTE = 0x0092; |
const XLS_Type_SCL = 0x00a0; |
const XLS_Type_PAGESETUP = 0x00a1; |
const XLS_Type_MULRK = 0x00bd; |
const XLS_Type_MULBLANK = 0x00be; |
const XLS_Type_DBCELL = 0x00d7; |
const XLS_Type_XF = 0x00e0; |
const XLS_Type_MERGEDCELLS = 0x00e5; |
const XLS_Type_MSODRAWINGGROUP = 0x00eb; |
const XLS_Type_MSODRAWING = 0x00ec; |
const XLS_Type_SST = 0x00fc; |
const XLS_Type_LABELSST = 0x00fd; |
const XLS_Type_EXTSST = 0x00ff; |
const XLS_Type_EXTERNALBOOK = 0x01ae; |
const XLS_Type_DATAVALIDATIONS = 0x01b2; |
const XLS_Type_TXO = 0x01b6; |
const XLS_Type_HYPERLINK = 0x01b8; |
const XLS_Type_DATAVALIDATION = 0x01be; |
const XLS_Type_DIMENSION = 0x0200; |
const XLS_Type_BLANK = 0x0201; |
const XLS_Type_NUMBER = 0x0203; |
const XLS_Type_LABEL = 0x0204; |
const XLS_Type_BOOLERR = 0x0205; |
const XLS_Type_STRING = 0x0207; |
const XLS_Type_ROW = 0x0208; |
const XLS_Type_INDEX = 0x020b; |
const XLS_Type_ARRAY = 0x0221; |
const XLS_Type_DEFAULTROWHEIGHT = 0x0225; |
const XLS_Type_WINDOW2 = 0x023e; |
const XLS_Type_RK = 0x027e; |
const XLS_Type_STYLE = 0x0293; |
const XLS_Type_FORMAT = 0x041e; |
const XLS_Type_SHAREDFMLA = 0x04bc; |
const XLS_Type_BOF = 0x0809; |
const XLS_Type_SHEETPROTECTION = 0x0867; |
const XLS_Type_RANGEPROTECTION = 0x0868; |
const XLS_Type_SHEETLAYOUT = 0x0862; |
const XLS_Type_XFEXT = 0x087d; |
const XLS_Type_PAGELAYOUTVIEW = 0x088b; |
const XLS_Type_UNKNOWN = 0xffff; |
/** |
* Summary Information stream data. |
* |
* @var string |
*/ |
private $_summaryInformation; |
/** |
* Extended Summary Information stream data. |
* |
* @var string |
*/ |
private $_documentSummaryInformation; |
/** |
* User-Defined Properties stream data. |
* |
* @var string |
*/ |
private $_userDefinedProperties; |
/** |
* Workbook stream data. (Includes workbook globals substream as well as sheet substreams) |
* |
* @var string |
*/ |
private $_data; |
/** |
* Size in bytes of $this->_data |
* |
* @var int |
*/ |
private $_dataSize; |
/** |
* Current position in stream |
* |
* @var integer |
*/ |
private $_pos; |
/** |
* Workbook to be returned by the reader. |
* |
* @var PHPExcel |
*/ |
private $_phpExcel; |
/** |
* Worksheet that is currently being built by the reader. |
* |
* @var PHPExcel_Worksheet |
*/ |
private $_phpSheet; |
/** |
* BIFF version |
* |
* @var int |
*/ |
private $_version; |
/** |
* Codepage set in the Excel file being read. Only important for BIFF5 (Excel 5.0 - Excel 95) |
* For BIFF8 (Excel 97 - Excel 2003) this will always have the value 'UTF-16LE' |
* |
* @var string |
*/ |
private $_codepage; |
/** |
* Shared formats |
* |
* @var array |
*/ |
private $_formats; |
/** |
* Shared fonts |
* |
* @var array |
*/ |
private $_objFonts; |
/** |
* Color palette |
* |
* @var array |
*/ |
private $_palette; |
/** |
* Worksheets |
* |
* @var array |
*/ |
private $_sheets; |
/** |
* External books |
* |
* @var array |
*/ |
private $_externalBooks; |
/** |
* REF structures. Only applies to BIFF8. |
* |
* @var array |
*/ |
private $_ref; |
/** |
* External names |
* |
* @var array |
*/ |
private $_externalNames; |
/** |
* Defined names |
* |
* @var array |
*/ |
private $_definedname; |
/** |
* Shared strings. Only applies to BIFF8. |
* |
* @var array |
*/ |
private $_sst; |
/** |
* Panes are frozen? (in sheet currently being read). See WINDOW2 record. |
* |
* @var boolean |
*/ |
private $_frozen; |
/** |
* Fit printout to number of pages? (in sheet currently being read). See SHEETPR record. |
* |
* @var boolean |
*/ |
private $_isFitToPages; |
/** |
* Objects. One OBJ record contributes with one entry. |
* |
* @var array |
*/ |
private $_objs; |
/** |
* Text Objects. One TXO record corresponds with one entry. |
* |
* @var array |
*/ |
private $_textObjects; |
/** |
* Cell Annotations (BIFF8) |
* |
* @var array |
*/ |
private $_cellNotes; |
/** |
* The combined MSODRAWINGGROUP data |
* |
* @var string |
*/ |
private $_drawingGroupData; |
/** |
* The combined MSODRAWING data (per sheet) |
* |
* @var string |
*/ |
private $_drawingData; |
/** |
* Keep track of XF index |
* |
* @var int |
*/ |
private $_xfIndex; |
/** |
* Mapping of XF index (that is a cell XF) to final index in cellXf collection |
* |
* @var array |
*/ |
private $_mapCellXfIndex; |
/** |
* Mapping of XF index (that is a style XF) to final index in cellStyleXf collection |
* |
* @var array |
*/ |
private $_mapCellStyleXfIndex; |
/** |
* The shared formulas in a sheet. One SHAREDFMLA record contributes with one value. |
* |
* @var array |
*/ |
private $_sharedFormulas; |
/** |
* The shared formula parts in a sheet. One FORMULA record contributes with one value if it |
* refers to a shared formula. |
* |
* @var array |
*/ |
private $_sharedFormulaParts; |
/** |
* Create a new PHPExcel_Reader_Excel5 instance |
*/ |
public function __construct() { |
$this->_readFilter = new PHPExcel_Reader_DefaultReadFilter(); |
} |
/** |
* Can the current PHPExcel_Reader_IReader read the file? |
* |
* @param string $pFilename |
* @return boolean |
* @throws PHPExcel_Reader_Exception |
*/ |
public function canRead($pFilename) |
{ |
// Check if file exists |
if (!file_exists($pFilename)) { |
throw new PHPExcel_Reader_Exception("Could not open " . $pFilename . " for reading! File does not exist."); |
} |
try { |
// Use ParseXL for the hard work. |
$ole = new PHPExcel_Shared_OLERead(); |
// get excel data |
$res = $ole->read($pFilename); |
return true; |
} catch (PHPExcel_Exception $e) { |
return false; |
} |
} |
/** |
* Reads names of the worksheets from a file, without parsing the whole file to a PHPExcel object |
* |
* @param string $pFilename |
* @throws PHPExcel_Reader_Exception |
*/ |
public function listWorksheetNames($pFilename) |
{ |
// Check if file exists |
if (!file_exists($pFilename)) { |
throw new PHPExcel_Reader_Exception("Could not open " . $pFilename . " for reading! File does not exist."); |
} |
$worksheetNames = array(); |
// Read the OLE file |
$this->_loadOLE($pFilename); |
// total byte size of Excel data (workbook global substream + sheet substreams) |
$this->_dataSize = strlen($this->_data); |
$this->_pos = 0; |
$this->_sheets = array(); |
// Parse Workbook Global Substream |
while ($this->_pos < $this->_dataSize) { |
$code = self::_GetInt2d($this->_data, $this->_pos); |
switch ($code) { |
case self::XLS_Type_BOF: $this->_readBof(); break; |
case self::XLS_Type_SHEET: $this->_readSheet(); break; |
case self::XLS_Type_EOF: $this->_readDefault(); break 2; |
default: $this->_readDefault(); break; |
} |
} |
foreach ($this->_sheets as $sheet) { |
if ($sheet['sheetType'] != 0x00) { |
// 0x00: Worksheet, 0x02: Chart, 0x06: Visual Basic module |
continue; |
} |
$worksheetNames[] = $sheet['name']; |
} |
return $worksheetNames; |
} |
/** |
* Return worksheet info (Name, Last Column Letter, Last Column Index, Total Rows, Total Columns) |
* |
* @param string $pFilename |
* @throws PHPExcel_Reader_Exception |
*/ |
public function listWorksheetInfo($pFilename) |
{ |
// Check if file exists |
if (!file_exists($pFilename)) { |
throw new PHPExcel_Reader_Exception("Could not open " . $pFilename . " for reading! File does not exist."); |
} |
$worksheetInfo = array(); |
// Read the OLE file |
$this->_loadOLE($pFilename); |
// total byte size of Excel data (workbook global substream + sheet substreams) |
$this->_dataSize = strlen($this->_data); |
// initialize |
$this->_pos = 0; |
$this->_sheets = array(); |
// Parse Workbook Global Substream |
while ($this->_pos < $this->_dataSize) { |
$code = self::_GetInt2d($this->_data, $this->_pos); |
switch ($code) { |
case self::XLS_Type_BOF: $this->_readBof(); break; |
case self::XLS_Type_SHEET: $this->_readSheet(); break; |
case self::XLS_Type_EOF: $this->_readDefault(); break 2; |
default: $this->_readDefault(); break; |
} |
} |
// Parse the individual sheets |
foreach ($this->_sheets as $sheet) { |
if ($sheet['sheetType'] != 0x00) { |
// 0x00: Worksheet |
// 0x02: Chart |
// 0x06: Visual Basic module |
continue; |
} |
$tmpInfo = array(); |
$tmpInfo['worksheetName'] = $sheet['name']; |
$tmpInfo['lastColumnLetter'] = 'A'; |
$tmpInfo['lastColumnIndex'] = 0; |
$tmpInfo['totalRows'] = 0; |
$tmpInfo['totalColumns'] = 0; |
$this->_pos = $sheet['offset']; |
while ($this->_pos <= $this->_dataSize - 4) { |
$code = self::_GetInt2d($this->_data, $this->_pos); |
switch ($code) { |
case self::XLS_Type_RK: |
case self::XLS_Type_LABELSST: |
case self::XLS_Type_NUMBER: |
case self::XLS_Type_FORMULA: |
case self::XLS_Type_BOOLERR: |
case self::XLS_Type_LABEL: |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
$rowIndex = self::_GetInt2d($recordData, 0) + 1; |
$columnIndex = self::_GetInt2d($recordData, 2); |
$tmpInfo['totalRows'] = max($tmpInfo['totalRows'], $rowIndex); |
$tmpInfo['lastColumnIndex'] = max($tmpInfo['lastColumnIndex'], $columnIndex); |
break; |
case self::XLS_Type_BOF: $this->_readBof(); break; |
case self::XLS_Type_EOF: $this->_readDefault(); break 2; |
default: $this->_readDefault(); break; |
} |
} |
$tmpInfo['lastColumnLetter'] = PHPExcel_Cell::stringFromColumnIndex($tmpInfo['lastColumnIndex']); |
$tmpInfo['totalColumns'] = $tmpInfo['lastColumnIndex'] + 1; |
$worksheetInfo[] = $tmpInfo; |
} |
return $worksheetInfo; |
} |
/** |
* Loads PHPExcel from file |
* |
* @param string $pFilename |
* @return PHPExcel |
* @throws PHPExcel_Reader_Exception |
*/ |
public function load($pFilename) |
{ |
// Read the OLE file |
$this->_loadOLE($pFilename); |
// Initialisations |
$this->_phpExcel = new PHPExcel; |
$this->_phpExcel->removeSheetByIndex(0); // remove 1st sheet |
if (!$this->_readDataOnly) { |
$this->_phpExcel->removeCellStyleXfByIndex(0); // remove the default style |
$this->_phpExcel->removeCellXfByIndex(0); // remove the default style |
} |
// Read the summary information stream (containing meta data) |
$this->_readSummaryInformation(); |
// Read the Additional document summary information stream (containing application-specific meta data) |
$this->_readDocumentSummaryInformation(); |
// total byte size of Excel data (workbook global substream + sheet substreams) |
$this->_dataSize = strlen($this->_data); |
// initialize |
$this->_pos = 0; |
$this->_codepage = 'CP1252'; |
$this->_formats = array(); |
$this->_objFonts = array(); |
$this->_palette = array(); |
$this->_sheets = array(); |
$this->_externalBooks = array(); |
$this->_ref = array(); |
$this->_definedname = array(); |
$this->_sst = array(); |
$this->_drawingGroupData = ''; |
$this->_xfIndex = ''; |
$this->_mapCellXfIndex = array(); |
$this->_mapCellStyleXfIndex = array(); |
// Parse Workbook Global Substream |
while ($this->_pos < $this->_dataSize) { |
$code = self::_GetInt2d($this->_data, $this->_pos); |
switch ($code) { |
case self::XLS_Type_BOF: $this->_readBof(); break; |
case self::XLS_Type_FILEPASS: $this->_readFilepass(); break; |
case self::XLS_Type_CODEPAGE: $this->_readCodepage(); break; |
case self::XLS_Type_DATEMODE: $this->_readDateMode(); break; |
case self::XLS_Type_FONT: $this->_readFont(); break; |
case self::XLS_Type_FORMAT: $this->_readFormat(); break; |
case self::XLS_Type_XF: $this->_readXf(); break; |
case self::XLS_Type_XFEXT: $this->_readXfExt(); break; |
case self::XLS_Type_STYLE: $this->_readStyle(); break; |
case self::XLS_Type_PALETTE: $this->_readPalette(); break; |
case self::XLS_Type_SHEET: $this->_readSheet(); break; |
case self::XLS_Type_EXTERNALBOOK: $this->_readExternalBook(); break; |
case self::XLS_Type_EXTERNNAME: $this->_readExternName(); break; |
case self::XLS_Type_EXTERNSHEET: $this->_readExternSheet(); break; |
case self::XLS_Type_DEFINEDNAME: $this->_readDefinedName(); break; |
case self::XLS_Type_MSODRAWINGGROUP: $this->_readMsoDrawingGroup(); break; |
case self::XLS_Type_SST: $this->_readSst(); break; |
case self::XLS_Type_EOF: $this->_readDefault(); break 2; |
default: $this->_readDefault(); break; |
} |
} |
// Resolve indexed colors for font, fill, and border colors |
// Cannot be resolved already in XF record, because PALETTE record comes afterwards |
if (!$this->_readDataOnly) { |
foreach ($this->_objFonts as $objFont) { |
if (isset($objFont->colorIndex)) { |
$color = self::_readColor($objFont->colorIndex,$this->_palette,$this->_version); |
$objFont->getColor()->setRGB($color['rgb']); |
} |
} |
foreach ($this->_phpExcel->getCellXfCollection() as $objStyle) { |
// fill start and end color |
$fill = $objStyle->getFill(); |
if (isset($fill->startcolorIndex)) { |
$startColor = self::_readColor($fill->startcolorIndex,$this->_palette,$this->_version); |
$fill->getStartColor()->setRGB($startColor['rgb']); |
} |
if (isset($fill->endcolorIndex)) { |
$endColor = self::_readColor($fill->endcolorIndex,$this->_palette,$this->_version); |
$fill->getEndColor()->setRGB($endColor['rgb']); |
} |
// border colors |
$top = $objStyle->getBorders()->getTop(); |
$right = $objStyle->getBorders()->getRight(); |
$bottom = $objStyle->getBorders()->getBottom(); |
$left = $objStyle->getBorders()->getLeft(); |
$diagonal = $objStyle->getBorders()->getDiagonal(); |
if (isset($top->colorIndex)) { |
$borderTopColor = self::_readColor($top->colorIndex,$this->_palette,$this->_version); |
$top->getColor()->setRGB($borderTopColor['rgb']); |
} |
if (isset($right->colorIndex)) { |
$borderRightColor = self::_readColor($right->colorIndex,$this->_palette,$this->_version); |
$right->getColor()->setRGB($borderRightColor['rgb']); |
} |
if (isset($bottom->colorIndex)) { |
$borderBottomColor = self::_readColor($bottom->colorIndex,$this->_palette,$this->_version); |
$bottom->getColor()->setRGB($borderBottomColor['rgb']); |
} |
if (isset($left->colorIndex)) { |
$borderLeftColor = self::_readColor($left->colorIndex,$this->_palette,$this->_version); |
$left->getColor()->setRGB($borderLeftColor['rgb']); |
} |
if (isset($diagonal->colorIndex)) { |
$borderDiagonalColor = self::_readColor($diagonal->colorIndex,$this->_palette,$this->_version); |
$diagonal->getColor()->setRGB($borderDiagonalColor['rgb']); |
} |
} |
} |
// treat MSODRAWINGGROUP records, workbook-level Escher |
if (!$this->_readDataOnly && $this->_drawingGroupData) { |
$escherWorkbook = new PHPExcel_Shared_Escher(); |
$reader = new PHPExcel_Reader_Excel5_Escher($escherWorkbook); |
$escherWorkbook = $reader->load($this->_drawingGroupData); |
// debug Escher stream |
//$debug = new Debug_Escher(new PHPExcel_Shared_Escher()); |
//$debug->load($this->_drawingGroupData); |
} |
// Parse the individual sheets |
foreach ($this->_sheets as $sheet) { |
if ($sheet['sheetType'] != 0x00) { |
// 0x00: Worksheet, 0x02: Chart, 0x06: Visual Basic module |
continue; |
} |
// check if sheet should be skipped |
if (isset($this->_loadSheetsOnly) && !in_array($sheet['name'], $this->_loadSheetsOnly)) { |
continue; |
} |
// add sheet to PHPExcel object |
$this->_phpSheet = $this->_phpExcel->createSheet(); |
// Use false for $updateFormulaCellReferences to prevent adjustment of worksheet references in formula |
// cells... during the load, all formulae should be correct, and we're simply bringing the worksheet |
// name in line with the formula, not the reverse |
$this->_phpSheet->setTitle($sheet['name'],false); |
$this->_phpSheet->setSheetState($sheet['sheetState']); |
$this->_pos = $sheet['offset']; |
// Initialize isFitToPages. May change after reading SHEETPR record. |
$this->_isFitToPages = false; |
// Initialize drawingData |
$this->_drawingData = ''; |
// Initialize objs |
$this->_objs = array(); |
// Initialize shared formula parts |
$this->_sharedFormulaParts = array(); |
// Initialize shared formulas |
$this->_sharedFormulas = array(); |
// Initialize text objs |
$this->_textObjects = array(); |
// Initialize cell annotations |
$this->_cellNotes = array(); |
$this->textObjRef = -1; |
while ($this->_pos <= $this->_dataSize - 4) { |
$code = self::_GetInt2d($this->_data, $this->_pos); |
switch ($code) { |
case self::XLS_Type_BOF: $this->_readBof(); break; |
case self::XLS_Type_PRINTGRIDLINES: $this->_readPrintGridlines(); break; |
case self::XLS_Type_DEFAULTROWHEIGHT: $this->_readDefaultRowHeight(); break; |
case self::XLS_Type_SHEETPR: $this->_readSheetPr(); break; |
case self::XLS_Type_HORIZONTALPAGEBREAKS: $this->_readHorizontalPageBreaks(); break; |
case self::XLS_Type_VERTICALPAGEBREAKS: $this->_readVerticalPageBreaks(); break; |
case self::XLS_Type_HEADER: $this->_readHeader(); break; |
case self::XLS_Type_FOOTER: $this->_readFooter(); break; |
case self::XLS_Type_HCENTER: $this->_readHcenter(); break; |
case self::XLS_Type_VCENTER: $this->_readVcenter(); break; |
case self::XLS_Type_LEFTMARGIN: $this->_readLeftMargin(); break; |
case self::XLS_Type_RIGHTMARGIN: $this->_readRightMargin(); break; |
case self::XLS_Type_TOPMARGIN: $this->_readTopMargin(); break; |
case self::XLS_Type_BOTTOMMARGIN: $this->_readBottomMargin(); break; |
case self::XLS_Type_PAGESETUP: $this->_readPageSetup(); break; |
case self::XLS_Type_PROTECT: $this->_readProtect(); break; |
case self::XLS_Type_SCENPROTECT: $this->_readScenProtect(); break; |
case self::XLS_Type_OBJECTPROTECT: $this->_readObjectProtect(); break; |
case self::XLS_Type_PASSWORD: $this->_readPassword(); break; |
case self::XLS_Type_DEFCOLWIDTH: $this->_readDefColWidth(); break; |
case self::XLS_Type_COLINFO: $this->_readColInfo(); break; |
case self::XLS_Type_DIMENSION: $this->_readDefault(); break; |
case self::XLS_Type_ROW: $this->_readRow(); break; |
case self::XLS_Type_DBCELL: $this->_readDefault(); break; |
case self::XLS_Type_RK: $this->_readRk(); break; |
case self::XLS_Type_LABELSST: $this->_readLabelSst(); break; |
case self::XLS_Type_MULRK: $this->_readMulRk(); break; |
case self::XLS_Type_NUMBER: $this->_readNumber(); break; |
case self::XLS_Type_FORMULA: $this->_readFormula(); break; |
case self::XLS_Type_SHAREDFMLA: $this->_readSharedFmla(); break; |
case self::XLS_Type_BOOLERR: $this->_readBoolErr(); break; |
case self::XLS_Type_MULBLANK: $this->_readMulBlank(); break; |
case self::XLS_Type_LABEL: $this->_readLabel(); break; |
case self::XLS_Type_BLANK: $this->_readBlank(); break; |
case self::XLS_Type_MSODRAWING: $this->_readMsoDrawing(); break; |
case self::XLS_Type_OBJ: $this->_readObj(); break; |
case self::XLS_Type_WINDOW2: $this->_readWindow2(); break; |
case self::XLS_Type_PAGELAYOUTVIEW: $this->_readPageLayoutView(); break; |
case self::XLS_Type_SCL: $this->_readScl(); break; |
case self::XLS_Type_PANE: $this->_readPane(); break; |
case self::XLS_Type_SELECTION: $this->_readSelection(); break; |
case self::XLS_Type_MERGEDCELLS: $this->_readMergedCells(); break; |
case self::XLS_Type_HYPERLINK: $this->_readHyperLink(); break; |
case self::XLS_Type_DATAVALIDATIONS: $this->_readDataValidations(); break; |
case self::XLS_Type_DATAVALIDATION: $this->_readDataValidation(); break; |
case self::XLS_Type_SHEETLAYOUT: $this->_readSheetLayout(); break; |
case self::XLS_Type_SHEETPROTECTION: $this->_readSheetProtection(); break; |
case self::XLS_Type_RANGEPROTECTION: $this->_readRangeProtection(); break; |
case self::XLS_Type_NOTE: $this->_readNote(); break; |
//case self::XLS_Type_IMDATA: $this->_readImData(); break; |
case self::XLS_Type_TXO: $this->_readTextObject(); break; |
case self::XLS_Type_CONTINUE: $this->_readContinue(); break; |
case self::XLS_Type_EOF: $this->_readDefault(); break 2; |
default: $this->_readDefault(); break; |
} |
} |
// treat MSODRAWING records, sheet-level Escher |
if (!$this->_readDataOnly && $this->_drawingData) { |
$escherWorksheet = new PHPExcel_Shared_Escher(); |
$reader = new PHPExcel_Reader_Excel5_Escher($escherWorksheet); |
$escherWorksheet = $reader->load($this->_drawingData); |
// debug Escher stream |
//$debug = new Debug_Escher(new PHPExcel_Shared_Escher()); |
//$debug->load($this->_drawingData); |
// get all spContainers in one long array, so they can be mapped to OBJ records |
$allSpContainers = $escherWorksheet->getDgContainer()->getSpgrContainer()->getAllSpContainers(); |
} |
// treat OBJ records |
foreach ($this->_objs as $n => $obj) { |
// echo '<hr /><b>Object</b> reference is ',$n,'<br />'; |
// var_dump($obj); |
// echo '<br />'; |
// the first shape container never has a corresponding OBJ record, hence $n + 1 |
if (isset($allSpContainers[$n + 1]) && is_object($allSpContainers[$n + 1])) { |
$spContainer = $allSpContainers[$n + 1]; |
// we skip all spContainers that are a part of a group shape since we cannot yet handle those |
if ($spContainer->getNestingLevel() > 1) { |
continue; |
} |
// calculate the width and height of the shape |
list($startColumn, $startRow) = PHPExcel_Cell::coordinateFromString($spContainer->getStartCoordinates()); |
list($endColumn, $endRow) = PHPExcel_Cell::coordinateFromString($spContainer->getEndCoordinates()); |
$startOffsetX = $spContainer->getStartOffsetX(); |
$startOffsetY = $spContainer->getStartOffsetY(); |
$endOffsetX = $spContainer->getEndOffsetX(); |
$endOffsetY = $spContainer->getEndOffsetY(); |
$width = PHPExcel_Shared_Excel5::getDistanceX($this->_phpSheet, $startColumn, $startOffsetX, $endColumn, $endOffsetX); |
$height = PHPExcel_Shared_Excel5::getDistanceY($this->_phpSheet, $startRow, $startOffsetY, $endRow, $endOffsetY); |
// calculate offsetX and offsetY of the shape |
$offsetX = $startOffsetX * PHPExcel_Shared_Excel5::sizeCol($this->_phpSheet, $startColumn) / 1024; |
$offsetY = $startOffsetY * PHPExcel_Shared_Excel5::sizeRow($this->_phpSheet, $startRow) / 256; |
switch ($obj['otObjType']) { |
case 0x19: |
// Note |
// echo 'Cell Annotation Object<br />'; |
// echo 'Object ID is ',$obj['idObjID'],'<br />'; |
// |
if (isset($this->_cellNotes[$obj['idObjID']])) { |
$cellNote = $this->_cellNotes[$obj['idObjID']]; |
if (isset($this->_textObjects[$obj['idObjID']])) { |
$textObject = $this->_textObjects[$obj['idObjID']]; |
$this->_cellNotes[$obj['idObjID']]['objTextData'] = $textObject; |
} |
} |
break; |
case 0x08: |
// echo 'Picture Object<br />'; |
// picture |
// get index to BSE entry (1-based) |
$BSEindex = $spContainer->getOPT(0x0104); |
$BSECollection = $escherWorkbook->getDggContainer()->getBstoreContainer()->getBSECollection(); |
$BSE = $BSECollection[$BSEindex - 1]; |
$blipType = $BSE->getBlipType(); |
// need check because some blip types are not supported by Escher reader such as EMF |
if ($blip = $BSE->getBlip()) { |
$ih = imagecreatefromstring($blip->getData()); |
$drawing = new PHPExcel_Worksheet_MemoryDrawing(); |
$drawing->setImageResource($ih); |
// width, height, offsetX, offsetY |
$drawing->setResizeProportional(false); |
$drawing->setWidth($width); |
$drawing->setHeight($height); |
$drawing->setOffsetX($offsetX); |
$drawing->setOffsetY($offsetY); |
switch ($blipType) { |
case PHPExcel_Shared_Escher_DggContainer_BstoreContainer_BSE::BLIPTYPE_JPEG: |
$drawing->setRenderingFunction(PHPExcel_Worksheet_MemoryDrawing::RENDERING_JPEG); |
$drawing->setMimeType(PHPExcel_Worksheet_MemoryDrawing::MIMETYPE_JPEG); |
break; |
case PHPExcel_Shared_Escher_DggContainer_BstoreContainer_BSE::BLIPTYPE_PNG: |
$drawing->setRenderingFunction(PHPExcel_Worksheet_MemoryDrawing::RENDERING_PNG); |
$drawing->setMimeType(PHPExcel_Worksheet_MemoryDrawing::MIMETYPE_PNG); |
break; |
} |
$drawing->setWorksheet($this->_phpSheet); |
$drawing->setCoordinates($spContainer->getStartCoordinates()); |
} |
break; |
default: |
// other object type |
break; |
} |
} |
} |
// treat SHAREDFMLA records |
if ($this->_version == self::XLS_BIFF8) { |
foreach ($this->_sharedFormulaParts as $cell => $baseCell) { |
list($column, $row) = PHPExcel_Cell::coordinateFromString($cell); |
if (($this->getReadFilter() !== NULL) && $this->getReadFilter()->readCell($column, $row, $this->_phpSheet->getTitle()) ) { |
$formula = $this->_getFormulaFromStructure($this->_sharedFormulas[$baseCell], $cell); |
$this->_phpSheet->getCell($cell)->setValueExplicit('=' . $formula, PHPExcel_Cell_DataType::TYPE_FORMULA); |
} |
} |
} |
if (!empty($this->_cellNotes)) { |
foreach($this->_cellNotes as $note => $noteDetails) { |
if (!isset($noteDetails['objTextData'])) { |
if (isset($this->_textObjects[$note])) { |
$textObject = $this->_textObjects[$note]; |
$noteDetails['objTextData'] = $textObject; |
} else { |
$noteDetails['objTextData']['text'] = ''; |
} |
} |
// echo '<b>Cell annotation ',$note,'</b><br />'; |
// var_dump($noteDetails); |
// echo '<br />'; |
$cellAddress = str_replace('$','',$noteDetails['cellRef']); |
$this->_phpSheet->getComment( $cellAddress ) |
->setAuthor( $noteDetails['author'] ) |
->setText($this->_parseRichText($noteDetails['objTextData']['text']) ); |
} |
} |
} |
// add the named ranges (defined names) |
foreach ($this->_definedname as $definedName) { |
if ($definedName['isBuiltInName']) { |
switch ($definedName['name']) { |
case pack('C', 0x06): |
// print area |
// in general, formula looks like this: Foo!$C$7:$J$66,Bar!$A$1:$IV$2 |
$ranges = explode(',', $definedName['formula']); // FIXME: what if sheetname contains comma? |
$extractedRanges = array(); |
foreach ($ranges as $range) { |
// $range should look like one of these |
// Foo!$C$7:$J$66 |
// Bar!$A$1:$IV$2 |
$explodes = explode('!', $range); // FIXME: what if sheetname contains exclamation mark? |
$sheetName = trim($explodes[0], "'"); |
if (count($explodes) == 2) { |
if (strpos($explodes[1], ':') === FALSE) { |
$explodes[1] = $explodes[1] . ':' . $explodes[1]; |
} |
$extractedRanges[] = str_replace('$', '', $explodes[1]); // C7:J66 |
} |
} |
if ($docSheet = $this->_phpExcel->getSheetByName($sheetName)) { |
$docSheet->getPageSetup()->setPrintArea(implode(',', $extractedRanges)); // C7:J66,A1:IV2 |
} |
break; |
case pack('C', 0x07): |
// print titles (repeating rows) |
// Assuming BIFF8, there are 3 cases |
// 1. repeating rows |
// formula looks like this: Sheet!$A$1:$IV$2 |
// rows 1-2 repeat |
// 2. repeating columns |
// formula looks like this: Sheet!$A$1:$B$65536 |
// columns A-B repeat |
// 3. both repeating rows and repeating columns |
// formula looks like this: Sheet!$A$1:$B$65536,Sheet!$A$1:$IV$2 |
$ranges = explode(',', $definedName['formula']); // FIXME: what if sheetname contains comma? |
foreach ($ranges as $range) { |
// $range should look like this one of these |
// Sheet!$A$1:$B$65536 |
// Sheet!$A$1:$IV$2 |
$explodes = explode('!', $range); |
if (count($explodes) == 2) { |
if ($docSheet = $this->_phpExcel->getSheetByName($explodes[0])) { |
$extractedRange = $explodes[1]; |
$extractedRange = str_replace('$', '', $extractedRange); |
$coordinateStrings = explode(':', $extractedRange); |
if (count($coordinateStrings) == 2) { |
list($firstColumn, $firstRow) = PHPExcel_Cell::coordinateFromString($coordinateStrings[0]); |
list($lastColumn, $lastRow) = PHPExcel_Cell::coordinateFromString($coordinateStrings[1]); |
if ($firstColumn == 'A' and $lastColumn == 'IV') { |
// then we have repeating rows |
$docSheet->getPageSetup()->setRowsToRepeatAtTop(array($firstRow, $lastRow)); |
} elseif ($firstRow == 1 and $lastRow == 65536) { |
// then we have repeating columns |
$docSheet->getPageSetup()->setColumnsToRepeatAtLeft(array($firstColumn, $lastColumn)); |
} |
} |
} |
} |
} |
break; |
} |
} else { |
// Extract range |
$explodes = explode('!', $definedName['formula']); |
if (count($explodes) == 2) { |
if (($docSheet = $this->_phpExcel->getSheetByName($explodes[0])) || |
($docSheet = $this->_phpExcel->getSheetByName(trim($explodes[0],"'")))) { |
$extractedRange = $explodes[1]; |
$extractedRange = str_replace('$', '', $extractedRange); |
$localOnly = ($definedName['scope'] == 0) ? false : true; |
$scope = ($definedName['scope'] == 0) ? |
null : $this->_phpExcel->getSheetByName($this->_sheets[$definedName['scope'] - 1]['name']); |
$this->_phpExcel->addNamedRange( new PHPExcel_NamedRange((string)$definedName['name'], $docSheet, $extractedRange, $localOnly, $scope) ); |
} |
} else { |
// Named Value |
// TODO Provide support for named values |
} |
} |
} |
return $this->_phpExcel; |
} |
/** |
* Use OLE reader to extract the relevant data streams from the OLE file |
* |
* @param string $pFilename |
*/ |
private function _loadOLE($pFilename) |
{ |
// OLE reader |
$ole = new PHPExcel_Shared_OLERead(); |
// get excel data, |
$res = $ole->read($pFilename); |
// Get workbook data: workbook stream + sheet streams |
$this->_data = $ole->getStream($ole->wrkbook); |
// Get summary information data |
$this->_summaryInformation = $ole->getStream($ole->summaryInformation); |
// Get additional document summary information data |
$this->_documentSummaryInformation = $ole->getStream($ole->documentSummaryInformation); |
// Get user-defined property data |
// $this->_userDefinedProperties = $ole->getUserDefinedProperties(); |
} |
/** |
* Read summary information |
*/ |
private function _readSummaryInformation() |
{ |
if (!isset($this->_summaryInformation)) { |
return; |
} |
// offset: 0; size: 2; must be 0xFE 0xFF (UTF-16 LE byte order mark) |
// offset: 2; size: 2; |
// offset: 4; size: 2; OS version |
// offset: 6; size: 2; OS indicator |
// offset: 8; size: 16 |
// offset: 24; size: 4; section count |
$secCount = self::_GetInt4d($this->_summaryInformation, 24); |
// 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 |
// offset: 44; size: 4 |
$secOffset = self::_GetInt4d($this->_summaryInformation, 44); |
// section header |
// offset: $secOffset; size: 4; section length |
$secLength = self::_GetInt4d($this->_summaryInformation, $secOffset); |
// offset: $secOffset+4; size: 4; property count |
$countProperties = self::_GetInt4d($this->_summaryInformation, $secOffset+4); |
// initialize code page (used to resolve string values) |
$codePage = 'CP1252'; |
// offset: ($secOffset+8); size: var |
// loop through property decarations and properties |
for ($i = 0; $i < $countProperties; ++$i) { |
// offset: ($secOffset+8) + (8 * $i); size: 4; property ID |
$id = self::_GetInt4d($this->_summaryInformation, ($secOffset+8) + (8 * $i)); |
// Use value of property id as appropriate |
// offset: ($secOffset+12) + (8 * $i); size: 4; offset from beginning of section (48) |
$offset = self::_GetInt4d($this->_summaryInformation, ($secOffset+12) + (8 * $i)); |
$type = self::_GetInt4d($this->_summaryInformation, $secOffset + $offset); |
// initialize property value |
$value = null; |
// extract property value based on property type |
switch ($type) { |
case 0x02: // 2 byte signed integer |
$value = self::_GetInt2d($this->_summaryInformation, $secOffset + 4 + $offset); |
break; |
case 0x03: // 4 byte signed integer |
$value = self::_GetInt4d($this->_summaryInformation, $secOffset + 4 + $offset); |
break; |
case 0x13: // 4 byte unsigned integer |
// not needed yet, fix later if necessary |
break; |
case 0x1E: // null-terminated string prepended by dword string length |
$byteLength = self::_GetInt4d($this->_summaryInformation, $secOffset + 4 + $offset); |
$value = substr($this->_summaryInformation, $secOffset + 8 + $offset, $byteLength); |
$value = PHPExcel_Shared_String::ConvertEncoding($value, 'UTF-8', $codePage); |
$value = rtrim($value); |
break; |
case 0x40: // Filetime (64-bit value representing the number of 100-nanosecond intervals since January 1, 1601) |
// PHP-time |
$value = PHPExcel_Shared_OLE::OLE2LocalDate(substr($this->_summaryInformation, $secOffset + 4 + $offset, 8)); |
break; |
case 0x47: // Clipboard format |
// not needed yet, fix later if necessary |
break; |
} |
switch ($id) { |
case 0x01: // Code Page |
$codePage = PHPExcel_Shared_CodePage::NumberToName($value); |
break; |
case 0x02: // Title |
$this->_phpExcel->getProperties()->setTitle($value); |
break; |
case 0x03: // Subject |
$this->_phpExcel->getProperties()->setSubject($value); |
break; |
case 0x04: // Author (Creator) |
$this->_phpExcel->getProperties()->setCreator($value); |
break; |
case 0x05: // Keywords |
$this->_phpExcel->getProperties()->setKeywords($value); |
break; |
case 0x06: // Comments (Description) |
$this->_phpExcel->getProperties()->setDescription($value); |
break; |
case 0x07: // Template |
// Not supported by PHPExcel |
break; |
case 0x08: // Last Saved By (LastModifiedBy) |
$this->_phpExcel->getProperties()->setLastModifiedBy($value); |
break; |
case 0x09: // Revision |
// Not supported by PHPExcel |
break; |
case 0x0A: // Total Editing Time |
// Not supported by PHPExcel |
break; |
case 0x0B: // Last Printed |
// Not supported by PHPExcel |
break; |
case 0x0C: // Created Date/Time |
$this->_phpExcel->getProperties()->setCreated($value); |
break; |
case 0x0D: // Modified Date/Time |
$this->_phpExcel->getProperties()->setModified($value); |
break; |
case 0x0E: // Number of Pages |
// Not supported by PHPExcel |
break; |
case 0x0F: // Number of Words |
// Not supported by PHPExcel |
break; |
case 0x10: // Number of Characters |
// Not supported by PHPExcel |
break; |
case 0x11: // Thumbnail |
// Not supported by PHPExcel |
break; |
case 0x12: // Name of creating application |
// Not supported by PHPExcel |
break; |
case 0x13: // Security |
// Not supported by PHPExcel |
break; |
} |
} |
} |
/** |
* Read additional document summary information |
*/ |
private function _readDocumentSummaryInformation() |
{ |
if (!isset($this->_documentSummaryInformation)) { |
return; |
} |
// offset: 0; size: 2; must be 0xFE 0xFF (UTF-16 LE byte order mark) |
// offset: 2; size: 2; |
// offset: 4; size: 2; OS version |
// offset: 6; size: 2; OS indicator |
// offset: 8; size: 16 |
// offset: 24; size: 4; section count |
$secCount = self::_GetInt4d($this->_documentSummaryInformation, 24); |
// echo '$secCount = ',$secCount,'<br />'; |
// 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 |
// offset: 44; size: 4; first section offset |
$secOffset = self::_GetInt4d($this->_documentSummaryInformation, 44); |
// echo '$secOffset = ',$secOffset,'<br />'; |
// section header |
// offset: $secOffset; size: 4; section length |
$secLength = self::_GetInt4d($this->_documentSummaryInformation, $secOffset); |
// echo '$secLength = ',$secLength,'<br />'; |
// offset: $secOffset+4; size: 4; property count |
$countProperties = self::_GetInt4d($this->_documentSummaryInformation, $secOffset+4); |
// echo '$countProperties = ',$countProperties,'<br />'; |
// initialize code page (used to resolve string values) |
$codePage = 'CP1252'; |
// offset: ($secOffset+8); size: var |
// loop through property decarations and properties |
for ($i = 0; $i < $countProperties; ++$i) { |
// echo 'Property ',$i,'<br />'; |
// offset: ($secOffset+8) + (8 * $i); size: 4; property ID |
$id = self::_GetInt4d($this->_documentSummaryInformation, ($secOffset+8) + (8 * $i)); |
// echo 'ID is ',$id,'<br />'; |
// Use value of property id as appropriate |
// offset: 60 + 8 * $i; size: 4; offset from beginning of section (48) |
$offset = self::_GetInt4d($this->_documentSummaryInformation, ($secOffset+12) + (8 * $i)); |
$type = self::_GetInt4d($this->_documentSummaryInformation, $secOffset + $offset); |
// echo 'Type is ',$type,', '; |
// initialize property value |
$value = null; |
// extract property value based on property type |
switch ($type) { |
case 0x02: // 2 byte signed integer |
$value = self::_GetInt2d($this->_documentSummaryInformation, $secOffset + 4 + $offset); |
break; |
case 0x03: // 4 byte signed integer |
$value = self::_GetInt4d($this->_documentSummaryInformation, $secOffset + 4 + $offset); |
break; |
case 0x0B: // Boolean |
$value = self::_GetInt2d($this->_documentSummaryInformation, $secOffset + 4 + $offset); |
$value = ($value == 0 ? false : true); |
break; |
case 0x13: // 4 byte unsigned integer |
// not needed yet, fix later if necessary |
break; |
case 0x1E: // null-terminated string prepended by dword string length |
$byteLength = self::_GetInt4d($this->_documentSummaryInformation, $secOffset + 4 + $offset); |
$value = substr($this->_documentSummaryInformation, $secOffset + 8 + $offset, $byteLength); |
$value = PHPExcel_Shared_String::ConvertEncoding($value, 'UTF-8', $codePage); |
$value = rtrim($value); |
break; |
case 0x40: // Filetime (64-bit value representing the number of 100-nanosecond intervals since January 1, 1601) |
// PHP-Time |
$value = PHPExcel_Shared_OLE::OLE2LocalDate(substr($this->_documentSummaryInformation, $secOffset + 4 + $offset, 8)); |
break; |
case 0x47: // Clipboard format |
// not needed yet, fix later if necessary |
break; |
} |
switch ($id) { |
case 0x01: // Code Page |
$codePage = PHPExcel_Shared_CodePage::NumberToName($value); |
break; |
case 0x02: // Category |
$this->_phpExcel->getProperties()->setCategory($value); |
break; |
case 0x03: // Presentation Target |
// Not supported by PHPExcel |
break; |
case 0x04: // Bytes |
// Not supported by PHPExcel |
break; |
case 0x05: // Lines |
// Not supported by PHPExcel |
break; |
case 0x06: // Paragraphs |
// Not supported by PHPExcel |
break; |
case 0x07: // Slides |
// Not supported by PHPExcel |
break; |
case 0x08: // Notes |
// Not supported by PHPExcel |
break; |
case 0x09: // Hidden Slides |
// Not supported by PHPExcel |
break; |
case 0x0A: // MM Clips |
// Not supported by PHPExcel |
break; |
case 0x0B: // Scale Crop |
// Not supported by PHPExcel |
break; |
case 0x0C: // Heading Pairs |
// Not supported by PHPExcel |
break; |
case 0x0D: // Titles of Parts |
// Not supported by PHPExcel |
break; |
case 0x0E: // Manager |
$this->_phpExcel->getProperties()->setManager($value); |
break; |
case 0x0F: // Company |
$this->_phpExcel->getProperties()->setCompany($value); |
break; |
case 0x10: // Links up-to-date |
// Not supported by PHPExcel |
break; |
} |
} |
} |
/** |
* Reads a general type of BIFF record. Does nothing except for moving stream pointer forward to next record. |
*/ |
private function _readDefault() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
// $recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
} |
/** |
* The NOTE record specifies a comment associated with a particular cell. In Excel 95 (BIFF7) and earlier versions, |
* this record stores a note (cell note). This feature was significantly enhanced in Excel 97. |
*/ |
private function _readNote() |
{ |
// echo '<b>Read Cell Annotation</b><br />'; |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
if ($this->_readDataOnly) { |
return; |
} |
$cellAddress = $this->_readBIFF8CellAddress(substr($recordData, 0, 4)); |
if ($this->_version == self::XLS_BIFF8) { |
$noteObjID = self::_GetInt2d($recordData, 6); |
$noteAuthor = self::_readUnicodeStringLong(substr($recordData, 8)); |
$noteAuthor = $noteAuthor['value']; |
// echo 'Note Address=',$cellAddress,'<br />'; |
// echo 'Note Object ID=',$noteObjID,'<br />'; |
// echo 'Note Author=',$noteAuthor,'<hr />'; |
// |
$this->_cellNotes[$noteObjID] = array('cellRef' => $cellAddress, |
'objectID' => $noteObjID, |
'author' => $noteAuthor |
); |
} else { |
$extension = false; |
if ($cellAddress == '$B$65536') { |
// If the address row is -1 and the column is 0, (which translates as $B$65536) then this is a continuation |
// note from the previous cell annotation. We're not yet handling this, so annotations longer than the |
// max 2048 bytes will probably throw a wobbly. |
$row = self::_GetInt2d($recordData, 0); |
$extension = true; |
$cellAddress = array_pop(array_keys($this->_phpSheet->getComments())); |
} |
// echo 'Note Address=',$cellAddress,'<br />'; |
$cellAddress = str_replace('$','',$cellAddress); |
$noteLength = self::_GetInt2d($recordData, 4); |
$noteText = trim(substr($recordData, 6)); |
// echo 'Note Length=',$noteLength,'<br />'; |
// echo 'Note Text=',$noteText,'<br />'; |
if ($extension) { |
// Concatenate this extension with the currently set comment for the cell |
$comment = $this->_phpSheet->getComment( $cellAddress ); |
$commentText = $comment->getText()->getPlainText(); |
$comment->setText($this->_parseRichText($commentText.$noteText) ); |
} else { |
// Set comment for the cell |
$this->_phpSheet->getComment( $cellAddress ) |
// ->setAuthor( $author ) |
->setText($this->_parseRichText($noteText) ); |
} |
} |
} |
/** |
* The TEXT Object record contains the text associated with a cell annotation. |
*/ |
private function _readTextObject() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
if ($this->_readDataOnly) { |
return; |
} |
// recordData consists of an array of subrecords looking like this: |
// grbit: 2 bytes; Option Flags |
// rot: 2 bytes; rotation |
// cchText: 2 bytes; length of the text (in the first continue record) |
// cbRuns: 2 bytes; length of the formatting (in the second continue record) |
// followed by the continuation records containing the actual text and formatting |
$grbitOpts = self::_GetInt2d($recordData, 0); |
$rot = self::_GetInt2d($recordData, 2); |
$cchText = self::_GetInt2d($recordData, 10); |
$cbRuns = self::_GetInt2d($recordData, 12); |
$text = $this->_getSplicedRecordData(); |
$this->_textObjects[$this->textObjRef] = array( |
'text' => substr($text["recordData"],$text["spliceOffsets"][0]+1,$cchText), |
'format' => substr($text["recordData"],$text["spliceOffsets"][1],$cbRuns), |
'alignment' => $grbitOpts, |
'rotation' => $rot |
); |
// echo '<b>_readTextObject()</b><br />'; |
// var_dump($this->_textObjects[$this->textObjRef]); |
// echo '<br />'; |
} |
/** |
* Read BOF |
*/ |
private function _readBof() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
// offset: 2; size: 2; type of the following data |
$substreamType = self::_GetInt2d($recordData, 2); |
switch ($substreamType) { |
case self::XLS_WorkbookGlobals: |
$version = self::_GetInt2d($recordData, 0); |
if (($version != self::XLS_BIFF8) && ($version != self::XLS_BIFF7)) { |
throw new PHPExcel_Reader_Exception('Cannot read this Excel file. Version is too old.'); |
} |
$this->_version = $version; |
break; |
case self::XLS_Worksheet: |
// do not use this version information for anything |
// it is unreliable (OpenOffice doc, 5.8), use only version information from the global stream |
break; |
default: |
// substream, e.g. chart |
// just skip the entire substream |
do { |
$code = self::_GetInt2d($this->_data, $this->_pos); |
$this->_readDefault(); |
} while ($code != self::XLS_Type_EOF && $this->_pos < $this->_dataSize); |
break; |
} |
} |
/** |
* FILEPASS |
* |
* This record is part of the File Protection Block. It |
* contains information about the read/write password of the |
* file. All record contents following this record will be |
* encrypted. |
* |
* -- "OpenOffice.org's Documentation of the Microsoft |
* Excel File Format" |
*/ |
private function _readFilepass() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
// $recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
throw new PHPExcel_Reader_Exception('Cannot read encrypted file'); |
} |
/** |
* CODEPAGE |
* |
* This record stores the text encoding used to write byte |
* strings, stored as MS Windows code page identifier. |
* |
* -- "OpenOffice.org's Documentation of the Microsoft |
* Excel File Format" |
*/ |
private function _readCodepage() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
// offset: 0; size: 2; code page identifier |
$codepage = self::_GetInt2d($recordData, 0); |
$this->_codepage = PHPExcel_Shared_CodePage::NumberToName($codepage); |
} |
/** |
* DATEMODE |
* |
* This record specifies the base date for displaying date |
* values. All dates are stored as count of days past this |
* base date. In BIFF2-BIFF4 this record is part of the |
* Calculation Settings Block. In BIFF5-BIFF8 it is |
* stored in the Workbook Globals Substream. |
* |
* -- "OpenOffice.org's Documentation of the Microsoft |
* Excel File Format" |
*/ |
private function _readDateMode() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
// offset: 0; size: 2; 0 = base 1900, 1 = base 1904 |
PHPExcel_Shared_Date::setExcelCalendar(PHPExcel_Shared_Date::CALENDAR_WINDOWS_1900); |
if (ord($recordData{0}) == 1) { |
PHPExcel_Shared_Date::setExcelCalendar(PHPExcel_Shared_Date::CALENDAR_MAC_1904); |
} |
} |
/** |
* Read a FONT record |
*/ |
private function _readFont() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
if (!$this->_readDataOnly) { |
$objFont = new PHPExcel_Style_Font(); |
// offset: 0; size: 2; height of the font (in twips = 1/20 of a point) |
$size = self::_GetInt2d($recordData, 0); |
$objFont->setSize($size / 20); |
// offset: 2; size: 2; option flags |
// bit: 0; mask 0x0001; bold (redundant in BIFF5-BIFF8) |
// bit: 1; mask 0x0002; italic |
$isItalic = (0x0002 & self::_GetInt2d($recordData, 2)) >> 1; |
if ($isItalic) $objFont->setItalic(true); |
// bit: 2; mask 0x0004; underlined (redundant in BIFF5-BIFF8) |
// bit: 3; mask 0x0008; strike |
$isStrike = (0x0008 & self::_GetInt2d($recordData, 2)) >> 3; |
if ($isStrike) $objFont->setStrikethrough(true); |
// offset: 4; size: 2; colour index |
$colorIndex = self::_GetInt2d($recordData, 4); |
$objFont->colorIndex = $colorIndex; |
// offset: 6; size: 2; font weight |
$weight = self::_GetInt2d($recordData, 6); |
switch ($weight) { |
case 0x02BC: |
$objFont->setBold(true); |
break; |
} |
// offset: 8; size: 2; escapement type |
$escapement = self::_GetInt2d($recordData, 8); |
switch ($escapement) { |
case 0x0001: |
$objFont->setSuperScript(true); |
break; |
case 0x0002: |
$objFont->setSubScript(true); |
break; |
} |
// offset: 10; size: 1; underline type |
$underlineType = ord($recordData{10}); |
switch ($underlineType) { |
case 0x00: |
break; // no underline |
case 0x01: |
$objFont->setUnderline(PHPExcel_Style_Font::UNDERLINE_SINGLE); |
break; |
case 0x02: |
$objFont->setUnderline(PHPExcel_Style_Font::UNDERLINE_DOUBLE); |
break; |
case 0x21: |
$objFont->setUnderline(PHPExcel_Style_Font::UNDERLINE_SINGLEACCOUNTING); |
break; |
case 0x22: |
$objFont->setUnderline(PHPExcel_Style_Font::UNDERLINE_DOUBLEACCOUNTING); |
break; |
} |
// offset: 11; size: 1; font family |
// offset: 12; size: 1; character set |
// offset: 13; size: 1; not used |
// offset: 14; size: var; font name |
if ($this->_version == self::XLS_BIFF8) { |
$string = self::_readUnicodeStringShort(substr($recordData, 14)); |
} else { |
$string = $this->_readByteStringShort(substr($recordData, 14)); |
} |
$objFont->setName($string['value']); |
$this->_objFonts[] = $objFont; |
} |
} |
/** |
* FORMAT |
* |
* This record contains information about a number format. |
* All FORMAT records occur together in a sequential list. |
* |
* In BIFF2-BIFF4 other records referencing a FORMAT record |
* contain a zero-based index into this list. From BIFF5 on |
* the FORMAT record contains the index itself that will be |
* used by other records. |
* |
* -- "OpenOffice.org's Documentation of the Microsoft |
* Excel File Format" |
*/ |
private function _readFormat() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
if (!$this->_readDataOnly) { |
$indexCode = self::_GetInt2d($recordData, 0); |
if ($this->_version == self::XLS_BIFF8) { |
$string = self::_readUnicodeStringLong(substr($recordData, 2)); |
} else { |
// BIFF7 |
$string = $this->_readByteStringShort(substr($recordData, 2)); |
} |
$formatString = $string['value']; |
$this->_formats[$indexCode] = $formatString; |
} |
} |
/** |
* XF - Extended Format |
* |
* This record contains formatting information for cells, rows, columns or styles. |
* According to http://support.microsoft.com/kb/147732 there are always at least 15 cell style XF |
* and 1 cell XF. |
* Inspection of Excel files generated by MS Office Excel shows that XF records 0-14 are cell style XF |
* and XF record 15 is a cell XF |
* We only read the first cell style XF and skip the remaining cell style XF records |
* We read all cell XF records. |
* |
* -- "OpenOffice.org's Documentation of the Microsoft |
* Excel File Format" |
*/ |
private function _readXf() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
$objStyle = new PHPExcel_Style(); |
if (!$this->_readDataOnly) { |
// offset: 0; size: 2; Index to FONT record |
if (self::_GetInt2d($recordData, 0) < 4) { |
$fontIndex = self::_GetInt2d($recordData, 0); |
} else { |
// this has to do with that index 4 is omitted in all BIFF versions for some strange reason |
// check the OpenOffice documentation of the FONT record |
$fontIndex = self::_GetInt2d($recordData, 0) - 1; |
} |
$objStyle->setFont($this->_objFonts[$fontIndex]); |
// offset: 2; size: 2; Index to FORMAT record |
$numberFormatIndex = self::_GetInt2d($recordData, 2); |
if (isset($this->_formats[$numberFormatIndex])) { |
// then we have user-defined format code |
$numberformat = array('code' => $this->_formats[$numberFormatIndex]); |
} elseif (($code = PHPExcel_Style_NumberFormat::builtInFormatCode($numberFormatIndex)) !== '') { |
// then we have built-in format code |
$numberformat = array('code' => $code); |
} else { |
// we set the general format code |
$numberformat = array('code' => 'General'); |
} |
$objStyle->getNumberFormat()->setFormatCode($numberformat['code']); |
// offset: 4; size: 2; XF type, cell protection, and parent style XF |
// bit 2-0; mask 0x0007; XF_TYPE_PROT |
$xfTypeProt = self::_GetInt2d($recordData, 4); |
// bit 0; mask 0x01; 1 = cell is locked |
$isLocked = (0x01 & $xfTypeProt) >> 0; |
$objStyle->getProtection()->setLocked($isLocked ? |
PHPExcel_Style_Protection::PROTECTION_INHERIT : PHPExcel_Style_Protection::PROTECTION_UNPROTECTED); |
// bit 1; mask 0x02; 1 = Formula is hidden |
$isHidden = (0x02 & $xfTypeProt) >> 1; |
$objStyle->getProtection()->setHidden($isHidden ? |
PHPExcel_Style_Protection::PROTECTION_PROTECTED : PHPExcel_Style_Protection::PROTECTION_UNPROTECTED); |
// bit 2; mask 0x04; 0 = Cell XF, 1 = Cell Style XF |
$isCellStyleXf = (0x04 & $xfTypeProt) >> 2; |
// offset: 6; size: 1; Alignment and text break |
// bit 2-0, mask 0x07; horizontal alignment |
$horAlign = (0x07 & ord($recordData{6})) >> 0; |
switch ($horAlign) { |
case 0: |
$objStyle->getAlignment()->setHorizontal(PHPExcel_Style_Alignment::HORIZONTAL_GENERAL); |
break; |
case 1: |
$objStyle->getAlignment()->setHorizontal(PHPExcel_Style_Alignment::HORIZONTAL_LEFT); |
break; |
case 2: |
$objStyle->getAlignment()->setHorizontal(PHPExcel_Style_Alignment::HORIZONTAL_CENTER); |
break; |
case 3: |
$objStyle->getAlignment()->setHorizontal(PHPExcel_Style_Alignment::HORIZONTAL_RIGHT); |
break; |
case 5: |
$objStyle->getAlignment()->setHorizontal(PHPExcel_Style_Alignment::HORIZONTAL_JUSTIFY); |
break; |
case 6: |
$objStyle->getAlignment()->setHorizontal(PHPExcel_Style_Alignment::HORIZONTAL_CENTER_CONTINUOUS); |
break; |
} |
// bit 3, mask 0x08; wrap text |
$wrapText = (0x08 & ord($recordData{6})) >> 3; |
switch ($wrapText) { |
case 0: |
$objStyle->getAlignment()->setWrapText(false); |
break; |
case 1: |
$objStyle->getAlignment()->setWrapText(true); |
break; |
} |
// bit 6-4, mask 0x70; vertical alignment |
$vertAlign = (0x70 & ord($recordData{6})) >> 4; |
switch ($vertAlign) { |
case 0: |
$objStyle->getAlignment()->setVertical(PHPExcel_Style_Alignment::VERTICAL_TOP); |
break; |
case 1: |
$objStyle->getAlignment()->setVertical(PHPExcel_Style_Alignment::VERTICAL_CENTER); |
break; |
case 2: |
$objStyle->getAlignment()->setVertical(PHPExcel_Style_Alignment::VERTICAL_BOTTOM); |
break; |
case 3: |
$objStyle->getAlignment()->setVertical(PHPExcel_Style_Alignment::VERTICAL_JUSTIFY); |
break; |
} |
if ($this->_version == self::XLS_BIFF8) { |
// offset: 7; size: 1; XF_ROTATION: Text rotation angle |
$angle = ord($recordData{7}); |
$rotation = 0; |
if ($angle <= 90) { |
$rotation = $angle; |
} else if ($angle <= 180) { |
$rotation = 90 - $angle; |
} else if ($angle == 255) { |
$rotation = -165; |
} |
$objStyle->getAlignment()->setTextRotation($rotation); |
// offset: 8; size: 1; Indentation, shrink to cell size, and text direction |
// bit: 3-0; mask: 0x0F; indent level |
$indent = (0x0F & ord($recordData{8})) >> 0; |
$objStyle->getAlignment()->setIndent($indent); |
// bit: 4; mask: 0x10; 1 = shrink content to fit into cell |
$shrinkToFit = (0x10 & ord($recordData{8})) >> 4; |
switch ($shrinkToFit) { |
case 0: |
$objStyle->getAlignment()->setShrinkToFit(false); |
break; |
case 1: |
$objStyle->getAlignment()->setShrinkToFit(true); |
break; |
} |
// offset: 9; size: 1; Flags used for attribute groups |
// offset: 10; size: 4; Cell border lines and background area |
// bit: 3-0; mask: 0x0000000F; left style |
if ($bordersLeftStyle = self::_mapBorderStyle((0x0000000F & self::_GetInt4d($recordData, 10)) >> 0)) { |
$objStyle->getBorders()->getLeft()->setBorderStyle($bordersLeftStyle); |
} |
// bit: 7-4; mask: 0x000000F0; right style |
if ($bordersRightStyle = self::_mapBorderStyle((0x000000F0 & self::_GetInt4d($recordData, 10)) >> 4)) { |
$objStyle->getBorders()->getRight()->setBorderStyle($bordersRightStyle); |
} |
// bit: 11-8; mask: 0x00000F00; top style |
if ($bordersTopStyle = self::_mapBorderStyle((0x00000F00 & self::_GetInt4d($recordData, 10)) >> 8)) { |
$objStyle->getBorders()->getTop()->setBorderStyle($bordersTopStyle); |
} |
// bit: 15-12; mask: 0x0000F000; bottom style |
if ($bordersBottomStyle = self::_mapBorderStyle((0x0000F000 & self::_GetInt4d($recordData, 10)) >> 12)) { |
$objStyle->getBorders()->getBottom()->setBorderStyle($bordersBottomStyle); |
} |
// bit: 22-16; mask: 0x007F0000; left color |
$objStyle->getBorders()->getLeft()->colorIndex = (0x007F0000 & self::_GetInt4d($recordData, 10)) >> 16; |
// bit: 29-23; mask: 0x3F800000; right color |
$objStyle->getBorders()->getRight()->colorIndex = (0x3F800000 & self::_GetInt4d($recordData, 10)) >> 23; |
// bit: 30; mask: 0x40000000; 1 = diagonal line from top left to right bottom |
$diagonalDown = (0x40000000 & self::_GetInt4d($recordData, 10)) >> 30 ? |
true : false; |
// bit: 31; mask: 0x80000000; 1 = diagonal line from bottom left to top right |
$diagonalUp = (0x80000000 & self::_GetInt4d($recordData, 10)) >> 31 ? |
true : false; |
if ($diagonalUp == false && $diagonalDown == false) { |
$objStyle->getBorders()->setDiagonalDirection(PHPExcel_Style_Borders::DIAGONAL_NONE); |
} elseif ($diagonalUp == true && $diagonalDown == false) { |
$objStyle->getBorders()->setDiagonalDirection(PHPExcel_Style_Borders::DIAGONAL_UP); |
} elseif ($diagonalUp == false && $diagonalDown == true) { |
$objStyle->getBorders()->setDiagonalDirection(PHPExcel_Style_Borders::DIAGONAL_DOWN); |
} elseif ($diagonalUp == true && $diagonalDown == true) { |
$objStyle->getBorders()->setDiagonalDirection(PHPExcel_Style_Borders::DIAGONAL_BOTH); |
} |
// offset: 14; size: 4; |
// bit: 6-0; mask: 0x0000007F; top color |
$objStyle->getBorders()->getTop()->colorIndex = (0x0000007F & self::_GetInt4d($recordData, 14)) >> 0; |
// bit: 13-7; mask: 0x00003F80; bottom color |
$objStyle->getBorders()->getBottom()->colorIndex = (0x00003F80 & self::_GetInt4d($recordData, 14)) >> 7; |
// bit: 20-14; mask: 0x001FC000; diagonal color |
$objStyle->getBorders()->getDiagonal()->colorIndex = (0x001FC000 & self::_GetInt4d($recordData, 14)) >> 14; |
// bit: 24-21; mask: 0x01E00000; diagonal style |
if ($bordersDiagonalStyle = self::_mapBorderStyle((0x01E00000 & self::_GetInt4d($recordData, 14)) >> 21)) { |
$objStyle->getBorders()->getDiagonal()->setBorderStyle($bordersDiagonalStyle); |
} |
// bit: 31-26; mask: 0xFC000000 fill pattern |
if ($fillType = self::_mapFillPattern((0xFC000000 & self::_GetInt4d($recordData, 14)) >> 26)) { |
$objStyle->getFill()->setFillType($fillType); |
} |
// offset: 18; size: 2; pattern and background colour |
// bit: 6-0; mask: 0x007F; color index for pattern color |
$objStyle->getFill()->startcolorIndex = (0x007F & self::_GetInt2d($recordData, 18)) >> 0; |
// bit: 13-7; mask: 0x3F80; color index for pattern background |
$objStyle->getFill()->endcolorIndex = (0x3F80 & self::_GetInt2d($recordData, 18)) >> 7; |
} else { |
// BIFF5 |
// offset: 7; size: 1; Text orientation and flags |
$orientationAndFlags = ord($recordData{7}); |
// bit: 1-0; mask: 0x03; XF_ORIENTATION: Text orientation |
$xfOrientation = (0x03 & $orientationAndFlags) >> 0; |
switch ($xfOrientation) { |
case 0: |
$objStyle->getAlignment()->setTextRotation(0); |
break; |
case 1: |
$objStyle->getAlignment()->setTextRotation(-165); |
break; |
case 2: |
$objStyle->getAlignment()->setTextRotation(90); |
break; |
case 3: |
$objStyle->getAlignment()->setTextRotation(-90); |
break; |
} |
// offset: 8; size: 4; cell border lines and background area |
$borderAndBackground = self::_GetInt4d($recordData, 8); |
// bit: 6-0; mask: 0x0000007F; color index for pattern color |
$objStyle->getFill()->startcolorIndex = (0x0000007F & $borderAndBackground) >> 0; |
// bit: 13-7; mask: 0x00003F80; color index for pattern background |
$objStyle->getFill()->endcolorIndex = (0x00003F80 & $borderAndBackground) >> 7; |
// bit: 21-16; mask: 0x003F0000; fill pattern |
$objStyle->getFill()->setFillType(self::_mapFillPattern((0x003F0000 & $borderAndBackground) >> 16)); |
// bit: 24-22; mask: 0x01C00000; bottom line style |
$objStyle->getBorders()->getBottom()->setBorderStyle(self::_mapBorderStyle((0x01C00000 & $borderAndBackground) >> 22)); |
// bit: 31-25; mask: 0xFE000000; bottom line color |
$objStyle->getBorders()->getBottom()->colorIndex = (0xFE000000 & $borderAndBackground) >> 25; |
// offset: 12; size: 4; cell border lines |
$borderLines = self::_GetInt4d($recordData, 12); |
// bit: 2-0; mask: 0x00000007; top line style |
$objStyle->getBorders()->getTop()->setBorderStyle(self::_mapBorderStyle((0x00000007 & $borderLines) >> 0)); |
// bit: 5-3; mask: 0x00000038; left line style |
$objStyle->getBorders()->getLeft()->setBorderStyle(self::_mapBorderStyle((0x00000038 & $borderLines) >> 3)); |
// bit: 8-6; mask: 0x000001C0; right line style |
$objStyle->getBorders()->getRight()->setBorderStyle(self::_mapBorderStyle((0x000001C0 & $borderLines) >> 6)); |
// bit: 15-9; mask: 0x0000FE00; top line color index |
$objStyle->getBorders()->getTop()->colorIndex = (0x0000FE00 & $borderLines) >> 9; |
// bit: 22-16; mask: 0x007F0000; left line color index |
$objStyle->getBorders()->getLeft()->colorIndex = (0x007F0000 & $borderLines) >> 16; |
// bit: 29-23; mask: 0x3F800000; right line color index |
$objStyle->getBorders()->getRight()->colorIndex = (0x3F800000 & $borderLines) >> 23; |
} |
// add cellStyleXf or cellXf and update mapping |
if ($isCellStyleXf) { |
// we only read one style XF record which is always the first |
if ($this->_xfIndex == 0) { |
$this->_phpExcel->addCellStyleXf($objStyle); |
$this->_mapCellStyleXfIndex[$this->_xfIndex] = 0; |
} |
} else { |
// we read all cell XF records |
$this->_phpExcel->addCellXf($objStyle); |
$this->_mapCellXfIndex[$this->_xfIndex] = count($this->_phpExcel->getCellXfCollection()) - 1; |
} |
// update XF index for when we read next record |
++$this->_xfIndex; |
} |
} |
/** |
* |
*/ |
private function _readXfExt() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
if (!$this->_readDataOnly) { |
// offset: 0; size: 2; 0x087D = repeated header |
// offset: 2; size: 2 |
// offset: 4; size: 8; not used |
// offset: 12; size: 2; record version |
// offset: 14; size: 2; index to XF record which this record modifies |
$ixfe = self::_GetInt2d($recordData, 14); |
// offset: 16; size: 2; not used |
// offset: 18; size: 2; number of extension properties that follow |
$cexts = self::_GetInt2d($recordData, 18); |
// start reading the actual extension data |
$offset = 20; |
while ($offset < $length) { |
// extension type |
$extType = self::_GetInt2d($recordData, $offset); |
// extension length |
$cb = self::_GetInt2d($recordData, $offset + 2); |
// extension data |
$extData = substr($recordData, $offset + 4, $cb); |
switch ($extType) { |
case 4: // fill start color |
$xclfType = self::_GetInt2d($extData, 0); // color type |
$xclrValue = substr($extData, 4, 4); // color value (value based on color type) |
if ($xclfType == 2) { |
$rgb = sprintf('%02X%02X%02X', ord($xclrValue{0}), ord($xclrValue{1}), ord($xclrValue{2})); |
// modify the relevant style property |
if ( isset($this->_mapCellXfIndex[$ixfe]) ) { |
$fill = $this->_phpExcel->getCellXfByIndex($this->_mapCellXfIndex[$ixfe])->getFill(); |
$fill->getStartColor()->setRGB($rgb); |
unset($fill->startcolorIndex); // normal color index does not apply, discard |
} |
} |
break; |
case 5: // fill end color |
$xclfType = self::_GetInt2d($extData, 0); // color type |
$xclrValue = substr($extData, 4, 4); // color value (value based on color type) |
if ($xclfType == 2) { |
$rgb = sprintf('%02X%02X%02X', ord($xclrValue{0}), ord($xclrValue{1}), ord($xclrValue{2})); |
// modify the relevant style property |
if ( isset($this->_mapCellXfIndex[$ixfe]) ) { |
$fill = $this->_phpExcel->getCellXfByIndex($this->_mapCellXfIndex[$ixfe])->getFill(); |
$fill->getEndColor()->setRGB($rgb); |
unset($fill->endcolorIndex); // normal color index does not apply, discard |
} |
} |
break; |
case 7: // border color top |
$xclfType = self::_GetInt2d($extData, 0); // color type |
$xclrValue = substr($extData, 4, 4); // color value (value based on color type) |
if ($xclfType == 2) { |
$rgb = sprintf('%02X%02X%02X', ord($xclrValue{0}), ord($xclrValue{1}), ord($xclrValue{2})); |
// modify the relevant style property |
if ( isset($this->_mapCellXfIndex[$ixfe]) ) { |
$top = $this->_phpExcel->getCellXfByIndex($this->_mapCellXfIndex[$ixfe])->getBorders()->getTop(); |
$top->getColor()->setRGB($rgb); |
unset($top->colorIndex); // normal color index does not apply, discard |
} |
} |
break; |
case 8: // border color bottom |
$xclfType = self::_GetInt2d($extData, 0); // color type |
$xclrValue = substr($extData, 4, 4); // color value (value based on color type) |
if ($xclfType == 2) { |
$rgb = sprintf('%02X%02X%02X', ord($xclrValue{0}), ord($xclrValue{1}), ord($xclrValue{2})); |
// modify the relevant style property |
if ( isset($this->_mapCellXfIndex[$ixfe]) ) { |
$bottom = $this->_phpExcel->getCellXfByIndex($this->_mapCellXfIndex[$ixfe])->getBorders()->getBottom(); |
$bottom->getColor()->setRGB($rgb); |
unset($bottom->colorIndex); // normal color index does not apply, discard |
} |
} |
break; |
case 9: // border color left |
$xclfType = self::_GetInt2d($extData, 0); // color type |
$xclrValue = substr($extData, 4, 4); // color value (value based on color type) |
if ($xclfType == 2) { |
$rgb = sprintf('%02X%02X%02X', ord($xclrValue{0}), ord($xclrValue{1}), ord($xclrValue{2})); |
// modify the relevant style property |
if ( isset($this->_mapCellXfIndex[$ixfe]) ) { |
$left = $this->_phpExcel->getCellXfByIndex($this->_mapCellXfIndex[$ixfe])->getBorders()->getLeft(); |
$left->getColor()->setRGB($rgb); |
unset($left->colorIndex); // normal color index does not apply, discard |
} |
} |
break; |
case 10: // border color right |
$xclfType = self::_GetInt2d($extData, 0); // color type |
$xclrValue = substr($extData, 4, 4); // color value (value based on color type) |
if ($xclfType == 2) { |
$rgb = sprintf('%02X%02X%02X', ord($xclrValue{0}), ord($xclrValue{1}), ord($xclrValue{2})); |
// modify the relevant style property |
if ( isset($this->_mapCellXfIndex[$ixfe]) ) { |
$right = $this->_phpExcel->getCellXfByIndex($this->_mapCellXfIndex[$ixfe])->getBorders()->getRight(); |
$right->getColor()->setRGB($rgb); |
unset($right->colorIndex); // normal color index does not apply, discard |
} |
} |
break; |
case 11: // border color diagonal |
$xclfType = self::_GetInt2d($extData, 0); // color type |
$xclrValue = substr($extData, 4, 4); // color value (value based on color type) |
if ($xclfType == 2) { |
$rgb = sprintf('%02X%02X%02X', ord($xclrValue{0}), ord($xclrValue{1}), ord($xclrValue{2})); |
// modify the relevant style property |
if ( isset($this->_mapCellXfIndex[$ixfe]) ) { |
$diagonal = $this->_phpExcel->getCellXfByIndex($this->_mapCellXfIndex[$ixfe])->getBorders()->getDiagonal(); |
$diagonal->getColor()->setRGB($rgb); |
unset($diagonal->colorIndex); // normal color index does not apply, discard |
} |
} |
break; |
case 13: // font color |
$xclfType = self::_GetInt2d($extData, 0); // color type |
$xclrValue = substr($extData, 4, 4); // color value (value based on color type) |
if ($xclfType == 2) { |
$rgb = sprintf('%02X%02X%02X', ord($xclrValue{0}), ord($xclrValue{1}), ord($xclrValue{2})); |
// modify the relevant style property |
if ( isset($this->_mapCellXfIndex[$ixfe]) ) { |
$font = $this->_phpExcel->getCellXfByIndex($this->_mapCellXfIndex[$ixfe])->getFont(); |
$font->getColor()->setRGB($rgb); |
unset($font->colorIndex); // normal color index does not apply, discard |
} |
} |
break; |
} |
$offset += $cb; |
} |
} |
} |
/** |
* Read STYLE record |
*/ |
private function _readStyle() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
if (!$this->_readDataOnly) { |
// offset: 0; size: 2; index to XF record and flag for built-in style |
$ixfe = self::_GetInt2d($recordData, 0); |
// bit: 11-0; mask 0x0FFF; index to XF record |
$xfIndex = (0x0FFF & $ixfe) >> 0; |
// bit: 15; mask 0x8000; 0 = user-defined style, 1 = built-in style |
$isBuiltIn = (bool) ((0x8000 & $ixfe) >> 15); |
if ($isBuiltIn) { |
// offset: 2; size: 1; identifier for built-in style |
$builtInId = ord($recordData{2}); |
switch ($builtInId) { |
case 0x00: |
// currently, we are not using this for anything |
break; |
default: |
break; |
} |
} else { |
// user-defined; not supported by PHPExcel |
} |
} |
} |
/** |
* Read PALETTE record |
*/ |
private function _readPalette() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
if (!$this->_readDataOnly) { |
// offset: 0; size: 2; number of following colors |
$nm = self::_GetInt2d($recordData, 0); |
// list of RGB colors |
for ($i = 0; $i < $nm; ++$i) { |
$rgb = substr($recordData, 2 + 4 * $i, 4); |
$this->_palette[] = self::_readRGB($rgb); |
} |
} |
} |
/** |
* SHEET |
* |
* This record is located in the Workbook Globals |
* Substream and represents a sheet inside the workbook. |
* One SHEET record is written for each sheet. It stores the |
* sheet name and a stream offset to the BOF record of the |
* respective Sheet Substream within the Workbook Stream. |
* |
* -- "OpenOffice.org's Documentation of the Microsoft |
* Excel File Format" |
*/ |
private function _readSheet() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
// offset: 0; size: 4; absolute stream position of the BOF record of the sheet |
$rec_offset = self::_GetInt4d($recordData, 0); |
// offset: 4; size: 1; sheet state |
switch (ord($recordData{4})) { |
case 0x00: $sheetState = PHPExcel_Worksheet::SHEETSTATE_VISIBLE; break; |
case 0x01: $sheetState = PHPExcel_Worksheet::SHEETSTATE_HIDDEN; break; |
case 0x02: $sheetState = PHPExcel_Worksheet::SHEETSTATE_VERYHIDDEN; break; |
default: $sheetState = PHPExcel_Worksheet::SHEETSTATE_VISIBLE; break; |
} |
// offset: 5; size: 1; sheet type |
$sheetType = ord($recordData{5}); |
// offset: 6; size: var; sheet name |
if ($this->_version == self::XLS_BIFF8) { |
$string = self::_readUnicodeStringShort(substr($recordData, 6)); |
$rec_name = $string['value']; |
} elseif ($this->_version == self::XLS_BIFF7) { |
$string = $this->_readByteStringShort(substr($recordData, 6)); |
$rec_name = $string['value']; |
} |
$this->_sheets[] = array( |
'name' => $rec_name, |
'offset' => $rec_offset, |
'sheetState' => $sheetState, |
'sheetType' => $sheetType, |
); |
} |
/** |
* Read EXTERNALBOOK record |
*/ |
private function _readExternalBook() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
// offset within record data |
$offset = 0; |
// there are 4 types of records |
if (strlen($recordData) > 4) { |
// external reference |
// offset: 0; size: 2; number of sheet names ($nm) |
$nm = self::_GetInt2d($recordData, 0); |
$offset += 2; |
// offset: 2; size: var; encoded URL without sheet name (Unicode string, 16-bit length) |
$encodedUrlString = self::_readUnicodeStringLong(substr($recordData, 2)); |
$offset += $encodedUrlString['size']; |
// offset: var; size: var; list of $nm sheet names (Unicode strings, 16-bit length) |
$externalSheetNames = array(); |
for ($i = 0; $i < $nm; ++$i) { |
$externalSheetNameString = self::_readUnicodeStringLong(substr($recordData, $offset)); |
$externalSheetNames[] = $externalSheetNameString['value']; |
$offset += $externalSheetNameString['size']; |
} |
// store the record data |
$this->_externalBooks[] = array( |
'type' => 'external', |
'encodedUrl' => $encodedUrlString['value'], |
'externalSheetNames' => $externalSheetNames, |
); |
} elseif (substr($recordData, 2, 2) == pack('CC', 0x01, 0x04)) { |
// internal reference |
// offset: 0; size: 2; number of sheet in this document |
// offset: 2; size: 2; 0x01 0x04 |
$this->_externalBooks[] = array( |
'type' => 'internal', |
); |
} elseif (substr($recordData, 0, 4) == pack('vCC', 0x0001, 0x01, 0x3A)) { |
// add-in function |
// offset: 0; size: 2; 0x0001 |
$this->_externalBooks[] = array( |
'type' => 'addInFunction', |
); |
} elseif (substr($recordData, 0, 2) == pack('v', 0x0000)) { |
// DDE links, OLE links |
// offset: 0; size: 2; 0x0000 |
// offset: 2; size: var; encoded source document name |
$this->_externalBooks[] = array( |
'type' => 'DDEorOLE', |
); |
} |
} |
/** |
* Read EXTERNNAME record. |
*/ |
private function _readExternName() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
// external sheet references provided for named cells |
if ($this->_version == self::XLS_BIFF8) { |
// offset: 0; size: 2; options |
$options = self::_GetInt2d($recordData, 0); |
// offset: 2; size: 2; |
// offset: 4; size: 2; not used |
// offset: 6; size: var |
$nameString = self::_readUnicodeStringShort(substr($recordData, 6)); |
// offset: var; size: var; formula data |
$offset = 6 + $nameString['size']; |
$formula = $this->_getFormulaFromStructure(substr($recordData, $offset)); |
$this->_externalNames[] = array( |
'name' => $nameString['value'], |
'formula' => $formula, |
); |
} |
} |
/** |
* Read EXTERNSHEET record |
*/ |
private function _readExternSheet() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
// external sheet references provided for named cells |
if ($this->_version == self::XLS_BIFF8) { |
// offset: 0; size: 2; number of following ref structures |
$nm = self::_GetInt2d($recordData, 0); |
for ($i = 0; $i < $nm; ++$i) { |
$this->_ref[] = array( |
// offset: 2 + 6 * $i; index to EXTERNALBOOK record |
'externalBookIndex' => self::_GetInt2d($recordData, 2 + 6 * $i), |
// offset: 4 + 6 * $i; index to first sheet in EXTERNALBOOK record |
'firstSheetIndex' => self::_GetInt2d($recordData, 4 + 6 * $i), |
// offset: 6 + 6 * $i; index to last sheet in EXTERNALBOOK record |
'lastSheetIndex' => self::_GetInt2d($recordData, 6 + 6 * $i), |
); |
} |
} |
} |
/** |
* DEFINEDNAME |
* |
* This record is part of a Link Table. It contains the name |
* and the token array of an internal defined name. Token |
* arrays of defined names contain tokens with aberrant |
* token classes. |
* |
* -- "OpenOffice.org's Documentation of the Microsoft |
* Excel File Format" |
*/ |
private function _readDefinedName() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
if ($this->_version == self::XLS_BIFF8) { |
// retrieves named cells |
// offset: 0; size: 2; option flags |
$opts = self::_GetInt2d($recordData, 0); |
// bit: 5; mask: 0x0020; 0 = user-defined name, 1 = built-in-name |
$isBuiltInName = (0x0020 & $opts) >> 5; |
// offset: 2; size: 1; keyboard shortcut |
// offset: 3; size: 1; length of the name (character count) |
$nlen = ord($recordData{3}); |
// offset: 4; size: 2; size of the formula data (it can happen that this is zero) |
// note: there can also be additional data, this is not included in $flen |
$flen = self::_GetInt2d($recordData, 4); |
// offset: 8; size: 2; 0=Global name, otherwise index to sheet (1-based) |
$scope = self::_GetInt2d($recordData, 8); |
// offset: 14; size: var; Name (Unicode string without length field) |
$string = self::_readUnicodeString(substr($recordData, 14), $nlen); |
// offset: var; size: $flen; formula data |
$offset = 14 + $string['size']; |
$formulaStructure = pack('v', $flen) . substr($recordData, $offset); |
try { |
$formula = $this->_getFormulaFromStructure($formulaStructure); |
} catch (PHPExcel_Exception $e) { |
$formula = ''; |
} |
$this->_definedname[] = array( |
'isBuiltInName' => $isBuiltInName, |
'name' => $string['value'], |
'formula' => $formula, |
'scope' => $scope, |
); |
} |
} |
/** |
* Read MSODRAWINGGROUP record |
*/ |
private function _readMsoDrawingGroup() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
// get spliced record data |
$splicedRecordData = $this->_getSplicedRecordData(); |
$recordData = $splicedRecordData['recordData']; |
$this->_drawingGroupData .= $recordData; |
} |
/** |
* SST - Shared String Table |
* |
* This record contains a list of all strings used anywhere |
* in the workbook. Each string occurs only once. The |
* workbook uses indexes into the list to reference the |
* strings. |
* |
* -- "OpenOffice.org's Documentation of the Microsoft |
* Excel File Format" |
**/ |
private function _readSst() |
{ |
// offset within (spliced) record data |
$pos = 0; |
// get spliced record data |
$splicedRecordData = $this->_getSplicedRecordData(); |
$recordData = $splicedRecordData['recordData']; |
$spliceOffsets = $splicedRecordData['spliceOffsets']; |
// offset: 0; size: 4; total number of strings in the workbook |
$pos += 4; |
// offset: 4; size: 4; number of following strings ($nm) |
$nm = self::_GetInt4d($recordData, 4); |
$pos += 4; |
// loop through the Unicode strings (16-bit length) |
for ($i = 0; $i < $nm; ++$i) { |
// number of characters in the Unicode string |
$numChars = self::_GetInt2d($recordData, $pos); |
$pos += 2; |
// option flags |
$optionFlags = ord($recordData{$pos}); |
++$pos; |
// bit: 0; mask: 0x01; 0 = compressed; 1 = uncompressed |
$isCompressed = (($optionFlags & 0x01) == 0) ; |
// bit: 2; mask: 0x02; 0 = ordinary; 1 = Asian phonetic |
$hasAsian = (($optionFlags & 0x04) != 0); |
// bit: 3; mask: 0x03; 0 = ordinary; 1 = Rich-Text |
$hasRichText = (($optionFlags & 0x08) != 0); |
if ($hasRichText) { |
// number of Rich-Text formatting runs |
$formattingRuns = self::_GetInt2d($recordData, $pos); |
$pos += 2; |
} |
if ($hasAsian) { |
// size of Asian phonetic setting |
$extendedRunLength = self::_GetInt4d($recordData, $pos); |
$pos += 4; |
} |
// expected byte length of character array if not split |
$len = ($isCompressed) ? $numChars : $numChars * 2; |
// look up limit position |
foreach ($spliceOffsets as $spliceOffset) { |
// it can happen that the string is empty, therefore we need |
// <= and not just < |
if ($pos <= $spliceOffset) { |
$limitpos = $spliceOffset; |
break; |
} |
} |
if ($pos + $len <= $limitpos) { |
// character array is not split between records |
$retstr = substr($recordData, $pos, $len); |
$pos += $len; |
} else { |
// character array is split between records |
// first part of character array |
$retstr = substr($recordData, $pos, $limitpos - $pos); |
$bytesRead = $limitpos - $pos; |
// remaining characters in Unicode string |
$charsLeft = $numChars - (($isCompressed) ? $bytesRead : ($bytesRead / 2)); |
$pos = $limitpos; |
// keep reading the characters |
while ($charsLeft > 0) { |
// look up next limit position, in case the string span more than one continue record |
foreach ($spliceOffsets as $spliceOffset) { |
if ($pos < $spliceOffset) { |
$limitpos = $spliceOffset; |
break; |
} |
} |
// repeated option flags |
// OpenOffice.org documentation 5.21 |
$option = ord($recordData{$pos}); |
++$pos; |
if ($isCompressed && ($option == 0)) { |
// 1st fragment compressed |
// this fragment compressed |
$len = min($charsLeft, $limitpos - $pos); |
$retstr .= substr($recordData, $pos, $len); |
$charsLeft -= $len; |
$isCompressed = true; |
} elseif (!$isCompressed && ($option != 0)) { |
// 1st fragment uncompressed |
// this fragment uncompressed |
$len = min($charsLeft * 2, $limitpos - $pos); |
$retstr .= substr($recordData, $pos, $len); |
$charsLeft -= $len / 2; |
$isCompressed = false; |
} elseif (!$isCompressed && ($option == 0)) { |
// 1st fragment uncompressed |
// this fragment compressed |
$len = min($charsLeft, $limitpos - $pos); |
for ($j = 0; $j < $len; ++$j) { |
$retstr .= $recordData{$pos + $j} . chr(0); |
} |
$charsLeft -= $len; |
$isCompressed = false; |
} else { |
// 1st fragment compressed |
// this fragment uncompressed |
$newstr = ''; |
for ($j = 0; $j < strlen($retstr); ++$j) { |
$newstr .= $retstr[$j] . chr(0); |
} |
$retstr = $newstr; |
$len = min($charsLeft * 2, $limitpos - $pos); |
$retstr .= substr($recordData, $pos, $len); |
$charsLeft -= $len / 2; |
$isCompressed = false; |
} |
$pos += $len; |
} |
} |
// convert to UTF-8 |
$retstr = self::_encodeUTF16($retstr, $isCompressed); |
// read additional Rich-Text information, if any |
$fmtRuns = array(); |
if ($hasRichText) { |
// list of formatting runs |
for ($j = 0; $j < $formattingRuns; ++$j) { |
// first formatted character; zero-based |
$charPos = self::_GetInt2d($recordData, $pos + $j * 4); |
// index to font record |
$fontIndex = self::_GetInt2d($recordData, $pos + 2 + $j * 4); |
$fmtRuns[] = array( |
'charPos' => $charPos, |
'fontIndex' => $fontIndex, |
); |
} |
$pos += 4 * $formattingRuns; |
} |
// read additional Asian phonetics information, if any |
if ($hasAsian) { |
// For Asian phonetic settings, we skip the extended string data |
$pos += $extendedRunLength; |
} |
// store the shared sting |
$this->_sst[] = array( |
'value' => $retstr, |
'fmtRuns' => $fmtRuns, |
); |
} |
// _getSplicedRecordData() takes care of moving current position in data stream |
} |
/** |
* Read PRINTGRIDLINES record |
*/ |
private function _readPrintGridlines() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
if ($this->_version == self::XLS_BIFF8 && !$this->_readDataOnly) { |
// offset: 0; size: 2; 0 = do not print sheet grid lines; 1 = print sheet gridlines |
$printGridlines = (bool) self::_GetInt2d($recordData, 0); |
$this->_phpSheet->setPrintGridlines($printGridlines); |
} |
} |
/** |
* Read DEFAULTROWHEIGHT record |
*/ |
private function _readDefaultRowHeight() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
// offset: 0; size: 2; option flags |
// offset: 2; size: 2; default height for unused rows, (twips 1/20 point) |
$height = self::_GetInt2d($recordData, 2); |
$this->_phpSheet->getDefaultRowDimension()->setRowHeight($height / 20); |
} |
/** |
* Read SHEETPR record |
*/ |
private function _readSheetPr() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
// offset: 0; size: 2 |
// bit: 6; mask: 0x0040; 0 = outline buttons above outline group |
$isSummaryBelow = (0x0040 & self::_GetInt2d($recordData, 0)) >> 6; |
$this->_phpSheet->setShowSummaryBelow($isSummaryBelow); |
// bit: 7; mask: 0x0080; 0 = outline buttons left of outline group |
$isSummaryRight = (0x0080 & self::_GetInt2d($recordData, 0)) >> 7; |
$this->_phpSheet->setShowSummaryRight($isSummaryRight); |
// bit: 8; mask: 0x100; 0 = scale printout in percent, 1 = fit printout to number of pages |
// this corresponds to radio button setting in page setup dialog in Excel |
$this->_isFitToPages = (bool) ((0x0100 & self::_GetInt2d($recordData, 0)) >> 8); |
} |
/** |
* Read HORIZONTALPAGEBREAKS record |
*/ |
private function _readHorizontalPageBreaks() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
if ($this->_version == self::XLS_BIFF8 && !$this->_readDataOnly) { |
// offset: 0; size: 2; number of the following row index structures |
$nm = self::_GetInt2d($recordData, 0); |
// offset: 2; size: 6 * $nm; list of $nm row index structures |
for ($i = 0; $i < $nm; ++$i) { |
$r = self::_GetInt2d($recordData, 2 + 6 * $i); |
$cf = self::_GetInt2d($recordData, 2 + 6 * $i + 2); |
$cl = self::_GetInt2d($recordData, 2 + 6 * $i + 4); |
// not sure why two column indexes are necessary? |
$this->_phpSheet->setBreakByColumnAndRow($cf, $r, PHPExcel_Worksheet::BREAK_ROW); |
} |
} |
} |
/** |
* Read VERTICALPAGEBREAKS record |
*/ |
private function _readVerticalPageBreaks() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
if ($this->_version == self::XLS_BIFF8 && !$this->_readDataOnly) { |
// offset: 0; size: 2; number of the following column index structures |
$nm = self::_GetInt2d($recordData, 0); |
// offset: 2; size: 6 * $nm; list of $nm row index structures |
for ($i = 0; $i < $nm; ++$i) { |
$c = self::_GetInt2d($recordData, 2 + 6 * $i); |
$rf = self::_GetInt2d($recordData, 2 + 6 * $i + 2); |
$rl = self::_GetInt2d($recordData, 2 + 6 * $i + 4); |
// not sure why two row indexes are necessary? |
$this->_phpSheet->setBreakByColumnAndRow($c, $rf, PHPExcel_Worksheet::BREAK_COLUMN); |
} |
} |
} |
/** |
* Read HEADER record |
*/ |
private function _readHeader() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
if (!$this->_readDataOnly) { |
// offset: 0; size: var |
// realized that $recordData can be empty even when record exists |
if ($recordData) { |
if ($this->_version == self::XLS_BIFF8) { |
$string = self::_readUnicodeStringLong($recordData); |
} else { |
$string = $this->_readByteStringShort($recordData); |
} |
$this->_phpSheet->getHeaderFooter()->setOddHeader($string['value']); |
$this->_phpSheet->getHeaderFooter()->setEvenHeader($string['value']); |
} |
} |
} |
/** |
* Read FOOTER record |
*/ |
private function _readFooter() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
if (!$this->_readDataOnly) { |
// offset: 0; size: var |
// realized that $recordData can be empty even when record exists |
if ($recordData) { |
if ($this->_version == self::XLS_BIFF8) { |
$string = self::_readUnicodeStringLong($recordData); |
} else { |
$string = $this->_readByteStringShort($recordData); |
} |
$this->_phpSheet->getHeaderFooter()->setOddFooter($string['value']); |
$this->_phpSheet->getHeaderFooter()->setEvenFooter($string['value']); |
} |
} |
} |
/** |
* Read HCENTER record |
*/ |
private function _readHcenter() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
if (!$this->_readDataOnly) { |
// offset: 0; size: 2; 0 = print sheet left aligned, 1 = print sheet centered horizontally |
$isHorizontalCentered = (bool) self::_GetInt2d($recordData, 0); |
$this->_phpSheet->getPageSetup()->setHorizontalCentered($isHorizontalCentered); |
} |
} |
/** |
* Read VCENTER record |
*/ |
private function _readVcenter() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
if (!$this->_readDataOnly) { |
// offset: 0; size: 2; 0 = print sheet aligned at top page border, 1 = print sheet vertically centered |
$isVerticalCentered = (bool) self::_GetInt2d($recordData, 0); |
$this->_phpSheet->getPageSetup()->setVerticalCentered($isVerticalCentered); |
} |
} |
/** |
* Read LEFTMARGIN record |
*/ |
private function _readLeftMargin() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
if (!$this->_readDataOnly) { |
// offset: 0; size: 8 |
$this->_phpSheet->getPageMargins()->setLeft(self::_extractNumber($recordData)); |
} |
} |
/** |
* Read RIGHTMARGIN record |
*/ |
private function _readRightMargin() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
if (!$this->_readDataOnly) { |
// offset: 0; size: 8 |
$this->_phpSheet->getPageMargins()->setRight(self::_extractNumber($recordData)); |
} |
} |
/** |
* Read TOPMARGIN record |
*/ |
private function _readTopMargin() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
if (!$this->_readDataOnly) { |
// offset: 0; size: 8 |
$this->_phpSheet->getPageMargins()->setTop(self::_extractNumber($recordData)); |
} |
} |
/** |
* Read BOTTOMMARGIN record |
*/ |
private function _readBottomMargin() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
if (!$this->_readDataOnly) { |
// offset: 0; size: 8 |
$this->_phpSheet->getPageMargins()->setBottom(self::_extractNumber($recordData)); |
} |
} |
/** |
* Read PAGESETUP record |
*/ |
private function _readPageSetup() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
if (!$this->_readDataOnly) { |
// offset: 0; size: 2; paper size |
$paperSize = self::_GetInt2d($recordData, 0); |
// offset: 2; size: 2; scaling factor |
$scale = self::_GetInt2d($recordData, 2); |
// offset: 6; size: 2; fit worksheet width to this number of pages, 0 = use as many as needed |
$fitToWidth = self::_GetInt2d($recordData, 6); |
// offset: 8; size: 2; fit worksheet height to this number of pages, 0 = use as many as needed |
$fitToHeight = self::_GetInt2d($recordData, 8); |
// offset: 10; size: 2; option flags |
// bit: 1; mask: 0x0002; 0=landscape, 1=portrait |
$isPortrait = (0x0002 & self::_GetInt2d($recordData, 10)) >> 1; |
// bit: 2; mask: 0x0004; 1= paper size, scaling factor, paper orient. not init |
// when this bit is set, do not use flags for those properties |
$isNotInit = (0x0004 & self::_GetInt2d($recordData, 10)) >> 2; |
if (!$isNotInit) { |
$this->_phpSheet->getPageSetup()->setPaperSize($paperSize); |
switch ($isPortrait) { |
case 0: $this->_phpSheet->getPageSetup()->setOrientation(PHPExcel_Worksheet_PageSetup::ORIENTATION_LANDSCAPE); break; |
case 1: $this->_phpSheet->getPageSetup()->setOrientation(PHPExcel_Worksheet_PageSetup::ORIENTATION_PORTRAIT); break; |
} |
$this->_phpSheet->getPageSetup()->setScale($scale, false); |
$this->_phpSheet->getPageSetup()->setFitToPage((bool) $this->_isFitToPages); |
$this->_phpSheet->getPageSetup()->setFitToWidth($fitToWidth, false); |
$this->_phpSheet->getPageSetup()->setFitToHeight($fitToHeight, false); |
} |
// offset: 16; size: 8; header margin (IEEE 754 floating-point value) |
$marginHeader = self::_extractNumber(substr($recordData, 16, 8)); |
$this->_phpSheet->getPageMargins()->setHeader($marginHeader); |
// offset: 24; size: 8; footer margin (IEEE 754 floating-point value) |
$marginFooter = self::_extractNumber(substr($recordData, 24, 8)); |
$this->_phpSheet->getPageMargins()->setFooter($marginFooter); |
} |
} |
/** |
* PROTECT - Sheet protection (BIFF2 through BIFF8) |
* if this record is omitted, then it also means no sheet protection |
*/ |
private function _readProtect() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
if ($this->_readDataOnly) { |
return; |
} |
// offset: 0; size: 2; |
// bit 0, mask 0x01; 1 = sheet is protected |
$bool = (0x01 & self::_GetInt2d($recordData, 0)) >> 0; |
$this->_phpSheet->getProtection()->setSheet((bool)$bool); |
} |
/** |
* SCENPROTECT |
*/ |
private function _readScenProtect() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
if ($this->_readDataOnly) { |
return; |
} |
// offset: 0; size: 2; |
// bit: 0, mask 0x01; 1 = scenarios are protected |
$bool = (0x01 & self::_GetInt2d($recordData, 0)) >> 0; |
$this->_phpSheet->getProtection()->setScenarios((bool)$bool); |
} |
/** |
* OBJECTPROTECT |
*/ |
private function _readObjectProtect() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
if ($this->_readDataOnly) { |
return; |
} |
// offset: 0; size: 2; |
// bit: 0, mask 0x01; 1 = objects are protected |
$bool = (0x01 & self::_GetInt2d($recordData, 0)) >> 0; |
$this->_phpSheet->getProtection()->setObjects((bool)$bool); |
} |
/** |
* PASSWORD - Sheet protection (hashed) password (BIFF2 through BIFF8) |
*/ |
private function _readPassword() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
if (!$this->_readDataOnly) { |
// offset: 0; size: 2; 16-bit hash value of password |
$password = strtoupper(dechex(self::_GetInt2d($recordData, 0))); // the hashed password |
$this->_phpSheet->getProtection()->setPassword($password, true); |
} |
} |
/** |
* Read DEFCOLWIDTH record |
*/ |
private function _readDefColWidth() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
// offset: 0; size: 2; default column width |
$width = self::_GetInt2d($recordData, 0); |
if ($width != 8) { |
$this->_phpSheet->getDefaultColumnDimension()->setWidth($width); |
} |
} |
/** |
* Read COLINFO record |
*/ |
private function _readColInfo() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
if (!$this->_readDataOnly) { |
// offset: 0; size: 2; index to first column in range |
$fc = self::_GetInt2d($recordData, 0); // first column index |
// offset: 2; size: 2; index to last column in range |
$lc = self::_GetInt2d($recordData, 2); // first column index |
// offset: 4; size: 2; width of the column in 1/256 of the width of the zero character |
$width = self::_GetInt2d($recordData, 4); |
// offset: 6; size: 2; index to XF record for default column formatting |
$xfIndex = self::_GetInt2d($recordData, 6); |
// offset: 8; size: 2; option flags |
// bit: 0; mask: 0x0001; 1= columns are hidden |
$isHidden = (0x0001 & self::_GetInt2d($recordData, 8)) >> 0; |
// bit: 10-8; mask: 0x0700; outline level of the columns (0 = no outline) |
$level = (0x0700 & self::_GetInt2d($recordData, 8)) >> 8; |
// bit: 12; mask: 0x1000; 1 = collapsed |
$isCollapsed = (0x1000 & self::_GetInt2d($recordData, 8)) >> 12; |
// offset: 10; size: 2; not used |
for ($i = $fc; $i <= $lc; ++$i) { |
if ($lc == 255 || $lc == 256) { |
$this->_phpSheet->getDefaultColumnDimension()->setWidth($width / 256); |
break; |
} |
$this->_phpSheet->getColumnDimensionByColumn($i)->setWidth($width / 256); |
$this->_phpSheet->getColumnDimensionByColumn($i)->setVisible(!$isHidden); |
$this->_phpSheet->getColumnDimensionByColumn($i)->setOutlineLevel($level); |
$this->_phpSheet->getColumnDimensionByColumn($i)->setCollapsed($isCollapsed); |
$this->_phpSheet->getColumnDimensionByColumn($i)->setXfIndex($this->_mapCellXfIndex[$xfIndex]); |
} |
} |
} |
/** |
* ROW |
* |
* This record contains the properties of a single row in a |
* sheet. Rows and cells in a sheet are divided into blocks |
* of 32 rows. |
* |
* -- "OpenOffice.org's Documentation of the Microsoft |
* Excel File Format" |
*/ |
private function _readRow() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
if (!$this->_readDataOnly) { |
// offset: 0; size: 2; index of this row |
$r = self::_GetInt2d($recordData, 0); |
// offset: 2; size: 2; index to column of the first cell which is described by a cell record |
// offset: 4; size: 2; index to column of the last cell which is described by a cell record, increased by 1 |
// offset: 6; size: 2; |
// bit: 14-0; mask: 0x7FFF; height of the row, in twips = 1/20 of a point |
$height = (0x7FFF & self::_GetInt2d($recordData, 6)) >> 0; |
// bit: 15: mask: 0x8000; 0 = row has custom height; 1= row has default height |
$useDefaultHeight = (0x8000 & self::_GetInt2d($recordData, 6)) >> 15; |
if (!$useDefaultHeight) { |
$this->_phpSheet->getRowDimension($r + 1)->setRowHeight($height / 20); |
} |
// offset: 8; size: 2; not used |
// offset: 10; size: 2; not used in BIFF5-BIFF8 |
// offset: 12; size: 4; option flags and default row formatting |
// bit: 2-0: mask: 0x00000007; outline level of the row |
$level = (0x00000007 & self::_GetInt4d($recordData, 12)) >> 0; |
$this->_phpSheet->getRowDimension($r + 1)->setOutlineLevel($level); |
// bit: 4; mask: 0x00000010; 1 = outline group start or ends here... and is collapsed |
$isCollapsed = (0x00000010 & self::_GetInt4d($recordData, 12)) >> 4; |
$this->_phpSheet->getRowDimension($r + 1)->setCollapsed($isCollapsed); |
// bit: 5; mask: 0x00000020; 1 = row is hidden |
$isHidden = (0x00000020 & self::_GetInt4d($recordData, 12)) >> 5; |
$this->_phpSheet->getRowDimension($r + 1)->setVisible(!$isHidden); |
// bit: 7; mask: 0x00000080; 1 = row has explicit format |
$hasExplicitFormat = (0x00000080 & self::_GetInt4d($recordData, 12)) >> 7; |
// bit: 27-16; mask: 0x0FFF0000; only applies when hasExplicitFormat = 1; index to XF record |
$xfIndex = (0x0FFF0000 & self::_GetInt4d($recordData, 12)) >> 16; |
if ($hasExplicitFormat) { |
$this->_phpSheet->getRowDimension($r + 1)->setXfIndex($this->_mapCellXfIndex[$xfIndex]); |
} |
} |
} |
/** |
* Read RK record |
* This record represents a cell that contains an RK value |
* (encoded integer or floating-point value). If a |
* floating-point value cannot be encoded to an RK value, |
* a NUMBER record will be written. This record replaces the |
* record INTEGER written in BIFF2. |
* |
* -- "OpenOffice.org's Documentation of the Microsoft |
* Excel File Format" |
*/ |
private function _readRk() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
// offset: 0; size: 2; index to row |
$row = self::_GetInt2d($recordData, 0); |
// offset: 2; size: 2; index to column |
$column = self::_GetInt2d($recordData, 2); |
$columnString = PHPExcel_Cell::stringFromColumnIndex($column); |
// Read cell? |
if (($this->getReadFilter() !== NULL) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->_phpSheet->getTitle()) ) { |
// offset: 4; size: 2; index to XF record |
$xfIndex = self::_GetInt2d($recordData, 4); |
// offset: 6; size: 4; RK value |
$rknum = self::_GetInt4d($recordData, 6); |
$numValue = self::_GetIEEE754($rknum); |
$cell = $this->_phpSheet->getCell($columnString . ($row + 1)); |
if (!$this->_readDataOnly) { |
// add style information |
$cell->setXfIndex($this->_mapCellXfIndex[$xfIndex]); |
} |
// add cell |
$cell->setValueExplicit($numValue, PHPExcel_Cell_DataType::TYPE_NUMERIC); |
} |
} |
/** |
* Read LABELSST record |
* This record represents a cell that contains a string. It |
* replaces the LABEL record and RSTRING record used in |
* BIFF2-BIFF5. |
* |
* -- "OpenOffice.org's Documentation of the Microsoft |
* Excel File Format" |
*/ |
private function _readLabelSst() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
// offset: 0; size: 2; index to row |
$row = self::_GetInt2d($recordData, 0); |
// offset: 2; size: 2; index to column |
$column = self::_GetInt2d($recordData, 2); |
$columnString = PHPExcel_Cell::stringFromColumnIndex($column); |
// Read cell? |
if (($this->getReadFilter() !== NULL) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->_phpSheet->getTitle()) ) { |
// offset: 4; size: 2; index to XF record |
$xfIndex = self::_GetInt2d($recordData, 4); |
// offset: 6; size: 4; index to SST record |
$index = self::_GetInt4d($recordData, 6); |
// add cell |
if (($fmtRuns = $this->_sst[$index]['fmtRuns']) && !$this->_readDataOnly) { |
// then we should treat as rich text |
$richText = new PHPExcel_RichText(); |
$charPos = 0; |
$sstCount = count($this->_sst[$index]['fmtRuns']); |
for ($i = 0; $i <= $sstCount; ++$i) { |
if (isset($fmtRuns[$i])) { |
$text = PHPExcel_Shared_String::Substring($this->_sst[$index]['value'], $charPos, $fmtRuns[$i]['charPos'] - $charPos); |
$charPos = $fmtRuns[$i]['charPos']; |
} else { |
$text = PHPExcel_Shared_String::Substring($this->_sst[$index]['value'], $charPos, PHPExcel_Shared_String::CountCharacters($this->_sst[$index]['value'])); |
} |
if (PHPExcel_Shared_String::CountCharacters($text) > 0) { |
if ($i == 0) { // first text run, no style |
$richText->createText($text); |
} else { |
$textRun = $richText->createTextRun($text); |
if (isset($fmtRuns[$i - 1])) { |
if ($fmtRuns[$i - 1]['fontIndex'] < 4) { |
$fontIndex = $fmtRuns[$i - 1]['fontIndex']; |
} else { |
// this has to do with that index 4 is omitted in all BIFF versions for some strange reason |
// check the OpenOffice documentation of the FONT record |
$fontIndex = $fmtRuns[$i - 1]['fontIndex'] - 1; |
} |
$textRun->setFont(clone $this->_objFonts[$fontIndex]); |
} |
} |
} |
} |
$cell = $this->_phpSheet->getCell($columnString . ($row + 1)); |
$cell->setValueExplicit($richText, PHPExcel_Cell_DataType::TYPE_STRING); |
} else { |
$cell = $this->_phpSheet->getCell($columnString . ($row + 1)); |
$cell->setValueExplicit($this->_sst[$index]['value'], PHPExcel_Cell_DataType::TYPE_STRING); |
} |
if (!$this->_readDataOnly) { |
// add style information |
$cell->setXfIndex($this->_mapCellXfIndex[$xfIndex]); |
} |
} |
} |
/** |
* Read MULRK record |
* This record represents a cell range containing RK value |
* cells. All cells are located in the same row. |
* |
* -- "OpenOffice.org's Documentation of the Microsoft |
* Excel File Format" |
*/ |
private function _readMulRk() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
// offset: 0; size: 2; index to row |
$row = self::_GetInt2d($recordData, 0); |
// offset: 2; size: 2; index to first column |
$colFirst = self::_GetInt2d($recordData, 2); |
// offset: var; size: 2; index to last column |
$colLast = self::_GetInt2d($recordData, $length - 2); |
$columns = $colLast - $colFirst + 1; |
// offset within record data |
$offset = 4; |
for ($i = 0; $i < $columns; ++$i) { |
$columnString = PHPExcel_Cell::stringFromColumnIndex($colFirst + $i); |
// Read cell? |
if (($this->getReadFilter() !== NULL) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->_phpSheet->getTitle()) ) { |
// offset: var; size: 2; index to XF record |
$xfIndex = self::_GetInt2d($recordData, $offset); |
// offset: var; size: 4; RK value |
$numValue = self::_GetIEEE754(self::_GetInt4d($recordData, $offset + 2)); |
$cell = $this->_phpSheet->getCell($columnString . ($row + 1)); |
if (!$this->_readDataOnly) { |
// add style |
$cell->setXfIndex($this->_mapCellXfIndex[$xfIndex]); |
} |
// add cell value |
$cell->setValueExplicit($numValue, PHPExcel_Cell_DataType::TYPE_NUMERIC); |
} |
$offset += 6; |
} |
} |
/** |
* Read NUMBER record |
* This record represents a cell that contains a |
* floating-point value. |
* |
* -- "OpenOffice.org's Documentation of the Microsoft |
* Excel File Format" |
*/ |
private function _readNumber() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
// offset: 0; size: 2; index to row |
$row = self::_GetInt2d($recordData, 0); |
// offset: 2; size 2; index to column |
$column = self::_GetInt2d($recordData, 2); |
$columnString = PHPExcel_Cell::stringFromColumnIndex($column); |
// Read cell? |
if (($this->getReadFilter() !== NULL) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->_phpSheet->getTitle()) ) { |
// offset 4; size: 2; index to XF record |
$xfIndex = self::_GetInt2d($recordData, 4); |
$numValue = self::_extractNumber(substr($recordData, 6, 8)); |
$cell = $this->_phpSheet->getCell($columnString . ($row + 1)); |
if (!$this->_readDataOnly) { |
// add cell style |
$cell->setXfIndex($this->_mapCellXfIndex[$xfIndex]); |
} |
// add cell value |
$cell->setValueExplicit($numValue, PHPExcel_Cell_DataType::TYPE_NUMERIC); |
} |
} |
/** |
* Read FORMULA record + perhaps a following STRING record if formula result is a string |
* This record contains the token array and the result of a |
* formula cell. |
* |
* -- "OpenOffice.org's Documentation of the Microsoft |
* Excel File Format" |
*/ |
private function _readFormula() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
// offset: 0; size: 2; row index |
$row = self::_GetInt2d($recordData, 0); |
// offset: 2; size: 2; col index |
$column = self::_GetInt2d($recordData, 2); |
$columnString = PHPExcel_Cell::stringFromColumnIndex($column); |
// offset: 20: size: variable; formula structure |
$formulaStructure = substr($recordData, 20); |
// offset: 14: size: 2; option flags, recalculate always, recalculate on open etc. |
$options = self::_GetInt2d($recordData, 14); |
// bit: 0; mask: 0x0001; 1 = recalculate always |
// bit: 1; mask: 0x0002; 1 = calculate on open |
// bit: 2; mask: 0x0008; 1 = part of a shared formula |
$isPartOfSharedFormula = (bool) (0x0008 & $options); |
// WARNING: |
// We can apparently not rely on $isPartOfSharedFormula. Even when $isPartOfSharedFormula = true |
// the formula data may be ordinary formula data, therefore we need to check |
// explicitly for the tExp token (0x01) |
$isPartOfSharedFormula = $isPartOfSharedFormula && ord($formulaStructure{2}) == 0x01; |
if ($isPartOfSharedFormula) { |
// part of shared formula which means there will be a formula with a tExp token and nothing else |
// get the base cell, grab tExp token |
$baseRow = self::_GetInt2d($formulaStructure, 3); |
$baseCol = self::_GetInt2d($formulaStructure, 5); |
$this->_baseCell = PHPExcel_Cell::stringFromColumnIndex($baseCol). ($baseRow + 1); |
} |
// Read cell? |
if (($this->getReadFilter() !== NULL) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->_phpSheet->getTitle()) ) { |
if ($isPartOfSharedFormula) { |
// formula is added to this cell after the sheet has been read |
$this->_sharedFormulaParts[$columnString . ($row + 1)] = $this->_baseCell; |
} |
// offset: 16: size: 4; not used |
// offset: 4; size: 2; XF index |
$xfIndex = self::_GetInt2d($recordData, 4); |
// offset: 6; size: 8; result of the formula |
if ( (ord($recordData{6}) == 0) |
&& (ord($recordData{12}) == 255) |
&& (ord($recordData{13}) == 255) ) { |
// String formula. Result follows in appended STRING record |
$dataType = PHPExcel_Cell_DataType::TYPE_STRING; |
// read possible SHAREDFMLA record |
$code = self::_GetInt2d($this->_data, $this->_pos); |
if ($code == self::XLS_Type_SHAREDFMLA) { |
$this->_readSharedFmla(); |
} |
// read STRING record |
$value = $this->_readString(); |
} elseif ((ord($recordData{6}) == 1) |
&& (ord($recordData{12}) == 255) |
&& (ord($recordData{13}) == 255)) { |
// Boolean formula. Result is in +2; 0=false, 1=true |
$dataType = PHPExcel_Cell_DataType::TYPE_BOOL; |
$value = (bool) ord($recordData{8}); |
} elseif ((ord($recordData{6}) == 2) |
&& (ord($recordData{12}) == 255) |
&& (ord($recordData{13}) == 255)) { |
// Error formula. Error code is in +2 |
$dataType = PHPExcel_Cell_DataType::TYPE_ERROR; |
$value = self::_mapErrorCode(ord($recordData{8})); |
} elseif ((ord($recordData{6}) == 3) |
&& (ord($recordData{12}) == 255) |
&& (ord($recordData{13}) == 255)) { |
// Formula result is a null string |
$dataType = PHPExcel_Cell_DataType::TYPE_NULL; |
$value = ''; |
} else { |
// forumla result is a number, first 14 bytes like _NUMBER record |
$dataType = PHPExcel_Cell_DataType::TYPE_NUMERIC; |
$value = self::_extractNumber(substr($recordData, 6, 8)); |
} |
$cell = $this->_phpSheet->getCell($columnString . ($row + 1)); |
if (!$this->_readDataOnly) { |
// add cell style |
$cell->setXfIndex($this->_mapCellXfIndex[$xfIndex]); |
} |
// store the formula |
if (!$isPartOfSharedFormula) { |
// not part of shared formula |
// add cell value. If we can read formula, populate with formula, otherwise just used cached value |
try { |
if ($this->_version != self::XLS_BIFF8) { |
throw new PHPExcel_Reader_Exception('Not BIFF8. Can only read BIFF8 formulas'); |
} |
$formula = $this->_getFormulaFromStructure($formulaStructure); // get formula in human language |
$cell->setValueExplicit('=' . $formula, PHPExcel_Cell_DataType::TYPE_FORMULA); |
} catch (PHPExcel_Exception $e) { |
$cell->setValueExplicit($value, $dataType); |
} |
} else { |
if ($this->_version == self::XLS_BIFF8) { |
// do nothing at this point, formula id added later in the code |
} else { |
$cell->setValueExplicit($value, $dataType); |
} |
} |
// store the cached calculated value |
$cell->setCalculatedValue($value); |
} |
} |
/** |
* Read a SHAREDFMLA record. This function just stores the binary shared formula in the reader, |
* which usually contains relative references. |
* These will be used to construct the formula in each shared formula part after the sheet is read. |
*/ |
private function _readSharedFmla() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
// offset: 0, size: 6; cell range address of the area used by the shared formula, not used for anything |
$cellRange = substr($recordData, 0, 6); |
$cellRange = $this->_readBIFF5CellRangeAddressFixed($cellRange); // note: even BIFF8 uses BIFF5 syntax |
// offset: 6, size: 1; not used |
// offset: 7, size: 1; number of existing FORMULA records for this shared formula |
$no = ord($recordData{7}); |
// offset: 8, size: var; Binary token array of the shared formula |
$formula = substr($recordData, 8); |
// at this point we only store the shared formula for later use |
$this->_sharedFormulas[$this->_baseCell] = $formula; |
} |
/** |
* Read a STRING record from current stream position and advance the stream pointer to next record |
* This record is used for storing result from FORMULA record when it is a string, and |
* it occurs directly after the FORMULA record |
* |
* @return string The string contents as UTF-8 |
*/ |
private function _readString() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
if ($this->_version == self::XLS_BIFF8) { |
$string = self::_readUnicodeStringLong($recordData); |
$value = $string['value']; |
} else { |
$string = $this->_readByteStringLong($recordData); |
$value = $string['value']; |
} |
return $value; |
} |
/** |
* Read BOOLERR record |
* This record represents a Boolean value or error value |
* cell. |
* |
* -- "OpenOffice.org's Documentation of the Microsoft |
* Excel File Format" |
*/ |
private function _readBoolErr() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
// offset: 0; size: 2; row index |
$row = self::_GetInt2d($recordData, 0); |
// offset: 2; size: 2; column index |
$column = self::_GetInt2d($recordData, 2); |
$columnString = PHPExcel_Cell::stringFromColumnIndex($column); |
// Read cell? |
if (($this->getReadFilter() !== NULL) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->_phpSheet->getTitle()) ) { |
// offset: 4; size: 2; index to XF record |
$xfIndex = self::_GetInt2d($recordData, 4); |
// offset: 6; size: 1; the boolean value or error value |
$boolErr = ord($recordData{6}); |
// offset: 7; size: 1; 0=boolean; 1=error |
$isError = ord($recordData{7}); |
$cell = $this->_phpSheet->getCell($columnString . ($row + 1)); |
switch ($isError) { |
case 0: // boolean |
$value = (bool) $boolErr; |
// add cell value |
$cell->setValueExplicit($value, PHPExcel_Cell_DataType::TYPE_BOOL); |
break; |
case 1: // error type |
$value = self::_mapErrorCode($boolErr); |
// add cell value |
$cell->setValueExplicit($value, PHPExcel_Cell_DataType::TYPE_ERROR); |
break; |
} |
if (!$this->_readDataOnly) { |
// add cell style |
$cell->setXfIndex($this->_mapCellXfIndex[$xfIndex]); |
} |
} |
} |
/** |
* Read MULBLANK record |
* This record represents a cell range of empty cells. All |
* cells are located in the same row |
* |
* -- "OpenOffice.org's Documentation of the Microsoft |
* Excel File Format" |
*/ |
private function _readMulBlank() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
// offset: 0; size: 2; index to row |
$row = self::_GetInt2d($recordData, 0); |
// offset: 2; size: 2; index to first column |
$fc = self::_GetInt2d($recordData, 2); |
// offset: 4; size: 2 x nc; list of indexes to XF records |
// add style information |
if (!$this->_readDataOnly) { |
for ($i = 0; $i < $length / 2 - 3; ++$i) { |
$columnString = PHPExcel_Cell::stringFromColumnIndex($fc + $i); |
// Read cell? |
if (($this->getReadFilter() !== NULL) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->_phpSheet->getTitle()) ) { |
$xfIndex = self::_GetInt2d($recordData, 4 + 2 * $i); |
$this->_phpSheet->getCell($columnString . ($row + 1))->setXfIndex($this->_mapCellXfIndex[$xfIndex]); |
} |
} |
} |
// offset: 6; size 2; index to last column (not needed) |
} |
/** |
* Read LABEL record |
* This record represents a cell that contains a string. In |
* BIFF8 it is usually replaced by the LABELSST record. |
* Excel still uses this record, if it copies unformatted |
* text cells to the clipboard. |
* |
* -- "OpenOffice.org's Documentation of the Microsoft |
* Excel File Format" |
*/ |
private function _readLabel() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
// offset: 0; size: 2; index to row |
$row = self::_GetInt2d($recordData, 0); |
// offset: 2; size: 2; index to column |
$column = self::_GetInt2d($recordData, 2); |
$columnString = PHPExcel_Cell::stringFromColumnIndex($column); |
// Read cell? |
if (($this->getReadFilter() !== NULL) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->_phpSheet->getTitle()) ) { |
// offset: 4; size: 2; XF index |
$xfIndex = self::_GetInt2d($recordData, 4); |
// add cell value |
// todo: what if string is very long? continue record |
if ($this->_version == self::XLS_BIFF8) { |
$string = self::_readUnicodeStringLong(substr($recordData, 6)); |
$value = $string['value']; |
} else { |
$string = $this->_readByteStringLong(substr($recordData, 6)); |
$value = $string['value']; |
} |
$cell = $this->_phpSheet->getCell($columnString . ($row + 1)); |
$cell->setValueExplicit($value, PHPExcel_Cell_DataType::TYPE_STRING); |
if (!$this->_readDataOnly) { |
// add cell style |
$cell->setXfIndex($this->_mapCellXfIndex[$xfIndex]); |
} |
} |
} |
/** |
* Read BLANK record |
*/ |
private function _readBlank() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
// offset: 0; size: 2; row index |
$row = self::_GetInt2d($recordData, 0); |
// offset: 2; size: 2; col index |
$col = self::_GetInt2d($recordData, 2); |
$columnString = PHPExcel_Cell::stringFromColumnIndex($col); |
// Read cell? |
if (($this->getReadFilter() !== NULL) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->_phpSheet->getTitle()) ) { |
// offset: 4; size: 2; XF index |
$xfIndex = self::_GetInt2d($recordData, 4); |
// add style information |
if (!$this->_readDataOnly) { |
$this->_phpSheet->getCell($columnString . ($row + 1))->setXfIndex($this->_mapCellXfIndex[$xfIndex]); |
} |
} |
} |
/** |
* Read MSODRAWING record |
*/ |
private function _readMsoDrawing() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
// get spliced record data |
$splicedRecordData = $this->_getSplicedRecordData(); |
$recordData = $splicedRecordData['recordData']; |
$this->_drawingData .= $recordData; |
} |
/** |
* Read OBJ record |
*/ |
private function _readObj() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
if ($this->_readDataOnly || $this->_version != self::XLS_BIFF8) { |
return; |
} |
// recordData consists of an array of subrecords looking like this: |
// ft: 2 bytes; ftCmo type (0x15) |
// cb: 2 bytes; size in bytes of ftCmo data |
// ot: 2 bytes; Object Type |
// id: 2 bytes; Object id number |
// grbit: 2 bytes; Option Flags |
// data: var; subrecord data |
// for now, we are just interested in the second subrecord containing the object type |
$ftCmoType = self::_GetInt2d($recordData, 0); |
$cbCmoSize = self::_GetInt2d($recordData, 2); |
$otObjType = self::_GetInt2d($recordData, 4); |
$idObjID = self::_GetInt2d($recordData, 6); |
$grbitOpts = self::_GetInt2d($recordData, 6); |
$this->_objs[] = array( |
'ftCmoType' => $ftCmoType, |
'cbCmoSize' => $cbCmoSize, |
'otObjType' => $otObjType, |
'idObjID' => $idObjID, |
'grbitOpts' => $grbitOpts |
); |
$this->textObjRef = $idObjID; |
// echo '<b>_readObj()</b><br />'; |
// var_dump(end($this->_objs)); |
// echo '<br />'; |
} |
/** |
* Read WINDOW2 record |
*/ |
private function _readWindow2() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
// offset: 0; size: 2; option flags |
$options = self::_GetInt2d($recordData, 0); |
// offset: 2; size: 2; index to first visible row |
$firstVisibleRow = self::_GetInt2d($recordData, 2); |
// offset: 4; size: 2; index to first visible colum |
$firstVisibleColumn = self::_GetInt2d($recordData, 4); |
if ($this->_version === self::XLS_BIFF8) { |
// offset: 8; size: 2; not used |
// offset: 10; size: 2; cached magnification factor in page break preview (in percent); 0 = Default (60%) |
// offset: 12; size: 2; cached magnification factor in normal view (in percent); 0 = Default (100%) |
// offset: 14; size: 4; not used |
$zoomscaleInPageBreakPreview = self::_GetInt2d($recordData, 10); |
if ($zoomscaleInPageBreakPreview === 0) $zoomscaleInPageBreakPreview = 60; |
$zoomscaleInNormalView = self::_GetInt2d($recordData, 12); |
if ($zoomscaleInNormalView === 0) $zoomscaleInNormalView = 100; |
} |
// bit: 1; mask: 0x0002; 0 = do not show gridlines, 1 = show gridlines |
$showGridlines = (bool) ((0x0002 & $options) >> 1); |
$this->_phpSheet->setShowGridlines($showGridlines); |
// bit: 2; mask: 0x0004; 0 = do not show headers, 1 = show headers |
$showRowColHeaders = (bool) ((0x0004 & $options) >> 2); |
$this->_phpSheet->setShowRowColHeaders($showRowColHeaders); |
// bit: 3; mask: 0x0008; 0 = panes are not frozen, 1 = panes are frozen |
$this->_frozen = (bool) ((0x0008 & $options) >> 3); |
// bit: 6; mask: 0x0040; 0 = columns from left to right, 1 = columns from right to left |
$this->_phpSheet->setRightToLeft((bool)((0x0040 & $options) >> 6)); |
// bit: 10; mask: 0x0400; 0 = sheet not active, 1 = sheet active |
$isActive = (bool) ((0x0400 & $options) >> 10); |
if ($isActive) { |
$this->_phpExcel->setActiveSheetIndex($this->_phpExcel->getIndex($this->_phpSheet)); |
} |
// bit: 11; mask: 0x0800; 0 = normal view, 1 = page break view |
$isPageBreakPreview = (bool) ((0x0800 & $options) >> 11); |
//FIXME: set $firstVisibleRow and $firstVisibleColumn |
if ($this->_phpSheet->getSheetView()->getView() !== PHPExcel_Worksheet_SheetView::SHEETVIEW_PAGE_LAYOUT) { |
//NOTE: this setting is inferior to page layout view(Excel2007-) |
$view = $isPageBreakPreview? PHPExcel_Worksheet_SheetView::SHEETVIEW_PAGE_BREAK_PREVIEW : |
PHPExcel_Worksheet_SheetView::SHEETVIEW_NORMAL; |
$this->_phpSheet->getSheetView()->setView($view); |
if ($this->_version === self::XLS_BIFF8) { |
$zoomScale = $isPageBreakPreview? $zoomscaleInPageBreakPreview : $zoomscaleInNormalView; |
$this->_phpSheet->getSheetView()->setZoomScale($zoomScale); |
$this->_phpSheet->getSheetView()->setZoomScaleNormal($zoomscaleInNormalView); |
} |
} |
} |
/** |
* Read PLV Record(Created by Excel2007 or upper) |
*/ |
private function _readPageLayoutView(){ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
//var_dump(unpack("vrt/vgrbitFrt/V2reserved/vwScalePLV/vgrbit", $recordData)); |
// offset: 0; size: 2; rt |
//->ignore |
$rt = self::_GetInt2d($recordData, 0); |
// offset: 2; size: 2; grbitfr |
//->ignore |
$grbitFrt = self::_GetInt2d($recordData, 2); |
// offset: 4; size: 8; reserved |
//->ignore |
// offset: 12; size 2; zoom scale |
$wScalePLV = self::_GetInt2d($recordData, 12); |
// offset: 14; size 2; grbit |
$grbit = self::_GetInt2d($recordData, 14); |
// decomprise grbit |
$fPageLayoutView = $grbit & 0x01; |
$fRulerVisible = ($grbit >> 1) & 0x01; //no support |
$fWhitespaceHidden = ($grbit >> 3) & 0x01; //no support |
if ($fPageLayoutView === 1) { |
$this->_phpSheet->getSheetView()->setView(PHPExcel_Worksheet_SheetView::SHEETVIEW_PAGE_LAYOUT); |
$this->_phpSheet->getSheetView()->setZoomScale($wScalePLV); //set by Excel2007 only if SHEETVIEW_PAGE_LAYOUT |
} |
//otherwise, we cannot know whether SHEETVIEW_PAGE_LAYOUT or SHEETVIEW_PAGE_BREAK_PREVIEW. |
} |
/** |
* Read SCL record |
*/ |
private function _readScl() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
// offset: 0; size: 2; numerator of the view magnification |
$numerator = self::_GetInt2d($recordData, 0); |
// offset: 2; size: 2; numerator of the view magnification |
$denumerator = self::_GetInt2d($recordData, 2); |
// set the zoom scale (in percent) |
$this->_phpSheet->getSheetView()->setZoomScale($numerator * 100 / $denumerator); |
} |
/** |
* Read PANE record |
*/ |
private function _readPane() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
if (!$this->_readDataOnly) { |
// offset: 0; size: 2; position of vertical split |
$px = self::_GetInt2d($recordData, 0); |
// offset: 2; size: 2; position of horizontal split |
$py = self::_GetInt2d($recordData, 2); |
if ($this->_frozen) { |
// frozen panes |
$this->_phpSheet->freezePane(PHPExcel_Cell::stringFromColumnIndex($px) . ($py + 1)); |
} else { |
// unfrozen panes; split windows; not supported by PHPExcel core |
} |
} |
} |
/** |
* Read SELECTION record. There is one such record for each pane in the sheet. |
*/ |
private function _readSelection() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
if (!$this->_readDataOnly) { |
// offset: 0; size: 1; pane identifier |
$paneId = ord($recordData{0}); |
// offset: 1; size: 2; index to row of the active cell |
$r = self::_GetInt2d($recordData, 1); |
// offset: 3; size: 2; index to column of the active cell |
$c = self::_GetInt2d($recordData, 3); |
// offset: 5; size: 2; index into the following cell range list to the |
// entry that contains the active cell |
$index = self::_GetInt2d($recordData, 5); |
// offset: 7; size: var; cell range address list containing all selected cell ranges |
$data = substr($recordData, 7); |
$cellRangeAddressList = $this->_readBIFF5CellRangeAddressList($data); // note: also BIFF8 uses BIFF5 syntax |
$selectedCells = $cellRangeAddressList['cellRangeAddresses'][0]; |
// first row '1' + last row '16384' indicates that full column is selected (apparently also in BIFF8!) |
if (preg_match('/^([A-Z]+1\:[A-Z]+)16384$/', $selectedCells)) { |
$selectedCells = preg_replace('/^([A-Z]+1\:[A-Z]+)16384$/', '${1}1048576', $selectedCells); |
} |
// first row '1' + last row '65536' indicates that full column is selected |
if (preg_match('/^([A-Z]+1\:[A-Z]+)65536$/', $selectedCells)) { |
$selectedCells = preg_replace('/^([A-Z]+1\:[A-Z]+)65536$/', '${1}1048576', $selectedCells); |
} |
// first column 'A' + last column 'IV' indicates that full row is selected |
if (preg_match('/^(A[0-9]+\:)IV([0-9]+)$/', $selectedCells)) { |
$selectedCells = preg_replace('/^(A[0-9]+\:)IV([0-9]+)$/', '${1}XFD${2}', $selectedCells); |
} |
$this->_phpSheet->setSelectedCells($selectedCells); |
} |
} |
private function _includeCellRangeFiltered($cellRangeAddress) |
{ |
$includeCellRange = true; |
if ($this->getReadFilter() !== NULL) { |
$includeCellRange = false; |
$rangeBoundaries = PHPExcel_Cell::getRangeBoundaries($cellRangeAddress); |
$rangeBoundaries[1][0]++; |
for ($row = $rangeBoundaries[0][1]; $row <= $rangeBoundaries[1][1]; $row++) { |
for ($column = $rangeBoundaries[0][0]; $column != $rangeBoundaries[1][0]; $column++) { |
if ($this->getReadFilter()->readCell($column, $row, $this->_phpSheet->getTitle())) { |
$includeCellRange = true; |
break 2; |
} |
} |
} |
} |
return $includeCellRange; |
} |
/** |
* MERGEDCELLS |
* |
* This record contains the addresses of merged cell ranges |
* in the current sheet. |
* |
* -- "OpenOffice.org's Documentation of the Microsoft |
* Excel File Format" |
*/ |
private function _readMergedCells() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
if ($this->_version == self::XLS_BIFF8 && !$this->_readDataOnly) { |
$cellRangeAddressList = $this->_readBIFF8CellRangeAddressList($recordData); |
foreach ($cellRangeAddressList['cellRangeAddresses'] as $cellRangeAddress) { |
if ((strpos($cellRangeAddress,':') !== FALSE) && |
($this->_includeCellRangeFiltered($cellRangeAddress))) { |
$this->_phpSheet->mergeCells($cellRangeAddress); |
} |
} |
} |
} |
/** |
* Read HYPERLINK record |
*/ |
private function _readHyperLink() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer forward to next record |
$this->_pos += 4 + $length; |
if (!$this->_readDataOnly) { |
// offset: 0; size: 8; cell range address of all cells containing this hyperlink |
try { |
$cellRange = $this->_readBIFF8CellRangeAddressFixed($recordData, 0, 8); |
} catch (PHPExcel_Exception $e) { |
return; |
} |
// offset: 8, size: 16; GUID of StdLink |
// offset: 24, size: 4; unknown value |
// offset: 28, size: 4; option flags |
// bit: 0; mask: 0x00000001; 0 = no link or extant, 1 = file link or URL |
$isFileLinkOrUrl = (0x00000001 & self::_GetInt2d($recordData, 28)) >> 0; |
// bit: 1; mask: 0x00000002; 0 = relative path, 1 = absolute path or URL |
$isAbsPathOrUrl = (0x00000001 & self::_GetInt2d($recordData, 28)) >> 1; |
// bit: 2 (and 4); mask: 0x00000014; 0 = no description |
$hasDesc = (0x00000014 & self::_GetInt2d($recordData, 28)) >> 2; |
// bit: 3; mask: 0x00000008; 0 = no text, 1 = has text |
$hasText = (0x00000008 & self::_GetInt2d($recordData, 28)) >> 3; |
// bit: 7; mask: 0x00000080; 0 = no target frame, 1 = has target frame |
$hasFrame = (0x00000080 & self::_GetInt2d($recordData, 28)) >> 7; |
// bit: 8; mask: 0x00000100; 0 = file link or URL, 1 = UNC path (inc. server name) |
$isUNC = (0x00000100 & self::_GetInt2d($recordData, 28)) >> 8; |
// offset within record data |
$offset = 32; |
if ($hasDesc) { |
// offset: 32; size: var; character count of description text |
$dl = self::_GetInt4d($recordData, 32); |
// offset: 36; size: var; character array of description text, no Unicode string header, always 16-bit characters, zero terminated |
$desc = self::_encodeUTF16(substr($recordData, 36, 2 * ($dl - 1)), false); |
$offset += 4 + 2 * $dl; |
} |
if ($hasFrame) { |
$fl = self::_GetInt4d($recordData, $offset); |
$offset += 4 + 2 * $fl; |
} |
// detect type of hyperlink (there are 4 types) |
$hyperlinkType = null; |
if ($isUNC) { |
$hyperlinkType = 'UNC'; |
} else if (!$isFileLinkOrUrl) { |
$hyperlinkType = 'workbook'; |
} else if (ord($recordData{$offset}) == 0x03) { |
$hyperlinkType = 'local'; |
} else if (ord($recordData{$offset}) == 0xE0) { |
$hyperlinkType = 'URL'; |
} |
switch ($hyperlinkType) { |
case 'URL': |
// section 5.58.2: Hyperlink containing a URL |
// e.g. http://example.org/index.php |
// offset: var; size: 16; GUID of URL Moniker |
$offset += 16; |
// offset: var; size: 4; size (in bytes) of character array of the URL including trailing zero word |
$us = self::_GetInt4d($recordData, $offset); |
$offset += 4; |
// offset: var; size: $us; character array of the URL, no Unicode string header, always 16-bit characters, zero-terminated |
$url = self::_encodeUTF16(substr($recordData, $offset, $us - 2), false); |
$url .= $hasText ? '#' : ''; |
$offset += $us; |
break; |
case 'local': |
// section 5.58.3: Hyperlink to local file |
// examples: |
// mydoc.txt |
// ../../somedoc.xls#Sheet!A1 |
// offset: var; size: 16; GUI of File Moniker |
$offset += 16; |
// offset: var; size: 2; directory up-level count. |
$upLevelCount = self::_GetInt2d($recordData, $offset); |
$offset += 2; |
// offset: var; size: 4; character count of the shortened file path and name, including trailing zero word |
$sl = self::_GetInt4d($recordData, $offset); |
$offset += 4; |
// offset: var; size: sl; character array of the shortened file path and name in 8.3-DOS-format (compressed Unicode string) |
$shortenedFilePath = substr($recordData, $offset, $sl); |
$shortenedFilePath = self::_encodeUTF16($shortenedFilePath, true); |
$shortenedFilePath = substr($shortenedFilePath, 0, -1); // remove trailing zero |
$offset += $sl; |
// offset: var; size: 24; unknown sequence |
$offset += 24; |
// extended file path |
// offset: var; size: 4; size of the following file link field including string lenth mark |
$sz = self::_GetInt4d($recordData, $offset); |
$offset += 4; |
// only present if $sz > 0 |
if ($sz > 0) { |
// offset: var; size: 4; size of the character array of the extended file path and name |
$xl = self::_GetInt4d($recordData, $offset); |
$offset += 4; |
// offset: var; size 2; unknown |
$offset += 2; |
// offset: var; size $xl; character array of the extended file path and name. |
$extendedFilePath = substr($recordData, $offset, $xl); |
$extendedFilePath = self::_encodeUTF16($extendedFilePath, false); |
$offset += $xl; |
} |
// construct the path |
$url = str_repeat('..\\', $upLevelCount); |
$url .= ($sz > 0) ? |
$extendedFilePath : $shortenedFilePath; // use extended path if available |
$url .= $hasText ? '#' : ''; |
break; |
case 'UNC': |
// section 5.58.4: Hyperlink to a File with UNC (Universal Naming Convention) Path |
// todo: implement |
return; |
case 'workbook': |
// section 5.58.5: Hyperlink to the Current Workbook |
// e.g. Sheet2!B1:C2, stored in text mark field |
$url = 'sheet://'; |
break; |
default: |
return; |
} |
if ($hasText) { |
// offset: var; size: 4; character count of text mark including trailing zero word |
$tl = self::_GetInt4d($recordData, $offset); |
$offset += 4; |
// offset: var; size: var; character array of the text mark without the # sign, no Unicode header, always 16-bit characters, zero-terminated |
$text = self::_encodeUTF16(substr($recordData, $offset, 2 * ($tl - 1)), false); |
$url .= $text; |
} |
// apply the hyperlink to all the relevant cells |
foreach (PHPExcel_Cell::extractAllCellReferencesInRange($cellRange) as $coordinate) { |
$this->_phpSheet->getCell($coordinate)->getHyperLink()->setUrl($url); |
} |
} |
} |
/** |
* Read DATAVALIDATIONS record |
*/ |
private function _readDataValidations() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer forward to next record |
$this->_pos += 4 + $length; |
} |
/** |
* Read DATAVALIDATION record |
*/ |
private function _readDataValidation() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer forward to next record |
$this->_pos += 4 + $length; |
if ($this->_readDataOnly) { |
return; |
} |
// offset: 0; size: 4; Options |
$options = self::_GetInt4d($recordData, 0); |
// bit: 0-3; mask: 0x0000000F; type |
$type = (0x0000000F & $options) >> 0; |
switch ($type) { |
case 0x00: $type = PHPExcel_Cell_DataValidation::TYPE_NONE; break; |
case 0x01: $type = PHPExcel_Cell_DataValidation::TYPE_WHOLE; break; |
case 0x02: $type = PHPExcel_Cell_DataValidation::TYPE_DECIMAL; break; |
case 0x03: $type = PHPExcel_Cell_DataValidation::TYPE_LIST; break; |
case 0x04: $type = PHPExcel_Cell_DataValidation::TYPE_DATE; break; |
case 0x05: $type = PHPExcel_Cell_DataValidation::TYPE_TIME; break; |
case 0x06: $type = PHPExcel_Cell_DataValidation::TYPE_TEXTLENGTH; break; |
case 0x07: $type = PHPExcel_Cell_DataValidation::TYPE_CUSTOM; break; |
} |
// bit: 4-6; mask: 0x00000070; error type |
$errorStyle = (0x00000070 & $options) >> 4; |
switch ($errorStyle) { |
case 0x00: $errorStyle = PHPExcel_Cell_DataValidation::STYLE_STOP; break; |
case 0x01: $errorStyle = PHPExcel_Cell_DataValidation::STYLE_WARNING; break; |
case 0x02: $errorStyle = PHPExcel_Cell_DataValidation::STYLE_INFORMATION; break; |
} |
// bit: 7; mask: 0x00000080; 1= formula is explicit (only applies to list) |
// I have only seen cases where this is 1 |
$explicitFormula = (0x00000080 & $options) >> 7; |
// bit: 8; mask: 0x00000100; 1= empty cells allowed |
$allowBlank = (0x00000100 & $options) >> 8; |
// bit: 9; mask: 0x00000200; 1= suppress drop down arrow in list type validity |
$suppressDropDown = (0x00000200 & $options) >> 9; |
// bit: 18; mask: 0x00040000; 1= show prompt box if cell selected |
$showInputMessage = (0x00040000 & $options) >> 18; |
// bit: 19; mask: 0x00080000; 1= show error box if invalid values entered |
$showErrorMessage = (0x00080000 & $options) >> 19; |
// bit: 20-23; mask: 0x00F00000; condition operator |
$operator = (0x00F00000 & $options) >> 20; |
switch ($operator) { |
case 0x00: $operator = PHPExcel_Cell_DataValidation::OPERATOR_BETWEEN ; break; |
case 0x01: $operator = PHPExcel_Cell_DataValidation::OPERATOR_NOTBETWEEN ; break; |
case 0x02: $operator = PHPExcel_Cell_DataValidation::OPERATOR_EQUAL ; break; |
case 0x03: $operator = PHPExcel_Cell_DataValidation::OPERATOR_NOTEQUAL ; break; |
case 0x04: $operator = PHPExcel_Cell_DataValidation::OPERATOR_GREATERTHAN ; break; |
case 0x05: $operator = PHPExcel_Cell_DataValidation::OPERATOR_LESSTHAN ; break; |
case 0x06: $operator = PHPExcel_Cell_DataValidation::OPERATOR_GREATERTHANOREQUAL; break; |
case 0x07: $operator = PHPExcel_Cell_DataValidation::OPERATOR_LESSTHANOREQUAL ; break; |
} |
// offset: 4; size: var; title of the prompt box |
$offset = 4; |
$string = self::_readUnicodeStringLong(substr($recordData, $offset)); |
$promptTitle = $string['value'] !== chr(0) ? |
$string['value'] : ''; |
$offset += $string['size']; |
// offset: var; size: var; title of the error box |
$string = self::_readUnicodeStringLong(substr($recordData, $offset)); |
$errorTitle = $string['value'] !== chr(0) ? |
$string['value'] : ''; |
$offset += $string['size']; |
// offset: var; size: var; text of the prompt box |
$string = self::_readUnicodeStringLong(substr($recordData, $offset)); |
$prompt = $string['value'] !== chr(0) ? |
$string['value'] : ''; |
$offset += $string['size']; |
// offset: var; size: var; text of the error box |
$string = self::_readUnicodeStringLong(substr($recordData, $offset)); |
$error = $string['value'] !== chr(0) ? |
$string['value'] : ''; |
$offset += $string['size']; |
// offset: var; size: 2; size of the formula data for the first condition |
$sz1 = self::_GetInt2d($recordData, $offset); |
$offset += 2; |
// offset: var; size: 2; not used |
$offset += 2; |
// offset: var; size: $sz1; formula data for first condition (without size field) |
$formula1 = substr($recordData, $offset, $sz1); |
$formula1 = pack('v', $sz1) . $formula1; // prepend the length |
try { |
$formula1 = $this->_getFormulaFromStructure($formula1); |
// in list type validity, null characters are used as item separators |
if ($type == PHPExcel_Cell_DataValidation::TYPE_LIST) { |
$formula1 = str_replace(chr(0), ',', $formula1); |
} |
} catch (PHPExcel_Exception $e) { |
return; |
} |
$offset += $sz1; |
// offset: var; size: 2; size of the formula data for the first condition |
$sz2 = self::_GetInt2d($recordData, $offset); |
$offset += 2; |
// offset: var; size: 2; not used |
$offset += 2; |
// offset: var; size: $sz2; formula data for second condition (without size field) |
$formula2 = substr($recordData, $offset, $sz2); |
$formula2 = pack('v', $sz2) . $formula2; // prepend the length |
try { |
$formula2 = $this->_getFormulaFromStructure($formula2); |
} catch (PHPExcel_Exception $e) { |
return; |
} |
$offset += $sz2; |
// offset: var; size: var; cell range address list with |
$cellRangeAddressList = $this->_readBIFF8CellRangeAddressList(substr($recordData, $offset)); |
$cellRangeAddresses = $cellRangeAddressList['cellRangeAddresses']; |
foreach ($cellRangeAddresses as $cellRange) { |
$stRange = $this->_phpSheet->shrinkRangeToFit($cellRange); |
$stRange = PHPExcel_Cell::extractAllCellReferencesInRange($stRange); |
foreach ($stRange as $coordinate) { |
$objValidation = $this->_phpSheet->getCell($coordinate)->getDataValidation(); |
$objValidation->setType($type); |
$objValidation->setErrorStyle($errorStyle); |
$objValidation->setAllowBlank((bool)$allowBlank); |
$objValidation->setShowInputMessage((bool)$showInputMessage); |
$objValidation->setShowErrorMessage((bool)$showErrorMessage); |
$objValidation->setShowDropDown(!$suppressDropDown); |
$objValidation->setOperator($operator); |
$objValidation->setErrorTitle($errorTitle); |
$objValidation->setError($error); |
$objValidation->setPromptTitle($promptTitle); |
$objValidation->setPrompt($prompt); |
$objValidation->setFormula1($formula1); |
$objValidation->setFormula2($formula2); |
} |
} |
} |
/** |
* Read SHEETLAYOUT record. Stores sheet tab color information. |
*/ |
private function _readSheetLayout() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
// local pointer in record data |
$offset = 0; |
if (!$this->_readDataOnly) { |
// offset: 0; size: 2; repeated record identifier 0x0862 |
// offset: 2; size: 10; not used |
// offset: 12; size: 4; size of record data |
// Excel 2003 uses size of 0x14 (documented), Excel 2007 uses size of 0x28 (not documented?) |
$sz = self::_GetInt4d($recordData, 12); |
switch ($sz) { |
case 0x14: |
// offset: 16; size: 2; color index for sheet tab |
$colorIndex = self::_GetInt2d($recordData, 16); |
$color = self::_readColor($colorIndex,$this->_palette,$this->_version); |
$this->_phpSheet->getTabColor()->setRGB($color['rgb']); |
break; |
case 0x28: |
// TODO: Investigate structure for .xls SHEETLAYOUT record as saved by MS Office Excel 2007 |
return; |
break; |
} |
} |
} |
/** |
* Read SHEETPROTECTION record (FEATHEADR) |
*/ |
private function _readSheetProtection() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
if ($this->_readDataOnly) { |
return; |
} |
// offset: 0; size: 2; repeated record header |
// offset: 2; size: 2; FRT cell reference flag (=0 currently) |
// offset: 4; size: 8; Currently not used and set to 0 |
// offset: 12; size: 2; Shared feature type index (2=Enhanced Protetion, 4=SmartTag) |
$isf = self::_GetInt2d($recordData, 12); |
if ($isf != 2) { |
return; |
} |
// offset: 14; size: 1; =1 since this is a feat header |
// offset: 15; size: 4; size of rgbHdrSData |
// rgbHdrSData, assume "Enhanced Protection" |
// offset: 19; size: 2; option flags |
$options = self::_GetInt2d($recordData, 19); |
// bit: 0; mask 0x0001; 1 = user may edit objects, 0 = users must not edit objects |
$bool = (0x0001 & $options) >> 0; |
$this->_phpSheet->getProtection()->setObjects(!$bool); |
// bit: 1; mask 0x0002; edit scenarios |
$bool = (0x0002 & $options) >> 1; |
$this->_phpSheet->getProtection()->setScenarios(!$bool); |
// bit: 2; mask 0x0004; format cells |
$bool = (0x0004 & $options) >> 2; |
$this->_phpSheet->getProtection()->setFormatCells(!$bool); |
// bit: 3; mask 0x0008; format columns |
$bool = (0x0008 & $options) >> 3; |
$this->_phpSheet->getProtection()->setFormatColumns(!$bool); |
// bit: 4; mask 0x0010; format rows |
$bool = (0x0010 & $options) >> 4; |
$this->_phpSheet->getProtection()->setFormatRows(!$bool); |
// bit: 5; mask 0x0020; insert columns |
$bool = (0x0020 & $options) >> 5; |
$this->_phpSheet->getProtection()->setInsertColumns(!$bool); |
// bit: 6; mask 0x0040; insert rows |
$bool = (0x0040 & $options) >> 6; |
$this->_phpSheet->getProtection()->setInsertRows(!$bool); |
// bit: 7; mask 0x0080; insert hyperlinks |
$bool = (0x0080 & $options) >> 7; |
$this->_phpSheet->getProtection()->setInsertHyperlinks(!$bool); |
// bit: 8; mask 0x0100; delete columns |
$bool = (0x0100 & $options) >> 8; |
$this->_phpSheet->getProtection()->setDeleteColumns(!$bool); |
// bit: 9; mask 0x0200; delete rows |
$bool = (0x0200 & $options) >> 9; |
$this->_phpSheet->getProtection()->setDeleteRows(!$bool); |
// bit: 10; mask 0x0400; select locked cells |
$bool = (0x0400 & $options) >> 10; |
$this->_phpSheet->getProtection()->setSelectLockedCells(!$bool); |
// bit: 11; mask 0x0800; sort cell range |
$bool = (0x0800 & $options) >> 11; |
$this->_phpSheet->getProtection()->setSort(!$bool); |
// bit: 12; mask 0x1000; auto filter |
$bool = (0x1000 & $options) >> 12; |
$this->_phpSheet->getProtection()->setAutoFilter(!$bool); |
// bit: 13; mask 0x2000; pivot tables |
$bool = (0x2000 & $options) >> 13; |
$this->_phpSheet->getProtection()->setPivotTables(!$bool); |
// bit: 14; mask 0x4000; select unlocked cells |
$bool = (0x4000 & $options) >> 14; |
$this->_phpSheet->getProtection()->setSelectUnlockedCells(!$bool); |
// offset: 21; size: 2; not used |
} |
/** |
* Read RANGEPROTECTION record |
* Reading of this record is based on Microsoft Office Excel 97-2000 Binary File Format Specification, |
* where it is referred to as FEAT record |
*/ |
private function _readRangeProtection() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
// local pointer in record data |
$offset = 0; |
if (!$this->_readDataOnly) { |
$offset += 12; |
// offset: 12; size: 2; shared feature type, 2 = enhanced protection, 4 = smart tag |
$isf = self::_GetInt2d($recordData, 12); |
if ($isf != 2) { |
// we only read FEAT records of type 2 |
return; |
} |
$offset += 2; |
$offset += 5; |
// offset: 19; size: 2; count of ref ranges this feature is on |
$cref = self::_GetInt2d($recordData, 19); |
$offset += 2; |
$offset += 6; |
// offset: 27; size: 8 * $cref; list of cell ranges (like in hyperlink record) |
$cellRanges = array(); |
for ($i = 0; $i < $cref; ++$i) { |
try { |
$cellRange = $this->_readBIFF8CellRangeAddressFixed(substr($recordData, 27 + 8 * $i, 8)); |
} catch (PHPExcel_Exception $e) { |
return; |
} |
$cellRanges[] = $cellRange; |
$offset += 8; |
} |
// offset: var; size: var; variable length of feature specific data |
$rgbFeat = substr($recordData, $offset); |
$offset += 4; |
// offset: var; size: 4; the encrypted password (only 16-bit although field is 32-bit) |
$wPassword = self::_GetInt4d($recordData, $offset); |
$offset += 4; |
// Apply range protection to sheet |
if ($cellRanges) { |
$this->_phpSheet->protectCells(implode(' ', $cellRanges), strtoupper(dechex($wPassword)), true); |
} |
} |
} |
/** |
* Read IMDATA record |
*/ |
private function _readImData() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
// get spliced record data |
$splicedRecordData = $this->_getSplicedRecordData(); |
$recordData = $splicedRecordData['recordData']; |
// UNDER CONSTRUCTION |
// offset: 0; size: 2; image format |
$cf = self::_GetInt2d($recordData, 0); |
// offset: 2; size: 2; environment from which the file was written |
$env = self::_GetInt2d($recordData, 2); |
// offset: 4; size: 4; length of the image data |
$lcb = self::_GetInt4d($recordData, 4); |
// offset: 8; size: var; image data |
$iData = substr($recordData, 8); |
switch ($cf) { |
case 0x09: // Windows bitmap format |
// BITMAPCOREINFO |
// 1. BITMAPCOREHEADER |
// offset: 0; size: 4; bcSize, Specifies the number of bytes required by the structure |
$bcSize = self::_GetInt4d($iData, 0); |
// var_dump($bcSize); |
// offset: 4; size: 2; bcWidth, specifies the width of the bitmap, in pixels |
$bcWidth = self::_GetInt2d($iData, 4); |
// var_dump($bcWidth); |
// offset: 6; size: 2; bcHeight, specifies the height of the bitmap, in pixels. |
$bcHeight = self::_GetInt2d($iData, 6); |
// var_dump($bcHeight); |
$ih = imagecreatetruecolor($bcWidth, $bcHeight); |
// offset: 8; size: 2; bcPlanes, specifies the number of planes for the target device. This value must be 1 |
// offset: 10; size: 2; bcBitCount specifies the number of bits-per-pixel. This value must be 1, 4, 8, or 24 |
$bcBitCount = self::_GetInt2d($iData, 10); |
// var_dump($bcBitCount); |
$rgbString = substr($iData, 12); |
$rgbTriples = array(); |
while (strlen($rgbString) > 0) { |
$rgbTriples[] = unpack('Cb/Cg/Cr', $rgbString); |
$rgbString = substr($rgbString, 3); |
} |
$x = 0; |
$y = 0; |
foreach ($rgbTriples as $i => $rgbTriple) { |
$color = imagecolorallocate($ih, $rgbTriple['r'], $rgbTriple['g'], $rgbTriple['b']); |
imagesetpixel($ih, $x, $bcHeight - 1 - $y, $color); |
$x = ($x + 1) % $bcWidth; |
$y = $y + floor(($x + 1) / $bcWidth); |
} |
//imagepng($ih, 'image.png'); |
$drawing = new PHPExcel_Worksheet_Drawing(); |
$drawing->setPath($filename); |
$drawing->setWorksheet($this->_phpSheet); |
break; |
case 0x02: // Windows metafile or Macintosh PICT format |
case 0x0e: // native format |
default; |
break; |
} |
// _getSplicedRecordData() takes care of moving current position in data stream |
} |
/** |
* Read a free CONTINUE record. Free CONTINUE record may be a camouflaged MSODRAWING record |
* When MSODRAWING data on a sheet exceeds 8224 bytes, CONTINUE records are used instead. Undocumented. |
* In this case, we must treat the CONTINUE record as a MSODRAWING record |
*/ |
private function _readContinue() |
{ |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$recordData = substr($this->_data, $this->_pos + 4, $length); |
// check if we are reading drawing data |
// this is in case a free CONTINUE record occurs in other circumstances we are unaware of |
if ($this->_drawingData == '') { |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
return; |
} |
// check if record data is at least 4 bytes long, otherwise there is no chance this is MSODRAWING data |
if ($length < 4) { |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
return; |
} |
// dirty check to see if CONTINUE record could be a camouflaged MSODRAWING record |
// look inside CONTINUE record to see if it looks like a part of an Escher stream |
// we know that Escher stream may be split at least at |
// 0xF003 MsofbtSpgrContainer |
// 0xF004 MsofbtSpContainer |
// 0xF00D MsofbtClientTextbox |
$validSplitPoints = array(0xF003, 0xF004, 0xF00D); // add identifiers if we find more |
$splitPoint = self::_GetInt2d($recordData, 2); |
if (in_array($splitPoint, $validSplitPoints)) { |
// get spliced record data (and move pointer to next record) |
$splicedRecordData = $this->_getSplicedRecordData(); |
$this->_drawingData .= $splicedRecordData['recordData']; |
return; |
} |
// move stream pointer to next record |
$this->_pos += 4 + $length; |
} |
/** |
* Reads a record from current position in data stream and continues reading data as long as CONTINUE |
* records are found. Splices the record data pieces and returns the combined string as if record data |
* is in one piece. |
* Moves to next current position in data stream to start of next record different from a CONtINUE record |
* |
* @return array |
*/ |
private function _getSplicedRecordData() |
{ |
$data = ''; |
$spliceOffsets = array(); |
$i = 0; |
$spliceOffsets[0] = 0; |
do { |
++$i; |
// offset: 0; size: 2; identifier |
$identifier = self::_GetInt2d($this->_data, $this->_pos); |
// offset: 2; size: 2; length |
$length = self::_GetInt2d($this->_data, $this->_pos + 2); |
$data .= substr($this->_data, $this->_pos + 4, $length); |
$spliceOffsets[$i] = $spliceOffsets[$i - 1] + $length; |
$this->_pos += 4 + $length; |
$nextIdentifier = self::_GetInt2d($this->_data, $this->_pos); |
} |
while ($nextIdentifier == self::XLS_Type_CONTINUE); |
$splicedData = array( |
'recordData' => $data, |
'spliceOffsets' => $spliceOffsets, |
); |
return $splicedData; |
} |
/** |
* Convert formula structure into human readable Excel formula like 'A3+A5*5' |
* |
* @param string $formulaStructure The complete binary data for the formula |
* @param string $baseCell Base cell, only needed when formula contains tRefN tokens, e.g. with shared formulas |
* @return string Human readable formula |
*/ |
private function _getFormulaFromStructure($formulaStructure, $baseCell = 'A1') |
{ |
// offset: 0; size: 2; size of the following formula data |
$sz = self::_GetInt2d($formulaStructure, 0); |
// offset: 2; size: sz |
$formulaData = substr($formulaStructure, 2, $sz); |
// for debug: dump the formula data |
//echo '<xmp>'; |
//echo 'size: ' . $sz . "\n"; |
//echo 'the entire formula data: '; |
//Debug::dump($formulaData); |
//echo "\n----\n"; |
// offset: 2 + sz; size: variable (optional) |
if (strlen($formulaStructure) > 2 + $sz) { |
$additionalData = substr($formulaStructure, 2 + $sz); |
// for debug: dump the additional data |
//echo 'the entire additional data: '; |
//Debug::dump($additionalData); |
//echo "\n----\n"; |
} else { |
$additionalData = ''; |
} |
return $this->_getFormulaFromData($formulaData, $additionalData, $baseCell); |
} |
/** |
* Take formula data and additional data for formula and return human readable formula |
* |
* @param string $formulaData The binary data for the formula itself |
* @param string $additionalData Additional binary data going with the formula |
* @param string $baseCell Base cell, only needed when formula contains tRefN tokens, e.g. with shared formulas |
* @return string Human readable formula |
*/ |
private function _getFormulaFromData($formulaData, $additionalData = '', $baseCell = 'A1') |
{ |
// start parsing the formula data |
$tokens = array(); |
while (strlen($formulaData) > 0 and $token = $this->_getNextToken($formulaData, $baseCell)) { |
$tokens[] = $token; |
$formulaData = substr($formulaData, $token['size']); |
// for debug: dump the token |
//var_dump($token); |
} |
$formulaString = $this->_createFormulaFromTokens($tokens, $additionalData); |
return $formulaString; |
} |
/** |
* Take array of tokens together with additional data for formula and return human readable formula |
* |
* @param array $tokens |
* @param array $additionalData Additional binary data going with the formula |
* @param string $baseCell Base cell, only needed when formula contains tRefN tokens, e.g. with shared formulas |
* @return string Human readable formula |
*/ |
private function _createFormulaFromTokens($tokens, $additionalData) |
{ |
// empty formula? |
if (empty($tokens)) { |
return ''; |
} |
$formulaStrings = array(); |
foreach ($tokens as $token) { |
// initialize spaces |
$space0 = isset($space0) ? $space0 : ''; // spaces before next token, not tParen |
$space1 = isset($space1) ? $space1 : ''; // carriage returns before next token, not tParen |
$space2 = isset($space2) ? $space2 : ''; // spaces before opening parenthesis |
$space3 = isset($space3) ? $space3 : ''; // carriage returns before opening parenthesis |
$space4 = isset($space4) ? $space4 : ''; // spaces before closing parenthesis |
$space5 = isset($space5) ? $space5 : ''; // carriage returns before closing parenthesis |
switch ($token['name']) { |
case 'tAdd': // addition |
case 'tConcat': // addition |
case 'tDiv': // division |
case 'tEQ': // equality |
case 'tGE': // greater than or equal |
case 'tGT': // greater than |
case 'tIsect': // intersection |
case 'tLE': // less than or equal |
case 'tList': // less than or equal |
case 'tLT': // less than |
case 'tMul': // multiplication |
case 'tNE': // multiplication |
case 'tPower': // power |
case 'tRange': // range |
case 'tSub': // subtraction |
$op2 = array_pop($formulaStrings); |
$op1 = array_pop($formulaStrings); |
$formulaStrings[] = "$op1$space1$space0{$token['data']}$op2"; |
unset($space0, $space1); |
break; |
case 'tUplus': // unary plus |
case 'tUminus': // unary minus |
$op = array_pop($formulaStrings); |
$formulaStrings[] = "$space1$space0{$token['data']}$op"; |
unset($space0, $space1); |
break; |
case 'tPercent': // percent sign |
$op = array_pop($formulaStrings); |
$formulaStrings[] = "$op$space1$space0{$token['data']}"; |
unset($space0, $space1); |
break; |
case 'tAttrVolatile': // indicates volatile function |
case 'tAttrIf': |
case 'tAttrSkip': |
case 'tAttrChoose': |
// token is only important for Excel formula evaluator |
// do nothing |
break; |
case 'tAttrSpace': // space / carriage return |
// space will be used when next token arrives, do not alter formulaString stack |
switch ($token['data']['spacetype']) { |
case 'type0': |
$space0 = str_repeat(' ', $token['data']['spacecount']); |
break; |
case 'type1': |
$space1 = str_repeat("\n", $token['data']['spacecount']); |
break; |
case 'type2': |
$space2 = str_repeat(' ', $token['data']['spacecount']); |
break; |
case 'type3': |
$space3 = str_repeat("\n", $token['data']['spacecount']); |
break; |
case 'type4': |
$space4 = str_repeat(' ', $token['data']['spacecount']); |
break; |
case 'type5': |
$space5 = str_repeat("\n", $token['data']['spacecount']); |
break; |
} |
break; |
case 'tAttrSum': // SUM function with one parameter |
$op = array_pop($formulaStrings); |
$formulaStrings[] = "{$space1}{$space0}SUM($op)"; |
unset($space0, $space1); |
break; |
case 'tFunc': // function with fixed number of arguments |
case 'tFuncV': // function with variable number of arguments |
if ($token['data']['function'] != '') { |
// normal function |
$ops = array(); // array of operators |
for ($i = 0; $i < $token['data']['args']; ++$i) { |
$ops[] = array_pop($formulaStrings); |
} |
$ops = array_reverse($ops); |
$formulaStrings[] = "$space1$space0{$token['data']['function']}(" . implode(',', $ops) . ")"; |
unset($space0, $space1); |
} else { |
// add-in function |
$ops = array(); // array of operators |
for ($i = 0; $i < $token['data']['args'] - 1; ++$i) { |
$ops[] = array_pop($formulaStrings); |
} |
$ops = array_reverse($ops); |
$function = array_pop($formulaStrings); |
$formulaStrings[] = "$space1$space0$function(" . implode(',', $ops) . ")"; |
unset($space0, $space1); |
} |
break; |
case 'tParen': // parenthesis |
$expression = array_pop($formulaStrings); |
$formulaStrings[] = "$space3$space2($expression$space5$space4)"; |
unset($space2, $space3, $space4, $space5); |
break; |
case 'tArray': // array constant |
$constantArray = self::_readBIFF8ConstantArray($additionalData); |
$formulaStrings[] = $space1 . $space0 . $constantArray['value']; |
$additionalData = substr($additionalData, $constantArray['size']); // bite of chunk of additional data |
unset($space0, $space1); |
break; |
case 'tMemArea': |
// bite off chunk of additional data |
$cellRangeAddressList = $this->_readBIFF8CellRangeAddressList($additionalData); |
$additionalData = substr($additionalData, $cellRangeAddressList['size']); |
$formulaStrings[] = "$space1$space0{$token['data']}"; |
unset($space0, $space1); |
break; |
case 'tArea': // cell range address |
case 'tBool': // boolean |
case 'tErr': // error code |
case 'tInt': // integer |
case 'tMemErr': |
case 'tMemFunc': |
case 'tMissArg': |
case 'tName': |
case 'tNameX': |
case 'tNum': // number |
case 'tRef': // single cell reference |
case 'tRef3d': // 3d cell reference |
case 'tArea3d': // 3d cell range reference |
case 'tRefN': |
case 'tAreaN': |
case 'tStr': // string |
$formulaStrings[] = "$space1$space0{$token['data']}"; |
unset($space0, $space1); |
break; |
} |
} |
$formulaString = $formulaStrings[0]; |
// for debug: dump the human readable formula |
//echo '----' . "\n"; |
//echo 'Formula: ' . $formulaString; |
return $formulaString; |
} |
/** |
* Fetch next token from binary formula data |
* |
* @param string Formula data |
* @param string $baseCell Base cell, only needed when formula contains tRefN tokens, e.g. with shared formulas |
* @return array |
* @throws PHPExcel_Reader_Exception |
*/ |
private function _getNextToken($formulaData, $baseCell = 'A1') |
{ |
// offset: 0; size: 1; token id |
$id = ord($formulaData[0]); // token id |
$name = false; // initialize token name |
switch ($id) { |
case 0x03: $name = 'tAdd'; $size = 1; $data = '+'; break; |
case 0x04: $name = 'tSub'; $size = 1; $data = '-'; break; |
case 0x05: $name = 'tMul'; $size = 1; $data = '*'; break; |
case 0x06: $name = 'tDiv'; $size = 1; $data = '/'; break; |
case 0x07: $name = 'tPower'; $size = 1; $data = '^'; break; |
case 0x08: $name = 'tConcat'; $size = 1; $data = '&'; break; |
case 0x09: $name = 'tLT'; $size = 1; $data = '<'; break; |
case 0x0A: $name = 'tLE'; $size = 1; $data = '<='; break; |
case 0x0B: $name = 'tEQ'; $size = 1; $data = '='; break; |
case 0x0C: $name = 'tGE'; $size = 1; $data = '>='; break; |
case 0x0D: $name = 'tGT'; $size = 1; $data = '>'; break; |
case 0x0E: $name = 'tNE'; $size = 1; $data = '<>'; break; |
case 0x0F: $name = 'tIsect'; $size = 1; $data = ' '; break; |
case 0x10: $name = 'tList'; $size = 1; $data = ','; break; |
case 0x11: $name = 'tRange'; $size = 1; $data = ':'; break; |
case 0x12: $name = 'tUplus'; $size = 1; $data = '+'; break; |
case 0x13: $name = 'tUminus'; $size = 1; $data = '-'; break; |
case 0x14: $name = 'tPercent'; $size = 1; $data = '%'; break; |
case 0x15: // parenthesis |
$name = 'tParen'; |
$size = 1; |
$data = null; |
break; |
case 0x16: // missing argument |
$name = 'tMissArg'; |
$size = 1; |
$data = ''; |
break; |
case 0x17: // string |
$name = 'tStr'; |
// offset: 1; size: var; Unicode string, 8-bit string length |
$string = self::_readUnicodeStringShort(substr($formulaData, 1)); |
$size = 1 + $string['size']; |
$data = self::_UTF8toExcelDoubleQuoted($string['value']); |
break; |
case 0x19: // Special attribute |
// offset: 1; size: 1; attribute type flags: |
switch (ord($formulaData[1])) { |
case 0x01: |
$name = 'tAttrVolatile'; |
$size = 4; |
$data = null; |
break; |
case 0x02: |
$name = 'tAttrIf'; |
$size = 4; |
$data = null; |
break; |
case 0x04: |
$name = 'tAttrChoose'; |
// offset: 2; size: 2; number of choices in the CHOOSE function ($nc, number of parameters decreased by 1) |
$nc = self::_GetInt2d($formulaData, 2); |
// offset: 4; size: 2 * $nc |
// offset: 4 + 2 * $nc; size: 2 |
$size = 2 * $nc + 6; |
$data = null; |
break; |
case 0x08: |
$name = 'tAttrSkip'; |
$size = 4; |
$data = null; |
break; |
case 0x10: |
$name = 'tAttrSum'; |
$size = 4; |
$data = null; |
break; |
case 0x40: |
case 0x41: |
$name = 'tAttrSpace'; |
$size = 4; |
// offset: 2; size: 2; space type and position |
switch (ord($formulaData[2])) { |
case 0x00: |
$spacetype = 'type0'; |
break; |
case 0x01: |
$spacetype = 'type1'; |
break; |
case 0x02: |
$spacetype = 'type2'; |
break; |
case 0x03: |
$spacetype = 'type3'; |
break; |
case 0x04: |
$spacetype = 'type4'; |
break; |
case 0x05: |
$spacetype = 'type5'; |
break; |
default: |
throw new PHPExcel_Reader_Exception('Unrecognized space type in tAttrSpace token'); |
break; |
} |
// offset: 3; size: 1; number of inserted spaces/carriage returns |
$spacecount = ord($formulaData[3]); |
$data = array('spacetype' => $spacetype, 'spacecount' => $spacecount); |
break; |
default: |
throw new PHPExcel_Reader_Exception('Unrecognized attribute flag in tAttr token'); |
break; |
} |
break; |
case 0x1C: // error code |
// offset: 1; size: 1; error code |
$name = 'tErr'; |
$size = 2; |
$data = self::_mapErrorCode(ord($formulaData[1])); |
break; |
case 0x1D: // boolean |
// offset: 1; size: 1; 0 = false, 1 = true; |
$name = 'tBool'; |
$size = 2; |
$data = ord($formulaData[1]) ? 'TRUE' : 'FALSE'; |
break; |
case 0x1E: // integer |
// offset: 1; size: 2; unsigned 16-bit integer |
$name = 'tInt'; |
$size = 3; |
$data = self::_GetInt2d($formulaData, 1); |
break; |
case 0x1F: // number |
// offset: 1; size: 8; |
$name = 'tNum'; |
$size = 9; |
$data = self::_extractNumber(substr($formulaData, 1)); |
$data = str_replace(',', '.', (string)$data); // in case non-English locale |
break; |
case 0x20: // array constant |
case 0x40: |
case 0x60: |
// offset: 1; size: 7; not used |
$name = 'tArray'; |
$size = 8; |
$data = null; |
break; |
case 0x21: // function with fixed number of arguments |
case 0x41: |
case 0x61: |
$name = 'tFunc'; |
$size = 3; |
// offset: 1; size: 2; index to built-in sheet function |
switch (self::_GetInt2d($formulaData, 1)) { |
case 2: $function = 'ISNA'; $args = 1; break; |
case 3: $function = 'ISERROR'; $args = 1; break; |
case 10: $function = 'NA'; $args = 0; break; |
case 15: $function = 'SIN'; $args = 1; break; |
case 16: $function = 'COS'; $args = 1; break; |
case 17: $function = 'TAN'; $args = 1; break; |
case 18: $function = 'ATAN'; $args = 1; break; |
case 19: $function = 'PI'; $args = 0; break; |
case 20: $function = 'SQRT'; $args = 1; break; |
case 21: $function = 'EXP'; $args = 1; break; |
case 22: $function = 'LN'; $args = 1; break; |
case 23: $function = 'LOG10'; $args = 1; break; |
case 24: $function = 'ABS'; $args = 1; break; |
case 25: $function = 'INT'; $args = 1; break; |
case 26: $function = 'SIGN'; $args = 1; break; |
case 27: $function = 'ROUND'; $args = 2; break; |
case 30: $function = 'REPT'; $args = 2; break; |
case 31: $function = 'MID'; $args = 3; break; |
case 32: $function = 'LEN'; $args = 1; break; |
case 33: $function = 'VALUE'; $args = 1; break; |
case 34: $function = 'TRUE'; $args = 0; break; |
case 35: $function = 'FALSE'; $args = 0; break; |
case 38: $function = 'NOT'; $args = 1; break; |
case 39: $function = 'MOD'; $args = 2; break; |
case 40: $function = 'DCOUNT'; $args = 3; break; |
case 41: $function = 'DSUM'; $args = 3; break; |
case 42: $function = 'DAVERAGE'; $args = 3; break; |
case 43: $function = 'DMIN'; $args = 3; break; |
case 44: $function = 'DMAX'; $args = 3; break; |
case 45: $function = 'DSTDEV'; $args = 3; break; |
case 48: $function = 'TEXT'; $args = 2; break; |
case 61: $function = 'MIRR'; $args = 3; break; |
case 63: $function = 'RAND'; $args = 0; break; |
case 65: $function = 'DATE'; $args = 3; break; |
case 66: $function = 'TIME'; $args = 3; break; |
case 67: $function = 'DAY'; $args = 1; break; |
case 68: $function = 'MONTH'; $args = 1; break; |
case 69: $function = 'YEAR'; $args = 1; break; |
case 71: $function = 'HOUR'; $args = 1; break; |
case 72: $function = 'MINUTE'; $args = 1; break; |
case 73: $function = 'SECOND'; $args = 1; break; |
case 74: $function = 'NOW'; $args = 0; break; |
case 75: $function = 'AREAS'; $args = 1; break; |
case 76: $function = 'ROWS'; $args = 1; break; |
case 77: $function = 'COLUMNS'; $args = 1; break; |
case 83: $function = 'TRANSPOSE'; $args = 1; break; |
case 86: $function = 'TYPE'; $args = 1; break; |
case 97: $function = 'ATAN2'; $args = 2; break; |
case 98: $function = 'ASIN'; $args = 1; break; |
case 99: $function = 'ACOS'; $args = 1; break; |
case 105: $function = 'ISREF'; $args = 1; break; |
case 111: $function = 'CHAR'; $args = 1; break; |
case 112: $function = 'LOWER'; $args = 1; break; |
case 113: $function = 'UPPER'; $args = 1; break; |
case 114: $function = 'PROPER'; $args = 1; break; |
case 117: $function = 'EXACT'; $args = 2; break; |
case 118: $function = 'TRIM'; $args = 1; break; |
case 119: $function = 'REPLACE'; $args = 4; break; |
case 121: $function = 'CODE'; $args = 1; break; |
case 126: $function = 'ISERR'; $args = 1; break; |
case 127: $function = 'ISTEXT'; $args = 1; break; |
case 128: $function = 'ISNUMBER'; $args = 1; break; |
case 129: $function = 'ISBLANK'; $args = 1; break; |
case 130: $function = 'T'; $args = 1; break; |
case 131: $function = 'N'; $args = 1; break; |
case 140: $function = 'DATEVALUE'; $args = 1; break; |
case 141: $function = 'TIMEVALUE'; $args = 1; break; |
case 142: $function = 'SLN'; $args = 3; break; |
case 143: $function = 'SYD'; $args = 4; break; |
case 162: $function = 'CLEAN'; $args = 1; break; |
case 163: $function = 'MDETERM'; $args = 1; break; |
case 164: $function = 'MINVERSE'; $args = 1; break; |
case 165: $function = 'MMULT'; $args = 2; break; |
case 184: $function = 'FACT'; $args = 1; break; |
case 189: $function = 'DPRODUCT'; $args = 3; break; |
case 190: $function = 'ISNONTEXT'; $args = 1; break; |
case 195: $function = 'DSTDEVP'; $args = 3; break; |
case 196: $function = 'DVARP'; $args = 3; break; |
case 198: $function = 'ISLOGICAL'; $args = 1; break; |
case 199: $function = 'DCOUNTA'; $args = 3; break; |
case 207: $function = 'REPLACEB'; $args = 4; break; |
case 210: $function = 'MIDB'; $args = 3; break; |
case 211: $function = 'LENB'; $args = 1; break; |
case 212: $function = 'ROUNDUP'; $args = 2; break; |
case 213: $function = 'ROUNDDOWN'; $args = 2; break; |
case 214: $function = 'ASC'; $args = 1; break; |
case 215: $function = 'DBCS'; $args = 1; break; |
case 221: $function = 'TODAY'; $args = 0; break; |
case 229: $function = 'SINH'; $args = 1; break; |
case 230: $function = 'COSH'; $args = 1; break; |
case 231: $function = 'TANH'; $args = 1; break; |
case 232: $function = 'ASINH'; $args = 1; break; |
case 233: $function = 'ACOSH'; $args = 1; break; |
case 234: $function = 'ATANH'; $args = 1; break; |
case 235: $function = 'DGET'; $args = 3; break; |
case 244: $function = 'INFO'; $args = 1; break; |
case 252: $function = 'FREQUENCY'; $args = 2; break; |
case 261: $function = 'ERROR.TYPE'; $args = 1; break; |
case 271: $function = 'GAMMALN'; $args = 1; break; |
case 273: $function = 'BINOMDIST'; $args = 4; break; |
case 274: $function = 'CHIDIST'; $args = 2; break; |
case 275: $function = 'CHIINV'; $args = 2; break; |
case 276: $function = 'COMBIN'; $args = 2; break; |
case 277: $function = 'CONFIDENCE'; $args = 3; break; |
case 278: $function = 'CRITBINOM'; $args = 3; break; |
case 279: $function = 'EVEN'; $args = 1; break; |
case 280: $function = 'EXPONDIST'; $args = 3; break; |
case 281: $function = 'FDIST'; $args = 3; break; |
case 282: $function = 'FINV'; $args = 3; break; |
case 283: $function = 'FISHER'; $args = 1; break; |
case 284: $function = 'FISHERINV'; $args = 1; break; |
case 285: $function = 'FLOOR'; $args = 2; break; |
case 286: $function = 'GAMMADIST'; $args = 4; break; |
case 287: $function = 'GAMMAINV'; $args = 3; break; |
case 288: $function = 'CEILING'; $args = 2; break; |
case 289: $function = 'HYPGEOMDIST'; $args = 4; break; |
case 290: $function = 'LOGNORMDIST'; $args = 3; break; |
case 291: $function = 'LOGINV'; $args = 3; break; |
case 292: $function = 'NEGBINOMDIST'; $args = 3; break; |
case 293: $function = 'NORMDIST'; $args = 4; break; |
case 294: $function = 'NORMSDIST'; $args = 1; break; |
case 295: $function = 'NORMINV'; $args = 3; break; |
case 296: $function = 'NORMSINV'; $args = 1; break; |
case 297: $function = 'STANDARDIZE'; $args = 3; break; |
case 298: $function = 'ODD'; $args = 1; break; |
case 299: $function = 'PERMUT'; $args = 2; break; |
case 300: $function = 'POISSON'; $args = 3; break; |
case 301: $function = 'TDIST'; $args = 3; break; |
case 302: $function = 'WEIBULL'; $args = 4; break; |
case 303: $function = 'SUMXMY2'; $args = 2; break; |
case 304: $function = 'SUMX2MY2'; $args = 2; break; |
case 305: $function = 'SUMX2PY2'; $args = 2; break; |
case 306: $function = 'CHITEST'; $args = 2; break; |
case 307: $function = 'CORREL'; $args = 2; break; |
case 308: $function = 'COVAR'; $args = 2; break; |
case 309: $function = 'FORECAST'; $args = 3; break; |
case 310: $function = 'FTEST'; $args = 2; break; |
case 311: $function = 'INTERCEPT'; $args = 2; break; |
case 312: $function = 'PEARSON'; $args = 2; break; |
case 313: $function = 'RSQ'; $args = 2; break; |
case 314: $function = 'STEYX'; $args = 2; break; |
case 315: $function = 'SLOPE'; $args = 2; break; |
case 316: $function = 'TTEST'; $args = 4; break; |
case 325: $function = 'LARGE'; $args = 2; break; |
case 326: $function = 'SMALL'; $args = 2; break; |
case 327: $function = 'QUARTILE'; $args = 2; break; |
case 328: $function = 'PERCENTILE'; $args = 2; break; |
case 331: $function = 'TRIMMEAN'; $args = 2; break; |
case 332: $function = 'TINV'; $args = 2; break; |
case 337: $function = 'POWER'; $args = 2; break; |
case 342: $function = 'RADIANS'; $args = 1; break; |
case 343: $function = 'DEGREES'; $args = 1; break; |
case 346: $function = 'COUNTIF'; $args = 2; break; |
case 347: $function = 'COUNTBLANK'; $args = 1; break; |
case 350: $function = 'ISPMT'; $args = 4; break; |
case 351: $function = 'DATEDIF'; $args = 3; break; |
case 352: $function = 'DATESTRING'; $args = 1; break; |
case 353: $function = 'NUMBERSTRING'; $args = 2; break; |
case 360: $function = 'PHONETIC'; $args = 1; break; |
case 368: $function = 'BAHTTEXT'; $args = 1; break; |
default: |
throw new PHPExcel_Reader_Exception('Unrecognized function in formula'); |
break; |
} |
$data = array('function' => $function, 'args' => $args); |
break; |
case 0x22: // function with variable number of arguments |
case 0x42: |
case 0x62: |
$name = 'tFuncV'; |
$size = 4; |
// offset: 1; size: 1; number of arguments |
$args = ord($formulaData[1]); |
// offset: 2: size: 2; index to built-in sheet function |
$index = self::_GetInt2d($formulaData, 2); |
switch ($index) { |
case 0: $function = 'COUNT'; break; |
case 1: $function = 'IF'; break; |
case 4: $function = 'SUM'; break; |
case 5: $function = 'AVERAGE'; break; |
case 6: $function = 'MIN'; break; |
case 7: $function = 'MAX'; break; |
case 8: $function = 'ROW'; break; |
case 9: $function = 'COLUMN'; break; |
case 11: $function = 'NPV'; break; |
case 12: $function = 'STDEV'; break; |
case 13: $function = 'DOLLAR'; break; |
case 14: $function = 'FIXED'; break; |
case 28: $function = 'LOOKUP'; break; |
case 29: $function = 'INDEX'; break; |
case 36: $function = 'AND'; break; |
case 37: $function = 'OR'; break; |
case 46: $function = 'VAR'; break; |
case 49: $function = 'LINEST'; break; |
case 50: $function = 'TREND'; break; |
case 51: $function = 'LOGEST'; break; |
case 52: $function = 'GROWTH'; break; |
case 56: $function = 'PV'; break; |
case 57: $function = 'FV'; break; |
case 58: $function = 'NPER'; break; |
case 59: $function = 'PMT'; break; |
case 60: $function = 'RATE'; break; |
case 62: $function = 'IRR'; break; |
case 64: $function = 'MATCH'; break; |
case 70: $function = 'WEEKDAY'; break; |
case 78: $function = 'OFFSET'; break; |
case 82: $function = 'SEARCH'; break; |
case 100: $function = 'CHOOSE'; break; |
case 101: $function = 'HLOOKUP'; break; |
case 102: $function = 'VLOOKUP'; break; |
case 109: $function = 'LOG'; break; |
case 115: $function = 'LEFT'; break; |
case 116: $function = 'RIGHT'; break; |
case 120: $function = 'SUBSTITUTE'; break; |
case 124: $function = 'FIND'; break; |
case 125: $function = 'CELL'; break; |
case 144: $function = 'DDB'; break; |
case 148: $function = 'INDIRECT'; break; |
case 167: $function = 'IPMT'; break; |
case 168: $function = 'PPMT'; break; |
case 169: $function = 'COUNTA'; break; |
case 183: $function = 'PRODUCT'; break; |
case 193: $function = 'STDEVP'; break; |
case 194: $function = 'VARP'; break; |
case 197: $function = 'TRUNC'; break; |
case 204: $function = 'USDOLLAR'; break; |
case 205: $function = 'FINDB'; break; |
case 206: $function = 'SEARCHB'; break; |
case 208: $function = 'LEFTB'; break; |
case 209: $function = 'RIGHTB'; break; |
case 216: $function = 'RANK'; break; |
case 219: $function = 'ADDRESS'; break; |
case 220: $function = 'DAYS360'; break; |
case 222: $function = 'VDB'; break; |
case 227: $function = 'MEDIAN'; break; |
case 228: $function = 'SUMPRODUCT'; break; |
case 247: $function = 'DB'; break; |
case 255: $function = ''; break; |
case 269: $function = 'AVEDEV'; break; |
case 270: $function = 'BETADIST'; break; |
case 272: $function = 'BETAINV'; break; |
case 317: $function = 'PROB'; break; |
case 318: $function = 'DEVSQ'; break; |
case 319: $function = 'GEOMEAN'; break; |
case 320: $function = 'HARMEAN'; break; |
case 321: $function = 'SUMSQ'; break; |
case 322: $function = 'KURT'; break; |
case 323: $function = 'SKEW'; break; |
case 324: $function = 'ZTEST'; break; |
case 329: $function = 'PERCENTRANK'; break; |
case 330: $function = 'MODE'; break; |
case 336: $function = 'CONCATENATE'; break; |
case 344: $function = 'SUBTOTAL'; break; |
case 345: $function = 'SUMIF'; break; |
case 354: $function = 'ROMAN'; break; |
case 358: $function = 'GETPIVOTDATA'; break; |
case 359: $function = 'HYPERLINK'; break; |
case 361: $function = 'AVERAGEA'; break; |
case 362: $function = 'MAXA'; break; |
case 363: $function = 'MINA'; break; |
case 364: $function = 'STDEVPA'; break; |
case 365: $function = 'VARPA'; break; |
case 366: $function = 'STDEVA'; break; |
case 367: $function = 'VARA'; break; |
default: |
throw new PHPExcel_Reader_Exception('Unrecognized function in formula'); |
break; |
} |
$data = array('function' => $function, 'args' => $args); |
break; |
case 0x23: // index to defined name |
case 0x43: |
case 0x63: |
$name = 'tName'; |
$size = 5; |
// offset: 1; size: 2; one-based index to definedname record |
$definedNameIndex = self::_GetInt2d($formulaData, 1) - 1; |
// offset: 2; size: 2; not used |
$data = $this->_definedname[$definedNameIndex]['name']; |
break; |
case 0x24: // single cell reference e.g. A5 |
case 0x44: |
case 0x64: |
$name = 'tRef'; |
$size = 5; |
$data = $this->_readBIFF8CellAddress(substr($formulaData, 1, 4)); |
break; |
case 0x25: // cell range reference to cells in the same sheet (2d) |
case 0x45: |
case 0x65: |
$name = 'tArea'; |
$size = 9; |
$data = $this->_readBIFF8CellRangeAddress(substr($formulaData, 1, 8)); |
break; |
case 0x26: // Constant reference sub-expression |
case 0x46: |
case 0x66: |
$name = 'tMemArea'; |
// offset: 1; size: 4; not used |
// offset: 5; size: 2; size of the following subexpression |
$subSize = self::_GetInt2d($formulaData, 5); |
$size = 7 + $subSize; |
$data = $this->_getFormulaFromData(substr($formulaData, 7, $subSize)); |
break; |
case 0x27: // Deleted constant reference sub-expression |
case 0x47: |
case 0x67: |
$name = 'tMemErr'; |
// offset: 1; size: 4; not used |
// offset: 5; size: 2; size of the following subexpression |
$subSize = self::_GetInt2d($formulaData, 5); |
$size = 7 + $subSize; |
$data = $this->_getFormulaFromData(substr($formulaData, 7, $subSize)); |
break; |
case 0x29: // Variable reference sub-expression |
case 0x49: |
case 0x69: |
$name = 'tMemFunc'; |
// offset: 1; size: 2; size of the following sub-expression |
$subSize = self::_GetInt2d($formulaData, 1); |
$size = 3 + $subSize; |
$data = $this->_getFormulaFromData(substr($formulaData, 3, $subSize)); |
break; |
case 0x2C: // Relative 2d cell reference reference, used in shared formulas and some other places |
case 0x4C: |
case 0x6C: |
$name = 'tRefN'; |
$size = 5; |
$data = $this->_readBIFF8CellAddressB(substr($formulaData, 1, 4), $baseCell); |
break; |
case 0x2D: // Relative 2d range reference |
case 0x4D: |
case 0x6D: |
$name = 'tAreaN'; |
$size = 9; |
$data = $this->_readBIFF8CellRangeAddressB(substr($formulaData, 1, 8), $baseCell); |
break; |
case 0x39: // External name |
case 0x59: |
case 0x79: |
$name = 'tNameX'; |
$size = 7; |
// offset: 1; size: 2; index to REF entry in EXTERNSHEET record |
// offset: 3; size: 2; one-based index to DEFINEDNAME or EXTERNNAME record |
$index = self::_GetInt2d($formulaData, 3); |
// assume index is to EXTERNNAME record |
$data = $this->_externalNames[$index - 1]['name']; |
// offset: 5; size: 2; not used |
break; |
case 0x3A: // 3d reference to cell |
case 0x5A: |
case 0x7A: |
$name = 'tRef3d'; |
$size = 7; |
try { |
// offset: 1; size: 2; index to REF entry |
$sheetRange = $this->_readSheetRangeByRefIndex(self::_GetInt2d($formulaData, 1)); |
// offset: 3; size: 4; cell address |
$cellAddress = $this->_readBIFF8CellAddress(substr($formulaData, 3, 4)); |
$data = "$sheetRange!$cellAddress"; |
} catch (PHPExcel_Exception $e) { |
// deleted sheet reference |
$data = '#REF!'; |
} |
break; |
case 0x3B: // 3d reference to cell range |
case 0x5B: |
case 0x7B: |
$name = 'tArea3d'; |
$size = 11; |
try { |
// offset: 1; size: 2; index to REF entry |
$sheetRange = $this->_readSheetRangeByRefIndex(self::_GetInt2d($formulaData, 1)); |
// offset: 3; size: 8; cell address |
$cellRangeAddress = $this->_readBIFF8CellRangeAddress(substr($formulaData, 3, 8)); |
$data = "$sheetRange!$cellRangeAddress"; |
} catch (PHPExcel_Exception $e) { |
// deleted sheet reference |
$data = '#REF!'; |
} |
break; |
// Unknown cases // don't know how to deal with |
default: |
throw new PHPExcel_Reader_Exception('Unrecognized token ' . sprintf('%02X', $id) . ' in formula'); |
break; |
} |
return array( |
'id' => $id, |
'name' => $name, |
'size' => $size, |
'data' => $data, |
); |
} |
/** |
* Reads a cell address in BIFF8 e.g. 'A2' or '$A$2' |
* section 3.3.4 |
* |
* @param string $cellAddressStructure |
* @return string |
*/ |
private function _readBIFF8CellAddress($cellAddressStructure) |
{ |
// offset: 0; size: 2; index to row (0... 65535) (or offset (-32768... 32767)) |
$row = self::_GetInt2d($cellAddressStructure, 0) + 1; |
// offset: 2; size: 2; index to column or column offset + relative flags |
// bit: 7-0; mask 0x00FF; column index |
$column = PHPExcel_Cell::stringFromColumnIndex(0x00FF & self::_GetInt2d($cellAddressStructure, 2)); |
// bit: 14; mask 0x4000; (1 = relative column index, 0 = absolute column index) |
if (!(0x4000 & self::_GetInt2d($cellAddressStructure, 2))) { |
$column = '$' . $column; |
} |
// bit: 15; mask 0x8000; (1 = relative row index, 0 = absolute row index) |
if (!(0x8000 & self::_GetInt2d($cellAddressStructure, 2))) { |
$row = '$' . $row; |
} |
return $column . $row; |
} |
/** |
* Reads a cell address in BIFF8 for shared formulas. Uses positive and negative values for row and column |
* to indicate offsets from a base cell |
* section 3.3.4 |
* |
* @param string $cellAddressStructure |
* @param string $baseCell Base cell, only needed when formula contains tRefN tokens, e.g. with shared formulas |
* @return string |
*/ |
private function _readBIFF8CellAddressB($cellAddressStructure, $baseCell = 'A1') |
{ |
list($baseCol, $baseRow) = PHPExcel_Cell::coordinateFromString($baseCell); |
$baseCol = PHPExcel_Cell::columnIndexFromString($baseCol) - 1; |
// offset: 0; size: 2; index to row (0... 65535) (or offset (-32768... 32767)) |
$rowIndex = self::_GetInt2d($cellAddressStructure, 0); |
$row = self::_GetInt2d($cellAddressStructure, 0) + 1; |
// offset: 2; size: 2; index to column or column offset + relative flags |
// bit: 7-0; mask 0x00FF; column index |
$colIndex = 0x00FF & self::_GetInt2d($cellAddressStructure, 2); |
// bit: 14; mask 0x4000; (1 = relative column index, 0 = absolute column index) |
if (!(0x4000 & self::_GetInt2d($cellAddressStructure, 2))) { |
$column = PHPExcel_Cell::stringFromColumnIndex($colIndex); |
$column = '$' . $column; |
} else { |
$colIndex = ($colIndex <= 127) ? $colIndex : $colIndex - 256; |
$column = PHPExcel_Cell::stringFromColumnIndex($baseCol + $colIndex); |
} |
// bit: 15; mask 0x8000; (1 = relative row index, 0 = absolute row index) |
if (!(0x8000 & self::_GetInt2d($cellAddressStructure, 2))) { |
$row = '$' . $row; |
} else { |
$rowIndex = ($rowIndex <= 32767) ? $rowIndex : $rowIndex - 65536; |
$row = $baseRow + $rowIndex; |
} |
return $column . $row; |
} |
/** |
* Reads a cell range address in BIFF5 e.g. 'A2:B6' or 'A1' |
* always fixed range |
* section 2.5.14 |
* |
* @param string $subData |
* @return string |
* @throws PHPExcel_Reader_Exception |
*/ |
private function _readBIFF5CellRangeAddressFixed($subData) |
{ |
// offset: 0; size: 2; index to first row |
$fr = self::_GetInt2d($subData, 0) + 1; |
// offset: 2; size: 2; index to last row |
$lr = self::_GetInt2d($subData, 2) + 1; |
// offset: 4; size: 1; index to first column |
$fc = ord($subData{4}); |
// offset: 5; size: 1; index to last column |
$lc = ord($subData{5}); |
// check values |
if ($fr > $lr || $fc > $lc) { |
throw new PHPExcel_Reader_Exception('Not a cell range address'); |
} |
// column index to letter |
$fc = PHPExcel_Cell::stringFromColumnIndex($fc); |
$lc = PHPExcel_Cell::stringFromColumnIndex($lc); |
if ($fr == $lr and $fc == $lc) { |
return "$fc$fr"; |
} |
return "$fc$fr:$lc$lr"; |
} |
/** |
* Reads a cell range address in BIFF8 e.g. 'A2:B6' or 'A1' |
* always fixed range |
* section 2.5.14 |
* |
* @param string $subData |
* @return string |
* @throws PHPExcel_Reader_Exception |
*/ |
private function _readBIFF8CellRangeAddressFixed($subData) |
{ |
// offset: 0; size: 2; index to first row |
$fr = self::_GetInt2d($subData, 0) + 1; |
// offset: 2; size: 2; index to last row |
$lr = self::_GetInt2d($subData, 2) + 1; |
// offset: 4; size: 2; index to first column |
$fc = self::_GetInt2d($subData, 4); |
// offset: 6; size: 2; index to last column |
$lc = self::_GetInt2d($subData, 6); |
// check values |
if ($fr > $lr || $fc > $lc) { |
throw new PHPExcel_Reader_Exception('Not a cell range address'); |
} |
// column index to letter |
$fc = PHPExcel_Cell::stringFromColumnIndex($fc); |
$lc = PHPExcel_Cell::stringFromColumnIndex($lc); |
if ($fr == $lr and $fc == $lc) { |
return "$fc$fr"; |
} |
return "$fc$fr:$lc$lr"; |
} |
/** |
* Reads a cell range address in BIFF8 e.g. 'A2:B6' or '$A$2:$B$6' |
* there are flags indicating whether column/row index is relative |
* section 3.3.4 |
* |
* @param string $subData |
* @return string |
*/ |
private function _readBIFF8CellRangeAddress($subData) |
{ |
// todo: if cell range is just a single cell, should this funciton |
// not just return e.g. 'A1' and not 'A1:A1' ? |
// offset: 0; size: 2; index to first row (0... 65535) (or offset (-32768... 32767)) |
$fr = self::_GetInt2d($subData, 0) + 1; |
// offset: 2; size: 2; index to last row (0... 65535) (or offset (-32768... 32767)) |
$lr = self::_GetInt2d($subData, 2) + 1; |
// offset: 4; size: 2; index to first column or column offset + relative flags |
// bit: 7-0; mask 0x00FF; column index |
$fc = PHPExcel_Cell::stringFromColumnIndex(0x00FF & self::_GetInt2d($subData, 4)); |
// bit: 14; mask 0x4000; (1 = relative column index, 0 = absolute column index) |
if (!(0x4000 & self::_GetInt2d($subData, 4))) { |
$fc = '$' . $fc; |
} |
// bit: 15; mask 0x8000; (1 = relative row index, 0 = absolute row index) |
if (!(0x8000 & self::_GetInt2d($subData, 4))) { |
$fr = '$' . $fr; |
} |
// offset: 6; size: 2; index to last column or column offset + relative flags |
// bit: 7-0; mask 0x00FF; column index |
$lc = PHPExcel_Cell::stringFromColumnIndex(0x00FF & self::_GetInt2d($subData, 6)); |
// bit: 14; mask 0x4000; (1 = relative column index, 0 = absolute column index) |
if (!(0x4000 & self::_GetInt2d($subData, 6))) { |
$lc = '$' . $lc; |
} |
// bit: 15; mask 0x8000; (1 = relative row index, 0 = absolute row index) |
if (!(0x8000 & self::_GetInt2d($subData, 6))) { |
$lr = '$' . $lr; |
} |
return "$fc$fr:$lc$lr"; |
} |
/** |
* Reads a cell range address in BIFF8 for shared formulas. Uses positive and negative values for row and column |
* to indicate offsets from a base cell |
* section 3.3.4 |
* |
* @param string $subData |
* @param string $baseCell Base cell |
* @return string Cell range address |
*/ |
private function _readBIFF8CellRangeAddressB($subData, $baseCell = 'A1') |
{ |
list($baseCol, $baseRow) = PHPExcel_Cell::coordinateFromString($baseCell); |
$baseCol = PHPExcel_Cell::columnIndexFromString($baseCol) - 1; |
// TODO: if cell range is just a single cell, should this funciton |
// not just return e.g. 'A1' and not 'A1:A1' ? |
// offset: 0; size: 2; first row |
$frIndex = self::_GetInt2d($subData, 0); // adjust below |
// offset: 2; size: 2; relative index to first row (0... 65535) should be treated as offset (-32768... 32767) |
$lrIndex = self::_GetInt2d($subData, 2); // adjust below |
// offset: 4; size: 2; first column with relative/absolute flags |
// bit: 7-0; mask 0x00FF; column index |
$fcIndex = 0x00FF & self::_GetInt2d($subData, 4); |
// bit: 14; mask 0x4000; (1 = relative column index, 0 = absolute column index) |
if (!(0x4000 & self::_GetInt2d($subData, 4))) { |
// absolute column index |
$fc = PHPExcel_Cell::stringFromColumnIndex($fcIndex); |
$fc = '$' . $fc; |
} else { |
// column offset |
$fcIndex = ($fcIndex <= 127) ? $fcIndex : $fcIndex - 256; |
$fc = PHPExcel_Cell::stringFromColumnIndex($baseCol + $fcIndex); |
} |
// bit: 15; mask 0x8000; (1 = relative row index, 0 = absolute row index) |
if (!(0x8000 & self::_GetInt2d($subData, 4))) { |
// absolute row index |
$fr = $frIndex + 1; |
$fr = '$' . $fr; |
} else { |
// row offset |
$frIndex = ($frIndex <= 32767) ? $frIndex : $frIndex - 65536; |
$fr = $baseRow + $frIndex; |
} |
// offset: 6; size: 2; last column with relative/absolute flags |
// bit: 7-0; mask 0x00FF; column index |
$lcIndex = 0x00FF & self::_GetInt2d($subData, 6); |
$lcIndex = ($lcIndex <= 127) ? $lcIndex : $lcIndex - 256; |
$lc = PHPExcel_Cell::stringFromColumnIndex($baseCol + $lcIndex); |
// bit: 14; mask 0x4000; (1 = relative column index, 0 = absolute column index) |
if (!(0x4000 & self::_GetInt2d($subData, 6))) { |
// absolute column index |
$lc = PHPExcel_Cell::stringFromColumnIndex($lcIndex); |
$lc = '$' . $lc; |
} else { |
// column offset |
$lcIndex = ($lcIndex <= 127) ? $lcIndex : $lcIndex - 256; |
$lc = PHPExcel_Cell::stringFromColumnIndex($baseCol + $lcIndex); |
} |
// bit: 15; mask 0x8000; (1 = relative row index, 0 = absolute row index) |
if (!(0x8000 & self::_GetInt2d($subData, 6))) { |
// absolute row index |
$lr = $lrIndex + 1; |
$lr = '$' . $lr; |
} else { |
// row offset |
$lrIndex = ($lrIndex <= 32767) ? $lrIndex : $lrIndex - 65536; |
$lr = $baseRow + $lrIndex; |
} |
return "$fc$fr:$lc$lr"; |
} |
/** |
* Read BIFF8 cell range address list |
* section 2.5.15 |
* |
* @param string $subData |
* @return array |
*/ |
private function _readBIFF8CellRangeAddressList($subData) |
{ |
$cellRangeAddresses = array(); |
// offset: 0; size: 2; number of the following cell range addresses |
$nm = self::_GetInt2d($subData, 0); |
$offset = 2; |
// offset: 2; size: 8 * $nm; list of $nm (fixed) cell range addresses |
for ($i = 0; $i < $nm; ++$i) { |
$cellRangeAddresses[] = $this->_readBIFF8CellRangeAddressFixed(substr($subData, $offset, 8)); |
$offset += 8; |
} |
return array( |
'size' => 2 + 8 * $nm, |
'cellRangeAddresses' => $cellRangeAddresses, |
); |
} |
/** |
* Read BIFF5 cell range address list |
* section 2.5.15 |
* |
* @param string $subData |
* @return array |
*/ |
private function _readBIFF5CellRangeAddressList($subData) |
{ |
$cellRangeAddresses = array(); |
// offset: 0; size: 2; number of the following cell range addresses |
$nm = self::_GetInt2d($subData, 0); |
$offset = 2; |
// offset: 2; size: 6 * $nm; list of $nm (fixed) cell range addresses |
for ($i = 0; $i < $nm; ++$i) { |
$cellRangeAddresses[] = $this->_readBIFF5CellRangeAddressFixed(substr($subData, $offset, 6)); |
$offset += 6; |
} |
return array( |
'size' => 2 + 6 * $nm, |
'cellRangeAddresses' => $cellRangeAddresses, |
); |
} |
/** |
* Get a sheet range like Sheet1:Sheet3 from REF index |
* Note: If there is only one sheet in the range, one gets e.g Sheet1 |
* It can also happen that the REF structure uses the -1 (FFFF) code to indicate deleted sheets, |
* in which case an PHPExcel_Reader_Exception is thrown |
* |
* @param int $index |
* @return string|false |
* @throws PHPExcel_Reader_Exception |
*/ |
private function _readSheetRangeByRefIndex($index) |
{ |
if (isset($this->_ref[$index])) { |
$type = $this->_externalBooks[$this->_ref[$index]['externalBookIndex']]['type']; |
switch ($type) { |
case 'internal': |
// check if we have a deleted 3d reference |
if ($this->_ref[$index]['firstSheetIndex'] == 0xFFFF or $this->_ref[$index]['lastSheetIndex'] == 0xFFFF) { |
throw new PHPExcel_Reader_Exception('Deleted sheet reference'); |
} |
// we have normal sheet range (collapsed or uncollapsed) |
$firstSheetName = $this->_sheets[$this->_ref[$index]['firstSheetIndex']]['name']; |
$lastSheetName = $this->_sheets[$this->_ref[$index]['lastSheetIndex']]['name']; |
if ($firstSheetName == $lastSheetName) { |
// collapsed sheet range |
$sheetRange = $firstSheetName; |
} else { |
$sheetRange = "$firstSheetName:$lastSheetName"; |
} |
// escape the single-quotes |
$sheetRange = str_replace("'", "''", $sheetRange); |
// if there are special characters, we need to enclose the range in single-quotes |
// todo: check if we have identified the whole set of special characters |
// it seems that the following characters are not accepted for sheet names |
// and we may assume that they are not present: []*/:\? |
if (preg_match("/[ !\"@#£$%&{()}<>=+'|^,;-]/", $sheetRange)) { |
$sheetRange = "'$sheetRange'"; |
} |
return $sheetRange; |
break; |
default: |
// TODO: external sheet support |
throw new PHPExcel_Reader_Exception('Excel5 reader only supports internal sheets in fomulas'); |
break; |
} |
} |
return false; |
} |
/** |
* read BIFF8 constant value array from array data |
* returns e.g. array('value' => '{1,2;3,4}', 'size' => 40} |
* section 2.5.8 |
* |
* @param string $arrayData |
* @return array |
*/ |
private static function _readBIFF8ConstantArray($arrayData) |
{ |
// offset: 0; size: 1; number of columns decreased by 1 |
$nc = ord($arrayData[0]); |
// offset: 1; size: 2; number of rows decreased by 1 |
$nr = self::_GetInt2d($arrayData, 1); |
$size = 3; // initialize |
$arrayData = substr($arrayData, 3); |
// offset: 3; size: var; list of ($nc + 1) * ($nr + 1) constant values |
$matrixChunks = array(); |
for ($r = 1; $r <= $nr + 1; ++$r) { |
$items = array(); |
for ($c = 1; $c <= $nc + 1; ++$c) { |
$constant = self::_readBIFF8Constant($arrayData); |
$items[] = $constant['value']; |
$arrayData = substr($arrayData, $constant['size']); |
$size += $constant['size']; |
} |
$matrixChunks[] = implode(',', $items); // looks like e.g. '1,"hello"' |
} |
$matrix = '{' . implode(';', $matrixChunks) . '}'; |
return array( |
'value' => $matrix, |
'size' => $size, |
); |
} |
/** |
* read BIFF8 constant value which may be 'Empty Value', 'Number', 'String Value', 'Boolean Value', 'Error Value' |
* section 2.5.7 |
* returns e.g. array('value' => '5', 'size' => 9) |
* |
* @param string $valueData |
* @return array |
*/ |
private static function _readBIFF8Constant($valueData) |
{ |
// offset: 0; size: 1; identifier for type of constant |
$identifier = ord($valueData[0]); |
switch ($identifier) { |
case 0x00: // empty constant (what is this?) |
$value = ''; |
$size = 9; |
break; |
case 0x01: // number |
// offset: 1; size: 8; IEEE 754 floating-point value |
$value = self::_extractNumber(substr($valueData, 1, 8)); |
$size = 9; |
break; |
case 0x02: // string value |
// offset: 1; size: var; Unicode string, 16-bit string length |
$string = self::_readUnicodeStringLong(substr($valueData, 1)); |
$value = '"' . $string['value'] . '"'; |
$size = 1 + $string['size']; |
break; |
case 0x04: // boolean |
// offset: 1; size: 1; 0 = FALSE, 1 = TRUE |
if (ord($valueData[1])) { |
$value = 'TRUE'; |
} else { |
$value = 'FALSE'; |
} |
$size = 9; |
break; |
case 0x10: // error code |
// offset: 1; size: 1; error code |
$value = self::_mapErrorCode(ord($valueData[1])); |
$size = 9; |
break; |
} |
return array( |
'value' => $value, |
'size' => $size, |
); |
} |
/** |
* Extract RGB color |
* OpenOffice.org's Documentation of the Microsoft Excel File Format, section 2.5.4 |
* |
* @param string $rgb Encoded RGB value (4 bytes) |
* @return array |
*/ |
private static function _readRGB($rgb) |
{ |
// offset: 0; size 1; Red component |
$r = ord($rgb{0}); |
// offset: 1; size: 1; Green component |
$g = ord($rgb{1}); |
// offset: 2; size: 1; Blue component |
$b = ord($rgb{2}); |
// HEX notation, e.g. 'FF00FC' |
$rgb = sprintf('%02X%02X%02X', $r, $g, $b); |
return array('rgb' => $rgb); |
} |
/** |
* Read byte string (8-bit string length) |
* OpenOffice documentation: 2.5.2 |
* |
* @param string $subData |
* @return array |
*/ |
private function _readByteStringShort($subData) |
{ |
// offset: 0; size: 1; length of the string (character count) |
$ln = ord($subData[0]); |
// offset: 1: size: var; character array (8-bit characters) |
$value = $this->_decodeCodepage(substr($subData, 1, $ln)); |
return array( |
'value' => $value, |
'size' => 1 + $ln, // size in bytes of data structure |
); |
} |
/** |
* Read byte string (16-bit string length) |
* OpenOffice documentation: 2.5.2 |
* |
* @param string $subData |
* @return array |
*/ |
private function _readByteStringLong($subData) |
{ |
// offset: 0; size: 2; length of the string (character count) |
$ln = self::_GetInt2d($subData, 0); |
// offset: 2: size: var; character array (8-bit characters) |
$value = $this->_decodeCodepage(substr($subData, 2)); |
//return $string; |
return array( |
'value' => $value, |
'size' => 2 + $ln, // size in bytes of data structure |
); |
} |
/** |
* Extracts an Excel Unicode short string (8-bit string length) |
* OpenOffice documentation: 2.5.3 |
* function will automatically find out where the Unicode string ends. |
* |
* @param string $subData |
* @return array |
*/ |
private static function _readUnicodeStringShort($subData) |
{ |
$value = ''; |
// offset: 0: size: 1; length of the string (character count) |
$characterCount = ord($subData[0]); |
$string = self::_readUnicodeString(substr($subData, 1), $characterCount); |
// add 1 for the string length |
$string['size'] += 1; |
return $string; |
} |
/** |
* Extracts an Excel Unicode long string (16-bit string length) |
* OpenOffice documentation: 2.5.3 |
* this function is under construction, needs to support rich text, and Asian phonetic settings |
* |
* @param string $subData |
* @return array |
*/ |
private static function _readUnicodeStringLong($subData) |
{ |
$value = ''; |
// offset: 0: size: 2; length of the string (character count) |
$characterCount = self::_GetInt2d($subData, 0); |
$string = self::_readUnicodeString(substr($subData, 2), $characterCount); |
// add 2 for the string length |
$string['size'] += 2; |
return $string; |
} |
/** |
* Read Unicode string with no string length field, but with known character count |
* this function is under construction, needs to support rich text, and Asian phonetic settings |
* OpenOffice.org's Documentation of the Microsoft Excel File Format, section 2.5.3 |
* |
* @param string $subData |
* @param int $characterCount |
* @return array |
*/ |
private static function _readUnicodeString($subData, $characterCount) |
{ |
$value = ''; |
// offset: 0: size: 1; option flags |
// bit: 0; mask: 0x01; character compression (0 = compressed 8-bit, 1 = uncompressed 16-bit) |
$isCompressed = !((0x01 & ord($subData[0])) >> 0); |
// bit: 2; mask: 0x04; Asian phonetic settings |
$hasAsian = (0x04) & ord($subData[0]) >> 2; |
// bit: 3; mask: 0x08; Rich-Text settings |
$hasRichText = (0x08) & ord($subData[0]) >> 3; |
// offset: 1: size: var; character array |
// this offset assumes richtext and Asian phonetic settings are off which is generally wrong |
// needs to be fixed |
$value = self::_encodeUTF16(substr($subData, 1, $isCompressed ? $characterCount : 2 * $characterCount), $isCompressed); |
return array( |
'value' => $value, |
'size' => $isCompressed ? 1 + $characterCount : 1 + 2 * $characterCount, // the size in bytes including the option flags |
); |
} |
/** |
* Convert UTF-8 string to string surounded by double quotes. Used for explicit string tokens in formulas. |
* Example: hello"world --> "hello""world" |
* |
* @param string $value UTF-8 encoded string |
* @return string |
*/ |
private static function _UTF8toExcelDoubleQuoted($value) |
{ |
return '"' . str_replace('"', '""', $value) . '"'; |
} |
/** |
* Reads first 8 bytes of a string and return IEEE 754 float |
* |
* @param string $data Binary string that is at least 8 bytes long |
* @return float |
*/ |
private static function _extractNumber($data) |
{ |
$rknumhigh = self::_GetInt4d($data, 4); |
$rknumlow = self::_GetInt4d($data, 0); |
$sign = ($rknumhigh & 0x80000000) >> 31; |
$exp = (($rknumhigh & 0x7ff00000) >> 20) - 1023; |
$mantissa = (0x100000 | ($rknumhigh & 0x000fffff)); |
$mantissalow1 = ($rknumlow & 0x80000000) >> 31; |
$mantissalow2 = ($rknumlow & 0x7fffffff); |
$value = $mantissa / pow( 2 , (20 - $exp)); |
if ($mantissalow1 != 0) { |
$value += 1 / pow (2 , (21 - $exp)); |
} |
$value += $mantissalow2 / pow (2 , (52 - $exp)); |
if ($sign) { |
$value *= -1; |
} |
return $value; |
} |
private static function _GetIEEE754($rknum) |
{ |
if (($rknum & 0x02) != 0) { |
$value = $rknum >> 2; |
} else { |
// changes by mmp, info on IEEE754 encoding from |
// research.microsoft.com/~hollasch/cgindex/coding/ieeefloat.html |
// The RK format calls for using only the most significant 30 bits |
// of the 64 bit floating point value. The other 34 bits are assumed |
// to be 0 so we use the upper 30 bits of $rknum as follows... |
$sign = ($rknum & 0x80000000) >> 31; |
$exp = ($rknum & 0x7ff00000) >> 20; |
$mantissa = (0x100000 | ($rknum & 0x000ffffc)); |
$value = $mantissa / pow( 2 , (20- ($exp - 1023))); |
if ($sign) { |
$value = -1 * $value; |
} |
//end of changes by mmp |
} |
if (($rknum & 0x01) != 0) { |
$value /= 100; |
} |
return $value; |
} |
/** |
* Get UTF-8 string from (compressed or uncompressed) UTF-16 string |
* |
* @param string $string |
* @param bool $compressed |
* @return string |
*/ |
private static function _encodeUTF16($string, $compressed = '') |
{ |
if ($compressed) { |
$string = self::_uncompressByteString($string); |
} |
return PHPExcel_Shared_String::ConvertEncoding($string, 'UTF-8', 'UTF-16LE'); |
} |
/** |
* Convert UTF-16 string in compressed notation to uncompressed form. Only used for BIFF8. |
* |
* @param string $string |
* @return string |
*/ |
private static function _uncompressByteString($string) |
{ |
$uncompressedString = ''; |
$strLen = strlen($string); |
for ($i = 0; $i < $strLen; ++$i) { |
$uncompressedString .= $string[$i] . "\0"; |
} |
return $uncompressedString; |
} |
/** |
* Convert string to UTF-8. Only used for BIFF5. |
* |
* @param string $string |
* @return string |
*/ |
private function _decodeCodepage($string) |
{ |
return PHPExcel_Shared_String::ConvertEncoding($string, 'UTF-8', $this->_codepage); |
} |
/** |
* Read 16-bit unsigned integer |
* |
* @param string $data |
* @param int $pos |
* @return int |
*/ |
public static function _GetInt2d($data, $pos) |
{ |
return ord($data[$pos]) | (ord($data[$pos+1]) << 8); |
} |
/** |
* Read 32-bit signed integer |
* |
* @param string $data |
* @param int $pos |
* @return int |
*/ |
public static function _GetInt4d($data, $pos) |
{ |
// FIX: represent numbers correctly on 64-bit system |
// http://sourceforge.net/tracker/index.php?func=detail&aid=1487372&group_id=99160&atid=623334 |
// Hacked by Andreas Rehm 2006 to ensure correct result of the <<24 block on 32 and 64bit systems |
$_or_24 = ord($data[$pos + 3]); |
if ($_or_24 >= 128) { |
// negative number |
$_ord_24 = -abs((256 - $_or_24) << 24); |
} else { |
$_ord_24 = ($_or_24 & 127) << 24; |
} |
return ord($data[$pos]) | (ord($data[$pos+1]) << 8) | (ord($data[$pos+2]) << 16) | $_ord_24; |
} |
/** |
* Read color |
* |
* @param int $color Indexed color |
* @param array $palette Color palette |
* @return array RGB color value, example: array('rgb' => 'FF0000') |
*/ |
private static function _readColor($color,$palette,$version) |
{ |
if ($color <= 0x07 || $color >= 0x40) { |
// special built-in color |
return self::_mapBuiltInColor($color); |
} elseif (isset($palette) && isset($palette[$color - 8])) { |
// palette color, color index 0x08 maps to pallete index 0 |
return $palette[$color - 8]; |
} else { |
// default color table |
if ($version == self::XLS_BIFF8) { |
return self::_mapColor($color); |
} else { |
// BIFF5 |
return self::_mapColorBIFF5($color); |
} |
} |
return $color; |
} |
/** |
* Map border style |
* OpenOffice documentation: 2.5.11 |
* |
* @param int $index |
* @return string |
*/ |
private static function _mapBorderStyle($index) |
{ |
switch ($index) { |
case 0x00: return PHPExcel_Style_Border::BORDER_NONE; |
case 0x01: return PHPExcel_Style_Border::BORDER_THIN; |
case 0x02: return PHPExcel_Style_Border::BORDER_MEDIUM; |
case 0x03: return PHPExcel_Style_Border::BORDER_DASHED; |
case 0x04: return PHPExcel_Style_Border::BORDER_DOTTED; |
case 0x05: return PHPExcel_Style_Border::BORDER_THICK; |
case 0x06: return PHPExcel_Style_Border::BORDER_DOUBLE; |
case 0x07: return PHPExcel_Style_Border::BORDER_HAIR; |
case 0x08: return PHPExcel_Style_Border::BORDER_MEDIUMDASHED; |
case 0x09: return PHPExcel_Style_Border::BORDER_DASHDOT; |
case 0x0A: return PHPExcel_Style_Border::BORDER_MEDIUMDASHDOT; |
case 0x0B: return PHPExcel_Style_Border::BORDER_DASHDOTDOT; |
case 0x0C: return PHPExcel_Style_Border::BORDER_MEDIUMDASHDOTDOT; |
case 0x0D: return PHPExcel_Style_Border::BORDER_SLANTDASHDOT; |
default: return PHPExcel_Style_Border::BORDER_NONE; |
} |
} |
/** |
* Get fill pattern from index |
* OpenOffice documentation: 2.5.12 |
* |
* @param int $index |
* @return string |
*/ |
private static function _mapFillPattern($index) |
{ |
switch ($index) { |
case 0x00: return PHPExcel_Style_Fill::FILL_NONE; |
case 0x01: return PHPExcel_Style_Fill::FILL_SOLID; |
case 0x02: return PHPExcel_Style_Fill::FILL_PATTERN_MEDIUMGRAY; |
case 0x03: return PHPExcel_Style_Fill::FILL_PATTERN_DARKGRAY; |
case 0x04: return PHPExcel_Style_Fill::FILL_PATTERN_LIGHTGRAY; |
case 0x05: return PHPExcel_Style_Fill::FILL_PATTERN_DARKHORIZONTAL; |
case 0x06: return PHPExcel_Style_Fill::FILL_PATTERN_DARKVERTICAL; |
case 0x07: return PHPExcel_Style_Fill::FILL_PATTERN_DARKDOWN; |
case 0x08: return PHPExcel_Style_Fill::FILL_PATTERN_DARKUP; |
case 0x09: return PHPExcel_Style_Fill::FILL_PATTERN_DARKGRID; |
case 0x0A: return PHPExcel_Style_Fill::FILL_PATTERN_DARKTRELLIS; |
case 0x0B: return PHPExcel_Style_Fill::FILL_PATTERN_LIGHTHORIZONTAL; |
case 0x0C: return PHPExcel_Style_Fill::FILL_PATTERN_LIGHTVERTICAL; |
case 0x0D: return PHPExcel_Style_Fill::FILL_PATTERN_LIGHTDOWN; |
case 0x0E: return PHPExcel_Style_Fill::FILL_PATTERN_LIGHTUP; |
case 0x0F: return PHPExcel_Style_Fill::FILL_PATTERN_LIGHTGRID; |
case 0x10: return PHPExcel_Style_Fill::FILL_PATTERN_LIGHTTRELLIS; |
case 0x11: return PHPExcel_Style_Fill::FILL_PATTERN_GRAY125; |
case 0x12: return PHPExcel_Style_Fill::FILL_PATTERN_GRAY0625; |
default: return PHPExcel_Style_Fill::FILL_NONE; |
} |
} |
/** |
* Map error code, e.g. '#N/A' |
* |
* @param int $subData |
* @return string |
*/ |
private static function _mapErrorCode($subData) |
{ |
switch ($subData) { |
case 0x00: return '#NULL!'; break; |
case 0x07: return '#DIV/0!'; break; |
case 0x0F: return '#VALUE!'; break; |
case 0x17: return '#REF!'; break; |
case 0x1D: return '#NAME?'; break; |
case 0x24: return '#NUM!'; break; |
case 0x2A: return '#N/A'; break; |
default: return false; |
} |
} |
/** |
* Map built-in color to RGB value |
* |
* @param int $color Indexed color |
* @return array |
*/ |
private static function _mapBuiltInColor($color) |
{ |
switch ($color) { |
case 0x00: return array('rgb' => '000000'); |
case 0x01: return array('rgb' => 'FFFFFF'); |
case 0x02: return array('rgb' => 'FF0000'); |
case 0x03: return array('rgb' => '00FF00'); |
case 0x04: return array('rgb' => '0000FF'); |
case 0x05: return array('rgb' => 'FFFF00'); |
case 0x06: return array('rgb' => 'FF00FF'); |
case 0x07: return array('rgb' => '00FFFF'); |
case 0x40: return array('rgb' => '000000'); // system window text color |
case 0x41: return array('rgb' => 'FFFFFF'); // system window background color |
default: return array('rgb' => '000000'); |
} |
} |
/** |
* Map color array from BIFF5 built-in color index |
* |
* @param int $subData |
* @return array |
*/ |
private static function _mapColorBIFF5($subData) |
{ |
switch ($subData) { |
case 0x08: return array('rgb' => '000000'); |
case 0x09: return array('rgb' => 'FFFFFF'); |
case 0x0A: return array('rgb' => 'FF0000'); |
case 0x0B: return array('rgb' => '00FF00'); |
case 0x0C: return array('rgb' => '0000FF'); |
case 0x0D: return array('rgb' => 'FFFF00'); |
case 0x0E: return array('rgb' => 'FF00FF'); |
case 0x0F: return array('rgb' => '00FFFF'); |
case 0x10: return array('rgb' => '800000'); |
case 0x11: return array('rgb' => '008000'); |
case 0x12: return array('rgb' => '000080'); |
case 0x13: return array('rgb' => '808000'); |
case 0x14: return array('rgb' => '800080'); |
case 0x15: return array('rgb' => '008080'); |
case 0x16: return array('rgb' => 'C0C0C0'); |
case 0x17: return array('rgb' => '808080'); |
case 0x18: return array('rgb' => '8080FF'); |
case 0x19: return array('rgb' => '802060'); |
case 0x1A: return array('rgb' => 'FFFFC0'); |
case 0x1B: return array('rgb' => 'A0E0F0'); |
case 0x1C: return array('rgb' => '600080'); |
case 0x1D: return array('rgb' => 'FF8080'); |
case 0x1E: return array('rgb' => '0080C0'); |
case 0x1F: return array('rgb' => 'C0C0FF'); |
case 0x20: return array('rgb' => '000080'); |
case 0x21: return array('rgb' => 'FF00FF'); |
case 0x22: return array('rgb' => 'FFFF00'); |
case 0x23: return array('rgb' => '00FFFF'); |
case 0x24: return array('rgb' => '800080'); |
case 0x25: return array('rgb' => '800000'); |
case 0x26: return array('rgb' => '008080'); |
case 0x27: return array('rgb' => '0000FF'); |
case 0x28: return array('rgb' => '00CFFF'); |
case 0x29: return array('rgb' => '69FFFF'); |
case 0x2A: return array('rgb' => 'E0FFE0'); |
case 0x2B: return array('rgb' => 'FFFF80'); |
case 0x2C: return array('rgb' => 'A6CAF0'); |
case 0x2D: return array('rgb' => 'DD9CB3'); |
case 0x2E: return array('rgb' => 'B38FEE'); |
case 0x2F: return array('rgb' => 'E3E3E3'); |
case 0x30: return array('rgb' => '2A6FF9'); |
case 0x31: return array('rgb' => '3FB8CD'); |
case 0x32: return array('rgb' => '488436'); |
case 0x33: return array('rgb' => '958C41'); |
case 0x34: return array('rgb' => '8E5E42'); |
case 0x35: return array('rgb' => 'A0627A'); |
case 0x36: return array('rgb' => '624FAC'); |
case 0x37: return array('rgb' => '969696'); |
case 0x38: return array('rgb' => '1D2FBE'); |
case 0x39: return array('rgb' => '286676'); |
case 0x3A: return array('rgb' => '004500'); |
case 0x3B: return array('rgb' => '453E01'); |
case 0x3C: return array('rgb' => '6A2813'); |
case 0x3D: return array('rgb' => '85396A'); |
case 0x3E: return array('rgb' => '4A3285'); |
case 0x3F: return array('rgb' => '424242'); |
default: return array('rgb' => '000000'); |
} |
} |
/** |
* Map color array from BIFF8 built-in color index |
* |
* @param int $subData |
* @return array |
*/ |
private static function _mapColor($subData) |
{ |
switch ($subData) { |
case 0x08: return array('rgb' => '000000'); |
case 0x09: return array('rgb' => 'FFFFFF'); |
case 0x0A: return array('rgb' => 'FF0000'); |
case 0x0B: return array('rgb' => '00FF00'); |
case 0x0C: return array('rgb' => '0000FF'); |
case 0x0D: return array('rgb' => 'FFFF00'); |
case 0x0E: return array('rgb' => 'FF00FF'); |
case 0x0F: return array('rgb' => '00FFFF'); |
case 0x10: return array('rgb' => '800000'); |
case 0x11: return array('rgb' => '008000'); |
case 0x12: return array('rgb' => '000080'); |
case 0x13: return array('rgb' => '808000'); |
case 0x14: return array('rgb' => '800080'); |
case 0x15: return array('rgb' => '008080'); |
case 0x16: return array('rgb' => 'C0C0C0'); |
case 0x17: return array('rgb' => '808080'); |
case 0x18: return array('rgb' => '9999FF'); |
case 0x19: return array('rgb' => '993366'); |
case 0x1A: return array('rgb' => 'FFFFCC'); |
case 0x1B: return array('rgb' => 'CCFFFF'); |
case 0x1C: return array('rgb' => '660066'); |
case 0x1D: return array('rgb' => 'FF8080'); |
case 0x1E: return array('rgb' => '0066CC'); |
case 0x1F: return array('rgb' => 'CCCCFF'); |
case 0x20: return array('rgb' => '000080'); |
case 0x21: return array('rgb' => 'FF00FF'); |
case 0x22: return array('rgb' => 'FFFF00'); |
case 0x23: return array('rgb' => '00FFFF'); |
case 0x24: return array('rgb' => '800080'); |
case 0x25: return array('rgb' => '800000'); |
case 0x26: return array('rgb' => '008080'); |
case 0x27: return array('rgb' => '0000FF'); |
case 0x28: return array('rgb' => '00CCFF'); |
case 0x29: return array('rgb' => 'CCFFFF'); |
case 0x2A: return array('rgb' => 'CCFFCC'); |
case 0x2B: return array('rgb' => 'FFFF99'); |
case 0x2C: return array('rgb' => '99CCFF'); |
case 0x2D: return array('rgb' => 'FF99CC'); |
case 0x2E: return array('rgb' => 'CC99FF'); |
case 0x2F: return array('rgb' => 'FFCC99'); |
case 0x30: return array('rgb' => '3366FF'); |
case 0x31: return array('rgb' => '33CCCC'); |
case 0x32: return array('rgb' => '99CC00'); |
case 0x33: return array('rgb' => 'FFCC00'); |
case 0x34: return array('rgb' => 'FF9900'); |
case 0x35: return array('rgb' => 'FF6600'); |
case 0x36: return array('rgb' => '666699'); |
case 0x37: return array('rgb' => '969696'); |
case 0x38: return array('rgb' => '003366'); |
case 0x39: return array('rgb' => '339966'); |
case 0x3A: return array('rgb' => '003300'); |
case 0x3B: return array('rgb' => '333300'); |
case 0x3C: return array('rgb' => '993300'); |
case 0x3D: return array('rgb' => '993366'); |
case 0x3E: return array('rgb' => '333399'); |
case 0x3F: return array('rgb' => '333333'); |
default: return array('rgb' => '000000'); |
} |
} |
private function _parseRichText($is = '') { |
$value = new PHPExcel_RichText(); |
$value->createText($is); |
return $value; |
} |
} |
/branches/v2.6-greffoir/jrest/lib/PHPExcel/Classes/PHPExcel/Reader/DefaultReadFilter.php |
---|
New file |
0,0 → 1,58 |
<?php |
/** |
* PHPExcel |
* |
* Copyright (c) 2006 - 2013 PHPExcel |
* |
* This library is free software; you can redistribute it and/or |
* modify it under the terms of the GNU Lesser General Public |
* License as published by the Free Software Foundation; either |
* version 2.1 of the License, or (at your option) any later version. |
* |
* This library is distributed in the hope that it will be useful, |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
* Lesser General Public License for more details. |
* |
* You should have received a copy of the GNU Lesser General Public |
* License along with this library; if not, write to the Free Software |
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
* |
* @category PHPExcel |
* @package PHPExcel_Reader |
* @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL |
* @version ##VERSION##, ##DATE## |
*/ |
/** PHPExcel root directory */ |
if (!defined('PHPEXCEL_ROOT')) { |
/** |
* @ignore |
*/ |
define('PHPEXCEL_ROOT', dirname(__FILE__) . '/../../'); |
require(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php'); |
} |
/** |
* PHPExcel_Reader_DefaultReadFilter |
* |
* @category PHPExcel |
* @package PHPExcel_Reader |
* @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
*/ |
class PHPExcel_Reader_DefaultReadFilter implements PHPExcel_Reader_IReadFilter |
{ |
/** |
* Should this cell be read? |
* |
* @param $column String column index |
* @param $row Row index |
* @param $worksheetName Optional worksheet name |
* @return boolean |
*/ |
public function readCell($column, $row, $worksheetName = '') { |
return true; |
} |
} |
/branches/v2.6-greffoir/jrest/lib/PHPExcel/Classes/PHPExcel/Reader/Excel2003XML.php |
---|
New file |
0,0 → 1,802 |
<?php |
/** |
* PHPExcel |
* |
* Copyright (c) 2006 - 2013 PHPExcel |
* |
* This library is free software; you can redistribute it and/or |
* modify it under the terms of the GNU Lesser General Public |
* License as published by the Free Software Foundation; either |
* version 2.1 of the License, or (at your option) any later version. |
* |
* This library is distributed in the hope that it will be useful, |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
* Lesser General Public License for more details. |
* |
* You should have received a copy of the GNU Lesser General Public |
* License along with this library; if not, write to the Free Software |
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
* |
* @category PHPExcel |
* @package PHPExcel_Reader |
* @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL |
* @version ##VERSION##, ##DATE## |
*/ |
/** PHPExcel root directory */ |
if (!defined('PHPEXCEL_ROOT')) { |
/** |
* @ignore |
*/ |
define('PHPEXCEL_ROOT', dirname(__FILE__) . '/../../'); |
require(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php'); |
} |
/** |
* PHPExcel_Reader_Excel2003XML |
* |
* @category PHPExcel |
* @package PHPExcel_Reader |
* @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
*/ |
class PHPExcel_Reader_Excel2003XML extends PHPExcel_Reader_Abstract implements PHPExcel_Reader_IReader |
{ |
/** |
* Formats |
* |
* @var array |
*/ |
private $_styles = array(); |
/** |
* Character set used in the file |
* |
* @var string |
*/ |
private $_charSet = 'UTF-8'; |
/** |
* Create a new PHPExcel_Reader_Excel2003XML |
*/ |
public function __construct() { |
$this->_readFilter = new PHPExcel_Reader_DefaultReadFilter(); |
} |
/** |
* Can the current PHPExcel_Reader_IReader read the file? |
* |
* @param string $pFilename |
* @return boolean |
* @throws PHPExcel_Reader_Exception |
*/ |
public function canRead($pFilename) |
{ |
// Office xmlns:o="urn:schemas-microsoft-com:office:office" |
// Excel xmlns:x="urn:schemas-microsoft-com:office:excel" |
// XML Spreadsheet xmlns:ss="urn:schemas-microsoft-com:office:spreadsheet" |
// Spreadsheet component xmlns:c="urn:schemas-microsoft-com:office:component:spreadsheet" |
// XML schema xmlns:s="uuid:BDC6E3F0-6DA3-11d1-A2A3-00AA00C14882" |
// XML data type xmlns:dt="uuid:C2F41010-65B3-11d1-A29F-00AA00C14882" |
// MS-persist recordset xmlns:rs="urn:schemas-microsoft-com:rowset" |
// Rowset xmlns:z="#RowsetSchema" |
// |
$signature = array( |
'<?xml version="1.0"', |
'<?mso-application progid="Excel.Sheet"?>' |
); |
// Open file |
$this->_openFile($pFilename); |
$fileHandle = $this->_fileHandle; |
// Read sample data (first 2 KB will do) |
$data = fread($fileHandle, 2048); |
fclose($fileHandle); |
$valid = true; |
foreach($signature as $match) { |
// every part of the signature must be present |
if (strpos($data, $match) === false) { |
$valid = false; |
break; |
} |
} |
// Retrieve charset encoding |
if(preg_match('/<?xml.*encoding=[\'"](.*?)[\'"].*?>/um',$data,$matches)) { |
$this->_charSet = strtoupper($matches[1]); |
} |
// echo 'Character Set is ',$this->_charSet,'<br />'; |
return $valid; |
} |
/** |
* Reads names of the worksheets from a file, without parsing the whole file to a PHPExcel object |
* |
* @param string $pFilename |
* @throws PHPExcel_Reader_Exception |
*/ |
public function listWorksheetNames($pFilename) |
{ |
// Check if file exists |
if (!file_exists($pFilename)) { |
throw new PHPExcel_Reader_Exception("Could not open " . $pFilename . " for reading! File does not exist."); |
} |
if (!$this->canRead($pFilename)) { |
throw new PHPExcel_Reader_Exception($pFilename . " is an Invalid Spreadsheet file."); |
} |
$worksheetNames = array(); |
$xml = simplexml_load_file($pFilename); |
$namespaces = $xml->getNamespaces(true); |
$xml_ss = $xml->children($namespaces['ss']); |
foreach($xml_ss->Worksheet as $worksheet) { |
$worksheet_ss = $worksheet->attributes($namespaces['ss']); |
$worksheetNames[] = self::_convertStringEncoding((string) $worksheet_ss['Name'],$this->_charSet); |
} |
return $worksheetNames; |
} |
/** |
* Return worksheet info (Name, Last Column Letter, Last Column Index, Total Rows, Total Columns) |
* |
* @param string $pFilename |
* @throws PHPExcel_Reader_Exception |
*/ |
public function listWorksheetInfo($pFilename) |
{ |
// Check if file exists |
if (!file_exists($pFilename)) { |
throw new PHPExcel_Reader_Exception("Could not open " . $pFilename . " for reading! File does not exist."); |
} |
$worksheetInfo = array(); |
$xml = simplexml_load_file($pFilename); |
$namespaces = $xml->getNamespaces(true); |
$worksheetID = 1; |
$xml_ss = $xml->children($namespaces['ss']); |
foreach($xml_ss->Worksheet as $worksheet) { |
$worksheet_ss = $worksheet->attributes($namespaces['ss']); |
$tmpInfo = array(); |
$tmpInfo['worksheetName'] = ''; |
$tmpInfo['lastColumnLetter'] = 'A'; |
$tmpInfo['lastColumnIndex'] = 0; |
$tmpInfo['totalRows'] = 0; |
$tmpInfo['totalColumns'] = 0; |
if (isset($worksheet_ss['Name'])) { |
$tmpInfo['worksheetName'] = (string) $worksheet_ss['Name']; |
} else { |
$tmpInfo['worksheetName'] = "Worksheet_{$worksheetID}"; |
} |
if (isset($worksheet->Table->Row)) { |
$rowIndex = 0; |
foreach($worksheet->Table->Row as $rowData) { |
$columnIndex = 0; |
$rowHasData = false; |
foreach($rowData->Cell as $cell) { |
if (isset($cell->Data)) { |
$tmpInfo['lastColumnIndex'] = max($tmpInfo['lastColumnIndex'], $columnIndex); |
$rowHasData = true; |
} |
++$columnIndex; |
} |
++$rowIndex; |
if ($rowHasData) { |
$tmpInfo['totalRows'] = max($tmpInfo['totalRows'], $rowIndex); |
} |
} |
} |
$tmpInfo['lastColumnLetter'] = PHPExcel_Cell::stringFromColumnIndex($tmpInfo['lastColumnIndex']); |
$tmpInfo['totalColumns'] = $tmpInfo['lastColumnIndex'] + 1; |
$worksheetInfo[] = $tmpInfo; |
++$worksheetID; |
} |
return $worksheetInfo; |
} |
/** |
* Loads PHPExcel from file |
* |
* @param string $pFilename |
* @return PHPExcel |
* @throws PHPExcel_Reader_Exception |
*/ |
public function load($pFilename) |
{ |
// Create new PHPExcel |
$objPHPExcel = new PHPExcel(); |
// Load into this instance |
return $this->loadIntoExisting($pFilename, $objPHPExcel); |
} |
private static function identifyFixedStyleValue($styleList,&$styleAttributeValue) { |
$styleAttributeValue = strtolower($styleAttributeValue); |
foreach($styleList as $style) { |
if ($styleAttributeValue == strtolower($style)) { |
$styleAttributeValue = $style; |
return true; |
} |
} |
return false; |
} |
/** |
* pixel units to excel width units(units of 1/256th of a character width) |
* @param pxs |
* @return |
*/ |
private static function _pixel2WidthUnits($pxs) { |
$UNIT_OFFSET_MAP = array(0, 36, 73, 109, 146, 182, 219); |
$widthUnits = 256 * ($pxs / 7); |
$widthUnits += $UNIT_OFFSET_MAP[($pxs % 7)]; |
return $widthUnits; |
} |
/** |
* excel width units(units of 1/256th of a character width) to pixel units |
* @param widthUnits |
* @return |
*/ |
private static function _widthUnits2Pixel($widthUnits) { |
$pixels = ($widthUnits / 256) * 7; |
$offsetWidthUnits = $widthUnits % 256; |
$pixels += round($offsetWidthUnits / (256 / 7)); |
return $pixels; |
} |
private static function _hex2str($hex) { |
return chr(hexdec($hex[1])); |
} |
/** |
* Loads PHPExcel from file into PHPExcel instance |
* |
* @param string $pFilename |
* @param PHPExcel $objPHPExcel |
* @return PHPExcel |
* @throws PHPExcel_Reader_Exception |
*/ |
public function loadIntoExisting($pFilename, PHPExcel $objPHPExcel) |
{ |
$fromFormats = array('\-', '\ '); |
$toFormats = array('-', ' '); |
$underlineStyles = array ( |
PHPExcel_Style_Font::UNDERLINE_NONE, |
PHPExcel_Style_Font::UNDERLINE_DOUBLE, |
PHPExcel_Style_Font::UNDERLINE_DOUBLEACCOUNTING, |
PHPExcel_Style_Font::UNDERLINE_SINGLE, |
PHPExcel_Style_Font::UNDERLINE_SINGLEACCOUNTING |
); |
$verticalAlignmentStyles = array ( |
PHPExcel_Style_Alignment::VERTICAL_BOTTOM, |
PHPExcel_Style_Alignment::VERTICAL_TOP, |
PHPExcel_Style_Alignment::VERTICAL_CENTER, |
PHPExcel_Style_Alignment::VERTICAL_JUSTIFY |
); |
$horizontalAlignmentStyles = array ( |
PHPExcel_Style_Alignment::HORIZONTAL_GENERAL, |
PHPExcel_Style_Alignment::HORIZONTAL_LEFT, |
PHPExcel_Style_Alignment::HORIZONTAL_RIGHT, |
PHPExcel_Style_Alignment::HORIZONTAL_CENTER, |
PHPExcel_Style_Alignment::HORIZONTAL_CENTER_CONTINUOUS, |
PHPExcel_Style_Alignment::HORIZONTAL_JUSTIFY |
); |
$timezoneObj = new DateTimeZone('Europe/London'); |
$GMT = new DateTimeZone('UTC'); |
// Check if file exists |
if (!file_exists($pFilename)) { |
throw new PHPExcel_Reader_Exception("Could not open " . $pFilename . " for reading! File does not exist."); |
} |
if (!$this->canRead($pFilename)) { |
throw new PHPExcel_Reader_Exception($pFilename . " is an Invalid Spreadsheet file."); |
} |
$xml = simplexml_load_file($pFilename); |
$namespaces = $xml->getNamespaces(true); |
$docProps = $objPHPExcel->getProperties(); |
if (isset($xml->DocumentProperties[0])) { |
foreach($xml->DocumentProperties[0] as $propertyName => $propertyValue) { |
switch ($propertyName) { |
case 'Title' : |
$docProps->setTitle(self::_convertStringEncoding($propertyValue,$this->_charSet)); |
break; |
case 'Subject' : |
$docProps->setSubject(self::_convertStringEncoding($propertyValue,$this->_charSet)); |
break; |
case 'Author' : |
$docProps->setCreator(self::_convertStringEncoding($propertyValue,$this->_charSet)); |
break; |
case 'Created' : |
$creationDate = strtotime($propertyValue); |
$docProps->setCreated($creationDate); |
break; |
case 'LastAuthor' : |
$docProps->setLastModifiedBy(self::_convertStringEncoding($propertyValue,$this->_charSet)); |
break; |
case 'LastSaved' : |
$lastSaveDate = strtotime($propertyValue); |
$docProps->setModified($lastSaveDate); |
break; |
case 'Company' : |
$docProps->setCompany(self::_convertStringEncoding($propertyValue,$this->_charSet)); |
break; |
case 'Category' : |
$docProps->setCategory(self::_convertStringEncoding($propertyValue,$this->_charSet)); |
break; |
case 'Manager' : |
$docProps->setManager(self::_convertStringEncoding($propertyValue,$this->_charSet)); |
break; |
case 'Keywords' : |
$docProps->setKeywords(self::_convertStringEncoding($propertyValue,$this->_charSet)); |
break; |
case 'Description' : |
$docProps->setDescription(self::_convertStringEncoding($propertyValue,$this->_charSet)); |
break; |
} |
} |
} |
if (isset($xml->CustomDocumentProperties)) { |
foreach($xml->CustomDocumentProperties[0] as $propertyName => $propertyValue) { |
$propertyAttributes = $propertyValue->attributes($namespaces['dt']); |
$propertyName = preg_replace_callback('/_x([0-9a-z]{4})_/','PHPExcel_Reader_Excel2003XML::_hex2str',$propertyName); |
$propertyType = PHPExcel_DocumentProperties::PROPERTY_TYPE_UNKNOWN; |
switch((string) $propertyAttributes) { |
case 'string' : |
$propertyType = PHPExcel_DocumentProperties::PROPERTY_TYPE_STRING; |
$propertyValue = trim($propertyValue); |
break; |
case 'boolean' : |
$propertyType = PHPExcel_DocumentProperties::PROPERTY_TYPE_BOOLEAN; |
$propertyValue = (bool) $propertyValue; |
break; |
case 'integer' : |
$propertyType = PHPExcel_DocumentProperties::PROPERTY_TYPE_INTEGER; |
$propertyValue = intval($propertyValue); |
break; |
case 'float' : |
$propertyType = PHPExcel_DocumentProperties::PROPERTY_TYPE_FLOAT; |
$propertyValue = floatval($propertyValue); |
break; |
case 'dateTime.tz' : |
$propertyType = PHPExcel_DocumentProperties::PROPERTY_TYPE_DATE; |
$propertyValue = strtotime(trim($propertyValue)); |
break; |
} |
$docProps->setCustomProperty($propertyName,$propertyValue,$propertyType); |
} |
} |
foreach($xml->Styles[0] as $style) { |
$style_ss = $style->attributes($namespaces['ss']); |
$styleID = (string) $style_ss['ID']; |
// echo 'Style ID = '.$styleID.'<br />'; |
if ($styleID == 'Default') { |
$this->_styles['Default'] = array(); |
} else { |
$this->_styles[$styleID] = $this->_styles['Default']; |
} |
foreach ($style as $styleType => $styleData) { |
$styleAttributes = $styleData->attributes($namespaces['ss']); |
// echo $styleType.'<br />'; |
switch ($styleType) { |
case 'Alignment' : |
foreach($styleAttributes as $styleAttributeKey => $styleAttributeValue) { |
// echo $styleAttributeKey.' = '.$styleAttributeValue.'<br />'; |
$styleAttributeValue = (string) $styleAttributeValue; |
switch ($styleAttributeKey) { |
case 'Vertical' : |
if (self::identifyFixedStyleValue($verticalAlignmentStyles,$styleAttributeValue)) { |
$this->_styles[$styleID]['alignment']['vertical'] = $styleAttributeValue; |
} |
break; |
case 'Horizontal' : |
if (self::identifyFixedStyleValue($horizontalAlignmentStyles,$styleAttributeValue)) { |
$this->_styles[$styleID]['alignment']['horizontal'] = $styleAttributeValue; |
} |
break; |
case 'WrapText' : |
$this->_styles[$styleID]['alignment']['wrap'] = true; |
break; |
} |
} |
break; |
case 'Borders' : |
foreach($styleData->Border as $borderStyle) { |
$borderAttributes = $borderStyle->attributes($namespaces['ss']); |
$thisBorder = array(); |
foreach($borderAttributes as $borderStyleKey => $borderStyleValue) { |
// echo $borderStyleKey.' = '.$borderStyleValue.'<br />'; |
switch ($borderStyleKey) { |
case 'LineStyle' : |
$thisBorder['style'] = PHPExcel_Style_Border::BORDER_MEDIUM; |
// $thisBorder['style'] = $borderStyleValue; |
break; |
case 'Weight' : |
// $thisBorder['style'] = $borderStyleValue; |
break; |
case 'Position' : |
$borderPosition = strtolower($borderStyleValue); |
break; |
case 'Color' : |
$borderColour = substr($borderStyleValue,1); |
$thisBorder['color']['rgb'] = $borderColour; |
break; |
} |
} |
if (!empty($thisBorder)) { |
if (($borderPosition == 'left') || ($borderPosition == 'right') || ($borderPosition == 'top') || ($borderPosition == 'bottom')) { |
$this->_styles[$styleID]['borders'][$borderPosition] = $thisBorder; |
} |
} |
} |
break; |
case 'Font' : |
foreach($styleAttributes as $styleAttributeKey => $styleAttributeValue) { |
// echo $styleAttributeKey.' = '.$styleAttributeValue.'<br />'; |
$styleAttributeValue = (string) $styleAttributeValue; |
switch ($styleAttributeKey) { |
case 'FontName' : |
$this->_styles[$styleID]['font']['name'] = $styleAttributeValue; |
break; |
case 'Size' : |
$this->_styles[$styleID]['font']['size'] = $styleAttributeValue; |
break; |
case 'Color' : |
$this->_styles[$styleID]['font']['color']['rgb'] = substr($styleAttributeValue,1); |
break; |
case 'Bold' : |
$this->_styles[$styleID]['font']['bold'] = true; |
break; |
case 'Italic' : |
$this->_styles[$styleID]['font']['italic'] = true; |
break; |
case 'Underline' : |
if (self::identifyFixedStyleValue($underlineStyles,$styleAttributeValue)) { |
$this->_styles[$styleID]['font']['underline'] = $styleAttributeValue; |
} |
break; |
} |
} |
break; |
case 'Interior' : |
foreach($styleAttributes as $styleAttributeKey => $styleAttributeValue) { |
// echo $styleAttributeKey.' = '.$styleAttributeValue.'<br />'; |
switch ($styleAttributeKey) { |
case 'Color' : |
$this->_styles[$styleID]['fill']['color']['rgb'] = substr($styleAttributeValue,1); |
break; |
} |
} |
break; |
case 'NumberFormat' : |
foreach($styleAttributes as $styleAttributeKey => $styleAttributeValue) { |
// echo $styleAttributeKey.' = '.$styleAttributeValue.'<br />'; |
$styleAttributeValue = str_replace($fromFormats,$toFormats,$styleAttributeValue); |
switch ($styleAttributeValue) { |
case 'Short Date' : |
$styleAttributeValue = 'dd/mm/yyyy'; |
break; |
} |
if ($styleAttributeValue > '') { |
$this->_styles[$styleID]['numberformat']['code'] = $styleAttributeValue; |
} |
} |
break; |
case 'Protection' : |
foreach($styleAttributes as $styleAttributeKey => $styleAttributeValue) { |
// echo $styleAttributeKey.' = '.$styleAttributeValue.'<br />'; |
} |
break; |
} |
} |
// print_r($this->_styles[$styleID]); |
// echo '<hr />'; |
} |
// echo '<hr />'; |
$worksheetID = 0; |
$xml_ss = $xml->children($namespaces['ss']); |
foreach($xml_ss->Worksheet as $worksheet) { |
$worksheet_ss = $worksheet->attributes($namespaces['ss']); |
if ((isset($this->_loadSheetsOnly)) && (isset($worksheet_ss['Name'])) && |
(!in_array($worksheet_ss['Name'], $this->_loadSheetsOnly))) { |
continue; |
} |
// echo '<h3>Worksheet: ',$worksheet_ss['Name'],'<h3>'; |
// |
// Create new Worksheet |
$objPHPExcel->createSheet(); |
$objPHPExcel->setActiveSheetIndex($worksheetID); |
if (isset($worksheet_ss['Name'])) { |
$worksheetName = self::_convertStringEncoding((string) $worksheet_ss['Name'],$this->_charSet); |
// Use false for $updateFormulaCellReferences to prevent adjustment of worksheet references in |
// formula cells... during the load, all formulae should be correct, and we're simply bringing |
// the worksheet name in line with the formula, not the reverse |
$objPHPExcel->getActiveSheet()->setTitle($worksheetName,false); |
} |
$columnID = 'A'; |
if (isset($worksheet->Table->Column)) { |
foreach($worksheet->Table->Column as $columnData) { |
$columnData_ss = $columnData->attributes($namespaces['ss']); |
if (isset($columnData_ss['Index'])) { |
$columnID = PHPExcel_Cell::stringFromColumnIndex($columnData_ss['Index']-1); |
} |
if (isset($columnData_ss['Width'])) { |
$columnWidth = $columnData_ss['Width']; |
// echo '<b>Setting column width for '.$columnID.' to '.$columnWidth.'</b><br />'; |
$objPHPExcel->getActiveSheet()->getColumnDimension($columnID)->setWidth($columnWidth / 5.4); |
} |
++$columnID; |
} |
} |
$rowID = 1; |
if (isset($worksheet->Table->Row)) { |
foreach($worksheet->Table->Row as $rowData) { |
$rowHasData = false; |
$row_ss = $rowData->attributes($namespaces['ss']); |
if (isset($row_ss['Index'])) { |
$rowID = (integer) $row_ss['Index']; |
} |
// echo '<b>Row '.$rowID.'</b><br />'; |
$columnID = 'A'; |
foreach($rowData->Cell as $cell) { |
$cell_ss = $cell->attributes($namespaces['ss']); |
if (isset($cell_ss['Index'])) { |
$columnID = PHPExcel_Cell::stringFromColumnIndex($cell_ss['Index']-1); |
} |
$cellRange = $columnID.$rowID; |
if ($this->getReadFilter() !== NULL) { |
if (!$this->getReadFilter()->readCell($columnID, $rowID, $worksheetName)) { |
continue; |
} |
} |
if ((isset($cell_ss['MergeAcross'])) || (isset($cell_ss['MergeDown']))) { |
$columnTo = $columnID; |
if (isset($cell_ss['MergeAcross'])) { |
$columnTo = PHPExcel_Cell::stringFromColumnIndex(PHPExcel_Cell::columnIndexFromString($columnID) + $cell_ss['MergeAcross'] -1); |
} |
$rowTo = $rowID; |
if (isset($cell_ss['MergeDown'])) { |
$rowTo = $rowTo + $cell_ss['MergeDown']; |
} |
$cellRange .= ':'.$columnTo.$rowTo; |
$objPHPExcel->getActiveSheet()->mergeCells($cellRange); |
} |
$cellIsSet = $hasCalculatedValue = false; |
$cellDataFormula = ''; |
if (isset($cell_ss['Formula'])) { |
$cellDataFormula = $cell_ss['Formula']; |
// added this as a check for array formulas |
if (isset($cell_ss['ArrayRange'])) { |
$cellDataCSEFormula = $cell_ss['ArrayRange']; |
// echo "found an array formula at ".$columnID.$rowID."<br />"; |
} |
$hasCalculatedValue = true; |
} |
if (isset($cell->Data)) { |
$cellValue = $cellData = $cell->Data; |
$type = PHPExcel_Cell_DataType::TYPE_NULL; |
$cellData_ss = $cellData->attributes($namespaces['ss']); |
if (isset($cellData_ss['Type'])) { |
$cellDataType = $cellData_ss['Type']; |
switch ($cellDataType) { |
/* |
const TYPE_STRING = 's'; |
const TYPE_FORMULA = 'f'; |
const TYPE_NUMERIC = 'n'; |
const TYPE_BOOL = 'b'; |
const TYPE_NULL = 'null'; |
const TYPE_INLINE = 'inlineStr'; |
const TYPE_ERROR = 'e'; |
*/ |
case 'String' : |
$cellValue = self::_convertStringEncoding($cellValue,$this->_charSet); |
$type = PHPExcel_Cell_DataType::TYPE_STRING; |
break; |
case 'Number' : |
$type = PHPExcel_Cell_DataType::TYPE_NUMERIC; |
$cellValue = (float) $cellValue; |
if (floor($cellValue) == $cellValue) { |
$cellValue = (integer) $cellValue; |
} |
break; |
case 'Boolean' : |
$type = PHPExcel_Cell_DataType::TYPE_BOOL; |
$cellValue = ($cellValue != 0); |
break; |
case 'DateTime' : |
$type = PHPExcel_Cell_DataType::TYPE_NUMERIC; |
$cellValue = PHPExcel_Shared_Date::PHPToExcel(strtotime($cellValue)); |
break; |
case 'Error' : |
$type = PHPExcel_Cell_DataType::TYPE_ERROR; |
break; |
} |
} |
if ($hasCalculatedValue) { |
// echo 'FORMULA<br />'; |
$type = PHPExcel_Cell_DataType::TYPE_FORMULA; |
$columnNumber = PHPExcel_Cell::columnIndexFromString($columnID); |
if (substr($cellDataFormula,0,3) == 'of:') { |
$cellDataFormula = substr($cellDataFormula,3); |
// echo 'Before: ',$cellDataFormula,'<br />'; |
$temp = explode('"',$cellDataFormula); |
$key = false; |
foreach($temp as &$value) { |
// Only replace in alternate array entries (i.e. non-quoted blocks) |
if ($key = !$key) { |
$value = str_replace(array('[.','.',']'),'',$value); |
} |
} |
} else { |
// Convert R1C1 style references to A1 style references (but only when not quoted) |
// echo 'Before: ',$cellDataFormula,'<br />'; |
$temp = explode('"',$cellDataFormula); |
$key = false; |
foreach($temp as &$value) { |
// Only replace in alternate array entries (i.e. non-quoted blocks) |
if ($key = !$key) { |
preg_match_all('/(R(\[?-?\d*\]?))(C(\[?-?\d*\]?))/',$value, $cellReferences,PREG_SET_ORDER+PREG_OFFSET_CAPTURE); |
// Reverse the matches array, otherwise all our offsets will become incorrect if we modify our way |
// through the formula from left to right. Reversing means that we work right to left.through |
// the formula |
$cellReferences = array_reverse($cellReferences); |
// Loop through each R1C1 style reference in turn, converting it to its A1 style equivalent, |
// then modify the formula to use that new reference |
foreach($cellReferences as $cellReference) { |
$rowReference = $cellReference[2][0]; |
// Empty R reference is the current row |
if ($rowReference == '') $rowReference = $rowID; |
// Bracketed R references are relative to the current row |
if ($rowReference{0} == '[') $rowReference = $rowID + trim($rowReference,'[]'); |
$columnReference = $cellReference[4][0]; |
// Empty C reference is the current column |
if ($columnReference == '') $columnReference = $columnNumber; |
// Bracketed C references are relative to the current column |
if ($columnReference{0} == '[') $columnReference = $columnNumber + trim($columnReference,'[]'); |
$A1CellReference = PHPExcel_Cell::stringFromColumnIndex($columnReference-1).$rowReference; |
$value = substr_replace($value,$A1CellReference,$cellReference[0][1],strlen($cellReference[0][0])); |
} |
} |
} |
} |
unset($value); |
// Then rebuild the formula string |
$cellDataFormula = implode('"',$temp); |
// echo 'After: ',$cellDataFormula,'<br />'; |
} |
// echo 'Cell '.$columnID.$rowID.' is a '.$type.' with a value of '.(($hasCalculatedValue) ? $cellDataFormula : $cellValue).'<br />'; |
// |
$objPHPExcel->getActiveSheet()->getCell($columnID.$rowID)->setValueExplicit((($hasCalculatedValue) ? $cellDataFormula : $cellValue),$type); |
if ($hasCalculatedValue) { |
// echo 'Formula result is '.$cellValue.'<br />'; |
$objPHPExcel->getActiveSheet()->getCell($columnID.$rowID)->setCalculatedValue($cellValue); |
} |
$cellIsSet = $rowHasData = true; |
} |
if (isset($cell->Comment)) { |
// echo '<b>comment found</b><br />'; |
$commentAttributes = $cell->Comment->attributes($namespaces['ss']); |
$author = 'unknown'; |
if (isset($commentAttributes->Author)) { |
$author = (string)$commentAttributes->Author; |
// echo 'Author: ',$author,'<br />'; |
} |
$node = $cell->Comment->Data->asXML(); |
// $annotation = str_replace('html:','',substr($node,49,-10)); |
// echo $annotation,'<br />'; |
$annotation = strip_tags($node); |
// echo 'Annotation: ',$annotation,'<br />'; |
$objPHPExcel->getActiveSheet()->getComment( $columnID.$rowID ) |
->setAuthor(self::_convertStringEncoding($author ,$this->_charSet)) |
->setText($this->_parseRichText($annotation) ); |
} |
if (($cellIsSet) && (isset($cell_ss['StyleID']))) { |
$style = (string) $cell_ss['StyleID']; |
// echo 'Cell style for '.$columnID.$rowID.' is '.$style.'<br />'; |
if ((isset($this->_styles[$style])) && (!empty($this->_styles[$style]))) { |
// echo 'Cell '.$columnID.$rowID.'<br />'; |
// print_r($this->_styles[$style]); |
// echo '<br />'; |
if (!$objPHPExcel->getActiveSheet()->cellExists($columnID.$rowID)) { |
$objPHPExcel->getActiveSheet()->getCell($columnID.$rowID)->setValue(NULL); |
} |
$objPHPExcel->getActiveSheet()->getStyle($cellRange)->applyFromArray($this->_styles[$style]); |
} |
} |
++$columnID; |
} |
if ($rowHasData) { |
if (isset($row_ss['StyleID'])) { |
$rowStyle = $row_ss['StyleID']; |
} |
if (isset($row_ss['Height'])) { |
$rowHeight = $row_ss['Height']; |
// echo '<b>Setting row height to '.$rowHeight.'</b><br />'; |
$objPHPExcel->getActiveSheet()->getRowDimension($rowID)->setRowHeight($rowHeight); |
} |
} |
++$rowID; |
} |
} |
++$worksheetID; |
} |
// Return |
return $objPHPExcel; |
} |
private static function _convertStringEncoding($string,$charset) { |
if ($charset != 'UTF-8') { |
return PHPExcel_Shared_String::ConvertEncoding($string,'UTF-8',$charset); |
} |
return $string; |
} |
private function _parseRichText($is = '') { |
$value = new PHPExcel_RichText(); |
$value->createText(self::_convertStringEncoding($is,$this->_charSet)); |
return $value; |
} |
} |
/branches/v2.6-greffoir/jrest/lib/PHPExcel/Classes/PHPExcel/Reader/Excel2007.php |
---|
New file |
0,0 → 1,1982 |
<?php |
/** |
* PHPExcel |
* |
* Copyright (c) 2006 - 2013 PHPExcel |
* |
* This library is free software; you can redistribute it and/or |
* modify it under the terms of the GNU Lesser General Public |
* License as published by the Free Software Foundation; either |
* version 2.1 of the License, or (at your option) any later version. |
* |
* This library is distributed in the hope that it will be useful, |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
* Lesser General Public License for more details. |
* |
* You should have received a copy of the GNU Lesser General Public |
* License along with this library; if not, write to the Free Software |
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
* |
* @category PHPExcel |
* @package PHPExcel_Reader |
* @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL |
* @version ##VERSION##, ##DATE## |
*/ |
/** PHPExcel root directory */ |
if (!defined('PHPEXCEL_ROOT')) { |
/** |
* @ignore |
*/ |
define('PHPEXCEL_ROOT', dirname(__FILE__) . '/../../'); |
require(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php'); |
} |
/** |
* PHPExcel_Reader_Excel2007 |
* |
* @category PHPExcel |
* @package PHPExcel_Reader |
* @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
*/ |
class PHPExcel_Reader_Excel2007 extends PHPExcel_Reader_Abstract implements PHPExcel_Reader_IReader |
{ |
/** |
* PHPExcel_ReferenceHelper instance |
* |
* @var PHPExcel_ReferenceHelper |
*/ |
private $_referenceHelper = NULL; |
/** |
* PHPExcel_Reader_Excel2007_Theme instance |
* |
* @var PHPExcel_Reader_Excel2007_Theme |
*/ |
private static $_theme = NULL; |
/** |
* Create a new PHPExcel_Reader_Excel2007 instance |
*/ |
public function __construct() { |
$this->_readFilter = new PHPExcel_Reader_DefaultReadFilter(); |
$this->_referenceHelper = PHPExcel_ReferenceHelper::getInstance(); |
} |
/** |
* Can the current PHPExcel_Reader_IReader read the file? |
* |
* @param string $pFilename |
* @return boolean |
* @throws PHPExcel_Reader_Exception |
*/ |
public function canRead($pFilename) |
{ |
// Check if file exists |
if (!file_exists($pFilename)) { |
throw new PHPExcel_Reader_Exception("Could not open " . $pFilename . " for reading! File does not exist."); |
} |
// Check if zip class exists |
if (!class_exists('ZipArchive',FALSE)) { |
throw new PHPExcel_Reader_Exception("ZipArchive library is not enabled"); |
} |
$xl = false; |
// Load file |
$zip = new ZipArchive; |
if ($zip->open($pFilename) === true) { |
// check if it is an OOXML archive |
$rels = simplexml_load_string($this->_getFromZipArchive($zip, "_rels/.rels")); |
if ($rels !== false) { |
foreach ($rels->Relationship as $rel) { |
switch ($rel["Type"]) { |
case "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument": |
if (basename($rel["Target"]) == 'workbook.xml') { |
$xl = true; |
} |
break; |
} |
} |
} |
$zip->close(); |
} |
return $xl; |
} |
/** |
* Reads names of the worksheets from a file, without parsing the whole file to a PHPExcel object |
* |
* @param string $pFilename |
* @throws PHPExcel_Reader_Exception |
*/ |
public function listWorksheetNames($pFilename) |
{ |
// Check if file exists |
if (!file_exists($pFilename)) { |
throw new PHPExcel_Reader_Exception("Could not open " . $pFilename . " for reading! File does not exist."); |
} |
$worksheetNames = array(); |
$zip = new ZipArchive; |
$zip->open($pFilename); |
// The files we're looking at here are small enough that simpleXML is more efficient than XMLReader |
$rels = simplexml_load_string( |
$this->_getFromZipArchive($zip, "_rels/.rels") |
); //~ http://schemas.openxmlformats.org/package/2006/relationships"); |
foreach ($rels->Relationship as $rel) { |
switch ($rel["Type"]) { |
case "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument": |
$xmlWorkbook = simplexml_load_string( |
$this->_getFromZipArchive($zip, "{$rel['Target']}") |
); //~ http://schemas.openxmlformats.org/spreadsheetml/2006/main"); |
if ($xmlWorkbook->sheets) { |
foreach ($xmlWorkbook->sheets->sheet as $eleSheet) { |
// Check if sheet should be skipped |
$worksheetNames[] = (string) $eleSheet["name"]; |
} |
} |
} |
} |
$zip->close(); |
return $worksheetNames; |
} |
/** |
* Return worksheet info (Name, Last Column Letter, Last Column Index, Total Rows, Total Columns) |
* |
* @param string $pFilename |
* @throws PHPExcel_Reader_Exception |
*/ |
public function listWorksheetInfo($pFilename) |
{ |
// Check if file exists |
if (!file_exists($pFilename)) { |
throw new PHPExcel_Reader_Exception("Could not open " . $pFilename . " for reading! File does not exist."); |
} |
$worksheetInfo = array(); |
$zip = new ZipArchive; |
$zip->open($pFilename); |
$rels = simplexml_load_string($this->_getFromZipArchive($zip, "_rels/.rels")); //~ http://schemas.openxmlformats.org/package/2006/relationships"); |
foreach ($rels->Relationship as $rel) { |
if ($rel["Type"] == "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument") { |
$dir = dirname($rel["Target"]); |
$relsWorkbook = simplexml_load_string($this->_getFromZipArchive($zip, "$dir/_rels/" . basename($rel["Target"]) . ".rels")); //~ http://schemas.openxmlformats.org/package/2006/relationships"); |
$relsWorkbook->registerXPathNamespace("rel", "http://schemas.openxmlformats.org/package/2006/relationships"); |
$worksheets = array(); |
foreach ($relsWorkbook->Relationship as $ele) { |
if ($ele["Type"] == "http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet") { |
$worksheets[(string) $ele["Id"]] = $ele["Target"]; |
} |
} |
$xmlWorkbook = simplexml_load_string($this->_getFromZipArchive($zip, "{$rel['Target']}")); //~ http://schemas.openxmlformats.org/spreadsheetml/2006/main"); |
if ($xmlWorkbook->sheets) { |
$dir = dirname($rel["Target"]); |
foreach ($xmlWorkbook->sheets->sheet as $eleSheet) { |
$tmpInfo = array( |
'worksheetName' => (string) $eleSheet["name"], |
'lastColumnLetter' => 'A', |
'lastColumnIndex' => 0, |
'totalRows' => 0, |
'totalColumns' => 0, |
); |
$fileWorksheet = $worksheets[(string) self::array_item($eleSheet->attributes("http://schemas.openxmlformats.org/officeDocument/2006/relationships"), "id")]; |
$xml = new XMLReader(); |
$res = $xml->open('zip://'.PHPExcel_Shared_File::realpath($pFilename).'#'."$dir/$fileWorksheet"); |
$xml->setParserProperty(2,true); |
$currCells = 0; |
while ($xml->read()) { |
if ($xml->name == 'row' && $xml->nodeType == XMLReader::ELEMENT) { |
$row = $xml->getAttribute('r'); |
$tmpInfo['totalRows'] = $row; |
$tmpInfo['totalColumns'] = max($tmpInfo['totalColumns'],$currCells); |
$currCells = 0; |
} elseif ($xml->name == 'c' && $xml->nodeType == XMLReader::ELEMENT) { |
$currCells++; |
} |
} |
$tmpInfo['totalColumns'] = max($tmpInfo['totalColumns'],$currCells); |
$xml->close(); |
$tmpInfo['lastColumnIndex'] = $tmpInfo['totalColumns'] - 1; |
$tmpInfo['lastColumnLetter'] = PHPExcel_Cell::stringFromColumnIndex($tmpInfo['lastColumnIndex']); |
$worksheetInfo[] = $tmpInfo; |
} |
} |
} |
} |
$zip->close(); |
return $worksheetInfo; |
} |
private static function _castToBool($c) { |
// echo 'Initial Cast to Boolean<br />'; |
$value = isset($c->v) ? (string) $c->v : NULL; |
if ($value == '0') { |
return FALSE; |
} elseif ($value == '1') { |
return TRUE; |
} else { |
return (bool)$c->v; |
} |
return $value; |
} // function _castToBool() |
private static function _castToError($c) { |
// echo 'Initial Cast to Error<br />'; |
return isset($c->v) ? (string) $c->v : NULL; |
} // function _castToError() |
private static function _castToString($c) { |
// echo 'Initial Cast to String<br />'; |
return isset($c->v) ? (string) $c->v : NULL; |
} // function _castToString() |
private function _castToFormula($c,$r,&$cellDataType,&$value,&$calculatedValue,&$sharedFormulas,$castBaseType) { |
// echo 'Formula<br />'; |
// echo '$c->f is '.$c->f.'<br />'; |
$cellDataType = 'f'; |
$value = "={$c->f}"; |
$calculatedValue = self::$castBaseType($c); |
// Shared formula? |
if (isset($c->f['t']) && strtolower((string)$c->f['t']) == 'shared') { |
// echo 'SHARED FORMULA<br />'; |
$instance = (string)$c->f['si']; |
// echo 'Instance ID = '.$instance.'<br />'; |
// |
// echo 'Shared Formula Array:<pre>'; |
// print_r($sharedFormulas); |
// echo '</pre>'; |
if (!isset($sharedFormulas[(string)$c->f['si']])) { |
// echo 'SETTING NEW SHARED FORMULA<br />'; |
// echo 'Master is '.$r.'<br />'; |
// echo 'Formula is '.$value.'<br />'; |
$sharedFormulas[$instance] = array( 'master' => $r, |
'formula' => $value |
); |
// echo 'New Shared Formula Array:<pre>'; |
// print_r($sharedFormulas); |
// echo '</pre>'; |
} else { |
// echo 'GETTING SHARED FORMULA<br />'; |
// echo 'Master is '.$sharedFormulas[$instance]['master'].'<br />'; |
// echo 'Formula is '.$sharedFormulas[$instance]['formula'].'<br />'; |
$master = PHPExcel_Cell::coordinateFromString($sharedFormulas[$instance]['master']); |
$current = PHPExcel_Cell::coordinateFromString($r); |
$difference = array(0, 0); |
$difference[0] = PHPExcel_Cell::columnIndexFromString($current[0]) - PHPExcel_Cell::columnIndexFromString($master[0]); |
$difference[1] = $current[1] - $master[1]; |
$value = $this->_referenceHelper->updateFormulaReferences( $sharedFormulas[$instance]['formula'], |
'A1', |
$difference[0], |
$difference[1] |
); |
// echo 'Adjusted Formula is '.$value.'<br />'; |
} |
} |
} |
public function _getFromZipArchive(ZipArchive $archive, $fileName = '') |
{ |
// Root-relative paths |
if (strpos($fileName, '//') !== false) |
{ |
$fileName = substr($fileName, strpos($fileName, '//') + 1); |
} |
$fileName = PHPExcel_Shared_File::realpath($fileName); |
// Apache POI fixes |
$contents = $archive->getFromName($fileName); |
if ($contents === false) |
{ |
$contents = $archive->getFromName(substr($fileName, 1)); |
} |
return $contents; |
} |
/** |
* Loads PHPExcel from file |
* |
* @param string $pFilename |
* @throws PHPExcel_Reader_Exception |
*/ |
public function load($pFilename) |
{ |
// Check if file exists |
if (!file_exists($pFilename)) { |
throw new PHPExcel_Reader_Exception("Could not open " . $pFilename . " for reading! File does not exist."); |
} |
// Initialisations |
$excel = new PHPExcel; |
$excel->removeSheetByIndex(0); |
if (!$this->_readDataOnly) { |
$excel->removeCellStyleXfByIndex(0); // remove the default style |
$excel->removeCellXfByIndex(0); // remove the default style |
} |
$zip = new ZipArchive; |
$zip->open($pFilename); |
// Read the theme first, because we need the colour scheme when reading the styles |
$wbRels = simplexml_load_string($this->_getFromZipArchive($zip, "xl/_rels/workbook.xml.rels")); //~ http://schemas.openxmlformats.org/package/2006/relationships"); |
foreach ($wbRels->Relationship as $rel) { |
switch ($rel["Type"]) { |
case "http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme": |
$themeOrderArray = array('lt1','dk1','lt2','dk2'); |
$themeOrderAdditional = count($themeOrderArray); |
$xmlTheme = simplexml_load_string($this->_getFromZipArchive($zip, "xl/{$rel['Target']}")); |
if (is_object($xmlTheme)) { |
$xmlThemeName = $xmlTheme->attributes(); |
$xmlTheme = $xmlTheme->children("http://schemas.openxmlformats.org/drawingml/2006/main"); |
$themeName = (string)$xmlThemeName['name']; |
$colourScheme = $xmlTheme->themeElements->clrScheme->attributes(); |
$colourSchemeName = (string)$colourScheme['name']; |
$colourScheme = $xmlTheme->themeElements->clrScheme->children("http://schemas.openxmlformats.org/drawingml/2006/main"); |
$themeColours = array(); |
foreach ($colourScheme as $k => $xmlColour) { |
$themePos = array_search($k,$themeOrderArray); |
if ($themePos === false) { |
$themePos = $themeOrderAdditional++; |
} |
if (isset($xmlColour->sysClr)) { |
$xmlColourData = $xmlColour->sysClr->attributes(); |
$themeColours[$themePos] = $xmlColourData['lastClr']; |
} elseif (isset($xmlColour->srgbClr)) { |
$xmlColourData = $xmlColour->srgbClr->attributes(); |
$themeColours[$themePos] = $xmlColourData['val']; |
} |
} |
self::$_theme = new PHPExcel_Reader_Excel2007_Theme($themeName,$colourSchemeName,$themeColours); |
} |
break; |
} |
} |
$rels = simplexml_load_string($this->_getFromZipArchive($zip, "_rels/.rels")); //~ http://schemas.openxmlformats.org/package/2006/relationships"); |
foreach ($rels->Relationship as $rel) { |
switch ($rel["Type"]) { |
case "http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties": |
$xmlCore = simplexml_load_string($this->_getFromZipArchive($zip, "{$rel['Target']}")); |
if (is_object($xmlCore)) { |
$xmlCore->registerXPathNamespace("dc", "http://purl.org/dc/elements/1.1/"); |
$xmlCore->registerXPathNamespace("dcterms", "http://purl.org/dc/terms/"); |
$xmlCore->registerXPathNamespace("cp", "http://schemas.openxmlformats.org/package/2006/metadata/core-properties"); |
$docProps = $excel->getProperties(); |
$docProps->setCreator((string) self::array_item($xmlCore->xpath("dc:creator"))); |
$docProps->setLastModifiedBy((string) self::array_item($xmlCore->xpath("cp:lastModifiedBy"))); |
$docProps->setCreated(strtotime(self::array_item($xmlCore->xpath("dcterms:created")))); //! respect xsi:type |
$docProps->setModified(strtotime(self::array_item($xmlCore->xpath("dcterms:modified")))); //! respect xsi:type |
$docProps->setTitle((string) self::array_item($xmlCore->xpath("dc:title"))); |
$docProps->setDescription((string) self::array_item($xmlCore->xpath("dc:description"))); |
$docProps->setSubject((string) self::array_item($xmlCore->xpath("dc:subject"))); |
$docProps->setKeywords((string) self::array_item($xmlCore->xpath("cp:keywords"))); |
$docProps->setCategory((string) self::array_item($xmlCore->xpath("cp:category"))); |
} |
break; |
case "http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties": |
$xmlCore = simplexml_load_string($this->_getFromZipArchive($zip, "{$rel['Target']}")); |
if (is_object($xmlCore)) { |
$docProps = $excel->getProperties(); |
if (isset($xmlCore->Company)) |
$docProps->setCompany((string) $xmlCore->Company); |
if (isset($xmlCore->Manager)) |
$docProps->setManager((string) $xmlCore->Manager); |
} |
break; |
case "http://schemas.openxmlformats.org/officeDocument/2006/relationships/custom-properties": |
$xmlCore = simplexml_load_string($this->_getFromZipArchive($zip, "{$rel['Target']}")); |
if (is_object($xmlCore)) { |
$docProps = $excel->getProperties(); |
foreach ($xmlCore as $xmlProperty) { |
$cellDataOfficeAttributes = $xmlProperty->attributes(); |
if (isset($cellDataOfficeAttributes['name'])) { |
$propertyName = (string) $cellDataOfficeAttributes['name']; |
$cellDataOfficeChildren = $xmlProperty->children('http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes'); |
$attributeType = $cellDataOfficeChildren->getName(); |
$attributeValue = (string) $cellDataOfficeChildren->{$attributeType}; |
$attributeValue = PHPExcel_DocumentProperties::convertProperty($attributeValue,$attributeType); |
$attributeType = PHPExcel_DocumentProperties::convertPropertyType($attributeType); |
$docProps->setCustomProperty($propertyName,$attributeValue,$attributeType); |
} |
} |
} |
break; |
case "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument": |
$dir = dirname($rel["Target"]); |
$relsWorkbook = simplexml_load_string($this->_getFromZipArchive($zip, "$dir/_rels/" . basename($rel["Target"]) . ".rels")); //~ http://schemas.openxmlformats.org/package/2006/relationships"); |
$relsWorkbook->registerXPathNamespace("rel", "http://schemas.openxmlformats.org/package/2006/relationships"); |
$sharedStrings = array(); |
$xpath = self::array_item($relsWorkbook->xpath("rel:Relationship[@Type='http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings']")); |
$xmlStrings = simplexml_load_string($this->_getFromZipArchive($zip, "$dir/$xpath[Target]")); //~ http://schemas.openxmlformats.org/spreadsheetml/2006/main"); |
if (isset($xmlStrings) && isset($xmlStrings->si)) { |
foreach ($xmlStrings->si as $val) { |
if (isset($val->t)) { |
$sharedStrings[] = PHPExcel_Shared_String::ControlCharacterOOXML2PHP( (string) $val->t ); |
} elseif (isset($val->r)) { |
$sharedStrings[] = $this->_parseRichText($val); |
} |
} |
} |
$worksheets = array(); |
foreach ($relsWorkbook->Relationship as $ele) { |
if ($ele["Type"] == "http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet") { |
$worksheets[(string) $ele["Id"]] = $ele["Target"]; |
} |
} |
$styles = array(); |
$cellStyles = array(); |
$xpath = self::array_item($relsWorkbook->xpath("rel:Relationship[@Type='http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles']")); |
$xmlStyles = simplexml_load_string($this->_getFromZipArchive($zip, "$dir/$xpath[Target]")); //~ http://schemas.openxmlformats.org/spreadsheetml/2006/main"); |
$numFmts = null; |
if ($xmlStyles && $xmlStyles->numFmts[0]) { |
$numFmts = $xmlStyles->numFmts[0]; |
} |
if (isset($numFmts) && ($numFmts !== NULL)) { |
$numFmts->registerXPathNamespace("sml", "http://schemas.openxmlformats.org/spreadsheetml/2006/main"); |
} |
if (!$this->_readDataOnly && $xmlStyles) { |
foreach ($xmlStyles->cellXfs->xf as $xf) { |
$numFmt = PHPExcel_Style_NumberFormat::FORMAT_GENERAL; |
if ($xf["numFmtId"]) { |
if (isset($numFmts)) { |
$tmpNumFmt = self::array_item($numFmts->xpath("sml:numFmt[@numFmtId=$xf[numFmtId]]")); |
if (isset($tmpNumFmt["formatCode"])) { |
$numFmt = (string) $tmpNumFmt["formatCode"]; |
} |
} |
if ((int)$xf["numFmtId"] < 164) { |
$numFmt = PHPExcel_Style_NumberFormat::builtInFormatCode((int)$xf["numFmtId"]); |
} |
} |
//$numFmt = str_replace('mm', 'i', $numFmt); |
//$numFmt = str_replace('h', 'H', $numFmt); |
$style = (object) array( |
"numFmt" => $numFmt, |
"font" => $xmlStyles->fonts->font[intval($xf["fontId"])], |
"fill" => $xmlStyles->fills->fill[intval($xf["fillId"])], |
"border" => $xmlStyles->borders->border[intval($xf["borderId"])], |
"alignment" => $xf->alignment, |
"protection" => $xf->protection, |
); |
$styles[] = $style; |
// add style to cellXf collection |
$objStyle = new PHPExcel_Style; |
self::_readStyle($objStyle, $style); |
$excel->addCellXf($objStyle); |
} |
foreach ($xmlStyles->cellStyleXfs->xf as $xf) { |
$numFmt = PHPExcel_Style_NumberFormat::FORMAT_GENERAL; |
if ($numFmts && $xf["numFmtId"]) { |
$tmpNumFmt = self::array_item($numFmts->xpath("sml:numFmt[@numFmtId=$xf[numFmtId]]")); |
if (isset($tmpNumFmt["formatCode"])) { |
$numFmt = (string) $tmpNumFmt["formatCode"]; |
} else if ((int)$xf["numFmtId"] < 165) { |
$numFmt = PHPExcel_Style_NumberFormat::builtInFormatCode((int)$xf["numFmtId"]); |
} |
} |
$cellStyle = (object) array( |
"numFmt" => $numFmt, |
"font" => $xmlStyles->fonts->font[intval($xf["fontId"])], |
"fill" => $xmlStyles->fills->fill[intval($xf["fillId"])], |
"border" => $xmlStyles->borders->border[intval($xf["borderId"])], |
"alignment" => $xf->alignment, |
"protection" => $xf->protection, |
); |
$cellStyles[] = $cellStyle; |
// add style to cellStyleXf collection |
$objStyle = new PHPExcel_Style; |
self::_readStyle($objStyle, $cellStyle); |
$excel->addCellStyleXf($objStyle); |
} |
} |
$dxfs = array(); |
if (!$this->_readDataOnly && $xmlStyles) { |
// Conditional Styles |
if ($xmlStyles->dxfs) { |
foreach ($xmlStyles->dxfs->dxf as $dxf) { |
$style = new PHPExcel_Style(FALSE, TRUE); |
self::_readStyle($style, $dxf); |
$dxfs[] = $style; |
} |
} |
// Cell Styles |
if ($xmlStyles->cellStyles) { |
foreach ($xmlStyles->cellStyles->cellStyle as $cellStyle) { |
if (intval($cellStyle['builtinId']) == 0) { |
if (isset($cellStyles[intval($cellStyle['xfId'])])) { |
// Set default style |
$style = new PHPExcel_Style; |
self::_readStyle($style, $cellStyles[intval($cellStyle['xfId'])]); |
// normal style, currently not using it for anything |
} |
} |
} |
} |
} |
$xmlWorkbook = simplexml_load_string($this->_getFromZipArchive($zip, "{$rel['Target']}")); //~ http://schemas.openxmlformats.org/spreadsheetml/2006/main"); |
// Set base date |
if ($xmlWorkbook->workbookPr) { |
PHPExcel_Shared_Date::setExcelCalendar(PHPExcel_Shared_Date::CALENDAR_WINDOWS_1900); |
if (isset($xmlWorkbook->workbookPr['date1904'])) { |
if (self::boolean((string) $xmlWorkbook->workbookPr['date1904'])) { |
PHPExcel_Shared_Date::setExcelCalendar(PHPExcel_Shared_Date::CALENDAR_MAC_1904); |
} |
} |
} |
$sheetId = 0; // keep track of new sheet id in final workbook |
$oldSheetId = -1; // keep track of old sheet id in final workbook |
$countSkippedSheets = 0; // keep track of number of skipped sheets |
$mapSheetId = array(); // mapping of sheet ids from old to new |
$charts = $chartDetails = array(); |
if ($xmlWorkbook->sheets) { |
foreach ($xmlWorkbook->sheets->sheet as $eleSheet) { |
++$oldSheetId; |
// Check if sheet should be skipped |
if (isset($this->_loadSheetsOnly) && !in_array((string) $eleSheet["name"], $this->_loadSheetsOnly)) { |
++$countSkippedSheets; |
$mapSheetId[$oldSheetId] = null; |
continue; |
} |
// Map old sheet id in original workbook to new sheet id. |
// They will differ if loadSheetsOnly() is being used |
$mapSheetId[$oldSheetId] = $oldSheetId - $countSkippedSheets; |
// Load sheet |
$docSheet = $excel->createSheet(); |
// Use false for $updateFormulaCellReferences to prevent adjustment of worksheet |
// references in formula cells... during the load, all formulae should be correct, |
// and we're simply bringing the worksheet name in line with the formula, not the |
// reverse |
$docSheet->setTitle((string) $eleSheet["name"],false); |
$fileWorksheet = $worksheets[(string) self::array_item($eleSheet->attributes("http://schemas.openxmlformats.org/officeDocument/2006/relationships"), "id")]; |
$xmlSheet = simplexml_load_string($this->_getFromZipArchive($zip, "$dir/$fileWorksheet")); //~ http://schemas.openxmlformats.org/spreadsheetml/2006/main"); |
$sharedFormulas = array(); |
if (isset($eleSheet["state"]) && (string) $eleSheet["state"] != '') { |
$docSheet->setSheetState( (string) $eleSheet["state"] ); |
} |
if (isset($xmlSheet->sheetViews) && isset($xmlSheet->sheetViews->sheetView)) { |
if (isset($xmlSheet->sheetViews->sheetView['zoomScale'])) { |
$docSheet->getSheetView()->setZoomScale( intval($xmlSheet->sheetViews->sheetView['zoomScale']) ); |
} |
if (isset($xmlSheet->sheetViews->sheetView['zoomScaleNormal'])) { |
$docSheet->getSheetView()->setZoomScaleNormal( intval($xmlSheet->sheetViews->sheetView['zoomScaleNormal']) ); |
} |
if (isset($xmlSheet->sheetViews->sheetView['view'])) { |
$docSheet->getSheetView()->setView((string) $xmlSheet->sheetViews->sheetView['view']); |
} |
if (isset($xmlSheet->sheetViews->sheetView['showGridLines'])) { |
$docSheet->setShowGridLines(self::boolean((string)$xmlSheet->sheetViews->sheetView['showGridLines'])); |
} |
if (isset($xmlSheet->sheetViews->sheetView['showRowColHeaders'])) { |
$docSheet->setShowRowColHeaders(self::boolean((string)$xmlSheet->sheetViews->sheetView['showRowColHeaders'])); |
} |
if (isset($xmlSheet->sheetViews->sheetView['rightToLeft'])) { |
$docSheet->setRightToLeft(self::boolean((string)$xmlSheet->sheetViews->sheetView['rightToLeft'])); |
} |
if (isset($xmlSheet->sheetViews->sheetView->pane)) { |
if (isset($xmlSheet->sheetViews->sheetView->pane['topLeftCell'])) { |
$docSheet->freezePane( (string)$xmlSheet->sheetViews->sheetView->pane['topLeftCell'] ); |
} else { |
$xSplit = 0; |
$ySplit = 0; |
if (isset($xmlSheet->sheetViews->sheetView->pane['xSplit'])) { |
$xSplit = 1 + intval($xmlSheet->sheetViews->sheetView->pane['xSplit']); |
} |
if (isset($xmlSheet->sheetViews->sheetView->pane['ySplit'])) { |
$ySplit = 1 + intval($xmlSheet->sheetViews->sheetView->pane['ySplit']); |
} |
$docSheet->freezePaneByColumnAndRow($xSplit, $ySplit); |
} |
} |
if (isset($xmlSheet->sheetViews->sheetView->selection)) { |
if (isset($xmlSheet->sheetViews->sheetView->selection['sqref'])) { |
$sqref = (string)$xmlSheet->sheetViews->sheetView->selection['sqref']; |
$sqref = explode(' ', $sqref); |
$sqref = $sqref[0]; |
$docSheet->setSelectedCells($sqref); |
} |
} |
} |
if (isset($xmlSheet->sheetPr) && isset($xmlSheet->sheetPr->tabColor)) { |
if (isset($xmlSheet->sheetPr->tabColor['rgb'])) { |
$docSheet->getTabColor()->setARGB( (string)$xmlSheet->sheetPr->tabColor['rgb'] ); |
} |
} |
if (isset($xmlSheet->sheetPr) && isset($xmlSheet->sheetPr->outlinePr)) { |
if (isset($xmlSheet->sheetPr->outlinePr['summaryRight']) && |
!self::boolean((string) $xmlSheet->sheetPr->outlinePr['summaryRight'])) { |
$docSheet->setShowSummaryRight(FALSE); |
} else { |
$docSheet->setShowSummaryRight(TRUE); |
} |
if (isset($xmlSheet->sheetPr->outlinePr['summaryBelow']) && |
!self::boolean((string) $xmlSheet->sheetPr->outlinePr['summaryBelow'])) { |
$docSheet->setShowSummaryBelow(FALSE); |
} else { |
$docSheet->setShowSummaryBelow(TRUE); |
} |
} |
if (isset($xmlSheet->sheetPr) && isset($xmlSheet->sheetPr->pageSetUpPr)) { |
if (isset($xmlSheet->sheetPr->pageSetUpPr['fitToPage']) && |
!self::boolean((string) $xmlSheet->sheetPr->pageSetUpPr['fitToPage'])) { |
$docSheet->getPageSetup()->setFitToPage(FALSE); |
} else { |
$docSheet->getPageSetup()->setFitToPage(TRUE); |
} |
} |
if (isset($xmlSheet->sheetFormatPr)) { |
if (isset($xmlSheet->sheetFormatPr['customHeight']) && |
self::boolean((string) $xmlSheet->sheetFormatPr['customHeight']) && |
isset($xmlSheet->sheetFormatPr['defaultRowHeight'])) { |
$docSheet->getDefaultRowDimension()->setRowHeight( (float)$xmlSheet->sheetFormatPr['defaultRowHeight'] ); |
} |
if (isset($xmlSheet->sheetFormatPr['defaultColWidth'])) { |
$docSheet->getDefaultColumnDimension()->setWidth( (float)$xmlSheet->sheetFormatPr['defaultColWidth'] ); |
} |
if (isset($xmlSheet->sheetFormatPr['zeroHeight']) && |
((string)$xmlSheet->sheetFormatPr['zeroHeight'] == '1')) { |
$docSheet->getDefaultRowDimension()->setzeroHeight(true); |
} |
} |
if (isset($xmlSheet->cols) && !$this->_readDataOnly) { |
foreach ($xmlSheet->cols->col as $col) { |
for ($i = intval($col["min"]) - 1; $i < intval($col["max"]); ++$i) { |
if ($col["style"] && !$this->_readDataOnly) { |
$docSheet->getColumnDimension(PHPExcel_Cell::stringFromColumnIndex($i))->setXfIndex(intval($col["style"])); |
} |
if (self::boolean($col["bestFit"])) { |
//$docSheet->getColumnDimension(PHPExcel_Cell::stringFromColumnIndex($i))->setAutoSize(TRUE); |
} |
if (self::boolean($col["hidden"])) { |
$docSheet->getColumnDimension(PHPExcel_Cell::stringFromColumnIndex($i))->setVisible(FALSE); |
} |
if (self::boolean($col["collapsed"])) { |
$docSheet->getColumnDimension(PHPExcel_Cell::stringFromColumnIndex($i))->setCollapsed(TRUE); |
} |
if ($col["outlineLevel"] > 0) { |
$docSheet->getColumnDimension(PHPExcel_Cell::stringFromColumnIndex($i))->setOutlineLevel(intval($col["outlineLevel"])); |
} |
$docSheet->getColumnDimension(PHPExcel_Cell::stringFromColumnIndex($i))->setWidth(floatval($col["width"])); |
if (intval($col["max"]) == 16384) { |
break; |
} |
} |
} |
} |
if (isset($xmlSheet->printOptions) && !$this->_readDataOnly) { |
if (self::boolean((string) $xmlSheet->printOptions['gridLinesSet'])) { |
$docSheet->setShowGridlines(TRUE); |
} |
if (self::boolean((string) $xmlSheet->printOptions['gridLines'])) { |
$docSheet->setPrintGridlines(TRUE); |
} |
if (self::boolean((string) $xmlSheet->printOptions['horizontalCentered'])) { |
$docSheet->getPageSetup()->setHorizontalCentered(TRUE); |
} |
if (self::boolean((string) $xmlSheet->printOptions['verticalCentered'])) { |
$docSheet->getPageSetup()->setVerticalCentered(TRUE); |
} |
} |
if ($xmlSheet && $xmlSheet->sheetData && $xmlSheet->sheetData->row) { |
foreach ($xmlSheet->sheetData->row as $row) { |
if ($row["ht"] && !$this->_readDataOnly) { |
$docSheet->getRowDimension(intval($row["r"]))->setRowHeight(floatval($row["ht"])); |
} |
if (self::boolean($row["hidden"]) && !$this->_readDataOnly) { |
$docSheet->getRowDimension(intval($row["r"]))->setVisible(FALSE); |
} |
if (self::boolean($row["collapsed"])) { |
$docSheet->getRowDimension(intval($row["r"]))->setCollapsed(TRUE); |
} |
if ($row["outlineLevel"] > 0) { |
$docSheet->getRowDimension(intval($row["r"]))->setOutlineLevel(intval($row["outlineLevel"])); |
} |
if ($row["s"] && !$this->_readDataOnly) { |
$docSheet->getRowDimension(intval($row["r"]))->setXfIndex(intval($row["s"])); |
} |
foreach ($row->c as $c) { |
$r = (string) $c["r"]; |
$cellDataType = (string) $c["t"]; |
$value = null; |
$calculatedValue = null; |
// Read cell? |
if ($this->getReadFilter() !== NULL) { |
$coordinates = PHPExcel_Cell::coordinateFromString($r); |
if (!$this->getReadFilter()->readCell($coordinates[0], $coordinates[1], $docSheet->getTitle())) { |
continue; |
} |
} |
// echo '<b>Reading cell '.$coordinates[0].$coordinates[1].'</b><br />'; |
// print_r($c); |
// echo '<br />'; |
// echo 'Cell Data Type is '.$cellDataType.': '; |
// |
// Read cell! |
switch ($cellDataType) { |
case "s": |
// echo 'String<br />'; |
if ((string)$c->v != '') { |
$value = $sharedStrings[intval($c->v)]; |
if ($value instanceof PHPExcel_RichText) { |
$value = clone $value; |
} |
} else { |
$value = ''; |
} |
break; |
case "b": |
// echo 'Boolean<br />'; |
if (!isset($c->f)) { |
$value = self::_castToBool($c); |
} else { |
// Formula |
$this->_castToFormula($c,$r,$cellDataType,$value,$calculatedValue,$sharedFormulas,'_castToBool'); |
if (isset($c->f['t'])) { |
$att = array(); |
$att = $c->f; |
$docSheet->getCell($r)->setFormulaAttributes($att); |
} |
// echo '$calculatedValue = '.$calculatedValue.'<br />'; |
} |
break; |
case "inlineStr": |
// echo 'Inline String<br />'; |
$value = $this->_parseRichText($c->is); |
break; |
case "e": |
// echo 'Error<br />'; |
if (!isset($c->f)) { |
$value = self::_castToError($c); |
} else { |
// Formula |
$this->_castToFormula($c,$r,$cellDataType,$value,$calculatedValue,$sharedFormulas,'_castToError'); |
// echo '$calculatedValue = '.$calculatedValue.'<br />'; |
} |
break; |
default: |
// echo 'Default<br />'; |
if (!isset($c->f)) { |
// echo 'Not a Formula<br />'; |
$value = self::_castToString($c); |
} else { |
// echo 'Treat as Formula<br />'; |
// Formula |
$this->_castToFormula($c,$r,$cellDataType,$value,$calculatedValue,$sharedFormulas,'_castToString'); |
// echo '$calculatedValue = '.$calculatedValue.'<br />'; |
} |
break; |
} |
// echo 'Value is '.$value.'<br />'; |
// Check for numeric values |
if (is_numeric($value) && $cellDataType != 's') { |
if ($value == (int)$value) $value = (int)$value; |
elseif ($value == (float)$value) $value = (float)$value; |
elseif ($value == (double)$value) $value = (double)$value; |
} |
// Rich text? |
if ($value instanceof PHPExcel_RichText && $this->_readDataOnly) { |
$value = $value->getPlainText(); |
} |
$cell = $docSheet->getCell($r); |
// Assign value |
if ($cellDataType != '') { |
$cell->setValueExplicit($value, $cellDataType); |
} else { |
$cell->setValue($value); |
} |
if ($calculatedValue !== NULL) { |
$cell->setCalculatedValue($calculatedValue); |
} |
// Style information? |
if ($c["s"] && !$this->_readDataOnly) { |
// no style index means 0, it seems |
$cell->setXfIndex(isset($styles[intval($c["s"])]) ? |
intval($c["s"]) : 0); |
} |
} |
} |
} |
$conditionals = array(); |
if (!$this->_readDataOnly && $xmlSheet && $xmlSheet->conditionalFormatting) { |
foreach ($xmlSheet->conditionalFormatting as $conditional) { |
foreach ($conditional->cfRule as $cfRule) { |
if ( |
( |
(string)$cfRule["type"] == PHPExcel_Style_Conditional::CONDITION_NONE || |
(string)$cfRule["type"] == PHPExcel_Style_Conditional::CONDITION_CELLIS || |
(string)$cfRule["type"] == PHPExcel_Style_Conditional::CONDITION_CONTAINSTEXT || |
(string)$cfRule["type"] == PHPExcel_Style_Conditional::CONDITION_EXPRESSION |
) && isset($dxfs[intval($cfRule["dxfId"])]) |
) { |
$conditionals[(string) $conditional["sqref"]][intval($cfRule["priority"])] = $cfRule; |
} |
} |
} |
foreach ($conditionals as $ref => $cfRules) { |
ksort($cfRules); |
$conditionalStyles = array(); |
foreach ($cfRules as $cfRule) { |
$objConditional = new PHPExcel_Style_Conditional(); |
$objConditional->setConditionType((string)$cfRule["type"]); |
$objConditional->setOperatorType((string)$cfRule["operator"]); |
if ((string)$cfRule["text"] != '') { |
$objConditional->setText((string)$cfRule["text"]); |
} |
if (count($cfRule->formula) > 1) { |
foreach ($cfRule->formula as $formula) { |
$objConditional->addCondition((string)$formula); |
} |
} else { |
$objConditional->addCondition((string)$cfRule->formula); |
} |
$objConditional->setStyle(clone $dxfs[intval($cfRule["dxfId"])]); |
$conditionalStyles[] = $objConditional; |
} |
// Extract all cell references in $ref |
$aReferences = PHPExcel_Cell::extractAllCellReferencesInRange($ref); |
foreach ($aReferences as $reference) { |
$docSheet->getStyle($reference)->setConditionalStyles($conditionalStyles); |
} |
} |
} |
$aKeys = array("sheet", "objects", "scenarios", "formatCells", "formatColumns", "formatRows", "insertColumns", "insertRows", "insertHyperlinks", "deleteColumns", "deleteRows", "selectLockedCells", "sort", "autoFilter", "pivotTables", "selectUnlockedCells"); |
if (!$this->_readDataOnly && $xmlSheet && $xmlSheet->sheetProtection) { |
foreach ($aKeys as $key) { |
$method = "set" . ucfirst($key); |
$docSheet->getProtection()->$method(self::boolean((string) $xmlSheet->sheetProtection[$key])); |
} |
} |
if (!$this->_readDataOnly && $xmlSheet && $xmlSheet->sheetProtection) { |
$docSheet->getProtection()->setPassword((string) $xmlSheet->sheetProtection["password"], TRUE); |
if ($xmlSheet->protectedRanges->protectedRange) { |
foreach ($xmlSheet->protectedRanges->protectedRange as $protectedRange) { |
$docSheet->protectCells((string) $protectedRange["sqref"], (string) $protectedRange["password"], true); |
} |
} |
} |
if ($xmlSheet && $xmlSheet->autoFilter && !$this->_readDataOnly) { |
$autoFilter = $docSheet->getAutoFilter(); |
$autoFilter->setRange((string) $xmlSheet->autoFilter["ref"]); |
foreach ($xmlSheet->autoFilter->filterColumn as $filterColumn) { |
$column = $autoFilter->getColumnByOffset((integer) $filterColumn["colId"]); |
// Check for standard filters |
if ($filterColumn->filters) { |
$column->setFilterType(PHPExcel_Worksheet_AutoFilter_Column::AUTOFILTER_FILTERTYPE_FILTER); |
$filters = $filterColumn->filters; |
if ((isset($filters["blank"])) && ($filters["blank"] == 1)) { |
$column->createRule()->setRule( |
NULL, // Operator is undefined, but always treated as EQUAL |
'' |
) |
->setRuleType(PHPExcel_Worksheet_AutoFilter_Column_Rule::AUTOFILTER_RULETYPE_FILTER); |
} |
// Standard filters are always an OR join, so no join rule needs to be set |
// Entries can be either filter elements |
foreach ($filters->filter as $filterRule) { |
$column->createRule()->setRule( |
NULL, // Operator is undefined, but always treated as EQUAL |
(string) $filterRule["val"] |
) |
->setRuleType(PHPExcel_Worksheet_AutoFilter_Column_Rule::AUTOFILTER_RULETYPE_FILTER); |
} |
// Or Date Group elements |
foreach ($filters->dateGroupItem as $dateGroupItem) { |
$column->createRule()->setRule( |
NULL, // Operator is undefined, but always treated as EQUAL |
array( |
'year' => (string) $dateGroupItem["year"], |
'month' => (string) $dateGroupItem["month"], |
'day' => (string) $dateGroupItem["day"], |
'hour' => (string) $dateGroupItem["hour"], |
'minute' => (string) $dateGroupItem["minute"], |
'second' => (string) $dateGroupItem["second"], |
), |
(string) $dateGroupItem["dateTimeGrouping"] |
) |
->setRuleType(PHPExcel_Worksheet_AutoFilter_Column_Rule::AUTOFILTER_RULETYPE_DATEGROUP); |
} |
} |
// Check for custom filters |
if ($filterColumn->customFilters) { |
$column->setFilterType(PHPExcel_Worksheet_AutoFilter_Column::AUTOFILTER_FILTERTYPE_CUSTOMFILTER); |
$customFilters = $filterColumn->customFilters; |
// Custom filters can an AND or an OR join; |
// and there should only ever be one or two entries |
if ((isset($customFilters["and"])) && ($customFilters["and"] == 1)) { |
$column->setJoin(PHPExcel_Worksheet_AutoFilter_Column::AUTOFILTER_COLUMN_JOIN_AND); |
} |
foreach ($customFilters->customFilter as $filterRule) { |
$column->createRule()->setRule( |
(string) $filterRule["operator"], |
(string) $filterRule["val"] |
) |
->setRuleType(PHPExcel_Worksheet_AutoFilter_Column_Rule::AUTOFILTER_RULETYPE_CUSTOMFILTER); |
} |
} |
// Check for dynamic filters |
if ($filterColumn->dynamicFilter) { |
$column->setFilterType(PHPExcel_Worksheet_AutoFilter_Column::AUTOFILTER_FILTERTYPE_DYNAMICFILTER); |
// We should only ever have one dynamic filter |
foreach ($filterColumn->dynamicFilter as $filterRule) { |
$column->createRule()->setRule( |
NULL, // Operator is undefined, but always treated as EQUAL |
(string) $filterRule["val"], |
(string) $filterRule["type"] |
) |
->setRuleType(PHPExcel_Worksheet_AutoFilter_Column_Rule::AUTOFILTER_RULETYPE_DYNAMICFILTER); |
if (isset($filterRule["val"])) { |
$column->setAttribute('val',(string) $filterRule["val"]); |
} |
if (isset($filterRule["maxVal"])) { |
$column->setAttribute('maxVal',(string) $filterRule["maxVal"]); |
} |
} |
} |
// Check for dynamic filters |
if ($filterColumn->top10) { |
$column->setFilterType(PHPExcel_Worksheet_AutoFilter_Column::AUTOFILTER_FILTERTYPE_TOPTENFILTER); |
// We should only ever have one top10 filter |
foreach ($filterColumn->top10 as $filterRule) { |
$column->createRule()->setRule( |
(((isset($filterRule["percent"])) && ($filterRule["percent"] == 1)) |
? PHPExcel_Worksheet_AutoFilter_Column_Rule::AUTOFILTER_COLUMN_RULE_TOPTEN_PERCENT |
: PHPExcel_Worksheet_AutoFilter_Column_Rule::AUTOFILTER_COLUMN_RULE_TOPTEN_BY_VALUE |
), |
(string) $filterRule["val"], |
(((isset($filterRule["top"])) && ($filterRule["top"] == 1)) |
? PHPExcel_Worksheet_AutoFilter_Column_Rule::AUTOFILTER_COLUMN_RULE_TOPTEN_TOP |
: PHPExcel_Worksheet_AutoFilter_Column_Rule::AUTOFILTER_COLUMN_RULE_TOPTEN_BOTTOM |
) |
) |
->setRuleType(PHPExcel_Worksheet_AutoFilter_Column_Rule::AUTOFILTER_RULETYPE_TOPTENFILTER); |
} |
} |
} |
} |
if ($xmlSheet && $xmlSheet->mergeCells && $xmlSheet->mergeCells->mergeCell && !$this->_readDataOnly) { |
foreach ($xmlSheet->mergeCells->mergeCell as $mergeCell) { |
$mergeRef = (string) $mergeCell["ref"]; |
if (strpos($mergeRef,':') !== FALSE) { |
$docSheet->mergeCells((string) $mergeCell["ref"]); |
} |
} |
} |
if ($xmlSheet && $xmlSheet->pageMargins && !$this->_readDataOnly) { |
$docPageMargins = $docSheet->getPageMargins(); |
$docPageMargins->setLeft(floatval($xmlSheet->pageMargins["left"])); |
$docPageMargins->setRight(floatval($xmlSheet->pageMargins["right"])); |
$docPageMargins->setTop(floatval($xmlSheet->pageMargins["top"])); |
$docPageMargins->setBottom(floatval($xmlSheet->pageMargins["bottom"])); |
$docPageMargins->setHeader(floatval($xmlSheet->pageMargins["header"])); |
$docPageMargins->setFooter(floatval($xmlSheet->pageMargins["footer"])); |
} |
if ($xmlSheet && $xmlSheet->pageSetup && !$this->_readDataOnly) { |
$docPageSetup = $docSheet->getPageSetup(); |
if (isset($xmlSheet->pageSetup["orientation"])) { |
$docPageSetup->setOrientation((string) $xmlSheet->pageSetup["orientation"]); |
} |
if (isset($xmlSheet->pageSetup["paperSize"])) { |
$docPageSetup->setPaperSize(intval($xmlSheet->pageSetup["paperSize"])); |
} |
if (isset($xmlSheet->pageSetup["scale"])) { |
$docPageSetup->setScale(intval($xmlSheet->pageSetup["scale"]), FALSE); |
} |
if (isset($xmlSheet->pageSetup["fitToHeight"]) && intval($xmlSheet->pageSetup["fitToHeight"]) >= 0) { |
$docPageSetup->setFitToHeight(intval($xmlSheet->pageSetup["fitToHeight"]), FALSE); |
} |
if (isset($xmlSheet->pageSetup["fitToWidth"]) && intval($xmlSheet->pageSetup["fitToWidth"]) >= 0) { |
$docPageSetup->setFitToWidth(intval($xmlSheet->pageSetup["fitToWidth"]), FALSE); |
} |
if (isset($xmlSheet->pageSetup["firstPageNumber"]) && isset($xmlSheet->pageSetup["useFirstPageNumber"]) && |
self::boolean((string) $xmlSheet->pageSetup["useFirstPageNumber"])) { |
$docPageSetup->setFirstPageNumber(intval($xmlSheet->pageSetup["firstPageNumber"])); |
} |
} |
if ($xmlSheet && $xmlSheet->headerFooter && !$this->_readDataOnly) { |
$docHeaderFooter = $docSheet->getHeaderFooter(); |
if (isset($xmlSheet->headerFooter["differentOddEven"]) && |
self::boolean((string)$xmlSheet->headerFooter["differentOddEven"])) { |
$docHeaderFooter->setDifferentOddEven(TRUE); |
} else { |
$docHeaderFooter->setDifferentOddEven(FALSE); |
} |
if (isset($xmlSheet->headerFooter["differentFirst"]) && |
self::boolean((string)$xmlSheet->headerFooter["differentFirst"])) { |
$docHeaderFooter->setDifferentFirst(TRUE); |
} else { |
$docHeaderFooter->setDifferentFirst(FALSE); |
} |
if (isset($xmlSheet->headerFooter["scaleWithDoc"]) && |
!self::boolean((string)$xmlSheet->headerFooter["scaleWithDoc"])) { |
$docHeaderFooter->setScaleWithDocument(FALSE); |
} else { |
$docHeaderFooter->setScaleWithDocument(TRUE); |
} |
if (isset($xmlSheet->headerFooter["alignWithMargins"]) && |
!self::boolean((string)$xmlSheet->headerFooter["alignWithMargins"])) { |
$docHeaderFooter->setAlignWithMargins(FALSE); |
} else { |
$docHeaderFooter->setAlignWithMargins(TRUE); |
} |
$docHeaderFooter->setOddHeader((string) $xmlSheet->headerFooter->oddHeader); |
$docHeaderFooter->setOddFooter((string) $xmlSheet->headerFooter->oddFooter); |
$docHeaderFooter->setEvenHeader((string) $xmlSheet->headerFooter->evenHeader); |
$docHeaderFooter->setEvenFooter((string) $xmlSheet->headerFooter->evenFooter); |
$docHeaderFooter->setFirstHeader((string) $xmlSheet->headerFooter->firstHeader); |
$docHeaderFooter->setFirstFooter((string) $xmlSheet->headerFooter->firstFooter); |
} |
if ($xmlSheet && $xmlSheet->rowBreaks && $xmlSheet->rowBreaks->brk && !$this->_readDataOnly) { |
foreach ($xmlSheet->rowBreaks->brk as $brk) { |
if ($brk["man"]) { |
$docSheet->setBreak("A$brk[id]", PHPExcel_Worksheet::BREAK_ROW); |
} |
} |
} |
if ($xmlSheet && $xmlSheet->colBreaks && $xmlSheet->colBreaks->brk && !$this->_readDataOnly) { |
foreach ($xmlSheet->colBreaks->brk as $brk) { |
if ($brk["man"]) { |
$docSheet->setBreak(PHPExcel_Cell::stringFromColumnIndex((string) $brk["id"]) . "1", PHPExcel_Worksheet::BREAK_COLUMN); |
} |
} |
} |
if ($xmlSheet && $xmlSheet->dataValidations && !$this->_readDataOnly) { |
foreach ($xmlSheet->dataValidations->dataValidation as $dataValidation) { |
// Uppercase coordinate |
$range = strtoupper($dataValidation["sqref"]); |
$rangeSet = explode(' ',$range); |
foreach($rangeSet as $range) { |
$stRange = $docSheet->shrinkRangeToFit($range); |
// Extract all cell references in $range |
$aReferences = PHPExcel_Cell::extractAllCellReferencesInRange($stRange); |
foreach ($aReferences as $reference) { |
// Create validation |
$docValidation = $docSheet->getCell($reference)->getDataValidation(); |
$docValidation->setType((string) $dataValidation["type"]); |
$docValidation->setErrorStyle((string) $dataValidation["errorStyle"]); |
$docValidation->setOperator((string) $dataValidation["operator"]); |
$docValidation->setAllowBlank($dataValidation["allowBlank"] != 0); |
$docValidation->setShowDropDown($dataValidation["showDropDown"] == 0); |
$docValidation->setShowInputMessage($dataValidation["showInputMessage"] != 0); |
$docValidation->setShowErrorMessage($dataValidation["showErrorMessage"] != 0); |
$docValidation->setErrorTitle((string) $dataValidation["errorTitle"]); |
$docValidation->setError((string) $dataValidation["error"]); |
$docValidation->setPromptTitle((string) $dataValidation["promptTitle"]); |
$docValidation->setPrompt((string) $dataValidation["prompt"]); |
$docValidation->setFormula1((string) $dataValidation->formula1); |
$docValidation->setFormula2((string) $dataValidation->formula2); |
} |
} |
} |
} |
// Add hyperlinks |
$hyperlinks = array(); |
if (!$this->_readDataOnly) { |
// Locate hyperlink relations |
if ($zip->locateName(dirname("$dir/$fileWorksheet") . "/_rels/" . basename($fileWorksheet) . ".rels")) { |
$relsWorksheet = simplexml_load_string($this->_getFromZipArchive($zip, dirname("$dir/$fileWorksheet") . "/_rels/" . basename($fileWorksheet) . ".rels") ); //~ http://schemas.openxmlformats.org/package/2006/relationships"); |
foreach ($relsWorksheet->Relationship as $ele) { |
if ($ele["Type"] == "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink") { |
$hyperlinks[(string)$ele["Id"]] = (string)$ele["Target"]; |
} |
} |
} |
// Loop through hyperlinks |
if ($xmlSheet && $xmlSheet->hyperlinks) { |
foreach ($xmlSheet->hyperlinks->hyperlink as $hyperlink) { |
// Link url |
$linkRel = $hyperlink->attributes('http://schemas.openxmlformats.org/officeDocument/2006/relationships'); |
foreach (PHPExcel_Cell::extractAllCellReferencesInRange($hyperlink['ref']) as $cellReference) { |
$cell = $docSheet->getCell( $cellReference ); |
if (isset($linkRel['id'])) { |
$hyperlinkUrl = $hyperlinks[ (string)$linkRel['id'] ]; |
if (isset($hyperlink['location'])) { |
$hyperlinkUrl .= '#' . (string) $hyperlink['location']; |
} |
$cell->getHyperlink()->setUrl($hyperlinkUrl); |
} elseif (isset($hyperlink['location'])) { |
$cell->getHyperlink()->setUrl( 'sheet://' . (string)$hyperlink['location'] ); |
} |
// Tooltip |
if (isset($hyperlink['tooltip'])) { |
$cell->getHyperlink()->setTooltip( (string)$hyperlink['tooltip'] ); |
} |
} |
} |
} |
} |
// Add comments |
$comments = array(); |
$vmlComments = array(); |
if (!$this->_readDataOnly) { |
// Locate comment relations |
if ($zip->locateName(dirname("$dir/$fileWorksheet") . "/_rels/" . basename($fileWorksheet) . ".rels")) { |
$relsWorksheet = simplexml_load_string($this->_getFromZipArchive($zip, dirname("$dir/$fileWorksheet") . "/_rels/" . basename($fileWorksheet) . ".rels") ); //~ http://schemas.openxmlformats.org/package/2006/relationships"); |
foreach ($relsWorksheet->Relationship as $ele) { |
if ($ele["Type"] == "http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments") { |
$comments[(string)$ele["Id"]] = (string)$ele["Target"]; |
} |
if ($ele["Type"] == "http://schemas.openxmlformats.org/officeDocument/2006/relationships/vmlDrawing") { |
$vmlComments[(string)$ele["Id"]] = (string)$ele["Target"]; |
} |
} |
} |
// Loop through comments |
foreach ($comments as $relName => $relPath) { |
// Load comments file |
$relPath = PHPExcel_Shared_File::realpath(dirname("$dir/$fileWorksheet") . "/" . $relPath); |
$commentsFile = simplexml_load_string($this->_getFromZipArchive($zip, $relPath) ); |
// Utility variables |
$authors = array(); |
// Loop through authors |
foreach ($commentsFile->authors->author as $author) { |
$authors[] = (string)$author; |
} |
// Loop through contents |
foreach ($commentsFile->commentList->comment as $comment) { |
$docSheet->getComment( (string)$comment['ref'] )->setAuthor( $authors[(string)$comment['authorId']] ); |
$docSheet->getComment( (string)$comment['ref'] )->setText( $this->_parseRichText($comment->text) ); |
} |
} |
// Loop through VML comments |
foreach ($vmlComments as $relName => $relPath) { |
// Load VML comments file |
$relPath = PHPExcel_Shared_File::realpath(dirname("$dir/$fileWorksheet") . "/" . $relPath); |
$vmlCommentsFile = simplexml_load_string( $this->_getFromZipArchive($zip, $relPath) ); |
$vmlCommentsFile->registerXPathNamespace('v', 'urn:schemas-microsoft-com:vml'); |
$shapes = $vmlCommentsFile->xpath('//v:shape'); |
foreach ($shapes as $shape) { |
$shape->registerXPathNamespace('v', 'urn:schemas-microsoft-com:vml'); |
if (isset($shape['style'])) { |
$style = (string)$shape['style']; |
$fillColor = strtoupper( substr( (string)$shape['fillcolor'], 1 ) ); |
$column = null; |
$row = null; |
$clientData = $shape->xpath('.//x:ClientData'); |
if (is_array($clientData) && !empty($clientData)) { |
$clientData = $clientData[0]; |
if ( isset($clientData['ObjectType']) && (string)$clientData['ObjectType'] == 'Note' ) { |
$temp = $clientData->xpath('.//x:Row'); |
if (is_array($temp)) $row = $temp[0]; |
$temp = $clientData->xpath('.//x:Column'); |
if (is_array($temp)) $column = $temp[0]; |
} |
} |
if (($column !== NULL) && ($row !== NULL)) { |
// Set comment properties |
$comment = $docSheet->getCommentByColumnAndRow((string) $column, $row + 1); |
$comment->getFillColor()->setRGB( $fillColor ); |
// Parse style |
$styleArray = explode(';', str_replace(' ', '', $style)); |
foreach ($styleArray as $stylePair) { |
$stylePair = explode(':', $stylePair); |
if ($stylePair[0] == 'margin-left') $comment->setMarginLeft($stylePair[1]); |
if ($stylePair[0] == 'margin-top') $comment->setMarginTop($stylePair[1]); |
if ($stylePair[0] == 'width') $comment->setWidth($stylePair[1]); |
if ($stylePair[0] == 'height') $comment->setHeight($stylePair[1]); |
if ($stylePair[0] == 'visibility') $comment->setVisible( $stylePair[1] == 'visible' ); |
} |
} |
} |
} |
} |
// Header/footer images |
if ($xmlSheet && $xmlSheet->legacyDrawingHF && !$this->_readDataOnly) { |
if ($zip->locateName(dirname("$dir/$fileWorksheet") . "/_rels/" . basename($fileWorksheet) . ".rels")) { |
$relsWorksheet = simplexml_load_string($this->_getFromZipArchive($zip, dirname("$dir/$fileWorksheet") . "/_rels/" . basename($fileWorksheet) . ".rels") ); //~ http://schemas.openxmlformats.org/package/2006/relationships"); |
$vmlRelationship = ''; |
foreach ($relsWorksheet->Relationship as $ele) { |
if ($ele["Type"] == "http://schemas.openxmlformats.org/officeDocument/2006/relationships/vmlDrawing") { |
$vmlRelationship = self::dir_add("$dir/$fileWorksheet", $ele["Target"]); |
} |
} |
if ($vmlRelationship != '') { |
// Fetch linked images |
$relsVML = simplexml_load_string($this->_getFromZipArchive($zip, dirname($vmlRelationship) . '/_rels/' . basename($vmlRelationship) . '.rels' )); //~ http://schemas.openxmlformats.org/package/2006/relationships"); |
$drawings = array(); |
foreach ($relsVML->Relationship as $ele) { |
if ($ele["Type"] == "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image") { |
$drawings[(string) $ele["Id"]] = self::dir_add($vmlRelationship, $ele["Target"]); |
} |
} |
// Fetch VML document |
$vmlDrawing = simplexml_load_string($this->_getFromZipArchive($zip, $vmlRelationship)); |
$vmlDrawing->registerXPathNamespace('v', 'urn:schemas-microsoft-com:vml'); |
$hfImages = array(); |
$shapes = $vmlDrawing->xpath('//v:shape'); |
foreach ($shapes as $shape) { |
$shape->registerXPathNamespace('v', 'urn:schemas-microsoft-com:vml'); |
$imageData = $shape->xpath('//v:imagedata'); |
$imageData = $imageData[0]; |
$imageData = $imageData->attributes('urn:schemas-microsoft-com:office:office'); |
$style = self::toCSSArray( (string)$shape['style'] ); |
$hfImages[ (string)$shape['id'] ] = new PHPExcel_Worksheet_HeaderFooterDrawing(); |
if (isset($imageData['title'])) { |
$hfImages[ (string)$shape['id'] ]->setName( (string)$imageData['title'] ); |
} |
$hfImages[ (string)$shape['id'] ]->setPath("zip://".PHPExcel_Shared_File::realpath($pFilename)."#" . $drawings[(string)$imageData['relid']], false); |
$hfImages[ (string)$shape['id'] ]->setResizeProportional(false); |
$hfImages[ (string)$shape['id'] ]->setWidth($style['width']); |
$hfImages[ (string)$shape['id'] ]->setHeight($style['height']); |
$hfImages[ (string)$shape['id'] ]->setOffsetX($style['margin-left']); |
$hfImages[ (string)$shape['id'] ]->setOffsetY($style['margin-top']); |
$hfImages[ (string)$shape['id'] ]->setResizeProportional(true); |
} |
$docSheet->getHeaderFooter()->setImages($hfImages); |
} |
} |
} |
} |
// TODO: Autoshapes from twoCellAnchors! |
if ($zip->locateName(dirname("$dir/$fileWorksheet") . "/_rels/" . basename($fileWorksheet) . ".rels")) { |
$relsWorksheet = simplexml_load_string($this->_getFromZipArchive($zip, dirname("$dir/$fileWorksheet") . "/_rels/" . basename($fileWorksheet) . ".rels") ); //~ http://schemas.openxmlformats.org/package/2006/relationships"); |
$drawings = array(); |
foreach ($relsWorksheet->Relationship as $ele) { |
if ($ele["Type"] == "http://schemas.openxmlformats.org/officeDocument/2006/relationships/drawing") { |
$drawings[(string) $ele["Id"]] = self::dir_add("$dir/$fileWorksheet", $ele["Target"]); |
} |
} |
if ($xmlSheet->drawing && !$this->_readDataOnly) { |
foreach ($xmlSheet->drawing as $drawing) { |
$fileDrawing = $drawings[(string) self::array_item($drawing->attributes("http://schemas.openxmlformats.org/officeDocument/2006/relationships"), "id")]; |
$relsDrawing = simplexml_load_string($this->_getFromZipArchive($zip, dirname($fileDrawing) . "/_rels/" . basename($fileDrawing) . ".rels") ); //~ http://schemas.openxmlformats.org/package/2006/relationships"); |
$images = array(); |
if ($relsDrawing && $relsDrawing->Relationship) { |
foreach ($relsDrawing->Relationship as $ele) { |
if ($ele["Type"] == "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image") { |
$images[(string) $ele["Id"]] = self::dir_add($fileDrawing, $ele["Target"]); |
} elseif ($ele["Type"] == "http://schemas.openxmlformats.org/officeDocument/2006/relationships/chart") { |
if ($this->_includeCharts) { |
$charts[self::dir_add($fileDrawing, $ele["Target"])] = array('id' => (string) $ele["Id"], |
'sheet' => $docSheet->getTitle() |
); |
} |
} |
} |
} |
$xmlDrawing = simplexml_load_string($this->_getFromZipArchive($zip, $fileDrawing))->children("http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing"); |
if ($xmlDrawing->oneCellAnchor) { |
foreach ($xmlDrawing->oneCellAnchor as $oneCellAnchor) { |
if ($oneCellAnchor->pic->blipFill) { |
$blip = $oneCellAnchor->pic->blipFill->children("http://schemas.openxmlformats.org/drawingml/2006/main")->blip; |
$xfrm = $oneCellAnchor->pic->spPr->children("http://schemas.openxmlformats.org/drawingml/2006/main")->xfrm; |
$outerShdw = $oneCellAnchor->pic->spPr->children("http://schemas.openxmlformats.org/drawingml/2006/main")->effectLst->outerShdw; |
$objDrawing = new PHPExcel_Worksheet_Drawing; |
$objDrawing->setName((string) self::array_item($oneCellAnchor->pic->nvPicPr->cNvPr->attributes(), "name")); |
$objDrawing->setDescription((string) self::array_item($oneCellAnchor->pic->nvPicPr->cNvPr->attributes(), "descr")); |
$objDrawing->setPath("zip://".PHPExcel_Shared_File::realpath($pFilename)."#" . $images[(string) self::array_item($blip->attributes("http://schemas.openxmlformats.org/officeDocument/2006/relationships"), "embed")], false); |
$objDrawing->setCoordinates(PHPExcel_Cell::stringFromColumnIndex((string) $oneCellAnchor->from->col) . ($oneCellAnchor->from->row + 1)); |
$objDrawing->setOffsetX(PHPExcel_Shared_Drawing::EMUToPixels($oneCellAnchor->from->colOff)); |
$objDrawing->setOffsetY(PHPExcel_Shared_Drawing::EMUToPixels($oneCellAnchor->from->rowOff)); |
$objDrawing->setResizeProportional(false); |
$objDrawing->setWidth(PHPExcel_Shared_Drawing::EMUToPixels(self::array_item($oneCellAnchor->ext->attributes(), "cx"))); |
$objDrawing->setHeight(PHPExcel_Shared_Drawing::EMUToPixels(self::array_item($oneCellAnchor->ext->attributes(), "cy"))); |
if ($xfrm) { |
$objDrawing->setRotation(PHPExcel_Shared_Drawing::angleToDegrees(self::array_item($xfrm->attributes(), "rot"))); |
} |
if ($outerShdw) { |
$shadow = $objDrawing->getShadow(); |
$shadow->setVisible(true); |
$shadow->setBlurRadius(PHPExcel_Shared_Drawing::EMUTopixels(self::array_item($outerShdw->attributes(), "blurRad"))); |
$shadow->setDistance(PHPExcel_Shared_Drawing::EMUTopixels(self::array_item($outerShdw->attributes(), "dist"))); |
$shadow->setDirection(PHPExcel_Shared_Drawing::angleToDegrees(self::array_item($outerShdw->attributes(), "dir"))); |
$shadow->setAlignment((string) self::array_item($outerShdw->attributes(), "algn")); |
$shadow->getColor()->setRGB(self::array_item($outerShdw->srgbClr->attributes(), "val")); |
$shadow->setAlpha(self::array_item($outerShdw->srgbClr->alpha->attributes(), "val") / 1000); |
} |
$objDrawing->setWorksheet($docSheet); |
} else { |
// ? Can charts be positioned with a oneCellAnchor ? |
$coordinates = PHPExcel_Cell::stringFromColumnIndex((string) $oneCellAnchor->from->col) . ($oneCellAnchor->from->row + 1); |
$offsetX = PHPExcel_Shared_Drawing::EMUToPixels($oneCellAnchor->from->colOff); |
$offsetY = PHPExcel_Shared_Drawing::EMUToPixels($oneCellAnchor->from->rowOff); |
$width = PHPExcel_Shared_Drawing::EMUToPixels(self::array_item($oneCellAnchor->ext->attributes(), "cx")); |
$height = PHPExcel_Shared_Drawing::EMUToPixels(self::array_item($oneCellAnchor->ext->attributes(), "cy")); |
} |
} |
} |
if ($xmlDrawing->twoCellAnchor) { |
foreach ($xmlDrawing->twoCellAnchor as $twoCellAnchor) { |
if ($twoCellAnchor->pic->blipFill) { |
$blip = $twoCellAnchor->pic->blipFill->children("http://schemas.openxmlformats.org/drawingml/2006/main")->blip; |
$xfrm = $twoCellAnchor->pic->spPr->children("http://schemas.openxmlformats.org/drawingml/2006/main")->xfrm; |
$outerShdw = $twoCellAnchor->pic->spPr->children("http://schemas.openxmlformats.org/drawingml/2006/main")->effectLst->outerShdw; |
$objDrawing = new PHPExcel_Worksheet_Drawing; |
$objDrawing->setName((string) self::array_item($twoCellAnchor->pic->nvPicPr->cNvPr->attributes(), "name")); |
$objDrawing->setDescription((string) self::array_item($twoCellAnchor->pic->nvPicPr->cNvPr->attributes(), "descr")); |
$objDrawing->setPath("zip://".PHPExcel_Shared_File::realpath($pFilename)."#" . $images[(string) self::array_item($blip->attributes("http://schemas.openxmlformats.org/officeDocument/2006/relationships"), "embed")], false); |
$objDrawing->setCoordinates(PHPExcel_Cell::stringFromColumnIndex((string) $twoCellAnchor->from->col) . ($twoCellAnchor->from->row + 1)); |
$objDrawing->setOffsetX(PHPExcel_Shared_Drawing::EMUToPixels($twoCellAnchor->from->colOff)); |
$objDrawing->setOffsetY(PHPExcel_Shared_Drawing::EMUToPixels($twoCellAnchor->from->rowOff)); |
$objDrawing->setResizeProportional(false); |
$objDrawing->setWidth(PHPExcel_Shared_Drawing::EMUToPixels(self::array_item($xfrm->ext->attributes(), "cx"))); |
$objDrawing->setHeight(PHPExcel_Shared_Drawing::EMUToPixels(self::array_item($xfrm->ext->attributes(), "cy"))); |
if ($xfrm) { |
$objDrawing->setRotation(PHPExcel_Shared_Drawing::angleToDegrees(self::array_item($xfrm->attributes(), "rot"))); |
} |
if ($outerShdw) { |
$shadow = $objDrawing->getShadow(); |
$shadow->setVisible(true); |
$shadow->setBlurRadius(PHPExcel_Shared_Drawing::EMUTopixels(self::array_item($outerShdw->attributes(), "blurRad"))); |
$shadow->setDistance(PHPExcel_Shared_Drawing::EMUTopixels(self::array_item($outerShdw->attributes(), "dist"))); |
$shadow->setDirection(PHPExcel_Shared_Drawing::angleToDegrees(self::array_item($outerShdw->attributes(), "dir"))); |
$shadow->setAlignment((string) self::array_item($outerShdw->attributes(), "algn")); |
$shadow->getColor()->setRGB(self::array_item($outerShdw->srgbClr->attributes(), "val")); |
$shadow->setAlpha(self::array_item($outerShdw->srgbClr->alpha->attributes(), "val") / 1000); |
} |
$objDrawing->setWorksheet($docSheet); |
} elseif(($this->_includeCharts) && ($twoCellAnchor->graphicFrame)) { |
$fromCoordinate = PHPExcel_Cell::stringFromColumnIndex((string) $twoCellAnchor->from->col) . ($twoCellAnchor->from->row + 1); |
$fromOffsetX = PHPExcel_Shared_Drawing::EMUToPixels($twoCellAnchor->from->colOff); |
$fromOffsetY = PHPExcel_Shared_Drawing::EMUToPixels($twoCellAnchor->from->rowOff); |
$toCoordinate = PHPExcel_Cell::stringFromColumnIndex((string) $twoCellAnchor->to->col) . ($twoCellAnchor->to->row + 1); |
$toOffsetX = PHPExcel_Shared_Drawing::EMUToPixels($twoCellAnchor->to->colOff); |
$toOffsetY = PHPExcel_Shared_Drawing::EMUToPixels($twoCellAnchor->to->rowOff); |
$graphic = $twoCellAnchor->graphicFrame->children("http://schemas.openxmlformats.org/drawingml/2006/main")->graphic; |
$chartRef = $graphic->graphicData->children("http://schemas.openxmlformats.org/drawingml/2006/chart")->chart; |
$thisChart = (string) $chartRef->attributes("http://schemas.openxmlformats.org/officeDocument/2006/relationships"); |
$chartDetails[$docSheet->getTitle().'!'.$thisChart] = |
array( 'fromCoordinate' => $fromCoordinate, |
'fromOffsetX' => $fromOffsetX, |
'fromOffsetY' => $fromOffsetY, |
'toCoordinate' => $toCoordinate, |
'toOffsetX' => $toOffsetX, |
'toOffsetY' => $toOffsetY, |
'worksheetTitle' => $docSheet->getTitle() |
); |
} |
} |
} |
} |
} |
} |
// Loop through definedNames |
if ($xmlWorkbook->definedNames) { |
foreach ($xmlWorkbook->definedNames->definedName as $definedName) { |
// Extract range |
$extractedRange = (string)$definedName; |
$extractedRange = preg_replace('/\'(\w+)\'\!/', '', $extractedRange); |
if (($spos = strpos($extractedRange,'!')) !== false) { |
$extractedRange = substr($extractedRange,0,$spos).str_replace('$', '', substr($extractedRange,$spos)); |
} else { |
$extractedRange = str_replace('$', '', $extractedRange); |
} |
// Valid range? |
if (stripos((string)$definedName, '#REF!') !== FALSE || $extractedRange == '') { |
continue; |
} |
// Some definedNames are only applicable if we are on the same sheet... |
if ((string)$definedName['localSheetId'] != '' && (string)$definedName['localSheetId'] == $sheetId) { |
// Switch on type |
switch ((string)$definedName['name']) { |
case '_xlnm._FilterDatabase': |
if ((string)$definedName['hidden'] !== '1') { |
$docSheet->getAutoFilter()->setRange($extractedRange); |
} |
break; |
case '_xlnm.Print_Titles': |
// Split $extractedRange |
$extractedRange = explode(',', $extractedRange); |
// Set print titles |
foreach ($extractedRange as $range) { |
$matches = array(); |
$range = str_replace('$', '', $range); |
// check for repeating columns, e g. 'A:A' or 'A:D' |
if (preg_match('/!?([A-Z]+)\:([A-Z]+)$/', $range, $matches)) { |
$docSheet->getPageSetup()->setColumnsToRepeatAtLeft(array($matches[1], $matches[2])); |
} |
// check for repeating rows, e.g. '1:1' or '1:5' |
elseif (preg_match('/!?(\d+)\:(\d+)$/', $range, $matches)) { |
$docSheet->getPageSetup()->setRowsToRepeatAtTop(array($matches[1], $matches[2])); |
} |
} |
break; |
case '_xlnm.Print_Area': |
$rangeSets = explode(',', $extractedRange); // FIXME: what if sheetname contains comma? |
$newRangeSets = array(); |
foreach($rangeSets as $rangeSet) { |
$range = explode('!', $rangeSet); // FIXME: what if sheetname contains exclamation mark? |
$rangeSet = isset($range[1]) ? $range[1] : $range[0]; |
if (strpos($rangeSet, ':') === FALSE) { |
$rangeSet = $rangeSet . ':' . $rangeSet; |
} |
$newRangeSets[] = str_replace('$', '', $rangeSet); |
} |
$docSheet->getPageSetup()->setPrintArea(implode(',',$newRangeSets)); |
break; |
default: |
break; |
} |
} |
} |
} |
// Next sheet id |
++$sheetId; |
} |
// Loop through definedNames |
if ($xmlWorkbook->definedNames) { |
foreach ($xmlWorkbook->definedNames->definedName as $definedName) { |
// Extract range |
$extractedRange = (string)$definedName; |
$extractedRange = preg_replace('/\'(\w+)\'\!/', '', $extractedRange); |
if (($spos = strpos($extractedRange,'!')) !== false) { |
$extractedRange = substr($extractedRange,0,$spos).str_replace('$', '', substr($extractedRange,$spos)); |
} else { |
$extractedRange = str_replace('$', '', $extractedRange); |
} |
// Valid range? |
if (stripos((string)$definedName, '#REF!') !== false || $extractedRange == '') { |
continue; |
} |
// Some definedNames are only applicable if we are on the same sheet... |
if ((string)$definedName['localSheetId'] != '') { |
// Local defined name |
// Switch on type |
switch ((string)$definedName['name']) { |
case '_xlnm._FilterDatabase': |
case '_xlnm.Print_Titles': |
case '_xlnm.Print_Area': |
break; |
default: |
if ($mapSheetId[(integer) $definedName['localSheetId']] !== null) { |
$range = explode('!', (string)$definedName); |
if (count($range) == 2) { |
$range[0] = str_replace("''", "'", $range[0]); |
$range[0] = str_replace("'", "", $range[0]); |
if ($worksheet = $docSheet->getParent()->getSheetByName($range[0])) { |
$extractedRange = str_replace('$', '', $range[1]); |
$scope = $docSheet->getParent()->getSheet($mapSheetId[(integer) $definedName['localSheetId']]); |
$excel->addNamedRange( new PHPExcel_NamedRange((string)$definedName['name'], $worksheet, $extractedRange, true, $scope) ); |
} |
} |
} |
break; |
} |
} else if (!isset($definedName['localSheetId'])) { |
// "Global" definedNames |
$locatedSheet = null; |
$extractedSheetName = ''; |
if (strpos( (string)$definedName, '!' ) !== false) { |
// Extract sheet name |
$extractedSheetName = PHPExcel_Worksheet::extractSheetTitle( (string)$definedName, true ); |
$extractedSheetName = $extractedSheetName[0]; |
// Locate sheet |
$locatedSheet = $excel->getSheetByName($extractedSheetName); |
// Modify range |
$range = explode('!', $extractedRange); |
$extractedRange = isset($range[1]) ? $range[1] : $range[0]; |
} |
if ($locatedSheet !== NULL) { |
$excel->addNamedRange( new PHPExcel_NamedRange((string)$definedName['name'], $locatedSheet, $extractedRange, false) ); |
} |
} |
} |
} |
} |
if ((!$this->_readDataOnly) || (!empty($this->_loadSheetsOnly))) { |
// active sheet index |
$activeTab = intval($xmlWorkbook->bookViews->workbookView["activeTab"]); // refers to old sheet index |
// keep active sheet index if sheet is still loaded, else first sheet is set as the active |
if (isset($mapSheetId[$activeTab]) && $mapSheetId[$activeTab] !== null) { |
$excel->setActiveSheetIndex($mapSheetId[$activeTab]); |
} else { |
if ($excel->getSheetCount() == 0) { |
$excel->createSheet(); |
} |
$excel->setActiveSheetIndex(0); |
} |
} |
break; |
} |
} |
if (!$this->_readDataOnly) { |
$contentTypes = simplexml_load_string($this->_getFromZipArchive($zip, "[Content_Types].xml")); |
foreach ($contentTypes->Override as $contentType) { |
switch ($contentType["ContentType"]) { |
case "application/vnd.openxmlformats-officedocument.drawingml.chart+xml": |
if ($this->_includeCharts) { |
$chartEntryRef = ltrim($contentType['PartName'],'/'); |
$chartElements = simplexml_load_string($this->_getFromZipArchive($zip, $chartEntryRef)); |
$objChart = PHPExcel_Reader_Excel2007_Chart::readChart($chartElements,basename($chartEntryRef,'.xml')); |
// echo 'Chart ',$chartEntryRef,'<br />'; |
// var_dump($charts[$chartEntryRef]); |
// |
if (isset($charts[$chartEntryRef])) { |
$chartPositionRef = $charts[$chartEntryRef]['sheet'].'!'.$charts[$chartEntryRef]['id']; |
// echo 'Position Ref ',$chartPositionRef,'<br />'; |
if (isset($chartDetails[$chartPositionRef])) { |
// var_dump($chartDetails[$chartPositionRef]); |
$excel->getSheetByName($charts[$chartEntryRef]['sheet'])->addChart($objChart); |
$objChart->setWorksheet($excel->getSheetByName($charts[$chartEntryRef]['sheet'])); |
$objChart->setTopLeftPosition( $chartDetails[$chartPositionRef]['fromCoordinate'], |
$chartDetails[$chartPositionRef]['fromOffsetX'], |
$chartDetails[$chartPositionRef]['fromOffsetY'] |
); |
$objChart->setBottomRightPosition( $chartDetails[$chartPositionRef]['toCoordinate'], |
$chartDetails[$chartPositionRef]['toOffsetX'], |
$chartDetails[$chartPositionRef]['toOffsetY'] |
); |
} |
} |
} |
} |
} |
} |
$zip->close(); |
return $excel; |
} |
private static function _readColor($color, $background=FALSE) { |
if (isset($color["rgb"])) { |
return (string)$color["rgb"]; |
} else if (isset($color["indexed"])) { |
return PHPExcel_Style_Color::indexedColor($color["indexed"]-7,$background)->getARGB(); |
} else if (isset($color["theme"])) { |
if (self::$_theme !== NULL) { |
$returnColour = self::$_theme->getColourByIndex((int)$color["theme"]); |
if (isset($color["tint"])) { |
$tintAdjust = (float) $color["tint"]; |
$returnColour = PHPExcel_Style_Color::changeBrightness($returnColour, $tintAdjust); |
} |
return 'FF'.$returnColour; |
} |
} |
if ($background) { |
return 'FFFFFFFF'; |
} |
return 'FF000000'; |
} |
private static function _readStyle($docStyle, $style) { |
// format code |
// if (isset($style->numFmt)) { |
// if (isset($style->numFmt['formatCode'])) { |
// $docStyle->getNumberFormat()->setFormatCode((string) $style->numFmt['formatCode']); |
// } else { |
$docStyle->getNumberFormat()->setFormatCode($style->numFmt); |
// } |
// } |
// font |
if (isset($style->font)) { |
$docStyle->getFont()->setName((string) $style->font->name["val"]); |
$docStyle->getFont()->setSize((string) $style->font->sz["val"]); |
if (isset($style->font->b)) { |
$docStyle->getFont()->setBold(!isset($style->font->b["val"]) || self::boolean((string) $style->font->b["val"])); |
} |
if (isset($style->font->i)) { |
$docStyle->getFont()->setItalic(!isset($style->font->i["val"]) || self::boolean((string) $style->font->i["val"])); |
} |
if (isset($style->font->strike)) { |
$docStyle->getFont()->setStrikethrough(!isset($style->font->strike["val"]) || self::boolean((string) $style->font->strike["val"])); |
} |
$docStyle->getFont()->getColor()->setARGB(self::_readColor($style->font->color)); |
if (isset($style->font->u) && !isset($style->font->u["val"])) { |
$docStyle->getFont()->setUnderline(PHPExcel_Style_Font::UNDERLINE_SINGLE); |
} else if (isset($style->font->u) && isset($style->font->u["val"])) { |
$docStyle->getFont()->setUnderline((string)$style->font->u["val"]); |
} |
if (isset($style->font->vertAlign) && isset($style->font->vertAlign["val"])) { |
$vertAlign = strtolower((string)$style->font->vertAlign["val"]); |
if ($vertAlign == 'superscript') { |
$docStyle->getFont()->setSuperScript(true); |
} |
if ($vertAlign == 'subscript') { |
$docStyle->getFont()->setSubScript(true); |
} |
} |
} |
// fill |
if (isset($style->fill)) { |
if ($style->fill->gradientFill) { |
$gradientFill = $style->fill->gradientFill[0]; |
if(!empty($gradientFill["type"])) { |
$docStyle->getFill()->setFillType((string) $gradientFill["type"]); |
} |
$docStyle->getFill()->setRotation(floatval($gradientFill["degree"])); |
$gradientFill->registerXPathNamespace("sml", "http://schemas.openxmlformats.org/spreadsheetml/2006/main"); |
$docStyle->getFill()->getStartColor()->setARGB(self::_readColor( self::array_item($gradientFill->xpath("sml:stop[@position=0]"))->color) ); |
$docStyle->getFill()->getEndColor()->setARGB(self::_readColor( self::array_item($gradientFill->xpath("sml:stop[@position=1]"))->color) ); |
} elseif ($style->fill->patternFill) { |
$patternType = (string)$style->fill->patternFill["patternType"] != '' ? (string)$style->fill->patternFill["patternType"] : 'solid'; |
$docStyle->getFill()->setFillType($patternType); |
if ($style->fill->patternFill->fgColor) { |
$docStyle->getFill()->getStartColor()->setARGB(self::_readColor($style->fill->patternFill->fgColor,true)); |
} else { |
$docStyle->getFill()->getStartColor()->setARGB('FF000000'); |
} |
if ($style->fill->patternFill->bgColor) { |
$docStyle->getFill()->getEndColor()->setARGB(self::_readColor($style->fill->patternFill->bgColor,true)); |
} |
} |
} |
// border |
if (isset($style->border)) { |
$diagonalUp = self::boolean((string) $style->border["diagonalUp"]); |
$diagonalDown = self::boolean((string) $style->border["diagonalDown"]); |
if (!$diagonalUp && !$diagonalDown) { |
$docStyle->getBorders()->setDiagonalDirection(PHPExcel_Style_Borders::DIAGONAL_NONE); |
} elseif ($diagonalUp && !$diagonalDown) { |
$docStyle->getBorders()->setDiagonalDirection(PHPExcel_Style_Borders::DIAGONAL_UP); |
} elseif (!$diagonalUp && $diagonalDown) { |
$docStyle->getBorders()->setDiagonalDirection(PHPExcel_Style_Borders::DIAGONAL_DOWN); |
} else { |
$docStyle->getBorders()->setDiagonalDirection(PHPExcel_Style_Borders::DIAGONAL_BOTH); |
} |
self::_readBorder($docStyle->getBorders()->getLeft(), $style->border->left); |
self::_readBorder($docStyle->getBorders()->getRight(), $style->border->right); |
self::_readBorder($docStyle->getBorders()->getTop(), $style->border->top); |
self::_readBorder($docStyle->getBorders()->getBottom(), $style->border->bottom); |
self::_readBorder($docStyle->getBorders()->getDiagonal(), $style->border->diagonal); |
} |
// alignment |
if (isset($style->alignment)) { |
$docStyle->getAlignment()->setHorizontal((string) $style->alignment["horizontal"]); |
$docStyle->getAlignment()->setVertical((string) $style->alignment["vertical"]); |
$textRotation = 0; |
if ((int)$style->alignment["textRotation"] <= 90) { |
$textRotation = (int)$style->alignment["textRotation"]; |
} else if ((int)$style->alignment["textRotation"] > 90) { |
$textRotation = 90 - (int)$style->alignment["textRotation"]; |
} |
$docStyle->getAlignment()->setTextRotation(intval($textRotation)); |
$docStyle->getAlignment()->setWrapText(self::boolean((string) $style->alignment["wrapText"])); |
$docStyle->getAlignment()->setShrinkToFit(self::boolean((string) $style->alignment["shrinkToFit"])); |
$docStyle->getAlignment()->setIndent( intval((string)$style->alignment["indent"]) > 0 ? intval((string)$style->alignment["indent"]) : 0 ); |
} |
// protection |
if (isset($style->protection)) { |
if (isset($style->protection['locked'])) { |
if (self::boolean((string) $style->protection['locked'])) { |
$docStyle->getProtection()->setLocked(PHPExcel_Style_Protection::PROTECTION_PROTECTED); |
} else { |
$docStyle->getProtection()->setLocked(PHPExcel_Style_Protection::PROTECTION_UNPROTECTED); |
} |
} |
if (isset($style->protection['hidden'])) { |
if (self::boolean((string) $style->protection['hidden'])) { |
$docStyle->getProtection()->setHidden(PHPExcel_Style_Protection::PROTECTION_PROTECTED); |
} else { |
$docStyle->getProtection()->setHidden(PHPExcel_Style_Protection::PROTECTION_UNPROTECTED); |
} |
} |
} |
} |
private static function _readBorder($docBorder, $eleBorder) { |
if (isset($eleBorder["style"])) { |
$docBorder->setBorderStyle((string) $eleBorder["style"]); |
} |
if (isset($eleBorder->color)) { |
$docBorder->getColor()->setARGB(self::_readColor($eleBorder->color)); |
} |
} |
private function _parseRichText($is = null) { |
$value = new PHPExcel_RichText(); |
if (isset($is->t)) { |
$value->createText( PHPExcel_Shared_String::ControlCharacterOOXML2PHP( (string) $is->t ) ); |
} else { |
foreach ($is->r as $run) { |
if (!isset($run->rPr)) { |
$objText = $value->createText( PHPExcel_Shared_String::ControlCharacterOOXML2PHP( (string) $run->t ) ); |
} else { |
$objText = $value->createTextRun( PHPExcel_Shared_String::ControlCharacterOOXML2PHP( (string) $run->t ) ); |
if (isset($run->rPr->rFont["val"])) { |
$objText->getFont()->setName((string) $run->rPr->rFont["val"]); |
} |
if (isset($run->rPr->sz["val"])) { |
$objText->getFont()->setSize((string) $run->rPr->sz["val"]); |
} |
if (isset($run->rPr->color)) { |
$objText->getFont()->setColor( new PHPExcel_Style_Color( self::_readColor($run->rPr->color) ) ); |
} |
if ((isset($run->rPr->b["val"]) && self::boolean((string) $run->rPr->b["val"])) || |
(isset($run->rPr->b) && !isset($run->rPr->b["val"]))) { |
$objText->getFont()->setBold(TRUE); |
} |
if ((isset($run->rPr->i["val"]) && self::boolean((string) $run->rPr->i["val"])) || |
(isset($run->rPr->i) && !isset($run->rPr->i["val"]))) { |
$objText->getFont()->setItalic(TRUE); |
} |
if (isset($run->rPr->vertAlign) && isset($run->rPr->vertAlign["val"])) { |
$vertAlign = strtolower((string)$run->rPr->vertAlign["val"]); |
if ($vertAlign == 'superscript') { |
$objText->getFont()->setSuperScript(TRUE); |
} |
if ($vertAlign == 'subscript') { |
$objText->getFont()->setSubScript(TRUE); |
} |
} |
if (isset($run->rPr->u) && !isset($run->rPr->u["val"])) { |
$objText->getFont()->setUnderline(PHPExcel_Style_Font::UNDERLINE_SINGLE); |
} else if (isset($run->rPr->u) && isset($run->rPr->u["val"])) { |
$objText->getFont()->setUnderline((string)$run->rPr->u["val"]); |
} |
if ((isset($run->rPr->strike["val"]) && self::boolean((string) $run->rPr->strike["val"])) || |
(isset($run->rPr->strike) && !isset($run->rPr->strike["val"]))) { |
$objText->getFont()->setStrikethrough(TRUE); |
} |
} |
} |
} |
return $value; |
} |
private static function array_item($array, $key = 0) { |
return (isset($array[$key]) ? $array[$key] : null); |
} |
private static function dir_add($base, $add) { |
return preg_replace('~[^/]+/\.\./~', '', dirname($base) . "/$add"); |
} |
private static function toCSSArray($style) { |
$style = str_replace(array("\r","\n"), "", $style); |
$temp = explode(';', $style); |
$style = array(); |
foreach ($temp as $item) { |
$item = explode(':', $item); |
if (strpos($item[1], 'px') !== false) { |
$item[1] = str_replace('px', '', $item[1]); |
} |
if (strpos($item[1], 'pt') !== false) { |
$item[1] = str_replace('pt', '', $item[1]); |
$item[1] = PHPExcel_Shared_Font::fontSizeToPixels($item[1]); |
} |
if (strpos($item[1], 'in') !== false) { |
$item[1] = str_replace('in', '', $item[1]); |
$item[1] = PHPExcel_Shared_Font::inchSizeToPixels($item[1]); |
} |
if (strpos($item[1], 'cm') !== false) { |
$item[1] = str_replace('cm', '', $item[1]); |
$item[1] = PHPExcel_Shared_Font::centimeterSizeToPixels($item[1]); |
} |
$style[$item[0]] = $item[1]; |
} |
return $style; |
} |
private static function boolean($value = NULL) |
{ |
if (is_numeric($value)) { |
return (bool) $value; |
} |
return ($value === 'true' || $value === 'TRUE') ? TRUE : FALSE; |
} |
} |
/branches/v2.6-greffoir/jrest/lib/PHPExcel/Classes/PHPExcel/Reader/Gnumeric.php |
---|
New file |
0,0 → 1,873 |
<?php |
/** |
* PHPExcel |
* |
* Copyright (c) 2006 - 2013 PHPExcel |
* |
* This library is free software; you can redistribute it and/or |
* modify it under the terms of the GNU Lesser General Public |
* License as published by the Free Software Foundation; either |
* version 2.1 of the License, or (at your option) any later version. |
* |
* This library is distributed in the hope that it will be useful, |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
* Lesser General Public License for more details. |
* |
* You should have received a copy of the GNU Lesser General Public |
* License along with this library; if not, write to the Free Software |
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
* |
* @category PHPExcel |
* @package PHPExcel_Reader |
* @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL |
* @version ##VERSION##, ##DATE## |
*/ |
/** PHPExcel root directory */ |
if (!defined('PHPEXCEL_ROOT')) { |
/** |
* @ignore |
*/ |
define('PHPEXCEL_ROOT', dirname(__FILE__) . '/../../'); |
require(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php'); |
} |
/** |
* PHPExcel_Reader_Gnumeric |
* |
* @category PHPExcel |
* @package PHPExcel_Reader |
* @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
*/ |
class PHPExcel_Reader_Gnumeric extends PHPExcel_Reader_Abstract implements PHPExcel_Reader_IReader |
{ |
/** |
* Formats |
* |
* @var array |
*/ |
private $_styles = array(); |
/** |
* Shared Expressions |
* |
* @var array |
*/ |
private $_expressions = array(); |
private $_referenceHelper = null; |
/** |
* Create a new PHPExcel_Reader_Gnumeric |
*/ |
public function __construct() { |
$this->_readFilter = new PHPExcel_Reader_DefaultReadFilter(); |
$this->_referenceHelper = PHPExcel_ReferenceHelper::getInstance(); |
} |
/** |
* Can the current PHPExcel_Reader_IReader read the file? |
* |
* @param string $pFilename |
* @return boolean |
* @throws PHPExcel_Reader_Exception |
*/ |
public function canRead($pFilename) |
{ |
// Check if file exists |
if (!file_exists($pFilename)) { |
throw new PHPExcel_Reader_Exception("Could not open " . $pFilename . " for reading! File does not exist."); |
} |
// Check if gzlib functions are available |
if (!function_exists('gzread')) { |
throw new PHPExcel_Reader_Exception("gzlib library is not enabled"); |
} |
// Read signature data (first 3 bytes) |
$fh = fopen($pFilename, 'r'); |
$data = fread($fh, 2); |
fclose($fh); |
if ($data != chr(0x1F).chr(0x8B)) { |
return false; |
} |
return true; |
} |
/** |
* Reads names of the worksheets from a file, without parsing the whole file to a PHPExcel object |
* |
* @param string $pFilename |
* @throws PHPExcel_Reader_Exception |
*/ |
public function listWorksheetNames($pFilename) |
{ |
// Check if file exists |
if (!file_exists($pFilename)) { |
throw new PHPExcel_Reader_Exception("Could not open " . $pFilename . " for reading! File does not exist."); |
} |
$xml = new XMLReader(); |
$xml->open( |
'compress.zlib://'.realpath($pFilename) |
); |
$xml->setParserProperty(2,true); |
$worksheetNames = array(); |
while ($xml->read()) { |
if ($xml->name == 'gnm:SheetName' && $xml->nodeType == XMLReader::ELEMENT) { |
$xml->read(); // Move onto the value node |
$worksheetNames[] = (string) $xml->value; |
} elseif ($xml->name == 'gnm:Sheets') { |
// break out of the loop once we've got our sheet names rather than parse the entire file |
break; |
} |
} |
return $worksheetNames; |
} |
/** |
* Return worksheet info (Name, Last Column Letter, Last Column Index, Total Rows, Total Columns) |
* |
* @param string $pFilename |
* @throws PHPExcel_Reader_Exception |
*/ |
public function listWorksheetInfo($pFilename) |
{ |
// Check if file exists |
if (!file_exists($pFilename)) { |
throw new PHPExcel_Reader_Exception("Could not open " . $pFilename . " for reading! File does not exist."); |
} |
$xml = new XMLReader(); |
$xml->open( |
'compress.zlib://'.realpath($pFilename) |
); |
$xml->setParserProperty(2,true); |
$worksheetInfo = array(); |
while ($xml->read()) { |
if ($xml->name == 'gnm:Sheet' && $xml->nodeType == XMLReader::ELEMENT) { |
$tmpInfo = array( |
'worksheetName' => '', |
'lastColumnLetter' => 'A', |
'lastColumnIndex' => 0, |
'totalRows' => 0, |
'totalColumns' => 0, |
); |
while ($xml->read()) { |
if ($xml->name == 'gnm:Name' && $xml->nodeType == XMLReader::ELEMENT) { |
$xml->read(); // Move onto the value node |
$tmpInfo['worksheetName'] = (string) $xml->value; |
} elseif ($xml->name == 'gnm:MaxCol' && $xml->nodeType == XMLReader::ELEMENT) { |
$xml->read(); // Move onto the value node |
$tmpInfo['lastColumnIndex'] = (int) $xml->value; |
$tmpInfo['totalColumns'] = (int) $xml->value + 1; |
} elseif ($xml->name == 'gnm:MaxRow' && $xml->nodeType == XMLReader::ELEMENT) { |
$xml->read(); // Move onto the value node |
$tmpInfo['totalRows'] = (int) $xml->value + 1; |
break; |
} |
} |
$tmpInfo['lastColumnLetter'] = PHPExcel_Cell::stringFromColumnIndex($tmpInfo['lastColumnIndex']); |
$worksheetInfo[] = $tmpInfo; |
} |
} |
return $worksheetInfo; |
} |
private function _gzfileGetContents($filename) { |
$file = @gzopen($filename, 'rb'); |
if ($file !== false) { |
$data = ''; |
while (!gzeof($file)) { |
$data .= gzread($file, 1024); |
} |
gzclose($file); |
} |
return $data; |
} |
/** |
* Loads PHPExcel from file |
* |
* @param string $pFilename |
* @return PHPExcel |
* @throws PHPExcel_Reader_Exception |
*/ |
public function load($pFilename) |
{ |
// Create new PHPExcel |
$objPHPExcel = new PHPExcel(); |
// Load into this instance |
return $this->loadIntoExisting($pFilename, $objPHPExcel); |
} |
/** |
* Loads PHPExcel from file into PHPExcel instance |
* |
* @param string $pFilename |
* @param PHPExcel $objPHPExcel |
* @return PHPExcel |
* @throws PHPExcel_Reader_Exception |
*/ |
public function loadIntoExisting($pFilename, PHPExcel $objPHPExcel) |
{ |
// Check if file exists |
if (!file_exists($pFilename)) { |
throw new PHPExcel_Reader_Exception("Could not open " . $pFilename . " for reading! File does not exist."); |
} |
$timezoneObj = new DateTimeZone('Europe/London'); |
$GMT = new DateTimeZone('UTC'); |
$gFileData = $this->_gzfileGetContents($pFilename); |
// echo '<pre>'; |
// echo htmlentities($gFileData,ENT_QUOTES,'UTF-8'); |
// echo '</pre><hr />'; |
// |
$xml = simplexml_load_string($gFileData); |
$namespacesMeta = $xml->getNamespaces(true); |
// var_dump($namespacesMeta); |
// |
$gnmXML = $xml->children($namespacesMeta['gnm']); |
$docProps = $objPHPExcel->getProperties(); |
// Document Properties are held differently, depending on the version of Gnumeric |
if (isset($namespacesMeta['office'])) { |
$officeXML = $xml->children($namespacesMeta['office']); |
$officeDocXML = $officeXML->{'document-meta'}; |
$officeDocMetaXML = $officeDocXML->meta; |
foreach($officeDocMetaXML as $officePropertyData) { |
$officePropertyDC = array(); |
if (isset($namespacesMeta['dc'])) { |
$officePropertyDC = $officePropertyData->children($namespacesMeta['dc']); |
} |
foreach($officePropertyDC as $propertyName => $propertyValue) { |
$propertyValue = (string) $propertyValue; |
switch ($propertyName) { |
case 'title' : |
$docProps->setTitle(trim($propertyValue)); |
break; |
case 'subject' : |
$docProps->setSubject(trim($propertyValue)); |
break; |
case 'creator' : |
$docProps->setCreator(trim($propertyValue)); |
$docProps->setLastModifiedBy(trim($propertyValue)); |
break; |
case 'date' : |
$creationDate = strtotime(trim($propertyValue)); |
$docProps->setCreated($creationDate); |
$docProps->setModified($creationDate); |
break; |
case 'description' : |
$docProps->setDescription(trim($propertyValue)); |
break; |
} |
} |
$officePropertyMeta = array(); |
if (isset($namespacesMeta['meta'])) { |
$officePropertyMeta = $officePropertyData->children($namespacesMeta['meta']); |
} |
foreach($officePropertyMeta as $propertyName => $propertyValue) { |
$attributes = $propertyValue->attributes($namespacesMeta['meta']); |
$propertyValue = (string) $propertyValue; |
switch ($propertyName) { |
case 'keyword' : |
$docProps->setKeywords(trim($propertyValue)); |
break; |
case 'initial-creator' : |
$docProps->setCreator(trim($propertyValue)); |
$docProps->setLastModifiedBy(trim($propertyValue)); |
break; |
case 'creation-date' : |
$creationDate = strtotime(trim($propertyValue)); |
$docProps->setCreated($creationDate); |
$docProps->setModified($creationDate); |
break; |
case 'user-defined' : |
list(,$attrName) = explode(':',$attributes['name']); |
switch ($attrName) { |
case 'publisher' : |
$docProps->setCompany(trim($propertyValue)); |
break; |
case 'category' : |
$docProps->setCategory(trim($propertyValue)); |
break; |
case 'manager' : |
$docProps->setManager(trim($propertyValue)); |
break; |
} |
break; |
} |
} |
} |
} elseif (isset($gnmXML->Summary)) { |
foreach($gnmXML->Summary->Item as $summaryItem) { |
$propertyName = $summaryItem->name; |
$propertyValue = $summaryItem->{'val-string'}; |
switch ($propertyName) { |
case 'title' : |
$docProps->setTitle(trim($propertyValue)); |
break; |
case 'comments' : |
$docProps->setDescription(trim($propertyValue)); |
break; |
case 'keywords' : |
$docProps->setKeywords(trim($propertyValue)); |
break; |
case 'category' : |
$docProps->setCategory(trim($propertyValue)); |
break; |
case 'manager' : |
$docProps->setManager(trim($propertyValue)); |
break; |
case 'author' : |
$docProps->setCreator(trim($propertyValue)); |
$docProps->setLastModifiedBy(trim($propertyValue)); |
break; |
case 'company' : |
$docProps->setCompany(trim($propertyValue)); |
break; |
} |
} |
} |
$worksheetID = 0; |
foreach($gnmXML->Sheets->Sheet as $sheet) { |
$worksheetName = (string) $sheet->Name; |
// echo '<b>Worksheet: ',$worksheetName,'</b><br />'; |
if ((isset($this->_loadSheetsOnly)) && (!in_array($worksheetName, $this->_loadSheetsOnly))) { |
continue; |
} |
$maxRow = $maxCol = 0; |
// Create new Worksheet |
$objPHPExcel->createSheet(); |
$objPHPExcel->setActiveSheetIndex($worksheetID); |
// Use false for $updateFormulaCellReferences to prevent adjustment of worksheet references in formula |
// cells... during the load, all formulae should be correct, and we're simply bringing the worksheet |
// name in line with the formula, not the reverse |
$objPHPExcel->getActiveSheet()->setTitle($worksheetName,false); |
if ((!$this->_readDataOnly) && (isset($sheet->PrintInformation))) { |
if (isset($sheet->PrintInformation->Margins)) { |
foreach($sheet->PrintInformation->Margins->children('gnm',TRUE) as $key => $margin) { |
$marginAttributes = $margin->attributes(); |
$marginSize = 72 / 100; // Default |
switch($marginAttributes['PrefUnit']) { |
case 'mm' : |
$marginSize = intval($marginAttributes['Points']) / 100; |
break; |
} |
switch($key) { |
case 'top' : |
$objPHPExcel->getActiveSheet()->getPageMargins()->setTop($marginSize); |
break; |
case 'bottom' : |
$objPHPExcel->getActiveSheet()->getPageMargins()->setBottom($marginSize); |
break; |
case 'left' : |
$objPHPExcel->getActiveSheet()->getPageMargins()->setLeft($marginSize); |
break; |
case 'right' : |
$objPHPExcel->getActiveSheet()->getPageMargins()->setRight($marginSize); |
break; |
case 'header' : |
$objPHPExcel->getActiveSheet()->getPageMargins()->setHeader($marginSize); |
break; |
case 'footer' : |
$objPHPExcel->getActiveSheet()->getPageMargins()->setFooter($marginSize); |
break; |
} |
} |
} |
} |
foreach($sheet->Cells->Cell as $cell) { |
$cellAttributes = $cell->attributes(); |
$row = (int) $cellAttributes->Row + 1; |
$column = (int) $cellAttributes->Col; |
if ($row > $maxRow) $maxRow = $row; |
if ($column > $maxCol) $maxCol = $column; |
$column = PHPExcel_Cell::stringFromColumnIndex($column); |
// Read cell? |
if ($this->getReadFilter() !== NULL) { |
if (!$this->getReadFilter()->readCell($column, $row, $worksheetName)) { |
continue; |
} |
} |
$ValueType = $cellAttributes->ValueType; |
$ExprID = (string) $cellAttributes->ExprID; |
// echo 'Cell ',$column,$row,'<br />'; |
// echo 'Type is ',$ValueType,'<br />'; |
// echo 'Value is ',$cell,'<br />'; |
$type = PHPExcel_Cell_DataType::TYPE_FORMULA; |
if ($ExprID > '') { |
if (((string) $cell) > '') { |
$this->_expressions[$ExprID] = array( 'column' => $cellAttributes->Col, |
'row' => $cellAttributes->Row, |
'formula' => (string) $cell |
); |
// echo 'NEW EXPRESSION ',$ExprID,'<br />'; |
} else { |
$expression = $this->_expressions[$ExprID]; |
$cell = $this->_referenceHelper->updateFormulaReferences( $expression['formula'], |
'A1', |
$cellAttributes->Col - $expression['column'], |
$cellAttributes->Row - $expression['row'], |
$worksheetName |
); |
// echo 'SHARED EXPRESSION ',$ExprID,'<br />'; |
// echo 'New Value is ',$cell,'<br />'; |
} |
$type = PHPExcel_Cell_DataType::TYPE_FORMULA; |
} else { |
switch($ValueType) { |
case '10' : // NULL |
$type = PHPExcel_Cell_DataType::TYPE_NULL; |
break; |
case '20' : // Boolean |
$type = PHPExcel_Cell_DataType::TYPE_BOOL; |
$cell = ($cell == 'TRUE') ? True : False; |
break; |
case '30' : // Integer |
$cell = intval($cell); |
case '40' : // Float |
$type = PHPExcel_Cell_DataType::TYPE_NUMERIC; |
break; |
case '50' : // Error |
$type = PHPExcel_Cell_DataType::TYPE_ERROR; |
break; |
case '60' : // String |
$type = PHPExcel_Cell_DataType::TYPE_STRING; |
break; |
case '70' : // Cell Range |
case '80' : // Array |
} |
} |
$objPHPExcel->getActiveSheet()->getCell($column.$row)->setValueExplicit($cell,$type); |
} |
if ((!$this->_readDataOnly) && (isset($sheet->Objects))) { |
foreach($sheet->Objects->children('gnm',TRUE) as $key => $comment) { |
$commentAttributes = $comment->attributes(); |
// Only comment objects are handled at the moment |
if ($commentAttributes->Text) { |
$objPHPExcel->getActiveSheet()->getComment( (string)$commentAttributes->ObjectBound ) |
->setAuthor( (string)$commentAttributes->Author ) |
->setText($this->_parseRichText((string)$commentAttributes->Text) ); |
} |
} |
} |
// echo '$maxCol=',$maxCol,'; $maxRow=',$maxRow,'<br />'; |
// |
foreach($sheet->Styles->StyleRegion as $styleRegion) { |
$styleAttributes = $styleRegion->attributes(); |
if (($styleAttributes['startRow'] <= $maxRow) && |
($styleAttributes['startCol'] <= $maxCol)) { |
$startColumn = PHPExcel_Cell::stringFromColumnIndex((int) $styleAttributes['startCol']); |
$startRow = $styleAttributes['startRow'] + 1; |
$endColumn = ($styleAttributes['endCol'] > $maxCol) ? $maxCol : (int) $styleAttributes['endCol']; |
$endColumn = PHPExcel_Cell::stringFromColumnIndex($endColumn); |
$endRow = ($styleAttributes['endRow'] > $maxRow) ? $maxRow : $styleAttributes['endRow']; |
$endRow += 1; |
$cellRange = $startColumn.$startRow.':'.$endColumn.$endRow; |
// echo $cellRange,'<br />'; |
$styleAttributes = $styleRegion->Style->attributes(); |
// var_dump($styleAttributes); |
// echo '<br />'; |
// We still set the number format mask for date/time values, even if _readDataOnly is true |
if ((!$this->_readDataOnly) || |
(PHPExcel_Shared_Date::isDateTimeFormatCode($styleArray['numberformat']['code']))) { |
$styleArray = array(); |
$styleArray['numberformat']['code'] = (string) $styleAttributes['Format']; |
// If _readDataOnly is false, we set all formatting information |
if (!$this->_readDataOnly) { |
switch($styleAttributes['HAlign']) { |
case '1' : |
$styleArray['alignment']['horizontal'] = PHPExcel_Style_Alignment::HORIZONTAL_GENERAL; |
break; |
case '2' : |
$styleArray['alignment']['horizontal'] = PHPExcel_Style_Alignment::HORIZONTAL_LEFT; |
break; |
case '4' : |
$styleArray['alignment']['horizontal'] = PHPExcel_Style_Alignment::HORIZONTAL_RIGHT; |
break; |
case '8' : |
$styleArray['alignment']['horizontal'] = PHPExcel_Style_Alignment::HORIZONTAL_CENTER; |
break; |
case '16' : |
case '64' : |
$styleArray['alignment']['horizontal'] = PHPExcel_Style_Alignment::HORIZONTAL_CENTER_CONTINUOUS; |
break; |
case '32' : |
$styleArray['alignment']['horizontal'] = PHPExcel_Style_Alignment::HORIZONTAL_JUSTIFY; |
break; |
} |
switch($styleAttributes['VAlign']) { |
case '1' : |
$styleArray['alignment']['vertical'] = PHPExcel_Style_Alignment::VERTICAL_TOP; |
break; |
case '2' : |
$styleArray['alignment']['vertical'] = PHPExcel_Style_Alignment::VERTICAL_BOTTOM; |
break; |
case '4' : |
$styleArray['alignment']['vertical'] = PHPExcel_Style_Alignment::VERTICAL_CENTER; |
break; |
case '8' : |
$styleArray['alignment']['vertical'] = PHPExcel_Style_Alignment::VERTICAL_JUSTIFY; |
break; |
} |
$styleArray['alignment']['wrap'] = ($styleAttributes['WrapText'] == '1') ? True : False; |
$styleArray['alignment']['shrinkToFit'] = ($styleAttributes['ShrinkToFit'] == '1') ? True : False; |
$styleArray['alignment']['indent'] = (intval($styleAttributes["Indent"]) > 0) ? $styleAttributes["indent"] : 0; |
$RGB = self::_parseGnumericColour($styleAttributes["Fore"]); |
$styleArray['font']['color']['rgb'] = $RGB; |
$RGB = self::_parseGnumericColour($styleAttributes["Back"]); |
$shade = $styleAttributes["Shade"]; |
if (($RGB != '000000') || ($shade != '0')) { |
$styleArray['fill']['color']['rgb'] = $styleArray['fill']['startcolor']['rgb'] = $RGB; |
$RGB2 = self::_parseGnumericColour($styleAttributes["PatternColor"]); |
$styleArray['fill']['endcolor']['rgb'] = $RGB2; |
switch($shade) { |
case '1' : |
$styleArray['fill']['type'] = PHPExcel_Style_Fill::FILL_SOLID; |
break; |
case '2' : |
$styleArray['fill']['type'] = PHPExcel_Style_Fill::FILL_GRADIENT_LINEAR; |
break; |
case '3' : |
$styleArray['fill']['type'] = PHPExcel_Style_Fill::FILL_GRADIENT_PATH; |
break; |
case '4' : |
$styleArray['fill']['type'] = PHPExcel_Style_Fill::FILL_PATTERN_DARKDOWN; |
break; |
case '5' : |
$styleArray['fill']['type'] = PHPExcel_Style_Fill::FILL_PATTERN_DARKGRAY; |
break; |
case '6' : |
$styleArray['fill']['type'] = PHPExcel_Style_Fill::FILL_PATTERN_DARKGRID; |
break; |
case '7' : |
$styleArray['fill']['type'] = PHPExcel_Style_Fill::FILL_PATTERN_DARKHORIZONTAL; |
break; |
case '8' : |
$styleArray['fill']['type'] = PHPExcel_Style_Fill::FILL_PATTERN_DARKTRELLIS; |
break; |
case '9' : |
$styleArray['fill']['type'] = PHPExcel_Style_Fill::FILL_PATTERN_DARKUP; |
break; |
case '10' : |
$styleArray['fill']['type'] = PHPExcel_Style_Fill::FILL_PATTERN_DARKVERTICAL; |
break; |
case '11' : |
$styleArray['fill']['type'] = PHPExcel_Style_Fill::FILL_PATTERN_GRAY0625; |
break; |
case '12' : |
$styleArray['fill']['type'] = PHPExcel_Style_Fill::FILL_PATTERN_GRAY125; |
break; |
case '13' : |
$styleArray['fill']['type'] = PHPExcel_Style_Fill::FILL_PATTERN_LIGHTDOWN; |
break; |
case '14' : |
$styleArray['fill']['type'] = PHPExcel_Style_Fill::FILL_PATTERN_LIGHTGRAY; |
break; |
case '15' : |
$styleArray['fill']['type'] = PHPExcel_Style_Fill::FILL_PATTERN_LIGHTGRID; |
break; |
case '16' : |
$styleArray['fill']['type'] = PHPExcel_Style_Fill::FILL_PATTERN_LIGHTHORIZONTAL; |
break; |
case '17' : |
$styleArray['fill']['type'] = PHPExcel_Style_Fill::FILL_PATTERN_LIGHTTRELLIS; |
break; |
case '18' : |
$styleArray['fill']['type'] = PHPExcel_Style_Fill::FILL_PATTERN_LIGHTUP; |
break; |
case '19' : |
$styleArray['fill']['type'] = PHPExcel_Style_Fill::FILL_PATTERN_LIGHTVERTICAL; |
break; |
case '20' : |
$styleArray['fill']['type'] = PHPExcel_Style_Fill::FILL_PATTERN_MEDIUMGRAY; |
break; |
} |
} |
$fontAttributes = $styleRegion->Style->Font->attributes(); |
// var_dump($fontAttributes); |
// echo '<br />'; |
$styleArray['font']['name'] = (string) $styleRegion->Style->Font; |
$styleArray['font']['size'] = intval($fontAttributes['Unit']); |
$styleArray['font']['bold'] = ($fontAttributes['Bold'] == '1') ? True : False; |
$styleArray['font']['italic'] = ($fontAttributes['Italic'] == '1') ? True : False; |
$styleArray['font']['strike'] = ($fontAttributes['StrikeThrough'] == '1') ? True : False; |
switch($fontAttributes['Underline']) { |
case '1' : |
$styleArray['font']['underline'] = PHPExcel_Style_Font::UNDERLINE_SINGLE; |
break; |
case '2' : |
$styleArray['font']['underline'] = PHPExcel_Style_Font::UNDERLINE_DOUBLE; |
break; |
case '3' : |
$styleArray['font']['underline'] = PHPExcel_Style_Font::UNDERLINE_SINGLEACCOUNTING; |
break; |
case '4' : |
$styleArray['font']['underline'] = PHPExcel_Style_Font::UNDERLINE_DOUBLEACCOUNTING; |
break; |
default : |
$styleArray['font']['underline'] = PHPExcel_Style_Font::UNDERLINE_NONE; |
break; |
} |
switch($fontAttributes['Script']) { |
case '1' : |
$styleArray['font']['superScript'] = True; |
break; |
case '-1' : |
$styleArray['font']['subScript'] = True; |
break; |
} |
if (isset($styleRegion->Style->StyleBorder)) { |
if (isset($styleRegion->Style->StyleBorder->Top)) { |
$styleArray['borders']['top'] = self::_parseBorderAttributes($styleRegion->Style->StyleBorder->Top->attributes()); |
} |
if (isset($styleRegion->Style->StyleBorder->Bottom)) { |
$styleArray['borders']['bottom'] = self::_parseBorderAttributes($styleRegion->Style->StyleBorder->Bottom->attributes()); |
} |
if (isset($styleRegion->Style->StyleBorder->Left)) { |
$styleArray['borders']['left'] = self::_parseBorderAttributes($styleRegion->Style->StyleBorder->Left->attributes()); |
} |
if (isset($styleRegion->Style->StyleBorder->Right)) { |
$styleArray['borders']['right'] = self::_parseBorderAttributes($styleRegion->Style->StyleBorder->Right->attributes()); |
} |
if ((isset($styleRegion->Style->StyleBorder->Diagonal)) && (isset($styleRegion->Style->StyleBorder->{'Rev-Diagonal'}))) { |
$styleArray['borders']['diagonal'] = self::_parseBorderAttributes($styleRegion->Style->StyleBorder->Diagonal->attributes()); |
$styleArray['borders']['diagonaldirection'] = PHPExcel_Style_Borders::DIAGONAL_BOTH; |
} elseif (isset($styleRegion->Style->StyleBorder->Diagonal)) { |
$styleArray['borders']['diagonal'] = self::_parseBorderAttributes($styleRegion->Style->StyleBorder->Diagonal->attributes()); |
$styleArray['borders']['diagonaldirection'] = PHPExcel_Style_Borders::DIAGONAL_UP; |
} elseif (isset($styleRegion->Style->StyleBorder->{'Rev-Diagonal'})) { |
$styleArray['borders']['diagonal'] = self::_parseBorderAttributes($styleRegion->Style->StyleBorder->{'Rev-Diagonal'}->attributes()); |
$styleArray['borders']['diagonaldirection'] = PHPExcel_Style_Borders::DIAGONAL_DOWN; |
} |
} |
if (isset($styleRegion->Style->HyperLink)) { |
// TO DO |
$hyperlink = $styleRegion->Style->HyperLink->attributes(); |
} |
} |
// var_dump($styleArray); |
// echo '<br />'; |
$objPHPExcel->getActiveSheet()->getStyle($cellRange)->applyFromArray($styleArray); |
} |
} |
} |
if ((!$this->_readDataOnly) && (isset($sheet->Cols))) { |
// Column Widths |
$columnAttributes = $sheet->Cols->attributes(); |
$defaultWidth = $columnAttributes['DefaultSizePts'] / 5.4; |
$c = 0; |
foreach($sheet->Cols->ColInfo as $columnOverride) { |
$columnAttributes = $columnOverride->attributes(); |
$column = $columnAttributes['No']; |
$columnWidth = $columnAttributes['Unit'] / 5.4; |
$hidden = ((isset($columnAttributes['Hidden'])) && ($columnAttributes['Hidden'] == '1')) ? true : false; |
$columnCount = (isset($columnAttributes['Count'])) ? $columnAttributes['Count'] : 1; |
while ($c < $column) { |
$objPHPExcel->getActiveSheet()->getColumnDimension(PHPExcel_Cell::stringFromColumnIndex($c))->setWidth($defaultWidth); |
++$c; |
} |
while (($c < ($column+$columnCount)) && ($c <= $maxCol)) { |
$objPHPExcel->getActiveSheet()->getColumnDimension(PHPExcel_Cell::stringFromColumnIndex($c))->setWidth($columnWidth); |
if ($hidden) { |
$objPHPExcel->getActiveSheet()->getColumnDimension(PHPExcel_Cell::stringFromColumnIndex($c))->setVisible(false); |
} |
++$c; |
} |
} |
while ($c <= $maxCol) { |
$objPHPExcel->getActiveSheet()->getColumnDimension(PHPExcel_Cell::stringFromColumnIndex($c))->setWidth($defaultWidth); |
++$c; |
} |
} |
if ((!$this->_readDataOnly) && (isset($sheet->Rows))) { |
// Row Heights |
$rowAttributes = $sheet->Rows->attributes(); |
$defaultHeight = $rowAttributes['DefaultSizePts']; |
$r = 0; |
foreach($sheet->Rows->RowInfo as $rowOverride) { |
$rowAttributes = $rowOverride->attributes(); |
$row = $rowAttributes['No']; |
$rowHeight = $rowAttributes['Unit']; |
$hidden = ((isset($rowAttributes['Hidden'])) && ($rowAttributes['Hidden'] == '1')) ? true : false; |
$rowCount = (isset($rowAttributes['Count'])) ? $rowAttributes['Count'] : 1; |
while ($r < $row) { |
++$r; |
$objPHPExcel->getActiveSheet()->getRowDimension($r)->setRowHeight($defaultHeight); |
} |
while (($r < ($row+$rowCount)) && ($r < $maxRow)) { |
++$r; |
$objPHPExcel->getActiveSheet()->getRowDimension($r)->setRowHeight($rowHeight); |
if ($hidden) { |
$objPHPExcel->getActiveSheet()->getRowDimension($r)->setVisible(false); |
} |
} |
} |
while ($r < $maxRow) { |
++$r; |
$objPHPExcel->getActiveSheet()->getRowDimension($r)->setRowHeight($defaultHeight); |
} |
} |
// Handle Merged Cells in this worksheet |
if (isset($sheet->MergedRegions)) { |
foreach($sheet->MergedRegions->Merge as $mergeCells) { |
if (strpos($mergeCells,':') !== FALSE) { |
$objPHPExcel->getActiveSheet()->mergeCells($mergeCells); |
} |
} |
} |
$worksheetID++; |
} |
// Loop through definedNames (global named ranges) |
if (isset($gnmXML->Names)) { |
foreach($gnmXML->Names->Name as $namedRange) { |
$name = (string) $namedRange->name; |
$range = (string) $namedRange->value; |
if (stripos($range, '#REF!') !== false) { |
continue; |
} |
$range = explode('!',$range); |
$range[0] = trim($range[0],"'");; |
if ($worksheet = $objPHPExcel->getSheetByName($range[0])) { |
$extractedRange = str_replace('$', '', $range[1]); |
$objPHPExcel->addNamedRange( new PHPExcel_NamedRange($name, $worksheet, $extractedRange) ); |
} |
} |
} |
// Return |
return $objPHPExcel; |
} |
private static function _parseBorderAttributes($borderAttributes) |
{ |
$styleArray = array(); |
if (isset($borderAttributes["Color"])) { |
$RGB = self::_parseGnumericColour($borderAttributes["Color"]); |
$styleArray['color']['rgb'] = $RGB; |
} |
switch ($borderAttributes["Style"]) { |
case '0' : |
$styleArray['style'] = PHPExcel_Style_Border::BORDER_NONE; |
break; |
case '1' : |
$styleArray['style'] = PHPExcel_Style_Border::BORDER_THIN; |
break; |
case '2' : |
$styleArray['style'] = PHPExcel_Style_Border::BORDER_MEDIUM; |
break; |
case '4' : |
$styleArray['style'] = PHPExcel_Style_Border::BORDER_DASHED; |
break; |
case '5' : |
$styleArray['style'] = PHPExcel_Style_Border::BORDER_THICK; |
break; |
case '6' : |
$styleArray['style'] = PHPExcel_Style_Border::BORDER_DOUBLE; |
break; |
case '7' : |
$styleArray['style'] = PHPExcel_Style_Border::BORDER_DOTTED; |
break; |
case '9' : |
$styleArray['style'] = PHPExcel_Style_Border::BORDER_DASHDOT; |
break; |
case '10' : |
$styleArray['style'] = PHPExcel_Style_Border::BORDER_MEDIUMDASHDOT; |
break; |
case '11' : |
$styleArray['style'] = PHPExcel_Style_Border::BORDER_DASHDOTDOT; |
break; |
case '12' : |
$styleArray['style'] = PHPExcel_Style_Border::BORDER_MEDIUMDASHDOTDOT; |
break; |
case '13' : |
$styleArray['style'] = PHPExcel_Style_Border::BORDER_MEDIUMDASHDOTDOT; |
break; |
case '3' : |
$styleArray['style'] = PHPExcel_Style_Border::BORDER_SLANTDASHDOT; |
break; |
case '8' : |
$styleArray['style'] = PHPExcel_Style_Border::BORDER_MEDIUMDASHED; |
break; |
} |
return $styleArray; |
} |
private function _parseRichText($is = '') { |
$value = new PHPExcel_RichText(); |
$value->createText($is); |
return $value; |
} |
private static function _parseGnumericColour($gnmColour) { |
list($gnmR,$gnmG,$gnmB) = explode(':',$gnmColour); |
$gnmR = substr(str_pad($gnmR,4,'0',STR_PAD_RIGHT),0,2); |
$gnmG = substr(str_pad($gnmG,4,'0',STR_PAD_RIGHT),0,2); |
$gnmB = substr(str_pad($gnmB,4,'0',STR_PAD_RIGHT),0,2); |
$RGB = $gnmR.$gnmG.$gnmB; |
// echo 'Excel Colour: ',$RGB,'<br />'; |
return $RGB; |
} |
} |
/branches/v2.6-greffoir/jrest/lib/PHPExcel/Classes/PHPExcel/Reader/IReadFilter.php |
---|
New file |
0,0 → 1,47 |
<?php |
/** |
* PHPExcel |
* |
* Copyright (c) 2006 - 2013 PHPExcel |
* |
* This library is free software; you can redistribute it and/or |
* modify it under the terms of the GNU Lesser General Public |
* License as published by the Free Software Foundation; either |
* version 2.1 of the License, or (at your option) any later version. |
* |
* This library is distributed in the hope that it will be useful, |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
* Lesser General Public License for more details. |
* |
* You should have received a copy of the GNU Lesser General Public |
* License along with this library; if not, write to the Free Software |
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
* |
* @category PHPExcel |
* @package PHPExcel_Reader |
* @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL |
* @version ##VERSION##, ##DATE## |
*/ |
/** |
* PHPExcel_Reader_IReadFilter |
* |
* @category PHPExcel |
* @package PHPExcel_Reader |
* @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
*/ |
interface PHPExcel_Reader_IReadFilter |
{ |
/** |
* Should this cell be read? |
* |
* @param $column String column index |
* @param $row Row index |
* @param $worksheetName Optional worksheet name |
* @return boolean |
*/ |
public function readCell($column, $row, $worksheetName = ''); |
} |
/branches/v2.6-greffoir/jrest/lib/PHPExcel/Classes/PHPExcel/Reader/CSV.php |
---|
New file |
0,0 → 1,415 |
<?php |
/** |
* PHPExcel |
* |
* Copyright (c) 2006 - 2013 PHPExcel |
* |
* This library is free software; you can redistribute it and/or |
* modify it under the terms of the GNU Lesser General Public |
* License as published by the Free Software Foundation; either |
* version 2.1 of the License, or (at your option) any later version. |
* |
* This library is distributed in the hope that it will be useful, |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
* Lesser General Public License for more details. |
* |
* You should have received a copy of the GNU Lesser General Public |
* License along with this library; if not, write to the Free Software |
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
* |
* @category PHPExcel |
* @package PHPExcel_Reader |
* @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL |
* @version ##VERSION##, ##DATE## |
*/ |
/** PHPExcel root directory */ |
if (!defined('PHPEXCEL_ROOT')) { |
/** |
* @ignore |
*/ |
define('PHPEXCEL_ROOT', dirname(__FILE__) . '/../../'); |
require(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php'); |
} |
/** |
* PHPExcel_Reader_CSV |
* |
* @category PHPExcel |
* @package PHPExcel_Reader |
* @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
*/ |
class PHPExcel_Reader_CSV extends PHPExcel_Reader_Abstract implements PHPExcel_Reader_IReader |
{ |
/** |
* Input encoding |
* |
* @access private |
* @var string |
*/ |
private $_inputEncoding = 'UTF-8'; |
/** |
* Delimiter |
* |
* @access private |
* @var string |
*/ |
private $_delimiter = ','; |
/** |
* Enclosure |
* |
* @access private |
* @var string |
*/ |
private $_enclosure = '"'; |
/** |
* Line ending |
* |
* @access private |
* @var string |
*/ |
private $_lineEnding = PHP_EOL; |
/** |
* Sheet index to read |
* |
* @access private |
* @var int |
*/ |
private $_sheetIndex = 0; |
/** |
* Load rows contiguously |
* |
* @access private |
* @var int |
*/ |
private $_contiguous = false; |
/** |
* Row counter for loading rows contiguously |
* |
* @var int |
*/ |
private $_contiguousRow = -1; |
/** |
* Create a new PHPExcel_Reader_CSV |
*/ |
public function __construct() { |
$this->_readFilter = new PHPExcel_Reader_DefaultReadFilter(); |
} |
/** |
* Validate that the current file is a CSV file |
* |
* @return boolean |
*/ |
protected function _isValidFormat() |
{ |
return TRUE; |
} |
/** |
* Set input encoding |
* |
* @param string $pValue Input encoding |
*/ |
public function setInputEncoding($pValue = 'UTF-8') |
{ |
$this->_inputEncoding = $pValue; |
return $this; |
} |
/** |
* Get input encoding |
* |
* @return string |
*/ |
public function getInputEncoding() |
{ |
return $this->_inputEncoding; |
} |
/** |
* Move filepointer past any BOM marker |
* |
*/ |
protected function _skipBOM() |
{ |
rewind($fileHandle); |
switch ($this->_inputEncoding) { |
case 'UTF-8': |
fgets($this->_fileHandle, 4) == "\xEF\xBB\xBF" ? |
fseek($this->_fileHandle, 3) : fseek($this->_fileHandle, 0); |
break; |
case 'UTF-16LE': |
fgets($this->_fileHandle, 3) == "\xFF\xFE" ? |
fseek($this->_fileHandle, 2) : fseek($this->_fileHandle, 0); |
break; |
case 'UTF-16BE': |
fgets($this->_fileHandle, 3) == "\xFE\xFF" ? |
fseek($this->_fileHandle, 2) : fseek($this->_fileHandle, 0); |
break; |
case 'UTF-32LE': |
fgets($this->_fileHandle, 5) == "\xFF\xFE\x00\x00" ? |
fseek($this->_fileHandle, 4) : fseek($this->_fileHandle, 0); |
break; |
case 'UTF-32BE': |
fgets($this->_fileHandle, 5) == "\x00\x00\xFE\xFF" ? |
fseek($this->_fileHandle, 4) : fseek($this->_fileHandle, 0); |
break; |
default: |
break; |
} |
} |
/** |
* Return worksheet info (Name, Last Column Letter, Last Column Index, Total Rows, Total Columns) |
* |
* @param string $pFilename |
* @throws PHPExcel_Reader_Exception |
*/ |
public function listWorksheetInfo($pFilename) |
{ |
// Open file |
$this->_openFile($pFilename); |
if (!$this->_isValidFormat()) { |
fclose ($this->_fileHandle); |
throw new PHPExcel_Reader_Exception($pFilename . " is an Invalid Spreadsheet file."); |
} |
$fileHandle = $this->_fileHandle; |
// Skip BOM, if any |
$this->_skipBOM(); |
$escapeEnclosures = array( "\\" . $this->_enclosure, $this->_enclosure . $this->_enclosure ); |
$worksheetInfo = array(); |
$worksheetInfo[0]['worksheetName'] = 'Worksheet'; |
$worksheetInfo[0]['lastColumnLetter'] = 'A'; |
$worksheetInfo[0]['lastColumnIndex'] = 0; |
$worksheetInfo[0]['totalRows'] = 0; |
$worksheetInfo[0]['totalColumns'] = 0; |
// Loop through each line of the file in turn |
while (($rowData = fgetcsv($fileHandle, 0, $this->_delimiter, $this->_enclosure)) !== FALSE) { |
$worksheetInfo[0]['totalRows']++; |
$worksheetInfo[0]['lastColumnIndex'] = max($worksheetInfo[0]['lastColumnIndex'], count($rowData) - 1); |
} |
$worksheetInfo[0]['lastColumnLetter'] = PHPExcel_Cell::stringFromColumnIndex($worksheetInfo[0]['lastColumnIndex']); |
$worksheetInfo[0]['totalColumns'] = $worksheetInfo[0]['lastColumnIndex'] + 1; |
// Close file |
fclose($fileHandle); |
return $worksheetInfo; |
} |
/** |
* Loads PHPExcel from file |
* |
* @param string $pFilename |
* @return PHPExcel |
* @throws PHPExcel_Reader_Exception |
*/ |
public function load($pFilename) |
{ |
// Create new PHPExcel |
$objPHPExcel = new PHPExcel(); |
// Load into this instance |
return $this->loadIntoExisting($pFilename, $objPHPExcel); |
} |
/** |
* Loads PHPExcel from file into PHPExcel instance |
* |
* @param string $pFilename |
* @param PHPExcel $objPHPExcel |
* @return PHPExcel |
* @throws PHPExcel_Reader_Exception |
*/ |
public function loadIntoExisting($pFilename, PHPExcel $objPHPExcel) |
{ |
$lineEnding = ini_get('auto_detect_line_endings'); |
ini_set('auto_detect_line_endings', true); |
// Open file |
$this->_openFile($pFilename); |
if (!$this->_isValidFormat()) { |
fclose ($this->_fileHandle); |
throw new PHPExcel_Reader_Exception($pFilename . " is an Invalid Spreadsheet file."); |
} |
$fileHandle = $this->_fileHandle; |
// Skip BOM, if any |
$this->_skipBOM(); |
// Create new PHPExcel object |
while ($objPHPExcel->getSheetCount() <= $this->_sheetIndex) { |
$objPHPExcel->createSheet(); |
} |
$sheet = $objPHPExcel->setActiveSheetIndex($this->_sheetIndex); |
$escapeEnclosures = array( "\\" . $this->_enclosure, |
$this->_enclosure . $this->_enclosure |
); |
// Set our starting row based on whether we're in contiguous mode or not |
$currentRow = 1; |
if ($this->_contiguous) { |
$currentRow = ($this->_contiguousRow == -1) ? $sheet->getHighestRow(): $this->_contiguousRow; |
} |
// Loop through each line of the file in turn |
while (($rowData = fgetcsv($fileHandle, 0, $this->_delimiter, $this->_enclosure)) !== FALSE) { |
$columnLetter = 'A'; |
foreach($rowData as $rowDatum) { |
if ($rowDatum != '' && $this->_readFilter->readCell($columnLetter, $currentRow)) { |
// Unescape enclosures |
$rowDatum = str_replace($escapeEnclosures, $this->_enclosure, $rowDatum); |
// Convert encoding if necessary |
if ($this->_inputEncoding !== 'UTF-8') { |
$rowDatum = PHPExcel_Shared_String::ConvertEncoding($rowDatum, 'UTF-8', $this->_inputEncoding); |
} |
// Set cell value |
$sheet->getCell($columnLetter . $currentRow)->setValue($rowDatum); |
} |
++$columnLetter; |
} |
++$currentRow; |
} |
// Close file |
fclose($fileHandle); |
if ($this->_contiguous) { |
$this->_contiguousRow = $currentRow; |
} |
ini_set('auto_detect_line_endings', $lineEnding); |
// Return |
return $objPHPExcel; |
} |
/** |
* Get delimiter |
* |
* @return string |
*/ |
public function getDelimiter() { |
return $this->_delimiter; |
} |
/** |
* Set delimiter |
* |
* @param string $pValue Delimiter, defaults to , |
* @return PHPExcel_Reader_CSV |
*/ |
public function setDelimiter($pValue = ',') { |
$this->_delimiter = $pValue; |
return $this; |
} |
/** |
* Get enclosure |
* |
* @return string |
*/ |
public function getEnclosure() { |
return $this->_enclosure; |
} |
/** |
* Set enclosure |
* |
* @param string $pValue Enclosure, defaults to " |
* @return PHPExcel_Reader_CSV |
*/ |
public function setEnclosure($pValue = '"') { |
if ($pValue == '') { |
$pValue = '"'; |
} |
$this->_enclosure = $pValue; |
return $this; |
} |
/** |
* Get line ending |
* |
* @return string |
*/ |
public function getLineEnding() { |
return $this->_lineEnding; |
} |
/** |
* Set line ending |
* |
* @param string $pValue Line ending, defaults to OS line ending (PHP_EOL) |
* @return PHPExcel_Reader_CSV |
*/ |
public function setLineEnding($pValue = PHP_EOL) { |
$this->_lineEnding = $pValue; |
return $this; |
} |
/** |
* Get sheet index |
* |
* @return integer |
*/ |
public function getSheetIndex() { |
return $this->_sheetIndex; |
} |
/** |
* Set sheet index |
* |
* @param integer $pValue Sheet index |
* @return PHPExcel_Reader_CSV |
*/ |
public function setSheetIndex($pValue = 0) { |
$this->_sheetIndex = $pValue; |
return $this; |
} |
/** |
* Set Contiguous |
* |
* @param boolean $contiguous |
*/ |
public function setContiguous($contiguous = FALSE) |
{ |
$this->_contiguous = (bool) $contiguous; |
if (!$contiguous) { |
$this->_contiguousRow = -1; |
} |
return $this; |
} |
/** |
* Get Contiguous |
* |
* @return boolean |
*/ |
public function getContiguous() { |
return $this->_contiguous; |
} |
} |
/branches/v2.6-greffoir/jrest/lib/PHPExcel/Classes/PHPExcel/Reader/IReader.php |
---|
New file |
0,0 → 1,53 |
<?php |
/** |
* PHPExcel |
* |
* Copyright (c) 2006 - 2013 PHPExcel |
* |
* This library is free software; you can redistribute it and/or |
* modify it under the terms of the GNU Lesser General Public |
* License as published by the Free Software Foundation; either |
* version 2.1 of the License, or (at your option) any later version. |
* |
* This library is distributed in the hope that it will be useful, |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
* Lesser General Public License for more details. |
* |
* You should have received a copy of the GNU Lesser General Public |
* License along with this library; if not, write to the Free Software |
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
* |
* @category PHPExcel |
* @package PHPExcel_Reader |
* @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
* @license http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt LGPL |
* @version ##VERSION##, ##DATE## |
*/ |
/** |
* PHPExcel_Reader_IReader |
* |
* @category PHPExcel |
* @package PHPExcel_Reader |
* @copyright Copyright (c) 2006 - 2013 PHPExcel (http://www.codeplex.com/PHPExcel) |
*/ |
interface PHPExcel_Reader_IReader |
{ |
/** |
* Can the current PHPExcel_Reader_IReader read the file? |
* |
* @param string $pFilename |
* @return boolean |
*/ |
public function canRead($pFilename); |
/** |
* Loads PHPExcel from file |
* |
* @param string $pFilename |
* @throws PHPExcel_Reader_Exception |
*/ |
public function load($pFilename); |
} |