faststep 0.1.0

UIKit-inspired embedded UI framework built on embedded-graphics
Documentation 
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

/// A localizable label with a stable lookup key and fallback text.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Localized<'a> {
    /// Stable localization key.
    pub key: &'a str,
    /// Fallback text used when no translation is available.
    pub fallback: &'a str,
}

impl<'a> Localized<'a> {
    /// Creates a new localized label.
    pub const fn new(key: &'a str, fallback: &'a str) -> Self {
        Self { key, fallback }
    }
}

/// One translated string in a locale table.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Translation<'a> {
    /// Stable localization key.
    pub key: &'a str,
    /// Resolved localized text.
    pub value: &'a str,
}

/// Translation table for one locale identifier.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct LocaleTable<'a> {
    /// Locale identifier, for example `"en"` or `"pl"`.
    pub id: &'a str,
    /// All translated entries for the locale.
    pub entries: &'a [Translation<'a>],
}

/// Small runtime localizer used by widgets and views.
#[derive(Clone, Copy, Debug)]
pub struct I18n<'a> {
    locale: &'a str,
    fallback_locale: &'a str,
    locales: &'a [LocaleTable<'a>],
}

impl<'a> I18n<'a> {
    /// Creates a new localization runtime.
    pub const fn new(
        locale: &'a str,
        fallback_locale: &'a str,
        locales: &'a [LocaleTable<'a>],
    ) -> Self {
        Self {
            locale,
            fallback_locale,
            locales,
        }
    }

    /// Returns the currently selected locale identifier.
    pub const fn locale(&self) -> &'a str {
        self.locale
    }

    /// Changes the active locale identifier.
    pub fn set_locale(&mut self, locale: &'a str) {
        self.locale = locale;
    }

    /// Resolves a [`Localized`] label into text.
    pub fn text(&self, label: Localized<'a>) -> &'a str {
        self.lookup(self.locale, label.key)
            .or_else(|| self.lookup(self.fallback_locale, label.key))
            .unwrap_or(label.fallback)
    }

    fn lookup(&self, locale: &str, key: &str) -> Option<&'a str> {
        let table = self.locales.iter().find(|table| table.id == locale)?;
        table
            .entries
            .iter()
            .find(|entry| entry.key == key)
            .map(|entry| entry.value)
    }
}