Merge branch 'fix/one-shot-charge-persistence' into 'devel'

fix: one-shot charging loses original charge limit after restart

See merge request asus-linux/asusctl!242

.gitlab-ci.yml

@@ -90,7 +90,7 @@ pages:
     - rm -rf public
     - mkdir public
     - cp -R ci-target/doc/* public
-    - if [ -f extra/index.html ]; then cp extra/index.html public; else echo "no extra/index.html to copy"; fi
+    - cp extra/index.html public
   artifacts:
     paths:
       - public

CHANGELOG.md

@@ -1,21 +1,9 @@
 # Changelog
 
-## [6.3.1]
+## [Unreleased]
-
-### Changes
-- Removed a lighting mode that is unavailable in windows to G835L: thanks to @shevchenko0013 again!
-- Added translations for Ukranian language, thanks @shevchenko0013!
-- Added LEDs definition for G615LR, thanks @btnrv
-- Fix improper usage of Quiet when only LowPower is available
-
-## [6.3.0]
 
 ### Changed
 - Added support for TUF keyboard powerstate control
-- Improved AniMe Matrix support thanks to @Seom1177 !
-- Fixed a bug with one-shot battery change, thanks @bitr8 !
-- Changed the CLI interface of asusctl to be less confusing
-- Added support for G835L, thanks to @shevchenko0013 !
 
 ## [6.2.0]
 

Cargo.toml

@@ -1,12 +1,9 @@
 [workspace.package]
-version = "6.3.1"
+version = "6.2.0"
 rust-version = "1.82"
 license = "MPL-2.0"
 readme = "README.md"
-authors = [
+authors = ["Luke <luke@ljones.dev>"]
-  "Luke <luke@ljones.dev>",
-  "Denis Benato <benato.denis96@gmail.com>"
-]
 repository = "https://gitlab.com/asus-linux/asusctl"
 homepage = "https://gitlab.com/asus-linux/asusctl"
 description = "Laptop feature control for ASUS ROG laptops and others"
@@ -47,7 +44,7 @@ smol = "^2.0"
 mio = "0.8.11"
 
 futures-util = "0.3.31"
-zbus = "5.13.1"
+zbus = "5.5.0"
 logind-zbus = { version = "5.2.0" } #, default-features = false, features = ["non_blocking"] }
 
 serde = { version = "^1.0", features = ["serde_derive"] }

README.md

@@ -13,7 +13,9 @@ Now includes a GUI, `rog-control-center`.
 
 Due to on-going driver work the minimum suggested kernel version is always **the latest*, as improvements and fixes are continuous.
 
-Support for TDP is tied to the new asus-armoury driver: available mainline since linux 6.19: everything older is not supported.
+Support for some new features is not avilable unless you run a patched kernel with the work I am doing [in this github repo](https://github.com/flukejones/linux/tree/wip/ally-6.13). Use the linked branch, or `wip/ally-6.12`. Everything that is done here is upstreamed eventually (a long process).
+
+Z13 devices will need [these](https://lore.kernel.org/linux-input/20240416090402.31057-1-luke@ljones.dev/T/#t)
 
 ## X11 support
 
@@ -178,7 +180,3 @@ Reference to any ASUS products, services, processes, or other information and/or
 The use of ROG and ASUS trademarks within this website and associated tools and libraries is only to provide a recognisable identifier to users to enable them to associate that these tools will work with ASUS ROG laptops.
 
 ---
-
-## AI Disaclaimer
-
-Portions of this code have been written by various AI tools and reviewed by the maintainer exaclty as with every other contribution.

asusctl/Cargo.toml

@@ -24,7 +24,6 @@ env_logger.workspace = true
 ron.workspace = true
 gumdrop.workspace = true
 zbus.workspace = true
-argh = "0.1"
 
 [dev-dependencies]
 rog_dbus = { path = "../rog-dbus" }

asusctl/src/anime_cli.rs

@@ -1,151 +1,154 @@
-use argh::FromArgs;
+use gumdrop::Options;
-use rog_anime::usb::{AnimAwake, AnimBooting, AnimShutdown, AnimSleeping};
+use rog_anime::usb::{AnimAwake, AnimBooting, AnimShutdown, AnimSleeping, Brightness};
 use rog_anime::AnimeType;
 
-#[derive(FromArgs, Debug)]
+#[derive(Options)]
-#[argh(subcommand, name = "anime", description = "anime commands")]
 pub struct AnimeCommand {
-    #[argh(option, description = "override the display type")]
+    #[options(help = "print help message")]
+    pub help: bool,
+    #[options(meta = "", help = "override the display type")]
     pub override_type: Option<AnimeType>,
-    #[argh(option, description = "enable/disable the display")]
+    #[options(meta = "", help = "enable/disable the display")]
     pub enable_display: Option<bool>,
-    #[argh(
+    #[options(meta = "", help = "enable/disable the builtin run/powersave animation")]
-        option,
-        description = "enable/disable the builtin run/powersave animation"
-    )]
     pub enable_powersave_anim: Option<bool>,
-    #[argh(
+    #[options(
-        option,
+        meta = "",
-        description = "set global base brightness value <off, low, med, high>"
+        help = "set global base brightness value <Off, Low, Med, High>"
     )]
-    pub brightness: Option<rog_anime::usb::Brightness>,
+    pub brightness: Option<Brightness>,
-    #[argh(switch, description = "clear the display")]
+    #[options(help = "clear the display")]
     pub clear: bool,
-    #[argh(
+    #[options(
-        option,
+        no_short,
-        description = "turn the anime off when external power is unplugged"
+        meta = "",
+        help = "turn the anime off when external power is unplugged"
     )]
     pub off_when_unplugged: Option<bool>,
-    #[argh(option, description = "turn the anime off when the laptop suspends")]
+    #[options(
+        no_short,
+        meta = "",
+        help = "turn the anime off when the laptop suspends"
+    )]
     pub off_when_suspended: Option<bool>,
-    #[argh(option, description = "turn the anime off when the lid is closed")]
+    #[options(
+        no_short,
+        meta = "",
+        help = "turn the anime off when the lid is closed"
+    )]
     pub off_when_lid_closed: Option<bool>,
-    #[argh(option, description = "off with his head!!!")]
+    #[options(no_short, meta = "", help = "Off with his head!!!")]
     pub off_with_his_head: Option<bool>,
-    #[argh(subcommand)]
+    #[options(command)]
     pub command: Option<AnimeActions>,
 }
 
-/// Anime subcommands (image, gif, builtins, etc.)
+#[derive(Options)]
-#[derive(FromArgs, Debug)]
-#[argh(subcommand)]
 pub enum AnimeActions {
+    #[options(help = "display a PNG image")]
     Image(AnimeImage),
+    #[options(help = "display a diagonal/pixel-perfect PNG")]
     PixelImage(AnimeImageDiagonal),
+    #[options(help = "display an animated GIF")]
     Gif(AnimeGif),
+    #[options(help = "display an animated diagonal/pixel-perfect GIF")]
     PixelGif(AnimeGifDiagonal),
+    #[options(help = "change which builtin animations are shown")]
     SetBuiltins(Builtins),
 }
 
-#[derive(FromArgs, Debug)]
+#[derive(Options)]
-#[argh(
-    subcommand,
-    name = "set-builtins",
-    description = "change which builtin animations are shown"
-)]
 pub struct Builtins {
-    #[argh(
+    #[options(help = "print help message")]
-        option,
+    pub help: bool,
-        description = "default is used if unspecified, <default:GlitchConstruction, StaticEmergence>"
+    #[options(
+        meta = "",
+        help = "Default is used if unspecified, <default:GlitchConstruction, StaticEmergence>"
     )]
     pub boot: AnimBooting,
-    #[argh(
+    #[options(
-        option,
+        meta = "",
-        description = "default is used if unspecified, <default:BinaryBannerScroll, RogLogoGlitch>"
+        help = "Default is used if unspecified, <default:BinaryBannerScroll, RogLogoGlitch>"
     )]
     pub awake: AnimAwake,
-    #[argh(
+    #[options(
-        option,
+        meta = "",
-        description = "default is used if unspecified, <default:BannerSwipe, Starfield>"
+        help = "Default is used if unspecified, <default:BannerSwipe, Starfield>"
     )]
     pub sleep: AnimSleeping,
-    #[argh(
+    #[options(
-        option,
+        meta = "",
-        description = "default is used if unspecified, <default:GlitchOut, SeeYa>"
+        help = "Default is used if unspecified, <default:GlitchOut, SeeYa>"
     )]
     pub shutdown: AnimShutdown,
-    #[argh(option, description = "set/apply the animations <true/false>")]
+    #[options(meta = "", help = "set/apply the animations <true/false>")]
     pub set: Option<bool>,
 }
 
-#[derive(FromArgs, Debug)]
+#[derive(Options)]
-#[argh(subcommand, name = "image", description = "display a PNG image")]
 pub struct AnimeImage {
-    #[argh(option, description = "full path to the png to display")]
+    #[options(help = "print help message")]
+    pub help: bool,
+    #[options(meta = "", help = "full path to the png to display")]
     pub path: String,
-    #[argh(option, default = "1.0", description = "scale 1.0 == normal")]
+    #[options(meta = "", default = "1.0", help = "scale 1.0 == normal")]
     pub scale: f32,
-    #[argh(option, default = "0.0", description = "x position (float)")]
+    #[options(meta = "", default = "0.0", help = "x position (float)")]
     pub x_pos: f32,
-    #[argh(option, default = "0.0", description = "y position (float)")]
+    #[options(meta = "", default = "0.0", help = "y position (float)")]
     pub y_pos: f32,
-    #[argh(option, default = "0.0", description = "the angle in radians")]
+    #[options(meta = "", default = "0.0", help = "the angle in radians")]
     pub angle: f32,
-    #[argh(option, default = "1.0", description = "brightness 0.0-1.0")]
+    #[options(meta = "", default = "1.0", help = "brightness 0.0-1.0")]
     pub bright: f32,
 }
 
-#[derive(FromArgs, Debug)]
+#[derive(Options)]
-#[argh(
-    subcommand,
-    name = "pixel-image",
-    description = "display a diagonal/pixel-perfect PNG"
-)]
 pub struct AnimeImageDiagonal {
-    #[argh(option, description = "full path to the png to display")]
+    #[options(help = "print help message")]
+    pub help: bool,
+    #[options(meta = "", help = "full path to the png to display")]
     pub path: String,
-    #[argh(option, default = "1.0", description = "brightness 0.0-1.0")]
+    #[options(meta = "", default = "1.0", help = "brightness 0.0-1.0")]
     pub bright: f32,
 }
 
-#[derive(FromArgs, Debug)]
+#[derive(Options)]
-#[argh(subcommand, name = "gif", description = "display an animated GIF")]
 pub struct AnimeGif {
-    #[argh(option, description = "full path to the gif to display")]
+    #[options(help = "print help message")]
+    pub help: bool,
+    #[options(meta = "", help = "full path to the png to display")]
     pub path: String,
-    #[argh(option, default = "1.0", description = "scale 1.0 == normal")]
+    #[options(meta = "", default = "1.0", help = "scale 1.0 == normal")]
     pub scale: f32,
-    #[argh(option, default = "0.0", description = "x position (float)")]
+    #[options(meta = "", default = "0.0", help = "x position (float)")]
     pub x_pos: f32,
-    #[argh(option, default = "0.0", description = "y position (float)")]
+    #[options(meta = "", default = "0.0", help = "y position (float)")]
     pub y_pos: f32,
-    #[argh(option, default = "0.0", description = "the angle in radians")]
+    #[options(meta = "", default = "0.0", help = "the angle in radians")]
     pub angle: f32,
-    #[argh(option, default = "1.0", description = "brightness 0.0-1.0")]
+    #[options(meta = "", default = "1.0", help = "brightness 0.0-1.0")]
     pub bright: f32,
-    #[argh(
+    #[options(
-        option,
+        meta = "",
         default = "1",
-        description = "how many loops to play - 0 is infinite"
+        help = "how many loops to play - 0 is infinite"
     )]
     pub loops: u32,
 }
 
-#[derive(FromArgs, Debug)]
+#[derive(Options)]
-#[argh(
-    subcommand,
-    name = "pixel-gif",
-    description = "display an animated diagonal/pixel-perfect GIF"
-)]
 pub struct AnimeGifDiagonal {
-    #[argh(option, description = "full path to the gif to display")]
+    #[options(help = "print help message")]
+    pub help: bool,
+    #[options(meta = "", help = "full path to the png to display")]
     pub path: String,
-    #[argh(option, default = "1.0", description = "brightness 0.0-1.0")]
+    #[options(meta = "", default = "1.0", help = "brightness 0.0-1.0")]
     pub bright: f32,
-    #[argh(
+    #[options(
-        option,
+        meta = "",
         default = "1",
-        description = "how many loops to play - 0 is infinite"
+        help = "how many loops to play - 0 is infinite"
     )]
     pub loops: u32,
 }

asusctl/src/aura_cli.rs

@@ -1,67 +1,68 @@
-use std::fmt;
 use std::str::FromStr;
 
-use argh::FromArgs;
+use gumdrop::Options;
 use rog_aura::error::Error;
 use rog_aura::{AuraEffect, AuraModeNum, AuraZone, Colour, Direction, Speed};
 
-#[derive(FromArgs, Debug, Clone)]
+#[derive(Options, Debug)]
-#[argh(
-    subcommand,
-    name = "aura-power-old",
-    description = "aura power (old ROGs and TUF laptops)"
-)]
 pub struct LedPowerCommand1 {
-    #[argh(
+    #[options(help = "print help message")]
-        option,
+    pub help: bool,
-        description = "control if LEDs enabled while awake <true/false>"
+    #[options(meta = "", help = "Control if LEDs enabled while awake <true/false>")]
-    )]
     pub awake: Option<bool>,
-
+    #[options(help = "Use with awake option, if excluded defaults to false")]
-    #[argh(
-        switch,
-        description = "use with awake option; if excluded defaults to false"
-    )]
     pub keyboard: bool,
-
+    #[options(help = "Use with awake option, if excluded defaults to false")]
-    #[argh(
-        switch,
-        description = "use with awake option; if excluded defaults to false"
-    )]
     pub lightbar: bool,
-
+    #[options(meta = "", help = "Control boot animations <true/false>")]
-    #[argh(option, description = "control boot animations <true/false>")]
     pub boot: Option<bool>,
-
+    #[options(meta = "", help = "Control suspend animations <true/false>")]
-    #[argh(option, description = "control suspend animations <true/false>")]
     pub sleep: Option<bool>,
 }
 
-#[derive(FromArgs, Debug, Clone)]
+#[derive(Options, Debug)]
-#[argh(subcommand, name = "aura-power", description = "aura power")]
 pub struct LedPowerCommand2 {
-    #[argh(subcommand)]
+    #[options(help = "print help message")]
+    pub help: bool,
+    #[options(command)]
     pub command: Option<SetAuraZoneEnabled>,
 }
 
-/// Subcommands to enable/disable specific aura zones
+#[derive(Options, Debug)]
-#[derive(FromArgs, Debug, Clone)]
-#[argh(subcommand)]
 pub enum SetAuraZoneEnabled {
-    Keyboard(KeyboardPower),
+    /// Applies to both old and new models
-    Logo(LogoPower),
+    #[options(help = "")]
-    Lightbar(LightbarPower),
+    Keyboard(AuraPowerStates),
-    Lid(LidPower),
+    #[options(help = "")]
-    RearGlow(RearGlowPower),
+    Logo(AuraPowerStates),
-    Ally(AllyPower),
+    #[options(help = "")]
+    Lightbar(AuraPowerStates),
+    #[options(help = "")]
+    Lid(AuraPowerStates),
+    #[options(help = "")]
+    RearGlow(AuraPowerStates),
+    #[options(help = "")]
+    Ally(AuraPowerStates),
 }
 
-/// Keyboard brightness argument helper
+#[derive(Debug, Clone, Options)]
-#[derive(Debug, Clone)]
+pub struct AuraPowerStates {
+    #[options(help = "print help message")]
+    pub help: bool,
+    #[options(help = "defaults to false if option unused")]
+    pub boot: bool,
+    #[options(help = "defaults to false if option unused")]
+    pub awake: bool,
+    #[options(help = "defaults to false if option unused")]
+    pub sleep: bool,
+    #[options(help = "defaults to false if option unused")]
+    pub shutdown: bool,
+}
+
+#[derive(Options)]
 pub struct LedBrightness {
     level: Option<u8>,
 }
-
 impl LedBrightness {
     pub fn new(level: Option<u8>) -> Self {
         LedBrightness { level }
@@ -71,302 +72,176 @@ impl LedBrightness {
         self.level
     }
 }
-
 impl FromStr for LedBrightness {
     type Err = Error;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         let s = s.to_lowercase();
         match s.as_str() {
-            "off" => Ok(Self::new(Some(0x00))),
+            "off" => Ok(LedBrightness { level: Some(0x00) }),
-            "low" => Ok(Self::new(Some(0x01))),
+            "low" => Ok(LedBrightness { level: Some(0x01) }),
-            "med" => Ok(Self::new(Some(0x02))),
+            "med" => Ok(LedBrightness { level: Some(0x02) }),
-            "high" => Ok(Self::new(Some(0x03))),
+            "high" => Ok(LedBrightness { level: Some(0x03) }),
-            _ => Err(Error::ParseBrightness),
+            _ => {
+                print!("Invalid argument, must be one of: off, low, med, high");
+                Err(Error::ParseBrightness)
+            }
         }
     }
 }
-
+#[allow(clippy::to_string_trait_impl)]
-impl fmt::Display for LedBrightness {
+impl ToString for LedBrightness {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+    fn to_string(&self) -> String {
         let s = match self.level {
-            Some(0x00) => "off",
+            Some(0x00) => "low",
-            Some(0x01) => "low",
+            Some(0x01) => "med",
-            Some(0x02) => "med",
+            Some(0x02) => "high",
-            Some(0x03) => "high",
             _ => "unknown",
         };
-        write!(f, "{}", s)
+        s.to_owned()
     }
 }
 
-#[derive(FromArgs, Debug, Clone, Default)]
+#[derive(Debug, Clone, Options, Default)]
-#[argh(
-    subcommand,
-    name = "keyboard",
-    description = "set power states for keyboard zone"
-)]
-pub struct KeyboardPower {
-    #[argh(switch, description = "defaults to false if option unused")]
-    pub boot: bool,
-    #[argh(switch, description = "defaults to false if option unused")]
-    pub awake: bool,
-    #[argh(switch, description = "defaults to false if option unused")]
-    pub sleep: bool,
-    #[argh(switch, description = "defaults to false if option unused")]
-    pub shutdown: bool,
-}
-
-#[derive(FromArgs, Debug, Clone, Default)]
-#[argh(
-    subcommand,
-    name = "logo",
-    description = "set power states for logo zone"
-)]
-pub struct LogoPower {
-    #[argh(switch, description = "defaults to false if option unused")]
-    pub boot: bool,
-    #[argh(switch, description = "defaults to false if option unused")]
-    pub awake: bool,
-    #[argh(switch, description = "defaults to false if option unused")]
-    pub sleep: bool,
-    #[argh(switch, description = "defaults to false if option unused")]
-    pub shutdown: bool,
-}
-
-#[derive(FromArgs, Debug, Clone, Default)]
-#[argh(
-    subcommand,
-    name = "lightbar",
-    description = "set power states for lightbar zone"
-)]
-pub struct LightbarPower {
-    #[argh(switch, description = "enable power while device is booting")]
-    pub boot: bool,
-    #[argh(switch, description = "enable power while device is awake")]
-    pub awake: bool,
-    #[argh(switch, description = "enable power while device is sleeping")]
-    pub sleep: bool,
-    #[argh(
-        switch,
-        description = "enable power while device is shutting down or hibernating"
-    )]
-    pub shutdown: bool,
-}
-
-#[derive(FromArgs, Debug, Clone, Default)]
-#[argh(
-    subcommand,
-    name = "lid",
-    description = "set power states for lid zone"
-)]
-pub struct LidPower {
-    #[argh(switch, description = "defaults to false if option unused")]
-    pub boot: bool,
-    #[argh(switch, description = "defaults to false if option unused")]
-    pub awake: bool,
-    #[argh(switch, description = "defaults to false if option unused")]
-    pub sleep: bool,
-    #[argh(switch, description = "defaults to false if option unused")]
-    pub shutdown: bool,
-}
-
-#[derive(FromArgs, Debug, Clone, Default)]
-#[argh(
-    subcommand,
-    name = "rear-glow",
-    description = "set power states for rear glow zone"
-)]
-pub struct RearGlowPower {
-    #[argh(switch, description = "defaults to false if option unused")]
-    pub boot: bool,
-    #[argh(switch, description = "defaults to false if option unused")]
-    pub awake: bool,
-    #[argh(switch, description = "defaults to false if option unused")]
-    pub sleep: bool,
-    #[argh(switch, description = "defaults to false if option unused")]
-    pub shutdown: bool,
-}
-
-#[derive(FromArgs, Debug, Clone, Default)]
-#[argh(
-    subcommand,
-    name = "ally",
-    description = "set power states for ally zone"
-)]
-pub struct AllyPower {
-    #[argh(switch, description = "defaults to false if option unused")]
-    pub boot: bool,
-    #[argh(switch, description = "defaults to false if option unused")]
-    pub awake: bool,
-    #[argh(switch, description = "defaults to false if option unused")]
-    pub sleep: bool,
-    #[argh(switch, description = "defaults to false if option unused")]
-    pub shutdown: bool,
-}
-
-/// Single speed-based effect
-#[derive(FromArgs, Debug, Clone, Default)]
-#[argh(
-    subcommand,
-    name = "rainbow-cycle",
-    description = "single speed-based effect"
-)]
 pub struct SingleSpeed {
-    #[argh(option, description = "set the speed: low, med, high")]
+    #[options(help = "print help message")]
+    help: bool,
+    #[options(no_long, meta = "WORD", help = "set the speed: low, med, high")]
     pub speed: Speed,
-
+    #[options(
-    #[argh(
+        no_long,
-        option,
+        meta = "",
-        default = "AuraZone::None",
+        help = "set the zone for this effect e.g, 0, 1, one, logo, lightbar-left"
-        description = "set the zone for this effect e.g. 0, 1, one, logo, lightbar-left"
     )]
     pub zone: AuraZone,
 }
 
-/// Single speed effect with direction
+#[derive(Debug, Clone, Options, Default)]
-#[derive(FromArgs, Debug, Clone, Default)]
-#[argh(
-    subcommand,
-    name = "rainbow-wave",
-    description = "single speed effect with direction"
-)]
 pub struct SingleSpeedDirection {
-    #[argh(option, description = "set the direction: up, down, left, right")]
+    #[options(help = "print help message")]
+    help: bool,
+    #[options(no_long, meta = "", help = "set the direction: up, down, left, right")]
     pub direction: Direction,
-
+    #[options(no_long, meta = "", help = "set the speed: low, med, high")]
-    #[argh(option, description = "set the speed: low, med, high")]
     pub speed: Speed,
-
+    #[options(
-    #[argh(
+        no_long,
-        option,
+        meta = "",
-        default = "AuraZone::None",
+        help = "set the zone for this effect e.g, 0, 1, one, logo, lightbar-left"
-        description = "set the zone for this effect e.g. 0, 1, one, logo, lightbar-left"
     )]
     pub zone: AuraZone,
 }
 
-/// Static single-colour effect
+#[derive(Debug, Clone, Default, Options)]
-#[derive(FromArgs, Debug, Clone, Default)]
-#[argh(
-    subcommand,
-    name = "static",
-    description = "static single-colour effect"
-)]
 pub struct SingleColour {
-    #[argh(option, short = 'c', description = "set the RGB value e.g. ff00ff")]
+    #[options(help = "print help message")]
+    help: bool,
+    #[options(no_long, meta = "", help = "set the RGB value e.g, ff00ff")]
     pub colour: Colour,
-
+    #[options(
-    #[argh(
+        no_long,
-        option,
+        meta = "",
-        default = "AuraZone::None",
+        help = "set the zone for this effect e.g, 0, 1, one, logo, lightbar-left"
-        description = "set the zone for this effect e.g. 0, 1, one, logo, lightbar-left"
     )]
     pub zone: AuraZone,
 }
 
-/// Single-colour effect with speed
+#[derive(Debug, Clone, Default, Options)]
-#[derive(FromArgs, Debug, Clone, Default)]
-#[argh(
-    subcommand,
-    name = "highlight",
-    description = "single-colour effect with speed"
-)]
 pub struct SingleColourSpeed {
-    #[argh(option, short = 'c', description = "set the RGB value e.g. ff00ff")]
+    #[options(help = "print help message")]
+    help: bool,
+    #[options(no_long, meta = "", help = "set the RGB value e.g, ff00ff")]
     pub colour: Colour,
-
+    #[options(no_long, meta = "", help = "set the speed: low, med, high")]
-    #[argh(option, description = "set the speed: low, med, high")]
     pub speed: Speed,
-
+    #[options(
-    #[argh(
+        no_long,
-        option,
+        meta = "",
-        default = "AuraZone::None",
+        help = "set the zone for this effect e.g, 0, 1, one, logo, lightbar-left"
-        description = "set the zone for this effect e.g. 0, 1, one, logo, lightbar-left"
     )]
     pub zone: AuraZone,
 }
 
-/// Two-colour breathing effect
+#[derive(Debug, Clone, Options, Default)]
-#[derive(FromArgs, Debug, Clone, Default)]
-#[argh(
-    subcommand,
-    name = "breathe",
-    description = "two-colour breathing effect"
-)]
 pub struct TwoColourSpeed {
-    #[argh(option, description = "set the first RGB value e.g. ff00ff")]
+    #[options(help = "print help message")]
+    help: bool,
+    #[options(no_long, meta = "", help = "set the first RGB value e.g, ff00ff")]
     pub colour: Colour,
-
+    #[options(no_long, meta = "", help = "set the second RGB value e.g, ff00ff")]
-    #[argh(option, description = "set the second RGB value e.g. ff00ff")]
     pub colour2: Colour,
-
+    #[options(no_long, meta = "", help = "set the speed: low, med, high")]
-    #[argh(option, description = "set the speed: low, med, high")]
     pub speed: Speed,
-
+    #[options(
-    #[argh(
+        no_long,
-        option,
+        meta = "",
-        default = "AuraZone::None",
+        help = "set the zone for this effect e.g, 0, 1, one, logo, lightbar-left"
-        description = "set the zone for this effect e.g. 0, 1, one, logo, lightbar-left"
     )]
     pub zone: AuraZone,
 }
 
-/// Multi-zone colour settings
+#[derive(Debug, Clone, Default, Options)]
-#[derive(FromArgs, Debug, Clone, Default)]
 #[allow(dead_code)]
-#[argh(description = "multi-zone colour settings")]
 pub struct MultiZone {
-    #[argh(option, short = 'a', description = "set the RGB value e.g. ff00ff")]
+    #[options(help = "print help message")]
+    help: bool,
+    #[options(short = "a", meta = "", help = "set the RGB value e.g, ff00ff")]
     pub colour1: Colour,
-
+    #[options(short = "b", meta = "", help = "set the RGB value e.g, ff00ff")]
-    #[argh(option, short = 'b', description = "set the RGB value e.g. ff00ff")]
     pub colour2: Colour,
-
+    #[options(short = "c", meta = "", help = "set the RGB value e.g, ff00ff")]
-    #[argh(option, short = 'c', description = "set the RGB value e.g. ff00ff")]
     pub colour3: Colour,
-
+    #[options(short = "d", meta = "", help = "set the RGB value e.g, ff00ff")]
-    #[argh(option, short = 'd', description = "set the RGB value e.g. ff00ff")]
     pub colour4: Colour,
 }
 
-/// Multi-colour with speed
+#[derive(Debug, Clone, Default, Options)]
-#[derive(FromArgs, Debug, Clone, Default)]
 #[allow(dead_code)]
-#[argh(description = "multi-colour with speed")]
 pub struct MultiColourSpeed {
-    #[argh(option, short = 'a', description = "set the RGB value e.g. ff00ff")]
+    #[options(help = "print help message")]
+    help: bool,
+    #[options(short = "a", meta = "", help = "set the RGB value e.g, ff00ff")]
     pub colour1: Colour,
-
+    #[options(short = "b", meta = "", help = "set the RGB value e.g, ff00ff")]
-    #[argh(option, short = 'b', description = "set the RGB value e.g. ff00ff")]
     pub colour2: Colour,
-
+    #[options(short = "c", meta = "", help = "set the RGB value e.g, ff00ff")]
-    #[argh(option, short = 'c', description = "set the RGB value e.g. ff00ff")]
     pub colour3: Colour,
-
+    #[options(short = "d", meta = "", help = "set the RGB value e.g, ff00ff")]
-    #[argh(option, short = 'd', description = "set the RGB value e.g. ff00ff")]
     pub colour4: Colour,
-
+    #[options(no_long, meta = "", help = "set the speed: low, med, high")]
-    #[argh(option, description = "set the speed: low, med, high")]
     pub speed: Speed,
 }
 
-/// Builtin aura effects
+/// Byte value for setting the built-in mode.
-#[derive(FromArgs, Debug)]
+///
-#[argh(subcommand)]
+/// Enum corresponds to the required integer value
+// NOTE: The option names here must match those in rog-aura crate
+#[derive(Options)]
 pub enum SetAuraBuiltin {
-    Static(SingleColour),              // 0
+    #[options(help = "set a single static colour")]
-    Breathe(TwoColourSpeed),           // 1
+    Static(SingleColour), // 0
-    RainbowCycle(SingleSpeed),         // 2
+    #[options(help = "pulse between one or two colours")]
+    Breathe(TwoColourSpeed), // 1
+    #[options(help = "strobe through all colours")]
+    RainbowCycle(SingleSpeed), // 2
+    #[options(help = "rainbow cycling in one of four directions")]
     RainbowWave(SingleSpeedDirection), // 3
-    Stars(TwoColourSpeed),             // 4
+    #[options(help = "rain pattern mimicking raindrops")]
-    Rain(SingleSpeed),                 // 5
+    Stars(TwoColourSpeed), // 4
-    Highlight(SingleColourSpeed),      // 6
+    #[options(help = "rain pattern of three preset colours")]
-    Laser(SingleColourSpeed),          // 7
+    Rain(SingleSpeed), // 5
-    Ripple(SingleColourSpeed),         // 8
+    #[options(help = "pressed keys are highlighted to fade")]
-    Pulse(SingleColour),               // 10
+    Highlight(SingleColourSpeed), // 6
-    Comet(SingleColour),               // 11
+    #[options(help = "pressed keys generate horizontal laser")]
-    Flash(SingleColour),               // 12
+    Laser(SingleColourSpeed), // 7
+    #[options(help = "pressed keys ripple outwards like a splash")]
+    Ripple(SingleColourSpeed), // 8
+    #[options(help = "set a rapid pulse")]
+    Pulse(SingleColour), // 10
+    #[options(help = "set a vertical line zooming from left")]
+    Comet(SingleColour), // 11
+    #[options(help = "set a wide vertical line zooming from left")]
+    Flash(SingleColour), // 12
 }
 
 impl Default for SetAuraBuiltin {

asusctl/src/cli_opts.rs

@@ -1,4 +1,4 @@
-use argh::FromArgs;
+use gumdrop::Options;
 use rog_platform::platform::PlatformProfile;
 
 use crate::anime_cli::AnimeCommand;
@@ -7,308 +7,128 @@ use crate::fan_curve_cli::FanCurveCommand;
 use crate::scsi_cli::ScsiCommand;
 use crate::slash_cli::SlashCommand;
 
-#[derive(FromArgs, Default, Debug)]
+#[derive(Default, Options)]
-/// asusctl command-line options
 pub struct CliStart {
-    #[argh(subcommand)]
+    #[options(help_flag, help = "print help message")]
-    pub command: CliCommand,
+    pub help: bool,
+    #[options(help = "show program version number")]
+    pub version: bool,
+    #[options(help = "show supported functions of this laptop")]
+    pub show_supported: bool,
+    #[options(meta = "", help = "<off, low, med, high>")]
+    pub kbd_bright: Option<LedBrightness>,
+    #[options(help = "Toggle to next keyboard brightness")]
+    pub next_kbd_bright: bool,
+    #[options(help = "Toggle to previous keyboard brightness")]
+    pub prev_kbd_bright: bool,
+    #[options(meta = "", help = "Set your battery charge limit <20-100>")]
+    pub chg_limit: Option<u8>,
+    #[options(help = "Toggle one-shot battery charge to 100%")]
+    pub one_shot_chg: bool,
+    #[options(command)]
+    pub command: Option<CliCommand>,
 }
 
-/// Top-level subcommands for asusctl
+#[derive(Options)]
-#[derive(FromArgs, Debug)]
-#[argh(subcommand)]
 pub enum CliCommand {
+    #[options(help = "Set the keyboard lighting from built-in modes")]
     Aura(LedModeCommand),
+    #[options(help = "Set the LED power states")]
     AuraPowerOld(LedPowerCommand1),
+    #[options(help = "Set the LED power states")]
     AuraPower(LedPowerCommand2),
-    Brightness(BrightnessCommand),
+    #[options(help = "Set or select platform_profile")]
     Profile(ProfileCommand),
+    #[options(help = "Set, select, or modify fan curves if supported")]
     FanCurve(FanCurveCommand),
+    #[options(help = "Set the graphics mode (obsoleted by supergfxctl)")]
+    Graphics(GraphicsCommand),
+    #[options(name = "anime", help = "Manage AniMe Matrix")]
     Anime(AnimeCommand),
+    #[options(name = "slash", help = "Manage Slash Ledbar")]
     Slash(SlashCommand),
+    #[options(name = "scsi", help = "Manage SCSI external drive")]
     Scsi(ScsiCommand),
+    #[options(
+        help = "Change platform settings. This is a new interface exposed by the asus-armoury \
+                driver, some of the settings will be the same as the older platform interface"
+    )]
     Armoury(ArmouryCommand),
+    #[options(name = "backlight", help = "Set screen backlight levels")]
     Backlight(BacklightCommand),
-    Battery(BatteryCommand),
-    Info(InfoCommand),
 }
 
-impl Default for CliCommand {
+#[derive(Debug, Clone, Options)]
-    fn default() -> Self {
-        CliCommand::Info(InfoCommand::default())
-    }
-}
-
-#[derive(FromArgs, Debug)]
-#[argh(subcommand, name = "profile", description = "profile management")]
 pub struct ProfileCommand {
-    #[argh(subcommand)]
+    #[options(help = "print help message")]
-    pub command: ProfileSubCommand,
+    pub help: bool,
-}
 
-#[derive(FromArgs, Debug)]
+    #[options(help = "toggle to next profile in list")]
-#[argh(subcommand)]
+    pub next: bool,
-pub enum ProfileSubCommand {
-    Next(ProfileNextCommand),
-    List(ProfileListCommand),
-    Get(ProfileGetCommand),
-    Set(ProfileSetCommand),
-}
 
-impl Default for ProfileSubCommand {
+    #[options(help = "list available profiles")]
-    fn default() -> Self {
+    pub list: bool,
-        ProfileSubCommand::List(ProfileListCommand::default())
-    }
-}
 
-#[derive(FromArgs, Debug, Default)]
+    #[options(help = "get profile")]
-#[argh(
+    pub profile_get: bool,
-    subcommand,
-    name = "next",
-    description = "toggle to next profile in list"
-)]
-pub struct ProfileNextCommand {}
 
-#[derive(FromArgs, Debug, Default)]
+    #[options(meta = "", help = "set the active profile")]
-#[argh(subcommand, name = "list", description = "list available profiles")]
+    pub profile_set: Option<PlatformProfile>,
-pub struct ProfileListCommand {}
 
-#[derive(FromArgs, Debug, Default)]
+    #[options(short = "a", meta = "", help = "set the profile to use on AC power")]
-#[argh(subcommand, name = "get", description = "get profile")]
+    pub profile_set_ac: Option<PlatformProfile>,
-pub struct ProfileGetCommand {}
 
-#[derive(FromArgs, Debug, Default)]
+    #[options(
-#[argh(subcommand, name = "set", description = "set profile")]
+        short = "b",
-pub struct ProfileSetCommand {
+        meta = "",
-    #[argh(positional, description = "profile to set")]
+        help = "set the profile to use on battery power"
-    pub profile: PlatformProfile,
-
-    #[argh(
-        switch,
-        short = 'a',
-        description = "set the profile to use on AC power"
     )]
-    pub ac: bool,
+    pub profile_set_bat: Option<PlatformProfile>,
-
-    #[argh(
-        switch,
-        short = 'b',
-        description = "set the profile to use on battery power"
-    )]
-    pub battery: bool,
 }
 
-#[derive(FromArgs, Debug, Default)]
+#[derive(Options)]
-#[argh(subcommand, name = "aura", description = "led mode commands")]
 pub struct LedModeCommand {
-    #[argh(switch, description = "switch to next aura mode")]
+    #[options(help = "print help message")]
+    pub help: bool,
+    #[options(help = "switch to next aura mode")]
     pub next_mode: bool,
-
+    #[options(help = "switch to previous aura mode")]
-    #[argh(switch, description = "switch to previous aura mode")]
     pub prev_mode: bool,
-
+    #[options(command)]
-    #[argh(subcommand)]
     pub command: Option<SetAuraBuiltin>,
 }
 
-#[derive(FromArgs, Debug, Default)]
+#[derive(Options)]
-#[argh(
+pub struct GraphicsCommand {
-    subcommand,
+    #[options(help = "print help message")]
-    name = "armoury",
+    pub help: bool,
-    description = "armoury / firmware attributes"
+}
-)]
+
+#[derive(Options, Debug)]
 pub struct ArmouryCommand {
-    #[argh(subcommand)]
+    #[options(help = "print help message")]
-    pub command: ArmourySubCommand,
+    pub help: bool,
-}
+    #[options(
-
+        free,
-#[derive(FromArgs, Debug)]
+        help = "append each value name followed by the value to set. `-1` sets to default"
-#[argh(subcommand)]
-pub enum ArmourySubCommand {
-    Set(ArmouryPropertySetCommand),
-    Get(ArmouryPropertyGetCommand),
-    List(ArmouryPropertyListCommand),
-}
-
-impl Default for ArmourySubCommand {
-    fn default() -> Self {
-        ArmourySubCommand::List(ArmouryPropertyListCommand::default())
-    }
-}
-
-#[derive(FromArgs, Debug, Default)]
-#[argh(
-    subcommand,
-    name = "set",
-    description = "set an asus-armoury firmware-attribute"
-)]
-pub struct ArmouryPropertySetCommand {
-    #[argh(
-        positional,
-        description = "name of the attribute to set (see asus-armoury list for available properties)"
     )]
-    pub property: String,
+    pub free: Vec<String>,
-
-    #[argh(positional, description = "value to set for the given attribute")]
-    pub value: i32,
 }
 
-#[derive(FromArgs, Debug, Default)]
+#[derive(Options)]
-#[argh(
-    subcommand,
-    name = "list",
-    description = "list all firmware-attributes supported by asus-armoury"
-)]
-pub struct ArmouryPropertyListCommand {}
-
-#[derive(FromArgs, Debug, Default)]
-#[argh(
-    subcommand,
-    name = "get",
-    description = "get a firmware-attribute from asus-armoury"
-)]
-pub struct ArmouryPropertyGetCommand {
-    #[argh(
-        positional,
-        description = "name of the property to get (see asus-armoury list for available properties)"
-    )]
-    pub property: String,
-}
-
-#[derive(FromArgs, Debug, Default)]
-#[argh(subcommand, name = "backlight", description = "backlight options")]
 pub struct BacklightCommand {
-    #[argh(option, description = "set screen brightness <0-100>")]
+    #[options(help = "print help message")]
+    pub help: bool,
+    #[options(meta = "", help = "Set screen brightness <0-100>")]
     pub screenpad_brightness: Option<i32>,
-
+    #[options(
-    #[argh(
+        meta = "",
-        option,
+        help = "Set screenpad gamma brightness 0.5 - 2.2, 1.0 == linear"
-        description = "set screenpad gamma brightness 0.5 - 2.2, 1.0 == linear"
     )]
     pub screenpad_gamma: Option<f32>,
-
+    #[options(
-    #[argh(
+        meta = "",
-        option,
+        help = "Set screenpad brightness to sync with primary display"
-        description = "set screenpad brightness to sync with primary display"
     )]
     pub sync_screenpad_brightness: Option<bool>,
 }
-
-#[derive(FromArgs, Debug)]
-#[argh(subcommand, name = "battery", description = "battery options")]
-pub struct BatteryCommand {
-    #[argh(subcommand)]
-    pub command: BatterySubCommand,
-}
-
-#[derive(FromArgs, Debug)]
-#[argh(subcommand)]
-pub enum BatterySubCommand {
-    Limit(BatteryLimitCommand),
-    OneShot(BatteryOneShotCommand),
-    Info(BatteryInfoCommand),
-}
-
-impl Default for BatterySubCommand {
-    fn default() -> Self {
-        BatterySubCommand::OneShot(BatteryOneShotCommand::default())
-    }
-}
-
-#[derive(FromArgs, Debug)]
-#[argh(
-    subcommand,
-    name = "limit",
-    description = "set battery charge limit <20-100>"
-)]
-pub struct BatteryLimitCommand {
-    #[argh(positional, description = "charge limit percentage 20-100")]
-    pub limit: u8,
-}
-
-#[derive(FromArgs, Debug, Default)]
-#[argh(
-    subcommand,
-    name = "oneshot",
-    description = "one-shot full charge (optional percent)"
-)]
-pub struct BatteryOneShotCommand {
-    #[argh(positional, description = "optional target percent (defaults to 100)")]
-    pub percent: Option<u8>,
-}
-
-#[derive(FromArgs, Debug, Default)]
-#[argh(
-    subcommand,
-    name = "info",
-    description = "show current battery charge limit"
-)]
-pub struct BatteryInfoCommand {}
-
-#[derive(FromArgs, Debug, Default)]
-#[argh(
-    subcommand,
-    name = "info",
-    description = "show program version and system info"
-)]
-pub struct InfoCommand {
-    #[argh(switch, description = "show supported functions of this laptop")]
-    pub show_supported: bool,
-}
-
-#[derive(FromArgs, Debug)]
-#[argh(subcommand, name = "leds", description = "keyboard brightness control")]
-pub struct BrightnessCommand {
-    #[argh(subcommand)]
-    pub command: BrightnessSubCommand,
-}
-
-#[derive(FromArgs, Debug)]
-#[argh(subcommand)]
-pub enum BrightnessSubCommand {
-    Set(BrightnessSetCommand),
-    Get(BrightnessGetCommand),
-    Next(BrightnessNextCommand),
-    Prev(BrightnessPrevCommand),
-}
-
-impl Default for BrightnessSubCommand {
-    fn default() -> Self {
-        BrightnessSubCommand::Get(BrightnessGetCommand::default())
-    }
-}
-
-#[derive(FromArgs, Debug)]
-#[argh(
-    subcommand,
-    name = "set",
-    description = "set keyboard brightness <off, low, med, high>"
-)]
-pub struct BrightnessSetCommand {
-    #[argh(positional, description = "brightness level: off, low, med, high")]
-    pub level: LedBrightness,
-}
-
-#[derive(FromArgs, Debug, Default)]
-#[argh(
-    subcommand,
-    name = "get",
-    description = "get current keyboard brightness"
-)]
-pub struct BrightnessGetCommand {}
-
-#[derive(FromArgs, Debug, Default)]
-#[argh(
-    subcommand,
-    name = "next",
-    description = "toggle to next keyboard brightness"
-)]
-pub struct BrightnessNextCommand {}
-
-#[derive(FromArgs, Debug, Default)]
-#[argh(
-    subcommand,
-    name = "prev",
-    description = "toggle to previous keyboard brightness"
-)]
-pub struct BrightnessPrevCommand {}

asusctl/src/fan_curve_cli.rs

@@ -1,44 +1,49 @@
-use argh::FromArgs;
+use gumdrop::Options;
 use rog_platform::platform::PlatformProfile;
 use rog_profiles::fan_curve_set::CurveData;
 use rog_profiles::FanCurvePU;
 
-#[derive(FromArgs, Debug, Clone)]
+#[derive(Debug, Clone, Options)]
-#[argh(subcommand, name = "fan-curve", description = "fan curve commands")]
 pub struct FanCurveCommand {
-    #[argh(switch, description = "get enabled fan profiles")]
+    #[options(help = "print help message")]
+    pub help: bool,
+
+    #[options(help = "get enabled fan profiles")]
     pub get_enabled: bool,
 
-    #[argh(switch, description = "set the active profile's fan curve to default")]
+    #[options(help = "set the active profile's fan curve to default")]
     pub default: bool,
 
-    #[argh(
+    #[options(
-        option,
+        meta = "",
-        description = "profile to modify fan-curve for. shows data if no options provided"
+        help = "profile to modify fan-curve for. Shows data if no options provided"
     )]
     pub mod_profile: Option<PlatformProfile>,
 
-    #[argh(
+    #[options(
-        option,
+        meta = "",
-        description = "enable or disable <true/false> fan all curves for a profile; --mod_profile required"
+        help = "enable or disable <true/false> fan all curves for a profile. `--mod_profile` \
+                required"
     )]
     pub enable_fan_curves: Option<bool>,
 
-    #[argh(
+    #[options(
-        option,
+        meta = "",
-        description = "enable or disable <true/false> a single fan curve for a profile; --mod_profile and --fan required"
+        help = "enable or disable <true/false> a single fan curve for a profile. `--mod_profile` \
+                and `--fan` required"
     )]
     pub enable_fan_curve: Option<bool>,
 
-    #[argh(
+    #[options(
-        option,
+        meta = "",
-        description = "select fan <cpu/gpu/mid> to modify; --mod_profile required"
+        help = "select fan <cpu/gpu/mid> to modify. `--mod_profile` required"
     )]
     pub fan: Option<FanCurvePU>,
 
-    #[argh(
+    #[options(
-        option,
+        meta = "",
-        description = "data format = 30c:1%,49c:2%,...; --mod-profile required. If '%' is omitted the fan range is 0-255"
+        help = "data format = 30c:1%,49c:2%,59c:3%,69c:4%,79c:31%,89c:49%,99c:56%,109c:58%. \
+                `--mod-profile` required. If '%' is omitted the fan range is 0-255"
     )]
     pub data: Option<CurveData>,
 }

asusctl/src/main.rs

@@ -1,4 +1,5 @@
 use std::convert::TryFrom;
+use std::env::args;
 use std::path::Path;
 use std::process::Command;
 use std::thread::sleep;
@@ -7,11 +8,12 @@ use anime_cli::{AnimeActions, AnimeCommand};
 use aura_cli::{LedPowerCommand1, LedPowerCommand2};
 use dmi_id::DMIID;
 use fan_curve_cli::FanCurveCommand;
+use gumdrop::{Opt, Options};
 use log::{error, info, LevelFilter};
 use rog_anime::usb::get_anime_type;
 use rog_anime::{AnimTime, AnimeDataBuffer, AnimeDiagonal, AnimeGif, AnimeImage, AnimeType, Vec2};
 use rog_aura::keyboard::{AuraPowerState, LaptopAuraPower};
-use rog_aura::{self, AuraEffect, PowerZones};
+use rog_aura::{self, AuraDeviceType, AuraEffect, PowerZones};
 use rog_dbus::asus_armoury::AsusArmouryProxyBlocking;
 use rog_dbus::list_iface_blocking;
 use rog_dbus::scsi_aura::ScsiAuraProxyBlocking;
@@ -30,6 +32,7 @@ use scsi_cli::ScsiCommand;
 use zbus::blocking::proxy::ProxyImpl;
 use zbus::blocking::Connection;
 
+use crate::aura_cli::{AuraPowerStates, LedBrightness};
 use crate::cli_opts::*;
 use crate::slash_cli::SlashCommand;
 
@@ -53,7 +56,22 @@ fn main() {
         .format_timestamp(None)
         .init();
 
-    let parsed: CliStart = argh::from_env();
+    let self_version = env!("CARGO_PKG_VERSION");
+    println!("Starting version {self_version}");
+    let args: Vec<String> = args().skip(1).collect();
+
+    let missing_argument_k = gumdrop::Error::missing_argument(Opt::Short('k'));
+    let parsed = match CliStart::parse_args_default(&args) {
+        Ok(p) => p,
+        Err(err) if err.to_string() == missing_argument_k.to_string() => CliStart {
+            kbd_bright: Some(LedBrightness::new(None)),
+            ..Default::default()
+        },
+        Err(err) => {
+            println!("Error: {}", err);
+            return;
+        }
+    };
 
     let conn = Connection::system().unwrap();
     if let Ok(platform_proxy) = PlatformProxyBlocking::new(&conn).map_err(|e| {
@@ -72,7 +90,6 @@ fn main() {
             }
         };
 
-        let self_version = env!("CARGO_PKG_VERSION");
         if asusd_version != self_version {
             println!("Version mismatch: asusctl = {self_version}, asusd = {asusd_version}");
             return;
@@ -93,6 +110,12 @@ fn main() {
             }
         };
 
+        if parsed.version {
+            println!("asusctl v{}", env!("CARGO_PKG_VERSION"));
+            println!();
+            print_info();
+        }
+
         if let Err(err) = do_parsed(&parsed, &supported_interfaces, &supported_properties, conn) {
             print_error_help(&*err, &supported_interfaces, &supported_properties);
         }
@@ -119,9 +142,9 @@ fn print_info() {
     let dmi = DMIID::new().unwrap_or_default();
     let board_name = dmi.board_name;
     let prod_family = dmi.product_family;
-    println!("Software version: {}", env!("CARGO_PKG_VERSION"));
+    println!("asusctl version: {}", env!("CARGO_PKG_VERSION"));
-    println!("  Product family: {}", prod_family.trim());
+    println!(" Product family: {}", prod_family.trim());
-    println!("      Board name: {}", board_name.trim());
+    println!("     Board name: {}", board_name.trim());
 }
 
 fn check_service(name: &str) -> bool {
@@ -186,63 +209,149 @@ fn do_parsed(
     conn: Connection,
 ) -> Result<(), Box<dyn std::error::Error>> {
     match &parsed.command {
-        CliCommand::Aura(mode) => handle_led_mode(mode)?,
+        Some(CliCommand::Aura(mode)) => handle_led_mode(mode)?,
-        CliCommand::AuraPowerOld(pow) => handle_led_power1(pow)?,
+        Some(CliCommand::AuraPowerOld(pow)) => handle_led_power1(pow)?,
-        CliCommand::AuraPower(pow) => handle_led_power2(pow)?,
+        Some(CliCommand::AuraPower(pow)) => handle_led_power2(pow)?,
-        CliCommand::Brightness(cmd) => handle_brightness(cmd)?,
+        Some(CliCommand::Profile(cmd)) => {
-        CliCommand::Profile(cmd) => handle_throttle_profile(&conn, supported_properties, cmd)?,
+            handle_throttle_profile(&conn, supported_properties, cmd)?
-        CliCommand::FanCurve(cmd) => handle_fan_curve(&conn, cmd)?,
-        CliCommand::Anime(cmd) => handle_anime(cmd)?,
-        CliCommand::Slash(cmd) => handle_slash(cmd)?,
-        CliCommand::Scsi(cmd) => handle_scsi(cmd)?,
-        CliCommand::Armoury(cmd) => handle_armoury_command(cmd)?,
-        CliCommand::Backlight(cmd) => handle_backlight(cmd)?,
-        CliCommand::Battery(cmd) => handle_battery(cmd, &conn)?,
-        CliCommand::Info(info_opt) => {
-            handle_info(info_opt, supported_interfaces, supported_properties)?
         }
-    }
+        Some(CliCommand::FanCurve(cmd)) => {
-
+            handle_fan_curve(&conn, cmd)?;
-    Ok(())
-}
-
-fn handle_battery(
-    cmd: &BatteryCommand,
-    conn: &Connection,
-) -> Result<(), Box<dyn std::error::Error>> {
-    match &cmd.command {
-        BatterySubCommand::Limit(l) => {
-            let proxy = PlatformProxyBlocking::new(conn)?;
-            proxy.set_charge_control_end_threshold(l.limit)?;
         }
-        BatterySubCommand::OneShot(o) => {
+        Some(CliCommand::Graphics(_)) => do_gfx(),
-            let proxy = PlatformProxyBlocking::new(conn)?;
+        Some(CliCommand::Anime(cmd)) => handle_anime(cmd)?,
-            if let Some(p) = o.percent {
+        Some(CliCommand::Slash(cmd)) => handle_slash(cmd)?,
-                proxy.set_charge_control_end_threshold(p)?;
+        Some(CliCommand::Scsi(cmd)) => handle_scsi(cmd)?,
+        Some(CliCommand::Armoury(cmd)) => handle_armoury_command(cmd)?,
+        Some(CliCommand::Backlight(cmd)) => handle_backlight(cmd)?,
+        None => {
+            if (!parsed.show_supported
+                && parsed.kbd_bright.is_none()
+                && parsed.chg_limit.is_none()
+                && !parsed.next_kbd_bright
+                && !parsed.prev_kbd_bright
+                && !parsed.one_shot_chg)
+                || parsed.help
+            {
+                println!("{}", CliStart::usage());
+                println!();
+                if let Some(cmdlist) = CliStart::command_list() {
+                    let dev_type =
+                        if let Ok(proxy) = find_iface::<AuraProxyBlocking>("xyz.ljones.Aura") {
+                            // TODO: commands on all?
+                            proxy
+                                .first()
+                                .unwrap()
+                                .device_type()
+                                .unwrap_or(AuraDeviceType::Unknown)
+                        } else {
+                            AuraDeviceType::Unknown
+                        };
+                    let commands: Vec<String> = cmdlist.lines().map(|s| s.to_owned()).collect();
+                    for command in commands.iter().filter(|command| {
+                        if command.trim().starts_with("fan-curve")
+                            && !supported_interfaces.contains(&"xyz.ljones.FanCurves".to_string())
+                        {
+                            return false;
+                        }
+
+                        if command.trim().starts_with("aura")
+                            && !supported_interfaces.contains(&"xyz.ljones.Aura".to_string())
+                        {
+                            return false;
+                        }
+
+                        if command.trim().starts_with("anime")
+                            && !supported_interfaces.contains(&"xyz.ljones.Anime".to_string())
+                        {
+                            return false;
+                        }
+
+                        if command.trim().starts_with("slash")
+                            && !supported_interfaces.contains(&"xyz.ljones.Slash".to_string())
+                        {
+                            return false;
+                        }
+
+                        if command.trim().starts_with("platform")
+                            && !supported_interfaces.contains(&"xyz.ljones.Platform".to_string())
+                        {
+                            return false;
+                        }
+
+                        if command.trim().starts_with("armoury")
+                            && !supported_interfaces.contains(&"xyz.ljones.AsusArmoury".to_string())
+                        {
+                            return false;
+                        }
+
+                        if command.trim().starts_with("backlight")
+                            && !supported_interfaces.contains(&"xyz.ljones.Backlight".to_string())
+                        {
+                            return false;
+                        }
+
+                        if !dev_type.is_old_laptop()
+                            && !dev_type.is_tuf_laptop()
+                            && command.trim().starts_with("aura-power-old")
+                        {
+                            return false;
+                        }
+                        if !dev_type.is_new_laptop() && command.trim().starts_with("aura-power") {
+                            return false;
+                        }
+                        true
+                    }) {
+                        println!("{}", command);
+                    }
+                }
+
+                println!("\nExtra help can be requested on any command or subcommand:");
+                println!(" asusctl aura --help");
+                println!(" asusctl aura static --help");
             }
-            proxy.one_shot_full_charge()?;
-        }
-        BatterySubCommand::Info(_) => {
-            let proxy = PlatformProxyBlocking::new(conn)?;
-            let limit = proxy.charge_control_end_threshold()?;
-            println!("Current battery charge limit: {}%", limit);
         }
     }
 
-    Ok(())
+    if let Some(brightness) = &parsed.kbd_bright {
-}
+        if let Ok(aura) = find_iface::<AuraProxyBlocking>("xyz.ljones.Aura") {
+            for aura in aura.iter() {
+                match brightness.level() {
+                    None => {
+                        let level = aura.brightness()?;
+                        println!("Current keyboard led brightness: {level:?}");
+                    }
+                    Some(level) => aura.set_brightness(rog_aura::LedBrightness::from(level))?,
+                }
+            }
+        } else {
+            println!("No aura interface found");
+        }
+    }
 
-fn handle_info(
+    if parsed.next_kbd_bright {
-    info_opt: &InfoCommand,
+        if let Ok(aura) = find_iface::<AuraProxyBlocking>("xyz.ljones.Aura") {
-    supported_interfaces: &[String],
+            for aura in aura.iter() {
-    supported_properties: &[Properties],
+                let brightness = aura.brightness()?;
-) -> Result<(), Box<dyn std::error::Error>> {
+                aura.set_brightness(brightness.next())?;
-    println!("asusctl v{}", env!("CARGO_PKG_VERSION"));
+            }
-    println!();
+        } else {
-    print_info();
+            println!("No aura interface found");
-    println!();
+        }
+    }
 
-    if info_opt.show_supported {
+    if parsed.prev_kbd_bright {
+        if let Ok(aura) = find_iface::<AuraProxyBlocking>("xyz.ljones.Aura") {
+            for aura in aura.iter() {
+                let brightness = aura.brightness()?;
+                aura.set_brightness(brightness.prev())?;
+            }
+        } else {
+            println!("No aura interface found");
+        }
+    }
+
+    if parsed.show_supported {
         println!("Supported Core Functions:\n{:#?}", supported_interfaces);
         println!(
             "Supported Platform Properties:\n{:#?}",
@@ -263,14 +372,35 @@ fn handle_info(
         }
     }
 
+    if let Some(chg_limit) = parsed.chg_limit {
+        let proxy = PlatformProxyBlocking::new(&conn)?;
+        proxy.set_charge_control_end_threshold(chg_limit)?;
+    }
+
+    if parsed.one_shot_chg {
+        let proxy = PlatformProxyBlocking::new(&conn)?;
+        proxy.one_shot_full_charge()?;
+    }
+
     Ok(())
 }
 
+fn do_gfx() {
+    println!(
+        "Please use supergfxctl for graphics switching. supergfxctl is the result of making \
+         asusctl graphics switching generic so all laptops can use it"
+    );
+    println!("This command will be removed in future");
+}
+
 fn handle_backlight(cmd: &BacklightCommand) -> Result<(), Box<dyn std::error::Error>> {
-    if cmd.screenpad_brightness.is_none()
+    if (cmd.screenpad_brightness.is_none()
         && cmd.screenpad_gamma.is_none()
-        && cmd.sync_screenpad_brightness.is_none()
+        && cmd.sync_screenpad_brightness.is_none())
+        || cmd.help
     {
+        println!("Missing arg or command\n\n{}", cmd.self_usage());
+
         let backlights = find_iface::<BacklightProxyBlocking>("xyz.ljones.Backlight")?;
         for backlight in backlights {
             println!("Current screenpad settings:");
@@ -303,50 +433,8 @@ fn handle_backlight(cmd: &BacklightCommand) -> Result<(), Box<dyn std::error::Er
     Ok(())
 }
 
-fn handle_brightness(cmd: &BrightnessCommand) -> Result<(), Box<dyn std::error::Error>> {
-    let Ok(aura_proxies) = find_iface::<AuraProxyBlocking>("xyz.ljones.Aura") else {
-        println!("No aura interface found");
-        return Ok(());
-    };
-
-    match &cmd.command {
-        BrightnessSubCommand::Set(s) => {
-            for aura in aura_proxies.iter() {
-                if let Some(level) = s.level.level() {
-                    aura.set_brightness(rog_aura::LedBrightness::from(level))?;
-                } else {
-                    let current = aura.brightness()?;
-                    println!("Current keyboard led brightness: {current:?}");
-                }
-            }
-        }
-        BrightnessSubCommand::Get(_) => {
-            for aura in aura_proxies.iter() {
-                let level = aura.brightness()?;
-                println!("Current keyboard led brightness: {level:?}");
-            }
-
-            return Ok(());
-        }
-        BrightnessSubCommand::Next(_) => {
-            for aura in aura_proxies.iter() {
-                let brightness = aura.brightness()?;
-                aura.set_brightness(brightness.next())?;
-            }
-        }
-        BrightnessSubCommand::Prev(_) => {
-            for aura in aura_proxies.iter() {
-                let brightness = aura.brightness()?;
-                aura.set_brightness(brightness.prev())?;
-            }
-        }
-    }
-
-    Ok(())
-}
-
 fn handle_anime(cmd: &AnimeCommand) -> Result<(), Box<dyn std::error::Error>> {
-    if cmd.command.is_none()
+    if (cmd.command.is_none()
         && cmd.enable_display.is_none()
         && cmd.enable_powersave_anim.is_none()
         && cmd.brightness.is_none()
@@ -354,9 +442,13 @@ fn handle_anime(cmd: &AnimeCommand) -> Result<(), Box<dyn std::error::Error>> {
         && cmd.off_when_suspended.is_none()
         && cmd.off_when_unplugged.is_none()
         && cmd.off_with_his_head.is_none()
-        && !cmd.clear
+        && !cmd.clear)
+        || cmd.help
     {
-        println!("Missing arg or command; run 'asusctl anime --help' for usage");
+        println!("Missing arg or command\n\n{}", cmd.self_usage());
+        if let Some(lst) = cmd.self_command_list() {
+            println!("\n{}", lst);
+        }
     }
 
     let animes = find_iface::<AnimeProxyBlocking>("xyz.ljones.Anime").map_err(|e| {
@@ -403,10 +495,11 @@ fn handle_anime(cmd: &AnimeCommand) -> Result<(), Box<dyn std::error::Error>> {
         if let Some(action) = cmd.command.as_ref() {
             match action {
                 AnimeActions::Image(image) => {
-                    if image.path.is_empty() {
+                    if image.help_requested() || image.path.is_empty() {
-                        println!(
+                        println!("Missing arg or command\n\n{}", image.self_usage());
-                            "Missing arg or command; run 'asusctl anime image --help' for usage"
+                        if let Some(lst) = image.self_command_list() {
-                        );
+                            println!("\n{}", lst);
+                        }
                         return Ok(());
                     }
                     verify_brightness(image.bright);
@@ -423,8 +516,11 @@ fn handle_anime(cmd: &AnimeCommand) -> Result<(), Box<dyn std::error::Error>> {
                     proxy.write(<AnimeDataBuffer>::try_from(&matrix)?)?;
                 }
                 AnimeActions::PixelImage(image) => {
-                    if image.path.is_empty() {
+                    if image.help_requested() || image.path.is_empty() {
-                        println!("Missing arg or command; run 'asusctl anime pixel-image --help' for usage");
+                        println!("Missing arg or command\n\n{}", image.self_usage());
+                        if let Some(lst) = image.self_command_list() {
+                            println!("\n{}", lst);
+                        }
                         return Ok(());
                     }
                     verify_brightness(image.bright);
@@ -439,10 +535,11 @@ fn handle_anime(cmd: &AnimeCommand) -> Result<(), Box<dyn std::error::Error>> {
                     proxy.write(matrix.into_data_buffer(anime_type)?)?;
                 }
                 AnimeActions::Gif(gif) => {
-                    if gif.path.is_empty() {
+                    if gif.help_requested() || gif.path.is_empty() {
-                        println!(
+                        println!("Missing arg or command\n\n{}", gif.self_usage());
-                            "Missing arg or command; run 'asusctl anime gif --help' for usage"
+                        if let Some(lst) = gif.self_command_list() {
-                        );
+                            println!("\n{}", lst);
+                        }
                         return Ok(());
                     }
                     verify_brightness(gif.bright);
@@ -472,8 +569,11 @@ fn handle_anime(cmd: &AnimeCommand) -> Result<(), Box<dyn std::error::Error>> {
                     }
                 }
                 AnimeActions::PixelGif(gif) => {
-                    if gif.path.is_empty() {
+                    if gif.help_requested() || gif.path.is_empty() {
-                        println!("Missing arg or command; run 'asusctl anime pixel-gif --help' for usage");
+                        println!("Missing arg or command\n\n{}", gif.self_usage());
+                        if let Some(lst) = gif.self_command_list() {
+                            println!("\n{}", lst);
+                        }
                         return Ok(());
                     }
                     verify_brightness(gif.bright);
@@ -500,8 +600,14 @@ fn handle_anime(cmd: &AnimeCommand) -> Result<(), Box<dyn std::error::Error>> {
                     }
                 }
                 AnimeActions::SetBuiltins(builtins) => {
-                    if builtins.set.is_none() {
+                    if builtins.help_requested() || builtins.set.is_none() {
-                        println!("Missing arg; run 'asusctl anime set-builtins --help' for usage");
+                        println!(
+                            "\nAny unspecified args will be set to default (first shown var)\n"
+                        );
+                        println!("\n{}", builtins.self_usage());
+                        if let Some(lst) = builtins.self_command_list() {
+                            println!("\n{}", lst);
+                        }
                         return Ok(());
                     }
 
@@ -528,19 +634,24 @@ fn verify_brightness(brightness: f32) {
 }
 
 fn handle_slash(cmd: &SlashCommand) -> Result<(), Box<dyn std::error::Error>> {
-    if cmd.brightness.is_none()
+    if (cmd.brightness.is_none()
         && cmd.interval.is_none()
         && cmd.show_on_boot.is_none()
         && cmd.show_on_shutdown.is_none()
         && cmd.show_on_sleep.is_none()
         && cmd.show_on_battery.is_none()
         && cmd.show_battery_warning.is_none()
+        // && cmd.show_on_lid_closed.is_none()
         && cmd.mode.is_none()
         && !cmd.list
         && !cmd.enable
-        && !cmd.disable
+        && !cmd.disable)
+        || cmd.help
     {
-        println!("Missing arg or command; run 'asusctl slash --help' for usage");
+        println!("Missing arg or command\n\n{}", cmd.self_usage());
+        if let Some(lst) = cmd.self_command_list() {
+            println!("\n{}", lst);
+        }
     }
 
     let slashes = find_iface::<SlashProxyBlocking>("xyz.ljones.Slash")?;
@@ -591,8 +702,13 @@ fn handle_slash(cmd: &SlashCommand) -> Result<(), Box<dyn std::error::Error>> {
 }
 
 fn handle_scsi(cmd: &ScsiCommand) -> Result<(), Box<dyn std::error::Error>> {
-    if !cmd.list && cmd.enable.is_none() && cmd.mode.is_none() && cmd.colours.is_empty() {
+    if (!cmd.list && cmd.enable.is_none() && cmd.mode.is_none() && cmd.colours.is_empty())
-        println!("Missing arg or command; run 'asusctl scsi --help' for usage");
+        || cmd.help
+    {
+        println!("Missing arg or command\n\n{}", cmd.self_usage());
+        if let Some(lst) = cmd.self_command_list() {
+            println!("\n{}", lst);
+        }
     }
 
     let scsis = find_iface::<ScsiAuraProxyBlocking>("xyz.ljones.ScsiAura")?;
@@ -658,15 +774,38 @@ fn handle_scsi(cmd: &ScsiCommand) -> Result<(), Box<dyn std::error::Error>> {
 
 fn handle_led_mode(mode: &LedModeCommand) -> Result<(), Box<dyn std::error::Error>> {
     if mode.command.is_none() && !mode.prev_mode && !mode.next_mode {
-        println!("Missing arg or command; run 'asusctl aura --help' for usage");
+        if !mode.help {
-        // print available modes when possible
+            println!("Missing arg or command\n");
-        if let Ok(aura) = find_iface::<AuraProxyBlocking>("xyz.ljones.Aura") {
+        }
+        println!("{}\n", mode.self_usage());
+        println!("Commands available");
+
+        if let Some(cmdlist) = LedModeCommand::command_list() {
+            let commands: Vec<String> = cmdlist.lines().map(|s| s.to_owned()).collect();
+            // TODO: multiple rgb check
+            let aura = find_iface::<AuraProxyBlocking>("xyz.ljones.Aura")?;
             let modes = aura.first().unwrap().supported_basic_modes()?;
-            println!("Available modes:");
+            for command in commands.iter().filter(|command| {
-            for m in modes {
+                for mode in &modes {
-                println!("  {:?}", m);
+                    let mut mode = <&str>::from(mode).to_string();
+                    if let Some(pos) = mode.chars().skip(1).position(|c| c.is_uppercase()) {
+                        mode.insert(pos + 1, '-');
+                    }
+                    if command.trim().starts_with(&mode.to_lowercase()) {
+                        return true;
+                    }
+                }
+                // TODO
+                // if !supported.basic_zones.is_empty() && command.trim().starts_with("multi") {
+                //     return true;
+                // }
+                false
+            }) {
+                println!("{}", command);
             }
         }
+
+        println!("\nHelp can also be requested on modes, e.g: static --help");
         return Ok(());
     }
 
@@ -698,6 +837,10 @@ fn handle_led_mode(mode: &LedModeCommand) -> Result<(), Box<dyn std::error::Erro
             aura.set_led_mode(modes[pos])?;
         }
     } else if let Some(mode) = mode.command.as_ref() {
+        if mode.help_requested() {
+            println!("{}", mode.self_usage());
+            return Ok(());
+        }
         for aura in aura {
             aura.set_led_mode_data(<AuraEffect>::from(mode))?;
         }
@@ -720,7 +863,10 @@ fn handle_led_power1(power: &LedPowerCommand1) -> Result<(), Box<dyn std::error:
             && !power.keyboard
             && !power.lightbar
         {
-            println!("Missing arg or command; run 'asusctl aura-power-old --help' for usage");
+            if !power.help {
+                println!("Missing arg or command\n");
+            }
+            println!("{}\n", power.self_usage());
             return Ok(());
         }
 
@@ -772,47 +918,51 @@ fn handle_led_power2(power: &LedPowerCommand2) -> Result<(), Box<dyn std::error:
             continue;
         }
 
-        if power.command.is_none() {
+        if power.command().is_none() {
-            println!("Missing arg or command; run 'asusctl aura-power --help' for usage");
+            if !power.help {
+                println!("Missing arg or command\n");
+            }
+            println!("{}\n", power.self_usage());
             println!("Commands available");
+
+            if let Some(cmdlist) = LedPowerCommand2::command_list() {
+                let commands: Vec<String> = cmdlist.lines().map(|s| s.to_owned()).collect();
+                for command in &commands {
+                    println!("{}", command);
+                }
+            }
+
+            println!("\nHelp can also be requested on commands, e.g: boot --help");
             return Ok(());
         }
 
-        if let Some(_pow) = power.command.as_ref() {
+        if let Some(pow) = power.command.as_ref() {
+            if pow.help_requested() {
+                println!("{}", pow.self_usage());
+                return Ok(());
+            }
+
             let mut states = aura.led_power()?;
-            let mut set =
+            let mut set = |zone: PowerZones, set_to: &AuraPowerStates| {
-                |zone: PowerZones, boot_v: bool, awake_v: bool, sleep_v: bool, shutdown_v: bool| {
+                for state in states.states.iter_mut() {
-                    for state in states.states.iter_mut() {
+                    if state.zone == zone {
-                        if state.zone == zone {
+                        state.boot = set_to.boot;
-                            state.boot = boot_v;
+                        state.awake = set_to.awake;
-                            state.awake = awake_v;
+                        state.sleep = set_to.sleep;
-                            state.sleep = sleep_v;
+                        state.shutdown = set_to.shutdown;
-                            state.shutdown = shutdown_v;
+                        break;
-                            break;
-                        }
                     }
-                };
+                }
+            };
 
             if let Some(cmd) = &power.command {
                 match cmd {
-                    aura_cli::SetAuraZoneEnabled::Keyboard(k) => {
+                    aura_cli::SetAuraZoneEnabled::Keyboard(k) => set(PowerZones::Keyboard, k),
-                        set(PowerZones::Keyboard, k.boot, k.awake, k.sleep, k.shutdown)
+                    aura_cli::SetAuraZoneEnabled::Logo(l) => set(PowerZones::Logo, l),
-                    }
+                    aura_cli::SetAuraZoneEnabled::Lightbar(l) => set(PowerZones::Lightbar, l),
-                    aura_cli::SetAuraZoneEnabled::Logo(l) => {
+                    aura_cli::SetAuraZoneEnabled::Lid(l) => set(PowerZones::Lid, l),
-                        set(PowerZones::Logo, l.boot, l.awake, l.sleep, l.shutdown)
+                    aura_cli::SetAuraZoneEnabled::RearGlow(r) => set(PowerZones::RearGlow, r),
-                    }
+                    aura_cli::SetAuraZoneEnabled::Ally(r) => set(PowerZones::Ally, r),
-                    aura_cli::SetAuraZoneEnabled::Lightbar(l) => {
-                        set(PowerZones::Lightbar, l.boot, l.awake, l.sleep, l.shutdown)
-                    }
-                    aura_cli::SetAuraZoneEnabled::Lid(l) => {
-                        set(PowerZones::Lid, l.boot, l.awake, l.sleep, l.shutdown)
-                    }
-                    aura_cli::SetAuraZoneEnabled::RearGlow(r) => {
-                        set(PowerZones::RearGlow, r.boot, r.awake, r.sleep, r.shutdown)
-                    }
-                    aura_cli::SetAuraZoneEnabled::Ally(r) => {
-                        set(PowerZones::Ally, r.boot, r.awake, r.sleep, r.shutdown)
-                    }
                 }
             }
 
@@ -833,39 +983,53 @@ fn handle_throttle_profile(
         return Err(ProfileError::NotSupported.into());
     }
 
+    if !cmd.next
+        && !cmd.list
+        && cmd.profile_set.is_none()
+        && !cmd.profile_get
+        && cmd.profile_set_ac.is_none()
+        && cmd.profile_set_bat.is_none()
+    {
+        if !cmd.help {
+            println!("Missing arg or command\n");
+        }
+        println!("{}", ProfileCommand::usage());
+
+        if let Some(lst) = cmd.self_command_list() {
+            println!("\n{}", lst);
+        }
+        return Ok(());
+    }
+
     let proxy = PlatformProxyBlocking::new(conn)?;
     let current = proxy.platform_profile()?;
     let choices = proxy.platform_profile_choices()?;
 
-    match &cmd.command {
+    if cmd.next {
-        crate::cli_opts::ProfileSubCommand::Next(_) => {
+        proxy.set_platform_profile(PlatformProfile::next(current, &choices))?;
-            proxy.set_platform_profile(PlatformProfile::next(current, &choices))?;
+    } else if let Some(profile) = cmd.profile_set {
-        }
+        proxy.set_platform_profile(profile)?;
-        crate::cli_opts::ProfileSubCommand::Set(s) => {
+    } else if let Some(profile) = cmd.profile_set_ac {
-            if !s.ac && !s.battery {
+        proxy.set_platform_profile_on_ac(profile)?;
-                proxy.set_platform_profile(s.profile)?;
+    } else if let Some(profile) = cmd.profile_set_bat {
-            } else {
+        proxy.set_platform_profile_on_battery(profile)?;
-                if s.ac {
+    }
-                    proxy.set_platform_profile_on_ac(s.profile)?;
+
-                }
+    if cmd.list {
-                if s.battery {
+        for p in &choices {
-                    proxy.set_platform_profile_on_battery(s.profile)?;
+            println!("{:?}", p);
-                }
-            }
-        }
-        crate::cli_opts::ProfileSubCommand::List(_) => {
-            for p in &choices {
-                println!("{:?}", p);
-            }
-        }
-        crate::cli_opts::ProfileSubCommand::Get(_) => {
-            println!("Active profile: {current:?}");
-            println!();
-            println!("AC profile {:?}", proxy.platform_profile_on_ac()?);
-            println!("Battery profile {:?}", proxy.platform_profile_on_battery()?);
         }
     }
 
+    if cmd.profile_get {
+        println!("Active profile is {current:?}");
+        println!("Profile on AC is {:?}", proxy.platform_profile_on_ac()?);
+        println!(
+            "Profile on Battery is {:?}",
+            proxy.platform_profile_on_battery()?
+        );
+    }
+
     Ok(())
 }
 
@@ -880,7 +1044,14 @@ fn handle_fan_curve(
     };
 
     if !cmd.get_enabled && !cmd.default && cmd.mod_profile.is_none() {
-        println!("Missing arg or command; run 'asusctl fan-curve --help' for usage");
+        if !cmd.help {
+            println!("Missing arg or command\n");
+        }
+        println!("{}", FanCurveCommand::usage());
+
+        if let Some(lst) = cmd.self_command_list() {
+            println!("\n{}", lst);
+        }
         return Ok(());
     }
 
@@ -1019,33 +1190,33 @@ fn print_firmware_attr(attr: &AsusArmouryProxyBlocking) -> Result<(), Box<dyn st
 
 #[allow(clippy::manual_is_multiple_of, clippy::nonminimal_bool)]
 fn handle_armoury_command(cmd: &ArmouryCommand) -> Result<(), Box<dyn std::error::Error>> {
-    // If nested subcommand provided, handle set/get/list.
+    {
-    match &cmd.command {
+        if cmd.free.is_empty() || (cmd.free.len() % 2 != 0) || cmd.help {
-        ArmourySubCommand::List(_) => {
+            const USAGE: &str = "Usage: asusctl platform panel_overdrive 1 nv_dynamic_boost 5";
-            if let Ok(attrs) = find_iface::<AsusArmouryProxyBlocking>("xyz.ljones.AsusArmoury") {
+            if cmd.free.len() % 2 != 0 {
-                for attr in attrs.iter() {
+                println!(
+                    "Incorrect number of args, each attribute label must be paired with a setting:"
+                );
+                println!("{USAGE}");
+                return Ok(());
+            }
+
+            if let Ok(attr) = find_iface::<AsusArmouryProxyBlocking>("xyz.ljones.AsusArmoury") {
+                println!("\n{USAGE}\n");
+                println!("Available firmware attributes: ");
+                for attr in attr.iter() {
                     print_firmware_attr(attr)?;
                 }
             }
-            Ok(())
+            return Ok(());
         }
-        ArmourySubCommand::Get(g) => {
+
-            if let Ok(attrs) = find_iface::<AsusArmouryProxyBlocking>("xyz.ljones.AsusArmoury") {
+        if let Ok(attr) = find_iface::<AsusArmouryProxyBlocking>("xyz.ljones.AsusArmoury") {
-                for attr in attrs.iter() {
+            for cmd in cmd.free.chunks(2) {
+                for attr in attr.iter() {
                     let name = attr.name()?;
-                    if <&str>::from(name) == g.property {
+                    if <&str>::from(name) == cmd[0] {
-                        print_firmware_attr(attr)?;
+                        let mut value: i32 = cmd[1].parse()?;
-                    }
-                }
-            }
-            Ok(())
-        }
-        ArmourySubCommand::Set(s) => {
-            if let Ok(attrs) = find_iface::<AsusArmouryProxyBlocking>("xyz.ljones.AsusArmoury") {
-                for attr in attrs.iter() {
-                    let name = attr.name()?;
-                    if <&str>::from(name) == s.property {
-                        let mut value: i32 = s.value;
                         if value == -1 {
                             info!("Setting to default");
                             value = attr.default_value()?;
@@ -1055,7 +1226,7 @@ fn handle_armoury_command(cmd: &ArmouryCommand) -> Result<(), Box<dyn std::error
                     }
                 }
             }
-            Ok(())
         }
     }
+    Ok(())
 }

asusctl/src/scsi_cli.rs

@@ -1,30 +1,35 @@
-use argh::FromArgs;
+use gumdrop::Options;
 use rog_scsi::{AuraMode, Colour, Direction, Speed};
 
-#[derive(FromArgs, Debug)]
+#[derive(Options)]
-#[argh(subcommand, name = "scsi", description = "scsi LED commands")]
 pub struct ScsiCommand {
-    #[argh(option, description = "enable the SCSI drive LEDs")]
+    #[options(help = "print help message")]
+    pub help: bool,
+
+    #[options(help = "Enable the SCSI drive LEDs")]
     pub enable: Option<bool>,
 
-    #[argh(option, description = "set LED mode (use 'list' for all options)")]
+    #[options(meta = "", help = "Set LED mode (so 'list' for all options)")]
     pub mode: Option<AuraMode>,
 
-    #[argh(
+    #[options(
-        option,
+        meta = "",
-        description = "set LED mode speed <slowest, slow, med, fast, fastest>"
+        help = "Set LED mode speed <slowest, slow, med, fast, fastest> (does not apply to all)"
     )]
     pub speed: Option<Speed>,
 
-    #[argh(option, description = "set LED mode direction <forward, reverse>")]
+    #[options(
+        meta = "",
+        help = "Set LED mode direction <forward, reverse> (does not apply to all)"
+    )]
     pub direction: Option<Direction>,
 
-    #[argh(
+    #[options(
-        option,
+        meta = "",
-        description = "set LED colours <hex>, specify up to 4 with repeated arg"
+        help = "Set LED colours <hex>, specify up to 4 with repeated arg"
     )]
     pub colours: Vec<Colour>,
 
-    #[argh(switch, description = "list available animations")]
+    #[options(help = "list available animations")]
     pub list: bool,
 }

asusctl/src/slash_cli.rs

@@ -1,34 +1,37 @@
-use argh::FromArgs;
+use gumdrop::Options;
 use rog_slash::SlashMode;
 
-#[derive(FromArgs, Debug)]
+#[derive(Options)]
-#[argh(subcommand, name = "slash", description = "slash ledbar commands")]
 pub struct SlashCommand {
-    #[argh(switch, description = "enable the Slash Ledbar")]
+    #[options(help = "print help message")]
+    pub help: bool,
+    #[options(help = "Enable the Slash Ledbar")]
     pub enable: bool,
-    #[argh(switch, description = "disable the Slash Ledbar")]
+    #[options(help = "Disable the Slash Ledbar")]
     pub disable: bool,
-    #[argh(option, short = 'l', description = "set brightness value <0-255>")]
+    #[options(short = "l", meta = "", help = "Set brightness value <0-255>")]
     pub brightness: Option<u8>,
-    #[argh(option, description = "set interval value <0-5>")]
+    #[options(meta = "", help = "Set interval value <0-5>")]
     pub interval: Option<u8>,
-    #[argh(option, description = "set SlashMode (use 'list' for options)")]
+    #[options(meta = "", help = "Set SlashMode (so 'list' for all options)")]
     pub mode: Option<SlashMode>,
-    #[argh(switch, description = "list available animations")]
+    #[options(help = "list available animations")]
     pub list: bool,
 
-    #[argh(option, short = 'B', description = "show the animation on boot")]
+    #[options(short = "B", meta = "", help = "Show the animation on boot")]
     pub show_on_boot: Option<bool>,
-    #[argh(option, short = 'S', description = "show the animation on shutdown")]
+    #[options(short = "S", meta = "", help = "Show the animation on shutdown")]
     pub show_on_shutdown: Option<bool>,
-    #[argh(option, short = 's', description = "show the animation on sleep")]
+    #[options(short = "s", meta = "", help = "Show the animation on sleep")]
     pub show_on_sleep: Option<bool>,
-    #[argh(option, short = 'b', description = "show the animation on battery")]
+    #[options(short = "b", meta = "", help = "Show the animation on battery")]
     pub show_on_battery: Option<bool>,
-    #[argh(
+    // #[options(short = "L", meta = "", help = "Show the animation on lid closed")]
-        option,
+    // pub show_on_lid_closed: Option<bool>,
-        short = 'w',
+    #[options(
-        description = "show the low-battery warning animation"
+        short = "w",
+        meta = "",
+        help = "Show the low-battery warning animation"
     )]
     pub show_battery_warning: Option<bool>,
 }

asusd/src/asus_armoury.rs

@@ -1,7 +1,7 @@
 use std::sync::Arc;
 
 use config_traits::StdConfig;
-use log::{debug, error, info, warn};
+use log::{debug, error, info};
 use rog_platform::asus_armoury::{AttrValue, Attribute, FirmwareAttribute, FirmwareAttributes};
 use rog_platform::platform::{PlatformProfile, RogPlatform};
 use rog_platform::power::AsusPower;
@@ -205,13 +205,7 @@ impl crate::Reloadable for AsusArmouryAttribute {
                         self.attr.base_path_exists();
                         e
                     })?;
-                info!(
+                info!("Set {} to {:?}", self.attr.name(), tune);
-                    "Restored PPT armoury setting {} to {:?}",
-                    self.attr.name(),
-                    tune
-                );
-            } else {
-                info!("Ignored restoring PPT armoury setting {} as tuning group is disabled or no saved value", self.attr.name());
             }
         } else {
             // Handle non-PPT attributes (boolean and other settings)
@@ -219,10 +213,7 @@ impl crate::Reloadable for AsusArmouryAttribute {
                 self.attr
                     .set_current_value(&AttrValue::Integer(*saved_value))
                     .map_err(|e| {
-                        error!(
+                        error!("Could not set {} value: {e:?}", self.attr.name());
-                            "Error restoring armoury setting {}: {e:?}",
-                            self.attr.name()
-                        );
                         self.attr.base_path_exists();
                         e
                     })?;
@@ -231,11 +222,6 @@ impl crate::Reloadable for AsusArmouryAttribute {
                     self.attr.name(),
                     saved_value
                 );
-            } else {
-                info!(
-                    "No saved armoury setting for {}: skipping restore",
-                    self.attr.name()
-                );
             }
         }
 
@@ -411,44 +397,44 @@ impl AsusArmouryAttribute {
                 self.attr
                     .set_current_value(&AttrValue::Integer(value))
                     .map_err(|e| {
-                        error!(
+                        error!("Could not set value: {e:?}");
-                            "Could not set value to PPT property {}: {e:?}",
-                            self.attr.name()
-                        );
                         e
                     })?;
-            } else {
-                warn!(
-                    "Tuning group is disabled: skipping setting value to PPT property {}",
-                    self.attr.name()
-                );
             }
         } else {
             self.attr
                 .set_current_value(&AttrValue::Integer(value))
                 .map_err(|e| {
-                    error!(
+                    error!("Could not set value: {e:?}");
-                        "Could not set value {value} to attribute {}: {e:?}",
-                        self.attr.name()
-                    );
                     e
                 })?;
 
-            let mut settings = self.config.lock().await;
+            let has_attr = self
-            settings
+                .config
+                .lock()
+                .await
                 .armoury_settings
-                .entry(self.name())
+                .contains_key(&self.name());
-                .and_modify(|setting| {
+            if has_attr {
-                    debug!("Set config for {} = {value}", self.attr.name());
+                if let Some(setting) = self
-                    *setting = value;
+                    .config
-                })
+                    .lock()
-                .or_insert_with(|| {
+                    .await
-                    debug!("Adding config for {} = {value}", self.attr.name());
+                    .armoury_settings
-                    value
+                    .get_mut(&self.name())
-                });
+                {
+                    *setting = value
+                }
+            } else {
+                debug!("Adding config for {}", self.attr.name());
+                self.config
+                    .lock()
+                    .await
+                    .armoury_settings
+                    .insert(self.name(), value);
+                debug!("Set config for {} = {:?}", self.attr.name(), value);
+            }
         }
-
-        // write config after setting value
         self.config.lock().await.write();
         Ok(())
     }

asusd/src/ctrl_platform.rs

@@ -459,18 +459,8 @@ impl CtrlPlatform {
         #[zbus(signal_context)] ctxt: SignalEmitter<'_>,
         policy: PlatformProfile,
     ) -> Result<(), FdoErr> {
-        // If the requested profile isn't available on this platform, and it's
+        self.config.lock().await.platform_profile_on_battery = policy;
-        // `Quiet`, fall back to `LowPower` so we don't write an unavailable
+        self.set_platform_profile(ctxt, policy).await?;
-        // profile into the config file.
-        let mut chosen = policy;
-        if let Ok(choices) = self.platform.get_platform_profile_choices() {
-            if chosen == PlatformProfile::Quiet && !choices.contains(&PlatformProfile::Quiet) {
-                chosen = PlatformProfile::LowPower;
-            }
-        }
-
-        self.config.lock().await.platform_profile_on_battery = chosen;
-        self.set_platform_profile(ctxt, chosen).await?;
         self.config.lock().await.write();
         Ok(())
     }
@@ -498,16 +488,8 @@ impl CtrlPlatform {
         #[zbus(signal_context)] ctxt: SignalEmitter<'_>,
         policy: PlatformProfile,
     ) -> Result<(), FdoErr> {
-        // Mirror the same fallback behavior for AC profile changes.
+        self.config.lock().await.platform_profile_on_ac = policy;
-        let mut chosen = policy;
+        self.set_platform_profile(ctxt, policy).await?;
-        if let Ok(choices) = self.platform.get_platform_profile_choices() {
-            if chosen == PlatformProfile::Quiet && !choices.contains(&PlatformProfile::Quiet) {
-                chosen = PlatformProfile::LowPower;
-            }
-        }
-
-        self.config.lock().await.platform_profile_on_ac = chosen;
-        self.set_platform_profile(ctxt, chosen).await?;
         self.config.lock().await.write();
         Ok(())
     }

data/asusd.service

@@ -9,7 +9,7 @@ Environment=IS_SERVICE=1
 # Reduce noisy span logs while keeping useful debug info for asusd and related crates.
 # Keep global level at info but allow debug for our crates; silence tracing::span (very noisy)
 # RUST_LOG format: <module>=<level>,...  (levels: error,warn,info,debug,trace)
-Environment=RUST_LOG="info,asusd=debug,rog_platform=debug,tracing::span=error,zbus::object_server=error,zbus::connection::handshake::common=error,zbus::connection::handshake::client=error"
+Environment=RUST_LOG="info,asusd=debug,rog_platform=debug,tracing::span=error"
 # required to prevent init issues with hid_asus and MCU
 ExecStartPre=/bin/sleep 1
 ExecStart=/usr/bin/asusd

distro-packaging/asusctl.spec

@@ -20,7 +20,7 @@
 %global debug_package %{nil}
 %endif
 
-%define version 6.3.1
+%define version 6.2.0
 %define specrelease %{?dist}
 %define pkg_release 1%{specrelease}
 

extra/index.html

@@ -1,23 +0,0 @@
-<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <meta name="viewport" content="width=device-width,initial-scale=1">
-  <title>asusctl docs</title>
-  <!-- Redirect to the generated crate docs -->
-  <meta http-equiv="refresh" content="0;url=asusctl/index.html">
-  <link rel="canonical" href="asusctl/index.html">
-  <style>
-    body { font-family: system-ui, -apple-system, "Segoe UI", Roboto, "Helvetica Neue", Arial; color:#222; display:flex; align-items:center; justify-content:center; height:100vh; margin:0 }
-    .box { text-align:center }
-    a { color: #0366d6 }
-  </style>
-</head>
-<body>
-  <div class="box">
-    <h1>asusctl documentation</h1>
-    <p>Redirecting to the generated docs — if your browser doesn't redirect automatically, <a href="asusctl/index.html">click here</a>.</p>
-    <p>If you expected a different landing page, update <code>extra/index.html</code> accordingly.</p>
-  </div>
-</body>
-</html>

rog-aura/data/aura_support.ron

@@ -332,15 +332,6 @@
         advanced_type: r#None,
         power_zones: [Keyboard, Lightbar],
     ),
-    (
-        device_name: "G615LR",
-        product_id: "",
-        layout_name: "g634j-per-key",
-        basic_modes: [Static, Breathe, RainbowCycle, RainbowWave],
-        basic_zones: [Key1, Key2, Key3, Key4],
-        advanced_type: r#None,
-        power_zones: [Keyboard, Lightbar],
-    ),
     (
         device_name: "G634J",
         product_id: "",
@@ -575,15 +566,6 @@
         advanced_type: PerKey,
         power_zones: [Keyboard, Lightbar, Logo, RearGlow],
     ),
-    (
-        device_name: "G835L",
-        product_id: "",
-        layout_name: "g814ji-per-key",
-        basic_modes: [Static, Breathe, RainbowCycle, RainbowWave, Star, Rain, Highlight, Laser, Ripple, Comet, Flash],
-        basic_zones: [],
-        advanced_type: PerKey,
-        power_zones: [Keyboard, Lightbar, Logo],
-    ),
     (
         device_name: "GA401I",
         product_id: "",

rog-aura/src/builtin_modes.rs

@@ -359,12 +359,6 @@ impl From<AuraEffect> for AuraModeNum {
     }
 }
 
-#[cfg(feature = "dbus")]
-impl zbus::zvariant::Basic for AuraModeNum {
-    const SIGNATURE_CHAR: char = 'u';
-    const SIGNATURE_STR: &'static str = "u";
-}
-
 /// Base effects have no zoning, while multizone is 1-4
 #[cfg_attr(
     feature = "dbus",

rog-control-center/Cargo.toml

@@ -14,7 +14,6 @@ mocking = []
 x11 = ["slint/backend-winit-x11"]
 # Optional tokio debug feature does not require nightly; remove RUSTFLAGS note.
 tokio-debug = ["console-subscriber"]
-rog_ally = []
 
 [dependencies]
 console-subscriber = { version = "^0.4", optional = true }

rog-control-center/src/main.rs

@@ -107,6 +107,7 @@ async fn main() -> Result<()> {
     let board_name = dmi.board_name;
     let prod_family = dmi.product_family;
     info!("Running on {board_name}, product: {prod_family}");
+    let is_rog_ally = board_name == "RC71L" || board_name == "RC72L" || prod_family == "ROG Ally";
 
     let args: Vec<String> = args().skip(1).collect();
 
@@ -137,18 +138,6 @@ async fn main() -> Result<()> {
         config.start_fullscreen = false;
     }
 
-    let is_rog_ally = {
-        #[cfg(feature = "rog_ally")]
-        {
-            board_name == "RC71L" || board_name == "RC72L" || prod_family == "ROG Ally"
-        }
-        #[cfg(not(feature = "rog_ally"))]
-        {
-            false
-        }
-    };
-
-    #[cfg(feature = "rog_ally")]
     if is_rog_ally {
         config.notifications.enabled = false;
         config.enable_tray_icon = false;
@@ -156,7 +145,6 @@ async fn main() -> Result<()> {
         config.startup_in_background = false;
         config.start_fullscreen = true;
     }
-
     config.write();
 
     let enable_tray_icon = config.enable_tray_icon;
@@ -215,77 +203,76 @@ async fn main() -> Result<()> {
                         }
                     })
                     .ok();
-
+            } else {
-                continue;
+                // save as a var, don't hold the lock the entire time or deadlocks happen
-            }
+                if let Ok(app_state) = app_state.lock() {
-
+                    state = *app_state;
-            // save as a var, don't hold the lock the entire time or deadlocks happen
-            if let Ok(app_state) = app_state.lock() {
-                state = *app_state;
-            }
-
-            // This sleep is required to give the event loop time to react
-            sleep(Duration::from_millis(300));
-            if state == AppState::MainWindowShouldOpen {
-                if let Ok(mut app_state) = app_state.lock() {
-                    *app_state = AppState::MainWindowOpen;
                 }
 
-                let config_copy = config.clone();
+                // This sleep is required to give the event loop time to react
-                let app_state_copy = app_state.clone();
+                sleep(Duration::from_millis(300));
-                slint::invoke_from_event_loop(move || {
+                if state == AppState::MainWindowShouldOpen {
-                    UI.with(|ui| {
+                    if let Ok(mut app_state) = app_state.lock() {
-                        let app_state_copy = app_state_copy.clone();
+                        *app_state = AppState::MainWindowOpen;
-                        let mut ui = ui.borrow_mut();
+                    }
-                        if let Some(ui) = ui.as_mut() {
-                            ui.window().show().unwrap();
-                            ui.window().on_close_requested(move || {
-                                if let Ok(mut app_state) = app_state_copy.lock() {
-                                    *app_state = AppState::MainWindowClosed;
-                                }
-                                slint::CloseRequestResponse::HideWindow
-                            });
-                        } else {
-                            let config_copy_2 = config_copy.clone();
-                            let newui = setup_window(config_copy);
-                            newui.window().on_close_requested(move || {
-                                if let Ok(mut app_state) = app_state_copy.lock() {
-                                    *app_state = AppState::MainWindowClosed;
-                                }
-                                slint::CloseRequestResponse::HideWindow
-                            });
 
-                            let ui_copy = newui.as_weak();
+                    let config_copy = config.clone();
-                            newui
+                    let app_state_copy = app_state.clone();
-                                .window()
+                    slint::invoke_from_event_loop(move || {
-                                .set_rendering_notifier(move |s, _| {
+                        UI.with(|ui| {
-                                    if let slint::RenderingState::RenderingSetup = s {
+                            let app_state_copy = app_state_copy.clone();
-                                        let config = config_copy_2.clone();
+                            let mut ui = ui.borrow_mut();
-                                        ui_copy
+                            if let Some(ui) = ui.as_mut() {
-                                            .upgrade_in_event_loop(move |w| {
+                                ui.window().show().unwrap();
-                                                let fullscreen =
+                                ui.window().on_close_requested(move || {
-                                                    config.lock().is_ok_and(|c| c.start_fullscreen);
+                                    if let Ok(mut app_state) = app_state_copy.lock() {
-                                                if fullscreen && !w.window().is_fullscreen() {
+                                        *app_state = AppState::MainWindowClosed;
-                                                    w.window().set_fullscreen(fullscreen);
-                                                }
-                                            })
-                                            .ok();
                                     }
-                                })
+                                    slint::CloseRequestResponse::HideWindow
-                                .ok();
+                                });
-                            ui.replace(newui);
+                            } else {
+                                let config_copy_2 = config_copy.clone();
+                                let newui = setup_window(config_copy);
+                                newui.window().on_close_requested(move || {
+                                    if let Ok(mut app_state) = app_state_copy.lock() {
+                                        *app_state = AppState::MainWindowClosed;
+                                    }
+                                    slint::CloseRequestResponse::HideWindow
+                                });
+
+                                let ui_copy = newui.as_weak();
+                                newui
+                                    .window()
+                                    .set_rendering_notifier(move |s, _| {
+                                        if let slint::RenderingState::RenderingSetup = s {
+                                            let config = config_copy_2.clone();
+                                            ui_copy
+                                                .upgrade_in_event_loop(move |w| {
+                                                    let fullscreen = config
+                                                        .lock()
+                                                        .is_ok_and(|c| c.start_fullscreen);
+                                                    if fullscreen && !w.window().is_fullscreen() {
+                                                        w.window().set_fullscreen(fullscreen);
+                                                    }
+                                                })
+                                                .ok();
+                                        }
+                                    })
+                                    .ok();
+                                ui.replace(newui);
+                            }
+                        });
+                    })
+                    .unwrap();
+                } else if state == AppState::QuitApp {
+                    slint::quit_event_loop().unwrap();
+                    exit(0);
+                } else if state != AppState::MainWindowOpen {
+                    if let Ok(config) = config.lock() {
+                        if !config.run_in_background {
+                            slint::quit_event_loop().unwrap();
+                            exit(0);
                         }
-                    });
-                })
-                .unwrap();
-            } else if state == AppState::QuitApp {
-                slint::quit_event_loop().unwrap();
-                exit(0);
-            } else if state != AppState::MainWindowOpen {
-                if let Ok(config) = config.lock() {
-                    if !config.run_in_background {
-                        slint::quit_event_loop().unwrap();
-                        exit(0);
                     }
                 }
             }

rog-control-center/src/notify.rs

@@ -9,11 +9,15 @@ use std::process::Command;
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
 
+use futures_util::StreamExt;
 use log::{debug, error, info, warn};
-use notify_rust::{Hint, Notification, Timeout};
+use notify_rust::{Hint, Notification, Timeout, Urgency};
+use rog_platform::platform::GpuMode;
 use rog_platform::power::AsusPower;
 use serde::{Deserialize, Serialize};
-use supergfxctl::pci_device::GfxPower;
+use supergfxctl::actions::UserActionRequired as GfxUserAction;
+use supergfxctl::pci_device::{GfxMode, GfxPower};
+use supergfxctl::zbus_proxy::DaemonProxy as SuperProxy;
 use tokio::runtime::Runtime;
 use tokio::task::JoinHandle;
 
@@ -141,8 +145,12 @@ pub fn start_notifications(
         }
     });
 
-    info!("Attempting to start plain dgpu status monitor");
+    let enabled_notifications_copy = config.clone();
-    start_dpu_status_mon(config.clone());
+    let no_supergfx = move |e: &zbus::Error| {
+        error!("zbus signal: receive_notify_gfx_status: {e}");
+        warn!("Attempting to start plain dgpu status monitor");
+        start_dpu_status_mon(enabled_notifications_copy.clone());
+    };
 
     // GPU MUX Mode notif
     // TODO: need to get armoury attrs and iter to find
@@ -181,9 +189,95 @@ pub fn start_notifications(
     //     Ok::<(), zbus::Error>(())
     // });
 
+    let enabled_notifications_copy = config.clone();
+    // GPU Mode change/action notif
+    tokio::spawn(async move {
+        let conn = zbus::Connection::system().await.inspect_err(|e| {
+            no_supergfx(e);
+        })?;
+        let proxy = SuperProxy::builder(&conn).build().await.inspect_err(|e| {
+            no_supergfx(e);
+        })?;
+        let _ = proxy.mode().await.inspect_err(|e| {
+            no_supergfx(e);
+        })?;
+
+        let proxy_copy = proxy.clone();
+        let enabled_notifications_copy_action = enabled_notifications_copy.clone();
+        let mut p = proxy.receive_notify_action().await?;
+        tokio::spawn(async move {
+            info!("Started zbus signal thread: receive_notify_action");
+            while let Some(e) = p.next().await {
+                if let Ok(out) = e.args() {
+                    // Respect user notification settings for gpu actions
+                    if let Ok(cfg) = enabled_notifications_copy_action.lock() {
+                        if !cfg.notifications.enabled || !cfg.notifications.receive_notify_gfx {
+                            continue;
+                        }
+                    }
+
+                    let action = out.action();
+                    let mode = convert_gfx_mode(proxy.mode().await.unwrap_or_default());
+                    match action {
+                        supergfxctl::actions::UserActionRequired::Reboot => {
+                            do_mux_notification("Graphics mode change requires reboot", &mode)
+                        }
+                        _ => do_gfx_action_notif(<&str>::from(action), *action, mode),
+                    }
+                    .map_err(|e| {
+                        error!("zbus signal: do_gfx_action_notif: {e}");
+                        e
+                    })
+                    .ok();
+                }
+            }
+        });
+
+        let mut p = proxy_copy.receive_notify_gfx_status().await?;
+        tokio::spawn(async move {
+            info!("Started zbus signal thread: receive_notify_gfx_status");
+            let mut last_status = GfxPower::Unknown;
+            while let Some(e) = p.next().await {
+                if let Ok(out) = e.args() {
+                    let status = out.status;
+                    if status != GfxPower::Unknown && status != last_status {
+                        if let Ok(config) = enabled_notifications_copy.lock() {
+                            if !config.notifications.receive_notify_gfx_status
+                                || !config.notifications.enabled
+                            {
+                                continue;
+                            }
+                        }
+                        // Required check because status cycles through
+                        // active/unknown/suspended
+                        do_gpu_status_notif("dGPU status changed:", &status)
+                            .show_async()
+                            .await
+                            .unwrap()
+                            .on_close(|_| ());
+                    }
+                    last_status = status;
+                }
+            }
+        });
+        Ok::<(), zbus::Error>(())
+    });
+
     Ok(vec![blocking])
 }
 
+fn convert_gfx_mode(gfx: GfxMode) -> GpuMode {
+    match gfx {
+        GfxMode::Hybrid => GpuMode::Optimus,
+        GfxMode::Integrated => GpuMode::Integrated,
+        GfxMode::NvidiaNoModeset => GpuMode::Optimus,
+        GfxMode::Vfio => GpuMode::Vfio,
+        GfxMode::AsusEgpu => GpuMode::Egpu,
+        GfxMode::AsusMuxDgpu => GpuMode::Ultimate,
+        GfxMode::None => GpuMode::Error,
+    }
+}
+
 fn base_notification<T>(message: &str, data: &T) -> Notification
 where
     T: Display,
@@ -209,3 +303,97 @@ fn do_gpu_status_notif(message: &str, data: &GfxPower) -> Notification {
     notif.icon(icon);
     notif
 }
+
+fn do_gfx_action_notif(message: &str, action: GfxUserAction, mode: GpuMode) -> Result<()> {
+    if matches!(action, GfxUserAction::Reboot) {
+        do_mux_notification("Graphics mode change requires reboot", &mode).ok();
+        return Ok(());
+    }
+
+    let mut notif = Notification::new();
+    notif
+        .appname(NOTIF_HEADER)
+        .summary(&format!("Changing to {mode}. {message}"))
+        //.hint(Hint::Resident(true))
+        .hint(Hint::Category("device".into()))
+        .urgency(Urgency::Critical)
+        // For user-action notifications keep them visible if they require interaction
+        // but for non-interactive actions we prefer they auto-hide like other notifs.
+        .timeout(Timeout::Milliseconds(6000))
+        .icon("dialog-warning")
+        .hint(Hint::Transient(true));
+
+    if matches!(action, GfxUserAction::Logout) {
+        notif.action("gfx-mode-session-action", "Logout");
+        let handle = notif.show()?;
+        if let Ok(desktop) = std::env::var("XDG_CURRENT_DESKTOP") {
+            if desktop.to_lowercase() == "gnome" {
+                handle.wait_for_action(|id| {
+                    if id == "gfx-mode-session-action" {
+                        let mut cmd = Command::new("gnome-session-quit");
+                        cmd.spawn().ok();
+                    } else if id == "__closed" {
+                        // TODO: cancel the switching
+                    }
+                });
+            } else if desktop.to_lowercase() == "kde" {
+                handle.wait_for_action(|id| {
+                    if id == "gfx-mode-session-action" {
+                        let mut cmd = Command::new("qdbus");
+                        cmd.args([
+                            "org.kde.ksmserver", "/KSMServer", "logout", "1", "0", "0",
+                        ]);
+                        cmd.spawn().ok();
+                    } else if id == "__closed" {
+                        // TODO: cancel the switching
+                    }
+                });
+            } else {
+                // todo: handle alternatives
+            }
+        }
+    } else {
+        notif.show()?;
+    }
+    Ok(())
+}
+
+/// Actual `GpuMode` unused as data is never correct until switched by reboot
+fn do_mux_notification(message: &str, m: &GpuMode) -> Result<()> {
+    let mut notif = base_notification(message, &m.to_string());
+    notif
+        .action("gfx-mode-session-action", "Reboot")
+        .urgency(Urgency::Critical)
+        .icon("system-reboot-symbolic")
+        .hint(Hint::Transient(true));
+    let handle = notif.show()?;
+
+    std::thread::spawn(|| {
+        if let Ok(desktop) = std::env::var("XDG_CURRENT_DESKTOP") {
+            if desktop.to_lowercase() == "gnome" {
+                handle.wait_for_action(|id| {
+                    if id == "gfx-mode-session-action" {
+                        let mut cmd = Command::new("gnome-session-quit");
+                        cmd.arg("--reboot");
+                        cmd.spawn().ok();
+                    } else if id == "__closed" {
+                        // TODO: cancel the switching
+                    }
+                });
+            } else if desktop.to_lowercase() == "kde" {
+                handle.wait_for_action(|id| {
+                    if id == "gfx-mode-session-action" {
+                        let mut cmd = Command::new("qdbus");
+                        cmd.args([
+                            "org.kde.ksmserver", "/KSMServer", "logout", "1", "1", "0",
+                        ]);
+                        cmd.spawn().ok();
+                    } else if id == "__closed" {
+                        // TODO: cancel the switching
+                    }
+                });
+            }
+        }
+    });
+    Ok(())
+}

rog-control-center/src/tray.rs

@@ -170,7 +170,7 @@ pub fn init_tray(_supported_properties: Vec<Properties>, config: Arc<Mutex<Confi
 
         // TODO: return an error to the UI
         let mut tray;
-        match tray_init.disable_dbus_name(true).spawn().await {
+        match tray_init.spawn_without_dbus_name().await {
             Ok(t) => tray = t,
             Err(e) => {
                 log::error!(

rog-control-center/translations/uk_UA/rog-control-center.po

@@ -1,810 +0,0 @@
-msgid ""
-msgstr ""
-"Project-Id-Version: rog-control-center\n"
-"POT-Creation-Date: 2026-01-16 22:25+0000\n"
-"PO-Revision-Date: 2024-07-28 12:00+0300\n"
-"Last-Translator: Mykola Shevchenko\n"
-"Language-Team: Ukrainian\n"
-"MIME-Version: 1.0\n"
-"Content-Type: text/plain; charset=UTF-8\n"
-"Content-Transfer-Encoding: 8bit\n"
-"Language: uk_UA\n"
-"Plural-Forms: nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);\n"
-
-#: rog-control-center/ui/main_window.slint:55
-msgctxt "MainWindow"
-msgid "ROG"
-msgstr "ROG"
-
-#: rog-control-center/ui/main_window.slint:57
-msgctxt "Menu1"
-msgid "System Control"
-msgstr "Системні"
-
-#: rog-control-center/ui/main_window.slint:58
-msgctxt "Menu2"
-msgid "Keyboard Aura"
-msgstr "Aura клавіатури"
-
-#: rog-control-center/ui/main_window.slint:59
-msgctxt "Menu3"
-msgid "AniMe Matrix"
-msgstr "AniMe матриця"
-
-#: rog-control-center/ui/main_window.slint:60
-msgctxt "Menu4"
-msgid "Fan Curves"
-msgstr "Криві вентиляторів"
-
-#: rog-control-center/ui/main_window.slint:61
-msgctxt "Menu5"
-msgid "App Settings"
-msgstr "Налаштування"
-
-#: rog-control-center/ui/main_window.slint:62
-msgctxt "Menu6"
-msgid "About"
-msgstr "Про додаток"
-
-#: rog-control-center/ui/main_window.slint:74
-msgctxt "MainWindow"
-msgid "Quit App"
-msgstr "Вийти"
-
-#: rog-control-center/ui/pages/anime.slint:6
-msgctxt "Anime Brightness"
-msgid "Off"
-msgstr "Вимкнено"
-
-#: rog-control-center/ui/pages/anime.slint:7
-msgctxt "Anime Brightness"
-msgid "Low"
-msgstr "Низька"
-
-#: rog-control-center/ui/pages/anime.slint:8
-msgctxt "Anime Brightness"
-msgid "Med"
-msgstr "Середня"
-
-#: rog-control-center/ui/pages/anime.slint:9
-msgctxt "Anime Brightness"
-msgid "High"
-msgstr "Висока"
-
-#: rog-control-center/ui/pages/anime.slint:23
-msgctxt "AnimePageData"
-msgid "Glitch Construction"
-msgstr "Збій конструкції"
-
-#: rog-control-center/ui/pages/anime.slint:23
-msgctxt "AnimePageData"
-msgid "Static Emergence"
-msgstr "Статична поява"
-
-#: rog-control-center/ui/pages/anime.slint:25
-msgctxt "AnimePageData"
-msgid "Binary Banner Scroll"
-msgstr "Прокрутка бінарного банера"
-
-#: rog-control-center/ui/pages/anime.slint:25
-msgctxt "AnimePageData"
-msgid "Rog Logo Glitch"
-msgstr "Збій логотипу Rog"
-
-#: rog-control-center/ui/pages/anime.slint:27
-msgctxt "AnimePageData"
-msgid "Banner Swipe"
-msgstr "Прогортання банера"
-
-#: rog-control-center/ui/pages/anime.slint:27
-msgctxt "AnimePageData"
-msgid "Starfield"
-msgstr "Зоряне поле"
-
-#: rog-control-center/ui/pages/anime.slint:29
-msgctxt "AnimePageData"
-msgid "Glitch Out"
-msgstr "Збій"
-
-#: rog-control-center/ui/pages/anime.slint:29
-msgctxt "AnimePageData"
-msgid "See Ya"
-msgstr "Бувай"
-
-#: rog-control-center/ui/pages/anime.slint:50
-msgctxt "Anime Brightness"
-msgid "Brightness"
-msgstr "Яскравість"
-
-#: rog-control-center/ui/pages/anime.slint:66
-msgctxt "PageAnime"
-msgid "Enable display"
-msgstr "Увімкнути показ"
-
-#: rog-control-center/ui/pages/anime.slint:74 rog-control-center/ui/pages/anime.slint:97
-msgctxt "PageAnime"
-msgid "Advanced"
-msgstr "Розширені"
-
-#: rog-control-center/ui/pages/anime.slint:89
-msgctxt "PageAnime"
-msgid "Use built-in animations"
-msgstr "Використовувати вбудовані анімації"
-
-#: rog-control-center/ui/pages/anime.slint:146
-msgctxt "PageAnime"
-msgid "Set which builtin animations are played"
-msgstr "Встановити, які вбудовані анімації відтворювати"
-
-#: rog-control-center/ui/pages/anime.slint:150
-msgctxt "Anime built-in selection"
-msgid "Boot Animation"
-msgstr "Анімація завантаження"
-
-#: rog-control-center/ui/pages/anime.slint:160
-msgctxt "Anime built-in selection"
-msgid "Running Animation"
-msgstr "Анімація роботи"
-
-#: rog-control-center/ui/pages/anime.slint:170
-msgctxt "Anime built-in selection"
-msgid "Sleep Animation"
-msgstr "Анімація сну"
-
-#: rog-control-center/ui/pages/anime.slint:180
-msgctxt "Anime built-in selection"
-msgid "Shutdown Animation"
-msgstr "Анімація вимкнення"
-
-#: rog-control-center/ui/pages/anime.slint:220
-msgctxt "PageAnime"
-msgid "Advanced Display Settings"
-msgstr "Розширені налаштування показу"
-
-#: rog-control-center/ui/pages/anime.slint:225
-msgctxt "PageAnime"
-msgid "Off when lid closed"
-msgstr "Вимикати при закритій кришці"
-
-#: rog-control-center/ui/pages/anime.slint:234
-msgctxt "PageAnime"
-msgid "Off when suspended"
-msgstr "Вимикати в режимі сну"
-
-#: rog-control-center/ui/pages/anime.slint:243
-msgctxt "PageAnime"
-msgid "Off when on battery"
-msgstr "Вимикати при роботі від батареї"
-
-#: rog-control-center/ui/pages/system.slint:20
-msgctxt "SystemPageData"
-msgid "Balanced"
-msgstr "Збалансований"
-
-#: rog-control-center/ui/pages/system.slint:20 rog-control-center/ui/pages/system.slint:27
-msgctxt "SystemPageData"
-msgid "Performance"
-msgstr "Продуктивний"
-
-#: rog-control-center/ui/pages/system.slint:20
-msgctxt "SystemPageData"
-msgid "Quiet"
-msgstr "Тихий"
-
-#: rog-control-center/ui/pages/system.slint:20
-msgctxt "SystemPageData"
-msgid "LowPower"
-msgstr "Низьке споживання"
-
-#: rog-control-center/ui/pages/system.slint:26
-msgctxt "SystemPageData"
-msgid "Default"
-msgstr "За замовчуванням"
-
-#: rog-control-center/ui/pages/system.slint:28
-msgctxt "SystemPageData"
-msgid "BalancePerformance"
-msgstr "Баланс-Продуктивність"
-
-#: rog-control-center/ui/pages/system.slint:29
-msgctxt "SystemPageData"
-msgid "BalancePower"
-msgstr "Баланс-Енергозбереження"
-
-#: rog-control-center/ui/pages/system.slint:30
-msgctxt "SystemPageData"
-msgid "Power"
-msgstr "Енергозбереження"
-
-#: rog-control-center/ui/pages/system.slint:159
-msgctxt "PageSystem"
-msgid "Power settings"
-msgstr "Налаштування живлення"
-
-#: rog-control-center/ui/pages/system.slint:164
-msgctxt "PageSystem"
-msgid "Charge limit"
-msgstr "Ліміт заряду"
-
-#: rog-control-center/ui/pages/system.slint:179
-msgctxt "PageSystem"
-msgid "Platform Profile"
-msgstr "Профіль платформи"
-
-#: rog-control-center/ui/pages/system.slint:189
-msgctxt "PageSystem"
-msgid "Advanced"
-msgstr "Розширені"
-
-#: rog-control-center/ui/pages/system.slint:209
-msgctxt "PageSystem"
-msgid "Screenpad brightness"
-msgstr "Яскравість екранної панелі"
-
-#: rog-control-center/ui/pages/system.slint:233
-msgctxt "PageSystem"
-msgid "Sync with primary"
-msgstr "Синхронізувати з основним"
-
-#: rog-control-center/ui/pages/system.slint:253
-msgctxt "PageSystem"
-msgid "Armoury settings"
-msgstr "Налаштування Armoury"
-
-#: rog-control-center/ui/pages/system.slint:253
-msgctxt "PageSystem"
-msgid "Keyboard Power Management"
-msgstr "Керування живленням клавіатури"
-
-#: rog-control-center/ui/pages/system.slint:263
-msgctxt "no_asus_armoury_driver_1"
-msgid "The asus-armoury driver is not loaded"
-msgstr "Драйвер asus-armoury не завантажено"
-
-#: rog-control-center/ui/pages/system.slint:269
-msgctxt "no_asus_armoury_driver_2"
-msgid "For advanced features you will require a kernel with this driver added."
-msgstr "Для розширених функцій вам знадобиться ядро з доданим цим драйвером."
-
-#: rog-control-center/ui/pages/system.slint:280
-msgctxt "PageSystem"
-msgid "Panel Overdrive"
-msgstr "Розгін матриці"
-
-#: rog-control-center/ui/pages/system.slint:288
-msgctxt "PageSystem"
-msgid "MiniLED Mode"
-msgstr "Режим MiniLED"
-
-#: rog-control-center/ui/pages/system.slint:296
-msgctxt "PageSystem"
-msgid "POST boot sound"
-msgstr "Звук при завантаженні"
-
-#: rog-control-center/ui/pages/system.slint:312
-msgctxt "ppt_warning"
-msgid "The following settings are not applied until the toggle is enabled."
-msgstr "Наступні налаштування не застосовуються, доки перемикач не буде увімкнено."
-
-#: rog-control-center/ui/pages/system.slint:317 rog-control-center/ui/pages/system.slint:324
-msgctxt "ppt_group_enabled"
-msgid "Enable Tuning"
-msgstr "Увімкнути налаштування"
-
-#: rog-control-center/ui/pages/system.slint:334 rog-control-center/ui/pages/system.slint:335
-msgctxt "ppt_pl1_spl"
-msgid "CPU Sustained Power Limit"
-msgstr "Тривалий ліміт потужності CPU"
-
-#: rog-control-center/ui/pages/system.slint:336
-msgctxt "ppt_pl1_spl_help"
-msgid ""
-"Long-term CPU power limit that affects sustained workload performance. "
-"Higher values may increase heat and power consumption."
-msgstr ""
-"Довготривалий ліміт потужності CPU, що впливає на продуктивність при тривалих навантаженнях."
-"Вищі значення можуть збільшити нагрівання та споживання енергії."
-
-#: rog-control-center/ui/pages/system.slint:352 rog-control-center/ui/pages/system.slint:353
-msgctxt "ppt_pl2_sppt"
-msgid "CPU Turbo Power Limit"
-msgstr "Турбо ліміт потужності CPU"
-
-#: rog-control-center/ui/pages/system.slint:354
-msgctxt "ppt_pl2_sppt_help"
-msgid ""
-"Short-term CPU power limit for boost periods. Controls maximum power during "
-"brief high-performance bursts."
-msgstr ""
-"Короткочасний ліміт потужності CPU для періодів прискорення. Контролює максимальну"
-"потужність під час коротких сплесків високої продуктивності."
-
-#: rog-control-center/ui/pages/system.slint:370 rog-control-center/ui/pages/system.slint:371
-msgctxt "ppt_pl3_fppt"
-msgid "CPU Fast Burst Power Limit"
-msgstr "Швидкий ліміт потужності CPU"
-
-#: rog-control-center/ui/pages/system.slint:372
-msgctxt "ppt_pl3_fppt_help"
-msgid ""
-"Ultra-short duration power limit for instantaneous CPU bursts. Affects "
-"responsiveness during sudden workload spikes."
-msgstr ""
-"Надкороткий ліміт потужності для миттєвих сплесків CPU."
-"Впливає на чутливість під час раптових піків навантаження."
-
-#: rog-control-center/ui/pages/system.slint:387 rog-control-center/ui/pages/system.slint:388
-msgctxt "ppt_fppt"
-msgid "Fast Package Power Limit"
-msgstr "Швидкий ліміт потужності пакета"
-
-#: rog-control-center/ui/pages/system.slint:389
-msgctxt "ppt_fppt_help"
-msgid ""
-"Ultra-short duration power limit for system package. Controls maximum power "
-"during millisecond-scale load spikes."
-msgstr ""
-"Надкороткий ліміт потужності для системного пакета. Контролює максимальну"
-"потужність під час пікових навантажень мілісекундного масштабу."
-
-#: rog-control-center/ui/pages/system.slint:405 rog-control-center/ui/pages/system.slint:406
-msgctxt "ppt_apu_sppt"
-msgid "APU Sustained Power Limit"
-msgstr "Тривалий ліміт потужності APU"
-
-#: rog-control-center/ui/pages/system.slint:407
-msgctxt "ppt_apu_sppt_help"
-msgid ""
-"Long-term power limit for integrated graphics and CPU combined. Affects "
-"sustained performance of APU-based workloads."
-msgstr ""
-"Довготривалий ліміт потужності для інтегрованої графіки та CPU разом."
-"Впливає на тривалу продуктивність навантажень на базі APU."
-
-#: rog-control-center/ui/pages/system.slint:423 rog-control-center/ui/pages/system.slint:424
-msgctxt "ppt_platform_sppt"
-msgid "Platform Sustained Power Limit"
-msgstr "Тривалий ліміт потужності платформи"
-
-#: rog-control-center/ui/pages/system.slint:425
-msgctxt "ppt_platform_sppt_help"
-msgid ""
-"Overall system power limit for sustained operations. Controls total platform "
-"power consumption over extended periods."
-msgstr ""
-"Загальний ліміт потужності системи для тривалих операцій. Контролює загальне"
-"споживання енергії платформою протягом тривалих періодів."
-
-#: rog-control-center/ui/pages/system.slint:441 rog-control-center/ui/pages/system.slint:442
-msgctxt "nv_dynamic_boost"
-msgid "GPU Power Boost"
-msgstr "Прискорення потужності GPU"
-
-#: rog-control-center/ui/pages/system.slint:443
-msgctxt "nv_dynamic_boost_help"
-msgid ""
-"Additional power allocation for GPU dynamic boost. Higher values increase "
-"GPU performance but generate more heat."
-msgstr ""
-"Додаткове виділення потужності для динамічного прискорення GPU. Вищі значення"
-"збільшують продуктивність GPU, але генерують більше тепла."
-
-#: rog-control-center/ui/pages/system.slint:459 rog-control-center/ui/pages/system.slint:460
-msgctxt "nv_temp_target"
-msgid "GPU Temperature Limit"
-msgstr "Ліміт температури GPU"
-
-#: rog-control-center/ui/pages/system.slint:461
-msgctxt "nv_temp_target_help"
-msgid ""
-"Maximum GPU temperature threshold in Celsius. GPU will throttle to maintain "
-"temperature below this limit."
-msgstr ""
-"Максимальний поріг температури GPU у градусах Цельсія. GPU буде знижувати"
-"частоту для підтримки температури нижче цього ліміту."
-
-#: rog-control-center/ui/pages/system.slint:513
-msgctxt "PageSystem"
-msgid "Energy Performance Preference linked to Throttle Policy"
-msgstr "Перевага енергоефективності пов'язана з Політикою Тротлінгу"
-
-#: rog-control-center/ui/pages/system.slint:517
-msgctxt "PageSystem"
-msgid "Change EPP based on Throttle Policy"
-msgstr "Змінювати EPP на основі Політики Тротлінгу"
-
-#: rog-control-center/ui/pages/system.slint:525
-msgctxt "PageSystem"
-msgid "EPP for Balanced Policy"
-msgstr "EPP для Збалансованої Політики"
-
-#: rog-control-center/ui/pages/system.slint:535
-msgctxt "PageSystem"
-msgid "EPP for Performance Policy"
-msgstr "EPP для Політики Продуктивності"
-
-#: rog-control-center/ui/pages/system.slint:545
-msgctxt "PageSystem"
-msgid "EPP for Quiet Policy"
-msgstr "EPP для Тихої Політики"
-
-#: rog-control-center/ui/pages/system.slint:563
-msgctxt "PageSystem"
-msgid "Throttle Policy for power state"
-msgstr "Політика Тротлінгу для стану живлення"
-
-#: rog-control-center/ui/pages/system.slint:569
-msgctxt "PageSystem"
-msgid "Throttle Policy on Battery"
-msgstr "Політика Тротлінгу при живленні від батареї"
-
-#: rog-control-center/ui/pages/system.slint:579 rog-control-center/ui/pages/system.slint:600
-msgctxt "PageSystem"
-msgid "Enabled"
-msgstr "Увімкнено"
-
-#: rog-control-center/ui/pages/system.slint:590
-msgctxt "PageSystem"
-msgid "Throttle Policy on AC"
-msgstr "Політика Тротлінгу при живленні від мережі"
-
-#: rog-control-center/ui/pages/aura.slint:28
-msgctxt "PageAura"
-msgid "Brightness"
-msgstr "Яскравість"
-
-#: rog-control-center/ui/pages/aura.slint:39
-msgctxt "PageAura"
-msgid "Aura mode"
-msgstr "Режим Aura"
-
-#: rog-control-center/ui/pages/aura.slint:59
-msgctxt "PageAura"
-msgid "Colour 1"
-msgstr "Колір 1"
-
-#: rog-control-center/ui/pages/aura.slint:85
-msgctxt "PageAura"
-msgid "Colour 2"
-msgstr "Колір 2"
-
-#: rog-control-center/ui/pages/aura.slint:119
-msgctxt "PageAura"
-msgid "Zone"
-msgstr "Зона"
-
-#: rog-control-center/ui/pages/aura.slint:142
-msgctxt "PageAura"
-msgid "Direction"
-msgstr "Напрямок"
-
-#: rog-control-center/ui/pages/aura.slint:164
-msgctxt "PageAura"
-msgid "Speed"
-msgstr "Швидкість"
-
-#: rog-control-center/ui/pages/aura.slint:185
-msgctxt "PageAura"
-msgid "Power Settings"
-msgstr "Налаштування живлення"
-
-#: rog-control-center/ui/pages/aura.slint:270
-msgctxt "PageAura"
-msgid "Power Zones"
-msgstr "Зони живлення"
-
-#: rog-control-center/ui/pages/app_settings.slint:26
-msgctxt "PageAppSettings"
-msgid "Run in background after closing"
-msgstr "Працювати у фоні після закриття"
-
-#: rog-control-center/ui/pages/app_settings.slint:34
-msgctxt "PageAppSettings"
-msgid "Start app in background (UI closed)"
-msgstr "Запускати у фоні (без інтерфейсу)"
-
-#: rog-control-center/ui/pages/app_settings.slint:42
-msgctxt "PageAppSettings"
-msgid "Enable system tray icon"
-msgstr "Увімкнути іконку в треї"
-
-#: rog-control-center/ui/pages/app_settings.slint:50
-msgctxt "PageAppSettings"
-msgid "Enable dGPU notifications"
-msgstr "Увімкнути сповіщення про dGPU"
-
-#: rog-control-center/ui/pages/fans.slint:26
-msgctxt "FanTab"
-msgid "This fan is not avilable on this machine"
-msgstr "Цей вентилятор недоступний на цьому пристрої"
-
-#: rog-control-center/ui/pages/fans.slint:34
-msgctxt "FanTab"
-msgid "Enabled"
-msgstr "Увімкнено"
-
-#: rog-control-center/ui/pages/fans.slint:43
-msgctxt "FanTab"
-msgid "Apply"
-msgstr "Застосувати"
-
-#: rog-control-center/ui/pages/fans.slint:51
-msgctxt "FanTab"
-msgid "Cancel"
-msgstr "Скасувати"
-
-#: rog-control-center/ui/pages/fans.slint:59
-msgctxt "FanTab"
-msgid "Factory Default (all fans)"
-msgstr "Заводські налаштування (всі вентилятори)"
-
-#: rog-control-center/ui/pages/fans.slint:72
-msgctxt "PageFans"
-msgid "Balanced"
-msgstr "Збалансований"
-
-#: rog-control-center/ui/pages/fans.slint:75 rog-control-center/ui/pages/fans.slint:134 rog-control-center/ui/pages/fans.slint:193
-msgctxt "PageFans"
-msgid "CPU"
-msgstr "CPU"
-
-#: rog-control-center/ui/pages/fans.slint:93 rog-control-center/ui/pages/fans.slint:152 rog-control-center/ui/pages/fans.slint:211
-msgctxt "PageFans"
-msgid "Mid"
-msgstr "Середній"
-
-#: rog-control-center/ui/pages/fans.slint:111 rog-control-center/ui/pages/fans.slint:170 rog-control-center/ui/pages/fans.slint:229
-msgctxt "PageFans"
-msgid "GPU"
-msgstr "GPU"
-
-#: rog-control-center/ui/pages/fans.slint:131
-msgctxt "PageFans"
-msgid "Performance"
-msgstr "Продуктивний"
-
-#: rog-control-center/ui/pages/fans.slint:190
-msgctxt "PageFans"
-msgid "Quiet"
-msgstr "Тихий"
-
-#: rog-control-center/ui/widgets/common.slint:126
-msgctxt "confirm_reset"
-msgid "Are you sure you want to reset this?"
-msgstr "Ви впевнені, що хочете скинути це?"
-
-#: rog-control-center/ui/widgets/aura_power.slint:33
-msgctxt "AuraPowerGroup"
-msgid "Boot"
-msgstr "Запуск"
-
-#: rog-control-center/ui/widgets/aura_power.slint:43
-msgctxt "AuraPowerGroup"
-msgid "Awake"
-msgstr "Робота"
-
-#: rog-control-center/ui/widgets/aura_power.slint:53
-msgctxt "AuraPowerGroup"
-msgid "Sleep"
-msgstr "Сон"
-
-#: rog-control-center/ui/widgets/aura_power.slint:63
-msgctxt "AuraPowerGroup"
-msgid "Shutdown"
-msgstr "Вимкнення"
-
-#: rog-control-center/ui/widgets/aura_power.slint:102
-msgctxt "AuraPowerGroupOld"
-msgid "Zone Selection"
-msgstr "Вибір зони"
-
-#: rog-control-center/ui/widgets/aura_power.slint:114
-msgctxt "AuraPowerGroupOld"
-msgid "Boot"
-msgstr "Завантаження"
-
-#: rog-control-center/ui/widgets/aura_power.slint:124
-msgctxt "AuraPowerGroupOld"
-msgid "Awake"
-msgstr "Робота"
-
-#: rog-control-center/ui/widgets/aura_power.slint:134
-msgctxt "AuraPowerGroupOld"
-msgid "Sleep"
-msgstr "Сон"
-
-#: rog-control-center/ui/types/aura_types.slint:52
-msgctxt "Aura power zone"
-msgid "Logo"
-msgstr "Логотип"
-
-#: rog-control-center/ui/types/aura_types.slint:53 rog-control-center/ui/types/aura_types.slint:63
-msgctxt "Aura power zone"
-msgid "Keyboard"
-msgstr "Клавіатура"
-
-#: rog-control-center/ui/types/aura_types.slint:54 rog-control-center/ui/types/aura_types.slint:64
-msgctxt "Aura power zone"
-msgid "Lightbar"
-msgstr "Світлова панель"
-
-#: rog-control-center/ui/types/aura_types.slint:55
-msgctxt "Aura power zone"
-msgid "Lid"
-msgstr "Кришка"
-
-#: rog-control-center/ui/types/aura_types.slint:56
-msgctxt "Aura power zone"
-msgid "Rear Glow"
-msgstr "Заднє світіння"
-
-#: rog-control-center/ui/types/aura_types.slint:57 rog-control-center/ui/types/aura_types.slint:65
-msgctxt "Aura power zone"
-msgid "Keyboard and Lightbar"
-msgstr "Клавіатура та світлова панель"
-
-#: rog-control-center/ui/types/aura_types.slint:58
-msgctxt "Aura power zone"
-msgid "Ally"
-msgstr "Ally"
-
-#: rog-control-center/ui/types/aura_types.slint:68
-msgctxt "Aura brightness"
-msgid "Off"
-msgstr "Вимкнено"
-
-#: rog-control-center/ui/types/aura_types.slint:69
-msgctxt "Aura brightness"
-msgid "Low"
-msgstr "Низька"
-
-#: rog-control-center/ui/types/aura_types.slint:70
-msgctxt "Aura brightness"
-msgid "Med"
-msgstr "Середня"
-
-#: rog-control-center/ui/types/aura_types.slint:71
-msgctxt "Aura brightness"
-msgid "High"
-msgstr "Висока"
-
-#: rog-control-center/ui/types/aura_types.slint:76 rog-control-center/ui/types/aura_types.slint:91
-msgctxt "Basic aura mode"
-msgid "Static"
-msgstr "Статичний"
-
-#: rog-control-center/ui/types/aura_types.slint:77 rog-control-center/ui/types/aura_types.slint:92
-msgctxt "Basic aura mode"
-msgid "Breathe"
-msgstr "Дихання"
-
-#: rog-control-center/ui/types/aura_types.slint:78 rog-control-center/ui/types/aura_types.slint:93
-msgctxt "Basic aura mode"
-msgid "Strobe"
-msgstr "Стробоскоп"
-
-#: rog-control-center/ui/types/aura_types.slint:79
-msgctxt "Basic aura mode"
-msgid "Rainbow"
-msgstr "Веселка"
-
-#: rog-control-center/ui/types/aura_types.slint:80
-msgctxt "Basic aura mode"
-msgid "Star"
-msgstr "Зірка"
-
-#: rog-control-center/ui/types/aura_types.slint:81
-msgctxt "Basic aura mode"
-msgid "Rain"
-msgstr "Дощ"
-
-#: rog-control-center/ui/types/aura_types.slint:82
-msgctxt "Basic aura mode"
-msgid "Highlight"
-msgstr "Підсвічування"
-
-#: rog-control-center/ui/types/aura_types.slint:83
-msgctxt "Basic aura mode"
-msgid "Laser"
-msgstr "Лазер"
-
-#: rog-control-center/ui/types/aura_types.slint:84
-msgctxt "Basic aura mode"
-msgid "Ripple"
-msgstr "Хвиля"
-
-#: rog-control-center/ui/types/aura_types.slint:85
-msgctxt "Basic aura mode"
-msgid "Nothing"
-msgstr "Нічого"
-
-#: rog-control-center/ui/types/aura_types.slint:86
-msgctxt "Basic aura mode"
-msgid "Pulse"
-msgstr "Пульс"
-
-#: rog-control-center/ui/types/aura_types.slint:87
-msgctxt "Basic aura mode"
-msgid "Comet"
-msgstr "Комета"
-
-#: rog-control-center/ui/types/aura_types.slint:88
-msgctxt "Basic aura mode"
-msgid "Flash"
-msgstr "Спалах"
-
-#: rog-control-center/ui/types/aura_types.slint:100
-msgctxt "Aura zone"
-msgid "None"
-msgstr "Немає"
-
-#: rog-control-center/ui/types/aura_types.slint:101
-msgctxt "Aura zone"
-msgid "Key1"
-msgstr "Клавіша 1"
-
-#: rog-control-center/ui/types/aura_types.slint:102
-msgctxt "Aura zone"
-msgid "Key2"
-msgstr "Клавіша 2"
-
-#: rog-control-center/ui/types/aura_types.slint:103
-msgctxt "Aura zone"
-msgid "Key3"
-msgstr "Клавіша 3"
-
-#: rog-control-center/ui/types/aura_types.slint:104
-msgctxt "Aura zone"
-msgid "Key4"
-msgstr "Клавіша 4"
-
-#: rog-control-center/ui/types/aura_types.slint:105
-msgctxt "Aura zone"
-msgid "Logo"
-msgstr "Логотип"
-
-#: rog-control-center/ui/types/aura_types.slint:106
-msgctxt "Aura zone"
-msgid "Lightbar Left"
-msgstr "Світлова панель зліва"
-
-#: rog-control-center/ui/types/aura_types.slint:107
-msgctxt "Aura zone"
-msgid "Lightbar Right"
-msgstr "Світлова панель справа"
-
-#: rog-control-center/ui/types/aura_types.slint:111
-msgctxt "Aura direction"
-msgid "Right"
-msgstr "Вправо"
-
-#: rog-control-center/ui/types/aura_types.slint:112
-msgctxt "Aura direction"
-msgid "Left"
-msgstr "Вліво"
-
-#: rog-control-center/ui/types/aura_types.slint:113
-msgctxt "Aura direction"
-msgid "Up"
-msgstr "Вгору"
-
-#: rog-control-center/ui/types/aura_types.slint:114
-msgctxt "Aura direction"
-msgid "Down"
-msgstr "Вниз"
-
-#: rog-control-center/ui/types/aura_types.slint:118
-msgctxt "Aura speed"
-msgid "Low"
-msgstr "Низька"
-
-#: rog-control-center/ui/types/aura_types.slint:119
-msgctxt "Aura speed"
-msgid "Medium"
-msgstr "Середня"
-
-#: rog-control-center/ui/types/aura_types.slint:120
-msgctxt "Aura speed"
-msgid "High"
-msgstr "Висока"
-

rog-control-center/ui/pages/about.slint

@@ -17,7 +17,7 @@ export component PageAbout inherits VerticalLayout {
 
             Text {
                 wrap: TextWrap.word-wrap;
-                text: "You need to use kernel version 6.19 to use this software";
+                text: "You will require a kernel built with my work from here: https://github.com/flukejones/linux";
             }
 
             Text {
@@ -43,6 +43,10 @@ export component PageAbout inherits VerticalLayout {
                 text: "- [ ] Slash control";
             }
 
+            Text {
+                text: "- [ ] Supergfx control";
+            }
+
             Text {
                 text: "- [ ] Screenpad controls";
             }

rog-scsi/src/builtin_modes.rs

@@ -177,12 +177,6 @@ pub enum AuraMode {
     DoubleFade = 14,
 }
 
-#[cfg(feature = "dbus")]
-impl zbus::zvariant::Basic for AuraMode {
-    const SIGNATURE_CHAR: char = 'u';
-    const SIGNATURE_STR: &'static str = "u";
-}
-
 impl AuraMode {
     pub fn list() -> [String; 15] {
         [

rog-slash/src/data.rs

@@ -12,13 +12,12 @@ use crate::usb::{PROD_ID1, PROD_ID1_STR, PROD_ID2, PROD_ID2_STR};
 
 #[derive(Default, Debug, Copy, Clone, PartialEq, Eq, Deserialize, Serialize)]
 pub enum SlashType {
-    GA403_2024,
+    GA403,
-    GA403_2025,
+    GA403W,
-    GA605_2024,
+    GA605,
-    GA605_2025,
+    GU605,
-    GU605_2024,
+    GU605C,
-    GU605_2025,
+    G614F,
-    G614_2025,
     #[default]
     Unsupported,
 }
@@ -26,26 +25,24 @@ pub enum SlashType {
 impl SlashType {
     pub const fn prod_id(&self) -> u16 {
         match self {
-            SlashType::GA403_2025 => PROD_ID2,
+            SlashType::GA403W => PROD_ID2,
-            SlashType::GA403_2024 => PROD_ID1,
+            SlashType::GA403 => PROD_ID1,
-            SlashType::GA605_2025 => PROD_ID2,
+            SlashType::GA605 => PROD_ID2,
-            SlashType::GA605_2024 => PROD_ID2,
+            SlashType::GU605 => PROD_ID1,
-            SlashType::GU605_2025 => PROD_ID2,
+            SlashType::GU605C => PROD_ID2,
-            SlashType::GU605_2024 => PROD_ID1,
+            SlashType::G614F => PROD_ID2,
-            SlashType::G614_2025 => PROD_ID2,
             SlashType::Unsupported => 0,
         }
     }
 
     pub const fn prod_id_str(&self) -> &str {
         match self {
-            SlashType::GA403_2025 => PROD_ID2_STR,
+            SlashType::GA403W => PROD_ID2_STR,
-            SlashType::GA403_2024 => PROD_ID1_STR,
+            SlashType::GA403 => PROD_ID1_STR,
-            SlashType::GA605_2025 => PROD_ID2_STR,
+            SlashType::GA605 => PROD_ID2_STR,
-            SlashType::GA605_2024 => PROD_ID2_STR,
+            SlashType::GU605 => PROD_ID1_STR,
-            SlashType::GU605_2025 => PROD_ID2_STR,
+            SlashType::GU605C => PROD_ID2_STR,
-            SlashType::GU605_2024 => PROD_ID1_STR,
+            SlashType::G614F => PROD_ID2_STR,
-            SlashType::G614_2025 => PROD_ID2_STR,
             SlashType::Unsupported => "",
         }
     }
@@ -53,24 +50,17 @@ impl SlashType {
     pub fn from_dmi() -> Self {
         let board_name = DMIID::new().unwrap_or_default().board_name.to_uppercase();
         if board_name.contains("G614F") {
-            SlashType::G614_2025
+            SlashType::G614F
-        } else if [
+        } else if board_name.contains("GA403W") {
-            "GA403W", "GA403UH", "GA403UM", "GA403UP",
+            SlashType::GA403W
-        ]
-        .iter()
-        .any(|s| board_name.contains(s))
-        {
-            SlashType::GA403_2025
         } else if board_name.contains("GA403") {
-            SlashType::GA403_2024
+            SlashType::GA403
-        } else if board_name.contains("GA605K") {
-            SlashType::GA605_2025
         } else if board_name.contains("GA605") {
-            SlashType::GA605_2024
+            SlashType::GA605
         } else if board_name.contains("GU605C") {
-            SlashType::GU605_2025
+            SlashType::GU605C
         } else if board_name.contains("GU605") {
-            SlashType::GU605_2024
+            SlashType::GU605
         } else {
             SlashType::Unsupported
         }
@@ -82,13 +72,12 @@ impl FromStr for SlashType {
 
     fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
         Ok(match s.to_uppercase().as_str() {
-            "GA403_2025" => Self::GA403_2025,
+            "GA403W" => Self::GA403W,
-            "GA403_2024" => Self::GA403_2024,
+            "GA403" => Self::GA403,
-            "GA605_2025" => Self::GA605_2025,
+            "GA605" => Self::GA605,
-            "GA605_2024" => Self::GA605_2024,
+            "GU605C" => Self::GU605C,
-            "GU605_2025" => Self::GU605_2025,
+            "GU605" => Self::GU605,
-            "GU605_2024" => Self::GU605_2024,
+            "G614FR" => Self::G614F,
-            "G614_2025" => Self::G614_2025,
             _ => Self::Unsupported,
         })
     }

rog-slash/src/usb.rs

@@ -39,24 +39,17 @@ pub fn get_slash_type() -> SlashType {
         .unwrap_or_default();
     let board_name = dmi.board_name.to_uppercase();
     if board_name.contains("G614F") {
-        SlashType::G614_2025
+        SlashType::G614F
-    } else if [
+    } else if board_name.contains("GA403W") {
-        "GA403W", "GA403UH", "GA403UM", "GA403UP",
+        SlashType::GA403W
-    ]
-    .iter()
-    .any(|s| board_name.contains(s))
-    {
-        SlashType::GA403_2025
     } else if board_name.contains("GA403") {
-        SlashType::GA403_2024
+        SlashType::GA403
-    } else if board_name.contains("GA605K") {
-        SlashType::GA605_2025
     } else if board_name.contains("GA605") {
-        SlashType::GA605_2024
+        SlashType::GA605
     } else if board_name.contains("GU605C") {
-        SlashType::GU605_2025
+        SlashType::GU605C
     } else if board_name.contains("GU605") {
-        SlashType::GU605_2024
+        SlashType::GU605
     } else {
         SlashType::Unsupported
     }
@@ -64,13 +57,12 @@ pub fn get_slash_type() -> SlashType {
 
 pub const fn report_id(slash_type: SlashType) -> u8 {
     match slash_type {
-        SlashType::GA403_2025 => REPORT_ID_19B6,
+        SlashType::GA403W => REPORT_ID_19B6,
-        SlashType::GA403_2024 => REPORT_ID_193B,
+        SlashType::GA403 => REPORT_ID_193B,
-        SlashType::GA605_2025 => REPORT_ID_19B6,
+        SlashType::GA605 => REPORT_ID_19B6,
-        SlashType::GA605_2024 => REPORT_ID_19B6,
+        SlashType::G614F => REPORT_ID_19B6,
-        SlashType::GU605_2025 => REPORT_ID_19B6,
+        SlashType::GU605 => REPORT_ID_193B,
-        SlashType::GU605_2024 => REPORT_ID_193B,
+        SlashType::GU605C => REPORT_ID_19B6,
-        SlashType::G614_2025 => REPORT_ID_19B6,
         SlashType::Unsupported => REPORT_ID_19B6,
     }
 }

rust-toolchain

@@ -1 +0,0 @@
-stable