Экзотические глифы: решётка «#» вместо .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:
Pjandro
2026-10-05 22:29:10 +00:00
parent 0c10bae3cf
commit ae31f27a27
15 changed files with 865 additions and 24 deletions
+6 -2
View File
@@ -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. - Алиасы 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`). - `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). - Символы 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`. - Поля страниц: 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`. - Символьные шрифты: 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()`; конструктор маппера каждый раз заново добавляет их). Не менять местами. - Порядок инициализации в `WordPdfConverter.convertToStream` важен: сначала `new BundledFontMapper()`, потом `BundledFonts.init()`, затем `BundledFonts.restrictToBundled()` (чистит реестр `PhysicalFonts` от системных шрифтов до `load()`; конструктор маппера каждый раз заново добавляет их). Не менять местами.
- docx4j 17.x по-прежнему теряет атрибуты `w:val="off"/"on"` при JAXB-разборе — нормализация байтов до загрузки (`DocxOnOffNormalizer`) нужна и на 17.x (проверялось отключением: красный `ruPlain_regularRunsUseRegularFont`). - docx4j 17.x по-прежнему теряет атрибуты `w:val="off"/"on"` при JAXB-разборе — нормализация байтов до загрузки (`DocxOnOffNormalizer`) нужна и на 17.x (проверялось отключением: красный `ruPlain_regularRunsUseRegularFont`).
+16 -4
View File
@@ -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-шрифта | | Семейство | Аналог MS-шрифта |
|---|---| |---|---|
@@ -82,11 +82,17 @@ WordPdfConverter.convert(Path.of("doc.docx"), Path.of("out.pdf")); // явный
| Tinos | Times New Roman | | Tinos | Times New Roman |
| Cousine | Courier New | | Cousine | Courier New |
| DejaVu Sans / DejaVu Serif | fallback | | DejaVu Sans / DejaVu Serif | fallback |
| Noto Naskh Arabic | арабские дополнения U+07B1–U+08FF |
| Noto Sans Armenian | армянские знаки Unicode 16 |
`BundledFontMapper` подставляет метрически совместимые аналоги при конвертации `BundledFontMapper` подставляет метрически совместимые аналоги при конвертации
(`Calibri → Carlito` и т.д.). Нераспознанные шрифты и символы, не найденные в (`Calibri → Carlito` и т.д.). Нераспознанные шрифты и символы, не найденные в
шрифте ранa (em-dash «—», кавычки, U+2000–U+2EFF), падают в **DejaVu Sans** шрифте ран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`). (см. `fonts/FONT-LICENSE.txt`).
- DejaVu Sans / DejaVu Serif — **SIL OFL 1.1 / Bitstream Vera** - DejaVu Sans / DejaVu Serif — **SIL OFL 1.1 / Bitstream Vera**
(см. `fonts/DejaVu-LICENSE.txt`). (см. `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-раны могли рендериться жирным курсивом), из-за чего regular-раны могли рендериться жирным курсивом),
`SymbolFontNormalizer` (маркеры из Symbol/Wingdings вместо «#») и `SymbolFontNormalizer` (маркеры из Symbol/Wingdings вместо «#») и
`FieldNormalizer` (поля `PAGE`/`NUMPAGES` пересчитываются, а не печатают `FieldNormalizer` (поля `PAGE`/`NUMPAGES` пересчитываются, а не печатают
кэш из docx). кэш из docx) и `GlyphCoverageNormalizer` (раны со знаками вне их шрифта).
2. Документ загружается в `WordprocessingMLPackage`, привязывается 2. Документ загружается в `WordprocessingMLPackage`, привязывается
`BundledFontMapper`, диаграммы и SmartArt предварительно растеризуются `BundledFontMapper`, диаграммы и SmartArt предварительно растеризуются
в PNG (`DrawingPreRenderer`). в PNG (`DrawingPreRenderer`).
@@ -120,6 +128,10 @@ docx ──> нормализация байтов ──> docx4j (Wordprocessin
приближённые (ограничения FOP/docx4j, а не «мы что-то упустили»). приближённые (ограничения FOP/docx4j, а не «мы что-то упустили»).
- Символы U+2000–U+2EFF (em-dash и т.п.) берутся из шрифта ранa, если в нём - Символы U+2000–U+2EFF (em-dash и т.п.) берутся из шрифта ранa, если в нём
есть глиф, иначе — из fallback-семейства DejaVu. есть глиф, иначе — из fallback-семейства DejaVu.
- Знаков, которых нет ни в одном шрифте бандла, это не касается: вместо них
остаётся `.notdef`. В эталонном `references/word.docx` таких два — U+2188 (ↈ)
и U+218A (↊), они есть только в GNU FreeSerif под GPL, а бандл держится
целиком на SIL OFL.
- Поддержка таблиц/изображений — базовая (через docx4j/FOP). - Поддержка таблиц/изображений — базовая (через docx4j/FOP).
## Тесты ## Тесты
@@ -13,6 +13,7 @@ import ru.pjandro.wordpdf.fonts.BundledFonts;
import ru.pjandro.wordpdf.internal.chart.DrawingPreRenderer; import ru.pjandro.wordpdf.internal.chart.DrawingPreRenderer;
import ru.pjandro.wordpdf.internal.DocxOnOffNormalizer; import ru.pjandro.wordpdf.internal.DocxOnOffNormalizer;
import ru.pjandro.wordpdf.internal.FieldNormalizer; import ru.pjandro.wordpdf.internal.FieldNormalizer;
import ru.pjandro.wordpdf.internal.GlyphCoverageNormalizer;
import ru.pjandro.wordpdf.internal.FopFallbackFonts; import ru.pjandro.wordpdf.internal.FopFallbackFonts;
import ru.pjandro.wordpdf.internal.SymbolFontNormalizer; import ru.pjandro.wordpdf.internal.SymbolFontNormalizer;
@@ -115,6 +116,10 @@ public final class WordPdfConverter {
// ...и поля PAGE/NUMPAGES из fldChar делаем w:fldSimple, иначе // ...и поля PAGE/NUMPAGES из fldChar делаем w:fldSimple, иначе
// в колонтитулах печатается кэш docx (см. FieldNormalizer). // в колонтитулах печатается кэш docx (см. FieldNormalizer).
docxBytes = FieldNormalizer.normalize(docxBytes); docxBytes = FieldNormalizer.normalize(docxBytes);
// ...и раны со знаками, которых нет в их шрифте: без этого
// FOP рисует «#» (docx4j проверяет покрытие не для всех знаков
// и кэширует фолбэк на группу Юникода, см. GlyphCoverageNormalizer).
docxBytes = GlyphCoverageNormalizer.normalize(docxBytes);
WordprocessingMLPackage pkg = WordprocessingMLPackage.load( WordprocessingMLPackage pkg = WordprocessingMLPackage.load(
new ByteArrayInputStream(docxBytes)); new ByteArrayInputStream(docxBytes));
try { try {
@@ -46,6 +46,18 @@ public class BundledFontMapper extends BestMatchingMapper {
/** Финальный fallback: шрифт с гарантированной кириллицей. */ /** Финальный fallback: шрифт с гарантированной кириллицей. */
private static final String FALLBACK_FAMILY = BundledFonts.FALLBACK_FAMILY; 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} запрашивает у маппера для * Имя, которое docx4j {@code RunFontSelector} запрашивает у маппера для
* символов диапазона U+2000–U+2EFF (em-dash «—», кавычки «„», многоточие * символов диапазона U+2000–U+2EFF (em-dash «—», кавычки «„», многоточие
@@ -74,6 +86,10 @@ public class BundledFontMapper extends BestMatchingMapper {
m.put("cousine", "cousine"); m.put("cousine", "cousine");
m.put("dejavu sans", "dejavu sans"); m.put("dejavu sans", "dejavu sans");
m.put("dejavu serif", "dejavu serif"); 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); ALIASES = Map.copyOf(m);
} }
@@ -89,6 +105,17 @@ public class BundledFontMapper extends BestMatchingMapper {
: FALLBACK_FAMILY; : 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(...)}: для каждого * Вызывается docx4j при {@code package.setFontMapper(...)}: для каждого
* имени шрифта, использованного в документе, нужно определить, каким * имени шрифта, использованного в документе, нужно определить, каким
@@ -97,7 +97,14 @@ public final class BundledFonts {
new Entry("DejaVuSerif-Regular.ttf", "dejavu serif", V_REGULAR), new Entry("DejaVuSerif-Regular.ttf", "dejavu serif", V_REGULAR),
new Entry("DejaVuSerif-Bold.ttf", "dejavu serif", V_BOLD), new Entry("DejaVuSerif-Bold.ttf", "dejavu serif", V_BOLD),
new Entry("DejaVuSerif-Italic.ttf", "dejavu serif", V_ITALIC), 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. */ /** Ключ семейства (lowercase) -> начертание -> зарегистрированный PhysicalFont. */
@@ -209,6 +216,16 @@ public final class BundledFonts {
return null; 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) + начертание. * Зарегистрированный шрифт: семейство (lowercase) + начертание.
* *
@@ -7,20 +7,26 @@ import org.docx4j.fonts.PhysicalFont;
import ru.pjandro.wordpdf.fonts.BundledFonts; import ru.pjandro.wordpdf.fonts.BundledFonts;
/** /**
* Декларирует fallback-семейство (DejaVu Sans) в FOP-конфиге. * Декларирует бандл-шрифты jar в FOP-конфиге.
* *
* FOP-конфиг, который docx4j строит в {@code FOSettings}, содержит * FOP-конфиг, который docx4j строит в {@code FOSettings}, содержит
* только шрифты, реально использованные в документе ({@code fontsInUse}). * только шрифты, реально использованные в документе ({@code fontsInUse}).
* Но docx4j {@code RunFontSelector} для символов диапазона U+2000–U+2EFF * Но {@code RunFontSelector} может выставить в {@code font-family} и шрифт
* (em-dash «—», кавычки, многоточие) выставляет в FO * извне документа:
* {@code font-family}, маппированный с "Segoe UI Symbol" на DejaVu Sans * <ul>
* (см. {@link ru.pjandro.wordpdf.fonts.BundledFontMapper}). Если семейство * <li>для символов U+2000–U+2EFF (em-dash «—», кавычки, многоточие)
* не задекларировано в FOP-конфиге, FOP не может его встроить и падает * подставляется "Segoe UI Symbol", маппированный на DejaVu Sans
* на базовый неembedded-шрифт (Helvetica) — символ рендерится шрифтом * (см. {@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 { public final class FopFallbackFonts {
@@ -28,7 +34,7 @@ public final class FopFallbackFonts {
} }
/** /**
* Добавляет все начертания fallback-семейства в FOP-конфиг * Добавляет все начертания всех бандл-семейств в FOP-конфиг
* {@code foSettings}. Вызывать после {@code new FOSettings(pkg)} * {@code foSettings}. Вызывать после {@code new FOSettings(pkg)}
* и до передачи настроек в {@code FORendererApacheFOP}. * и до передачи настроек в {@code FORendererApacheFOP}.
*/ */
@@ -37,7 +43,16 @@ public final class FopFallbackFonts {
if (rendererFonts == null) { if (rendererFonts == null) {
return; 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) { if (regular == null) {
return; return;
} }
@@ -54,14 +69,13 @@ public final class FopFallbackFonts {
} }
} }
ObjectFactory factory = new ObjectFactory();
addFont(rendererFonts, factory, familyName, regular, "normal", "normal"); addFont(rendererFonts, factory, familyName, regular, "normal", "normal");
addFont(rendererFonts, factory, familyName, addFont(rendererFonts, factory, familyName,
BundledFonts.bold(BundledFonts.FALLBACK_FAMILY), "normal", "bold"); BundledFonts.bold(family), "normal", "bold");
addFont(rendererFonts, factory, familyName, addFont(rendererFonts, factory, familyName,
BundledFonts.italic(BundledFonts.FALLBACK_FAMILY), "italic", "normal"); BundledFonts.italic(family), "italic", "normal");
addFont(rendererFonts, factory, familyName, 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 (&#8212; / &#x2014;). */
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("&lt;", "<").replace("&gt;", ">")
.replace("&quot;", "\"").replace("&apos;", "'")
.replace("&amp;", "&");
}
/** Обратное {@link #decode}: текст снова безопасен для {@code w:t}. */
private static String encode(String text) {
return text.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;");
}
}
@@ -15,4 +15,12 @@
Источник: официальный tarball dejavu-fonts-ttf-2.37 (https://dejavu-fonts.github.io), Источник: официальный tarball dejavu-fonts-ttf-2.37 (https://dejavu-fonts.github.io),
LICENSE см. DejaVu-LICENSE.txt. 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.
@@ -67,6 +67,7 @@ public final class SampleDocxGenerator {
ruTableImage(dir.resolve("ru-table-image.docx")); ruTableImage(dir.resolve("ru-table-image.docx"));
symbolBullets(dir.resolve("symbol-bullets.docx")); symbolBullets(dir.resolve("symbol-bullets.docx"));
pageNumbers(dir.resolve("page-numbers.docx")); pageNumbers(dir.resolve("page-numbers.docx"));
exoticGlyphs(dir.resolve("exotic-glyphs.docx"));
System.out.println("Готово: " + dir.toAbsolutePath()); System.out.println("Готово: " + dir.toAbsolutePath());
} }
@@ -301,6 +302,30 @@ public final class SampleDocxGenerator {
.setFldCharType(STFldCharType.END); .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, поэтому /** Абзац-заголовок: POI 5.5 не имеет createHeading, поэтому
@@ -159,6 +159,38 @@ class WordPdfConverterTest {
"пропал текст пункта списка: " + text); "пропал текст пункта списка: " + 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} * Поля PAGE/NUMPAGES Word пишет как {@code fldChar} + {@code instrText}
* + закэшированный результат. Экспорт docx4j в FO инструкцию игнорирует * + закэшированный результат. Экспорт docx4j в FO инструкцию игнорирует
@@ -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>&#8530;&#8533;</w:t>"));
assertNotNull(out, "сущности не разобраны: U+2152 требует подстановки");
assertTrue(out.contains("DejaVu Serif"), "нет подстановки: " + out);
}
/** Экранирование обратимо: &amp; не превращается в &amp;amp;. */
@Test
void escapesTextBack() {
String out = GlyphCoverageNormalizer.rewrite(
run(timesRPr(), "<w:t>Tom &amp; Jerry " + ROMAN + "</w:t>"));
assertNotNull(out);
assertTrue(out.contains("Tom &amp; Jerry"), "сломано экранирование: " + out);
assertFalse(out.contains("&amp;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;
}
}