Merge branch 'rusty_popup' into 'master'

language selection popup

See merge request Librem5/squeekboard!190

src/action.rs

@@ -36,4 +36,5 @@ pub enum Action {
         /// The key events this symbol submits when submitting text is not possible
         keys: Vec<KeySym>,
     },
+    ShowPreferences,
 }

src/data.rs

@@ -509,10 +509,7 @@ fn create_action(
                 &view_names
             ),
         },
-        Some(Action::ShowPrefs) => ::action::Action::Submit {
-            text: None,
-            keys: Vec::new(),
-        },
+        Some(Action::ShowPrefs) => ::action::Action::ShowPreferences,
         None => ::action::Action::Submit {
             text: None,
             keys: keysyms.into_iter().map(::action::KeySym).collect(),

src/layout.h

@@ -62,7 +62,10 @@ const char *squeek_layout_get_keymap(const struct squeek_layout*);
 enum squeek_arrangement_kind squeek_layout_get_kind(const struct squeek_layout *);
 void squeek_layout_free(struct squeek_layout*);
 
-void squeek_layout_release(struct squeek_layout *layout, struct zwp_virtual_keyboard_v1 *virtual_keyboard, uint32_t timestamp, EekGtkKeyboard *ui_keyboard);
+void squeek_layout_release(struct squeek_layout *layout, struct zwp_virtual_keyboard_v1 *virtual_keyboard,
+                           struct transformation widget_to_layout,
+                           uint32_t timestamp,
+                           EekGtkKeyboard *ui_keyboard);
 void squeek_layout_release_all_only(struct squeek_layout *layout, struct zwp_virtual_keyboard_v1 *virtual_keyboard, uint32_t timestamp);
 void squeek_layout_depress(struct squeek_layout *layout, struct zwp_virtual_keyboard_v1 *virtual_keyboard,
                            double x_widget, double y_widget,

src/layout.rs

@@ -37,6 +37,7 @@ pub mod c {
     use std::ffi::CStr;
     use std::os::raw::{ c_char, c_void };
     use std::ptr;
+    use gtk_sys;
 
     // The following defined in C
 
@@ -45,7 +46,7 @@ pub mod c {
 
     #[repr(transparent)]
     #[derive(Copy, Clone)]
-    pub struct EekGtkKeyboard(*const c_void);
+    pub struct EekGtkKeyboard(pub *const gtk_sys::GtkWidget);
 
     /// Defined in eek-types.h
     #[repr(C)]
@@ -245,7 +246,7 @@ pub mod c {
             origin_y: f64,
             scale: f64,
         }
-        
+
         impl Transformation {
             fn forward(&self, p: Point) -> Point {
                 Point {
@@ -253,6 +254,25 @@ pub mod c {
                     y: (p.y - self.origin_y) / self.scale,
                 }
             }
+            fn reverse(&self, p: Point) -> Point {
+                Point {
+                    x: p.x * self.scale + self.origin_x,
+                    y: p.y * self.scale + self.origin_y,
+                }
+            }
+            pub fn reverse_bounds(&self, b: Bounds) -> Bounds {
+                let start = self.reverse(Point { x: b.x, y: b.y });
+                let end = self.reverse(Point {
+                    x: b.x + b.width,
+                    y: b.y + b.height,
+                });
+                Bounds {
+                    x: start.x,
+                    y: start.y,
+                    width: end.x - start.x,
+                    height: end.y - start.y,
+                }
+            }
         }
 
         // This is constructed only in C, no need for warnings
@@ -319,28 +339,30 @@ pub mod c {
             }
         }
 
+        /// Release pointer in the specified position
         #[no_mangle]
         pub extern "C"
         fn squeek_layout_release(
             layout: *mut Layout,
             virtual_keyboard: ZwpVirtualKeyboardV1, // TODO: receive a reference to the backend
+            widget_to_layout: Transformation,
             time: u32,
             ui_keyboard: EekGtkKeyboard,
         ) {
+            let time = Timestamp(time);
             let layout = unsafe { &mut *layout };
             let virtual_keyboard = VirtualKeyboard(virtual_keyboard);
             // The list must be copied,
             // because it will be mutated in the loop
             for key in layout.pressed_keys.clone() {
                 let key: &Rc<RefCell<KeyState>> = key.borrow();
-                layout.release_key(
+                ui::release_key(
+                    layout,
                     &virtual_keyboard,
-                    &mut key.clone(),
-                    Timestamp(time)
-                );
-                let view = layout.get_current_view();
-                ::layout::procedures::release_ui_buttons(
-                    &view, key, ui_keyboard,
+                    &widget_to_layout,
+                    time,
+                    ui_keyboard,
+                    key
                 );
             }
         }
@@ -418,6 +440,7 @@ pub mod c {
             time: u32,
             ui_keyboard: EekGtkKeyboard,
         ) {
+            let time = Timestamp(time);
             let layout = unsafe { &mut *layout };
             let virtual_keyboard = VirtualKeyboard(virtual_keyboard);
 
@@ -442,36 +465,30 @@ pub mod c {
                     if Rc::ptr_eq(&state, &wrapped_key.0) {
                         found = true;
                     } else {
-                        layout.release_key(
+                        ui::release_key(
+                            layout,
                             &virtual_keyboard,
-                            &mut key.clone(), 
-                            Timestamp(time),
-                        );
-                        let view = layout.get_current_view();
-                        ::layout::procedures::release_ui_buttons(
-                            &view, key, ui_keyboard,
+                            &widget_to_layout,
+                            time,
+                            ui_keyboard,
+                            key,
                         );
                     }
                 }
                 if !found {
-                    layout.press_key(
-                        &virtual_keyboard,
-                        &mut state,
-                        Timestamp(time),
-                    );
+                    layout.press_key(&virtual_keyboard, &mut state, time);
                     unsafe { eek_gtk_on_button_pressed(c_place, ui_keyboard) };
                 }
             } else {
                 for wrapped_key in pressed {
                     let key: &Rc<RefCell<KeyState>> = wrapped_key.borrow();
-                    layout.release_key(
+                    ui::release_key(
+                        layout,
                         &virtual_keyboard,
-                        &mut key.clone(), 
-                        Timestamp(time),
-                    );
-                    let view = layout.get_current_view();
-                    ::layout::procedures::release_ui_buttons(
-                        &view, key, ui_keyboard,
+                        &widget_to_layout,
+                        time,
+                        ui_keyboard,
+                        key,
                     );
                 }
             }
@@ -503,6 +520,28 @@ pub mod c {
                 }
             }
         }
+
+        #[cfg(test)]
+        mod test {
+            use super::*;
+            
+            fn near(a: f64, b: f64) -> bool {
+                (a - b).abs() < ((a + b) * 0.001f64).abs()
+            }
+            
+            #[test]
+            fn transform_back() {
+                let transform = Transformation {
+                    origin_x: 10f64,
+                    origin_y: 11f64,
+                    scale: 12f64,
+                };
+                let point = Point { x: 1f64, y: 1f64 };
+                let transformed = transform.reverse(transform.forward(point.clone()));
+                assert!(near(point.x, transformed.x));
+                assert!(near(point.y, transformed.y));
+            }
+        }
     }
 }
 
@@ -717,6 +756,12 @@ pub struct Layout {
     pub keymap_str: CString,
     // Changeable state
     // a Vec would be enough, but who cares, this will be small & fast enough
+    // TODO: turn those into per-input point *_buttons to track dragging.
+    // The renderer doesn't need the list of pressed keys any more,
+    // because it needs to iterate
+    // through all buttons of the current view anyway.
+    // When the list tracks actual location,
+    // it becomes possible to place popovers and other UI accurately.
     pub pressed_keys: HashSet<::util::Pointer<RefCell<KeyState>>>,
     pub locked_keys: HashSet<::util::Pointer<RefCell<KeyState>>>,
 }
@@ -949,6 +994,64 @@ mod procedures {
             );
         }
     }
+    
+    pub fn get_button_bounds(
+        view: &View,
+        row: &Row,
+        button: &Button
+    ) -> Option<c::Bounds> {
+        match &row.bounds {
+            Some(row) => Some(c::Bounds {
+                x: view.bounds.x + row.x + button.bounds.x,
+                y: view.bounds.y + row.y + button.bounds.y,
+                width: button.bounds.width,
+                height: button.bounds.height,
+            }),
+            _ => None,
+        }
+    }
+}
+
+/// Top level UI procedures
+mod ui {
+    use super::*;
+
+    // TODO: turn into release_button
+    pub fn release_key(
+        layout: &mut Layout,
+        virtual_keyboard: &VirtualKeyboard,
+        widget_to_layout: &c::procedures::Transformation,
+        time: Timestamp,
+        ui_keyboard: c::EekGtkKeyboard,
+        key: &Rc<RefCell<KeyState>>,
+    ) {
+        layout.release_key(virtual_keyboard, &mut key.clone(), time);
+
+        let view = layout.get_current_view();
+        let action = RefCell::borrow(key).action.clone();
+        if let Action::ShowPreferences = action {
+            let paths = ::layout::procedures::find_key_paths(
+                view, key
+            );
+            // getting first item will cause mispositioning
+            // with more than one button with the same key
+            // on the keyboard
+            if let Some((row, button)) = paths.get(0) {
+                let bounds = ::layout::procedures::get_button_bounds(
+                    view, row, button
+                ).unwrap_or_else(|| {
+                    eprintln!("BUG: Clicked button has no position?");
+                    c::Bounds { x: 0f64, y: 0f64, width: 0f64, height: 0f64 }
+                });
+                ::popover::show(
+                    ui_keyboard,
+                    widget_to_layout.reverse_bounds(bounds)
+                );
+            }
+        }
+        
+        procedures::release_ui_buttons(view, key, ui_keyboard);
+    }
 }
 
 #[cfg(test)]

src/lib.rs

@@ -1,8 +1,14 @@
 #[macro_use]
 extern crate bitflags;
+extern crate gio;
+extern crate glib;
+extern crate glib_sys;
+extern crate gtk;
+extern crate gtk_sys;
 #[allow(unused_imports)]
 #[macro_use] // only for tests
 extern crate maplit;
+extern crate regex;
 extern crate serde;
 extern crate xkbcommon;
 
@@ -12,7 +18,10 @@ pub mod float_ord;
 pub mod imservice;
 mod keyboard;
 mod layout;
+mod locale;
+mod locale_config;
 mod outputs;
+mod popover;
 mod resources;
 mod submission;
 mod util;

src/locale.rs

@@ -0,0 +1,39 @@
+/*! Locale-specific functions */
+
+use std::cmp;
+use std::ffi::CString;
+
+mod c {
+    use std::os::raw::c_char;
+
+    #[allow(non_camel_case_types)]
+    pub type c_int = i32;
+
+    #[no_mangle]
+    extern "C" {
+        // from libc
+        pub fn strcoll(cs: *const c_char, ct: *const c_char) -> c_int;
+    }
+}
+
+fn cstring_safe(s: &str) -> CString {
+    CString::new(s)
+        .unwrap_or(CString::new("").unwrap())
+}
+
+pub fn compare_current_locale(a: &str, b: &str) -> cmp::Ordering {
+    let a = cstring_safe(a);
+    let b = cstring_safe(b);
+    let a = a.as_ptr();
+    let b = b.as_ptr();
+    let result = unsafe { c::strcoll(a, b) };
+    if result == 0 {
+        cmp::Ordering::Equal
+    } else if result > 0 {
+        cmp::Ordering::Greater
+    } else if result < 0 {
+        cmp::Ordering::Less
+    } else {
+        unreachable!()
+    }
+}

src/locale_config.rs

@@ -0,0 +1,541 @@
+/*! Locale detection and management.
+ * Based on https://github.com/rust-locale/locale_config
+ * 
+ * Ready for deletion/replacement once Debian starts packaging this,
+ * although this version doesn't need lazy_static.
+ * 
+ * Copyright (c) 2016–2019 Jan Hudec <bulb@ucw.cz>
+   Copyright (c) 2016 A.J. Gardner <aaron.j.gardner@gmail.com>
+   Copyright (c) 2019, Bastien Orivel <eijebong@bananium.fr>
+   Copyright (c) 2019, Igor Gnatenko <i.gnatenko.brain@gmail.com>
+   Copyright (c) 2019, Sophie Tauchert <999eagle@999eagle.moe>
+ */
+
+use regex::Regex;
+use std::borrow::Cow;
+use std::env;
+
+/// Errors that may be returned by `locale_config`.
+#[derive(Copy,Clone,Debug,PartialEq,Eq)]
+pub enum Error {
+    /// Provided definition was not well formed.
+    ///
+    /// This is returned when provided configuration string does not match even the rather loose
+    /// definition for language range from [RFC4647] or the composition format used by `Locale`.
+    ///
+    /// [RFC4647]: https://www.rfc-editor.org/rfc/rfc4647.txt
+    NotWellFormed,
+    /// Placeholder for adding more errors in future. **Do not match!**.
+    __NonExhaustive,
+}
+
+impl ::std::fmt::Display for Error {
+    fn fmt(&self, out: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+        use ::std::error::Error;
+        out.write_str(self.description())
+    }
+}
+
+impl ::std::error::Error for Error {
+    fn description(&self) -> &str {
+        match self {
+            &Error::NotWellFormed => "Language tag is not well-formed.",
+            // this is exception: here we do want exhaustive match so we don't publish version with
+            // missing descriptions by mistake.
+            &Error::__NonExhaustive => panic!("Placeholder error must not be instantiated!"),
+        }
+    }
+}
+
+/// Convenience Result alias.
+type Result<T> = ::std::result::Result<T, Error>;
+
+/// Iterator over `LanguageRange`s for specific category in a `Locale`
+///
+/// Returns `LanguageRange`s in the `Locale` that are applicable to provided category. The tags
+/// are returned in order of preference, which means the category-specific ones first and then
+/// the generic ones.
+///
+/// The iterator is guaranteed to return at least one value.
+pub struct TagsFor<'a, 'c> {
+    src: &'a str,
+    tags: std::str::Split<'a, &'static str>,
+    category: Option<&'c str>,
+}
+
+impl<'a, 'c> Iterator for TagsFor<'a, 'c> {
+    type Item = LanguageRange<'a>;
+    fn next(&mut self) -> Option<Self::Item> {
+        if let Some(cat) = self.category {
+            while let Some(s) = self.tags.next() {
+                if s.starts_with(cat) && s[cat.len()..].starts_with("=") {
+                    return Some(
+                        LanguageRange { language: Cow::Borrowed(&s[cat.len()+1..]) });
+                }
+            }
+            self.category = None;
+            self.tags = self.src.split(",");
+        }
+        while let Some(s) = self.tags.next() {
+            if s.find('=').is_none() {
+                return Some(
+                    LanguageRange{ language: Cow::Borrowed(s) });
+            }
+        }
+        return None;
+    }
+}
+
+/// Language and culture identifier.
+///
+/// This object holds a [RFC4647] extended language range.
+///
+/// The internal data may be owned or shared from object with lifetime `'a`. The lifetime can be
+/// extended using the `into_static()` method, which internally clones the data as needed.
+///
+/// # Syntax
+///
+/// The range is composed of `-`-separated alphanumeric subtags, possibly replaced by `*`s. It
+/// might be empty.
+///
+/// In agreement with [RFC4647], this object only requires that the tag matches:
+///
+/// ```ebnf
+/// language_tag = (alpha{1,8} | "*")
+///                ("-" (alphanum{1,8} | "*"))*
+/// ```
+///
+/// The exact interpretation is up to the downstream localization provider, but it expected that
+/// it will be matched against a normalized [RFC5646] language tag, which has the structure:
+///
+/// ```ebnf
+/// language_tag    = language
+///                   ("-" script)?
+///                   ("-" region)?
+///                   ("-" variant)*
+///                   ("-" extension)*
+///                   ("-" private)?
+///
+/// language        = alpha{2,3} ("-" alpha{3}){0,3}
+///
+/// script          = aplha{4}
+///
+/// region          = alpha{2}
+///                 | digit{3}
+///
+/// variant         = alphanum{5,8}
+///                 | digit alphanum{3}
+///
+/// extension       = [0-9a-wyz] ("-" alphanum{2,8})+
+///
+/// private         = "x" ("-" alphanum{1,8})+
+/// ```
+///
+///  * `language` is an [ISO639] 2-letter or, where not defined, 3-letter code. A code for
+///     macro-language might be followed by code of specific dialect.
+///  * `script` is an [ISO15924] 4-letter code.
+///  * `region` is either an [ISO3166] 2-letter code or, for areas other than countries, [UN M.49]
+///    3-digit numeric code.
+///  * `variant` is a string indicating variant of the language.
+///  * `extension` and `private` define additional options. The private part has same structure as
+///    the Unicode [`-u-` extension][u_ext]. Available options are documented for the facets that
+///    use them.
+///
+/// The values obtained by inspecting the system are normalized according to those rules.
+///
+/// The content will be case-normalized as recommended in [RFC5646] §2.1.1, namely:
+///
+///  * `language` is written in lowercase,
+///  * `script` is written with first capital,
+///  * `country` is written in uppercase and
+///  * all other subtags are written in lowercase.
+///
+/// When detecting system configuration, additional options that may be generated under the
+/// [`-u-` extension][u_ext] currently are:
+///
+/// * `cf` — Currency format (`account` for parenthesized negative values, `standard` for minus
+///   sign).
+/// * `fw` — First day of week (`mon` to `sun`).
+/// * `hc` — Hour cycle (`h12` for 1–12, `h23` for 0–23).
+/// * `ms` — Measurement system (`metric` or `ussystem`).
+/// * `nu` — Numbering system—only decimal systems are currently used.
+/// * `va` — Variant when locale is specified in Unix format and the tag after `@` does not
+///   correspond to any variant defined in [Language subtag registry].
+///
+/// And under the `-x-` extension, following options are defined:
+///
+/// * `df` — Date format:
+///
+///     * `iso`: Short date should be in ISO format of `yyyy-MM-dd`.
+///
+///     For example `-df-iso`.
+///
+/// * `dm` — Decimal separator for monetary:
+///
+///     Followed by one or more Unicode codepoints in hexadecimal. For example `-dm-002d` means to
+///     use comma.
+///
+/// * `ds` — Decimal separator for numbers:
+///
+///     Followed by one or more Unicode codepoints in hexadecimal. For example `-ds-002d` means to
+///     use comma.
+///
+/// * `gm` — Group (thousand) separator for monetary:
+///
+///     Followed by one or more Unicode codepoints in hexadecimal. For example `-dm-00a0` means to
+///     use non-breaking space.
+///
+/// * `gs` — Group (thousand) separator for numbers:
+///
+///     Followed by one or more Unicode codepoints in hexadecimal. For example `-ds-00a0` means to
+///     use non-breaking space.
+///
+/// * `ls` — List separator:
+///
+///     Followed by one or more Unicode codepoints in hexadecimal. For example, `-ds-003b` means to
+///     use a semicolon.
+///
+/// [RFC5646]: https://www.rfc-editor.org/rfc/rfc5646.txt
+/// [RFC4647]: https://www.rfc-editor.org/rfc/rfc4647.txt
+/// [ISO639]: https://en.wikipedia.org/wiki/ISO_639
+/// [ISO15924]: https://en.wikipedia.org/wiki/ISO_15924
+/// [ISO3166]: https://en.wikipedia.org/wiki/ISO_3166
+/// [UN M.49]: https://en.wikipedia.org/wiki/UN_M.49
+/// [u_ext]: http://www.unicode.org/reports/tr35/#u_Extension
+/// [Language subtag registry]: https://www.iana.org/assignments/language-subtag-registry/language-subtag-registry
+#[derive(Clone,Debug,Eq,Hash,PartialEq)]
+pub struct LanguageRange<'a> {
+    language: Cow<'a, str>
+}
+
+impl<'a> LanguageRange<'a> {
+    /// Return LanguageRange for the invariant locale.
+    ///
+    /// Invariant language is identified simply by empty string.
+    pub fn invariant() -> LanguageRange<'static> {
+        LanguageRange { language: Cow::Borrowed("") }
+    }
+
+    /// Create language tag from Unix/Linux/GNU locale tag.
+    ///
+    /// Unix locale tags have the form
+    ///
+    /// > *language* [ `_` *region* ] [ `.` *encoding* ] [ `@` *variant* ]
+    ///
+    /// The *language* and *region* have the same format as RFC5646. *Encoding* is not relevant
+    /// here, since Rust always uses Utf-8. That leaves *variant*, which is unfortunately rather
+    /// free-form. So this function will translate known variants to corresponding RFC5646 subtags
+    /// and represent anything else with Unicode POSIX variant (`-u-va-`) extension.
+    ///
+    /// Note: This function is public here for benefit of applications that may come across this
+    /// kind of tags from other sources than system configuration.
+    pub fn from_unix(s: &str) -> Result<LanguageRange<'static>> {
+        let unix_tag_regex = Regex::new(r"(?ix) ^
+            (?P<language> [[:alpha:]]{2,3} )
+            (?: _  (?P<region> [[:alpha:]]{2} | [[:digit:]]{3} ))?
+            (?: \. (?P<encoding> [0-9a-zA-Z-]{1,20} ))?
+            (?: @  (?P<variant> [[:alnum:]]{1,20} ))?
+        $ ").unwrap();
+        
+        let unix_invariant_regex = Regex::new(r"(?ix) ^
+            (?: c | posix )
+            (?: \. (?: [0-9a-zA-Z-]{1,20} ))?
+        $ ").unwrap();
+        
+        if let Some(caps) = unix_tag_regex.captures(s) {
+            let src_variant = caps.name("variant").map(|m| m.as_str()).unwrap_or("").to_ascii_lowercase();
+            let mut res = caps.name("language").map(|m| m.as_str()).unwrap().to_ascii_lowercase();
+            let region = caps.name("region").map(|m| m.as_str()).unwrap_or("");
+            let mut script = "";
+            let mut variant = "";
+            let mut uvariant = "";
+            match src_variant.as_ref() {
+            // Variants seen in the wild in GNU LibC (via http://lh.2xlibre.net/) or in Debian
+            // GNU/Linux Stretch system. Treatment of things not found in RFC5646 subtag registry
+            // (http://www.iana.org/assignments/language-subtag-registry/language-subtag-registry)
+            // or CLDR according to notes at https://wiki.openoffice.org/wiki/LocaleMapping.
+            // Dialects:
+                // aa_ER@saaho - NOTE: Can't be found under that name in RFC5646 subtag registry,
+                // but there is language Saho with code ssy, which is likely that thing.
+                "saaho" if res == "aa" => res = String::from("ssy"),
+            // Scripts:
+                // @arabic
+                "arabic" => script = "Arab",
+                // @cyrillic
+                "cyrl" => script = "Cyrl",
+                "cyrillic" => script = "Cyrl",
+                // @devanagari
+                "devanagari" => script = "Deva",
+                // @hebrew
+                "hebrew" => script = "Hebr",
+                // tt@iqtelif
+                // Neither RFC5646 subtag registry nor CLDR knows anything about this, but as best
+                // as I can tell it is Tatar name for Latin (default is Cyrillic).
+                "iqtelif" => script = "Latn",
+                // @Latn
+                "latn" => script = "Latn",
+                // @latin
+                "latin" => script = "Latn",
+                // en@shaw
+                "shaw" => script = "Shaw",
+            // Variants:
+                // sr@ijekavianlatin
+                "ijekavianlatin" => {
+                    script = "Latn";
+                    variant = "ijekavsk";
+                },
+                // sr@ije
+                "ije" => variant = "ijekavsk",
+                // sr@ijekavian
+                "ijekavian" => variant = "ijekavsk",
+                // ca@valencia
+                "valencia" => variant = "valencia",
+            // Currencies:
+                // @euro - NOTE: We follow suite of Java and Openoffice and ignore it, because it
+                // is default for all locales where it sometimes appears now, and because we use
+                // explicit currency in monetary formatting anyway.
+                "euro" => {},
+            // Collation:
+                // gez@abegede - NOTE: This is collation, but CLDR does not have any code for it,
+                // so we for the moment leave it fall through as -u-va- instead of -u-co-.
+            // Anything else:
+                // en@boldquot, en@quot, en@piglatin - just randomish stuff
+                // @cjknarrow - beware, it's gonna end up as -u-va-cjknarro due to lenght limit
+                s if s.len() <= 8 => uvariant = &*s,
+                s => uvariant = &s[0..8], // the subtags are limited to 8 chars, but some are longer
+            };
+            if script != "" {
+                res.push('-');
+                res.push_str(script);
+            }
+            if region != "" {
+                res.push('-');
+                res.push_str(&*region.to_ascii_uppercase());
+            }
+            if variant != "" {
+                res.push('-');
+                res.push_str(variant);
+            }
+            if uvariant != "" {
+                res.push_str("-u-va-");
+                res.push_str(uvariant);
+            }
+            return Ok(LanguageRange {
+                language: Cow::Owned(res)
+            });
+        } else if unix_invariant_regex.is_match(s) {
+            return Ok(LanguageRange::invariant())
+        } else {
+            return Err(Error::NotWellFormed);
+        }
+    }
+}
+
+impl<'a> AsRef<str> for LanguageRange<'a> {
+    fn as_ref(&self) -> &str {
+        self.language.as_ref()
+    }
+}
+
+/// Locale configuration.
+///
+/// Users may accept several languages in some order of preference and may want to use rules from
+/// different culture for some particular aspect of the program behaviour, and operating systems
+/// allow them to specify this (to various extent).
+///
+/// The `Locale` objects represent the user configuration. They contain:
+///
+///  - The primary `LanguageRange`.
+///  - Optional category-specific overrides.
+///  - Optional fallbacks in case data (usually translations) for the primary language are not
+///    available.
+///
+/// The set of categories is open-ended. The `locale` crate uses five well-known categories
+/// `messages`, `numeric`, `time`, `collate` and `monetary`, but some systems define additional
+/// ones (GNU Linux has additionally `paper`, `name`, `address`, `telephone` and `measurement`) and
+/// these are provided in the user default `Locale` and other libraries can use them.
+///
+/// `Locale` is represented by a `,`-separated sequence of tags in `LanguageRange` syntax, where
+/// all except the first one may be preceded by category name and `=` sign.
+///
+/// The first tag indicates the default locale, the tags prefixed by category names indicate
+/// _overrides_ for those categories and the remaining tags indicate fallbacks.
+///
+/// Note that a syntactically valid value of HTTP `Accept-Language` header is a valid `Locale`. Not
+/// the other way around though due to the presence of category selectors.
+// TODO: Interning
+#[derive(Clone,Debug,Eq,Hash,PartialEq)]
+pub struct Locale {
+    // TODO: Intern the string for performance reasons
+    // XXX: Store pre-split to LanguageTags?
+    inner: String,
+}
+
+impl Locale {
+    /// Construct invariant locale.
+    ///
+    /// Invariant locale is represented simply with empty string.
+    pub fn invariant() -> Locale {
+        Locale::from(LanguageRange::invariant())
+    }
+
+    /// Append fallback language tag.
+    ///
+    /// Adds fallback to the end of the list.
+    pub fn add(&mut self, tag: &LanguageRange) {
+        for i in self.inner.split(',') {
+            if i == tag.as_ref() {
+                return; // don't add duplicates
+            }
+        }
+        self.inner.push_str(",");
+        self.inner.push_str(tag.as_ref());
+    }
+
+    /// Append category override.
+    ///
+    /// Appending new override for a category that already has one will not replace the existing
+    /// override. This might change in future.
+    pub fn add_category(&mut self, category: &str, tag: &LanguageRange) {
+        if self.inner.split(',').next().unwrap() == tag.as_ref() {
+            return; // don't add useless override equal to the primary tag
+        }
+        for i in self.inner.split(',') {
+            if i.starts_with(category) &&
+                    i[category.len()..].starts_with("=") &&
+                    &i[category.len() + 1..] == tag.as_ref() {
+                return; // don't add duplicates
+            }
+        }
+        self.inner.push_str(",");
+        self.inner.push_str(category);
+        self.inner.push_str("=");
+        self.inner.push_str(tag.as_ref());
+    }
+
+    /// Iterate over `LanguageRange`s in this `Locale` applicable to given category.
+    ///
+    /// Returns `LanguageRange`s in the `Locale` that are applicable to provided category. The tags
+    /// are returned in order of preference, which means the category-specific ones first and then
+    /// the generic ones.
+    ///
+    /// The iterator is guaranteed to return at least one value.
+    pub fn tags_for<'a, 'c>(&'a self, category: &'c str) -> TagsFor<'a, 'c> {
+        let mut tags = self.inner.split(",");
+        while let Some(s) = tags.clone().next() {
+            if s.starts_with(category) && s[category.len()..].starts_with("=") {
+                return TagsFor {
+                    src: self.inner.as_ref(),
+                    tags: tags,
+                    category: Some(category),
+                };
+            }
+            tags.next();
+        }
+        return TagsFor {
+            src: self.inner.as_ref(),
+            tags: self.inner.split(","),
+            category: None,
+        };
+    }
+}
+
+/// Locale is specified by a string tag. This is the way to access it.
+// FIXME: Do we want to provide the full string representation? We would have it as single string
+// then.
+impl AsRef<str> for Locale {
+    fn as_ref(&self) -> &str {
+        self.inner.as_ref()
+    }
+}
+
+impl<'a> From<LanguageRange<'a>> for Locale {
+    fn from(t: LanguageRange<'a>) -> Locale {
+        Locale {
+            inner: t.language.into_owned(),
+        }
+    }
+}
+
+fn tag(s: &str) -> Result<LanguageRange> {
+    LanguageRange::from_unix(s)
+}
+
+// TODO: Read /etc/locale.alias
+fn tag_inv(s: &str) -> LanguageRange {
+    tag(s).unwrap_or(LanguageRange::invariant())
+}
+
+pub fn system_locale() -> Option<Locale> {
+    // LC_ALL overrides everything
+    if let Ok(all) = env::var("LC_ALL") {
+        if let Ok(t) = tag(all.as_ref()) {
+            return Some(Locale::from(t));
+        }
+    }
+    // LANG is default
+    let mut loc =
+        if let Ok(lang) = env::var("LANG") {
+            Locale::from(tag_inv(lang.as_ref()))
+        } else {
+            Locale::invariant()
+        };
+    // category overrides
+    for &(cat, var) in [
+        ("ctype",       "LC_CTYPE"),
+        ("numeric",     "LC_NUMERIC"),
+        ("time",        "LC_TIME"),
+        ("collate",     "LC_COLLATE"),
+        ("monetary",    "LC_MONETARY"),
+        ("messages",    "LC_MESSAGES"),
+        ("paper",       "LC_PAPER"),
+        ("name",        "LC_NAME"),
+        ("address",     "LC_ADDRESS"),
+        ("telephone",   "LC_TELEPHONE"),
+        ("measurement", "LC_MEASUREMENT"),
+    ].iter() {
+        if let Ok(val) = env::var(var) {
+            if let Ok(tag) = tag(val.as_ref())
+            {
+                loc.add_category(cat, &tag);
+            }
+        }
+    }
+    // LANGUAGE defines fallbacks
+    if let Ok(langs) = env::var("LANGUAGE") {
+        for i in langs.split(':') {
+            if i != "" {
+                if let Ok(tag) = tag(i) {
+                    loc.add(&tag);
+                }
+            }
+        }
+    }
+    if loc.as_ref() != "" {
+        return Some(loc);
+    } else {
+        return None;
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::LanguageRange;
+
+    #[test]
+    fn unix_tags() {
+        assert_eq!("cs-CZ", LanguageRange::from_unix("cs_CZ.UTF-8").unwrap().as_ref());
+        assert_eq!("sr-RS-ijekavsk", LanguageRange::from_unix("sr_RS@ijekavian").unwrap().as_ref());
+        assert_eq!("sr-Latn-ijekavsk", LanguageRange::from_unix("sr.UTF-8@ijekavianlatin").unwrap().as_ref());
+        assert_eq!("en-Arab", LanguageRange::from_unix("en@arabic").unwrap().as_ref());
+        assert_eq!("en-Arab", LanguageRange::from_unix("en.UTF-8@arabic").unwrap().as_ref());
+        assert_eq!("de-DE", LanguageRange::from_unix("DE_de.UTF-8@euro").unwrap().as_ref());
+        assert_eq!("ssy-ER", LanguageRange::from_unix("aa_ER@saaho").unwrap().as_ref());
+        assert!(LanguageRange::from_unix("foo_BAR").is_err());
+        assert!(LanguageRange::from_unix("en@arabic.UTF-8").is_err());
+        assert_eq!("", LanguageRange::from_unix("C").unwrap().as_ref());
+        assert_eq!("", LanguageRange::from_unix("C.UTF-8").unwrap().as_ref());
+        assert_eq!("", LanguageRange::from_unix("C.ISO-8859-1").unwrap().as_ref());
+        assert_eq!("", LanguageRange::from_unix("POSIX").unwrap().as_ref());
+    }
+}

src/popover.h

@@ -0,0 +1,9 @@
+#ifndef POPOVER_H__
+#define POPOVER_H__
+
+#include <gtk/gtk.h>
+#include "eek/eek-keyboard.h"
+
+void squeek_popover_show(GtkWidget*, struct button_place);
+
+#endif

src/popover.rs

@@ -0,0 +1,190 @@
+/*! The layout chooser popover */
+
+use gio;
+use gtk;
+use ::layout::c::EekGtkKeyboard;
+use ::locale::compare_current_locale;
+use ::locale_config::system_locale;
+use ::resources;
+
+use gio::ActionExt;
+use gio::ActionMapExt;
+use gio::SettingsExt;
+use glib::translate::FromGlibPtrNone;
+use glib::variant::ToVariant;
+use gtk::PopoverExt;
+use gtk::WidgetExt;
+use std::io::Write;
+
+mod variants {
+    use glib;
+    use glib_sys;
+
+    use glib::translate::FromGlibPtrFull;
+    use glib::translate::ToGlibPtr;
+
+    /// Unpacks tuple & array variants
+    fn get_items(items: glib::Variant) -> Vec<glib::Variant> {
+        let variant_naked = items.to_glib_none().0;
+        let count = unsafe { glib_sys::g_variant_n_children(variant_naked) };
+        (0..count).map(|index| 
+            unsafe {
+                glib::Variant::from_glib_full(
+                    glib_sys::g_variant_get_child_value(variant_naked, index)
+                )
+            }
+        ).collect()
+    }
+
+    /// Unpacks "a(ss)" variants
+    pub fn get_tuples(items: glib::Variant) -> Vec<(String, String)> {
+        get_items(items)
+            .into_iter()
+            .map(get_items)
+            .map(|v| {
+                (
+                    v[0].get::<String>().unwrap(),
+                    v[1].get::<String>().unwrap(),
+                )
+            })
+            .collect()
+    }
+}
+
+fn make_menu_builder(inputs: Vec<(&str, &str)>) -> gtk::Builder {
+    let mut xml: Vec<u8> = Vec::new();
+    writeln!(
+        xml,
+        "<?xml version=\"1.0\" encoding=\"UTF-8\"?>
+<interface>
+  <menu id=\"app-menu\">
+    <section>"
+    ).unwrap();
+    for (input_name, human_name) in inputs {
+        writeln!(
+            xml,
+            "
+        <item>
+            <attribute name=\"label\" translatable=\"yes\">{}</attribute>
+            <attribute name=\"action\">layout</attribute>
+            <attribute name=\"target\">{}</attribute>
+        </item>",
+            human_name,
+            input_name,
+        ).unwrap();
+    }
+    writeln!(
+        xml,
+        "
+    </section>
+  </menu>
+</interface>"
+    ).unwrap();
+    gtk::Builder::new_from_string(
+        &String::from_utf8(xml).expect("Bad menu definition")
+    )
+}
+
+fn set_layout(kind: String, name: String) {
+    let settings = gio::Settings::new("org.gnome.desktop.input-sources");
+    let inputs = settings.get_value("sources").unwrap();
+    let inputs = variants::get_tuples(inputs).into_iter();
+    for (index, (ikind, iname)) in inputs.enumerate() {
+        if (&ikind, &iname) == (&kind, &name) {
+            settings.set_uint("current", index as u32);
+        }
+    }
+    settings.apply();
+}
+
+pub fn show(window: EekGtkKeyboard, position: ::layout::c::Bounds) {
+    unsafe { gtk::set_initialized() };
+    let window = unsafe { gtk::Widget::from_glib_none(window.0) };
+
+    let settings = gio::Settings::new("org.gnome.desktop.input-sources");
+    let inputs = settings.get_value("sources").unwrap();
+    let current = settings.get_uint("current") as usize;
+    let inputs = variants::get_tuples(inputs);
+    
+    let input_names: Vec<&str> = inputs.iter()
+        .map(|(_kind, name)| name.as_str())
+        .collect();
+
+    let translations = system_locale()
+        .map(|locale|
+            locale.tags_for("messages")
+                .next().unwrap() // guaranteed to exist
+                .as_ref()
+                .to_owned()
+        )
+        .and_then(|lang| resources::get_layout_names(lang.as_str()));
+
+    // sorted collection of human and machine names
+    let mut human_names: Vec<(&str, &str)> = match translations {
+        Some(translations) => {
+            input_names.iter()
+                .map(|name| (*name, *translations.get(name).unwrap_or(name)))
+                .collect()
+        },
+        // display bare codes
+        None => {
+            input_names.iter()
+                .map(|n| (*n, *n)) // turns &&str into &str
+                .collect()
+        }
+    };
+
+    human_names.sort_unstable_by(|(_, human_label_a), (_, human_label_b)| {
+        compare_current_locale(human_label_a, human_label_b)
+    });
+
+    let builder = make_menu_builder(human_names);
+    // Much more debuggable to populate the model & menu
+    // from a string representation
+    // than add items imperatively
+    let model: gio::MenuModel = builder.get_object("app-menu").unwrap();
+
+    let menu = gtk::Popover::new_from_model(Some(&window), &model);
+    menu.set_pointing_to(&gtk::Rectangle {
+        x: position.x.ceil() as i32,
+        y: position.y.ceil() as i32,
+        width: position.width.floor() as i32,
+        height: position.width.floor() as i32,
+    });
+
+    let initial_state = input_names[current].to_variant();
+
+    let layout_action = gio::SimpleAction::new_stateful(
+        "layout",
+        Some(initial_state.type_()),
+        &initial_state,
+    );
+
+    let action_group = gio::SimpleActionGroup::new();
+    action_group.add_action(&layout_action);
+
+    menu.insert_action_group("popup", Some(&action_group));
+    menu.bind_model(Some(&model), Some("popup"));
+
+    menu.connect_closed(move |_menu| {
+        let state = match layout_action.get_state() {
+            Some(v) => {
+                let s = v.get::<String>().or_else(|| {
+                    eprintln!("Variant is not string: {:?}", v);
+                    None
+                });
+                // FIXME: the `get_state` docs call for unrefing,
+                // but the function is nowhere to be found
+                // glib::Variant::unref(v);
+                s
+            },
+            None => {
+                eprintln!("No variant selected");
+                None
+            },
+        };
+        set_layout("xkb".into(), state.unwrap_or("us".into()));
+    });
+
+    menu.popup();
+}

src/resources.rs

@@ -2,6 +2,13 @@
  * This could be done using GResource, but that would need additional work.
  */
 
+use std::collections::HashMap;
+
+use std::iter::FromIterator;
+
+// TODO: keep a list of what is a language layout,
+// and what a convenience layout. "_wide" is not a layout,
+// neither is "number"
 const KEYBOARDS: &[(*const str, *const str)] = &[
     ("us", include_str!("../data/keyboards/us.yaml")),
     ("us_wide", include_str!("../data/keyboards/us_wide.yaml")),
@@ -28,3 +35,76 @@ pub fn get_keyboard(needle: &str) -> Option<&'static str> {
             unsafe { &*value }
         })
 }
+
+/// Translations of the layout identifier strings
+const LAYOUT_NAMES: &[(*const str, *const str)] = &[
+    ("en-US", include_str!("../data/langs/en-US.txt")),
+    ("pl-PL", include_str!("../data/langs/pl-PL.txt")),
+];
+
+pub fn get_layout_names(lang: &str)
+    -> Option<HashMap<&'static str, &'static str>>
+{
+    let translations = LAYOUT_NAMES.iter()
+        .find(|(name, _data)| {
+            let name: *const str = *name;
+            (unsafe { &*name }) == lang
+        })
+        .map(|(_name, data)| {
+            let data: *const str = *data;
+            unsafe { &*data }
+        });
+    translations.map(make_mapping)
+}
+
+fn parse_line(line: &str) -> Option<(&str, &str)> {
+    let comment = line.trim().starts_with("#");
+    if comment {
+        None
+    } else {
+        let mut iter = line.splitn(2, " ");
+        let name = iter.next().unwrap();
+        // will skip empty and unfinished lines
+        iter.next().map(|tr| (name, tr.trim()))
+    }
+}
+
+fn make_mapping(data: &str) -> HashMap<&str, &str> {
+    HashMap::from_iter(
+        data.split("\n")
+            .filter_map(parse_line)
+    )
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn mapping_line() {
+        assert_eq!(
+            Some(("name", "translation")),
+            parse_line("name translation")
+        );
+    }
+
+    #[test]
+    fn mapping_bad() {
+        assert_eq!(None, parse_line("bad"));
+    }
+
+    #[test]
+    fn mapping_empty() {
+        assert_eq!(None, parse_line(""));
+    }
+
+    #[test]
+    fn mapping_comment() {
+        assert_eq!(None, parse_line("# comment"));
+    }
+
+    #[test]
+    fn mapping_comment_offset() {
+        assert_eq!(None, parse_line("  # comment"));
+    }
+}

src/submission.rs

@@ -23,6 +23,7 @@ pub mod c {
     }
 }
 
+#[derive(Clone, Copy)]
 pub struct Timestamp(pub u32);
 
 /// Layout-independent backend. TODO: Have one instance per program or seat