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).
+ *
+ * Обрабатываются оба места, где встречается символный шрифт:
+ *
+ * - {@code w:lvl} (numbering.xml): {@code w:lvlText/@w:val} +
+ * {@code w:lvl/w:rPr/w:rFonts} — маркеры списков;
+ * - {@code w:r}: текст в {@code w:t} и элементы {@code w:sym}
+ * ({@code w:sym} имеет собственный {@code w:font}, поэтому ран с ним
+ * разрезается на части — иначе соседнему тексту поменялся бы шрифт).
+ *
+ *
+ * Как и {@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 = "" + tag + ">";
+ 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 0000000..b253344
Binary files /dev/null and b/wordpdf-core/src/test/resources/samples/symbol-bullets.docx differ