init

lib/Classes/PHPExcel/Chart/Legend.php

+<?php
+/**
+ * PHPExcel
+ *
+ * Copyright (c) 2006 - 2014 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_Chart
+ * @copyright	Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
+ * @license		http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt	LGPL
+ * @version		1.8.0, 2014-03-02
+ */
+
+
+/**
+ * PHPExcel_Chart_Legend
+ *
+ * @category	PHPExcel
+ * @package		PHPExcel_Chart
+ * @copyright	Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
+ */
+class PHPExcel_Chart_Legend
+{
+	/** Legend positions */
+	const xlLegendPositionBottom	= -4107;	//	Below the chart.
+	const xlLegendPositionCorner	= 2;		//	In the upper right-hand corner of the chart border.
+	const xlLegendPositionCustom	= -4161;	//	A custom position.
+	const xlLegendPositionLeft		= -4131;	//	Left of the chart.
+	const xlLegendPositionRight		= -4152;	//	Right of the chart.
+	const xlLegendPositionTop		= -4160;	//	Above the chart.
+
+	const POSITION_RIGHT	= 'r';
+	const POSITION_LEFT		= 'l';
+	const POSITION_BOTTOM	= 'b';
+	const POSITION_TOP		= 't';
+	const POSITION_TOPRIGHT	= 'tr';
+
+	private static $_positionXLref = array( self::xlLegendPositionBottom	=> self::POSITION_BOTTOM,
+											self::xlLegendPositionCorner	=> self::POSITION_TOPRIGHT,
+											self::xlLegendPositionCustom	=> '??',
+											self::xlLegendPositionLeft		=> self::POSITION_LEFT,
+											self::xlLegendPositionRight		=> self::POSITION_RIGHT,
+											self::xlLegendPositionTop		=> self::POSITION_TOP
+										  );
+
+	/**
+	 * Legend position
+	 *
+	 * @var	string
+	 */
+	private $_position = self::POSITION_RIGHT;
+
+	/**
+	 * Allow overlay of other elements?
+	 *
+	 * @var	boolean
+	 */
+	private $_overlay = TRUE;
+
+	/**
+	 * Legend Layout
+	 *
+	 * @var	PHPExcel_Chart_Layout
+	 */
+	private $_layout = NULL;
+
+
+	/**
+	 *	Create a new PHPExcel_Chart_Legend
+	 */
+	public function __construct($position = self::POSITION_RIGHT, PHPExcel_Chart_Layout $layout = NULL, $overlay = FALSE)
+	{
+		$this->setPosition($position);
+		$this->_layout = $layout;
+		$this->setOverlay($overlay);
+	}
+
+	/**
+	 * Get legend position as an excel string value
+	 *
+	 * @return	string
+	 */
+	public function getPosition() {
+		return $this->_position;
+	}
+
+	/**
+	 * Get legend position using an excel string value
+	 *
+	 * @param	string	$position
+	 */
+	public function setPosition($position = self::POSITION_RIGHT) {
+		if (!in_array($position,self::$_positionXLref)) {
+			return false;
+		}
+
+		$this->_position = $position;
+		return true;
+	}
+
+	/**
+	 * Get legend position as an Excel internal numeric value
+	 *
+	 * @return	number
+	 */
+	public function getPositionXL() {
+		return array_search($this->_position,self::$_positionXLref);
+	}
+
+	/**
+	 * Set legend position using an Excel internal numeric value
+	 *
+	 * @param	number	$positionXL
+	 */
+	public function setPositionXL($positionXL = self::xlLegendPositionRight) {
+		if (!array_key_exists($positionXL,self::$_positionXLref)) {
+			return false;
+		}
+
+		$this->_position = self::$_positionXLref[$positionXL];
+		return true;
+	}
+
+	/**
+	 * Get allow overlay of other elements?
+	 *
+	 * @return	boolean
+	 */
+	public function getOverlay() {
+		return $this->_overlay;
+	}
+
+	/**
+	 * Set allow overlay of other elements?
+	 *
+	 * @param	boolean	$overlay
+	 * @return	boolean
+	 */
+	public function setOverlay($overlay = FALSE) {
+		if (!is_bool($overlay)) {
+			return false;
+		}
+
+		$this->_overlay = $overlay;
+		return true;
+	}
+
+	/**
+	 * Get Layout
+	 *
+	 * @return PHPExcel_Chart_Layout
+	 */
+	public function getLayout() {
+		return $this->_layout;
+	}
+
+}

lib/Classes/PHPExcel/Chart/PlotArea.php

+<?php
+/**
+ * PHPExcel
+ *
+ * Copyright (c) 2006 - 2014 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_Chart
+ * @copyright	Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
+ * @license		http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt	LGPL
+ * @version		1.8.0, 2014-03-02
+ */
+
+
+/**
+ * PHPExcel_Chart_PlotArea
+ *
+ * @category	PHPExcel
+ * @package		PHPExcel_Chart
+ * @copyright	Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
+ */
+class PHPExcel_Chart_PlotArea
+{
+	/**
+	 * PlotArea Layout
+	 *
+	 * @var PHPExcel_Chart_Layout
+	 */
+	private $_layout = null;
+
+	/**
+	 * Plot Series
+	 *
+	 * @var array of PHPExcel_Chart_DataSeries
+	 */
+	private $_plotSeries = array();
+
+	/**
+	 * Create a new PHPExcel_Chart_PlotArea
+	 */
+	public function __construct(PHPExcel_Chart_Layout $layout = null, $plotSeries = array())
+	{
+		$this->_layout = $layout;
+		$this->_plotSeries = $plotSeries;
+	}
+
+	/**
+	 * Get Layout
+	 *
+	 * @return PHPExcel_Chart_Layout
+	 */
+	public function getLayout() {
+		return $this->_layout;
+	}
+
+	/**
+	 * Get Number of Plot Groups
+	 *
+	 * @return array of PHPExcel_Chart_DataSeries
+	 */
+	public function getPlotGroupCount() {
+		return count($this->_plotSeries);
+	}
+
+	/**
+	 * Get Number of Plot Series
+	 *
+	 * @return integer
+	 */
+	public function getPlotSeriesCount() {
+		$seriesCount = 0;
+		foreach($this->_plotSeries as $plot) {
+			$seriesCount += $plot->getPlotSeriesCount();
+		}
+		return $seriesCount;
+	}
+
+	/**
+	 * Get Plot Series
+	 *
+	 * @return array of PHPExcel_Chart_DataSeries
+	 */
+	public function getPlotGroup() {
+		return $this->_plotSeries;
+	}
+
+	/**
+	 * Get Plot Series by Index
+	 *
+	 * @return PHPExcel_Chart_DataSeries
+	 */
+	public function getPlotGroupByIndex($index) {
+		return $this->_plotSeries[$index];
+	}
+
+	/**
+	 * Set Plot Series
+	 *
+	 * @param [PHPExcel_Chart_DataSeries]
+     * @return PHPExcel_Chart_PlotArea
+	 */
+	public function setPlotSeries($plotSeries = array()) {
+		$this->_plotSeries = $plotSeries;
+        
+        return $this;
+	}
+
+	public function refresh(PHPExcel_Worksheet $worksheet) {
+	    foreach($this->_plotSeries as $plotSeries) {
+			$plotSeries->refresh($worksheet);
+		}
+	}
+
+}

lib/Classes/PHPExcel/Chart/Renderer/PHP Charting Libraries.txt

+ChartDirector
+	http://www.advsofteng.com/cdphp.html
+
+GraPHPite
+	http://graphpite.sourceforge.net/
+
+JpGraph
+	http://www.aditus.nu/jpgraph/
+
+LibChart
+	http://naku.dohcrew.com/libchart/pages/introduction/
+
+pChart
+	http://pchart.sourceforge.net/
+
+TeeChart
+	http://www.steema.com/products/teechart/overview.html

lib/Classes/PHPExcel/Chart/Renderer/jpgraph.php

+<?php
+
+/**
+ * PHPExcel
+ *
+ * Copyright (c) 2006 - 2014 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_Chart_Renderer
+ * @copyright	Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
+ * @license		http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt	LGPL
+ * @version		1.8.0, 2014-03-02
+ */
+
+
+require_once(PHPExcel_Settings::getChartRendererPath().'/jpgraph.php');
+
+
+/**
+ * PHPExcel_Chart_Renderer_jpgraph
+ *
+ * @category	PHPExcel
+ * @package		PHPExcel_Chart_Renderer
+ * @copyright	Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
+ */
+class PHPExcel_Chart_Renderer_jpgraph
+{
+	private static $_width	= 640;
+
+	private static $_height	= 480;
+
+	private static $_colourSet = array( 'mediumpurple1',	'palegreen3',	'gold1',		'cadetblue1',
+										'darkmagenta',		'coral',		'dodgerblue3',	'eggplant',
+										'mediumblue',		'magenta',		'sandybrown',	'cyan',
+										'firebrick1',		'forestgreen',	'deeppink4',	'darkolivegreen',
+										'goldenrod2'
+									  );
+
+	private static $_markSet = array(	'diamond'	=> MARK_DIAMOND,
+										'square'	=> MARK_SQUARE,
+										'triangle'	=> MARK_UTRIANGLE,
+										'x'			=> MARK_X,
+										'star'		=> MARK_STAR,
+										'dot'		=> MARK_FILLEDCIRCLE,
+										'dash'		=> MARK_DTRIANGLE,
+										'circle'	=> MARK_CIRCLE,
+										'plus'		=> MARK_CROSS
+									);
+
+
+	private $_chart	= null;
+
+	private $_graph	= null;
+
+	private static $_plotColour	= 0;
+
+	private static $_plotMark	= 0;
+
+
+	private function _formatPointMarker($seriesPlot,$markerID) {
+		$plotMarkKeys = array_keys(self::$_markSet);
+		if (is_null($markerID)) {
+			//	Use default plot marker (next marker in the series)
+			self::$_plotMark %= count(self::$_markSet);
+			$seriesPlot->mark->SetType(self::$_markSet[$plotMarkKeys[self::$_plotMark++]]);
+		} elseif ($markerID !== 'none') {
+			//	Use specified plot marker (if it exists)
+			if (isset(self::$_markSet[$markerID])) {
+				$seriesPlot->mark->SetType(self::$_markSet[$markerID]);
+			} else {
+				//	If the specified plot marker doesn't exist, use default plot marker (next marker in the series)
+				self::$_plotMark %= count(self::$_markSet);
+				$seriesPlot->mark->SetType(self::$_markSet[$plotMarkKeys[self::$_plotMark++]]);
+			}
+		} else {
+			//	Hide plot marker
+			$seriesPlot->mark->Hide();
+		}
+		$seriesPlot->mark->SetColor(self::$_colourSet[self::$_plotColour]);
+		$seriesPlot->mark->SetFillColor(self::$_colourSet[self::$_plotColour]);
+		$seriesPlot->SetColor(self::$_colourSet[self::$_plotColour++]);
+
+		return $seriesPlot;
+	}	//	function _formatPointMarker()
+
+
+	private function _formatDataSetLabels($groupID, $datasetLabels, $labelCount, $rotation = '') {
+		$datasetLabelFormatCode = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotCategoryByIndex(0)->getFormatCode();
+		if (!is_null($datasetLabelFormatCode)) {
+			//	Retrieve any label formatting code
+			$datasetLabelFormatCode = stripslashes($datasetLabelFormatCode);
+		}
+
+		$testCurrentIndex = 0;
+		foreach($datasetLabels as $i => $datasetLabel) {
+			if (is_array($datasetLabel)) {
+				if ($rotation == 'bar') {
+					$datasetLabels[$i] = implode(" ",$datasetLabel);
+				} else {
+					$datasetLabel = array_reverse($datasetLabel);
+					$datasetLabels[$i] = implode("\n",$datasetLabel);
+				}
+			} else {
+				//	Format labels according to any formatting code
+				if (!is_null($datasetLabelFormatCode)) {
+					$datasetLabels[$i] = PHPExcel_Style_NumberFormat::toFormattedString($datasetLabel,$datasetLabelFormatCode);
+				}
+			}
+			++$testCurrentIndex;
+		}
+
+		return $datasetLabels;
+	}	//	function _formatDataSetLabels()
+
+
+	private function _percentageSumCalculation($groupID,$seriesCount) {
+		//	Adjust our values to a percentage value across all series in the group
+		for($i = 0; $i < $seriesCount; ++$i) {
+			if ($i == 0) {
+				$sumValues = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotValuesByIndex($i)->getDataValues();
+			} else {
+				$nextValues = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotValuesByIndex($i)->getDataValues();
+				foreach($nextValues as $k => $value) {
+					if (isset($sumValues[$k])) {
+						$sumValues[$k] += $value;
+					} else {
+						$sumValues[$k] = $value;
+					}
+				}
+			}
+		}
+
+		return $sumValues;
+	}	//	function _percentageSumCalculation()
+
+
+	private function _percentageAdjustValues($dataValues,$sumValues) {
+		foreach($dataValues as $k => $dataValue) {
+			$dataValues[$k] = $dataValue / $sumValues[$k] * 100;
+		}
+
+		return $dataValues;
+	}	//	function _percentageAdjustValues()
+
+
+	private function _getCaption($captionElement) {
+		//	Read any caption
+		$caption = (!is_null($captionElement)) ? $captionElement->getCaption() : NULL;
+		//	Test if we have a title caption to display
+		if (!is_null($caption)) {
+			//	If we do, it could be a plain string or an array
+			if (is_array($caption)) {
+				//	Implode an array to a plain string
+				$caption = implode('',$caption);
+			}
+		}
+		return $caption;
+	}	//	function _getCaption()
+
+
+	private function _renderTitle() {
+		$title = $this->_getCaption($this->_chart->getTitle());
+		if (!is_null($title)) {
+			$this->_graph->title->Set($title);
+		}
+	}	//	function _renderTitle()
+
+
+	private function _renderLegend() {
+		$legend = $this->_chart->getLegend();
+		if (!is_null($legend)) {
+			$legendPosition = $legend->getPosition();
+			$legendOverlay = $legend->getOverlay();
+			switch ($legendPosition) {
+				case 'r'	:
+					$this->_graph->legend->SetPos(0.01,0.5,'right','center');	//	right
+					$this->_graph->legend->SetColumns(1);
+					break;
+				case 'l'	:
+					$this->_graph->legend->SetPos(0.01,0.5,'left','center');	//	left
+					$this->_graph->legend->SetColumns(1);
+					break;
+				case 't'	:
+					$this->_graph->legend->SetPos(0.5,0.01,'center','top');	//	top
+					break;
+				case 'b'	:
+					$this->_graph->legend->SetPos(0.5,0.99,'center','bottom');	//	bottom
+					break;
+				default		:
+					$this->_graph->legend->SetPos(0.01,0.01,'right','top');	//	top-right
+					$this->_graph->legend->SetColumns(1);
+					break;
+			}
+		} else {
+			$this->_graph->legend->Hide();
+		}
+	}	//	function _renderLegend()
+
+
+	private function _renderCartesianPlotArea($type='textlin') {
+		$this->_graph = new Graph(self::$_width,self::$_height);
+		$this->_graph->SetScale($type);
+
+		$this->_renderTitle();
+
+		//	Rotate for bar rather than column chart
+		$rotation = $this->_chart->getPlotArea()->getPlotGroupByIndex(0)->getPlotDirection();
+		$reverse = ($rotation == 'bar') ? true : false;
+
+		$xAxisLabel = $this->_chart->getXAxisLabel();
+		if (!is_null($xAxisLabel)) {
+			$title = $this->_getCaption($xAxisLabel);
+			if (!is_null($title)) {
+				$this->_graph->xaxis->SetTitle($title,'center');
+				$this->_graph->xaxis->title->SetMargin(35);
+				if ($reverse) {
+					$this->_graph->xaxis->title->SetAngle(90);
+					$this->_graph->xaxis->title->SetMargin(90);
+				}
+			}
+		}
+
+		$yAxisLabel = $this->_chart->getYAxisLabel();
+		if (!is_null($yAxisLabel)) {
+			$title = $this->_getCaption($yAxisLabel);
+			if (!is_null($title)) {
+				$this->_graph->yaxis->SetTitle($title,'center');
+				if ($reverse) {
+					$this->_graph->yaxis->title->SetAngle(0);
+					$this->_graph->yaxis->title->SetMargin(-55);
+				}
+			}
+		}
+	}	//	function _renderCartesianPlotArea()
+
+
+	private function _renderPiePlotArea($doughnut = False) {
+		$this->_graph = new PieGraph(self::$_width,self::$_height);
+
+		$this->_renderTitle();
+	}	//	function _renderPiePlotArea()
+
+
+	private function _renderRadarPlotArea() {
+		$this->_graph = new RadarGraph(self::$_width,self::$_height);
+		$this->_graph->SetScale('lin');
+
+		$this->_renderTitle();
+	}	//	function _renderRadarPlotArea()
+
+
+	private function _renderPlotLine($groupID, $filled = false, $combination = false, $dimensions = '2d') {
+		$grouping = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotGrouping();
+
+        $labelCount = count($this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotValuesByIndex(0)->getPointCount());
+		if ($labelCount > 0) {
+			$datasetLabels = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotCategoryByIndex(0)->getDataValues();
+			$datasetLabels = $this->_formatDataSetLabels($groupID, $datasetLabels, $labelCount);
+			$this->_graph->xaxis->SetTickLabels($datasetLabels);
+		}
+
+		$seriesCount = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotSeriesCount();
+		$seriesPlots = array();
+		if ($grouping == 'percentStacked') {
+			$sumValues = $this->_percentageSumCalculation($groupID,$seriesCount);
+		}
+
+		//	Loop through each data series in turn
+		for($i = 0; $i < $seriesCount; ++$i) {
+			$dataValues = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotValuesByIndex($i)->getDataValues();
+			$marker = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotValuesByIndex($i)->getPointMarker();
+
+			if ($grouping == 'percentStacked') {
+				$dataValues = $this->_percentageAdjustValues($dataValues,$sumValues);
+			}
+
+			//	Fill in any missing values in the $dataValues array
+			$testCurrentIndex = 0;
+			foreach($dataValues as $k => $dataValue) {
+				while($k != $testCurrentIndex) {
+					$dataValues[$testCurrentIndex] = null;
+					++$testCurrentIndex;
+				}
+				++$testCurrentIndex;
+			}
+
+			$seriesPlot = new LinePlot($dataValues);
+			if ($combination) {
+				$seriesPlot->SetBarCenter();
+			}
+
+			if ($filled) {
+				$seriesPlot->SetFilled(true);
+				$seriesPlot->SetColor('black');
+				$seriesPlot->SetFillColor(self::$_colourSet[self::$_plotColour++]);
+			} else {
+				//	Set the appropriate plot marker
+				$this->_formatPointMarker($seriesPlot,$marker);
+			}
+			$dataLabel = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotLabelByIndex($i)->getDataValue();
+			$seriesPlot->SetLegend($dataLabel);
+
+			$seriesPlots[] = $seriesPlot;
+		}
+
+		if ($grouping == 'standard') {
+			$groupPlot = $seriesPlots;
+		} else {
+			$groupPlot = new AccLinePlot($seriesPlots);
+		}
+		$this->_graph->Add($groupPlot);
+	}	//	function _renderPlotLine()
+
+
+	private function _renderPlotBar($groupID, $dimensions = '2d') {
+		$rotation = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotDirection();
+		//	Rotate for bar rather than column chart
+		if (($groupID == 0) && ($rotation == 'bar')) {
+			$this->_graph->Set90AndMargin();
+		}
+		$grouping = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotGrouping();
+
+        $labelCount = count($this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotValuesByIndex(0)->getPointCount());
+		if ($labelCount > 0) {
+			$datasetLabels = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotCategoryByIndex(0)->getDataValues();
+			$datasetLabels = $this->_formatDataSetLabels($groupID, $datasetLabels, $labelCount, $rotation);
+			//	Rotate for bar rather than column chart
+			if ($rotation == 'bar') {
+				$datasetLabels = array_reverse($datasetLabels);
+				$this->_graph->yaxis->SetPos('max');
+				$this->_graph->yaxis->SetLabelAlign('center','top');
+				$this->_graph->yaxis->SetLabelSide(SIDE_RIGHT);
+			}
+			$this->_graph->xaxis->SetTickLabels($datasetLabels);
+		}
+
+
+		$seriesCount = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotSeriesCount();
+		$seriesPlots = array();
+		if ($grouping == 'percentStacked') {
+			$sumValues = $this->_percentageSumCalculation($groupID,$seriesCount);
+		}
+
+		//	Loop through each data series in turn
+		for($j = 0; $j < $seriesCount; ++$j) {
+			$dataValues = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotValuesByIndex($j)->getDataValues();
+			if ($grouping == 'percentStacked') {
+				$dataValues = $this->_percentageAdjustValues($dataValues,$sumValues);
+			}
+
+			//	Fill in any missing values in the $dataValues array
+			$testCurrentIndex = 0;
+			foreach($dataValues as $k => $dataValue) {
+				while($k != $testCurrentIndex) {
+					$dataValues[$testCurrentIndex] = null;
+					++$testCurrentIndex;
+				}
+				++$testCurrentIndex;
+			}
+
+			//	Reverse the $dataValues order for bar rather than column chart
+			if ($rotation == 'bar') {
+				$dataValues = array_reverse($dataValues);
+			}
+			$seriesPlot = new BarPlot($dataValues);
+			$seriesPlot->SetColor('black');
+			$seriesPlot->SetFillColor(self::$_colourSet[self::$_plotColour++]);
+			if ($dimensions == '3d') {
+				$seriesPlot->SetShadow();
+			}
+			if (!$this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotLabelByIndex($j)) {
+				$dataLabel = '';
+			} else {
+				$dataLabel = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotLabelByIndex($j)->getDataValue();
+			}
+			$seriesPlot->SetLegend($dataLabel);
+
+			$seriesPlots[] = $seriesPlot;
+		}
+		//	Reverse the plot order for bar rather than column chart
+		if (($rotation == 'bar') && (!($grouping == 'percentStacked'))) {
+			$seriesPlots = array_reverse($seriesPlots);
+		}
+
+		if ($grouping == 'clustered') {
+			$groupPlot = new GroupBarPlot($seriesPlots);
+		} elseif ($grouping == 'standard') {
+			$groupPlot = new GroupBarPlot($seriesPlots);
+		} else {
+			$groupPlot = new AccBarPlot($seriesPlots);
+			if ($dimensions == '3d') {
+				$groupPlot->SetShadow();
+			}
+		}
+
+		$this->_graph->Add($groupPlot);
+	}	//	function _renderPlotBar()
+
+
+	private function _renderPlotScatter($groupID,$bubble) {
+		$grouping = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotGrouping();
+		$scatterStyle = $bubbleSize = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotStyle();
+
+		$seriesCount = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotSeriesCount();
+		$seriesPlots = array();
+
+		//	Loop through each data series in turn
+		for($i = 0; $i < $seriesCount; ++$i) {
+			$dataValuesY = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotCategoryByIndex($i)->getDataValues();
+			$dataValuesX = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotValuesByIndex($i)->getDataValues();
+
+			foreach($dataValuesY as $k => $dataValueY) {
+				$dataValuesY[$k] = $k;
+			}
+
+			$seriesPlot = new ScatterPlot($dataValuesX,$dataValuesY);
+			if ($scatterStyle == 'lineMarker') {
+				$seriesPlot->SetLinkPoints();
+				$seriesPlot->link->SetColor(self::$_colourSet[self::$_plotColour]);
+			} elseif ($scatterStyle == 'smoothMarker') {
+				$spline = new Spline($dataValuesY,$dataValuesX);
+				list($splineDataY,$splineDataX) = $spline->Get(count($dataValuesX) * self::$_width / 20);
+				$lplot = new LinePlot($splineDataX,$splineDataY);
+				$lplot->SetColor(self::$_colourSet[self::$_plotColour]);
+
+				$this->_graph->Add($lplot);
+			}
+
+			if ($bubble) {
+				$this->_formatPointMarker($seriesPlot,'dot');
+				$seriesPlot->mark->SetColor('black');
+				$seriesPlot->mark->SetSize($bubbleSize);
+			} else {
+				$marker = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotValuesByIndex($i)->getPointMarker();
+				$this->_formatPointMarker($seriesPlot,$marker);
+			}
+			$dataLabel = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotLabelByIndex($i)->getDataValue();
+			$seriesPlot->SetLegend($dataLabel);
+
+			$this->_graph->Add($seriesPlot);
+		}
+	}	//	function _renderPlotScatter()
+
+
+	private function _renderPlotRadar($groupID) {
+		$radarStyle = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotStyle();
+
+		$seriesCount = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotSeriesCount();
+		$seriesPlots = array();
+
+		//	Loop through each data series in turn
+		for($i = 0; $i < $seriesCount; ++$i) {
+			$dataValuesY = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotCategoryByIndex($i)->getDataValues();
+			$dataValuesX = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotValuesByIndex($i)->getDataValues();
+			$marker = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotValuesByIndex($i)->getPointMarker();
+
+			$dataValues = array();
+			foreach($dataValuesY as $k => $dataValueY) {
+				$dataValues[$k] = implode(' ',array_reverse($dataValueY));
+			}
+			$tmp = array_shift($dataValues);
+			$dataValues[] = $tmp;
+			$tmp = array_shift($dataValuesX);
+			$dataValuesX[] = $tmp;
+
+			$this->_graph->SetTitles(array_reverse($dataValues));
+
+			$seriesPlot = new RadarPlot(array_reverse($dataValuesX));
+
+			$dataLabel = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotLabelByIndex($i)->getDataValue();
+			$seriesPlot->SetColor(self::$_colourSet[self::$_plotColour++]);
+			if ($radarStyle == 'filled') {
+				$seriesPlot->SetFillColor(self::$_colourSet[self::$_plotColour]);
+			}
+			$this->_formatPointMarker($seriesPlot,$marker);
+			$seriesPlot->SetLegend($dataLabel);
+
+			$this->_graph->Add($seriesPlot);
+		}
+	}	//	function _renderPlotRadar()
+
+
+	private function _renderPlotContour($groupID) {
+		$contourStyle = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotStyle();
+
+		$seriesCount = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotSeriesCount();
+		$seriesPlots = array();
+
+		$dataValues = array();
+		//	Loop through each data series in turn
+		for($i = 0; $i < $seriesCount; ++$i) {
+			$dataValuesY = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotCategoryByIndex($i)->getDataValues();
+			$dataValuesX = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotValuesByIndex($i)->getDataValues();
+
+			$dataValues[$i] = $dataValuesX;
+		}
+		$seriesPlot = new ContourPlot($dataValues);
+
+		$this->_graph->Add($seriesPlot);
+	}	//	function _renderPlotContour()
+
+
+	private function _renderPlotStock($groupID) {
+		$seriesCount = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotSeriesCount();
+		$plotOrder = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotOrder();
+
+		$dataValues = array();
+		//	Loop through each data series in turn and build the plot arrays
+		foreach($plotOrder as $i => $v) {
+			$dataValuesX = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotValuesByIndex($v)->getDataValues();
+			foreach($dataValuesX as $j => $dataValueX) {
+				$dataValues[$plotOrder[$i]][$j] = $dataValueX;
+			}
+		}
+		if(empty($dataValues)) {
+			return;
+		}
+
+		$dataValuesPlot = array();
+        // Flatten the plot arrays to a single dimensional array to work with jpgraph
+		for($j = 0; $j < count($dataValues[0]); $j++) {
+			for($i = 0; $i < $seriesCount; $i++) {
+				$dataValuesPlot[] = $dataValues[$i][$j];
+			}
+		}
+
+        // Set the x-axis labels
+        $labelCount = count($this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotValuesByIndex(0)->getPointCount());
+		if ($labelCount > 0) {
+			$datasetLabels = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotCategoryByIndex(0)->getDataValues();
+			$datasetLabels = $this->_formatDataSetLabels($groupID, $datasetLabels, $labelCount);
+			$this->_graph->xaxis->SetTickLabels($datasetLabels);
+		}
+
+		$seriesPlot = new StockPlot($dataValuesPlot);
+		$seriesPlot->SetWidth(20);
+
+		$this->_graph->Add($seriesPlot);
+	}	//	function _renderPlotStock()
+
+
+	private function _renderAreaChart($groupCount, $dimensions = '2d') {
+		require_once('jpgraph_line.php');
+
+		$this->_renderCartesianPlotArea();
+
+		for($i = 0; $i < $groupCount; ++$i) {
+			$this->_renderPlotLine($i,True,False,$dimensions);
+		}
+	}	//	function _renderAreaChart()
+
+
+	private function _renderLineChart($groupCount, $dimensions = '2d') {
+		require_once('jpgraph_line.php');
+
+		$this->_renderCartesianPlotArea();
+
+		for($i = 0; $i < $groupCount; ++$i) {
+			$this->_renderPlotLine($i,False,False,$dimensions);
+		}
+	}	//	function _renderLineChart()
+
+
+	private function _renderBarChart($groupCount, $dimensions = '2d') {
+		require_once('jpgraph_bar.php');
+
+		$this->_renderCartesianPlotArea();
+
+		for($i = 0; $i < $groupCount; ++$i) {
+			$this->_renderPlotBar($i,$dimensions);
+		}
+	}	//	function _renderBarChart()
+
+
+	private function _renderScatterChart($groupCount) {
+		require_once('jpgraph_scatter.php');
+		require_once('jpgraph_regstat.php');
+		require_once('jpgraph_line.php');
+
+		$this->_renderCartesianPlotArea('linlin');
+
+		for($i = 0; $i < $groupCount; ++$i) {
+			$this->_renderPlotScatter($i,false);
+		}
+	}	//	function _renderScatterChart()
+
+
+	private function _renderBubbleChart($groupCount) {
+		require_once('jpgraph_scatter.php');
+
+		$this->_renderCartesianPlotArea('linlin');
+
+		for($i = 0; $i < $groupCount; ++$i) {
+			$this->_renderPlotScatter($i,true);
+		}
+	}	//	function _renderBubbleChart()
+
+
+	private function _renderPieChart($groupCount, $dimensions = '2d', $doughnut = False, $multiplePlots = False) {
+		require_once('jpgraph_pie.php');
+		if ($dimensions == '3d') {
+			require_once('jpgraph_pie3d.php');
+		}
+
+		$this->_renderPiePlotArea($doughnut);
+
+		$iLimit = ($multiplePlots) ? $groupCount : 1;
+		for($groupID = 0; $groupID < $iLimit; ++$groupID) {
+			$grouping = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotGrouping();
+			$exploded = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotStyle();
+			if ($groupID == 0) {
+		        $labelCount = count($this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotValuesByIndex(0)->getPointCount());
+				if ($labelCount > 0) {
+					$datasetLabels = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotCategoryByIndex(0)->getDataValues();
+					$datasetLabels = $this->_formatDataSetLabels($groupID, $datasetLabels, $labelCount);
+				}
+			}
+
+			$seriesCount = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotSeriesCount();
+			$seriesPlots = array();
+			//	For pie charts, we only display the first series: doughnut charts generally display all series
+			$jLimit = ($multiplePlots) ? $seriesCount : 1;
+			//	Loop through each data series in turn
+			for($j = 0; $j < $jLimit; ++$j) {
+				$dataValues = $this->_chart->getPlotArea()->getPlotGroupByIndex($groupID)->getPlotValuesByIndex($j)->getDataValues();
+
+				//	Fill in any missing values in the $dataValues array
+				$testCurrentIndex = 0;
+				foreach($dataValues as $k => $dataValue) {
+					while($k != $testCurrentIndex) {
+						$dataValues[$testCurrentIndex] = null;
+						++$testCurrentIndex;
+					}
+					++$testCurrentIndex;
+				}
+
+				if ($dimensions == '3d') {
+					$seriesPlot = new PiePlot3D($dataValues);
+				} else {
+					if ($doughnut) {
+						$seriesPlot = new PiePlotC($dataValues);
+					} else {
+						$seriesPlot = new PiePlot($dataValues);
+					}
+				}
+
+				if ($multiplePlots) {
+					$seriesPlot->SetSize(($jLimit-$j) / ($jLimit * 4));
+				}
+
+				if ($doughnut) {
+					$seriesPlot->SetMidColor('white');
+				}
+
+				$seriesPlot->SetColor(self::$_colourSet[self::$_plotColour++]);
+				if (count($datasetLabels) > 0)
+					$seriesPlot->SetLabels(array_fill(0,count($datasetLabels),''));
+				if ($dimensions != '3d') {
+					$seriesPlot->SetGuideLines(false);
+				}
+				if ($j == 0) {
+					if ($exploded) {
+						$seriesPlot->ExplodeAll();
+					}
+					$seriesPlot->SetLegends($datasetLabels);
+				}
+
+				$this->_graph->Add($seriesPlot);
+			}
+		}
+	}	//	function _renderPieChart()
+
+
+	private function _renderRadarChart($groupCount) {
+		require_once('jpgraph_radar.php');
+
+		$this->_renderRadarPlotArea();
+
+		for($groupID = 0; $groupID < $groupCount; ++$groupID) {
+			$this->_renderPlotRadar($groupID);
+		}
+	}	//	function _renderRadarChart()
+
+
+	private function _renderStockChart($groupCount) {
+		require_once('jpgraph_stock.php');
+
+		$this->_renderCartesianPlotArea('intint');
+
+		for($groupID = 0; $groupID < $groupCount; ++$groupID) {
+			$this->_renderPlotStock($groupID);
+		}
+	}	//	function _renderStockChart()
+
+
+	private function _renderContourChart($groupCount,$dimensions) {
+		require_once('jpgraph_contour.php');
+
+		$this->_renderCartesianPlotArea('intint');
+
+		for($i = 0; $i < $groupCount; ++$i) {
+			$this->_renderPlotContour($i);
+		}
+	}	//	function _renderContourChart()
+
+
+	private function _renderCombinationChart($groupCount,$dimensions,$outputDestination) {
+		require_once('jpgraph_line.php');
+		require_once('jpgraph_bar.php');
+		require_once('jpgraph_scatter.php');
+		require_once('jpgraph_regstat.php');
+		require_once('jpgraph_line.php');
+
+		$this->_renderCartesianPlotArea();
+
+		for($i = 0; $i < $groupCount; ++$i) {
+			$dimensions = null;
+			$chartType = $this->_chart->getPlotArea()->getPlotGroupByIndex($i)->getPlotType();
+			switch ($chartType) {
+				case 'area3DChart' :
+					$dimensions = '3d';
+				case 'areaChart' :
+					$this->_renderPlotLine($i,True,True,$dimensions);
+					break;
+				case 'bar3DChart' :
+					$dimensions = '3d';
+				case 'barChart' :
+					$this->_renderPlotBar($i,$dimensions);
+					break;
+				case 'line3DChart' :
+					$dimensions = '3d';
+				case 'lineChart' :
+					$this->_renderPlotLine($i,False,True,$dimensions);
+					break;
+				case 'scatterChart' :
+					$this->_renderPlotScatter($i,false);
+					break;
+				case 'bubbleChart' :
+					$this->_renderPlotScatter($i,true);
+					break;
+				default	:
+					$this->_graph = null;
+					return false;
+			}
+		}
+
+		$this->_renderLegend();
+
+		$this->_graph->Stroke($outputDestination);
+		return true;
+	}	//	function _renderCombinationChart()
+
+
+	public function render($outputDestination) {
+        self::$_plotColour = 0;
+
+		$groupCount = $this->_chart->getPlotArea()->getPlotGroupCount();
+
+		$dimensions = null;
+		if ($groupCount == 1) {
+			$chartType = $this->_chart->getPlotArea()->getPlotGroupByIndex(0)->getPlotType();
+		} else {
+			$chartTypes = array();
+			for($i = 0; $i < $groupCount; ++$i) {
+				$chartTypes[] = $this->_chart->getPlotArea()->getPlotGroupByIndex($i)->getPlotType();
+			}
+			$chartTypes = array_unique($chartTypes);
+			if (count($chartTypes) == 1) {
+				$chartType = array_pop($chartTypes);
+			} elseif (count($chartTypes) == 0) {
+				echo 'Chart is not yet implemented<br />';
+				return false;
+			} else {
+				return $this->_renderCombinationChart($groupCount,$dimensions,$outputDestination);
+			}
+		}
+
+		switch ($chartType) {
+			case 'area3DChart' :
+				$dimensions = '3d';
+			case 'areaChart' :
+				$this->_renderAreaChart($groupCount,$dimensions);
+				break;
+			case 'bar3DChart' :
+				$dimensions = '3d';
+			case 'barChart' :
+				$this->_renderBarChart($groupCount,$dimensions);
+				break;
+			case 'line3DChart' :
+				$dimensions = '3d';
+			case 'lineChart' :
+				$this->_renderLineChart($groupCount,$dimensions);
+				break;
+			case 'pie3DChart' :
+				$dimensions = '3d';
+			case 'pieChart' :
+				$this->_renderPieChart($groupCount,$dimensions,False,False);
+				break;
+			case 'doughnut3DChart' :
+				$dimensions = '3d';
+			case 'doughnutChart' :
+				$this->_renderPieChart($groupCount,$dimensions,True,True);
+				break;
+			case 'scatterChart' :
+				$this->_renderScatterChart($groupCount);
+				break;
+			case 'bubbleChart' :
+				$this->_renderBubbleChart($groupCount);
+				break;
+			case 'radarChart' :
+				$this->_renderRadarChart($groupCount);
+				break;
+			case 'surface3DChart' :
+				$dimensions = '3d';
+			case 'surfaceChart' :
+				$this->_renderContourChart($groupCount,$dimensions);
+				break;
+			case 'stockChart' :
+				$this->_renderStockChart($groupCount,$dimensions);
+				break;
+			default	:
+				echo $chartType.' is not yet implemented<br />';
+				return false;
+		}
+		$this->_renderLegend();
+
+		$this->_graph->Stroke($outputDestination);
+		return true;
+	}	//	function render()
+
+
+	/**
+	 * Create a new PHPExcel_Chart_Renderer_jpgraph
+	 */
+	public function __construct(PHPExcel_Chart $chart)
+	{
+		$this->_graph	= null;
+		$this->_chart	= $chart;
+	}	//	function __construct()
+
+}	//	PHPExcel_Chart_Renderer_jpgraph

lib/Classes/PHPExcel/Chart/Title.php

+<?php
+/**
+ * PHPExcel
+ *
+ * Copyright (c) 2006 - 2014 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_Chart
+ * @copyright	Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
+ * @license		http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt	LGPL
+ * @version		1.8.0, 2014-03-02
+ */
+
+
+/**
+ * PHPExcel_Chart_Title
+ *
+ * @category	PHPExcel
+ * @package		PHPExcel_Chart
+ * @copyright	Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
+ */
+class PHPExcel_Chart_Title
+{
+
+	/**
+	 * Title Caption
+	 *
+	 * @var string
+	 */
+	private $_caption = null;
+
+	/**
+	 * Title Layout
+	 *
+	 * @var PHPExcel_Chart_Layout
+	 */
+	private $_layout = null;
+
+	/**
+	 * Create a new PHPExcel_Chart_Title
+	 */
+	public function __construct($caption = null, PHPExcel_Chart_Layout $layout = null)
+	{
+		$this->_caption = $caption;
+		$this->_layout = $layout;
+	}
+
+	/**
+	 * Get caption
+	 *
+	 * @return string
+	 */
+	public function getCaption() {
+		return $this->_caption;
+	}
+
+	/**
+	 * Set caption
+	 *
+	 * @param string $caption
+     * @return PHPExcel_Chart_Title
+	 */
+	public function setCaption($caption = null) {
+		$this->_caption = $caption;
+        
+        return $this;
+	}
+
+	/**
+	 * Get Layout
+	 *
+	 * @return PHPExcel_Chart_Layout
+	 */
+	public function getLayout() {
+		return $this->_layout;
+	}
+
+}

lib/Classes/PHPExcel/Comment.php

+<?php
+/**
+ * PHPExcel
+ *
+ * Copyright (c) 2006 - 2014 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
+ * @copyright  Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
+ * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt    LGPL
+ * @version    1.8.0, 2014-03-02
+ */
+
+
+/**
+ * PHPExcel_Comment
+ *
+ * @category   PHPExcel
+ * @package    PHPExcel
+ * @copyright  Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
+ */
+class PHPExcel_Comment implements PHPExcel_IComparable
+{
+    /**
+     * Author
+     *
+     * @var string
+     */
+    private $_author;
+
+    /**
+     * Rich text comment
+     *
+     * @var PHPExcel_RichText
+     */
+    private $_text;
+
+    /**
+     * Comment width (CSS style, i.e. XXpx or YYpt)
+     *
+     * @var string
+     */
+    private $_width = '96pt';
+
+    /**
+     * Left margin (CSS style, i.e. XXpx or YYpt)
+     *
+     * @var string
+     */
+    private $_marginLeft = '59.25pt';
+
+    /**
+     * Top margin (CSS style, i.e. XXpx or YYpt)
+     *
+     * @var string
+     */
+    private $_marginTop = '1.5pt';
+
+    /**
+     * Visible
+     *
+     * @var boolean
+     */
+    private $_visible = false;
+
+    /**
+     * Comment height (CSS style, i.e. XXpx or YYpt)
+     *
+     * @var string
+     */
+    private $_height = '55.5pt';
+
+    /**
+     * Comment fill color
+     *
+     * @var PHPExcel_Style_Color
+     */
+    private $_fillColor;
+
+    /**
+     * Alignment
+     *
+     * @var string
+     */
+    private $_alignment;
+
+    /**
+     * Create a new PHPExcel_Comment
+     *
+     * @throws PHPExcel_Exception
+     */
+    public function __construct()
+    {
+        // Initialise variables
+        $this->_author		= 'Author';
+        $this->_text		= new PHPExcel_RichText();
+        $this->_fillColor	= new PHPExcel_Style_Color('FFFFFFE1');
+        $this->_alignment	= PHPExcel_Style_Alignment::HORIZONTAL_GENERAL;
+    }
+
+    /**
+     * Get Author
+     *
+     * @return string
+     */
+    public function getAuthor() {
+        return $this->_author;
+    }
+
+    /**
+     * Set Author
+     *
+     * @param string $pValue
+     * @return PHPExcel_Comment
+     */
+    public function setAuthor($pValue = '') {
+        $this->_author = $pValue;
+        return $this;
+    }
+
+    /**
+     * Get Rich text comment
+     *
+     * @return PHPExcel_RichText
+     */
+    public function getText() {
+        return $this->_text;
+    }
+
+    /**
+     * Set Rich text comment
+     *
+     * @param PHPExcel_RichText $pValue
+     * @return PHPExcel_Comment
+     */
+    public function setText(PHPExcel_RichText $pValue) {
+        $this->_text = $pValue;
+        return $this;
+    }
+
+    /**
+     * Get comment width (CSS style, i.e. XXpx or YYpt)
+     *
+     * @return string
+     */
+    public function getWidth() {
+        return $this->_width;
+    }
+
+    /**
+     * Set comment width (CSS style, i.e. XXpx or YYpt)
+     *
+     * @param string $value
+     * @return PHPExcel_Comment
+     */
+    public function setWidth($value = '96pt') {
+        $this->_width = $value;
+        return $this;
+    }
+
+    /**
+     * Get comment height (CSS style, i.e. XXpx or YYpt)
+     *
+     * @return string
+     */
+    public function getHeight() {
+        return $this->_height;
+    }
+
+    /**
+     * Set comment height (CSS style, i.e. XXpx or YYpt)
+     *
+     * @param string $value
+     * @return PHPExcel_Comment
+     */
+    public function setHeight($value = '55.5pt') {
+        $this->_height = $value;
+        return $this;
+    }
+
+    /**
+     * Get left margin (CSS style, i.e. XXpx or YYpt)
+     *
+     * @return string
+     */
+    public function getMarginLeft() {
+        return $this->_marginLeft;
+    }
+
+    /**
+     * Set left margin (CSS style, i.e. XXpx or YYpt)
+     *
+     * @param string $value
+     * @return PHPExcel_Comment
+     */
+    public function setMarginLeft($value = '59.25pt') {
+        $this->_marginLeft = $value;
+        return $this;
+    }
+
+    /**
+     * Get top margin (CSS style, i.e. XXpx or YYpt)
+     *
+     * @return string
+     */
+    public function getMarginTop() {
+        return $this->_marginTop;
+    }
+
+    /**
+     * Set top margin (CSS style, i.e. XXpx or YYpt)
+     *
+     * @param string $value
+     * @return PHPExcel_Comment
+     */
+    public function setMarginTop($value = '1.5pt') {
+        $this->_marginTop = $value;
+        return $this;
+    }
+
+    /**
+     * Is the comment visible by default?
+     *
+     * @return boolean
+     */
+    public function getVisible() {
+        return $this->_visible;
+    }
+
+    /**
+     * Set comment default visibility
+     *
+     * @param boolean $value
+     * @return PHPExcel_Comment
+     */
+    public function setVisible($value = false) {
+        $this->_visible = $value;
+        return $this;
+    }
+
+    /**
+     * Get fill color
+     *
+     * @return PHPExcel_Style_Color
+     */
+    public function getFillColor() {
+        return $this->_fillColor;
+    }
+
+    /**
+     * Set Alignment
+     *
+     * @param string $pValue
+     * @return PHPExcel_Comment
+     */
+    public function setAlignment($pValue = PHPExcel_Style_Alignment::HORIZONTAL_GENERAL) {
+        $this->_alignment = $pValue;
+        return $this;
+    }
+
+    /**
+     * Get Alignment
+     *
+     * @return string
+     */
+    public function getAlignment() {
+        return $this->_alignment;
+    }
+
+    /**
+     * Get hash code
+     *
+     * @return string    Hash code
+     */
+    public function getHashCode() {
+        return md5(
+              $this->_author
+            . $this->_text->getHashCode()
+            . $this->_width
+            . $this->_height
+            . $this->_marginLeft
+            . $this->_marginTop
+            . ($this->_visible ? 1 : 0)
+            . $this->_fillColor->getHashCode()
+            . $this->_alignment
+            . __CLASS__
+        );
+    }
+
+    /**
+     * 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)) {
+                $this->$key = clone $value;
+            } else {
+                $this->$key = $value;
+            }
+        }
+    }
+
+    /**
+     * Convert to string
+     *
+     * @return string
+     */
+    public function __toString() {
+        return $this->_text->getPlainText();
+    }
+
+}

lib/Classes/PHPExcel/DocumentProperties.php

+<?php
+/**
+ * PHPExcel
+ *
+ * Copyright (c) 2006 - 2014 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
+ * @copyright    Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
+ * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt    LGPL
+ * @version    1.8.0, 2014-03-02
+ */
+
+
+/**
+ * PHPExcel_DocumentProperties
+ *
+ * @category    PHPExcel
+ * @package        PHPExcel
+ * @copyright    Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
+ */
+class PHPExcel_DocumentProperties
+{
+    /** constants */
+    const PROPERTY_TYPE_BOOLEAN	= 'b';
+    const PROPERTY_TYPE_INTEGER = 'i';
+    const PROPERTY_TYPE_FLOAT   = 'f';
+    const PROPERTY_TYPE_DATE    = 'd';
+    const PROPERTY_TYPE_STRING  = 's';
+    const PROPERTY_TYPE_UNKNOWN = 'u';
+
+    /**
+     * Creator
+     *
+     * @var string
+     */
+    private $_creator    = 'Unknown Creator';
+
+    /**
+     * LastModifiedBy
+     *
+     * @var string
+     */
+    private $_lastModifiedBy;
+
+    /**
+     * Created
+     *
+     * @var datetime
+     */
+    private $_created;
+
+    /**
+     * Modified
+     *
+     * @var datetime
+     */
+    private $_modified;
+
+    /**
+     * Title
+     *
+     * @var string
+     */
+    private $_title            = 'Untitled Spreadsheet';
+
+    /**
+     * Description
+     *
+     * @var string
+     */
+    private $_description    = '';
+
+    /**
+     * Subject
+     *
+     * @var string
+     */
+    private $_subject        = '';
+
+    /**
+     * Keywords
+     *
+     * @var string
+     */
+    private $_keywords        = '';
+
+    /**
+     * Category
+     *
+     * @var string
+     */
+    private $_category        = '';
+
+    /**
+     * Manager
+     *
+     * @var string
+     */
+    private $_manager        = '';
+
+    /**
+     * Company
+     *
+     * @var string
+     */
+    private $_company        = 'Microsoft Corporation';
+
+    /**
+     * Custom Properties
+     *
+     * @var string
+     */
+    private $_customProperties    = array();
+
+
+    /**
+     * Create a new PHPExcel_DocumentProperties
+     */
+    public function __construct()
+    {
+        // Initialise values
+        $this->_lastModifiedBy    = $this->_creator;
+        $this->_created        = time();
+        $this->_modified    = time();
+    }
+
+    /**
+     * Get Creator
+     *
+     * @return string
+     */
+    public function getCreator() {
+        return $this->_creator;
+    }
+
+    /**
+     * Set Creator
+     *
+     * @param string $pValue
+     * @return PHPExcel_DocumentProperties
+     */
+    public function setCreator($pValue = '') {
+        $this->_creator = $pValue;
+        return $this;
+    }
+
+    /**
+     * Get Last Modified By
+     *
+     * @return string
+     */
+    public function getLastModifiedBy() {
+        return $this->_lastModifiedBy;
+    }
+
+    /**
+     * Set Last Modified By
+     *
+     * @param string $pValue
+     * @return PHPExcel_DocumentProperties
+     */
+    public function setLastModifiedBy($pValue = '') {
+        $this->_lastModifiedBy = $pValue;
+        return $this;
+    }
+
+    /**
+     * Get Created
+     *
+     * @return datetime
+     */
+    public function getCreated() {
+        return $this->_created;
+    }
+
+    /**
+     * Set Created
+     *
+     * @param datetime $pValue
+     * @return PHPExcel_DocumentProperties
+     */
+    public function setCreated($pValue = null) {
+        if ($pValue === NULL) {
+            $pValue = time();
+        } elseif (is_string($pValue)) {
+            if (is_numeric($pValue)) {
+                $pValue = intval($pValue);
+            } else {
+                $pValue = strtotime($pValue);
+            }
+        }
+
+        $this->_created = $pValue;
+        return $this;
+    }
+
+    /**
+     * Get Modified
+     *
+     * @return datetime
+     */
+    public function getModified() {
+        return $this->_modified;
+    }
+
+    /**
+     * Set Modified
+     *
+     * @param datetime $pValue
+     * @return PHPExcel_DocumentProperties
+     */
+    public function setModified($pValue = null) {
+        if ($pValue === NULL) {
+            $pValue = time();
+        } elseif (is_string($pValue)) {
+            if (is_numeric($pValue)) {
+                $pValue = intval($pValue);
+            } else {
+                $pValue = strtotime($pValue);
+            }
+        }
+
+        $this->_modified = $pValue;
+        return $this;
+    }
+
+    /**
+     * Get Title
+     *
+     * @return string
+     */
+    public function getTitle() {
+        return $this->_title;
+    }
+
+    /**
+     * Set Title
+     *
+     * @param string $pValue
+     * @return PHPExcel_DocumentProperties
+     */
+    public function setTitle($pValue = '') {
+        $this->_title = $pValue;
+        return $this;
+    }
+
+    /**
+     * Get Description
+     *
+     * @return string
+     */
+    public function getDescription() {
+        return $this->_description;
+    }
+
+    /**
+     * Set Description
+     *
+     * @param string $pValue
+     * @return PHPExcel_DocumentProperties
+     */
+    public function setDescription($pValue = '') {
+        $this->_description = $pValue;
+        return $this;
+    }
+
+    /**
+     * Get Subject
+     *
+     * @return string
+     */
+    public function getSubject() {
+        return $this->_subject;
+    }
+
+    /**
+     * Set Subject
+     *
+     * @param string $pValue
+     * @return PHPExcel_DocumentProperties
+     */
+    public function setSubject($pValue = '') {
+        $this->_subject = $pValue;
+        return $this;
+    }
+
+    /**
+     * Get Keywords
+     *
+     * @return string
+     */
+    public function getKeywords() {
+        return $this->_keywords;
+    }
+
+    /**
+     * Set Keywords
+     *
+     * @param string $pValue
+     * @return PHPExcel_DocumentProperties
+     */
+    public function setKeywords($pValue = '') {
+        $this->_keywords = $pValue;
+        return $this;
+    }
+
+    /**
+     * Get Category
+     *
+     * @return string
+     */
+    public function getCategory() {
+        return $this->_category;
+    }
+
+    /**
+     * Set Category
+     *
+     * @param string $pValue
+     * @return PHPExcel_DocumentProperties
+     */
+    public function setCategory($pValue = '') {
+        $this->_category = $pValue;
+        return $this;
+    }
+
+    /**
+     * Get Company
+     *
+     * @return string
+     */
+    public function getCompany() {
+        return $this->_company;
+    }
+
+    /**
+     * Set Company
+     *
+     * @param string $pValue
+     * @return PHPExcel_DocumentProperties
+     */
+    public function setCompany($pValue = '') {
+        $this->_company = $pValue;
+        return $this;
+    }
+
+    /**
+     * Get Manager
+     *
+     * @return string
+     */
+    public function getManager() {
+        return $this->_manager;
+    }
+
+    /**
+     * Set Manager
+     *
+     * @param string $pValue
+     * @return PHPExcel_DocumentProperties
+     */
+    public function setManager($pValue = '') {
+        $this->_manager = $pValue;
+        return $this;
+    }
+
+    /**
+     * Get a List of Custom Property Names
+     *
+     * @return array of string
+     */
+    public function getCustomProperties() {
+        return array_keys($this->_customProperties);
+    }
+
+    /**
+     * Check if a Custom Property is defined
+     *
+     * @param string $propertyName
+     * @return boolean
+     */
+    public function isCustomPropertySet($propertyName) {
+        return isset($this->_customProperties[$propertyName]);
+    }
+
+    /**
+     * Get a Custom Property Value
+     *
+     * @param string $propertyName
+     * @return string
+     */
+    public function getCustomPropertyValue($propertyName) {
+        if (isset($this->_customProperties[$propertyName])) {
+            return $this->_customProperties[$propertyName]['value'];
+        }
+
+    }
+
+    /**
+     * Get a Custom Property Type
+     *
+     * @param string $propertyName
+     * @return string
+     */
+    public function getCustomPropertyType($propertyName) {
+        if (isset($this->_customProperties[$propertyName])) {
+            return $this->_customProperties[$propertyName]['type'];
+        }
+
+    }
+
+    /**
+     * Set a Custom Property
+     *
+     * @param string $propertyName
+     * @param mixed $propertyValue
+     * @param string $propertyType
+     * 	 'i'    : Integer
+     *   'f' : Floating Point
+     *   's' : String
+     *   'd' : Date/Time
+     *   'b' : Boolean
+     * @return PHPExcel_DocumentProperties
+     */
+    public function setCustomProperty($propertyName,$propertyValue='',$propertyType=NULL) {
+        if (($propertyType === NULL) || (!in_array($propertyType,array(self::PROPERTY_TYPE_INTEGER,
+                                                                       self::PROPERTY_TYPE_FLOAT,
+                                                                       self::PROPERTY_TYPE_STRING,
+                                                                       self::PROPERTY_TYPE_DATE,
+                                                                       self::PROPERTY_TYPE_BOOLEAN)))) {
+            if ($propertyValue === NULL) {
+                $propertyType = self::PROPERTY_TYPE_STRING;
+            } elseif (is_float($propertyValue)) {
+                $propertyType = self::PROPERTY_TYPE_FLOAT;
+            } elseif(is_int($propertyValue)) {
+                $propertyType = self::PROPERTY_TYPE_INTEGER;
+            } elseif (is_bool($propertyValue)) {
+                $propertyType = self::PROPERTY_TYPE_BOOLEAN;
+            } else {
+                $propertyType = self::PROPERTY_TYPE_STRING;
+            }
+        }
+
+        $this->_customProperties[$propertyName] = array('value' => $propertyValue, 'type' => $propertyType);
+        return $this;
+    }
+
+    /**
+     * 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)) {
+                $this->$key = clone $value;
+            } else {
+                $this->$key = $value;
+            }
+        }
+    }
+
+    public static function convertProperty($propertyValue,$propertyType) {
+        switch ($propertyType) {
+            case 'empty'    :    //    Empty
+                return '';
+                break;
+            case 'null'        :    //    Null
+                return NULL;
+                break;
+            case 'i1'        :    //    1-Byte Signed Integer
+            case 'i2'        :    //    2-Byte Signed Integer
+            case 'i4'        :    //    4-Byte Signed Integer
+            case 'i8'        :    //    8-Byte Signed Integer
+            case 'int'        :    //    Integer
+                return (int) $propertyValue;
+                break;
+            case 'ui1'        :    //    1-Byte Unsigned Integer
+            case 'ui2'        :    //    2-Byte Unsigned Integer
+            case 'ui4'        :    //    4-Byte Unsigned Integer
+            case 'ui8'        :    //    8-Byte Unsigned Integer
+            case 'uint'        :    //    Unsigned Integer
+                return abs((int) $propertyValue);
+                break;
+            case 'r4'        :    //    4-Byte Real Number
+            case 'r8'        :    //    8-Byte Real Number
+            case 'decimal'    :    //    Decimal
+                return (float) $propertyValue;
+                break;
+            case 'lpstr'    :    //    LPSTR
+            case 'lpwstr'    :    //    LPWSTR
+            case 'bstr'        :    //    Basic String
+                return $propertyValue;
+                break;
+            case 'date'        :    //    Date and Time
+            case 'filetime'    :    //    File Time
+                return strtotime($propertyValue);
+                break;
+            case 'bool'        :    //    Boolean
+                return ($propertyValue == 'true') ? True : False;
+                break;
+            case 'cy'        :    //    Currency
+            case 'error'    :    //    Error Status Code
+            case 'vector'    :    //    Vector
+            case 'array'    :    //    Array
+            case 'blob'        :    //    Binary Blob
+            case 'oblob'    :    //    Binary Blob Object
+            case 'stream'    :    //    Binary Stream
+            case 'ostream'    :    //    Binary Stream Object
+            case 'storage'    :    //    Binary Storage
+            case 'ostorage'    :    //    Binary Storage Object
+            case 'vstream'    :    //    Binary Versioned Stream
+            case 'clsid'    :    //    Class ID
+            case 'cf'        :    //    Clipboard Data
+                return $propertyValue;
+                break;
+        }
+        return $propertyValue;
+    }
+
+    public static function convertPropertyType($propertyType) {
+        switch ($propertyType) {
+            case 'i1'        :    //    1-Byte Signed Integer
+            case 'i2'        :    //    2-Byte Signed Integer
+            case 'i4'        :    //    4-Byte Signed Integer
+            case 'i8'        :    //    8-Byte Signed Integer
+            case 'int'        :    //    Integer
+            case 'ui1'        :    //    1-Byte Unsigned Integer
+            case 'ui2'        :    //    2-Byte Unsigned Integer
+            case 'ui4'        :    //    4-Byte Unsigned Integer
+            case 'ui8'        :    //    8-Byte Unsigned Integer
+            case 'uint'        :    //    Unsigned Integer
+                return self::PROPERTY_TYPE_INTEGER;
+                break;
+            case 'r4'        :    //    4-Byte Real Number
+            case 'r8'        :    //    8-Byte Real Number
+            case 'decimal'    :    //    Decimal
+                return self::PROPERTY_TYPE_FLOAT;
+                break;
+            case 'empty'    :    //    Empty
+            case 'null'        :    //    Null
+            case 'lpstr'    :    //    LPSTR
+            case 'lpwstr'    :    //    LPWSTR
+            case 'bstr'        :    //    Basic String
+                return self::PROPERTY_TYPE_STRING;
+                break;
+            case 'date'        :    //    Date and Time
+            case 'filetime'    :    //    File Time
+                return self::PROPERTY_TYPE_DATE;
+                break;
+            case 'bool'        :    //    Boolean
+                return self::PROPERTY_TYPE_BOOLEAN;
+                break;
+            case 'cy'        :    //    Currency
+            case 'error'    :    //    Error Status Code
+            case 'vector'    :    //    Vector
+            case 'array'    :    //    Array
+            case 'blob'        :    //    Binary Blob
+            case 'oblob'    :    //    Binary Blob Object
+            case 'stream'    :    //    Binary Stream
+            case 'ostream'    :    //    Binary Stream Object
+            case 'storage'    :    //    Binary Storage
+            case 'ostorage'    :    //    Binary Storage Object
+            case 'vstream'    :    //    Binary Versioned Stream
+            case 'clsid'    :    //    Class ID
+            case 'cf'        :    //    Clipboard Data
+                return self::PROPERTY_TYPE_UNKNOWN;
+                break;
+        }
+        return self::PROPERTY_TYPE_UNKNOWN;
+    }
+
+}

lib/Classes/PHPExcel/DocumentSecurity.php

+<?php
+/**
+ * PHPExcel
+ *
+ * Copyright (c) 2006 - 2014 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
+ * @copyright  Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
+ * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt	LGPL
+ * @version    1.8.0, 2014-03-02
+ */
+
+
+/**
+ * PHPExcel_DocumentSecurity
+ *
+ * @category   PHPExcel
+ * @package    PHPExcel
+ * @copyright  Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
+ */
+class PHPExcel_DocumentSecurity
+{
+	/**
+	 * LockRevision
+	 *
+	 * @var boolean
+	 */
+	private $_lockRevision;
+
+	/**
+	 * LockStructure
+	 *
+	 * @var boolean
+	 */
+	private $_lockStructure;
+
+	/**
+	 * LockWindows
+	 *
+	 * @var boolean
+	 */
+	private $_lockWindows;
+
+	/**
+	 * RevisionsPassword
+	 *
+	 * @var string
+	 */
+	private $_revisionsPassword;
+
+	/**
+	 * WorkbookPassword
+	 *
+	 * @var string
+	 */
+	private $_workbookPassword;
+
+    /**
+     * Create a new PHPExcel_DocumentSecurity
+     */
+    public function __construct()
+    {
+    	// Initialise values
+    	$this->_lockRevision		= false;
+    	$this->_lockStructure		= false;
+    	$this->_lockWindows			= false;
+    	$this->_revisionsPassword	= '';
+    	$this->_workbookPassword	= '';
+    }
+
+    /**
+     * Is some sort of dcument security enabled?
+     *
+     * @return boolean
+     */
+    function isSecurityEnabled() {
+    	return 	$this->_lockRevision ||
+		    	$this->_lockStructure ||
+		    	$this->_lockWindows;
+    }
+
+    /**
+     * Get LockRevision
+     *
+     * @return boolean
+     */
+    function getLockRevision() {
+    	return $this->_lockRevision;
+    }
+
+    /**
+     * Set LockRevision
+     *
+     * @param boolean $pValue
+     * @return PHPExcel_DocumentSecurity
+     */
+    function setLockRevision($pValue = false) {
+    	$this->_lockRevision = $pValue;
+    	return $this;
+    }
+
+    /**
+     * Get LockStructure
+     *
+     * @return boolean
+     */
+    function getLockStructure() {
+    	return $this->_lockStructure;
+    }
+
+    /**
+     * Set LockStructure
+     *
+     * @param boolean $pValue
+     * @return PHPExcel_DocumentSecurity
+     */
+    function setLockStructure($pValue = false) {
+		$this->_lockStructure = $pValue;
+		return $this;
+    }
+
+    /**
+     * Get LockWindows
+     *
+     * @return boolean
+     */
+    function getLockWindows() {
+    	return $this->_lockWindows;
+    }
+
+    /**
+     * Set LockWindows
+     *
+     * @param boolean $pValue
+     * @return PHPExcel_DocumentSecurity
+     */
+    function setLockWindows($pValue = false) {
+    	$this->_lockWindows = $pValue;
+    	return $this;
+    }
+
+    /**
+     * Get RevisionsPassword (hashed)
+     *
+     * @return string
+     */
+    function getRevisionsPassword() {
+    	return $this->_revisionsPassword;
+    }
+
+    /**
+     * Set RevisionsPassword
+     *
+     * @param string 	$pValue
+     * @param boolean 	$pAlreadyHashed If the password has already been hashed, set this to true
+     * @return PHPExcel_DocumentSecurity
+     */
+    function setRevisionsPassword($pValue = '', $pAlreadyHashed = false) {
+    	if (!$pAlreadyHashed) {
+    		$pValue = PHPExcel_Shared_PasswordHasher::hashPassword($pValue);
+    	}
+    	$this->_revisionsPassword = $pValue;
+    	return $this;
+    }
+
+    /**
+     * Get WorkbookPassword (hashed)
+     *
+     * @return string
+     */
+    function getWorkbookPassword() {
+    	return $this->_workbookPassword;
+    }
+
+    /**
+     * Set WorkbookPassword
+     *
+     * @param string 	$pValue
+     * @param boolean 	$pAlreadyHashed If the password has already been hashed, set this to true
+     * @return PHPExcel_DocumentSecurity
+     */
+    function setWorkbookPassword($pValue = '', $pAlreadyHashed = false) {
+    	if (!$pAlreadyHashed) {
+    		$pValue = PHPExcel_Shared_PasswordHasher::hashPassword($pValue);
+    	}
+		$this->_workbookPassword = $pValue;
+		return $this;
+    }
+
+	/**
+	 * 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)) {
+				$this->$key = clone $value;
+			} else {
+				$this->$key = $value;
+			}
+		}
+	}
+}

lib/Classes/PHPExcel/Exception.php

+<?php
+/**
+ * PHPExcel
+ *
+ * Copyright (c) 2006 - 2014 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
+ * @copyright  Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
+ * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt    LGPL
+ * @version    1.8.0, 2014-03-02
+ */
+
+
+/**
+ * PHPExcel_Exception
+ *
+ * @category   PHPExcel
+ * @package    PHPExcel
+ * @copyright  Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
+ */
+class PHPExcel_Exception extends 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;
+    }
+}

lib/Classes/PHPExcel/HashTable.php

+<?php
+/**
+ * PHPExcel
+ *
+ * Copyright (c) 2006 - 2014 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
+ * @copyright  Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
+ * @license	http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt	LGPL
+ * @version	1.8.0, 2014-03-02
+ */
+
+
+/**
+ * PHPExcel_HashTable
+ *
+ * @category   PHPExcel
+ * @package	PHPExcel
+ * @copyright  Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
+ */
+class PHPExcel_HashTable
+{
+	/**
+	 * HashTable elements
+	 *
+	 * @var array
+	 */
+	public $_items = array();
+
+	/**
+	 * HashTable key map
+	 *
+	 * @var array
+	 */
+	public $_keyMap = array();
+
+	/**
+	 * Create a new PHPExcel_HashTable
+	 *
+	 * @param	PHPExcel_IComparable[] $pSource	Optional source array to create HashTable from
+	 * @throws	PHPExcel_Exception
+	 */
+	public function __construct($pSource = null)
+	{
+		if ($pSource !== NULL) {
+			// Create HashTable
+			$this->addFromSource($pSource);
+		}
+	}
+
+	/**
+	 * Add HashTable items from source
+	 *
+	 * @param	PHPExcel_IComparable[] $pSource	Source array to create HashTable from
+	 * @throws	PHPExcel_Exception
+	 */
+	public function addFromSource($pSource = null) {
+		// Check if an array was passed
+		if ($pSource == null) {
+			return;
+		} else if (!is_array($pSource)) {
+			throw new PHPExcel_Exception('Invalid array parameter passed.');
+		}
+
+		foreach ($pSource as $item) {
+			$this->add($item);
+		}
+	}
+
+	/**
+	 * Add HashTable item
+	 *
+	 * @param	PHPExcel_IComparable $pSource	Item to add
+	 * @throws	PHPExcel_Exception
+	 */
+	public function add(PHPExcel_IComparable $pSource = null) {
+		$hash = $pSource->getHashCode();
+		if (!isset($this->_items[$hash])) {
+			$this->_items[$hash] = $pSource;
+			$this->_keyMap[count($this->_items) - 1] = $hash;
+		}
+	}
+
+	/**
+	 * Remove HashTable item
+	 *
+	 * @param	PHPExcel_IComparable $pSource	Item to remove
+	 * @throws	PHPExcel_Exception
+	 */
+	public function remove(PHPExcel_IComparable $pSource = null) {
+		$hash = $pSource->getHashCode();
+		if (isset($this->_items[$hash])) {
+			unset($this->_items[$hash]);
+
+			$deleteKey = -1;
+			foreach ($this->_keyMap as $key => $value) {
+				if ($deleteKey >= 0) {
+					$this->_keyMap[$key - 1] = $value;
+				}
+
+				if ($value == $hash) {
+					$deleteKey = $key;
+				}
+			}
+			unset($this->_keyMap[count($this->_keyMap) - 1]);
+		}
+	}
+
+	/**
+	 * Clear HashTable
+	 *
+	 */
+	public function clear() {
+		$this->_items = array();
+		$this->_keyMap = array();
+	}
+
+	/**
+	 * Count
+	 *
+	 * @return int
+	 */
+	public function count() {
+		return count($this->_items);
+	}
+
+	/**
+	 * Get index for hash code
+	 *
+	 * @param	string	$pHashCode
+	 * @return	int	Index
+	 */
+	public function getIndexForHashCode($pHashCode = '') {
+		return array_search($pHashCode, $this->_keyMap);
+	}
+
+	/**
+	 * Get by index
+	 *
+	 * @param	int	$pIndex
+	 * @return	PHPExcel_IComparable
+	 *
+	 */
+	public function getByIndex($pIndex = 0) {
+		if (isset($this->_keyMap[$pIndex])) {
+			return $this->getByHashCode( $this->_keyMap[$pIndex] );
+		}
+
+		return null;
+	}
+
+	/**
+	 * Get by hashcode
+	 *
+	 * @param	string	$pHashCode
+	 * @return	PHPExcel_IComparable
+	 *
+	 */
+	public function getByHashCode($pHashCode = '') {
+		if (isset($this->_items[$pHashCode])) {
+			return $this->_items[$pHashCode];
+		}
+
+		return null;
+	}
+
+	/**
+	 * HashTable to array
+	 *
+	 * @return PHPExcel_IComparable[]
+	 */
+	public function toArray() {
+		return $this->_items;
+	}
+
+	/**
+	 * 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)) {
+				$this->$key = clone $value;
+			}
+		}
+	}
+}

lib/Classes/PHPExcel/IComparable.php

+<?php
+/**
+ * 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
+ * @copyright  Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
+ * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt	LGPL
+ * @version    1.8.0, 2014-03-02
+ */
+
+
+/**
+ * PHPExcel_IComparable
+ *
+ * @category   PHPExcel
+ * @package    PHPExcel
+ * @copyright  Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
+ */
+interface PHPExcel_IComparable
+{
+	/**
+	 * Get hash code
+	 *
+	 * @return string	Hash code
+	 */
+	public function getHashCode();
+
+}

lib/Classes/PHPExcel/IOFactory.php

+<?php
+/**
+ * PHPExcel
+ *
+ * Copyright (c) 2006 - 2014 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
+ * @copyright  Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
+ * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt	LGPL
+ * @version    1.8.0, 2014-03-02
+ */
+
+
+/**	PHPExcel root directory */
+if (!defined('PHPEXCEL_ROOT')) {
+	/**
+	 * @ignore
+	 */
+	define('PHPEXCEL_ROOT', dirname(__FILE__) . '/../');
+	require(PHPEXCEL_ROOT . 'PHPExcel/Autoloader.php');
+}
+
+/**
+ * PHPExcel_IOFactory
+ *
+ * @category   PHPExcel
+ * @package    PHPExcel
+ * @copyright  Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
+ */
+class PHPExcel_IOFactory
+{
+	/**
+	 * Search locations
+	 *
+	 * @var	array
+	 * @access	private
+	 * @static
+	 */
+	private static $_searchLocations = array(
+		array( 'type' => 'IWriter', 'path' => 'PHPExcel/Writer/{0}.php', 'class' => 'PHPExcel_Writer_{0}' ),
+		array( 'type' => 'IReader', 'path' => 'PHPExcel/Reader/{0}.php', 'class' => 'PHPExcel_Reader_{0}' )
+	);
+
+	/**
+	 * Autoresolve classes
+	 *
+	 * @var	array
+	 * @access	private
+	 * @static
+	 */
+	private static $_autoResolveClasses = array(
+		'Excel2007',
+		'Excel5',
+		'Excel2003XML',
+		'OOCalc',
+		'SYLK',
+		'Gnumeric',
+		'HTML',
+		'CSV',
+	);
+
+    /**
+     *	Private constructor for PHPExcel_IOFactory
+     */
+    private function __construct() { }
+
+    /**
+     * Get search locations
+     *
+	 * @static
+	 * @access	public
+     * @return	array
+     */
+	public static function getSearchLocations() {
+		return self::$_searchLocations;
+	}	//	function getSearchLocations()
+
+	/**
+	 * Set search locations
+	 *
+	 * @static
+	 * @access	public
+	 * @param	array $value
+	 * @throws	PHPExcel_Reader_Exception
+	 */
+	public static function setSearchLocations($value) {
+		if (is_array($value)) {
+			self::$_searchLocations = $value;
+		} else {
+			throw new PHPExcel_Reader_Exception('Invalid parameter passed.');
+		}
+	}	//	function setSearchLocations()
+
+	/**
+	 * Add search location
+	 *
+	 * @static
+	 * @access	public
+	 * @param	string $type		Example: IWriter
+	 * @param	string $location	Example: PHPExcel/Writer/{0}.php
+	 * @param	string $classname 	Example: PHPExcel_Writer_{0}
+	 */
+	public static function addSearchLocation($type = '', $location = '', $classname = '') {
+		self::$_searchLocations[] = array( 'type' => $type, 'path' => $location, 'class' => $classname );
+	}	//	function addSearchLocation()
+
+	/**
+	 * Create PHPExcel_Writer_IWriter
+	 *
+	 * @static
+	 * @access	public
+	 * @param	PHPExcel $phpExcel
+	 * @param	string  $writerType	Example: Excel2007
+	 * @return	PHPExcel_Writer_IWriter
+	 * @throws	PHPExcel_Reader_Exception
+	 */
+	public static function createWriter(PHPExcel $phpExcel, $writerType = '') {
+		// Search type
+		$searchType = 'IWriter';
+
+		// Include class
+		foreach (self::$_searchLocations as $searchLocation) {
+			if ($searchLocation['type'] == $searchType) {
+				$className = str_replace('{0}', $writerType, $searchLocation['class']);
+
+				$instance = new $className($phpExcel);
+				if ($instance !== NULL) {
+					return $instance;
+				}
+			}
+		}
+
+		// Nothing found...
+		throw new PHPExcel_Reader_Exception("No $searchType found for type $writerType");
+	}	//	function createWriter()
+
+	/**
+	 * Create PHPExcel_Reader_IReader
+	 *
+	 * @static
+	 * @access	public
+	 * @param	string $readerType	Example: Excel2007
+	 * @return	PHPExcel_Reader_IReader
+	 * @throws	PHPExcel_Reader_Exception
+	 */
+	public static function createReader($readerType = '') {
+		// Search type
+		$searchType = 'IReader';
+
+		// Include class
+		foreach (self::$_searchLocations as $searchLocation) {
+			if ($searchLocation['type'] == $searchType) {
+				$className = str_replace('{0}', $readerType, $searchLocation['class']);
+
+				$instance = new $className();
+				if ($instance !== NULL) {
+					return $instance;
+				}
+			}
+		}
+
+		// Nothing found...
+		throw new PHPExcel_Reader_Exception("No $searchType found for type $readerType");
+	}	//	function createReader()
+
+	/**
+	 * Loads PHPExcel from file using automatic PHPExcel_Reader_IReader resolution
+	 *
+	 * @static
+	 * @access public
+	 * @param 	string 		$pFilename		The name of the spreadsheet file
+	 * @return	PHPExcel
+	 * @throws	PHPExcel_Reader_Exception
+	 */
+	public static function load($pFilename) {
+		$reader = self::createReaderForFile($pFilename);
+		return $reader->load($pFilename);
+	}	//	function load()
+
+	/**
+	 * Identify file type using automatic PHPExcel_Reader_IReader resolution
+	 *
+	 * @static
+	 * @access public
+	 * @param 	string 		$pFilename		The name of the spreadsheet file to identify
+	 * @return	string
+	 * @throws	PHPExcel_Reader_Exception
+	 */
+	public static function identify($pFilename) {
+		$reader = self::createReaderForFile($pFilename);
+		$className = get_class($reader);
+		$classType = explode('_',$className);
+		unset($reader);
+		return array_pop($classType);
+	}	//	function identify()
+
+	/**
+	 * Create PHPExcel_Reader_IReader for file using automatic PHPExcel_Reader_IReader resolution
+	 *
+	 * @static
+	 * @access	public
+	 * @param 	string 		$pFilename		The name of the spreadsheet file
+	 * @return	PHPExcel_Reader_IReader
+	 * @throws	PHPExcel_Reader_Exception
+	 */
+	public static function createReaderForFile($pFilename) {
+
+		// First, lucky guess by inspecting file extension
+		$pathinfo = pathinfo($pFilename);
+
+		$extensionType = NULL;
+		if (isset($pathinfo['extension'])) {
+			switch (strtolower($pathinfo['extension'])) {
+				case 'xlsx':			//	Excel (OfficeOpenXML) Spreadsheet
+				case 'xlsm':			//	Excel (OfficeOpenXML) Macro Spreadsheet (macros will be discarded)
+				case 'xltx':			//	Excel (OfficeOpenXML) Template
+				case 'xltm':			//	Excel (OfficeOpenXML) Macro Template (macros will be discarded)
+					$extensionType = 'Excel2007';
+					break;
+				case 'xls':				//	Excel (BIFF) Spreadsheet
+				case 'xlt':				//	Excel (BIFF) Template
+					$extensionType = 'Excel5';
+					break;
+				case 'ods':				//	Open/Libre Offic Calc
+				case 'ots':				//	Open/Libre Offic Calc Template
+					$extensionType = 'OOCalc';
+					break;
+				case 'slk':
+					$extensionType = 'SYLK';
+					break;
+				case 'xml':				//	Excel 2003 SpreadSheetML
+					$extensionType = 'Excel2003XML';
+					break;
+				case 'gnumeric':
+					$extensionType = 'Gnumeric';
+					break;
+				case 'htm':
+				case 'html':
+					$extensionType = 'HTML';
+					break;
+				case 'csv':
+					// Do nothing
+					// We must not try to use CSV reader since it loads
+					// all files including Excel files etc.
+					break;
+				default:
+					break;
+			}
+
+			if ($extensionType !== NULL) {
+				$reader = self::createReader($extensionType);
+				// Let's see if we are lucky
+				if (isset($reader) && $reader->canRead($pFilename)) {
+					return $reader;
+				}
+			}
+		}
+
+		// If we reach here then "lucky guess" didn't give any result
+		// Try walking through all the options in self::$_autoResolveClasses
+		foreach (self::$_autoResolveClasses as $autoResolveClass) {
+			//	Ignore our original guess, we know that won't work
+			if ($autoResolveClass !== $extensionType) {
+				$reader = self::createReader($autoResolveClass);
+				if ($reader->canRead($pFilename)) {
+					return $reader;
+				}
+			}
+		}
+
+		throw new PHPExcel_Reader_Exception('Unable to identify a reader for this file');
+	}	//	function createReaderForFile()
+}

lib/Classes/PHPExcel/NamedRange.php

+<?php
+/**
+ * PHPExcel
+ *
+ * Copyright (c) 2006 - 2014 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
+ * @copyright  Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
+ * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt	LGPL
+ * @version    1.8.0, 2014-03-02
+ */
+
+
+/**
+ * PHPExcel_NamedRange
+ *
+ * @category   PHPExcel
+ * @package    PHPExcel
+ * @copyright  Copyright (c) 2006 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
+ */
+class PHPExcel_NamedRange
+{
+	/**
+	 * Range name
+	 *
+	 * @var string
+	 */
+	private $_name;
+
+	/**
+	 * Worksheet on which the named range can be resolved
+	 *
+	 * @var PHPExcel_Worksheet
+	 */
+	private $_worksheet;
+
+	/**
+	 * Range of the referenced cells
+	 *
+	 * @var string
+	 */
+	private $_range;
+
+	/**
+	 * Is the named range local? (i.e. can only be used on $this->_worksheet)
+	 *
+	 * @var bool
+	 */
+	private $_localOnly;
+
+	/**
+	 * Scope
+	 *
+	 * @var PHPExcel_Worksheet
+	 */
+	private $_scope;
+
+    /**
+     * Create a new NamedRange
+     *
+     * @param string $pName
+     * @param PHPExcel_Worksheet $pWorksheet
+     * @param string $pRange
+     * @param bool $pLocalOnly
+     * @param PHPExcel_Worksheet|null $pScope	Scope. Only applies when $pLocalOnly = true. Null for global scope.
+     * @throws PHPExcel_Exception
+     */
+    public function __construct($pName = null, PHPExcel_Worksheet $pWorksheet, $pRange = 'A1', $pLocalOnly = false, $pScope = null)
+    {
+    	// Validate data
+    	if (($pName === NULL) || ($pWorksheet === NULL) || ($pRange === NULL)) {
+    		throw new PHPExcel_Exception('Parameters can not be null.');
+    	}
+
+    	// Set local members
+    	$this->_name 		= $pName;
+    	$this->_worksheet 	= $pWorksheet;
+    	$this->_range 		= $pRange;
+    	$this->_localOnly 	= $pLocalOnly;
+    	$this->_scope 		= ($pLocalOnly == true) ?
+								(($pScope == null) ? $pWorksheet : $pScope) : null;
+    }
+
+    /**
+     * Get name
+     *
+     * @return string
+     */
+    public function getName() {
+    	return $this->_name;
+    }
+
+    /**
+     * Set name
+     *
+     * @param string $value
+     * @return PHPExcel_NamedRange
+     */
+    public function setName($value = null) {
+    	if ($value !== NULL) {
+    		// Old title
+    		$oldTitle = $this->_name;
+
+    		// Re-attach
+    		if ($this->_worksheet !== NULL) {
+    			$this->_worksheet->getParent()->removeNamedRange($this->_name,$this->_worksheet);
+    		}
+    		$this->_name = $value;
+
+    		if ($this->_worksheet !== NULL) {
+    			$this->_worksheet->getParent()->addNamedRange($this);
+    		}
+
+	    	// New title
+	    	$newTitle = $this->_name;
+	    	PHPExcel_ReferenceHelper::getInstance()->updateNamedFormulas($this->_worksheet->getParent(), $oldTitle, $newTitle);
+    	}
+    	return $this;
+    }
+
+    /**
+     * Get worksheet
+     *
+     * @return PHPExcel_Worksheet
+     */
+    public function getWorksheet() {
+    	return $this->_worksheet;
+    }
+
+    /**
+     * Set worksheet
+     *
+     * @param PHPExcel_Worksheet $value
+     * @return PHPExcel_NamedRange
+     */
+    public function setWorksheet(PHPExcel_Worksheet $value = null) {
+    	if ($value !== NULL) {
+    		$this->_worksheet = $value;
+    	}
+    	return $this;
+    }
+
+    /**
+     * Get range
+     *
+     * @return string
+     */
+    public function getRange() {
+    	return $this->_range;
+    }
+
+    /**
+     * Set range
+     *
+     * @param string $value
+     * @return PHPExcel_NamedRange
+     */
+    public function setRange($value = null) {
+    	if ($value !== NULL) {
+    		$this->_range = $value;
+    	}
+    	return $this;
+    }
+
+    /**
+     * Get localOnly
+     *
+     * @return bool
+     */
+    public function getLocalOnly() {
+    	return $this->_localOnly;
+    }
+
+    /**
+     * Set localOnly
+     *
+     * @param bool $value
+     * @return PHPExcel_NamedRange
+     */
+    public function setLocalOnly($value = false) {
+    	$this->_localOnly = $value;
+    	$this->_scope = $value ? $this->_worksheet : null;
+    	return $this;
+    }
+
+    /**
+     * Get scope
+     *
+     * @return PHPExcel_Worksheet|null
+     */
+    public function getScope() {
+    	return $this->_scope;
+    }
+
+    /**
+     * Set scope
+     *
+     * @param PHPExcel_Worksheet|null $value
+     * @return PHPExcel_NamedRange
+     */
+    public function setScope(PHPExcel_Worksheet $value = null) {
+    	$this->_scope = $value;
+    	$this->_localOnly = ($value == null) ? false : true;
+    	return $this;
+    }
+
+    /**
+     * Resolve a named range to a regular cell range
+     *
+     * @param string $pNamedRange Named range
+     * @param PHPExcel_Worksheet|null $pSheet Scope. Use null for global scope
+     * @return PHPExcel_NamedRange
+     */
+    public static function resolveRange($pNamedRange = '', PHPExcel_Worksheet $pSheet) {
+		return $pSheet->getParent()->getNamedRange($pNamedRange, $pSheet);
+    }
+
+	/**
+	 * 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)) {
+				$this->$key = clone $value;
+			} else {
+				$this->$key = $value;
+			}
+		}
+	}
+}

lib/Classes/PHPExcel/Reader/Abstract.php

+<?php
+/**
+ * PHPExcel
+ *
+ * Copyright (c) 2006 - 2014 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 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
+ * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt	LGPL
+ * @version    1.8.0, 2014-03-02
+ */
+
+
+/**
+ * PHPExcel_Reader_Abstract
+ *
+ * @category	PHPExcel
+ * @package	PHPExcel_Reader
+ * @copyright	Copyright (c) 2006 - 2014 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;
+	}
+
+}

lib/Classes/PHPExcel/Reader/CSV.php

+<?php
+/**
+ * PHPExcel
+ *
+ * Copyright (c) 2006 - 2014 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 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
+ * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt	LGPL
+ * @version    1.8.0, 2014-03-02
+ */
+
+
+/** 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 - 2014 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($this->_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;
+	}
+
+}

lib/Classes/PHPExcel/Reader/DefaultReadFilter.php

+<?php
+/**
+ * PHPExcel
+ *
+ * Copyright (c) 2006 - 2014 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 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
+ * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt	LGPL
+ * @version    1.8.0, 2014-03-02
+ */
+
+
+/** 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 - 2014 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;
+	}
+}

lib/Classes/PHPExcel/Reader/Excel2003XML.php

+<?php
+/**
+ * PHPExcel
+ *
+ * Copyright (c) 2006 - 2014 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 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
+ * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt	LGPL
+ * @version    1.8.0, 2014-03-02
+ */
+
+
+/** 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 - 2014 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, 'SimpleXMLElement', PHPExcel_Settings::getLibXmlLoaderOptions());
+		$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, 'SimpleXMLElement', PHPExcel_Settings::getLibXmlLoaderOptions());
+		$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, 'SimpleXMLElement', PHPExcel_Settings::getLibXmlLoaderOptions());
+		$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;
+	}
+
+}

lib/Classes/PHPExcel/Reader/Excel2007.php

+<?php
+/**
+ * PHPExcel
+ *
+ * Copyright (c) 2006 - 2014 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 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
+ * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt	LGPL
+ * @version    1.8.0, 2014-03-02
+ */
+
+
+/** 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 - 2014 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.");
+		}
+
+        $zipClass = PHPExcel_Settings::getZipClass();
+
+		// Check if zip class exists
+//		if (!class_exists($zipClass, FALSE)) {
+//			throw new PHPExcel_Reader_Exception($zipClass . " library is not enabled");
+//		}
+
+		$xl = false;
+		// Load file
+		$zip = new $zipClass;
+		if ($zip->open($pFilename) === true) {
+			// check if it is an OOXML archive
+			$rels = simplexml_load_string($this->_getFromZipArchive($zip, "_rels/.rels"), 'SimpleXMLElement', PHPExcel_Settings::getLibXmlLoaderOptions());
+			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();
+
+        $zipClass = PHPExcel_Settings::getZipClass();
+
+		$zip = new $zipClass;
+		$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", 'SimpleXMLElement', PHPExcel_Settings::getLibXmlLoaderOptions())
+		); //~ 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']}", 'SimpleXMLElement', PHPExcel_Settings::getLibXmlLoaderOptions())
+					);  //~ 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();
+
+        $zipClass = PHPExcel_Settings::getZipClass();
+
+		$zip = new $zipClass;
+		$zip->open($pFilename);
+
+		$rels = simplexml_load_string($this->_getFromZipArchive($zip, "_rels/.rels"), 'SimpleXMLElement', PHPExcel_Settings::getLibXmlLoaderOptions()); //~ 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"), 'SimpleXMLElement', PHPExcel_Settings::getLibXmlLoaderOptions());  //~ 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']}"), 'SimpleXMLElement', PHPExcel_Settings::getLibXmlLoaderOptions());  //~ 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", null, PHPExcel_Settings::getLibXmlLoaderOptions());
+						$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', PHP_EOL;
+		$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', PHP_EOL;
+		return isset($c->v) ? (string) $c->v : NULL;
+	}	//	function _castToError()
+
+
+	private static function _castToString($c) {
+//		echo 'Initial Cast to String, PHP_EOL;
+		return isset($c->v) ? (string) $c->v : NULL;
+	}	//	function _castToString()
+
+
+	private function _castToFormula($c,$r,&$cellDataType,&$value,&$calculatedValue,&$sharedFormulas,$castBaseType) {
+//		echo 'Formula', PHP_EOL;
+//		echo '$c->f is ', $c->f, PHP_EOL;
+		$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', PHP_EOL;
+			$instance = (string)$c->f['si'];
+
+//			echo 'Instance ID = ', $instance, PHP_EOL;
+//
+//			echo 'Shared Formula Array:', PHP_EOL;
+//			print_r($sharedFormulas);
+			if (!isset($sharedFormulas[(string)$c->f['si']])) {
+//				echo 'SETTING NEW SHARED FORMULA', PHP_EOL;
+//				echo 'Master is ', $r, PHP_EOL;
+//				echo 'Formula is ', $value, PHP_EOL;
+				$sharedFormulas[$instance] = array(	'master' => $r,
+													'formula' => $value
+												  );
+//				echo 'New Shared Formula Array:', PHP_EOL;
+//				print_r($sharedFormulas);
+			} else {
+//				echo 'GETTING SHARED FORMULA', PHP_EOL;
+//				echo 'Master is ', $sharedFormulas[$instance]['master'], PHP_EOL;
+//				echo 'Formula is ', $sharedFormulas[$instance]['formula'], PHP_EOL;
+				$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, PHP_EOL;
+			}
+		}
+	}
+
+
+	public function _getFromZipArchive($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
+		}
+
+        $zipClass = PHPExcel_Settings::getZipClass();
+
+		$zip = new $zipClass;
+		$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"), 'SimpleXMLElement', PHPExcel_Settings::getLibXmlLoaderOptions()); //~ 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']}"), 'SimpleXMLElement', PHPExcel_Settings::getLibXmlLoaderOptions());
+					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"), 'SimpleXMLElement', PHPExcel_Settings::getLibXmlLoaderOptions()); //~ 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']}"), 'SimpleXMLElement', PHPExcel_Settings::getLibXmlLoaderOptions());
+					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']}"), 'SimpleXMLElement', PHPExcel_Settings::getLibXmlLoaderOptions());
+					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']}"), 'SimpleXMLElement', PHPExcel_Settings::getLibXmlLoaderOptions());
+					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;
+				//Ribbon
+				case "http://schemas.microsoft.com/office/2006/relationships/ui/extensibility":
+					$customUI = $rel['Target'];
+					if(!is_null($customUI)){
+						$this->_readRibbon($excel, $customUI, $zip);
+					}
+				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"), 'SimpleXMLElement', PHPExcel_Settings::getLibXmlLoaderOptions());  //~ 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]"), 'SimpleXMLElement', PHPExcel_Settings::getLibXmlLoaderOptions());  //~ 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();
+                    $macros = $customUI = NULL;
+					foreach ($relsWorkbook->Relationship as $ele) {
+						switch($ele['Type']){
+						case "http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet": 
+							$worksheets[(string) $ele["Id"]] = $ele["Target"];
+							break;
+						// a vbaProject ? (: some macros)
+						case "http://schemas.microsoft.com/office/2006/relationships/vbaProject":
+							$macros = $ele["Target"];
+							break;
+						}
+					}
+
+					if(!is_null($macros)){
+						$macrosCode = $this->_getFromZipArchive($zip, 'xl/vbaProject.bin');//vbaProject.bin always in 'xl' dir and always named vbaProject.bin
+						if($macrosCode !== false){
+							$excel->setMacrosCode($macrosCode);
+							$excel->setHasMacros(true);
+							//short-circuit : not reading vbaProject.bin.rel to get Signature =>allways vbaProjectSignature.bin in 'xl' dir
+							$Certificate = $this->_getFromZipArchive($zip, 'xl/vbaProjectSignature.bin');
+							if($Certificate !== false)
+								$excel->setMacrosCertificate($Certificate);
+						}
+					}
+					$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]"), 'SimpleXMLElement', PHPExcel_Settings::getLibXmlLoaderOptions()); //~ 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"]);
+								}
+							}
+                            $quotePrefix = false;
+							if (isset($xf["quotePrefix"])) {
+                                $quotePrefix = (boolean) $xf["quotePrefix"];
+                            }
+							//$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,
+								"quotePrefix" => $quotePrefix,
+							);
+							$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,
+								"quotePrefix" => $quotePrefix,
+							);
+							$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']}"), 'SimpleXMLElement', PHPExcel_Settings::getLibXmlLoaderOptions());  //~ 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"), 'SimpleXMLElement', PHPExcel_Settings::getLibXmlLoaderOptions());  //~ 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['codeName'])) {
+								$docSheet->setCodeName((string) $xmlSheet->sheetPr['codeName']);
+							}
+							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"])) {
+                                        // echo PHPExcel_Cell::stringFromColumnIndex($i),': HIDDEN COLUMN',PHP_EOL;
+											$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 'Reading cell ', $coordinates[0], $coordinates[1], PHP_EOL;
+	//									print_r($c);
+	//									echo PHP_EOL;
+	//									echo 'Cell Data Type is ', $cellDataType, ': ';
+	//
+										// Read cell!
+										switch ($cellDataType) {
+											case "s":
+	//											echo 'String', PHP_EOL;
+												if ((string)$c->v != '') {
+													$value = $sharedStrings[intval($c->v)];
+
+													if ($value instanceof PHPExcel_RichText) {
+														$value = clone $value;
+													}
+												} else {
+													$value = '';
+												}
+
+												break;
+											case "b":
+	//											echo 'Boolean', PHP_EOL;
+												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, PHP_EOL;
+												}
+												break;
+											case "inlineStr":
+	//											echo 'Inline String', PHP_EOL;
+												$value = $this->_parseRichText($c->is);
+
+												break;
+											case "e":
+	//											echo 'Error', PHP_EOL;
+												if (!isset($c->f)) {
+													$value = self::_castToError($c);
+												} else {
+													// Formula
+													$this->_castToFormula($c,$r,$cellDataType,$value,$calculatedValue,$sharedFormulas,'_castToError');
+	//												echo '$calculatedValue = ', $calculatedValue, PHP_EOL;
+												}
+
+												break;
+
+											default:
+	//											echo 'Default', PHP_EOL;
+												if (!isset($c->f)) {
+	//												echo 'Not a Formula', PHP_EOL;
+													$value = self::_castToString($c);
+												} else {
+	//												echo 'Treat as Formula', PHP_EOL;
+													// Formula
+													$this->_castToFormula($c,$r,$cellDataType,$value,$calculatedValue,$sharedFormulas,'_castToString');
+	//												echo '$calculatedValue = ', $calculatedValue, PHP_EOL;
+												}
+
+												break;
+										}
+	//									echo 'Value is ', $value, PHP_EOL;
+
+										// 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") , 'SimpleXMLElement', PHPExcel_Settings::getLibXmlLoaderOptions()); //~ 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") , 'SimpleXMLElement', PHPExcel_Settings::getLibXmlLoaderOptions()); //~ 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) , 'SimpleXMLElement', PHPExcel_Settings::getLibXmlLoaderOptions());
+
+									// 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) , 'SimpleXMLElement', PHPExcel_Settings::getLibXmlLoaderOptions());
+									$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") , 'SimpleXMLElement', PHPExcel_Settings::getLibXmlLoaderOptions()); //~ 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' ), 'SimpleXMLElement', PHPExcel_Settings::getLibXmlLoaderOptions()); //~ 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), 'SimpleXMLElement', PHPExcel_Settings::getLibXmlLoaderOptions());
+											$vmlDrawing->registerXPathNamespace('v', 'urn:schemas-microsoft-com:vml');
+
+											$hfImages = array();
+
+											$shapes = $vmlDrawing->xpath('//v:shape');
+											foreach ($shapes as $idx => $shape) {
+												$shape->registerXPathNamespace('v', 'urn:schemas-microsoft-com:vml');
+												$imageData = $shape->xpath('//v:imagedata');
+												$imageData = $imageData[$idx];
+
+												$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']);
+												if (isset($style['margin-left'])) {
+													$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") , 'SimpleXMLElement', PHPExcel_Settings::getLibXmlLoaderOptions()); //~ 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") , 'SimpleXMLElement', PHPExcel_Settings::getLibXmlLoaderOptions()); //~ 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), 'SimpleXMLElement', PHPExcel_Settings::getLibXmlLoaderOptions())->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"), 'SimpleXMLElement', PHPExcel_Settings::getLibXmlLoaderOptions());
+			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), 'SimpleXMLElement', PHPExcel_Settings::getLibXmlLoaderOptions());
+							$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);
+				}
+			}
+		}
+
+		// top-level style settings
+		if (isset($style->quotePrefix)) {
+			$docStyle->setQuotePrefix($style->quotePrefix);
+        }
+	}
+
+
+	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 function _readRibbon($excel, $customUITarget, $zip)
+    {
+		$baseDir = dirname($customUITarget);
+		$nameCustomUI = basename($customUITarget);
+        // get the xml file (ribbon)
+		$localRibbon = $this->_getFromZipArchive($zip, $customUITarget);
+		$customUIImagesNames = array(); 
+        $customUIImagesBinaries = array();
+        // something like customUI/_rels/customUI.xml.rels
+		$pathRels = $baseDir . '/_rels/' . $nameCustomUI . '.rels';
+		$dataRels = $this->_getFromZipArchive($zip, $pathRels);
+		if ($dataRels) {
+            // exists and not empty if the ribbon have some pictures (other than internal MSO)
+			$UIRels = simplexml_load_string($dataRels, 'SimpleXMLElement', PHPExcel_Settings::getLibXmlLoaderOptions());
+			if ($UIRels) {
+				// we need to save id and target to avoid parsing customUI.xml and "guess" if it's a pseudo callback who load the image
+				foreach ($UIRels->Relationship as $ele) {
+					if ($ele["Type"] == 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/image') {
+                        // an image ?
+						$customUIImagesNames[(string) $ele['Id']] = (string)$ele['Target'];
+						$customUIImagesBinaries[(string)$ele['Target']] = $this->_getFromZipArchive($zip, $baseDir . '/' . (string) $ele['Target']);
+					}
+				}
+			}
+		}
+		if ($localRibbon) {
+			$excel->setRibbonXMLData($customUITarget, $localRibbon);
+			if (count($customUIImagesNames) > 0 && count($customUIImagesBinaries) > 0) {
+				$excel->setRibbonBinObjects($customUIImagesNames, $customUIImagesBinaries);
+			} else {
+				$excel->setRibbonBinObjects(NULL);
+			}
+		} else {
+			$excel->setRibbonXMLData(NULL);
+			$excel->setRibbonBinObjects(NULL);
+		}
+	}
+
+	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_object($value)) {
+			$value = (string) $value;
+        }
+		if (is_numeric($value)) {
+			return (bool) $value;
+        }
+		return ($value === 'true' || $value === 'TRUE');
+	}
+}

lib/Classes/PHPExcel/Reader/Excel2007/Chart.php

+<?php
+/**
+ * PHPExcel
+ *
+ * Copyright (c) 2006 - 2014 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 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
+ * @license		http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt	LGPL
+ * @version		1.8.0, 2014-03-02
+ */
+
+/**
+ * PHPExcel_Reader_Excel2007_Chart
+ *
+ * @category	PHPExcel
+ * @package		PHPExcel_Reader_Excel2007
+ * @copyright	Copyright (c) 2006 - 2014 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;
+			}
+		}
+	}
+
+}

lib/Classes/PHPExcel/Reader/Excel2007/Theme.php

+<?php
+/**
+ * PHPExcel
+ *
+ * Copyright (c) 2006 - 2014 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 - 2014 PHPExcel (http://www.codeplex.com/PHPExcel)
+ * @license    http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt	LGPL
+ * @version    1.8.0, 2014-03-02
+ */
+
+
+/**
+ * PHPExcel_Reader_Excel2007_Theme
+ *
+ * @category   PHPExcel
+ * @package    PHPExcel_Reader_Excel2007
+ * @copyright  Copyright (c) 2006 - 2014 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;
+			}
+		}
+	}
+}