Ejemplo n.º 1
0
 /**
  * Save PHPExcel to file
  *
  * @param     string         $pFilename
  * @throws     \PHPExcel\Writer\Exception
  */
 public function save($pFilename = null)
 {
     if ($this->spreadSheet !== null) {
         // garbage collect
         $this->spreadSheet->garbageCollect();
         // If $pFilename is php://output or php://stdout, make it a temporary file...
         $originalFilename = $pFilename;
         if (strtolower($pFilename) == 'php://output' || strtolower($pFilename) == 'php://stdout') {
             $pFilename = @tempnam(\PHPExcel\Shared\File::sysGetTempDir(), 'phpxltmp');
             if ($pFilename == '') {
                 $pFilename = $originalFilename;
             }
         }
         $saveDebugLog = \PHPExcel\Calculation::getInstance($this->spreadSheet)->getDebugLog()->getWriteDebugLog();
         \PHPExcel\Calculation::getInstance($this->spreadSheet)->getDebugLog()->setWriteDebugLog(false);
         $saveDateReturnType = \PHPExcel\Calculation\Functions::getReturnDateType();
         \PHPExcel\Calculation\Functions::setReturnDateType(\PHPExcel\Calculation\Functions::RETURNDATE_EXCEL);
         // Create string lookup table
         $this->stringTable = array();
         for ($i = 0; $i < $this->spreadSheet->getSheetCount(); ++$i) {
             $this->stringTable = $this->getWriterPart('StringTable')->createStringTable($this->spreadSheet->getSheet($i), $this->stringTable);
         }
         // Create styles dictionaries
         $this->styleHashTable->addFromSource($this->getWriterPart('Style')->allStyles($this->spreadSheet));
         $this->stylesConditionalHashTable->addFromSource($this->getWriterPart('Style')->allConditionalStyles($this->spreadSheet));
         $this->fillHashTable->addFromSource($this->getWriterPart('Style')->allFills($this->spreadSheet));
         $this->fontHashTable->addFromSource($this->getWriterPart('Style')->allFonts($this->spreadSheet));
         $this->bordersHashTable->addFromSource($this->getWriterPart('Style')->allBorders($this->spreadSheet));
         $this->numFmtHashTable->addFromSource($this->getWriterPart('Style')->allNumberFormats($this->spreadSheet));
         // Create drawing dictionary
         $this->drawingHashTable->addFromSource($this->getWriterPart('Drawing')->allDrawings($this->spreadSheet));
         // Create new ZIP file and open it for writing
         $zipClass = \PHPExcel\Settings::getZipClass();
         /** @var \ZipArchive $objZip */
         $objZip = new $zipClass();
         //    Retrieve OVERWRITE and CREATE constants from the instantiated zip class
         //    This method of accessing constant values from a dynamic class should work with all appropriate versions of PHP
         $ro = new \ReflectionObject($objZip);
         $zipOverWrite = $ro->getConstant('OVERWRITE');
         $zipCreate = $ro->getConstant('CREATE');
         if (file_exists($pFilename)) {
             unlink($pFilename);
         }
         // Try opening the ZIP file
         if ($objZip->open($pFilename, $zipOverWrite) !== true) {
             if ($objZip->open($pFilename, $zipCreate) !== true) {
                 throw new \PHPExcel\Writer\Exception("Could not open " . $pFilename . " for writing.");
             }
         }
         // Add [Content_Types].xml to ZIP file
         $objZip->addFromString('[Content_Types].xml', $this->getWriterPart('ContentTypes')->writeContentTypes($this->spreadSheet, $this->includeCharts));
         //if hasMacros, add the vbaProject.bin file, Certificate file(if exists)
         if ($this->spreadSheet->hasMacros()) {
             $macrosCode = $this->spreadSheet->getMacrosCode();
             if (!is_null($macrosCode)) {
                 // we have the code ?
                 $objZip->addFromString('xl/vbaProject.bin', $macrosCode);
                 //allways in 'xl', allways named vbaProject.bin
                 if ($this->spreadSheet->hasMacrosCertificate()) {
                     //signed macros ?
                     // Yes : add the certificate file and the related rels file
                     $objZip->addFromString('xl/vbaProjectSignature.bin', $this->spreadSheet->getMacrosCertificate());
                     $objZip->addFromString('xl/_rels/vbaProject.bin.rels', $this->getWriterPart('RelsVBA')->writeVBARelationships($this->spreadSheet));
                 }
             }
         }
         //a custom UI in this workbook ? add it ("base" xml and additional objects (pictures) and rels)
         if ($this->spreadSheet->hasRibbon()) {
             $tmpRibbonTarget = $this->spreadSheet->getRibbonXMLData('target');
             $objZip->addFromString($tmpRibbonTarget, $this->spreadSheet->getRibbonXMLData('data'));
             if ($this->spreadSheet->hasRibbonBinObjects()) {
                 $tmpRootPath = dirname($tmpRibbonTarget) . '/';
                 $ribbonBinObjects = $this->spreadSheet->getRibbonBinObjects('data');
                 //the files to write
                 foreach ($ribbonBinObjects as $aPath => $aContent) {
                     $objZip->addFromString($tmpRootPath . $aPath, $aContent);
                 }
                 //the rels for files
                 $objZip->addFromString($tmpRootPath . '_rels/' . basename($tmpRibbonTarget) . '.rels', $this->getWriterPart('RelsRibbonObjects')->writeRibbonRelationships($this->spreadSheet));
             }
         }
         // Add relationships to ZIP file
         $objZip->addFromString('_rels/.rels', $this->getWriterPart('Rels')->writeRelationships($this->spreadSheet));
         $objZip->addFromString('xl/_rels/workbook.xml.rels', $this->getWriterPart('Rels')->writeWorkbookRelationships($this->spreadSheet));
         // Add document properties to ZIP file
         $objZip->addFromString('docProps/app.xml', $this->getWriterPart('DocProps')->writeDocPropsApp($this->spreadSheet));
         $objZip->addFromString('docProps/core.xml', $this->getWriterPart('DocProps')->writeDocPropsCore($this->spreadSheet));
         $customPropertiesPart = $this->getWriterPart('DocProps')->writeDocPropsCustom($this->spreadSheet);
         if ($customPropertiesPart !== null) {
             $objZip->addFromString('docProps/custom.xml', $customPropertiesPart);
         }
         // Add theme to ZIP file
         $objZip->addFromString('xl/theme/theme1.xml', $this->getWriterPart('Theme')->writeTheme($this->spreadSheet));
         // Add string table to ZIP file
         $objZip->addFromString('xl/sharedStrings.xml', $this->getWriterPart('StringTable')->writeStringTable($this->stringTable));
         // Add styles to ZIP file
         $objZip->addFromString('xl/styles.xml', $this->getWriterPart('Style')->writeStyles($this->spreadSheet));
         // Add workbook to ZIP file
         $objZip->addFromString('xl/workbook.xml', $this->getWriterPart('Workbook')->writeWorkbook($this->spreadSheet, $this->preCalculateFormulas));
         $chartCount = 0;
         // Add worksheets
         for ($i = 0; $i < $this->spreadSheet->getSheetCount(); ++$i) {
             $objZip->addFromString('xl/worksheets/sheet' . ($i + 1) . '.xml', $this->getWriterPart('Worksheet')->writeWorksheet($this->spreadSheet->getSheet($i), $this->stringTable, $this->includeCharts));
             if ($this->includeCharts) {
                 $charts = $this->spreadSheet->getSheet($i)->getChartCollection();
                 if (count($charts) > 0) {
                     foreach ($charts as $chart) {
                         $objZip->addFromString('xl/charts/chart' . ($chartCount + 1) . '.xml', $this->getWriterPart('Chart')->writeChart($chart, $this->preCalculateFormulas));
                         $chartCount++;
                     }
                 }
             }
         }
         $chartRef1 = $chartRef2 = 0;
         // Add worksheet relationships (drawings, ...)
         for ($i = 0; $i < $this->spreadSheet->getSheetCount(); ++$i) {
             // Add relationships
             $objZip->addFromString('xl/worksheets/_rels/sheet' . ($i + 1) . '.xml.rels', $this->getWriterPart('Rels')->writeWorksheetRelationships($this->spreadSheet->getSheet($i), $i + 1, $this->includeCharts));
             $drawings = $this->spreadSheet->getSheet($i)->getDrawingCollection();
             $drawingCount = count($drawings);
             if ($this->includeCharts) {
                 $chartCount = $this->spreadSheet->getSheet($i)->getChartCount();
             }
             // Add drawing and image relationship parts
             if ($drawingCount > 0 || $chartCount > 0) {
                 // Drawing relationships
                 $objZip->addFromString('xl/drawings/_rels/drawing' . ($i + 1) . '.xml.rels', $this->getWriterPart('Rels')->writeDrawingRelationships($this->spreadSheet->getSheet($i), $chartRef1, $this->includeCharts));
                 // Drawings
                 $objZip->addFromString('xl/drawings/drawing' . ($i + 1) . '.xml', $this->getWriterPart('Drawing')->writeDrawings($this->spreadSheet->getSheet($i), $chartRef2, $this->includeCharts));
             }
             // Add comment relationship parts
             if (count($this->spreadSheet->getSheet($i)->getComments()) > 0) {
                 // VML Comments
                 $objZip->addFromString('xl/drawings/vmlDrawing' . ($i + 1) . '.vml', $this->getWriterPart('Comments')->writeVMLComments($this->spreadSheet->getSheet($i)));
                 // Comments
                 $objZip->addFromString('xl/comments' . ($i + 1) . '.xml', $this->getWriterPart('Comments')->writeComments($this->spreadSheet->getSheet($i)));
             }
             // Add header/footer relationship parts
             if (count($this->spreadSheet->getSheet($i)->getHeaderFooter()->getImages()) > 0) {
                 // VML Drawings
                 $objZip->addFromString('xl/drawings/vmlDrawingHF' . ($i + 1) . '.vml', $this->getWriterPart('Drawing')->writeVMLHeaderFooterImages($this->spreadSheet->getSheet($i)));
                 // VML Drawing relationships
                 $objZip->addFromString('xl/drawings/_rels/vmlDrawingHF' . ($i + 1) . '.vml.rels', $this->getWriterPart('Rels')->writeHeaderFooterDrawingRelationships($this->spreadSheet->getSheet($i)));
                 // Media
                 foreach ($this->spreadSheet->getSheet($i)->getHeaderFooter()->getImages() as $image) {
                     $objZip->addFromString('xl/media/' . $image->getIndexedFilename(), file_get_contents($image->getPath()));
                 }
             }
         }
         // Add media
         for ($i = 0; $i < $this->getDrawingHashTable()->count(); ++$i) {
             if ($this->getDrawingHashTable()->getByIndex($i) instanceof \PHPExcel\Worksheet\Drawing) {
                 $imageContents = null;
                 $imagePath = $this->getDrawingHashTable()->getByIndex($i)->getPath();
                 if (strpos($imagePath, 'zip://') !== false) {
                     $imagePath = substr($imagePath, 6);
                     $imagePathSplitted = explode('#', $imagePath);
                     $imageZip = new ZipArchive();
                     $imageZip->open($imagePathSplitted[0]);
                     $imageContents = $imageZip->getFromName($imagePathSplitted[1]);
                     $imageZip->close();
                     unset($imageZip);
                 } else {
                     $imageContents = file_get_contents($imagePath);
                 }
                 $objZip->addFromString('xl/media/' . str_replace(' ', '_', $this->getDrawingHashTable()->getByIndex($i)->getIndexedFilename()), $imageContents);
             } elseif ($this->getDrawingHashTable()->getByIndex($i) instanceof \PHPExcel\Worksheet\MemoryDrawing) {
                 ob_start();
                 call_user_func($this->getDrawingHashTable()->getByIndex($i)->getRenderingFunction(), $this->getDrawingHashTable()->getByIndex($i)->getImageResource());
                 $imageContents = ob_get_contents();
                 ob_end_clean();
                 $objZip->addFromString('xl/media/' . str_replace(' ', '_', $this->getDrawingHashTable()->getByIndex($i)->getIndexedFilename()), $imageContents);
             }
         }
         \PHPExcel\Calculation\Functions::setReturnDateType($saveDateReturnType);
         \PHPExcel\Calculation::getInstance($this->spreadSheet)->getDebugLog()->setWriteDebugLog($saveDebugLog);
         // Close file
         if ($objZip->close() === false) {
             throw new \PHPExcel\Writer\Exception("Could not close zip file {$pFilename}.");
         }
         // If a temporary file was used, copy it to the correct file stream
         if ($originalFilename != $pFilename) {
             if (copy($pFilename, $originalFilename) === false) {
                 throw new \PHPExcel\Writer\Exception("Could not copy temporary zip file {$pFilename} to {$originalFilename}.");
             }
             @unlink($pFilename);
         }
     } else {
         throw new \PHPExcel\Writer\Exception("PHPExcel object unassigned.");
     }
 }
Ejemplo n.º 2
0
 /**
  * Get image mime type
  *
  * @param     string    $pFile    Filename
  * @return     string    Mime Type
  * @throws     \PHPExcel\Writer\Exception
  */
 private function getImageMimeType($pFile = '')
 {
     if (\PHPExcel\Shared\File::fileExists($pFile)) {
         $image = getimagesize($pFile);
         return image_type_to_mime_type($image[2]);
     } else {
         throw new \PHPExcel\Writer\Exception("File {$pFile} does not exist");
     }
 }
Ejemplo n.º 3
0
 /**
  *  Create a new PDF Writer instance
  *
  *  @param     \PHPExcel\Spreadsheet    $phpExcel    Spreadsheet object
  */
 public function __construct(\PHPExcel\Spreadsheet $phpExcel)
 {
     parent::__construct($phpExcel);
     $this->setUseInlineCss(true);
     $this->tempDir = \PHPExcel\Shared\File::sysGetTempDir();
 }
Ejemplo n.º 4
0
 /**
  * Open a new zip archive
  *
  * @param    string    $fileName    Filename for the zip archive
  * @return    boolean
  */
 public function open($fileName)
 {
     $this->tempDir = File::sysGetTempDir();
     $this->zip = new PclZip($fileName);
     return true;
 }
Ejemplo n.º 5
0
 /**
  * Loads Spreadsheet from file
  *
  * @param     string         $pFilename
  * @return    Spreadsheet
  * @throws    Exception
  */
 public function load($pFilename)
 {
     // Check if file exists
     if (!file_exists($pFilename)) {
         throw new Exception("Could not open " . $pFilename . " for reading! File does not exist.");
     }
     // Initialisations
     $excel = new \PHPExcel\Spreadsheet();
     $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->securityScan($this->getFromZipArchive($zip, "xl/_rels/workbook.xml.rels")), 'SimpleXMLElement', \PHPExcel\Settings::getLibXmlLoaderOptions());
     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->securityScan($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 Excel2007\Theme($themeName, $colourSchemeName, $themeColours);
                 }
                 break;
         }
     }
     $rels = simplexml_load_string($this->securityScan($this->getFromZipArchive($zip, "_rels/.rels")), 'SimpleXMLElement', \PHPExcel\Settings::getLibXmlLoaderOptions());
     foreach ($rels->Relationship as $rel) {
         switch ($rel["Type"]) {
             case "http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties":
                 $xmlCore = simplexml_load_string($this->securityScan($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::getArrayItem($xmlCore->xpath("dc:creator")));
                     $docProps->setLastModifiedBy((string) self::getArrayItem($xmlCore->xpath("cp:lastModifiedBy")));
                     $docProps->setCreated(strtotime(self::getArrayItem($xmlCore->xpath("dcterms:created"))));
                     //! respect xsi:type
                     $docProps->setModified(strtotime(self::getArrayItem($xmlCore->xpath("dcterms:modified"))));
                     //! respect xsi:type
                     $docProps->setTitle((string) self::getArrayItem($xmlCore->xpath("dc:title")));
                     $docProps->setDescription((string) self::getArrayItem($xmlCore->xpath("dc:description")));
                     $docProps->setSubject((string) self::getArrayItem($xmlCore->xpath("dc:subject")));
                     $docProps->setKeywords((string) self::getArrayItem($xmlCore->xpath("cp:keywords")));
                     $docProps->setCategory((string) self::getArrayItem($xmlCore->xpath("cp:category")));
                 }
                 break;
             case "http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties":
                 $xmlCore = simplexml_load_string($this->securityScan($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->securityScan($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\Document\Properties::convertProperty($attributeValue, $attributeType);
                             $attributeType = \PHPExcel\Document\Properties::convertPropertyType($attributeType);
                             $docProps->setCustomProperty($propertyName, $attributeValue, $attributeType);
                         }
                     }
                 }
                 break;
                 //Ribbon
             //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->securityScan($this->getFromZipArchive($zip, "{$dir}/_rels/" . basename($rel["Target"]) . ".rels")), 'SimpleXMLElement', \PHPExcel\Settings::getLibXmlLoaderOptions());
                 $relsWorkbook->registerXPathNamespace("rel", "http://schemas.openxmlformats.org/package/2006/relationships");
                 $sharedStrings = array();
                 $xpath = self::getArrayItem($relsWorkbook->xpath("rel:Relationship[@Type='http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings']"));
                 $xmlStrings = simplexml_load_string($this->securityScan($this->getFromZipArchive($zip, "{$dir}/{$xpath['Target']}")), 'SimpleXMLElement', \PHPExcel\Settings::getLibXmlLoaderOptions());
                 if (isset($xmlStrings) && isset($xmlStrings->si)) {
                     foreach ($xmlStrings->si as $val) {
                         if (isset($val->t)) {
                             $sharedStrings[] = \PHPExcel\Shared\StringHelper::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)
                         // 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::getArrayItem($relsWorkbook->xpath("rel:Relationship[@Type='http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles']"));
                 $xmlStyles = simplexml_load_string($this->securityScan($this->getFromZipArchive($zip, "{$dir}/{$xpath['Target']}")), 'SimpleXMLElement', \PHPExcel\Settings::getLibXmlLoaderOptions());
                 $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::getArrayItem($numFmts->xpath("sml:numFmt[@numFmtId={$xf['numFmtId']}]"));
                                 if (isset($tmpNumFmt["formatCode"])) {
                                     $numFmt = (string) $tmpNumFmt["formatCode"];
                                 }
                             }
                             // We shouldn't override any of the built-in MS Excel values (values below id 164)
                             //  But there's a lot of naughty homebrew xlsx writers that do use "reserved" id values that aren't actually used
                             //  So we make allowance for them rather than lose formatting masks
                             if ((int) $xf["numFmtId"] < 164 && \PHPExcel\Style\NumberFormat::builtInFormatCode((int) $xf["numFmtId"]) !== '') {
                                 $numFmt = \PHPExcel\Style\NumberFormat::builtInFormatCode((int) $xf["numFmtId"]);
                             }
                         }
                         $quotePrefix = false;
                         if (isset($xf["quotePrefix"])) {
                             $quotePrefix = (bool) $xf["quotePrefix"];
                         }
                         $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::getArrayItem($numFmts->xpath("sml:numFmt[@numFmtId={$xf['numFmtId']}]"));
                             if (isset($tmpNumFmt["formatCode"])) {
                                 $numFmt = (string) $tmpNumFmt["formatCode"];
                             } elseif ((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->securityScan($this->getFromZipArchive($zip, "{$rel['Target']}")), 'SimpleXMLElement', \PHPExcel\Settings::getLibXmlLoaderOptions());
                 // 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::getArrayItem($eleSheet->attributes("http://schemas.openxmlformats.org/officeDocument/2006/relationships"), "id")];
                         $xmlSheet = simplexml_load_string($this->securityScan($this->getFromZipArchive($zip, "{$dir}/{$fileWorksheet}")), 'SimpleXMLElement', \PHPExcel\Settings::getLibXmlLoaderOptions());
                         $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((double) $xmlSheet->sheetFormatPr['defaultRowHeight']);
                             }
                             if (isset($xmlSheet->sheetFormatPr['defaultColWidth'])) {
                                 $docSheet->getDefaultColumnDimension()->setWidth((double) $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::castToBoolean($c);
                                             } else {
                                                 // Formula
                                                 $this->castToFormula($c, $r, $cellDataType, $value, $calculatedValue, $sharedFormulas, 'castToBoolean');
                                                 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;
                                             if (isset($c->f)) {
                                                 $this->castToFormula($c, $r, $cellDataType, $value, $calculatedValue, $sharedFormulas, 'castToError');
                                             } else {
                                                 $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 == (double) $value) {
                                             $value = (double) $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
                                 $cellBlocks = explode(' ', str_replace('$', '', strtoupper($ref)));
                                 foreach ($cellBlocks as $cellBlock) {
                                     $docSheet->getStyle($cellBlock)->setConditionalStyles($conditionalStyles);
                                 }
                             }
                         }
                         $aKeys = ["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) {
                             $autoFilterRange = (string) $xmlSheet->autoFilter["ref"];
                             if (strpos($autoFilterRange, ':') !== false) {
                                 $autoFilter = $docSheet->getAutoFilter();
                                 $autoFilter->setRange($autoFilterRange);
                                 foreach ($xmlSheet->autoFilter->filterColumn as $filterColumn) {
                                     $column = $autoFilter->getColumnByOffset((int) $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) {
                                             //    Operator is undefined, but always treated as EQUAL
                                             $column->createRule()->setRule(null, '')->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) {
                                             //    Operator is undefined, but always treated as EQUAL
                                             $column->createRule()->setRule(null, (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, 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, (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
                                     foreach (\PHPExcel\Cell::extractAllCellReferencesInRange($stRange) 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->securityScan($this->getFromZipArchive($zip, dirname("{$dir}/{$fileWorksheet}") . "/_rels/" . basename($fileWorksheet) . ".rels")), 'SimpleXMLElement', \PHPExcel\Settings::getLibXmlLoaderOptions());
                                 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->securityScan($this->getFromZipArchive($zip, dirname("{$dir}/{$fileWorksheet}") . "/_rels/" . basename($fileWorksheet) . ".rels")), 'SimpleXMLElement', \PHPExcel\Settings::getLibXmlLoaderOptions());
                                 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->securityScan($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) {
                                     if (!empty($comment['authorId'])) {
                                         $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->securityScan($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->securityScan($this->getFromZipArchive($zip, dirname("{$dir}/{$fileWorksheet}") . "/_rels/" . basename($fileWorksheet) . ".rels")), 'SimpleXMLElement', \PHPExcel\Settings::getLibXmlLoaderOptions());
                                     $vmlRelationship = '';
                                     foreach ($relsWorksheet->Relationship as $ele) {
                                         if ($ele["Type"] == "http://schemas.openxmlformats.org/officeDocument/2006/relationships/vmlDrawing") {
                                             $vmlRelationship = self::dirAdd("{$dir}/{$fileWorksheet}", $ele["Target"]);
                                         }
                                     }
                                     if ($vmlRelationship != '') {
                                         // Fetch linked images
                                         $relsVML = simplexml_load_string($this->securityScan($this->getFromZipArchive($zip, dirname($vmlRelationship) . '/_rels/' . basename($vmlRelationship) . '.rels')), 'SimpleXMLElement', \PHPExcel\Settings::getLibXmlLoaderOptions());
                                         $drawings = array();
                                         foreach ($relsVML->Relationship as $ele) {
                                             if ($ele["Type"] == "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image") {
                                                 $drawings[(string) $ele["Id"]] = self::dirAdd($vmlRelationship, $ele["Target"]);
                                             }
                                         }
                                         // Fetch VML document
                                         $vmlDrawing = simplexml_load_string($this->securityScan($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->securityScan($this->getFromZipArchive($zip, dirname("{$dir}/{$fileWorksheet}") . "/_rels/" . basename($fileWorksheet) . ".rels")), 'SimpleXMLElement', \PHPExcel\Settings::getLibXmlLoaderOptions());
                             $drawings = array();
                             foreach ($relsWorksheet->Relationship as $ele) {
                                 if ($ele["Type"] == "http://schemas.openxmlformats.org/officeDocument/2006/relationships/drawing") {
                                     $drawings[(string) $ele["Id"]] = self::dirAdd("{$dir}/{$fileWorksheet}", $ele["Target"]);
                                 }
                             }
                             if ($xmlSheet->drawing && !$this->readDataOnly) {
                                 foreach ($xmlSheet->drawing as $drawing) {
                                     $fileDrawing = $drawings[(string) self::getArrayItem($drawing->attributes("http://schemas.openxmlformats.org/officeDocument/2006/relationships"), "id")];
                                     $relsDrawing = simplexml_load_string($this->securityScan($this->getFromZipArchive($zip, dirname($fileDrawing) . "/_rels/" . basename($fileDrawing) . ".rels")), 'SimpleXMLElement', \PHPExcel\Settings::getLibXmlLoaderOptions());
                                     $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::dirAdd($fileDrawing, $ele["Target"]);
                                             } elseif ($ele["Type"] == "http://schemas.openxmlformats.org/officeDocument/2006/relationships/chart") {
                                                 if ($this->includeCharts) {
                                                     $charts[self::dirAdd($fileDrawing, $ele["Target"])] = array('id' => (string) $ele["Id"], 'sheet' => $docSheet->getTitle());
                                                 }
                                             }
                                         }
                                     }
                                     $xmlDrawing = simplexml_load_string($this->securityScan($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::getArrayItem($oneCellAnchor->pic->nvPicPr->cNvPr->attributes(), "name"));
                                                 $objDrawing->setDescription((string) self::getArrayItem($oneCellAnchor->pic->nvPicPr->cNvPr->attributes(), "descr"));
                                                 $objDrawing->setPath("zip://" . \PHPExcel\Shared\File::realpath($pFilename) . "#" . $images[(string) self::getArrayItem($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::getArrayItem($oneCellAnchor->ext->attributes(), "cx")));
                                                 $objDrawing->setHeight(\PHPExcel\Shared\Drawing::EMUToPixels(self::getArrayItem($oneCellAnchor->ext->attributes(), "cy")));
                                                 if ($xfrm) {
                                                     $objDrawing->setRotation(\PHPExcel\Shared\Drawing::angleToDegrees(self::getArrayItem($xfrm->attributes(), "rot")));
                                                 }
                                                 if ($outerShdw) {
                                                     $shadow = $objDrawing->getShadow();
                                                     $shadow->setVisible(true);
                                                     $shadow->setBlurRadius(\PHPExcel\Shared\Drawing::EMUTopixels(self::getArrayItem($outerShdw->attributes(), "blurRad")));
                                                     $shadow->setDistance(\PHPExcel\Shared\Drawing::EMUTopixels(self::getArrayItem($outerShdw->attributes(), "dist")));
                                                     $shadow->setDirection(\PHPExcel\Shared\Drawing::angleToDegrees(self::getArrayItem($outerShdw->attributes(), "dir")));
                                                     $shadow->setAlignment((string) self::getArrayItem($outerShdw->attributes(), "algn"));
                                                     $shadow->getColor()->setRGB(self::getArrayItem($outerShdw->srgbClr->attributes(), "val"));
                                                     $shadow->setAlpha(self::getArrayItem($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::getArrayItem($oneCellAnchor->ext->attributes(), "cx"));
                                                 $height = \PHPExcel\Shared\Drawing::EMUToPixels(self::getArrayItem($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::getArrayItem($twoCellAnchor->pic->nvPicPr->cNvPr->attributes(), "name"));
                                                 $objDrawing->setDescription((string) self::getArrayItem($twoCellAnchor->pic->nvPicPr->cNvPr->attributes(), "descr"));
                                                 $objDrawing->setPath("zip://" . \PHPExcel\Shared\File::realpath($pFilename) . "#" . $images[(string) self::getArrayItem($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);
                                                 if ($xfrm) {
                                                     $objDrawing->setWidth(\PHPExcel\Shared\Drawing::EMUToPixels(self::getArrayItem($xfrm->ext->attributes(), "cx")));
                                                     $objDrawing->setHeight(\PHPExcel\Shared\Drawing::EMUToPixels(self::getArrayItem($xfrm->ext->attributes(), "cy")));
                                                     $objDrawing->setRotation(\PHPExcel\Shared\Drawing::angleToDegrees(self::getArrayItem($xfrm->attributes(), "rot")));
                                                 }
                                                 if ($outerShdw) {
                                                     $shadow = $objDrawing->getShadow();
                                                     $shadow->setVisible(true);
                                                     $shadow->setBlurRadius(\PHPExcel\Shared\Drawing::EMUTopixels(self::getArrayItem($outerShdw->attributes(), "blurRad")));
                                                     $shadow->setDistance(\PHPExcel\Shared\Drawing::EMUTopixels(self::getArrayItem($outerShdw->attributes(), "dist")));
                                                     $shadow->setDirection(\PHPExcel\Shared\Drawing::angleToDegrees(self::getArrayItem($outerShdw->attributes(), "dir")));
                                                     $shadow->setAlignment((string) self::getArrayItem($outerShdw->attributes(), "algn"));
                                                     $shadow->getColor()->setRGB(self::getArrayItem($outerShdw->srgbClr->attributes(), "val"));
                                                     $shadow->setAlpha(self::getArrayItem($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') {
                                                 $extractedRange = explode(',', $extractedRange);
                                                 foreach ($extractedRange as $range) {
                                                     $autoFilterRange = $range;
                                                     if (strpos($autoFilterRange, ':') !== false) {
                                                         $docSheet->getAutoFilter()->setRange($autoFilterRange);
                                                     }
                                                 }
                                             }
                                             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]));
                                                 } elseif (preg_match('/!?(\\d+)\\:(\\d+)$/', $range, $matches)) {
                                                     // check for repeating rows, e.g. '1:1' or '1:5'
                                                     $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[(int) $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[(int) $definedName['localSheetId']]);
                                                     $excel->addNamedRange(new \PHPExcel\NamedRange((string) $definedName['name'], $worksheet, $extractedRange, true, $scope));
                                                 }
                                             }
                                         }
                                         break;
                                 }
                             } elseif (!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->securityScan($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->securityScan($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;
 }
Ejemplo n.º 6
0
 /**
  * Save PHPExcel to file
  *
  * @param  string  $pFilename
  * @throws \PHPExcel\Writer\Exception
  */
 public function save($pFilename = null)
 {
     if (!$this->spreadSheet) {
         throw new \PHPExcel\Writer\Exception('PHPExcel object unassigned.');
     }
     // garbage collect
     $this->spreadSheet->garbageCollect();
     // If $pFilename is php://output or php://stdout, make it a temporary file...
     $originalFilename = $pFilename;
     if (strtolower($pFilename) == 'php://output' || strtolower($pFilename) == 'php://stdout') {
         $pFilename = @tempnam(\PHPExcel\Shared\File::sysGetTempDir(), 'phpxltmp');
         if ($pFilename == '') {
             $pFilename = $originalFilename;
         }
     }
     $objZip = $this->createZip($pFilename);
     $objZip->addFromString('META-INF/manifest.xml', $this->getWriterPart('meta_inf')->writeManifest());
     $objZip->addFromString('Thumbnails/thumbnail.png', $this->getWriterPart('thumbnails')->writeThumbnail());
     $objZip->addFromString('content.xml', $this->getWriterPart('content')->write());
     $objZip->addFromString('meta.xml', $this->getWriterPart('meta')->write());
     $objZip->addFromString('mimetype', $this->getWriterPart('mimetype')->write());
     $objZip->addFromString('settings.xml', $this->getWriterPart('settings')->write());
     $objZip->addFromString('styles.xml', $this->getWriterPart('styles')->write());
     // Close file
     if ($objZip->close() === false) {
         throw new \PHPExcel\Writer\Exception("Could not close zip file {$pFilename}.");
     }
     // If a temporary file was used, copy it to the correct file stream
     if ($originalFilename != $pFilename) {
         if (copy($pFilename, $originalFilename) === false) {
             throw new \PHPExcel\Writer\Exception("Could not copy temporary zip file {$pFilename} to {$originalFilename}.");
         }
         @unlink($pFilename);
     }
 }
Ejemplo n.º 7
0
 /**
  * Generate chart tag in cell
  *
  * @param    \PHPExcel\Worksheet    $pSheet            \PHPExcel\Worksheet
  * @param    string                $coordinates    Cell coordinates
  * @return    string
  * @throws    \PHPExcel\Writer\Exception
  */
 private function writeChartInCell(\PHPExcel\Worksheet $pSheet, $coordinates)
 {
     // Construct HTML
     $html = '';
     // Write charts
     foreach ($pSheet->getChartCollection() as $chart) {
         if ($chart instanceof PHPExcel_Chart) {
             $chartCoordinates = $chart->getTopLeftPosition();
             if ($chartCoordinates['cell'] == $coordinates) {
                 $chartFileName = \PHPExcel\Shared\File::sysGetTempDir() . '/' . uniqid() . '.png';
                 if (!$chart->render($chartFileName)) {
                     return;
                 }
                 $html .= PHP_EOL;
                 $imageDetails = getimagesize($chartFileName);
                 if ($fp = fopen($chartFileName, "rb", 0)) {
                     $picture = fread($fp, filesize($chartFileName));
                     fclose($fp);
                     // base64 encode the binary data, then break it
                     // into chunks according to RFC 2045 semantics
                     $base64 = chunk_split(base64_encode($picture));
                     $imageData = 'data:' . $imageDetails['mime'] . ';base64,' . $base64;
                     $html .= '<div style="position: relative;">';
                     $html .= '<img style="position: absolute; z-index: 1; left: ' . $chartCoordinates['xOffset'] . 'px; top: ' . $chartCoordinates['yOffset'] . 'px; width: ' . $imageDetails[0] . 'px; height: ' . $imageDetails[1] . 'px;" src="' . $imageData . '" border="0" />' . PHP_EOL;
                     $html .= '</div>';
                     unlink($chartFileName);
                 }
             }
         }
     }
     // Return
     return $html;
 }
Ejemplo n.º 8
0
 /**
  * Initialise this new cell collection
  *
  * @param    \PHPExcel\Worksheet    $parent        The worksheet for this cell collection
  * @param    array of mixed        $arguments    Additional initialisation arguments
  */
 public function __construct(\PHPExcel\Worksheet $parent, $arguments)
 {
     $this->cacheDirectory = isset($arguments['dir']) && $arguments['dir'] !== null ? $arguments['dir'] : \PHPExcel\Shared\File::sysGetTempDir();
     parent::__construct($parent);
     if (is_null($this->fileHandle)) {
         $baseUnique = $this->getUniqueID();
         $this->fileName = $this->cacheDirectory . '/PHPExcel.' . $baseUnique . '.cache';
         $this->fileHandle = fopen($this->fileName, 'a+');
     }
 }