From 660bc19da74f5aabbb5a5bc6bda6a7114f518b3d Mon Sep 17 00:00:00 2001 From: Pjandro Date: Mon, 5 Oct 2026 21:10:36 +0000 Subject: [PATCH] =?UTF-8?q?=D0=A1=D0=B8=D0=BC=D0=B2=D0=BE=D0=BB=D1=8C?= =?UTF-8?q?=D0=BD=D1=8B=D0=B5=20=D1=88=D1=80=D0=B8=D1=84=D1=82=D1=8B:=20Sy?= =?UTF-8?q?mbol/Wingdings=20->=20Unicode=20(=D0=BC=D0=B0=D1=80=D0=BA=D0=B5?= =?UTF-8?q?=D1=80=D1=8B=20=D1=81=D0=BF=D0=B8=D1=81=D0=BA=D0=BE=D0=B2=20?= =?UTF-8?q?=D0=B2=D0=BC=D0=B5=D1=81=D1=82=D0=BE=20=C2=AB#=C2=BB)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Word задаёт маркеры списков кодами из PUA (U+F0xx), а глиф выбирается по имени шрифта. Экспорт docx4j в XSL-FO эти шрифты не знает: код уходит в fallback-семейство, глифа там нет, FOP рисует .notdef — в PDF решётка «#». SymbolFontNormalizer (шаг перед JAXB, как DocxOnOffNormalizer) меняет код на Unicode, а имя шрифта — на DejaVu Sans. Таблица кодов — SymbolMapper из docx4j 17.x, отфильтрована по наличию глифа в DejaVu; совпадение с экспортом Word сверено по references/word.pdf. Обрабатываются w:lvl (numbering.xml), w:r и w:sym — ран с w:sym разрезается, т.к. у символа собственный w:font. В эталонном документе пропали все 19 решёток в маркированных списках (− • ▪ ❖ ➢ ✓ ♥) и поправились два w:sym. --- AGENTS.md | 3 +- .../ru/pjandro/wordpdf/WordPdfConverter.java | 9 +- .../internal/SymbolFontNormalizer.java | 452 ++++++++++++++++++ .../pjandro/wordpdf/SampleDocxGenerator.java | 67 +++ .../pjandro/wordpdf/WordPdfConverterTest.java | 22 + .../internal/SymbolFontNormalizerTest.java | 159 ++++++ .../resources/samples/symbol-bullets.docx | Bin 0 -> 3037 bytes 7 files changed, 708 insertions(+), 4 deletions(-) create mode 100644 wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/SymbolFontNormalizer.java create mode 100644 wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/SymbolFontNormalizerTest.java create mode 100644 wordpdf-core/src/test/resources/samples/symbol-bullets.docx diff --git a/AGENTS.md b/AGENTS.md index cd1cf14..cd9364a 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -32,7 +32,8 @@ ## Архитектура (неочевидное) -- Пайплайн: байты docx → `DocxOnOffNormalizer` → docx4j → XSL-FO (XSLT) → FOP → PDF. +- Пайплайн: байты docx → `DocxOnOffNormalizer` → `SymbolFontNormalizer` → docx4j → XSL-FO (XSLT) → FOP → PDF. +- Символьные шрифты: 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`). - Диаграммы: `docx2fo.xslt` умеет только `a:graphicData/pic:pic`, для `c:chart` и `dgm:relIds` там `notImplemented` (объект молча исчезает). Поэтому `DrawingPreRenderer.run(pkg)` (шаг 3.5 в `convertToStream`, после `setFontMapper` и до `FOSettings`) рендерит их своим Java2D-движком в PNG 300 dpi (`internal/chart/*`) и подменяет на `pic:pic`. Тест `chartsSmartArt_drawingsBecomeImages`, фикстура `samples/charts-smartart.docx`. 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 10fdd19..808967d 100644 --- a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/WordPdfConverter.java +++ b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/WordPdfConverter.java @@ -12,6 +12,7 @@ import ru.pjandro.wordpdf.fonts.BundledFonts; import ru.pjandro.wordpdf.internal.chart.DrawingPreRenderer; import ru.pjandro.wordpdf.internal.DocxOnOffNormalizer; import ru.pjandro.wordpdf.internal.FopFallbackFonts; +import ru.pjandro.wordpdf.internal.SymbolFontNormalizer; import java.io.ByteArrayInputStream; import java.io.OutputStream; @@ -95,10 +96,12 @@ public final class WordPdfConverter { // 2. Загрузка документа. Предварительно нормализуем w:val="off"/"on" // в "false"/"true": docx4j 11.x теряет атрибуты "off"/"on" // при JAXB-разборе (см. DocxOnOffNormalizer). - byte[] docxBytes = Files.readAllBytes(docxIn); - byte[] normalized = DocxOnOffNormalizer.normalize(docxBytes); + byte[] docxBytes = DocxOnOffNormalizer.normalize(Files.readAllBytes(docxIn)); + // ...и символьные шрифты Symbol/Wingdings: их коды из PUA экспорт + // в FO не понимает и рисует «#» (см. SymbolFontNormalizer). + docxBytes = SymbolFontNormalizer.normalize(docxBytes); WordprocessingMLPackage pkg = WordprocessingMLPackage.load( - new ByteArrayInputStream(normalized)); + new ByteArrayInputStream(docxBytes)); try { // 3. Привязка маппера: docx4j сопоставляет шрифты документа // с физическими TTF (учитывая и шрифты, встроенные в docx) diff --git a/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/SymbolFontNormalizer.java b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/SymbolFontNormalizer.java new file mode 100644 index 0000000..d9cd810 --- /dev/null +++ b/wordpdf-core/src/main/java/ru/pjandro/wordpdf/internal/SymbolFontNormalizer.java @@ -0,0 +1,452 @@ +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.HashMap; +import java.util.Locale; +import java.util.Map; +import java.util.regex.Matcher; +import java.util.regex.Pattern; +import java.util.zip.ZipEntry; +import java.util.zip.ZipInputStream; +import java.util.zip.ZipOutputStream; + +/** + * Замена символьных шрифтов (Symbol/Wingdings/Webdings) на Unicode + + * бандл-шрифт — до загрузки docx4j. + * + * Word хранит маркеры списков и спецсимволы кодами из private use area + * (U+F0xx), а какой именно глиф покажет документ, задаёт шрифт: + * {@code } + {@code w:rFonts w:ascii="Wingdings"} + * — это «▪», а тот же код в Symbol — «♣». Экспорт docx4j в XSL-FO эти + * шрифты не знает: код уходит в fallback-семейство, глифа там нет, и FOP + * рисует {@code .notdef} — в PDF решётку «#» (регрессия: + * {@code WordPdfConverterTest#symbolFonts_bulletsAreNotHash}). + * + * Делаем то же, что Word: код из PUA заменяем его Unicode-эквивалентом, + * а имя шрифта — на fallback-семейство (в нём этих глифов достаточно). + * Таблица кодов — из {@code org.docx4j.convert.out.common.writer.SymbolMapper} + * (docx4j 17.x), отфильтрована по наличию глифа в DejaVu Sans; она же + * сверяется с эталоном Word (references/word.pdf). + * + * Обрабатываются оба места, где встречается символный шрифт: + * + * + * Как и {@link DocxOnOffNormalizer}, правим байты zip до JAXB-разбора. + */ +public final class SymbolFontNormalizer { + + /** Семейство, на которое заменяются символьные шрифты (есть в jar). */ + static final String REPLACEMENT_FAMILY = "DejaVu Sans"; + + /** + * Имя шрифта (lowercase) -> таблица из 256 слотов по 4 hex-цифры: + * младший байт кода из PUA -> Unicode-код цели (0 — соответствия нет). + * Источник — SymbolMapper из docx4j 17.x; сгенерировано, см. javadoc + * класса. Коды вне U+F000–U+F0FF (обычная ASCII-часть символьного + * шрифта) не переписываются. + */ + private static final Map SYMBOL_MAPS = buildMaps(); + + /** w:rFonts с именем символьного шрифта в любом из атрибутов. */ + private static final Pattern SYMBOL_FONT_ATTR = Pattern.compile( + "w:(?:ascii|hAnsi|cs|eastAsia)=\"([^\"]+)\""); + + /** w:sym w:font="Symbol" w:char="F02D" */ + private static final Pattern SYM_ELEMENT = Pattern.compile( + "]*?/>"); + + private static final Pattern SYM_FONT = Pattern.compile("w:font=\"([^\"]+)\""); + private static final Pattern SYM_CHAR = Pattern.compile("w:char=\"([0-9A-Fa-f]{4})\""); + + private SymbolFontNormalizer() { + } + + /** + * Заменяет символьные шрифты в XML-частях docx (word/*.xml). + * + * @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; + } + + /** + * Переписывает {@code w:lvl} и {@code w:r} с символьными шрифтами. + * + * @return новая строка либо null, если менять нечего + */ + static String rewrite(String xml) { + // Быстрый путь: ни кода из PUA (U+F000–U+F0FF), ни w:sym. + if (!hasPua(xml) && xml.indexOf("} ... {@code } и + * заменяет каждый через {@link #rewriteBlock}. + */ + private static String rewriteBlocks(String xml, String tag) { + String open = "<" + tag; + String close = ""; + StringBuilder sb = new StringBuilder(xml.length()); + int pos = 0; + while (true) { + int start = indexOfOpenTag(xml, open, pos); + if (start < 0) { + break; + } + int openEnd = xml.indexOf('>', start); + int end = xml.indexOf(close, openEnd); + if (openEnd < 0 || end < 0) { + break; + } + end += close.length(); + String block = xml.substring(start, end); + sb.append(xml, pos, start).append(rewriteBlock(block)); + pos = end; + } + if (pos == 0) { + return xml; + } + return sb.append(xml, pos, xml.length()).toString(); + } + + /** Есть ли в строке символ из U+F000–U+F0FF. */ + private static boolean hasPua(String xml) { + for (int i = 0; i < xml.length(); i++) { + char c = xml.charAt(i); + if (c >= 0xF000 && c <= 0xF0FF) { + return true; + } + } + return false; + } + + /** Позиция открывающего (не самозакрывающегося) тега {@code open}. */ + private static int indexOfOpenTag(String xml, String open, int from) { + int i = xml.indexOf(open, from); + while (i >= 0) { + char next = i + open.length() < xml.length() ? xml.charAt(i + open.length()) : 0; + if (next == '>' || next == ' ' || next == '\t' || next == '\n' || next == '\r') { + int openEnd = xml.indexOf('>', i); + if (openEnd < 0) { + return -1; + } + // самозакрывающийся — блока нет + return xml.charAt(openEnd - 1) == '/' ? indexOfOpenTag(xml, open, openEnd) : i; + } + i = xml.indexOf(open, i + open.length()); + } + return -1; + } + + /** Переписывает один блок {@code w:lvl} или {@code w:r}. */ + private static String rewriteBlock(String block) { + String symbolFont = symbolFontOf(block); + String map = symbolFont == null ? null : SYMBOL_MAPS.get(symbolFont.toLowerCase(Locale.ROOT)); + boolean hasSym = block.indexOf("= 0; + if (map == null && !hasSym) { + return block; + } + // w:sym имеет собственный w:font, поэтому обрабатывается и в ране + // с обычным шрифтом (например, Times New Roman + Symbol). + String result = hasSym ? replaceSymElements(block, map) : block; + if (map == null) { + return result; + } + result = mapPua(result, map); + return replaceFontNames(result); + } + + /** Имя символьного шрифта, объявленного в {@code w:rFonts} блока. */ + private static String symbolFontOf(String block) { + int rFonts = block.indexOf("', rFonts); + if (end < 0) { + return null; + } + Matcher m = SYMBOL_FONT_ATTR.matcher(block.substring(rFonts, end)); + while (m.find()) { + String name = m.group(1).toLowerCase(Locale.ROOT); + if (SYMBOL_MAPS.containsKey(name)) { + return m.group(1); + } + } + return null; + } + + /** + * Заменяет коды из U+F000–U+F0FF на Unicode по таблице {@code map}. + * Касается {@code w:t}, {@code w:lvlText/@w:val} и текста самого блока. + */ + private static String mapPua(String block, String map) { + StringBuilder sb = new StringBuilder(block.length()); + for (int i = 0; i < block.length(); i++) { + char c = block.charAt(i); + if (c >= 0xF000 && c <= 0xF0FF) { + char mapped = mapped(map, c & 0xFF); + sb.append(mapped != 0 ? mapped : c); + } else { + sb.append(c); + } + } + return sb.toString(); + } + + /** + * Разрезает ран по элементам {@code w:sym}: каждый заменяется раном с + * {@code w:t} (Unicode-глиф) и fallback-шрифтом, соседний текст + * остаётся со своим {@code w:rPr}. + */ + private static String replaceSymElements(String block, String map) { + if (!block.endsWith("")) { + return block; + } + int tagEnd = block.indexOf('>'); + String openTag = block.substring(0, tagEnd + 1); + String body = block.substring(tagEnd + 1, block.length() - "".length()); + + String rPr = ""; + if (body.startsWith("")) { + int rPrEnd = body.indexOf(""); + if (rPrEnd < 0) { + return block; + } + rPr = body.substring(0, rPrEnd + "".length()); + body = body.substring(rPrEnd + "".length()); + } + String fallbackRPr = rPr.isEmpty() + ? "" + : forceFont(rPr, REPLACEMENT_FAMILY); + + StringBuilder sb = new StringBuilder(block.length()); + int pos = 0; + Matcher m = SYM_ELEMENT.matcher(body); + while (m.find()) { + String text = body.substring(pos, m.start()); + if (!text.isEmpty()) { + sb.append(openTag).append(rPr).append(text).append(""); + } + String charHex = firstGroup(SYM_CHAR, m.group()); + String font = firstGroup(SYM_FONT, m.group()); + String fontMap = font == null ? map + : SYMBOL_MAPS.getOrDefault(font.toLowerCase(Locale.ROOT), map); + char mapped = 0; + if (charHex != null && fontMap != null) { + char code = (char) Integer.parseInt(charHex, 16); + if (code >= 0xF000 && code <= 0xF0FF) { + mapped = mapped(fontMap, code & 0xFF); + } + } + if (mapped != 0) { + sb.append(openTag).append(fallbackRPr) + .append("").append(mapped) + .append(""); + } + pos = m.end(); + } + if (pos == 0) { + return block; + } + String tail = body.substring(pos); + if (!tail.isEmpty()) { + sb.append(openTag).append(rPr).append(tail).append(""); + } + return sb.toString(); + } + + /** + * Принудительно ставит семейство в {@code w:rPr}: заменяет значения + * атрибутов {@code w:rFonts}, а если {@code w:rFonts} нет — вставляет + * его первым ребёнком (так делает Word). + */ + private static String forceFont(String rPr, String family) { + if (rPr.indexOf("", ""); + } + Matcher m = SYMBOL_FONT_ATTR.matcher(rPr); + StringBuilder sb = new StringBuilder(rPr.length()); + while (m.find()) { + m.appendReplacement(sb, Matcher.quoteReplacement( + m.group().replace(m.group(1), family))); + } + m.appendTail(sb); + return sb.toString(); + } + + /** Имена символьных шрифтов в {@code w:rFonts} -> fallback-семейство. */ + private static String replaceFontNames(String block) { + Matcher m = SYMBOL_FONT_ATTR.matcher(block); + if (!m.find()) { + return block; + } + m.reset(); + StringBuilder sb = new StringBuilder(block.length()); + while (m.find()) { + String replacement = SYMBOL_MAPS.containsKey(m.group(1).toLowerCase(Locale.ROOT)) + ? m.group().replace(m.group(1), REPLACEMENT_FAMILY) + : m.group(); + m.appendReplacement(sb, Matcher.quoteReplacement(replacement)); + } + m.appendTail(sb); + return sb.toString(); + } + + private static String firstGroup(Pattern p, String input) { + Matcher m = p.matcher(input); + return m.find() ? m.group(1) : null; + } + + /** Unicode-код цели для младшего байта кода PUA; 0 — соответствия нет. */ + private static char mapped(String map, int slot) { + int hi = Character.digit(map.charAt(slot * 4), 16) << 12 + | Character.digit(map.charAt(slot * 4 + 1), 16) << 8 + | Character.digit(map.charAt(slot * 4 + 2), 16) << 4 + | Character.digit(map.charAt(slot * 4 + 3), 16); + return (char) hi; + } + + private static Map buildMaps() { + Map m = new HashMap<>(); + m.put("symbol", MAP_SYMBOL); + m.put("wingdings", MAP_WINGDINGS); + m.put("wingdings 2", MAP_WINGDINGS_2); + m.put("wingdings 3", MAP_WINGDINGS_3); + m.put("webdings", MAP_WEBDINGS); + return Map.copyOf(m); + } + + // Symbol: 256 слотов по 4 hex-цифры, индекс = младший байт кода U+F0?? + private static final String MAP_SYMBOL = + "0000000000000000000000000000000000000000000000000000000000000000" + + "0000000000000000000000000000000000000000000000000000000000000000" + + "0000002122000023220300250026220D002800292217002B002C2212002E002F" + + "0030003100320033003400350036003700380039003A003B003C003D003E003F" + + "22450391039203A70394039503A603930397039903D1039A039B039C039D039F" + + "03A0039803A103A303A403A503C203A9039E03A80396005B2234005D22A5005F" + + "000003B103B203C703B403B503C603B303B703B903D503BA03BB03BC03BD03BF" + + "03C003B803C103C303C403C503D603C903BE03C803B6007B007C007D223C0000" + + "0000000000000000000000000000000000000000000000000000000000000000" + + "0000000000000000000000000000000000000000000000000000000000000000" + + "000003D2203222642044221E0192266326662665266021942190219121922193" + + "00B000B12033226500D7221D2202202200F7226022612248202623D023AF21B5" + + "21352111211C21182297229522052229222A2283228722842282228622082209" + + "2220220700AE00A92122220F221A22C500AC2227222821D421D021D121D221D3" + + "25CA232900AE00A921222211239B239C239D23A123A223A323A723A823A923AA" + + "20AC232A222B232023AE2321239E239F23A023A423A523A623AB23AC23AD0000"; + + // Wingdings: 256 слотов по 4 hex-цифры, индекс = младший байт кода U+F0?? + private static final String MAP_WINGDINGS = + "0000000000000000000000000000000000000000000000000000000000000000" + + "0000000000000000000000000000000000000000000000000000000000000000" + + "0000000027022701000000000000000000002706000000000000000000000000" + + "000000000000000000000000231B00000000000000000000000000002707270D" + + "0000270C000000000000261C261E261D261F0000263A00002639000026200000" + + "00002708263C000027440000271E000027202721262A262F0950263826482649" + + "264A264B264C264D264E264F26502651265226530000000025CF000025A025A1" + + "0000275127522B2729EB25C627562B2523272BB9231800000000000000000000" + + "24EA246024612462246324642465246624672468246924FF2776277727782779" + + "277A277B277C277D277E277F0000000000000000000000000000000000B72022" + + "25AA26AA0000000025C925CE000025AA25FB0000272626052736273427392735" + + "2BD0231627E123112BD1272A2730000000000000000000000000000000000000" + + "0000000000002BB02BB12BB22BB32BB42BB52BB62BB700000000000000000000" + + "00000000000000000000232B23262B9827A22B992B9B2B882B8A2B892B8B0000" + + "00000000000000000000000000000000000000000000000000000000000021E6" + + "21E821E721E92B0421F32B002B012B032B02000000000000271300000000229E"; + + // Wingdings 2: 256 слотов по 4 hex-цифры, индекс = младший байт кода U+F0?? + private static final String MAP_WINGDINGS_2 = + "0000000000000000000000000000000000000000000000000000000000000000" + + "0000000000000000000000000000000000000000000000000000000000000000" + + "0000000000000000000027042700000000000000000000000000000000000000" + + "0000000000000000000000000000000000000000000000000000000000000000" + + "0000000000000000000000000000000000000000000000000000000000000000" + + "271300002611261226122BBE2BBF29B829B80000000000000000203D00000000" + + "00000000000000000000000000000000000024EA246024612462246324642465" + + "246624672468246924FF2776277727782779277A277B277C277D277E277F0000" + + "26090000263D263E2E3F271D0000000000000000000000000000000000000000" + + "00000000000000000000202225CF26AB2B240000000000000000000029BF25FE" + + "25A025FC2B1B2B1C000000000000000025A30000000000002B292B2525C625C7" + + "000025C80000000000002B2A2B2729EB25CA000025D625D72BCA2BCB25FC2B25" + + "2B1F2BC22B232B222BC32BC40000000000000000000000000000000000000000" + + "0000000000000000000000000000000000000000000000000000000000000000" + + "0000000000000000000000000000000027260000260527360000273700000000" + + "273900000000272F000000002BCC2BCD203B2042000000000000000000000000"; + + // Wingdings 3: 256 слотов по 4 hex-цифры, индекс = младший байт кода U+F0?? + private static final String MAP_WINGDINGS_3 = + "0000000000000000000000000000000000000000000000000000000000000000" + + "0000000000000000000000000000000000000000000000000000000000000000" + + "00002B602B622B612B632B662B672B692B682B702B722B712B732B762B782B7B" + + "2B7D2B642B652B6A2B6C2B6B2B6D2B4D2BA02BA12BA22BA32BA42BA52BA62BA7" + + "2B902B912B922B932B802B832B7E2B7F2B842B862B852B872B8F2B8D2B8E2B8C" + + "2B6E2B6F238B23242303232523B5237D21EA2BB8000000000000000000000000" + + "0000000000000000000000002190219221912193219621972199219800000000" + + "25B225BC25B325BD25C425BA25C125B725E325E225E425E50000000000000000" + + "000025B225BC25C025B62B9C2B9E2B9D2B9F0000000000000000000000000000" + + "0000000000000000000000000000000000000000000000000000000000000000" + + "0000000000000000000000000000000000000000000000000000000000000000" + + "0000000000000000000000000000000000000000000000000000000000000000" + + "0000000000000000000000000000000000002BA82BA92BAA2BAB2BAC2BAD2BAE" + + "2BAF000000000000000000000000000000000000000000000000000000000000" + + "0000000000000000000000000000000000000000000000000000000000000000" + + "0000000000000000000000000000000000000000000000000000000000000000"; + + // Webdings: 256 слотов по 4 hex-цифры, индекс = младший байт кода U+F0?? + private static final String MAP_WEBDINGS = + "0000000000000000000000000000000000000000000000000000000000000000" + + "0000000000000000000000000000000000000000000000000000000000000000" + + "0000000000000000000000000000000000000000000000000000000000000000" + + "00000000000023F423F523F623F723EA23E923EE23ED23F823F923FA00000000" + + "0000000000000000000000000000000000000000000000000000000000000000" + + "0000000000000000000000000000000000000000000000000000000000000000" + + "2B942714000025A100000000000025A000000000000000000000000026AB0000" + + "000000000000275300000000000026F30000229600000000007C000000000000" + + "000000000000000000000000000026F700000000000000000000000000000000" + + "00000000000000000000000000000000272F0000000000000000000000000000" + + "0000000000000000000000000000000000000000000000000000000000000000" + + "0000000000000000000000000000000000000000000000000000000000000000" + + "0000000000000000000000000000000000000000000000000000000000000000" + + "0000000000000000000000000000000000002601000000000000000000000000" + + "0000000000000000000000000000000024C5267F000000000000000000000000" + + "0000000000000000000000000000000000000000000000000000000000000000"; +} 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 5e5e7a4..a29c458 100644 --- a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/SampleDocxGenerator.java +++ b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/SampleDocxGenerator.java @@ -6,7 +6,15 @@ 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.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.STNumberFormat; +import org.apache.poi.xwpf.usermodel.XWPFAbstractNum; +import org.apache.poi.xwpf.usermodel.XWPFNumbering; import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTR; import org.openxmlformats.schemas.wordprocessingml.x2006.main.CTRPr; @@ -17,6 +25,7 @@ import java.awt.image.BufferedImage; import java.io.ByteArrayOutputStream; import java.io.File; import java.io.FileOutputStream; +import java.math.BigInteger; import java.nio.file.Path; import java.nio.file.Paths; import java.util.List; @@ -51,6 +60,7 @@ public final class SampleDocxGenerator { ruEnMixed(dir.resolve("ru-en-mixed.docx")); ruTimes(dir.resolve("ru-times.docx")); ruTableImage(dir.resolve("ru-table-image.docx")); + symbolBullets(dir.resolve("symbol-bullets.docx")); System.out.println("Готово: " + dir.toAbsolutePath()); } @@ -181,6 +191,63 @@ public final class SampleDocxGenerator { } } + /** + * Маркеры списков из символьных шрифтов: {@code w:lvlText} кодами из + * PUA (U+F0xx) + {@code w:rFonts} = Symbol/Wingdings, символьный шрифт + * прямо в ране и отдельный {@code w:sym}. Без SymbolFontNormalizer все + * они превращаются в «#». + */ + private static void symbolBullets(Path out) throws Exception { + try (XWPFDocument doc = new XWPFDocument()) { + heading(doc, "Символьные шрифты", "Times New Roman"); + + XWPFNumbering numbering = doc.createNumbering(); + CTAbstractNum abstractNum = CTAbstractNum.Factory.newInstance(); + abstractNum.setAbstractNumId(BigInteger.ONE); + String[][] markers = { + {"Wingdings", "F0A7"}, // ▪ + {"Symbol", "F0B7"}, // • + {"Symbol", "F02D"}, // − + {"Wingdings", "F076"}, // ❖ + }; + for (int i = 0; i < markers.length; i++) { + CTLvl lvl = abstractNum.addNewLvl(); + lvl.setIlvl(BigInteger.valueOf(i)); + lvl.addNewStart().setVal(BigInteger.ONE); + lvl.addNewNumFmt().setVal(STNumberFormat.BULLET); + lvl.addNewLvlText().setVal( + String.valueOf((char) Integer.parseInt(markers[i][1], 16))); + CTFonts fonts = lvl.addNewRPr().addNewRFonts(); + fonts.setAscii(markers[i][0]); + fonts.setHAnsi(markers[i][0]); + } + BigInteger numId = numbering.addNum( + numbering.addAbstractNum(new XWPFAbstractNum(abstractNum))); + + for (int i = 0; i < markers.length; i++) { + XWPFParagraph p = doc.createParagraph(); + CTPPr pPr = p.getCTP().isSetPPr() ? p.getCTP().getPPr() : p.getCTP().addNewPPr(); + CTNumPr numPr = pPr.addNewNumPr(); + numPr.addNewIlvl().setVal(BigInteger.valueOf(i)); + numPr.addNewNumId().setVal(numId); + run(p, "Пункт " + (i + 1) + " со списочным маркером", + "Times New Roman", false, false); + } + + XWPFParagraph p = doc.createParagraph(); + run(p, "\uF0B7 маркер в ране Symbol", "Symbol", false, false); + run(p, " и обычный текст Times New Roman", "Times New Roman", false, false); + + p = doc.createParagraph(); + CTSym sym = p.createRun().getCTR().addNewSym(); + sym.setFont("Symbol"); + sym.setChar(new byte[]{(byte) 0xF0, (byte) 0xA9}); // ♥ + run(p, " это был символ w:sym", "Times New Roman", false, false); + + save(doc, out); + } + } + // ================== Вспомогательные ================== /** Абзац-заголовок: 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 a46968e..4316834 100644 --- a/wordpdf-core/src/test/java/ru/pjandro/wordpdf/WordPdfConverterTest.java +++ b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/WordPdfConverterTest.java @@ -14,6 +14,7 @@ import java.io.InputStream; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.StandardCopyOption; +import java.util.List; import java.util.Set; import java.util.TreeSet; @@ -104,6 +105,27 @@ class WordPdfConverterTest { "ожидались 4 растра (SmartArt + 3 графика), найдено: " + imageCount(pdf)); } + /** + * Маркеры списков из символьных шрифтов (Symbol/Wingdings, коды из + * PUA U+F0xx) экспорт в FO не понимает и рисует .notdef — решётку «#». + * SymbolFontNormalizer заменяет их Unicode-эквивалентами, поэтому + * маркеры остаются маркерами. + */ + @Test + void symbolFonts_bulletsAreNotHash() throws Exception { + Path in = extractSample("symbol-bullets.docx"); + String text = norm(pdfText(convert(in))); + + for (String marker : List.of("▪", "•", "−", "❖", "♥")) { + assertTrue(text.contains(marker), + "нет маркера «" + marker + "»: " + text); + } + assertFalse(text.contains("#"), + "в PDF остались .notdef-решётки вместо маркеров: " + text); + assertTrue(text.contains("Пункт 1 со списочным маркером"), + "пропал текст пункта списка: " + 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/SymbolFontNormalizerTest.java b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/SymbolFontNormalizerTest.java new file mode 100644 index 0000000..84b6ec9 --- /dev/null +++ b/wordpdf-core/src/test/java/ru/pjandro/wordpdf/internal/SymbolFontNormalizerTest.java @@ -0,0 +1,159 @@ +package ru.pjandro.wordpdf.internal; + +import org.junit.jupiter.api.Test; + +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.nio.charset.StandardCharsets; +import java.util.zip.ZipEntry; +import java.util.zip.ZipInputStream; +import java.util.zip.ZipOutputStream; + +import static org.junit.jupiter.api.Assertions.*; + +/** + * Замена символьных шрифтов Symbol/Wingdings на Unicode + бандл-шрифт + * (см. SymbolFontNormalizer). Коды берутся из SymbolMapper docx4j 17.x и + * сверяются с экспортом Word (references/word.pdf). + */ +class SymbolFontNormalizerTest { + + /** Маркеры списков: Wingdings F0A7 -> ▪, Symbol F0B7 -> •, F02D -> −. */ + private static final String NUMBERING_XML = + "" + + "" + + "" + + "" + + "" + + "" + + "" + + "" + + "" + + "" + + "" + + "" + + ""; + + /** Символьный шрифт в ране + w:sym с собственным w:font. */ + private static final String DOCUMENT_XML = + "" + + "" + + "\uF0B7 хвостик" + + "" + + "до " + + " после" + + "" + + "обычный текст" + + ""; + + private static byte[] makeDocx(String documentXml, String numberingXml) throws IOException { + ByteArrayOutputStream out = new ByteArrayOutputStream(); + try (ZipOutputStream zos = new ZipOutputStream(out)) { + zos.putNextEntry(new ZipEntry("[Content_Types].xml")); + zos.write("\uF0A7".getBytes(StandardCharsets.UTF_8)); + zos.closeEntry(); + zos.putNextEntry(new ZipEntry("word/document.xml")); + zos.write(documentXml.getBytes(StandardCharsets.UTF_8)); + zos.closeEntry(); + if (numberingXml != null) { + zos.putNextEntry(new ZipEntry("word/numbering.xml")); + zos.write(numberingXml.getBytes(StandardCharsets.UTF_8)); + zos.closeEntry(); + } + } + return out.toByteArray(); + } + + private static String readEntry(byte[] zip, String name) throws IOException { + try (ZipInputStream zis = new ZipInputStream( + new java.io.ByteArrayInputStream(zip))) { + ZipEntry e; + while ((e = zis.getNextEntry()) != null) { + if (e.getName().equals(name)) { + return new String(zis.readAllBytes(), StandardCharsets.UTF_8); + } + } + } + throw new AssertionError("нет записи " + name); + } + + @Test + void listMarkersBecomeUnicode() throws Exception { + byte[] result = SymbolFontNormalizer.normalize(makeDocx("", NUMBERING_XML)); + + String numbering = readEntry(result, "word/numbering.xml"); + assertTrue(numbering.contains(""), + "Wingdings F0A7 не стал ▪: " + numbering); + assertTrue(numbering.contains(""), + "Symbol F0B7 не стал •: " + numbering); + assertTrue(numbering.contains(""), + "уровень без символьного шрифта изменён: " + numbering); + assertFalse(numbering.contains("Wingdings"), "имя шрифта не заменено: " + numbering); + assertTrue(numbering.contains("w:ascii=\"" + SymbolFontNormalizer.REPLACEMENT_FAMILY + "\""), + "fallback-семейство не проставлено: " + numbering); + } + + @Test + void symbolFontInRunIsReplaced() throws Exception { + byte[] result = SymbolFontNormalizer.normalize(makeDocx(DOCUMENT_XML, null)); + + String document = readEntry(result, "word/document.xml"); + assertTrue(document.contains("• хвостик"), + "PUA в ране не заменён: " + document); + assertFalse(document.contains("=\"Symbol\""), + "Symbol остался в w:rFonts: " + document); + assertTrue(document.contains("обычный текст"), + "чужой ран изменён: " + document); + } + + /** + * w:sym имеет собственный w:font, поэтому ран разрезается: символ + * уходит в fallback-шрифт, соседний текст сохраняет Times New Roman. + */ + @Test + void symElementSplitsRunAndKeepsNeighbourFont() throws Exception { + byte[] result = SymbolFontNormalizer.normalize(makeDocx(DOCUMENT_XML, null)); + + String document = readEntry(result, "word/document.xml"); + assertTrue(document.contains("♥"), "w:sym F0A9 не стал ♥: " + document); + assertFalse(document.contains("до "), + "текст до w:sym потерян: " + document); + assertTrue(document.contains(" после"), + "текст после w:sym потерян: " + document); + // Соседний текст остался на своём шрифте, символ — на fallback + assertTrue(document.contains("w:ascii=\"Times New Roman\""), + "шрифт соседнего текста изменён: " + document); + assertTrue(document.contains("♥"), "символ потерян: " + document); + } + + @Test + void nothingToChangeReturnsOriginalArray() throws Exception { + byte[] docx = makeDocx("обычный текст", null); + + assertSame(docx, SymbolFontNormalizer.normalize(docx)); + } + + /** Часть вне word/*.xml не трогаем (та же политика, что у DocxOnOffNormalizer). */ + @Test + void nonWordPartsNotTouched() throws Exception { + byte[] result = SymbolFontNormalizer.normalize(makeDocx("", NUMBERING_XML)); + + assertEquals("\uF0A7", readEntry(result, "[Content_Types].xml")); + } + + @Test + void rewriteWithoutMatchesIsNull() { + assertNull(SymbolFontNormalizer.rewrite("текст")); + assertNull(SymbolFontNormalizer.rewrite("нет символных шрифтов")); + } + + /** Символьный шрифт без кодов из PUA и коды из PUA без шрифта — не трогаем. */ + @Test + void fontWithoutPuaAndPuaWithoutFontUntouched() { + assertNull(SymbolFontNormalizer.rewrite( + "текст")); + assertNull(SymbolFontNormalizer.rewrite( + "\uF0A7")); + } +} diff --git a/wordpdf-core/src/test/resources/samples/symbol-bullets.docx b/wordpdf-core/src/test/resources/samples/symbol-bullets.docx new file mode 100644 index 0000000000000000000000000000000000000000..b253344081258c9e7363dbd8a733ffdcb201495b GIT binary patch literal 3037 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 bjnIFgAKFe3xF84w0e)YB{