chore: Refactor physical_layout.rs

Author: ids1024

backend/src/board.rs

@@ -80,6 +80,7 @@ impl DaemonBoard {
             .0
             .layout
             .physical
+            .keys
             .iter()
             .map(|i| Key::new(&self_, i))
             .collect();

backend/src/layout/mod.rs

@@ -12,7 +12,7 @@ pub struct Layout {
     pub default: KeyMap,
     keymap: HashMap<String, u16>,
     scancode_names: HashMap<u16, String>,
-    pub(crate) physical: Vec<PhysicalLayoutKey>,
+    pub(crate) physical: PhysicalLayout,
     pub(crate) layout: HashMap<String, (u8, u8)>,
     pub(crate) leds: HashMap<String, Vec<u8>>,
 }
@@ -78,9 +78,7 @@ impl Layout {
         let (keymap, scancode_names) = parse_keymap_json(keymap_json);
         let layout = serde_json::from_str(layout_json).unwrap();
         let leds = serde_json::from_str(leds_json).unwrap();
-        let physical = serde_json::from_str::<PhysicalLayout>(physical_json)
-            .unwrap()
-            .keys();
+        let physical = PhysicalLayout::from_str(physical_json);
         Self {
             meta,
             default,

backend/src/layout/physical_layout.rs

@@ -3,104 +3,119 @@ use serde::Deserialize;
 
 use crate::{Rect, Rgb};
 
-pub(crate) struct PhysicalLayoutKey {
-    pub logical: (u8, u8),
-    pub physical: Rect,
-    pub physical_name: String,
-    pub background_color: Rgb,
+pub(crate) struct PhysicalLayout {
+    pub meta: PhysicalLayoutMeta,
+    pub keys: Vec<PhysicalLayoutKey>,
 }
 
-#[derive(Debug, Deserialize)]
-pub struct PhysicalLayout(pub Vec<PhysicalLayoutEntry>);
-
 impl PhysicalLayout {
-    pub(crate) fn keys(&self) -> Vec<PhysicalLayoutKey> {
+    pub fn from_str(physical_json: &str) -> Self {
+        let json = serde_json::from_str::<PhysicalLayoutJson>(physical_json).unwrap();
+
         let mut keys = Vec::new();
 
         let mut row_i = 0;
         let mut col_i = 0;
         let mut physical = Rect::new(0.0, 0.0, 1.0, 1.0);
         let mut background_color = Rgb::new(0xcc, 0xcc, 0xcc);
+        let mut meta = None;
 
-        for entry in &self.0 {
-            if let PhysicalLayoutEntry::Row(row) = entry {
-                for i in &row.0 {
-                    match i {
-                        PhysicalKeyEnum::Meta(meta) => {
-                            debug!("Key metadata {:?}", meta);
-                            physical.x += meta.x;
-                            physical.y -= meta.y;
-                            physical.w = meta.w.unwrap_or(physical.w);
-                            physical.h = meta.h.unwrap_or(physical.h);
-                            background_color = meta
-                                .c
-                                .as_ref()
-                                .map(|c| {
-                                    let err = format!("Failed to parse color {}", c);
-                                    Rgb::parse(&c[1..]).expect(&err)
-                                })
-                                .unwrap_or(background_color);
-                        }
-                        PhysicalKeyEnum::Name(name) => {
-                            keys.push(PhysicalLayoutKey {
-                                logical: (row_i as u8, col_i as u8),
-                                physical,
-                                physical_name: name.clone(),
-                                background_color,
-                            });
-
-                            physical.x += physical.w;
-
-                            physical.w = 1.0;
-                            physical.h = 1.0;
-
-                            col_i += 1;
+        for entry in json.0 {
+            match entry {
+                PhysicalLayoutEntry::Meta(data) => {
+                    meta = Some(data);
+                }
+                PhysicalLayoutEntry::Row(row) => {
+                    for i in &row.0 {
+                        match i {
+                            PhysicalKeyEnum::Meta(meta) => {
+                                debug!("Key metadata {:?}", meta);
+                                physical.x += meta.x;
+                                physical.y -= meta.y;
+                                physical.w = meta.w.unwrap_or(physical.w);
+                                physical.h = meta.h.unwrap_or(physical.h);
+                                background_color = meta
+                                    .c
+                                    .as_ref()
+                                    .map(|c| {
+                                        let err = format!("Failed to parse color {}", c);
+                                        Rgb::parse(&c[1..]).expect(&err)
+                                    })
+                                    .unwrap_or(background_color);
+                            }
+                            PhysicalKeyEnum::Name(name) => {
+                                keys.push(PhysicalLayoutKey {
+                                    logical: (row_i as u8, col_i as u8),
+                                    physical,
+                                    physical_name: name.clone(),
+                                    background_color,
+                                });
+
+                                physical.x += physical.w;
+
+                                physical.w = 1.0;
+                                physical.h = 1.0;
+
+                                col_i += 1;
+                            }
                         }
                     }
-                }
 
-                physical.x = 0.0;
-                physical.y -= 1.0;
+                    physical.x = 0.0;
+                    physical.y -= 1.0;
 
-                col_i = 0;
-                row_i += 1;
+                    col_i = 0;
+                    row_i += 1;
+                }
             }
         }
 
-        keys
+        let meta = meta.expect("No layout meta");
+
+        Self { keys, meta }
     }
 }
 
+pub(crate) struct PhysicalLayoutKey {
+    pub logical: (u8, u8),
+    pub physical: Rect,
+    pub physical_name: String,
+    pub background_color: Rgb,
+}
+
+#[derive(Debug, Deserialize)]
+struct PhysicalLayoutJson(Vec<PhysicalLayoutEntry>);
+
 #[derive(Debug, Deserialize)]
 #[serde(untagged)]
-pub enum PhysicalLayoutEntry {
+enum PhysicalLayoutEntry {
     Meta(PhysicalLayoutMeta),
     Row(PhysicalRow),
 }
 
 #[derive(Debug, Deserialize)]
-pub struct PhysicalLayoutMeta {
+pub(crate) struct PhysicalLayoutMeta {
     pub name: String,
     pub author: String,
 }
 
 #[derive(Debug, Deserialize)]
-pub struct PhysicalRow(pub Vec<PhysicalKeyEnum>);
+struct PhysicalRow(Vec<PhysicalKeyEnum>);
 
 #[derive(Debug, Deserialize)]
 #[serde(untagged)]
-pub enum PhysicalKeyEnum {
+enum PhysicalKeyEnum {
     Name(String),
     Meta(PhysicalKeyMeta),
 }
 
 #[derive(Debug, Deserialize)]
-pub struct PhysicalKeyMeta {
+struct PhysicalKeyMeta {
     #[serde(default)]
-    pub x: f64,
+    x: f64,
     #[serde(default)]
-    pub y: f64,
-    pub w: Option<f64>,
-    pub h: Option<f64>,
-    pub c: Option<String>,
+    y: f64,
+    w: Option<f64>,
+    h: Option<f64>,
+    c: Option<String>,
 }