d84914ef1e5a
i18n.rs
//! UI text lookup over the optional shared craft-i18n catalogs.
//! Missing translations and builds without catalogs use the English source text.
use std::fmt::Display;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::{LazyLock, OnceLock};
include!(concat!(env!("OUT_DIR"), "/craft_i18n.rs"));
static I18N: LazyLock<craft_i18n::I18n> = LazyLock::new(|| {
let offered: Vec<_> = LANGUAGES.iter().map(|l| l.code).collect();
let (i18n, problems) = craft_i18n::I18n::new(CRAFT_I18N, &offered);
for problem in problems {
log::warn!("translation catalog: {problem}");
}
i18n
});
static SHARED_LANGUAGES: OnceLock<[craft_i18n::Lang; COUNT]> = OnceLock::new();
/// Resolve the fixed picker codes once; hot text lookups only load the cached language handle.
fn shared_languages() -> &'static [craft_i18n::Lang; COUNT] {
SHARED_LANGUAGES.get_or_init(|| LANGUAGES.each_ref().map(|l| I18N.from_code(l.code).unwrap_or(craft_i18n::Lang::EN)))
}
/// Whether this build embeds a catalog for a supported language.
pub fn available(code: &str) -> bool {
I18N.from_code(code).is_some()
}
pub struct Language {
/// BCP 47 code ("en", "pt-BR", "zh-Hans").
pub code: &'static str,
/// The language's own name, for the picker.
pub name: &'static str,
/// Its English name (the picker's fallback when no font can draw `name`).
pub english: &'static str,
}
const COUNT: usize = 10;
pub static LANGUAGES: [Language; COUNT] = [
Language { code: "en", name: "English", english: "English" },
Language { code: "fr", name: "Français", english: "French" },
Language { code: "de", name: "Deutsch", english: "German" },
Language { code: "es", name: "Español", english: "Spanish" },
Language { code: "pt-BR", name: "Português (Brasil)", english: "Portuguese (Brazil)" },
Language { code: "it", name: "Italiano", english: "Italian" },
Language { code: "ja", name: "日本語", english: "Japanese" },
Language { code: "zh-Hans", name: "简体中文", english: "Chinese (Simplified)" },
Language { code: "ko", name: "한국어", english: "Korean" },
Language { code: "ar", name: "العربية", english: "Arabic" },
];
static CURRENT: AtomicUsize = AtomicUsize::new(0);
/// Display labels belong to the UI; the model exposes only map identities
pub(crate) fn baked_map_label(map: texturecraft_engine::core::BakedMap) -> &'static str {
use texturecraft_engine::core::BakedMap;
match map {
BakedMap::Normal => n_("Normal"),
BakedMap::WorldNormal => n_("World Space Normal"),
BakedMap::Id => n_("ID"),
BakedMap::AmbientOcclusion => n_("Ambient Occlusion"),
BakedMap::Curvature => n_("Curvature"),
BakedMap::Position => n_("Position"),
BakedMap::Thickness => n_("Thickness"),
BakedMap::Height => n_("Height"),
BakedMap::BentNormal => n_("Bent Normals"),
BakedMap::Opacity => n_("Opacity"),
}
}
/// The saved language that follows the operating system's (Settings > Language > Default (System Language)).
pub const SYSTEM_LANGUAGE: &str = "";
/// Switch the UI language ([`SYSTEM_LANGUAGE`] follows the system; unknown codes fall back to English).
pub fn set_language(code: &str) {
let code = if code == SYSTEM_LANGUAGE { system_language() } else { code };
CURRENT.store(LANGUAGES.iter().position(|l| l.code.eq_ignore_ascii_case(code) && available(l.code)).unwrap_or(0), Ordering::Relaxed);
}
/// The current UI language.
pub fn current() -> &'static Language {
LANGUAGES.get(CURRENT.load(Ordering::Relaxed)).unwrap_or(&LANGUAGES[0])
}
/// `text` in the current language (unchanged when it has no translation).
pub fn tr(text: &str) -> &str {
let lang = shared_languages().get(CURRENT.load(Ordering::Relaxed)).copied().unwrap_or(craft_i18n::Lang::EN);
I18N.t(lang, text)
}
/// Marks a static string for translation where it is defined (gettext's `N_`); it is translated
/// with [`tr`] where it is shown. The key test collects both.
pub const fn n_(text: &'static str) -> &'static str {
text
}
/// `template` translated, with each `{name}` replaced by its value in `args`.
pub fn trf(template: &str, args: &[(&str, &dyn Display)]) -> String {
let values: Vec<_> = args.iter().map(|(name, value)| (*name, value.to_string())).collect();
let args: Vec<_> = values.iter().map(|(name, value)| (*name, value.as_str())).collect();
craft_i18n::fmt(tr(template), &args)
}
/// An undo step's label in the current language. A label with a layer name, path number or
/// smart mask name in it ("Paint on Rust") is matched to its engine template, which is translated
/// and filled in again; any other label is translated as it is.
pub fn tr_history(label: &str) -> String {
tr_history_with(label, |text| tr(text).to_string())
}
/// [`tr_history`] with its own lookup `translate`
fn tr_history_with(label: &str, translate: impl Fn(&str) -> String) -> String {
match history_template(label) {
Some((template, name, value)) => craft_i18n::fmt(&translate(template), &[(name, value)]),
None => translate(label),
}
}
/// The engine template a history label was made from, its placeholder name and the value in it.
/// The template with the longest fixed start wins.
fn history_template(label: &str) -> Option<(&'static str, &'static str, &str)> {
texturecraft_engine::HISTORY_TEMPLATES
.iter()
.filter_map(|template| {
let (open, close) = (template.find('{')?, template.find('}')?);
let (prefix, suffix) = (&template[..open], &template[close + 1..]);
let value = label.strip_prefix(prefix)?.strip_suffix(suffix)?;
Some((prefix.len(), *template, &template[open + 1..close], value))
})
.max_by_key(|(prefix_length, ..)| *prefix_length)
.map(|(_, template, name, value)| (template, name, value))
}
/// The supported language for a locale such as "de-AT", "pt_BR.UTF-8" or "zh-Hant-TW" ("en" when
/// none matches). Chinese locales get Simplified Chinese; Portuguese ones get Brazilian Portuguese.
pub fn language_for_locale(locale: &str) -> &'static str {
let lang = locale.split(['-', '_', '.', '@']).next().unwrap_or("").to_ascii_lowercase();
match lang.as_str() {
"pt" => "pt-BR",
"zh" => "zh-Hans",
l => LANGUAGES.iter().find(|x| x.code == l).map_or("en", |x| x.code),
}
}
/// The operating system's (or browser's) UI language, for the first run.
pub fn os_language() -> &'static str {
#[cfg(not(target_arch = "wasm32"))]
let locale = sys_locale::get_locale();
#[cfg(target_arch = "wasm32")]
let locale = web_sys::window().and_then(|w| w.navigator().language());
locale.map_or("en", |l| language_for_locale(&l))
}
/// [`os_language`] read once: the language is applied every frame.
fn system_language() -> &'static str {
static SYSTEM: OnceLock<&'static str> = OnceLock::new();
SYSTEM.get_or_init(os_language)
}
/// Tests that switch the global UI language, or draw the UI under it, run one at a time.
#[cfg(test)]
pub(crate) static TEST_LANGUAGE: std::sync::Mutex<()> = std::sync::Mutex::new(());
#[cfg(test)]
mod tests {
use super::TEST_LANGUAGE as LANGUAGE;
use super::*;
use std::collections::{BTreeSet, HashMap};
/// Every key the UI looks up: `tr("…")` / `trf("…"` literals in the sources, plus the
/// static catalogs whose labels are translated where they are shown.
fn keys() -> Vec<String> {
let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("src");
let mut keys = Vec::new();
let mut directories = vec![dir];
while let Some(directory) = directories.pop() {
for entry in std::fs::read_dir(directory).unwrap() {
let path = entry.unwrap().path();
if path.is_dir() && path.file_name().is_some_and(|name| name != "i18n") {
directories.push(path);
} else if path.extension().is_some_and(|extension| extension == "rs") {
literals(&std::fs::read_to_string(path).unwrap(), &mut keys);
}
}
}
keys.extend(catalog_keys().into_iter().map(str::to_owned));
keys.sort();
keys.dedup();
keys
}
/// The labels of the menu catalog, panels, shortcuts, shelf tabs and engine enums that are
/// translated where they are shown.
fn catalog_keys() -> Vec<&'static str> {
use texturecraft_engine::core::{
BlendMode, Channel, EffectKind, GeneratorKind, ProceduralKind, TileBlending, TileInputDistribution, TileShape, TileSizeMode, TileSymmetry,
};
use texturecraft_engine::filter_lib::{FILTERS, build, scalar_params};
let mut keys: Vec<&'static str> = Vec::new();
keys.extend(crate::menus::TOP);
for item in crate::menus::CATALOG.iter().filter(|item| item.label != "-") {
keys.push(item.label);
keys.extend(item.sub);
}
keys.extend(crate::docking::VIEWS.iter().map(|(_, panel)| panel.name()));
for binding in crate::keymap::bindings() {
keys.push(binding.label);
keys.push(binding.group);
}
keys.extend(crate::shelf::TABS.iter().map(|tab| tab.2));
keys.extend(Channel::ALL.iter().flat_map(|channel| [channel.label(), channel.short()]));
keys.extend(BlendMode::all().map(|mode| mode.label()));
keys.extend(texturecraft_engine::formats::export::VirtualMap::ALL.iter().map(|map| map.label()));
keys.extend(texturecraft_engine::Tool::ALL.iter().map(|tool| tool.label()));
keys.extend(texturecraft_engine::HISTORY_TEMPLATES);
keys.extend(ProceduralKind::ALL.iter().map(|kind| kind.label()));
keys.extend(GeneratorKind::ALL.iter().map(|kind| kind.label()));
keys.extend(TileShape::ALL.iter().map(|shape| shape.label()));
keys.extend(TileSizeMode::ALL.iter().map(|mode| mode.label()));
keys.extend(TileInputDistribution::ALL.iter().map(|distribution| distribution.label()));
keys.extend(TileSymmetry::ALL.iter().map(|symmetry| symmetry.label()));
keys.extend(TileBlending::ALL.iter().map(|blending| blending.label()));
keys.extend(texturecraft_engine::paint::BrushAlpha::ALL.iter().map(|alpha| alpha.label()));
keys.extend(texturecraft_engine::geom::primitives::BUILTINS.iter().map(|(_, label)| *label));
for filter in FILTERS {
keys.extend([filter.label, filter.group]);
if let Ok(EffectKind::Filter(effect)) = build(filter.id, &serde_json::Value::Null) {
keys.push(effect.label());
keys.extend(scalar_params(&effect).into_iter().map(|parameter| parameter.1));
}
}
// Include effect, view and camera names supplied by the engine
keys.extend([
"Paint",
"Path",
"Fill",
"Generator",
"Levels",
"Color selection",
"Compare mask",
"Anchor point",
"Layer mask",
texturecraft_engine::camera_cmds::DEFAULT_CAMERA,
crate::dock::SOLO_HINT,
]);
keys.retain(|key| !key.is_empty() && !UNTRANSLATED.contains(key));
keys
}
/// String literals passed straight to `tr(` or `trf(` in `src`.
fn literals(src: &str, out: &mut Vec<String>) {
let src = src
.split(
"#[cfg(test)]
mod tests",
)
.next()
.unwrap_or(src);
for pat in ["tr(", "trf(", "n_("] {
let mut rest = src;
while let Some(i) = rest.find(pat) {
let before = rest[..i].chars().next_back();
rest = rest[i + pat.len()..].trim_start();
if before.is_some_and(|c| c.is_alphanumeric() || c == '_') {
continue;
}
let Some(after) = rest.strip_prefix('"') else { continue };
rest = after;
let mut s = String::new();
let mut chars = rest.chars();
while let Some(c) = chars.next() {
match c {
'"' => break,
'\\' => match chars.next() {
Some('n') => s.push('\n'),
Some(c) => s.push(c),
None => break,
},
c => s.push(c),
}
}
out.push(s);
}
}
}
#[test]
fn the_system_language_setting_speaks_the_operating_system_language() {
let _language = LANGUAGE.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
set_language(SYSTEM_LANGUAGE);
let shown = current().code;
set_language("en");
let expected = if available(os_language()) { os_language() } else { "en" };
assert_eq!(shown, expected);
}
#[test]
fn embedded_catalogs_are_valid() {
assert!(I18N.check_all().is_empty(), "{:?}", I18N.check_all());
}
/// Translation work never blocks a feature: report missing/stale keys without failing.
#[test]
fn translation_coverage_report() {
let keys = keys();
assert!(keys.len() > 300, "found only {} keys", keys.len());
let used: BTreeSet<_> = keys.iter().map(String::as_str).collect();
for &(locale, common, app) in CRAFT_I18N {
let Some(lang) = I18N.from_code(locale) else { continue };
let missing: Vec<_> = keys.iter().filter(|key| I18N.get(lang, "", key).is_none()).collect();
// Decode TSV escapes to compare with literal source strings
let mut rows = HashMap::new();
for text in [common, app] {
for line in text.lines().filter(|l| !l.starts_with('#')) {
let columns: Vec<_> = line.split('\t').collect();
if let ["", source, _] = columns.as_slice() {
let mut decoded = String::new();
let mut chars = source.chars();
while let Some(c) = chars.next() {
decoded.push(if c == '\\' {
match chars.next() {
Some('n') => '\n',
Some('t') => '\t',
Some(c) => c,
None => '\\',
}
} else {
c
});
}
rows.insert(decoded, ());
}
}
}
let stale: Vec<_> = rows.keys().filter(|key| !used.contains(key.as_str())).collect();
eprintln!("{locale}: missing {} {missing:?}; unused/shared {} {stale:?}", missing.len(), stale.len());
}
}
#[test]
fn history_labels_are_matched_to_their_templates() {
assert_eq!(history_template("Paint on Rust"), Some(("Paint on {layer}", "layer", "Rust")));
assert_eq!(history_template("Paint on Paint mask of x"), Some(("Paint on {layer}", "layer", "Paint mask of x")));
assert_eq!(history_template("Paint mask of Paint on x"), Some(("Paint mask of {layer}", "layer", "Paint on x")));
assert_eq!(history_template("Erase mask of Rust"), Some(("Erase mask of {layer}", "layer", "Rust")));
assert_eq!(history_template("Edit path 2"), Some(("Edit path {n}", "n", "2")));
assert_eq!(history_template("Apply smart mask Dirt"), Some(("Apply smart mask {name}", "name", "Dirt")));
assert_eq!(history_template("Rename layer"), None);
}
/// The template is translated and the layer name filled in; other labels are translated whole
#[test]
fn history_labels_with_a_layer_name_are_translated_through_their_template() {
let translate = |text: &str| {
match text {
"Paint on {layer}" => "Auf {layer} malen",
"Paint mask of {layer}" => "Maske von {layer} malen",
"Remove layer" => "Ebene entfernen",
other => other,
}
.to_string()
};
assert_eq!(tr_history_with("Paint on Rust", translate), "Auf Rust malen");
assert_eq!(tr_history_with("Paint mask of Paint on x", translate), "Maske von Paint on x malen");
assert_eq!(tr_history_with("Remove layer", translate), "Ebene entfernen");
assert_eq!(tr_history_with("Clone on Rust", translate), "Clone on Rust");
assert_eq!(tr_history_with("Paint on {layer}", translate), "Auf {layer} malen");
}
const UNTRANSLATED: &[&str] = &["RGB", "RGBA"];
#[test]
fn lookup_formatting_and_fallbacks() {
let _lock = LANGUAGE.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
set_language("xx");
assert_eq!(current().code, "en");
assert_eq!(tr("Layers"), "Layers");
assert_eq!(trf("Saved {path}", &[("path", &"a.tcraft")]), "Saved a.tcraft");
assert_eq!(trf("{a} of {b} {c}", &[("a", &1), ("b", &2)]), "1 of 2 {c}");
assert_eq!(trf("{unclosed", &[]), "{unclosed");
for (locale, code) in
[("de-AT", "de"), ("pt_PT.UTF-8", "pt-BR"), ("zh-Hant-TW", "zh-Hans"), ("ja", "ja"), ("ko_KR", "ko"), ("ar-EG", "ar"), ("nl-NL", "en"), ("", "en")]
{
assert_eq!(language_for_locale(locale), code, "{locale}");
}
set_language("de");
assert_eq!(current().code, if available("de") { "de" } else { "en" });
assert_eq!(tr("not a key"), "not a key");
set_language("en");
}
#[test]
fn shared_lookup_overrides_and_missing_translations() {
static CATALOGS: &craft_i18n::Embedded = &[("es", "\tSave\tGuardar\n\tOpen\tAbrir\n", "\tSave\tGuardar proyecto\n")];
let (runtime, problems) = craft_i18n::I18n::new(CATALOGS, &["es"]);
assert!(problems.is_empty());
assert!(runtime.check_all().is_empty());
let lang = runtime.from_code("es").unwrap();
assert_eq!(runtime.t(lang, "Save"), "Guardar proyecto");
assert_eq!(runtime.t(lang, "Open"), "Abrir");
assert_eq!(runtime.t(lang, "New feature"), "New feature");
assert_eq!(runtime.t(craft_i18n::Lang::EN, "Save"), "Save");
}
#[test]
fn saved_language_codes_and_spanish_lookup() {
let _lock = LANGUAGE.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
for language in &LANGUAGES {
set_language(language.code);
assert_eq!(current().code, if available(language.code) { language.code } else { "en" });
}
set_language("es");
assert_eq!(tr("Layers"), if available("es") { "Capas" } else { "Layers" });
set_language("en");
}
#[test]
fn lookup_is_fast() {
let _lock = LANGUAGE.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
let keys = keys();
set_language("ja");
let started = std::time::Instant::now();
let mut total_chars = 0usize;
for _ in 0..100 {
for key in &keys {
total_chars += tr(key).len();
}
}
let ns_per_lookup = started.elapsed().as_secs_f64() * 1e9 / (100 * keys.len()) as f64;
set_language("en");
assert!(total_chars > 0);
// A frame looks up a few hundred strings, each expected below one microsecond
assert!(ns_per_lookup < 1000.0, "{ns_per_lookup:.0} ns per lookup");
}
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.