Proyectos de Subversion Moodle

<?php

namespace PhpOffice\PhpSpreadsheet\Writer;

use HTMLPurifier;

use PhpOffice\PhpSpreadsheet\Calculation\Calculation;

use PhpOffice\PhpSpreadsheet\Cell\Cell;

use PhpOffice\PhpSpreadsheet\Cell\Coordinate;

use PhpOffice\PhpSpreadsheet\Chart\Chart;

use PhpOffice\PhpSpreadsheet\Document\Properties;

use PhpOffice\PhpSpreadsheet\RichText\RichText;

use PhpOffice\PhpSpreadsheet\RichText\Run;

use PhpOffice\PhpSpreadsheet\Settings;

use PhpOffice\PhpSpreadsheet\Shared\Date;

use PhpOffice\PhpSpreadsheet\Shared\Drawing as SharedDrawing;

use PhpOffice\PhpSpreadsheet\Shared\File;

use PhpOffice\PhpSpreadsheet\Shared\Font as SharedFont;

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 PhpOffice\PhpSpreadsheet\Style\NumberFormat;

use PhpOffice\PhpSpreadsheet\Style\Style;

use PhpOffice\PhpSpreadsheet\Worksheet\Drawing;

use PhpOffice\PhpSpreadsheet\Worksheet\MemoryDrawing;

use PhpOffice\PhpSpreadsheet\Worksheet\PageSetup;

use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;

class Html extends BaseWriter

{

    /**

     * Spreadsheet object.

     *

     * @var Spreadsheet

     */

    protected $spreadsheet;

    /**

     * Sheet index to write.

     *

     * @var null|int

     */

    private $sheetIndex = 0;

    /**

     * Images root.

     *

     * @var string

     */

    private $imagesRoot = '';

    /**

     * embed images, or link to images.

     *

     * @var bool

     */

    protected $embedImages = false;

    /**

     * Use inline CSS?

     *

     * @var bool

     */

    private $useInlineCss = false;

    /**

     * Use embedded CSS?

     *

     * @var bool

     */

    private $useEmbeddedCSS = true;

    /**

     * Array of CSS styles.

     *

     * @var array

     */

    private $cssStyles;

    /**

     * Array of column widths in points.

     *

     * @var array

     */

    private $columnWidths;

    /**

     * Default font.

     *

     * @var Font

     */

    private $defaultFont;

    /**

     * Flag whether spans have been calculated.

     *

     * @var bool

     */

    private $spansAreCalculated = false;

    /**

     * Excel cells that should not be written as HTML cells.

     *

     * @var array

     */

    private $isSpannedCell = [];

    /**

     * Excel cells that are upper-left corner in a cell merge.

     *

     * @var array

     */

    private $isBaseCell = [];

    /**

     * Excel rows that should not be written as HTML rows.

     *

     * @var array

     */

    private $isSpannedRow = [];

    /**

     * Is the current writer creating PDF?

     *

     * @var bool

     */

    protected $isPdf = false;

    /**

     * Is the current writer creating mPDF?

     *

     * @var bool

     */

    protected $isMPdf = false;

    /**

     * Generate the Navigation block.

     *

     * @var bool

     */

    private $generateSheetNavigationBlock = true;

    /**

     * Callback for editing generated html.

     *

     * @var null|callable

     */

    private $editHtmlCallback;

    /**

     * Create a new HTML.

     */

    public function __construct(Spreadsheet $spreadsheet)

    {

        $this->spreadsheet = $spreadsheet;

        $this->defaultFont = $this->spreadsheet->getDefaultStyle()->getFont();

    }

    /**

     * Save Spreadsheet to file.

     *

     * @param resource|string $filename

     */

    public function save($filename, int $flags = 0): void

    {

        $this->processFlags($flags);

        // Open file

        $this->openFileHandle($filename);

        // Write html

        fwrite($this->fileHandle, $this->generateHTMLAll());

        // Close file

        $this->maybeCloseFileHandle();

    }

    /**

     * Save Spreadsheet as html to variable.

     *

     * @return string

     */

    public function generateHtmlAll()

    {

        // garbage collect

        $this->spreadsheet->garbageCollect();

        $saveDebugLog = Calculation::getInstance($this->spreadsheet)->getDebugLog()->getWriteDebugLog();

        Calculation::getInstance($this->spreadsheet)->getDebugLog()->setWriteDebugLog(false);

        $saveArrayReturnType = Calculation::getArrayReturnType();

        Calculation::setArrayReturnType(Calculation::RETURN_ARRAY_AS_VALUE);

        // Build CSS

        $this->buildCSS(!$this->useInlineCss);

        $html = '';

        // Write headers

        $html .= $this->generateHTMLHeader(!$this->useInlineCss);

        // Write navigation (tabs)

        if ((!$this->isPdf) && ($this->generateSheetNavigationBlock)) {

            $html .= $this->generateNavigation();

        }

        // Write data

        $html .= $this->generateSheetData();

        // Write footer

        $html .= $this->generateHTMLFooter();

        $callback = $this->editHtmlCallback;

        if ($callback) {

            $html = $callback($html);

        }

        Calculation::setArrayReturnType($saveArrayReturnType);

        Calculation::getInstance($this->spreadsheet)->getDebugLog()->setWriteDebugLog($saveDebugLog);

        return $html;

    }

    /**

     * Set a callback to edit the entire HTML.

     *

     * The callback must accept the HTML as string as first parameter,

     * and it must return the edited HTML as string.

     */

    public function setEditHtmlCallback(?callable $callback): void

    {

        $this->editHtmlCallback = $callback;

    }

    /**

     * Map VAlign.

     *

     * @param string $vAlign Vertical alignment

     *

     * @return string

     */

    private function mapVAlign($vAlign)

    {

        return Alignment::VERTICAL_ALIGNMENT_FOR_HTML[$vAlign] ?? '';

    }

    /**

     * Map HAlign.

     *

     * @param string $hAlign Horizontal alignment

     *

     * @return string

     */

    private function mapHAlign($hAlign)

    {

        return Alignment::HORIZONTAL_ALIGNMENT_FOR_HTML[$hAlign] ?? '';

    }

    const BORDER_ARR = [

        Border::BORDER_NONE => 'none',

        Border::BORDER_DASHDOT => '1px dashed',

        Border::BORDER_DASHDOTDOT => '1px dotted',

        Border::BORDER_DASHED => '1px dashed',

        Border::BORDER_DOTTED => '1px dotted',

        Border::BORDER_DOUBLE => '3px double',

        Border::BORDER_HAIR => '1px solid',

        Border::BORDER_MEDIUM => '2px solid',

        Border::BORDER_MEDIUMDASHDOT => '2px dashed',

        Border::BORDER_MEDIUMDASHDOTDOT => '2px dotted',

        Border::BORDER_SLANTDASHDOT => '2px dashed',

        Border::BORDER_THICK => '3px solid',

    ];

    /**

     * Map border style.

     *

     * @param int|string $borderStyle Sheet index

     *

     * @return string

     */

    private function mapBorderStyle($borderStyle)

    {

        return array_key_exists($borderStyle, self::BORDER_ARR) ? self::BORDER_ARR[$borderStyle] : '1px solid';

    }

    /**

     * Get sheet index.

     */

    public function getSheetIndex(): ?int

    {

        return $this->sheetIndex;

    }

    /**

     * Set sheet index.

     *

     * @param int $sheetIndex Sheet index

     *

     * @return $this

     */

    public function setSheetIndex($sheetIndex)

    {

        $this->sheetIndex = $sheetIndex;

        return $this;

    }

    /**

     * Get sheet index.

     *

     * @return bool

     */

    public function getGenerateSheetNavigationBlock()

    {

        return $this->generateSheetNavigationBlock;

    }

    /**

     * Set sheet index.

     *

     * @param bool $generateSheetNavigationBlock Flag indicating whether the sheet navigation block should be generated or not

     *

     * @return $this

     */

    public function setGenerateSheetNavigationBlock($generateSheetNavigationBlock)

    {

        $this->generateSheetNavigationBlock = (bool) $generateSheetNavigationBlock;

        return $this;

    }

    /**

     * Write all sheets (resets sheetIndex to NULL).

     *

     * @return $this

     */

    public function writeAllSheets()

    {

        $this->sheetIndex = null;

        return $this;

    }

    private static function generateMeta(?string $val, string $desc): string

    {

        return ($val || $val === '0')

            ? ('      <meta name="' . $desc . '" content="' . htmlspecialchars($val, Settings::htmlEntityFlags()) . '" />' . PHP_EOL)

            : '';

    }

    public const BODY_LINE = '  <body>' . PHP_EOL;

    private const CUSTOM_TO_META = [

        Properties::PROPERTY_TYPE_BOOLEAN => 'bool',

        Properties::PROPERTY_TYPE_DATE => 'date',

        Properties::PROPERTY_TYPE_FLOAT => 'float',

        Properties::PROPERTY_TYPE_INTEGER => 'int',

        Properties::PROPERTY_TYPE_STRING => 'string',

    ];

    /**

     * Generate HTML header.

     *

     * @param bool $includeStyles Include styles?

     *

     * @return string

     */

    public function generateHTMLHeader($includeStyles = false)

    {

        // Construct HTML

        $properties = $this->spreadsheet->getProperties();

        $html = '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">' . PHP_EOL;

        $html .= '<html xmlns="http://www.w3.org/1999/xhtml">' . PHP_EOL;

        $html .= '  <head>' . PHP_EOL;

        $html .= '      <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />' . PHP_EOL;

        $html .= '      <meta name="generator" content="PhpSpreadsheet, https://github.com/PHPOffice/PhpSpreadsheet" />' . PHP_EOL;

        $html .= '      <title>' . htmlspecialchars($properties->getTitle(), Settings::htmlEntityFlags()) . '</title>' . PHP_EOL;

        $html .= self::generateMeta($properties->getCreator(), 'author');

        $html .= self::generateMeta($properties->getTitle(), 'title');

        $html .= self::generateMeta($properties->getDescription(), 'description');

        $html .= self::generateMeta($properties->getSubject(), 'subject');

        $html .= self::generateMeta($properties->getKeywords(), 'keywords');

        $html .= self::generateMeta($properties->getCategory(), 'category');

        $html .= self::generateMeta($properties->getCompany(), 'company');

        $html .= self::generateMeta($properties->getManager(), 'manager');

        $html .= self::generateMeta($properties->getLastModifiedBy(), 'lastModifiedBy');

        $date = Date::dateTimeFromTimestamp((string) $properties->getCreated());

        $date->setTimeZone(Date::getDefaultOrLocalTimeZone());

        $html .= self::generateMeta($date->format(DATE_W3C), 'created');

        $date = Date::dateTimeFromTimestamp((string) $properties->getModified());

        $date->setTimeZone(Date::getDefaultOrLocalTimeZone());

        $html .= self::generateMeta($date->format(DATE_W3C), 'modified');

        $customProperties = $properties->getCustomProperties();

        foreach ($customProperties as $customProperty) {

            $propertyValue = $properties->getCustomPropertyValue($customProperty);

            $propertyType = $properties->getCustomPropertyType($customProperty);

            $propertyQualifier = self::CUSTOM_TO_META[$propertyType] ?? null;

            if ($propertyQualifier !== null) {

                if ($propertyType === Properties::PROPERTY_TYPE_BOOLEAN) {

                    $propertyValue = $propertyValue ? '1' : '0';

                } elseif ($propertyType === Properties::PROPERTY_TYPE_DATE) {

                    $date = Date::dateTimeFromTimestamp((string) $propertyValue);

                    $date->setTimeZone(Date::getDefaultOrLocalTimeZone());

                    $propertyValue = $date->format(DATE_W3C);

                } else {

                    $propertyValue = (string) $propertyValue;

                }

                $html .= self::generateMeta($propertyValue, "custom.$propertyQualifier.$customProperty");

            }

        }

        if (!empty($properties->getHyperlinkBase())) {

            $html .= '      <base href="' . $properties->getHyperlinkBase() . '" />' . PHP_EOL;

        }

        $html .= $includeStyles ? $this->generateStyles(true) : $this->generatePageDeclarations(true);

        $html .= '  </head>' . PHP_EOL;

        $html .= '' . PHP_EOL;

        $html .= self::BODY_LINE;

        return $html;

    }

    private function generateSheetPrep(): array

    {

        // Ensure that Spans have been calculated?

        $this->calculateSpans();

        // Fetch sheets

        if ($this->sheetIndex === null) {

            $sheets = $this->spreadsheet->getAllSheets();

        } else {

            $sheets = [$this->spreadsheet->getSheet($this->sheetIndex)];

        }

        return $sheets;

    }

    private function generateSheetStarts(Worksheet $sheet, int $rowMin): array

    {

        // calculate start of <tbody>, <thead>

        $tbodyStart = $rowMin;

        $theadStart = $theadEnd = 0; // default: no <thead>    no </thead>

        if ($sheet->getPageSetup()->isRowsToRepeatAtTopSet()) {

            $rowsToRepeatAtTop = $sheet->getPageSetup()->getRowsToRepeatAtTop();

            // we can only support repeating rows that start at top row

            if ($rowsToRepeatAtTop[0] == 1) {

                $theadStart = $rowsToRepeatAtTop[0];

                $theadEnd = $rowsToRepeatAtTop[1];

                $tbodyStart = $rowsToRepeatAtTop[1] + 1;

            }

        }

        return [$theadStart, $theadEnd, $tbodyStart];

    }

    private function generateSheetTags(int $row, int $theadStart, int $theadEnd, int $tbodyStart): array

    {

        // <thead> ?

        $startTag = ($row == $theadStart) ? ('        <thead>' . PHP_EOL) : '';

        if (!$startTag) {

            $startTag = ($row == $tbodyStart) ? ('        <tbody>' . PHP_EOL) : '';

        }

        $endTag = ($row == $theadEnd) ? ('        </thead>' . PHP_EOL) : '';

        $cellType = ($row >= $tbodyStart) ? 'td' : 'th';

        return [$cellType, $startTag, $endTag];

    }

    /**

     * Generate sheet data.

     *

     * @return string

     */

    public function generateSheetData()

    {

        $sheets = $this->generateSheetPrep();

        // Construct HTML

        $html = '';

        // Loop all sheets

        $sheetId = 0;

        foreach ($sheets as $sheet) {

            // Write table header

            $html .= $this->generateTableHeader($sheet);

            // Get worksheet dimension

            [$min, $max] = explode(':', $sheet->calculateWorksheetDataDimension());

            [$minCol, $minRow] = Coordinate::indexesFromString($min);

            [$maxCol, $maxRow] = Coordinate::indexesFromString($max);

            [$theadStart, $theadEnd, $tbodyStart] = $this->generateSheetStarts($sheet, $minRow);

            // Loop through cells

            $row = $minRow - 1;

            while ($row++ < $maxRow) {

                [$cellType, $startTag, $endTag] = $this->generateSheetTags($row, $theadStart, $theadEnd, $tbodyStart);

                $html .= $startTag;

                // Write row if there are HTML table cells in it

                if (!isset($this->isSpannedRow[$sheet->getParent()->getIndex($sheet)][$row])) {

                    // Start a new rowData

                    $rowData = [];

                    // Loop through columns

                    $column = $minCol;

                    while ($column <= $maxCol) {

                        // Cell exists?

                        $cellAddress = Coordinate::stringFromColumnIndex($column) . $row;

                        $rowData[$column++] = ($sheet->getCellCollection()->has($cellAddress)) ? $cellAddress : '';

                    }

                    $html .= $this->generateRow($sheet, $rowData, $row - 1, $cellType);

                }

                $html .= $endTag;

            }

            --$row;

            $html .= $this->extendRowsForChartsAndImages($sheet, $row);

            // Write table footer

            $html .= $this->generateTableFooter();

            // Writing PDF?

            if ($this->isPdf && $this->useInlineCss) {

                if ($this->sheetIndex === null && $sheetId + 1 < $this->spreadsheet->getSheetCount()) {

                    $html .= '<div style="page-break-before:always" ></div>';

                }

            }

            // Next sheet

            ++$sheetId;

        }

        return $html;

    }

    /**

     * Generate sheet tabs.

     *

     * @return string

     */

    public function generateNavigation()

    {

        // Fetch sheets

        $sheets = [];

        if ($this->sheetIndex === null) {

            $sheets = $this->spreadsheet->getAllSheets();

        } else {

            $sheets[] = $this->spreadsheet->getSheet($this->sheetIndex);

        }

        // Construct HTML

        $html = '';

        // Only if there are more than 1 sheets

        if (count($sheets) > 1) {

            // Loop all sheets

            $sheetId = 0;

            $html .= '<ul class="navigation">' . PHP_EOL;

            foreach ($sheets as $sheet) {

                $html .= '  <li class="sheet' . $sheetId . '"><a href="#sheet' . $sheetId . '">' . $sheet->getTitle() . '</a></li>' . PHP_EOL;

                ++$sheetId;

            }

            $html .= '</ul>' . PHP_EOL;

        }

        return $html;

    }

    /**

     * Extend Row if chart is placed after nominal end of row.

     * This code should be exercised by sample:

     * Chart/32_Chart_read_write_PDF.php.

     *

     * @param int $row Row to check for charts

     *

     * @return array

     */

    private function extendRowsForCharts(Worksheet $worksheet, int $row)

    {

        $rowMax = $row;

        $colMax = 'A';

        $anyfound = false;

        if ($this->includeCharts) {

            foreach ($worksheet->getChartCollection() as $chart) {

                if ($chart instanceof Chart) {

                    $anyfound = true;

                    $chartCoordinates = $chart->getTopLeftPosition();

                    $chartTL = Coordinate::coordinateFromString($chartCoordinates['cell']);

                    $chartCol = Coordinate::columnIndexFromString($chartTL[0]);

                    if ($chartTL[1] > $rowMax) {

                        $rowMax = $chartTL[1];

                        if ($chartCol > Coordinate::columnIndexFromString($colMax)) {

                            $colMax = $chartTL[0];

                        }

                    }

                }

            }

        }

        return [$rowMax, $colMax, $anyfound];

    }

    private function extendRowsForChartsAndImages(Worksheet $worksheet, int $row): string

    {

        [$rowMax, $colMax, $anyfound] = $this->extendRowsForCharts($worksheet, $row);

        foreach ($worksheet->getDrawingCollection() as $drawing) {

            $anyfound = true;

            $imageTL = Coordinate::coordinateFromString($drawing->getCoordinates());

            $imageCol = Coordinate::columnIndexFromString($imageTL[0]);

            if ($imageTL[1] > $rowMax) {

                $rowMax = $imageTL[1];

                if ($imageCol > Coordinate::columnIndexFromString($colMax)) {

                    $colMax = $imageTL[0];

                }

            }

        }

        // Don't extend rows if not needed

        if ($row === $rowMax || !$anyfound) {

            return '';

        }

        $html = '';

        ++$colMax;

        ++$row;

        while ($row <= $rowMax) {

            $html .= '<tr>';

            for ($col = 'A'; $col != $colMax; ++$col) {

                $htmlx = $this->writeImageInCell($worksheet, $col . $row);

                $htmlx .= $this->includeCharts ? $this->writeChartInCell($worksheet, $col . $row) : '';

                if ($htmlx) {

                    $html .= "<td class='style0' style='position: relative;'>$htmlx</td>";

                } else {

                    $html .= "<td class='style0'></td>";

                }

            }

            ++$row;

            $html .= '</tr>' . PHP_EOL;

        }

        return $html;

    }

    /**

     * Convert Windows file name to file protocol URL.

     *

     * @param string $filename file name on local system

     *

     * @return string

     */

    public static function winFileToUrl($filename, bool $mpdf = false)

    {

        // Windows filename

        if (substr($filename, 1, 2) === ':\\') {

            $protocol = $mpdf ? '' : 'file:///';

            $filename = $protocol . str_replace('\\', '/', $filename);

        }

        return $filename;

    }

    /**

     * Generate image tag in cell.

     *

     * @param Worksheet $worksheet \PhpOffice\PhpSpreadsheet\Worksheet\Worksheet

     * @param string $coordinates Cell coordinates

     *

     * @return string

     */

    private function writeImageInCell(Worksheet $worksheet, $coordinates)

    {

        // Construct HTML

        $html = '';

        // Write images

        foreach ($worksheet->getDrawingCollection() as $drawing) {

            if ($drawing->getCoordinates() != $coordinates) {

                continue;

            }

            $filedesc = $drawing->getDescription();

            $filedesc = $filedesc ? htmlspecialchars($filedesc, ENT_QUOTES) : 'Embedded image';

            if ($drawing instanceof Drawing) {

                $filename = $drawing->getPath();

                // Strip off eventual '.'

                $filename = (string) preg_replace('/^[.]/', '', $filename);

                // Prepend images root

                $filename = $this->getImagesRoot() . $filename;

                // Strip off eventual '.' if followed by non-/

                $filename = (string) preg_replace('@^[.]([^/])@', '$1', $filename);

                // Convert UTF8 data to PCDATA

                $filename = htmlspecialchars($filename, Settings::htmlEntityFlags());

                $html .= PHP_EOL;

                $imageData = self::winFileToUrl($filename, $this->isMPdf);

                if ($this->embedImages || substr($imageData, 0, 6) === 'zip://') {

                    $picture = @file_get_contents($filename);

                    if ($picture !== false) {

                        $imageDetails = getimagesize($filename) ?: [];

                        // base64 encode the binary data

                        $base64 = base64_encode($picture);

                        $imageData = 'data:' . $imageDetails['mime'] . ';base64,' . $base64;

                    }

                }

                $html .= '<img style="position: absolute; z-index: 1; left: ' .

                    $drawing->getOffsetX() . 'px; top: ' . $drawing->getOffsetY() . 'px; width: ' .

                    $drawing->getWidth() . 'px; height: ' . $drawing->getHeight() . 'px;" src="' .

                    $imageData . '" alt="' . $filedesc . '" />';

            } elseif ($drawing instanceof MemoryDrawing) {

                $imageResource = $drawing->getImageResource();

                if ($imageResource) {

                    ob_start(); //  Let's start output buffering.

                    imagepng($imageResource); //  This will normally output the image, but because of ob_start(), it won't.

                    $contents = (string) ob_get_contents(); //  Instead, output above is saved to $contents

                    ob_end_clean(); //  End the output buffer.

                    $dataUri = 'data:image/png;base64,' . base64_encode($contents);

                    //  Because of the nature of tables, width is more important than height.

                    //  max-width: 100% ensures that image doesnt overflow containing cell

                    //  width: X sets width of supplied image.

                    //  As a result, images bigger than cell will be contained and images smaller will not get stretched

                    $html .= '<img alt="' . $filedesc . '" src="' . $dataUri . '" style="max-width:100%;width:' . $drawing->getWidth() . 'px;left: ' .

                    $drawing->getOffsetX() . 'px; top: ' . $drawing->getOffsetY() . 'px;position: absolute; z-index: 1;" />';

                }

            }

        }

        return $html;

    }

    /**

     * Generate chart tag in cell.

     * This code should be exercised by sample:

     * Chart/32_Chart_read_write_PDF.php.

     */

    private function writeChartInCell(Worksheet $worksheet, string $coordinates): string

    {

        // Construct HTML

        $html = '';

        // Write charts

        foreach ($worksheet->getChartCollection() as $chart) {

            if ($chart instanceof Chart) {

                $chartCoordinates = $chart->getTopLeftPosition();

                if ($chartCoordinates['cell'] == $coordinates) {

                    $chartFileName = File::sysGetTempDir() . '/' . uniqid('', true) . '.png';

                    if (!$chart->render($chartFileName)) {

                        return '';

                    }

                    $html .= PHP_EOL;

                    $imageDetails = getimagesize($chartFileName) ?: [];

                    $filedesc = $chart->getTitle();

                    $filedesc = $filedesc ? $filedesc->getCaptionText() : '';

                    $filedesc = $filedesc ? htmlspecialchars($filedesc, ENT_QUOTES) : 'Embedded chart';

                    $picture = file_get_contents($chartFileName);

                    if ($picture !== false) {

                        $base64 = base64_encode($picture);

                        $imageData = 'data:' . $imageDetails['mime'] . ';base64,' . $base64;

                        $html .= '<img style="position: absolute; z-index: 1; left: ' . $chartCoordinates['xOffset'] . 'px; top: ' . $chartCoordinates['yOffset'] . 'px; width: ' . $imageDetails[0] . 'px; height: ' . $imageDetails[1] . 'px;" src="' . $imageData . '" alt="' . $filedesc . '" />' . PHP_EOL;

                    }

                    unlink($chartFileName);

                }

            }

        }

        // Return

        return $html;

    }

    /**

     * Generate CSS styles.

     *

     * @param bool $generateSurroundingHTML Generate surrounding HTML tags? (<style> and </style>)

     *

     * @return string

     */

    public function generateStyles($generateSurroundingHTML = true)

    {

        // Build CSS

        $css = $this->buildCSS($generateSurroundingHTML);

        // Construct HTML

        $html = '';

        // Start styles

        if ($generateSurroundingHTML) {

            $html .= '    <style type="text/css">' . PHP_EOL;

            $html .= (array_key_exists('html', $css)) ? ('      html { ' . $this->assembleCSS($css['html']) . ' }' . PHP_EOL) : '';

        }

        // Write all other styles

        foreach ($css as $styleName => $styleDefinition) {

            if ($styleName != 'html') {

                $html .= '      ' . $styleName . ' { ' . $this->assembleCSS($styleDefinition) . ' }' . PHP_EOL;

            }

        }

        $html .= $this->generatePageDeclarations(false);

        // End styles

        if ($generateSurroundingHTML) {

            $html .= '    </style>' . PHP_EOL;

        }

        // Return

        return $html;

    }

    private function buildCssRowHeights(Worksheet $sheet, array &$css, int $sheetIndex): void

    {

        // Calculate row heights

        foreach ($sheet->getRowDimensions() as $rowDimension) {

            $row = $rowDimension->getRowIndex() - 1;

            // table.sheetN tr.rowYYYYYY { }

            $css['table.sheet' . $sheetIndex . ' tr.row' . $row] = [];

            if ($rowDimension->getRowHeight() != -1) {

                $pt_height = $rowDimension->getRowHeight();

                $css['table.sheet' . $sheetIndex . ' tr.row' . $row]['height'] = $pt_height . 'pt';

            }

            if ($rowDimension->getVisible() === false) {

                $css['table.sheet' . $sheetIndex . ' tr.row' . $row]['display'] = 'none';

                $css['table.sheet' . $sheetIndex . ' tr.row' . $row]['visibility'] = 'hidden';

            }

        }

    }

    private function buildCssPerSheet(Worksheet $sheet, array &$css): void

    {

        // Calculate hash code

        $sheetIndex = $sheet->getParentOrThrow()->getIndex($sheet);

        $setup = $sheet->getPageSetup();

        if ($setup->getFitToPage() && $setup->getFitToHeight() === 1) {

            $css["table.sheet$sheetIndex"]['page-break-inside'] = 'avoid';

            $css["table.sheet$sheetIndex"]['break-inside'] = 'avoid';

        }

        // Build styles

        // Calculate column widths

        $sheet->calculateColumnWidths();

        // col elements, initialize

        $highestColumnIndex = Coordinate::columnIndexFromString($sheet->getHighestColumn()) - 1;

        $column = -1;

        while ($column++ < $highestColumnIndex) {

            $this->columnWidths[$sheetIndex][$column] = 42; // approximation

            $css['table.sheet' . $sheetIndex . ' col.col' . $column]['width'] = '42pt';

        }

        // col elements, loop through columnDimensions and set width

        foreach ($sheet->getColumnDimensions() as $columnDimension) {

            $column = Coordinate::columnIndexFromString($columnDimension->getColumnIndex()) - 1;

            $width = SharedDrawing::cellDimensionToPixels($columnDimension->getWidth(), $this->defaultFont);

            $width = SharedDrawing::pixelsToPoints($width);

            if ($columnDimension->getVisible() === false) {

                $css['table.sheet' . $sheetIndex . ' .column' . $column]['display'] = 'none';

            }

            if ($width >= 0) {

                $this->columnWidths[$sheetIndex][$column] = $width;

                $css['table.sheet' . $sheetIndex . ' col.col' . $column]['width'] = $width . 'pt';

            }

        }

        // Default row height

        $rowDimension = $sheet->getDefaultRowDimension();

        // table.sheetN tr { }

        $css['table.sheet' . $sheetIndex . ' tr'] = [];

        if ($rowDimension->getRowHeight() == -1) {

            $pt_height = SharedFont::getDefaultRowHeightByFont($this->spreadsheet->getDefaultStyle()->getFont());

        } else {

            $pt_height = $rowDimension->getRowHeight();

        }

        $css['table.sheet' . $sheetIndex . ' tr']['height'] = $pt_height . 'pt';

        if ($rowDimension->getVisible() === false) {

            $css['table.sheet' . $sheetIndex . ' tr']['display'] = 'none';

            $css['table.sheet' . $sheetIndex . ' tr']['visibility'] = 'hidden';

        }

        $this->buildCssRowHeights($sheet, $css, $sheetIndex);

    }

    /**

     * Build CSS styles.

     *

     * @param bool $generateSurroundingHTML Generate surrounding HTML style? (html { })

     *

     * @return array

     */

    public function buildCSS($generateSurroundingHTML = true)

    {

        // Cached?

        if ($this->cssStyles !== null) {

            return $this->cssStyles;

        }

        // Ensure that spans have been calculated

        $this->calculateSpans();

        // Construct CSS

        $css = [];

        // Start styles

        if ($generateSurroundingHTML) {

            // html { }

            $css['html']['font-family'] = 'Calibri, Arial, Helvetica, sans-serif';

            $css['html']['font-size'] = '11pt';

            $css['html']['background-color'] = 'white';

        }

        // CSS for comments as found in LibreOffice

        $css['a.comment-indicator:hover + div.comment'] = [

            'background' => '#ffd',

            'position' => 'absolute',

            'display' => 'block',

            'border' => '1px solid black',

            'padding' => '0.5em',

        ];

        $css['a.comment-indicator'] = [

            'background' => 'red',

            'display' => 'inline-block',

            'border' => '1px solid black',

            'width' => '0.5em',

            'height' => '0.5em',

        ];

        $css['div.comment']['display'] = 'none';

        // table { }

        $css['table']['border-collapse'] = 'collapse';

        // .b {}

        $css['.b']['text-align'] = 'center'; // BOOL

        // .e {}

        $css['.e']['text-align'] = 'center'; // ERROR

        // .f {}

        $css['.f']['text-align'] = 'right'; // FORMULA

        // .inlineStr {}

        $css['.inlineStr']['text-align'] = 'left'; // INLINE

        // .n {}

        $css['.n']['text-align'] = 'right'; // NUMERIC

        // .s {}

        $css['.s']['text-align'] = 'left'; // STRING

        // Calculate cell style hashes

        foreach ($this->spreadsheet->getCellXfCollection() as $index => $style) {

            $css['td.style' . $index . ', th.style' . $index] = $this->createCSSStyle($style);

            //$css['th.style' . $index] = $this->createCSSStyle($style);

        }

        // Fetch sheets

        $sheets = [];

        if ($this->sheetIndex === null) {

            $sheets = $this->spreadsheet->getAllSheets();

        } else {

            $sheets[] = $this->spreadsheet->getSheet($this->sheetIndex);

        }

        // Build styles per sheet

        foreach ($sheets as $sheet) {

            $this->buildCssPerSheet($sheet, $css);

        }

        // Cache

        if ($this->cssStyles === null) {

            $this->cssStyles = $css;

        }

        // Return

        return $css;

    }

    /**

     * Create CSS style.

     *

     * @return array

     */

    private function createCSSStyle(Style $style)

    {

        // Create CSS

        return array_merge(

            $this->createCSSStyleAlignment($style->getAlignment()),