mirror of
https://gitlab.com/asus-linux/asusctl.git
synced 2026-02-06 00:15:04 +01:00
311 lines
10 KiB
Rust
311 lines
10 KiB
Rust
use crate::cli_options::SetAuraBuiltin;
|
|
use crate::error::AuraError;
|
|
use gumdrop::Options;
|
|
use serde_derive::{Deserialize, Serialize};
|
|
use std::str::FromStr;
|
|
|
|
pub const STATIC: u8 = 0x00;
|
|
pub const BREATHING: u8 = 0x01;
|
|
pub const STROBE: u8 = 0x02;
|
|
pub const RAINBOW: u8 = 0x03;
|
|
pub const STAR: u8 = 0x04;
|
|
pub const RAIN: u8 = 0x05;
|
|
pub const HIGHLIGHT: u8 = 0x06;
|
|
pub const LASER: u8 = 0x07;
|
|
pub const RIPPLE: u8 = 0x08;
|
|
pub const PULSE: u8 = 0x0a;
|
|
pub const COMET: u8 = 0x0b;
|
|
pub const FLASH: u8 = 0x0c;
|
|
pub const MULTISTATIC: u8 = 0x0d;
|
|
pub const MULTIBREATHE: u8 = 0x0e;
|
|
pub const PER_KEY: u8 = 0xff;
|
|
|
|
#[derive(Debug, Clone, Deserialize, Serialize)]
|
|
pub struct Colour(pub u8, pub u8, pub u8);
|
|
|
|
impl Default for Colour {
|
|
fn default() -> Self {
|
|
Colour(128, 0, 0)
|
|
}
|
|
}
|
|
|
|
impl FromStr for Colour {
|
|
type Err = AuraError;
|
|
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
if s.len() < 6 {
|
|
return Err(AuraError::ParseColour);
|
|
}
|
|
let r = u8::from_str_radix(&s[0..2], 16).or(Err(AuraError::ParseColour))?;
|
|
let g = u8::from_str_radix(&s[2..4], 16).or(Err(AuraError::ParseColour))?;
|
|
let b = u8::from_str_radix(&s[4..6], 16).or(Err(AuraError::ParseColour))?;
|
|
Ok(Colour(r, g, b))
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Copy, Clone, Deserialize, Serialize)]
|
|
pub enum Speed {
|
|
Low = 0xe1,
|
|
Med = 0xeb,
|
|
High = 0xf5,
|
|
}
|
|
impl Default for Speed {
|
|
fn default() -> Self {
|
|
Speed::Med
|
|
}
|
|
}
|
|
impl FromStr for Speed {
|
|
type Err = AuraError;
|
|
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
let s = s.to_lowercase();
|
|
match s.as_str() {
|
|
"low" => Ok(Speed::Low),
|
|
"med" => Ok(Speed::Med),
|
|
"high" => Ok(Speed::High),
|
|
_ => Err(AuraError::ParseSpeed),
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Used for Rainbow mode.
|
|
///
|
|
/// Enum corresponds to the required integer value
|
|
#[derive(Debug, Copy, Clone, Deserialize, Serialize)]
|
|
pub enum Direction {
|
|
Right,
|
|
Left,
|
|
Up,
|
|
Down,
|
|
}
|
|
impl Default for Direction {
|
|
fn default() -> Self {
|
|
Direction::Right
|
|
}
|
|
}
|
|
impl FromStr for Direction {
|
|
type Err = AuraError;
|
|
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
let s = s.to_lowercase();
|
|
match s.as_str() {
|
|
"right" => Ok(Direction::Right),
|
|
"up" => Ok(Direction::Up),
|
|
"down" => Ok(Direction::Down),
|
|
"left" => Ok(Direction::Left),
|
|
_ => Err(AuraError::ParseDirection),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, Options, Default, Deserialize, Serialize)]
|
|
pub struct SingleSpeed {
|
|
#[serde(skip)]
|
|
#[options(help = "print help message")]
|
|
help: bool,
|
|
#[options(no_long, meta = "WORD", help = "set the speed: low, med, high")]
|
|
pub speed: Speed,
|
|
}
|
|
#[derive(Debug, Clone, Options, Default, Deserialize, Serialize)]
|
|
pub struct SingleSpeedDirection {
|
|
#[serde(skip)]
|
|
#[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")]
|
|
pub speed: Speed,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Default, Options, Deserialize, Serialize)]
|
|
pub struct SingleColour {
|
|
#[serde(skip)]
|
|
#[options(help = "print help message")]
|
|
help: bool,
|
|
#[options(no_long, meta = "", help = "set the RGB value e.g, ff00ff")]
|
|
pub colour: Colour,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Default, Options, Deserialize, Serialize)]
|
|
pub struct SingleColourSpeed {
|
|
#[serde(skip)]
|
|
#[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")]
|
|
pub speed: Speed,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Options, Default, Deserialize, Serialize)]
|
|
pub struct TwoColourSpeed {
|
|
#[serde(skip)]
|
|
#[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")]
|
|
pub colour2: Colour,
|
|
#[options(no_long, meta = "", help = "set the speed: low, med, high")]
|
|
pub speed: Speed,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Default, Options, Deserialize, Serialize)]
|
|
pub struct MultiColour {
|
|
#[serde(skip)]
|
|
#[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")]
|
|
pub colour2: Colour,
|
|
#[options(short = "c", meta = "", help = "set the RGB value e.g, ff00ff")]
|
|
pub colour3: Colour,
|
|
#[options(short = "d", meta = "", help = "set the RGB value e.g, ff00ff")]
|
|
pub colour4: Colour,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Default, Options, Deserialize, Serialize)]
|
|
pub struct MultiColourSpeed {
|
|
#[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")]
|
|
pub colour2: Colour,
|
|
#[options(short = "c", meta = "", help = "set the RGB value e.g, ff00ff")]
|
|
pub colour3: Colour,
|
|
#[options(short = "d", meta = "", help = "set the RGB value e.g, ff00ff")]
|
|
pub colour4: Colour,
|
|
#[options(no_long, meta = "", help = "set the speed: low, med, high")]
|
|
pub speed: Speed,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Deserialize, Serialize)]
|
|
pub enum AuraModes {
|
|
Static(SingleColour),
|
|
Breathe(TwoColourSpeed),
|
|
Strobe(SingleSpeed),
|
|
Rainbow(SingleSpeedDirection),
|
|
Star(TwoColourSpeed),
|
|
Rain(SingleSpeed),
|
|
Highlight(SingleColourSpeed),
|
|
Laser(SingleColourSpeed),
|
|
Ripple(SingleColourSpeed),
|
|
Pulse(SingleColour),
|
|
Comet(SingleColour),
|
|
Flash(SingleColour),
|
|
MultiStatic(MultiColour),
|
|
MultiBreathe(MultiColourSpeed),
|
|
LedBrightness(u8),
|
|
// TODO: use a serializable structure for this (KeyColourArray)
|
|
PerKey(Vec<Vec<u8>>),
|
|
}
|
|
|
|
impl From<SetAuraBuiltin> for AuraModes {
|
|
fn from(mode: SetAuraBuiltin) -> Self {
|
|
match mode {
|
|
SetAuraBuiltin::Static(x) => AuraModes::Static(x.into()),
|
|
SetAuraBuiltin::Breathe(x) => AuraModes::Breathe(x.into()),
|
|
SetAuraBuiltin::Strobe(x) => AuraModes::Strobe(x.into()),
|
|
SetAuraBuiltin::Rainbow(x) => AuraModes::Rainbow(x.into()),
|
|
SetAuraBuiltin::Star(x) => AuraModes::Star(x.into()),
|
|
SetAuraBuiltin::Rain(x) => AuraModes::Rain(x.into()),
|
|
SetAuraBuiltin::Highlight(x) => AuraModes::Highlight(x.into()),
|
|
SetAuraBuiltin::Laser(x) => AuraModes::Laser(x.into()),
|
|
SetAuraBuiltin::Ripple(x) => AuraModes::Ripple(x.into()),
|
|
SetAuraBuiltin::Pulse(x) => AuraModes::Pulse(x.into()),
|
|
SetAuraBuiltin::Comet(x) => AuraModes::Comet(x.into()),
|
|
SetAuraBuiltin::Flash(x) => AuraModes::Flash(x.into()),
|
|
SetAuraBuiltin::MultiStatic(x) => AuraModes::MultiStatic(x.into()),
|
|
SetAuraBuiltin::MultiBreathe(x) => AuraModes::MultiBreathe(x.into()),
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Very specific mode conversion required because numbering isn't linear
|
|
impl From<AuraModes> for u8 {
|
|
fn from(mode: AuraModes) -> Self {
|
|
u8::from(&mode)
|
|
}
|
|
}
|
|
|
|
/// Very specific mode conversion required because numbering isn't linear
|
|
impl From<&mut AuraModes> for u8 {
|
|
fn from(mode: &mut AuraModes) -> Self {
|
|
u8::from(&*mode)
|
|
}
|
|
}
|
|
|
|
/// Very specific mode conversion required because numbering isn't linear
|
|
impl From<&AuraModes> for u8 {
|
|
fn from(mode: &AuraModes) -> Self {
|
|
match mode {
|
|
AuraModes::Static(_) => STATIC,
|
|
AuraModes::Breathe(_) => BREATHING,
|
|
AuraModes::Strobe(_) => STROBE,
|
|
AuraModes::Rainbow(_) => RAINBOW,
|
|
AuraModes::Star(_) => STAR,
|
|
AuraModes::Rain(_) => RAIN,
|
|
AuraModes::Highlight(_) => HIGHLIGHT,
|
|
AuraModes::Laser(_) => LASER,
|
|
AuraModes::Ripple(_) => RIPPLE,
|
|
AuraModes::Pulse(_) => PULSE,
|
|
AuraModes::Comet(_) => COMET,
|
|
AuraModes::Flash(_) => FLASH,
|
|
AuraModes::MultiStatic(_) => MULTISTATIC,
|
|
AuraModes::MultiBreathe(_) => MULTIBREATHE,
|
|
AuraModes::PerKey(_) => PER_KEY,
|
|
_ => panic!("Invalid mode"),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<&AuraModes> for &str {
|
|
fn from(mode: &AuraModes) -> Self {
|
|
match mode {
|
|
AuraModes::Static(_) => "Static",
|
|
AuraModes::Breathe(_) => "Breathing",
|
|
AuraModes::Strobe(_) => "Strobing",
|
|
AuraModes::Rainbow(_) => "Rainbow",
|
|
AuraModes::Star(_) => "Stars",
|
|
AuraModes::Rain(_) => "Rain",
|
|
AuraModes::Highlight(_) => "Keypress Highlight",
|
|
AuraModes::Laser(_) => "Keypress Laser",
|
|
AuraModes::Ripple(_) => "Keypress Ripple",
|
|
AuraModes::Pulse(_) => "Pulse",
|
|
AuraModes::Comet(_) => "Comet",
|
|
AuraModes::Flash(_) => "Flash",
|
|
AuraModes::MultiStatic(_) => "4-Zone Static Colours",
|
|
AuraModes::MultiBreathe(_) => "4-Zone Breathing Colours",
|
|
AuraModes::PerKey(_) => "RGB per-key",
|
|
_ => panic!("Invalid mode"),
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Exists to convert back from correct bytes. PER_KEY byte intentionally left off as it
|
|
/// does not correspond to an actual pre-set mode, nor does brightness.
|
|
impl From<u8> for AuraModes {
|
|
fn from(byte: u8) -> Self {
|
|
match byte {
|
|
STATIC => AuraModes::Static(SingleColour::default()),
|
|
BREATHING => AuraModes::Breathe(TwoColourSpeed::default()),
|
|
STROBE => AuraModes::Strobe(SingleSpeed::default()),
|
|
RAINBOW => AuraModes::Rainbow(SingleSpeedDirection::default()),
|
|
STAR => AuraModes::Star(TwoColourSpeed::default()),
|
|
RAIN => AuraModes::Rain(SingleSpeed::default()),
|
|
HIGHLIGHT => AuraModes::Highlight(SingleColourSpeed::default()),
|
|
LASER => AuraModes::Laser(SingleColourSpeed::default()),
|
|
RIPPLE => AuraModes::Ripple(SingleColourSpeed::default()),
|
|
PULSE => AuraModes::Pulse(SingleColour::default()),
|
|
COMET => AuraModes::Comet(SingleColour::default()),
|
|
FLASH => AuraModes::Flash(SingleColour::default()),
|
|
MULTISTATIC => AuraModes::MultiStatic(MultiColour::default()),
|
|
MULTIBREATHE => AuraModes::MultiBreathe(MultiColourSpeed::default()),
|
|
PER_KEY => AuraModes::PerKey(vec![]),
|
|
_ => panic!("Invalid mode byte"),
|
|
}
|
|
}
|
|
}
|