WIP update of networkmanager & volume modules

src/modules/networkmanager.rs

@@ -6,15 +6,15 @@ use gtk::{Box as GtkBox, Image, Orientation};
 use serde::Deserialize;
 use tokio::sync::mpsc::Receiver;
 
+use crate::channels::{AsyncSenderExt, BroadcastReceiverExt};
+use crate::clients::networkmanager::Client;
 use crate::clients::networkmanager::state::{
     CellularState, State, VpnState, WifiState, WiredState,
 };
-use crate::clients::networkmanager::Client;
 use crate::config::CommonConfig;
 use crate::gtk_helpers::IronbarGtkExt;
-use crate::image::ImageProvider;
 use crate::modules::{Module, ModuleInfo, ModuleParts, ModuleUpdateEvent, WidgetContext};
-use crate::{glib_recv, module_impl, send_async, spawn};
+use crate::{module_impl, spawn};
 
 #[derive(Debug, Deserialize, Clone)]
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
@@ -38,9 +38,9 @@ impl Module<GtkBox> for NetworkManagerModule {
 
     fn spawn_controller(
         &self,
-        _: &ModuleInfo,
+        _info: &ModuleInfo,
         context: &WidgetContext<State, ()>,
-        _: Receiver<()>,
+        _rx: Receiver<()>,
     ) -> Result<()> {
         let client = context.try_client::<Client>()?;
         let mut client_signal = client.subscribe().to_stream();
@@ -48,7 +48,9 @@ impl Module<GtkBox> for NetworkManagerModule {
 
         spawn(async move {
             while let Some(state) = client_signal.next().await {
-                send_async!(widget_transmitter, ModuleUpdateEvent::Update(state));
+                widget_transmitter
+                    .send_expect(ModuleUpdateEvent::Update(state))
+                    .await;
             }
         });
 
@@ -58,7 +60,7 @@ impl Module<GtkBox> for NetworkManagerModule {
     fn into_widget(
         self,
         context: WidgetContext<State, ()>,
-        info: &ModuleInfo,
+        _info: &ModuleInfo,
     ) -> Result<ModuleParts<GtkBox>> {
         let container = GtkBox::new(Orientation::Horizontal, 0);
 
@@ -86,48 +88,80 @@ impl Module<GtkBox> for NetworkManagerModule {
         vpn_icon.add_class("vpn-icon");
         container.add(&vpn_icon);
 
-        let icon_theme = info.icon_theme.clone();
-        glib_recv!(context.subscribe(), state => {
-            macro_rules! update_icon {
-                (
-                    $icon_var:expr,
-                    $state_type:ident,
-                    {$($state:pat => $icon_name:expr,)+}
-                ) => {
-                    let icon_name = match state.$state_type {
-                        $($state => $icon_name,)+
-                    };
-                    if icon_name.is_empty() {
-                        $icon_var.hide();
-                    } else {
-                        ImageProvider::parse(icon_name, &icon_theme, false, self.icon_size)
-                            .map(|provider| provider.load_into_image($icon_var.clone()));
-                        $icon_var.show();
-                    }
-                };
-            }
+        context.subscribe().recv_glib_async((), move |(), state| {
+            // TODO: Make this whole section less boneheaded
 
-            update_icon!(wired_icon, wired, {
+            let wired_icon_name = match state.wired {
                 WiredState::Connected => "icon:network-wired-symbolic",
                 WiredState::Disconnected => "icon:network-wired-disconnected-symbolic",
                 WiredState::NotPresent | WiredState::Unknown => "",
-            });
-            update_icon!(wifi_icon, wifi, {
+            };
+            let wifi_icon_name = match state.wifi {
                 WifiState::Connected(_) => "icon:network-wireless-connected-symbolic",
                 WifiState::Disconnected => "icon:network-wireless-offline-symbolic",
                 WifiState::Disabled => "icon:network-wireless-hardware-disabled-symbolic",
                 WifiState::NotPresent | WifiState::Unknown => "",
-            });
-            update_icon!(cellular_icon, cellular, {
+            };
+            let cellular_icon_name = match state.cellular {
                 CellularState::Connected => "icon:network-cellular-connected-symbolic",
                 CellularState::Disconnected => "icon:network-cellular-offline-symbolic",
                 CellularState::Disabled => "icon:network-cellular-hardware-disabled-symbolic",
                 CellularState::NotPresent | CellularState::Unknown => "",
-            });
-            update_icon!(vpn_icon, vpn, {
+            };
+            let vpn_icon_name = match state.vpn {
                 VpnState::Connected(_) => "icon:network-vpn-symbolic",
                 VpnState::Disconnected | VpnState::Unknown => "",
-            });
+            };
+
+            let wired_icon = wired_icon.clone();
+            let wifi_icon = wifi_icon.clone();
+            let cellular_icon = cellular_icon.clone();
+            let vpn_icon = vpn_icon.clone();
+
+            let image_provider = context.ironbar.image_provider();
+
+            async move {
+                if wired_icon_name.is_empty() {
+                    wired_icon.hide();
+                } else {
+                    image_provider
+                        .load_into_image_silent(wired_icon_name, self.icon_size, false, &wired_icon)
+                        .await;
+                    wired_icon.show();
+                }
+
+                if wifi_icon_name.is_empty() {
+                    wifi_icon.hide();
+                } else {
+                    image_provider
+                        .load_into_image_silent(wifi_icon_name, self.icon_size, false, &wifi_icon)
+                        .await;
+                    wifi_icon.show();
+                }
+
+                if cellular_icon_name.is_empty() {
+                    cellular_icon.hide();
+                } else {
+                    image_provider
+                        .load_into_image_silent(
+                            cellular_icon_name,
+                            self.icon_size,
+                            false,
+                            &cellular_icon,
+                        )
+                        .await;
+                    cellular_icon.show();
+                }
+
+                if vpn_icon_name.is_empty() {
+                    vpn_icon.hide();
+                } else {
+                    image_provider
+                        .load_into_image_silent(vpn_icon_name, self.icon_size, false, &vpn_icon)
+                        .await;
+                    vpn_icon.show();
+                }
+            }
         });
 
         Ok(ModuleParts::new(container, None))