improve: Use use once_cell::sync::Lazy for scancode labels

This means the `Key::refresh()` doesn't require a reference to the
`Picker`.

Author: ids1024

src/application/key.rs

@@ -4,7 +4,7 @@ use std::{
 };
 
 use super::page::Page;
-use super::picker::Picker;
+use super::picker::SCANCODE_LABELS;
 use super::rect::Rect;
 
 #[derive(Clone, Debug)]
@@ -59,16 +59,16 @@ button {{
         )
     }
 
-    pub fn refresh(&self, picker: &Picker) {
+    pub fn refresh(&self) {
         for (layer, (_button, label)) in self.gtk.iter() {
             label.set_label(match layer {
                 Page::Layer1 => {
                     let scancode_name = &self.scancodes[0].1;
-                    picker.get_text(scancode_name).unwrap_or(scancode_name)
+                    SCANCODE_LABELS.get(scancode_name).unwrap_or(scancode_name)
                 },
                 Page::Layer2 => {
                     let scancode_name = &self.scancodes[1].1;
-                    picker.get_text(scancode_name).unwrap_or(scancode_name)
+                    SCANCODE_LABELS.get(scancode_name).unwrap_or(scancode_name)
                 },
                 Page::Keycaps => &self.physical_name,
                 Page::Logical => &self.logical_name,

src/application/keyboard.rs

@@ -258,14 +258,13 @@ impl Keyboard {
         self.keymap().contains_key(scancode_name)
     }
 
-    pub fn keymap_set(&self, picker: &Picker, key_index: usize, layer: usize, scancode_name: &str) {
-        // XXX avoid reference to Picker
+    pub fn keymap_set(&self, key_index: usize, layer: usize, scancode_name: &str) {
         let mut keys = self.inner().keys.borrow_mut();
         let k = &mut keys[key_index];
         let mut found = false;
         if let Some(scancode) = self.keymap().get(scancode_name) {
             k.scancodes[layer] = (*scancode, scancode_name.to_string());
-            k.refresh(&picker);
+            k.refresh();
             found = true;
         }
         if !found {
@@ -377,6 +376,7 @@ impl Keyboard {
 
                 let mut keys = self.inner().keys.borrow_mut();
                 let k = &mut keys[i];
+                k.refresh();
                 k.gtk.insert(page, (button, label));
             }
         }
@@ -388,12 +388,6 @@ impl Keyboard {
             Some(picker) => picker.downgrade(),
             None => WeakRef::new(),
         };
-
-        for k in self.inner().keys.borrow().iter() {
-            if let Some(picker) = self.inner().picker.borrow().upgrade() {
-                k.refresh(&picker);
-            }
-        }
     }
 
     fn set_selected(&self, i: Option<usize>) {

src/application/picker/mod.rs

@@ -6,8 +6,9 @@ use glib::subclass::prelude::*;
 use gtk::prelude::*;
 use gtk::subclass::prelude::*;
 use glib::translate::{FromGlibPtrFull, ToGlib, ToGlibPtr};
+use once_cell::sync::Lazy;
 use std::{
-    cell::{Cell, RefCell},
+    cell::RefCell,
     collections::HashMap,
     rc::Rc,
 };
@@ -33,6 +34,24 @@ button {
 }
 "#;
 
+pub static SCANCODE_LABELS: Lazy<HashMap<String, String>> = Lazy::new(|| {
+    let mut labels = HashMap::new();
+    for record in picker_csv() {
+        match record {
+            PickerCsv::Group { .. } => {}
+            PickerCsv::Key { name, top, bottom } => {
+                let text = if bottom.is_empty() {
+                    top
+                } else {
+                    format!("{}\n{}", top, bottom)
+                };
+                labels.insert(name, text);
+            }
+        }
+    }
+    labels
+});
+
 pub struct PickerInner {
     groups: Vec<PickerGroup>,
     keys: HashMap<String, Rc<PickerKey>>,
@@ -180,7 +199,7 @@ impl Picker {
 
                     println!("Clicked {} layer {}", name, layer);
                     if let Some(i) = kb.selected() {
-                        kb.keymap_set(&picker, i, layer, &name);
+                        kb.keymap_set(i, layer, &name);
                     }
                 }));
             }
@@ -191,10 +210,6 @@ impl Picker {
         self.inner().keys.get(scancode_name).map(|k| &k.gtk)
     }
 
-    pub(crate) fn get_text(&self, scancode_name: &str) -> Option<&str> {
-        self.inner().keys.get(scancode_name).map(|k| k.text.as_ref())
-    }
-
     pub(crate) fn set_keyboard(&self, keyboard: Option<Keyboard>) {
         if let Some(old_kb) = &*self.inner().keyboard.borrow() {
             old_kb.set_picker(None);