chore: Move some logic from DaemonBoard::new() to Key::new()

Author: ids1024

backend/src/board.rs

@@ -76,54 +76,17 @@ impl DaemonBoard {
             has_matrix,
         }));
 
-        let mut keys = Vec::new();
-        for i in &self_.0.layout.physical {
-            let key = Key::new(
-                &self_,
-                i.logical,
-                i.physical,
-                i.physical_name.clone(),
-                i.background_color,
-            );
-
-            for layer in 0..self_.0.layout.meta.num_layers {
-                debug!("  Layer {}", layer);
-                let scancode = match self_.0.daemon.keymap_get(
-                    board,
-                    layer,
-                    key.electrical.0,
-                    key.electrical.1,
-                ) {
-                    Ok(value) => value,
-                    Err(err) => {
-                        error!("Failed to read scancode: {:?}", err);
-                        0
-                    }
-                };
-                debug!("    Scancode: {:04X}", scancode);
-
-                let scancode_name = match self_.0.layout.scancode_names.get(&scancode) {
-                    Some(some) => some.to_string(),
-                    None => String::new(),
-                };
-                debug!("    Scancode Name: {}", scancode_name);
-
-                key.scancodes.borrow_mut().push((scancode, scancode_name));
-            }
-
-            if self_.layout().meta.has_mode && key.leds.len() > 0 {
-                match self_.0.daemon.color(self_.0.board, key.leds[0]) {
-                    Ok(color) => key.led_color.set(Some(color)),
-                    Err(err) => error!("error getting key color: {}", err),
-                }
-            }
-
-            keys.push(key);
-        }
+        let keys = self_
+            .0
+            .layout
+            .physical
+            .iter()
+            .map(|i| Key::new(&self_, i))
+            .collect();
         self_.0.keys.set(keys).unwrap();
 
         let layers = (0..num_layers)
-            .map(|layer| Layer::new(layer, &self_))
+            .map(|layer| Layer::new(&self_, layer))
             .collect();
         self_.0.layers.set(layers).unwrap();
 

backend/src/key.rs

@@ -3,7 +3,7 @@ use std::{
     char,
 };
 
-use crate::{DaemonBoard, DaemonBoardWeak, Hs, Rect, Rgb};
+use crate::{DaemonBoard, DaemonBoardWeak, Hs, PhysicalLayoutKey, Rect, Rgb};
 
 #[derive(Debug)]
 pub struct Key {
@@ -34,13 +34,12 @@ pub struct Key {
 }
 
 impl Key {
-    pub(crate) fn new(
-        board: &DaemonBoard,
-        logical: (u8, u8),
-        physical: Rect,
-        physical_name: String,
-        background_color: Rgb,
-    ) -> Self {
+    pub(crate) fn new(board: &DaemonBoard, physical_key: &PhysicalLayoutKey) -> Self {
+        let logical = physical_key.logical;
+        let physical = physical_key.physical;
+        let physical_name = physical_key.physical_name.clone();
+        let background_color = physical_key.background_color;
+
         debug!("Key {}, {} = {:?}", physical.x, physical.y, physical_name);
 
         debug!("  Logical: {:?}", logical);
@@ -75,6 +74,40 @@ impl Key {
             led_name.push_str(&led.to_string());
         }
 
+        let mut scancodes = Vec::new();
+        for layer in 0..board.layout().meta.num_layers {
+            debug!("  Layer {}", layer);
+            let scancode =
+                match board
+                    .0
+                    .daemon
+                    .keymap_get(board.0.board, layer, electrical.0, electrical.1)
+                {
+                    Ok(value) => value,
+                    Err(err) => {
+                        error!("Failed to read scancode: {:?}", err);
+                        0
+                    }
+                };
+            debug!("    Scancode: {:04X}", scancode);
+
+            let scancode_name = match board.layout().scancode_names.get(&scancode) {
+                Some(some) => some.to_string(),
+                None => String::new(),
+            };
+            debug!("    Scancode Name: {}", scancode_name);
+
+            scancodes.push((scancode, scancode_name));
+        }
+
+        let mut led_color = None;
+        if board.layout().meta.has_mode && leds.len() > 0 {
+            match board.0.daemon.color(board.0.board, leds[0]) {
+                Ok(color) => led_color = Some(color),
+                Err(err) => error!("error getting key color: {}", err),
+            }
+        }
+
         Self {
             board: board.downgrade(),
             logical,
@@ -85,9 +118,9 @@ impl Key {
             electrical_name: format!("{}, {}", electrical.0, electrical.1),
             leds,
             led_name,
-            led_color: Cell::new(None),
+            led_color: Cell::new(led_color),
             pressed: Cell::new(false),
-            scancodes: RefCell::new(Vec::new()),
+            scancodes: RefCell::new(scancodes),
             background_color,
         }
     }

backend/src/layer.rs

@@ -13,7 +13,7 @@ pub struct Layer {
 }
 
 impl Layer {
-    pub(crate) fn new(layer: u8, board: &DaemonBoard) -> Self {
+    pub(crate) fn new(board: &DaemonBoard, layer: u8) -> Self {
         let index = if board.layout().meta.has_per_layer {
             0xf0 + layer
         } else {