Экзотические глифы: решётка «#» вместо .notdef
Знак без глифа в шрифте ранa FOP рисовал .notdef — в эталонном references/word.docx таких оставалось 28. - Noto Naskh Arabic и Noto Sans Armenian (SIL OFL, 278 КБ) в бандле: FontFallback.selectCovering перебирает весь реестр PhysicalFonts и находит их сам — арабские дополнения и армянские Unicode 16 рисуются без нашего кода. - GlyphCoverageNormalizer режет ран по покрытию глифов и пишет семейство в w:rFonts. Нужен из-за двух дыр docx4j: needsCoverage=false для «латинской» группы (римские цифры U+2150–U+218F) и кэш fallbackByScript на всю группу Юникода (армянские U+058D/U+058E получали DejaVu Serif). - FopFallbackFonts.declare декларирует все бандл-семейства: FOP встраивает только задекларированные, а font-family в FO может запросить любое. В эталоне осталось 2 решёток: U+2188 и U+218A есть только в GNU FreeSerif (GPL-3+ с Font Exception), которого в бандле нет намеренно.
This commit is contained in:
@@ -13,6 +13,7 @@ import ru.pjandro.wordpdf.fonts.BundledFonts;
|
||||
import ru.pjandro.wordpdf.internal.chart.DrawingPreRenderer;
|
||||
import ru.pjandro.wordpdf.internal.DocxOnOffNormalizer;
|
||||
import ru.pjandro.wordpdf.internal.FieldNormalizer;
|
||||
import ru.pjandro.wordpdf.internal.GlyphCoverageNormalizer;
|
||||
import ru.pjandro.wordpdf.internal.FopFallbackFonts;
|
||||
import ru.pjandro.wordpdf.internal.SymbolFontNormalizer;
|
||||
|
||||
@@ -115,6 +116,10 @@ public final class WordPdfConverter {
|
||||
// ...и поля PAGE/NUMPAGES из fldChar делаем w:fldSimple, иначе
|
||||
// в колонтитулах печатается кэш docx (см. FieldNormalizer).
|
||||
docxBytes = FieldNormalizer.normalize(docxBytes);
|
||||
// ...и раны со знаками, которых нет в их шрифте: без этого
|
||||
// FOP рисует «#» (docx4j проверяет покрытие не для всех знаков
|
||||
// и кэширует фолбэк на группу Юникода, см. GlyphCoverageNormalizer).
|
||||
docxBytes = GlyphCoverageNormalizer.normalize(docxBytes);
|
||||
WordprocessingMLPackage pkg = WordprocessingMLPackage.load(
|
||||
new ByteArrayInputStream(docxBytes));
|
||||
try {
|
||||
|
||||
@@ -46,6 +46,18 @@ public class BundledFontMapper extends BestMatchingMapper {
|
||||
/** Финальный fallback: шрифт с гарантированной кириллицей. */
|
||||
private static final String FALLBACK_FAMILY = BundledFonts.FALLBACK_FAMILY;
|
||||
|
||||
/**
|
||||
* Имя семейства для записи в {@code w:rFonts} (ключ — lowercase-семейство).
|
||||
* Нужно {@code GlyphCoverageNormalizer}: он пишет в разрезанный ран
|
||||
* человекочитаемое имя, а {@link #populateFontMappings} маппит его
|
||||
* обратно на TTF.
|
||||
*/
|
||||
private static final Map<String, String> DISPLAY_NAMES = Map.of(
|
||||
"dejavu sans", "DejaVu Sans",
|
||||
"dejavu serif", "DejaVu Serif",
|
||||
"noto naskh arabic", "Noto Naskh Arabic",
|
||||
"noto sans armenian", "Noto Sans Armenian");
|
||||
|
||||
/**
|
||||
* Имя, которое docx4j {@code RunFontSelector} запрашивает у маппера для
|
||||
* символов диапазона U+2000–U+2EFF (em-dash «—», кавычки «„», многоточие
|
||||
@@ -74,6 +86,10 @@ public class BundledFontMapper extends BestMatchingMapper {
|
||||
m.put("cousine", "cousine");
|
||||
m.put("dejavu sans", "dejavu sans");
|
||||
m.put("dejavu serif", "dejavu serif");
|
||||
// Покрывающие шрифты (в документе обычно не встречаются, но если
|
||||
// встречаться — маппятся на себя, а не в DejaVu-фолбэк)
|
||||
m.put("noto naskh arabic", "noto naskh arabic");
|
||||
m.put("noto sans armenian", "noto sans armenian");
|
||||
ALIASES = Map.copyOf(m);
|
||||
}
|
||||
|
||||
@@ -89,6 +105,17 @@ public class BundledFontMapper extends BestMatchingMapper {
|
||||
: FALLBACK_FAMILY;
|
||||
}
|
||||
|
||||
/**
|
||||
* Имя шрифта, которое можно поставить в {@code w:rFonts}, чтобы получить
|
||||
* бандл-семейство {@code family}: {@link GlyphCoverageNormalizer} пишет
|
||||
* его в разрезанные раны. Обратная к {@link #bundledFamily} операция —
|
||||
* имена берутся из таблицы алиасов, поэтому маппинг гарантированно
|
||||
* возвращается к тому же семейству.
|
||||
*/
|
||||
public static String documentFontName(String family) {
|
||||
return DISPLAY_NAMES.getOrDefault(family, family);
|
||||
}
|
||||
|
||||
/**
|
||||
* Вызывается docx4j при {@code package.setFontMapper(...)}: для каждого
|
||||
* имени шрифта, использованного в документе, нужно определить, каким
|
||||
|
||||
@@ -97,7 +97,14 @@ public final class BundledFonts {
|
||||
new Entry("DejaVuSerif-Regular.ttf", "dejavu serif", V_REGULAR),
|
||||
new Entry("DejaVuSerif-Bold.ttf", "dejavu serif", V_BOLD),
|
||||
new Entry("DejaVuSerif-Italic.ttf", "dejavu serif", V_ITALIC),
|
||||
new Entry("DejaVuSerif-BoldItalic.ttf", "dejavu serif", V_BOLD_ITALIC)
|
||||
new Entry("DejaVuSerif-BoldItalic.ttf", "dejavu serif", V_BOLD_ITALIC),
|
||||
// Noto — покрытие письменностей, которых нет ни в одном шрифте
|
||||
// выше (арабские дополнения U+07B1–U+08FF, армянские знаки
|
||||
// Unicode 16). В docx4j-фолбэк они попадают сами:
|
||||
// FontFallback.selectCovering перебирает весь реестр
|
||||
// PhysicalFonts и берёт тот, что покрывает код (SIL OFL 1.1)
|
||||
new Entry("NotoNaskhArabic-Regular.ttf", "noto naskh arabic", V_REGULAR),
|
||||
new Entry("NotoSansArmenian-Regular.ttf", "noto sans armenian", V_REGULAR)
|
||||
);
|
||||
|
||||
/** Ключ семейства (lowercase) -> начертание -> зарегистрированный PhysicalFont. */
|
||||
@@ -209,6 +216,16 @@ public final class BundledFonts {
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Все бандл-семейства (lowercase) в порядке {@link #ENTRIES}.
|
||||
* Нужны, чтобы задекларировать в FOP-конфиге каждый шрифт jar:
|
||||
* FO может запросить любой из них (фолбэк docx4j по покрытию глифов),
|
||||
* а FOP знает только задекларированные.
|
||||
*/
|
||||
public static java.util.List<String> families() {
|
||||
return ENTRIES.stream().map(Entry::family).distinct().toList();
|
||||
}
|
||||
|
||||
/**
|
||||
* Зарегистрированный шрифт: семейство (lowercase) + начертание.
|
||||
*
|
||||
|
||||
@@ -7,20 +7,26 @@ import org.docx4j.fonts.PhysicalFont;
|
||||
import ru.pjandro.wordpdf.fonts.BundledFonts;
|
||||
|
||||
/**
|
||||
* Декларирует fallback-семейство (DejaVu Sans) в FOP-конфиге.
|
||||
* Декларирует бандл-шрифты jar в FOP-конфиге.
|
||||
*
|
||||
* FOP-конфиг, который docx4j строит в {@code FOSettings}, содержит
|
||||
* только шрифты, реально использованные в документе ({@code fontsInUse}).
|
||||
* Но docx4j {@code RunFontSelector} для символов диапазона U+2000–U+2EFF
|
||||
* (em-dash «—», кавычки, многоточие) выставляет в FO
|
||||
* {@code font-family}, маппированный с "Segoe UI Symbol" на DejaVu Sans
|
||||
* (см. {@link ru.pjandro.wordpdf.fonts.BundledFontMapper}). Если семейство
|
||||
* не задекларировано в FOP-конфиге, FOP не может его встроить и падает
|
||||
* на базовый неembedded-шрифт (Helvetica) — символ рендерится шрифтом
|
||||
* просмотрщика, а не встраиваемым подмножеством.
|
||||
* Но {@code RunFontSelector} может выставить в {@code font-family} и шрифт
|
||||
* извне документа:
|
||||
* <ul>
|
||||
* <li>для символов U+2000–U+2EFF (em-dash «—», кавычки, многоточие)
|
||||
* подставляется "Segoe UI Symbol", маппированный на DejaVu Sans
|
||||
* (см. {@link ru.pjandro.wordpdf.fonts.BundledFontMapper});</li>
|
||||
* <li>для знаков, которых нет в шрифте ранa, {@code FontFallback}
|
||||
* ищет покрывающий шрифт по всему реестру {@code PhysicalFonts} —
|
||||
* так в FO попадают Noto Naskh Arabic и Noto Sans Armenian.</li>
|
||||
* </ul>
|
||||
* Если семейство не задекларировано в FOP-конфиге, FOP не может его
|
||||
* встроить и падает на базовый неembedded-шрифт (Helvetica) — символ
|
||||
* рендерится шрифтом просмотрщика либо .notdef («#»). Поэтому в конфиг
|
||||
* добавляются ВСЕ шрифты бандла: стоит они в документе или нет, решает FO.
|
||||
*
|
||||
* Метод идемпотентен: если семейство уже задекларировано (например,
|
||||
* документ прямо использует DejaVu), ничего не добавляет.
|
||||
* Метод идемпотентен: уже задекларированное семейство не дублируется.
|
||||
*/
|
||||
public final class FopFallbackFonts {
|
||||
|
||||
@@ -28,7 +34,7 @@ public final class FopFallbackFonts {
|
||||
}
|
||||
|
||||
/**
|
||||
* Добавляет все начертания fallback-семейства в FOP-конфиг
|
||||
* Добавляет все начертания всех бандл-семейств в FOP-конфиг
|
||||
* {@code foSettings}. Вызывать после {@code new FOSettings(pkg)}
|
||||
* и до передачи настроек в {@code FORendererApacheFOP}.
|
||||
*/
|
||||
@@ -37,7 +43,16 @@ public final class FopFallbackFonts {
|
||||
if (rendererFonts == null) {
|
||||
return;
|
||||
}
|
||||
PhysicalFont regular = BundledFonts.regular(BundledFonts.FALLBACK_FAMILY);
|
||||
ObjectFactory factory = new ObjectFactory();
|
||||
for (String family : BundledFonts.families()) {
|
||||
declareFamily(rendererFonts, factory, family);
|
||||
}
|
||||
}
|
||||
|
||||
/** Одно семейство: regular + существующие начертания (Noto — только regular). */
|
||||
private static void declareFamily(Fonts rendererFonts, ObjectFactory factory,
|
||||
String family) {
|
||||
PhysicalFont regular = BundledFonts.regular(family);
|
||||
if (regular == null) {
|
||||
return;
|
||||
}
|
||||
@@ -54,14 +69,13 @@ public final class FopFallbackFonts {
|
||||
}
|
||||
}
|
||||
|
||||
ObjectFactory factory = new ObjectFactory();
|
||||
addFont(rendererFonts, factory, familyName, regular, "normal", "normal");
|
||||
addFont(rendererFonts, factory, familyName,
|
||||
BundledFonts.bold(BundledFonts.FALLBACK_FAMILY), "normal", "bold");
|
||||
BundledFonts.bold(family), "normal", "bold");
|
||||
addFont(rendererFonts, factory, familyName,
|
||||
BundledFonts.italic(BundledFonts.FALLBACK_FAMILY), "italic", "normal");
|
||||
BundledFonts.italic(family), "italic", "normal");
|
||||
addFont(rendererFonts, factory, familyName,
|
||||
BundledFonts.boldItalic(BundledFonts.FALLBACK_FAMILY), "italic", "bold");
|
||||
BundledFonts.boldItalic(family), "italic", "bold");
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@@ -0,0 +1,422 @@
|
||||
package ru.pjandro.wordpdf.internal;
|
||||
|
||||
import ru.pjandro.wordpdf.fonts.BundledFontMapper;
|
||||
import ru.pjandro.wordpdf.fonts.BundledFonts;
|
||||
|
||||
import java.io.ByteArrayInputStream;
|
||||
import java.io.ByteArrayOutputStream;
|
||||
import java.io.IOException;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.util.ArrayList;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.regex.Matcher;
|
||||
import java.util.regex.Pattern;
|
||||
import java.util.zip.ZipEntry;
|
||||
import java.util.zip.ZipInputStream;
|
||||
import java.util.zip.ZipOutputStream;
|
||||
|
||||
/**
|
||||
* Разрезание ранов по покрытию глифов — до загрузки docx4j.
|
||||
*
|
||||
* Если у знака нет глифа в шрифте ранa, FOP рисует {@code .notdef} — в PDF
|
||||
* решётка «#». Часть таких знаков спасает сам docx4j
|
||||
* ({@code FontFallback.selectCovering} ищет покрывающий шрифт по реестру),
|
||||
* но у его механизма две дыры:
|
||||
* <ul>
|
||||
* <li>покрытие проверяется не для всех знаков: {@code needsCoverage}
|
||||
* возвращает false для «латинской» группы, поэтому римские цифры и
|
||||
* дроби (U+2150–U+218F) остаются на шрифте ранa (Tinos) навсегда;</li>
|
||||
* <li>фолбэк считается один раз на группу Юникода и кэшируется
|
||||
* ({@code RunFontSelector.fallbackByScript}): армянские «ՊՌՋտ»
|
||||
* покрываются DejaVu Serif, и найденный DejaVu Serif подставляется
|
||||
* и для следующих за ними U+058D/U+058E, которых в DejaVu нет.</li>
|
||||
* </ul>
|
||||
*
|
||||
* Делаем то, что должен был сделать рендер: ран, в тексте которого есть
|
||||
* знаки без глифа, разрезается на части, и каждой части явно назначается
|
||||
* бандл-семейство, где глиф есть ({@link #targetFamily}). Имя пишется в
|
||||
* {@code w:rFonts}, дальше {@link BundledFontMapper} маппит его на TTF,
|
||||
* а {@link FopFallbackFonts} декларирует его в FOP-конфиге.
|
||||
*
|
||||
* Правила, ограничивающие вмешательство:
|
||||
* <ul>
|
||||
* <li>трогаются только раны с одним {@code w:t} — составные
|
||||
* ({@code w:tab}, {@code w:drawing}, несколько текстовых узлов)
|
||||
* остаются как есть;</li>
|
||||
* <li>ран без {@code w:rFonts} не трогаем: его шрифт приходит из стилей,
|
||||
* угадать его здесь нельзя;</li>
|
||||
* <li>если знака нет ни в одном бандл-шрифте, ран не меняется — решётку
|
||||
* честнее оставить, чем подменять случайным шрифтом.</li>
|
||||
* </ul>
|
||||
*
|
||||
* Как и {@link SymbolFontNormalizer}, правим байты zip до JAXB-разбора.
|
||||
*/
|
||||
public final class GlyphCoverageNormalizer {
|
||||
|
||||
/** Семейства с засечками: для них fallback ищется сначала среди serif. */
|
||||
private static final List<String> SERIF_FAMILIES =
|
||||
List.of("dejavu serif", "tinos", "caladea");
|
||||
|
||||
/** Без засечек — общий fallback проекта (в нём есть кириллица). */
|
||||
private static final String SANS_FALLBACK = BundledFonts.FALLBACK_FAMILY;
|
||||
|
||||
/** {@code <w:t ...>текст</w:t>} — единственный текстовый узел рана. */
|
||||
private static final Pattern TEXT_ELEMENT = Pattern.compile(
|
||||
"<w:t\\b([^>]*)>(.*?)</w:t>", Pattern.DOTALL);
|
||||
|
||||
/** Атрибуты w:rFonts с именем шрифта. */
|
||||
private static final Pattern FONT_ATTR = Pattern.compile(
|
||||
"w:(ascii|hAnsi)=\"([^\"]+)\"");
|
||||
|
||||
/** Числовые сущности XML (— / —). */
|
||||
private static final Pattern NUMERIC_ENTITY = Pattern.compile(
|
||||
"&#(x?)([0-9A-Fa-f]+);");
|
||||
|
||||
/** Кэш покрытия: семейство -> множества проверенных/покрытых кодов. */
|
||||
private static final Map<String, Coverage> COVERAGE = new HashMap<>();
|
||||
|
||||
private GlyphCoverageNormalizer() {
|
||||
}
|
||||
|
||||
/**
|
||||
* Разрезает раны с непокрытыми глифами в XML-частях docx (word/*.xml).
|
||||
*
|
||||
* @param docx байты .docx (zip)
|
||||
* @return те же или переупакованные байты
|
||||
*/
|
||||
public static byte[] normalize(byte[] docx) throws IOException {
|
||||
ByteArrayOutputStream out = new ByteArrayOutputStream(docx.length);
|
||||
boolean changed = false;
|
||||
try (ZipInputStream zis = new ZipInputStream(new ByteArrayInputStream(docx));
|
||||
ZipOutputStream zos = new ZipOutputStream(out)) {
|
||||
ZipEntry entry;
|
||||
while ((entry = zis.getNextEntry()) != null) {
|
||||
byte[] data = zis.readAllBytes();
|
||||
String name = entry.getName();
|
||||
if (name.startsWith("word/") && name.endsWith(".xml")) {
|
||||
String fixed = rewrite(new String(data, StandardCharsets.UTF_8));
|
||||
if (fixed != null) {
|
||||
changed = true;
|
||||
data = fixed.getBytes(StandardCharsets.UTF_8);
|
||||
}
|
||||
}
|
||||
zos.putNextEntry(new ZipEntry(name));
|
||||
zos.write(data);
|
||||
zos.closeEntry();
|
||||
}
|
||||
}
|
||||
return changed ? out.toByteArray() : docx;
|
||||
}
|
||||
|
||||
/**
|
||||
* Переписывает раны с непокрытыми глифами.
|
||||
*
|
||||
* @return новая строка либо null, если менять нечего
|
||||
*/
|
||||
static String rewrite(String xml) {
|
||||
String result = rewriteBlocks(xml, "w:r");
|
||||
return result.equals(xml) ? null : result;
|
||||
}
|
||||
|
||||
/**
|
||||
* Проходит невложенные блоки {@code <w:r>} ... {@code </w:r>} и заменяет
|
||||
* каждый через {@link #rewriteBlock}. Приём тот же, что в
|
||||
* {@link SymbolFontNormalizer}: полные раны не вложены друг в друга.
|
||||
*/
|
||||
private static String rewriteBlocks(String xml, String tag) {
|
||||
String open = "<" + tag;
|
||||
String close = "</" + tag + ">";
|
||||
StringBuilder sb = new StringBuilder(xml.length());
|
||||
int pos = 0;
|
||||
while (true) {
|
||||
int start = indexOfOpenTag(xml, open, pos);
|
||||
if (start < 0) {
|
||||
break;
|
||||
}
|
||||
int openEnd = xml.indexOf('>', start);
|
||||
int end = xml.indexOf(close, openEnd);
|
||||
if (openEnd < 0 || end < 0) {
|
||||
break;
|
||||
}
|
||||
end += close.length();
|
||||
sb.append(xml, pos, start).append(rewriteBlock(xml.substring(start, end)));
|
||||
pos = end;
|
||||
}
|
||||
if (pos == 0) {
|
||||
return xml;
|
||||
}
|
||||
return sb.append(xml, pos, xml.length()).toString();
|
||||
}
|
||||
|
||||
/** Позиция открывающего (не самозакрывающегося) тега {@code open}. */
|
||||
private static int indexOfOpenTag(String xml, String open, int from) {
|
||||
int i = xml.indexOf(open, from);
|
||||
while (i >= 0) {
|
||||
char next = i + open.length() < xml.length() ? xml.charAt(i + open.length()) : 0;
|
||||
if (next == '>' || next == ' ' || next == '\t' || next == '\n' || next == '\r') {
|
||||
int openEnd = xml.indexOf('>', i);
|
||||
if (openEnd < 0) {
|
||||
return -1;
|
||||
}
|
||||
return xml.charAt(openEnd - 1) == '/'
|
||||
? indexOfOpenTag(xml, open, openEnd) : i;
|
||||
}
|
||||
i = xml.indexOf(open, i + open.length());
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
/**
|
||||
* Разрезает один {@code w:r}: части текста без глифа в шрифте ранa
|
||||
* получают собственное {@code w:rFonts}.
|
||||
*/
|
||||
private static String rewriteBlock(String block) {
|
||||
if (!block.endsWith("</w:r>")) {
|
||||
return block;
|
||||
}
|
||||
int tagEnd = block.indexOf('>');
|
||||
String openTag = block.substring(0, tagEnd + 1);
|
||||
String body = block.substring(tagEnd + 1, block.length() - "</w:r>".length());
|
||||
|
||||
String rPr = "";
|
||||
if (body.startsWith("<w:rPr>")) {
|
||||
int rPrEnd = body.indexOf("</w:rPr>");
|
||||
if (rPrEnd < 0) {
|
||||
return block;
|
||||
}
|
||||
rPr = body.substring(0, rPrEnd + "</w:rPr>".length());
|
||||
body = body.substring(rPrEnd + "</w:rPr>".length());
|
||||
}
|
||||
String runFamily = runFamily(rPr);
|
||||
if (runFamily == null) {
|
||||
// Шрифт не указан явно — приходит из стилей, не угадываем.
|
||||
return block;
|
||||
}
|
||||
Matcher text = TEXT_ELEMENT.matcher(body);
|
||||
if (!text.matches()) {
|
||||
// Составной ран (w:tab, w:drawing, несколько w:t) не трогаем.
|
||||
return block;
|
||||
}
|
||||
String decoded = decode(text.group(2));
|
||||
List<Segment> segments = split(decoded, runFamily);
|
||||
if (segments == null) {
|
||||
return block;
|
||||
}
|
||||
|
||||
StringBuilder sb = new StringBuilder(block.length() + 64);
|
||||
for (Segment s : segments) {
|
||||
sb.append(openTag).append(s.family == null ? rPr : forceFont(rPr, s.family))
|
||||
.append("<w:t").append(attrs(text.group(1), s.text)).append('>')
|
||||
.append(encode(s.text))
|
||||
.append("</w:t></w:r>");
|
||||
}
|
||||
return sb.toString();
|
||||
}
|
||||
|
||||
/**
|
||||
* Разбивает текст на части по семейству, которое обязано его отрисовать.
|
||||
*
|
||||
* @return части либо null, если весь текст остаётся на шрифте ранa
|
||||
* (или ни один бандл-шрифт не покрывает недостающие знаки)
|
||||
*/
|
||||
static List<Segment> split(String text, String runFamily) {
|
||||
List<Segment> segments = new ArrayList<>();
|
||||
int start = 0;
|
||||
String current = null;
|
||||
for (int i = 0; i < text.length(); ) {
|
||||
int cp = text.codePointAt(i);
|
||||
int next = i + Character.charCount(cp);
|
||||
String target = targetFamily(cp, runFamily);
|
||||
if (start == i) {
|
||||
current = target;
|
||||
} else if (!java.util.Objects.equals(target, current)) {
|
||||
segments.add(new Segment(text.substring(start, i), current));
|
||||
start = i;
|
||||
current = target;
|
||||
}
|
||||
i = next;
|
||||
}
|
||||
if (text.isEmpty()) {
|
||||
return null;
|
||||
}
|
||||
segments.add(new Segment(text.substring(start), current));
|
||||
boolean changed = segments.size() > 1 || segments.get(0).family != null;
|
||||
return changed ? segments : null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Семейство, которым нужно рисовать знак {@code cp}, или null, если
|
||||
* штатного шрифта ранa достаточно.
|
||||
*
|
||||
* Порядок перебора: сначала семейства того же рисунка (serif к serif),
|
||||
* затем остальные бандл-семейства — так знак остаётся максимально
|
||||
* близким по начертанию.
|
||||
*/
|
||||
static String targetFamily(int cp, String runFamily) {
|
||||
if (covers(runFamily, cp)) {
|
||||
return null;
|
||||
}
|
||||
boolean serif = SERIF_FAMILIES.contains(runFamily);
|
||||
for (String family : candidates(runFamily, serif)) {
|
||||
if (covers(family, cp)) {
|
||||
return family;
|
||||
}
|
||||
}
|
||||
// Одиночный знак может не найтись ни в одном семействе — решётку
|
||||
// не прячем: ран остаётся как есть.
|
||||
return null;
|
||||
}
|
||||
|
||||
/** Кандидаты на подстановку: сначала «свой» класс, потом остальные. */
|
||||
private static List<String> candidates(String runFamily, boolean serif) {
|
||||
List<String> ordered = new ArrayList<>();
|
||||
if (serif) {
|
||||
ordered.addAll(SERIF_FAMILIES);
|
||||
}
|
||||
ordered.add(SANS_FALLBACK);
|
||||
for (String family : BundledFonts.families()) {
|
||||
if (!ordered.contains(family)) {
|
||||
ordered.add(family);
|
||||
}
|
||||
}
|
||||
ordered.remove(runFamily);
|
||||
return ordered;
|
||||
}
|
||||
|
||||
/** Есть ли у семейства глиф для кода (regular-начертание). */
|
||||
static boolean covers(String family, int cp) {
|
||||
if (family == null) {
|
||||
return false;
|
||||
}
|
||||
return coverage(family).covers(cp);
|
||||
}
|
||||
|
||||
private static Coverage coverage(String family) {
|
||||
Coverage c = COVERAGE.get(family);
|
||||
if (c == null) {
|
||||
c = new Coverage(BundledFonts.awtFont(family, BundledFonts.V_REGULAR));
|
||||
COVERAGE.put(family, c);
|
||||
}
|
||||
return c;
|
||||
}
|
||||
|
||||
/**
|
||||
* Покрытие одного семейства: {@code java.awt.Font.canDisplay} с кэшем
|
||||
* «проверенных» кодов. AWT берётся вместо {@code GlyphCheck}, чтобы не
|
||||
* плодить INFO-лог на каждый отсутствующий глиф.
|
||||
*/
|
||||
private static final class Coverage {
|
||||
|
||||
private final java.awt.Font font;
|
||||
private final java.util.BitSet checked = new java.util.BitSet();
|
||||
private final java.util.BitSet covered = new java.util.BitSet();
|
||||
|
||||
Coverage(java.awt.Font font) {
|
||||
this.font = font;
|
||||
}
|
||||
|
||||
boolean covers(int cp) {
|
||||
if (font == null || cp < 0) {
|
||||
return false;
|
||||
}
|
||||
if (checked.get(cp)) {
|
||||
return covered.get(cp);
|
||||
}
|
||||
checked.set(cp);
|
||||
if (font.canDisplay(cp)) {
|
||||
covered.set(cp);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/** Часть текста рана; family == null — рисовать штатным шрифтом ранa. */
|
||||
static final class Segment {
|
||||
|
||||
final String text;
|
||||
/** Ключ бандл-семейства (lowercase) или null. */
|
||||
final String family;
|
||||
|
||||
Segment(String text, String family) {
|
||||
this.text = text;
|
||||
this.family = family;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Бандл-семейство шрифта ранa (первое из {@code w:ascii}/{@code w:hAnsi})
|
||||
* либо null, если рана шрифт не объявлен.
|
||||
*/
|
||||
private static String runFamily(String rPr) {
|
||||
int rFonts = rPr.indexOf("<w:rFonts");
|
||||
if (rFonts < 0) {
|
||||
return null;
|
||||
}
|
||||
int end = rPr.indexOf('>', rFonts);
|
||||
if (end < 0) {
|
||||
return null;
|
||||
}
|
||||
Matcher m = FONT_ATTR.matcher(rPr.substring(rFonts, end));
|
||||
if (!m.find()) {
|
||||
return null;
|
||||
}
|
||||
return BundledFontMapper.bundledFamily(m.group(2));
|
||||
}
|
||||
|
||||
/**
|
||||
* Принудительно ставит семейство в {@code w:rPr}: заменяет атрибуты
|
||||
* {@code w:rFonts}, а если их нет — вставляет элемент первым ребёнком.
|
||||
*/
|
||||
private static String forceFont(String rPr, String family) {
|
||||
String name = BundledFontMapper.documentFontName(family);
|
||||
String fonts = "<w:rFonts w:ascii=\"" + name + "\" w:hAnsi=\"" + name + "\"/>";
|
||||
if (rPr.isEmpty()) {
|
||||
return "<w:rPr>" + fonts + "</w:rPr>";
|
||||
}
|
||||
int start = rPr.indexOf("<w:rFonts");
|
||||
if (start < 0) {
|
||||
return rPr.replaceFirst("<w:rPr>", "<w:rPr>" + fonts);
|
||||
}
|
||||
int end = rPr.indexOf("/>", start);
|
||||
int blockEnd = rPr.indexOf("</w:rFonts>", start);
|
||||
if (blockEnd >= 0 && (end < 0 || blockEnd < end)) {
|
||||
return rPr.substring(0, start) + fonts + rPr.substring(blockEnd + "</w:rFonts>".length());
|
||||
}
|
||||
if (end < 0) {
|
||||
return rPr;
|
||||
}
|
||||
return rPr.substring(0, start) + fonts + rPr.substring(end + 2);
|
||||
}
|
||||
|
||||
/** Атрибуты w:t: сохраняем исходные и добавляем preserve, если нужно. */
|
||||
private static String attrs(String original, String segmentText) {
|
||||
// Пустой после strip() сегмент — это тоже пробелы, их Word бы съел.
|
||||
boolean needsPreserve = !segmentText.equals(segmentText.strip());
|
||||
if (needsPreserve && !original.contains("xml:space")) {
|
||||
return original + " xml:space=\"preserve\"";
|
||||
}
|
||||
return original;
|
||||
}
|
||||
|
||||
/** Разворачивает XML-сущности текста в настоящие символы. */
|
||||
private static String decode(String xmlText) {
|
||||
if (xmlText.indexOf('&') < 0) {
|
||||
return xmlText;
|
||||
}
|
||||
String result = NUMERIC_ENTITY.matcher(xmlText).replaceAll(mr -> {
|
||||
int cp = Integer.parseInt(mr.group(2), mr.group(1).isEmpty() ? 10 : 16);
|
||||
return Matcher.quoteReplacement(new String(Character.toChars(cp)));
|
||||
});
|
||||
return result.replace("<", "<").replace(">", ">")
|
||||
.replace(""", "\"").replace("'", "'")
|
||||
.replace("&", "&");
|
||||
}
|
||||
|
||||
/** Обратное {@link #decode}: текст снова безопасен для {@code w:t}. */
|
||||
private static String encode(String text) {
|
||||
return text.replace("&", "&").replace("<", "<").replace(">", ">");
|
||||
}
|
||||
}
|
||||
@@ -15,4 +15,12 @@
|
||||
Источник: официальный tarball dejavu-fonts-ttf-2.37 (https://dejavu-fonts.github.io),
|
||||
LICENSE см. DejaVu-LICENSE.txt.
|
||||
|
||||
Все шрифты свободно распространяемы и поддерживают кириллицу.
|
||||
- Noto Naskh Arabic, Noto Sans Armenian
|
||||
SIL Open Font License 1.1 (SIL OFL 1.1).
|
||||
Покрывают письменности, которых нет в шрифтах выше (арабские дополнения
|
||||
U+07B1–U+08FF, армянские знаки Unicode 16).
|
||||
(c) The Noto Project Authors.
|
||||
Источник: notofonts.github.io (hinted TTF), LICENSE см. Noto-LICENSE.txt.
|
||||
|
||||
Все шрифты свободно распространяемы (SIL OFL 1.1); шрифты текста
|
||||
(Carlito, Caladea, Arimo, Tinos, Cousine, DejaVu) содержат кириллицу.
|
||||
|
||||
@@ -0,0 +1,94 @@
|
||||
Copyright 2022 The Noto Project Authors (https://github.com/notofonts/)
|
||||
|
||||
This Font Software is licensed under the SIL Open Font License,
|
||||
Version 1.1.
|
||||
|
||||
This license is copied below, and is also available with a FAQ at:
|
||||
http://scripts.sil.org/OFL
|
||||
|
||||
-----------------------------------------------------------
|
||||
SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
|
||||
-----------------------------------------------------------
|
||||
|
||||
PREAMBLE
|
||||
The goals of the Open Font License (OFL) are to stimulate worldwide
|
||||
development of collaborative font projects, to support the font
|
||||
creation efforts of academic and linguistic communities, and to
|
||||
provide a free and open framework in which fonts may be shared and
|
||||
improved in partnership with others.
|
||||
|
||||
The OFL allows the licensed fonts to be used, studied, modified and
|
||||
redistributed freely as long as they are not sold by themselves. The
|
||||
fonts, including any derivative works, can be bundled, embedded,
|
||||
redistributed and/or sold with any software provided that any reserved
|
||||
names are not used by derivative works. The fonts and derivatives,
|
||||
however, cannot be released under any other type of license. The
|
||||
requirement for fonts to remain under this license does not apply to
|
||||
any document created using the fonts or their derivatives.
|
||||
|
||||
DEFINITIONS
|
||||
"Font Software" refers to the set of files released by the Copyright
|
||||
Holder(s) under this license and clearly marked as such. This may
|
||||
include source files, build scripts and documentation.
|
||||
|
||||
"Reserved Font Name" refers to any names specified as such after the
|
||||
copyright statement(s).
|
||||
|
||||
"Original Version" refers to the collection of Font Software
|
||||
components as distributed by the Copyright Holder(s).
|
||||
|
||||
"Modified Version" refers to any derivative made by adding to,
|
||||
deleting, or substituting -- in part or in whole -- any of the
|
||||
components of the Original Version, by changing formats or by porting
|
||||
the Font Software to a new environment.
|
||||
|
||||
"Author" refers to any designer, engineer, programmer, technical
|
||||
writer or other person who contributed to the Font Software.
|
||||
|
||||
PERMISSION & CONDITIONS
|
||||
Permission is hereby granted, free of charge, to any person obtaining
|
||||
a copy of the Font Software, to use, study, copy, merge, embed,
|
||||
modify, redistribute, and sell modified and unmodified copies of the
|
||||
Font Software, subject to the following conditions:
|
||||
|
||||
1) Neither the Font Software nor any of its individual components, in
|
||||
Original or Modified Versions, may be sold by itself.
|
||||
|
||||
2) Original or Modified Versions of the Font Software may be bundled,
|
||||
redistributed and/or sold with any software, provided that each copy
|
||||
contains the above copyright notice and this license. These can be
|
||||
included either as stand-alone text files, human-readable headers or
|
||||
in the appropriate machine-readable metadata fields within text or
|
||||
binary files as long as those fields can be easily viewed by the user.
|
||||
|
||||
3) No Modified Version of the Font Software may use the Reserved Font
|
||||
Name(s) unless explicit written permission is granted by the
|
||||
corresponding Copyright Holder. This restriction only applies to the
|
||||
primary font name as presented to the users.
|
||||
|
||||
4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
|
||||
Software shall not be used to promote, endorse or advertise any
|
||||
Modified Version, except to acknowledge the contribution(s) of the
|
||||
Copyright Holder(s) and the Author(s) or with their explicit written
|
||||
permission.
|
||||
|
||||
5) The Font Software, modified or unmodified, in part or in whole,
|
||||
must be distributed entirely under this license, and must not be
|
||||
distributed under any other license. The requirement for fonts to
|
||||
remain under this license does not apply to any document created using
|
||||
the Font Software.
|
||||
|
||||
TERMINATION
|
||||
This license becomes null and void if any of the above conditions are
|
||||
not met.
|
||||
|
||||
DISCLAIMER
|
||||
THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
|
||||
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
|
||||
OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
|
||||
COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
||||
INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
|
||||
DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||||
FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
|
||||
OTHER DEALINGS IN THE FONT SOFTWARE.
|
||||
Binary file not shown.
Binary file not shown.
Reference in New Issue
Block a user