diff --git a/AGENTS.md b/AGENTS.md index cd9364a..6fcd5ee 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -32,7 +32,8 @@ ## Архитектура (неочевидное) -- Пайплайн: байты docx → `DocxOnOffNormalizer` → `SymbolFontNormalizer` → docx4j → XSL-FO (XSLT) → FOP → PDF. +- Пайплайн: байты docx → `DocxOnOffNormalizer` → `SymbolFontNormalizer` → `FieldNormalizer` → docx4j → XSL-FO (XSLT) → FOP → PDF. +- Поля страниц: Word пишет `PAGE`/`NUMPAGES` сложным полем (`fldChar begin` → `instrText` → `separate` → кэш → `end`). Экспорт docx4j в FO `w:instrText` внутри такого поля игнорирует и печатает кэш docx — во всех колонтитулах одно число (в эталоне «2» вместо 1, 2, 3 …). `FieldNormalizer` разворачивает поле в `w:fldSimple` (его обрабатывает `FldSimpleWriter` из docx4j-export-fo: PAGE → `fo:page-number`, есть также NUMPAGES/SECTIONPAGES/PAGEREF), сохраняя внутри закэшированные ран — они дают шрифт/размер. Штатный `FieldsCombiner` docx4j делает то же, но не заходит внутрь `w:sdt`, а Word держит нумерацию именно в контентном контроле («Page Numbers (Top of Page)»). Трогаются только инструкции, для которых есть обработчик; вложенные поля пропускаются. Регрессия — `WordPdfConverterTest#pageNumbers_recomputedNotCached`, фикстура `samples/page-numbers.docx`. - Символьные шрифты: Word хранит маркеры списков и спецсимволы кодами из PUA (U+F0xx), глиф выбирается по имени шрифта (`Symbol`, `Wingdings`, `Webdings`). Экспорт docx4j в FO этих шрифтов не знает: код уходит в fallback, глифа нет, FOP рисует `.notdef` — в PDF решётка «#». `SymbolFontNormalizer` (шаг 1.6, тоже правит байты до JAXB) меняет код на Unicode, а имя шрифта — на `DejaVu Sans`. Таблица кодов — `SymbolMapper` из docx4j 17.x, отфильтрована по наличию глифа в DejaVu; константы сгенерированы, менять руками нельзя. Обрабатываются `w:lvl` (numbering.xml), `w:r` и `w:sym`; ран с `w:sym` разрезается, т.к. у символа собственный `w:font`. Регрессия — `WordPdfConverterTest#symbolFonts_bulletsAreNotHash`, фикстура `samples/symbol-bullets.docx`. - Порядок инициализации в `WordPdfConverter.convertToStream` важен: сначала `new BundledFontMapper()`, потом `BundledFonts.init()` (бандл-шрифты регистрируются поверх системных), затем `BundledFonts.restrictToBundled()` (чистит реестр `PhysicalFonts` от системных шрифтов до `load()`; конструктор маппера каждый раз заново добавляет их, и `GlyphCheck` на Windows находит системный Calibri — em-dash остаётся на Carlito, красный `ruPlain_emDashEmbeddedNotHelvetica`). Не менять местами. - docx4j 11.x теряет атрибуты `w:val="off"/"on"` при JAXB-разборе — поэтому нужна нормализация байтов до загрузки (регрессионный тест `ruPlain_regularRunsUseRegularFont`). diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/WordPdfConverter.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/WordPdfConverter.java index 808967d..7b296d8 100644 --- a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/WordPdfConverter.java +++ b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/WordPdfConverter.java @@ -11,6 +11,7 @@ import ru.pjandro.wordpdf.fonts.BundledFontMapper; import ru.pjandro.wordpdf.fonts.BundledFonts; import ru.pjandro.wordpdf.internal.chart.DrawingPreRenderer; import ru.pjandro.wordpdf.internal.DocxOnOffNormalizer; +import ru.pjandro.wordpdf.internal.FieldNormalizer; import ru.pjandro.wordpdf.internal.FopFallbackFonts; import ru.pjandro.wordpdf.internal.SymbolFontNormalizer; @@ -100,6 +101,9 @@ public final class WordPdfConverter { // ...и символьные шрифты Symbol/Wingdings: их коды из PUA экспорт // в FO не понимает и рисует «#» (см. SymbolFontNormalizer). docxBytes = SymbolFontNormalizer.normalize(docxBytes); + // ...и поля PAGE/NUMPAGES из fldChar делаем w:fldSimple, иначе + // в колонтитулах печатается кэш docx (см. FieldNormalizer). + docxBytes = FieldNormalizer.normalize(docxBytes); WordprocessingMLPackage pkg = WordprocessingMLPackage.load( new ByteArrayInputStream(docxBytes)); try { diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/FieldNormalizer.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/FieldNormalizer.java new file mode 100644 index 0000000..b0edc6f --- /dev/null +++ b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/FieldNormalizer.java @@ -0,0 +1,223 @@ +package ru.pjandro.wordpdf.internal; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.nio.charset.StandardCharsets; +import java.util.Locale; +import java.util.zip.ZipEntry; +import java.util.zip.ZipInputStream; +import java.util.zip.ZipOutputStream; + +/** + * Разворачивание «сложных» полей PAGE/NUMPAGES в {@code w:fldSimple} — + * до загрузки docx4j. + * + * Word записывает поле как последовательность ранов: + * {@code fldChar begin} → {@code instrText "PAGE"} → {@code fldChar separate} + * → закэшированный результат → {@code fldChar end}. Экспорт docx4j в XSL-FO + * игнорирует {@code w:instrText} внутри такого поля и печатает кэш из docx, + * поэтому в колонтитулах всех страниц стоит одно и то же число + * (в references/word.docx — «2» вместо 1, 2, 3 …). + * + * Собственно поле docx4j умеет: {@code w:fldSimple} обрабатывает + * {@code FldSimpleWriter} из docx4j-export-fo, у которого есть обработчики + * {@code PAGE} (→ {@code fo:page-number}), {@code NUMPAGES} и + * {@code SECTIONPAGES}. Поэтому переписываем поле в {@code w:fldSimple}, + * сохраняя внутри закэшированные ран — они дают оформление (шрифт, размер). + * + * Штатный {@code FieldsCombiner} docx4j делает то же самое, но не заходит + * внутрь {@code w:sdt}: нумерация страниц Word почти всегда лежит в + * контентном контроле («Page Numbers (Top of Page)»), и до поля не добирается. + * Отсюда и нормализация байтов, как в {@link DocxOnOffNormalizer}. + * + * Трогаются только поля, которые действительно есть кому рисовать + * ({@link #SUPPORTED}); остальные остаются как были. Вложенные поля не + * разбираются — если внутри {@code begin … end} встречается ещё один + * {@code begin}, поле пропускается. + */ +public final class FieldNormalizer { + + /** Инструкции, для которых в docx4j-export-fo есть обработчик fldSimple. */ + private static final String[] SUPPORTED = {"PAGE", "NUMPAGES", "SECTIONPAGES"}; + + private FieldNormalizer() { + } + + /** + * Переписывает поддерживаемые поля во всех word/*.xml частях docx. + * + * @param docx байты .docx (zip) + * @return те же или переупакованные байты + */ + public static byte[] normalize(byte[] docx) throws IOException { + ByteArrayOutputStream out = new ByteArrayOutputStream(docx.length); + boolean changed = false; + try (ZipInputStream zis = new ZipInputStream(new ByteArrayInputStream(docx)); + ZipOutputStream zos = new ZipOutputStream(out)) { + ZipEntry entry; + while ((entry = zis.getNextEntry()) != null) { + byte[] data = zis.readAllBytes(); + String name = entry.getName(); + if (name.startsWith("word/") && name.endsWith(".xml")) { + String fixed = rewrite(new String(data, StandardCharsets.UTF_8)); + if (fixed != null) { + changed = true; + data = fixed.getBytes(StandardCharsets.UTF_8); + } + } + zos.putNextEntry(new ZipEntry(name)); + zos.write(data); + zos.closeEntry(); + } + } + return changed ? out.toByteArray() : docx; + } + + /** + * @return новая строка либо null, если менять нечего + */ + static String rewrite(String xml) { + if (xml.indexOf("fldCharType=\"begin\"") < 0) { + return null; + } + StringBuilder sb = new StringBuilder(xml.length()); + int pos = 0; + boolean changed = false; + while (true) { + int begin = xml.indexOf("fldCharType=\"begin\"", pos); + if (begin < 0) { + break; + } + int runStart = runStart(xml, begin); + int runEnd = xml.indexOf(RUN_CLOSE, begin); + if (runStart < 0 || runEnd < 0) { + break; + } + runEnd += RUN_CLOSE.length(); + + int end = xml.indexOf("fldCharType=\"end\"", runEnd); + int endRunEnd = end < 0 ? -1 : endRunEnd(xml, end); + int nested = xml.indexOf("fldCharType=\"begin\"", runEnd); + // поле без конца, битое или с вложенным полем — пропускаем целиком + int skipTo = endRunEnd >= 0 ? endRunEnd : runEnd; + if (endRunEnd < 0 || (nested >= 0 && nested < end)) { + sb.append(xml, pos, skipTo); + pos = skipTo; + continue; + } + + String instr = instruction(xml.substring(runStart, endRunEnd)); + if (instr.isBlank() || !isSupported(instr)) { + sb.append(xml, pos, endRunEnd); + pos = endRunEnd; + continue; + } + sb.append(xml, pos, runStart) + .append(toFldSimple(instr, cached(xml, runEnd, end))); + pos = endRunEnd; + changed = true; + } + if (!changed) { + return null; + } + return sb.append(xml, pos, xml.length()).toString(); + } + + private static final String RUN_CLOSE = ""; + + /** + * Результат поля: ран-маркер {@code separate} и всё, что идёт после него + * до рана с {@code end}. Если {@code separate} нет, кэша нет — поле + * отрисует обработчик. + */ + private static String cached(String xml, int from, int endMarker) { + int sep = xml.indexOf("fldCharType=\"separate\"", from); + int sepRunEnd = xml.indexOf(RUN_CLOSE, sep); + if (sep < 0 || sep > endMarker || sepRunEnd < 0) { + return ""; + } + sepRunEnd += RUN_CLOSE.length(); + int endRunStart = runStart(xml, endMarker); + if (endRunStart < 0 || endRunStart < sepRunEnd) { + return ""; + } + return xml.substring(sepRunEnd, endRunStart); + } + + /** Склеивает все {@code w:instrText} блока — Word дробит инструкцию на части. */ + private static String instruction(String block) { + StringBuilder instr = new StringBuilder(64); + int pos = 0; + while (true) { + int open = block.indexOf("', open); + int close = block.indexOf("", gt); + if (gt < 0 || close < 0) { + break; + } + instr.append(unescape(block.substring(gt + 1, close))); + pos = close + "".length(); + } + // не trim(): пробелы вокруг инструкции — часть записи Word + return instr.toString(); + } + + private static boolean isSupported(String instr) { + String name = instr.trim().split("[\\\\\\s]", 2)[0].toUpperCase(Locale.ROOT); + for (String s : SUPPORTED) { + if (s.equals(name)) { + return true; + } + } + return false; + } + + private static String toFldSimple(String instr, String cached) { + return "" + + cached + ""; + } + + /** Начало рана, содержащего позицию {@code idx} (раны не вложены). */ + private static int runStart(String xml, int idx) { + for (int i = xml.lastIndexOf("= 0; i = xml.lastIndexOf("= xml.length()) { + continue; + } + char next = xml.charAt(i + 4); + if (next != '>' && next != ' ') { + continue; + } + // между найденным открытием и idx не должно быть конца рана + if (xml.indexOf(RUN_CLOSE, i) > idx) { + return i; + } + } + return -1; + } + + /** Позиция сразу за {@code } рана, содержащего {@code idx}. */ + private static int endRunEnd(String xml, int idx) { + int end = xml.indexOf(RUN_CLOSE, idx); + return end < 0 ? -1 : end + RUN_CLOSE.length(); + } + + private static String escapeAttr(String value) { + return value.replace("&", "&") + .replace("<", "<") + .replace(">", ">") + .replace("\"", """); + } + + private static String unescape(String value) { + String v = value; + if (v.indexOf('&') < 0) { + return v; + } + v = v.replace("<", "<").replace(">", ">").replace(""", "\""); + return v.replace("&", "&"); + } +} diff --git a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/SampleDocxGenerator.java b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/SampleDocxGenerator.java index a29c458..6acd203 100644 --- a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/SampleDocxGenerator.java +++ b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/SampleDocxGenerator.java @@ -6,12 +6,17 @@ import org.apache.poi.xwpf.usermodel.XWPFParagraph; import org.apache.poi.xwpf.usermodel.XWPFRun; import org.apache.poi.xwpf.usermodel.XWPFTable; import org.apache.poi.xwpf.usermodel.XWPFTableCell; +import org.apache.poi.xwpf.usermodel.XWPFHeader; +import org.apache.poi.xwpf.usermodel.XWPFFooter; +import org.apache.poi.wp.usermodel.HeaderFooterType; +import org.apache.poi.xwpf.usermodel.ParagraphAlignment; import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTAbstractNum; import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTFonts; import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTLvl; import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTNumPr; import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTPPr; import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTSym; +import org.openxmlformats.schemas.wordprocessingml.x2006.main.STFldCharType; import org.openxmlformats.schemas.wordprocessingml.x2006.main.STNumberFormat; import org.apache.poi.xwpf.usermodel.XWPFAbstractNum; import org.apache.poi.xwpf.usermodel.XWPFNumbering; @@ -61,6 +66,7 @@ public final class SampleDocxGenerator { ruTimes(dir.resolve("ru-times.docx")); ruTableImage(dir.resolve("ru-table-image.docx")); symbolBullets(dir.resolve("symbol-bullets.docx")); + pageNumbers(dir.resolve("page-numbers.docx")); System.out.println("Готово: " + dir.toAbsolutePath()); } @@ -248,6 +254,53 @@ public final class SampleDocxGenerator { } } + /** + * Нумерация страниц: {@code PAGE} в колонтитуле — сложным полем + * ({@code fldChar} + {@code instrText} + кэш), как его пишет Word. + * Экспорт docx4j в FO {@code instrText} в таком поле игнорирует и печатает + * кэш, поэтому без FieldNormalizers все страницы получают одно число. + */ + private static void pageNumbers(Path out) throws Exception { + try (XWPFDocument doc = new XWPFDocument()) { + XWPFHeader header = doc.createHeader(HeaderFooterType.DEFAULT); + XWPFParagraph hp = header.createParagraph(); + hp.setAlignment(ParagraphAlignment.CENTER); + complexField(hp, " PAGE \\* MERGEFORMAT ", "2"); + + XWPFFooter footer = doc.createFooter(HeaderFooterType.DEFAULT); + XWPFParagraph fp = footer.createParagraph(); + fp.setAlignment(ParagraphAlignment.CENTER); + complexField(fp, " PAGE ", "2"); + fp.createRun().setText(" / "); + complexField(fp, " NUMPAGES \\* ARABIC ", "11"); + + for (int page = 1; page <= 3; page++) { + XWPFParagraph p = doc.createParagraph(); + if (page > 1) { + p.getCTP().addNewPPr().addNewPageBreakBefore(); + } + run(p, "Страница " + page, "Times New Roman", false, false); + } + save(doc, out); + } + } + + /** + * Поле так, как его сохраняет Word: ран {@code fldChar begin}, ран + * {@code instrText}, {@code separate}, закэшированный результат и + * {@code end}. + */ + private static void complexField(XWPFParagraph p, String instr, String cached) { + p.createRun().getCTR().addNewFldChar() + .setFldCharType(STFldCharType.BEGIN); + p.createRun().getCTR().addNewInstrText().setStringValue(instr); + p.createRun().getCTR().addNewFldChar() + .setFldCharType(STFldCharType.SEPARATE); + p.createRun().setText(cached); + p.createRun().getCTR().addNewFldChar() + .setFldCharType(STFldCharType.END); + } + // ================== Вспомогательные ================== /** Абзац-заголовок: POI 5.5 не имеет createHeading, поэтому diff --git a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/WordPdfConverterTest.java b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/WordPdfConverterTest.java index 4316834..7e2f4d0 100644 --- a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/WordPdfConverterTest.java +++ b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/WordPdfConverterTest.java @@ -44,6 +44,16 @@ class WordPdfConverterTest { } } + /** Извлекает текст одной страницы PDF (нумерация колонтитулов). */ + private static String pdfPageText(Path pdf, int page) throws IOException { + try (PDDocument doc = Loader.loadPDF(pdf.toFile())) { + PDFTextStripper stripper = new PDFTextStripper(); + stripper.setStartPage(page); + stripper.setEndPage(page); + return stripper.getText(doc); + } + } + /** Конвертирует docx в временный PDF и возвращает его путь. */ private static Path convert(Path docx) throws IOException { Path out = Files.createTempFile("converted-", ".pdf"); @@ -126,6 +136,26 @@ class WordPdfConverterTest { "пропал текст пункта списка: " + text); } + /** + * Поля PAGE/NUMPAGES Word пишет как {@code fldChar} + {@code instrText} + * + закэшированный результат. Экспорт docx4j в FO инструкцию игнорирует + * и печатает кэш — все страницы получают одно и то же число. + * FieldNormalizer разворачивает поле в {@code w:fldSimple}, и FOP + * считает номер заново на каждой странице. + */ + @Test + void pageNumbers_recomputedNotCached() throws Exception { + Path pdf = convert(extractSample("page-numbers.docx")); + + for (int page = 1; page <= 3; page++) { + String text = norm(pdfPageText(pdf, page)); + assertTrue(text.contains("Страница " + page), + "страница " + page + " содержит не своё содержимое: " + text); + assertTrue(text.contains(page + " / 3"), + "колонтитул страницы " + page + " не пересчитан: " + text); + } + } + @Test void ruPlain_cyrillicAndStyles() throws Exception { Path in = extractSample("ru-plain.docx"); diff --git a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/FieldNormalizerTest.java b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/FieldNormalizerTest.java new file mode 100644 index 0000000..a538532 --- /dev/null +++ b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/FieldNormalizerTest.java @@ -0,0 +1,126 @@ +package ru.pjandro.wordpdf.internal; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + +class FieldNormalizerTest { + + /** Сложное поле Word: begin / instrText / separate / кэш / end. */ + private static String field(String instr, String cached) { + return "" + + "" + instr + + "" + + "" + + "" + cached + "" + + ""; + } + + @Test + void pageFieldBecomesFldSimple() { + String xml = "" + field(" PAGE \\* MERGEFORMAT ", "2") + ""; + String out = FieldNormalizer.rewrite(xml); + + assertTrue(out.startsWith(""), + out); + // кэш остаётся внутри — он даёт оформление (шрифт, размер) + assertTrue(out.contains("2"), out); + assertTrue(out.endsWith(""), out); + assertTrue(!out.contains("fldChar"), "fldChar не удалён: " + out); + } + + @Test + void numpagesAndSectionpagesAreSupported() { + for (String instr : new String[]{" NUMPAGES \\* ARABIC ", " SECTIONPAGES "}) { + String out = FieldNormalizer.rewrite("" + field(instr, "11") + ""); + assertTrue(out.contains(""), instr + ": " + out); + } + } + + /** Инструкцию Word дробит на несколько w:instrText — их нужно склеить. */ + @Test + void instructionSplitAcrossRuns() { + String xml = "" + + " NUM" + + "PAGES " + + "" + + "11" + + ""; + String out = FieldNormalizer.rewrite(xml); + + assertTrue(out.contains(""), out); + } + + @Test + void otherFieldsUntouched() { + String xml = "" + field(" HYPERLINK \"https://example.com\" ", "ссылка") + + ""; + assertNull(FieldNormalizer.rewrite(xml), "чужое поле переписано"); + } + + /** Вложенное поле: разбирать его не берёмся, но и ломать не должны. */ + @Test + void nestedFieldUntouched() { + String xml = "" + + "" + + "= PAGE " + + field(" PAGE ", "2") + + ""; + assertNull(FieldNormalizer.rewrite(xml), "вложенное поле переписано"); + } + + /** Соседние ран-свойства и остальной документ остаются без изменений. */ + @Test + void surroundingContentPreserved() { + String xml = "" + + "до" + field(" PAGE ", "2") + + "после"; + String out = FieldNormalizer.rewrite(xml); + + assertTrue(out.startsWith("" + + "до"), out); + assertTrue(out.endsWith("после"), out); + } + + /** Поле внутри w:sdt — так Word пишет нумерацию «Page Numbers (Top of Page)». */ + @Test + void fieldInsideSdt() { + String xml = "" + + field(" PAGE ", "2") + ""; + String out = FieldNormalizer.rewrite(xml); + + assertTrue(out.startsWith("" + + ""), out); + } + + @Test + void nothingToChangeReturnsNull() { + assertNull(FieldNormalizer.rewrite("текст")); + } + + /** Поле без separate/end — битое, пропускаем, остальное не трогаем. */ + @Test + void unterminatedFieldSkipped() { + String xml = "" + + " PAGE "; + assertNull(FieldNormalizer.rewrite(xml)); + } + + /** Кавычка и ampersand в инструкции не должны сломать атрибут. */ + @Test + void instructionEscapedIntoAttribute() { + String out = FieldNormalizer.rewrite( + "" + field(" STYLEREF \"Раздел & номер\" ", "1") + ""); + // STYLEREF не поддерживается — поле должно остаться как было + assertNull(out); + + String page = FieldNormalizer.rewrite( + "" + field(" PAGE ", "1") + ""); + assertEquals("" + + "1" + + "", page); + } +} diff --git a/wordpdf-core/src/test/resources/samples/page-numbers.docx b/wordpdf-core/src/test/resources/samples/page-numbers.docx new file mode 100644 index 0000000..3b1bac5 Binary files /dev/null and b/wordpdf-core/src/test/resources/samples/page-numbers.docx differ