Символьные шрифты: Symbol/Wingdings -> Unicode (маркеры списков вместо «#»)

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.
This commit is contained in:
Pjandro
2026-10-05 21:10:36 +00:00
parent 87c79d6776
commit 660bc19da7
7 changed files with 708 additions and 4 deletions
@@ -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)
@@ -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 <w:lvlText w:val="&#xF0A7;"/>} + {@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).
*
* Обрабатываются оба места, где встречается символный шрифт:
* <ul>
* <li>{@code w:lvl} (numbering.xml): {@code w:lvlText/@w:val} +
* {@code w:lvl/w:rPr/w:rFonts} — маркеры списков;</li>
* <li>{@code w:r}: текст в {@code w:t} и элементы {@code w:sym}
* ({@code w:sym} имеет собственный {@code w:font}, поэтому ран с ним
* разрезается на части — иначе соседнему тексту поменялся бы шрифт).</li>
* </ul>
*
* Как и {@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<String, String> 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(
"<w:sym\\b[^>]*?/>");
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("<w:sym") < 0) {
return null;
}
String result = rewriteBlocks(xml, "w:lvl");
result = rewriteBlocks(result, "w:r");
return result.equals(xml) ? null : result;
}
/**
* Проходит невложенные блоки {@code <tag ...>} ... {@code </tag>} и
* заменяет каждый через {@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;
}
// самозакрывающийся <w:r ... /> — блока нет
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("<w:sym") >= 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("<w:rFonts");
if (rFonts < 0) {
return null;
}
int end = 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("</w:r>")) {
return block;
}
int tagEnd = block.indexOf('>');
String openTag = block.substring(0, tagEnd + 1);
String body = block.substring(tagEnd + 1, block.length() - "</w:r>".length());
String rPr = "";
if (body.startsWith("<w:rPr>")) {
int rPrEnd = body.indexOf("</w:rPr>");
if (rPrEnd < 0) {
return block;
}
rPr = body.substring(0, rPrEnd + "</w:rPr>".length());
body = body.substring(rPrEnd + "</w:rPr>".length());
}
String fallbackRPr = rPr.isEmpty()
? "<w:rPr><w:rFonts w:ascii=\"" + REPLACEMENT_FAMILY
+ "\" w:hAnsi=\"" + REPLACEMENT_FAMILY + "\"/></w:rPr>"
: 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("</w:r>");
}
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("<w:t xml:space=\"preserve\">").append(mapped)
.append("</w:t></w:r>");
}
pos = m.end();
}
if (pos == 0) {
return block;
}
String tail = body.substring(pos);
if (!tail.isEmpty()) {
sb.append(openTag).append(rPr).append(tail).append("</w:r>");
}
return sb.toString();
}
/**
* Принудительно ставит семейство в {@code w:rPr}: заменяет значения
* атрибутов {@code w:rFonts}, а если {@code w:rFonts} нет — вставляет
* его первым ребёнком (так делает Word).
*/
private static String forceFont(String rPr, String family) {
if (rPr.indexOf("<w:rFonts") < 0) {
return rPr.replaceFirst("<w:rPr>", "<w:rPr><w:rFonts w:ascii=\"" + family
+ "\" w:hAnsi=\"" + family + "\" w:cs=\"" + family + "\"/>");
}
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<String, String> buildMaps() {
Map<String, String> 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";
}
@@ -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, поэтому
@@ -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");
@@ -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 =
"<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
+ "<w:numbering xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\">"
+ "<w:abstractNum w:abstractNumId=\"1\">"
+ "<w:lvl w:ilvl=\"0\"><w:numFmt w:val=\"bullet\"/>"
+ "<w:lvlText w:val=\"\uF0A7\"/>"
+ "<w:rPr><w:rFonts w:ascii=\"Wingdings\" w:hAnsi=\"Wingdings\" w:hint=\"default\"/></w:rPr></w:lvl>"
+ "<w:lvl w:ilvl=\"1\"><w:numFmt w:val=\"bullet\"/>"
+ "<w:lvlText w:val=\"\uF0B7\"/>"
+ "<w:rPr><w:rFonts w:ascii=\"Symbol\" w:hAnsi=\"Symbol\"/></w:rPr></w:lvl>"
+ "<w:lvl w:ilvl=\"2\"><w:numFmt w:val=\"bullet\"/>"
+ "<w:lvlText w:val=\"%1.\"/>"
+ "<w:rPr><w:rFonts w:ascii=\"Times New Roman\"/></w:rPr></w:lvl>"
+ "</w:abstractNum></w:numbering>";
/** Символьный шрифт в ране + w:sym с собственным w:font. */
private static final String DOCUMENT_XML =
"<w:document xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\"><w:body>"
+ "<w:r><w:rPr><w:rFonts w:ascii=\"Symbol\" w:hAnsi=\"Symbol\"/></w:rPr>"
+ "<w:t>\uF0B7 хвостик</w:t></w:r>"
+ "<w:r><w:rPr><w:rFonts w:ascii=\"Times New Roman\"/><w:sz w:val=\"28\"/></w:rPr>"
+ "<w:t xml:space=\"preserve\">до </w:t><w:sym w:font=\"Symbol\" w:char=\"F0A9\"/>"
+ "<w:t xml:space=\"preserve\"> после</w:t></w:r>"
+ "<w:r><w:rPr><w:rFonts w:ascii=\"Times New Roman\"/></w:rPr>"
+ "<w:t>обычный текст</w:t></w:r>"
+ "</w:body></w:document>";
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("<w:document/>", NUMBERING_XML));
String numbering = readEntry(result, "word/numbering.xml");
assertTrue(numbering.contains("<w:lvlText w:val=\"▪\"/>"),
"Wingdings F0A7 не стал ▪: " + numbering);
assertTrue(numbering.contains("<w:lvlText w:val=\"•\"/>"),
"Symbol F0B7 не стал •: " + numbering);
assertTrue(numbering.contains("<w:lvlText w:val=\"%1.\"/>"),
"уровень без символьного шрифта изменён: " + 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("<w:t>• хвостик</w:t>"),
"PUA в ране не заменён: " + document);
assertFalse(document.contains("=\"Symbol\""),
"Symbol остался в w:rFonts: " + document);
assertTrue(document.contains("<w:t>обычный текст</w:t>"),
"чужой ран изменён: " + 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"), "w:sym не заменён: " + document);
assertTrue(document.contains("<w:t xml:space=\"preserve\">до </w:t>"),
"текст до w:sym потерян: " + document);
assertTrue(document.contains("<w:t xml:space=\"preserve\"> после</w:t>"),
"текст после 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("<w:document><w:t>обычный текст</w:t></w:document>", null);
assertSame(docx, SymbolFontNormalizer.normalize(docx));
}
/** Часть вне word/*.xml не трогаем (та же политика, что у DocxOnOffNormalizer). */
@Test
void nonWordPartsNotTouched() throws Exception {
byte[] result = SymbolFontNormalizer.normalize(makeDocx("<w:document/>", NUMBERING_XML));
assertEquals("\uF0A7", readEntry(result, "[Content_Types].xml"));
}
@Test
void rewriteWithoutMatchesIsNull() {
assertNull(SymbolFontNormalizer.rewrite("<w:document><w:t>текст</w:t></w:document>"));
assertNull(SymbolFontNormalizer.rewrite("<w:r><w:t>нет символных шрифтов</w:t></w:r>"));
}
/** Символьный шрифт без кодов из PUA и коды из PUA без шрифта — не трогаем. */
@Test
void fontWithoutPuaAndPuaWithoutFontUntouched() {
assertNull(SymbolFontNormalizer.rewrite(
"<w:r><w:rPr><w:rFonts w:ascii=\"Wingdings\"/></w:rPr><w:t>текст</w:t></w:r>"));
assertNull(SymbolFontNormalizer.rewrite(
"<w:r><w:rPr><w:rFonts w:ascii=\"Arial\"/></w:rPr><w:t>\uF0A7</w:t></w:r>"));
}
}