diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/WordPdfConverter.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/WordPdfConverter.java index 7ca1e25..98cc5cf 100644 --- a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/WordPdfConverter.java +++ b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/WordPdfConverter.java @@ -17,6 +17,7 @@ import ru.pjandro.wordpdf.internal.DependencyGuard; import ru.pjandro.wordpdf.internal.DocxNormalizer; import ru.pjandro.wordpdf.internal.DocxRewritePipeline; import ru.pjandro.wordpdf.internal.doc.DocToDocx; +import ru.pjandro.wordpdf.internal.xlsx.XlsxToDocx; import ru.pjandro.wordpdf.internal.OleObjectNormalizer; import ru.pjandro.wordpdf.internal.FopFallbackFonts; import ru.pjandro.wordpdf.internal.LayoutPostRenderer; @@ -124,14 +125,19 @@ public final class WordPdfConverter { // лимита), затем для .docx — zip/контейнер/страницы, для .doc — // страницы по чистому бинарному документу (до конвертации). WordPdfValidator.validate(docxBytes, opts); - // Бинарный .doc (Word 97–2003): мост internal.doc. Сгенерированный + // Роутинг мостов по классификации входа: бинарный .doc (CFB) — мост + // internal.doc; zip с манифестом spreadsheetml — мост internal.xlsx + // (оценка страниц уже сделана валидатором xlsx-путём). Сгенерированный // .docx — собственный артефакт, его штатной валидацией входа не - // проверяем (вход уже проверен по байтам .doc). Переиспользование слота - // docxBytes: результат моста становится в тот же слот, и сырые байты - // .doc сбрасываются в кадре на этом же месте — детерминированно, до - // рендера (точные liveness-карты HotSpot строит только для - // скомпилированных кадров; отдельное присваивание null не нужно). - docxBytes = WordPdfValidator.isBinaryDoc(docxBytes) ? DocToDocx.convert(docxBytes) : docxBytes; + // проверяем (вход уже проверен по байтам оригинала). Переиспользование + // слота docxBytes: результат моста становится в тот же слот, и сырые + // байты оригинала сбрасываются в кадре на этом же месте — + // детерминированно, до рендера (точные liveness-карты HotSpot строит + // только для скомпилированных кадров; отдельное присваивание null не + // нужно). + docxBytes = WordPdfValidator.isBinaryDoc(docxBytes) ? DocToDocx.convert(docxBytes) + : WordPdfValidator.isSpreadsheet(docxBytes) ? XlsxToDocx.convert(docxBytes, opts) + : docxBytes; ByteArrayOutputStream bos = new ByteArrayOutputStream(Math.max(1 << 16, docxBytes.length)); try { convertToStream(docxBytes, title, opts, bos); diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/ColorSpec.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/ColorSpec.java new file mode 100644 index 0000000..0d8dcae --- /dev/null +++ b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/ColorSpec.java @@ -0,0 +1,72 @@ +package ru.pjandro.wordpdf.internal.xlsx; + +/** + * Цвет элемента {@code color} (ECMA-376 §18.8: CT_Color — атрибуты rgb, + * indexed, theme, auto, tint, shade). Разбор атрибутов отделён от + * вычисления: {@link ColorResolver} превращает спецификацию в + * {@code #RRGGBB} (theme → {@link ThemeModel}, indexed → палитра Excel 97, + * tint/shade → коррекция светлоты). Ни один атрибут не задан — auto + * ({@link #resolve} вернёт {@code null}, Word рисует «auto»). + * + * @param rgb ARGB-хеks (alpha отбрасывается при разборе) или null + * @param indexed значение {@code @indexed} или null + * @param theme значение {@code @theme} или null + * @param tint {@code @tint} ([-1..1]) или null + * @param shade {@code @shade} ([-1..1]) или null + */ +record ColorSpec(String rgb, Integer indexed, Integer theme, Double tint, Double shade) { + + /** auto / не задан. */ + static final ColorSpec AUTO = new ColorSpec(null, null, null, null, null); + + /** Только rgb (без tint/shade) — синтетика генератора/тестов. */ + static ColorSpec rgb(String hex) { + return new ColorSpec(hex, null, null, null, null); + } + + /** + * Разбор атрибутов элемента {@code color} (CT_Color) с текущей позиции + * StAX-читателя: rgb/indexed/theme/tint/shade. Числовые значения, + * не парсящиеся как double, — null (битый атрибут не роняет документ). + */ + static ColorSpec fromColorElement(javax.xml.stream.XMLStreamReader xr) { + String rgb = XlsxPackage.attr(xr, "rgb"); + String indexed = XlsxPackage.attr(xr, "indexed"); + String theme = XlsxPackage.attr(xr, "theme"); + Double tint = parseDouble(XlsxPackage.attr(xr, "tint")); + Double shade = parseDouble(XlsxPackage.attr(xr, "shade")); + Integer idx = parseInt(indexed); + Integer th = parseInt(theme); + if (rgb == null && idx == null && th == null && tint == null && shade == null) { + return AUTO; + } + return new ColorSpec(rgb, idx, th, tint, shade); + } + + static Integer parseInt(String s) { + if (s == null) { + return null; + } + try { + return Integer.valueOf(s); + } catch (NumberFormatException e) { + return null; + } + } + + static Double parseDouble(String s) { + if (s == null) { + return null; + } + try { + return Double.valueOf(s); + } catch (NumberFormatException e) { + return null; + } + } + + /** Есть ли хоть один источник цвета. */ + boolean isEmpty() { + return rgb == null && indexed == null && theme == null; + } +} diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/Metrics.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/Metrics.java new file mode 100644 index 0000000..993287c --- /dev/null +++ b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/Metrics.java @@ -0,0 +1,109 @@ +package ru.pjandro.wordpdf.internal.xlsx; + +import ru.pjandro.wordpdf.fonts.BundledFonts; +import ru.pjandro.wordpdf.fonts.GlyphFont; + +/** + * Метрики ширины столбцов .xlsx в пиксели/ twips. MDW (max digit width, + * ECMA-376 §18.3.1.13 note) — максимальная ширина цифры Normal-семейства + * (шрифт стиля Normal после алиасов бандла; дефолт Calibri→Carlito, 11 pt, + * 96 dpi, fontbox-движок {@link GlyphFont}; сбой чтения — 7 px, ровно + * Calibri 11). + * + *

Формула px (прямая инверсия {@code width}, MS-OI29500 §2.1.598-f и + * «Column Width» Office): + * {@code px = Truncate((256·w + Truncate(128/MDW)) / 256 · MDW) + 5} — + * +5 = 2×2 px полей + 1 px гридлайнов; при w=8.43, MDW=7 даёт канонические + * 64 px. Столбец без {@code @width} = {@code baseColWidth} + паддинг-часть + * (0.43 знака при MDW=7 — та же формула, решённая для ширины по умолчанию), + * {@code @hidden} — 0 px (скрытый столбец не печатается).

+ */ +final class Metrics { + + /** Fallback MDW (px) при недоступности fontbox/шрифта. */ + static final int FALLBACK_MDW = 7; + /** Epsilon ширины по умолчанию: паддинг 5 px в знаках при MDW=7. */ + private static final double DEFAULT_WIDTH_PAD = 0.43; + + private final int mdw; + + private Metrics(int mdw) { + this.mdw = mdw; + } + + /** + * MDW по семейству стиля Normal: имя → алиасы бандла (маленький регистр), + * отсутствующее семейство — Carlito (алиас Calibri). + */ + static Metrics forNormalFamily(String familyName) { + int px; + try { + BundledFonts.init(); + GlyphFont f = bundled(familyName); + double max = 0; + for (int d = '0'; d <= '9'; d++) { + max = Math.max(max, f.advance(String.valueOf((char) d), 11.0)); + } + px = (int) Math.max(1, Math.round(max * 96.0 / 72.0)); + } catch (RuntimeException e) { + px = FALLBACK_MDW; + } + return new Metrics(px); + } + + /** Шрифт бандла по имени (lowercase) с фолбэком Carlito; null невозможен. */ + private static GlyphFont bundled(String familyName) { + GlyphFont f = familyName == null ? null + : GlyphFont.of(familyName.toLowerCase(java.util.Locale.ROOT), + BundledFonts.V_REGULAR); + if (f == null) { + f = GlyphFont.of("carlito", BundledFonts.V_REGULAR); + } + if (f == null) { + throw new IllegalStateException("Бандл без Carlito"); + } + return f; + } + + /** MDW в px. */ + int mdw() { + return mdw; + } + + /** + * Ширина столбца в px: hidden — 0; {@code widthChars == null} — + * дефолт {@code baseColWidth + pad}. + */ + int colWidthPx(Double widthChars, double baseColWidth, boolean hidden) { + if (hidden) { + return 0; + } + double w = widthChars == null ? baseColWidth + DEFAULT_WIDTH_PAD : widthChars; + return (int) Math.floor((256.0 * w + Math.floor(128.0 / mdw)) / 256.0 * mdw) + 5; + } + + /** Дефолтная ширина столбца (px) — та же формула без {@code @width}. */ + int defaultWidthPx(double baseColWidth) { + return colWidthPx(null, baseColWidth, false); + } + + /** Пиксели в twips (96 dpi → 1/20 pt: 1 px = 15 twips). */ + static int pxToTwips(int px) { + return px * 15; + } + + /** Пиксели в EMU (1 px = 9525 EMU, ECMA-376 Part 1 §20.1.1.77-ish). */ + static long pxToEmu(int px) { + return px * 9525L; + } + + /** Пункты в twips. */ + static int ptToTwips(double pt) { + return (int) Math.round(pt * 20.0); + } + + /** Дюймы в twips. */ + static int inchesToTwips(double inches) { + return (int) Math.round(inches * 1440.0); + } +} diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/NumberText.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/NumberText.java new file mode 100644 index 0000000..6632d2e --- /dev/null +++ b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/NumberText.java @@ -0,0 +1,77 @@ +package ru.pjandro.wordpdf.internal.xlsx; + +/** + * General-вывод значения ячейки (§18.8.30 примечания) и текстовые типы: + * число — кратчайкая round-trip запись без хвостовых нулей; |x| ≥ 1e10 или + * ≠0 и < 1e-9 — научный с 10 знаками (как Excel General). Полный + * движок форматных кодов — {@link NumberFormats}; здесь — то, что едет + * при {@code numFmt="General"} и в fallback'ах. + */ +final class NumberText { + + private NumberText() { + } + + /** + * Текст ячейки по типу {@code @t}: {@code b} — TRUE/FALSE, {@code e} — + * сырая ошибка, {@code str} — строка кэша формулы, число (null/"n") — + * General. {@code s}/{@code inlineStr} сюда не доходят (раны), + * {@code d} — ISO-строка как есть (парсинг дат — {@link NumberFormats}). + */ + static String of(String raw, String type) { + if (raw == null) { + return ""; + } + return switch (type == null ? "" : type) { + case "b" -> "1".equals(raw.trim()) ? "TRUE" : "FALSE"; + case "e", "str", "d" -> raw; + default -> general(raw); + }; + } + + /** General по сырой строке {@code v}: парсится в double — форматим, нет — как есть. */ + static String general(String raw) { + double value; + try { + value = Double.parseDouble(raw.trim()); + } catch (NumberFormatException e) { + return raw; + } + if (value == Math.rint(value) && !Double.isInfinite(value) + && Math.abs(value) < 1e15) { + return Long.toString((long) value); + } + return decimalOrScientific(value); + } + + /** + * Дробное: shortest round-trip без хвостовых нулей; диапазон — научный + * {@code 0.##########E+xx} (10 значащих знаков, экспонента с знаком и + * минимум двумя цифрами — Excel General). + */ + static String decimalOrScientific(double value) { + double abs = Math.abs(value); + if (abs == 0 || abs < 1e10 && abs >= 1e-9) { + return shortestRepr(value); + } + String sci = String.format(java.util.Locale.ROOT, "%.9E", value); + int e = sci.indexOf('E'); + double mantissa = Double.parseDouble(sci.substring(0, e)); + int exponent = Integer.parseInt(sci.substring(e + 1)); + String mant = shortestRepr(mantissa).replace("-", "-"); + return mant + "E" + (exponent < 0 ? "-" : "+") + + String.format(java.util.Locale.ROOT, "%02d", Math.abs(exponent)); + } + + /** Кратчайая десятичная запись double без хвостового «.0». */ + private static String shortestRepr(double value) { + String s = Double.toString(value); + if (s.indexOf('E') >= 0 || s.indexOf('e') >= 0) { + return s; + } + if (s.endsWith(".0")) { + return s.substring(0, s.length() - 2); + } + return s; + } +} diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/SharedStrings.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/SharedStrings.java new file mode 100644 index 0000000..3373de1 --- /dev/null +++ b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/SharedStrings.java @@ -0,0 +1,200 @@ +package ru.pjandro.wordpdf.internal.xlsx; + +import javax.xml.stream.XMLStreamConstants; +import javax.xml.stream.XMLStreamException; +import javax.xml.stream.XMLStreamReader; +import java.io.ByteArrayInputStream; +import java.io.IOException; +import java.util.ArrayList; +import java.util.List; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * {@code xl/sharedStrings.xml} (ECMA-376 §18.5): таблица строк {@code sst}, + * элемент {@code si} — plain-{@code t} или rich-раны {@code r} (§18.4.1: + * {@code r/t} + {@code rPr}). Ран сохраняется списком {@link Run} (стили + * не схлопываются — Word рисует rich-строку несколькими {@code w:r}). + * Фонетика {@code rPh} вырезается (как руби в правиле 10 — надстрочница + * в PDF не печатается). + * + *

Тот же разбор {@code CT_Rst} используется для inlineStr-ячеек + * ( worksheet §18.3.1.53 {@code is} — та же структура), см. + * {@link #parseRst(XMLStreamReader, WarnOnce)}.

+ */ +final class SharedStrings { + + /** Фрагмент rich-строки; {@code style == null} — стиль ячейки. */ + record Run(String text, RunStyle style) { + } + + /** Переопределение rPr rich-рана (ECMA-376 §18.4.8 CT_RPrElt). */ + record RunStyle(Boolean bold, Boolean italic, String underline, Boolean strikeout, + Double sizePt, ColorSpec color, String fontName, String vertAlign) { + + boolean isEmpty() { + return bold == null && italic == null && underline == null && strikeout == null + && sizePt == null && (color == null || color.isEmpty()) + && fontName == null && vertAlign == null; + } + } + + private static final Logger LOG = LoggerFactory.getLogger(SharedStrings.class); + private static final String SST_PART = "xl/sharedStrings.xml"; + static final List NO_RUNS = List.of(); + + private final List> items; + + private SharedStrings(List> items) { + this.items = items; + } + + static SharedStrings read(XlsxPackage pkg, WarnOnce warn) throws IOException { + byte[] data = pkg.entry(SST_PART); + List> items = new ArrayList<>(); + if (data == null) { + return new SharedStrings(items); + } + try { + XMLStreamReader xr = XlsxPackage.newSecureReader() + .createXMLStreamReader(new ByteArrayInputStream(data)); + while (xr.hasNext()) { + if (xr.next() == XMLStreamReader.START_ELEMENT + && "si".equals(xr.getLocalName())) { + items.add(parseRst(xr, warn)); + } + } + xr.close(); + } catch (XMLStreamException e) { + throw new IOException("Не удалось разобрать xl/sharedStrings.xml", e); + } + return new SharedStrings(items); + } + + /** Строка по индексу SST; индекс за таблицей — пусто + warn (§18.5). */ + List at(int index, WarnOnce warn) { + if (index < 0 || index >= items.size()) { + warn.warn(LOG, "Индекс shared string {} вне таблицы ({} записей) — пустая строка", + index, items.size()); + return NO_RUNS; + } + return items.get(index); + } + + /** + * Разбор {@code CT_Rst} с текущей позиции (читатель стоит на START + * {@code si}/{@code is}): plain-{@code t}, ран {@code r} (текст + rPr), + * {@code rPh} — вырезается. Вызов потребляет элемент целиком. + */ + static List parseRst(XMLStreamReader xr, WarnOnce warn) throws XMLStreamException { + List runs = new ArrayList<>(); + StringBuilder plain = new StringBuilder(); + while (xr.hasNext()) { + int ev = xr.next(); + if (ev == XMLStreamConstants.END_ELEMENT) { + break; + } + if (ev != XMLStreamConstants.START_ELEMENT) { + continue; + } + switch (xr.getLocalName()) { + case "t" -> plain.append(xr.getElementText()); + case "r" -> runs.add(parseRun(xr)); + case "rPh" -> skipElement(xr); + default -> skipElement(xr); + } + } + if (plain.length() > 0) { + runs.add(0, new Run(plain.toString(), null)); + } + return runs; + } + + /** Ран {@code r}: текст из {@code t}, переопределения из {@code rPr}. */ + private static Run parseRun(XMLStreamReader xr) throws XMLStreamException { + StringBuilder text = new StringBuilder(); + RunStyle style = null; + while (xr.hasNext()) { + int ev = xr.next(); + if (ev == XMLStreamConstants.END_ELEMENT) { + break; + } + if (ev != XMLStreamConstants.START_ELEMENT) { + continue; + } + String name = xr.getLocalName(); + switch (name) { + case "t" -> text.append(xr.getElementText()); + case "rPr" -> style = parseRPr(xr); + default -> skipElement(xr); + } + } + return new Run(text.toString(), style != null && !style.isEmpty() ? style : null); + } + + /** {@code CT_RPrElt}: b, i, u, strike, sz, color, vertAlign, rFont. */ + private static RunStyle parseRPr(XMLStreamReader xr) throws XMLStreamException { + Boolean bold = null; + Boolean italic = null; + String underline = null; + Boolean strikeout = null; + Double size = null; + ColorSpec color = null; + String font = null; + String vertAlign = null; + while (xr.hasNext()) { + int ev = xr.next(); + if (ev == XMLStreamConstants.END_ELEMENT) { + break; + } + if (ev != XMLStreamConstants.START_ELEMENT) { + continue; + } + switch (xr.getLocalName()) { + case "b" -> bold = boolVal(xr); + case "i" -> italic = boolVal(xr); + case "strike" -> strikeout = boolVal(xr); + case "u" -> { + String v = XlsxPackage.attr(xr, "val"); + underline = v == null || "none".equals(v) ? null : v; + } + case "sz" -> size = ColorSpec.parseDouble(XlsxPackage.attr(xr, "val")); + case "color" -> color = ColorSpec.fromColorElement(xr); + case "vertAlign" -> { + String v = XlsxPackage.attr(xr, "val"); + vertAlign = v == null || "baseline".equals(v) ? null : v; + } + case "rFont" -> font = XlsxPackage.attr(xr, "val"); + default -> { + } + } + // дочерний листок (b/sz/color/…) обязан быть потреблён целиком, + // иначе его END досрочно прервёт разбор rPr + skipElement(xr); + } + return new RunStyle(bold, italic, underline, strikeout, size, color, font, vertAlign); + } + + /** Три-state булева атрибута {@code @val}: absent — true, none/0/false — false. */ + static Boolean boolVal(XMLStreamReader xr) { + String v = XlsxPackage.attr(xr, "val"); + if (v == null) { + return Boolean.TRUE; + } + return !("0".equals(v) || "false".equalsIgnoreCase(v) || "none".equalsIgnoreCase(v)); + } + + /** Потребить элемент с текущей позиции (START) до его END. */ + static void skipElement(XMLStreamReader xr) throws XMLStreamException { + int depth = 1; + while (xr.hasNext() && depth > 0) { + int ev = xr.next(); + if (ev == XMLStreamConstants.START_ELEMENT) { + depth++; + } else if (ev == XMLStreamConstants.END_ELEMENT) { + depth--; + } + } + } +} diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/SheetModel.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/SheetModel.java new file mode 100644 index 0000000..d10fdc3 --- /dev/null +++ b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/SheetModel.java @@ -0,0 +1,500 @@ +package ru.pjandro.wordpdf.internal.xlsx; + +import javax.xml.stream.XMLStreamConstants; +import javax.xml.stream.XMLStreamException; +import javax.xml.stream.XMLStreamReader; +import java.io.ByteArrayInputStream; +import java.io.IOException; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.TreeMap; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * One worksheet part (§18.3.1): структура листа целиком — колонки/строки/ + * ячейки, merge'ы, внешние гиперссылки, ручные разрывы строк, page setup и + * ссылки на drawing/OLE. Разбор StAX; любые не разобранные части — + * «пустой лист»/игнор по деградационному контракту моста. + * + *

Ячейка хранится СЫРОЙ строкой {@code v}/{@code is} + типом {@code @t}: + * форматирование чисел/дат — {@link NumberFormats} на этапе эмитта (формула + * без кэша {@code } — пустая ячейка + warn).

+ */ +final class SheetModel { + + /** Колонка {@code cols/col} (range развёрнут по индексам). */ + record ColDef(Double width, boolean hidden, Integer style) { + } + + /** Ячейка {@code c} (§18.3.1.4): сырое значение, rich-раны, тип, индекс xf. */ + record CellData(String raw, List runs, String type, Integer styleIdx) { + } + + /** Строка {@code row} (§18.3.1.73): индекс 1-based {@code @r} → данные. */ + record RowData(Double ht, boolean customHeight, boolean hidden, Integer styleIdx, + boolean customFormat, Map cells) { + + /** Стиль строки, применяемый к ячейкам без своего (только при {@code @customFormat}). */ + Integer effectiveStyle() { + return customFormat ? styleIdx : null; + } + } + + /** Прямоугольник merge'а (§18.3.1.54), индексы 0-based включительно. */ + record Merge(int row1, int row2, int col1, int col2) { + } + + /** {@code pageSetup} (§18.3.1.63) + {@code pageSetUpPr/@fitToPage}. */ + record PageSetup(int paperSize, boolean landscape, int scale, int fitToWidth, + int fitToHeight, boolean fitToPage) { + } + + /** {@code pageMargins} в дюймах (§18.3.1.67). */ + record Margins(double left, double right, double top, double bottom, + double header, double footer) { + } + + private static final Logger LOG = LoggerFactory.getLogger(SheetModel.class); + private static final String REL_NS = + "http://schemas.openxmlformats.org/officeDocument/2006/relationships"; + private static final String HYPERLINK_REL_TYPE = + "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink"; + /** Дефициты pageMargins по §18.3.1.67. */ + private static final double DEF_MARGIN_LR = 0.7; + private static final double DEF_MARGIN_TB = 0.75; + private static final double DEF_MARGIN_HF = 0.3; + /** Дефолт sheetFormatPr/@defaultRowHeight (pt) и @baseColWidth (знаков). */ + private static final double DEF_ROW_HEIGHT = 15.0; + private static final double DEF_BASE_COL_WIDTH = 8.0; + + private final TreeMap rows = new TreeMap<>(); + private final Map cols = new HashMap<>(); + private final List merges = new ArrayList<>(); + private final Map externalLinks = new HashMap<>(); + private final List rowBreaks = new ArrayList<>(); + private double defaultRowHeight = DEF_ROW_HEIGHT; + private double baseColWidth = DEF_BASE_COL_WIDTH; + private PageSetup pageSetup = new PageSetup(9, false, 100, 1, 1, false); + private Margins margins = new Margins(DEF_MARGIN_LR, DEF_MARGIN_LR, + DEF_MARGIN_TB, DEF_MARGIN_TB, DEF_MARGIN_HF, DEF_MARGIN_HF); + private String drawingPath; + private boolean olePresent; + /** Максимальный использованный индекс колонки+1 (0 — ячеек нет). */ + private int usedCols; + + private SheetModel() { + } + + TreeMap rows() { + return rows; + } + + Map cols() { + return cols; + } + + List merges() { + return merges; + } + + Map externalLinks() { + return externalLinks; + } + + List rowBreaks() { + return rowBreaks; + } + + double defaultRowHeight() { + return defaultRowHeight; + } + + double baseColWidth() { + return baseColWidth; + } + + PageSetup pageSetup() { + return pageSetup; + } + + Margins margins() { + return margins; + } + + String drawingPath() { + return drawingPath; + } + + boolean olePresent() { + return olePresent; + } + + int usedCols() { + return usedCols; + } + + ColDef col(int index) { + return cols.get(index); + } + + /** Стиль колонки (индекс xf) или null. */ + Integer colStyle(int index) { + ColDef c = cols.get(index); + return c == null ? null : c.style(); + } + + static SheetModel read(XlsxPackage pkg, WorkbookModel.Sheet sheet, WarnOnce warn) + throws IOException { + byte[] data = pkg.entry(sheet.partPath()); + SheetModel model = new SheetModel(); + if (data == null) { + warn.warn(LOG, "Часть листа {} отсутствует — пустой лист", sheet.partPath()); + return model; + } + Map sheetLinks = hyperlinkTargets(pkg, sheet.partPath()); + try { + XMLStreamReader xr = XlsxPackage.newSecureReader() + .createXMLStreamReader(new ByteArrayInputStream(data)); + model.parse(xr, sheetLinks, warn, pkg, sheet.partPath()); + xr.close(); + } catch (XMLStreamException e) { + throw new IOException("Не удалось разобрать часть листа " + sheet.partPath(), e); + } + return model; + } + + /** ref ячейки → внешний target гиперссылки (rel part-листа). */ + private static Map hyperlinkTargets(XlsxPackage pkg, String sheetPart) { + Map byId = new HashMap<>(); + for (XlsxPackage.Rel rel : pkg.rels(sheetPart)) { + if (HYPERLINK_REL_TYPE.equals(rel.type()) && rel.external()) { + byId.putIfAbsent(rel.id(), rel.target()); + } + } + return byId; + } + + private void parse(XMLStreamReader xr, Map sheetLinks, WarnOnce warn, + XlsxPackage pkg, String sheetPart) throws XMLStreamException { + boolean rootOpen = false; + while (!rootOpen && xr.hasNext()) { + // до START корня worksheet + rootOpen = xr.next() == XMLStreamConstants.START_ELEMENT; + } + // корень уже открыт — диспатчим только его детей (иначе default-skip + // проглотит весь документ) + while (xr.hasNext()) { + if (xr.next() != XMLStreamConstants.START_ELEMENT) { + continue; + } + switch (xr.getLocalName()) { + case "sheetPr" -> parseSheetPr(xr); + case "sheetFormatPr" -> parseSheetFormatPr(xr); + case "cols" -> parseCols(xr, warn); + case "sheetData" -> parseSheetData(xr, warn); + case "mergeCells" -> parseMergeCells(xr); + case "hyperlinks" -> parseHyperlinks(xr, sheetLinks); + case "drawing" -> { + String rid = XlsxPackage.attrNs(xr, REL_NS, "id"); + drawingPath = rid == null ? null : pkg.relTargetPath(sheetPart, rid); + } + case "rowBreaks" -> parseRowBreaks(xr); + case "pageMargins" -> parsePageMargins(xr); + case "pageSetup" -> parsePageSetup(xr); + case "printOptions" -> parsePrintOptions(xr, warn); + case "legacyDrawing", "legacyDrawingHF", "oleObjects", "controls" -> + olePresent = true; + default -> SharedStrings.skipElement(xr); + } + } + } + + private void parseSheetPr(XMLStreamReader xr) throws XMLStreamException { + while (xr.hasNext()) { + int ev = xr.next(); + if (ev == XMLStreamConstants.END_ELEMENT) { + break; + } + if (ev == XMLStreamConstants.START_ELEMENT && "pageSetUpPr".equals(xr.getLocalName())) { + boolean fit = XlsxPackage.truthy(XlsxPackage.attr(xr, "fitToPage")); + pageSetup = new PageSetup(pageSetup.paperSize(), pageSetup.landscape(), + pageSetup.scale(), pageSetup.fitToWidth(), pageSetup.fitToHeight(), fit); + SharedStrings.skipElement(xr); + } else if (ev == XMLStreamConstants.START_ELEMENT) { + SharedStrings.skipElement(xr); + } + } + } + + private void parseSheetFormatPr(XMLStreamReader xr) { + Double h = ColorSpec.parseDouble(XlsxPackage.attr(xr, "defaultRowHeight")); + if (h != null && h > 0) { + defaultRowHeight = h; + } + Double b = ColorSpec.parseDouble(XlsxPackage.attr(xr, "baseColWidth")); + if (b != null && b > 0) { + baseColWidth = b; + } + } + + private void parseCols(XMLStreamReader xr, WarnOnce warn) throws XMLStreamException { + while (xr.hasNext()) { + int ev = xr.next(); + if (ev == XMLStreamConstants.END_ELEMENT) { + break; + } + if (ev != XMLStreamConstants.START_ELEMENT || !"col".equals(xr.getLocalName())) { + continue; + } + Integer min = ColorSpec.parseInt(XlsxPackage.attr(xr, "min")); + Integer max = ColorSpec.parseInt(XlsxPackage.attr(xr, "max")); + Double width = ColorSpec.parseDouble(XlsxPackage.attr(xr, "width")); + boolean hidden = XlsxPackage.truthy(XlsxPackage.attr(xr, "hidden")); + Integer style = ColorSpec.parseInt(XlsxPackage.attr(xr, "style")); + SharedStrings.skipElement(xr); // листок col доедает свой END + if (min == null || min < 1) { + continue; + } + int hi = max == null || max < min ? min : max; + ColDef def = new ColDef(width, hidden, style); + for (int i = min - 1; i < hi; i++) { + // пересечение записей col — первая выигрывает (Excel пишет + // непересекающиеся; пересечение — брак генератора) + if (cols.putIfAbsent(i, def) == null) { + continue; + } + warn.warn(LOG, "Перекрывающаяся запись col для индекса {} — первая выигрывает", i); + } + } + } + + private void parseSheetData(XMLStreamReader xr, WarnOnce warn) throws XMLStreamException { + while (xr.hasNext()) { + int ev = xr.next(); + if (ev == XMLStreamConstants.END_ELEMENT) { + break; + } + if (ev != XMLStreamConstants.START_ELEMENT || !"row".equals(xr.getLocalName())) { + continue; + } + Integer r = ColorSpec.parseInt(XlsxPackage.attr(xr, "r")); + if (r == null || r < 1) { + continue; + } + Double ht = ColorSpec.parseDouble(XlsxPackage.attr(xr, "ht")); + boolean customHeight = XlsxPackage.truthy(XlsxPackage.attr(xr, "customHeight")); + boolean hidden = XlsxPackage.truthy(XlsxPackage.attr(xr, "hidden")); + Integer rowStyle = ColorSpec.parseInt(XlsxPackage.attr(xr, "s")); + boolean customFormat = XlsxPackage.truthy(XlsxPackage.attr(xr, "customFormat")); + Map cells = new HashMap<>(); + parseCells(xr, cells, warn); + rows.put(r, new RowData(ht, customHeight, hidden, rowStyle, customFormat, cells)); + } + } + + /** Дочерние {@code c} текущей {@code row}; вызов на START row, выход на END row. */ + private void parseCells(XMLStreamReader xr, Map cells, WarnOnce warn) + throws XMLStreamException { + while (xr.hasNext()) { + int ev = xr.next(); + if (ev == XMLStreamConstants.END_ELEMENT) { + break; + } + if (ev != XMLStreamConstants.START_ELEMENT || !"c".equals(xr.getLocalName())) { + continue; + } + String ref = XlsxPackage.attr(xr, "r"); + Integer style = ColorSpec.parseInt(XlsxPackage.attr(xr, "s")); + String type = XlsxPackage.attr(xr, "t"); + int[] rc = parseRef(ref); + int col = rc.length == 0 ? cells.size() : rc[1]; + CellData cell = readCell(xr, type, style, warn); + cells.put(col, cell); + usedCols = Math.max(usedCols, col + 1); + } + } + + /** Дети ячейки: v/is/f — вызов на START c. */ + private CellData readCell(XMLStreamReader xr, String type, Integer style, WarnOnce warn) + throws XMLStreamException { + String v = null; + List runs = null; + boolean hasFormula = false; + while (xr.hasNext()) { + int ev = xr.next(); + if (ev == XMLStreamConstants.END_ELEMENT) { + break; + } + if (ev != XMLStreamConstants.START_ELEMENT) { + continue; + } + switch (xr.getLocalName()) { + case "v" -> v = xr.getElementText(); + case "is" -> runs = SharedStrings.parseRst(xr, warn); + case "f" -> { + hasFormula = true; + SharedStrings.skipElement(xr); + } + default -> SharedStrings.skipElement(xr); // r (formula2) — игнор + } + } + if (v == null && runs == null && hasFormula) { + warn.warn(LOG, "Формула без кэшированного значения — пустая ячейка"); + } + return new CellData(v, runs, type, style); + } + + private void parseMergeCells(XMLStreamReader xr) throws XMLStreamException { + while (xr.hasNext()) { + int ev = xr.next(); + if (ev == XMLStreamConstants.END_ELEMENT) { + break; + } + if (ev == XMLStreamConstants.START_ELEMENT + && "mergeCell".equals(xr.getLocalName())) { + String ref = XlsxPackage.attr(xr, "ref"); + SharedStrings.skipElement(xr); + int[] range = parseRange(ref); + if (range.length > 0) { + merges.add(new Merge(range[0], range[2], range[1], range[3])); + } + } + } + } + + private void parseHyperlinks(XMLStreamReader xr, Map sheetLinks) + throws XMLStreamException { + while (xr.hasNext()) { + int ev = xr.next(); + if (ev == XMLStreamConstants.END_ELEMENT) { + break; + } + if (ev != XMLStreamConstants.START_ELEMENT + || !"hyperlink".equals(xr.getLocalName())) { + continue; + } + String ref = XlsxPackage.attr(xr, "ref"); + String rid = XlsxPackage.attrNs(xr, REL_NS, "id"); + SharedStrings.skipElement(xr); + // @location (внутренний переход) — бросается без warn: PDF-ссылок + // внутри документа мост не эмитит (деградация v1) + if (ref != null && rid != null) { + String target = sheetLinks.get(rid); + if (target != null) { + externalLinks.put(ref, target); + } + } + } + } + + /** id ручных разрывов строк (1-based, семантика — см. SheetToTable). */ + private void parseRowBreaks(XMLStreamReader xr) throws XMLStreamException { + while (xr.hasNext()) { + int ev = xr.next(); + if (ev == XMLStreamConstants.END_ELEMENT) { + break; + } + if (ev == XMLStreamConstants.START_ELEMENT && "brk".equals(xr.getLocalName())) { + String man = XlsxPackage.attr(xr, "man"); + Integer id = ColorSpec.parseInt(XlsxPackage.attr(xr, "id")); + SharedStrings.skipElement(xr); + // man absent/truthy — ручной; id — 1-based номер строки, после + // которой разрыв (POI setRowBreak(11) → id=12, фикстура xlsx-wide) + if (id != null && id >= 1 + && !"0".equals(man) && !"false".equalsIgnoreCase(man)) { + rowBreaks.add(id); + } + } + } + } + + private void parsePageMargins(XMLStreamReader xr) { + Double left = ColorSpec.parseDouble(XlsxPackage.attr(xr, "left")); + Double right = ColorSpec.parseDouble(XlsxPackage.attr(xr, "right")); + Double top = ColorSpec.parseDouble(XlsxPackage.attr(xr, "top")); + Double bottom = ColorSpec.parseDouble(XlsxPackage.attr(xr, "bottom")); + Double header = ColorSpec.parseDouble(XlsxPackage.attr(xr, "header")); + Double footer = ColorSpec.parseDouble(XlsxPackage.attr(xr, "footer")); + margins = new Margins( + left == null ? DEF_MARGIN_LR : left, + right == null ? DEF_MARGIN_LR : right, + top == null ? DEF_MARGIN_TB : top, + bottom == null ? DEF_MARGIN_TB : bottom, + header == null ? DEF_MARGIN_HF : header, + footer == null ? DEF_MARGIN_HF : footer); + } + + private void parsePageSetup(XMLStreamReader xr) { + Integer paper = ColorSpec.parseInt(XlsxPackage.attr(xr, "paperSize")); + boolean landscape = "landscape".equals(XlsxPackage.attr(xr, "orientation")); + Integer scale = ColorSpec.parseInt(XlsxPackage.attr(xr, "scale")); + Integer fitW = ColorSpec.parseInt(XlsxPackage.attr(xr, "fitToWidth")); + Integer fitH = ColorSpec.parseInt(XlsxPackage.attr(xr, "fitToHeight")); + pageSetup = new PageSetup(paper == null ? 9 : paper, landscape, + scale == null ? 100 : scale, + fitW == null ? 1 : fitW, fitH == null ? 1 : fitH, pageSetup.fitToPage()); + } + + private void parsePrintOptions(XMLStreamReader xr, WarnOnce warn) { + if (XlsxPackage.truthy(XlsxPackage.attr(xr, "horizontalCentered")) + && !"0".equals(XlsxPackage.attr(xr, "horizontalCentered"))) { + warn.warn(LOG, "horizontalCentered игнорируется (центрирование страниц в v1 не эмитится)"); + } + if (XlsxPackage.truthy(XlsxPackage.attr(xr, "verticalCentered")) + && !"0".equals(XlsxPackage.attr(xr, "verticalCentered"))) { + warn.warn(LOG, "verticalCentered игнорируется"); + } + if (XlsxPackage.truthy(XlsxPackage.attr(xr, "gridLines")) + && !"0".equals(XlsxPackage.attr(xr, "gridLines"))) { + warn.warn(LOG, "gridLines при печати игнорируется (сетка ячеек не рисуется)"); + } + } + + /** + * ref ячейки/якоря {@code "AB12"} → {row, col} (0-based); битый ref — + * пустой массив (PMD: null-массивов нет). + */ + static int[] parseRef(String ref) { + if (ref == null || ref.isEmpty()) { + return new int[0]; + } + int letters = 0; + while (letters < ref.length() && Character.isLetter(ref.charAt(letters))) { + letters++; + } + if (letters == 0 || letters == ref.length()) { + return new int[0]; + } + int col = 0; + for (int i = 0; i < letters; i++) { + col = col * 26 + Character.toUpperCase(ref.charAt(i)) - 'A' + 1; + } + Integer row = ColorSpec.parseInt(ref.substring(letters)); + if (row == null || row < 1) { + return new int[0]; + } + return new int[] {row - 1, col - 1}; + } + + /** Диапазон {@code "B2:D2"} → {r1,c1,r2,c2} (0-based); битый — пустой массив. */ + static int[] parseRange(String range) { + if (range == null || range.isEmpty()) { + return new int[0]; + } + String[] parts = range.split(":"); + int[] a = parseRef(parts[0].trim()); + if (a.length == 0) { + return new int[0]; + } + int[] b = parts.length > 1 ? parseRef(parts[1].trim()) : a; + if (b.length == 0) { + b = a; + } + return new int[] {Math.min(a[0], b[0]), Math.min(a[1], b[1]), + Math.max(a[0], b[0]), Math.max(a[1], b[1])}; + } +} diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/SheetToTable.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/SheetToTable.java new file mode 100644 index 0000000..06eed24 --- /dev/null +++ b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/SheetToTable.java @@ -0,0 +1,426 @@ +package ru.pjandro.wordpdf.internal.xlsx; + +import java.util.ArrayList; +import java.util.LinkedHashSet; +import java.util.List; +import ru.pjandro.wordpdf.internal.DocxPackageWriter; + +/** + * Эмитт листа в Word-таблицу фиксированной сетки: одна {@code w:tbl} на лист + * (каркас v1 — шаг 4: значения, шрифт, jc, merge, скрытые строки/столбцы, + * внешние гиперссылки; полные границы/заливки/цвета/numFmt/vAlign — шаг 5, + * нарезка на срезы и секции — шаг 6). + * + *

Разрывы строк {@code rowBreaks/@id}: семантика Excel — id это 1-based + * номер строки, ПОСЛЕ которой печатная страница обрывается (POI + * {@code setRowBreak(11)} пишет {@code id="12"}; фикстура xlsx-wide, + * регрессия — XlsxPdfConverterTest#rowBreak_pages). Резку выполняет + * планировщик блоков шага 6.

+ */ +final class SheetToTable { + + /** Роль ячейки в merge-прямоугольнике. */ + private enum MergeRole { NONE, ORIGIN, H_CONT, V_CONT } + + /** Дефолт CT_Font/@sz при отсутствии таблицы шрифтов. */ + private static final double DEFAULT_SIZE_PT = 11.0; + + /** gridSpan одиночной ячейки не эмитится (§17.4.76: по умолчанию 1). */ + private static final int SINGLE_CELL_SPAN = 1; + + private SheetToTable() { + } + + /** + * Фрагмент {@code } для листа: таблица (+ рисунки — шаг 7). + * Пустой лист — пустая строка (секция шага 6 даст свою страницу). + * + * @param hyperlinks дедуплицированный порядок targets внешних ссылок + * (id {@code hl0…} = позиция множества) + */ + static String emit(SheetModel sheet, StylesModel styles, SharedStrings sst, + WorkbookModel wb, Metrics metrics, List parts, + LinkedHashSet hyperlinks, WarnOnce warn) { + int totalCols = totalColumns(sheet); + List visibleCols = new ArrayList<>(); + for (int c = 0; c < totalCols; c++) { + SheetModel.ColDef def = sheet.col(c); + if (def == null || !def.hidden()) { + visibleCols.add(c); + } + } + StringBuilder xml = new StringBuilder(); + xml.append("") + .append(""); + for (int c : visibleCols) { + xml.append(""); + } + xml.append(""); + int emittedRows = 0; + for (var e : sheet.rows().entrySet()) { + SheetModel.RowData row = e.getValue(); + if (row.hidden()) { + continue; + } + if (!isSignificant(sheet, row, e.getKey())) { + continue; + } + emitRow(xml, e.getKey(), row, sheet, styles, sst, metrics, visibleCols, + hyperlinks, warn); + emittedRows++; + } + if (emittedRows == 0) { + return ""; + } + xml.append(""); + return xml.toString(); + } + + /** Максимальная колонка данных/merge'ей (exclusive). */ + private static int totalColumns(SheetModel sheet) { + int total = sheet.usedCols(); + for (SheetModel.Merge m : sheet.merges()) { + total = Math.max(total, m.col2() + 1); + } + return total; + } + + private static int colTwips(SheetModel sheet, Metrics metrics, int col) { + SheetModel.ColDef def = sheet.col(col); + return Metrics.pxToTwips(metrics.colWidthPx(def == null ? null : def.width(), + sheet.baseColWidth(), def != null && def.hidden())); + } + + /** Строку эмитим, когда в ней есть значение, стиль (s≠0) или merge. */ + private static boolean isSignificant(SheetModel sheet, SheetModel.RowData row, int rowNum1) { + if (row.styleIdx() != null && row.styleIdx() > 0) { + return true; + } + for (var c : row.cells().values()) { + if (c.raw() != null || c.runs() != null + || (c.styleIdx() != null && c.styleIdx() > 0)) { + return true; + } + } + int r = rowNum1 - 1; + for (SheetModel.Merge m : sheet.merges()) { + if (r >= m.row1() && r <= m.row2()) { + return true; + } + } + return false; + } + + private static void emitRow(StringBuilder xml, int rowNum1, SheetModel.RowData row, + SheetModel sheet, StylesModel styles, SharedStrings sst, Metrics metrics, + List visibleCols, LinkedHashSet hyperlinks, WarnOnce warn) { + int r = rowNum1 - 1; + xml.append(""); + for (int c : visibleCols) { + MergeRole role = mergeRole(sheet, r, c); + switch (role) { + case V_CONT -> xml.append(""); + case H_CONT -> xml.append(""); + default -> emitCell(xml, r, c, row, role, sheet, styles, sst, metrics, + visibleCols, hyperlinks, warn); + } + } + xml.append(""); + } + + /** Высота строки exact (Excel печатает фиксированную сетку). */ + private static int trHeightTwips(SheetModel.RowData row, SheetModel sheet) { + double pt = row.ht() == null ? sheet.defaultRowHeight() : row.ht(); + return Metrics.ptToTwips(pt); + } + + /** + * ORIGIN — первая видимая колонка диапазона; при скрытой origin-строке/ + * колонке контент доезжает до первой видимой ячейки диапазона (план). + * H_CONT — продолжение по горизонтали (пустая {@code w:tc}), + * V_CONT — продолжение по вертикали ({@code w:vMerge}). + */ + private static MergeRole mergeRole(SheetModel sheet, int r, int c) { + for (SheetModel.Merge m : sheet.merges()) { + if (r < m.row1() || r > m.row2() || c < m.col1() || c > m.col2()) { + continue; + } + boolean firstVisibleCol = firstVisibleColOf(sheet, m) == c; + boolean originRow = verticalOriginRow(sheet, m) == r; + if (firstVisibleCol && originRow) { + return MergeRole.ORIGIN; + } + return originRow ? MergeRole.H_CONT : MergeRole.V_CONT; + } + return MergeRole.NONE; + } + + private static int firstVisibleColOf(SheetModel sheet, SheetModel.Merge m) { + for (int c = m.col1(); c <= m.col2(); c++) { + SheetModel.ColDef def = sheet.col(c); + if (def == null || !def.hidden()) { + return c; + } + } + return m.col1(); + } + + /** Первая видимая строка диапазона (все скрытые — формально первая). */ + private static int verticalOriginRow(SheetModel sheet, SheetModel.Merge m) { + for (int r = m.row1(); r <= m.row2(); r++) { + SheetModel.RowData row = sheet.rows().get(r + 1); + if (row == null || !row.hidden()) { + return r; + } + } + return m.row1(); + } + + private static void emitCell(StringBuilder xml, int r, int c, SheetModel.RowData row, + MergeRole role, SheetModel sheet, StylesModel styles, SharedStrings sst, + Metrics metrics, List visibleCols, LinkedHashSet hyperlinks, + WarnOnce warn) { + xml.append(""); + SheetModel.Merge merge = role == MergeRole.ORIGIN ? sheetMergeAt(sheet, r, c) : null; + if (merge != null) { + int span = gridSpan(merge, visibleCols); + if (span != SINGLE_CELL_SPAN) { + xml.append(""); + } + if (merge.row2() > merge.row1()) { + xml.append(""); + } + } + xml.append(""); + SheetModel.CellData cell = contentCell(sheet, row, r, c, merge); + // стиль — физической ячейки позиции (редирект контента стиль не переносит) + int styleIdx = resolveStyle(row.cells().get(c), row, sheet, c); + String linkId = hyperlinkId(sheet, r, c, hyperlinks); + emitParagraph(xml, cell, styleIdx, linkId, styles, sst, warn); + xml.append(""); + } + + /** + * Содержимое ячейки: при редиректе origin'а (скрытая строка/колонка) — + * значение из фактической origin-клетки диапазона. + */ + private static SheetModel.CellData contentCell(SheetModel sheet, SheetModel.RowData row, + int r, int c, SheetModel.Merge merge) { + SheetModel.CellData own = row.cells().get(c); + if (merge == null || (r == merge.row1() && c == merge.col1()) + || own == null || hasContent(own)) { + return own; + } + SheetModel.RowData originRow = sheet.rows().get(merge.row1() + 1); + if (originRow == null) { + return own; + } + SheetModel.CellData origin = originRow.cells().get(merge.col1()); + return origin != null && hasContent(origin) ? origin : own; + } + + private static boolean hasContent(SheetModel.CellData cell) { + return cell.raw() != null || cell.runs() != null; + } + + private static SheetModel.Merge sheetMergeAt(SheetModel sheet, int r, int c) { + for (SheetModel.Merge m : sheet.merges()) { + if (r >= m.row1() && r <= m.row2() && c >= m.col1() && c <= m.col2()) { + return m; + } + } + return null; + } + + /** Число видимых колонок диапазона. */ + private static int gridSpan(SheetModel.Merge m, List visibleCols) { + int span = 0; + for (int c : visibleCols) { + if (c >= m.col1() && c <= m.col2()) { + span++; + } + } + return Math.max(1, span); + } + + /** cell s → row s (@customFormat) → col s → 0. */ + private static int resolveStyle(SheetModel.CellData cell, SheetModel.RowData row, + SheetModel sheet, int c) { + if (cell != null && cell.styleIdx() != null) { + return cell.styleIdx(); + } + Integer rowStyle = row.effectiveStyle(); + if (rowStyle != null) { + return rowStyle; + } + Integer colStyle = sheet.colStyle(c); + return colStyle == null ? 0 : colStyle; + } + + /** {@code hlN} для ячейки внутри диапазона внешней ссылки (dedup по target). */ + private static String hyperlinkId(SheetModel sheet, int r, int c, + LinkedHashSet hyperlinks) { + for (var e : sheet.externalLinks().entrySet()) { + int[] range = SheetModel.parseRange(e.getKey()); + if (range.length < 4 || r < range[0] || r > range[2] || c < range[1] || c > range[3]) { + continue; + } + hyperlinks.add(e.getValue()); + return "hl" + indexOf(hyperlinks, e.getValue()); + } + return null; + } + + private static int indexOf(LinkedHashSet set, String value) { + int i = 0; + for (String v : set) { + if (v.equals(value)) { + return i; + } + i++; + } + return -1; + } + + /** Абзац ячейки: pPr (spacing/jc) + раны (rich или один по стилю ячейки). */ + private static void emitParagraph(StringBuilder xml, SheetModel.CellData cell, int styleIdx, + String linkId, StylesModel styles, SharedStrings sst, WarnOnce warn) { + StylesModel.CellXf xf = styles.xf(styleIdx); + xml.append("") + .append(""); + appendJc(xml, xf.horizontal()); + xml.append(""); + if (linkId != null) { + xml.append(""); + } + List runs = cellRuns(cell, sst, warn); + if (runs.isEmpty()) { + String text = plainText(cell); + if (!text.isEmpty() || linkId != null) { + emitRun(xml, text, null, xf, styles); + } + } else { + for (SharedStrings.Run run : runs) { + emitRun(xml, run.text(), run.style(), xf, styles); + } + } + if (linkId != null) { + xml.append(""); + } + xml.append(""); + } + + /** Excel-горизонталь → Word jc (§18.8.1 + деградации distributed/distribute). */ + private static void appendJc(StringBuilder xml, String horizontal) { + String jc = switch (horizontal == null ? "" : horizontal) { + case "center", "centerContinuous" -> "center"; + case "right" -> "right"; + case "fill", "justify" -> "both"; + case "distributed" -> "distribute"; + default -> null; + }; + if (jc != null) { + xml.append(""); + } + } + + private static List cellRuns(SheetModel.CellData cell, + SharedStrings sst, WarnOnce warn) { + if (cell == null) { + return List.of(); + } + String type = cell.type(); + switch (type == null ? "" : type) { + case "inlineStr": + return cell.runs() == null ? List.of() : cell.runs(); + case "s": { + Integer idx = cell.raw() == null ? null : ColorSpec.parseInt(cell.raw().trim()); + return idx == null ? List.of() : sst.at(idx, warn); + } + default: + return List.of(); + } + } + + /** Текст не-rich ячейки (numFmt-движок подключается шагом 5). */ + private static String plainText(SheetModel.CellData cell) { + if (cell == null || cell.raw() == null) { + return ""; + } + return NumberText.of(cell.raw(), cell.type()); + } + + /** + * Один {@code w:r}: rFonts/sz из шрифта ячейки (переопределения rich-рана + * приоритетны); цвет/зачёрк/индекс — каркас шага 5. + */ + private static void emitRun(StringBuilder xml, String text, SharedStrings.RunStyle style, + StylesModel.CellXf xf, StylesModel styles) { + StylesModel.FontDef base = styles.font(xf.fontId()); + String family = style != null && style.fontName() != null ? style.fontName() + : base == null || base.name() == null ? "Calibri" : base.name(); + boolean bold = (base != null && Boolean.TRUE.equals(base.bold())) + || style != null && Boolean.TRUE.equals(style.bold()); + boolean italic = (base != null && Boolean.TRUE.equals(base.italic())) + || style != null && Boolean.TRUE.equals(style.italic()); + boolean strikeout = (base != null && Boolean.TRUE.equals(base.strikeout())) + || style != null && Boolean.TRUE.equals(style.strikeout()); + boolean underline = style != null && style.underline() != null + || base != null && base.underline() != null; + double size = style != null && style.sizePt() != null ? style.sizePt() + : base == null || base.sizePt() == null ? DEFAULT_SIZE_PT : base.sizePt(); + xml.append(""); + appendRFonts(xml, family); + int half = (int) Math.ceil(size * 2); + xml.append("") + .append(""); + if (bold) { + xml.append(""); + } + if (italic) { + xml.append(""); + } + if (underline) { + xml.append(""); + } + if (strikeout) { + xml.append(""); + } + xml.append("").append(escapeXml(text)).append(""); + } + + /** rFonts ascii/hAnsi/cs (Word определяет латиницу/кириллицу по hAnsi). */ + private static void appendRFonts(StringBuilder xml, String family) { + String esc = escapeXml(family); + xml.append(""); + } + + private static String escapeXml(String s) { + StringBuilder out = new StringBuilder(s.length() + 8); + for (int i = 0; i < s.length(); i++) { + char ch = s.charAt(i); + switch (ch) { + case '&' -> out.append("&"); + case '<' -> out.append("<"); + case '>' -> out.append(">"); + case '"' -> out.append("""); + default -> { + // управляющие XML 1.0 не допускает — вырезаем + if (ch >= 0x20 || ch == '\t' || ch == '\n' || ch == '\r') { + out.append(ch); + } + } + } + } + return out.toString(); + } +} diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/StylesModel.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/StylesModel.java new file mode 100644 index 0000000..2f70210 --- /dev/null +++ b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/StylesModel.java @@ -0,0 +1,506 @@ +package ru.pjandro.wordpdf.internal.xlsx; + +import javax.xml.stream.XMLStreamConstants; +import javax.xml.stream.XMLStreamException; +import javax.xml.stream.XMLStreamReader; +import java.io.ByteArrayInputStream; +import java.io.IOException; +import java.util.ArrayList; +import java.util.List; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * {@code xl/styles.xml} (ECMA-376 §18.8): таблицы {@code numFmts}, + * {@code fonts}, {@code fills}, {@code borders}, {@code cellStyleXfs} + + * {@code cellXfs}. Для каждого индекса {@code c/@s} заранее вычисляется + * эффективный формат {@link CellXf}: старт от базы {@code cellStyleXfs[xfId]} + * (base-first), поля cellXfs перекрывают базу по правилам apply*-флагов + * Excel: {@code applyX="1"} — берём значение cellXfs (даже отсутствующий + * атрибут = дефолт 0), {@code applyX="0"} — всегда база, флага нет — + * значение cellXfs, если атрибут задан явно, иначе база. + * + *

{@code dxfs} (§18.8.15) не парсятся: conditional formatting вне v1.

+ */ +final class StylesModel { + + /** Шрифт {@code fonts/font} (§18.8.23 CT_Font). */ + record FontDef(String name, String scheme, Double sizePt, Boolean bold, Boolean italic, + String underline, Boolean strikeout, ColorSpec color) { + } + + /** Заливка {@code fills/fill} (§18.8.32 CT_PatternFill). */ + record FillDef(String patternType, ColorSpec fgColor) { + } + + /** Одна сторона границы (§18.8.5 CT_Border). */ + record BorderSide(String style, ColorSpec color) { + } + + /** Граница {@code borders/border}; диагонали не эмитятся (Word-ячейка). */ + record BorderDef(BorderSide left, BorderSide right, BorderSide top, BorderSide bottom) { + } + + /** Эффективный формат ячейки (cellXfs[с], разрешённый через базу). */ + record CellXf(int numFmtId, int fontId, int fillId, int borderId, + String horizontal, String vertical, boolean wrapText, int indent) { + } + + private static final Logger LOG = LoggerFactory.getLogger(StylesModel.class); + private static final String STYLES_PART = "xl/styles.xml"; + /** Дефолт CT_Font/@sz. */ + private static final double DEFAULT_SIZE_PT = 11.0; + + private final List fonts; + private final List fills; + private final List borders; + private final List xfs; + /** {@code colors/indexedColors/rgbColor}: индекс 64+n. */ + private final List indexedColors; + + private StylesModel(List fonts, List fills, List borders, + List xfs, List indexedColors) { + this.fonts = fonts; + this.fills = fills; + this.borders = borders; + this.xfs = xfs; + this.indexedColors = indexedColors; + } + + FontDef font(int index) { + return index >= 0 && index < fonts.size() ? fonts.get(index) : null; + } + + FillDef fill(int index) { + return index >= 0 && index < fills.size() ? fills.get(index) : null; + } + + BorderDef border(int index) { + return index >= 0 && index < borders.size() ? borders.get(index) : null; + } + + CellXf xf(int index) { + return index >= 0 && index < xfs.size() ? xfs.get(index) : xfs.get(0); + } + + int xfCount() { + return xfs.size(); + } + + /** Палитра {@code indexedColors} (может быть короче/пустой). */ + List indexedColors() { + return indexedColors; + } + + /** + * Семейство шрифта Normal-стиля (индекс 0 cellStyles) — для MDW в + * {@link Metrics}; имя (или scheme=minor при отсутствии имени). + */ + String normalFontName() { + CellXf base = xfs.isEmpty() ? new CellXf(0, 0, 0, 0, null, null, false, 0) : xfs.get(0); + FontDef f = font(base.fontId()); + if (f == null || f.name() == null) { + return "Calibri"; + } + return f.name(); + } + + static StylesModel read(XlsxPackage pkg, WarnOnce warn) throws IOException { + byte[] data = pkg.entry(STYLES_PART); + if (data == null) { + warn.warn(LOG, "В .xlsx нет xl/styles.xml — все ячейки дефолтным форматом"); + return new StylesModel(List.of(defaultFont()), List.of(noFill(), gray125()), + List.of(noBorder()), List.of(new CellXf(0, 0, 0, 0, null, null, false, 0)), + List.of()); + } + Parser p = new Parser(); + try { + XMLStreamReader xr = XlsxPackage.newSecureReader() + .createXMLStreamReader(new ByteArrayInputStream(data)); + p.parse(xr); + xr.close(); + } catch (XMLStreamException e) { + throw new IOException("Не удалось разобрать xl/styles.xml", e); + } + return p.build(); + } + + // ================== разбор ================== + + /** Промежуточное xf-сырьё (до разрешения базы). */ + private record RawXf(Integer numFmtId, Integer fontId, Integer fillId, Integer borderId, + Integer xfId, Boolean applyNumFmt, Boolean applyFont, Boolean applyFill, + Boolean applyBorder, Boolean applyAlignment, + String horizontal, String vertical, Boolean wrap, Integer indent) { + + /** Эффективный xf по правилу apply*-флагов (base-first). */ + CellXf resolve(RawXf base) { + int nf = pickNum(numFmtId, applyNumFmt, base == null ? null : base.numFmtId); + int fn = pickNum(fontId, applyFont, base == null ? null : base.fontId); + int fl = pickNum(fillId, applyFill, base == null ? null : base.fillId); + int bd = pickNum(borderId, applyBorder, base == null ? null : base.borderId); + String hz; + String vt; + boolean wr; + int ind; + if (Boolean.FALSE.equals(applyAlignment) && base != null) { + hz = base.horizontal; + vt = base.vertical; + wr = Boolean.TRUE.equals(base.wrap); + ind = base.indent == null ? 0 : base.indent; + } else { + hz = horizontal != null || base == null || Boolean.TRUE.equals(applyAlignment) + ? horizontal : base.horizontal; + vt = vertical != null || base == null || Boolean.TRUE.equals(applyAlignment) + ? vertical : base.vertical; + wr = wrap != null || base == null || Boolean.TRUE.equals(applyAlignment) + ? Boolean.TRUE.equals(wrap) : Boolean.TRUE.equals(base.wrap); + ind = indent != null || base == null || Boolean.TRUE.equals(applyAlignment) + ? (indent == null ? 0 : indent) : base.indent == null ? 0 : base.indent; + } + return new CellXf(nf, fn, fl, bd, hz, vt, wr, ind); + } + + private static int pickNum(Integer own, Boolean apply, Integer base) { + if (Boolean.TRUE.equals(apply)) { + return own == null ? 0 : own; + } + if (Boolean.FALSE.equals(apply)) { + return base == null ? 0 : base; + } + if (own != null) { + return own; + } + return base == null ? 0 : base; + } + } + + /** Контейнер разбора одной части styles.xml. */ + private static final class Parser { + private final List fonts = new ArrayList<>(); + private final List fills = new ArrayList<>(); + private final List borders = new ArrayList<>(); + private final List styleXfs = new ArrayList<>(); + private final List cellXfs = new ArrayList<>(); + private final List indexedColors = new ArrayList<>(); + /** Текущая таблица для дочерних элементов. */ + private String table; + + void parse(XMLStreamReader xr) throws XMLStreamException { + boolean rootOpen = false; + while (!rootOpen && xr.hasNext()) { + // до START корня styleSheet — дальше диспатчим только детей + // (иначе default-skip проглотит весь документ) + rootOpen = xr.next() == XMLStreamConstants.START_ELEMENT; + } + while (xr.hasNext()) { + if (xr.next() != XMLStreamConstants.START_ELEMENT) { + continue; + } + table = xr.getLocalName(); + switch (table) { + case "fonts" -> parseFonts(xr); + case "fills" -> parseFills(xr); + case "borders" -> parseBorders(xr); + case "cellStyleXfs" -> styleXfs.addAll(parseXfs(xr)); + case "cellXfs" -> cellXfs.addAll(parseXfs(xr)); + case "colors" -> parseColors(xr); + default -> SharedStrings.skipElement(xr); + } + } + } + + StylesModel build() { + if (fonts.isEmpty()) { + fonts.add(defaultFont()); + } + // ECMA §18.8.21: fills[0] — none, fills[1] — легаси gray125 + // (генераторы иногда пишут только первую). + while (fills.size() < 2) { + fills.add(fills.isEmpty() ? noFill() : gray125()); + } + if (borders.isEmpty()) { + borders.add(noBorder()); + } + List xfs = new ArrayList<>(cellXfs.size()); + for (RawXf xf : cellXfs) { + RawXf base = xf.xfId() == null || xf.xfId() < 0 || xf.xfId() >= styleXfs.size() + ? null : styleXfs.get(xf.xfId()); + xfs.add(xf.resolve(base)); + } + if (xfs.isEmpty()) { + xfs.add(new CellXf(0, 0, 0, 0, null, null, false, 0)); + } + return new StylesModel(List.copyOf(fonts), List.copyOf(fills), + List.copyOf(borders), List.copyOf(xfs), List.copyOf(indexedColors)); + } + + private void parseFonts(XMLStreamReader xr) throws XMLStreamException { + while (nextTableItem(xr, "font")) { + fonts.add(readFont(xr)); + } + } + + private FontDef readFont(XMLStreamReader xr) throws XMLStreamException { + String name = null; + String scheme = null; + Double size = null; + Boolean bold = null; + Boolean italic = null; + String underline = null; + Boolean strikeout = null; + ColorSpec color = null; + while (xr.hasNext()) { + int ev = xr.next(); + if (ev == XMLStreamConstants.END_ELEMENT) { + break; + } + if (ev != XMLStreamConstants.START_ELEMENT) { + continue; + } + switch (xr.getLocalName()) { + case "name" -> name = XlsxPackage.attr(xr, "val"); + case "scheme" -> scheme = XlsxPackage.attr(xr, "val"); + case "sz" -> size = ColorSpec.parseDouble(XlsxPackage.attr(xr, "val")); + case "b" -> bold = SharedStrings.boolVal(xr); + case "i" -> italic = SharedStrings.boolVal(xr); + case "strike" -> strikeout = SharedStrings.boolVal(xr); + case "u" -> { + String v = XlsxPackage.attr(xr, "val"); + underline = v == null || "none".equals(v) ? null : v; + } + case "color" -> color = ColorSpec.fromColorElement(xr); + default -> { + } + } + // листок font (name/sz/b/…) доедает свой END, иначе он + // досрочно прервёт разбор шрифта + SharedStrings.skipElement(xr); + } + return new FontDef(name, scheme, size, bold, italic, underline, strikeout, color); + } + + private void parseFills(XMLStreamReader xr) throws XMLStreamException { + while (nextTableItem(xr, "fill")) { + fills.add(readFill(xr)); + } + } + + private FillDef readFill(XMLStreamReader xr) throws XMLStreamException { + String pattern = "none"; + ColorSpec fg = null; + while (xr.hasNext()) { + int ev = xr.next(); + if (ev == XMLStreamConstants.END_ELEMENT) { + break; + } + if (ev == XMLStreamConstants.START_ELEMENT + && "patternFill".equals(xr.getLocalName())) { + String pt = XlsxPackage.attr(xr, "patternType"); + pattern = pt == null ? "none" : pt; + fg = readPatternColors(xr); + } else if (ev == XMLStreamConstants.START_ELEMENT) { + SharedStrings.skipElement(xr); + } + } + return new FillDef(pattern, fg); + } + + /** fgColor patternFill (solid — это ОН же цвет заливки); bgColor пропускается. */ + private ColorSpec readPatternColors(XMLStreamReader xr) throws XMLStreamException { + ColorSpec fg = null; + while (xr.hasNext()) { + int ev = xr.next(); + if (ev == XMLStreamConstants.END_ELEMENT) { + break; + } + if (ev != XMLStreamConstants.START_ELEMENT) { + continue; + } + switch (xr.getLocalName()) { + case "fgColor" -> { + fg = ColorSpec.fromColorElement(xr); + SharedStrings.skipElement(xr); + } + default -> SharedStrings.skipElement(xr); + } + } + return fg; + } + + private void parseBorders(XMLStreamReader xr) throws XMLStreamException { + while (nextTableItem(xr, "border")) { + borders.add(readBorder(xr)); + } + } + + private BorderDef readBorder(XMLStreamReader xr) throws XMLStreamException { + BorderSide left = null; + BorderSide right = null; + BorderSide top = null; + BorderSide bottom = null; + while (xr.hasNext()) { + int ev = xr.next(); + if (ev == XMLStreamConstants.END_ELEMENT) { + break; + } + if (ev != XMLStreamConstants.START_ELEMENT) { + continue; + } + String side = xr.getLocalName(); + if ("left".equals(side) || "right".equals(side) + || "top".equals(side) || "bottom".equals(side)) { + String style = XlsxPackage.attr(xr, "style"); + ColorSpec color = readSideColor(xr); + BorderSide s = new BorderSide(style, color); + switch (side) { + case "left" -> left = s; + case "right" -> right = s; + case "top" -> top = s; + default -> bottom = s; + } + } else { + SharedStrings.skipElement(xr); + } + } + return new BorderDef(left, right, top, bottom); + } + + /** Дочерний color стороны (сторона без children — просто END). */ + private ColorSpec readSideColor(XMLStreamReader xr) throws XMLStreamException { + while (xr.hasNext()) { + int ev = xr.next(); + if (ev == XMLStreamConstants.END_ELEMENT) { + break; + } + if (ev == XMLStreamConstants.START_ELEMENT && "color".equals(xr.getLocalName())) { + ColorSpec c = ColorSpec.fromColorElement(xr); + SharedStrings.skipElement(xr); + return c; + } + } + return null; + } + + private List parseXfs(XMLStreamReader xr) throws XMLStreamException { + List xfs = new ArrayList<>(); + while (nextTableItem(xr, "xf")) { + xfs.add(readXf(xr)); + } + return xfs; + } + + private RawXf readXf(XMLStreamReader xr) throws XMLStreamException { + Integer numFmtId = ColorSpec.parseInt(XlsxPackage.attr(xr, "numFmtId")); + Integer fontId = ColorSpec.parseInt(XlsxPackage.attr(xr, "fontId")); + Integer fillId = ColorSpec.parseInt(XlsxPackage.attr(xr, "fillId")); + Integer borderId = ColorSpec.parseInt(XlsxPackage.attr(xr, "borderId")); + Integer xfId = ColorSpec.parseInt(XlsxPackage.attr(xr, "xfId")); + Boolean applyNumFmt = flag(XlsxPackage.attr(xr, "applyNumFmt")); + Boolean applyFont = flag(XlsxPackage.attr(xr, "applyFont")); + Boolean applyFill = flag(XlsxPackage.attr(xr, "applyFill")); + Boolean applyBorder = flag(XlsxPackage.attr(xr, "applyBorder")); + Boolean applyAlignment = flag(XlsxPackage.attr(xr, "applyAlignment")); + String hz = null; + String vt = null; + Boolean wrap = null; + Integer indent = null; + while (xr.hasNext()) { + int ev = xr.next(); + if (ev == XMLStreamConstants.END_ELEMENT) { + break; + } + if (ev != XMLStreamConstants.START_ELEMENT) { + continue; + } + switch (xr.getLocalName()) { + case "alignment" -> { + hz = XlsxPackage.attr(xr, "horizontal"); + vt = XlsxPackage.attr(xr, "vertical"); + String w = XlsxPackage.attr(xr, "wrapText"); + wrap = w == null ? null : XlsxPackage.truthy(w); + indent = ColorSpec.parseInt(XlsxPackage.attr(xr, "indent")); + SharedStrings.skipElement(xr); + } + default -> SharedStrings.skipElement(xr); // protection/неизвестное + } + } + return new RawXf(numFmtId, fontId, fillId, borderId, xfId, applyNumFmt, + applyFont, applyFill, applyBorder, applyAlignment, hz, vt, wrap, indent); + } + + private void parseColors(XMLStreamReader xr) throws XMLStreamException { + while (xr.hasNext()) { + int ev = xr.next(); + if (ev == XMLStreamConstants.END_ELEMENT) { + break; + } + if (ev != XMLStreamConstants.START_ELEMENT) { + continue; + } + switch (xr.getLocalName()) { + case "indexedColors": + while (xr.hasNext()) { + int e2 = xr.next(); + if (e2 == XMLStreamConstants.END_ELEMENT) { + break; + } + if (e2 != XMLStreamConstants.START_ELEMENT) { + continue; + } + switch (xr.getLocalName()) { + case "rgbColor" -> { + String rgb = XlsxPackage.attr(xr, "rgb"); + indexedColors.add(rgb == null ? "000000" : rgb); + } + default -> { + } + } + SharedStrings.skipElement(xr); + } + break; + default: + SharedStrings.skipElement(xr); + } + } + } + + /** Следующий START дочернего элемента {@code item} таблицы; END таблицы — false. */ + private boolean nextTableItem(XMLStreamReader xr, String item) throws XMLStreamException { + while (xr.hasNext()) { + int ev = xr.next(); + if (ev == XMLStreamConstants.END_ELEMENT) { + return false; + } + if (ev == XMLStreamConstants.START_ELEMENT && item.equals(xr.getLocalName())) { + return true; + } + } + return false; + } + + private static Boolean flag(String v) { + if (v == null) { + return null; + } + return XlsxPackage.truthy(v); + } + } + + private static FontDef defaultFont() { + return new FontDef("Calibri", "minor", DEFAULT_SIZE_PT, null, null, null, null, null); + } + + private static FillDef noFill() { + return new FillDef("none", null); + } + + private static FillDef gray125() { + return new FillDef("gray125", null); + } + + private static BorderDef noBorder() { + return new BorderDef(null, null, null, null); + } +} diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/WarnOnce.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/WarnOnce.java new file mode 100644 index 0000000..506fa16 Binary files /dev/null and b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/WarnOnce.java differ diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/WorkbookModel.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/WorkbookModel.java new file mode 100644 index 0000000..a99762d --- /dev/null +++ b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/WorkbookModel.java @@ -0,0 +1,118 @@ +package ru.pjandro.wordpdf.internal.xlsx; + +import javax.xml.stream.XMLStreamConstants; +import javax.xml.stream.XMLStreamReader; +import java.io.ByteArrayInputStream; +import java.io.IOException; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * {@code xl/workbook.xml} (ECMA-376 §18.2.20): листы в tab-порядке + * {@code sheets/sheet} с путями частей через {@code xl/_rels/workbook.xml.rels} + * и флаг {@code workbookPr/@date1904} (§18.2.28 — эпoca дат 1904-01-01). + * Лист без связи на worksheet-часть (внешняя связь, chartsheet, rel на + * отсутствующую часть) в модель не попадает — {@link XlsxToDocx} печатает + * warn и пропускает лист. + */ +final class WorkbookModel { + + /** Один лист: имя, {@code @state} ("visible" если нет) и путь части (null — не резолвится). */ + record Sheet(String name, String state, String partPath) { + + boolean visible() { + return state == null || "visible".equals(state); + } + } + + /** Namespace атрибута r:id (ECMA-376 Part 2 §17.7.5.4). */ + private static final String REL_NS = + "http://schemas.openxmlformats.org/officeDocument/2006/relationships"; + + /** Тип связи worksheet (ECMA-376 Part 2). */ + private static final String WORKSHEET_REL_TYPE = + "http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet"; + + private static final String WORKBOOK_PART = "xl/workbook.xml"; + private static final String WORKBOOK_RELS_PART = "xl/_rels/workbook.xml.rels"; + + private static final Logger LOG = LoggerFactory.getLogger(WorkbookModel.class); + + private final List sheets; + private final boolean date1904; + + private WorkbookModel(List sheets, boolean date1904) { + this.sheets = sheets; + this.date1904 = date1904; + } + + /** Листы в порядке {@code sheets}. */ + List sheets() { + return sheets; + } + + /** {@code workbookPr/@date1904} — система дат 1904. */ + boolean date1904() { + return date1904; + } + + static WorkbookModel read(XlsxPackage pkg) throws IOException { + byte[] data = pkg.entry(WORKBOOK_PART); + if (data == null) { + throw new IOException("В .xlsx нет части xl/workbook.xml"); + } + // pass 1: rId → worksheet-часть (rels уже отрезолвлены от xl/) + Map partByRid = new HashMap<>(); + for (XlsxPackage.Rel rel : pkg.rels(WORKBOOK_PART)) { + if (WORKSHEET_REL_TYPE.equals(rel.type()) && !rel.external()) { + partByRid.putIfAbsent(rel.id(), + XlsxPackage.resolvePath("xl/", rel.target())); + } + } + // pass 2: sheets/sheet в порядке документа + List sheets = new ArrayList<>(); + boolean date1904 = false; + try { + XMLStreamReader xr = XlsxPackage.newSecureReader() + .createXMLStreamReader(new ByteArrayInputStream(data)); + while (xr.hasNext()) { + if (xr.next() != XMLStreamConstants.START_ELEMENT) { + continue; + } + String name = xr.getLocalName(); + switch (name) { + case "sheet" -> { + String sheetName = XlsxPackage.attr(xr, "name"); + String state = XlsxPackage.attr(xr, "state"); + String rid = XlsxPackage.attrNs(xr, REL_NS, "id"); + String partPath = rid == null ? null : partByRid.get(rid); + if (partPath == null || !pkg.has(partPath)) { + LOG.warn("Лист '{}' (.xlsx) не имеет worksheet-части — пропущен", + sheetName); + continue; + } + sheets.add(new Sheet(sheetName == null ? "" : sheetName, state, partPath)); + } + case "workbookPr" -> + date1904 = XlsxPackage.truthy(XlsxPackage.attr(xr, "date1904")); + default -> { + } + } + } + xr.close(); + } catch (javax.xml.stream.XMLStreamException e) { + throw new IOException("Не удалось разобрать xl/workbook.xml", e); + } + // rels workbook обязаны существовать, но лист-то уже найден через map; + // отдельная проверка части rels не нужна (пустой rels ⇒ нет листов ⇒ warn выше). + if (pkg.entry(WORKBOOK_RELS_PART) == null && !sheets.isEmpty()) { + LOG.warn("В .xlsx нет xl/_rels/workbook.xml.rels — связи листов не найдены"); + } + return new WorkbookModel(sheets, date1904); + } +} diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/XlsxPackage.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/XlsxPackage.java new file mode 100644 index 0000000..c416905 --- /dev/null +++ b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/XlsxPackage.java @@ -0,0 +1,220 @@ +package ru.pjandro.wordpdf.internal.xlsx; + +import javax.xml.stream.XMLInputFactory; +import javax.xml.stream.XMLStreamException; +import javax.xml.stream.XMLStreamReader; +import java.io.ByteArrayInputStream; +import java.io.IOException; +import java.util.ArrayList; +import java.util.ArrayDeque; +import java.util.Deque; +import java.util.HashMap; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.zip.ZipEntry; +import java.util.zip.ZipInputStream; + +/** + * .xlsx как zip: байты записей (дубликаты враждебного архива — первая + * выигрывает) и разбор OPC-связей {@code /_rels/.rels} (StAX, + * ECMA-376 Part 2 §15). Целый архив в памяти держится сознательно: вход + * уже проскан валидатором (zip-бомба отсекается ДО моста, + * {@code WordPdfSettings#MAX_DECOMPRESSED_MB}), а per-part ленивое чтение + * потребовало бы либо держать байты xlsx, либо раскрывать zip вторично — + * при multi-sheet обходе это дороже. + */ +final class XlsxPackage { + + /** Одна связь {@code Relationship} из .rels-части. */ + record Rel(String id, String type, String target, boolean external) { + } + + private final Map entries = new LinkedHashMap<>(); + private final Map> relsByPart = new HashMap<>(); + + private XlsxPackage() { + } + + /** Распаковка архива (первая запись из дубликатов). */ + static XlsxPackage read(byte[] xlsxBytes) throws IOException { + XlsxPackage pkg = new XlsxPackage(); + try (ZipInputStream zip = new ZipInputStream(new ByteArrayInputStream(xlsxBytes))) { + ZipEntry entry; + while ((entry = zip.getNextEntry()) != null) { + if (entry.isDirectory() || pkg.entries.containsKey(entry.getName())) { + continue; + } + pkg.entries.put(entry.getName(), zip.readAllBytes()); + } + } + return pkg; + } + + /** Байты части или {@code null} (части нет). */ + byte[] entry(String path) { + return entries.get(path); + } + + /** Есть ли часть. */ + boolean has(String path) { + return entries.containsKey(path); + } + + /** + * Связи части: {@code dir/_rels/.rels} рядом с {@code partPath} + * (пустой список, если rels-части нет). Парсинг ленивый, повторный вызов + * отдаёт кэш. + */ + List rels(String partPath) { + List cached = relsByPart.get(partPath); + if (cached != null) { + return cached; + } + String relsPath = relsPathOf(partPath); + List rels = new ArrayList<>(); + byte[] data = relsPath == null ? null : entries.get(relsPath); + if (data != null) { + try { + rels = parseRels(data); + } catch (XMLStreamException | IOException e) { + // Битые rels — «связей нет»: лист без rels пустой (+warn у + // вызывающего), падать из-за них на весь документ незачем. + rels = List.of(); + } + } + relsByPart.put(partPath, rels); + return rels; + } + + /** First rel заданного типа с id (внешние тоже) или null. */ + Rel relByTargetId(String partPath, String relId) { + for (Rel rel : rels(partPath)) { + if (rel.id().equals(relId)) { + return rel; + } + } + return null; + } + + /** Часть-цель связи (resolved от каталога part-источника) или null. */ + String relTargetPath(String partPath, String relId) { + Rel rel = relByTargetId(partPath, relId); + if (rel == null || rel.external()) { + return null; + } + return resolvePath(parentDir(partPath), rel.target()); + } + + /** {@code word/document.xml} → {@code word/_rels/document.xml.rels}. */ + static String relsPathOf(String partPath) { + int slash = partPath.lastIndexOf('/'); + String dir = slash < 0 ? "" : partPath.substring(0, slash + 1); + String file = slash < 0 ? partPath : partPath.substring(slash + 1); + return dir + "_rels/" + file + ".rels"; + } + + /** Каталог части с завершающим слэшем ("" для корневых). */ + static String parentDir(String partPath) { + int slash = partPath.lastIndexOf('/'); + return slash < 0 ? "" : partPath.substring(0, slash + 1); + } + + /** + * Target связи в путь zip-записи: абсолютный ("/xl/…") — от корня + * пакета; относительный разрешается от каталога {@code fromDir} + * («.», «..», обратный слэш). + */ + static String resolvePath(String fromDir, String target) { + String t = target.replace('\\', '/'); + int query = t.indexOf('?'); + if (query >= 0) { + t = t.substring(0, query); + } + if (t.startsWith("/")) { + return t.substring(1); + } + Deque segs = new ArrayDeque<>(); + for (String dir : fromDir.split("/")) { + if (!dir.isEmpty()) { + segs.push(dir); + } + } + for (String seg : t.split("/")) { + if (seg.isEmpty() || CUR.equals(seg)) { + continue; + } + if (UP.equals(seg)) { + if (!segs.isEmpty()) { + segs.pop(); + } + } else { + segs.push(seg); + } + } + StringBuilder path = new StringBuilder(); + for (var it = segs.descendingIterator(); it.hasNext(); ) { + if (path.length() > 0) { + path.append('/'); + } + path.append(it.next()); + } + return path.toString(); + } + + /** Сегменты относительных путей. */ + private static final String CUR = "."; + private static final String UP = ".."; + + private static List parseRels(byte[] data) throws IOException, XMLStreamException { + List rels = new ArrayList<>(); + Map seenIds = new HashMap<>(); + XMLStreamReader xr = newSecureReader().createXMLStreamReader(new ByteArrayInputStream(data)); + while (xr.hasNext()) { + if (xr.next() == XMLStreamReader.START_ELEMENT + && "Relationship".equals(xr.getLocalName())) { + String id = attr(xr, "Id"); + String type = attr(xr, "Type"); + String target = attr(xr, "Target"); + boolean external = "External".equals(attr(xr, "TargetMode")); + if (id != null && type != null && target != null && seenIds.put(id, true) == null) { + rels.add(new Rel(id, type, target, external)); + } + } + } + xr.close(); + return rels; + } + + /** Значение атрибута по локальному имени (без привязки к namespace). */ + static String attr(XMLStreamReader xr, String name) { + for (int i = 0; i < xr.getAttributeCount(); i++) { + if (xr.getAttributeName(i).getLocalPart().equals(name)) { + return xr.getAttributeValue(i); + } + } + return null; + } + + /** Значение namespace-атрибута (например r:id). */ + static String attrNs(XMLStreamReader xr, String ns, String name) { + return xr.getAttributeValue(ns, name); + } + + /** + * XML-boolean атрибут ECMA-376 (§18.18.62): отсутствует или {@code 0}/ + * {@code false}/{@code off} — ложь; {@code 1}/{@code true}/{@code on}/ + * пустое значение (атрибут выставлен) — истина. + */ + static boolean truthy(String value) { + return value != null && !"0".equals(value) && !"false".equalsIgnoreCase(value) + && !"off".equalsIgnoreCase(value); + } + + static XMLInputFactory newSecureReader() { + XMLInputFactory f = XMLInputFactory.newInstance(); + f.setProperty(XMLInputFactory.SUPPORT_DTD, false); + f.setProperty(XMLInputFactory.IS_SUPPORTING_EXTERNAL_ENTITIES, false); + return f; + } +} diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/XlsxToDocx.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/XlsxToDocx.java new file mode 100644 index 0000000..6db48af --- /dev/null +++ b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/xlsx/XlsxToDocx.java @@ -0,0 +1,91 @@ +package ru.pjandro.wordpdf.internal.xlsx; + +import ru.pjandro.wordpdf.ConvertOptions; +import ru.pjandro.wordpdf.ConversionException; +import ru.pjandro.wordpdf.DrawingFoundException; +import ru.pjandro.wordpdf.ValidationException; +import ru.pjandro.wordpdf.internal.DocxPackageWriter; + +import java.util.ArrayList; +import java.util.LinkedHashSet; +import java.util.List; + +/** + * Мост .xlsx → in-memory .docx: лист Excel превращается в Word-таблицу + * фиксированной сетки, дальше — штатный пайплайн {@code WordPdfConverter} + * (шаги 1–7: шрифты, {@code DrawingPreRenderer}, вендорный XSLT, FOP). + * Нормативная база — ECMA-376 Part 1 §18 SpreadsheetML (ссылки § — в + * javadoc'ах классов пакета); печатная семантика (срезы/разрывы/fitToPage) + * — как печать Excel. + * + *

Тот же архитектурный приём, что мост {@code internal.doc}: разбор → + * модель → генерация docx-байтов; наружу из пакета — только {@link #convert}. + * Сгенерированный docx — собственный артефакт, штатной валидацией входа не + * проверяется (вход проверен {@code WordPdfValidator} по байтам .xlsx).

+ */ +public final class XlsxToDocx { + + private XlsxToDocx() { + } + + /** + * Байты .xlsx → байты .docx того же документа (все видимые листы по + * tab-порядку; между листами — разрыв секции, шаг 6). + * + * @param options error-флаги рисунков (chart/OLE) и лимиты на этот вызов + * @throws DrawingFoundException {@code options.errorOnCharts()}/{@code errorOnOle()} + * и объект найден — уходит вызывающему как есть (REST мапит в 422) + * @throws ValidationException любой внешний отказ разбора — контрактный + * текст «Не удалось разобрать байты .xlsx» + */ + public static byte[] convert(byte[] xlsxBytes, ConvertOptions options) + throws ConversionException { + try { + return convertInternal(xlsxBytes, options); + } catch (ConversionException e) { + // DrawingFoundException (и иной Contract-исключение моста) — как есть + throw e; + } catch (Exception e) { + throw new ValidationException("Не удалось разобрать байты .xlsx", e); + } + } + + private static byte[] convertInternal(byte[] xlsxBytes, ConvertOptions options) + throws Exception { + WarnOnce warn = new WarnOnce(); + XlsxPackage pkg = XlsxPackage.read(xlsxBytes); + WorkbookModel wb = WorkbookModel.read(pkg); + StylesModel styles = StylesModel.read(pkg, warn); + SharedStrings sst = SharedStrings.read(pkg, warn); + Metrics metrics = Metrics.forNormalFamily(styles.normalFontName()); + + StringBuilder body = new StringBuilder(); + List parts = new ArrayList<>(); + LinkedHashSet hyperlinks = new LinkedHashSet<>(); + int emitted = 0; + for (WorkbookModel.Sheet sheet : wb.sheets()) { + if (!sheet.visible()) { + continue; + } + SheetModel model = SheetModel.read(pkg, sheet, warn); + if (model.olePresent() && options.errorOnOle()) { + // OLE в xlsx: объект не эмитится никогда; флаг — отказ (шаг 7 + // уточняет находку по embeddings; structural-признаки — здесь) + throw new DrawingFoundException(DrawingFoundException.Kind.OLE); + } + String tableXml = SheetToTable.emit(model, styles, sst, wb, metrics, + parts, hyperlinks, warn); + if (tableXml.isEmpty()) { + // пустой лист — только страница (секция появится шагом 6) + continue; + } + if (emitted++ > 0) { + body.append(""); + } + body.append(tableXml); + } + // финальный абзац body (Word-контент-блок после последней таблицы) + body.append(""); + return DocxPackageWriter.write(body.toString(), parts, new ArrayList<>(hyperlinks)); + } +} diff --git a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/XlsxPdfConverterTest.java b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/XlsxPdfConverterTest.java new file mode 100644 index 0000000..5144d8b --- /dev/null +++ b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/XlsxPdfConverterTest.java @@ -0,0 +1,60 @@ +package ru.pjandro.wordpdf; + +import org.apache.pdfbox.Loader; +import org.apache.pdfbox.pdmodel.PDDocument; +import org.apache.pdfbox.text.PDFTextStripper; +import org.junit.jupiter.api.Test; + +import java.io.IOException; +import java.io.InputStream; +import java.nio.file.Files; +import java.nio.file.Path; + +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + +/** + * Сквозная конвертация .xlsx (роутинг моста {@code internal.xlsx} внутри + * {@link WordPdfConverter}) до PDF: текст доезжает, глифов «#» нет, шрифт + * не Helvetica. Остальные аспекты (срезы, numFmt, рисунки) — тесты шагов 5–7. + */ +class XlsxPdfConverterTest { + + private static byte[] sample(String name) throws IOException { + try (InputStream in = XlsxPdfConverterTest.class.getClassLoader() + .getResourceAsStream("samples/" + name)) { + assertNotNull(in, "Нет фикстуры: samples/" + name); + return in.readAllBytes(); + } + } + + private static Path convertPdf(byte[] xlsx) throws IOException { + Path out = Files.createTempFile("xlsx-", ".pdf"); + Files.write(out, WordPdfConverter.convert(xlsx, "xlsx")); + return out; + } + + private static String norm(String s) { + return s.replaceAll("\\s+", " "); + } + + @Test + void basic_ruTextReachesPdf_noHashNoHelvetica() throws IOException { + Path pdf = convertPdf(sample("xlsx-basic.xlsx")); + String text; + try (PDDocument doc = Loader.loadPDF(pdf.toFile())) { + assertTrue(doc.getNumberOfPages() >= 1); + text = norm(new PDFTextStripper().getText(doc)); + } + assertFalse(text.contains("#"), "в PDF есть «#» (не покрыт глиф): " + text); + assertFalse(text.contains("Helvetica"), "FOP ушёл в Helvetica"); + assertTrue(text.contains("Отчёт"), "нет заголовка листа"); + // узкие колонки v1 рвут слова переносом — сравнение без пробелов + String flat = text.replaceAll("\\s+", ""); + assertTrue(flat.contains("Молоко"), "нет данных"); + assertTrue(text.contains("1234.5"), "нет числа"); + assertTrue(flat.contains("ЖИРНЫЙ"), "rich-строка потеряна"); + assertTrue(flat.contains("объединённойячейки"), "merge-текст потерян"); + } +} diff --git a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/xlsx/XlsxToDocxTest.java b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/xlsx/XlsxToDocxTest.java new file mode 100644 index 0000000..437b286 --- /dev/null +++ b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/xlsx/XlsxToDocxTest.java @@ -0,0 +1,103 @@ +package ru.pjandro.wordpdf.internal.xlsx; + +import org.junit.jupiter.api.Test; + +import java.io.ByteArrayInputStream; +import java.io.IOException; +import java.io.InputStream; +import java.nio.charset.StandardCharsets; +import java.util.regex.Matcher; +import java.util.regex.Pattern; +import java.util.zip.ZipEntry; +import java.util.zip.ZipInputStream; + +import ru.pjandro.wordpdf.ConvertOptions; + +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + +/** + * Структура docx-конвертата моста .xlsx (samples/xlsx-basic.xlsx): сетка без + * скрытых колонок/строк, merge'ы, внешняя гиперссылка, rich-раны SST. + * PDF-уровень — XlsxPdfConverterTest; стили/numFmt — шаг 5. + */ +class XlsxToDocxTest { + + private static final String DOCUMENT_ENTRY = "word/document.xml"; + + private static byte[] sample(String name) throws IOException { + try (InputStream in = XlsxToDocxTest.class.getClassLoader() + .getResourceAsStream("samples/" + name)) { + assertNotNull(in, "Нет фикстуры: samples/" + name); + return in.readAllBytes(); + } + } + + private static String documentXml(String fixture) throws IOException { + byte[] docx = XlsxToDocx.convert(sample(fixture), ConvertOptions.defaults()); + try (ZipInputStream zip = new ZipInputStream(new ByteArrayInputStream(docx))) { + ZipEntry entry; + while ((entry = zip.getNextEntry()) != null) { + if (DOCUMENT_ENTRY.equals(entry.getName())) { + return new String(zip.readAllBytes(), StandardCharsets.UTF_8); + } + } + } + throw new AssertionError("в конвертате нет word/document.xml"); + } + + @Test + void basic_gridDropsHiddenColumnAndRow() throws IOException { + String xml = documentXml("xlsx-basic.xlsx"); + // фикстура: колонка H и строка 8 скрыты — сетка 7 колонок, 7 строк + Matcher grid = Pattern.compile("(.*?)").matcher(xml); + assertTrue(grid.find(), "нет tblGrid"); + assertTrue(grid.group(1).split("Отчёт"), "нет заголовка"); + assertTrue(!xml.contains("скрытая"), "скрытая строка 8 эмитирована"); + } + + @Test + void merges_gridSpanAndVMerge() throws IOException { + String xml = documentXml("xlsx-basic.xlsx"); + // B2:D2 — горизонтальный; F3:G4 — блок; C5:C6 — вертикальный + assertTrue(xml.contains(""), "нет gridSpan=3 (B2:D2)"); + assertTrue(xml.contains(""), "нет gridSpan=2 (F3:G4)"); + assertTrue(xml.contains(""), "нет vMerge restart"); + assertTrue(Pattern.compile("").matcher(xml).find(), "нет vMerge continue"); + assertTrue(xml.contains("объединённой ячейки"), "текст merge-ячейки потерян"); + } + + @Test + void externalHyperlink_emittedWithRelId() throws IOException { + String xml = documentXml("xlsx-basic.xlsx"); + assertTrue(xml.contains(""), "нет w:hyperlink r:id=hl0: " + + xml.substring(0, Math.min(xml.length(), 600))); + } + + @Test + void richSharedString_boldRunPreserved() throws IOException { + String xml = documentXml("xlsx-basic.xlsx"); + int at = xml.indexOf("ЖИРНЫЙ"); + assertTrue(at > 0, "rich-строка потеряна"); + String run = xml.substring(xml.lastIndexOf("", at), at); + assertTrue(run.contains(""), "полужирный run потерян: " + run); + } + + @Test + void booleanAndInlineStrings_values() throws IOException { + String xml = documentXml("xlsx-basic.xlsx"); + assertTrue(xml.contains("TRUE"), "boolean TRUE потерян"); + assertTrue(xml.contains("инлайн-строка"), "inlineStr потерян"); + assertTrue(xml.contains("1234.5"), "дробное число потеряно"); + } + + @Test + void secondSheet_appendedAfterSeparator() throws IOException { + String xml = documentXml("xlsx-basic.xlsx"); + assertTrue(xml.indexOf("Заметка") > 0, "лист 2 потерян"); + int tables = xml.split("", -1).length - 1; + assertTrue(tables == 2, "число таблиц: " + tables); + } +}