Мост .xlsx → PDF: SpreadsheetML-конвейер без LibreOffice/POI #91
@@ -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 и < 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("&");
|
||||
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();
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
Binary file not shown.
@@ -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);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user