feat: Use env_logger to not always print so many messages

Author: ids1024

Cargo.lock

@@ -29,6 +29,8 @@ pango = { git = "https://github.com/pop-os/gtk-rs" }
 pangocairo = { git = "https://github.com/pop-os/gtk-rs" }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
+log = "0.4.0"
+env_logger = "0.8.3"
 
 [build-dependencies]
 gio = { git = "https://github.com/pop-os/gtk-rs" }

Cargo.toml

@@ -62,7 +62,7 @@ impl ObjectImpl for KeyboardInner {
                         .get_visible_child()
                         .map(|c| c.downcast_ref::<KeyboardLayer>().unwrap().page());
 
-                    println!("{:?}", page);
+                    debug!("{:?}", page);
                     let last_layer = keyboard.layer();
                     keyboard.inner().page.set(page.unwrap_or(Page::Layer1));
                     if keyboard.layer() != last_layer {
@@ -79,9 +79,9 @@ impl ObjectImpl for KeyboardInner {
             ..connect_value_changed(clone!(@weak keyboard => move |this| {
                 let value = this.get_value() as i32;
                 if let Err(err) = keyboard.board().set_brightness(value) {
-                    eprintln!("{}", err);
+                    error!("{}", err);
                 }
-                println!("{}", value);
+                info!("{}", value);
             }));
         };
 
@@ -229,21 +229,21 @@ impl Keyboard {
         let mut keys = layout.keys();
         for key in keys.iter_mut() {
             for layer in 0..2 {
-                println!("  Layer {}", layer);
+                debug!("  Layer {}", layer);
                 let scancode = match board.keymap_get(layer, key.electrical.0, key.electrical.1) {
                     Ok(value) => value,
                     Err(err) => {
-                        eprintln!("Failed to read scancode: {:?}", err);
+                        error!("Failed to read scancode: {:?}", err);
                         0
                     }
                 };
-                println!("    Scancode: {:04X}", scancode);
+                debug!("    Scancode: {:04X}", scancode);
 
                 let scancode_name = match layout.scancode_names.get(&scancode) {
                     Some(some) => some.to_string(),
                     None => String::new(),
                 };
-                println!("    Scancode Name: {}", scancode_name);
+                debug!("    Scancode Name: {}", scancode_name);
 
                 key.scancodes.borrow_mut().push((scancode, scancode_name));
             }
@@ -260,7 +260,7 @@ impl Keyboard {
         let max_brightness = match keyboard.board().max_brightness() {
             Ok(value) => value as f64,
             Err(err) => {
-                eprintln!("{}", err);
+                error!("{}", err);
                 100.0
             }
         };
@@ -272,7 +272,7 @@ impl Keyboard {
         let brightness = match keyboard.board().brightness() {
             Ok(value) => value as f64,
             Err(err) => {
-                eprintln!("{}", err);
+                error!("{}", err);
                 0.0
             }
         };
@@ -366,7 +366,7 @@ impl Keyboard {
         if !found {
             return;
         }
-        println!(
+        info!(
             "  set {}, {}, {} to {:04X}",
             layer,
             k.electrical.0,
@@ -379,7 +379,7 @@ impl Keyboard {
             k.electrical.1,
             k.scancodes.borrow_mut()[layer].0,
         ) {
-            eprintln!("Failed to set keymap: {:?}", err);
+            error!("Failed to set keymap: {:?}", err);
         }
 
         self.set_selected(self.selected());
@@ -535,7 +535,7 @@ impl Keyboard {
 
         if let Some(i) = i {
             let k = &keys[i];
-            println!("{:#?}", k);
+            debug!("{:#?}", k);
             if let Some(layer) = self.layer() {
                 if let Some((_scancode, scancode_name)) = keys[i].scancodes.borrow().get(layer) {
                     picker.set_selected(Some(scancode_name.to_string()));

src/application/keyboard.rs

@@ -102,7 +102,7 @@ impl Layout {
                 for i in &row.0 {
                     match i {
                         PhysicalKeyEnum::Meta(meta) => {
-                            println!("Key metadata {:?}", meta);
+                            debug!("Key metadata {:?}", meta);
                             x += meta.x;
                             y -= meta.y;
                             w = meta.w.unwrap_or(w);
@@ -125,24 +125,24 @@ impl Layout {
                             }
                         }
                         PhysicalKeyEnum::Name(name) => {
-                            println!("Key {}, {} = {:?}", x, y, name);
+                            debug!("Key {}, {} = {:?}", x, y, name);
 
                             let logical = (row_i as u8, col_i as u8);
-                            println!("  Logical: {:?}", logical);
+                            debug!("  Logical: {:?}", logical);
 
                             let row_char = char::from_digit(logical.0 as u32, 36)
                                 .expect("Failed to convert row to char");
                             let col_char = char::from_digit(logical.1 as u32, 36)
                                 .expect("Failed to convert col to char");
                             let logical_name = format!("K{}{}", row_char, col_char).to_uppercase();
-                            println!("  Logical Name: {}", logical_name);
+                            debug!("  Logical Name: {}", logical_name);
 
                             let electrical = self
                                 .layout
                                 .get(logical_name.as_str())
                                 //.expect("Failed to find electrical mapping");
                                 .unwrap_or(&(0, 0));
-                            println!("  Electrical: {:?}", electrical);
+                            debug!("  Electrical: {:?}", electrical);
 
                             keys.push(Key {
                                 logical,

src/application/layout/mod.rs

@@ -116,7 +116,7 @@ impl ObjectImpl for MainWindowInner {
 impl WidgetImpl for MainWindowInner {
     fn destroy(&self, window: &MainWindow) {
         self.parent_destroy(window);
-        eprintln!("Window close");
+        info!("Window close");
     }
 }
 impl ContainerImpl for MainWindowInner {}
@@ -149,7 +149,7 @@ impl MainWindow {
                 window.add_keyboard(daemon.clone(), board, i);
             }
         } else if window.inner().count.load(Ordering::Relaxed) == 0 {
-            eprintln!("Failed to locate any keyboards, showing demo");
+            error!("Failed to locate any keyboards, showing demo");
 
             let daemon = Rc::new(DaemonDummy::new(
                 vec!["system76/launch_alpha_2".to_string()],
@@ -191,18 +191,18 @@ impl MainWindow {
                 self.insert_action_group("kbd", Some(keyboard.action_group()));
             }
         } else {
-            eprintln!("Failed to locate layout for '{}'", board_name);
+            error!("Failed to locate layout for '{}'", board_name);
         }
     }
 }
 
 #[cfg(target_os = "linux")]
 fn daemon() -> Rc<dyn Daemon> {
     if unsafe { libc::geteuid() == 0 } {
-        eprintln!("Already running as root");
+        info!("Already running as root");
         Rc::new(DaemonServer::new_stdio().expect("Failed to create server"))
     } else {
-        eprintln!("Not running as root, spawning daemon with pkexec");
+        info!("Not running as root, spawning daemon with pkexec");
         Rc::new(DaemonClient::new_pkexec())
     }
 }

src/application/main_window.rs

@@ -99,8 +99,7 @@ impl ApplicationImpl for ConfiguratorAppInner {
         self.parent_activate(app);
 
         if let Some(window) = app.get_active_window() {
-            //TODO
-            eprintln!("Focusing current window");
+            info!("Focusing current window");
             window.present();
         } else {
             let phony_board_names = &*self.phony_board_names;

src/application/mod.rs

@@ -165,7 +165,7 @@ impl Picker {
                     };
                     let layer = kb.layer();
 
-                    println!("Clicked {} layer {:?}", name, layer);
+                    info!("Clicked {} layer {:?}", name, layer);
                     if let Some(i) = kb.selected() {
                         if let Some(layer) = layer {
                             kb.keymap_set(i, layer, &name);

src/application/picker/mod.rs

@@ -35,7 +35,7 @@ pub fn choose_color<W: IsA<gtk::Widget>>(
 
     color_wheel.connect_hs_changed(clone!(@weak preview => @default-panic, move |wheel| {
         if let Err(err) = board.set_color(wheel.hs().to_rgb()) {
-            eprintln!("Failed to set keyboard color: {}", err);
+            error!("Failed to set keyboard color: {}", err);
         }
         preview.queue_draw();
     }));