diff options
Diffstat (limited to 'vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader')
41 files changed, 19047 insertions, 0 deletions
diff --git a/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/BaseReader.php b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/BaseReader.php new file mode 100644 index 0000000..81de248 --- /dev/null +++ b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/BaseReader.php @@ -0,0 +1,161 @@ +<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader;
+
+use PhpOffice\PhpSpreadsheet\Reader\Exception as ReaderException;
+use PhpOffice\PhpSpreadsheet\Reader\Security\XmlScanner;
+use PhpOffice\PhpSpreadsheet\Shared\File;
+
+abstract class BaseReader implements IReader
+{
+ /**
+ * Read data only?
+ * Identifies whether the Reader should only read data values for cells, and ignore any formatting information;
+ * or whether it should read both data and formatting.
+ *
+ * @var bool
+ */
+ protected $readDataOnly = false;
+
+ /**
+ * Read empty cells?
+ * Identifies whether the Reader should read data values for cells all cells, or should ignore cells containing
+ * null value or empty string.
+ *
+ * @var bool
+ */
+ protected $readEmptyCells = true;
+
+ /**
+ * Read charts that are defined in the workbook?
+ * Identifies whether the Reader should read the definitions for any charts that exist in the workbook;.
+ *
+ * @var bool
+ */
+ protected $includeCharts = false;
+
+ /**
+ * Restrict which sheets should be loaded?
+ * This property holds an array of worksheet names to be loaded. If null, then all worksheets will be loaded.
+ *
+ * @var array of string
+ */
+ protected $loadSheetsOnly;
+
+ /**
+ * IReadFilter instance.
+ *
+ * @var IReadFilter
+ */
+ protected $readFilter;
+
+ protected $fileHandle;
+
+ /**
+ * @var XmlScanner
+ */
+ protected $securityScanner;
+
+ public function __construct()
+ {
+ $this->readFilter = new DefaultReadFilter();
+ }
+
+ public function getReadDataOnly()
+ {
+ return $this->readDataOnly;
+ }
+
+ public function setReadDataOnly($pValue)
+ {
+ $this->readDataOnly = (bool) $pValue;
+
+ return $this;
+ }
+
+ public function getReadEmptyCells()
+ {
+ return $this->readEmptyCells;
+ }
+
+ public function setReadEmptyCells($pValue)
+ {
+ $this->readEmptyCells = (bool) $pValue;
+
+ return $this;
+ }
+
+ public function getIncludeCharts()
+ {
+ return $this->includeCharts;
+ }
+
+ public function setIncludeCharts($pValue)
+ {
+ $this->includeCharts = (bool) $pValue;
+
+ return $this;
+ }
+
+ public function getLoadSheetsOnly()
+ {
+ return $this->loadSheetsOnly;
+ }
+
+ public function setLoadSheetsOnly($value)
+ {
+ if ($value === null) {
+ return $this->setLoadAllSheets();
+ }
+
+ $this->loadSheetsOnly = is_array($value) ? $value : [$value];
+
+ return $this;
+ }
+
+ public function setLoadAllSheets()
+ {
+ $this->loadSheetsOnly = null;
+
+ return $this;
+ }
+
+ public function getReadFilter()
+ {
+ return $this->readFilter;
+ }
+
+ public function setReadFilter(IReadFilter $pValue)
+ {
+ $this->readFilter = $pValue;
+
+ return $this;
+ }
+
+ public function getSecurityScanner()
+ {
+ return $this->securityScanner;
+ }
+
+ /**
+ * Open file for reading.
+ *
+ * @param string $pFilename
+ */
+ protected function openFile($pFilename): void
+ {
+ if ($pFilename) {
+ File::assertFile($pFilename);
+
+ // Open file
+ $fileHandle = fopen($pFilename, 'rb');
+ } else {
+ $fileHandle = false;
+ }
+ if ($fileHandle !== false) {
+ $this->fileHandle = $fileHandle;
+ } else {
+ throw new ReaderException('Could not open file ' . $pFilename . ' for reading.');
+ }
+ }
+}
diff --git a/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Csv.php b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Csv.php new file mode 100644 index 0000000..cbfa61a --- /dev/null +++ b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Csv.php @@ -0,0 +1,534 @@ +<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader;
+
+use InvalidArgumentException;
+use PhpOffice\PhpSpreadsheet\Cell\Coordinate;
+use PhpOffice\PhpSpreadsheet\Shared\StringHelper;
+use PhpOffice\PhpSpreadsheet\Spreadsheet;
+
+class Csv extends BaseReader
+{
+ /**
+ * Input encoding.
+ *
+ * @var string
+ */
+ private $inputEncoding = 'UTF-8';
+
+ /**
+ * Delimiter.
+ *
+ * @var string
+ */
+ private $delimiter;
+
+ /**
+ * Enclosure.
+ *
+ * @var string
+ */
+ private $enclosure = '"';
+
+ /**
+ * Sheet index to read.
+ *
+ * @var int
+ */
+ private $sheetIndex = 0;
+
+ /**
+ * Load rows contiguously.
+ *
+ * @var bool
+ */
+ private $contiguous = false;
+
+ /**
+ * The character that can escape the enclosure.
+ *
+ * @var string
+ */
+ private $escapeCharacter = '\\';
+
+ /**
+ * Create a new CSV Reader instance.
+ */
+ public function __construct()
+ {
+ parent::__construct();
+ }
+
+ /**
+ * Set input encoding.
+ *
+ * @param string $pValue Input encoding, eg: 'UTF-8'
+ *
+ * @return $this
+ */
+ public function setInputEncoding($pValue)
+ {
+ $this->inputEncoding = $pValue;
+
+ return $this;
+ }
+
+ /**
+ * Get input encoding.
+ *
+ * @return string
+ */
+ public function getInputEncoding()
+ {
+ return $this->inputEncoding;
+ }
+
+ /**
+ * Move filepointer past any BOM marker.
+ */
+ protected function skipBOM(): void
+ {
+ rewind($this->fileHandle);
+
+ switch ($this->inputEncoding) {
+ case 'UTF-8':
+ fgets($this->fileHandle, 4) == "\xEF\xBB\xBF" ?
+ fseek($this->fileHandle, 3) : fseek($this->fileHandle, 0);
+
+ break;
+ }
+ }
+
+ /**
+ * Identify any separator that is explicitly set in the file.
+ */
+ protected function checkSeparator(): void
+ {
+ $line = fgets($this->fileHandle);
+ if ($line === false) {
+ return;
+ }
+
+ if ((strlen(trim($line, "\r\n")) == 5) && (stripos($line, 'sep=') === 0)) {
+ $this->delimiter = substr($line, 4, 1);
+
+ return;
+ }
+
+ $this->skipBOM();
+ }
+
+ /**
+ * Infer the separator if it isn't explicitly set in the file or specified by the user.
+ */
+ protected function inferSeparator(): void
+ {
+ if ($this->delimiter !== null) {
+ return;
+ }
+
+ $potentialDelimiters = [',', ';', "\t", '|', ':', ' ', '~'];
+ $counts = [];
+ foreach ($potentialDelimiters as $delimiter) {
+ $counts[$delimiter] = [];
+ }
+
+ // Count how many times each of the potential delimiters appears in each line
+ $numberLines = 0;
+ while (($line = $this->getNextLine()) !== false && (++$numberLines < 1000)) {
+ $countLine = [];
+ for ($i = strlen($line) - 1; $i >= 0; --$i) {
+ $char = $line[$i];
+ if (isset($counts[$char])) {
+ if (!isset($countLine[$char])) {
+ $countLine[$char] = 0;
+ }
+ ++$countLine[$char];
+ }
+ }
+ foreach ($potentialDelimiters as $delimiter) {
+ $counts[$delimiter][] = $countLine[$delimiter]
+ ?? 0;
+ }
+ }
+
+ // If number of lines is 0, nothing to infer : fall back to the default
+ if ($numberLines === 0) {
+ $this->delimiter = reset($potentialDelimiters);
+ $this->skipBOM();
+
+ return;
+ }
+
+ // Calculate the mean square deviations for each delimiter (ignoring delimiters that haven't been found consistently)
+ $meanSquareDeviations = [];
+ $middleIdx = floor(($numberLines - 1) / 2);
+
+ foreach ($potentialDelimiters as $delimiter) {
+ $series = $counts[$delimiter];
+ sort($series);
+
+ $median = ($numberLines % 2)
+ ? $series[$middleIdx]
+ : ($series[$middleIdx] + $series[$middleIdx + 1]) / 2;
+
+ if ($median === 0) {
+ continue;
+ }
+
+ $meanSquareDeviations[$delimiter] = array_reduce(
+ $series,
+ function ($sum, $value) use ($median) {
+ return $sum + ($value - $median) ** 2;
+ }
+ ) / count($series);
+ }
+
+ // ... and pick the delimiter with the smallest mean square deviation (in case of ties, the order in potentialDelimiters is respected)
+ $min = INF;
+ foreach ($potentialDelimiters as $delimiter) {
+ if (!isset($meanSquareDeviations[$delimiter])) {
+ continue;
+ }
+
+ if ($meanSquareDeviations[$delimiter] < $min) {
+ $min = $meanSquareDeviations[$delimiter];
+ $this->delimiter = $delimiter;
+ }
+ }
+
+ // If no delimiter could be detected, fall back to the default
+ if ($this->delimiter === null) {
+ $this->delimiter = reset($potentialDelimiters);
+ }
+
+ $this->skipBOM();
+ }
+
+ /**
+ * Get the next full line from the file.
+ *
+ * @return false|string
+ */
+ private function getNextLine()
+ {
+ $line = '';
+ $enclosure = '(?<!' . preg_quote($this->escapeCharacter, '/') . ')' . preg_quote($this->enclosure, '/');
+
+ do {
+ // Get the next line in the file
+ $newLine = fgets($this->fileHandle);
+
+ // Return false if there is no next line
+ if ($newLine === false) {
+ return false;
+ }
+
+ // Add the new line to the line passed in
+ $line = $line . $newLine;
+
+ // Drop everything that is enclosed to avoid counting false positives in enclosures
+ $line = preg_replace('/(' . $enclosure . '.*' . $enclosure . ')/Us', '', $line);
+
+ // See if we have any enclosures left in the line
+ // if we still have an enclosure then we need to read the next line as well
+ } while (preg_match('/(' . $enclosure . ')/', $line) > 0);
+
+ return $line;
+ }
+
+ /**
+ * Return worksheet info (Name, Last Column Letter, Last Column Index, Total Rows, Total Columns).
+ *
+ * @param string $pFilename
+ *
+ * @return array
+ */
+ public function listWorksheetInfo($pFilename)
+ {
+ // Open file
+ $this->openFileOrMemory($pFilename);
+ $fileHandle = $this->fileHandle;
+
+ // Skip BOM, if any
+ $this->skipBOM();
+ $this->checkSeparator();
+ $this->inferSeparator();
+
+ $worksheetInfo = [];
+ $worksheetInfo[0]['worksheetName'] = 'Worksheet';
+ $worksheetInfo[0]['lastColumnLetter'] = 'A';
+ $worksheetInfo[0]['lastColumnIndex'] = 0;
+ $worksheetInfo[0]['totalRows'] = 0;
+ $worksheetInfo[0]['totalColumns'] = 0;
+
+ // Loop through each line of the file in turn
+ while (($rowData = fgetcsv($fileHandle, 0, $this->delimiter, $this->enclosure, $this->escapeCharacter)) !== false) {
+ ++$worksheetInfo[0]['totalRows'];
+ $worksheetInfo[0]['lastColumnIndex'] = max($worksheetInfo[0]['lastColumnIndex'], count($rowData) - 1);
+ }
+
+ $worksheetInfo[0]['lastColumnLetter'] = Coordinate::stringFromColumnIndex($worksheetInfo[0]['lastColumnIndex'] + 1);
+ $worksheetInfo[0]['totalColumns'] = $worksheetInfo[0]['lastColumnIndex'] + 1;
+
+ // Close file
+ fclose($fileHandle);
+
+ return $worksheetInfo;
+ }
+
+ /**
+ * Loads Spreadsheet from file.
+ *
+ * @param string $pFilename
+ *
+ * @return Spreadsheet
+ */
+ public function load($pFilename)
+ {
+ // Create new Spreadsheet
+ $spreadsheet = new Spreadsheet();
+
+ // Load into this instance
+ return $this->loadIntoExisting($pFilename, $spreadsheet);
+ }
+
+ private function openFileOrMemory($pFilename): void
+ {
+ // Open file
+ $fhandle = $this->canRead($pFilename);
+ if (!$fhandle) {
+ throw new Exception($pFilename . ' is an Invalid Spreadsheet file.');
+ }
+ $this->openFile($pFilename);
+ if ($this->inputEncoding !== 'UTF-8') {
+ fclose($this->fileHandle);
+ $entireFile = file_get_contents($pFilename);
+ $this->fileHandle = fopen('php://memory', 'r+b');
+ $data = StringHelper::convertEncoding($entireFile, 'UTF-8', $this->inputEncoding);
+ fwrite($this->fileHandle, $data);
+ rewind($this->fileHandle);
+ }
+ }
+
+ /**
+ * Loads PhpSpreadsheet from file into PhpSpreadsheet instance.
+ *
+ * @param string $pFilename
+ *
+ * @return Spreadsheet
+ */
+ public function loadIntoExisting($pFilename, Spreadsheet $spreadsheet)
+ {
+ $lineEnding = ini_get('auto_detect_line_endings');
+ ini_set('auto_detect_line_endings', true);
+
+ // Open file
+ $this->openFileOrMemory($pFilename);
+ $fileHandle = $this->fileHandle;
+
+ // Skip BOM, if any
+ $this->skipBOM();
+ $this->checkSeparator();
+ $this->inferSeparator();
+
+ // Create new PhpSpreadsheet object
+ while ($spreadsheet->getSheetCount() <= $this->sheetIndex) {
+ $spreadsheet->createSheet();
+ }
+ $sheet = $spreadsheet->setActiveSheetIndex($this->sheetIndex);
+
+ // Set our starting row based on whether we're in contiguous mode or not
+ $currentRow = 1;
+ $outRow = 0;
+
+ // Loop through each line of the file in turn
+ while (($rowData = fgetcsv($fileHandle, 0, $this->delimiter, $this->enclosure, $this->escapeCharacter)) !== false) {
+ $noOutputYet = true;
+ $columnLetter = 'A';
+ foreach ($rowData as $rowDatum) {
+ if ($rowDatum != '' && $this->readFilter->readCell($columnLetter, $currentRow)) {
+ if ($this->contiguous) {
+ if ($noOutputYet) {
+ $noOutputYet = false;
+ ++$outRow;
+ }
+ } else {
+ $outRow = $currentRow;
+ }
+ // Set cell value
+ $sheet->getCell($columnLetter . $outRow)->setValue($rowDatum);
+ }
+ ++$columnLetter;
+ }
+ ++$currentRow;
+ }
+
+ // Close file
+ fclose($fileHandle);
+
+ ini_set('auto_detect_line_endings', $lineEnding);
+
+ // Return
+ return $spreadsheet;
+ }
+
+ /**
+ * Get delimiter.
+ *
+ * @return string
+ */
+ public function getDelimiter()
+ {
+ return $this->delimiter;
+ }
+
+ /**
+ * Set delimiter.
+ *
+ * @param string $delimiter Delimiter, eg: ','
+ *
+ * @return $this
+ */
+ public function setDelimiter($delimiter)
+ {
+ $this->delimiter = $delimiter;
+
+ return $this;
+ }
+
+ /**
+ * Get enclosure.
+ *
+ * @return string
+ */
+ public function getEnclosure()
+ {
+ return $this->enclosure;
+ }
+
+ /**
+ * Set enclosure.
+ *
+ * @param string $enclosure Enclosure, defaults to "
+ *
+ * @return $this
+ */
+ public function setEnclosure($enclosure)
+ {
+ if ($enclosure == '') {
+ $enclosure = '"';
+ }
+ $this->enclosure = $enclosure;
+
+ return $this;
+ }
+
+ /**
+ * Get sheet index.
+ *
+ * @return int
+ */
+ public function getSheetIndex()
+ {
+ return $this->sheetIndex;
+ }
+
+ /**
+ * Set sheet index.
+ *
+ * @param int $pValue Sheet index
+ *
+ * @return $this
+ */
+ public function setSheetIndex($pValue)
+ {
+ $this->sheetIndex = $pValue;
+
+ return $this;
+ }
+
+ /**
+ * Set Contiguous.
+ *
+ * @param bool $contiguous
+ *
+ * @return $this
+ */
+ public function setContiguous($contiguous)
+ {
+ $this->contiguous = (bool) $contiguous;
+
+ return $this;
+ }
+
+ /**
+ * Get Contiguous.
+ *
+ * @return bool
+ */
+ public function getContiguous()
+ {
+ return $this->contiguous;
+ }
+
+ /**
+ * Set escape backslashes.
+ *
+ * @param string $escapeCharacter
+ *
+ * @return $this
+ */
+ public function setEscapeCharacter($escapeCharacter)
+ {
+ $this->escapeCharacter = $escapeCharacter;
+
+ return $this;
+ }
+
+ /**
+ * Get escape backslashes.
+ *
+ * @return string
+ */
+ public function getEscapeCharacter()
+ {
+ return $this->escapeCharacter;
+ }
+
+ /**
+ * Can the current IReader read the file?
+ *
+ * @param string $pFilename
+ *
+ * @return bool
+ */
+ public function canRead($pFilename)
+ {
+ // Check if file exists
+ try {
+ $this->openFile($pFilename);
+ } catch (InvalidArgumentException $e) {
+ return false;
+ }
+
+ fclose($this->fileHandle);
+
+ // Trust file extension if any
+ $extension = strtolower(pathinfo($pFilename, PATHINFO_EXTENSION));
+ if (in_array($extension, ['csv', 'tsv'])) {
+ return true;
+ }
+
+ // Attempt to guess mimetype
+ $type = mime_content_type($pFilename);
+ $supportedTypes = [
+ 'application/csv',
+ 'text/csv',
+ 'text/plain',
+ 'inode/x-empty',
+ ];
+
+ return in_array($type, $supportedTypes, true);
+ }
+}
diff --git a/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/DefaultReadFilter.php b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/DefaultReadFilter.php new file mode 100644 index 0000000..4f9f314 --- /dev/null +++ b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/DefaultReadFilter.php @@ -0,0 +1,20 @@ +<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader;
+
+class DefaultReadFilter implements IReadFilter
+{
+ /**
+ * Should this cell be read?
+ *
+ * @param string $column Column address (as a string value like "A", or "IV")
+ * @param int $row Row number
+ * @param string $worksheetName Optional worksheet name
+ *
+ * @return bool
+ */
+ public function readCell($column, $row, $worksheetName = '')
+ {
+ return true;
+ }
+}
diff --git a/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Exception.php b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Exception.php new file mode 100644 index 0000000..bddd3c7 --- /dev/null +++ b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Exception.php @@ -0,0 +1,9 @@ +<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader;
+
+use PhpOffice\PhpSpreadsheet\Exception as PhpSpreadsheetException;
+
+class Exception extends PhpSpreadsheetException
+{
+}
diff --git a/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Gnumeric.php b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Gnumeric.php new file mode 100644 index 0000000..588e8ae --- /dev/null +++ b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Gnumeric.php @@ -0,0 +1,831 @@ +<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader;
+
+use PhpOffice\PhpSpreadsheet\Cell\Coordinate;
+use PhpOffice\PhpSpreadsheet\Cell\DataType;
+use PhpOffice\PhpSpreadsheet\DefinedName;
+use PhpOffice\PhpSpreadsheet\Reader\Gnumeric\PageSetup;
+use PhpOffice\PhpSpreadsheet\Reader\Security\XmlScanner;
+use PhpOffice\PhpSpreadsheet\ReferenceHelper;
+use PhpOffice\PhpSpreadsheet\RichText\RichText;
+use PhpOffice\PhpSpreadsheet\Settings;
+use PhpOffice\PhpSpreadsheet\Shared\Date;
+use PhpOffice\PhpSpreadsheet\Shared\File;
+use PhpOffice\PhpSpreadsheet\Spreadsheet;
+use PhpOffice\PhpSpreadsheet\Style\Alignment;
+use PhpOffice\PhpSpreadsheet\Style\Border;
+use PhpOffice\PhpSpreadsheet\Style\Borders;
+use PhpOffice\PhpSpreadsheet\Style\Fill;
+use PhpOffice\PhpSpreadsheet\Style\Font;
+use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
+use SimpleXMLElement;
+use XMLReader;
+
+class Gnumeric extends BaseReader
+{
+ private const UOM_CONVERSION_POINTS_TO_CENTIMETERS = 0.03527777778;
+
+ /**
+ * Shared Expressions.
+ *
+ * @var array
+ */
+ private $expressions = [];
+
+ /**
+ * Spreadsheet shared across all functions.
+ *
+ * @var Spreadsheet
+ */
+ private $spreadsheet;
+
+ private $referenceHelper;
+
+ /**
+ * Namespace shared across all functions.
+ * It is 'gnm', except for really old sheets which use 'gmr'.
+ *
+ * @var string
+ */
+ private $gnm = 'gnm';
+
+ /**
+ * Create a new Gnumeric.
+ */
+ public function __construct()
+ {
+ parent::__construct();
+ $this->referenceHelper = ReferenceHelper::getInstance();
+ $this->securityScanner = XmlScanner::getInstance($this);
+ }
+
+ /**
+ * Can the current IReader read the file?
+ *
+ * @param string $pFilename
+ *
+ * @return bool
+ */
+ public function canRead($pFilename)
+ {
+ File::assertFile($pFilename);
+
+ // Check if gzlib functions are available
+ $data = '';
+ if (function_exists('gzread')) {
+ // Read signature data (first 3 bytes)
+ $fh = fopen($pFilename, 'rb');
+ $data = fread($fh, 2);
+ fclose($fh);
+ }
+
+ return $data == chr(0x1F) . chr(0x8B);
+ }
+
+ private static function matchXml(string $name, string $field): bool
+ {
+ return 1 === preg_match("/^(gnm|gmr):$field$/", $name);
+ }
+
+ /**
+ * Reads names of the worksheets from a file, without parsing the whole file to a Spreadsheet object.
+ *
+ * @param string $pFilename
+ *
+ * @return array
+ */
+ public function listWorksheetNames($pFilename)
+ {
+ File::assertFile($pFilename);
+
+ $xml = new XMLReader();
+ $xml->xml($this->securityScanner->scanFile('compress.zlib://' . realpath($pFilename)), null, Settings::getLibXmlLoaderOptions());
+ $xml->setParserProperty(2, true);
+
+ $worksheetNames = [];
+ while ($xml->read()) {
+ if (self::matchXml($xml->name, 'SheetName') && $xml->nodeType == XMLReader::ELEMENT) {
+ $xml->read(); // Move onto the value node
+ $worksheetNames[] = (string) $xml->value;
+ } elseif (self::matchXml($xml->name, 'Sheets')) {
+ // break out of the loop once we've got our sheet names rather than parse the entire file
+ break;
+ }
+ }
+
+ return $worksheetNames;
+ }
+
+ /**
+ * Return worksheet info (Name, Last Column Letter, Last Column Index, Total Rows, Total Columns).
+ *
+ * @param string $pFilename
+ *
+ * @return array
+ */
+ public function listWorksheetInfo($pFilename)
+ {
+ File::assertFile($pFilename);
+
+ $xml = new XMLReader();
+ $xml->xml($this->securityScanner->scanFile('compress.zlib://' . realpath($pFilename)), null, Settings::getLibXmlLoaderOptions());
+ $xml->setParserProperty(2, true);
+
+ $worksheetInfo = [];
+ while ($xml->read()) {
+ if (self::matchXml($xml->name, 'Sheet') && $xml->nodeType == XMLReader::ELEMENT) {
+ $tmpInfo = [
+ 'worksheetName' => '',
+ 'lastColumnLetter' => 'A',
+ 'lastColumnIndex' => 0,
+ 'totalRows' => 0,
+ 'totalColumns' => 0,
+ ];
+
+ while ($xml->read()) {
+ if ($xml->nodeType == XMLReader::ELEMENT) {
+ if (self::matchXml($xml->name, 'Name')) {
+ $xml->read(); // Move onto the value node
+ $tmpInfo['worksheetName'] = (string) $xml->value;
+ } elseif (self::matchXml($xml->name, 'MaxCol')) {
+ $xml->read(); // Move onto the value node
+ $tmpInfo['lastColumnIndex'] = (int) $xml->value;
+ $tmpInfo['totalColumns'] = (int) $xml->value + 1;
+ } elseif (self::matchXml($xml->name, 'MaxRow')) {
+ $xml->read(); // Move onto the value node
+ $tmpInfo['totalRows'] = (int) $xml->value + 1;
+
+ break;
+ }
+ }
+ }
+ $tmpInfo['lastColumnLetter'] = Coordinate::stringFromColumnIndex($tmpInfo['lastColumnIndex'] + 1);
+ $worksheetInfo[] = $tmpInfo;
+ }
+ }
+
+ return $worksheetInfo;
+ }
+
+ /**
+ * @param string $filename
+ *
+ * @return string
+ */
+ private function gzfileGetContents($filename)
+ {
+ $file = @gzopen($filename, 'rb');
+ $data = '';
+ if ($file !== false) {
+ while (!gzeof($file)) {
+ $data .= gzread($file, 1024);
+ }
+ gzclose($file);
+ }
+
+ return $data;
+ }
+
+ private static $mappings = [
+ 'borderStyle' => [
+ '0' => Border::BORDER_NONE,
+ '1' => Border::BORDER_THIN,
+ '2' => Border::BORDER_MEDIUM,
+ '3' => Border::BORDER_SLANTDASHDOT,
+ '4' => Border::BORDER_DASHED,
+ '5' => Border::BORDER_THICK,
+ '6' => Border::BORDER_DOUBLE,
+ '7' => Border::BORDER_DOTTED,
+ '8' => Border::BORDER_MEDIUMDASHED,
+ '9' => Border::BORDER_DASHDOT,
+ '10' => Border::BORDER_MEDIUMDASHDOT,
+ '11' => Border::BORDER_DASHDOTDOT,
+ '12' => Border::BORDER_MEDIUMDASHDOTDOT,
+ '13' => Border::BORDER_MEDIUMDASHDOTDOT,
+ ],
+ 'dataType' => [
+ '10' => DataType::TYPE_NULL,
+ '20' => DataType::TYPE_BOOL,
+ '30' => DataType::TYPE_NUMERIC, // Integer doesn't exist in Excel
+ '40' => DataType::TYPE_NUMERIC, // Float
+ '50' => DataType::TYPE_ERROR,
+ '60' => DataType::TYPE_STRING,
+ //'70': // Cell Range
+ //'80': // Array
+ ],
+ 'fillType' => [
+ '1' => Fill::FILL_SOLID,
+ '2' => Fill::FILL_PATTERN_DARKGRAY,
+ '3' => Fill::FILL_PATTERN_MEDIUMGRAY,
+ '4' => Fill::FILL_PATTERN_LIGHTGRAY,
+ '5' => Fill::FILL_PATTERN_GRAY125,
+ '6' => Fill::FILL_PATTERN_GRAY0625,
+ '7' => Fill::FILL_PATTERN_DARKHORIZONTAL, // horizontal stripe
+ '8' => Fill::FILL_PATTERN_DARKVERTICAL, // vertical stripe
+ '9' => Fill::FILL_PATTERN_DARKDOWN, // diagonal stripe
+ '10' => Fill::FILL_PATTERN_DARKUP, // reverse diagonal stripe
+ '11' => Fill::FILL_PATTERN_DARKGRID, // diagoanl crosshatch
+ '12' => Fill::FILL_PATTERN_DARKTRELLIS, // thick diagonal crosshatch
+ '13' => Fill::FILL_PATTERN_LIGHTHORIZONTAL,
+ '14' => Fill::FILL_PATTERN_LIGHTVERTICAL,
+ '15' => Fill::FILL_PATTERN_LIGHTUP,
+ '16' => Fill::FILL_PATTERN_LIGHTDOWN,
+ '17' => Fill::FILL_PATTERN_LIGHTGRID, // thin horizontal crosshatch
+ '18' => Fill::FILL_PATTERN_LIGHTTRELLIS, // thin diagonal crosshatch
+ ],
+ 'horizontal' => [
+ '1' => Alignment::HORIZONTAL_GENERAL,
+ '2' => Alignment::HORIZONTAL_LEFT,
+ '4' => Alignment::HORIZONTAL_RIGHT,
+ '8' => Alignment::HORIZONTAL_CENTER,
+ '16' => Alignment::HORIZONTAL_CENTER_CONTINUOUS,
+ '32' => Alignment::HORIZONTAL_JUSTIFY,
+ '64' => Alignment::HORIZONTAL_CENTER_CONTINUOUS,
+ ],
+ 'underline' => [
+ '1' => Font::UNDERLINE_SINGLE,
+ '2' => Font::UNDERLINE_DOUBLE,
+ '3' => Font::UNDERLINE_SINGLEACCOUNTING,
+ '4' => Font::UNDERLINE_DOUBLEACCOUNTING,
+ ],
+ 'vertical' => [
+ '1' => Alignment::VERTICAL_TOP,
+ '2' => Alignment::VERTICAL_BOTTOM,
+ '4' => Alignment::VERTICAL_CENTER,
+ '8' => Alignment::VERTICAL_JUSTIFY,
+ ],
+ ];
+
+ public static function gnumericMappings(): array
+ {
+ return self::$mappings;
+ }
+
+ private function docPropertiesOld(SimpleXMLElement $gnmXML): void
+ {
+ $docProps = $this->spreadsheet->getProperties();
+ foreach ($gnmXML->Summary->Item as $summaryItem) {
+ $propertyName = $summaryItem->name;
+ $propertyValue = $summaryItem->{'val-string'};
+ switch ($propertyName) {
+ case 'title':
+ $docProps->setTitle(trim($propertyValue));
+
+ break;
+ case 'comments':
+ $docProps->setDescription(trim($propertyValue));
+
+ break;
+ case 'keywords':
+ $docProps->setKeywords(trim($propertyValue));
+
+ break;
+ case 'category':
+ $docProps->setCategory(trim($propertyValue));
+
+ break;
+ case 'manager':
+ $docProps->setManager(trim($propertyValue));
+
+ break;
+ case 'author':
+ $docProps->setCreator(trim($propertyValue));
+ $docProps->setLastModifiedBy(trim($propertyValue));
+
+ break;
+ case 'company':
+ $docProps->setCompany(trim($propertyValue));
+
+ break;
+ }
+ }
+ }
+
+ private function docPropertiesDC(SimpleXMLElement $officePropertyDC): void
+ {
+ $docProps = $this->spreadsheet->getProperties();
+ foreach ($officePropertyDC as $propertyName => $propertyValue) {
+ $propertyValue = trim((string) $propertyValue);
+ switch ($propertyName) {
+ case 'title':
+ $docProps->setTitle($propertyValue);
+
+ break;
+ case 'subject':
+ $docProps->setSubject($propertyValue);
+
+ break;
+ case 'creator':
+ $docProps->setCreator($propertyValue);
+ $docProps->setLastModifiedBy($propertyValue);
+
+ break;
+ case 'date':
+ $creationDate = strtotime($propertyValue);
+ $docProps->setCreated($creationDate);
+ $docProps->setModified($creationDate);
+
+ break;
+ case 'description':
+ $docProps->setDescription($propertyValue);
+
+ break;
+ }
+ }
+ }
+
+ private function docPropertiesMeta(SimpleXMLElement $officePropertyMeta, array $namespacesMeta): void
+ {
+ $docProps = $this->spreadsheet->getProperties();
+ foreach ($officePropertyMeta as $propertyName => $propertyValue) {
+ $attributes = $propertyValue->attributes($namespacesMeta['meta']);
+ $propertyValue = trim((string) $propertyValue);
+ switch ($propertyName) {
+ case 'keyword':
+ $docProps->setKeywords($propertyValue);
+
+ break;
+ case 'initial-creator':
+ $docProps->setCreator($propertyValue);
+ $docProps->setLastModifiedBy($propertyValue);
+
+ break;
+ case 'creation-date':
+ $creationDate = strtotime($propertyValue);
+ $docProps->setCreated($creationDate);
+ $docProps->setModified($creationDate);
+
+ break;
+ case 'user-defined':
+ [, $attrName] = explode(':', $attributes['name']);
+ switch ($attrName) {
+ case 'publisher':
+ $docProps->setCompany($propertyValue);
+
+ break;
+ case 'category':
+ $docProps->setCategory($propertyValue);
+
+ break;
+ case 'manager':
+ $docProps->setManager($propertyValue);
+
+ break;
+ }
+
+ break;
+ }
+ }
+ }
+
+ private function docProperties(SimpleXMLElement $xml, SimpleXMLElement $gnmXML, array $namespacesMeta): void
+ {
+ if (isset($namespacesMeta['office'])) {
+ $officeXML = $xml->children($namespacesMeta['office']);
+ $officeDocXML = $officeXML->{'document-meta'};
+ $officeDocMetaXML = $officeDocXML->meta;
+
+ foreach ($officeDocMetaXML as $officePropertyData) {
+ $officePropertyDC = [];
+ if (isset($namespacesMeta['dc'])) {
+ $officePropertyDC = $officePropertyData->children($namespacesMeta['dc']);
+ }
+ $this->docPropertiesDC($officePropertyDC);
+
+ $officePropertyMeta = [];
+ if (isset($namespacesMeta['meta'])) {
+ $officePropertyMeta = $officePropertyData->children($namespacesMeta['meta']);
+ }
+ $this->docPropertiesMeta($officePropertyMeta, $namespacesMeta);
+ }
+ } elseif (isset($gnmXML->Summary)) {
+ $this->docPropertiesOld($gnmXML);
+ }
+ }
+
+ private function processComments(SimpleXMLElement $sheet): void
+ {
+ if ((!$this->readDataOnly) && (isset($sheet->Objects))) {
+ foreach ($sheet->Objects->children($this->gnm, true) as $key => $comment) {
+ $commentAttributes = $comment->attributes();
+ // Only comment objects are handled at the moment
+ if ($commentAttributes->Text) {
+ $this->spreadsheet->getActiveSheet()->getComment((string) $commentAttributes->ObjectBound)->setAuthor((string) $commentAttributes->Author)->setText($this->parseRichText((string) $commentAttributes->Text));
+ }
+ }
+ }
+ }
+
+ /**
+ * Loads Spreadsheet from file.
+ *
+ * @param string $pFilename
+ *
+ * @return Spreadsheet
+ */
+ public function load($pFilename)
+ {
+ // Create new Spreadsheet
+ $spreadsheet = new Spreadsheet();
+ $spreadsheet->removeSheetByIndex(0);
+
+ // Load into this instance
+ return $this->loadIntoExisting($pFilename, $spreadsheet);
+ }
+
+ /**
+ * Loads from file into Spreadsheet instance.
+ */
+ public function loadIntoExisting(string $pFilename, Spreadsheet $spreadsheet): Spreadsheet
+ {
+ $this->spreadsheet = $spreadsheet;
+ File::assertFile($pFilename);
+
+ $gFileData = $this->gzfileGetContents($pFilename);
+
+ $xml2 = simplexml_load_string($this->securityScanner->scan($gFileData), 'SimpleXMLElement', Settings::getLibXmlLoaderOptions());
+ $xml = ($xml2 !== false) ? $xml2 : new SimpleXMLElement('<?xml version="1.0" encoding="UTF-8"?><root></root>');
+ $namespacesMeta = $xml->getNamespaces(true);
+ $this->gnm = array_key_exists('gmr', $namespacesMeta) ? 'gmr' : 'gnm';
+
+ $gnmXML = $xml->children($namespacesMeta[$this->gnm]);
+ $this->docProperties($xml, $gnmXML, $namespacesMeta);
+
+ $worksheetID = 0;
+ foreach ($gnmXML->Sheets->Sheet as $sheet) {
+ $worksheetName = (string) $sheet->Name;
+ if ((isset($this->loadSheetsOnly)) && (!in_array($worksheetName, $this->loadSheetsOnly))) {
+ continue;
+ }
+
+ $maxRow = $maxCol = 0;
+
+ // Create new Worksheet
+ $this->spreadsheet->createSheet();
+ $this->spreadsheet->setActiveSheetIndex($worksheetID);
+ // Use false for $updateFormulaCellReferences to prevent adjustment of worksheet references in formula
+ // cells... during the load, all formulae should be correct, and we're simply bringing the worksheet
+ // name in line with the formula, not the reverse
+ $this->spreadsheet->getActiveSheet()->setTitle($worksheetName, false, false);
+
+ if (!$this->readDataOnly) {
+ (new PageSetup($this->spreadsheet, $this->gnm))
+ ->printInformation($sheet)
+ ->sheetMargins($sheet);
+ }
+
+ foreach ($sheet->Cells->Cell as $cell) {
+ $cellAttributes = $cell->attributes();
+ $row = (int) $cellAttributes->Row + 1;
+ $column = (int) $cellAttributes->Col;
+
+ if ($row > $maxRow) {
+ $maxRow = $row;
+ }
+ if ($column > $maxCol) {
+ $maxCol = $column;
+ }
+
+ $column = Coordinate::stringFromColumnIndex($column + 1);
+
+ // Read cell?
+ if ($this->getReadFilter() !== null) {
+ if (!$this->getReadFilter()->readCell($column, $row, $worksheetName)) {
+ continue;
+ }
+ }
+
+ $ValueType = $cellAttributes->ValueType;
+ $ExprID = (string) $cellAttributes->ExprID;
+ $type = DataType::TYPE_FORMULA;
+ if ($ExprID > '') {
+ if (((string) $cell) > '') {
+ $this->expressions[$ExprID] = [
+ 'column' => $cellAttributes->Col,
+ 'row' => $cellAttributes->Row,
+ 'formula' => (string) $cell,
+ ];
+ } else {
+ $expression = $this->expressions[$ExprID];
+
+ $cell = $this->referenceHelper->updateFormulaReferences(
+ $expression['formula'],
+ 'A1',
+ $cellAttributes->Col - $expression['column'],
+ $cellAttributes->Row - $expression['row'],
+ $worksheetName
+ );
+ }
+ $type = DataType::TYPE_FORMULA;
+ } else {
+ $vtype = (string) $ValueType;
+ if (array_key_exists($vtype, self::$mappings['dataType'])) {
+ $type = self::$mappings['dataType'][$vtype];
+ }
+ if ($vtype == '20') { // Boolean
+ $cell = $cell == 'TRUE';
+ }
+ }
+ $this->spreadsheet->getActiveSheet()->getCell($column . $row)->setValueExplicit((string) $cell, $type);
+ }
+
+ $this->processComments($sheet);
+
+ foreach ($sheet->Styles->StyleRegion as $styleRegion) {
+ $styleAttributes = $styleRegion->attributes();
+ if (
+ ($styleAttributes['startRow'] <= $maxRow) &&
+ ($styleAttributes['startCol'] <= $maxCol)
+ ) {
+ $startColumn = Coordinate::stringFromColumnIndex((int) $styleAttributes['startCol'] + 1);
+ $startRow = $styleAttributes['startRow'] + 1;
+
+ $endColumn = ($styleAttributes['endCol'] > $maxCol) ? $maxCol : (int) $styleAttributes['endCol'];
+ $endColumn = Coordinate::stringFromColumnIndex($endColumn + 1);
+
+ $endRow = 1 + (($styleAttributes['endRow'] > $maxRow) ? $maxRow : (int) $styleAttributes['endRow']);
+ $cellRange = $startColumn . $startRow . ':' . $endColumn . $endRow;
+
+ $styleAttributes = $styleRegion->Style->attributes();
+
+ $styleArray = [];
+ // We still set the number format mask for date/time values, even if readDataOnly is true
+ $formatCode = (string) $styleAttributes['Format'];
+ if (Date::isDateTimeFormatCode($formatCode)) {
+ $styleArray['numberFormat']['formatCode'] = $formatCode;
+ }
+ if (!$this->readDataOnly) {
+ // If readDataOnly is false, we set all formatting information
+ $styleArray['numberFormat']['formatCode'] = $formatCode;
+
+ self::addStyle2($styleArray, 'alignment', 'horizontal', $styleAttributes['HAlign']);
+ self::addStyle2($styleArray, 'alignment', 'vertical', $styleAttributes['VAlign']);
+ $styleArray['alignment']['wrapText'] = $styleAttributes['WrapText'] == '1';
+ $styleArray['alignment']['textRotation'] = $this->calcRotation($styleAttributes);
+ $styleArray['alignment']['shrinkToFit'] = $styleAttributes['ShrinkToFit'] == '1';
+ $styleArray['alignment']['indent'] = ((int) ($styleAttributes['Indent']) > 0) ? $styleAttributes['indent'] : 0;
+
+ $this->addColors($styleArray, $styleAttributes);
+
+ $fontAttributes = $styleRegion->Style->Font->attributes();
+ $styleArray['font']['name'] = (string) $styleRegion->Style->Font;
+ $styleArray['font']['size'] = (int) ($fontAttributes['Unit']);
+ $styleArray['font']['bold'] = $fontAttributes['Bold'] == '1';
+ $styleArray['font']['italic'] = $fontAttributes['Italic'] == '1';
+ $styleArray['font']['strikethrough'] = $fontAttributes['StrikeThrough'] == '1';
+ self::addStyle2($styleArray, 'font', 'underline', $fontAttributes['Underline']);
+
+ switch ($fontAttributes['Script']) {
+ case '1':
+ $styleArray['font']['superscript'] = true;
+
+ break;
+ case '-1':
+ $styleArray['font']['subscript'] = true;
+
+ break;
+ }
+
+ if (isset($styleRegion->Style->StyleBorder)) {
+ $srssb = $styleRegion->Style->StyleBorder;
+ $this->addBorderStyle($srssb, $styleArray, 'top');
+ $this->addBorderStyle($srssb, $styleArray, 'bottom');
+ $this->addBorderStyle($srssb, $styleArray, 'left');
+ $this->addBorderStyle($srssb, $styleArray, 'right');
+ $this->addBorderDiagonal($srssb, $styleArray);
+ }
+ if (isset($styleRegion->Style->HyperLink)) {
+ // TO DO
+ $hyperlink = $styleRegion->Style->HyperLink->attributes();
+ }
+ }
+ $this->spreadsheet->getActiveSheet()->getStyle($cellRange)->applyFromArray($styleArray);
+ }
+ }
+
+ $this->processColumnWidths($sheet, $maxCol);
+ $this->processRowHeights($sheet, $maxRow);
+ $this->processMergedCells($sheet);
+
+ ++$worksheetID;
+ }
+
+ $this->processDefinedNames($gnmXML);
+
+ // Return
+ return $this->spreadsheet;
+ }
+
+ private function addBorderDiagonal(SimpleXMLElement $srssb, array &$styleArray): void
+ {
+ if (isset($srssb->Diagonal, $srssb->{'Rev-Diagonal'})) {
+ $styleArray['borders']['diagonal'] = self::parseBorderAttributes($srssb->Diagonal->attributes());
+ $styleArray['borders']['diagonalDirection'] = Borders::DIAGONAL_BOTH;
+ } elseif (isset($srssb->Diagonal)) {
+ $styleArray['borders']['diagonal'] = self::parseBorderAttributes($srssb->Diagonal->attributes());
+ $styleArray['borders']['diagonalDirection'] = Borders::DIAGONAL_UP;
+ } elseif (isset($srssb->{'Rev-Diagonal'})) {
+ $styleArray['borders']['diagonal'] = self::parseBorderAttributes($srssb->{'Rev-Diagonal'}->attributes());
+ $styleArray['borders']['diagonalDirection'] = Borders::DIAGONAL_DOWN;
+ }
+ }
+
+ private function addBorderStyle(SimpleXMLElement $srssb, array &$styleArray, string $direction): void
+ {
+ $ucDirection = ucfirst($direction);
+ if (isset($srssb->$ucDirection)) {
+ $styleArray['borders'][$direction] = self::parseBorderAttributes($srssb->$ucDirection->attributes());
+ }
+ }
+
+ private function processMergedCells(SimpleXMLElement $sheet): void
+ {
+ // Handle Merged Cells in this worksheet
+ if (isset($sheet->MergedRegions)) {
+ foreach ($sheet->MergedRegions->Merge as $mergeCells) {
+ if (strpos($mergeCells, ':') !== false) {
+ $this->spreadsheet->getActiveSheet()->mergeCells($mergeCells);
+ }
+ }
+ }
+ }
+
+ private function processColumnLoop(int $c, int $maxCol, SimpleXMLElement $columnOverride, float $defaultWidth): int
+ {
+ $columnAttributes = $columnOverride->attributes();
+ $column = $columnAttributes['No'];
+ $columnWidth = ((float) $columnAttributes['Unit']) / 5.4;
+ $hidden = (isset($columnAttributes['Hidden'])) && ((string) $columnAttributes['Hidden'] == '1');
+ $columnCount = (isset($columnAttributes['Count'])) ? $columnAttributes['Count'] : 1;
+ while ($c < $column) {
+ $this->spreadsheet->getActiveSheet()->getColumnDimension(Coordinate::stringFromColumnIndex($c + 1))->setWidth($defaultWidth);
+ ++$c;
+ }
+ while (($c < ($column + $columnCount)) && ($c <= $maxCol)) {
+ $this->spreadsheet->getActiveSheet()->getColumnDimension(Coordinate::stringFromColumnIndex($c + 1))->setWidth($columnWidth);
+ if ($hidden) {
+ $this->spreadsheet->getActiveSheet()->getColumnDimension(Coordinate::stringFromColumnIndex($c + 1))->setVisible(false);
+ }
+ ++$c;
+ }
+
+ return $c;
+ }
+
+ private function processColumnWidths(SimpleXMLElement $sheet, int $maxCol): void
+ {
+ if ((!$this->readDataOnly) && (isset($sheet->Cols))) {
+ // Column Widths
+ $columnAttributes = $sheet->Cols->attributes();
+ $defaultWidth = $columnAttributes['DefaultSizePts'] / 5.4;
+ $c = 0;
+ foreach ($sheet->Cols->ColInfo as $columnOverride) {
+ $c = $this->processColumnLoop($c, $maxCol, $columnOverride, $defaultWidth);
+ }
+ while ($c <= $maxCol) {
+ $this->spreadsheet->getActiveSheet()->getColumnDimension(Coordinate::stringFromColumnIndex($c + 1))->setWidth($defaultWidth);
+ ++$c;
+ }
+ }
+ }
+
+ private function processRowLoop(int $r, int $maxRow, SimpleXMLElement $rowOverride, float $defaultHeight): int
+ {
+ $rowAttributes = $rowOverride->attributes();
+ $row = $rowAttributes['No'];
+ $rowHeight = (float) $rowAttributes['Unit'];
+ $hidden = (isset($rowAttributes['Hidden'])) && ((string) $rowAttributes['Hidden'] == '1');
+ $rowCount = (isset($rowAttributes['Count'])) ? $rowAttributes['Count'] : 1;
+ while ($r < $row) {
+ ++$r;
+ $this->spreadsheet->getActiveSheet()->getRowDimension($r)->setRowHeight($defaultHeight);
+ }
+ while (($r < ($row + $rowCount)) && ($r < $maxRow)) {
+ ++$r;
+ $this->spreadsheet->getActiveSheet()->getRowDimension($r)->setRowHeight($rowHeight);
+ if ($hidden) {
+ $this->spreadsheet->getActiveSheet()->getRowDimension($r)->setVisible(false);
+ }
+ }
+
+ return $r;
+ }
+
+ private function processRowHeights(SimpleXMLElement $sheet, int $maxRow): void
+ {
+ if ((!$this->readDataOnly) && (isset($sheet->Rows))) {
+ // Row Heights
+ $rowAttributes = $sheet->Rows->attributes();
+ $defaultHeight = (float) $rowAttributes['DefaultSizePts'];
+ $r = 0;
+
+ foreach ($sheet->Rows->RowInfo as $rowOverride) {
+ $r = $this->processRowLoop($r, $maxRow, $rowOverride, $defaultHeight);
+ }
+ // never executed, I can't figure out any circumstances
+ // under which it would be executed, and, even if
+ // such exist, I'm not convinced this is needed.
+ //while ($r < $maxRow) {
+ // ++$r;
+ // $this->spreadsheet->getActiveSheet()->getRowDimension($r)->setRowHeight($defaultHeight);
+ //}
+ }
+ }
+
+ private function processDefinedNames(SimpleXMLElement $gnmXML): void
+ {
+ // Loop through definedNames (global named ranges)
+ if (isset($gnmXML->Names)) {
+ foreach ($gnmXML->Names->Name as $definedName) {
+ $name = (string) $definedName->name;
+ $value = (string) $definedName->value;
+ if (stripos($value, '#REF!') !== false) {
+ continue;
+ }
+
+ [$worksheetName] = Worksheet::extractSheetTitle($value, true);
+ $worksheetName = trim($worksheetName, "'");
+ $worksheet = $this->spreadsheet->getSheetByName($worksheetName);
+ // Worksheet might still be null if we're only loading selected sheets rather than the full spreadsheet
+ if ($worksheet !== null) {
+ $this->spreadsheet->addDefinedName(DefinedName::createInstance($name, $worksheet, $value));
+ }
+ }
+ }
+ }
+
+ private function calcRotation(SimpleXMLElement $styleAttributes): int
+ {
+ $rotation = (int) $styleAttributes->Rotation;
+ if ($rotation >= 270 && $rotation <= 360) {
+ $rotation -= 360;
+ }
+ $rotation = (abs($rotation) > 90) ? 0 : $rotation;
+
+ return $rotation;
+ }
+
+ private static function addStyle(array &$styleArray, string $key, string $value): void
+ {
+ if (array_key_exists($value, self::$mappings[$key])) {
+ $styleArray[$key] = self::$mappings[$key][$value];
+ }
+ }
+
+ private static function addStyle2(array &$styleArray, string $key1, string $key, string $value): void
+ {
+ if (array_key_exists($value, self::$mappings[$key])) {
+ $styleArray[$key1][$key] = self::$mappings[$key][$value];
+ }
+ }
+
+ private static function parseBorderAttributes($borderAttributes)
+ {
+ $styleArray = [];
+ if (isset($borderAttributes['Color'])) {
+ $styleArray['color']['rgb'] = self::parseGnumericColour($borderAttributes['Color']);
+ }
+
+ self::addStyle($styleArray, 'borderStyle', $borderAttributes['Style']);
+
+ return $styleArray;
+ }
+
+ private function parseRichText($is)
+ {
+ $value = new RichText();
+ $value->createText($is);
+
+ return $value;
+ }
+
+ private static function parseGnumericColour($gnmColour)
+ {
+ [$gnmR, $gnmG, $gnmB] = explode(':', $gnmColour);
+ $gnmR = substr(str_pad($gnmR, 4, '0', STR_PAD_RIGHT), 0, 2);
+ $gnmG = substr(str_pad($gnmG, 4, '0', STR_PAD_RIGHT), 0, 2);
+ $gnmB = substr(str_pad($gnmB, 4, '0', STR_PAD_RIGHT), 0, 2);
+
+ return $gnmR . $gnmG . $gnmB;
+ }
+
+ private function addColors(array &$styleArray, SimpleXMLElement $styleAttributes): void
+ {
+ $RGB = self::parseGnumericColour($styleAttributes['Fore']);
+ $styleArray['font']['color']['rgb'] = $RGB;
+ $RGB = self::parseGnumericColour($styleAttributes['Back']);
+ $shade = (string) $styleAttributes['Shade'];
+ if (($RGB != '000000') || ($shade != '0')) {
+ $RGB2 = self::parseGnumericColour($styleAttributes['PatternColor']);
+ if ($shade == '1') {
+ $styleArray['fill']['startColor']['rgb'] = $RGB;
+ $styleArray['fill']['endColor']['rgb'] = $RGB2;
+ } else {
+ $styleArray['fill']['endColor']['rgb'] = $RGB;
+ $styleArray['fill']['startColor']['rgb'] = $RGB2;
+ }
+ self::addStyle2($styleArray, 'fill', 'fillType', $shade);
+ }
+ }
+}
diff --git a/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Gnumeric/PageSetup.php b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Gnumeric/PageSetup.php new file mode 100644 index 0000000..445b021 --- /dev/null +++ b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Gnumeric/PageSetup.php @@ -0,0 +1,143 @@ +<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader\Gnumeric;
+
+use PhpOffice\PhpSpreadsheet\Spreadsheet;
+use PhpOffice\PhpSpreadsheet\Worksheet\PageMargins;
+use PhpOffice\PhpSpreadsheet\Worksheet\PageSetup as WorksheetPageSetup;
+use SimpleXMLElement;
+
+class PageSetup
+{
+ /**
+ * @var Spreadsheet
+ */
+ private $spreadsheet;
+
+ /**
+ * @var string
+ */
+ private $gnm;
+
+ public function __construct(Spreadsheet $spreadsheet, string $gnm)
+ {
+ $this->spreadsheet = $spreadsheet;
+ $this->gnm = $gnm;
+ }
+
+ public function printInformation(SimpleXMLElement $sheet): self
+ {
+ if (isset($sheet->PrintInformation)) {
+ $printInformation = $sheet->PrintInformation[0];
+ $scale = (string) $printInformation->Scale->attributes()['percentage'];
+ $pageOrder = (string) $printInformation->order;
+ $orientation = (string) $printInformation->orientation;
+ $horizontalCentered = (string) $printInformation->hcenter->attributes()['value'];
+ $verticalCentered = (string) $printInformation->vcenter->attributes()['value'];
+
+ $this->spreadsheet->getActiveSheet()->getPageSetup()
+ ->setPageOrder($pageOrder === 'r_then_d' ? WorksheetPageSetup::PAGEORDER_OVER_THEN_DOWN : WorksheetPageSetup::PAGEORDER_DOWN_THEN_OVER)
+ ->setScale((int) $scale)
+ ->setOrientation($orientation ?? WorksheetPageSetup::ORIENTATION_DEFAULT)
+ ->setHorizontalCentered((bool) $horizontalCentered)
+ ->setVerticalCentered((bool) $verticalCentered);
+ }
+
+ return $this;
+ }
+
+ public function sheetMargins(SimpleXMLElement $sheet): self
+ {
+ if (isset($sheet->PrintInformation, $sheet->PrintInformation->Margins)) {
+ $marginSet = [
+ // Default Settings
+ 'top' => 0.75,
+ 'header' => 0.3,
+ 'left' => 0.7,
+ 'right' => 0.7,
+ 'bottom' => 0.75,
+ 'footer' => 0.3,
+ ];
+
+ $marginSet = $this->buildMarginSet($sheet, $marginSet);
+ $this->adjustMargins($marginSet);
+ }
+
+ return $this;
+ }
+
+ private function buildMarginSet(SimpleXMLElement $sheet, array $marginSet): array
+ {
+ foreach ($sheet->PrintInformation->Margins->children($this->gnm, true) as $key => $margin) {
+ $marginAttributes = $margin->attributes();
+ $marginSize = ($marginAttributes['Points']) ?? 72; // Default is 72pt
+ // Convert value in points to inches
+ $marginSize = PageMargins::fromPoints((float) $marginSize);
+ $marginSet[$key] = $marginSize;
+ }
+
+ return $marginSet;
+ }
+
+ private function adjustMargins(array $marginSet): void
+ {
+ foreach ($marginSet as $key => $marginSize) {
+ // Gnumeric is quirky in the way it displays the header/footer values:
+ // header is actually the sum of top and header; footer is actually the sum of bottom and footer
+ // then top is actually the header value, and bottom is actually the footer value
+ switch ($key) {
+ case 'left':
+ case 'right':
+ $this->sheetMargin($key, $marginSize);
+
+ break;
+ case 'top':
+ $this->sheetMargin($key, $marginSet['header'] ?? 0);
+
+ break;
+ case 'bottom':
+ $this->sheetMargin($key, $marginSet['footer'] ?? 0);
+
+ break;
+ case 'header':
+ $this->sheetMargin($key, ($marginSet['top'] ?? 0) - $marginSize);
+
+ break;
+ case 'footer':
+ $this->sheetMargin($key, ($marginSet['bottom'] ?? 0) - $marginSize);
+
+ break;
+ }
+ }
+ }
+
+ private function sheetMargin(string $key, float $marginSize): void
+ {
+ switch ($key) {
+ case 'top':
+ $this->spreadsheet->getActiveSheet()->getPageMargins()->setTop($marginSize);
+
+ break;
+ case 'bottom':
+ $this->spreadsheet->getActiveSheet()->getPageMargins()->setBottom($marginSize);
+
+ break;
+ case 'left':
+ $this->spreadsheet->getActiveSheet()->getPageMargins()->setLeft($marginSize);
+
+ break;
+ case 'right':
+ $this->spreadsheet->getActiveSheet()->getPageMargins()->setRight($marginSize);
+
+ break;
+ case 'header':
+ $this->spreadsheet->getActiveSheet()->getPageMargins()->setHeader($marginSize);
+
+ break;
+ case 'footer':
+ $this->spreadsheet->getActiveSheet()->getPageMargins()->setFooter($marginSize);
+
+ break;
+ }
+ }
+}
diff --git a/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Html.php b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Html.php new file mode 100644 index 0000000..17a45c0 --- /dev/null +++ b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Html.php @@ -0,0 +1,1026 @@ +<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader;
+
+use DOMDocument;
+use DOMElement;
+use DOMNode;
+use DOMText;
+use PhpOffice\PhpSpreadsheet\Cell\Coordinate;
+use PhpOffice\PhpSpreadsheet\Reader\Security\XmlScanner;
+use PhpOffice\PhpSpreadsheet\Spreadsheet;
+use PhpOffice\PhpSpreadsheet\Style\Border;
+use PhpOffice\PhpSpreadsheet\Style\Color;
+use PhpOffice\PhpSpreadsheet\Style\Fill;
+use PhpOffice\PhpSpreadsheet\Style\Font;
+use PhpOffice\PhpSpreadsheet\Style\Style;
+use PhpOffice\PhpSpreadsheet\Worksheet\Drawing;
+use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
+use Throwable;
+
+/** PhpSpreadsheet root directory */
+class Html extends BaseReader
+{
+ /**
+ * Sample size to read to determine if it's HTML or not.
+ */
+ const TEST_SAMPLE_SIZE = 2048;
+
+ /**
+ * Input encoding.
+ *
+ * @var string
+ */
+ protected $inputEncoding = 'ANSI';
+
+ /**
+ * Sheet index to read.
+ *
+ * @var int
+ */
+ protected $sheetIndex = 0;
+
+ /**
+ * Formats.
+ *
+ * @var array
+ */
+ protected $formats = [
+ 'h1' => [
+ 'font' => [
+ 'bold' => true,
+ 'size' => 24,
+ ],
+ ], // Bold, 24pt
+ 'h2' => [
+ 'font' => [
+ 'bold' => true,
+ 'size' => 18,
+ ],
+ ], // Bold, 18pt
+ 'h3' => [
+ 'font' => [
+ 'bold' => true,
+ 'size' => 13.5,
+ ],
+ ], // Bold, 13.5pt
+ 'h4' => [
+ 'font' => [
+ 'bold' => true,
+ 'size' => 12,
+ ],
+ ], // Bold, 12pt
+ 'h5' => [
+ 'font' => [
+ 'bold' => true,
+ 'size' => 10,
+ ],
+ ], // Bold, 10pt
+ 'h6' => [
+ 'font' => [
+ 'bold' => true,
+ 'size' => 7.5,
+ ],
+ ], // Bold, 7.5pt
+ 'a' => [
+ 'font' => [
+ 'underline' => true,
+ 'color' => [
+ 'argb' => Color::COLOR_BLUE,
+ ],
+ ],
+ ], // Blue underlined
+ 'hr' => [
+ 'borders' => [
+ 'bottom' => [
+ 'borderStyle' => Border::BORDER_THIN,
+ 'color' => [
+ Color::COLOR_BLACK,
+ ],
+ ],
+ ],
+ ], // Bottom border
+ 'strong' => [
+ 'font' => [
+ 'bold' => true,
+ ],
+ ], // Bold
+ 'b' => [
+ 'font' => [
+ 'bold' => true,
+ ],
+ ], // Bold
+ 'i' => [
+ 'font' => [
+ 'italic' => true,
+ ],
+ ], // Italic
+ 'em' => [
+ 'font' => [
+ 'italic' => true,
+ ],
+ ], // Italic
+ ];
+
+ protected $rowspan = [];
+
+ /**
+ * Create a new HTML Reader instance.
+ */
+ public function __construct()
+ {
+ parent::__construct();
+ $this->securityScanner = XmlScanner::getInstance($this);
+ }
+
+ /**
+ * Validate that the current file is an HTML file.
+ *
+ * @param string $pFilename
+ *
+ * @return bool
+ */
+ public function canRead($pFilename)
+ {
+ // Check if file exists
+ try {
+ $this->openFile($pFilename);
+ } catch (Exception $e) {
+ return false;
+ }
+
+ $beginning = $this->readBeginning();
+ $startWithTag = self::startsWithTag($beginning);
+ $containsTags = self::containsTags($beginning);
+ $endsWithTag = self::endsWithTag($this->readEnding());
+
+ fclose($this->fileHandle);
+
+ return $startWithTag && $containsTags && $endsWithTag;
+ }
+
+ private function readBeginning()
+ {
+ fseek($this->fileHandle, 0);
+
+ return fread($this->fileHandle, self::TEST_SAMPLE_SIZE);
+ }
+
+ private function readEnding()
+ {
+ $meta = stream_get_meta_data($this->fileHandle);
+ $filename = $meta['uri'];
+
+ $size = filesize($filename);
+ if ($size === 0) {
+ return '';
+ }
+
+ $blockSize = self::TEST_SAMPLE_SIZE;
+ if ($size < $blockSize) {
+ $blockSize = $size;
+ }
+
+ fseek($this->fileHandle, $size - $blockSize);
+
+ return fread($this->fileHandle, $blockSize);
+ }
+
+ private static function startsWithTag($data)
+ {
+ return '<' === substr(trim($data), 0, 1);
+ }
+
+ private static function endsWithTag($data)
+ {
+ return '>' === substr(trim($data), -1, 1);
+ }
+
+ private static function containsTags($data)
+ {
+ return strlen($data) !== strlen(strip_tags($data));
+ }
+
+ /**
+ * Loads Spreadsheet from file.
+ *
+ * @param string $pFilename
+ *
+ * @return Spreadsheet
+ */
+ public function load($pFilename)
+ {
+ // Create new Spreadsheet
+ $spreadsheet = new Spreadsheet();
+
+ // Load into this instance
+ return $this->loadIntoExisting($pFilename, $spreadsheet);
+ }
+
+ /**
+ * Set input encoding.
+ *
+ * @deprecated no use is made of this property
+ *
+ * @param string $pValue Input encoding, eg: 'ANSI'
+ *
+ * @return $this
+ *
+ * @codeCoverageIgnore
+ */
+ public function setInputEncoding($pValue)
+ {
+ $this->inputEncoding = $pValue;
+
+ return $this;
+ }
+
+ /**
+ * Get input encoding.
+ *
+ * @deprecated no use is made of this property
+ *
+ * @return string
+ *
+ * @codeCoverageIgnore
+ */
+ public function getInputEncoding()
+ {
+ return $this->inputEncoding;
+ }
+
+ // Data Array used for testing only, should write to Spreadsheet object on completion of tests
+ protected $dataArray = [];
+
+ protected $tableLevel = 0;
+
+ protected $nestedColumn = ['A'];
+
+ protected function setTableStartColumn($column)
+ {
+ if ($this->tableLevel == 0) {
+ $column = 'A';
+ }
+ ++$this->tableLevel;
+ $this->nestedColumn[$this->tableLevel] = $column;
+
+ return $this->nestedColumn[$this->tableLevel];
+ }
+
+ protected function getTableStartColumn()
+ {
+ return $this->nestedColumn[$this->tableLevel];
+ }
+
+ protected function releaseTableStartColumn()
+ {
+ --$this->tableLevel;
+
+ return array_pop($this->nestedColumn);
+ }
+
+ protected function flushCell(Worksheet $sheet, $column, $row, &$cellContent): void
+ {
+ if (is_string($cellContent)) {
+ // Simple String content
+ if (trim($cellContent) > '') {
+ // Only actually write it if there's content in the string
+ // Write to worksheet to be done here...
+ // ... we return the cell so we can mess about with styles more easily
+ $sheet->setCellValue($column . $row, $cellContent);
+ $this->dataArray[$row][$column] = $cellContent;
+ }
+ } else {
+ // We have a Rich Text run
+ // TODO
+ $this->dataArray[$row][$column] = 'RICH TEXT: ' . $cellContent;
+ }
+ $cellContent = (string) '';
+ }
+
+ private function processDomElementBody(Worksheet $sheet, int &$row, string &$column, string &$cellContent, DOMElement $child): void
+ {
+ $attributeArray = [];
+ foreach ($child->attributes as $attribute) {
+ $attributeArray[$attribute->name] = $attribute->value;
+ }
+
+ if ($child->nodeName === 'body') {
+ $row = 1;
+ $column = 'A';
+ $cellContent = '';
+ $this->tableLevel = 0;
+ $this->processDomElement($child, $sheet, $row, $column, $cellContent);
+ } else {
+ $this->processDomElementTitle($sheet, $row, $column, $cellContent, $child, $attributeArray);
+ }
+ }
+
+ private function processDomElementTitle(Worksheet $sheet, int &$row, string &$column, string &$cellContent, DOMElement $child, array &$attributeArray): void
+ {
+ if ($child->nodeName === 'title') {
+ $this->processDomElement($child, $sheet, $row, $column, $cellContent);
+ $sheet->setTitle($cellContent, true, false);
+ $cellContent = '';
+ } else {
+ $this->processDomElementSpanEtc($sheet, $row, $column, $cellContent, $child, $attributeArray);
+ }
+ }
+
+ private static $spanEtc = ['span', 'div', 'font', 'i', 'em', 'strong', 'b'];
+
+ private function processDomElementSpanEtc(Worksheet $sheet, int &$row, string &$column, string &$cellContent, DOMElement $child, array &$attributeArray): void
+ {
+ if (in_array($child->nodeName, self::$spanEtc)) {
+ if (isset($attributeArray['class']) && $attributeArray['class'] === 'comment') {
+ $sheet->getComment($column . $row)
+ ->getText()
+ ->createTextRun($child->textContent);
+ }
+ $this->processDomElement($child, $sheet, $row, $column, $cellContent);
+
+ if (isset($this->formats[$child->nodeName])) {
+ $sheet->getStyle($column . $row)->applyFromArray($this->formats[$child->nodeName]);
+ }
+ } else {
+ $this->processDomElementHr($sheet, $row, $column, $cellContent, $child, $attributeArray);
+ }
+ }
+
+ private function processDomElementHr(Worksheet $sheet, int &$row, string &$column, string &$cellContent, DOMElement $child, array &$attributeArray): void
+ {
+ if ($child->nodeName === 'hr') {
+ $this->flushCell($sheet, $column, $row, $cellContent);
+ ++$row;
+ if (isset($this->formats[$child->nodeName])) {
+ $sheet->getStyle($column . $row)->applyFromArray($this->formats[$child->nodeName]);
+ }
+ ++$row;
+ }
+ // fall through to br
+ $this->processDomElementBr($sheet, $row, $column, $cellContent, $child, $attributeArray);
+ }
+
+ private function processDomElementBr(Worksheet $sheet, int &$row, string &$column, string &$cellContent, DOMElement $child, array &$attributeArray): void
+ {
+ if ($child->nodeName === 'br' || $child->nodeName === 'hr') {
+ if ($this->tableLevel > 0) {
+ // If we're inside a table, replace with a \n and set the cell to wrap
+ $cellContent .= "\n";
+ $sheet->getStyle($column . $row)->getAlignment()->setWrapText(true);
+ } else {
+ // Otherwise flush our existing content and move the row cursor on
+ $this->flushCell($sheet, $column, $row, $cellContent);
+ ++$row;
+ }
+ } else {
+ $this->processDomElementA($sheet, $row, $column, $cellContent, $child, $attributeArray);
+ }
+ }
+
+ private function processDomElementA(Worksheet $sheet, int &$row, string &$column, string &$cellContent, DOMElement $child, array &$attributeArray): void
+ {
+ if ($child->nodeName === 'a') {
+ foreach ($attributeArray as $attributeName => $attributeValue) {
+ switch ($attributeName) {
+ case 'href':
+ $sheet->getCell($column . $row)->getHyperlink()->setUrl($attributeValue);
+ if (isset($this->formats[$child->nodeName])) {
+ $sheet->getStyle($column . $row)->applyFromArray($this->formats[$child->nodeName]);
+ }
+
+ break;
+ case 'class':
+ if ($attributeValue === 'comment-indicator') {
+ break; // Ignore - it's just a red square.
+ }
+ }
+ }
+ // no idea why this should be needed
+ //$cellContent .= ' ';
+ $this->processDomElement($child, $sheet, $row, $column, $cellContent);
+ } else {
+ $this->processDomElementH1Etc($sheet, $row, $column, $cellContent, $child, $attributeArray);
+ }
+ }
+
+ private static $h1Etc = ['h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'ol', 'ul', 'p'];
+
+ private function processDomElementH1Etc(Worksheet $sheet, int &$row, string &$column, string &$cellContent, DOMElement $child, array &$attributeArray): void
+ {
+ if (in_array($child->nodeName, self::$h1Etc)) {
+ if ($this->tableLevel > 0) {
+ // If we're inside a table, replace with a \n
+ $cellContent .= $cellContent ? "\n" : '';
+ $sheet->getStyle($column . $row)->getAlignment()->setWrapText(true);
+ $this->processDomElement($child, $sheet, $row, $column, $cellContent);
+ } else {
+ if ($cellContent > '') {
+ $this->flushCell($sheet, $column, $row, $cellContent);
+ ++$row;
+ }
+ $this->processDomElement($child, $sheet, $row, $column, $cellContent);
+ $this->flushCell($sheet, $column, $row, $cellContent);
+
+ if (isset($this->formats[$child->nodeName])) {
+ $sheet->getStyle($column . $row)->applyFromArray($this->formats[$child->nodeName]);
+ }
+
+ ++$row;
+ $column = 'A';
+ }
+ } else {
+ $this->processDomElementLi($sheet, $row, $column, $cellContent, $child, $attributeArray);
+ }
+ }
+
+ private function processDomElementLi(Worksheet $sheet, int &$row, string &$column, string &$cellContent, DOMElement $child, array &$attributeArray): void
+ {
+ if ($child->nodeName === 'li') {
+ if ($this->tableLevel > 0) {
+ // If we're inside a table, replace with a \n
+ $cellContent .= $cellContent ? "\n" : '';
+ $this->processDomElement($child, $sheet, $row, $column, $cellContent);
+ } else {
+ if ($cellContent > '') {
+ $this->flushCell($sheet, $column, $row, $cellContent);
+ }
+ ++$row;
+ $this->processDomElement($child, $sheet, $row, $column, $cellContent);
+ $this->flushCell($sheet, $column, $row, $cellContent);
+ $column = 'A';
+ }
+ } else {
+ $this->processDomElementImg($sheet, $row, $column, $cellContent, $child, $attributeArray);
+ }
+ }
+
+ private function processDomElementImg(Worksheet $sheet, int &$row, string &$column, string &$cellContent, DOMElement $child, array &$attributeArray): void
+ {
+ if ($child->nodeName === 'img') {
+ $this->insertImage($sheet, $column, $row, $attributeArray);
+ } else {
+ $this->processDomElementTable($sheet, $row, $column, $cellContent, $child, $attributeArray);
+ }
+ }
+
+ private function processDomElementTable(Worksheet $sheet, int &$row, string &$column, string &$cellContent, DOMElement $child, array &$attributeArray): void
+ {
+ if ($child->nodeName === 'table') {
+ $this->flushCell($sheet, $column, $row, $cellContent);
+ $column = $this->setTableStartColumn($column);
+ if ($this->tableLevel > 1) {
+ --$row;
+ }
+ $this->processDomElement($child, $sheet, $row, $column, $cellContent);
+ $column = $this->releaseTableStartColumn();
+ if ($this->tableLevel > 1) {
+ ++$column;
+ } else {
+ ++$row;
+ }
+ } else {
+ $this->processDomElementTr($sheet, $row, $column, $cellContent, $child, $attributeArray);
+ }
+ }
+
+ private function processDomElementTr(Worksheet $sheet, int &$row, string &$column, string &$cellContent, DOMElement $child, array &$attributeArray): void
+ {
+ if ($child->nodeName === 'tr') {
+ $column = $this->getTableStartColumn();
+ $cellContent = '';
+ $this->processDomElement($child, $sheet, $row, $column, $cellContent);
+
+ if (isset($attributeArray['height'])) {
+ $sheet->getRowDimension($row)->setRowHeight($attributeArray['height']);
+ }
+
+ ++$row;
+ } else {
+ $this->processDomElementThTdOther($sheet, $row, $column, $cellContent, $child, $attributeArray);
+ }
+ }
+
+ private function processDomElementThTdOther(Worksheet $sheet, int &$row, string &$column, string &$cellContent, DOMElement $child, array &$attributeArray): void
+ {
+ if ($child->nodeName !== 'td' && $child->nodeName !== 'th') {
+ $this->processDomElement($child, $sheet, $row, $column, $cellContent);
+ } else {
+ $this->processDomElementThTd($sheet, $row, $column, $cellContent, $child, $attributeArray);
+ }
+ }
+
+ private function processDomElementBgcolor(Worksheet $sheet, int $row, string $column, array $attributeArray): void
+ {
+ if (isset($attributeArray['bgcolor'])) {
+ $sheet->getStyle("$column$row")->applyFromArray(
+ [
+ 'fill' => [
+ 'fillType' => Fill::FILL_SOLID,
+ 'color' => ['rgb' => $this->getStyleColor($attributeArray['bgcolor'])],
+ ],
+ ]
+ );
+ }
+ }
+
+ private function processDomElementWidth(Worksheet $sheet, string $column, array $attributeArray): void
+ {
+ if (isset($attributeArray['width'])) {
+ $sheet->getColumnDimension($column)->setWidth($attributeArray['width']);
+ }
+ }
+
+ private function processDomElementHeight(Worksheet $sheet, int $row, array $attributeArray): void
+ {
+ if (isset($attributeArray['height'])) {
+ $sheet->getRowDimension($row)->setRowHeight($attributeArray['height']);
+ }
+ }
+
+ private function processDomElementAlign(Worksheet $sheet, int $row, string $column, array $attributeArray): void
+ {
+ if (isset($attributeArray['align'])) {
+ $sheet->getStyle($column . $row)->getAlignment()->setHorizontal($attributeArray['align']);
+ }
+ }
+
+ private function processDomElementVAlign(Worksheet $sheet, int $row, string $column, array $attributeArray): void
+ {
+ if (isset($attributeArray['valign'])) {
+ $sheet->getStyle($column . $row)->getAlignment()->setVertical($attributeArray['valign']);
+ }
+ }
+
+ private function processDomElementDataFormat(Worksheet $sheet, int $row, string $column, array $attributeArray): void
+ {
+ if (isset($attributeArray['data-format'])) {
+ $sheet->getStyle($column . $row)->getNumberFormat()->setFormatCode($attributeArray['data-format']);
+ }
+ }
+
+ private function processDomElementThTd(Worksheet $sheet, int &$row, string &$column, string &$cellContent, DOMElement $child, array &$attributeArray): void
+ {
+ while (isset($this->rowspan[$column . $row])) {
+ ++$column;
+ }
+ $this->processDomElement($child, $sheet, $row, $column, $cellContent);
+
+ // apply inline style
+ $this->applyInlineStyle($sheet, $row, $column, $attributeArray);
+
+ $this->flushCell($sheet, $column, $row, $cellContent);
+
+ $this->processDomElementBgcolor($sheet, $row, $column, $attributeArray);
+ $this->processDomElementWidth($sheet, $column, $attributeArray);
+ $this->processDomElementHeight($sheet, $row, $attributeArray);
+ $this->processDomElementAlign($sheet, $row, $column, $attributeArray);
+ $this->processDomElementVAlign($sheet, $row, $column, $attributeArray);
+ $this->processDomElementDataFormat($sheet, $row, $column, $attributeArray);
+
+ if (isset($attributeArray['rowspan'], $attributeArray['colspan'])) {
+ //create merging rowspan and colspan
+ $columnTo = $column;
+ for ($i = 0; $i < (int) $attributeArray['colspan'] - 1; ++$i) {
+ ++$columnTo;
+ }
+ $range = $column . $row . ':' . $columnTo . ($row + (int) $attributeArray['rowspan'] - 1);
+ foreach (Coordinate::extractAllCellReferencesInRange($range) as $value) {
+ $this->rowspan[$value] = true;
+ }
+ $sheet->mergeCells($range);
+ $column = $columnTo;
+ } elseif (isset($attributeArray['rowspan'])) {
+ //create merging rowspan
+ $range = $column . $row . ':' . $column . ($row + (int) $attributeArray['rowspan'] - 1);
+ foreach (Coordinate::extractAllCellReferencesInRange($range) as $value) {
+ $this->rowspan[$value] = true;
+ }
+ $sheet->mergeCells($range);
+ } elseif (isset($attributeArray['colspan'])) {
+ //create merging colspan
+ $columnTo = $column;
+ for ($i = 0; $i < (int) $attributeArray['colspan'] - 1; ++$i) {
+ ++$columnTo;
+ }
+ $sheet->mergeCells($column . $row . ':' . $columnTo . $row);
+ $column = $columnTo;
+ }
+
+ ++$column;
+ }
+
+ protected function processDomElement(DOMNode $element, Worksheet $sheet, int &$row, string &$column, string &$cellContent): void
+ {
+ foreach ($element->childNodes as $child) {
+ if ($child instanceof DOMText) {
+ $domText = preg_replace('/\s+/u', ' ', trim($child->nodeValue));
+ if (is_string($cellContent)) {
+ // simply append the text if the cell content is a plain text string
+ $cellContent .= $domText;
+ }
+ // but if we have a rich text run instead, we need to append it correctly
+ // TODO
+ } elseif ($child instanceof DOMElement) {
+ $this->processDomElementBody($sheet, $row, $column, $cellContent, $child);
+ }
+ }
+ }
+
+ /**
+ * Loads PhpSpreadsheet from file into PhpSpreadsheet instance.
+ *
+ * @param string $pFilename
+ *
+ * @return Spreadsheet
+ */
+ public function loadIntoExisting($pFilename, Spreadsheet $spreadsheet)
+ {
+ // Validate
+ if (!$this->canRead($pFilename)) {
+ throw new Exception($pFilename . ' is an Invalid HTML file.');
+ }
+
+ // Create a new DOM object
+ $dom = new DOMDocument();
+ // Reload the HTML file into the DOM object
+ try {
+ $loaded = $dom->loadHTML(mb_convert_encoding($this->securityScanner->scanFile($pFilename), 'HTML-ENTITIES', 'UTF-8'));
+ } catch (Throwable $e) {
+ $loaded = false;
+ }
+ if ($loaded === false) {
+ throw new Exception('Failed to load ' . $pFilename . ' as a DOM Document');
+ }
+
+ return $this->loadDocument($dom, $spreadsheet);
+ }
+
+ /**
+ * Spreadsheet from content.
+ *
+ * @param string $content
+ */
+ public function loadFromString($content, ?Spreadsheet $spreadsheet = null): Spreadsheet
+ {
+ // Create a new DOM object
+ $dom = new DOMDocument();
+ // Reload the HTML file into the DOM object
+ try {
+ $loaded = $dom->loadHTML(mb_convert_encoding($this->securityScanner->scan($content), 'HTML-ENTITIES', 'UTF-8'));
+ } catch (Throwable $e) {
+ $loaded = false;
+ }
+ if ($loaded === false) {
+ throw new Exception('Failed to load content as a DOM Document');
+ }
+
+ return $this->loadDocument($dom, $spreadsheet ?? new Spreadsheet());
+ }
+
+ /**
+ * Loads PhpSpreadsheet from DOMDocument into PhpSpreadsheet instance.
+ */
+ private function loadDocument(DOMDocument $document, Spreadsheet $spreadsheet): Spreadsheet
+ {
+ while ($spreadsheet->getSheetCount() <= $this->sheetIndex) {
+ $spreadsheet->createSheet();
+ }
+ $spreadsheet->setActiveSheetIndex($this->sheetIndex);
+
+ // Discard white space
+ $document->preserveWhiteSpace = false;
+
+ $row = 0;
+ $column = 'A';
+ $content = '';
+ $this->rowspan = [];
+ $this->processDomElement($document, $spreadsheet->getActiveSheet(), $row, $column, $content);
+
+ // Return
+ return $spreadsheet;
+ }
+
+ /**
+ * Get sheet index.
+ *
+ * @return int
+ */
+ public function getSheetIndex()
+ {
+ return $this->sheetIndex;
+ }
+
+ /**
+ * Set sheet index.
+ *
+ * @param int $pValue Sheet index
+ *
+ * @return $this
+ */
+ public function setSheetIndex($pValue)
+ {
+ $this->sheetIndex = $pValue;
+
+ return $this;
+ }
+
+ /**
+ * Apply inline css inline style.
+ *
+ * NOTES :
+ * Currently only intended for td & th element,
+ * and only takes 'background-color' and 'color'; property with HEX color
+ *
+ * TODO :
+ * - Implement to other propertie, such as border
+ *
+ * @param Worksheet $sheet
+ * @param int $row
+ * @param string $column
+ * @param array $attributeArray
+ */
+ private function applyInlineStyle(&$sheet, $row, $column, $attributeArray): void
+ {
+ if (!isset($attributeArray['style'])) {
+ return;
+ }
+
+ if (isset($attributeArray['rowspan'], $attributeArray['colspan'])) {
+ $columnTo = $column;
+ for ($i = 0; $i < (int) $attributeArray['colspan'] - 1; ++$i) {
+ ++$columnTo;
+ }
+ $range = $column . $row . ':' . $columnTo . ($row + (int) $attributeArray['rowspan'] - 1);
+ $cellStyle = $sheet->getStyle($range);
+ } elseif (isset($attributeArray['rowspan'])) {
+ $range = $column . $row . ':' . $column . ($row + (int) $attributeArray['rowspan'] - 1);
+ $cellStyle = $sheet->getStyle($range);
+ } elseif (isset($attributeArray['colspan'])) {
+ $columnTo = $column;
+ for ($i = 0; $i < (int) $attributeArray['colspan'] - 1; ++$i) {
+ ++$columnTo;
+ }
+ $range = $column . $row . ':' . $columnTo . $row;
+ $cellStyle = $sheet->getStyle($range);
+ } else {
+ $cellStyle = $sheet->getStyle($column . $row);
+ }
+
+ // add color styles (background & text) from dom element,currently support : td & th, using ONLY inline css style with RGB color
+ $styles = explode(';', $attributeArray['style']);
+ foreach ($styles as $st) {
+ $value = explode(':', $st);
+ $styleName = isset($value[0]) ? trim($value[0]) : null;
+ $styleValue = isset($value[1]) ? trim($value[1]) : null;
+
+ if (!$styleName) {
+ continue;
+ }
+
+ switch ($styleName) {
+ case 'background':
+ case 'background-color':
+ $styleColor = $this->getStyleColor($styleValue);
+
+ if (!$styleColor) {
+ continue 2;
+ }
+
+ $cellStyle->applyFromArray(['fill' => ['fillType' => Fill::FILL_SOLID, 'color' => ['rgb' => $styleColor]]]);
+
+ break;
+ case 'color':
+ $styleColor = $this->getStyleColor($styleValue);
+
+ if (!$styleColor) {
+ continue 2;
+ }
+
+ $cellStyle->applyFromArray(['font' => ['color' => ['rgb' => $styleColor]]]);
+
+ break;
+
+ case 'border':
+ $this->setBorderStyle($cellStyle, $styleValue, 'allBorders');
+
+ break;
+
+ case 'border-top':
+ $this->setBorderStyle($cellStyle, $styleValue, 'top');
+
+ break;
+
+ case 'border-bottom':
+ $this->setBorderStyle($cellStyle, $styleValue, 'bottom');
+
+ break;
+
+ case 'border-left':
+ $this->setBorderStyle($cellStyle, $styleValue, 'left');
+
+ break;
+
+ case 'border-right':
+ $this->setBorderStyle($cellStyle, $styleValue, 'right');
+
+ break;
+
+ case 'font-size':
+ $cellStyle->getFont()->setSize(
+ (float) $styleValue
+ );
+
+ break;
+
+ case 'font-weight':
+ if ($styleValue === 'bold' || $styleValue >= 500) {
+ $cellStyle->getFont()->setBold(true);
+ }
+
+ break;
+
+ case 'font-style':
+ if ($styleValue === 'italic') {
+ $cellStyle->getFont()->setItalic(true);
+ }
+
+ break;
+
+ case 'font-family':
+ $cellStyle->getFont()->setName(str_replace('\'', '', $styleValue));
+
+ break;
+
+ case 'text-decoration':
+ switch ($styleValue) {
+ case 'underline':
+ $cellStyle->getFont()->setUnderline(Font::UNDERLINE_SINGLE);
+
+ break;
+ case 'line-through':
+ $cellStyle->getFont()->setStrikethrough(true);
+
+ break;
+ }
+
+ break;
+
+ case 'text-align':
+ $cellStyle->getAlignment()->setHorizontal($styleValue);
+
+ break;
+
+ case 'vertical-align':
+ $cellStyle->getAlignment()->setVertical($styleValue);
+
+ break;
+
+ case 'width':
+ $sheet->getColumnDimension($column)->setWidth(
+ str_replace('px', '', $styleValue)
+ );
+
+ break;
+
+ case 'height':
+ $sheet->getRowDimension($row)->setRowHeight(
+ str_replace('px', '', $styleValue)
+ );
+
+ break;
+
+ case 'word-wrap':
+ $cellStyle->getAlignment()->setWrapText(
+ $styleValue === 'break-word'
+ );
+
+ break;
+
+ case 'text-indent':
+ $cellStyle->getAlignment()->setIndent(
+ (int) str_replace(['px'], '', $styleValue)
+ );
+
+ break;
+ }
+ }
+ }
+
+ /**
+ * Check if has #, so we can get clean hex.
+ *
+ * @param $value
+ *
+ * @return null|string
+ */
+ public function getStyleColor($value)
+ {
+ if (strpos($value, '#') === 0) {
+ return substr($value, 1);
+ }
+
+ return \PhpOffice\PhpSpreadsheet\Helper\Html::colourNameLookup((string) $value);
+ }
+
+ /**
+ * @param string $column
+ * @param int $row
+ */
+ private function insertImage(Worksheet $sheet, $column, $row, array $attributes): void
+ {
+ if (!isset($attributes['src'])) {
+ return;
+ }
+
+ $src = urldecode($attributes['src']);
+ $width = isset($attributes['width']) ? (float) $attributes['width'] : null;
+ $height = isset($attributes['height']) ? (float) $attributes['height'] : null;
+ $name = $attributes['alt'] ?? null;
+
+ $drawing = new Drawing();
+ $drawing->setPath($src);
+ $drawing->setWorksheet($sheet);
+ $drawing->setCoordinates($column . $row);
+ $drawing->setOffsetX(0);
+ $drawing->setOffsetY(10);
+ $drawing->setResizeProportional(true);
+
+ if ($name) {
+ $drawing->setName($name);
+ }
+
+ if ($width) {
+ $drawing->setWidth((int) $width);
+ }
+
+ if ($height) {
+ $drawing->setHeight((int) $height);
+ }
+
+ $sheet->getColumnDimension($column)->setWidth(
+ $drawing->getWidth() / 6
+ );
+
+ $sheet->getRowDimension($row)->setRowHeight(
+ $drawing->getHeight() * 0.9
+ );
+ }
+
+ private static $borderMappings = [
+ 'dash-dot' => Border::BORDER_DASHDOT,
+ 'dash-dot-dot' => Border::BORDER_DASHDOTDOT,
+ 'dashed' => Border::BORDER_DASHED,
+ 'dotted' => Border::BORDER_DOTTED,
+ 'double' => Border::BORDER_DOUBLE,
+ 'hair' => Border::BORDER_HAIR,
+ 'medium' => Border::BORDER_MEDIUM,
+ 'medium-dashed' => Border::BORDER_MEDIUMDASHED,
+ 'medium-dash-dot' => Border::BORDER_MEDIUMDASHDOT,
+ 'medium-dash-dot-dot' => Border::BORDER_MEDIUMDASHDOTDOT,
+ 'none' => Border::BORDER_NONE,
+ 'slant-dash-dot' => Border::BORDER_SLANTDASHDOT,
+ 'solid' => Border::BORDER_THIN,
+ 'thick' => Border::BORDER_THICK,
+ ];
+
+ public static function getBorderMappings(): array
+ {
+ return self::$borderMappings;
+ }
+
+ /**
+ * Map html border style to PhpSpreadsheet border style.
+ *
+ * @param string $style
+ *
+ * @return null|string
+ */
+ public function getBorderStyle($style)
+ {
+ return (array_key_exists($style, self::$borderMappings)) ? self::$borderMappings[$style] : null;
+ }
+
+ /**
+ * @param string $styleValue
+ * @param string $type
+ */
+ private function setBorderStyle(Style $cellStyle, $styleValue, $type): void
+ {
+ if (trim($styleValue) === Border::BORDER_NONE) {
+ $borderStyle = Border::BORDER_NONE;
+ $color = null;
+ } else {
+ [, $borderStyle, $color] = explode(' ', $styleValue);
+ }
+
+ $cellStyle->applyFromArray([
+ 'borders' => [
+ $type => [
+ 'borderStyle' => $this->getBorderStyle($borderStyle),
+ 'color' => ['rgb' => $this->getStyleColor($color)],
+ ],
+ ],
+ ]);
+ }
+}
diff --git a/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/IReadFilter.php b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/IReadFilter.php new file mode 100644 index 0000000..16a587e --- /dev/null +++ b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/IReadFilter.php @@ -0,0 +1,17 @@ +<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader;
+
+interface IReadFilter
+{
+ /**
+ * Should this cell be read?
+ *
+ * @param string $column Column address (as a string value like "A", or "IV")
+ * @param int $row Row number
+ * @param string $worksheetName Optional worksheet name
+ *
+ * @return bool
+ */
+ public function readCell($column, $row, $worksheetName = '');
+}
diff --git a/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/IReader.php b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/IReader.php new file mode 100644 index 0000000..7707bb3 --- /dev/null +++ b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/IReader.php @@ -0,0 +1,133 @@ +<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader;
+
+interface IReader
+{
+ /**
+ * IReader constructor.
+ */
+ public function __construct();
+
+ /**
+ * Can the current IReader read the file?
+ *
+ * @param string $pFilename
+ *
+ * @return bool
+ */
+ public function canRead($pFilename);
+
+ /**
+ * Read data only?
+ * If this is true, then the Reader will only read data values for cells, it will not read any formatting information.
+ * If false (the default) it will read data and formatting.
+ *
+ * @return bool
+ */
+ public function getReadDataOnly();
+
+ /**
+ * Set read data only
+ * Set to true, to advise the Reader only to read data values for cells, and to ignore any formatting information.
+ * Set to false (the default) to advise the Reader to read both data and formatting for cells.
+ *
+ * @param bool $pValue
+ *
+ * @return IReader
+ */
+ public function setReadDataOnly($pValue);
+
+ /**
+ * Read empty cells?
+ * If this is true (the default), then the Reader will read data values for all cells, irrespective of value.
+ * If false it will not read data for cells containing a null value or an empty string.
+ *
+ * @return bool
+ */
+ public function getReadEmptyCells();
+
+ /**
+ * Set read empty cells
+ * Set to true (the default) to advise the Reader read data values for all cells, irrespective of value.
+ * Set to false to advise the Reader to ignore cells containing a null value or an empty string.
+ *
+ * @param bool $pValue
+ *
+ * @return IReader
+ */
+ public function setReadEmptyCells($pValue);
+
+ /**
+ * Read charts in workbook?
+ * If this is true, then the Reader will include any charts that exist in the workbook.
+ * Note that a ReadDataOnly value of false overrides, and charts won't be read regardless of the IncludeCharts value.
+ * If false (the default) it will ignore any charts defined in the workbook file.
+ *
+ * @return bool
+ */
+ public function getIncludeCharts();
+
+ /**
+ * Set read charts in workbook
+ * Set to true, to advise the Reader to include any charts that exist in the workbook.
+ * Note that a ReadDataOnly value of false overrides, and charts won't be read regardless of the IncludeCharts value.
+ * Set to false (the default) to discard charts.
+ *
+ * @param bool $pValue
+ *
+ * @return IReader
+ */
+ public function setIncludeCharts($pValue);
+
+ /**
+ * Get which sheets to load
+ * Returns either an array of worksheet names (the list of worksheets that should be loaded), or a null
+ * indicating that all worksheets in the workbook should be loaded.
+ *
+ * @return mixed
+ */
+ public function getLoadSheetsOnly();
+
+ /**
+ * Set which sheets to load.
+ *
+ * @param mixed $value
+ * This should be either an array of worksheet names to be loaded, or a string containing a single worksheet name.
+ * If NULL, then it tells the Reader to read all worksheets in the workbook
+ *
+ * @return IReader
+ */
+ public function setLoadSheetsOnly($value);
+
+ /**
+ * Set all sheets to load
+ * Tells the Reader to load all worksheets from the workbook.
+ *
+ * @return IReader
+ */
+ public function setLoadAllSheets();
+
+ /**
+ * Read filter.
+ *
+ * @return IReadFilter
+ */
+ public function getReadFilter();
+
+ /**
+ * Set read filter.
+ *
+ * @return IReader
+ */
+ public function setReadFilter(IReadFilter $pValue);
+
+ /**
+ * Loads PhpSpreadsheet from file.
+ *
+ * @param string $pFilename
+ *
+ * @return \PhpOffice\PhpSpreadsheet\Spreadsheet
+ */
+ public function load($pFilename);
+}
diff --git a/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Ods.php b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Ods.php new file mode 100644 index 0000000..ea46b75 --- /dev/null +++ b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Ods.php @@ -0,0 +1,795 @@ +<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader;
+
+use DateTime;
+use DateTimeZone;
+use DOMAttr;
+use DOMDocument;
+use DOMElement;
+use DOMNode;
+use PhpOffice\PhpSpreadsheet\Calculation\Calculation;
+use PhpOffice\PhpSpreadsheet\Cell\Coordinate;
+use PhpOffice\PhpSpreadsheet\Cell\DataType;
+use PhpOffice\PhpSpreadsheet\DefinedName;
+use PhpOffice\PhpSpreadsheet\Reader\Exception as ReaderException;
+use PhpOffice\PhpSpreadsheet\Reader\Ods\PageSettings;
+use PhpOffice\PhpSpreadsheet\Reader\Ods\Properties as DocumentProperties;
+use PhpOffice\PhpSpreadsheet\Reader\Security\XmlScanner;
+use PhpOffice\PhpSpreadsheet\RichText\RichText;
+use PhpOffice\PhpSpreadsheet\Settings;
+use PhpOffice\PhpSpreadsheet\Shared\Date;
+use PhpOffice\PhpSpreadsheet\Shared\File;
+use PhpOffice\PhpSpreadsheet\Spreadsheet;
+use PhpOffice\PhpSpreadsheet\Style\NumberFormat;
+use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
+use XMLReader;
+use ZipArchive;
+
+class Ods extends BaseReader
+{
+ /**
+ * Create a new Ods Reader instance.
+ */
+ public function __construct()
+ {
+ parent::__construct();
+ $this->securityScanner = XmlScanner::getInstance($this);
+ }
+
+ /**
+ * Can the current IReader read the file?
+ *
+ * @param string $pFilename
+ *
+ * @return bool
+ */
+ public function canRead($pFilename)
+ {
+ File::assertFile($pFilename);
+
+ $mimeType = 'UNKNOWN';
+
+ // Load file
+
+ $zip = new ZipArchive();
+ if ($zip->open($pFilename) === true) {
+ // check if it is an OOXML archive
+ $stat = $zip->statName('mimetype');
+ if ($stat && ($stat['size'] <= 255)) {
+ $mimeType = $zip->getFromName($stat['name']);
+ } elseif ($zip->statName('META-INF/manifest.xml')) {
+ $xml = simplexml_load_string(
+ $this->securityScanner->scan($zip->getFromName('META-INF/manifest.xml')),
+ 'SimpleXMLElement',
+ Settings::getLibXmlLoaderOptions()
+ );
+ $namespacesContent = $xml->getNamespaces(true);
+ if (isset($namespacesContent['manifest'])) {
+ $manifest = $xml->children($namespacesContent['manifest']);
+ foreach ($manifest as $manifestDataSet) {
+ $manifestAttributes = $manifestDataSet->attributes($namespacesContent['manifest']);
+ if ($manifestAttributes->{'full-path'} == '/') {
+ $mimeType = (string) $manifestAttributes->{'media-type'};
+
+ break;
+ }
+ }
+ }
+ }
+
+ $zip->close();
+ }
+
+ return $mimeType === 'application/vnd.oasis.opendocument.spreadsheet';
+ }
+
+ /**
+ * Reads names of the worksheets from a file, without parsing the whole file to a PhpSpreadsheet object.
+ *
+ * @param string $pFilename
+ *
+ * @return string[]
+ */
+ public function listWorksheetNames($pFilename)
+ {
+ File::assertFile($pFilename);
+
+ $zip = new ZipArchive();
+ if ($zip->open($pFilename) !== true) {
+ throw new ReaderException('Could not open ' . $pFilename . ' for reading! Error opening file.');
+ }
+
+ $worksheetNames = [];
+
+ $xml = new XMLReader();
+ $xml->xml(
+ $this->securityScanner->scanFile('zip://' . realpath($pFilename) . '#content.xml'),
+ null,
+ Settings::getLibXmlLoaderOptions()
+ );
+ $xml->setParserProperty(2, true);
+
+ // Step into the first level of content of the XML
+ $xml->read();
+ while ($xml->read()) {
+ // Quickly jump through to the office:body node
+ while ($xml->name !== 'office:body') {
+ if ($xml->isEmptyElement) {
+ $xml->read();
+ } else {
+ $xml->next();
+ }
+ }
+ // Now read each node until we find our first table:table node
+ while ($xml->read()) {
+ if ($xml->name == 'table:table' && $xml->nodeType == XMLReader::ELEMENT) {
+ // Loop through each table:table node reading the table:name attribute for each worksheet name
+ do {
+ $worksheetNames[] = $xml->getAttribute('table:name');
+ $xml->next();
+ } while ($xml->name == 'table:table' && $xml->nodeType == XMLReader::ELEMENT);
+ }
+ }
+ }
+
+ return $worksheetNames;
+ }
+
+ /**
+ * Return worksheet info (Name, Last Column Letter, Last Column Index, Total Rows, Total Columns).
+ *
+ * @param string $pFilename
+ *
+ * @return array
+ */
+ public function listWorksheetInfo($pFilename)
+ {
+ File::assertFile($pFilename);
+
+ $worksheetInfo = [];
+
+ $zip = new ZipArchive();
+ if ($zip->open($pFilename) !== true) {
+ throw new ReaderException('Could not open ' . $pFilename . ' for reading! Error opening file.');
+ }
+
+ $xml = new XMLReader();
+ $xml->xml(
+ $this->securityScanner->scanFile('zip://' . realpath($pFilename) . '#content.xml'),
+ null,
+ Settings::getLibXmlLoaderOptions()
+ );
+ $xml->setParserProperty(2, true);
+
+ // Step into the first level of content of the XML
+ $xml->read();
+ while ($xml->read()) {
+ // Quickly jump through to the office:body node
+ while ($xml->name !== 'office:body') {
+ if ($xml->isEmptyElement) {
+ $xml->read();
+ } else {
+ $xml->next();
+ }
+ }
+ // Now read each node until we find our first table:table node
+ while ($xml->read()) {
+ if ($xml->name == 'table:table' && $xml->nodeType == XMLReader::ELEMENT) {
+ $worksheetNames[] = $xml->getAttribute('table:name');
+
+ $tmpInfo = [
+ 'worksheetName' => $xml->getAttribute('table:name'),
+ 'lastColumnLetter' => 'A',
+ 'lastColumnIndex' => 0,
+ 'totalRows' => 0,
+ 'totalColumns' => 0,
+ ];
+
+ // Loop through each child node of the table:table element reading
+ $currCells = 0;
+ do {
+ $xml->read();
+ if ($xml->name == 'table:table-row' && $xml->nodeType == XMLReader::ELEMENT) {
+ $rowspan = $xml->getAttribute('table:number-rows-repeated');
+ $rowspan = empty($rowspan) ? 1 : $rowspan;
+ $tmpInfo['totalRows'] += $rowspan;
+ $tmpInfo['totalColumns'] = max($tmpInfo['totalColumns'], $currCells);
+ $currCells = 0;
+ // Step into the row
+ $xml->read();
+ do {
+ $doread = true;
+ if ($xml->name == 'table:table-cell' && $xml->nodeType == XMLReader::ELEMENT) {
+ if (!$xml->isEmptyElement) {
+ ++$currCells;
+ $xml->next();
+ $doread = false;
+ }
+ } elseif ($xml->name == 'table:covered-table-cell' && $xml->nodeType == XMLReader::ELEMENT) {
+ $mergeSize = $xml->getAttribute('table:number-columns-repeated');
+ $currCells += (int) $mergeSize;
+ }
+ if ($doread) {
+ $xml->read();
+ }
+ } while ($xml->name != 'table:table-row');
+ }
+ } while ($xml->name != 'table:table');
+
+ $tmpInfo['totalColumns'] = max($tmpInfo['totalColumns'], $currCells);
+ $tmpInfo['lastColumnIndex'] = $tmpInfo['totalColumns'] - 1;
+ $tmpInfo['lastColumnLetter'] = Coordinate::stringFromColumnIndex($tmpInfo['lastColumnIndex'] + 1);
+ $worksheetInfo[] = $tmpInfo;
+ }
+ }
+ }
+
+ return $worksheetInfo;
+ }
+
+ /**
+ * Loads PhpSpreadsheet from file.
+ *
+ * @param string $pFilename
+ *
+ * @return Spreadsheet
+ */
+ public function load($pFilename)
+ {
+ // Create new Spreadsheet
+ $spreadsheet = new Spreadsheet();
+
+ // Load into this instance
+ return $this->loadIntoExisting($pFilename, $spreadsheet);
+ }
+
+ /**
+ * Loads PhpSpreadsheet from file into PhpSpreadsheet instance.
+ *
+ * @param string $pFilename
+ *
+ * @return Spreadsheet
+ */
+ public function loadIntoExisting($pFilename, Spreadsheet $spreadsheet)
+ {
+ File::assertFile($pFilename);
+
+ $timezoneObj = new DateTimeZone('Europe/London');
+ $GMT = new DateTimeZone('UTC');
+
+ $zip = new ZipArchive();
+ if ($zip->open($pFilename) !== true) {
+ throw new Exception("Could not open {$pFilename} for reading! Error opening file.");
+ }
+
+ // Meta
+
+ $xml = @simplexml_load_string(
+ $this->securityScanner->scan($zip->getFromName('meta.xml')),
+ 'SimpleXMLElement',
+ Settings::getLibXmlLoaderOptions()
+ );
+ if ($xml === false) {
+ throw new Exception('Unable to read data from {$pFilename}');
+ }
+
+ $namespacesMeta = $xml->getNamespaces(true);
+
+ (new DocumentProperties($spreadsheet))->load($xml, $namespacesMeta);
+
+ // Styles
+
+ $dom = new DOMDocument('1.01', 'UTF-8');
+ $dom->loadXML(
+ $this->securityScanner->scan($zip->getFromName('styles.xml')),
+ Settings::getLibXmlLoaderOptions()
+ );
+
+ $pageSettings = new PageSettings($dom);
+
+ // Main Content
+
+ $dom = new DOMDocument('1.01', 'UTF-8');
+ $dom->loadXML(
+ $this->securityScanner->scan($zip->getFromName('content.xml')),
+ Settings::getLibXmlLoaderOptions()
+ );
+
+ $officeNs = $dom->lookupNamespaceUri('office');
+ $tableNs = $dom->lookupNamespaceUri('table');
+ $textNs = $dom->lookupNamespaceUri('text');
+ $xlinkNs = $dom->lookupNamespaceUri('xlink');
+
+ $pageSettings->readStyleCrossReferences($dom);
+
+ // Content
+
+ $spreadsheets = $dom->getElementsByTagNameNS($officeNs, 'body')
+ ->item(0)
+ ->getElementsByTagNameNS($officeNs, 'spreadsheet');
+
+ foreach ($spreadsheets as $workbookData) {
+ /** @var DOMElement $workbookData */
+ $tables = $workbookData->getElementsByTagNameNS($tableNs, 'table');
+
+ $worksheetID = 0;
+ foreach ($tables as $worksheetDataSet) {
+ /** @var DOMElement $worksheetDataSet */
+ $worksheetName = $worksheetDataSet->getAttributeNS($tableNs, 'name');
+
+ // Check loadSheetsOnly
+ if (
+ isset($this->loadSheetsOnly)
+ && $worksheetName
+ && !in_array($worksheetName, $this->loadSheetsOnly)
+ ) {
+ continue;
+ }
+
+ $worksheetStyleName = $worksheetDataSet->getAttributeNS($tableNs, 'style-name');
+
+ // Create sheet
+ if ($worksheetID > 0) {
+ $spreadsheet->createSheet(); // First sheet is added by default
+ }
+ $spreadsheet->setActiveSheetIndex($worksheetID);
+
+ if ($worksheetName) {
+ // 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
+ $spreadsheet->getActiveSheet()->setTitle((string) $worksheetName, false, false);
+ }
+
+ // Go through every child of table element
+ $rowID = 1;
+ foreach ($worksheetDataSet->childNodes as $childNode) {
+ /** @var DOMElement $childNode */
+
+ // Filter elements which are not under the "table" ns
+ if ($childNode->namespaceURI != $tableNs) {
+ continue;
+ }
+
+ $key = $childNode->nodeName;
+
+ // Remove ns from node name
+ if (strpos($key, ':') !== false) {
+ $keyChunks = explode(':', $key);
+ $key = array_pop($keyChunks);
+ }
+
+ switch ($key) {
+ case 'table-header-rows':
+ /// TODO :: Figure this out. This is only a partial implementation I guess.
+ // ($rowData it's not used at all and I'm not sure that PHPExcel
+ // has an API for this)
+
+// foreach ($rowData as $keyRowData => $cellData) {
+// $rowData = $cellData;
+// break;
+// }
+ break;
+ case 'table-row':
+ if ($childNode->hasAttributeNS($tableNs, 'number-rows-repeated')) {
+ $rowRepeats = $childNode->getAttributeNS($tableNs, 'number-rows-repeated');
+ } else {
+ $rowRepeats = 1;
+ }
+
+ $columnID = 'A';
+ foreach ($childNode->childNodes as $key => $cellData) {
+ // @var \DOMElement $cellData
+
+ if ($this->getReadFilter() !== null) {
+ if (!$this->getReadFilter()->readCell($columnID, $rowID, $worksheetName)) {
+ ++$columnID;
+
+ continue;
+ }
+ }
+
+ // Initialize variables
+ $formatting = $hyperlink = null;
+ $hasCalculatedValue = false;
+ $cellDataFormula = '';
+
+ if ($cellData->hasAttributeNS($tableNs, 'formula')) {
+ $cellDataFormula = $cellData->getAttributeNS($tableNs, 'formula');
+ $hasCalculatedValue = true;
+ }
+
+ // Annotations
+ $annotation = $cellData->getElementsByTagNameNS($officeNs, 'annotation');
+
+ if ($annotation->length > 0) {
+ $textNode = $annotation->item(0)->getElementsByTagNameNS($textNs, 'p');
+
+ if ($textNode->length > 0) {
+ $text = $this->scanElementForText($textNode->item(0));
+
+ $spreadsheet->getActiveSheet()
+ ->getComment($columnID . $rowID)
+ ->setText($this->parseRichText($text));
+// ->setAuthor( $author )
+ }
+ }
+
+ // Content
+
+ /** @var DOMElement[] $paragraphs */
+ $paragraphs = [];
+
+ foreach ($cellData->childNodes as $item) {
+ /** @var DOMElement $item */
+
+ // Filter text:p elements
+ if ($item->nodeName == 'text:p') {
+ $paragraphs[] = $item;
+ }
+ }
+
+ if (count($paragraphs) > 0) {
+ // Consolidate if there are multiple p records (maybe with spans as well)
+ $dataArray = [];
+
+ // Text can have multiple text:p and within those, multiple text:span.
+ // text:p newlines, but text:span does not.
+ // Also, here we assume there is no text data is span fields are specified, since
+ // we have no way of knowing proper positioning anyway.
+
+ foreach ($paragraphs as $pData) {
+ $dataArray[] = $this->scanElementForText($pData);
+ }
+ $allCellDataText = implode("\n", $dataArray);
+
+ $type = $cellData->getAttributeNS($officeNs, 'value-type');
+
+ switch ($type) {
+ case 'string':
+ $type = DataType::TYPE_STRING;
+ $dataValue = $allCellDataText;
+
+ foreach ($paragraphs as $paragraph) {
+ $link = $paragraph->getElementsByTagNameNS($textNs, 'a');
+ if ($link->length > 0) {
+ $hyperlink = $link->item(0)->getAttributeNS($xlinkNs, 'href');
+ }
+ }
+
+ break;
+ case 'boolean':
+ $type = DataType::TYPE_BOOL;
+ $dataValue = ($allCellDataText == 'TRUE') ? true : false;
+
+ break;
+ case 'percentage':
+ $type = DataType::TYPE_NUMERIC;
+ $dataValue = (float) $cellData->getAttributeNS($officeNs, 'value');
+
+ // percentage should always be float
+ //if (floor($dataValue) == $dataValue) {
+ // $dataValue = (int) $dataValue;
+ //}
+ $formatting = NumberFormat::FORMAT_PERCENTAGE_00;
+
+ break;
+ case 'currency':
+ $type = DataType::TYPE_NUMERIC;
+ $dataValue = (float) $cellData->getAttributeNS($officeNs, 'value');
+
+ if (floor($dataValue) == $dataValue) {
+ $dataValue = (int) $dataValue;
+ }
+ $formatting = NumberFormat::FORMAT_CURRENCY_USD_SIMPLE;
+
+ break;
+ case 'float':
+ $type = DataType::TYPE_NUMERIC;
+ $dataValue = (float) $cellData->getAttributeNS($officeNs, 'value');
+
+ if (floor($dataValue) == $dataValue) {
+ if ($dataValue == (int) $dataValue) {
+ $dataValue = (int) $dataValue;
+ }
+ }
+
+ break;
+ case 'date':
+ $type = DataType::TYPE_NUMERIC;
+ $value = $cellData->getAttributeNS($officeNs, 'date-value');
+
+ $dateObj = new DateTime($value, $GMT);
+ $dateObj->setTimeZone($timezoneObj);
+ [$year, $month, $day, $hour, $minute, $second] = explode(
+ ' ',
+ $dateObj->format('Y m d H i s')
+ );
+
+ $dataValue = Date::formattedPHPToExcel(
+ (int) $year,
+ (int) $month,
+ (int) $day,
+ (int) $hour,
+ (int) $minute,
+ (int) $second
+ );
+
+ if ($dataValue != floor($dataValue)) {
+ $formatting = NumberFormat::FORMAT_DATE_XLSX15
+ . ' '
+ . NumberFormat::FORMAT_DATE_TIME4;
+ } else {
+ $formatting = NumberFormat::FORMAT_DATE_XLSX15;
+ }
+
+ break;
+ case 'time':
+ $type = DataType::TYPE_NUMERIC;
+
+ $timeValue = $cellData->getAttributeNS($officeNs, 'time-value');
+
+ $dataValue = Date::PHPToExcel(
+ strtotime(
+ '01-01-1970 ' . implode(':', sscanf($timeValue, 'PT%dH%dM%dS'))
+ )
+ );
+ $formatting = NumberFormat::FORMAT_DATE_TIME4;
+
+ break;
+ default:
+ $dataValue = null;
+ }
+ } else {
+ $type = DataType::TYPE_NULL;
+ $dataValue = null;
+ }
+
+ if ($hasCalculatedValue) {
+ $type = DataType::TYPE_FORMULA;
+ $cellDataFormula = substr($cellDataFormula, strpos($cellDataFormula, ':=') + 1);
+ $cellDataFormula = $this->convertToExcelFormulaValue($cellDataFormula);
+ }
+
+ if ($cellData->hasAttributeNS($tableNs, 'number-columns-repeated')) {
+ $colRepeats = (int) $cellData->getAttributeNS($tableNs, 'number-columns-repeated');
+ } else {
+ $colRepeats = 1;
+ }
+
+ if ($type !== null) {
+ for ($i = 0; $i < $colRepeats; ++$i) {
+ if ($i > 0) {
+ ++$columnID;
+ }
+
+ if ($type !== DataType::TYPE_NULL) {
+ for ($rowAdjust = 0; $rowAdjust < $rowRepeats; ++$rowAdjust) {
+ $rID = $rowID + $rowAdjust;
+
+ $cell = $spreadsheet->getActiveSheet()
+ ->getCell($columnID . $rID);
+
+ // Set value
+ if ($hasCalculatedValue) {
+ $cell->setValueExplicit($cellDataFormula, $type);
+ } else {
+ $cell->setValueExplicit($dataValue, $type);
+ }
+
+ if ($hasCalculatedValue) {
+ $cell->setCalculatedValue($dataValue);
+ }
+
+ // Set other properties
+ if ($formatting !== null) {
+ $spreadsheet->getActiveSheet()
+ ->getStyle($columnID . $rID)
+ ->getNumberFormat()
+ ->setFormatCode($formatting);
+ } else {
+ $spreadsheet->getActiveSheet()
+ ->getStyle($columnID . $rID)
+ ->getNumberFormat()
+ ->setFormatCode(NumberFormat::FORMAT_GENERAL);
+ }
+
+ if ($hyperlink !== null) {
+ $cell->getHyperlink()
+ ->setUrl($hyperlink);
+ }
+ }
+ }
+ }
+ }
+
+ // Merged cells
+ if (
+ $cellData->hasAttributeNS($tableNs, 'number-columns-spanned')
+ || $cellData->hasAttributeNS($tableNs, 'number-rows-spanned')
+ ) {
+ if (($type !== DataType::TYPE_NULL) || (!$this->readDataOnly)) {
+ $columnTo = $columnID;
+
+ if ($cellData->hasAttributeNS($tableNs, 'number-columns-spanned')) {
+ $columnIndex = Coordinate::columnIndexFromString($columnID);
+ $columnIndex += (int) $cellData->getAttributeNS($tableNs, 'number-columns-spanned');
+ $columnIndex -= 2;
+
+ $columnTo = Coordinate::stringFromColumnIndex($columnIndex + 1);
+ }
+
+ $rowTo = $rowID;
+
+ if ($cellData->hasAttributeNS($tableNs, 'number-rows-spanned')) {
+ $rowTo = $rowTo + (int) $cellData->getAttributeNS($tableNs, 'number-rows-spanned') - 1;
+ }
+
+ $cellRange = $columnID . $rowID . ':' . $columnTo . $rowTo;
+ $spreadsheet->getActiveSheet()->mergeCells($cellRange);
+ }
+ }
+
+ ++$columnID;
+ }
+ $rowID += $rowRepeats;
+
+ break;
+ }
+ }
+ $pageSettings->setPrintSettingsForWorksheet($spreadsheet->getActiveSheet(), $worksheetStyleName);
+ ++$worksheetID;
+ }
+
+ $this->readDefinedRanges($spreadsheet, $workbookData, $tableNs);
+ $this->readDefinedExpressions($spreadsheet, $workbookData, $tableNs);
+ }
+ $spreadsheet->setActiveSheetIndex(0);
+ // Return
+ return $spreadsheet;
+ }
+
+ /**
+ * Recursively scan element.
+ *
+ * @return string
+ */
+ protected function scanElementForText(DOMNode $element)
+ {
+ $str = '';
+ foreach ($element->childNodes as $child) {
+ /** @var DOMNode $child */
+ if ($child->nodeType == XML_TEXT_NODE) {
+ $str .= $child->nodeValue;
+ } elseif ($child->nodeType == XML_ELEMENT_NODE && $child->nodeName == 'text:s') {
+ // It's a space
+
+ // Multiple spaces?
+ /** @var DOMAttr $cAttr */
+ $cAttr = $child->attributes->getNamedItem('c');
+ if ($cAttr) {
+ $multiplier = (int) $cAttr->nodeValue;
+ } else {
+ $multiplier = 1;
+ }
+
+ $str .= str_repeat(' ', $multiplier);
+ }
+
+ if ($child->hasChildNodes()) {
+ $str .= $this->scanElementForText($child);
+ }
+ }
+
+ return $str;
+ }
+
+ /**
+ * @param string $is
+ *
+ * @return RichText
+ */
+ private function parseRichText($is)
+ {
+ $value = new RichText();
+ $value->createText($is);
+
+ return $value;
+ }
+
+ private function convertToExcelAddressValue(string $openOfficeAddress): string
+ {
+ $excelAddress = $openOfficeAddress;
+
+ // Cell range 3-d reference
+ // As we don't support 3-d ranges, we're just going to take a quick and dirty approach
+ // and assume that the second worksheet reference is the same as the first
+ $excelAddress = preg_replace('/\$?([^\.]+)\.([^\.]+):\$?([^\.]+)\.([^\.]+)/miu', '$1!$2:$4', $excelAddress);
+ // Cell range reference in another sheet
+ $excelAddress = preg_replace('/\$?([^\.]+)\.([^\.]+):\.([^\.]+)/miu', '$1!$2:$3', $excelAddress);
+ // Cell reference in another sheet
+ $excelAddress = preg_replace('/\$?([^\.]+)\.([^\.]+)/miu', '$1!$2', $excelAddress);
+ // Cell range reference
+ $excelAddress = preg_replace('/\.([^\.]+):\.([^\.]+)/miu', '$1:$2', $excelAddress);
+ // Simple cell reference
+ $excelAddress = preg_replace('/\.([^\.]+)/miu', '$1', $excelAddress);
+
+ return $excelAddress;
+ }
+
+ private function convertToExcelFormulaValue(string $openOfficeFormula): string
+ {
+ $temp = explode('"', $openOfficeFormula);
+ $tKey = false;
+ foreach ($temp as &$value) {
+ // Only replace in alternate array entries (i.e. non-quoted blocks)
+ if ($tKey = !$tKey) {
+ // Cell range reference in another sheet
+ $value = preg_replace('/\[\$?([^\.]+)\.([^\.]+):\.([^\.]+)\]/miu', '$1!$2:$3', $value);
+ // Cell reference in another sheet
+ $value = preg_replace('/\[\$?([^\.]+)\.([^\.]+)\]/miu', '$1!$2', $value);
+ // Cell range reference
+ $value = preg_replace('/\[\.([^\.]+):\.([^\.]+)\]/miu', '$1:$2', $value);
+ // Simple cell reference
+ $value = preg_replace('/\[\.([^\.]+)\]/miu', '$1', $value);
+
+ $value = Calculation::translateSeparator(';', ',', $value, $inBraces);
+ }
+ }
+
+ // Then rebuild the formula string
+ $excelFormula = implode('"', $temp);
+
+ return $excelFormula;
+ }
+
+ /**
+ * Read any Named Ranges that are defined in this spreadsheet.
+ */
+ private function readDefinedRanges(Spreadsheet $spreadsheet, DOMElement $workbookData, string $tableNs): void
+ {
+ $namedRanges = $workbookData->getElementsByTagNameNS($tableNs, 'named-range');
+ foreach ($namedRanges as $definedNameElement) {
+ $definedName = $definedNameElement->getAttributeNS($tableNs, 'name');
+ $baseAddress = $definedNameElement->getAttributeNS($tableNs, 'base-cell-address');
+ $range = $definedNameElement->getAttributeNS($tableNs, 'cell-range-address');
+
+ $baseAddress = $this->convertToExcelAddressValue($baseAddress);
+ $range = $this->convertToExcelAddressValue($range);
+
+ $this->addDefinedName($spreadsheet, $baseAddress, $definedName, $range);
+ }
+ }
+
+ /**
+ * Read any Named Formulae that are defined in this spreadsheet.
+ */
+ private function readDefinedExpressions(Spreadsheet $spreadsheet, DOMElement $workbookData, string $tableNs): void
+ {
+ $namedExpressions = $workbookData->getElementsByTagNameNS($tableNs, 'named-expression');
+ foreach ($namedExpressions as $definedNameElement) {
+ $definedName = $definedNameElement->getAttributeNS($tableNs, 'name');
+ $baseAddress = $definedNameElement->getAttributeNS($tableNs, 'base-cell-address');
+ $expression = $definedNameElement->getAttributeNS($tableNs, 'expression');
+
+ $baseAddress = $this->convertToExcelAddressValue($baseAddress);
+ $expression = $this->convertToExcelFormulaValue($expression);
+
+ $this->addDefinedName($spreadsheet, $baseAddress, $definedName, $expression);
+ }
+ }
+
+ /**
+ * Assess scope and store the Defined Name.
+ */
+ private function addDefinedName(Spreadsheet $spreadsheet, string $baseAddress, string $definedName, string $value): void
+ {
+ [$sheetReference] = Worksheet::extractSheetTitle($baseAddress, true);
+ $worksheet = $spreadsheet->getSheetByName($sheetReference);
+ // Worksheet might still be null if we're only loading selected sheets rather than the full spreadsheet
+ if ($worksheet !== null) {
+ $spreadsheet->addDefinedName(DefinedName::createInstance((string) $definedName, $worksheet, $value));
+ }
+ }
+}
diff --git a/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Ods/PageSettings.php b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Ods/PageSettings.php new file mode 100644 index 0000000..64495df --- /dev/null +++ b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Ods/PageSettings.php @@ -0,0 +1,139 @@ +<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader\Ods;
+
+use DOMDocument;
+use PhpOffice\PhpSpreadsheet\Worksheet\PageSetup;
+use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
+
+class PageSettings
+{
+ private $officeNs;
+
+ private $stylesNs;
+
+ private $stylesFo;
+
+ private $pageLayoutStyles = [];
+
+ private $masterStylesCrossReference = [];
+
+ private $masterPrintStylesCrossReference = [];
+
+ public function __construct(DOMDocument $styleDom)
+ {
+ $this->setDomNameSpaces($styleDom);
+ $this->readPageSettingStyles($styleDom);
+ $this->readStyleMasterLookup($styleDom);
+ }
+
+ private function setDomNameSpaces(DOMDocument $styleDom): void
+ {
+ $this->officeNs = $styleDom->lookupNamespaceUri('office');
+ $this->stylesNs = $styleDom->lookupNamespaceUri('style');
+ $this->stylesFo = $styleDom->lookupNamespaceUri('fo');
+ }
+
+ private function readPageSettingStyles(DOMDocument $styleDom): void
+ {
+ $styles = $styleDom->getElementsByTagNameNS($this->officeNs, 'automatic-styles')
+ ->item(0)
+ ->getElementsByTagNameNS($this->stylesNs, 'page-layout');
+
+ foreach ($styles as $styleSet) {
+ $styleName = $styleSet->getAttributeNS($this->stylesNs, 'name');
+ $pageLayoutProperties = $styleSet->getElementsByTagNameNS($this->stylesNs, 'page-layout-properties')[0];
+ $styleOrientation = $pageLayoutProperties->getAttributeNS($this->stylesNs, 'print-orientation');
+ $styleScale = $pageLayoutProperties->getAttributeNS($this->stylesNs, 'scale-to');
+ $stylePrintOrder = $pageLayoutProperties->getAttributeNS($this->stylesNs, 'print-page-order');
+ $centered = $pageLayoutProperties->getAttributeNS($this->stylesNs, 'table-centering');
+
+ $marginLeft = $pageLayoutProperties->getAttributeNS($this->stylesFo, 'margin-left');
+ $marginRight = $pageLayoutProperties->getAttributeNS($this->stylesFo, 'margin-right');
+ $marginTop = $pageLayoutProperties->getAttributeNS($this->stylesFo, 'margin-top');
+ $marginBottom = $pageLayoutProperties->getAttributeNS($this->stylesFo, 'margin-bottom');
+ $header = $styleSet->getElementsByTagNameNS($this->stylesNs, 'header-style')[0];
+ $headerProperties = $header->getElementsByTagNameNS($this->stylesNs, 'header-footer-properties')[0];
+ $marginHeader = $headerProperties->getAttributeNS($this->stylesFo, 'min-height');
+ $footer = $styleSet->getElementsByTagNameNS($this->stylesNs, 'footer-style')[0];
+ $footerProperties = $footer->getElementsByTagNameNS($this->stylesNs, 'header-footer-properties')[0];
+ $marginFooter = $footerProperties->getAttributeNS($this->stylesFo, 'min-height');
+
+ $this->pageLayoutStyles[$styleName] = (object) [
+ 'orientation' => $styleOrientation ?: PageSetup::ORIENTATION_DEFAULT,
+ 'scale' => $styleScale ?: 100,
+ 'printOrder' => $stylePrintOrder,
+ 'horizontalCentered' => $centered === 'horizontal' || $centered === 'both',
+ 'verticalCentered' => $centered === 'vertical' || $centered === 'both',
+ // margin size is already stored in inches, so no UOM conversion is required
+ 'marginLeft' => (float) $marginLeft ?? 0.7,
+ 'marginRight' => (float) $marginRight ?? 0.7,
+ 'marginTop' => (float) $marginTop ?? 0.3,
+ 'marginBottom' => (float) $marginBottom ?? 0.3,
+ 'marginHeader' => (float) $marginHeader ?? 0.45,
+ 'marginFooter' => (float) $marginFooter ?? 0.45,
+ ];
+ }
+ }
+
+ private function readStyleMasterLookup(DOMDocument $styleDom): void
+ {
+ $styleMasterLookup = $styleDom->getElementsByTagNameNS($this->officeNs, 'master-styles')
+ ->item(0)
+ ->getElementsByTagNameNS($this->stylesNs, 'master-page');
+
+ foreach ($styleMasterLookup as $styleMasterSet) {
+ $styleMasterName = $styleMasterSet->getAttributeNS($this->stylesNs, 'name');
+ $pageLayoutName = $styleMasterSet->getAttributeNS($this->stylesNs, 'page-layout-name');
+ $this->masterPrintStylesCrossReference[$styleMasterName] = $pageLayoutName;
+ }
+ }
+
+ public function readStyleCrossReferences(DOMDocument $contentDom): void
+ {
+ $styleXReferences = $contentDom->getElementsByTagNameNS($this->officeNs, 'automatic-styles')
+ ->item(0)
+ ->getElementsByTagNameNS($this->stylesNs, 'style');
+
+ foreach ($styleXReferences as $styleXreferenceSet) {
+ $styleXRefName = $styleXreferenceSet->getAttributeNS($this->stylesNs, 'name');
+ $stylePageLayoutName = $styleXreferenceSet->getAttributeNS($this->stylesNs, 'master-page-name');
+ if (!empty($stylePageLayoutName)) {
+ $this->masterStylesCrossReference[$styleXRefName] = $stylePageLayoutName;
+ }
+ }
+ }
+
+ public function setPrintSettingsForWorksheet(Worksheet $worksheet, string $styleName): void
+ {
+ if (!array_key_exists($styleName, $this->masterStylesCrossReference)) {
+ return;
+ }
+ $masterStyleName = $this->masterStylesCrossReference[$styleName];
+
+ if (!array_key_exists($masterStyleName, $this->masterPrintStylesCrossReference)) {
+ return;
+ }
+ $printSettingsIndex = $this->masterPrintStylesCrossReference[$masterStyleName];
+
+ if (!array_key_exists($printSettingsIndex, $this->pageLayoutStyles)) {
+ return;
+ }
+ $printSettings = $this->pageLayoutStyles[$printSettingsIndex];
+
+ $worksheet->getPageSetup()
+ ->setOrientation($printSettings->orientation ?? PageSetup::ORIENTATION_DEFAULT)
+ ->setPageOrder($printSettings->printOrder === 'ltr' ? PageSetup::PAGEORDER_OVER_THEN_DOWN : PageSetup::PAGEORDER_DOWN_THEN_OVER)
+ ->setScale((int) trim($printSettings->scale, '%'))
+ ->setHorizontalCentered($printSettings->horizontalCentered)
+ ->setVerticalCentered($printSettings->verticalCentered);
+
+ $worksheet->getPageMargins()
+ ->setLeft($printSettings->marginLeft)
+ ->setRight($printSettings->marginRight)
+ ->setTop($printSettings->marginTop)
+ ->setBottom($printSettings->marginBottom)
+ ->setHeader($printSettings->marginHeader)
+ ->setFooter($printSettings->marginFooter);
+ }
+}
diff --git a/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Ods/Properties.php b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Ods/Properties.php new file mode 100644 index 0000000..b68dcfc --- /dev/null +++ b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Ods/Properties.php @@ -0,0 +1,132 @@ +<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader\Ods;
+
+use PhpOffice\PhpSpreadsheet\Document\Properties as DocumentProperties;
+use PhpOffice\PhpSpreadsheet\Spreadsheet;
+use SimpleXMLElement;
+
+class Properties
+{
+ private $spreadsheet;
+
+ public function __construct(Spreadsheet $spreadsheet)
+ {
+ $this->spreadsheet = $spreadsheet;
+ }
+
+ public function load(SimpleXMLElement $xml, $namespacesMeta): void
+ {
+ $docProps = $this->spreadsheet->getProperties();
+ $officeProperty = $xml->children($namespacesMeta['office']);
+ foreach ($officeProperty as $officePropertyData) {
+ // @var \SimpleXMLElement $officePropertyData
+ if (isset($namespacesMeta['dc'])) {
+ $officePropertiesDC = $officePropertyData->children($namespacesMeta['dc']);
+ $this->setCoreProperties($docProps, $officePropertiesDC);
+ }
+
+ $officePropertyMeta = (object) [];
+ if (isset($namespacesMeta['dc'])) {
+ $officePropertyMeta = $officePropertyData->children($namespacesMeta['meta']);
+ }
+ foreach ($officePropertyMeta as $propertyName => $propertyValue) {
+ $this->setMetaProperties($namespacesMeta, $propertyValue, $propertyName, $docProps);
+ }
+ }
+ }
+
+ private function setCoreProperties(DocumentProperties $docProps, SimpleXMLElement $officePropertyDC): void
+ {
+ foreach ($officePropertyDC as $propertyName => $propertyValue) {
+ $propertyValue = (string) $propertyValue;
+ switch ($propertyName) {
+ case 'title':
+ $docProps->setTitle($propertyValue);
+
+ break;
+ case 'subject':
+ $docProps->setSubject($propertyValue);
+
+ break;
+ case 'creator':
+ $docProps->setCreator($propertyValue);
+ $docProps->setLastModifiedBy($propertyValue);
+
+ break;
+ case 'date':
+ $creationDate = strtotime($propertyValue);
+ $docProps->setCreated($creationDate);
+ $docProps->setModified($creationDate);
+
+ break;
+ case 'description':
+ $docProps->setDescription($propertyValue);
+
+ break;
+ }
+ }
+ }
+
+ private function setMetaProperties(
+ $namespacesMeta,
+ SimpleXMLElement $propertyValue,
+ $propertyName,
+ DocumentProperties $docProps
+ ): void {
+ $propertyValueAttributes = $propertyValue->attributes($namespacesMeta['meta']);
+ $propertyValue = (string) $propertyValue;
+ switch ($propertyName) {
+ case 'initial-creator':
+ $docProps->setCreator($propertyValue);
+
+ break;
+ case 'keyword':
+ $docProps->setKeywords($propertyValue);
+
+ break;
+ case 'creation-date':
+ $creationDate = strtotime($propertyValue);
+ $docProps->setCreated($creationDate);
+
+ break;
+ case 'user-defined':
+ $this->setUserDefinedProperty($propertyValueAttributes, $propertyValue, $docProps);
+
+ break;
+ }
+ }
+
+ private function setUserDefinedProperty($propertyValueAttributes, $propertyValue, DocumentProperties $docProps): void
+ {
+ $propertyValueName = '';
+ $propertyValueType = DocumentProperties::PROPERTY_TYPE_STRING;
+ foreach ($propertyValueAttributes as $key => $value) {
+ if ($key == 'name') {
+ $propertyValueName = (string) $value;
+ } elseif ($key == 'value-type') {
+ switch ($value) {
+ case 'date':
+ $propertyValue = DocumentProperties::convertProperty($propertyValue, 'date');
+ $propertyValueType = DocumentProperties::PROPERTY_TYPE_DATE;
+
+ break;
+ case 'boolean':
+ $propertyValue = DocumentProperties::convertProperty($propertyValue, 'bool');
+ $propertyValueType = DocumentProperties::PROPERTY_TYPE_BOOLEAN;
+
+ break;
+ case 'float':
+ $propertyValue = DocumentProperties::convertProperty($propertyValue, 'r4');
+ $propertyValueType = DocumentProperties::PROPERTY_TYPE_FLOAT;
+
+ break;
+ default:
+ $propertyValueType = DocumentProperties::PROPERTY_TYPE_STRING;
+ }
+ }
+ }
+
+ $docProps->setCustomProperty($propertyValueName, $propertyValue, $propertyValueType);
+ }
+}
diff --git a/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Security/XmlScanner.php b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Security/XmlScanner.php new file mode 100644 index 0000000..dca6792 --- /dev/null +++ b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Security/XmlScanner.php @@ -0,0 +1,150 @@ +<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader\Security;
+
+use PhpOffice\PhpSpreadsheet\Reader;
+use PhpOffice\PhpSpreadsheet\Settings;
+
+class XmlScanner
+{
+ /**
+ * String used to identify risky xml elements.
+ *
+ * @var string
+ */
+ private $pattern;
+
+ private $callback;
+
+ private static $libxmlDisableEntityLoaderValue;
+
+ public function __construct($pattern = '<!DOCTYPE')
+ {
+ $this->pattern = $pattern;
+
+ $this->disableEntityLoaderCheck();
+
+ // A fatal error will bypass the destructor, so we register a shutdown here
+ register_shutdown_function([__CLASS__, 'shutdown']);
+ }
+
+ public static function getInstance(Reader\IReader $reader)
+ {
+ switch (true) {
+ case $reader instanceof Reader\Html:
+ return new self('<!ENTITY');
+ case $reader instanceof Reader\Xlsx:
+ case $reader instanceof Reader\Xml:
+ case $reader instanceof Reader\Ods:
+ case $reader instanceof Reader\Gnumeric:
+ return new self('<!DOCTYPE');
+ default:
+ return new self('<!DOCTYPE');
+ }
+ }
+
+ public static function threadSafeLibxmlDisableEntityLoaderAvailability()
+ {
+ if (PHP_MAJOR_VERSION == 7) {
+ switch (PHP_MINOR_VERSION) {
+ case 2:
+ return PHP_RELEASE_VERSION >= 1;
+ case 1:
+ return PHP_RELEASE_VERSION >= 13;
+ case 0:
+ return PHP_RELEASE_VERSION >= 27;
+ }
+
+ return true;
+ }
+
+ return false;
+ }
+
+ private function disableEntityLoaderCheck(): void
+ {
+ if (Settings::getLibXmlDisableEntityLoader() && \PHP_VERSION_ID < 80000) {
+ $libxmlDisableEntityLoaderValue = libxml_disable_entity_loader(true);
+
+ if (self::$libxmlDisableEntityLoaderValue === null) {
+ self::$libxmlDisableEntityLoaderValue = $libxmlDisableEntityLoaderValue;
+ }
+ }
+ }
+
+ public static function shutdown(): void
+ {
+ if (self::$libxmlDisableEntityLoaderValue !== null && \PHP_VERSION_ID < 80000) {
+ libxml_disable_entity_loader(self::$libxmlDisableEntityLoaderValue);
+ self::$libxmlDisableEntityLoaderValue = null;
+ }
+ }
+
+ public function __destruct()
+ {
+ self::shutdown();
+ }
+
+ public function setAdditionalCallback(callable $callback): void
+ {
+ $this->callback = $callback;
+ }
+
+ private function toUtf8($xml)
+ {
+ $pattern = '/encoding="(.*?)"/';
+ $result = preg_match($pattern, $xml, $matches);
+ $charset = strtoupper($result ? $matches[1] : 'UTF-8');
+
+ if ($charset !== 'UTF-8') {
+ $xml = mb_convert_encoding($xml, 'UTF-8', $charset);
+
+ $result = preg_match($pattern, $xml, $matches);
+ $charset = strtoupper($result ? $matches[1] : 'UTF-8');
+ if ($charset !== 'UTF-8') {
+ throw new Reader\Exception('Suspicious Double-encoded XML, spreadsheet file load() aborted to prevent XXE/XEE attacks');
+ }
+ }
+
+ return $xml;
+ }
+
+ /**
+ * Scan the XML for use of <!ENTITY to prevent XXE/XEE attacks.
+ *
+ * @param mixed $xml
+ *
+ * @return string
+ */
+ public function scan($xml)
+ {
+ $this->disableEntityLoaderCheck();
+
+ $xml = $this->toUtf8($xml);
+
+ // Don't rely purely on libxml_disable_entity_loader()
+ $pattern = '/\\0?' . implode('\\0?', str_split($this->pattern)) . '\\0?/';
+
+ if (preg_match($pattern, $xml)) {
+ throw new Reader\Exception('Detected use of ENTITY in XML, spreadsheet file load() aborted to prevent XXE/XEE attacks');
+ }
+
+ if ($this->callback !== null && is_callable($this->callback)) {
+ $xml = call_user_func($this->callback, $xml);
+ }
+
+ return $xml;
+ }
+
+ /**
+ * Scan theXML for use of <!ENTITY to prevent XXE/XEE attacks.
+ *
+ * @param string $filestream
+ *
+ * @return string
+ */
+ public function scanFile($filestream)
+ {
+ return $this->scan(file_get_contents($filestream));
+ }
+}
diff --git a/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Slk.php b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Slk.php new file mode 100644 index 0000000..675777c --- /dev/null +++ b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Slk.php @@ -0,0 +1,590 @@ +<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader;
+
+use InvalidArgumentException;
+use PhpOffice\PhpSpreadsheet\Calculation\Calculation;
+use PhpOffice\PhpSpreadsheet\Cell\Coordinate;
+use PhpOffice\PhpSpreadsheet\Reader\Exception as ReaderException;
+use PhpOffice\PhpSpreadsheet\Shared\StringHelper;
+use PhpOffice\PhpSpreadsheet\Spreadsheet;
+use PhpOffice\PhpSpreadsheet\Style\Border;
+
+class Slk extends BaseReader
+{
+ /**
+ * Input encoding.
+ *
+ * @var string
+ */
+ private $inputEncoding = 'ANSI';
+
+ /**
+ * Sheet index to read.
+ *
+ * @var int
+ */
+ private $sheetIndex = 0;
+
+ /**
+ * Formats.
+ *
+ * @var array
+ */
+ private $formats = [];
+
+ /**
+ * Format Count.
+ *
+ * @var int
+ */
+ private $format = 0;
+
+ /**
+ * Fonts.
+ *
+ * @var array
+ */
+ private $fonts = [];
+
+ /**
+ * Font Count.
+ *
+ * @var int
+ */
+ private $fontcount = 0;
+
+ /**
+ * Create a new SYLK Reader instance.
+ */
+ public function __construct()
+ {
+ parent::__construct();
+ }
+
+ /**
+ * Validate that the current file is a SYLK file.
+ *
+ * @param string $pFilename
+ *
+ * @return bool
+ */
+ public function canRead($pFilename)
+ {
+ try {
+ $this->openFile($pFilename);
+ } catch (InvalidArgumentException $e) {
+ return false;
+ }
+
+ // Read sample data (first 2 KB will do)
+ $data = fread($this->fileHandle, 2048);
+
+ // Count delimiters in file
+ $delimiterCount = substr_count($data, ';');
+ $hasDelimiter = $delimiterCount > 0;
+
+ // Analyze first line looking for ID; signature
+ $lines = explode("\n", $data);
+ $hasId = substr($lines[0], 0, 4) === 'ID;P';
+
+ fclose($this->fileHandle);
+
+ return $hasDelimiter && $hasId;
+ }
+
+ private function canReadOrBust(string $pFilename): void
+ {
+ if (!$this->canRead($pFilename)) {
+ throw new ReaderException($pFilename . ' is an Invalid SYLK file.');
+ }
+ $this->openFile($pFilename);
+ }
+
+ /**
+ * Set input encoding.
+ *
+ * @deprecated no use is made of this property
+ *
+ * @param string $pValue Input encoding, eg: 'ANSI'
+ *
+ * @return $this
+ *
+ * @codeCoverageIgnore
+ */
+ public function setInputEncoding($pValue)
+ {
+ $this->inputEncoding = $pValue;
+
+ return $this;
+ }
+
+ /**
+ * Get input encoding.
+ *
+ * @deprecated no use is made of this property
+ *
+ * @return string
+ *
+ * @codeCoverageIgnore
+ */
+ public function getInputEncoding()
+ {
+ return $this->inputEncoding;
+ }
+
+ /**
+ * Return worksheet info (Name, Last Column Letter, Last Column Index, Total Rows, Total Columns).
+ *
+ * @param string $pFilename
+ *
+ * @return array
+ */
+ public function listWorksheetInfo($pFilename)
+ {
+ // Open file
+ $this->canReadOrBust($pFilename);
+ $fileHandle = $this->fileHandle;
+ rewind($fileHandle);
+
+ $worksheetInfo = [];
+ $worksheetInfo[0]['worksheetName'] = basename($pFilename, '.slk');
+
+ // loop through one row (line) at a time in the file
+ $rowIndex = 0;
+ $columnIndex = 0;
+ while (($rowData = fgets($fileHandle)) !== false) {
+ $columnIndex = 0;
+
+ // convert SYLK encoded $rowData to UTF-8
+ $rowData = StringHelper::SYLKtoUTF8($rowData);
+
+ // explode each row at semicolons while taking into account that literal semicolon (;)
+ // is escaped like this (;;)
+ $rowData = explode("\t", str_replace('¤', ';', str_replace(';', "\t", str_replace(';;', '¤', rtrim($rowData)))));
+
+ $dataType = array_shift($rowData);
+ if ($dataType == 'B') {
+ foreach ($rowData as $rowDatum) {
+ switch ($rowDatum[0]) {
+ case 'X':
+ $columnIndex = substr($rowDatum, 1) - 1;
+
+ break;
+ case 'Y':
+ $rowIndex = substr($rowDatum, 1);
+
+ break;
+ }
+ }
+
+ break;
+ }
+ }
+
+ $worksheetInfo[0]['lastColumnIndex'] = $columnIndex;
+ $worksheetInfo[0]['totalRows'] = $rowIndex;
+ $worksheetInfo[0]['lastColumnLetter'] = Coordinate::stringFromColumnIndex($worksheetInfo[0]['lastColumnIndex'] + 1);
+ $worksheetInfo[0]['totalColumns'] = $worksheetInfo[0]['lastColumnIndex'] + 1;
+
+ // Close file
+ fclose($fileHandle);
+
+ return $worksheetInfo;
+ }
+
+ /**
+ * Loads PhpSpreadsheet from file.
+ *
+ * @param string $pFilename
+ *
+ * @return Spreadsheet
+ */
+ public function load($pFilename)
+ {
+ // Create new Spreadsheet
+ $spreadsheet = new Spreadsheet();
+
+ // Load into this instance
+ return $this->loadIntoExisting($pFilename, $spreadsheet);
+ }
+
+ private $colorArray = [
+ 'FF00FFFF', // 0 - cyan
+ 'FF000000', // 1 - black
+ 'FFFFFFFF', // 2 - white
+ 'FFFF0000', // 3 - red
+ 'FF00FF00', // 4 - green
+ 'FF0000FF', // 5 - blue
+ 'FFFFFF00', // 6 - yellow
+ 'FFFF00FF', // 7 - magenta
+ ];
+
+ private $fontStyleMappings = [
+ 'B' => 'bold',
+ 'I' => 'italic',
+ 'U' => 'underline',
+ ];
+
+ private function processFormula(string $rowDatum, bool &$hasCalculatedValue, string &$cellDataFormula, string $row, string $column): void
+ {
+ $cellDataFormula = '=' . substr($rowDatum, 1);
+ // Convert R1C1 style references to A1 style references (but only when not quoted)
+ $temp = explode('"', $cellDataFormula);
+ $key = false;
+ foreach ($temp as &$value) {
+ // Only count/replace in alternate array entries
+ if ($key = !$key) {
+ preg_match_all('/(R(\[?-?\d*\]?))(C(\[?-?\d*\]?))/', $value, $cellReferences, PREG_SET_ORDER + PREG_OFFSET_CAPTURE);
+ // Reverse the matches array, otherwise all our offsets will become incorrect if we modify our way
+ // through the formula from left to right. Reversing means that we work right to left.through
+ // the formula
+ $cellReferences = array_reverse($cellReferences);
+ // Loop through each R1C1 style reference in turn, converting it to its A1 style equivalent,
+ // then modify the formula to use that new reference
+ foreach ($cellReferences as $cellReference) {
+ $rowReference = $cellReference[2][0];
+ // Empty R reference is the current row
+ if ($rowReference == '') {
+ $rowReference = $row;
+ }
+ // Bracketed R references are relative to the current row
+ if ($rowReference[0] == '[') {
+ $rowReference = $row + trim($rowReference, '[]');
+ }
+ $columnReference = $cellReference[4][0];
+ // Empty C reference is the current column
+ if ($columnReference == '') {
+ $columnReference = $column;
+ }
+ // Bracketed C references are relative to the current column
+ if ($columnReference[0] == '[') {
+ $columnReference = $column + trim($columnReference, '[]');
+ }
+ $A1CellReference = Coordinate::stringFromColumnIndex($columnReference) . $rowReference;
+
+ $value = substr_replace($value, $A1CellReference, $cellReference[0][1], strlen($cellReference[0][0]));
+ }
+ }
+ }
+ unset($value);
+ // Then rebuild the formula string
+ $cellDataFormula = implode('"', $temp);
+ $hasCalculatedValue = true;
+ }
+
+ private function processCRecord(array $rowData, Spreadsheet &$spreadsheet, string &$row, string &$column): void
+ {
+ // Read cell value data
+ $hasCalculatedValue = false;
+ $cellDataFormula = $cellData = '';
+ foreach ($rowData as $rowDatum) {
+ switch ($rowDatum[0]) {
+ case 'C':
+ case 'X':
+ $column = substr($rowDatum, 1);
+
+ break;
+ case 'R':
+ case 'Y':
+ $row = substr($rowDatum, 1);
+
+ break;
+ case 'K':
+ $cellData = substr($rowDatum, 1);
+
+ break;
+ case 'E':
+ $this->processFormula($rowDatum, $hasCalculatedValue, $cellDataFormula, $row, $column);
+
+ break;
+ }
+ }
+ $columnLetter = Coordinate::stringFromColumnIndex((int) $column);
+ $cellData = Calculation::unwrapResult($cellData);
+
+ // Set cell value
+ $this->processCFinal($spreadsheet, $hasCalculatedValue, $cellDataFormula, $cellData, "$columnLetter$row");
+ }
+
+ private function processCFinal(Spreadsheet &$spreadsheet, bool $hasCalculatedValue, string $cellDataFormula, string $cellData, string $coordinate): void
+ {
+ // Set cell value
+ $spreadsheet->getActiveSheet()->getCell($coordinate)->setValue(($hasCalculatedValue) ? $cellDataFormula : $cellData);
+ if ($hasCalculatedValue) {
+ $cellData = Calculation::unwrapResult($cellData);
+ $spreadsheet->getActiveSheet()->getCell($coordinate)->setCalculatedValue($cellData);
+ }
+ }
+
+ private function processFRecord(array $rowData, Spreadsheet &$spreadsheet, string &$row, string &$column): void
+ {
+ // Read cell formatting
+ $formatStyle = $columnWidth = '';
+ $startCol = $endCol = '';
+ $fontStyle = '';
+ $styleData = [];
+ foreach ($rowData as $rowDatum) {
+ switch ($rowDatum[0]) {
+ case 'C':
+ case 'X':
+ $column = substr($rowDatum, 1);
+
+ break;
+ case 'R':
+ case 'Y':
+ $row = substr($rowDatum, 1);
+
+ break;
+ case 'P':
+ $formatStyle = $rowDatum;
+
+ break;
+ case 'W':
+ [$startCol, $endCol, $columnWidth] = explode(' ', substr($rowDatum, 1));
+
+ break;
+ case 'S':
+ $this->styleSettings($rowDatum, $styleData, $fontStyle);
+
+ break;
+ }
+ }
+ $this->addFormats($spreadsheet, $formatStyle, $row, $column);
+ $this->addFonts($spreadsheet, $fontStyle, $row, $column);
+ $this->addStyle($spreadsheet, $styleData, $row, $column);
+ $this->addWidth($spreadsheet, $columnWidth, $startCol, $endCol);
+ }
+
+ private $styleSettingsFont = ['D' => 'bold', 'I' => 'italic'];
+
+ private $styleSettingsBorder = [
+ 'B' => 'bottom',
+ 'L' => 'left',
+ 'R' => 'right',
+ 'T' => 'top',
+ ];
+
+ private function styleSettings(string $rowDatum, array &$styleData, string &$fontStyle): void
+ {
+ $styleSettings = substr($rowDatum, 1);
+ $iMax = strlen($styleSettings);
+ for ($i = 0; $i < $iMax; ++$i) {
+ $char = $styleSettings[$i];
+ if (array_key_exists($char, $this->styleSettingsFont)) {
+ $styleData['font'][$this->styleSettingsFont[$char]] = true;
+ } elseif (array_key_exists($char, $this->styleSettingsBorder)) {
+ $styleData['borders'][$this->styleSettingsBorder[$char]]['borderStyle'] = Border::BORDER_THIN;
+ } elseif ($char == 'S') {
+ $styleData['fill']['fillType'] = \PhpOffice\PhpSpreadsheet\Style\Fill::FILL_PATTERN_GRAY125;
+ } elseif ($char == 'M') {
+ if (preg_match('/M([1-9]\\d*)/', $styleSettings, $matches)) {
+ $fontStyle = $matches[1];
+ }
+ }
+ }
+ }
+
+ private function addFormats(Spreadsheet &$spreadsheet, string $formatStyle, string $row, string $column): void
+ {
+ if ($formatStyle && $column > '' && $row > '') {
+ $columnLetter = Coordinate::stringFromColumnIndex((int) $column);
+ if (isset($this->formats[$formatStyle])) {
+ $spreadsheet->getActiveSheet()->getStyle($columnLetter . $row)->applyFromArray($this->formats[$formatStyle]);
+ }
+ }
+ }
+
+ private function addFonts(Spreadsheet &$spreadsheet, string $fontStyle, string $row, string $column): void
+ {
+ if ($fontStyle && $column > '' && $row > '') {
+ $columnLetter = Coordinate::stringFromColumnIndex((int) $column);
+ if (isset($this->fonts[$fontStyle])) {
+ $spreadsheet->getActiveSheet()->getStyle($columnLetter . $row)->applyFromArray($this->fonts[$fontStyle]);
+ }
+ }
+ }
+
+ private function addStyle(Spreadsheet &$spreadsheet, array $styleData, string $row, string $column): void
+ {
+ if ((!empty($styleData)) && $column > '' && $row > '') {
+ $columnLetter = Coordinate::stringFromColumnIndex($column);
+ $spreadsheet->getActiveSheet()->getStyle($columnLetter . $row)->applyFromArray($styleData);
+ }
+ }
+
+ private function addWidth(Spreadsheet $spreadsheet, string $columnWidth, string $startCol, string $endCol): void
+ {
+ if ($columnWidth > '') {
+ if ($startCol == $endCol) {
+ $startCol = Coordinate::stringFromColumnIndex((int) $startCol);
+ $spreadsheet->getActiveSheet()->getColumnDimension($startCol)->setWidth($columnWidth);
+ } else {
+ $startCol = Coordinate::stringFromColumnIndex($startCol);
+ $endCol = Coordinate::stringFromColumnIndex($endCol);
+ $spreadsheet->getActiveSheet()->getColumnDimension($startCol)->setWidth((float) $columnWidth);
+ do {
+ $spreadsheet->getActiveSheet()->getColumnDimension(++$startCol)->setWidth($columnWidth);
+ } while ($startCol != $endCol);
+ }
+ }
+ }
+
+ private function processPRecord(array $rowData, Spreadsheet &$spreadsheet): void
+ {
+ // Read shared styles
+ $formatArray = [];
+ $fromFormats = ['\-', '\ '];
+ $toFormats = ['-', ' '];
+ foreach ($rowData as $rowDatum) {
+ switch ($rowDatum[0]) {
+ case 'P':
+ $formatArray['numberFormat']['formatCode'] = str_replace($fromFormats, $toFormats, substr($rowDatum, 1));
+
+ break;
+ case 'E':
+ case 'F':
+ $formatArray['font']['name'] = substr($rowDatum, 1);
+
+ break;
+ case 'M':
+ $formatArray['font']['size'] = substr($rowDatum, 1) / 20;
+
+ break;
+ case 'L':
+ $this->processPColors($rowDatum, $formatArray);
+
+ break;
+ case 'S':
+ $this->processPFontStyles($rowDatum, $formatArray);
+
+ break;
+ }
+ }
+ $this->processPFinal($spreadsheet, $formatArray);
+ }
+
+ private function processPColors(string $rowDatum, array &$formatArray): void
+ {
+ if (preg_match('/L([1-9]\\d*)/', $rowDatum, $matches)) {
+ $fontColor = $matches[1] % 8;
+ $formatArray['font']['color']['argb'] = $this->colorArray[$fontColor];
+ }
+ }
+
+ private function processPFontStyles(string $rowDatum, array &$formatArray): void
+ {
+ $styleSettings = substr($rowDatum, 1);
+ $iMax = strlen($styleSettings);
+ for ($i = 0; $i < $iMax; ++$i) {
+ if (array_key_exists($styleSettings[$i], $this->fontStyleMappings)) {
+ $formatArray['font'][$this->fontStyleMappings[$styleSettings[$i]]] = true;
+ }
+ }
+ }
+
+ private function processPFinal(Spreadsheet &$spreadsheet, array $formatArray): void
+ {
+ if (array_key_exists('numberFormat', $formatArray)) {
+ $this->formats['P' . $this->format] = $formatArray;
+ ++$this->format;
+ } elseif (array_key_exists('font', $formatArray)) {
+ ++$this->fontcount;
+ $this->fonts[$this->fontcount] = $formatArray;
+ if ($this->fontcount === 1) {
+ $spreadsheet->getDefaultStyle()->applyFromArray($formatArray);
+ }
+ }
+ }
+
+ /**
+ * Loads PhpSpreadsheet from file into PhpSpreadsheet instance.
+ *
+ * @param string $pFilename
+ *
+ * @return Spreadsheet
+ */
+ public function loadIntoExisting($pFilename, Spreadsheet $spreadsheet)
+ {
+ // Open file
+ $this->canReadOrBust($pFilename);
+ $fileHandle = $this->fileHandle;
+ rewind($fileHandle);
+
+ // Create new Worksheets
+ while ($spreadsheet->getSheetCount() <= $this->sheetIndex) {
+ $spreadsheet->createSheet();
+ }
+ $spreadsheet->setActiveSheetIndex($this->sheetIndex);
+ $spreadsheet->getActiveSheet()->setTitle(basename($pFilename, '.slk'));
+
+ // Loop through file
+ $column = $row = '';
+
+ // loop through one row (line) at a time in the file
+ while (($rowDataTxt = fgets($fileHandle)) !== false) {
+ // convert SYLK encoded $rowData to UTF-8
+ $rowDataTxt = StringHelper::SYLKtoUTF8($rowDataTxt);
+
+ // explode each row at semicolons while taking into account that literal semicolon (;)
+ // is escaped like this (;;)
+ $rowData = explode("\t", str_replace('¤', ';', str_replace(';', "\t", str_replace(';;', '¤', rtrim($rowDataTxt)))));
+
+ $dataType = array_shift($rowData);
+ if ($dataType == 'P') {
+ // Read shared styles
+ $this->processPRecord($rowData, $spreadsheet);
+ } elseif ($dataType == 'C') {
+ // Read cell value data
+ $this->processCRecord($rowData, $spreadsheet, $row, $column);
+ } elseif ($dataType == 'F') {
+ // Read cell formatting
+ $this->processFRecord($rowData, $spreadsheet, $row, $column);
+ } else {
+ $this->columnRowFromRowData($rowData, $column, $row);
+ }
+ }
+
+ // Close file
+ fclose($fileHandle);
+
+ // Return
+ return $spreadsheet;
+ }
+
+ private function columnRowFromRowData(array $rowData, string &$column, string &$row): void
+ {
+ foreach ($rowData as $rowDatum) {
+ $char0 = $rowDatum[0];
+ if ($char0 === 'X' || $char0 == 'C') {
+ $column = substr($rowDatum, 1);
+ } elseif ($char0 === 'Y' || $char0 == 'R') {
+ $row = substr($rowDatum, 1);
+ }
+ }
+ }
+
+ /**
+ * Get sheet index.
+ *
+ * @return int
+ */
+ public function getSheetIndex()
+ {
+ return $this->sheetIndex;
+ }
+
+ /**
+ * Set sheet index.
+ *
+ * @param int $pValue Sheet index
+ *
+ * @return $this
+ */
+ public function setSheetIndex($pValue)
+ {
+ $this->sheetIndex = $pValue;
+
+ return $this;
+ }
+}
diff --git a/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xls.php b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xls.php new file mode 100644 index 0000000..2aeb83d --- /dev/null +++ b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xls.php @@ -0,0 +1,7954 @@ +<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader;
+
+use PhpOffice\PhpSpreadsheet\Cell\Coordinate;
+use PhpOffice\PhpSpreadsheet\Cell\DataType;
+use PhpOffice\PhpSpreadsheet\Cell\DataValidation;
+use PhpOffice\PhpSpreadsheet\Exception as PhpSpreadsheetException;
+use PhpOffice\PhpSpreadsheet\NamedRange;
+use PhpOffice\PhpSpreadsheet\RichText\RichText;
+use PhpOffice\PhpSpreadsheet\Shared\CodePage;
+use PhpOffice\PhpSpreadsheet\Shared\Date;
+use PhpOffice\PhpSpreadsheet\Shared\Escher;
+use PhpOffice\PhpSpreadsheet\Shared\Escher\DggContainer\BstoreContainer\BSE;
+use PhpOffice\PhpSpreadsheet\Shared\File;
+use PhpOffice\PhpSpreadsheet\Shared\OLE;
+use PhpOffice\PhpSpreadsheet\Shared\OLERead;
+use PhpOffice\PhpSpreadsheet\Shared\StringHelper;
+use PhpOffice\PhpSpreadsheet\Spreadsheet;
+use PhpOffice\PhpSpreadsheet\Style\Alignment;
+use PhpOffice\PhpSpreadsheet\Style\Borders;
+use PhpOffice\PhpSpreadsheet\Style\Font;
+use PhpOffice\PhpSpreadsheet\Style\NumberFormat;
+use PhpOffice\PhpSpreadsheet\Style\Protection;
+use PhpOffice\PhpSpreadsheet\Style\Style;
+use PhpOffice\PhpSpreadsheet\Worksheet\MemoryDrawing;
+use PhpOffice\PhpSpreadsheet\Worksheet\PageSetup;
+use PhpOffice\PhpSpreadsheet\Worksheet\SheetView;
+use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
+
+// Original file header of ParseXL (used as the base for this class):
+// --------------------------------------------------------------------------------
+// Adapted from Excel_Spreadsheet_Reader developed by users bizon153,
+// trex005, and mmp11 (SourceForge.net)
+// https://sourceforge.net/projects/phpexcelreader/
+// Primary changes made by canyoncasa (dvc) for ParseXL 1.00 ...
+// Modelled moreso after Perl Excel Parse/Write modules
+// Added Parse_Excel_Spreadsheet object
+// Reads a whole worksheet or tab as row,column array or as
+// associated hash of indexed rows and named column fields
+// Added variables for worksheet (tab) indexes and names
+// Added an object call for loading individual woorksheets
+// Changed default indexing defaults to 0 based arrays
+// Fixed date/time and percent formats
+// Includes patches found at SourceForge...
+// unicode patch by nobody
+// unpack("d") machine depedency patch by matchy
+// boundsheet utf16 patch by bjaenichen
+// Renamed functions for shorter names
+// General code cleanup and rigor, including <80 column width
+// Included a testcase Excel file and PHP example calls
+// Code works for PHP 5.x
+
+// Primary changes made by canyoncasa (dvc) for ParseXL 1.10 ...
+// http://sourceforge.net/tracker/index.php?func=detail&aid=1466964&group_id=99160&atid=623334
+// Decoding of formula conditions, results, and tokens.
+// Support for user-defined named cells added as an array "namedcells"
+// Patch code for user-defined named cells supports single cells only.
+// NOTE: this patch only works for BIFF8 as BIFF5-7 use a different
+// external sheet reference structure
+class Xls extends BaseReader
+{
+ // ParseXL definitions
+ const XLS_BIFF8 = 0x0600;
+ const XLS_BIFF7 = 0x0500;
+ const XLS_WORKBOOKGLOBALS = 0x0005;
+ const XLS_WORKSHEET = 0x0010;
+
+ // record identifiers
+ const XLS_TYPE_FORMULA = 0x0006;
+ const XLS_TYPE_EOF = 0x000a;
+ const XLS_TYPE_PROTECT = 0x0012;
+ const XLS_TYPE_OBJECTPROTECT = 0x0063;
+ const XLS_TYPE_SCENPROTECT = 0x00dd;
+ const XLS_TYPE_PASSWORD = 0x0013;
+ const XLS_TYPE_HEADER = 0x0014;
+ const XLS_TYPE_FOOTER = 0x0015;
+ const XLS_TYPE_EXTERNSHEET = 0x0017;
+ const XLS_TYPE_DEFINEDNAME = 0x0018;
+ const XLS_TYPE_VERTICALPAGEBREAKS = 0x001a;
+ const XLS_TYPE_HORIZONTALPAGEBREAKS = 0x001b;
+ const XLS_TYPE_NOTE = 0x001c;
+ const XLS_TYPE_SELECTION = 0x001d;
+ const XLS_TYPE_DATEMODE = 0x0022;
+ const XLS_TYPE_EXTERNNAME = 0x0023;
+ const XLS_TYPE_LEFTMARGIN = 0x0026;
+ const XLS_TYPE_RIGHTMARGIN = 0x0027;
+ const XLS_TYPE_TOPMARGIN = 0x0028;
+ const XLS_TYPE_BOTTOMMARGIN = 0x0029;
+ const XLS_TYPE_PRINTGRIDLINES = 0x002b;
+ const XLS_TYPE_FILEPASS = 0x002f;
+ const XLS_TYPE_FONT = 0x0031;
+ const XLS_TYPE_CONTINUE = 0x003c;
+ const XLS_TYPE_PANE = 0x0041;
+ const XLS_TYPE_CODEPAGE = 0x0042;
+ const XLS_TYPE_DEFCOLWIDTH = 0x0055;
+ const XLS_TYPE_OBJ = 0x005d;
+ const XLS_TYPE_COLINFO = 0x007d;
+ const XLS_TYPE_IMDATA = 0x007f;
+ const XLS_TYPE_SHEETPR = 0x0081;
+ const XLS_TYPE_HCENTER = 0x0083;
+ const XLS_TYPE_VCENTER = 0x0084;
+ const XLS_TYPE_SHEET = 0x0085;
+ const XLS_TYPE_PALETTE = 0x0092;
+ const XLS_TYPE_SCL = 0x00a0;
+ const XLS_TYPE_PAGESETUP = 0x00a1;
+ const XLS_TYPE_MULRK = 0x00bd;
+ const XLS_TYPE_MULBLANK = 0x00be;
+ const XLS_TYPE_DBCELL = 0x00d7;
+ const XLS_TYPE_XF = 0x00e0;
+ const XLS_TYPE_MERGEDCELLS = 0x00e5;
+ const XLS_TYPE_MSODRAWINGGROUP = 0x00eb;
+ const XLS_TYPE_MSODRAWING = 0x00ec;
+ const XLS_TYPE_SST = 0x00fc;
+ const XLS_TYPE_LABELSST = 0x00fd;
+ const XLS_TYPE_EXTSST = 0x00ff;
+ const XLS_TYPE_EXTERNALBOOK = 0x01ae;
+ const XLS_TYPE_DATAVALIDATIONS = 0x01b2;
+ const XLS_TYPE_TXO = 0x01b6;
+ const XLS_TYPE_HYPERLINK = 0x01b8;
+ const XLS_TYPE_DATAVALIDATION = 0x01be;
+ const XLS_TYPE_DIMENSION = 0x0200;
+ const XLS_TYPE_BLANK = 0x0201;
+ const XLS_TYPE_NUMBER = 0x0203;
+ const XLS_TYPE_LABEL = 0x0204;
+ const XLS_TYPE_BOOLERR = 0x0205;
+ const XLS_TYPE_STRING = 0x0207;
+ const XLS_TYPE_ROW = 0x0208;
+ const XLS_TYPE_INDEX = 0x020b;
+ const XLS_TYPE_ARRAY = 0x0221;
+ const XLS_TYPE_DEFAULTROWHEIGHT = 0x0225;
+ const XLS_TYPE_WINDOW2 = 0x023e;
+ const XLS_TYPE_RK = 0x027e;
+ const XLS_TYPE_STYLE = 0x0293;
+ const XLS_TYPE_FORMAT = 0x041e;
+ const XLS_TYPE_SHAREDFMLA = 0x04bc;
+ const XLS_TYPE_BOF = 0x0809;
+ const XLS_TYPE_SHEETPROTECTION = 0x0867;
+ const XLS_TYPE_RANGEPROTECTION = 0x0868;
+ const XLS_TYPE_SHEETLAYOUT = 0x0862;
+ const XLS_TYPE_XFEXT = 0x087d;
+ const XLS_TYPE_PAGELAYOUTVIEW = 0x088b;
+ const XLS_TYPE_UNKNOWN = 0xffff;
+
+ // Encryption type
+ const MS_BIFF_CRYPTO_NONE = 0;
+ const MS_BIFF_CRYPTO_XOR = 1;
+ const MS_BIFF_CRYPTO_RC4 = 2;
+
+ // Size of stream blocks when using RC4 encryption
+ const REKEY_BLOCK = 0x400;
+
+ /**
+ * Summary Information stream data.
+ *
+ * @var string
+ */
+ private $summaryInformation;
+
+ /**
+ * Extended Summary Information stream data.
+ *
+ * @var string
+ */
+ private $documentSummaryInformation;
+
+ /**
+ * Workbook stream data. (Includes workbook globals substream as well as sheet substreams).
+ *
+ * @var string
+ */
+ private $data;
+
+ /**
+ * Size in bytes of $this->data.
+ *
+ * @var int
+ */
+ private $dataSize;
+
+ /**
+ * Current position in stream.
+ *
+ * @var int
+ */
+ private $pos;
+
+ /**
+ * Workbook to be returned by the reader.
+ *
+ * @var Spreadsheet
+ */
+ private $spreadsheet;
+
+ /**
+ * Worksheet that is currently being built by the reader.
+ *
+ * @var Worksheet
+ */
+ private $phpSheet;
+
+ /**
+ * BIFF version.
+ *
+ * @var int
+ */
+ private $version;
+
+ /**
+ * Codepage set in the Excel file being read. Only important for BIFF5 (Excel 5.0 - Excel 95)
+ * For BIFF8 (Excel 97 - Excel 2003) this will always have the value 'UTF-16LE'.
+ *
+ * @var string
+ */
+ private $codepage;
+
+ /**
+ * Shared formats.
+ *
+ * @var array
+ */
+ private $formats;
+
+ /**
+ * Shared fonts.
+ *
+ * @var array
+ */
+ private $objFonts;
+
+ /**
+ * Color palette.
+ *
+ * @var array
+ */
+ private $palette;
+
+ /**
+ * Worksheets.
+ *
+ * @var array
+ */
+ private $sheets;
+
+ /**
+ * External books.
+ *
+ * @var array
+ */
+ private $externalBooks;
+
+ /**
+ * REF structures. Only applies to BIFF8.
+ *
+ * @var array
+ */
+ private $ref;
+
+ /**
+ * External names.
+ *
+ * @var array
+ */
+ private $externalNames;
+
+ /**
+ * Defined names.
+ *
+ * @var array
+ */
+ private $definedname;
+
+ /**
+ * Shared strings. Only applies to BIFF8.
+ *
+ * @var array
+ */
+ private $sst;
+
+ /**
+ * Panes are frozen? (in sheet currently being read). See WINDOW2 record.
+ *
+ * @var bool
+ */
+ private $frozen;
+
+ /**
+ * Fit printout to number of pages? (in sheet currently being read). See SHEETPR record.
+ *
+ * @var bool
+ */
+ private $isFitToPages;
+
+ /**
+ * Objects. One OBJ record contributes with one entry.
+ *
+ * @var array
+ */
+ private $objs;
+
+ /**
+ * Text Objects. One TXO record corresponds with one entry.
+ *
+ * @var array
+ */
+ private $textObjects;
+
+ /**
+ * Cell Annotations (BIFF8).
+ *
+ * @var array
+ */
+ private $cellNotes;
+
+ /**
+ * The combined MSODRAWINGGROUP data.
+ *
+ * @var string
+ */
+ private $drawingGroupData;
+
+ /**
+ * The combined MSODRAWING data (per sheet).
+ *
+ * @var string
+ */
+ private $drawingData;
+
+ /**
+ * Keep track of XF index.
+ *
+ * @var int
+ */
+ private $xfIndex;
+
+ /**
+ * Mapping of XF index (that is a cell XF) to final index in cellXf collection.
+ *
+ * @var array
+ */
+ private $mapCellXfIndex;
+
+ /**
+ * Mapping of XF index (that is a style XF) to final index in cellStyleXf collection.
+ *
+ * @var array
+ */
+ private $mapCellStyleXfIndex;
+
+ /**
+ * The shared formulas in a sheet. One SHAREDFMLA record contributes with one value.
+ *
+ * @var array
+ */
+ private $sharedFormulas;
+
+ /**
+ * The shared formula parts in a sheet. One FORMULA record contributes with one value if it
+ * refers to a shared formula.
+ *
+ * @var array
+ */
+ private $sharedFormulaParts;
+
+ /**
+ * The type of encryption in use.
+ *
+ * @var int
+ */
+ private $encryption = 0;
+
+ /**
+ * The position in the stream after which contents are encrypted.
+ *
+ * @var int
+ */
+ private $encryptionStartPos = false;
+
+ /**
+ * The current RC4 decryption object.
+ *
+ * @var Xls\RC4
+ */
+ private $rc4Key;
+
+ /**
+ * The position in the stream that the RC4 decryption object was left at.
+ *
+ * @var int
+ */
+ private $rc4Pos = 0;
+
+ /**
+ * The current MD5 context state.
+ *
+ * @var string
+ */
+ private $md5Ctxt;
+
+ /**
+ * @var int
+ */
+ private $textObjRef;
+
+ /**
+ * @var string
+ */
+ private $baseCell;
+
+ /**
+ * Create a new Xls Reader instance.
+ */
+ public function __construct()
+ {
+ parent::__construct();
+ }
+
+ /**
+ * Can the current IReader read the file?
+ *
+ * @param string $pFilename
+ *
+ * @return bool
+ */
+ public function canRead($pFilename)
+ {
+ File::assertFile($pFilename);
+
+ try {
+ // Use ParseXL for the hard work.
+ $ole = new OLERead();
+
+ // get excel data
+ $ole->read($pFilename);
+
+ return true;
+ } catch (PhpSpreadsheetException $e) {
+ return false;
+ }
+ }
+
+ public function setCodepage(string $codepage): void
+ {
+ if (!CodePage::validate($codepage)) {
+ throw new PhpSpreadsheetException('Unknown codepage: ' . $codepage);
+ }
+
+ $this->codepage = $codepage;
+ }
+
+ /**
+ * Reads names of the worksheets from a file, without parsing the whole file to a PhpSpreadsheet object.
+ *
+ * @param string $pFilename
+ *
+ * @return array
+ */
+ public function listWorksheetNames($pFilename)
+ {
+ File::assertFile($pFilename);
+
+ $worksheetNames = [];
+
+ // Read the OLE file
+ $this->loadOLE($pFilename);
+
+ // total byte size of Excel data (workbook global substream + sheet substreams)
+ $this->dataSize = strlen($this->data);
+
+ $this->pos = 0;
+ $this->sheets = [];
+
+ // Parse Workbook Global Substream
+ while ($this->pos < $this->dataSize) {
+ $code = self::getUInt2d($this->data, $this->pos);
+
+ switch ($code) {
+ case self::XLS_TYPE_BOF:
+ $this->readBof();
+
+ break;
+ case self::XLS_TYPE_SHEET:
+ $this->readSheet();
+
+ break;
+ case self::XLS_TYPE_EOF:
+ $this->readDefault();
+
+ break 2;
+ default:
+ $this->readDefault();
+
+ break;
+ }
+ }
+
+ foreach ($this->sheets as $sheet) {
+ if ($sheet['sheetType'] != 0x00) {
+ // 0x00: Worksheet, 0x02: Chart, 0x06: Visual Basic module
+ continue;
+ }
+
+ $worksheetNames[] = $sheet['name'];
+ }
+
+ return $worksheetNames;
+ }
+
+ /**
+ * Return worksheet info (Name, Last Column Letter, Last Column Index, Total Rows, Total Columns).
+ *
+ * @param string $pFilename
+ *
+ * @return array
+ */
+ public function listWorksheetInfo($pFilename)
+ {
+ File::assertFile($pFilename);
+
+ $worksheetInfo = [];
+
+ // Read the OLE file
+ $this->loadOLE($pFilename);
+
+ // total byte size of Excel data (workbook global substream + sheet substreams)
+ $this->dataSize = strlen($this->data);
+
+ // initialize
+ $this->pos = 0;
+ $this->sheets = [];
+
+ // Parse Workbook Global Substream
+ while ($this->pos < $this->dataSize) {
+ $code = self::getUInt2d($this->data, $this->pos);
+
+ switch ($code) {
+ case self::XLS_TYPE_BOF:
+ $this->readBof();
+
+ break;
+ case self::XLS_TYPE_SHEET:
+ $this->readSheet();
+
+ break;
+ case self::XLS_TYPE_EOF:
+ $this->readDefault();
+
+ break 2;
+ default:
+ $this->readDefault();
+
+ break;
+ }
+ }
+
+ // Parse the individual sheets
+ foreach ($this->sheets as $sheet) {
+ if ($sheet['sheetType'] != 0x00) {
+ // 0x00: Worksheet
+ // 0x02: Chart
+ // 0x06: Visual Basic module
+ continue;
+ }
+
+ $tmpInfo = [];
+ $tmpInfo['worksheetName'] = $sheet['name'];
+ $tmpInfo['lastColumnLetter'] = 'A';
+ $tmpInfo['lastColumnIndex'] = 0;
+ $tmpInfo['totalRows'] = 0;
+ $tmpInfo['totalColumns'] = 0;
+
+ $this->pos = $sheet['offset'];
+
+ while ($this->pos <= $this->dataSize - 4) {
+ $code = self::getUInt2d($this->data, $this->pos);
+
+ switch ($code) {
+ case self::XLS_TYPE_RK:
+ case self::XLS_TYPE_LABELSST:
+ case self::XLS_TYPE_NUMBER:
+ case self::XLS_TYPE_FORMULA:
+ case self::XLS_TYPE_BOOLERR:
+ case self::XLS_TYPE_LABEL:
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ $rowIndex = self::getUInt2d($recordData, 0) + 1;
+ $columnIndex = self::getUInt2d($recordData, 2);
+
+ $tmpInfo['totalRows'] = max($tmpInfo['totalRows'], $rowIndex);
+ $tmpInfo['lastColumnIndex'] = max($tmpInfo['lastColumnIndex'], $columnIndex);
+
+ break;
+ case self::XLS_TYPE_BOF:
+ $this->readBof();
+
+ break;
+ case self::XLS_TYPE_EOF:
+ $this->readDefault();
+
+ break 2;
+ default:
+ $this->readDefault();
+
+ break;
+ }
+ }
+
+ $tmpInfo['lastColumnLetter'] = Coordinate::stringFromColumnIndex($tmpInfo['lastColumnIndex'] + 1);
+ $tmpInfo['totalColumns'] = $tmpInfo['lastColumnIndex'] + 1;
+
+ $worksheetInfo[] = $tmpInfo;
+ }
+
+ return $worksheetInfo;
+ }
+
+ /**
+ * Loads PhpSpreadsheet from file.
+ *
+ * @param string $pFilename
+ *
+ * @return Spreadsheet
+ */
+ public function load($pFilename)
+ {
+ // Read the OLE file
+ $this->loadOLE($pFilename);
+
+ // Initialisations
+ $this->spreadsheet = new Spreadsheet();
+ $this->spreadsheet->removeSheetByIndex(0); // remove 1st sheet
+ if (!$this->readDataOnly) {
+ $this->spreadsheet->removeCellStyleXfByIndex(0); // remove the default style
+ $this->spreadsheet->removeCellXfByIndex(0); // remove the default style
+ }
+
+ // Read the summary information stream (containing meta data)
+ $this->readSummaryInformation();
+
+ // Read the Additional document summary information stream (containing application-specific meta data)
+ $this->readDocumentSummaryInformation();
+
+ // total byte size of Excel data (workbook global substream + sheet substreams)
+ $this->dataSize = strlen($this->data);
+
+ // initialize
+ $this->pos = 0;
+ $this->codepage = $this->codepage ?: CodePage::DEFAULT_CODE_PAGE;
+ $this->formats = [];
+ $this->objFonts = [];
+ $this->palette = [];
+ $this->sheets = [];
+ $this->externalBooks = [];
+ $this->ref = [];
+ $this->definedname = [];
+ $this->sst = [];
+ $this->drawingGroupData = '';
+ $this->xfIndex = '';
+ $this->mapCellXfIndex = [];
+ $this->mapCellStyleXfIndex = [];
+
+ // Parse Workbook Global Substream
+ while ($this->pos < $this->dataSize) {
+ $code = self::getUInt2d($this->data, $this->pos);
+
+ switch ($code) {
+ case self::XLS_TYPE_BOF:
+ $this->readBof();
+
+ break;
+ case self::XLS_TYPE_FILEPASS:
+ $this->readFilepass();
+
+ break;
+ case self::XLS_TYPE_CODEPAGE:
+ $this->readCodepage();
+
+ break;
+ case self::XLS_TYPE_DATEMODE:
+ $this->readDateMode();
+
+ break;
+ case self::XLS_TYPE_FONT:
+ $this->readFont();
+
+ break;
+ case self::XLS_TYPE_FORMAT:
+ $this->readFormat();
+
+ break;
+ case self::XLS_TYPE_XF:
+ $this->readXf();
+
+ break;
+ case self::XLS_TYPE_XFEXT:
+ $this->readXfExt();
+
+ break;
+ case self::XLS_TYPE_STYLE:
+ $this->readStyle();
+
+ break;
+ case self::XLS_TYPE_PALETTE:
+ $this->readPalette();
+
+ break;
+ case self::XLS_TYPE_SHEET:
+ $this->readSheet();
+
+ break;
+ case self::XLS_TYPE_EXTERNALBOOK:
+ $this->readExternalBook();
+
+ break;
+ case self::XLS_TYPE_EXTERNNAME:
+ $this->readExternName();
+
+ break;
+ case self::XLS_TYPE_EXTERNSHEET:
+ $this->readExternSheet();
+
+ break;
+ case self::XLS_TYPE_DEFINEDNAME:
+ $this->readDefinedName();
+
+ break;
+ case self::XLS_TYPE_MSODRAWINGGROUP:
+ $this->readMsoDrawingGroup();
+
+ break;
+ case self::XLS_TYPE_SST:
+ $this->readSst();
+
+ break;
+ case self::XLS_TYPE_EOF:
+ $this->readDefault();
+
+ break 2;
+ default:
+ $this->readDefault();
+
+ break;
+ }
+ }
+
+ // Resolve indexed colors for font, fill, and border colors
+ // Cannot be resolved already in XF record, because PALETTE record comes afterwards
+ if (!$this->readDataOnly) {
+ foreach ($this->objFonts as $objFont) {
+ if (isset($objFont->colorIndex)) {
+ $color = Xls\Color::map($objFont->colorIndex, $this->palette, $this->version);
+ $objFont->getColor()->setRGB($color['rgb']);
+ }
+ }
+
+ foreach ($this->spreadsheet->getCellXfCollection() as $objStyle) {
+ // fill start and end color
+ $fill = $objStyle->getFill();
+
+ if (isset($fill->startcolorIndex)) {
+ $startColor = Xls\Color::map($fill->startcolorIndex, $this->palette, $this->version);
+ $fill->getStartColor()->setRGB($startColor['rgb']);
+ }
+ if (isset($fill->endcolorIndex)) {
+ $endColor = Xls\Color::map($fill->endcolorIndex, $this->palette, $this->version);
+ $fill->getEndColor()->setRGB($endColor['rgb']);
+ }
+
+ // border colors
+ $top = $objStyle->getBorders()->getTop();
+ $right = $objStyle->getBorders()->getRight();
+ $bottom = $objStyle->getBorders()->getBottom();
+ $left = $objStyle->getBorders()->getLeft();
+ $diagonal = $objStyle->getBorders()->getDiagonal();
+
+ if (isset($top->colorIndex)) {
+ $borderTopColor = Xls\Color::map($top->colorIndex, $this->palette, $this->version);
+ $top->getColor()->setRGB($borderTopColor['rgb']);
+ }
+ if (isset($right->colorIndex)) {
+ $borderRightColor = Xls\Color::map($right->colorIndex, $this->palette, $this->version);
+ $right->getColor()->setRGB($borderRightColor['rgb']);
+ }
+ if (isset($bottom->colorIndex)) {
+ $borderBottomColor = Xls\Color::map($bottom->colorIndex, $this->palette, $this->version);
+ $bottom->getColor()->setRGB($borderBottomColor['rgb']);
+ }
+ if (isset($left->colorIndex)) {
+ $borderLeftColor = Xls\Color::map($left->colorIndex, $this->palette, $this->version);
+ $left->getColor()->setRGB($borderLeftColor['rgb']);
+ }
+ if (isset($diagonal->colorIndex)) {
+ $borderDiagonalColor = Xls\Color::map($diagonal->colorIndex, $this->palette, $this->version);
+ $diagonal->getColor()->setRGB($borderDiagonalColor['rgb']);
+ }
+ }
+ }
+
+ // treat MSODRAWINGGROUP records, workbook-level Escher
+ if (!$this->readDataOnly && $this->drawingGroupData) {
+ $escherWorkbook = new Escher();
+ $reader = new Xls\Escher($escherWorkbook);
+ $escherWorkbook = $reader->load($this->drawingGroupData);
+ }
+
+ // Parse the individual sheets
+ foreach ($this->sheets as $sheet) {
+ if ($sheet['sheetType'] != 0x00) {
+ // 0x00: Worksheet, 0x02: Chart, 0x06: Visual Basic module
+ continue;
+ }
+
+ // check if sheet should be skipped
+ if (isset($this->loadSheetsOnly) && !in_array($sheet['name'], $this->loadSheetsOnly)) {
+ continue;
+ }
+
+ // add sheet to PhpSpreadsheet object
+ $this->phpSheet = $this->spreadsheet->createSheet();
+ // Use false for $updateFormulaCellReferences to prevent adjustment of worksheet references in formula
+ // cells... during the load, all formulae should be correct, and we're simply bringing the worksheet
+ // name in line with the formula, not the reverse
+ $this->phpSheet->setTitle($sheet['name'], false, false);
+ $this->phpSheet->setSheetState($sheet['sheetState']);
+
+ $this->pos = $sheet['offset'];
+
+ // Initialize isFitToPages. May change after reading SHEETPR record.
+ $this->isFitToPages = false;
+
+ // Initialize drawingData
+ $this->drawingData = '';
+
+ // Initialize objs
+ $this->objs = [];
+
+ // Initialize shared formula parts
+ $this->sharedFormulaParts = [];
+
+ // Initialize shared formulas
+ $this->sharedFormulas = [];
+
+ // Initialize text objs
+ $this->textObjects = [];
+
+ // Initialize cell annotations
+ $this->cellNotes = [];
+ $this->textObjRef = -1;
+
+ while ($this->pos <= $this->dataSize - 4) {
+ $code = self::getUInt2d($this->data, $this->pos);
+
+ switch ($code) {
+ case self::XLS_TYPE_BOF:
+ $this->readBof();
+
+ break;
+ case self::XLS_TYPE_PRINTGRIDLINES:
+ $this->readPrintGridlines();
+
+ break;
+ case self::XLS_TYPE_DEFAULTROWHEIGHT:
+ $this->readDefaultRowHeight();
+
+ break;
+ case self::XLS_TYPE_SHEETPR:
+ $this->readSheetPr();
+
+ break;
+ case self::XLS_TYPE_HORIZONTALPAGEBREAKS:
+ $this->readHorizontalPageBreaks();
+
+ break;
+ case self::XLS_TYPE_VERTICALPAGEBREAKS:
+ $this->readVerticalPageBreaks();
+
+ break;
+ case self::XLS_TYPE_HEADER:
+ $this->readHeader();
+
+ break;
+ case self::XLS_TYPE_FOOTER:
+ $this->readFooter();
+
+ break;
+ case self::XLS_TYPE_HCENTER:
+ $this->readHcenter();
+
+ break;
+ case self::XLS_TYPE_VCENTER:
+ $this->readVcenter();
+
+ break;
+ case self::XLS_TYPE_LEFTMARGIN:
+ $this->readLeftMargin();
+
+ break;
+ case self::XLS_TYPE_RIGHTMARGIN:
+ $this->readRightMargin();
+
+ break;
+ case self::XLS_TYPE_TOPMARGIN:
+ $this->readTopMargin();
+
+ break;
+ case self::XLS_TYPE_BOTTOMMARGIN:
+ $this->readBottomMargin();
+
+ break;
+ case self::XLS_TYPE_PAGESETUP:
+ $this->readPageSetup();
+
+ break;
+ case self::XLS_TYPE_PROTECT:
+ $this->readProtect();
+
+ break;
+ case self::XLS_TYPE_SCENPROTECT:
+ $this->readScenProtect();
+
+ break;
+ case self::XLS_TYPE_OBJECTPROTECT:
+ $this->readObjectProtect();
+
+ break;
+ case self::XLS_TYPE_PASSWORD:
+ $this->readPassword();
+
+ break;
+ case self::XLS_TYPE_DEFCOLWIDTH:
+ $this->readDefColWidth();
+
+ break;
+ case self::XLS_TYPE_COLINFO:
+ $this->readColInfo();
+
+ break;
+ case self::XLS_TYPE_DIMENSION:
+ $this->readDefault();
+
+ break;
+ case self::XLS_TYPE_ROW:
+ $this->readRow();
+
+ break;
+ case self::XLS_TYPE_DBCELL:
+ $this->readDefault();
+
+ break;
+ case self::XLS_TYPE_RK:
+ $this->readRk();
+
+ break;
+ case self::XLS_TYPE_LABELSST:
+ $this->readLabelSst();
+
+ break;
+ case self::XLS_TYPE_MULRK:
+ $this->readMulRk();
+
+ break;
+ case self::XLS_TYPE_NUMBER:
+ $this->readNumber();
+
+ break;
+ case self::XLS_TYPE_FORMULA:
+ $this->readFormula();
+
+ break;
+ case self::XLS_TYPE_SHAREDFMLA:
+ $this->readSharedFmla();
+
+ break;
+ case self::XLS_TYPE_BOOLERR:
+ $this->readBoolErr();
+
+ break;
+ case self::XLS_TYPE_MULBLANK:
+ $this->readMulBlank();
+
+ break;
+ case self::XLS_TYPE_LABEL:
+ $this->readLabel();
+
+ break;
+ case self::XLS_TYPE_BLANK:
+ $this->readBlank();
+
+ break;
+ case self::XLS_TYPE_MSODRAWING:
+ $this->readMsoDrawing();
+
+ break;
+ case self::XLS_TYPE_OBJ:
+ $this->readObj();
+
+ break;
+ case self::XLS_TYPE_WINDOW2:
+ $this->readWindow2();
+
+ break;
+ case self::XLS_TYPE_PAGELAYOUTVIEW:
+ $this->readPageLayoutView();
+
+ break;
+ case self::XLS_TYPE_SCL:
+ $this->readScl();
+
+ break;
+ case self::XLS_TYPE_PANE:
+ $this->readPane();
+
+ break;
+ case self::XLS_TYPE_SELECTION:
+ $this->readSelection();
+
+ break;
+ case self::XLS_TYPE_MERGEDCELLS:
+ $this->readMergedCells();
+
+ break;
+ case self::XLS_TYPE_HYPERLINK:
+ $this->readHyperLink();
+
+ break;
+ case self::XLS_TYPE_DATAVALIDATIONS:
+ $this->readDataValidations();
+
+ break;
+ case self::XLS_TYPE_DATAVALIDATION:
+ $this->readDataValidation();
+
+ break;
+ case self::XLS_TYPE_SHEETLAYOUT:
+ $this->readSheetLayout();
+
+ break;
+ case self::XLS_TYPE_SHEETPROTECTION:
+ $this->readSheetProtection();
+
+ break;
+ case self::XLS_TYPE_RANGEPROTECTION:
+ $this->readRangeProtection();
+
+ break;
+ case self::XLS_TYPE_NOTE:
+ $this->readNote();
+
+ break;
+ case self::XLS_TYPE_TXO:
+ $this->readTextObject();
+
+ break;
+ case self::XLS_TYPE_CONTINUE:
+ $this->readContinue();
+
+ break;
+ case self::XLS_TYPE_EOF:
+ $this->readDefault();
+
+ break 2;
+ default:
+ $this->readDefault();
+
+ break;
+ }
+ }
+
+ // treat MSODRAWING records, sheet-level Escher
+ if (!$this->readDataOnly && $this->drawingData) {
+ $escherWorksheet = new Escher();
+ $reader = new Xls\Escher($escherWorksheet);
+ $escherWorksheet = $reader->load($this->drawingData);
+
+ // get all spContainers in one long array, so they can be mapped to OBJ records
+ $allSpContainers = $escherWorksheet->getDgContainer()->getSpgrContainer()->getAllSpContainers();
+ }
+
+ // treat OBJ records
+ foreach ($this->objs as $n => $obj) {
+ // the first shape container never has a corresponding OBJ record, hence $n + 1
+ if (isset($allSpContainers[$n + 1]) && is_object($allSpContainers[$n + 1])) {
+ $spContainer = $allSpContainers[$n + 1];
+
+ // we skip all spContainers that are a part of a group shape since we cannot yet handle those
+ if ($spContainer->getNestingLevel() > 1) {
+ continue;
+ }
+
+ // calculate the width and height of the shape
+ [$startColumn, $startRow] = Coordinate::coordinateFromString($spContainer->getStartCoordinates());
+ [$endColumn, $endRow] = Coordinate::coordinateFromString($spContainer->getEndCoordinates());
+
+ $startOffsetX = $spContainer->getStartOffsetX();
+ $startOffsetY = $spContainer->getStartOffsetY();
+ $endOffsetX = $spContainer->getEndOffsetX();
+ $endOffsetY = $spContainer->getEndOffsetY();
+
+ $width = \PhpOffice\PhpSpreadsheet\Shared\Xls::getDistanceX($this->phpSheet, $startColumn, $startOffsetX, $endColumn, $endOffsetX);
+ $height = \PhpOffice\PhpSpreadsheet\Shared\Xls::getDistanceY($this->phpSheet, $startRow, $startOffsetY, $endRow, $endOffsetY);
+
+ // calculate offsetX and offsetY of the shape
+ $offsetX = $startOffsetX * \PhpOffice\PhpSpreadsheet\Shared\Xls::sizeCol($this->phpSheet, $startColumn) / 1024;
+ $offsetY = $startOffsetY * \PhpOffice\PhpSpreadsheet\Shared\Xls::sizeRow($this->phpSheet, $startRow) / 256;
+
+ switch ($obj['otObjType']) {
+ case 0x19:
+ // Note
+ if (isset($this->cellNotes[$obj['idObjID']])) {
+ $cellNote = $this->cellNotes[$obj['idObjID']];
+
+ if (isset($this->textObjects[$obj['idObjID']])) {
+ $textObject = $this->textObjects[$obj['idObjID']];
+ $this->cellNotes[$obj['idObjID']]['objTextData'] = $textObject;
+ }
+ }
+
+ break;
+ case 0x08:
+ // picture
+ // get index to BSE entry (1-based)
+ $BSEindex = $spContainer->getOPT(0x0104);
+
+ // If there is no BSE Index, we will fail here and other fields are not read.
+ // Fix by checking here.
+ // TODO: Why is there no BSE Index? Is this a new Office Version? Password protected field?
+ // More likely : a uncompatible picture
+ if (!$BSEindex) {
+ continue 2;
+ }
+
+ $BSECollection = $escherWorkbook->getDggContainer()->getBstoreContainer()->getBSECollection();
+ $BSE = $BSECollection[$BSEindex - 1];
+ $blipType = $BSE->getBlipType();
+
+ // need check because some blip types are not supported by Escher reader such as EMF
+ if ($blip = $BSE->getBlip()) {
+ $ih = imagecreatefromstring($blip->getData());
+ $drawing = new MemoryDrawing();
+ $drawing->setImageResource($ih);
+
+ // width, height, offsetX, offsetY
+ $drawing->setResizeProportional(false);
+ $drawing->setWidth($width);
+ $drawing->setHeight($height);
+ $drawing->setOffsetX($offsetX);
+ $drawing->setOffsetY($offsetY);
+
+ switch ($blipType) {
+ case BSE::BLIPTYPE_JPEG:
+ $drawing->setRenderingFunction(MemoryDrawing::RENDERING_JPEG);
+ $drawing->setMimeType(MemoryDrawing::MIMETYPE_JPEG);
+
+ break;
+ case BSE::BLIPTYPE_PNG:
+ $drawing->setRenderingFunction(MemoryDrawing::RENDERING_PNG);
+ $drawing->setMimeType(MemoryDrawing::MIMETYPE_PNG);
+
+ break;
+ }
+
+ $drawing->setWorksheet($this->phpSheet);
+ $drawing->setCoordinates($spContainer->getStartCoordinates());
+ }
+
+ break;
+ default:
+ // other object type
+ break;
+ }
+ }
+ }
+
+ // treat SHAREDFMLA records
+ if ($this->version == self::XLS_BIFF8) {
+ foreach ($this->sharedFormulaParts as $cell => $baseCell) {
+ [$column, $row] = Coordinate::coordinateFromString($cell);
+ if (($this->getReadFilter() !== null) && $this->getReadFilter()->readCell($column, $row, $this->phpSheet->getTitle())) {
+ $formula = $this->getFormulaFromStructure($this->sharedFormulas[$baseCell], $cell);
+ $this->phpSheet->getCell($cell)->setValueExplicit('=' . $formula, DataType::TYPE_FORMULA);
+ }
+ }
+ }
+
+ if (!empty($this->cellNotes)) {
+ foreach ($this->cellNotes as $note => $noteDetails) {
+ if (!isset($noteDetails['objTextData'])) {
+ if (isset($this->textObjects[$note])) {
+ $textObject = $this->textObjects[$note];
+ $noteDetails['objTextData'] = $textObject;
+ } else {
+ $noteDetails['objTextData']['text'] = '';
+ }
+ }
+ $cellAddress = str_replace('$', '', $noteDetails['cellRef']);
+ $this->phpSheet->getComment($cellAddress)->setAuthor($noteDetails['author'])->setText($this->parseRichText($noteDetails['objTextData']['text']));
+ }
+ }
+ }
+
+ // add the named ranges (defined names)
+ foreach ($this->definedname as $definedName) {
+ if ($definedName['isBuiltInName']) {
+ switch ($definedName['name']) {
+ case pack('C', 0x06):
+ // print area
+ // in general, formula looks like this: Foo!$C$7:$J$66,Bar!$A$1:$IV$2
+ $ranges = explode(',', $definedName['formula']); // FIXME: what if sheetname contains comma?
+
+ $extractedRanges = [];
+ foreach ($ranges as $range) {
+ // $range should look like one of these
+ // Foo!$C$7:$J$66
+ // Bar!$A$1:$IV$2
+ $explodes = Worksheet::extractSheetTitle($range, true);
+ $sheetName = trim($explodes[0], "'");
+ if (count($explodes) == 2) {
+ if (strpos($explodes[1], ':') === false) {
+ $explodes[1] = $explodes[1] . ':' . $explodes[1];
+ }
+ $extractedRanges[] = str_replace('$', '', $explodes[1]); // C7:J66
+ }
+ }
+ if ($docSheet = $this->spreadsheet->getSheetByName($sheetName)) {
+ $docSheet->getPageSetup()->setPrintArea(implode(',', $extractedRanges)); // C7:J66,A1:IV2
+ }
+
+ break;
+ case pack('C', 0x07):
+ // print titles (repeating rows)
+ // Assuming BIFF8, there are 3 cases
+ // 1. repeating rows
+ // formula looks like this: Sheet!$A$1:$IV$2
+ // rows 1-2 repeat
+ // 2. repeating columns
+ // formula looks like this: Sheet!$A$1:$B$65536
+ // columns A-B repeat
+ // 3. both repeating rows and repeating columns
+ // formula looks like this: Sheet!$A$1:$B$65536,Sheet!$A$1:$IV$2
+ $ranges = explode(',', $definedName['formula']); // FIXME: what if sheetname contains comma?
+ foreach ($ranges as $range) {
+ // $range should look like this one of these
+ // Sheet!$A$1:$B$65536
+ // Sheet!$A$1:$IV$2
+ if (strpos($range, '!') !== false) {
+ $explodes = Worksheet::extractSheetTitle($range, true);
+ if ($docSheet = $this->spreadsheet->getSheetByName($explodes[0])) {
+ $extractedRange = $explodes[1];
+ $extractedRange = str_replace('$', '', $extractedRange);
+
+ $coordinateStrings = explode(':', $extractedRange);
+ if (count($coordinateStrings) == 2) {
+ [$firstColumn, $firstRow] = Coordinate::coordinateFromString($coordinateStrings[0]);
+ [$lastColumn, $lastRow] = Coordinate::coordinateFromString($coordinateStrings[1]);
+
+ if ($firstColumn == 'A' && $lastColumn == 'IV') {
+ // then we have repeating rows
+ $docSheet->getPageSetup()->setRowsToRepeatAtTop([$firstRow, $lastRow]);
+ } elseif ($firstRow == 1 && $lastRow == 65536) {
+ // then we have repeating columns
+ $docSheet->getPageSetup()->setColumnsToRepeatAtLeft([$firstColumn, $lastColumn]);
+ }
+ }
+ }
+ }
+ }
+
+ break;
+ }
+ } else {
+ // Extract range
+ if (strpos($definedName['formula'], '!') !== false) {
+ $explodes = Worksheet::extractSheetTitle($definedName['formula'], true);
+ if (
+ ($docSheet = $this->spreadsheet->getSheetByName($explodes[0])) ||
+ ($docSheet = $this->spreadsheet->getSheetByName(trim($explodes[0], "'")))
+ ) {
+ $extractedRange = $explodes[1];
+ $extractedRange = str_replace('$', '', $extractedRange);
+
+ $localOnly = ($definedName['scope'] == 0) ? false : true;
+
+ $scope = ($definedName['scope'] == 0) ? null : $this->spreadsheet->getSheetByName($this->sheets[$definedName['scope'] - 1]['name']);
+
+ $this->spreadsheet->addNamedRange(new NamedRange((string) $definedName['name'], $docSheet, $extractedRange, $localOnly, $scope));
+ }
+ }
+ // Named Value
+ // TODO Provide support for named values
+ }
+ }
+ $this->data = null;
+
+ return $this->spreadsheet;
+ }
+
+ /**
+ * Read record data from stream, decrypting as required.
+ *
+ * @param string $data Data stream to read from
+ * @param int $pos Position to start reading from
+ * @param int $len Record data length
+ *
+ * @return string Record data
+ */
+ private function readRecordData($data, $pos, $len)
+ {
+ $data = substr($data, $pos, $len);
+
+ // File not encrypted, or record before encryption start point
+ if ($this->encryption == self::MS_BIFF_CRYPTO_NONE || $pos < $this->encryptionStartPos) {
+ return $data;
+ }
+
+ $recordData = '';
+ if ($this->encryption == self::MS_BIFF_CRYPTO_RC4) {
+ $oldBlock = floor($this->rc4Pos / self::REKEY_BLOCK);
+ $block = floor($pos / self::REKEY_BLOCK);
+ $endBlock = floor(($pos + $len) / self::REKEY_BLOCK);
+
+ // Spin an RC4 decryptor to the right spot. If we have a decryptor sitting
+ // at a point earlier in the current block, re-use it as we can save some time.
+ if ($block != $oldBlock || $pos < $this->rc4Pos || !$this->rc4Key) {
+ $this->rc4Key = $this->makeKey($block, $this->md5Ctxt);
+ $step = $pos % self::REKEY_BLOCK;
+ } else {
+ $step = $pos - $this->rc4Pos;
+ }
+ $this->rc4Key->RC4(str_repeat("\0", $step));
+
+ // Decrypt record data (re-keying at the end of every block)
+ while ($block != $endBlock) {
+ $step = self::REKEY_BLOCK - ($pos % self::REKEY_BLOCK);
+ $recordData .= $this->rc4Key->RC4(substr($data, 0, $step));
+ $data = substr($data, $step);
+ $pos += $step;
+ $len -= $step;
+ ++$block;
+ $this->rc4Key = $this->makeKey($block, $this->md5Ctxt);
+ }
+ $recordData .= $this->rc4Key->RC4(substr($data, 0, $len));
+
+ // Keep track of the position of this decryptor.
+ // We'll try and re-use it later if we can to speed things up
+ $this->rc4Pos = $pos + $len;
+ } elseif ($this->encryption == self::MS_BIFF_CRYPTO_XOR) {
+ throw new Exception('XOr encryption not supported');
+ }
+
+ return $recordData;
+ }
+
+ /**
+ * Use OLE reader to extract the relevant data streams from the OLE file.
+ *
+ * @param string $pFilename
+ */
+ private function loadOLE($pFilename): void
+ {
+ // OLE reader
+ $ole = new OLERead();
+ // get excel data,
+ $ole->read($pFilename);
+ // Get workbook data: workbook stream + sheet streams
+ $this->data = $ole->getStream($ole->wrkbook);
+ // Get summary information data
+ $this->summaryInformation = $ole->getStream($ole->summaryInformation);
+ // Get additional document summary information data
+ $this->documentSummaryInformation = $ole->getStream($ole->documentSummaryInformation);
+ }
+
+ /**
+ * Read summary information.
+ */
+ private function readSummaryInformation(): void
+ {
+ if (!isset($this->summaryInformation)) {
+ return;
+ }
+
+ // offset: 0; size: 2; must be 0xFE 0xFF (UTF-16 LE byte order mark)
+ // offset: 2; size: 2;
+ // offset: 4; size: 2; OS version
+ // offset: 6; size: 2; OS indicator
+ // offset: 8; size: 16
+ // offset: 24; size: 4; section count
+ $secCount = self::getInt4d($this->summaryInformation, 24);
+
+ // offset: 28; size: 16; first section's class id: e0 85 9f f2 f9 4f 68 10 ab 91 08 00 2b 27 b3 d9
+ // offset: 44; size: 4
+ $secOffset = self::getInt4d($this->summaryInformation, 44);
+
+ // section header
+ // offset: $secOffset; size: 4; section length
+ $secLength = self::getInt4d($this->summaryInformation, $secOffset);
+
+ // offset: $secOffset+4; size: 4; property count
+ $countProperties = self::getInt4d($this->summaryInformation, $secOffset + 4);
+
+ // initialize code page (used to resolve string values)
+ $codePage = 'CP1252';
+
+ // offset: ($secOffset+8); size: var
+ // loop through property decarations and properties
+ for ($i = 0; $i < $countProperties; ++$i) {
+ // offset: ($secOffset+8) + (8 * $i); size: 4; property ID
+ $id = self::getInt4d($this->summaryInformation, ($secOffset + 8) + (8 * $i));
+
+ // Use value of property id as appropriate
+ // offset: ($secOffset+12) + (8 * $i); size: 4; offset from beginning of section (48)
+ $offset = self::getInt4d($this->summaryInformation, ($secOffset + 12) + (8 * $i));
+
+ $type = self::getInt4d($this->summaryInformation, $secOffset + $offset);
+
+ // initialize property value
+ $value = null;
+
+ // extract property value based on property type
+ switch ($type) {
+ case 0x02: // 2 byte signed integer
+ $value = self::getUInt2d($this->summaryInformation, $secOffset + 4 + $offset);
+
+ break;
+ case 0x03: // 4 byte signed integer
+ $value = self::getInt4d($this->summaryInformation, $secOffset + 4 + $offset);
+
+ break;
+ case 0x13: // 4 byte unsigned integer
+ // not needed yet, fix later if necessary
+ break;
+ case 0x1E: // null-terminated string prepended by dword string length
+ $byteLength = self::getInt4d($this->summaryInformation, $secOffset + 4 + $offset);
+ $value = substr($this->summaryInformation, $secOffset + 8 + $offset, $byteLength);
+ $value = StringHelper::convertEncoding($value, 'UTF-8', $codePage);
+ $value = rtrim($value);
+
+ break;
+ case 0x40: // Filetime (64-bit value representing the number of 100-nanosecond intervals since January 1, 1601)
+ // PHP-time
+ $value = OLE::OLE2LocalDate(substr($this->summaryInformation, $secOffset + 4 + $offset, 8));
+
+ break;
+ case 0x47: // Clipboard format
+ // not needed yet, fix later if necessary
+ break;
+ }
+
+ switch ($id) {
+ case 0x01: // Code Page
+ $codePage = CodePage::numberToName($value);
+
+ break;
+ case 0x02: // Title
+ $this->spreadsheet->getProperties()->setTitle($value);
+
+ break;
+ case 0x03: // Subject
+ $this->spreadsheet->getProperties()->setSubject($value);
+
+ break;
+ case 0x04: // Author (Creator)
+ $this->spreadsheet->getProperties()->setCreator($value);
+
+ break;
+ case 0x05: // Keywords
+ $this->spreadsheet->getProperties()->setKeywords($value);
+
+ break;
+ case 0x06: // Comments (Description)
+ $this->spreadsheet->getProperties()->setDescription($value);
+
+ break;
+ case 0x07: // Template
+ // Not supported by PhpSpreadsheet
+ break;
+ case 0x08: // Last Saved By (LastModifiedBy)
+ $this->spreadsheet->getProperties()->setLastModifiedBy($value);
+
+ break;
+ case 0x09: // Revision
+ // Not supported by PhpSpreadsheet
+ break;
+ case 0x0A: // Total Editing Time
+ // Not supported by PhpSpreadsheet
+ break;
+ case 0x0B: // Last Printed
+ // Not supported by PhpSpreadsheet
+ break;
+ case 0x0C: // Created Date/Time
+ $this->spreadsheet->getProperties()->setCreated($value);
+
+ break;
+ case 0x0D: // Modified Date/Time
+ $this->spreadsheet->getProperties()->setModified($value);
+
+ break;
+ case 0x0E: // Number of Pages
+ // Not supported by PhpSpreadsheet
+ break;
+ case 0x0F: // Number of Words
+ // Not supported by PhpSpreadsheet
+ break;
+ case 0x10: // Number of Characters
+ // Not supported by PhpSpreadsheet
+ break;
+ case 0x11: // Thumbnail
+ // Not supported by PhpSpreadsheet
+ break;
+ case 0x12: // Name of creating application
+ // Not supported by PhpSpreadsheet
+ break;
+ case 0x13: // Security
+ // Not supported by PhpSpreadsheet
+ break;
+ }
+ }
+ }
+
+ /**
+ * Read additional document summary information.
+ */
+ private function readDocumentSummaryInformation(): void
+ {
+ if (!isset($this->documentSummaryInformation)) {
+ return;
+ }
+
+ // offset: 0; size: 2; must be 0xFE 0xFF (UTF-16 LE byte order mark)
+ // offset: 2; size: 2;
+ // offset: 4; size: 2; OS version
+ // offset: 6; size: 2; OS indicator
+ // offset: 8; size: 16
+ // offset: 24; size: 4; section count
+ $secCount = self::getInt4d($this->documentSummaryInformation, 24);
+
+ // offset: 28; size: 16; first section's class id: 02 d5 cd d5 9c 2e 1b 10 93 97 08 00 2b 2c f9 ae
+ // offset: 44; size: 4; first section offset
+ $secOffset = self::getInt4d($this->documentSummaryInformation, 44);
+
+ // section header
+ // offset: $secOffset; size: 4; section length
+ $secLength = self::getInt4d($this->documentSummaryInformation, $secOffset);
+
+ // offset: $secOffset+4; size: 4; property count
+ $countProperties = self::getInt4d($this->documentSummaryInformation, $secOffset + 4);
+
+ // initialize code page (used to resolve string values)
+ $codePage = 'CP1252';
+
+ // offset: ($secOffset+8); size: var
+ // loop through property decarations and properties
+ for ($i = 0; $i < $countProperties; ++$i) {
+ // offset: ($secOffset+8) + (8 * $i); size: 4; property ID
+ $id = self::getInt4d($this->documentSummaryInformation, ($secOffset + 8) + (8 * $i));
+
+ // Use value of property id as appropriate
+ // offset: 60 + 8 * $i; size: 4; offset from beginning of section (48)
+ $offset = self::getInt4d($this->documentSummaryInformation, ($secOffset + 12) + (8 * $i));
+
+ $type = self::getInt4d($this->documentSummaryInformation, $secOffset + $offset);
+
+ // initialize property value
+ $value = null;
+
+ // extract property value based on property type
+ switch ($type) {
+ case 0x02: // 2 byte signed integer
+ $value = self::getUInt2d($this->documentSummaryInformation, $secOffset + 4 + $offset);
+
+ break;
+ case 0x03: // 4 byte signed integer
+ $value = self::getInt4d($this->documentSummaryInformation, $secOffset + 4 + $offset);
+
+ break;
+ case 0x0B: // Boolean
+ $value = self::getUInt2d($this->documentSummaryInformation, $secOffset + 4 + $offset);
+ $value = ($value == 0 ? false : true);
+
+ break;
+ case 0x13: // 4 byte unsigned integer
+ // not needed yet, fix later if necessary
+ break;
+ case 0x1E: // null-terminated string prepended by dword string length
+ $byteLength = self::getInt4d($this->documentSummaryInformation, $secOffset + 4 + $offset);
+ $value = substr($this->documentSummaryInformation, $secOffset + 8 + $offset, $byteLength);
+ $value = StringHelper::convertEncoding($value, 'UTF-8', $codePage);
+ $value = rtrim($value);
+
+ break;
+ case 0x40: // Filetime (64-bit value representing the number of 100-nanosecond intervals since January 1, 1601)
+ // PHP-Time
+ $value = OLE::OLE2LocalDate(substr($this->documentSummaryInformation, $secOffset + 4 + $offset, 8));
+
+ break;
+ case 0x47: // Clipboard format
+ // not needed yet, fix later if necessary
+ break;
+ }
+
+ switch ($id) {
+ case 0x01: // Code Page
+ $codePage = CodePage::numberToName($value);
+
+ break;
+ case 0x02: // Category
+ $this->spreadsheet->getProperties()->setCategory($value);
+
+ break;
+ case 0x03: // Presentation Target
+ // Not supported by PhpSpreadsheet
+ break;
+ case 0x04: // Bytes
+ // Not supported by PhpSpreadsheet
+ break;
+ case 0x05: // Lines
+ // Not supported by PhpSpreadsheet
+ break;
+ case 0x06: // Paragraphs
+ // Not supported by PhpSpreadsheet
+ break;
+ case 0x07: // Slides
+ // Not supported by PhpSpreadsheet
+ break;
+ case 0x08: // Notes
+ // Not supported by PhpSpreadsheet
+ break;
+ case 0x09: // Hidden Slides
+ // Not supported by PhpSpreadsheet
+ break;
+ case 0x0A: // MM Clips
+ // Not supported by PhpSpreadsheet
+ break;
+ case 0x0B: // Scale Crop
+ // Not supported by PhpSpreadsheet
+ break;
+ case 0x0C: // Heading Pairs
+ // Not supported by PhpSpreadsheet
+ break;
+ case 0x0D: // Titles of Parts
+ // Not supported by PhpSpreadsheet
+ break;
+ case 0x0E: // Manager
+ $this->spreadsheet->getProperties()->setManager($value);
+
+ break;
+ case 0x0F: // Company
+ $this->spreadsheet->getProperties()->setCompany($value);
+
+ break;
+ case 0x10: // Links up-to-date
+ // Not supported by PhpSpreadsheet
+ break;
+ }
+ }
+ }
+
+ /**
+ * Reads a general type of BIFF record. Does nothing except for moving stream pointer forward to next record.
+ */
+ private function readDefault(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+ }
+
+ /**
+ * The NOTE record specifies a comment associated with a particular cell. In Excel 95 (BIFF7) and earlier versions,
+ * this record stores a note (cell note). This feature was significantly enhanced in Excel 97.
+ */
+ private function readNote(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ if ($this->readDataOnly) {
+ return;
+ }
+
+ $cellAddress = $this->readBIFF8CellAddress(substr($recordData, 0, 4));
+ if ($this->version == self::XLS_BIFF8) {
+ $noteObjID = self::getUInt2d($recordData, 6);
+ $noteAuthor = self::readUnicodeStringLong(substr($recordData, 8));
+ $noteAuthor = $noteAuthor['value'];
+ $this->cellNotes[$noteObjID] = [
+ 'cellRef' => $cellAddress,
+ 'objectID' => $noteObjID,
+ 'author' => $noteAuthor,
+ ];
+ } else {
+ $extension = false;
+ if ($cellAddress == '$B$65536') {
+ // If the address row is -1 and the column is 0, (which translates as $B$65536) then this is a continuation
+ // note from the previous cell annotation. We're not yet handling this, so annotations longer than the
+ // max 2048 bytes will probably throw a wobbly.
+ $row = self::getUInt2d($recordData, 0);
+ $extension = true;
+ $cellAddress = array_pop(array_keys($this->phpSheet->getComments()));
+ }
+
+ $cellAddress = str_replace('$', '', $cellAddress);
+ $noteLength = self::getUInt2d($recordData, 4);
+ $noteText = trim(substr($recordData, 6));
+
+ if ($extension) {
+ // Concatenate this extension with the currently set comment for the cell
+ $comment = $this->phpSheet->getComment($cellAddress);
+ $commentText = $comment->getText()->getPlainText();
+ $comment->setText($this->parseRichText($commentText . $noteText));
+ } else {
+ // Set comment for the cell
+ $this->phpSheet->getComment($cellAddress)->setText($this->parseRichText($noteText));
+// ->setAuthor($author)
+ }
+ }
+ }
+
+ /**
+ * The TEXT Object record contains the text associated with a cell annotation.
+ */
+ private function readTextObject(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ if ($this->readDataOnly) {
+ return;
+ }
+
+ // recordData consists of an array of subrecords looking like this:
+ // grbit: 2 bytes; Option Flags
+ // rot: 2 bytes; rotation
+ // cchText: 2 bytes; length of the text (in the first continue record)
+ // cbRuns: 2 bytes; length of the formatting (in the second continue record)
+ // followed by the continuation records containing the actual text and formatting
+ $grbitOpts = self::getUInt2d($recordData, 0);
+ $rot = self::getUInt2d($recordData, 2);
+ $cchText = self::getUInt2d($recordData, 10);
+ $cbRuns = self::getUInt2d($recordData, 12);
+ $text = $this->getSplicedRecordData();
+
+ $textByte = $text['spliceOffsets'][1] - $text['spliceOffsets'][0] - 1;
+ $textStr = substr($text['recordData'], $text['spliceOffsets'][0] + 1, $textByte);
+ // get 1 byte
+ $is16Bit = ord($text['recordData'][0]);
+ // it is possible to use a compressed format,
+ // which omits the high bytes of all characters, if they are all zero
+ if (($is16Bit & 0x01) === 0) {
+ $textStr = StringHelper::ConvertEncoding($textStr, 'UTF-8', 'ISO-8859-1');
+ } else {
+ $textStr = $this->decodeCodepage($textStr);
+ }
+
+ $this->textObjects[$this->textObjRef] = [
+ 'text' => $textStr,
+ 'format' => substr($text['recordData'], $text['spliceOffsets'][1], $cbRuns),
+ 'alignment' => $grbitOpts,
+ 'rotation' => $rot,
+ ];
+ }
+
+ /**
+ * Read BOF.
+ */
+ private function readBof(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = substr($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ // offset: 2; size: 2; type of the following data
+ $substreamType = self::getUInt2d($recordData, 2);
+
+ switch ($substreamType) {
+ case self::XLS_WORKBOOKGLOBALS:
+ $version = self::getUInt2d($recordData, 0);
+ if (($version != self::XLS_BIFF8) && ($version != self::XLS_BIFF7)) {
+ throw new Exception('Cannot read this Excel file. Version is too old.');
+ }
+ $this->version = $version;
+
+ break;
+ case self::XLS_WORKSHEET:
+ // do not use this version information for anything
+ // it is unreliable (OpenOffice doc, 5.8), use only version information from the global stream
+ break;
+ default:
+ // substream, e.g. chart
+ // just skip the entire substream
+ do {
+ $code = self::getUInt2d($this->data, $this->pos);
+ $this->readDefault();
+ } while ($code != self::XLS_TYPE_EOF && $this->pos < $this->dataSize);
+
+ break;
+ }
+ }
+
+ /**
+ * FILEPASS.
+ *
+ * This record is part of the File Protection Block. It
+ * contains information about the read/write password of the
+ * file. All record contents following this record will be
+ * encrypted.
+ *
+ * -- "OpenOffice.org's Documentation of the Microsoft
+ * Excel File Format"
+ *
+ * The decryption functions and objects used from here on in
+ * are based on the source of Spreadsheet-ParseExcel:
+ * https://metacpan.org/release/Spreadsheet-ParseExcel
+ */
+ private function readFilepass(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+
+ if ($length != 54) {
+ throw new Exception('Unexpected file pass record length');
+ }
+
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ if (!$this->verifyPassword('VelvetSweatshop', substr($recordData, 6, 16), substr($recordData, 22, 16), substr($recordData, 38, 16), $this->md5Ctxt)) {
+ throw new Exception('Decryption password incorrect');
+ }
+
+ $this->encryption = self::MS_BIFF_CRYPTO_RC4;
+
+ // Decryption required from the record after next onwards
+ $this->encryptionStartPos = $this->pos + self::getUInt2d($this->data, $this->pos + 2);
+ }
+
+ /**
+ * Make an RC4 decryptor for the given block.
+ *
+ * @param int $block Block for which to create decrypto
+ * @param string $valContext MD5 context state
+ *
+ * @return Xls\RC4
+ */
+ private function makeKey($block, $valContext)
+ {
+ $pwarray = str_repeat("\0", 64);
+
+ for ($i = 0; $i < 5; ++$i) {
+ $pwarray[$i] = $valContext[$i];
+ }
+
+ $pwarray[5] = chr($block & 0xff);
+ $pwarray[6] = chr(($block >> 8) & 0xff);
+ $pwarray[7] = chr(($block >> 16) & 0xff);
+ $pwarray[8] = chr(($block >> 24) & 0xff);
+
+ $pwarray[9] = "\x80";
+ $pwarray[56] = "\x48";
+
+ $md5 = new Xls\MD5();
+ $md5->add($pwarray);
+
+ $s = $md5->getContext();
+
+ return new Xls\RC4($s);
+ }
+
+ /**
+ * Verify RC4 file password.
+ *
+ * @param string $password Password to check
+ * @param string $docid Document id
+ * @param string $salt_data Salt data
+ * @param string $hashedsalt_data Hashed salt data
+ * @param string $valContext Set to the MD5 context of the value
+ *
+ * @return bool Success
+ */
+ private function verifyPassword($password, $docid, $salt_data, $hashedsalt_data, &$valContext)
+ {
+ $pwarray = str_repeat("\0", 64);
+
+ $iMax = strlen($password);
+ for ($i = 0; $i < $iMax; ++$i) {
+ $o = ord(substr($password, $i, 1));
+ $pwarray[2 * $i] = chr($o & 0xff);
+ $pwarray[2 * $i + 1] = chr(($o >> 8) & 0xff);
+ }
+ $pwarray[2 * $i] = chr(0x80);
+ $pwarray[56] = chr(($i << 4) & 0xff);
+
+ $md5 = new Xls\MD5();
+ $md5->add($pwarray);
+
+ $mdContext1 = $md5->getContext();
+
+ $offset = 0;
+ $keyoffset = 0;
+ $tocopy = 5;
+
+ $md5->reset();
+
+ while ($offset != 16) {
+ if ((64 - $offset) < 5) {
+ $tocopy = 64 - $offset;
+ }
+ for ($i = 0; $i <= $tocopy; ++$i) {
+ $pwarray[$offset + $i] = $mdContext1[$keyoffset + $i];
+ }
+ $offset += $tocopy;
+
+ if ($offset == 64) {
+ $md5->add($pwarray);
+ $keyoffset = $tocopy;
+ $tocopy = 5 - $tocopy;
+ $offset = 0;
+
+ continue;
+ }
+
+ $keyoffset = 0;
+ $tocopy = 5;
+ for ($i = 0; $i < 16; ++$i) {
+ $pwarray[$offset + $i] = $docid[$i];
+ }
+ $offset += 16;
+ }
+
+ $pwarray[16] = "\x80";
+ for ($i = 0; $i < 47; ++$i) {
+ $pwarray[17 + $i] = "\0";
+ }
+ $pwarray[56] = "\x80";
+ $pwarray[57] = "\x0a";
+
+ $md5->add($pwarray);
+ $valContext = $md5->getContext();
+
+ $key = $this->makeKey(0, $valContext);
+
+ $salt = $key->RC4($salt_data);
+ $hashedsalt = $key->RC4($hashedsalt_data);
+
+ $salt .= "\x80" . str_repeat("\0", 47);
+ $salt[56] = "\x80";
+
+ $md5->reset();
+ $md5->add($salt);
+ $mdContext2 = $md5->getContext();
+
+ return $mdContext2 == $hashedsalt;
+ }
+
+ /**
+ * CODEPAGE.
+ *
+ * This record stores the text encoding used to write byte
+ * strings, stored as MS Windows code page identifier.
+ *
+ * -- "OpenOffice.org's Documentation of the Microsoft
+ * Excel File Format"
+ */
+ private function readCodepage(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ // offset: 0; size: 2; code page identifier
+ $codepage = self::getUInt2d($recordData, 0);
+
+ $this->codepage = CodePage::numberToName($codepage);
+ }
+
+ /**
+ * DATEMODE.
+ *
+ * This record specifies the base date for displaying date
+ * values. All dates are stored as count of days past this
+ * base date. In BIFF2-BIFF4 this record is part of the
+ * Calculation Settings Block. In BIFF5-BIFF8 it is
+ * stored in the Workbook Globals Substream.
+ *
+ * -- "OpenOffice.org's Documentation of the Microsoft
+ * Excel File Format"
+ */
+ private function readDateMode(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ // offset: 0; size: 2; 0 = base 1900, 1 = base 1904
+ Date::setExcelCalendar(Date::CALENDAR_WINDOWS_1900);
+ if (ord($recordData[0]) == 1) {
+ Date::setExcelCalendar(Date::CALENDAR_MAC_1904);
+ }
+ }
+
+ /**
+ * Read a FONT record.
+ */
+ private function readFont(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ if (!$this->readDataOnly) {
+ $objFont = new Font();
+
+ // offset: 0; size: 2; height of the font (in twips = 1/20 of a point)
+ $size = self::getUInt2d($recordData, 0);
+ $objFont->setSize($size / 20);
+
+ // offset: 2; size: 2; option flags
+ // bit: 0; mask 0x0001; bold (redundant in BIFF5-BIFF8)
+ // bit: 1; mask 0x0002; italic
+ $isItalic = (0x0002 & self::getUInt2d($recordData, 2)) >> 1;
+ if ($isItalic) {
+ $objFont->setItalic(true);
+ }
+
+ // bit: 2; mask 0x0004; underlined (redundant in BIFF5-BIFF8)
+ // bit: 3; mask 0x0008; strikethrough
+ $isStrike = (0x0008 & self::getUInt2d($recordData, 2)) >> 3;
+ if ($isStrike) {
+ $objFont->setStrikethrough(true);
+ }
+
+ // offset: 4; size: 2; colour index
+ $colorIndex = self::getUInt2d($recordData, 4);
+ $objFont->colorIndex = $colorIndex;
+
+ // offset: 6; size: 2; font weight
+ $weight = self::getUInt2d($recordData, 6);
+ switch ($weight) {
+ case 0x02BC:
+ $objFont->setBold(true);
+
+ break;
+ }
+
+ // offset: 8; size: 2; escapement type
+ $escapement = self::getUInt2d($recordData, 8);
+ switch ($escapement) {
+ case 0x0001:
+ $objFont->setSuperscript(true);
+
+ break;
+ case 0x0002:
+ $objFont->setSubscript(true);
+
+ break;
+ }
+
+ // offset: 10; size: 1; underline type
+ $underlineType = ord($recordData[10]);
+ switch ($underlineType) {
+ case 0x00:
+ break; // no underline
+ case 0x01:
+ $objFont->setUnderline(Font::UNDERLINE_SINGLE);
+
+ break;
+ case 0x02:
+ $objFont->setUnderline(Font::UNDERLINE_DOUBLE);
+
+ break;
+ case 0x21:
+ $objFont->setUnderline(Font::UNDERLINE_SINGLEACCOUNTING);
+
+ break;
+ case 0x22:
+ $objFont->setUnderline(Font::UNDERLINE_DOUBLEACCOUNTING);
+
+ break;
+ }
+
+ // offset: 11; size: 1; font family
+ // offset: 12; size: 1; character set
+ // offset: 13; size: 1; not used
+ // offset: 14; size: var; font name
+ if ($this->version == self::XLS_BIFF8) {
+ $string = self::readUnicodeStringShort(substr($recordData, 14));
+ } else {
+ $string = $this->readByteStringShort(substr($recordData, 14));
+ }
+ $objFont->setName($string['value']);
+
+ $this->objFonts[] = $objFont;
+ }
+ }
+
+ /**
+ * FORMAT.
+ *
+ * This record contains information about a number format.
+ * All FORMAT records occur together in a sequential list.
+ *
+ * In BIFF2-BIFF4 other records referencing a FORMAT record
+ * contain a zero-based index into this list. From BIFF5 on
+ * the FORMAT record contains the index itself that will be
+ * used by other records.
+ *
+ * -- "OpenOffice.org's Documentation of the Microsoft
+ * Excel File Format"
+ */
+ private function readFormat(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ if (!$this->readDataOnly) {
+ $indexCode = self::getUInt2d($recordData, 0);
+
+ if ($this->version == self::XLS_BIFF8) {
+ $string = self::readUnicodeStringLong(substr($recordData, 2));
+ } else {
+ // BIFF7
+ $string = $this->readByteStringShort(substr($recordData, 2));
+ }
+
+ $formatString = $string['value'];
+ $this->formats[$indexCode] = $formatString;
+ }
+ }
+
+ /**
+ * XF - Extended Format.
+ *
+ * This record contains formatting information for cells, rows, columns or styles.
+ * According to https://support.microsoft.com/en-us/help/147732 there are always at least 15 cell style XF
+ * and 1 cell XF.
+ * Inspection of Excel files generated by MS Office Excel shows that XF records 0-14 are cell style XF
+ * and XF record 15 is a cell XF
+ * We only read the first cell style XF and skip the remaining cell style XF records
+ * We read all cell XF records.
+ *
+ * -- "OpenOffice.org's Documentation of the Microsoft
+ * Excel File Format"
+ */
+ private function readXf(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ $objStyle = new Style();
+
+ if (!$this->readDataOnly) {
+ // offset: 0; size: 2; Index to FONT record
+ if (self::getUInt2d($recordData, 0) < 4) {
+ $fontIndex = self::getUInt2d($recordData, 0);
+ } else {
+ // this has to do with that index 4 is omitted in all BIFF versions for some strange reason
+ // check the OpenOffice documentation of the FONT record
+ $fontIndex = self::getUInt2d($recordData, 0) - 1;
+ }
+ $objStyle->setFont($this->objFonts[$fontIndex]);
+
+ // offset: 2; size: 2; Index to FORMAT record
+ $numberFormatIndex = self::getUInt2d($recordData, 2);
+ if (isset($this->formats[$numberFormatIndex])) {
+ // then we have user-defined format code
+ $numberFormat = ['formatCode' => $this->formats[$numberFormatIndex]];
+ } elseif (($code = NumberFormat::builtInFormatCode($numberFormatIndex)) !== '') {
+ // then we have built-in format code
+ $numberFormat = ['formatCode' => $code];
+ } else {
+ // we set the general format code
+ $numberFormat = ['formatCode' => 'General'];
+ }
+ $objStyle->getNumberFormat()->setFormatCode($numberFormat['formatCode']);
+
+ // offset: 4; size: 2; XF type, cell protection, and parent style XF
+ // bit 2-0; mask 0x0007; XF_TYPE_PROT
+ $xfTypeProt = self::getUInt2d($recordData, 4);
+ // bit 0; mask 0x01; 1 = cell is locked
+ $isLocked = (0x01 & $xfTypeProt) >> 0;
+ $objStyle->getProtection()->setLocked($isLocked ? Protection::PROTECTION_INHERIT : Protection::PROTECTION_UNPROTECTED);
+
+ // bit 1; mask 0x02; 1 = Formula is hidden
+ $isHidden = (0x02 & $xfTypeProt) >> 1;
+ $objStyle->getProtection()->setHidden($isHidden ? Protection::PROTECTION_PROTECTED : Protection::PROTECTION_UNPROTECTED);
+
+ // bit 2; mask 0x04; 0 = Cell XF, 1 = Cell Style XF
+ $isCellStyleXf = (0x04 & $xfTypeProt) >> 2;
+
+ // offset: 6; size: 1; Alignment and text break
+ // bit 2-0, mask 0x07; horizontal alignment
+ $horAlign = (0x07 & ord($recordData[6])) >> 0;
+ switch ($horAlign) {
+ case 0:
+ $objStyle->getAlignment()->setHorizontal(Alignment::HORIZONTAL_GENERAL);
+
+ break;
+ case 1:
+ $objStyle->getAlignment()->setHorizontal(Alignment::HORIZONTAL_LEFT);
+
+ break;
+ case 2:
+ $objStyle->getAlignment()->setHorizontal(Alignment::HORIZONTAL_CENTER);
+
+ break;
+ case 3:
+ $objStyle->getAlignment()->setHorizontal(Alignment::HORIZONTAL_RIGHT);
+
+ break;
+ case 4:
+ $objStyle->getAlignment()->setHorizontal(Alignment::HORIZONTAL_FILL);
+
+ break;
+ case 5:
+ $objStyle->getAlignment()->setHorizontal(Alignment::HORIZONTAL_JUSTIFY);
+
+ break;
+ case 6:
+ $objStyle->getAlignment()->setHorizontal(Alignment::HORIZONTAL_CENTER_CONTINUOUS);
+
+ break;
+ }
+ // bit 3, mask 0x08; wrap text
+ $wrapText = (0x08 & ord($recordData[6])) >> 3;
+ switch ($wrapText) {
+ case 0:
+ $objStyle->getAlignment()->setWrapText(false);
+
+ break;
+ case 1:
+ $objStyle->getAlignment()->setWrapText(true);
+
+ break;
+ }
+ // bit 6-4, mask 0x70; vertical alignment
+ $vertAlign = (0x70 & ord($recordData[6])) >> 4;
+ switch ($vertAlign) {
+ case 0:
+ $objStyle->getAlignment()->setVertical(Alignment::VERTICAL_TOP);
+
+ break;
+ case 1:
+ $objStyle->getAlignment()->setVertical(Alignment::VERTICAL_CENTER);
+
+ break;
+ case 2:
+ $objStyle->getAlignment()->setVertical(Alignment::VERTICAL_BOTTOM);
+
+ break;
+ case 3:
+ $objStyle->getAlignment()->setVertical(Alignment::VERTICAL_JUSTIFY);
+
+ break;
+ }
+
+ if ($this->version == self::XLS_BIFF8) {
+ // offset: 7; size: 1; XF_ROTATION: Text rotation angle
+ $angle = ord($recordData[7]);
+ $rotation = 0;
+ if ($angle <= 90) {
+ $rotation = $angle;
+ } elseif ($angle <= 180) {
+ $rotation = 90 - $angle;
+ } elseif ($angle == 255) {
+ $rotation = -165;
+ }
+ $objStyle->getAlignment()->setTextRotation($rotation);
+
+ // offset: 8; size: 1; Indentation, shrink to cell size, and text direction
+ // bit: 3-0; mask: 0x0F; indent level
+ $indent = (0x0F & ord($recordData[8])) >> 0;
+ $objStyle->getAlignment()->setIndent($indent);
+
+ // bit: 4; mask: 0x10; 1 = shrink content to fit into cell
+ $shrinkToFit = (0x10 & ord($recordData[8])) >> 4;
+ switch ($shrinkToFit) {
+ case 0:
+ $objStyle->getAlignment()->setShrinkToFit(false);
+
+ break;
+ case 1:
+ $objStyle->getAlignment()->setShrinkToFit(true);
+
+ break;
+ }
+
+ // offset: 9; size: 1; Flags used for attribute groups
+
+ // offset: 10; size: 4; Cell border lines and background area
+ // bit: 3-0; mask: 0x0000000F; left style
+ if ($bordersLeftStyle = Xls\Style\Border::lookup((0x0000000F & self::getInt4d($recordData, 10)) >> 0)) {
+ $objStyle->getBorders()->getLeft()->setBorderStyle($bordersLeftStyle);
+ }
+ // bit: 7-4; mask: 0x000000F0; right style
+ if ($bordersRightStyle = Xls\Style\Border::lookup((0x000000F0 & self::getInt4d($recordData, 10)) >> 4)) {
+ $objStyle->getBorders()->getRight()->setBorderStyle($bordersRightStyle);
+ }
+ // bit: 11-8; mask: 0x00000F00; top style
+ if ($bordersTopStyle = Xls\Style\Border::lookup((0x00000F00 & self::getInt4d($recordData, 10)) >> 8)) {
+ $objStyle->getBorders()->getTop()->setBorderStyle($bordersTopStyle);
+ }
+ // bit: 15-12; mask: 0x0000F000; bottom style
+ if ($bordersBottomStyle = Xls\Style\Border::lookup((0x0000F000 & self::getInt4d($recordData, 10)) >> 12)) {
+ $objStyle->getBorders()->getBottom()->setBorderStyle($bordersBottomStyle);
+ }
+ // bit: 22-16; mask: 0x007F0000; left color
+ $objStyle->getBorders()->getLeft()->colorIndex = (0x007F0000 & self::getInt4d($recordData, 10)) >> 16;
+
+ // bit: 29-23; mask: 0x3F800000; right color
+ $objStyle->getBorders()->getRight()->colorIndex = (0x3F800000 & self::getInt4d($recordData, 10)) >> 23;
+
+ // bit: 30; mask: 0x40000000; 1 = diagonal line from top left to right bottom
+ $diagonalDown = (0x40000000 & self::getInt4d($recordData, 10)) >> 30 ? true : false;
+
+ // bit: 31; mask: 0x80000000; 1 = diagonal line from bottom left to top right
+ $diagonalUp = (0x80000000 & self::getInt4d($recordData, 10)) >> 31 ? true : false;
+
+ if ($diagonalUp == false && $diagonalDown == false) {
+ $objStyle->getBorders()->setDiagonalDirection(Borders::DIAGONAL_NONE);
+ } elseif ($diagonalUp == true && $diagonalDown == false) {
+ $objStyle->getBorders()->setDiagonalDirection(Borders::DIAGONAL_UP);
+ } elseif ($diagonalUp == false && $diagonalDown == true) {
+ $objStyle->getBorders()->setDiagonalDirection(Borders::DIAGONAL_DOWN);
+ } elseif ($diagonalUp == true && $diagonalDown == true) {
+ $objStyle->getBorders()->setDiagonalDirection(Borders::DIAGONAL_BOTH);
+ }
+
+ // offset: 14; size: 4;
+ // bit: 6-0; mask: 0x0000007F; top color
+ $objStyle->getBorders()->getTop()->colorIndex = (0x0000007F & self::getInt4d($recordData, 14)) >> 0;
+
+ // bit: 13-7; mask: 0x00003F80; bottom color
+ $objStyle->getBorders()->getBottom()->colorIndex = (0x00003F80 & self::getInt4d($recordData, 14)) >> 7;
+
+ // bit: 20-14; mask: 0x001FC000; diagonal color
+ $objStyle->getBorders()->getDiagonal()->colorIndex = (0x001FC000 & self::getInt4d($recordData, 14)) >> 14;
+
+ // bit: 24-21; mask: 0x01E00000; diagonal style
+ if ($bordersDiagonalStyle = Xls\Style\Border::lookup((0x01E00000 & self::getInt4d($recordData, 14)) >> 21)) {
+ $objStyle->getBorders()->getDiagonal()->setBorderStyle($bordersDiagonalStyle);
+ }
+
+ // bit: 31-26; mask: 0xFC000000 fill pattern
+ if ($fillType = Xls\Style\FillPattern::lookup((0xFC000000 & self::getInt4d($recordData, 14)) >> 26)) {
+ $objStyle->getFill()->setFillType($fillType);
+ }
+ // offset: 18; size: 2; pattern and background colour
+ // bit: 6-0; mask: 0x007F; color index for pattern color
+ $objStyle->getFill()->startcolorIndex = (0x007F & self::getUInt2d($recordData, 18)) >> 0;
+
+ // bit: 13-7; mask: 0x3F80; color index for pattern background
+ $objStyle->getFill()->endcolorIndex = (0x3F80 & self::getUInt2d($recordData, 18)) >> 7;
+ } else {
+ // BIFF5
+
+ // offset: 7; size: 1; Text orientation and flags
+ $orientationAndFlags = ord($recordData[7]);
+
+ // bit: 1-0; mask: 0x03; XF_ORIENTATION: Text orientation
+ $xfOrientation = (0x03 & $orientationAndFlags) >> 0;
+ switch ($xfOrientation) {
+ case 0:
+ $objStyle->getAlignment()->setTextRotation(0);
+
+ break;
+ case 1:
+ $objStyle->getAlignment()->setTextRotation(-165);
+
+ break;
+ case 2:
+ $objStyle->getAlignment()->setTextRotation(90);
+
+ break;
+ case 3:
+ $objStyle->getAlignment()->setTextRotation(-90);
+
+ break;
+ }
+
+ // offset: 8; size: 4; cell border lines and background area
+ $borderAndBackground = self::getInt4d($recordData, 8);
+
+ // bit: 6-0; mask: 0x0000007F; color index for pattern color
+ $objStyle->getFill()->startcolorIndex = (0x0000007F & $borderAndBackground) >> 0;
+
+ // bit: 13-7; mask: 0x00003F80; color index for pattern background
+ $objStyle->getFill()->endcolorIndex = (0x00003F80 & $borderAndBackground) >> 7;
+
+ // bit: 21-16; mask: 0x003F0000; fill pattern
+ $objStyle->getFill()->setFillType(Xls\Style\FillPattern::lookup((0x003F0000 & $borderAndBackground) >> 16));
+
+ // bit: 24-22; mask: 0x01C00000; bottom line style
+ $objStyle->getBorders()->getBottom()->setBorderStyle(Xls\Style\Border::lookup((0x01C00000 & $borderAndBackground) >> 22));
+
+ // bit: 31-25; mask: 0xFE000000; bottom line color
+ $objStyle->getBorders()->getBottom()->colorIndex = (0xFE000000 & $borderAndBackground) >> 25;
+
+ // offset: 12; size: 4; cell border lines
+ $borderLines = self::getInt4d($recordData, 12);
+
+ // bit: 2-0; mask: 0x00000007; top line style
+ $objStyle->getBorders()->getTop()->setBorderStyle(Xls\Style\Border::lookup((0x00000007 & $borderLines) >> 0));
+
+ // bit: 5-3; mask: 0x00000038; left line style
+ $objStyle->getBorders()->getLeft()->setBorderStyle(Xls\Style\Border::lookup((0x00000038 & $borderLines) >> 3));
+
+ // bit: 8-6; mask: 0x000001C0; right line style
+ $objStyle->getBorders()->getRight()->setBorderStyle(Xls\Style\Border::lookup((0x000001C0 & $borderLines) >> 6));
+
+ // bit: 15-9; mask: 0x0000FE00; top line color index
+ $objStyle->getBorders()->getTop()->colorIndex = (0x0000FE00 & $borderLines) >> 9;
+
+ // bit: 22-16; mask: 0x007F0000; left line color index
+ $objStyle->getBorders()->getLeft()->colorIndex = (0x007F0000 & $borderLines) >> 16;
+
+ // bit: 29-23; mask: 0x3F800000; right line color index
+ $objStyle->getBorders()->getRight()->colorIndex = (0x3F800000 & $borderLines) >> 23;
+ }
+
+ // add cellStyleXf or cellXf and update mapping
+ if ($isCellStyleXf) {
+ // we only read one style XF record which is always the first
+ if ($this->xfIndex == 0) {
+ $this->spreadsheet->addCellStyleXf($objStyle);
+ $this->mapCellStyleXfIndex[$this->xfIndex] = 0;
+ }
+ } else {
+ // we read all cell XF records
+ $this->spreadsheet->addCellXf($objStyle);
+ $this->mapCellXfIndex[$this->xfIndex] = count($this->spreadsheet->getCellXfCollection()) - 1;
+ }
+
+ // update XF index for when we read next record
+ ++$this->xfIndex;
+ }
+ }
+
+ private function readXfExt(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ if (!$this->readDataOnly) {
+ // offset: 0; size: 2; 0x087D = repeated header
+
+ // offset: 2; size: 2
+
+ // offset: 4; size: 8; not used
+
+ // offset: 12; size: 2; record version
+
+ // offset: 14; size: 2; index to XF record which this record modifies
+ $ixfe = self::getUInt2d($recordData, 14);
+
+ // offset: 16; size: 2; not used
+
+ // offset: 18; size: 2; number of extension properties that follow
+ $cexts = self::getUInt2d($recordData, 18);
+
+ // start reading the actual extension data
+ $offset = 20;
+ while ($offset < $length) {
+ // extension type
+ $extType = self::getUInt2d($recordData, $offset);
+
+ // extension length
+ $cb = self::getUInt2d($recordData, $offset + 2);
+
+ // extension data
+ $extData = substr($recordData, $offset + 4, $cb);
+
+ switch ($extType) {
+ case 4: // fill start color
+ $xclfType = self::getUInt2d($extData, 0); // color type
+ $xclrValue = substr($extData, 4, 4); // color value (value based on color type)
+
+ if ($xclfType == 2) {
+ $rgb = sprintf('%02X%02X%02X', ord($xclrValue[0]), ord($xclrValue[1]), ord($xclrValue[2]));
+
+ // modify the relevant style property
+ if (isset($this->mapCellXfIndex[$ixfe])) {
+ $fill = $this->spreadsheet->getCellXfByIndex($this->mapCellXfIndex[$ixfe])->getFill();
+ $fill->getStartColor()->setRGB($rgb);
+ $fill->startcolorIndex = null; // normal color index does not apply, discard
+ }
+ }
+
+ break;
+ case 5: // fill end color
+ $xclfType = self::getUInt2d($extData, 0); // color type
+ $xclrValue = substr($extData, 4, 4); // color value (value based on color type)
+
+ if ($xclfType == 2) {
+ $rgb = sprintf('%02X%02X%02X', ord($xclrValue[0]), ord($xclrValue[1]), ord($xclrValue[2]));
+
+ // modify the relevant style property
+ if (isset($this->mapCellXfIndex[$ixfe])) {
+ $fill = $this->spreadsheet->getCellXfByIndex($this->mapCellXfIndex[$ixfe])->getFill();
+ $fill->getEndColor()->setRGB($rgb);
+ $fill->endcolorIndex = null; // normal color index does not apply, discard
+ }
+ }
+
+ break;
+ case 7: // border color top
+ $xclfType = self::getUInt2d($extData, 0); // color type
+ $xclrValue = substr($extData, 4, 4); // color value (value based on color type)
+
+ if ($xclfType == 2) {
+ $rgb = sprintf('%02X%02X%02X', ord($xclrValue[0]), ord($xclrValue[1]), ord($xclrValue[2]));
+
+ // modify the relevant style property
+ if (isset($this->mapCellXfIndex[$ixfe])) {
+ $top = $this->spreadsheet->getCellXfByIndex($this->mapCellXfIndex[$ixfe])->getBorders()->getTop();
+ $top->getColor()->setRGB($rgb);
+ $top->colorIndex = null; // normal color index does not apply, discard
+ }
+ }
+
+ break;
+ case 8: // border color bottom
+ $xclfType = self::getUInt2d($extData, 0); // color type
+ $xclrValue = substr($extData, 4, 4); // color value (value based on color type)
+
+ if ($xclfType == 2) {
+ $rgb = sprintf('%02X%02X%02X', ord($xclrValue[0]), ord($xclrValue[1]), ord($xclrValue[2]));
+
+ // modify the relevant style property
+ if (isset($this->mapCellXfIndex[$ixfe])) {
+ $bottom = $this->spreadsheet->getCellXfByIndex($this->mapCellXfIndex[$ixfe])->getBorders()->getBottom();
+ $bottom->getColor()->setRGB($rgb);
+ $bottom->colorIndex = null; // normal color index does not apply, discard
+ }
+ }
+
+ break;
+ case 9: // border color left
+ $xclfType = self::getUInt2d($extData, 0); // color type
+ $xclrValue = substr($extData, 4, 4); // color value (value based on color type)
+
+ if ($xclfType == 2) {
+ $rgb = sprintf('%02X%02X%02X', ord($xclrValue[0]), ord($xclrValue[1]), ord($xclrValue[2]));
+
+ // modify the relevant style property
+ if (isset($this->mapCellXfIndex[$ixfe])) {
+ $left = $this->spreadsheet->getCellXfByIndex($this->mapCellXfIndex[$ixfe])->getBorders()->getLeft();
+ $left->getColor()->setRGB($rgb);
+ $left->colorIndex = null; // normal color index does not apply, discard
+ }
+ }
+
+ break;
+ case 10: // border color right
+ $xclfType = self::getUInt2d($extData, 0); // color type
+ $xclrValue = substr($extData, 4, 4); // color value (value based on color type)
+
+ if ($xclfType == 2) {
+ $rgb = sprintf('%02X%02X%02X', ord($xclrValue[0]), ord($xclrValue[1]), ord($xclrValue[2]));
+
+ // modify the relevant style property
+ if (isset($this->mapCellXfIndex[$ixfe])) {
+ $right = $this->spreadsheet->getCellXfByIndex($this->mapCellXfIndex[$ixfe])->getBorders()->getRight();
+ $right->getColor()->setRGB($rgb);
+ $right->colorIndex = null; // normal color index does not apply, discard
+ }
+ }
+
+ break;
+ case 11: // border color diagonal
+ $xclfType = self::getUInt2d($extData, 0); // color type
+ $xclrValue = substr($extData, 4, 4); // color value (value based on color type)
+
+ if ($xclfType == 2) {
+ $rgb = sprintf('%02X%02X%02X', ord($xclrValue[0]), ord($xclrValue[1]), ord($xclrValue[2]));
+
+ // modify the relevant style property
+ if (isset($this->mapCellXfIndex[$ixfe])) {
+ $diagonal = $this->spreadsheet->getCellXfByIndex($this->mapCellXfIndex[$ixfe])->getBorders()->getDiagonal();
+ $diagonal->getColor()->setRGB($rgb);
+ $diagonal->colorIndex = null; // normal color index does not apply, discard
+ }
+ }
+
+ break;
+ case 13: // font color
+ $xclfType = self::getUInt2d($extData, 0); // color type
+ $xclrValue = substr($extData, 4, 4); // color value (value based on color type)
+
+ if ($xclfType == 2) {
+ $rgb = sprintf('%02X%02X%02X', ord($xclrValue[0]), ord($xclrValue[1]), ord($xclrValue[2]));
+
+ // modify the relevant style property
+ if (isset($this->mapCellXfIndex[$ixfe])) {
+ $font = $this->spreadsheet->getCellXfByIndex($this->mapCellXfIndex[$ixfe])->getFont();
+ $font->getColor()->setRGB($rgb);
+ $font->colorIndex = null; // normal color index does not apply, discard
+ }
+ }
+
+ break;
+ }
+
+ $offset += $cb;
+ }
+ }
+ }
+
+ /**
+ * Read STYLE record.
+ */
+ private function readStyle(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ if (!$this->readDataOnly) {
+ // offset: 0; size: 2; index to XF record and flag for built-in style
+ $ixfe = self::getUInt2d($recordData, 0);
+
+ // bit: 11-0; mask 0x0FFF; index to XF record
+ $xfIndex = (0x0FFF & $ixfe) >> 0;
+
+ // bit: 15; mask 0x8000; 0 = user-defined style, 1 = built-in style
+ $isBuiltIn = (bool) ((0x8000 & $ixfe) >> 15);
+
+ if ($isBuiltIn) {
+ // offset: 2; size: 1; identifier for built-in style
+ $builtInId = ord($recordData[2]);
+
+ switch ($builtInId) {
+ case 0x00:
+ // currently, we are not using this for anything
+ break;
+ default:
+ break;
+ }
+ }
+ // user-defined; not supported by PhpSpreadsheet
+ }
+ }
+
+ /**
+ * Read PALETTE record.
+ */
+ private function readPalette(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ if (!$this->readDataOnly) {
+ // offset: 0; size: 2; number of following colors
+ $nm = self::getUInt2d($recordData, 0);
+
+ // list of RGB colors
+ for ($i = 0; $i < $nm; ++$i) {
+ $rgb = substr($recordData, 2 + 4 * $i, 4);
+ $this->palette[] = self::readRGB($rgb);
+ }
+ }
+ }
+
+ /**
+ * SHEET.
+ *
+ * This record is located in the Workbook Globals
+ * Substream and represents a sheet inside the workbook.
+ * One SHEET record is written for each sheet. It stores the
+ * sheet name and a stream offset to the BOF record of the
+ * respective Sheet Substream within the Workbook Stream.
+ *
+ * -- "OpenOffice.org's Documentation of the Microsoft
+ * Excel File Format"
+ */
+ private function readSheet(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // offset: 0; size: 4; absolute stream position of the BOF record of the sheet
+ // NOTE: not encrypted
+ $rec_offset = self::getInt4d($this->data, $this->pos + 4);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ // offset: 4; size: 1; sheet state
+ switch (ord($recordData[4])) {
+ case 0x00:
+ $sheetState = Worksheet::SHEETSTATE_VISIBLE;
+
+ break;
+ case 0x01:
+ $sheetState = Worksheet::SHEETSTATE_HIDDEN;
+
+ break;
+ case 0x02:
+ $sheetState = Worksheet::SHEETSTATE_VERYHIDDEN;
+
+ break;
+ default:
+ $sheetState = Worksheet::SHEETSTATE_VISIBLE;
+
+ break;
+ }
+
+ // offset: 5; size: 1; sheet type
+ $sheetType = ord($recordData[5]);
+
+ // offset: 6; size: var; sheet name
+ if ($this->version == self::XLS_BIFF8) {
+ $string = self::readUnicodeStringShort(substr($recordData, 6));
+ $rec_name = $string['value'];
+ } elseif ($this->version == self::XLS_BIFF7) {
+ $string = $this->readByteStringShort(substr($recordData, 6));
+ $rec_name = $string['value'];
+ }
+
+ $this->sheets[] = [
+ 'name' => $rec_name,
+ 'offset' => $rec_offset,
+ 'sheetState' => $sheetState,
+ 'sheetType' => $sheetType,
+ ];
+ }
+
+ /**
+ * Read EXTERNALBOOK record.
+ */
+ private function readExternalBook(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ // offset within record data
+ $offset = 0;
+
+ // there are 4 types of records
+ if (strlen($recordData) > 4) {
+ // external reference
+ // offset: 0; size: 2; number of sheet names ($nm)
+ $nm = self::getUInt2d($recordData, 0);
+ $offset += 2;
+
+ // offset: 2; size: var; encoded URL without sheet name (Unicode string, 16-bit length)
+ $encodedUrlString = self::readUnicodeStringLong(substr($recordData, 2));
+ $offset += $encodedUrlString['size'];
+
+ // offset: var; size: var; list of $nm sheet names (Unicode strings, 16-bit length)
+ $externalSheetNames = [];
+ for ($i = 0; $i < $nm; ++$i) {
+ $externalSheetNameString = self::readUnicodeStringLong(substr($recordData, $offset));
+ $externalSheetNames[] = $externalSheetNameString['value'];
+ $offset += $externalSheetNameString['size'];
+ }
+
+ // store the record data
+ $this->externalBooks[] = [
+ 'type' => 'external',
+ 'encodedUrl' => $encodedUrlString['value'],
+ 'externalSheetNames' => $externalSheetNames,
+ ];
+ } elseif (substr($recordData, 2, 2) == pack('CC', 0x01, 0x04)) {
+ // internal reference
+ // offset: 0; size: 2; number of sheet in this document
+ // offset: 2; size: 2; 0x01 0x04
+ $this->externalBooks[] = [
+ 'type' => 'internal',
+ ];
+ } elseif (substr($recordData, 0, 4) == pack('vCC', 0x0001, 0x01, 0x3A)) {
+ // add-in function
+ // offset: 0; size: 2; 0x0001
+ $this->externalBooks[] = [
+ 'type' => 'addInFunction',
+ ];
+ } elseif (substr($recordData, 0, 2) == pack('v', 0x0000)) {
+ // DDE links, OLE links
+ // offset: 0; size: 2; 0x0000
+ // offset: 2; size: var; encoded source document name
+ $this->externalBooks[] = [
+ 'type' => 'DDEorOLE',
+ ];
+ }
+ }
+
+ /**
+ * Read EXTERNNAME record.
+ */
+ private function readExternName(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ // external sheet references provided for named cells
+ if ($this->version == self::XLS_BIFF8) {
+ // offset: 0; size: 2; options
+ $options = self::getUInt2d($recordData, 0);
+
+ // offset: 2; size: 2;
+
+ // offset: 4; size: 2; not used
+
+ // offset: 6; size: var
+ $nameString = self::readUnicodeStringShort(substr($recordData, 6));
+
+ // offset: var; size: var; formula data
+ $offset = 6 + $nameString['size'];
+ $formula = $this->getFormulaFromStructure(substr($recordData, $offset));
+
+ $this->externalNames[] = [
+ 'name' => $nameString['value'],
+ 'formula' => $formula,
+ ];
+ }
+ }
+
+ /**
+ * Read EXTERNSHEET record.
+ */
+ private function readExternSheet(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ // external sheet references provided for named cells
+ if ($this->version == self::XLS_BIFF8) {
+ // offset: 0; size: 2; number of following ref structures
+ $nm = self::getUInt2d($recordData, 0);
+ for ($i = 0; $i < $nm; ++$i) {
+ $this->ref[] = [
+ // offset: 2 + 6 * $i; index to EXTERNALBOOK record
+ 'externalBookIndex' => self::getUInt2d($recordData, 2 + 6 * $i),
+ // offset: 4 + 6 * $i; index to first sheet in EXTERNALBOOK record
+ 'firstSheetIndex' => self::getUInt2d($recordData, 4 + 6 * $i),
+ // offset: 6 + 6 * $i; index to last sheet in EXTERNALBOOK record
+ 'lastSheetIndex' => self::getUInt2d($recordData, 6 + 6 * $i),
+ ];
+ }
+ }
+ }
+
+ /**
+ * DEFINEDNAME.
+ *
+ * This record is part of a Link Table. It contains the name
+ * and the token array of an internal defined name. Token
+ * arrays of defined names contain tokens with aberrant
+ * token classes.
+ *
+ * -- "OpenOffice.org's Documentation of the Microsoft
+ * Excel File Format"
+ */
+ private function readDefinedName(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ if ($this->version == self::XLS_BIFF8) {
+ // retrieves named cells
+
+ // offset: 0; size: 2; option flags
+ $opts = self::getUInt2d($recordData, 0);
+
+ // bit: 5; mask: 0x0020; 0 = user-defined name, 1 = built-in-name
+ $isBuiltInName = (0x0020 & $opts) >> 5;
+
+ // offset: 2; size: 1; keyboard shortcut
+
+ // offset: 3; size: 1; length of the name (character count)
+ $nlen = ord($recordData[3]);
+
+ // offset: 4; size: 2; size of the formula data (it can happen that this is zero)
+ // note: there can also be additional data, this is not included in $flen
+ $flen = self::getUInt2d($recordData, 4);
+
+ // offset: 8; size: 2; 0=Global name, otherwise index to sheet (1-based)
+ $scope = self::getUInt2d($recordData, 8);
+
+ // offset: 14; size: var; Name (Unicode string without length field)
+ $string = self::readUnicodeString(substr($recordData, 14), $nlen);
+
+ // offset: var; size: $flen; formula data
+ $offset = 14 + $string['size'];
+ $formulaStructure = pack('v', $flen) . substr($recordData, $offset);
+
+ try {
+ $formula = $this->getFormulaFromStructure($formulaStructure);
+ } catch (PhpSpreadsheetException $e) {
+ $formula = '';
+ }
+
+ $this->definedname[] = [
+ 'isBuiltInName' => $isBuiltInName,
+ 'name' => $string['value'],
+ 'formula' => $formula,
+ 'scope' => $scope,
+ ];
+ }
+ }
+
+ /**
+ * Read MSODRAWINGGROUP record.
+ */
+ private function readMsoDrawingGroup(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+
+ // get spliced record data
+ $splicedRecordData = $this->getSplicedRecordData();
+ $recordData = $splicedRecordData['recordData'];
+
+ $this->drawingGroupData .= $recordData;
+ }
+
+ /**
+ * SST - Shared String Table.
+ *
+ * This record contains a list of all strings used anywhere
+ * in the workbook. Each string occurs only once. The
+ * workbook uses indexes into the list to reference the
+ * strings.
+ *
+ * -- "OpenOffice.org's Documentation of the Microsoft
+ * Excel File Format"
+ */
+ private function readSst(): void
+ {
+ // offset within (spliced) record data
+ $pos = 0;
+
+ // get spliced record data
+ $splicedRecordData = $this->getSplicedRecordData();
+
+ $recordData = $splicedRecordData['recordData'];
+ $spliceOffsets = $splicedRecordData['spliceOffsets'];
+
+ // offset: 0; size: 4; total number of strings in the workbook
+ $pos += 4;
+
+ // offset: 4; size: 4; number of following strings ($nm)
+ $nm = self::getInt4d($recordData, 4);
+ $pos += 4;
+
+ // loop through the Unicode strings (16-bit length)
+ for ($i = 0; $i < $nm; ++$i) {
+ // number of characters in the Unicode string
+ $numChars = self::getUInt2d($recordData, $pos);
+ $pos += 2;
+
+ // option flags
+ $optionFlags = ord($recordData[$pos]);
+ ++$pos;
+
+ // bit: 0; mask: 0x01; 0 = compressed; 1 = uncompressed
+ $isCompressed = (($optionFlags & 0x01) == 0);
+
+ // bit: 2; mask: 0x02; 0 = ordinary; 1 = Asian phonetic
+ $hasAsian = (($optionFlags & 0x04) != 0);
+
+ // bit: 3; mask: 0x03; 0 = ordinary; 1 = Rich-Text
+ $hasRichText = (($optionFlags & 0x08) != 0);
+
+ if ($hasRichText) {
+ // number of Rich-Text formatting runs
+ $formattingRuns = self::getUInt2d($recordData, $pos);
+ $pos += 2;
+ }
+
+ if ($hasAsian) {
+ // size of Asian phonetic setting
+ $extendedRunLength = self::getInt4d($recordData, $pos);
+ $pos += 4;
+ }
+
+ // expected byte length of character array if not split
+ $len = ($isCompressed) ? $numChars : $numChars * 2;
+
+ // look up limit position
+ foreach ($spliceOffsets as $spliceOffset) {
+ // it can happen that the string is empty, therefore we need
+ // <= and not just <
+ if ($pos <= $spliceOffset) {
+ $limitpos = $spliceOffset;
+
+ break;
+ }
+ }
+
+ if ($pos + $len <= $limitpos) {
+ // character array is not split between records
+
+ $retstr = substr($recordData, $pos, $len);
+ $pos += $len;
+ } else {
+ // character array is split between records
+
+ // first part of character array
+ $retstr = substr($recordData, $pos, $limitpos - $pos);
+
+ $bytesRead = $limitpos - $pos;
+
+ // remaining characters in Unicode string
+ $charsLeft = $numChars - (($isCompressed) ? $bytesRead : ($bytesRead / 2));
+
+ $pos = $limitpos;
+
+ // keep reading the characters
+ while ($charsLeft > 0) {
+ // look up next limit position, in case the string span more than one continue record
+ foreach ($spliceOffsets as $spliceOffset) {
+ if ($pos < $spliceOffset) {
+ $limitpos = $spliceOffset;
+
+ break;
+ }
+ }
+
+ // repeated option flags
+ // OpenOffice.org documentation 5.21
+ $option = ord($recordData[$pos]);
+ ++$pos;
+
+ if ($isCompressed && ($option == 0)) {
+ // 1st fragment compressed
+ // this fragment compressed
+ $len = min($charsLeft, $limitpos - $pos);
+ $retstr .= substr($recordData, $pos, $len);
+ $charsLeft -= $len;
+ $isCompressed = true;
+ } elseif (!$isCompressed && ($option != 0)) {
+ // 1st fragment uncompressed
+ // this fragment uncompressed
+ $len = min($charsLeft * 2, $limitpos - $pos);
+ $retstr .= substr($recordData, $pos, $len);
+ $charsLeft -= $len / 2;
+ $isCompressed = false;
+ } elseif (!$isCompressed && ($option == 0)) {
+ // 1st fragment uncompressed
+ // this fragment compressed
+ $len = min($charsLeft, $limitpos - $pos);
+ for ($j = 0; $j < $len; ++$j) {
+ $retstr .= $recordData[$pos + $j]
+ . chr(0);
+ }
+ $charsLeft -= $len;
+ $isCompressed = false;
+ } else {
+ // 1st fragment compressed
+ // this fragment uncompressed
+ $newstr = '';
+ $jMax = strlen($retstr);
+ for ($j = 0; $j < $jMax; ++$j) {
+ $newstr .= $retstr[$j] . chr(0);
+ }
+ $retstr = $newstr;
+ $len = min($charsLeft * 2, $limitpos - $pos);
+ $retstr .= substr($recordData, $pos, $len);
+ $charsLeft -= $len / 2;
+ $isCompressed = false;
+ }
+
+ $pos += $len;
+ }
+ }
+
+ // convert to UTF-8
+ $retstr = self::encodeUTF16($retstr, $isCompressed);
+
+ // read additional Rich-Text information, if any
+ $fmtRuns = [];
+ if ($hasRichText) {
+ // list of formatting runs
+ for ($j = 0; $j < $formattingRuns; ++$j) {
+ // first formatted character; zero-based
+ $charPos = self::getUInt2d($recordData, $pos + $j * 4);
+
+ // index to font record
+ $fontIndex = self::getUInt2d($recordData, $pos + 2 + $j * 4);
+
+ $fmtRuns[] = [
+ 'charPos' => $charPos,
+ 'fontIndex' => $fontIndex,
+ ];
+ }
+ $pos += 4 * $formattingRuns;
+ }
+
+ // read additional Asian phonetics information, if any
+ if ($hasAsian) {
+ // For Asian phonetic settings, we skip the extended string data
+ $pos += $extendedRunLength;
+ }
+
+ // store the shared sting
+ $this->sst[] = [
+ 'value' => $retstr,
+ 'fmtRuns' => $fmtRuns,
+ ];
+ }
+
+ // getSplicedRecordData() takes care of moving current position in data stream
+ }
+
+ /**
+ * Read PRINTGRIDLINES record.
+ */
+ private function readPrintGridlines(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ if ($this->version == self::XLS_BIFF8 && !$this->readDataOnly) {
+ // offset: 0; size: 2; 0 = do not print sheet grid lines; 1 = print sheet gridlines
+ $printGridlines = (bool) self::getUInt2d($recordData, 0);
+ $this->phpSheet->setPrintGridlines($printGridlines);
+ }
+ }
+
+ /**
+ * Read DEFAULTROWHEIGHT record.
+ */
+ private function readDefaultRowHeight(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ // offset: 0; size: 2; option flags
+ // offset: 2; size: 2; default height for unused rows, (twips 1/20 point)
+ $height = self::getUInt2d($recordData, 2);
+ $this->phpSheet->getDefaultRowDimension()->setRowHeight($height / 20);
+ }
+
+ /**
+ * Read SHEETPR record.
+ */
+ private function readSheetPr(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ // offset: 0; size: 2
+
+ // bit: 6; mask: 0x0040; 0 = outline buttons above outline group
+ $isSummaryBelow = (0x0040 & self::getUInt2d($recordData, 0)) >> 6;
+ $this->phpSheet->setShowSummaryBelow($isSummaryBelow);
+
+ // bit: 7; mask: 0x0080; 0 = outline buttons left of outline group
+ $isSummaryRight = (0x0080 & self::getUInt2d($recordData, 0)) >> 7;
+ $this->phpSheet->setShowSummaryRight($isSummaryRight);
+
+ // bit: 8; mask: 0x100; 0 = scale printout in percent, 1 = fit printout to number of pages
+ // this corresponds to radio button setting in page setup dialog in Excel
+ $this->isFitToPages = (bool) ((0x0100 & self::getUInt2d($recordData, 0)) >> 8);
+ }
+
+ /**
+ * Read HORIZONTALPAGEBREAKS record.
+ */
+ private function readHorizontalPageBreaks(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ if ($this->version == self::XLS_BIFF8 && !$this->readDataOnly) {
+ // offset: 0; size: 2; number of the following row index structures
+ $nm = self::getUInt2d($recordData, 0);
+
+ // offset: 2; size: 6 * $nm; list of $nm row index structures
+ for ($i = 0; $i < $nm; ++$i) {
+ $r = self::getUInt2d($recordData, 2 + 6 * $i);
+ $cf = self::getUInt2d($recordData, 2 + 6 * $i + 2);
+ $cl = self::getUInt2d($recordData, 2 + 6 * $i + 4);
+
+ // not sure why two column indexes are necessary?
+ $this->phpSheet->setBreakByColumnAndRow($cf + 1, $r, Worksheet::BREAK_ROW);
+ }
+ }
+ }
+
+ /**
+ * Read VERTICALPAGEBREAKS record.
+ */
+ private function readVerticalPageBreaks(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ if ($this->version == self::XLS_BIFF8 && !$this->readDataOnly) {
+ // offset: 0; size: 2; number of the following column index structures
+ $nm = self::getUInt2d($recordData, 0);
+
+ // offset: 2; size: 6 * $nm; list of $nm row index structures
+ for ($i = 0; $i < $nm; ++$i) {
+ $c = self::getUInt2d($recordData, 2 + 6 * $i);
+ $rf = self::getUInt2d($recordData, 2 + 6 * $i + 2);
+ $rl = self::getUInt2d($recordData, 2 + 6 * $i + 4);
+
+ // not sure why two row indexes are necessary?
+ $this->phpSheet->setBreakByColumnAndRow($c + 1, $rf, Worksheet::BREAK_COLUMN);
+ }
+ }
+ }
+
+ /**
+ * Read HEADER record.
+ */
+ private function readHeader(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ if (!$this->readDataOnly) {
+ // offset: 0; size: var
+ // realized that $recordData can be empty even when record exists
+ if ($recordData) {
+ if ($this->version == self::XLS_BIFF8) {
+ $string = self::readUnicodeStringLong($recordData);
+ } else {
+ $string = $this->readByteStringShort($recordData);
+ }
+
+ $this->phpSheet->getHeaderFooter()->setOddHeader($string['value']);
+ $this->phpSheet->getHeaderFooter()->setEvenHeader($string['value']);
+ }
+ }
+ }
+
+ /**
+ * Read FOOTER record.
+ */
+ private function readFooter(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ if (!$this->readDataOnly) {
+ // offset: 0; size: var
+ // realized that $recordData can be empty even when record exists
+ if ($recordData) {
+ if ($this->version == self::XLS_BIFF8) {
+ $string = self::readUnicodeStringLong($recordData);
+ } else {
+ $string = $this->readByteStringShort($recordData);
+ }
+ $this->phpSheet->getHeaderFooter()->setOddFooter($string['value']);
+ $this->phpSheet->getHeaderFooter()->setEvenFooter($string['value']);
+ }
+ }
+ }
+
+ /**
+ * Read HCENTER record.
+ */
+ private function readHcenter(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ if (!$this->readDataOnly) {
+ // offset: 0; size: 2; 0 = print sheet left aligned, 1 = print sheet centered horizontally
+ $isHorizontalCentered = (bool) self::getUInt2d($recordData, 0);
+
+ $this->phpSheet->getPageSetup()->setHorizontalCentered($isHorizontalCentered);
+ }
+ }
+
+ /**
+ * Read VCENTER record.
+ */
+ private function readVcenter(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ if (!$this->readDataOnly) {
+ // offset: 0; size: 2; 0 = print sheet aligned at top page border, 1 = print sheet vertically centered
+ $isVerticalCentered = (bool) self::getUInt2d($recordData, 0);
+
+ $this->phpSheet->getPageSetup()->setVerticalCentered($isVerticalCentered);
+ }
+ }
+
+ /**
+ * Read LEFTMARGIN record.
+ */
+ private function readLeftMargin(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ if (!$this->readDataOnly) {
+ // offset: 0; size: 8
+ $this->phpSheet->getPageMargins()->setLeft(self::extractNumber($recordData));
+ }
+ }
+
+ /**
+ * Read RIGHTMARGIN record.
+ */
+ private function readRightMargin(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ if (!$this->readDataOnly) {
+ // offset: 0; size: 8
+ $this->phpSheet->getPageMargins()->setRight(self::extractNumber($recordData));
+ }
+ }
+
+ /**
+ * Read TOPMARGIN record.
+ */
+ private function readTopMargin(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ if (!$this->readDataOnly) {
+ // offset: 0; size: 8
+ $this->phpSheet->getPageMargins()->setTop(self::extractNumber($recordData));
+ }
+ }
+
+ /**
+ * Read BOTTOMMARGIN record.
+ */
+ private function readBottomMargin(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ if (!$this->readDataOnly) {
+ // offset: 0; size: 8
+ $this->phpSheet->getPageMargins()->setBottom(self::extractNumber($recordData));
+ }
+ }
+
+ /**
+ * Read PAGESETUP record.
+ */
+ private function readPageSetup(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ if (!$this->readDataOnly) {
+ // offset: 0; size: 2; paper size
+ $paperSize = self::getUInt2d($recordData, 0);
+
+ // offset: 2; size: 2; scaling factor
+ $scale = self::getUInt2d($recordData, 2);
+
+ // offset: 6; size: 2; fit worksheet width to this number of pages, 0 = use as many as needed
+ $fitToWidth = self::getUInt2d($recordData, 6);
+
+ // offset: 8; size: 2; fit worksheet height to this number of pages, 0 = use as many as needed
+ $fitToHeight = self::getUInt2d($recordData, 8);
+
+ // offset: 10; size: 2; option flags
+
+ // bit: 0; mask: 0x0001; 0=down then over, 1=over then down
+ $isOverThenDown = (0x0001 & self::getUInt2d($recordData, 10));
+
+ // bit: 1; mask: 0x0002; 0=landscape, 1=portrait
+ $isPortrait = (0x0002 & self::getUInt2d($recordData, 10)) >> 1;
+
+ // bit: 2; mask: 0x0004; 1= paper size, scaling factor, paper orient. not init
+ // when this bit is set, do not use flags for those properties
+ $isNotInit = (0x0004 & self::getUInt2d($recordData, 10)) >> 2;
+
+ if (!$isNotInit) {
+ $this->phpSheet->getPageSetup()->setPaperSize($paperSize);
+ $this->phpSheet->getPageSetup()->setPageOrder(((bool) $isOverThenDown) ? PageSetup::PAGEORDER_OVER_THEN_DOWN : PageSetup::PAGEORDER_DOWN_THEN_OVER);
+ $this->phpSheet->getPageSetup()->setOrientation(((bool) $isPortrait) ? PageSetup::ORIENTATION_PORTRAIT : PageSetup::ORIENTATION_LANDSCAPE);
+
+ $this->phpSheet->getPageSetup()->setScale($scale, false);
+ $this->phpSheet->getPageSetup()->setFitToPage((bool) $this->isFitToPages);
+ $this->phpSheet->getPageSetup()->setFitToWidth($fitToWidth, false);
+ $this->phpSheet->getPageSetup()->setFitToHeight($fitToHeight, false);
+ }
+
+ // offset: 16; size: 8; header margin (IEEE 754 floating-point value)
+ $marginHeader = self::extractNumber(substr($recordData, 16, 8));
+ $this->phpSheet->getPageMargins()->setHeader($marginHeader);
+
+ // offset: 24; size: 8; footer margin (IEEE 754 floating-point value)
+ $marginFooter = self::extractNumber(substr($recordData, 24, 8));
+ $this->phpSheet->getPageMargins()->setFooter($marginFooter);
+ }
+ }
+
+ /**
+ * PROTECT - Sheet protection (BIFF2 through BIFF8)
+ * if this record is omitted, then it also means no sheet protection.
+ */
+ private function readProtect(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ if ($this->readDataOnly) {
+ return;
+ }
+
+ // offset: 0; size: 2;
+
+ // bit 0, mask 0x01; 1 = sheet is protected
+ $bool = (0x01 & self::getUInt2d($recordData, 0)) >> 0;
+ $this->phpSheet->getProtection()->setSheet((bool) $bool);
+ }
+
+ /**
+ * SCENPROTECT.
+ */
+ private function readScenProtect(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ if ($this->readDataOnly) {
+ return;
+ }
+
+ // offset: 0; size: 2;
+
+ // bit: 0, mask 0x01; 1 = scenarios are protected
+ $bool = (0x01 & self::getUInt2d($recordData, 0)) >> 0;
+
+ $this->phpSheet->getProtection()->setScenarios((bool) $bool);
+ }
+
+ /**
+ * OBJECTPROTECT.
+ */
+ private function readObjectProtect(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ if ($this->readDataOnly) {
+ return;
+ }
+
+ // offset: 0; size: 2;
+
+ // bit: 0, mask 0x01; 1 = objects are protected
+ $bool = (0x01 & self::getUInt2d($recordData, 0)) >> 0;
+
+ $this->phpSheet->getProtection()->setObjects((bool) $bool);
+ }
+
+ /**
+ * PASSWORD - Sheet protection (hashed) password (BIFF2 through BIFF8).
+ */
+ private function readPassword(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ if (!$this->readDataOnly) {
+ // offset: 0; size: 2; 16-bit hash value of password
+ $password = strtoupper(dechex(self::getUInt2d($recordData, 0))); // the hashed password
+ $this->phpSheet->getProtection()->setPassword($password, true);
+ }
+ }
+
+ /**
+ * Read DEFCOLWIDTH record.
+ */
+ private function readDefColWidth(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ // offset: 0; size: 2; default column width
+ $width = self::getUInt2d($recordData, 0);
+ if ($width != 8) {
+ $this->phpSheet->getDefaultColumnDimension()->setWidth($width);
+ }
+ }
+
+ /**
+ * Read COLINFO record.
+ */
+ private function readColInfo(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ if (!$this->readDataOnly) {
+ // offset: 0; size: 2; index to first column in range
+ $firstColumnIndex = self::getUInt2d($recordData, 0);
+
+ // offset: 2; size: 2; index to last column in range
+ $lastColumnIndex = self::getUInt2d($recordData, 2);
+
+ // offset: 4; size: 2; width of the column in 1/256 of the width of the zero character
+ $width = self::getUInt2d($recordData, 4);
+
+ // offset: 6; size: 2; index to XF record for default column formatting
+ $xfIndex = self::getUInt2d($recordData, 6);
+
+ // offset: 8; size: 2; option flags
+ // bit: 0; mask: 0x0001; 1= columns are hidden
+ $isHidden = (0x0001 & self::getUInt2d($recordData, 8)) >> 0;
+
+ // bit: 10-8; mask: 0x0700; outline level of the columns (0 = no outline)
+ $level = (0x0700 & self::getUInt2d($recordData, 8)) >> 8;
+
+ // bit: 12; mask: 0x1000; 1 = collapsed
+ $isCollapsed = (0x1000 & self::getUInt2d($recordData, 8)) >> 12;
+
+ // offset: 10; size: 2; not used
+
+ for ($i = $firstColumnIndex + 1; $i <= $lastColumnIndex + 1; ++$i) {
+ if ($lastColumnIndex == 255 || $lastColumnIndex == 256) {
+ $this->phpSheet->getDefaultColumnDimension()->setWidth($width / 256);
+
+ break;
+ }
+ $this->phpSheet->getColumnDimensionByColumn($i)->setWidth($width / 256);
+ $this->phpSheet->getColumnDimensionByColumn($i)->setVisible(!$isHidden);
+ $this->phpSheet->getColumnDimensionByColumn($i)->setOutlineLevel($level);
+ $this->phpSheet->getColumnDimensionByColumn($i)->setCollapsed($isCollapsed);
+ if (isset($this->mapCellXfIndex[$xfIndex])) {
+ $this->phpSheet->getColumnDimensionByColumn($i)->setXfIndex($this->mapCellXfIndex[$xfIndex]);
+ }
+ }
+ }
+ }
+
+ /**
+ * ROW.
+ *
+ * This record contains the properties of a single row in a
+ * sheet. Rows and cells in a sheet are divided into blocks
+ * of 32 rows.
+ *
+ * -- "OpenOffice.org's Documentation of the Microsoft
+ * Excel File Format"
+ */
+ private function readRow(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ if (!$this->readDataOnly) {
+ // offset: 0; size: 2; index of this row
+ $r = self::getUInt2d($recordData, 0);
+
+ // offset: 2; size: 2; index to column of the first cell which is described by a cell record
+
+ // offset: 4; size: 2; index to column of the last cell which is described by a cell record, increased by 1
+
+ // offset: 6; size: 2;
+
+ // bit: 14-0; mask: 0x7FFF; height of the row, in twips = 1/20 of a point
+ $height = (0x7FFF & self::getUInt2d($recordData, 6)) >> 0;
+
+ // bit: 15: mask: 0x8000; 0 = row has custom height; 1= row has default height
+ $useDefaultHeight = (0x8000 & self::getUInt2d($recordData, 6)) >> 15;
+
+ if (!$useDefaultHeight) {
+ $this->phpSheet->getRowDimension($r + 1)->setRowHeight($height / 20);
+ }
+
+ // offset: 8; size: 2; not used
+
+ // offset: 10; size: 2; not used in BIFF5-BIFF8
+
+ // offset: 12; size: 4; option flags and default row formatting
+
+ // bit: 2-0: mask: 0x00000007; outline level of the row
+ $level = (0x00000007 & self::getInt4d($recordData, 12)) >> 0;
+ $this->phpSheet->getRowDimension($r + 1)->setOutlineLevel($level);
+
+ // bit: 4; mask: 0x00000010; 1 = outline group start or ends here... and is collapsed
+ $isCollapsed = (0x00000010 & self::getInt4d($recordData, 12)) >> 4;
+ $this->phpSheet->getRowDimension($r + 1)->setCollapsed($isCollapsed);
+
+ // bit: 5; mask: 0x00000020; 1 = row is hidden
+ $isHidden = (0x00000020 & self::getInt4d($recordData, 12)) >> 5;
+ $this->phpSheet->getRowDimension($r + 1)->setVisible(!$isHidden);
+
+ // bit: 7; mask: 0x00000080; 1 = row has explicit format
+ $hasExplicitFormat = (0x00000080 & self::getInt4d($recordData, 12)) >> 7;
+
+ // bit: 27-16; mask: 0x0FFF0000; only applies when hasExplicitFormat = 1; index to XF record
+ $xfIndex = (0x0FFF0000 & self::getInt4d($recordData, 12)) >> 16;
+
+ if ($hasExplicitFormat && isset($this->mapCellXfIndex[$xfIndex])) {
+ $this->phpSheet->getRowDimension($r + 1)->setXfIndex($this->mapCellXfIndex[$xfIndex]);
+ }
+ }
+ }
+
+ /**
+ * Read RK record
+ * This record represents a cell that contains an RK value
+ * (encoded integer or floating-point value). If a
+ * floating-point value cannot be encoded to an RK value,
+ * a NUMBER record will be written. This record replaces the
+ * record INTEGER written in BIFF2.
+ *
+ * -- "OpenOffice.org's Documentation of the Microsoft
+ * Excel File Format"
+ */
+ private function readRk(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ // offset: 0; size: 2; index to row
+ $row = self::getUInt2d($recordData, 0);
+
+ // offset: 2; size: 2; index to column
+ $column = self::getUInt2d($recordData, 2);
+ $columnString = Coordinate::stringFromColumnIndex($column + 1);
+
+ // Read cell?
+ if (($this->getReadFilter() !== null) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->phpSheet->getTitle())) {
+ // offset: 4; size: 2; index to XF record
+ $xfIndex = self::getUInt2d($recordData, 4);
+
+ // offset: 6; size: 4; RK value
+ $rknum = self::getInt4d($recordData, 6);
+ $numValue = self::getIEEE754($rknum);
+
+ $cell = $this->phpSheet->getCell($columnString . ($row + 1));
+ if (!$this->readDataOnly && isset($this->mapCellXfIndex[$xfIndex])) {
+ // add style information
+ $cell->setXfIndex($this->mapCellXfIndex[$xfIndex]);
+ }
+
+ // add cell
+ $cell->setValueExplicit($numValue, DataType::TYPE_NUMERIC);
+ }
+ }
+
+ /**
+ * Read LABELSST record
+ * This record represents a cell that contains a string. It
+ * replaces the LABEL record and RSTRING record used in
+ * BIFF2-BIFF5.
+ *
+ * -- "OpenOffice.org's Documentation of the Microsoft
+ * Excel File Format"
+ */
+ private function readLabelSst(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ // offset: 0; size: 2; index to row
+ $row = self::getUInt2d($recordData, 0);
+
+ // offset: 2; size: 2; index to column
+ $column = self::getUInt2d($recordData, 2);
+ $columnString = Coordinate::stringFromColumnIndex($column + 1);
+
+ $emptyCell = true;
+ // Read cell?
+ if (($this->getReadFilter() !== null) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->phpSheet->getTitle())) {
+ // offset: 4; size: 2; index to XF record
+ $xfIndex = self::getUInt2d($recordData, 4);
+
+ // offset: 6; size: 4; index to SST record
+ $index = self::getInt4d($recordData, 6);
+
+ // add cell
+ if (($fmtRuns = $this->sst[$index]['fmtRuns']) && !$this->readDataOnly) {
+ // then we should treat as rich text
+ $richText = new RichText();
+ $charPos = 0;
+ $sstCount = count($this->sst[$index]['fmtRuns']);
+ for ($i = 0; $i <= $sstCount; ++$i) {
+ if (isset($fmtRuns[$i])) {
+ $text = StringHelper::substring($this->sst[$index]['value'], $charPos, $fmtRuns[$i]['charPos'] - $charPos);
+ $charPos = $fmtRuns[$i]['charPos'];
+ } else {
+ $text = StringHelper::substring($this->sst[$index]['value'], $charPos, StringHelper::countCharacters($this->sst[$index]['value']));
+ }
+
+ if (StringHelper::countCharacters($text) > 0) {
+ if ($i == 0) { // first text run, no style
+ $richText->createText($text);
+ } else {
+ $textRun = $richText->createTextRun($text);
+ if (isset($fmtRuns[$i - 1])) {
+ if ($fmtRuns[$i - 1]['fontIndex'] < 4) {
+ $fontIndex = $fmtRuns[$i - 1]['fontIndex'];
+ } else {
+ // this has to do with that index 4 is omitted in all BIFF versions for some strange reason
+ // check the OpenOffice documentation of the FONT record
+ $fontIndex = $fmtRuns[$i - 1]['fontIndex'] - 1;
+ }
+ $textRun->setFont(clone $this->objFonts[$fontIndex]);
+ }
+ }
+ }
+ }
+ if ($this->readEmptyCells || trim($richText->getPlainText()) !== '') {
+ $cell = $this->phpSheet->getCell($columnString . ($row + 1));
+ $cell->setValueExplicit($richText, DataType::TYPE_STRING);
+ $emptyCell = false;
+ }
+ } else {
+ if ($this->readEmptyCells || trim($this->sst[$index]['value']) !== '') {
+ $cell = $this->phpSheet->getCell($columnString . ($row + 1));
+ $cell->setValueExplicit($this->sst[$index]['value'], DataType::TYPE_STRING);
+ $emptyCell = false;
+ }
+ }
+
+ if (!$this->readDataOnly && !$emptyCell && isset($this->mapCellXfIndex[$xfIndex])) {
+ // add style information
+ $cell->setXfIndex($this->mapCellXfIndex[$xfIndex]);
+ }
+ }
+ }
+
+ /**
+ * Read MULRK record
+ * This record represents a cell range containing RK value
+ * cells. All cells are located in the same row.
+ *
+ * -- "OpenOffice.org's Documentation of the Microsoft
+ * Excel File Format"
+ */
+ private function readMulRk(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ // offset: 0; size: 2; index to row
+ $row = self::getUInt2d($recordData, 0);
+
+ // offset: 2; size: 2; index to first column
+ $colFirst = self::getUInt2d($recordData, 2);
+
+ // offset: var; size: 2; index to last column
+ $colLast = self::getUInt2d($recordData, $length - 2);
+ $columns = $colLast - $colFirst + 1;
+
+ // offset within record data
+ $offset = 4;
+
+ for ($i = 1; $i <= $columns; ++$i) {
+ $columnString = Coordinate::stringFromColumnIndex($colFirst + $i);
+
+ // Read cell?
+ if (($this->getReadFilter() !== null) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->phpSheet->getTitle())) {
+ // offset: var; size: 2; index to XF record
+ $xfIndex = self::getUInt2d($recordData, $offset);
+
+ // offset: var; size: 4; RK value
+ $numValue = self::getIEEE754(self::getInt4d($recordData, $offset + 2));
+ $cell = $this->phpSheet->getCell($columnString . ($row + 1));
+ if (!$this->readDataOnly && isset($this->mapCellXfIndex[$xfIndex])) {
+ // add style
+ $cell->setXfIndex($this->mapCellXfIndex[$xfIndex]);
+ }
+
+ // add cell value
+ $cell->setValueExplicit($numValue, DataType::TYPE_NUMERIC);
+ }
+
+ $offset += 6;
+ }
+ }
+
+ /**
+ * Read NUMBER record
+ * This record represents a cell that contains a
+ * floating-point value.
+ *
+ * -- "OpenOffice.org's Documentation of the Microsoft
+ * Excel File Format"
+ */
+ private function readNumber(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ // offset: 0; size: 2; index to row
+ $row = self::getUInt2d($recordData, 0);
+
+ // offset: 2; size 2; index to column
+ $column = self::getUInt2d($recordData, 2);
+ $columnString = Coordinate::stringFromColumnIndex($column + 1);
+
+ // Read cell?
+ if (($this->getReadFilter() !== null) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->phpSheet->getTitle())) {
+ // offset 4; size: 2; index to XF record
+ $xfIndex = self::getUInt2d($recordData, 4);
+
+ $numValue = self::extractNumber(substr($recordData, 6, 8));
+
+ $cell = $this->phpSheet->getCell($columnString . ($row + 1));
+ if (!$this->readDataOnly && isset($this->mapCellXfIndex[$xfIndex])) {
+ // add cell style
+ $cell->setXfIndex($this->mapCellXfIndex[$xfIndex]);
+ }
+
+ // add cell value
+ $cell->setValueExplicit($numValue, DataType::TYPE_NUMERIC);
+ }
+ }
+
+ /**
+ * Read FORMULA record + perhaps a following STRING record if formula result is a string
+ * This record contains the token array and the result of a
+ * formula cell.
+ *
+ * -- "OpenOffice.org's Documentation of the Microsoft
+ * Excel File Format"
+ */
+ private function readFormula(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ // offset: 0; size: 2; row index
+ $row = self::getUInt2d($recordData, 0);
+
+ // offset: 2; size: 2; col index
+ $column = self::getUInt2d($recordData, 2);
+ $columnString = Coordinate::stringFromColumnIndex($column + 1);
+
+ // offset: 20: size: variable; formula structure
+ $formulaStructure = substr($recordData, 20);
+
+ // offset: 14: size: 2; option flags, recalculate always, recalculate on open etc.
+ $options = self::getUInt2d($recordData, 14);
+
+ // bit: 0; mask: 0x0001; 1 = recalculate always
+ // bit: 1; mask: 0x0002; 1 = calculate on open
+ // bit: 2; mask: 0x0008; 1 = part of a shared formula
+ $isPartOfSharedFormula = (bool) (0x0008 & $options);
+
+ // WARNING:
+ // We can apparently not rely on $isPartOfSharedFormula. Even when $isPartOfSharedFormula = true
+ // the formula data may be ordinary formula data, therefore we need to check
+ // explicitly for the tExp token (0x01)
+ $isPartOfSharedFormula = $isPartOfSharedFormula && ord($formulaStructure[2]) == 0x01;
+
+ if ($isPartOfSharedFormula) {
+ // part of shared formula which means there will be a formula with a tExp token and nothing else
+ // get the base cell, grab tExp token
+ $baseRow = self::getUInt2d($formulaStructure, 3);
+ $baseCol = self::getUInt2d($formulaStructure, 5);
+ $this->baseCell = Coordinate::stringFromColumnIndex($baseCol + 1) . ($baseRow + 1);
+ }
+
+ // Read cell?
+ if (($this->getReadFilter() !== null) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->phpSheet->getTitle())) {
+ if ($isPartOfSharedFormula) {
+ // formula is added to this cell after the sheet has been read
+ $this->sharedFormulaParts[$columnString . ($row + 1)] = $this->baseCell;
+ }
+
+ // offset: 16: size: 4; not used
+
+ // offset: 4; size: 2; XF index
+ $xfIndex = self::getUInt2d($recordData, 4);
+
+ // offset: 6; size: 8; result of the formula
+ if ((ord($recordData[6]) == 0) && (ord($recordData[12]) == 255) && (ord($recordData[13]) == 255)) {
+ // String formula. Result follows in appended STRING record
+ $dataType = DataType::TYPE_STRING;
+
+ // read possible SHAREDFMLA record
+ $code = self::getUInt2d($this->data, $this->pos);
+ if ($code == self::XLS_TYPE_SHAREDFMLA) {
+ $this->readSharedFmla();
+ }
+
+ // read STRING record
+ $value = $this->readString();
+ } elseif (
+ (ord($recordData[6]) == 1)
+ && (ord($recordData[12]) == 255)
+ && (ord($recordData[13]) == 255)
+ ) {
+ // Boolean formula. Result is in +2; 0=false, 1=true
+ $dataType = DataType::TYPE_BOOL;
+ $value = (bool) ord($recordData[8]);
+ } elseif (
+ (ord($recordData[6]) == 2)
+ && (ord($recordData[12]) == 255)
+ && (ord($recordData[13]) == 255)
+ ) {
+ // Error formula. Error code is in +2
+ $dataType = DataType::TYPE_ERROR;
+ $value = Xls\ErrorCode::lookup(ord($recordData[8]));
+ } elseif (
+ (ord($recordData[6]) == 3)
+ && (ord($recordData[12]) == 255)
+ && (ord($recordData[13]) == 255)
+ ) {
+ // Formula result is a null string
+ $dataType = DataType::TYPE_NULL;
+ $value = '';
+ } else {
+ // forumla result is a number, first 14 bytes like _NUMBER record
+ $dataType = DataType::TYPE_NUMERIC;
+ $value = self::extractNumber(substr($recordData, 6, 8));
+ }
+
+ $cell = $this->phpSheet->getCell($columnString . ($row + 1));
+ if (!$this->readDataOnly && isset($this->mapCellXfIndex[$xfIndex])) {
+ // add cell style
+ $cell->setXfIndex($this->mapCellXfIndex[$xfIndex]);
+ }
+
+ // store the formula
+ if (!$isPartOfSharedFormula) {
+ // not part of shared formula
+ // add cell value. If we can read formula, populate with formula, otherwise just used cached value
+ try {
+ if ($this->version != self::XLS_BIFF8) {
+ throw new Exception('Not BIFF8. Can only read BIFF8 formulas');
+ }
+ $formula = $this->getFormulaFromStructure($formulaStructure); // get formula in human language
+ $cell->setValueExplicit('=' . $formula, DataType::TYPE_FORMULA);
+ } catch (PhpSpreadsheetException $e) {
+ $cell->setValueExplicit($value, $dataType);
+ }
+ } else {
+ if ($this->version == self::XLS_BIFF8) {
+ // do nothing at this point, formula id added later in the code
+ } else {
+ $cell->setValueExplicit($value, $dataType);
+ }
+ }
+
+ // store the cached calculated value
+ $cell->setCalculatedValue($value);
+ }
+ }
+
+ /**
+ * Read a SHAREDFMLA record. This function just stores the binary shared formula in the reader,
+ * which usually contains relative references.
+ * These will be used to construct the formula in each shared formula part after the sheet is read.
+ */
+ private function readSharedFmla(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ // offset: 0, size: 6; cell range address of the area used by the shared formula, not used for anything
+ $cellRange = substr($recordData, 0, 6);
+ $cellRange = $this->readBIFF5CellRangeAddressFixed($cellRange); // note: even BIFF8 uses BIFF5 syntax
+
+ // offset: 6, size: 1; not used
+
+ // offset: 7, size: 1; number of existing FORMULA records for this shared formula
+ $no = ord($recordData[7]);
+
+ // offset: 8, size: var; Binary token array of the shared formula
+ $formula = substr($recordData, 8);
+
+ // at this point we only store the shared formula for later use
+ $this->sharedFormulas[$this->baseCell] = $formula;
+ }
+
+ /**
+ * Read a STRING record from current stream position and advance the stream pointer to next record
+ * This record is used for storing result from FORMULA record when it is a string, and
+ * it occurs directly after the FORMULA record.
+ *
+ * @return string The string contents as UTF-8
+ */
+ private function readString()
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ if ($this->version == self::XLS_BIFF8) {
+ $string = self::readUnicodeStringLong($recordData);
+ $value = $string['value'];
+ } else {
+ $string = $this->readByteStringLong($recordData);
+ $value = $string['value'];
+ }
+
+ return $value;
+ }
+
+ /**
+ * Read BOOLERR record
+ * This record represents a Boolean value or error value
+ * cell.
+ *
+ * -- "OpenOffice.org's Documentation of the Microsoft
+ * Excel File Format"
+ */
+ private function readBoolErr(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ // offset: 0; size: 2; row index
+ $row = self::getUInt2d($recordData, 0);
+
+ // offset: 2; size: 2; column index
+ $column = self::getUInt2d($recordData, 2);
+ $columnString = Coordinate::stringFromColumnIndex($column + 1);
+
+ // Read cell?
+ if (($this->getReadFilter() !== null) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->phpSheet->getTitle())) {
+ // offset: 4; size: 2; index to XF record
+ $xfIndex = self::getUInt2d($recordData, 4);
+
+ // offset: 6; size: 1; the boolean value or error value
+ $boolErr = ord($recordData[6]);
+
+ // offset: 7; size: 1; 0=boolean; 1=error
+ $isError = ord($recordData[7]);
+
+ $cell = $this->phpSheet->getCell($columnString . ($row + 1));
+ switch ($isError) {
+ case 0: // boolean
+ $value = (bool) $boolErr;
+
+ // add cell value
+ $cell->setValueExplicit($value, DataType::TYPE_BOOL);
+
+ break;
+ case 1: // error type
+ $value = Xls\ErrorCode::lookup($boolErr);
+
+ // add cell value
+ $cell->setValueExplicit($value, DataType::TYPE_ERROR);
+
+ break;
+ }
+
+ if (!$this->readDataOnly && isset($this->mapCellXfIndex[$xfIndex])) {
+ // add cell style
+ $cell->setXfIndex($this->mapCellXfIndex[$xfIndex]);
+ }
+ }
+ }
+
+ /**
+ * Read MULBLANK record
+ * This record represents a cell range of empty cells. All
+ * cells are located in the same row.
+ *
+ * -- "OpenOffice.org's Documentation of the Microsoft
+ * Excel File Format"
+ */
+ private function readMulBlank(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ // offset: 0; size: 2; index to row
+ $row = self::getUInt2d($recordData, 0);
+
+ // offset: 2; size: 2; index to first column
+ $fc = self::getUInt2d($recordData, 2);
+
+ // offset: 4; size: 2 x nc; list of indexes to XF records
+ // add style information
+ if (!$this->readDataOnly && $this->readEmptyCells) {
+ for ($i = 0; $i < $length / 2 - 3; ++$i) {
+ $columnString = Coordinate::stringFromColumnIndex($fc + $i + 1);
+
+ // Read cell?
+ if (($this->getReadFilter() !== null) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->phpSheet->getTitle())) {
+ $xfIndex = self::getUInt2d($recordData, 4 + 2 * $i);
+ if (isset($this->mapCellXfIndex[$xfIndex])) {
+ $this->phpSheet->getCell($columnString . ($row + 1))->setXfIndex($this->mapCellXfIndex[$xfIndex]);
+ }
+ }
+ }
+ }
+
+ // offset: 6; size 2; index to last column (not needed)
+ }
+
+ /**
+ * Read LABEL record
+ * This record represents a cell that contains a string. In
+ * BIFF8 it is usually replaced by the LABELSST record.
+ * Excel still uses this record, if it copies unformatted
+ * text cells to the clipboard.
+ *
+ * -- "OpenOffice.org's Documentation of the Microsoft
+ * Excel File Format"
+ */
+ private function readLabel(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ // offset: 0; size: 2; index to row
+ $row = self::getUInt2d($recordData, 0);
+
+ // offset: 2; size: 2; index to column
+ $column = self::getUInt2d($recordData, 2);
+ $columnString = Coordinate::stringFromColumnIndex($column + 1);
+
+ // Read cell?
+ if (($this->getReadFilter() !== null) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->phpSheet->getTitle())) {
+ // offset: 4; size: 2; XF index
+ $xfIndex = self::getUInt2d($recordData, 4);
+
+ // add cell value
+ // todo: what if string is very long? continue record
+ if ($this->version == self::XLS_BIFF8) {
+ $string = self::readUnicodeStringLong(substr($recordData, 6));
+ $value = $string['value'];
+ } else {
+ $string = $this->readByteStringLong(substr($recordData, 6));
+ $value = $string['value'];
+ }
+ if ($this->readEmptyCells || trim($value) !== '') {
+ $cell = $this->phpSheet->getCell($columnString . ($row + 1));
+ $cell->setValueExplicit($value, DataType::TYPE_STRING);
+
+ if (!$this->readDataOnly && isset($this->mapCellXfIndex[$xfIndex])) {
+ // add cell style
+ $cell->setXfIndex($this->mapCellXfIndex[$xfIndex]);
+ }
+ }
+ }
+ }
+
+ /**
+ * Read BLANK record.
+ */
+ private function readBlank(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ // offset: 0; size: 2; row index
+ $row = self::getUInt2d($recordData, 0);
+
+ // offset: 2; size: 2; col index
+ $col = self::getUInt2d($recordData, 2);
+ $columnString = Coordinate::stringFromColumnIndex($col + 1);
+
+ // Read cell?
+ if (($this->getReadFilter() !== null) && $this->getReadFilter()->readCell($columnString, $row + 1, $this->phpSheet->getTitle())) {
+ // offset: 4; size: 2; XF index
+ $xfIndex = self::getUInt2d($recordData, 4);
+
+ // add style information
+ if (!$this->readDataOnly && $this->readEmptyCells && isset($this->mapCellXfIndex[$xfIndex])) {
+ $this->phpSheet->getCell($columnString . ($row + 1))->setXfIndex($this->mapCellXfIndex[$xfIndex]);
+ }
+ }
+ }
+
+ /**
+ * Read MSODRAWING record.
+ */
+ private function readMsoDrawing(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+
+ // get spliced record data
+ $splicedRecordData = $this->getSplicedRecordData();
+ $recordData = $splicedRecordData['recordData'];
+
+ $this->drawingData .= $recordData;
+ }
+
+ /**
+ * Read OBJ record.
+ */
+ private function readObj(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ if ($this->readDataOnly || $this->version != self::XLS_BIFF8) {
+ return;
+ }
+
+ // recordData consists of an array of subrecords looking like this:
+ // ft: 2 bytes; ftCmo type (0x15)
+ // cb: 2 bytes; size in bytes of ftCmo data
+ // ot: 2 bytes; Object Type
+ // id: 2 bytes; Object id number
+ // grbit: 2 bytes; Option Flags
+ // data: var; subrecord data
+
+ // for now, we are just interested in the second subrecord containing the object type
+ $ftCmoType = self::getUInt2d($recordData, 0);
+ $cbCmoSize = self::getUInt2d($recordData, 2);
+ $otObjType = self::getUInt2d($recordData, 4);
+ $idObjID = self::getUInt2d($recordData, 6);
+ $grbitOpts = self::getUInt2d($recordData, 6);
+
+ $this->objs[] = [
+ 'ftCmoType' => $ftCmoType,
+ 'cbCmoSize' => $cbCmoSize,
+ 'otObjType' => $otObjType,
+ 'idObjID' => $idObjID,
+ 'grbitOpts' => $grbitOpts,
+ ];
+ $this->textObjRef = $idObjID;
+ }
+
+ /**
+ * Read WINDOW2 record.
+ */
+ private function readWindow2(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ // offset: 0; size: 2; option flags
+ $options = self::getUInt2d($recordData, 0);
+
+ // offset: 2; size: 2; index to first visible row
+ $firstVisibleRow = self::getUInt2d($recordData, 2);
+
+ // offset: 4; size: 2; index to first visible colum
+ $firstVisibleColumn = self::getUInt2d($recordData, 4);
+ if ($this->version === self::XLS_BIFF8) {
+ // offset: 8; size: 2; not used
+ // offset: 10; size: 2; cached magnification factor in page break preview (in percent); 0 = Default (60%)
+ // offset: 12; size: 2; cached magnification factor in normal view (in percent); 0 = Default (100%)
+ // offset: 14; size: 4; not used
+ $zoomscaleInPageBreakPreview = self::getUInt2d($recordData, 10);
+ if ($zoomscaleInPageBreakPreview === 0) {
+ $zoomscaleInPageBreakPreview = 60;
+ }
+ $zoomscaleInNormalView = self::getUInt2d($recordData, 12);
+ if ($zoomscaleInNormalView === 0) {
+ $zoomscaleInNormalView = 100;
+ }
+ }
+
+ // bit: 1; mask: 0x0002; 0 = do not show gridlines, 1 = show gridlines
+ $showGridlines = (bool) ((0x0002 & $options) >> 1);
+ $this->phpSheet->setShowGridlines($showGridlines);
+
+ // bit: 2; mask: 0x0004; 0 = do not show headers, 1 = show headers
+ $showRowColHeaders = (bool) ((0x0004 & $options) >> 2);
+ $this->phpSheet->setShowRowColHeaders($showRowColHeaders);
+
+ // bit: 3; mask: 0x0008; 0 = panes are not frozen, 1 = panes are frozen
+ $this->frozen = (bool) ((0x0008 & $options) >> 3);
+
+ // bit: 6; mask: 0x0040; 0 = columns from left to right, 1 = columns from right to left
+ $this->phpSheet->setRightToLeft((bool) ((0x0040 & $options) >> 6));
+
+ // bit: 10; mask: 0x0400; 0 = sheet not active, 1 = sheet active
+ $isActive = (bool) ((0x0400 & $options) >> 10);
+ if ($isActive) {
+ $this->spreadsheet->setActiveSheetIndex($this->spreadsheet->getIndex($this->phpSheet));
+ }
+
+ // bit: 11; mask: 0x0800; 0 = normal view, 1 = page break view
+ $isPageBreakPreview = (bool) ((0x0800 & $options) >> 11);
+
+ //FIXME: set $firstVisibleRow and $firstVisibleColumn
+
+ if ($this->phpSheet->getSheetView()->getView() !== SheetView::SHEETVIEW_PAGE_LAYOUT) {
+ //NOTE: this setting is inferior to page layout view(Excel2007-)
+ $view = $isPageBreakPreview ? SheetView::SHEETVIEW_PAGE_BREAK_PREVIEW : SheetView::SHEETVIEW_NORMAL;
+ $this->phpSheet->getSheetView()->setView($view);
+ if ($this->version === self::XLS_BIFF8) {
+ $zoomScale = $isPageBreakPreview ? $zoomscaleInPageBreakPreview : $zoomscaleInNormalView;
+ $this->phpSheet->getSheetView()->setZoomScale($zoomScale);
+ $this->phpSheet->getSheetView()->setZoomScaleNormal($zoomscaleInNormalView);
+ }
+ }
+ }
+
+ /**
+ * Read PLV Record(Created by Excel2007 or upper).
+ */
+ private function readPageLayoutView(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ // offset: 0; size: 2; rt
+ //->ignore
+ $rt = self::getUInt2d($recordData, 0);
+ // offset: 2; size: 2; grbitfr
+ //->ignore
+ $grbitFrt = self::getUInt2d($recordData, 2);
+ // offset: 4; size: 8; reserved
+ //->ignore
+
+ // offset: 12; size 2; zoom scale
+ $wScalePLV = self::getUInt2d($recordData, 12);
+ // offset: 14; size 2; grbit
+ $grbit = self::getUInt2d($recordData, 14);
+
+ // decomprise grbit
+ $fPageLayoutView = $grbit & 0x01;
+ $fRulerVisible = ($grbit >> 1) & 0x01; //no support
+ $fWhitespaceHidden = ($grbit >> 3) & 0x01; //no support
+
+ if ($fPageLayoutView === 1) {
+ $this->phpSheet->getSheetView()->setView(SheetView::SHEETVIEW_PAGE_LAYOUT);
+ $this->phpSheet->getSheetView()->setZoomScale($wScalePLV); //set by Excel2007 only if SHEETVIEW_PAGE_LAYOUT
+ }
+ //otherwise, we cannot know whether SHEETVIEW_PAGE_LAYOUT or SHEETVIEW_PAGE_BREAK_PREVIEW.
+ }
+
+ /**
+ * Read SCL record.
+ */
+ private function readScl(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ // offset: 0; size: 2; numerator of the view magnification
+ $numerator = self::getUInt2d($recordData, 0);
+
+ // offset: 2; size: 2; numerator of the view magnification
+ $denumerator = self::getUInt2d($recordData, 2);
+
+ // set the zoom scale (in percent)
+ $this->phpSheet->getSheetView()->setZoomScale($numerator * 100 / $denumerator);
+ }
+
+ /**
+ * Read PANE record.
+ */
+ private function readPane(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ if (!$this->readDataOnly) {
+ // offset: 0; size: 2; position of vertical split
+ $px = self::getUInt2d($recordData, 0);
+
+ // offset: 2; size: 2; position of horizontal split
+ $py = self::getUInt2d($recordData, 2);
+
+ // offset: 4; size: 2; top most visible row in the bottom pane
+ $rwTop = self::getUInt2d($recordData, 4);
+
+ // offset: 6; size: 2; first visible left column in the right pane
+ $colLeft = self::getUInt2d($recordData, 6);
+
+ if ($this->frozen) {
+ // frozen panes
+ $cell = Coordinate::stringFromColumnIndex($px + 1) . ($py + 1);
+ $topLeftCell = Coordinate::stringFromColumnIndex($colLeft + 1) . ($rwTop + 1);
+ $this->phpSheet->freezePane($cell, $topLeftCell);
+ }
+ // unfrozen panes; split windows; not supported by PhpSpreadsheet core
+ }
+ }
+
+ /**
+ * Read SELECTION record. There is one such record for each pane in the sheet.
+ */
+ private function readSelection(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ if (!$this->readDataOnly) {
+ // offset: 0; size: 1; pane identifier
+ $paneId = ord($recordData[0]);
+
+ // offset: 1; size: 2; index to row of the active cell
+ $r = self::getUInt2d($recordData, 1);
+
+ // offset: 3; size: 2; index to column of the active cell
+ $c = self::getUInt2d($recordData, 3);
+
+ // offset: 5; size: 2; index into the following cell range list to the
+ // entry that contains the active cell
+ $index = self::getUInt2d($recordData, 5);
+
+ // offset: 7; size: var; cell range address list containing all selected cell ranges
+ $data = substr($recordData, 7);
+ $cellRangeAddressList = $this->readBIFF5CellRangeAddressList($data); // note: also BIFF8 uses BIFF5 syntax
+
+ $selectedCells = $cellRangeAddressList['cellRangeAddresses'][0];
+
+ // first row '1' + last row '16384' indicates that full column is selected (apparently also in BIFF8!)
+ if (preg_match('/^([A-Z]+1\:[A-Z]+)16384$/', $selectedCells)) {
+ $selectedCells = preg_replace('/^([A-Z]+1\:[A-Z]+)16384$/', '${1}1048576', $selectedCells);
+ }
+
+ // first row '1' + last row '65536' indicates that full column is selected
+ if (preg_match('/^([A-Z]+1\:[A-Z]+)65536$/', $selectedCells)) {
+ $selectedCells = preg_replace('/^([A-Z]+1\:[A-Z]+)65536$/', '${1}1048576', $selectedCells);
+ }
+
+ // first column 'A' + last column 'IV' indicates that full row is selected
+ if (preg_match('/^(A\d+\:)IV(\d+)$/', $selectedCells)) {
+ $selectedCells = preg_replace('/^(A\d+\:)IV(\d+)$/', '${1}XFD${2}', $selectedCells);
+ }
+
+ $this->phpSheet->setSelectedCells($selectedCells);
+ }
+ }
+
+ private function includeCellRangeFiltered($cellRangeAddress)
+ {
+ $includeCellRange = true;
+ if ($this->getReadFilter() !== null) {
+ $includeCellRange = false;
+ $rangeBoundaries = Coordinate::getRangeBoundaries($cellRangeAddress);
+ ++$rangeBoundaries[1][0];
+ for ($row = $rangeBoundaries[0][1]; $row <= $rangeBoundaries[1][1]; ++$row) {
+ for ($column = $rangeBoundaries[0][0]; $column != $rangeBoundaries[1][0]; ++$column) {
+ if ($this->getReadFilter()->readCell($column, $row, $this->phpSheet->getTitle())) {
+ $includeCellRange = true;
+
+ break 2;
+ }
+ }
+ }
+ }
+
+ return $includeCellRange;
+ }
+
+ /**
+ * MERGEDCELLS.
+ *
+ * This record contains the addresses of merged cell ranges
+ * in the current sheet.
+ *
+ * -- "OpenOffice.org's Documentation of the Microsoft
+ * Excel File Format"
+ */
+ private function readMergedCells(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ if ($this->version == self::XLS_BIFF8 && !$this->readDataOnly) {
+ $cellRangeAddressList = $this->readBIFF8CellRangeAddressList($recordData);
+ foreach ($cellRangeAddressList['cellRangeAddresses'] as $cellRangeAddress) {
+ if (
+ (strpos($cellRangeAddress, ':') !== false) &&
+ ($this->includeCellRangeFiltered($cellRangeAddress))
+ ) {
+ $this->phpSheet->mergeCells($cellRangeAddress);
+ }
+ }
+ }
+ }
+
+ /**
+ * Read HYPERLINK record.
+ */
+ private function readHyperLink(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer forward to next record
+ $this->pos += 4 + $length;
+
+ if (!$this->readDataOnly) {
+ // offset: 0; size: 8; cell range address of all cells containing this hyperlink
+ try {
+ $cellRange = $this->readBIFF8CellRangeAddressFixed($recordData);
+ } catch (PhpSpreadsheetException $e) {
+ return;
+ }
+
+ // offset: 8, size: 16; GUID of StdLink
+
+ // offset: 24, size: 4; unknown value
+
+ // offset: 28, size: 4; option flags
+ // bit: 0; mask: 0x00000001; 0 = no link or extant, 1 = file link or URL
+ $isFileLinkOrUrl = (0x00000001 & self::getUInt2d($recordData, 28)) >> 0;
+
+ // bit: 1; mask: 0x00000002; 0 = relative path, 1 = absolute path or URL
+ $isAbsPathOrUrl = (0x00000001 & self::getUInt2d($recordData, 28)) >> 1;
+
+ // bit: 2 (and 4); mask: 0x00000014; 0 = no description
+ $hasDesc = (0x00000014 & self::getUInt2d($recordData, 28)) >> 2;
+
+ // bit: 3; mask: 0x00000008; 0 = no text, 1 = has text
+ $hasText = (0x00000008 & self::getUInt2d($recordData, 28)) >> 3;
+
+ // bit: 7; mask: 0x00000080; 0 = no target frame, 1 = has target frame
+ $hasFrame = (0x00000080 & self::getUInt2d($recordData, 28)) >> 7;
+
+ // bit: 8; mask: 0x00000100; 0 = file link or URL, 1 = UNC path (inc. server name)
+ $isUNC = (0x00000100 & self::getUInt2d($recordData, 28)) >> 8;
+
+ // offset within record data
+ $offset = 32;
+
+ if ($hasDesc) {
+ // offset: 32; size: var; character count of description text
+ $dl = self::getInt4d($recordData, 32);
+ // offset: 36; size: var; character array of description text, no Unicode string header, always 16-bit characters, zero terminated
+ $desc = self::encodeUTF16(substr($recordData, 36, 2 * ($dl - 1)), false);
+ $offset += 4 + 2 * $dl;
+ }
+ if ($hasFrame) {
+ $fl = self::getInt4d($recordData, $offset);
+ $offset += 4 + 2 * $fl;
+ }
+
+ // detect type of hyperlink (there are 4 types)
+ $hyperlinkType = null;
+
+ if ($isUNC) {
+ $hyperlinkType = 'UNC';
+ } elseif (!$isFileLinkOrUrl) {
+ $hyperlinkType = 'workbook';
+ } elseif (ord($recordData[$offset]) == 0x03) {
+ $hyperlinkType = 'local';
+ } elseif (ord($recordData[$offset]) == 0xE0) {
+ $hyperlinkType = 'URL';
+ }
+
+ switch ($hyperlinkType) {
+ case 'URL':
+ // section 5.58.2: Hyperlink containing a URL
+ // e.g. http://example.org/index.php
+
+ // offset: var; size: 16; GUID of URL Moniker
+ $offset += 16;
+ // offset: var; size: 4; size (in bytes) of character array of the URL including trailing zero word
+ $us = self::getInt4d($recordData, $offset);
+ $offset += 4;
+ // offset: var; size: $us; character array of the URL, no Unicode string header, always 16-bit characters, zero-terminated
+ $url = self::encodeUTF16(substr($recordData, $offset, $us - 2), false);
+ $nullOffset = strpos($url, chr(0x00));
+ if ($nullOffset) {
+ $url = substr($url, 0, $nullOffset);
+ }
+ $url .= $hasText ? '#' : '';
+ $offset += $us;
+
+ break;
+ case 'local':
+ // section 5.58.3: Hyperlink to local file
+ // examples:
+ // mydoc.txt
+ // ../../somedoc.xls#Sheet!A1
+
+ // offset: var; size: 16; GUI of File Moniker
+ $offset += 16;
+
+ // offset: var; size: 2; directory up-level count.
+ $upLevelCount = self::getUInt2d($recordData, $offset);
+ $offset += 2;
+
+ // offset: var; size: 4; character count of the shortened file path and name, including trailing zero word
+ $sl = self::getInt4d($recordData, $offset);
+ $offset += 4;
+
+ // offset: var; size: sl; character array of the shortened file path and name in 8.3-DOS-format (compressed Unicode string)
+ $shortenedFilePath = substr($recordData, $offset, $sl);
+ $shortenedFilePath = self::encodeUTF16($shortenedFilePath, true);
+ $shortenedFilePath = substr($shortenedFilePath, 0, -1); // remove trailing zero
+
+ $offset += $sl;
+
+ // offset: var; size: 24; unknown sequence
+ $offset += 24;
+
+ // extended file path
+ // offset: var; size: 4; size of the following file link field including string lenth mark
+ $sz = self::getInt4d($recordData, $offset);
+ $offset += 4;
+
+ // only present if $sz > 0
+ if ($sz > 0) {
+ // offset: var; size: 4; size of the character array of the extended file path and name
+ $xl = self::getInt4d($recordData, $offset);
+ $offset += 4;
+
+ // offset: var; size 2; unknown
+ $offset += 2;
+
+ // offset: var; size $xl; character array of the extended file path and name.
+ $extendedFilePath = substr($recordData, $offset, $xl);
+ $extendedFilePath = self::encodeUTF16($extendedFilePath, false);
+ $offset += $xl;
+ }
+
+ // construct the path
+ $url = str_repeat('..\\', $upLevelCount);
+ $url .= ($sz > 0) ? $extendedFilePath : $shortenedFilePath; // use extended path if available
+ $url .= $hasText ? '#' : '';
+
+ break;
+ case 'UNC':
+ // section 5.58.4: Hyperlink to a File with UNC (Universal Naming Convention) Path
+ // todo: implement
+ return;
+ case 'workbook':
+ // section 5.58.5: Hyperlink to the Current Workbook
+ // e.g. Sheet2!B1:C2, stored in text mark field
+ $url = 'sheet://';
+
+ break;
+ default:
+ return;
+ }
+
+ if ($hasText) {
+ // offset: var; size: 4; character count of text mark including trailing zero word
+ $tl = self::getInt4d($recordData, $offset);
+ $offset += 4;
+ // offset: var; size: var; character array of the text mark without the # sign, no Unicode header, always 16-bit characters, zero-terminated
+ $text = self::encodeUTF16(substr($recordData, $offset, 2 * ($tl - 1)), false);
+ $url .= $text;
+ }
+
+ // apply the hyperlink to all the relevant cells
+ foreach (Coordinate::extractAllCellReferencesInRange($cellRange) as $coordinate) {
+ $this->phpSheet->getCell($coordinate)->getHyperLink()->setUrl($url);
+ }
+ }
+ }
+
+ /**
+ * Read DATAVALIDATIONS record.
+ */
+ private function readDataValidations(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer forward to next record
+ $this->pos += 4 + $length;
+ }
+
+ /**
+ * Read DATAVALIDATION record.
+ */
+ private function readDataValidation(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer forward to next record
+ $this->pos += 4 + $length;
+
+ if ($this->readDataOnly) {
+ return;
+ }
+
+ // offset: 0; size: 4; Options
+ $options = self::getInt4d($recordData, 0);
+
+ // bit: 0-3; mask: 0x0000000F; type
+ $type = (0x0000000F & $options) >> 0;
+ switch ($type) {
+ case 0x00:
+ $type = DataValidation::TYPE_NONE;
+
+ break;
+ case 0x01:
+ $type = DataValidation::TYPE_WHOLE;
+
+ break;
+ case 0x02:
+ $type = DataValidation::TYPE_DECIMAL;
+
+ break;
+ case 0x03:
+ $type = DataValidation::TYPE_LIST;
+
+ break;
+ case 0x04:
+ $type = DataValidation::TYPE_DATE;
+
+ break;
+ case 0x05:
+ $type = DataValidation::TYPE_TIME;
+
+ break;
+ case 0x06:
+ $type = DataValidation::TYPE_TEXTLENGTH;
+
+ break;
+ case 0x07:
+ $type = DataValidation::TYPE_CUSTOM;
+
+ break;
+ }
+
+ // bit: 4-6; mask: 0x00000070; error type
+ $errorStyle = (0x00000070 & $options) >> 4;
+ switch ($errorStyle) {
+ case 0x00:
+ $errorStyle = DataValidation::STYLE_STOP;
+
+ break;
+ case 0x01:
+ $errorStyle = DataValidation::STYLE_WARNING;
+
+ break;
+ case 0x02:
+ $errorStyle = DataValidation::STYLE_INFORMATION;
+
+ break;
+ }
+
+ // bit: 7; mask: 0x00000080; 1= formula is explicit (only applies to list)
+ // I have only seen cases where this is 1
+ $explicitFormula = (0x00000080 & $options) >> 7;
+
+ // bit: 8; mask: 0x00000100; 1= empty cells allowed
+ $allowBlank = (0x00000100 & $options) >> 8;
+
+ // bit: 9; mask: 0x00000200; 1= suppress drop down arrow in list type validity
+ $suppressDropDown = (0x00000200 & $options) >> 9;
+
+ // bit: 18; mask: 0x00040000; 1= show prompt box if cell selected
+ $showInputMessage = (0x00040000 & $options) >> 18;
+
+ // bit: 19; mask: 0x00080000; 1= show error box if invalid values entered
+ $showErrorMessage = (0x00080000 & $options) >> 19;
+
+ // bit: 20-23; mask: 0x00F00000; condition operator
+ $operator = (0x00F00000 & $options) >> 20;
+ switch ($operator) {
+ case 0x00:
+ $operator = DataValidation::OPERATOR_BETWEEN;
+
+ break;
+ case 0x01:
+ $operator = DataValidation::OPERATOR_NOTBETWEEN;
+
+ break;
+ case 0x02:
+ $operator = DataValidation::OPERATOR_EQUAL;
+
+ break;
+ case 0x03:
+ $operator = DataValidation::OPERATOR_NOTEQUAL;
+
+ break;
+ case 0x04:
+ $operator = DataValidation::OPERATOR_GREATERTHAN;
+
+ break;
+ case 0x05:
+ $operator = DataValidation::OPERATOR_LESSTHAN;
+
+ break;
+ case 0x06:
+ $operator = DataValidation::OPERATOR_GREATERTHANOREQUAL;
+
+ break;
+ case 0x07:
+ $operator = DataValidation::OPERATOR_LESSTHANOREQUAL;
+
+ break;
+ }
+
+ // offset: 4; size: var; title of the prompt box
+ $offset = 4;
+ $string = self::readUnicodeStringLong(substr($recordData, $offset));
+ $promptTitle = $string['value'] !== chr(0) ? $string['value'] : '';
+ $offset += $string['size'];
+
+ // offset: var; size: var; title of the error box
+ $string = self::readUnicodeStringLong(substr($recordData, $offset));
+ $errorTitle = $string['value'] !== chr(0) ? $string['value'] : '';
+ $offset += $string['size'];
+
+ // offset: var; size: var; text of the prompt box
+ $string = self::readUnicodeStringLong(substr($recordData, $offset));
+ $prompt = $string['value'] !== chr(0) ? $string['value'] : '';
+ $offset += $string['size'];
+
+ // offset: var; size: var; text of the error box
+ $string = self::readUnicodeStringLong(substr($recordData, $offset));
+ $error = $string['value'] !== chr(0) ? $string['value'] : '';
+ $offset += $string['size'];
+
+ // offset: var; size: 2; size of the formula data for the first condition
+ $sz1 = self::getUInt2d($recordData, $offset);
+ $offset += 2;
+
+ // offset: var; size: 2; not used
+ $offset += 2;
+
+ // offset: var; size: $sz1; formula data for first condition (without size field)
+ $formula1 = substr($recordData, $offset, $sz1);
+ $formula1 = pack('v', $sz1) . $formula1; // prepend the length
+
+ try {
+ $formula1 = $this->getFormulaFromStructure($formula1);
+
+ // in list type validity, null characters are used as item separators
+ if ($type == DataValidation::TYPE_LIST) {
+ $formula1 = str_replace(chr(0), ',', $formula1);
+ }
+ } catch (PhpSpreadsheetException $e) {
+ return;
+ }
+ $offset += $sz1;
+
+ // offset: var; size: 2; size of the formula data for the first condition
+ $sz2 = self::getUInt2d($recordData, $offset);
+ $offset += 2;
+
+ // offset: var; size: 2; not used
+ $offset += 2;
+
+ // offset: var; size: $sz2; formula data for second condition (without size field)
+ $formula2 = substr($recordData, $offset, $sz2);
+ $formula2 = pack('v', $sz2) . $formula2; // prepend the length
+
+ try {
+ $formula2 = $this->getFormulaFromStructure($formula2);
+ } catch (PhpSpreadsheetException $e) {
+ return;
+ }
+ $offset += $sz2;
+
+ // offset: var; size: var; cell range address list with
+ $cellRangeAddressList = $this->readBIFF8CellRangeAddressList(substr($recordData, $offset));
+ $cellRangeAddresses = $cellRangeAddressList['cellRangeAddresses'];
+
+ foreach ($cellRangeAddresses as $cellRange) {
+ $stRange = $this->phpSheet->shrinkRangeToFit($cellRange);
+ foreach (Coordinate::extractAllCellReferencesInRange($stRange) as $coordinate) {
+ $objValidation = $this->phpSheet->getCell($coordinate)->getDataValidation();
+ $objValidation->setType($type);
+ $objValidation->setErrorStyle($errorStyle);
+ $objValidation->setAllowBlank((bool) $allowBlank);
+ $objValidation->setShowInputMessage((bool) $showInputMessage);
+ $objValidation->setShowErrorMessage((bool) $showErrorMessage);
+ $objValidation->setShowDropDown(!$suppressDropDown);
+ $objValidation->setOperator($operator);
+ $objValidation->setErrorTitle($errorTitle);
+ $objValidation->setError($error);
+ $objValidation->setPromptTitle($promptTitle);
+ $objValidation->setPrompt($prompt);
+ $objValidation->setFormula1($formula1);
+ $objValidation->setFormula2($formula2);
+ }
+ }
+ }
+
+ /**
+ * Read SHEETLAYOUT record. Stores sheet tab color information.
+ */
+ private function readSheetLayout(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ // local pointer in record data
+ $offset = 0;
+
+ if (!$this->readDataOnly) {
+ // offset: 0; size: 2; repeated record identifier 0x0862
+
+ // offset: 2; size: 10; not used
+
+ // offset: 12; size: 4; size of record data
+ // Excel 2003 uses size of 0x14 (documented), Excel 2007 uses size of 0x28 (not documented?)
+ $sz = self::getInt4d($recordData, 12);
+
+ switch ($sz) {
+ case 0x14:
+ // offset: 16; size: 2; color index for sheet tab
+ $colorIndex = self::getUInt2d($recordData, 16);
+ $color = Xls\Color::map($colorIndex, $this->palette, $this->version);
+ $this->phpSheet->getTabColor()->setRGB($color['rgb']);
+
+ break;
+ case 0x28:
+ // TODO: Investigate structure for .xls SHEETLAYOUT record as saved by MS Office Excel 2007
+ return;
+
+ break;
+ }
+ }
+ }
+
+ /**
+ * Read SHEETPROTECTION record (FEATHEADR).
+ */
+ private function readSheetProtection(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ if ($this->readDataOnly) {
+ return;
+ }
+
+ // offset: 0; size: 2; repeated record header
+
+ // offset: 2; size: 2; FRT cell reference flag (=0 currently)
+
+ // offset: 4; size: 8; Currently not used and set to 0
+
+ // offset: 12; size: 2; Shared feature type index (2=Enhanced Protetion, 4=SmartTag)
+ $isf = self::getUInt2d($recordData, 12);
+ if ($isf != 2) {
+ return;
+ }
+
+ // offset: 14; size: 1; =1 since this is a feat header
+
+ // offset: 15; size: 4; size of rgbHdrSData
+
+ // rgbHdrSData, assume "Enhanced Protection"
+ // offset: 19; size: 2; option flags
+ $options = self::getUInt2d($recordData, 19);
+
+ // bit: 0; mask 0x0001; 1 = user may edit objects, 0 = users must not edit objects
+ $bool = (0x0001 & $options) >> 0;
+ $this->phpSheet->getProtection()->setObjects(!$bool);
+
+ // bit: 1; mask 0x0002; edit scenarios
+ $bool = (0x0002 & $options) >> 1;
+ $this->phpSheet->getProtection()->setScenarios(!$bool);
+
+ // bit: 2; mask 0x0004; format cells
+ $bool = (0x0004 & $options) >> 2;
+ $this->phpSheet->getProtection()->setFormatCells(!$bool);
+
+ // bit: 3; mask 0x0008; format columns
+ $bool = (0x0008 & $options) >> 3;
+ $this->phpSheet->getProtection()->setFormatColumns(!$bool);
+
+ // bit: 4; mask 0x0010; format rows
+ $bool = (0x0010 & $options) >> 4;
+ $this->phpSheet->getProtection()->setFormatRows(!$bool);
+
+ // bit: 5; mask 0x0020; insert columns
+ $bool = (0x0020 & $options) >> 5;
+ $this->phpSheet->getProtection()->setInsertColumns(!$bool);
+
+ // bit: 6; mask 0x0040; insert rows
+ $bool = (0x0040 & $options) >> 6;
+ $this->phpSheet->getProtection()->setInsertRows(!$bool);
+
+ // bit: 7; mask 0x0080; insert hyperlinks
+ $bool = (0x0080 & $options) >> 7;
+ $this->phpSheet->getProtection()->setInsertHyperlinks(!$bool);
+
+ // bit: 8; mask 0x0100; delete columns
+ $bool = (0x0100 & $options) >> 8;
+ $this->phpSheet->getProtection()->setDeleteColumns(!$bool);
+
+ // bit: 9; mask 0x0200; delete rows
+ $bool = (0x0200 & $options) >> 9;
+ $this->phpSheet->getProtection()->setDeleteRows(!$bool);
+
+ // bit: 10; mask 0x0400; select locked cells
+ $bool = (0x0400 & $options) >> 10;
+ $this->phpSheet->getProtection()->setSelectLockedCells(!$bool);
+
+ // bit: 11; mask 0x0800; sort cell range
+ $bool = (0x0800 & $options) >> 11;
+ $this->phpSheet->getProtection()->setSort(!$bool);
+
+ // bit: 12; mask 0x1000; auto filter
+ $bool = (0x1000 & $options) >> 12;
+ $this->phpSheet->getProtection()->setAutoFilter(!$bool);
+
+ // bit: 13; mask 0x2000; pivot tables
+ $bool = (0x2000 & $options) >> 13;
+ $this->phpSheet->getProtection()->setPivotTables(!$bool);
+
+ // bit: 14; mask 0x4000; select unlocked cells
+ $bool = (0x4000 & $options) >> 14;
+ $this->phpSheet->getProtection()->setSelectUnlockedCells(!$bool);
+
+ // offset: 21; size: 2; not used
+ }
+
+ /**
+ * Read RANGEPROTECTION record
+ * Reading of this record is based on Microsoft Office Excel 97-2000 Binary File Format Specification,
+ * where it is referred to as FEAT record.
+ */
+ private function readRangeProtection(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ // local pointer in record data
+ $offset = 0;
+
+ if (!$this->readDataOnly) {
+ $offset += 12;
+
+ // offset: 12; size: 2; shared feature type, 2 = enhanced protection, 4 = smart tag
+ $isf = self::getUInt2d($recordData, 12);
+ if ($isf != 2) {
+ // we only read FEAT records of type 2
+ return;
+ }
+ $offset += 2;
+
+ $offset += 5;
+
+ // offset: 19; size: 2; count of ref ranges this feature is on
+ $cref = self::getUInt2d($recordData, 19);
+ $offset += 2;
+
+ $offset += 6;
+
+ // offset: 27; size: 8 * $cref; list of cell ranges (like in hyperlink record)
+ $cellRanges = [];
+ for ($i = 0; $i < $cref; ++$i) {
+ try {
+ $cellRange = $this->readBIFF8CellRangeAddressFixed(substr($recordData, 27 + 8 * $i, 8));
+ } catch (PhpSpreadsheetException $e) {
+ return;
+ }
+ $cellRanges[] = $cellRange;
+ $offset += 8;
+ }
+
+ // offset: var; size: var; variable length of feature specific data
+ $rgbFeat = substr($recordData, $offset);
+ $offset += 4;
+
+ // offset: var; size: 4; the encrypted password (only 16-bit although field is 32-bit)
+ $wPassword = self::getInt4d($recordData, $offset);
+ $offset += 4;
+
+ // Apply range protection to sheet
+ if ($cellRanges) {
+ $this->phpSheet->protectCells(implode(' ', $cellRanges), strtoupper(dechex($wPassword)), true);
+ }
+ }
+ }
+
+ /**
+ * Read a free CONTINUE record. Free CONTINUE record may be a camouflaged MSODRAWING record
+ * When MSODRAWING data on a sheet exceeds 8224 bytes, CONTINUE records are used instead. Undocumented.
+ * In this case, we must treat the CONTINUE record as a MSODRAWING record.
+ */
+ private function readContinue(): void
+ {
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $recordData = $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ // check if we are reading drawing data
+ // this is in case a free CONTINUE record occurs in other circumstances we are unaware of
+ if ($this->drawingData == '') {
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ return;
+ }
+
+ // check if record data is at least 4 bytes long, otherwise there is no chance this is MSODRAWING data
+ if ($length < 4) {
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+
+ return;
+ }
+
+ // dirty check to see if CONTINUE record could be a camouflaged MSODRAWING record
+ // look inside CONTINUE record to see if it looks like a part of an Escher stream
+ // we know that Escher stream may be split at least at
+ // 0xF003 MsofbtSpgrContainer
+ // 0xF004 MsofbtSpContainer
+ // 0xF00D MsofbtClientTextbox
+ $validSplitPoints = [0xF003, 0xF004, 0xF00D]; // add identifiers if we find more
+
+ $splitPoint = self::getUInt2d($recordData, 2);
+ if (in_array($splitPoint, $validSplitPoints)) {
+ // get spliced record data (and move pointer to next record)
+ $splicedRecordData = $this->getSplicedRecordData();
+ $this->drawingData .= $splicedRecordData['recordData'];
+
+ return;
+ }
+
+ // move stream pointer to next record
+ $this->pos += 4 + $length;
+ }
+
+ /**
+ * Reads a record from current position in data stream and continues reading data as long as CONTINUE
+ * records are found. Splices the record data pieces and returns the combined string as if record data
+ * is in one piece.
+ * Moves to next current position in data stream to start of next record different from a CONtINUE record.
+ *
+ * @return array
+ */
+ private function getSplicedRecordData()
+ {
+ $data = '';
+ $spliceOffsets = [];
+
+ $i = 0;
+ $spliceOffsets[0] = 0;
+
+ do {
+ ++$i;
+
+ // offset: 0; size: 2; identifier
+ $identifier = self::getUInt2d($this->data, $this->pos);
+ // offset: 2; size: 2; length
+ $length = self::getUInt2d($this->data, $this->pos + 2);
+ $data .= $this->readRecordData($this->data, $this->pos + 4, $length);
+
+ $spliceOffsets[$i] = $spliceOffsets[$i - 1] + $length;
+
+ $this->pos += 4 + $length;
+ $nextIdentifier = self::getUInt2d($this->data, $this->pos);
+ } while ($nextIdentifier == self::XLS_TYPE_CONTINUE);
+
+ return [
+ 'recordData' => $data,
+ 'spliceOffsets' => $spliceOffsets,
+ ];
+ }
+
+ /**
+ * Convert formula structure into human readable Excel formula like 'A3+A5*5'.
+ *
+ * @param string $formulaStructure The complete binary data for the formula
+ * @param string $baseCell Base cell, only needed when formula contains tRefN tokens, e.g. with shared formulas
+ *
+ * @return string Human readable formula
+ */
+ private function getFormulaFromStructure($formulaStructure, $baseCell = 'A1')
+ {
+ // offset: 0; size: 2; size of the following formula data
+ $sz = self::getUInt2d($formulaStructure, 0);
+
+ // offset: 2; size: sz
+ $formulaData = substr($formulaStructure, 2, $sz);
+
+ // offset: 2 + sz; size: variable (optional)
+ if (strlen($formulaStructure) > 2 + $sz) {
+ $additionalData = substr($formulaStructure, 2 + $sz);
+ } else {
+ $additionalData = '';
+ }
+
+ return $this->getFormulaFromData($formulaData, $additionalData, $baseCell);
+ }
+
+ /**
+ * Take formula data and additional data for formula and return human readable formula.
+ *
+ * @param string $formulaData The binary data for the formula itself
+ * @param string $additionalData Additional binary data going with the formula
+ * @param string $baseCell Base cell, only needed when formula contains tRefN tokens, e.g. with shared formulas
+ *
+ * @return string Human readable formula
+ */
+ private function getFormulaFromData($formulaData, $additionalData = '', $baseCell = 'A1')
+ {
+ // start parsing the formula data
+ $tokens = [];
+
+ while (strlen($formulaData) > 0 && $token = $this->getNextToken($formulaData, $baseCell)) {
+ $tokens[] = $token;
+ $formulaData = substr($formulaData, $token['size']);
+ }
+
+ $formulaString = $this->createFormulaFromTokens($tokens, $additionalData);
+
+ return $formulaString;
+ }
+
+ /**
+ * Take array of tokens together with additional data for formula and return human readable formula.
+ *
+ * @param array $tokens
+ * @param string $additionalData Additional binary data going with the formula
+ *
+ * @return string Human readable formula
+ */
+ private function createFormulaFromTokens($tokens, $additionalData)
+ {
+ // empty formula?
+ if (empty($tokens)) {
+ return '';
+ }
+
+ $formulaStrings = [];
+ foreach ($tokens as $token) {
+ // initialize spaces
+ $space0 = $space0 ?? ''; // spaces before next token, not tParen
+ $space1 = $space1 ?? ''; // carriage returns before next token, not tParen
+ $space2 = $space2 ?? ''; // spaces before opening parenthesis
+ $space3 = $space3 ?? ''; // carriage returns before opening parenthesis
+ $space4 = $space4 ?? ''; // spaces before closing parenthesis
+ $space5 = $space5 ?? ''; // carriage returns before closing parenthesis
+
+ switch ($token['name']) {
+ case 'tAdd': // addition
+ case 'tConcat': // addition
+ case 'tDiv': // division
+ case 'tEQ': // equality
+ case 'tGE': // greater than or equal
+ case 'tGT': // greater than
+ case 'tIsect': // intersection
+ case 'tLE': // less than or equal
+ case 'tList': // less than or equal
+ case 'tLT': // less than
+ case 'tMul': // multiplication
+ case 'tNE': // multiplication
+ case 'tPower': // power
+ case 'tRange': // range
+ case 'tSub': // subtraction
+ $op2 = array_pop($formulaStrings);
+ $op1 = array_pop($formulaStrings);
+ $formulaStrings[] = "$op1$space1$space0{$token['data']}$op2";
+ unset($space0, $space1);
+
+ break;
+ case 'tUplus': // unary plus
+ case 'tUminus': // unary minus
+ $op = array_pop($formulaStrings);
+ $formulaStrings[] = "$space1$space0{$token['data']}$op";
+ unset($space0, $space1);
+
+ break;
+ case 'tPercent': // percent sign
+ $op = array_pop($formulaStrings);
+ $formulaStrings[] = "$op$space1$space0{$token['data']}";
+ unset($space0, $space1);
+
+ break;
+ case 'tAttrVolatile': // indicates volatile function
+ case 'tAttrIf':
+ case 'tAttrSkip':
+ case 'tAttrChoose':
+ // token is only important for Excel formula evaluator
+ // do nothing
+ break;
+ case 'tAttrSpace': // space / carriage return
+ // space will be used when next token arrives, do not alter formulaString stack
+ switch ($token['data']['spacetype']) {
+ case 'type0':
+ $space0 = str_repeat(' ', $token['data']['spacecount']);
+
+ break;
+ case 'type1':
+ $space1 = str_repeat("\n", $token['data']['spacecount']);
+
+ break;
+ case 'type2':
+ $space2 = str_repeat(' ', $token['data']['spacecount']);
+
+ break;
+ case 'type3':
+ $space3 = str_repeat("\n", $token['data']['spacecount']);
+
+ break;
+ case 'type4':
+ $space4 = str_repeat(' ', $token['data']['spacecount']);
+
+ break;
+ case 'type5':
+ $space5 = str_repeat("\n", $token['data']['spacecount']);
+
+ break;
+ }
+
+ break;
+ case 'tAttrSum': // SUM function with one parameter
+ $op = array_pop($formulaStrings);
+ $formulaStrings[] = "{$space1}{$space0}SUM($op)";
+ unset($space0, $space1);
+
+ break;
+ case 'tFunc': // function with fixed number of arguments
+ case 'tFuncV': // function with variable number of arguments
+ if ($token['data']['function'] != '') {
+ // normal function
+ $ops = []; // array of operators
+ for ($i = 0; $i < $token['data']['args']; ++$i) {
+ $ops[] = array_pop($formulaStrings);
+ }
+ $ops = array_reverse($ops);
+ $formulaStrings[] = "$space1$space0{$token['data']['function']}(" . implode(',', $ops) . ')';
+ unset($space0, $space1);
+ } else {
+ // add-in function
+ $ops = []; // array of operators
+ for ($i = 0; $i < $token['data']['args'] - 1; ++$i) {
+ $ops[] = array_pop($formulaStrings);
+ }
+ $ops = array_reverse($ops);
+ $function = array_pop($formulaStrings);
+ $formulaStrings[] = "$space1$space0$function(" . implode(',', $ops) . ')';
+ unset($space0, $space1);
+ }
+
+ break;
+ case 'tParen': // parenthesis
+ $expression = array_pop($formulaStrings);
+ $formulaStrings[] = "$space3$space2($expression$space5$space4)";
+ unset($space2, $space3, $space4, $space5);
+
+ break;
+ case 'tArray': // array constant
+ $constantArray = self::readBIFF8ConstantArray($additionalData);
+ $formulaStrings[] = $space1 . $space0 . $constantArray['value'];
+ $additionalData = substr($additionalData, $constantArray['size']); // bite of chunk of additional data
+ unset($space0, $space1);
+
+ break;
+ case 'tMemArea':
+ // bite off chunk of additional data
+ $cellRangeAddressList = $this->readBIFF8CellRangeAddressList($additionalData);
+ $additionalData = substr($additionalData, $cellRangeAddressList['size']);
+ $formulaStrings[] = "$space1$space0{$token['data']}";
+ unset($space0, $space1);
+
+ break;
+ case 'tArea': // cell range address
+ case 'tBool': // boolean
+ case 'tErr': // error code
+ case 'tInt': // integer
+ case 'tMemErr':
+ case 'tMemFunc':
+ case 'tMissArg':
+ case 'tName':
+ case 'tNameX':
+ case 'tNum': // number
+ case 'tRef': // single cell reference
+ case 'tRef3d': // 3d cell reference
+ case 'tArea3d': // 3d cell range reference
+ case 'tRefN':
+ case 'tAreaN':
+ case 'tStr': // string
+ $formulaStrings[] = "$space1$space0{$token['data']}";
+ unset($space0, $space1);
+
+ break;
+ }
+ }
+ $formulaString = $formulaStrings[0];
+
+ return $formulaString;
+ }
+
+ /**
+ * Fetch next token from binary formula data.
+ *
+ * @param string $formulaData Formula data
+ * @param string $baseCell Base cell, only needed when formula contains tRefN tokens, e.g. with shared formulas
+ *
+ * @return array
+ */
+ private function getNextToken($formulaData, $baseCell = 'A1')
+ {
+ // offset: 0; size: 1; token id
+ $id = ord($formulaData[0]); // token id
+ $name = false; // initialize token name
+
+ switch ($id) {
+ case 0x03:
+ $name = 'tAdd';
+ $size = 1;
+ $data = '+';
+
+ break;
+ case 0x04:
+ $name = 'tSub';
+ $size = 1;
+ $data = '-';
+
+ break;
+ case 0x05:
+ $name = 'tMul';
+ $size = 1;
+ $data = '*';
+
+ break;
+ case 0x06:
+ $name = 'tDiv';
+ $size = 1;
+ $data = '/';
+
+ break;
+ case 0x07:
+ $name = 'tPower';
+ $size = 1;
+ $data = '^';
+
+ break;
+ case 0x08:
+ $name = 'tConcat';
+ $size = 1;
+ $data = '&';
+
+ break;
+ case 0x09:
+ $name = 'tLT';
+ $size = 1;
+ $data = '<';
+
+ break;
+ case 0x0A:
+ $name = 'tLE';
+ $size = 1;
+ $data = '<=';
+
+ break;
+ case 0x0B:
+ $name = 'tEQ';
+ $size = 1;
+ $data = '=';
+
+ break;
+ case 0x0C:
+ $name = 'tGE';
+ $size = 1;
+ $data = '>=';
+
+ break;
+ case 0x0D:
+ $name = 'tGT';
+ $size = 1;
+ $data = '>';
+
+ break;
+ case 0x0E:
+ $name = 'tNE';
+ $size = 1;
+ $data = '<>';
+
+ break;
+ case 0x0F:
+ $name = 'tIsect';
+ $size = 1;
+ $data = ' ';
+
+ break;
+ case 0x10:
+ $name = 'tList';
+ $size = 1;
+ $data = ',';
+
+ break;
+ case 0x11:
+ $name = 'tRange';
+ $size = 1;
+ $data = ':';
+
+ break;
+ case 0x12:
+ $name = 'tUplus';
+ $size = 1;
+ $data = '+';
+
+ break;
+ case 0x13:
+ $name = 'tUminus';
+ $size = 1;
+ $data = '-';
+
+ break;
+ case 0x14:
+ $name = 'tPercent';
+ $size = 1;
+ $data = '%';
+
+ break;
+ case 0x15: // parenthesis
+ $name = 'tParen';
+ $size = 1;
+ $data = null;
+
+ break;
+ case 0x16: // missing argument
+ $name = 'tMissArg';
+ $size = 1;
+ $data = '';
+
+ break;
+ case 0x17: // string
+ $name = 'tStr';
+ // offset: 1; size: var; Unicode string, 8-bit string length
+ $string = self::readUnicodeStringShort(substr($formulaData, 1));
+ $size = 1 + $string['size'];
+ $data = self::UTF8toExcelDoubleQuoted($string['value']);
+
+ break;
+ case 0x19: // Special attribute
+ // offset: 1; size: 1; attribute type flags:
+ switch (ord($formulaData[1])) {
+ case 0x01:
+ $name = 'tAttrVolatile';
+ $size = 4;
+ $data = null;
+
+ break;
+ case 0x02:
+ $name = 'tAttrIf';
+ $size = 4;
+ $data = null;
+
+ break;
+ case 0x04:
+ $name = 'tAttrChoose';
+ // offset: 2; size: 2; number of choices in the CHOOSE function ($nc, number of parameters decreased by 1)
+ $nc = self::getUInt2d($formulaData, 2);
+ // offset: 4; size: 2 * $nc
+ // offset: 4 + 2 * $nc; size: 2
+ $size = 2 * $nc + 6;
+ $data = null;
+
+ break;
+ case 0x08:
+ $name = 'tAttrSkip';
+ $size = 4;
+ $data = null;
+
+ break;
+ case 0x10:
+ $name = 'tAttrSum';
+ $size = 4;
+ $data = null;
+
+ break;
+ case 0x40:
+ case 0x41:
+ $name = 'tAttrSpace';
+ $size = 4;
+ // offset: 2; size: 2; space type and position
+ switch (ord($formulaData[2])) {
+ case 0x00:
+ $spacetype = 'type0';
+
+ break;
+ case 0x01:
+ $spacetype = 'type1';
+
+ break;
+ case 0x02:
+ $spacetype = 'type2';
+
+ break;
+ case 0x03:
+ $spacetype = 'type3';
+
+ break;
+ case 0x04:
+ $spacetype = 'type4';
+
+ break;
+ case 0x05:
+ $spacetype = 'type5';
+
+ break;
+ default:
+ throw new Exception('Unrecognized space type in tAttrSpace token');
+
+ break;
+ }
+ // offset: 3; size: 1; number of inserted spaces/carriage returns
+ $spacecount = ord($formulaData[3]);
+
+ $data = ['spacetype' => $spacetype, 'spacecount' => $spacecount];
+
+ break;
+ default:
+ throw new Exception('Unrecognized attribute flag in tAttr token');
+
+ break;
+ }
+
+ break;
+ case 0x1C: // error code
+ // offset: 1; size: 1; error code
+ $name = 'tErr';
+ $size = 2;
+ $data = Xls\ErrorCode::lookup(ord($formulaData[1]));
+
+ break;
+ case 0x1D: // boolean
+ // offset: 1; size: 1; 0 = false, 1 = true;
+ $name = 'tBool';
+ $size = 2;
+ $data = ord($formulaData[1]) ? 'TRUE' : 'FALSE';
+
+ break;
+ case 0x1E: // integer
+ // offset: 1; size: 2; unsigned 16-bit integer
+ $name = 'tInt';
+ $size = 3;
+ $data = self::getUInt2d($formulaData, 1);
+
+ break;
+ case 0x1F: // number
+ // offset: 1; size: 8;
+ $name = 'tNum';
+ $size = 9;
+ $data = self::extractNumber(substr($formulaData, 1));
+ $data = str_replace(',', '.', (string) $data); // in case non-English locale
+
+ break;
+ case 0x20: // array constant
+ case 0x40:
+ case 0x60:
+ // offset: 1; size: 7; not used
+ $name = 'tArray';
+ $size = 8;
+ $data = null;
+
+ break;
+ case 0x21: // function with fixed number of arguments
+ case 0x41:
+ case 0x61:
+ $name = 'tFunc';
+ $size = 3;
+ // offset: 1; size: 2; index to built-in sheet function
+ switch (self::getUInt2d($formulaData, 1)) {
+ case 2:
+ $function = 'ISNA';
+ $args = 1;
+
+ break;
+ case 3:
+ $function = 'ISERROR';
+ $args = 1;
+
+ break;
+ case 10:
+ $function = 'NA';
+ $args = 0;
+
+ break;
+ case 15:
+ $function = 'SIN';
+ $args = 1;
+
+ break;
+ case 16:
+ $function = 'COS';
+ $args = 1;
+
+ break;
+ case 17:
+ $function = 'TAN';
+ $args = 1;
+
+ break;
+ case 18:
+ $function = 'ATAN';
+ $args = 1;
+
+ break;
+ case 19:
+ $function = 'PI';
+ $args = 0;
+
+ break;
+ case 20:
+ $function = 'SQRT';
+ $args = 1;
+
+ break;
+ case 21:
+ $function = 'EXP';
+ $args = 1;
+
+ break;
+ case 22:
+ $function = 'LN';
+ $args = 1;
+
+ break;
+ case 23:
+ $function = 'LOG10';
+ $args = 1;
+
+ break;
+ case 24:
+ $function = 'ABS';
+ $args = 1;
+
+ break;
+ case 25:
+ $function = 'INT';
+ $args = 1;
+
+ break;
+ case 26:
+ $function = 'SIGN';
+ $args = 1;
+
+ break;
+ case 27:
+ $function = 'ROUND';
+ $args = 2;
+
+ break;
+ case 30:
+ $function = 'REPT';
+ $args = 2;
+
+ break;
+ case 31:
+ $function = 'MID';
+ $args = 3;
+
+ break;
+ case 32:
+ $function = 'LEN';
+ $args = 1;
+
+ break;
+ case 33:
+ $function = 'VALUE';
+ $args = 1;
+
+ break;
+ case 34:
+ $function = 'TRUE';
+ $args = 0;
+
+ break;
+ case 35:
+ $function = 'FALSE';
+ $args = 0;
+
+ break;
+ case 38:
+ $function = 'NOT';
+ $args = 1;
+
+ break;
+ case 39:
+ $function = 'MOD';
+ $args = 2;
+
+ break;
+ case 40:
+ $function = 'DCOUNT';
+ $args = 3;
+
+ break;
+ case 41:
+ $function = 'DSUM';
+ $args = 3;
+
+ break;
+ case 42:
+ $function = 'DAVERAGE';
+ $args = 3;
+
+ break;
+ case 43:
+ $function = 'DMIN';
+ $args = 3;
+
+ break;
+ case 44:
+ $function = 'DMAX';
+ $args = 3;
+
+ break;
+ case 45:
+ $function = 'DSTDEV';
+ $args = 3;
+
+ break;
+ case 48:
+ $function = 'TEXT';
+ $args = 2;
+
+ break;
+ case 61:
+ $function = 'MIRR';
+ $args = 3;
+
+ break;
+ case 63:
+ $function = 'RAND';
+ $args = 0;
+
+ break;
+ case 65:
+ $function = 'DATE';
+ $args = 3;
+
+ break;
+ case 66:
+ $function = 'TIME';
+ $args = 3;
+
+ break;
+ case 67:
+ $function = 'DAY';
+ $args = 1;
+
+ break;
+ case 68:
+ $function = 'MONTH';
+ $args = 1;
+
+ break;
+ case 69:
+ $function = 'YEAR';
+ $args = 1;
+
+ break;
+ case 71:
+ $function = 'HOUR';
+ $args = 1;
+
+ break;
+ case 72:
+ $function = 'MINUTE';
+ $args = 1;
+
+ break;
+ case 73:
+ $function = 'SECOND';
+ $args = 1;
+
+ break;
+ case 74:
+ $function = 'NOW';
+ $args = 0;
+
+ break;
+ case 75:
+ $function = 'AREAS';
+ $args = 1;
+
+ break;
+ case 76:
+ $function = 'ROWS';
+ $args = 1;
+
+ break;
+ case 77:
+ $function = 'COLUMNS';
+ $args = 1;
+
+ break;
+ case 83:
+ $function = 'TRANSPOSE';
+ $args = 1;
+
+ break;
+ case 86:
+ $function = 'TYPE';
+ $args = 1;
+
+ break;
+ case 97:
+ $function = 'ATAN2';
+ $args = 2;
+
+ break;
+ case 98:
+ $function = 'ASIN';
+ $args = 1;
+
+ break;
+ case 99:
+ $function = 'ACOS';
+ $args = 1;
+
+ break;
+ case 105:
+ $function = 'ISREF';
+ $args = 1;
+
+ break;
+ case 111:
+ $function = 'CHAR';
+ $args = 1;
+
+ break;
+ case 112:
+ $function = 'LOWER';
+ $args = 1;
+
+ break;
+ case 113:
+ $function = 'UPPER';
+ $args = 1;
+
+ break;
+ case 114:
+ $function = 'PROPER';
+ $args = 1;
+
+ break;
+ case 117:
+ $function = 'EXACT';
+ $args = 2;
+
+ break;
+ case 118:
+ $function = 'TRIM';
+ $args = 1;
+
+ break;
+ case 119:
+ $function = 'REPLACE';
+ $args = 4;
+
+ break;
+ case 121:
+ $function = 'CODE';
+ $args = 1;
+
+ break;
+ case 126:
+ $function = 'ISERR';
+ $args = 1;
+
+ break;
+ case 127:
+ $function = 'ISTEXT';
+ $args = 1;
+
+ break;
+ case 128:
+ $function = 'ISNUMBER';
+ $args = 1;
+
+ break;
+ case 129:
+ $function = 'ISBLANK';
+ $args = 1;
+
+ break;
+ case 130:
+ $function = 'T';
+ $args = 1;
+
+ break;
+ case 131:
+ $function = 'N';
+ $args = 1;
+
+ break;
+ case 140:
+ $function = 'DATEVALUE';
+ $args = 1;
+
+ break;
+ case 141:
+ $function = 'TIMEVALUE';
+ $args = 1;
+
+ break;
+ case 142:
+ $function = 'SLN';
+ $args = 3;
+
+ break;
+ case 143:
+ $function = 'SYD';
+ $args = 4;
+
+ break;
+ case 162:
+ $function = 'CLEAN';
+ $args = 1;
+
+ break;
+ case 163:
+ $function = 'MDETERM';
+ $args = 1;
+
+ break;
+ case 164:
+ $function = 'MINVERSE';
+ $args = 1;
+
+ break;
+ case 165:
+ $function = 'MMULT';
+ $args = 2;
+
+ break;
+ case 184:
+ $function = 'FACT';
+ $args = 1;
+
+ break;
+ case 189:
+ $function = 'DPRODUCT';
+ $args = 3;
+
+ break;
+ case 190:
+ $function = 'ISNONTEXT';
+ $args = 1;
+
+ break;
+ case 195:
+ $function = 'DSTDEVP';
+ $args = 3;
+
+ break;
+ case 196:
+ $function = 'DVARP';
+ $args = 3;
+
+ break;
+ case 198:
+ $function = 'ISLOGICAL';
+ $args = 1;
+
+ break;
+ case 199:
+ $function = 'DCOUNTA';
+ $args = 3;
+
+ break;
+ case 207:
+ $function = 'REPLACEB';
+ $args = 4;
+
+ break;
+ case 210:
+ $function = 'MIDB';
+ $args = 3;
+
+ break;
+ case 211:
+ $function = 'LENB';
+ $args = 1;
+
+ break;
+ case 212:
+ $function = 'ROUNDUP';
+ $args = 2;
+
+ break;
+ case 213:
+ $function = 'ROUNDDOWN';
+ $args = 2;
+
+ break;
+ case 214:
+ $function = 'ASC';
+ $args = 1;
+
+ break;
+ case 215:
+ $function = 'DBCS';
+ $args = 1;
+
+ break;
+ case 221:
+ $function = 'TODAY';
+ $args = 0;
+
+ break;
+ case 229:
+ $function = 'SINH';
+ $args = 1;
+
+ break;
+ case 230:
+ $function = 'COSH';
+ $args = 1;
+
+ break;
+ case 231:
+ $function = 'TANH';
+ $args = 1;
+
+ break;
+ case 232:
+ $function = 'ASINH';
+ $args = 1;
+
+ break;
+ case 233:
+ $function = 'ACOSH';
+ $args = 1;
+
+ break;
+ case 234:
+ $function = 'ATANH';
+ $args = 1;
+
+ break;
+ case 235:
+ $function = 'DGET';
+ $args = 3;
+
+ break;
+ case 244:
+ $function = 'INFO';
+ $args = 1;
+
+ break;
+ case 252:
+ $function = 'FREQUENCY';
+ $args = 2;
+
+ break;
+ case 261:
+ $function = 'ERROR.TYPE';
+ $args = 1;
+
+ break;
+ case 271:
+ $function = 'GAMMALN';
+ $args = 1;
+
+ break;
+ case 273:
+ $function = 'BINOMDIST';
+ $args = 4;
+
+ break;
+ case 274:
+ $function = 'CHIDIST';
+ $args = 2;
+
+ break;
+ case 275:
+ $function = 'CHIINV';
+ $args = 2;
+
+ break;
+ case 276:
+ $function = 'COMBIN';
+ $args = 2;
+
+ break;
+ case 277:
+ $function = 'CONFIDENCE';
+ $args = 3;
+
+ break;
+ case 278:
+ $function = 'CRITBINOM';
+ $args = 3;
+
+ break;
+ case 279:
+ $function = 'EVEN';
+ $args = 1;
+
+ break;
+ case 280:
+ $function = 'EXPONDIST';
+ $args = 3;
+
+ break;
+ case 281:
+ $function = 'FDIST';
+ $args = 3;
+
+ break;
+ case 282:
+ $function = 'FINV';
+ $args = 3;
+
+ break;
+ case 283:
+ $function = 'FISHER';
+ $args = 1;
+
+ break;
+ case 284:
+ $function = 'FISHERINV';
+ $args = 1;
+
+ break;
+ case 285:
+ $function = 'FLOOR';
+ $args = 2;
+
+ break;
+ case 286:
+ $function = 'GAMMADIST';
+ $args = 4;
+
+ break;
+ case 287:
+ $function = 'GAMMAINV';
+ $args = 3;
+
+ break;
+ case 288:
+ $function = 'CEILING';
+ $args = 2;
+
+ break;
+ case 289:
+ $function = 'HYPGEOMDIST';
+ $args = 4;
+
+ break;
+ case 290:
+ $function = 'LOGNORMDIST';
+ $args = 3;
+
+ break;
+ case 291:
+ $function = 'LOGINV';
+ $args = 3;
+
+ break;
+ case 292:
+ $function = 'NEGBINOMDIST';
+ $args = 3;
+
+ break;
+ case 293:
+ $function = 'NORMDIST';
+ $args = 4;
+
+ break;
+ case 294:
+ $function = 'NORMSDIST';
+ $args = 1;
+
+ break;
+ case 295:
+ $function = 'NORMINV';
+ $args = 3;
+
+ break;
+ case 296:
+ $function = 'NORMSINV';
+ $args = 1;
+
+ break;
+ case 297:
+ $function = 'STANDARDIZE';
+ $args = 3;
+
+ break;
+ case 298:
+ $function = 'ODD';
+ $args = 1;
+
+ break;
+ case 299:
+ $function = 'PERMUT';
+ $args = 2;
+
+ break;
+ case 300:
+ $function = 'POISSON';
+ $args = 3;
+
+ break;
+ case 301:
+ $function = 'TDIST';
+ $args = 3;
+
+ break;
+ case 302:
+ $function = 'WEIBULL';
+ $args = 4;
+
+ break;
+ case 303:
+ $function = 'SUMXMY2';
+ $args = 2;
+
+ break;
+ case 304:
+ $function = 'SUMX2MY2';
+ $args = 2;
+
+ break;
+ case 305:
+ $function = 'SUMX2PY2';
+ $args = 2;
+
+ break;
+ case 306:
+ $function = 'CHITEST';
+ $args = 2;
+
+ break;
+ case 307:
+ $function = 'CORREL';
+ $args = 2;
+
+ break;
+ case 308:
+ $function = 'COVAR';
+ $args = 2;
+
+ break;
+ case 309:
+ $function = 'FORECAST';
+ $args = 3;
+
+ break;
+ case 310:
+ $function = 'FTEST';
+ $args = 2;
+
+ break;
+ case 311:
+ $function = 'INTERCEPT';
+ $args = 2;
+
+ break;
+ case 312:
+ $function = 'PEARSON';
+ $args = 2;
+
+ break;
+ case 313:
+ $function = 'RSQ';
+ $args = 2;
+
+ break;
+ case 314:
+ $function = 'STEYX';
+ $args = 2;
+
+ break;
+ case 315:
+ $function = 'SLOPE';
+ $args = 2;
+
+ break;
+ case 316:
+ $function = 'TTEST';
+ $args = 4;
+
+ break;
+ case 325:
+ $function = 'LARGE';
+ $args = 2;
+
+ break;
+ case 326:
+ $function = 'SMALL';
+ $args = 2;
+
+ break;
+ case 327:
+ $function = 'QUARTILE';
+ $args = 2;
+
+ break;
+ case 328:
+ $function = 'PERCENTILE';
+ $args = 2;
+
+ break;
+ case 331:
+ $function = 'TRIMMEAN';
+ $args = 2;
+
+ break;
+ case 332:
+ $function = 'TINV';
+ $args = 2;
+
+ break;
+ case 337:
+ $function = 'POWER';
+ $args = 2;
+
+ break;
+ case 342:
+ $function = 'RADIANS';
+ $args = 1;
+
+ break;
+ case 343:
+ $function = 'DEGREES';
+ $args = 1;
+
+ break;
+ case 346:
+ $function = 'COUNTIF';
+ $args = 2;
+
+ break;
+ case 347:
+ $function = 'COUNTBLANK';
+ $args = 1;
+
+ break;
+ case 350:
+ $function = 'ISPMT';
+ $args = 4;
+
+ break;
+ case 351:
+ $function = 'DATEDIF';
+ $args = 3;
+
+ break;
+ case 352:
+ $function = 'DATESTRING';
+ $args = 1;
+
+ break;
+ case 353:
+ $function = 'NUMBERSTRING';
+ $args = 2;
+
+ break;
+ case 360:
+ $function = 'PHONETIC';
+ $args = 1;
+
+ break;
+ case 368:
+ $function = 'BAHTTEXT';
+ $args = 1;
+
+ break;
+ default:
+ throw new Exception('Unrecognized function in formula');
+
+ break;
+ }
+ $data = ['function' => $function, 'args' => $args];
+
+ break;
+ case 0x22: // function with variable number of arguments
+ case 0x42:
+ case 0x62:
+ $name = 'tFuncV';
+ $size = 4;
+ // offset: 1; size: 1; number of arguments
+ $args = ord($formulaData[1]);
+ // offset: 2: size: 2; index to built-in sheet function
+ $index = self::getUInt2d($formulaData, 2);
+ switch ($index) {
+ case 0:
+ $function = 'COUNT';
+
+ break;
+ case 1:
+ $function = 'IF';
+
+ break;
+ case 4:
+ $function = 'SUM';
+
+ break;
+ case 5:
+ $function = 'AVERAGE';
+
+ break;
+ case 6:
+ $function = 'MIN';
+
+ break;
+ case 7:
+ $function = 'MAX';
+
+ break;
+ case 8:
+ $function = 'ROW';
+
+ break;
+ case 9:
+ $function = 'COLUMN';
+
+ break;
+ case 11:
+ $function = 'NPV';
+
+ break;
+ case 12:
+ $function = 'STDEV';
+
+ break;
+ case 13:
+ $function = 'DOLLAR';
+
+ break;
+ case 14:
+ $function = 'FIXED';
+
+ break;
+ case 28:
+ $function = 'LOOKUP';
+
+ break;
+ case 29:
+ $function = 'INDEX';
+
+ break;
+ case 36:
+ $function = 'AND';
+
+ break;
+ case 37:
+ $function = 'OR';
+
+ break;
+ case 46:
+ $function = 'VAR';
+
+ break;
+ case 49:
+ $function = 'LINEST';
+
+ break;
+ case 50:
+ $function = 'TREND';
+
+ break;
+ case 51:
+ $function = 'LOGEST';
+
+ break;
+ case 52:
+ $function = 'GROWTH';
+
+ break;
+ case 56:
+ $function = 'PV';
+
+ break;
+ case 57:
+ $function = 'FV';
+
+ break;
+ case 58:
+ $function = 'NPER';
+
+ break;
+ case 59:
+ $function = 'PMT';
+
+ break;
+ case 60:
+ $function = 'RATE';
+
+ break;
+ case 62:
+ $function = 'IRR';
+
+ break;
+ case 64:
+ $function = 'MATCH';
+
+ break;
+ case 70:
+ $function = 'WEEKDAY';
+
+ break;
+ case 78:
+ $function = 'OFFSET';
+
+ break;
+ case 82:
+ $function = 'SEARCH';
+
+ break;
+ case 100:
+ $function = 'CHOOSE';
+
+ break;
+ case 101:
+ $function = 'HLOOKUP';
+
+ break;
+ case 102:
+ $function = 'VLOOKUP';
+
+ break;
+ case 109:
+ $function = 'LOG';
+
+ break;
+ case 115:
+ $function = 'LEFT';
+
+ break;
+ case 116:
+ $function = 'RIGHT';
+
+ break;
+ case 120:
+ $function = 'SUBSTITUTE';
+
+ break;
+ case 124:
+ $function = 'FIND';
+
+ break;
+ case 125:
+ $function = 'CELL';
+
+ break;
+ case 144:
+ $function = 'DDB';
+
+ break;
+ case 148:
+ $function = 'INDIRECT';
+
+ break;
+ case 167:
+ $function = 'IPMT';
+
+ break;
+ case 168:
+ $function = 'PPMT';
+
+ break;
+ case 169:
+ $function = 'COUNTA';
+
+ break;
+ case 183:
+ $function = 'PRODUCT';
+
+ break;
+ case 193:
+ $function = 'STDEVP';
+
+ break;
+ case 194:
+ $function = 'VARP';
+
+ break;
+ case 197:
+ $function = 'TRUNC';
+
+ break;
+ case 204:
+ $function = 'USDOLLAR';
+
+ break;
+ case 205:
+ $function = 'FINDB';
+
+ break;
+ case 206:
+ $function = 'SEARCHB';
+
+ break;
+ case 208:
+ $function = 'LEFTB';
+
+ break;
+ case 209:
+ $function = 'RIGHTB';
+
+ break;
+ case 216:
+ $function = 'RANK';
+
+ break;
+ case 219:
+ $function = 'ADDRESS';
+
+ break;
+ case 220:
+ $function = 'DAYS360';
+
+ break;
+ case 222:
+ $function = 'VDB';
+
+ break;
+ case 227:
+ $function = 'MEDIAN';
+
+ break;
+ case 228:
+ $function = 'SUMPRODUCT';
+
+ break;
+ case 247:
+ $function = 'DB';
+
+ break;
+ case 255:
+ $function = '';
+
+ break;
+ case 269:
+ $function = 'AVEDEV';
+
+ break;
+ case 270:
+ $function = 'BETADIST';
+
+ break;
+ case 272:
+ $function = 'BETAINV';
+
+ break;
+ case 317:
+ $function = 'PROB';
+
+ break;
+ case 318:
+ $function = 'DEVSQ';
+
+ break;
+ case 319:
+ $function = 'GEOMEAN';
+
+ break;
+ case 320:
+ $function = 'HARMEAN';
+
+ break;
+ case 321:
+ $function = 'SUMSQ';
+
+ break;
+ case 322:
+ $function = 'KURT';
+
+ break;
+ case 323:
+ $function = 'SKEW';
+
+ break;
+ case 324:
+ $function = 'ZTEST';
+
+ break;
+ case 329:
+ $function = 'PERCENTRANK';
+
+ break;
+ case 330:
+ $function = 'MODE';
+
+ break;
+ case 336:
+ $function = 'CONCATENATE';
+
+ break;
+ case 344:
+ $function = 'SUBTOTAL';
+
+ break;
+ case 345:
+ $function = 'SUMIF';
+
+ break;
+ case 354:
+ $function = 'ROMAN';
+
+ break;
+ case 358:
+ $function = 'GETPIVOTDATA';
+
+ break;
+ case 359:
+ $function = 'HYPERLINK';
+
+ break;
+ case 361:
+ $function = 'AVERAGEA';
+
+ break;
+ case 362:
+ $function = 'MAXA';
+
+ break;
+ case 363:
+ $function = 'MINA';
+
+ break;
+ case 364:
+ $function = 'STDEVPA';
+
+ break;
+ case 365:
+ $function = 'VARPA';
+
+ break;
+ case 366:
+ $function = 'STDEVA';
+
+ break;
+ case 367:
+ $function = 'VARA';
+
+ break;
+ default:
+ throw new Exception('Unrecognized function in formula');
+
+ break;
+ }
+ $data = ['function' => $function, 'args' => $args];
+
+ break;
+ case 0x23: // index to defined name
+ case 0x43:
+ case 0x63:
+ $name = 'tName';
+ $size = 5;
+ // offset: 1; size: 2; one-based index to definedname record
+ $definedNameIndex = self::getUInt2d($formulaData, 1) - 1;
+ // offset: 2; size: 2; not used
+ $data = $this->definedname[$definedNameIndex]['name'];
+
+ break;
+ case 0x24: // single cell reference e.g. A5
+ case 0x44:
+ case 0x64:
+ $name = 'tRef';
+ $size = 5;
+ $data = $this->readBIFF8CellAddress(substr($formulaData, 1, 4));
+
+ break;
+ case 0x25: // cell range reference to cells in the same sheet (2d)
+ case 0x45:
+ case 0x65:
+ $name = 'tArea';
+ $size = 9;
+ $data = $this->readBIFF8CellRangeAddress(substr($formulaData, 1, 8));
+
+ break;
+ case 0x26: // Constant reference sub-expression
+ case 0x46:
+ case 0x66:
+ $name = 'tMemArea';
+ // offset: 1; size: 4; not used
+ // offset: 5; size: 2; size of the following subexpression
+ $subSize = self::getUInt2d($formulaData, 5);
+ $size = 7 + $subSize;
+ $data = $this->getFormulaFromData(substr($formulaData, 7, $subSize));
+
+ break;
+ case 0x27: // Deleted constant reference sub-expression
+ case 0x47:
+ case 0x67:
+ $name = 'tMemErr';
+ // offset: 1; size: 4; not used
+ // offset: 5; size: 2; size of the following subexpression
+ $subSize = self::getUInt2d($formulaData, 5);
+ $size = 7 + $subSize;
+ $data = $this->getFormulaFromData(substr($formulaData, 7, $subSize));
+
+ break;
+ case 0x29: // Variable reference sub-expression
+ case 0x49:
+ case 0x69:
+ $name = 'tMemFunc';
+ // offset: 1; size: 2; size of the following sub-expression
+ $subSize = self::getUInt2d($formulaData, 1);
+ $size = 3 + $subSize;
+ $data = $this->getFormulaFromData(substr($formulaData, 3, $subSize));
+
+ break;
+ case 0x2C: // Relative 2d cell reference reference, used in shared formulas and some other places
+ case 0x4C:
+ case 0x6C:
+ $name = 'tRefN';
+ $size = 5;
+ $data = $this->readBIFF8CellAddressB(substr($formulaData, 1, 4), $baseCell);
+
+ break;
+ case 0x2D: // Relative 2d range reference
+ case 0x4D:
+ case 0x6D:
+ $name = 'tAreaN';
+ $size = 9;
+ $data = $this->readBIFF8CellRangeAddressB(substr($formulaData, 1, 8), $baseCell);
+
+ break;
+ case 0x39: // External name
+ case 0x59:
+ case 0x79:
+ $name = 'tNameX';
+ $size = 7;
+ // offset: 1; size: 2; index to REF entry in EXTERNSHEET record
+ // offset: 3; size: 2; one-based index to DEFINEDNAME or EXTERNNAME record
+ $index = self::getUInt2d($formulaData, 3);
+ // assume index is to EXTERNNAME record
+ $data = $this->externalNames[$index - 1]['name'];
+ // offset: 5; size: 2; not used
+ break;
+ case 0x3A: // 3d reference to cell
+ case 0x5A:
+ case 0x7A:
+ $name = 'tRef3d';
+ $size = 7;
+
+ try {
+ // offset: 1; size: 2; index to REF entry
+ $sheetRange = $this->readSheetRangeByRefIndex(self::getUInt2d($formulaData, 1));
+ // offset: 3; size: 4; cell address
+ $cellAddress = $this->readBIFF8CellAddress(substr($formulaData, 3, 4));
+
+ $data = "$sheetRange!$cellAddress";
+ } catch (PhpSpreadsheetException $e) {
+ // deleted sheet reference
+ $data = '#REF!';
+ }
+
+ break;
+ case 0x3B: // 3d reference to cell range
+ case 0x5B:
+ case 0x7B:
+ $name = 'tArea3d';
+ $size = 11;
+
+ try {
+ // offset: 1; size: 2; index to REF entry
+ $sheetRange = $this->readSheetRangeByRefIndex(self::getUInt2d($formulaData, 1));
+ // offset: 3; size: 8; cell address
+ $cellRangeAddress = $this->readBIFF8CellRangeAddress(substr($formulaData, 3, 8));
+
+ $data = "$sheetRange!$cellRangeAddress";
+ } catch (PhpSpreadsheetException $e) {
+ // deleted sheet reference
+ $data = '#REF!';
+ }
+
+ break;
+ // Unknown cases // don't know how to deal with
+ default:
+ throw new Exception('Unrecognized token ' . sprintf('%02X', $id) . ' in formula');
+
+ break;
+ }
+
+ return [
+ 'id' => $id,
+ 'name' => $name,
+ 'size' => $size,
+ 'data' => $data,
+ ];
+ }
+
+ /**
+ * Reads a cell address in BIFF8 e.g. 'A2' or '$A$2'
+ * section 3.3.4.
+ *
+ * @param string $cellAddressStructure
+ *
+ * @return string
+ */
+ private function readBIFF8CellAddress($cellAddressStructure)
+ {
+ // offset: 0; size: 2; index to row (0... 65535) (or offset (-32768... 32767))
+ $row = self::getUInt2d($cellAddressStructure, 0) + 1;
+
+ // offset: 2; size: 2; index to column or column offset + relative flags
+ // bit: 7-0; mask 0x00FF; column index
+ $column = Coordinate::stringFromColumnIndex((0x00FF & self::getUInt2d($cellAddressStructure, 2)) + 1);
+
+ // bit: 14; mask 0x4000; (1 = relative column index, 0 = absolute column index)
+ if (!(0x4000 & self::getUInt2d($cellAddressStructure, 2))) {
+ $column = '$' . $column;
+ }
+ // bit: 15; mask 0x8000; (1 = relative row index, 0 = absolute row index)
+ if (!(0x8000 & self::getUInt2d($cellAddressStructure, 2))) {
+ $row = '$' . $row;
+ }
+
+ return $column . $row;
+ }
+
+ /**
+ * Reads a cell address in BIFF8 for shared formulas. Uses positive and negative values for row and column
+ * to indicate offsets from a base cell
+ * section 3.3.4.
+ *
+ * @param string $cellAddressStructure
+ * @param string $baseCell Base cell, only needed when formula contains tRefN tokens, e.g. with shared formulas
+ *
+ * @return string
+ */
+ private function readBIFF8CellAddressB($cellAddressStructure, $baseCell = 'A1')
+ {
+ [$baseCol, $baseRow] = Coordinate::coordinateFromString($baseCell);
+ $baseCol = Coordinate::columnIndexFromString($baseCol) - 1;
+
+ // offset: 0; size: 2; index to row (0... 65535) (or offset (-32768... 32767))
+ $rowIndex = self::getUInt2d($cellAddressStructure, 0);
+ $row = self::getUInt2d($cellAddressStructure, 0) + 1;
+
+ // bit: 14; mask 0x4000; (1 = relative column index, 0 = absolute column index)
+ if (!(0x4000 & self::getUInt2d($cellAddressStructure, 2))) {
+ // offset: 2; size: 2; index to column or column offset + relative flags
+ // bit: 7-0; mask 0x00FF; column index
+ $colIndex = 0x00FF & self::getUInt2d($cellAddressStructure, 2);
+
+ $column = Coordinate::stringFromColumnIndex($colIndex + 1);
+ $column = '$' . $column;
+ } else {
+ // offset: 2; size: 2; index to column or column offset + relative flags
+ // bit: 7-0; mask 0x00FF; column index
+ $relativeColIndex = 0x00FF & self::getInt2d($cellAddressStructure, 2);
+ $colIndex = $baseCol + $relativeColIndex;
+ $colIndex = ($colIndex < 256) ? $colIndex : $colIndex - 256;
+ $colIndex = ($colIndex >= 0) ? $colIndex : $colIndex + 256;
+ $column = Coordinate::stringFromColumnIndex($colIndex + 1);
+ }
+
+ // bit: 15; mask 0x8000; (1 = relative row index, 0 = absolute row index)
+ if (!(0x8000 & self::getUInt2d($cellAddressStructure, 2))) {
+ $row = '$' . $row;
+ } else {
+ $rowIndex = ($rowIndex <= 32767) ? $rowIndex : $rowIndex - 65536;
+ $row = $baseRow + $rowIndex;
+ }
+
+ return $column . $row;
+ }
+
+ /**
+ * Reads a cell range address in BIFF5 e.g. 'A2:B6' or 'A1'
+ * always fixed range
+ * section 2.5.14.
+ *
+ * @param string $subData
+ *
+ * @return string
+ */
+ private function readBIFF5CellRangeAddressFixed($subData)
+ {
+ // offset: 0; size: 2; index to first row
+ $fr = self::getUInt2d($subData, 0) + 1;
+
+ // offset: 2; size: 2; index to last row
+ $lr = self::getUInt2d($subData, 2) + 1;
+
+ // offset: 4; size: 1; index to first column
+ $fc = ord($subData[4]);
+
+ // offset: 5; size: 1; index to last column
+ $lc = ord($subData[5]);
+
+ // check values
+ if ($fr > $lr || $fc > $lc) {
+ throw new Exception('Not a cell range address');
+ }
+
+ // column index to letter
+ $fc = Coordinate::stringFromColumnIndex($fc + 1);
+ $lc = Coordinate::stringFromColumnIndex($lc + 1);
+
+ if ($fr == $lr && $fc == $lc) {
+ return "$fc$fr";
+ }
+
+ return "$fc$fr:$lc$lr";
+ }
+
+ /**
+ * Reads a cell range address in BIFF8 e.g. 'A2:B6' or 'A1'
+ * always fixed range
+ * section 2.5.14.
+ *
+ * @param string $subData
+ *
+ * @return string
+ */
+ private function readBIFF8CellRangeAddressFixed($subData)
+ {
+ // offset: 0; size: 2; index to first row
+ $fr = self::getUInt2d($subData, 0) + 1;
+
+ // offset: 2; size: 2; index to last row
+ $lr = self::getUInt2d($subData, 2) + 1;
+
+ // offset: 4; size: 2; index to first column
+ $fc = self::getUInt2d($subData, 4);
+
+ // offset: 6; size: 2; index to last column
+ $lc = self::getUInt2d($subData, 6);
+
+ // check values
+ if ($fr > $lr || $fc > $lc) {
+ throw new Exception('Not a cell range address');
+ }
+
+ // column index to letter
+ $fc = Coordinate::stringFromColumnIndex($fc + 1);
+ $lc = Coordinate::stringFromColumnIndex($lc + 1);
+
+ if ($fr == $lr && $fc == $lc) {
+ return "$fc$fr";
+ }
+
+ return "$fc$fr:$lc$lr";
+ }
+
+ /**
+ * Reads a cell range address in BIFF8 e.g. 'A2:B6' or '$A$2:$B$6'
+ * there are flags indicating whether column/row index is relative
+ * section 3.3.4.
+ *
+ * @param string $subData
+ *
+ * @return string
+ */
+ private function readBIFF8CellRangeAddress($subData)
+ {
+ // todo: if cell range is just a single cell, should this funciton
+ // not just return e.g. 'A1' and not 'A1:A1' ?
+
+ // offset: 0; size: 2; index to first row (0... 65535) (or offset (-32768... 32767))
+ $fr = self::getUInt2d($subData, 0) + 1;
+
+ // offset: 2; size: 2; index to last row (0... 65535) (or offset (-32768... 32767))
+ $lr = self::getUInt2d($subData, 2) + 1;
+
+ // offset: 4; size: 2; index to first column or column offset + relative flags
+
+ // bit: 7-0; mask 0x00FF; column index
+ $fc = Coordinate::stringFromColumnIndex((0x00FF & self::getUInt2d($subData, 4)) + 1);
+
+ // bit: 14; mask 0x4000; (1 = relative column index, 0 = absolute column index)
+ if (!(0x4000 & self::getUInt2d($subData, 4))) {
+ $fc = '$' . $fc;
+ }
+
+ // bit: 15; mask 0x8000; (1 = relative row index, 0 = absolute row index)
+ if (!(0x8000 & self::getUInt2d($subData, 4))) {
+ $fr = '$' . $fr;
+ }
+
+ // offset: 6; size: 2; index to last column or column offset + relative flags
+
+ // bit: 7-0; mask 0x00FF; column index
+ $lc = Coordinate::stringFromColumnIndex((0x00FF & self::getUInt2d($subData, 6)) + 1);
+
+ // bit: 14; mask 0x4000; (1 = relative column index, 0 = absolute column index)
+ if (!(0x4000 & self::getUInt2d($subData, 6))) {
+ $lc = '$' . $lc;
+ }
+
+ // bit: 15; mask 0x8000; (1 = relative row index, 0 = absolute row index)
+ if (!(0x8000 & self::getUInt2d($subData, 6))) {
+ $lr = '$' . $lr;
+ }
+
+ return "$fc$fr:$lc$lr";
+ }
+
+ /**
+ * Reads a cell range address in BIFF8 for shared formulas. Uses positive and negative values for row and column
+ * to indicate offsets from a base cell
+ * section 3.3.4.
+ *
+ * @param string $subData
+ * @param string $baseCell Base cell
+ *
+ * @return string Cell range address
+ */
+ private function readBIFF8CellRangeAddressB($subData, $baseCell = 'A1')
+ {
+ [$baseCol, $baseRow] = Coordinate::coordinateFromString($baseCell);
+ $baseCol = Coordinate::columnIndexFromString($baseCol) - 1;
+
+ // TODO: if cell range is just a single cell, should this funciton
+ // not just return e.g. 'A1' and not 'A1:A1' ?
+
+ // offset: 0; size: 2; first row
+ $frIndex = self::getUInt2d($subData, 0); // adjust below
+
+ // offset: 2; size: 2; relative index to first row (0... 65535) should be treated as offset (-32768... 32767)
+ $lrIndex = self::getUInt2d($subData, 2); // adjust below
+
+ // bit: 14; mask 0x4000; (1 = relative column index, 0 = absolute column index)
+ if (!(0x4000 & self::getUInt2d($subData, 4))) {
+ // absolute column index
+ // offset: 4; size: 2; first column with relative/absolute flags
+ // bit: 7-0; mask 0x00FF; column index
+ $fcIndex = 0x00FF & self::getUInt2d($subData, 4);
+ $fc = Coordinate::stringFromColumnIndex($fcIndex + 1);
+ $fc = '$' . $fc;
+ } else {
+ // column offset
+ // offset: 4; size: 2; first column with relative/absolute flags
+ // bit: 7-0; mask 0x00FF; column index
+ $relativeFcIndex = 0x00FF & self::getInt2d($subData, 4);
+ $fcIndex = $baseCol + $relativeFcIndex;
+ $fcIndex = ($fcIndex < 256) ? $fcIndex : $fcIndex - 256;
+ $fcIndex = ($fcIndex >= 0) ? $fcIndex : $fcIndex + 256;
+ $fc = Coordinate::stringFromColumnIndex($fcIndex + 1);
+ }
+
+ // bit: 15; mask 0x8000; (1 = relative row index, 0 = absolute row index)
+ if (!(0x8000 & self::getUInt2d($subData, 4))) {
+ // absolute row index
+ $fr = $frIndex + 1;
+ $fr = '$' . $fr;
+ } else {
+ // row offset
+ $frIndex = ($frIndex <= 32767) ? $frIndex : $frIndex - 65536;
+ $fr = $baseRow + $frIndex;
+ }
+
+ // bit: 14; mask 0x4000; (1 = relative column index, 0 = absolute column index)
+ if (!(0x4000 & self::getUInt2d($subData, 6))) {
+ // absolute column index
+ // offset: 6; size: 2; last column with relative/absolute flags
+ // bit: 7-0; mask 0x00FF; column index
+ $lcIndex = 0x00FF & self::getUInt2d($subData, 6);
+ $lc = Coordinate::stringFromColumnIndex($lcIndex + 1);
+ $lc = '$' . $lc;
+ } else {
+ // column offset
+ // offset: 4; size: 2; first column with relative/absolute flags
+ // bit: 7-0; mask 0x00FF; column index
+ $relativeLcIndex = 0x00FF & self::getInt2d($subData, 4);
+ $lcIndex = $baseCol + $relativeLcIndex;
+ $lcIndex = ($lcIndex < 256) ? $lcIndex : $lcIndex - 256;
+ $lcIndex = ($lcIndex >= 0) ? $lcIndex : $lcIndex + 256;
+ $lc = Coordinate::stringFromColumnIndex($lcIndex + 1);
+ }
+
+ // bit: 15; mask 0x8000; (1 = relative row index, 0 = absolute row index)
+ if (!(0x8000 & self::getUInt2d($subData, 6))) {
+ // absolute row index
+ $lr = $lrIndex + 1;
+ $lr = '$' . $lr;
+ } else {
+ // row offset
+ $lrIndex = ($lrIndex <= 32767) ? $lrIndex : $lrIndex - 65536;
+ $lr = $baseRow + $lrIndex;
+ }
+
+ return "$fc$fr:$lc$lr";
+ }
+
+ /**
+ * Read BIFF8 cell range address list
+ * section 2.5.15.
+ *
+ * @param string $subData
+ *
+ * @return array
+ */
+ private function readBIFF8CellRangeAddressList($subData)
+ {
+ $cellRangeAddresses = [];
+
+ // offset: 0; size: 2; number of the following cell range addresses
+ $nm = self::getUInt2d($subData, 0);
+
+ $offset = 2;
+ // offset: 2; size: 8 * $nm; list of $nm (fixed) cell range addresses
+ for ($i = 0; $i < $nm; ++$i) {
+ $cellRangeAddresses[] = $this->readBIFF8CellRangeAddressFixed(substr($subData, $offset, 8));
+ $offset += 8;
+ }
+
+ return [
+ 'size' => 2 + 8 * $nm,
+ 'cellRangeAddresses' => $cellRangeAddresses,
+ ];
+ }
+
+ /**
+ * Read BIFF5 cell range address list
+ * section 2.5.15.
+ *
+ * @param string $subData
+ *
+ * @return array
+ */
+ private function readBIFF5CellRangeAddressList($subData)
+ {
+ $cellRangeAddresses = [];
+
+ // offset: 0; size: 2; number of the following cell range addresses
+ $nm = self::getUInt2d($subData, 0);
+
+ $offset = 2;
+ // offset: 2; size: 6 * $nm; list of $nm (fixed) cell range addresses
+ for ($i = 0; $i < $nm; ++$i) {
+ $cellRangeAddresses[] = $this->readBIFF5CellRangeAddressFixed(substr($subData, $offset, 6));
+ $offset += 6;
+ }
+
+ return [
+ 'size' => 2 + 6 * $nm,
+ 'cellRangeAddresses' => $cellRangeAddresses,
+ ];
+ }
+
+ /**
+ * Get a sheet range like Sheet1:Sheet3 from REF index
+ * Note: If there is only one sheet in the range, one gets e.g Sheet1
+ * It can also happen that the REF structure uses the -1 (FFFF) code to indicate deleted sheets,
+ * in which case an Exception is thrown.
+ *
+ * @param int $index
+ *
+ * @return false|string
+ */
+ private function readSheetRangeByRefIndex($index)
+ {
+ if (isset($this->ref[$index])) {
+ $type = $this->externalBooks[$this->ref[$index]['externalBookIndex']]['type'];
+
+ switch ($type) {
+ case 'internal':
+ // check if we have a deleted 3d reference
+ if ($this->ref[$index]['firstSheetIndex'] == 0xFFFF || $this->ref[$index]['lastSheetIndex'] == 0xFFFF) {
+ throw new Exception('Deleted sheet reference');
+ }
+
+ // we have normal sheet range (collapsed or uncollapsed)
+ $firstSheetName = $this->sheets[$this->ref[$index]['firstSheetIndex']]['name'];
+ $lastSheetName = $this->sheets[$this->ref[$index]['lastSheetIndex']]['name'];
+
+ if ($firstSheetName == $lastSheetName) {
+ // collapsed sheet range
+ $sheetRange = $firstSheetName;
+ } else {
+ $sheetRange = "$firstSheetName:$lastSheetName";
+ }
+
+ // escape the single-quotes
+ $sheetRange = str_replace("'", "''", $sheetRange);
+
+ // if there are special characters, we need to enclose the range in single-quotes
+ // todo: check if we have identified the whole set of special characters
+ // it seems that the following characters are not accepted for sheet names
+ // and we may assume that they are not present: []*/:\?
+ if (preg_match("/[ !\"@#£$%&{()}<>=+'|^,;-]/u", $sheetRange)) {
+ $sheetRange = "'$sheetRange'";
+ }
+
+ return $sheetRange;
+
+ break;
+ default:
+ // TODO: external sheet support
+ throw new Exception('Xls reader only supports internal sheets in formulas');
+
+ break;
+ }
+ }
+
+ return false;
+ }
+
+ /**
+ * read BIFF8 constant value array from array data
+ * returns e.g. ['value' => '{1,2;3,4}', 'size' => 40]
+ * section 2.5.8.
+ *
+ * @param string $arrayData
+ *
+ * @return array
+ */
+ private static function readBIFF8ConstantArray($arrayData)
+ {
+ // offset: 0; size: 1; number of columns decreased by 1
+ $nc = ord($arrayData[0]);
+
+ // offset: 1; size: 2; number of rows decreased by 1
+ $nr = self::getUInt2d($arrayData, 1);
+ $size = 3; // initialize
+ $arrayData = substr($arrayData, 3);
+
+ // offset: 3; size: var; list of ($nc + 1) * ($nr + 1) constant values
+ $matrixChunks = [];
+ for ($r = 1; $r <= $nr + 1; ++$r) {
+ $items = [];
+ for ($c = 1; $c <= $nc + 1; ++$c) {
+ $constant = self::readBIFF8Constant($arrayData);
+ $items[] = $constant['value'];
+ $arrayData = substr($arrayData, $constant['size']);
+ $size += $constant['size'];
+ }
+ $matrixChunks[] = implode(',', $items); // looks like e.g. '1,"hello"'
+ }
+ $matrix = '{' . implode(';', $matrixChunks) . '}';
+
+ return [
+ 'value' => $matrix,
+ 'size' => $size,
+ ];
+ }
+
+ /**
+ * read BIFF8 constant value which may be 'Empty Value', 'Number', 'String Value', 'Boolean Value', 'Error Value'
+ * section 2.5.7
+ * returns e.g. ['value' => '5', 'size' => 9].
+ *
+ * @param string $valueData
+ *
+ * @return array
+ */
+ private static function readBIFF8Constant($valueData)
+ {
+ // offset: 0; size: 1; identifier for type of constant
+ $identifier = ord($valueData[0]);
+
+ switch ($identifier) {
+ case 0x00: // empty constant (what is this?)
+ $value = '';
+ $size = 9;
+
+ break;
+ case 0x01: // number
+ // offset: 1; size: 8; IEEE 754 floating-point value
+ $value = self::extractNumber(substr($valueData, 1, 8));
+ $size = 9;
+
+ break;
+ case 0x02: // string value
+ // offset: 1; size: var; Unicode string, 16-bit string length
+ $string = self::readUnicodeStringLong(substr($valueData, 1));
+ $value = '"' . $string['value'] . '"';
+ $size = 1 + $string['size'];
+
+ break;
+ case 0x04: // boolean
+ // offset: 1; size: 1; 0 = FALSE, 1 = TRUE
+ if (ord($valueData[1])) {
+ $value = 'TRUE';
+ } else {
+ $value = 'FALSE';
+ }
+ $size = 9;
+
+ break;
+ case 0x10: // error code
+ // offset: 1; size: 1; error code
+ $value = Xls\ErrorCode::lookup(ord($valueData[1]));
+ $size = 9;
+
+ break;
+ }
+
+ return [
+ 'value' => $value,
+ 'size' => $size,
+ ];
+ }
+
+ /**
+ * Extract RGB color
+ * OpenOffice.org's Documentation of the Microsoft Excel File Format, section 2.5.4.
+ *
+ * @param string $rgb Encoded RGB value (4 bytes)
+ *
+ * @return array
+ */
+ private static function readRGB($rgb)
+ {
+ // offset: 0; size 1; Red component
+ $r = ord($rgb[0]);
+
+ // offset: 1; size: 1; Green component
+ $g = ord($rgb[1]);
+
+ // offset: 2; size: 1; Blue component
+ $b = ord($rgb[2]);
+
+ // HEX notation, e.g. 'FF00FC'
+ $rgb = sprintf('%02X%02X%02X', $r, $g, $b);
+
+ return ['rgb' => $rgb];
+ }
+
+ /**
+ * Read byte string (8-bit string length)
+ * OpenOffice documentation: 2.5.2.
+ *
+ * @param string $subData
+ *
+ * @return array
+ */
+ private function readByteStringShort($subData)
+ {
+ // offset: 0; size: 1; length of the string (character count)
+ $ln = ord($subData[0]);
+
+ // offset: 1: size: var; character array (8-bit characters)
+ $value = $this->decodeCodepage(substr($subData, 1, $ln));
+
+ return [
+ 'value' => $value,
+ 'size' => 1 + $ln, // size in bytes of data structure
+ ];
+ }
+
+ /**
+ * Read byte string (16-bit string length)
+ * OpenOffice documentation: 2.5.2.
+ *
+ * @param string $subData
+ *
+ * @return array
+ */
+ private function readByteStringLong($subData)
+ {
+ // offset: 0; size: 2; length of the string (character count)
+ $ln = self::getUInt2d($subData, 0);
+
+ // offset: 2: size: var; character array (8-bit characters)
+ $value = $this->decodeCodepage(substr($subData, 2));
+
+ //return $string;
+ return [
+ 'value' => $value,
+ 'size' => 2 + $ln, // size in bytes of data structure
+ ];
+ }
+
+ /**
+ * Extracts an Excel Unicode short string (8-bit string length)
+ * OpenOffice documentation: 2.5.3
+ * function will automatically find out where the Unicode string ends.
+ *
+ * @param string $subData
+ *
+ * @return array
+ */
+ private static function readUnicodeStringShort($subData)
+ {
+ $value = '';
+
+ // offset: 0: size: 1; length of the string (character count)
+ $characterCount = ord($subData[0]);
+
+ $string = self::readUnicodeString(substr($subData, 1), $characterCount);
+
+ // add 1 for the string length
+ ++$string['size'];
+
+ return $string;
+ }
+
+ /**
+ * Extracts an Excel Unicode long string (16-bit string length)
+ * OpenOffice documentation: 2.5.3
+ * this function is under construction, needs to support rich text, and Asian phonetic settings.
+ *
+ * @param string $subData
+ *
+ * @return array
+ */
+ private static function readUnicodeStringLong($subData)
+ {
+ $value = '';
+
+ // offset: 0: size: 2; length of the string (character count)
+ $characterCount = self::getUInt2d($subData, 0);
+
+ $string = self::readUnicodeString(substr($subData, 2), $characterCount);
+
+ // add 2 for the string length
+ $string['size'] += 2;
+
+ return $string;
+ }
+
+ /**
+ * Read Unicode string with no string length field, but with known character count
+ * this function is under construction, needs to support rich text, and Asian phonetic settings
+ * OpenOffice.org's Documentation of the Microsoft Excel File Format, section 2.5.3.
+ *
+ * @param string $subData
+ * @param int $characterCount
+ *
+ * @return array
+ */
+ private static function readUnicodeString($subData, $characterCount)
+ {
+ $value = '';
+
+ // offset: 0: size: 1; option flags
+ // bit: 0; mask: 0x01; character compression (0 = compressed 8-bit, 1 = uncompressed 16-bit)
+ $isCompressed = !((0x01 & ord($subData[0])) >> 0);
+
+ // bit: 2; mask: 0x04; Asian phonetic settings
+ $hasAsian = (0x04) & ord($subData[0]) >> 2;
+
+ // bit: 3; mask: 0x08; Rich-Text settings
+ $hasRichText = (0x08) & ord($subData[0]) >> 3;
+
+ // offset: 1: size: var; character array
+ // this offset assumes richtext and Asian phonetic settings are off which is generally wrong
+ // needs to be fixed
+ $value = self::encodeUTF16(substr($subData, 1, $isCompressed ? $characterCount : 2 * $characterCount), $isCompressed);
+
+ return [
+ 'value' => $value,
+ 'size' => $isCompressed ? 1 + $characterCount : 1 + 2 * $characterCount, // the size in bytes including the option flags
+ ];
+ }
+
+ /**
+ * Convert UTF-8 string to string surounded by double quotes. Used for explicit string tokens in formulas.
+ * Example: hello"world --> "hello""world".
+ *
+ * @param string $value UTF-8 encoded string
+ *
+ * @return string
+ */
+ private static function UTF8toExcelDoubleQuoted($value)
+ {
+ return '"' . str_replace('"', '""', $value) . '"';
+ }
+
+ /**
+ * Reads first 8 bytes of a string and return IEEE 754 float.
+ *
+ * @param string $data Binary string that is at least 8 bytes long
+ *
+ * @return float
+ */
+ private static function extractNumber($data)
+ {
+ $rknumhigh = self::getInt4d($data, 4);
+ $rknumlow = self::getInt4d($data, 0);
+ $sign = ($rknumhigh & 0x80000000) >> 31;
+ $exp = (($rknumhigh & 0x7ff00000) >> 20) - 1023;
+ $mantissa = (0x100000 | ($rknumhigh & 0x000fffff));
+ $mantissalow1 = ($rknumlow & 0x80000000) >> 31;
+ $mantissalow2 = ($rknumlow & 0x7fffffff);
+ $value = $mantissa / 2 ** (20 - $exp);
+
+ if ($mantissalow1 != 0) {
+ $value += 1 / 2 ** (21 - $exp);
+ }
+
+ $value += $mantissalow2 / 2 ** (52 - $exp);
+ if ($sign) {
+ $value *= -1;
+ }
+
+ return $value;
+ }
+
+ /**
+ * @param int $rknum
+ *
+ * @return float
+ */
+ private static function getIEEE754($rknum)
+ {
+ if (($rknum & 0x02) != 0) {
+ $value = $rknum >> 2;
+ } else {
+ // changes by mmp, info on IEEE754 encoding from
+ // research.microsoft.com/~hollasch/cgindex/coding/ieeefloat.html
+ // The RK format calls for using only the most significant 30 bits
+ // of the 64 bit floating point value. The other 34 bits are assumed
+ // to be 0 so we use the upper 30 bits of $rknum as follows...
+ $sign = ($rknum & 0x80000000) >> 31;
+ $exp = ($rknum & 0x7ff00000) >> 20;
+ $mantissa = (0x100000 | ($rknum & 0x000ffffc));
+ $value = $mantissa / 2 ** (20 - ($exp - 1023));
+ if ($sign) {
+ $value = -1 * $value;
+ }
+ //end of changes by mmp
+ }
+ if (($rknum & 0x01) != 0) {
+ $value /= 100;
+ }
+
+ return $value;
+ }
+
+ /**
+ * Get UTF-8 string from (compressed or uncompressed) UTF-16 string.
+ *
+ * @param string $string
+ * @param bool $compressed
+ *
+ * @return string
+ */
+ private static function encodeUTF16($string, $compressed = false)
+ {
+ if ($compressed) {
+ $string = self::uncompressByteString($string);
+ }
+
+ return StringHelper::convertEncoding($string, 'UTF-8', 'UTF-16LE');
+ }
+
+ /**
+ * Convert UTF-16 string in compressed notation to uncompressed form. Only used for BIFF8.
+ *
+ * @param string $string
+ *
+ * @return string
+ */
+ private static function uncompressByteString($string)
+ {
+ $uncompressedString = '';
+ $strLen = strlen($string);
+ for ($i = 0; $i < $strLen; ++$i) {
+ $uncompressedString .= $string[$i] . "\0";
+ }
+
+ return $uncompressedString;
+ }
+
+ /**
+ * Convert string to UTF-8. Only used for BIFF5.
+ *
+ * @param string $string
+ *
+ * @return string
+ */
+ private function decodeCodepage($string)
+ {
+ return StringHelper::convertEncoding($string, 'UTF-8', $this->codepage);
+ }
+
+ /**
+ * Read 16-bit unsigned integer.
+ *
+ * @param string $data
+ * @param int $pos
+ *
+ * @return int
+ */
+ public static function getUInt2d($data, $pos)
+ {
+ return ord($data[$pos]) | (ord($data[$pos + 1]) << 8);
+ }
+
+ /**
+ * Read 16-bit signed integer.
+ *
+ * @param string $data
+ * @param int $pos
+ *
+ * @return int
+ */
+ public static function getInt2d($data, $pos)
+ {
+ return unpack('s', $data[$pos] . $data[$pos + 1])[1];
+ }
+
+ /**
+ * Read 32-bit signed integer.
+ *
+ * @param string $data
+ * @param int $pos
+ *
+ * @return int
+ */
+ public static function getInt4d($data, $pos)
+ {
+ // FIX: represent numbers correctly on 64-bit system
+ // http://sourceforge.net/tracker/index.php?func=detail&aid=1487372&group_id=99160&atid=623334
+ // Changed by Andreas Rehm 2006 to ensure correct result of the <<24 block on 32 and 64bit systems
+ $_or_24 = ord($data[$pos + 3]);
+ if ($_or_24 >= 128) {
+ // negative number
+ $_ord_24 = -abs((256 - $_or_24) << 24);
+ } else {
+ $_ord_24 = ($_or_24 & 127) << 24;
+ }
+
+ return ord($data[$pos]) | (ord($data[$pos + 1]) << 8) | (ord($data[$pos + 2]) << 16) | $_ord_24;
+ }
+
+ private function parseRichText($is)
+ {
+ $value = new RichText();
+ $value->createText($is);
+
+ return $value;
+ }
+}
diff --git a/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xls/Color.php b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xls/Color.php new file mode 100644 index 0000000..0b6ad6e --- /dev/null +++ b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xls/Color.php @@ -0,0 +1,36 @@ +<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader\Xls;
+
+use PhpOffice\PhpSpreadsheet\Reader\Xls;
+
+class Color
+{
+ /**
+ * Read color.
+ *
+ * @param int $color Indexed color
+ * @param array $palette Color palette
+ * @param int $version
+ *
+ * @return array RGB color value, example: ['rgb' => 'FF0000']
+ */
+ public static function map($color, $palette, $version)
+ {
+ if ($color <= 0x07 || $color >= 0x40) {
+ // special built-in color
+ return Color\BuiltIn::lookup($color);
+ } elseif (isset($palette, $palette[$color - 8])) {
+ // palette color, color index 0x08 maps to pallete index 0
+ return $palette[$color - 8];
+ }
+
+ // default color table
+ if ($version == Xls::XLS_BIFF8) {
+ return Color\BIFF8::lookup($color);
+ }
+
+ // BIFF5
+ return Color\BIFF5::lookup($color);
+ }
+}
diff --git a/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xls/Color/BIFF5.php b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xls/Color/BIFF5.php new file mode 100644 index 0000000..3536f6b --- /dev/null +++ b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xls/Color/BIFF5.php @@ -0,0 +1,81 @@ +<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader\Xls\Color;
+
+class BIFF5
+{
+ protected static $map = [
+ 0x08 => '000000',
+ 0x09 => 'FFFFFF',
+ 0x0A => 'FF0000',
+ 0x0B => '00FF00',
+ 0x0C => '0000FF',
+ 0x0D => 'FFFF00',
+ 0x0E => 'FF00FF',
+ 0x0F => '00FFFF',
+ 0x10 => '800000',
+ 0x11 => '008000',
+ 0x12 => '000080',
+ 0x13 => '808000',
+ 0x14 => '800080',
+ 0x15 => '008080',
+ 0x16 => 'C0C0C0',
+ 0x17 => '808080',
+ 0x18 => '8080FF',
+ 0x19 => '802060',
+ 0x1A => 'FFFFC0',
+ 0x1B => 'A0E0F0',
+ 0x1C => '600080',
+ 0x1D => 'FF8080',
+ 0x1E => '0080C0',
+ 0x1F => 'C0C0FF',
+ 0x20 => '000080',
+ 0x21 => 'FF00FF',
+ 0x22 => 'FFFF00',
+ 0x23 => '00FFFF',
+ 0x24 => '800080',
+ 0x25 => '800000',
+ 0x26 => '008080',
+ 0x27 => '0000FF',
+ 0x28 => '00CFFF',
+ 0x29 => '69FFFF',
+ 0x2A => 'E0FFE0',
+ 0x2B => 'FFFF80',
+ 0x2C => 'A6CAF0',
+ 0x2D => 'DD9CB3',
+ 0x2E => 'B38FEE',
+ 0x2F => 'E3E3E3',
+ 0x30 => '2A6FF9',
+ 0x31 => '3FB8CD',
+ 0x32 => '488436',
+ 0x33 => '958C41',
+ 0x34 => '8E5E42',
+ 0x35 => 'A0627A',
+ 0x36 => '624FAC',
+ 0x37 => '969696',
+ 0x38 => '1D2FBE',
+ 0x39 => '286676',
+ 0x3A => '004500',
+ 0x3B => '453E01',
+ 0x3C => '6A2813',
+ 0x3D => '85396A',
+ 0x3E => '4A3285',
+ 0x3F => '424242',
+ ];
+
+ /**
+ * Map color array from BIFF5 built-in color index.
+ *
+ * @param int $color
+ *
+ * @return array
+ */
+ public static function lookup($color)
+ {
+ if (isset(self::$map[$color])) {
+ return ['rgb' => self::$map[$color]];
+ }
+
+ return ['rgb' => '000000'];
+ }
+}
diff --git a/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xls/Color/BIFF8.php b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xls/Color/BIFF8.php new file mode 100644 index 0000000..423932c --- /dev/null +++ b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xls/Color/BIFF8.php @@ -0,0 +1,81 @@ +<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader\Xls\Color;
+
+class BIFF8
+{
+ protected static $map = [
+ 0x08 => '000000',
+ 0x09 => 'FFFFFF',
+ 0x0A => 'FF0000',
+ 0x0B => '00FF00',
+ 0x0C => '0000FF',
+ 0x0D => 'FFFF00',
+ 0x0E => 'FF00FF',
+ 0x0F => '00FFFF',
+ 0x10 => '800000',
+ 0x11 => '008000',
+ 0x12 => '000080',
+ 0x13 => '808000',
+ 0x14 => '800080',
+ 0x15 => '008080',
+ 0x16 => 'C0C0C0',
+ 0x17 => '808080',
+ 0x18 => '9999FF',
+ 0x19 => '993366',
+ 0x1A => 'FFFFCC',
+ 0x1B => 'CCFFFF',
+ 0x1C => '660066',
+ 0x1D => 'FF8080',
+ 0x1E => '0066CC',
+ 0x1F => 'CCCCFF',
+ 0x20 => '000080',
+ 0x21 => 'FF00FF',
+ 0x22 => 'FFFF00',
+ 0x23 => '00FFFF',
+ 0x24 => '800080',
+ 0x25 => '800000',
+ 0x26 => '008080',
+ 0x27 => '0000FF',
+ 0x28 => '00CCFF',
+ 0x29 => 'CCFFFF',
+ 0x2A => 'CCFFCC',
+ 0x2B => 'FFFF99',
+ 0x2C => '99CCFF',
+ 0x2D => 'FF99CC',
+ 0x2E => 'CC99FF',
+ 0x2F => 'FFCC99',
+ 0x30 => '3366FF',
+ 0x31 => '33CCCC',
+ 0x32 => '99CC00',
+ 0x33 => 'FFCC00',
+ 0x34 => 'FF9900',
+ 0x35 => 'FF6600',
+ 0x36 => '666699',
+ 0x37 => '969696',
+ 0x38 => '003366',
+ 0x39 => '339966',
+ 0x3A => '003300',
+ 0x3B => '333300',
+ 0x3C => '993300',
+ 0x3D => '993366',
+ 0x3E => '333399',
+ 0x3F => '333333',
+ ];
+
+ /**
+ * Map color array from BIFF8 built-in color index.
+ *
+ * @param int $color
+ *
+ * @return array
+ */
+ public static function lookup($color)
+ {
+ if (isset(self::$map[$color])) {
+ return ['rgb' => self::$map[$color]];
+ }
+
+ return ['rgb' => '000000'];
+ }
+}
diff --git a/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xls/Color/BuiltIn.php b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xls/Color/BuiltIn.php new file mode 100644 index 0000000..2658f0e --- /dev/null +++ b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xls/Color/BuiltIn.php @@ -0,0 +1,35 @@ +<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader\Xls\Color;
+
+class BuiltIn
+{
+ protected static $map = [
+ 0x00 => '000000',
+ 0x01 => 'FFFFFF',
+ 0x02 => 'FF0000',
+ 0x03 => '00FF00',
+ 0x04 => '0000FF',
+ 0x05 => 'FFFF00',
+ 0x06 => 'FF00FF',
+ 0x07 => '00FFFF',
+ 0x40 => '000000', // system window text color
+ 0x41 => 'FFFFFF', // system window background color
+ ];
+
+ /**
+ * Map built-in color to RGB value.
+ *
+ * @param int $color Indexed color
+ *
+ * @return array
+ */
+ public static function lookup($color)
+ {
+ if (isset(self::$map[$color])) {
+ return ['rgb' => self::$map[$color]];
+ }
+
+ return ['rgb' => '000000'];
+ }
+}
diff --git a/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xls/ErrorCode.php b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xls/ErrorCode.php new file mode 100644 index 0000000..4538717 --- /dev/null +++ b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xls/ErrorCode.php @@ -0,0 +1,32 @@ +<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader\Xls;
+
+class ErrorCode
+{
+ protected static $map = [
+ 0x00 => '#NULL!',
+ 0x07 => '#DIV/0!',
+ 0x0F => '#VALUE!',
+ 0x17 => '#REF!',
+ 0x1D => '#NAME?',
+ 0x24 => '#NUM!',
+ 0x2A => '#N/A',
+ ];
+
+ /**
+ * Map error code, e.g. '#N/A'.
+ *
+ * @param int $code
+ *
+ * @return bool|string
+ */
+ public static function lookup($code)
+ {
+ if (isset(self::$map[$code])) {
+ return self::$map[$code];
+ }
+
+ return false;
+ }
+}
diff --git a/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xls/Escher.php b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xls/Escher.php new file mode 100644 index 0000000..646de44 --- /dev/null +++ b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xls/Escher.php @@ -0,0 +1,677 @@ +<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader\Xls;
+
+use PhpOffice\PhpSpreadsheet\Cell\Coordinate;
+use PhpOffice\PhpSpreadsheet\Reader\Xls;
+use PhpOffice\PhpSpreadsheet\Shared\Escher\DgContainer;
+use PhpOffice\PhpSpreadsheet\Shared\Escher\DgContainer\SpgrContainer;
+use PhpOffice\PhpSpreadsheet\Shared\Escher\DgContainer\SpgrContainer\SpContainer;
+use PhpOffice\PhpSpreadsheet\Shared\Escher\DggContainer;
+use PhpOffice\PhpSpreadsheet\Shared\Escher\DggContainer\BstoreContainer;
+use PhpOffice\PhpSpreadsheet\Shared\Escher\DggContainer\BstoreContainer\BSE;
+use PhpOffice\PhpSpreadsheet\Shared\Escher\DggContainer\BstoreContainer\BSE\Blip;
+
+class Escher
+{
+ const DGGCONTAINER = 0xF000;
+ const BSTORECONTAINER = 0xF001;
+ const DGCONTAINER = 0xF002;
+ const SPGRCONTAINER = 0xF003;
+ const SPCONTAINER = 0xF004;
+ const DGG = 0xF006;
+ const BSE = 0xF007;
+ const DG = 0xF008;
+ const SPGR = 0xF009;
+ const SP = 0xF00A;
+ const OPT = 0xF00B;
+ const CLIENTTEXTBOX = 0xF00D;
+ const CLIENTANCHOR = 0xF010;
+ const CLIENTDATA = 0xF011;
+ const BLIPJPEG = 0xF01D;
+ const BLIPPNG = 0xF01E;
+ const SPLITMENUCOLORS = 0xF11E;
+ const TERTIARYOPT = 0xF122;
+
+ /**
+ * Escher stream data (binary).
+ *
+ * @var string
+ */
+ private $data;
+
+ /**
+ * Size in bytes of the Escher stream data.
+ *
+ * @var int
+ */
+ private $dataSize;
+
+ /**
+ * Current position of stream pointer in Escher stream data.
+ *
+ * @var int
+ */
+ private $pos;
+
+ /**
+ * The object to be returned by the reader. Modified during load.
+ *
+ * @var BSE|BstoreContainer|DgContainer|DggContainer|\PhpOffice\PhpSpreadsheet\Shared\Escher|SpContainer|SpgrContainer
+ */
+ private $object;
+
+ /**
+ * Create a new Escher instance.
+ *
+ * @param mixed $object
+ */
+ public function __construct($object)
+ {
+ $this->object = $object;
+ }
+
+ /**
+ * Load Escher stream data. May be a partial Escher stream.
+ *
+ * @param string $data
+ *
+ * @return BSE|BstoreContainer|DgContainer|DggContainer|\PhpOffice\PhpSpreadsheet\Shared\Escher|SpContainer|SpgrContainer
+ */
+ public function load($data)
+ {
+ $this->data = $data;
+
+ // total byte size of Excel data (workbook global substream + sheet substreams)
+ $this->dataSize = strlen($this->data);
+
+ $this->pos = 0;
+
+ // Parse Escher stream
+ while ($this->pos < $this->dataSize) {
+ // offset: 2; size: 2: Record Type
+ $fbt = Xls::getUInt2d($this->data, $this->pos + 2);
+
+ switch ($fbt) {
+ case self::DGGCONTAINER:
+ $this->readDggContainer();
+
+ break;
+ case self::DGG:
+ $this->readDgg();
+
+ break;
+ case self::BSTORECONTAINER:
+ $this->readBstoreContainer();
+
+ break;
+ case self::BSE:
+ $this->readBSE();
+
+ break;
+ case self::BLIPJPEG:
+ $this->readBlipJPEG();
+
+ break;
+ case self::BLIPPNG:
+ $this->readBlipPNG();
+
+ break;
+ case self::OPT:
+ $this->readOPT();
+
+ break;
+ case self::TERTIARYOPT:
+ $this->readTertiaryOPT();
+
+ break;
+ case self::SPLITMENUCOLORS:
+ $this->readSplitMenuColors();
+
+ break;
+ case self::DGCONTAINER:
+ $this->readDgContainer();
+
+ break;
+ case self::DG:
+ $this->readDg();
+
+ break;
+ case self::SPGRCONTAINER:
+ $this->readSpgrContainer();
+
+ break;
+ case self::SPCONTAINER:
+ $this->readSpContainer();
+
+ break;
+ case self::SPGR:
+ $this->readSpgr();
+
+ break;
+ case self::SP:
+ $this->readSp();
+
+ break;
+ case self::CLIENTTEXTBOX:
+ $this->readClientTextbox();
+
+ break;
+ case self::CLIENTANCHOR:
+ $this->readClientAnchor();
+
+ break;
+ case self::CLIENTDATA:
+ $this->readClientData();
+
+ break;
+ default:
+ $this->readDefault();
+
+ break;
+ }
+ }
+
+ return $this->object;
+ }
+
+ /**
+ * Read a generic record.
+ */
+ private function readDefault(): void
+ {
+ // offset 0; size: 2; recVer and recInstance
+ $verInstance = Xls::getUInt2d($this->data, $this->pos);
+
+ // offset: 2; size: 2: Record Type
+ $fbt = Xls::getUInt2d($this->data, $this->pos + 2);
+
+ // bit: 0-3; mask: 0x000F; recVer
+ $recVer = (0x000F & $verInstance) >> 0;
+
+ $length = Xls::getInt4d($this->data, $this->pos + 4);
+ $recordData = substr($this->data, $this->pos + 8, $length);
+
+ // move stream pointer to next record
+ $this->pos += 8 + $length;
+ }
+
+ /**
+ * Read DggContainer record (Drawing Group Container).
+ */
+ private function readDggContainer(): void
+ {
+ $length = Xls::getInt4d($this->data, $this->pos + 4);
+ $recordData = substr($this->data, $this->pos + 8, $length);
+
+ // move stream pointer to next record
+ $this->pos += 8 + $length;
+
+ // record is a container, read contents
+ $dggContainer = new DggContainer();
+ $this->object->setDggContainer($dggContainer);
+ $reader = new self($dggContainer);
+ $reader->load($recordData);
+ }
+
+ /**
+ * Read Dgg record (Drawing Group).
+ */
+ private function readDgg(): void
+ {
+ $length = Xls::getInt4d($this->data, $this->pos + 4);
+ $recordData = substr($this->data, $this->pos + 8, $length);
+
+ // move stream pointer to next record
+ $this->pos += 8 + $length;
+ }
+
+ /**
+ * Read BstoreContainer record (Blip Store Container).
+ */
+ private function readBstoreContainer(): void
+ {
+ $length = Xls::getInt4d($this->data, $this->pos + 4);
+ $recordData = substr($this->data, $this->pos + 8, $length);
+
+ // move stream pointer to next record
+ $this->pos += 8 + $length;
+
+ // record is a container, read contents
+ $bstoreContainer = new BstoreContainer();
+ $this->object->setBstoreContainer($bstoreContainer);
+ $reader = new self($bstoreContainer);
+ $reader->load($recordData);
+ }
+
+ /**
+ * Read BSE record.
+ */
+ private function readBSE(): void
+ {
+ // offset: 0; size: 2; recVer and recInstance
+
+ // bit: 4-15; mask: 0xFFF0; recInstance
+ $recInstance = (0xFFF0 & Xls::getUInt2d($this->data, $this->pos)) >> 4;
+
+ $length = Xls::getInt4d($this->data, $this->pos + 4);
+ $recordData = substr($this->data, $this->pos + 8, $length);
+
+ // move stream pointer to next record
+ $this->pos += 8 + $length;
+
+ // add BSE to BstoreContainer
+ $BSE = new BSE();
+ $this->object->addBSE($BSE);
+
+ $BSE->setBLIPType($recInstance);
+
+ // offset: 0; size: 1; btWin32 (MSOBLIPTYPE)
+ $btWin32 = ord($recordData[0]);
+
+ // offset: 1; size: 1; btWin32 (MSOBLIPTYPE)
+ $btMacOS = ord($recordData[1]);
+
+ // offset: 2; size: 16; MD4 digest
+ $rgbUid = substr($recordData, 2, 16);
+
+ // offset: 18; size: 2; tag
+ $tag = Xls::getUInt2d($recordData, 18);
+
+ // offset: 20; size: 4; size of BLIP in bytes
+ $size = Xls::getInt4d($recordData, 20);
+
+ // offset: 24; size: 4; number of references to this BLIP
+ $cRef = Xls::getInt4d($recordData, 24);
+
+ // offset: 28; size: 4; MSOFO file offset
+ $foDelay = Xls::getInt4d($recordData, 28);
+
+ // offset: 32; size: 1; unused1
+ $unused1 = ord($recordData[32]);
+
+ // offset: 33; size: 1; size of nameData in bytes (including null terminator)
+ $cbName = ord($recordData[33]);
+
+ // offset: 34; size: 1; unused2
+ $unused2 = ord($recordData[34]);
+
+ // offset: 35; size: 1; unused3
+ $unused3 = ord($recordData[35]);
+
+ // offset: 36; size: $cbName; nameData
+ $nameData = substr($recordData, 36, $cbName);
+
+ // offset: 36 + $cbName, size: var; the BLIP data
+ $blipData = substr($recordData, 36 + $cbName);
+
+ // record is a container, read contents
+ $reader = new self($BSE);
+ $reader->load($blipData);
+ }
+
+ /**
+ * Read BlipJPEG record. Holds raw JPEG image data.
+ */
+ private function readBlipJPEG(): void
+ {
+ // offset: 0; size: 2; recVer and recInstance
+
+ // bit: 4-15; mask: 0xFFF0; recInstance
+ $recInstance = (0xFFF0 & Xls::getUInt2d($this->data, $this->pos)) >> 4;
+
+ $length = Xls::getInt4d($this->data, $this->pos + 4);
+ $recordData = substr($this->data, $this->pos + 8, $length);
+
+ // move stream pointer to next record
+ $this->pos += 8 + $length;
+
+ $pos = 0;
+
+ // offset: 0; size: 16; rgbUid1 (MD4 digest of)
+ $rgbUid1 = substr($recordData, 0, 16);
+ $pos += 16;
+
+ // offset: 16; size: 16; rgbUid2 (MD4 digest), only if $recInstance = 0x46B or 0x6E3
+ if (in_array($recInstance, [0x046B, 0x06E3])) {
+ $rgbUid2 = substr($recordData, 16, 16);
+ $pos += 16;
+ }
+
+ // offset: var; size: 1; tag
+ $tag = ord($recordData[$pos]);
+ ++$pos;
+
+ // offset: var; size: var; the raw image data
+ $data = substr($recordData, $pos);
+
+ $blip = new Blip();
+ $blip->setData($data);
+
+ $this->object->setBlip($blip);
+ }
+
+ /**
+ * Read BlipPNG record. Holds raw PNG image data.
+ */
+ private function readBlipPNG(): void
+ {
+ // offset: 0; size: 2; recVer and recInstance
+
+ // bit: 4-15; mask: 0xFFF0; recInstance
+ $recInstance = (0xFFF0 & Xls::getUInt2d($this->data, $this->pos)) >> 4;
+
+ $length = Xls::getInt4d($this->data, $this->pos + 4);
+ $recordData = substr($this->data, $this->pos + 8, $length);
+
+ // move stream pointer to next record
+ $this->pos += 8 + $length;
+
+ $pos = 0;
+
+ // offset: 0; size: 16; rgbUid1 (MD4 digest of)
+ $rgbUid1 = substr($recordData, 0, 16);
+ $pos += 16;
+
+ // offset: 16; size: 16; rgbUid2 (MD4 digest), only if $recInstance = 0x46B or 0x6E3
+ if ($recInstance == 0x06E1) {
+ $rgbUid2 = substr($recordData, 16, 16);
+ $pos += 16;
+ }
+
+ // offset: var; size: 1; tag
+ $tag = ord($recordData[$pos]);
+ ++$pos;
+
+ // offset: var; size: var; the raw image data
+ $data = substr($recordData, $pos);
+
+ $blip = new Blip();
+ $blip->setData($data);
+
+ $this->object->setBlip($blip);
+ }
+
+ /**
+ * Read OPT record. This record may occur within DggContainer record or SpContainer.
+ */
+ private function readOPT(): void
+ {
+ // offset: 0; size: 2; recVer and recInstance
+
+ // bit: 4-15; mask: 0xFFF0; recInstance
+ $recInstance = (0xFFF0 & Xls::getUInt2d($this->data, $this->pos)) >> 4;
+
+ $length = Xls::getInt4d($this->data, $this->pos + 4);
+ $recordData = substr($this->data, $this->pos + 8, $length);
+
+ // move stream pointer to next record
+ $this->pos += 8 + $length;
+
+ $this->readOfficeArtRGFOPTE($recordData, $recInstance);
+ }
+
+ /**
+ * Read TertiaryOPT record.
+ */
+ private function readTertiaryOPT(): void
+ {
+ // offset: 0; size: 2; recVer and recInstance
+
+ // bit: 4-15; mask: 0xFFF0; recInstance
+ $recInstance = (0xFFF0 & Xls::getUInt2d($this->data, $this->pos)) >> 4;
+
+ $length = Xls::getInt4d($this->data, $this->pos + 4);
+ $recordData = substr($this->data, $this->pos + 8, $length);
+
+ // move stream pointer to next record
+ $this->pos += 8 + $length;
+ }
+
+ /**
+ * Read SplitMenuColors record.
+ */
+ private function readSplitMenuColors(): void
+ {
+ $length = Xls::getInt4d($this->data, $this->pos + 4);
+ $recordData = substr($this->data, $this->pos + 8, $length);
+
+ // move stream pointer to next record
+ $this->pos += 8 + $length;
+ }
+
+ /**
+ * Read DgContainer record (Drawing Container).
+ */
+ private function readDgContainer(): void
+ {
+ $length = Xls::getInt4d($this->data, $this->pos + 4);
+ $recordData = substr($this->data, $this->pos + 8, $length);
+
+ // move stream pointer to next record
+ $this->pos += 8 + $length;
+
+ // record is a container, read contents
+ $dgContainer = new DgContainer();
+ $this->object->setDgContainer($dgContainer);
+ $reader = new self($dgContainer);
+ $escher = $reader->load($recordData);
+ }
+
+ /**
+ * Read Dg record (Drawing).
+ */
+ private function readDg(): void
+ {
+ $length = Xls::getInt4d($this->data, $this->pos + 4);
+ $recordData = substr($this->data, $this->pos + 8, $length);
+
+ // move stream pointer to next record
+ $this->pos += 8 + $length;
+ }
+
+ /**
+ * Read SpgrContainer record (Shape Group Container).
+ */
+ private function readSpgrContainer(): void
+ {
+ // context is either context DgContainer or SpgrContainer
+
+ $length = Xls::getInt4d($this->data, $this->pos + 4);
+ $recordData = substr($this->data, $this->pos + 8, $length);
+
+ // move stream pointer to next record
+ $this->pos += 8 + $length;
+
+ // record is a container, read contents
+ $spgrContainer = new SpgrContainer();
+
+ if ($this->object instanceof DgContainer) {
+ // DgContainer
+ $this->object->setSpgrContainer($spgrContainer);
+ } else {
+ // SpgrContainer
+ $this->object->addChild($spgrContainer);
+ }
+
+ $reader = new self($spgrContainer);
+ $escher = $reader->load($recordData);
+ }
+
+ /**
+ * Read SpContainer record (Shape Container).
+ */
+ private function readSpContainer(): void
+ {
+ $length = Xls::getInt4d($this->data, $this->pos + 4);
+ $recordData = substr($this->data, $this->pos + 8, $length);
+
+ // add spContainer to spgrContainer
+ $spContainer = new SpContainer();
+ $this->object->addChild($spContainer);
+
+ // move stream pointer to next record
+ $this->pos += 8 + $length;
+
+ // record is a container, read contents
+ $reader = new self($spContainer);
+ $escher = $reader->load($recordData);
+ }
+
+ /**
+ * Read Spgr record (Shape Group).
+ */
+ private function readSpgr(): void
+ {
+ $length = Xls::getInt4d($this->data, $this->pos + 4);
+ $recordData = substr($this->data, $this->pos + 8, $length);
+
+ // move stream pointer to next record
+ $this->pos += 8 + $length;
+ }
+
+ /**
+ * Read Sp record (Shape).
+ */
+ private function readSp(): void
+ {
+ // offset: 0; size: 2; recVer and recInstance
+
+ // bit: 4-15; mask: 0xFFF0; recInstance
+ $recInstance = (0xFFF0 & Xls::getUInt2d($this->data, $this->pos)) >> 4;
+
+ $length = Xls::getInt4d($this->data, $this->pos + 4);
+ $recordData = substr($this->data, $this->pos + 8, $length);
+
+ // move stream pointer to next record
+ $this->pos += 8 + $length;
+ }
+
+ /**
+ * Read ClientTextbox record.
+ */
+ private function readClientTextbox(): void
+ {
+ // offset: 0; size: 2; recVer and recInstance
+
+ // bit: 4-15; mask: 0xFFF0; recInstance
+ $recInstance = (0xFFF0 & Xls::getUInt2d($this->data, $this->pos)) >> 4;
+
+ $length = Xls::getInt4d($this->data, $this->pos + 4);
+ $recordData = substr($this->data, $this->pos + 8, $length);
+
+ // move stream pointer to next record
+ $this->pos += 8 + $length;
+ }
+
+ /**
+ * Read ClientAnchor record. This record holds information about where the shape is anchored in worksheet.
+ */
+ private function readClientAnchor(): void
+ {
+ $length = Xls::getInt4d($this->data, $this->pos + 4);
+ $recordData = substr($this->data, $this->pos + 8, $length);
+
+ // move stream pointer to next record
+ $this->pos += 8 + $length;
+
+ // offset: 2; size: 2; upper-left corner column index (0-based)
+ $c1 = Xls::getUInt2d($recordData, 2);
+
+ // offset: 4; size: 2; upper-left corner horizontal offset in 1/1024 of column width
+ $startOffsetX = Xls::getUInt2d($recordData, 4);
+
+ // offset: 6; size: 2; upper-left corner row index (0-based)
+ $r1 = Xls::getUInt2d($recordData, 6);
+
+ // offset: 8; size: 2; upper-left corner vertical offset in 1/256 of row height
+ $startOffsetY = Xls::getUInt2d($recordData, 8);
+
+ // offset: 10; size: 2; bottom-right corner column index (0-based)
+ $c2 = Xls::getUInt2d($recordData, 10);
+
+ // offset: 12; size: 2; bottom-right corner horizontal offset in 1/1024 of column width
+ $endOffsetX = Xls::getUInt2d($recordData, 12);
+
+ // offset: 14; size: 2; bottom-right corner row index (0-based)
+ $r2 = Xls::getUInt2d($recordData, 14);
+
+ // offset: 16; size: 2; bottom-right corner vertical offset in 1/256 of row height
+ $endOffsetY = Xls::getUInt2d($recordData, 16);
+
+ // set the start coordinates
+ $this->object->setStartCoordinates(Coordinate::stringFromColumnIndex($c1 + 1) . ($r1 + 1));
+
+ // set the start offsetX
+ $this->object->setStartOffsetX($startOffsetX);
+
+ // set the start offsetY
+ $this->object->setStartOffsetY($startOffsetY);
+
+ // set the end coordinates
+ $this->object->setEndCoordinates(Coordinate::stringFromColumnIndex($c2 + 1) . ($r2 + 1));
+
+ // set the end offsetX
+ $this->object->setEndOffsetX($endOffsetX);
+
+ // set the end offsetY
+ $this->object->setEndOffsetY($endOffsetY);
+ }
+
+ /**
+ * Read ClientData record.
+ */
+ private function readClientData(): void
+ {
+ $length = Xls::getInt4d($this->data, $this->pos + 4);
+ $recordData = substr($this->data, $this->pos + 8, $length);
+
+ // move stream pointer to next record
+ $this->pos += 8 + $length;
+ }
+
+ /**
+ * Read OfficeArtRGFOPTE table of property-value pairs.
+ *
+ * @param string $data Binary data
+ * @param int $n Number of properties
+ */
+ private function readOfficeArtRGFOPTE($data, $n): void
+ {
+ $splicedComplexData = substr($data, 6 * $n);
+
+ // loop through property-value pairs
+ for ($i = 0; $i < $n; ++$i) {
+ // read 6 bytes at a time
+ $fopte = substr($data, 6 * $i, 6);
+
+ // offset: 0; size: 2; opid
+ $opid = Xls::getUInt2d($fopte, 0);
+
+ // bit: 0-13; mask: 0x3FFF; opid.opid
+ $opidOpid = (0x3FFF & $opid) >> 0;
+
+ // bit: 14; mask 0x4000; 1 = value in op field is BLIP identifier
+ $opidFBid = (0x4000 & $opid) >> 14;
+
+ // bit: 15; mask 0x8000; 1 = this is a complex property, op field specifies size of complex data
+ $opidFComplex = (0x8000 & $opid) >> 15;
+
+ // offset: 2; size: 4; the value for this property
+ $op = Xls::getInt4d($fopte, 2);
+
+ if ($opidFComplex) {
+ $complexData = substr($splicedComplexData, 0, $op);
+ $splicedComplexData = substr($splicedComplexData, $op);
+
+ // we store string value with complex data
+ $value = $complexData;
+ } else {
+ // we store integer value
+ $value = $op;
+ }
+
+ $this->object->setOPT($opidOpid, $value);
+ }
+ }
+}
diff --git a/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xls/MD5.php b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xls/MD5.php new file mode 100644 index 0000000..8ef2df2 --- /dev/null +++ b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xls/MD5.php @@ -0,0 +1,184 @@ +<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader\Xls;
+
+class MD5
+{
+ // Context
+ private $a;
+
+ private $b;
+
+ private $c;
+
+ private $d;
+
+ /**
+ * MD5 stream constructor.
+ */
+ public function __construct()
+ {
+ $this->reset();
+ }
+
+ /**
+ * Reset the MD5 stream context.
+ */
+ public function reset(): void
+ {
+ $this->a = 0x67452301;
+ $this->b = 0xEFCDAB89;
+ $this->c = 0x98BADCFE;
+ $this->d = 0x10325476;
+ }
+
+ /**
+ * Get MD5 stream context.
+ *
+ * @return string
+ */
+ public function getContext()
+ {
+ $s = '';
+ foreach (['a', 'b', 'c', 'd'] as $i) {
+ $v = $this->{$i};
+ $s .= chr($v & 0xff);
+ $s .= chr(($v >> 8) & 0xff);
+ $s .= chr(($v >> 16) & 0xff);
+ $s .= chr(($v >> 24) & 0xff);
+ }
+
+ return $s;
+ }
+
+ /**
+ * Add data to context.
+ *
+ * @param string $data Data to add
+ */
+ public function add($data): void
+ {
+ $words = array_values(unpack('V16', $data));
+
+ $A = $this->a;
+ $B = $this->b;
+ $C = $this->c;
+ $D = $this->d;
+
+ $F = ['self', 'f'];
+ $G = ['self', 'g'];
+ $H = ['self', 'h'];
+ $I = ['self', 'i'];
+
+ // ROUND 1
+ self::step($F, $A, $B, $C, $D, $words[0], 7, 0xd76aa478);
+ self::step($F, $D, $A, $B, $C, $words[1], 12, 0xe8c7b756);
+ self::step($F, $C, $D, $A, $B, $words[2], 17, 0x242070db);
+ self::step($F, $B, $C, $D, $A, $words[3], 22, 0xc1bdceee);
+ self::step($F, $A, $B, $C, $D, $words[4], 7, 0xf57c0faf);
+ self::step($F, $D, $A, $B, $C, $words[5], 12, 0x4787c62a);
+ self::step($F, $C, $D, $A, $B, $words[6], 17, 0xa8304613);
+ self::step($F, $B, $C, $D, $A, $words[7], 22, 0xfd469501);
+ self::step($F, $A, $B, $C, $D, $words[8], 7, 0x698098d8);
+ self::step($F, $D, $A, $B, $C, $words[9], 12, 0x8b44f7af);
+ self::step($F, $C, $D, $A, $B, $words[10], 17, 0xffff5bb1);
+ self::step($F, $B, $C, $D, $A, $words[11], 22, 0x895cd7be);
+ self::step($F, $A, $B, $C, $D, $words[12], 7, 0x6b901122);
+ self::step($F, $D, $A, $B, $C, $words[13], 12, 0xfd987193);
+ self::step($F, $C, $D, $A, $B, $words[14], 17, 0xa679438e);
+ self::step($F, $B, $C, $D, $A, $words[15], 22, 0x49b40821);
+
+ // ROUND 2
+ self::step($G, $A, $B, $C, $D, $words[1], 5, 0xf61e2562);
+ self::step($G, $D, $A, $B, $C, $words[6], 9, 0xc040b340);
+ self::step($G, $C, $D, $A, $B, $words[11], 14, 0x265e5a51);
+ self::step($G, $B, $C, $D, $A, $words[0], 20, 0xe9b6c7aa);
+ self::step($G, $A, $B, $C, $D, $words[5], 5, 0xd62f105d);
+ self::step($G, $D, $A, $B, $C, $words[10], 9, 0x02441453);
+ self::step($G, $C, $D, $A, $B, $words[15], 14, 0xd8a1e681);
+ self::step($G, $B, $C, $D, $A, $words[4], 20, 0xe7d3fbc8);
+ self::step($G, $A, $B, $C, $D, $words[9], 5, 0x21e1cde6);
+ self::step($G, $D, $A, $B, $C, $words[14], 9, 0xc33707d6);
+ self::step($G, $C, $D, $A, $B, $words[3], 14, 0xf4d50d87);
+ self::step($G, $B, $C, $D, $A, $words[8], 20, 0x455a14ed);
+ self::step($G, $A, $B, $C, $D, $words[13], 5, 0xa9e3e905);
+ self::step($G, $D, $A, $B, $C, $words[2], 9, 0xfcefa3f8);
+ self::step($G, $C, $D, $A, $B, $words[7], 14, 0x676f02d9);
+ self::step($G, $B, $C, $D, $A, $words[12], 20, 0x8d2a4c8a);
+
+ // ROUND 3
+ self::step($H, $A, $B, $C, $D, $words[5], 4, 0xfffa3942);
+ self::step($H, $D, $A, $B, $C, $words[8], 11, 0x8771f681);
+ self::step($H, $C, $D, $A, $B, $words[11], 16, 0x6d9d6122);
+ self::step($H, $B, $C, $D, $A, $words[14], 23, 0xfde5380c);
+ self::step($H, $A, $B, $C, $D, $words[1], 4, 0xa4beea44);
+ self::step($H, $D, $A, $B, $C, $words[4], 11, 0x4bdecfa9);
+ self::step($H, $C, $D, $A, $B, $words[7], 16, 0xf6bb4b60);
+ self::step($H, $B, $C, $D, $A, $words[10], 23, 0xbebfbc70);
+ self::step($H, $A, $B, $C, $D, $words[13], 4, 0x289b7ec6);
+ self::step($H, $D, $A, $B, $C, $words[0], 11, 0xeaa127fa);
+ self::step($H, $C, $D, $A, $B, $words[3], 16, 0xd4ef3085);
+ self::step($H, $B, $C, $D, $A, $words[6], 23, 0x04881d05);
+ self::step($H, $A, $B, $C, $D, $words[9], 4, 0xd9d4d039);
+ self::step($H, $D, $A, $B, $C, $words[12], 11, 0xe6db99e5);
+ self::step($H, $C, $D, $A, $B, $words[15], 16, 0x1fa27cf8);
+ self::step($H, $B, $C, $D, $A, $words[2], 23, 0xc4ac5665);
+
+ // ROUND 4
+ self::step($I, $A, $B, $C, $D, $words[0], 6, 0xf4292244);
+ self::step($I, $D, $A, $B, $C, $words[7], 10, 0x432aff97);
+ self::step($I, $C, $D, $A, $B, $words[14], 15, 0xab9423a7);
+ self::step($I, $B, $C, $D, $A, $words[5], 21, 0xfc93a039);
+ self::step($I, $A, $B, $C, $D, $words[12], 6, 0x655b59c3);
+ self::step($I, $D, $A, $B, $C, $words[3], 10, 0x8f0ccc92);
+ self::step($I, $C, $D, $A, $B, $words[10], 15, 0xffeff47d);
+ self::step($I, $B, $C, $D, $A, $words[1], 21, 0x85845dd1);
+ self::step($I, $A, $B, $C, $D, $words[8], 6, 0x6fa87e4f);
+ self::step($I, $D, $A, $B, $C, $words[15], 10, 0xfe2ce6e0);
+ self::step($I, $C, $D, $A, $B, $words[6], 15, 0xa3014314);
+ self::step($I, $B, $C, $D, $A, $words[13], 21, 0x4e0811a1);
+ self::step($I, $A, $B, $C, $D, $words[4], 6, 0xf7537e82);
+ self::step($I, $D, $A, $B, $C, $words[11], 10, 0xbd3af235);
+ self::step($I, $C, $D, $A, $B, $words[2], 15, 0x2ad7d2bb);
+ self::step($I, $B, $C, $D, $A, $words[9], 21, 0xeb86d391);
+
+ $this->a = ($this->a + $A) & 0xffffffff;
+ $this->b = ($this->b + $B) & 0xffffffff;
+ $this->c = ($this->c + $C) & 0xffffffff;
+ $this->d = ($this->d + $D) & 0xffffffff;
+ }
+
+ private static function f($X, $Y, $Z)
+ {
+ return ($X & $Y) | ((~$X) & $Z); // X AND Y OR NOT X AND Z
+ }
+
+ private static function g($X, $Y, $Z)
+ {
+ return ($X & $Z) | ($Y & (~$Z)); // X AND Z OR Y AND NOT Z
+ }
+
+ private static function h($X, $Y, $Z)
+ {
+ return $X ^ $Y ^ $Z; // X XOR Y XOR Z
+ }
+
+ private static function i($X, $Y, $Z)
+ {
+ return $Y ^ ($X | (~$Z)); // Y XOR (X OR NOT Z)
+ }
+
+ private static function step($func, &$A, $B, $C, $D, $M, $s, $t): void
+ {
+ $A = ($A + call_user_func($func, $B, $C, $D) + $M + $t) & 0xffffffff;
+ $A = self::rotate($A, $s);
+ $A = ($B + $A) & 0xffffffff;
+ }
+
+ private static function rotate($decimal, $bits)
+ {
+ $binary = str_pad(decbin($decimal), 32, '0', STR_PAD_LEFT);
+
+ return bindec(substr($binary, $bits) . substr($binary, 0, $bits));
+ }
+}
diff --git a/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xls/RC4.php b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xls/RC4.php new file mode 100644 index 0000000..af17f12 --- /dev/null +++ b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xls/RC4.php @@ -0,0 +1,61 @@ +<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader\Xls;
+
+class RC4
+{
+ // Context
+ protected $s = [];
+
+ protected $i = 0;
+
+ protected $j = 0;
+
+ /**
+ * RC4 stream decryption/encryption constrcutor.
+ *
+ * @param string $key Encryption key/passphrase
+ */
+ public function __construct($key)
+ {
+ $len = strlen($key);
+
+ for ($this->i = 0; $this->i < 256; ++$this->i) {
+ $this->s[$this->i] = $this->i;
+ }
+
+ $this->j = 0;
+ for ($this->i = 0; $this->i < 256; ++$this->i) {
+ $this->j = ($this->j + $this->s[$this->i] + ord($key[$this->i % $len])) % 256;
+ $t = $this->s[$this->i];
+ $this->s[$this->i] = $this->s[$this->j];
+ $this->s[$this->j] = $t;
+ }
+ $this->i = $this->j = 0;
+ }
+
+ /**
+ * Symmetric decryption/encryption function.
+ *
+ * @param string $data Data to encrypt/decrypt
+ *
+ * @return string
+ */
+ public function RC4($data)
+ {
+ $len = strlen($data);
+ for ($c = 0; $c < $len; ++$c) {
+ $this->i = ($this->i + 1) % 256;
+ $this->j = ($this->j + $this->s[$this->i]) % 256;
+ $t = $this->s[$this->i];
+ $this->s[$this->i] = $this->s[$this->j];
+ $this->s[$this->j] = $t;
+
+ $t = ($this->s[$this->i] + $this->s[$this->j]) % 256;
+
+ $data[$c] = chr(ord($data[$c]) ^ $this->s[$t]);
+ }
+
+ return $data;
+ }
+}
diff --git a/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xls/Style/Border.php b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xls/Style/Border.php new file mode 100644 index 0000000..ca98581 --- /dev/null +++ b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xls/Style/Border.php @@ -0,0 +1,42 @@ +<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader\Xls\Style;
+
+use PhpOffice\PhpSpreadsheet\Style\Border as StyleBorder;
+
+class Border
+{
+ protected static $map = [
+ 0x00 => StyleBorder::BORDER_NONE,
+ 0x01 => StyleBorder::BORDER_THIN,
+ 0x02 => StyleBorder::BORDER_MEDIUM,
+ 0x03 => StyleBorder::BORDER_DASHED,
+ 0x04 => StyleBorder::BORDER_DOTTED,
+ 0x05 => StyleBorder::BORDER_THICK,
+ 0x06 => StyleBorder::BORDER_DOUBLE,
+ 0x07 => StyleBorder::BORDER_HAIR,
+ 0x08 => StyleBorder::BORDER_MEDIUMDASHED,
+ 0x09 => StyleBorder::BORDER_DASHDOT,
+ 0x0A => StyleBorder::BORDER_MEDIUMDASHDOT,
+ 0x0B => StyleBorder::BORDER_DASHDOTDOT,
+ 0x0C => StyleBorder::BORDER_MEDIUMDASHDOTDOT,
+ 0x0D => StyleBorder::BORDER_SLANTDASHDOT,
+ ];
+
+ /**
+ * Map border style
+ * OpenOffice documentation: 2.5.11.
+ *
+ * @param int $index
+ *
+ * @return string
+ */
+ public static function lookup($index)
+ {
+ if (isset(self::$map[$index])) {
+ return self::$map[$index];
+ }
+
+ return StyleBorder::BORDER_NONE;
+ }
+}
diff --git a/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xls/Style/FillPattern.php b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xls/Style/FillPattern.php new file mode 100644 index 0000000..77e0520 --- /dev/null +++ b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xls/Style/FillPattern.php @@ -0,0 +1,47 @@ +<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader\Xls\Style;
+
+use PhpOffice\PhpSpreadsheet\Style\Fill;
+
+class FillPattern
+{
+ protected static $map = [
+ 0x00 => Fill::FILL_NONE,
+ 0x01 => Fill::FILL_SOLID,
+ 0x02 => Fill::FILL_PATTERN_MEDIUMGRAY,
+ 0x03 => Fill::FILL_PATTERN_DARKGRAY,
+ 0x04 => Fill::FILL_PATTERN_LIGHTGRAY,
+ 0x05 => Fill::FILL_PATTERN_DARKHORIZONTAL,
+ 0x06 => Fill::FILL_PATTERN_DARKVERTICAL,
+ 0x07 => Fill::FILL_PATTERN_DARKDOWN,
+ 0x08 => Fill::FILL_PATTERN_DARKUP,
+ 0x09 => Fill::FILL_PATTERN_DARKGRID,
+ 0x0A => Fill::FILL_PATTERN_DARKTRELLIS,
+ 0x0B => Fill::FILL_PATTERN_LIGHTHORIZONTAL,
+ 0x0C => Fill::FILL_PATTERN_LIGHTVERTICAL,
+ 0x0D => Fill::FILL_PATTERN_LIGHTDOWN,
+ 0x0E => Fill::FILL_PATTERN_LIGHTUP,
+ 0x0F => Fill::FILL_PATTERN_LIGHTGRID,
+ 0x10 => Fill::FILL_PATTERN_LIGHTTRELLIS,
+ 0x11 => Fill::FILL_PATTERN_GRAY125,
+ 0x12 => Fill::FILL_PATTERN_GRAY0625,
+ ];
+
+ /**
+ * Get fill pattern from index
+ * OpenOffice documentation: 2.5.12.
+ *
+ * @param int $index
+ *
+ * @return string
+ */
+ public static function lookup($index)
+ {
+ if (isset(self::$map[$index])) {
+ return self::$map[$index];
+ }
+
+ return Fill::FILL_NONE;
+ }
+}
diff --git a/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xlsx.php b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xlsx.php new file mode 100644 index 0000000..52f1a06 --- /dev/null +++ b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xlsx.php @@ -0,0 +1,2058 @@ +<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader;
+
+use PhpOffice\PhpSpreadsheet\Cell\Coordinate;
+use PhpOffice\PhpSpreadsheet\Cell\Hyperlink;
+use PhpOffice\PhpSpreadsheet\DefinedName;
+use PhpOffice\PhpSpreadsheet\Reader\Security\XmlScanner;
+use PhpOffice\PhpSpreadsheet\Reader\Xlsx\AutoFilter;
+use PhpOffice\PhpSpreadsheet\Reader\Xlsx\Chart;
+use PhpOffice\PhpSpreadsheet\Reader\Xlsx\ColumnAndRowAttributes;
+use PhpOffice\PhpSpreadsheet\Reader\Xlsx\ConditionalStyles;
+use PhpOffice\PhpSpreadsheet\Reader\Xlsx\DataValidations;
+use PhpOffice\PhpSpreadsheet\Reader\Xlsx\Hyperlinks;
+use PhpOffice\PhpSpreadsheet\Reader\Xlsx\PageSetup;
+use PhpOffice\PhpSpreadsheet\Reader\Xlsx\Properties as PropertyReader;
+use PhpOffice\PhpSpreadsheet\Reader\Xlsx\SheetViewOptions;
+use PhpOffice\PhpSpreadsheet\Reader\Xlsx\SheetViews;
+use PhpOffice\PhpSpreadsheet\Reader\Xlsx\Styles;
+use PhpOffice\PhpSpreadsheet\ReferenceHelper;
+use PhpOffice\PhpSpreadsheet\RichText\RichText;
+use PhpOffice\PhpSpreadsheet\Settings;
+use PhpOffice\PhpSpreadsheet\Shared\Date;
+use PhpOffice\PhpSpreadsheet\Shared\Drawing;
+use PhpOffice\PhpSpreadsheet\Shared\File;
+use PhpOffice\PhpSpreadsheet\Shared\Font;
+use PhpOffice\PhpSpreadsheet\Shared\StringHelper;
+use PhpOffice\PhpSpreadsheet\Spreadsheet;
+use PhpOffice\PhpSpreadsheet\Style\Border;
+use PhpOffice\PhpSpreadsheet\Style\Borders;
+use PhpOffice\PhpSpreadsheet\Style\Color;
+use PhpOffice\PhpSpreadsheet\Style\NumberFormat;
+use PhpOffice\PhpSpreadsheet\Style\Protection;
+use PhpOffice\PhpSpreadsheet\Style\Style;
+use PhpOffice\PhpSpreadsheet\Worksheet\HeaderFooterDrawing;
+use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
+use SimpleXMLElement;
+use stdClass;
+use Throwable;
+use XMLReader;
+use ZipArchive;
+
+class Xlsx extends BaseReader
+{
+ /**
+ * ReferenceHelper instance.
+ *
+ * @var ReferenceHelper
+ */
+ private $referenceHelper;
+
+ /**
+ * Xlsx\Theme instance.
+ *
+ * @var Xlsx\Theme
+ */
+ private static $theme = null;
+
+ /**
+ * Create a new Xlsx Reader instance.
+ */
+ public function __construct()
+ {
+ parent::__construct();
+ $this->referenceHelper = ReferenceHelper::getInstance();
+ $this->securityScanner = XmlScanner::getInstance($this);
+ }
+
+ /**
+ * Can the current IReader read the file?
+ *
+ * @param string $pFilename
+ *
+ * @return bool
+ */
+ public function canRead($pFilename)
+ {
+ File::assertFile($pFilename);
+
+ $result = false;
+ $zip = new ZipArchive();
+
+ if ($zip->open($pFilename) === true) {
+ $workbookBasename = $this->getWorkbookBaseName($zip);
+ $result = !empty($workbookBasename);
+
+ $zip->close();
+ }
+
+ return $result;
+ }
+
+ /**
+ * Reads names of the worksheets from a file, without parsing the whole file to a Spreadsheet object.
+ *
+ * @param string $pFilename
+ *
+ * @return array
+ */
+ public function listWorksheetNames($pFilename)
+ {
+ File::assertFile($pFilename);
+
+ $worksheetNames = [];
+
+ $zip = new ZipArchive();
+ $zip->open($pFilename);
+
+ // The files we're looking at here are small enough that simpleXML is more efficient than XMLReader
+ //~ http://schemas.openxmlformats.org/package/2006/relationships");
+ $rels = simplexml_load_string(
+ $this->securityScanner->scan($this->getFromZipArchive($zip, '_rels/.rels'))
+ );
+ foreach ($rels->Relationship as $rel) {
+ switch ($rel['Type']) {
+ case 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument':
+ //~ http://schemas.openxmlformats.org/spreadsheetml/2006/main"
+ $xmlWorkbook = simplexml_load_string(
+ $this->securityScanner->scan($this->getFromZipArchive($zip, "{$rel['Target']}"))
+ );
+
+ if ($xmlWorkbook->sheets) {
+ foreach ($xmlWorkbook->sheets->sheet as $eleSheet) {
+ // Check if sheet should be skipped
+ $worksheetNames[] = (string) $eleSheet['name'];
+ }
+ }
+ }
+ }
+
+ $zip->close();
+
+ return $worksheetNames;
+ }
+
+ /**
+ * Return worksheet info (Name, Last Column Letter, Last Column Index, Total Rows, Total Columns).
+ *
+ * @param string $pFilename
+ *
+ * @return array
+ */
+ public function listWorksheetInfo($pFilename)
+ {
+ File::assertFile($pFilename);
+
+ $worksheetInfo = [];
+
+ $zip = new ZipArchive();
+ $zip->open($pFilename);
+
+ //~ http://schemas.openxmlformats.org/package/2006/relationships"
+ $rels = simplexml_load_string(
+ $this->securityScanner->scan($this->getFromZipArchive($zip, '_rels/.rels')),
+ 'SimpleXMLElement',
+ Settings::getLibXmlLoaderOptions()
+ );
+ foreach ($rels->Relationship as $rel) {
+ if ($rel['Type'] == 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument') {
+ $dir = dirname($rel['Target']);
+
+ //~ http://schemas.openxmlformats.org/package/2006/relationships"
+ $relsWorkbook = simplexml_load_string(
+ $this->securityScanner->scan(
+ $this->getFromZipArchive($zip, "$dir/_rels/" . basename($rel['Target']) . '.rels')
+ ),
+ 'SimpleXMLElement',
+ Settings::getLibXmlLoaderOptions()
+ );
+ $relsWorkbook->registerXPathNamespace('rel', 'http://schemas.openxmlformats.org/package/2006/relationships');
+
+ $worksheets = [];
+ foreach ($relsWorkbook->Relationship as $ele) {
+ if ($ele['Type'] == 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet') {
+ $worksheets[(string) $ele['Id']] = $ele['Target'];
+ }
+ }
+
+ //~ http://schemas.openxmlformats.org/spreadsheetml/2006/main"
+ $xmlWorkbook = simplexml_load_string(
+ $this->securityScanner->scan(
+ $this->getFromZipArchive($zip, "{$rel['Target']}")
+ ),
+ 'SimpleXMLElement',
+ Settings::getLibXmlLoaderOptions()
+ );
+ if ($xmlWorkbook->sheets) {
+ $dir = dirname($rel['Target']);
+ /** @var SimpleXMLElement $eleSheet */
+ foreach ($xmlWorkbook->sheets->sheet as $eleSheet) {
+ $tmpInfo = [
+ 'worksheetName' => (string) $eleSheet['name'],
+ 'lastColumnLetter' => 'A',
+ 'lastColumnIndex' => 0,
+ 'totalRows' => 0,
+ 'totalColumns' => 0,
+ ];
+
+ $fileWorksheet = $worksheets[(string) self::getArrayItem($eleSheet->attributes('http://schemas.openxmlformats.org/officeDocument/2006/relationships'), 'id')];
+
+ $xml = new XMLReader();
+ $xml->xml(
+ $this->securityScanner->scanFile(
+ 'zip://' . File::realpath($pFilename) . '#' . "$dir/$fileWorksheet"
+ ),
+ null,
+ Settings::getLibXmlLoaderOptions()
+ );
+ $xml->setParserProperty(2, true);
+
+ $currCells = 0;
+ while ($xml->read()) {
+ if ($xml->name == 'row' && $xml->nodeType == XMLReader::ELEMENT) {
+ $row = $xml->getAttribute('r');
+ $tmpInfo['totalRows'] = $row;
+ $tmpInfo['totalColumns'] = max($tmpInfo['totalColumns'], $currCells);
+ $currCells = 0;
+ } elseif ($xml->name == 'c' && $xml->nodeType == XMLReader::ELEMENT) {
+ ++$currCells;
+ }
+ }
+ $tmpInfo['totalColumns'] = max($tmpInfo['totalColumns'], $currCells);
+ $xml->close();
+
+ $tmpInfo['lastColumnIndex'] = $tmpInfo['totalColumns'] - 1;
+ $tmpInfo['lastColumnLetter'] = Coordinate::stringFromColumnIndex($tmpInfo['lastColumnIndex'] + 1);
+
+ $worksheetInfo[] = $tmpInfo;
+ }
+ }
+ }
+ }
+
+ $zip->close();
+
+ return $worksheetInfo;
+ }
+
+ private static function castToBoolean($c)
+ {
+ $value = isset($c->v) ? (string) $c->v : null;
+ if ($value == '0') {
+ return false;
+ } elseif ($value == '1') {
+ return true;
+ }
+
+ return (bool) $c->v;
+ }
+
+ private static function castToError($c)
+ {
+ return isset($c->v) ? (string) $c->v : null;
+ }
+
+ private static function castToString($c)
+ {
+ return isset($c->v) ? (string) $c->v : null;
+ }
+
+ private function castToFormula($c, $r, &$cellDataType, &$value, &$calculatedValue, &$sharedFormulas, $castBaseType): void
+ {
+ $cellDataType = 'f';
+ $value = "={$c->f}";
+ $calculatedValue = self::$castBaseType($c);
+
+ // Shared formula?
+ if (isset($c->f['t']) && strtolower((string) $c->f['t']) == 'shared') {
+ $instance = (string) $c->f['si'];
+
+ if (!isset($sharedFormulas[(string) $c->f['si']])) {
+ $sharedFormulas[$instance] = ['master' => $r, 'formula' => $value];
+ } else {
+ $master = Coordinate::coordinateFromString($sharedFormulas[$instance]['master']);
+ $current = Coordinate::coordinateFromString($r);
+
+ $difference = [0, 0];
+ $difference[0] = Coordinate::columnIndexFromString($current[0]) - Coordinate::columnIndexFromString($master[0]);
+ $difference[1] = $current[1] - $master[1];
+
+ $value = $this->referenceHelper->updateFormulaReferences($sharedFormulas[$instance]['formula'], 'A1', $difference[0], $difference[1]);
+ }
+ }
+ }
+
+ /**
+ * @param string $fileName
+ *
+ * @return string
+ */
+ private function getFromZipArchive(ZipArchive $archive, $fileName = '')
+ {
+ // Root-relative paths
+ if (strpos($fileName, '//') !== false) {
+ $fileName = substr($fileName, strpos($fileName, '//') + 1);
+ }
+ $fileName = File::realpath($fileName);
+
+ // Sadly, some 3rd party xlsx generators don't use consistent case for filenaming
+ // so we need to load case-insensitively from the zip file
+
+ // Apache POI fixes
+ $contents = $archive->getFromName($fileName, 0, ZipArchive::FL_NOCASE);
+ if ($contents === false) {
+ $contents = $archive->getFromName(substr($fileName, 1), 0, ZipArchive::FL_NOCASE);
+ }
+
+ return $contents;
+ }
+
+ /**
+ * Loads Spreadsheet from file.
+ *
+ * @param string $pFilename
+ *
+ * @return Spreadsheet
+ */
+ public function load($pFilename)
+ {
+ File::assertFile($pFilename);
+
+ // Initialisations
+ $excel = new Spreadsheet();
+ $excel->removeSheetByIndex(0);
+ if (!$this->readDataOnly) {
+ $excel->removeCellStyleXfByIndex(0); // remove the default style
+ $excel->removeCellXfByIndex(0); // remove the default style
+ }
+ $unparsedLoadedData = [];
+
+ $zip = new ZipArchive();
+ $zip->open($pFilename);
+
+ // Read the theme first, because we need the colour scheme when reading the styles
+ //~ http://schemas.openxmlformats.org/package/2006/relationships"
+ $workbookBasename = $this->getWorkbookBaseName($zip);
+ $wbRels = simplexml_load_string(
+ $this->securityScanner->scan($this->getFromZipArchive($zip, "xl/_rels/${workbookBasename}.rels")),
+ 'SimpleXMLElement',
+ Settings::getLibXmlLoaderOptions()
+ );
+ foreach ($wbRels->Relationship as $rel) {
+ switch ($rel['Type']) {
+ case 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme':
+ $themeOrderArray = ['lt1', 'dk1', 'lt2', 'dk2'];
+ $themeOrderAdditional = count($themeOrderArray);
+
+ $xmlTheme = simplexml_load_string(
+ $this->securityScanner->scan($this->getFromZipArchive($zip, "xl/{$rel['Target']}")),
+ 'SimpleXMLElement',
+ 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 = [];
+ 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 Xlsx\Theme($themeName, $colourSchemeName, $themeColours);
+ }
+
+ break;
+ }
+ }
+
+ //~ http://schemas.openxmlformats.org/package/2006/relationships"
+ $rels = simplexml_load_string(
+ $this->securityScanner->scan($this->getFromZipArchive($zip, '_rels/.rels')),
+ 'SimpleXMLElement',
+ Settings::getLibXmlLoaderOptions()
+ );
+
+ $propertyReader = new PropertyReader($this->securityScanner, $excel->getProperties());
+ foreach ($rels->Relationship as $rel) {
+ switch ($rel['Type']) {
+ case 'http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties':
+ $propertyReader->readCoreProperties($this->getFromZipArchive($zip, "{$rel['Target']}"));
+
+ break;
+ case 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties':
+ $propertyReader->readExtendedProperties($this->getFromZipArchive($zip, "{$rel['Target']}"));
+
+ break;
+ case 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/custom-properties':
+ $propertyReader->readCustomProperties($this->getFromZipArchive($zip, "{$rel['Target']}"));
+
+ break;
+ //Ribbon
+ case 'http://schemas.microsoft.com/office/2006/relationships/ui/extensibility':
+ $customUI = $rel['Target'];
+ if ($customUI !== null) {
+ $this->readRibbon($excel, $customUI, $zip);
+ }
+
+ break;
+ case 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument':
+ $dir = dirname($rel['Target']);
+ //~ http://schemas.openxmlformats.org/package/2006/relationships"
+ $relsWorkbook = simplexml_load_string(
+ $this->securityScanner->scan($this->getFromZipArchive($zip, "$dir/_rels/" . basename($rel['Target']) . '.rels')),
+ 'SimpleXMLElement',
+ Settings::getLibXmlLoaderOptions()
+ );
+ $relsWorkbook->registerXPathNamespace('rel', 'http://schemas.openxmlformats.org/package/2006/relationships');
+
+ $sharedStrings = [];
+ $xpath = self::getArrayItem($relsWorkbook->xpath("rel:Relationship[@Type='http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings']"));
+ if ($xpath) {
+ //~ http://schemas.openxmlformats.org/spreadsheetml/2006/main"
+ $xmlStrings = simplexml_load_string(
+ $this->securityScanner->scan($this->getFromZipArchive($zip, "$dir/$xpath[Target]")),
+ 'SimpleXMLElement',
+ Settings::getLibXmlLoaderOptions()
+ );
+ if (isset($xmlStrings, $xmlStrings->si)) {
+ foreach ($xmlStrings->si as $val) {
+ if (isset($val->t)) {
+ $sharedStrings[] = StringHelper::controlCharacterOOXML2PHP((string) $val->t);
+ } elseif (isset($val->r)) {
+ $sharedStrings[] = $this->parseRichText($val);
+ }
+ }
+ }
+ }
+
+ $worksheets = [];
+ $macros = $customUI = null;
+ foreach ($relsWorkbook->Relationship as $ele) {
+ switch ($ele['Type']) {
+ case 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet':
+ $worksheets[(string) $ele['Id']] = $ele['Target'];
+
+ break;
+ // a vbaProject ? (: some macros)
+ case 'http://schemas.microsoft.com/office/2006/relationships/vbaProject':
+ $macros = $ele['Target'];
+
+ break;
+ }
+ }
+
+ if ($macros !== null) {
+ $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);
+ }
+ }
+ }
+
+ $xpath = self::getArrayItem($relsWorkbook->xpath("rel:Relationship[@Type='http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles']"));
+ //~ http://schemas.openxmlformats.org/spreadsheetml/2006/main"
+ $xmlStyles = simplexml_load_string(
+ $this->securityScanner->scan($this->getFromZipArchive($zip, "$dir/$xpath[Target]")),
+ 'SimpleXMLElement',
+ Settings::getLibXmlLoaderOptions()
+ );
+
+ $styles = [];
+ $cellStyles = [];
+ $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 = 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 &&
+ NumberFormat::builtInFormatCode((int) $xf['numFmtId']) !== ''
+ ) {
+ $numFmt = NumberFormat::builtInFormatCode((int) $xf['numFmtId']);
+ }
+ }
+ $quotePrefix = false;
+ if (isset($xf['quotePrefix'])) {
+ $quotePrefix = (bool) $xf['quotePrefix'];
+ }
+
+ $style = (object) [
+ 'numFmt' => $numFmt,
+ 'font' => $xmlStyles->fonts->font[(int) ($xf['fontId'])],
+ 'fill' => $xmlStyles->fills->fill[(int) ($xf['fillId'])],
+ 'border' => $xmlStyles->borders->border[(int) ($xf['borderId'])],
+ 'alignment' => $xf->alignment,
+ 'protection' => $xf->protection,
+ 'quotePrefix' => $quotePrefix,
+ ];
+ $styles[] = $style;
+
+ // add style to cellXf collection
+ $objStyle = new Style();
+ self::readStyle($objStyle, $style);
+ $excel->addCellXf($objStyle);
+ }
+
+ foreach (isset($xmlStyles->cellStyleXfs->xf) ? $xmlStyles->cellStyleXfs->xf : [] as $xf) {
+ $numFmt = 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 = NumberFormat::builtInFormatCode((int) $xf['numFmtId']);
+ }
+ }
+
+ $cellStyle = (object) [
+ 'numFmt' => $numFmt,
+ 'font' => $xmlStyles->fonts->font[(int) ($xf['fontId'])],
+ 'fill' => $xmlStyles->fills->fill[(int) ($xf['fillId'])],
+ 'border' => $xmlStyles->borders->border[(int) ($xf['borderId'])],
+ 'alignment' => $xf->alignment,
+ 'protection' => $xf->protection,
+ 'quotePrefix' => $quotePrefix,
+ ];
+ $cellStyles[] = $cellStyle;
+
+ // add style to cellStyleXf collection
+ $objStyle = new Style();
+ self::readStyle($objStyle, $cellStyle);
+ $excel->addCellStyleXf($objStyle);
+ }
+ }
+
+ $styleReader = new Styles($xmlStyles);
+ $styleReader->setStyleBaseData(self::$theme, $styles, $cellStyles);
+ $dxfs = $styleReader->dxfs($this->readDataOnly);
+ $styles = $styleReader->styles();
+
+ //~ http://schemas.openxmlformats.org/spreadsheetml/2006/main"
+ $xmlWorkbook = simplexml_load_string(
+ $this->securityScanner->scan($this->getFromZipArchive($zip, "{$rel['Target']}")),
+ 'SimpleXMLElement',
+ Settings::getLibXmlLoaderOptions()
+ );
+
+ // Set base date
+ if ($xmlWorkbook->workbookPr) {
+ Date::setExcelCalendar(Date::CALENDAR_WINDOWS_1900);
+ if (isset($xmlWorkbook->workbookPr['date1904'])) {
+ if (self::boolean((string) $xmlWorkbook->workbookPr['date1904'])) {
+ Date::setExcelCalendar(Date::CALENDAR_MAC_1904);
+ }
+ }
+ }
+
+ // Set protection
+ $this->readProtection($excel, $xmlWorkbook);
+
+ $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 = []; // mapping of sheet ids from old to new
+
+ $charts = $chartDetails = [];
+
+ if ($xmlWorkbook->sheets) {
+ /** @var SimpleXMLElement $eleSheet */
+ 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, false);
+ $fileWorksheet = $worksheets[(string) self::getArrayItem($eleSheet->attributes('http://schemas.openxmlformats.org/officeDocument/2006/relationships'), 'id')];
+ //~ http://schemas.openxmlformats.org/spreadsheetml/2006/main"
+ $xmlSheet = simplexml_load_string(
+ $this->securityScanner->scan($this->getFromZipArchive($zip, "$dir/$fileWorksheet")),
+ 'SimpleXMLElement',
+ Settings::getLibXmlLoaderOptions()
+ );
+
+ $sharedFormulas = [];
+
+ if (isset($eleSheet['state']) && (string) $eleSheet['state'] != '') {
+ $docSheet->setSheetState((string) $eleSheet['state']);
+ }
+
+ if ($xmlSheet) {
+ if (isset($xmlSheet->sheetViews, $xmlSheet->sheetViews->sheetView)) {
+ $sheetViews = new SheetViews($xmlSheet->sheetViews->sheetView, $docSheet);
+ $sheetViews->load();
+ }
+
+ $sheetViewOptions = new SheetViewOptions($docSheet, $xmlSheet);
+ $sheetViewOptions->load($this->getReadDataOnly());
+
+ (new ColumnAndRowAttributes($docSheet, $xmlSheet))
+ ->load($this->getReadFilter(), $this->getReadDataOnly());
+ }
+
+ if ($xmlSheet && $xmlSheet->sheetData && $xmlSheet->sheetData->row) {
+ $cIndex = 1; // Cell Start from 1
+ foreach ($xmlSheet->sheetData->row as $row) {
+ $rowIndex = 1;
+ foreach ($row->c as $c) {
+ $r = (string) $c['r'];
+ if ($r == '') {
+ $r = Coordinate::stringFromColumnIndex($rowIndex) . $cIndex;
+ }
+ $cellDataType = (string) $c['t'];
+ $value = null;
+ $calculatedValue = null;
+
+ // Read cell?
+ if ($this->getReadFilter() !== null) {
+ $coordinates = Coordinate::coordinateFromString($r);
+
+ if (!$this->getReadFilter()->readCell($coordinates[0], (int) $coordinates[1], $docSheet->getTitle())) {
+ ++$rowIndex;
+
+ continue;
+ }
+ }
+
+ // Read cell!
+ switch ($cellDataType) {
+ case 's':
+ if ((string) $c->v != '') {
+ $value = $sharedStrings[(int) ($c->v)];
+
+ if ($value instanceof RichText) {
+ $value = clone $value;
+ }
+ } else {
+ $value = '';
+ }
+
+ break;
+ case 'b':
+ 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 = $c->f;
+ $docSheet->getCell($r)->setFormulaAttributes($att);
+ }
+ }
+
+ break;
+ case 'inlineStr':
+ if (isset($c->f)) {
+ $this->castToFormula($c, $r, $cellDataType, $value, $calculatedValue, $sharedFormulas, 'castToError');
+ } else {
+ $value = $this->parseRichText($c->is);
+ }
+
+ break;
+ case 'e':
+ if (!isset($c->f)) {
+ $value = self::castToError($c);
+ } else {
+ // Formula
+ $this->castToFormula($c, $r, $cellDataType, $value, $calculatedValue, $sharedFormulas, 'castToError');
+ }
+
+ break;
+ default:
+ if (!isset($c->f)) {
+ $value = self::castToString($c);
+ } else {
+ // Formula
+ $this->castToFormula($c, $r, $cellDataType, $value, $calculatedValue, $sharedFormulas, 'castToString');
+ }
+
+ break;
+ }
+
+ // read empty cells or the cells are not empty
+ if ($this->readEmptyCells || ($value !== null && $value !== '')) {
+ // Rich text?
+ if ($value instanceof 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[(int) ($c['s'])]) ?
+ (int) ($c['s']) : 0);
+ }
+ }
+ ++$rowIndex;
+ }
+ ++$cIndex;
+ }
+ }
+
+ if (!$this->readDataOnly && $xmlSheet && $xmlSheet->conditionalFormatting) {
+ (new ConditionalStyles($docSheet, $xmlSheet, $dxfs))->load();
+ }
+
+ $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 ($xmlSheet) {
+ $this->readSheetProtection($docSheet, $xmlSheet);
+ }
+
+ if ($xmlSheet && $xmlSheet->autoFilter && !$this->readDataOnly) {
+ (new AutoFilter($docSheet, $xmlSheet))->load();
+ }
+
+ 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 && !$this->readDataOnly) {
+ $unparsedLoadedData = (new PageSetup($docSheet, $xmlSheet))->load($unparsedLoadedData);
+ }
+
+ if ($xmlSheet && $xmlSheet->dataValidations && !$this->readDataOnly) {
+ (new DataValidations($docSheet, $xmlSheet))->load();
+ }
+
+ // unparsed sheet AlternateContent
+ if ($xmlSheet && !$this->readDataOnly) {
+ $mc = $xmlSheet->children('http://schemas.openxmlformats.org/markup-compatibility/2006');
+ if ($mc->AlternateContent) {
+ foreach ($mc->AlternateContent as $alternateContent) {
+ $unparsedLoadedData['sheets'][$docSheet->getCodeName()]['AlternateContents'][] = $alternateContent->asXML();
+ }
+ }
+ }
+
+ // Add hyperlinks
+ if (!$this->readDataOnly) {
+ $hyperlinkReader = new Hyperlinks($docSheet);
+ // Locate hyperlink relations
+ $relationsFileName = dirname("$dir/$fileWorksheet") . '/_rels/' . basename($fileWorksheet) . '.rels';
+ if ($zip->locateName($relationsFileName)) {
+ //~ http://schemas.openxmlformats.org/package/2006/relationships"
+ $relsWorksheet = simplexml_load_string(
+ $this->securityScanner->scan(
+ $this->getFromZipArchive($zip, $relationsFileName)
+ ),
+ 'SimpleXMLElement',
+ Settings::getLibXmlLoaderOptions()
+ );
+ $hyperlinkReader->readHyperlinks($relsWorksheet);
+ }
+
+ // Loop through hyperlinks
+ if ($xmlSheet && $xmlSheet->hyperlinks) {
+ $hyperlinkReader->setHyperlinks($xmlSheet->hyperlinks);
+ }
+ }
+
+ // Add comments
+ $comments = [];
+ $vmlComments = [];
+ if (!$this->readDataOnly) {
+ // Locate comment relations
+ if ($zip->locateName(dirname("$dir/$fileWorksheet") . '/_rels/' . basename($fileWorksheet) . '.rels')) {
+ //~ http://schemas.openxmlformats.org/package/2006/relationships"
+ $relsWorksheet = simplexml_load_string(
+ $this->securityScanner->scan(
+ $this->getFromZipArchive($zip, dirname("$dir/$fileWorksheet") . '/_rels/' . basename($fileWorksheet) . '.rels')
+ ),
+ 'SimpleXMLElement',
+ 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 = File::realpath(dirname("$dir/$fileWorksheet") . '/' . $relPath);
+ $commentsFile = simplexml_load_string(
+ $this->securityScanner->scan($this->getFromZipArchive($zip, $relPath)),
+ 'SimpleXMLElement',
+ Settings::getLibXmlLoaderOptions()
+ );
+
+ // Utility variables
+ $authors = [];
+
+ // 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));
+ }
+ }
+
+ // later we will remove from it real vmlComments
+ $unparsedVmlDrawings = $vmlComments;
+
+ // Loop through VML comments
+ foreach ($vmlComments as $relName => $relPath) {
+ // Load VML comments file
+ $relPath = File::realpath(dirname("$dir/$fileWorksheet") . '/' . $relPath);
+
+ try {
+ $vmlCommentsFile = simplexml_load_string(
+ $this->securityScanner->scan($this->getFromZipArchive($zip, $relPath)),
+ 'SimpleXMLElement',
+ Settings::getLibXmlLoaderOptions()
+ );
+ $vmlCommentsFile->registerXPathNamespace('v', 'urn:schemas-microsoft-com:vml');
+ } catch (Throwable $ex) {
+ //Ignore unparsable vmlDrawings. Later they will be moved from $unparsedVmlDrawings to $unparsedLoadedData
+ continue;
+ }
+
+ $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($column + 1, $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');
+ }
+ }
+
+ unset($unparsedVmlDrawings[$relName]);
+ }
+ }
+ }
+ }
+
+ // unparsed vmlDrawing
+ if ($unparsedVmlDrawings) {
+ foreach ($unparsedVmlDrawings as $rId => $relPath) {
+ $rId = substr($rId, 3); // rIdXXX
+ $unparsedVmlDrawing = &$unparsedLoadedData['sheets'][$docSheet->getCodeName()]['vmlDrawings'];
+ $unparsedVmlDrawing[$rId] = [];
+ $unparsedVmlDrawing[$rId]['filePath'] = self::dirAdd("$dir/$fileWorksheet", $relPath);
+ $unparsedVmlDrawing[$rId]['relFilePath'] = $relPath;
+ $unparsedVmlDrawing[$rId]['content'] = $this->securityScanner->scan($this->getFromZipArchive($zip, $unparsedVmlDrawing[$rId]['filePath']));
+ unset($unparsedVmlDrawing);
+ }
+ }
+
+ // Header/footer images
+ if ($xmlSheet && $xmlSheet->legacyDrawingHF && !$this->readDataOnly) {
+ if ($zip->locateName(dirname("$dir/$fileWorksheet") . '/_rels/' . basename($fileWorksheet) . '.rels')) {
+ //~ http://schemas.openxmlformats.org/package/2006/relationships"
+ $relsWorksheet = simplexml_load_string(
+ $this->securityScanner->scan(
+ $this->getFromZipArchive($zip, dirname("$dir/$fileWorksheet") . '/_rels/' . basename($fileWorksheet) . '.rels')
+ ),
+ 'SimpleXMLElement',
+ 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
+ //~ http://schemas.openxmlformats.org/package/2006/relationships"
+ $relsVML = simplexml_load_string(
+ $this->securityScanner->scan(
+ $this->getFromZipArchive($zip, dirname($vmlRelationship) . '/_rels/' . basename($vmlRelationship) . '.rels')
+ ),
+ 'SimpleXMLElement',
+ Settings::getLibXmlLoaderOptions()
+ );
+ $drawings = [];
+ if (isset($relsVML->Relationship)) {
+ 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->securityScanner->scan($this->getFromZipArchive($zip, $vmlRelationship)),
+ 'SimpleXMLElement',
+ Settings::getLibXmlLoaderOptions()
+ );
+ $vmlDrawing->registerXPathNamespace('v', 'urn:schemas-microsoft-com:vml');
+
+ $hfImages = [];
+
+ $shapes = $vmlDrawing->xpath('//v:shape');
+ foreach ($shapes as $idx => $shape) {
+ $shape->registerXPathNamespace('v', 'urn:schemas-microsoft-com:vml');
+ $imageData = $shape->xpath('//v:imagedata');
+
+ if (!$imageData) {
+ continue;
+ }
+
+ $imageData = $imageData[$idx];
+
+ $imageData = $imageData->attributes('urn:schemas-microsoft-com:office:office');
+ $style = self::toCSSArray((string) $shape['style']);
+
+ $hfImages[(string) $shape['id']] = new HeaderFooterDrawing();
+ if (isset($imageData['title'])) {
+ $hfImages[(string) $shape['id']]->setName((string) $imageData['title']);
+ }
+
+ $hfImages[(string) $shape['id']]->setPath('zip://' . 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')) {
+ //~ http://schemas.openxmlformats.org/package/2006/relationships"
+ $relsWorksheet = simplexml_load_string(
+ $this->securityScanner->scan(
+ $this->getFromZipArchive($zip, dirname("$dir/$fileWorksheet") . '/_rels/' . basename($fileWorksheet) . '.rels')
+ ),
+ 'SimpleXMLElement',
+ Settings::getLibXmlLoaderOptions()
+ );
+ $drawings = [];
+ 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) {
+ $unparsedDrawings = [];
+ foreach ($xmlSheet->drawing as $drawing) {
+ $drawingRelId = (string) self::getArrayItem($drawing->attributes('http://schemas.openxmlformats.org/officeDocument/2006/relationships'), 'id');
+ $fileDrawing = $drawings[$drawingRelId];
+ //~ http://schemas.openxmlformats.org/package/2006/relationships"
+ $relsDrawing = simplexml_load_string(
+ $this->securityScanner->scan(
+ $this->getFromZipArchive($zip, dirname($fileDrawing) . '/_rels/' . basename($fileDrawing) . '.rels')
+ ),
+ 'SimpleXMLElement',
+ Settings::getLibXmlLoaderOptions()
+ );
+ $images = [];
+ $hyperlinks = [];
+ if ($relsDrawing && $relsDrawing->Relationship) {
+ foreach ($relsDrawing->Relationship as $ele) {
+ if ($ele['Type'] == 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink') {
+ $hyperlinks[(string) $ele['Id']] = (string) $ele['Target'];
+ }
+ 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'])] = [
+ 'id' => (string) $ele['Id'],
+ 'sheet' => $docSheet->getTitle(),
+ ];
+ }
+ }
+ }
+ }
+ $xmlDrawing = simplexml_load_string(
+ $this->securityScanner->scan($this->getFromZipArchive($zip, $fileDrawing)),
+ 'SimpleXMLElement',
+ Settings::getLibXmlLoaderOptions()
+ );
+ $xmlDrawingChildren = $xmlDrawing->children('http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing');
+
+ if ($xmlDrawingChildren->oneCellAnchor) {
+ foreach ($xmlDrawingChildren->oneCellAnchor as $oneCellAnchor) {
+ if ($oneCellAnchor->pic->blipFill) {
+ /** @var SimpleXMLElement $blip */
+ $blip = $oneCellAnchor->pic->blipFill->children('http://schemas.openxmlformats.org/drawingml/2006/main')->blip;
+ /** @var SimpleXMLElement $xfrm */
+ $xfrm = $oneCellAnchor->pic->spPr->children('http://schemas.openxmlformats.org/drawingml/2006/main')->xfrm;
+ /** @var SimpleXMLElement $outerShdw */
+ $outerShdw = $oneCellAnchor->pic->spPr->children('http://schemas.openxmlformats.org/drawingml/2006/main')->effectLst->outerShdw;
+ /** @var SimpleXMLElement $hlinkClick */
+ $hlinkClick = $oneCellAnchor->pic->nvPicPr->cNvPr->children('http://schemas.openxmlformats.org/drawingml/2006/main')->hlinkClick;
+
+ $objDrawing = new \PhpOffice\PhpSpreadsheet\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://' . File::realpath($pFilename) . '#' .
+ $images[(string) self::getArrayItem(
+ $blip->attributes('http://schemas.openxmlformats.org/officeDocument/2006/relationships'),
+ 'embed'
+ )],
+ false
+ );
+ $objDrawing->setCoordinates(Coordinate::stringFromColumnIndex(((string) $oneCellAnchor->from->col) + 1) . ($oneCellAnchor->from->row + 1));
+ $objDrawing->setOffsetX(Drawing::EMUToPixels($oneCellAnchor->from->colOff));
+ $objDrawing->setOffsetY(Drawing::EMUToPixels($oneCellAnchor->from->rowOff));
+ $objDrawing->setResizeProportional(false);
+ $objDrawing->setWidth(Drawing::EMUToPixels(self::getArrayItem($oneCellAnchor->ext->attributes(), 'cx')));
+ $objDrawing->setHeight(Drawing::EMUToPixels(self::getArrayItem($oneCellAnchor->ext->attributes(), 'cy')));
+ if ($xfrm) {
+ $objDrawing->setRotation(Drawing::angleToDegrees(self::getArrayItem($xfrm->attributes(), 'rot')));
+ }
+ if ($outerShdw) {
+ $shadow = $objDrawing->getShadow();
+ $shadow->setVisible(true);
+ $shadow->setBlurRadius(Drawing::EMUToPixels(self::getArrayItem($outerShdw->attributes(), 'blurRad')));
+ $shadow->setDistance(Drawing::EMUToPixels(self::getArrayItem($outerShdw->attributes(), 'dist')));
+ $shadow->setDirection(Drawing::angleToDegrees(self::getArrayItem($outerShdw->attributes(), 'dir')));
+ $shadow->setAlignment((string) self::getArrayItem($outerShdw->attributes(), 'algn'));
+ $clr = isset($outerShdw->srgbClr) ? $outerShdw->srgbClr : $outerShdw->prstClr;
+ $shadow->getColor()->setRGB(self::getArrayItem($clr->attributes(), 'val'));
+ $shadow->setAlpha(self::getArrayItem($clr->alpha->attributes(), 'val') / 1000);
+ }
+
+ $this->readHyperLinkDrawing($objDrawing, $oneCellAnchor, $hyperlinks);
+
+ $objDrawing->setWorksheet($docSheet);
+ } else {
+ // ? Can charts be positioned with a oneCellAnchor ?
+ $coordinates = Coordinate::stringFromColumnIndex(((string) $oneCellAnchor->from->col) + 1) . ($oneCellAnchor->from->row + 1);
+ $offsetX = Drawing::EMUToPixels($oneCellAnchor->from->colOff);
+ $offsetY = Drawing::EMUToPixels($oneCellAnchor->from->rowOff);
+ $width = Drawing::EMUToPixels(self::getArrayItem($oneCellAnchor->ext->attributes(), 'cx'));
+ $height = Drawing::EMUToPixels(self::getArrayItem($oneCellAnchor->ext->attributes(), 'cy'));
+ }
+ }
+ }
+ if ($xmlDrawingChildren->twoCellAnchor) {
+ foreach ($xmlDrawingChildren->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;
+ $hlinkClick = $twoCellAnchor->pic->nvPicPr->cNvPr->children('http://schemas.openxmlformats.org/drawingml/2006/main')->hlinkClick;
+ $objDrawing = new \PhpOffice\PhpSpreadsheet\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://' . File::realpath($pFilename) . '#' .
+ $images[(string) self::getArrayItem(
+ $blip->attributes('http://schemas.openxmlformats.org/officeDocument/2006/relationships'),
+ 'embed'
+ )],
+ false
+ );
+ $objDrawing->setCoordinates(Coordinate::stringFromColumnIndex(((string) $twoCellAnchor->from->col) + 1) . ($twoCellAnchor->from->row + 1));
+ $objDrawing->setOffsetX(Drawing::EMUToPixels($twoCellAnchor->from->colOff));
+ $objDrawing->setOffsetY(Drawing::EMUToPixels($twoCellAnchor->from->rowOff));
+ $objDrawing->setResizeProportional(false);
+
+ if ($xfrm) {
+ $objDrawing->setWidth(Drawing::EMUToPixels(self::getArrayItem($xfrm->ext->attributes(), 'cx')));
+ $objDrawing->setHeight(Drawing::EMUToPixels(self::getArrayItem($xfrm->ext->attributes(), 'cy')));
+ $objDrawing->setRotation(Drawing::angleToDegrees(self::getArrayItem($xfrm->attributes(), 'rot')));
+ }
+ if ($outerShdw) {
+ $shadow = $objDrawing->getShadow();
+ $shadow->setVisible(true);
+ $shadow->setBlurRadius(Drawing::EMUToPixels(self::getArrayItem($outerShdw->attributes(), 'blurRad')));
+ $shadow->setDistance(Drawing::EMUToPixels(self::getArrayItem($outerShdw->attributes(), 'dist')));
+ $shadow->setDirection(Drawing::angleToDegrees(self::getArrayItem($outerShdw->attributes(), 'dir')));
+ $shadow->setAlignment((string) self::getArrayItem($outerShdw->attributes(), 'algn'));
+ $clr = isset($outerShdw->srgbClr) ? $outerShdw->srgbClr : $outerShdw->prstClr;
+ $shadow->getColor()->setRGB(self::getArrayItem($clr->attributes(), 'val'));
+ $shadow->setAlpha(self::getArrayItem($clr->alpha->attributes(), 'val') / 1000);
+ }
+
+ $this->readHyperLinkDrawing($objDrawing, $twoCellAnchor, $hyperlinks);
+
+ $objDrawing->setWorksheet($docSheet);
+ } elseif (($this->includeCharts) && ($twoCellAnchor->graphicFrame)) {
+ $fromCoordinate = Coordinate::stringFromColumnIndex(((string) $twoCellAnchor->from->col) + 1) . ($twoCellAnchor->from->row + 1);
+ $fromOffsetX = Drawing::EMUToPixels($twoCellAnchor->from->colOff);
+ $fromOffsetY = Drawing::EMUToPixels($twoCellAnchor->from->rowOff);
+ $toCoordinate = Coordinate::stringFromColumnIndex(((string) $twoCellAnchor->to->col) + 1) . ($twoCellAnchor->to->row + 1);
+ $toOffsetX = Drawing::EMUToPixels($twoCellAnchor->to->colOff);
+ $toOffsetY = Drawing::EMUToPixels($twoCellAnchor->to->rowOff);
+ $graphic = $twoCellAnchor->graphicFrame->children('http://schemas.openxmlformats.org/drawingml/2006/main')->graphic;
+ /** @var SimpleXMLElement $chartRef */
+ $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] = [
+ 'fromCoordinate' => $fromCoordinate,
+ 'fromOffsetX' => $fromOffsetX,
+ 'fromOffsetY' => $fromOffsetY,
+ 'toCoordinate' => $toCoordinate,
+ 'toOffsetX' => $toOffsetX,
+ 'toOffsetY' => $toOffsetY,
+ 'worksheetTitle' => $docSheet->getTitle(),
+ ];
+ }
+ }
+ }
+ if ($relsDrawing === false && $xmlDrawing->count() == 0) {
+ // Save Drawing without rels and children as unparsed
+ $unparsedDrawings[$drawingRelId] = $xmlDrawing->asXML();
+ }
+ }
+
+ // store original rId of drawing files
+ $unparsedLoadedData['sheets'][$docSheet->getCodeName()]['drawingOriginalIds'] = [];
+ foreach ($relsWorksheet->Relationship as $ele) {
+ if ($ele['Type'] == 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/drawing') {
+ $drawingRelId = (string) $ele['Id'];
+ $unparsedLoadedData['sheets'][$docSheet->getCodeName()]['drawingOriginalIds'][(string) $ele['Target']] = $drawingRelId;
+ if (isset($unparsedDrawings[$drawingRelId])) {
+ $unparsedLoadedData['sheets'][$docSheet->getCodeName()]['Drawings'][$drawingRelId] = $unparsedDrawings[$drawingRelId];
+ }
+ }
+ }
+
+ // unparsed drawing AlternateContent
+ $xmlAltDrawing = simplexml_load_string(
+ $this->securityScanner->scan($this->getFromZipArchive($zip, $fileDrawing)),
+ 'SimpleXMLElement',
+ Settings::getLibXmlLoaderOptions()
+ )->children('http://schemas.openxmlformats.org/markup-compatibility/2006');
+
+ if ($xmlAltDrawing->AlternateContent) {
+ foreach ($xmlAltDrawing->AlternateContent as $alternateContent) {
+ $unparsedLoadedData['sheets'][$docSheet->getCodeName()]['drawingAlternateContents'][] = $alternateContent->asXML();
+ }
+ }
+ }
+ }
+
+ $this->readFormControlProperties($excel, $zip, $dir, $fileWorksheet, $docSheet, $unparsedLoadedData);
+ $this->readPrinterSettings($excel, $zip, $dir, $fileWorksheet, $docSheet, $unparsedLoadedData);
+
+ // Loop through definedNames
+ if ($xmlWorkbook->definedNames) {
+ foreach ($xmlWorkbook->definedNames->definedName as $definedName) {
+ // Extract range
+ $extractedRange = (string) $definedName;
+ 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'] == $oldSheetId) {
+ // 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 = [];
+ $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([$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([$matches[1], $matches[2]]);
+ }
+ }
+
+ break;
+ case '_xlnm.Print_Area':
+ $rangeSets = preg_split("/('?(?:.*?)'?(?:![A-Z0-9]+:[A-Z0-9]+)),?/", $extractedRange, -1, PREG_SPLIT_NO_EMPTY | PREG_SPLIT_DELIM_CAPTURE);
+ $newRangeSets = [];
+ foreach ($rangeSets as $rangeSet) {
+ [$sheetName, $rangeSet] = Worksheet::extractSheetTitle($rangeSet, true);
+ 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;
+
+ // 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 = Worksheet::extractSheetTitle((string) $definedName, true);
+ $scope = $excel->getSheet($mapSheetId[(int) $definedName['localSheetId']]);
+ if (strpos((string) $definedName, '!') !== false) {
+ $range[0] = str_replace("''", "'", $range[0]);
+ $range[0] = str_replace("'", '', $range[0]);
+ if ($worksheet = $excel->getSheetByName($range[0])) {
+ $excel->addDefinedName(DefinedName::createInstance((string) $definedName['name'], $worksheet, $extractedRange, true, $scope));
+ } else {
+ $excel->addDefinedName(DefinedName::createInstance((string) $definedName['name'], $scope, $extractedRange, true, $scope));
+ }
+ } else {
+ $excel->addDefinedName(DefinedName::createInstance((string) $definedName['name'], $scope, $extractedRange, true));
+ }
+ }
+
+ break;
+ }
+ } elseif (!isset($definedName['localSheetId'])) {
+ $definedRange = (string) $definedName;
+ // "Global" definedNames
+ $locatedSheet = null;
+ if (strpos((string) $definedName, '!') !== false) {
+ // Modify range, and extract the first worksheet reference
+ // Need to split on a comma or a space if not in quotes, and extract the first part.
+ $definedNameValueParts = preg_split("/[ ,](?=([^']*'[^']*')*[^']*$)/miuU", $definedRange);
+ // Extract sheet name
+ [$extractedSheetName] = Worksheet::extractSheetTitle((string) $definedNameValueParts[0], true);
+ $extractedSheetName = trim($extractedSheetName, "'");
+
+ // Locate sheet
+ $locatedSheet = $excel->getSheetByName($extractedSheetName);
+ }
+
+ $excel->addDefinedName(DefinedName::createInstance((string) $definedName['name'], $locatedSheet, $definedRange, false));
+ }
+ }
+ }
+ }
+
+ if ((!$this->readDataOnly || !empty($this->loadSheetsOnly)) && isset($xmlWorkbook->bookViews->workbookView)) {
+ $workbookView = $xmlWorkbook->bookViews->workbookView;
+
+ // active sheet index
+ $activeTab = (int) ($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);
+ }
+
+ if (isset($workbookView['showHorizontalScroll'])) {
+ $showHorizontalScroll = (string) $workbookView['showHorizontalScroll'];
+ $excel->setShowHorizontalScroll($this->castXsdBooleanToBool($showHorizontalScroll));
+ }
+
+ if (isset($workbookView['showVerticalScroll'])) {
+ $showVerticalScroll = (string) $workbookView['showVerticalScroll'];
+ $excel->setShowVerticalScroll($this->castXsdBooleanToBool($showVerticalScroll));
+ }
+
+ if (isset($workbookView['showSheetTabs'])) {
+ $showSheetTabs = (string) $workbookView['showSheetTabs'];
+ $excel->setShowSheetTabs($this->castXsdBooleanToBool($showSheetTabs));
+ }
+
+ if (isset($workbookView['minimized'])) {
+ $minimized = (string) $workbookView['minimized'];
+ $excel->setMinimized($this->castXsdBooleanToBool($minimized));
+ }
+
+ if (isset($workbookView['autoFilterDateGrouping'])) {
+ $autoFilterDateGrouping = (string) $workbookView['autoFilterDateGrouping'];
+ $excel->setAutoFilterDateGrouping($this->castXsdBooleanToBool($autoFilterDateGrouping));
+ }
+
+ if (isset($workbookView['firstSheet'])) {
+ $firstSheet = (string) $workbookView['firstSheet'];
+ $excel->setFirstSheetIndex((int) $firstSheet);
+ }
+
+ if (isset($workbookView['visibility'])) {
+ $visibility = (string) $workbookView['visibility'];
+ $excel->setVisibility($visibility);
+ }
+
+ if (isset($workbookView['tabRatio'])) {
+ $tabRatio = (string) $workbookView['tabRatio'];
+ $excel->setTabRatio((int) $tabRatio);
+ }
+ }
+
+ break;
+ }
+ }
+
+ if (!$this->readDataOnly) {
+ $contentTypes = simplexml_load_string(
+ $this->securityScanner->scan(
+ $this->getFromZipArchive($zip, '[Content_Types].xml')
+ ),
+ 'SimpleXMLElement',
+ Settings::getLibXmlLoaderOptions()
+ );
+
+ // Default content types
+ foreach ($contentTypes->Default as $contentType) {
+ switch ($contentType['ContentType']) {
+ case 'application/vnd.openxmlformats-officedocument.spreadsheetml.printerSettings':
+ $unparsedLoadedData['default_content_types'][(string) $contentType['Extension']] = (string) $contentType['ContentType'];
+
+ break;
+ }
+ }
+
+ // Override content types
+ 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->securityScanner->scan(
+ $this->getFromZipArchive($zip, $chartEntryRef)
+ ),
+ 'SimpleXMLElement',
+ Settings::getLibXmlLoaderOptions()
+ );
+ $objChart = Chart::readChart($chartElements, basename($chartEntryRef, '.xml'));
+
+ if (isset($charts[$chartEntryRef])) {
+ $chartPositionRef = $charts[$chartEntryRef]['sheet'] . '!' . $charts[$chartEntryRef]['id'];
+ if (isset($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']);
+ }
+ }
+ }
+
+ break;
+
+ // unparsed
+ case 'application/vnd.ms-excel.controlproperties+xml':
+ $unparsedLoadedData['override_content_types'][(string) $contentType['PartName']] = (string) $contentType['ContentType'];
+
+ break;
+ }
+ }
+ }
+
+ $excel->setUnparsedLoadedData($unparsedLoadedData);
+
+ $zip->close();
+
+ return $excel;
+ }
+
+ private static function readColor($color, $background = false)
+ {
+ if (isset($color['rgb'])) {
+ return (string) $color['rgb'];
+ } elseif (isset($color['indexed'])) {
+ return Color::indexedColor($color['indexed'] - 7, $background)->getARGB();
+ } elseif (isset($color['theme'])) {
+ if (self::$theme !== null) {
+ $returnColour = self::$theme->getColourByIndex((int) $color['theme']);
+ if (isset($color['tint'])) {
+ $tintAdjust = (float) $color['tint'];
+ $returnColour = Color::changeBrightness($returnColour, $tintAdjust);
+ }
+
+ return 'FF' . $returnColour;
+ }
+ }
+
+ if ($background) {
+ return 'FFFFFFFF';
+ }
+
+ return 'FF000000';
+ }
+
+ /**
+ * @param SimpleXMLElement|stdClass $style
+ */
+ private static function readStyle(Style $docStyle, $style): void
+ {
+ $docStyle->getNumberFormat()->setFormatCode($style->numFmt);
+
+ // font
+ if (isset($style->font)) {
+ $docStyle->getFont()->setName((string) $style->font->name['val']);
+ $docStyle->getFont()->setSize((string) $style->font->sz['val']);
+ if (isset($style->font->b)) {
+ $docStyle->getFont()->setBold(!isset($style->font->b['val']) || self::boolean((string) $style->font->b['val']));
+ }
+ if (isset($style->font->i)) {
+ $docStyle->getFont()->setItalic(!isset($style->font->i['val']) || self::boolean((string) $style->font->i['val']));
+ }
+ if (isset($style->font->strike)) {
+ $docStyle->getFont()->setStrikethrough(!isset($style->font->strike['val']) || self::boolean((string) $style->font->strike['val']));
+ }
+ $docStyle->getFont()->getColor()->setARGB(self::readColor($style->font->color));
+
+ if (isset($style->font->u) && !isset($style->font->u['val'])) {
+ $docStyle->getFont()->setUnderline(\PhpOffice\PhpSpreadsheet\Style\Font::UNDERLINE_SINGLE);
+ } elseif (isset($style->font->u, $style->font->u['val'])) {
+ $docStyle->getFont()->setUnderline((string) $style->font->u['val']);
+ }
+
+ if (isset($style->font->vertAlign, $style->font->vertAlign['val'])) {
+ $vertAlign = strtolower((string) $style->font->vertAlign['val']);
+ if ($vertAlign == 'superscript') {
+ $docStyle->getFont()->setSuperscript(true);
+ }
+ if ($vertAlign == 'subscript') {
+ $docStyle->getFont()->setSubscript(true);
+ }
+ }
+ }
+
+ // fill
+ if (isset($style->fill)) {
+ if ($style->fill->gradientFill) {
+ /** @var SimpleXMLElement $gradientFill */
+ $gradientFill = $style->fill->gradientFill[0];
+ if (!empty($gradientFill['type'])) {
+ $docStyle->getFill()->setFillType((string) $gradientFill['type']);
+ }
+ $docStyle->getFill()->setRotation((float) ($gradientFill['degree']));
+ $gradientFill->registerXPathNamespace('sml', 'http://schemas.openxmlformats.org/spreadsheetml/2006/main');
+ $docStyle->getFill()->getStartColor()->setARGB(self::readColor(self::getArrayItem($gradientFill->xpath('sml:stop[@position=0]'))->color));
+ $docStyle->getFill()->getEndColor()->setARGB(self::readColor(self::getArrayItem($gradientFill->xpath('sml:stop[@position=1]'))->color));
+ } elseif ($style->fill->patternFill) {
+ $patternType = (string) $style->fill->patternFill['patternType'] != '' ? (string) $style->fill->patternFill['patternType'] : 'solid';
+ $docStyle->getFill()->setFillType($patternType);
+ if ($style->fill->patternFill->fgColor) {
+ $docStyle->getFill()->getStartColor()->setARGB(self::readColor($style->fill->patternFill->fgColor, true));
+ }
+ if ($style->fill->patternFill->bgColor) {
+ $docStyle->getFill()->getEndColor()->setARGB(self::readColor($style->fill->patternFill->bgColor, true));
+ }
+ }
+ }
+
+ // border
+ if (isset($style->border)) {
+ $diagonalUp = self::boolean((string) $style->border['diagonalUp']);
+ $diagonalDown = self::boolean((string) $style->border['diagonalDown']);
+ if (!$diagonalUp && !$diagonalDown) {
+ $docStyle->getBorders()->setDiagonalDirection(Borders::DIAGONAL_NONE);
+ } elseif ($diagonalUp && !$diagonalDown) {
+ $docStyle->getBorders()->setDiagonalDirection(Borders::DIAGONAL_UP);
+ } elseif (!$diagonalUp && $diagonalDown) {
+ $docStyle->getBorders()->setDiagonalDirection(Borders::DIAGONAL_DOWN);
+ } else {
+ $docStyle->getBorders()->setDiagonalDirection(Borders::DIAGONAL_BOTH);
+ }
+ self::readBorder($docStyle->getBorders()->getLeft(), $style->border->left);
+ self::readBorder($docStyle->getBorders()->getRight(), $style->border->right);
+ self::readBorder($docStyle->getBorders()->getTop(), $style->border->top);
+ self::readBorder($docStyle->getBorders()->getBottom(), $style->border->bottom);
+ self::readBorder($docStyle->getBorders()->getDiagonal(), $style->border->diagonal);
+ }
+
+ // alignment
+ if (isset($style->alignment)) {
+ $docStyle->getAlignment()->setHorizontal((string) $style->alignment['horizontal']);
+ $docStyle->getAlignment()->setVertical((string) $style->alignment['vertical']);
+
+ $textRotation = 0;
+ if ((int) $style->alignment['textRotation'] <= 90) {
+ $textRotation = (int) $style->alignment['textRotation'];
+ } elseif ((int) $style->alignment['textRotation'] > 90) {
+ $textRotation = 90 - (int) $style->alignment['textRotation'];
+ }
+
+ $docStyle->getAlignment()->setTextRotation((int) $textRotation);
+ $docStyle->getAlignment()->setWrapText(self::boolean((string) $style->alignment['wrapText']));
+ $docStyle->getAlignment()->setShrinkToFit(self::boolean((string) $style->alignment['shrinkToFit']));
+ $docStyle->getAlignment()->setIndent((int) ((string) $style->alignment['indent']) > 0 ? (int) ((string) $style->alignment['indent']) : 0);
+ $docStyle->getAlignment()->setReadOrder((int) ((string) $style->alignment['readingOrder']) > 0 ? (int) ((string) $style->alignment['readingOrder']) : 0);
+ }
+
+ // protection
+ if (isset($style->protection)) {
+ if (isset($style->protection['locked'])) {
+ if (self::boolean((string) $style->protection['locked'])) {
+ $docStyle->getProtection()->setLocked(Protection::PROTECTION_PROTECTED);
+ } else {
+ $docStyle->getProtection()->setLocked(Protection::PROTECTION_UNPROTECTED);
+ }
+ }
+
+ if (isset($style->protection['hidden'])) {
+ if (self::boolean((string) $style->protection['hidden'])) {
+ $docStyle->getProtection()->setHidden(Protection::PROTECTION_PROTECTED);
+ } else {
+ $docStyle->getProtection()->setHidden(Protection::PROTECTION_UNPROTECTED);
+ }
+ }
+ }
+
+ // top-level style settings
+ if (isset($style->quotePrefix)) {
+ $docStyle->setQuotePrefix($style->quotePrefix);
+ }
+ }
+
+ /**
+ * @param SimpleXMLElement $eleBorder
+ */
+ private static function readBorder(Border $docBorder, $eleBorder): void
+ {
+ if (isset($eleBorder['style'])) {
+ $docBorder->setBorderStyle((string) $eleBorder['style']);
+ }
+ if (isset($eleBorder->color)) {
+ $docBorder->getColor()->setARGB(self::readColor($eleBorder->color));
+ }
+ }
+
+ /**
+ * @param SimpleXMLElement | null $is
+ *
+ * @return RichText
+ */
+ private function parseRichText($is)
+ {
+ $value = new RichText();
+
+ if (isset($is->t)) {
+ $value->createText(StringHelper::controlCharacterOOXML2PHP((string) $is->t));
+ } else {
+ if (is_object($is->r)) {
+ foreach ($is->r as $run) {
+ if (!isset($run->rPr)) {
+ $value->createText(StringHelper::controlCharacterOOXML2PHP((string) $run->t));
+ } else {
+ $objText = $value->createTextRun(StringHelper::controlCharacterOOXML2PHP((string) $run->t));
+
+ if (isset($run->rPr->rFont['val'])) {
+ $objText->getFont()->setName((string) $run->rPr->rFont['val']);
+ }
+ if (isset($run->rPr->sz['val'])) {
+ $objText->getFont()->setSize((float) $run->rPr->sz['val']);
+ }
+ if (isset($run->rPr->color)) {
+ $objText->getFont()->setColor(new Color(self::readColor($run->rPr->color)));
+ }
+ if (
+ (isset($run->rPr->b['val']) && self::boolean((string) $run->rPr->b['val'])) ||
+ (isset($run->rPr->b) && !isset($run->rPr->b['val']))
+ ) {
+ $objText->getFont()->setBold(true);
+ }
+ if (
+ (isset($run->rPr->i['val']) && self::boolean((string) $run->rPr->i['val'])) ||
+ (isset($run->rPr->i) && !isset($run->rPr->i['val']))
+ ) {
+ $objText->getFont()->setItalic(true);
+ }
+ if (isset($run->rPr->vertAlign, $run->rPr->vertAlign['val'])) {
+ $vertAlign = strtolower((string) $run->rPr->vertAlign['val']);
+ if ($vertAlign == 'superscript') {
+ $objText->getFont()->setSuperscript(true);
+ }
+ if ($vertAlign == 'subscript') {
+ $objText->getFont()->setSubscript(true);
+ }
+ }
+ if (isset($run->rPr->u) && !isset($run->rPr->u['val'])) {
+ $objText->getFont()->setUnderline(\PhpOffice\PhpSpreadsheet\Style\Font::UNDERLINE_SINGLE);
+ } elseif (isset($run->rPr->u, $run->rPr->u['val'])) {
+ $objText->getFont()->setUnderline((string) $run->rPr->u['val']);
+ }
+ if (
+ (isset($run->rPr->strike['val']) && self::boolean((string) $run->rPr->strike['val'])) ||
+ (isset($run->rPr->strike) && !isset($run->rPr->strike['val']))
+ ) {
+ $objText->getFont()->setStrikethrough(true);
+ }
+ }
+ }
+ }
+ }
+
+ return $value;
+ }
+
+ /**
+ * @param mixed $customUITarget
+ * @param mixed $zip
+ */
+ private function readRibbon(Spreadsheet $excel, $customUITarget, $zip): void
+ {
+ $baseDir = dirname($customUITarget);
+ $nameCustomUI = basename($customUITarget);
+ // get the xml file (ribbon)
+ $localRibbon = $this->getFromZipArchive($zip, $customUITarget);
+ $customUIImagesNames = [];
+ $customUIImagesBinaries = [];
+ // something like customUI/_rels/customUI.xml.rels
+ $pathRels = $baseDir . '/_rels/' . $nameCustomUI . '.rels';
+ $dataRels = $this->getFromZipArchive($zip, $pathRels);
+ if ($dataRels) {
+ // exists and not empty if the ribbon have some pictures (other than internal MSO)
+ $UIRels = simplexml_load_string(
+ $this->securityScanner->scan($dataRels),
+ 'SimpleXMLElement',
+ Settings::getLibXmlLoaderOptions()
+ );
+ if (false !== $UIRels) {
+ // we need to save id and target to avoid parsing customUI.xml and "guess" if it's a pseudo callback who load the image
+ foreach ($UIRels->Relationship as $ele) {
+ if ($ele['Type'] == 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/image') {
+ // an image ?
+ $customUIImagesNames[(string) $ele['Id']] = (string) $ele['Target'];
+ $customUIImagesBinaries[(string) $ele['Target']] = $this->getFromZipArchive($zip, $baseDir . '/' . (string) $ele['Target']);
+ }
+ }
+ }
+ }
+ if ($localRibbon) {
+ $excel->setRibbonXMLData($customUITarget, $localRibbon);
+ if (count($customUIImagesNames) > 0 && count($customUIImagesBinaries) > 0) {
+ $excel->setRibbonBinObjects($customUIImagesNames, $customUIImagesBinaries);
+ } else {
+ $excel->setRibbonBinObjects(null, null);
+ }
+ } else {
+ $excel->setRibbonXMLData(null, null);
+ $excel->setRibbonBinObjects(null, null);
+ }
+ }
+
+ private static function getArrayItem($array, $key = 0)
+ {
+ return $array[$key] ?? null;
+ }
+
+ private static function dirAdd($base, $add)
+ {
+ return preg_replace('~[^/]+/\.\./~', '', dirname($base) . "/$add");
+ }
+
+ private static function toCSSArray($style)
+ {
+ $style = self::stripWhiteSpaceFromStyleString($style);
+
+ $temp = explode(';', $style);
+ $style = [];
+ foreach ($temp as $item) {
+ $item = explode(':', $item);
+
+ if (strpos($item[1], 'px') !== false) {
+ $item[1] = str_replace('px', '', $item[1]);
+ }
+ if (strpos($item[1], 'pt') !== false) {
+ $item[1] = str_replace('pt', '', $item[1]);
+ $item[1] = Font::fontSizeToPixels($item[1]);
+ }
+ if (strpos($item[1], 'in') !== false) {
+ $item[1] = str_replace('in', '', $item[1]);
+ $item[1] = Font::inchSizeToPixels($item[1]);
+ }
+ if (strpos($item[1], 'cm') !== false) {
+ $item[1] = str_replace('cm', '', $item[1]);
+ $item[1] = Font::centimeterSizeToPixels($item[1]);
+ }
+
+ $style[$item[0]] = $item[1];
+ }
+
+ return $style;
+ }
+
+ public static function stripWhiteSpaceFromStyleString($string)
+ {
+ return trim(str_replace(["\r", "\n", ' '], '', $string), ';');
+ }
+
+ private static function boolean($value)
+ {
+ if (is_object($value)) {
+ $value = (string) $value;
+ }
+ if (is_numeric($value)) {
+ return (bool) $value;
+ }
+
+ return $value === 'true' || $value === 'TRUE';
+ }
+
+ /**
+ * @param \PhpOffice\PhpSpreadsheet\Worksheet\Drawing $objDrawing
+ * @param SimpleXMLElement $cellAnchor
+ * @param array $hyperlinks
+ */
+ private function readHyperLinkDrawing($objDrawing, $cellAnchor, $hyperlinks): void
+ {
+ $hlinkClick = $cellAnchor->pic->nvPicPr->cNvPr->children('http://schemas.openxmlformats.org/drawingml/2006/main')->hlinkClick;
+
+ if ($hlinkClick->count() === 0) {
+ return;
+ }
+
+ $hlinkId = (string) $hlinkClick->attributes('http://schemas.openxmlformats.org/officeDocument/2006/relationships')['id'];
+ $hyperlink = new Hyperlink(
+ $hyperlinks[$hlinkId],
+ (string) self::getArrayItem($cellAnchor->pic->nvPicPr->cNvPr->attributes(), 'name')
+ );
+ $objDrawing->setHyperlink($hyperlink);
+ }
+
+ private function readProtection(Spreadsheet $excel, SimpleXMLElement $xmlWorkbook): void
+ {
+ if (!$xmlWorkbook->workbookProtection) {
+ return;
+ }
+
+ if ($xmlWorkbook->workbookProtection['lockRevision']) {
+ $excel->getSecurity()->setLockRevision((bool) $xmlWorkbook->workbookProtection['lockRevision']);
+ }
+
+ if ($xmlWorkbook->workbookProtection['lockStructure']) {
+ $excel->getSecurity()->setLockStructure((bool) $xmlWorkbook->workbookProtection['lockStructure']);
+ }
+
+ if ($xmlWorkbook->workbookProtection['lockWindows']) {
+ $excel->getSecurity()->setLockWindows((bool) $xmlWorkbook->workbookProtection['lockWindows']);
+ }
+
+ if ($xmlWorkbook->workbookProtection['revisionsPassword']) {
+ $excel->getSecurity()->setRevisionsPassword((string) $xmlWorkbook->workbookProtection['revisionsPassword'], true);
+ }
+
+ if ($xmlWorkbook->workbookProtection['workbookPassword']) {
+ $excel->getSecurity()->setWorkbookPassword((string) $xmlWorkbook->workbookProtection['workbookPassword'], true);
+ }
+ }
+
+ private function readFormControlProperties(Spreadsheet $excel, ZipArchive $zip, $dir, $fileWorksheet, $docSheet, array &$unparsedLoadedData): void
+ {
+ if (!$zip->locateName(dirname("$dir/$fileWorksheet") . '/_rels/' . basename($fileWorksheet) . '.rels')) {
+ return;
+ }
+
+ //~ http://schemas.openxmlformats.org/package/2006/relationships"
+ $relsWorksheet = simplexml_load_string(
+ $this->securityScanner->scan(
+ $this->getFromZipArchive($zip, dirname("$dir/$fileWorksheet") . '/_rels/' . basename($fileWorksheet) . '.rels')
+ ),
+ 'SimpleXMLElement',
+ Settings::getLibXmlLoaderOptions()
+ );
+ $ctrlProps = [];
+ foreach ($relsWorksheet->Relationship as $ele) {
+ if ($ele['Type'] == 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/ctrlProp') {
+ $ctrlProps[(string) $ele['Id']] = $ele;
+ }
+ }
+
+ $unparsedCtrlProps = &$unparsedLoadedData['sheets'][$docSheet->getCodeName()]['ctrlProps'];
+ foreach ($ctrlProps as $rId => $ctrlProp) {
+ $rId = substr($rId, 3); // rIdXXX
+ $unparsedCtrlProps[$rId] = [];
+ $unparsedCtrlProps[$rId]['filePath'] = self::dirAdd("$dir/$fileWorksheet", $ctrlProp['Target']);
+ $unparsedCtrlProps[$rId]['relFilePath'] = (string) $ctrlProp['Target'];
+ $unparsedCtrlProps[$rId]['content'] = $this->securityScanner->scan($this->getFromZipArchive($zip, $unparsedCtrlProps[$rId]['filePath']));
+ }
+ unset($unparsedCtrlProps);
+ }
+
+ private function readPrinterSettings(Spreadsheet $excel, ZipArchive $zip, $dir, $fileWorksheet, $docSheet, array &$unparsedLoadedData): void
+ {
+ if (!$zip->locateName(dirname("$dir/$fileWorksheet") . '/_rels/' . basename($fileWorksheet) . '.rels')) {
+ return;
+ }
+
+ //~ http://schemas.openxmlformats.org/package/2006/relationships"
+ $relsWorksheet = simplexml_load_string(
+ $this->securityScanner->scan(
+ $this->getFromZipArchive($zip, dirname("$dir/$fileWorksheet") . '/_rels/' . basename($fileWorksheet) . '.rels')
+ ),
+ 'SimpleXMLElement',
+ Settings::getLibXmlLoaderOptions()
+ );
+ $sheetPrinterSettings = [];
+ foreach ($relsWorksheet->Relationship as $ele) {
+ if ($ele['Type'] == 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/printerSettings') {
+ $sheetPrinterSettings[(string) $ele['Id']] = $ele;
+ }
+ }
+
+ $unparsedPrinterSettings = &$unparsedLoadedData['sheets'][$docSheet->getCodeName()]['printerSettings'];
+ foreach ($sheetPrinterSettings as $rId => $printerSettings) {
+ $rId = substr($rId, 3); // rIdXXX
+ $unparsedPrinterSettings[$rId] = [];
+ $unparsedPrinterSettings[$rId]['filePath'] = self::dirAdd("$dir/$fileWorksheet", $printerSettings['Target']);
+ $unparsedPrinterSettings[$rId]['relFilePath'] = (string) $printerSettings['Target'];
+ $unparsedPrinterSettings[$rId]['content'] = $this->securityScanner->scan($this->getFromZipArchive($zip, $unparsedPrinterSettings[$rId]['filePath']));
+ }
+ unset($unparsedPrinterSettings);
+ }
+
+ /**
+ * Convert an 'xsd:boolean' XML value to a PHP boolean value.
+ * A valid 'xsd:boolean' XML value can be one of the following
+ * four values: 'true', 'false', '1', '0'. It is case sensitive.
+ *
+ * Note that just doing '(bool) $xsdBoolean' is not safe,
+ * since '(bool) "false"' returns true.
+ *
+ * @see https://www.w3.org/TR/xmlschema11-2/#boolean
+ *
+ * @param string $xsdBoolean An XML string value of type 'xsd:boolean'
+ *
+ * @return bool Boolean value
+ */
+ private function castXsdBooleanToBool($xsdBoolean)
+ {
+ if ($xsdBoolean === 'false') {
+ return false;
+ }
+
+ return (bool) $xsdBoolean;
+ }
+
+ /**
+ * @param ZipArchive $zip Opened zip archive
+ *
+ * @return string basename of the used excel workbook
+ */
+ private function getWorkbookBaseName(ZipArchive $zip)
+ {
+ $workbookBasename = '';
+
+ // check if it is an OOXML archive
+ $rels = simplexml_load_string(
+ $this->securityScanner->scan(
+ $this->getFromZipArchive($zip, '_rels/.rels')
+ ),
+ 'SimpleXMLElement',
+ Settings::getLibXmlLoaderOptions()
+ );
+ if ($rels !== false) {
+ foreach ($rels->Relationship as $rel) {
+ switch ($rel['Type']) {
+ case 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument':
+ $basename = basename($rel['Target']);
+ if (preg_match('/workbook.*\.xml/', $basename)) {
+ $workbookBasename = $basename;
+ }
+
+ break;
+ }
+ }
+ }
+
+ return $workbookBasename;
+ }
+
+ private function readSheetProtection(Worksheet $docSheet, SimpleXMLElement $xmlSheet): void
+ {
+ if ($this->readDataOnly || !$xmlSheet->sheetProtection) {
+ return;
+ }
+
+ $algorithmName = (string) $xmlSheet->sheetProtection['algorithmName'];
+ $protection = $docSheet->getProtection();
+ $protection->setAlgorithm($algorithmName);
+
+ if ($algorithmName) {
+ $protection->setPassword((string) $xmlSheet->sheetProtection['hashValue'], true);
+ $protection->setSalt((string) $xmlSheet->sheetProtection['saltValue']);
+ $protection->setSpinCount((int) $xmlSheet->sheetProtection['spinCount']);
+ } else {
+ $protection->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);
+ }
+ }
+ }
+}
diff --git a/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xlsx/AutoFilter.php b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xlsx/AutoFilter.php new file mode 100644 index 0000000..685b017 --- /dev/null +++ b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xlsx/AutoFilter.php @@ -0,0 +1,146 @@ +<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader\Xlsx;
+
+use PhpOffice\PhpSpreadsheet\Worksheet\AutoFilter\Column;
+use PhpOffice\PhpSpreadsheet\Worksheet\AutoFilter\Column\Rule;
+use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
+use SimpleXMLElement;
+
+class AutoFilter
+{
+ private $worksheet;
+
+ private $worksheetXml;
+
+ public function __construct(Worksheet $workSheet, SimpleXMLElement $worksheetXml)
+ {
+ $this->worksheet = $workSheet;
+ $this->worksheetXml = $worksheetXml;
+ }
+
+ public function load(): void
+ {
+ // Remove all "$" in the auto filter range
+ $autoFilterRange = preg_replace('/\$/', '', $this->worksheetXml->autoFilter['ref']);
+ if (strpos($autoFilterRange, ':') !== false) {
+ $this->readAutoFilter($autoFilterRange, $this->worksheetXml);
+ }
+ }
+
+ private function readAutoFilter($autoFilterRange, $xmlSheet): void
+ {
+ $autoFilter = $this->worksheet->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(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(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(Rule::AUTOFILTER_RULETYPE_FILTER);
+ }
+
+ // Or Date Group elements
+ $this->readDateRangeAutoFilter($filters, $column);
+ }
+
+ // Check for custom filters
+ $this->readCustomAutoFilter($filterColumn, $column);
+ // Check for dynamic filters
+ $this->readDynamicAutoFilter($filterColumn, $column);
+ // Check for dynamic filters
+ $this->readTopTenAutoFilter($filterColumn, $column);
+ }
+ }
+
+ private function readDateRangeAutoFilter(SimpleXMLElement $filters, Column $column): void
+ {
+ foreach ($filters->dateGroupItem as $dateGroupItem) {
+ // Operator is undefined, but always treated as EQUAL
+ $column->createRule()->setRule(
+ null,
+ [
+ '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(Rule::AUTOFILTER_RULETYPE_DATEGROUP);
+ }
+ }
+
+ private function readCustomAutoFilter(SimpleXMLElement $filterColumn, Column $column): void
+ {
+ if ($filterColumn->customFilters) {
+ $column->setFilterType(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(Column::AUTOFILTER_COLUMN_JOIN_AND);
+ }
+ foreach ($customFilters->customFilter as $filterRule) {
+ $column->createRule()->setRule(
+ (string) $filterRule['operator'],
+ (string) $filterRule['val']
+ )->setRuleType(Rule::AUTOFILTER_RULETYPE_CUSTOMFILTER);
+ }
+ }
+ }
+
+ private function readDynamicAutoFilter(SimpleXMLElement $filterColumn, Column $column): void
+ {
+ if ($filterColumn->dynamicFilter) {
+ $column->setFilterType(Column::AUTOFILTER_FILTERTYPE_DYNAMICFILTER);
+ // We should only ever have one dynamic filter
+ foreach ($filterColumn->dynamicFilter as $filterRule) {
+ // Operator is undefined, but always treated as EQUAL
+ $column->createRule()->setRule(
+ null,
+ (string) $filterRule['val'],
+ (string) $filterRule['type']
+ )->setRuleType(Rule::AUTOFILTER_RULETYPE_DYNAMICFILTER);
+ if (isset($filterRule['val'])) {
+ $column->setAttribute('val', (string) $filterRule['val']);
+ }
+ if (isset($filterRule['maxVal'])) {
+ $column->setAttribute('maxVal', (string) $filterRule['maxVal']);
+ }
+ }
+ }
+ }
+
+ private function readTopTenAutoFilter(SimpleXMLElement $filterColumn, Column $column): void
+ {
+ if ($filterColumn->top10) {
+ $column->setFilterType(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))
+ ? Rule::AUTOFILTER_COLUMN_RULE_TOPTEN_PERCENT
+ : Rule::AUTOFILTER_COLUMN_RULE_TOPTEN_BY_VALUE
+ ),
+ (string) $filterRule['val'],
+ (((isset($filterRule['top'])) && ($filterRule['top'] == 1))
+ ? Rule::AUTOFILTER_COLUMN_RULE_TOPTEN_TOP
+ : Rule::AUTOFILTER_COLUMN_RULE_TOPTEN_BOTTOM
+ )
+ )->setRuleType(Rule::AUTOFILTER_RULETYPE_TOPTENFILTER);
+ }
+ }
+ }
+}
diff --git a/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xlsx/BaseParserClass.php b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xlsx/BaseParserClass.php new file mode 100644 index 0000000..3c2fc90 --- /dev/null +++ b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xlsx/BaseParserClass.php @@ -0,0 +1,19 @@ +<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader\Xlsx;
+
+class BaseParserClass
+{
+ protected static function boolean($value)
+ {
+ if (is_object($value)) {
+ $value = (string) $value;
+ }
+
+ if (is_numeric($value)) {
+ return (bool) $value;
+ }
+
+ return $value === strtolower('true');
+ }
+}
diff --git a/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xlsx/Chart.php b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xlsx/Chart.php new file mode 100644 index 0000000..f2c10e3 --- /dev/null +++ b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xlsx/Chart.php @@ -0,0 +1,567 @@ +<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader\Xlsx;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheet\Chart\DataSeries;
+use PhpOffice\PhpSpreadsheet\Chart\DataSeriesValues;
+use PhpOffice\PhpSpreadsheet\Chart\Layout;
+use PhpOffice\PhpSpreadsheet\Chart\Legend;
+use PhpOffice\PhpSpreadsheet\Chart\PlotArea;
+use PhpOffice\PhpSpreadsheet\Chart\Title;
+use PhpOffice\PhpSpreadsheet\RichText\RichText;
+use PhpOffice\PhpSpreadsheet\Style\Color;
+use PhpOffice\PhpSpreadsheet\Style\Font;
+use SimpleXMLElement;
+
+class Chart
+{
+ /**
+ * @param string $name
+ * @param string $format
+ *
+ * @return null|bool|float|int|string
+ */
+ private static function getAttribute(SimpleXMLElement $component, $name, $format)
+ {
+ $attributes = $component->attributes();
+ if (isset($attributes[$name])) {
+ if ($format == 'string') {
+ return (string) $attributes[$name];
+ } elseif ($format == 'integer') {
+ return (int) $attributes[$name];
+ } elseif ($format == 'boolean') {
+ return (bool) ($attributes[$name] === '0' || $attributes[$name] !== 'true') ? false : true;
+ }
+
+ return (float) $attributes[$name];
+ }
+
+ return null;
+ }
+
+ private static function readColor($color, $background = false)
+ {
+ if (isset($color['rgb'])) {
+ return (string) $color['rgb'];
+ } elseif (isset($color['indexed'])) {
+ return Color::indexedColor($color['indexed'] - 7, $background)->getARGB();
+ }
+ }
+
+ /**
+ * @param string $chartName
+ *
+ * @return \PhpOffice\PhpSpreadsheet\Chart\Chart
+ */
+ public static function readChart(SimpleXMLElement $chartElements, $chartName)
+ {
+ $namespacesChartMeta = $chartElements->getNamespaces(true);
+ $chartElementsC = $chartElements->children($namespacesChartMeta['c']);
+
+ $XaxisLabel = $YaxisLabel = $legend = $title = null;
+ $dispBlanksAs = $plotVisOnly = null;
+
+ foreach ($chartElementsC as $chartElementKey => $chartElement) {
+ switch ($chartElementKey) {
+ case 'chart':
+ foreach ($chartElement as $chartDetailsKey => $chartDetails) {
+ $chartDetailsC = $chartDetails->children($namespacesChartMeta['c']);
+ switch ($chartDetailsKey) {
+ case 'plotArea':
+ $plotAreaLayout = $XaxisLable = $YaxisLable = null;
+ $plotSeries = $plotAttributes = [];
+ foreach ($chartDetails as $chartDetailKey => $chartDetail) {
+ switch ($chartDetailKey) {
+ case 'layout':
+ $plotAreaLayout = self::chartLayoutDetails($chartDetail, $namespacesChartMeta);
+
+ break;
+ case 'catAx':
+ if (isset($chartDetail->title)) {
+ $XaxisLabel = self::chartTitle($chartDetail->title->children($namespacesChartMeta['c']), $namespacesChartMeta);
+ }
+
+ break;
+ case 'dateAx':
+ if (isset($chartDetail->title)) {
+ $XaxisLabel = self::chartTitle($chartDetail->title->children($namespacesChartMeta['c']), $namespacesChartMeta);
+ }
+
+ break;
+ case 'valAx':
+ if (isset($chartDetail->title)) {
+ $YaxisLabel = self::chartTitle($chartDetail->title->children($namespacesChartMeta['c']), $namespacesChartMeta);
+ }
+
+ break;
+ case 'barChart':
+ case 'bar3DChart':
+ $barDirection = self::getAttribute($chartDetail->barDir, 'val', 'string');
+ $plotSer = self::chartDataSeries($chartDetail, $namespacesChartMeta, $chartDetailKey);
+ $plotSer->setPlotDirection($barDirection);
+ $plotSeries[] = $plotSer;
+ $plotAttributes = self::readChartAttributes($chartDetail);
+
+ break;
+ case 'lineChart':
+ case 'line3DChart':
+ $plotSeries[] = self::chartDataSeries($chartDetail, $namespacesChartMeta, $chartDetailKey);
+ $plotAttributes = self::readChartAttributes($chartDetail);
+
+ break;
+ case 'areaChart':
+ case 'area3DChart':
+ $plotSeries[] = self::chartDataSeries($chartDetail, $namespacesChartMeta, $chartDetailKey);
+ $plotAttributes = self::readChartAttributes($chartDetail);
+
+ break;
+ case 'doughnutChart':
+ case 'pieChart':
+ case 'pie3DChart':
+ $explosion = isset($chartDetail->ser->explosion);
+ $plotSer = self::chartDataSeries($chartDetail, $namespacesChartMeta, $chartDetailKey);
+ $plotSer->setPlotStyle($explosion);
+ $plotSeries[] = $plotSer;
+ $plotAttributes = self::readChartAttributes($chartDetail);
+
+ break;
+ case 'scatterChart':
+ $scatterStyle = self::getAttribute($chartDetail->scatterStyle, 'val', 'string');
+ $plotSer = self::chartDataSeries($chartDetail, $namespacesChartMeta, $chartDetailKey);
+ $plotSer->setPlotStyle($scatterStyle);
+ $plotSeries[] = $plotSer;
+ $plotAttributes = self::readChartAttributes($chartDetail);
+
+ break;
+ case 'bubbleChart':
+ $bubbleScale = self::getAttribute($chartDetail->bubbleScale, 'val', 'integer');
+ $plotSer = self::chartDataSeries($chartDetail, $namespacesChartMeta, $chartDetailKey);
+ $plotSer->setPlotStyle($bubbleScale);
+ $plotSeries[] = $plotSer;
+ $plotAttributes = self::readChartAttributes($chartDetail);
+
+ break;
+ case 'radarChart':
+ $radarStyle = self::getAttribute($chartDetail->radarStyle, 'val', 'string');
+ $plotSer = self::chartDataSeries($chartDetail, $namespacesChartMeta, $chartDetailKey);
+ $plotSer->setPlotStyle($radarStyle);
+ $plotSeries[] = $plotSer;
+ $plotAttributes = self::readChartAttributes($chartDetail);
+
+ break;
+ case 'surfaceChart':
+ case 'surface3DChart':
+ $wireFrame = self::getAttribute($chartDetail->wireframe, 'val', 'boolean');
+ $plotSer = self::chartDataSeries($chartDetail, $namespacesChartMeta, $chartDetailKey);
+ $plotSer->setPlotStyle($wireFrame);
+ $plotSeries[] = $plotSer;
+ $plotAttributes = self::readChartAttributes($chartDetail);
+
+ break;
+ case 'stockChart':
+ $plotSeries[] = self::chartDataSeries($chartDetail, $namespacesChartMeta, $chartDetailKey);
+ $plotAttributes = self::readChartAttributes($plotAreaLayout);
+
+ break;
+ }
+ }
+ if ($plotAreaLayout == null) {
+ $plotAreaLayout = new Layout();
+ }
+ $plotArea = new PlotArea($plotAreaLayout, $plotSeries);
+ self::setChartAttributes($plotAreaLayout, $plotAttributes);
+
+ break;
+ case 'plotVisOnly':
+ $plotVisOnly = self::getAttribute($chartDetails, 'val', 'string');
+
+ break;
+ case 'dispBlanksAs':
+ $dispBlanksAs = self::getAttribute($chartDetails, 'val', 'string');
+
+ break;
+ case 'title':
+ $title = self::chartTitle($chartDetails, $namespacesChartMeta);
+
+ break;
+ case 'legend':
+ $legendPos = 'r';
+ $legendLayout = null;
+ $legendOverlay = false;
+ foreach ($chartDetails as $chartDetailKey => $chartDetail) {
+ switch ($chartDetailKey) {
+ case 'legendPos':
+ $legendPos = self::getAttribute($chartDetail, 'val', 'string');
+
+ break;
+ case 'overlay':
+ $legendOverlay = self::getAttribute($chartDetail, 'val', 'boolean');
+
+ break;
+ case 'layout':
+ $legendLayout = self::chartLayoutDetails($chartDetail, $namespacesChartMeta);
+
+ break;
+ }
+ }
+ $legend = new Legend($legendPos, $legendLayout, $legendOverlay);
+
+ break;
+ }
+ }
+ }
+ }
+ $chart = new \PhpOffice\PhpSpreadsheet\Chart\Chart($chartName, $title, $legend, $plotArea, $plotVisOnly, $dispBlanksAs, $XaxisLabel, $YaxisLabel);
+
+ return $chart;
+ }
+
+ private static function chartTitle(SimpleXMLElement $titleDetails, array $namespacesChartMeta)
+ {
+ $caption = [];
+ $titleLayout = null;
+ foreach ($titleDetails as $titleDetailKey => $chartDetail) {
+ switch ($titleDetailKey) {
+ case 'tx':
+ $titleDetails = $chartDetail->rich->children($namespacesChartMeta['a']);
+ foreach ($titleDetails as $titleKey => $titleDetail) {
+ switch ($titleKey) {
+ case 'p':
+ $titleDetailPart = $titleDetail->children($namespacesChartMeta['a']);
+ $caption[] = self::parseRichText($titleDetailPart);
+ }
+ }
+
+ break;
+ case 'layout':
+ $titleLayout = self::chartLayoutDetails($chartDetail, $namespacesChartMeta);
+
+ break;
+ }
+ }
+
+ return new Title($caption, $titleLayout);
+ }
+
+ private static function chartLayoutDetails($chartDetail, $namespacesChartMeta)
+ {
+ if (!isset($chartDetail->manualLayout)) {
+ return null;
+ }
+ $details = $chartDetail->manualLayout->children($namespacesChartMeta['c']);
+ if ($details === null) {
+ return null;
+ }
+ $layout = [];
+ foreach ($details as $detailKey => $detail) {
+ $layout[$detailKey] = self::getAttribute($detail, 'val', 'string');
+ }
+
+ return new Layout($layout);
+ }
+
+ private static function chartDataSeries($chartDetail, $namespacesChartMeta, $plotType)
+ {
+ $multiSeriesType = null;
+ $smoothLine = false;
+ $seriesLabel = $seriesCategory = $seriesValues = $plotOrder = [];
+
+ $seriesDetailSet = $chartDetail->children($namespacesChartMeta['c']);
+ foreach ($seriesDetailSet as $seriesDetailKey => $seriesDetails) {
+ switch ($seriesDetailKey) {
+ case 'grouping':
+ $multiSeriesType = self::getAttribute($chartDetail->grouping, 'val', 'string');
+
+ break;
+ case 'ser':
+ $marker = null;
+ $seriesIndex = '';
+ foreach ($seriesDetails as $seriesKey => $seriesDetail) {
+ switch ($seriesKey) {
+ case 'idx':
+ $seriesIndex = self::getAttribute($seriesDetail, 'val', 'integer');
+
+ break;
+ case 'order':
+ $seriesOrder = self::getAttribute($seriesDetail, 'val', 'integer');
+ $plotOrder[$seriesIndex] = $seriesOrder;
+
+ break;
+ case 'tx':
+ $seriesLabel[$seriesIndex] = self::chartDataSeriesValueSet($seriesDetail, $namespacesChartMeta);
+
+ break;
+ case 'marker':
+ $marker = self::getAttribute($seriesDetail->symbol, 'val', 'string');
+
+ break;
+ case 'smooth':
+ $smoothLine = self::getAttribute($seriesDetail, 'val', 'boolean');
+
+ break;
+ case 'cat':
+ $seriesCategory[$seriesIndex] = self::chartDataSeriesValueSet($seriesDetail, $namespacesChartMeta);
+
+ break;
+ case 'val':
+ $seriesValues[$seriesIndex] = self::chartDataSeriesValueSet($seriesDetail, $namespacesChartMeta, $marker);
+
+ break;
+ case 'xVal':
+ $seriesCategory[$seriesIndex] = self::chartDataSeriesValueSet($seriesDetail, $namespacesChartMeta, $marker);
+
+ break;
+ case 'yVal':
+ $seriesValues[$seriesIndex] = self::chartDataSeriesValueSet($seriesDetail, $namespacesChartMeta, $marker);
+
+ break;
+ }
+ }
+ }
+ }
+
+ return new DataSeries($plotType, $multiSeriesType, $plotOrder, $seriesLabel, $seriesCategory, $seriesValues, $smoothLine);
+ }
+
+ private static function chartDataSeriesValueSet($seriesDetail, $namespacesChartMeta, $marker = null)
+ {
+ if (isset($seriesDetail->strRef)) {
+ $seriesSource = (string) $seriesDetail->strRef->f;
+ $seriesData = self::chartDataSeriesValues($seriesDetail->strRef->strCache->children($namespacesChartMeta['c']), 's');
+
+ return new DataSeriesValues(DataSeriesValues::DATASERIES_TYPE_STRING, $seriesSource, $seriesData['formatCode'], $seriesData['pointCount'], $seriesData['dataValues'], $marker);
+ } elseif (isset($seriesDetail->numRef)) {
+ $seriesSource = (string) $seriesDetail->numRef->f;
+ $seriesData = self::chartDataSeriesValues($seriesDetail->numRef->numCache->children($namespacesChartMeta['c']));
+
+ return new DataSeriesValues(DataSeriesValues::DATASERIES_TYPE_NUMBER, $seriesSource, $seriesData['formatCode'], $seriesData['pointCount'], $seriesData['dataValues'], $marker);
+ } elseif (isset($seriesDetail->multiLvlStrRef)) {
+ $seriesSource = (string) $seriesDetail->multiLvlStrRef->f;
+ $seriesData = self::chartDataSeriesValuesMultiLevel($seriesDetail->multiLvlStrRef->multiLvlStrCache->children($namespacesChartMeta['c']), 's');
+ $seriesData['pointCount'] = count($seriesData['dataValues']);
+
+ return new DataSeriesValues(DataSeriesValues::DATASERIES_TYPE_STRING, $seriesSource, $seriesData['formatCode'], $seriesData['pointCount'], $seriesData['dataValues'], $marker);
+ } elseif (isset($seriesDetail->multiLvlNumRef)) {
+ $seriesSource = (string) $seriesDetail->multiLvlNumRef->f;
+ $seriesData = self::chartDataSeriesValuesMultiLevel($seriesDetail->multiLvlNumRef->multiLvlNumCache->children($namespacesChartMeta['c']), 's');
+ $seriesData['pointCount'] = count($seriesData['dataValues']);
+
+ return new DataSeriesValues(DataSeriesValues::DATASERIES_TYPE_STRING, $seriesSource, $seriesData['formatCode'], $seriesData['pointCount'], $seriesData['dataValues'], $marker);
+ }
+
+ return null;
+ }
+
+ private static function chartDataSeriesValues($seriesValueSet, $dataType = 'n')
+ {
+ $seriesVal = [];
+ $formatCode = '';
+ $pointCount = 0;
+
+ foreach ($seriesValueSet as $seriesValueIdx => $seriesValue) {
+ switch ($seriesValueIdx) {
+ case 'ptCount':
+ $pointCount = self::getAttribute($seriesValue, 'val', 'integer');
+
+ break;
+ case 'formatCode':
+ $formatCode = (string) $seriesValue;
+
+ break;
+ case 'pt':
+ $pointVal = self::getAttribute($seriesValue, 'idx', 'integer');
+ if ($dataType == 's') {
+ $seriesVal[$pointVal] = (string) $seriesValue->v;
+ } elseif ($seriesValue->v === Functions::NA()) {
+ $seriesVal[$pointVal] = null;
+ } else {
+ $seriesVal[$pointVal] = (float) $seriesValue->v;
+ }
+
+ break;
+ }
+ }
+
+ return [
+ 'formatCode' => $formatCode,
+ 'pointCount' => $pointCount,
+ 'dataValues' => $seriesVal,
+ ];
+ }
+
+ private static function chartDataSeriesValuesMultiLevel($seriesValueSet, $dataType = 'n')
+ {
+ $seriesVal = [];
+ $formatCode = '';
+ $pointCount = 0;
+
+ foreach ($seriesValueSet->lvl as $seriesLevelIdx => $seriesLevel) {
+ foreach ($seriesLevel as $seriesValueIdx => $seriesValue) {
+ switch ($seriesValueIdx) {
+ case 'ptCount':
+ $pointCount = self::getAttribute($seriesValue, 'val', 'integer');
+
+ break;
+ case 'formatCode':
+ $formatCode = (string) $seriesValue;
+
+ break;
+ case 'pt':
+ $pointVal = self::getAttribute($seriesValue, 'idx', 'integer');
+ if ($dataType == 's') {
+ $seriesVal[$pointVal][] = (string) $seriesValue->v;
+ } elseif ($seriesValue->v === Functions::NA()) {
+ $seriesVal[$pointVal] = null;
+ } else {
+ $seriesVal[$pointVal][] = (float) $seriesValue->v;
+ }
+
+ break;
+ }
+ }
+ }
+
+ return [
+ 'formatCode' => $formatCode,
+ 'pointCount' => $pointCount,
+ 'dataValues' => $seriesVal,
+ ];
+ }
+
+ private static function parseRichText(SimpleXMLElement $titleDetailPart)
+ {
+ $value = new RichText();
+ $objText = null;
+ foreach ($titleDetailPart as $titleDetailElementKey => $titleDetailElement) {
+ if (isset($titleDetailElement->t)) {
+ $objText = $value->createTextRun((string) $titleDetailElement->t);
+ }
+ if (isset($titleDetailElement->rPr)) {
+ if (isset($titleDetailElement->rPr->rFont['val'])) {
+ $objText->getFont()->setName((string) $titleDetailElement->rPr->rFont['val']);
+ }
+
+ $fontSize = (self::getAttribute($titleDetailElement->rPr, 'sz', 'integer'));
+ if ($fontSize !== null) {
+ $objText->getFont()->setSize(floor($fontSize / 100));
+ }
+
+ $fontColor = (self::getAttribute($titleDetailElement->rPr, 'color', 'string'));
+ if ($fontColor !== null) {
+ $objText->getFont()->setColor(new Color(self::readColor($fontColor)));
+ }
+
+ $bold = self::getAttribute($titleDetailElement->rPr, 'b', 'boolean');
+ if ($bold !== null) {
+ $objText->getFont()->setBold($bold);
+ }
+
+ $italic = self::getAttribute($titleDetailElement->rPr, 'i', 'boolean');
+ if ($italic !== null) {
+ $objText->getFont()->setItalic($italic);
+ }
+
+ $baseline = self::getAttribute($titleDetailElement->rPr, 'baseline', 'integer');
+ if ($baseline !== null) {
+ if ($baseline > 0) {
+ $objText->getFont()->setSuperscript(true);
+ } elseif ($baseline < 0) {
+ $objText->getFont()->setSubscript(true);
+ }
+ }
+
+ $underscore = (self::getAttribute($titleDetailElement->rPr, 'u', 'string'));
+ if ($underscore !== null) {
+ if ($underscore == 'sng') {
+ $objText->getFont()->setUnderline(Font::UNDERLINE_SINGLE);
+ } elseif ($underscore == 'dbl') {
+ $objText->getFont()->setUnderline(Font::UNDERLINE_DOUBLE);
+ } else {
+ $objText->getFont()->setUnderline(Font::UNDERLINE_NONE);
+ }
+ }
+
+ $strikethrough = (self::getAttribute($titleDetailElement->rPr, 's', 'string'));
+ if ($strikethrough !== null) {
+ if ($strikethrough == 'noStrike') {
+ $objText->getFont()->setStrikethrough(false);
+ } else {
+ $objText->getFont()->setStrikethrough(true);
+ }
+ }
+ }
+ }
+
+ return $value;
+ }
+
+ private static function readChartAttributes($chartDetail)
+ {
+ $plotAttributes = [];
+ if (isset($chartDetail->dLbls)) {
+ if (isset($chartDetail->dLbls->howLegendKey)) {
+ $plotAttributes['showLegendKey'] = self::getAttribute($chartDetail->dLbls->showLegendKey, 'val', 'string');
+ }
+ if (isset($chartDetail->dLbls->showVal)) {
+ $plotAttributes['showVal'] = self::getAttribute($chartDetail->dLbls->showVal, 'val', 'string');
+ }
+ if (isset($chartDetail->dLbls->showCatName)) {
+ $plotAttributes['showCatName'] = self::getAttribute($chartDetail->dLbls->showCatName, 'val', 'string');
+ }
+ if (isset($chartDetail->dLbls->showSerName)) {
+ $plotAttributes['showSerName'] = self::getAttribute($chartDetail->dLbls->showSerName, 'val', 'string');
+ }
+ if (isset($chartDetail->dLbls->showPercent)) {
+ $plotAttributes['showPercent'] = self::getAttribute($chartDetail->dLbls->showPercent, 'val', 'string');
+ }
+ if (isset($chartDetail->dLbls->showBubbleSize)) {
+ $plotAttributes['showBubbleSize'] = self::getAttribute($chartDetail->dLbls->showBubbleSize, 'val', 'string');
+ }
+ if (isset($chartDetail->dLbls->showLeaderLines)) {
+ $plotAttributes['showLeaderLines'] = self::getAttribute($chartDetail->dLbls->showLeaderLines, 'val', 'string');
+ }
+ }
+
+ return $plotAttributes;
+ }
+
+ /**
+ * @param mixed $plotAttributes
+ */
+ private static function setChartAttributes(Layout $plotArea, $plotAttributes): void
+ {
+ foreach ($plotAttributes as $plotAttributeKey => $plotAttributeValue) {
+ switch ($plotAttributeKey) {
+ case 'showLegendKey':
+ $plotArea->setShowLegendKey($plotAttributeValue);
+
+ break;
+ case 'showVal':
+ $plotArea->setShowVal($plotAttributeValue);
+
+ break;
+ case 'showCatName':
+ $plotArea->setShowCatName($plotAttributeValue);
+
+ break;
+ case 'showSerName':
+ $plotArea->setShowSerName($plotAttributeValue);
+
+ break;
+ case 'showPercent':
+ $plotArea->setShowPercent($plotAttributeValue);
+
+ break;
+ case 'showBubbleSize':
+ $plotArea->setShowBubbleSize($plotAttributeValue);
+
+ break;
+ case 'showLeaderLines':
+ $plotArea->setShowLeaderLines($plotAttributeValue);
+
+ break;
+ }
+ }
+ }
+}
diff --git a/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xlsx/ColumnAndRowAttributes.php b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xlsx/ColumnAndRowAttributes.php new file mode 100644 index 0000000..e24d918 --- /dev/null +++ b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xlsx/ColumnAndRowAttributes.php @@ -0,0 +1,209 @@ +<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader\Xlsx;
+
+use PhpOffice\PhpSpreadsheet\Cell\Coordinate;
+use PhpOffice\PhpSpreadsheet\Reader\IReadFilter;
+use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
+use SimpleXMLElement;
+
+class ColumnAndRowAttributes extends BaseParserClass
+{
+ private $worksheet;
+
+ private $worksheetXml;
+
+ public function __construct(Worksheet $workSheet, ?SimpleXMLElement $worksheetXml = null)
+ {
+ $this->worksheet = $workSheet;
+ $this->worksheetXml = $worksheetXml;
+ }
+
+ /**
+ * Set Worksheet column attributes by attributes array passed.
+ *
+ * @param string $columnAddress A, B, ... DX, ...
+ * @param array $columnAttributes array of attributes (indexes are attribute name, values are value)
+ * 'xfIndex', 'visible', 'collapsed', 'outlineLevel', 'width', ... ?
+ */
+ private function setColumnAttributes($columnAddress, array $columnAttributes): void
+ {
+ if (isset($columnAttributes['xfIndex'])) {
+ $this->worksheet->getColumnDimension($columnAddress)->setXfIndex($columnAttributes['xfIndex']);
+ }
+ if (isset($columnAttributes['visible'])) {
+ $this->worksheet->getColumnDimension($columnAddress)->setVisible($columnAttributes['visible']);
+ }
+ if (isset($columnAttributes['collapsed'])) {
+ $this->worksheet->getColumnDimension($columnAddress)->setCollapsed($columnAttributes['collapsed']);
+ }
+ if (isset($columnAttributes['outlineLevel'])) {
+ $this->worksheet->getColumnDimension($columnAddress)->setOutlineLevel($columnAttributes['outlineLevel']);
+ }
+ if (isset($columnAttributes['width'])) {
+ $this->worksheet->getColumnDimension($columnAddress)->setWidth($columnAttributes['width']);
+ }
+ }
+
+ /**
+ * Set Worksheet row attributes by attributes array passed.
+ *
+ * @param int $rowNumber 1, 2, 3, ... 99, ...
+ * @param array $rowAttributes array of attributes (indexes are attribute name, values are value)
+ * 'xfIndex', 'visible', 'collapsed', 'outlineLevel', 'rowHeight', ... ?
+ */
+ private function setRowAttributes($rowNumber, array $rowAttributes): void
+ {
+ if (isset($rowAttributes['xfIndex'])) {
+ $this->worksheet->getRowDimension($rowNumber)->setXfIndex($rowAttributes['xfIndex']);
+ }
+ if (isset($rowAttributes['visible'])) {
+ $this->worksheet->getRowDimension($rowNumber)->setVisible($rowAttributes['visible']);
+ }
+ if (isset($rowAttributes['collapsed'])) {
+ $this->worksheet->getRowDimension($rowNumber)->setCollapsed($rowAttributes['collapsed']);
+ }
+ if (isset($rowAttributes['outlineLevel'])) {
+ $this->worksheet->getRowDimension($rowNumber)->setOutlineLevel($rowAttributes['outlineLevel']);
+ }
+ if (isset($rowAttributes['rowHeight'])) {
+ $this->worksheet->getRowDimension($rowNumber)->setRowHeight($rowAttributes['rowHeight']);
+ }
+ }
+
+ /**
+ * @param IReadFilter $readFilter
+ * @param bool $readDataOnly
+ */
+ public function load(?IReadFilter $readFilter = null, $readDataOnly = false): void
+ {
+ if ($this->worksheetXml === null) {
+ return;
+ }
+
+ $columnsAttributes = [];
+ $rowsAttributes = [];
+ if (isset($this->worksheetXml->cols)) {
+ $columnsAttributes = $this->readColumnAttributes($this->worksheetXml->cols, $readDataOnly);
+ }
+
+ if ($this->worksheetXml->sheetData && $this->worksheetXml->sheetData->row) {
+ $rowsAttributes = $this->readRowAttributes($this->worksheetXml->sheetData->row, $readDataOnly);
+ }
+
+ // set columns/rows attributes
+ $columnsAttributesAreSet = [];
+ foreach ($columnsAttributes as $columnCoordinate => $columnAttributes) {
+ if (
+ $readFilter === null ||
+ !$this->isFilteredColumn($readFilter, $columnCoordinate, $rowsAttributes)
+ ) {
+ if (!isset($columnsAttributesAreSet[$columnCoordinate])) {
+ $this->setColumnAttributes($columnCoordinate, $columnAttributes);
+ $columnsAttributesAreSet[$columnCoordinate] = true;
+ }
+ }
+ }
+
+ $rowsAttributesAreSet = [];
+ foreach ($rowsAttributes as $rowCoordinate => $rowAttributes) {
+ if (
+ $readFilter === null ||
+ !$this->isFilteredRow($readFilter, $rowCoordinate, $columnsAttributes)
+ ) {
+ if (!isset($rowsAttributesAreSet[$rowCoordinate])) {
+ $this->setRowAttributes($rowCoordinate, $rowAttributes);
+ $rowsAttributesAreSet[$rowCoordinate] = true;
+ }
+ }
+ }
+ }
+
+ private function isFilteredColumn(IReadFilter $readFilter, $columnCoordinate, array $rowsAttributes)
+ {
+ foreach ($rowsAttributes as $rowCoordinate => $rowAttributes) {
+ if (!$readFilter->readCell($columnCoordinate, $rowCoordinate, $this->worksheet->getTitle())) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ private function readColumnAttributes(SimpleXMLElement $worksheetCols, $readDataOnly)
+ {
+ $columnAttributes = [];
+
+ foreach ($worksheetCols->col as $column) {
+ $startColumn = Coordinate::stringFromColumnIndex((int) $column['min']);
+ $endColumn = Coordinate::stringFromColumnIndex((int) $column['max']);
+ ++$endColumn;
+ for ($columnAddress = $startColumn; $columnAddress !== $endColumn; ++$columnAddress) {
+ $columnAttributes[$columnAddress] = $this->readColumnRangeAttributes($column, $readDataOnly);
+
+ if ((int) ($column['max']) == 16384) {
+ break;
+ }
+ }
+ }
+
+ return $columnAttributes;
+ }
+
+ private function readColumnRangeAttributes(SimpleXMLElement $column, $readDataOnly)
+ {
+ $columnAttributes = [];
+
+ if ($column['style'] && !$readDataOnly) {
+ $columnAttributes['xfIndex'] = (int) $column['style'];
+ }
+ if (self::boolean($column['hidden'])) {
+ $columnAttributes['visible'] = false;
+ }
+ if (self::boolean($column['collapsed'])) {
+ $columnAttributes['collapsed'] = true;
+ }
+ if (((int) $column['outlineLevel']) > 0) {
+ $columnAttributes['outlineLevel'] = (int) $column['outlineLevel'];
+ }
+ $columnAttributes['width'] = (float) $column['width'];
+
+ return $columnAttributes;
+ }
+
+ private function isFilteredRow(IReadFilter $readFilter, $rowCoordinate, array $columnsAttributes)
+ {
+ foreach ($columnsAttributes as $columnCoordinate => $columnAttributes) {
+ if (!$readFilter->readCell($columnCoordinate, $rowCoordinate, $this->worksheet->getTitle())) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ private function readRowAttributes(SimpleXMLElement $worksheetRow, $readDataOnly)
+ {
+ $rowAttributes = [];
+
+ foreach ($worksheetRow as $row) {
+ if ($row['ht'] && !$readDataOnly) {
+ $rowAttributes[(int) $row['r']]['rowHeight'] = (float) $row['ht'];
+ }
+ if (self::boolean($row['hidden'])) {
+ $rowAttributes[(int) $row['r']]['visible'] = false;
+ }
+ if (self::boolean($row['collapsed'])) {
+ $rowAttributes[(int) $row['r']]['collapsed'] = true;
+ }
+ if ((int) $row['outlineLevel'] > 0) {
+ $rowAttributes[(int) $row['r']]['outlineLevel'] = (int) $row['outlineLevel'];
+ }
+ if ($row['s'] && !$readDataOnly) {
+ $rowAttributes[(int) $row['r']]['xfIndex'] = (int) $row['s'];
+ }
+ }
+
+ return $rowAttributes;
+ }
+}
diff --git a/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xlsx/ConditionalStyles.php b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xlsx/ConditionalStyles.php new file mode 100644 index 0000000..a31aa7e --- /dev/null +++ b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xlsx/ConditionalStyles.php @@ -0,0 +1,97 @@ +<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader\Xlsx;
+
+use PhpOffice\PhpSpreadsheet\Style\Conditional;
+use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
+use SimpleXMLElement;
+
+class ConditionalStyles
+{
+ private $worksheet;
+
+ private $worksheetXml;
+
+ private $dxfs;
+
+ public function __construct(Worksheet $workSheet, SimpleXMLElement $worksheetXml, array $dxfs = [])
+ {
+ $this->worksheet = $workSheet;
+ $this->worksheetXml = $worksheetXml;
+ $this->dxfs = $dxfs;
+ }
+
+ public function load(): void
+ {
+ $this->setConditionalStyles(
+ $this->worksheet,
+ $this->readConditionalStyles($this->worksheetXml)
+ );
+ }
+
+ private function readConditionalStyles($xmlSheet)
+ {
+ $conditionals = [];
+ foreach ($xmlSheet->conditionalFormatting as $conditional) {
+ foreach ($conditional->cfRule as $cfRule) {
+ if (
+ ((string) $cfRule['type'] == Conditional::CONDITION_NONE
+ || (string) $cfRule['type'] == Conditional::CONDITION_CELLIS
+ || (string) $cfRule['type'] == Conditional::CONDITION_CONTAINSTEXT
+ || (string) $cfRule['type'] == Conditional::CONDITION_CONTAINSBLANKS
+ || (string) $cfRule['type'] == Conditional::CONDITION_NOTCONTAINSBLANKS
+ || (string) $cfRule['type'] == Conditional::CONDITION_EXPRESSION)
+ && isset($this->dxfs[(int) ($cfRule['dxfId'])])
+ ) {
+ $conditionals[(string) $conditional['sqref']][(int) ($cfRule['priority'])] = $cfRule;
+ }
+ }
+ }
+
+ return $conditionals;
+ }
+
+ private function setConditionalStyles(Worksheet $worksheet, array $conditionals): void
+ {
+ foreach ($conditionals as $ref => $cfRules) {
+ ksort($cfRules);
+ $conditionalStyles = $this->readStyleRules($cfRules);
+
+ // Extract all cell references in $ref
+ $cellBlocks = explode(' ', str_replace('$', '', strtoupper($ref)));
+ foreach ($cellBlocks as $cellBlock) {
+ $worksheet->getStyle($cellBlock)->setConditionalStyles($conditionalStyles);
+ }
+ }
+ }
+
+ private function readStyleRules($cfRules)
+ {
+ $conditionalStyles = [];
+ foreach ($cfRules as $cfRule) {
+ $objConditional = new Conditional();
+ $objConditional->setConditionType((string) $cfRule['type']);
+ $objConditional->setOperatorType((string) $cfRule['operator']);
+
+ if ((string) $cfRule['text'] != '') {
+ $objConditional->setText((string) $cfRule['text']);
+ }
+
+ if (isset($cfRule['stopIfTrue']) && (int) $cfRule['stopIfTrue'] === 1) {
+ $objConditional->setStopIfTrue(true);
+ }
+
+ if (count($cfRule->formula) > 1) {
+ foreach ($cfRule->formula as $formula) {
+ $objConditional->addCondition((string) $formula);
+ }
+ } else {
+ $objConditional->addCondition((string) $cfRule->formula);
+ }
+ $objConditional->setStyle(clone $this->dxfs[(int) ($cfRule['dxfId'])]);
+ $conditionalStyles[] = $objConditional;
+ }
+
+ return $conditionalStyles;
+ }
+}
diff --git a/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xlsx/DataValidations.php b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xlsx/DataValidations.php new file mode 100644 index 0000000..c396cc7 --- /dev/null +++ b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xlsx/DataValidations.php @@ -0,0 +1,51 @@ +<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader\Xlsx;
+
+use PhpOffice\PhpSpreadsheet\Cell\Coordinate;
+use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
+use SimpleXMLElement;
+
+class DataValidations
+{
+ private $worksheet;
+
+ private $worksheetXml;
+
+ public function __construct(Worksheet $workSheet, SimpleXMLElement $worksheetXml)
+ {
+ $this->worksheet = $workSheet;
+ $this->worksheetXml = $worksheetXml;
+ }
+
+ public function load(): void
+ {
+ foreach ($this->worksheetXml->dataValidations->dataValidation as $dataValidation) {
+ // Uppercase coordinate
+ $range = strtoupper($dataValidation['sqref']);
+ $rangeSet = explode(' ', $range);
+ foreach ($rangeSet as $range) {
+ $stRange = $this->worksheet->shrinkRangeToFit($range);
+
+ // Extract all cell references in $range
+ foreach (Coordinate::extractAllCellReferencesInRange($stRange) as $reference) {
+ // Create validation
+ $docValidation = $this->worksheet->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);
+ }
+ }
+ }
+ }
+}
diff --git a/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xlsx/Hyperlinks.php b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xlsx/Hyperlinks.php new file mode 100644 index 0000000..697def3 --- /dev/null +++ b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xlsx/Hyperlinks.php @@ -0,0 +1,59 @@ +<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader\Xlsx;
+
+use PhpOffice\PhpSpreadsheet\Cell\Coordinate;
+use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
+use SimpleXMLElement;
+
+class Hyperlinks
+{
+ private $worksheet;
+
+ private $hyperlinks = [];
+
+ public function __construct(Worksheet $workSheet)
+ {
+ $this->worksheet = $workSheet;
+ }
+
+ public function readHyperlinks(SimpleXMLElement $relsWorksheet): void
+ {
+ foreach ($relsWorksheet->Relationship as $element) {
+ if ($element['Type'] == 'http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink') {
+ $this->hyperlinks[(string) $element['Id']] = (string) $element['Target'];
+ }
+ }
+ }
+
+ public function setHyperlinks(SimpleXMLElement $worksheetXml): void
+ {
+ foreach ($worksheetXml->hyperlink as $hyperlink) {
+ $this->setHyperlink($hyperlink, $this->worksheet);
+ }
+ }
+
+ private function setHyperlink(SimpleXMLElement $hyperlink, Worksheet $worksheet): void
+ {
+ // Link url
+ $linkRel = $hyperlink->attributes('http://schemas.openxmlformats.org/officeDocument/2006/relationships');
+
+ foreach (Coordinate::extractAllCellReferencesInRange($hyperlink['ref']) as $cellReference) {
+ $cell = $worksheet->getCell($cellReference);
+ if (isset($linkRel['id'])) {
+ $hyperlinkUrl = $this->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']);
+ }
+ }
+ }
+}
diff --git a/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xlsx/PageSetup.php b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xlsx/PageSetup.php new file mode 100644 index 0000000..e26b004 --- /dev/null +++ b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xlsx/PageSetup.php @@ -0,0 +1,164 @@ +<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader\Xlsx;
+
+use PhpOffice\PhpSpreadsheet\Cell\Coordinate;
+use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
+use SimpleXMLElement;
+
+class PageSetup extends BaseParserClass
+{
+ private $worksheet;
+
+ private $worksheetXml;
+
+ public function __construct(Worksheet $workSheet, ?SimpleXMLElement $worksheetXml = null)
+ {
+ $this->worksheet = $workSheet;
+ $this->worksheetXml = $worksheetXml;
+ }
+
+ public function load(array $unparsedLoadedData)
+ {
+ if (!$this->worksheetXml) {
+ return $unparsedLoadedData;
+ }
+
+ $this->margins($this->worksheetXml, $this->worksheet);
+ $unparsedLoadedData = $this->pageSetup($this->worksheetXml, $this->worksheet, $unparsedLoadedData);
+ $this->headerFooter($this->worksheetXml, $this->worksheet);
+ $this->pageBreaks($this->worksheetXml, $this->worksheet);
+
+ return $unparsedLoadedData;
+ }
+
+ private function margins(SimpleXMLElement $xmlSheet, Worksheet $worksheet): void
+ {
+ if ($xmlSheet->pageMargins) {
+ $docPageMargins = $worksheet->getPageMargins();
+ $docPageMargins->setLeft((float) ($xmlSheet->pageMargins['left']));
+ $docPageMargins->setRight((float) ($xmlSheet->pageMargins['right']));
+ $docPageMargins->setTop((float) ($xmlSheet->pageMargins['top']));
+ $docPageMargins->setBottom((float) ($xmlSheet->pageMargins['bottom']));
+ $docPageMargins->setHeader((float) ($xmlSheet->pageMargins['header']));
+ $docPageMargins->setFooter((float) ($xmlSheet->pageMargins['footer']));
+ }
+ }
+
+ private function pageSetup(SimpleXMLElement $xmlSheet, Worksheet $worksheet, array $unparsedLoadedData)
+ {
+ if ($xmlSheet->pageSetup) {
+ $docPageSetup = $worksheet->getPageSetup();
+
+ if (isset($xmlSheet->pageSetup['orientation'])) {
+ $docPageSetup->setOrientation((string) $xmlSheet->pageSetup['orientation']);
+ }
+ if (isset($xmlSheet->pageSetup['paperSize'])) {
+ $docPageSetup->setPaperSize((int) ($xmlSheet->pageSetup['paperSize']));
+ }
+ if (isset($xmlSheet->pageSetup['scale'])) {
+ $docPageSetup->setScale((int) ($xmlSheet->pageSetup['scale']), false);
+ }
+ if (isset($xmlSheet->pageSetup['fitToHeight']) && (int) ($xmlSheet->pageSetup['fitToHeight']) >= 0) {
+ $docPageSetup->setFitToHeight((int) ($xmlSheet->pageSetup['fitToHeight']), false);
+ }
+ if (isset($xmlSheet->pageSetup['fitToWidth']) && (int) ($xmlSheet->pageSetup['fitToWidth']) >= 0) {
+ $docPageSetup->setFitToWidth((int) ($xmlSheet->pageSetup['fitToWidth']), false);
+ }
+ if (
+ isset($xmlSheet->pageSetup['firstPageNumber'], $xmlSheet->pageSetup['useFirstPageNumber']) &&
+ self::boolean((string) $xmlSheet->pageSetup['useFirstPageNumber'])
+ ) {
+ $docPageSetup->setFirstPageNumber((int) ($xmlSheet->pageSetup['firstPageNumber']));
+ }
+ if (isset($xmlSheet->pageSetup['pageOrder'])) {
+ $docPageSetup->setPageOrder((string) $xmlSheet->pageSetup['pageOrder']);
+ }
+
+ $relAttributes = $xmlSheet->pageSetup->attributes('http://schemas.openxmlformats.org/officeDocument/2006/relationships');
+ if (isset($relAttributes['id'])) {
+ $unparsedLoadedData['sheets'][$worksheet->getCodeName()]['pageSetupRelId'] = (string) $relAttributes['id'];
+ }
+ }
+
+ return $unparsedLoadedData;
+ }
+
+ private function headerFooter(SimpleXMLElement $xmlSheet, Worksheet $worksheet): void
+ {
+ if ($xmlSheet->headerFooter) {
+ $docHeaderFooter = $worksheet->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);
+ }
+ }
+
+ private function pageBreaks(SimpleXMLElement $xmlSheet, Worksheet $worksheet): void
+ {
+ if ($xmlSheet->rowBreaks && $xmlSheet->rowBreaks->brk) {
+ $this->rowBreaks($xmlSheet, $worksheet);
+ }
+ if ($xmlSheet->colBreaks && $xmlSheet->colBreaks->brk) {
+ $this->columnBreaks($xmlSheet, $worksheet);
+ }
+ }
+
+ private function rowBreaks(SimpleXMLElement $xmlSheet, Worksheet $worksheet): void
+ {
+ foreach ($xmlSheet->rowBreaks->brk as $brk) {
+ if ($brk['man']) {
+ $worksheet->setBreak("A{$brk['id']}", Worksheet::BREAK_ROW);
+ }
+ }
+ }
+
+ private function columnBreaks(SimpleXMLElement $xmlSheet, Worksheet $worksheet): void
+ {
+ foreach ($xmlSheet->colBreaks->brk as $brk) {
+ if ($brk['man']) {
+ $worksheet->setBreak(
+ Coordinate::stringFromColumnIndex(((int) $brk['id']) + 1) . '1',
+ Worksheet::BREAK_COLUMN
+ );
+ }
+ }
+ }
+}
diff --git a/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xlsx/Properties.php b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xlsx/Properties.php new file mode 100644 index 0000000..07bd076 --- /dev/null +++ b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xlsx/Properties.php @@ -0,0 +1,92 @@ +<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader\Xlsx;
+
+use PhpOffice\PhpSpreadsheet\Document\Properties as DocumentProperties;
+use PhpOffice\PhpSpreadsheet\Reader\Security\XmlScanner;
+use PhpOffice\PhpSpreadsheet\Settings;
+use SimpleXMLElement;
+
+class Properties
+{
+ private $securityScanner;
+
+ private $docProps;
+
+ public function __construct(XmlScanner $securityScanner, DocumentProperties $docProps)
+ {
+ $this->securityScanner = $securityScanner;
+ $this->docProps = $docProps;
+ }
+
+ private function extractPropertyData($propertyData)
+ {
+ return simplexml_load_string(
+ $this->securityScanner->scan($propertyData),
+ 'SimpleXMLElement',
+ Settings::getLibXmlLoaderOptions()
+ );
+ }
+
+ public function readCoreProperties($propertyData): void
+ {
+ $xmlCore = $this->extractPropertyData($propertyData);
+
+ 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');
+
+ $this->docProps->setCreator((string) self::getArrayItem($xmlCore->xpath('dc:creator')));
+ $this->docProps->setLastModifiedBy((string) self::getArrayItem($xmlCore->xpath('cp:lastModifiedBy')));
+ $this->docProps->setCreated(strtotime(self::getArrayItem($xmlCore->xpath('dcterms:created')))); //! respect xsi:type
+ $this->docProps->setModified(strtotime(self::getArrayItem($xmlCore->xpath('dcterms:modified')))); //! respect xsi:type
+ $this->docProps->setTitle((string) self::getArrayItem($xmlCore->xpath('dc:title')));
+ $this->docProps->setDescription((string) self::getArrayItem($xmlCore->xpath('dc:description')));
+ $this->docProps->setSubject((string) self::getArrayItem($xmlCore->xpath('dc:subject')));
+ $this->docProps->setKeywords((string) self::getArrayItem($xmlCore->xpath('cp:keywords')));
+ $this->docProps->setCategory((string) self::getArrayItem($xmlCore->xpath('cp:category')));
+ }
+ }
+
+ public function readExtendedProperties($propertyData): void
+ {
+ $xmlCore = $this->extractPropertyData($propertyData);
+
+ if (is_object($xmlCore)) {
+ if (isset($xmlCore->Company)) {
+ $this->docProps->setCompany((string) $xmlCore->Company);
+ }
+ if (isset($xmlCore->Manager)) {
+ $this->docProps->setManager((string) $xmlCore->Manager);
+ }
+ }
+ }
+
+ public function readCustomProperties($propertyData): void
+ {
+ $xmlCore = $this->extractPropertyData($propertyData);
+
+ if (is_object($xmlCore)) {
+ foreach ($xmlCore as $xmlProperty) {
+ /** @var SimpleXMLElement $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 = DocumentProperties::convertProperty($attributeValue, $attributeType);
+ $attributeType = DocumentProperties::convertPropertyType($attributeType);
+ $this->docProps->setCustomProperty($propertyName, $attributeValue, $attributeType);
+ }
+ }
+ }
+ }
+
+ private static function getArrayItem(array $array, $key = 0)
+ {
+ return $array[$key] ?? null;
+ }
+}
diff --git a/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xlsx/SheetViewOptions.php b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xlsx/SheetViewOptions.php new file mode 100644 index 0000000..491d7d3 --- /dev/null +++ b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xlsx/SheetViewOptions.php @@ -0,0 +1,135 @@ +<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader\Xlsx;
+
+use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
+use SimpleXMLElement;
+
+class SheetViewOptions extends BaseParserClass
+{
+ private $worksheet;
+
+ private $worksheetXml;
+
+ public function __construct(Worksheet $workSheet, ?SimpleXMLElement $worksheetXml = null)
+ {
+ $this->worksheet = $workSheet;
+ $this->worksheetXml = $worksheetXml;
+ }
+
+ /**
+ * @param bool $readDataOnly
+ */
+ public function load($readDataOnly = false): void
+ {
+ if ($this->worksheetXml === null) {
+ return;
+ }
+
+ if (isset($this->worksheetXml->sheetPr)) {
+ $this->tabColor($this->worksheetXml->sheetPr);
+ $this->codeName($this->worksheetXml->sheetPr);
+ $this->outlines($this->worksheetXml->sheetPr);
+ $this->pageSetup($this->worksheetXml->sheetPr);
+ }
+
+ if (isset($this->worksheetXml->sheetFormatPr)) {
+ $this->sheetFormat($this->worksheetXml->sheetFormatPr);
+ }
+
+ if (!$readDataOnly && isset($this->worksheetXml->printOptions)) {
+ $this->printOptions($this->worksheetXml->printOptions);
+ }
+ }
+
+ private function tabColor(SimpleXMLElement $sheetPr): void
+ {
+ if (isset($sheetPr->tabColor, $sheetPr->tabColor['rgb'])) {
+ $this->worksheet->getTabColor()->setARGB((string) $sheetPr->tabColor['rgb']);
+ }
+ }
+
+ private function codeName(SimpleXMLElement $sheetPr): void
+ {
+ if (isset($sheetPr['codeName'])) {
+ $this->worksheet->setCodeName((string) $sheetPr['codeName'], false);
+ }
+ }
+
+ private function outlines(SimpleXMLElement $sheetPr): void
+ {
+ if (isset($sheetPr->outlinePr)) {
+ if (
+ isset($sheetPr->outlinePr['summaryRight']) &&
+ !self::boolean((string) $sheetPr->outlinePr['summaryRight'])
+ ) {
+ $this->worksheet->setShowSummaryRight(false);
+ } else {
+ $this->worksheet->setShowSummaryRight(true);
+ }
+
+ if (
+ isset($sheetPr->outlinePr['summaryBelow']) &&
+ !self::boolean((string) $sheetPr->outlinePr['summaryBelow'])
+ ) {
+ $this->worksheet->setShowSummaryBelow(false);
+ } else {
+ $this->worksheet->setShowSummaryBelow(true);
+ }
+ }
+ }
+
+ private function pageSetup(SimpleXMLElement $sheetPr): void
+ {
+ if (isset($sheetPr->pageSetUpPr)) {
+ if (
+ isset($sheetPr->pageSetUpPr['fitToPage']) &&
+ !self::boolean((string) $sheetPr->pageSetUpPr['fitToPage'])
+ ) {
+ $this->worksheet->getPageSetup()->setFitToPage(false);
+ } else {
+ $this->worksheet->getPageSetup()->setFitToPage(true);
+ }
+ }
+ }
+
+ private function sheetFormat(SimpleXMLElement $sheetFormatPr): void
+ {
+ if (
+ isset($sheetFormatPr['customHeight']) &&
+ self::boolean((string) $sheetFormatPr['customHeight']) &&
+ isset($sheetFormatPr['defaultRowHeight'])
+ ) {
+ $this->worksheet->getDefaultRowDimension()
+ ->setRowHeight((float) $sheetFormatPr['defaultRowHeight']);
+ }
+
+ if (isset($sheetFormatPr['defaultColWidth'])) {
+ $this->worksheet->getDefaultColumnDimension()
+ ->setWidth((float) $sheetFormatPr['defaultColWidth']);
+ }
+
+ if (
+ isset($sheetFormatPr['zeroHeight']) &&
+ ((string) $sheetFormatPr['zeroHeight'] === '1')
+ ) {
+ $this->worksheet->getDefaultRowDimension()->setZeroHeight(true);
+ }
+ }
+
+ private function printOptions(SimpleXMLElement $printOptions): void
+ {
+ if (self::boolean((string) $printOptions['gridLinesSet'])) {
+ $this->worksheet->setShowGridlines(true);
+ }
+ if (self::boolean((string) $printOptions['gridLines'])) {
+ $this->worksheet->setPrintGridlines(true);
+ }
+ if (self::boolean((string) $printOptions['horizontalCentered'])) {
+ $this->worksheet->getPageSetup()->setHorizontalCentered(true);
+ }
+ if (self::boolean((string) $printOptions['verticalCentered'])) {
+ $this->worksheet->getPageSetup()->setVerticalCentered(true);
+ }
+ }
+}
diff --git a/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xlsx/SheetViews.php b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xlsx/SheetViews.php new file mode 100644 index 0000000..3ae65bc --- /dev/null +++ b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xlsx/SheetViews.php @@ -0,0 +1,138 @@ +<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader\Xlsx;
+
+use PhpOffice\PhpSpreadsheet\Cell\Coordinate;
+use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
+use SimpleXMLElement;
+
+class SheetViews extends BaseParserClass
+{
+ private $sheetViewXml;
+
+ private $worksheet;
+
+ public function __construct(SimpleXMLElement $sheetViewXml, Worksheet $workSheet)
+ {
+ $this->sheetViewXml = $sheetViewXml;
+ $this->worksheet = $workSheet;
+ }
+
+ public function load(): void
+ {
+ $this->zoomScale();
+ $this->view();
+ $this->gridLines();
+ $this->headers();
+ $this->direction();
+ $this->showZeros();
+
+ if (isset($this->sheetViewXml->pane)) {
+ $this->pane();
+ }
+ if (isset($this->sheetViewXml->selection, $this->sheetViewXml->selection['sqref'])) {
+ $this->selection();
+ }
+ }
+
+ private function zoomScale(): void
+ {
+ if (isset($this->sheetViewXml['zoomScale'])) {
+ $zoomScale = (int) ($this->sheetViewXml['zoomScale']);
+ if ($zoomScale <= 0) {
+ // setZoomScale will throw an Exception if the scale is less than or equals 0
+ // that is OK when manually creating documents, but we should be able to read all documents
+ $zoomScale = 100;
+ }
+
+ $this->worksheet->getSheetView()->setZoomScale($zoomScale);
+ }
+
+ if (isset($this->sheetViewXml['zoomScaleNormal'])) {
+ $zoomScaleNormal = (int) ($this->sheetViewXml['zoomScaleNormal']);
+ if ($zoomScaleNormal <= 0) {
+ // setZoomScaleNormal will throw an Exception if the scale is less than or equals 0
+ // that is OK when manually creating documents, but we should be able to read all documents
+ $zoomScaleNormal = 100;
+ }
+
+ $this->worksheet->getSheetView()->setZoomScaleNormal($zoomScaleNormal);
+ }
+ }
+
+ private function view(): void
+ {
+ if (isset($this->sheetViewXml['view'])) {
+ $this->worksheet->getSheetView()->setView((string) $this->sheetViewXml['view']);
+ }
+ }
+
+ private function gridLines(): void
+ {
+ if (isset($this->sheetViewXml['showGridLines'])) {
+ $this->worksheet->setShowGridLines(
+ self::boolean((string) $this->sheetViewXml['showGridLines'])
+ );
+ }
+ }
+
+ private function headers(): void
+ {
+ if (isset($this->sheetViewXml['showRowColHeaders'])) {
+ $this->worksheet->setShowRowColHeaders(
+ self::boolean((string) $this->sheetViewXml['showRowColHeaders'])
+ );
+ }
+ }
+
+ private function direction(): void
+ {
+ if (isset($this->sheetViewXml['rightToLeft'])) {
+ $this->worksheet->setRightToLeft(
+ self::boolean((string) $this->sheetViewXml['rightToLeft'])
+ );
+ }
+ }
+
+ private function showZeros(): void
+ {
+ if (isset($this->sheetViewXml['showZeros'])) {
+ $this->worksheet->getSheetView()->setShowZeros(
+ self::boolean((string) $this->sheetViewXml['showZeros'])
+ );
+ }
+ }
+
+ private function pane(): void
+ {
+ $xSplit = 0;
+ $ySplit = 0;
+ $topLeftCell = null;
+
+ if (isset($this->sheetViewXml->pane['xSplit'])) {
+ $xSplit = (int) ($this->sheetViewXml->pane['xSplit']);
+ }
+
+ if (isset($this->sheetViewXml->pane['ySplit'])) {
+ $ySplit = (int) ($this->sheetViewXml->pane['ySplit']);
+ }
+
+ if (isset($this->sheetViewXml->pane['topLeftCell'])) {
+ $topLeftCell = (string) $this->sheetViewXml->pane['topLeftCell'];
+ }
+
+ $this->worksheet->freezePane(
+ Coordinate::stringFromColumnIndex($xSplit + 1) . ($ySplit + 1),
+ $topLeftCell
+ );
+ }
+
+ private function selection(): void
+ {
+ $sqref = (string) $this->sheetViewXml->selection['sqref'];
+ $sqref = explode(' ', $sqref);
+ $sqref = $sqref[0];
+
+ $this->worksheet->setSelectedCells($sqref);
+ }
+}
diff --git a/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xlsx/Styles.php b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xlsx/Styles.php new file mode 100644 index 0000000..9ff4a13 --- /dev/null +++ b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xlsx/Styles.php @@ -0,0 +1,282 @@ +<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader\Xlsx;
+
+use PhpOffice\PhpSpreadsheet\Style\Alignment;
+use PhpOffice\PhpSpreadsheet\Style\Border;
+use PhpOffice\PhpSpreadsheet\Style\Borders;
+use PhpOffice\PhpSpreadsheet\Style\Color;
+use PhpOffice\PhpSpreadsheet\Style\Fill;
+use PhpOffice\PhpSpreadsheet\Style\Font;
+use PhpOffice\PhpSpreadsheet\Style\NumberFormat;
+use PhpOffice\PhpSpreadsheet\Style\Protection;
+use PhpOffice\PhpSpreadsheet\Style\Style;
+use SimpleXMLElement;
+
+class Styles extends BaseParserClass
+{
+ /**
+ * Theme instance.
+ *
+ * @var Theme
+ */
+ private static $theme = null;
+
+ private $styles = [];
+
+ private $cellStyles = [];
+
+ private $styleXml;
+
+ public function __construct(SimpleXMLElement $styleXml)
+ {
+ $this->styleXml = $styleXml;
+ }
+
+ public function setStyleBaseData(?Theme $theme = null, $styles = [], $cellStyles = []): void
+ {
+ self::$theme = $theme;
+ $this->styles = $styles;
+ $this->cellStyles = $cellStyles;
+ }
+
+ private static function readFontStyle(Font $fontStyle, SimpleXMLElement $fontStyleXml): void
+ {
+ $fontStyle->setName((string) $fontStyleXml->name['val']);
+ $fontStyle->setSize((float) $fontStyleXml->sz['val']);
+
+ if (isset($fontStyleXml->b)) {
+ $fontStyle->setBold(!isset($fontStyleXml->b['val']) || self::boolean((string) $fontStyleXml->b['val']));
+ }
+ if (isset($fontStyleXml->i)) {
+ $fontStyle->setItalic(!isset($fontStyleXml->i['val']) || self::boolean((string) $fontStyleXml->i['val']));
+ }
+ if (isset($fontStyleXml->strike)) {
+ $fontStyle->setStrikethrough(!isset($fontStyleXml->strike['val']) || self::boolean((string) $fontStyleXml->strike['val']));
+ }
+ $fontStyle->getColor()->setARGB(self::readColor($fontStyleXml->color));
+
+ if (isset($fontStyleXml->u) && !isset($fontStyleXml->u['val'])) {
+ $fontStyle->setUnderline(Font::UNDERLINE_SINGLE);
+ } elseif (isset($fontStyleXml->u, $fontStyleXml->u['val'])) {
+ $fontStyle->setUnderline((string) $fontStyleXml->u['val']);
+ }
+
+ if (isset($fontStyleXml->vertAlign, $fontStyleXml->vertAlign['val'])) {
+ $verticalAlign = strtolower((string) $fontStyleXml->vertAlign['val']);
+ if ($verticalAlign === 'superscript') {
+ $fontStyle->setSuperscript(true);
+ }
+ if ($verticalAlign === 'subscript') {
+ $fontStyle->setSubscript(true);
+ }
+ }
+ }
+
+ private static function readNumberFormat(NumberFormat $numfmtStyle, SimpleXMLElement $numfmtStyleXml): void
+ {
+ if ($numfmtStyleXml->count() === 0) {
+ return;
+ }
+ $numfmt = $numfmtStyleXml->attributes();
+ if ($numfmt->count() > 0 && isset($numfmt['formatCode'])) {
+ $numfmtStyle->setFormatCode((string) $numfmt['formatCode']);
+ }
+ }
+
+ private static function readFillStyle(Fill $fillStyle, SimpleXMLElement $fillStyleXml): void
+ {
+ if ($fillStyleXml->gradientFill) {
+ /** @var SimpleXMLElement $gradientFill */
+ $gradientFill = $fillStyleXml->gradientFill[0];
+ if (!empty($gradientFill['type'])) {
+ $fillStyle->setFillType((string) $gradientFill['type']);
+ }
+ $fillStyle->setRotation((float) ($gradientFill['degree']));
+ $gradientFill->registerXPathNamespace('sml', 'http://schemas.openxmlformats.org/spreadsheetml/2006/main');
+ $fillStyle->getStartColor()->setARGB(self::readColor(self::getArrayItem($gradientFill->xpath('sml:stop[@position=0]'))->color));
+ $fillStyle->getEndColor()->setARGB(self::readColor(self::getArrayItem($gradientFill->xpath('sml:stop[@position=1]'))->color));
+ } elseif ($fillStyleXml->patternFill) {
+ $patternType = (string) $fillStyleXml->patternFill['patternType'] != '' ? (string) $fillStyleXml->patternFill['patternType'] : 'solid';
+ $fillStyle->setFillType($patternType);
+ if ($fillStyleXml->patternFill->fgColor) {
+ $fillStyle->getStartColor()->setARGB(self::readColor($fillStyleXml->patternFill->fgColor, true));
+ } else {
+ $fillStyle->getStartColor()->setARGB('FF000000');
+ }
+ if ($fillStyleXml->patternFill->bgColor) {
+ $fillStyle->getEndColor()->setARGB(self::readColor($fillStyleXml->patternFill->bgColor, true));
+ }
+ }
+ }
+
+ private static function readBorderStyle(Borders $borderStyle, SimpleXMLElement $borderStyleXml): void
+ {
+ $diagonalUp = self::boolean((string) $borderStyleXml['diagonalUp']);
+ $diagonalDown = self::boolean((string) $borderStyleXml['diagonalDown']);
+ if (!$diagonalUp && !$diagonalDown) {
+ $borderStyle->setDiagonalDirection(Borders::DIAGONAL_NONE);
+ } elseif ($diagonalUp && !$diagonalDown) {
+ $borderStyle->setDiagonalDirection(Borders::DIAGONAL_UP);
+ } elseif (!$diagonalUp && $diagonalDown) {
+ $borderStyle->setDiagonalDirection(Borders::DIAGONAL_DOWN);
+ } else {
+ $borderStyle->setDiagonalDirection(Borders::DIAGONAL_BOTH);
+ }
+
+ self::readBorder($borderStyle->getLeft(), $borderStyleXml->left);
+ self::readBorder($borderStyle->getRight(), $borderStyleXml->right);
+ self::readBorder($borderStyle->getTop(), $borderStyleXml->top);
+ self::readBorder($borderStyle->getBottom(), $borderStyleXml->bottom);
+ self::readBorder($borderStyle->getDiagonal(), $borderStyleXml->diagonal);
+ }
+
+ private static function readBorder(Border $border, SimpleXMLElement $borderXml): void
+ {
+ if (isset($borderXml['style'])) {
+ $border->setBorderStyle((string) $borderXml['style']);
+ }
+ if (isset($borderXml->color)) {
+ $border->getColor()->setARGB(self::readColor($borderXml->color));
+ }
+ }
+
+ private static function readAlignmentStyle(Alignment $alignment, SimpleXMLElement $alignmentXml): void
+ {
+ $alignment->setHorizontal((string) $alignmentXml->alignment['horizontal']);
+ $alignment->setVertical((string) $alignmentXml->alignment['vertical']);
+
+ $textRotation = 0;
+ if ((int) $alignmentXml->alignment['textRotation'] <= 90) {
+ $textRotation = (int) $alignmentXml->alignment['textRotation'];
+ } elseif ((int) $alignmentXml->alignment['textRotation'] > 90) {
+ $textRotation = 90 - (int) $alignmentXml->alignment['textRotation'];
+ }
+
+ $alignment->setTextRotation((int) $textRotation);
+ $alignment->setWrapText(self::boolean((string) $alignmentXml->alignment['wrapText']));
+ $alignment->setShrinkToFit(self::boolean((string) $alignmentXml->alignment['shrinkToFit']));
+ $alignment->setIndent((int) ((string) $alignmentXml->alignment['indent']) > 0 ? (int) ((string) $alignmentXml->alignment['indent']) : 0);
+ $alignment->setReadOrder((int) ((string) $alignmentXml->alignment['readingOrder']) > 0 ? (int) ((string) $alignmentXml->alignment['readingOrder']) : 0);
+ }
+
+ private function readStyle(Style $docStyle, $style): void
+ {
+ if ($style->numFmt instanceof SimpleXMLElement) {
+ self::readNumberFormat($docStyle->getNumberFormat(), $style->numFmt);
+ } else {
+ $docStyle->getNumberFormat()->setFormatCode($style->numFmt);
+ }
+
+ if (isset($style->font)) {
+ self::readFontStyle($docStyle->getFont(), $style->font);
+ }
+
+ if (isset($style->fill)) {
+ self::readFillStyle($docStyle->getFill(), $style->fill);
+ }
+
+ if (isset($style->border)) {
+ self::readBorderStyle($docStyle->getBorders(), $style->border);
+ }
+
+ if (isset($style->alignment->alignment)) {
+ self::readAlignmentStyle($docStyle->getAlignment(), $style->alignment);
+ }
+
+ // protection
+ if (isset($style->protection)) {
+ $this->readProtectionLocked($docStyle, $style);
+ $this->readProtectionHidden($docStyle, $style);
+ }
+
+ // top-level style settings
+ if (isset($style->quotePrefix)) {
+ $docStyle->setQuotePrefix(true);
+ }
+ }
+
+ private function readProtectionLocked(Style $docStyle, $style): void
+ {
+ if (isset($style->protection['locked'])) {
+ if (self::boolean((string) $style->protection['locked'])) {
+ $docStyle->getProtection()->setLocked(Protection::PROTECTION_PROTECTED);
+ } else {
+ $docStyle->getProtection()->setLocked(Protection::PROTECTION_UNPROTECTED);
+ }
+ }
+ }
+
+ private function readProtectionHidden(Style $docStyle, $style): void
+ {
+ if (isset($style->protection['hidden'])) {
+ if (self::boolean((string) $style->protection['hidden'])) {
+ $docStyle->getProtection()->setHidden(Protection::PROTECTION_PROTECTED);
+ } else {
+ $docStyle->getProtection()->setHidden(Protection::PROTECTION_UNPROTECTED);
+ }
+ }
+ }
+
+ private static function readColor($color, $background = false)
+ {
+ if (isset($color['rgb'])) {
+ return (string) $color['rgb'];
+ } elseif (isset($color['indexed'])) {
+ return Color::indexedColor($color['indexed'] - 7, $background)->getARGB();
+ } elseif (isset($color['theme'])) {
+ if (self::$theme !== null) {
+ $returnColour = self::$theme->getColourByIndex((int) $color['theme']);
+ if (isset($color['tint'])) {
+ $tintAdjust = (float) $color['tint'];
+ $returnColour = Color::changeBrightness($returnColour, $tintAdjust);
+ }
+
+ return 'FF' . $returnColour;
+ }
+ }
+
+ return ($background) ? 'FFFFFFFF' : 'FF000000';
+ }
+
+ public function dxfs($readDataOnly = false)
+ {
+ $dxfs = [];
+ if (!$readDataOnly && $this->styleXml) {
+ // Conditional Styles
+ if ($this->styleXml->dxfs) {
+ foreach ($this->styleXml->dxfs->dxf as $dxf) {
+ $style = new Style(false, true);
+ $this->readStyle($style, $dxf);
+ $dxfs[] = $style;
+ }
+ }
+ // Cell Styles
+ if ($this->styleXml->cellStyles) {
+ foreach ($this->styleXml->cellStyles->cellStyle as $cellStyle) {
+ if ((int) ($cellStyle['builtinId']) == 0) {
+ if (isset($this->cellStyles[(int) ($cellStyle['xfId'])])) {
+ // Set default style
+ $style = new Style();
+ $this->readStyle($style, $this->cellStyles[(int) ($cellStyle['xfId'])]);
+
+ // normal style, currently not using it for anything
+ }
+ }
+ }
+ }
+ }
+
+ return $dxfs;
+ }
+
+ public function styles()
+ {
+ return $this->styles;
+ }
+
+ private static function getArrayItem($array, $key = 0)
+ {
+ return $array[$key] ?? null;
+ }
+}
diff --git a/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xlsx/Theme.php b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xlsx/Theme.php new file mode 100644 index 0000000..0e062cc --- /dev/null +++ b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xlsx/Theme.php @@ -0,0 +1,93 @@ +<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader\Xlsx;
+
+class Theme
+{
+ /**
+ * Theme Name.
+ *
+ * @var string
+ */
+ private $themeName;
+
+ /**
+ * Colour Scheme Name.
+ *
+ * @var string
+ */
+ private $colourSchemeName;
+
+ /**
+ * Colour Map.
+ *
+ * @var array of string
+ */
+ private $colourMap;
+
+ /**
+ * Create a new Theme.
+ *
+ * @param mixed $themeName
+ * @param mixed $colourSchemeName
+ * @param mixed $colourMap
+ */
+ public function __construct($themeName, $colourSchemeName, $colourMap)
+ {
+ // Initialise values
+ $this->themeName = $themeName;
+ $this->colourSchemeName = $colourSchemeName;
+ $this->colourMap = $colourMap;
+ }
+
+ /**
+ * Get Theme Name.
+ *
+ * @return string
+ */
+ public function getThemeName()
+ {
+ return $this->themeName;
+ }
+
+ /**
+ * Get colour Scheme Name.
+ *
+ * @return string
+ */
+ public function getColourSchemeName()
+ {
+ return $this->colourSchemeName;
+ }
+
+ /**
+ * Get colour Map Value by Position.
+ *
+ * @param mixed $index
+ *
+ * @return string
+ */
+ public function getColourByIndex($index)
+ {
+ if (isset($this->colourMap[$index])) {
+ return $this->colourMap[$index];
+ }
+
+ return null;
+ }
+
+ /**
+ * Implement PHP __clone to create a deep clone, not just a shallow copy.
+ */
+ public function __clone()
+ {
+ $vars = get_object_vars($this);
+ foreach ($vars as $key => $value) {
+ if ((is_object($value)) && ($key != '_parent')) {
+ $this->$key = clone $value;
+ } else {
+ $this->$key = $value;
+ }
+ }
+ }
+}
diff --git a/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xml.php b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xml.php new file mode 100644 index 0000000..5f909d0 --- /dev/null +++ b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xml.php @@ -0,0 +1,897 @@ +<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader;
+
+use PhpOffice\PhpSpreadsheet\Cell\AddressHelper;
+use PhpOffice\PhpSpreadsheet\Cell\Coordinate;
+use PhpOffice\PhpSpreadsheet\Cell\DataType;
+use PhpOffice\PhpSpreadsheet\DefinedName;
+use PhpOffice\PhpSpreadsheet\Document\Properties;
+use PhpOffice\PhpSpreadsheet\Reader\Security\XmlScanner;
+use PhpOffice\PhpSpreadsheet\Reader\Xml\PageSettings;
+use PhpOffice\PhpSpreadsheet\RichText\RichText;
+use PhpOffice\PhpSpreadsheet\Settings;
+use PhpOffice\PhpSpreadsheet\Shared\Date;
+use PhpOffice\PhpSpreadsheet\Shared\File;
+use PhpOffice\PhpSpreadsheet\Shared\StringHelper;
+use PhpOffice\PhpSpreadsheet\Spreadsheet;
+use PhpOffice\PhpSpreadsheet\Style\Alignment;
+use PhpOffice\PhpSpreadsheet\Style\Border;
+use PhpOffice\PhpSpreadsheet\Style\Borders;
+use PhpOffice\PhpSpreadsheet\Style\Fill;
+use PhpOffice\PhpSpreadsheet\Style\Font;
+use SimpleXMLElement;
+
+/**
+ * Reader for SpreadsheetML, the XML schema for Microsoft Office Excel 2003.
+ */
+class Xml extends BaseReader
+{
+ /**
+ * Formats.
+ *
+ * @var array
+ */
+ protected $styles = [];
+
+ /**
+ * Create a new Excel2003XML Reader instance.
+ */
+ public function __construct()
+ {
+ parent::__construct();
+ $this->securityScanner = XmlScanner::getInstance($this);
+ }
+
+ private $fileContents = '';
+
+ private static $mappings = [
+ 'borderStyle' => [
+ '1continuous' => Border::BORDER_THIN,
+ '1dash' => Border::BORDER_DASHED,
+ '1dashdot' => Border::BORDER_DASHDOT,
+ '1dashdotdot' => Border::BORDER_DASHDOTDOT,
+ '1dot' => Border::BORDER_DOTTED,
+ '1double' => Border::BORDER_DOUBLE,
+ '2continuous' => Border::BORDER_MEDIUM,
+ '2dash' => Border::BORDER_MEDIUMDASHED,
+ '2dashdot' => Border::BORDER_MEDIUMDASHDOT,
+ '2dashdotdot' => Border::BORDER_MEDIUMDASHDOTDOT,
+ '2dot' => Border::BORDER_DOTTED,
+ '2double' => Border::BORDER_DOUBLE,
+ '3continuous' => Border::BORDER_THICK,
+ '3dash' => Border::BORDER_MEDIUMDASHED,
+ '3dashdot' => Border::BORDER_MEDIUMDASHDOT,
+ '3dashdotdot' => Border::BORDER_MEDIUMDASHDOTDOT,
+ '3dot' => Border::BORDER_DOTTED,
+ '3double' => Border::BORDER_DOUBLE,
+ ],
+ 'fillType' => [
+ 'solid' => Fill::FILL_SOLID,
+ 'gray75' => Fill::FILL_PATTERN_DARKGRAY,
+ 'gray50' => Fill::FILL_PATTERN_MEDIUMGRAY,
+ 'gray25' => Fill::FILL_PATTERN_LIGHTGRAY,
+ 'gray125' => Fill::FILL_PATTERN_GRAY125,
+ 'gray0625' => Fill::FILL_PATTERN_GRAY0625,
+ 'horzstripe' => Fill::FILL_PATTERN_DARKHORIZONTAL, // horizontal stripe
+ 'vertstripe' => Fill::FILL_PATTERN_DARKVERTICAL, // vertical stripe
+ 'reversediagstripe' => Fill::FILL_PATTERN_DARKUP, // reverse diagonal stripe
+ 'diagstripe' => Fill::FILL_PATTERN_DARKDOWN, // diagonal stripe
+ 'diagcross' => Fill::FILL_PATTERN_DARKGRID, // diagoanl crosshatch
+ 'thickdiagcross' => Fill::FILL_PATTERN_DARKTRELLIS, // thick diagonal crosshatch
+ 'thinhorzstripe' => Fill::FILL_PATTERN_LIGHTHORIZONTAL,
+ 'thinvertstripe' => Fill::FILL_PATTERN_LIGHTVERTICAL,
+ 'thinreversediagstripe' => Fill::FILL_PATTERN_LIGHTUP,
+ 'thindiagstripe' => Fill::FILL_PATTERN_LIGHTDOWN,
+ 'thinhorzcross' => Fill::FILL_PATTERN_LIGHTGRID, // thin horizontal crosshatch
+ 'thindiagcross' => Fill::FILL_PATTERN_LIGHTTRELLIS, // thin diagonal crosshatch
+ ],
+ ];
+
+ public static function xmlMappings(): array
+ {
+ return self::$mappings;
+ }
+
+ /**
+ * Can the current IReader read the file?
+ *
+ * @param string $pFilename
+ *
+ * @return bool
+ */
+ public function canRead($pFilename)
+ {
+ // Office xmlns:o="urn:schemas-microsoft-com:office:office"
+ // Excel xmlns:x="urn:schemas-microsoft-com:office:excel"
+ // XML Spreadsheet xmlns:ss="urn:schemas-microsoft-com:office:spreadsheet"
+ // Spreadsheet component xmlns:c="urn:schemas-microsoft-com:office:component:spreadsheet"
+ // XML schema xmlns:s="uuid:BDC6E3F0-6DA3-11d1-A2A3-00AA00C14882"
+ // XML data type xmlns:dt="uuid:C2F41010-65B3-11d1-A29F-00AA00C14882"
+ // MS-persist recordset xmlns:rs="urn:schemas-microsoft-com:rowset"
+ // Rowset xmlns:z="#RowsetSchema"
+ //
+
+ $signature = [
+ '<?xml version="1.0"',
+ '<?mso-application progid="Excel.Sheet"?>',
+ ];
+
+ // Open file
+ $data = file_get_contents($pFilename);
+
+ // Why?
+ //$data = str_replace("'", '"', $data); // fix headers with single quote
+
+ $valid = true;
+ foreach ($signature as $match) {
+ // every part of the signature must be present
+ if (strpos($data, $match) === false) {
+ $valid = false;
+
+ break;
+ }
+ }
+
+ // Retrieve charset encoding
+ if (preg_match('/<?xml.*encoding=[\'"](.*?)[\'"].*?>/m', $data, $matches)) {
+ $charSet = strtoupper($matches[1]);
+ if (1 == preg_match('/^ISO-8859-\d[\dL]?$/i', $charSet)) {
+ $data = StringHelper::convertEncoding($data, 'UTF-8', $charSet);
+ $data = preg_replace('/(<?xml.*encoding=[\'"]).*?([\'"].*?>)/um', '$1' . 'UTF-8' . '$2', $data, 1);
+ }
+ }
+ $this->fileContents = $data;
+
+ return $valid;
+ }
+
+ /**
+ * Check if the file is a valid SimpleXML.
+ *
+ * @param string $pFilename
+ *
+ * @return false|SimpleXMLElement
+ */
+ public function trySimpleXMLLoadString($pFilename)
+ {
+ try {
+ $xml = simplexml_load_string(
+ $this->securityScanner->scan($this->fileContents ?: file_get_contents($pFilename)),
+ 'SimpleXMLElement',
+ Settings::getLibXmlLoaderOptions()
+ );
+ } catch (\Exception $e) {
+ throw new Exception('Cannot load invalid XML file: ' . $pFilename, 0, $e);
+ }
+ $this->fileContents = '';
+
+ return $xml;
+ }
+
+ /**
+ * Reads names of the worksheets from a file, without parsing the whole file to a Spreadsheet object.
+ *
+ * @param string $pFilename
+ *
+ * @return array
+ */
+ public function listWorksheetNames($pFilename)
+ {
+ File::assertFile($pFilename);
+ if (!$this->canRead($pFilename)) {
+ throw new Exception($pFilename . ' is an Invalid Spreadsheet file.');
+ }
+
+ $worksheetNames = [];
+
+ $xml = $this->trySimpleXMLLoadString($pFilename);
+
+ $namespaces = $xml->getNamespaces(true);
+
+ $xml_ss = $xml->children($namespaces['ss']);
+ foreach ($xml_ss->Worksheet as $worksheet) {
+ $worksheet_ss = $worksheet->attributes($namespaces['ss']);
+ $worksheetNames[] = (string) $worksheet_ss['Name'];
+ }
+
+ return $worksheetNames;
+ }
+
+ /**
+ * Return worksheet info (Name, Last Column Letter, Last Column Index, Total Rows, Total Columns).
+ *
+ * @param string $pFilename
+ *
+ * @return array
+ */
+ public function listWorksheetInfo($pFilename)
+ {
+ File::assertFile($pFilename);
+ if (!$this->canRead($pFilename)) {
+ throw new Exception($pFilename . ' is an Invalid Spreadsheet file.');
+ }
+
+ $worksheetInfo = [];
+
+ $xml = $this->trySimpleXMLLoadString($pFilename);
+
+ $namespaces = $xml->getNamespaces(true);
+
+ $worksheetID = 1;
+ $xml_ss = $xml->children($namespaces['ss']);
+ foreach ($xml_ss->Worksheet as $worksheet) {
+ $worksheet_ss = $worksheet->attributes($namespaces['ss']);
+
+ $tmpInfo = [];
+ $tmpInfo['worksheetName'] = '';
+ $tmpInfo['lastColumnLetter'] = 'A';
+ $tmpInfo['lastColumnIndex'] = 0;
+ $tmpInfo['totalRows'] = 0;
+ $tmpInfo['totalColumns'] = 0;
+
+ $tmpInfo['worksheetName'] = "Worksheet_{$worksheetID}";
+ if (isset($worksheet_ss['Name'])) {
+ $tmpInfo['worksheetName'] = (string) $worksheet_ss['Name'];
+ }
+
+ if (isset($worksheet->Table->Row)) {
+ $rowIndex = 0;
+
+ foreach ($worksheet->Table->Row as $rowData) {
+ $columnIndex = 0;
+ $rowHasData = false;
+
+ foreach ($rowData->Cell as $cell) {
+ if (isset($cell->Data)) {
+ $tmpInfo['lastColumnIndex'] = max($tmpInfo['lastColumnIndex'], $columnIndex);
+ $rowHasData = true;
+ }
+
+ ++$columnIndex;
+ }
+
+ ++$rowIndex;
+
+ if ($rowHasData) {
+ $tmpInfo['totalRows'] = max($tmpInfo['totalRows'], $rowIndex);
+ }
+ }
+ }
+
+ $tmpInfo['lastColumnLetter'] = Coordinate::stringFromColumnIndex($tmpInfo['lastColumnIndex'] + 1);
+ $tmpInfo['totalColumns'] = $tmpInfo['lastColumnIndex'] + 1;
+
+ $worksheetInfo[] = $tmpInfo;
+ ++$worksheetID;
+ }
+
+ return $worksheetInfo;
+ }
+
+ /**
+ * Loads Spreadsheet from file.
+ *
+ * @param string $pFilename
+ *
+ * @return Spreadsheet
+ */
+ public function load($pFilename)
+ {
+ // Create new Spreadsheet
+ $spreadsheet = new Spreadsheet();
+ $spreadsheet->removeSheetByIndex(0);
+
+ // Load into this instance
+ return $this->loadIntoExisting($pFilename, $spreadsheet);
+ }
+
+ private static function identifyFixedStyleValue($styleList, &$styleAttributeValue)
+ {
+ $returnValue = false;
+ $styleAttributeValue = strtolower($styleAttributeValue);
+ foreach ($styleList as $style) {
+ if ($styleAttributeValue == strtolower($style)) {
+ $styleAttributeValue = $style;
+ $returnValue = true;
+
+ break;
+ }
+ }
+
+ return $returnValue;
+ }
+
+ protected static function hex2str($hex)
+ {
+ return mb_chr((int) hexdec($hex[1]), 'UTF-8');
+ }
+
+ /**
+ * Loads from file into Spreadsheet instance.
+ *
+ * @param string $pFilename
+ *
+ * @return Spreadsheet
+ */
+ public function loadIntoExisting($pFilename, Spreadsheet $spreadsheet)
+ {
+ File::assertFile($pFilename);
+ if (!$this->canRead($pFilename)) {
+ throw new Exception($pFilename . ' is an Invalid Spreadsheet file.');
+ }
+
+ $xml = $this->trySimpleXMLLoadString($pFilename);
+
+ $namespaces = $xml->getNamespaces(true);
+
+ $docProps = $spreadsheet->getProperties();
+ if (isset($xml->DocumentProperties[0])) {
+ foreach ($xml->DocumentProperties[0] as $propertyName => $propertyValue) {
+ $stringValue = (string) $propertyValue;
+ switch ($propertyName) {
+ case 'Title':
+ $docProps->setTitle($stringValue);
+
+ break;
+ case 'Subject':
+ $docProps->setSubject($stringValue);
+
+ break;
+ case 'Author':
+ $docProps->setCreator($stringValue);
+
+ break;
+ case 'Created':
+ $creationDate = strtotime($stringValue);
+ $docProps->setCreated($creationDate);
+
+ break;
+ case 'LastAuthor':
+ $docProps->setLastModifiedBy($stringValue);
+
+ break;
+ case 'LastSaved':
+ $lastSaveDate = strtotime($stringValue);
+ $docProps->setModified($lastSaveDate);
+
+ break;
+ case 'Company':
+ $docProps->setCompany($stringValue);
+
+ break;
+ case 'Category':
+ $docProps->setCategory($stringValue);
+
+ break;
+ case 'Manager':
+ $docProps->setManager($stringValue);
+
+ break;
+ case 'Keywords':
+ $docProps->setKeywords($stringValue);
+
+ break;
+ case 'Description':
+ $docProps->setDescription($stringValue);
+
+ break;
+ }
+ }
+ }
+ if (isset($xml->CustomDocumentProperties)) {
+ foreach ($xml->CustomDocumentProperties[0] as $propertyName => $propertyValue) {
+ $propertyAttributes = $propertyValue->attributes($namespaces['dt']);
+ $propertyName = preg_replace_callback('/_x([0-9a-f]{4})_/i', ['self', 'hex2str'], $propertyName);
+ $propertyType = Properties::PROPERTY_TYPE_UNKNOWN;
+ switch ((string) $propertyAttributes) {
+ case 'string':
+ $propertyType = Properties::PROPERTY_TYPE_STRING;
+ $propertyValue = trim($propertyValue);
+
+ break;
+ case 'boolean':
+ $propertyType = Properties::PROPERTY_TYPE_BOOLEAN;
+ $propertyValue = (bool) $propertyValue;
+
+ break;
+ case 'integer':
+ $propertyType = Properties::PROPERTY_TYPE_INTEGER;
+ $propertyValue = (int) $propertyValue;
+
+ break;
+ case 'float':
+ $propertyType = Properties::PROPERTY_TYPE_FLOAT;
+ $propertyValue = (float) $propertyValue;
+
+ break;
+ case 'dateTime.tz':
+ $propertyType = Properties::PROPERTY_TYPE_DATE;
+ $propertyValue = strtotime(trim($propertyValue));
+
+ break;
+ }
+ $docProps->setCustomProperty($propertyName, $propertyValue, $propertyType);
+ }
+ }
+
+ $this->parseStyles($xml, $namespaces);
+
+ $worksheetID = 0;
+ $xml_ss = $xml->children($namespaces['ss']);
+
+ foreach ($xml_ss->Worksheet as $worksheet) {
+ $worksheet_ss = $worksheet->attributes($namespaces['ss']);
+
+ if (
+ (isset($this->loadSheetsOnly)) && (isset($worksheet_ss['Name'])) &&
+ (!in_array($worksheet_ss['Name'], $this->loadSheetsOnly))
+ ) {
+ continue;
+ }
+
+ // Create new Worksheet
+ $spreadsheet->createSheet();
+ $spreadsheet->setActiveSheetIndex($worksheetID);
+ if (isset($worksheet_ss['Name'])) {
+ $worksheetName = (string) $worksheet_ss['Name'];
+ // Use false for $updateFormulaCellReferences to prevent adjustment of worksheet references in
+ // formula cells... during the load, all formulae should be correct, and we're simply bringing
+ // the worksheet name in line with the formula, not the reverse
+ $spreadsheet->getActiveSheet()->setTitle($worksheetName, false, false);
+ }
+
+ // locally scoped defined names
+ if (isset($worksheet->Names[0])) {
+ foreach ($worksheet->Names[0] as $definedName) {
+ $definedName_ss = $definedName->attributes($namespaces['ss']);
+ $name = (string) $definedName_ss['Name'];
+ $definedValue = (string) $definedName_ss['RefersTo'];
+ $convertedValue = AddressHelper::convertFormulaToA1($definedValue);
+ if ($convertedValue[0] === '=') {
+ $convertedValue = substr($convertedValue, 1);
+ }
+ $spreadsheet->addDefinedName(DefinedName::createInstance($name, $spreadsheet->getActiveSheet(), $convertedValue, true));
+ }
+ }
+
+ $columnID = 'A';
+ if (isset($worksheet->Table->Column)) {
+ foreach ($worksheet->Table->Column as $columnData) {
+ $columnData_ss = $columnData->attributes($namespaces['ss']);
+ if (isset($columnData_ss['Index'])) {
+ $columnID = Coordinate::stringFromColumnIndex((int) $columnData_ss['Index']);
+ }
+ if (isset($columnData_ss['Width'])) {
+ $columnWidth = $columnData_ss['Width'];
+ $spreadsheet->getActiveSheet()->getColumnDimension($columnID)->setWidth($columnWidth / 5.4);
+ }
+ ++$columnID;
+ }
+ }
+
+ $rowID = 1;
+ if (isset($worksheet->Table->Row)) {
+ $additionalMergedCells = 0;
+ foreach ($worksheet->Table->Row as $rowData) {
+ $rowHasData = false;
+ $row_ss = $rowData->attributes($namespaces['ss']);
+ if (isset($row_ss['Index'])) {
+ $rowID = (int) $row_ss['Index'];
+ }
+
+ $columnID = 'A';
+ foreach ($rowData->Cell as $cell) {
+ $cell_ss = $cell->attributes($namespaces['ss']);
+ if (isset($cell_ss['Index'])) {
+ $columnID = Coordinate::stringFromColumnIndex((int) $cell_ss['Index']);
+ }
+ $cellRange = $columnID . $rowID;
+
+ if ($this->getReadFilter() !== null) {
+ if (!$this->getReadFilter()->readCell($columnID, $rowID, $worksheetName)) {
+ ++$columnID;
+
+ continue;
+ }
+ }
+
+ if (isset($cell_ss['HRef'])) {
+ $spreadsheet->getActiveSheet()->getCell($cellRange)->getHyperlink()->setUrl((string) $cell_ss['HRef']);
+ }
+
+ if ((isset($cell_ss['MergeAcross'])) || (isset($cell_ss['MergeDown']))) {
+ $columnTo = $columnID;
+ if (isset($cell_ss['MergeAcross'])) {
+ $additionalMergedCells += (int) $cell_ss['MergeAcross'];
+ $columnTo = Coordinate::stringFromColumnIndex(Coordinate::columnIndexFromString($columnID) + $cell_ss['MergeAcross']);
+ }
+ $rowTo = $rowID;
+ if (isset($cell_ss['MergeDown'])) {
+ $rowTo = $rowTo + $cell_ss['MergeDown'];
+ }
+ $cellRange .= ':' . $columnTo . $rowTo;
+ $spreadsheet->getActiveSheet()->mergeCells($cellRange);
+ }
+
+ $hasCalculatedValue = false;
+ $cellDataFormula = '';
+ if (isset($cell_ss['Formula'])) {
+ $cellDataFormula = $cell_ss['Formula'];
+ $hasCalculatedValue = true;
+ }
+ if (isset($cell->Data)) {
+ $cellData = $cell->Data;
+ $cellValue = (string) $cellData;
+ $type = DataType::TYPE_NULL;
+ $cellData_ss = $cellData->attributes($namespaces['ss']);
+ if (isset($cellData_ss['Type'])) {
+ $cellDataType = $cellData_ss['Type'];
+ switch ($cellDataType) {
+ /*
+ const TYPE_STRING = 's';
+ const TYPE_FORMULA = 'f';
+ const TYPE_NUMERIC = 'n';
+ const TYPE_BOOL = 'b';
+ const TYPE_NULL = 'null';
+ const TYPE_INLINE = 'inlineStr';
+ const TYPE_ERROR = 'e';
+ */
+ case 'String':
+ $type = DataType::TYPE_STRING;
+
+ break;
+ case 'Number':
+ $type = DataType::TYPE_NUMERIC;
+ $cellValue = (float) $cellValue;
+ if (floor($cellValue) == $cellValue) {
+ $cellValue = (int) $cellValue;
+ }
+
+ break;
+ case 'Boolean':
+ $type = DataType::TYPE_BOOL;
+ $cellValue = ($cellValue != 0);
+
+ break;
+ case 'DateTime':
+ $type = DataType::TYPE_NUMERIC;
+ $cellValue = Date::PHPToExcel(strtotime($cellValue . ' UTC'));
+
+ break;
+ case 'Error':
+ $type = DataType::TYPE_ERROR;
+ $hasCalculatedValue = false;
+
+ break;
+ }
+ }
+
+ if ($hasCalculatedValue) {
+ $type = DataType::TYPE_FORMULA;
+ $columnNumber = Coordinate::columnIndexFromString($columnID);
+ $cellDataFormula = AddressHelper::convertFormulaToA1($cellDataFormula, $rowID, $columnNumber);
+ }
+
+ $spreadsheet->getActiveSheet()->getCell($columnID . $rowID)->setValueExplicit((($hasCalculatedValue) ? $cellDataFormula : $cellValue), $type);
+ if ($hasCalculatedValue) {
+ $spreadsheet->getActiveSheet()->getCell($columnID . $rowID)->setCalculatedValue($cellValue);
+ }
+ $rowHasData = true;
+ }
+
+ if (isset($cell->Comment)) {
+ $commentAttributes = $cell->Comment->attributes($namespaces['ss']);
+ $author = 'unknown';
+ if (isset($commentAttributes->Author)) {
+ $author = (string) $commentAttributes->Author;
+ }
+ $node = $cell->Comment->Data->asXML();
+ $annotation = strip_tags($node);
+ $spreadsheet->getActiveSheet()->getComment($columnID . $rowID)->setAuthor($author)->setText($this->parseRichText($annotation));
+ }
+
+ if (isset($cell_ss['StyleID'])) {
+ $style = (string) $cell_ss['StyleID'];
+ if ((isset($this->styles[$style])) && (!empty($this->styles[$style]))) {
+ //if (!$spreadsheet->getActiveSheet()->cellExists($columnID . $rowID)) {
+ // $spreadsheet->getActiveSheet()->getCell($columnID . $rowID)->setValue(null);
+ //}
+ $spreadsheet->getActiveSheet()->getStyle($cellRange)->applyFromArray($this->styles[$style]);
+ }
+ }
+ ++$columnID;
+ while ($additionalMergedCells > 0) {
+ ++$columnID;
+ --$additionalMergedCells;
+ }
+ }
+
+ if ($rowHasData) {
+ if (isset($row_ss['Height'])) {
+ $rowHeight = $row_ss['Height'];
+ $spreadsheet->getActiveSheet()->getRowDimension($rowID)->setRowHeight($rowHeight);
+ }
+ }
+
+ ++$rowID;
+ }
+
+ $xmlX = $worksheet->children($namespaces['x']);
+ if (isset($xmlX->WorksheetOptions)) {
+ (new PageSettings($xmlX, $namespaces))->loadPageSettings($spreadsheet);
+ }
+ }
+ ++$worksheetID;
+ }
+
+ // Globally scoped defined names
+ $activeWorksheet = $spreadsheet->setActiveSheetIndex(0);
+ if (isset($xml->Names[0])) {
+ foreach ($xml->Names[0] as $definedName) {
+ $definedName_ss = $definedName->attributes($namespaces['ss']);
+ $name = (string) $definedName_ss['Name'];
+ $definedValue = (string) $definedName_ss['RefersTo'];
+ $convertedValue = AddressHelper::convertFormulaToA1($definedValue);
+ if ($convertedValue[0] === '=') {
+ $convertedValue = substr($convertedValue, 1);
+ }
+ $spreadsheet->addDefinedName(DefinedName::createInstance($name, $activeWorksheet, $convertedValue));
+ }
+ }
+
+ // Return
+ return $spreadsheet;
+ }
+
+ protected function parseRichText($is)
+ {
+ $value = new RichText();
+
+ $value->createText($is);
+
+ return $value;
+ }
+
+ private function parseStyles(SimpleXMLElement $xml, array $namespaces): void
+ {
+ if (!isset($xml->Styles)) {
+ return;
+ }
+
+ foreach ($xml->Styles[0] as $style) {
+ $style_ss = $style->attributes($namespaces['ss']);
+ $styleID = (string) $style_ss['ID'];
+ $this->styles[$styleID] = (isset($this->styles['Default'])) ? $this->styles['Default'] : [];
+ foreach ($style as $styleType => $styleData) {
+ $styleAttributes = $styleData->attributes($namespaces['ss']);
+ switch ($styleType) {
+ case 'Alignment':
+ $this->parseStyleAlignment($styleID, $styleAttributes);
+
+ break;
+ case 'Borders':
+ $this->parseStyleBorders($styleID, $styleData, $namespaces);
+
+ break;
+ case 'Font':
+ $this->parseStyleFont($styleID, $styleAttributes);
+
+ break;
+ case 'Interior':
+ $this->parseStyleInterior($styleID, $styleAttributes);
+
+ break;
+ case 'NumberFormat':
+ $this->parseStyleNumberFormat($styleID, $styleAttributes);
+
+ break;
+ }
+ }
+ }
+ }
+
+ /**
+ * @param string $styleID
+ */
+ private function parseStyleAlignment($styleID, SimpleXMLElement $styleAttributes): void
+ {
+ $verticalAlignmentStyles = [
+ Alignment::VERTICAL_BOTTOM,
+ Alignment::VERTICAL_TOP,
+ Alignment::VERTICAL_CENTER,
+ Alignment::VERTICAL_JUSTIFY,
+ ];
+ $horizontalAlignmentStyles = [
+ Alignment::HORIZONTAL_GENERAL,
+ Alignment::HORIZONTAL_LEFT,
+ Alignment::HORIZONTAL_RIGHT,
+ Alignment::HORIZONTAL_CENTER,
+ Alignment::HORIZONTAL_CENTER_CONTINUOUS,
+ Alignment::HORIZONTAL_JUSTIFY,
+ ];
+
+ foreach ($styleAttributes as $styleAttributeKey => $styleAttributeValue) {
+ $styleAttributeValue = (string) $styleAttributeValue;
+ switch ($styleAttributeKey) {
+ case 'Vertical':
+ if (self::identifyFixedStyleValue($verticalAlignmentStyles, $styleAttributeValue)) {
+ $this->styles[$styleID]['alignment']['vertical'] = $styleAttributeValue;
+ }
+
+ break;
+ case 'Horizontal':
+ if (self::identifyFixedStyleValue($horizontalAlignmentStyles, $styleAttributeValue)) {
+ $this->styles[$styleID]['alignment']['horizontal'] = $styleAttributeValue;
+ }
+
+ break;
+ case 'WrapText':
+ $this->styles[$styleID]['alignment']['wrapText'] = true;
+
+ break;
+ case 'Rotate':
+ $this->styles[$styleID]['alignment']['textRotation'] = $styleAttributeValue;
+
+ break;
+ }
+ }
+ }
+
+ private static $borderPositions = ['top', 'left', 'bottom', 'right'];
+
+ /**
+ * @param $styleID
+ */
+ private function parseStyleBorders($styleID, SimpleXMLElement $styleData, array $namespaces): void
+ {
+ $diagonalDirection = '';
+ $borderPosition = '';
+ foreach ($styleData->Border as $borderStyle) {
+ $borderAttributes = $borderStyle->attributes($namespaces['ss']);
+ $thisBorder = [];
+ $style = (string) $borderAttributes->Weight;
+ $style .= strtolower((string) $borderAttributes->LineStyle);
+ $thisBorder['borderStyle'] = self::$mappings['borderStyle'][$style] ?? Border::BORDER_NONE;
+ foreach ($borderAttributes as $borderStyleKey => $borderStyleValue) {
+ switch ($borderStyleKey) {
+ case 'Position':
+ $borderStyleValue = strtolower((string) $borderStyleValue);
+ if (in_array($borderStyleValue, self::$borderPositions)) {
+ $borderPosition = $borderStyleValue;
+ } elseif ($borderStyleValue == 'diagonalleft') {
+ $diagonalDirection = $diagonalDirection ? Borders::DIAGONAL_BOTH : Borders::DIAGONAL_DOWN;
+ } elseif ($borderStyleValue == 'diagonalright') {
+ $diagonalDirection = $diagonalDirection ? Borders::DIAGONAL_BOTH : Borders::DIAGONAL_UP;
+ }
+
+ break;
+ case 'Color':
+ $borderColour = substr($borderStyleValue, 1);
+ $thisBorder['color']['rgb'] = $borderColour;
+
+ break;
+ }
+ }
+ if ($borderPosition) {
+ $this->styles[$styleID]['borders'][$borderPosition] = $thisBorder;
+ } elseif ($diagonalDirection) {
+ $this->styles[$styleID]['borders']['diagonalDirection'] = $diagonalDirection;
+ $this->styles[$styleID]['borders']['diagonal'] = $thisBorder;
+ }
+ }
+ }
+
+ private static $underlineStyles = [
+ Font::UNDERLINE_NONE,
+ Font::UNDERLINE_DOUBLE,
+ Font::UNDERLINE_DOUBLEACCOUNTING,
+ Font::UNDERLINE_SINGLE,
+ Font::UNDERLINE_SINGLEACCOUNTING,
+ ];
+
+ private function parseStyleFontUnderline(string $styleID, string $styleAttributeValue): void
+ {
+ if (self::identifyFixedStyleValue(self::$underlineStyles, $styleAttributeValue)) {
+ $this->styles[$styleID]['font']['underline'] = $styleAttributeValue;
+ }
+ }
+
+ private function parseStyleFontVerticalAlign(string $styleID, string $styleAttributeValue): void
+ {
+ if ($styleAttributeValue == 'Superscript') {
+ $this->styles[$styleID]['font']['superscript'] = true;
+ }
+ if ($styleAttributeValue == 'Subscript') {
+ $this->styles[$styleID]['font']['subscript'] = true;
+ }
+ }
+
+ /**
+ * @param $styleID
+ */
+ private function parseStyleFont(string $styleID, SimpleXMLElement $styleAttributes): void
+ {
+ foreach ($styleAttributes as $styleAttributeKey => $styleAttributeValue) {
+ $styleAttributeValue = (string) $styleAttributeValue;
+ switch ($styleAttributeKey) {
+ case 'FontName':
+ $this->styles[$styleID]['font']['name'] = $styleAttributeValue;
+
+ break;
+ case 'Size':
+ $this->styles[$styleID]['font']['size'] = $styleAttributeValue;
+
+ break;
+ case 'Color':
+ $this->styles[$styleID]['font']['color']['rgb'] = substr($styleAttributeValue, 1);
+
+ break;
+ case 'Bold':
+ $this->styles[$styleID]['font']['bold'] = true;
+
+ break;
+ case 'Italic':
+ $this->styles[$styleID]['font']['italic'] = true;
+
+ break;
+ case 'Underline':
+ $this->parseStyleFontUnderline($styleID, $styleAttributeValue);
+
+ break;
+ case 'VerticalAlign':
+ $this->parseStyleFontVerticalAlign($styleID, $styleAttributeValue);
+
+ break;
+ }
+ }
+ }
+
+ /**
+ * @param $styleID
+ */
+ private function parseStyleInterior($styleID, SimpleXMLElement $styleAttributes): void
+ {
+ foreach ($styleAttributes as $styleAttributeKey => $styleAttributeValue) {
+ switch ($styleAttributeKey) {
+ case 'Color':
+ $this->styles[$styleID]['fill']['endColor']['rgb'] = substr($styleAttributeValue, 1);
+ $this->styles[$styleID]['fill']['startColor']['rgb'] = substr($styleAttributeValue, 1);
+
+ break;
+ case 'PatternColor':
+ $this->styles[$styleID]['fill']['startColor']['rgb'] = substr($styleAttributeValue, 1);
+
+ break;
+ case 'Pattern':
+ $lcStyleAttributeValue = strtolower((string) $styleAttributeValue);
+ $this->styles[$styleID]['fill']['fillType'] = self::$mappings['fillType'][$lcStyleAttributeValue] ?? Fill::FILL_NONE;
+
+ break;
+ }
+ }
+ }
+
+ /**
+ * @param $styleID
+ */
+ private function parseStyleNumberFormat($styleID, SimpleXMLElement $styleAttributes): void
+ {
+ $fromFormats = ['\-', '\ '];
+ $toFormats = ['-', ' '];
+
+ foreach ($styleAttributes as $styleAttributeKey => $styleAttributeValue) {
+ $styleAttributeValue = str_replace($fromFormats, $toFormats, $styleAttributeValue);
+ switch ($styleAttributeValue) {
+ case 'Short Date':
+ $styleAttributeValue = 'dd/mm/yyyy';
+
+ break;
+ }
+
+ if ($styleAttributeValue > '') {
+ $this->styles[$styleID]['numberFormat']['formatCode'] = $styleAttributeValue;
+ }
+ }
+ }
+}
diff --git a/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xml/PageSettings.php b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xml/PageSettings.php new file mode 100644 index 0000000..346440f --- /dev/null +++ b/vendor/phpoffice/phpspreadsheet/src/PhpSpreadsheet/Reader/Xml/PageSettings.php @@ -0,0 +1,130 @@ +<?php
+
+namespace PhpOffice\PhpSpreadsheet\Reader\Xml;
+
+use PhpOffice\PhpSpreadsheet\Spreadsheet;
+use PhpOffice\PhpSpreadsheet\Worksheet\PageSetup;
+use SimpleXMLElement;
+use stdClass;
+
+class PageSettings
+{
+ /**
+ * @var stdClass
+ */
+ private $printSettings;
+
+ public function __construct(SimpleXMLElement $xmlX, array $namespaces)
+ {
+ $printSettings = $this->pageSetup($xmlX, $namespaces, $this->getPrintDefaults());
+ $this->printSettings = $this->printSetup($xmlX, $printSettings);
+ }
+
+ public function loadPageSettings(Spreadsheet $spreadsheet): void
+ {
+ $spreadsheet->getActiveSheet()->getPageSetup()
+ ->setPaperSize($this->printSettings->paperSize)
+ ->setOrientation($this->printSettings->orientation)
+ ->setScale($this->printSettings->scale)
+ ->setVerticalCentered($this->printSettings->verticalCentered)
+ ->setHorizontalCentered($this->printSettings->horizontalCentered)
+ ->setPageOrder($this->printSettings->printOrder);
+ $spreadsheet->getActiveSheet()->getPageMargins()
+ ->setTop($this->printSettings->topMargin)
+ ->setHeader($this->printSettings->headerMargin)
+ ->setLeft($this->printSettings->leftMargin)
+ ->setRight($this->printSettings->rightMargin)
+ ->setBottom($this->printSettings->bottomMargin)
+ ->setFooter($this->printSettings->footerMargin);
+ }
+
+ private function getPrintDefaults(): stdClass
+ {
+ return (object) [
+ 'paperSize' => 9,
+ 'orientation' => PageSetup::ORIENTATION_DEFAULT,
+ 'scale' => 100,
+ 'horizontalCentered' => false,
+ 'verticalCentered' => false,
+ 'printOrder' => PageSetup::PAGEORDER_DOWN_THEN_OVER,
+ 'topMargin' => 0.75,
+ 'headerMargin' => 0.3,
+ 'leftMargin' => 0.7,
+ 'rightMargin' => 0.7,
+ 'bottomMargin' => 0.75,
+ 'footerMargin' => 0.3,
+ ];
+ }
+
+ private function pageSetup(SimpleXMLElement $xmlX, array $namespaces, stdClass $printDefaults): stdClass
+ {
+ if (isset($xmlX->WorksheetOptions->PageSetup)) {
+ foreach ($xmlX->WorksheetOptions->PageSetup as $pageSetupData) {
+ foreach ($pageSetupData as $pageSetupKey => $pageSetupValue) {
+ $pageSetupAttributes = $pageSetupValue->attributes($namespaces['x']);
+ switch ($pageSetupKey) {
+ case 'Layout':
+ $this->setLayout($printDefaults, $pageSetupAttributes);
+
+ break;
+ case 'Header':
+ $printDefaults->headerMargin = (float) $pageSetupAttributes->Margin ?: 1.0;
+
+ break;
+ case 'Footer':
+ $printDefaults->footerMargin = (float) $pageSetupAttributes->Margin ?: 1.0;
+
+ break;
+ case 'PageMargins':
+ $this->setMargins($printDefaults, $pageSetupAttributes);
+
+ break;
+ }
+ }
+ }
+ }
+
+ return $printDefaults;
+ }
+
+ private function printSetup(SimpleXMLElement $xmlX, stdClass $printDefaults): stdClass
+ {
+ if (isset($xmlX->WorksheetOptions->Print)) {
+ foreach ($xmlX->WorksheetOptions->Print as $printData) {
+ foreach ($printData as $printKey => $printValue) {
+ switch ($printKey) {
+ case 'LeftToRight':
+ $printDefaults->printOrder = PageSetup::PAGEORDER_OVER_THEN_DOWN;
+
+ break;
+ case 'PaperSizeIndex':
+ $printDefaults->paperSize = (int) $printValue ?: 9;
+
+ break;
+ case 'Scale':
+ $printDefaults->scale = (int) $printValue ?: 100;
+
+ break;
+ }
+ }
+ }
+ }
+
+ return $printDefaults;
+ }
+
+ private function setLayout(stdClass $printDefaults, SimpleXMLElement $pageSetupAttributes): void
+ {
+ $printDefaults->orientation = (string) strtolower($pageSetupAttributes->Orientation) ?: PageSetup::ORIENTATION_PORTRAIT;
+ $printDefaults->horizontalCentered = (bool) $pageSetupAttributes->CenterHorizontal ?: false;
+ $printDefaults->verticalCentered = (bool) $pageSetupAttributes->CenterVertical ?: false;
+ }
+
+ private function setMargins(stdClass $printDefaults, SimpleXMLElement $pageSetupAttributes): void
+ {
+ $printDefaults->leftMargin = (float) $pageSetupAttributes->Left ?: 1.0;
+ $printDefaults->rightMargin = (float) $pageSetupAttributes->Right ?: 1.0;
+ $printDefaults->topMargin = (float) $pageSetupAttributes->Top ?: 1.0;
+ $printDefaults->bottomMargin = (float) $pageSetupAttributes->Bottom ?: 1.0;
+ }
+}
|