Экзотические глифы: решётка «#» вместо .notdef
Знак без глифа в шрифте ранa FOP рисовал .notdef — в эталонном references/word.docx таких оставалось 28. - Noto Naskh Arabic и Noto Sans Armenian (SIL OFL, 278 КБ) в бандле: FontFallback.selectCovering перебирает весь реестр PhysicalFonts и находит их сам — арабские дополнения и армянские Unicode 16 рисуются без нашего кода. - GlyphCoverageNormalizer режет ран по покрытию глифов и пишет семейство в w:rFonts. Нужен из-за двух дыр docx4j: needsCoverage=false для «латинской» группы (римские цифры U+2150–U+218F) и кэш fallbackByScript на всю группу Юникода (армянские U+058D/U+058E получали DejaVu Serif). - FopFallbackFonts.declare декларирует все бандл-семейства: FOP встраивает только задекларированные, а font-family в FO может запросить любое. В эталоне осталось 2 решёток: U+2188 и U+218A есть только в GNU FreeSerif (GPL-3+ с Font Exception), которого в бандле нет намеренно.
This commit is contained in:
@@ -25,15 +25,19 @@
|
||||
|
||||
## Шрифты (важно при изменениях)
|
||||
|
||||
- 28 TTF в `wordpdf-core/src/main/resources/fonts/` — бинарные фикстуры, часть jar; не удалять/переименовывать без обновления маппинга.
|
||||
- 30 TTF в `wordpdf-core/src/main/resources/fonts/` — бинарные фикстуры, часть jar; не удалять/переименовывать без обновления маппинга.
|
||||
- Алиасы MS→open-source: Calibri→Carlito, Cambria→Caladea, Arial→Arimo, Times New Roman→Tinos, Courier New→Cousine; fallback — DejaVu Sans.
|
||||
- Noto Naskh Arabic и Noto Sans Armenian (OFL, 278 КБ) добавлены ради глифов, которых нет больше ни в одном шрифте бандла (арабские дополнения U+07B1–U+08FF, армянские U+058D/U+058E). Регистрировать их в `BundledFontMapper` не требуется: `FontFallback.selectCovering` перебирает **весь** реестр `PhysicalFonts` и находит их сам — достаточно `BundledFonts.ENTRIES`. У них только regular-начертание (`BundledFonts.families()` это учитывает, `allFamiliesHaveAllVariants` их не проверяет).
|
||||
- `FopFallbackFonts.declare` декларирует в FOP-конфиге **все** бандл-семейства, а не один fallback: FOP умеет встраивать только задекларированные, а `font-family` в FO может запросить любой из них.
|
||||
- `slf4j-simple` обязателен: без него docx4j печатает предупреждение прямо в выходной PDF (регрессионный тест `noLoggingWarningInPdf`).
|
||||
- Символы U+2000–U+2EFF (em-dash, кавычки, многоточие): `RunFontSelector.symbolBlockFont` оставляет шрифт ранa, если в нём есть этот глиф, и только иначе подставляет виртуальный «Segoe UI Symbol» (маппится на fallback DejaVu Sans, см. `BundledFontMapper`). Так же делает Word: в `references/word.pdf` em-dash нарисован Calibri/Times, DejaVu там нет вообще. Регрессия — `ruPlain_emDashEmbeddedNotHelvetica` (проверяет, что глиф рисует **вшитый** шрифт, а не базовый Helvetica).
|
||||
|
||||
## Архитектура (неочевидное)
|
||||
|
||||
- Пайплайн: байты docx → `DocxOnOffNormalizer` → `SymbolFontNormalizer` → `FieldNormalizer` → docx4j → XSL-FO (XSLT) → FOP → PDF.
|
||||
- Пайплайн: байты docx → `DocxOnOffNormalizer` → `SymbolFontNormalizer` → `FieldNormalizer` → `GlyphCoverageNormalizer` → docx4j → XSL-FO (XSLT) → FOP → PDF.
|
||||
- Поля страниц: Word пишет `PAGE`/`NUMPAGES` сложным полем (`fldChar begin` → `instrText` → `separate` → кэш → `end`). Экспорт docx4j в FO `w:instrText` внутри такого поля игнорирует и печатает кэш docx — во всех колонтитулах одно число (в эталоне «2» вместо 1, 2, 3 …). `FieldNormalizer` разворачивает поле в `w:fldSimple` (его обрабатывает `FldSimpleWriter` из docx4j-export-fo: PAGE → `fo:page-number`, есть также NUMPAGES/SECTIONPAGES/PAGEREF), сохраняя внутри закэшированные ран — они дают шрифт/размер. Штатный `FieldsCombiner` docx4j делает то же, но не заходит внутрь `w:sdt`, а Word держит нумерацию именно в контентном контроле («Page Numbers (Top of Page)»). Трогаются только инструкции, для которых есть обработчик; вложенные поля пропускаются. Регрессия — `WordPdfConverterTest#pageNumbers_recomputedNotCached`, фикстура `samples/page-numbers.docx`.
|
||||
- Покрытие глифов: знак без глифа в шрифте ранa FOP рисует `.notdef` («#»). Docx4j 17.x сам ищет покрывающий шрифт (`FontFallback.selectCovering` по реестру `PhysicalFonts`), но с двумя дырами: `needsCoverage` возвращает false для «латинской» группы (поэтому U+2150–U+218F — римские цифры и дроби — остаются на Tinos навсегда), а `RunFontSelector.fallbackByScript` кэширует фолбэк **на всю группу Юникода** (обычные армянские «ՊՌՋտ» покрываются DejaVu Serif, и найденный DejaVu Serif подставляется следующим за ними U+058D/U+058E). `GlyphCoverageNormalizer` (шаг 2.4, тоже байты до JAXB) режет ран по покрытию и пишет семейство в `w:rFonts` (имя — `BundledFontMapper.documentFontName`, обратное к `bundledFamily`). Покрытие меряется `java.awt.Font.canDisplay` через `BundledFonts.awtFont` (не `GlyphCheck` — тот логирует INFO на каждый отсутствующий глиф). Трогаются только раны с одним `w:t` и с явным `w:rFonts`; если знака нет ни в одном бандл-шрифте, ран не меняется. Регрессия — `WordPdfConverterTest#exoticGlyphs_drawnNotHash`, unit — `GlyphCoverageNormalizerTest`, фикстура `samples/exotic-glyphs.docx`.
|
||||
- Известный остаток эталона: U+2188 (ↈ) и U+218A (↊) — есть только в GNU FreeSerif (GPL-3+ с Font Exception), которого в бандле нет намеренно (весь бандл — SIL OFL). В `references/word.pdf` на их месте у нас две решётки; ради них OFL не меняют.
|
||||
- Символьные шрифты: 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()`; конструктор маппера каждый раз заново добавляет их). Не менять местами.
|
||||
- docx4j 17.x по-прежнему теряет атрибуты `w:val="off"/"on"` при JAXB-разборе — нормализация байтов до загрузки (`DocxOnOffNormalizer`) нужна и на 17.x (проверялось отключением: красный `ruPlain_regularRunsUseRegularFont`).
|
||||
|
||||
@@ -71,8 +71,8 @@ WordPdfConverter.convert(Path.of("doc.docx"), Path.of("out.pdf")); // явный
|
||||
|
||||
## Шрифты
|
||||
|
||||
В `wordpdf-core/src/main/resources/fonts/` упакованы 28 TTF (по 4 начертания
|
||||
на семейство):
|
||||
В `wordpdf-core/src/main/resources/fonts/` упакованы 30 TTF: 7 текстовых
|
||||
семейств по 4 начертания плюс два покрывающих шрифта (только regular):
|
||||
|
||||
| Семейство | Аналог MS-шрифта |
|
||||
|---|---|
|
||||
@@ -82,11 +82,17 @@ WordPdfConverter.convert(Path.of("doc.docx"), Path.of("out.pdf")); // явный
|
||||
| Tinos | Times New Roman |
|
||||
| Cousine | Courier New |
|
||||
| DejaVu Sans / DejaVu Serif | fallback |
|
||||
| Noto Naskh Arabic | арабские дополнения U+07B1–U+08FF |
|
||||
| Noto Sans Armenian | армянские знаки Unicode 16 |
|
||||
|
||||
`BundledFontMapper` подставляет метрически совместимые аналоги при конвертации
|
||||
(`Calibri → Carlito` и т.д.). Нераспознанные шрифты и символы, не найденные в
|
||||
шрифте ранa (em-dash «—», кавычки, U+2000–U+2EFF), падают в **DejaVu Sans**
|
||||
(гарантированная кириллица). Все шрифты встраиваются в PDF как подмножества.
|
||||
(гарантированная кириллица). Знак, которого нет ни в шрифте ранa, ни там, куда
|
||||
его отправил docx4j, ищет себе место сам: `GlyphCoverageNormalizer` режет такой
|
||||
ран и для каждой части назначает покрывающее семейство — serif-раны в
|
||||
**DejaVu Serif**, sans — в **DejaVu Sans**, экзотика — в Noto. Все шрифты
|
||||
встраиваются в PDF как подмножества.
|
||||
|
||||
### Лицензии шрифтов
|
||||
|
||||
@@ -94,6 +100,8 @@ WordPdfConverter.convert(Path.of("doc.docx"), Path.of("out.pdf")); // явный
|
||||
(см. `fonts/FONT-LICENSE.txt`).
|
||||
- DejaVu Sans / DejaVu Serif — **SIL OFL 1.1 / Bitstream Vera**
|
||||
(см. `fonts/DejaVu-LICENSE.txt`).
|
||||
- Noto Naskh Arabic, Noto Sans Armenian — **SIL OFL 1.1**
|
||||
(см. `fonts/Noto-LICENSE.txt`).
|
||||
|
||||
## Как это работает
|
||||
|
||||
@@ -107,7 +115,7 @@ docx ──> нормализация байтов ──> docx4j (Wordprocessin
|
||||
из-за чего regular-раны могли рендериться жирным курсивом),
|
||||
`SymbolFontNormalizer` (маркеры из Symbol/Wingdings вместо «#») и
|
||||
`FieldNormalizer` (поля `PAGE`/`NUMPAGES` пересчитываются, а не печатают
|
||||
кэш из docx).
|
||||
кэш из docx) и `GlyphCoverageNormalizer` (раны со знаками вне их шрифта).
|
||||
2. Документ загружается в `WordprocessingMLPackage`, привязывается
|
||||
`BundledFontMapper`, диаграммы и SmartArt предварительно растеризуются
|
||||
в PNG (`DrawingPreRenderer`).
|
||||
@@ -120,6 +128,10 @@ docx ──> нормализация байтов ──> docx4j (Wordprocessin
|
||||
приближённые (ограничения FOP/docx4j, а не «мы что-то упустили»).
|
||||
- Символы U+2000–U+2EFF (em-dash и т.п.) берутся из шрифта ранa, если в нём
|
||||
есть глиф, иначе — из fallback-семейства DejaVu.
|
||||
- Знаков, которых нет ни в одном шрифте бандла, это не касается: вместо них
|
||||
остаётся `.notdef`. В эталонном `references/word.docx` таких два — U+2188 (ↈ)
|
||||
и U+218A (↊), они есть только в GNU FreeSerif под GPL, а бандл держится
|
||||
целиком на SIL OFL.
|
||||
- Поддержка таблиц/изображений — базовая (через docx4j/FOP).
|
||||
|
||||
## Тесты
|
||||
|
||||
@@ -13,6 +13,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.FieldNormalizer;
|
||||
import ru.pjandro.wordpdf.internal.GlyphCoverageNormalizer;
|
||||
import ru.pjandro.wordpdf.internal.FopFallbackFonts;
|
||||
import ru.pjandro.wordpdf.internal.SymbolFontNormalizer;
|
||||
|
||||
@@ -115,6 +116,10 @@ public final class WordPdfConverter {
|
||||
// ...и поля PAGE/NUMPAGES из fldChar делаем w:fldSimple, иначе
|
||||
// в колонтитулах печатается кэш docx (см. FieldNormalizer).
|
||||
docxBytes = FieldNormalizer.normalize(docxBytes);
|
||||
// ...и раны со знаками, которых нет в их шрифте: без этого
|
||||
// FOP рисует «#» (docx4j проверяет покрытие не для всех знаков
|
||||
// и кэширует фолбэк на группу Юникода, см. GlyphCoverageNormalizer).
|
||||
docxBytes = GlyphCoverageNormalizer.normalize(docxBytes);
|
||||
WordprocessingMLPackage pkg = WordprocessingMLPackage.load(
|
||||
new ByteArrayInputStream(docxBytes));
|
||||
try {
|
||||
|
||||
@@ -46,6 +46,18 @@ public class BundledFontMapper extends BestMatchingMapper {
|
||||
/** Финальный fallback: шрифт с гарантированной кириллицей. */
|
||||
private static final String FALLBACK_FAMILY = BundledFonts.FALLBACK_FAMILY;
|
||||
|
||||
/**
|
||||
* Имя семейства для записи в {@code w:rFonts} (ключ — lowercase-семейство).
|
||||
* Нужно {@code GlyphCoverageNormalizer}: он пишет в разрезанный ран
|
||||
* человекочитаемое имя, а {@link #populateFontMappings} маппит его
|
||||
* обратно на TTF.
|
||||
*/
|
||||
private static final Map<String, String> DISPLAY_NAMES = Map.of(
|
||||
"dejavu sans", "DejaVu Sans",
|
||||
"dejavu serif", "DejaVu Serif",
|
||||
"noto naskh arabic", "Noto Naskh Arabic",
|
||||
"noto sans armenian", "Noto Sans Armenian");
|
||||
|
||||
/**
|
||||
* Имя, которое docx4j {@code RunFontSelector} запрашивает у маппера для
|
||||
* символов диапазона U+2000–U+2EFF (em-dash «—», кавычки «„», многоточие
|
||||
@@ -74,6 +86,10 @@ public class BundledFontMapper extends BestMatchingMapper {
|
||||
m.put("cousine", "cousine");
|
||||
m.put("dejavu sans", "dejavu sans");
|
||||
m.put("dejavu serif", "dejavu serif");
|
||||
// Покрывающие шрифты (в документе обычно не встречаются, но если
|
||||
// встречаться — маппятся на себя, а не в DejaVu-фолбэк)
|
||||
m.put("noto naskh arabic", "noto naskh arabic");
|
||||
m.put("noto sans armenian", "noto sans armenian");
|
||||
ALIASES = Map.copyOf(m);
|
||||
}
|
||||
|
||||
@@ -89,6 +105,17 @@ public class BundledFontMapper extends BestMatchingMapper {
|
||||
: FALLBACK_FAMILY;
|
||||
}
|
||||
|
||||
/**
|
||||
* Имя шрифта, которое можно поставить в {@code w:rFonts}, чтобы получить
|
||||
* бандл-семейство {@code family}: {@link GlyphCoverageNormalizer} пишет
|
||||
* его в разрезанные раны. Обратная к {@link #bundledFamily} операция —
|
||||
* имена берутся из таблицы алиасов, поэтому маппинг гарантированно
|
||||
* возвращается к тому же семейству.
|
||||
*/
|
||||
public static String documentFontName(String family) {
|
||||
return DISPLAY_NAMES.getOrDefault(family, family);
|
||||
}
|
||||
|
||||
/**
|
||||
* Вызывается docx4j при {@code package.setFontMapper(...)}: для каждого
|
||||
* имени шрифта, использованного в документе, нужно определить, каким
|
||||
|
||||
@@ -97,7 +97,14 @@ public final class BundledFonts {
|
||||
new Entry("DejaVuSerif-Regular.ttf", "dejavu serif", V_REGULAR),
|
||||
new Entry("DejaVuSerif-Bold.ttf", "dejavu serif", V_BOLD),
|
||||
new Entry("DejaVuSerif-Italic.ttf", "dejavu serif", V_ITALIC),
|
||||
new Entry("DejaVuSerif-BoldItalic.ttf", "dejavu serif", V_BOLD_ITALIC)
|
||||
new Entry("DejaVuSerif-BoldItalic.ttf", "dejavu serif", V_BOLD_ITALIC),
|
||||
// Noto — покрытие письменностей, которых нет ни в одном шрифте
|
||||
// выше (арабские дополнения U+07B1–U+08FF, армянские знаки
|
||||
// Unicode 16). В docx4j-фолбэк они попадают сами:
|
||||
// FontFallback.selectCovering перебирает весь реестр
|
||||
// PhysicalFonts и берёт тот, что покрывает код (SIL OFL 1.1)
|
||||
new Entry("NotoNaskhArabic-Regular.ttf", "noto naskh arabic", V_REGULAR),
|
||||
new Entry("NotoSansArmenian-Regular.ttf", "noto sans armenian", V_REGULAR)
|
||||
);
|
||||
|
||||
/** Ключ семейства (lowercase) -> начертание -> зарегистрированный PhysicalFont. */
|
||||
@@ -209,6 +216,16 @@ public final class BundledFonts {
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Все бандл-семейства (lowercase) в порядке {@link #ENTRIES}.
|
||||
* Нужны, чтобы задекларировать в FOP-конфиге каждый шрифт jar:
|
||||
* FO может запросить любой из них (фолбэк docx4j по покрытию глифов),
|
||||
* а FOP знает только задекларированные.
|
||||
*/
|
||||
public static java.util.List<String> families() {
|
||||
return ENTRIES.stream().map(Entry::family).distinct().toList();
|
||||
}
|
||||
|
||||
/**
|
||||
* Зарегистрированный шрифт: семейство (lowercase) + начертание.
|
||||
*
|
||||
|
||||
@@ -7,20 +7,26 @@ import org.docx4j.fonts.PhysicalFont;
|
||||
import ru.pjandro.wordpdf.fonts.BundledFonts;
|
||||
|
||||
/**
|
||||
* Декларирует fallback-семейство (DejaVu Sans) в FOP-конфиге.
|
||||
* Декларирует бандл-шрифты jar в FOP-конфиге.
|
||||
*
|
||||
* FOP-конфиг, который docx4j строит в {@code FOSettings}, содержит
|
||||
* только шрифты, реально использованные в документе ({@code fontsInUse}).
|
||||
* Но docx4j {@code RunFontSelector} для символов диапазона U+2000–U+2EFF
|
||||
* (em-dash «—», кавычки, многоточие) выставляет в FO
|
||||
* {@code font-family}, маппированный с "Segoe UI Symbol" на DejaVu Sans
|
||||
* (см. {@link ru.pjandro.wordpdf.fonts.BundledFontMapper}). Если семейство
|
||||
* не задекларировано в FOP-конфиге, FOP не может его встроить и падает
|
||||
* на базовый неembedded-шрифт (Helvetica) — символ рендерится шрифтом
|
||||
* просмотрщика, а не встраиваемым подмножеством.
|
||||
* Но {@code RunFontSelector} может выставить в {@code font-family} и шрифт
|
||||
* извне документа:
|
||||
* <ul>
|
||||
* <li>для символов U+2000–U+2EFF (em-dash «—», кавычки, многоточие)
|
||||
* подставляется "Segoe UI Symbol", маппированный на DejaVu Sans
|
||||
* (см. {@link ru.pjandro.wordpdf.fonts.BundledFontMapper});</li>
|
||||
* <li>для знаков, которых нет в шрифте ранa, {@code FontFallback}
|
||||
* ищет покрывающий шрифт по всему реестру {@code PhysicalFonts} —
|
||||
* так в FO попадают Noto Naskh Arabic и Noto Sans Armenian.</li>
|
||||
* </ul>
|
||||
* Если семейство не задекларировано в FOP-конфиге, FOP не может его
|
||||
* встроить и падает на базовый неembedded-шрифт (Helvetica) — символ
|
||||
* рендерится шрифтом просмотрщика либо .notdef («#»). Поэтому в конфиг
|
||||
* добавляются ВСЕ шрифты бандла: стоит они в документе или нет, решает FO.
|
||||
*
|
||||
* Метод идемпотентен: если семейство уже задекларировано (например,
|
||||
* документ прямо использует DejaVu), ничего не добавляет.
|
||||
* Метод идемпотентен: уже задекларированное семейство не дублируется.
|
||||
*/
|
||||
public final class FopFallbackFonts {
|
||||
|
||||
@@ -28,7 +34,7 @@ public final class FopFallbackFonts {
|
||||
}
|
||||
|
||||
/**
|
||||
* Добавляет все начертания fallback-семейства в FOP-конфиг
|
||||
* Добавляет все начертания всех бандл-семейств в FOP-конфиг
|
||||
* {@code foSettings}. Вызывать после {@code new FOSettings(pkg)}
|
||||
* и до передачи настроек в {@code FORendererApacheFOP}.
|
||||
*/
|
||||
@@ -37,7 +43,16 @@ public final class FopFallbackFonts {
|
||||
if (rendererFonts == null) {
|
||||
return;
|
||||
}
|
||||
PhysicalFont regular = BundledFonts.regular(BundledFonts.FALLBACK_FAMILY);
|
||||
ObjectFactory factory = new ObjectFactory();
|
||||
for (String family : BundledFonts.families()) {
|
||||
declareFamily(rendererFonts, factory, family);
|
||||
}
|
||||
}
|
||||
|
||||
/** Одно семейство: regular + существующие начертания (Noto — только regular). */
|
||||
private static void declareFamily(Fonts rendererFonts, ObjectFactory factory,
|
||||
String family) {
|
||||
PhysicalFont regular = BundledFonts.regular(family);
|
||||
if (regular == null) {
|
||||
return;
|
||||
}
|
||||
@@ -54,14 +69,13 @@ public final class FopFallbackFonts {
|
||||
}
|
||||
}
|
||||
|
||||
ObjectFactory factory = new ObjectFactory();
|
||||
addFont(rendererFonts, factory, familyName, regular, "normal", "normal");
|
||||
addFont(rendererFonts, factory, familyName,
|
||||
BundledFonts.bold(BundledFonts.FALLBACK_FAMILY), "normal", "bold");
|
||||
BundledFonts.bold(family), "normal", "bold");
|
||||
addFont(rendererFonts, factory, familyName,
|
||||
BundledFonts.italic(BundledFonts.FALLBACK_FAMILY), "italic", "normal");
|
||||
BundledFonts.italic(family), "italic", "normal");
|
||||
addFont(rendererFonts, factory, familyName,
|
||||
BundledFonts.boldItalic(BundledFonts.FALLBACK_FAMILY), "italic", "bold");
|
||||
BundledFonts.boldItalic(family), "italic", "bold");
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@@ -0,0 +1,422 @@
|
||||
package ru.pjandro.wordpdf.internal;
|
||||
|
||||
import ru.pjandro.wordpdf.fonts.BundledFontMapper;
|
||||
import ru.pjandro.wordpdf.fonts.BundledFonts;
|
||||
|
||||
import java.io.ByteArrayInputStream;
|
||||
import java.io.ByteArrayOutputStream;
|
||||
import java.io.IOException;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
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;
|
||||
|
||||
/**
|
||||
* Разрезание ранов по покрытию глифов — до загрузки docx4j.
|
||||
*
|
||||
* Если у знака нет глифа в шрифте ранa, FOP рисует {@code .notdef} — в PDF
|
||||
* решётка «#». Часть таких знаков спасает сам docx4j
|
||||
* ({@code FontFallback.selectCovering} ищет покрывающий шрифт по реестру),
|
||||
* но у его механизма две дыры:
|
||||
* <ul>
|
||||
* <li>покрытие проверяется не для всех знаков: {@code needsCoverage}
|
||||
* возвращает false для «латинской» группы, поэтому римские цифры и
|
||||
* дроби (U+2150–U+218F) остаются на шрифте ранa (Tinos) навсегда;</li>
|
||||
* <li>фолбэк считается один раз на группу Юникода и кэшируется
|
||||
* ({@code RunFontSelector.fallbackByScript}): армянские «ՊՌՋտ»
|
||||
* покрываются DejaVu Serif, и найденный DejaVu Serif подставляется
|
||||
* и для следующих за ними U+058D/U+058E, которых в DejaVu нет.</li>
|
||||
* </ul>
|
||||
*
|
||||
* Делаем то, что должен был сделать рендер: ран, в тексте которого есть
|
||||
* знаки без глифа, разрезается на части, и каждой части явно назначается
|
||||
* бандл-семейство, где глиф есть ({@link #targetFamily}). Имя пишется в
|
||||
* {@code w:rFonts}, дальше {@link BundledFontMapper} маппит его на TTF,
|
||||
* а {@link FopFallbackFonts} декларирует его в FOP-конфиге.
|
||||
*
|
||||
* Правила, ограничивающие вмешательство:
|
||||
* <ul>
|
||||
* <li>трогаются только раны с одним {@code w:t} — составные
|
||||
* ({@code w:tab}, {@code w:drawing}, несколько текстовых узлов)
|
||||
* остаются как есть;</li>
|
||||
* <li>ран без {@code w:rFonts} не трогаем: его шрифт приходит из стилей,
|
||||
* угадать его здесь нельзя;</li>
|
||||
* <li>если знака нет ни в одном бандл-шрифте, ран не меняется — решётку
|
||||
* честнее оставить, чем подменять случайным шрифтом.</li>
|
||||
* </ul>
|
||||
*
|
||||
* Как и {@link SymbolFontNormalizer}, правим байты zip до JAXB-разбора.
|
||||
*/
|
||||
public final class GlyphCoverageNormalizer {
|
||||
|
||||
/** Семейства с засечками: для них fallback ищется сначала среди serif. */
|
||||
private static final List<String> SERIF_FAMILIES =
|
||||
List.of("dejavu serif", "tinos", "caladea");
|
||||
|
||||
/** Без засечек — общий fallback проекта (в нём есть кириллица). */
|
||||
private static final String SANS_FALLBACK = BundledFonts.FALLBACK_FAMILY;
|
||||
|
||||
/** {@code <w:t ...>текст</w:t>} — единственный текстовый узел рана. */
|
||||
private static final Pattern TEXT_ELEMENT = Pattern.compile(
|
||||
"<w:t\\b([^>]*)>(.*?)</w:t>", Pattern.DOTALL);
|
||||
|
||||
/** Атрибуты w:rFonts с именем шрифта. */
|
||||
private static final Pattern FONT_ATTR = Pattern.compile(
|
||||
"w:(ascii|hAnsi)=\"([^\"]+)\"");
|
||||
|
||||
/** Числовые сущности XML (— / —). */
|
||||
private static final Pattern NUMERIC_ENTITY = Pattern.compile(
|
||||
"&#(x?)([0-9A-Fa-f]+);");
|
||||
|
||||
/** Кэш покрытия: семейство -> множества проверенных/покрытых кодов. */
|
||||
private static final Map<String, Coverage> COVERAGE = new HashMap<>();
|
||||
|
||||
private GlyphCoverageNormalizer() {
|
||||
}
|
||||
|
||||
/**
|
||||
* Разрезает раны с непокрытыми глифами в 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;
|
||||
}
|
||||
|
||||
/**
|
||||
* Переписывает раны с непокрытыми глифами.
|
||||
*
|
||||
* @return новая строка либо null, если менять нечего
|
||||
*/
|
||||
static String rewrite(String xml) {
|
||||
String result = rewriteBlocks(xml, "w:r");
|
||||
return result.equals(xml) ? null : result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Проходит невложенные блоки {@code <w:r>} ... {@code </w:r>} и заменяет
|
||||
* каждый через {@link #rewriteBlock}. Приём тот же, что в
|
||||
* {@link SymbolFontNormalizer}: полные раны не вложены друг в друга.
|
||||
*/
|
||||
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();
|
||||
sb.append(xml, pos, start).append(rewriteBlock(xml.substring(start, end)));
|
||||
pos = end;
|
||||
}
|
||||
if (pos == 0) {
|
||||
return xml;
|
||||
}
|
||||
return sb.append(xml, pos, xml.length()).toString();
|
||||
}
|
||||
|
||||
/** Позиция открывающего (не самозакрывающегося) тега {@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:r}: части текста без глифа в шрифте ранa
|
||||
* получают собственное {@code w:rFonts}.
|
||||
*/
|
||||
private static String rewriteBlock(String block) {
|
||||
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 runFamily = runFamily(rPr);
|
||||
if (runFamily == null) {
|
||||
// Шрифт не указан явно — приходит из стилей, не угадываем.
|
||||
return block;
|
||||
}
|
||||
Matcher text = TEXT_ELEMENT.matcher(body);
|
||||
if (!text.matches()) {
|
||||
// Составной ран (w:tab, w:drawing, несколько w:t) не трогаем.
|
||||
return block;
|
||||
}
|
||||
String decoded = decode(text.group(2));
|
||||
List<Segment> segments = split(decoded, runFamily);
|
||||
if (segments == null) {
|
||||
return block;
|
||||
}
|
||||
|
||||
StringBuilder sb = new StringBuilder(block.length() + 64);
|
||||
for (Segment s : segments) {
|
||||
sb.append(openTag).append(s.family == null ? rPr : forceFont(rPr, s.family))
|
||||
.append("<w:t").append(attrs(text.group(1), s.text)).append('>')
|
||||
.append(encode(s.text))
|
||||
.append("</w:t></w:r>");
|
||||
}
|
||||
return sb.toString();
|
||||
}
|
||||
|
||||
/**
|
||||
* Разбивает текст на части по семейству, которое обязано его отрисовать.
|
||||
*
|
||||
* @return части либо null, если весь текст остаётся на шрифте ранa
|
||||
* (или ни один бандл-шрифт не покрывает недостающие знаки)
|
||||
*/
|
||||
static List<Segment> split(String text, String runFamily) {
|
||||
List<Segment> segments = new ArrayList<>();
|
||||
int start = 0;
|
||||
String current = null;
|
||||
for (int i = 0; i < text.length(); ) {
|
||||
int cp = text.codePointAt(i);
|
||||
int next = i + Character.charCount(cp);
|
||||
String target = targetFamily(cp, runFamily);
|
||||
if (start == i) {
|
||||
current = target;
|
||||
} else if (!java.util.Objects.equals(target, current)) {
|
||||
segments.add(new Segment(text.substring(start, i), current));
|
||||
start = i;
|
||||
current = target;
|
||||
}
|
||||
i = next;
|
||||
}
|
||||
if (text.isEmpty()) {
|
||||
return null;
|
||||
}
|
||||
segments.add(new Segment(text.substring(start), current));
|
||||
boolean changed = segments.size() > 1 || segments.get(0).family != null;
|
||||
return changed ? segments : null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Семейство, которым нужно рисовать знак {@code cp}, или null, если
|
||||
* штатного шрифта ранa достаточно.
|
||||
*
|
||||
* Порядок перебора: сначала семейства того же рисунка (serif к serif),
|
||||
* затем остальные бандл-семейства — так знак остаётся максимально
|
||||
* близким по начертанию.
|
||||
*/
|
||||
static String targetFamily(int cp, String runFamily) {
|
||||
if (covers(runFamily, cp)) {
|
||||
return null;
|
||||
}
|
||||
boolean serif = SERIF_FAMILIES.contains(runFamily);
|
||||
for (String family : candidates(runFamily, serif)) {
|
||||
if (covers(family, cp)) {
|
||||
return family;
|
||||
}
|
||||
}
|
||||
// Одиночный знак может не найтись ни в одном семействе — решётку
|
||||
// не прячем: ран остаётся как есть.
|
||||
return null;
|
||||
}
|
||||
|
||||
/** Кандидаты на подстановку: сначала «свой» класс, потом остальные. */
|
||||
private static List<String> candidates(String runFamily, boolean serif) {
|
||||
List<String> ordered = new ArrayList<>();
|
||||
if (serif) {
|
||||
ordered.addAll(SERIF_FAMILIES);
|
||||
}
|
||||
ordered.add(SANS_FALLBACK);
|
||||
for (String family : BundledFonts.families()) {
|
||||
if (!ordered.contains(family)) {
|
||||
ordered.add(family);
|
||||
}
|
||||
}
|
||||
ordered.remove(runFamily);
|
||||
return ordered;
|
||||
}
|
||||
|
||||
/** Есть ли у семейства глиф для кода (regular-начертание). */
|
||||
static boolean covers(String family, int cp) {
|
||||
if (family == null) {
|
||||
return false;
|
||||
}
|
||||
return coverage(family).covers(cp);
|
||||
}
|
||||
|
||||
private static Coverage coverage(String family) {
|
||||
Coverage c = COVERAGE.get(family);
|
||||
if (c == null) {
|
||||
c = new Coverage(BundledFonts.awtFont(family, BundledFonts.V_REGULAR));
|
||||
COVERAGE.put(family, c);
|
||||
}
|
||||
return c;
|
||||
}
|
||||
|
||||
/**
|
||||
* Покрытие одного семейства: {@code java.awt.Font.canDisplay} с кэшем
|
||||
* «проверенных» кодов. AWT берётся вместо {@code GlyphCheck}, чтобы не
|
||||
* плодить INFO-лог на каждый отсутствующий глиф.
|
||||
*/
|
||||
private static final class Coverage {
|
||||
|
||||
private final java.awt.Font font;
|
||||
private final java.util.BitSet checked = new java.util.BitSet();
|
||||
private final java.util.BitSet covered = new java.util.BitSet();
|
||||
|
||||
Coverage(java.awt.Font font) {
|
||||
this.font = font;
|
||||
}
|
||||
|
||||
boolean covers(int cp) {
|
||||
if (font == null || cp < 0) {
|
||||
return false;
|
||||
}
|
||||
if (checked.get(cp)) {
|
||||
return covered.get(cp);
|
||||
}
|
||||
checked.set(cp);
|
||||
if (font.canDisplay(cp)) {
|
||||
covered.set(cp);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/** Часть текста рана; family == null — рисовать штатным шрифтом ранa. */
|
||||
static final class Segment {
|
||||
|
||||
final String text;
|
||||
/** Ключ бандл-семейства (lowercase) или null. */
|
||||
final String family;
|
||||
|
||||
Segment(String text, String family) {
|
||||
this.text = text;
|
||||
this.family = family;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Бандл-семейство шрифта ранa (первое из {@code w:ascii}/{@code w:hAnsi})
|
||||
* либо null, если рана шрифт не объявлен.
|
||||
*/
|
||||
private static String runFamily(String rPr) {
|
||||
int rFonts = rPr.indexOf("<w:rFonts");
|
||||
if (rFonts < 0) {
|
||||
return null;
|
||||
}
|
||||
int end = rPr.indexOf('>', rFonts);
|
||||
if (end < 0) {
|
||||
return null;
|
||||
}
|
||||
Matcher m = FONT_ATTR.matcher(rPr.substring(rFonts, end));
|
||||
if (!m.find()) {
|
||||
return null;
|
||||
}
|
||||
return BundledFontMapper.bundledFamily(m.group(2));
|
||||
}
|
||||
|
||||
/**
|
||||
* Принудительно ставит семейство в {@code w:rPr}: заменяет атрибуты
|
||||
* {@code w:rFonts}, а если их нет — вставляет элемент первым ребёнком.
|
||||
*/
|
||||
private static String forceFont(String rPr, String family) {
|
||||
String name = BundledFontMapper.documentFontName(family);
|
||||
String fonts = "<w:rFonts w:ascii=\"" + name + "\" w:hAnsi=\"" + name + "\"/>";
|
||||
if (rPr.isEmpty()) {
|
||||
return "<w:rPr>" + fonts + "</w:rPr>";
|
||||
}
|
||||
int start = rPr.indexOf("<w:rFonts");
|
||||
if (start < 0) {
|
||||
return rPr.replaceFirst("<w:rPr>", "<w:rPr>" + fonts);
|
||||
}
|
||||
int end = rPr.indexOf("/>", start);
|
||||
int blockEnd = rPr.indexOf("</w:rFonts>", start);
|
||||
if (blockEnd >= 0 && (end < 0 || blockEnd < end)) {
|
||||
return rPr.substring(0, start) + fonts + rPr.substring(blockEnd + "</w:rFonts>".length());
|
||||
}
|
||||
if (end < 0) {
|
||||
return rPr;
|
||||
}
|
||||
return rPr.substring(0, start) + fonts + rPr.substring(end + 2);
|
||||
}
|
||||
|
||||
/** Атрибуты w:t: сохраняем исходные и добавляем preserve, если нужно. */
|
||||
private static String attrs(String original, String segmentText) {
|
||||
// Пустой после strip() сегмент — это тоже пробелы, их Word бы съел.
|
||||
boolean needsPreserve = !segmentText.equals(segmentText.strip());
|
||||
if (needsPreserve && !original.contains("xml:space")) {
|
||||
return original + " xml:space=\"preserve\"";
|
||||
}
|
||||
return original;
|
||||
}
|
||||
|
||||
/** Разворачивает XML-сущности текста в настоящие символы. */
|
||||
private static String decode(String xmlText) {
|
||||
if (xmlText.indexOf('&') < 0) {
|
||||
return xmlText;
|
||||
}
|
||||
String result = NUMERIC_ENTITY.matcher(xmlText).replaceAll(mr -> {
|
||||
int cp = Integer.parseInt(mr.group(2), mr.group(1).isEmpty() ? 10 : 16);
|
||||
return Matcher.quoteReplacement(new String(Character.toChars(cp)));
|
||||
});
|
||||
return result.replace("<", "<").replace(">", ">")
|
||||
.replace(""", "\"").replace("'", "'")
|
||||
.replace("&", "&");
|
||||
}
|
||||
|
||||
/** Обратное {@link #decode}: текст снова безопасен для {@code w:t}. */
|
||||
private static String encode(String text) {
|
||||
return text.replace("&", "&").replace("<", "<").replace(">", ">");
|
||||
}
|
||||
}
|
||||
@@ -15,4 +15,12 @@
|
||||
Источник: официальный tarball dejavu-fonts-ttf-2.37 (https://dejavu-fonts.github.io),
|
||||
LICENSE см. DejaVu-LICENSE.txt.
|
||||
|
||||
Все шрифты свободно распространяемы и поддерживают кириллицу.
|
||||
- Noto Naskh Arabic, Noto Sans Armenian
|
||||
SIL Open Font License 1.1 (SIL OFL 1.1).
|
||||
Покрывают письменности, которых нет в шрифтах выше (арабские дополнения
|
||||
U+07B1–U+08FF, армянские знаки Unicode 16).
|
||||
(c) The Noto Project Authors.
|
||||
Источник: notofonts.github.io (hinted TTF), LICENSE см. Noto-LICENSE.txt.
|
||||
|
||||
Все шрифты свободно распространяемы (SIL OFL 1.1); шрифты текста
|
||||
(Carlito, Caladea, Arimo, Tinos, Cousine, DejaVu) содержат кириллицу.
|
||||
|
||||
@@ -0,0 +1,94 @@
|
||||
Copyright 2022 The Noto Project Authors (https://github.com/notofonts/)
|
||||
|
||||
This Font Software is licensed under the SIL Open Font License,
|
||||
Version 1.1.
|
||||
|
||||
This license is copied below, and is also available with a FAQ at:
|
||||
http://scripts.sil.org/OFL
|
||||
|
||||
-----------------------------------------------------------
|
||||
SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
|
||||
-----------------------------------------------------------
|
||||
|
||||
PREAMBLE
|
||||
The goals of the Open Font License (OFL) are to stimulate worldwide
|
||||
development of collaborative font projects, to support the font
|
||||
creation efforts of academic and linguistic communities, and to
|
||||
provide a free and open framework in which fonts may be shared and
|
||||
improved in partnership with others.
|
||||
|
||||
The OFL allows the licensed fonts to be used, studied, modified and
|
||||
redistributed freely as long as they are not sold by themselves. The
|
||||
fonts, including any derivative works, can be bundled, embedded,
|
||||
redistributed and/or sold with any software provided that any reserved
|
||||
names are not used by derivative works. The fonts and derivatives,
|
||||
however, cannot be released under any other type of license. The
|
||||
requirement for fonts to remain under this license does not apply to
|
||||
any document created using the fonts or their derivatives.
|
||||
|
||||
DEFINITIONS
|
||||
"Font Software" refers to the set of files released by the Copyright
|
||||
Holder(s) under this license and clearly marked as such. This may
|
||||
include source files, build scripts and documentation.
|
||||
|
||||
"Reserved Font Name" refers to any names specified as such after the
|
||||
copyright statement(s).
|
||||
|
||||
"Original Version" refers to the collection of Font Software
|
||||
components as distributed by the Copyright Holder(s).
|
||||
|
||||
"Modified Version" refers to any derivative made by adding to,
|
||||
deleting, or substituting -- in part or in whole -- any of the
|
||||
components of the Original Version, by changing formats or by porting
|
||||
the Font Software to a new environment.
|
||||
|
||||
"Author" refers to any designer, engineer, programmer, technical
|
||||
writer or other person who contributed to the Font Software.
|
||||
|
||||
PERMISSION & CONDITIONS
|
||||
Permission is hereby granted, free of charge, to any person obtaining
|
||||
a copy of the Font Software, to use, study, copy, merge, embed,
|
||||
modify, redistribute, and sell modified and unmodified copies of the
|
||||
Font Software, subject to the following conditions:
|
||||
|
||||
1) Neither the Font Software nor any of its individual components, in
|
||||
Original or Modified Versions, may be sold by itself.
|
||||
|
||||
2) Original or Modified Versions of the Font Software may be bundled,
|
||||
redistributed and/or sold with any software, provided that each copy
|
||||
contains the above copyright notice and this license. These can be
|
||||
included either as stand-alone text files, human-readable headers or
|
||||
in the appropriate machine-readable metadata fields within text or
|
||||
binary files as long as those fields can be easily viewed by the user.
|
||||
|
||||
3) No Modified Version of the Font Software may use the Reserved Font
|
||||
Name(s) unless explicit written permission is granted by the
|
||||
corresponding Copyright Holder. This restriction only applies to the
|
||||
primary font name as presented to the users.
|
||||
|
||||
4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
|
||||
Software shall not be used to promote, endorse or advertise any
|
||||
Modified Version, except to acknowledge the contribution(s) of the
|
||||
Copyright Holder(s) and the Author(s) or with their explicit written
|
||||
permission.
|
||||
|
||||
5) The Font Software, modified or unmodified, in part or in whole,
|
||||
must be distributed entirely under this license, and must not be
|
||||
distributed under any other license. The requirement for fonts to
|
||||
remain under this license does not apply to any document created using
|
||||
the Font Software.
|
||||
|
||||
TERMINATION
|
||||
This license becomes null and void if any of the above conditions are
|
||||
not met.
|
||||
|
||||
DISCLAIMER
|
||||
THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
|
||||
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
|
||||
OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
|
||||
COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
||||
INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
|
||||
DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||||
FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
|
||||
OTHER DEALINGS IN THE FONT SOFTWARE.
|
||||
Binary file not shown.
Binary file not shown.
@@ -67,6 +67,7 @@ public final class SampleDocxGenerator {
|
||||
ruTableImage(dir.resolve("ru-table-image.docx"));
|
||||
symbolBullets(dir.resolve("symbol-bullets.docx"));
|
||||
pageNumbers(dir.resolve("page-numbers.docx"));
|
||||
exoticGlyphs(dir.resolve("exotic-glyphs.docx"));
|
||||
|
||||
System.out.println("Готово: " + dir.toAbsolutePath());
|
||||
}
|
||||
@@ -301,6 +302,30 @@ public final class SampleDocxGenerator {
|
||||
.setFldCharType(STFldCharType.END);
|
||||
}
|
||||
|
||||
/**
|
||||
* Знаки без глифа в шрифте ранa: римские цифры и дроби (U+2150–U+218F,
|
||||
* которые docx4j вообще не проверяет на покрытие), армянские знаки
|
||||
* Unicode 16 рядом с обычными армянскими (столкновение кэша фолбэка
|
||||
* docx4j на группе Юникода) и арабские дополнения. Всё в Times New Roman
|
||||
* — в нём этих глифов нет.
|
||||
*/
|
||||
private static void exoticGlyphs(Path out) throws Exception {
|
||||
try (XWPFDocument doc = new XWPFDocument()) {
|
||||
heading(doc, "Экзотические глифы", "Times New Roman");
|
||||
|
||||
String[] font = {"Times New Roman"};
|
||||
run(doc.createParagraph(), "Числовые символы \u2152\u2155\u215E "
|
||||
+ "\u2161\u216A\u216D\u2174\u2181\u2183\u2182", font[0], false, false);
|
||||
run(doc.createParagraph(), "Армянский: \u054A\u054C\u054B\u057F "
|
||||
+ "\u058D\u058E", font[0], false, false);
|
||||
run(doc.createParagraph(), "Арабский: \u08E1\u08EC\u08ED "
|
||||
+ "\u076E\u0770", font[0], false, false);
|
||||
run(doc.createParagraph(), "Обычный текст 123, кириллица и em-dash —",
|
||||
font[0], false, false);
|
||||
save(doc, out);
|
||||
}
|
||||
}
|
||||
|
||||
// ================== Вспомогательные ==================
|
||||
|
||||
/** Абзац-заголовок: POI 5.5 не имеет createHeading, поэтому
|
||||
|
||||
@@ -159,6 +159,38 @@ class WordPdfConverterTest {
|
||||
"пропал текст пункта списка: " + text);
|
||||
}
|
||||
|
||||
/**
|
||||
* Знаки, у которых нет глифа в шрифте ранa (римские цифры и дроби,
|
||||
* армянские знаки Unicode 16, арабские дополнения), FOP рисовал
|
||||
* {@code .notdef} — решётку «#». Docx4j сам ищет покрывающий шрифт,
|
||||
* но не проверяет покрытие для «латинской» группы и кэширует фолбэк на
|
||||
* всю группу Юникода. GlyphCoverageNormalizer разрезает такой ран и
|
||||
* явно назначает семейство для каждой части.
|
||||
*/
|
||||
@Test
|
||||
void exoticGlyphs_drawnNotHash() throws Exception {
|
||||
Path in = extractSample("exotic-glyphs.docx");
|
||||
Path pdf = convert(in);
|
||||
String text = norm(pdfText(pdf));
|
||||
|
||||
for (String ch : List.of("\u2152", "\u2181", "\u058D", "\u08E1")) {
|
||||
assertTrue(text.contains(ch), "нет символа U+"
|
||||
+ Integer.toHexString(ch.charAt(0)) + ": " + text);
|
||||
}
|
||||
assertFalse(text.contains("#"),
|
||||
"в PDF остались .notdef-решётки: " + text);
|
||||
|
||||
// Римская цифра — вшитым DejaVu Serif, а не базовым Helvetica
|
||||
assertTrue(fontNameOf(pdf, '\u2181').contains("DejaVuSerif"),
|
||||
"римская цифра нарисована не DejaVu Serif");
|
||||
// Армянский знак Unicode 16 — Noto Sans Armenian
|
||||
assertTrue(fontNameOf(pdf, '\u058D').contains("NotoSansArmenian"),
|
||||
"армянский знак нарисован не Noto Sans Armenian");
|
||||
// Соседний обычный текст не уехал в подставленное семейство
|
||||
assertTrue(fontNameOf(pdf, 'ы').contains("Tinos"),
|
||||
"кириллица уехала с Tinos");
|
||||
}
|
||||
|
||||
/**
|
||||
* Поля PAGE/NUMPAGES Word пишет как {@code fldChar} + {@code instrText}
|
||||
* + закэшированный результат. Экспорт docx4j в FO инструкцию игнорирует
|
||||
|
||||
+181
@@ -0,0 +1,181 @@
|
||||
package ru.pjandro.wordpdf.internal;
|
||||
|
||||
import org.junit.jupiter.api.BeforeAll;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import ru.pjandro.wordpdf.fonts.BundledFontMapper;
|
||||
import ru.pjandro.wordpdf.fonts.BundledFonts;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
/**
|
||||
* Разрезание ранов по покрытию глифов (см. GlyphCoverageNormalizer).
|
||||
*
|
||||
* Покрытие берётся из реальных TTF бандла, поэтому перед тестами
|
||||
* шрифты инициализируются ровно так же, как в конвертере.
|
||||
*/
|
||||
class GlyphCoverageNormalizerTest {
|
||||
|
||||
private static final String NS =
|
||||
"<w:document xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\"><w:body>";
|
||||
|
||||
/** Римская цифра: в Tinos глифа нет, в DejaVu Serif есть. */
|
||||
private static final String ROMAN = "\u2181";
|
||||
/** Знак, которого нет ни в одном бандл-шрифте. */
|
||||
private static final String NOWHERE = "\u2188";
|
||||
/** Обычная кириллица — есть в Tinos. */
|
||||
private static final String CYRILLIC = "ы";
|
||||
|
||||
@BeforeAll
|
||||
static void initFonts() {
|
||||
new BundledFontMapper();
|
||||
BundledFonts.init();
|
||||
BundledFonts.restrictToBundled();
|
||||
}
|
||||
|
||||
private static String run(String rPr, String body) {
|
||||
return NS + "<w:r>" + rPr + body + "</w:r></w:body></w:document>";
|
||||
}
|
||||
|
||||
private static String timesRPr() {
|
||||
return "<w:rPr><w:rFonts w:ascii=\"Times New Roman\" w:hAnsi=\"Times New Roman\""
|
||||
+ " w:cs=\"Times New Roman\"/><w:sz w:val=\"28\"/></w:rPr>";
|
||||
}
|
||||
|
||||
/** Знак без глифа в шрифте ранa уезжает в отдельный ран со своим w:rFonts. */
|
||||
@Test
|
||||
void splitsRunForUncoveredGlyph() {
|
||||
String xml = run(timesRPr(), "<w:t>ы" + ROMAN + "ы</w:t>");
|
||||
|
||||
String out = GlyphCoverageNormalizer.rewrite(xml);
|
||||
|
||||
assertNotNull(out, "ран с римской цифрой не разрезан");
|
||||
assertTrue(out.contains("<w:rFonts w:ascii=\"DejaVu Serif\" w:hAnsi=\"DejaVu Serif\"/>"),
|
||||
"нет подставленного семейства: " + out);
|
||||
assertTrue(out.contains("w:cs=\"Times New Roman\""),
|
||||
"потеряны остальные атрибуты w:rFonts: " + out);
|
||||
assertTrue(out.contains("<w:sz w:val=\"28\"/>"),
|
||||
"потеряно начертание рана: " + out);
|
||||
assertEquals(3, occurrences(out, "<w:r>"), "ожидалось три рана: " + out);
|
||||
assertTrue(out.contains(ROMAN), "пропал сам знак: " + out);
|
||||
}
|
||||
|
||||
/** Порядок частей сохраняется: сначала обычный текст, потом подстановка. */
|
||||
@Test
|
||||
void keepsSegmentOrder() {
|
||||
String out = GlyphCoverageNormalizer.rewrite(
|
||||
run(timesRPr(), "<w:t>ы" + ROMAN + "ы</w:t>"));
|
||||
|
||||
assertNotNull(out);
|
||||
int substituted = out.indexOf("DejaVu Serif");
|
||||
int tail = out.lastIndexOf("ы");
|
||||
assertTrue(out.indexOf("<w:t>") < substituted && substituted < tail,
|
||||
"части идут не в исходном порядке: " + out);
|
||||
}
|
||||
|
||||
/** Всё, что рисует штатный шрифт, остаётся нетронутым. */
|
||||
@Test
|
||||
void coveredRunUntouched() {
|
||||
String xml = run(timesRPr(), "<w:t>обычный текст 1234</w:t>");
|
||||
|
||||
assertNull(GlyphCoverageNormalizer.rewrite(xml));
|
||||
}
|
||||
|
||||
/** Ран без w:rFonts получает шрифт из стилей — угадывать нечем. */
|
||||
@Test
|
||||
void runWithoutExplicitFontUntouched() {
|
||||
String xml = run("", "<w:t>" + ROMAN + "</w:t>");
|
||||
|
||||
assertNull(GlyphCoverageNormalizer.rewrite(xml));
|
||||
}
|
||||
|
||||
/** Составной ран (несколько детей в w:r) не трогаем. */
|
||||
@Test
|
||||
void compoundRunUntouched() {
|
||||
String xml = run(timesRPr(), "<w:tab/><w:t>" + ROMAN + "</w:t>");
|
||||
|
||||
assertNull(GlyphCoverageNormalizer.rewrite(xml));
|
||||
}
|
||||
|
||||
/** Знака нет ни в одном бандл-шрифте: решётку не прячем за случайный шрифт. */
|
||||
@Test
|
||||
void glyphMissingEverywhereUntouched() {
|
||||
String xml = run(timesRPr(), "<w:t>" + NOWHERE + "</w:t>");
|
||||
|
||||
assertNull(GlyphCoverageNormalizer.rewrite(xml));
|
||||
}
|
||||
|
||||
/** Часть с пробелами по краям обязана остаться с xml:space="preserve". */
|
||||
@Test
|
||||
void addsXmlSpacePreserve() {
|
||||
String out = GlyphCoverageNormalizer.rewrite(
|
||||
run(timesRPr(), "<w:t>" + ROMAN + " ы</w:t>"));
|
||||
|
||||
assertNotNull(out);
|
||||
assertTrue(out.contains("<w:t xml:space=\"preserve\"> ы</w:t>"),
|
||||
"часть с пробелами потеряла xml:space: " + out);
|
||||
assertTrue(out.contains("<w:t>" + ROMAN + "</w:t>"),
|
||||
"часть без пробелов получила лишний xml:space: " + out);
|
||||
}
|
||||
|
||||
/** Исходный xml:space не дублируется. */
|
||||
@Test
|
||||
void keepsExistingXmlSpace() {
|
||||
String out = GlyphCoverageNormalizer.rewrite(
|
||||
run(timesRPr(), "<w:t xml:space=\"preserve\">" + ROMAN + " ы</w:t>"));
|
||||
|
||||
assertNotNull(out);
|
||||
assertEquals(2, occurrences(out, "xml:space=\"preserve\""),
|
||||
"xml:space задублирован: " + out);
|
||||
}
|
||||
|
||||
/** Числовые сущности разбираются, а не разрезаются по буквам. */
|
||||
@Test
|
||||
void decodesNumericEntities() {
|
||||
String out = GlyphCoverageNormalizer.rewrite(
|
||||
run(timesRPr(), "<w:t>⅒⅕</w:t>"));
|
||||
|
||||
assertNotNull(out, "сущности не разобраны: U+2152 требует подстановки");
|
||||
assertTrue(out.contains("DejaVu Serif"), "нет подстановки: " + out);
|
||||
}
|
||||
|
||||
/** Экранирование обратимо: & не превращается в &amp;. */
|
||||
@Test
|
||||
void escapesTextBack() {
|
||||
String out = GlyphCoverageNormalizer.rewrite(
|
||||
run(timesRPr(), "<w:t>Tom & Jerry " + ROMAN + "</w:t>"));
|
||||
|
||||
assertNotNull(out);
|
||||
assertTrue(out.contains("Tom & Jerry"), "сломано экранирование: " + out);
|
||||
assertFalse(out.contains("&amp;"), "двойное экранирование: " + out);
|
||||
}
|
||||
|
||||
/** Serif-ран уходит в serif-семейство, а не в sans fallback. */
|
||||
@Test
|
||||
void serifRunPrefersSerifFamily() {
|
||||
List<GlyphCoverageNormalizer.Segment> segments =
|
||||
GlyphCoverageNormalizer.split("ы" + ROMAN, "tinos");
|
||||
|
||||
assertNotNull(segments);
|
||||
assertEquals("dejavu serif", segments.get(1).family);
|
||||
}
|
||||
|
||||
/** Sans-ран уходит в sans fallback. */
|
||||
@Test
|
||||
void sansRunPrefersSansFamily() {
|
||||
List<GlyphCoverageNormalizer.Segment> segments =
|
||||
GlyphCoverageNormalizer.split("ы" + ROMAN, "carlito");
|
||||
|
||||
assertNotNull(segments);
|
||||
assertEquals("dejavu sans", segments.get(1).family);
|
||||
}
|
||||
|
||||
private static int occurrences(String s, String needle) {
|
||||
int count = 0;
|
||||
for (int i = s.indexOf(needle); i >= 0; i = s.indexOf(needle, i + 1)) {
|
||||
count++;
|
||||
}
|
||||
return count;
|
||||
}
|
||||
}
|
||||
Binary file not shown.
Reference in New Issue
Block a user