#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum CjkLanguage {
Japanese,
SimplifiedChinese,
TraditionalChinese,
Korean,
}
impl CjkLanguage {
pub(crate) fn from_tag(tag: &str) -> Option<Self> {
let lower = tag.trim().to_ascii_lowercase();
let mut subtags = lower.split(['-', '_']);
match subtags.next()? {
"ja" => Some(CjkLanguage::Japanese),
"ko" => Some(CjkLanguage::Korean),
"yue" => Some(CjkLanguage::TraditionalChinese),
"zh" => {
let traditional = subtags.any(|s| matches!(s, "hant" | "tw" | "hk" | "mo"));
Some(if traditional {
CjkLanguage::TraditionalChinese
} else {
CjkLanguage::SimplifiedChinese
})
}
_ => None,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum Platform {
Windows,
MacOs,
Unix,
}
impl Platform {
pub(crate) const CURRENT: Platform = if cfg!(target_os = "windows") {
Platform::Windows
} else if cfg!(target_os = "macos") {
Platform::MacOs
} else {
Platform::Unix
};
}
fn families(platform: Platform, language: CjkLanguage) -> &'static [&'static str] {
use CjkLanguage::*;
match (platform, language) {
(Platform::Windows, Japanese) => &["Yu Gothic UI", "Yu Gothic", "Meiryo UI", "Meiryo"],
(Platform::Windows, SimplifiedChinese) => &["Microsoft YaHei UI", "Microsoft YaHei"],
(Platform::Windows, TraditionalChinese) => &["Microsoft JhengHei UI", "Microsoft JhengHei"],
(Platform::Windows, Korean) => &["Malgun Gothic"],
(Platform::MacOs, Japanese) => &["Hiragino Sans", "Hiragino Kaku Gothic ProN"],
(Platform::MacOs, SimplifiedChinese) => &["PingFang SC", "Hiragino Sans GB"],
(Platform::MacOs, TraditionalChinese) => &["PingFang TC", "PingFang HK"],
(Platform::MacOs, Korean) => &["Apple SD Gothic Neo"],
(Platform::Unix, Japanese) => &[
"Noto Sans CJK JP",
"Noto Sans JP",
"Source Han Sans JP",
"Source Han Sans J",
"IPAexGothic",
"IPAGothic",
"VL Gothic",
],
(Platform::Unix, SimplifiedChinese) => &[
"Noto Sans CJK SC",
"Noto Sans SC",
"Source Han Sans SC",
"Source Han Sans CN",
"WenQuanYi Zen Hei",
"WenQuanYi Micro Hei",
],
(Platform::Unix, TraditionalChinese) => &[
"Noto Sans CJK TC",
"Noto Sans TC",
"Source Han Sans TC",
"Source Han Sans TW",
"Noto Sans CJK HK",
],
(Platform::Unix, Korean) => &[
"Noto Sans CJK KR",
"Noto Sans KR",
"Source Han Sans KR",
"Source Han Sans K",
"NanumGothic",
"Nanum Gothic",
],
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum TableScript {
Kana,
Hangul,
Bopomofo,
Han,
}
fn table_script(ch: char) -> Option<TableScript> {
let script = match ch as u32 {
0x3040..=0x30FF | 0x31F0..=0x31FF | 0xFF65..=0xFF9F | 0x1AFF0..=0x1B16F => {
TableScript::Kana
}
0x1100..=0x11FF | 0x3130..=0x318F | 0xA960..=0xA97F | 0xAC00..=0xD7FF | 0xFFA0..=0xFFDC => {
TableScript::Hangul
}
0x3100..=0x312F | 0x31A0..=0x31BF => TableScript::Bopomofo,
0x2E80..=0x2FFF
| 0x3000..=0x303F
| 0x3190..=0x319F
| 0x31C0..=0x31EF
| 0x3200..=0x4DBF
| 0x4E00..=0x9FFF
| 0xF900..=0xFAFF
| 0xFE30..=0xFE4F
| 0xFF00..=0xFF64
| 0xFFE0..=0xFFEF
| 0x20000..=0x323AF => TableScript::Han,
_ => return None,
};
Some(script)
}
#[derive(Debug, Clone, Copy)]
pub(crate) struct ScriptContext<'a> {
paragraph: &'a str,
language: Option<CjkLanguage>,
tag: Option<&'a str>,
}
impl<'a> ScriptContext<'a> {
pub(crate) fn new(paragraph: &'a str, language: Option<CjkLanguage>) -> Self {
Self {
paragraph,
language,
tag: None,
}
}
pub(crate) fn in_language(paragraph: &'a str, tag: Option<&'a str>) -> Self {
Self {
paragraph,
language: tag.and_then(CjkLanguage::from_tag),
tag: tag.filter(|t| !t.trim().is_empty()),
}
}
pub(crate) fn language_tag(&self) -> Option<&'a str> {
self.tag
}
fn language_at(&self, pos: usize) -> Option<CjkLanguage> {
self.language
.or_else(|| nearest_kana_or_hangul(self.paragraph, pos))
}
}
fn nearest_kana_or_hangul(paragraph: &str, pos: usize) -> Option<CjkLanguage> {
let pos = pos.min(paragraph.len());
let (before, after) = (paragraph.get(..pos)?, paragraph.get(pos..)?);
let language = |ch: char| match table_script(ch) {
Some(TableScript::Kana) => Some(CjkLanguage::Japanese),
Some(TableScript::Hangul) => Some(CjkLanguage::Korean),
_ => None,
};
let ahead = after
.chars()
.enumerate()
.find_map(|(n, ch)| language(ch).map(|l| (n, l)));
let behind = before
.chars()
.rev()
.enumerate()
.find_map(|(n, ch)| language(ch).map(|l| (n + 1, l)));
match (behind, ahead) {
(Some((b, lb)), Some((a, la))) => {
if b < a || (b == a && lb == CjkLanguage::Japanese) {
Some(lb)
} else {
Some(la)
}
}
(one, other) => one.or(other).map(|(_, l)| l),
}
}
pub(crate) fn preferred_families(
ch: char,
context: &ScriptContext<'_>,
pos: usize,
default_language: Option<CjkLanguage>,
platform: Platform,
) -> &'static [&'static str] {
let language = match table_script(ch) {
None => return &[],
Some(TableScript::Kana) => CjkLanguage::Japanese,
Some(TableScript::Hangul) => CjkLanguage::Korean,
Some(TableScript::Bopomofo) => CjkLanguage::TraditionalChinese,
Some(TableScript::Han) => context
.language_at(pos)
.or(default_language)
.unwrap_or(CjkLanguage::SimplifiedChinese),
};
families(platform, language)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn tags_name_their_cjk_language() {
use CjkLanguage::*;
for (tag, language) in [
("ja", Some(Japanese)),
("ja-JP", Some(Japanese)),
("ko_KR", Some(Korean)),
("zh", Some(SimplifiedChinese)),
("zh-CN", Some(SimplifiedChinese)),
("zh-Hans-SG", Some(SimplifiedChinese)),
("zh-TW", Some(TraditionalChinese)),
("zh-Hant", Some(TraditionalChinese)),
("zh_HK", Some(TraditionalChinese)),
("yue", Some(TraditionalChinese)),
("fr-FR", None),
("", None),
] {
assert_eq!(CjkLanguage::from_tag(tag), language, "{tag:?}");
}
}
#[test]
fn han_takes_the_language_of_the_nearest_kana_or_hangul() {
let text = "日本語のテキスト、한국어 漢字";
let at = |s: &str| text.find(s).unwrap();
assert_eq!(
nearest_kana_or_hangul(text, at("日")),
Some(CjkLanguage::Japanese)
);
assert_eq!(
nearest_kana_or_hangul(text, at("漢")),
Some(CjkLanguage::Korean)
);
assert_eq!(nearest_kana_or_hangul("中文", 0), None);
}
#[test]
fn the_hosts_language_wins_over_the_paragraph() {
let context = ScriptContext::new("日本のテキスト", Some(CjkLanguage::SimplifiedChinese));
assert_eq!(
preferred_families('日', &context, 0, None, Platform::Unix)[0],
"Noto Sans CJK SC"
);
}
#[test]
fn han_alone_follows_the_default_language_then_simplified_chinese() {
let context = ScriptContext::new("中文", None);
assert_eq!(
preferred_families(
'中',
&context,
0,
Some(CjkLanguage::Japanese),
Platform::Windows
)[0],
"Yu Gothic UI"
);
assert_eq!(
preferred_families('中', &context, 0, None, Platform::MacOs)[0],
"PingFang SC"
);
}
#[test]
fn latin_has_no_table_entry() {
let context = ScriptContext::new("abc", None);
assert!(preferred_families('a', &context, 0, None, Platform::Unix).is_empty());
}
mod fallback {
use super::super::*;
use crate::font::registry::FontRegistry;
use crate::font::resolve::resolve_font;
use crate::shaping::shaper::{TextDirection, shape_text_in_paragraph};
use crate::types::FontFaceId;
const LATIN: &[u8] = include_bytes!("../../test-fonts/NotoSans-Variable.ttf");
const CJK: &[u8] = include_bytes!("../../test-fonts/NotoSansCJKkr-Mixed-subset.otf");
struct Faces {
registry: FontRegistry,
jp_bold: Option<FontFaceId>,
}
fn registry_with(families: &[(&str, u16)]) -> Faces {
let mut registry = FontRegistry::new_without_system_fonts();
let latin = registry.register_font(LATIN)[0];
registry.set_default_font(latin, 16.0);
let mut jp_bold = None;
for &(family, weight) in families {
let face = registry.register_font_as(CJK, family, weight, false)[0];
registry.treat_as_system(face);
if family == "Noto Sans CJK JP" && weight == 700 {
jp_bold = Some(face);
}
}
registry.set_fallback_platform(Platform::Unix);
Faces { registry, jp_bold }
}
fn system() -> Faces {
registry_with(&[
("BIZ UDGothic", 400),
("Noto Serif CJK KR", 400),
("Noto Sans CJK JP", 400),
("Noto Sans CJK JP", 700),
("Noto Sans CJK SC", 400),
("Noto Sans CJK TC", 400),
("Noto Sans CJK KR", 400),
])
}
fn faces_of(
faces: &Faces,
text: &str,
paragraph: &str,
at: usize,
language: Option<CjkLanguage>,
weight: u32,
) -> Vec<FontFaceId> {
let resolved = resolve_font(
&faces.registry,
None,
Some(weight),
None,
None,
None,
1.0,
1.0,
)
.unwrap();
let run = shape_text_in_paragraph(
&faces.registry,
&resolved,
text,
0,
TextDirection::Auto,
&[],
&ScriptContext::new(paragraph, language),
at,
)
.unwrap();
run.glyphs
.iter()
.filter(|g| g.glyph_id != 0 && g.font_face_id != resolved.font_face_id)
.map(|g| g.font_face_id)
.collect()
}
fn families_of(faces: &Faces, ids: &[FontFaceId]) -> Vec<String> {
ids.iter()
.map(|&id| faces.registry.font_family_name(id).unwrap())
.collect()
}
fn family(faces: &Faces, text: &str) -> String {
let families = families_of(faces, &faces_of(faces, text, text, 0, None, 400));
assert!(!families.is_empty(), "{text:?} fell back to nothing");
assert!(
families.iter().all(|f| *f == families[0]),
"{text:?} is drawn in {families:?}"
);
families[0].clone()
}
fn registry_of(bytes: &[(&str, Vec<u8>)], platform: Platform) -> Faces {
let mut registry = FontRegistry::new_without_system_fonts();
let latin = registry.register_font(LATIN)[0];
registry.set_default_font(latin, 16.0);
for (family, data) in bytes {
let face = registry.register_font_as(data, family, 400, false)[0];
registry.treat_as_system(face);
}
registry.set_fallback_platform(platform);
Faces {
registry,
jp_bold: None,
}
}
fn undrawable() -> Vec<u8> {
crate::font::color::with_tables(CJK, &[b"CFF "], &[b"hvgl"])
}
#[test]
fn the_table_skips_a_listed_face_that_cannot_be_drawn() {
let faces = registry_of(
&[
("PingFang SC", undrawable()),
("Hiragino Sans GB", CJK.to_vec()),
],
Platform::MacOs,
);
assert_eq!(family(&faces, "中你好"), "Hiragino Sans GB");
}
#[test]
fn the_coverage_search_skips_a_face_that_cannot_be_drawn() {
let faces = registry_of(
&[("Blank CJK", undrawable()), ("Drawn CJK", CJK.to_vec())],
Platform::Unix,
);
assert_eq!(family(&faces, "中你好"), "Drawn CJK");
}
#[test]
fn with_no_drawable_face_the_text_falls_back_to_nothing() {
let faces = registry_of(&[("Blank CJK", undrawable())], Platform::Unix);
let shaped = faces_of(&faces, "中你好", "中你好", 0, None, 400);
assert!(shaped.is_empty());
}
#[test]
fn chinese_text_picks_the_sc_face_over_a_jp_face_that_covers_it() {
assert_eq!(family(&system(), "中你好"), "Noto Sans CJK SC");
}
#[test]
fn a_japanese_paragraph_with_kana_picks_jp_for_its_han() {
let faces = system();
assert_eq!(family(&faces, "日本語のテキスト"), "Noto Sans CJK JP");
let paragraph = "日本語のテキスト";
let ids = faces_of(&faces, "日本語", paragraph, 0, None, 400);
assert_eq!(families_of(&faces, &ids), vec!["Noto Sans CJK JP"; 3]);
}
#[test]
fn korean_picks_kr_never_a_serif() {
let faces = system();
assert_eq!(family(&faces, "한국어"), "Noto Sans CJK KR");
let ids = faces_of(&faces, "日本 한글", "日本 한글", 0, None, 400);
assert_eq!(families_of(&faces, &ids), vec!["Noto Sans CJK KR"; 4]);
}
#[test]
fn the_blocks_language_and_the_default_language_decide_lone_han() {
let mut faces = system();
let ids = faces_of(
&faces,
"中你好",
"中你好",
0,
Some(CjkLanguage::Japanese),
400,
);
assert_eq!(families_of(&faces, &ids), vec!["Noto Sans CJK JP"; 3]);
faces.registry.set_default_language(Some("zh-TW"));
assert_eq!(family(&faces, "中你好"), "Noto Sans CJK TC");
faces.registry.set_default_language(Some("ko"));
assert_eq!(family(&faces, "中你好"), "Noto Sans CJK KR");
assert_eq!(family(&faces, "日本のテキスト"), "Noto Sans CJK JP");
}
#[test]
fn bold_text_picks_the_table_faces_bold() {
let faces = system();
let ids = faces_of(&faces, "日本の", "日本の", 0, None, 700);
assert_eq!(ids, vec![faces.jp_bold.unwrap(); 3]);
}
#[test]
fn with_no_table_face_installed_the_coverage_search_decides() {
let faces = registry_with(&[("BIZ UDGothic", 400), ("Noto Serif CJK KR", 400)]);
assert_eq!(family(&faces, "中你好"), "BIZ UDGothic");
assert_eq!(family(&faces, "한국어"), "BIZ UDGothic");
}
#[test]
fn a_face_the_host_registered_wins_over_the_table() {
let mut faces = system();
faces
.registry
.register_font_as(CJK, "App Sans CJK", 400, false);
for text in ["中你好", "日本のテキスト", "한국어"] {
assert_eq!(family(&faces, text), "App Sans CJK", "{text:?}");
}
}
fn block_families(
faces: &Faces,
fragments: &[(&str, bool)],
hyphenation: Option<crate::types::Hyphenation>,
) -> Vec<String> {
block_families_in(faces, fragments, hyphenation, None)
}
fn block_families_in(
faces: &Faces,
fragments: &[(&str, bool)],
hyphenation: Option<crate::types::Hyphenation>,
language: Option<&str>,
) -> Vec<String> {
use crate::layout::block::{BlockLayoutParams, FragmentParams, layout_block};
let mut text = String::new();
let mut params_fragments = Vec::new();
for &(piece, bold) in fragments {
params_fragments.push(FragmentParams {
text: piece.to_string(),
offset: text.len(),
length: piece.len(),
font_family: None,
font_weight: None,
font_bold: Some(bold),
font_italic: None,
font_point_size: None,
size_scale: 1.0,
underline_style: crate::types::UnderlineStyle::None,
overline: false,
strikeout: false,
is_link: false,
letter_spacing: 0.0,
word_spacing: 0.0,
foreground_color: None,
underline_color: None,
background_color: None,
anchor_href: None,
tooltip: None,
vertical_alignment: crate::types::VerticalAlignment::Normal,
image_name: None,
image_width: 0.0,
image_height: 0.0,
footnote_marker: None,
features: Vec::new(),
});
text.push_str(piece);
}
let params = BlockLayoutParams {
block_id: 1,
position: 0,
text,
fragments: params_fragments,
alignment: crate::layout::paragraph::Alignment::Left,
top_margin: 0.0,
bottom_margin: 0.0,
left_margin: 0.0,
right_margin: 0.0,
text_indent: 0.0,
list_marker: String::new(),
list_indent: 0.0,
tab_positions: Vec::new(),
base_direction: TextDirection::Auto,
line_height_multiplier: None,
non_breakable_lines: false,
hyphenation,
checkbox: None,
background_color: None,
neutral_direction: crate::shaping::shaper::TextDirection::Auto,
language: language.map(str::to_owned),
};
let block = layout_block(&faces.registry, ¶ms, 800.0, 1.0, 1.0);
let default = faces.registry.default_font();
let ids: Vec<FontFaceId> = block.lines[0]
.runs
.iter()
.flat_map(|run| run.shaped_run.glyphs.iter().map(|g| g.font_face_id))
.filter(|&id| Some(id) != default)
.collect();
families_of(faces, &ids)
}
#[test]
fn han_in_a_run_of_its_own_takes_the_kana_of_its_block() {
let faces = system();
let found = block_families(&faces, &[("日本語", true), ("のテキスト", false)], None);
assert_eq!(found.len(), 8, "{found:?}");
assert!(found.iter().all(|f| f == "Noto Sans CJK JP"), "{found:?}");
}
#[test]
fn the_blocks_language_wins_over_its_kana() {
let faces = system();
let found = block_families(
&faces,
&[("中のテキスト", false)],
Some(crate::types::Hyphenation::new(*b"zh")),
);
assert_eq!(found[0], "Noto Sans CJK SC", "{found:?}");
}
#[test]
fn the_blocks_language_decides_with_hyphenation_off() {
let faces = system();
let found = block_families_in(&faces, &[("中你好", false)], None, Some("ja"));
assert_eq!(found, vec!["Noto Sans CJK JP"; 3]);
}
#[test]
fn the_whole_tag_reaches_han_so_traditional_chinese_is_traditional() {
let faces = system();
let found = block_families_in(
&faces,
&[("中你好", false)],
Some(crate::types::Hyphenation::new(*b"zh")),
Some("zh-Hant"),
);
assert_eq!(found, vec!["Noto Sans CJK TC"; 3]);
}
#[test]
fn a_block_with_no_language_takes_its_hyphenations() {
let faces = system();
let found = block_families_in(
&faces,
&[("中你好", false)],
Some(crate::types::Hyphenation::new(*b"ko")),
None,
);
assert_eq!(found, vec!["Noto Sans CJK KR"; 3]);
}
#[test]
fn a_label_follows_the_services_default_language() {
use crate::{DocumentFlow, TextFontService, TextFormat};
let mut service = TextFontService::new_without_system_fonts();
service.font_registry = system().registry;
let label = |service: &mut TextFontService| {
let result = DocumentFlow::new().layout_single_line(
service,
"中你好",
&TextFormat::default(),
None,
1.0,
);
let ids: Vec<FontFaceId> =
result.glyph_keys.iter().map(|k| k.font_face_id).collect();
ids.iter()
.map(|&id| service.font_registry.font_family_name(id).unwrap())
.collect::<Vec<_>>()
};
assert_eq!(label(&mut service), vec!["Noto Sans CJK SC"; 3]);
service.set_default_language(Some("ja-JP"));
assert_eq!(label(&mut service), vec!["Noto Sans CJK JP"; 3]);
}
#[test]
fn a_label_takes_its_flows_language_over_the_services() {
use crate::{DocumentFlow, TextFontService, TextFormat};
let mut service = TextFontService::new_without_system_fonts();
service.font_registry = system().registry;
service.set_default_language(Some("ja-JP"));
let mut flow = DocumentFlow::new();
flow.set_default_language(Some("zh-Hant"));
let label = |flow: &mut DocumentFlow, service: &mut TextFontService| {
let single =
flow.layout_single_line(service, "中你好", &TextFormat::default(), None, 1.0);
let wrapped = flow.layout_paragraph(
service,
"中你好",
&TextFormat::default(),
400.0,
None,
1.0,
);
[single.glyph_keys, wrapped.glyph_keys]
.iter()
.flatten()
.map(|k| {
service
.font_registry
.font_family_name(k.font_face_id)
.unwrap()
})
.collect::<Vec<_>>()
};
assert_eq!(label(&mut flow, &mut service), vec!["Noto Sans CJK TC"; 6]);
flow.set_default_language(None);
assert_eq!(label(&mut flow, &mut service), vec!["Noto Sans CJK JP"; 6]);
}
}
}