Мост .xlsx → PDF: SpreadsheetML-конвейер без LibreOffice/POI #91

Closed
ai wants to merge 8 commits from feat/xlsx-bridge into main
14 changed files with 2495 additions and 7 deletions
Showing only changes of commit e8afc8966f - Show all commits
@@ -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);
@@ -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;
}
}
@@ -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).
*
* <p>Формула 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 (скрытый столбец не печатается).</p>
*/
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);
}
}
@@ -0,0 +1,77 @@
package ru.pjandro.wordpdf.internal.xlsx;
/**
* General-вывод значения ячейки (§18.8.30 примечания) и текстовые типы:
* число — кратчайкая round-trip запись без хвостовых нулей; |x| ≥ 1e10 или
* ≠0 и &lt; 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;
}
}
@@ -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 не печатается).
*
* <p>Тот же разбор {@code CT_Rst} используется для inlineStr-ячеек
* ( worksheet §18.3.1.53 {@code is} — та же структура), см.
* {@link #parseRst(XMLStreamReader, WarnOnce)}.</p>
*/
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<Run> NO_RUNS = List.of();
private final List<List<Run>> items;
private SharedStrings(List<List<Run>> items) {
this.items = items;
}
static SharedStrings read(XlsxPackage pkg, WarnOnce warn) throws IOException {
byte[] data = pkg.entry(SST_PART);
List<List<Run>> 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<Run> 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<Run> parseRst(XMLStreamReader xr, WarnOnce warn) throws XMLStreamException {
List<Run> 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--;
}
}
}
}
@@ -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; любые не разобранные части —
* «пустой лист»/игнор по деградационному контракту моста.
*
* <p>Ячейка хранится СЫРОЙ строкой {@code v}/{@code is} + типом {@code @t}:
* форматирование чисел/дат — {@link NumberFormats} на этапе эмитта (формула
* без кэша {@code <v>} — пустая ячейка + warn).</p>
*/
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<SharedStrings.Run> 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<Integer, CellData> 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<Integer, RowData> rows = new TreeMap<>();
private final Map<Integer, ColDef> cols = new HashMap<>();
private final List<Merge> merges = new ArrayList<>();
private final Map<String, String> externalLinks = new HashMap<>();
private final List<Integer> 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<Integer, RowData> rows() {
return rows;
}
Map<Integer, ColDef> cols() {
return cols;
}
List<Merge> merges() {
return merges;
}
Map<String, String> externalLinks() {
return externalLinks;
}
List<Integer> 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<String, String> 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<String, String> hyperlinkTargets(XlsxPackage pkg, String sheetPart) {
Map<String, String> 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<String, String> 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<Integer, CellData> 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<Integer, CellData> 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<SharedStrings.Run> 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<String, String> 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])};
}
}
@@ -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).
*
* <p>Разрывы строк {@code rowBreaks/@id}: семантика Excel — id это 1-based
* номер строки, ПОСЛЕ которой печатная страница обрывается (POI
* {@code setRowBreak(11)} пишет {@code id="12"}; фикстура xlsx-wide,
* регрессия — XlsxPdfConverterTest#rowBreak_pages). Резку выполняет
* планировщик блоков шага 6.</p>
*/
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 <w:body>} для листа: таблица (+ рисунки — шаг 7).
* Пустой лист — пустая строка (секция шага 6 даст свою страницу).
*
* @param hyperlinks дедуплицированный порядок targets внешних ссылок
* (id {@code hl0…} = позиция множества)
*/
static String emit(SheetModel sheet, StylesModel styles, SharedStrings sst,
WorkbookModel wb, Metrics metrics, List<DocxPackageWriter.Part> parts,
LinkedHashSet<String> hyperlinks, WarnOnce warn) {
int totalCols = totalColumns(sheet);
List<Integer> 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("<w:tbl><w:tblPr><w:tblW w:w=\"0\" w:type=\"auto\"/>")
.append("<w:tblLayout w:type=\"fixed\"/></w:tblPr><w:tblGrid>");
for (int c : visibleCols) {
xml.append("<w:gridCol w:w=\"").append(colTwips(sheet, metrics, c)).append("\"/>");
}
xml.append("</w:tblGrid>");
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("</w:tbl>");
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<Integer> visibleCols, LinkedHashSet<String> hyperlinks, WarnOnce warn) {
int r = rowNum1 - 1;
xml.append("<w:tr><w:trPr><w:trHeight w:val=\"")
.append(trHeightTwips(row, sheet))
.append("\" w:hRule=\"exact\"/></w:trPr>");
for (int c : visibleCols) {
MergeRole role = mergeRole(sheet, r, c);
switch (role) {
case V_CONT -> xml.append("<w:tc><w:tcPr><w:vMerge/></w:tcPr><w:p/></w:tc>");
case H_CONT -> xml.append("<w:tc><w:p/></w:tc>");
default -> emitCell(xml, r, c, row, role, sheet, styles, sst, metrics,
visibleCols, hyperlinks, warn);
}
}
xml.append("</w:tr>");
}
/** Высота строки 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<Integer> visibleCols, LinkedHashSet<String> hyperlinks,
WarnOnce warn) {
xml.append("<w:tc><w:tcPr><w:tcW w:w=\"").append(colTwips(sheet, metrics, c))
.append("\" w:type=\"dxa\"/>");
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("<w:gridSpan w:val=\"").append(span).append("\"/>");
}
if (merge.row2() > merge.row1()) {
xml.append("<w:vMerge w:val=\"restart\"/>");
}
}
xml.append("</w:tcPr>");
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("</w:tc>");
}
/**
* Содержимое ячейки: при редиректе 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<Integer> 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<String> 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<String> 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("<w:p><w:pPr>")
.append("<w:spacing w:before=\"0\" w:after=\"0\" w:line=\"240\" w:lineRule=\"auto\"/>");
appendJc(xml, xf.horizontal());
xml.append("</w:pPr>");
if (linkId != null) {
xml.append("<w:hyperlink r:id=\"").append(linkId).append("\">");
}
List<SharedStrings.Run> 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("</w:hyperlink>");
}
xml.append("</w:p>");
}
/** 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("<w:jc w:val=\"").append(jc).append("\"/>");
}
}
private static List<SharedStrings.Run> 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("<w:r><w:rPr>");
appendRFonts(xml, family);
int half = (int) Math.ceil(size * 2);
xml.append("<w:sz w:val=\"").append(half).append("\"/>")
.append("<w:szCs w:val=\"").append(half).append("\"/>");
if (bold) {
xml.append("<w:b/><w:bCs/>");
}
if (italic) {
xml.append("<w:i/><w:iCs/>");
}
if (underline) {
xml.append("<w:u w:val=\"single\"/>");
}
if (strikeout) {
xml.append("<w:strike/>");
}
xml.append("</w:rPr><w:t");
if (!text.equals(text.strip())) {
xml.append(" xml:space=\"preserve\"");
}
xml.append(">").append(escapeXml(text)).append("</w:t></w:r>");
}
/** rFonts ascii/hAnsi/cs (Word определяет латиницу/кириллицу по hAnsi). */
private static void appendRFonts(StringBuilder xml, String family) {
String esc = escapeXml(family);
xml.append("<w:rFonts w:ascii=\"").append(esc)
.append("\" w:hAnsi=\"").append(esc)
.append("\" w:cs=\"").append(esc).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("&amp;");
case '<' -> out.append("&lt;");
case '>' -> out.append("&gt;");
case '"' -> out.append("&quot;");
default -> {
// управляющие XML 1.0 не допускает — вырезаем
if (ch >= 0x20 || ch == '\t' || ch == '\n' || ch == '\r') {
out.append(ch);
}
}
}
}
return out.toString();
}
}
@@ -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, если атрибут задан явно, иначе база.
*
* <p>{@code dxfs} (§18.8.15) не парсятся: conditional formatting вне v1.</p>
*/
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<FontDef> fonts;
private final List<FillDef> fills;
private final List<BorderDef> borders;
private final List<CellXf> xfs;
/** {@code colors/indexedColors/rgbColor}: индекс 64+n. */
private final List<String> indexedColors;
private StylesModel(List<FontDef> fonts, List<FillDef> fills, List<BorderDef> borders,
List<CellXf> xfs, List<String> 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<String> 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<FontDef> fonts = new ArrayList<>();
private final List<FillDef> fills = new ArrayList<>();
private final List<BorderDef> borders = new ArrayList<>();
private final List<RawXf> styleXfs = new ArrayList<>();
private final List<RawXf> cellXfs = new ArrayList<>();
private final List<String> 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<CellXf> 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<RawXf> parseXfs(XMLStreamReader xr) throws XMLStreamException {
List<RawXf> 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);
}
}
@@ -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<Sheet> sheets;
private final boolean date1904;
private WorkbookModel(List<Sheet> sheets, boolean date1904) {
this.sheets = sheets;
this.date1904 = date1904;
}
/** Листы в порядке {@code sheets}. */
List<Sheet> 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<String, String> 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<Sheet> 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);
}
}
@@ -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 <part>/_rels/<name>.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<String, byte[]> entries = new LinkedHashMap<>();
private final Map<String, List<Rel>> 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/<file>.rels} рядом с {@code partPath}
* (пустой список, если rels-части нет). Парсинг ленивый, повторный вызов
* отдаёт кэш.
*/
List<Rel> rels(String partPath) {
List<Rel> cached = relsByPart.get(partPath);
if (cached != null) {
return cached;
}
String relsPath = relsPathOf(partPath);
List<Rel> 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<String> 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<Rel> parseRels(byte[] data) throws IOException, XMLStreamException {
List<Rel> rels = new ArrayList<>();
Map<String, Boolean> 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;
}
}
@@ -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.
*
* <p>Тот же архитектурный приём, что мост {@code internal.doc}: разбор →
* модель → генерация docx-байтов; наружу из пакета — только {@link #convert}.
* Сгенерированный docx — собственный артефакт, штатной валидацией входа не
* проверяется (вход проверен {@code WordPdfValidator} по байтам .xlsx).</p>
*/
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<DocxPackageWriter.Part> parts = new ArrayList<>();
LinkedHashSet<String> 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("<w:p/>");
}
body.append(tableXml);
}
// финальный абзац body (Word-контент-блок после последней таблицы)
body.append("<w:p/>");
return DocxPackageWriter.write(body.toString(), parts, new ArrayList<>(hyperlinks));
}
}
@@ -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-текст потерян");
}
}
@@ -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("<w:tblGrid>(.*?)</w:tblGrid>").matcher(xml);
assertTrue(grid.find(), "нет tblGrid");
assertTrue(grid.group(1).split("<w:gridCol", -1).length - 1 == 7,
"скрытая колонка H в сетке: " + grid.group(1));
assertTrue(xml.contains("<w:t>Отчёт</w:t>"), "нет заголовка");
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("<w:gridSpan w:val=\"3\"/>"), "нет gridSpan=3 (B2:D2)");
assertTrue(xml.contains("<w:gridSpan w:val=\"2\"/>"), "нет gridSpan=2 (F3:G4)");
assertTrue(xml.contains("<w:vMerge w:val=\"restart\"/>"), "нет vMerge restart");
assertTrue(Pattern.compile("<w:vMerge/>").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\">"), "нет 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("<w:r>", at), at);
assertTrue(run.contains("<w:b/>"), "полужирный run потерян: " + run);
}
@Test
void booleanAndInlineStrings_values() throws IOException {
String xml = documentXml("xlsx-basic.xlsx");
assertTrue(xml.contains("<w:t>TRUE</w:t>"), "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("<w:tbl>", -1).length - 1;
assertTrue(tables == 2, "число таблиц: " + tables);
}
}