improv: Make members of application::Keyboard private

Adds methods for cases where Picker needs to access them.

Still could use improvement.

Author: ids1024

src/application/keyboard.rs

@@ -24,13 +24,13 @@ use super::page::Page;
 use super::picker::Picker;
 
 pub struct Keyboard {
-    pub(crate) daemon: Rc<dyn Daemon>,
-    pub(crate) daemon_board: usize,
-    pub(crate) keymap: HashMap<String, u16>,
-    pub(crate) keys: RefCell<Vec<Key>>,
+    daemon: Rc<dyn Daemon>,
+    daemon_board: usize,
+    keymap: HashMap<String, u16>,
+    keys: RefCell<Vec<Key>>,
     page: Cell<Page>,
     picker: RefCell<WeakRef<Picker>>,
-    pub(crate) selected: Cell<Option<usize>>,
+    selected: Cell<Option<usize>>,
 }
 
 impl Keyboard {
@@ -101,6 +101,45 @@ impl Keyboard {
         }
     }
 
+    pub fn selected(&self) -> Option<usize> {
+        self.selected.get()
+    }
+
+    pub fn has_scancode(&self, scancode_name: &str) -> bool {
+        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
+        let mut keys = self.keys.borrow_mut();
+        let k = &mut keys[key_index];
+        let mut found = false;
+        if let Some(scancode) = self.keymap.get(scancode_name) {
+            k.deselect(&picker, layer);
+            k.scancodes[layer] = (*scancode, scancode_name.to_string());
+            k.refresh(&picker);
+            k.select(&picker, layer);
+            found = true;
+        }
+        if !found {
+            return;
+        }
+        println!(
+            "  set {}, {}, {} to {:04X}",
+            layer, k.electrical.0, k.electrical.1, k.scancodes[layer].0
+        );
+        if let Err(err) = self.daemon.keymap_set(
+            self.daemon_board,
+            layer as u8,
+            k.electrical.0,
+            k.electrical.1,
+            k.scancodes[layer].0,
+        ) {
+            eprintln!("Failed to set keymap: {:?}", err);
+        }
+
+    }
+
     pub fn gtk(self: Rc<Self>) -> gtk::Box {
         let stack = cascade! {
             gtk::Stack::new();

src/application/picker/mod.rs

@@ -173,33 +173,8 @@ impl Picker {
                     let layer = kb.layer();
 
                     println!("Clicked {} layer {}", name, layer);
-                    if let Some(i) = kb.selected.get() {
-                        let mut keys = kb.keys.borrow_mut();
-                        let k = &mut keys[i];
-                        let mut found = false;
-                        if let Some(scancode) = kb.keymap.get(name.as_str()) {
-                            k.deselect(&picker, layer);
-                            k.scancodes[layer] = (*scancode, name.clone());
-                            k.refresh(&picker);
-                            k.select(&picker, layer);
-                            found = true;
-                        }
-                        if !found {
-                            return;
-                        }
-                        println!(
-                            "  set {}, {}, {} to {:04X}",
-                            layer, k.electrical.0, k.electrical.1, k.scancodes[layer].0
-                        );
-                        if let Err(err) = kb.daemon.keymap_set(
-                            kb.daemon_board,
-                            layer as u8,
-                            k.electrical.0,
-                            k.electrical.1,
-                            k.scancodes[layer].0,
-                        ) {
-                            eprintln!("Failed to set keymap: {:?}", err);
-                        }
+                    if let Some(i) = kb.selected() {
+                        kb.keymap_set(&picker, i, layer, &name);
                     }
                 }));
             }
@@ -222,7 +197,7 @@ impl Picker {
             for group in self.inner().groups.iter() {
                 for key in group.iter_keys() {
                     // Check that scancode is available for the keyboard
-                    let sensitive = kb.keymap.contains_key(key.name.as_str());
+                    let sensitive = kb.has_scancode(&key.name);
                     key.gtk.set_sensitive(sensitive);
                 }
             }