feat(core): собственный рендер OMML→PNG и полный FOP-конфиг шрифтов
PR checks / web (pull_request) Successful in 9s
PR checks / java (pull_request) Successful in 5m26s
Main: tests, deploy, autotests / web (push) Successful in 9s
Main: tests, deploy, autotests / images-web (push) Successful in 23s
Main: tests, deploy, autotests / java (push) Successful in 1m30s
Main: tests, deploy, autotests / images-app (push) Successful in 49s
Main: tests, deploy, autotests / deploy (push) Successful in 2m13s
Main: tests, deploy, autotests / autotests (push) Successful in 17s
Main: tests, deploy, autotests / rollback (push) Has been skipped
PR checks / web (pull_request) Successful in 9s
PR checks / java (pull_request) Successful in 5m26s
Main: tests, deploy, autotests / web (push) Successful in 9s
Main: tests, deploy, autotests / images-web (push) Successful in 23s
Main: tests, deploy, autotests / java (push) Successful in 1m30s
Main: tests, deploy, autotests / images-app (push) Successful in 49s
Main: tests, deploy, autotests / deploy (push) Successful in 2m13s
Main: tests, deploy, autotests / autotests (push) Successful in 17s
Main: tests, deploy, autotests / rollback (push) Has been skipped
Замена JEuclid/AWT-ветки формул на детерминированный растер только бандл-шрифтами jar (без fontconfig); FOP-конфиг дополняется всеми бандл-начертаниями при каждом declare — иначе общая FopFactory замораживает fopconf первого документа и теряет глифы. MathModel/MathRenderer: OMML (§22.1) → дерево боксов → PNG 300 dpi (только GlyphFont/fontbox, без java.awt.Font); метрики боксов равны габариту paint (пределы nary/sPre не обрезаются канвой). Unsupported конструкция или переполнение бюджета — текстовая деградация (m:t). Inline-картинка опускается раном w:rPr/w:position на базовую линию строки (FOP ставит инлайн-графику нижним краем на базу; AUDIT-FIX baseline-shift). Байтовое правило 6 MathFallbackNormalizer (перед GlyphCoverage) срезает unsupported-формулы до загрузки docx4j; формула в wps:txbx уходит в docx4j-фолбэк mathText. JEuclid исключён из pom (de.rototor jeuclid-core/jeuclid-fop); порядок zip-правил сдвинут (MathFallback → 6). Порядок сканов шрифтов закрыт гейтом FontsBundledOnlyInvariantTest + BundledFontAliases (единый алиас-реестр вместо рефлексивных мутаций реестра). Счётчики: 63 класса / 1004 теста (core 57/956, app 6/48); JaCoCo BRANCH core 0.8518. Доки: pipeline/render-limitations/repo-map/ testing/doc-bridge/MEM_USAGE_UPGRADE синхронизированы.
This commit was merged in pull request #113.
This commit is contained in:
@@ -29,6 +29,24 @@
|
||||
<dependency>
|
||||
<groupId>org.docx4j</groupId>
|
||||
<artifactId>docx4j-export-fo</artifactId>
|
||||
<!-- JEuclid (MathML-рендер FOP) исключён: формулы OMML больше не
|
||||
доходят до FO — DrawingPreRenderer заменяет каждую math-узел
|
||||
собственным растером (MathModel/MathRenderer) или текстом, а
|
||||
MathFallbackNormalizer (правило 6) срезает unsupported до
|
||||
загрузки. Jeuclid тянул AWT-менеджер шрифтов (fontconfig —
|
||||
падение на без-fontconfig хостах) и системные шрифты в вывод;
|
||||
инвариант «шрифты только бандла» пинит
|
||||
FontsBundledOnlyInvariantTest. -->
|
||||
<exclusions>
|
||||
<exclusion>
|
||||
<groupId>de.rototor.jeuclid</groupId>
|
||||
<artifactId>jeuclid-fop</artifactId>
|
||||
</exclusion>
|
||||
<exclusion>
|
||||
<groupId>de.rototor.jeuclid</groupId>
|
||||
<artifactId>jeuclid-core</artifactId>
|
||||
</exclusion>
|
||||
</exclusions>
|
||||
</dependency>
|
||||
<!-- Простой логгер в консоль (slf4j). Обязателен: без него docx4j
|
||||
пишет предупреждение прямо в выходной PDF. -->
|
||||
|
||||
@@ -0,0 +1,106 @@
|
||||
package ru.pjandro.wordpdf.fonts;
|
||||
|
||||
import java.util.HashMap;
|
||||
import java.util.Locale;
|
||||
import java.util.Map;
|
||||
|
||||
/**
|
||||
* Таблица алиасов имён шрифтов и обратное имя для {@code w:rFonts}.
|
||||
*
|
||||
* Почему это вынесено из {@link BundledFontMapper}: обращение к статикам
|
||||
* маппера (чарты, GlyphCoverageNormalizer, MathModel) по правилам JVM
|
||||
* инициализирует и суперкласс {@code BestMatchingMapper}, чей
|
||||
* {@code <clinit>} сканирует classpath-джары в реестр {@code PhysicalFonts};
|
||||
* системный скан гейтится свойствами {@code docx4j.fonts.discover*},
|
||||
* которые выставляет {@code WordPdfConverter.<clinit>}, — и при раннем
|
||||
* обращении к мапперу скан мог пройти без гейта. У этого класса нет
|
||||
* наследования, его статика безопасна при любом порядке загрузки.
|
||||
* Экземпляр {@code BundledFontMapper} создаётся только в конвейере
|
||||
* {@code WordPdfConverter} — всегда после его {@code <clinit>}.
|
||||
*/
|
||||
public final class BundledFontAliases {
|
||||
|
||||
/**
|
||||
* Алиасы: имя шрифта из документа (lowercase) -> бандл-семейство (lowercase).
|
||||
* Croscore (Arimo/Tinos/Cousine) и crosextra (Carlito/Caladea) шрифты
|
||||
* метрически совместимы с соответствующими MS-шрифтами и содержат
|
||||
* кириллицу.
|
||||
*/
|
||||
static final Map<String, String> ALIASES;
|
||||
|
||||
static {
|
||||
Map<String, String> m = new HashMap<>();
|
||||
// Частые MS-шрифты -> open-source аналоги
|
||||
m.put("calibri", "carlito");
|
||||
m.put("calibri light", "carlito");
|
||||
m.put("cambria", "caladea");
|
||||
m.put("arial", "arimo");
|
||||
m.put("times new roman", "tinos");
|
||||
m.put("courier new", "cousine");
|
||||
// Бандл-шрифты сами по себе (на случай, если документ прямо
|
||||
// указывает одно из них)
|
||||
m.put("carlito", "carlito");
|
||||
m.put("caladea", "caladea");
|
||||
m.put("arimo", "arimo");
|
||||
m.put("tinos", "tinos");
|
||||
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);
|
||||
}
|
||||
|
||||
/** Финальный fallback: шрифт с гарантированной кириллицей. */
|
||||
private static final String FALLBACK_FAMILY = BundledFonts.FALLBACK_FAMILY;
|
||||
|
||||
/**
|
||||
* Имя семейства для записи в {@code w:rFonts} (ключ — lowercase-семейство).
|
||||
* Нужно {@code GlyphCoverageNormalizer}: он пишет в разрезанный ран
|
||||
* человекочитаемое имя, а {@code BundledFontMapper.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 «—», кавычки «„», многоточие
|
||||
* «…»), если шрифт ранa не содержит глифа. Это виртуальное имя (в
|
||||
* документе его нет), поэтому маппим его на {@link #FALLBACK_FAMILY}:
|
||||
* без записи символ остаётся без font-family в FO и рендерится системным
|
||||
* неembedded-шрифтом (Helvetica).
|
||||
*/
|
||||
static final String SYMBOL_FONT = "Segoe UI Symbol";
|
||||
|
||||
private BundledFontAliases() {
|
||||
}
|
||||
|
||||
/**
|
||||
* Бандл-семейство для имени шрифта из документа (таблица алиасов)
|
||||
* или финальный fallback. Используется пре-рендером диаграмм и формул
|
||||
* (internal/chart), которому нужен тот же шрифт, что и у текста PDF.
|
||||
*/
|
||||
public static String bundledFamily(String docFontName) {
|
||||
String family = ALIASES.get(docFontName.toLowerCase(Locale.ROOT));
|
||||
return family != null && BundledFonts.regular(family) != null
|
||||
? family
|
||||
: FALLBACK_FAMILY;
|
||||
}
|
||||
|
||||
/**
|
||||
* Имя шрифта, которое можно поставить в {@code w:rFonts}, чтобы получить
|
||||
* бандл-семейство {@code family}: {@code GlyphCoverageNormalizer} пишет
|
||||
* его в разрезанные раны. Обратная к {@link #bundledFamily} операция —
|
||||
* имена берутся из таблицы алиасов, поэтому маппинг гарантированно
|
||||
* возвращается к тому же семейству.
|
||||
*/
|
||||
public static String documentFontName(String family) {
|
||||
return DISPLAY_NAMES.getOrDefault(family, family);
|
||||
}
|
||||
}
|
||||
@@ -4,10 +4,8 @@ import org.docx4j.fonts.BestMatchingMapper;
|
||||
import org.docx4j.fonts.PhysicalFont;
|
||||
import org.docx4j.wml.Fonts;
|
||||
|
||||
import java.util.HashMap;
|
||||
import java.util.LinkedHashSet;
|
||||
import java.util.Locale;
|
||||
import java.util.Map;
|
||||
import java.util.Set;
|
||||
|
||||
/**
|
||||
@@ -15,7 +13,8 @@ import java.util.Set;
|
||||
*
|
||||
* Стратегия (см. {@link #populateFontMappings}):
|
||||
* 1. Частые MS-шрифты заменяются метрически совместимыми open-source
|
||||
* аналогами (таблица алиасов) — они есть в jar и содержат кириллицу.
|
||||
* аналогами (таблица алиасов {@link BundledFontAliases}) — они есть в
|
||||
* jar и содержат кириллицу.
|
||||
* 2. Нераспознанные шрифты передаются родительскому
|
||||
* {@link BestMatchingMapper} (совпадение по Panose-кодам среди
|
||||
* доступных шрифтов).
|
||||
@@ -31,91 +30,15 @@ import java.util.Set;
|
||||
* запускает обнаружение системных шрифтов, которые могут занять те же
|
||||
* имена в реестре docx4j. Поэтому {@code BundledFonts.init()} нужно
|
||||
* вызывать ПОСЛЕ создания маппера, чтобы бандл-шрифты оказались в
|
||||
* реестре поверх системных.
|
||||
* реестре поверх системных. Таблица алиасов вынесена в
|
||||
* {@link BundledFontAliases}, чтобы обращение к ней не инициировало этот
|
||||
* класс до гейта {@code WordPdfConverter.<clinit>}.
|
||||
*/
|
||||
public class BundledFontMapper extends BestMatchingMapper {
|
||||
|
||||
/**
|
||||
* Алиасы: имя шрифта из документа (lowercase) -> бандл-семейство (lowercase).
|
||||
* Croscore (Arimo/Tinos/Cousine) и crosextra (Carlito/Caladea) шрифты
|
||||
* метрически совместимы с соответствующими MS-шрифтами и содержат
|
||||
* кириллицу.
|
||||
*/
|
||||
private static final Map<String, String> ALIASES;
|
||||
|
||||
/** Финальный 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 «—», кавычки «„», многоточие
|
||||
* «…»), если шрифт ранa не содержит глифа. Это виртуальное имя (в
|
||||
* документе его нет), поэтому маппим его на {@link #FALLBACK_FAMILY}:
|
||||
* без записи символ остаётся без font-family в FO и рендерится системным
|
||||
* неembedded-шрифтом (Helvetica).
|
||||
*/
|
||||
static final String SYMBOL_FONT = "Segoe UI Symbol";
|
||||
|
||||
static {
|
||||
Map<String, String> m = new HashMap<>();
|
||||
// Частые MS-шрифты -> open-source аналоги
|
||||
m.put("calibri", "carlito");
|
||||
m.put("calibri light", "carlito");
|
||||
m.put("cambria", "caladea");
|
||||
m.put("arial", "arimo");
|
||||
m.put("times new roman", "tinos");
|
||||
m.put("courier new", "cousine");
|
||||
// Бандл-шрифты сами по себе (на случай, если документ прямо
|
||||
// указывает одно из них)
|
||||
m.put("carlito", "carlito");
|
||||
m.put("caladea", "caladea");
|
||||
m.put("arimo", "arimo");
|
||||
m.put("tinos", "tinos");
|
||||
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);
|
||||
}
|
||||
|
||||
/**
|
||||
* Бандл-семейство для имени шрифта из документа (таблица алиасов)
|
||||
* или финальный fallback. Используется пре-рендером диаграмм
|
||||
* (internal/chart), которому нужен тот же шрифт, что и у текста PDF.
|
||||
*/
|
||||
public static String bundledFamily(String docFontName) {
|
||||
String family = ALIASES.get(docFontName.toLowerCase(Locale.ROOT));
|
||||
return family != null && BundledFonts.regular(family) != null
|
||||
? family
|
||||
: FALLBACK_FAMILY;
|
||||
}
|
||||
|
||||
/**
|
||||
* Имя шрифта, которое можно поставить в {@code w:rFonts}, чтобы получить
|
||||
* бандл-семейство {@code family}: {@code GlyphCoverageNormalizer} пишет
|
||||
* его в разрезанные раны. Обратная к {@link #bundledFamily} операция —
|
||||
* имена берутся из таблицы алиасов, поэтому маппинг гарантированно
|
||||
* возвращается к тому же семейству.
|
||||
*/
|
||||
public static String documentFontName(String family) {
|
||||
return DISPLAY_NAMES.getOrDefault(family, family);
|
||||
}
|
||||
|
||||
/**
|
||||
* Вызывается docx4j при {@code package.setFontMapper(...)}: для каждого
|
||||
* имени шрифта, использованного в документе, нужно определить, каким
|
||||
@@ -126,21 +49,21 @@ public class BundledFontMapper extends BestMatchingMapper {
|
||||
*/
|
||||
@Override
|
||||
public void populateFontMappings(Set<String> documentFontNames, Fonts wmlFonts) throws Exception {
|
||||
// Виртуальное имя для символов U+2000–U+2EFF (см. SYMBOL_FONT):
|
||||
// Виртуальное имя для символов U+2000–U+2EFF (см. BundledFontAliases.SYMBOL_FONT):
|
||||
// маппим сразу, чтобы оно не попало в remaining и родительский
|
||||
// BestMatchingMapper не пытался искать его в fontTable (и не логировал
|
||||
// "Font Segoe UI Symbol not found in font table!").
|
||||
if (BundledFonts.regular(FALLBACK_FAMILY) != null) {
|
||||
mapFamily(SYMBOL_FONT, FALLBACK_FAMILY);
|
||||
mapFamily(BundledFontAliases.SYMBOL_FONT, FALLBACK_FAMILY);
|
||||
}
|
||||
|
||||
Set<String> remaining = new LinkedHashSet<>();
|
||||
for (String docFontName : documentFontNames) {
|
||||
if (SYMBOL_FONT.equalsIgnoreCase(docFontName)) {
|
||||
if (BundledFontAliases.SYMBOL_FONT.equalsIgnoreCase(docFontName)) {
|
||||
// уже маппировано выше
|
||||
continue;
|
||||
}
|
||||
String family = ALIASES.get(docFontName.toLowerCase(Locale.ROOT));
|
||||
String family = BundledFontAliases.ALIASES.get(docFontName.toLowerCase(Locale.ROOT));
|
||||
if (family == null || BundledFonts.regular(family) == null) {
|
||||
// Нет алиаса (или init() не вызван) — доверимся родителю
|
||||
remaining.add(docFontName);
|
||||
|
||||
@@ -16,9 +16,11 @@ import org.apache.commons.compress.utils.SeekableInMemoryByteChannel;
|
||||
* Единый zip-проход переписывания XML-частей (.docx) вместо отдельных
|
||||
* проходов нормализаторов: к каждой записи {@code word/*.xml} применяются
|
||||
* все одиннадцать рерайтов в фиксированном порядке
|
||||
* Strict→OnOff→Symbol→Field→Invisible→GlyphCoverage→TableIndent→NumberingSuffix→Hidden→Ruby→MathFallback.
|
||||
* Strict→OnOff→Symbol→Field→Invisible→MathFallback→GlyphCoverage→TableIndent→NumberingSuffix→Hidden→Ruby.
|
||||
* Порядок значим: Strict первым — дальше части в transitional-виде
|
||||
* (TableIndent читает transitional-атрибуты {@code w:}); GlyphCoverage
|
||||
* (TableIndent читает transitional-атрибуты {@code w:}); MathFallback
|
||||
* шестым — flatten unsupported-формул даёт обычный текст ранов, который
|
||||
* следующий GlyphCoverage покрывает кириллицей бандла; GlyphCoverage
|
||||
* режет раны по финальному тексту рана (после Symbol/Invisible); Hidden
|
||||
* девятым — вырезает уже финальные раны (после Symbol/GLYPH-разбиений),
|
||||
* а его OnOff-форма vanish читается после правила 2. Каждый
|
||||
@@ -114,6 +116,10 @@ public final class DocxRewritePipeline {
|
||||
if (next != null) {
|
||||
cur = next;
|
||||
}
|
||||
next = MathFallbackNormalizer.rewrite(cur);
|
||||
if (next != null) {
|
||||
cur = next;
|
||||
}
|
||||
next = GlyphCoverageNormalizer.rewrite(cur);
|
||||
if (next != null) {
|
||||
cur = next;
|
||||
@@ -134,10 +140,6 @@ public final class DocxRewritePipeline {
|
||||
if (next != null) {
|
||||
cur = next;
|
||||
}
|
||||
next = MathFallbackNormalizer.rewrite(cur);
|
||||
if (next != null) {
|
||||
cur = next;
|
||||
}
|
||||
if (!cur.equals(xml)) {
|
||||
changed = true;
|
||||
rewritten = cur.getBytes(StandardCharsets.UTF_8);
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
package ru.pjandro.wordpdf.internal;
|
||||
|
||||
import ru.pjandro.wordpdf.fonts.BundledFontMapper;
|
||||
import ru.pjandro.wordpdf.fonts.BundledFontAliases;
|
||||
import ru.pjandro.wordpdf.fonts.BundledFonts;
|
||||
import ru.pjandro.wordpdf.fonts.GlyphFont;
|
||||
|
||||
@@ -38,7 +38,7 @@ import java.util.concurrent.ConcurrentHashMap;
|
||||
* Делаем то, что должен был сделать рендер: ран, в тексте которого есть
|
||||
* знаки без глифа, разрезается на части, и каждой части явно назначается
|
||||
* бандл-семейство, где глиф есть ({@link #targetFamily}). Имя пишется в
|
||||
* {@code w:rFonts}, дальше {@link BundledFontMapper} маппит его на TTF,
|
||||
* {@code w:rFonts}, дальше {@code BundledFontMapper} маппит его на TTF,
|
||||
* а {@link FopFallbackFonts} декларирует его в FOP-конфиге.
|
||||
*
|
||||
* Правила, ограничивающие вмешательство:
|
||||
@@ -406,7 +406,7 @@ final class GlyphCoverageNormalizer {
|
||||
if (!m.find()) {
|
||||
return null;
|
||||
}
|
||||
return BundledFontMapper.bundledFamily(m.group(2));
|
||||
return BundledFontAliases.bundledFamily(m.group(2));
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -414,7 +414,7 @@ final class GlyphCoverageNormalizer {
|
||||
* {@code w:rFonts}, а если их нет — вставляет элемент первым ребёнком.
|
||||
*/
|
||||
private static String forceFont(String rPr, String family) {
|
||||
String name = BundledFontMapper.documentFontName(family);
|
||||
String name = BundledFontAliases.documentFontName(family);
|
||||
String fonts = "<w:rFonts w:ascii=\"" + name + "\" w:hAnsi=\"" + name + "\"/>";
|
||||
if (rPr.isEmpty()) {
|
||||
return "<w:rPr>" + fonts + "</w:rPr>";
|
||||
|
||||
+225
-50
@@ -1,90 +1,265 @@
|
||||
package ru.pjandro.wordpdf.internal;
|
||||
|
||||
import ru.pjandro.wordpdf.internal.chart.MathModel;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashMap;
|
||||
import java.util.HashSet;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Set;
|
||||
import java.util.regex.Matcher;
|
||||
import java.util.regex.Pattern;
|
||||
|
||||
/**
|
||||
* Деградация OMML-формул (§22.1) в текст на хостах без fontconfig.
|
||||
* Байтовый скан формул OMML (§22.1): блок {@code m:oMathPara}/{@code m:oMath},
|
||||
* содержащий math-элемент вне {@link MathModel#SUPPORTED}, заменяется раном с
|
||||
* конкатенацией текста {@code m:t} (как штатный фолбэк docx4j
|
||||
* {@code XsltFOFunctions.mathText}) — формула видна текстом, а не теряется.
|
||||
*
|
||||
* <p>docx4j превращает {@code m:oMath}/{@code m:oMathPara} в
|
||||
* {@code fo:instream-foreign-object} с MathML, а FOP рисует его через
|
||||
* jeuclid-fop. JEuclid при первой формуле обращается к AWT-менеджеру шрифтов,
|
||||
* которому на Linux нужен fontconfig; без него конвертация падает
|
||||
* {@code InternalError: Fontconfig head is null} (репро: arm64 без /etc/fonts;
|
||||
* контейнерный рантайм проекта тоже без fontconfig — Containerfile).
|
||||
* Поэтому до загрузки docx4j формулы заменяются обычными ранами с текстом
|
||||
* {@code m:t} (конкатенация, как в штатном фолбэке docx4j
|
||||
* {@code XsltFOFunctions.mathText}) — формула видна, приложение не падает.
|
||||
* <p>Зачем скан до загрузки docx4j: собственный растер формул
|
||||
* ({@code MathModel}/{@code MathRenderer} в {@code DrawingPreRenderer})
|
||||
* уронил бы unsupported-конструкцию в {@code MathUnsupportedException} и
|
||||
* деградировал тем же текстом — но скан даёт детерминизм «формула целиком
|
||||
* текстом» для байтового уровня пайплайна и не зависит от JAXB-биндинга.
|
||||
* Рантайм-деградация остаётся второй сетью (биндинг может не смонтировать
|
||||
* неизвестный элемент, который скан увидел).
|
||||
*
|
||||
* <p>На хосте с fontconfig рерайт не срабатывает (возвращается {@code null},
|
||||
* пайплайн отдаёт тот же массив). Позиция в цепочке — после Ruby (правило 10),
|
||||
* одиннадцатый рерайт:
|
||||
* {@code m:oMathPara} содержит {@code m:oMath}, поэтому блок para заменяется
|
||||
* первым, иначе остался бы несбалансированный каркас. Префикс {@code m:}
|
||||
* предполагается (Word и strict-OOXML используют его; StrictOoxmlNormalizer
|
||||
* его не переименовывает).
|
||||
* <p>Скан namespace-aware: префиксы, привязанные к math-URI на корневом
|
||||
* элементе (+ переопределения {@code xmlns} внутри блока), — unsupported
|
||||
* проверяется только для тегов в math-namespace; префиксы чужих namespace'ов
|
||||
* ( {@code w:rPr} внутри рана формулы) игнорируются. Непривязанный/отсутствующий
|
||||
* map объявлений при наличии {@code :oMath} — консервативная обработка «как
|
||||
* math» (риск потерять контент при недобитом биндинге сильнее избыточной
|
||||
* деградации).
|
||||
*
|
||||
* <p>Регрессия — WordPdfConverterTest#ommlMath_drawnAsVectors.
|
||||
* <p>Позиция в цепочке — шестое правило, перед GlyphCoverage: flatten даёт
|
||||
* обычный текст ранов, который следующий рерайт покрывает кириллицей бандла
|
||||
* (раньше формулы с {@code м} теряли глифы именно из-за порядка —
|
||||
* GlyphCoverage не видел текст внутри OMML). Блок para заменяется первым:
|
||||
* {@code m:oMathPara} содержит {@code m:oMath}, иначе остался бы
|
||||
* несбалансированный каркас.
|
||||
*/
|
||||
final class MathFallbackNormalizer {
|
||||
|
||||
/** {@code m:oMathPara} ... {@code </m:oMathPara>} — блок формулы. */
|
||||
private static final Pattern MATH_PARA = Pattern.compile(
|
||||
"<m:oMathPara(?:\\s[^>]*)?>.*?</m:oMathPara>", Pattern.DOTALL);
|
||||
/** Закрывающий символ открывающего тега (скан конца корня формулы). */
|
||||
private static final char TAG_END = '>';
|
||||
|
||||
/** Самозакрывающийся {@code <m:oMathPara/>}. */
|
||||
private static final Pattern MATH_PARA_SELF = Pattern.compile(
|
||||
"<m:oMathPara(?:\\s[^>]*)?/>");
|
||||
/** Math-namespace OMML (§22.1). */
|
||||
private static final String MATH_NS =
|
||||
"http://schemas.openxmlformats.org/officeDocument/2006/math";
|
||||
|
||||
/** {@code m:oMath} ... {@code </m:oMath>} — встроенная формула. */
|
||||
private static final Pattern MATH_INLINE = Pattern.compile(
|
||||
"<m:oMath(?:\\s[^>]*)?>.*?</m:oMath>", Pattern.DOTALL);
|
||||
/** Объявление {@code xmlns:prefix="uri"} (значение без кавычек). */
|
||||
private static final Pattern XMLNS = Pattern.compile(
|
||||
"xmlns:([A-Za-z_][\\w.-]*)=\"([^\"]*)\"");
|
||||
|
||||
/** Самозакрывающийся {@code <m:oMath/>}. */
|
||||
private static final Pattern MATH_INLINE_SELF = Pattern.compile(
|
||||
"<m:oMath(?:\\s[^>]*)?/>");
|
||||
/** Начало блока формулы; префикс обязателен (без него {@code :oMath} нет). */
|
||||
private static final Pattern MATH_BLOCK = Pattern.compile(
|
||||
"<([A-Za-z_][\\w.-]*):oMath(Para)?(?=[\\s/>])");
|
||||
|
||||
/** Текстовый узел OMML; содержимое — уже экранированный XML-текст. */
|
||||
/** Элементный тег с префиксом {@code <p:name>} / {@code </p:name>}. */
|
||||
private static final Pattern PREFIXED_TAG = Pattern.compile(
|
||||
"</?([A-Za-z_][\\w.-]*):([A-Za-z_][\\w.-]*)");
|
||||
|
||||
/** Текстовый узел {@code <p:t>}; содержимое — уже экранированный XML. */
|
||||
private static final Pattern MATH_TEXT = Pattern.compile(
|
||||
"<m:t(?:\\s[^>]*)?>(.*?)</m:t>", Pattern.DOTALL);
|
||||
"<([A-Za-z_][\\w.-]*):t(?:\\s[^>]*)?>(.*?)</\\1:t>", Pattern.DOTALL);
|
||||
|
||||
private MathFallbackNormalizer() {
|
||||
}
|
||||
|
||||
/**
|
||||
* Рерайт одной XML-части: формулы → текст, если AWT-шрифтов нет.
|
||||
* Формул нет / шрифты есть / ничего не изменилось → {@code null}.
|
||||
* Рерайт одной XML-части: unsupported-формулы → текст. Формул нет /
|
||||
* все поддерживаются / ничего не изменилось → {@code null}
|
||||
* (пайплайн отдаёт тот же массив).
|
||||
*/
|
||||
static String rewrite(String xml) {
|
||||
if (!xml.contains("<m:oMath")) {
|
||||
if (!xml.contains(":oMath")) {
|
||||
return null;
|
||||
}
|
||||
return MathMlSupport.awtFontsAvailable() ? null : flatten(xml);
|
||||
Map<String, String> rootNs = rootNamespaces(xml);
|
||||
StringBuilder out = new StringBuilder();
|
||||
int pos = 0;
|
||||
boolean changed = false;
|
||||
Matcher m = MATH_BLOCK.matcher(xml);
|
||||
int search = 0;
|
||||
while (m.find(search)) {
|
||||
String prefix = m.group(1);
|
||||
boolean para = m.group(2) != null;
|
||||
int start = m.start();
|
||||
int tagEnd = tagEnd(xml, start);
|
||||
if (tagEnd < 0) {
|
||||
break; // незакрытый тег — дело валидатора, скан останавливаем
|
||||
}
|
||||
Map<String, String> ns = mergedNamespaces(rootNs, xml.substring(start, tagEnd));
|
||||
if (!isMath(ns, prefix)) {
|
||||
search = tagEnd;
|
||||
continue; // чужой namespace — не формула
|
||||
}
|
||||
int blockEnd;
|
||||
int before = tagEnd - 2;
|
||||
while (before > start && Character.isWhitespace(xml.charAt(before))) {
|
||||
before--;
|
||||
}
|
||||
boolean selfClosing = xml.charAt(before) == '/';
|
||||
if (selfClosing) {
|
||||
blockEnd = tagEnd;
|
||||
} else {
|
||||
String closing = "</" + prefix + ":oMath" + (para ? "Para" : "") + ">";
|
||||
int close = xml.indexOf(closing, tagEnd);
|
||||
if (close < 0) {
|
||||
break; // битый каркас — валидатор его и отвергнет
|
||||
}
|
||||
blockEnd = close + closing.length();
|
||||
}
|
||||
String block = xml.substring(start, blockEnd);
|
||||
if (hasUnsupported(ns, block)) {
|
||||
out.append(xml, pos, start).append(run(text(ns, block)));
|
||||
pos = blockEnd;
|
||||
changed = true;
|
||||
search = blockEnd;
|
||||
continue;
|
||||
}
|
||||
search = tagEnd;
|
||||
}
|
||||
if (!changed) {
|
||||
return null;
|
||||
}
|
||||
return out.append(xml, pos, xml.length()).toString();
|
||||
}
|
||||
|
||||
/**
|
||||
* Замена всех формул на раны с текстом (без проверки доступности шрифтов).
|
||||
* Формул нет → {@code null}. Package-private — прямой юнит-тест
|
||||
* детерминирован на любом хосте.
|
||||
* Объявления {@code xmlns:} фактического корневого элемента: пролог
|
||||
* ({@code <?xml ...?>}, комментарии, DOCTYPE) пропускается — иначе
|
||||
* карта осталась бы пустой на реальном XML-файле части, а пустая карта
|
||||
* консервативно считает каждый префикс math-тегом и срезает боевые
|
||||
* формулы (внутри {@code m:r}/{@code m:ctrlPr} Word пишет
|
||||
* {@code w:rPr}/{@code w:rFonts} — имена вне SUPPORTED).
|
||||
*/
|
||||
static String flatten(String xml) {
|
||||
String out = MATH_PARA.matcher(xml).replaceAll(m -> run(text(m.group())));
|
||||
out = MATH_PARA_SELF.matcher(out).replaceAll("");
|
||||
out = MATH_INLINE.matcher(out).replaceAll(m -> run(text(m.group())));
|
||||
out = MATH_INLINE_SELF.matcher(out).replaceAll("");
|
||||
return out.equals(xml) ? null : out;
|
||||
private static Map<String, String> rootNamespaces(String xml) {
|
||||
Map<String, String> map = new HashMap<>();
|
||||
int pos = 0;
|
||||
while (pos < xml.length()) {
|
||||
int open = xml.indexOf('<', pos);
|
||||
if (open < 0) {
|
||||
return map;
|
||||
}
|
||||
if (xml.startsWith("<?", open)) {
|
||||
int end = xml.indexOf("?>", open);
|
||||
pos = end < 0 ? xml.length() : end + 2;
|
||||
continue;
|
||||
}
|
||||
if (xml.startsWith("<!--", open)) {
|
||||
int end = xml.indexOf("-->", open);
|
||||
pos = end < 0 ? xml.length() : end + 3;
|
||||
continue;
|
||||
}
|
||||
if (xml.startsWith("<!", open)) {
|
||||
int end = xml.indexOf('>', open);
|
||||
pos = end < 0 ? xml.length() : end + 1;
|
||||
continue;
|
||||
}
|
||||
int end = tagEnd(xml, open);
|
||||
if (end < 0) {
|
||||
return map;
|
||||
}
|
||||
Matcher m = XMLNS.matcher(xml.substring(open, end));
|
||||
while (m.find()) {
|
||||
map.put(m.group(1), m.group(2));
|
||||
}
|
||||
return map;
|
||||
}
|
||||
return map;
|
||||
}
|
||||
|
||||
/** Текст формулы: конкатенация содержимого всех {@code m:t} (как docx4j mathText). */
|
||||
private static String text(String block) {
|
||||
Matcher m = MATH_TEXT.matcher(block);
|
||||
StringBuilder sb = new StringBuilder();
|
||||
/** Корневые объявления + переопределения из заголовка блока. */
|
||||
private static Map<String, String> mergedNamespaces(Map<String, String> root,
|
||||
String openTag) {
|
||||
Matcher m = XMLNS.matcher(openTag);
|
||||
if (!m.find()) {
|
||||
return root;
|
||||
}
|
||||
Map<String, String> map = new HashMap<>(root);
|
||||
m.reset();
|
||||
while (m.find()) {
|
||||
sb.append(m.group(1));
|
||||
map.put(m.group(1), m.group(2));
|
||||
}
|
||||
return map;
|
||||
}
|
||||
|
||||
/**
|
||||
* Привязан ли префикс к math-namespace: явная привязка — да; привязка к
|
||||
* другому URI — нет; префикс не объявлен нигде — да (консервативно, см.
|
||||
* javadoc класса), если только вообще нет ни одного объявления xmlns
|
||||
* (тогда это не XML с map префиксов, а мусор — тоже «как math»).
|
||||
*/
|
||||
private static boolean isMath(Map<String, String> ns, String prefix) {
|
||||
String bound = ns.get(prefix);
|
||||
if (MATH_NS.equals(bound)) {
|
||||
return true;
|
||||
}
|
||||
return bound == null;
|
||||
}
|
||||
|
||||
/** Есть ли в блоке тег math-namespace вне {@link MathModel#SUPPORTED}. */
|
||||
private static boolean hasUnsupported(Map<String, String> ns, String block) {
|
||||
List<String> mathPrefixes = new ArrayList<>();
|
||||
for (Map.Entry<String, String> e : ns.entrySet()) {
|
||||
if (MATH_NS.equals(e.getValue())) {
|
||||
mathPrefixes.add(e.getKey());
|
||||
}
|
||||
}
|
||||
Matcher m = PREFIXED_TAG.matcher(block);
|
||||
while (m.find()) {
|
||||
String prefix = m.group(1);
|
||||
String name = m.group(2);
|
||||
boolean mathTag = mathPrefixes.contains(prefix)
|
||||
|| (mathPrefixes.isEmpty() && !ns.containsKey(prefix));
|
||||
if (mathTag && !MathModel.SUPPORTED.contains(name)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/** Текст формулы: конкатенация {@code m:t} math-префиксов (как mathText). */
|
||||
private static String text(Map<String, String> ns, String block) {
|
||||
Set<String> mathPrefixes = new HashSet<>();
|
||||
for (Map.Entry<String, String> e : ns.entrySet()) {
|
||||
if (MATH_NS.equals(e.getValue())) {
|
||||
mathPrefixes.add(e.getKey());
|
||||
}
|
||||
}
|
||||
StringBuilder sb = new StringBuilder();
|
||||
Matcher m = MATH_TEXT.matcher(block);
|
||||
while (m.find()) {
|
||||
String prefix = m.group(1);
|
||||
if (mathPrefixes.contains(prefix)
|
||||
|| (mathPrefixes.isEmpty() && !ns.containsKey(prefix))) {
|
||||
sb.append(m.group(2));
|
||||
}
|
||||
}
|
||||
return sb.toString();
|
||||
}
|
||||
|
||||
/** Конец открывающего тега (индекс после {@code >}), кавычки-осведомлённый. */
|
||||
private static int tagEnd(String xml, int start) {
|
||||
char quote = 0;
|
||||
for (int i = start + 1; i < xml.length(); i++) {
|
||||
char c = xml.charAt(i);
|
||||
if (quote != 0) {
|
||||
if (c == quote) {
|
||||
quote = 0;
|
||||
}
|
||||
} else if (c == '"' || c == '\'') {
|
||||
quote = c;
|
||||
} else if (c == TAG_END) {
|
||||
return i + 1;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
/** Ран с текстом формулы; пустая формула удаляется. */
|
||||
private static String run(String text) {
|
||||
return text.isEmpty() ? ""
|
||||
|
||||
@@ -1,48 +0,0 @@
|
||||
package ru.pjandro.wordpdf.internal;
|
||||
|
||||
import java.awt.GraphicsEnvironment;
|
||||
import java.util.logging.Logger;
|
||||
|
||||
/**
|
||||
* Проба доступности AWT-шрифтового менеджера (fontconfig) в текущем JVM.
|
||||
*
|
||||
* <p>JEuclid (jeuclid-fop), которым docx4j рисует OMML (§22.1), при первой
|
||||
* отрисовке формулы вызывает {@code GraphicsEnvironment.getAvailableFontFamilyNames()}.
|
||||
* На Linux без libfontconfig/конфигурации шрифтов это падает
|
||||
* {@code InternalError → RuntimeException: Fontconfig head is null}
|
||||
* (репро: arm64 без /etc/fonts). Проба выполняется лениво и один раз:
|
||||
* результат определяет, оставлять ли MathML (вектор) или деградировать
|
||||
* формулу в текст в {@link MathFallbackNormalizer}.
|
||||
*
|
||||
* <p>Проба намеренно ловит {@link Throwable}: отказ приходит как
|
||||
* {@code java.lang.InternalError}, а не RuntimeException.
|
||||
*
|
||||
* <p>Регрессия — WordPdfConverterTest#ommlMath_drawnAsVectors.
|
||||
*/
|
||||
final class MathMlSupport {
|
||||
|
||||
private static final Logger LOGGER = Logger.getLogger(MathMlSupport.class.getName());
|
||||
|
||||
private MathMlSupport() {
|
||||
}
|
||||
|
||||
/** Доступен ли AWT-менеджер шрифтов (fontconfig); проба — один раз на JVM. */
|
||||
static boolean awtFontsAvailable() {
|
||||
return Holder.AVAILABLE;
|
||||
}
|
||||
|
||||
private static final class Holder {
|
||||
private static final boolean AVAILABLE = probe();
|
||||
}
|
||||
|
||||
private static boolean probe() {
|
||||
try {
|
||||
GraphicsEnvironment.getLocalGraphicsEnvironment().getAvailableFontFamilyNames();
|
||||
return true;
|
||||
} catch (Throwable t) {
|
||||
LOGGER.info("AWT-менеджер шрифтов недоступен (нет fontconfig): "
|
||||
+ "OMML-формулы будут отрисованы текстом: " + t);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -7,7 +7,7 @@ import org.docx4j.dml.CTTextParagraph;
|
||||
import org.docx4j.dml.CTTextParagraphProperties;
|
||||
import org.docx4j.dml.CTTextSpacing;
|
||||
import org.docx4j.dml.TextFont;
|
||||
import ru.pjandro.wordpdf.fonts.BundledFontMapper;
|
||||
import ru.pjandro.wordpdf.fonts.BundledFontAliases;
|
||||
import ru.pjandro.wordpdf.fonts.BundledFonts;
|
||||
|
||||
import ru.pjandro.wordpdf.fonts.GlyphFont;
|
||||
@@ -23,7 +23,7 @@ import java.util.List;
|
||||
* (a:defRPr / a:rPr: sz, b, i, solidFill, latin) и разбивка на строки.
|
||||
*
|
||||
* Шрифты берутся из того же бандла, что и у текста PDF
|
||||
* ({@link BundledFontMapper#bundledFamily}), поэтому подпись диаграммы
|
||||
* ({@link BundledFontAliases#bundledFamily}), поэтому подпись диаграммы
|
||||
* рисуется тем же Carlito/Tinos, что и абзацы документа.
|
||||
*/
|
||||
final class DrawMlText {
|
||||
@@ -84,7 +84,7 @@ final class DrawMlText {
|
||||
String fallbackFam, double fallbackSize, Color fallbackColor) {
|
||||
Style base = new Style(fallbackSize, false, false, fallbackColor,
|
||||
fallbackFam == null ? BundledFonts.FALLBACK_FAMILY
|
||||
: BundledFontMapper.bundledFamily(fallbackFam));
|
||||
: BundledFontAliases.bundledFamily(fallbackFam));
|
||||
if (txPr == null || txPr.getP().isEmpty()) {
|
||||
return base;
|
||||
}
|
||||
@@ -170,7 +170,7 @@ final class DrawMlText {
|
||||
case "+mj-lt", "+mj-ea", "+mj-cs" -> colors.majorFontName();
|
||||
default -> typeface;
|
||||
};
|
||||
return BundledFontMapper.bundledFamily(name != null ? name : fallbackFam);
|
||||
return BundledFontAliases.bundledFamily(name != null ? name : fallbackFam);
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
+247
-10
@@ -22,6 +22,8 @@ import org.docx4j.dml.diagram2008.CTDrawing;
|
||||
import org.docx4j.dml.picture.Pic;
|
||||
import org.docx4j.dml.wordprocessingDrawing.Anchor;
|
||||
import org.docx4j.dml.wordprocessingDrawing.Inline;
|
||||
import org.docx4j.math.CTOMath;
|
||||
import org.docx4j.math.CTOMathPara;
|
||||
import org.docx4j.openpackaging.contenttype.ContentTypes;
|
||||
import org.docx4j.openpackaging.exceptions.Docx4JException;
|
||||
import org.docx4j.openpackaging.exceptions.InvalidFormatException;
|
||||
@@ -32,7 +34,15 @@ import org.docx4j.openpackaging.parts.PartName;
|
||||
import org.docx4j.openpackaging.parts.ThemePart;
|
||||
import org.docx4j.openpackaging.parts.WordprocessingML.BinaryPartAbstractImage;
|
||||
import org.docx4j.openpackaging.parts.relationships.RelationshipsPart;
|
||||
import org.docx4j.wml.CTSignedHpsMeasure;
|
||||
import org.docx4j.wml.Drawing;
|
||||
import org.docx4j.wml.Jc;
|
||||
import org.docx4j.wml.JcEnumeration;
|
||||
import org.docx4j.wml.P;
|
||||
import org.docx4j.wml.PPr;
|
||||
import org.docx4j.wml.R;
|
||||
import org.docx4j.wml.RPr;
|
||||
import org.docx4j.wml.Text;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
import ru.pjandro.wordpdf.ChartsFoundException;
|
||||
@@ -41,10 +51,13 @@ import ru.pjandro.wordpdf.ConversionException;
|
||||
import ru.pjandro.wordpdf.SmartArtFoundException;
|
||||
|
||||
import javax.imageio.ImageIO;
|
||||
import javax.xml.namespace.QName;
|
||||
import java.awt.image.BufferedImage;
|
||||
import java.io.ByteArrayInputStream;
|
||||
import java.io.ByteArrayOutputStream;
|
||||
import java.io.IOException;
|
||||
import java.lang.reflect.Method;
|
||||
import java.math.BigInteger;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.HashSet;
|
||||
@@ -62,6 +75,17 @@ import java.util.Set;
|
||||
* пакета и до создания FOSettings, иначе FOP увидит исходные chart/diagram
|
||||
* и молча их выбросит (notImplemented в шаблоне).
|
||||
*
|
||||
* <p>Третий объект — формулы OMML (§22.1): {@code m:oMathPara}/{@code m:oMath}
|
||||
* доходят сюда нетронутыми (docx2fo.xslt кладёт их в
|
||||
* {@code fo:instream-foreign-object} с MathML, который FOP+jeuclid на
|
||||
* без-fontconfig хостах роняет конвертацию, а на остальных рисует чужими
|
||||
* системными шрифтами). Каждая формула рендерится своим растером
|
||||
* ({@link MathModel} → {@link MathRenderer}) и заменяется inline-картинкой
|
||||
* на месте; unsupported/битая формула деградирует раном с текстом
|
||||
* {@code m:t}. Байтовый скан {@code MathFallbackNormalizer} (правило 6)
|
||||
* срезает unsupported-конструкции до загрузки docx4j — этот путь остаётся
|
||||
* безопасной сетью.
|
||||
*
|
||||
* Error-флаги {@link ConvertOptions}: при выключенном render-флаге и
|
||||
* включённом error-флаге находка объекта — {@link ChartsFoundException} или
|
||||
* {@link SmartArtFoundException}
|
||||
@@ -81,6 +105,15 @@ public final class DrawingPreRenderer {
|
||||
"http://schemas.openxmlformats.org/drawingml/2006/picture";
|
||||
private static final String DIAGRAM_DRAWING_REL =
|
||||
"http://schemas.microsoft.com/office/2007/relationships/diagramDrawing";
|
||||
/** {@code m:} — namespace OMML (§22.1); {@code w:} — wordprocessingML. */
|
||||
private static final String MATH_URI =
|
||||
"http://schemas.openxmlformats.org/officeDocument/2006/math";
|
||||
/** Local name элемента {@code m:oMath} (диспетч JAXBElement по имени тега). */
|
||||
private static final String LOCAL_OMATH = "oMath";
|
||||
/** Local name элемента {@code m:oMathPara} (формула отдельным абзацем). */
|
||||
private static final String LOCAL_OMATH_PARA = "oMathPara";
|
||||
private static final String WML_URI =
|
||||
"http://schemas.openxmlformats.org/wordprocessingml/2006/main";
|
||||
|
||||
/**
|
||||
* Верхняя граница {@code wp:extent} в EMU: максимальная страница Word —
|
||||
@@ -147,7 +180,8 @@ public final class DrawingPreRenderer {
|
||||
if (content.isEmpty()) {
|
||||
continue;
|
||||
}
|
||||
walk(p, content, pkg, colors, idSeq, pngTotal, maxPngBytesTotal, options, visitedContents);
|
||||
walk(p, content, pkg, colors, idSeq, pngTotal, maxPngBytesTotal, options,
|
||||
visitedContents, null);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -175,26 +209,59 @@ public final class DrawingPreRenderer {
|
||||
private static void walk(Part part, List<?> content, WordprocessingMLPackage pkg,
|
||||
DrawMlColor colors, int[] idSeq, long[] pngTotal,
|
||||
long maxPngBytesTotal, ConvertOptions options,
|
||||
Set<List<?>> visitedContents) {
|
||||
Set<List<?>> visitedContents, P ownerPara) {
|
||||
// Посещённые списки — по идентичности (IdentityHashMap): рефлексивный
|
||||
// getContent (ребёнок возвращает список родителя) не зацикливает обход.
|
||||
// Сравнение списков через ==/!= запрещено PMD CompareObjectsWithEquals.
|
||||
if (!visitedContents.add(content)) {
|
||||
return;
|
||||
}
|
||||
for (Object o : content) {
|
||||
for (int i = 0; i < content.size(); i++) {
|
||||
Object o = content.get(i);
|
||||
Object v = o instanceof JAXBElement ? ((JAXBElement<?>) o).getValue() : o;
|
||||
if (v instanceof Drawing drawing) {
|
||||
replaceDrawing(part, drawing, pkg, colors, idSeq, pngTotal, maxPngBytesTotal, options);
|
||||
replaceDrawing(part, drawing, pkg, colors, idSeq, pngTotal,
|
||||
maxPngBytesTotal, options);
|
||||
continue;
|
||||
}
|
||||
if (o instanceof JAXBElement<?> el && el.getName() != null
|
||||
&& MATH_URI.equals(el.getName().getNamespaceURI())) {
|
||||
String local = el.getName().getLocalPart();
|
||||
if (LOCAL_OMATH.equals(local) && v instanceof CTOMath math) {
|
||||
i = splice(content, i, mathReplacements(math, false, part, pkg,
|
||||
idSeq, pngTotal, maxPngBytesTotal));
|
||||
continue;
|
||||
}
|
||||
if (LOCAL_OMATH_PARA.equals(local) && v instanceof CTOMathPara para) {
|
||||
i = splice(content, i, mathParaReplacements(para, ownerPara, part,
|
||||
pkg, idSeq, pngTotal, maxPngBytesTotal));
|
||||
continue;
|
||||
}
|
||||
}
|
||||
P para = v instanceof P p ? p : ownerPara;
|
||||
List<?> nested = invokeList(v, "getContent");
|
||||
if (!nested.isEmpty()) {
|
||||
walk(part, nested, pkg, colors, idSeq, pngTotal, maxPngBytesTotal, options, visitedContents);
|
||||
walk(part, nested, pkg, colors, idSeq, pngTotal, maxPngBytesTotal,
|
||||
options, visitedContents, para);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* In-place замена элемента {@code index} живого списка дерева на {@code reps}
|
||||
* (формула → картинка/текст). Живые списки docx4j — изменяемые
|
||||
* {@code ArrayList}; немодифицируемый список (нетипичный биндинг) —
|
||||
* {@link UnsupportedOperationException}, который вызывающий не ловит:
|
||||
* это ошибка программы, а не враждебный вход (валидатор пропускает только
|
||||
* OOXML-валидные пакеты). Raw-сигнатура — единственный способ mutate
|
||||
* {@code List<?>} без {@code @SuppressWarnings}.
|
||||
*/
|
||||
private static int splice(List content, int index, List reps) {
|
||||
content.remove(index);
|
||||
content.addAll(index, reps);
|
||||
return index + reps.size() - 1;
|
||||
}
|
||||
|
||||
private static List<?> invokeList(Object target, String getter) {
|
||||
try {
|
||||
Method m = target.getClass().getMethod(getter);
|
||||
@@ -269,6 +336,165 @@ public final class DrawingPreRenderer {
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Одна {@code m:oMath} → замены на позиции формулы: inline
|
||||
* {@code w:drawing} с pic:pic (успех) или ран с конкатенацией
|
||||
* {@code m:t} (деградация: unsupported-конструкция — безопасная сеть
|
||||
* после байтового скана MathFallbackNormalizer, пустая/битая формула,
|
||||
* переполнение бюджета PNG). OOM — {@link ConversionException}, не
|
||||
* деградация (тот же контракт, что у графиков).
|
||||
*/
|
||||
private static List<Object> mathReplacements(CTOMath math, boolean display,
|
||||
Part part, WordprocessingMLPackage pkg,
|
||||
int[] idSeq, long[] pngTotal,
|
||||
long maxPngBytesTotal) {
|
||||
try {
|
||||
MathRenderer.MathImage mi = MathRenderer.render(MathModel.build(math, display));
|
||||
if (mi.image() == null) {
|
||||
return textRuns(MathModel.mathText(math));
|
||||
}
|
||||
byte[] png;
|
||||
try {
|
||||
ByteArrayOutputStream bos = new ByteArrayOutputStream();
|
||||
ImageIO.write(mi.image(), "png", bos);
|
||||
png = bos.toByteArray();
|
||||
} finally {
|
||||
mi.image().flush();
|
||||
}
|
||||
if (png.length == 0) {
|
||||
LOG.warn("PNG формулы пуст — формула деградирована в текст");
|
||||
return textRuns(MathModel.mathText(math));
|
||||
}
|
||||
if (pngTotal[0] + png.length > maxPngBytesTotal) {
|
||||
LOG.warn("суммарный размер PNG превысил {} байт — формула деградирована в текст",
|
||||
maxPngBytesTotal);
|
||||
return textRuns(MathModel.mathText(math));
|
||||
}
|
||||
pngTotal[0] += png.length;
|
||||
String relId = addChartMedia(pkg, part, png);
|
||||
long cx = Math.round(mi.widthPt() * 12700.0);
|
||||
long cy = Math.round(mi.heightPt() * 12700.0);
|
||||
Drawing pic = mathPicture(idSeq, relId, cx, cy);
|
||||
if (display) {
|
||||
return List.of(pic);
|
||||
}
|
||||
// FOP ставит инлайн-картинку НИЖНИМ краем на базовую линию
|
||||
// строки, поэтому формула «всплывала» на descent+PAD над
|
||||
// текстом. Word роняет базовую линию формулы на базовую
|
||||
// линию строки — компенсируем смещением ранa вниз:
|
||||
// w:rPr/w:position (полупункты, отрицательное опускает,
|
||||
// §17.3.2.24) через AUDIT-FIX baseline-shift вендорного
|
||||
// XSLT. belowBaselinePt > PAD всегда (канва ≥ габариту +
|
||||
// 2·PAD), нулевого смещения не бывает. Регрессия —
|
||||
// WordPdfConverterTest#ommlMathInline_sitsOnTextBaseline.
|
||||
R run = new R();
|
||||
RPr rpr = new RPr();
|
||||
CTSignedHpsMeasure pos = new CTSignedHpsMeasure();
|
||||
pos.setVal(BigInteger.valueOf(-Math.round(2 * mi.belowBaselinePt())));
|
||||
rpr.setPosition(pos);
|
||||
run.setRPr(rpr);
|
||||
run.getContent().add(pic);
|
||||
return List.of(run);
|
||||
} catch (MathUnsupportedException e) {
|
||||
LOG.info("формула не поддерживается рендером — деградация в текст: {}",
|
||||
e.getMessage());
|
||||
return textRuns(MathModel.mathText(math));
|
||||
} catch (OutOfMemoryError e) {
|
||||
LOG.error("память исчерпана при рендере формулы", e);
|
||||
throw new ConversionException("Память исчерпана при рендере формулы", e);
|
||||
} catch (Docx4JException | IOException | RuntimeException e) {
|
||||
LOG.warn("рендер формулы упал: {}", e.toString());
|
||||
return textRuns(MathModel.mathText(math));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Блок {@code m:oMathPara} (§22.1.3.13): все формулы блока — display.
|
||||
* Word кладёт {@code oMathPara} либо в блок-контейнер (§22.1.3 —
|
||||
* наблюдаемая раскладка Word-файлов), либо в {@code w:p}; в первом
|
||||
* случае формулы заворачиваются в новый центрированный {@code w:p},
|
||||
* во втором — вставляются на место блока, а содержащему абзацу
|
||||
* выставляется {@code jc=center} (семантика центрированной
|
||||
* формулы-абзаца; prose в том же абзаце — враждебный вход, центрируется
|
||||
* тоже — зарегистрированная деградация).
|
||||
*/
|
||||
private static List<Object> mathParaReplacements(CTOMathPara para, P ownerPara,
|
||||
Part part, WordprocessingMLPackage pkg,
|
||||
int[] idSeq, long[] pngTotal,
|
||||
long maxPngBytesTotal) {
|
||||
List<Object> inner = new ArrayList<>();
|
||||
for (CTOMath m : para.getOMath()) {
|
||||
inner.addAll(mathReplacements(m, true, part, pkg, idSeq, pngTotal,
|
||||
maxPngBytesTotal));
|
||||
}
|
||||
if (ownerPara != null) {
|
||||
centerParagraph(ownerPara);
|
||||
return inner;
|
||||
}
|
||||
if (inner.isEmpty()) {
|
||||
return List.of();
|
||||
}
|
||||
P p = new P();
|
||||
PPr ppr = new PPr();
|
||||
Jc jc = new Jc();
|
||||
jc.setVal(JcEnumeration.CENTER);
|
||||
ppr.setJc(jc);
|
||||
p.setPPr(ppr);
|
||||
p.getContent().addAll(inner);
|
||||
return List.of(p);
|
||||
}
|
||||
|
||||
/** {@code jc=center} на абзаце (создаёт {@code w:pPr}, если нет). */
|
||||
private static void centerParagraph(P para) {
|
||||
PPr ppr = para.getPPr();
|
||||
if (ppr == null) {
|
||||
ppr = new PPr();
|
||||
para.setPPr(ppr);
|
||||
}
|
||||
Jc jc = new Jc();
|
||||
jc.setVal(JcEnumeration.CENTER);
|
||||
ppr.setJc(jc);
|
||||
}
|
||||
|
||||
/** Inline {@code w:drawing} с pic:Pic заданного размера (EMU). */
|
||||
private static Drawing mathPicture(int[] idSeq, String relId, long cx, long cy) {
|
||||
Drawing drawing = new Drawing();
|
||||
Inline inline = new Inline();
|
||||
inline.setDistT(0L);
|
||||
inline.setDistB(0L);
|
||||
inline.setDistL(0L);
|
||||
inline.setDistR(0L);
|
||||
CTPositiveSize2D extent = new CTPositiveSize2D();
|
||||
extent.setCx(cx);
|
||||
extent.setCy(cy);
|
||||
inline.setExtent(extent);
|
||||
CTNonVisualDrawingProps docPr = new CTNonVisualDrawingProps();
|
||||
docPr.setId(idSeq[0]++);
|
||||
docPr.setName("Формула " + docPr.getId());
|
||||
inline.setDocPr(docPr);
|
||||
Graphic graphic = new Graphic();
|
||||
GraphicData gd = new GraphicData();
|
||||
gd.setUri(PICTURE_URI);
|
||||
gd.getAny().add(buildPic(idSeq, relId, cx, cy, "Формула"));
|
||||
graphic.setGraphicData(gd);
|
||||
inline.setGraphic(graphic);
|
||||
drawing.getAnchorOrInline().add(inline);
|
||||
return drawing;
|
||||
}
|
||||
|
||||
/** Ран с текстом (деградация формулы); пустой текст — пустой список. */
|
||||
private static List<Object> textRuns(String text) {
|
||||
if (text.isEmpty()) {
|
||||
return List.of();
|
||||
}
|
||||
R run = new R();
|
||||
Text t = new Text();
|
||||
t.setValue(text);
|
||||
t.setSpace("preserve");
|
||||
run.getContent().add(new JAXBElement<>(new QName(WML_URI, "t"), Text.class, t));
|
||||
return List.of(run);
|
||||
}
|
||||
|
||||
private static BufferedImage renderChart(Part part, CTRelId ref,
|
||||
DrawMlColor colors, long cx, long cy) {
|
||||
Part target = resolve(part, ref.getId());
|
||||
@@ -384,11 +610,25 @@ public final class DrawingPreRenderer {
|
||||
return;
|
||||
}
|
||||
|
||||
Pic pic = buildPic(idSeq, relId, cx, cy, "Диаграмма");
|
||||
|
||||
gd.setUri(PICTURE_URI);
|
||||
gd.getAny().clear();
|
||||
gd.getAny().add(pic);
|
||||
}
|
||||
|
||||
/**
|
||||
* {@code pic:pic} на готовый media-r:id: id/имя из счётчика {@code idSeq}
|
||||
* (общего для картинок диаграмм и формул), геометрия — входной extent
|
||||
* (EMU), превью не нужно.
|
||||
*/
|
||||
private static Pic buildPic(int[] idSeq, String relId, long cx, long cy,
|
||||
String namePrefix) {
|
||||
Pic pic = new Pic();
|
||||
org.docx4j.dml.picture.CTPictureNonVisual nv = new org.docx4j.dml.picture.CTPictureNonVisual();
|
||||
CTNonVisualDrawingProps props = new CTNonVisualDrawingProps();
|
||||
props.setId(idSeq[0]++);
|
||||
props.setName("Диаграмма " + props.getId());
|
||||
props.setName(namePrefix + " " + props.getId());
|
||||
nv.setCNvPr(props);
|
||||
nv.setCNvPicPr(new CTNonVisualPictureProperties());
|
||||
pic.setNvPicPr(nv);
|
||||
@@ -418,10 +658,7 @@ public final class DrawingPreRenderer {
|
||||
geom.setAvLst(new CTGeomGuideList());
|
||||
spPr.setPrstGeom(geom);
|
||||
pic.setSpPr(spPr);
|
||||
|
||||
gd.setUri(PICTURE_URI);
|
||||
gd.getAny().clear();
|
||||
gd.getAny().add(pic);
|
||||
return pic;
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,75 @@
|
||||
package ru.pjandro.wordpdf.internal.chart;
|
||||
|
||||
import java.awt.Color;
|
||||
import java.awt.Graphics2D;
|
||||
import java.awt.RenderingHints;
|
||||
import java.awt.image.BufferedImage;
|
||||
|
||||
/**
|
||||
* Растеризация разобранной формулы: дерево {@link MathModel.Box} → PNG
|
||||
* в координатах pt×dpi/72 (тот же растер-контракт, что у график:
|
||||
* {@link ChartRenderer#DPI}, понижение dpi по {@link ChartRenderer#fitDpi}
|
||||
* при превышении площади). Фон прозрачный (ARGB), сглаживание включено —
|
||||
* глифы рисуются контурами fontbox, шрифтов хоста не касается.
|
||||
*
|
||||
* <p>Пустая формула (нулевые метрики) → {@link MathImage} с нулевыми
|
||||
* размерами и {@code image == null}: вызывающий заменяет её текстом
|
||||
* {@code m:t} либо убирает вовсе. {@code OutOfMemoryError} при раздутии
|
||||
* битмапа НЕ перехватывается — это {@code ConversionException} (500) выше
|
||||
* по стеку, не деградация (контракт chart-модели).
|
||||
*/
|
||||
final class MathRenderer {
|
||||
|
||||
/** Минимальный размер растра формулы, pt (тонкий индекс не «схлопнется»). */
|
||||
static final double MIN_WIDTH_PT = 4.0;
|
||||
|
||||
/** Минимальная высота растра формулы, pt. */
|
||||
static final double MIN_HEIGHT_PT = 12.0;
|
||||
|
||||
/** Отступ вокруг габарита формулы, pt (обрезка сглаженных краёв). */
|
||||
static final double PAD_PT = 1.0;
|
||||
|
||||
private MathRenderer() {
|
||||
}
|
||||
|
||||
/**
|
||||
* Растр формулы: PNG-носитель, габарит в pt (для extcx/extcy) и
|
||||
* {@code belowBaselinePt} — расстояние от базовой линии формулы до
|
||||
* нижнего края растра (высота минус верхний отступ и ascent; при
|
||||
* клампе к MIN_HEIGHT — с запасом снизу).
|
||||
*/
|
||||
record MathImage(BufferedImage image, double widthPt, double heightPt,
|
||||
double belowBaselinePt) {
|
||||
}
|
||||
|
||||
/** Растр бокса; пустой бокс → {@code image == null}, размеры 0. */
|
||||
static MathImage render(MathModel.Box root) {
|
||||
if (root.isEmpty()) {
|
||||
return new MathImage(null, 0, 0, 0);
|
||||
}
|
||||
double widthPt = Math.max(MIN_WIDTH_PT, root.width + 2 * PAD_PT);
|
||||
double heightPt = Math.max(MIN_HEIGHT_PT, root.ascent + root.descent + 2 * PAD_PT);
|
||||
double dpi = ChartRenderer.fitDpi(widthPt, heightPt);
|
||||
int w = Math.max(1, (int) Math.round(widthPt * dpi / 72.0));
|
||||
int h = Math.max(1, (int) Math.round(heightPt * dpi / 72.0));
|
||||
BufferedImage img = new BufferedImage(w, h, BufferedImage.TYPE_INT_ARGB);
|
||||
Graphics2D g = img.createGraphics();
|
||||
try {
|
||||
g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
|
||||
RenderingHints.VALUE_ANTIALIAS_ON);
|
||||
g.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
|
||||
RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
|
||||
g.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL,
|
||||
RenderingHints.VALUE_STROKE_PURE);
|
||||
g.setColor(new Color(0, 0, 0, 0));
|
||||
double k = dpi / 72.0;
|
||||
g.scale(k, k);
|
||||
double x = (widthPt - root.width) / 2.0;
|
||||
double baseline = PAD_PT + root.ascent;
|
||||
root.paint(g, x, baseline);
|
||||
} finally {
|
||||
g.dispose();
|
||||
}
|
||||
return new MathImage(img, widthPt, heightPt, heightPt - PAD_PT - root.ascent);
|
||||
}
|
||||
}
|
||||
+20
@@ -0,0 +1,20 @@
|
||||
package ru.pjandro.wordpdf.internal.chart;
|
||||
|
||||
/**
|
||||
* Конструкция OMML, которую формульный рендер не раскладывает: math-элемент
|
||||
* вне {@link MathModel#SUPPORTED}, math-узел не JAXBElement или структурная
|
||||
* поломка (например, {@code w:br} внутри math-рана).
|
||||
*
|
||||
* <p>Сигнал деградации, не отказа: {@code DrawingPreRenderer} заменяет
|
||||
* формулу её текстом {@code m:t} вместо растра (контент не теряется).
|
||||
* Бросается на разборе ({@link MathModel#build}), тем же критерием
|
||||
* срезается раньше — на байтовом уровне в {@code MathFallbackNormalizer}.
|
||||
*/
|
||||
final class MathUnsupportedException extends RuntimeException {
|
||||
|
||||
private static final long serialVersionUID = 1L;
|
||||
|
||||
MathUnsupportedException(String what) {
|
||||
super(what);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,191 @@
|
||||
package ru.pjandro.wordpdf;
|
||||
|
||||
import org.apache.pdfbox.Loader;
|
||||
import org.apache.pdfbox.pdmodel.PDDocument;
|
||||
import org.apache.pdfbox.pdmodel.PDResources;
|
||||
import org.apache.pdfbox.pdmodel.font.PDFont;
|
||||
import org.apache.pdfbox.cos.COSName;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.ByteArrayOutputStream;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.nio.file.Files;
|
||||
import java.nio.file.Path;
|
||||
import java.util.HashSet;
|
||||
import java.util.Set;
|
||||
import java.util.zip.ZipEntry;
|
||||
import java.util.zip.ZipOutputStream;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertThrows;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
/**
|
||||
* Инвариант «шрифты только бандла» после выноса JEuclid из класса путей:
|
||||
* MathML-рендер FOP (jeuclid-fop) обращался к AWT-менеджеру шрифтов и
|
||||
* тащил в вывод системные гарнитуры; формулы теперь рисуются собственным
|
||||
* растером из jar-шрифтов (fontbox), поэтому JEuclid в classpath и
|
||||
* протёкших системных имён в PDF быть не должно ни на одном хосте (в т.ч. без
|
||||
* fontconfig — CI-образ). Регрессия — удаление jeuclid, 2026-11.
|
||||
*/
|
||||
class FontsBundledOnlyInvariantTest {
|
||||
|
||||
private static final String M_NS =
|
||||
"http://schemas.openxmlformats.org/officeDocument/2006/math";
|
||||
private static final String W_NS =
|
||||
"http://schemas.openxmlformats.org/wordprocessingml/2006/main";
|
||||
|
||||
/**
|
||||
* JEuclid обязан отсутствовать в классе путей (exclusion в pom):
|
||||
* реальные FQCN обоих артефактов форка de.rototor (сверены по jar'ам
|
||||
* 3.1.14) — вымышленное имя дало бы зелёный тест и без exclusion.
|
||||
*/
|
||||
@Test
|
||||
void jeuclidAbsentFromClasspath() {
|
||||
assertThrows(ClassNotFoundException.class,
|
||||
() -> Class.forName("net.sourceforge.jeuclid.MathMLParserSupport"));
|
||||
assertThrows(ClassNotFoundException.class,
|
||||
() -> Class.forName("net.sourceforge.jeuclid.fop.JEuclidElementMapping"));
|
||||
}
|
||||
|
||||
/**
|
||||
* Исходники main не обращаются к AWT-шрифтам: ни {@code java.awt.Font},
|
||||
* ни {@code GraphicsEnvironment}, ни {@code createFont(} вне комментариев
|
||||
* и строк. Любое такое обращение инициализирует AWT-менеджер шрифтов
|
||||
* (fontconfig на хосте) и рвёт инвариант «только бандл» — детект по
|
||||
* тексту исходников работает и на хосте с шрифтами, и в CI-контейнере
|
||||
* без fontconfig.
|
||||
*/
|
||||
@Test
|
||||
void sourcesFreeOfAwtFonts() throws IOException {
|
||||
Path root = Files.isDirectory(Path.of("src/main/java"))
|
||||
? Path.of("src/main/java")
|
||||
: Path.of("wordpdf-core/src/main/java");
|
||||
assertTrue(Files.isDirectory(root), "нет каталога исходников: " + root.toAbsolutePath());
|
||||
java.util.regex.Pattern createFont =
|
||||
java.util.regex.Pattern.compile("\\bcreateFont\\s*\\(");
|
||||
Set<String> hits = new HashSet<>();
|
||||
try (var walk = Files.walk(root)) {
|
||||
for (Path p : (Iterable<Path>) walk.filter(f -> f.toString().endsWith(".java"))::iterator) {
|
||||
String effective = stripCommentsAndStrings(
|
||||
new String(Files.readAllBytes(p), StandardCharsets.UTF_8));
|
||||
if (effective.contains("java.awt.Font")
|
||||
|| effective.contains("java.awt.GraphicsEnvironment")
|
||||
|| createFont.matcher(effective).find()) {
|
||||
hits.add(root.relativize(p).toString());
|
||||
}
|
||||
}
|
||||
}
|
||||
assertTrue(hits.isEmpty(), "AWT-шрифты в исходниках: " + hits);
|
||||
}
|
||||
|
||||
/** Выкидывает комментарии и строковые/символьные литералы — остаётся код. */
|
||||
private static String stripCommentsAndStrings(String src) {
|
||||
StringBuilder out = new StringBuilder(src.length());
|
||||
int i = 0;
|
||||
int n = src.length();
|
||||
while (i < n) {
|
||||
char c = src.charAt(i);
|
||||
if (c == '/' && i + 1 < n && src.charAt(i + 1) == '/') {
|
||||
while (i < n && src.charAt(i) != '\n') {
|
||||
i++;
|
||||
}
|
||||
} else if (c == '/' && i + 1 < n && src.charAt(i + 1) == '*') {
|
||||
i += 2;
|
||||
while (i + 1 < n && !(src.charAt(i) == '*' && src.charAt(i + 1) == '/')) {
|
||||
i++;
|
||||
}
|
||||
i += 2;
|
||||
} else if (c == '"' || c == '\'') {
|
||||
char q = c;
|
||||
i++;
|
||||
while (i < n && src.charAt(i) != q) {
|
||||
i += src.charAt(i) == '\\' ? 2 : 1;
|
||||
}
|
||||
i++;
|
||||
out.append(' ');
|
||||
} else {
|
||||
out.append(c);
|
||||
i++;
|
||||
}
|
||||
}
|
||||
return out.toString();
|
||||
}
|
||||
|
||||
/**
|
||||
* Формула Word-кегля с {@code w:rFonts w:ascii="Cambria Math"}: растр
|
||||
* рисуется бандлом, в PDF нет ни «Cambria Math», ни иного имени с
|
||||
* Math-маркером (AWT-цепочка недоступна на без-fontconfig хостах в
|
||||
* CI — тест одинаков на любом хосте).
|
||||
*/
|
||||
@Test
|
||||
void mathEmbeddedFonts_bundledOnly() throws IOException {
|
||||
String body = "<w:p><w:r><w:t>ТЕКСТ</w:t></w:r>"
|
||||
+ "<m:oMath xmlns:m=\"" + M_NS + "\">"
|
||||
+ "<m:r><w:rPr><w:rFonts w:ascii=\"Cambria Math\"/></w:rPr>"
|
||||
+ "<m:t>∑x²</m:t></m:r></m:oMath></w:p>";
|
||||
byte[] pdf = WordPdfConverter.convert(mathDocx(body), "тест",
|
||||
new ConvertOptions(false, false, false, 5, 100));
|
||||
Path out = Files.createTempFile("fonts-invariant-", ".pdf");
|
||||
try {
|
||||
Files.write(out, pdf);
|
||||
Set<String> names = embeddedFontNames(out);
|
||||
for (String n : names) {
|
||||
assertTrue(!n.contains("Cambria") && !n.contains("Math"),
|
||||
"системный math-шрифт встроился в PDF: " + n + " ⊆ " + names);
|
||||
}
|
||||
} finally {
|
||||
Files.deleteIfExists(out);
|
||||
}
|
||||
}
|
||||
|
||||
/** Минимальный docx с формулой (идеома модуля: ZipOutputStream из литералов). */
|
||||
private static byte[] mathDocx(String bodyXml) throws IOException {
|
||||
ByteArrayOutputStream out = new ByteArrayOutputStream();
|
||||
try (ZipOutputStream zos = new ZipOutputStream(out)) {
|
||||
putZip(zos, "[Content_Types].xml",
|
||||
"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>"
|
||||
+ "<Types xmlns=\"http://schemas.openxmlformats.org/package/2006/content-types\">"
|
||||
+ "<Default Extension=\"rels\" ContentType=\"application/vnd.openxmlformats-package.relationships+xml\"/>"
|
||||
+ "<Default Extension=\"xml\" ContentType=\"application/xml\"/>"
|
||||
+ "<Override PartName=\"/word/document.xml\" ContentType=\"application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml\"/>"
|
||||
+ "</Types>");
|
||||
putZip(zos, "_rels/.rels",
|
||||
"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>"
|
||||
+ "<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">"
|
||||
+ "<Relationship Id=\"rId1\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument\" Target=\"word/document.xml\"/>"
|
||||
+ "</Relationships>");
|
||||
putZip(zos, "word/document.xml",
|
||||
"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>"
|
||||
+ "<w:document xmlns:w=\"" + W_NS + "\"><w:body>"
|
||||
+ bodyXml
|
||||
+ "<w:sectPr><w:pgSz w:w=\"11906\" w:h=\"16838\"/></w:sectPr>"
|
||||
+ "</w:body></w:document>");
|
||||
}
|
||||
return out.toByteArray();
|
||||
}
|
||||
|
||||
private static void putZip(ZipOutputStream zos, String name, String xml)
|
||||
throws IOException {
|
||||
zos.putNextEntry(new ZipEntry(name));
|
||||
zos.write(xml.getBytes(StandardCharsets.UTF_8));
|
||||
zos.closeEntry();
|
||||
}
|
||||
|
||||
/** Имена встроенных шрифтов PDF (дублируется намеренно: утилит нет). */
|
||||
private static Set<String> embeddedFontNames(Path pdf) throws IOException {
|
||||
Set<String> names = new HashSet<>();
|
||||
try (PDDocument doc = Loader.loadPDF(pdf.toFile())) {
|
||||
for (org.apache.pdfbox.pdmodel.PDPage page : doc.getPages()) {
|
||||
PDResources res = page.getResources();
|
||||
for (COSName name : res.getFontNames()) {
|
||||
PDFont font = res.getFont(name);
|
||||
if (font != null) {
|
||||
names.add(font.getName());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return names;
|
||||
}
|
||||
}
|
||||
@@ -2394,17 +2394,6 @@ class WordPdfConverterTest {
|
||||
}
|
||||
}
|
||||
|
||||
/** Доступен ли AWT-менеджер шрифтов (fontconfig) — та же проба, что в ядре. */
|
||||
private static boolean awtFontsAvailable() {
|
||||
try {
|
||||
java.awt.GraphicsEnvironment.getLocalGraphicsEnvironment()
|
||||
.getAvailableFontFamilyNames();
|
||||
return true;
|
||||
} catch (Throwable t) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Скрытый текст не выводится: правило 9 (HiddenTextNormalizer) вырезает
|
||||
* раны с прямым truthy vanish и с rStyle на vanish-стиль; falsy vanish
|
||||
@@ -2693,31 +2682,149 @@ class WordPdfConverterTest {
|
||||
}
|
||||
|
||||
/**
|
||||
* OMML-формула (§22.1): на хосте с fontconfig рисуется вектором
|
||||
* (jeuclid-fop) — чернила страницы с дробью a/b заметно плотнее чернил
|
||||
* того же текста без формулы (замер аудита: +150 px при 150 dpi; текст
|
||||
* формулы из PDF не извлекается). Без fontconfig (контейнерный рантайм,
|
||||
* arm64-хост без /etc/fonts) JEuclid недоступен: формула обязана
|
||||
* деградировать в текст (MathFallbackNormalizer), а не валить конвертацию
|
||||
* InternalError'ом — чернил становится больше, чем у маркера.
|
||||
* Формула внутри текстового бокса ({@code w:txbxContent}): обход
|
||||
* {@code DrawingPreRenderer} в drawing-нагрузку не спускается, формула
|
||||
* доходит до FO, а там docx4j без JEuclid штатно фолбэкает
|
||||
* {@code XsltFOFunctions.mathText} — конвертация обязана пройти, текст
|
||||
* бокса напечатан, падения FOP (нет MathML-рендера) нет. Регрессия —
|
||||
* удаление jeuclid без sweep'а, 2026-11.
|
||||
*/
|
||||
@Test
|
||||
void ommlMath_drawnAsVectors() throws IOException {
|
||||
String marker = "<w:p><w:r><w:t>МАТЕМАРКЕР</w:t></w:r></w:p>";
|
||||
String math = marker + "<w:p><m:oMath"
|
||||
+ " xmlns:m=\"http://schemas.openxmlformats.org/officeDocument/2006/math\">"
|
||||
void drawingTextBoxMath_convertsViaDocx4jTextFallback() throws IOException {
|
||||
String body = "<w:p><w:r><w:drawing><wp:inline distT=\"0\" distB=\"0\" distL=\"0\" distR=\"0\">"
|
||||
+ "<wp:extent cx=\"1000000\" cy=\"600000\"/><wp:docPr id=\"1\" name=\"b1\"/>"
|
||||
+ "<a:graphic xmlns:a=\"http://schemas.openxmlformats.org/drawingml/2006/main\">"
|
||||
+ "<a:graphicData uri=\"http://schemas.openxmlformats.org/drawingml/2006/wordprocessingShape\">"
|
||||
+ "<wps:wsp xmlns:wps=\"http://schemas.microsoft.com/office/word/2010/wordprocessingShape\">"
|
||||
+ "<wps:spPr><a:xfrm><a:off x=\"0\" y=\"0\"/>"
|
||||
+ "<a:ext cx=\"1000000\" cy=\"600000\"/></a:xfrm>"
|
||||
+ "<a:prstGeom prst=\"rect\"><a:avLst/></a:prstGeom></wps:spPr>"
|
||||
+ "<wps:txbx><w:txbxContent><w:p><w:r><w:t>БОКС</w:t></w:r>"
|
||||
+ "<m:oMath xmlns:m=\"http://schemas.openxmlformats.org/officeDocument/2006/math\">"
|
||||
+ "<m:f><m:num><m:r><m:t>a</m:t></m:r></m:num>"
|
||||
+ "<m:den><m:r><m:t>b</m:t></m:r></m:den></m:f></m:oMath></w:p>";
|
||||
int plainPx = countPixels(minimalDocx(marker), false);
|
||||
int mathPx = countPixels(minimalDocx(math), false);
|
||||
if (awtFontsAvailable()) {
|
||||
assertTrue(mathPx - plainPx >= 100, "math=" + mathPx + " plain=" + plainPx);
|
||||
} else {
|
||||
assertTrue(mathPx > plainPx,
|
||||
"формула не деградировала в текст: math=" + mathPx + " plain=" + plainPx);
|
||||
+ "<m:den><m:r><m:t>b</m:t></m:r></m:den></m:f></m:oMath></w:p>"
|
||||
+ "</w:txbxContent></wps:txbx></wps:wsp></a:graphicData></a:graphic></wp:inline>"
|
||||
+ "</w:drawing></w:r></w:p>";
|
||||
byte[] doc = docx("xmlns:w=\"" + W_NS + "\""
|
||||
+ " xmlns:wp=\"http://schemas.openxmlformats.org/drawingml/2006/wordprocessingDrawing\"",
|
||||
body, A4_SECT, null, null, null);
|
||||
String t = norm(pdfText(convertPdf(doc, "тест")));
|
||||
assertTrue(t.contains("БОКС"), t);
|
||||
assertTrue(t.contains("ab"),
|
||||
"docx4j-фолбэк обязан напечатать конкатенацию m:t формулы: " + t);
|
||||
}
|
||||
|
||||
/**
|
||||
* OMML-формула (§22.1) рисуется собственным растером (MathModel →
|
||||
* MathRenderer в DrawingPreRenderer) и заменяется картинкой: inline
|
||||
* {@code m:oMath} — на месте в абзаце, блок {@code m:oMathPara} —
|
||||
* центрированным абзацем. Чернила формул — растровые XObject, символа
|
||||
* формул в текстовом слое нет; поведение не зависит от fontconfig
|
||||
* (jeuclid/AWT-шрифты в конвейере не участвуют). Регрессия —
|
||||
* замена jeuclid-ветки на собственный рендер, 2026-11.
|
||||
*/
|
||||
@Test
|
||||
void ommlMath_drawnAsRaster() throws IOException {
|
||||
String mathNs = " xmlns:m=\"http://schemas.openxmlformats.org"
|
||||
+ "/officeDocument/2006/math\"";
|
||||
String frac = "<m:f><m:num><m:r><m:t>a</m:t></m:r></m:num>"
|
||||
+ "<m:den><m:r><m:t>b</m:t></m:r></m:den></m:f>";
|
||||
String body = "<w:p><w:r><w:t>МАТЕМАРКЕР</w:t></w:r>"
|
||||
+ "<m:oMath" + mathNs + ">" + frac + "</m:oMath></w:p>"
|
||||
+ "<m:oMathPara" + mathNs + "><m:oMath>" + frac
|
||||
+ "</m:oMath></m:oMathPara>";
|
||||
Path pdf = convertPdf(minimalDocx(body), "тест");
|
||||
assertEquals(2, distinctImageCount(pdf),
|
||||
"обе формулы (inline и display) обязаны стать растрами");
|
||||
String t = norm(pdfText(pdf));
|
||||
assertTrue(t.contains("МАТЕМАРКЕР"), t);
|
||||
assertFalse(t.contains("a b") || t.contains("ab"),
|
||||
"формула протекла в текстовый слой: " + t);
|
||||
}
|
||||
|
||||
/**
|
||||
* Inline-формула стоит на базовой линии строки, как в Word: FOP
|
||||
* роняет нижний край инлайн-картинки на базовую линию, поэтому
|
||||
* {@code DrawingPreRenderer} опускает ран с картинкой через
|
||||
* {@code w:rPr/w:position} на её нижний запас (descent+PAD). Замер —
|
||||
* попиксельно (144 dpi): чернила знаменателя без спуска (цифры)
|
||||
* обязаны кончаться на строке базовой линии текста (±2 px). Без
|
||||
* компенсации формула висела на ~3 pt выше базы. Регрессия —
|
||||
* собственный рендер OMML, 2026-11.
|
||||
*/
|
||||
@Test
|
||||
void ommlMathInline_sitsOnTextBaseline() throws IOException {
|
||||
String body = "<w:p><w:r><w:t>ZZZ</w:t></w:r>"
|
||||
+ "<m:oMath xmlns:m=\"http://schemas.openxmlformats.org"
|
||||
+ "/officeDocument/2006/math\">"
|
||||
+ "<m:f><m:num><m:r><m:t>7</m:t></m:r></m:num>"
|
||||
+ "<m:den><m:r><m:t>1</m:t></m:r></m:den></m:f></m:oMath>"
|
||||
+ "<w:r><w:t>YYY</w:t></w:r></w:p>";
|
||||
Path pdf = convertPdf(minimalDocx(body), "тест");
|
||||
final double[] baseY = {Double.NaN};
|
||||
final double[] zEnd = {0};
|
||||
final double[] yStart = {99999};
|
||||
PDFTextStripper stripper = new PDFTextStripper() {
|
||||
@Override
|
||||
protected void writeString(String s,
|
||||
List<org.apache.pdfbox.text.TextPosition> positions) {
|
||||
for (org.apache.pdfbox.text.TextPosition tp : positions) {
|
||||
if ("Z".equals(tp.getUnicode())) {
|
||||
baseY[0] = tp.getYDirAdj();
|
||||
zEnd[0] = Math.max(zEnd[0], tp.getXDirAdj() + tp.getWidth());
|
||||
} else if ("Y".equals(tp.getUnicode())) {
|
||||
yStart[0] = Math.min(yStart[0], tp.getXDirAdj());
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
float scale = 2f;
|
||||
try (PDDocument doc = Loader.loadPDF(pdf.toFile())) {
|
||||
stripper.setStartPage(1);
|
||||
stripper.setEndPage(1);
|
||||
stripper.getText(doc);
|
||||
java.awt.image.BufferedImage raster =
|
||||
new PDFRenderer(doc).renderImage(0, scale);
|
||||
int x0 = (int) (zEnd[0] * scale) + 2;
|
||||
int x1 = (int) (yStart[0] * scale) - 2;
|
||||
int baselineRow = (int) Math.round(baseY[0] * scale);
|
||||
int inkBottom = -1;
|
||||
final int inkMask = 0xFFFFFF;
|
||||
final int inkMax = 0x808080;
|
||||
for (int y = 0; y < raster.getHeight(); y++) {
|
||||
for (int x = x0; x < x1; x++) {
|
||||
if ((raster.getRGB(x, y) & inkMask) < inkMax) {
|
||||
inkBottom = y;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
assertTrue(inkBottom > 0, "чернил формулы между ZZZ и YYY нет");
|
||||
assertTrue(Math.abs(inkBottom - baselineRow) <= 2,
|
||||
"низ чернил формулы row=" + inkBottom
|
||||
+ " против базовой строки row=" + baselineRow);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Неизвестная math-конструкция (вне {@code MathModel.SUPPORTED}):
|
||||
* MathFallbackNormalizer (правило 6) срезает блок в конкатенацию
|
||||
* {@code m:t} ещё до загрузки docx4j — текст выводится (кириллица —
|
||||
* бандлом, GlyphCoverage видит уже расплющенный ран), растра нет.
|
||||
*/
|
||||
@Test
|
||||
void ommlUnsupported_degradesToText() throws IOException {
|
||||
String body = "<w:p><m:oMath"
|
||||
+ " xmlns:m=\"http://schemas.openxmlformats.org/officeDocument/2006/math\">"
|
||||
+ "<m:fooBar><m:r><m:t>ФОРМУЛАДЕГРАД</m:t></m:r></m:fooBar>"
|
||||
+ "</m:oMath></w:p>";
|
||||
Path pdf = convertPdf(minimalDocx(body), "тест");
|
||||
String t = norm(pdfText(pdf));
|
||||
assertTrue(t.contains("ФОРМУЛАДЕГРАД"), t);
|
||||
assertEquals(0, distinctImageCount(pdf),
|
||||
"unsupported-формула не обязана давать растр");
|
||||
}
|
||||
|
||||
/**
|
||||
* {@code w:highlight} и run-{@code w:shd} (§17.3.2.16/.29) рисуют фон —
|
||||
* вопреки прежней записи аудита о «фоном не обладающем fo:inline»
|
||||
|
||||
@@ -0,0 +1,71 @@
|
||||
package ru.pjandro.wordpdf.fonts;
|
||||
|
||||
import org.docx4j.fonts.PhysicalFont;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.lang.reflect.Field;
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
/**
|
||||
* Таблица алиасов шрифтов (BundledFontAliases): прямое и обратное
|
||||
* имя, fallback. Состояние «бандл не инициализирован» моделируется
|
||||
* сохранением и восстановлением статического реестра BundledFonts.
|
||||
*
|
||||
* Класс намеренно не наследует BestMatchingMapper: обращение к его
|
||||
* статикам не должно сканировать реестр шрифтов (см. javadoc класса).
|
||||
*/
|
||||
class BundledFontAliasesTest {
|
||||
|
||||
/** Выполнить body в состоянии «шрифты бандла не зарегистрированы», затем восстановить. */
|
||||
private static void withoutBundledInit(Runnable body) throws Exception {
|
||||
Field initedField = BundledFonts.class.getDeclaredField("inited");
|
||||
initedField.setAccessible(true);
|
||||
// VARIANTS package-private (тот же пакет) — снимок/очистка напрямую,
|
||||
// типизированно, без reflection-каста.
|
||||
Map<String, Map<String, PhysicalFont>> savedVariants = new HashMap<>(BundledFonts.VARIANTS);
|
||||
boolean savedInited = initedField.getBoolean(null);
|
||||
BundledFonts.VARIANTS.clear();
|
||||
initedField.setBoolean(null, false);
|
||||
try {
|
||||
body.run();
|
||||
} finally {
|
||||
BundledFonts.VARIANTS.clear();
|
||||
BundledFonts.VARIANTS.putAll(savedVariants);
|
||||
initedField.setBoolean(null, savedInited);
|
||||
}
|
||||
}
|
||||
|
||||
/** Алиас + зарегистрированное семейство -> бандл-семейство (имя в любом регистре). */
|
||||
@Test
|
||||
void bundledFamilyKnownAliasMapsToBundle() {
|
||||
BundledFonts.init();
|
||||
assertEquals("carlito", BundledFontAliases.bundledFamily("Calibri"));
|
||||
assertEquals("tinos", BundledFontAliases.bundledFamily("Times New Roman"));
|
||||
assertEquals("dejavu sans", BundledFontAliases.bundledFamily("DejaVu Sans"));
|
||||
}
|
||||
|
||||
/** Имени нет в таблице алиасов -> финальный fallback. */
|
||||
@Test
|
||||
void bundledFamilyUnknownFallsBack() {
|
||||
BundledFonts.init();
|
||||
assertEquals("dejavu sans", BundledFontAliases.bundledFamily("Zzz Not A Font"));
|
||||
}
|
||||
|
||||
/** Алиас есть, но бандл не зарегистрирован (init() не вызван) -> fallback. */
|
||||
@Test
|
||||
void bundledFamilyWithoutInitFallsBack() throws Exception {
|
||||
withoutBundledInit(() ->
|
||||
assertEquals("dejavu sans", BundledFontAliases.bundledFamily("Calibri")));
|
||||
}
|
||||
|
||||
/** Имя бандл-семейства для w:rFonts: отображаемое имя или само семейство. */
|
||||
@Test
|
||||
void documentFontNameMapsDisplayNames() {
|
||||
assertEquals("DejaVu Sans", BundledFontAliases.documentFontName("dejavu sans"));
|
||||
assertEquals("carlito", BundledFontAliases.documentFontName("carlito"),
|
||||
"семейство без отображаемого имени возвращается как есть");
|
||||
}
|
||||
}
|
||||
@@ -1,5 +1,6 @@
|
||||
package ru.pjandro.wordpdf.fonts;
|
||||
|
||||
import org.docx4j.Docx4jProperties;
|
||||
import org.docx4j.fonts.PhysicalFont;
|
||||
import org.docx4j.wml.Fonts;
|
||||
import org.junit.jupiter.api.Test;
|
||||
@@ -20,6 +21,22 @@ import static org.junit.jupiter.api.Assertions.*;
|
||||
*/
|
||||
class BundledFontMapperTest {
|
||||
|
||||
/**
|
||||
* Гейт сканов docx4j: тот же, что {@code WordPdfConverter.<clinit>}
|
||||
* (строки 85–86). Тест грузит {@code BundledFontMapper} напрямую, а
|
||||
* инициализация класса-подкласса по JLS тянет {@code <clinit>}
|
||||
* {@code BestMatchingMapper} — без арминга скан прошёл бы ungated.
|
||||
* Package-private: PMD UnusedPrivateField не видит побочных эффектов
|
||||
* инициализации, обращение к полю не нужно ни одному тесту.
|
||||
*/
|
||||
static final boolean ARMED = arm();
|
||||
|
||||
private static boolean arm() {
|
||||
Docx4jProperties.setProperty("docx4j.fonts.discoverPhysicalFonts.enabled", "false");
|
||||
Docx4jProperties.setProperty("docx4j.fonts.discoverJarFonts.enabled", "false");
|
||||
return true;
|
||||
}
|
||||
|
||||
/** Тело теста, кидающее checked-исключение (populateFontMappings throws Exception). */
|
||||
private interface TestBody {
|
||||
void run() throws Exception;
|
||||
@@ -44,29 +61,6 @@ class BundledFontMapperTest {
|
||||
}
|
||||
}
|
||||
|
||||
/** Алиас + зарегистрированное семейство -> бандл-семейство (имя в любом регистре). */
|
||||
@Test
|
||||
void bundledFamilyKnownAliasMapsToBundle() {
|
||||
BundledFonts.init();
|
||||
assertEquals("carlito", BundledFontMapper.bundledFamily("Calibri"));
|
||||
assertEquals("tinos", BundledFontMapper.bundledFamily("Times New Roman"));
|
||||
assertEquals("dejavu sans", BundledFontMapper.bundledFamily("DejaVu Sans"));
|
||||
}
|
||||
|
||||
/** Имени нет в таблице алиасов -> финальный fallback. */
|
||||
@Test
|
||||
void bundledFamilyUnknownFallsBack() {
|
||||
BundledFonts.init();
|
||||
assertEquals("dejavu sans", BundledFontMapper.bundledFamily("Zzz Not A Font"));
|
||||
}
|
||||
|
||||
/** Алиас есть, но бандл не зарегистрирован (init() не вызван) -> fallback. */
|
||||
@Test
|
||||
void bundledFamilyWithoutInitFallsBack() throws Exception {
|
||||
withoutBundledInit(() ->
|
||||
assertEquals("dejavu sans", BundledFontMapper.bundledFamily("Calibri")));
|
||||
}
|
||||
|
||||
/**
|
||||
* Имя документа == SYMBOL_FONT маппится сразу (до родительского поиска),
|
||||
* алиасы — на бандл, нераспознанное — в fallback DejaVu Sans.
|
||||
@@ -105,12 +99,4 @@ class BundledFontMapperTest {
|
||||
"без init() алиасованный шрифт не должен попасть и в fallback");
|
||||
});
|
||||
}
|
||||
|
||||
/** Имя бандл-семейства для w:rFonts: отображаемое имя или само семейство. */
|
||||
@Test
|
||||
void documentFontNameMapsDisplayNames() {
|
||||
assertEquals("DejaVu Sans", BundledFontMapper.documentFontName("dejavu sans"));
|
||||
assertEquals("carlito", BundledFontMapper.documentFontName("carlito"),
|
||||
"семейство без отображаемого имени возвращается как есть");
|
||||
}
|
||||
}
|
||||
|
||||
+140
-28
@@ -4,56 +4,168 @@ import org.junit.jupiter.api.Test;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertFalse;
|
||||
import static org.junit.jupiter.api.Assertions.assertNotNull;
|
||||
import static org.junit.jupiter.api.Assertions.assertNull;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
/** Юниты правила 11: OMML → текст без fontconfig (MathFallbackNormalizer). */
|
||||
/**
|
||||
* Юниты правила 6: unsupported-формулы OMML → текст (MathFallbackNormalizer).
|
||||
* Скан namespace-aware: чужие префиксы не триггерят, unsupported-имя в
|
||||
* math-namespace — срезает весь блок в конкатенацию {@code m:t}.
|
||||
*/
|
||||
class MathFallbackNormalizerTest {
|
||||
|
||||
private static final String M_NS =
|
||||
"http://schemas.openxmlformats.org/officeDocument/2006/math";
|
||||
private static final String W_NS =
|
||||
"http://schemas.openxmlformats.org/wordprocessingml/2006/main";
|
||||
private static final String ROOT = "<w:document xmlns:w=\"" + W_NS
|
||||
+ "\" xmlns:m=\"" + M_NS + "\"><w:body>";
|
||||
|
||||
/** Unsupported-имя в math-namespace — блок целиком становится раном. */
|
||||
@Test
|
||||
void flatten_inlineMath_becomesRunWithText() {
|
||||
String xml = "<w:p><w:r><w:t>ДО</w:t></w:r><m:oMath xmlns:m=\"" + M_NS + "\">"
|
||||
+ "<m:r><m:t>x</m:t></m:r><m:sSup><m:e><m:r><m:t>y</m:t></m:r></m:e>"
|
||||
+ "<m:sup><m:r><m:t>2</m:t></m:r></m:sup></m:sSup></m:oMath>"
|
||||
+ "<w:r><w:t>ПОСЛЕ</w:t></w:r></w:p>";
|
||||
assertEquals("<w:p><w:r><w:t>ДО</w:t></w:r>"
|
||||
+ "<w:r><w:t xml:space=\"preserve\">xy2</w:t></w:r>"
|
||||
+ "<w:r><w:t>ПОСЛЕ</w:t></w:r></w:p>",
|
||||
MathFallbackNormalizer.flatten(xml));
|
||||
void unsupportedMathTag_flattensToText() {
|
||||
String xml = ROOT + "<w:p><m:oMath><m:fooBar/>"
|
||||
+ "<m:r><m:t>a/b</m:t></m:r></m:oMath></w:p></w:body></w:document>";
|
||||
String out = MathFallbackNormalizer.rewrite(xml);
|
||||
assertEquals(ROOT + "<w:p><w:r><w:t xml:space=\"preserve\">a/b</w:t></w:r>"
|
||||
+ "</w:p></w:body></w:document>", out);
|
||||
}
|
||||
|
||||
/**
|
||||
* Боевой XML начинается с {@code <?xml ...?>}: карта root-ных xmlns
|
||||
* обязана браться с фактического корневого элемента, а {@code w:rPr}/
|
||||
* {@code w:rFonts} внутри math-рана — чужой namespace, не unsupported.
|
||||
* Иначе пустая карта консервативно срезала бы каждую Word-формулу.
|
||||
*/
|
||||
@Test
|
||||
void flatten_mathPara_removedBeforeInline() {
|
||||
String xml = "<w:p><m:oMathPara xmlns:m=\"" + M_NS + "\"><m:oMath>"
|
||||
+ "<m:f><m:num><m:r><m:t>a</m:t></m:r></m:num>"
|
||||
+ "<m:den><m:r><m:t>b</m:t></m:r></m:den></m:f>"
|
||||
+ "</m:oMath></m:oMathPara></w:p>";
|
||||
String out = MathFallbackNormalizer.flatten(xml);
|
||||
assertEquals("<w:p><w:r><w:t xml:space=\"preserve\">ab</w:t></w:r></w:p>", out);
|
||||
assertFalse(out.contains("m:oMath"), out);
|
||||
void xmlPrologueAndWmlRPrInMath_unchanged() {
|
||||
String xml = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>"
|
||||
+ "<w:document xmlns:w=\"" + W_NS + "\" xmlns:m=\"" + M_NS + "\">"
|
||||
+ "<w:body><w:p><m:oMath><m:r><w:rPr><w:rFonts w:ascii=\"Cambria\"/>"
|
||||
+ "<w:sz w:val=\"22\"/></w:rPr><m:t>a</m:t></m:r></m:oMath></w:p>"
|
||||
+ "</w:body></w:document>";
|
||||
assertNull(MathFallbackNormalizer.rewrite(xml));
|
||||
}
|
||||
|
||||
/** Поддерживаемая конструкция (дробь) — массив не меняется (null). */
|
||||
@Test
|
||||
void flatten_selfClosingMath_removed() {
|
||||
assertEquals("ДОПОСЛЕ",
|
||||
MathFallbackNormalizer.flatten("ДО<m:oMath/>ПОСЛЕ"));
|
||||
void supportedMath_unchanged() {
|
||||
String xml = ROOT + "<w:p><m:oMath><m:f><m:num><m:r><m:t>a</m:t></m:r></m:num>"
|
||||
+ "<m:den><m:r><m:t>b</m:t></m:r></m:den></m:f></m:oMath></w:p>"
|
||||
+ "</w:body></w:document>";
|
||||
assertNull(MathFallbackNormalizer.rewrite(xml));
|
||||
}
|
||||
|
||||
/** Неизвестный тег ЧУЖОГО namespace внутри формулы — не unsupported. */
|
||||
@Test
|
||||
void flatten_emptyMath_removed() {
|
||||
assertEquals("ДОПОСЛЕ",
|
||||
MathFallbackNormalizer.flatten("ДО<m:oMath></m:oMath>ПОСЛЕ"));
|
||||
void foreignNamespaceIgnored() {
|
||||
String xml = ROOT + "<w:p><m:oMath><w:someWmlForeign/><m:r><m:t>x</m:t></m:r>"
|
||||
+ "</m:oMath></w:p></w:body></w:document>";
|
||||
assertNull(MathFallbackNormalizer.rewrite(xml));
|
||||
}
|
||||
|
||||
/** {@code m:oMathPara} с unsupported внутри — срезается весь блок, каркас сбалансирован. */
|
||||
@Test
|
||||
void flatten_noMath_returnsNull() {
|
||||
assertNull(MathFallbackNormalizer.flatten("<w:r><w:t>ТЕКСТ</w:t></w:r>"));
|
||||
void mathParaBlockReplacedWhole() {
|
||||
String xml = ROOT + "<m:oMathPara><m:oMath><m:nope/><m:r><m:t>X</m:t></m:r>"
|
||||
+ "</m:oMath></m:oMathPara>";
|
||||
String out = MathFallbackNormalizer.rewrite(xml);
|
||||
assertEquals(ROOT + "<w:r><w:t xml:space=\"preserve\">X</w:t></w:r>", out);
|
||||
assertFalse(out.contains("oMath"), "каркас формулы остался: " + out);
|
||||
}
|
||||
|
||||
/** Самозакрывающийся пустой блок формул — supported, без изменений. */
|
||||
@Test
|
||||
void rewrite_noMath_returnsNullWithoutProbe() {
|
||||
assertNull(MathFallbackNormalizer.rewrite("<w:r><w:t>ТЕКСТ</w:t></w:r>"));
|
||||
void selfClosingEmpty_unchanged() {
|
||||
String xml = ROOT + "<m:oMathPara/><w:p><m:oMath/></w:p></w:body></w:document>";
|
||||
assertNull(MathFallbackNormalizer.rewrite(xml));
|
||||
}
|
||||
|
||||
/** Inline-формула перед unsupported-пара — блок inline не «склеивается» с парой. */
|
||||
@Test
|
||||
void inlineAndParaBlocksIndependent() {
|
||||
String xml = ROOT + "<w:p><m:oMath><m:r><m:t>OK</m:t></m:r></m:oMath></w:p>"
|
||||
+ "<m:oMathPara><m:oMath><m:bad/></m:oMath></m:oMathPara>";
|
||||
String out = MathFallbackNormalizer.rewrite(xml);
|
||||
assertTrue(out.contains("<m:oMath><m:r><m:t>OK</m:t></m:r></m:oMath>"),
|
||||
"supported inline-формула не должна была меняться: " + out);
|
||||
assertFalse(out.contains("m:bad"), out);
|
||||
assertFalse(out.contains("oMathPara"), out);
|
||||
}
|
||||
|
||||
/** Без объявленных xmlns вообще — консервативно: unknown имя режет блок. */
|
||||
@Test
|
||||
void noNamespaceMap_conservativeFlatten() {
|
||||
String xml = "ДО<m:oMath><m:weird/></m:oMath>ПОСЛЕ";
|
||||
String out = MathFallbackNormalizer.rewrite(xml);
|
||||
assertEquals("ДОПОСЛЕ", out, "пустая формула удаляется без следа");
|
||||
}
|
||||
|
||||
/** Формул нет / формула без префикса math — {@code null} (тот же массив). */
|
||||
@Test
|
||||
void noMathBlocks_null() {
|
||||
assertNull(MathFallbackNormalizer.rewrite(
|
||||
"<w:r xmlns:w=\"" + W_NS + "\"><w:t>ТЕКСТ</w:t></w:r>"));
|
||||
assertNull(MathFallbackNormalizer.rewrite("<doc><oMath/>мусор</doc>"));
|
||||
}
|
||||
|
||||
/** Переопределение {@code xmlns:m} на чужой URI внутри блока — не формула. */
|
||||
@Test
|
||||
void blockLocalNamespaceOverride_skipped() {
|
||||
String xml = ROOT + "<w:p><q:oMath xmlns:q=\"urn:custom\">"
|
||||
+ "<q:whatever/><q:t>x</q:t></q:oMath></w:p></w:body></w:document>";
|
||||
assertNull(MathFallbackNormalizer.rewrite(xml));
|
||||
}
|
||||
|
||||
/**
|
||||
* Битый каркас (незакрытый тег, нет закрывающего {@code </m:oMath...>})
|
||||
* — скан останавливается без изменений: чинять XML — дело валидатора.
|
||||
*/
|
||||
@Test
|
||||
void brokenFrames_stopScan() {
|
||||
assertNull(MathFallbackNormalizer.rewrite(ROOT + "<w:p><m:oMath"));
|
||||
assertNull(MathFallbackNormalizer.rewrite(
|
||||
ROOT + "<w:p><m:oMath><m:fooBar/></w:p></w:body></w:document>"));
|
||||
assertNull(MathFallbackNormalizer.rewrite(
|
||||
ROOT + "<m:oMathPara><m:oMath><m:bad/>"));
|
||||
}
|
||||
|
||||
/** tagEnd кавычки-осведомлён: {@code >}/кавычки внутри значения атрибута тег не заканчивают. */
|
||||
@Test
|
||||
void quoteAwareTagEnd_flattens() {
|
||||
String out = MathFallbackNormalizer.rewrite(ROOT
|
||||
+ "<w:p><m:oMath><m:bad m:val=\"a>'b\"/>"
|
||||
+ "<m:r><m:t>Q</m:t></m:r></m:oMath></w:p></w:body></w:document>");
|
||||
assertNotNull(out, "символ > в кавычках ошибочно закончил тег");
|
||||
assertTrue(out.contains(">Q<") && !out.contains("m:bad"), out);
|
||||
}
|
||||
|
||||
/**
|
||||
* Незакрытые пролог-объявления (PI/комментарий/DOCTYPE) — карта xmlns
|
||||
* пустая, консервативный срез (как в {@link #noNamespaceMap_conservativeFlatten});
|
||||
* закрытые варианты — обычный путь.
|
||||
*/
|
||||
@Test
|
||||
void unterminatedPrologues_conservativeFlatten() {
|
||||
assertTrue(MathFallbackNormalizer.rewrite(
|
||||
"<?xml<m:oMath><m:bad/><m:r><m:t>Т</m:t></m:r></m:oMath>")
|
||||
.contains(">Т<"), "блок не срезан");
|
||||
assertTrue(MathFallbackNormalizer.rewrite(
|
||||
"<!-- p<m:oMath><m:bad/><m:r><m:t>ТК</m:t></m:r></m:oMath>")
|
||||
.contains(">ТК<"), "блок не срезан");
|
||||
assertTrue(MathFallbackNormalizer.rewrite(
|
||||
"<!D<m:oMath><m:bad/><m:r><m:t>ТЕ</m:t></m:r></m:oMath>")
|
||||
.contains(">ТЕ<"), "блок не срезан");
|
||||
assertTrue(MathFallbackNormalizer.rewrite(
|
||||
"<!-- c --><!D d><m:oMath><m:bad/><m:r><m:t>Ы</m:t></m:r></m:oMath>")
|
||||
.contains(">Ы<"), "блок не срезан");
|
||||
}
|
||||
|
||||
/** Пробелы перед {@code />} самозакрывающегося блока — габарит-петля не сбивает self-closing. */
|
||||
@Test
|
||||
void whitespaceBeforeSelfClosing_unchanged() {
|
||||
assertNull(MathFallbackNormalizer.rewrite(
|
||||
ROOT + "<w:p><m:oMath /></w:p></w:body></w:document>"));
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,540 @@
|
||||
package ru.pjandro.wordpdf.internal.chart;
|
||||
|
||||
import jakarta.xml.bind.JAXBElement;
|
||||
import org.docx4j.math.CTOMath;
|
||||
import org.docx4j.openpackaging.packages.WordprocessingMLPackage;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import ru.pjandro.wordpdf.fonts.BundledFonts;
|
||||
import ru.pjandro.wordpdf.fonts.GlyphFont;
|
||||
|
||||
import javax.xml.namespace.QName;
|
||||
import java.awt.Color;
|
||||
import java.io.ByteArrayInputStream;
|
||||
import java.io.ByteArrayOutputStream;
|
||||
import java.io.IOException;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.util.List;
|
||||
import java.util.zip.ZipEntry;
|
||||
import java.util.zip.ZipOutputStream;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertNotNull;
|
||||
import static org.junit.jupiter.api.Assertions.assertNull;
|
||||
import static org.junit.jupiter.api.Assertions.assertThrows;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
/**
|
||||
* Разбор OMML в боксы и растеризация (MathModel/MathRenderer) на
|
||||
* синтетическом docx (ZipOutputStream из литеральных XML — идеома модуля)
|
||||
* и синтетических JAXB-элементах.
|
||||
*/
|
||||
class MathModelTest {
|
||||
|
||||
private static final String M_NS =
|
||||
"http://schemas.openxmlformats.org/officeDocument/2006/math";
|
||||
private static final String W_NS =
|
||||
"http://schemas.openxmlformats.org/wordprocessingml/2006/main";
|
||||
|
||||
/** Дробь a/b внутри inline-формулы. */
|
||||
private static final String FRAC = "<m:f><m:num><m:r><m:t>a</m:t></m:r></m:num>"
|
||||
+ "<m:den><m:r><m:t>b</m:t></m:r></m:den></m:f>";
|
||||
|
||||
// ------------------------------------------------------------------
|
||||
// Метрики и растер дроби
|
||||
// ------------------------------------------------------------------
|
||||
|
||||
/** Дробь: ненулевые метрики; растер — с чернилами и минимумом габарита. */
|
||||
@Test
|
||||
void fraction_measuresAndRenders() throws IOException {
|
||||
CTOMath math = firstMath(mathDocx("<w:p><m:oMath xmlns:m=\"" + M_NS + "\">"
|
||||
+ FRAC + "</m:oMath></w:p>"));
|
||||
MathModel.Box box = MathModel.build(math, false);
|
||||
assertTrue(box.width > 0, "нулевая ширина дроби");
|
||||
assertTrue(box.ascent > 0, "нулевой подъём дроби");
|
||||
assertTrue(box.descent > 0, "нулевой спуск дроби");
|
||||
|
||||
MathRenderer.MathImage img = MathRenderer.render(box);
|
||||
assertNotNull(img.image(), "пустой растр при неразрешённой дроби");
|
||||
assertTrue(img.widthPt() >= MathRenderer.MIN_WIDTH_PT, "ширина ниже минимума");
|
||||
assertTrue(img.heightPt() >= MathRenderer.MIN_HEIGHT_PT, "высота ниже минимума");
|
||||
assertTrue(hasInk(img.image()), "растр дроби без единого непрозрачного пикселя");
|
||||
}
|
||||
|
||||
/** Конкатенация {@code m:t} (контракт деградации): num+den без разделителя. */
|
||||
@Test
|
||||
void mathText_collectsNestedRuns() throws IOException {
|
||||
CTOMath math = firstMath(mathDocx("<w:p><m:oMath xmlns:m=\"" + M_NS + "\">"
|
||||
+ FRAC + "</m:oMath></w:p>"));
|
||||
assertEquals("ab", MathModel.mathText(math));
|
||||
}
|
||||
|
||||
/** Пустая формула: {@code image == null}, габариты нулевые (вызывающий удалит блок). */
|
||||
@Test
|
||||
void emptyMath_rendersNullImage() throws IOException {
|
||||
CTOMath math = firstMath(mathDocx("<w:p><m:oMath xmlns:m=\"" + M_NS + "\">"
|
||||
+ "</m:oMath></w:p>"));
|
||||
MathRenderer.MathImage img = MathRenderer.render(MathModel.build(math, false));
|
||||
assertNull(img.image(), "пустая формула не обязана рисоваться");
|
||||
assertEquals(0, img.widthPt(), 0.0001);
|
||||
assertEquals(0, img.heightPt(), 0.0001);
|
||||
}
|
||||
|
||||
/** Надстрочный индекс добавляет ширину и не режет верх базы (подъём ≥ базы). */
|
||||
@Test
|
||||
void superscript_addsScriptWidth() throws IOException {
|
||||
CTOMath math = firstMath(mathDocx("<w:p><m:oMath xmlns:m=\"" + M_NS + "\">"
|
||||
+ "<m:sSup><m:e><m:r><m:t>x</m:t></m:r></m:e>"
|
||||
+ "<m:sup><m:r><m:t>2</m:t></m:r></m:sup></m:sSup></m:oMath></w:p>"));
|
||||
MathModel.Box sup = MathModel.build(math, false);
|
||||
GlyphFont plain = GlyphFont.of(BundledFonts.FALLBACK_FAMILY, BundledFonts.V_REGULAR);
|
||||
MathModel.Box run = new MathModel.RunBox("x", plain,
|
||||
MathModel.DEFAULT_SIZE_PT, Color.BLACK);
|
||||
assertTrue(sup.width > run.width,
|
||||
"индекс не добавил ширины: " + sup.width + " <= " + run.width);
|
||||
assertTrue(sup.ascent >= run.ascent,
|
||||
"индекс срезал верх базы: " + sup.ascent + " < " + run.ascent);
|
||||
}
|
||||
|
||||
/**
|
||||
* Канва растра обязана вмещать пределы (undOvr-пределы nary и стопку
|
||||
* sPre) целиком: метрики бокса равны габариту paint, поэтому чернила
|
||||
* не касаются верхней/нижней границы канвы (PAD-отступ снаружи).
|
||||
* До пересчёта метрик ascent/descent NaryBox/PreScriptBox не учитывали
|
||||
* полную высоту пределов — чернила резались по краю канвы (тот же
|
||||
* зелёный «есть чернила», но подрезанный растер). Регрессия — 2026-11.
|
||||
*/
|
||||
@Test
|
||||
void limits_notClippedByCanvas() throws IOException {
|
||||
String nary = "<m:nary><m:naryPr><m:chr m:val=\"∑\"/>"
|
||||
+ "<m:limLoc m:val=\"undOvr\"/></m:naryPr>"
|
||||
+ "<m:sub><m:r><m:t>abc</m:t></m:r></m:sub>"
|
||||
+ "<m:sup><m:r><m:t>def</m:t></m:r></m:sup>"
|
||||
+ "<m:e><m:r><m:t>x</m:t></m:r></m:e></m:nary>";
|
||||
String pre = "<m:sPre><m:e><m:r><m:t>B</m:t></m:r></m:e>"
|
||||
+ "<m:sub><m:r><m:t>i+j</m:t></m:r></m:sub>"
|
||||
+ "<m:sup><m:r><m:t>m-n</m:t></m:r></m:sup></m:sPre>";
|
||||
for (String xmlBody : new String[] {nary, pre}) {
|
||||
CTOMath math = firstMath(mathDocx("<w:p><m:oMath xmlns:m=\"" + M_NS + "\">"
|
||||
+ xmlBody + "</m:oMath></w:p>"));
|
||||
MathRenderer.MathImage img = MathRenderer.render(MathModel.build(math, false));
|
||||
assertNotNull(img.image(), "пустой растр");
|
||||
java.awt.image.BufferedImage raster = img.image();
|
||||
int h = raster.getHeight();
|
||||
assertTrue(!rowInk(raster, 0) && !rowInk(raster, 1)
|
||||
&& !rowInk(raster, h - 1) && !rowInk(raster, h - 2),
|
||||
"чернила пределов обрезаны краем канвы (h=" + h + ")");
|
||||
}
|
||||
}
|
||||
|
||||
/** Есть ли непрозрачный пиксель в строке растра. */
|
||||
private static boolean rowInk(java.awt.image.BufferedImage img, int y) {
|
||||
for (int x = 0; x < img.getWidth(); x++) {
|
||||
if ((img.getRGB(x, y) >>> 24) != 0) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Свойства конструкций (§22.1.2): нестандартные значения идут теми же
|
||||
* ветками диспетчера, что и документ-образец — bot-позиции bar/groupChr,
|
||||
* произвольные m:chr, пустой m:chr, show=on у phantom, явный тип дроби,
|
||||
* begChr/endChr/sepChr разделителя (в т.ч. разделитель между аргументами),
|
||||
* degHide радикала, chr/limLoc=subSup у nary, rPr ранa (m:sty, w:sz,
|
||||
* w:color валидный/битый, w:rFonts, m:t без значения), limLow с пустым
|
||||
* lim, малый разделитель без масштабирования скобок.
|
||||
*/
|
||||
@Test
|
||||
void propertyVariants_render() throws IOException {
|
||||
assertRendered("<m:bar><m:barPr><m:pos m:val=\"bot\"/></m:barPr>"
|
||||
+ "<m:e><m:r><m:t>x</m:t></m:r></m:e></m:bar>");
|
||||
assertRendered("<m:acc><m:accPr><m:chr m:val=\"~\"/></m:accPr>"
|
||||
+ "<m:e><m:r><m:t>y</m:t></m:r></m:e></m:acc>");
|
||||
assertRendered("<m:groupChr><m:groupChrPr><m:chr m:val=\"⏝\"/>"
|
||||
+ "<m:pos m:val=\"bot\"/></m:groupChrPr>"
|
||||
+ "<m:e><m:r><m:t>abc</m:t></m:r></m:e></m:groupChr>");
|
||||
assertRendered("<m:groupChr><m:groupChrPr><m:chr m:val=\"\"/></m:groupChrPr>"
|
||||
+ "<m:e><m:r><m:t>de</m:t></m:r></m:e></m:groupChr>");
|
||||
assertRendered("<m:groupChr><m:groupChrPr><m:chr m:val=\"\"/></m:groupChrPr>"
|
||||
+ "<m:e><m:r><m:t>fg</m:t></m:r></m:e></m:groupChr>");
|
||||
assertRendered("<m:phant><m:phantPr><m:show m:val=\"on\"/></m:phantPr>"
|
||||
+ "<m:e><m:r><m:t>z</m:t></m:r></m:e></m:phant>");
|
||||
assertRendered("<m:f><m:fPr><m:type m:val=\"bar\"/></m:fPr>"
|
||||
+ "<m:num><m:r><m:t>a</m:t></m:r></m:num>"
|
||||
+ "<m:den><m:r><m:t>b</m:t></m:r></m:den></m:f>");
|
||||
assertRendered("<m:d><m:dPr><m:begChr m:val=\"[\"/><m:endChr m:val=\"]\"/>"
|
||||
+ "<m:sepChr m:val=\";\"/></m:dPr>"
|
||||
+ "<m:e><m:r><m:t>a</m:t></m:r></m:e>"
|
||||
+ "<m:e><m:r><m:t>b</m:t></m:r></m:e></m:d>");
|
||||
assertRendered("<m:d><m:e><m:r><m:t>q</m:t></m:r></m:e></m:d>");
|
||||
assertRendered("<m:d><m:e><m:f><m:num><m:r><m:t>a</m:t></m:r></m:num>"
|
||||
+ "<m:den><m:r><m:t>b</m:t></m:r></m:den></m:f></m:e></m:d>");
|
||||
assertRendered("<m:rad><m:radPr><m:degHide m:val=\"on\"/></m:radPr><m:deg/>"
|
||||
+ "<m:e><m:r><m:t>x</m:t></m:r></m:e></m:rad>");
|
||||
assertRendered("<m:nary><m:naryPr><m:chr m:val=\"∮\"/>"
|
||||
+ "<m:limLoc m:val=\"subSup\"/></m:naryPr>"
|
||||
+ "<m:sub><m:r><m:t>0</m:t></m:r></m:sub>"
|
||||
+ "<m:sup><m:r><m:t>1</m:t></m:r></m:sup>"
|
||||
+ "<m:e><m:r><m:t>f</m:t></m:r></m:e></m:nary>");
|
||||
assertRendered("<m:limLow><m:lim/><m:e><m:r><m:t>u</m:t></m:r></m:e></m:limLow>");
|
||||
assertRendered("<m:limLow><m:lim><m:r><m:t>n→∞</m:t></m:r></m:lim>"
|
||||
+ "<m:e><m:r><m:t>a</m:t></m:r></m:e></m:limLow>");
|
||||
assertRendered("<m:r><m:rPr><m:sty m:val=\"p\"/></m:rPr>"
|
||||
+ "<w:rPr><w:sz w:val=\"20\"/><w:color w:val=\"#FF0000\"/>"
|
||||
+ "<w:rFonts w:ascii=\"Arial\"/></w:rPr>"
|
||||
+ "<m:t>Q</m:t></m:r>");
|
||||
assertRendered("<m:r><w:rPr><w:color w:val=\"#GG\"/></w:rPr>"
|
||||
+ "<m:t>R</m:t></m:r>");
|
||||
assertRendered("<m:r><w:rPr><w:color w:val=\"#GGHHII\"/></w:rPr>"
|
||||
+ "<m:t>R2</m:t></m:r>");
|
||||
assertRendered("<m:r><m:t></m:t></m:r><m:r><m:t>S</m:t></m:r>");
|
||||
// val-пустые свойства — дефолтные цепочки (атрибут без m:val/w:val)
|
||||
assertRendered("<m:acc><m:accPr><m:chr/></m:accPr>"
|
||||
+ "<m:e><m:r><m:t>x</m:t></m:r></m:e></m:acc>");
|
||||
assertRendered("<m:groupChr><m:groupChrPr><m:chr/><m:pos/></m:groupChrPr>"
|
||||
+ "<m:e><m:r><m:t>yz</m:t></m:r></m:e></m:groupChr>");
|
||||
assertRendered("<m:bar><m:barPr><m:pos/></m:barPr>"
|
||||
+ "<m:e><m:r><m:t>u</m:t></m:r></m:e></m:bar>");
|
||||
assertRendered("<m:nary><m:naryPr><m:chr/><m:limLoc/></m:naryPr>"
|
||||
+ "<m:sub><m:r><m:t>0</m:t></m:r></m:sub><m:sup/>"
|
||||
+ "<m:e><m:r><m:t>g</m:t></m:r></m:e></m:nary>");
|
||||
assertRendered("<m:d><m:dPr><m:begChr/><m:endChr/><m:sepChr/></m:dPr>"
|
||||
+ "<m:e><m:r><m:t>a</m:t></m:r></m:e>"
|
||||
+ "<m:e><m:r><m:t>b</m:t></m:r></m:e></m:d>");
|
||||
assertRendered("<m:f><m:fPr><m:type/></m:fPr>"
|
||||
+ "<m:num><m:r><m:t>a</m:t></m:r></m:num>"
|
||||
+ "<m:den><m:r><m:t>b</m:t></m:r></m:den></m:f>");
|
||||
assertRendered("<m:r><w:rPr><w:sz/><w:color/></w:rPr>"
|
||||
+ "<m:t>Z</m:t></m:r>");
|
||||
assertRendered("<m:r><w:rPr><w:rFonts w:ascii=\"\"/></w:rPr>"
|
||||
+ "<m:t>W</m:t></m:r>");
|
||||
assertRendered("<m:rad><m:deg/><m:e><m:r><m:t>x</m:t></m:r></m:e></m:rad>");
|
||||
}
|
||||
|
||||
/** {@code w:br} внутри math-рана — unsupported (деградация в текст, не PD-падение). */
|
||||
@Test
|
||||
void brInMathRun_unsupported() throws IOException {
|
||||
CTOMath math = firstMath(mathDocx("<w:p><m:oMath xmlns:m=\"" + M_NS + "\">"
|
||||
+ "<m:r><w:br/><m:t>x</m:t></m:r></m:oMath></w:p>"));
|
||||
assertThrows(MathUnsupportedException.class, () -> MathModel.build(math, false));
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------
|
||||
// Unsupported и безопасная сеть
|
||||
// ------------------------------------------------------------------
|
||||
|
||||
/** Неизвестный math-элемент — {@link MathUnsupportedException} (не падение PDF). */
|
||||
@Test
|
||||
void unsupportedElement_throws() {
|
||||
CTOMath math = new CTOMath();
|
||||
math.getEGOMathElements().add(new JAXBElement<>(
|
||||
new QName(M_NS, "fooBar"), String.class, "any"));
|
||||
MathUnsupportedException e = assertThrows(MathUnsupportedException.class,
|
||||
() -> MathModel.build(math, false));
|
||||
assertTrue(e.getMessage().contains("fooBar"), e.getMessage());
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------
|
||||
// Охват всех поддерживаемых конструкций (метки веток диспетчера)
|
||||
// ------------------------------------------------------------------
|
||||
|
||||
/** Конструкция разобрана и отрисована (с чернилами), ширина ненулевая. */
|
||||
private static void assertRendered(String inlineMath) throws IOException {
|
||||
CTOMath math = firstMath(mathDocx("<w:p><m:oMath xmlns:m=\"" + M_NS + "\">"
|
||||
+ inlineMath + "</m:oMath></w:p>"));
|
||||
MathModel.Box box = MathModel.build(math, false);
|
||||
MathRenderer.MathImage img = MathRenderer.render(box);
|
||||
assertNotNull(img.image(), "нет растера: " + inlineMath);
|
||||
assertTrue(hasInk(img.image()), "растр без чернил: " + inlineMath);
|
||||
}
|
||||
|
||||
/** Скобки: свой набор символов, разнеситель, пустые скобки, рост под контентом. */
|
||||
@Test
|
||||
void delimiters_bracketsSeparatorsGrowth() throws IOException {
|
||||
assertRendered("<m:d><m:dPr><m:begChr m:val=\"[\"/><m:endChr m:val=\"]\"/>"
|
||||
+ "<m:sepChr m:val=\"/\"/></m:dPr>"
|
||||
+ "<m:e><m:r><m:t>a</m:t></m:r></m:e>"
|
||||
+ "<m:e><m:r><m:t>b</m:t></m:r></m:e></m:d>");
|
||||
assertRendered("<m:d><m:dPr><m:begChr m:val=\"\"/><m:endChr m:val=\"\"/></m:dPr>"
|
||||
+ "<m:e><m:r><m:t>x</m:t></m:r></m:e></m:d>");
|
||||
// высокая дробь внутри — глиф скобки растягивается (k > 1)
|
||||
assertRendered("<m:d><m:e>" + FRAC + "</m:e></m:d>");
|
||||
}
|
||||
|
||||
/** Радикал: со степенью, без степени (degHide), под корнем — дробь (растяжение). */
|
||||
@Test
|
||||
void radicals_degreeDegHideTallContent() throws IOException {
|
||||
assertRendered("<m:rad><m:deg><m:r><m:t>3</m:t></m:r></m:deg>"
|
||||
+ "<m:e><m:r><m:t>x</m:t></m:r></m:e></m:rad>");
|
||||
assertRendered("<m:rad><m:radPr><m:degHide m:val=\"on\"/></m:radPr><m:deg/>"
|
||||
+ "<m:e>" + FRAC + "</m:e></m:rad>");
|
||||
}
|
||||
|
||||
/** N-арный оператор: пределы над/под, subSup-форма, subHide/supHide, свой символ. */
|
||||
@Test
|
||||
void nary_limitsFormsHidingChar() throws IOException {
|
||||
assertRendered("<m:nary><m:naryPr><m:chr m:val=\"∫\"/>"
|
||||
+ "<m:limLoc m:val=\"undOvr\"/><m:subHide m:val=\"on\"/></m:naryPr>"
|
||||
+ "<m:sub/><m:sup><m:r><m:t>∞</m:t></m:r></m:sup>"
|
||||
+ "<m:e><m:r><m:t>f</m:t></m:r></m:e></m:nary>");
|
||||
assertRendered("<m:nary><m:naryPr><m:limLoc m:val=\"subSup\"/></m:naryPr>"
|
||||
+ "<m:sub><m:r><m:t>i</m:t></m:r></m:sub>"
|
||||
+ "<m:sup><m:r><m:t>n</m:t></m:r></m:sup>"
|
||||
+ "<m:e><m:r><m:t>a</m:t></m:r></m:e></m:nary>");
|
||||
assertRendered("<m:nary><m:naryPr><m:supHide m:val=\"on\"/></m:naryPr>"
|
||||
+ "<m:sub><m:r><m:t>1</m:t></m:r></m:sub><m:sup/>"
|
||||
+ "<m:e><m:r><m:t>u</m:t></m:r></m:e></m:nary>");
|
||||
}
|
||||
|
||||
/** Функция и пределы limLow/limUpp. */
|
||||
@Test
|
||||
void funcAndLimits_render() throws IOException {
|
||||
assertRendered("<m:func><m:fName><m:r><m:rPr><m:sty m:val=\"p\"/></m:rPr>"
|
||||
+ "<m:t>sin</m:t></m:r></m:fName>"
|
||||
+ "<m:e><m:r><m:t>x</m:t></m:r></m:e></m:func>");
|
||||
assertRendered("<m:limLow><m:e><m:r><m:rPr><m:sty m:val=\"p\"/></m:rPr>"
|
||||
+ "<m:t>lim</m:t></m:r></m:e>"
|
||||
+ "<m:lim><m:r><m:t>x→0</m:t></m:r></m:lim></m:limLow>");
|
||||
assertRendered("<m:limUpp><m:e><m:r><m:rPr><m:sty m:val=\"p\"/></m:rPr>"
|
||||
+ "<m:t>max</m:t></m:r></m:e>"
|
||||
+ "<m:lim><m:r><m:t>S</m:t></m:r></m:lim></m:limUpp>");
|
||||
}
|
||||
|
||||
/** Черта сверху/снизу, акцент (символ по умолчанию и явный). */
|
||||
@Test
|
||||
void barAndAccent_render() throws IOException {
|
||||
assertRendered("<m:bar><m:e><m:r><m:t>x</m:t></m:r></m:e></m:bar>");
|
||||
assertRendered("<m:bar><m:barPr><m:pos m:val=\"bot\"/></m:barPr>"
|
||||
+ "<m:e><m:r><m:t>y</m:t></m:r></m:e></m:bar>");
|
||||
assertRendered("<m:acc><m:e><m:r><m:t>a</m:t></m:r></m:e></m:acc>");
|
||||
assertRendered("<m:acc><m:accPr><m:chr m:val=\"~\"/></m:accPr>"
|
||||
+ "<m:e><m:r><m:t>b</m:t></m:r></m:e></m:acc>");
|
||||
}
|
||||
|
||||
/** Групповая скобка: низ/верх, дефолтный ⏞ и глиф вне бандла (fits=false). */
|
||||
@Test
|
||||
void groupChr_positionsAndGlyphFallback() throws IOException {
|
||||
assertRendered("<m:groupChr><m:groupChrPr><m:chr m:val=\"_\"/>"
|
||||
+ "<m:pos m:val=\"bot\"/></m:groupChrPr>"
|
||||
+ "<m:e><m:r><m:t>abc</m:t></m:r></m:e></m:groupChr>");
|
||||
assertRendered("<m:groupChr><m:groupChrPr><m:chr m:val=\"﹏\"/></m:groupChrPr>"
|
||||
+ "<m:e><m:r><m:t>def</m:t></m:r></m:e></m:groupChr>");
|
||||
assertRendered("<m:groupChr><m:e><m:r><m:t>ghi</m:t></m:r></m:e></m:groupChr>");
|
||||
}
|
||||
|
||||
/** Матрица (сетка), пустая матрица, eqArr. */
|
||||
@Test
|
||||
void matrixAndEqArr_render() throws IOException {
|
||||
CTOMath matrix = firstMath(mathDocx("<w:p><m:oMath xmlns:m=\"" + M_NS + "\">"
|
||||
+ "<m:m><m:mr><m:e><m:r><m:t>1</m:t></m:r></m:e>"
|
||||
+ "<m:e><m:r><m:t>2</m:t></m:r></m:e></m:mr>"
|
||||
+ "<m:mr><m:e><m:r><m:t>3</m:t></m:r></m:e>"
|
||||
+ "<m:e><m:r><m:t>4</m:t></m:r></m:e></m:mr></m:m></m:oMath></w:p>"));
|
||||
MathModel.Box grid = MathModel.build(matrix, false);
|
||||
MathRenderer.MathImage img = MathRenderer.render(grid);
|
||||
assertTrue(grid.width > 0 && hasInk(img.image()), "матрица не отрисована");
|
||||
|
||||
CTOMath emptyMatrix = firstMath(mathDocx("<w:p><m:oMath xmlns:m=\"" + M_NS + "\">"
|
||||
+ "<m:m/></m:oMath></w:p>"));
|
||||
assertEquals(0, MathModel.build(emptyMatrix, false).width, 0.0001,
|
||||
"пустая матрица обязана иметь нулевую ширину");
|
||||
|
||||
assertRendered("<m:eqArr><m:e><m:r><m:t>a</m:t></m:r></m:e>"
|
||||
+ "<m:e><m:r><m:t>b</m:t></m:r></m:e></m:eqArr>");
|
||||
}
|
||||
|
||||
/** m:box: контент боксируется без рамки. */
|
||||
@Test
|
||||
void box_rendersContent() throws IOException {
|
||||
assertRendered("<m:box><m:e><m:r><m:t>bb</m:t></m:r></m:e></m:box>");
|
||||
}
|
||||
|
||||
/** m:phant: невидим, но место занимает; {@code show=on} — обычный контент. */
|
||||
@Test
|
||||
void phantom_invisibleSpacingShowVisible() throws IOException {
|
||||
CTOMath phant = firstMath(mathDocx("<w:p><m:oMath xmlns:m=\"" + M_NS + "\">"
|
||||
+ "<m:r><m:t>x</m:t></m:r>"
|
||||
+ "<m:phant><m:e><m:r><m:t>WWWWWWWWWW</m:t></m:r></m:e></m:phant>"
|
||||
+ "</m:oMath></w:p>"));
|
||||
MathModel.Box with = MathModel.build(phant, false);
|
||||
CTOMath bare = firstMath(mathDocx("<w:p><m:oMath xmlns:m=\"" + M_NS + "\">"
|
||||
+ "<m:r><m:t>x</m:t></m:r></m:oMath></w:p>"));
|
||||
MathModel.Box without = MathModel.build(bare, false);
|
||||
assertTrue(with.width > without.width,
|
||||
"phant не занял место: " + with.width + " <= " + without.width);
|
||||
MathRenderer.MathImage img = MathRenderer.render(with);
|
||||
assertNotNull(img.image(), "phant не обязан падать");
|
||||
CTOMath shown = firstMath(mathDocx("<w:p><m:oMath xmlns:m=\"" + M_NS + "\">"
|
||||
+ "<m:phant><m:phantPr><m:show m:val=\"on\"/></m:phantPr>"
|
||||
+ "<m:e><m:r><m:t>WWWWWWWWWW</m:t></m:r></m:e></m:phant></m:oMath></w:p>"));
|
||||
assertTrue(hasInk(MathRenderer.render(MathModel.build(shown, false)).image()),
|
||||
"show=on обязан рисовать содержимое");
|
||||
}
|
||||
|
||||
/** Типы дроби: bar явный, skw/lin/noBar — через слэш. */
|
||||
@Test
|
||||
void fractionTypes_render() throws IOException {
|
||||
for (String type : List.of("bar", "skw", "lin", "noBar")) {
|
||||
assertRendered("<m:f><m:fPr><m:type m:val=\"" + type + "\"/></m:fPr>"
|
||||
+ "<m:num><m:r><m:t>n</m:t></m:r></m:num>"
|
||||
+ "<m:den><m:r><m:t>d</m:t></m:r></m:den></m:f>");
|
||||
}
|
||||
}
|
||||
|
||||
/** display-режим: дефолт дроби — bar, дефолт nary — пределы над/под. */
|
||||
@Test
|
||||
void displayMode_defaultsBarFractionAndNaryLimits() throws IOException {
|
||||
CTOMath math = firstMath(mathDocx("<w:p><m:oMath xmlns:m=\"" + M_NS + "\">"
|
||||
+ FRAC + "<m:nary><m:sub><m:r><m:t>1</m:t></m:r></m:sub><m:sup/>"
|
||||
+ "<m:e><m:r><m:t>a</m:t></m:r></m:e></m:nary></m:oMath></w:p>"));
|
||||
MathModel.Box box = MathModel.build(math, true);
|
||||
assertTrue(box.width > 0 && box.ascent > 0 && box.descent > 0);
|
||||
assertTrue(hasInk(MathRenderer.render(box).image()), "display-формула без чернил");
|
||||
}
|
||||
|
||||
/** sPre / sSubSup / sSub. */
|
||||
@Test
|
||||
void scriptForms_render() throws IOException {
|
||||
assertRendered("<m:sPre><m:e><m:r><m:t>B</m:t></m:r></m:e>"
|
||||
+ "<m:sub><m:r><m:t>i</m:t></m:r></m:sub>"
|
||||
+ "<m:sup><m:r><m:t>n</m:t></m:r></m:sup></m:sPre>");
|
||||
assertRendered("<m:sSubSup><m:e><m:r><m:t>x</m:t></m:r></m:e>"
|
||||
+ "<m:sub><m:r><m:t>i</m:t></m:r></m:sub>"
|
||||
+ "<m:sup><m:r><m:t>2</m:t></m:r></m:sup></m:sSubSup>");
|
||||
assertRendered("<m:sSub><m:e><m:r><m:t>y</m:t></m:r></m:e>"
|
||||
+ "<m:sub><m:r><m:t>j</m:t></m:r></m:sub></m:sSub>");
|
||||
}
|
||||
|
||||
/** Начертания и оформление рана: sty=b/i/bi, цвет, кегль, переменная-кириллица. */
|
||||
@Test
|
||||
void runStyles_render() throws IOException {
|
||||
assertRendered("<m:r><m:rPr><m:sty m:val=\"b\"/></m:rPr>"
|
||||
+ "<m:t>B</m:t></m:r>");
|
||||
assertRendered("<m:r><m:rPr><m:sty m:val=\"i\"/></m:rPr>"
|
||||
+ "<m:t>i</m:t></m:r>");
|
||||
assertRendered("<m:r><m:rPr><m:sty m:val=\"bi\"/></m:rPr>"
|
||||
+ "<w:rPr xmlns:w=\"" + W_NS + "\"><w:sz w:val=\"32\"/>"
|
||||
+ "<w:color w:val=\"FF0000\"/></w:rPr>"
|
||||
+ "<m:t>Q</m:t></m:r>");
|
||||
assertRendered("<m:r><m:t>абв</m:t></m:r>");
|
||||
}
|
||||
|
||||
/** Перенос внутри math-рана — unsupported (текстовая деградация на интеграции). */
|
||||
@Test
|
||||
void runWithBreak_unsupported() throws IOException {
|
||||
CTOMath math = firstMath(mathDocx("<w:p><m:oMath xmlns:m=\"" + M_NS + "\">"
|
||||
+ "<m:r><m:t>a</m:t><w:br xmlns:w=\"" + W_NS + "\"/><m:t>b</m:t></m:r>"
|
||||
+ "</m:oMath></w:p>"));
|
||||
assertThrows(MathUnsupportedException.class, () -> MathModel.build(math, false));
|
||||
}
|
||||
|
||||
/** Контент-узел не JAXBElement — unsupported (защита диспетчера). */
|
||||
@Test
|
||||
void rawObjectContent_unsupported() {
|
||||
CTOMath math = new CTOMath();
|
||||
math.getEGOMathElements().add("не узел");
|
||||
assertThrows(MathUnsupportedException.class, () -> MathModel.build(math, false));
|
||||
}
|
||||
|
||||
/**
|
||||
* Текст извлекается из произвольного каркаса (в т.ч. неизвестных узлов):
|
||||
* docx4j при unmarshal неизвестный m:*-элемент теряет, поэтому «сеть»
|
||||
* проверяется синтетическим деревом — та же форма, что оставляет
|
||||
* байтовый скан перед flatten.
|
||||
*/
|
||||
@Test
|
||||
void unsupportedElement_textStillCollects() {
|
||||
CTOMath math = new CTOMath();
|
||||
org.docx4j.math.CTText t = new org.docx4j.math.CTText();
|
||||
t.setValue("СЕТЬ");
|
||||
math.getEGOMathElements().add(new JAXBElement<>(
|
||||
new QName(M_NS, "fooBar"), Object.class, t));
|
||||
assertEquals("СЕТЬ", MathModel.mathText(math));
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------
|
||||
// Каркас
|
||||
// ------------------------------------------------------------------
|
||||
|
||||
/** docx с телом, содержащим формулу; оMath ищется в дереве после загрузки. */
|
||||
private static byte[] mathDocx(String bodyXml) throws IOException {
|
||||
ByteArrayOutputStream out = new ByteArrayOutputStream();
|
||||
try (ZipOutputStream zos = new ZipOutputStream(out)) {
|
||||
putZip(zos, "[Content_Types].xml",
|
||||
"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>"
|
||||
+ "<Types xmlns=\"http://schemas.openxmlformats.org/package/2006/content-types\">"
|
||||
+ "<Default Extension=\"rels\" ContentType=\"application/vnd.openxmlformats-package.relationships+xml\"/>"
|
||||
+ "<Default Extension=\"xml\" ContentType=\"application/xml\"/>"
|
||||
+ "<Override PartName=\"/word/document.xml\" ContentType=\"application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml\"/>"
|
||||
+ "</Types>");
|
||||
putZip(zos, "_rels/.rels",
|
||||
"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>"
|
||||
+ "<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">"
|
||||
+ "<Relationship Id=\"rId1\" Type=\"http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument\" Target=\"word/document.xml\"/>"
|
||||
+ "</Relationships>");
|
||||
putZip(zos, "word/document.xml",
|
||||
"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>"
|
||||
+ "<w:document xmlns:w=\"" + W_NS + "\"><w:body>"
|
||||
+ bodyXml
|
||||
+ "<w:sectPr><w:pgSz w:w=\"11906\" w:h=\"16838\"/></w:sectPr>"
|
||||
+ "</w:body></w:document>");
|
||||
}
|
||||
return out.toByteArray();
|
||||
}
|
||||
|
||||
private static void putZip(ZipOutputStream zos, String name, String xml)
|
||||
throws IOException {
|
||||
zos.putNextEntry(new ZipEntry(name));
|
||||
zos.write(xml.getBytes(StandardCharsets.UTF_8));
|
||||
zos.closeEntry();
|
||||
}
|
||||
|
||||
/** Первый {@code m:oMath} дерева документа (формулы лежат в content-списках). */
|
||||
private static CTOMath firstMath(byte[] docx) throws IOException {
|
||||
try {
|
||||
WordprocessingMLPackage pkg =
|
||||
WordprocessingMLPackage.load(new ByteArrayInputStream(docx));
|
||||
CTOMath found = findMath(
|
||||
pkg.getMainDocumentPart().getJaxbElement().getBody().getContent());
|
||||
assertNotNull(found, "oMath не найден в дереве docx4j");
|
||||
return found;
|
||||
} catch (org.docx4j.openpackaging.exceptions.Docx4JException e) {
|
||||
throw new IOException(e);
|
||||
}
|
||||
}
|
||||
|
||||
private static CTOMath findMath(List<?> content) {
|
||||
for (Object o : content) {
|
||||
Object v = o instanceof JAXBElement<?> el ? el.getValue() : o;
|
||||
if (v instanceof CTOMath m) {
|
||||
return m;
|
||||
}
|
||||
if (v instanceof org.docx4j.wml.Body b) {
|
||||
CTOMath m = findMath(b.getContent());
|
||||
if (m != null) {
|
||||
return m;
|
||||
}
|
||||
}
|
||||
if (v instanceof org.docx4j.wml.P p) {
|
||||
CTOMath m = findMath(p.getContent());
|
||||
if (m != null) {
|
||||
return m;
|
||||
}
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
/** Есть ли в ARGB-растре непрозрачный пиксель. */
|
||||
private static boolean hasInk(java.awt.image.BufferedImage img) {
|
||||
for (int y = 0; y < img.getHeight(); y++) {
|
||||
for (int x = 0; x < img.getWidth(); x++) {
|
||||
if ((img.getRGB(x, y) >>> 24) > 0) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user