init

lib/PhpSpreadsheet/Writer/Ods/AutoFilters.php

@@ -0,0 +1,57 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Writer\Ods;
+
+use PhpOffice\PhpSpreadsheet\Shared\XMLWriter;
+use PhpOffice\PhpSpreadsheet\Spreadsheet;
+use PhpOffice\PhpSpreadsheet\Worksheet\AutoFilter;
+use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
+
+class AutoFilters
+{
+    private XMLWriter $objWriter;
+
+    private Spreadsheet $spreadsheet;
+
+    public function __construct(XMLWriter $objWriter, Spreadsheet $spreadsheet)
+    {
+        $this->objWriter = $objWriter;
+        $this->spreadsheet = $spreadsheet;
+    }
+
+    public function write(): void
+    {
+        $wrapperWritten = false;
+        $sheetCount = $this->spreadsheet->getSheetCount();
+        for ($i = 0; $i < $sheetCount; ++$i) {
+            $worksheet = $this->spreadsheet->getSheet($i);
+            $autofilter = $worksheet->getAutoFilter();
+            if ($autofilter !== null && !empty($autofilter->getRange())) {
+                if ($wrapperWritten === false) {
+                    $this->objWriter->startElement('table:database-ranges');
+                    $wrapperWritten = true;
+                }
+                $this->objWriter->startElement('table:database-range');
+                $this->objWriter->writeAttribute('table:orientation', 'column');
+                $this->objWriter->writeAttribute('table:display-filter-buttons', 'true');
+                $this->objWriter->writeAttribute(
+                    'table:target-range-address',
+                    $this->formatRange($worksheet, $autofilter)
+                );
+                $this->objWriter->endElement();
+            }
+        }
+
+        if ($wrapperWritten === true) {
+            $this->objWriter->endElement();
+        }
+    }
+
+    protected function formatRange(Worksheet $worksheet, Autofilter $autofilter): string
+    {
+        $title = $worksheet->getTitle();
+        $range = $autofilter->getRange();
+
+        return "'{$title}'.{$range}";
+    }
+}

lib/PhpSpreadsheet/Writer/Ods/Cell/Comment.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Writer\Ods\Cell;
+
+use PhpOffice\PhpSpreadsheet\Cell\Cell;
+use PhpOffice\PhpSpreadsheet\Shared\XMLWriter;
+
+/**
+ * @author     Alexander Pervakov <frost-nzcr4@jagmort.com>
+ */
+class Comment
+{
+    public static function write(XMLWriter $objWriter, Cell $cell): void
+    {
+        $comments = $cell->getWorksheet()->getComments();
+        if (!isset($comments[$cell->getCoordinate()])) {
+            return;
+        }
+        $comment = $comments[$cell->getCoordinate()];
+
+        $objWriter->startElement('office:annotation');
+        $objWriter->writeAttribute('svg:width', $comment->getWidth());
+        $objWriter->writeAttribute('svg:height', $comment->getHeight());
+        $objWriter->writeAttribute('svg:x', $comment->getMarginLeft());
+        $objWriter->writeAttribute('svg:y', $comment->getMarginTop());
+        $objWriter->writeElement('dc:creator', $comment->getAuthor());
+        $objWriter->writeElement('text:p', $comment->getText()->getPlainText());
+        $objWriter->endElement();
+    }
+}

lib/PhpSpreadsheet/Writer/Ods/Cell/Style.php

@@ -0,0 +1,320 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Writer\Ods\Cell;
+
+use PhpOffice\PhpSpreadsheet\Helper\Dimension;
+use PhpOffice\PhpSpreadsheet\Shared\XMLWriter;
+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\Style as CellStyle;
+use PhpOffice\PhpSpreadsheet\Worksheet\ColumnDimension;
+use PhpOffice\PhpSpreadsheet\Worksheet\RowDimension;
+use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
+
+class Style
+{
+    public const CELL_STYLE_PREFIX = 'ce';
+    public const COLUMN_STYLE_PREFIX = 'co';
+    public const ROW_STYLE_PREFIX = 'ro';
+    public const TABLE_STYLE_PREFIX = 'ta';
+
+    private XMLWriter $writer;
+
+    public function __construct(XMLWriter $writer)
+    {
+        $this->writer = $writer;
+    }
+
+    private function mapHorizontalAlignment(string $horizontalAlignment): string
+    {
+        return match ($horizontalAlignment) {
+            Alignment::HORIZONTAL_CENTER, Alignment::HORIZONTAL_CENTER_CONTINUOUS, Alignment::HORIZONTAL_DISTRIBUTED => 'center',
+            Alignment::HORIZONTAL_RIGHT => 'end',
+            Alignment::HORIZONTAL_FILL, Alignment::HORIZONTAL_JUSTIFY => 'justify',
+            default => 'start',
+        };
+    }
+
+    private function mapVerticalAlignment(string $verticalAlignment): string
+    {
+        return match ($verticalAlignment) {
+            Alignment::VERTICAL_TOP => 'top',
+            Alignment::VERTICAL_CENTER => 'middle',
+            Alignment::VERTICAL_DISTRIBUTED, Alignment::VERTICAL_JUSTIFY => 'automatic',
+            default => 'bottom',
+        };
+    }
+
+    private function writeFillStyle(Fill $fill): void
+    {
+        switch ($fill->getFillType()) {
+            case Fill::FILL_SOLID:
+                $this->writer->writeAttribute('fo:background-color', sprintf(
+                    '#%s',
+                    strtolower($fill->getStartColor()->getRGB())
+                ));
+
+                break;
+            case Fill::FILL_GRADIENT_LINEAR:
+            case Fill::FILL_GRADIENT_PATH:
+                /// TODO :: To be implemented
+                break;
+            case Fill::FILL_NONE:
+            default:
+        }
+    }
+
+    private function writeBordersStyle(Borders $borders): void
+    {
+        $this->writeBorderStyle('bottom', $borders->getBottom());
+        $this->writeBorderStyle('left', $borders->getLeft());
+        $this->writeBorderStyle('right', $borders->getRight());
+        $this->writeBorderStyle('top', $borders->getTop());
+    }
+
+    private function writeBorderStyle(string $direction, Border $border): void
+    {
+        if ($border->getBorderStyle() === Border::BORDER_NONE) {
+            return;
+        }
+
+        $this->writer->writeAttribute('fo:border-' . $direction, sprintf(
+            '%s %s #%s',
+            $this->mapBorderWidth($border),
+            $this->mapBorderStyle($border),
+            $border->getColor()->getRGB(),
+        ));
+    }
+
+    private function mapBorderWidth(Border $border): string
+    {
+        switch ($border->getBorderStyle()) {
+            case Border::BORDER_THIN:
+            case Border::BORDER_DASHED:
+            case Border::BORDER_DASHDOT:
+            case Border::BORDER_DASHDOTDOT:
+            case Border::BORDER_DOTTED:
+            case Border::BORDER_HAIR:
+                return '0.75pt';
+            case Border::BORDER_MEDIUM:
+            case Border::BORDER_MEDIUMDASHED:
+            case Border::BORDER_MEDIUMDASHDOT:
+            case Border::BORDER_MEDIUMDASHDOTDOT:
+            case Border::BORDER_SLANTDASHDOT:
+                return '1.75pt';
+            case Border::BORDER_DOUBLE:
+            case Border::BORDER_THICK:
+                return '2.5pt';
+        }
+
+        return '1pt';
+    }
+
+    private function mapBorderStyle(Border $border): string
+    {
+        switch ($border->getBorderStyle()) {
+            case Border::BORDER_DOTTED:
+            case Border::BORDER_MEDIUMDASHDOTDOT:
+                return Border::BORDER_DOTTED;
+
+            case Border::BORDER_DASHED:
+            case Border::BORDER_DASHDOT:
+            case Border::BORDER_DASHDOTDOT:
+            case Border::BORDER_MEDIUMDASHDOT:
+            case Border::BORDER_MEDIUMDASHED:
+            case Border::BORDER_SLANTDASHDOT:
+                return Border::BORDER_DASHED;
+
+            case Border::BORDER_DOUBLE:
+                return Border::BORDER_DOUBLE;
+
+            case Border::BORDER_HAIR:
+            case Border::BORDER_MEDIUM:
+            case Border::BORDER_THICK:
+            case Border::BORDER_THIN:
+                return 'solid';
+        }
+
+        return 'solid';
+    }
+
+    private function writeCellProperties(CellStyle $style): void
+    {
+        // Align
+        $hAlign = $style->getAlignment()->getHorizontal();
+        $vAlign = $style->getAlignment()->getVertical();
+        $wrap = $style->getAlignment()->getWrapText();
+
+        $this->writer->startElement('style:table-cell-properties');
+        if (!empty($vAlign) || $wrap) {
+            if (!empty($vAlign)) {
+                $vAlign = $this->mapVerticalAlignment($vAlign);
+                $this->writer->writeAttribute('style:vertical-align', $vAlign);
+            }
+            if ($wrap) {
+                $this->writer->writeAttribute('fo:wrap-option', 'wrap');
+            }
+        }
+        $this->writer->writeAttribute('style:rotation-align', 'none');
+
+        // Fill
+        $this->writeFillStyle($style->getFill());
+
+        // Border
+        $this->writeBordersStyle($style->getBorders());
+
+        $this->writer->endElement();
+
+        if (!empty($hAlign)) {
+            $hAlign = $this->mapHorizontalAlignment($hAlign);
+            $this->writer->startElement('style:paragraph-properties');
+            $this->writer->writeAttribute('fo:text-align', $hAlign);
+            $this->writer->endElement();
+        }
+    }
+
+    protected function mapUnderlineStyle(Font $font): string
+    {
+        return match ($font->getUnderline()) {
+            Font::UNDERLINE_DOUBLE, Font::UNDERLINE_DOUBLEACCOUNTING => 'double',
+            Font::UNDERLINE_SINGLE, Font::UNDERLINE_SINGLEACCOUNTING => 'single',
+            default => 'none',
+        };
+    }
+
+    protected function writeTextProperties(CellStyle $style): void
+    {
+        // Font
+        $this->writer->startElement('style:text-properties');
+
+        $font = $style->getFont();
+
+        if ($font->getBold()) {
+            $this->writer->writeAttribute('fo:font-weight', 'bold');
+            $this->writer->writeAttribute('style:font-weight-complex', 'bold');
+            $this->writer->writeAttribute('style:font-weight-asian', 'bold');
+        }
+
+        if ($font->getItalic()) {
+            $this->writer->writeAttribute('fo:font-style', 'italic');
+        }
+
+        $this->writer->writeAttribute('fo:color', sprintf('#%s', $font->getColor()->getRGB()));
+
+        if ($family = $font->getName()) {
+            $this->writer->writeAttribute('fo:font-family', $family);
+        }
+
+        if ($size = $font->getSize()) {
+            $this->writer->writeAttribute('fo:font-size', sprintf('%.1Fpt', $size));
+        }
+
+        if ($font->getUnderline() && $font->getUnderline() !== Font::UNDERLINE_NONE) {
+            $this->writer->writeAttribute('style:text-underline-style', 'solid');
+            $this->writer->writeAttribute('style:text-underline-width', 'auto');
+            $this->writer->writeAttribute('style:text-underline-color', 'font-color');
+
+            $underline = $this->mapUnderlineStyle($font);
+            $this->writer->writeAttribute('style:text-underline-type', $underline);
+        }
+
+        $this->writer->endElement(); // Close style:text-properties
+    }
+
+    protected function writeColumnProperties(ColumnDimension $columnDimension): void
+    {
+        $this->writer->startElement('style:table-column-properties');
+        $this->writer->writeAttribute(
+            'style:column-width',
+            round($columnDimension->getWidth(Dimension::UOM_CENTIMETERS), 3) . 'cm'
+        );
+        $this->writer->writeAttribute('fo:break-before', 'auto');
+
+        // End
+        $this->writer->endElement(); // Close style:table-column-properties
+    }
+
+    public function writeColumnStyles(ColumnDimension $columnDimension, int $sheetId): void
+    {
+        $this->writer->startElement('style:style');
+        $this->writer->writeAttribute('style:family', 'table-column');
+        $this->writer->writeAttribute(
+            'style:name',
+            sprintf('%s_%d_%d', self::COLUMN_STYLE_PREFIX, $sheetId, $columnDimension->getColumnNumeric())
+        );
+
+        $this->writeColumnProperties($columnDimension);
+
+        // End
+        $this->writer->endElement(); // Close style:style
+    }
+
+    protected function writeRowProperties(RowDimension $rowDimension): void
+    {
+        $this->writer->startElement('style:table-row-properties');
+        $this->writer->writeAttribute(
+            'style:row-height',
+            round($rowDimension->getRowHeight(Dimension::UOM_CENTIMETERS), 3) . 'cm'
+        );
+        $this->writer->writeAttribute('style:use-optimal-row-height', 'false');
+        $this->writer->writeAttribute('fo:break-before', 'auto');
+
+        // End
+        $this->writer->endElement(); // Close style:table-row-properties
+    }
+
+    public function writeRowStyles(RowDimension $rowDimension, int $sheetId): void
+    {
+        $this->writer->startElement('style:style');
+        $this->writer->writeAttribute('style:family', 'table-row');
+        $this->writer->writeAttribute(
+            'style:name',
+            sprintf('%s_%d_%d', self::ROW_STYLE_PREFIX, $sheetId, $rowDimension->getRowIndex())
+        );
+
+        $this->writeRowProperties($rowDimension);
+
+        // End
+        $this->writer->endElement(); // Close style:style
+    }
+
+    public function writeTableStyle(Worksheet $worksheet, int $sheetId): void
+    {
+        $this->writer->startElement('style:style');
+        $this->writer->writeAttribute('style:family', 'table');
+        $this->writer->writeAttribute(
+            'style:name',
+            sprintf('%s%d', self::TABLE_STYLE_PREFIX, $sheetId)
+        );
+
+        $this->writer->startElement('style:table-properties');
+
+        $this->writer->writeAttribute(
+            'table:display',
+            $worksheet->getSheetState() === Worksheet::SHEETSTATE_VISIBLE ? 'true' : 'false'
+        );
+
+        $this->writer->endElement(); // Close style:table-properties
+        $this->writer->endElement(); // Close style:style
+    }
+
+    public function write(CellStyle $style): void
+    {
+        $this->writer->startElement('style:style');
+        $this->writer->writeAttribute('style:name', self::CELL_STYLE_PREFIX . $style->getIndex());
+        $this->writer->writeAttribute('style:family', 'table-cell');
+        $this->writer->writeAttribute('style:parent-style-name', 'Default');
+
+        // Alignment, fill colour, etc
+        $this->writeCellProperties($style);
+
+        // style:text-properties
+        $this->writeTextProperties($style);
+
+        // End
+        $this->writer->endElement(); // Close style:style
+    }
+}

lib/PhpSpreadsheet/Writer/Ods/Content.php

@@ -0,0 +1,356 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Writer\Ods;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Exception as CalculationException;
+use PhpOffice\PhpSpreadsheet\Cell\Cell;
+use PhpOffice\PhpSpreadsheet\Cell\Coordinate;
+use PhpOffice\PhpSpreadsheet\Cell\DataType;
+use PhpOffice\PhpSpreadsheet\Shared\XMLWriter;
+use PhpOffice\PhpSpreadsheet\Spreadsheet;
+use PhpOffice\PhpSpreadsheet\Worksheet\RowCellIterator;
+use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
+use PhpOffice\PhpSpreadsheet\Writer\Ods;
+use PhpOffice\PhpSpreadsheet\Writer\Ods\Cell\Comment;
+use PhpOffice\PhpSpreadsheet\Writer\Ods\Cell\Style;
+
+/**
+ * @author     Alexander Pervakov <frost-nzcr4@jagmort.com>
+ */
+class Content extends WriterPart
+{
+    const NUMBER_COLS_REPEATED_MAX = 1024;
+    const NUMBER_ROWS_REPEATED_MAX = 1048576;
+
+    private Formula $formulaConvertor;
+
+    /**
+     * Set parent Ods writer.
+     */
+    public function __construct(Ods $writer)
+    {
+        parent::__construct($writer);
+
+        $this->formulaConvertor = new Formula($this->getParentWriter()->getSpreadsheet()->getDefinedNames());
+    }
+
+    /**
+     * Write content.xml to XML format.
+     *
+     * @return string XML Output
+     */
+    public function write(): string
+    {
+        $objWriter = null;
+        if ($this->getParentWriter()->getUseDiskCaching()) {
+            $objWriter = new XMLWriter(XMLWriter::STORAGE_DISK, $this->getParentWriter()->getDiskCachingDirectory());
+        } else {
+            $objWriter = new XMLWriter(XMLWriter::STORAGE_MEMORY);
+        }
+
+        // XML header
+        $objWriter->startDocument('1.0', 'UTF-8');
+
+        // Content
+        $objWriter->startElement('office:document-content');
+        $objWriter->writeAttribute('xmlns:office', 'urn:oasis:names:tc:opendocument:xmlns:office:1.0');
+        $objWriter->writeAttribute('xmlns:style', 'urn:oasis:names:tc:opendocument:xmlns:style:1.0');
+        $objWriter->writeAttribute('xmlns:text', 'urn:oasis:names:tc:opendocument:xmlns:text:1.0');
+        $objWriter->writeAttribute('xmlns:table', 'urn:oasis:names:tc:opendocument:xmlns:table:1.0');
+        $objWriter->writeAttribute('xmlns:draw', 'urn:oasis:names:tc:opendocument:xmlns:drawing:1.0');
+        $objWriter->writeAttribute('xmlns:fo', 'urn:oasis:names:tc:opendocument:xmlns:xsl-fo-compatible:1.0');
+        $objWriter->writeAttribute('xmlns:xlink', 'http://www.w3.org/1999/xlink');
+        $objWriter->writeAttribute('xmlns:dc', 'http://purl.org/dc/elements/1.1/');
+        $objWriter->writeAttribute('xmlns:meta', 'urn:oasis:names:tc:opendocument:xmlns:meta:1.0');
+        $objWriter->writeAttribute('xmlns:number', 'urn:oasis:names:tc:opendocument:xmlns:datastyle:1.0');
+        $objWriter->writeAttribute('xmlns:presentation', 'urn:oasis:names:tc:opendocument:xmlns:presentation:1.0');
+        $objWriter->writeAttribute('xmlns:svg', 'urn:oasis:names:tc:opendocument:xmlns:svg-compatible:1.0');
+        $objWriter->writeAttribute('xmlns:chart', 'urn:oasis:names:tc:opendocument:xmlns:chart:1.0');
+        $objWriter->writeAttribute('xmlns:dr3d', 'urn:oasis:names:tc:opendocument:xmlns:dr3d:1.0');
+        $objWriter->writeAttribute('xmlns:math', 'http://www.w3.org/1998/Math/MathML');
+        $objWriter->writeAttribute('xmlns:form', 'urn:oasis:names:tc:opendocument:xmlns:form:1.0');
+        $objWriter->writeAttribute('xmlns:script', 'urn:oasis:names:tc:opendocument:xmlns:script:1.0');
+        $objWriter->writeAttribute('xmlns:ooo', 'http://openoffice.org/2004/office');
+        $objWriter->writeAttribute('xmlns:ooow', 'http://openoffice.org/2004/writer');
+        $objWriter->writeAttribute('xmlns:oooc', 'http://openoffice.org/2004/calc');
+        $objWriter->writeAttribute('xmlns:dom', 'http://www.w3.org/2001/xml-events');
+        $objWriter->writeAttribute('xmlns:xforms', 'http://www.w3.org/2002/xforms');
+        $objWriter->writeAttribute('xmlns:xsd', 'http://www.w3.org/2001/XMLSchema');
+        $objWriter->writeAttribute('xmlns:xsi', 'http://www.w3.org/2001/XMLSchema-instance');
+        $objWriter->writeAttribute('xmlns:rpt', 'http://openoffice.org/2005/report');
+        $objWriter->writeAttribute('xmlns:of', 'urn:oasis:names:tc:opendocument:xmlns:of:1.2');
+        $objWriter->writeAttribute('xmlns:xhtml', 'http://www.w3.org/1999/xhtml');
+        $objWriter->writeAttribute('xmlns:grddl', 'http://www.w3.org/2003/g/data-view#');
+        $objWriter->writeAttribute('xmlns:tableooo', 'http://openoffice.org/2009/table');
+        $objWriter->writeAttribute('xmlns:field', 'urn:openoffice:names:experimental:ooo-ms-interop:xmlns:field:1.0');
+        $objWriter->writeAttribute('xmlns:formx', 'urn:openoffice:names:experimental:ooxml-odf-interop:xmlns:form:1.0');
+        $objWriter->writeAttribute('xmlns:css3t', 'http://www.w3.org/TR/css3-text/');
+        $objWriter->writeAttribute('office:version', '1.2');
+
+        $objWriter->writeElement('office:scripts');
+        $objWriter->writeElement('office:font-face-decls');
+
+        // Styles XF
+        $objWriter->startElement('office:automatic-styles');
+        $this->writeXfStyles($objWriter, $this->getParentWriter()->getSpreadsheet());
+        $objWriter->endElement();
+
+        $objWriter->startElement('office:body');
+        $objWriter->startElement('office:spreadsheet');
+        $objWriter->writeElement('table:calculation-settings');
+
+        $this->writeSheets($objWriter);
+
+        (new AutoFilters($objWriter, $this->getParentWriter()->getSpreadsheet()))->write();
+        // Defined names (ranges and formulae)
+        (new NamedExpressions($objWriter, $this->getParentWriter()->getSpreadsheet(), $this->formulaConvertor))->write();
+
+        $objWriter->endElement();
+        $objWriter->endElement();
+        $objWriter->endElement();
+
+        return $objWriter->getData();
+    }
+
+    /**
+     * Write sheets.
+     */
+    private function writeSheets(XMLWriter $objWriter): void
+    {
+        $spreadsheet = $this->getParentWriter()->getSpreadsheet();
+        $sheetCount = $spreadsheet->getSheetCount();
+        for ($sheetIndex = 0; $sheetIndex < $sheetCount; ++$sheetIndex) {
+            $objWriter->startElement('table:table');
+            $objWriter->writeAttribute('table:name', $spreadsheet->getSheet($sheetIndex)->getTitle());
+            $objWriter->writeAttribute('table:style-name', Style::TABLE_STYLE_PREFIX . (string) ($sheetIndex + 1));
+            $objWriter->writeElement('office:forms');
+            $lastColumn = 0;
+            foreach ($spreadsheet->getSheet($sheetIndex)->getColumnDimensions() as $columnDimension) {
+                $thisColumn = $columnDimension->getColumnNumeric();
+                $emptyColumns = $thisColumn - $lastColumn - 1;
+                if ($emptyColumns > 0) {
+                    $objWriter->startElement('table:table-column');
+                    $objWriter->writeAttribute('table:number-columns-repeated', (string) $emptyColumns);
+                    $objWriter->endElement();
+                }
+                $lastColumn = $thisColumn;
+                $objWriter->startElement('table:table-column');
+                $objWriter->writeAttribute(
+                    'table:style-name',
+                    sprintf('%s_%d_%d', Style::COLUMN_STYLE_PREFIX, $sheetIndex, $columnDimension->getColumnNumeric())
+                );
+                $objWriter->writeAttribute('table:default-cell-style-name', 'ce0');
+//                $objWriter->writeAttribute('table:number-columns-repeated', self::NUMBER_COLS_REPEATED_MAX);
+                $objWriter->endElement();
+            }
+            $this->writeRows($objWriter, $spreadsheet->getSheet($sheetIndex), $sheetIndex);
+            $objWriter->endElement();
+        }
+    }
+
+    /**
+     * Write rows of the specified sheet.
+     */
+    private function writeRows(XMLWriter $objWriter, Worksheet $sheet, int $sheetIndex): void
+    {
+        $numberRowsRepeated = self::NUMBER_ROWS_REPEATED_MAX;
+        $span_row = 0;
+        $rows = $sheet->getRowIterator();
+        foreach ($rows as $row) {
+            $cellIterator = $row->getCellIterator();
+            --$numberRowsRepeated;
+            if ($cellIterator->valid()) {
+                $objWriter->startElement('table:table-row');
+                if ($span_row) {
+                    if ($span_row > 1) {
+                        $objWriter->writeAttribute('table:number-rows-repeated', (string) $span_row);
+                    }
+                    $objWriter->startElement('table:table-cell');
+                    $objWriter->writeAttribute('table:number-columns-repeated', (string) self::NUMBER_COLS_REPEATED_MAX);
+                    $objWriter->endElement();
+                    $span_row = 0;
+                } else {
+                    if ($sheet->rowDimensionExists($row->getRowIndex()) && $sheet->getRowDimension($row->getRowIndex())->getRowHeight() > 0) {
+                        $objWriter->writeAttribute(
+                            'table:style-name',
+                            sprintf('%s_%d_%d', Style::ROW_STYLE_PREFIX, $sheetIndex, $row->getRowIndex())
+                        );
+                    }
+                    $this->writeCells($objWriter, $cellIterator);
+                }
+                $objWriter->endElement();
+            } else {
+                ++$span_row;
+            }
+        }
+    }
+
+    /**
+     * Write cells of the specified row.
+     */
+    private function writeCells(XMLWriter $objWriter, RowCellIterator $cells): void
+    {
+        $numberColsRepeated = self::NUMBER_COLS_REPEATED_MAX;
+        $prevColumn = -1;
+        foreach ($cells as $cell) {
+            /** @var Cell $cell */
+            $column = Coordinate::columnIndexFromString($cell->getColumn()) - 1;
+
+            $this->writeCellSpan($objWriter, $column, $prevColumn);
+            $objWriter->startElement('table:table-cell');
+            $this->writeCellMerge($objWriter, $cell);
+
+            // Style XF
+            $style = $cell->getXfIndex();
+            if ($style !== null) {
+                $objWriter->writeAttribute('table:style-name', Style::CELL_STYLE_PREFIX . $style);
+            }
+
+            switch ($cell->getDataType()) {
+                case DataType::TYPE_BOOL:
+                    $objWriter->writeAttribute('office:value-type', 'boolean');
+                    $objWriter->writeAttribute('office:value', $cell->getValue());
+                    $objWriter->writeElement('text:p', $cell->getValue());
+
+                    break;
+                case DataType::TYPE_ERROR:
+                    $objWriter->writeAttribute('table:formula', 'of:=#NULL!');
+                    $objWriter->writeAttribute('office:value-type', 'string');
+                    $objWriter->writeAttribute('office:string-value', '');
+                    $objWriter->writeElement('text:p', '#NULL!');
+
+                    break;
+                case DataType::TYPE_FORMULA:
+                    $formulaValue = $cell->getValue();
+                    if ($this->getParentWriter()->getPreCalculateFormulas()) {
+                        try {
+                            $formulaValue = $cell->getCalculatedValue();
+                        } catch (CalculationException $e) {
+                            // don't do anything
+                        }
+                    }
+                    $objWriter->writeAttribute('table:formula', $this->formulaConvertor->convertFormula($cell->getValue()));
+                    if (is_numeric($formulaValue)) {
+                        $objWriter->writeAttribute('office:value-type', 'float');
+                    } else {
+                        $objWriter->writeAttribute('office:value-type', 'string');
+                    }
+                    $objWriter->writeAttribute('office:value', $formulaValue);
+                    $objWriter->writeElement('text:p', $formulaValue);
+
+                    break;
+                case DataType::TYPE_NUMERIC:
+                    $objWriter->writeAttribute('office:value-type', 'float');
+                    $objWriter->writeAttribute('office:value', $cell->getValue());
+                    $objWriter->writeElement('text:p', $cell->getValue());
+
+                    break;
+                case DataType::TYPE_INLINE:
+                    // break intentionally omitted
+                case DataType::TYPE_STRING:
+                    $objWriter->writeAttribute('office:value-type', 'string');
+                    $url = $cell->getHyperlink()->getUrl();
+                    if (empty($url)) {
+                        $objWriter->writeElement('text:p', $cell->getValue());
+                    } else {
+                        $objWriter->startElement('text:p');
+                        $objWriter->startElement('text:a');
+                        $sheets = 'sheet://';
+                        $lensheets = strlen($sheets);
+                        if (substr($url, 0, $lensheets) === $sheets) {
+                            $url = '#' . substr($url, $lensheets);
+                        }
+                        $objWriter->writeAttribute('xlink:href', $url);
+                        $objWriter->writeAttribute('xlink:type', 'simple');
+                        $objWriter->text($cell->getValue());
+                        $objWriter->endElement(); // text:a
+                        $objWriter->endElement(); // text:p
+                    }
+
+                    break;
+            }
+            Comment::write($objWriter, $cell);
+            $objWriter->endElement();
+            $prevColumn = $column;
+        }
+
+        $numberColsRepeated = $numberColsRepeated - $prevColumn - 1;
+        if ($numberColsRepeated > 0) {
+            if ($numberColsRepeated > 1) {
+                $objWriter->startElement('table:table-cell');
+                $objWriter->writeAttribute('table:number-columns-repeated', (string) $numberColsRepeated);
+                $objWriter->endElement();
+            } else {
+                $objWriter->writeElement('table:table-cell');
+            }
+        }
+    }
+
+    /**
+     * Write span.
+     */
+    private function writeCellSpan(XMLWriter $objWriter, int $curColumn, int $prevColumn): void
+    {
+        $diff = $curColumn - $prevColumn - 1;
+        if (1 === $diff) {
+            $objWriter->writeElement('table:table-cell');
+        } elseif ($diff > 1) {
+            $objWriter->startElement('table:table-cell');
+            $objWriter->writeAttribute('table:number-columns-repeated', (string) $diff);
+            $objWriter->endElement();
+        }
+    }
+
+    /**
+     * Write XF cell styles.
+     */
+    private function writeXfStyles(XMLWriter $writer, Spreadsheet $spreadsheet): void
+    {
+        $styleWriter = new Style($writer);
+
+        $sheetCount = $spreadsheet->getSheetCount();
+        for ($i = 0; $i < $sheetCount; ++$i) {
+            $worksheet = $spreadsheet->getSheet($i);
+            $styleWriter->writeTableStyle($worksheet, $i + 1);
+
+            $worksheet->calculateColumnWidths();
+            foreach ($worksheet->getColumnDimensions() as $columnDimension) {
+                if ($columnDimension->getWidth() !== -1.0) {
+                    $styleWriter->writeColumnStyles($columnDimension, $i);
+                }
+            }
+        }
+        for ($i = 0; $i < $sheetCount; ++$i) {
+            $worksheet = $spreadsheet->getSheet($i);
+            foreach ($worksheet->getRowDimensions() as $rowDimension) {
+                if ($rowDimension->getRowHeight() > 0.0) {
+                    $styleWriter->writeRowStyles($rowDimension, $i);
+                }
+            }
+        }
+
+        foreach ($spreadsheet->getCellXfCollection() as $style) {
+            $styleWriter->write($style);
+        }
+    }
+
+    /**
+     * Write attributes for merged cell.
+     */
+    private function writeCellMerge(XMLWriter $objWriter, Cell $cell): void
+    {
+        if (!$cell->isMergeRangeValueCell()) {
+            return;
+        }
+
+        $mergeRange = Coordinate::splitRange((string) $cell->getMergeRange());
+        [$startCell, $endCell] = $mergeRange[0];
+        $start = Coordinate::coordinateFromString($startCell);
+        $end = Coordinate::coordinateFromString($endCell);
+        $columnSpan = Coordinate::columnIndexFromString($end[0]) - Coordinate::columnIndexFromString($start[0]) + 1;
+        $rowSpan = ((int) $end[1]) - ((int) $start[1]) + 1;
+
+        $objWriter->writeAttribute('table:number-columns-spanned', (string) $columnSpan);
+        $objWriter->writeAttribute('table:number-rows-spanned', (string) $rowSpan);
+    }
+}

lib/PhpSpreadsheet/Writer/Ods/Formula.php

@@ -0,0 +1,119 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Writer\Ods;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Calculation;
+use PhpOffice\PhpSpreadsheet\DefinedName;
+
+class Formula
+{
+    private array $definedNames = [];
+
+    /**
+     * @param DefinedName[] $definedNames
+     */
+    public function __construct(array $definedNames)
+    {
+        foreach ($definedNames as $definedName) {
+            $this->definedNames[] = $definedName->getName();
+        }
+    }
+
+    public function convertFormula(string $formula, string $worksheetName = ''): string
+    {
+        $formula = $this->convertCellReferences($formula, $worksheetName);
+        $formula = $this->convertDefinedNames($formula);
+
+        if (!str_starts_with($formula, '=')) {
+            $formula = '=' . $formula;
+        }
+
+        return 'of:' . $formula;
+    }
+
+    private function convertDefinedNames(string $formula): string
+    {
+        $splitCount = preg_match_all(
+            '/' . Calculation::CALCULATION_REGEXP_DEFINEDNAME . '/mui',
+            $formula,
+            $splitRanges,
+            PREG_OFFSET_CAPTURE
+        );
+
+        $lengths = array_map('strlen', array_column($splitRanges[0], 0));
+        $offsets = array_column($splitRanges[0], 1);
+        $values = array_column($splitRanges[0], 0);
+
+        while ($splitCount > 0) {
+            --$splitCount;
+            $length = $lengths[$splitCount];
+            $offset = $offsets[$splitCount];
+            $value = $values[$splitCount];
+
+            if (in_array($value, $this->definedNames, true)) {
+                $formula = substr($formula, 0, $offset) . '$$' . $value . substr($formula, $offset + $length);
+            }
+        }
+
+        return $formula;
+    }
+
+    private function convertCellReferences(string $formula, string $worksheetName): string
+    {
+        $splitCount = preg_match_all(
+            '/' . Calculation::CALCULATION_REGEXP_CELLREF_RELATIVE . '/mui',
+            $formula,
+            $splitRanges,
+            PREG_OFFSET_CAPTURE
+        );
+
+        $lengths = array_map('strlen', array_column($splitRanges[0], 0));
+        $offsets = array_column($splitRanges[0], 1);
+
+        $worksheets = $splitRanges[2];
+        $columns = $splitRanges[6];
+        $rows = $splitRanges[7];
+
+        // Replace any commas in the formula with semi-colons for Ods
+        // If by chance there are commas in worksheet names, then they will be "fixed" again in the loop
+        //    because we've already extracted worksheet names with our preg_match_all()
+        $formula = str_replace(',', ';', $formula);
+        while ($splitCount > 0) {
+            --$splitCount;
+            $length = $lengths[$splitCount];
+            $offset = $offsets[$splitCount];
+            $worksheet = $worksheets[$splitCount][0];
+            $column = $columns[$splitCount][0];
+            $row = $rows[$splitCount][0];
+
+            $newRange = '';
+            if (empty($worksheet)) {
+                if (($offset === 0) || ($formula[$offset - 1] !== ':')) {
+                    // We need a worksheet
+                    $worksheet = $worksheetName;
+                }
+            } else {
+                $worksheet = str_replace("''", "'", trim($worksheet, "'"));
+            }
+            if (!empty($worksheet)) {
+                $newRange = "['" . str_replace("'", "''", $worksheet) . "'";
+            } elseif (substr($formula, $offset - 1, 1) !== ':') {
+                $newRange = '[';
+            }
+            $newRange .= '.';
+
+            if (!empty($column)) {
+                $newRange .= $column;
+            }
+            if (!empty($row)) {
+                $newRange .= $row;
+            }
+            // close the wrapping [] unless this is the first part of a range
+            $newRange .= substr($formula, $offset + $length, 1) !== ':' ? ']' : '';
+
+            $formula = substr($formula, 0, $offset) . $newRange . substr($formula, $offset + $length);
+        }
+
+        return $formula;
+    }
+}

lib/PhpSpreadsheet/Writer/Ods/Meta.php

@@ -0,0 +1,122 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Writer\Ods;
+
+use PhpOffice\PhpSpreadsheet\Document\Properties;
+use PhpOffice\PhpSpreadsheet\Shared\Date;
+use PhpOffice\PhpSpreadsheet\Shared\XMLWriter;
+use PhpOffice\PhpSpreadsheet\Spreadsheet;
+
+class Meta extends WriterPart
+{
+    /**
+     * Write meta.xml to XML format.
+     *
+     * @return string XML Output
+     */
+    public function write(): string
+    {
+        $spreadsheet = $this->getParentWriter()->getSpreadsheet();
+
+        $objWriter = null;
+        if ($this->getParentWriter()->getUseDiskCaching()) {
+            $objWriter = new XMLWriter(XMLWriter::STORAGE_DISK, $this->getParentWriter()->getDiskCachingDirectory());
+        } else {
+            $objWriter = new XMLWriter(XMLWriter::STORAGE_MEMORY);
+        }
+
+        // XML header
+        $objWriter->startDocument('1.0', 'UTF-8');
+
+        // Meta
+        $objWriter->startElement('office:document-meta');
+
+        $objWriter->writeAttribute('xmlns:office', 'urn:oasis:names:tc:opendocument:xmlns:office:1.0');
+        $objWriter->writeAttribute('xmlns:xlink', 'http://www.w3.org/1999/xlink');
+        $objWriter->writeAttribute('xmlns:dc', 'http://purl.org/dc/elements/1.1/');
+        $objWriter->writeAttribute('xmlns:meta', 'urn:oasis:names:tc:opendocument:xmlns:meta:1.0');
+        $objWriter->writeAttribute('xmlns:ooo', 'http://openoffice.org/2004/office');
+        $objWriter->writeAttribute('xmlns:grddl', 'http://www.w3.org/2003/g/data-view#');
+        $objWriter->writeAttribute('office:version', '1.2');
+
+        $objWriter->startElement('office:meta');
+
+        $objWriter->writeElement('meta:initial-creator', $spreadsheet->getProperties()->getCreator());
+        $objWriter->writeElement('dc:creator', $spreadsheet->getProperties()->getCreator());
+        $created = $spreadsheet->getProperties()->getCreated();
+        $date = Date::dateTimeFromTimestamp("$created");
+        $date->setTimeZone(Date::getDefaultOrLocalTimeZone());
+        $objWriter->writeElement('meta:creation-date', $date->format(DATE_W3C));
+        $created = $spreadsheet->getProperties()->getModified();
+        $date = Date::dateTimeFromTimestamp("$created");
+        $date->setTimeZone(Date::getDefaultOrLocalTimeZone());
+        $objWriter->writeElement('dc:date', $date->format(DATE_W3C));
+        $objWriter->writeElement('dc:title', $spreadsheet->getProperties()->getTitle());
+        $objWriter->writeElement('dc:description', $spreadsheet->getProperties()->getDescription());
+        $objWriter->writeElement('dc:subject', $spreadsheet->getProperties()->getSubject());
+        $objWriter->writeElement('meta:keyword', $spreadsheet->getProperties()->getKeywords());
+        // Don't know if this changed over time, but the keywords are all
+        //  in a single declaration now.
+        //$keywords = explode(' ', $spreadsheet->getProperties()->getKeywords());
+        //foreach ($keywords as $keyword) {
+        //    $objWriter->writeElement('meta:keyword', $keyword);
+        //}
+
+        //<meta:document-statistic meta:table-count="XXX" meta:cell-count="XXX" meta:object-count="XXX"/>
+        $objWriter->startElement('meta:user-defined');
+        $objWriter->writeAttribute('meta:name', 'Company');
+        $objWriter->writeRawData($spreadsheet->getProperties()->getCompany());
+        $objWriter->endElement();
+
+        $objWriter->startElement('meta:user-defined');
+        $objWriter->writeAttribute('meta:name', 'category');
+        $objWriter->writeRawData($spreadsheet->getProperties()->getCategory());
+        $objWriter->endElement();
+
+        self::writeDocPropsCustom($objWriter, $spreadsheet);
+
+        $objWriter->endElement();
+
+        $objWriter->endElement();
+
+        return $objWriter->getData();
+    }
+
+    private static function writeDocPropsCustom(XMLWriter $objWriter, Spreadsheet $spreadsheet): void
+    {
+        $customPropertyList = $spreadsheet->getProperties()->getCustomProperties();
+        foreach ($customPropertyList as $customProperty) {
+            $propertyValue = $spreadsheet->getProperties()->getCustomPropertyValue($customProperty);
+            $propertyType = $spreadsheet->getProperties()->getCustomPropertyType($customProperty);
+
+            $objWriter->startElement('meta:user-defined');
+            $objWriter->writeAttribute('meta:name', $customProperty);
+
+            switch ($propertyType) {
+                case Properties::PROPERTY_TYPE_INTEGER:
+                case Properties::PROPERTY_TYPE_FLOAT:
+                    $objWriter->writeAttribute('meta:value-type', 'float');
+                    $objWriter->writeRawData($propertyValue); // @phpstan-ignore-line
+
+                    break;
+                case Properties::PROPERTY_TYPE_BOOLEAN:
+                    $objWriter->writeAttribute('meta:value-type', 'boolean');
+                    $objWriter->writeRawData($propertyValue ? 'true' : 'false');
+
+                    break;
+                case Properties::PROPERTY_TYPE_DATE:
+                    $objWriter->writeAttribute('meta:value-type', 'date');
+                    $dtobj = Date::dateTimeFromTimestamp($propertyValue ?? 0); // @phpstan-ignore-line
+                    $objWriter->writeRawData($dtobj->format(DATE_W3C));
+
+                    break;
+                default:
+                    $objWriter->writeRawData($propertyValue); // @phpstan-ignore-line
+
+                    break;
+            }
+
+            $objWriter->endElement();
+        }
+    }
+}

lib/PhpSpreadsheet/Writer/Ods/MetaInf.php

@@ -0,0 +1,60 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Writer\Ods;
+
+use PhpOffice\PhpSpreadsheet\Shared\XMLWriter;
+
+class MetaInf extends WriterPart
+{
+    /**
+     * Write META-INF/manifest.xml to XML format.
+     *
+     * @return string XML Output
+     */
+    public function write(): string
+    {
+        $objWriter = null;
+        if ($this->getParentWriter()->getUseDiskCaching()) {
+            $objWriter = new XMLWriter(XMLWriter::STORAGE_DISK, $this->getParentWriter()->getDiskCachingDirectory());
+        } else {
+            $objWriter = new XMLWriter(XMLWriter::STORAGE_MEMORY);
+        }
+
+        // XML header
+        $objWriter->startDocument('1.0', 'UTF-8');
+
+        // Manifest
+        $objWriter->startElement('manifest:manifest');
+        $objWriter->writeAttribute('xmlns:manifest', 'urn:oasis:names:tc:opendocument:xmlns:manifest:1.0');
+        $objWriter->writeAttribute('manifest:version', '1.2');
+
+        $objWriter->startElement('manifest:file-entry');
+        $objWriter->writeAttribute('manifest:full-path', '/');
+        $objWriter->writeAttribute('manifest:version', '1.2');
+        $objWriter->writeAttribute('manifest:media-type', 'application/vnd.oasis.opendocument.spreadsheet');
+        $objWriter->endElement();
+        $objWriter->startElement('manifest:file-entry');
+        $objWriter->writeAttribute('manifest:full-path', 'meta.xml');
+        $objWriter->writeAttribute('manifest:media-type', 'text/xml');
+        $objWriter->endElement();
+        $objWriter->startElement('manifest:file-entry');
+        $objWriter->writeAttribute('manifest:full-path', 'settings.xml');
+        $objWriter->writeAttribute('manifest:media-type', 'text/xml');
+        $objWriter->endElement();
+        $objWriter->startElement('manifest:file-entry');
+        $objWriter->writeAttribute('manifest:full-path', 'content.xml');
+        $objWriter->writeAttribute('manifest:media-type', 'text/xml');
+        $objWriter->endElement();
+        $objWriter->startElement('manifest:file-entry');
+        $objWriter->writeAttribute('manifest:full-path', 'Thumbnails/thumbnail.png');
+        $objWriter->writeAttribute('manifest:media-type', 'image/png');
+        $objWriter->endElement();
+        $objWriter->startElement('manifest:file-entry');
+        $objWriter->writeAttribute('manifest:full-path', 'styles.xml');
+        $objWriter->writeAttribute('manifest:media-type', 'text/xml');
+        $objWriter->endElement();
+        $objWriter->endElement();
+
+        return $objWriter->getData();
+    }
+}

lib/PhpSpreadsheet/Writer/Ods/Mimetype.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Writer\Ods;
+
+class Mimetype extends WriterPart
+{
+    /**
+     * Write mimetype to plain text format.
+     *
+     * @return string XML Output
+     */
+    public function write(): string
+    {
+        return 'application/vnd.oasis.opendocument.spreadsheet';
+    }
+}

lib/PhpSpreadsheet/Writer/Ods/NamedExpressions.php

@@ -0,0 +1,137 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Writer\Ods;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Calculation;
+use PhpOffice\PhpSpreadsheet\DefinedName;
+use PhpOffice\PhpSpreadsheet\Shared\XMLWriter;
+use PhpOffice\PhpSpreadsheet\Spreadsheet;
+use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
+
+class NamedExpressions
+{
+    private XMLWriter $objWriter;
+
+    private Spreadsheet $spreadsheet;
+
+    private Formula $formulaConvertor;
+
+    public function __construct(XMLWriter $objWriter, Spreadsheet $spreadsheet, Formula $formulaConvertor)
+    {
+        $this->objWriter = $objWriter;
+        $this->spreadsheet = $spreadsheet;
+        $this->formulaConvertor = $formulaConvertor;
+    }
+
+    public function write(): string
+    {
+        $this->objWriter->startElement('table:named-expressions');
+        $this->writeExpressions();
+        $this->objWriter->endElement();
+
+        return '';
+    }
+
+    private function writeExpressions(): void
+    {
+        $definedNames = $this->spreadsheet->getDefinedNames();
+
+        foreach ($definedNames as $definedName) {
+            if ($definedName->isFormula()) {
+                $this->objWriter->startElement('table:named-expression');
+                $this->writeNamedFormula($definedName, $this->spreadsheet->getActiveSheet());
+            } else {
+                $this->objWriter->startElement('table:named-range');
+                $this->writeNamedRange($definedName);
+            }
+
+            $this->objWriter->endElement();
+        }
+    }
+
+    private function writeNamedFormula(DefinedName $definedName, Worksheet $defaultWorksheet): void
+    {
+        $title = ($definedName->getWorksheet() !== null) ? $definedName->getWorksheet()->getTitle() : $defaultWorksheet->getTitle();
+        $this->objWriter->writeAttribute('table:name', $definedName->getName());
+        $this->objWriter->writeAttribute(
+            'table:expression',
+            $this->formulaConvertor->convertFormula($definedName->getValue(), $title)
+        );
+        $this->objWriter->writeAttribute('table:base-cell-address', $this->convertAddress(
+            $definedName,
+            "'" . $title . "'!\$A\$1"
+        ));
+    }
+
+    private function writeNamedRange(DefinedName $definedName): void
+    {
+        $baseCell = '$A$1';
+        $ws = $definedName->getWorksheet();
+        if ($ws !== null) {
+            $baseCell = "'" . $ws->getTitle() . "'!$baseCell";
+        }
+        $this->objWriter->writeAttribute('table:name', $definedName->getName());
+        $this->objWriter->writeAttribute('table:base-cell-address', $this->convertAddress(
+            $definedName,
+            $baseCell
+        ));
+        $this->objWriter->writeAttribute('table:cell-range-address', $this->convertAddress($definedName, $definedName->getValue()));
+    }
+
+    private function convertAddress(DefinedName $definedName, string $address): string
+    {
+        $splitCount = preg_match_all(
+            '/' . Calculation::CALCULATION_REGEXP_CELLREF_RELATIVE . '/mui',
+            $address,
+            $splitRanges,
+            PREG_OFFSET_CAPTURE
+        );
+
+        $lengths = array_map('strlen', array_column($splitRanges[0], 0));
+        $offsets = array_column($splitRanges[0], 1);
+
+        $worksheets = $splitRanges[2];
+        $columns = $splitRanges[6];
+        $rows = $splitRanges[7];
+
+        while ($splitCount > 0) {
+            --$splitCount;
+            $length = $lengths[$splitCount];
+            $offset = $offsets[$splitCount];
+            $worksheet = $worksheets[$splitCount][0];
+            $column = $columns[$splitCount][0];
+            $row = $rows[$splitCount][0];
+
+            $newRange = '';
+            if (empty($worksheet)) {
+                if (($offset === 0) || ($address[$offset - 1] !== ':')) {
+                    // We need a worksheet
+                    $ws = $definedName->getWorksheet();
+                    if ($ws !== null) {
+                        $worksheet = $ws->getTitle();
+                    }
+                }
+            } else {
+                $worksheet = str_replace("''", "'", trim($worksheet, "'"));
+            }
+            if (!empty($worksheet)) {
+                $newRange = "'" . str_replace("'", "''", $worksheet) . "'.";
+            }
+
+            if (!empty($column)) {
+                $newRange .= $column;
+            }
+            if (!empty($row)) {
+                $newRange .= $row;
+            }
+
+            $address = substr($address, 0, $offset) . $newRange . substr($address, $offset + $length);
+        }
+
+        if (str_starts_with($address, '=')) {
+            $address = substr($address, 1);
+        }
+
+        return $address;
+    }
+}

lib/PhpSpreadsheet/Writer/Ods/Settings.php

@@ -0,0 +1,152 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Writer\Ods;
+
+use PhpOffice\PhpSpreadsheet\Cell\CellAddress;
+use PhpOffice\PhpSpreadsheet\Cell\Coordinate;
+use PhpOffice\PhpSpreadsheet\Shared\XMLWriter;
+use PhpOffice\PhpSpreadsheet\Spreadsheet;
+use PhpOffice\PhpSpreadsheet\Worksheet\Worksheet;
+
+class Settings extends WriterPart
+{
+    /**
+     * Write settings.xml to XML format.
+     *
+     * @return string XML Output
+     */
+    public function write(): string
+    {
+        if ($this->getParentWriter()->getUseDiskCaching()) {
+            $objWriter = new XMLWriter(XMLWriter::STORAGE_DISK, $this->getParentWriter()->getDiskCachingDirectory());
+        } else {
+            $objWriter = new XMLWriter(XMLWriter::STORAGE_MEMORY);
+        }
+
+        // XML header
+        $objWriter->startDocument('1.0', 'UTF-8');
+
+        // Settings
+        $objWriter->startElement('office:document-settings');
+        $objWriter->writeAttribute('xmlns:office', 'urn:oasis:names:tc:opendocument:xmlns:office:1.0');
+        $objWriter->writeAttribute('xmlns:xlink', 'http://www.w3.org/1999/xlink');
+        $objWriter->writeAttribute('xmlns:config', 'urn:oasis:names:tc:opendocument:xmlns:config:1.0');
+        $objWriter->writeAttribute('xmlns:ooo', 'http://openoffice.org/2004/office');
+        $objWriter->writeAttribute('office:version', '1.2');
+
+        $objWriter->startElement('office:settings');
+        $objWriter->startElement('config:config-item-set');
+        $objWriter->writeAttribute('config:name', 'ooo:view-settings');
+        $objWriter->startElement('config:config-item-map-indexed');
+        $objWriter->writeAttribute('config:name', 'Views');
+        $objWriter->startElement('config:config-item-map-entry');
+        $spreadsheet = $this->getParentWriter()->getSpreadsheet();
+
+        $objWriter->startElement('config:config-item');
+        $objWriter->writeAttribute('config:name', 'ViewId');
+        $objWriter->writeAttribute('config:type', 'string');
+        $objWriter->text('view1');
+        $objWriter->endElement(); // ViewId
+        $objWriter->startElement('config:config-item-map-named');
+
+        $this->writeAllWorksheetSettings($objWriter, $spreadsheet);
+
+        $wstitle = $spreadsheet->getActiveSheet()->getTitle();
+        $objWriter->startElement('config:config-item');
+        $objWriter->writeAttribute('config:name', 'ActiveTable');
+        $objWriter->writeAttribute('config:type', 'string');
+        $objWriter->text($wstitle);
+        $objWriter->endElement(); // config:config-item ActiveTable
+
+        $objWriter->endElement(); // config:config-item-map-entry
+        $objWriter->endElement(); // config:config-item-map-indexed Views
+        $objWriter->endElement(); // config:config-item-set ooo:view-settings
+        $objWriter->startElement('config:config-item-set');
+        $objWriter->writeAttribute('config:name', 'ooo:configuration-settings');
+        $objWriter->endElement(); // config:config-item-set ooo:configuration-settings
+        $objWriter->endElement(); // office:settings
+        $objWriter->endElement(); // office:document-settings
+
+        return $objWriter->getData();
+    }
+
+    private function writeAllWorksheetSettings(XMLWriter $objWriter, Spreadsheet $spreadsheet): void
+    {
+        $objWriter->writeAttribute('config:name', 'Tables');
+
+        foreach ($spreadsheet->getWorksheetIterator() as $worksheet) {
+            $this->writeWorksheetSettings($objWriter, $worksheet);
+        }
+
+        $objWriter->endElement(); // config:config-item-map-entry Tables
+    }
+
+    private function writeWorksheetSettings(XMLWriter $objWriter, Worksheet $worksheet): void
+    {
+        $objWriter->startElement('config:config-item-map-entry');
+        $objWriter->writeAttribute('config:name', $worksheet->getTitle());
+
+        $this->writeSelectedCells($objWriter, $worksheet);
+        if ($worksheet->getFreezePane() !== null) {
+            $this->writeFreezePane($objWriter, $worksheet);
+        }
+
+        $objWriter->endElement(); // config:config-item-map-entry Worksheet
+    }
+
+    private function writeSelectedCells(XMLWriter $objWriter, Worksheet $worksheet): void
+    {
+        $selected = $worksheet->getSelectedCells();
+        if (preg_match('/^([a-z]+)([0-9]+)/i', $selected, $matches) === 1) {
+            $colSel = Coordinate::columnIndexFromString($matches[1]) - 1;
+            $rowSel = (int) $matches[2] - 1;
+            $objWriter->startElement('config:config-item');
+            $objWriter->writeAttribute('config:name', 'CursorPositionX');
+            $objWriter->writeAttribute('config:type', 'int');
+            $objWriter->text((string) $colSel);
+            $objWriter->endElement();
+            $objWriter->startElement('config:config-item');
+            $objWriter->writeAttribute('config:name', 'CursorPositionY');
+            $objWriter->writeAttribute('config:type', 'int');
+            $objWriter->text((string) $rowSel);
+            $objWriter->endElement();
+        }
+    }
+
+    private function writeSplitValue(XMLWriter $objWriter, string $splitMode, string $type, string $value): void
+    {
+        $objWriter->startElement('config:config-item');
+        $objWriter->writeAttribute('config:name', $splitMode);
+        $objWriter->writeAttribute('config:type', $type);
+        $objWriter->text($value);
+        $objWriter->endElement();
+    }
+
+    private function writeFreezePane(XMLWriter $objWriter, Worksheet $worksheet): void
+    {
+        $freezePane = CellAddress::fromCellAddress($worksheet->getFreezePane());
+        if ($freezePane->cellAddress() === 'A1') {
+            return;
+        }
+
+        $columnId = $freezePane->columnId();
+        $columnName = $freezePane->columnName();
+        $row = $freezePane->rowId();
+
+        $this->writeSplitValue($objWriter, 'HorizontalSplitMode', 'short', '2');
+        $this->writeSplitValue($objWriter, 'HorizontalSplitPosition', 'int', (string) ($columnId - 1));
+        $this->writeSplitValue($objWriter, 'PositionLeft', 'short', '0');
+        $this->writeSplitValue($objWriter, 'PositionRight', 'short', (string) ($columnId - 1));
+
+        for ($column = 'A'; $column !== $columnName; ++$column) {
+            $worksheet->getColumnDimension($column)->setAutoSize(true);
+        }
+
+        $this->writeSplitValue($objWriter, 'VerticalSplitMode', 'short', '2');
+        $this->writeSplitValue($objWriter, 'VerticalSplitPosition', 'int', (string) ($row - 1));
+        $this->writeSplitValue($objWriter, 'PositionTop', 'short', '0');
+        $this->writeSplitValue($objWriter, 'PositionBottom', 'short', (string) ($row - 1));
+
+        $this->writeSplitValue($objWriter, 'ActiveSplitRange', 'short', '3');
+    }
+}

lib/PhpSpreadsheet/Writer/Ods/Styles.php

@@ -0,0 +1,65 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Writer\Ods;
+
+use PhpOffice\PhpSpreadsheet\Shared\XMLWriter;
+
+class Styles extends WriterPart
+{
+    /**
+     * Write styles.xml to XML format.
+     *
+     * @return string XML Output
+     */
+    public function write(): string
+    {
+        $objWriter = null;
+        if ($this->getParentWriter()->getUseDiskCaching()) {
+            $objWriter = new XMLWriter(XMLWriter::STORAGE_DISK, $this->getParentWriter()->getDiskCachingDirectory());
+        } else {
+            $objWriter = new XMLWriter(XMLWriter::STORAGE_MEMORY);
+        }
+
+        // XML header
+        $objWriter->startDocument('1.0', 'UTF-8');
+
+        // Content
+        $objWriter->startElement('office:document-styles');
+        $objWriter->writeAttribute('xmlns:office', 'urn:oasis:names:tc:opendocument:xmlns:office:1.0');
+        $objWriter->writeAttribute('xmlns:style', 'urn:oasis:names:tc:opendocument:xmlns:style:1.0');
+        $objWriter->writeAttribute('xmlns:text', 'urn:oasis:names:tc:opendocument:xmlns:text:1.0');
+        $objWriter->writeAttribute('xmlns:table', 'urn:oasis:names:tc:opendocument:xmlns:table:1.0');
+        $objWriter->writeAttribute('xmlns:draw', 'urn:oasis:names:tc:opendocument:xmlns:drawing:1.0');
+        $objWriter->writeAttribute('xmlns:fo', 'urn:oasis:names:tc:opendocument:xmlns:xsl-fo-compatible:1.0');
+        $objWriter->writeAttribute('xmlns:xlink', 'http://www.w3.org/1999/xlink');
+        $objWriter->writeAttribute('xmlns:dc', 'http://purl.org/dc/elements/1.1/');
+        $objWriter->writeAttribute('xmlns:meta', 'urn:oasis:names:tc:opendocument:xmlns:meta:1.0');
+        $objWriter->writeAttribute('xmlns:number', 'urn:oasis:names:tc:opendocument:xmlns:datastyle:1.0');
+        $objWriter->writeAttribute('xmlns:presentation', 'urn:oasis:names:tc:opendocument:xmlns:presentation:1.0');
+        $objWriter->writeAttribute('xmlns:svg', 'urn:oasis:names:tc:opendocument:xmlns:svg-compatible:1.0');
+        $objWriter->writeAttribute('xmlns:chart', 'urn:oasis:names:tc:opendocument:xmlns:chart:1.0');
+        $objWriter->writeAttribute('xmlns:dr3d', 'urn:oasis:names:tc:opendocument:xmlns:dr3d:1.0');
+        $objWriter->writeAttribute('xmlns:math', 'http://www.w3.org/1998/Math/MathML');
+        $objWriter->writeAttribute('xmlns:form', 'urn:oasis:names:tc:opendocument:xmlns:form:1.0');
+        $objWriter->writeAttribute('xmlns:script', 'urn:oasis:names:tc:opendocument:xmlns:script:1.0');
+        $objWriter->writeAttribute('xmlns:ooo', 'http://openoffice.org/2004/office');
+        $objWriter->writeAttribute('xmlns:ooow', 'http://openoffice.org/2004/writer');
+        $objWriter->writeAttribute('xmlns:oooc', 'http://openoffice.org/2004/calc');
+        $objWriter->writeAttribute('xmlns:dom', 'http://www.w3.org/2001/xml-events');
+        $objWriter->writeAttribute('xmlns:rpt', 'http://openoffice.org/2005/report');
+        $objWriter->writeAttribute('xmlns:of', 'urn:oasis:names:tc:opendocument:xmlns:of:1.2');
+        $objWriter->writeAttribute('xmlns:xhtml', 'http://www.w3.org/1999/xhtml');
+        $objWriter->writeAttribute('xmlns:grddl', 'http://www.w3.org/2003/g/data-view#');
+        $objWriter->writeAttribute('xmlns:tableooo', 'http://openoffice.org/2009/table');
+        $objWriter->writeAttribute('xmlns:css3t', 'http://www.w3.org/TR/css3-text/');
+        $objWriter->writeAttribute('office:version', '1.2');
+
+        $objWriter->writeElement('office:font-face-decls');
+        $objWriter->writeElement('office:styles');
+        $objWriter->writeElement('office:automatic-styles');
+        $objWriter->writeElement('office:master-styles');
+        $objWriter->endElement();
+
+        return $objWriter->getData();
+    }
+}

lib/PhpSpreadsheet/Writer/Ods/Thumbnails.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Writer\Ods;
+
+class Thumbnails extends WriterPart
+{
+    /**
+     * Write Thumbnails/thumbnail.png to PNG format.
+     *
+     * @return string XML Output
+     */
+    public function write(): string
+    {
+        return '';
+    }
+}

lib/PhpSpreadsheet/Writer/Ods/WriterPart.php

@@ -0,0 +1,31 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheet\Writer\Ods;
+
+use PhpOffice\PhpSpreadsheet\Writer\Ods;
+
+abstract class WriterPart
+{
+    /**
+     * Parent Ods object.
+     */
+    private Ods $parentWriter;
+
+    /**
+     * Get Ods writer.
+     */
+    public function getParentWriter(): Ods
+    {
+        return $this->parentWriter;
+    }
+
+    /**
+     * Set parent Ods writer.
+     */
+    public function __construct(Ods $writer)
+    {
+        $this->parentWriter = $writer;
+    }
+
+    abstract public function write(): string;
+}