gilles/asusctl
1
0
Fork 0
mirror of https://gitlab.com/asus-linux/asusctl.git synced 2026-02-06 00:15:04 +01:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source
This commit is contained in:
Luke D. Jones
2022-11-15 11:08:40 +13:00
parent b41fdf5cfe
commit 762bfea102
18 changed files with 315 additions and 406 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
asusctl/src/main.rs
View File

@@ -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 {

1
daemon/src/lib.rs
View File

@@ -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();
});

133
rog-control-center/src/app.rs
View File

@@ -1,10 +1,8 @@
use std::{
f64::consts::PI,
io::Write,
sync::{
atomic::{AtomicBool, AtomicU8, Ordering},
mpsc::Receiver,
Arc,
Arc, Mutex,
},
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,
Page, RogDbusClientBlocking, SHOW_GUI,
config::Config, error::Result, page_states::PageDataStates, Page, RogDbusClientBlocking,
};
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,
app_cmd: Arc<Receiver<TrayToApp>>,
states: Arc<Mutex<PageDataStates>>,
_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 {
supported,
asus_dbus: dbus,
states,
..
} = 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();
if let Ok(mut states) = states.try_lock() {
if states.app_should_update {
states.app_should_update = false;
ctx.request_repaint();
}
}
let page = self.page;
self.top_bar(ctx, frame);
self.side_panel(ctx);
if let Some(err) = self.states.error.clone() {
egui::CentralPanel::default().show(ctx, |ui| {
ui.heading(RichText::new("Error!").size(28.0));
let mut was_error = false;
ui.centered_and_justified(|ui| {
ui.label(RichText::new(format!("The error was: {:?}", err)).size(22.0));
});
});
egui::TopBottomPanel::bottom("error_bar")
.default_height(26.0)
.show(ctx, |ui| {
ui.with_layout(egui::Layout::right_to_left(egui::Align::TOP), |ui| {
if ui
.add(Button::new(RichText::new("Okay").size(20.0)))
.clicked()
{
self.states.error = None;
}
if let Ok(mut states) = states.try_lock() {
if let Some(err) = states.error.clone() {
was_error = true;
egui::CentralPanel::default().show(ctx, |ui| {
ui.heading(RichText::new("Error!").size(28.0));
ui.centered_and_justified(|ui| {
ui.label(RichText::new(format!("The error was: {:?}", err)).size(22.0));
});
});
} else if page == Page::System {
self.system_page(ctx);
} else if page == Page::AuraEffects {
self.aura_page(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(ctx);
egui::TopBottomPanel::bottom("error_bar")
.default_height(26.0)
.show(ctx, |ui| {
ui.with_layout(egui::Layout::right_to_left(egui::Align::TOP), |ui| {
if ui
.add(Button::new(RichText::new("Okay").size(20.0)))
.clicked()
{
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);
}
}
}
}
}

74
rog-control-center/src/main.rs
View File

@@ -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,
RogApp, RogDbusClientBlocking, SHOWING_GUI, SHOW_GUI,
page_states::PageDataStates, print_versions, startup_error::AppErrorShow, RogApp,
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(
layout,
&dbus,
enabled_notifications,
update_tray,
&supported,
)
.unwrap();
let states = Arc::new(Mutex::new(
setup_page_state_and_notifs(layout, enabled_notifications, &supported).unwrap(),
));
init_tray(supported, states.clone());
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
// This is quite different when done in a retained mode app
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));
let page_states =
PageDataStates::new(keyboard_layout, enabled_notifications.clone(), supported)?;
start_notifications(
charge_notified.clone(),
bios_notified.clone(),
aura_notified.clone(),
anime_notified.clone(),
profiles_notified.clone(),
fans_notified.clone(),
enabled_notifications.clone(),
update_tray,
)?;
start_notifications(page_states.was_notified.clone(), enabled_notifications)?;
PageDataStates::new(
keyboard_layout,
enabled_notifications,
charge_notified,
bios_notified,
aura_notified,
anime_notified,
profiles_notified,
fans_notified,
supported,
dbus,
)
Ok(page_states)
}
fn start_app(
states: PageDataStates,
native_options: NativeOptions,
app_cmd: Arc<Receiver<TrayToApp>>,
) -> Result<()> {
fn start_app(states: Arc<Mutex<PageDataStates>>, native_options: NativeOptions) -> 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(RogApp::new(Config::load().unwrap(), states, app_cmd, cc).unwrap())
}),
Box::new(move |cc| Box::new(RogApp::new(Config::load().unwrap(), states, cc).unwrap())),
);
Ok(())
}

45
rog-control-center/src/notify.rs
View File

@@ -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>,
bios_notified: Arc<AtomicBool>,
aura_notified: Arc<AtomicBool>,
anime_notified: Arc<AtomicBool>,
profiles_notified: Arc<AtomicBool>,
_fans_notified: Arc<AtomicBool>,
was_notified: WasNotified,
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() {
lock.send(AppToTray::DgpuStatus(*status)).ok();
}
gfx_notified.store(true, Ordering::SeqCst);
}
}
}
bios_notified1.store(true, Ordering::SeqCst);
};
});

192
rog-control-center/src/page_states.rs
View File

@@ -1,24 +1,28 @@
use std::{
collections::{BTreeMap, HashSet},
sync::{
atomic::{AtomicBool, Ordering},
Arc, Mutex,
},
sync::{atomic::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(
was_notified: Arc<AtomicBool>,
supported: &SupportedFunctions,
dbus: &RogDbusClientBlocking,
) -> Result<Self> {
pub fn new(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(
was_notified: Arc<AtomicBool>,
supported: &SupportedFunctions,
dbus: &RogDbusClientBlocking,
) -> Result<Self> {
pub fn new(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(
was_notified: Arc<AtomicBool>,
supported: &SupportedFunctions,
dbus: &RogDbusClientBlocking,
) -> Result<Self> {
pub fn new(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(
was_notified: Arc<AtomicBool>,
supported: &SupportedFunctions,
dbus: &RogDbusClientBlocking,
) -> Result<Self> {
pub fn new(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(
was_notified: Arc<AtomicBool>,
supported: &SupportedFunctions,
dbus: &RogDbusClientBlocking,
) -> Result<Self> {
pub fn new(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,
charge_limit: dbus.proxies().charge().charge_control_end_threshold()?,
bios: BiosState::new(bios_notified, supported, dbus)?,
aura: AuraState::new(aura_notified, supported, dbus)?,
anime: AnimeState::new(anime_notified, supported, dbus)?,
profiles: ProfilesState::new(profiles_notified, supported, dbus)?,
fan_curves: FanCurvesState::new(fans_notified, supported, dbus)?,
was_notified: WasNotified::default(),
charge_limit: asus_dbus
.proxies()
.charge()
.charge_control_end_threshold()?,
bios: BiosState::new(supported, &asus_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(
&mut self,
supported: &SupportedFunctions,
dbus: &RogDbusClientBlocking,
) -> Result<bool> {
pub fn refresh_if_notfied(&mut self, supported: &SupportedFunctions) -> Result<bool> {
let mut notified = false;
if self.was_notified.load(Ordering::SeqCst) {
self.charge_limit = dbus.proxies().charge().charge_control_end_threshold()?;
self.was_notified.store(false, Ordering::SeqCst);
if self.was_notified.charge.load(Ordering::SeqCst) {
self.charge_limit = self
.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) {
self.aura = AuraState::new(self.aura.was_notified.clone(), supported, dbus)?;
self.aura.was_notified.store(false, Ordering::SeqCst);
if self.was_notified.aura.load(Ordering::SeqCst) {
self.aura = AuraState::new(supported, &self.asus_dbus)?;
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) {
self.bios = BiosState::new(self.bios.was_notified.clone(), supported, dbus)?;
self.bios.was_notified.store(false, Ordering::SeqCst);
if self.was_notified.bios.load(Ordering::SeqCst) {
self.bios = BiosState::new(supported, &self.asus_dbus)?;
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) {
self.profiles =
ProfilesState::new(self.profiles.was_notified.clone(), supported, dbus)?;
self.profiles.was_notified.store(false, Ordering::SeqCst);
if self.was_notified.profiles.load(Ordering::SeqCst) {
self.profiles = ProfilesState::new(supported, &self.asus_dbus)?;
self.was_notified.profiles.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) {
self.fan_curves =
FanCurvesState::new(self.fan_curves.was_notified.clone(), supported, dbus)?;
self.fan_curves.was_notified.store(false, Ordering::SeqCst);
if self.was_notified.fans.load(Ordering::SeqCst) {
self.fan_curves = FanCurvesState::new(supported, &self.asus_dbus)?;
self.was_notified.fans.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,
}
}
}

2
rog-control-center/src/pages/anime_page.rs
View File

@@ -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");

10
rog-control-center/src/pages/aura_page.rs
View File

@@ -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> {
pub fn aura_page(&mut self, ctx: &egui::Context) {
impl RogApp {
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);
});

20
rog-control-center/src/pages/fan_curve_page.rs
View File

@@ -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> {
pub fn fan_curve_page(&mut self, ctx: &egui::Context) {
let Self {
supported,
states,
asus_dbus: dbus,
..
} = self;
impl RogApp {
pub fn fan_curve_page(&mut self, states: &mut PageDataStates, ctx: &egui::Context) {
let Self { supported, .. } = 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(notif, supported, dbus) {
match FanCurvesState::new(supported, dbus) {
Ok(f) => *curves = f,
Err(e) => *do_error = Some(e.to_string()),
}

19
rog-control-center/src/pages/system_page.rs
View File

@@ -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> {
pub fn system_page(&mut self, ctx: &egui::Context) {
impl RogApp {
pub fn system_page(&mut self, states: &mut PageDataStates, ctx: &egui::Context) {
let Self {
config,
supported,
states,
asus_dbus: dbus,
..
config, supported, ..
} = 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| {

121
rog-control-center/src/tray.rs
View File

@@ -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::{
zbus_platform::{RogBiosProxy, RogBiosProxyBlocking},
zbus_power::PowerProxy,
};
use rog_dbus::zbus_platform::RogBiosProxyBlocking;
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 = supergfxctl::zbus_proxy::DaemonProxyBlocking::new(&conn).unwrap();
let mode = gfx_dbus.mode().unwrap();
let gfx_dbus = self.gfx_proxy.clone();
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) {
tray.rebuild_and_update(
&supported,
mode,
update_charge.load(Ordering::Relaxed),
update_panel_od.load(Ordering::Relaxed),
);
update_menu.store(false, Ordering::Relaxed);
}
if let Ok(mut lock) = states.lock() {
if lock.tray_should_update {
tray.rebuild_and_update(
&supported,
lock.gfx_state.mode,
lock.charge_limit,
lock.bios.panel_overdrive,
);
lock.tray_should_update = false;
if let Ok(command) = recv_command.try_recv() {
match command {
AppToTray::DgpuStatus(s) => {
match s {
GfxPower::Active => tray.set_icon("asus_notif_red"),
GfxPower::Suspended => tray.set_icon("asus_notif_blue"),
GfxPower::Off => tray.set_icon("asus_notif_green"),
GfxPower::AsusDisabled => tray.set_icon("asus_notif_white"),
GfxPower::AsusMuxDiscreet => tray.set_icon("asus_notif_red"),
GfxPower::Unknown => tray.set_icon("gpu-integrated"),
};
}
match lock.gfx_state.power_status {
GfxPower::Active => tray.set_icon("asus_notif_red"),
GfxPower::Suspended => tray.set_icon("asus_notif_blue"),
GfxPower::Off => tray.set_icon("asus_notif_green"),
GfxPower::AsusDisabled => tray.set_icon("asus_notif_white"),
GfxPower::AsusMuxDiscreet => tray.set_icon("asus_notif_red"),
GfxPower::Unknown => tray.set_icon("gpu-integrated"),
};
}
}

11
rog-control-center/src/widgets/anime_power.rs
View File

@@ -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| {

13
rog-control-center/src/widgets/aura_modes.rs
View File

@@ -7,16 +7,12 @@ use egui::{RichText, Ui};
use rog_aura::{AuraEffect, AuraModeNum, AuraZone, Colour, Speed};
use rog_platform::supported::SupportedFunctions;
use crate::{
page_states::{AuraState, PageDataStates},
RogDbusClientBlocking,
};
use crate::page_states::{AuraState, PageDataStates};
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(notif, supported, dbus) {
match AuraState::new(supported, &states.asus_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| {

41
rog-control-center/src/widgets/aura_power.rs
View File

@@ -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(
supported: &SupportedFunctions,
states: &mut PageDataStates,
dbus: &mut RogDbusClientBlocking,
ui: &mut Ui,
) {
pub fn aura_power_group(supported: &SupportedFunctions, states: &mut PageDataStates, 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::Tuf => aura_power1(supported, states, dbus, ui),
AuraDevice::X19B6 => aura_power2(supported, states, ui),
AuraDevice::Tuf => aura_power1(supported, states, ui),
AuraDevice::Unknown => {}
}
}
fn aura_power1(
supported: &SupportedFunctions,
states: &mut PageDataStates,
dbus: &mut RogDbusClientBlocking,
ui: &mut Ui,
) {
fn aura_power1(supported: &SupportedFunctions, states: &mut PageDataStates, 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(
supported: &SupportedFunctions,
states: &mut PageDataStates,
dbus: &mut RogDbusClientBlocking,
ui: &mut Ui,
) {
fn aura_power2(supported: &SupportedFunctions, states: &mut PageDataStates, 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| {

3
rog-control-center/src/widgets/fan_graph.rs
View File

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

31
rog-control-center/src/widgets/rog_bios.rs
View File

@@ -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(
supported: &SupportedFunctions,
states: &mut PageDataStates,
dbus: &mut RogDbusClientBlocking,
ui: &mut Ui,
) {
pub fn rog_bios_group(supported: &SupportedFunctions, states: &mut PageDataStates, 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| {

2
rog-control-center/src/widgets/side_panel.rs
View File

@@ -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)

2
rog-control-center/src/widgets/top_bar.rs
View File

@@ -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: