Экзотические глифы: решётка «#» вместо .notdef

Знак без глифа в шрифте ранa FOP рисовал .notdef — в эталонном
references/word.docx таких оставалось 28.

- Noto Naskh Arabic и Noto Sans Armenian (SIL OFL, 278 КБ) в бандле:
  FontFallback.selectCovering перебирает весь реестр PhysicalFonts и
  находит их сам — арабские дополнения и армянские Unicode 16 рисуются
  без нашего кода.
- GlyphCoverageNormalizer режет ран по покрытию глифов и пишет семейство
  в w:rFonts. Нужен из-за двух дыр docx4j: needsCoverage=false для
  «латинской» группы (римские цифры U+2150–U+218F) и кэш fallbackByScript
  на всю группу Юникода (армянские U+058D/U+058E получали DejaVu Serif).
- FopFallbackFonts.declare декларирует все бандл-семейства: FOP встраивает
  только задекларированные, а font-family в FO может запросить любое.

В эталоне осталось 2 решёток: U+2188 и U+218A есть только в GNU FreeSerif
(GPL-3+ с Font Exception), которого в бандле нет намеренно.
This commit is contained in:
Pjandro
2026-10-05 22:29:10 +00:00
parent 0c10bae3cf
commit ae31f27a27
15 changed files with 865 additions and 24 deletions
@@ -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 (&#8212; / &#x2014;). */
private static final Pattern NUMERIC_ENTITY = Pattern.compile(
"&#(x?)([0-9A-Fa-f]+);");
/** Кэш покрытия: семейство -> множества проверенных/покрытых кодов. */
private static final Map<String, Coverage> COVERAGE = new HashMap<>();
private GlyphCoverageNormalizer() {
}
/**
* Разрезает раны с непокрытыми глифами в XML-частях docx (word/*.xml).
*
* @param docx байты .docx (zip)
* @return те же или переупакованные байты
*/
public static byte[] normalize(byte[] docx) throws IOException {
ByteArrayOutputStream out = new ByteArrayOutputStream(docx.length);
boolean changed = false;
try (ZipInputStream zis = new ZipInputStream(new ByteArrayInputStream(docx));
ZipOutputStream zos = new ZipOutputStream(out)) {
ZipEntry entry;
while ((entry = zis.getNextEntry()) != null) {
byte[] data = zis.readAllBytes();
String name = entry.getName();
if (name.startsWith("word/") && name.endsWith(".xml")) {
String fixed = rewrite(new String(data, StandardCharsets.UTF_8));
if (fixed != null) {
changed = true;
data = fixed.getBytes(StandardCharsets.UTF_8);
}
}
zos.putNextEntry(new ZipEntry(name));
zos.write(data);
zos.closeEntry();
}
}
return changed ? out.toByteArray() : docx;
}
/**
* Переписывает раны с непокрытыми глифами.
*
* @return новая строка либо null, если менять нечего
*/
static String rewrite(String xml) {
String result = rewriteBlocks(xml, "w:r");
return result.equals(xml) ? null : result;
}
/**
* Проходит невложенные блоки {@code <w:r>} ... {@code </w:r>} и заменяет
* каждый через {@link #rewriteBlock}. Приём тот же, что в
* {@link SymbolFontNormalizer}: полные раны не вложены друг в друга.
*/
private static String rewriteBlocks(String xml, String tag) {
String open = "<" + tag;
String close = "</" + tag + ">";
StringBuilder sb = new StringBuilder(xml.length());
int pos = 0;
while (true) {
int start = indexOfOpenTag(xml, open, pos);
if (start < 0) {
break;
}
int openEnd = xml.indexOf('>', start);
int end = xml.indexOf(close, openEnd);
if (openEnd < 0 || end < 0) {
break;
}
end += close.length();
sb.append(xml, pos, start).append(rewriteBlock(xml.substring(start, end)));
pos = end;
}
if (pos == 0) {
return xml;
}
return sb.append(xml, pos, xml.length()).toString();
}
/** Позиция открывающего (не самозакрывающегося) тега {@code open}. */
private static int indexOfOpenTag(String xml, String open, int from) {
int i = xml.indexOf(open, from);
while (i >= 0) {
char next = i + open.length() < xml.length() ? xml.charAt(i + open.length()) : 0;
if (next == '>' || next == ' ' || next == '\t' || next == '\n' || next == '\r') {
int openEnd = xml.indexOf('>', i);
if (openEnd < 0) {
return -1;
}
return xml.charAt(openEnd - 1) == '/'
? indexOfOpenTag(xml, open, openEnd) : i;
}
i = xml.indexOf(open, i + open.length());
}
return -1;
}
/**
* Разрезает один {@code w:r}: части текста без глифа в шрифте ранa
* получают собственное {@code w:rFonts}.
*/
private static String rewriteBlock(String block) {
if (!block.endsWith("</w:r>")) {
return block;
}
int tagEnd = block.indexOf('>');
String openTag = block.substring(0, tagEnd + 1);
String body = block.substring(tagEnd + 1, block.length() - "</w:r>".length());
String rPr = "";
if (body.startsWith("<w:rPr>")) {
int rPrEnd = body.indexOf("</w:rPr>");
if (rPrEnd < 0) {
return block;
}
rPr = body.substring(0, rPrEnd + "</w:rPr>".length());
body = body.substring(rPrEnd + "</w:rPr>".length());
}
String runFamily = runFamily(rPr);
if (runFamily == null) {
// Шрифт не указан явно — приходит из стилей, не угадываем.
return block;
}
Matcher text = TEXT_ELEMENT.matcher(body);
if (!text.matches()) {
// Составной ран (w:tab, w:drawing, несколько w:t) не трогаем.
return block;
}
String decoded = decode(text.group(2));
List<Segment> segments = split(decoded, runFamily);
if (segments == null) {
return block;
}
StringBuilder sb = new StringBuilder(block.length() + 64);
for (Segment s : segments) {
sb.append(openTag).append(s.family == null ? rPr : forceFont(rPr, s.family))
.append("<w:t").append(attrs(text.group(1), s.text)).append('>')
.append(encode(s.text))
.append("</w:t></w:r>");
}
return sb.toString();
}
/**
* Разбивает текст на части по семейству, которое обязано его отрисовать.
*
* @return части либо null, если весь текст остаётся на шрифте ранa
* (или ни один бандл-шрифт не покрывает недостающие знаки)
*/
static List<Segment> split(String text, String runFamily) {
List<Segment> segments = new ArrayList<>();
int start = 0;
String current = null;
for (int i = 0; i < text.length(); ) {
int cp = text.codePointAt(i);
int next = i + Character.charCount(cp);
String target = targetFamily(cp, runFamily);
if (start == i) {
current = target;
} else if (!java.util.Objects.equals(target, current)) {
segments.add(new Segment(text.substring(start, i), current));
start = i;
current = target;
}
i = next;
}
if (text.isEmpty()) {
return null;
}
segments.add(new Segment(text.substring(start), current));
boolean changed = segments.size() > 1 || segments.get(0).family != null;
return changed ? segments : null;
}
/**
* Семейство, которым нужно рисовать знак {@code cp}, или null, если
* штатного шрифта ранa достаточно.
*
* Порядок перебора: сначала семейства того же рисунка (serif к serif),
* затем остальные бандл-семейства — так знак остаётся максимально
* близким по начертанию.
*/
static String targetFamily(int cp, String runFamily) {
if (covers(runFamily, cp)) {
return null;
}
boolean serif = SERIF_FAMILIES.contains(runFamily);
for (String family : candidates(runFamily, serif)) {
if (covers(family, cp)) {
return family;
}
}
// Одиночный знак может не найтись ни в одном семействе — решётку
// не прячем: ран остаётся как есть.
return null;
}
/** Кандидаты на подстановку: сначала «свой» класс, потом остальные. */
private static List<String> candidates(String runFamily, boolean serif) {
List<String> ordered = new ArrayList<>();
if (serif) {
ordered.addAll(SERIF_FAMILIES);
}
ordered.add(SANS_FALLBACK);
for (String family : BundledFonts.families()) {
if (!ordered.contains(family)) {
ordered.add(family);
}
}
ordered.remove(runFamily);
return ordered;
}
/** Есть ли у семейства глиф для кода (regular-начертание). */
static boolean covers(String family, int cp) {
if (family == null) {
return false;
}
return coverage(family).covers(cp);
}
private static Coverage coverage(String family) {
Coverage c = COVERAGE.get(family);
if (c == null) {
c = new Coverage(BundledFonts.awtFont(family, BundledFonts.V_REGULAR));
COVERAGE.put(family, c);
}
return c;
}
/**
* Покрытие одного семейства: {@code java.awt.Font.canDisplay} с кэшем
* «проверенных» кодов. AWT берётся вместо {@code GlyphCheck}, чтобы не
* плодить INFO-лог на каждый отсутствующий глиф.
*/
private static final class Coverage {
private final java.awt.Font font;
private final java.util.BitSet checked = new java.util.BitSet();
private final java.util.BitSet covered = new java.util.BitSet();
Coverage(java.awt.Font font) {
this.font = font;
}
boolean covers(int cp) {
if (font == null || cp < 0) {
return false;
}
if (checked.get(cp)) {
return covered.get(cp);
}
checked.set(cp);
if (font.canDisplay(cp)) {
covered.set(cp);
return true;
}
return false;
}
}
/** Часть текста рана; family == null — рисовать штатным шрифтом ранa. */
static final class Segment {
final String text;
/** Ключ бандл-семейства (lowercase) или null. */
final String family;
Segment(String text, String family) {
this.text = text;
this.family = family;
}
}
/**
* Бандл-семейство шрифта ранa (первое из {@code w:ascii}/{@code w:hAnsi})
* либо null, если рана шрифт не объявлен.
*/
private static String runFamily(String rPr) {
int rFonts = rPr.indexOf("<w:rFonts");
if (rFonts < 0) {
return null;
}
int end = rPr.indexOf('>', rFonts);
if (end < 0) {
return null;
}
Matcher m = FONT_ATTR.matcher(rPr.substring(rFonts, end));
if (!m.find()) {
return null;
}
return BundledFontMapper.bundledFamily(m.group(2));
}
/**
* Принудительно ставит семейство в {@code w:rPr}: заменяет атрибуты
* {@code w:rFonts}, а если их нет — вставляет элемент первым ребёнком.
*/
private static String forceFont(String rPr, String family) {
String name = BundledFontMapper.documentFontName(family);
String fonts = "<w:rFonts w:ascii=\"" + name + "\" w:hAnsi=\"" + name + "\"/>";
if (rPr.isEmpty()) {
return "<w:rPr>" + fonts + "</w:rPr>";
}
int start = rPr.indexOf("<w:rFonts");
if (start < 0) {
return rPr.replaceFirst("<w:rPr>", "<w:rPr>" + fonts);
}
int end = rPr.indexOf("/>", start);
int blockEnd = rPr.indexOf("</w:rFonts>", start);
if (blockEnd >= 0 && (end < 0 || blockEnd < end)) {
return rPr.substring(0, start) + fonts + rPr.substring(blockEnd + "</w:rFonts>".length());
}
if (end < 0) {
return rPr;
}
return rPr.substring(0, start) + fonts + rPr.substring(end + 2);
}
/** Атрибуты w:t: сохраняем исходные и добавляем preserve, если нужно. */
private static String attrs(String original, String segmentText) {
// Пустой после strip() сегмент — это тоже пробелы, их Word бы съел.
boolean needsPreserve = !segmentText.equals(segmentText.strip());
if (needsPreserve && !original.contains("xml:space")) {
return original + " xml:space=\"preserve\"";
}
return original;
}
/** Разворачивает XML-сущности текста в настоящие символы. */
private static String decode(String xmlText) {
if (xmlText.indexOf('&') < 0) {
return xmlText;
}
String result = NUMERIC_ENTITY.matcher(xmlText).replaceAll(mr -> {
int cp = Integer.parseInt(mr.group(2), mr.group(1).isEmpty() ? 10 : 16);
return Matcher.quoteReplacement(new String(Character.toChars(cp)));
});
return result.replace("&lt;", "<").replace("&gt;", ">")
.replace("&quot;", "\"").replace("&apos;", "'")
.replace("&amp;", "&");
}
/** Обратное {@link #decode}: текст снова безопасен для {@code w:t}. */
private static String encode(String text) {
return text.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;");
}
}
@@ -15,4 +15,12 @@
Источник: официальный tarball dejavu-fonts-ttf-2.37 (https://dejavu-fonts.github.io),
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.