Random commit

src/backend.rs

@@ -14,7 +14,7 @@ use crate::backend::brightness_control::{BrightnessManager, BrightnessMessage};
 use crate::backend::commands::ControlSocket;
 use crate::backend::idle::{IdleDaemon, IdleMessage, IdleState};
 use crate::backend::json_socket::{JsonSocketBackend, State};
-use crate::backend::network::{NetworkBackendHandle, NetworkCommand, NetworkState};
+use crate::backend::network::{NetworkBackend, NetworkCommand, NetworkState};
 use crate::backend::perf_stats::{Stats, StatsBackend};
 use crate::backend::window_manager_hypr::{HyprlandComms, WindowManagerEvent};
 use crossbeam_channel::{Receiver, Sender};
@@ -31,6 +31,13 @@ pub trait BackendThread<M: Debug + Clone, D> {
     fn subscribers(&self) -> &Vec<Sender<M>>;
     fn init(self, registration_rx: Receiver<Sender<M>>);
     fn publish(&self, message: M) {
+        if self.subscribers().is_empty() {
+            warn!(
+                &LOGGER,
+                "Tried sending message: {message:?} to no subscribers"
+            );
+            return;
+        }
         trace!(&LOGGER, "Sending: {message:?} to {:?}", self.subscribers());
         for tx in self.subscribers() {
             if let Err(e) = tx.send(message.clone()) {
@@ -103,7 +110,7 @@ impl Backend {
     pub fn start(config: &Config) -> Self {
         debug!(&LOGGER, "Starting Backend threads...");
         let hypr_registrator = HyprlandComms::new().start();
-        let net_registrator = NetworkBackendHandle::new().start();
+        let net_registrator = NetworkBackend::new().start();
         let br_registrator = BrightnessManager::new().start();
         let stats_registrator = StatsBackend::new().start();
         let audio_registrator = AudioBackend::new().start();
@@ -130,7 +137,7 @@ impl Backend {
         for ch_type in channel_types {
             match ch_type {
                 ChannelType::Net => {
-                    let (rx, tx) = NetworkBackendHandle::subscribe(self.net_registrator.clone());
+                    let (rx, tx) = NetworkBackend::subscribe(self.net_registrator.clone());
                     channels.net_tx = Some(tx);
                     channels.net_rx = Some(rx);
                 }

src/backend/window_manager_hypr.rs

@@ -166,7 +166,7 @@ impl HyprlandComms {
         None
     }
 
-    pub fn current_monitor() -> MonitorId {
+    pub fn _current_monitor() -> MonitorId {
         if let Ok(monitor) = Monitor::get_active() {
             return monitor.id;
         }

src/ui.rs

@@ -80,10 +80,8 @@ pub fn create_bars(app: &Application, backend: Backend) {
         move || {
             while let Ok(cmd) = ctl_rx.try_recv() {
                 match cmd {
-                    ControlCommand::OpenRunMenu => menu.show(),
+                    ControlCommand::OpenRunMenu => menu.toggle(),
-                    ControlCommand::OpenNetMenu => {
+                    ControlCommand::OpenNetMenu => action_centre.toggle_active_monitor(),
-                        action_centre.show_action_centre_active_monitor()
-                    }
                 }
             }
             ControlFlow::Continue

src/ui/action_centre.rs

@@ -117,7 +117,7 @@ impl ActionCentre {
             let instance = instance.clone();
             move |_, key, _, _| {
                 if key == gdk::Key::Escape {
-                    instance.hide_action_centre();
+                    instance.hide();
                     glib::Propagation::Stop
                 } else {
                     glib::Propagation::Proceed
@@ -319,17 +319,25 @@ impl ActionCentre {
         }
     }
     
-    pub fn show_action_centre_active_monitor(&self) {
+    pub fn toggle_active_monitor(&self) {
+        if self.window.is_visible() {
+            self.hide();
+        } else {
+            self.show_active_monitor();
+        }
+    }
+
+    pub fn show_active_monitor(&self) {
         let Some(display) = Display::default() else {
             return;
         };
         let Some(monitor) = HyprlandComms::cursor_monitor() else {
             return;
         };
-        self.show_action_centre(monitor as u32, &display);
+        self.show(monitor as u32, &display);
     }
 
-    pub fn show_action_centre(&self, monitor_idx: u32, display: &Display) {
+    pub fn show(&self, monitor_idx: u32, display: &Display) {
         let window = &self.window;
         let monitors = display.monitors();
         let Some(monitor) = monitors.item(monitor_idx) else {
@@ -345,7 +353,7 @@ impl ActionCentre {
         }
     }
 
-    pub fn hide_action_centre(&self) {
+    pub fn hide(&self) {
         let clone = self.clone();
         self.animate_margin(
             20,

src/ui/run_menu.rs

@@ -189,6 +189,14 @@ impl RunMenu {
         self.window.present();
     }
 
+    pub fn toggle(&mut self) {
+        if self.window.is_visible() {
+            self.hide();
+        } else {
+            self.show();
+        }
+    }
+
     fn create_entry(&self, content_box: &gtk::Box, entry: &str) -> gtk::Button {
         let entry_clone = entry.to_owned();
         let button = gtk::Button::new();

src/ui/utilities_panel.rs

@@ -7,6 +7,7 @@ use crate::backend::{BackendChannels, json_socket};
 use crate::ui::action_centre::ActionCentre;
 use crate::ui::widgets::{ExpandableBarItem, IconSlider};
 use battery::State;
+use crossbeam_channel::TryRecvError;
 use glib::prelude::Cast;
 use glib::subclass::prelude::ObjectSubclassIsExt;
 use glib::{ControlFlow, clone};
@@ -205,9 +206,9 @@ pub fn build(
         display,
         move |_| {
             if action_centre.window.is_visible() {
-                action_centre.hide_action_centre();
+                action_centre.hide();
             } else {
-                action_centre.show_action_centre(monitor_idx, &display);
+                action_centre.show(monitor_idx, &display);
             }
         }
     ));
@@ -390,43 +391,61 @@ pub fn build(
                     }
                 }
             }
-            while let Ok(result) = net_rx.try_recv() {
+            loop {
-                trace!(&LOGGER, "NetworkResult: {:?}", result);
+                match net_rx.try_recv() {
-                match result {
+                    Ok(result) => {
-                    NetworkState::ChangeNetwork(cfg) => {
+                        trace!(&LOGGER, "NetworkResult: {:?}", result);
-                        match cfg {
+                        match result {
-                            Some(network) => {
+                            NetworkState::ChangeNetwork(cfg) => {
-                                match network.network_type {
+                                println!("Change network: {cfg:?}");
-                                    NetworkType::Wifi => {
+                                match cfg {
-                                        //let idx = ((20.0 / 100.0) * (WIFI_ICON_PATHS.len() - 1) as f32 + 0.5) as usize;
+                                    Some(network) => {
-                                        let idx = ((network.signal as f32 / 100.0)
+                                        match network.network_type {
-                                            * (WIFI_ICON_PATHS.len() - 1) as f32
+                                            NetworkType::Wifi => {
-                                            + 0.5)
+                                                //let idx = ((20.0 / 100.0) * (WIFI_ICON_PATHS.len() - 1) as f32 + 0.5) as usize;
-                                            as usize;
+                                                let idx = ((network.signal as f32 / 100.0)
-                                        network_icon.set_from_file(Some(WIFI_ICON_PATHS[idx]));
+                                                    * (WIFI_ICON_PATHS.len() - 1) as f32
-                                        network_label.set_label(&network.name);
+                                                    + 0.5)
-                                        network_label.set_visible(true);
+                                                    as usize;
+                                                network_icon
+                                                    .set_from_file(Some(WIFI_ICON_PATHS[idx]));
+                                                network_label.set_label(&network.name);
+                                                network_label.set_visible(true);
+                                            }
+                                            NetworkType::Wired => {
+                                                network_icon
+                                                    .set_from_file(Some("icons/ethernet.svg"));
+                                                network_label.set_visible(false);
+                                            }
+                                        }
                                     }
-                                    NetworkType::Wired => {
+                                    None => {
-                                        network_icon.set_from_file(Some("icons/ethernet.svg"));
+                                        network_icon.set_from_file(Some("icons/disconnected.svg"));
                                         network_label.set_visible(false);
                                     }
                                 }
                             }
-                            None => {
+                            NetworkState::VpnState { connected, profile }
-                                network_icon.set_from_file(Some("icons/disconnected.svg"));
+                                if profile.as_str() == "wg" =>
-                                network_label.set_visible(false);
+                            {
+                                if connected {
+                                    wg_button.add_css_class("on");
+                                } else {
+                                    wg_button.remove_css_class("on");
+                                }
+                            }
+                            _ => {}
+                        }
+                    }
+                    Err(e) => {
+                        match e {
+                            TryRecvError::Empty => {}
+                            TryRecvError::Disconnected => {
+                                warn!(&LOGGER, "Network channel disconnected")
                             }
                         }
+                        break;
                     }
-                    NetworkState::VpnState { connected, profile } if profile.as_str() == "wg" => {
-                        if connected {
-                            wg_button.add_css_class("on");
-                        } else {
-                            wg_button.remove_css_class("on");
-                        }
-                    }
-                    _ => {}
                 }
             }
             while let Ok(tailscale_state) = netbird_rx.try_recv() {