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

feat: refactor cli interface

Browse Source
This commit is contained in:
Denis Benato
2026-01-13 23:50:31 +01:00
parent b521a9ffc1
commit 20cbddb6fa
9 changed files with 579 additions and 604 deletions
Download Patch File Download Diff File Expand all files Collapse all files

39
Cargo.lock generated
View File

@@ -151,6 +151,38 @@ dependencies = [
"syn 2.0.114", "syn 2.0.114",
] ]
[[package]]
name = "argh"
version = "0.1.13"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "34ff18325c8a36b82f992e533ece1ec9f9a9db446bd1c14d4f936bac88fcd240"
dependencies = [
"argh_derive",
"argh_shared",
"rust-fuzzy-search",
]
[[package]]
name = "argh_derive"
version = "0.1.13"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "adb7b2b83a50d329d5d8ccc620f5c7064028828538bdf5646acd60dc1f767803"
dependencies = [
"argh_shared",
"proc-macro2",
"quote",
"syn 2.0.114",
]
[[package]]
name = "argh_shared"
version = "0.1.13"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a464143cc82dedcdc3928737445362466b7674b5db4e2eb8e869846d6d84f4f6"
dependencies = [
"serde",
]
[[package]] [[package]]
name = "arrayref" name = "arrayref"
version = "0.3.9" version = "0.3.9"
@@ -182,6 +214,7 @@ dependencies = [
name = "asusctl" name = "asusctl"
version = "6.2.0" version = "6.2.0"
dependencies = [ dependencies = [
"argh",
"dmi_id", "dmi_id",
"env_logger", "env_logger",
"gumdrop", "gumdrop",
@@ -4621,6 +4654,12 @@ dependencies = [
"libusb1-sys", "libusb1-sys",
] ]
[[package]]
name = "rust-fuzzy-search"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a157657054ffe556d8858504af8a672a054a6e0bd9e8ee531059100c0fa11bb2"
[[package]] [[package]]
name = "rustc-hash" name = "rustc-hash"
version = "1.1.0" version = "1.1.0"

1
asusctl/Cargo.toml
View File

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

169
asusctl/src/anime_cli.rs
View File

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

408
asusctl/src/aura_cli.rs
View File

@@ -1,68 +1,66 @@
use std::str::FromStr; use std::str::FromStr;
use gumdrop::Options; use argh::FromArgs;
use rog_aura::error::Error; use rog_aura::error::Error;
use rog_aura::{AuraEffect, AuraModeNum, AuraZone, Colour, Direction, Speed}; use rog_aura::{AuraEffect, AuraModeNum, AuraZone, Colour, Direction, Speed};
#[derive(Options, Debug)] #[derive(FromArgs, Debug, Clone)]
#[argh(
subcommand,
name = "aura-power-old",
description = "aura power (old api)"
)]
pub struct LedPowerCommand1 { pub struct LedPowerCommand1 {
#[options(help = "print help message")] #[argh(
pub help: bool, option,
#[options(meta = "", help = "Control if LEDs enabled while awake <true/false>")] description = "control if LEDs enabled while awake <true/false>"
)]
pub awake: Option<bool>, 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, 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, pub lightbar: bool,
#[options(meta = "", help = "Control boot animations <true/false>")]
#[argh(option, description = "control boot animations <true/false>")]
pub boot: Option<bool>, pub boot: Option<bool>,
#[options(meta = "", help = "Control suspend animations <true/false>")]
#[argh(option, description = "control suspend animations <true/false>")]
pub sleep: Option<bool>, pub sleep: Option<bool>,
} }
#[derive(Options, Debug)] #[derive(FromArgs, Debug, Clone)]
#[argh(subcommand, name = "aura-power", description = "aura power")]
pub struct LedPowerCommand2 { pub struct LedPowerCommand2 {
#[options(help = "print help message")] #[argh(subcommand)]
pub help: bool,
#[options(command)]
pub command: Option<SetAuraZoneEnabled>, pub command: Option<SetAuraZoneEnabled>,
} }
#[derive(Options, Debug)] /// Subcommands to enable/disable specific aura zones
#[derive(FromArgs, Debug, Clone)]
#[argh(subcommand)]
pub enum SetAuraZoneEnabled { pub enum SetAuraZoneEnabled {
/// Applies to both old and new models Keyboard(KeyboardPower),
#[options(help = "")] Logo(LogoPower),
Keyboard(AuraPowerStates), Lightbar(LightbarPower),
#[options(help = "")] Lid(LidPower),
Logo(AuraPowerStates), RearGlow(RearGlowPower),
#[options(help = "")] Ally(AllyPower),
Lightbar(AuraPowerStates),
#[options(help = "")]
Lid(AuraPowerStates),
#[options(help = "")]
RearGlow(AuraPowerStates),
#[options(help = "")]
Ally(AuraPowerStates),
} }
#[derive(Debug, Clone, Options)] /// Keyboard brightness argument helper
pub struct AuraPowerStates { #[derive(Debug, Clone)]
#[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 { pub struct LedBrightness {
level: Option<u8>, level: Option<u8>,
} }
impl LedBrightness { impl LedBrightness {
pub fn new(level: Option<u8>) -> Self { pub fn new(level: Option<u8>) -> Self {
LedBrightness { level } LedBrightness { level }
@@ -72,176 +70,296 @@ impl LedBrightness {
self.level self.level
} }
} }
impl FromStr for LedBrightness { impl FromStr for LedBrightness {
type Err = Error; type Err = Error;
fn from_str(s: &str) -> Result<Self, Self::Err> { fn from_str(s: &str) -> Result<Self, Self::Err> {
let s = s.to_lowercase(); let s = s.to_lowercase();
match s.as_str() { match s.as_str() {
"off" => Ok(LedBrightness { level: Some(0x00) }), "off" => Ok(Self::new(Some(0x00))),
"low" => Ok(LedBrightness { level: Some(0x01) }), "low" => Ok(Self::new(Some(0x01))),
"med" => Ok(LedBrightness { level: Some(0x02) }), "med" => Ok(Self::new(Some(0x02))),
"high" => Ok(LedBrightness { level: Some(0x03) }), "high" => Ok(Self::new(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 ToString for LedBrightness { impl ToString for LedBrightness {
fn to_string(&self) -> String { fn to_string(&self) -> String {
let s = match self.level { match self.level {
Some(0x00) => "low", Some(0x00) => "off".to_owned(),
Some(0x01) => "med", Some(0x01) => "low".to_owned(),
Some(0x02) => "high", Some(0x02) => "med".to_owned(),
_ => "unknown", Some(0x03) => "high".to_owned(),
}; _ => "unknown".to_owned(),
s.to_owned() }
} }
} }
#[derive(Debug, Clone, Options, Default)] #[derive(FromArgs, Debug, Clone, 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 { pub struct SingleSpeed {
#[options(help = "print help message")] #[argh(option, description = "set the speed: low, med, high")]
help: bool,
#[options(no_long, meta = "WORD", help = "set the speed: low, med, high")]
pub speed: Speed, pub speed: Speed,
#[options(
no_long, #[argh(
meta = "", option,
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, pub zone: AuraZone,
} }
#[derive(Debug, Clone, Options, Default)] /// Single speed effect with direction
#[derive(FromArgs, Debug, Clone, Default)]
#[argh(
subcommand,
name = "rainbow-wave",
description = "single speed effect with direction"
)]
pub struct SingleSpeedDirection { pub struct SingleSpeedDirection {
#[options(help = "print help message")] #[argh(option, description = "set the direction: up, down, left, right")]
help: bool,
#[options(no_long, meta = "", help = "set the direction: up, down, left, right")]
pub direction: Direction, 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, pub speed: Speed,
#[options(
no_long, #[argh(
meta = "", option,
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, pub zone: AuraZone,
} }
#[derive(Debug, Clone, Default, Options)] /// Static single-colour effect
#[derive(FromArgs, Debug, Clone, Default)]
#[argh(
subcommand,
name = "static",
description = "static single-colour effect"
)]
pub struct SingleColour { pub struct SingleColour {
#[options(help = "print help message")] #[argh(option, description = "set the RGB value e.g. ff00ff")]
help: bool,
#[options(no_long, meta = "", help = "set the RGB value e.g, ff00ff")]
pub colour: Colour, pub colour: Colour,
#[options(
no_long, #[argh(
meta = "", option,
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, pub zone: AuraZone,
} }
#[derive(Debug, Clone, Default, Options)] /// Single-colour effect with speed
#[derive(FromArgs, Debug, Clone, Default)]
#[argh(
subcommand,
name = "highlight",
description = "single-colour effect with speed"
)]
pub struct SingleColourSpeed { pub struct SingleColourSpeed {
#[options(help = "print help message")] #[argh(option, description = "set the RGB value e.g. ff00ff")]
help: bool,
#[options(no_long, meta = "", help = "set the RGB value e.g, ff00ff")]
pub colour: Colour, 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, pub speed: Speed,
#[options(
no_long, #[argh(
meta = "", option,
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, pub zone: AuraZone,
} }
#[derive(Debug, Clone, Options, Default)] /// Two-colour breathing effect
#[derive(FromArgs, Debug, Clone, Default)]
#[argh(
subcommand,
name = "breathe",
description = "two-colour breathing effect"
)]
pub struct TwoColourSpeed { pub struct TwoColourSpeed {
#[options(help = "print help message")] #[argh(option, description = "set the first RGB value e.g. ff00ff")]
help: bool,
#[options(no_long, meta = "", help = "set the first RGB value e.g, ff00ff")]
pub colour: Colour, 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, 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, pub speed: Speed,
#[options(
no_long, #[argh(
meta = "", option,
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, pub zone: AuraZone,
} }
#[derive(Debug, Clone, Default, Options)] /// Multi-zone colour settings
#[derive(FromArgs, Debug, Clone, Default)]
#[allow(dead_code)] #[allow(dead_code)]
#[argh(description = "multi-zone colour settings")]
pub struct MultiZone { pub struct MultiZone {
#[options(help = "print help message")] #[argh(option, short = 'a', description = "set the RGB value e.g. ff00ff")]
help: bool,
#[options(short = "a", meta = "", help = "set the RGB value e.g, ff00ff")]
pub colour1: Colour, 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, 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, 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, pub colour4: Colour,
} }
#[derive(Debug, Clone, Default, Options)] /// Multi-colour with speed
#[derive(FromArgs, Debug, Clone, Default)]
#[allow(dead_code)] #[allow(dead_code)]
#[argh(description = "multi-colour with speed")]
pub struct MultiColourSpeed { pub struct MultiColourSpeed {
#[options(help = "print help message")] #[argh(option, short = 'a', description = "set the RGB value e.g. ff00ff")]
help: bool,
#[options(short = "a", meta = "", help = "set the RGB value e.g, ff00ff")]
pub colour1: Colour, 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, 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, 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, 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, pub speed: Speed,
} }
/// Byte value for setting the built-in mode. /// Builtin aura effects
/// #[derive(FromArgs, Debug)]
/// Enum corresponds to the required integer value #[argh(subcommand)]
// NOTE: The option names here must match those in rog-aura crate
#[derive(Options)]
pub enum SetAuraBuiltin { pub enum SetAuraBuiltin {
#[options(help = "set a single static colour")] Static(SingleColour), // 0
Static(SingleColour), // 0 Breathe(TwoColourSpeed), // 1
#[options(help = "pulse between one or two colours")] RainbowCycle(SingleSpeed), // 2
Breathe(TwoColourSpeed), // 1
#[options(help = "strobe through all colours")]
RainbowCycle(SingleSpeed), // 2
#[options(help = "rainbow cycling in one of four directions")]
RainbowWave(SingleSpeedDirection), // 3 RainbowWave(SingleSpeedDirection), // 3
#[options(help = "rain pattern mimicking raindrops")] Stars(TwoColourSpeed), // 4
Stars(TwoColourSpeed), // 4 Rain(SingleSpeed), // 5
#[options(help = "rain pattern of three preset colours")] Highlight(SingleColourSpeed), // 6
Rain(SingleSpeed), // 5 Laser(SingleColourSpeed), // 7
#[options(help = "pressed keys are highlighted to fade")] Ripple(SingleColourSpeed), // 8
Highlight(SingleColourSpeed), // 6 Pulse(SingleColour), // 10
#[options(help = "pressed keys generate horizontal laser")] Comet(SingleColour), // 11
Laser(SingleColourSpeed), // 7 Flash(SingleColour), // 12
#[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 { impl Default for SetAuraBuiltin {

137
asusctl/src/cli_opts.rs
View File

@@ -1,4 +1,4 @@
use gumdrop::Options; use argh::FromArgs;
use rog_platform::platform::PlatformProfile; use rog_platform::platform::PlatformProfile;
use crate::anime_cli::AnimeCommand; use crate::anime_cli::AnimeCommand;
@@ -7,128 +7,131 @@ use crate::fan_curve_cli::FanCurveCommand;
use crate::scsi_cli::ScsiCommand; use crate::scsi_cli::ScsiCommand;
use crate::slash_cli::SlashCommand; use crate::slash_cli::SlashCommand;
#[derive(Default, Options)] #[derive(FromArgs, Default, Debug)]
/// asusctl command-line options
pub struct CliStart { pub struct CliStart {
#[options(help_flag, help = "print help message")] #[argh(switch, description = "show program version number")]
pub help: bool,
#[options(help = "show program version number")]
pub version: bool, pub version: bool,
#[options(help = "show supported functions of this laptop")]
#[argh(switch, description = "show supported functions of this laptop")]
pub show_supported: bool, pub show_supported: bool,
#[options(meta = "", help = "<off, low, med, high>")]
#[argh(option, description = "keyboard brightness <off, low, med, high>")]
pub kbd_bright: Option<LedBrightness>, pub kbd_bright: Option<LedBrightness>,
#[options(help = "Toggle to next keyboard brightness")]
#[argh(switch, description = "toggle to next keyboard brightness")]
pub next_kbd_bright: bool, pub next_kbd_bright: bool,
#[options(help = "Toggle to previous keyboard brightness")]
#[argh(switch, description = "toggle to previous keyboard brightness")]
pub prev_kbd_bright: bool, pub prev_kbd_bright: bool,
#[options(meta = "", help = "Set your battery charge limit <20-100>")]
#[argh(option, description = "set your battery charge limit <20-100>")]
pub chg_limit: Option<u8>, pub chg_limit: Option<u8>,
#[options(help = "Toggle one-shot battery charge to 100%")]
#[argh(switch, description = "toggle one-shot battery charge to 100%")]
pub one_shot_chg: bool, pub one_shot_chg: bool,
#[options(command)]
#[argh(subcommand)]
pub command: Option<CliCommand>, pub command: Option<CliCommand>,
} }
#[derive(Options)] /// Top-level subcommands for asusctl
#[derive(FromArgs, Debug)]
#[argh(subcommand)]
pub enum CliCommand { pub enum CliCommand {
#[options(help = "Set the keyboard lighting from built-in modes")]
Aura(LedModeCommand), Aura(LedModeCommand),
#[options(help = "Set the LED power states")]
AuraPowerOld(LedPowerCommand1), AuraPowerOld(LedPowerCommand1),
#[options(help = "Set the LED power states")]
AuraPower(LedPowerCommand2), AuraPower(LedPowerCommand2),
#[options(help = "Set or select platform_profile")]
Profile(ProfileCommand), Profile(ProfileCommand),
#[options(help = "Set, select, or modify fan curves if supported")]
FanCurve(FanCurveCommand), FanCurve(FanCurveCommand),
#[options(help = "Set the graphics mode (obsoleted by supergfxctl)")]
Graphics(GraphicsCommand), Graphics(GraphicsCommand),
#[options(name = "anime", help = "Manage AniMe Matrix")]
Anime(AnimeCommand), Anime(AnimeCommand),
#[options(name = "slash", help = "Manage Slash Ledbar")]
Slash(SlashCommand), Slash(SlashCommand),
#[options(name = "scsi", help = "Manage SCSI external drive")]
Scsi(ScsiCommand), 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), Armoury(ArmouryCommand),
#[options(name = "backlight", help = "Set screen backlight levels")]
Backlight(BacklightCommand), Backlight(BacklightCommand),
} }
#[derive(Debug, Clone, Options)] #[derive(FromArgs, Debug, Clone, Default)]
#[argh(subcommand, name = "profile", description = "profile management")]
pub struct ProfileCommand { pub struct ProfileCommand {
#[options(help = "print help message")] #[argh(switch, description = "toggle to next profile in list")]
pub help: bool,
#[options(help = "toggle to next profile in list")]
pub next: bool, pub next: bool,
#[options(help = "list available profiles")] #[argh(switch, description = "list available profiles")]
pub list: bool, pub list: bool,
#[options(help = "get profile")] #[argh(switch, description = "get profile")]
pub profile_get: bool, pub profile_get: bool,
#[options(meta = "", help = "set the active profile")] #[argh(option, description = "set the active profile")]
pub profile_set: Option<PlatformProfile>, pub profile_set: Option<PlatformProfile>,
#[options(short = "a", meta = "", help = "set the profile to use on AC power")] #[argh(
option,
short = 'a',
description = "set the profile to use on AC power"
)]
pub profile_set_ac: Option<PlatformProfile>, pub profile_set_ac: Option<PlatformProfile>,
#[options( #[argh(
short = "b", option,
meta = "", short = 'b',
help = "set the profile to use on battery power" description = "set the profile to use on battery power"
)] )]
pub profile_set_bat: Option<PlatformProfile>, pub profile_set_bat: Option<PlatformProfile>,
} }
#[derive(Options)] #[derive(FromArgs, Debug, Default)]
#[argh(subcommand, name = "aura", description = "led mode commands")]
pub struct LedModeCommand { pub struct LedModeCommand {
#[options(help = "print help message")] #[argh(switch, description = "switch to next aura mode")]
pub help: bool,
#[options(help = "switch to next aura mode")]
pub next_mode: bool, pub next_mode: bool,
#[options(help = "switch to previous aura mode")]
#[argh(switch, description = "switch to previous aura mode")]
pub prev_mode: bool, pub prev_mode: bool,
#[options(command)]
#[argh(subcommand)]
pub command: Option<SetAuraBuiltin>, pub command: Option<SetAuraBuiltin>,
} }
#[derive(Options)] #[derive(FromArgs, Debug, Default)]
pub struct GraphicsCommand { #[argh(
#[options(help = "print help message")] subcommand,
pub help: bool, name = "graphics",
} description = "graphics command (deprecated)"
)]
pub struct GraphicsCommand {}
#[derive(Options, Debug)] #[derive(FromArgs, Debug, Default)]
#[argh(
subcommand,
name = "armoury",
description = "armoury / firmware attributes"
)]
pub struct ArmouryCommand { pub struct ArmouryCommand {
#[options(help = "print help message")] #[argh(
pub help: bool, positional,
#[options( description = "append each value name followed by the value to set. `-1` sets to default"
free,
help = "append each value name followed by the value to set. `-1` sets to default"
)] )]
pub free: Vec<String>, pub free: Vec<String>,
} }
#[derive(Options)] #[derive(FromArgs, Debug, Default)]
#[argh(subcommand, name = "backlight", description = "backlight options")]
pub struct BacklightCommand { pub struct BacklightCommand {
#[options(help = "print help message")] #[argh(option, description = "set screen brightness <0-100>")]
pub help: bool,
#[options(meta = "", help = "Set screen brightness <0-100>")]
pub screenpad_brightness: Option<i32>, pub screenpad_brightness: Option<i32>,
#[options(
meta = "", #[argh(
help = "Set screenpad gamma brightness 0.5 - 2.2, 1.0 == linear" option,
description = "set screenpad gamma brightness 0.5 - 2.2, 1.0 == linear"
)] )]
pub screenpad_gamma: Option<f32>, pub screenpad_gamma: Option<f32>,
#[options(
meta = "", #[argh(
help = "Set screenpad brightness to sync with primary display" option,
description = "set screenpad brightness to sync with primary display"
)] )]
pub sync_screenpad_brightness: Option<bool>, pub sync_screenpad_brightness: Option<bool>,
} }

45
asusctl/src/fan_curve_cli.rs
View File

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

316
asusctl/src/main.rs
View File

@@ -1,19 +1,18 @@
use std::convert::TryFrom; use std::convert::TryFrom;
use std::env::args;
use std::path::Path; use std::path::Path;
use std::process::Command; use std::process::Command;
use std::thread::sleep; use std::thread::sleep;
use anime_cli::{AnimeActions, AnimeCommand}; use anime_cli::{AnimeActions, AnimeCommand};
use argh;
use aura_cli::{LedPowerCommand1, LedPowerCommand2}; use aura_cli::{LedPowerCommand1, LedPowerCommand2};
use dmi_id::DMIID; use dmi_id::DMIID;
use fan_curve_cli::FanCurveCommand; use fan_curve_cli::FanCurveCommand;
use gumdrop::{Opt, Options};
use log::{error, info, LevelFilter}; use log::{error, info, LevelFilter};
use rog_anime::usb::get_anime_type; use rog_anime::usb::get_anime_type;
use rog_anime::{AnimTime, AnimeDataBuffer, AnimeDiagonal, AnimeGif, AnimeImage, AnimeType, Vec2}; use rog_anime::{AnimTime, AnimeDataBuffer, AnimeDiagonal, AnimeGif, AnimeImage, AnimeType, Vec2};
use rog_aura::keyboard::{AuraPowerState, LaptopAuraPower}; use rog_aura::keyboard::{AuraPowerState, LaptopAuraPower};
use rog_aura::{self, AuraDeviceType, AuraEffect, PowerZones}; use rog_aura::{self, AuraEffect, PowerZones};
use rog_dbus::asus_armoury::AsusArmouryProxyBlocking; use rog_dbus::asus_armoury::AsusArmouryProxyBlocking;
use rog_dbus::list_iface_blocking; use rog_dbus::list_iface_blocking;
use rog_dbus::scsi_aura::ScsiAuraProxyBlocking; use rog_dbus::scsi_aura::ScsiAuraProxyBlocking;
@@ -32,7 +31,6 @@ use scsi_cli::ScsiCommand;
use zbus::blocking::proxy::ProxyImpl; use zbus::blocking::proxy::ProxyImpl;
use zbus::blocking::Connection; use zbus::blocking::Connection;
use crate::aura_cli::{AuraPowerStates, LedBrightness};
use crate::cli_opts::*; use crate::cli_opts::*;
use crate::slash_cli::SlashCommand; use crate::slash_cli::SlashCommand;
@@ -58,20 +56,7 @@ fn main() {
let self_version = env!("CARGO_PKG_VERSION"); let self_version = env!("CARGO_PKG_VERSION");
println!("Starting version {self_version}"); println!("Starting version {self_version}");
let args: Vec<String> = args().skip(1).collect(); let parsed: CliStart = argh::from_env();
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(); let conn = Connection::system().unwrap();
if let Ok(platform_proxy) = PlatformProxyBlocking::new(&conn).map_err(|e| { if let Ok(platform_proxy) = PlatformProxyBlocking::new(&conn).map_err(|e| {
@@ -225,90 +210,14 @@ fn do_parsed(
Some(CliCommand::Armoury(cmd)) => handle_armoury_command(cmd)?, Some(CliCommand::Armoury(cmd)) => handle_armoury_command(cmd)?,
Some(CliCommand::Backlight(cmd)) => handle_backlight(cmd)?, Some(CliCommand::Backlight(cmd)) => handle_backlight(cmd)?,
None => { None => {
if (!parsed.show_supported if !parsed.show_supported
&& parsed.kbd_bright.is_none() && parsed.kbd_bright.is_none()
&& parsed.chg_limit.is_none() && parsed.chg_limit.is_none()
&& !parsed.next_kbd_bright && !parsed.next_kbd_bright
&& !parsed.prev_kbd_bright && !parsed.prev_kbd_bright
&& !parsed.one_shot_chg) && !parsed.one_shot_chg
|| parsed.help
{ {
println!("{}", CliStart::usage()); println!("No command given. Run 'asusctl --help' for usage and 'asusctl <command> --help' for subcommands.");
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");
} }
} }
} }
@@ -394,13 +303,10 @@ fn do_gfx() {
} }
fn handle_backlight(cmd: &BacklightCommand) -> Result<(), Box<dyn std::error::Error>> { 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.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")?; let backlights = find_iface::<BacklightProxyBlocking>("xyz.ljones.Backlight")?;
for backlight in backlights { for backlight in backlights {
println!("Current screenpad settings:"); println!("Current screenpad settings:");
@@ -434,7 +340,7 @@ fn handle_backlight(cmd: &BacklightCommand) -> Result<(), Box<dyn std::error::Er
} }
fn handle_anime(cmd: &AnimeCommand) -> Result<(), Box<dyn std::error::Error>> { 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_display.is_none()
&& cmd.enable_powersave_anim.is_none() && cmd.enable_powersave_anim.is_none()
&& cmd.brightness.is_none() && cmd.brightness.is_none()
@@ -442,13 +348,9 @@ fn handle_anime(cmd: &AnimeCommand) -> Result<(), Box<dyn std::error::Error>> {
&& cmd.off_when_suspended.is_none() && cmd.off_when_suspended.is_none()
&& cmd.off_when_unplugged.is_none() && cmd.off_when_unplugged.is_none()
&& cmd.off_with_his_head.is_none() && cmd.off_with_his_head.is_none()
&& !cmd.clear) && !cmd.clear
|| cmd.help
{ {
println!("Missing arg or command\n\n{}", cmd.self_usage()); println!("Missing arg or command; run 'asusctl anime --help' for usage");
if let Some(lst) = cmd.self_command_list() {
println!("\n{}", lst);
}
} }
let animes = find_iface::<AnimeProxyBlocking>("xyz.ljones.Anime").map_err(|e| { let animes = find_iface::<AnimeProxyBlocking>("xyz.ljones.Anime").map_err(|e| {
@@ -464,7 +366,7 @@ fn handle_anime(cmd: &AnimeCommand) -> Result<(), Box<dyn std::error::Error>> {
proxy.set_builtins_enabled(enable)?; proxy.set_builtins_enabled(enable)?;
} }
if let Some(bright) = cmd.brightness { if let Some(bright) = cmd.brightness {
proxy.set_brightness(bright)?; proxy.set_brightness(bright.into())?;
} }
if let Some(enable) = cmd.off_when_lid_closed { if let Some(enable) = cmd.off_when_lid_closed {
proxy.set_off_when_lid_closed(enable)?; proxy.set_off_when_lid_closed(enable)?;
@@ -495,11 +397,10 @@ fn handle_anime(cmd: &AnimeCommand) -> Result<(), Box<dyn std::error::Error>> {
if let Some(action) = cmd.command.as_ref() { if let Some(action) = cmd.command.as_ref() {
match action { match action {
AnimeActions::Image(image) => { AnimeActions::Image(image) => {
if image.help_requested() || image.path.is_empty() { if image.path.is_empty() {
println!("Missing arg or command\n\n{}", image.self_usage()); println!(
if let Some(lst) = image.self_command_list() { "Missing arg or command; run 'asusctl anime image --help' for usage"
println!("\n{}", lst); );
}
return Ok(()); return Ok(());
} }
verify_brightness(image.bright); verify_brightness(image.bright);
@@ -516,11 +417,8 @@ fn handle_anime(cmd: &AnimeCommand) -> Result<(), Box<dyn std::error::Error>> {
proxy.write(<AnimeDataBuffer>::try_from(&matrix)?)?; proxy.write(<AnimeDataBuffer>::try_from(&matrix)?)?;
} }
AnimeActions::PixelImage(image) => { AnimeActions::PixelImage(image) => {
if image.help_requested() || image.path.is_empty() { if image.path.is_empty() {
println!("Missing arg or command\n\n{}", image.self_usage()); println!("Missing arg or command; run 'asusctl anime pixel-image --help' for usage");
if let Some(lst) = image.self_command_list() {
println!("\n{}", lst);
}
return Ok(()); return Ok(());
} }
verify_brightness(image.bright); verify_brightness(image.bright);
@@ -535,11 +433,10 @@ fn handle_anime(cmd: &AnimeCommand) -> Result<(), Box<dyn std::error::Error>> {
proxy.write(matrix.into_data_buffer(anime_type)?)?; proxy.write(matrix.into_data_buffer(anime_type)?)?;
} }
AnimeActions::Gif(gif) => { AnimeActions::Gif(gif) => {
if gif.help_requested() || gif.path.is_empty() { if gif.path.is_empty() {
println!("Missing arg or command\n\n{}", gif.self_usage()); println!(
if let Some(lst) = gif.self_command_list() { "Missing arg or command; run 'asusctl anime gif --help' for usage"
println!("\n{}", lst); );
}
return Ok(()); return Ok(());
} }
verify_brightness(gif.bright); verify_brightness(gif.bright);
@@ -569,11 +466,8 @@ fn handle_anime(cmd: &AnimeCommand) -> Result<(), Box<dyn std::error::Error>> {
} }
} }
AnimeActions::PixelGif(gif) => { AnimeActions::PixelGif(gif) => {
if gif.help_requested() || gif.path.is_empty() { if gif.path.is_empty() {
println!("Missing arg or command\n\n{}", gif.self_usage()); println!("Missing arg or command; run 'asusctl anime pixel-gif --help' for usage");
if let Some(lst) = gif.self_command_list() {
println!("\n{}", lst);
}
return Ok(()); return Ok(());
} }
verify_brightness(gif.bright); verify_brightness(gif.bright);
@@ -600,14 +494,8 @@ fn handle_anime(cmd: &AnimeCommand) -> Result<(), Box<dyn std::error::Error>> {
} }
} }
AnimeActions::SetBuiltins(builtins) => { AnimeActions::SetBuiltins(builtins) => {
if builtins.help_requested() || builtins.set.is_none() { if builtins.set.is_none() {
println!( println!("Missing arg; run 'asusctl anime set-builtins --help' for usage");
"\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(()); return Ok(());
} }
@@ -634,24 +522,19 @@ fn verify_brightness(brightness: f32) {
} }
fn handle_slash(cmd: &SlashCommand) -> Result<(), Box<dyn std::error::Error>> { 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.interval.is_none()
&& cmd.show_on_boot.is_none() && cmd.show_on_boot.is_none()
&& cmd.show_on_shutdown.is_none() && cmd.show_on_shutdown.is_none()
&& cmd.show_on_sleep.is_none() && cmd.show_on_sleep.is_none()
&& cmd.show_on_battery.is_none() && cmd.show_on_battery.is_none()
&& cmd.show_battery_warning.is_none() && cmd.show_battery_warning.is_none()
// && cmd.show_on_lid_closed.is_none()
&& cmd.mode.is_none() && cmd.mode.is_none()
&& !cmd.list && !cmd.list
&& !cmd.enable && !cmd.enable
&& !cmd.disable) && !cmd.disable
|| cmd.help
{ {
println!("Missing arg or command\n\n{}", cmd.self_usage()); println!("Missing arg or command; run 'asusctl slash --help' for usage");
if let Some(lst) = cmd.self_command_list() {
println!("\n{}", lst);
}
} }
let slashes = find_iface::<SlashProxyBlocking>("xyz.ljones.Slash")?; let slashes = find_iface::<SlashProxyBlocking>("xyz.ljones.Slash")?;
@@ -702,13 +585,8 @@ fn handle_slash(cmd: &SlashCommand) -> Result<(), Box<dyn std::error::Error>> {
} }
fn handle_scsi(cmd: &ScsiCommand) -> 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() {
|| cmd.help println!("Missing arg or command; run 'asusctl scsi --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 scsis = find_iface::<ScsiAuraProxyBlocking>("xyz.ljones.ScsiAura")?; let scsis = find_iface::<ScsiAuraProxyBlocking>("xyz.ljones.ScsiAura")?;
@@ -774,38 +652,15 @@ fn handle_scsi(cmd: &ScsiCommand) -> Result<(), Box<dyn std::error::Error>> {
fn handle_led_mode(mode: &LedModeCommand) -> 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 { if mode.command.is_none() && !mode.prev_mode && !mode.next_mode {
if !mode.help { println!("Missing arg or command; run 'asusctl aura --help' for usage");
println!("Missing arg or command\n"); // print available modes when possible
} 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()?; let modes = aura.first().unwrap().supported_basic_modes()?;
for command in commands.iter().filter(|command| { println!("Available modes:");
for mode in &modes { for m in modes {
let mut mode = <&str>::from(mode).to_string(); println!(" {:?}", m);
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(()); return Ok(());
} }
@@ -837,10 +692,6 @@ fn handle_led_mode(mode: &LedModeCommand) -> Result<(), Box<dyn std::error::Erro
aura.set_led_mode(modes[pos])?; aura.set_led_mode(modes[pos])?;
} }
} else if let Some(mode) = mode.command.as_ref() { } else if let Some(mode) = mode.command.as_ref() {
if mode.help_requested() {
println!("{}", mode.self_usage());
return Ok(());
}
for aura in aura { for aura in aura {
aura.set_led_mode_data(<AuraEffect>::from(mode))?; aura.set_led_mode_data(<AuraEffect>::from(mode))?;
} }
@@ -863,10 +714,7 @@ fn handle_led_power1(power: &LedPowerCommand1) -> Result<(), Box<dyn std::error:
&& !power.keyboard && !power.keyboard
&& !power.lightbar && !power.lightbar
{ {
if !power.help { println!("Missing arg or command; run 'asusctl aura-power-old --help' for usage");
println!("Missing arg or command\n");
}
println!("{}\n", power.self_usage());
return Ok(()); return Ok(());
} }
@@ -918,51 +766,47 @@ fn handle_led_power2(power: &LedPowerCommand2) -> Result<(), Box<dyn std::error:
continue; continue;
} }
if power.command().is_none() { if power.command.is_none() {
if !power.help { println!("Missing arg or command; run 'asusctl aura-power --help' for usage");
println!("Missing arg or command\n");
}
println!("{}\n", power.self_usage());
println!("Commands available"); 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(()); 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 states = aura.led_power()?;
let mut set = |zone: PowerZones, set_to: &AuraPowerStates| { let mut set =
for state in states.states.iter_mut() { |zone: PowerZones, boot_v: bool, awake_v: bool, sleep_v: bool, shutdown_v: bool| {
if state.zone == zone { for state in states.states.iter_mut() {
state.boot = set_to.boot; if state.zone == zone {
state.awake = set_to.awake; state.boot = boot_v;
state.sleep = set_to.sleep; state.awake = awake_v;
state.shutdown = set_to.shutdown; state.sleep = sleep_v;
break; state.shutdown = shutdown_v;
break;
}
} }
} };
};
if let Some(cmd) = &power.command { if let Some(cmd) = &power.command {
match cmd { match cmd {
aura_cli::SetAuraZoneEnabled::Keyboard(k) => set(PowerZones::Keyboard, k), aura_cli::SetAuraZoneEnabled::Keyboard(k) => {
aura_cli::SetAuraZoneEnabled::Logo(l) => set(PowerZones::Logo, l), set(PowerZones::Keyboard, k.boot, k.awake, k.sleep, k.shutdown)
aura_cli::SetAuraZoneEnabled::Lightbar(l) => set(PowerZones::Lightbar, l), }
aura_cli::SetAuraZoneEnabled::Lid(l) => set(PowerZones::Lid, l), aura_cli::SetAuraZoneEnabled::Logo(l) => {
aura_cli::SetAuraZoneEnabled::RearGlow(r) => set(PowerZones::RearGlow, r), set(PowerZones::Logo, l.boot, l.awake, l.sleep, l.shutdown)
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)
}
} }
} }
@@ -990,14 +834,7 @@ fn handle_throttle_profile(
&& cmd.profile_set_ac.is_none() && cmd.profile_set_ac.is_none()
&& cmd.profile_set_bat.is_none() && cmd.profile_set_bat.is_none()
{ {
if !cmd.help { println!("Missing arg or command; run 'asusctl profile --help' for usage");
println!("Missing arg or command\n");
}
println!("{}", ProfileCommand::usage());
if let Some(lst) = cmd.self_command_list() {
println!("\n{}", lst);
}
return Ok(()); return Ok(());
} }
@@ -1044,14 +881,7 @@ fn handle_fan_curve(
}; };
if !cmd.get_enabled && !cmd.default && cmd.mod_profile.is_none() { if !cmd.get_enabled && !cmd.default && cmd.mod_profile.is_none() {
if !cmd.help { println!("Missing arg or command; run 'asusctl fan-curve --help' for usage");
println!("Missing arg or command\n");
}
println!("{}", FanCurveCommand::usage());
if let Some(lst) = cmd.self_command_list() {
println!("\n{}", lst);
}
return Ok(()); return Ok(());
} }
@@ -1191,7 +1021,7 @@ fn print_firmware_attr(attr: &AsusArmouryProxyBlocking) -> Result<(), Box<dyn st
#[allow(clippy::manual_is_multiple_of, clippy::nonminimal_bool)] #[allow(clippy::manual_is_multiple_of, clippy::nonminimal_bool)]
fn handle_armoury_command(cmd: &ArmouryCommand) -> Result<(), Box<dyn std::error::Error>> { fn handle_armoury_command(cmd: &ArmouryCommand) -> Result<(), Box<dyn std::error::Error>> {
{ {
if cmd.free.is_empty() || (cmd.free.len() % 2 != 0) || cmd.help { if cmd.free.is_empty() || (cmd.free.len() % 2 != 0) {
const USAGE: &str = "Usage: asusctl armoury panel_overdrive 1 nv_dynamic_boost 5"; const USAGE: &str = "Usage: asusctl armoury panel_overdrive 1 nv_dynamic_boost 5";
if cmd.free.len() % 2 != 0 { if cmd.free.len() % 2 != 0 {
println!( println!(

31
asusctl/src/scsi_cli.rs
View File

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

37
asusctl/src/slash_cli.rs
View File

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