chore: Make DaemonBoard a glib object

ids1024 · ids1024 · commit 9996427be899 · 2021-04-02T13:15:22.000-07:00
diff --git a/backend/src/board.rs b/backend/src/board.rs
@@ -1,41 +1,37 @@
-use once_cell::unsync::OnceCell;
-use std::{
-    cell::Cell,
-    collections::HashMap,
-    rc::{Rc, Weak},
-};
-
-use crate::{BoardId, Daemon, Key, KeyMap, Layer, Layout};
-
-pub(crate) struct DaemonBoardInner {
-    pub(crate) daemon: Rc<dyn Daemon>,
-    pub(crate) board: BoardId,
-    model: String,
-    layout: Layout,
-    keys: OnceCell<Vec<Key>>,
-    layers: OnceCell<Vec<Layer>>,
-    max_brightness: i32,
+use glib::subclass::prelude::*;
+use std::{cell::Cell, collections::HashMap, rc::Rc};
+
+use crate::{BoardId, Daemon, DerefCell, Key, KeyMap, Layer, Layout};
+
+// GObject
+// Add changed signal
+// Want DerefCell, I guess... Or use OnceCell
+
+#[derive(Default)]
+pub struct DaemonBoardInner {
+    daemon: DerefCell<Rc<dyn Daemon>>,
+    board: DerefCell<BoardId>,
+    model: DerefCell<String>,
+    layout: DerefCell<Layout>,
+    keys: DerefCell<Vec<Key>>,
+    layers: DerefCell<Vec<Layer>>,
+    max_brightness: DerefCell<i32>,
     pub(crate) leds_changed: Cell<bool>,
-    has_led_save: bool,
-    has_matrix: bool,
+    has_led_save: DerefCell<bool>,
+    has_matrix: DerefCell<bool>,
 }
 
-#[derive(Clone, glib::GBoxed)]
-#[gboxed(type_name = "S76DaemonBoard")]
-pub struct DaemonBoard(pub(crate) Rc<DaemonBoardInner>);
-
-pub(crate) struct DaemonBoardWeak(Weak<DaemonBoardInner>);
-
-impl std::fmt::Debug for DaemonBoardWeak {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        write!(f, "DaemonBoardWeak({:p})", self)
-    }
+#[glib::object_subclass]
+impl ObjectSubclass for DaemonBoardInner {
+    const NAME: &'static str = "S76DaemonBoard";
+    type ParentType = glib::Object;
+    type Type = DaemonBoard;
 }
 
-impl DaemonBoardWeak {
-    pub fn upgrade(&self) -> Option<DaemonBoard> {
-        self.0.upgrade().map(DaemonBoard)
-    }
+impl ObjectImpl for DaemonBoardInner {}
+
+glib::wrapper! {
+    pub struct DaemonBoard(ObjectSubclass<DaemonBoardInner>);
 }
 
 impl DaemonBoard {
@@ -63,51 +59,55 @@ impl DaemonBoard {
         let has_led_save = daemon.led_save(board).is_ok();
         let has_matrix = daemon.matrix_get(board).is_ok();
 
-        let self_ = Self(Rc::new(DaemonBoardInner {
-            daemon,
-            board,
-            keys: OnceCell::new(),
-            layers: OnceCell::new(),
-            layout,
-            max_brightness,
-            model,
-            leds_changed: Cell::new(false),
-            has_led_save,
-            has_matrix,
-        }));
+        let self_ = glib::Object::new::<DaemonBoard>(&[]).unwrap();
+        self_.inner().daemon.set(daemon);
+        self_.inner().board.set(board);
+        self_.inner().model.set(model);
+        self_.inner().layout.set(layout);
+        self_.inner().max_brightness.set(max_brightness);
+        self_.inner().has_led_save.set(has_led_save);
+        self_.inner().has_matrix.set(has_matrix);
 
         let keys = self_
-            .0
+            .inner()
             .layout
             .physical
             .keys
             .iter()
             .map(|i| Key::new(&self_, i))
             .collect();
-        self_.0.keys.set(keys).unwrap();
+        self_.inner().keys.set(keys);
 
         let layers = (0..num_layers)
             .map(|layer| Layer::new(&self_, layer))
             .collect();
-        self_.0.layers.set(layers).unwrap();
+        self_.inner().layers.set(layers);
 
         Ok(self_)
     }
 
-    pub(crate) fn downgrade(&self) -> DaemonBoardWeak {
-        DaemonBoardWeak(Rc::downgrade(&self.0))
+    pub(crate) fn inner(&self) -> &DaemonBoardInner {
+        DaemonBoardInner::from_instance(self)
+    }
+
+    pub(crate) fn daemon(&self) -> &dyn Daemon {
+        self.inner().daemon.as_ref()
+    }
+
+    pub(crate) fn board(&self) -> BoardId {
+        *self.inner().board
     }
 
     pub fn model(&self) -> &str {
-        &self.0.model
+        &self.inner().model
     }
 
     pub fn has_matrix(&self) -> bool {
-        self.0.has_matrix
+        *self.inner().has_matrix
     }
 
     pub fn refresh_matrix(&self) -> Result<bool, String> {
-        let matrix = self.0.daemon.matrix_get(self.0.board)?;
+        let matrix = self.daemon().matrix_get(self.board())?;
         let mut changed = false;
         for key in self.keys() {
             let pressed = matrix
@@ -119,36 +119,36 @@ impl DaemonBoard {
     }
 
     pub fn max_brightness(&self) -> i32 {
-        self.0.max_brightness
+        *self.inner().max_brightness
     }
 
     pub fn led_save(&self) -> Result<(), String> {
-        if self.has_led_save() && self.0.leds_changed.get() {
-            self.0.daemon.led_save(self.0.board)?;
-            self.0.leds_changed.set(false);
+        if self.has_led_save() && self.inner().leds_changed.get() {
+            self.daemon().led_save(self.board())?;
+            self.inner().leds_changed.set(false);
             debug!("led_save");
         }
         Ok(())
     }
 
     pub fn is_fake(&self) -> bool {
-        self.0.daemon.is_fake()
+        self.daemon().is_fake()
     }
 
     pub fn has_led_save(&self) -> bool {
-        self.0.has_led_save
+        *self.inner().has_led_save
     }
 
     pub fn layout(&self) -> &Layout {
-        &self.0.layout
+        &*self.inner().layout
     }
 
     pub fn layers(&self) -> &[Layer] {
-        self.0.layers.get().unwrap()
+        &*self.inner().layers
     }
 
     pub fn keys(&self) -> &[Key] {
-        self.0.keys.get().unwrap()
+        &*self.inner().keys
     }
 
     pub fn export_keymap(&self) -> KeyMap {
diff --git a/backend/src/deref_cell.rs b/backend/src/deref_cell.rs
diff --git a/backend/src/key.rs b/backend/src/key.rs
@@ -1,10 +1,11 @@
+use glib::clone::Downgrade;
 use std::{cell::Cell, char};
 
-use crate::{DaemonBoard, DaemonBoardWeak, Hs, PhysicalLayoutKey, Rect, Rgb};
+use crate::{DaemonBoard, Hs, PhysicalLayoutKey, Rect, Rgb};
 
 #[derive(Debug)]
 pub struct Key {
-    pub(crate) board: DaemonBoardWeak,
+    pub(crate) board: glib::WeakRef<DaemonBoard>,
     // Logical position (row, column)
     pub logical: (u8, u8),
     // Logical name (something like K01, where 0 is the row and 1 is the column)
@@ -76,9 +77,8 @@ impl Key {
             debug!("  Layer {}", layer);
             let scancode =
                 match board
-                    .0
-                    .daemon
-                    .keymap_get(board.0.board, layer, electrical.0, electrical.1)
+                    .daemon()
+                    .keymap_get(board.board(), layer, electrical.0, electrical.1)
                 {
                     Ok(value) => value,
                     Err(err) => {
@@ -97,7 +97,7 @@ impl Key {
 
         let mut led_color = None;
         if board.layout().meta.has_mode && leds.len() > 0 {
-            match board.0.daemon.color(board.0.board, leds[0]) {
+            match board.daemon().color(board.board(), leds[0]) {
                 Ok(color) => led_color = Some(color),
                 Err(err) => error!("error getting key color: {}", err),
             }
@@ -135,10 +135,10 @@ impl Key {
     pub fn set_color(&self, color: Hs) -> Result<(), String> {
         let board = self.board();
         for index in &self.leds {
-            board.0.daemon.set_color(board.0.board, *index, color)?;
+            board.daemon().set_color(board.board(), *index, color)?;
         }
         self.led_color.set(Some(color));
-        board.0.leds_changed.set(true);
+        board.inner().leds_changed.set(true);
         Ok(())
     }
 
@@ -158,8 +158,8 @@ impl Key {
             .layout()
             .scancode_from_name(scancode_name)
             .ok_or_else(|| format!("Unable to find scancode '{}'", scancode_name))?;
-        board.0.daemon.keymap_set(
-            board.0.board,
+        board.daemon().keymap_set(
+            board.board(),
             layer as u8,
             self.electrical.0,
             self.electrical.1,
diff --git a/backend/src/layer.rs b/backend/src/layer.rs
@@ -1,12 +1,13 @@
+use glib::clone::Downgrade;
 use std::cell::Cell;
 
-use crate::{DaemonBoard, DaemonBoardWeak, Hs, Mode};
+use crate::{DaemonBoard, Hs, Mode};
 
 #[derive(Debug)]
 pub struct Layer {
     layer: u8,
     index: u8,
-    board: DaemonBoardWeak,
+    board: glib::WeakRef<DaemonBoard>,
     mode: Cell<Option<(u8, u8)>>,
     brightness: Cell<i32>,
     color: Cell<Hs>,
@@ -21,9 +22,8 @@ impl Layer {
         };
         let mode = if board.layout().meta.has_mode {
             board
-                .0
-                .daemon
-                .mode(board.0.board, layer)
+                .daemon()
+                .mode(board.board(), layer)
                 .map(Some)
                 .unwrap_or_else(|err| {
                     error!("Error getting layer mode: {}", err);
@@ -33,17 +33,15 @@ impl Layer {
             None
         };
         let brightness = board
-            .0
-            .daemon
-            .brightness(board.0.board, index)
+            .daemon()
+            .brightness(board.board(), index)
             .unwrap_or_else(|err| {
                 error!("error getting layer brightness: {}", err);
                 0
             });
         let color = board
-            .0
-            .daemon
-            .color(board.0.board, index)
+            .daemon()
+            .color(board.board(), index)
             .unwrap_or_else(|err| {
                 error!("error getting layer color: {}", err);
                 Hs::new(0., 0.)
@@ -70,11 +68,10 @@ impl Layer {
     pub fn set_mode(&self, mode: &Mode, speed: u8) -> Result<(), String> {
         let board = self.board();
         board
-            .0
-            .daemon
-            .set_mode(board.0.board, self.layer, mode.index, speed)?;
+            .daemon()
+            .set_mode(board.board(), self.layer, mode.index, speed)?;
         self.mode.set(Some((mode.index, speed)));
-        board.0.leds_changed.set(true);
+        board.inner().leds_changed.set(true);
         Ok(())
     }
 
@@ -85,11 +82,10 @@ impl Layer {
     pub fn set_brightness(&self, brightness: i32) -> Result<(), String> {
         let board = self.board();
         board
-            .0
-            .daemon
-            .set_brightness(board.0.board, self.index, brightness)?;
+            .daemon()
+            .set_brightness(board.board(), self.index, brightness)?;
         self.brightness.set(brightness);
-        board.0.leds_changed.set(true);
+        board.inner().leds_changed.set(true);
         Ok(())
     }
 
@@ -99,9 +95,9 @@ impl Layer {
 
     pub fn set_color(&self, color: Hs) -> Result<(), String> {
         let board = self.board();
-        board.0.daemon.set_color(board.0.board, self.index, color)?;
+        board.daemon().set_color(board.board(), self.index, color)?;
         self.color.set(color);
-        board.0.leds_changed.set(true);
+        board.inner().leds_changed.set(true);
         Ok(())
     }
 }
diff --git a/backend/src/lib.rs b/backend/src/lib.rs
@@ -4,6 +4,7 @@ extern crate log;
 mod board;
 mod color;
 mod daemon;
+mod deref_cell;
 mod key;
 mod keymap;
 mod layer;
@@ -12,5 +13,6 @@ mod mode;
 mod rect;
 
 pub use self::{
-    board::*, color::*, daemon::*, key::*, keymap::*, layer::*, layout::*, mode::*, rect::*,
+    board::*, color::*, daemon::*, deref_cell::*, key::*, keymap::*, layer::*, layout::*, mode::*,
+    rect::*,
 };
diff --git a/src/lib.rs b/src/lib.rs
@@ -6,14 +6,13 @@ pub mod application;
 mod choose_color;
 mod color_circle;
 mod color_wheel;
-mod deref_cell;
 mod keyboard_backlight_widget;
 mod keyboard_color;
 mod selected_keys;
 
 use crate::{
-    choose_color::*, color_circle::*, color_wheel::*, deref_cell::*, keyboard_color::*,
-    selected_keys::*,
+    choose_color::*, color_circle::*, color_wheel::*, keyboard_color::*, selected_keys::*,
 };
 pub use backend;
+use backend::DerefCell;
 pub use keyboard_backlight_widget::keyboard_backlight_widget;
