OCP 2.10.18

offline-chess-puzzles - GUI to solve puzzles from the lichess puzzle database
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use fluent_bundle::FluentResource;
use fluent_bundle::bundle::FluentBundle;
use once_cell::sync::Lazy;
use unic_langid::langid;

static BUNDLE_ENUS: Lazy<FluentBundle<FluentResource, intl_memoizer::concurrent::IntlLangMemoizer>> = Lazy::new(|| {
	let source = include_str!("../include/translations/en-US/ocp.ftl").to_string();
	let res = FluentResource::try_new(source).expect("Could not parse the FTL file.");
	let mut bundle = FluentBundle::new_concurrent(vec![langid!("en-US")]);
	bundle.add_resource(res).expect("Failed to add FTL resources to the bundle.");
	bundle
});

static BUNDLE_NL: Lazy<FluentBundle<FluentResource, intl_memoizer::concurrent::IntlLangMemoizer>> = Lazy::new(|| {
	let source = include_str!("../include/translations/nl/ocp.ftl").to_string();
	let res = FluentResource::try_new(source).expect("Could not parse the FTL file.");
	let mut bundle = FluentBundle::new_concurrent(vec![langid!("nl")]);
	bundle.add_resource(res).expect("Failed to add FTL resources to the bundle.");
	bundle
});

static BUNDLE_PTBR: Lazy<FluentBundle<FluentResource, intl_memoizer::concurrent::IntlLangMemoizer>> = Lazy::new(|| {
	let source = include_str!("../include/translations/pt-BR/ocp.ftl").to_string();
	let res = FluentResource::try_new(source).expect("Could not parse the FTL file.");
	let mut bundle = FluentBundle::new_concurrent(vec![langid!("pt-BR")]);
	bundle.add_resource(res).expect("Failed to add FTL resources to the bundle.");
	bundle
});

static BUNDLE_ES: Lazy<FluentBundle<FluentResource, intl_memoizer::concurrent::IntlLangMemoizer>> = Lazy::new(|| {
	let source = include_str!("../include/translations/es/ocp.ftl").to_string();
	let res = FluentResource::try_new(source).expect("Could not parse the FTL file.");
	let mut bundle = FluentBundle::new_concurrent(vec![langid!("es")]);
	bundle.add_resource(res).expect("Failed to add FTL resources to the bundle.");
	bundle
});

static BUNDLE_FR: Lazy<FluentBundle<FluentResource, intl_memoizer::concurrent::IntlLangMemoizer>> = Lazy::new(|| {
	let source = include_str!("../include/translations/fr/ocp.ftl").to_string();
	let res = FluentResource::try_new(source).expect("Could not parse the FTL file.");
	let mut bundle = FluentBundle::new_concurrent(vec![langid!("fr")]);
	bundle.add_resource(res).expect("Failed to add FTL resources to the bundle.");
	bundle
});

pub fn tr(lang: &Language, key: &str) -> String {
	let bundle = match lang {
		Language::Portuguese => &BUNDLE_PTBR,
		Language::English => &BUNDLE_ENUS,
		Language::Dutch => &BUNDLE_NL,
		Language::Spanish => &BUNDLE_ES,
		Language::French => &BUNDLE_FR,
	};
	let msg = bundle.get_message(key).expect(&("Missing translation key ".to_owned() + key));
	let mut errors = vec![];
	let pattern = msg.value().expect("Missing Value.");
	bundle.format_pattern(pattern, None, &mut errors).to_string()
}

#[derive(Debug, Serialize, Deserialize, Clone, Copy, PartialEq, Eq)]
pub enum Language {
	Dutch,
	English,
	Portuguese,
	Spanish,
	French,
}

impl Language {
	pub const ALL: [Language; 5] = [Language::Dutch, Language::English, Language::Portuguese, Language::Spanish, Language::French];
}

impl DisplayTranslated for Language {
	fn to_str_tr(&self) -> &str {
		match self {
			Language::Dutch => "dutch",
			Language::English => "english",
			Language::Portuguese => "portuguese",
			Language::Spanish => "spanish",
			Language::French => "french",
		}
	}
}

#[derive(Debug, Clone)]
pub struct PickListWrapper<D: DisplayTranslated> {
	pub lang: Language,
	pub item: D,
}

pub trait DisplayTranslated {
	fn to_str_tr(&self) -> &str;
}

impl<D: DisplayTranslated> std::fmt::Display for PickListWrapper<D> {
	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
		f.write_str(&tr(&self.lang, self.item.to_str_tr()))
	}
}

impl<D: DisplayTranslated + std::cmp::PartialEq> PartialEq for PickListWrapper<D> {
	fn eq(&self, other: &Self) -> bool {
		self.item == other.item
	}
}

impl<D: DisplayTranslated + std::cmp::PartialEq> Eq for PickListWrapper<D> {}

impl PickListWrapper<Language> {
	pub fn get_langs(lang: Language) -> Vec<PickListWrapper<Language>> {
		let mut themes_wrapper = Vec::new();
		for item in Language::ALL {
			themes_wrapper.push(PickListWrapper::<Language> { lang, item });
		}
		themes_wrapper
	}

	pub fn new_lang(lang: Language, item: Language) -> Self {
		Self { lang, item }
	}
}