ROGCC: share PageState so tray can use it. zbus notifs update this

asusctl/src/main.rs

@@ -539,7 +539,6 @@ fn handle_led_power_1_do_tuf(
         x19b6: vec![],
         tuf: enabled,
     };
-    dbg!(&data);
     dbus.proxies().led().set_leds_power(data, true)?;
 
     let data = AuraPowerDev {

daemon/src/lib.rs

@@ -64,7 +64,6 @@ macro_rules! task_watch_item {
                             let mut buffer = [0; 32];
                             watch.event_stream(&mut buffer).unwrap().for_each(|_| async {
                                 let value = ctrl.$name();
-                                dbg!(&value);
                                 concat_idents::concat_idents!(notif_fn = notify_, $name {
                                     Self::notif_fn(&signal_ctxt, value).await.ok();
                                 });

rog-control-center/src/app.rs

@@ -1,10 +1,8 @@
 use std::{
     f64::consts::PI,
-    io::Write,
     sync::{
         atomic::{AtomicBool, AtomicU8, Ordering},
-        mpsc::Receiver,
+        Arc, Mutex,
-        Arc,
     },
     time::{Duration, Instant},
 };
@@ -13,17 +11,15 @@ use egui::{Button, RichText};
 use rog_platform::supported::SupportedFunctions;
 
 use crate::{
-    config::Config, error::Result, get_ipc_file, page_states::PageDataStates, tray::TrayToApp,
+    config::Config, error::Result, page_states::PageDataStates, Page, RogDbusClientBlocking,
-    Page, RogDbusClientBlocking, SHOW_GUI,
 };
 
-pub struct RogApp<'a> {
+pub struct RogApp {
     pub page: Page,
-    pub states: PageDataStates,
+    pub states: Arc<Mutex<PageDataStates>>,
     pub supported: SupportedFunctions,
     // TODO: can probably just open and read whenever
     pub config: Config,
-    pub asus_dbus: RogDbusClientBlocking<'a>,
     /// Oscillator in percentage
     pub oscillator1: Arc<AtomicU8>,
     pub oscillator2: Arc<AtomicU8>,
@@ -32,15 +28,13 @@ pub struct RogApp<'a> {
     pub oscillator_freq: Arc<AtomicU8>,
     /// A toggle that toggles true/false when the oscillator reaches 0
     pub oscillator_toggle: Arc<AtomicBool>,
-    pub app_cmd: Arc<Receiver<TrayToApp>>,
 }
 
-impl<'a> RogApp<'a> {
+impl RogApp {
     /// Called once before the first frame.
     pub fn new(
         config: Config,
-        states: PageDataStates,
+        states: Arc<Mutex<PageDataStates>>,
-        app_cmd: Arc<Receiver<TrayToApp>>,
         _cc: &eframe::CreationContext<'_>,
     ) -> Result<Self> {
         let (dbus, _) = RogDbusClientBlocking::new()?;
@@ -60,6 +54,9 @@ impl<'a> RogApp<'a> {
         let oscillator_freq1 = oscillator_freq.clone();
         let oscillator_toggle = Arc::new(AtomicBool::new(false));
         let oscillator_toggle1 = oscillator_toggle.clone();
+
+        let states1 = states.clone();
+        let supported1 = supported.clone();
         std::thread::spawn(move || {
             let started = Instant::now();
             let mut toggled = false;
@@ -88,6 +85,14 @@ impl<'a> RogApp<'a> {
                 oscillator1_1.store(tmp1, Ordering::SeqCst);
                 oscillator1_2.store(tmp2, Ordering::SeqCst);
                 oscillator1_3.store(tmp3, Ordering::SeqCst);
+
+                if let Ok(mut states) = states1.try_lock() {
+                    states
+                        .refresh_if_notfied(&supported1)
+                        .map_err(|e| states.error = Some(e.to_string()))
+                        .ok();
+                }
+
                 std::thread::sleep(Duration::from_millis(33));
             }
         });
@@ -97,88 +102,72 @@ impl<'a> RogApp<'a> {
             states,
             page: Page::System,
             config,
-            asus_dbus: dbus,
             oscillator1,
             oscillator2,
             oscillator3,
             oscillator_toggle,
             oscillator_freq,
-            app_cmd,
         })
     }
-
-    fn check_app_cmds(&mut self, _ctx: &egui::Context, _frame: &mut eframe::Frame) {
-        let Self { app_cmd, .. } = self;
-
-        if let Ok(cmd) = app_cmd.try_recv() {
-            match cmd {
-                TrayToApp::Open => {
-                    dbg!();
-                    get_ipc_file().unwrap().write_all(&[SHOW_GUI]).ok();
-                }
-                TrayToApp::Quit => _frame.close(),
-            }
-        }
-    }
 }
 
-impl<'a> eframe::App for RogApp<'a> {
+impl eframe::App for RogApp {
     /// Called each time the UI needs repainting, which may be many times per second.
     /// Put your widgets into a `SidePanel`, `TopPanel`, `CentralPanel`, `Window` or `Area`.
     fn update(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
-        self.check_app_cmds(ctx, frame);
+        let states = self.states.clone();
 
-        let Self {
+        if let Ok(mut states) = states.try_lock() {
-            supported,
+            if states.app_should_update {
-            asus_dbus: dbus,
+                states.app_should_update = false;
-            states,
+                ctx.request_repaint();
-            ..
+            }
-        } = self;
+        }
-
-        states
-            .refresh_if_notfied(supported, dbus)
-            .map(|repaint| {
-                if repaint {
-                    ctx.request_repaint();
-                }
-            })
-            .map_err(|e| self.states.error = Some(e.to_string()))
-            .ok();
 
         let page = self.page;
 
         self.top_bar(ctx, frame);
         self.side_panel(ctx);
 
-        if let Some(err) = self.states.error.clone() {
+        let mut was_error = false;
-            egui::CentralPanel::default().show(ctx, |ui| {
-                ui.heading(RichText::new("Error!").size(28.0));
 
-                ui.centered_and_justified(|ui| {
+        if let Ok(mut states) = states.try_lock() {
-                    ui.label(RichText::new(format!("The error was: {:?}", err)).size(22.0));
+            if let Some(err) = states.error.clone() {
-                });
+                was_error = true;
-            });
+                egui::CentralPanel::default().show(ctx, |ui| {
-            egui::TopBottomPanel::bottom("error_bar")
+                    ui.heading(RichText::new("Error!").size(28.0));
-                .default_height(26.0)
+
-                .show(ctx, |ui| {
+                    ui.centered_and_justified(|ui| {
-                    ui.with_layout(egui::Layout::right_to_left(egui::Align::TOP), |ui| {
+                        ui.label(RichText::new(format!("The error was: {:?}", err)).size(22.0));
-                        if ui
-                            .add(Button::new(RichText::new("Okay").size(20.0)))
-                            .clicked()
-                        {
-                            self.states.error = None;
-                        }
                     });
                 });
-        } else if page == Page::System {
+                egui::TopBottomPanel::bottom("error_bar")
-            self.system_page(ctx);
+                    .default_height(26.0)
-        } else if page == Page::AuraEffects {
+                    .show(ctx, |ui| {
-            self.aura_page(ctx);
+                        ui.with_layout(egui::Layout::right_to_left(egui::Align::TOP), |ui| {
-        // TODO: Anime page is not complete
+                            if ui
-        // } else if page == Page::AnimeMatrix {
+                                .add(Button::new(RichText::new("Okay").size(20.0)))
-        //     self.anime_page(ctx);
+                                .clicked()
-        } else if page == Page::FanCurves {
+                            {
-            self.fan_curve_page(ctx);
+                                states.error = None;
+                            }
+                        });
+                    });
+            }
+        }
+        if !was_error {
+            if let Ok(mut states) = states.try_lock() {
+                if page == Page::System {
+                    self.system_page(&mut states, ctx);
+                } else if page == Page::AuraEffects {
+                    self.aura_page(&mut states, ctx);
+                // TODO: Anime page is not complete
+                // } else if page == Page::AnimeMatrix {
+                //     self.anime_page(ctx);
+                } else if page == Page::FanCurves {
+                    self.fan_curve_page(&mut states, ctx);
+                }
+            }
         }
     }
 }

rog-control-center/src/main.rs

@@ -2,20 +2,19 @@ use eframe::{IconData, NativeOptions};
 use log::{error, LevelFilter};
 use rog_aura::layouts::KeyLayout;
 use rog_control_center::notify::EnabledNotifications;
-use rog_control_center::tray::{AppToTray, TrayToApp};
+use rog_control_center::tray::init_tray;
 use rog_control_center::{
     config::Config, error::Result, get_ipc_file, notify::start_notifications, on_tmp_dir_exists,
-    page_states::PageDataStates, print_versions, startup_error::AppErrorShow, tray::init_tray,
+    page_states::PageDataStates, print_versions, startup_error::AppErrorShow, RogApp,
-    RogApp, RogDbusClientBlocking, SHOWING_GUI, SHOW_GUI,
+    RogDbusClientBlocking, SHOWING_GUI, SHOW_GUI,
 };
 use rog_platform::supported::SupportedFunctions;
-use std::sync::mpsc::{channel, Receiver, Sender};
 use std::sync::Mutex;
 use std::{
     fs::OpenOptions,
     io::{Read, Write},
     path::PathBuf,
-    sync::{atomic::AtomicBool, Arc},
+    sync::Arc,
 };
 use tokio::runtime::Runtime;
 
@@ -73,10 +72,6 @@ fn main() -> Result<()> {
         }
     };
 
-    let (send, recv) = channel();
-    let update_tray = Arc::new(Mutex::new(send));
-    let app_cmd = Arc::new(init_tray(supported.clone(), recv));
-
     // Startup
     let mut config = Config::load()?;
     let mut start_closed = config.startup_in_background;
@@ -123,18 +118,15 @@ fn main() -> Result<()> {
         Err(_) => on_tmp_dir_exists().unwrap(),
     };
 
-    let states = setup_page_state_and_notifs(
+    let states = Arc::new(Mutex::new(
-        layout,
+        setup_page_state_and_notifs(layout, enabled_notifications, &supported).unwrap(),
-        &dbus,
+    ));
-        enabled_notifications,
+
-        update_tray,
+    init_tray(supported, states.clone());
-        &supported,
-    )
-    .unwrap();
 
     loop {
         if !start_closed {
-            start_app(states.clone(), native_options.clone(), app_cmd.clone())?;
+            start_app(states.clone(), native_options.clone())?;
         }
 
         let config = Config::load().unwrap();
@@ -162,58 +154,24 @@ fn main() -> Result<()> {
 
 fn setup_page_state_and_notifs(
     keyboard_layout: KeyLayout,
-    dbus: &RogDbusClientBlocking,
     enabled_notifications: Arc<Mutex<EnabledNotifications>>,
-    update_tray: Arc<Mutex<Sender<AppToTray>>>,
     supported: &SupportedFunctions,
 ) -> Result<PageDataStates> {
-    // Cheap method to alert to notifications rather than spinning a thread for each
+    let page_states =
-    // This is quite different when done in a retained mode app
+        PageDataStates::new(keyboard_layout, enabled_notifications.clone(), supported)?;
-    let charge_notified = Arc::new(AtomicBool::new(false));
-    let bios_notified = Arc::new(AtomicBool::new(false));
-    let aura_notified = Arc::new(AtomicBool::new(false));
-    let anime_notified = Arc::new(AtomicBool::new(false));
-    let profiles_notified = Arc::new(AtomicBool::new(false));
-    let fans_notified = Arc::new(AtomicBool::new(false));
 
-    start_notifications(
+    start_notifications(page_states.was_notified.clone(), enabled_notifications)?;
-        charge_notified.clone(),
-        bios_notified.clone(),
-        aura_notified.clone(),
-        anime_notified.clone(),
-        profiles_notified.clone(),
-        fans_notified.clone(),
-        enabled_notifications.clone(),
-        update_tray,
-    )?;
 
-    PageDataStates::new(
+    Ok(page_states)
-        keyboard_layout,
-        enabled_notifications,
-        charge_notified,
-        bios_notified,
-        aura_notified,
-        anime_notified,
-        profiles_notified,
-        fans_notified,
-        supported,
-        dbus,
-    )
 }
 
-fn start_app(
+fn start_app(states: Arc<Mutex<PageDataStates>>, native_options: NativeOptions) -> Result<()> {
-    states: PageDataStates,
-    native_options: NativeOptions,
-    app_cmd: Arc<Receiver<TrayToApp>>,
-) -> Result<()> {
     let mut ipc_file = get_ipc_file().unwrap();
     ipc_file.write_all(&[SHOWING_GUI]).unwrap();
     eframe::run_native(
         "ROG Control Center",
         native_options,
-        Box::new(move |cc| {
+        Box::new(move |cc| Box::new(RogApp::new(Config::load().unwrap(), states, cc).unwrap())),
-            Box::new(RogApp::new(Config::load().unwrap(), states, app_cmd, cc).unwrap())
-        }),
     );
     Ok(())
 }

rog-control-center/src/notify.rs

@@ -1,4 +1,4 @@
-use crate::{config::Config, error::Result, tray::AppToTray};
+use crate::{config::Config, error::Result};
 use notify_rust::{Hint, Notification, NotificationHandle, Urgency};
 use rog_dbus::{
     zbus_anime::AnimeProxy, zbus_led::LedProxy, zbus_platform::RogBiosProxy,
@@ -12,7 +12,6 @@ use std::{
     process::Command,
     sync::{
         atomic::{AtomicBool, Ordering},
-        mpsc::Sender,
         Arc, Mutex,
     },
 };
@@ -66,6 +65,18 @@ impl EnabledNotifications {
     }
 }
 
+/// Intended as a help to determine if daemon controllers notified state
+#[derive(Debug, Default, Clone)]
+pub struct WasNotified {
+    pub charge: Arc<AtomicBool>,
+    pub bios: Arc<AtomicBool>,
+    pub aura: Arc<AtomicBool>,
+    pub anime: Arc<AtomicBool>,
+    pub profiles: Arc<AtomicBool>,
+    pub fans: Arc<AtomicBool>,
+    pub gfx: Arc<AtomicBool>,
+}
+
 macro_rules! notify {
     ($notifier:expr, $last_notif:ident) => {
         if let Some(notif) = $last_notif.take() {
@@ -77,6 +88,7 @@ macro_rules! notify {
     };
 }
 
+// TODO: drop the macro and use generics plus closure
 macro_rules! recv_notif {
     ($proxy:ident,
         $signal:ident,
@@ -101,9 +113,9 @@ macro_rules! recv_notif {
                                     if let Ok(ref mut lock) = last_notif.try_lock() {
                                         notify!($notifier($msg, &out$(.$out_arg)+()), lock);
                                     }
-                                    notified.store(true, Ordering::SeqCst);
                                 }
                             }
+                            notified.store(true, Ordering::SeqCst);
                         }
                     }
                 };
@@ -114,17 +126,21 @@ macro_rules! recv_notif {
 type SharedHandle = Arc<Mutex<Option<NotificationHandle>>>;
 
 pub fn start_notifications(
-    charge_notified: Arc<AtomicBool>,
+    was_notified: WasNotified,
-    bios_notified: Arc<AtomicBool>,
-    aura_notified: Arc<AtomicBool>,
-    anime_notified: Arc<AtomicBool>,
-    profiles_notified: Arc<AtomicBool>,
-    _fans_notified: Arc<AtomicBool>,
     enabled_notifications: Arc<Mutex<EnabledNotifications>>,
-    update_tray: Arc<std::sync::Mutex<Sender<AppToTray>>>,
 ) -> Result<()> {
     let last_notification: SharedHandle = Arc::new(Mutex::new(None));
 
+    let WasNotified {
+        bios: bios_notified,
+        charge: charge_notified,
+        profiles: profiles_notified,
+        aura: aura_notified,
+        anime: anime_notified,
+        gfx: gfx_notified,
+        ..
+    } = was_notified;
+
     // BIOS notif
     recv_notif!(
         RogBiosProxy,
@@ -275,7 +291,6 @@ pub fn start_notifications(
     //     do_gfx_action_notif
     // );
 
-    let bios_notified1 = bios_notified.clone();
     tokio::spawn(async move {
         let conn = zbus::Connection::system().await.unwrap();
         let proxy = SuperProxy::new(&conn).await.unwrap();
@@ -285,15 +300,14 @@ pub fn start_notifications(
                     let action = out.action();
                     do_gfx_action_notif("Gfx mode change requires", &format!("{action:?}",))
                         .unwrap();
+                    bios_notified.store(true, Ordering::SeqCst);
                 }
             }
-            bios_notified1.store(true, Ordering::SeqCst);
         };
     });
 
     let notifs_enabled1 = enabled_notifications;
     let last_notif = last_notification;
-    let bios_notified1 = bios_notified;
     tokio::spawn(async move {
         let conn = zbus::Connection::system().await.unwrap();
         let proxy = SuperProxy::new(&conn).await.unwrap();
@@ -313,13 +327,10 @@ pub fn start_notifications(
                                 }
                             }
                         }
-                        if let Ok(lock) = update_tray.try_lock() {
+                        gfx_notified.store(true, Ordering::SeqCst);
-                            lock.send(AppToTray::DgpuStatus(*status)).ok();
-                        }
                     }
                 }
             }
-            bios_notified1.store(true, Ordering::SeqCst);
         };
     });
 

rog-control-center/src/page_states.rs

@@ -1,24 +1,28 @@
 use std::{
     collections::{BTreeMap, HashSet},
-    sync::{
+    sync::{atomic::Ordering, Arc, Mutex},
-        atomic::{AtomicBool, Ordering},
-        Arc, Mutex,
-    },
 };
 
 use egui::Vec2;
 use rog_aura::{layouts::KeyLayout, usb::AuraPowerDev, AuraEffect, AuraModeNum};
 use rog_platform::{platform::GpuMode, supported::SupportedFunctions};
 use rog_profiles::{fan_curve_set::FanCurveSet, FanCurvePU, Profile};
+use supergfxctl::{
+    pci_device::{GfxMode, GfxPower},
+    zbus_proxy::DaemonProxyBlocking as GfxProxyBlocking,
+};
 
-use crate::{error::Result, notify::EnabledNotifications, RogDbusClientBlocking};
+use crate::{
+    error::Result,
+    notify::{EnabledNotifications, WasNotified},
+    RogDbusClientBlocking,
+};
 
 #[derive(Clone, Debug)]
 pub struct BiosState {
     /// To be shared to a thread that checks notifications.
     /// It's a bit general in that it won't provide *what* was
     /// updated, so the full state needs refresh
-    pub was_notified: Arc<AtomicBool>,
     pub post_sound: bool,
     pub dedicated_gfx: GpuMode,
     pub panel_overdrive: bool,
@@ -27,13 +31,8 @@ pub struct BiosState {
 }
 
 impl BiosState {
-    pub fn new(
+    pub fn new(supported: &SupportedFunctions, dbus: &RogDbusClientBlocking) -> Result<Self> {
-        was_notified: Arc<AtomicBool>,
-        supported: &SupportedFunctions,
-        dbus: &RogDbusClientBlocking,
-    ) -> Result<Self> {
         Ok(Self {
-            was_notified,
             post_sound: if supported.rog_bios_ctrl.post_sound {
                 dbus.proxies().rog_bios().post_boot_sound()? != 0
             } else {
@@ -58,19 +57,13 @@ impl BiosState {
 
 #[derive(Clone, Debug)]
 pub struct ProfilesState {
-    pub was_notified: Arc<AtomicBool>,
     pub list: Vec<Profile>,
     pub current: Profile,
 }
 
 impl ProfilesState {
-    pub fn new(
+    pub fn new(supported: &SupportedFunctions, dbus: &RogDbusClientBlocking) -> Result<Self> {
-        was_notified: Arc<AtomicBool>,
-        supported: &SupportedFunctions,
-        dbus: &RogDbusClientBlocking,
-    ) -> Result<Self> {
         Ok(Self {
-            was_notified,
             list: if supported.platform_profile.platform_profile {
                 let mut list = dbus.proxies().profile().profiles()?;
                 list.sort();
@@ -89,7 +82,6 @@ impl ProfilesState {
 
 #[derive(Clone, Debug)]
 pub struct FanCurvesState {
-    pub was_notified: Arc<AtomicBool>,
     pub show_curve: Profile,
     pub show_graph: FanCurvePU,
     pub enabled: HashSet<Profile>,
@@ -98,11 +90,7 @@ pub struct FanCurvesState {
 }
 
 impl FanCurvesState {
-    pub fn new(
+    pub fn new(supported: &SupportedFunctions, dbus: &RogDbusClientBlocking) -> Result<Self> {
-        was_notified: Arc<AtomicBool>,
-        supported: &SupportedFunctions,
-        dbus: &RogDbusClientBlocking,
-    ) -> Result<Self> {
         let profiles = if supported.platform_profile.platform_profile {
             dbus.proxies().profile().profiles()?
         } else {
@@ -143,7 +131,6 @@ impl FanCurvesState {
         };
 
         Ok(Self {
-            was_notified,
             show_curve,
             show_graph: FanCurvePU::CPU,
             enabled,
@@ -155,7 +142,6 @@ impl FanCurvesState {
 
 #[derive(Clone, Debug)]
 pub struct AuraState {
-    pub was_notified: Arc<AtomicBool>,
     pub current_mode: AuraModeNum,
     pub modes: BTreeMap<AuraModeNum, AuraEffect>,
     pub enabled: AuraPowerDev,
@@ -167,13 +153,8 @@ pub struct AuraState {
 }
 
 impl AuraState {
-    pub fn new(
+    pub fn new(supported: &SupportedFunctions, dbus: &RogDbusClientBlocking) -> Result<Self> {
-        was_notified: Arc<AtomicBool>,
-        supported: &SupportedFunctions,
-        dbus: &RogDbusClientBlocking,
-    ) -> Result<Self> {
         Ok(Self {
-            was_notified,
             current_mode: if !supported.keyboard_led.stock_led_modes.is_empty() {
                 dbus.proxies().led().led_mode().unwrap_or_default()
             } else {
@@ -214,7 +195,6 @@ impl AuraState {
 
 #[derive(Clone, Debug)]
 pub struct AnimeState {
-    pub was_notified: Arc<AtomicBool>,
     pub bright: u8,
     pub boot: bool,
     pub awake: bool,
@@ -222,13 +202,8 @@ pub struct AnimeState {
 }
 
 impl AnimeState {
-    pub fn new(
+    pub fn new(supported: &SupportedFunctions, dbus: &RogDbusClientBlocking) -> Result<Self> {
-        was_notified: Arc<AtomicBool>,
-        supported: &SupportedFunctions,
-        dbus: &RogDbusClientBlocking,
-    ) -> Result<Self> {
         Ok(Self {
-            was_notified,
             boot: if supported.anime_ctrl.0 {
                 dbus.proxies().anime().boot_enabled()?
             } else {
@@ -246,11 +221,25 @@ impl AnimeState {
     }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Clone, Debug)]
+pub struct GfxState {
+    pub mode: GfxMode,
+    pub power_status: GfxPower,
+}
+
+impl GfxState {
+    pub fn new(_supported: &SupportedFunctions, dbus: &GfxProxyBlocking) -> Result<Self> {
+        Ok(Self {
+            mode: dbus.mode()?,
+            power_status: dbus.power()?,
+        })
+    }
+}
+
 pub struct PageDataStates {
     pub keyboard_layout: KeyLayout,
     pub enabled_notifications: Arc<Mutex<EnabledNotifications>>,
-    pub was_notified: Arc<AtomicBool>,
+    pub was_notified: WasNotified,
     /// Because much of the app state here is the same as `RogBiosSupportedFunctions`
     /// we can re-use that structure.
     pub bios: BiosState,
@@ -258,87 +247,116 @@ pub struct PageDataStates {
     pub anime: AnimeState,
     pub profiles: ProfilesState,
     pub fan_curves: FanCurvesState,
+    pub gfx_state: GfxState,
     pub charge_limit: u8,
     pub error: Option<String>,
+    /// Specific field for the tray only so that we can know when it does need update.
+    /// The tray should set this to false when done.
+    pub tray_should_update: bool,
+    pub app_should_update: bool,
+    pub asus_dbus: RogDbusClientBlocking<'static>,
+    pub gfx_dbus: GfxProxyBlocking<'static>,
 }
 
-#[allow(clippy::too_many_arguments)]
 impl PageDataStates {
+    /// Creates self, including the relevant dbus connections and proixies for internal use
     pub fn new(
         keyboard_layout: KeyLayout,
         enabled_notifications: Arc<Mutex<EnabledNotifications>>,
-        charge_notified: Arc<AtomicBool>,
-        bios_notified: Arc<AtomicBool>,
-        aura_notified: Arc<AtomicBool>,
-        anime_notified: Arc<AtomicBool>,
-        profiles_notified: Arc<AtomicBool>,
-        fans_notified: Arc<AtomicBool>,
         supported: &SupportedFunctions,
-        dbus: &RogDbusClientBlocking,
     ) -> Result<Self> {
+        let (asus_dbus, conn) = RogDbusClientBlocking::new().unwrap();
+        let gfx_dbus = GfxProxyBlocking::new(&conn).unwrap();
         Ok(Self {
             keyboard_layout,
             enabled_notifications,
-            was_notified: charge_notified,
+            was_notified: WasNotified::default(),
-            charge_limit: dbus.proxies().charge().charge_control_end_threshold()?,
+            charge_limit: asus_dbus
-            bios: BiosState::new(bios_notified, supported, dbus)?,
+                .proxies()
-            aura: AuraState::new(aura_notified, supported, dbus)?,
+                .charge()
-            anime: AnimeState::new(anime_notified, supported, dbus)?,
+                .charge_control_end_threshold()?,
-            profiles: ProfilesState::new(profiles_notified, supported, dbus)?,
+            bios: BiosState::new(supported, &asus_dbus)?,
-            fan_curves: FanCurvesState::new(fans_notified, supported, dbus)?,
+            aura: AuraState::new(supported, &asus_dbus)?,
+            anime: AnimeState::new(supported, &asus_dbus)?,
+            profiles: ProfilesState::new(supported, &asus_dbus)?,
+            fan_curves: FanCurvesState::new(supported, &asus_dbus)?,
+            gfx_state: GfxState::new(supported, &gfx_dbus)?,
             error: None,
+            tray_should_update: true,
+            app_should_update: true,
+            asus_dbus,
+            gfx_dbus,
         })
     }
 
-    pub fn refresh_if_notfied(
+    pub fn refresh_if_notfied(&mut self, supported: &SupportedFunctions) -> Result<bool> {
-        &mut self,
-        supported: &SupportedFunctions,
-        dbus: &RogDbusClientBlocking,
-    ) -> Result<bool> {
         let mut notified = false;
-        if self.was_notified.load(Ordering::SeqCst) {
+        if self.was_notified.charge.load(Ordering::SeqCst) {
-            self.charge_limit = dbus.proxies().charge().charge_control_end_threshold()?;
+            self.charge_limit = self
-            self.was_notified.store(false, Ordering::SeqCst);
+                .asus_dbus
+                .proxies()
+                .charge()
+                .charge_control_end_threshold()?;
+            self.was_notified.charge.store(false, Ordering::SeqCst);
             notified = true;
+            self.tray_should_update = true;
+            self.app_should_update = true;
         }
 
-        if self.aura.was_notified.load(Ordering::SeqCst) {
+        if self.was_notified.aura.load(Ordering::SeqCst) {
-            self.aura = AuraState::new(self.aura.was_notified.clone(), supported, dbus)?;
+            self.aura = AuraState::new(supported, &self.asus_dbus)?;
-            self.aura.was_notified.store(false, Ordering::SeqCst);
+            self.was_notified.aura.store(false, Ordering::SeqCst);
             notified = true;
+            self.tray_should_update = true;
+            self.app_should_update = true;
         }
 
-        if self.bios.was_notified.load(Ordering::SeqCst) {
+        if self.was_notified.bios.load(Ordering::SeqCst) {
-            self.bios = BiosState::new(self.bios.was_notified.clone(), supported, dbus)?;
+            self.bios = BiosState::new(supported, &self.asus_dbus)?;
-            self.bios.was_notified.store(false, Ordering::SeqCst);
+            self.was_notified.bios.store(false, Ordering::SeqCst);
             notified = true;
+            self.tray_should_update = true;
+            self.app_should_update = true;
         }
 
-        if self.profiles.was_notified.load(Ordering::SeqCst) {
+        if self.was_notified.profiles.load(Ordering::SeqCst) {
-            self.profiles =
+            self.profiles = ProfilesState::new(supported, &self.asus_dbus)?;
-                ProfilesState::new(self.profiles.was_notified.clone(), supported, dbus)?;
+            self.was_notified.profiles.store(false, Ordering::SeqCst);
-            self.profiles.was_notified.store(false, Ordering::SeqCst);
             notified = true;
+            self.tray_should_update = true;
+            self.app_should_update = true;
         }
 
-        if self.fan_curves.was_notified.load(Ordering::SeqCst) {
+        if self.was_notified.fans.load(Ordering::SeqCst) {
-            self.fan_curves =
+            self.fan_curves = FanCurvesState::new(supported, &self.asus_dbus)?;
-                FanCurvesState::new(self.fan_curves.was_notified.clone(), supported, dbus)?;
+            self.was_notified.fans.store(false, Ordering::SeqCst);
-            self.fan_curves.was_notified.store(false, Ordering::SeqCst);
             notified = true;
+            self.tray_should_update = true;
+            self.app_should_update = true;
         }
+
+        if self.was_notified.gfx.load(Ordering::SeqCst) {
+            self.gfx_state = GfxState::new(supported, &self.gfx_dbus)?;
+            self.was_notified.gfx.store(false, Ordering::SeqCst);
+            notified = true;
+            self.tray_should_update = true;
+            self.app_should_update = true;
+        }
+
         Ok(notified)
     }
 }
 
 impl Default for PageDataStates {
     fn default() -> Self {
+        let (asus_dbus, conn) = RogDbusClientBlocking::new().unwrap();
+        let gfx_dbus = GfxProxyBlocking::new(&conn).unwrap();
+
         Self {
             keyboard_layout: KeyLayout::ga401_layout(),
             enabled_notifications: Default::default(),
-            was_notified: Default::default(),
+            was_notified: WasNotified::default(),
             bios: BiosState {
-                was_notified: Default::default(),
                 post_sound: Default::default(),
                 dedicated_gfx: GpuMode::NotSupported,
                 panel_overdrive: Default::default(),
@@ -346,7 +364,6 @@ impl Default for PageDataStates {
                 egpu_enable: Default::default(),
             },
             aura: AuraState {
-                was_notified: Default::default(),
                 current_mode: AuraModeNum::Static,
                 modes: Default::default(),
                 enabled: AuraPowerDev {
@@ -360,27 +377,32 @@ impl Default for PageDataStates {
                 wave_blue: Default::default(),
             },
             anime: AnimeState {
-                was_notified: Default::default(),
                 bright: Default::default(),
                 boot: Default::default(),
                 awake: Default::default(),
                 sleep: Default::default(),
             },
             profiles: ProfilesState {
-                was_notified: Default::default(),
                 list: Default::default(),
                 current: Default::default(),
             },
             fan_curves: FanCurvesState {
-                was_notified: Default::default(),
                 show_curve: Default::default(),
                 show_graph: Default::default(),
                 enabled: Default::default(),
                 curves: Default::default(),
                 drag_delta: Default::default(),
             },
+            gfx_state: GfxState {
+                mode: GfxMode::None,
+                power_status: GfxPower::Unknown,
+            },
             charge_limit: Default::default(),
             error: Default::default(),
+            tray_should_update: true,
+            app_should_update: true,
+            asus_dbus,
+            gfx_dbus,
         }
     }
 }

rog-control-center/src/pages/anime_page.rs

@@ -1,6 +1,6 @@
 use crate::RogApp;
 
-impl<'a> RogApp<'a> {
+impl RogApp {
     pub fn anime_page(&mut self, ctx: &egui::Context) {
         egui::CentralPanel::default().show(ctx, |ui| {
             ui.label("In progress");

rog-control-center/src/pages/aura_page.rs

@@ -4,16 +4,15 @@ use egui::Color32;
 use rog_aura::{AuraEffect, AuraModeNum};
 
 use crate::{
+    page_states::PageDataStates,
     widgets::{aura_modes_group, keyboard},
     RogApp,
 };
 
-impl<'a> RogApp<'a> {
+impl RogApp {
-    pub fn aura_page(&mut self, ctx: &egui::Context) {
+    pub fn aura_page(&mut self, states: &mut PageDataStates, ctx: &egui::Context) {
         let Self {
             supported,
-            states,
-            asus_dbus: dbus,
             oscillator1,
             oscillator2,
             oscillator3,
@@ -26,7 +25,6 @@ impl<'a> RogApp<'a> {
         let blue = oscillator3.load(Ordering::SeqCst) as u32;
         states.aura.nudge_wave(red as u8, green as u8, blue as u8);
         // let osc = c.0 * 255 / osc;
-        // dbg!(osc);
         let c1 = states
             .aura
             .modes
@@ -72,7 +70,7 @@ impl<'a> RogApp<'a> {
 
         // TODO: animation of colour changes/periods/blending
         egui::CentralPanel::default().show(ctx, |ui| {
-            aura_modes_group(supported, states, oscillator_freq, dbus, ui);
+            aura_modes_group(supported, states, oscillator_freq, ui);
 
             keyboard(ui, &states.keyboard_layout, &mut states.aura, colour);
         });

rog-control-center/src/pages/fan_curve_page.rs

@@ -1,5 +1,5 @@
 use crate::{
-    page_states::{FanCurvesState, ProfilesState},
+    page_states::{FanCurvesState, PageDataStates, ProfilesState},
     widgets::fan_graphs,
     RogApp, RogDbusClientBlocking,
 };
@@ -7,14 +7,9 @@ use egui::Ui;
 use rog_platform::supported::SupportedFunctions;
 use rog_profiles::Profile;
 
-impl<'a> RogApp<'a> {
+impl RogApp {
-    pub fn fan_curve_page(&mut self, ctx: &egui::Context) {
+    pub fn fan_curve_page(&mut self, states: &mut PageDataStates, ctx: &egui::Context) {
-        let Self {
+        let Self { supported, .. } = self;
-            supported,
-            states,
-            asus_dbus: dbus,
-            ..
-        } = self;
 
         egui::CentralPanel::default().show(ctx, |ui| {
             ui.heading("Custom fan curves");
@@ -23,11 +18,11 @@ impl<'a> RogApp<'a> {
                 supported,
                 &mut states.profiles,
                 &mut states.fan_curves,
-                dbus, &mut states.error,
+                &states.asus_dbus, &mut states.error,
                 ui,
             );
 
-            fan_graphs(supported, &mut states.profiles, &mut states.fan_curves, dbus, &mut states.error, ui);
+            fan_graphs(supported, &mut states.profiles, &mut states.fan_curves, &states.asus_dbus, &mut states.error, ui);
         });
     }
 
@@ -76,8 +71,7 @@ impl<'a> RogApp<'a> {
             let selected_profile = curves.show_curve;
             let selected_pu = curves.show_graph;
 
-            let notif = curves.was_notified.clone();
+            match FanCurvesState::new(supported, dbus) {
-            match FanCurvesState::new(notif, supported, dbus) {
                 Ok(f) => *curves = f,
                 Err(e) => *do_error = Some(e.to_string()),
             }

rog-control-center/src/pages/system_page.rs

@@ -1,18 +1,15 @@
 use crate::{
+    page_states::PageDataStates,
     widgets::{
         anime_power_group, app_settings, aura_power_group, platform_profile, rog_bios_group,
     },
     RogApp,
 };
 
-impl<'a> RogApp<'a> {
+impl RogApp {
-    pub fn system_page(&mut self, ctx: &egui::Context) {
+    pub fn system_page(&mut self, states: &mut PageDataStates, ctx: &egui::Context) {
         let Self {
-            config,
+            config, supported, ..
-            supported,
-            states,
-            asus_dbus: dbus,
-            ..
         } = self;
 
         egui::CentralPanel::default().show(ctx, |ui| {
@@ -28,12 +25,12 @@ impl<'a> RogApp<'a> {
                         ui.vertical(|ui| {
                             ui.separator();
                             if supported.platform_profile.platform_profile {
-                                platform_profile(states, dbus, ui);
+                                platform_profile(states, ui);
                             }
                         });
                         ui.vertical(|ui| {
                             ui.separator();
-                            aura_power_group(supported, states, dbus, ui);
+                            aura_power_group(supported, states, ui);
                         });
                         ui.end_row();
 
@@ -44,7 +41,7 @@ impl<'a> RogApp<'a> {
                         });
                         ui.vertical(|ui| {
                             ui.separator();
-                            rog_bios_group(supported, states, dbus, ui);
+                            rog_bios_group(supported, states, ui);
                         });
                         ui.end_row();
 
@@ -52,7 +49,7 @@ impl<'a> RogApp<'a> {
                         ui.vertical(|ui| {
                             ui.separator();
                             if supported.anime_ctrl.0 {
-                                anime_power_group(supported, states, dbus, ui);
+                                anime_power_group(supported, states, ui);
                             }
                         });
                         ui.vertical(|ui| {

rog-control-center/src/tray.rs

@@ -4,7 +4,6 @@
 use std::{
     io::Write,
     sync::{
-        atomic::{AtomicBool, AtomicU8, Ordering},
         mpsc::{channel, Receiver},
         Arc, Mutex,
     },
@@ -12,18 +11,14 @@ use std::{
 };
 
 use gtk::{gio::Icon, prelude::*};
-use rog_dbus::{
+use rog_dbus::zbus_platform::RogBiosProxyBlocking;
-    zbus_platform::{RogBiosProxy, RogBiosProxyBlocking},
-    zbus_power::PowerProxy,
-};
 use rog_platform::{platform::GpuMode, supported::SupportedFunctions};
-use zbus::export::futures_util::StreamExt;
 
-use crate::{error::Result, get_ipc_file, SHOW_GUI};
+use crate::{error::Result, get_ipc_file, page_states::PageDataStates, SHOW_GUI};
 use libappindicator::{AppIndicator, AppIndicatorStatus};
 use supergfxctl::{
     pci_device::{GfxMode, GfxPower},
-    zbus_proxy::DaemonProxyBlocking,
+    zbus_proxy::DaemonProxyBlocking as GfxProxyBlocking,
 };
 
 use log::trace;
@@ -85,14 +80,19 @@ pub struct ROGTray {
     tray: AppIndicator,
     menu: gtk::Menu,
     icon: &'static str,
+    bios_proxy: RogBiosProxyBlocking<'static>,
+    gfx_proxy: GfxProxyBlocking<'static>,
 }
 
 impl ROGTray {
     pub fn new() -> Result<Self> {
+        let conn = zbus::blocking::Connection::system().unwrap();
         let rog_tray = Self {
             tray: AppIndicator::new(TRAY_LABEL, TRAY_APP_ICON),
             menu: gtk::Menu::new(),
             icon: TRAY_APP_ICON,
+            bios_proxy: RogBiosProxyBlocking::new(&conn).unwrap(),
+            gfx_proxy: GfxProxyBlocking::new(&conn).unwrap(),
         };
         Ok(rog_tray)
     }
@@ -200,25 +200,22 @@ impl ROGTray {
     }
 
     fn menu_add_panel_od(&mut self, panel_od: bool) {
+        let bios = self.bios_proxy.clone();
         self.add_check_menu_item("Panel Overdrive", panel_od, move |this| {
-            let conn = zbus::blocking::Connection::system().unwrap();
-            let bios = RogBiosProxyBlocking::new(&conn).unwrap();
             bios.set_panel_od(this.is_active()).unwrap();
         });
     }
 
     fn menu_add_gpu(&mut self, supported: &SupportedFunctions, current_mode: GfxMode) {
-        let conn = zbus::blocking::Connection::system().unwrap();
+        let gfx_dbus = self.gfx_proxy.clone();
-        let gfx_dbus = supergfxctl::zbus_proxy::DaemonProxyBlocking::new(&conn).unwrap();
-
-        let mode = gfx_dbus.mode().unwrap();
         let mut gpu_menu = RadioGroup::new("Integrated", move |_| {
             let mode = gfx_dbus.mode().unwrap();
             if mode != GfxMode::Integrated {
                 gfx_dbus.set_mode(&GfxMode::Integrated).unwrap();
             }
         });
-        let gfx_dbus = supergfxctl::zbus_proxy::DaemonProxyBlocking::new(&conn).unwrap();
+
+        let gfx_dbus = self.gfx_proxy.clone();
         gpu_menu.add("Hybrid", move |_| {
             let mode = gfx_dbus.mode().unwrap();
             if mode != GfxMode::Hybrid {
@@ -226,7 +223,7 @@ impl ROGTray {
             }
         });
         if supported.rog_bios_ctrl.gpu_mux {
-            let gfx_dbus = rog_dbus::zbus_platform::RogBiosProxyBlocking::new(&conn).unwrap();
+            let gfx_dbus = self.bios_proxy.clone();
             gpu_menu.add("Ultimate (Reboot required)", move |_| {
                 let mode = gfx_dbus.gpu_mux_mode().unwrap();
                 if mode != GpuMode::Discrete {
@@ -235,7 +232,7 @@ impl ROGTray {
             });
         }
         if supported.rog_bios_ctrl.egpu_enable {
-            let gfx_dbus = supergfxctl::zbus_proxy::DaemonProxyBlocking::new(&conn).unwrap();
+            let gfx_dbus = self.gfx_proxy.clone();
             gpu_menu.add("eGPU", move |_| {
                 let mode = gfx_dbus.mode().unwrap();
                 if mode != GfxMode::Egpu {
@@ -244,9 +241,9 @@ impl ROGTray {
             });
         }
 
-        let active = match mode {
+        let active = match current_mode {
             GfxMode::AsusMuxDiscreet => "Discreet".to_string(),
-            _ => mode.to_string(),
+            _ => current_mode.to_string(),
         };
         self.add_radio_sub_menu(
             &format!("GPU Mode: {current_mode}"),
@@ -284,56 +281,10 @@ impl ROGTray {
 
 pub fn init_tray(
     supported: SupportedFunctions,
-    recv_command: Receiver<AppToTray>,
+    states: Arc<Mutex<PageDataStates>>,
 ) -> Receiver<TrayToApp> {
     let (send, recv) = channel();
     let _send = Arc::new(Mutex::new(send));
-    let update_menu = Arc::new(AtomicBool::new(false));
-    let update_charge = Arc::new(AtomicU8::new(100));
-    let update_panel_od = Arc::new(AtomicBool::new(false));
-
-    // TODO: mostly follows same pattern as the notify macro stuff. Should make it gerneric
-    let update_menu1 = update_menu.clone();
-    let update_charge1 = update_charge.clone();
-    tokio::spawn(async move {
-        let conn = zbus::Connection::system().await.unwrap();
-        let proxy = PowerProxy::new(&conn).await.unwrap();
-        let charge_limit = proxy.charge_control_end_threshold().await.unwrap();
-        update_charge1.store(charge_limit, Ordering::Relaxed);
-        update_menu1.store(true, Ordering::Relaxed);
-
-        if let Ok(mut p) = proxy.receive_notify_charge_control_end_threshold().await {
-            while let Some(e) = p.next().await {
-                if let Ok(out) = e.args() {
-                    update_charge1.store(out.limit, Ordering::Relaxed);
-                    update_menu1.store(true, Ordering::Relaxed);
-                }
-            }
-        };
-    });
-
-    let update_menu1 = update_menu.clone();
-    let update_panel_od1 = update_panel_od.clone();
-    tokio::spawn(async move {
-        let conn = zbus::Connection::system().await.unwrap();
-        let proxy = RogBiosProxy::new(&conn).await.unwrap();
-        let charge_limit = proxy.panel_od().await.unwrap();
-        update_panel_od1.store(charge_limit, Ordering::Relaxed);
-        update_menu1.store(true, Ordering::Relaxed);
-
-        if let Ok(mut p) = proxy.receive_notify_panel_od().await {
-            while let Some(e) = p.next().await {
-                if let Ok(out) = e.args() {
-                    update_panel_od1.store(out.overdrive, Ordering::Relaxed);
-                    update_menu1.store(true, Ordering::Relaxed);
-                }
-            }
-        };
-    });
-
-    let conn = zbus::blocking::Connection::system().unwrap();
-    let proxy = DaemonProxyBlocking::new(&conn).unwrap();
-    let mode = proxy.mode().unwrap();
 
     std::thread::spawn(move || {
         gtk::init().unwrap(); // Make this the main thread for gtk
@@ -343,28 +294,24 @@ pub fn init_tray(
         tray.set_icon(TRAY_APP_ICON);
 
         loop {
-            if update_menu.load(Ordering::Relaxed) {
+            if let Ok(mut lock) = states.lock() {
-                tray.rebuild_and_update(
+                if lock.tray_should_update {
-                    &supported,
+                    tray.rebuild_and_update(
-                    mode,
+                        &supported,
-                    update_charge.load(Ordering::Relaxed),
+                        lock.gfx_state.mode,
-                    update_panel_od.load(Ordering::Relaxed),
+                        lock.charge_limit,
-                );
+                        lock.bios.panel_overdrive,
-                update_menu.store(false, Ordering::Relaxed);
+                    );
-            }
+                    lock.tray_should_update = false;
 
-            if let Ok(command) = recv_command.try_recv() {
+                    match lock.gfx_state.power_status {
-                match command {
+                        GfxPower::Active => tray.set_icon("asus_notif_red"),
-                    AppToTray::DgpuStatus(s) => {
+                        GfxPower::Suspended => tray.set_icon("asus_notif_blue"),
-                        match s {
+                        GfxPower::Off => tray.set_icon("asus_notif_green"),
-                            GfxPower::Active => tray.set_icon("asus_notif_red"),
+                        GfxPower::AsusDisabled => tray.set_icon("asus_notif_white"),
-                            GfxPower::Suspended => tray.set_icon("asus_notif_blue"),
+                        GfxPower::AsusMuxDiscreet => tray.set_icon("asus_notif_red"),
-                            GfxPower::Off => tray.set_icon("asus_notif_green"),
+                        GfxPower::Unknown => tray.set_icon("gpu-integrated"),
-                            GfxPower::AsusDisabled => tray.set_icon("asus_notif_white"),
+                    };
-                            GfxPower::AsusMuxDiscreet => tray.set_icon("asus_notif_red"),
-                            GfxPower::Unknown => tray.set_icon("gpu-integrated"),
-                        };
-                    }
                 }
             }
 

rog-control-center/src/widgets/anime_power.rs

@@ -1,12 +1,11 @@
 use egui::{RichText, Ui};
 use rog_platform::supported::SupportedFunctions;
 
-use crate::{page_states::PageDataStates, RogDbusClientBlocking};
+use crate::page_states::PageDataStates;
 
 pub fn anime_power_group(
     _supported: &SupportedFunctions,
     states: &mut PageDataStates,
-    dbus: &mut RogDbusClientBlocking,
     ui: &mut Ui,
 ) {
     ui.heading("AniMe Matrix Settings");
@@ -43,7 +42,9 @@ pub fn anime_power_group(
             });
             ui.horizontal_wrapped(|ui| {
                 if ui.checkbox(&mut states.anime.boot, "Enable").changed() {
-                    dbus.proxies()
+                    states
+                        .asus_dbus
+                        .proxies()
                         .anime()
                         .set_boot_on_off(states.anime.boot)
                         .map_err(|err| {
@@ -54,7 +55,9 @@ pub fn anime_power_group(
             });
             ui.horizontal_wrapped(|ui| {
                 if ui.checkbox(&mut states.anime.awake, "Enable").changed() {
-                    dbus.proxies()
+                    states
+                        .asus_dbus
+                        .proxies()
                         .anime()
                         .set_on_off(states.anime.awake)
                         .map_err(|err| {

rog-control-center/src/widgets/aura_modes.rs

@@ -7,16 +7,12 @@ use egui::{RichText, Ui};
 use rog_aura::{AuraEffect, AuraModeNum, AuraZone, Colour, Speed};
 use rog_platform::supported::SupportedFunctions;
 
-use crate::{
+use crate::page_states::{AuraState, PageDataStates};
-    page_states::{AuraState, PageDataStates},
-    RogDbusClientBlocking,
-};
 
 pub fn aura_modes_group(
     supported: &SupportedFunctions,
     states: &mut PageDataStates,
     freq: &mut Arc<AtomicU8>,
-    dbus: &mut RogDbusClientBlocking,
     ui: &mut Ui,
 ) {
     let mut changed = false;
@@ -172,8 +168,7 @@ pub fn aura_modes_group(
     ui.separator();
     ui.with_layout(egui::Layout::right_to_left(egui::Align::TOP), |ui| {
         if ui.add(egui::Button::new("Cancel")).clicked() {
-            let notif = states.aura.was_notified.clone();
+            match AuraState::new(supported, &states.asus_dbus) {
-            match AuraState::new(notif, supported, dbus) {
                 Ok(a) => states.aura.modes = a.modes,
                 Err(e) => states.error = Some(e.to_string()),
             }
@@ -202,7 +197,9 @@ pub fn aura_modes_group(
     if changed {
         states.aura.current_mode = selected;
 
-        dbus.proxies()
+        states
+            .asus_dbus
+            .proxies()
             .led()
             .set_led_mode(states.aura.modes.get(&selected).unwrap())
             .map_err(|err| {

rog-control-center/src/widgets/aura_power.rs

@@ -5,32 +5,22 @@ use rog_aura::{
 };
 use rog_platform::supported::SupportedFunctions;
 
-use crate::{page_states::PageDataStates, RogDbusClientBlocking};
+use crate::page_states::PageDataStates;
 
-pub fn aura_power_group(
+pub fn aura_power_group(supported: &SupportedFunctions, states: &mut PageDataStates, ui: &mut Ui) {
-    supported: &SupportedFunctions,
-    states: &mut PageDataStates,
-    dbus: &mut RogDbusClientBlocking,
-    ui: &mut Ui,
-) {
     ui.heading("LED settings");
 
     match supported.keyboard_led.prod_id {
         AuraDevice::X1854 | AuraDevice::X1869 | AuraDevice::X1866 => {
-            aura_power1(supported, states, dbus, ui)
+            aura_power1(supported, states, ui)
         }
-        AuraDevice::X19B6 => aura_power2(supported, states, dbus, ui),
+        AuraDevice::X19B6 => aura_power2(supported, states, ui),
-        AuraDevice::Tuf => aura_power1(supported, states, dbus, ui),
+        AuraDevice::Tuf => aura_power1(supported, states, ui),
         AuraDevice::Unknown => {}
     }
 }
 
-fn aura_power1(
+fn aura_power1(supported: &SupportedFunctions, states: &mut PageDataStates, ui: &mut Ui) {
-    supported: &SupportedFunctions,
-    states: &mut PageDataStates,
-    dbus: &mut RogDbusClientBlocking,
-    ui: &mut Ui,
-) {
     let enabled_states = &mut states.aura.enabled;
     let mut boot = enabled_states.x1866.contains(&AuraDev1866::Boot);
     let mut sleep = enabled_states.x1866.contains(&AuraDev1866::Sleep);
@@ -144,7 +134,9 @@ fn aura_power1(
                     x19b6: vec![],
                 };
                 // build data to send
-                dbus.proxies()
+                states
+                    .asus_dbus
+                    .proxies()
                     .led()
                     .set_leds_power(options, enable)
                     .map_err(|err| {
@@ -193,7 +185,9 @@ fn aura_power1(
                     x19b6: vec![],
                 };
                 // build data to send
-                dbus.proxies()
+                states
+                    .asus_dbus
+                    .proxies()
                     .led()
                     .set_leds_power(options, enable)
                     .map_err(|err| {
@@ -207,12 +201,7 @@ fn aura_power1(
     }
 }
 
-fn aura_power2(
+fn aura_power2(supported: &SupportedFunctions, states: &mut PageDataStates, ui: &mut Ui) {
-    supported: &SupportedFunctions,
-    states: &mut PageDataStates,
-    dbus: &mut RogDbusClientBlocking,
-    ui: &mut Ui,
-) {
     let enabled_states = &mut states.aura.enabled;
     let has_logo = supported
         .keyboard_led
@@ -331,7 +320,9 @@ fn aura_power2(
                 x19b6: data,
             };
             // build data to send
-            dbus.proxies()
+            states
+                .asus_dbus
+                .proxies()
                 .led()
                 .set_leds_power(options, enable)
                 .map_err(|err| {

rog-control-center/src/widgets/fan_graph.rs

@@ -136,8 +136,7 @@ pub fn fan_graphs(
             })
             .ok();
 
-        let notif = curves.was_notified.clone();
+        match FanCurvesState::new(supported, dbus) {
-        match FanCurvesState::new(notif, supported, dbus) {
             Ok(f) => *curves = f,
             Err(e) => *do_error = Some(e.to_string()),
         }

rog-control-center/src/widgets/rog_bios.rs

@@ -1,9 +1,9 @@
-use crate::{page_states::PageDataStates, RogDbusClientBlocking};
+use crate::page_states::PageDataStates;
 use egui::Ui;
 use rog_platform::{platform::GpuMode, supported::SupportedFunctions};
 use rog_profiles::Profile;
 
-pub fn platform_profile(states: &mut PageDataStates, dbus: &RogDbusClientBlocking, ui: &mut Ui) {
+pub fn platform_profile(states: &mut PageDataStates, ui: &mut Ui) {
     ui.heading("Platform profile");
 
     let mut changed = false;
@@ -23,7 +23,9 @@ pub fn platform_profile(states: &mut PageDataStates, dbus: &RogDbusClientBlockin
     });
 
     if changed {
-        dbus.proxies()
+        states
+            .asus_dbus
+            .proxies()
             .profile()
             .set_active_profile(states.profiles.current)
             .map_err(|err| {
@@ -33,19 +35,16 @@ pub fn platform_profile(states: &mut PageDataStates, dbus: &RogDbusClientBlockin
     };
 }
 
-pub fn rog_bios_group(
+pub fn rog_bios_group(supported: &SupportedFunctions, states: &mut PageDataStates, ui: &mut Ui) {
-    supported: &SupportedFunctions,
-    states: &mut PageDataStates,
-    dbus: &mut RogDbusClientBlocking,
-    ui: &mut Ui,
-) {
     ui.heading("Bios options");
 
     let slider = egui::Slider::new(&mut states.charge_limit, 20..=100)
         .text("Charging limit")
         .step_by(1.0);
     if ui.add(slider).drag_released() {
-        dbus.proxies()
+        states
+            .asus_dbus
+            .proxies()
             .charge()
             .set_charge_control_end_threshold(states.charge_limit as u8)
             .map_err(|err| {
@@ -62,7 +61,9 @@ pub fn rog_bios_group(
             ))
             .changed()
     {
-        dbus.proxies()
+        states
+            .asus_dbus
+            .proxies()
             .rog_bios()
             .set_post_boot_sound(states.bios.post_sound)
             .map_err(|err| {
@@ -79,7 +80,9 @@ pub fn rog_bios_group(
             ))
             .changed()
     {
-        dbus.proxies()
+        states
+            .asus_dbus
+            .proxies()
             .rog_bios()
             .set_panel_od(states.bios.panel_overdrive)
             .map_err(|err| {
@@ -114,7 +117,9 @@ pub fn rog_bios_group(
         });
 
         if changed {
-            dbus.proxies()
+            states
+                .asus_dbus
+                .proxies()
                 .rog_bios()
                 .set_gpu_mux_mode(states.bios.dedicated_gfx)
                 .map_err(|err| {

rog-control-center/src/widgets/side_panel.rs

@@ -1,6 +1,6 @@
 use crate::{Page, RogApp};
 
-impl<'a> RogApp<'a> {
+impl RogApp {
     pub fn side_panel(&mut self, ctx: &egui::Context) {
         egui::SidePanel::left("side_panel")
             .resizable(false)

rog-control-center/src/widgets/top_bar.rs

@@ -2,7 +2,7 @@ use egui::{vec2, Align2, FontId, Id, Sense};
 
 use crate::{RogApp, VERSION};
 
-impl<'a> RogApp<'a> {
+impl RogApp {
     pub fn top_bar(&mut self, ctx: &egui::Context, frame: &mut eframe::Frame) {
         egui::TopBottomPanel::top("top_panel").show(ctx, |ui| {
             // The top panel is often a good place for a menu bar: