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

feat(rog-control-center): Major UI/UX improvements and new features

Browse Source 
- Add software RGB animations for static-only keyboards (rainbow, color cycle)
- Add custom fan curve control via direct sysfs for unsupported laptops
- Add real-time system status bar (CPU/GPU temps, fan speeds, power draw)
- Add tray icon tooltip with live system stats
- Add power profile change notifications (Fn+F5)
- Add dGPU status notifications
- Add ROG theme with dark palette and accent colors
- Add Screenpad, Slash, and SuperGFX page stubs
- Improve fan curve graph UI
- Various UI refinements and fixes

Co-Authored-By: Gemini <noreply@google.com>
This commit is contained in:
mihai2mn
2026-01-15 20:09:40 +01:00
parent 5303bfc1ad
commit 3d0caa39e1
40 changed files with 2790 additions and 692 deletions
Download Patch File Download Diff File Expand all files Collapse all files
rog-control-center/src/ui/aura_animator.rs
+200
View File
@@ -0,0 +1,200 @@
//! Software-based keyboard animation for keyboards that only support Static mode.
//! Provides Rainbow and Color Cycle animations via timer-based color updates.
use log::{info, warn};
use slint::Weak;
use std::process::Command;
use std::sync::atomic::{AtomicBool, AtomicU32, Ordering};
use std::sync::Arc;
use std::time::Duration;
use crate::MainWindow;
/// Animation mode enum matching the UI
#[derive(Clone, Copy, Debug, PartialEq, Default)]
pub enum AnimationMode {
#[default]
None,
Rainbow,
ColorCycle,
}
impl From<i32> for AnimationMode {
fn from(v: i32) -> Self {
match v {
1 => AnimationMode::Rainbow,
2 => AnimationMode::ColorCycle,
_ => AnimationMode::None,
}
}
}
/// Shared state for the animator
pub struct AnimatorState {
/// Current animation mode
pub mode: AtomicU32,
/// Animation speed in milliseconds (update interval)
pub speed_ms: AtomicU32,
/// Stop signal
pub stop: AtomicBool,
/// Current hue for rainbow mode (0-360)
hue: AtomicU32,
}
impl Default for AnimatorState {
fn default() -> Self {
Self {
mode: AtomicU32::new(0),
speed_ms: AtomicU32::new(200),
stop: AtomicBool::new(false),
hue: AtomicU32::new(0),
}
}
}
/// Convert HSV to RGB (H: 0-360, S: 0-100, V: 0-100)
fn hsv_to_rgb(h: u32, s: u32, v: u32) -> (u8, u8, u8) {
let s = s as f32 / 100.0;
let v = v as f32 / 100.0;
let c = v * s;
let h_prime = (h as f32 / 60.0) % 6.0;
let x = c * (1.0 - ((h_prime % 2.0) - 1.0).abs());
let m = v - c;
let (r, g, b) = match h_prime as u32 {
0 => (c, x, 0.0),
1 => (x, c, 0.0),
2 => (0.0, c, x),
3 => (0.0, x, c),
4 => (x, 0.0, c),
_ => (c, 0.0, x),
};
(
((r + m) * 255.0) as u8,
((g + m) * 255.0) as u8,
((b + m) * 255.0) as u8,
)
}
/// Format RGB as hex color string for asusctl
fn rgb_to_hex(r: u8, g: u8, b: u8) -> String {
format!("{:02x}{:02x}{:02x}", r, g, b)
}
// Simple LCG for random numbers to avoid pulling in rand crate
fn next_random(seed: &mut u64) -> u32 {
*seed = seed.wrapping_mul(6364136223846793005).wrapping_add(1);
(*seed >> 32) as u32
}
/// Start the animation loop (runs in tokio task)
pub fn start_animator(state: Arc<AnimatorState>, _ui_weak: Weak<MainWindow>) {
info!("Starting keyboard animator");
tokio::spawn(async move {
// Local state for Color Cycle (RGB)
let mut current_r: f32 = 255.0;
let mut current_g: f32 = 0.0;
let mut current_b: f32 = 0.0;
let mut target_r: f32 = 0.0;
let mut target_g: f32 = 255.0;
let mut target_b: f32 = 0.0;
let mut seed = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_nanos() as u64)
.unwrap_or(12345);
loop {
// Check for stop signal
if state.stop.load(Ordering::Relaxed) {
info!("Animator stopping");
break;
}
let mode = AnimationMode::from(state.mode.load(Ordering::Relaxed) as i32);
// Cap speed at 150ms for stability
let raw_speed = state.speed_ms.load(Ordering::Relaxed);
let effective_speed = raw_speed.max(150) as u64;
if mode == AnimationMode::None {
// No animation, sleep longer
tokio::time::sleep(Duration::from_millis(500)).await;
continue;
}
// Calculate next color
let hex_color = match mode {
AnimationMode::Rainbow => {
// Hue step 1 for smooth, granular transitions
let hue = state.hue.fetch_add(1, Ordering::Relaxed) % 360;
let (r, g, b) = hsv_to_rgb(hue, 100, 100);
rgb_to_hex(r, g, b)
}
AnimationMode::ColorCycle => {
// RGB Linear Interpolation (Fading) - NOT Rainbow
// 1. Check distance to target
let dist_sq = (target_r - current_r).powi(2)
+ (target_g - current_g).powi(2)
+ (target_b - current_b).powi(2);
// If close, pick new random target color
if dist_sq < 100.0 {
let next_h = next_random(&mut seed) % 360;
let (r, g, b) = hsv_to_rgb(next_h, 100, 100);
target_r = r as f32;
target_g = g as f32;
target_b = b as f32;
}
// 2. Lerp towards target (5% per frame for smooth ease-out)
let factor = 0.05;
current_r += (target_r - current_r) * factor;
current_g += (target_g - current_g) * factor;
current_b += (target_b - current_b) * factor;
rgb_to_hex(current_r as u8, current_g as u8, current_b as u8)
}
AnimationMode::None => continue,
};
// Send color update via asusctl command (blocking, AWAITED to prevent races)
let hex = hex_color.clone();
let _ = tokio::task::spawn_blocking(move || {
let result = Command::new("asusctl")
.args([
"aura", "static", "-c", &hex,
])
.output();
if let Err(e) = result {
warn!("Failed to set aura color: {}", e);
}
})
.await;
// Sleep for the animation speed interval
tokio::time::sleep(Duration::from_millis(effective_speed)).await;
}
});
}
/// Stop the animator
pub fn stop_animator(state: &Arc<AnimatorState>) {
state.stop.store(true, Ordering::Relaxed);
state.mode.store(0, Ordering::Relaxed);
}
/// Set animation mode
pub fn set_animation_mode(state: &Arc<AnimatorState>, mode: AnimationMode) {
state.mode.store(mode as u32, Ordering::Relaxed);
// Reset stop flag in case we're restarting
state.stop.store(false, Ordering::Relaxed);
}
/// Set animation speed
pub fn set_animation_speed(state: &Arc<AnimatorState>, speed_ms: u32) {
let clamped = speed_ms.clamp(50, 2000);
state.speed_ms.store(clamped, Ordering::Relaxed);
}
rog-control-center/src/ui/mod.rs
+109 -5
View File
@@ -1,6 +1,12 @@
pub mod aura_animator;
pub mod setup_anime;
pub mod setup_aura;
pub mod setup_fan_curve_custom;
pub mod setup_fans;
pub mod setup_screenpad;
pub mod setup_slash;
pub mod setup_status;
pub mod setup_supergfx;
pub mod setup_system;
use std::sync::{Arc, Mutex};
@@ -11,9 +17,14 @@ use rog_dbus::list_iface_blocking;
use slint::{ComponentHandle, SharedString, Weak};
use crate::config::Config;
use crate::tray::TrayStats;
use crate::ui::setup_anime::setup_anime_page;
use crate::ui::setup_aura::setup_aura_page;
use crate::ui::setup_fans::setup_fan_curve_page;
use crate::ui::setup_screenpad::setup_screenpad;
use crate::ui::setup_slash::setup_slash;
use crate::ui::setup_status::setup_status;
use crate::ui::setup_supergfx::setup_supergfx;
use crate::ui::setup_system::{setup_system_page, setup_system_page_callbacks};
use crate::{AppSettingsPageData, MainWindow};
@@ -82,7 +93,10 @@ pub fn show_toast(
};
}
pub fn setup_window(config: Arc<Mutex<Config>>) -> MainWindow {
pub fn setup_window(
config: Arc<Mutex<Config>>,
stats_tx: tokio::sync::watch::Sender<TrayStats>,
) -> MainWindow {
slint::set_xdg_app_id("rog-control-center")
.map_err(|e| warn!("Couldn't set application ID: {e:?}"))
.ok();
@@ -101,9 +115,27 @@ pub fn setup_window(config: Arc<Mutex<Config>>) -> MainWindow {
available.contains(&"xyz.ljones.Platform".to_string()),
available.contains(&"xyz.ljones.Aura".to_string()),
available.contains(&"xyz.ljones.Anime".to_string()),
available.contains(&"xyz.ljones.Slash".to_string()),
// Supergfx check
{
if let Ok(conn) = zbus::blocking::Connection::system() {
zbus::blocking::fdo::DBusProxy::new(&conn)
.ok()
.and_then(|p| {
p.name_has_owner("org.supergfxctl.Daemon".try_into().ok()?)
.ok()
})
.unwrap_or(false)
} else {
false
}
},
// Screenpad check (Backlight interface)
available.contains(&"xyz.ljones.Backlight".to_string()),
available.contains(&"xyz.ljones.FanCurves".to_string()),
true,
true,
true,
]
.into(),
);
@@ -112,6 +144,33 @@ pub fn setup_window(config: Arc<Mutex<Config>>) -> MainWindow {
slint::quit_event_loop().unwrap();
});
// Auto-hide toast logic
let toast_gen = Arc::new(Mutex::new(0u64));
let ui_weak = ui.as_weak();
ui.on_start_toast_timer(move || {
let toast_gen_clone = toast_gen.clone();
let ui_weak_clone = ui_weak.clone();
let my_gen = {
if let Ok(mut g) = toast_gen.lock() {
*g += 1;
*g
} else {
0
}
};
if my_gen > 0 {
tokio::spawn(async move {
tokio::time::sleep(tokio::time::Duration::from_secs(4)).await;
if let Ok(g) = toast_gen_clone.lock() {
if *g == my_gen {
let _ =
ui_weak_clone.upgrade_in_event_loop(move |ui| ui.invoke_hide_toast());
}
}
});
}
});
setup_app_settings_page(&ui, config.clone());
if available.contains(&"xyz.ljones.Platform".to_string()) {
setup_system_page(&ui, config.clone());
@@ -123,10 +182,24 @@ pub fn setup_window(config: Arc<Mutex<Config>>) -> MainWindow {
if available.contains(&"xyz.ljones.Anime".to_string()) {
setup_anime_page(&ui, config.clone());
}
if available.contains(&"xyz.ljones.FanCurves".to_string()) {
setup_fan_curve_page(&ui, config);
if available.contains(&"xyz.ljones.Slash".to_string()) {
setup_slash(&ui, config.clone());
}
// Always try to setup supergfx if detected above, but for simplicity here we assume if sidebar has it (re-check or just run)
// We didn't capture the boolean above. Let's just run it, it handles its own availability check internally via async proxy creation.
setup_supergfx(&ui, config.clone());
if available.contains(&"xyz.ljones.Backlight".to_string()) {
setup_screenpad(&ui, config.clone());
}
if available.contains(&"xyz.ljones.FanCurves".to_string()) {
setup_fan_curve_page(&ui, config.clone());
}
setup_status(&ui, config, stats_tx);
ui
}
@@ -153,18 +226,49 @@ pub fn setup_app_settings_page(ui: &MainWindow, config: Arc<Mutex<Config>>) {
lock.write();
}
});
// Master notifications toggle
let config_copy = config.clone();
global.on_set_enable_dgpu_notifications(move |enable| {
global.on_set_notifications_enabled(move |enable| {
if let Ok(mut lock) = config_copy.try_lock() {
lock.notifications.enabled = enable;
lock.write();
}
});
// Granular notification toggles
let config_copy = config.clone();
global.on_set_notify_gfx_switch(move |enable| {
if let Ok(mut lock) = config_copy.try_lock() {
lock.notifications.receive_notify_gfx = enable;
lock.write();
}
});
let config_copy = config.clone();
global.on_set_notify_gfx_status(move |enable| {
if let Ok(mut lock) = config_copy.try_lock() {
lock.notifications.receive_notify_gfx_status = enable;
lock.write();
}
});
let config_copy = config.clone();
global.on_set_notify_platform_profile(move |enable| {
if let Ok(mut lock) = config_copy.try_lock() {
lock.notifications.receive_notify_platform_profile = enable;
lock.write();
}
});
// Initialize UI values from config
if let Ok(lock) = config.try_lock() {
global.set_run_in_background(lock.run_in_background);
global.set_startup_in_background(lock.startup_in_background);
global.set_enable_tray_icon(lock.enable_tray_icon);
global.set_enable_dgpu_notifications(lock.notifications.enabled);
global.set_notifications_enabled(lock.notifications.enabled);
global.set_notify_gfx_switch(lock.notifications.receive_notify_gfx);
global.set_notify_gfx_status(lock.notifications.receive_notify_gfx_status);
global.set_notify_platform_profile(lock.notifications.receive_notify_platform_profile);
}
}
rog-control-center/src/ui/setup_aura.rs
+39
View File
@@ -7,6 +7,9 @@ use rog_dbus::zbus_aura::AuraProxy;
use slint::{ComponentHandle, Model, RgbaColor, SharedString};
use crate::config::Config;
use crate::ui::aura_animator::{
set_animation_mode, set_animation_speed, start_animator, AnimationMode, AnimatorState,
};
use crate::ui::show_toast;
use crate::{
set_ui_callbacks, set_ui_props_async, AuraPageData, MainWindow, PowerZones as SlintPowerZones,
@@ -123,8 +126,17 @@ pub fn setup_aura_page(ui: &MainWindow, _states: Arc<Mutex<Config>>) {
.ok();
}
// Create animator state (shared across callbacks)
let animator_state = Arc::new(AnimatorState::default());
if let Ok(modes) = aura.supported_basic_modes().await {
log::debug!("Available LED modes {modes:?}");
// Check if only Static mode is available (enable software animation)
let static_only = modes.len() == 1 && modes.iter().any(|m| *m == 0.into());
let handle_for_anim = handle.clone();
let animator_state_clone = animator_state.clone();
handle
.upgrade_in_event_loop(move |handle| {
let m: Vec<i32> = modes.iter().map(|n| (*n).into()).collect();
@@ -143,6 +155,33 @@ pub fn setup_aura_page(ui: &MainWindow, _states: Arc<Mutex<Config>>) {
handle
.global::<AuraPageData>()
.set_available_mode_names(res.as_slice().into());
// Enable software animation if only Static mode is available
if static_only {
info!("Only Static mode available - enabling software animation controls");
handle
.global::<AuraPageData>()
.set_soft_animation_available(true);
// Start the animator thread
start_animator(animator_state_clone.clone(), handle_for_anim.clone());
// Connect mode callback
let state_for_mode = animator_state_clone.clone();
handle
.global::<AuraPageData>()
.on_cb_soft_animation_mode(move |mode| {
set_animation_mode(&state_for_mode, AnimationMode::from(mode));
});
// Connect speed callback
let state_for_speed = animator_state_clone.clone();
handle
.global::<AuraPageData>()
.on_cb_soft_animation_speed(move |speed| {
set_animation_speed(&state_for_speed, speed as u32);
});
}
})
.map_err(|e| error!("{e:}"))
.ok();
rog-control-center/src/ui/setup_fan_curve_custom.rs
+241
View File
@@ -0,0 +1,241 @@
use std::fs;
use std::path::{Path, PathBuf};
use log::{error, info};
use serde::{Deserialize, Serialize};
use crate::{FanType, MainWindow, Node};
const ASUS_CUSTOM_FAN_NAME: &str = "asus_custom_fan_curve";
const CONFIG_FILE_NAME: &str = "custom_fans.ron";
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CustomCurvePoint {
pub temp: u8,
pub pwm: u8,
}
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct CustomFanConfig {
pub cpu_curve: Vec<CustomCurvePoint>,
pub gpu_curve: Vec<CustomCurvePoint>,
pub enabled: bool,
}
#[derive(Clone)]
struct SysfsPaths {
root: PathBuf,
}
impl SysfsPaths {
fn new() -> Option<Self> {
let hwmon = Path::new("/sys/class/hwmon");
if let Ok(entries) = fs::read_dir(hwmon) {
for entry in entries.flatten() {
let path = entry.path();
let name_path = path.join("name");
if let Ok(name) = fs::read_to_string(&name_path) {
if name.trim() == ASUS_CUSTOM_FAN_NAME {
info!("Found ASUS Custom Fan Control at {:?}", path);
return Some(Self { root: path });
}
}
}
}
None
}
fn enable_path(&self, index: u8) -> PathBuf {
self.root.join(format!("pwm{}_enable", index))
}
fn point_pwm_path(&self, fan_idx: u8, point_idx: u8) -> PathBuf {
self.root
.join(format!("pwm{}_auto_point{}_pwm", fan_idx, point_idx))
}
fn point_temp_path(&self, fan_idx: u8, point_idx: u8) -> PathBuf {
self.root
.join(format!("pwm{}_auto_point{}_temp", fan_idx, point_idx))
}
}
// Helper to write with logging
fn write_sysfs(path: &Path, value: &str) -> std::io::Result<()> {
// debug!("Writing {} to {:?}", value, path);
fs::write(path, value)
}
fn _read_sysfs_u8(path: &Path) -> std::io::Result<u8> {
let s = fs::read_to_string(path)?;
s.trim()
.parse::<u8>()
.map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidData, e))
}
pub fn is_custom_fan_supported() -> bool {
SysfsPaths::new().is_some()
}
// Logic to apply a full curve to a specific fan (1=CPU, 2=GPU usually)
// Implements the "Gradual Descent" algorithm
fn apply_curve_to_fan(
paths: &SysfsPaths,
fan_idx: u8,
points: &[CustomCurvePoint],
) -> std::io::Result<()> {
// Sort target points by temp (Hardware Requirement)
let mut sorted_target = points.to_vec();
sorted_target.sort_by_key(|p| p.temp);
// Ensure we have 8 points (fill with last if needed, or sensible default)
while sorted_target.len() < 8 {
if let Some(last) = sorted_target.last() {
sorted_target.push(last.clone());
} else {
sorted_target.push(CustomCurvePoint {
temp: 100,
pwm: 255,
});
}
}
sorted_target.truncate(8);
// Validate Temp Order (Synchronous Check)
for (i, p) in sorted_target.iter().enumerate() {
if i > 0 {
let prev_temp = sorted_target[i - 1].temp;
if p.temp < prev_temp {
error!("Invalid temp order");
return Err(std::io::Error::new(
std::io::ErrorKind::InvalidInput,
"Temp disorder",
));
}
}
}
// Spawn completely detached thread for ALL I/O
let paths_clone = paths.clone();
let sorted_target = sorted_target.clone();
std::thread::spawn(move || {
let paths = paths_clone;
// 1. Enable custom mode
if let Err(e) = write_sysfs(&paths.enable_path(fan_idx), "1") {
error!("Failed to enable custom fan mode: {}", e);
return;
}
// 2. Write Temps
for (i, p) in sorted_target.iter().enumerate() {
let point_idx = (i + 1) as u8;
if let Err(e) = write_sysfs(
&paths.point_temp_path(fan_idx, point_idx),
&p.temp.to_string(),
) {
error!("Failed to write temp point {}: {}", point_idx, e);
}
}
// 3. Write PWMs directly (hardware handles gradual transition)
for (i, target_p) in sorted_target.iter().enumerate() {
let point_idx = (i + 1) as u8;
if let Err(e) = write_sysfs(
&paths.point_pwm_path(fan_idx, point_idx),
&target_p.pwm.to_string(),
) {
error!("Failed to write PWM point {}: {}", point_idx, e);
}
}
// 4. Ensure enable is set
let _ = write_sysfs(&paths.enable_path(fan_idx), "1");
});
Ok(())
}
fn set_fan_auto(paths: &SysfsPaths, fan_idx: u8) -> std::io::Result<()> {
// 2 = Auto (usually)
write_sysfs(&paths.enable_path(fan_idx), "2")
}
fn load_config() -> CustomFanConfig {
if let Some(config_dir) = dirs::config_dir() {
let path = config_dir.join("rog").join(CONFIG_FILE_NAME);
if let Ok(content) = fs::read_to_string(path) {
if let Ok(cfg) = ron::from_str(&content) {
return cfg;
}
}
}
CustomFanConfig::default()
}
fn save_config(config: &CustomFanConfig) {
if let Some(config_dir) = dirs::config_dir() {
let rog_dir = config_dir.join("rog");
let _ = fs::create_dir_all(&rog_dir);
let path = rog_dir.join(CONFIG_FILE_NAME);
if let Ok(s) = ron::ser::to_string_pretty(config, ron::ser::PrettyConfig::default()) {
let _ = fs::write(path, s);
}
}
}
// Public entry point called from setup_fans.rs or similar
// Returns immediately - all work is done in a detached thread
pub fn apply_custom_fan_curve(
_handle_weak: slint::Weak<MainWindow>,
fan_type: FanType,
enabled: bool,
nodes: Vec<Node>,
) {
// Fan Index: 1=CPU, 2=GPU usually.
let fan_idx = match fan_type {
FanType::CPU => 1,
FanType::GPU => 2,
_ => return, // Ignore others
};
// Convert nodes to points (fast, CPU-only)
let points: Vec<CustomCurvePoint> = nodes
.iter()
.map(|n| CustomCurvePoint {
temp: n.x as u8,
pwm: n.y as u8,
})
.collect();
// Spawn a completely detached thread for ALL I/O
std::thread::spawn(move || {
// Get paths (blocking FS operation)
let Some(paths) = SysfsPaths::new() else {
error!("No custom fan support found");
return;
};
// Save config
let mut cfg = load_config();
if enabled {
match fan_type {
FanType::CPU => cfg.cpu_curve = points.clone(),
FanType::GPU => cfg.gpu_curve = points.clone(),
_ => {}
}
}
cfg.enabled = enabled;
save_config(&cfg);
// Apply curve or set auto
if enabled {
if let Err(e) = apply_curve_to_fan(&paths, fan_idx, &points) {
error!("Failed to apply fan curve: {}", e);
}
} else if let Err(e) = set_fan_auto(&paths, fan_idx) {
error!("Failed to set fan auto: {}", e);
}
});
}
rog-control-center/src/ui/setup_fans.rs
+164 -18
View File
@@ -1,4 +1,6 @@
use std::sync::{Arc, Mutex};
use crate::ui::show_toast;
use std::collections::HashMap;
use std::sync::{Arc, Mutex, OnceLock};
use log::error;
use rog_dbus::zbus_fan_curves::FanCurvesProxy;
@@ -8,7 +10,25 @@ use rog_profiles::fan_curve_set::CurveData;
use slint::{ComponentHandle, Model, Weak};
use crate::config::Config;
use crate::{FanPageData, FanType, MainWindow, Node};
use crate::{FanPageData, FanType, MainWindow, Node, Profile};
// Isolated Rust-side cache for fan curves (not affected by Slint reactivity)
type FanCacheKey = (i32, i32); // (Profile as i32, FanType as i32)
static FAN_CACHE: OnceLock<Mutex<HashMap<FanCacheKey, Vec<Node>>>> = OnceLock::new();
fn fan_cache() -> &'static Mutex<HashMap<FanCacheKey, Vec<Node>>> {
FAN_CACHE.get_or_init(|| Mutex::new(HashMap::new()))
}
fn cache_fan_curve(profile: Profile, fan_type: FanType, nodes: Vec<Node>) {
let key = (profile as i32, fan_type as i32);
fan_cache().lock().unwrap().insert(key, nodes);
}
fn get_cached_fan_curve(profile: Profile, fan_type: FanType) -> Option<Vec<Node>> {
let key = (profile as i32, fan_type as i32);
fan_cache().lock().unwrap().get(&key).cloned()
}
pub fn update_fan_data(
handle: Weak<MainWindow>,
@@ -19,7 +39,7 @@ pub fn update_fan_data(
handle
.upgrade_in_event_loop(move |handle| {
let global = handle.global::<FanPageData>();
let collect = |temp: &[u8], pwm: &[u8]| -> slint::ModelRc<Node> {
let _collect = |temp: &[u8], pwm: &[u8]| -> slint::ModelRc<Node> {
let tmp: Vec<Node> = temp
.iter()
.zip(pwm.iter())
@@ -33,61 +53,100 @@ pub fn update_fan_data(
for fan in bal {
global.set_balanced_available(true);
let nodes_vec: Vec<Node> = fan
.temp
.iter()
.zip(fan.pwm.iter())
.map(|(x, y)| Node {
x: *x as f32,
y: *y as f32,
})
.collect();
let nodes: slint::ModelRc<Node> = nodes_vec.as_slice().into();
match fan.fan {
rog_profiles::FanCurvePU::CPU => {
global.set_cpu_fan_available(true);
global.set_balanced_cpu_enabled(fan.enabled);
global.set_balanced_cpu(collect(&fan.temp, &fan.pwm))
global.set_balanced_cpu(nodes.clone());
cache_fan_curve(Profile::Balanced, FanType::CPU, nodes_vec);
}
rog_profiles::FanCurvePU::GPU => {
global.set_gpu_fan_available(true);
global.set_balanced_gpu_enabled(fan.enabled);
global.set_balanced_gpu(collect(&fan.temp, &fan.pwm))
global.set_balanced_gpu(nodes.clone());
cache_fan_curve(Profile::Balanced, FanType::GPU, nodes_vec);
}
rog_profiles::FanCurvePU::MID => {
global.set_mid_fan_available(true);
global.set_balanced_mid_enabled(fan.enabled);
global.set_balanced_mid(collect(&fan.temp, &fan.pwm))
global.set_balanced_mid(nodes.clone());
cache_fan_curve(Profile::Balanced, FanType::Middle, nodes_vec);
}
}
}
for fan in perf {
global.set_performance_available(true);
let nodes_vec: Vec<Node> = fan
.temp
.iter()
.zip(fan.pwm.iter())
.map(|(x, y)| Node {
x: *x as f32,
y: *y as f32,
})
.collect();
let nodes: slint::ModelRc<Node> = nodes_vec.as_slice().into();
match fan.fan {
rog_profiles::FanCurvePU::CPU => {
global.set_cpu_fan_available(true);
global.set_performance_cpu_enabled(fan.enabled);
global.set_performance_cpu(collect(&fan.temp, &fan.pwm))
global.set_performance_cpu(nodes.clone());
cache_fan_curve(Profile::Performance, FanType::CPU, nodes_vec);
}
rog_profiles::FanCurvePU::GPU => {
global.set_gpu_fan_available(true);
global.set_performance_gpu_enabled(fan.enabled);
global.set_performance_gpu(collect(&fan.temp, &fan.pwm))
global.set_performance_gpu(nodes.clone());
cache_fan_curve(Profile::Performance, FanType::GPU, nodes_vec);
}
rog_profiles::FanCurvePU::MID => {
global.set_mid_fan_available(true);
global.set_performance_mid_enabled(fan.enabled);
global.set_performance_mid(collect(&fan.temp, &fan.pwm))
global.set_performance_mid(nodes.clone());
cache_fan_curve(Profile::Performance, FanType::Middle, nodes_vec);
}
}
}
for fan in quiet {
global.set_quiet_available(true);
let nodes_vec: Vec<Node> = fan
.temp
.iter()
.zip(fan.pwm.iter())
.map(|(x, y)| Node {
x: *x as f32,
y: *y as f32,
})
.collect();
let nodes: slint::ModelRc<Node> = nodes_vec.as_slice().into();
match fan.fan {
rog_profiles::FanCurvePU::CPU => {
global.set_cpu_fan_available(true);
global.set_quiet_cpu_enabled(fan.enabled);
global.set_quiet_cpu(collect(&fan.temp, &fan.pwm))
global.set_quiet_cpu(nodes.clone());
cache_fan_curve(Profile::Quiet, FanType::CPU, nodes_vec);
}
rog_profiles::FanCurvePU::GPU => {
global.set_gpu_fan_available(true);
global.set_quiet_gpu_enabled(fan.enabled);
global.set_quiet_gpu(collect(&fan.temp, &fan.pwm))
global.set_quiet_gpu(nodes.clone());
cache_fan_curve(Profile::Quiet, FanType::GPU, nodes_vec);
}
rog_profiles::FanCurvePU::MID => {
global.set_mid_fan_available(true);
global.set_quiet_mid_enabled(fan.enabled);
global.set_quiet_mid(collect(&fan.temp, &fan.pwm))
global.set_quiet_mid(nodes.clone());
cache_fan_curve(Profile::Quiet, FanType::Middle, nodes_vec);
}
}
}
@@ -171,6 +230,7 @@ pub fn setup_fan_curve_page(ui: &MainWindow, _config: Arc<Mutex<Config>>) {
let choices_for_ui = platform_profile_choices.clone();
let handle_next1 = handle_copy.clone();
if let Err(e) = handle_copy.upgrade_in_event_loop(move |handle| {
let handle_weak_for_fans = handle.as_weak();
let global = handle.global::<FanPageData>();
let fans1 = fans.clone();
let choices = choices_for_ui.clone();
@@ -212,17 +272,103 @@ pub fn setup_fan_curve_page(ui: &MainWindow, _config: Arc<Mutex<Config>>) {
update_fan_data(handle_next, balanced, perf, quiet);
});
});
let handle_weak_for_cancel = handle_weak_for_fans.clone();
global.on_set_fan_data(move |fan, profile, enabled, data| {
if crate::ui::setup_fan_curve_custom::is_custom_fan_supported() {
let handle_weak = handle_weak_for_fans.clone();
let data: Vec<Node> = data.iter().collect();
use log::info;
info!("MainThread: Request to apply custom curve for {:?}", fan);
// Explicitly spawn a thread to handle this, preventing ANY main thread blocking
std::thread::spawn(move || {
info!("WorkerThread: applying curve for {:?}", fan);
crate::ui::setup_fan_curve_custom::apply_custom_fan_curve(
handle_weak.clone(),
fan,
enabled,
data,
);
info!("WorkerThread: returned from apply (async), clearing busy flag for {:?}", fan);
// Clear busy flag
let _ = handle_weak.upgrade_in_event_loop(move |h| {
let g = h.global::<FanPageData>();
match fan {
FanType::CPU => g.set_is_busy_cpu(false),
FanType::GPU => g.set_is_busy_gpu(false),
FanType::Middle => g.set_is_busy_mid(false),
}
info!("MainThread: cleared busy flag for {:?}", fan);
});
});
return;
}
let fans = fans.clone();
let data: Vec<Node> = data.iter().collect();
let data = fan_data_for(fan, enabled, data);
let handle_weak = handle_weak_for_fans.clone();
let nodes_vec: Vec<Node> = data.iter().collect();
let _data_copy = nodes_vec.clone();
let cache_copy = nodes_vec.clone(); // Clone for cache update
let fan_data = fan_data_for(fan, enabled, nodes_vec);
tokio::spawn(async move {
fans.set_fan_curve(profile.into(), data)
.await
.map_err(|e| error!("{e:}"))
.ok()
show_toast(
"Fan curve applied".into(),
"Failed to apply fan curve".into(),
handle_weak.clone(),
fans.set_fan_curve(profile.into(), fan_data).await,
);
let _ = handle_weak.upgrade_in_event_loop(move |h| {
let g = h.global::<FanPageData>();
// Update Rust-side cache (isolated from Slint properties)
cache_fan_curve(profile, fan, cache_copy);
match fan {
FanType::CPU => g.set_is_busy_cpu(false),
FanType::GPU => g.set_is_busy_gpu(false),
FanType::Middle => g.set_is_busy_mid(false),
}
});
});
});
global.on_cancel(move |fan_type, profile| {
let handle_weak = handle_weak_for_cancel.clone();
let _ = handle_weak.upgrade_in_event_loop(move |h: MainWindow| {
let global = h.global::<FanPageData>();
// Retrieve from isolated Rust cache
let nodes_opt = get_cached_fan_curve(profile, fan_type);
if let Some(nodes_vec) = nodes_opt {
use log::info;
info!("Canceling {:?} {:?} - restoring {} nodes from isolated cache", fan_type, profile, nodes_vec.len());
let new_model: slint::ModelRc<Node> = nodes_vec.as_slice().into();
match (profile, fan_type) {
(crate::Profile::Balanced, FanType::CPU) => global.set_balanced_cpu(new_model),
(crate::Profile::Balanced, FanType::GPU) => global.set_balanced_gpu(new_model),
(crate::Profile::Balanced, FanType::Middle) => global.set_balanced_mid(new_model),
(crate::Profile::Performance, FanType::CPU) => global.set_performance_cpu(new_model),
(crate::Profile::Performance, FanType::GPU) => global.set_performance_gpu(new_model),
(crate::Profile::Performance, FanType::Middle) => global.set_performance_mid(new_model),
(crate::Profile::Quiet, FanType::CPU) => global.set_quiet_cpu(new_model),
(crate::Profile::Quiet, FanType::GPU) => global.set_quiet_gpu(new_model),
(crate::Profile::Quiet, FanType::Middle) => global.set_quiet_mid(new_model),
_ => {}
}
} else {
log::warn!("Cancel failed: No cached data for {:?} {:?}", fan_type, profile);
}
});
});
// Initialize warning
if crate::ui::setup_fan_curve_custom::is_custom_fan_supported() {
global.set_show_custom_warning(true);
}
}) {
error!("setup_fan_curve_page: upgrade_in_event_loop: {e:?}");
}
rog-control-center/src/ui/setup_screenpad.rs
+143
View File
@@ -0,0 +1,143 @@
use log::{debug, error};
use rog_dbus::zbus_backlight::BacklightProxy;
use slint::ComponentHandle;
use std::sync::{Arc, Mutex};
use crate::config::Config;
use crate::ui::show_toast;
use crate::{MainWindow, ScreenpadPageData};
pub fn setup_screenpad(ui: &MainWindow, _config: Arc<Mutex<Config>>) {
let handle = ui.as_weak();
tokio::spawn(async move {
// Create the connections/proxies here
let conn = match zbus::Connection::system().await {
Ok(conn) => conn,
Err(e) => {
error!("Failed to connect to system bus for Screenpad: {e:}");
return;
}
};
let backlight = match BacklightProxy::builder(&conn).build().await {
Ok(backlight) => backlight,
Err(e) => {
error!("Failed to create backlight proxy for Screenpad: {e:}");
return;
}
};
// Initialize state
debug!("Initializing Screenpad page data");
// Use helper to set initial properties
if let Ok(val) = backlight.screenpad_brightness().await {
handle
.upgrade_in_event_loop(move |h| {
h.global::<ScreenpadPageData>().set_brightness(val);
// Assume power is on if brightness > 0
h.global::<ScreenpadPageData>().set_power(val > 0);
})
.ok();
}
if let Ok(gamma_str) = backlight.screenpad_gamma().await {
if let Ok(gamma) = gamma_str.parse::<f32>() {
handle
.upgrade_in_event_loop(move |h| {
h.global::<ScreenpadPageData>().set_gamma(gamma);
})
.ok();
}
}
if let Ok(sync) = backlight.screenpad_sync_with_primary().await {
handle
.upgrade_in_event_loop(move |h| {
h.global::<ScreenpadPageData>().set_sync_with_primary(sync);
})
.ok();
}
// Set up callbacks
let handle_copy = handle.clone();
let backlight_copy = backlight.clone();
handle
.upgrade_in_event_loop(move |h| {
let global = h.global::<ScreenpadPageData>();
// Brightness Callback
let hl = handle_copy.clone();
let bl = backlight_copy.clone();
global.on_cb_brightness(move |val| {
let bl = bl.clone();
let hl = hl.clone();
tokio::spawn(async move {
show_toast(
format!("Screenpad brightness set to {}", val).into(),
"Failed to set Screenpad brightness".into(),
hl,
bl.set_screenpad_brightness(val).await,
);
});
});
// Gamma Callback
let hl = handle_copy.clone();
let bl = backlight_copy.clone();
global.on_cb_gamma(move |val| {
let bl = bl.clone();
let hl = hl.clone();
tokio::spawn(async move {
show_toast(
format!("Screenpad gamma set to {:.2}", val).into(),
"Failed to set Screenpad gamma".into(),
hl,
bl.set_screenpad_gamma(&val.to_string()).await,
);
});
});
// Sync Callback
let hl = handle_copy.clone();
let bl = backlight_copy.clone();
global.on_cb_sync_with_primary(move |val| {
let bl = bl.clone();
let hl = hl.clone();
tokio::spawn(async move {
show_toast(
format!(
"Screenpad sync {}",
if val { "enabled" } else { "disabled" }
)
.into(),
"Failed to toggle Screenpad sync".into(),
hl,
bl.set_screenpad_sync_with_primary(val).await,
);
});
});
// Power Callback (Toggle brightness to 0/last or 100)
let hl = handle_copy.clone();
let bl = backlight_copy.clone();
global.on_cb_power(move |val| {
let bl = bl.clone();
let hl = hl.clone();
tokio::spawn(async move {
let target = if val { 100 } else { 0 };
let _ = bl.set_screenpad_brightness(target).await;
hl.upgrade_in_event_loop(move |h| {
h.global::<ScreenpadPageData>().set_brightness(target);
})
.ok();
});
});
})
.ok();
// Optional: Value watches for external changes
// (Similar to setup_system.rs if needed)
});
}
rog-control-center/src/ui/setup_slash.rs
+132
View File
@@ -0,0 +1,132 @@
use crate::config::Config;
use crate::set_ui_callbacks;
use crate::ui::show_toast;
use crate::{MainWindow, SlashPageData};
use rog_dbus::{find_iface_async, zbus_slash::SlashProxy};
use rog_slash::SlashMode;
use slint::{ComponentHandle, Model};
use std::str::FromStr;
use std::sync::{Arc, Mutex};
pub fn setup_slash(ui: &MainWindow, _config: Arc<Mutex<Config>>) {
let ui_weak = ui.as_weak();
tokio::spawn(async move {
// Find the Slash interface proxy
let proxies = match find_iface_async::<SlashProxy>("xyz.ljones.Slash").await {
Ok(p) => p,
Err(e) => {
log::warn!("Failed to find Slash interface: {}", e);
return;
}
};
let proxy = match proxies.first() {
Some(p) => p.clone(),
None => return,
};
// UI Callbacks (MUST be done on UI thread to access global state)
{
let proxy_copy = proxy.clone();
let _ = ui_weak.upgrade_in_event_loop(move |ui| {
let proxy = proxy_copy.clone();
let ui_handle = ui;
set_ui_callbacks!(ui_handle, SlashPageData(), proxy.enabled(), "Slash enabled {}", "Failed to enable slash");
// Fix: Cast f32 (UI) to u8 (DBus)
set_ui_callbacks!(ui_handle, SlashPageData(as f32), proxy.brightness(as u8), "Slash brightness set to {}", "Failed to set slash brightness");
set_ui_callbacks!(ui_handle, SlashPageData(as f32), proxy.interval(as u8), "Slash interval set to {}", "Failed to set slash interval");
set_ui_callbacks!(ui_handle, SlashPageData(), proxy.show_battery_warning(), "Battery warning set to {}", "Failed to set battery warning");
set_ui_callbacks!(ui_handle, SlashPageData(), proxy.show_on_battery(), "Show on battery set to {}", "Failed to set show on battery");
set_ui_callbacks!(ui_handle, SlashPageData(), proxy.show_on_boot(), "Show on boot set to {}", "Failed to set show on boot");
set_ui_callbacks!(ui_handle, SlashPageData(), proxy.show_on_shutdown(), "Show on shutdown set to {}", "Failed to set show on shutdown");
set_ui_callbacks!(ui_handle, SlashPageData(), proxy.show_on_sleep(), "Show on sleep set to {}", "Failed to set show on sleep");
set_ui_callbacks!(ui_handle, SlashPageData(), proxy.show_on_lid_closed(), "Show on lid closed set to {}", "Failed to set show on lid closed");
});
}
// Custom Mode Logic - Callback setup
{
let proxy_copy = proxy.clone();
let ui_weak_copy = ui_weak.clone();
let _ = ui_weak.upgrade_in_event_loop(move |ui| {
let data = ui.global::<SlashPageData>();
data.on_cb_mode_index(move |idx| {
let proxy_copy = proxy_copy.clone();
let handle_weak = ui_weak_copy.clone();
let mode_str_opt = if let Some(h) = handle_weak.upgrade() {
let d = h.global::<SlashPageData>();
if idx >= 0 && (idx as usize) < d.get_modes().row_count() {
Some(d.get_modes().row_data(idx as usize).unwrap_or_default())
} else {
None
}
} else {
None
};
if let Some(mode_str) = mode_str_opt {
if let Ok(mode) = SlashMode::from_str(&mode_str) {
tokio::spawn(async move {
show_toast(
format!("Slash mode set to {}", mode).into(),
"Failed to set slash mode".into(),
handle_weak,
proxy_copy.set_mode(mode).await,
);
});
}
}
});
});
}
// D-Bus Signal -> UI
let proxy_copy = proxy.clone();
let handle_copy = ui_weak.clone();
tokio::spawn(async move {
let mut changes = proxy_copy.receive_mode_changed().await;
use futures_util::StreamExt;
while let Some(change) = changes.next().await {
if let Ok(mode) = change.get().await {
let mode_str = mode.to_string();
let handle_copy = handle_copy.clone();
let _ = slint::invoke_from_event_loop(move || {
if let Some(h) = handle_copy.upgrade() {
let d = h.global::<SlashPageData>();
let model = d.get_modes();
for (i, m) in model.iter().enumerate() {
if m == mode_str {
d.set_mode_index(i as i32);
break;
}
}
}
});
}
}
});
if let Ok(m) = proxy.mode().await {
let mode_str = m.to_string();
let _ = slint::invoke_from_event_loop(move || {
if let Some(h) = ui_weak.upgrade() {
let d = h.global::<SlashPageData>();
let model = d.get_modes();
for (i, m) in model.iter().enumerate() {
if m == mode_str {
d.set_mode_index(i as i32);
break;
}
}
}
});
}
});
}
rog-control-center/src/ui/setup_status.rs
+150
View File
@@ -0,0 +1,150 @@
use crate::config::Config;
use crate::tray::TrayStats;
use crate::{MainWindow, SystemStatus};
use rog_dbus::zbus_platform::PlatformProxy;
use slint::ComponentHandle;
use std::collections::VecDeque;
use std::path::PathBuf;
use std::sync::{Arc, Mutex};
use tokio::fs;
use tokio::time::Duration;
use zbus::Connection;
pub fn setup_status(
ui: &MainWindow,
_config: Arc<Mutex<Config>>,
stats_tx: tokio::sync::watch::Sender<TrayStats>,
) {
let ui_weak = ui.as_weak();
tokio::spawn(async move {
let mut power_history: VecDeque<i32> = VecDeque::with_capacity(150); // 300s window at 2s poll
// DBus connection for profile
let conn = Connection::system().await.ok();
let platform = if let Some(c) = &conn {
PlatformProxy::new(c).await.ok()
} else {
None
};
loop {
let (cpu_temp, gpu_temp, cpu_fan, gpu_fan) = read_hwmon().await;
let power_microwatts = read_power().await;
// Rolling average logic
if power_history.len() >= 150 {
power_history.pop_front();
}
power_history.push_back(power_microwatts);
let sum: i64 = power_history.iter().map(|&x| x as i64).sum();
let avg_microwatts = if !power_history.is_empty() {
sum / power_history.len() as i64
} else {
0
};
// Convert to Watts
let power_w = power_microwatts as f64 / 1_000_000.0;
let avg_w = avg_microwatts as f64 / 1_000_000.0;
// Fetch profile
let mut profile_str = "Unknown".to_string();
if let Some(p) = &platform {
if let Ok(prof) = p.platform_profile().await {
profile_str = format!("{:?}", prof);
}
}
let ui_weak_loop = ui_weak.clone(); // Clone ui_weak for this iteration
// Send to Tray
let _ = stats_tx.send(TrayStats {
cpu_temp: format!("{}", cpu_temp),
gpu_temp: format!("{}", gpu_temp),
cpu_fan: format!("{}", cpu_fan),
gpu_fan: format!("{}", gpu_fan),
power_w: format!("{:.1}", power_w),
power_profile: profile_str,
});
let _ = slint::invoke_from_event_loop(move || {
if let Some(ui) = ui_weak_loop.upgrade() {
let global = ui.global::<SystemStatus>();
global.set_cpu_temp(cpu_temp);
global.set_gpu_temp(gpu_temp);
global.set_cpu_fan(cpu_fan);
global.set_gpu_fan(gpu_fan);
global.set_power_w(slint::SharedString::from(format!("{:.1}", power_w)));
global.set_power_avg_w(slint::SharedString::from(format!("{:.1}", avg_w)));
}
});
tokio::time::sleep(Duration::from_secs(2)).await;
}
});
}
async fn read_hwmon() -> (i32, i32, i32, i32) {
let mut cpu_temp = 0;
let mut gpu_temp = 0;
let mut cpu_fan = 0;
let mut gpu_fan = 0;
let mut entries = match fs::read_dir("/sys/class/hwmon").await {
Ok(e) => e,
Err(_) => return (0, 0, 0, 0),
};
while let Ok(Some(entry)) = entries.next_entry().await {
let path = entry.path();
let name_path = path.join("name");
if let Ok(name_str) = fs::read_to_string(&name_path).await {
let name = name_str.trim();
if name == "k10temp" || name == "coretemp" || name == "zenpower" {
// Try temp1_input (TCtl/Package)
if let Ok(temp) = read_val(&path.join("temp1_input")).await {
cpu_temp = temp / 1000;
}
} else if name == "amdgpu" || name == "nvidia" {
if let Ok(temp) = read_val(&path.join("temp1_input")).await {
gpu_temp = temp / 1000;
}
} else if name == "asus" || name == "asus_custom_fan_curve" {
if let Ok(fan) = read_val(&path.join("fan1_input")).await {
cpu_fan = fan;
}
if let Ok(fan) = read_val(&path.join("fan2_input")).await {
gpu_fan = fan;
}
}
}
}
(cpu_temp, gpu_temp, cpu_fan, gpu_fan)
}
async fn read_val(path: &PathBuf) -> Result<i32, ()> {
let s = fs::read_to_string(path).await.map_err(|_| ())?;
s.trim().parse::<i32>().map_err(|_| ())
}
async fn read_power() -> i32 {
let mut p = 0;
// Try BAT0 then BAT1
if let Ok(v) = read_val(&PathBuf::from("/sys/class/power_supply/BAT0/power_now")).await {
p = v.abs();
} else if let Ok(v) = read_val(&PathBuf::from("/sys/class/power_supply/BAT1/power_now")).await {
p = v.abs();
}
// Check status
if let Ok(s) = fs::read_to_string("/sys/class/power_supply/BAT0/status").await {
if s.trim() == "Discharging" {
return -p;
}
}
p
}
rog-control-center/src/ui/setup_supergfx.rs
+102
View File
@@ -0,0 +1,102 @@
use crate::config::Config;
use crate::ui::show_toast;
use crate::{MainWindow, SupergfxPageData};
use slint::{ComponentHandle, Model, SharedString, VecModel};
use std::rc::Rc;
use std::sync::{Arc, Mutex};
use zbus::proxy;
#[proxy(
interface = "org.supergfxctl.Daemon",
default_service = "org.supergfxctl.Daemon",
default_path = "/org/supergfxctl/Gfx"
)]
trait Supergfx {
fn supported(&self) -> zbus::Result<Vec<String>>;
fn mode(&self) -> zbus::Result<String>;
fn set_mode(&self, mode: &str) -> zbus::Result<()>;
fn vendor(&self) -> zbus::Result<String>;
}
pub fn setup_supergfx(ui: &MainWindow, _config: Arc<Mutex<Config>>) {
let ui_weak = ui.as_weak();
tokio::spawn(async move {
let conn = match zbus::Connection::system().await {
Ok(c) => c,
Err(e) => {
log::warn!("Failed to connect to system bus: {}", e);
return;
}
};
let proxy = match SupergfxProxy::new(&conn).await {
Ok(p) => p,
Err(e) => {
log::warn!("Failed to create Supergfx proxy: {}", e);
return;
}
};
// Register Callbacks on UI Thread
{
let proxy_copy = proxy.clone();
let ui_weak_copy = ui_weak.clone();
let _ = ui_weak.upgrade_in_event_loop(move |ui| {
let handle_copy = ui_weak_copy.clone();
ui.global::<SupergfxPageData>()
.on_set_mode(move |mode_str| {
let proxy = proxy_copy.clone();
let handle = handle_copy.clone();
tokio::spawn(async move {
show_toast(
format!("Switching to {}. Logout required.", mode_str).into(),
"Failed to set mode".into(),
handle,
proxy.set_mode(&mode_str).await,
);
});
});
});
}
// Fetch Initial State
// Vendor
if let Ok(vendor) = proxy.vendor().await {
let _ = ui_weak.upgrade_in_event_loop(move |ui| {
ui.global::<SupergfxPageData>().set_vendor(vendor.into())
});
}
// Supported Modes
if let Ok(supported) = proxy.supported().await {
let modes: Vec<SharedString> = supported
.iter()
.map(|s| SharedString::from(s.as_str()))
.collect();
let _ = ui_weak.upgrade_in_event_loop(move |ui| {
let mode_model = Rc::new(VecModel::from(modes));
ui.global::<SupergfxPageData>()
.set_supported_modes(mode_model.into())
});
}
// Current Mode
if let Ok(mode) = proxy.mode().await {
let _ = ui_weak.upgrade_in_event_loop(move |ui| {
let g = ui.global::<SupergfxPageData>();
g.set_current_mode(mode.clone().into());
// Update selection index
let model = g.get_supported_modes();
for (i, m) in model.iter().enumerate() {
if m == mode.as_str() {
g.set_selected_index(i as i32);
break;
}
}
});
}
// No signal monitoring implemented as supergfxctl state changes usually require user action/logout
});
}
rog-control-center/src/ui/setup_system.rs
+5 -36
View File
@@ -47,7 +47,6 @@ pub fn setup_system_page(ui: &MainWindow, _config: Arc<Mutex<Config>>) {
ui.global::<SystemPageData>().set_screen_auto_brightness(-1);
ui.global::<SystemPageData>().set_mcu_powersave(-1);
ui.global::<SystemPageData>().set_mini_led_mode(-1);
ui.global::<SystemPageData>().set_screenpad_brightness(-1);
ui.global::<SystemPageData>().set_ppt_pl1_spl(MINMAX);
ui.global::<SystemPageData>().set_ppt_pl2_sppt(MINMAX);
ui.global::<SystemPageData>().set_ppt_pl3_fppt(MINMAX);
@@ -296,7 +295,7 @@ pub fn setup_system_page_callbacks(ui: &MainWindow, _states: Arc<Mutex<Config>>)
log::error!("Failed to create platform proxy: {}", e);
})
.unwrap();
let backlight = BacklightProxy::builder(&conn)
let _backlight = BacklightProxy::builder(&conn)
.build()
.await
.map_err(|e| {
@@ -397,23 +396,7 @@ pub fn setup_system_page_callbacks(ui: &MainWindow, _states: Arc<Mutex<Config>>)
set_ui_props_async!(handle, platform, SystemPageData, enable_ppt_group);
set_ui_props_async!(handle, backlight, SystemPageData, screenpad_brightness);
if let Ok(value) = backlight.screenpad_gamma().await {
handle
.upgrade_in_event_loop(move |handle| {
handle
.global::<SystemPageData>()
.set_screenpad_gamma(value.parse().unwrap_or(1.0));
})
.ok();
}
set_ui_props_async!(
handle,
backlight,
SystemPageData,
screenpad_sync_with_primary
);
set_ui_props_async!(handle, platform, SystemPageData, enable_ppt_group);
let platform_copy = platform.clone();
handle
@@ -536,25 +519,11 @@ pub fn setup_system_page_callbacks(ui: &MainWindow, _states: Arc<Mutex<Config>>)
"Setting Throttle policy on AC failed"
);
set_ui_callbacks!(handle,
SystemPageData(as i32),
backlight.screenpad_brightness(as i32),
"Screenpad successfully set to {}",
"Setting screenpad brightness failed"
);
set_ui_callbacks!(handle,
SystemPageData(as bool),
backlight.screenpad_sync_with_primary(as bool),
"Screenpad successfully set to {}",
"Setting screenpad brightness failed"
);
set_ui_callbacks!(handle,
SystemPageData(.parse().unwrap_or(1.0)),
backlight.screenpad_gamma(.to_string().as_str()),
"Screenpad successfully set to {}",
"Setting screenpad brightness failed"
platform_copy.change_platform_profile_on_battery(.into()),
"Throttle policy on battery enabled: {}",
"Setting Throttle policy on AC failed"
);
})
.ok();